diff --git a/.editorconfig b/.editorconfig
index c28089d720..d6bd9e592d 100644
--- a/.editorconfig
+++ b/.editorconfig
@@ -104,8 +104,8 @@ dotnet_style_parentheses_in_relational_binary_operators = always_for_clarity:war
 dotnet_style_parentheses_in_other_binary_operators = always_for_clarity:warning
 dotnet_style_parentheses_in_other_operators = always_for_clarity:suggestion
 # Expression-level preferences
-dotnet_style_object_initializer = true:warning
-dotnet_style_collection_initializer = true:warning
+dotnet_style_object_initializer = true:error
+dotnet_style_collection_initializer = true:error
 dotnet_style_explicit_tuple_names = true:warning
 dotnet_style_prefer_inferred_tuple_names = true:warning
 dotnet_style_prefer_inferred_anonymous_type_member_names = true:warning
@@ -135,9 +135,9 @@ csharp_style_prefer_null_check_over_type_check = true:warning
 # https://docs.microsoft.com/dotnet/fundamentals/code-analysis/style-rules/language-rules#c-style-rules
 [*.{cs,csx,cake}]
 # 'var' preferences
-csharp_style_var_for_built_in_types = false:warning
-csharp_style_var_when_type_is_apparent = false:warning
-csharp_style_var_elsewhere = false:warning
+csharp_style_var_for_built_in_types = false:error
+csharp_style_var_when_type_is_apparent = false:error
+csharp_style_var_elsewhere = false:error
 # Expression-bodied members
 csharp_style_expression_bodied_methods = true:warning
 csharp_style_expression_bodied_constructors = true:warning
@@ -160,7 +160,10 @@ csharp_style_pattern_local_over_anonymous_function = true:warning
 csharp_style_deconstructed_variable_declaration = true:warning
 csharp_style_prefer_index_operator = true:warning
 csharp_style_prefer_range_operator = true:warning
-csharp_style_implicit_object_creation_when_type_is_apparent = true:warning
+csharp_style_implicit_object_creation_when_type_is_apparent = true:error
+# ReSharper inspection severities
+resharper_arrange_object_creation_when_type_evident_highlighting = error
+resharper_arrange_object_creation_when_type_not_evident_highlighting = error
 # "Null" checking preferences
 csharp_style_throw_expression = true:warning
 csharp_style_conditional_delegate_call = true:warning
@@ -174,6 +177,11 @@ csharp_using_directive_placement = outside_namespace:warning
 csharp_prefer_static_local_function = true:warning
 # Primary constructor preferences
 csharp_style_prefer_primary_constructors = false:none
+# Collection preferences
+dotnet_style_prefer_collection_expression = true:error
+resharper_use_collection_expression_highlighting =true:error
+
+
 
 ##########################################
 # Unnecessary Code Rules
diff --git a/.gitattributes b/.gitattributes
index 1ab893e0a8..f7bd4d061e 100644
--- a/.gitattributes
+++ b/.gitattributes
@@ -139,3 +139,7 @@
 *.heic              filter=lfs diff=lfs merge=lfs -text
 *.hif               filter=lfs diff=lfs merge=lfs -text
 *.avif              filter=lfs diff=lfs merge=lfs -text
+###############################################################################
+# Handle ICC files by git lfs
+###############################################################################
+*.icc               filter=lfs diff=lfs merge=lfs -text
diff --git a/.github/workflows/build-and-test.yml b/.github/workflows/build-and-test.yml
index 5900a531b7..e00757cb7b 100644
--- a/.github/workflows/build-and-test.yml
+++ b/.github/workflows/build-and-test.yml
@@ -12,8 +12,54 @@ on:
       - main
       - release/*
     types: [ labeled, opened, synchronize, reopened ]
+
 jobs:
+  # Prime a single LFS cache and expose the exact key for the matrix
+  WarmLFS:
+    runs-on: ubuntu-latest
+    outputs:
+      lfs_key: ${{ steps.expose-key.outputs.lfs_key }}
+    steps:
+      - name: Git Config
+        shell: bash
+        run: |
+          git config --global core.autocrlf false
+          git config --global core.longpaths true
+
+      - name: Git Checkout
+        uses: actions/checkout@v4
+        with:
+          fetch-depth: 0
+          submodules: recursive
+
+      # Deterministic list of LFS object IDs, then compute a portable key:
+      # - `git lfs ls-files -l` lists all tracked LFS objects with their SHA-256
+      # - `awk '{print $1}'` extracts just the SHA field
+      # - `sort` sorts in byte order (hex hashes sort the same everywhere)
+      # This ensures the file content is identical regardless of OS or locale
+      - name: Git Create LFS id list
+        shell: bash
+        run: git lfs ls-files -l | awk '{print $1}' | sort > .lfs-assets-id
+
+      - name: Git Expose LFS cache key
+        id: expose-key
+        shell: bash
+        env:
+          LFS_KEY: lfs-${{ hashFiles('.lfs-assets-id') }}-v1
+        run: echo "lfs_key=$LFS_KEY" >> "$GITHUB_OUTPUT"
+
+      - name: Git Setup LFS Cache
+        uses: actions/cache@v4
+        with:
+          path: .git/lfs
+          key: ${{ steps.expose-key.outputs.lfs_key }}
+
+      - name: Git Pull LFS
+        shell: bash
+        run: git lfs pull
+
   Build:
+    needs: WarmLFS
     strategy:
       matrix:
         isARM:
@@ -69,12 +115,14 @@ jobs:
             options:
               os: buildjet-4vcpu-ubuntu-2204-arm
 
-    runs-on: ${{matrix.options.os}}
+    runs-on: ${{ matrix.options.os }}
 
     steps:
       - name: Install libgdi+, which is required for tests running on ubuntu
         if: ${{ contains(matrix.options.os, 'ubuntu') }}
-        run: sudo apt-get -y install libgdiplus libgif-dev libglib2.0-dev libcairo2-dev libtiff-dev libexif-dev
+        run: |
+          sudo apt-get update
+          sudo apt-get -y install libgdiplus libgif-dev libglib2.0-dev libcairo2-dev libtiff-dev libexif-dev
 
       - name: Git Config
         shell: bash
@@ -88,18 +136,15 @@ jobs:
           fetch-depth: 0
           submodules: recursive
 
-      # See https://github.com/actions/checkout/issues/165#issuecomment-657673315
-      - name: Git Create LFS FileList
-        run: git lfs ls-files -l | cut -d' ' -f1 | sort > .lfs-assets-id
-
+      # Use the warmed key from WarmLFS. Do not recompute or recreate .lfs-assets-id here.
       - name: Git Setup LFS Cache
         uses: actions/cache@v4
-        id: lfs-cache
         with:
           path: .git/lfs
-          key: ${{ runner.os }}-lfs-${{ hashFiles('.lfs-assets-id') }}-v1
+          key: ${{ needs.WarmLFS.outputs.lfs_key }}
 
       - name: Git Pull LFS
+        shell: bash
         run: git lfs pull
 
       - name: NuGet Install
@@ -166,11 +211,8 @@ jobs:
 
   Publish:
     needs: [Build]
-
     runs-on: ubuntu-latest
-
     if: (github.event_name == 'push')
-
     steps:
       - name: Git Config
         shell: bash
@@ -211,4 +253,3 @@ jobs:
         run: |
           dotnet nuget push .\artifacts\*.nupkg -k ${{secrets.NUGET_TOKEN}} -s https://api.nuget.org/v3/index.json --skip-duplicate
           dotnet nuget push .\artifacts\*.snupkg -k ${{secrets.NUGET_TOKEN}} -s https://api.nuget.org/v3/index.json --skip-duplicate
-
diff --git a/.github/workflows/code-coverage.yml b/.github/workflows/code-coverage.yml
index 30cb9d0f51..a7278a8175 100644
--- a/.github/workflows/code-coverage.yml
+++ b/.github/workflows/code-coverage.yml
@@ -4,6 +4,7 @@ on:
   schedule:
     # 2AM every Tuesday/Thursday
     - cron: "0 2 * * 2,4"
+
 jobs:
   Build:
     strategy:
@@ -14,13 +15,14 @@ jobs:
             runtime: -x64
             codecov: true
 
-    runs-on: ${{matrix.options.os}}
+    runs-on: ${{ matrix.options.os }}
 
     steps:
-
       - name: Install libgdi+, which is required for tests running on ubuntu
         if: ${{ contains(matrix.options.os, 'ubuntu') }}
-        run: sudo apt-get -y install libgdiplus libgif-dev libglib2.0-dev libcairo2-dev libtiff-dev libexif-dev
+        run: |
+          sudo apt-get update
+          sudo apt-get -y install libgdiplus libgif-dev libglib2.0-dev libcairo2-dev libtiff-dev libexif-dev
 
       - name: Git Config
         shell: bash
@@ -34,16 +36,21 @@ jobs:
           fetch-depth: 0
           submodules: recursive
 
-      # See https://github.com/actions/checkout/issues/165#issuecomment-657673315
-      - name: Git Create LFS FileList
-        run: git lfs ls-files -l | cut -d' ' -f1 | sort > .lfs-assets-id
+      # Deterministic list of LFS object IDs, then compute a portable key:
+      # - `git lfs ls-files -l` lists all tracked LFS objects with their SHA-256
+      # - `awk '{print $1}'` extracts just the SHA field
+      # - `sort` sorts in byte order (hex hashes sort the same everywhere)
+      # This ensures the file content is identical regardless of OS or locale
+      - name: Git Create LFS id list
+        shell: bash
+        run: git lfs ls-files -l | awk '{print $1}' | sort > .lfs-assets-id
 
       - name: Git Setup LFS Cache
         uses: actions/cache@v4
         id: lfs-cache
         with:
           path: .git/lfs
-          key: ${{ runner.os }}-lfs-${{ hashFiles('.lfs-assets-id') }}-v1
+          key: lfs-${{ hashFiles('.lfs-assets-id') }}-v1
 
       - name: Git Pull LFS
         run: git lfs pull
@@ -67,13 +74,13 @@ jobs:
 
       - name: DotNet Build
         shell: pwsh
-        run: ./ci-build.ps1 "${{matrix.options.framework}}"
+        run: ./ci-build.ps1 "${{ matrix.options.framework }}"
         env:
           SIXLABORS_TESTING: True
 
       - name: DotNet Test
         shell: pwsh
-        run: ./ci-test.ps1 "${{matrix.options.os}}" "${{matrix.options.framework}}" "${{matrix.options.runtime}}" "${{matrix.options.codecov}}"
+        run: ./ci-test.ps1 "${{ matrix.options.os }}" "${{ matrix.options.framework }}" "${{ matrix.options.runtime }}" "${{ matrix.options.codecov }}"
         env:
           SIXLABORS_TESTING: True
           XUNIT_PATH: .\tests\ImageSharp.Tests # Required for xunit
diff --git a/Directory.Build.props b/Directory.Build.props
index 26b3cc5afc..755cbe3b30 100644
--- a/Directory.Build.props
+++ b/Directory.Build.props
@@ -21,9 +21,8 @@
   <!-- Import the shared global .props file -->
   <Import Project="$(MSBuildThisFileDirectory)shared-infrastructure\msbuild\props\SixLabors.Global.props" />
 
-  <PropertyGroup Condition="$(SIXLABORS_TESTING_PREVIEW) == true">
-    <!-- Workaround various issues bound to implicit language features. -->
-    <LangVersion>preview</LangVersion>
+  <PropertyGroup>
+    <LangVersion>12.0</LangVersion>
   </PropertyGroup>
 
   <!--
diff --git a/shared-infrastructure b/shared-infrastructure
index 922c5b21e5..d0f141bad2 160000
--- a/shared-infrastructure
+++ b/shared-infrastructure
@@ -1 +1 @@
-Subproject commit 922c5b21e5dfa02d4ef0d95334ab01c87a7a4309
+Subproject commit d0f141bad2baf7e256aa38ef18129c31cfb857a5
diff --git a/src/ImageSharp/Advanced/AotCompilerTools.cs b/src/ImageSharp/Advanced/AotCompilerTools.cs
index 0d5faabe18..fef49bffd4 100644
--- a/src/ImageSharp/Advanced/AotCompilerTools.cs
+++ b/src/ImageSharp/Advanced/AotCompilerTools.cs
@@ -138,10 +138,11 @@ internal static class AotCompilerTools
         AotCompileResamplers<TPixel>();
         AotCompileQuantizers<TPixel>();
         AotCompilePixelSamplingStrategys<TPixel>();
+        AotCompilePixelMaps<TPixel>();
         AotCompileDithers<TPixel>();
         AotCompileMemoryManagers<TPixel>();
 
-        Unsafe.SizeOf<TPixel>();
+        _ = Unsafe.SizeOf<TPixel>();
 
         // TODO: Do the discovery work to figure out what works and what doesn't.
     }
@@ -276,11 +277,11 @@ internal static class AotCompilerTools
     private static void AotCompileSpectralConverter<TPixel>()
         where TPixel : unmanaged, IPixel<TPixel>
     {
-        default(SpectralConverter<TPixel>).GetPixelBuffer(default);
-        default(GrayJpegSpectralConverter<TPixel>).GetPixelBuffer(default);
-        default(RgbJpegSpectralConverter<TPixel>).GetPixelBuffer(default);
-        default(TiffJpegSpectralConverter<TPixel>).GetPixelBuffer(default);
-        default(TiffOldJpegSpectralConverter<TPixel>).GetPixelBuffer(default);
+        default(SpectralConverter<TPixel>).GetPixelBuffer(default, default);
+        default(GrayJpegSpectralConverter<TPixel>).GetPixelBuffer(default, default);
+        default(RgbJpegSpectralConverter<TPixel>).GetPixelBuffer(default, default);
+        default(TiffJpegSpectralConverter<TPixel>).GetPixelBuffer(default, default);
+        default(TiffOldJpegSpectralConverter<TPixel>).GetPixelBuffer(default, default);
     }
 
     /// <summary>
@@ -514,6 +515,20 @@ internal static class AotCompilerTools
         default(ExtensivePixelSamplingStrategy).EnumeratePixelRegions(default(ImageFrame<TPixel>));
     }
 
+    /// <summary>
+    /// This method pre-seeds the all <see cref="IColorIndexCache{T}" /> in the AoT compiler.
+    /// </summary>
+    /// <typeparam name="TPixel">The pixel format.</typeparam>
+    [Preserve]
+    private static void AotCompilePixelMaps<TPixel>()
+        where TPixel : unmanaged, IPixel<TPixel>
+    {
+        default(EuclideanPixelMap<TPixel, HybridCache>).GetClosestColor(default, out _);
+        default(EuclideanPixelMap<TPixel, AccurateCache>).GetClosestColor(default, out _);
+        default(EuclideanPixelMap<TPixel, CoarseCache>).GetClosestColor(default, out _);
+        default(EuclideanPixelMap<TPixel, NullCache>).GetClosestColor(default, out _);
+    }
+
     /// <summary>
     /// This method pre-seeds the all <see cref="IDither" /> in the AoT compiler.
     /// </summary>
diff --git a/src/ImageSharp/Advanced/ParallelRowIterator.Wrappers.cs b/src/ImageSharp/Advanced/ParallelRowIterator.Wrappers.cs
index a959faa3b6..cbcd12aec2 100644
--- a/src/ImageSharp/Advanced/ParallelRowIterator.Wrappers.cs
+++ b/src/ImageSharp/Advanced/ParallelRowIterator.Wrappers.cs
@@ -139,7 +139,7 @@ public static partial class ParallelRowIterator
             }
 
             int yMax = Math.Min(yMin + this.stepY, this.maxY);
-            var rows = new RowInterval(yMin, yMax);
+            RowInterval rows = new(yMin, yMax);
 
             // Skip the safety copy when invoking a potentially impure method on a readonly field
             Unsafe.AsRef(in this.operation).Invoke(in rows);
@@ -185,7 +185,7 @@ public static partial class ParallelRowIterator
             }
 
             int yMax = Math.Min(yMin + this.stepY, this.maxY);
-            var rows = new RowInterval(yMin, yMax);
+            RowInterval rows = new(yMin, yMax);
 
             using IMemoryOwner<TBuffer> buffer = this.allocator.Allocate<TBuffer>(this.bufferLength);
 
diff --git a/src/ImageSharp/Advanced/ParallelRowIterator.cs b/src/ImageSharp/Advanced/ParallelRowIterator.cs
index 1284a3a898..b878f9ec0a 100644
--- a/src/ImageSharp/Advanced/ParallelRowIterator.cs
+++ b/src/ImageSharp/Advanced/ParallelRowIterator.cs
@@ -26,7 +26,7 @@ public static partial class ParallelRowIterator
     public static void IterateRows<T>(Configuration configuration, Rectangle rectangle, in T operation)
         where T : struct, IRowOperation
     {
-        var parallelSettings = ParallelExecutionSettings.FromConfiguration(configuration);
+        ParallelExecutionSettings parallelSettings = ParallelExecutionSettings.FromConfiguration(configuration);
         IterateRows(rectangle, in parallelSettings, in operation);
     }
 
@@ -65,8 +65,8 @@ public static partial class ParallelRowIterator
         }
 
         int verticalStep = DivideCeil(rectangle.Height, numOfSteps);
-        var parallelOptions = new ParallelOptions { MaxDegreeOfParallelism = numOfSteps };
-        var wrappingOperation = new RowOperationWrapper<T>(top, bottom, verticalStep, in operation);
+        ParallelOptions parallelOptions = new() { MaxDegreeOfParallelism = numOfSteps };
+        RowOperationWrapper<T> wrappingOperation = new(top, bottom, verticalStep, in operation);
 
         Parallel.For(
             0,
@@ -88,7 +88,7 @@ public static partial class ParallelRowIterator
         where T : struct, IRowOperation<TBuffer>
         where TBuffer : unmanaged
     {
-        var parallelSettings = ParallelExecutionSettings.FromConfiguration(configuration);
+        ParallelExecutionSettings parallelSettings = ParallelExecutionSettings.FromConfiguration(configuration);
         IterateRows<T, TBuffer>(rectangle, in parallelSettings, in operation);
     }
 
@@ -135,8 +135,8 @@ public static partial class ParallelRowIterator
         }
 
         int verticalStep = DivideCeil(height, numOfSteps);
-        var parallelOptions = new ParallelOptions { MaxDegreeOfParallelism = numOfSteps };
-        var wrappingOperation = new RowOperationWrapper<T, TBuffer>(top, bottom, verticalStep, bufferLength, allocator, in operation);
+        ParallelOptions parallelOptions = new() { MaxDegreeOfParallelism = numOfSteps };
+        RowOperationWrapper<T, TBuffer> wrappingOperation = new(top, bottom, verticalStep, bufferLength, allocator, in operation);
 
         Parallel.For(
             0,
@@ -156,7 +156,7 @@ public static partial class ParallelRowIterator
     public static void IterateRowIntervals<T>(Configuration configuration, Rectangle rectangle, in T operation)
         where T : struct, IRowIntervalOperation
     {
-        var parallelSettings = ParallelExecutionSettings.FromConfiguration(configuration);
+        ParallelExecutionSettings parallelSettings = ParallelExecutionSettings.FromConfiguration(configuration);
         IterateRowIntervals(rectangle, in parallelSettings, in operation);
     }
 
@@ -186,14 +186,14 @@ public static partial class ParallelRowIterator
         // Avoid TPL overhead in this trivial case:
         if (numOfSteps == 1)
         {
-            var rows = new RowInterval(top, bottom);
+            RowInterval rows = new(top, bottom);
             Unsafe.AsRef(in operation).Invoke(in rows);
             return;
         }
 
         int verticalStep = DivideCeil(rectangle.Height, numOfSteps);
-        var parallelOptions = new ParallelOptions { MaxDegreeOfParallelism = numOfSteps };
-        var wrappingOperation = new RowIntervalOperationWrapper<T>(top, bottom, verticalStep, in operation);
+        ParallelOptions parallelOptions = new() { MaxDegreeOfParallelism = numOfSteps };
+        RowIntervalOperationWrapper<T> wrappingOperation = new(top, bottom, verticalStep, in operation);
 
         Parallel.For(
             0,
@@ -215,7 +215,7 @@ public static partial class ParallelRowIterator
         where T : struct, IRowIntervalOperation<TBuffer>
         where TBuffer : unmanaged
     {
-        var parallelSettings = ParallelExecutionSettings.FromConfiguration(configuration);
+        ParallelExecutionSettings parallelSettings = ParallelExecutionSettings.FromConfiguration(configuration);
         IterateRowIntervals<T, TBuffer>(rectangle, in parallelSettings, in operation);
     }
 
@@ -250,7 +250,7 @@ public static partial class ParallelRowIterator
         // Avoid TPL overhead in this trivial case:
         if (numOfSteps == 1)
         {
-            var rows = new RowInterval(top, bottom);
+            RowInterval rows = new(top, bottom);
             using IMemoryOwner<TBuffer> buffer = allocator.Allocate<TBuffer>(bufferLength);
 
             Unsafe.AsRef(in operation).Invoke(in rows, buffer.Memory.Span);
@@ -259,8 +259,8 @@ public static partial class ParallelRowIterator
         }
 
         int verticalStep = DivideCeil(height, numOfSteps);
-        var parallelOptions = new ParallelOptions { MaxDegreeOfParallelism = numOfSteps };
-        var wrappingOperation = new RowIntervalOperationWrapper<T, TBuffer>(top, bottom, verticalStep, bufferLength, allocator, in operation);
+        ParallelOptions parallelOptions = new() { MaxDegreeOfParallelism = numOfSteps };
+        RowIntervalOperationWrapper<T, TBuffer> wrappingOperation = new(top, bottom, verticalStep, bufferLength, allocator, in operation);
 
         Parallel.For(
             0,
diff --git a/src/ImageSharp/Color/Color.WebSafePalette.cs b/src/ImageSharp/Color/Color.WebSafePalette.cs
index feb4a8659d..bd17d9a76c 100644
--- a/src/ImageSharp/Color/Color.WebSafePalette.cs
+++ b/src/ImageSharp/Color/Color.WebSafePalette.cs
@@ -8,15 +8,15 @@ namespace SixLabors.ImageSharp;
 /// </content>
 public partial struct Color
 {
-    private static readonly Lazy<Color[]> WebSafePaletteLazy = new Lazy<Color[]>(CreateWebSafePalette, true);
+    private static readonly Lazy<Color[]> WebSafePaletteLazy = new(CreateWebSafePalette, true);
 
     /// <summary>
     /// Gets a collection of named, web safe colors as defined in the CSS Color Module Level 4.
     /// </summary>
     public static ReadOnlyMemory<Color> WebSafePalette => WebSafePaletteLazy.Value;
 
-    private static Color[] CreateWebSafePalette() => new[]
-    {
+    private static Color[] CreateWebSafePalette() =>
+    [
         AliceBlue,
         AntiqueWhite,
         Aqua,
@@ -159,5 +159,5 @@ public partial struct Color
         WhiteSmoke,
         Yellow,
         YellowGreen
-    };
+    ];
 }
diff --git a/src/ImageSharp/Color/Color.WernerPalette.cs b/src/ImageSharp/Color/Color.WernerPalette.cs
index 1058da6547..583c71379f 100644
--- a/src/ImageSharp/Color/Color.WernerPalette.cs
+++ b/src/ImageSharp/Color/Color.WernerPalette.cs
@@ -8,7 +8,7 @@ namespace SixLabors.ImageSharp;
 /// </content>
 public partial struct Color
 {
-    private static readonly Lazy<Color[]> WernerPaletteLazy = new Lazy<Color[]>(CreateWernerPalette, true);
+    private static readonly Lazy<Color[]> WernerPaletteLazy = new(CreateWernerPalette, true);
 
     /// <summary>
     /// Gets a collection of colors as defined in the original second edition of Werner’s Nomenclature of Colours 1821.
@@ -16,8 +16,8 @@ public partial struct Color
     /// </summary>
     public static ReadOnlyMemory<Color> WernerPalette => WernerPaletteLazy.Value;
 
-    private static Color[] CreateWernerPalette() => new[]
-    {
+    private static Color[] CreateWernerPalette() =>
+    [
         ParseHex("#f1e9cd"),
         ParseHex("#f2e7cf"),
         ParseHex("#ece6d0"),
@@ -128,5 +128,5 @@ public partial struct Color
         ParseHex("#9b856b"),
         ParseHex("#766051"),
         ParseHex("#453b32")
-    };
+    ];
 }
diff --git a/src/ImageSharp/Color/Color.cs b/src/ImageSharp/Color/Color.cs
index 8f54680ec4..bb78dcbbc3 100644
--- a/src/ImageSharp/Color/Color.cs
+++ b/src/ImageSharp/Color/Color.cs
@@ -1,6 +1,7 @@
 // Copyright (c) Six Labors.
 // Licensed under the Six Labors Split License.
 
+using System.Globalization;
 using System.Numerics;
 using System.Runtime.CompilerServices;
 using SixLabors.ImageSharp.PixelFormats;
@@ -81,10 +82,10 @@ public readonly partial struct Color : IEquatable<Color>
         PixelTypeInfo info = TPixel.GetPixelTypeInfo();
         if (info.ComponentInfo.HasValue && info.ComponentInfo.Value.GetMaximumComponentPrecision() <= (int)PixelComponentBitDepth.Bit32)
         {
-            return new(source.ToScaledVector4());
+            return new Color(source.ToScaledVector4());
         }
 
-        return new(source);
+        return new Color(source);
     }
 
     /// <summary>
@@ -120,72 +121,97 @@ public readonly partial struct Color : IEquatable<Color>
         {
             for (int i = 0; i < destination.Length; i++)
             {
-                destination[i] = new(source[i]);
+                destination[i] = new Color(source[i]);
             }
         }
     }
 
     /// <summary>
-    /// Creates a new instance of the <see cref="Color"/> struct
-    /// from the given hexadecimal string.
+    /// Gets a <see cref="Color"/> from the given hexadecimal string.
     /// </summary>
     /// <param name="hex">
-    /// The hexadecimal representation of the combined color components arranged
-    /// in rgb, rgba, rrggbb, or rrggbbaa format to match web syntax.
+    /// The hexadecimal representation of the combined color components.
+    /// </param>
+    /// <param name="format">
+    /// The format of the hexadecimal string to parse, if applicable. Defaults to <see cref="ColorHexFormat.Rgba"/>.
     /// </param>
     /// <returns>
-    /// The <see cref="Color"/>.
+    /// The <see cref="Color"/> equivalent of the hexadecimal input.
     /// </returns>
-    [MethodImpl(MethodImplOptions.AggressiveInlining)]
-    public static Color ParseHex(string hex)
+    /// <exception cref="ArgumentException">
+    /// Thrown when the <paramref name="hex"/> is not in the correct format.
+    /// </exception>
+    public static Color ParseHex(string hex, ColorHexFormat format = ColorHexFormat.Rgba)
     {
-        Rgba32 rgba = Rgba32.ParseHex(hex);
-        return FromPixel(rgba);
+        Guard.NotNull(hex, nameof(hex));
+
+        if (!TryParseHex(hex, out Color color, format))
+        {
+            throw new ArgumentException("Hexadecimal string is not in the correct format.", nameof(hex));
+        }
+
+        return color;
     }
 
     /// <summary>
-    /// Attempts to creates a new instance of the <see cref="Color"/> struct
-    /// from the given hexadecimal string.
+    /// Gets a <see cref="Color"/> from the given hexadecimal string.
     /// </summary>
     /// <param name="hex">
-    /// The hexadecimal representation of the combined color components arranged
-    /// in rgb, rgba, rrggbb, or rrggbbaa format to match web syntax.
+    /// The hexadecimal representation of the combined color components.
+    /// </param>
+    /// <param name="result">
+    /// When this method returns, contains the <see cref="Color"/> equivalent of the hexadecimal input.
+    /// </param>
+    /// <param name="format">
+    /// The format of the hexadecimal string to parse, if applicable. Defaults to <see cref="ColorHexFormat.Rgba"/>.
     /// </param>
-    /// <param name="result">When this method returns, contains the <see cref="Color"/> equivalent of the hexadecimal input.</param>
     /// <returns>
-    /// The <see cref="bool"/>.
+    /// <see langword="true"/> if the parsing was successful; otherwise, <see langword="false"/>.
     /// </returns>
-    [MethodImpl(MethodImplOptions.AggressiveInlining)]
-    public static bool TryParseHex(string hex, out Color result)
+    public static bool TryParseHex(string hex, out Color result, ColorHexFormat format = ColorHexFormat.Rgba)
     {
         result = default;
 
-        if (Rgba32.TryParseHex(hex, out Rgba32 rgba))
+        if (format == ColorHexFormat.Argb)
         {
-            result = FromPixel(rgba);
-            return true;
+            if (TryParseArgbHex(hex, out Argb32 argb))
+            {
+                result = FromPixel(argb);
+                return true;
+            }
+        }
+        else if (format == ColorHexFormat.Rgba)
+        {
+            if (TryParseRgbaHex(hex, out Rgba32 rgba))
+            {
+                result = FromPixel(rgba);
+                return true;
+            }
         }
 
         return false;
     }
 
     /// <summary>
-    /// Creates a new instance of the <see cref="Color"/> struct
-    /// from the given input string.
+    /// Gets a <see cref="Color"/> from the given input string.
     /// </summary>
     /// <param name="input">
-    /// The name of the color or the hexadecimal representation of the combined color components arranged
-    /// in rgb, rgba, rrggbb, or rrggbbaa format to match web syntax.
+    /// The name of the color or the hexadecimal representation of the combined color components.
+    /// </param>
+    /// <param name="format">
+    /// The format of the hexadecimal string to parse, if applicable. Defaults to <see cref="ColorHexFormat.Rgba"/>.
     /// </param>
     /// <returns>
-    /// The <see cref="Color"/>.
+    /// The <see cref="Color"/> equivalent of the input string.
     /// </returns>
-    /// <exception cref="ArgumentException">Input string is not in the correct format.</exception>
-    public static Color Parse(string input)
+    /// <exception cref="ArgumentException">
+    /// Thrown when the <paramref name="input"/> is not in the correct format.
+    /// </exception>
+    public static Color Parse(string input, ColorHexFormat format = ColorHexFormat.Rgba)
     {
         Guard.NotNull(input, nameof(input));
 
-        if (!TryParse(input, out Color color))
+        if (!TryParse(input, out Color color, format))
         {
             throw new ArgumentException("Input string is not in the correct format.", nameof(input));
         }
@@ -194,18 +220,21 @@ public readonly partial struct Color : IEquatable<Color>
     }
 
     /// <summary>
-    /// Attempts to creates a new instance of the <see cref="Color"/> struct
-    /// from the given input string.
+    /// Tries to create a new instance of the <see cref="Color"/> struct from the given input string.
     /// </summary>
     /// <param name="input">
-    /// The name of the color or the hexadecimal representation of the combined color components arranged
-    /// in rgb, rgba, rrggbb, or rrggbbaa format to match web syntax.
+    /// The name of the color or the hexadecimal representation of the combined color components.
+    /// </param>
+    /// <param name="result">
+    /// When this method returns, contains the <see cref="Color"/> equivalent of the input string.
+    /// </param>
+    /// <param name="format">
+    /// The format of the hexadecimal string to parse, if applicable. Defaults to <see cref="ColorHexFormat.Rgba"/>.
     /// </param>
-    /// <param name="result">When this method returns, contains the <see cref="Color"/> equivalent of the hexadecimal input.</param>
     /// <returns>
-    /// The <see cref="bool"/>.
+    /// <see langword="true"/> if the parsing was successful; otherwise, <see langword="false"/>.
     /// </returns>
-    public static bool TryParse(string input, out Color result)
+    public static bool TryParse(string input, out Color result, ColorHexFormat format = ColorHexFormat.Rgba)
     {
         result = default;
 
@@ -219,7 +248,13 @@ public readonly partial struct Color : IEquatable<Color>
             return true;
         }
 
-        return TryParseHex(input, out result);
+        result = default;
+        if (string.IsNullOrWhiteSpace(input))
+        {
+            return false;
+        }
+
+        return TryParseHex(input, out result, format);
     }
 
     /// <summary>
@@ -227,6 +262,7 @@ public readonly partial struct Color : IEquatable<Color>
     /// </summary>
     /// <param name="alpha">The new value of alpha [0..1].</param>
     /// <returns>The color having it's alpha channel altered.</returns>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
     public Color WithAlpha(float alpha)
     {
         Vector4 v = this.ToScaledVector4();
@@ -235,22 +271,32 @@ public readonly partial struct Color : IEquatable<Color>
     }
 
     /// <summary>
-    /// Gets the hexadecimal representation of the color instance in rrggbbaa form.
+    /// Gets the hexadecimal string representation of the color instance.
     /// </summary>
+    /// <param name="format">
+    /// The format of the hexadecimal string to return. Defaults to <see cref="ColorHexFormat.Rgba"/>.
+    /// </param>
     /// <returns>A hexadecimal string representation of the value.</returns>
+    /// <exception cref="ArgumentOutOfRangeException">Thrown when the <paramref name="format"/> is not supported.</exception>
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
-    public string ToHex()
+    public string ToHex(ColorHexFormat format = ColorHexFormat.Rgba)
     {
-        if (this.boxedHighPrecisionPixel is not null)
+        Rgba32 rgba = (this.boxedHighPrecisionPixel is not null)
+            ? this.boxedHighPrecisionPixel.ToRgba32()
+            : Rgba32.FromScaledVector4(this.data);
+
+        uint hexOrder = format switch
         {
-            return this.boxedHighPrecisionPixel.ToRgba32().ToHex();
-        }
+            ColorHexFormat.Argb => (uint)((rgba.B << 0) | (rgba.G << 8) | (rgba.R << 16) | (rgba.A << 24)),
+            ColorHexFormat.Rgba => (uint)((rgba.A << 0) | (rgba.B << 8) | (rgba.G << 16) | (rgba.R << 24)),
+            _ => throw new ArgumentOutOfRangeException(nameof(format), format, "Unsupported color hex format.")
+        };
 
-        return Rgba32.FromScaledVector4(this.data).ToHex();
+        return hexOrder.ToString("X8", CultureInfo.InvariantCulture);
     }
 
     /// <inheritdoc />
-    public override string ToString() => this.ToHex();
+    public override string ToString() => this.ToHex(ColorHexFormat.Rgba);
 
     /// <summary>
     /// Converts the color instance to a specified <typeparamref name="TPixel"/> type.
@@ -336,4 +382,241 @@ public readonly partial struct Color : IEquatable<Color>
 
         return this.boxedHighPrecisionPixel.GetHashCode();
     }
+
+    /// <summary>
+    /// Gets the hexadecimal string representation of the color instance in the format RRGGBBAA.
+    /// </summary>
+    /// <param name="hex">
+    /// The hexadecimal representation of the combined color components.
+    /// </param>
+    /// <param name="result">
+    /// When this method returns, contains the <see cref="Rgba32"/> equivalent of the hexadecimal input.
+    /// </param>
+    /// <returns>
+    /// <see langword="true"/> if the parsing was successful; otherwise, <see langword="false"/>.
+    /// </returns>
+    private static bool TryParseRgbaHex(string? hex, out Rgba32 result)
+    {
+        result = default;
+
+        if (!TryConvertToRgbaUInt32(hex, out uint packedValue))
+        {
+            return false;
+        }
+
+        result = Unsafe.As<uint, Rgba32>(ref packedValue);
+        return true;
+    }
+
+    /// <summary>
+    /// Gets the hexadecimal string representation of the color instance in the format AARRGGBB.
+    /// </summary>
+    /// <param name="hex">
+    /// The hexadecimal representation of the combined color components.
+    /// </param>
+    /// <param name="result">
+    /// When this method returns, contains the <see cref="Argb32"/> equivalent of the hexadecimal input.
+    /// </param>
+    /// <returns>
+    /// <see langword="true"/> if the parsing was successful; otherwise, <see langword="false"/>.
+    /// </returns>
+    private static bool TryParseArgbHex(string? hex, out Argb32 result)
+    {
+        result = default;
+
+        if (!TryConvertToArgbUInt32(hex, out uint packedValue))
+        {
+            return false;
+        }
+
+        result = Unsafe.As<uint, Argb32>(ref packedValue);
+        return true;
+    }
+
+    private static bool TryConvertToRgbaUInt32(string? value, out uint result)
+    {
+        result = default;
+
+        if (string.IsNullOrWhiteSpace(value))
+        {
+            return false;
+        }
+
+        ReadOnlySpan<char> hex = value.AsSpan();
+
+        if (hex[0] == '#')
+        {
+            hex = hex[1..];
+        }
+
+        byte a = 255, r, g, b;
+
+        switch (hex.Length)
+        {
+            case 8:
+                if (!TryParseByte(hex[0], hex[1], out r) ||
+                    !TryParseByte(hex[2], hex[3], out g) ||
+                    !TryParseByte(hex[4], hex[5], out b) ||
+                    !TryParseByte(hex[6], hex[7], out a))
+                {
+                    return false;
+                }
+
+                break;
+
+            case 6:
+                if (!TryParseByte(hex[0], hex[1], out r) ||
+                    !TryParseByte(hex[2], hex[3], out g) ||
+                    !TryParseByte(hex[4], hex[5], out b))
+                {
+                    return false;
+                }
+
+                break;
+
+            case 4:
+                if (!TryExpand(hex[0], out r) ||
+                    !TryExpand(hex[1], out g) ||
+                    !TryExpand(hex[2], out b) ||
+                    !TryExpand(hex[3], out a))
+                {
+                    return false;
+                }
+
+                break;
+
+            case 3:
+                if (!TryExpand(hex[0], out r) ||
+                    !TryExpand(hex[1], out g) ||
+                    !TryExpand(hex[2], out b))
+                {
+                    return false;
+                }
+
+                break;
+
+            default:
+                return false;
+        }
+
+        result = (uint)(r | (g << 8) | (b << 16) | (a << 24)); // RGBA layout
+        return true;
+    }
+
+    private static bool TryConvertToArgbUInt32(string? value, out uint result)
+    {
+        result = default;
+
+        if (string.IsNullOrWhiteSpace(value))
+        {
+            return false;
+        }
+
+        ReadOnlySpan<char> hex = value.AsSpan();
+
+        if (hex[0] == '#')
+        {
+            hex = hex[1..];
+        }
+
+        byte a = 255, r, g, b;
+
+        switch (hex.Length)
+        {
+            case 8:
+                if (!TryParseByte(hex[0], hex[1], out a) ||
+                    !TryParseByte(hex[2], hex[3], out r) ||
+                    !TryParseByte(hex[4], hex[5], out g) ||
+                    !TryParseByte(hex[6], hex[7], out b))
+                {
+                    return false;
+                }
+
+                break;
+
+            case 6:
+                if (!TryParseByte(hex[0], hex[1], out r) ||
+                    !TryParseByte(hex[2], hex[3], out g) ||
+                    !TryParseByte(hex[4], hex[5], out b))
+                {
+                    return false;
+                }
+
+                break;
+
+            case 4:
+                if (!TryExpand(hex[0], out a) ||
+                    !TryExpand(hex[1], out r) ||
+                    !TryExpand(hex[2], out g) ||
+                    !TryExpand(hex[3], out b))
+                {
+                    return false;
+                }
+
+                break;
+
+            case 3:
+                if (!TryExpand(hex[0], out r) ||
+                    !TryExpand(hex[1], out g) ||
+                    !TryExpand(hex[2], out b))
+                {
+                    return false;
+                }
+
+                break;
+
+            default:
+                return false;
+        }
+
+        result = (uint)((b << 24) | (g << 16) | (r << 8) | a);
+        return true;
+    }
+
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    private static bool TryParseByte(char hi, char lo, out byte value)
+    {
+        if (TryConvertHexCharToByte(hi, out byte high) && TryConvertHexCharToByte(lo, out byte low))
+        {
+            value = (byte)((high << 4) | low);
+            return true;
+        }
+
+        value = 0;
+        return false;
+    }
+
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    private static bool TryExpand(char c, out byte value)
+    {
+        if (TryConvertHexCharToByte(c, out byte nibble))
+        {
+            value = (byte)((nibble << 4) | nibble);
+            return true;
+        }
+
+        value = 0;
+        return false;
+    }
+
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    private static bool TryConvertHexCharToByte(char c, out byte value)
+    {
+        if ((uint)(c - '0') <= 9)
+        {
+            value = (byte)(c - '0');
+            return true;
+        }
+
+        char lower = (char)(c | 0x20); // Normalize to lowercase
+
+        if ((uint)(lower - 'a') <= 5)
+        {
+            value = (byte)(lower - 'a' + 10);
+            return true;
+        }
+
+        value = 0;
+        return false;
+    }
 }
diff --git a/src/ImageSharp/Color/ColorHexFormat.cs b/src/ImageSharp/Color/ColorHexFormat.cs
new file mode 100644
index 0000000000..e1cd898c70
--- /dev/null
+++ b/src/ImageSharp/Color/ColorHexFormat.cs
@@ -0,0 +1,40 @@
+// Copyright (c) Six Labors.
+// Licensed under the Six Labors Split License.
+
+namespace SixLabors.ImageSharp;
+
+/// <summary>
+/// Specifies the channel order when formatting or parsing a color as a hexadecimal string.
+/// </summary>
+public enum ColorHexFormat
+{
+    /// <summary>
+    /// Uses <c>RRGGBBAA</c> channel order where the red, green, and blue components come first,
+    /// followed by the alpha component. This matches the CSS Color Module Level 4 and common web standards.
+    /// <para>
+    /// When parsing, supports the following formats:
+    /// <list type="bullet">
+    /// <item><description><c>#RGB</c> expands to <c>RRGGBBFF</c> (fully opaque)</description></item>
+    /// <item><description><c>#RGBA</c> expands to <c>RRGGBBAA</c></description></item>
+    /// <item><description><c>#RRGGBB</c> expands to <c>RRGGBBFF</c> (fully opaque)</description></item>
+    /// <item><description><c>#RRGGBBAA</c> used as-is</description></item>
+    /// </list>
+    /// </para>
+    /// When formatting, outputs an 8-digit hex string in <c>RRGGBBAA</c> order.
+    /// </summary>
+    Rgba,
+
+    /// <summary>
+    /// Uses <c>AARRGGBB</c> channel order where the alpha component comes first,
+    /// followed by the red, green, and blue components. This matches the Microsoft/XAML convention.
+    /// <para>
+    /// When parsing, supports the following formats:
+    /// <list type="bullet">
+    /// <item><description><c>#ARGB</c> expands to <c>AARRGGBB</c></description></item>
+    /// <item><description><c>#AARRGGBB</c> used as-is</description></item>
+    /// </list>
+    /// </para>
+    /// When formatting, outputs an 8-digit hex string in <c>AARRGGBB</c> order.
+    /// </summary>
+    Argb
+}
diff --git a/src/ImageSharp/ColorProfiles/CieLab.cs b/src/ImageSharp/ColorProfiles/CieLab.cs
index 377cc20a99..ebe1631021 100644
--- a/src/ImageSharp/ColorProfiles/CieLab.cs
+++ b/src/ImageSharp/ColorProfiles/CieLab.cs
@@ -35,7 +35,6 @@ public readonly struct CieLab : IProfileConnectingSpace<CieLab, CieXyz>
     /// <param name="vector">The vector representing the l, a, b components.</param>
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
     public CieLab(Vector3 vector)
-        : this()
     {
         this.L = vector.X;
         this.A = vector.Y;
@@ -82,6 +81,49 @@ public readonly struct CieLab : IProfileConnectingSpace<CieLab, CieXyz>
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
     public static bool operator !=(CieLab left, CieLab right) => !left.Equals(right);
 
+    /// <inheritdoc/>
+    public Vector4 ToScaledVector4()
+    {
+        Vector3 v3 = default;
+        v3 += this.AsVector3Unsafe();
+        v3 += new Vector3(0, 128F, 128F);
+        v3 /= new Vector3(100F, 255F, 255F);
+        return new Vector4(v3, 1F);
+    }
+
+    /// <inheritdoc/>
+    public static CieLab FromScaledVector4(Vector4 source)
+    {
+        Vector3 v3 = source.AsVector3();
+        v3 *= new Vector3(100F, 255, 255);
+        v3 -= new Vector3(0, 128F, 128F);
+        return new CieLab(v3);
+    }
+
+    /// <inheritdoc/>
+    public static void ToScaledVector4(ReadOnlySpan<CieLab> source, Span<Vector4> destination)
+    {
+        Guard.DestinationShouldNotBeTooShort(source, destination, nameof(destination));
+
+        // TODO: Optimize via SIMD
+        for (int i = 0; i < source.Length; i++)
+        {
+            destination[i] = source[i].ToScaledVector4();
+        }
+    }
+
+    /// <inheritdoc/>
+    public static void FromScaledVector4(ReadOnlySpan<Vector4> source, Span<CieLab> destination)
+    {
+        Guard.DestinationShouldNotBeTooShort(source, destination, nameof(destination));
+
+        // TODO: Optimize via SIMD
+        for (int i = 0; i < source.Length; i++)
+        {
+            destination[i] = FromScaledVector4(source[i]);
+        }
+    }
+
     /// <inheritdoc/>
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
     public static CieLab FromProfileConnectingSpace(ColorConversionOptions options, in CieXyz source)
@@ -136,11 +178,11 @@ public readonly struct CieLab : IProfileConnectingSpace<CieLab, CieXyz>
         float yr = l > CieConstants.Kappa * CieConstants.Epsilon ? Numerics.Pow3((l + 16F) / 116F) : l / CieConstants.Kappa;
         float zr = fz3 > CieConstants.Epsilon ? fz3 : ((116F * fz) - 16F) / CieConstants.Kappa;
 
-        CieXyz whitePoint = options.WhitePoint;
+        CieXyz whitePoint = options.SourceWhitePoint;
         Vector3 wxyz = new(whitePoint.X, whitePoint.Y, whitePoint.Z);
         Vector3 xyzr = new(xr, yr, zr);
 
-        return new(xyzr * wxyz);
+        return new CieXyz(xyzr * wxyz);
     }
 
     /// <inheritdoc/>
diff --git a/src/ImageSharp/ColorProfiles/CieLch.cs b/src/ImageSharp/ColorProfiles/CieLch.cs
index 1319783406..e62aa2ba23 100644
--- a/src/ImageSharp/ColorProfiles/CieLch.cs
+++ b/src/ImageSharp/ColorProfiles/CieLch.cs
@@ -42,6 +42,17 @@ public readonly struct CieLch : IColorProfile<CieLch, CieLab>
         this.H = vector.Z;
     }
 
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+#pragma warning disable SA1313 // Parameter names should begin with lower-case letter
+    private CieLch(Vector3 vector, bool _)
+#pragma warning restore SA1313 // Parameter names should begin with lower-case letter
+    {
+        vector = Vector3.Clamp(vector, Min, Max);
+        this.L = vector.X;
+        this.C = vector.Y;
+        this.H = vector.Z;
+    }
+
     /// <summary>
     /// Gets the lightness dimension.
     /// <remarks>A value ranging between 0 (black), 100 (diffuse white) or higher (specular white).</remarks>
@@ -50,7 +61,7 @@ public readonly struct CieLch : IColorProfile<CieLch, CieLab>
 
     /// <summary>
     /// Gets the a chroma component.
-    /// <remarks>A value ranging from 0 to 200.</remarks>
+    /// <remarks>A value ranging from -200 to 200.</remarks>
     /// </summary>
     public float C { get; }
 
@@ -82,6 +93,49 @@ public readonly struct CieLch : IColorProfile<CieLch, CieLab>
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
     public static bool operator !=(CieLch left, CieLch right) => !left.Equals(right);
 
+    /// <inheritdoc/>
+    public Vector4 ToScaledVector4()
+    {
+        Vector3 v3 = default;
+        v3 += this.AsVector3Unsafe();
+        v3 += new Vector3(0, 200, 0);
+        v3 /= new Vector3(100, 400, 360);
+        return new Vector4(v3, 1F);
+    }
+
+    /// <inheritdoc/>
+    public static CieLch FromScaledVector4(Vector4 source)
+    {
+        Vector3 v3 = source.AsVector3();
+        v3 *= new Vector3(100, 400, 360);
+        v3 -= new Vector3(0, 200, 0);
+        return new CieLch(v3, true);
+    }
+
+    /// <inheritdoc/>
+    public static void ToScaledVector4(ReadOnlySpan<CieLch> source, Span<Vector4> destination)
+    {
+        Guard.DestinationShouldNotBeTooShort(source, destination, nameof(destination));
+
+        // TODO: Optimize via SIMD
+        for (int i = 0; i < source.Length; i++)
+        {
+            destination[i] = source[i].ToScaledVector4();
+        }
+    }
+
+    /// <inheritdoc/>
+    public static void FromScaledVector4(ReadOnlySpan<Vector4> source, Span<CieLch> destination)
+    {
+        Guard.DestinationShouldNotBeTooShort(source, destination, nameof(destination));
+
+        // TODO: Optimize via SIMD
+        for (int i = 0; i < source.Length; i++)
+        {
+            destination[i] = FromScaledVector4(source[i]);
+        }
+    }
+
     /// <inheritdoc/>
     public static CieLch FromProfileConnectingSpace(ColorConversionOptions options, in CieLab source)
     {
diff --git a/src/ImageSharp/ColorProfiles/CieLchuv.cs b/src/ImageSharp/ColorProfiles/CieLchuv.cs
index 7fd95feb19..5478752ddc 100644
--- a/src/ImageSharp/ColorProfiles/CieLchuv.cs
+++ b/src/ImageSharp/ColorProfiles/CieLchuv.cs
@@ -35,7 +35,6 @@ public readonly struct CieLchuv : IColorProfile<CieLchuv, CieXyz>
     /// <param name="vector">The vector representing the l, c, h components.</param>
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
     public CieLchuv(Vector3 vector)
-        : this()
     {
         vector = Vector3.Clamp(vector, Min, Max);
         this.L = vector.X;
@@ -43,6 +42,16 @@ public readonly struct CieLchuv : IColorProfile<CieLchuv, CieXyz>
         this.H = vector.Z;
     }
 
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+#pragma warning disable SA1313 // Parameter names should begin with lower-case letter
+    private CieLchuv(Vector3 vector, bool _)
+#pragma warning restore SA1313 // Parameter names should begin with lower-case letter
+    {
+        this.L = vector.X;
+        this.C = vector.Y;
+        this.H = vector.Z;
+    }
+
     /// <summary>
     /// Gets the lightness dimension.
     /// <remarks>A value ranging between 0 (black), 100 (diffuse white) or higher (specular white).</remarks>
@@ -51,7 +60,7 @@ public readonly struct CieLchuv : IColorProfile<CieLchuv, CieXyz>
 
     /// <summary>
     /// Gets the a chroma component.
-    /// <remarks>A value ranging from 0 to 200.</remarks>
+    /// <remarks>A value ranging from -200 to 200.</remarks>
     /// </summary>
     public float C { get; }
 
@@ -81,6 +90,49 @@ public readonly struct CieLchuv : IColorProfile<CieLchuv, CieXyz>
     /// </returns>
     public static bool operator !=(CieLchuv left, CieLchuv right) => !left.Equals(right);
 
+    /// <inheritdoc/>
+    public Vector4 ToScaledVector4()
+    {
+        Vector3 v3 = default;
+        v3 += this.AsVector3Unsafe();
+        v3 += new Vector3(0, 200, 0);
+        v3 /= new Vector3(100, 400, 360);
+        return new Vector4(v3, 1F);
+    }
+
+    /// <inheritdoc/>
+    public static CieLchuv FromScaledVector4(Vector4 source)
+    {
+        Vector3 v3 = source.AsVector3();
+        v3 *= new Vector3(100, 400, 360);
+        v3 -= new Vector3(0, 200, 0);
+        return new CieLchuv(v3, true);
+    }
+
+    /// <inheritdoc/>
+    public static void ToScaledVector4(ReadOnlySpan<CieLchuv> source, Span<Vector4> destination)
+    {
+        Guard.DestinationShouldNotBeTooShort(source, destination, nameof(destination));
+
+        // TODO: Optimize via SIMD
+        for (int i = 0; i < source.Length; i++)
+        {
+            destination[i] = source[i].ToScaledVector4();
+        }
+    }
+
+    /// <inheritdoc/>
+    public static void FromScaledVector4(ReadOnlySpan<Vector4> source, Span<CieLchuv> destination)
+    {
+        Guard.DestinationShouldNotBeTooShort(source, destination, nameof(destination));
+
+        // TODO: Optimize via SIMD
+        for (int i = 0; i < source.Length; i++)
+        {
+            destination[i] = FromScaledVector4(source[i]);
+        }
+    }
+
     /// <inheritdoc/>
     public static CieLchuv FromProfileConnectingSpace(ColorConversionOptions options, in CieXyz source)
     {
diff --git a/src/ImageSharp/ColorProfiles/CieLuv.cs b/src/ImageSharp/ColorProfiles/CieLuv.cs
index 97e2826f74..b17c433313 100644
--- a/src/ImageSharp/ColorProfiles/CieLuv.cs
+++ b/src/ImageSharp/ColorProfiles/CieLuv.cs
@@ -37,7 +37,6 @@ public readonly struct CieLuv : IColorProfile<CieLuv, CieXyz>
     /// <param name="vector">The vector representing the l, u, v components.</param>
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
     public CieLuv(Vector3 vector)
-        : this()
     {
         this.L = vector.X;
         this.U = vector.Y;
@@ -84,6 +83,18 @@ public readonly struct CieLuv : IColorProfile<CieLuv, CieXyz>
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
     public static bool operator !=(CieLuv left, CieLuv right) => !left.Equals(right);
 
+    /// <inheritdoc/>
+    public Vector4 ToScaledVector4() => throw new NotImplementedException();
+
+    /// <inheritdoc/>
+    public static CieLuv FromScaledVector4(Vector4 source) => throw new NotImplementedException();
+
+    /// <inheritdoc/>
+    public static void ToScaledVector4(ReadOnlySpan<CieLuv> source, Span<Vector4> destination) => throw new NotImplementedException();
+
+    /// <inheritdoc/>
+    public static void FromScaledVector4(ReadOnlySpan<Vector4> source, Span<CieLuv> destination) => throw new NotImplementedException();
+
     /// <inheritdoc/>
     public static CieLuv FromProfileConnectingSpace(ColorConversionOptions options, in CieXyz source)
     {
@@ -143,7 +154,7 @@ public readonly struct CieLuv : IColorProfile<CieLuv, CieXyz>
         // Use doubles here for accuracy.
         // Conversion algorithm described here:
         // http://www.brucelindbloom.com/index.html?Eqn_Luv_to_XYZ.html
-        CieXyz whitePoint = options.WhitePoint;
+        CieXyz whitePoint = options.SourceWhitePoint;
 
         double l = this.L, u = this.U, v = this.V;
 
diff --git a/src/ImageSharp/ColorProfiles/CieXyy.cs b/src/ImageSharp/ColorProfiles/CieXyy.cs
index 62873df147..744b6195e9 100644
--- a/src/ImageSharp/ColorProfiles/CieXyy.cs
+++ b/src/ImageSharp/ColorProfiles/CieXyy.cs
@@ -35,7 +35,6 @@ public readonly struct CieXyy : IColorProfile<CieXyy, CieXyz>
     /// <param name="vector">The vector representing the x, y, Y components.</param>
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
     public CieXyy(Vector3 vector)
-        : this()
     {
         // Not clamping as documentation about this space only indicates "usual" ranges
         this.X = vector.X;
@@ -83,6 +82,38 @@ public readonly struct CieXyy : IColorProfile<CieXyy, CieXyz>
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
     public static bool operator !=(CieXyy left, CieXyy right) => !left.Equals(right);
 
+    /// <inheritdoc/>
+    public Vector4 ToScaledVector4()
+        => new(this.AsVector3Unsafe(), 1F);
+
+    /// <inheritdoc/>
+    public static CieXyy FromScaledVector4(Vector4 source)
+        => new(source.AsVector3());
+
+    /// <inheritdoc/>
+    public static void ToScaledVector4(ReadOnlySpan<CieXyy> source, Span<Vector4> destination)
+    {
+        Guard.DestinationShouldNotBeTooShort(source, destination, nameof(destination));
+
+        // TODO: Optimize via SIMD
+        for (int i = 0; i < source.Length; i++)
+        {
+            destination[i] = source[i].ToScaledVector4();
+        }
+    }
+
+    /// <inheritdoc/>
+    public static void FromScaledVector4(ReadOnlySpan<Vector4> source, Span<CieXyy> destination)
+    {
+        Guard.DestinationShouldNotBeTooShort(source, destination, nameof(destination));
+
+        // TODO: Optimize via SIMD
+        for (int i = 0; i < source.Length; i++)
+        {
+            destination[i] = FromScaledVector4(source[i]);
+        }
+    }
+
     /// <inheritdoc/>
     public static CieXyy FromProfileConnectingSpace(ColorConversionOptions options, in CieXyz source)
     {
diff --git a/src/ImageSharp/ColorProfiles/CieXyz.cs b/src/ImageSharp/ColorProfiles/CieXyz.cs
index 07f9b47f9b..94fcfb21bb 100644
--- a/src/ImageSharp/ColorProfiles/CieXyz.cs
+++ b/src/ImageSharp/ColorProfiles/CieXyz.cs
@@ -34,7 +34,6 @@ public readonly struct CieXyz : IProfileConnectingSpace<CieXyz, CieXyz>
     /// </summary>
     /// <param name="vector">The vector representing the x, y, z components.</param>
     public CieXyz(Vector3 vector)
-        : this()
     {
         this.X = vector.X;
         this.Y = vector.Y;
@@ -81,12 +80,85 @@ public readonly struct CieXyz : IProfileConnectingSpace<CieXyz, CieXyz>
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
     public static bool operator !=(CieXyz left, CieXyz right) => !left.Equals(right);
 
-    /// <summary>
-    /// Returns a new <see cref="Vector3"/> representing this instance.
-    /// </summary>
-    /// <returns>The <see cref="Vector3"/>.</returns>
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
-    public Vector3 ToVector3() => new(this.X, this.Y, this.Z);
+    internal Vector3 ToVector3() => new(this.X, this.Y, this.Z);
+
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    internal Vector4 ToVector4()
+    {
+        Vector3 v3 = default;
+        v3 += this.AsVector3Unsafe();
+        return new Vector4(v3, 1F);
+    }
+
+    /// <inheritdoc/>
+    public Vector4 ToScaledVector4()
+    {
+        Vector3 v3 = default;
+        v3 += this.AsVector3Unsafe();
+        v3 *= 32768F / 65535;
+        return new Vector4(v3, 1F);
+    }
+
+    internal static CieXyz FromVector4(Vector4 source)
+    {
+        Vector3 v3 = source.AsVector3();
+        return new CieXyz(v3);
+    }
+
+    /// <inheritdoc/>
+    public static CieXyz FromScaledVector4(Vector4 source)
+    {
+        Vector3 v3 = source.AsVector3();
+        v3 *= 65535 / 32768F;
+        return new CieXyz(v3);
+    }
+
+    /// <inheritdoc/>
+    public static void ToScaledVector4(ReadOnlySpan<CieXyz> source, Span<Vector4> destination)
+    {
+        Guard.DestinationShouldNotBeTooShort(source, destination, nameof(destination));
+
+        // TODO: Optimize via SIMD
+        for (int i = 0; i < source.Length; i++)
+        {
+            destination[i] = source[i].ToScaledVector4();
+        }
+    }
+
+    /// <inheritdoc/>
+    public static void FromScaledVector4(ReadOnlySpan<Vector4> source, Span<CieXyz> destination)
+    {
+        Guard.DestinationShouldNotBeTooShort(source, destination, nameof(destination));
+
+        // TODO: Optimize via SIMD
+        for (int i = 0; i < source.Length; i++)
+        {
+            destination[i] = FromScaledVector4(source[i]);
+        }
+    }
+
+    internal static void FromVector4(ReadOnlySpan<Vector4> source, Span<CieXyz> destination)
+    {
+        Guard.DestinationShouldNotBeTooShort(source, destination, nameof(destination));
+
+        // TODO: Optimize via SIMD
+        for (int i = 0; i < source.Length; i++)
+        {
+            destination[i] = FromVector4(source[i]);
+        }
+    }
+
+    internal static void ToVector4(ReadOnlySpan<CieXyz> source, Span<Vector4> destination)
+    {
+        Guard.DestinationShouldNotBeTooShort(source, destination, nameof(destination));
+
+        // TODO: Optimize via SIMD
+        for (int i = 0; i < source.Length; i++)
+        {
+            destination[i] = source[i].ToVector4();
+        }
+    }
 
     /// <inheritdoc/>
     public static CieXyz FromProfileConnectingSpace(ColorConversionOptions options, in CieXyz source)
@@ -127,5 +199,5 @@ public readonly struct CieXyz : IProfileConnectingSpace<CieXyz, CieXyz>
     public bool Equals(CieXyz other)
         => this.AsVector3Unsafe() == other.AsVector3Unsafe();
 
-    private Vector3 AsVector3Unsafe() => Unsafe.As<CieXyz, Vector3>(ref Unsafe.AsRef(in this));
+    internal Vector3 AsVector3Unsafe() => Unsafe.As<CieXyz, Vector3>(ref Unsafe.AsRef(in this));
 }
diff --git a/src/ImageSharp/ColorProfiles/Cmyk.cs b/src/ImageSharp/ColorProfiles/Cmyk.cs
index e924904497..ee81ff9f7e 100644
--- a/src/ImageSharp/ColorProfiles/Cmyk.cs
+++ b/src/ImageSharp/ColorProfiles/Cmyk.cs
@@ -9,6 +9,7 @@ namespace SixLabors.ImageSharp.ColorProfiles;
 
 /// <summary>
 /// Represents an CMYK (cyan, magenta, yellow, keyline) color.
+/// <see href="https://en.wikipedia.org/wiki/CMYK_color_model"/>
 /// </summary>
 [StructLayout(LayoutKind.Sequential)]
 public readonly struct Cmyk : IColorProfile<Cmyk, Rgb>
@@ -36,7 +37,18 @@ public readonly struct Cmyk : IColorProfile<Cmyk, Rgb>
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
     public Cmyk(Vector4 vector)
     {
-        vector = Numerics.Clamp(vector, Min, Max);
+        vector = Vector4.Clamp(vector, Min, Max);
+        this.C = vector.X;
+        this.M = vector.Y;
+        this.Y = vector.Z;
+        this.K = vector.W;
+    }
+
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+#pragma warning disable SA1313 // Parameter names should begin with lower-case letter
+    private Cmyk(Vector4 vector, bool _)
+#pragma warning restore SA1313 // Parameter names should begin with lower-case letter
+    {
         this.C = vector.X;
         this.M = vector.Y;
         this.Y = vector.Z;
@@ -89,16 +101,42 @@ public readonly struct Cmyk : IColorProfile<Cmyk, Rgb>
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
     public static bool operator !=(Cmyk left, Cmyk right) => !left.Equals(right);
 
+    /// <inheritdoc/>
+    public Vector4 ToScaledVector4()
+    {
+        Vector4 v4 = default;
+        v4 += this.AsVector4Unsafe();
+        return v4;
+    }
+
+    /// <inheritdoc/>
+    public static Cmyk FromScaledVector4(Vector4 source)
+        => new(source, true);
+
+    /// <inheritdoc/>
+    public static void ToScaledVector4(ReadOnlySpan<Cmyk> source, Span<Vector4> destination)
+    {
+        Guard.DestinationShouldNotBeTooShort(source, destination, nameof(destination));
+        MemoryMarshal.Cast<Cmyk, Vector4>(source).CopyTo(destination);
+    }
+
+    /// <inheritdoc/>
+    public static void FromScaledVector4(ReadOnlySpan<Vector4> source, Span<Cmyk> destination)
+    {
+        Guard.DestinationShouldNotBeTooShort(source, destination, nameof(destination));
+        MemoryMarshal.Cast<Vector4, Cmyk>(source).CopyTo(destination);
+    }
+
     /// <inheritdoc/>
     public static Cmyk FromProfileConnectingSpace(ColorConversionOptions options, in Rgb source)
     {
         // To CMY
-        Vector3 cmy = Vector3.One - source.ToScaledVector3();
+        Vector3 cmy = Vector3.One - source.AsVector3Unsafe();
 
         // To CMYK
         Vector3 k = new(MathF.Min(cmy.X, MathF.Min(cmy.Y, cmy.Z)));
 
-        if (MathF.Abs(k.X - 1F) < Constants.Epsilon)
+        if (k.X >= 1F - Constants.Epsilon)
         {
             return new Cmyk(0, 0, 0, 1F);
         }
@@ -124,7 +162,7 @@ public readonly struct Cmyk : IColorProfile<Cmyk, Rgb>
     /// <inheritdoc/>
     public Rgb ToProfileConnectingSpace(ColorConversionOptions options)
     {
-        Vector3 rgb = (Vector3.One - new Vector3(this.C, this.M, this.Y)) * (Vector3.One - new Vector3(this.K));
+        Vector3 rgb = (Vector3.One - new Vector3(this.C, this.M, this.Y)) * (1F - this.K);
         return Rgb.FromScaledVector3(rgb);
     }
 
@@ -134,8 +172,7 @@ public readonly struct Cmyk : IColorProfile<Cmyk, Rgb>
         // TODO: We can possibly optimize this by using SIMD
         for (int i = 0; i < source.Length; i++)
         {
-            Cmyk cmyk = source[i];
-            destination[i] = cmyk.ToProfileConnectingSpace(options);
+            destination[i] = source[i].ToProfileConnectingSpace(options);
         }
     }
 
diff --git a/src/ImageSharp/ColorProfiles/ColorConversionOptions.cs b/src/ImageSharp/ColorProfiles/ColorConversionOptions.cs
index 1eb118834a..882d246a76 100644
--- a/src/ImageSharp/ColorProfiles/ColorConversionOptions.cs
+++ b/src/ImageSharp/ColorProfiles/ColorConversionOptions.cs
@@ -4,6 +4,7 @@
 using System.Numerics;
 using SixLabors.ImageSharp.ColorProfiles.WorkingSpaces;
 using SixLabors.ImageSharp.Memory;
+using SixLabors.ImageSharp.Metadata.Profiles.Icc;
 
 namespace SixLabors.ImageSharp.ColorProfiles;
 
@@ -13,11 +14,16 @@ namespace SixLabors.ImageSharp.ColorProfiles;
 public class ColorConversionOptions
 {
     private Matrix4x4 adaptationMatrix;
+    private YCbCrTransform yCbCrTransform;
 
     /// <summary>
     /// Initializes a new instance of the <see cref="ColorConversionOptions"/> class.
     /// </summary>
-    public ColorConversionOptions() => this.AdaptationMatrix = KnownChromaticAdaptationMatrices.Bradford;
+    public ColorConversionOptions()
+    {
+        this.AdaptationMatrix = KnownChromaticAdaptationMatrices.Bradford;
+        this.YCbCrTransform = KnownYCbCrMatrices.BT601;
+    }
 
     /// <summary>
     /// Gets the memory allocator.
@@ -27,7 +33,7 @@ public class ColorConversionOptions
     /// <summary>
     /// Gets the source white point used for chromatic adaptation in conversions from/to XYZ color space.
     /// </summary>
-    public CieXyz WhitePoint { get; init; } = KnownIlluminants.D50;
+    public CieXyz SourceWhitePoint { get; init; } = KnownIlluminants.D50;
 
     /// <summary>
     /// Gets the destination white point used for chromatic adaptation in conversions from/to XYZ color space.
@@ -37,13 +43,36 @@ public class ColorConversionOptions
     /// <summary>
     /// Gets the source working space used for companding in conversions from/to XYZ color space.
     /// </summary>
-    public RgbWorkingSpace RgbWorkingSpace { get; init; } = KnownRgbWorkingSpaces.SRgb;
+    public RgbWorkingSpace SourceRgbWorkingSpace { get; init; } = KnownRgbWorkingSpaces.SRgb;
 
     /// <summary>
     /// Gets the destination working space used for companding in conversions from/to XYZ color space.
     /// </summary>
     public RgbWorkingSpace TargetRgbWorkingSpace { get; init; } = KnownRgbWorkingSpaces.SRgb;
 
+    /// <summary>
+    /// Gets the YCbCr matrix to used to perform conversions from/to RGB.
+    /// </summary>
+    public YCbCrTransform YCbCrTransform
+    {
+        get => this.yCbCrTransform;
+        init
+        {
+            this.yCbCrTransform = value;
+            this.TransposedYCbCrTransform = value.Transpose();
+        }
+    }
+
+    /// <summary>
+    /// Gets the source ICC profile.
+    /// </summary>
+    public IccProfile? SourceIccProfile { get; init; }
+
+    /// <summary>
+    /// Gets the target ICC profile.
+    /// </summary>
+    public IccProfile? TargetIccProfile { get; init; }
+
     /// <summary>
     /// Gets the transformation matrix used in conversion to perform chromatic adaptation.
     /// <see cref="KnownChromaticAdaptationMatrices"/> for further information. Default is Bradford.
@@ -54,10 +83,12 @@ public class ColorConversionOptions
         init
         {
             this.adaptationMatrix = value;
-            Matrix4x4.Invert(value, out Matrix4x4 inverted);
+            _ = Matrix4x4.Invert(value, out Matrix4x4 inverted);
             this.InverseAdaptationMatrix = inverted;
         }
     }
 
+    internal YCbCrTransform TransposedYCbCrTransform { get; private set; }
+
     internal Matrix4x4 InverseAdaptationMatrix { get; private set; }
 }
diff --git a/src/ImageSharp/ColorProfiles/ColorProfileConverter.cs b/src/ImageSharp/ColorProfiles/ColorProfileConverter.cs
index 18b90a622a..7072537a4a 100644
--- a/src/ImageSharp/ColorProfiles/ColorProfileConverter.cs
+++ b/src/ImageSharp/ColorProfiles/ColorProfileConverter.cs
@@ -12,7 +12,7 @@ public class ColorProfileConverter
     /// Initializes a new instance of the <see cref="ColorProfileConverter"/> class.
     /// </summary>
     public ColorProfileConverter()
-    : this(new())
+        : this(new ColorConversionOptions())
     {
     }
 
@@ -33,8 +33,8 @@ public class ColorProfileConverter
                where TTo : struct, IColorProfile
     {
         CieXyz sourceWhitePoint = TFrom.GetChromaticAdaptionWhitePointSource() == ChromaticAdaptionWhitePointSource.WhitePoint
-            ? this.Options.WhitePoint
-            : this.Options.RgbWorkingSpace.WhitePoint;
+            ? this.Options.SourceWhitePoint
+            : this.Options.SourceRgbWorkingSpace.WhitePoint;
 
         CieXyz targetWhitePoint = TTo.GetChromaticAdaptionWhitePointSource() == ChromaticAdaptionWhitePointSource.WhitePoint
             ? this.Options.TargetWhitePoint
@@ -42,4 +42,7 @@ public class ColorProfileConverter
 
         return (sourceWhitePoint, targetWhitePoint);
     }
+
+    internal bool ShouldUseIccProfiles()
+        => this.Options.SourceIccProfile != null && this.Options.TargetIccProfile != null;
 }
diff --git a/src/ImageSharp/ColorProfiles/ColorProfileConverterExtensionsCieLabCieLab.cs b/src/ImageSharp/ColorProfiles/ColorProfileConverterExtensionsCieLabCieLab.cs
index 41ae4b08fa..a2dd5d9ced 100644
--- a/src/ImageSharp/ColorProfiles/ColorProfileConverterExtensionsCieLabCieLab.cs
+++ b/src/ImageSharp/ColorProfiles/ColorProfileConverterExtensionsCieLabCieLab.cs
@@ -12,6 +12,11 @@ internal static class ColorProfileConverterExtensionsCieLabCieLab
         where TFrom : struct, IColorProfile<TFrom, CieLab>
         where TTo : struct, IColorProfile<TTo, CieLab>
     {
+        if (converter.ShouldUseIccProfiles())
+        {
+            return converter.ConvertUsingIccProfile<TFrom, TTo>(source);
+        }
+
         ColorConversionOptions options = converter.Options;
 
         // Convert to input PCS
@@ -33,6 +38,12 @@ internal static class ColorProfileConverterExtensionsCieLabCieLab
         where TFrom : struct, IColorProfile<TFrom, CieLab>
         where TTo : struct, IColorProfile<TTo, CieLab>
     {
+        if (converter.ShouldUseIccProfiles())
+        {
+            converter.ConvertUsingIccProfile(source, destination);
+            return;
+        }
+
         ColorConversionOptions options = converter.Options;
 
         // Convert to input PCS.
diff --git a/src/ImageSharp/ColorProfiles/ColorProfileConverterExtensionsCieLabCieXyz.cs b/src/ImageSharp/ColorProfiles/ColorProfileConverterExtensionsCieLabCieXyz.cs
index 04937e927e..096622564c 100644
--- a/src/ImageSharp/ColorProfiles/ColorProfileConverterExtensionsCieLabCieXyz.cs
+++ b/src/ImageSharp/ColorProfiles/ColorProfileConverterExtensionsCieLabCieXyz.cs
@@ -12,6 +12,11 @@ internal static class ColorProfileConverterExtensionsCieLabCieXyz
         where TFrom : struct, IColorProfile<TFrom, CieLab>
         where TTo : struct, IColorProfile<TTo, CieXyz>
     {
+        if (converter.ShouldUseIccProfiles())
+        {
+            return converter.ConvertUsingIccProfile<TFrom, TTo>(source);
+        }
+
         ColorConversionOptions options = converter.Options;
 
         // Convert to input PCS
@@ -32,6 +37,12 @@ internal static class ColorProfileConverterExtensionsCieLabCieXyz
         where TFrom : struct, IColorProfile<TFrom, CieLab>
         where TTo : struct, IColorProfile<TTo, CieXyz>
     {
+        if (converter.ShouldUseIccProfiles())
+        {
+            converter.ConvertUsingIccProfile(source, destination);
+            return;
+        }
+
         ColorConversionOptions options = converter.Options;
 
         // Convert to input PCS.
diff --git a/src/ImageSharp/ColorProfiles/ColorProfileConverterExtensionsCieLabRgb.cs b/src/ImageSharp/ColorProfiles/ColorProfileConverterExtensionsCieLabRgb.cs
index 47e4d2a80a..51be13799c 100644
--- a/src/ImageSharp/ColorProfiles/ColorProfileConverterExtensionsCieLabRgb.cs
+++ b/src/ImageSharp/ColorProfiles/ColorProfileConverterExtensionsCieLabRgb.cs
@@ -12,6 +12,11 @@ internal static class ColorProfileConverterExtensionsCieLabRgb
         where TFrom : struct, IColorProfile<TFrom, CieLab>
         where TTo : struct, IColorProfile<TTo, Rgb>
     {
+        if (converter.ShouldUseIccProfiles())
+        {
+            return converter.ConvertUsingIccProfile<TFrom, TTo>(source);
+        }
+
         ColorConversionOptions options = converter.Options;
 
         // Convert to input PCS
@@ -33,6 +38,12 @@ internal static class ColorProfileConverterExtensionsCieLabRgb
         where TFrom : struct, IColorProfile<TFrom, CieLab>
         where TTo : struct, IColorProfile<TTo, Rgb>
     {
+        if (converter.ShouldUseIccProfiles())
+        {
+            converter.ConvertUsingIccProfile(source, destination);
+            return;
+        }
+
         ColorConversionOptions options = converter.Options;
 
         // Convert to input PCS.
diff --git a/src/ImageSharp/ColorProfiles/ColorProfileConverterExtensionsCieXyzCieLab.cs b/src/ImageSharp/ColorProfiles/ColorProfileConverterExtensionsCieXyzCieLab.cs
index 6b1575d04c..3bab4e7b16 100644
--- a/src/ImageSharp/ColorProfiles/ColorProfileConverterExtensionsCieXyzCieLab.cs
+++ b/src/ImageSharp/ColorProfiles/ColorProfileConverterExtensionsCieXyzCieLab.cs
@@ -12,6 +12,11 @@ internal static class ColorProfileConverterExtensionsCieXyzCieLab
         where TFrom : struct, IColorProfile<TFrom, CieXyz>
         where TTo : struct, IColorProfile<TTo, CieLab>
     {
+        if (converter.ShouldUseIccProfiles())
+        {
+            return converter.ConvertUsingIccProfile<TFrom, TTo>(source);
+        }
+
         ColorConversionOptions options = converter.Options;
 
         // Convert to input PCS
@@ -32,6 +37,12 @@ internal static class ColorProfileConverterExtensionsCieXyzCieLab
         where TFrom : struct, IColorProfile<TFrom, CieXyz>
         where TTo : struct, IColorProfile<TTo, CieLab>
     {
+        if (converter.ShouldUseIccProfiles())
+        {
+            converter.ConvertUsingIccProfile(source, destination);
+            return;
+        }
+
         ColorConversionOptions options = converter.Options;
 
         // Convert to input PCS.
diff --git a/src/ImageSharp/ColorProfiles/ColorProfileConverterExtensionsCieXyzCieXyz.cs b/src/ImageSharp/ColorProfiles/ColorProfileConverterExtensionsCieXyzCieXyz.cs
index 8f56a5a663..5188511476 100644
--- a/src/ImageSharp/ColorProfiles/ColorProfileConverterExtensionsCieXyzCieXyz.cs
+++ b/src/ImageSharp/ColorProfiles/ColorProfileConverterExtensionsCieXyzCieXyz.cs
@@ -12,6 +12,11 @@ internal static class ColorProfileConverterExtensionsCieXyzCieXyz
         where TFrom : struct, IColorProfile<TFrom, CieXyz>
         where TTo : struct, IColorProfile<TTo, CieXyz>
     {
+        if (converter.ShouldUseIccProfiles())
+        {
+            return converter.ConvertUsingIccProfile<TFrom, TTo>(source);
+        }
+
         ColorConversionOptions options = converter.Options;
 
         // Convert to input PCS
@@ -29,6 +34,12 @@ internal static class ColorProfileConverterExtensionsCieXyzCieXyz
         where TFrom : struct, IColorProfile<TFrom, CieXyz>
         where TTo : struct, IColorProfile<TTo, CieXyz>
     {
+        if (converter.ShouldUseIccProfiles())
+        {
+            converter.ConvertUsingIccProfile(source, destination);
+            return;
+        }
+
         ColorConversionOptions options = converter.Options;
 
         // Convert to input PCS.
diff --git a/src/ImageSharp/ColorProfiles/ColorProfileConverterExtensionsCieXyzRgb.cs b/src/ImageSharp/ColorProfiles/ColorProfileConverterExtensionsCieXyzRgb.cs
index 9cc0bd9436..c56bf214b9 100644
--- a/src/ImageSharp/ColorProfiles/ColorProfileConverterExtensionsCieXyzRgb.cs
+++ b/src/ImageSharp/ColorProfiles/ColorProfileConverterExtensionsCieXyzRgb.cs
@@ -12,6 +12,11 @@ internal static class ColorProfileConverterExtensionsCieXyzRgb
         where TFrom : struct, IColorProfile<TFrom, CieXyz>
         where TTo : struct, IColorProfile<TTo, Rgb>
     {
+        if (converter.ShouldUseIccProfiles())
+        {
+            return converter.ConvertUsingIccProfile<TFrom, TTo>(source);
+        }
+
         ColorConversionOptions options = converter.Options;
 
         // Convert to input PCS
@@ -32,6 +37,12 @@ internal static class ColorProfileConverterExtensionsCieXyzRgb
         where TFrom : struct, IColorProfile<TFrom, CieXyz>
         where TTo : struct, IColorProfile<TTo, Rgb>
     {
+        if (converter.ShouldUseIccProfiles())
+        {
+            converter.ConvertUsingIccProfile(source, destination);
+            return;
+        }
+
         ColorConversionOptions options = converter.Options;
 
         // Convert to input PCS.
diff --git a/src/ImageSharp/ColorProfiles/ColorProfileConverterExtensionsIcc.cs b/src/ImageSharp/ColorProfiles/ColorProfileConverterExtensionsIcc.cs
new file mode 100644
index 0000000000..c33f40001a
--- /dev/null
+++ b/src/ImageSharp/ColorProfiles/ColorProfileConverterExtensionsIcc.cs
@@ -0,0 +1,731 @@
+// Copyright (c) Six Labors.
+// Licensed under the Six Labors Split License.
+
+using System.Buffers;
+using System.Diagnostics.CodeAnalysis;
+using System.Numerics;
+using System.Runtime.CompilerServices;
+using System.Runtime.Intrinsics;
+using SixLabors.ImageSharp.ColorProfiles.Conversion.Icc;
+using SixLabors.ImageSharp.ColorProfiles.Icc;
+using SixLabors.ImageSharp.Memory;
+using SixLabors.ImageSharp.Metadata.Profiles.Icc;
+
+namespace SixLabors.ImageSharp.ColorProfiles;
+
+internal static class ColorProfileConverterExtensionsIcc
+{
+    private static readonly float[] PcsV2FromBlackPointScale =
+        [0.9965153F, 0.9965269F, 0.9965208F, 1F,
+         0.9965153F, 0.9965269F, 0.9965208F, 1F,
+         0.9965153F, 0.9965269F, 0.9965208F, 1F,
+         0.9965153F, 0.9965269F, 0.9965208F, 1F];
+
+    private static readonly float[] PcsV2FromBlackPointOffset =
+        [0.00336F, 0.0034731F, 0.00287F, 0F,
+         0.00336F, 0.0034731F, 0.00287F, 0F,
+         0.00336F, 0.0034731F, 0.00287F, 0F,
+         0.00336F, 0.0034731F, 0.00287F, 0F];
+
+    private static readonly float[] PcsV2ToBlackPointScale =
+        [1.0034969F, 1.0034852F, 1.0034913F, 1F,
+         1.0034969F, 1.0034852F, 1.0034913F, 1F,
+         1.0034969F, 1.0034852F, 1.0034913F, 1F,
+         1.0034969F, 1.0034852F, 1.0034913F, 1F];
+
+    private static readonly float[] PcsV2ToBlackPointOffset =
+        [0.0033717495F, 0.0034852044F, 0.0028800198F, 0F,
+         0.0033717495F, 0.0034852044F, 0.0028800198F, 0F,
+         0.0033717495F, 0.0034852044F, 0.0028800198F, 0F,
+         0.0033717495F, 0.0034852044F, 0.0028800198F, 0F];
+
+    internal static TTo ConvertUsingIccProfile<TFrom, TTo>(this ColorProfileConverter converter, in TFrom source)
+        where TFrom : struct, IColorProfile<TFrom>
+        where TTo : struct, IColorProfile<TTo>
+    {
+        // TODO: Validation of ICC Profiles against color profile. Is this possible?
+        if (converter.Options.SourceIccProfile is null)
+        {
+            throw new InvalidOperationException("Source ICC profile is missing.");
+        }
+
+        if (converter.Options.TargetIccProfile is null)
+        {
+            throw new InvalidOperationException("Target ICC profile is missing.");
+        }
+
+        ConversionParams sourceParams = new(converter.Options.SourceIccProfile, toPcs: true);
+        ConversionParams targetParams = new(converter.Options.TargetIccProfile, toPcs: false);
+
+        ColorProfileConverter pcsConverter = new(new ColorConversionOptions
+        {
+            MemoryAllocator = converter.Options.MemoryAllocator,
+            SourceWhitePoint = new CieXyz(converter.Options.SourceIccProfile.Header.PcsIlluminant),
+            TargetWhitePoint = new CieXyz(converter.Options.TargetIccProfile.Header.PcsIlluminant),
+        });
+
+        // Normalize the source, then convert to the PCS space.
+        Vector4 sourcePcs = sourceParams.Converter.Calculate(source.ToScaledVector4());
+
+        // If both profiles need PCS adjustment, they both share the same unadjusted PCS space
+        // cancelling out the need to make the adjustment
+        // except if using TRC transforms, which always requires perceptual handling
+        // TODO: this does not include adjustment for absolute intent, which would double existing complexity, suggest throwing exception and addressing in future update
+        bool anyProfileNeedsPerceptualAdjustment = sourceParams.HasNoPerceptualHandling || targetParams.HasNoPerceptualHandling;
+        bool oneProfileHasV2PerceptualAdjustment = sourceParams.HasV2PerceptualHandling ^ targetParams.HasV2PerceptualHandling;
+
+        Vector4 targetPcs = anyProfileNeedsPerceptualAdjustment || oneProfileHasV2PerceptualAdjustment
+            ? GetTargetPcsWithPerceptualAdjustment(sourcePcs, sourceParams, targetParams, pcsConverter)
+            : GetTargetPcsWithoutAdjustment(sourcePcs, sourceParams, targetParams, pcsConverter);
+
+        return TTo.FromScaledVector4(targetParams.Converter.Calculate(targetPcs));
+    }
+
+    internal static void ConvertUsingIccProfile<TFrom, TTo>(this ColorProfileConverter converter, ReadOnlySpan<TFrom> source, Span<TTo> destination)
+        where TFrom : struct, IColorProfile<TFrom>
+        where TTo : struct, IColorProfile<TTo>
+    {
+        // TODO: Validation of ICC Profiles against color profile. Is this possible?
+        if (converter.Options.SourceIccProfile is null)
+        {
+            throw new InvalidOperationException("Source ICC profile is missing.");
+        }
+
+        if (converter.Options.TargetIccProfile is null)
+        {
+            throw new InvalidOperationException("Target ICC profile is missing.");
+        }
+
+        Guard.MustBeGreaterThanOrEqualTo(source.Length, destination.Length, nameof(destination));
+
+        ConversionParams sourceParams = new(converter.Options.SourceIccProfile, toPcs: true);
+        ConversionParams targetParams = new(converter.Options.TargetIccProfile, toPcs: false);
+
+        ColorProfileConverter pcsConverter = new(new ColorConversionOptions
+        {
+            MemoryAllocator = converter.Options.MemoryAllocator,
+            SourceWhitePoint = new CieXyz(converter.Options.SourceIccProfile.Header.PcsIlluminant),
+            TargetWhitePoint = new CieXyz(converter.Options.TargetIccProfile.Header.PcsIlluminant),
+        });
+
+        using IMemoryOwner<Vector4> pcsBuffer = converter.Options.MemoryAllocator.Allocate<Vector4>(source.Length);
+        Span<Vector4> pcs = pcsBuffer.GetSpan();
+
+        // Normalize the source, then convert to the PCS space.
+        TFrom.ToScaledVector4(source, pcs);
+        sourceParams.Converter.Calculate(pcs, pcs);
+
+        // If both profiles need PCS adjustment, they both share the same unadjusted PCS space
+        // cancelling out the need to make the adjustment
+        // except if using TRC transforms, which always requires perceptual handling
+        // TODO: this does not include adjustment for absolute intent, which would double existing complexity, suggest throwing exception and addressing in future update
+        bool anyProfileNeedsPerceptualAdjustment = sourceParams.HasNoPerceptualHandling || targetParams.HasNoPerceptualHandling;
+        bool oneProfileHasV2PerceptualAdjustment = sourceParams.HasV2PerceptualHandling ^ targetParams.HasV2PerceptualHandling;
+
+        if (anyProfileNeedsPerceptualAdjustment || oneProfileHasV2PerceptualAdjustment)
+        {
+            GetTargetPcsWithPerceptualAdjustment(pcs, sourceParams, targetParams, pcsConverter);
+        }
+        else
+        {
+            GetTargetPcsWithoutAdjustment(pcs, sourceParams, targetParams, pcsConverter);
+        }
+
+        // Convert to the target space.
+        targetParams.Converter.Calculate(pcs, pcs);
+        TTo.FromScaledVector4(pcs, destination);
+    }
+
+    private static Vector4 GetTargetPcsWithoutAdjustment(
+        Vector4 sourcePcs,
+        ConversionParams sourceParams,
+        ConversionParams targetParams,
+        ColorProfileConverter pcsConverter)
+    {
+        // Profile connecting spaces can only be Lab, XYZ.
+        // 16-bit Lab encodings changed from v2 to v4, but 16-bit LUTs always use the legacy encoding regardless of version
+        // so ensure that Lab is using the correct encoding when a 16-bit LUT is used
+        switch (sourceParams.PcsType)
+        {
+            // Convert from Lab to XYZ.
+            case IccColorSpaceType.CieLab when targetParams.PcsType is IccColorSpaceType.CieXyz:
+            {
+                sourcePcs = sourceParams.Is16BitLutEntry ? LabV2ToLab(sourcePcs) : sourcePcs;
+                CieLab lab = CieLab.FromScaledVector4(sourcePcs);
+                CieXyz xyz = pcsConverter.Convert<CieLab, CieXyz>(in lab);
+                return xyz.ToScaledVector4();
+            }
+
+            // Convert from XYZ to Lab.
+            case IccColorSpaceType.CieXyz when targetParams.PcsType is IccColorSpaceType.CieLab:
+            {
+                CieXyz xyz = CieXyz.FromScaledVector4(sourcePcs);
+                CieLab lab = pcsConverter.Convert<CieXyz, CieLab>(in xyz);
+                Vector4 targetPcs = lab.ToScaledVector4();
+                return targetParams.Is16BitLutEntry ? LabToLabV2(targetPcs) : targetPcs;
+            }
+
+            // Convert from XYZ to XYZ.
+            case IccColorSpaceType.CieXyz when targetParams.PcsType is IccColorSpaceType.CieXyz:
+            {
+                CieXyz xyz = CieXyz.FromScaledVector4(sourcePcs);
+                CieXyz targetXyz = pcsConverter.Convert<CieXyz, CieXyz>(in xyz);
+                return targetXyz.ToScaledVector4();
+            }
+
+            // Convert from Lab to Lab.
+            case IccColorSpaceType.CieLab when targetParams.PcsType is IccColorSpaceType.CieLab:
+            {
+                // if both source and target LUT use same v2 LAB encoding, no need to correct them
+                if (sourceParams.Is16BitLutEntry && targetParams.Is16BitLutEntry)
+                {
+                    CieLab sourceLab = CieLab.FromScaledVector4(sourcePcs);
+                    CieLab targetLab = pcsConverter.Convert<CieLab, CieLab>(in sourceLab);
+                    return targetLab.ToScaledVector4();
+                }
+                else
+                {
+                    sourcePcs = sourceParams.Is16BitLutEntry ? LabV2ToLab(sourcePcs) : sourcePcs;
+                    CieLab sourceLab = CieLab.FromScaledVector4(sourcePcs);
+                    CieLab targetLab = pcsConverter.Convert<CieLab, CieLab>(in sourceLab);
+                    Vector4 targetPcs = targetLab.ToScaledVector4();
+                    return targetParams.Is16BitLutEntry ? LabToLabV2(targetPcs) : targetPcs;
+                }
+            }
+
+            default:
+                throw new ArgumentOutOfRangeException($"Source PCS {sourceParams.PcsType} to target PCS {targetParams.PcsType} is not supported");
+        }
+    }
+
+    private static void GetTargetPcsWithoutAdjustment(
+        Span<Vector4> pcs,
+        ConversionParams sourceParams,
+        ConversionParams targetParams,
+        ColorProfileConverter pcsConverter)
+    {
+        // Profile connecting spaces can only be Lab, XYZ.
+        // 16-bit Lab encodings changed from v2 to v4, but 16-bit LUTs always use the legacy encoding regardless of version
+        // so ensure that Lab is using the correct encoding when a 16-bit LUT is used
+        switch (sourceParams.PcsType)
+        {
+            // Convert from Lab to XYZ.
+            case IccColorSpaceType.CieLab when targetParams.PcsType is IccColorSpaceType.CieXyz:
+            {
+                if (sourceParams.Is16BitLutEntry)
+                {
+                    LabV2ToLab(pcs, pcs);
+                }
+
+                using IMemoryOwner<CieLab> pcsFromBuffer = pcsConverter.Options.MemoryAllocator.Allocate<CieLab>(pcs.Length);
+                Span<CieLab> pcsFrom = pcsFromBuffer.GetSpan();
+
+                using IMemoryOwner<CieXyz> pcsToBuffer = pcsConverter.Options.MemoryAllocator.Allocate<CieXyz>(pcs.Length);
+                Span<CieXyz> pcsTo = pcsToBuffer.GetSpan();
+
+                CieLab.FromScaledVector4(pcs, pcsFrom);
+                pcsConverter.Convert<CieLab, CieXyz>(pcsFrom, pcsTo);
+
+                CieXyz.ToScaledVector4(pcsTo, pcs);
+                break;
+            }
+
+            // Convert from XYZ to Lab.
+            case IccColorSpaceType.CieXyz when targetParams.PcsType is IccColorSpaceType.CieLab:
+            {
+                using IMemoryOwner<CieXyz> pcsFromBuffer = pcsConverter.Options.MemoryAllocator.Allocate<CieXyz>(pcs.Length);
+                Span<CieXyz> pcsFrom = pcsFromBuffer.GetSpan();
+
+                using IMemoryOwner<CieLab> pcsToBuffer = pcsConverter.Options.MemoryAllocator.Allocate<CieLab>(pcs.Length);
+                Span<CieLab> pcsTo = pcsToBuffer.GetSpan();
+
+                CieXyz.FromScaledVector4(pcs, pcsFrom);
+                pcsConverter.Convert<CieXyz, CieLab>(pcsFrom, pcsTo);
+
+                CieLab.ToScaledVector4(pcsTo, pcs);
+
+                if (targetParams.Is16BitLutEntry)
+                {
+                    LabToLabV2(pcs, pcs);
+                }
+
+                break;
+            }
+
+            // Convert from XYZ to XYZ.
+            case IccColorSpaceType.CieXyz when targetParams.PcsType is IccColorSpaceType.CieXyz:
+            {
+                using IMemoryOwner<CieXyz> pcsFromToBuffer = pcsConverter.Options.MemoryAllocator.Allocate<CieXyz>(pcs.Length);
+                Span<CieXyz> pcsFromTo = pcsFromToBuffer.GetSpan();
+
+                CieXyz.FromScaledVector4(pcs, pcsFromTo);
+                pcsConverter.Convert<CieXyz, CieXyz>(pcsFromTo, pcsFromTo);
+
+                CieXyz.ToScaledVector4(pcsFromTo, pcs);
+                break;
+            }
+
+            // Convert from Lab to Lab.
+            case IccColorSpaceType.CieLab when targetParams.PcsType is IccColorSpaceType.CieLab:
+            {
+                using IMemoryOwner<CieLab> pcsFromToBuffer = pcsConverter.Options.MemoryAllocator.Allocate<CieLab>(pcs.Length);
+                Span<CieLab> pcsFromTo = pcsFromToBuffer.GetSpan();
+
+                // if both source and target LUT use same v2 LAB encoding, no need to correct them
+                if (sourceParams.Is16BitLutEntry && targetParams.Is16BitLutEntry)
+                {
+                    CieLab.FromScaledVector4(pcs, pcsFromTo);
+                    pcsConverter.Convert<CieLab, CieLab>(pcsFromTo, pcsFromTo);
+                    CieLab.ToScaledVector4(pcsFromTo, pcs);
+                }
+                else
+                {
+                    if (sourceParams.Is16BitLutEntry)
+                    {
+                        LabV2ToLab(pcs, pcs);
+                    }
+
+                    CieLab.FromScaledVector4(pcs, pcsFromTo);
+                    pcsConverter.Convert<CieLab, CieLab>(pcsFromTo, pcsFromTo);
+                    CieLab.ToScaledVector4(pcsFromTo, pcs);
+
+                    if (targetParams.Is16BitLutEntry)
+                    {
+                        LabToLabV2(pcs, pcs);
+                    }
+                }
+
+                break;
+            }
+
+            default:
+                throw new ArgumentOutOfRangeException($"Source PCS {sourceParams.PcsType} to target PCS {targetParams.PcsType} is not supported");
+        }
+    }
+
+    /// <summary>
+    /// Effectively this is <see cref="GetTargetPcsWithoutAdjustment(Vector4, ConversionParams, ConversionParams, ColorProfileConverter)"/> with an extra step in the middle.
+    /// It adjusts PCS by compensating for the black point used for perceptual intent in v2 profiles.
+    /// The adjustment needs to be performed in XYZ space, potentially an overhead of 2 more conversions.
+    /// Not required if both spaces need V2 correction, since they both have the same understanding of the PCS.
+    /// Not compatible with PCS adjustment for absolute intent.
+    /// </summary>
+    /// <param name="sourcePcs">The source PCS values.</param>
+    /// <param name="sourceParams">The source profile parameters.</param>
+    /// <param name="targetParams">The target profile parameters.</param>
+    /// <param name="pcsConverter">The converter to use for the PCS adjustments.</param>
+    /// <exception cref="ArgumentOutOfRangeException">Thrown when the source or target PCS is not supported.</exception>
+    private static Vector4 GetTargetPcsWithPerceptualAdjustment(
+        Vector4 sourcePcs,
+        ConversionParams sourceParams,
+        ConversionParams targetParams,
+        ColorProfileConverter pcsConverter)
+    {
+        // all conversions are funneled through XYZ in case PCS adjustments need to be made
+        CieXyz xyz;
+
+        switch (sourceParams.PcsType)
+        {
+            // 16-bit Lab encodings changed from v2 to v4, but 16-bit LUTs always use the legacy encoding regardless of version
+            // so convert Lab to modern v4 encoding when returned from a 16-bit LUT
+            case IccColorSpaceType.CieLab:
+                sourcePcs = sourceParams.Is16BitLutEntry ? LabV2ToLab(sourcePcs) : sourcePcs;
+                CieLab lab = CieLab.FromScaledVector4(sourcePcs);
+                xyz = pcsConverter.Convert<CieLab, CieXyz>(in lab);
+                break;
+            case IccColorSpaceType.CieXyz:
+                xyz = CieXyz.FromScaledVector4(sourcePcs);
+                break;
+            default:
+                throw new ArgumentOutOfRangeException($"Source PCS {sourceParams.PcsType} is not supported");
+        }
+
+        bool oneProfileHasV2PerceptualAdjustment = sourceParams.HasV2PerceptualHandling ^ targetParams.HasV2PerceptualHandling;
+
+        // when converting from device to PCS with v2 perceptual intent
+        // the black point needs to be adjusted to v4 after converting the PCS values
+        if (sourceParams.HasNoPerceptualHandling ||
+            (oneProfileHasV2PerceptualAdjustment && sourceParams.HasV2PerceptualHandling))
+        {
+            Vector3 vector = xyz.ToVector3();
+
+            // when using LAB PCS, negative values are clipped before PCS adjustment (in DemoIccMAX)
+            if (sourceParams.PcsType == IccColorSpaceType.CieLab)
+            {
+                vector = Vector3.Max(vector, Vector3.Zero);
+            }
+
+            xyz = new CieXyz(AdjustPcsFromV2BlackPoint(vector));
+        }
+
+        // when converting from PCS to device with v2 perceptual intent
+        // the black point needs to be adjusted to v2 before converting the PCS values
+        if (targetParams.HasNoPerceptualHandling ||
+            (oneProfileHasV2PerceptualAdjustment && targetParams.HasV2PerceptualHandling))
+        {
+            Vector3 vector = AdjustPcsToV2BlackPoint(xyz.AsVector3Unsafe());
+
+            // when using XYZ PCS, negative values are clipped after PCS adjustment (in DemoIccMAX)
+            if (targetParams.PcsType == IccColorSpaceType.CieXyz)
+            {
+                vector = Vector3.Max(vector, Vector3.Zero);
+            }
+
+            xyz = new CieXyz(vector);
+        }
+
+        switch (targetParams.PcsType)
+        {
+            // 16-bit Lab encodings changed from v2 to v4, but 16-bit LUTs always use the legacy encoding regardless of version
+            // so convert Lab back to legacy encoding before using in a 16-bit LUT
+            case IccColorSpaceType.CieLab:
+                CieLab lab = pcsConverter.Convert<CieXyz, CieLab>(in xyz);
+                Vector4 targetPcs = lab.ToScaledVector4();
+                return targetParams.Is16BitLutEntry ? LabToLabV2(targetPcs) : targetPcs;
+            case IccColorSpaceType.CieXyz:
+                return xyz.ToScaledVector4();
+            default:
+                throw new ArgumentOutOfRangeException($"Target PCS {targetParams.PcsType} is not supported");
+        }
+    }
+
+    /// <summary>
+    /// Effectively this is <see cref="GetTargetPcsWithoutAdjustment(Span{Vector4}, ConversionParams, ConversionParams, ColorProfileConverter)"/> with an extra step in the middle.
+    /// It adjusts PCS by compensating for the black point used for perceptual intent in v2 profiles.
+    /// The adjustment needs to be performed in XYZ space, potentially an overhead of 2 more conversions.
+    /// Not required if both spaces need V2 correction, since they both have the same understanding of the PCS.
+    /// Not compatible with PCS adjustment for absolute intent.
+    /// </summary>
+    /// <param name="pcs">The PCS values from the source.</param>
+    /// <param name="sourceParams">The source profile parameters.</param>
+    /// <param name="targetParams">The target profile parameters.</param>
+    /// <param name="pcsConverter">The converter to use for the PCS adjustments.</param>
+    /// <exception cref="ArgumentOutOfRangeException">Thrown when the source or target PCS is not supported.</exception>
+    private static void GetTargetPcsWithPerceptualAdjustment(
+        Span<Vector4> pcs,
+        ConversionParams sourceParams,
+        ConversionParams targetParams,
+        ColorProfileConverter pcsConverter)
+    {
+        // All conversions are funneled through XYZ in case PCS adjustments need to be made
+        using IMemoryOwner<CieXyz> xyzBuffer = pcsConverter.Options.MemoryAllocator.Allocate<CieXyz>(pcs.Length);
+        Span<CieXyz> xyz = xyzBuffer.GetSpan();
+
+        switch (sourceParams.PcsType)
+        {
+            // 16-bit Lab encodings changed from v2 to v4, but 16-bit LUTs always use the legacy encoding regardless of version
+            // so convert Lab to modern v4 encoding when returned from a 16-bit LUT
+            case IccColorSpaceType.CieLab:
+            {
+                if (sourceParams.Is16BitLutEntry)
+                {
+                    LabV2ToLab(pcs, pcs);
+                }
+
+                using IMemoryOwner<CieLab> pcsFromBuffer = pcsConverter.Options.MemoryAllocator.Allocate<CieLab>(pcs.Length);
+                Span<CieLab> pcsFrom = pcsFromBuffer.GetSpan();
+                CieLab.FromScaledVector4(pcs, pcsFrom);
+                pcsConverter.Convert<CieLab, CieXyz>(pcsFrom, xyz);
+                break;
+            }
+
+            case IccColorSpaceType.CieXyz:
+                CieXyz.FromScaledVector4(pcs, xyz);
+                break;
+            default:
+                throw new ArgumentOutOfRangeException($"Source PCS {sourceParams.PcsType} is not supported");
+        }
+
+        bool oneProfileHasV2PerceptualAdjustment = sourceParams.HasV2PerceptualHandling ^ targetParams.HasV2PerceptualHandling;
+
+        using IMemoryOwner<Vector4> vectorBuffer = pcsConverter.Options.MemoryAllocator.Allocate<Vector4>(pcs.Length);
+        Span<Vector4> vector = vectorBuffer.GetSpan();
+
+        // When converting from device to PCS with v2 perceptual intent
+        // the black point needs to be adjusted to v4 after converting the PCS values
+        if (sourceParams.HasNoPerceptualHandling ||
+            (oneProfileHasV2PerceptualAdjustment && sourceParams.HasV2PerceptualHandling))
+        {
+            CieXyz.ToVector4(xyz, vector);
+
+            // When using LAB PCS, negative values are clipped before PCS adjustment (in DemoIccMAX)
+            if (sourceParams.PcsType == IccColorSpaceType.CieLab)
+            {
+                ClipNegative(vector);
+            }
+
+            AdjustPcsFromV2BlackPoint(vector, vector);
+            CieXyz.FromVector4(vector, xyz);
+        }
+
+        // When converting from PCS to device with v2 perceptual intent
+        // the black point needs to be adjusted to v2 before converting the PCS values
+        if (targetParams.HasNoPerceptualHandling ||
+            (oneProfileHasV2PerceptualAdjustment && targetParams.HasV2PerceptualHandling))
+        {
+            CieXyz.ToVector4(xyz, vector);
+            AdjustPcsToV2BlackPoint(vector, vector);
+
+            // When using XYZ PCS, negative values are clipped after PCS adjustment (in DemoIccMAX)
+            if (targetParams.PcsType == IccColorSpaceType.CieXyz)
+            {
+                ClipNegative(vector);
+            }
+
+            CieXyz.FromVector4(vector, xyz);
+        }
+
+        switch (targetParams.PcsType)
+        {
+            // 16-bit Lab encodings changed from v2 to v4, but 16-bit LUTs always use the legacy encoding regardless of version
+            // so convert Lab back to legacy encoding before using in a 16-bit LUT
+            case IccColorSpaceType.CieLab:
+            {
+                using IMemoryOwner<CieLab> pcsToBuffer = pcsConverter.Options.MemoryAllocator.Allocate<CieLab>(pcs.Length);
+                Span<CieLab> pcsTo = pcsToBuffer.GetSpan();
+                pcsConverter.Convert<CieXyz, CieLab>(xyz, pcsTo);
+
+                CieLab.ToScaledVector4(pcsTo, pcs);
+
+                if (targetParams.Is16BitLutEntry)
+                {
+                    LabToLabV2(pcs, pcs);
+                }
+
+                break;
+            }
+
+            case IccColorSpaceType.CieXyz:
+                CieXyz.ToScaledVector4(xyz, pcs);
+                break;
+            default:
+                throw new ArgumentOutOfRangeException($"Target PCS {targetParams.PcsType} is not supported");
+        }
+    }
+
+    // as per DemoIccMAX icPerceptual values in IccCmm.h
+    // refBlack = 0.00336F, 0.0034731F, 0.00287F
+    // refWhite = 0.9642F, 1.0000F, 0.8249F
+    // scale = 1 - (refBlack / refWhite)
+    // offset = refBlack
+    private static Vector3 AdjustPcsFromV2BlackPoint(Vector3 xyz)
+        => (xyz * new Vector3(0.9965153F, 0.9965269F, 0.9965208F)) + new Vector3(0.00336F, 0.0034731F, 0.00287F);
+
+    // as per DemoIccMAX icPerceptual values in IccCmm.h
+    // refBlack = 0.00336F, 0.0034731F, 0.00287F
+    // refWhite = 0.9642F, 1.0000F, 0.8249F
+    // scale = 1 / (1 - (refBlack / refWhite))
+    // offset = -refBlack * scale
+    private static Vector3 AdjustPcsToV2BlackPoint(Vector3 xyz)
+        => (xyz * new Vector3(1.0034969F, 1.0034852F, 1.0034913F)) - new Vector3(0.0033717495F, 0.0034852044F, 0.0028800198F);
+
+    private static void AdjustPcsFromV2BlackPoint(Span<Vector4> source, Span<Vector4> destination)
+    {
+        if (Vector.IsHardwareAccelerated && Vector<float>.IsSupported &&
+            Vector<float>.Count <= Vector512<float>.Count &&
+            source.Length * 4 >= Vector<float>.Count)
+        {
+            // TODO: Check our constants. They may require scaling.
+            Vector<float> vScale = new(PcsV2FromBlackPointScale.AsSpan()[..Vector<float>.Count]);
+            Vector<float> vOffset = new(PcsV2FromBlackPointOffset.AsSpan()[..Vector<float>.Count]);
+
+            // SIMD loop
+            int i = 0;
+            int simdBatchSize = Vector<float>.Count / 4; // Number of Vector4 elements per SIMD batch
+            for (; i <= source.Length - simdBatchSize; i += simdBatchSize)
+            {
+                // Load the vector from source span
+                Vector<float> v = Unsafe.ReadUnaligned<Vector<float>>(ref Unsafe.As<Vector4, byte>(ref source[i]));
+
+                // Scale and offset the vector
+                v *= vScale;
+                v += vOffset;
+
+                // Write the vector to the destination span
+                Unsafe.WriteUnaligned(ref Unsafe.As<Vector4, byte>(ref destination[i]), v);
+            }
+
+            // Scalar fallback for remaining elements
+            for (; i < source.Length; i++)
+            {
+                Vector4 s = source[i];
+                s *= new Vector4(0.9965153F, 0.9965269F, 0.9965208F, 1F);
+                s += new Vector4(0.00336F, 0.0034731F, 0.00287F, 0F);
+                destination[i] = s;
+            }
+        }
+        else
+        {
+            // Scalar fallback if SIMD is not supported
+            for (int i = 0; i < source.Length; i++)
+            {
+                Vector4 s = source[i];
+                s *= new Vector4(0.9965153F, 0.9965269F, 0.9965208F, 1F);
+                s += new Vector4(0.00336F, 0.0034731F, 0.00287F, 0F);
+                destination[i] = s;
+            }
+        }
+    }
+
+    private static void AdjustPcsToV2BlackPoint(Span<Vector4> source, Span<Vector4> destination)
+    {
+        if (Vector.IsHardwareAccelerated && Vector<float>.IsSupported &&
+            Vector<float>.Count <= Vector512<float>.Count &&
+            source.Length * 4 >= Vector<float>.Count)
+        {
+            // TODO: Check our constants. They may require scaling.
+            Vector<float> vScale = new(PcsV2ToBlackPointScale.AsSpan()[..Vector<float>.Count]);
+            Vector<float> vOffset = new(PcsV2ToBlackPointOffset.AsSpan()[..Vector<float>.Count]);
+
+            // SIMD loop
+            int i = 0;
+            int simdBatchSize = Vector<float>.Count / 4; // Number of Vector4 elements per SIMD batch
+            for (; i <= source.Length - simdBatchSize; i += simdBatchSize)
+            {
+                // Load the vector from source span
+                Vector<float> v = Unsafe.ReadUnaligned<Vector<float>>(ref Unsafe.As<Vector4, byte>(ref source[i]));
+
+                // Scale and offset the vector
+                v *= vScale;
+                v -= vOffset;
+
+                // Write the vector to the destination span
+                Unsafe.WriteUnaligned(ref Unsafe.As<Vector4, byte>(ref destination[i]), v);
+            }
+
+            // Scalar fallback for remaining elements
+            for (; i < source.Length; i++)
+            {
+                Vector4 s = source[i];
+                s *= new Vector4(1.0034969F, 1.0034852F, 1.0034913F, 1F);
+                s -= new Vector4(0.0033717495F, 0.0034852044F, 0.0028800198F, 0F);
+                destination[i] = s;
+            }
+        }
+        else
+        {
+            // Scalar fallback if SIMD is not supported
+            for (int i = 0; i < source.Length; i++)
+            {
+                Vector4 s = source[i];
+                s *= new Vector4(1.0034969F, 1.0034852F, 1.0034913F, 1F);
+                s -= new Vector4(0.0033717495F, 0.0034852044F, 0.0028800198F, 0F);
+                destination[i] = s;
+            }
+        }
+    }
+
+    private static void ClipNegative(Span<Vector4> source)
+    {
+        if (Vector.IsHardwareAccelerated && Vector<float>.IsSupported && Vector<float>.Count >= source.Length * 4)
+        {
+            // SIMD loop
+            int i = 0;
+            int simdBatchSize = Vector<float>.Count / 4; // Number of Vector4 elements per SIMD batch
+            for (; i <= source.Length - simdBatchSize; i += simdBatchSize)
+            {
+                // Load the vector from source span
+                Vector<float> v = Unsafe.ReadUnaligned<Vector<float>>(ref Unsafe.As<Vector4, byte>(ref source[i]));
+
+                v = Vector.Max(v, Vector<float>.Zero);
+
+                // Write the vector to the destination span
+                Unsafe.WriteUnaligned(ref Unsafe.As<Vector4, byte>(ref source[i]), v);
+            }
+
+            // Scalar fallback for remaining elements
+            for (; i < source.Length; i++)
+            {
+                ref Vector4 s = ref source[i];
+                s = Vector4.Max(s, Vector4.Zero);
+            }
+        }
+        else
+        {
+            // Scalar fallback if SIMD is not supported
+            for (int i = 0; i < source.Length; i++)
+            {
+                ref Vector4 s = ref source[i];
+                s = Vector4.Max(s, Vector4.Zero);
+            }
+        }
+    }
+
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    private static Vector4 LabToLabV2(Vector4 input)
+        => input * 65280F / 65535F;
+
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    private static Vector4 LabV2ToLab(Vector4 input)
+        => input * 65535F / 65280F;
+
+    private static void LabToLabV2(Span<Vector4> source, Span<Vector4> destination)
+        => LabToLab(source, destination, 65280F / 65535F);
+
+    private static void LabV2ToLab(Span<Vector4> source, Span<Vector4> destination)
+        => LabToLab(source, destination, 65535F / 65280F);
+
+    private static void LabToLab(Span<Vector4> source, Span<Vector4> destination, [ConstantExpected] float scale)
+    {
+        if (Vector.IsHardwareAccelerated && Vector<float>.IsSupported)
+        {
+            Vector<float> vScale = new(scale);
+            int i = 0;
+
+            // SIMD loop
+            int simdBatchSize = Vector<float>.Count / 4; // Number of Vector4 elements per SIMD batch
+            for (; i <= source.Length - simdBatchSize; i += simdBatchSize)
+            {
+                // Load the vector from source span
+                Vector<float> v = Unsafe.ReadUnaligned<Vector<float>>(ref Unsafe.As<Vector4, byte>(ref source[i]));
+
+                // Scale the vector
+                v *= vScale;
+
+                // Write the scaled vector to the destination span
+                Unsafe.WriteUnaligned(ref Unsafe.As<Vector4, byte>(ref destination[i]), v);
+            }
+
+            // Scalar fallback for remaining elements
+            for (; i < source.Length; i++)
+            {
+                destination[i] = source[i] * scale;
+            }
+        }
+        else
+        {
+            // Scalar fallback if SIMD is not supported
+            for (int i = 0; i < source.Length; i++)
+            {
+                destination[i] = source[i] * scale;
+            }
+        }
+    }
+
+    private class ConversionParams
+    {
+        private readonly IccProfile profile;
+
+        internal ConversionParams(IccProfile profile, bool toPcs)
+        {
+            this.profile = profile;
+            this.Converter = toPcs ? new IccDataToPcsConverter(profile) : new IccPcsToDataConverter(profile);
+        }
+
+        internal IccConverterBase Converter { get; }
+
+        internal IccProfileHeader Header => this.profile.Header;
+
+        internal IccRenderingIntent Intent => this.Header.RenderingIntent;
+
+        internal IccColorSpaceType PcsType => this.Header.ProfileConnectionSpace;
+
+        internal IccVersion Version => this.Header.Version;
+
+        internal bool HasV2PerceptualHandling => this.Intent == IccRenderingIntent.Perceptual && this.Version.Major == 2;
+
+        internal bool HasNoPerceptualHandling => this.Intent == IccRenderingIntent.Perceptual && this.Converter.IsTrc;
+
+        internal bool Is16BitLutEntry => this.Converter.Is16BitLutEntry;
+    }
+}
diff --git a/src/ImageSharp/ColorProfiles/ColorProfileConverterExtensionsRgbCieLab.cs b/src/ImageSharp/ColorProfiles/ColorProfileConverterExtensionsRgbCieLab.cs
index 415dd94c3f..badbcc6831 100644
--- a/src/ImageSharp/ColorProfiles/ColorProfileConverterExtensionsRgbCieLab.cs
+++ b/src/ImageSharp/ColorProfiles/ColorProfileConverterExtensionsRgbCieLab.cs
@@ -12,6 +12,11 @@ internal static class ColorProfileConverterExtensionsRgbCieLab
         where TFrom : struct, IColorProfile<TFrom, Rgb>
         where TTo : struct, IColorProfile<TTo, CieLab>
     {
+        if (converter.ShouldUseIccProfiles())
+        {
+            return converter.ConvertUsingIccProfile<TFrom, TTo>(source);
+        }
+
         ColorConversionOptions options = converter.Options;
 
         // Convert to input PCS
@@ -33,6 +38,12 @@ internal static class ColorProfileConverterExtensionsRgbCieLab
         where TFrom : struct, IColorProfile<TFrom, Rgb>
         where TTo : struct, IColorProfile<TTo, CieLab>
     {
+        if (converter.ShouldUseIccProfiles())
+        {
+            converter.ConvertUsingIccProfile(source, destination);
+            return;
+        }
+
         ColorConversionOptions options = converter.Options;
 
         // Convert to input PCS.
diff --git a/src/ImageSharp/ColorProfiles/ColorProfileConverterExtensionsRgbCieXyz.cs b/src/ImageSharp/ColorProfiles/ColorProfileConverterExtensionsRgbCieXyz.cs
index a13f645778..cd7d5e4d65 100644
--- a/src/ImageSharp/ColorProfiles/ColorProfileConverterExtensionsRgbCieXyz.cs
+++ b/src/ImageSharp/ColorProfiles/ColorProfileConverterExtensionsRgbCieXyz.cs
@@ -12,6 +12,11 @@ internal static class ColorProfileConverterExtensionsRgbCieXyz
         where TFrom : struct, IColorProfile<TFrom, Rgb>
         where TTo : struct, IColorProfile<TTo, CieXyz>
     {
+        if (converter.ShouldUseIccProfiles())
+        {
+            return converter.ConvertUsingIccProfile<TFrom, TTo>(source);
+        }
+
         ColorConversionOptions options = converter.Options;
 
         // Convert to input PCS
@@ -32,6 +37,12 @@ internal static class ColorProfileConverterExtensionsRgbCieXyz
         where TFrom : struct, IColorProfile<TFrom, Rgb>
         where TTo : struct, IColorProfile<TTo, CieXyz>
     {
+        if (converter.ShouldUseIccProfiles())
+        {
+            converter.ConvertUsingIccProfile(source, destination);
+            return;
+        }
+
         ColorConversionOptions options = converter.Options;
 
         // Convert to input PCS.
diff --git a/src/ImageSharp/ColorProfiles/ColorProfileConverterExtensionsRgbRgb.cs b/src/ImageSharp/ColorProfiles/ColorProfileConverterExtensionsRgbRgb.cs
index c1c75dea1b..2a4b64b1ca 100644
--- a/src/ImageSharp/ColorProfiles/ColorProfileConverterExtensionsRgbRgb.cs
+++ b/src/ImageSharp/ColorProfiles/ColorProfileConverterExtensionsRgbRgb.cs
@@ -12,6 +12,11 @@ internal static class ColorProfileConverterExtensionsRgbRgb
         where TFrom : struct, IColorProfile<TFrom, Rgb>
         where TTo : struct, IColorProfile<TTo, Rgb>
     {
+        if (converter.ShouldUseIccProfiles())
+        {
+            return converter.ConvertUsingIccProfile<TFrom, TTo>(source);
+        }
+
         ColorConversionOptions options = converter.Options;
 
         // Convert to input PCS
@@ -33,6 +38,12 @@ internal static class ColorProfileConverterExtensionsRgbRgb
         where TFrom : struct, IColorProfile<TFrom, Rgb>
         where TTo : struct, IColorProfile<TTo, Rgb>
     {
+        if (converter.ShouldUseIccProfiles())
+        {
+            converter.ConvertUsingIccProfile(source, destination);
+            return;
+        }
+
         ColorConversionOptions options = converter.Options;
 
         // Convert to input PCS.
diff --git a/src/ImageSharp/ColorProfiles/Hsl.cs b/src/ImageSharp/ColorProfiles/Hsl.cs
index 2c98c7df99..7a9365fb75 100644
--- a/src/ImageSharp/ColorProfiles/Hsl.cs
+++ b/src/ImageSharp/ColorProfiles/Hsl.cs
@@ -41,6 +41,16 @@ public readonly struct Hsl : IColorProfile<Hsl, Rgb>
         this.L = vector.Z;
     }
 
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+#pragma warning disable SA1313 // Parameter names should begin with lower-case letter
+    private Hsl(Vector3 vector, bool _)
+#pragma warning restore SA1313 // Parameter names should begin with lower-case letter
+    {
+        this.H = vector.X;
+        this.S = vector.Y;
+        this.L = vector.Z;
+    }
+
     /// <summary>
     /// Gets the hue component.
     /// <remarks>A value ranging between 0 and 360.</remarks>
@@ -83,6 +93,38 @@ public readonly struct Hsl : IColorProfile<Hsl, Rgb>
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
     public static bool operator !=(Hsl left, Hsl right) => !left.Equals(right);
 
+    /// <inheritdoc/>
+    public Vector4 ToScaledVector4()
+        => new(this.AsVector3Unsafe() / 360F, 1F);
+
+    /// <inheritdoc/>
+    public static Hsl FromScaledVector4(Vector4 source)
+        => new(source.AsVector3() * 360F, true);
+
+    /// <inheritdoc/>
+    public static void ToScaledVector4(ReadOnlySpan<Hsl> source, Span<Vector4> destination)
+    {
+        Guard.DestinationShouldNotBeTooShort(source, destination, nameof(destination));
+
+        // TODO: Optimize via SIMD
+        for (int i = 0; i < source.Length; i++)
+        {
+            destination[i] = source[i].ToScaledVector4();
+        }
+    }
+
+    /// <inheritdoc/>
+    public static void FromScaledVector4(ReadOnlySpan<Vector4> source, Span<Hsl> destination)
+    {
+        Guard.DestinationShouldNotBeTooShort(source, destination, nameof(destination));
+
+        // TODO: Optimize via SIMD
+        for (int i = 0; i < source.Length; i++)
+        {
+            destination[i] = FromScaledVector4(source[i]);
+        }
+    }
+
     /// <inheritdoc/>
     public static Hsl FromProfileConnectingSpace(ColorConversionOptions options, in Rgb source)
     {
diff --git a/src/ImageSharp/ColorProfiles/Hsv.cs b/src/ImageSharp/ColorProfiles/Hsv.cs
index 7535f2463d..1e013fe1fb 100644
--- a/src/ImageSharp/ColorProfiles/Hsv.cs
+++ b/src/ImageSharp/ColorProfiles/Hsv.cs
@@ -41,6 +41,16 @@ public readonly struct Hsv : IColorProfile<Hsv, Rgb>
         this.V = vector.Z;
     }
 
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+#pragma warning disable SA1313 // Parameter names should begin with lower-case letter
+    private Hsv(Vector3 vector, bool _)
+#pragma warning restore SA1313 // Parameter names should begin with lower-case letter
+    {
+        this.H = vector.X;
+        this.S = vector.Y;
+        this.V = vector.Z;
+    }
+
     /// <summary>
     /// Gets the hue component.
     /// <remarks>A value ranging between 0 and 360.</remarks>
@@ -81,6 +91,38 @@ public readonly struct Hsv : IColorProfile<Hsv, Rgb>
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
     public static bool operator !=(Hsv left, Hsv right) => !left.Equals(right);
 
+    /// <inheritdoc/>
+    public Vector4 ToScaledVector4()
+        => new(this.AsVector3Unsafe() / 360F, 1F);
+
+    /// <inheritdoc/>
+    public static Hsv FromScaledVector4(Vector4 source)
+        => new(source.AsVector3() * 360F, true);
+
+    /// <inheritdoc/>
+    public static void ToScaledVector4(ReadOnlySpan<Hsv> source, Span<Vector4> destination)
+    {
+        Guard.DestinationShouldNotBeTooShort(source, destination, nameof(destination));
+
+        // TODO: Optimize via SIMD
+        for (int i = 0; i < source.Length; i++)
+        {
+            destination[i] = source[i].ToScaledVector4();
+        }
+    }
+
+    /// <inheritdoc/>
+    public static void FromScaledVector4(ReadOnlySpan<Vector4> source, Span<Hsv> destination)
+    {
+        Guard.DestinationShouldNotBeTooShort(source, destination, nameof(destination));
+
+        // TODO: Optimize via SIMD
+        for (int i = 0; i < source.Length; i++)
+        {
+            destination[i] = FromScaledVector4(source[i]);
+        }
+    }
+
     /// <inheritdoc/>
     public static Hsv FromProfileConnectingSpace(ColorConversionOptions options, in Rgb source)
     {
diff --git a/src/ImageSharp/ColorProfiles/HunterLab.cs b/src/ImageSharp/ColorProfiles/HunterLab.cs
index 43ad2ac5c0..e978c6de22 100644
--- a/src/ImageSharp/ColorProfiles/HunterLab.cs
+++ b/src/ImageSharp/ColorProfiles/HunterLab.cs
@@ -80,6 +80,49 @@ public readonly struct HunterLab : IColorProfile<HunterLab, CieXyz>
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
     public static bool operator !=(HunterLab left, HunterLab right) => !left.Equals(right);
 
+    /// <inheritdoc/>
+    public Vector4 ToScaledVector4()
+    {
+        Vector3 v3 = default;
+        v3 += this.AsVector3Unsafe();
+        v3 += new Vector3(0, 128F, 128F);
+        v3 /= new Vector3(100F, 255F, 255F);
+        return new Vector4(v3, 1F);
+    }
+
+    /// <inheritdoc/>
+    public static HunterLab FromScaledVector4(Vector4 source)
+    {
+        Vector3 v3 = source.AsVector3();
+        v3 *= new Vector3(100F, 255, 255);
+        v3 -= new Vector3(0, 128F, 128F);
+        return new HunterLab(v3);
+    }
+
+    /// <inheritdoc/>
+    public static void ToScaledVector4(ReadOnlySpan<HunterLab> source, Span<Vector4> destination)
+    {
+        Guard.DestinationShouldNotBeTooShort(source, destination, nameof(destination));
+
+        // TODO: Optimize via SIMD
+        for (int i = 0; i < source.Length; i++)
+        {
+            destination[i] = source[i].ToScaledVector4();
+        }
+    }
+
+    /// <inheritdoc/>
+    public static void FromScaledVector4(ReadOnlySpan<Vector4> source, Span<HunterLab> destination)
+    {
+        Guard.DestinationShouldNotBeTooShort(source, destination, nameof(destination));
+
+        // TODO: Optimize via SIMD
+        for (int i = 0; i < source.Length; i++)
+        {
+            destination[i] = FromScaledVector4(source[i]);
+        }
+    }
+
     /// <inheritdoc/>
     public static HunterLab FromProfileConnectingSpace(ColorConversionOptions options, in CieXyz source)
     {
@@ -127,7 +170,7 @@ public readonly struct HunterLab : IColorProfile<HunterLab, CieXyz>
     {
         // Conversion algorithm described here:
         // http://en.wikipedia.org/wiki/Lab_color_space#Hunter_Lab
-        CieXyz whitePoint = options.WhitePoint;
+        CieXyz whitePoint = options.SourceWhitePoint;
         float l = this.L, a = this.A, b = this.B;
         float xn = whitePoint.X, yn = whitePoint.Y, zn = whitePoint.Z;
 
diff --git a/src/ImageSharp/ColorProfiles/IColorProfile.cs b/src/ImageSharp/ColorProfiles/IColorProfile.cs
index 6a1b2ee8d0..425e030300 100644
--- a/src/ImageSharp/ColorProfiles/IColorProfile.cs
+++ b/src/ImageSharp/ColorProfiles/IColorProfile.cs
@@ -1,6 +1,8 @@
 // Copyright (c) Six Labors.
 // Licensed under the Six Labors Split License.
 
+using System.Numerics;
+
 namespace SixLabors.ImageSharp.ColorProfiles;
 
 /// <summary>
@@ -15,18 +17,60 @@ public interface IColorProfile
     public static abstract ChromaticAdaptionWhitePointSource GetChromaticAdaptionWhitePointSource();
 }
 
+/// <summary>
+/// Defines the contract for all color profiles.
+/// </summary>
+/// <typeparam name="TSelf">The type of color profile.</typeparam>
+public interface IColorProfile<TSelf> : IColorProfile, IEquatable<TSelf>
+    where TSelf : IColorProfile<TSelf>
+{
+    /// <summary>
+    /// Expands the pixel into a generic ("scaled") <see cref="Vector4"/> representation
+    /// with values scaled and clamped between <value>0</value> and <value>1</value>.
+    /// The vector components are typically expanded in least to greatest significance order.
+    /// </summary>
+    /// <returns>The <see cref="Vector4"/>.</returns>
+    public Vector4 ToScaledVector4();
+
+#pragma warning disable CA1000 // Do not declare static members on generic types
+    /// <summary>
+    /// Initializes the color instance from a generic a generic ("scaled") <see cref="Vector4"/> representation
+    /// with values scaled and clamped between <value>0</value> and <value>1</value>.
+    /// </summary>
+    /// <param name="source">The vector to load the pixel from.</param>
+    /// <returns>The <typeparamref name="TSelf"/>.</returns>
+    public static abstract TSelf FromScaledVector4(Vector4 source);
+
+    /// <summary>
+    /// Converts the span of colors to a generic ("scaled") <see cref="Vector4"/> representation
+    /// with values scaled and clamped between <value>0</value> and <value>1</value>.
+    /// </summary>
+    /// <param name="source">The color span to convert from.</param>
+    /// <param name="destination">The vector span to write the results to.</param>
+    public static abstract void ToScaledVector4(ReadOnlySpan<TSelf> source, Span<Vector4> destination);
+
+    /// <summary>
+    /// Converts the span of colors from a generic ("scaled") <see cref="Vector4"/> representation
+    /// with values scaled and clamped between <value>0</value> and <value>1</value>.
+    /// </summary>
+    /// <param name="source">The vector span to convert from.</param>
+    /// <param name="destination">The color span to write the results to.</param>
+    public static abstract void FromScaledVector4(ReadOnlySpan<Vector4> source, Span<TSelf> destination);
+#pragma warning restore CA1000 // Do not declare static members on generic types
+}
+
 /// <summary>
 /// Defines the contract for all color profiles.
 /// </summary>
 /// <typeparam name="TSelf">The type of color profile.</typeparam>
 /// <typeparam name="TProfileSpace">The type of color profile connecting space.</typeparam>
-public interface IColorProfile<TSelf, TProfileSpace> : IColorProfile, IEquatable<TSelf>
+public interface IColorProfile<TSelf, TProfileSpace> : IColorProfile<TSelf>
     where TSelf : IColorProfile<TSelf, TProfileSpace>
     where TProfileSpace : struct, IProfileConnectingSpace
 {
 #pragma warning disable CA1000 // Do not declare static members on generic types
     /// <summary>
-    /// Converts the color from the profile connection space.
+    /// Initializes the color instance from the profile connection space.
     /// </summary>
     /// <param name="options">The color profile conversion options.</param>
     /// <param name="source">The color profile connecting space.</param>
diff --git a/src/ImageSharp/ColorProfiles/Icc/Calculators/ClutCalculator.cs b/src/ImageSharp/ColorProfiles/Icc/Calculators/ClutCalculator.cs
new file mode 100644
index 0000000000..82d475e578
--- /dev/null
+++ b/src/ImageSharp/ColorProfiles/Icc/Calculators/ClutCalculator.cs
@@ -0,0 +1,506 @@
+// Copyright (c) Six Labors.
+// Licensed under the Six Labors Split License.
+
+using System.Numerics;
+using SixLabors.ImageSharp.Metadata.Profiles.Icc;
+
+namespace SixLabors.ImageSharp.ColorProfiles.Icc.Calculators;
+
+/// <summary>
+/// Implements interpolation methods for color profile lookup tables.
+/// Adapted from ICC Reference implementation:
+/// https://github.com/InternationalColorConsortium/DemoIccMAX/blob/79ecb74135ad47bac7d42692905a079839b7e105/IccProfLib/IccTagLut.cpp
+/// </summary>
+internal class ClutCalculator : IVector4Calculator
+{
+    private readonly int inputCount;
+    private readonly int outputCount;
+    private readonly float[] lut;
+    private readonly byte[] gridPointCount;
+    private readonly byte[] maxGridPoint;
+    private readonly int[] indexFactor;
+    private readonly int[] dimSize;
+    private readonly int nodeCount;
+    private readonly float[][] nodes;
+    private readonly float[] g;
+    private readonly uint[] ig;
+    private readonly float[] s;
+    private readonly float[] df;
+    private readonly uint[] nPower;
+    private int n000;
+    private int n001;
+    private int n010;
+    private int n011;
+    private int n100;
+    private int n101;
+    private int n110;
+    private int n111;
+    private int n1000;
+
+    public ClutCalculator(IccClut clut)
+    {
+        Guard.NotNull(clut, nameof(clut));
+        Guard.MustBeGreaterThan(clut.InputChannelCount, 0, nameof(clut.InputChannelCount));
+        Guard.MustBeGreaterThan(clut.OutputChannelCount, 0, nameof(clut.OutputChannelCount));
+
+        this.inputCount = clut.InputChannelCount;
+        this.outputCount = clut.OutputChannelCount;
+        this.g = new float[this.inputCount];
+        this.ig = new uint[this.inputCount];
+        this.s = new float[this.inputCount];
+        this.nPower = new uint[16];
+        this.lut = clut.Values;
+        this.nodeCount = (int)Math.Pow(2, clut.InputChannelCount);
+        this.df = new float[this.nodeCount];
+        this.nodes = new float[this.nodeCount][];
+        this.dimSize = new int[this.inputCount];
+        this.gridPointCount = clut.GridPointCount;
+        this.maxGridPoint = new byte[this.inputCount];
+        for (int i = 0; i < this.inputCount; i++)
+        {
+            this.maxGridPoint[i] = (byte)(this.gridPointCount[i] - 1);
+        }
+
+        this.dimSize[this.inputCount - 1] = this.outputCount;
+        for (int i = this.inputCount - 2; i >= 0; i--)
+        {
+            this.dimSize[i] = this.dimSize[i + 1] * this.gridPointCount[i + 1];
+        }
+
+        this.indexFactor = this.CalculateIndexFactor();
+    }
+
+    public unsafe Vector4 Calculate(Vector4 value)
+    {
+        Vector4 result = default;
+        switch (this.inputCount)
+        {
+            case 1:
+                this.Interpolate1d((float*)&value, (float*)&result);
+                break;
+            case 2:
+                this.Interpolate2d((float*)&value, (float*)&result);
+                break;
+            case 3:
+                this.Interpolate3d((float*)&value, (float*)&result);
+                break;
+            case 4:
+                this.Interpolate4d((float*)&value, (float*)&result);
+                break;
+            default:
+                this.InterpolateNd((float*)&value, (float*)&result);
+                break;
+        }
+
+        return result;
+    }
+
+    private int[] CalculateIndexFactor()
+    {
+        int[] factors = new int[16];
+        switch (this.inputCount)
+        {
+            case 1:
+                factors[0] = this.n000 = 0;
+                factors[1] = this.n001 = this.dimSize[0];
+                break;
+            case 2:
+                factors[0] = this.n000 = 0;
+                factors[1] = this.n001 = this.dimSize[0];
+                factors[2] = this.n010 = this.dimSize[1];
+                factors[3] = this.n011 = this.n001 + this.n010;
+                break;
+            case 3:
+                factors[0] = this.n000 = 0;
+                factors[1] = this.n001 = this.dimSize[0];
+                factors[2] = this.n010 = this.dimSize[1];
+                factors[3] = this.n011 = this.n001 + this.n010;
+                factors[4] = this.n100 = this.dimSize[2];
+                factors[5] = this.n101 = this.n100 + this.n001;
+                factors[6] = this.n110 = this.n100 + this.n010;
+                factors[7] = this.n111 = this.n110 + this.n001;
+                break;
+            case 4:
+                factors[0] = 0;
+                factors[1] = this.n001 = this.dimSize[0];
+                factors[2] = this.n010 = this.dimSize[1];
+                factors[3] = factors[2] + factors[1];
+                factors[4] = this.n100 = this.dimSize[2];
+                factors[5] = factors[4] + factors[1];
+                factors[6] = factors[4] + factors[2];
+                factors[7] = factors[4] + factors[3];
+                factors[8] = this.n1000 = this.dimSize[3];
+                factors[9] = factors[8] + factors[1];
+                factors[10] = factors[8] + factors[2];
+                factors[11] = factors[8] + factors[3];
+                factors[12] = factors[8] + factors[4];
+                factors[13] = factors[8] + factors[5];
+                factors[14] = factors[8] + factors[6];
+                factors[15] = factors[8] + factors[7];
+                break;
+            default:
+                // Initialize ND interpolation variables.
+                factors[0] = 0;
+                int count;
+                for (count = 0; count < this.inputCount; count++)
+                {
+                    this.nPower[count] = (uint)(1 << (this.inputCount - 1 - count));
+                }
+
+                uint[] nPower = [0, 1];
+                count = 0;
+                int nFlag = 1;
+                for (uint j = 1; j < this.nodeCount; j++)
+                {
+                    if (j == nPower[1])
+                    {
+                        factors[j] = this.dimSize[count];
+                        nPower[0] = (uint)(1 << count);
+                        count++;
+                        nPower[1] = (uint)(1 << count);
+                        nFlag = 1;
+                    }
+                    else
+                    {
+                        factors[j] = factors[nPower[0]] + factors[nFlag];
+                        nFlag++;
+                    }
+                }
+
+                break;
+        }
+
+        return factors;
+    }
+
+    /// <summary>
+    /// One dimensional interpolation function.
+    /// </summary>
+    /// <param name="srcPixel">The input pixel values, which will be interpolated.</param>
+    /// <param name="destPixel">The interpolated output pixels.</param>
+    private unsafe void Interpolate1d(float* srcPixel, float* destPixel)
+    {
+        byte mx = this.maxGridPoint[0];
+
+        float x = UnitClip(srcPixel[0]) * mx;
+
+        uint ix = (uint)x;
+
+        float u = x - ix;
+
+        if (ix == mx)
+        {
+            ix--;
+            u = 1.0f;
+        }
+
+        float nu = (float)(1.0 - u);
+
+        int i;
+        Span<float> p = this.lut.AsSpan((int)(ix * this.n001));
+
+        // Normalize grid units.
+        float dF0 = nu;
+        float dF1 = u;
+
+        int offset = 0;
+        for (i = 0; i < this.outputCount; i++)
+        {
+            destPixel[i] = (float)((p[offset + this.n000] * dF0) + (p[offset + this.n001] * dF1));
+            offset++;
+        }
+    }
+
+    /// <summary>
+    /// Two dimensional interpolation function.
+    /// </summary>
+    /// <param name="srcPixel">The input pixel values, which will be interpolated.</param>
+    /// <param name="destPixel">The interpolated output pixels.</param>
+    private unsafe void Interpolate2d(float* srcPixel, float* destPixel)
+    {
+        byte mx = this.maxGridPoint[0];
+        byte my = this.maxGridPoint[1];
+
+        float x = UnitClip(srcPixel[0]) * mx;
+        float y = UnitClip(srcPixel[1]) * my;
+
+        uint ix = (uint)x;
+        uint iy = (uint)y;
+
+        float u = x - ix;
+        float t = y - iy;
+
+        if (ix == mx)
+        {
+            ix--;
+            u = 1.0f;
+        }
+
+        if (iy == my)
+        {
+            iy--;
+            t = 1.0f;
+        }
+
+        float nt = (float)(1.0 - t);
+        float nu = (float)(1.0 - u);
+
+        int i;
+        Span<float> p = this.lut.AsSpan((int)((ix * this.n001) + (iy * this.n010)));
+
+        // Normalize grid units.
+        float dF0 = nt * nu;
+        float dF1 = nt * u;
+        float dF2 = t * nu;
+        float dF3 = t * u;
+
+        int offset = 0;
+        for (i = 0; i < this.outputCount; i++)
+        {
+            destPixel[i] = (float)((p[offset + this.n000] * dF0) + (p[offset + this.n001] * dF1) + (p[offset + this.n010] * dF2) + (p[offset + this.n011] * dF3));
+            offset++;
+        }
+    }
+
+    /// <summary>
+    /// Three dimensional interpolation function.
+    /// </summary>
+    /// <param name="srcPixel">The input pixel values, which will be interpolated.</param>
+    /// <param name="destPixel">The interpolated output pixels.</param>
+    private unsafe void Interpolate3d(float* srcPixel, float* destPixel)
+    {
+        byte mx = this.maxGridPoint[0];
+        byte my = this.maxGridPoint[1];
+        byte mz = this.maxGridPoint[2];
+
+        float x = UnitClip(srcPixel[0]) * mx;
+        float y = UnitClip(srcPixel[1]) * my;
+        float z = UnitClip(srcPixel[2]) * mz;
+
+        uint ix = (uint)x;
+        uint iy = (uint)y;
+        uint iz = (uint)z;
+
+        float u = x - ix;
+        float t = y - iy;
+        float s = z - iz;
+
+        if (ix == mx)
+        {
+            ix--;
+            u = 1.0f;
+        }
+
+        if (iy == my)
+        {
+            iy--;
+            t = 1.0f;
+        }
+
+        if (iz == mz)
+        {
+            iz--;
+            s = 1.0f;
+        }
+
+        float ns = (float)(1.0 - s);
+        float nt = (float)(1.0 - t);
+        float nu = (float)(1.0 - u);
+
+        Span<float> p = this.lut.AsSpan((int)((ix * this.n001) + (iy * this.n010) + (iz * this.n100)));
+
+        // Normalize grid units
+        float dF0 = ns * nt * nu;
+        float dF1 = ns * nt * u;
+        float dF2 = ns * t * nu;
+        float dF3 = ns * t * u;
+        float dF4 = s * nt * nu;
+        float dF5 = s * nt * u;
+        float dF6 = s * t * nu;
+        float dF7 = s * t * u;
+
+        int offset = 0;
+        for (int i = 0; i < this.outputCount; i++)
+        {
+            destPixel[i] = (float)((p[offset + this.n000] * dF0) +
+                                   (p[offset + this.n001] * dF1) +
+                                   (p[offset + this.n010] * dF2) +
+                                   (p[offset + this.n011] * dF3) +
+                                   (p[offset + this.n100] * dF4) +
+                                   (p[offset + this.n101] * dF5) +
+                                   (p[offset + this.n110] * dF6) +
+                                   (p[offset + this.n111] * dF7));
+            offset++;
+        }
+    }
+
+    /// <summary>
+    /// Four dimensional interpolation function.
+    /// </summary>
+    /// <param name="srcPixel">The input pixel values, which will be interpolated.</param>
+    /// <param name="destPixel">The interpolated output pixels.</param>
+    private unsafe void Interpolate4d(float* srcPixel, float* destPixel)
+    {
+        byte mw = this.maxGridPoint[0];
+        byte mx = this.maxGridPoint[1];
+        byte my = this.maxGridPoint[2];
+        byte mz = this.maxGridPoint[3];
+
+        float w = UnitClip(srcPixel[0]) * mw;
+        float x = UnitClip(srcPixel[1]) * mx;
+        float y = UnitClip(srcPixel[2]) * my;
+        float z = UnitClip(srcPixel[3]) * mz;
+
+        uint iw = (uint)w;
+        uint ix = (uint)x;
+        uint iy = (uint)y;
+        uint iz = (uint)z;
+
+        float v = w - iw;
+        float u = x - ix;
+        float t = y - iy;
+        float s = z - iz;
+
+        if (iw == mw)
+        {
+            iw--;
+            v = 1.0f;
+        }
+
+        if (ix == mx)
+        {
+            ix--;
+            u = 1.0f;
+        }
+
+        if (iy == my)
+        {
+            iy--;
+            t = 1.0f;
+        }
+
+        if (iz == mz)
+        {
+            iz--;
+            s = 1.0f;
+        }
+
+        float ns = (float)(1.0 - s);
+        float nt = (float)(1.0 - t);
+        float nu = (float)(1.0 - u);
+        float nv = (float)(1.0 - v);
+
+        Span<float> p = this.lut.AsSpan((int)((iw * this.n001) + (ix * this.n010) + (iy * this.n100) + (iz * this.n1000)));
+
+        // Normalize grid units.
+        float[] dF =
+        [
+            ns * nt * nu * nv,
+            ns * nt * nu * v,
+            ns * nt * u * nv,
+            ns * nt * u * v,
+            ns * t * nu * nv,
+            ns * t * nu * v,
+            ns * t * u * nv,
+            ns * t * u * v,
+            s * nt * nu * nv,
+            s * nt * nu * v,
+            s * nt * u * nv,
+            s * nt * u * v,
+            s * t * nu * nv,
+            s * t * nu * v,
+            s * t * u * nv,
+            s * t * u * v,
+        ];
+
+        int offset = 0;
+        for (int i = 0; i < this.outputCount; i++)
+        {
+            float pv = 0.0f;
+            for (int j = 0; j < 16; j++)
+            {
+                pv += p[offset + this.indexFactor[j]] * dF[j];
+            }
+
+            destPixel[i] = pv;
+            offset++;
+        }
+    }
+
+    /// <summary>
+    /// Generic N-dimensional interpolation function.
+    /// </summary>
+    /// <param name="srcPixel">The input pixel values, which will be interpolated.</param>
+    /// <param name="destPixel">The interpolated output pixels.</param>
+    private unsafe void InterpolateNd(float* srcPixel, float* destPixel)
+    {
+        int index = 0;
+        for (int i = 0; i < this.inputCount; i++)
+        {
+            this.g[i] = UnitClip(srcPixel[i]) * this.maxGridPoint[i];
+            this.ig[i] = (uint)this.g[i];
+            this.s[this.inputCount - 1 - i] = this.g[i] - this.ig[i];
+            if (this.ig[i] == this.maxGridPoint[i])
+            {
+                this.ig[i]--;
+                this.s[this.inputCount - 1 - i] = 1.0f;
+            }
+
+            index += (int)this.ig[i] * this.dimSize[i];
+        }
+
+        Span<float> p = this.lut.AsSpan(index);
+        float[] temp = new float[2];
+        bool nFlag = false;
+
+        for (int i = 0; i < this.nodeCount; i++)
+        {
+            this.df[i] = 1.0f;
+        }
+
+        for (int i = 0; i < this.inputCount; i++)
+        {
+            temp[0] = 1.0f - this.s[i];
+            temp[1] = this.s[i];
+            index = (int)this.nPower[i];
+            for (int j = 0; j < this.nodeCount; j++)
+            {
+                this.df[j] *= temp[nFlag ? 1 : 0];
+                if ((j + 1) % index == 0)
+                {
+                    nFlag = !nFlag;
+                }
+            }
+
+            nFlag = false;
+        }
+
+        int offset = 0;
+        for (int i = 0; i < this.outputCount; i++)
+        {
+            float pv = 0;
+            for (int j = 0; j < this.nodeCount; j++)
+            {
+                pv += p[offset + this.indexFactor[j]] * this.df[j];
+            }
+
+            destPixel[i] = pv;
+            offset++;
+        }
+    }
+
+    private static float UnitClip(float v)
+    {
+        if (v < 0)
+        {
+            return 0;
+        }
+
+        if (v > 1.0)
+        {
+            return 1.0f;
+        }
+
+        return v;
+    }
+}
diff --git a/src/ImageSharp/ColorProfiles/Icc/Calculators/ColorTrcCalculator.cs b/src/ImageSharp/ColorProfiles/Icc/Calculators/ColorTrcCalculator.cs
new file mode 100644
index 0000000000..01c66881a1
--- /dev/null
+++ b/src/ImageSharp/ColorProfiles/Icc/Calculators/ColorTrcCalculator.cs
@@ -0,0 +1,65 @@
+// Copyright (c) Six Labors.
+// Licensed under the Six Labors Split License.
+
+using System.Numerics;
+using System.Runtime.CompilerServices;
+using SixLabors.ImageSharp.Metadata.Profiles.Icc;
+
+namespace SixLabors.ImageSharp.ColorProfiles.Icc.Calculators;
+
+internal class ColorTrcCalculator : IVector4Calculator
+{
+    private readonly TrcCalculator curveCalculator;
+    private readonly Matrix4x4 matrix;
+    private readonly bool toPcs;
+
+    public ColorTrcCalculator(
+        IccXyzTagDataEntry redMatrixColumn,
+        IccXyzTagDataEntry greenMatrixColumn,
+        IccXyzTagDataEntry blueMatrixColumn,
+        IccTagDataEntry redTrc,
+        IccTagDataEntry greenTrc,
+        IccTagDataEntry blueTrc,
+        bool toPcs)
+    {
+        this.toPcs = toPcs;
+        this.curveCalculator = new TrcCalculator([redTrc, greenTrc, blueTrc], !toPcs);
+
+        Vector3 mr = redMatrixColumn.Data[0];
+        Vector3 mg = greenMatrixColumn.Data[0];
+        Vector3 mb = blueMatrixColumn.Data[0];
+        this.matrix = new Matrix4x4(mr.X, mr.Y, mr.Z, 0, mg.X, mg.Y, mg.Z, 0, mb.X, mb.Y, mb.Z, 0, 0, 0, 0, 1);
+
+        if (!toPcs)
+        {
+            Matrix4x4.Invert(this.matrix, out this.matrix);
+        }
+    }
+
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public Vector4 Calculate(Vector4 value)
+    {
+        if (this.toPcs)
+        {
+            // input is always linear RGB
+            value = this.curveCalculator.Calculate(value);
+            CieXyz xyz = new(Vector4.Transform(value, this.matrix).AsVector3());
+
+            // when data to PCS, output from calculator is descaled XYZ
+            // but downstream process requires scaled XYZ
+            // (see DemoMaxICC IccCmm.cpp : CIccXformMatrixTRC::Apply)
+            return xyz.ToScaledVector4();
+        }
+        else
+        {
+            // input is always XYZ
+            Vector4 xyz = Vector4.Transform(value, this.matrix);
+
+            // when data to PCS, upstream process provides scaled XYZ
+            // but input to calculator is descaled XYZ
+            // (see DemoMaxICC IccCmm.cpp : CIccXformMatrixTRC::Apply)
+            xyz = new Vector4(CieXyz.FromScaledVector4(xyz).AsVector3Unsafe(), 1);
+            return this.curveCalculator.Calculate(xyz);
+        }
+    }
+}
diff --git a/src/ImageSharp/ColorProfiles/Icc/Calculators/CurveCalculator.CalculationType.cs b/src/ImageSharp/ColorProfiles/Icc/Calculators/CurveCalculator.CalculationType.cs
new file mode 100644
index 0000000000..d035bd1793
--- /dev/null
+++ b/src/ImageSharp/ColorProfiles/Icc/Calculators/CurveCalculator.CalculationType.cs
@@ -0,0 +1,14 @@
+// Copyright (c) Six Labors.
+// Licensed under the Six Labors Split License.
+
+namespace SixLabors.ImageSharp.ColorProfiles.Conversion.Icc;
+
+internal partial class CurveCalculator
+{
+    private enum CalculationType
+    {
+        Identity,
+        Gamma,
+        Lut,
+    }
+}
diff --git a/src/ImageSharp/ColorProfiles/Icc/Calculators/CurveCalculator.cs b/src/ImageSharp/ColorProfiles/Icc/Calculators/CurveCalculator.cs
new file mode 100644
index 0000000000..c39eaf958f
--- /dev/null
+++ b/src/ImageSharp/ColorProfiles/Icc/Calculators/CurveCalculator.cs
@@ -0,0 +1,47 @@
+// Copyright (c) Six Labors.
+// Licensed under the Six Labors Split License.
+#nullable disable
+
+using SixLabors.ImageSharp.ColorProfiles.Icc.Calculators;
+using SixLabors.ImageSharp.Metadata.Profiles.Icc;
+
+namespace SixLabors.ImageSharp.ColorProfiles.Conversion.Icc;
+
+internal partial class CurveCalculator : ISingleCalculator
+{
+    private readonly LutCalculator lutCalculator;
+    private readonly float gamma;
+    private readonly CalculationType type;
+
+    public CurveCalculator(IccCurveTagDataEntry entry, bool inverted)
+    {
+        if (entry.IsIdentityResponse)
+        {
+            this.type = CalculationType.Identity;
+        }
+        else if (entry.IsGamma)
+        {
+            this.gamma = entry.Gamma;
+            if (inverted)
+            {
+                this.gamma = 1f / this.gamma;
+            }
+
+            this.type = CalculationType.Gamma;
+        }
+        else
+        {
+            this.lutCalculator = new LutCalculator(entry.CurveData, inverted);
+            this.type = CalculationType.Lut;
+        }
+    }
+
+    public float Calculate(float value)
+        => this.type switch
+        {
+            CalculationType.Identity => value,
+            CalculationType.Gamma => MathF.Pow(value, this.gamma), // TODO: This could be optimized using a LUT. See SrgbCompanding
+            CalculationType.Lut => this.lutCalculator.Calculate(value),
+            _ => throw new InvalidOperationException("Invalid calculation type"),
+        };
+}
diff --git a/src/ImageSharp/ColorProfiles/Icc/Calculators/GrayTrcCalculator.cs b/src/ImageSharp/ColorProfiles/Icc/Calculators/GrayTrcCalculator.cs
new file mode 100644
index 0000000000..8d823c1e95
--- /dev/null
+++ b/src/ImageSharp/ColorProfiles/Icc/Calculators/GrayTrcCalculator.cs
@@ -0,0 +1,19 @@
+// Copyright (c) Six Labors.
+// Licensed under the Six Labors Split License.
+
+using System.Numerics;
+using System.Runtime.CompilerServices;
+using SixLabors.ImageSharp.Metadata.Profiles.Icc;
+
+namespace SixLabors.ImageSharp.ColorProfiles.Icc.Calculators;
+
+internal class GrayTrcCalculator : IVector4Calculator
+{
+    private readonly TrcCalculator calculator;
+
+    public GrayTrcCalculator(IccTagDataEntry grayTrc, bool toPcs)
+        => this.calculator = new TrcCalculator(new IccTagDataEntry[] { grayTrc }, !toPcs);
+
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public Vector4 Calculate(Vector4 value) => this.calculator.Calculate(value);
+}
diff --git a/src/ImageSharp/ColorProfiles/Icc/Calculators/ISingleCalculator.cs b/src/ImageSharp/ColorProfiles/Icc/Calculators/ISingleCalculator.cs
new file mode 100644
index 0000000000..ce9b7d2f9b
--- /dev/null
+++ b/src/ImageSharp/ColorProfiles/Icc/Calculators/ISingleCalculator.cs
@@ -0,0 +1,17 @@
+// Copyright (c) Six Labors.
+// Licensed under the Six Labors Split License.
+
+namespace SixLabors.ImageSharp.ColorProfiles.Icc.Calculators;
+
+/// <summary>
+/// Represents an ICC calculator with a single floating point value and result
+/// </summary>
+internal interface ISingleCalculator
+{
+    /// <summary>
+    /// Calculates a result from the given value
+    /// </summary>
+    /// <param name="value">The input value</param>
+    /// <returns>The calculated result</returns>
+    float Calculate(float value);
+}
diff --git a/src/ImageSharp/ColorProfiles/Icc/Calculators/IVector4Calculator.cs b/src/ImageSharp/ColorProfiles/Icc/Calculators/IVector4Calculator.cs
new file mode 100644
index 0000000000..9beea79503
--- /dev/null
+++ b/src/ImageSharp/ColorProfiles/Icc/Calculators/IVector4Calculator.cs
@@ -0,0 +1,19 @@
+// Copyright (c) Six Labors.
+// Licensed under the Six Labors Split License.
+
+using System.Numerics;
+
+namespace SixLabors.ImageSharp.ColorProfiles.Icc.Calculators;
+
+/// <summary>
+/// Represents an ICC calculator with <see cref="Vector4"/> values and results
+/// </summary>
+internal interface IVector4Calculator
+{
+    /// <summary>
+    /// Calculates a result from the given values
+    /// </summary>
+    /// <param name="value">The input values</param>
+    /// <returns>The calculated result</returns>
+    Vector4 Calculate(Vector4 value);
+}
diff --git a/src/ImageSharp/ColorProfiles/Icc/Calculators/LutABCalculator.CalculationType.cs b/src/ImageSharp/ColorProfiles/Icc/Calculators/LutABCalculator.CalculationType.cs
new file mode 100644
index 0000000000..253239cb79
--- /dev/null
+++ b/src/ImageSharp/ColorProfiles/Icc/Calculators/LutABCalculator.CalculationType.cs
@@ -0,0 +1,18 @@
+// Copyright (c) Six Labors.
+// Licensed under the Six Labors Split License.
+
+namespace SixLabors.ImageSharp.ColorProfiles.Conversion.Icc;
+
+internal partial class LutABCalculator
+{
+    private enum CalculationType
+    {
+        AtoB = 1 << 3,
+        BtoA = 1 << 4,
+
+        SingleCurve = 1,
+        CurveMatrix = 2,
+        CurveClut = 3,
+        Full = 4,
+    }
+}
diff --git a/src/ImageSharp/ColorProfiles/Icc/Calculators/LutABCalculator.cs b/src/ImageSharp/ColorProfiles/Icc/Calculators/LutABCalculator.cs
new file mode 100644
index 0000000000..172d806394
--- /dev/null
+++ b/src/ImageSharp/ColorProfiles/Icc/Calculators/LutABCalculator.cs
@@ -0,0 +1,135 @@
+// Copyright (c) Six Labors.
+// Licensed under the Six Labors Split License.
+#nullable disable
+
+using System.Numerics;
+using SixLabors.ImageSharp.ColorProfiles.Icc.Calculators;
+using SixLabors.ImageSharp.Metadata.Profiles.Icc;
+
+namespace SixLabors.ImageSharp.ColorProfiles.Conversion.Icc;
+
+internal partial class LutABCalculator : IVector4Calculator
+{
+    private CalculationType type;
+    private TrcCalculator curveACalculator;
+    private TrcCalculator curveBCalculator;
+    private TrcCalculator curveMCalculator;
+    private MatrixCalculator matrixCalculator;
+    private ClutCalculator clutCalculator;
+
+    public LutABCalculator(IccLutAToBTagDataEntry entry)
+    {
+        Guard.NotNull(entry, nameof(entry));
+        this.Init(entry.CurveA, entry.CurveB, entry.CurveM, entry.Matrix3x1, entry.Matrix3x3, entry.ClutValues);
+        this.type |= CalculationType.AtoB;
+    }
+
+    public LutABCalculator(IccLutBToATagDataEntry entry)
+    {
+        Guard.NotNull(entry, nameof(entry));
+        this.Init(entry.CurveA, entry.CurveB, entry.CurveM, entry.Matrix3x1, entry.Matrix3x3, entry.ClutValues);
+        this.type |= CalculationType.BtoA;
+    }
+
+    public Vector4 Calculate(Vector4 value)
+    {
+        switch (this.type)
+        {
+            case CalculationType.Full | CalculationType.AtoB:
+                value = this.curveACalculator.Calculate(value);
+                value = this.clutCalculator.Calculate(value);
+                value = this.curveMCalculator.Calculate(value);
+                value = this.matrixCalculator.Calculate(value);
+                return this.curveBCalculator.Calculate(value);
+
+            case CalculationType.Full | CalculationType.BtoA:
+                value = this.curveBCalculator.Calculate(value);
+                value = this.matrixCalculator.Calculate(value);
+                value = this.curveMCalculator.Calculate(value);
+                value = this.clutCalculator.Calculate(value);
+                return this.curveACalculator.Calculate(value);
+
+            case CalculationType.CurveClut | CalculationType.AtoB:
+                value = this.curveACalculator.Calculate(value);
+                value = this.clutCalculator.Calculate(value);
+                return this.curveBCalculator.Calculate(value);
+
+            case CalculationType.CurveClut | CalculationType.BtoA:
+                value = this.curveBCalculator.Calculate(value);
+                value = this.clutCalculator.Calculate(value);
+                return this.curveACalculator.Calculate(value);
+
+            case CalculationType.CurveMatrix | CalculationType.AtoB:
+                value = this.curveMCalculator.Calculate(value);
+                value = this.matrixCalculator.Calculate(value);
+                return this.curveBCalculator.Calculate(value);
+
+            case CalculationType.CurveMatrix | CalculationType.BtoA:
+                value = this.curveBCalculator.Calculate(value);
+                value = this.matrixCalculator.Calculate(value);
+                return this.curveMCalculator.Calculate(value);
+
+            case CalculationType.SingleCurve | CalculationType.AtoB:
+            case CalculationType.SingleCurve | CalculationType.BtoA:
+                return this.curveBCalculator.Calculate(value);
+
+            default:
+                throw new InvalidOperationException("Invalid calculation type");
+        }
+    }
+
+    private void Init(IccTagDataEntry[] curveA, IccTagDataEntry[] curveB, IccTagDataEntry[] curveM, Vector3? matrix3x1, Matrix4x4? matrix3x3, IccClut clut)
+    {
+        bool hasACurve = curveA != null;
+        bool hasBCurve = curveB != null;
+        bool hasMCurve = curveM != null;
+        bool hasMatrix = matrix3x1 != null && matrix3x3 != null;
+        bool hasClut = clut != null;
+
+        if (hasBCurve && hasMatrix && hasMCurve && hasClut && hasACurve)
+        {
+            this.type = CalculationType.Full;
+        }
+        else if (hasBCurve && hasClut && hasACurve)
+        {
+            this.type = CalculationType.CurveClut;
+        }
+        else if (hasBCurve && hasMatrix && hasMCurve)
+        {
+            this.type = CalculationType.CurveMatrix;
+        }
+        else if (hasBCurve)
+        {
+            this.type = CalculationType.SingleCurve;
+        }
+        else
+        {
+            throw new InvalidIccProfileException("AToB or BToA tag has an invalid configuration");
+        }
+
+        if (hasACurve)
+        {
+            this.curveACalculator = new TrcCalculator(curveA, false);
+        }
+
+        if (hasBCurve)
+        {
+            this.curveBCalculator = new TrcCalculator(curveB, false);
+        }
+
+        if (hasMCurve)
+        {
+            this.curveMCalculator = new TrcCalculator(curveM, false);
+        }
+
+        if (hasMatrix)
+        {
+            this.matrixCalculator = new MatrixCalculator(matrix3x3.Value, matrix3x1.Value);
+        }
+
+        if (hasClut)
+        {
+            this.clutCalculator = new ClutCalculator(clut);
+        }
+    }
+}
diff --git a/src/ImageSharp/ColorProfiles/Icc/Calculators/LutCalculator.cs b/src/ImageSharp/ColorProfiles/Icc/Calculators/LutCalculator.cs
new file mode 100644
index 0000000000..83704ae214
--- /dev/null
+++ b/src/ImageSharp/ColorProfiles/Icc/Calculators/LutCalculator.cs
@@ -0,0 +1,77 @@
+// Copyright (c) Six Labors.
+// Licensed under the Six Labors Split License.
+
+using System.Runtime.CompilerServices;
+
+namespace SixLabors.ImageSharp.ColorProfiles.Icc.Calculators;
+
+internal class LutCalculator : ISingleCalculator
+{
+    private readonly float[] lut;
+    private readonly bool inverse;
+
+    public LutCalculator(float[] lut, bool inverse)
+    {
+        Guard.NotNull(lut, nameof(lut));
+
+        this.lut = lut;
+        this.inverse = inverse;
+    }
+
+    public float Calculate(float value)
+    {
+        if (this.inverse)
+        {
+            return this.LookupInverse(value);
+        }
+
+        return this.Lookup(value);
+    }
+
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    private float Lookup(float value)
+    {
+        value = Math.Max(value, 0);
+
+        float factor = value * (this.lut.Length - 1);
+        int index = (int)factor;
+        float low = this.lut[index];
+
+        float high = 1F;
+        if (index < this.lut.Length - 1)
+        {
+            high = this.lut[index + 1];
+        }
+
+        return low + ((high - low) * (factor - index));
+    }
+
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    private float LookupInverse(float value)
+    {
+        int index = Array.BinarySearch(this.lut, value);
+        if (index >= 0)
+        {
+            return index / (float)(this.lut.Length - 1);
+        }
+
+        index = ~index;
+        if (index == 0)
+        {
+            return 0;
+        }
+        else if (index == this.lut.Length)
+        {
+            return 1;
+        }
+
+        float high = this.lut[index];
+        float low = this.lut[index - 1];
+
+        float valuePercent = (value - low) / (high - low);
+        float lutRange = 1 / (float)(this.lut.Length - 1);
+        float lutLow = (index - 1) / (float)(this.lut.Length - 1);
+
+        return lutLow + (valuePercent * lutRange);
+    }
+}
diff --git a/src/ImageSharp/ColorProfiles/Icc/Calculators/LutEntryCalculator.cs b/src/ImageSharp/ColorProfiles/Icc/Calculators/LutEntryCalculator.cs
new file mode 100644
index 0000000000..c97578ee3f
--- /dev/null
+++ b/src/ImageSharp/ColorProfiles/Icc/Calculators/LutEntryCalculator.cs
@@ -0,0 +1,80 @@
+// Copyright (c) Six Labors.
+// Licensed under the Six Labors Split License.
+#nullable disable
+
+using System.Numerics;
+using System.Runtime.CompilerServices;
+using SixLabors.ImageSharp.Metadata.Profiles.Icc;
+
+namespace SixLabors.ImageSharp.ColorProfiles.Icc.Calculators;
+
+internal class LutEntryCalculator : IVector4Calculator
+{
+    private LutCalculator[] inputCurve;
+    private LutCalculator[] outputCurve;
+    private ClutCalculator clutCalculator;
+    private Matrix4x4 matrix;
+    private bool doTransform;
+
+    public LutEntryCalculator(IccLut8TagDataEntry lut)
+    {
+        Guard.NotNull(lut, nameof(lut));
+        this.Init(lut.InputValues, lut.OutputValues, lut.ClutValues, lut.Matrix);
+        this.Is16Bit = false;
+    }
+
+    public LutEntryCalculator(IccLut16TagDataEntry lut)
+    {
+        Guard.NotNull(lut, nameof(lut));
+        this.Init(lut.InputValues, lut.OutputValues, lut.ClutValues, lut.Matrix);
+        this.Is16Bit = true;
+    }
+
+    internal bool Is16Bit { get; }
+
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public Vector4 Calculate(Vector4 value)
+    {
+        if (this.doTransform)
+        {
+            value = Vector4.Transform(value, this.matrix);
+        }
+
+        value = CalculateLut(this.inputCurve, value);
+        value = this.clutCalculator.Calculate(value);
+        return CalculateLut(this.outputCurve, value);
+    }
+
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    private static Vector4 CalculateLut(LutCalculator[] lut, Vector4 value)
+    {
+        ref float f = ref Unsafe.As<Vector4, float>(ref value);
+        for (int i = 0; i < lut.Length; i++)
+        {
+            Unsafe.Add(ref f, i) = lut[i].Calculate(Unsafe.Add(ref f, i));
+        }
+
+        return value;
+    }
+
+    private void Init(IccLut[] inputCurve, IccLut[] outputCurve, IccClut clut, Matrix4x4 matrix)
+    {
+        this.inputCurve = InitLut(inputCurve);
+        this.outputCurve = InitLut(outputCurve);
+        this.clutCalculator = new ClutCalculator(clut);
+        this.matrix = matrix;
+
+        this.doTransform = !matrix.IsIdentity && inputCurve.Length == 3;
+    }
+
+    private static LutCalculator[] InitLut(IccLut[] curves)
+    {
+        LutCalculator[] calculators = new LutCalculator[curves.Length];
+        for (int i = 0; i < curves.Length; i++)
+        {
+            calculators[i] = new LutCalculator(curves[i].Values, false);
+        }
+
+        return calculators;
+    }
+}
diff --git a/src/ImageSharp/ColorProfiles/Icc/Calculators/MatrixCalculator.cs b/src/ImageSharp/ColorProfiles/Icc/Calculators/MatrixCalculator.cs
new file mode 100644
index 0000000000..6be1fdbf95
--- /dev/null
+++ b/src/ImageSharp/ColorProfiles/Icc/Calculators/MatrixCalculator.cs
@@ -0,0 +1,26 @@
+// Copyright (c) Six Labors.
+// Licensed under the Six Labors Split License.
+
+using System.Numerics;
+using System.Runtime.CompilerServices;
+
+namespace SixLabors.ImageSharp.ColorProfiles.Icc.Calculators;
+
+internal class MatrixCalculator : IVector4Calculator
+{
+    private Matrix4x4 matrix2D;
+    private Vector4 matrix1D;
+
+    public MatrixCalculator(Matrix4x4 matrix3x3, Vector3 matrix3x1)
+    {
+        this.matrix2D = matrix3x3;
+        this.matrix1D = new Vector4(matrix3x1, 0);
+    }
+
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public Vector4 Calculate(Vector4 value)
+    {
+        Vector4 transformed = Vector4.Transform(value, this.matrix2D);
+        return Vector4.Add(this.matrix1D, transformed);
+    }
+}
diff --git a/src/ImageSharp/ColorProfiles/Icc/Calculators/ParametricCurveCalculator.cs b/src/ImageSharp/ColorProfiles/Icc/Calculators/ParametricCurveCalculator.cs
new file mode 100644
index 0000000000..2a3945e270
--- /dev/null
+++ b/src/ImageSharp/ColorProfiles/Icc/Calculators/ParametricCurveCalculator.cs
@@ -0,0 +1,130 @@
+// Copyright (c) Six Labors.
+// Licensed under the Six Labors Split License.
+
+using System.Runtime.CompilerServices;
+using SixLabors.ImageSharp.Metadata.Profiles.Icc;
+
+namespace SixLabors.ImageSharp.ColorProfiles.Icc.Calculators;
+
+internal class ParametricCurveCalculator : ISingleCalculator
+{
+    private readonly IccParametricCurve curve;
+    private readonly IccParametricCurveType type;
+    private const IccParametricCurveType InvertedFlag = (IccParametricCurveType)(1 << 3);
+
+    public ParametricCurveCalculator(IccParametricCurveTagDataEntry entry, bool inverted)
+    {
+        Guard.NotNull(entry, nameof(entry));
+        this.curve = entry.Curve;
+        this.type = entry.Curve.Type;
+
+        if (inverted)
+        {
+            this.type |= InvertedFlag;
+        }
+    }
+
+    public float Calculate(float value)
+        => this.type switch
+        {
+            IccParametricCurveType.Type1 => this.CalculateGamma(value),
+            IccParametricCurveType.Cie122_1996 => this.CalculateCie122(value),
+            IccParametricCurveType.Iec61966_3 => this.CalculateIec61966(value),
+            IccParametricCurveType.SRgb => this.CalculateSRgb(value),
+            IccParametricCurveType.Type5 => this.CalculateType5(value),
+            IccParametricCurveType.Type1 | InvertedFlag => this.CalculateInvertedGamma(value),
+            IccParametricCurveType.Cie122_1996 | InvertedFlag => this.CalculateInvertedCie122(value),
+            IccParametricCurveType.Iec61966_3 | InvertedFlag => this.CalculateInvertedIec61966(value),
+            IccParametricCurveType.SRgb | InvertedFlag => this.CalculateInvertedSRgb(value),
+            IccParametricCurveType.Type5 | InvertedFlag => this.CalculateInvertedType5(value),
+            _ => throw new InvalidIccProfileException("ParametricCurve"),
+        };
+
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    private float CalculateGamma(float value) => MathF.Pow(value, this.curve.G);
+
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    private float CalculateCie122(float value)
+    {
+        if (value >= -this.curve.B / this.curve.A)
+        {
+            return MathF.Pow((this.curve.A * value) + this.curve.B, this.curve.G);
+        }
+
+        return 0;
+    }
+
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    private float CalculateIec61966(float value)
+    {
+        if (value >= -this.curve.B / this.curve.A)
+        {
+            return MathF.Pow((this.curve.A * value) + this.curve.B, this.curve.G) + this.curve.C;
+        }
+
+        return this.curve.C;
+    }
+
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    private float CalculateSRgb(float value)
+    {
+        if (value >= this.curve.D)
+        {
+            return MathF.Pow((this.curve.A * value) + this.curve.B, this.curve.G);
+        }
+
+        return this.curve.C * value;
+    }
+
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    private float CalculateType5(float value)
+    {
+        if (value >= this.curve.D)
+        {
+            return MathF.Pow((this.curve.A * value) + this.curve.B, this.curve.G) + this.curve.E;
+        }
+
+        return (this.curve.C * value) + this.curve.F;
+    }
+
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    private float CalculateInvertedGamma(float value)
+        => MathF.Pow(value, 1 / this.curve.G);
+
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    private float CalculateInvertedCie122(float value)
+        => (MathF.Pow(value, 1 / this.curve.G) - this.curve.B) / this.curve.A;
+
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    private float CalculateInvertedIec61966(float value)
+    {
+        if (value >= this.curve.C)
+        {
+            return (MathF.Pow(value - this.curve.C, 1 / this.curve.G) - this.curve.B) / this.curve.A;
+        }
+
+        return -this.curve.B / this.curve.A;
+    }
+
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    private float CalculateInvertedSRgb(float value)
+    {
+        if (value >= MathF.Pow((this.curve.A * this.curve.D) + this.curve.B, this.curve.G))
+        {
+            return (MathF.Pow(value, 1 / this.curve.G) - this.curve.B) / this.curve.A;
+        }
+
+        return value / this.curve.C;
+    }
+
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    private float CalculateInvertedType5(float value)
+    {
+        if (value >= (this.curve.C * this.curve.D) + this.curve.F)
+        {
+            return (MathF.Pow(value - this.curve.E, 1 / this.curve.G) - this.curve.B) / this.curve.A;
+        }
+
+        return (value - this.curve.F) / this.curve.C;
+    }
+}
diff --git a/src/ImageSharp/ColorProfiles/Icc/Calculators/TrcCalculator.cs b/src/ImageSharp/ColorProfiles/Icc/Calculators/TrcCalculator.cs
new file mode 100644
index 0000000000..d2fc5d9b55
--- /dev/null
+++ b/src/ImageSharp/ColorProfiles/Icc/Calculators/TrcCalculator.cs
@@ -0,0 +1,41 @@
+// Copyright (c) Six Labors.
+// Licensed under the Six Labors Split License.
+
+using System.Numerics;
+using System.Runtime.CompilerServices;
+using SixLabors.ImageSharp.ColorProfiles.Conversion.Icc;
+using SixLabors.ImageSharp.Metadata.Profiles.Icc;
+
+namespace SixLabors.ImageSharp.ColorProfiles.Icc.Calculators;
+
+internal class TrcCalculator : IVector4Calculator
+{
+    private readonly ISingleCalculator[] calculators;
+
+    public TrcCalculator(IccTagDataEntry[] entries, bool inverted)
+    {
+        Guard.NotNull(entries, nameof(entries));
+
+        this.calculators = new ISingleCalculator[entries.Length];
+        for (int i = 0; i < entries.Length; i++)
+        {
+            this.calculators[i] = entries[i] switch
+            {
+                IccCurveTagDataEntry curve => new CurveCalculator(curve, inverted),
+                IccParametricCurveTagDataEntry parametricCurve => new ParametricCurveCalculator(parametricCurve, inverted),
+                _ => throw new InvalidIccProfileException("Invalid Entry."),
+            };
+        }
+    }
+
+    public unsafe Vector4 Calculate(Vector4 value)
+    {
+        ref float f = ref Unsafe.As<Vector4, float>(ref value);
+        for (int i = 0; i < this.calculators.Length; i++)
+        {
+            Unsafe.Add(ref f, i) = this.calculators[i].Calculate(Unsafe.Add(ref f, i));
+        }
+
+        return value;
+    }
+}
diff --git a/src/ImageSharp/ColorProfiles/Icc/CompactSrgbV4Profile.cs b/src/ImageSharp/ColorProfiles/Icc/CompactSrgbV4Profile.cs
new file mode 100644
index 0000000000..29e30b53e2
--- /dev/null
+++ b/src/ImageSharp/ColorProfiles/Icc/CompactSrgbV4Profile.cs
@@ -0,0 +1,42 @@
+// Copyright (c) Six Labors.
+// Licensed under the Six Labors Split License.
+
+using SixLabors.ImageSharp.Metadata.Profiles.Icc;
+
+namespace SixLabors.ImageSharp.ColorProfiles.Icc;
+
+internal static class CompactSrgbV4Profile
+{
+    private static readonly Lazy<IccProfile> LazyIccProfile = new(GetIccProfile);
+
+    // Generated using the sRGB-v4.icc profile found at https://github.com/saucecontrol/Compact-ICC-Profiles
+    private static ReadOnlySpan<byte> Data =>
+    [
+        0, 0, 1, 224, 108, 99, 109, 115, 4, 32, 0, 0, 109, 110, 116, 114, 82, 71, 66, 32, 88, 89, 90, 32, 7, 226, 0, 3, 0,
+        20, 0, 9, 0, 14, 0, 29, 97, 99, 115, 112, 77, 83, 70, 84, 0, 0, 0, 0, 115, 97, 119, 115, 99, 116, 114, 108, 0, 0,
+        0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 246, 214, 0, 1, 0, 0, 0, 0, 211, 45, 104, 97, 110, 100, 163, 178, 171,
+        223, 92, 167, 3, 18, 168, 85, 164, 236, 53, 122, 209, 243, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+        0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 10, 100, 101, 115, 99, 0, 0, 0, 252, 0, 0, 0, 36, 99,
+        112, 114, 116, 0, 0, 1, 32, 0, 0, 0, 34, 119, 116, 112, 116, 0, 0, 1, 68, 0, 0, 0, 20, 99, 104, 97, 100, 0, 0,
+        1, 88, 0, 0, 0, 44, 114, 88, 89, 90, 0, 0, 1, 132, 0, 0, 0, 20, 103, 88, 89, 90, 0, 0, 1, 152, 0, 0, 0,
+        20, 98, 88, 89, 90, 0, 0, 1, 172, 0, 0, 0, 20, 114, 84, 82, 67, 0, 0, 1, 192, 0, 0, 0, 32, 103, 84, 82, 67,
+        0, 0, 1, 192, 0, 0, 0, 32, 98, 84, 82, 67, 0, 0, 1, 192, 0, 0, 0, 32, 109, 108, 117, 99, 0, 0, 0, 0, 0,
+        0, 0, 1, 0, 0, 0, 12, 101, 110, 85, 83, 0, 0, 0, 8, 0, 0, 0, 28, 0, 115, 0, 82, 0, 71, 0, 66, 109, 108,
+        117, 99, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 12, 101, 110, 85, 83, 0, 0, 0, 6, 0, 0, 0, 28, 0, 67, 0,
+        67, 0, 48, 0, 33, 88, 89, 90, 32, 0, 0, 0, 0, 0, 0, 246, 214, 0, 1, 0, 0, 0, 0, 211, 45, 115, 102, 51, 50,
+        0, 0, 0, 0, 0, 1, 12, 63, 0, 0, 5, 221, 255, 255, 243, 38, 0, 0, 7, 144, 0, 0, 253, 146, 255, 255, 251, 161, 255,
+        255, 253, 162, 0, 0, 3, 220, 0, 0, 192, 113, 88, 89, 90, 32, 0, 0, 0, 0, 0, 0, 111, 160, 0, 0, 56, 242, 0, 0,
+        3, 143, 88, 89, 90, 32, 0, 0, 0, 0, 0, 0, 98, 150, 0, 0, 183, 137, 0, 0, 24, 218, 88, 89, 90, 32, 0, 0, 0,
+        0, 0, 0, 36, 160, 0, 0, 15, 133, 0, 0, 182, 196, 112, 97, 114, 97, 0, 0, 0, 0, 0, 3, 0, 0, 0, 2, 102, 105,
+        0, 0, 242, 167, 0, 0, 13, 89, 0, 0, 19, 208, 0, 0, 10, 91,
+    ];
+
+    public static IccProfile Profile => LazyIccProfile.Value;
+
+    private static IccProfile GetIccProfile()
+    {
+        byte[] buffer = new byte[Data.Length];
+        Data.CopyTo(buffer);
+        return new IccProfile(buffer);
+    }
+}
diff --git a/src/ImageSharp/ColorProfiles/Icc/IccConverterBase.Checks.cs b/src/ImageSharp/ColorProfiles/Icc/IccConverterBase.Checks.cs
new file mode 100644
index 0000000000..94f906709a
--- /dev/null
+++ b/src/ImageSharp/ColorProfiles/Icc/IccConverterBase.Checks.cs
@@ -0,0 +1,155 @@
+// Copyright (c) Six Labors.
+// Licensed under the Six Labors Split License.
+#nullable disable
+
+using SixLabors.ImageSharp.Metadata.Profiles.Icc;
+
+namespace SixLabors.ImageSharp.ColorProfiles.Conversion.Icc;
+
+/// <summary>
+/// Color converter for ICC profiles
+/// </summary>
+internal abstract partial class IccConverterBase
+{
+    private static ConversionMethod GetConversionMethod(IccProfile profile, IccRenderingIntent renderingIntent) => profile.Header.Class switch
+    {
+        IccProfileClass.InputDevice or
+        IccProfileClass.DisplayDevice or
+        IccProfileClass.OutputDevice or
+        IccProfileClass.ColorSpace => CheckMethod1(profile, renderingIntent),
+        IccProfileClass.DeviceLink or IccProfileClass.Abstract => CheckMethod2(profile),
+        _ => ConversionMethod.Invalid,
+    };
+
+    private static ConversionMethod CheckMethod1(IccProfile profile, IccRenderingIntent renderingIntent)
+    {
+        ConversionMethod method = CheckMethodD(profile, renderingIntent);
+        if (method != ConversionMethod.Invalid)
+        {
+            return method;
+        }
+
+        method = CheckMethodA(profile, renderingIntent);
+        if (method != ConversionMethod.Invalid)
+        {
+            return method;
+        }
+
+        method = CheckMethodA0(profile);
+        if (method != ConversionMethod.Invalid)
+        {
+            return method;
+        }
+
+        method = CheckMethodTrc(profile);
+        if (method != ConversionMethod.Invalid)
+        {
+            return method;
+        }
+
+        return ConversionMethod.Invalid;
+    }
+
+    private static ConversionMethod CheckMethodD(IccProfile profile, IccRenderingIntent renderingIntent)
+    {
+        if ((HasTag(profile, IccProfileTag.DToB0) || HasTag(profile, IccProfileTag.BToD0))
+            && renderingIntent == IccRenderingIntent.Perceptual)
+        {
+            return ConversionMethod.D0;
+        }
+
+        if ((HasTag(profile, IccProfileTag.DToB1) || HasTag(profile, IccProfileTag.BToD1))
+            && renderingIntent == IccRenderingIntent.MediaRelativeColorimetric)
+        {
+            return ConversionMethod.D1;
+        }
+
+        if ((HasTag(profile, IccProfileTag.DToB2) || HasTag(profile, IccProfileTag.BToD2))
+            && renderingIntent == IccRenderingIntent.Saturation)
+        {
+            return ConversionMethod.D2;
+        }
+
+        if ((HasTag(profile, IccProfileTag.DToB3) || HasTag(profile, IccProfileTag.BToD3))
+            && renderingIntent == IccRenderingIntent.AbsoluteColorimetric)
+        {
+            return ConversionMethod.D3;
+        }
+
+        return ConversionMethod.Invalid;
+    }
+
+    private static ConversionMethod CheckMethodA(IccProfile profile, IccRenderingIntent renderingIntent)
+    {
+        if ((HasTag(profile, IccProfileTag.AToB0) || HasTag(profile, IccProfileTag.BToA0))
+            && renderingIntent == IccRenderingIntent.Perceptual)
+        {
+            return ConversionMethod.A0;
+        }
+
+        if ((HasTag(profile, IccProfileTag.AToB1) || HasTag(profile, IccProfileTag.BToA1))
+            && renderingIntent == IccRenderingIntent.MediaRelativeColorimetric)
+        {
+            return ConversionMethod.A1;
+        }
+
+        if ((HasTag(profile, IccProfileTag.AToB2) || HasTag(profile, IccProfileTag.BToA2))
+            && renderingIntent == IccRenderingIntent.Saturation)
+        {
+            return ConversionMethod.A2;
+        }
+
+        return ConversionMethod.Invalid;
+    }
+
+    private static ConversionMethod CheckMethodA0(IccProfile profile)
+    {
+        bool valid = HasTag(profile, IccProfileTag.AToB0) || HasTag(profile, IccProfileTag.BToA0);
+        return valid ? ConversionMethod.A0 : ConversionMethod.Invalid;
+    }
+
+    private static ConversionMethod CheckMethodTrc(IccProfile profile)
+    {
+        if (HasTag(profile, IccProfileTag.RedMatrixColumn)
+            && HasTag(profile, IccProfileTag.GreenMatrixColumn)
+            && HasTag(profile, IccProfileTag.BlueMatrixColumn)
+            && HasTag(profile, IccProfileTag.RedTrc)
+            && HasTag(profile, IccProfileTag.GreenTrc)
+            && HasTag(profile, IccProfileTag.BlueTrc))
+        {
+            return ConversionMethod.ColorTrc;
+        }
+
+        if (HasTag(profile, IccProfileTag.GrayTrc))
+        {
+            return ConversionMethod.GrayTrc;
+        }
+
+        return ConversionMethod.Invalid;
+    }
+
+    private static ConversionMethod CheckMethod2(IccProfile profile)
+    {
+        if (HasTag(profile, IccProfileTag.DToB0) || HasTag(profile, IccProfileTag.BToD0))
+        {
+            return ConversionMethod.D0;
+        }
+
+        if (HasTag(profile, IccProfileTag.AToB0) || HasTag(profile, IccProfileTag.AToB0))
+        {
+            return ConversionMethod.A0;
+        }
+
+        return ConversionMethod.Invalid;
+    }
+
+    private static bool HasTag(IccProfile profile, IccProfileTag tag)
+        => profile.Entries.Any(t => t.TagSignature == tag);
+
+    private static IccTagDataEntry GetTag(IccProfile profile, IccProfileTag tag)
+        => Array.Find(profile.Entries, t => t.TagSignature == tag);
+
+    private static T GetTag<T>(IccProfile profile, IccProfileTag tag)
+        where T : IccTagDataEntry
+        => profile.Entries.OfType<T>().FirstOrDefault(t => t.TagSignature == tag);
+}
diff --git a/src/ImageSharp/ColorProfiles/Icc/IccConverterBase.ConversionMethod.cs b/src/ImageSharp/ColorProfiles/Icc/IccConverterBase.ConversionMethod.cs
new file mode 100644
index 0000000000..43593f0ae9
--- /dev/null
+++ b/src/ImageSharp/ColorProfiles/Icc/IccConverterBase.ConversionMethod.cs
@@ -0,0 +1,66 @@
+// Copyright (c) Six Labors.
+// Licensed under the Six Labors Split License.
+
+namespace SixLabors.ImageSharp.ColorProfiles.Conversion.Icc;
+
+/// <summary>
+/// Color converter for ICC profiles
+/// </summary>
+internal abstract partial class IccConverterBase
+{
+    /// <summary>
+    /// Conversion methods with ICC profiles
+    /// </summary>
+    private enum ConversionMethod
+    {
+        /// <summary>
+        /// Conversion using anything but Multi Process Elements with perceptual rendering intent
+        /// </summary>
+        A0,
+
+        /// <summary>
+        /// Conversion using anything but Multi Process Elements with relative colorimetric rendering intent
+        /// </summary>
+        A1,
+
+        /// <summary>
+        /// Conversion using anything but Multi Process Elements with saturation rendering intent
+        /// </summary>
+        A2,
+
+        /// <summary>
+        /// Conversion using Multi Process Elements with perceptual rendering intent
+        /// </summary>
+        D0,
+
+        /// <summary>
+        /// Conversion using Multi Process Elements with relative colorimetric rendering intent
+        /// </summary>
+        D1,
+
+        /// <summary>
+        /// Conversion using Multi Process Elements with saturation rendering intent
+        /// </summary>
+        D2,
+
+        /// <summary>
+        /// Conversion using Multi Process Elements with absolute colorimetric rendering intent
+        /// </summary>
+        D3,
+
+        /// <summary>
+        /// Conversion of more than one channel using tone reproduction curves
+        /// </summary>
+        ColorTrc,
+
+        /// <summary>
+        /// Conversion of exactly one channel using a tone reproduction curve
+        /// </summary>
+        GrayTrc,
+
+        /// <summary>
+        /// No valid conversion method available or found
+        /// </summary>
+        Invalid,
+    }
+}
diff --git a/src/ImageSharp/ColorProfiles/Icc/IccConverterbase.Conversions.cs b/src/ImageSharp/ColorProfiles/Icc/IccConverterbase.Conversions.cs
new file mode 100644
index 0000000000..20df08e378
--- /dev/null
+++ b/src/ImageSharp/ColorProfiles/Icc/IccConverterbase.Conversions.cs
@@ -0,0 +1,109 @@
+// Copyright (c) Six Labors.
+// Licensed under the Six Labors Split License.
+
+using SixLabors.ImageSharp.ColorProfiles.Icc.Calculators;
+using SixLabors.ImageSharp.Metadata.Profiles.Icc;
+
+namespace SixLabors.ImageSharp.ColorProfiles.Conversion.Icc;
+
+/// <summary>
+/// Color converter for ICC profiles
+/// </summary>
+internal abstract partial class IccConverterBase
+{
+    private IVector4Calculator calculator;
+
+    internal bool Is16BitLutEntry => this.calculator is LutEntryCalculator { Is16Bit: true };
+
+    internal bool IsTrc => this.calculator is ColorTrcCalculator or GrayTrcCalculator;
+
+    /// <summary>
+    /// Checks the profile for available conversion methods and gathers all the information's necessary for it.
+    /// </summary>
+    /// <param name="profile">The profile to use for the conversion.</param>
+    /// <param name="toPcs">True if the conversion is to the Profile Connection Space.</param>
+    /// <param name="renderingIntent">The wanted rendering intent. Can be ignored if not available.</param>
+    /// <exception cref="InvalidIccProfileException">Invalid conversion method.</exception>
+    protected void Init(IccProfile profile, bool toPcs, IccRenderingIntent renderingIntent)
+        => this.calculator = GetConversionMethod(profile, renderingIntent) switch
+        {
+            ConversionMethod.D0 => toPcs ?
+                                InitD(profile, IccProfileTag.DToB0) :
+                                InitD(profile, IccProfileTag.BToD0),
+            ConversionMethod.D1 => toPcs ?
+                                InitD(profile, IccProfileTag.DToB1) :
+                                InitD(profile, IccProfileTag.BToD1),
+            ConversionMethod.D2 => toPcs ?
+                                InitD(profile, IccProfileTag.DToB2) :
+                                InitD(profile, IccProfileTag.BToD2),
+            ConversionMethod.D3 => toPcs ?
+                                InitD(profile, IccProfileTag.DToB3) :
+                                InitD(profile, IccProfileTag.BToD3),
+            ConversionMethod.A0 => toPcs ?
+                                InitA(profile, IccProfileTag.AToB0) :
+                                InitA(profile, IccProfileTag.BToA0),
+            ConversionMethod.A1 => toPcs ?
+                                InitA(profile, IccProfileTag.AToB1) :
+                                InitA(profile, IccProfileTag.BToA1),
+            ConversionMethod.A2 => toPcs ?
+                                InitA(profile, IccProfileTag.AToB2) :
+                                InitA(profile, IccProfileTag.BToA2),
+            ConversionMethod.ColorTrc => InitColorTrc(profile, toPcs),
+            ConversionMethod.GrayTrc => InitGrayTrc(profile, toPcs),
+            _ => throw new InvalidIccProfileException("Invalid conversion method."),
+        };
+
+    private static IVector4Calculator InitA(IccProfile profile, IccProfileTag tag)
+        => GetTag(profile, tag) switch
+        {
+            IccLut8TagDataEntry lut8 => new LutEntryCalculator(lut8),
+            IccLut16TagDataEntry lut16 => new LutEntryCalculator(lut16),
+            IccLutAToBTagDataEntry lutAtoB => new LutABCalculator(lutAtoB),
+            IccLutBToATagDataEntry lutBtoA => new LutABCalculator(lutBtoA),
+            _ => throw new InvalidIccProfileException("Invalid entry."),
+        };
+
+    private static IVector4Calculator InitD(IccProfile profile, IccProfileTag tag)
+    {
+        IccMultiProcessElementsTagDataEntry entry = GetTag<IccMultiProcessElementsTagDataEntry>(profile, tag)
+            ?? throw new InvalidIccProfileException("Entry is null.");
+
+        throw new NotImplementedException("Multi process elements are not supported");
+    }
+
+    private static ColorTrcCalculator InitColorTrc(IccProfile profile, bool toPcs)
+    {
+        IccXyzTagDataEntry redMatrixColumn = GetTag<IccXyzTagDataEntry>(profile, IccProfileTag.RedMatrixColumn);
+        IccXyzTagDataEntry greenMatrixColumn = GetTag<IccXyzTagDataEntry>(profile, IccProfileTag.GreenMatrixColumn);
+        IccXyzTagDataEntry blueMatrixColumn = GetTag<IccXyzTagDataEntry>(profile, IccProfileTag.BlueMatrixColumn);
+
+        IccTagDataEntry redTrc = GetTag(profile, IccProfileTag.RedTrc);
+        IccTagDataEntry greenTrc = GetTag(profile, IccProfileTag.GreenTrc);
+        IccTagDataEntry blueTrc = GetTag(profile, IccProfileTag.BlueTrc);
+
+        if (redMatrixColumn == null ||
+            greenMatrixColumn == null ||
+            blueMatrixColumn == null ||
+            redTrc == null ||
+            greenTrc == null ||
+            blueTrc == null)
+        {
+            throw new InvalidIccProfileException("Missing matrix column or channel.");
+        }
+
+        return new ColorTrcCalculator(
+            redMatrixColumn,
+            greenMatrixColumn,
+            blueMatrixColumn,
+            redTrc,
+            greenTrc,
+            blueTrc,
+            toPcs);
+    }
+
+    private static GrayTrcCalculator InitGrayTrc(IccProfile profile, bool toPcs)
+    {
+        IccTagDataEntry entry = GetTag(profile, IccProfileTag.GrayTrc);
+        return new GrayTrcCalculator(entry, toPcs);
+    }
+}
diff --git a/src/ImageSharp/ColorProfiles/Icc/IccConverterbase.cs b/src/ImageSharp/ColorProfiles/Icc/IccConverterbase.cs
new file mode 100644
index 0000000000..d9976dc2ac
--- /dev/null
+++ b/src/ImageSharp/ColorProfiles/Icc/IccConverterbase.cs
@@ -0,0 +1,49 @@
+// Copyright (c) Six Labors.
+// Licensed under the Six Labors Split License.
+#nullable disable
+
+using System.Numerics;
+using System.Runtime.CompilerServices;
+using SixLabors.ImageSharp.Metadata.Profiles.Icc;
+
+namespace SixLabors.ImageSharp.ColorProfiles.Conversion.Icc;
+
+/// <summary>
+/// Color converter for ICC profiles
+/// </summary>
+internal abstract partial class IccConverterBase
+{
+    /// <summary>
+    /// Initializes a new instance of the <see cref="IccConverterBase"/> class.
+    /// </summary>
+    /// <param name="profile">The ICC profile to use for the conversions</param>
+    /// <param name="toPcs">True if the conversion is to the profile connection space (PCS); False if the conversion is to the data space</param>
+    protected IccConverterBase(IccProfile profile, bool toPcs)
+    {
+        Guard.NotNull(profile, nameof(profile));
+        this.Init(profile, toPcs, profile.Header.RenderingIntent);
+    }
+
+    /// <summary>
+    /// Converts colors with the initially provided ICC profile
+    /// </summary>
+    /// <param name="value">The value to convert</param>
+    /// <returns>The converted value</returns>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public Vector4 Calculate(Vector4 value) => this.calculator.Calculate(value);
+
+    /// <summary>
+    /// Converts colors with the initially provided ICC profile
+    /// </summary>
+    /// <param name="source">The source colors</param>
+    /// <param name="destination">The destination colors</param>
+    public void Calculate(ReadOnlySpan<Vector4> source, Span<Vector4> destination)
+    {
+        Guard.DestinationShouldNotBeTooShort(source, destination, nameof(destination));
+
+        for (int i = 0; i < source.Length; i++)
+        {
+            destination[i] = this.Calculate(source[i]);
+        }
+    }
+}
diff --git a/src/ImageSharp/ColorProfiles/Icc/IccDataToDataConverter.cs b/src/ImageSharp/ColorProfiles/Icc/IccDataToDataConverter.cs
new file mode 100644
index 0000000000..cb4d89bb53
--- /dev/null
+++ b/src/ImageSharp/ColorProfiles/Icc/IccDataToDataConverter.cs
@@ -0,0 +1,22 @@
+// Copyright (c) Six Labors.
+// Licensed under the Six Labors Split License.
+
+using SixLabors.ImageSharp.ColorProfiles.Conversion.Icc;
+using SixLabors.ImageSharp.Metadata.Profiles.Icc;
+
+namespace SixLabors.ImageSharp.ColorProfiles.Icc;
+
+/// <summary>
+/// Color converter for ICC profiles
+/// </summary>
+internal class IccDataToDataConverter : IccConverterBase
+{
+    /// <summary>
+    /// Initializes a new instance of the <see cref="IccDataToDataConverter"/> class.
+    /// </summary>
+    /// <param name="profile">The ICC profile to use for the conversions</param>
+    public IccDataToDataConverter(IccProfile profile)
+        : base(profile, true) // toPCS is true because in this case the PCS space is also a data space
+    {
+    }
+}
diff --git a/src/ImageSharp/ColorProfiles/Icc/IccDataToPcsConverter.cs b/src/ImageSharp/ColorProfiles/Icc/IccDataToPcsConverter.cs
new file mode 100644
index 0000000000..6e95d3cb32
--- /dev/null
+++ b/src/ImageSharp/ColorProfiles/Icc/IccDataToPcsConverter.cs
@@ -0,0 +1,22 @@
+// Copyright (c) Six Labors.
+// Licensed under the Six Labors Split License.
+
+using SixLabors.ImageSharp.ColorProfiles.Conversion.Icc;
+using SixLabors.ImageSharp.Metadata.Profiles.Icc;
+
+namespace SixLabors.ImageSharp.ColorProfiles.Icc;
+
+/// <summary>
+/// Color converter for ICC profiles
+/// </summary>
+internal class IccDataToPcsConverter : IccConverterBase
+{
+    /// <summary>
+    /// Initializes a new instance of the <see cref="IccDataToPcsConverter"/> class.
+    /// </summary>
+    /// <param name="profile">The ICC profile to use for the conversions</param>
+    public IccDataToPcsConverter(IccProfile profile)
+        : base(profile, true)
+    {
+    }
+}
diff --git a/src/ImageSharp/ColorProfiles/Icc/IccPcsToDataConverter.cs b/src/ImageSharp/ColorProfiles/Icc/IccPcsToDataConverter.cs
new file mode 100644
index 0000000000..d29517fca2
--- /dev/null
+++ b/src/ImageSharp/ColorProfiles/Icc/IccPcsToDataConverter.cs
@@ -0,0 +1,22 @@
+// Copyright (c) Six Labors.
+// Licensed under the Six Labors Split License.
+
+using SixLabors.ImageSharp.ColorProfiles.Conversion.Icc;
+using SixLabors.ImageSharp.Metadata.Profiles.Icc;
+
+namespace SixLabors.ImageSharp.ColorProfiles.Icc;
+
+/// <summary>
+/// Color converter for ICC profiles
+/// </summary>
+internal class IccPcsToDataConverter : IccConverterBase
+{
+    /// <summary>
+    /// Initializes a new instance of the <see cref="IccPcsToDataConverter"/> class.
+    /// </summary>
+    /// <param name="profile">The ICC profile to use for the conversions</param>
+    public IccPcsToDataConverter(IccProfile profile)
+        : base(profile, false)
+    {
+    }
+}
diff --git a/src/ImageSharp/ColorProfiles/Icc/IccPcsToPcsConverter.cs b/src/ImageSharp/ColorProfiles/Icc/IccPcsToPcsConverter.cs
new file mode 100644
index 0000000000..30b44ca75c
--- /dev/null
+++ b/src/ImageSharp/ColorProfiles/Icc/IccPcsToPcsConverter.cs
@@ -0,0 +1,22 @@
+// Copyright (c) Six Labors.
+// Licensed under the Six Labors Split License.
+
+using SixLabors.ImageSharp.ColorProfiles.Conversion.Icc;
+using SixLabors.ImageSharp.Metadata.Profiles.Icc;
+
+namespace SixLabors.ImageSharp.ColorProfiles.Icc;
+
+/// <summary>
+/// Color converter for ICC profiles
+/// </summary>
+internal class IccPcsToPcsConverter : IccConverterBase
+{
+    /// <summary>
+    /// Initializes a new instance of the <see cref="IccPcsToPcsConverter"/> class.
+    /// </summary>
+    /// <param name="profile">The ICC profile to use for the conversions</param>
+    public IccPcsToPcsConverter(IccProfile profile)
+        : base(profile, true)
+    {
+    }
+}
diff --git a/src/ImageSharp/ColorProfiles/KnownYCbCrMatrices.cs b/src/ImageSharp/ColorProfiles/KnownYCbCrMatrices.cs
new file mode 100644
index 0000000000..d32833a382
--- /dev/null
+++ b/src/ImageSharp/ColorProfiles/KnownYCbCrMatrices.cs
@@ -0,0 +1,62 @@
+// Copyright (c) Six Labors.
+// Licensed under the Six Labors Split License.
+
+using System.Numerics;
+
+namespace SixLabors.ImageSharp.ColorProfiles;
+
+/// <summary>
+/// Provides standard YCbCr matrices for RGB to YCbCr conversion.
+/// </summary>
+public static class KnownYCbCrMatrices
+{
+#pragma warning disable SA1137 // Elements should have the same indentation
+#pragma warning disable SA1117 // Parameters should be on same line or separate lines
+    /// <summary>
+    /// ITU-R BT.601 (SD video standard).
+    /// </summary>
+    public static readonly YCbCrTransform BT601 = new(
+        new Matrix4x4(
+            0.299000F, 0.587000F, 0.114000F, 0F,
+           -0.168736F, -0.331264F, 0.500000F, 0F,
+            0.500000F, -0.418688F, -0.081312F, 0F,
+            0F, 0F, 0F, 1F),
+        new Matrix4x4(
+            1.000000F, 0.000000F, 1.402000F, 0F,
+            1.000000F, -0.344136F, -0.714136F, 0F,
+            1.000000F, 1.772000F, 0.000000F, 0F,
+            0F, 0F, 0F, 1F),
+        new Vector3(0F, 0.5F, 0.5F));
+
+    /// <summary>
+    /// ITU-R BT.709 (HD video, sRGB standard).
+    /// </summary>
+    public static readonly YCbCrTransform BT709 = new(
+        new Matrix4x4(
+            0.212600F, 0.715200F, 0.072200F, 0F,
+           -0.114572F, -0.385428F, 0.500000F, 0F,
+            0.500000F, -0.454153F, -0.045847F, 0F,
+            0F, 0F, 0F, 1F),
+        new Matrix4x4(
+            1.000000F, 0.000000F, 1.574800F, 0F,
+            1.000000F, -0.187324F, -0.468124F, 0F,
+            1.000000F, 1.855600F, 0.000000F, 0F,
+            0F, 0F, 0F, 1F),
+        new Vector3(0F, 0.5F, 0.5F));
+
+    /// <summary>
+    /// ITU-R BT.2020 (UHD/4K video standard).
+    /// </summary>
+    public static readonly YCbCrTransform BT2020 = new(
+        new Matrix4x4(
+            0.262700F, 0.678000F, 0.059300F, 0F,
+           -0.139630F, -0.360370F, 0.500000F, 0F,
+            0.500000F, -0.459786F, -0.040214F, 0F,
+            0F, 0F, 0F, 1F),
+        new Matrix4x4(
+            1.000000F, 0.000000F, 1.474600F, 0F,
+            1.000000F, -0.164553F, -0.571353F, 0F,
+            1.000000F, 1.881400F, 0.000000F, 0F,
+            0F, 0F, 0F, 1F),
+        new Vector3(0F, 0.5F, 0.5F));
+}
diff --git a/src/ImageSharp/ColorProfiles/Lms.cs b/src/ImageSharp/ColorProfiles/Lms.cs
index 5a6791b2d7..3aa3d72557 100644
--- a/src/ImageSharp/ColorProfiles/Lms.cs
+++ b/src/ImageSharp/ColorProfiles/Lms.cs
@@ -82,20 +82,53 @@ public readonly struct Lms : IColorProfile<Lms, CieXyz>
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
     public static bool operator !=(Lms left, Lms right) => !left.Equals(right);
 
-    /// <summary>
-    /// Returns a new <see cref="Vector3"/> representing this instance.
-    /// </summary>
-    /// <returns>The <see cref="Vector3"/>.</returns>
-    [MethodImpl(MethodImplOptions.AggressiveInlining)]
-    public Vector3 ToVector3() => new(this.L, this.M, this.S);
+    /// <inheritdoc/>
+    public Vector4 ToScaledVector4()
+    {
+        Vector3 v3 = default;
+        v3 += this.AsVector3Unsafe();
+        v3 += new Vector3(1F);
+        v3 /= 2F;
+        return new Vector4(v3, 1F);
+    }
 
     /// <inheritdoc/>
-    public static Lms FromProfileConnectingSpace(ColorConversionOptions options, in CieXyz source)
+    public static Lms FromScaledVector4(Vector4 source)
+    {
+        Vector3 v3 = source.AsVector3();
+        v3 *= 2F;
+        v3 -= new Vector3(1F);
+        return new Lms(v3);
+    }
+
+    /// <inheritdoc/>
+    public static void ToScaledVector4(ReadOnlySpan<Lms> source, Span<Vector4> destination)
+    {
+        Guard.DestinationShouldNotBeTooShort(source, destination, nameof(destination));
+
+        // TODO: Optimize via SIMD
+        for (int i = 0; i < source.Length; i++)
+        {
+            destination[i] = source[i].ToScaledVector4();
+        }
+    }
+
+    /// <inheritdoc/>
+    public static void FromScaledVector4(ReadOnlySpan<Vector4> source, Span<Lms> destination)
     {
-        Vector3 vector = Vector3.Transform(source.ToVector3(), options.AdaptationMatrix);
-        return new Lms(vector);
+        Guard.DestinationShouldNotBeTooShort(source, destination, nameof(destination));
+
+        // TODO: Optimize via SIMD
+        for (int i = 0; i < source.Length; i++)
+        {
+            destination[i] = FromScaledVector4(source[i]);
+        }
     }
 
+    /// <inheritdoc/>
+    public static Lms FromProfileConnectingSpace(ColorConversionOptions options, in CieXyz source)
+        => new(Vector3.Transform(source.AsVector3Unsafe(), options.AdaptationMatrix));
+
     /// <inheritdoc/>
     public static void FromProfileConnectionSpace(ColorConversionOptions options, ReadOnlySpan<CieXyz> source, Span<Lms> destination)
     {
@@ -110,10 +143,7 @@ public readonly struct Lms : IColorProfile<Lms, CieXyz>
 
     /// <inheritdoc/>
     public CieXyz ToProfileConnectingSpace(ColorConversionOptions options)
-    {
-        Vector3 vector = Vector3.Transform(this.ToVector3(), options.InverseAdaptationMatrix);
-        return new CieXyz(vector);
-    }
+        => new(Vector3.Transform(this.AsVector3Unsafe(), options.InverseAdaptationMatrix));
 
     /// <inheritdoc/>
     public static void ToProfileConnectionSpace(ColorConversionOptions options, ReadOnlySpan<Lms> source, Span<CieXyz> destination)
diff --git a/src/ImageSharp/ColorProfiles/Rgb.cs b/src/ImageSharp/ColorProfiles/Rgb.cs
index 6698e12cb8..42e502592c 100644
--- a/src/ImageSharp/ColorProfiles/Rgb.cs
+++ b/src/ImageSharp/ColorProfiles/Rgb.cs
@@ -81,11 +81,54 @@ public readonly struct Rgb : IProfileConnectingSpace<Rgb, CieXyz>
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
     public static bool operator !=(Rgb left, Rgb right) => !left.Equals(right);
 
+    /// <summary>
+    /// Initializes the color instance from a generic scaled <see cref="Vector4"/>.
+    /// </summary>
+    /// <param name="source">The vector to load the color from.</param>
+    /// <returns>The <see cref="Rgb"/>.</returns>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static Rgb FromScaledVector4(Vector4 source)
+        => new(source.AsVector3());
+
+    /// <summary>
+    /// Expands the color into a generic ("scaled") <see cref="Vector4"/> representation
+    /// with values scaled and usually clamped between <value>0</value> and <value>1</value>.
+    /// The vector components are typically expanded in least to greatest significance order.
+    /// </summary>
+    /// <returns>The <see cref="Vector4"/>.</returns>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public Vector4 ToScaledVector4()
+        => new(this.AsVector3Unsafe(), 1F);
+
+    /// <inheritdoc/>
+    public static void ToScaledVector4(ReadOnlySpan<Rgb> source, Span<Vector4> destination)
+    {
+        Guard.DestinationShouldNotBeTooShort(source, destination, nameof(destination));
+
+        // TODO: Optimize via SIMD
+        for (int i = 0; i < source.Length; i++)
+        {
+            destination[i] = source[i].ToScaledVector4();
+        }
+    }
+
+    /// <inheritdoc/>
+    public static void FromScaledVector4(ReadOnlySpan<Vector4> source, Span<Rgb> destination)
+    {
+        Guard.DestinationShouldNotBeTooShort(source, destination, nameof(destination));
+
+        // TODO: Optimize via SIMD
+        for (int i = 0; i < source.Length; i++)
+        {
+            destination[i] = FromScaledVector4(source[i]);
+        }
+    }
+
     /// <inheritdoc/>
     public static Rgb FromProfileConnectingSpace(ColorConversionOptions options, in CieXyz source)
     {
         // Convert to linear rgb then compress.
-        Rgb linear = new(Vector3.Transform(source.ToVector3(), GetCieXyzToRgbMatrix(options.TargetRgbWorkingSpace)));
+        Rgb linear = new(Vector3.Transform(source.AsVector3Unsafe(), GetCieXyzToRgbMatrix(options.TargetRgbWorkingSpace)));
         return FromScaledVector4(options.TargetRgbWorkingSpace.Compress(linear.ToScaledVector4()));
     }
 
@@ -98,7 +141,7 @@ public readonly struct Rgb : IProfileConnectingSpace<Rgb, CieXyz>
         for (int i = 0; i < source.Length; i++)
         {
             // Convert to linear rgb then compress.
-            Rgb linear = new(Vector3.Transform(source[i].ToVector3(), matrix));
+            Rgb linear = new(Vector3.Transform(source[i].AsVector3Unsafe(), matrix));
             Vector4 nonlinear = options.TargetRgbWorkingSpace.Compress(linear.ToScaledVector4());
             destination[i] = FromScaledVector4(nonlinear);
         }
@@ -108,10 +151,10 @@ public readonly struct Rgb : IProfileConnectingSpace<Rgb, CieXyz>
     public CieXyz ToProfileConnectingSpace(ColorConversionOptions options)
     {
         // First expand to linear rgb
-        Rgb linear = FromScaledVector4(options.RgbWorkingSpace.Expand(this.ToScaledVector4()));
+        Rgb linear = FromScaledVector4(options.SourceRgbWorkingSpace.Expand(this.ToScaledVector4()));
 
         // Then convert to xyz
-        return new CieXyz(Vector3.Transform(linear.ToScaledVector3(), GetRgbToCieXyzMatrix(options.RgbWorkingSpace)));
+        return new CieXyz(Vector3.Transform(linear.AsVector3Unsafe(), GetRgbToCieXyzMatrix(options.SourceRgbWorkingSpace)));
     }
 
     /// <inheritdoc/>
@@ -119,21 +162,22 @@ public readonly struct Rgb : IProfileConnectingSpace<Rgb, CieXyz>
     {
         Guard.DestinationShouldNotBeTooShort(source, destination, nameof(destination));
 
-        Matrix4x4 matrix = GetRgbToCieXyzMatrix(options.RgbWorkingSpace);
+        Matrix4x4 matrix = GetRgbToCieXyzMatrix(options.SourceRgbWorkingSpace);
         for (int i = 0; i < source.Length; i++)
         {
             Rgb rgb = source[i];
 
             // First expand to linear rgb
-            Rgb linear = FromScaledVector4(options.RgbWorkingSpace.Expand(rgb.ToScaledVector4()));
+            Rgb linear = FromScaledVector4(options.SourceRgbWorkingSpace.Expand(rgb.ToScaledVector4()));
 
             // Then convert to xyz
-            destination[i] = new CieXyz(Vector3.Transform(linear.ToScaledVector3(), matrix));
+            destination[i] = new CieXyz(Vector3.Transform(linear.AsVector3Unsafe(), matrix));
         }
     }
 
     /// <inheritdoc/>
-    public static ChromaticAdaptionWhitePointSource GetChromaticAdaptionWhitePointSource() => ChromaticAdaptionWhitePointSource.RgbWorkingSpace;
+    public static ChromaticAdaptionWhitePointSource GetChromaticAdaptionWhitePointSource()
+        => ChromaticAdaptionWhitePointSource.RgbWorkingSpace;
 
     /// <summary>
     /// Initializes the color instance from a generic scaled <see cref="Vector3"/>.
@@ -141,19 +185,8 @@ public readonly struct Rgb : IProfileConnectingSpace<Rgb, CieXyz>
     /// <param name="source">The vector to load the color from.</param>
     /// <returns>The <see cref="Rgb"/>.</returns>
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
-    public static Rgb FromScaledVector3(Vector3 source) => new(Vector3.Clamp(source, Vector3.Zero, Vector3.One));
-
-    /// <summary>
-    /// Initializes the color instance from a generic scaled <see cref="Vector4"/>.
-    /// </summary>
-    /// <param name="source">The vector to load the color from.</param>
-    /// <returns>The <see cref="Rgb"/>.</returns>
-    [MethodImpl(MethodImplOptions.AggressiveInlining)]
-    public static Rgb FromScaledVector4(Vector4 source)
-    {
-        source = Vector4.Clamp(source, Vector4.Zero, Vector4.One);
-        return new(source.X, source.Y, source.Z);
-    }
+    public static Rgb FromScaledVector3(Vector3 source)
+        => new(source);
 
     /// <summary>
     /// Initializes the color instance for a source clamped between <value>0</value> and <value>1</value>
@@ -161,7 +194,8 @@ public readonly struct Rgb : IProfileConnectingSpace<Rgb, CieXyz>
     /// <param name="source">The source to load the color from.</param>
     /// <returns>The <see cref="Rgb"/>.</returns>
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
-    public static Rgb Clamp(Rgb source) => new(Vector3.Clamp(new(source.R, source.G, source.B), Vector3.Zero, Vector3.One));
+    public static Rgb Clamp(Rgb source)
+        => new(Vector3.Clamp(source.AsVector3Unsafe(), Vector3.Zero, Vector3.One));
 
     /// <summary>
     /// Expands the color into a generic ("scaled") <see cref="Vector3"/> representation
@@ -170,24 +204,12 @@ public readonly struct Rgb : IProfileConnectingSpace<Rgb, CieXyz>
     /// </summary>
     /// <returns>The <see cref="Vector3"/>.</returns>
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
-    public Vector3 ToScaledVector3() => Clamp(this).ToVector3();
-
-    /// <summary>
-    /// Expands the color into a generic <see cref="Vector3"/> representation.
-    /// The vector components are typically expanded in least to greatest significance order.
-    /// </summary>
-    /// <returns>The <see cref="Vector3"/>.</returns>
-    [MethodImpl(MethodImplOptions.AggressiveInlining)]
-    public Vector3 ToVector3() => new(this.R, this.G, this.B);
-
-    /// <summary>
-    /// Expands the color into a generic ("scaled") <see cref="Vector4"/> representation
-    /// with values scaled and usually clamped between <value>0</value> and <value>1</value>.
-    /// The vector components are typically expanded in least to greatest significance order.
-    /// </summary>
-    /// <returns>The <see cref="Vector4"/>.</returns>
-    [MethodImpl(MethodImplOptions.AggressiveInlining)]
-    public Vector4 ToScaledVector4() => new(this.ToScaledVector3(), 1f);
+    public Vector3 ToScaledVector3()
+    {
+        Vector3 v3 = default;
+        v3 += this.AsVector3Unsafe();
+        return v3;
+    }
 
     /// <inheritdoc/>
     public override int GetHashCode() => HashCode.Combine(this.R, this.G, this.B);
@@ -203,7 +225,7 @@ public readonly struct Rgb : IProfileConnectingSpace<Rgb, CieXyz>
     public bool Equals(Rgb other)
         => this.AsVector3Unsafe() == other.AsVector3Unsafe();
 
-    private Vector3 AsVector3Unsafe() => Unsafe.As<Rgb, Vector3>(ref Unsafe.AsRef(in this));
+    internal Vector3 AsVector3Unsafe() => Unsafe.As<Rgb, Vector3>(ref Unsafe.AsRef(in this));
 
     private static Matrix4x4 GetCieXyzToRgbMatrix(RgbWorkingSpace workingSpace)
     {
@@ -249,7 +271,7 @@ public readonly struct Rgb : IProfileConnectingSpace<Rgb, CieXyz>
 
         Matrix4x4.Invert(xyzMatrix, out Matrix4x4 inverseXyzMatrix);
 
-        Vector3 vector = Vector3.Transform(workingSpace.WhitePoint.ToVector3(), inverseXyzMatrix);
+        Vector3 vector = Vector3.Transform(workingSpace.WhitePoint.AsVector3Unsafe(), inverseXyzMatrix);
 
         // Use transposed Rows/Columns
         return new Matrix4x4
diff --git a/src/ImageSharp/ColorProfiles/VonKriesChromaticAdaptation.cs b/src/ImageSharp/ColorProfiles/VonKriesChromaticAdaptation.cs
index 2f9a52912e..25604001fc 100644
--- a/src/ImageSharp/ColorProfiles/VonKriesChromaticAdaptation.cs
+++ b/src/ImageSharp/ColorProfiles/VonKriesChromaticAdaptation.cs
@@ -31,12 +31,12 @@ public static class VonKriesChromaticAdaptation
 
         if (from.Equals(to))
         {
-            return new(source.X, source.Y, source.Z);
+            return new CieXyz(source.X, source.Y, source.Z);
         }
 
-        Vector3 sourceColorLms = Vector3.Transform(source.ToVector3(), matrix);
-        Vector3 sourceWhitePointLms = Vector3.Transform(from.ToVector3(), matrix);
-        Vector3 targetWhitePointLms = Vector3.Transform(to.ToVector3(), matrix);
+        Vector3 sourceColorLms = Vector3.Transform(source.AsVector3Unsafe(), matrix);
+        Vector3 sourceWhitePointLms = Vector3.Transform(from.AsVector3Unsafe(), matrix);
+        Vector3 targetWhitePointLms = Vector3.Transform(to.AsVector3Unsafe(), matrix);
 
         Vector3 vector = targetWhitePointLms / sourceWhitePointLms;
         Vector3 targetColorLms = Vector3.Multiply(vector, sourceColorLms);
@@ -76,8 +76,8 @@ public static class VonKriesChromaticAdaptation
         ref CieXyz sourceBase = ref MemoryMarshal.GetReference(source);
         ref CieXyz destinationBase = ref MemoryMarshal.GetReference(destination);
 
-        Vector3 sourceWhitePointLms = Vector3.Transform(from.ToVector3(), matrix);
-        Vector3 targetWhitePointLms = Vector3.Transform(to.ToVector3(), matrix);
+        Vector3 sourceWhitePointLms = Vector3.Transform(from.AsVector3Unsafe(), matrix);
+        Vector3 targetWhitePointLms = Vector3.Transform(to.AsVector3Unsafe(), matrix);
 
         Vector3 vector = targetWhitePointLms / sourceWhitePointLms;
 
@@ -86,7 +86,7 @@ public static class VonKriesChromaticAdaptation
             ref CieXyz sp = ref Unsafe.Add(ref sourceBase, i);
             ref CieXyz dp = ref Unsafe.Add(ref destinationBase, i);
 
-            Vector3 sourceColorLms = Vector3.Transform(sp.ToVector3(), matrix);
+            Vector3 sourceColorLms = Vector3.Transform(sp.AsVector3Unsafe(), matrix);
 
             Vector3 targetColorLms = Vector3.Multiply(vector, sourceColorLms);
             dp = new CieXyz(Vector3.Transform(targetColorLms, inverseMatrix));
diff --git a/src/ImageSharp/ColorProfiles/Y.cs b/src/ImageSharp/ColorProfiles/Y.cs
new file mode 100644
index 0000000000..2be34fc311
--- /dev/null
+++ b/src/ImageSharp/ColorProfiles/Y.cs
@@ -0,0 +1,142 @@
+// Copyright (c) Six Labors.
+// Licensed under the Six Labors Split License.
+
+using System.Numerics;
+using System.Runtime.CompilerServices;
+using System.Runtime.InteropServices;
+
+namespace SixLabors.ImageSharp.ColorProfiles;
+
+/// <summary>
+/// Represents a Y (luminance) color.
+/// </summary>
+[StructLayout(LayoutKind.Sequential)]
+public readonly struct Y : IColorProfile<Y, Rgb>
+{
+    /// <summary>
+    /// Initializes a new instance of the <see cref="Y"/> struct.
+    /// </summary>
+    /// <param name="l">The luminance component.</param>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public Y(float l) => this.L = Numerics.Clamp(l, 0, 1);
+
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+#pragma warning disable SA1313 // Parameter names should begin with lower-case letter
+    private Y(float l, bool _) => this.L = l;
+#pragma warning restore SA1313 // Parameter names should begin with lower-case letter
+
+    /// <summary>
+    /// Gets the luminance component.
+    /// </summary>
+    /// <remarks>A value ranging between 0 and 1.</remarks>
+    public float L { get; }
+
+    /// <summary>
+    /// Compares two <see cref="Y"/> objects for equality.
+    /// </summary>
+    /// <param name="left">The <see cref="Y"/> on the left side of the operand.</param>
+    /// <param name="right">The <see cref="Y"/> on the right side of the operand.</param>
+    /// <returns>
+    /// True if the current left is equal to the <paramref name="right"/> parameter; otherwise, false.
+    /// </returns>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static bool operator ==(Y left, Y right) => left.Equals(right);
+
+    /// <summary>
+    /// Compares two <see cref="Y"/> objects for inequality.
+    /// </summary>
+    /// <param name="left">The <see cref="Y"/> on the left side of the operand.</param>
+    /// <param name="right">The <see cref="Y"/> on the right side of the operand.</param>
+    /// <returns>
+    /// True if the current left is unequal to the <paramref name="right"/> parameter; otherwise, false.
+    /// </returns>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static bool operator !=(Y left, Y right) => !left.Equals(right);
+
+    /// <inheritdoc/>
+    public Vector4 ToScaledVector4() => new(this.L);
+
+    /// <inheritdoc/>
+    public static Y FromScaledVector4(Vector4 source) => new(source.X, true);
+
+    /// <inheritdoc/>
+    public static void ToScaledVector4(ReadOnlySpan<Y> source, Span<Vector4> destination)
+    {
+        Guard.DestinationShouldNotBeTooShort(source, destination, nameof(destination));
+
+        // TODO: Optimize via SIMD
+        for (int i = 0; i < source.Length; i++)
+        {
+            destination[i] = source[i].ToScaledVector4();
+        }
+    }
+
+    /// <inheritdoc/>
+    public static void FromScaledVector4(ReadOnlySpan<Vector4> source, Span<Y> destination)
+    {
+        Guard.DestinationShouldNotBeTooShort(source, destination, nameof(destination));
+
+        // TODO: Optimize via SIMD
+        for (int i = 0; i < source.Length; i++)
+        {
+            destination[i] = FromScaledVector4(source[i]);
+        }
+    }
+
+    /// <inheritdoc/>
+    public Rgb ToProfileConnectingSpace(ColorConversionOptions options)
+        => new(this.L, this.L, this.L);
+
+    /// <inheritdoc/>
+    public static Y FromProfileConnectingSpace(ColorConversionOptions options, in Rgb source)
+    {
+        Matrix4x4 m = options.YCbCrTransform.Forward;
+        float offset = options.YCbCrTransform.Offset.X;
+        return new Y(Vector3.Dot(source.AsVector3Unsafe(), new Vector3(m.M11, m.M12, m.M13)) + offset);
+    }
+
+    /// <inheritdoc/>
+    public static void ToProfileConnectionSpace(ColorConversionOptions options, ReadOnlySpan<Y> source, Span<Rgb> destination)
+    {
+        Guard.DestinationShouldNotBeTooShort(source, destination, nameof(destination));
+
+        // TODO: We can optimize this by using SIMD
+        for (int i = 0; i < source.Length; i++)
+        {
+            destination[i] = source[i].ToProfileConnectingSpace(options);
+        }
+    }
+
+    /// <inheritdoc/>
+    public static void FromProfileConnectionSpace(ColorConversionOptions options, ReadOnlySpan<Rgb> source, Span<Y> destination)
+    {
+        Guard.DestinationShouldNotBeTooShort(source, destination, nameof(destination));
+
+        // TODO: We can optimize this by using SIMD
+        for (int i = 0; i < source.Length; i++)
+        {
+            Rgb rgb = source[i];
+            destination[i] = FromProfileConnectingSpace(options, in rgb);
+        }
+    }
+
+    /// <inheritdoc/>
+    public static ChromaticAdaptionWhitePointSource GetChromaticAdaptionWhitePointSource()
+        => ChromaticAdaptionWhitePointSource.RgbWorkingSpace;
+
+    /// <inheritdoc/>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public override int GetHashCode()
+        => this.L.GetHashCode();
+
+    /// <inheritdoc/>
+    public override string ToString()
+        => FormattableString.Invariant($"Y({this.L:#0.##})");
+
+    /// <inheritdoc/>
+    public override bool Equals(object? obj)
+        => obj is Y other && this.Equals(other);
+
+    /// <inheritdoc/>
+    public bool Equals(Y other) => this.L == other.L;
+}
diff --git a/src/ImageSharp/ColorProfiles/YCbCr.cs b/src/ImageSharp/ColorProfiles/YCbCr.cs
index 03bd1d3120..22d629373b 100644
--- a/src/ImageSharp/ColorProfiles/YCbCr.cs
+++ b/src/ImageSharp/ColorProfiles/YCbCr.cs
@@ -8,15 +8,13 @@ using System.Runtime.InteropServices;
 namespace SixLabors.ImageSharp.ColorProfiles;
 
 /// <summary>
-/// Represents an YCbCr (luminance, blue chroma, red chroma) color as defined in the ITU-T T.871 specification for the JFIF use with Jpeg.
-/// <see href="http://en.wikipedia.org/wiki/YCbCr"/>
-/// <see href="http://www.ijg.org/files/T-REC-T.871-201105-I!!PDF-E.pdf"/>
+/// Represents an YCbCr (luminance, blue chroma, red chroma) color.
 /// </summary>
 [StructLayout(LayoutKind.Sequential)]
 public readonly struct YCbCr : IColorProfile<YCbCr, Rgb>
 {
     private static readonly Vector3 Min = Vector3.Zero;
-    private static readonly Vector3 Max = new(255);
+    private static readonly Vector3 Max = Vector3.One;
 
     /// <summary>
     /// Initializes a new instance of the <see cref="YCbCr"/> struct.
@@ -43,21 +41,31 @@ public readonly struct YCbCr : IColorProfile<YCbCr, Rgb>
         this.Cr = vector.Z;
     }
 
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+#pragma warning disable SA1313 // Parameter names should begin with lower-case letter
+    private YCbCr(Vector3 vector, bool _)
+#pragma warning restore SA1313 // Parameter names should begin with lower-case letter
+    {
+        this.Y = vector.X;
+        this.Cb = vector.Y;
+        this.Cr = vector.Z;
+    }
+
     /// <summary>
     /// Gets the Y luminance component.
-    /// <remarks>A value ranging between 0 and 255.</remarks>
+    /// <remarks>A value ranging between 0 and 1.</remarks>
     /// </summary>
     public float Y { get; }
 
     /// <summary>
     /// Gets the Cb chroma component.
-    /// <remarks>A value ranging between 0 and 255.</remarks>
+    /// <remarks>A value ranging between 0 and 1.</remarks>
     /// </summary>
     public float Cb { get; }
 
     /// <summary>
     /// Gets the Cr chroma component.
-    /// <remarks>A value ranging between 0 and 255.</remarks>
+    /// <remarks>A value ranging between 0 and 1.</remarks>
     /// </summary>
     public float Cr { get; }
 
@@ -83,18 +91,49 @@ public readonly struct YCbCr : IColorProfile<YCbCr, Rgb>
     public static bool operator !=(YCbCr left, YCbCr right) => !left.Equals(right);
 
     /// <inheritdoc/>
-    public static YCbCr FromProfileConnectingSpace(ColorConversionOptions options, in Rgb source)
+    public Vector4 ToScaledVector4()
     {
-        Vector3 rgb = source.ToScaledVector3() * Max;
-        float r = rgb.X;
-        float g = rgb.Y;
-        float b = rgb.Z;
+        Vector3 v3 = default;
+        v3 += this.AsVector3Unsafe();
+        return new Vector4(v3, 1F);
+    }
 
-        float y = (0.299F * r) + (0.587F * g) + (0.114F * b);
-        float cb = 128F + ((-0.168736F * r) - (0.331264F * g) + (0.5F * b));
-        float cr = 128F + ((0.5F * r) - (0.418688F * g) - (0.081312F * b));
+    /// <inheritdoc/>
+    public static YCbCr FromScaledVector4(Vector4 source)
+        => new(source.AsVector3(), true);
+
+    /// <inheritdoc/>
+    public static void ToScaledVector4(ReadOnlySpan<YCbCr> source, Span<Vector4> destination)
+    {
+        Guard.DestinationShouldNotBeTooShort(source, destination, nameof(destination));
 
-        return new YCbCr(y, cb, cr);
+        // TODO: Optimize via SIMD
+        for (int i = 0; i < source.Length; i++)
+        {
+            destination[i] = source[i].ToScaledVector4();
+        }
+    }
+
+    /// <inheritdoc/>
+    public static void FromScaledVector4(ReadOnlySpan<Vector4> source, Span<YCbCr> destination)
+    {
+        Guard.DestinationShouldNotBeTooShort(source, destination, nameof(destination));
+
+        // TODO: Optimize via SIMD
+        for (int i = 0; i < source.Length; i++)
+        {
+            destination[i] = FromScaledVector4(source[i]);
+        }
+    }
+
+    /// <inheritdoc/>
+    public static YCbCr FromProfileConnectingSpace(ColorConversionOptions options, in Rgb source)
+    {
+        Vector3 rgb = source.AsVector3Unsafe();
+        Matrix4x4 m = options.TransposedYCbCrTransform.Forward;
+        Vector3 offset = options.TransposedYCbCrTransform.Offset;
+
+        return new YCbCr(Vector3.Transform(rgb, m) + offset, true);
     }
 
     /// <inheritdoc/>
@@ -113,15 +152,11 @@ public readonly struct YCbCr : IColorProfile<YCbCr, Rgb>
     /// <inheritdoc/>
     public Rgb ToProfileConnectingSpace(ColorConversionOptions options)
     {
-        float y = this.Y;
-        float cb = this.Cb - 128F;
-        float cr = this.Cr - 128F;
-
-        float r = MathF.Round(y + (1.402F * cr), MidpointRounding.AwayFromZero);
-        float g = MathF.Round(y - (0.344136F * cb) - (0.714136F * cr), MidpointRounding.AwayFromZero);
-        float b = MathF.Round(y + (1.772F * cb), MidpointRounding.AwayFromZero);
+        Matrix4x4 m = options.TransposedYCbCrTransform.Inverse;
+        Vector3 offset = options.TransposedYCbCrTransform.Offset;
+        Vector3 normalized = this.AsVector3Unsafe() - offset;
 
-        return Rgb.FromScaledVector3(new Vector3(r, g, b) / Max);
+        return Rgb.FromScaledVector3(Vector3.Transform(normalized, m));
     }
 
     /// <inheritdoc/>
@@ -132,8 +167,7 @@ public readonly struct YCbCr : IColorProfile<YCbCr, Rgb>
         // TODO: We can optimize this by using SIMD
         for (int i = 0; i < source.Length; i++)
         {
-            YCbCr ycbcr = source[i];
-            destination[i] = ycbcr.ToProfileConnectingSpace(options);
+            destination[i] = source[i].ToProfileConnectingSpace(options);
         }
     }
 
diff --git a/src/ImageSharp/ColorProfiles/YCbCrTransform.cs b/src/ImageSharp/ColorProfiles/YCbCrTransform.cs
new file mode 100644
index 0000000000..c90b90708d
--- /dev/null
+++ b/src/ImageSharp/ColorProfiles/YCbCrTransform.cs
@@ -0,0 +1,61 @@
+// Copyright (c) Six Labors.
+// Licensed under the Six Labors Split License.
+
+using System.Numerics;
+using SixLabors.ImageSharp.ColorProfiles.WorkingSpaces;
+
+namespace SixLabors.ImageSharp.ColorProfiles;
+
+/// <summary>
+/// <para>
+/// Represents a YCbCr color transform containing forward and inverse transformation matrices,
+/// and the chrominance offsets to apply for full-range encoding
+/// </para>
+/// <para>
+/// These matrices must be selected to match the characteristics of the associated <see cref="RgbWorkingSpace"/>,
+/// including its transfer function (gamma or companding) and chromaticity coordinates. Using mismatched matrices and
+/// working spaces will produce incorrect conversions.
+/// </para>
+/// </summary>
+public readonly struct YCbCrTransform
+{
+    /// <summary>
+    /// Initializes a new instance of the <see cref="YCbCrTransform"/> struct.
+    /// </summary>
+    /// <param name="forward">
+    /// The forward transformation matrix from RGB to YCbCr. The matrix must include the
+    /// standard chrominance offsets in the fourth column, such as <c>(0, 0.5, 0.5)</c>.
+    /// </param>
+    /// <param name="inverse">
+    /// The inverse transformation matrix from YCbCr to RGB. This matrix expects that
+    /// chrominance offsets have already been subtracted prior to application.
+    /// </param>
+    /// <param name="offset">
+    /// The chrominance offsets to be added after the forward conversion,
+    /// and subtracted before the inverse conversion. Usually <c>(0, 0.5, 0.5)</c>.
+    /// </param>
+    public YCbCrTransform(Matrix4x4 forward, Matrix4x4 inverse, Vector3 offset)
+    {
+        this.Forward = forward;
+        this.Inverse = inverse;
+        this.Offset = offset;
+    }
+
+    /// <summary>
+    /// Gets the matrix used to convert gamma-encoded RGB to YCbCr.
+    /// </summary>
+    public Matrix4x4 Forward { get; }
+
+    /// <summary>
+    /// Gets the matrix used to convert YCbCr back to gamma-encoded RGB.
+    /// </summary>
+    public Matrix4x4 Inverse { get; }
+
+    /// <summary>
+    /// Gets the chrominance offset vector to apply during encoding (add) or decoding (subtract).
+    /// </summary>
+    public Vector3 Offset { get; }
+
+    internal YCbCrTransform Transpose()
+        => new(Matrix4x4.Transpose(this.Forward), Matrix4x4.Transpose(this.Inverse), this.Offset);
+}
diff --git a/src/ImageSharp/ColorProfiles/YccK.cs b/src/ImageSharp/ColorProfiles/YccK.cs
new file mode 100644
index 0000000000..df5eb48947
--- /dev/null
+++ b/src/ImageSharp/ColorProfiles/YccK.cs
@@ -0,0 +1,206 @@
+// Copyright (c) Six Labors.
+// Licensed under the Six Labors Split License.
+
+using System.Numerics;
+using System.Runtime.CompilerServices;
+using System.Runtime.InteropServices;
+
+namespace SixLabors.ImageSharp.ColorProfiles;
+
+/// <summary>
+/// Represents a YCCK (luminance, blue chroma, red chroma, black) color.
+/// YCCK is not a true color space but a reversible transform of CMYK, where the CMY components
+/// are converted to YCbCr using the ITU-R BT.601 standard, and the K (black) component is preserved separately.
+/// </summary>
+[StructLayout(LayoutKind.Sequential)]
+public readonly struct YccK : IColorProfile<YccK, Rgb>
+{
+    private static readonly Vector4 Min = Vector4.Zero;
+    private static readonly Vector4 Max = Vector4.One;
+
+    /// <summary>
+    /// Initializes a new instance of the <see cref="YccK"/> struct.
+    /// </summary>
+    /// <param name="y">The y luminance component.</param>
+    /// <param name="cb">The cb chroma component.</param>
+    /// <param name="cr">The cr chroma component.</param>
+    /// <param name="k">The keyline black component.</param>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public YccK(float y, float cb, float cr, float k)
+        : this(new Vector4(y, cb, cr, k))
+    {
+    }
+
+    /// <summary>
+    /// Initializes a new instance of the <see cref="YccK"/> struct.
+    /// </summary>
+    /// <param name="vector">The vector representing the c, m, y, k components.</param>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public YccK(Vector4 vector)
+    {
+        vector = Vector4.Clamp(vector, Min, Max);
+        this.Y = vector.X;
+        this.Cb = vector.Y;
+        this.Cr = vector.Z;
+        this.K = vector.W;
+    }
+
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+#pragma warning disable SA1313 // Parameter names should begin with lower-case letter
+    private YccK(Vector4 vector, bool _)
+#pragma warning restore SA1313 // Parameter names should begin with lower-case letter
+    {
+        this.Y = vector.X;
+        this.Cb = vector.Y;
+        this.Cr = vector.Z;
+        this.K = vector.W;
+    }
+
+    /// <summary>
+    /// Gets the Y luminance component.
+    /// <remarks>A value ranging between 0 and 1.</remarks>
+    /// </summary>
+    public float Y { get; }
+
+    /// <summary>
+    /// Gets the C (blue) chroma component.
+    /// <remarks>A value ranging between 0 and 1.</remarks>
+    /// </summary>
+    public float Cb { get; }
+
+    /// <summary>
+    /// Gets the C (red) chroma component.
+    /// <remarks>A value ranging between 0 and 1.</remarks>
+    /// </summary>
+    public float Cr { get; }
+
+    /// <summary>
+    /// Gets the keyline black color component.
+    /// <remarks>A value ranging between 0 and 1.</remarks>
+    /// </summary>
+    public float K { get; }
+
+    /// <summary>
+    /// Compares two <see cref="YccK"/> objects for equality.
+    /// </summary>
+    /// <param name="left">The <see cref="YccK"/> on the left side of the operand.</param>
+    /// <param name="right">The <see cref="YccK"/> on the right side of the operand.</param>
+    /// <returns>
+    /// True if the current left is equal to the <paramref name="right"/> parameter; otherwise, false.
+    /// </returns>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static bool operator ==(YccK left, YccK right) => left.Equals(right);
+
+    /// <summary>
+    /// Compares two <see cref="YccK"/> objects for inequality.
+    /// </summary>
+    /// <param name="left">The <see cref="YccK"/> on the left side of the operand.</param>
+    /// <param name="right">The <see cref="YccK"/> on the right side of the operand.</param>
+    /// <returns>
+    /// True if the current left is unequal to the <paramref name="right"/> parameter; otherwise, false.
+    /// </returns>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static bool operator !=(YccK left, YccK right) => !left.Equals(right);
+
+    /// <inheritdoc/>
+    public Vector4 ToScaledVector4()
+    {
+        Vector4 v4 = default;
+        v4 += this.AsVector4Unsafe();
+        return v4;
+    }
+
+    /// <inheritdoc/>
+    public static YccK FromScaledVector4(Vector4 source)
+        => new(source, true);
+
+    /// <inheritdoc/>
+    public static void ToScaledVector4(ReadOnlySpan<YccK> source, Span<Vector4> destination)
+    {
+        Guard.DestinationShouldNotBeTooShort(source, destination, nameof(destination));
+        MemoryMarshal.Cast<YccK, Vector4>(source).CopyTo(destination);
+    }
+
+    /// <inheritdoc/>
+    public static void FromScaledVector4(ReadOnlySpan<Vector4> source, Span<YccK> destination)
+    {
+        Guard.DestinationShouldNotBeTooShort(source, destination, nameof(destination));
+        MemoryMarshal.Cast<Vector4, YccK>(source).CopyTo(destination);
+    }
+
+    /// <inheritdoc/>
+    public Rgb ToProfileConnectingSpace(ColorConversionOptions options)
+    {
+        Matrix4x4 m = options.TransposedYCbCrTransform.Inverse;
+        Vector3 offset = options.TransposedYCbCrTransform.Offset;
+        Vector3 normalized = this.AsVector3Unsafe() - offset;
+
+        return Rgb.FromScaledVector3(Vector3.Transform(normalized, m) * (1F - this.K));
+    }
+
+    /// <inheritdoc/>
+    public static YccK FromProfileConnectingSpace(ColorConversionOptions options, in Rgb source)
+    {
+        Matrix4x4 m = options.TransposedYCbCrTransform.Forward;
+        Vector3 offset = options.TransposedYCbCrTransform.Offset;
+
+        Vector3 rgb = source.AsVector3Unsafe();
+        float k = 1F - MathF.Max(rgb.X, MathF.Max(rgb.Y, rgb.Z));
+
+        if (k >= 1F - Constants.Epsilon)
+        {
+            return new YccK(new Vector4(0F, 0.5F, 0.5F, 1F), true);
+        }
+
+        rgb /= 1F - k;
+        return new YccK(new Vector4(Vector3.Transform(rgb, m), k) + new Vector4(offset, 0F));
+    }
+
+    /// <inheritdoc/>
+    public static void ToProfileConnectionSpace(ColorConversionOptions options, ReadOnlySpan<YccK> source, Span<Rgb> destination)
+    {
+        // TODO: We can possibly optimize this by using SIMD
+        for (int i = 0; i < source.Length; i++)
+        {
+            destination[i] = source[i].ToProfileConnectingSpace(options);
+        }
+    }
+
+    /// <inheritdoc/>
+    public static void FromProfileConnectionSpace(ColorConversionOptions options, ReadOnlySpan<Rgb> source, Span<YccK> destination)
+    {
+        Guard.DestinationShouldNotBeTooShort(source, destination, nameof(destination));
+
+        // TODO: We can optimize this by using SIMD
+        for (int i = 0; i < source.Length; i++)
+        {
+            Rgb rgb = source[i];
+            destination[i] = FromProfileConnectingSpace(options, in rgb);
+        }
+    }
+
+    /// <inheritdoc/>
+    public static ChromaticAdaptionWhitePointSource GetChromaticAdaptionWhitePointSource()
+        => ChromaticAdaptionWhitePointSource.RgbWorkingSpace;
+
+    /// <inheritdoc/>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public override int GetHashCode()
+        => HashCode.Combine(this.Y, this.Cb, this.Cr, this.K);
+
+    /// <inheritdoc/>
+    public override string ToString()
+        => FormattableString.Invariant($"YccK({this.Y:#0.##}, {this.Cb:#0.##}, {this.Cr:#0.##}, {this.K:#0.##})");
+
+    /// <inheritdoc/>
+    public override bool Equals(object? obj)
+        => obj is YccK other && this.Equals(other);
+
+    /// <inheritdoc/>
+    public bool Equals(YccK other)
+        => this.AsVector4Unsafe() == other.AsVector4Unsafe();
+
+    private Vector3 AsVector3Unsafe() => Unsafe.As<YccK, Vector3>(ref Unsafe.AsRef(in this));
+
+    private Vector4 AsVector4Unsafe() => Unsafe.As<YccK, Vector4>(ref Unsafe.AsRef(in this));
+}
diff --git a/src/ImageSharp/Common/Extensions/Vector4Extensions.cs b/src/ImageSharp/Common/Extensions/Vector4Extensions.cs
new file mode 100644
index 0000000000..4e8ea61742
--- /dev/null
+++ b/src/ImageSharp/Common/Extensions/Vector4Extensions.cs
@@ -0,0 +1,21 @@
+// Copyright (c) Six Labors.
+// Licensed under the Six Labors Split License.
+
+#if !NET9_0_OR_GREATER
+using System.Numerics;
+using System.Runtime.CompilerServices;
+using System.Runtime.Intrinsics;
+
+namespace SixLabors.ImageSharp;
+
+internal static class Vector4Extensions
+{
+    /// <summary>
+    /// Reinterprets a <see cref="Vector4" /> as a new <see cref="Vector3" />.
+    /// </summary>
+    /// <param name="value">The vector to reinterpret.</param>
+    /// <returns><paramref name="value" /> reinterpreted as a new <see cref="Vector3" />.</returns>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static Vector3 AsVector3(this Vector4 value) => value.AsVector128().AsVector3();
+}
+#endif
diff --git a/src/ImageSharp/Common/Helpers/HexConverter.cs b/src/ImageSharp/Common/Helpers/HexConverter.cs
index 8c473688f3..a6face960e 100644
--- a/src/ImageSharp/Common/Helpers/HexConverter.cs
+++ b/src/ImageSharp/Common/Helpers/HexConverter.cs
@@ -35,8 +35,8 @@ internal static class HexConverter
         {
             // Map from an ASCII char to its hex value, e.g. arr['b'] == 11. 0xFF means it's not a hex digit.
             // This doesn't actually allocate.
-            ReadOnlySpan<byte> charToHexLookup = new byte[]
-            {
+            ReadOnlySpan<byte> charToHexLookup =
+            [
                 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, // 15
                 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, // 31
                 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, // 47
@@ -52,8 +52,8 @@ internal static class HexConverter
                 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, // 207
                 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, // 223
                 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, // 239
-                0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, // 255
-            };
+                0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF // 255
+            ];
 
             return (uint)c >= (uint)charToHexLookup.Length ? 0xFF : charToHexLookup[c];
         }
diff --git a/src/ImageSharp/Common/Helpers/Numerics.cs b/src/ImageSharp/Common/Helpers/Numerics.cs
index ca14ae4c38..ff28063f05 100644
--- a/src/ImageSharp/Common/Helpers/Numerics.cs
+++ b/src/ImageSharp/Common/Helpers/Numerics.cs
@@ -470,8 +470,8 @@ internal static class Numerics
         where T : unmanaged
     {
         ref T sRef = ref MemoryMarshal.GetReference(span);
-        var vmin = new Vector<T>(min);
-        var vmax = new Vector<T>(max);
+        Vector<T> vmin = new(min);
+        Vector<T> vmax = new(max);
 
         nint n = (nint)(uint)span.Length / Vector<T>.Count;
         nint m = Modulo4(n);
@@ -656,7 +656,7 @@ internal static class Numerics
             return Sse.Shuffle(value.AsVector128(), value.AsVector128(), ShuffleAlphaControl).AsVector4();
         }
 
-        return new(value.W);
+        return new Vector4(value.W);
     }
 
     /// <summary>
@@ -726,12 +726,12 @@ internal static class Numerics
             ref Vector128<float> vectors128Ref = ref Unsafe.As<Vector4, Vector128<float>>(ref MemoryMarshal.GetReference(vectors));
             ref Vector128<float> vectors128End = ref Unsafe.Add(ref vectors128Ref, (uint)vectors.Length);
 
-            var v128_341 = Vector128.Create(341);
+            Vector128<int> v128_341 = Vector128.Create(341);
             Vector128<int> v128_negativeZero = Vector128.Create(-0.0f).AsInt32();
             Vector128<int> v128_one = Vector128.Create(1.0f).AsInt32();
 
-            var v128_13rd = Vector128.Create(1 / 3f);
-            var v128_23rds = Vector128.Create(2 / 3f);
+            Vector128<float> v128_13rd = Vector128.Create(1 / 3f);
+            Vector128<float> v128_23rds = Vector128.Create(2 / 3f);
 
             while (Unsafe.IsAddressLessThan(ref vectors128Ref, ref vectors128End))
             {
@@ -884,23 +884,6 @@ internal static class Numerics
         accumulator += intHigh;
     }
 
-    /// <summary>
-    /// Reduces elements of the vector into one sum.
-    /// </summary>
-    /// <param name="accumulator">The accumulator to reduce.</param>
-    /// <returns>The sum of all elements.</returns>
-    [MethodImpl(MethodImplOptions.AggressiveInlining)]
-    public static int ReduceSum(Vector128<int> accumulator)
-    {
-        // Add odd to even.
-        Vector128<int> vsum = Sse2.Add(accumulator, Sse2.Shuffle(accumulator, 0b_11_11_01_01));
-
-        // Add high to low.
-        vsum = Sse2.Add(vsum, Sse2.Shuffle(vsum, 0b_11_10_11_10));
-
-        return Sse2.ConvertToInt32(vsum);
-    }
-
     /// <summary>
     /// Reduces elements of the vector into one sum.
     /// </summary>
diff --git a/src/ImageSharp/Common/Helpers/SimdUtils.HwIntrinsics.cs b/src/ImageSharp/Common/Helpers/SimdUtils.HwIntrinsics.cs
index 17ccb396d6..ff5ea5de33 100644
--- a/src/ImageSharp/Common/Helpers/SimdUtils.HwIntrinsics.cs
+++ b/src/ImageSharp/Common/Helpers/SimdUtils.HwIntrinsics.cs
@@ -66,9 +66,9 @@ internal static partial class SimdUtils
             ref Span<float> destination,
             [ConstantExpected] byte control)
         {
-            if ((Vector512.IsHardwareAccelerated && Vector512Utilities.SupportsShuffleFloat) ||
-                (Vector256.IsHardwareAccelerated && Vector256Utilities.SupportsShuffleFloat) ||
-                (Vector128.IsHardwareAccelerated && Vector128Utilities.SupportsShuffleFloat))
+            if (Vector512.IsHardwareAccelerated ||
+                Vector256.IsHardwareAccelerated ||
+                Vector128.IsHardwareAccelerated)
             {
                 int remainder = 0;
                 if (Vector512.IsHardwareAccelerated)
@@ -112,9 +112,9 @@ internal static partial class SimdUtils
             ref Span<byte> destination,
             [ConstantExpected] byte control)
         {
-            if ((Vector512.IsHardwareAccelerated && Vector512Utilities.SupportsShuffleByte) ||
-                (Vector256.IsHardwareAccelerated && Vector256Utilities.SupportsShuffleByte) ||
-                (Vector128.IsHardwareAccelerated && Vector128Utilities.SupportsShuffleByte))
+            if (Vector512.IsHardwareAccelerated ||
+                Vector256.IsHardwareAccelerated ||
+                Vector128.IsHardwareAccelerated)
             {
                 int remainder = 0;
                 if (Vector512.IsHardwareAccelerated)
@@ -158,7 +158,7 @@ internal static partial class SimdUtils
             ref Span<byte> destination,
             [ConstantExpected] byte control)
         {
-            if (Vector128.IsHardwareAccelerated && Vector128Utilities.SupportsShuffleByte && Vector128Utilities.SupportsRightAlign)
+            if (Vector128.IsHardwareAccelerated)
             {
                 int remainder = source.Length % (Vector128<byte>.Count * 3);
 
@@ -190,7 +190,7 @@ internal static partial class SimdUtils
             ref Span<byte> destination,
             [ConstantExpected] byte control)
         {
-            if (Vector128.IsHardwareAccelerated && Vector128Utilities.SupportsShuffleByte && Vector128Utilities.SupportsShiftByte)
+            if (Vector128.IsHardwareAccelerated)
             {
                 int remainder = source.Length % (Vector128<byte>.Count * 3);
 
@@ -223,7 +223,7 @@ internal static partial class SimdUtils
             ref Span<byte> destination,
             [ConstantExpected] byte control)
         {
-            if (Vector128.IsHardwareAccelerated && Vector128Utilities.SupportsShuffleByte && Vector128Utilities.SupportsShiftByte)
+            if (Vector128.IsHardwareAccelerated)
             {
                 int remainder = source.Length & ((Vector128<byte>.Count * 4) - 1);    // bit-hack for modulo
 
@@ -249,7 +249,7 @@ internal static partial class SimdUtils
             Span<float> destination,
             [ConstantExpected] byte control)
         {
-            if (Vector512.IsHardwareAccelerated && Vector512Utilities.SupportsShuffleFloat)
+            if (Vector512.IsHardwareAccelerated)
             {
                 ref Vector512<float> sourceBase = ref Unsafe.As<float, Vector512<float>>(ref MemoryMarshal.GetReference(source));
                 ref Vector512<float> destinationBase = ref Unsafe.As<float, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
@@ -263,21 +263,21 @@ internal static partial class SimdUtils
                     ref Vector512<float> vs0 = ref Unsafe.Add(ref sourceBase, i);
                     ref Vector512<float> vd0 = ref Unsafe.Add(ref destinationBase, i);
 
-                    vd0 = Vector512Utilities.Shuffle(vs0, control);
-                    Unsafe.Add(ref vd0, (nuint)1) = Vector512Utilities.Shuffle(Unsafe.Add(ref vs0, (nuint)1), control);
-                    Unsafe.Add(ref vd0, (nuint)2) = Vector512Utilities.Shuffle(Unsafe.Add(ref vs0, (nuint)2), control);
-                    Unsafe.Add(ref vd0, (nuint)3) = Vector512Utilities.Shuffle(Unsafe.Add(ref vs0, (nuint)3), control);
+                    vd0 = Vector512_.ShuffleNative(vs0, control);
+                    Unsafe.Add(ref vd0, (nuint)1) = Vector512_.ShuffleNative(Unsafe.Add(ref vs0, (nuint)1), control);
+                    Unsafe.Add(ref vd0, (nuint)2) = Vector512_.ShuffleNative(Unsafe.Add(ref vs0, (nuint)2), control);
+                    Unsafe.Add(ref vd0, (nuint)3) = Vector512_.ShuffleNative(Unsafe.Add(ref vs0, (nuint)3), control);
                 }
 
                 if (m > 0)
                 {
                     for (nuint i = u; i < n; i++)
                     {
-                        Unsafe.Add(ref destinationBase, i) = Vector512Utilities.Shuffle(Unsafe.Add(ref sourceBase, i), control);
+                        Unsafe.Add(ref destinationBase, i) = Vector512_.ShuffleNative(Unsafe.Add(ref sourceBase, i), control);
                     }
                 }
             }
-            else if (Vector256.IsHardwareAccelerated && Vector256Utilities.SupportsShuffleFloat)
+            else if (Vector256.IsHardwareAccelerated)
             {
                 ref Vector256<float> sourceBase = ref Unsafe.As<float, Vector256<float>>(ref MemoryMarshal.GetReference(source));
                 ref Vector256<float> destinationBase = ref Unsafe.As<float, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
@@ -291,21 +291,21 @@ internal static partial class SimdUtils
                     ref Vector256<float> vs0 = ref Unsafe.Add(ref sourceBase, i);
                     ref Vector256<float> vd0 = ref Unsafe.Add(ref destinationBase, i);
 
-                    vd0 = Vector256Utilities.Shuffle(vs0, control);
-                    Unsafe.Add(ref vd0, (nuint)1) = Vector256Utilities.Shuffle(Unsafe.Add(ref vs0, (nuint)1), control);
-                    Unsafe.Add(ref vd0, (nuint)2) = Vector256Utilities.Shuffle(Unsafe.Add(ref vs0, (nuint)2), control);
-                    Unsafe.Add(ref vd0, (nuint)3) = Vector256Utilities.Shuffle(Unsafe.Add(ref vs0, (nuint)3), control);
+                    vd0 = Vector256_.ShuffleNative(vs0, control);
+                    Unsafe.Add(ref vd0, (nuint)1) = Vector256_.ShuffleNative(Unsafe.Add(ref vs0, (nuint)1), control);
+                    Unsafe.Add(ref vd0, (nuint)2) = Vector256_.ShuffleNative(Unsafe.Add(ref vs0, (nuint)2), control);
+                    Unsafe.Add(ref vd0, (nuint)3) = Vector256_.ShuffleNative(Unsafe.Add(ref vs0, (nuint)3), control);
                 }
 
                 if (m > 0)
                 {
                     for (nuint i = u; i < n; i++)
                     {
-                        Unsafe.Add(ref destinationBase, i) = Vector256Utilities.Shuffle(Unsafe.Add(ref sourceBase, i), control);
+                        Unsafe.Add(ref destinationBase, i) = Vector256_.ShuffleNative(Unsafe.Add(ref sourceBase, i), control);
                     }
                 }
             }
-            else if (Vector128.IsHardwareAccelerated && Vector128Utilities.SupportsShuffleFloat)
+            else if (Vector128.IsHardwareAccelerated)
             {
                 ref Vector128<float> sourceBase = ref Unsafe.As<float, Vector128<float>>(ref MemoryMarshal.GetReference(source));
                 ref Vector128<float> destinationBase = ref Unsafe.As<float, Vector128<float>>(ref MemoryMarshal.GetReference(destination));
@@ -319,17 +319,17 @@ internal static partial class SimdUtils
                     ref Vector128<float> vs0 = ref Unsafe.Add(ref sourceBase, i);
                     ref Vector128<float> vd0 = ref Unsafe.Add(ref destinationBase, i);
 
-                    vd0 = Vector128Utilities.Shuffle(vs0, control);
-                    Unsafe.Add(ref vd0, (nuint)1) = Vector128Utilities.Shuffle(Unsafe.Add(ref vs0, (nuint)1), control);
-                    Unsafe.Add(ref vd0, (nuint)2) = Vector128Utilities.Shuffle(Unsafe.Add(ref vs0, (nuint)2), control);
-                    Unsafe.Add(ref vd0, (nuint)3) = Vector128Utilities.Shuffle(Unsafe.Add(ref vs0, (nuint)3), control);
+                    vd0 = Vector128_.ShuffleNative(vs0, control);
+                    Unsafe.Add(ref vd0, (nuint)1) = Vector128_.ShuffleNative(Unsafe.Add(ref vs0, (nuint)1), control);
+                    Unsafe.Add(ref vd0, (nuint)2) = Vector128_.ShuffleNative(Unsafe.Add(ref vs0, (nuint)2), control);
+                    Unsafe.Add(ref vd0, (nuint)3) = Vector128_.ShuffleNative(Unsafe.Add(ref vs0, (nuint)3), control);
                 }
 
                 if (m > 0)
                 {
                     for (nuint i = u; i < n; i++)
                     {
-                        Unsafe.Add(ref destinationBase, i) = Vector128Utilities.Shuffle(Unsafe.Add(ref sourceBase, i), control);
+                        Unsafe.Add(ref destinationBase, i) = Vector128_.ShuffleNative(Unsafe.Add(ref sourceBase, i), control);
                     }
                 }
             }
@@ -341,7 +341,7 @@ internal static partial class SimdUtils
             Span<byte> destination,
             [ConstantExpected] byte control)
         {
-            if (Vector512.IsHardwareAccelerated && Vector512Utilities.SupportsShuffleByte)
+            if (Vector512.IsHardwareAccelerated)
             {
                 Span<byte> temp = stackalloc byte[Vector512<byte>.Count];
                 Shuffle.MMShuffleSpan(ref temp, control);
@@ -359,22 +359,27 @@ internal static partial class SimdUtils
                     ref Vector512<byte> vs0 = ref Unsafe.Add(ref sourceBase, i);
                     ref Vector512<byte> vd0 = ref Unsafe.Add(ref destinationBase, i);
 
-                    vd0 = Vector512Utilities.Shuffle(vs0, mask);
-                    Unsafe.Add(ref vd0, (nuint)1) = Vector512Utilities.Shuffle(Unsafe.Add(ref vs0, (nuint)1), mask);
-                    Unsafe.Add(ref vd0, (nuint)2) = Vector512Utilities.Shuffle(Unsafe.Add(ref vs0, (nuint)2), mask);
-                    Unsafe.Add(ref vd0, (nuint)3) = Vector512Utilities.Shuffle(Unsafe.Add(ref vs0, (nuint)3), mask);
+                    vd0 = Vector512_.ShuffleNative(vs0, mask);
+                    Unsafe.Add(ref vd0, (nuint)1) = Vector512_.ShuffleNative(Unsafe.Add(ref vs0, (nuint)1), mask);
+                    Unsafe.Add(ref vd0, (nuint)2) = Vector512_.ShuffleNative(Unsafe.Add(ref vs0, (nuint)2), mask);
+                    Unsafe.Add(ref vd0, (nuint)3) = Vector512_.ShuffleNative(Unsafe.Add(ref vs0, (nuint)3), mask);
                 }
 
                 if (m > 0)
                 {
                     for (nuint i = u; i < n; i++)
                     {
-                        Unsafe.Add(ref destinationBase, i) = Vector512Utilities.Shuffle(Unsafe.Add(ref sourceBase, i), mask);
+                        Unsafe.Add(ref destinationBase, i) = Vector512_.ShuffleNative(Unsafe.Add(ref sourceBase, i), mask);
                     }
                 }
             }
-            else if (Vector256.IsHardwareAccelerated && Vector256Utilities.SupportsShuffleByte)
+            else if (Vector256.IsHardwareAccelerated)
             {
+                // ShufflePerLane performs per-128-bit-lane shuffling using Avx2.Shuffle (vpshufb).
+                // MMShuffleSpan generates indices in the range [0, 31] and never sets bit 7 in any byte,
+                // so the shuffle will not zero elements. Because vpshufb uses only the low 4 bits (b[i] & 0x0F)
+                // for indexing within each lane, and ignores the upper bits unless bit 7 is set,
+                // this usage is guaranteed to remain within-lane and non-zeroing.
                 Span<byte> temp = stackalloc byte[Vector256<byte>.Count];
                 Shuffle.MMShuffleSpan(ref temp, control);
                 Vector256<byte> mask = Unsafe.As<byte, Vector256<byte>>(ref MemoryMarshal.GetReference(temp));
@@ -391,21 +396,21 @@ internal static partial class SimdUtils
                     ref Vector256<byte> vs0 = ref Unsafe.Add(ref sourceBase, i);
                     ref Vector256<byte> vd0 = ref Unsafe.Add(ref destinationBase, i);
 
-                    vd0 = Vector256Utilities.Shuffle(vs0, mask);
-                    Unsafe.Add(ref vd0, (nuint)1) = Vector256Utilities.Shuffle(Unsafe.Add(ref vs0, (nuint)1), mask);
-                    Unsafe.Add(ref vd0, (nuint)2) = Vector256Utilities.Shuffle(Unsafe.Add(ref vs0, (nuint)2), mask);
-                    Unsafe.Add(ref vd0, (nuint)3) = Vector256Utilities.Shuffle(Unsafe.Add(ref vs0, (nuint)3), mask);
+                    vd0 = Vector256_.ShufflePerLane(vs0, mask);
+                    Unsafe.Add(ref vd0, (nuint)1) = Vector256_.ShufflePerLane(Unsafe.Add(ref vs0, (nuint)1), mask);
+                    Unsafe.Add(ref vd0, (nuint)2) = Vector256_.ShufflePerLane(Unsafe.Add(ref vs0, (nuint)2), mask);
+                    Unsafe.Add(ref vd0, (nuint)3) = Vector256_.ShufflePerLane(Unsafe.Add(ref vs0, (nuint)3), mask);
                 }
 
                 if (m > 0)
                 {
                     for (nuint i = u; i < n; i++)
                     {
-                        Unsafe.Add(ref destinationBase, i) = Vector256Utilities.Shuffle(Unsafe.Add(ref sourceBase, i), mask);
+                        Unsafe.Add(ref destinationBase, i) = Vector256_.ShufflePerLane(Unsafe.Add(ref sourceBase, i), mask);
                     }
                 }
             }
-            else if (Vector128.IsHardwareAccelerated && Vector128Utilities.SupportsShuffleByte)
+            else if (Vector128.IsHardwareAccelerated)
             {
                 Span<byte> temp = stackalloc byte[Vector128<byte>.Count];
                 Shuffle.MMShuffleSpan(ref temp, control);
@@ -423,17 +428,17 @@ internal static partial class SimdUtils
                     ref Vector128<byte> vs0 = ref Unsafe.Add(ref sourceBase, i);
                     ref Vector128<byte> vd0 = ref Unsafe.Add(ref destinationBase, i);
 
-                    vd0 = Vector128Utilities.Shuffle(vs0, mask);
-                    Unsafe.Add(ref vd0, (nuint)1) = Vector128Utilities.Shuffle(Unsafe.Add(ref vs0, (nuint)1), mask);
-                    Unsafe.Add(ref vd0, (nuint)2) = Vector128Utilities.Shuffle(Unsafe.Add(ref vs0, (nuint)2), mask);
-                    Unsafe.Add(ref vd0, (nuint)3) = Vector128Utilities.Shuffle(Unsafe.Add(ref vs0, (nuint)3), mask);
+                    vd0 = Vector128_.ShuffleNative(vs0, mask);
+                    Unsafe.Add(ref vd0, (nuint)1) = Vector128_.ShuffleNative(Unsafe.Add(ref vs0, (nuint)1), mask);
+                    Unsafe.Add(ref vd0, (nuint)2) = Vector128_.ShuffleNative(Unsafe.Add(ref vs0, (nuint)2), mask);
+                    Unsafe.Add(ref vd0, (nuint)3) = Vector128_.ShuffleNative(Unsafe.Add(ref vs0, (nuint)3), mask);
                 }
 
                 if (m > 0)
                 {
                     for (nuint i = u; i < n; i++)
                     {
-                        Unsafe.Add(ref destinationBase, i) = Vector128Utilities.Shuffle(Unsafe.Add(ref sourceBase, i), mask);
+                        Unsafe.Add(ref destinationBase, i) = Vector128_.ShuffleNative(Unsafe.Add(ref sourceBase, i), mask);
                     }
                 }
             }
@@ -445,11 +450,11 @@ internal static partial class SimdUtils
             Span<byte> destination,
             [ConstantExpected] byte control)
         {
-            if (Vector128.IsHardwareAccelerated && Vector128Utilities.SupportsShuffleByte && Vector128Utilities.SupportsRightAlign)
+            if (Vector128.IsHardwareAccelerated)
             {
                 Vector128<byte> maskPad4Nx16 = ShuffleMaskPad4Nx16();
                 Vector128<byte> maskSlice4Nx16 = ShuffleMaskSlice4Nx16();
-                Vector128<byte> maskE = Vector128Utilities.AlignRight(maskSlice4Nx16, maskSlice4Nx16, 12);
+                Vector128<byte> maskE = Vector128_.AlignRight(maskSlice4Nx16, maskSlice4Nx16, 12);
 
                 Span<byte> bytes = stackalloc byte[Vector128<byte>.Count];
                 Shuffle.MMShuffleSpan(ref bytes, control);
@@ -467,28 +472,28 @@ internal static partial class SimdUtils
                     Vector128<byte> v0 = vs;
                     Vector128<byte> v1 = Unsafe.Add(ref vs, (nuint)1);
                     Vector128<byte> v2 = Unsafe.Add(ref vs, (nuint)2);
-                    Vector128<byte> v3 = Vector128Utilities.ShiftRightBytesInVector(v2, 4);
+                    Vector128<byte> v3 = Vector128_.ShiftRightBytesInVector(v2, 4);
 
-                    v2 = Vector128Utilities.AlignRight(v2, v1, 8);
-                    v1 = Vector128Utilities.AlignRight(v1, v0, 12);
+                    v2 = Vector128_.AlignRight(v2, v1, 8);
+                    v1 = Vector128_.AlignRight(v1, v0, 12);
 
-                    v0 = Vector128Utilities.Shuffle(Vector128Utilities.Shuffle(v0, maskPad4Nx16), mask);
-                    v1 = Vector128Utilities.Shuffle(Vector128Utilities.Shuffle(v1, maskPad4Nx16), mask);
-                    v2 = Vector128Utilities.Shuffle(Vector128Utilities.Shuffle(v2, maskPad4Nx16), mask);
-                    v3 = Vector128Utilities.Shuffle(Vector128Utilities.Shuffle(v3, maskPad4Nx16), mask);
+                    v0 = Vector128_.ShuffleNative(Vector128_.ShuffleNative(v0, maskPad4Nx16), mask);
+                    v1 = Vector128_.ShuffleNative(Vector128_.ShuffleNative(v1, maskPad4Nx16), mask);
+                    v2 = Vector128_.ShuffleNative(Vector128_.ShuffleNative(v2, maskPad4Nx16), mask);
+                    v3 = Vector128_.ShuffleNative(Vector128_.ShuffleNative(v3, maskPad4Nx16), mask);
 
-                    v0 = Vector128Utilities.Shuffle(v0, maskE);
-                    v1 = Vector128Utilities.Shuffle(v1, maskSlice4Nx16);
-                    v2 = Vector128Utilities.Shuffle(v2, maskE);
-                    v3 = Vector128Utilities.Shuffle(v3, maskSlice4Nx16);
+                    v0 = Vector128_.ShuffleNative(v0, maskE);
+                    v1 = Vector128_.ShuffleNative(v1, maskSlice4Nx16);
+                    v2 = Vector128_.ShuffleNative(v2, maskE);
+                    v3 = Vector128_.ShuffleNative(v3, maskSlice4Nx16);
 
-                    v0 = Vector128Utilities.AlignRight(v1, v0, 4);
-                    v3 = Vector128Utilities.AlignRight(v3, v2, 12);
+                    v0 = Vector128_.AlignRight(v1, v0, 4);
+                    v3 = Vector128_.AlignRight(v3, v2, 12);
 
-                    v1 = Vector128Utilities.ShiftLeftBytesInVector(v1, 4);
-                    v2 = Vector128Utilities.ShiftRightBytesInVector(v2, 4);
+                    v1 = Vector128_.ShiftLeftBytesInVector(v1, 4);
+                    v2 = Vector128_.ShiftRightBytesInVector(v2, 4);
 
-                    v1 = Vector128Utilities.AlignRight(v2, v1, 8);
+                    v1 = Vector128_.AlignRight(v2, v1, 8);
 
                     ref Vector128<byte> vd = ref Unsafe.Add(ref destinationBase, i);
 
@@ -505,7 +510,7 @@ internal static partial class SimdUtils
             Span<byte> destination,
             [ConstantExpected] byte control)
         {
-            if (Vector128.IsHardwareAccelerated && Vector128Utilities.SupportsShuffleByte && Vector128Utilities.SupportsShiftByte)
+            if (Vector128.IsHardwareAccelerated)
             {
                 Vector128<byte> maskPad4Nx16 = ShuffleMaskPad4Nx16();
                 Vector128<byte> fill = Vector128.Create(0xff000000ff000000ul).AsByte();
@@ -527,17 +532,17 @@ internal static partial class SimdUtils
                     ref Vector128<byte> v0 = ref Unsafe.Add(ref sourceBase, i);
                     Vector128<byte> v1 = Unsafe.Add(ref v0, 1);
                     Vector128<byte> v2 = Unsafe.Add(ref v0, 2);
-                    Vector128<byte> v3 = Vector128Utilities.ShiftRightBytesInVector(v2, 4);
+                    Vector128<byte> v3 = Vector128_.ShiftRightBytesInVector(v2, 4);
 
-                    v2 = Vector128Utilities.AlignRight(v2, v1, 8);
-                    v1 = Vector128Utilities.AlignRight(v1, v0, 12);
+                    v2 = Vector128_.AlignRight(v2, v1, 8);
+                    v1 = Vector128_.AlignRight(v1, v0, 12);
 
                     ref Vector128<byte> vd = ref Unsafe.Add(ref destinationBase, j);
 
-                    vd = Vector128Utilities.Shuffle(Vector128Utilities.Shuffle(v0, maskPad4Nx16) | fill, mask);
-                    Unsafe.Add(ref vd, 1) = Vector128Utilities.Shuffle(Vector128Utilities.Shuffle(v1, maskPad4Nx16) | fill, mask);
-                    Unsafe.Add(ref vd, 2) = Vector128Utilities.Shuffle(Vector128Utilities.Shuffle(v2, maskPad4Nx16) | fill, mask);
-                    Unsafe.Add(ref vd, 3) = Vector128Utilities.Shuffle(Vector128Utilities.Shuffle(v3, maskPad4Nx16) | fill, mask);
+                    vd = Vector128_.ShuffleNative(Vector128_.ShuffleNative(v0, maskPad4Nx16) | fill, mask);
+                    Unsafe.Add(ref vd, 1) = Vector128_.ShuffleNative(Vector128_.ShuffleNative(v1, maskPad4Nx16) | fill, mask);
+                    Unsafe.Add(ref vd, 2) = Vector128_.ShuffleNative(Vector128_.ShuffleNative(v2, maskPad4Nx16) | fill, mask);
+                    Unsafe.Add(ref vd, 3) = Vector128_.ShuffleNative(Vector128_.ShuffleNative(v3, maskPad4Nx16) | fill, mask);
                 }
             }
         }
@@ -548,10 +553,10 @@ internal static partial class SimdUtils
             Span<byte> destination,
             [ConstantExpected] byte control)
         {
-            if (Vector128.IsHardwareAccelerated && Vector128Utilities.SupportsShuffleByte && Vector128Utilities.SupportsShiftByte)
+            if (Vector128.IsHardwareAccelerated)
             {
                 Vector128<byte> maskSlice4Nx16 = ShuffleMaskSlice4Nx16();
-                Vector128<byte> maskE = Vector128Utilities.AlignRight(maskSlice4Nx16, maskSlice4Nx16, 12);
+                Vector128<byte> maskE = Vector128_.AlignRight(maskSlice4Nx16, maskSlice4Nx16, 12);
 
                 Span<byte> temp = stackalloc byte[Vector128<byte>.Count];
                 Shuffle.MMShuffleSpan(ref temp, control);
@@ -574,18 +579,18 @@ internal static partial class SimdUtils
                     Vector128<byte> v2 = Unsafe.Add(ref vs, 2);
                     Vector128<byte> v3 = Unsafe.Add(ref vs, 3);
 
-                    v0 = Vector128Utilities.Shuffle(Vector128Utilities.Shuffle(v0, mask), maskE);
-                    v1 = Vector128Utilities.Shuffle(Vector128Utilities.Shuffle(v1, mask), maskSlice4Nx16);
-                    v2 = Vector128Utilities.Shuffle(Vector128Utilities.Shuffle(v2, mask), maskE);
-                    v3 = Vector128Utilities.Shuffle(Vector128Utilities.Shuffle(v3, mask), maskSlice4Nx16);
+                    v0 = Vector128_.ShuffleNative(Vector128_.ShuffleNative(v0, mask), maskE);
+                    v1 = Vector128_.ShuffleNative(Vector128_.ShuffleNative(v1, mask), maskSlice4Nx16);
+                    v2 = Vector128_.ShuffleNative(Vector128_.ShuffleNative(v2, mask), maskE);
+                    v3 = Vector128_.ShuffleNative(Vector128_.ShuffleNative(v3, mask), maskSlice4Nx16);
 
-                    v0 = Vector128Utilities.AlignRight(v1, v0, 4);
-                    v3 = Vector128Utilities.AlignRight(v3, v2, 12);
+                    v0 = Vector128_.AlignRight(v1, v0, 4);
+                    v3 = Vector128_.AlignRight(v3, v2, 12);
 
-                    v1 = Vector128Utilities.ShiftLeftBytesInVector(v1, 4);
-                    v2 = Vector128Utilities.ShiftRightBytesInVector(v2, 4);
+                    v1 = Vector128_.ShiftLeftBytesInVector(v1, 4);
+                    v2 = Vector128_.ShiftRightBytesInVector(v2, 4);
 
-                    v1 = Vector128Utilities.AlignRight(v2, v1, 8);
+                    v1 = Vector128_.AlignRight(v2, v1, 8);
 
                     ref Vector128<byte> vd = ref Unsafe.Add(ref destinationBase, j);
 
@@ -616,58 +621,7 @@ internal static partial class SimdUtils
                 return Fma.MultiplyAdd(vm1, vm0, va);
             }
 
-            return Avx.Add(Avx.Multiply(vm0, vm1), va);
-        }
-
-        /// <summary>
-        /// Performs a multiplication and an addition of the <see cref="Vector128{Single}"/>.
-        /// TODO: Fix. The arguments are in a different order to the FMA intrinsic.
-        /// </summary>
-        /// <remarks>ret = (vm0 * vm1) + va</remarks>
-        /// <param name="va">The vector to add to the intermediate result.</param>
-        /// <param name="vm0">The first vector to multiply.</param>
-        /// <param name="vm1">The second vector to multiply.</param>
-        /// <returns>The <see cref="Vector256{T}"/>.</returns>
-        [MethodImpl(InliningOptions.AlwaysInline)]
-        public static Vector128<float> MultiplyAdd(
-            Vector128<float> va,
-            Vector128<float> vm0,
-            Vector128<float> vm1)
-        {
-            if (Fma.IsSupported)
-            {
-                return Fma.MultiplyAdd(vm1, vm0, va);
-            }
-
-            if (AdvSimd.IsSupported)
-            {
-                return AdvSimd.Add(AdvSimd.Multiply(vm0, vm1), va);
-            }
-
-            return Sse.Add(Sse.Multiply(vm0, vm1), va);
-        }
-
-        /// <summary>
-        /// Performs a multiplication and a subtraction of the <see cref="Vector256{Single}"/>.
-        /// TODO: Fix. The arguments are in a different order to the FMA intrinsic.
-        /// </summary>
-        /// <remarks>ret = (vm0 * vm1) - vs</remarks>
-        /// <param name="vs">The vector to subtract from the intermediate result.</param>
-        /// <param name="vm0">The first vector to multiply.</param>
-        /// <param name="vm1">The second vector to multiply.</param>
-        /// <returns>The <see cref="Vector256{T}"/>.</returns>
-        [MethodImpl(InliningOptions.ShortMethod)]
-        public static Vector256<float> MultiplySubtract(
-            Vector256<float> vs,
-            Vector256<float> vm0,
-            Vector256<float> vm1)
-        {
-            if (Fma.IsSupported)
-            {
-                return Fma.MultiplySubtract(vm1, vm0, vs);
-            }
-
-            return Avx.Subtract(Avx.Multiply(vm0, vm1), vs);
+            return va + (vm0 * vm1);
         }
 
         /// <summary>
@@ -993,10 +947,10 @@ internal static partial class SimdUtils
                     Vector512<float> f2 = scale * Unsafe.Add(ref s, 2);
                     Vector512<float> f3 = scale * Unsafe.Add(ref s, 3);
 
-                    Vector512<int> w0 = Vector512Utilities.ConvertToInt32RoundToEven(f0);
-                    Vector512<int> w1 = Vector512Utilities.ConvertToInt32RoundToEven(f1);
-                    Vector512<int> w2 = Vector512Utilities.ConvertToInt32RoundToEven(f2);
-                    Vector512<int> w3 = Vector512Utilities.ConvertToInt32RoundToEven(f3);
+                    Vector512<int> w0 = Vector512_.ConvertToInt32RoundToEven(f0);
+                    Vector512<int> w1 = Vector512_.ConvertToInt32RoundToEven(f1);
+                    Vector512<int> w2 = Vector512_.ConvertToInt32RoundToEven(f2);
+                    Vector512<int> w3 = Vector512_.ConvertToInt32RoundToEven(f3);
 
                     Vector512<short> u0 = Avx512BW.PackSignedSaturate(w0, w1);
                     Vector512<short> u1 = Avx512BW.PackSignedSaturate(w2, w3);
@@ -1027,10 +981,10 @@ internal static partial class SimdUtils
                     Vector256<float> f2 = scale * Unsafe.Add(ref s, 2);
                     Vector256<float> f3 = scale * Unsafe.Add(ref s, 3);
 
-                    Vector256<int> w0 = Vector256Utilities.ConvertToInt32RoundToEven(f0);
-                    Vector256<int> w1 = Vector256Utilities.ConvertToInt32RoundToEven(f1);
-                    Vector256<int> w2 = Vector256Utilities.ConvertToInt32RoundToEven(f2);
-                    Vector256<int> w3 = Vector256Utilities.ConvertToInt32RoundToEven(f3);
+                    Vector256<int> w0 = Vector256_.ConvertToInt32RoundToEven(f0);
+                    Vector256<int> w1 = Vector256_.ConvertToInt32RoundToEven(f1);
+                    Vector256<int> w2 = Vector256_.ConvertToInt32RoundToEven(f2);
+                    Vector256<int> w3 = Vector256_.ConvertToInt32RoundToEven(f3);
 
                     Vector256<short> u0 = Avx2.PackSignedSaturate(w0, w1);
                     Vector256<short> u1 = Avx2.PackSignedSaturate(w2, w3);
@@ -1040,9 +994,9 @@ internal static partial class SimdUtils
                     Unsafe.Add(ref destinationBase, i) = b;
                 }
             }
-            else if (Sse2.IsSupported || AdvSimd.IsSupported)
+            else if (Vector128.IsHardwareAccelerated)
             {
-                // Sse, AdvSimd
+                // Sse, AdvSimd, etc.
                 DebugVerifySpanInput(source, destination, Vector128<byte>.Count);
 
                 nuint n = destination.Vector128Count<byte>();
@@ -1051,6 +1005,8 @@ internal static partial class SimdUtils
                 ref Vector128<byte> destinationBase = ref Unsafe.As<byte, Vector128<byte>>(ref MemoryMarshal.GetReference(destination));
 
                 Vector128<float> scale = Vector128.Create((float)byte.MaxValue);
+                Vector128<int> min = Vector128<int>.Zero;
+                Vector128<int> max = Vector128.Create((int)byte.MaxValue);
 
                 for (nuint i = 0; i < n; i++)
                 {
@@ -1061,15 +1017,20 @@ internal static partial class SimdUtils
                     Vector128<float> f2 = scale * Unsafe.Add(ref s, 2);
                     Vector128<float> f3 = scale * Unsafe.Add(ref s, 3);
 
-                    Vector128<int> w0 = Vector128Utilities.ConvertToInt32RoundToEven(f0);
-                    Vector128<int> w1 = Vector128Utilities.ConvertToInt32RoundToEven(f1);
-                    Vector128<int> w2 = Vector128Utilities.ConvertToInt32RoundToEven(f2);
-                    Vector128<int> w3 = Vector128Utilities.ConvertToInt32RoundToEven(f3);
+                    Vector128<int> w0 = Vector128_.ConvertToInt32RoundToEven(f0);
+                    Vector128<int> w1 = Vector128_.ConvertToInt32RoundToEven(f1);
+                    Vector128<int> w2 = Vector128_.ConvertToInt32RoundToEven(f2);
+                    Vector128<int> w3 = Vector128_.ConvertToInt32RoundToEven(f3);
+
+                    w0 = Vector128_.Clamp(w0, min, max);
+                    w1 = Vector128_.Clamp(w1, min, max);
+                    w2 = Vector128_.Clamp(w2, min, max);
+                    w3 = Vector128_.Clamp(w3, min, max);
 
-                    Vector128<short> u0 = Vector128Utilities.PackSignedSaturate(w0, w1);
-                    Vector128<short> u1 = Vector128Utilities.PackSignedSaturate(w2, w3);
+                    Vector128<ushort> u0 = Vector128.Narrow(w0, w1).AsUInt16();
+                    Vector128<ushort> u1 = Vector128.Narrow(w2, w3).AsUInt16();
 
-                    Unsafe.Add(ref destinationBase, i) = Vector128Utilities.PackUnsignedSaturate(u0, u1);
+                    Unsafe.Add(ref destinationBase, i) = Vector128.Narrow(u0, u1);
                 }
             }
         }
diff --git a/src/ImageSharp/Common/Helpers/SimdUtils.cs b/src/ImageSharp/Common/Helpers/SimdUtils.cs
index 0279e57cc6..7f98c83754 100644
--- a/src/ImageSharp/Common/Helpers/SimdUtils.cs
+++ b/src/ImageSharp/Common/Helpers/SimdUtils.cs
@@ -1,11 +1,11 @@
-// Copyright (c) Six Labors.
+// Copyright (c) Six Labors.
 // Licensed under the Six Labors Split License.
 
 using System.Diagnostics;
 using System.Numerics;
 using System.Runtime.CompilerServices;
-using System.Runtime.InteropServices;
 using System.Runtime.Intrinsics;
+using System.Runtime.Intrinsics.Arm;
 using System.Runtime.Intrinsics.X86;
 
 namespace SixLabors.ImageSharp;
@@ -36,30 +36,39 @@ internal static partial class SimdUtils
 
     /// <summary>
     /// Rounds all values in 'v' to the nearest integer following <see cref="MidpointRounding.ToEven"/> semantics.
-    /// Source:
-    /// <see>
-    ///     <cref>https://github.com/g-truc/glm/blob/master/glm/simd/common.h#L110</cref>
-    /// </see>
     /// </summary>
     /// <param name="v">The vector</param>
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
     internal static Vector<float> FastRound(this Vector<float> v)
     {
-        if (Avx2.IsSupported)
+        // .NET9+ has a built-in method for this Vector.Round
+        if (Avx2.IsSupported && Vector<float>.Count == Vector256<float>.Count)
         {
             ref Vector256<float> v256 = ref Unsafe.As<Vector<float>, Vector256<float>>(ref v);
             Vector256<float> vRound = Avx.RoundToNearestInteger(v256);
             return Unsafe.As<Vector256<float>, Vector<float>>(ref vRound);
         }
-        else
+
+        if (Sse41.IsSupported && Vector<float>.Count == Vector128<float>.Count)
+        {
+            ref Vector128<float> v128 = ref Unsafe.As<Vector<float>, Vector128<float>>(ref v);
+            Vector128<float> vRound = Sse41.RoundToNearestInteger(v128);
+            return Unsafe.As<Vector128<float>, Vector<float>>(ref vRound);
+        }
+
+        if (AdvSimd.IsSupported && Vector<float>.Count == Vector128<float>.Count)
         {
-            var magic0 = new Vector<int>(int.MinValue); // 0x80000000
-            var sgn0 = Vector.AsVectorSingle(magic0);
-            var and0 = Vector.BitwiseAnd(sgn0, v);
-            var or0 = Vector.BitwiseOr(and0, new Vector<float>(8388608.0f));
-            var add0 = Vector.Add(v, or0);
-            return Vector.Subtract(add0, or0);
+            ref Vector128<float> v128 = ref Unsafe.As<Vector<float>, Vector128<float>>(ref v);
+            Vector128<float> vRound = AdvSimd.RoundToNearest(v128);
+            return Unsafe.As<Vector128<float>, Vector<float>>(ref vRound);
         }
+
+        // https://github.com/g-truc/glm/blob/master/glm/simd/common.h#L11
+        Vector<float> sign = v & new Vector<float>(-0F);
+        Vector<float> val_2p23_f32 = sign | new Vector<float>(8388608F);
+
+        val_2p23_f32 = (v + val_2p23_f32) - val_2p23_f32;
+        return val_2p23_f32 | sign;
     }
 
     [Conditional("DEBUG")]
diff --git a/src/ImageSharp/Common/Helpers/TolerantMath.cs b/src/ImageSharp/Common/Helpers/TolerantMath.cs
index b4ed9ee2f2..2c622d1679 100644
--- a/src/ImageSharp/Common/Helpers/TolerantMath.cs
+++ b/src/ImageSharp/Common/Helpers/TolerantMath.cs
@@ -20,7 +20,7 @@ internal readonly struct TolerantMath
     /// It is a field so it can be passed as an 'in' parameter.
     /// Does not necessarily fit all use cases!
     /// </summary>
-    public static readonly TolerantMath Default = new TolerantMath(1e-8);
+    public static readonly TolerantMath Default = new(1e-8);
 
     public TolerantMath(double epsilon)
     {
diff --git a/src/ImageSharp/Common/Helpers/Vector128Utilities.cs b/src/ImageSharp/Common/Helpers/Vector128Utilities.cs
index b6dd319f06..a5d377eb90 100644
--- a/src/ImageSharp/Common/Helpers/Vector128Utilities.cs
+++ b/src/ImageSharp/Common/Helpers/Vector128Utilities.cs
@@ -1,11 +1,11 @@
 // Copyright (c) Six Labors.
 // Licensed under the Six Labors Split License.
 
-using System.Diagnostics;
 using System.Diagnostics.CodeAnalysis;
 using System.Runtime.CompilerServices;
 using System.Runtime.Intrinsics;
 using System.Runtime.Intrinsics.Arm;
+using System.Runtime.Intrinsics.Wasm;
 using System.Runtime.Intrinsics.X86;
 
 namespace SixLabors.ImageSharp.Common.Helpers;
@@ -18,60 +18,144 @@ namespace SixLabors.ImageSharp.Common.Helpers;
 /// </list>
 /// Should only be used if the intrinsics are available.
 /// </summary>
-internal static class Vector128Utilities
+#pragma warning disable SA1649 // File name should match first type name
+internal static class Vector128_
+#pragma warning restore SA1649 // File name should match first type name
 {
     /// <summary>
-    /// Gets a value indicating whether shuffle operations are supported.
+    /// Average packed unsigned 8-bit integers in <paramref name="left"/> and <paramref name="right"/>, and store the results.
     /// </summary>
-    public static bool SupportsShuffleFloat
+    /// <param name="left">
+    /// The first vector containing packed unsigned 8-bit integers to average.
+    /// </param>
+    /// <param name="right">
+    /// The second vector containing packed unsigned 8-bit integers to average.
+    /// </param>
+    /// <returns>
+    /// A vector containing the average of the packed unsigned 8-bit integers
+    /// </returns>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static Vector128<byte> Average(Vector128<byte> left, Vector128<byte> right)
     {
-        [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        get => Sse.IsSupported;
+        if (Sse2.IsSupported)
+        {
+            return Sse2.Average(left, right);
+        }
+
+        if (AdvSimd.IsSupported)
+        {
+            return AdvSimd.FusedAddRoundedHalving(left, right);
+        }
+
+        // Account for potential 9th bit to ensure correct rounded result.
+        return Vector128.Narrow(
+            (Vector128.WidenLower(left) + Vector128.WidenLower(right) + Vector128<ushort>.One) >> 1,
+            (Vector128.WidenUpper(left) + Vector128.WidenUpper(right) + Vector128<ushort>.One) >> 1);
     }
 
     /// <summary>
-    /// Gets a value indicating whether shuffle operations are supported.
+    /// Creates a new vector by selecting values from an input vector using the control.
     /// </summary>
-    public static bool SupportsShuffleByte
+    /// <param name="vector">The input vector from which values are selected.</param>
+    /// <param name="control">The shuffle control byte.</param>
+    /// <returns>The <see cref="Vector128{Single}"/>.</returns>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static Vector128<float> ShuffleNative(Vector128<float> vector, [ConstantExpected] byte control)
     {
-        [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        get => Ssse3.IsSupported || AdvSimd.Arm64.IsSupported;
+        if (Sse.IsSupported)
+        {
+            return Sse.Shuffle(vector, vector, control);
+        }
+
+        // Don't use InverseMMShuffle here as we want to avoid the cast.
+        Vector128<int> indices = Vector128.Create(
+            control & 0x3,
+            (control >> 2) & 0x3,
+            (control >> 4) & 0x3,
+            (control >> 6) & 0x3);
+
+        return Vector128.Shuffle(vector, indices);
     }
 
     /// <summary>
-    /// Gets a value indicating whether right align operations are supported.
+    /// Creates a new vector by selecting values from an input vector using the control.
     /// </summary>
-    public static bool SupportsRightAlign
+    /// <param name="vector">The input vector from which values are selected.</param>
+    /// <param name="control">The shuffle control byte.</param>
+    /// <returns>The <see cref="Vector128{Single}"/>.</returns>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static Vector128<int> ShuffleNative(Vector128<int> vector, [ConstantExpected] byte control)
     {
-        [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        get => Ssse3.IsSupported || AdvSimd.IsSupported;
+        // Don't use InverseMMShuffle here as we want to avoid the cast.
+        Vector128<int> indices = Vector128.Create(
+            control & 0x3,
+            (control >> 2) & 0x3,
+            (control >> 4) & 0x3,
+            (control >> 6) & 0x3);
+
+        return Vector128.Shuffle(vector, indices);
     }
 
     /// <summary>
-    /// Gets a value indicating whether right or left byte shift operations are supported.
+    /// Shuffle 16-bit integers in the high 64 bits of <paramref name="value"/> using the control in <paramref name="control"/>.
+    /// Store the results in the high 64 bits of the destination, with the low 64 bits being copied from <paramref name="value"/>.
     /// </summary>
-    public static bool SupportsShiftByte
+    /// <param name="value">The input vector containing packed 16-bit integers to shuffle.</param>
+    /// <param name="control">The shuffle control byte.</param>
+    /// <returns>
+    /// A vector containing the shuffled 16-bit integers in the high 64 bits, with the low 64 bits copied from <paramref name="value"/>.
+    /// </returns>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static Vector128<short> ShuffleHigh(Vector128<short> value, [ConstantExpected] byte control)
     {
-        [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        get => Sse2.IsSupported || AdvSimd.IsSupported;
+        if (Sse2.IsSupported)
+        {
+            return Sse2.ShuffleHigh(value, control);
+        }
+
+        // Don't use InverseMMShuffle here as we want to avoid the cast.
+        Vector128<short> indices = Vector128.Create(
+           0,
+           1,
+           2,
+           3,
+           (short)((control & 0x3) + 4),
+           (short)(((control >> 2) & 0x3) + 4),
+           (short)(((control >> 4) & 0x3) + 4),
+           (short)(((control >> 6) & 0x3) + 4));
+
+        return Vector128.Shuffle(value, indices);
     }
 
     /// <summary>
-    /// Creates a new vector by selecting values from an input vector using the control.
+    /// Shuffle 16-bit integers in the low 64 bits of <paramref name="value"/> using the control in <paramref name="control"/>.
+    /// Store the results in the low 64 bits of the destination, with the high 64 bits being copied from <paramref name="value"/>.
     /// </summary>
-    /// <param name="vector">The input vector from which values are selected.</param>
+    /// <param name="value">The input vector containing packed 16-bit integers to shuffle.</param>
     /// <param name="control">The shuffle control byte.</param>
-    /// <returns>The <see cref="Vector128{Single}"/>.</returns>
+    /// <returns>
+    /// A vector containing the shuffled 16-bit integers in the low 64 bits, with the high 64 bits copied from <paramref name="value"/>.
+    /// </returns>
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
-    public static Vector128<float> Shuffle(Vector128<float> vector, [ConstantExpected] byte control)
+    public static Vector128<short> ShuffleLow(Vector128<short> value, [ConstantExpected] byte control)
     {
-        if (Sse.IsSupported)
+        if (Sse2.IsSupported)
         {
-            return Sse.Shuffle(vector, vector, control);
+            return Sse2.ShuffleLow(value, control);
         }
 
-        ThrowUnreachableException();
-        return default;
+        // Don't use InverseMMShuffle here as we want to avoid the cast.
+        Vector128<short> indices = Vector128.Create(
+           (short)(control & 0x3),
+           (short)((control >> 2) & 0x3),
+           (short)((control >> 4) & 0x3),
+           (short)((control >> 6) & 0x3),
+           4,
+           5,
+           6,
+           7);
+
+        return Vector128.Shuffle(value, indices);
     }
 
     /// <summary>
@@ -86,20 +170,18 @@ internal static class Vector128Utilities
     /// A new vector containing the values from <paramref name="vector" /> selected by the given <paramref name="indices" />.
     /// </returns>
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
-    public static Vector128<byte> Shuffle(Vector128<byte> vector, Vector128<byte> indices)
+    public static Vector128<byte> ShuffleNative(Vector128<byte> vector, Vector128<byte> indices)
     {
+        // For x64 we use the SSSE3 shuffle intrinsic to avoid additional instructions. 3 vs 1.
         if (Ssse3.IsSupported)
         {
             return Ssse3.Shuffle(vector, indices);
         }
 
-        if (AdvSimd.Arm64.IsSupported)
-        {
-            return AdvSimd.Arm64.VectorTableLookup(vector, indices);
-        }
-
-        ThrowUnreachableException();
-        return default;
+        // For ARM and WASM, codegen will be optimal.
+        // We don't throw for x86/x64 so we should never use this method without
+        // checking for support.
+        return Vector128.Shuffle(vector, indices);
     }
 
     /// <summary>
@@ -121,8 +203,7 @@ internal static class Vector128Utilities
             return AdvSimd.ExtractVector128(value, Vector128<byte>.Zero, numBytes);
         }
 
-        ThrowUnreachableException();
-        return default;
+        return Vector128.Shuffle(value, Vector128.Create((byte)0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15) + Vector128.Create(numBytes));
     }
 
     /// <summary>
@@ -146,8 +227,28 @@ internal static class Vector128Utilities
 #pragma warning restore CA1857 // A constant is expected for the parameter
         }
 
-        ThrowUnreachableException();
-        return default;
+        return Vector128.Shuffle(value, Vector128.Create((byte)0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15) - Vector128.Create(numBytes));
+    }
+
+    /// <summary>
+    /// Shift packed 16-bit integers in <paramref name="value"/> left by <paramref name="value"/> while
+    /// shifting in zeros, and store the results
+    /// </summary>
+    /// <param name="value">The vector containing packed 16-bit integers to shift.</param>
+    /// <param name="count">The number of bits to shift left.</param>
+    /// <returns>
+    /// A vector containing the packed 16-bit integers shifted left by <paramref name="count"/>, with zeros shifted in.
+    /// </returns>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static Vector128<short> ShiftLeftLogical(Vector128<short> value, [ConstantExpected] byte count)
+    {
+        // Zero lanes where count >= 16 to match SSE2
+        if (count >= 16)
+        {
+            return Vector128<short>.Zero;
+        }
+
+        return value << count;
     }
 
     /// <summary>
@@ -170,8 +271,9 @@ internal static class Vector128Utilities
             return AdvSimd.ExtractVector128(right, left, mask);
         }
 
-        ThrowUnreachableException();
-        return default;
+#pragma warning disable CA1857 // A constant is expected for the parameter
+        return ShiftLeftBytesInVector(left, (byte)(Vector128<byte>.Count - mask)) | ShiftRightBytesInVector(right, mask);
+#pragma warning restore CA1857 // A constant is expected for the parameter
     }
 
     /// <summary>
@@ -193,13 +295,75 @@ internal static class Vector128Utilities
             return AdvSimd.ConvertToInt32RoundToEven(vector);
         }
 
-        Vector128<float> sign = vector & Vector128.Create(-0.0f);
-        Vector128<float> val_2p23_f32 = sign | Vector128.Create(8388608.0f);
+        if (PackedSimd.IsSupported)
+        {
+            return PackedSimd.ConvertToInt32Saturate(PackedSimd.RoundToNearest(vector));
+        }
+
+        Vector128<float> sign = vector & Vector128.Create(-0F);
+        Vector128<float> val_2p23_f32 = sign | Vector128.Create(8388608F);
 
         val_2p23_f32 = (vector + val_2p23_f32) - val_2p23_f32;
         return Vector128.ConvertToInt32(val_2p23_f32 | sign);
     }
 
+    /// <summary>
+    /// Rounds all values in <paramref name="vector"/> to the nearest integer
+    /// following <see cref="MidpointRounding.ToEven"/> semantics.
+    /// </summary>
+    /// <param name="vector">The vector</param>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static Vector128<float> RoundToNearestInteger(Vector128<float> vector)
+    {
+        if (Sse41.IsSupported)
+        {
+            return Sse41.RoundToNearestInteger(vector);
+        }
+
+        if (AdvSimd.IsSupported)
+        {
+            return AdvSimd.RoundToNearest(vector);
+        }
+
+        if (PackedSimd.IsSupported)
+        {
+            return PackedSimd.RoundToNearest(vector);
+        }
+
+        Vector128<float> sign = vector & Vector128.Create(-0F);
+        Vector128<float> val_2p23_f32 = sign | Vector128.Create(8388608F);
+
+        val_2p23_f32 = (vector + val_2p23_f32) - val_2p23_f32;
+        return val_2p23_f32 | sign;
+    }
+
+    /// <summary>
+    /// Performs a multiplication and an addition of the <see cref="Vector128{Single}"/>.
+    /// </summary>
+    /// <remarks>ret = (vm0 * vm1) + va</remarks>
+    /// <param name="va">The vector to add to the intermediate result.</param>
+    /// <param name="vm0">The first vector to multiply.</param>
+    /// <param name="vm1">The second vector to multiply.</param>
+    /// <returns>The <see cref="Vector256{T}"/>.</returns>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static Vector128<float> MultiplyAdd(
+        Vector128<float> va,
+        Vector128<float> vm0,
+        Vector128<float> vm1)
+    {
+        if (Fma.IsSupported)
+        {
+            return Fma.MultiplyAdd(vm1, vm0, va);
+        }
+
+        if (AdvSimd.IsSupported)
+        {
+            return AdvSimd.FusedMultiplyAdd(va, vm0, vm1);
+        }
+
+        return va + (vm0 * vm1);
+    }
+
     /// <summary>
     /// Packs signed 16-bit integers to unsigned 8-bit integers and saturates.
     /// </summary>
@@ -218,8 +382,47 @@ internal static class Vector128Utilities
             return AdvSimd.ExtractNarrowingSaturateUnsignedUpper(AdvSimd.ExtractNarrowingSaturateUnsignedLower(left), right);
         }
 
-        ThrowUnreachableException();
-        return default;
+        if (PackedSimd.IsSupported)
+        {
+            return PackedSimd.ConvertNarrowingSaturateUnsigned(left, right);
+        }
+
+        Vector128<short> min = Vector128.Create((short)byte.MinValue);
+        Vector128<short> max = Vector128.Create((short)byte.MaxValue);
+        Vector128<ushort> lefClamped = Clamp(left, min, max).AsUInt16();
+        Vector128<ushort> rightClamped = Clamp(right, min, max).AsUInt16();
+        return Vector128.Narrow(lefClamped, rightClamped);
+    }
+
+    /// <summary>
+    /// Packs signed 32-bit integers to unsigned 16-bit integers and saturates.
+    /// </summary>
+    /// <param name="left">The left hand source vector.</param>
+    /// <param name="right">The right hand source vector.</param>
+    /// <returns>The <see cref="Vector128{UInt16}"/>.</returns>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static Vector128<ushort> PackUnsignedSaturate(Vector128<int> left, Vector128<int> right)
+    {
+        if (Sse41.IsSupported)
+        {
+            return Sse41.PackUnsignedSaturate(left, right);
+        }
+
+        if (AdvSimd.IsSupported)
+        {
+            return AdvSimd.ExtractNarrowingSaturateUnsignedUpper(AdvSimd.ExtractNarrowingSaturateUnsignedLower(left), right);
+        }
+
+        if (PackedSimd.IsSupported)
+        {
+            return PackedSimd.ConvertNarrowingSaturateUnsigned(left, right);
+        }
+
+        Vector128<int> min = Vector128.Create((int)ushort.MinValue);
+        Vector128<int> max = Vector128.Create((int)ushort.MaxValue);
+        Vector128<uint> lefClamped = Clamp(left, min, max).AsUInt32();
+        Vector128<uint> rightClamped = Clamp(right, min, max).AsUInt32();
+        return Vector128.Narrow(lefClamped, rightClamped);
     }
 
     /// <summary>
@@ -241,10 +444,919 @@ internal static class Vector128Utilities
             return AdvSimd.ExtractNarrowingSaturateUpper(AdvSimd.ExtractNarrowingSaturateLower(left), right);
         }
 
-        ThrowUnreachableException();
-        return default;
+        if (PackedSimd.IsSupported)
+        {
+            return PackedSimd.ConvertNarrowingSaturateSigned(left, right);
+        }
+
+        Vector128<int> min = Vector128.Create((int)short.MinValue);
+        Vector128<int> max = Vector128.Create((int)short.MaxValue);
+        Vector128<int> lefClamped = Clamp(left, min, max);
+        Vector128<int> rightClamped = Clamp(right, min, max);
+        return Vector128.Narrow(lefClamped, rightClamped);
+    }
+
+    /// <summary>
+    /// Packs signed 16-bit integers to signed 8-bit integers and saturates.
+    /// </summary>
+    /// <param name="left">The left hand source vector.</param>
+    /// <param name="right">The right hand source vector.</param>
+    /// <returns>The <see cref="Vector128{Int16}"/>.</returns>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static Vector128<sbyte> PackSignedSaturate(Vector128<short> left, Vector128<short> right)
+    {
+        if (Sse2.IsSupported)
+        {
+            return Sse2.PackSignedSaturate(left, right);
+        }
+
+        if (AdvSimd.IsSupported)
+        {
+            return AdvSimd.ExtractNarrowingSaturateUpper(AdvSimd.ExtractNarrowingSaturateLower(left), right);
+        }
+
+        if (PackedSimd.IsSupported)
+        {
+            return PackedSimd.ConvertNarrowingSaturateSigned(left, right);
+        }
+
+        Vector128<short> min = Vector128.Create((short)sbyte.MinValue);
+        Vector128<short> max = Vector128.Create((short)sbyte.MaxValue);
+        Vector128<short> lefClamped = Clamp(left, min, max);
+        Vector128<short> rightClamped = Clamp(right, min, max);
+        return Vector128.Narrow(lefClamped, rightClamped);
+    }
+
+    /// <summary>
+    /// Restricts a vector between a minimum and a maximum value.
+    /// </summary>
+    /// <typeparam name="T">The type of the elements in the vector.</typeparam>
+    /// <param name="value">The vector to restrict.</param>
+    /// <param name="min">The minimum value.</param>
+    /// <param name="max">The maximum value.</param>
+    /// <returns>The restricted <see cref="Vector128{T}"/>.</returns>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static Vector128<T> Clamp<T>(Vector128<T> value, Vector128<T> min, Vector128<T> max)
+        => Vector128.Min(Vector128.Max(value, min), max);
+
+    /// <summary>
+    /// Multiply packed signed 16-bit integers in <paramref name="left"/> and <paramref name="right"/>, producing
+    /// intermediate signed 32-bit integers. Horizontally add adjacent pairs of intermediate 32-bit integers, and
+    /// pack the results.
+    /// </summary>
+    /// <param name="left">
+    /// The first vector containing packed signed 16-bit integers to multiply and add.
+    /// </param>
+    /// <param name="right">
+    /// The second vector containing packed signed 16-bit integers to multiply and add.
+    /// </param>
+    /// <returns>
+    /// A vector containing the results of multiplying and adding adjacent pairs of packed signed 16-bit integers
+    /// </returns>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static Vector128<int> MultiplyAddAdjacent(Vector128<short> left, Vector128<short> right)
+    {
+        if (Sse2.IsSupported)
+        {
+            return Sse2.MultiplyAddAdjacent(left, right);
+        }
+
+        if (AdvSimd.IsSupported)
+        {
+            Vector128<int> prodLo = AdvSimd.MultiplyWideningLower(left.GetLower(), right.GetLower());
+            Vector128<int> prodHi = AdvSimd.MultiplyWideningUpper(left, right);
+
+            if (AdvSimd.Arm64.IsSupported)
+            {
+                return AdvSimd.Arm64.AddPairwise(prodLo, prodHi);
+            }
+
+            Vector64<int> v0 = AdvSimd.AddPairwise(prodLo.GetLower(), prodLo.GetUpper());
+            Vector64<int> v1 = AdvSimd.AddPairwise(prodHi.GetLower(), prodHi.GetUpper());
+            return Vector128.Create(v0, v1);
+        }
+
+        {
+            // Widen each half of the short vectors into two int vectors
+            (Vector128<int> leftLo, Vector128<int> leftHi) = Vector128.Widen(left);
+            (Vector128<int> rightLo, Vector128<int> rightHi) = Vector128.Widen(right);
+
+            // Elementwise multiply: each int lane now holds the full 32-bit product
+            Vector128<int> prodLo = leftLo * rightLo;
+            Vector128<int> prodHi = leftHi * rightHi;
+
+            // Extract the low and high parts of the products shuffling them to form a result we can add together.
+            // Use out-of-bounds to zero out the unused lanes.
+            Vector128<int> v0 = Vector128.Shuffle(prodLo, Vector128.Create(0, 2, 8, 8));
+            Vector128<int> v1 = Vector128.Shuffle(prodHi, Vector128.Create(8, 8, 0, 2));
+            Vector128<int> v2 = Vector128.Shuffle(prodLo, Vector128.Create(1, 3, 8, 8));
+            Vector128<int> v3 = Vector128.Shuffle(prodHi, Vector128.Create(8, 8, 1, 3));
+
+            return v0 + v1 + v2 + v3;
+        }
+    }
+
+    /// <summary>
+    /// Horizontally add adjacent pairs of 16-bit integers in <paramref name="left"/> and <paramref name="right"/>, and
+    /// pack the signed 16-bit results.
+    /// </summary>
+    /// <param name="left">
+    /// The first vector containing packed signed 16-bit integers to add.
+    /// </param>
+    /// <param name="right">
+    /// The second vector containing packed signed 16-bit integers to add.
+    /// </param>
+    /// <returns>
+    /// A vector containing the results of horizontally adding adjacent pairs of packed signed 16-bit integers
+    /// </returns>
+    public static Vector128<short> HorizontalAdd(Vector128<short> left, Vector128<short> right)
+    {
+        if (Ssse3.IsSupported)
+        {
+            return Ssse3.HorizontalAdd(left, right);
+        }
+
+        if (AdvSimd.Arm64.IsSupported)
+        {
+            return AdvSimd.Arm64.AddPairwise(left, right);
+        }
+
+        if (AdvSimd.IsSupported)
+        {
+            Vector128<int> v0 = AdvSimd.AddPairwiseWidening(left);
+            Vector128<int> v1 = AdvSimd.AddPairwiseWidening(right);
+
+            return Vector128.Narrow(v0, v1);
+        }
+
+        {
+            // Extract the low and high parts of the products shuffling them to form a result we can add together.
+            // Use out-of-bounds to zero out the unused lanes.
+            Vector128<short> even = Vector128.Create(0, 2, 4, 6, 8, 8, 8, 8);
+            Vector128<short> odd = Vector128.Create(1, 3, 5, 7, 8, 8, 8, 8);
+            Vector128<short> v0 = Vector128.Shuffle(right, even);
+            Vector128<short> v1 = Vector128.Shuffle(right, odd);
+            Vector128<short> v2 = Vector128.Shuffle(left, even);
+            Vector128<short> v3 = Vector128.Shuffle(left, odd);
+
+            return v0 + v1 + v2 + v3;
+        }
+    }
+
+    /// <summary>
+    /// Multiply the packed 16-bit integers in <paramref name="left"/> and <paramref name="right"/>, producing
+    /// intermediate 32-bit integers, and store the high 16 bits of the intermediate integers in the result.
+    /// </summary>
+    /// <param name="left">
+    /// The first vector containing packed 16-bit integers to multiply.
+    /// </param>
+    /// <param name="right">
+    /// The second vector containing packed 16-bit integers to multiply.
+    /// </param>
+    /// <returns>
+    /// A vector containing the high 16 bits of the products of the packed 16-bit integers
+    /// from <paramref name="left"/> and <paramref name="right"/>.
+    /// </returns>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static Vector128<short> MultiplyHigh(Vector128<short> left, Vector128<short> right)
+    {
+        if (Sse2.IsSupported)
+        {
+            return Sse2.MultiplyHigh(left, right);
+        }
+
+        if (AdvSimd.IsSupported)
+        {
+            Vector128<int> prodLo = AdvSimd.MultiplyWideningLower(left.GetLower(), right.GetLower());
+            Vector128<int> prodHi = AdvSimd.MultiplyWideningUpper(left, right);
+
+            prodLo >>= 16;
+            prodHi >>= 16;
+
+            return Vector128.Narrow(prodLo, prodHi);
+        }
+
+        {
+            // Widen each half of the short vectors into two int vectors
+            (Vector128<int> leftLo, Vector128<int> leftHi) = Vector128.Widen(left);
+            (Vector128<int> rightLo, Vector128<int> rightHi) = Vector128.Widen(right);
+
+            // Elementwise multiply: each int lane now holds the full 32-bit product
+            Vector128<int> prodLo = leftLo * rightLo;
+            Vector128<int> prodHi = leftHi * rightHi;
+
+            // Arithmetic shift right by 16 bits to extract the high word
+            prodLo >>= 16;
+            prodHi >>= 16;
+
+            // Narrow the two int vectors back into one short vector
+            return Vector128.Narrow(prodLo, prodHi);
+        }
+    }
+
+    /// <summary>
+    /// Multiply the packed 16-bit unsigned integers in <paramref name="left"/> and <paramref name="right"/>, producing
+    /// intermediate unsigned 32-bit integers, and store the high 16 bits of the intermediate integers in the result.
+    /// </summary>
+    /// <param name="left">
+    /// The first vector containing packed 16-bit unsigned integers to multiply.
+    /// </param>
+    /// <param name="right">
+    /// The second vector containing packed 16-bit unsigned integers to multiply.
+    /// </param>
+    /// <returns>
+    /// A vector containing the high 16 bits of the products of the packed 16-bit unsigned integers
+    /// from <paramref name="left"/> and <paramref name="right"/>.
+    /// </returns>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static Vector128<ushort> MultiplyHigh(Vector128<ushort> left, Vector128<ushort> right)
+    {
+        if (Sse2.IsSupported)
+        {
+            return Sse2.MultiplyHigh(left, right);
+        }
+
+        if (AdvSimd.IsSupported)
+        {
+            Vector128<uint> prodLo = AdvSimd.MultiplyWideningLower(left.GetLower(), right.GetLower());
+            Vector128<uint> prodHi = AdvSimd.MultiplyWideningUpper(left, right);
+
+            prodLo >>= 16;
+            prodHi >>= 16;
+
+            return Vector128.Narrow(prodLo, prodHi);
+        }
+
+        {
+            // Widen each half of the short vectors into two uint vectors
+            (Vector128<uint> leftLo, Vector128<uint> leftHi) = Vector128.Widen(left);
+            (Vector128<uint> rightLo, Vector128<uint> rightHi) = Vector128.Widen(right);
+
+            // Elementwise multiply: each int lane now holds the full 32-bit product
+            Vector128<uint> prodLo = leftLo * rightLo;
+            Vector128<uint> prodHi = leftHi * rightHi;
+
+            // Arithmetic shift right by 16 bits to extract the high word
+            prodLo >>= 16;
+            prodHi >>= 16;
+
+            // Narrow the two int vectors back into one short vector
+            return Vector128.Narrow(prodLo, prodHi);
+        }
     }
 
-    [DoesNotReturn]
-    private static void ThrowUnreachableException() => throw new UnreachableException();
+    /// <summary>
+    /// Unpack and interleave 64-bit integers from the high half of <paramref name="left"/> and <paramref name="right"/>
+    /// and store the results in the result.
+    /// </summary>
+    /// <param name="left">
+    /// The first vector containing packed 64-bit integers to unpack from the high half.
+    /// </param>
+    /// <param name="right">
+    /// The second vector containing packed 64-bit integers to unpack from the high half.
+    /// </param>
+    /// <returns>
+    /// A vector containing the unpacked and interleaved 64-bit integers from the high
+    /// halves of <paramref name="left"/> and <paramref name="right"/>.
+    /// </returns>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static Vector128<long> UnpackHigh(Vector128<long> left, Vector128<long> right)
+    {
+        if (Sse2.IsSupported)
+        {
+            return Sse2.UnpackHigh(left, right);
+        }
+
+        if (AdvSimd.IsSupported)
+        {
+            return AdvSimd.Arm64.ZipHigh(left, right);
+        }
+
+        return Vector128.Create(left.GetUpper(), right.GetUpper());
+    }
+
+    /// <summary>
+    /// Unpack and interleave 64-bit integers from the low half of <paramref name="left"/> and <paramref name="right"/>
+    /// and store the results in the result.
+    /// </summary>
+    /// <param name="left">
+    /// The first vector containing packed 64-bit integers to unpack from the low half.
+    /// </param>
+    /// <param name="right">
+    /// The second vector containing packed 64-bit integers to unpack from the low half.
+    /// </param>
+    /// <returns>
+    /// A vector containing the unpacked and interleaved 64-bit integers from the low
+    /// halves of <paramref name="left"/> and <paramref name="right"/>.
+    /// </returns>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static Vector128<long> UnpackLow(Vector128<long> left, Vector128<long> right)
+    {
+        if (Sse2.IsSupported)
+        {
+            return Sse2.UnpackLow(left, right);
+        }
+
+        if (AdvSimd.IsSupported)
+        {
+            return AdvSimd.Arm64.ZipLow(left, right);
+        }
+
+        return Vector128.Create(left.GetLower(), right.GetLower());
+    }
+
+    /// <summary>
+    /// Unpack and interleave 32-bit integers from the high half of <paramref name="left"/> and <paramref name="right"/>
+    /// and store the results in the result.
+    /// </summary>
+    /// <param name="left">
+    /// The first vector containing packed 32-bit integers to unpack from the high half.
+    /// </param>
+    /// <param name="right">
+    /// The second vector containing packed 32-bit integers to unpack from the high half.
+    /// </param>
+    /// <returns>
+    /// A vector containing the unpacked and interleaved 32-bit integers from the high
+    /// halves of <paramref name="left"/> and <paramref name="right"/>.
+    /// </returns>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static Vector128<int> UnpackHigh(Vector128<int> left, Vector128<int> right)
+    {
+        if (Sse2.IsSupported)
+        {
+            return Sse2.UnpackHigh(left, right);
+        }
+
+        if (AdvSimd.IsSupported)
+        {
+            return AdvSimd.Arm64.ZipHigh(left, right);
+        }
+
+        Vector128<int> unpacked = Vector128.Create(left.GetUpper(), right.GetUpper());
+        return Vector128.Shuffle(unpacked, Vector128.Create(0, 2, 1, 3));
+    }
+
+    /// <summary>
+    /// Unpack and interleave 32-bit integers from the low half of <paramref name="left"/> and <paramref name="right"/>
+    /// and store the results in the result.
+    /// </summary>
+    /// <param name="left">
+    /// The first vector containing packed 32-bit integers to unpack from the low half.
+    /// </param>
+    /// <param name="right">
+    /// The second vector containing packed 32-bit integers to unpack from the low half.
+    /// </param>
+    /// <returns>
+    /// A vector containing the unpacked and interleaved 32-bit integers from the low
+    /// halves of <paramref name="left"/> and <paramref name="right"/>.
+    /// </returns>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static Vector128<int> UnpackLow(Vector128<int> left, Vector128<int> right)
+    {
+        if (Sse2.IsSupported)
+        {
+            return Sse2.UnpackLow(left, right);
+        }
+
+        if (AdvSimd.IsSupported)
+        {
+            return AdvSimd.Arm64.ZipLow(left, right);
+        }
+
+        Vector128<int> unpacked = Vector128.Create(left.GetLower(), right.GetLower());
+        return Vector128.Shuffle(unpacked, Vector128.Create(0, 2, 1, 3));
+    }
+
+    /// <summary>
+    /// Unpack and interleave 16-bit integers from the high half of <paramref name="left"/> and <paramref name="right"/>
+    /// and store the results in the result.
+    /// </summary>
+    /// <param name="left">
+    /// The first vector containing packed 16-bit integers to unpack from the high half.
+    /// </param>
+    /// <param name="right">
+    /// The second vector containing packed 16-bit integers to unpack from the high half.
+    /// </param>
+    /// <returns>
+    /// A vector containing the unpacked and interleaved 16-bit integers from the high
+    /// halves of <paramref name="left"/> and <paramref name="right"/>.
+    /// </returns>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static Vector128<short> UnpackHigh(Vector128<short> left, Vector128<short> right)
+    {
+        if (Sse2.IsSupported)
+        {
+            return Sse2.UnpackHigh(left, right);
+        }
+
+        if (AdvSimd.IsSupported)
+        {
+            return AdvSimd.Arm64.ZipHigh(left, right);
+        }
+
+        Vector128<short> unpacked = Vector128.Create(left.GetUpper(), right.GetUpper());
+        return Vector128.Shuffle(unpacked, Vector128.Create(0, 4, 1, 5, 2, 6, 3, 7));
+    }
+
+    /// <summary>
+    /// Unpack and interleave 16-bit integers from the low half of <paramref name="left"/> and <paramref name="right"/>
+    /// and store the results in the result.
+    /// </summary>
+    /// <param name="left">
+    /// The first vector containing packed 16-bit integers to unpack from the low half.
+    /// </param>
+    /// <param name="right">
+    /// The second vector containing packed 16-bit integers to unpack from the low half.
+    /// </param>
+    /// <returns>
+    /// A vector containing the unpacked and interleaved 16-bit integers from the low
+    /// halves of <paramref name="left"/> and <paramref name="right"/>.
+    /// </returns>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static Vector128<short> UnpackLow(Vector128<short> left, Vector128<short> right)
+    {
+        if (Sse2.IsSupported)
+        {
+            return Sse2.UnpackLow(left, right);
+        }
+
+        if (AdvSimd.IsSupported)
+        {
+            return AdvSimd.Arm64.ZipLow(left, right);
+        }
+
+        Vector128<short> unpacked = Vector128.Create(left.GetLower(), right.GetLower());
+        return Vector128.Shuffle(unpacked, Vector128.Create(0, 4, 1, 5, 2, 6, 3, 7));
+    }
+
+    /// <summary>
+    /// Unpack and interleave 8-bit integers from the high half of <paramref name="left"/> and <paramref name="right"/>
+    /// and store the results in the result.
+    /// </summary>
+    /// <param name="left">
+    /// The first vector containing packed 8-bit integers to unpack from the high half.
+    /// </param>
+    /// <param name="right">
+    /// The second vector containing packed 8-bit integers to unpack from the high half.
+    /// </param>
+    /// <returns>
+    /// A vector containing the unpacked and interleaved 8-bit integers from the high
+    /// halves of <paramref name="left"/> and <paramref name="right"/>.
+    /// </returns>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static Vector128<byte> UnpackHigh(Vector128<byte> left, Vector128<byte> right)
+    {
+        if (Sse2.IsSupported)
+        {
+            return Sse2.UnpackHigh(left, right);
+        }
+
+        if (AdvSimd.IsSupported)
+        {
+            return AdvSimd.Arm64.ZipHigh(left, right);
+        }
+
+        Vector128<byte> unpacked = Vector128.Create(left.GetUpper(), right.GetUpper());
+        return Vector128.Shuffle(unpacked, Vector128.Create((byte)0, 8, 1, 9, 2, 10, 3, 11, 4, 12, 5, 13, 6, 14, 7, 15));
+    }
+
+    /// <summary>
+    /// Unpack and interleave 8-bit integers from the low half of <paramref name="left"/> and <paramref name="right"/>
+    /// and store the results in the result.
+    /// </summary>
+    /// <param name="left">
+    /// The first vector containing packed 8-bit integers to unpack from the low half.
+    /// </param>
+    /// <param name="right">
+    /// The second vector containing packed 8-bit integers to unpack from the low half.
+    /// </param>
+    /// <returns>
+    /// A vector containing the unpacked and interleaved 8-bit integers from the low
+    /// halves of <paramref name="left"/> and <paramref name="right"/>.
+    /// </returns>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static Vector128<byte> UnpackLow(Vector128<byte> left, Vector128<byte> right)
+    {
+        if (Sse2.IsSupported)
+        {
+            return Sse2.UnpackLow(left, right);
+        }
+
+        if (AdvSimd.IsSupported)
+        {
+            return AdvSimd.Arm64.ZipLow(left, right);
+        }
+
+        Vector128<byte> unpacked = Vector128.Create(left.GetLower(), right.GetLower());
+        return Vector128.Shuffle(unpacked, Vector128.Create((byte)0, 8, 1, 9, 2, 10, 3, 11, 4, 12, 5, 13, 6, 14, 7, 15));
+    }
+
+    /// <summary>
+    /// Unpack and interleave 8-bit signed integers from the high half of <paramref name="left"/> and <paramref name="right"/>
+    /// and store the results in the result.
+    /// </summary>
+    /// <param name="left">
+    /// The first vector containing packed 8-bit signed integers to unpack from the high half.
+    /// </param>
+    /// <param name="right">
+    /// The second vector containing packed 8-bit signed integers to unpack from the high half.
+    /// </param>
+    /// <returns>
+    /// A vector containing the unpacked and interleaved 8-bit signed integers from the high
+    /// halves of <paramref name="left"/> and <paramref name="right"/>.
+    /// </returns>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static Vector128<sbyte> UnpackHigh(Vector128<sbyte> left, Vector128<sbyte> right)
+    {
+        if (Sse2.IsSupported)
+        {
+            return Sse2.UnpackHigh(left, right);
+        }
+
+        if (AdvSimd.IsSupported)
+        {
+            return AdvSimd.Arm64.ZipHigh(left, right);
+        }
+
+        Vector128<sbyte> unpacked = Vector128.Create(left.GetUpper(), right.GetUpper());
+        return Vector128.Shuffle(unpacked, Vector128.Create(0, 8, 1, 9, 2, 10, 3, 11, 4, 12, 5, 13, 6, 14, 7, 15));
+    }
+
+    /// <summary>
+    /// Unpack and interleave 8-bit signed integers from the low half of <paramref name="left"/> and <paramref name="right"/>
+    /// and store the results in the result.
+    /// </summary>
+    /// <param name="left">
+    /// The first vector containing packed 8-bit signed integers to unpack from the low half.
+    /// </param>
+    /// <param name="right">
+    /// The second vector containing packed 8-bit signed integers to unpack from the low half.
+    /// </param>
+    /// <returns>
+    /// A vector containing the unpacked and interleaved 8-bit signed integers from the low
+    /// halves of <paramref name="left"/> and <paramref name="right"/>.
+    /// </returns>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static Vector128<sbyte> UnpackLow(Vector128<sbyte> left, Vector128<sbyte> right)
+    {
+        if (Sse2.IsSupported)
+        {
+            return Sse2.UnpackLow(left, right);
+        }
+
+        if (AdvSimd.IsSupported)
+        {
+            return AdvSimd.Arm64.ZipLow(left, right);
+        }
+
+        Vector128<sbyte> unpacked = Vector128.Create(left.GetLower(), right.GetLower());
+        return Vector128.Shuffle(unpacked, Vector128.Create(0, 8, 1, 9, 2, 10, 3, 11, 4, 12, 5, 13, 6, 14, 7, 15));
+    }
+
+    /// <summary>
+    /// Subtract packed signed 16-bit integers in <paramref name="right"/> from packed signed 16-bit integers
+    /// in <paramref name="left"/> using saturation, and store the results.
+    /// </summary>
+    /// <param name="left">
+    /// The first vector containing packed signed 16-bit integers to subtract from.
+    /// </param>
+    /// <param name="right">
+    /// The second vector containing packed signed 16-bit integers to subtract.
+    /// </param>
+    /// <returns>
+    /// A vector containing the results of subtracting packed signed 16-bit integers
+    /// </returns>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static Vector128<short> SubtractSaturate(Vector128<short> left, Vector128<short> right)
+    {
+        if (Sse2.IsSupported)
+        {
+            return Sse2.SubtractSaturate(left, right);
+        }
+
+        if (AdvSimd.IsSupported)
+        {
+            return AdvSimd.SubtractSaturate(left, right);
+        }
+
+        if (PackedSimd.IsSupported)
+        {
+            return PackedSimd.SubtractSaturate(left, right);
+        }
+
+        // Widen inputs to 32-bit signed
+        (Vector128<int> leftLo, Vector128<int> leftHi) = Vector128.Widen(left);
+        (Vector128<int> rightLo, Vector128<int> rightHi) = Vector128.Widen(right);
+
+        // Subtract
+        Vector128<int> diffLo = leftLo - rightLo;
+        Vector128<int> diffHi = leftHi - rightHi;
+
+        // Clamp to signed 16-bit range
+        Vector128<int> min = Vector128.Create((int)short.MinValue);
+        Vector128<int> max = Vector128.Create((int)short.MaxValue);
+
+        diffLo = Clamp(diffLo, min, max);
+        diffHi = Clamp(diffHi, min, max);
+
+        // Narrow back to 16 bit signed.
+        return Vector128.Narrow(diffLo, diffHi);
+    }
+
+    /// <summary>
+    /// Subtract packed unsigned 16-bit integers in <paramref name="right"/> from packed unsigned 16-bit integers
+    /// in <paramref name="left"/> using saturation, and store the results.
+    /// </summary>
+    /// <param name="left">
+    /// The first vector containing packed unsigned 16-bit integers to subtract from.
+    /// </param>
+    /// <param name="right">
+    /// The second vector containing packed unsigned 16-bit integers to subtract.
+    /// </param>
+    /// <returns>
+    /// A vector containing the results of subtracting packed unsigned 16-bit integers
+    /// </returns>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static Vector128<ushort> SubtractSaturate(Vector128<ushort> left, Vector128<ushort> right)
+    {
+        if (Sse2.IsSupported)
+        {
+            return Sse2.SubtractSaturate(left, right);
+        }
+
+        if (AdvSimd.IsSupported)
+        {
+            return AdvSimd.SubtractSaturate(left, right);
+        }
+
+        if (PackedSimd.IsSupported)
+        {
+            return PackedSimd.SubtractSaturate(left, right);
+        }
+
+        // Widen inputs to 32-bit signed
+        (Vector128<uint> leftLo, Vector128<uint> leftHi) = Vector128.Widen(left);
+        (Vector128<uint> rightLo, Vector128<uint> rightHi) = Vector128.Widen(right);
+
+        // Subtract
+        Vector128<uint> diffLo = leftLo - rightLo;
+        Vector128<uint> diffHi = leftHi - rightHi;
+
+        // Clamp to signed 16-bit range
+        Vector128<uint> min = Vector128.Create((uint)ushort.MinValue);
+        Vector128<uint> max = Vector128.Create((uint)ushort.MaxValue);
+
+        diffLo = Clamp(diffLo, min, max);
+        diffHi = Clamp(diffHi, min, max);
+
+        // Narrow back to 16 bit signed.
+        return Vector128.Narrow(diffLo, diffHi);
+    }
+
+    /// <summary>
+    /// Add packed unsigned 8-bit integers in <paramref name="right"/> to packed unsigned 8-bit integers
+    /// in <paramref name="left"/> using saturation, and store the results.
+    /// </summary>
+    /// <param name="left">
+    /// The first vector containing packed unsigned 8-bit integers to add to.
+    /// </param>
+    /// <param name="right">
+    /// The second vector containing packed unsigned 8-bit integers to add.
+    /// </param>
+    /// <returns>
+    /// A vector containing the results of adding packed unsigned 8-bit integers
+    /// </returns>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static Vector128<byte> AddSaturate(Vector128<byte> left, Vector128<byte> right)
+    {
+        if (Sse2.IsSupported)
+        {
+            return Sse2.AddSaturate(left, right);
+        }
+
+        if (AdvSimd.IsSupported)
+        {
+            return AdvSimd.AddSaturate(left, right);
+        }
+
+        if (PackedSimd.IsSupported)
+        {
+            return PackedSimd.AddSaturate(left, right);
+        }
+
+        // Widen inputs to 16-bit
+        (Vector128<ushort> leftLo, Vector128<ushort> leftHi) = Vector128.Widen(left);
+        (Vector128<ushort> rightLo, Vector128<ushort> rightHi) = Vector128.Widen(right);
+
+        // Add
+        Vector128<ushort> sumLo = leftLo + rightLo;
+        Vector128<ushort> sumHi = leftHi + rightHi;
+
+        // Clamp to signed 8-bit range
+        Vector128<ushort> max = Vector128.Create((ushort)byte.MaxValue);
+
+        sumLo = Clamp(sumLo, Vector128<ushort>.Zero, max);
+        sumHi = Clamp(sumHi, Vector128<ushort>.Zero, max);
+
+        // Narrow back to bytes
+        return Vector128.Narrow(sumLo, sumHi);
+    }
+
+    /// <summary>
+    /// Add packed unsigned 16-bit integers in <paramref name="right"/> to packed unsigned 16-bit integers
+    /// in <paramref name="left"/> using saturation, and store the results.
+    /// </summary>
+    /// <param name="left">
+    /// The first vector containing packed unsigned 16-bit integers to add to.
+    /// </param>
+    /// <param name="right">
+    /// The second vector containing packed unsigned 16-bit integers to add.
+    /// </param>
+    /// <returns>
+    /// A vector containing the results of adding packed unsigned 16-bit integers
+    /// </returns>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static Vector128<ushort> AddSaturate(Vector128<ushort> left, Vector128<ushort> right)
+    {
+        if (Sse2.IsSupported)
+        {
+            return Sse2.AddSaturate(left, right);
+        }
+
+        if (AdvSimd.IsSupported)
+        {
+            return AdvSimd.AddSaturate(left, right);
+        }
+
+        if (PackedSimd.IsSupported)
+        {
+            return PackedSimd.AddSaturate(left, right);
+        }
+
+        // Widen inputs to 32-bit
+        (Vector128<uint> leftLo, Vector128<uint> leftHi) = Vector128.Widen(left);
+        (Vector128<uint> rightLo, Vector128<uint> rightHi) = Vector128.Widen(right);
+
+        // Add
+        Vector128<uint> sumLo = leftLo + rightLo;
+        Vector128<uint> sumHi = leftHi + rightHi;
+
+        // Clamp to signed 16-bit range
+        Vector128<uint> max = Vector128.Create((uint)ushort.MaxValue);
+
+        sumLo = Clamp(sumLo, Vector128<uint>.Zero, max);
+        sumHi = Clamp(sumHi, Vector128<uint>.Zero, max);
+
+        // Narrow back to 16 bit unsigned.
+        return Vector128.Narrow(sumLo, sumHi);
+    }
+
+    /// <summary>
+    /// Subtract packed unsigned 8-bit integers in <paramref name="right"/> from packed unsigned 8-bit integers
+    /// in <paramref name="left"/> using saturation, and store the results.
+    /// </summary>
+    /// <param name="left">
+    /// The first vector containing packed unsigned 8-bit integers to subtract from.
+    /// </param>
+    /// <param name="right">
+    /// The second vector containing packed unsigned 8-bit integers to subtract.
+    /// </param>
+    /// <returns>
+    /// A vector containing the results of subtracting packed unsigned 8-bit integers
+    /// </returns>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static Vector128<byte> SubtractSaturate(Vector128<byte> left, Vector128<byte> right)
+    {
+        if (Sse2.IsSupported)
+        {
+            return Sse2.SubtractSaturate(left, right);
+        }
+
+        if (AdvSimd.IsSupported)
+        {
+            return AdvSimd.SubtractSaturate(left, right);
+        }
+
+        if (PackedSimd.IsSupported)
+        {
+            return PackedSimd.SubtractSaturate(left, right);
+        }
+
+        // Widen inputs to 16-bit
+        (Vector128<ushort> leftLo, Vector128<ushort> leftHi) = Vector128.Widen(left);
+        (Vector128<ushort> rightLo, Vector128<ushort> rightHi) = Vector128.Widen(right);
+
+        // Subtract
+        Vector128<ushort> diffLo = leftLo - rightLo;
+        Vector128<ushort> diffHi = leftHi - rightHi;
+
+        // Clamp to signed 8-bit range
+        Vector128<ushort> max = Vector128.Create((ushort)byte.MaxValue);
+
+        diffLo = Clamp(diffLo, Vector128<ushort>.Zero, max);
+        diffHi = Clamp(diffHi, Vector128<ushort>.Zero, max);
+
+        // Narrow back to bytes
+        return Vector128.Narrow(diffLo, diffHi);
+    }
+
+    /// <summary>
+    /// Add packed unsigned 8-bit integers in <paramref name="right"/> from packed unsigned 8-bit integers
+    /// in <paramref name="left"/> using saturation, and store the results.
+    /// </summary>
+    /// <param name="left">
+    /// The first vector containing packed unsigned 8-bit integers to add to.
+    /// </param>
+    /// <param name="right">
+    /// The second vector containing packed unsigned 8-bit integers to add.
+    /// </param>
+    /// <returns>
+    /// A vector containing the results of adding packed unsigned 8-bit integers
+    /// </returns>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static Vector128<sbyte> AddSaturate(Vector128<sbyte> left, Vector128<sbyte> right)
+    {
+        if (Sse2.IsSupported)
+        {
+            return Sse2.AddSaturate(left, right);
+        }
+
+        if (AdvSimd.IsSupported)
+        {
+            return AdvSimd.AddSaturate(left, right);
+        }
+
+        if (PackedSimd.IsSupported)
+        {
+            return PackedSimd.AddSaturate(left, right);
+        }
+
+        // Widen inputs to 16-bit
+        (Vector128<short> leftLo, Vector128<short> leftHi) = Vector128.Widen(left);
+        (Vector128<short> rightLo, Vector128<short> rightHi) = Vector128.Widen(right);
+
+        // Add
+        Vector128<short> sumLo = leftLo + rightLo;
+        Vector128<short> sumHi = leftHi + rightHi;
+
+        // Clamp to signed 8-bit range
+        Vector128<short> min = Vector128.Create((short)sbyte.MinValue);
+        Vector128<short> max = Vector128.Create((short)sbyte.MaxValue);
+
+        sumLo = Clamp(sumLo, min, max);
+        sumHi = Clamp(sumHi, min, max);
+
+        // Narrow back to signed bytes
+        return Vector128.Narrow(sumLo, sumHi);
+    }
+
+    /// <summary>
+    /// Subtract packed signed 8-bit integers in <paramref name="right"/> from packed signed 8-bit integers
+    /// in <paramref name="left"/> using saturation, and store the results.
+    /// </summary>
+    /// <param name="left">
+    /// The first vector containing packed signed 8-bit integers to subtract from.
+    /// </param>
+    /// <param name="right">
+    /// The second vector containing packed signed 8-bit integers to subtract.
+    /// </param>
+    /// <returns>
+    /// A vector containing the results of subtracting packed signed 8-bit integers
+    /// </returns>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static Vector128<sbyte> SubtractSaturate(Vector128<sbyte> left, Vector128<sbyte> right)
+    {
+        if (Sse2.IsSupported)
+        {
+            return Sse2.SubtractSaturate(left, right);
+        }
+
+        if (AdvSimd.IsSupported)
+        {
+            return AdvSimd.SubtractSaturate(left, right);
+        }
+
+        if (PackedSimd.IsSupported)
+        {
+            return PackedSimd.SubtractSaturate(left, right);
+        }
+
+        // Widen inputs to 16-bit
+        (Vector128<short> leftLo, Vector128<short> leftHi) = Vector128.Widen(left);
+        (Vector128<short> rightLo, Vector128<short> rightHi) = Vector128.Widen(right);
+
+        // Subtract
+        Vector128<short> diffLo = leftLo - rightLo;
+        Vector128<short> diffHi = leftHi - rightHi;
+
+        // Clamp to signed 8-bit range
+        Vector128<short> min = Vector128.Create((short)sbyte.MinValue);
+        Vector128<short> max = Vector128.Create((short)sbyte.MaxValue);
+
+        diffLo = Clamp(diffLo, min, max);
+        diffHi = Clamp(diffHi, min, max);
+
+        // Narrow back to signed bytes
+        return Vector128.Narrow(diffLo, diffHi);
+    }
 }
diff --git a/src/ImageSharp/Common/Helpers/Vector256Utilities.cs b/src/ImageSharp/Common/Helpers/Vector256Utilities.cs
index 6e8c0d1de4..14ac13dd8d 100644
--- a/src/ImageSharp/Common/Helpers/Vector256Utilities.cs
+++ b/src/ImageSharp/Common/Helpers/Vector256Utilities.cs
@@ -1,7 +1,6 @@
 // Copyright (c) Six Labors.
 // Licensed under the Six Labors Split License.
 
-using System.Diagnostics;
 using System.Diagnostics.CodeAnalysis;
 using System.Runtime.CompilerServices;
 using System.Runtime.Intrinsics;
@@ -17,26 +16,10 @@ namespace SixLabors.ImageSharp.Common.Helpers;
 /// </list>
 /// Should only be used if the intrinsics are available.
 /// </summary>
-internal static class Vector256Utilities
+#pragma warning disable SA1649 // File name should match first type name
+internal static class Vector256_
+#pragma warning restore SA1649 // File name should match first type name
 {
-    /// <summary>
-    /// Gets a value indicating whether shuffle byte operations are supported.
-    /// </summary>
-    public static bool SupportsShuffleFloat
-    {
-        [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        get => Avx.IsSupported || Sse.IsSupported;
-    }
-
-    /// <summary>
-    /// Gets a value indicating whether shuffle byte operations are supported.
-    /// </summary>
-    public static bool SupportsShuffleByte
-    {
-        [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        get => Avx2.IsSupported;
-    }
-
     /// <summary>
     /// Creates a new vector by selecting values from an input vector using a set of indices.
     /// </summary>
@@ -44,23 +27,8 @@ internal static class Vector256Utilities
     /// <param name="control">The shuffle control byte.</param>
     /// <returns>The <see cref="Vector256{Single}"/>.</returns>
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
-    public static Vector256<float> Shuffle(Vector256<float> vector, [ConstantExpected] byte control)
-    {
-        if (Avx.IsSupported)
-        {
-            return Avx.Shuffle(vector, vector, control);
-        }
-
-        if (Sse.IsSupported)
-        {
-            Vector128<float> lower = vector.GetLower();
-            Vector128<float> upper = vector.GetUpper();
-            return Vector256.Create(Sse.Shuffle(lower, lower, control), Sse.Shuffle(upper, upper, control));
-        }
-
-        ThrowUnreachableException();
-        return default;
-    }
+    public static Vector256<float> ShuffleNative(Vector256<float> vector, [ConstantExpected] byte control)
+        => Avx.Shuffle(vector, vector, control);
 
     /// <summary>
     /// Creates a new vector by selecting values from an input vector using a set of indices.</summary>
@@ -71,15 +39,17 @@ internal static class Vector256Utilities
     /// </param>
     /// <returns>The <see cref="Vector256{Single}"/>.</returns>
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
-    public static Vector256<byte> Shuffle(Vector256<byte> vector, Vector256<byte> indices)
+    public static Vector256<byte> ShufflePerLane(Vector256<byte> vector, Vector256<byte> indices)
     {
         if (Avx2.IsSupported)
         {
             return Avx2.Shuffle(vector, indices);
         }
 
-        ThrowUnreachableException();
-        return default;
+        Vector128<byte> indicesLo = indices.GetLower();
+        Vector128<byte> lower = Vector128_.ShuffleNative(vector.GetLower(), indicesLo);
+        Vector128<byte> upper = Vector128_.ShuffleNative(vector.GetUpper(), indicesLo);
+        return Vector256.Create(lower, upper);
     }
 
     /// <summary>
@@ -96,20 +66,399 @@ internal static class Vector256Utilities
             return Avx.ConvertToVector256Int32(vector);
         }
 
-        if (Sse2.IsSupported)
+        Vector256<float> sign = vector & Vector256.Create(-0F);
+        Vector256<float> val_2p23_f32 = sign | Vector256.Create(8388608F);
+
+        val_2p23_f32 = (vector + val_2p23_f32) - val_2p23_f32;
+        return Vector256.ConvertToInt32(val_2p23_f32 | sign);
+    }
+
+    /// <summary>
+    /// Rounds all values in <paramref name="vector"/> to the nearest integer
+    /// following <see cref="MidpointRounding.ToEven"/> semantics.
+    /// </summary>
+    /// <param name="vector">The vector</param>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static Vector256<float> RoundToNearestInteger(Vector256<float> vector)
+    {
+        if (Avx.IsSupported)
         {
-            Vector128<int> lower = Sse2.ConvertToVector128Int32(vector.GetLower());
-            Vector128<int> upper = Sse2.ConvertToVector128Int32(vector.GetUpper());
-            return Vector256.Create(lower, upper);
+            return Avx.RoundToNearestInteger(vector);
         }
 
-        Vector256<float> sign = vector & Vector256.Create(-0.0f);
-        Vector256<float> val_2p23_f32 = sign | Vector256.Create(8388608.0f);
+        Vector256<float> sign = vector & Vector256.Create(-0F);
+        Vector256<float> val_2p23_f32 = sign | Vector256.Create(8388608F);
 
         val_2p23_f32 = (vector + val_2p23_f32) - val_2p23_f32;
-        return Vector256.ConvertToInt32(val_2p23_f32 | sign);
+        return val_2p23_f32 | sign;
+    }
+
+    /// <summary>
+    /// Performs a multiplication and an addition of the <see cref="Vector256{Single}"/>.
+    /// </summary>
+    /// <remarks>ret = (vm0 * vm1) + va</remarks>
+    /// <param name="va">The vector to add to the intermediate result.</param>
+    /// <param name="vm0">The first vector to multiply.</param>
+    /// <param name="vm1">The second vector to multiply.</param>
+    /// <returns>The <see cref="Vector256{T}"/>.</returns>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static Vector256<float> MultiplyAdd(
+        Vector256<float> va,
+        Vector256<float> vm0,
+        Vector256<float> vm1)
+    {
+        if (Fma.IsSupported)
+        {
+            return Fma.MultiplyAdd(vm0, vm1, va);
+        }
+
+        return va + (vm0 * vm1);
+    }
+
+    /// <summary>
+    /// Performs a multiplication and a subtraction of the <see cref="Vector256{Single}"/>.
+    /// </summary>
+    /// <remarks>ret = (vm0 * vm1) - vs</remarks>
+    /// <param name="vs">The vector to subtract from the intermediate result.</param>
+    /// <param name="vm0">The first vector to multiply.</param>
+    /// <param name="vm1">The second vector to multiply.</param>
+    /// <returns>The <see cref="Vector256{T}"/>.</returns>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static Vector256<float> MultiplySubtract(
+        Vector256<float> vs,
+        Vector256<float> vm0,
+        Vector256<float> vm1)
+    {
+        if (Fma.IsSupported)
+        {
+            return Fma.MultiplySubtract(vm1, vm0, vs);
+        }
+
+        return (vm0 * vm1) - vs;
+    }
+
+    /// <summary>
+    /// Multiply packed signed 16-bit integers in <paramref name="left"/> and <paramref name="right"/>, producing
+    /// intermediate signed 32-bit integers. Horizontally add adjacent pairs of intermediate 32-bit integers, and
+    /// pack the results.
+    /// </summary>
+    /// <param name="left">
+    /// The first vector containing packed signed 16-bit integers to multiply and add.
+    /// </param>
+    /// <param name="right">
+    /// The second vector containing packed signed 16-bit integers to multiply and add.
+    /// </param>
+    /// <returns>
+    /// A vector containing the results of multiplying and adding adjacent pairs of packed signed 16-bit integers
+    /// </returns>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static Vector256<int> MultiplyAddAdjacent(Vector256<short> left, Vector256<short> right)
+    {
+        if (Avx2.IsSupported)
+        {
+            return Avx2.MultiplyAddAdjacent(left, right);
+        }
+
+        return Vector256.Create(
+            Vector128_.MultiplyAddAdjacent(left.GetLower(), right.GetLower()),
+            Vector128_.MultiplyAddAdjacent(left.GetUpper(), right.GetUpper()));
+    }
+
+    /// <summary>
+    /// Packs signed 32-bit integers to signed 16-bit integers and saturates.
+    /// </summary>
+    /// <param name="left">The left hand source vector.</param>
+    /// <param name="right">The right hand source vector.</param>
+    /// <returns>The <see cref="Vector256{UInt16}"/>.</returns>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static Vector256<ushort> PackUnsignedSaturate(Vector256<int> left, Vector256<int> right)
+    {
+        if (Avx2.IsSupported)
+        {
+            return Avx2.PackUnsignedSaturate(left, right);
+        }
+
+        Vector256<int> min = Vector256.Create((int)ushort.MinValue);
+        Vector256<int> max = Vector256.Create((int)ushort.MaxValue);
+        Vector256<uint> lefClamped = Clamp(left, min, max).AsUInt32();
+        Vector256<uint> rightClamped = Clamp(right, min, max).AsUInt32();
+        return Vector256.Narrow(lefClamped, rightClamped);
+    }
+
+    /// <summary>
+    /// Packs signed 32-bit integers to signed 16-bit integers and saturates.
+    /// </summary>
+    /// <param name="left">The left hand source vector.</param>
+    /// <param name="right">The right hand source vector.</param>
+    /// <returns>The <see cref="Vector256{Int16}"/>.</returns>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static Vector256<short> PackSignedSaturate(Vector256<int> left, Vector256<int> right)
+    {
+        if (Avx2.IsSupported)
+        {
+            return Avx2.PackSignedSaturate(left, right);
+        }
+
+        Vector256<int> min = Vector256.Create((int)short.MinValue);
+        Vector256<int> max = Vector256.Create((int)short.MaxValue);
+        Vector256<int> lefClamped = Clamp(left, min, max);
+        Vector256<int> rightClamped = Clamp(right, min, max);
+        return Vector256.Narrow(lefClamped, rightClamped);
+    }
+
+    /// <summary>
+    /// Packs signed 16-bit integers to signed 8-bit integers and saturates.
+    /// </summary>
+    /// <param name="left">The left hand source vector.</param>
+    /// <param name="right">The right hand source vector.</param>
+    /// <returns>The <see cref="Vector256{SByte}"/>.</returns>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static Vector256<sbyte> PackSignedSaturate(Vector256<short> left, Vector256<short> right)
+    {
+        if (Avx2.IsSupported)
+        {
+            return Avx2.PackSignedSaturate(left, right);
+        }
+
+        Vector256<short> min = Vector256.Create((short)sbyte.MinValue);
+        Vector256<short> max = Vector256.Create((short)sbyte.MaxValue);
+        Vector256<short> lefClamped = Clamp(left, min, max);
+        Vector256<short> rightClamped = Clamp(right, min, max);
+        return Vector256.Narrow(lefClamped, rightClamped);
+    }
+
+    /// <summary>
+    /// Restricts a vector between a minimum and a maximum value.
+    /// </summary>
+    /// <typeparam name="T">The type of the elements in the vector.</typeparam>
+    /// <param name="value">The vector to restrict.</param>
+    /// <param name="min">The minimum value.</param>
+    /// <param name="max">The maximum value.</param>
+    /// <returns>The restricted <see cref="Vector256{T}"/>.</returns>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static Vector256<T> Clamp<T>(Vector256<T> value, Vector256<T> min, Vector256<T> max)
+        => Vector256.Min(Vector256.Max(value, min), max);
+
+    /// <summary>
+    /// Widens a <see cref="Vector128{Int16}"/> to a <see cref="Vector256{Int32}"/>.
+    /// </summary>
+    /// <param name="value">The vector to widen.</param>
+    /// <returns>The widened <see cref="Vector256{Int32}"/>.</returns>
+    public static Vector256<int> Widen(Vector128<short> value)
+    {
+        if (Avx2.IsSupported)
+        {
+            return Avx2.ConvertToVector256Int32(value);
+        }
+
+        return Vector256.WidenLower(value.ToVector256());
     }
 
-    [DoesNotReturn]
-    private static void ThrowUnreachableException() => throw new UnreachableException();
+    /// <summary>
+    /// Multiply the packed 16-bit integers in <paramref name="left"/> and <paramref name="right"/>, producing
+    /// intermediate 32-bit integers, and store the low 16 bits of the intermediate integers in the result.
+    /// </summary>
+    /// <param name="left">
+    /// The first vector containing packed 16-bit integers to multiply.
+    /// </param>
+    /// <param name="right">
+    /// The second vector containing packed 16-bit integers to multiply.
+    /// </param>
+    /// <returns>
+    /// A vector containing the low 16 bits of the products of the packed 16-bit integers
+    /// from <paramref name="left"/> and <paramref name="right"/>.
+    /// </returns>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static Vector256<short> MultiplyLow(Vector256<short> left, Vector256<short> right)
+    {
+        if (Avx2.IsSupported)
+        {
+            return Avx2.MultiplyLow(left, right);
+        }
+
+        // Widen each half of the short vectors into two int vectors
+        (Vector256<int> leftLower, Vector256<int> leftUpper) = Vector256.Widen(left);
+        (Vector256<int> rightLower, Vector256<int> rightUpper) = Vector256.Widen(right);
+
+        // Elementwise multiply: each int lane now holds the full 32-bit product
+        Vector256<int> prodLo = leftLower * rightLower;
+        Vector256<int> prodHi = leftUpper * rightUpper;
+
+        // Narrow the two int vectors back into one short vector
+        return Vector256.Narrow(prodLo, prodHi);
+    }
+
+    /// <summary>
+    /// Multiply the packed 16-bit integers in <paramref name="left"/> and <paramref name="right"/>, producing
+    /// intermediate 32-bit integers, and store the high 16 bits of the intermediate integers in the result.
+    /// </summary>
+    /// <param name="left">
+    /// The first vector containing packed 16-bit integers to multiply.
+    /// </param>
+    /// <param name="right">
+    /// The second vector containing packed 16-bit integers to multiply.
+    /// </param>
+    /// <returns>
+    /// A vector containing the high 16 bits of the products of the packed 16-bit integers
+    /// from <paramref name="left"/> and <paramref name="right"/>.
+    /// </returns>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static Vector256<short> MultiplyHigh(Vector256<short> left, Vector256<short> right)
+    {
+        if (Avx2.IsSupported)
+        {
+            return Avx2.MultiplyHigh(left, right);
+        }
+
+        // Widen each half of the short vectors into two int vectors
+        (Vector256<int> leftLower, Vector256<int> leftUpper) = Vector256.Widen(left);
+        (Vector256<int> rightLower, Vector256<int> rightUpper) = Vector256.Widen(right);
+
+        // Elementwise multiply: each int lane now holds the full 32-bit product
+        Vector256<int> prodLo = leftLower * rightLower;
+        Vector256<int> prodHi = leftUpper * rightUpper;
+
+        // Arithmetic shift right by 16 bits to extract the high word
+        prodLo >>= 16;
+        prodHi >>= 16;
+
+        // Narrow the two int vectors back into one short vector
+        return Vector256.Narrow(prodLo, prodHi);
+    }
+
+    /// <summary>
+    /// Unpack and interleave 32-bit integers from the low half of <paramref name="left"/> and <paramref name="right"/>
+    /// and store the results in the result.
+    /// </summary>
+    /// <param name="left">
+    /// The first vector containing packed 32-bit integers to unpack from the low half.
+    /// </param>
+    /// <param name="right">
+    /// The second vector containing packed 32-bit integers to unpack from the low half.
+    /// </param>
+    /// <returns>
+    /// A vector containing the unpacked and interleaved 32-bit integers from the low
+    /// halves of <paramref name="left"/> and <paramref name="right"/>.
+    /// </returns>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static Vector256<int> UnpackLow(Vector256<int> left, Vector256<int> right)
+    {
+        if (Avx2.IsSupported)
+        {
+            return Avx2.UnpackLow(left, right);
+        }
+
+        Vector128<int> lo = Vector128_.UnpackLow(left.GetLower(), right.GetLower());
+        Vector128<int> hi = Vector128_.UnpackLow(left.GetUpper(), right.GetUpper());
+
+        return Vector256.Create(lo, hi);
+    }
+
+    /// <summary>
+    /// Unpack and interleave 8-bit integers from the high half of <paramref name="left"/> and <paramref name="right"/>
+    /// and store the results in the result.
+    /// </summary>
+    /// <param name="left">
+    /// The first vector containing packed 8-bit integers to unpack from the high half.
+    /// </param>
+    /// <param name="right">
+    /// The second vector containing packed 8-bit integers to unpack from the high half.
+    /// </param>
+    /// <returns>
+    /// A vector containing the unpacked and interleaved 8-bit integers from the high
+    /// halves of <paramref name="left"/> and <paramref name="right"/>.
+    /// </returns>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static Vector256<byte> UnpackHigh(Vector256<byte> left, Vector256<byte> right)
+    {
+        if (Avx2.IsSupported)
+        {
+            return Avx2.UnpackHigh(left, right);
+        }
+
+        Vector128<byte> lo = Vector128_.UnpackHigh(left.GetLower(), right.GetLower());
+        Vector128<byte> hi = Vector128_.UnpackHigh(left.GetUpper(), right.GetUpper());
+
+        return Vector256.Create(lo, hi);
+    }
+
+    /// <summary>
+    /// Unpack and interleave 8-bit integers from the low half of <paramref name="left"/> and <paramref name="right"/>
+    /// and store the results in the result.
+    /// </summary>
+    /// <param name="left">
+    /// The first vector containing packed 8-bit integers to unpack from the low half.
+    /// </param>
+    /// <param name="right">
+    /// The second vector containing packed 8-bit integers to unpack from the low half.
+    /// </param>
+    /// <returns>
+    /// A vector containing the unpacked and interleaved 8-bit integers from the low
+    /// halves of <paramref name="left"/> and <paramref name="right"/>.
+    /// </returns>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static Vector256<byte> UnpackLow(Vector256<byte> left, Vector256<byte> right)
+    {
+        if (Avx2.IsSupported)
+        {
+            return Avx2.UnpackLow(left, right);
+        }
+
+        Vector128<byte> lo = Vector128_.UnpackLow(left.GetLower(), right.GetLower());
+        Vector128<byte> hi = Vector128_.UnpackLow(left.GetUpper(), right.GetUpper());
+
+        return Vector256.Create(lo, hi);
+    }
+
+    /// <summary>
+    /// Subtract packed signed 16-bit integers in <paramref name="right"/> from packed signed 16-bit integers
+    /// in <paramref name="left"/> using saturation, and store the results.
+    /// </summary>
+    /// <param name="left">
+    /// The first vector containing packed signed 16-bit integers to subtract from.
+    /// </param>
+    /// <param name="right">
+    /// The second vector containing packed signed 16-bit integers to subtract.
+    /// </param>
+    /// <returns>
+    /// A vector containing the results of subtracting packed unsigned 16-bit integers
+    /// </returns>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static Vector256<short> SubtractSaturate(Vector256<short> left, Vector256<short> right)
+    {
+        if (Avx2.IsSupported)
+        {
+            return Avx2.SubtractSaturate(left, right);
+        }
+
+        return Vector256.Create(
+            Vector128_.SubtractSaturate(left.GetLower(), right.GetLower()),
+            Vector128_.SubtractSaturate(left.GetUpper(), right.GetUpper()));
+    }
+
+    /// <summary>
+    /// Subtract packed unsigned 8-bit integers in <paramref name="right"/> from packed unsigned 8-bit integers
+    /// in <paramref name="left"/> using saturation, and store the results.
+    /// </summary>
+    /// <param name="left">
+    /// The first vector containing packed unsigned 8-bit integers to subtract from.
+    /// </param>
+    /// <param name="right">
+    /// The second vector containing packed unsigned 8-bit integers to subtract.
+    /// </param>
+    /// <returns>
+    /// A vector containing the results of subtracting packed unsigned 8-bit integers
+    /// </returns>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static Vector256<byte> SubtractSaturate(Vector256<byte> left, Vector256<byte> right)
+    {
+        if (Avx2.IsSupported)
+        {
+            return Avx2.SubtractSaturate(left, right);
+        }
+
+        return Vector256.Create(
+            Vector128_.SubtractSaturate(left.GetLower(), right.GetLower()),
+            Vector128_.SubtractSaturate(left.GetUpper(), right.GetUpper()));
+    }
 }
diff --git a/src/ImageSharp/Common/Helpers/Vector512Utilities.cs b/src/ImageSharp/Common/Helpers/Vector512Utilities.cs
index 0165af90ef..03ee4626cd 100644
--- a/src/ImageSharp/Common/Helpers/Vector512Utilities.cs
+++ b/src/ImageSharp/Common/Helpers/Vector512Utilities.cs
@@ -1,7 +1,6 @@
 // Copyright (c) Six Labors.
 // Licensed under the Six Labors Split License.
 
-using System.Diagnostics;
 using System.Diagnostics.CodeAnalysis;
 using System.Runtime.CompilerServices;
 using System.Runtime.Intrinsics;
@@ -17,26 +16,10 @@ namespace SixLabors.ImageSharp.Common.Helpers;
 /// </list>
 /// Should only be used if the intrinsics are available.
 /// </summary>
-internal static class Vector512Utilities
+#pragma warning disable SA1649 // File name should match first type name
+internal static class Vector512_
+#pragma warning restore SA1649 // File name should match first type name
 {
-    /// <summary>
-    /// Gets a value indicating whether shuffle float operations are supported.
-    /// </summary>
-    public static bool SupportsShuffleFloat
-    {
-        [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        get => Avx512F.IsSupported || Avx.IsSupported;
-    }
-
-    /// <summary>
-    /// Gets a value indicating whether shuffle byte operations are supported.
-    /// </summary>
-    public static bool SupportsShuffleByte
-    {
-        [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        get => Avx512BW.IsSupported;
-    }
-
     /// <summary>
     /// Creates a new vector by selecting values from an input vector using the control.
     /// </summary>
@@ -44,23 +27,8 @@ internal static class Vector512Utilities
     /// <param name="control">The shuffle control byte.</param>
     /// <returns>The <see cref="Vector512{Single}"/>.</returns>
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
-    public static Vector512<float> Shuffle(Vector512<float> vector, [ConstantExpected] byte control)
-    {
-        if (Avx512F.IsSupported)
-        {
-            return Avx512F.Shuffle(vector, vector, control);
-        }
-
-        if (Avx.IsSupported)
-        {
-            Vector256<float> lower = vector.GetLower();
-            Vector256<float> upper = vector.GetUpper();
-            return Vector512.Create(Avx.Shuffle(lower, lower, control), Avx.Shuffle(upper, upper, control));
-        }
-
-        ThrowUnreachableException();
-        return default;
-    }
+    public static Vector512<float> ShuffleNative(Vector512<float> vector, [ConstantExpected] byte control)
+        => Avx512F.Shuffle(vector, vector, control);
 
     /// <summary>
     /// Creates a new vector by selecting values from an input vector using a set of indices.
@@ -71,15 +39,14 @@ internal static class Vector512Utilities
     /// </param>
     /// <returns>The <see cref="Vector512{Byte}"/>.</returns>
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
-    public static Vector512<byte> Shuffle(Vector512<byte> vector, Vector512<byte> indices)
+    public static Vector512<byte> ShuffleNative(Vector512<byte> vector, Vector512<byte> indices)
     {
         if (Avx512BW.IsSupported)
         {
             return Avx512BW.Shuffle(vector, indices);
         }
 
-        ThrowUnreachableException();
-        return default;
+        return Vector512.Shuffle(vector, indices);
     }
 
     /// <summary>
@@ -90,26 +57,45 @@ internal static class Vector512Utilities
     /// <returns>The <see cref="Vector128{Int32}"/>.</returns>
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
     public static Vector512<int> ConvertToInt32RoundToEven(Vector512<float> vector)
-    {
-        if (Avx512F.IsSupported)
-        {
-            return Avx512F.ConvertToVector512Int32(vector);
-        }
+        => Avx512F.ConvertToVector512Int32(vector);
 
-        if (Avx.IsSupported)
-        {
-            Vector256<int> lower = Avx.ConvertToVector256Int32(vector.GetLower());
-            Vector256<int> upper = Avx.ConvertToVector256Int32(vector.GetUpper());
-            return Vector512.Create(lower, upper);
-        }
+    /// <summary>
+    /// Rounds all values in <paramref name="vector"/> to the nearest integer
+    /// following <see cref="MidpointRounding.ToEven"/> semantics.
+    /// </summary>
+    /// <param name="vector">The vector</param>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static Vector512<float> RoundToNearestInteger(Vector512<float> vector)
 
-        Vector512<float> sign = vector & Vector512.Create(-0.0f);
-        Vector512<float> val_2p23_f32 = sign | Vector512.Create(8388608.0f);
+          // imm8 = 0b1000:
+          //   imm8[7:4] = 0b0000 -> preserve 0 fractional bits (round to whole numbers)
+          //   imm8[3:0] = 0b1000 -> _MM_FROUND_TO_NEAREST_INT | _MM_FROUND_NO_EXC (round to nearest even, suppress exceptions)
+          => Avx512F.RoundScale(vector, 0b0000_1000);
 
-        val_2p23_f32 = (vector + val_2p23_f32) - val_2p23_f32;
-        return Vector512.ConvertToInt32(val_2p23_f32 | sign);
-    }
+    /// <summary>
+    /// Performs a multiplication and an addition of the <see cref="Vector512{Single}"/>.
+    /// </summary>
+    /// <remarks>ret = (vm0 * vm1) + va</remarks>
+    /// <param name="va">The vector to add to the intermediate result.</param>
+    /// <param name="vm0">The first vector to multiply.</param>
+    /// <param name="vm1">The second vector to multiply.</param>
+    /// <returns>The <see cref="Vector256{T}"/>.</returns>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static Vector512<float> MultiplyAdd(
+        Vector512<float> va,
+        Vector512<float> vm0,
+        Vector512<float> vm1)
+        => Avx512F.FusedMultiplyAdd(vm0, vm1, va);
 
-    [DoesNotReturn]
-    private static void ThrowUnreachableException() => throw new UnreachableException();
+    /// <summary>
+    /// Restricts a vector between a minimum and a maximum value.
+    /// </summary>
+    /// <typeparam name="T">The type of the elements in the vector.</typeparam>
+    /// <param name="value">The vector to restrict.</param>
+    /// <param name="min">The minimum value.</param>
+    /// <param name="max">The maximum value.</param>
+    /// <returns>The restricted <see cref="Vector512{T}"/>.</returns>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static Vector512<T> Clamp<T>(Vector512<T> value, Vector512<T> min, Vector512<T> max)
+        => Vector512.Min(Vector512.Max(value, min), max);
 }
diff --git a/src/ImageSharp/Common/InlineArray.cs b/src/ImageSharp/Common/InlineArray.cs
new file mode 100644
index 0000000000..778981fd96
--- /dev/null
+++ b/src/ImageSharp/Common/InlineArray.cs
@@ -0,0 +1,38 @@
+// Copyright (c) Six Labors.
+// Licensed under the Six Labors Split License.
+
+// <auto-generated />
+
+using System;
+using System.Runtime.CompilerServices;
+
+namespace SixLabors.ImageSharp;
+
+/// <summary>
+/// Represents a safe, fixed sized buffer of 4 elements.
+/// </summary>
+[InlineArray(4)]
+internal struct InlineArray4<T>
+{
+    private T t;
+}
+
+/// <summary>
+/// Represents a safe, fixed sized buffer of 8 elements.
+/// </summary>
+[InlineArray(8)]
+internal struct InlineArray8<T>
+{
+    private T t;
+}
+
+/// <summary>
+/// Represents a safe, fixed sized buffer of 16 elements.
+/// </summary>
+[InlineArray(16)]
+internal struct InlineArray16<T>
+{
+    private T t;
+}
+
+
diff --git a/src/ImageSharp/Common/InlineArray.tt b/src/ImageSharp/Common/InlineArray.tt
new file mode 100644
index 0000000000..6dc17b9a9c
--- /dev/null
+++ b/src/ImageSharp/Common/InlineArray.tt
@@ -0,0 +1,38 @@
+<#@ template debug="false" hostspecific="false" language="C#" #>
+<#@ assembly name="System.Core" #>
+<#@ import namespace="System.Linq" #>
+<#@ import namespace="System.Text" #>
+<#@ import namespace="System.Collections.Generic" #>
+// Copyright (c) Six Labors.
+// Licensed under the Six Labors Split License.
+
+// <auto-generated />
+
+using System;
+using System.Runtime.CompilerServices;
+
+namespace SixLabors.ImageSharp;
+
+<#GenerateInlineArrays();#>
+
+<#+
+private static int[] Lengths = [4, 8, 16 ];
+
+void GenerateInlineArrays()
+{
+    foreach (int length in Lengths)
+    {
+#>
+/// <summary>
+/// Represents a safe, fixed sized buffer of <#=length#> elements.
+/// </summary>
+[InlineArray(<#=length#>)]
+internal struct InlineArray<#=length#><T>
+{
+    private T t;
+}
+
+<#+
+    }
+}
+#>
diff --git a/src/ImageSharp/Compression/Zlib/Adler32.cs b/src/ImageSharp/Compression/Zlib/Adler32.cs
index dd8217541a..6f21850818 100644
--- a/src/ImageSharp/Compression/Zlib/Adler32.cs
+++ b/src/ImageSharp/Compression/Zlib/Adler32.cs
@@ -32,11 +32,11 @@ internal static class Adler32
     private const int BlockSize = 1 << 5;
 
     // The C# compiler emits this as a compile-time constant embedded in the PE file.
-    private static ReadOnlySpan<byte> Tap1Tap2 => new byte[]
-    {
+    private static ReadOnlySpan<byte> Tap1Tap2 =>
+    [
         32, 31, 30, 29, 28, 27, 26, 25, 24, 23, 22, 21, 20, 19, 18, 17, // tap1
         16, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1 // tap2
-    };
+    ];
 
     /// <summary>
     /// Calculates the Adler32 checksum with the bytes taken from the span.
diff --git a/src/ImageSharp/Compression/Zlib/DeflaterConstants.cs b/src/ImageSharp/Compression/Zlib/DeflaterConstants.cs
index b623149470..fbc2083b39 100644
--- a/src/ImageSharp/Compression/Zlib/DeflaterConstants.cs
+++ b/src/ImageSharp/Compression/Zlib/DeflaterConstants.cs
@@ -124,25 +124,25 @@ internal static class DeflaterConstants
     /// <summary>
     /// Internal compression engine constant
     /// </summary>
-    public static int[] GOOD_LENGTH = { 0, 4, 4, 4, 4, 8, 8, 8, 32, 32 };
+    public static int[] GOOD_LENGTH = [0, 4, 4, 4, 4, 8, 8, 8, 32, 32];
 
     /// <summary>
     /// Internal compression engine constant
     /// </summary>
-    public static int[] MAX_LAZY = { 0, 4, 5, 6, 4, 16, 16, 32, 128, 258 };
+    public static int[] MAX_LAZY = [0, 4, 5, 6, 4, 16, 16, 32, 128, 258];
 
     /// <summary>
     /// Internal compression engine constant
     /// </summary>
-    public static int[] NICE_LENGTH = { 0, 8, 16, 32, 16, 32, 128, 128, 258, 258 };
+    public static int[] NICE_LENGTH = [0, 8, 16, 32, 16, 32, 128, 128, 258, 258];
 
     /// <summary>
     /// Internal compression engine constant
     /// </summary>
-    public static int[] MAX_CHAIN = { 0, 4, 8, 32, 16, 32, 128, 256, 1024, 4096 };
+    public static int[] MAX_CHAIN = [0, 4, 8, 32, 16, 32, 128, 256, 1024, 4096];
 
     /// <summary>
     /// Internal compression engine constant
     /// </summary>
-    public static int[] COMPR_FUNC = { 0, 1, 1, 1, 1, 2, 2, 2, 2, 2 };
+    public static int[] COMPR_FUNC = [0, 1, 1, 1, 1, 2, 2, 2, 2, 2];
 }
diff --git a/src/ImageSharp/Compression/Zlib/DeflaterHuffman.cs b/src/ImageSharp/Compression/Zlib/DeflaterHuffman.cs
index e4dc1945a8..17cb1925df 100644
--- a/src/ImageSharp/Compression/Zlib/DeflaterHuffman.cs
+++ b/src/ImageSharp/Compression/Zlib/DeflaterHuffman.cs
@@ -77,8 +77,8 @@ internal sealed unsafe class DeflaterHuffman : IDisposable
 
     // See RFC 1951 3.2.6
     // Literal codes
-    private static readonly short[] StaticLCodes = new short[]
-    {
+    private static readonly short[] StaticLCodes =
+    [
         12, 140, 76, 204, 44, 172, 108, 236, 28, 156, 92, 220, 60, 188, 124, 252,
         2, 130, 66, 194, 34, 162, 98, 226, 18, 146, 82, 210, 50, 178, 114, 242,
         10, 138, 74, 202, 42, 170, 106, 234, 26, 154, 90, 218, 58, 186, 122, 250,
@@ -97,10 +97,10 @@ internal sealed unsafe class DeflaterHuffman : IDisposable
         31, 287, 159, 415, 95, 351, 223, 479, 63, 319, 191, 447, 127, 383, 255, 511,
         0, 64, 32, 96, 16, 80, 48, 112, 8, 72, 40, 104, 24, 88, 56, 120, 4, 68, 36,
         100, 20, 84, 52, 116, 3, 131, 67, 195, 35, 163
-    };
+    ];
 
-    private static ReadOnlySpan<byte> StaticLLength => new byte[]
-    {
+    private static ReadOnlySpan<byte> StaticLLength =>
+    [
         8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8,
         8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8,
         8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8,
@@ -119,34 +119,34 @@ internal sealed unsafe class DeflaterHuffman : IDisposable
         9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9,
         7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7,
         7, 7, 7, 7, 7, 7, 7, 7, 8, 8, 8, 8, 8, 8
-    };
+    ];
 
     // Distance codes and lengths.
-    private static readonly short[] StaticDCodes = new short[]
-    {
+    private static readonly short[] StaticDCodes =
+    [
         0, 16, 8, 24, 4, 20, 12, 28, 2, 18, 10, 26, 6, 22, 14,
         30, 1, 17, 9, 25, 5, 21, 13, 29, 3, 19, 11, 27, 7, 23
-    };
+    ];
 
-    private static ReadOnlySpan<byte> StaticDLength => new byte[]
-    {
+    private static ReadOnlySpan<byte> StaticDLength =>
+    [
         5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5,
         5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5
-    };
+    ];
 #pragma warning restore SA1201 // Elements should appear in the correct order
 
     /// <summary>
     /// Gets the lengths of the bit length codes are sent in order of decreasing probability, to avoid transmitting the lengths for unused bit length codes.
     /// </summary>
-    private static ReadOnlySpan<byte> BitLengthOrder => new byte[]
-    {
+    private static ReadOnlySpan<byte> BitLengthOrder =>
+    [
         16, 17, 18, 0, 8, 7, 9, 6, 10, 5, 11, 4, 12, 3, 13, 2, 14, 1, 15
-    };
+    ];
 
-    private static ReadOnlySpan<byte> Bit4Reverse => new byte[]
-    {
+    private static ReadOnlySpan<byte> Bit4Reverse =>
+    [
         0, 8, 4, 12, 2, 10, 6, 14, 1, 9, 5, 13, 3, 11, 7, 15
-    };
+    ];
 
     /// <summary>
     /// Gets the pending buffer to use.
diff --git a/src/ImageSharp/Configuration.cs b/src/ImageSharp/Configuration.cs
index 228e42bfe4..7d801f1456 100644
--- a/src/ImageSharp/Configuration.cs
+++ b/src/ImageSharp/Configuration.cs
@@ -123,7 +123,7 @@ public sealed class Configuration
     /// <summary>
     /// Gets or the <see cref="ImageFormatManager"/> that is currently in use.
     /// </summary>
-    public ImageFormatManager ImageFormatsManager { get; private set; } = new ImageFormatManager();
+    public ImageFormatManager ImageFormatsManager { get; private set; } = new();
 
     /// <summary>
     /// Gets or sets the <see cref="Memory.MemoryAllocator"/> that is currently in use.
diff --git a/src/ImageSharp/Formats/AlphaAwareImageEncoder.cs b/src/ImageSharp/Formats/AlphaAwareImageEncoder.cs
index f753e7282b..1c1a8b2910 100644
--- a/src/ImageSharp/Formats/AlphaAwareImageEncoder.cs
+++ b/src/ImageSharp/Formats/AlphaAwareImageEncoder.cs
@@ -1,6 +1,8 @@
 // Copyright (c) Six Labors.
 // Licensed under the Six Labors Split License.
 
+using SixLabors.ImageSharp.Processing.Processors.Quantization;
+
 namespace SixLabors.ImageSharp.Formats;
 
 /// <summary>
@@ -10,6 +12,8 @@ public abstract class AlphaAwareImageEncoder : ImageEncoder
 {
     /// <summary>
     /// Gets or initializes the mode that determines how transparent pixels are handled during encoding.
+    /// This overrides any other settings that may affect the encoding of transparent pixels
+    /// including those passed via <see cref="QuantizerOptions"/>.
     /// </summary>
     public TransparentColorMode TransparentColorMode { get; init; }
 }
diff --git a/src/ImageSharp/Formats/Bmp/BmpConstants.cs b/src/ImageSharp/Formats/Bmp/BmpConstants.cs
index 62edfdfdfa..1ac79a9e26 100644
--- a/src/ImageSharp/Formats/Bmp/BmpConstants.cs
+++ b/src/ImageSharp/Formats/Bmp/BmpConstants.cs
@@ -11,17 +11,17 @@ internal static class BmpConstants
     /// <summary>
     /// The list of mimetypes that equate to a bmp.
     /// </summary>
-    public static readonly IEnumerable<string> MimeTypes = new[]
-    {
+    public static readonly IEnumerable<string> MimeTypes =
+    [
         "image/bmp",
         "image/x-windows-bmp",
         "image/x-win-bitmap"
-    };
+    ];
 
     /// <summary>
     /// The list of file extensions that equate to a bmp.
     /// </summary>
-    public static readonly IEnumerable<string> FileExtensions = new[] { "bm", "bmp", "dip" };
+    public static readonly IEnumerable<string> FileExtensions = ["bm", "bmp", "dip"];
 
     /// <summary>
     /// Valid magic bytes markers identifying a Bitmap file.
diff --git a/src/ImageSharp/Formats/Bmp/BmpDecoder.cs b/src/ImageSharp/Formats/Bmp/BmpDecoder.cs
index da6556b367..d98f7bccb5 100644
--- a/src/ImageSharp/Formats/Bmp/BmpDecoder.cs
+++ b/src/ImageSharp/Formats/Bmp/BmpDecoder.cs
@@ -25,7 +25,7 @@ public sealed class BmpDecoder : SpecializedImageDecoder<BmpDecoderOptions>
         Guard.NotNull(options, nameof(options));
         Guard.NotNull(stream, nameof(stream));
 
-        return new BmpDecoderCore(new() { GeneralOptions = options }).Identify(options.Configuration, stream, cancellationToken);
+        return new BmpDecoderCore(new BmpDecoderOptions { GeneralOptions = options }).Identify(options.Configuration, stream, cancellationToken);
     }
 
     /// <inheritdoc/>
diff --git a/src/ImageSharp/Formats/Bmp/BmpDecoderCore.cs b/src/ImageSharp/Formats/Bmp/BmpDecoderCore.cs
index 94257517d2..17c1f545b7 100644
--- a/src/ImageSharp/Formats/Bmp/BmpDecoderCore.cs
+++ b/src/ImageSharp/Formats/Bmp/BmpDecoderCore.cs
@@ -220,7 +220,7 @@ internal sealed class BmpDecoderCore : ImageDecoderCore
     protected override ImageInfo Identify(BufferedReadStream stream, CancellationToken cancellationToken)
     {
         this.ReadImageHeaders(stream, out _, out _);
-        return new ImageInfo(new(this.infoHeader.Width, this.infoHeader.Height), this.metadata);
+        return new ImageInfo(new Size(this.infoHeader.Width, this.infoHeader.Height), this.metadata);
     }
 
     /// <summary>
@@ -1270,7 +1270,7 @@ internal sealed class BmpDecoderCore : ImageDecoderCore
                     byte g = (byte)((temp & greenMask) >> rightShiftGreenMask);
                     byte b = (byte)((temp & blueMask) >> rightShiftBlueMask);
                     byte a = alphaMask != 0 ? (byte)((temp & alphaMask) >> rightShiftAlphaMask) : byte.MaxValue;
-                    pixelRow[x] = TPixel.FromRgba32(new(r, g, b, a));
+                    pixelRow[x] = TPixel.FromRgba32(new Rgba32(r, g, b, a));
                 }
 
                 offset += 4;
@@ -1457,7 +1457,7 @@ internal sealed class BmpDecoderCore : ImageDecoderCore
         this.bmpMetadata.InfoHeaderType = infoHeaderType;
         this.bmpMetadata.BitsPerPixel = (BmpBitsPerPixel)bitsPerPixel;
 
-        this.Dimensions = new(this.infoHeader.Width, this.infoHeader.Height);
+        this.Dimensions = new Size(this.infoHeader.Width, this.infoHeader.Height);
     }
 
     /// <summary>
@@ -1597,8 +1597,8 @@ internal sealed class BmpDecoderCore : ImageDecoderCore
 
         if (palette.Length > 0)
         {
-            Color[] colorTable = new Color[palette.Length / Unsafe.SizeOf<Bgr24>()];
-            ReadOnlySpan<Bgr24> rgbTable = MemoryMarshal.Cast<byte, Bgr24>(palette);
+            Color[] colorTable = new Color[palette.Length / Unsafe.SizeOf<Bgra32>()];
+            ReadOnlySpan<Bgra32> rgbTable = MemoryMarshal.Cast<byte, Bgra32>(palette);
             Color.FromPixel(rgbTable, colorTable);
             this.bmpMetadata.ColorTable = colorTable;
         }
diff --git a/src/ImageSharp/Formats/Bmp/BmpEncoderCore.cs b/src/ImageSharp/Formats/Bmp/BmpEncoderCore.cs
index 321a559b1e..ccc620d6c4 100644
--- a/src/ImageSharp/Formats/Bmp/BmpEncoderCore.cs
+++ b/src/ImageSharp/Formats/Bmp/BmpEncoderCore.cs
@@ -362,10 +362,13 @@ internal sealed class BmpEncoderCore
         ImageFrame<TPixel>? clonedFrame = null;
         try
         {
-            if (EncodingUtilities.ShouldClearTransparentPixels<TPixel>(this.transparentColorMode))
+            // No need to clone when quantizing. The quantizer will do it for us.
+            // TODO: We should really try to avoid the clone entirely.
+            int bpp = this.bitsPerPixel != null ? (int)this.bitsPerPixel : 32;
+            if (bpp > 8 && EncodingUtilities.ShouldReplaceTransparentPixels<TPixel>(this.transparentColorMode))
             {
                 clonedFrame = image.Frames.RootFrame.Clone();
-                EncodingUtilities.ClearTransparentPixels(clonedFrame, Color.Transparent);
+                EncodingUtilities.ReplaceTransparentPixels(clonedFrame);
             }
 
             ImageFrame<TPixel> encodingFrame = clonedFrame ?? image.Frames.RootFrame;
@@ -652,7 +655,7 @@ internal sealed class BmpEncoderCore
         CancellationToken cancellationToken)
         where TPixel : unmanaged, IPixel<TPixel>
     {
-        using IQuantizer<TPixel> frameQuantizer = this.quantizer.CreatePixelSpecificQuantizer<TPixel>(configuration, new QuantizerOptions()
+        using IQuantizer<TPixel> frameQuantizer = this.quantizer.CreatePixelSpecificQuantizer<TPixel>(configuration, new QuantizerOptions
         {
             MaxColors = 16,
             Dither = this.quantizer.Options.Dither,
@@ -709,7 +712,7 @@ internal sealed class BmpEncoderCore
         CancellationToken cancellationToken)
         where TPixel : unmanaged, IPixel<TPixel>
     {
-        using IQuantizer<TPixel> frameQuantizer = this.quantizer.CreatePixelSpecificQuantizer<TPixel>(configuration, new QuantizerOptions()
+        using IQuantizer<TPixel> frameQuantizer = this.quantizer.CreatePixelSpecificQuantizer<TPixel>(configuration, new QuantizerOptions
         {
             MaxColors = 4,
             Dither = this.quantizer.Options.Dither,
@@ -775,7 +778,7 @@ internal sealed class BmpEncoderCore
         CancellationToken cancellationToken)
         where TPixel : unmanaged, IPixel<TPixel>
     {
-        using IQuantizer<TPixel> frameQuantizer = this.quantizer.CreatePixelSpecificQuantizer<TPixel>(configuration, new QuantizerOptions()
+        using IQuantizer<TPixel> frameQuantizer = this.quantizer.CreatePixelSpecificQuantizer<TPixel>(configuration, new QuantizerOptions
         {
             MaxColors = 2,
             Dither = this.quantizer.Options.Dither,
diff --git a/src/ImageSharp/Formats/Bmp/BmpFormat.cs b/src/ImageSharp/Formats/Bmp/BmpFormat.cs
index a67b06cb88..5dec4a6748 100644
--- a/src/ImageSharp/Formats/Bmp/BmpFormat.cs
+++ b/src/ImageSharp/Formats/Bmp/BmpFormat.cs
@@ -15,7 +15,7 @@ public sealed class BmpFormat : IImageFormat<BmpMetadata>
     /// <summary>
     /// Gets the shared instance.
     /// </summary>
-    public static BmpFormat Instance { get; } = new BmpFormat();
+    public static BmpFormat Instance { get; } = new();
 
     /// <inheritdoc/>
     public string Name => "BMP";
diff --git a/src/ImageSharp/Formats/Bmp/BmpMetadata.cs b/src/ImageSharp/Formats/Bmp/BmpMetadata.cs
index d0c60421c4..3572687c99 100644
--- a/src/ImageSharp/Formats/Bmp/BmpMetadata.cs
+++ b/src/ImageSharp/Formats/Bmp/BmpMetadata.cs
@@ -1,6 +1,7 @@
 // Copyright (c) Six Labors.
 // Licensed under the Six Labors Split License.
 
+using System.Numerics;
 using SixLabors.ImageSharp.PixelFormats;
 
 // TODO: Add color table information.
@@ -156,8 +157,7 @@ public class BmpMetadata : IFormatMetadata<BmpMetadata>
     public BmpMetadata DeepClone() => new(this);
 
     /// <inheritdoc/>
-    public void AfterImageApply<TPixel>(Image<TPixel> destination)
+    public void AfterImageApply<TPixel>(Image<TPixel> destination, Matrix4x4 matrix)
         where TPixel : unmanaged, IPixel<TPixel>
-    {
-    }
+        => this.ColorTable = null;
 }
diff --git a/src/ImageSharp/Formats/ColorProfileHandling.cs b/src/ImageSharp/Formats/ColorProfileHandling.cs
new file mode 100644
index 0000000000..661e6c4bc3
--- /dev/null
+++ b/src/ImageSharp/Formats/ColorProfileHandling.cs
@@ -0,0 +1,26 @@
+// Copyright (c) Six Labors.
+// Licensed under the Six Labors Split License.
+
+namespace SixLabors.ImageSharp.Formats;
+
+/// <summary>
+/// Provides enumeration of methods that control how ICC profiles are handled during decode.
+/// </summary>
+public enum ColorProfileHandling
+{
+    /// <summary>
+    /// Leaves any embedded ICC color profiles intact.
+    /// </summary>
+    Preserve,
+
+    /// <summary>
+    /// Removes any embedded Standard sRGB ICC color profiles without transforming the pixels of the image.
+    /// </summary>
+    Compact,
+
+    /// <summary>
+    /// Transforms the pixels of the image based on the conversion of any embedded ICC color profiles to sRGB V4 profile.
+    /// The original profile is then removed.
+    /// </summary>
+    Convert
+}
diff --git a/src/ImageSharp/Formats/Cur/CurFrameMetadata.cs b/src/ImageSharp/Formats/Cur/CurFrameMetadata.cs
index 01b7fbce08..dbe8183b6d 100644
--- a/src/ImageSharp/Formats/Cur/CurFrameMetadata.cs
+++ b/src/ImageSharp/Formats/Cur/CurFrameMetadata.cs
@@ -1,6 +1,7 @@
 // Copyright (c) Six Labors.
 // Licensed under the Six Labors Split License.
 
+using System.Numerics;
 using SixLabors.ImageSharp.Formats.Bmp;
 using SixLabors.ImageSharp.Formats.Icon;
 using SixLabors.ImageSharp.PixelFormats;
@@ -104,7 +105,6 @@ public class CurFrameMetadata : IFormatFrameMetadata<CurFrameMetadata>
             Compression = compression,
             EncodingWidth = ClampEncodingDimension(metadata.EncodingWidth),
             EncodingHeight = ClampEncodingDimension(metadata.EncodingHeight),
-            ColorTable = compression == IconFrameCompression.Bmp ? metadata.ColorTable : null
         };
     }
 
@@ -113,19 +113,19 @@ public class CurFrameMetadata : IFormatFrameMetadata<CurFrameMetadata>
         => new()
         {
             PixelTypeInfo = this.GetPixelTypeInfo(),
-            ColorTable = this.ColorTable,
             EncodingWidth = this.EncodingWidth,
             EncodingHeight = this.EncodingHeight
         };
 
     /// <inheritdoc/>
-    public void AfterFrameApply<TPixel>(ImageFrame<TPixel> source, ImageFrame<TPixel> destination)
+    public void AfterFrameApply<TPixel>(ImageFrame<TPixel> source, ImageFrame<TPixel> destination, Matrix4x4 matrix)
         where TPixel : unmanaged, IPixel<TPixel>
     {
         float ratioX = destination.Width / (float)source.Width;
         float ratioY = destination.Height / (float)source.Height;
         this.EncodingWidth = ScaleEncodingDimension(this.EncodingWidth, destination.Width, ratioX);
         this.EncodingHeight = ScaleEncodingDimension(this.EncodingHeight, destination.Height, ratioY);
+        this.ColorTable = null;
     }
 
     /// <inheritdoc/>
@@ -148,7 +148,7 @@ public class CurFrameMetadata : IFormatFrameMetadata<CurFrameMetadata>
             ? (byte)0
             : (byte)ColorNumerics.GetColorCountForBitDepth((int)this.BmpBitsPerPixel);
 
-        return new()
+        return new IconDirEntry
         {
             Width = ClampEncodingDimension(this.EncodingWidth ?? size.Width),
             Height = ClampEncodingDimension(this.EncodingHeight ?? size.Height),
diff --git a/src/ImageSharp/Formats/Cur/CurMetadata.cs b/src/ImageSharp/Formats/Cur/CurMetadata.cs
index 19de7f434d..4c4d83dd88 100644
--- a/src/ImageSharp/Formats/Cur/CurMetadata.cs
+++ b/src/ImageSharp/Formats/Cur/CurMetadata.cs
@@ -1,6 +1,7 @@
 // Copyright (c) Six Labors.
 // Licensed under the Six Labors Split License.
 
+using System.Numerics;
 using SixLabors.ImageSharp.Formats.Bmp;
 using SixLabors.ImageSharp.Formats.Icon;
 using SixLabors.ImageSharp.PixelFormats;
@@ -71,8 +72,7 @@ public class CurMetadata : IFormatMetadata<CurMetadata>
         return new CurMetadata
         {
             BmpBitsPerPixel = bbpp,
-            Compression = compression,
-            ColorTable = compression == IconFrameCompression.Bmp ? metadata.ColorTable : null
+            Compression = compression
         };
     }
 
@@ -145,15 +145,13 @@ public class CurMetadata : IFormatMetadata<CurMetadata>
             EncodingType = this.Compression == IconFrameCompression.Bmp && this.BmpBitsPerPixel <= BmpBitsPerPixel.Bit8
                 ? EncodingType.Lossy
                 : EncodingType.Lossless,
-            PixelTypeInfo = this.GetPixelTypeInfo(),
-            ColorTable = this.ColorTable
+            PixelTypeInfo = this.GetPixelTypeInfo()
         };
 
     /// <inheritdoc/>
-    public void AfterImageApply<TPixel>(Image<TPixel> destination)
+    public void AfterImageApply<TPixel>(Image<TPixel> destination, Matrix4x4 matrix)
         where TPixel : unmanaged, IPixel<TPixel>
-    {
-    }
+        => this.ColorTable = null;
 
     /// <inheritdoc/>
     IDeepCloneable IDeepCloneable.DeepClone() => this.DeepClone();
diff --git a/src/ImageSharp/Formats/DecoderOptions.cs b/src/ImageSharp/Formats/DecoderOptions.cs
index 3b16159b7e..2511cffdbb 100644
--- a/src/ImageSharp/Formats/DecoderOptions.cs
+++ b/src/ImageSharp/Formats/DecoderOptions.cs
@@ -1,6 +1,8 @@
 // Copyright (c) Six Labors.
 // Licensed under the Six Labors Split License.
 
+using System.Diagnostics.CodeAnalysis;
+using SixLabors.ImageSharp.Metadata.Profiles.Icc;
 using SixLabors.ImageSharp.Processing;
 using SixLabors.ImageSharp.Processing.Processors.Transforms;
 
@@ -11,7 +13,7 @@ namespace SixLabors.ImageSharp.Formats;
 /// </summary>
 public sealed class DecoderOptions
 {
-    private static readonly Lazy<DecoderOptions> LazyOptions = new(() => new());
+    private static readonly Lazy<DecoderOptions> LazyOptions = new(() => new DecoderOptions());
 
     private uint maxFrames = int.MaxValue;
 
@@ -60,5 +62,48 @@ public sealed class DecoderOptions
     /// </summary>
     public SegmentIntegrityHandling SegmentIntegrityHandling { get; init; } = SegmentIntegrityHandling.IgnoreNonCritical;
 
+    /// <summary>
+    /// Gets a value that controls how ICC profiles are handled during decode.
+    /// </summary>
+    public ColorProfileHandling ColorProfileHandling { get; init; }
+
     internal void SetConfiguration(Configuration configuration) => this.configuration = configuration;
+
+    internal bool TryGetIccProfileForColorConversion(IccProfile? profile, [NotNullWhen(true)] out IccProfile? value)
+    {
+        value = null;
+
+        if (profile is null)
+        {
+            return false;
+        }
+
+        if (IccProfileHeader.IsLikelySrgb(profile.Header))
+        {
+            return false;
+        }
+
+        if (this.ColorProfileHandling == ColorProfileHandling.Preserve)
+        {
+            return false;
+        }
+
+        value = profile;
+        return true;
+    }
+
+    internal bool CanRemoveIccProfile(IccProfile? profile)
+    {
+        if (profile is null)
+        {
+            return false;
+        }
+
+        if (this.ColorProfileHandling == ColorProfileHandling.Compact && IccProfileHeader.IsLikelySrgb(profile.Header))
+        {
+            return true;
+        }
+
+        return this.ColorProfileHandling == ColorProfileHandling.Convert;
+    }
 }
diff --git a/src/ImageSharp/Formats/EncodingUtilities.cs b/src/ImageSharp/Formats/EncodingUtilities.cs
index a979fdf6fa..3994743933 100644
--- a/src/ImageSharp/Formats/EncodingUtilities.cs
+++ b/src/ImageSharp/Formats/EncodingUtilities.cs
@@ -3,6 +3,8 @@
 
 using System.Buffers;
 using System.Numerics;
+using System.Runtime.CompilerServices;
+using System.Runtime.InteropServices;
 using System.Runtime.Intrinsics;
 using SixLabors.ImageSharp.Memory;
 using SixLabors.ImageSharp.PixelFormats;
@@ -14,62 +16,132 @@ namespace SixLabors.ImageSharp.Formats;
 /// </summary>
 internal static class EncodingUtilities
 {
-    public static bool ShouldClearTransparentPixels<TPixel>(TransparentColorMode mode)
+    /// <summary>
+    /// Determines if transparent pixels can be replaced based on the specified color mode and pixel type.
+    /// </summary>
+    /// <typeparam name="TPixel">The type of the pixel.</typeparam>
+    /// <param name="mode">Indicates the color mode used to assess the ability to replace transparent pixels.</param>
+    /// <returns>Returns true if transparent pixels can be replaced; otherwise, false.</returns>
+    public static bool ShouldReplaceTransparentPixels<TPixel>(TransparentColorMode mode)
+        where TPixel : unmanaged, IPixel<TPixel>
+        => mode == TransparentColorMode.Clear && TPixel.GetPixelTypeInfo().AlphaRepresentation == PixelAlphaRepresentation.Unassociated;
+
+    /// <summary>
+    /// Replaces pixels with a transparent alpha component with fully transparent pixels.
+    /// </summary>
+    /// <typeparam name="TPixel">The type of the pixel.</typeparam>
+    /// <param name="frame">The <see cref="ImageFrame{TPixel}"/> where the transparent pixels will be changed.</param>
+    public static void ReplaceTransparentPixels<TPixel>(ImageFrame<TPixel> frame)
         where TPixel : unmanaged, IPixel<TPixel>
-        => mode == TransparentColorMode.Clear &&
-                   TPixel.GetPixelTypeInfo().AlphaRepresentation == PixelAlphaRepresentation.Unassociated;
+        => ReplaceTransparentPixels(frame.Configuration, frame.PixelBuffer);
 
     /// <summary>
-    /// Convert transparent pixels, to pixels represented by <paramref name="color"/>, which can yield
-    /// to better compression in some cases.
+    /// Replaces pixels with a transparent alpha component with fully transparent pixels.
     /// </summary>
     /// <typeparam name="TPixel">The type of the pixel.</typeparam>
-    /// <param name="clone">The cloned <see cref="ImageFrame{TPixel}"/> where the transparent pixels will be changed.</param>
-    /// <param name="color">The color to replace transparent pixels with.</param>
-    public static void ClearTransparentPixels<TPixel>(ImageFrame<TPixel> clone, Color color)
+    /// <param name="configuration">The configuration.</param>
+    /// <param name="buffer">The  <see cref="Buffer2D{TPixel}"/> where the transparent pixels will be changed.</param>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static void ReplaceTransparentPixels<TPixel>(Configuration configuration, Buffer2D<TPixel> buffer)
         where TPixel : unmanaged, IPixel<TPixel>
     {
-        Buffer2DRegion<TPixel> buffer = clone.PixelBuffer.GetRegion();
-        ClearTransparentPixels(clone.Configuration, ref buffer, color);
+        Buffer2DRegion<TPixel> region = buffer.GetRegion();
+        ReplaceTransparentPixels(configuration, in region);
     }
 
     /// <summary>
-    /// Convert transparent pixels, to pixels represented by <paramref name="color"/>, which can yield
-    /// to better compression in some cases.
+    /// Replaces pixels with a transparent alpha component with fully transparent pixels.
     /// </summary>
     /// <typeparam name="TPixel">The type of the pixel.</typeparam>
     /// <param name="configuration">The configuration.</param>
-    /// <param name="clone">The cloned <see cref="Buffer2DRegion{T}"/> where the transparent pixels will be changed.</param>
-    /// <param name="color">The color to replace transparent pixels with.</param>
-    public static void ClearTransparentPixels<TPixel>(
+    /// <param name="region">The <see cref="Buffer2DRegion{T}"/> where the transparent pixels will be changed.</param>
+    public static void ReplaceTransparentPixels<TPixel>(
         Configuration configuration,
-        ref Buffer2DRegion<TPixel> clone,
-        Color color)
+        in Buffer2DRegion<TPixel> region)
         where TPixel : unmanaged, IPixel<TPixel>
     {
-        using IMemoryOwner<Vector4> vectors = configuration.MemoryAllocator.Allocate<Vector4>(clone.Width);
+        using IMemoryOwner<Vector4> vectors = configuration.MemoryAllocator.Allocate<Vector4>(region.Width);
         Span<Vector4> vectorsSpan = vectors.GetSpan();
-        Vector4 replacement = color.ToScaledVector4();
-        for (int y = 0; y < clone.Height; y++)
+        for (int y = 0; y < region.Height; y++)
         {
-            Span<TPixel> span = clone.DangerousGetRowSpan(y);
+            Span<TPixel> span = region.DangerousGetRowSpan(y);
             PixelOperations<TPixel>.Instance.ToVector4(configuration, span, vectorsSpan, PixelConversionModifiers.Scale);
-            ClearTransparentPixelRow(vectorsSpan, replacement);
+            ReplaceTransparentPixels(vectorsSpan);
             PixelOperations<TPixel>.Instance.FromVector4Destructive(configuration, vectorsSpan, span, PixelConversionModifiers.Scale);
         }
     }
 
-    private static void ClearTransparentPixelRow(
-        Span<Vector4> vectorsSpan,
-        Vector4 replacement)
+    /// <summary>
+    /// Replaces pixels with a transparent alpha component with fully transparent pixels.
+    /// </summary>
+    /// <param name="source">A span of color vectors that will be checked for transparency and potentially modified.</param>
+    public static void ReplaceTransparentPixels(Span<Vector4> source)
     {
-        if (Vector128.IsHardwareAccelerated)
+        if (Vector512.IsHardwareAccelerated && source.Length >= 4)
+        {
+            Span<Vector512<float>> source512 = MemoryMarshal.Cast<Vector4, Vector512<float>>(source);
+            for (int i = 0; i < source512.Length; i++)
+            {
+                ref Vector512<float> v = ref source512[i];
+
+                // Do `vector < threshold`
+                Vector512<float> mask = Vector512.Equals(v, Vector512<float>.Zero);
+
+                // Replicate the result for W to all elements (is AllBitsSet if the W was 0 and Zero otherwise)
+                mask = Vector512.Shuffle(mask, Vector512.Create(3, 3, 3, 3, 7, 7, 7, 7, 11, 11, 11, 11, 15, 15, 15, 15));
+
+                // Use the mask to select the replacement vector
+                // (replacement & mask) | (v512 & ~mask)
+                v = Vector512.ConditionalSelect(mask, Vector512<float>.Zero, v);
+            }
+
+            int m = Numerics.Modulo4(source.Length);
+            if (m != 0)
+            {
+                for (int i = source.Length - m; i < source.Length; i++)
+                {
+                    if (source[i].W == 0)
+                    {
+                        source[i] = Vector4.Zero;
+                    }
+                }
+            }
+        }
+        else if (Vector256.IsHardwareAccelerated && source.Length >= 2)
         {
-            Vector128<float> replacement128 = replacement.AsVector128();
+            Span<Vector256<float>> source256 = MemoryMarshal.Cast<Vector4, Vector256<float>>(source);
+            for (int i = 0; i < source256.Length; i++)
+            {
+                ref Vector256<float> v = ref source256[i];
+
+                // Do `vector < threshold`
+                Vector256<float> mask = Vector256.Equals(v, Vector256<float>.Zero);
+
+                // Replicate the result for W to all elements (is AllBitsSet if the W was 0 and Zero otherwise)
+                mask = Vector256.Shuffle(mask, Vector256.Create(3, 3, 3, 3, 7, 7, 7, 7));
 
-            for (int i = 0; i < vectorsSpan.Length; i++)
+                // Use the mask to select the replacement vector
+                // (replacement & mask) | (v256 & ~mask)
+                v = Vector256.ConditionalSelect(mask, Vector256<float>.Zero, v);
+            }
+
+            int m = Numerics.Modulo2(source.Length);
+            if (m != 0)
+            {
+                for (int i = source.Length - m; i < source.Length; i++)
+                {
+                    if (source[i].W == 0)
+                    {
+                        source[i] = Vector4.Zero;
+                    }
+                }
+            }
+        }
+        else if (Vector128.IsHardwareAccelerated)
+        {
+            for (int i = 0; i < source.Length; i++)
             {
-                ref Vector4 v = ref vectorsSpan[i];
+                ref Vector4 v = ref source[i];
                 Vector128<float> v128 = v.AsVector128();
 
                 // Do `vector == 0`
@@ -80,16 +152,16 @@ internal static class EncodingUtilities
 
                 // Use the mask to select the replacement vector
                 // (replacement & mask) | (v128 & ~mask)
-                v = Vector128.ConditionalSelect(mask, replacement128, v128).AsVector4();
+                v = Vector128.ConditionalSelect(mask, Vector128<float>.Zero, v128).AsVector4();
             }
         }
         else
         {
-            for (int i = 0; i < vectorsSpan.Length; i++)
+            for (int i = 0; i < source.Length; i++)
             {
-                if (vectorsSpan[i].W == 0F)
+                if (source[i].W == 0F)
                 {
-                    vectorsSpan[i] = replacement;
+                    source[i] = Vector4.Zero;
                 }
             }
         }
diff --git a/src/ImageSharp/Formats/FormatConnectingFrameMetadata.cs b/src/ImageSharp/Formats/FormatConnectingFrameMetadata.cs
index ded220c9ad..15a28c301a 100644
--- a/src/ImageSharp/Formats/FormatConnectingFrameMetadata.cs
+++ b/src/ImageSharp/Formats/FormatConnectingFrameMetadata.cs
@@ -15,11 +15,6 @@ public class FormatConnectingFrameMetadata
     /// </summary>
     public PixelTypeInfo? PixelTypeInfo { get; init; }
 
-    /// <summary>
-    /// Gets the frame color table if any.
-    /// </summary>
-    public ReadOnlyMemory<Color>? ColorTable { get; init; }
-
     /// <summary>
     /// Gets the frame color table mode.
     /// </summary>
diff --git a/src/ImageSharp/Formats/FormatConnectingMetadata.cs b/src/ImageSharp/Formats/FormatConnectingMetadata.cs
index 9cfe40f385..efa7acdc86 100644
--- a/src/ImageSharp/Formats/FormatConnectingMetadata.cs
+++ b/src/ImageSharp/Formats/FormatConnectingMetadata.cs
@@ -28,11 +28,6 @@ public class FormatConnectingMetadata
     /// </summary>
     public PixelTypeInfo PixelTypeInfo { get; init; }
 
-    /// <summary>
-    /// Gets the shared color table if any.
-    /// </summary>
-    public ReadOnlyMemory<Color>? ColorTable { get; init; }
-
     /// <summary>
     /// Gets the shared color table mode.
     /// </summary>
diff --git a/src/ImageSharp/Formats/Gif/GifConstants.cs b/src/ImageSharp/Formats/Gif/GifConstants.cs
index 796b5506c7..d2121adce2 100644
--- a/src/ImageSharp/Formats/Gif/GifConstants.cs
+++ b/src/ImageSharp/Formats/Gif/GifConstants.cs
@@ -93,41 +93,41 @@ internal static class GifConstants
     /// <summary>
     /// The collection of mimetypes that equate to a Gif.
     /// </summary>
-    public static readonly IEnumerable<string> MimeTypes = new[] { "image/gif" };
+    public static readonly IEnumerable<string> MimeTypes = ["image/gif"];
 
     /// <summary>
     /// The collection of file extensions that equate to a Gif.
     /// </summary>
-    public static readonly IEnumerable<string> FileExtensions = new[] { "gif" };
+    public static readonly IEnumerable<string> FileExtensions = ["gif"];
 
     /// <summary>
     /// Gets the ASCII encoded bytes used to identify the GIF file (combining <see cref="FileType"/> and <see cref="FileVersion"/>).
     /// </summary>
-    internal static ReadOnlySpan<byte> MagicNumber => new[]
-    {
+    internal static ReadOnlySpan<byte> MagicNumber =>
+    [
         (byte)'G', (byte)'I', (byte)'F',
         (byte)'8', (byte)'9', (byte)'a'
-    };
+    ];
 
     /// <summary>
     /// Gets the ASCII encoded application identification bytes (representing <see cref="NetscapeApplicationIdentification"/>).
     /// </summary>
-    internal static ReadOnlySpan<byte> NetscapeApplicationIdentificationBytes => new[]
-    {
+    internal static ReadOnlySpan<byte> NetscapeApplicationIdentificationBytes =>
+    [
         (byte)'N', (byte)'E', (byte)'T',
         (byte)'S', (byte)'C', (byte)'A',
         (byte)'P', (byte)'E',
         (byte)'2', (byte)'.', (byte)'0'
-    };
+    ];
 
     /// <summary>
     /// Gets the ASCII encoded application identification bytes.
     /// </summary>
-    internal static ReadOnlySpan<byte> XmpApplicationIdentificationBytes => new[]
-    {
+    internal static ReadOnlySpan<byte> XmpApplicationIdentificationBytes =>
+    [
         (byte)'X', (byte)'M', (byte)'P',
         (byte)' ', (byte)'D', (byte)'a',
         (byte)'t', (byte)'a',
         (byte)'X', (byte)'M', (byte)'P'
-    };
+    ];
 }
diff --git a/src/ImageSharp/Formats/Gif/GifDecoderCore.cs b/src/ImageSharp/Formats/Gif/GifDecoderCore.cs
index e18166c4b8..ca28bc7713 100644
--- a/src/ImageSharp/Formats/Gif/GifDecoderCore.cs
+++ b/src/ImageSharp/Formats/Gif/GifDecoderCore.cs
@@ -89,6 +89,11 @@ internal sealed class GifDecoderCore : ImageDecoderCore
     /// </summary>
     private GifMetadata? gifMetadata;
 
+    /// <summary>
+    /// The background color index.
+    /// </summary>
+    private byte backgroundColorIndex;
+
     /// <summary>
     /// Initializes a new instance of the <see cref="GifDecoderCore"/> class.
     /// </summary>
@@ -108,6 +113,10 @@ internal sealed class GifDecoderCore : ImageDecoderCore
         uint frameCount = 0;
         Image<TPixel>? image = null;
         ImageFrame<TPixel>? previousFrame = null;
+        FrameDisposalMode? previousDisposalMode = null;
+        bool globalColorTableUsed = false;
+        Color backgroundColor = Color.Transparent;
+
         try
         {
             this.ReadLogicalScreenDescriptorAndGlobalColorTable(stream);
@@ -123,7 +132,7 @@ internal sealed class GifDecoderCore : ImageDecoderCore
                         break;
                     }
 
-                    this.ReadFrame(stream, ref image, ref previousFrame);
+                    globalColorTableUsed |= this.ReadFrame(stream, ref image, ref previousFrame, ref previousDisposalMode, ref backgroundColor);
 
                     // Reset per-frame state.
                     this.imageDescriptor = default;
@@ -158,6 +167,13 @@ internal sealed class GifDecoderCore : ImageDecoderCore
                     break;
                 }
             }
+
+            // We cannot always trust the global GIF palette has actually been used.
+            // https://github.com/SixLabors/ImageSharp/issues/2866
+            if (!globalColorTableUsed)
+            {
+                this.gifMetadata.ColorTableMode = FrameColorTableMode.Local;
+            }
         }
         finally
         {
@@ -179,6 +195,8 @@ internal sealed class GifDecoderCore : ImageDecoderCore
         uint frameCount = 0;
         ImageFrameMetadata? previousFrame = null;
         List<ImageFrameMetadata> framesMetadata = [];
+        bool globalColorTableUsed = false;
+
         try
         {
             this.ReadLogicalScreenDescriptorAndGlobalColorTable(stream);
@@ -194,7 +212,7 @@ internal sealed class GifDecoderCore : ImageDecoderCore
                         break;
                     }
 
-                    this.ReadFrameMetadata(stream, framesMetadata, ref previousFrame);
+                    globalColorTableUsed |= this.ReadFrameMetadata(stream, framesMetadata, ref previousFrame);
 
                     // Reset per-frame state.
                     this.imageDescriptor = default;
@@ -229,6 +247,13 @@ internal sealed class GifDecoderCore : ImageDecoderCore
                     break;
                 }
             }
+
+            // We cannot always trust the global GIF palette has actually been used.
+            // https://github.com/SixLabors/ImageSharp/issues/2866
+            if (!globalColorTableUsed)
+            {
+                this.gifMetadata.ColorTableMode = FrameColorTableMode.Local;
+            }
         }
         finally
         {
@@ -242,7 +267,7 @@ internal sealed class GifDecoderCore : ImageDecoderCore
         }
 
         return new ImageInfo(
-            new(this.logicalScreenDescriptor.Width, this.logicalScreenDescriptor.Height),
+            new Size(this.logicalScreenDescriptor.Width, this.logicalScreenDescriptor.Height),
             this.metadata,
             framesMetadata);
     }
@@ -280,7 +305,7 @@ internal sealed class GifDecoderCore : ImageDecoderCore
             GifThrowHelper.ThrowInvalidImageContentException("Width or height should not be 0");
         }
 
-        this.Dimensions = new(this.imageDescriptor.Width, this.imageDescriptor.Height);
+        this.Dimensions = new Size(this.imageDescriptor.Width, this.imageDescriptor.Height);
     }
 
     /// <summary>
@@ -389,6 +414,11 @@ internal sealed class GifDecoderCore : ImageDecoderCore
                 GifThrowHelper.ThrowInvalidImageContentException($"Gif comment length '{length}' exceeds max '{GifConstants.MaxCommentSubBlockLength}' of a comment data block");
             }
 
+            if (length == -1)
+            {
+                GifThrowHelper.ThrowInvalidImageContentException("Unexpected end of stream while reading gif comment");
+            }
+
             if (this.skipMetadata)
             {
                 stream.Seek(length, SeekOrigin.Current);
@@ -416,7 +446,15 @@ internal sealed class GifDecoderCore : ImageDecoderCore
     /// <param name="stream">The <see cref="BufferedReadStream"/> containing image data.</param>
     /// <param name="image">The image to decode the information to.</param>
     /// <param name="previousFrame">The previous frame.</param>
-    private void ReadFrame<TPixel>(BufferedReadStream stream, ref Image<TPixel>? image, ref ImageFrame<TPixel>? previousFrame)
+    /// <param name="previousDisposalMode">The previous frame disposal mode.</param>
+    /// <param name="backgroundColor">The background color.</param>
+    /// <returns>Whether the frame has a global color table.</returns>
+    private bool ReadFrame<TPixel>(
+        BufferedReadStream stream,
+        ref Image<TPixel>? image,
+        ref ImageFrame<TPixel>? previousFrame,
+        ref FrameDisposalMode? previousDisposalMode,
+        ref Color backgroundColor)
         where TPixel : unmanaged, IPixel<TPixel>
     {
         this.ReadImageDescriptor(stream);
@@ -438,10 +476,52 @@ internal sealed class GifDecoderCore : ImageDecoderCore
         }
 
         ReadOnlySpan<Rgb24> colorTable = MemoryMarshal.Cast<byte, Rgb24>(rawColorTable);
-        this.ReadFrameColors(stream, ref image, ref previousFrame, colorTable);
+
+        // First frame
+        if (image is null)
+        {
+            if (this.backgroundColorIndex < colorTable.Length)
+            {
+                backgroundColor = Color.FromPixel(colorTable[this.backgroundColorIndex]);
+            }
+            else
+            {
+                backgroundColor = Color.Transparent;
+            }
+
+            if (this.graphicsControlExtension.TransparencyFlag)
+            {
+                backgroundColor = backgroundColor.WithAlpha(0);
+            }
+        }
+
+        this.ReadFrameColors(stream, ref image, ref previousFrame, ref previousDisposalMode, colorTable, backgroundColor.ToPixel<TPixel>());
+
+        // Update from newly decoded frame.
+        if (this.graphicsControlExtension.DisposalMethod != FrameDisposalMode.RestoreToPrevious)
+        {
+            if (this.backgroundColorIndex < colorTable.Length)
+            {
+                backgroundColor = Color.FromPixel(colorTable[this.backgroundColorIndex]);
+            }
+            else
+            {
+                backgroundColor = Color.Transparent;
+            }
+
+            // TODO: I don't understand why this is always set to alpha of zero.
+            // This should be dependent on the transparency flag of the graphics
+            // control extension. ImageMagick does the same.
+            // if (this.graphicsControlExtension.TransparencyFlag)
+            {
+                backgroundColor = backgroundColor.WithAlpha(0);
+            }
+        }
 
         // Skip any remaining blocks
         SkipBlock(stream);
+
+        return !hasLocalColorTable;
     }
 
     /// <summary>
@@ -451,56 +531,73 @@ internal sealed class GifDecoderCore : ImageDecoderCore
     /// <param name="stream">The <see cref="BufferedReadStream"/> containing image data.</param>
     /// <param name="image">The image to decode the information to.</param>
     /// <param name="previousFrame">The previous frame.</param>
+    /// <param name="previousDisposalMode">The previous frame disposal mode.</param>
     /// <param name="colorTable">The color table containing the available colors.</param>
+    /// <param name="backgroundPixel">The background color pixel.</param>
     private void ReadFrameColors<TPixel>(
         BufferedReadStream stream,
         ref Image<TPixel>? image,
         ref ImageFrame<TPixel>? previousFrame,
-        ReadOnlySpan<Rgb24> colorTable)
+        ref FrameDisposalMode? previousDisposalMode,
+        ReadOnlySpan<Rgb24> colorTable,
+        TPixel backgroundPixel)
         where TPixel : unmanaged, IPixel<TPixel>
     {
         GifImageDescriptor descriptor = this.imageDescriptor;
         int imageWidth = this.logicalScreenDescriptor.Width;
         int imageHeight = this.logicalScreenDescriptor.Height;
         bool transFlag = this.graphicsControlExtension.TransparencyFlag;
+        FrameDisposalMode disposalMethod = this.graphicsControlExtension.DisposalMethod;
+        ImageFrame<TPixel> currentFrame;
+        ImageFrame<TPixel>? restoreFrame = null;
 
-        ImageFrame<TPixel>? prevFrame = null;
-        ImageFrame<TPixel>? currentFrame = null;
-        ImageFrame<TPixel> imageFrame;
+        if (previousFrame is null && previousDisposalMode is null)
+        {
+            image = transFlag
+                ? new Image<TPixel>(this.configuration, imageWidth, imageHeight, this.metadata)
+                : new Image<TPixel>(this.configuration, imageWidth, imageHeight, backgroundPixel, this.metadata);
 
-        if (previousFrame is null)
+            this.SetFrameMetadata(image.Frames.RootFrame.Metadata);
+            currentFrame = image.Frames.RootFrame;
+        }
+        else
         {
-            if (!transFlag)
+            if (previousFrame != null)
             {
-                image = new Image<TPixel>(this.configuration, imageWidth, imageHeight, Color.Black.ToPixel<TPixel>(), this.metadata);
+                currentFrame = image!.Frames.AddFrame(previousFrame);
             }
             else
             {
-                // This initializes the image to become fully transparent because the alpha channel is zero.
-                image = new Image<TPixel>(this.configuration, imageWidth, imageHeight, this.metadata);
+                currentFrame = image!.Frames.CreateFrame(backgroundPixel);
             }
 
-            this.SetFrameMetadata(image.Frames.RootFrame.Metadata);
+            this.SetFrameMetadata(currentFrame.Metadata);
 
-            imageFrame = image.Frames.RootFrame;
-        }
-        else
-        {
             if (this.graphicsControlExtension.DisposalMethod == FrameDisposalMode.RestoreToPrevious)
             {
-                prevFrame = previousFrame;
+                restoreFrame = previousFrame;
             }
 
-            // We create a clone of the frame and add it.
-            // We will overpaint the difference of pixels on the current frame to create a complete image.
-            // This ensures that we have enough pixel data to process without distortion. #2450
-            currentFrame = image!.Frames.AddFrame(previousFrame);
+            if (previousDisposalMode == FrameDisposalMode.RestoreToBackground)
+            {
+                this.RestoreToBackground(currentFrame, backgroundPixel, transFlag);
+            }
+        }
 
-            this.SetFrameMetadata(currentFrame.Metadata);
+        if (this.graphicsControlExtension.DisposalMethod == FrameDisposalMode.RestoreToPrevious)
+        {
+            previousFrame = restoreFrame;
+        }
+        else
+        {
+            previousFrame = currentFrame;
+        }
 
-            imageFrame = currentFrame;
+        previousDisposalMode = disposalMethod;
 
-            this.RestoreToBackground(imageFrame);
+        if (disposalMethod == FrameDisposalMode.RestoreToBackground)
+        {
+            this.restoreArea = Rectangle.Intersect(image.Bounds, new Rectangle(descriptor.Left, descriptor.Top, descriptor.Width, descriptor.Height));
         }
 
         if (colorTable.Length == 0)
@@ -568,7 +665,7 @@ internal sealed class GifDecoderCore : ImageDecoderCore
 
                 // #403 The left + width value can be larger than the image width
                 int maxX = Math.Min(descriptorRight, imageWidth);
-                Span<TPixel> row = imageFrame.PixelBuffer.DangerousGetRowSpan(writeY);
+                Span<TPixel> row = currentFrame.PixelBuffer.DangerousGetRowSpan(writeY);
 
                 // Take the descriptorLeft..maxX slice of the row, so the loop can be simplified.
                 row = row[descriptorLeft..maxX];
@@ -599,19 +696,6 @@ internal sealed class GifDecoderCore : ImageDecoderCore
                 }
             }
         }
-
-        if (prevFrame != null)
-        {
-            previousFrame = prevFrame;
-            return;
-        }
-
-        previousFrame = currentFrame ?? image.Frames.RootFrame;
-
-        if (this.graphicsControlExtension.DisposalMethod == FrameDisposalMode.RestoreToBackground)
-        {
-            this.restoreArea = new Rectangle(descriptor.Left, descriptor.Top, descriptor.Width, descriptor.Height);
-        }
     }
 
     /// <summary>
@@ -620,7 +704,8 @@ internal sealed class GifDecoderCore : ImageDecoderCore
     /// <param name="stream">The <see cref="BufferedReadStream"/> containing image data.</param>
     /// <param name="frameMetadata">The collection of frame metadata.</param>
     /// <param name="previousFrame">The previous frame metadata.</param>
-    private void ReadFrameMetadata(BufferedReadStream stream, List<ImageFrameMetadata> frameMetadata, ref ImageFrameMetadata? previousFrame)
+    /// <returns>Whether the frame has a global color table.</returns>
+    private bool ReadFrameMetadata(BufferedReadStream stream, List<ImageFrameMetadata> frameMetadata, ref ImageFrameMetadata? previousFrame)
     {
         this.ReadImageDescriptor(stream);
 
@@ -632,6 +717,11 @@ internal sealed class GifDecoderCore : ImageDecoderCore
             this.currentLocalColorTable ??= this.configuration.MemoryAllocator.Allocate<byte>(768, AllocationOptions.Clean);
             stream.Read(this.currentLocalColorTable.GetSpan()[..length]);
         }
+        else
+        {
+            this.currentLocalColorTable = null;
+            this.currentLocalColorTableSize = 0;
+        }
 
         // Skip the frame indices. Pixels length + mincode size.
         // The gif format does not tell us the length of the compressed data beforehand.
@@ -649,6 +739,8 @@ internal sealed class GifDecoderCore : ImageDecoderCore
 
         // Skip any remaining blocks
         SkipBlock(stream);
+
+        return !this.imageDescriptor.LocalColorTableFlag;
     }
 
     /// <summary>
@@ -656,7 +748,9 @@ internal sealed class GifDecoderCore : ImageDecoderCore
     /// </summary>
     /// <typeparam name="TPixel">The pixel format.</typeparam>
     /// <param name="frame">The frame.</param>
-    private void RestoreToBackground<TPixel>(ImageFrame<TPixel> frame)
+    /// <param name="background">The background color.</param>
+    /// <param name="transparent">Whether the background is transparent.</param>
+    private void RestoreToBackground<TPixel>(ImageFrame<TPixel> frame, TPixel background, bool transparent)
         where TPixel : unmanaged, IPixel<TPixel>
     {
         if (this.restoreArea is null)
@@ -666,7 +760,14 @@ internal sealed class GifDecoderCore : ImageDecoderCore
 
         Rectangle interest = Rectangle.Intersect(frame.Bounds, this.restoreArea.Value);
         Buffer2DRegion<TPixel> pixelRegion = frame.PixelBuffer.GetRegion(interest);
-        pixelRegion.Clear();
+        if (transparent)
+        {
+            pixelRegion.Clear();
+        }
+        else
+        {
+            pixelRegion.Fill(background);
+        }
 
         this.restoreArea = null;
     }
@@ -775,7 +876,9 @@ internal sealed class GifDecoderCore : ImageDecoderCore
             }
         }
 
-        this.gifMetadata.BackgroundColorIndex = this.logicalScreenDescriptor.BackgroundColorIndex;
+        byte index = this.logicalScreenDescriptor.BackgroundColorIndex;
+        this.backgroundColorIndex = index;
+        this.gifMetadata.BackgroundColorIndex = index;
     }
 
     private unsafe struct ScratchBuffer
diff --git a/src/ImageSharp/Formats/Gif/GifEncoderCore.cs b/src/ImageSharp/Formats/Gif/GifEncoderCore.cs
index 797e825dc4..ffe318063e 100644
--- a/src/ImageSharp/Formats/Gif/GifEncoderCore.cs
+++ b/src/ImageSharp/Formats/Gif/GifEncoderCore.cs
@@ -9,7 +9,6 @@ using SixLabors.ImageSharp.Memory;
 using SixLabors.ImageSharp.Metadata;
 using SixLabors.ImageSharp.Metadata.Profiles.Xmp;
 using SixLabors.ImageSharp.PixelFormats;
-using SixLabors.ImageSharp.Processing;
 using SixLabors.ImageSharp.Processing.Processors.Quantization;
 
 namespace SixLabors.ImageSharp.Formats.Gif;
@@ -19,6 +18,8 @@ namespace SixLabors.ImageSharp.Formats.Gif;
 /// </summary>
 internal sealed class GifEncoderCore
 {
+    private readonly GifEncoder encoder;
+
     /// <summary>
     /// Used for allocating memory during processing operations.
     /// </summary>
@@ -34,16 +35,6 @@ internal sealed class GifEncoderCore
     /// </summary>
     private readonly bool skipMetadata;
 
-    /// <summary>
-    /// The quantizer used to generate the color palette.
-    /// </summary>
-    private IQuantizer? quantizer;
-
-    /// <summary>
-    /// Whether the quantizer was supplied via options.
-    /// </summary>
-    private readonly bool hasQuantizer;
-
     /// <summary>
     /// The color table mode: Global or local.
     /// </summary>
@@ -67,6 +58,9 @@ internal sealed class GifEncoderCore
     /// </summary>
     private readonly ushort? repeatCount;
 
+    /// <summary>
+    /// The transparent color mode.
+    /// </summary>
     private readonly TransparentColorMode transparentColorMode;
 
     /// <summary>
@@ -78,9 +72,8 @@ internal sealed class GifEncoderCore
     {
         this.configuration = configuration;
         this.memoryAllocator = configuration.MemoryAllocator;
+        this.encoder = encoder;
         this.skipMetadata = encoder.SkipMetadata;
-        this.quantizer = encoder.Quantizer;
-        this.hasQuantizer = encoder.Quantizer is not null;
         this.colorTableMode = encoder.ColorTableMode;
         this.pixelSamplingStrategy = encoder.PixelSamplingStrategy;
         this.backgroundColor = encoder.BackgroundColor;
@@ -104,70 +97,76 @@ internal sealed class GifEncoderCore
         GifMetadata gifMetadata = image.Metadata.CloneGifMetadata();
         this.colorTableMode ??= gifMetadata.ColorTableMode;
         bool useGlobalTable = this.colorTableMode == FrameColorTableMode.Global;
-
-        // Quantize the first image frame returning a palette.
-        IndexedImageFrame<TPixel>? quantized = null;
+        bool useGlobalTableForFirstFrame = useGlobalTable;
 
         // Work out if there is an explicit transparent index set for the frame. We use that to ensure the
         // correct value is set for the background index when quantizing.
         GifFrameMetadata frameMetadata = GetGifFrameMetadata(image.Frames.RootFrame, -1);
+        if (frameMetadata.ColorTableMode == FrameColorTableMode.Local)
+        {
+            useGlobalTableForFirstFrame = false;
+        }
+
+        // Quantize the first image frame returning a palette.
+        IndexedImageFrame<TPixel>? quantized = null;
+        IQuantizer? globalQuantizer = this.encoder.Quantizer;
+        TransparentColorMode mode = this.transparentColorMode;
 
-        if (this.quantizer is null)
+        // Create a new quantizer options instance augmenting the transparent color mode to match the encoder.
+        QuantizerOptions options = (this.encoder.Quantizer?.Options ?? new QuantizerOptions()).DeepClone(o => o.TransparentColorMode = mode);
+
+        if (globalQuantizer is null)
         {
             // Is this a gif with color information. If so use that, otherwise use octree.
             if (gifMetadata.ColorTableMode == FrameColorTableMode.Global && gifMetadata.GlobalColorTable?.Length > 0)
             {
-                // We avoid dithering by default to preserve the original colors.
                 int transparencyIndex = GetTransparentIndex(quantized, frameMetadata);
                 if (transparencyIndex >= 0 || gifMetadata.GlobalColorTable.Value.Length < 256)
                 {
-                    this.quantizer = new PaletteQuantizer(gifMetadata.GlobalColorTable.Value, new() { Dither = null }, transparencyIndex);
+                    // We avoid dithering by default to preserve the original colors.
+                    globalQuantizer = new PaletteQuantizer(gifMetadata.GlobalColorTable.Value, options.DeepClone(o => o.Dither = null));
                 }
                 else
                 {
-                    this.quantizer = KnownQuantizers.Octree;
+                    globalQuantizer = new OctreeQuantizer(options);
                 }
             }
             else
             {
-                this.quantizer = KnownQuantizers.Octree;
+                globalQuantizer = new OctreeQuantizer(options);
             }
         }
 
-        // Quantize the first frame. Checking to see whether we can clear the transparent pixels
-        // to allow for a smaller color palette and encoded result.
-        using (IQuantizer<TPixel> frameQuantizer = this.quantizer.CreatePixelSpecificQuantizer<TPixel>(this.configuration))
-        {
-            ImageFrame<TPixel>? clonedFrame = null;
-            Configuration configuration = this.configuration;
-            TransparentColorMode mode = this.transparentColorMode;
-            IPixelSamplingStrategy strategy = this.pixelSamplingStrategy;
-            if (EncodingUtilities.ShouldClearTransparentPixels<TPixel>(mode))
-            {
-                clonedFrame = image.Frames.RootFrame.Clone();
-
-                GifFrameMetadata frameMeta = clonedFrame.Metadata.GetGifMetadata();
-                Color background = frameMeta.DisposalMode == FrameDisposalMode.RestoreToBackground
-                    ? this.backgroundColor ?? Color.Transparent
-                    : Color.Transparent;
-
-                EncodingUtilities.ClearTransparentPixels(clonedFrame, background);
-            }
-
-            ImageFrame<TPixel> encodingFrame = clonedFrame ?? image.Frames.RootFrame;
+        // Quantize the first frame.
+        IPixelSamplingStrategy strategy = this.pixelSamplingStrategy;
 
+        ImageFrame<TPixel> encodingFrame = image.Frames.RootFrame;
+        if (useGlobalTableForFirstFrame)
+        {
+            using IQuantizer<TPixel> firstFrameQuantizer = globalQuantizer.CreatePixelSpecificQuantizer<TPixel>(this.configuration, options);
             if (useGlobalTable)
             {
-                frameQuantizer.BuildPalette(configuration, mode, strategy, image);
-                quantized = frameQuantizer.QuantizeFrame(encodingFrame, image.Bounds);
+                firstFrameQuantizer.BuildPalette(strategy, image);
             }
             else
             {
-                frameQuantizer.BuildPalette(configuration, mode, strategy, encodingFrame);
-                quantized = frameQuantizer.QuantizeFrame(encodingFrame, image.Bounds);
+                firstFrameQuantizer.BuildPalette(strategy, encodingFrame);
             }
 
-            clonedFrame?.Dispose();
+            quantized = firstFrameQuantizer.QuantizeFrame(encodingFrame, encodingFrame.Bounds);
+        }
+        else
+        {
+            quantized = this.QuantizeFrameAndUpdateMetadata(
+                encodingFrame,
+                globalQuantizer,
+                default,
+                encodingFrame.Bounds,
+                frameMetadata,
+                true,
+                false,
+                frameMetadata.HasTransparency ? frameMetadata.TransparencyIndex : -1,
+                Color.Transparent);
         }
 
         // Write the header.
@@ -181,6 +180,7 @@ internal sealed class GifEncoderCore
             frameMetadata.TransparencyIndex = ClampIndex(derivedTransparencyIndex);
         }
 
+        // TODO: We should be checking the metadata here also I think?
         if (!TryGetBackgroundIndex(quantized, this.backgroundColor, out byte backgroundIndex))
         {
             backgroundIndex = derivedTransparencyIndex >= 0
@@ -216,13 +216,18 @@ internal sealed class GifEncoderCore
             // Capture the global palette for reuse on subsequent frames and cleanup the quantized frame.
             TPixel[] globalPalette = image.Frames.Count == 1 ? [] : quantized.Palette.ToArray();
 
-            this.EncodeAdditionalFrames(
-                stream,
-                image,
-                globalPalette,
-                derivedTransparencyIndex,
-                frameMetadata.DisposalMode,
-                cancellationToken);
+            if (image.Frames.Count > 1)
+            {
+                using PaletteQuantizer<TPixel> globalFrameQuantizer = new(this.configuration, globalQuantizer.Options, quantized.Palette.ToArray());
+                this.EncodeAdditionalFrames(
+                    stream,
+                    image,
+                    globalQuantizer,
+                    globalFrameQuantizer,
+                    derivedTransparencyIndex,
+                    frameMetadata.DisposalMode,
+                    cancellationToken);
+            }
         }
         finally
         {
@@ -248,69 +253,43 @@ internal sealed class GifEncoderCore
     private void EncodeAdditionalFrames<TPixel>(
         Stream stream,
         Image<TPixel> image,
-        ReadOnlyMemory<TPixel> globalPalette,
+        IQuantizer globalQuantizer,
+        PaletteQuantizer<TPixel> globalFrameQuantizer,
         int globalTransparencyIndex,
         FrameDisposalMode previousDisposalMode,
         CancellationToken cancellationToken)
         where TPixel : unmanaged, IPixel<TPixel>
     {
-        if (image.Frames.Count == 1)
-        {
-            return;
-        }
-
-        PaletteQuantizer<TPixel> paletteQuantizer = default;
-        bool hasPaletteQuantizer = false;
-
         // Store the first frame as a reference for de-duplication comparison.
         ImageFrame<TPixel> previousFrame = image.Frames.RootFrame;
 
         // This frame is reused to store de-duplicated pixel buffers.
         using ImageFrame<TPixel> encodingFrame = new(previousFrame.Configuration, previousFrame.Size);
 
-        try
+        for (int i = 1; i < image.Frames.Count; i++)
         {
-            for (int i = 1; i < image.Frames.Count; i++)
-            {
-                cancellationToken.ThrowIfCancellationRequested();
+            cancellationToken.ThrowIfCancellationRequested();
 
-                // Gather the metadata for this frame.
-                ImageFrame<TPixel> currentFrame = image.Frames[i];
-                ImageFrame<TPixel>? nextFrame = i < image.Frames.Count - 1 ? image.Frames[i + 1] : null;
-                GifFrameMetadata gifMetadata = GetGifFrameMetadata(currentFrame, globalTransparencyIndex);
-                bool useLocal = this.colorTableMode == FrameColorTableMode.Local || (gifMetadata.ColorTableMode == FrameColorTableMode.Local);
+            // Gather the metadata for this frame.
+            ImageFrame<TPixel> currentFrame = image.Frames[i];
+            ImageFrame<TPixel>? nextFrame = i < image.Frames.Count - 1 ? image.Frames[i + 1] : null;
+            GifFrameMetadata gifMetadata = GetGifFrameMetadata(currentFrame, globalTransparencyIndex);
+            bool useLocal = this.colorTableMode == FrameColorTableMode.Local || (gifMetadata.ColorTableMode == FrameColorTableMode.Local);
 
-                if (!useLocal && !hasPaletteQuantizer && i > 0)
-                {
-                    // The palette quantizer can reuse the same global pixel map across multiple frames since the palette is unchanging.
-                    // This allows a reduction of memory usage across multi-frame gifs using a global palette
-                    // and also allows use to reuse the cache from previous runs.
-                    int transparencyIndex = gifMetadata.HasTransparency ? gifMetadata.TransparencyIndex : -1;
-                    paletteQuantizer = new(this.configuration, this.quantizer!.Options, globalPalette, transparencyIndex);
-                    hasPaletteQuantizer = true;
-                }
+            this.EncodeAdditionalFrame(
+                stream,
+                previousFrame,
+                currentFrame,
+                nextFrame,
+                encodingFrame,
+                globalQuantizer,
+                globalFrameQuantizer,
+                useLocal,
+                gifMetadata,
+                previousDisposalMode);
 
-                this.EncodeAdditionalFrame(
-                    stream,
-                    previousFrame,
-                    currentFrame,
-                    nextFrame,
-                    encodingFrame,
-                    useLocal,
-                    gifMetadata,
-                    paletteQuantizer,
-                    previousDisposalMode);
-
-                previousFrame = currentFrame;
-                previousDisposalMode = gifMetadata.DisposalMode;
-            }
-        }
-        finally
-        {
-            if (hasPaletteQuantizer)
-            {
-                paletteQuantizer.Dispose();
-            }
+            previousFrame = currentFrame;
+            previousDisposalMode = gifMetadata.DisposalMode;
         }
     }
 
@@ -346,9 +325,10 @@ internal sealed class GifEncoderCore
         ImageFrame<TPixel> currentFrame,
         ImageFrame<TPixel>? nextFrame,
         ImageFrame<TPixel> encodingFrame,
+        IQuantizer globalQuantizer,
+        PaletteQuantizer<TPixel> globalFrameQuantizer,
         bool useLocal,
         GifFrameMetadata metadata,
-        PaletteQuantizer<TPixel> globalPaletteQuantizer,
         FrameDisposalMode previousDisposalMode)
         where TPixel : unmanaged, IPixel<TPixel>
     {
@@ -375,19 +355,16 @@ internal sealed class GifEncoderCore
                 background,
                 true);
 
-        if (EncodingUtilities.ShouldClearTransparentPixels<TPixel>(this.transparentColorMode))
-        {
-            EncodingUtilities.ClearTransparentPixels(encodingFrame, background);
-        }
-
-        using IndexedImageFrame<TPixel> quantized = this.QuantizeAdditionalFrameAndUpdateMetadata(
+        using IndexedImageFrame<TPixel> quantized = this.QuantizeFrameAndUpdateMetadata(
                 encodingFrame,
+                globalQuantizer,
+                globalFrameQuantizer,
                 bounds,
                 metadata,
                 useLocal,
-                globalPaletteQuantizer,
                 difference,
-                transparencyIndex);
+                transparencyIndex,
+                background);
 
         this.WriteGraphicalControlExtension(metadata, stream);
 
@@ -403,14 +380,16 @@ internal sealed class GifEncoderCore
         this.WriteImageData(indices, stream, quantized.Palette.Length, metadata.TransparencyIndex);
     }
 
-    private IndexedImageFrame<TPixel> QuantizeAdditionalFrameAndUpdateMetadata<TPixel>(
+    private IndexedImageFrame<TPixel> QuantizeFrameAndUpdateMetadata<TPixel>(
         ImageFrame<TPixel> encodingFrame,
+        IQuantizer globalQuantizer,
+        PaletteQuantizer<TPixel> globalFrameQuantizer,
         Rectangle bounds,
         GifFrameMetadata metadata,
         bool useLocal,
-        PaletteQuantizer<TPixel> globalPaletteQuantizer,
         bool hasDuplicates,
-        int transparencyIndex)
+        int transparencyIndex,
+        Color transparentColor)
         where TPixel : unmanaged, IPixel<TPixel>
     {
         IndexedImageFrame<TPixel> quantized;
@@ -434,15 +413,19 @@ internal sealed class GifEncoderCore
                         transparencyIndex = palette.Length;
                         metadata.TransparencyIndex = ClampIndex(transparencyIndex);
 
-                        PaletteQuantizer quantizer = new(palette, new() { Dither = null }, transparencyIndex);
-                        using IQuantizer<TPixel> frameQuantizer = quantizer.CreatePixelSpecificQuantizer<TPixel>(this.configuration, quantizer.Options);
+                        QuantizerOptions options = globalQuantizer.Options.DeepClone(o =>
+                        {
+                            o.MaxColors = palette.Length;
+                            o.Dither = null;
+                        });
+                        PaletteQuantizer quantizer = new(palette, options, transparencyIndex, transparentColor);
+                        using IQuantizer<TPixel> frameQuantizer = quantizer.CreatePixelSpecificQuantizer<TPixel>(this.configuration);
                         quantized = frameQuantizer.BuildPaletteAndQuantizeFrame(encodingFrame, bounds);
                     }
                     else
                     {
                         // We must quantize the frame to generate a local color table.
-                        IQuantizer quantizer = this.hasQuantizer ? this.quantizer! : KnownQuantizers.Octree;
-                        using IQuantizer<TPixel> frameQuantizer = quantizer.CreatePixelSpecificQuantizer<TPixel>(this.configuration, quantizer.Options);
+                        using IQuantizer<TPixel> frameQuantizer = globalQuantizer.CreatePixelSpecificQuantizer<TPixel>(this.configuration);
                         quantized = frameQuantizer.BuildPaletteAndQuantizeFrame(encodingFrame, bounds);
 
                         // The transparency index derived by the quantizer will differ from the index
@@ -454,7 +437,12 @@ internal sealed class GifEncoderCore
                 else
                 {
                     // Just use the local palette.
-                    PaletteQuantizer quantizer = new(palette, new() { Dither = null }, transparencyIndex);
+                    QuantizerOptions paletteOptions = globalQuantizer.Options.DeepClone(o =>
+                    {
+                        o.MaxColors = palette.Length;
+                        o.Dither = null;
+                    });
+                    PaletteQuantizer quantizer = new(palette, paletteOptions, transparencyIndex, transparentColor);
                     using IQuantizer<TPixel> frameQuantizer = quantizer.CreatePixelSpecificQuantizer<TPixel>(this.configuration, quantizer.Options);
                     quantized = frameQuantizer.BuildPaletteAndQuantizeFrame(encodingFrame, bounds);
                 }
@@ -462,8 +450,7 @@ internal sealed class GifEncoderCore
             else
             {
                 // We must quantize the frame to generate a local color table.
-                IQuantizer quantizer = this.hasQuantizer ? this.quantizer! : KnownQuantizers.Octree;
-                using IQuantizer<TPixel> frameQuantizer = quantizer.CreatePixelSpecificQuantizer<TPixel>(this.configuration, quantizer.Options);
+                using IQuantizer<TPixel> frameQuantizer = globalQuantizer.CreatePixelSpecificQuantizer<TPixel>(this.configuration);
                 quantized = frameQuantizer.BuildPaletteAndQuantizeFrame(encodingFrame, bounds);
 
                 // The transparency index derived by the quantizer might differ from the index
@@ -486,18 +473,19 @@ internal sealed class GifEncoderCore
         else
         {
             // Quantize the image using the global palette.
-            // Individual frames, though using the shared palette, can use a different transparent index to represent transparency.
+            // Individual frames, though using the shared palette, can use a different transparent index
+            // to represent transparency.
 
             // A difference was captured but the metadata does not have transparency.
             if (hasDuplicates && !metadata.HasTransparency)
             {
                 metadata.HasTransparency = true;
-                transparencyIndex = globalPaletteQuantizer.Palette.Length;
+                transparencyIndex = globalFrameQuantizer.Palette.Length;
                 metadata.TransparencyIndex = ClampIndex(transparencyIndex);
             }
 
-            globalPaletteQuantizer.SetTransparentIndex(transparencyIndex);
-            quantized = globalPaletteQuantizer.QuantizeFrame(encodingFrame, bounds);
+            globalFrameQuantizer.SetTransparencyIndex(transparencyIndex, transparentColor.ToPixel<TPixel>());
+            quantized = globalFrameQuantizer.QuantizeFrame(encodingFrame, bounds);
         }
 
         return quantized;
diff --git a/src/ImageSharp/Formats/Gif/GifFrameMetadata.cs b/src/ImageSharp/Formats/Gif/GifFrameMetadata.cs
index 5fe892c656..f58ee786f3 100644
--- a/src/ImageSharp/Formats/Gif/GifFrameMetadata.cs
+++ b/src/ImageSharp/Formats/Gif/GifFrameMetadata.cs
@@ -77,34 +77,12 @@ public class GifFrameMetadata : IFormatFrameMetadata<GifFrameMetadata>
 
     /// <inheritdoc />
     public static GifFrameMetadata FromFormatConnectingFrameMetadata(FormatConnectingFrameMetadata metadata)
-    {
-        int index = -1;
-        const float background = 1f;
-        if (metadata.ColorTable.HasValue)
-        {
-            ReadOnlySpan<Color> colorTable = metadata.ColorTable.Value.Span;
-            for (int i = 0; i < colorTable.Length; i++)
-            {
-                Vector4 vector = colorTable[i].ToScaledVector4();
-                if (vector.W < background)
-                {
-                    index = i;
-                }
-            }
-        }
-
-        bool hasTransparency = index >= 0;
-
-        return new()
+        => new()
         {
-            LocalColorTable = metadata.ColorTable,
             ColorTableMode = metadata.ColorTableMode,
             FrameDelay = (int)Math.Round(metadata.Duration.TotalMilliseconds / 10),
             DisposalMode = metadata.DisposalMode,
-            HasTransparency = hasTransparency,
-            TransparencyIndex = hasTransparency ? unchecked((byte)index) : byte.MinValue,
         };
-    }
 
     /// <inheritdoc />
     public FormatConnectingFrameMetadata ToFormatConnectingFrameMetadata()
@@ -116,9 +94,8 @@ public class GifFrameMetadata : IFormatFrameMetadata<GifFrameMetadata>
         // If the color table is global and frame has no transparency. Consider it 'Source' also.
         blendSource |= this.ColorTableMode == FrameColorTableMode.Global && !this.HasTransparency;
 
-        return new()
+        return new FormatConnectingFrameMetadata
         {
-            ColorTable = this.LocalColorTable,
             ColorTableMode = this.ColorTableMode,
             Duration = TimeSpan.FromMilliseconds(this.FrameDelay * 10),
             DisposalMode = this.DisposalMode,
@@ -127,10 +104,9 @@ public class GifFrameMetadata : IFormatFrameMetadata<GifFrameMetadata>
     }
 
     /// <inheritdoc/>
-    public void AfterFrameApply<TPixel>(ImageFrame<TPixel> source, ImageFrame<TPixel> destination)
+    public void AfterFrameApply<TPixel>(ImageFrame<TPixel> source, ImageFrame<TPixel> destination, Matrix4x4 matrix)
         where TPixel : unmanaged, IPixel<TPixel>
-    {
-    }
+        => this.LocalColorTable = null;
 
     /// <inheritdoc/>
     IDeepCloneable IDeepCloneable.DeepClone() => this.DeepClone();
diff --git a/src/ImageSharp/Formats/Gif/GifMetadata.cs b/src/ImageSharp/Formats/Gif/GifMetadata.cs
index 517609af45..978209b23b 100644
--- a/src/ImageSharp/Formats/Gif/GifMetadata.cs
+++ b/src/ImageSharp/Formats/Gif/GifMetadata.cs
@@ -1,6 +1,7 @@
 // Copyright (c) Six Labors.
 // Licensed under the Six Labors Split License.
 
+using System.Numerics;
 using SixLabors.ImageSharp.PixelFormats;
 
 namespace SixLabors.ImageSharp.Formats.Gif;
@@ -71,37 +72,19 @@ public class GifMetadata : IFormatMetadata<GifMetadata>
 
     /// <inheritdoc/>
     public static GifMetadata FromFormatConnectingMetadata(FormatConnectingMetadata metadata)
-    {
-        int index = 0;
-        Color background = metadata.BackgroundColor;
-        if (metadata.ColorTable.HasValue)
+        => new()
         {
-            ReadOnlySpan<Color> colorTable = metadata.ColorTable.Value.Span;
-            for (int i = 0; i < colorTable.Length; i++)
-            {
-                if (background != colorTable[i])
-                {
-                    continue;
-                }
-
-                index = i;
-                break;
-            }
-        }
-
-        return new()
-        {
-            GlobalColorTable = metadata.ColorTable,
+            // Do not copy the color table or bit depth.
+            // This will lead to a mismatch when the image is comprised of frames
+            // extracted individually from a multi-frame image.
             ColorTableMode = metadata.ColorTableMode,
             RepeatCount = metadata.RepeatCount,
-            BackgroundColorIndex = (byte)Numerics.Clamp(index, 0, 255),
         };
-    }
 
     /// <inheritdoc/>
     public PixelTypeInfo GetPixelTypeInfo()
     {
-        int bpp = this.GlobalColorTable.HasValue
+        int bpp = this.ColorTableMode == FrameColorTableMode.Global && this.GlobalColorTable.HasValue
             ? Numerics.Clamp(ColorNumerics.GetBitsNeededForColorDepth(this.GlobalColorTable.Value.Length), 1, 8)
             : 8;
 
@@ -114,27 +97,18 @@ public class GifMetadata : IFormatMetadata<GifMetadata>
 
     /// <inheritdoc/>
     public FormatConnectingMetadata ToFormatConnectingMetadata()
-    {
-        Color color = this.GlobalColorTable.HasValue && this.GlobalColorTable.Value.Span.Length > this.BackgroundColorIndex
-            ? this.GlobalColorTable.Value.Span[this.BackgroundColorIndex]
-            : Color.Transparent;
-
-        return new()
+        => new()
         {
             AnimateRootFrame = true,
-            BackgroundColor = color,
-            ColorTable = this.GlobalColorTable,
             ColorTableMode = this.ColorTableMode,
             PixelTypeInfo = this.GetPixelTypeInfo(),
             RepeatCount = this.RepeatCount,
         };
-    }
 
     /// <inheritdoc/>
-    public void AfterImageApply<TPixel>(Image<TPixel> destination)
+    public void AfterImageApply<TPixel>(Image<TPixel> destination, Matrix4x4 matrix)
         where TPixel : unmanaged, IPixel<TPixel>
-    {
-    }
+        => this.GlobalColorTable = null;
 
     /// <inheritdoc/>
     IDeepCloneable IDeepCloneable.DeepClone() => this.DeepClone();
diff --git a/src/ImageSharp/Formats/Gif/LzwEncoder.cs b/src/ImageSharp/Formats/Gif/LzwEncoder.cs
index d4050810df..08daf38990 100644
--- a/src/ImageSharp/Formats/Gif/LzwEncoder.cs
+++ b/src/ImageSharp/Formats/Gif/LzwEncoder.cs
@@ -47,7 +47,7 @@ internal sealed class LzwEncoder : IDisposable
     /// Mask used when shifting pixel values
     /// </summary>
     private static readonly int[] Masks =
-    {
+    [
         0b0,
         0b1,
         0b11,
@@ -65,7 +65,7 @@ internal sealed class LzwEncoder : IDisposable
         0b11111111111111,
         0b111111111111111,
         0b1111111111111111
-    };
+    ];
 
     /// <summary>
     /// The maximum number of bits/code.
diff --git a/src/ImageSharp/Formats/Gif/Sections/GifXmpApplicationExtension.cs b/src/ImageSharp/Formats/Gif/Sections/GifXmpApplicationExtension.cs
index 1c1127c3be..dc78f28bf1 100644
--- a/src/ImageSharp/Formats/Gif/Sections/GifXmpApplicationExtension.cs
+++ b/src/ImageSharp/Formats/Gif/Sections/GifXmpApplicationExtension.cs
@@ -34,7 +34,7 @@ internal readonly struct GifXmpApplicationExtension : IGifExtension
 
         // Exclude the "magic trailer", see XMP Specification Part 3, 1.1.2 GIF
         int xmpLength = xmpBytes.Length - 256; // 257 - unread 0x0
-        byte[] buffer = Array.Empty<byte>();
+        byte[] buffer = [];
         if (xmpLength > 0)
         {
             buffer = new byte[xmpLength];
diff --git a/src/ImageSharp/Formats/IAnimatedImageEncoder.cs b/src/ImageSharp/Formats/IAnimatedImageEncoder.cs
index d2c3ad6907..26f2114df2 100644
--- a/src/ImageSharp/Formats/IAnimatedImageEncoder.cs
+++ b/src/ImageSharp/Formats/IAnimatedImageEncoder.cs
@@ -14,17 +14,17 @@ public interface IAnimatedImageEncoder
     /// as well as the transparent pixels of the first frame.
     /// The background color is also used when a frame disposal mode is <see cref="FrameDisposalMode.RestoreToBackground"/>.
     /// </summary>
-    Color? BackgroundColor { get; }
+    public Color? BackgroundColor { get; }
 
     /// <summary>
     /// Gets the number of times any animation is repeated in supported encoders.
     /// </summary>
-    ushort? RepeatCount { get; }
+    public ushort? RepeatCount { get; }
 
     /// <summary>
     /// Gets a value indicating whether the root frame is shown as part of the animated sequence in supported encoders.
     /// </summary>
-    bool? AnimateRootFrame { get; }
+    public bool? AnimateRootFrame { get; }
 }
 
 /// <summary>
diff --git a/src/ImageSharp/Formats/IFormatFrameMetadata.cs b/src/ImageSharp/Formats/IFormatFrameMetadata.cs
index 20f27d050c..68959272c5 100644
--- a/src/ImageSharp/Formats/IFormatFrameMetadata.cs
+++ b/src/ImageSharp/Formats/IFormatFrameMetadata.cs
@@ -1,6 +1,7 @@
 // Copyright (c) Six Labors.
 // Licensed under the Six Labors Split License.
 
+using System.Numerics;
 using SixLabors.ImageSharp.PixelFormats;
 
 namespace SixLabors.ImageSharp.Formats;
@@ -14,7 +15,7 @@ public interface IFormatFrameMetadata : IDeepCloneable
     /// Converts the metadata to a <see cref="FormatConnectingFrameMetadata"/> instance.
     /// </summary>
     /// <returns>The <see cref="FormatConnectingFrameMetadata"/>.</returns>
-    FormatConnectingFrameMetadata ToFormatConnectingFrameMetadata();
+    public FormatConnectingFrameMetadata ToFormatConnectingFrameMetadata();
 
     /// <summary>
     /// This method is called after a process has been applied to the image frame.
@@ -22,7 +23,8 @@ public interface IFormatFrameMetadata : IDeepCloneable
     /// <typeparam name="TPixel">The type of pixel format.</typeparam>
     /// <param name="source">The source image frame.</param>
     /// <param name="destination">The destination image frame.</param>
-    void AfterFrameApply<TPixel>(ImageFrame<TPixel> source, ImageFrame<TPixel> destination)
+    /// <param name="matrix">The transformation matrix applied to the image frame.</param>
+    public void AfterFrameApply<TPixel>(ImageFrame<TPixel> source, ImageFrame<TPixel> destination, Matrix4x4 matrix)
         where TPixel : unmanaged, IPixel<TPixel>;
 }
 
@@ -39,6 +41,6 @@ public interface IFormatFrameMetadata<TSelf> : IFormatFrameMetadata, IDeepClonea
     /// <param name="metadata">The <see cref="FormatConnectingFrameMetadata"/>.</param>
     /// <returns>The <typeparamref name="TSelf"/>.</returns>
 #pragma warning disable CA1000 // Do not declare static members on generic types
-    static abstract TSelf FromFormatConnectingFrameMetadata(FormatConnectingFrameMetadata metadata);
+    public static abstract TSelf FromFormatConnectingFrameMetadata(FormatConnectingFrameMetadata metadata);
 #pragma warning restore CA1000 // Do not declare static members on generic types
 }
diff --git a/src/ImageSharp/Formats/IFormatMetadata.cs b/src/ImageSharp/Formats/IFormatMetadata.cs
index a351431c94..81b3449352 100644
--- a/src/ImageSharp/Formats/IFormatMetadata.cs
+++ b/src/ImageSharp/Formats/IFormatMetadata.cs
@@ -1,6 +1,7 @@
 // Copyright (c) Six Labors.
 // Licensed under the Six Labors Split License.
 
+using System.Numerics;
 using SixLabors.ImageSharp.PixelFormats;
 
 namespace SixLabors.ImageSharp.Formats;
@@ -14,20 +15,21 @@ public interface IFormatMetadata : IDeepCloneable
     /// Converts the metadata to a <see cref="PixelTypeInfo"/> instance.
     /// </summary>
     /// <returns>The pixel type info.</returns>
-    PixelTypeInfo GetPixelTypeInfo();
+    public PixelTypeInfo GetPixelTypeInfo();
 
     /// <summary>
     /// Converts the metadata to a <see cref="FormatConnectingMetadata"/> instance.
     /// </summary>
     /// <returns>The <see cref="FormatConnectingMetadata"/>.</returns>
-    FormatConnectingMetadata ToFormatConnectingMetadata();
+    public FormatConnectingMetadata ToFormatConnectingMetadata();
 
     /// <summary>
     /// This method is called after a process has been applied to the image.
     /// </summary>
     /// <typeparam name="TPixel">The type of pixel format.</typeparam>
     /// <param name="destination">The destination image .</param>
-    void AfterImageApply<TPixel>(Image<TPixel> destination)
+    /// <param name="matrix">The transformation matrix applied to the image.</param>
+    public void AfterImageApply<TPixel>(Image<TPixel> destination, Matrix4x4 matrix)
         where TPixel : unmanaged, IPixel<TPixel>;
 }
 
@@ -44,6 +46,6 @@ public interface IFormatMetadata<TSelf> : IFormatMetadata, IDeepCloneable<TSelf>
     /// <param name="metadata">The <see cref="FormatConnectingMetadata"/>.</param>
     /// <returns>The <typeparamref name="TSelf"/>.</returns>
 #pragma warning disable CA1000 // Do not declare static members on generic types
-    static abstract TSelf FromFormatConnectingMetadata(FormatConnectingMetadata metadata);
+    public static abstract TSelf FromFormatConnectingMetadata(FormatConnectingMetadata metadata);
 #pragma warning restore CA1000 // Do not declare static members on generic types
 }
diff --git a/src/ImageSharp/Formats/IQuantizingImageEncoder.cs b/src/ImageSharp/Formats/IQuantizingImageEncoder.cs
index 5edf6e40e9..1ce2aa0918 100644
--- a/src/ImageSharp/Formats/IQuantizingImageEncoder.cs
+++ b/src/ImageSharp/Formats/IQuantizingImageEncoder.cs
@@ -13,12 +13,12 @@ public interface IQuantizingImageEncoder
     /// <summary>
     /// Gets the quantizer used to generate the color palette.
     /// </summary>
-    IQuantizer? Quantizer { get; }
+    public IQuantizer? Quantizer { get; }
 
     /// <summary>
     /// Gets the <see cref="IPixelSamplingStrategy"/> used for quantization when building color palettes.
     /// </summary>
-    IPixelSamplingStrategy PixelSamplingStrategy { get; }
+    public IPixelSamplingStrategy PixelSamplingStrategy { get; }
 }
 
 /// <summary>
diff --git a/src/ImageSharp/Formats/ISpecializedDecoderOptions.cs b/src/ImageSharp/Formats/ISpecializedDecoderOptions.cs
index e0a4c9b62c..881b5bcd44 100644
--- a/src/ImageSharp/Formats/ISpecializedDecoderOptions.cs
+++ b/src/ImageSharp/Formats/ISpecializedDecoderOptions.cs
@@ -11,5 +11,5 @@ public interface ISpecializedDecoderOptions
     /// <summary>
     /// Gets the general decoder options.
     /// </summary>
-    DecoderOptions GeneralOptions { get; init; }
+    public DecoderOptions GeneralOptions { get; init; }
 }
diff --git a/src/ImageSharp/Formats/Ico/IcoFrameMetadata.cs b/src/ImageSharp/Formats/Ico/IcoFrameMetadata.cs
index 62aa705cbe..fb42d60437 100644
--- a/src/ImageSharp/Formats/Ico/IcoFrameMetadata.cs
+++ b/src/ImageSharp/Formats/Ico/IcoFrameMetadata.cs
@@ -1,6 +1,7 @@
 // Copyright (c) Six Labors.
 // Licensed under the Six Labors Split License.
 
+using System.Numerics;
 using SixLabors.ImageSharp.Formats.Bmp;
 using SixLabors.ImageSharp.Formats.Icon;
 using SixLabors.ImageSharp.PixelFormats;
@@ -96,8 +97,7 @@ public class IcoFrameMetadata : IFormatFrameMetadata<IcoFrameMetadata>
             BmpBitsPerPixel = bbpp,
             Compression = compression,
             EncodingWidth = ClampEncodingDimension(metadata.EncodingWidth),
-            EncodingHeight = ClampEncodingDimension(metadata.EncodingHeight),
-            ColorTable = compression == IconFrameCompression.Bmp ? metadata.ColorTable : null
+            EncodingHeight = ClampEncodingDimension(metadata.EncodingHeight)
         };
     }
 
@@ -106,19 +106,19 @@ public class IcoFrameMetadata : IFormatFrameMetadata<IcoFrameMetadata>
         => new()
         {
             PixelTypeInfo = this.GetPixelTypeInfo(),
-            ColorTable = this.ColorTable,
             EncodingWidth = this.EncodingWidth,
             EncodingHeight = this.EncodingHeight
         };
 
     /// <inheritdoc/>
-    public void AfterFrameApply<TPixel>(ImageFrame<TPixel> source, ImageFrame<TPixel> destination)
+    public void AfterFrameApply<TPixel>(ImageFrame<TPixel> source, ImageFrame<TPixel> destination, Matrix4x4 matrix)
         where TPixel : unmanaged, IPixel<TPixel>
     {
         float ratioX = destination.Width / (float)source.Width;
         float ratioY = destination.Height / (float)source.Height;
         this.EncodingWidth = ScaleEncodingDimension(this.EncodingWidth, destination.Width, ratioX);
         this.EncodingHeight = ScaleEncodingDimension(this.EncodingHeight, destination.Height, ratioY);
+        this.ColorTable = null;
     }
 
     /// <inheritdoc/>
@@ -139,7 +139,7 @@ public class IcoFrameMetadata : IFormatFrameMetadata<IcoFrameMetadata>
             ? (byte)0
             : (byte)ColorNumerics.GetColorCountForBitDepth((int)this.BmpBitsPerPixel);
 
-        return new()
+        return new IconDirEntry
         {
             Width = ClampEncodingDimension(this.EncodingWidth ?? size.Width),
             Height = ClampEncodingDimension(this.EncodingHeight ?? size.Height),
diff --git a/src/ImageSharp/Formats/Ico/IcoMetadata.cs b/src/ImageSharp/Formats/Ico/IcoMetadata.cs
index a6c2704b31..ae768d3111 100644
--- a/src/ImageSharp/Formats/Ico/IcoMetadata.cs
+++ b/src/ImageSharp/Formats/Ico/IcoMetadata.cs
@@ -1,6 +1,7 @@
 // Copyright (c) Six Labors.
 // Licensed under the Six Labors Split License.
 
+using System.Numerics;
 using SixLabors.ImageSharp.Formats.Bmp;
 using SixLabors.ImageSharp.Formats.Icon;
 using SixLabors.ImageSharp.PixelFormats;
@@ -71,8 +72,7 @@ public class IcoMetadata : IFormatMetadata<IcoMetadata>
         return new IcoMetadata
         {
             BmpBitsPerPixel = bbpp,
-            Compression = compression,
-            ColorTable = compression == IconFrameCompression.Bmp ? metadata.ColorTable : null
+            Compression = compression
         };
     }
 
@@ -145,15 +145,13 @@ public class IcoMetadata : IFormatMetadata<IcoMetadata>
             EncodingType = this.Compression == IconFrameCompression.Bmp && this.BmpBitsPerPixel <= BmpBitsPerPixel.Bit8
                 ? EncodingType.Lossy
                 : EncodingType.Lossless,
-            PixelTypeInfo = this.GetPixelTypeInfo(),
-            ColorTable = this.ColorTable
+            PixelTypeInfo = this.GetPixelTypeInfo()
         };
 
     /// <inheritdoc/>
-    public void AfterImageApply<TPixel>(Image<TPixel> destination)
+    public void AfterImageApply<TPixel>(Image<TPixel> destination, Matrix4x4 matrix)
         where TPixel : unmanaged, IPixel<TPixel>
-    {
-    }
+        => this.ColorTable = null;
 
     /// <inheritdoc/>
     IDeepCloneable IDeepCloneable.DeepClone() => this.DeepClone();
diff --git a/src/ImageSharp/Formats/Icon/IconDecoderCore.cs b/src/ImageSharp/Formats/Icon/IconDecoderCore.cs
index caed2dd902..bc3258e6b2 100644
--- a/src/ImageSharp/Formats/Icon/IconDecoderCore.cs
+++ b/src/ImageSharp/Formats/Icon/IconDecoderCore.cs
@@ -63,7 +63,7 @@ internal abstract class IconDecoderCore : ImageDecoderCore
 
             // Since Windows Vista, the size of an image is determined from the BITMAPINFOHEADER structure or PNG image data
             // which technically allows storing icons with larger than 256 pixels, but such larger sizes are not recommended by Microsoft.
-            this.Dimensions = new(Math.Max(this.Dimensions.Width, temp.Size.Width), Math.Max(this.Dimensions.Height, temp.Size.Height));
+            this.Dimensions = new Size(Math.Max(this.Dimensions.Width, temp.Size.Width), Math.Max(this.Dimensions.Height, temp.Size.Height));
         }
 
         ImageMetadata metadata = new();
@@ -208,7 +208,7 @@ internal abstract class IconDecoderCore : ImageDecoderCore
 
             // Since Windows Vista, the size of an image is determined from the BITMAPINFOHEADER structure or PNG image data
             // which technically allows storing icons with larger than 256 pixels, but such larger sizes are not recommended by Microsoft.
-            this.Dimensions = new(Math.Max(this.Dimensions.Width, frameInfo.Size.Width), Math.Max(this.Dimensions.Height, frameInfo.Size.Height));
+            this.Dimensions = new Size(Math.Max(this.Dimensions.Width, frameInfo.Size.Width), Math.Max(this.Dimensions.Height, frameInfo.Size.Height));
         }
 
         // Copy the format specific metadata to the image.
@@ -222,7 +222,7 @@ internal abstract class IconDecoderCore : ImageDecoderCore
             metadata.SetFormatMetadata(PngFormat.Instance, pngMetadata);
         }
 
-        return new(this.Dimensions, metadata, frames);
+        return new ImageInfo(this.Dimensions, metadata, frames);
     }
 
     protected abstract void SetFrameMetadata(
@@ -276,20 +276,20 @@ internal abstract class IconDecoderCore : ImageDecoderCore
             height = Math.Max(height, entry.Height);
         }
 
-        this.Dimensions = new(width, height);
+        this.Dimensions = new Size(width, height);
     }
 
     private ImageDecoderCore GetDecoder(bool isPng)
     {
         if (isPng)
         {
-            return new PngDecoderCore(new()
+            return new PngDecoderCore(new PngDecoderOptions
             {
                 GeneralOptions = this.Options,
             });
         }
 
-        return new BmpDecoderCore(new()
+        return new BmpDecoderCore(new BmpDecoderOptions
         {
             GeneralOptions = this.Options,
             ProcessedAlphaMask = true,
diff --git a/src/ImageSharp/Formats/Icon/IconEncoderCore.cs b/src/ImageSharp/Formats/Icon/IconEncoderCore.cs
index 03e01f912f..479cf9f1b0 100644
--- a/src/ImageSharp/Formats/Icon/IconEncoderCore.cs
+++ b/src/ImageSharp/Formats/Icon/IconEncoderCore.cs
@@ -116,21 +116,21 @@ internal abstract class IconEncoderCore
     [MemberNotNull(nameof(entries))]
     private void InitHeader(Image image)
     {
-        this.fileHeader = new(this.iconFileType, (ushort)image.Frames.Count);
+        this.fileHeader = new IconDir(this.iconFileType, (ushort)image.Frames.Count);
         this.entries = this.iconFileType switch
         {
             IconFileType.ICO =>
-            image.Frames.Select(i =>
+            [.. image.Frames.Select(i =>
             {
                 IcoFrameMetadata metadata = i.Metadata.GetIcoMetadata();
                 return new EncodingFrameMetadata(metadata.Compression, metadata.BmpBitsPerPixel, metadata.ColorTable, metadata.ToIconDirEntry(i.Size));
-            }).ToArray(),
+            })],
             IconFileType.CUR =>
-            image.Frames.Select(i =>
+            [.. image.Frames.Select(i =>
             {
                 CurFrameMetadata metadata = i.Metadata.GetCurMetadata();
                 return new EncodingFrameMetadata(metadata.Compression, metadata.BmpBitsPerPixel, metadata.ColorTable, metadata.ToIconDirEntry(i.Size));
-            }).ToArray(),
+            })],
             _ => throw new NotSupportedException(),
         };
     }
@@ -149,14 +149,20 @@ internal abstract class IconEncoderCore
 
         if (metadata.ColorTable is null)
         {
-            return new WuQuantizer(new()
+            int count = metadata.Entry.ColorCount;
+            if (count == 0)
             {
-                MaxColors = metadata.Entry.ColorCount
+                count = 256;
+            }
+
+            return new WuQuantizer(new QuantizerOptions
+            {
+                MaxColors = count
             });
         }
 
         // Don't dither if we have a palette. We want to preserve as much information as possible.
-        return new PaletteQuantizer(metadata.ColorTable.Value, new() { Dither = null });
+        return new PaletteQuantizer(metadata.ColorTable.Value, new QuantizerOptions { Dither = null });
     }
 
     internal sealed class EncodingFrameMetadata
diff --git a/src/ImageSharp/Formats/ImageDecoder.cs b/src/ImageSharp/Formats/ImageDecoder.cs
index e58cd6a6de..c18fc663b5 100644
--- a/src/ImageSharp/Formats/ImageDecoder.cs
+++ b/src/ImageSharp/Formats/ImageDecoder.cs
@@ -24,6 +24,7 @@ public abstract class ImageDecoder : IImageDecoder
             s => this.Decode<TPixel>(options, s, default));
 
         this.SetDecoderFormat(options.Configuration, image);
+        HandleIccProfile(options, image);
 
         return image;
     }
@@ -37,6 +38,7 @@ public abstract class ImageDecoder : IImageDecoder
             s => this.Decode(options, s, default));
 
         this.SetDecoderFormat(options.Configuration, image);
+        HandleIccProfile(options, image);
 
         return image;
     }
@@ -46,12 +48,13 @@ public abstract class ImageDecoder : IImageDecoder
         where TPixel : unmanaged, IPixel<TPixel>
     {
         Image<TPixel> image = await WithSeekableMemoryStreamAsync(
-                options,
-                stream,
-                (s, ct) => this.Decode<TPixel>(options, s, ct),
-                cancellationToken).ConfigureAwait(false);
+            options,
+            stream,
+            (s, ct) => this.Decode<TPixel>(options, s, ct),
+            cancellationToken).ConfigureAwait(false);
 
         this.SetDecoderFormat(options.Configuration, image);
+        HandleIccProfile(options, image);
 
         return image;
     }
@@ -66,6 +69,7 @@ public abstract class ImageDecoder : IImageDecoder
             cancellationToken).ConfigureAwait(false);
 
         this.SetDecoderFormat(options.Configuration, image);
+        HandleIccProfile(options, image);
 
         return image;
     }
@@ -79,6 +83,7 @@ public abstract class ImageDecoder : IImageDecoder
             s => this.Identify(options, s, default));
 
         this.SetDecoderFormat(options.Configuration, info);
+        HandleIccProfile(options, info);
 
         return info;
     }
@@ -93,6 +98,7 @@ public abstract class ImageDecoder : IImageDecoder
             cancellationToken).ConfigureAwait(false);
 
         this.SetDecoderFormat(options.Configuration, info);
+        HandleIccProfile(options, info);
 
         return info;
     }
@@ -315,4 +321,20 @@ public abstract class ImageDecoder : IImageDecoder
             }
         }
     }
+
+    private static void HandleIccProfile(DecoderOptions options, Image image)
+    {
+        if (options.CanRemoveIccProfile(image.Metadata.IccProfile))
+        {
+            image.Metadata.IccProfile = null;
+        }
+    }
+
+    private static void HandleIccProfile(DecoderOptions options, ImageInfo image)
+    {
+        if (options.CanRemoveIccProfile(image.Metadata.IccProfile))
+        {
+            image.Metadata.IccProfile = null;
+        }
+    }
 }
diff --git a/src/ImageSharp/Formats/ImageFormatManager.cs b/src/ImageSharp/Formats/ImageFormatManager.cs
index b6b5f87797..ecf96855e5 100644
--- a/src/ImageSharp/Formats/ImageFormatManager.cs
+++ b/src/ImageSharp/Formats/ImageFormatManager.cs
@@ -161,7 +161,7 @@ public class ImageFormatManager
     /// <summary>
     /// Removes all the registered image format detectors.
     /// </summary>
-    public void ClearImageFormatDetectors() => this.imageFormatDetectors = new();
+    public void ClearImageFormatDetectors() => this.imageFormatDetectors = new ConcurrentBag<IImageFormatDetector>();
 
     /// <summary>
     /// Adds a new detector for detecting mime types.
diff --git a/src/ImageSharp/Formats/Jpeg/Components/Block8x8.cs b/src/ImageSharp/Formats/Jpeg/Components/Block8x8.cs
index 01d112bd6f..d2c383132a 100644
--- a/src/ImageSharp/Formats/Jpeg/Components/Block8x8.cs
+++ b/src/ImageSharp/Formats/Jpeg/Components/Block8x8.cs
@@ -140,7 +140,7 @@ internal partial struct Block8x8
     /// <inheritdoc />
     public override string ToString()
     {
-        var sb = new StringBuilder();
+        StringBuilder sb = new();
         sb.Append('[');
         for (int i = 0; i < Size; i++)
         {
@@ -211,10 +211,10 @@ internal partial struct Block8x8
     }
 
     /// <summary>
-    /// Transpose the block inplace.
+    /// Transpose the block in place.
     /// </summary>
     [MethodImpl(InliningOptions.ShortMethod)]
-    public void TransposeInplace()
+    public void TransposeInPlace()
     {
         ref short elemRef = ref Unsafe.As<Block8x8, short>(ref this);
 
diff --git a/src/ImageSharp/Formats/Jpeg/Components/Block8x8F.Generated.cs b/src/ImageSharp/Formats/Jpeg/Components/Block8x8F.Generated.cs
deleted file mode 100644
index 93bb7be36e..0000000000
--- a/src/ImageSharp/Formats/Jpeg/Components/Block8x8F.Generated.cs
+++ /dev/null
@@ -1,153 +0,0 @@
-// Copyright (c) Six Labors.
-// Licensed under the Six Labors Split License.
-
-using System.Numerics;
-using System.Runtime.CompilerServices;
-
-// <auto-generated />
-namespace SixLabors.ImageSharp.Formats.Jpeg.Components;
-
-internal partial struct Block8x8F
-{
-	/// <summary>
-    /// Level shift by +maximum/2, clip to [0, maximum]
-    /// </summary>
-    public void NormalizeColorsInPlace(float maximum)
-    {
-        var CMin4 = new Vector4(0F);
-        var CMax4 = new Vector4(maximum);
-        var COff4 = new Vector4(MathF.Ceiling(maximum * 0.5F));
-
-        this.V0L = Numerics.Clamp(this.V0L + COff4, CMin4, CMax4);
-        this.V0R = Numerics.Clamp(this.V0R + COff4, CMin4, CMax4);
-        this.V1L = Numerics.Clamp(this.V1L + COff4, CMin4, CMax4);
-        this.V1R = Numerics.Clamp(this.V1R + COff4, CMin4, CMax4);
-        this.V2L = Numerics.Clamp(this.V2L + COff4, CMin4, CMax4);
-        this.V2R = Numerics.Clamp(this.V2R + COff4, CMin4, CMax4);
-        this.V3L = Numerics.Clamp(this.V3L + COff4, CMin4, CMax4);
-        this.V3R = Numerics.Clamp(this.V3R + COff4, CMin4, CMax4);
-        this.V4L = Numerics.Clamp(this.V4L + COff4, CMin4, CMax4);
-        this.V4R = Numerics.Clamp(this.V4R + COff4, CMin4, CMax4);
-        this.V5L = Numerics.Clamp(this.V5L + COff4, CMin4, CMax4);
-        this.V5R = Numerics.Clamp(this.V5R + COff4, CMin4, CMax4);
-        this.V6L = Numerics.Clamp(this.V6L + COff4, CMin4, CMax4);
-        this.V6R = Numerics.Clamp(this.V6R + COff4, CMin4, CMax4);
-        this.V7L = Numerics.Clamp(this.V7L + COff4, CMin4, CMax4);
-        this.V7R = Numerics.Clamp(this.V7R + COff4, CMin4, CMax4);
-    }
-
-    /// <summary>
-    /// AVX2-only variant for executing <see cref="NormalizeColorsInPlace"/> and <see cref="RoundInPlace"/> in one step.
-    /// </summary>
-    [MethodImpl(InliningOptions.ShortMethod)]
-    public void NormalizeColorsAndRoundInPlaceVector8(float maximum)
-    {
-        var off = new Vector<float>(MathF.Ceiling(maximum * 0.5F));
-        var max = new Vector<float>(maximum);
-        
-        ref Vector<float> row0 = ref Unsafe.As<Vector4, Vector<float>>(ref this.V0L);
-        row0 = NormalizeAndRound(row0, off, max);
-            
-        ref Vector<float> row1 = ref Unsafe.As<Vector4, Vector<float>>(ref this.V1L);
-        row1 = NormalizeAndRound(row1, off, max);
-            
-        ref Vector<float> row2 = ref Unsafe.As<Vector4, Vector<float>>(ref this.V2L);
-        row2 = NormalizeAndRound(row2, off, max);
-            
-        ref Vector<float> row3 = ref Unsafe.As<Vector4, Vector<float>>(ref this.V3L);
-        row3 = NormalizeAndRound(row3, off, max);
-            
-        ref Vector<float> row4 = ref Unsafe.As<Vector4, Vector<float>>(ref this.V4L);
-        row4 = NormalizeAndRound(row4, off, max);
-            
-        ref Vector<float> row5 = ref Unsafe.As<Vector4, Vector<float>>(ref this.V5L);
-        row5 = NormalizeAndRound(row5, off, max);
-            
-        ref Vector<float> row6 = ref Unsafe.As<Vector4, Vector<float>>(ref this.V6L);
-        row6 = NormalizeAndRound(row6, off, max);
-            
-        ref Vector<float> row7 = ref Unsafe.As<Vector4, Vector<float>>(ref this.V7L);
-        row7 = NormalizeAndRound(row7, off, max);
-            
-    }
-
-    /// <summary>
-    /// Fill the block from 'source' doing short -> float conversion.
-    /// </summary>
-    public void LoadFromInt16Scalar(ref Block8x8 source)
-    {
-        ref short selfRef = ref Unsafe.As<Block8x8, short>(ref source);
-
-        this.V0L.X =  Unsafe.Add(ref selfRef, 0);
-        this.V0L.Y =  Unsafe.Add(ref selfRef, 1);
-        this.V0L.Z =  Unsafe.Add(ref selfRef, 2);
-        this.V0L.W =  Unsafe.Add(ref selfRef, 3);
-        this.V0R.X =  Unsafe.Add(ref selfRef, 4);
-        this.V0R.Y =  Unsafe.Add(ref selfRef, 5);
-        this.V0R.Z =  Unsafe.Add(ref selfRef, 6);
-        this.V0R.W =  Unsafe.Add(ref selfRef, 7);
-
-        this.V1L.X =  Unsafe.Add(ref selfRef, 8);
-        this.V1L.Y =  Unsafe.Add(ref selfRef, 9);
-        this.V1L.Z =  Unsafe.Add(ref selfRef, 10);
-        this.V1L.W =  Unsafe.Add(ref selfRef, 11);
-        this.V1R.X =  Unsafe.Add(ref selfRef, 12);
-        this.V1R.Y =  Unsafe.Add(ref selfRef, 13);
-        this.V1R.Z =  Unsafe.Add(ref selfRef, 14);
-        this.V1R.W =  Unsafe.Add(ref selfRef, 15);
-
-        this.V2L.X =  Unsafe.Add(ref selfRef, 16);
-        this.V2L.Y =  Unsafe.Add(ref selfRef, 17);
-        this.V2L.Z =  Unsafe.Add(ref selfRef, 18);
-        this.V2L.W =  Unsafe.Add(ref selfRef, 19);
-        this.V2R.X =  Unsafe.Add(ref selfRef, 20);
-        this.V2R.Y =  Unsafe.Add(ref selfRef, 21);
-        this.V2R.Z =  Unsafe.Add(ref selfRef, 22);
-        this.V2R.W =  Unsafe.Add(ref selfRef, 23);
-
-        this.V3L.X =  Unsafe.Add(ref selfRef, 24);
-        this.V3L.Y =  Unsafe.Add(ref selfRef, 25);
-        this.V3L.Z =  Unsafe.Add(ref selfRef, 26);
-        this.V3L.W =  Unsafe.Add(ref selfRef, 27);
-        this.V3R.X =  Unsafe.Add(ref selfRef, 28);
-        this.V3R.Y =  Unsafe.Add(ref selfRef, 29);
-        this.V3R.Z =  Unsafe.Add(ref selfRef, 30);
-        this.V3R.W =  Unsafe.Add(ref selfRef, 31);
-
-        this.V4L.X =  Unsafe.Add(ref selfRef, 32);
-        this.V4L.Y =  Unsafe.Add(ref selfRef, 33);
-        this.V4L.Z =  Unsafe.Add(ref selfRef, 34);
-        this.V4L.W =  Unsafe.Add(ref selfRef, 35);
-        this.V4R.X =  Unsafe.Add(ref selfRef, 36);
-        this.V4R.Y =  Unsafe.Add(ref selfRef, 37);
-        this.V4R.Z =  Unsafe.Add(ref selfRef, 38);
-        this.V4R.W =  Unsafe.Add(ref selfRef, 39);
-
-        this.V5L.X =  Unsafe.Add(ref selfRef, 40);
-        this.V5L.Y =  Unsafe.Add(ref selfRef, 41);
-        this.V5L.Z =  Unsafe.Add(ref selfRef, 42);
-        this.V5L.W =  Unsafe.Add(ref selfRef, 43);
-        this.V5R.X =  Unsafe.Add(ref selfRef, 44);
-        this.V5R.Y =  Unsafe.Add(ref selfRef, 45);
-        this.V5R.Z =  Unsafe.Add(ref selfRef, 46);
-        this.V5R.W =  Unsafe.Add(ref selfRef, 47);
-
-        this.V6L.X =  Unsafe.Add(ref selfRef, 48);
-        this.V6L.Y =  Unsafe.Add(ref selfRef, 49);
-        this.V6L.Z =  Unsafe.Add(ref selfRef, 50);
-        this.V6L.W =  Unsafe.Add(ref selfRef, 51);
-        this.V6R.X =  Unsafe.Add(ref selfRef, 52);
-        this.V6R.Y =  Unsafe.Add(ref selfRef, 53);
-        this.V6R.Z =  Unsafe.Add(ref selfRef, 54);
-        this.V6R.W =  Unsafe.Add(ref selfRef, 55);
-
-        this.V7L.X =  Unsafe.Add(ref selfRef, 56);
-        this.V7L.Y =  Unsafe.Add(ref selfRef, 57);
-        this.V7L.Z =  Unsafe.Add(ref selfRef, 58);
-        this.V7L.W =  Unsafe.Add(ref selfRef, 59);
-        this.V7R.X =  Unsafe.Add(ref selfRef, 60);
-        this.V7R.Y =  Unsafe.Add(ref selfRef, 61);
-        this.V7R.Z =  Unsafe.Add(ref selfRef, 62);
-        this.V7R.W =  Unsafe.Add(ref selfRef, 63);
-    }
-}
diff --git a/src/ImageSharp/Formats/Jpeg/Components/Block8x8F.Generated.tt b/src/ImageSharp/Formats/Jpeg/Components/Block8x8F.Generated.tt
deleted file mode 100644
index 19b795c23a..0000000000
--- a/src/ImageSharp/Formats/Jpeg/Components/Block8x8F.Generated.tt
+++ /dev/null
@@ -1,103 +0,0 @@
-<#
-// Copyright (c) Six Labors.
-// Licensed under the Six Labors Split License.
-#>
-<#@ template debug="false" hostspecific="false" language="C#" #>
-<#@ assembly name="System.Core" #>
-<#@ import namespace="System.Linq" #>
-<#@ import namespace="System.Text" #>
-<#@ import namespace="System.Collections.Generic" #>
-<#@ output extension=".cs" #>
-// Copyright (c) Six Labors.
-// Licensed under the Six Labors Split License.
-
-using System.Numerics;
-using System.Runtime.CompilerServices;
-
-// <auto-generated />
-<#
-char[] coordz = {'X', 'Y', 'Z', 'W'};
-#>
-namespace SixLabors.ImageSharp.Formats.Jpeg.Components;
-
-internal partial struct Block8x8F
-{
-	/// <summary>
-    /// Level shift by +maximum/2, clip to [0, maximum]
-    /// </summary>
-    public void NormalizeColorsInPlace(float maximum)
-    {
-        var CMin4 = new Vector4(0F);
-        var CMax4 = new Vector4(maximum);
-        var COff4 = new Vector4(MathF.Ceiling(maximum * 0.5F));
-
-        <#
-
-		PushIndent("        ");
-
-        for (int i = 0; i < 8; i++)
-        {
-            for (int j = 0; j < 2; j++)
-            {
-				char side = j == 0 ? 'L' : 'R';
-				Write($"this.V{i}{side} = Numerics.Clamp(this.V{i}{side} + COff4, CMin4, CMax4);\r\n");
-            }
-        }
-		PopIndent();
-		#>
-    }
-
-    /// <summary>
-    /// AVX2-only variant for executing <see cref="NormalizeColorsInPlace"/> and <see cref="RoundInPlace"/> in one step.
-    /// </summary>
-    [MethodImpl(InliningOptions.ShortMethod)]
-    public void NormalizeColorsAndRoundInPlaceVector8(float maximum)
-    {
-        var off = new Vector<float>(MathF.Ceiling(maximum * 0.5F));
-        var max = new Vector<float>(maximum);
-        <#
-
-        for (int i = 0; i < 8; i++)
-        {
-            #>
-
-        ref Vector<float> row<#=i#> = ref Unsafe.As<Vector4, Vector<float>>(ref this.V<#=i#>L);
-        row<#=i#> = NormalizeAndRound(row<#=i#>, off, max);
-            <#
-        }
-		#>
-
-    }
-
-    /// <summary>
-    /// Fill the block from 'source' doing short -> float conversion.
-    /// </summary>
-    public void LoadFromInt16Scalar(ref Block8x8 source)
-    {
-        ref short selfRef = ref Unsafe.As<Block8x8, short>(ref source);
-
-        <#
-		PushIndent("        ");
-        for (int j = 0; j < 8; j++)
-        {
-            for (int i = 0; i < 8; i++)
-            {
-                char destCoord = coordz[i % 4];
-                char destSide = (i / 4) % 2 == 0 ? 'L' : 'R';
-
-				if(j > 0 && i == 0){
-				WriteLine("");
-				}
-
-                char srcCoord = coordz[j % 4];
-                char srcSide = (j / 4) % 2 == 0 ? 'L' : 'R';
-
-                var expression = $"this.V{j}{destSide}.{destCoord} =  Unsafe.Add(ref selfRef, {j*8+i});\r\n";
-				Write(expression);
-
-            }
-        }
-		PopIndent();
-		#>
-    }
-}
diff --git a/src/ImageSharp/Formats/Jpeg/Components/Block8x8F.Intrinsic.cs b/src/ImageSharp/Formats/Jpeg/Components/Block8x8F.Intrinsic.cs
deleted file mode 100644
index 63be76f00f..0000000000
--- a/src/ImageSharp/Formats/Jpeg/Components/Block8x8F.Intrinsic.cs
+++ /dev/null
@@ -1,144 +0,0 @@
-// Copyright (c) Six Labors.
-// Licensed under the Six Labors Split License.
-
-using System.Numerics;
-using System.Runtime.CompilerServices;
-using System.Runtime.InteropServices;
-using System.Runtime.Intrinsics;
-using System.Runtime.Intrinsics.X86;
-
-namespace SixLabors.ImageSharp.Formats.Jpeg.Components;
-
-internal partial struct Block8x8F
-{
-    /// <summary>
-    /// A number of rows of 8 scalar coefficients each in <see cref="Block8x8F"/>
-    /// </summary>
-    public const int RowCount = 8;
-
-    [FieldOffset(0)]
-    public Vector256<float> V0;
-    [FieldOffset(32)]
-    public Vector256<float> V1;
-    [FieldOffset(64)]
-    public Vector256<float> V2;
-    [FieldOffset(96)]
-    public Vector256<float> V3;
-    [FieldOffset(128)]
-    public Vector256<float> V4;
-    [FieldOffset(160)]
-    public Vector256<float> V5;
-    [FieldOffset(192)]
-    public Vector256<float> V6;
-    [FieldOffset(224)]
-    public Vector256<float> V7;
-
-    private static unsafe void MultiplyIntoInt16_Avx2(ref Block8x8F a, ref Block8x8F b, ref Block8x8 dest)
-    {
-        DebugGuard.IsTrue(Avx2.IsSupported, "Avx2 support is required to run this operation!");
-
-        ref Vector256<float> aBase = ref a.V0;
-        ref Vector256<float> bBase = ref b.V0;
-
-        ref Vector256<short> destRef = ref dest.V01;
-        Vector256<int> multiplyIntoInt16ShuffleMask = Vector256.Create(0, 1, 4, 5, 2, 3, 6, 7);
-
-        for (nuint i = 0; i < 8; i += 2)
-        {
-            Vector256<int> row0 = Avx.ConvertToVector256Int32(Avx.Multiply(Unsafe.Add(ref aBase, i + 0), Unsafe.Add(ref bBase, i + 0)));
-            Vector256<int> row1 = Avx.ConvertToVector256Int32(Avx.Multiply(Unsafe.Add(ref aBase, i + 1), Unsafe.Add(ref bBase, i + 1)));
-
-            Vector256<short> row = Avx2.PackSignedSaturate(row0, row1);
-            row = Avx2.PermuteVar8x32(row.AsInt32(), multiplyIntoInt16ShuffleMask).AsInt16();
-
-            Unsafe.Add(ref destRef, i / 2) = row;
-        }
-    }
-
-    private static void MultiplyIntoInt16_Sse2(ref Block8x8F a, ref Block8x8F b, ref Block8x8 dest)
-    {
-        DebugGuard.IsTrue(Sse2.IsSupported, "Sse2 support is required to run this operation!");
-
-        ref Vector128<float> aBase = ref Unsafe.As<Block8x8F, Vector128<float>>(ref a);
-        ref Vector128<float> bBase = ref Unsafe.As<Block8x8F, Vector128<float>>(ref b);
-
-        ref Vector128<short> destBase = ref Unsafe.As<Block8x8, Vector128<short>>(ref dest);
-
-        for (nuint i = 0; i < 16; i += 2)
-        {
-            Vector128<int> left = Sse2.ConvertToVector128Int32(Sse.Multiply(Unsafe.Add(ref aBase, i + 0), Unsafe.Add(ref bBase, i + 0)));
-            Vector128<int> right = Sse2.ConvertToVector128Int32(Sse.Multiply(Unsafe.Add(ref aBase, i + 1), Unsafe.Add(ref bBase, i + 1)));
-
-            Vector128<short> row = Sse2.PackSignedSaturate(left, right);
-            Unsafe.Add(ref destBase, i / 2) = row;
-        }
-    }
-
-    private void TransposeInplace_Avx()
-    {
-        // https://stackoverflow.com/questions/25622745/transpose-an-8x8-float-using-avx-avx2/25627536#25627536
-        Vector256<float> r0 = Avx.InsertVector128(
-            this.V0,
-            Unsafe.As<Vector4, Vector128<float>>(ref this.V4L),
-            1);
-
-        Vector256<float> r1 = Avx.InsertVector128(
-           this.V1,
-           Unsafe.As<Vector4, Vector128<float>>(ref this.V5L),
-           1);
-
-        Vector256<float> r2 = Avx.InsertVector128(
-           this.V2,
-           Unsafe.As<Vector4, Vector128<float>>(ref this.V6L),
-           1);
-
-        Vector256<float> r3 = Avx.InsertVector128(
-           this.V3,
-           Unsafe.As<Vector4, Vector128<float>>(ref this.V7L),
-           1);
-
-        Vector256<float> r4 = Avx.InsertVector128(
-           Unsafe.As<Vector4, Vector128<float>>(ref this.V0R).ToVector256(),
-           Unsafe.As<Vector4, Vector128<float>>(ref this.V4R),
-           1);
-
-        Vector256<float> r5 = Avx.InsertVector128(
-           Unsafe.As<Vector4, Vector128<float>>(ref this.V1R).ToVector256(),
-           Unsafe.As<Vector4, Vector128<float>>(ref this.V5R),
-           1);
-
-        Vector256<float> r6 = Avx.InsertVector128(
-           Unsafe.As<Vector4, Vector128<float>>(ref this.V2R).ToVector256(),
-           Unsafe.As<Vector4, Vector128<float>>(ref this.V6R),
-           1);
-
-        Vector256<float> r7 = Avx.InsertVector128(
-           Unsafe.As<Vector4, Vector128<float>>(ref this.V3R).ToVector256(),
-           Unsafe.As<Vector4, Vector128<float>>(ref this.V7R),
-           1);
-
-        Vector256<float> t0 = Avx.UnpackLow(r0, r1);
-        Vector256<float> t2 = Avx.UnpackLow(r2, r3);
-        Vector256<float> v = Avx.Shuffle(t0, t2, 0x4E);
-        this.V0 = Avx.Blend(t0, v, 0xCC);
-        this.V1 = Avx.Blend(t2, v, 0x33);
-
-        Vector256<float> t4 = Avx.UnpackLow(r4, r5);
-        Vector256<float> t6 = Avx.UnpackLow(r6, r7);
-        v = Avx.Shuffle(t4, t6, 0x4E);
-        this.V4 = Avx.Blend(t4, v, 0xCC);
-        this.V5 = Avx.Blend(t6, v, 0x33);
-
-        Vector256<float> t1 = Avx.UnpackHigh(r0, r1);
-        Vector256<float> t3 = Avx.UnpackHigh(r2, r3);
-        v = Avx.Shuffle(t1, t3, 0x4E);
-        this.V2 = Avx.Blend(t1, v, 0xCC);
-        this.V3 = Avx.Blend(t3, v, 0x33);
-
-        Vector256<float> t5 = Avx.UnpackHigh(r4, r5);
-        Vector256<float> t7 = Avx.UnpackHigh(r6, r7);
-        v = Avx.Shuffle(t5, t7, 0x4E);
-        this.V6 = Avx.Blend(t5, v, 0xCC);
-        this.V7 = Avx.Blend(t7, v, 0x33);
-    }
-}
diff --git a/src/ImageSharp/Formats/Jpeg/Components/Block8x8F.ScaledCopy.cs b/src/ImageSharp/Formats/Jpeg/Components/Block8x8F.ScaledCopy.cs
index efc1dbd729..179f9aa287 100644
--- a/src/ImageSharp/Formats/Jpeg/Components/Block8x8F.ScaledCopy.cs
+++ b/src/ImageSharp/Formats/Jpeg/Components/Block8x8F.ScaledCopy.cs
@@ -57,19 +57,19 @@ internal partial struct Block8x8F
             ref Vector4 dTopLeft = ref Unsafe.As<Vector2, Vector4>(ref Unsafe.Add(ref destBase, offset));
             ref Vector4 dBottomLeft = ref Unsafe.As<Vector2, Vector4>(ref Unsafe.Add(ref destBase, offset + destStride));
 
-            var xyLeft = new Vector4(sLeft.X);
+            Vector4 xyLeft = new(sLeft.X);
             xyLeft.Z = sLeft.Y;
             xyLeft.W = sLeft.Y;
 
-            var zwLeft = new Vector4(sLeft.Z);
+            Vector4 zwLeft = new(sLeft.Z);
             zwLeft.Z = sLeft.W;
             zwLeft.W = sLeft.W;
 
-            var xyRight = new Vector4(sRight.X);
+            Vector4 xyRight = new(sRight.X);
             xyRight.Z = sRight.Y;
             xyRight.W = sRight.Y;
 
-            var zwRight = new Vector4(sRight.Z);
+            Vector4 zwRight = new(sRight.Z);
             zwRight.Z = sRight.W;
             zwRight.W = sRight.W;
 
diff --git a/src/ImageSharp/Formats/Jpeg/Components/Block8x8F.Vector128.cs b/src/ImageSharp/Formats/Jpeg/Components/Block8x8F.Vector128.cs
new file mode 100644
index 0000000000..d4c0398d97
--- /dev/null
+++ b/src/ImageSharp/Formats/Jpeg/Components/Block8x8F.Vector128.cs
@@ -0,0 +1,93 @@
+// Copyright (c) Six Labors.
+// Licensed under the Six Labors Split License.
+
+using System.Runtime.CompilerServices;
+using System.Runtime.Intrinsics;
+using SixLabors.ImageSharp.Common.Helpers;
+
+namespace SixLabors.ImageSharp.Formats.Jpeg.Components;
+
+/// <content>
+/// <see cref="Vector128{Single}"/> version of <see cref="Block8x8F"/>.
+/// </content>
+internal partial struct Block8x8F
+{
+    /// <summary>
+    /// <see cref="Vector128{Single}"/> version of <see cref="NormalizeColorsInPlace(float)"/> and <see cref="RoundInPlace()"/>.
+    /// </summary>
+    /// <param name="maximum">The maximum value to normalize to.</param>
+    [MethodImpl(InliningOptions.ShortMethod)]
+    public void NormalizeColorsAndRoundInPlaceVector128(float maximum)
+    {
+        Vector128<float> max = Vector128.Create(maximum);
+        Vector128<float> off = Vector128.Ceiling(max * .5F);
+
+        this.V0L = NormalizeAndRoundVector128(this.V0L.AsVector128(), off, max).AsVector4();
+        this.V0R = NormalizeAndRoundVector128(this.V0R.AsVector128(), off, max).AsVector4();
+        this.V1L = NormalizeAndRoundVector128(this.V1L.AsVector128(), off, max).AsVector4();
+        this.V1R = NormalizeAndRoundVector128(this.V1R.AsVector128(), off, max).AsVector4();
+        this.V2L = NormalizeAndRoundVector128(this.V2L.AsVector128(), off, max).AsVector4();
+        this.V2R = NormalizeAndRoundVector128(this.V2R.AsVector128(), off, max).AsVector4();
+        this.V3L = NormalizeAndRoundVector128(this.V3L.AsVector128(), off, max).AsVector4();
+        this.V3R = NormalizeAndRoundVector128(this.V3R.AsVector128(), off, max).AsVector4();
+        this.V4L = NormalizeAndRoundVector128(this.V4L.AsVector128(), off, max).AsVector4();
+        this.V4R = NormalizeAndRoundVector128(this.V4R.AsVector128(), off, max).AsVector4();
+        this.V5L = NormalizeAndRoundVector128(this.V5L.AsVector128(), off, max).AsVector4();
+        this.V5R = NormalizeAndRoundVector128(this.V5R.AsVector128(), off, max).AsVector4();
+        this.V6L = NormalizeAndRoundVector128(this.V6L.AsVector128(), off, max).AsVector4();
+        this.V6R = NormalizeAndRoundVector128(this.V6R.AsVector128(), off, max).AsVector4();
+        this.V7L = NormalizeAndRoundVector128(this.V7L.AsVector128(), off, max).AsVector4();
+        this.V7R = NormalizeAndRoundVector128(this.V7R.AsVector128(), off, max).AsVector4();
+    }
+
+    /// <summary>
+    /// Loads values from <paramref name="source"/> using extended AVX2 intrinsics.
+    /// </summary>
+    /// <param name="source">The source <see cref="Block8x8"/></param>
+    public void LoadFromInt16ExtendedVector128(ref Block8x8 source)
+    {
+        DebugGuard.IsTrue(Vector128.IsHardwareAccelerated, "Vector128 support is required to run this operation!");
+
+        ref Vector128<short> srcBase = ref Unsafe.As<Block8x8, Vector128<short>>(ref source);
+        ref Vector128<float> destBase = ref Unsafe.As<Block8x8F, Vector128<float>>(ref this);
+
+        // Only 8 iterations, one per 128b short block
+        for (nuint i = 0; i < 8; i++)
+        {
+            Vector128<short> src = Unsafe.Add(ref srcBase, i);
+
+            // Step 1: Widen short -> int
+            Vector128<int> lower = Vector128.WidenLower(src); // lower 4 shorts -> 4 ints
+            Vector128<int> upper = Vector128.WidenUpper(src); // upper 4 shorts -> 4 ints
+
+            // Step 2: Convert int -> float
+            Vector128<float> lowerF = Vector128.ConvertToSingle(lower);
+            Vector128<float> upperF = Vector128.ConvertToSingle(upper);
+
+            // Step 3: Store to destination (this is 16 lanes -> two Vector128<float> blocks)
+            Unsafe.Add(ref destBase, (i * 2) + 0) = lowerF;
+            Unsafe.Add(ref destBase, (i * 2) + 1) = upperF;
+        }
+    }
+
+    [MethodImpl(InliningOptions.ShortMethod)]
+    private static Vector128<float> NormalizeAndRoundVector128(Vector128<float> value, Vector128<float> off, Vector128<float> max)
+        => Vector128_.RoundToNearestInteger(Vector128_.Clamp(value + off, Vector128<float>.Zero, max));
+
+    private static void MultiplyIntoInt16Vector128(ref Block8x8F a, ref Block8x8F b, ref Block8x8 dest)
+    {
+        DebugGuard.IsTrue(Vector128.IsHardwareAccelerated, "Vector128 support is required to run this operation!");
+
+        ref Vector128<float> aBase = ref Unsafe.As<Block8x8F, Vector128<float>>(ref a);
+        ref Vector128<float> bBase = ref Unsafe.As<Block8x8F, Vector128<float>>(ref b);
+        ref Vector128<short> destBase = ref Unsafe.As<Block8x8, Vector128<short>>(ref dest);
+
+        for (nuint i = 0; i < 16; i += 2)
+        {
+            Vector128<int> left = Vector128_.ConvertToInt32RoundToEven(Unsafe.Add(ref aBase, i + 0) * Unsafe.Add(ref bBase, i + 0));
+            Vector128<int> right = Vector128_.ConvertToInt32RoundToEven(Unsafe.Add(ref aBase, i + 1) * Unsafe.Add(ref bBase, i + 1));
+
+            Unsafe.Add(ref destBase, i / 2) = Vector128_.PackSignedSaturate(left, right);
+        }
+    }
+}
diff --git a/src/ImageSharp/Formats/Jpeg/Components/Block8x8F.Vector256.cs b/src/ImageSharp/Formats/Jpeg/Components/Block8x8F.Vector256.cs
new file mode 100644
index 0000000000..2aaf5c9431
--- /dev/null
+++ b/src/ImageSharp/Formats/Jpeg/Components/Block8x8F.Vector256.cs
@@ -0,0 +1,157 @@
+// Copyright (c) Six Labors.
+// Licensed under the Six Labors Split License.
+
+using System.Runtime.CompilerServices;
+using System.Runtime.InteropServices;
+using System.Runtime.Intrinsics;
+using System.Runtime.Intrinsics.X86;
+using SixLabors.ImageSharp.Common.Helpers;
+
+namespace SixLabors.ImageSharp.Formats.Jpeg.Components;
+
+/// <content>
+/// <see cref="Vector128{Single}"/> version of <see cref="Block8x8F"/>.
+/// </content>
+internal partial struct Block8x8F
+{
+    /// <summary>
+    /// A number of rows of 8 scalar coefficients each in <see cref="Block8x8F"/>
+    /// </summary>
+    public const int RowCount = 8;
+
+#pragma warning disable SA1310 // Field names should not contain underscore
+    [FieldOffset(0)]
+    public Vector256<float> V256_0;
+    [FieldOffset(32)]
+    public Vector256<float> V256_1;
+    [FieldOffset(64)]
+    public Vector256<float> V256_2;
+    [FieldOffset(96)]
+    public Vector256<float> V256_3;
+    [FieldOffset(128)]
+    public Vector256<float> V256_4;
+    [FieldOffset(160)]
+    public Vector256<float> V256_5;
+    [FieldOffset(192)]
+    public Vector256<float> V256_6;
+    [FieldOffset(224)]
+    public Vector256<float> V256_7;
+#pragma warning restore SA1310 // Field names should not contain underscore
+
+    /// <summary>
+    /// <see cref="Vector256{Single}"/> version of <see cref="NormalizeColorsInPlace(float)"/> and <see cref="RoundInPlace()"/>.
+    /// </summary>
+    /// <param name="maximum">The maximum value to normalize to.</param>
+    [MethodImpl(InliningOptions.ShortMethod)]
+    public void NormalizeColorsAndRoundInPlaceVector256(float maximum)
+    {
+        Vector256<float> max = Vector256.Create(maximum);
+        Vector256<float> off = Vector256.Ceiling(max * .5F);
+
+        this.V256_0 = NormalizeAndRoundVector256(this.V256_0, off, max);
+        this.V256_1 = NormalizeAndRoundVector256(this.V256_1, off, max);
+        this.V256_2 = NormalizeAndRoundVector256(this.V256_2, off, max);
+        this.V256_3 = NormalizeAndRoundVector256(this.V256_3, off, max);
+        this.V256_4 = NormalizeAndRoundVector256(this.V256_4, off, max);
+        this.V256_5 = NormalizeAndRoundVector256(this.V256_5, off, max);
+        this.V256_6 = NormalizeAndRoundVector256(this.V256_6, off, max);
+        this.V256_7 = NormalizeAndRoundVector256(this.V256_7, off, max);
+    }
+
+    /// <summary>
+    /// Loads values from <paramref name="source"/> using <see cref="Vector256{T}"/> intrinsics.
+    /// </summary>
+    /// <param name="source">The source <see cref="Block8x8"/></param>
+    public void LoadFromInt16ExtendedVector256(ref Block8x8 source)
+    {
+        DebugGuard.IsTrue(
+            Vector256.IsHardwareAccelerated,
+            "LoadFromInt16ExtendedVector256 only works on Vector256 compatible architecture!");
+
+        ref short sRef = ref Unsafe.As<Block8x8, short>(ref source);
+        ref Vector256<float> dRef = ref Unsafe.As<Block8x8F, Vector256<float>>(ref this);
+
+        // Vector256<ushort>.Count == 16
+        // We can process 2 block rows in a single step
+        Vector256<int> top = Vector256_.Widen(Vector128.LoadUnsafe(ref sRef));
+        Vector256<int> bottom = Vector256_.Widen(Vector128.LoadUnsafe(ref sRef, (nuint)Vector256<int>.Count));
+        dRef = Vector256.ConvertToSingle(top);
+        Unsafe.Add(ref dRef, 1) = Vector256.ConvertToSingle(bottom);
+
+        top = Vector256_.Widen(Vector128.LoadUnsafe(ref sRef, (nuint)(Vector256<int>.Count * 2)));
+        bottom = Vector256_.Widen(Vector128.LoadUnsafe(ref sRef, (nuint)(Vector256<int>.Count * 3)));
+        Unsafe.Add(ref dRef, 2) = Vector256.ConvertToSingle(top);
+        Unsafe.Add(ref dRef, 3) = Vector256.ConvertToSingle(bottom);
+
+        top = Vector256_.Widen(Vector128.LoadUnsafe(ref sRef, (nuint)(Vector256<int>.Count * 4)));
+        bottom = Vector256_.Widen(Vector128.LoadUnsafe(ref sRef, (nuint)(Vector256<int>.Count * 5)));
+        Unsafe.Add(ref dRef, 4) = Vector256.ConvertToSingle(top);
+        Unsafe.Add(ref dRef, 5) = Vector256.ConvertToSingle(bottom);
+
+        top = Vector256_.Widen(Vector128.LoadUnsafe(ref sRef, (nuint)(Vector256<int>.Count * 6)));
+        bottom = Vector256_.Widen(Vector128.LoadUnsafe(ref sRef, (nuint)(Vector256<int>.Count * 7)));
+        Unsafe.Add(ref dRef, 6) = Vector256.ConvertToSingle(top);
+        Unsafe.Add(ref dRef, 7) = Vector256.ConvertToSingle(bottom);
+    }
+
+    [MethodImpl(InliningOptions.ShortMethod)]
+    private static Vector256<float> NormalizeAndRoundVector256(Vector256<float> value, Vector256<float> off, Vector256<float> max)
+        => Vector256_.RoundToNearestInteger(Vector256_.Clamp(value + off, Vector256<float>.Zero, max));
+
+    private static unsafe void MultiplyIntoInt16Vector256(ref Block8x8F a, ref Block8x8F b, ref Block8x8 dest)
+    {
+        DebugGuard.IsTrue(Vector256.IsHardwareAccelerated, "Vector256 support is required to run this operation!");
+
+        ref Vector256<float> aBase = ref a.V256_0;
+        ref Vector256<float> bBase = ref b.V256_0;
+        ref Vector256<short> destRef = ref dest.V01;
+
+        for (nuint i = 0; i < 8; i += 2)
+        {
+            Vector256<int> row0 = Vector256_.ConvertToInt32RoundToEven(Unsafe.Add(ref aBase, i + 0) * Unsafe.Add(ref bBase, i + 0));
+            Vector256<int> row1 = Vector256_.ConvertToInt32RoundToEven(Unsafe.Add(ref aBase, i + 1) * Unsafe.Add(ref bBase, i + 1));
+
+            Vector256<short> row = Vector256_.PackSignedSaturate(row0, row1);
+            row = Vector256.Shuffle(row.AsInt32(), Vector256.Create(0, 1, 4, 5, 2, 3, 6, 7)).AsInt16();
+
+            Unsafe.Add(ref destRef, i / 2) = row;
+        }
+    }
+
+    private void TransposeInPlaceVector256()
+    {
+        // https://stackoverflow.com/questions/25622745/transpose-an-8x8-float-using-avx-avx2/25627536#25627536
+        Vector256<float> r0 = this.V256_0.WithUpper(this.V4L.AsVector128());
+        Vector256<float> r1 = this.V256_1.WithUpper(this.V5L.AsVector128());
+        Vector256<float> r2 = this.V256_2.WithUpper(this.V6L.AsVector128());
+        Vector256<float> r3 = this.V256_3.WithUpper(this.V7L.AsVector128());
+        Vector256<float> r4 = this.V0R.AsVector128().ToVector256().WithUpper(this.V4R.AsVector128());
+        Vector256<float> r5 = this.V1R.AsVector128().ToVector256().WithUpper(this.V5R.AsVector128());
+        Vector256<float> r6 = this.V2R.AsVector128().ToVector256().WithUpper(this.V6R.AsVector128());
+        Vector256<float> r7 = this.V3R.AsVector128().ToVector256().WithUpper(this.V7R.AsVector128());
+
+        Vector256<float> t0 = Avx.UnpackLow(r0, r1);
+        Vector256<float> t2 = Avx.UnpackLow(r2, r3);
+        Vector256<float> v = Avx.Shuffle(t0, t2, 0x4E);
+        this.V256_0 = Avx.Blend(t0, v, 0xCC);
+        this.V256_1 = Avx.Blend(t2, v, 0x33);
+
+        Vector256<float> t4 = Avx.UnpackLow(r4, r5);
+        Vector256<float> t6 = Avx.UnpackLow(r6, r7);
+        v = Avx.Shuffle(t4, t6, 0x4E);
+        this.V256_4 = Avx.Blend(t4, v, 0xCC);
+        this.V256_5 = Avx.Blend(t6, v, 0x33);
+
+        Vector256<float> t1 = Avx.UnpackHigh(r0, r1);
+        Vector256<float> t3 = Avx.UnpackHigh(r2, r3);
+        v = Avx.Shuffle(t1, t3, 0x4E);
+        this.V256_2 = Avx.Blend(t1, v, 0xCC);
+        this.V256_3 = Avx.Blend(t3, v, 0x33);
+
+        Vector256<float> t5 = Avx.UnpackHigh(r4, r5);
+        Vector256<float> t7 = Avx.UnpackHigh(r6, r7);
+        v = Avx.Shuffle(t5, t7, 0x4E);
+        this.V256_6 = Avx.Blend(t5, v, 0xCC);
+        this.V256_7 = Avx.Blend(t7, v, 0x33);
+    }
+}
diff --git a/src/ImageSharp/Formats/Jpeg/Components/Block8x8F.cs b/src/ImageSharp/Formats/Jpeg/Components/Block8x8F.cs
index 018df5f9f4..49b519201f 100644
--- a/src/ImageSharp/Formats/Jpeg/Components/Block8x8F.cs
+++ b/src/ImageSharp/Formats/Jpeg/Components/Block8x8F.cs
@@ -5,7 +5,6 @@ using System.Numerics;
 using System.Runtime.CompilerServices;
 using System.Runtime.InteropServices;
 using System.Runtime.Intrinsics;
-using System.Runtime.Intrinsics.X86;
 using System.Text;
 using SixLabors.ImageSharp.Common.Helpers;
 
@@ -23,7 +22,6 @@ internal partial struct Block8x8F : IEquatable<Block8x8F>
     /// </summary>
     public const int Size = 64;
 
-#pragma warning disable SA1600 // ElementsMustBeDocumented
     [FieldOffset(0)]
     public Vector4 V0L;
     [FieldOffset(16)]
@@ -63,7 +61,6 @@ internal partial struct Block8x8F : IEquatable<Block8x8F>
     public Vector4 V7L;
     [FieldOffset(240)]
     public Vector4 V7R;
-#pragma warning restore SA1600 // ElementsMustBeDocumented
 
     /// <summary>
     /// Get/Set scalar elements at a given index
@@ -157,17 +154,17 @@ internal partial struct Block8x8F : IEquatable<Block8x8F>
     [MethodImpl(InliningOptions.ShortMethod)]
     public void MultiplyInPlace(float value)
     {
-        if (Avx.IsSupported)
+        if (Vector256.IsHardwareAccelerated)
         {
             Vector256<float> valueVec = Vector256.Create(value);
-            this.V0 = Avx.Multiply(this.V0, valueVec);
-            this.V1 = Avx.Multiply(this.V1, valueVec);
-            this.V2 = Avx.Multiply(this.V2, valueVec);
-            this.V3 = Avx.Multiply(this.V3, valueVec);
-            this.V4 = Avx.Multiply(this.V4, valueVec);
-            this.V5 = Avx.Multiply(this.V5, valueVec);
-            this.V6 = Avx.Multiply(this.V6, valueVec);
-            this.V7 = Avx.Multiply(this.V7, valueVec);
+            this.V256_0 *= valueVec;
+            this.V256_1 *= valueVec;
+            this.V256_2 *= valueVec;
+            this.V256_3 *= valueVec;
+            this.V256_4 *= valueVec;
+            this.V256_5 *= valueVec;
+            this.V256_6 *= valueVec;
+            this.V256_7 *= valueVec;
         }
         else
         {
@@ -198,16 +195,16 @@ internal partial struct Block8x8F : IEquatable<Block8x8F>
     [MethodImpl(InliningOptions.ShortMethod)]
     public unsafe void MultiplyInPlace(ref Block8x8F other)
     {
-        if (Avx.IsSupported)
+        if (Vector256.IsHardwareAccelerated)
         {
-            this.V0 = Avx.Multiply(this.V0, other.V0);
-            this.V1 = Avx.Multiply(this.V1, other.V1);
-            this.V2 = Avx.Multiply(this.V2, other.V2);
-            this.V3 = Avx.Multiply(this.V3, other.V3);
-            this.V4 = Avx.Multiply(this.V4, other.V4);
-            this.V5 = Avx.Multiply(this.V5, other.V5);
-            this.V6 = Avx.Multiply(this.V6, other.V6);
-            this.V7 = Avx.Multiply(this.V7, other.V7);
+            this.V256_0 *= other.V256_0;
+            this.V256_1 *= other.V256_1;
+            this.V256_2 *= other.V256_2;
+            this.V256_3 *= other.V256_3;
+            this.V256_4 *= other.V256_4;
+            this.V256_5 *= other.V256_5;
+            this.V256_6 *= other.V256_6;
+            this.V256_7 *= other.V256_7;
         }
         else
         {
@@ -237,17 +234,17 @@ internal partial struct Block8x8F : IEquatable<Block8x8F>
     [MethodImpl(InliningOptions.ShortMethod)]
     public void AddInPlace(float value)
     {
-        if (Avx.IsSupported)
+        if (Vector256.IsHardwareAccelerated)
         {
             Vector256<float> valueVec = Vector256.Create(value);
-            this.V0 = Avx.Add(this.V0, valueVec);
-            this.V1 = Avx.Add(this.V1, valueVec);
-            this.V2 = Avx.Add(this.V2, valueVec);
-            this.V3 = Avx.Add(this.V3, valueVec);
-            this.V4 = Avx.Add(this.V4, valueVec);
-            this.V5 = Avx.Add(this.V5, valueVec);
-            this.V6 = Avx.Add(this.V6, valueVec);
-            this.V7 = Avx.Add(this.V7, valueVec);
+            this.V256_0 += valueVec;
+            this.V256_1 += valueVec;
+            this.V256_2 += valueVec;
+            this.V256_3 += valueVec;
+            this.V256_4 += valueVec;
+            this.V256_5 += valueVec;
+            this.V256_6 += valueVec;
+            this.V256_7 += valueVec;
         }
         else
         {
@@ -279,15 +276,15 @@ internal partial struct Block8x8F : IEquatable<Block8x8F>
     /// <param name="qt">The quantization table.</param>
     public static void Quantize(ref Block8x8F block, ref Block8x8 dest, ref Block8x8F qt)
     {
-        if (Avx2.IsSupported)
+        if (Vector256.IsHardwareAccelerated)
         {
-            MultiplyIntoInt16_Avx2(ref block, ref qt, ref dest);
+            MultiplyIntoInt16Vector256(ref block, ref qt, ref dest);
             ZigZag.ApplyTransposingZigZagOrderingAvx2(ref dest);
         }
-        else if (Ssse3.IsSupported)
+        else if (Vector128.IsHardwareAccelerated)
         {
-            MultiplyIntoInt16_Sse2(ref block, ref qt, ref dest);
-            ZigZag.ApplyTransposingZigZagOrderingSsse3(ref dest);
+            MultiplyIntoInt16Vector128(ref block, ref qt, ref dest);
+            ZigZag.ApplyTransposingZigZagOrderingVector128(ref dest);
         }
         else
         {
@@ -332,9 +329,13 @@ internal partial struct Block8x8F : IEquatable<Block8x8F>
     /// <param name="maximum">The maximum value.</param>
     public void NormalizeColorsAndRoundInPlace(float maximum)
     {
-        if (SimdUtils.HasVector8)
+        if (Vector256.IsHardwareAccelerated)
         {
-            this.NormalizeColorsAndRoundInPlaceVector8(maximum);
+            this.NormalizeColorsAndRoundInPlaceVector256(maximum);
+        }
+        else if (Vector128.IsHardwareAccelerated)
+        {
+            this.NormalizeColorsAndRoundInPlaceVector128(maximum);
         }
         else
         {
@@ -343,17 +344,32 @@ internal partial struct Block8x8F : IEquatable<Block8x8F>
         }
     }
 
-    public void DE_NormalizeColors(float maximum)
+    /// <summary>
+    /// Level shift by +maximum/2, clip to [0, maximum]
+    /// </summary>
+    /// <param name="maximum">The maximum value to normalize to.</param>
+    public void NormalizeColorsInPlace(float maximum)
     {
-        if (SimdUtils.HasVector8)
-        {
-            this.NormalizeColorsAndRoundInPlaceVector8(maximum);
-        }
-        else
-        {
-            this.NormalizeColorsInPlace(maximum);
-            this.RoundInPlace();
-        }
+        Vector4 min = Vector4.Zero;
+        Vector4 max = new(maximum);
+        Vector4 off = new(MathF.Ceiling(maximum * 0.5F));
+
+        this.V0L = Vector4.Clamp(this.V0L + off, min, max);
+        this.V0R = Vector4.Clamp(this.V0R + off, min, max);
+        this.V1L = Vector4.Clamp(this.V1L + off, min, max);
+        this.V1R = Vector4.Clamp(this.V1R + off, min, max);
+        this.V2L = Vector4.Clamp(this.V2L + off, min, max);
+        this.V2R = Vector4.Clamp(this.V2R + off, min, max);
+        this.V3L = Vector4.Clamp(this.V3L + off, min, max);
+        this.V3R = Vector4.Clamp(this.V3R + off, min, max);
+        this.V4L = Vector4.Clamp(this.V4L + off, min, max);
+        this.V4R = Vector4.Clamp(this.V4R + off, min, max);
+        this.V5L = Vector4.Clamp(this.V5L + off, min, max);
+        this.V5R = Vector4.Clamp(this.V5R + off, min, max);
+        this.V6L = Vector4.Clamp(this.V6L + off, min, max);
+        this.V6R = Vector4.Clamp(this.V6R + off, min, max);
+        this.V7L = Vector4.Clamp(this.V7L + off, min, max);
+        this.V7R = Vector4.Clamp(this.V7R + off, min, max);
     }
 
     /// <summary>
@@ -370,9 +386,14 @@ internal partial struct Block8x8F : IEquatable<Block8x8F>
     [MethodImpl(InliningOptions.ShortMethod)]
     public void LoadFrom(ref Block8x8 source)
     {
-        if (SimdUtils.HasVector8)
+        if (Vector256.IsHardwareAccelerated)
         {
-            this.LoadFromInt16ExtendedAvx2(ref source);
+            this.LoadFromInt16ExtendedVector256(ref source);
+            return;
+        }
+        else if (Vector128.IsHardwareAccelerated)
+        {
+            this.LoadFromInt16ExtendedVector128(ref source);
             return;
         }
 
@@ -380,39 +401,84 @@ internal partial struct Block8x8F : IEquatable<Block8x8F>
     }
 
     /// <summary>
-    /// Loads values from <paramref name="source"/> using extended AVX2 intrinsics.
+    /// Fill the block from <paramref name="source"/> doing short -&gt; float conversion.
     /// </summary>
-    /// <param name="source">The source <see cref="Block8x8"/></param>
-    public void LoadFromInt16ExtendedAvx2(ref Block8x8 source)
+    /// <param name="source">The source block</param>
+    public void LoadFromInt16Scalar(ref Block8x8 source)
     {
-        DebugGuard.IsTrue(
-            Avx2.IsSupported,
-            "LoadFromUInt16ExtendedAvx2 only works on AVX2 compatible architecture!");
-
-        ref short sRef = ref Unsafe.As<Block8x8, short>(ref source);
-        ref Vector256<float> dRef = ref Unsafe.As<Block8x8F, Vector256<float>>(ref this);
-
-        // Vector256<ushort>.Count == 16 on AVX2
-        // We can process 2 block rows in a single step
-        Vector256<int> top = Avx2.ConvertToVector256Int32(Vector128.LoadUnsafe(ref sRef));
-        Vector256<int> bottom = Avx2.ConvertToVector256Int32(Vector128.LoadUnsafe(ref sRef, (nuint)Vector256<int>.Count));
-        dRef = Avx.ConvertToVector256Single(top);
-        Unsafe.Add(ref dRef, 1) = Avx.ConvertToVector256Single(bottom);
-
-        top = Avx2.ConvertToVector256Int32(Vector128.LoadUnsafe(ref sRef, (nuint)(Vector256<int>.Count * 2)));
-        bottom = Avx2.ConvertToVector256Int32(Vector128.LoadUnsafe(ref sRef, (nuint)(Vector256<int>.Count * 3)));
-        Unsafe.Add(ref dRef, 2) = Avx.ConvertToVector256Single(top);
-        Unsafe.Add(ref dRef, 3) = Avx.ConvertToVector256Single(bottom);
-
-        top = Avx2.ConvertToVector256Int32(Vector128.LoadUnsafe(ref sRef, (nuint)(Vector256<int>.Count * 4)));
-        bottom = Avx2.ConvertToVector256Int32(Vector128.LoadUnsafe(ref sRef, (nuint)(Vector256<int>.Count * 5)));
-        Unsafe.Add(ref dRef, 4) = Avx.ConvertToVector256Single(top);
-        Unsafe.Add(ref dRef, 5) = Avx.ConvertToVector256Single(bottom);
-
-        top = Avx2.ConvertToVector256Int32(Vector128.LoadUnsafe(ref sRef, (nuint)(Vector256<int>.Count * 6)));
-        bottom = Avx2.ConvertToVector256Int32(Vector128.LoadUnsafe(ref sRef, (nuint)(Vector256<int>.Count * 7)));
-        Unsafe.Add(ref dRef, 6) = Avx.ConvertToVector256Single(top);
-        Unsafe.Add(ref dRef, 7) = Avx.ConvertToVector256Single(bottom);
+        ref short selfRef = ref Unsafe.As<Block8x8, short>(ref source);
+
+        this.V0L.X = Unsafe.Add(ref selfRef, 0);
+        this.V0L.Y = Unsafe.Add(ref selfRef, 1);
+        this.V0L.Z = Unsafe.Add(ref selfRef, 2);
+        this.V0L.W = Unsafe.Add(ref selfRef, 3);
+        this.V0R.X = Unsafe.Add(ref selfRef, 4);
+        this.V0R.Y = Unsafe.Add(ref selfRef, 5);
+        this.V0R.Z = Unsafe.Add(ref selfRef, 6);
+        this.V0R.W = Unsafe.Add(ref selfRef, 7);
+
+        this.V1L.X = Unsafe.Add(ref selfRef, 8);
+        this.V1L.Y = Unsafe.Add(ref selfRef, 9);
+        this.V1L.Z = Unsafe.Add(ref selfRef, 10);
+        this.V1L.W = Unsafe.Add(ref selfRef, 11);
+        this.V1R.X = Unsafe.Add(ref selfRef, 12);
+        this.V1R.Y = Unsafe.Add(ref selfRef, 13);
+        this.V1R.Z = Unsafe.Add(ref selfRef, 14);
+        this.V1R.W = Unsafe.Add(ref selfRef, 15);
+
+        this.V2L.X = Unsafe.Add(ref selfRef, 16);
+        this.V2L.Y = Unsafe.Add(ref selfRef, 17);
+        this.V2L.Z = Unsafe.Add(ref selfRef, 18);
+        this.V2L.W = Unsafe.Add(ref selfRef, 19);
+        this.V2R.X = Unsafe.Add(ref selfRef, 20);
+        this.V2R.Y = Unsafe.Add(ref selfRef, 21);
+        this.V2R.Z = Unsafe.Add(ref selfRef, 22);
+        this.V2R.W = Unsafe.Add(ref selfRef, 23);
+
+        this.V3L.X = Unsafe.Add(ref selfRef, 24);
+        this.V3L.Y = Unsafe.Add(ref selfRef, 25);
+        this.V3L.Z = Unsafe.Add(ref selfRef, 26);
+        this.V3L.W = Unsafe.Add(ref selfRef, 27);
+        this.V3R.X = Unsafe.Add(ref selfRef, 28);
+        this.V3R.Y = Unsafe.Add(ref selfRef, 29);
+        this.V3R.Z = Unsafe.Add(ref selfRef, 30);
+        this.V3R.W = Unsafe.Add(ref selfRef, 31);
+
+        this.V4L.X = Unsafe.Add(ref selfRef, 32);
+        this.V4L.Y = Unsafe.Add(ref selfRef, 33);
+        this.V4L.Z = Unsafe.Add(ref selfRef, 34);
+        this.V4L.W = Unsafe.Add(ref selfRef, 35);
+        this.V4R.X = Unsafe.Add(ref selfRef, 36);
+        this.V4R.Y = Unsafe.Add(ref selfRef, 37);
+        this.V4R.Z = Unsafe.Add(ref selfRef, 38);
+        this.V4R.W = Unsafe.Add(ref selfRef, 39);
+
+        this.V5L.X = Unsafe.Add(ref selfRef, 40);
+        this.V5L.Y = Unsafe.Add(ref selfRef, 41);
+        this.V5L.Z = Unsafe.Add(ref selfRef, 42);
+        this.V5L.W = Unsafe.Add(ref selfRef, 43);
+        this.V5R.X = Unsafe.Add(ref selfRef, 44);
+        this.V5R.Y = Unsafe.Add(ref selfRef, 45);
+        this.V5R.Z = Unsafe.Add(ref selfRef, 46);
+        this.V5R.W = Unsafe.Add(ref selfRef, 47);
+
+        this.V6L.X = Unsafe.Add(ref selfRef, 48);
+        this.V6L.Y = Unsafe.Add(ref selfRef, 49);
+        this.V6L.Z = Unsafe.Add(ref selfRef, 50);
+        this.V6L.W = Unsafe.Add(ref selfRef, 51);
+        this.V6R.X = Unsafe.Add(ref selfRef, 52);
+        this.V6R.Y = Unsafe.Add(ref selfRef, 53);
+        this.V6R.Z = Unsafe.Add(ref selfRef, 54);
+        this.V6R.W = Unsafe.Add(ref selfRef, 55);
+
+        this.V7L.X = Unsafe.Add(ref selfRef, 56);
+        this.V7L.Y = Unsafe.Add(ref selfRef, 57);
+        this.V7L.Z = Unsafe.Add(ref selfRef, 58);
+        this.V7L.W = Unsafe.Add(ref selfRef, 59);
+        this.V7R.X = Unsafe.Add(ref selfRef, 60);
+        this.V7R.Y = Unsafe.Add(ref selfRef, 61);
+        this.V7R.Z = Unsafe.Add(ref selfRef, 62);
+        this.V7R.W = Unsafe.Add(ref selfRef, 63);
     }
 
     /// <summary>
@@ -421,17 +487,30 @@ internal partial struct Block8x8F : IEquatable<Block8x8F>
     /// <param name="value">Value to compare to.</param>
     public bool EqualsToScalar(int value)
     {
-        if (Avx2.IsSupported)
+        if (Vector256.IsHardwareAccelerated)
         {
-            const int equalityMask = unchecked((int)0b1111_1111_1111_1111_1111_1111_1111_1111);
-
             Vector256<int> targetVector = Vector256.Create(value);
-            ref Vector256<float> blockStride = ref this.V0;
+            ref Vector256<float> blockStride = ref this.V256_0;
 
             for (nuint i = 0; i < RowCount; i++)
             {
-                Vector256<int> areEqual = Avx2.CompareEqual(Avx.ConvertToVector256Int32WithTruncation(Unsafe.Add(ref this.V0, i)), targetVector);
-                if (Avx2.MoveMask(areEqual.AsByte()) != equalityMask)
+                if (!Vector256.EqualsAll(Vector256.ConvertToInt32(Unsafe.Add(ref this.V256_0, i)), targetVector))
+                {
+                    return false;
+                }
+            }
+
+            return true;
+        }
+
+        if (Vector128.IsHardwareAccelerated)
+        {
+            Vector128<int> targetVector = Vector128.Create(value);
+            ref Vector4 blockStride = ref this.V0L;
+
+            for (nuint i = 0; i < RowCount * 2; i++)
+            {
+                if (!Vector128.EqualsAll(Vector128.ConvertToInt32(Unsafe.Add(ref this.V0L, i).AsVector128()), targetVector))
                 {
                     return false;
                 }
@@ -516,26 +595,27 @@ internal partial struct Block8x8F : IEquatable<Block8x8F>
     }
 
     /// <summary>
-    /// Transpose the block inplace.
+    /// Transpose the block in-place.
     /// </summary>
     [MethodImpl(InliningOptions.ShortMethod)]
-    public void TransposeInplace()
+    public void TransposeInPlace()
     {
-        if (Avx.IsSupported)
+        if (Vector256.IsHardwareAccelerated)
         {
-            this.TransposeInplace_Avx();
+            this.TransposeInPlaceVector256();
         }
         else
         {
-            this.TransposeInplace_Scalar();
+            // TODO: Can we provide a Vector128 implementation for this?
+            this.TransposeInPlace_Scalar();
         }
     }
 
     /// <summary>
-    /// Scalar inplace transpose implementation for <see cref="TransposeInplace"/>
+    /// Scalar in-place transpose implementation for <see cref="TransposeInPlace"/>
     /// </summary>
     [MethodImpl(InliningOptions.ShortMethod)]
-    private void TransposeInplace_Scalar()
+    private void TransposeInPlace_Scalar()
     {
         ref float elemRef = ref Unsafe.As<Block8x8F, float>(ref this);
 
@@ -581,13 +661,4 @@ internal partial struct Block8x8F : IEquatable<Block8x8F>
         // row #6
         RuntimeUtility.Swap(ref Unsafe.Add(ref elemRef, 55), ref Unsafe.Add(ref elemRef, 62));
     }
-
-    [MethodImpl(InliningOptions.ShortMethod)]
-    private static Vector<float> NormalizeAndRound(Vector<float> row, Vector<float> off, Vector<float> max)
-    {
-        row += off;
-        row = Vector.Max(row, Vector<float>.Zero);
-        row = Vector.Min(row, max);
-        return row.FastRound();
-    }
 }
diff --git a/src/ImageSharp/Formats/Jpeg/Components/ColorConverters/JpegColorConverter.CmykScalar.cs b/src/ImageSharp/Formats/Jpeg/Components/ColorConverters/JpegColorConverter.CmykScalar.cs
index 6d0013b88d..ebaa7c4b0b 100644
--- a/src/ImageSharp/Formats/Jpeg/Components/ColorConverters/JpegColorConverter.CmykScalar.cs
+++ b/src/ImageSharp/Formats/Jpeg/Components/ColorConverters/JpegColorConverter.CmykScalar.cs
@@ -1,6 +1,13 @@
 // Copyright (c) Six Labors.
 // Licensed under the Six Labors Split License.
 
+using System.Buffers;
+using System.Numerics;
+using System.Runtime.InteropServices;
+using SixLabors.ImageSharp.ColorProfiles;
+using SixLabors.ImageSharp.ColorProfiles.Icc;
+using SixLabors.ImageSharp.Metadata.Profiles.Icc;
+
 namespace SixLabors.ImageSharp.Formats.Jpeg.Components;
 
 internal abstract partial class JpegColorConverterBase
@@ -13,14 +20,18 @@ internal abstract partial class JpegColorConverterBase
         }
 
         /// <inheritdoc/>
-        public override void ConvertToRgbInplace(in ComponentValues values) =>
-            ConvertToRgbInplace(values, this.MaximumValue);
+        public override void ConvertToRgbInPlace(in ComponentValues values) =>
+            ConvertToRgbInPlace(values, this.MaximumValue);
+
+        /// <inheritdoc/>
+        public override void ConvertToRgbInPlaceWithIcc(Configuration configuration, in ComponentValues values, IccProfile profile)
+            => ConvertToRgbInPlaceWithIcc(configuration, profile, values, this.MaximumValue);
 
         /// <inheritdoc/>
-        public override void ConvertFromRgb(in ComponentValues values, Span<float> r, Span<float> g, Span<float> b)
-            => ConvertFromRgb(values, this.MaximumValue, r, g, b);
+        public override void ConvertFromRgb(in ComponentValues values, Span<float> rLane, Span<float> gLane, Span<float> bLane)
+            => ConvertFromRgb(values, this.MaximumValue, rLane, gLane, bLane);
 
-        public static void ConvertToRgbInplace(in ComponentValues values, float maxValue)
+        public static void ConvertToRgbInPlace(in ComponentValues values, float maxValue)
         {
             Span<float> c0 = values.Component0;
             Span<float> c1 = values.Component1;
@@ -42,7 +53,7 @@ internal abstract partial class JpegColorConverterBase
             }
         }
 
-        public static void ConvertFromRgb(in ComponentValues values, float maxValue, Span<float> r, Span<float> g, Span<float> b)
+        public static void ConvertFromRgb(in ComponentValues values, float maxValue, Span<float> rLane, Span<float> gLane, Span<float> bLane)
         {
             Span<float> c = values.Component0;
             Span<float> m = values.Component1;
@@ -51,9 +62,9 @@ internal abstract partial class JpegColorConverterBase
 
             for (int i = 0; i < c.Length; i++)
             {
-                float ctmp = 255f - r[i];
-                float mtmp = 255f - g[i];
-                float ytmp = 255f - b[i];
+                float ctmp = 255f - rLane[i];
+                float mtmp = 255f - gLane[i];
+                float ytmp = 255f - bLane[i];
                 float ktmp = MathF.Min(MathF.Min(ctmp, mtmp), ytmp);
 
                 if (ktmp >= 255f)
@@ -75,5 +86,31 @@ internal abstract partial class JpegColorConverterBase
                 k[i] = maxValue - ktmp;
             }
         }
+
+        public static void ConvertToRgbInPlaceWithIcc(Configuration configuration, IccProfile profile, in ComponentValues values, float maxValue)
+        {
+            using IMemoryOwner<float> memoryOwner = configuration.MemoryAllocator.Allocate<float>(values.Component0.Length * 4);
+            Span<float> packed = memoryOwner.Memory.Span;
+
+            Span<float> c0 = values.Component0;
+            Span<float> c1 = values.Component1;
+            Span<float> c2 = values.Component2;
+            Span<float> c3 = values.Component3;
+
+            PackedInvertNormalizeInterleave4(c0, c1, c2, c3, packed, maxValue);
+
+            Span<Cmyk> source = MemoryMarshal.Cast<float, Cmyk>(packed);
+            Span<Rgb> destination = MemoryMarshal.Cast<float, Rgb>(packed)[..source.Length];
+
+            ColorConversionOptions options = new()
+            {
+                SourceIccProfile = profile,
+                TargetIccProfile = CompactSrgbV4Profile.Profile,
+            };
+            ColorProfileConverter converter = new(options);
+            converter.Convert<Cmyk, Rgb>(source, destination);
+
+            UnpackDeinterleave3(MemoryMarshal.Cast<float, Vector3>(packed)[..source.Length], c0, c1, c2);
+        }
     }
 }
diff --git a/src/ImageSharp/Formats/Jpeg/Components/ColorConverters/JpegColorConverter.CmykVector.cs b/src/ImageSharp/Formats/Jpeg/Components/ColorConverters/JpegColorConverter.CmykVector.cs
deleted file mode 100644
index a59be009b7..0000000000
--- a/src/ImageSharp/Formats/Jpeg/Components/ColorConverters/JpegColorConverter.CmykVector.cs
+++ /dev/null
@@ -1,104 +0,0 @@
-// Copyright (c) Six Labors.
-// Licensed under the Six Labors Split License.
-
-using System.Numerics;
-using System.Runtime.CompilerServices;
-using System.Runtime.InteropServices;
-
-namespace SixLabors.ImageSharp.Formats.Jpeg.Components;
-
-internal abstract partial class JpegColorConverterBase
-{
-    internal sealed class CmykVector : JpegColorConverterVector
-    {
-        public CmykVector(int precision)
-            : base(JpegColorSpace.Cmyk, precision)
-        {
-        }
-
-        /// <inheritdoc/>
-        protected override void ConvertToRgbInplaceVectorized(in ComponentValues values)
-        {
-            ref Vector<float> cBase =
-                ref Unsafe.As<float, Vector<float>>(ref MemoryMarshal.GetReference(values.Component0));
-            ref Vector<float> mBase =
-                ref Unsafe.As<float, Vector<float>>(ref MemoryMarshal.GetReference(values.Component1));
-            ref Vector<float> yBase =
-                ref Unsafe.As<float, Vector<float>>(ref MemoryMarshal.GetReference(values.Component2));
-            ref Vector<float> kBase =
-                ref Unsafe.As<float, Vector<float>>(ref MemoryMarshal.GetReference(values.Component3));
-
-            var scale = new Vector<float>(1 / (this.MaximumValue * this.MaximumValue));
-
-            nuint n = values.Component0.VectorCount<float>();
-            for (nuint i = 0; i < n; i++)
-            {
-                ref Vector<float> c = ref Unsafe.Add(ref cBase, i);
-                ref Vector<float> m = ref Unsafe.Add(ref mBase, i);
-                ref Vector<float> y = ref Unsafe.Add(ref yBase, i);
-                Vector<float> k = Unsafe.Add(ref kBase, i);
-
-                k *= scale;
-                c *= k;
-                m *= k;
-                y *= k;
-            }
-        }
-
-        /// <inheritdoc/>
-        protected override void ConvertToRgbInplaceScalarRemainder(in ComponentValues values)
-             => CmykScalar.ConvertToRgbInplace(values, this.MaximumValue);
-
-        /// <inheritdoc/>
-        protected override void ConvertFromRgbVectorized(in ComponentValues values, Span<float> r, Span<float> g, Span<float> b)
-            => ConvertFromRgbInplaceVectorized(in values, this.MaximumValue, r, g, b);
-
-        /// <inheritdoc/>
-        protected override void ConvertFromRgbScalarRemainder(in ComponentValues values, Span<float> r, Span<float> g, Span<float> b)
-            => ConvertFromRgbInplaceRemainder(values, this.MaximumValue, r, g, b);
-
-        public static void ConvertFromRgbInplaceVectorized(in ComponentValues values, float maxValue, Span<float> r, Span<float> g, Span<float> b)
-        {
-            ref Vector<float> destC =
-                ref Unsafe.As<float, Vector<float>>(ref MemoryMarshal.GetReference(values.Component0));
-            ref Vector<float> destM =
-                ref Unsafe.As<float, Vector<float>>(ref MemoryMarshal.GetReference(values.Component1));
-            ref Vector<float> destY =
-                ref Unsafe.As<float, Vector<float>>(ref MemoryMarshal.GetReference(values.Component2));
-            ref Vector<float> destK =
-                ref Unsafe.As<float, Vector<float>>(ref MemoryMarshal.GetReference(values.Component3));
-
-            ref Vector<float> srcR =
-                ref Unsafe.As<float, Vector<float>>(ref MemoryMarshal.GetReference(r));
-            ref Vector<float> srcG =
-                ref Unsafe.As<float, Vector<float>>(ref MemoryMarshal.GetReference(g));
-            ref Vector<float> srcB =
-                ref Unsafe.As<float, Vector<float>>(ref MemoryMarshal.GetReference(b));
-
-            // Used for the color conversion
-            var scale = new Vector<float>(maxValue);
-
-            nuint n = values.Component0.VectorCount<float>();
-            for (nuint i = 0; i < n; i++)
-            {
-                Vector<float> ctmp = scale - Unsafe.Add(ref srcR, i);
-                Vector<float> mtmp = scale - Unsafe.Add(ref srcG, i);
-                Vector<float> ytmp = scale - Unsafe.Add(ref srcB, i);
-                Vector<float> ktmp = Vector.Min(ctmp, Vector.Min(mtmp, ytmp));
-
-                var kMask = Vector.Equals(ktmp, scale);
-                ctmp = Vector.AndNot((ctmp - ktmp) / (scale - ktmp), kMask.As<int, float>());
-                mtmp = Vector.AndNot((mtmp - ktmp) / (scale - ktmp), kMask.As<int, float>());
-                ytmp = Vector.AndNot((ytmp - ktmp) / (scale - ktmp), kMask.As<int, float>());
-
-                Unsafe.Add(ref destC, i) = scale - (ctmp * scale);
-                Unsafe.Add(ref destM, i) = scale - (mtmp * scale);
-                Unsafe.Add(ref destY, i) = scale - (ytmp * scale);
-                Unsafe.Add(ref destK, i) = scale - ktmp;
-            }
-        }
-
-        public static void ConvertFromRgbInplaceRemainder(in ComponentValues values, float maxValue, Span<float> r, Span<float> g, Span<float> b)
-            => CmykScalar.ConvertFromRgb(values, maxValue, r, g, b);
-    }
-}
diff --git a/src/ImageSharp/Formats/Jpeg/Components/ColorConverters/JpegColorConverter.CmykArm64.cs b/src/ImageSharp/Formats/Jpeg/Components/ColorConverters/JpegColorConverter.CmykVector128.cs
similarity index 59%
rename from src/ImageSharp/Formats/Jpeg/Components/ColorConverters/JpegColorConverter.CmykArm64.cs
rename to src/ImageSharp/Formats/Jpeg/Components/ColorConverters/JpegColorConverter.CmykVector128.cs
index 11122d3b89..14addafc1d 100644
--- a/src/ImageSharp/Formats/Jpeg/Components/ColorConverters/JpegColorConverter.CmykArm64.cs
+++ b/src/ImageSharp/Formats/Jpeg/Components/ColorConverters/JpegColorConverter.CmykVector128.cs
@@ -4,21 +4,21 @@
 using System.Runtime.CompilerServices;
 using System.Runtime.InteropServices;
 using System.Runtime.Intrinsics;
-using System.Runtime.Intrinsics.Arm;
+using SixLabors.ImageSharp.Metadata.Profiles.Icc;
 
 namespace SixLabors.ImageSharp.Formats.Jpeg.Components;
 
 internal abstract partial class JpegColorConverterBase
 {
-    internal sealed class CmykArm64 : JpegColorConverterArm64
+    internal sealed class CmykVector128 : JpegColorConverterVector128
     {
-        public CmykArm64(int precision)
+        public CmykVector128(int precision)
             : base(JpegColorSpace.Cmyk, precision)
         {
         }
 
         /// <inheritdoc/>
-        public override void ConvertToRgbInplace(in ComponentValues values)
+        public override void ConvertToRgbInPlace(in ComponentValues values)
         {
             ref Vector128<float> c0Base =
                 ref Unsafe.As<float, Vector128<float>>(ref MemoryMarshal.GetReference(values.Component0));
@@ -30,23 +30,27 @@ internal abstract partial class JpegColorConverterBase
                 ref Unsafe.As<float, Vector128<float>>(ref MemoryMarshal.GetReference(values.Component3));
 
             // Used for the color conversion
-            var scale = Vector128.Create(1 / (this.MaximumValue * this.MaximumValue));
+            Vector128<float> scale = Vector128.Create(1 / (this.MaximumValue * this.MaximumValue));
 
-            nint n = (nint)(uint)values.Component0.Length / Vector128<float>.Count;
-            for (nint i = 0; i < n; i++)
+            nuint n = values.Component0.Vector128Count<float>();
+            for (nuint i = 0; i < n; i++)
             {
                 ref Vector128<float> c = ref Unsafe.Add(ref c0Base, i);
                 ref Vector128<float> m = ref Unsafe.Add(ref c1Base, i);
                 ref Vector128<float> y = ref Unsafe.Add(ref c2Base, i);
                 Vector128<float> k = Unsafe.Add(ref c3Base, i);
 
-                k = AdvSimd.Multiply(k, scale);
-                c = AdvSimd.Multiply(c, k);
-                m = AdvSimd.Multiply(m, k);
-                y = AdvSimd.Multiply(y, k);
+                k *= scale;
+                c *= k;
+                m *= k;
+                y *= k;
             }
         }
 
+        /// <inheritdoc/>
+        public override void ConvertToRgbInPlaceWithIcc(Configuration configuration, in ComponentValues values, IccProfile profile)
+            => CmykScalar.ConvertToRgbInPlaceWithIcc(configuration, profile, values, this.MaximumValue);
+
         /// <inheritdoc/>
         public override void ConvertFromRgb(in ComponentValues values, Span<float> rLane, Span<float> gLane, Span<float> bLane)
             => ConvertFromRgb(in values, this.MaximumValue, rLane, gLane, bLane);
@@ -69,26 +73,27 @@ internal abstract partial class JpegColorConverterBase
             ref Vector128<float> srcB =
                 ref Unsafe.As<float, Vector128<float>>(ref MemoryMarshal.GetReference(bLane));
 
-            var scale = Vector128.Create(maxValue);
+            Vector128<float> scale = Vector128.Create(maxValue);
 
-            nint n = (nint)(uint)values.Component0.Length / Vector128<float>.Count;
-            for (nint i = 0; i < n; i++)
+            nuint n = values.Component0.Vector128Count<float>();
+            for (nuint i = 0; i < n; i++)
             {
-                Vector128<float> ctmp = AdvSimd.Subtract(scale, Unsafe.Add(ref srcR, i));
-                Vector128<float> mtmp = AdvSimd.Subtract(scale, Unsafe.Add(ref srcG, i));
-                Vector128<float> ytmp = AdvSimd.Subtract(scale, Unsafe.Add(ref srcB, i));
-                Vector128<float> ktmp = AdvSimd.Min(ctmp, AdvSimd.Min(mtmp, ytmp));
+                Vector128<float> ctmp = scale - Unsafe.Add(ref srcR, i);
+                Vector128<float> mtmp = scale - Unsafe.Add(ref srcG, i);
+                Vector128<float> ytmp = scale - Unsafe.Add(ref srcB, i);
+                Vector128<float> ktmp = Vector128.Min(ctmp, Vector128.Min(mtmp, ytmp));
 
-                Vector128<float> kMask = AdvSimd.Not(AdvSimd.CompareEqual(ktmp, scale));
+                Vector128<float> kMask = ~Vector128.Equals(ktmp, scale);
+                Vector128<float> divisor = scale - ktmp;
 
-                ctmp = AdvSimd.And(AdvSimd.Arm64.Divide(AdvSimd.Subtract(ctmp, ktmp), AdvSimd.Subtract(scale, ktmp)), kMask);
-                mtmp = AdvSimd.And(AdvSimd.Arm64.Divide(AdvSimd.Subtract(mtmp, ktmp), AdvSimd.Subtract(scale, ktmp)), kMask);
-                ytmp = AdvSimd.And(AdvSimd.Arm64.Divide(AdvSimd.Subtract(ytmp, ktmp), AdvSimd.Subtract(scale, ktmp)), kMask);
+                ctmp = ((ctmp - ktmp) / divisor) & kMask;
+                mtmp = ((mtmp - ktmp) / divisor) & kMask;
+                ytmp = ((ytmp - ktmp) / divisor) & kMask;
 
-                Unsafe.Add(ref destC, i) = AdvSimd.Subtract(scale, AdvSimd.Multiply(ctmp, scale));
-                Unsafe.Add(ref destM, i) = AdvSimd.Subtract(scale, AdvSimd.Multiply(mtmp, scale));
-                Unsafe.Add(ref destY, i) = AdvSimd.Subtract(scale, AdvSimd.Multiply(ytmp, scale));
-                Unsafe.Add(ref destK, i) = AdvSimd.Subtract(scale, ktmp);
+                Unsafe.Add(ref destC, i) = scale - (ctmp * scale);
+                Unsafe.Add(ref destM, i) = scale - (mtmp * scale);
+                Unsafe.Add(ref destY, i) = scale - (ytmp * scale);
+                Unsafe.Add(ref destK, i) = scale - ktmp;
             }
         }
     }
diff --git a/src/ImageSharp/Formats/Jpeg/Components/ColorConverters/JpegColorConverter.CmykAvx.cs b/src/ImageSharp/Formats/Jpeg/Components/ColorConverters/JpegColorConverter.CmykVector256.cs
similarity index 65%
rename from src/ImageSharp/Formats/Jpeg/Components/ColorConverters/JpegColorConverter.CmykAvx.cs
rename to src/ImageSharp/Formats/Jpeg/Components/ColorConverters/JpegColorConverter.CmykVector256.cs
index 76d188f457..98bda53d20 100644
--- a/src/ImageSharp/Formats/Jpeg/Components/ColorConverters/JpegColorConverter.CmykAvx.cs
+++ b/src/ImageSharp/Formats/Jpeg/Components/ColorConverters/JpegColorConverter.CmykVector256.cs
@@ -4,21 +4,21 @@
 using System.Runtime.CompilerServices;
 using System.Runtime.InteropServices;
 using System.Runtime.Intrinsics;
-using System.Runtime.Intrinsics.X86;
+using SixLabors.ImageSharp.Metadata.Profiles.Icc;
 
 namespace SixLabors.ImageSharp.Formats.Jpeg.Components;
 
 internal abstract partial class JpegColorConverterBase
 {
-    internal sealed class CmykAvx : JpegColorConverterAvx
+    internal sealed class CmykVector256 : JpegColorConverterVector256
     {
-        public CmykAvx(int precision)
+        public CmykVector256(int precision)
             : base(JpegColorSpace.Cmyk, precision)
         {
         }
 
         /// <inheritdoc/>
-        public override void ConvertToRgbInplace(in ComponentValues values)
+        public override void ConvertToRgbInPlace(in ComponentValues values)
         {
             ref Vector256<float> c0Base =
                 ref Unsafe.As<float, Vector256<float>>(ref MemoryMarshal.GetReference(values.Component0));
@@ -30,7 +30,7 @@ internal abstract partial class JpegColorConverterBase
                 ref Unsafe.As<float, Vector256<float>>(ref MemoryMarshal.GetReference(values.Component3));
 
             // Used for the color conversion
-            var scale = Vector256.Create(1 / (this.MaximumValue * this.MaximumValue));
+            Vector256<float> scale = Vector256.Create(1 / (this.MaximumValue * this.MaximumValue));
 
             nuint n = values.Component0.Vector256Count<float>();
             for (nuint i = 0; i < n; i++)
@@ -40,13 +40,17 @@ internal abstract partial class JpegColorConverterBase
                 ref Vector256<float> y = ref Unsafe.Add(ref c2Base, i);
                 Vector256<float> k = Unsafe.Add(ref c3Base, i);
 
-                k = Avx.Multiply(k, scale);
-                c = Avx.Multiply(c, k);
-                m = Avx.Multiply(m, k);
-                y = Avx.Multiply(y, k);
+                k *= scale;
+                c *= k;
+                m *= k;
+                y *= k;
             }
         }
 
+        /// <inheritdoc/>
+        public override void ConvertToRgbInPlaceWithIcc(Configuration configuration, in ComponentValues values, IccProfile profile)
+            => CmykScalar.ConvertToRgbInPlaceWithIcc(configuration, profile, values, this.MaximumValue);
+
         /// <inheritdoc/>
         public override void ConvertFromRgb(in ComponentValues values, Span<float> rLane, Span<float> gLane, Span<float> bLane)
             => ConvertFromRgb(in values, this.MaximumValue, rLane, gLane, bLane);
@@ -69,26 +73,27 @@ internal abstract partial class JpegColorConverterBase
             ref Vector256<float> srcB =
                 ref Unsafe.As<float, Vector256<float>>(ref MemoryMarshal.GetReference(bLane));
 
-            var scale = Vector256.Create(maxValue);
+            Vector256<float> scale = Vector256.Create(maxValue);
 
             nuint n = values.Component0.Vector256Count<float>();
             for (nuint i = 0; i < n; i++)
             {
-                Vector256<float> ctmp = Avx.Subtract(scale, Unsafe.Add(ref srcR, i));
-                Vector256<float> mtmp = Avx.Subtract(scale, Unsafe.Add(ref srcG, i));
-                Vector256<float> ytmp = Avx.Subtract(scale, Unsafe.Add(ref srcB, i));
-                Vector256<float> ktmp = Avx.Min(ctmp, Avx.Min(mtmp, ytmp));
+                Vector256<float> ctmp = scale - Unsafe.Add(ref srcR, i);
+                Vector256<float> mtmp = scale - Unsafe.Add(ref srcG, i);
+                Vector256<float> ytmp = scale - Unsafe.Add(ref srcB, i);
+                Vector256<float> ktmp = Vector256.Min(ctmp, Vector256.Min(mtmp, ytmp));
 
-                Vector256<float> kMask = Avx.CompareNotEqual(ktmp, scale);
+                Vector256<float> kMask = ~Vector256.Equals(ktmp, scale);
+                Vector256<float> divisor = scale - ktmp;
 
-                ctmp = Avx.And(Avx.Divide(Avx.Subtract(ctmp, ktmp), Avx.Subtract(scale, ktmp)), kMask);
-                mtmp = Avx.And(Avx.Divide(Avx.Subtract(mtmp, ktmp), Avx.Subtract(scale, ktmp)), kMask);
-                ytmp = Avx.And(Avx.Divide(Avx.Subtract(ytmp, ktmp), Avx.Subtract(scale, ktmp)), kMask);
+                ctmp = ((ctmp - ktmp) / divisor) & kMask;
+                mtmp = ((mtmp - ktmp) / divisor) & kMask;
+                ytmp = ((ytmp - ktmp) / divisor) & kMask;
 
-                Unsafe.Add(ref destC, i) = Avx.Subtract(scale, Avx.Multiply(ctmp, scale));
-                Unsafe.Add(ref destM, i) = Avx.Subtract(scale, Avx.Multiply(mtmp, scale));
-                Unsafe.Add(ref destY, i) = Avx.Subtract(scale, Avx.Multiply(ytmp, scale));
-                Unsafe.Add(ref destK, i) = Avx.Subtract(scale, ktmp);
+                Unsafe.Add(ref destC, i) = scale - (ctmp * scale);
+                Unsafe.Add(ref destM, i) = scale - (mtmp * scale);
+                Unsafe.Add(ref destY, i) = scale - (ytmp * scale);
+                Unsafe.Add(ref destK, i) = scale - ktmp;
             }
         }
     }
diff --git a/src/ImageSharp/Formats/Jpeg/Components/ColorConverters/JpegColorConverter.CmykVector512.cs b/src/ImageSharp/Formats/Jpeg/Components/ColorConverters/JpegColorConverter.CmykVector512.cs
new file mode 100644
index 0000000000..c72af2faf2
--- /dev/null
+++ b/src/ImageSharp/Formats/Jpeg/Components/ColorConverters/JpegColorConverter.CmykVector512.cs
@@ -0,0 +1,108 @@
+// Copyright (c) Six Labors.
+// Licensed under the Six Labors Split License.
+
+using System.Runtime.CompilerServices;
+using System.Runtime.InteropServices;
+using System.Runtime.Intrinsics;
+using SixLabors.ImageSharp.Metadata.Profiles.Icc;
+
+namespace SixLabors.ImageSharp.Formats.Jpeg.Components;
+
+internal abstract partial class JpegColorConverterBase
+{
+    internal sealed class CmykVector512 : JpegColorConverterVector512
+    {
+        public CmykVector512(int precision)
+            : base(JpegColorSpace.Cmyk, precision)
+        {
+        }
+
+        /// <inheritdoc/>
+        public override void ConvertToRgbInPlaceWithIcc(Configuration configuration, in ComponentValues values, IccProfile profile)
+            => CmykScalar.ConvertToRgbInPlaceWithIcc(configuration, profile, values, this.MaximumValue);
+
+        /// <inheritdoc/>
+        protected override void ConvertToRgbInPlaceVectorized(in ComponentValues values)
+        {
+            ref Vector512<float> c0Base =
+                ref Unsafe.As<float, Vector512<float>>(ref MemoryMarshal.GetReference(values.Component0));
+            ref Vector512<float> c1Base =
+                ref Unsafe.As<float, Vector512<float>>(ref MemoryMarshal.GetReference(values.Component1));
+            ref Vector512<float> c2Base =
+                ref Unsafe.As<float, Vector512<float>>(ref MemoryMarshal.GetReference(values.Component2));
+            ref Vector512<float> c3Base =
+                ref Unsafe.As<float, Vector512<float>>(ref MemoryMarshal.GetReference(values.Component3));
+
+            // Used for the color conversion
+            Vector512<float> scale = Vector512.Create(1 / (this.MaximumValue * this.MaximumValue));
+
+            nuint n = values.Component0.Vector512Count<float>();
+            for (nuint i = 0; i < n; i++)
+            {
+                ref Vector512<float> c = ref Unsafe.Add(ref c0Base, i);
+                ref Vector512<float> m = ref Unsafe.Add(ref c1Base, i);
+                ref Vector512<float> y = ref Unsafe.Add(ref c2Base, i);
+                Vector512<float> k = Unsafe.Add(ref c3Base, i);
+
+                k *= scale;
+                c *= k;
+                m *= k;
+                y *= k;
+            }
+        }
+
+        /// <inheritdoc/>
+        protected override void ConvertFromRgbVectorized(in ComponentValues values, Span<float> rLane, Span<float> gLane, Span<float> bLane)
+            => ConvertFromRgbVectorized(in values, this.MaximumValue, rLane, gLane, bLane);
+
+        /// <inheritdoc/>
+        protected override void ConvertToRgbInPlaceScalarRemainder(in ComponentValues values)
+             => CmykScalar.ConvertToRgbInPlace(values, this.MaximumValue);
+
+        /// <inheritdoc/>
+        protected override void ConvertFromRgbScalarRemainder(in ComponentValues values, Span<float> rLane, Span<float> gLane, Span<float> bLane)
+            => CmykScalar.ConvertFromRgb(values, this.MaximumValue, rLane, gLane, bLane);
+
+        internal static void ConvertFromRgbVectorized(in ComponentValues values, float maxValue, Span<float> rLane, Span<float> gLane, Span<float> bLane)
+        {
+            ref Vector512<float> destC =
+                ref Unsafe.As<float, Vector512<float>>(ref MemoryMarshal.GetReference(values.Component0));
+            ref Vector512<float> destM =
+                ref Unsafe.As<float, Vector512<float>>(ref MemoryMarshal.GetReference(values.Component1));
+            ref Vector512<float> destY =
+                ref Unsafe.As<float, Vector512<float>>(ref MemoryMarshal.GetReference(values.Component2));
+            ref Vector512<float> destK =
+                ref Unsafe.As<float, Vector512<float>>(ref MemoryMarshal.GetReference(values.Component3));
+
+            ref Vector512<float> srcR =
+                ref Unsafe.As<float, Vector512<float>>(ref MemoryMarshal.GetReference(rLane));
+            ref Vector512<float> srcG =
+                ref Unsafe.As<float, Vector512<float>>(ref MemoryMarshal.GetReference(gLane));
+            ref Vector512<float> srcB =
+                ref Unsafe.As<float, Vector512<float>>(ref MemoryMarshal.GetReference(bLane));
+
+            Vector512<float> scale = Vector512.Create(maxValue);
+
+            nuint n = values.Component0.Vector512Count<float>();
+            for (nuint i = 0; i < n; i++)
+            {
+                Vector512<float> ctmp = scale - Unsafe.Add(ref srcR, i);
+                Vector512<float> mtmp = scale - Unsafe.Add(ref srcG, i);
+                Vector512<float> ytmp = scale - Unsafe.Add(ref srcB, i);
+                Vector512<float> ktmp = Vector512.Min(ctmp, Vector512.Min(mtmp, ytmp));
+
+                Vector512<float> kMask = ~Vector512.Equals(ktmp, scale);
+                Vector512<float> divisor = scale - ktmp;
+
+                ctmp = ((ctmp - ktmp) / divisor) & kMask;
+                mtmp = ((mtmp - ktmp) / divisor) & kMask;
+                ytmp = ((ytmp - ktmp) / divisor) & kMask;
+
+                Unsafe.Add(ref destC, i) = scale - (ctmp * scale);
+                Unsafe.Add(ref destM, i) = scale - (mtmp * scale);
+                Unsafe.Add(ref destY, i) = scale - (ytmp * scale);
+                Unsafe.Add(ref destK, i) = scale - ktmp;
+            }
+        }
+    }
+}
diff --git a/src/ImageSharp/Formats/Jpeg/Components/ColorConverters/JpegColorConverter.GrayScaleScalar.cs b/src/ImageSharp/Formats/Jpeg/Components/ColorConverters/JpegColorConverter.GrayScaleScalar.cs
index 4d3b5c60bd..74869c93ca 100644
--- a/src/ImageSharp/Formats/Jpeg/Components/ColorConverters/JpegColorConverter.GrayScaleScalar.cs
+++ b/src/ImageSharp/Formats/Jpeg/Components/ColorConverters/JpegColorConverter.GrayScaleScalar.cs
@@ -1,48 +1,96 @@
 // Copyright (c) Six Labors.
 // Licensed under the Six Labors Split License.
 
+using System.Buffers;
+using System.Numerics;
 using System.Runtime.CompilerServices;
 using System.Runtime.InteropServices;
+using SixLabors.ImageSharp.ColorProfiles;
+using SixLabors.ImageSharp.ColorProfiles.Icc;
+using SixLabors.ImageSharp.Metadata.Profiles.Icc;
 
 namespace SixLabors.ImageSharp.Formats.Jpeg.Components;
 
 internal abstract partial class JpegColorConverterBase
 {
-    internal sealed class GrayscaleScalar : JpegColorConverterScalar
+    internal sealed class GrayScaleScalar : JpegColorConverterScalar
     {
-        public GrayscaleScalar(int precision)
+        public GrayScaleScalar(int precision)
             : base(JpegColorSpace.Grayscale, precision)
         {
         }
 
         /// <inheritdoc/>
-        public override void ConvertToRgbInplace(in ComponentValues values)
-            => ConvertToRgbInplace(values.Component0, this.MaximumValue);
+        public override void ConvertToRgbInPlace(in ComponentValues values)
+            => ConvertToRgbInPlace(in values, this.MaximumValue);
 
         /// <inheritdoc/>
-        public override void ConvertFromRgb(in ComponentValues values, Span<float> r, Span<float> g, Span<float> b)
-            => ConvertCoreInplaceFromRgb(values, r, g, b);
+        public override void ConvertToRgbInPlaceWithIcc(Configuration configuration, in ComponentValues values, IccProfile profile)
+            => ConvertToRgbInPlaceWithIcc(configuration, profile, values, this.MaximumValue);
 
-        internal static void ConvertToRgbInplace(Span<float> values, float maxValue)
+        /// <inheritdoc/>
+        public override void ConvertFromRgb(in ComponentValues values, Span<float> rLane, Span<float> gLane, Span<float> bLane)
+            => ConvertFromRgbScalar(values, rLane, gLane, bLane);
+
+        internal static void ConvertToRgbInPlace(in ComponentValues values, float maxValue)
+        {
+            ref float c0Base = ref MemoryMarshal.GetReference(values.Component0);
+            ref float c1Base = ref MemoryMarshal.GetReference(values.Component1);
+            ref float c2Base = ref MemoryMarshal.GetReference(values.Component2);
+
+            float scale = 1F / maxValue;
+            for (nuint i = 0; i < (nuint)values.Component0.Length; i++)
+            {
+                float c = Unsafe.Add(ref c0Base, i) * scale;
+
+                Unsafe.Add(ref c0Base, i) = c;
+                Unsafe.Add(ref c1Base, i) = c;
+                Unsafe.Add(ref c2Base, i) = c;
+            }
+        }
+
+        public static void ConvertToRgbInPlaceWithIcc(Configuration configuration, IccProfile profile, in ComponentValues values, float maxValue)
         {
-            ref float valuesRef = ref MemoryMarshal.GetReference(values);
-            float scale = 1 / maxValue;
+            using IMemoryOwner<float> memoryOwner = configuration.MemoryAllocator.Allocate<float>(values.Component0.Length * 3);
+            Span<float> packed = memoryOwner.Memory.Span;
+
+            Span<float> c0 = values.Component0;
+            Span<float> c1 = values.Component1;
+            Span<float> c2 = values.Component2;
+
+            ref float c0Base = ref MemoryMarshal.GetReference(c0);
+            ref float c1Base = ref MemoryMarshal.GetReference(c1);
+            ref float c2Base = ref MemoryMarshal.GetReference(c2);
 
-            for (nuint i = 0; i < (uint)values.Length; i++)
+            float scale = 1F / maxValue;
+            for (nuint i = 0; i < (nuint)values.Component0.Length; i++)
             {
-                Unsafe.Add(ref valuesRef, i) *= scale;
+                ref float c = ref Unsafe.Add(ref c0Base, i);
+                c *= scale;
             }
+
+            Span<Y> source = MemoryMarshal.Cast<float, Y>(values.Component0);
+            Span<Rgb> destination = MemoryMarshal.Cast<float, Rgb>(packed);
+
+            ColorConversionOptions options = new()
+            {
+                SourceIccProfile = profile,
+                TargetIccProfile = CompactSrgbV4Profile.Profile,
+            };
+            ColorProfileConverter converter = new(options);
+            converter.Convert<Y, Rgb>(source, destination);
+
+            UnpackDeinterleave3(MemoryMarshal.Cast<float, Vector3>(packed)[..source.Length], c0, c1, c2);
         }
 
-        internal static void ConvertCoreInplaceFromRgb(in ComponentValues values, Span<float> rLane, Span<float> gLane, Span<float> bLane)
+        internal static void ConvertFromRgbScalar(in ComponentValues values, Span<float> rLane, Span<float> gLane, Span<float> bLane)
         {
             Span<float> c0 = values.Component0;
 
             for (int i = 0; i < c0.Length; i++)
             {
-                // luminocity = (0.299 * r) + (0.587 * g) + (0.114 * b)
-                float luma = (0.299f * rLane[i]) + (0.587f * gLane[i]) + (0.114f * bLane[i]);
-                c0[i] = luma;
+                // luminosity = (0.299 * r) + (0.587 * g) + (0.114 * b)
+                c0[i] = (float)((0.299f * rLane[i]) + (0.587f * gLane[i]) + (0.114f * bLane[i]));
             }
         }
     }
diff --git a/src/ImageSharp/Formats/Jpeg/Components/ColorConverters/JpegColorConverter.GrayScaleVector.cs b/src/ImageSharp/Formats/Jpeg/Components/ColorConverters/JpegColorConverter.GrayScaleVector.cs
deleted file mode 100644
index cac10636f5..0000000000
--- a/src/ImageSharp/Formats/Jpeg/Components/ColorConverters/JpegColorConverter.GrayScaleVector.cs
+++ /dev/null
@@ -1,72 +0,0 @@
-// Copyright (c) Six Labors.
-// Licensed under the Six Labors Split License.
-
-using System.Numerics;
-using System.Runtime.CompilerServices;
-using System.Runtime.InteropServices;
-
-namespace SixLabors.ImageSharp.Formats.Jpeg.Components;
-
-internal abstract partial class JpegColorConverterBase
-{
-    internal sealed class GrayScaleVector : JpegColorConverterVector
-    {
-        public GrayScaleVector(int precision)
-            : base(JpegColorSpace.Grayscale, precision)
-        {
-        }
-
-        /// <inheritdoc/>
-        protected override void ConvertToRgbInplaceVectorized(in ComponentValues values)
-        {
-            ref Vector<float> cBase =
-                ref Unsafe.As<float, Vector<float>>(ref MemoryMarshal.GetReference(values.Component0));
-
-            var scale = new Vector<float>(1 / this.MaximumValue);
-
-            nuint n = values.Component0.VectorCount<float>();
-            for (nuint i = 0; i < n; i++)
-            {
-                ref Vector<float> c0 = ref Unsafe.Add(ref cBase, i);
-                c0 *= scale;
-            }
-        }
-
-        /// <inheritdoc/>
-        protected override void ConvertToRgbInplaceScalarRemainder(in ComponentValues values)
-            => GrayscaleScalar.ConvertToRgbInplace(values.Component0, this.MaximumValue);
-
-        /// <inheritdoc/>
-        protected override void ConvertFromRgbVectorized(in ComponentValues values, Span<float> rLane, Span<float> gLane, Span<float> bLane)
-        {
-            ref Vector<float> destLuma =
-                ref Unsafe.As<float, Vector<float>>(ref MemoryMarshal.GetReference(values.Component0));
-
-            ref Vector<float> srcR =
-                ref Unsafe.As<float, Vector<float>>(ref MemoryMarshal.GetReference(rLane));
-            ref Vector<float> srcG =
-                ref Unsafe.As<float, Vector<float>>(ref MemoryMarshal.GetReference(gLane));
-            ref Vector<float> srcB =
-                ref Unsafe.As<float, Vector<float>>(ref MemoryMarshal.GetReference(bLane));
-
-            var rMult = new Vector<float>(0.299f);
-            var gMult = new Vector<float>(0.587f);
-            var bMult = new Vector<float>(0.114f);
-
-            nuint n = values.Component0.VectorCount<float>();
-            for (nuint i = 0; i < n; i++)
-            {
-                Vector<float> r = Unsafe.Add(ref srcR, i);
-                Vector<float> g = Unsafe.Add(ref srcR, i);
-                Vector<float> b = Unsafe.Add(ref srcR, i);
-
-                // luminocity = (0.299 * r) + (0.587 * g) + (0.114 * b)
-                Unsafe.Add(ref destLuma, i) = (rMult * r) + (gMult * g) + (bMult * b);
-            }
-        }
-
-        /// <inheritdoc/>
-        protected override void ConvertFromRgbScalarRemainder(in ComponentValues values, Span<float> r, Span<float> g, Span<float> b)
-            => GrayscaleScalar.ConvertCoreInplaceFromRgb(values, r, g, b);
-    }
-}
diff --git a/src/ImageSharp/Formats/Jpeg/Components/ColorConverters/JpegColorConverter.GrayScaleArm.cs b/src/ImageSharp/Formats/Jpeg/Components/ColorConverters/JpegColorConverter.GrayScaleVector128.cs
similarity index 56%
rename from src/ImageSharp/Formats/Jpeg/Components/ColorConverters/JpegColorConverter.GrayScaleArm.cs
rename to src/ImageSharp/Formats/Jpeg/Components/ColorConverters/JpegColorConverter.GrayScaleVector128.cs
index 6bb8fd7aa3..633080706b 100644
--- a/src/ImageSharp/Formats/Jpeg/Components/ColorConverters/JpegColorConverter.GrayScaleArm.cs
+++ b/src/ImageSharp/Formats/Jpeg/Components/ColorConverters/JpegColorConverter.GrayScaleVector128.cs
@@ -4,34 +4,47 @@
 using System.Runtime.CompilerServices;
 using System.Runtime.InteropServices;
 using System.Runtime.Intrinsics;
-using System.Runtime.Intrinsics.Arm;
-using static SixLabors.ImageSharp.SimdUtils;
+using SixLabors.ImageSharp.Common.Helpers;
+using SixLabors.ImageSharp.Metadata.Profiles.Icc;
 
 namespace SixLabors.ImageSharp.Formats.Jpeg.Components;
 
 internal abstract partial class JpegColorConverterBase
 {
-    internal sealed class GrayscaleArm : JpegColorConverterArm
+    internal sealed class GrayScaleVector128 : JpegColorConverterVector128
     {
-        public GrayscaleArm(int precision)
+        public GrayScaleVector128(int precision)
             : base(JpegColorSpace.Grayscale, precision)
         {
         }
 
         /// <inheritdoc/>
-        public override void ConvertToRgbInplace(in ComponentValues values)
+        public override void ConvertToRgbInPlaceWithIcc(Configuration configuration, in ComponentValues values, IccProfile profile)
+            => GrayScaleScalar.ConvertToRgbInPlaceWithIcc(configuration, profile, values, this.MaximumValue);
+
+        /// <inheritdoc/>
+        public override void ConvertToRgbInPlace(in ComponentValues values)
         {
             ref Vector128<float> c0Base =
                 ref Unsafe.As<float, Vector128<float>>(ref MemoryMarshal.GetReference(values.Component0));
 
+            ref Vector128<float> c1Base =
+                ref Unsafe.As<float, Vector128<float>>(ref MemoryMarshal.GetReference(values.Component1));
+
+            ref Vector128<float> c2Base =
+                ref Unsafe.As<float, Vector128<float>>(ref MemoryMarshal.GetReference(values.Component2));
+
             // Used for the color conversion
-            var scale = Vector128.Create(1 / this.MaximumValue);
+            Vector128<float> scale = Vector128.Create(1 / this.MaximumValue);
 
             nuint n = values.Component0.Vector128Count<float>();
             for (nuint i = 0; i < n; i++)
             {
-                ref Vector128<float> c0 = ref Unsafe.Add(ref c0Base, i);
-                c0 = AdvSimd.Multiply(c0, scale);
+                Vector128<float> c = Unsafe.Add(ref c0Base, i) * scale;
+
+                Unsafe.Add(ref c0Base, i) = c;
+                Unsafe.Add(ref c1Base, i) = c;
+                Unsafe.Add(ref c2Base, i) = c;
             }
         }
 
@@ -49,9 +62,9 @@ internal abstract partial class JpegColorConverterBase
                 ref Unsafe.As<float, Vector128<float>>(ref MemoryMarshal.GetReference(bLane));
 
             // Used for the color conversion
-            var f0299 = Vector128.Create(0.299f);
-            var f0587 = Vector128.Create(0.587f);
-            var f0114 = Vector128.Create(0.114f);
+            Vector128<float> f0299 = Vector128.Create(0.299f);
+            Vector128<float> f0587 = Vector128.Create(0.587f);
+            Vector128<float> f0114 = Vector128.Create(0.114f);
 
             nuint n = values.Component0.Vector128Count<float>();
             for (nuint i = 0; i < n; i++)
@@ -60,8 +73,8 @@ internal abstract partial class JpegColorConverterBase
                 ref Vector128<float> g = ref Unsafe.Add(ref srcGreen, i);
                 ref Vector128<float> b = ref Unsafe.Add(ref srcBlue, i);
 
-                // luminocity = (0.299 * r) + (0.587 * g) + (0.114 * b)
-                Unsafe.Add(ref destLuminance, i) = HwIntrinsics.MultiplyAdd(HwIntrinsics.MultiplyAdd(AdvSimd.Multiply(f0114, b), f0587, g), f0299, r);
+                // luminosity = (0.299 * r) + (0.587 * g) + (0.114 * b)
+                Unsafe.Add(ref destLuminance, i) = Vector128_.MultiplyAdd(Vector128_.MultiplyAdd(f0114 * b, f0587, g), f0299, r);
             }
         }
     }
diff --git a/src/ImageSharp/Formats/Jpeg/Components/ColorConverters/JpegColorConverter.GrayScaleAvx.cs b/src/ImageSharp/Formats/Jpeg/Components/ColorConverters/JpegColorConverter.GrayScaleVector256.cs
similarity index 56%
rename from src/ImageSharp/Formats/Jpeg/Components/ColorConverters/JpegColorConverter.GrayScaleAvx.cs
rename to src/ImageSharp/Formats/Jpeg/Components/ColorConverters/JpegColorConverter.GrayScaleVector256.cs
index a9e1c5d130..0b2b8a119f 100644
--- a/src/ImageSharp/Formats/Jpeg/Components/ColorConverters/JpegColorConverter.GrayScaleAvx.cs
+++ b/src/ImageSharp/Formats/Jpeg/Components/ColorConverters/JpegColorConverter.GrayScaleVector256.cs
@@ -4,37 +4,50 @@
 using System.Runtime.CompilerServices;
 using System.Runtime.InteropServices;
 using System.Runtime.Intrinsics;
-using System.Runtime.Intrinsics.X86;
-using static SixLabors.ImageSharp.SimdUtils;
+using SixLabors.ImageSharp.Common.Helpers;
+using SixLabors.ImageSharp.Metadata.Profiles.Icc;
 
 namespace SixLabors.ImageSharp.Formats.Jpeg.Components;
 
 internal abstract partial class JpegColorConverterBase
 {
-    internal sealed class GrayscaleAvx : JpegColorConverterAvx
+    internal sealed class GrayScaleVector256 : JpegColorConverterVector256
     {
-        public GrayscaleAvx(int precision)
+        public GrayScaleVector256(int precision)
             : base(JpegColorSpace.Grayscale, precision)
         {
         }
 
         /// <inheritdoc/>
-        public override void ConvertToRgbInplace(in ComponentValues values)
+        public override void ConvertToRgbInPlace(in ComponentValues values)
         {
             ref Vector256<float> c0Base =
                 ref Unsafe.As<float, Vector256<float>>(ref MemoryMarshal.GetReference(values.Component0));
 
+            ref Vector256<float> c1Base =
+                ref Unsafe.As<float, Vector256<float>>(ref MemoryMarshal.GetReference(values.Component1));
+
+            ref Vector256<float> c2Base =
+                ref Unsafe.As<float, Vector256<float>>(ref MemoryMarshal.GetReference(values.Component2));
+
             // Used for the color conversion
-            var scale = Vector256.Create(1 / this.MaximumValue);
+            Vector256<float> scale = Vector256.Create(1 / this.MaximumValue);
 
             nuint n = values.Component0.Vector256Count<float>();
             for (nuint i = 0; i < n; i++)
             {
-                ref Vector256<float> c0 = ref Unsafe.Add(ref c0Base, i);
-                c0 = Avx.Multiply(c0, scale);
+                Vector256<float> c = Unsafe.Add(ref c0Base, i) * scale;
+
+                Unsafe.Add(ref c0Base, i) = c;
+                Unsafe.Add(ref c1Base, i) = c;
+                Unsafe.Add(ref c2Base, i) = c;
             }
         }
 
+        /// <inheritdoc/>
+        public override void ConvertToRgbInPlaceWithIcc(Configuration configuration, in ComponentValues values, IccProfile profile)
+            => GrayScaleScalar.ConvertToRgbInPlaceWithIcc(configuration, profile, values, this.MaximumValue);
+
         /// <inheritdoc/>
         public override void ConvertFromRgb(in ComponentValues values, Span<float> rLane, Span<float> gLane, Span<float> bLane)
         {
@@ -49,9 +62,9 @@ internal abstract partial class JpegColorConverterBase
                 ref Unsafe.As<float, Vector256<float>>(ref MemoryMarshal.GetReference(bLane));
 
             // Used for the color conversion
-            var f0299 = Vector256.Create(0.299f);
-            var f0587 = Vector256.Create(0.587f);
-            var f0114 = Vector256.Create(0.114f);
+            Vector256<float> f0299 = Vector256.Create(0.299f);
+            Vector256<float> f0587 = Vector256.Create(0.587f);
+            Vector256<float> f0114 = Vector256.Create(0.114f);
 
             nuint n = values.Component0.Vector256Count<float>();
             for (nuint i = 0; i < n; i++)
@@ -60,8 +73,8 @@ internal abstract partial class JpegColorConverterBase
                 ref Vector256<float> g = ref Unsafe.Add(ref srcGreen, i);
                 ref Vector256<float> b = ref Unsafe.Add(ref srcBlue, i);
 
-                // luminocity = (0.299 * r) + (0.587 * g) + (0.114 * b)
-                Unsafe.Add(ref destLuminance, i) = HwIntrinsics.MultiplyAdd(HwIntrinsics.MultiplyAdd(Avx.Multiply(f0114, b), f0587, g), f0299, r);
+                // luminosity = (0.299 * r) + (0.587 * g) + (0.114 * b)
+                Unsafe.Add(ref destLuminance, i) = Vector256_.MultiplyAdd(Vector256_.MultiplyAdd(f0114 * b, f0587, g), f0299, r);
             }
         }
     }
diff --git a/src/ImageSharp/Formats/Jpeg/Components/ColorConverters/JpegColorConverter.GrayScaleVector512.cs b/src/ImageSharp/Formats/Jpeg/Components/ColorConverters/JpegColorConverter.GrayScaleVector512.cs
new file mode 100644
index 0000000000..0a58b0196b
--- /dev/null
+++ b/src/ImageSharp/Formats/Jpeg/Components/ColorConverters/JpegColorConverter.GrayScaleVector512.cs
@@ -0,0 +1,89 @@
+// Copyright (c) Six Labors.
+// Licensed under the Six Labors Split License.
+
+using System.Runtime.CompilerServices;
+using System.Runtime.InteropServices;
+using System.Runtime.Intrinsics;
+using SixLabors.ImageSharp.Common.Helpers;
+using SixLabors.ImageSharp.Metadata.Profiles.Icc;
+
+namespace SixLabors.ImageSharp.Formats.Jpeg.Components;
+
+internal abstract partial class JpegColorConverterBase
+{
+    internal sealed class GrayScaleVector512 : JpegColorConverterVector512
+    {
+        public GrayScaleVector512(int precision)
+            : base(JpegColorSpace.Grayscale, precision)
+        {
+        }
+
+        /// <inheritdoc/>
+        public override void ConvertToRgbInPlaceWithIcc(Configuration configuration, in ComponentValues values, IccProfile profile)
+            => GrayScaleScalar.ConvertToRgbInPlaceWithIcc(configuration, profile, values, this.MaximumValue);
+
+        /// <inheritdoc/>
+        protected override void ConvertToRgbInPlaceVectorized(in ComponentValues values)
+        {
+            ref Vector512<float> c0Base =
+                ref Unsafe.As<float, Vector512<float>>(ref MemoryMarshal.GetReference(values.Component0));
+
+            ref Vector512<float> c1Base =
+                ref Unsafe.As<float, Vector512<float>>(ref MemoryMarshal.GetReference(values.Component1));
+
+            ref Vector512<float> c2Base =
+                ref Unsafe.As<float, Vector512<float>>(ref MemoryMarshal.GetReference(values.Component2));
+
+            // Used for the color conversion
+            Vector512<float> scale = Vector512.Create(1 / this.MaximumValue);
+
+            nuint n = values.Component0.Vector512Count<float>();
+            for (nuint i = 0; i < n; i++)
+            {
+                Vector512<float> c = Unsafe.Add(ref c0Base, i) * scale;
+
+                Unsafe.Add(ref c0Base, i) = c;
+                Unsafe.Add(ref c1Base, i) = c;
+                Unsafe.Add(ref c2Base, i) = c;
+            }
+        }
+
+        /// <inheritdoc/>
+        protected override void ConvertFromRgbVectorized(in ComponentValues values, Span<float> rLane, Span<float> gLane, Span<float> bLane)
+        {
+            ref Vector512<float> destLuminance =
+                ref Unsafe.As<float, Vector512<float>>(ref MemoryMarshal.GetReference(values.Component0));
+
+            ref Vector512<float> srcRed =
+                ref Unsafe.As<float, Vector512<float>>(ref MemoryMarshal.GetReference(rLane));
+            ref Vector512<float> srcGreen =
+                ref Unsafe.As<float, Vector512<float>>(ref MemoryMarshal.GetReference(gLane));
+            ref Vector512<float> srcBlue =
+                ref Unsafe.As<float, Vector512<float>>(ref MemoryMarshal.GetReference(bLane));
+
+            // Used for the color conversion
+            Vector512<float> f0299 = Vector512.Create(0.299f);
+            Vector512<float> f0587 = Vector512.Create(0.587f);
+            Vector512<float> f0114 = Vector512.Create(0.114f);
+
+            nuint n = values.Component0.Vector512Count<float>();
+            for (nuint i = 0; i < n; i++)
+            {
+                ref Vector512<float> r = ref Unsafe.Add(ref srcRed, i);
+                ref Vector512<float> g = ref Unsafe.Add(ref srcGreen, i);
+                ref Vector512<float> b = ref Unsafe.Add(ref srcBlue, i);
+
+                // luminosity = (0.299 * r) + (0.587 * g) + (0.114 * b)
+                Unsafe.Add(ref destLuminance, i) = Vector512_.MultiplyAdd(Vector512_.MultiplyAdd(f0114 * b, f0587, g), f0299, r);
+            }
+        }
+
+        /// <inheritdoc/>
+        protected override void ConvertToRgbInPlaceScalarRemainder(in ComponentValues values)
+            => GrayScaleScalar.ConvertToRgbInPlace(in values, this.MaximumValue);
+
+        /// <inheritdoc/>
+        protected override void ConvertFromRgbScalarRemainder(in ComponentValues values, Span<float> rLane, Span<float> gLane, Span<float> bLane)
+            => GrayScaleScalar.ConvertFromRgbScalar(values, rLane, gLane, bLane);
+    }
+}
diff --git a/src/ImageSharp/Formats/Jpeg/Components/ColorConverters/JpegColorConverter.RgbScalar.cs b/src/ImageSharp/Formats/Jpeg/Components/ColorConverters/JpegColorConverter.RgbScalar.cs
index a43b7ef842..92be9e8961 100644
--- a/src/ImageSharp/Formats/Jpeg/Components/ColorConverters/JpegColorConverter.RgbScalar.cs
+++ b/src/ImageSharp/Formats/Jpeg/Components/ColorConverters/JpegColorConverter.RgbScalar.cs
@@ -1,6 +1,14 @@
 // Copyright (c) Six Labors.
 // Licensed under the Six Labors Split License.
 
+using System.Buffers;
+using System.Numerics;
+using System.Runtime.CompilerServices;
+using System.Runtime.InteropServices;
+using SixLabors.ImageSharp.ColorProfiles;
+using SixLabors.ImageSharp.ColorProfiles.Icc;
+using SixLabors.ImageSharp.Metadata.Profiles.Icc;
+
 namespace SixLabors.ImageSharp.Formats.Jpeg.Components;
 
 internal abstract partial class JpegColorConverterBase
@@ -13,25 +21,64 @@ internal abstract partial class JpegColorConverterBase
         }
 
         /// <inheritdoc/>
-        public override void ConvertToRgbInplace(in ComponentValues values)
-            => ConvertToRgbInplace(values, this.MaximumValue);
+        public override void ConvertToRgbInPlace(in ComponentValues values)
+            => ConvertToRgbInPlace(values, this.MaximumValue);
+
+        /// <inheritdoc/>
+        public override void ConvertToRgbInPlaceWithIcc(Configuration configuration, in ComponentValues values, IccProfile profile)
+            => ConvertToRgbInPlaceWithIcc(configuration, profile, values, this.MaximumValue);
 
         /// <inheritdoc/>
-        public override void ConvertFromRgb(in ComponentValues values, Span<float> r, Span<float> g, Span<float> b)
-            => ConvertFromRgb(values, r, g, b);
+        public override void ConvertFromRgb(in ComponentValues values, Span<float> rLane, Span<float> gLane, Span<float> bLane)
+            => ConvertFromRgb(values, rLane, gLane, bLane);
 
-        internal static void ConvertToRgbInplace(ComponentValues values, float maxValue)
+        public static void ConvertToRgbInPlaceWithIcc(Configuration configuration, IccProfile profile, in ComponentValues values, float maxValue)
         {
-            GrayscaleScalar.ConvertToRgbInplace(values.Component0, maxValue);
-            GrayscaleScalar.ConvertToRgbInplace(values.Component1, maxValue);
-            GrayscaleScalar.ConvertToRgbInplace(values.Component2, maxValue);
+            using IMemoryOwner<float> memoryOwner = configuration.MemoryAllocator.Allocate<float>(values.Component0.Length * 3);
+            Span<float> packed = memoryOwner.Memory.Span;
+
+            Span<float> c0 = values.Component0;
+            Span<float> c1 = values.Component1;
+            Span<float> c2 = values.Component2;
+
+            PackedNormalizeInterleave3(c0, c1, c2, packed, 1F / maxValue);
+
+            Span<Rgb> source = MemoryMarshal.Cast<float, Rgb>(packed);
+            Span<Rgb> destination = MemoryMarshal.Cast<float, Rgb>(packed);
+
+            ColorConversionOptions options = new()
+            {
+                SourceIccProfile = profile,
+                TargetIccProfile = CompactSrgbV4Profile.Profile,
+            };
+            ColorProfileConverter converter = new(options);
+            converter.Convert<Rgb, Rgb>(source, destination);
+
+            UnpackDeinterleave3(MemoryMarshal.Cast<float, Vector3>(packed)[..source.Length], c0, c1, c2);
+        }
+
+        internal static void ConvertToRgbInPlace(ComponentValues values, float maxValue)
+        {
+            ref float c0Base = ref MemoryMarshal.GetReference(values.Component0);
+            ref float c1Base = ref MemoryMarshal.GetReference(values.Component1);
+            ref float c2Base = ref MemoryMarshal.GetReference(values.Component2);
+
+            float scale = 1F / maxValue;
+
+            for (nuint i = 0; i < (nuint)values.Component0.Length; i++)
+            {
+                Unsafe.Add(ref c0Base, i) *= scale;
+                Unsafe.Add(ref c1Base, i) *= scale;
+                Unsafe.Add(ref c2Base, i) *= scale;
+            }
         }
 
-        internal static void ConvertFromRgb(ComponentValues values, Span<float> r, Span<float> g, Span<float> b)
+        internal static void ConvertFromRgb(ComponentValues values, Span<float> rLane, Span<float> gLane, Span<float> bLane)
         {
-            r.CopyTo(values.Component0);
-            g.CopyTo(values.Component1);
-            b.CopyTo(values.Component2);
+            // TODO: This doesn't seem correct. We should be scaling to the maximum value here.
+            rLane.CopyTo(values.Component0);
+            gLane.CopyTo(values.Component1);
+            bLane.CopyTo(values.Component2);
         }
     }
 }
diff --git a/src/ImageSharp/Formats/Jpeg/Components/ColorConverters/JpegColorConverter.RgbVector.cs b/src/ImageSharp/Formats/Jpeg/Components/ColorConverters/JpegColorConverter.RgbVector.cs
deleted file mode 100644
index bd3142fa13..0000000000
--- a/src/ImageSharp/Formats/Jpeg/Components/ColorConverters/JpegColorConverter.RgbVector.cs
+++ /dev/null
@@ -1,59 +0,0 @@
-// Copyright (c) Six Labors.
-// Licensed under the Six Labors Split License.
-
-using System.Numerics;
-using System.Runtime.CompilerServices;
-using System.Runtime.InteropServices;
-
-namespace SixLabors.ImageSharp.Formats.Jpeg.Components;
-
-internal abstract partial class JpegColorConverterBase
-{
-    internal sealed class RgbVector : JpegColorConverterVector
-    {
-        public RgbVector(int precision)
-            : base(JpegColorSpace.RGB, precision)
-        {
-        }
-
-        /// <inheritdoc/>
-        protected override void ConvertToRgbInplaceVectorized(in ComponentValues values)
-        {
-            ref Vector<float> rBase =
-                ref Unsafe.As<float, Vector<float>>(ref MemoryMarshal.GetReference(values.Component0));
-            ref Vector<float> gBase =
-                ref Unsafe.As<float, Vector<float>>(ref MemoryMarshal.GetReference(values.Component1));
-            ref Vector<float> bBase =
-                ref Unsafe.As<float, Vector<float>>(ref MemoryMarshal.GetReference(values.Component2));
-
-            var scale = new Vector<float>(1 / this.MaximumValue);
-
-            nuint n = values.Component0.VectorCount<float>();
-            for (nuint i = 0; i < n; i++)
-            {
-                ref Vector<float> r = ref Unsafe.Add(ref rBase, i);
-                ref Vector<float> g = ref Unsafe.Add(ref gBase, i);
-                ref Vector<float> b = ref Unsafe.Add(ref bBase, i);
-                r *= scale;
-                g *= scale;
-                b *= scale;
-            }
-        }
-
-        /// <inheritdoc/>
-        protected override void ConvertToRgbInplaceScalarRemainder(in ComponentValues values)
-            => RgbScalar.ConvertToRgbInplace(values, this.MaximumValue);
-
-        /// <inheritdoc/>
-        protected override void ConvertFromRgbVectorized(in ComponentValues values, Span<float> r, Span<float> g, Span<float> b)
-        {
-            r.CopyTo(values.Component0);
-            g.CopyTo(values.Component1);
-            b.CopyTo(values.Component2);
-        }
-
-        /// <inheritdoc/>
-        protected override void ConvertFromRgbScalarRemainder(in ComponentValues values, Span<float> r, Span<float> g, Span<float> b)
-            => RgbScalar.ConvertFromRgb(values, r, g, b);
-    }
-}
diff --git a/src/ImageSharp/Formats/Jpeg/Components/ColorConverters/JpegColorConverter.RgbArm.cs b/src/ImageSharp/Formats/Jpeg/Components/ColorConverters/JpegColorConverter.RgbVector128.cs
similarity index 71%
rename from src/ImageSharp/Formats/Jpeg/Components/ColorConverters/JpegColorConverter.RgbArm.cs
rename to src/ImageSharp/Formats/Jpeg/Components/ColorConverters/JpegColorConverter.RgbVector128.cs
index 75eeb17dd3..6cbbc7c7cf 100644
--- a/src/ImageSharp/Formats/Jpeg/Components/ColorConverters/JpegColorConverter.RgbArm.cs
+++ b/src/ImageSharp/Formats/Jpeg/Components/ColorConverters/JpegColorConverter.RgbVector128.cs
@@ -4,22 +4,21 @@
 using System.Runtime.CompilerServices;
 using System.Runtime.InteropServices;
 using System.Runtime.Intrinsics;
-using System.Runtime.Intrinsics.Arm;
-using System.Runtime.Intrinsics.X86;
+using SixLabors.ImageSharp.Metadata.Profiles.Icc;
 
 namespace SixLabors.ImageSharp.Formats.Jpeg.Components;
 
 internal abstract partial class JpegColorConverterBase
 {
-    internal sealed class RgbArm : JpegColorConverterArm
+    internal sealed class RgbVector128 : JpegColorConverterVector128
     {
-        public RgbArm(int precision)
+        public RgbVector128(int precision)
             : base(JpegColorSpace.RGB, precision)
         {
         }
 
         /// <inheritdoc/>
-        public override void ConvertToRgbInplace(in ComponentValues values)
+        public override void ConvertToRgbInPlace(in ComponentValues values)
         {
             ref Vector128<float> rBase =
                 ref Unsafe.As<float, Vector128<float>>(ref MemoryMarshal.GetReference(values.Component0));
@@ -29,19 +28,23 @@ internal abstract partial class JpegColorConverterBase
                 ref Unsafe.As<float, Vector128<float>>(ref MemoryMarshal.GetReference(values.Component2));
 
             // Used for the color conversion
-            var scale = Vector128.Create(1 / this.MaximumValue);
+            Vector128<float> scale = Vector128.Create(1 / this.MaximumValue);
             nuint n = values.Component0.Vector128Count<float>();
             for (nuint i = 0; i < n; i++)
             {
                 ref Vector128<float> r = ref Unsafe.Add(ref rBase, i);
                 ref Vector128<float> g = ref Unsafe.Add(ref gBase, i);
                 ref Vector128<float> b = ref Unsafe.Add(ref bBase, i);
-                r = AdvSimd.Multiply(r, scale);
-                g = AdvSimd.Multiply(g, scale);
-                b = AdvSimd.Multiply(b, scale);
+                r *= scale;
+                g *= scale;
+                b *= scale;
             }
         }
 
+        /// <inheritdoc/>
+        public override void ConvertToRgbInPlaceWithIcc(Configuration configuration, in ComponentValues values, IccProfile profile)
+            => RgbScalar.ConvertToRgbInPlaceWithIcc(configuration, profile, values, this.MaximumValue);
+
         /// <inheritdoc/>
         public override void ConvertFromRgb(in ComponentValues values, Span<float> rLane, Span<float> gLane, Span<float> bLane)
         {
diff --git a/src/ImageSharp/Formats/Jpeg/Components/ColorConverters/JpegColorConverter.RgbAvx.cs b/src/ImageSharp/Formats/Jpeg/Components/ColorConverters/JpegColorConverter.RgbVector256.cs
similarity index 71%
rename from src/ImageSharp/Formats/Jpeg/Components/ColorConverters/JpegColorConverter.RgbAvx.cs
rename to src/ImageSharp/Formats/Jpeg/Components/ColorConverters/JpegColorConverter.RgbVector256.cs
index b56728fa71..10bc2be5f8 100644
--- a/src/ImageSharp/Formats/Jpeg/Components/ColorConverters/JpegColorConverter.RgbAvx.cs
+++ b/src/ImageSharp/Formats/Jpeg/Components/ColorConverters/JpegColorConverter.RgbVector256.cs
@@ -4,21 +4,21 @@
 using System.Runtime.CompilerServices;
 using System.Runtime.InteropServices;
 using System.Runtime.Intrinsics;
-using System.Runtime.Intrinsics.X86;
+using SixLabors.ImageSharp.Metadata.Profiles.Icc;
 
 namespace SixLabors.ImageSharp.Formats.Jpeg.Components;
 
 internal abstract partial class JpegColorConverterBase
 {
-    internal sealed class RgbAvx : JpegColorConverterAvx
+    internal sealed class RgbVector256 : JpegColorConverterVector256
     {
-        public RgbAvx(int precision)
+        public RgbVector256(int precision)
             : base(JpegColorSpace.RGB, precision)
         {
         }
 
         /// <inheritdoc/>
-        public override void ConvertToRgbInplace(in ComponentValues values)
+        public override void ConvertToRgbInPlace(in ComponentValues values)
         {
             ref Vector256<float> rBase =
                 ref Unsafe.As<float, Vector256<float>>(ref MemoryMarshal.GetReference(values.Component0));
@@ -28,19 +28,23 @@ internal abstract partial class JpegColorConverterBase
                 ref Unsafe.As<float, Vector256<float>>(ref MemoryMarshal.GetReference(values.Component2));
 
             // Used for the color conversion
-            var scale = Vector256.Create(1 / this.MaximumValue);
+            Vector256<float> scale = Vector256.Create(1 / this.MaximumValue);
             nuint n = values.Component0.Vector256Count<float>();
             for (nuint i = 0; i < n; i++)
             {
                 ref Vector256<float> r = ref Unsafe.Add(ref rBase, i);
                 ref Vector256<float> g = ref Unsafe.Add(ref gBase, i);
                 ref Vector256<float> b = ref Unsafe.Add(ref bBase, i);
-                r = Avx.Multiply(r, scale);
-                g = Avx.Multiply(g, scale);
-                b = Avx.Multiply(b, scale);
+                r *= scale;
+                g *= scale;
+                b *= scale;
             }
         }
 
+        /// <inheritdoc/>
+        public override void ConvertToRgbInPlaceWithIcc(Configuration configuration, in ComponentValues values, IccProfile profile)
+            => RgbScalar.ConvertToRgbInPlaceWithIcc(configuration, profile, values, this.MaximumValue);
+
         /// <inheritdoc/>
         public override void ConvertFromRgb(in ComponentValues values, Span<float> rLane, Span<float> gLane, Span<float> bLane)
         {
diff --git a/src/ImageSharp/Formats/Jpeg/Components/ColorConverters/JpegColorConverter.RgbVector512.cs b/src/ImageSharp/Formats/Jpeg/Components/ColorConverters/JpegColorConverter.RgbVector512.cs
new file mode 100644
index 0000000000..6e01ad7cb0
--- /dev/null
+++ b/src/ImageSharp/Formats/Jpeg/Components/ColorConverters/JpegColorConverter.RgbVector512.cs
@@ -0,0 +1,64 @@
+// Copyright (c) Six Labors.
+// Licensed under the Six Labors Split License.
+
+using System.Runtime.CompilerServices;
+using System.Runtime.InteropServices;
+using System.Runtime.Intrinsics;
+using SixLabors.ImageSharp.Metadata.Profiles.Icc;
+
+namespace SixLabors.ImageSharp.Formats.Jpeg.Components;
+
+internal abstract partial class JpegColorConverterBase
+{
+    internal sealed class RgbVector512 : JpegColorConverterVector512
+    {
+        public RgbVector512(int precision)
+            : base(JpegColorSpace.RGB, precision)
+        {
+        }
+
+        /// <inheritdoc/>
+        protected override void ConvertToRgbInPlaceVectorized(in ComponentValues values)
+        {
+            ref Vector512<float> rBase =
+                ref Unsafe.As<float, Vector512<float>>(ref MemoryMarshal.GetReference(values.Component0));
+            ref Vector512<float> gBase =
+                ref Unsafe.As<float, Vector512<float>>(ref MemoryMarshal.GetReference(values.Component1));
+            ref Vector512<float> bBase =
+                ref Unsafe.As<float, Vector512<float>>(ref MemoryMarshal.GetReference(values.Component2));
+
+            // Used for the color conversion
+            Vector512<float> scale = Vector512.Create(1 / this.MaximumValue);
+            nuint n = values.Component0.Vector512Count<float>();
+            for (nuint i = 0; i < n; i++)
+            {
+                ref Vector512<float> r = ref Unsafe.Add(ref rBase, i);
+                ref Vector512<float> g = ref Unsafe.Add(ref gBase, i);
+                ref Vector512<float> b = ref Unsafe.Add(ref bBase, i);
+                r *= scale;
+                g *= scale;
+                b *= scale;
+            }
+        }
+
+        /// <inheritdoc/>
+        public override void ConvertToRgbInPlaceWithIcc(Configuration configuration, in ComponentValues values, IccProfile profile)
+            => RgbScalar.ConvertToRgbInPlaceWithIcc(configuration, profile, values, this.MaximumValue);
+
+        /// <inheritdoc/>
+        protected override void ConvertFromRgbVectorized(in ComponentValues values, Span<float> rLane, Span<float> gLane, Span<float> bLane)
+        {
+            rLane.CopyTo(values.Component0);
+            gLane.CopyTo(values.Component1);
+            bLane.CopyTo(values.Component2);
+        }
+
+        /// <inheritdoc/>
+        protected override void ConvertToRgbInPlaceScalarRemainder(in ComponentValues values)
+            => RgbScalar.ConvertToRgbInPlace(values, this.MaximumValue);
+
+        /// <inheritdoc/>
+        protected override void ConvertFromRgbScalarRemainder(in ComponentValues values, Span<float> rLane, Span<float> gLane, Span<float> bLane)
+            => RgbScalar.ConvertFromRgb(values, rLane, gLane, bLane);
+    }
+}
diff --git a/src/ImageSharp/Formats/Jpeg/Components/ColorConverters/JpegColorConverter.TiffCmykScalar.cs b/src/ImageSharp/Formats/Jpeg/Components/ColorConverters/JpegColorConverter.TiffCmykScalar.cs
new file mode 100644
index 0000000000..27449a368a
--- /dev/null
+++ b/src/ImageSharp/Formats/Jpeg/Components/ColorConverters/JpegColorConverter.TiffCmykScalar.cs
@@ -0,0 +1,118 @@
+// Copyright (c) Six Labors.
+// Licensed under the Six Labors Split License.
+
+using System.Buffers;
+using System.Numerics;
+using System.Runtime.InteropServices;
+using SixLabors.ImageSharp.ColorProfiles;
+using SixLabors.ImageSharp.ColorProfiles.Icc;
+using SixLabors.ImageSharp.Metadata.Profiles.Icc;
+
+namespace SixLabors.ImageSharp.Formats.Jpeg.Components;
+
+internal abstract partial class JpegColorConverterBase
+{
+    /// <summary>
+    /// Color converter for tiff images, which use the jpeg compression and CMYK colorspace.
+    /// </summary>
+    internal sealed class TiffCmykScalar : JpegColorConverterScalar
+    {
+        public TiffCmykScalar(int precision)
+            : base(JpegColorSpace.TiffCmyk, precision)
+        {
+        }
+
+        /// <inheritdoc/>
+        public override void ConvertToRgbInPlace(in ComponentValues values)
+            => ConvertToRgbInPlace(in values, this.MaximumValue);
+
+        /// <inheritdoc/>
+        public override void ConvertToRgbInPlaceWithIcc(Configuration configuration, in ComponentValues values, IccProfile profile)
+            => ConvertToRgbInPlaceWithIcc(configuration, profile, values, this.MaximumValue);
+
+        public override void ConvertFromRgb(in ComponentValues values, Span<float> rLane, Span<float> gLane, Span<float> bLane)
+            => ConvertFromRgb(in values, this.MaximumValue, rLane, gLane, bLane);
+
+        public static void ConvertToRgbInPlace(in ComponentValues values, float maxValue)
+        {
+            Span<float> c0 = values.Component0;
+            Span<float> c1 = values.Component1;
+            Span<float> c2 = values.Component2;
+            Span<float> c3 = values.Component3;
+
+            float scale = 1 / maxValue;
+            for (int i = 0; i < c0.Length; i++)
+            {
+                float c = c0[i] * scale;
+                float m = c1[i] * scale;
+                float y = c2[i] * scale;
+                float k = 1 - (c3[i] * scale);
+
+                c0[i] = (1 - c) * k;
+                c1[i] = (1 - m) * k;
+                c2[i] = (1 - y) * k;
+            }
+        }
+
+        public static void ConvertFromRgb(in ComponentValues values, float maxValue, Span<float> rLane, Span<float> gLane, Span<float> bLane)
+        {
+            Span<float> c = values.Component0;
+            Span<float> m = values.Component1;
+            Span<float> y = values.Component2;
+            Span<float> k = values.Component3;
+
+            for (int i = 0; i < c.Length; i++)
+            {
+                float ctmp = 255F - rLane[i];
+                float mtmp = 255F - gLane[i];
+                float ytmp = 255F - bLane[i];
+                float ktmp = MathF.Min(MathF.Min(ctmp, mtmp), ytmp);
+
+                if (ktmp >= 255F)
+                {
+                    ctmp = 0F;
+                    mtmp = 0F;
+                    ytmp = 0F;
+                }
+                else
+                {
+                    float divisor = 1 / (255F - ktmp);
+                    ctmp = (ctmp - ktmp) * divisor;
+                    mtmp = (mtmp - ktmp) * divisor;
+                    ytmp = (ytmp - ktmp) * divisor;
+                }
+
+                c[i] = ctmp * maxValue;
+                m[i] = mtmp * maxValue;
+                y[i] = ytmp * maxValue;
+                k[i] = ktmp;
+            }
+        }
+
+        public static void ConvertToRgbInPlaceWithIcc(Configuration configuration, IccProfile profile, in ComponentValues values, float maxValue)
+        {
+            using IMemoryOwner<float> memoryOwner = configuration.MemoryAllocator.Allocate<float>(values.Component0.Length * 4);
+            Span<float> packed = memoryOwner.Memory.Span;
+
+            Span<float> c0 = values.Component0;
+            Span<float> c1 = values.Component1;
+            Span<float> c2 = values.Component2;
+            Span<float> c3 = values.Component3;
+
+            PackedNormalizeInterleave4(c0, c1, c2, c3, packed, maxValue);
+
+            Span<Cmyk> source = MemoryMarshal.Cast<float, Cmyk>(packed);
+            Span<Rgb> destination = MemoryMarshal.Cast<float, Rgb>(packed)[..source.Length];
+
+            ColorConversionOptions options = new()
+            {
+                SourceIccProfile = profile,
+                TargetIccProfile = CompactSrgbV4Profile.Profile,
+            };
+            ColorProfileConverter converter = new(options);
+            converter.Convert<Cmyk, Rgb>(source, destination);
+
+            UnpackDeinterleave3(MemoryMarshal.Cast<float, Vector3>(packed)[..source.Length], c0, c1, c2);
+        }
+    }
+}
diff --git a/src/ImageSharp/Formats/Jpeg/Components/ColorConverters/JpegColorConverter.TiffCmykVector128.cs b/src/ImageSharp/Formats/Jpeg/Components/ColorConverters/JpegColorConverter.TiffCmykVector128.cs
new file mode 100644
index 0000000000..6d52d5c728
--- /dev/null
+++ b/src/ImageSharp/Formats/Jpeg/Components/ColorConverters/JpegColorConverter.TiffCmykVector128.cs
@@ -0,0 +1,99 @@
+// Copyright (c) Six Labors.
+// Licensed under the Six Labors Split License.
+
+using System.Runtime.CompilerServices;
+using System.Runtime.InteropServices;
+using System.Runtime.Intrinsics;
+using SixLabors.ImageSharp.Metadata.Profiles.Icc;
+
+namespace SixLabors.ImageSharp.Formats.Jpeg.Components;
+
+internal abstract partial class JpegColorConverterBase
+{
+    internal sealed class TiffCmykVector128 : JpegColorConverterVector128
+    {
+        public TiffCmykVector128(int precision)
+            : base(JpegColorSpace.TiffCmyk, precision)
+        {
+        }
+
+        /// <inheritdoc/>
+        public override void ConvertToRgbInPlace(in ComponentValues values)
+        {
+            ref Vector128<float> c0Base =
+                ref Unsafe.As<float, Vector128<float>>(ref MemoryMarshal.GetReference(values.Component0));
+            ref Vector128<float> c1Base =
+                ref Unsafe.As<float, Vector128<float>>(ref MemoryMarshal.GetReference(values.Component1));
+            ref Vector128<float> c2Base =
+                ref Unsafe.As<float, Vector128<float>>(ref MemoryMarshal.GetReference(values.Component2));
+            ref Vector128<float> c3Base =
+                ref Unsafe.As<float, Vector128<float>>(ref MemoryMarshal.GetReference(values.Component3));
+
+            Vector128<float> scale = Vector128.Create(1 / this.MaximumValue);
+
+            nuint n = values.Component0.Vector128Count<float>();
+            for (nuint i = 0; i < n; i++)
+            {
+                ref Vector128<float> c = ref Unsafe.Add(ref c0Base, i);
+                ref Vector128<float> m = ref Unsafe.Add(ref c1Base, i);
+                ref Vector128<float> y = ref Unsafe.Add(ref c2Base, i);
+                Vector128<float> k = Unsafe.Add(ref c3Base, i);
+
+                k = Vector128<float>.One - (k * scale);
+                c = (Vector128<float>.One - (c * scale)) * k;
+                m = (Vector128<float>.One - (m * scale)) * k;
+                y = (Vector128<float>.One - (y * scale)) * k;
+            }
+        }
+
+        /// <inheritdoc/>
+        public override void ConvertToRgbInPlaceWithIcc(Configuration configuration, in ComponentValues values, IccProfile profile)
+            => TiffCmykScalar.ConvertToRgbInPlaceWithIcc(configuration, profile, values, this.MaximumValue);
+
+        /// <inheritdoc/>
+        public override void ConvertFromRgb(in ComponentValues values, Span<float> rLane, Span<float> gLane, Span<float> bLane)
+            => ConvertFromRgb(in values, this.MaximumValue, rLane, gLane, bLane);
+
+        public static void ConvertFromRgb(in ComponentValues values, float maxValue, Span<float> rLane, Span<float> gLane, Span<float> bLane)
+        {
+            ref Vector128<float> destC =
+                ref Unsafe.As<float, Vector128<float>>(ref MemoryMarshal.GetReference(values.Component0));
+            ref Vector128<float> destM =
+                ref Unsafe.As<float, Vector128<float>>(ref MemoryMarshal.GetReference(values.Component1));
+            ref Vector128<float> destY =
+                ref Unsafe.As<float, Vector128<float>>(ref MemoryMarshal.GetReference(values.Component2));
+            ref Vector128<float> destK =
+                ref Unsafe.As<float, Vector128<float>>(ref MemoryMarshal.GetReference(values.Component3));
+
+            ref Vector128<float> srcR =
+                ref Unsafe.As<float, Vector128<float>>(ref MemoryMarshal.GetReference(rLane));
+            ref Vector128<float> srcG =
+                ref Unsafe.As<float, Vector128<float>>(ref MemoryMarshal.GetReference(gLane));
+            ref Vector128<float> srcB =
+                ref Unsafe.As<float, Vector128<float>>(ref MemoryMarshal.GetReference(bLane));
+
+            Vector128<float> scale = Vector128.Create(maxValue);
+
+            nuint n = values.Component0.Vector128Count<float>();
+            for (nuint i = 0; i < n; i++)
+            {
+                Vector128<float> ctmp = scale - Unsafe.Add(ref srcR, i);
+                Vector128<float> mtmp = scale - Unsafe.Add(ref srcG, i);
+                Vector128<float> ytmp = scale - Unsafe.Add(ref srcB, i);
+                Vector128<float> ktmp = Vector128.Min(ctmp, Vector128.Min(mtmp, ytmp));
+
+                Vector128<float> kMask = ~Vector128.Equals(ktmp, scale);
+                Vector128<float> divisor = Vector128<float>.One / (scale - ktmp);
+
+                ctmp = ((ctmp - ktmp) * divisor) & kMask;
+                mtmp = ((mtmp - ktmp) * divisor) & kMask;
+                ytmp = ((ytmp - ktmp) * divisor) & kMask;
+
+                Unsafe.Add(ref destC, i) = ctmp * scale;
+                Unsafe.Add(ref destM, i) = mtmp * scale;
+                Unsafe.Add(ref destY, i) = ytmp * scale;
+                Unsafe.Add(ref destK, i) = ktmp;
+            }
+        }
+    }
+}
diff --git a/src/ImageSharp/Formats/Jpeg/Components/ColorConverters/JpegColorConverter.TiffCmykVector256.cs b/src/ImageSharp/Formats/Jpeg/Components/ColorConverters/JpegColorConverter.TiffCmykVector256.cs
new file mode 100644
index 0000000000..61b312a063
--- /dev/null
+++ b/src/ImageSharp/Formats/Jpeg/Components/ColorConverters/JpegColorConverter.TiffCmykVector256.cs
@@ -0,0 +1,99 @@
+// Copyright (c) Six Labors.
+// Licensed under the Six Labors Split License.
+
+using System.Runtime.CompilerServices;
+using System.Runtime.InteropServices;
+using System.Runtime.Intrinsics;
+using SixLabors.ImageSharp.Metadata.Profiles.Icc;
+
+namespace SixLabors.ImageSharp.Formats.Jpeg.Components;
+
+internal abstract partial class JpegColorConverterBase
+{
+    internal sealed class TiffCmykVector256 : JpegColorConverterVector256
+    {
+        public TiffCmykVector256(int precision)
+            : base(JpegColorSpace.TiffCmyk, precision)
+        {
+        }
+
+        /// <inheritdoc/>
+        public override void ConvertToRgbInPlace(in ComponentValues values)
+        {
+            ref Vector256<float> c0Base =
+                ref Unsafe.As<float, Vector256<float>>(ref MemoryMarshal.GetReference(values.Component0));
+            ref Vector256<float> c1Base =
+                ref Unsafe.As<float, Vector256<float>>(ref MemoryMarshal.GetReference(values.Component1));
+            ref Vector256<float> c2Base =
+                ref Unsafe.As<float, Vector256<float>>(ref MemoryMarshal.GetReference(values.Component2));
+            ref Vector256<float> c3Base =
+                ref Unsafe.As<float, Vector256<float>>(ref MemoryMarshal.GetReference(values.Component3));
+
+            Vector256<float> scale = Vector256.Create(1 / this.MaximumValue);
+
+            nuint n = values.Component0.Vector256Count<float>();
+            for (nuint i = 0; i < n; i++)
+            {
+                ref Vector256<float> c = ref Unsafe.Add(ref c0Base, i);
+                ref Vector256<float> m = ref Unsafe.Add(ref c1Base, i);
+                ref Vector256<float> y = ref Unsafe.Add(ref c2Base, i);
+                Vector256<float> k = Unsafe.Add(ref c3Base, i);
+
+                k = Vector256<float>.One - (k * scale);
+                c = (Vector256<float>.One - (c * scale)) * k;
+                m = (Vector256<float>.One - (m * scale)) * k;
+                y = (Vector256<float>.One - (y * scale)) * k;
+            }
+        }
+
+        /// <inheritdoc/>
+        public override void ConvertToRgbInPlaceWithIcc(Configuration configuration, in ComponentValues values, IccProfile profile)
+            => CmykScalar.ConvertToRgbInPlaceWithIcc(configuration, profile, values, this.MaximumValue);
+
+        /// <inheritdoc/>
+        public override void ConvertFromRgb(in ComponentValues values, Span<float> rLane, Span<float> gLane, Span<float> bLane)
+            => ConvertFromRgb(in values, this.MaximumValue, rLane, gLane, bLane);
+
+        public static void ConvertFromRgb(in ComponentValues values, float maxValue, Span<float> rLane, Span<float> gLane, Span<float> bLane)
+        {
+            ref Vector256<float> destC =
+                ref Unsafe.As<float, Vector256<float>>(ref MemoryMarshal.GetReference(values.Component0));
+            ref Vector256<float> destM =
+                ref Unsafe.As<float, Vector256<float>>(ref MemoryMarshal.GetReference(values.Component1));
+            ref Vector256<float> destY =
+                ref Unsafe.As<float, Vector256<float>>(ref MemoryMarshal.GetReference(values.Component2));
+            ref Vector256<float> destK =
+                ref Unsafe.As<float, Vector256<float>>(ref MemoryMarshal.GetReference(values.Component3));
+
+            ref Vector256<float> srcR =
+                ref Unsafe.As<float, Vector256<float>>(ref MemoryMarshal.GetReference(rLane));
+            ref Vector256<float> srcG =
+                ref Unsafe.As<float, Vector256<float>>(ref MemoryMarshal.GetReference(gLane));
+            ref Vector256<float> srcB =
+                ref Unsafe.As<float, Vector256<float>>(ref MemoryMarshal.GetReference(bLane));
+
+            Vector256<float> scale = Vector256.Create(maxValue);
+
+            nuint n = values.Component0.Vector256Count<float>();
+            for (nuint i = 0; i < n; i++)
+            {
+                Vector256<float> ctmp = scale - Unsafe.Add(ref srcR, i);
+                Vector256<float> mtmp = scale - Unsafe.Add(ref srcG, i);
+                Vector256<float> ytmp = scale - Unsafe.Add(ref srcB, i);
+                Vector256<float> ktmp = Vector256.Min(ctmp, Vector256.Min(mtmp, ytmp));
+
+                Vector256<float> kMask = ~Vector256.Equals(ktmp, scale);
+                Vector256<float> divisor = Vector256<float>.One / (scale - ktmp);
+
+                ctmp = ((ctmp - ktmp) * divisor) & kMask;
+                mtmp = ((mtmp - ktmp) * divisor) & kMask;
+                ytmp = ((ytmp - ktmp) * divisor) & kMask;
+
+                Unsafe.Add(ref destC, i) = ctmp * scale;
+                Unsafe.Add(ref destM, i) = mtmp * scale;
+                Unsafe.Add(ref destY, i) = ytmp * scale;
+                Unsafe.Add(ref destK, i) = ktmp;
+            }
+        }
+    }
+}
diff --git a/src/ImageSharp/Formats/Jpeg/Components/ColorConverters/JpegColorConverter.TiffCmykVector512.cs b/src/ImageSharp/Formats/Jpeg/Components/ColorConverters/JpegColorConverter.TiffCmykVector512.cs
new file mode 100644
index 0000000000..51d5cc76d3
--- /dev/null
+++ b/src/ImageSharp/Formats/Jpeg/Components/ColorConverters/JpegColorConverter.TiffCmykVector512.cs
@@ -0,0 +1,108 @@
+// Copyright (c) Six Labors.
+// Licensed under the Six Labors Split License.
+
+using System.Runtime.CompilerServices;
+using System.Runtime.InteropServices;
+using System.Runtime.Intrinsics;
+using SixLabors.ImageSharp.Metadata.Profiles.Icc;
+
+namespace SixLabors.ImageSharp.Formats.Jpeg.Components;
+
+internal abstract partial class JpegColorConverterBase
+{
+    internal sealed class TiffCmykVector512 : JpegColorConverterVector512
+    {
+        public TiffCmykVector512(int precision)
+            : base(JpegColorSpace.TiffCmyk, precision)
+        {
+        }
+
+        /// <inheritdoc/>
+        public override void ConvertToRgbInPlaceWithIcc(Configuration configuration, in ComponentValues values, IccProfile profile)
+            => TiffCmykScalar.ConvertToRgbInPlaceWithIcc(configuration, profile, values, this.MaximumValue);
+
+        /// <inheritdoc/>
+        protected override void ConvertToRgbInPlaceVectorized(in ComponentValues values)
+        {
+            ref Vector512<float> c0Base =
+                ref Unsafe.As<float, Vector512<float>>(ref MemoryMarshal.GetReference(values.Component0));
+            ref Vector512<float> c1Base =
+                ref Unsafe.As<float, Vector512<float>>(ref MemoryMarshal.GetReference(values.Component1));
+            ref Vector512<float> c2Base =
+                ref Unsafe.As<float, Vector512<float>>(ref MemoryMarshal.GetReference(values.Component2));
+            ref Vector512<float> c3Base =
+                ref Unsafe.As<float, Vector512<float>>(ref MemoryMarshal.GetReference(values.Component3));
+
+            // Used for the color conversion
+            Vector512<float> scale = Vector512.Create(1 / this.MaximumValue);
+
+            nuint n = values.Component0.Vector512Count<float>();
+            for (nuint i = 0; i < n; i++)
+            {
+                ref Vector512<float> c = ref Unsafe.Add(ref c0Base, i);
+                ref Vector512<float> m = ref Unsafe.Add(ref c1Base, i);
+                ref Vector512<float> y = ref Unsafe.Add(ref c2Base, i);
+                Vector512<float> k = Unsafe.Add(ref c3Base, i);
+
+                k = Vector512<float>.One - (k * scale);
+                c = (Vector512<float>.One - (c * scale)) * k;
+                m = (Vector512<float>.One - (m * scale)) * k;
+                y = (Vector512<float>.One - (y * scale)) * k;
+            }
+        }
+
+        /// <inheritdoc/>
+        protected override void ConvertFromRgbVectorized(in ComponentValues values, Span<float> rLane, Span<float> gLane, Span<float> bLane)
+            => ConvertFromRgbVectorized(in values, this.MaximumValue, rLane, gLane, bLane);
+
+        /// <inheritdoc/>
+        protected override void ConvertToRgbInPlaceScalarRemainder(in ComponentValues values)
+             => TiffCmykScalar.ConvertToRgbInPlace(values, this.MaximumValue);
+
+        /// <inheritdoc/>
+        protected override void ConvertFromRgbScalarRemainder(in ComponentValues values, Span<float> rLane, Span<float> gLane, Span<float> bLane)
+            => TiffCmykScalar.ConvertFromRgb(values, this.MaximumValue, rLane, gLane, bLane);
+
+        internal static void ConvertFromRgbVectorized(in ComponentValues values, float maxValue, Span<float> rLane, Span<float> gLane, Span<float> bLane)
+        {
+            ref Vector512<float> destC =
+                ref Unsafe.As<float, Vector512<float>>(ref MemoryMarshal.GetReference(values.Component0));
+            ref Vector512<float> destM =
+                ref Unsafe.As<float, Vector512<float>>(ref MemoryMarshal.GetReference(values.Component1));
+            ref Vector512<float> destY =
+                ref Unsafe.As<float, Vector512<float>>(ref MemoryMarshal.GetReference(values.Component2));
+            ref Vector512<float> destK =
+                ref Unsafe.As<float, Vector512<float>>(ref MemoryMarshal.GetReference(values.Component3));
+
+            ref Vector512<float> srcR =
+                ref Unsafe.As<float, Vector512<float>>(ref MemoryMarshal.GetReference(rLane));
+            ref Vector512<float> srcG =
+                ref Unsafe.As<float, Vector512<float>>(ref MemoryMarshal.GetReference(gLane));
+            ref Vector512<float> srcB =
+                ref Unsafe.As<float, Vector512<float>>(ref MemoryMarshal.GetReference(bLane));
+
+            Vector512<float> scale = Vector512.Create(maxValue);
+
+            nuint n = values.Component0.Vector512Count<float>();
+            for (nuint i = 0; i < n; i++)
+            {
+                Vector512<float> ctmp = scale - Unsafe.Add(ref srcR, i);
+                Vector512<float> mtmp = scale - Unsafe.Add(ref srcG, i);
+                Vector512<float> ytmp = scale - Unsafe.Add(ref srcB, i);
+                Vector512<float> ktmp = Vector512.Min(ctmp, Vector512.Min(mtmp, ytmp));
+
+                Vector512<float> kMask = ~Vector512.Equals(ktmp, scale);
+                Vector512<float> divisor = Vector512<float>.One / (scale - ktmp);
+
+                ctmp = ((ctmp - ktmp) * divisor) & kMask;
+                mtmp = ((mtmp - ktmp) * divisor) & kMask;
+                ytmp = ((ytmp - ktmp) * divisor) & kMask;
+
+                Unsafe.Add(ref destC, i) = ctmp * scale;
+                Unsafe.Add(ref destM, i) = mtmp * scale;
+                Unsafe.Add(ref destY, i) = ytmp * scale;
+                Unsafe.Add(ref destK, i) = ktmp;
+            }
+        }
+    }
+}
diff --git a/src/ImageSharp/Formats/Jpeg/Components/ColorConverters/JpegColorConverter.TiffYccKScalar.cs b/src/ImageSharp/Formats/Jpeg/Components/ColorConverters/JpegColorConverter.TiffYccKScalar.cs
new file mode 100644
index 0000000000..01bfc0875a
--- /dev/null
+++ b/src/ImageSharp/Formats/Jpeg/Components/ColorConverters/JpegColorConverter.TiffYccKScalar.cs
@@ -0,0 +1,153 @@
+// Copyright (c) Six Labors.
+// Licensed under the Six Labors Split License.
+
+using System.Buffers;
+using System.Numerics;
+using System.Runtime.InteropServices;
+using SixLabors.ImageSharp.ColorProfiles;
+using SixLabors.ImageSharp.ColorProfiles.Icc;
+using SixLabors.ImageSharp.Metadata.Profiles.Icc;
+
+namespace SixLabors.ImageSharp.Formats.Jpeg.Components;
+
+internal abstract partial class JpegColorConverterBase
+{
+    /// <summary>
+    /// Color converter for tiff images, which use the jpeg compression and CMYK colorspace.
+    /// </summary>
+    internal sealed class TiffYccKScalar : JpegColorConverterScalar
+    {
+        // Derived from ITU-T Rec. T.871
+        internal const float RCrMult = 1.402f;
+        internal const float GCbMult = (float)(0.114 * 1.772 / 0.587);
+        internal const float GCrMult = (float)(0.299 * 1.402 / 0.587);
+        internal const float BCbMult = 1.772f;
+
+        public TiffYccKScalar(int precision)
+            : base(JpegColorSpace.TiffYccK, precision)
+        {
+        }
+
+        /// <inheritdoc/>
+        public override void ConvertToRgbInPlace(in ComponentValues values)
+            => ConvertToRgbInPlace(in values, this.MaximumValue, this.HalfValue);
+
+        /// <inheritdoc/>
+        public override void ConvertToRgbInPlaceWithIcc(Configuration configuration, in ComponentValues values, IccProfile profile)
+            => ConvertToRgbInPlaceWithIcc(configuration, profile, values, this.MaximumValue);
+
+        public override void ConvertFromRgb(in ComponentValues values, Span<float> rLane, Span<float> gLane, Span<float> bLane)
+            => ConvertFromRgb(values, this.HalfValue, this.MaximumValue, rLane, gLane, bLane);
+
+        public static void ConvertToRgbInPlace(in ComponentValues values, float maxValue, float halfValue)
+        {
+            Span<float> c0 = values.Component0;
+            Span<float> c1 = values.Component1;
+            Span<float> c2 = values.Component2;
+            Span<float> c3 = values.Component3;
+
+            float scale = 1F / maxValue;
+            halfValue *= scale;
+
+            for (int i = 0; i < values.Component0.Length; i++)
+            {
+                float y = c0[i] * scale;
+                float cb = (c1[i] * scale) - halfValue;
+                float cr = (c2[i] * scale) - halfValue;
+                float scaledK = 1 - (c3[i] * scale);
+
+                // r = y + (1.402F * cr);
+                // g = y - (0.344136F * cb) - (0.714136F * cr);
+                // b = y + (1.772F * cb);
+                c0[i] = (y + (RCrMult * cr)) * scaledK;
+                c1[i] = (y - (GCbMult * cb) - (GCrMult * cr)) * scaledK;
+                c2[i] = (y + (BCbMult * cb)) * scaledK;
+            }
+        }
+
+        public static void ConvertFromRgb(in ComponentValues values, float halfValue, float maxValue, Span<float> rLane, Span<float> gLane, Span<float> bLane)
+        {
+            Span<float> y = values.Component0;
+            Span<float> cb = values.Component1;
+            Span<float> cr = values.Component2;
+            Span<float> k = values.Component3;
+
+            for (int i = 0; i < cr.Length; i++)
+            {
+                // Scale down to [0-1]
+                const float divisor = 1F / 255F;
+                float r = rLane[i] * divisor;
+                float g = gLane[i] * divisor;
+                float b = bLane[i] * divisor;
+
+                float ytmp;
+                float cbtmp;
+                float crtmp;
+                float ktmp = 1F - MathF.Max(r, MathF.Max(g, b));
+
+                if (ktmp >= 1F)
+                {
+                    ytmp = 0F;
+                    cbtmp = 0.5F;
+                    crtmp = 0.5F;
+                    ktmp = maxValue;
+                }
+                else
+                {
+                    float kmask = 1F / (1F - ktmp);
+                    r *= kmask;
+                    g *= kmask;
+                    b *= kmask;
+
+                    // Scale to [0-maxValue]
+                    ytmp = ((0.299f * r) + (0.587f * g) + (0.114f * b)) * maxValue;
+                    cbtmp = halfValue - (((0.168736f * r) - (0.331264f * g) + (0.5f * b)) * maxValue);
+                    crtmp = halfValue + (((0.5f * r) - (0.418688f * g) - (0.081312f * b)) * maxValue);
+                    ktmp *= maxValue;
+                }
+
+                y[i] = ytmp;
+                cb[i] = cbtmp;
+                cr[i] = crtmp;
+                k[i] = ktmp;
+            }
+        }
+
+        public static void ConvertToRgbInPlaceWithIcc(Configuration configuration, IccProfile profile, in ComponentValues values, float maxValue)
+        {
+            using IMemoryOwner<float> memoryOwner = configuration.MemoryAllocator.Allocate<float>(values.Component0.Length * 4);
+            Span<float> packed = memoryOwner.Memory.Span;
+
+            Span<float> c0 = values.Component0;
+            Span<float> c1 = values.Component1;
+            Span<float> c2 = values.Component2;
+            Span<float> c3 = values.Component3;
+
+            PackedNormalizeInterleave4(c0, c1, c2, c3, packed, maxValue);
+
+            ColorProfileConverter converter = new();
+            Span<Cmyk> source = MemoryMarshal.Cast<float, Cmyk>(packed);
+
+            // YccK is not a defined ICC color space � it's a JPEG-specific encoding used in Adobe-style CMYK JPEGs.
+            // ICC profiles expect colorimetric CMYK values, so we must first convert YccK to CMYK using a hardcoded inverse transform.
+            // This transform assumes Rec.601 YCbCr coefficients and an inverted K channel.
+            //
+            // The YccK => Cmyk conversion is independent of any embedded ICC profile.
+            // Since the same RGB working space is used during conversion to and from XYZ,
+            // colorimetric accuracy is preserved.
+            converter.Convert<YccK, Cmyk>(MemoryMarshal.Cast<Cmyk, YccK>(source), source);
+
+            Span<Rgb> destination = MemoryMarshal.Cast<float, Rgb>(packed)[..source.Length];
+
+            ColorConversionOptions options = new()
+            {
+                SourceIccProfile = profile,
+                TargetIccProfile = CompactSrgbV4Profile.Profile,
+            };
+            converter = new ColorProfileConverter(options);
+            converter.Convert<Cmyk, Rgb>(source, destination);
+
+            UnpackDeinterleave3(MemoryMarshal.Cast<float, Vector3>(packed)[..source.Length], c0, c1, c2);
+        }
+    }
+}
diff --git a/src/ImageSharp/Formats/Jpeg/Components/ColorConverters/JpegColorConverter.TiffYccKVector128.cs b/src/ImageSharp/Formats/Jpeg/Components/ColorConverters/JpegColorConverter.TiffYccKVector128.cs
new file mode 100644
index 0000000000..b360c373ad
--- /dev/null
+++ b/src/ImageSharp/Formats/Jpeg/Components/ColorConverters/JpegColorConverter.TiffYccKVector128.cs
@@ -0,0 +1,131 @@
+// Copyright (c) Six Labors.
+// Licensed under the Six Labors Split License.
+
+using System.Runtime.CompilerServices;
+using System.Runtime.InteropServices;
+using System.Runtime.Intrinsics;
+using SixLabors.ImageSharp.Common.Helpers;
+using SixLabors.ImageSharp.Metadata.Profiles.Icc;
+
+namespace SixLabors.ImageSharp.Formats.Jpeg.Components;
+
+internal abstract partial class JpegColorConverterBase
+{
+    internal sealed class TiffYccKVector128 : JpegColorConverterVector128
+    {
+        public TiffYccKVector128(int precision)
+            : base(JpegColorSpace.TiffYccK, precision)
+        {
+        }
+
+        /// <inheritdoc/>
+        public override void ConvertToRgbInPlace(in ComponentValues values)
+        {
+            ref Vector128<float> c0Base =
+                ref Unsafe.As<float, Vector128<float>>(ref MemoryMarshal.GetReference(values.Component0));
+            ref Vector128<float> c1Base =
+                ref Unsafe.As<float, Vector128<float>>(ref MemoryMarshal.GetReference(values.Component1));
+            ref Vector128<float> c2Base =
+                ref Unsafe.As<float, Vector128<float>>(ref MemoryMarshal.GetReference(values.Component2));
+            ref Vector128<float> c3Base =
+                ref Unsafe.As<float, Vector128<float>>(ref MemoryMarshal.GetReference(values.Component3));
+
+            Vector128<float> scale = Vector128.Create(1F / this.MaximumValue);
+            Vector128<float> chromaOffset = Vector128.Create(this.HalfValue) * scale;
+            Vector128<float> rCrMult = Vector128.Create(YCbCrScalar.RCrMult);
+            Vector128<float> gCbMult = Vector128.Create(-YCbCrScalar.GCbMult);
+            Vector128<float> gCrMult = Vector128.Create(-YCbCrScalar.GCrMult);
+            Vector128<float> bCbMult = Vector128.Create(YCbCrScalar.BCbMult);
+
+            nuint n = values.Component0.Vector128Count<float>();
+            for (nuint i = 0; i < n; i++)
+            {
+                ref Vector128<float> c0 = ref Unsafe.Add(ref c0Base, i);
+                ref Vector128<float> c1 = ref Unsafe.Add(ref c1Base, i);
+                ref Vector128<float> c2 = ref Unsafe.Add(ref c2Base, i);
+                ref Vector128<float> c3 = ref Unsafe.Add(ref c3Base, i);
+
+                Vector128<float> y = c0 * scale;
+                Vector128<float> cb = (c1 * scale) - chromaOffset;
+                Vector128<float> cr = (c2 * scale) - chromaOffset;
+                Vector128<float> scaledK = Vector128<float>.One - (c3 * scale);
+
+                // r = y + (1.402F * cr);
+                // g = y - (0.344136F * cb) - (0.714136F * cr);
+                // b = y + (1.772F * cb);
+                Vector128<float> r = Vector128_.MultiplyAdd(y, cr, rCrMult) * scaledK;
+                Vector128<float> g = Vector128_.MultiplyAdd(Vector128_.MultiplyAdd(y, cb, gCbMult), cr, gCrMult) * scaledK;
+                Vector128<float> b = Vector128_.MultiplyAdd(y, cb, bCbMult) * scaledK;
+
+                c0 = r;
+                c1 = g;
+                c2 = b;
+            }
+        }
+
+        /// <inheritdoc/>
+        public override void ConvertToRgbInPlaceWithIcc(Configuration configuration, in ComponentValues values, IccProfile profile)
+            => TiffYccKScalar.ConvertToRgbInPlaceWithIcc(configuration, profile, values, this.MaximumValue);
+
+        /// <inheritdoc/>
+        public override void ConvertFromRgb(in ComponentValues values, Span<float> rLane, Span<float> gLane, Span<float> bLane)
+        {
+            ref Vector128<float> srcR =
+                ref Unsafe.As<float, Vector128<float>>(ref MemoryMarshal.GetReference(rLane));
+            ref Vector128<float> srcG =
+                ref Unsafe.As<float, Vector128<float>>(ref MemoryMarshal.GetReference(gLane));
+            ref Vector128<float> srcB =
+                ref Unsafe.As<float, Vector128<float>>(ref MemoryMarshal.GetReference(bLane));
+
+            ref Vector128<float> destY =
+                ref Unsafe.As<float, Vector128<float>>(ref MemoryMarshal.GetReference(values.Component0));
+            ref Vector128<float> destCb =
+                ref Unsafe.As<float, Vector128<float>>(ref MemoryMarshal.GetReference(values.Component1));
+            ref Vector128<float> destCr =
+                ref Unsafe.As<float, Vector128<float>>(ref MemoryMarshal.GetReference(values.Component2));
+            ref Vector128<float> destK =
+                ref Unsafe.As<float, Vector128<float>>(ref MemoryMarshal.GetReference(values.Component3));
+
+            Vector128<float> maxSourceValue = Vector128.Create(1 / 255F);
+            Vector128<float> maxSampleValue = Vector128.Create(this.MaximumValue);
+            Vector128<float> chromaOffset = Vector128.Create(this.HalfValue);
+
+            Vector128<float> f0299 = Vector128.Create(0.299f);
+            Vector128<float> f0587 = Vector128.Create(0.587f);
+            Vector128<float> f0114 = Vector128.Create(0.114f);
+            Vector128<float> fn0168736 = Vector128.Create(-0.168736f);
+            Vector128<float> fn0331264 = Vector128.Create(-0.331264f);
+            Vector128<float> fn0418688 = Vector128.Create(-0.418688f);
+            Vector128<float> fn0081312F = Vector128.Create(-0.081312F);
+            Vector128<float> f05 = Vector128.Create(0.5f);
+
+            nuint n = values.Component0.Vector128Count<float>();
+            for (nuint i = 0; i < n; i++)
+            {
+                Vector128<float> r = Unsafe.Add(ref srcR, i) * maxSourceValue;
+                Vector128<float> g = Unsafe.Add(ref srcG, i) * maxSourceValue;
+                Vector128<float> b = Unsafe.Add(ref srcB, i) * maxSourceValue;
+                Vector128<float> ktmp = Vector128<float>.One - Vector128.Max(r, Vector128.Min(g, b));
+
+                Vector128<float> kMask = ~Vector128.Equals(ktmp, Vector128<float>.One);
+                Vector128<float> divisor = Vector128<float>.One / (Vector128<float>.One - ktmp);
+
+                r = (r * divisor) & kMask;
+                g = (g * divisor) & kMask;
+                b = (b * divisor) & kMask;
+
+                // y  =   0 + (0.299 * r) + (0.587 * g) + (0.114 * b)
+                // cb = 128 - (0.168736 * r) - (0.331264 * g) + (0.5 * b)
+                // cr = 128 + (0.5 * r) - (0.418688 * g) - (0.081312 * b)
+                Vector128<float> y = Vector128_.MultiplyAdd(Vector128_.MultiplyAdd(f0114 * b, f0587, g), f0299, r);
+                Vector128<float> cb = chromaOffset + Vector128_.MultiplyAdd(Vector128_.MultiplyAdd(f05 * b, fn0331264, g), fn0168736, r);
+                Vector128<float> cr = chromaOffset + Vector128_.MultiplyAdd(Vector128_.MultiplyAdd(fn0081312F * b, fn0418688, g), f05, r);
+
+                Unsafe.Add(ref destY, i) = y * maxSampleValue;
+                Unsafe.Add(ref destCb, i) = chromaOffset + (cb * maxSampleValue);
+                Unsafe.Add(ref destCr, i) = chromaOffset + (cr * maxSampleValue);
+                Unsafe.Add(ref destK, i) = ktmp * maxSampleValue;
+            }
+        }
+    }
+}
diff --git a/src/ImageSharp/Formats/Jpeg/Components/ColorConverters/JpegColorConverter.TiffYccKVector256.cs b/src/ImageSharp/Formats/Jpeg/Components/ColorConverters/JpegColorConverter.TiffYccKVector256.cs
new file mode 100644
index 0000000000..f996522d36
--- /dev/null
+++ b/src/ImageSharp/Formats/Jpeg/Components/ColorConverters/JpegColorConverter.TiffYccKVector256.cs
@@ -0,0 +1,131 @@
+// Copyright (c) Six Labors.
+// Licensed under the Six Labors Split License.
+
+using System.Runtime.CompilerServices;
+using System.Runtime.InteropServices;
+using System.Runtime.Intrinsics;
+using SixLabors.ImageSharp.Common.Helpers;
+using SixLabors.ImageSharp.Metadata.Profiles.Icc;
+
+namespace SixLabors.ImageSharp.Formats.Jpeg.Components;
+
+internal abstract partial class JpegColorConverterBase
+{
+    internal sealed class TiffYccKVector256 : JpegColorConverterVector256
+    {
+        public TiffYccKVector256(int precision)
+            : base(JpegColorSpace.TiffYccK, precision)
+        {
+        }
+
+        /// <inheritdoc/>
+        public override void ConvertToRgbInPlace(in ComponentValues values)
+        {
+            ref Vector256<float> c0Base =
+                ref Unsafe.As<float, Vector256<float>>(ref MemoryMarshal.GetReference(values.Component0));
+            ref Vector256<float> c1Base =
+                ref Unsafe.As<float, Vector256<float>>(ref MemoryMarshal.GetReference(values.Component1));
+            ref Vector256<float> c2Base =
+                ref Unsafe.As<float, Vector256<float>>(ref MemoryMarshal.GetReference(values.Component2));
+            ref Vector256<float> c3Base =
+                ref Unsafe.As<float, Vector256<float>>(ref MemoryMarshal.GetReference(values.Component3));
+
+            Vector256<float> scale = Vector256.Create(1F / this.MaximumValue);
+            Vector256<float> chromaOffset = Vector256.Create(this.HalfValue) * scale;
+            Vector256<float> rCrMult = Vector256.Create(YCbCrScalar.RCrMult);
+            Vector256<float> gCbMult = Vector256.Create(-YCbCrScalar.GCbMult);
+            Vector256<float> gCrMult = Vector256.Create(-YCbCrScalar.GCrMult);
+            Vector256<float> bCbMult = Vector256.Create(YCbCrScalar.BCbMult);
+
+            nuint n = values.Component0.Vector256Count<float>();
+            for (nuint i = 0; i < n; i++)
+            {
+                ref Vector256<float> c0 = ref Unsafe.Add(ref c0Base, i);
+                ref Vector256<float> c1 = ref Unsafe.Add(ref c1Base, i);
+                ref Vector256<float> c2 = ref Unsafe.Add(ref c2Base, i);
+                ref Vector256<float> c3 = ref Unsafe.Add(ref c3Base, i);
+
+                Vector256<float> y = c0 * scale;
+                Vector256<float> cb = (c1 * scale) - chromaOffset;
+                Vector256<float> cr = (c2 * scale) - chromaOffset;
+                Vector256<float> scaledK = Vector256<float>.One - (c3 * scale);
+
+                // r = y + (1.402F * cr);
+                // g = y - (0.344136F * cb) - (0.714136F * cr);
+                // b = y + (1.772F * cb);
+                Vector256<float> r = Vector256_.MultiplyAdd(y, cr, rCrMult) * scaledK;
+                Vector256<float> g = Vector256_.MultiplyAdd(Vector256_.MultiplyAdd(y, cb, gCbMult), cr, gCrMult) * scaledK;
+                Vector256<float> b = Vector256_.MultiplyAdd(y, cb, bCbMult) * scaledK;
+
+                c0 = r;
+                c1 = g;
+                c2 = b;
+            }
+        }
+
+        /// <inheritdoc/>
+        public override void ConvertToRgbInPlaceWithIcc(Configuration configuration, in ComponentValues values, IccProfile profile)
+            => TiffYccKScalar.ConvertToRgbInPlaceWithIcc(configuration, profile, values, this.MaximumValue);
+
+        /// <inheritdoc/>
+        public override void ConvertFromRgb(in ComponentValues values, Span<float> rLane, Span<float> gLane, Span<float> bLane)
+        {
+            ref Vector256<float> srcR =
+                ref Unsafe.As<float, Vector256<float>>(ref MemoryMarshal.GetReference(rLane));
+            ref Vector256<float> srcG =
+                ref Unsafe.As<float, Vector256<float>>(ref MemoryMarshal.GetReference(gLane));
+            ref Vector256<float> srcB =
+                ref Unsafe.As<float, Vector256<float>>(ref MemoryMarshal.GetReference(bLane));
+
+            ref Vector256<float> destY =
+                ref Unsafe.As<float, Vector256<float>>(ref MemoryMarshal.GetReference(values.Component0));
+            ref Vector256<float> destCb =
+                ref Unsafe.As<float, Vector256<float>>(ref MemoryMarshal.GetReference(values.Component1));
+            ref Vector256<float> destCr =
+                ref Unsafe.As<float, Vector256<float>>(ref MemoryMarshal.GetReference(values.Component2));
+            ref Vector256<float> destK =
+                ref Unsafe.As<float, Vector256<float>>(ref MemoryMarshal.GetReference(values.Component3));
+
+            Vector256<float> maxSourceValue = Vector256.Create(255F);
+            Vector256<float> maxSampleValue = Vector256.Create(this.MaximumValue);
+            Vector256<float> chromaOffset = Vector256.Create(this.HalfValue);
+
+            Vector256<float> f0299 = Vector256.Create(0.299f);
+            Vector256<float> f0587 = Vector256.Create(0.587f);
+            Vector256<float> f0114 = Vector256.Create(0.114f);
+            Vector256<float> fn0168736 = Vector256.Create(-0.168736f);
+            Vector256<float> fn0331264 = Vector256.Create(-0.331264f);
+            Vector256<float> fn0418688 = Vector256.Create(-0.418688f);
+            Vector256<float> fn0081312F = Vector256.Create(-0.081312F);
+            Vector256<float> f05 = Vector256.Create(0.5f);
+
+            nuint n = values.Component0.Vector256Count<float>();
+            for (nuint i = 0; i < n; i++)
+            {
+                Vector256<float> r = Unsafe.Add(ref srcR, i) / maxSourceValue;
+                Vector256<float> g = Unsafe.Add(ref srcG, i) / maxSourceValue;
+                Vector256<float> b = Unsafe.Add(ref srcB, i) / maxSourceValue;
+                Vector256<float> ktmp = Vector256<float>.One - Vector256.Max(r, Vector256.Min(g, b));
+
+                Vector256<float> kMask = ~Vector256.Equals(ktmp, Vector256<float>.One);
+                Vector256<float> divisor = Vector256<float>.One / (Vector256<float>.One - ktmp);
+
+                r = (r * divisor) & kMask;
+                g = (g * divisor) & kMask;
+                b = (b * divisor) & kMask;
+
+                // y  =   0 + (0.299 * r) + (0.587 * g) + (0.114 * b)
+                // cb = 128 - (0.168736 * r) - (0.331264 * g) + (0.5 * b)
+                // cr = 128 + (0.5 * r) - (0.418688 * g) - (0.081312 * b)
+                Vector256<float> y = Vector256_.MultiplyAdd(Vector256_.MultiplyAdd(f0114 * b, f0587, g), f0299, r);
+                Vector256<float> cb = chromaOffset + Vector256_.MultiplyAdd(Vector256_.MultiplyAdd(f05 * b, fn0331264, g), fn0168736, r);
+                Vector256<float> cr = chromaOffset + Vector256_.MultiplyAdd(Vector256_.MultiplyAdd(fn0081312F * b, fn0418688, g), f05, r);
+
+                Unsafe.Add(ref destY, i) = y * maxSampleValue;
+                Unsafe.Add(ref destCb, i) = chromaOffset + (cb * maxSampleValue);
+                Unsafe.Add(ref destCr, i) = chromaOffset + (cr * maxSampleValue);
+                Unsafe.Add(ref destK, i) = ktmp * maxSampleValue;
+            }
+        }
+    }
+}
diff --git a/src/ImageSharp/Formats/Jpeg/Components/ColorConverters/JpegColorConverter.TiffYccKVector512.cs b/src/ImageSharp/Formats/Jpeg/Components/ColorConverters/JpegColorConverter.TiffYccKVector512.cs
new file mode 100644
index 0000000000..47168a739d
--- /dev/null
+++ b/src/ImageSharp/Formats/Jpeg/Components/ColorConverters/JpegColorConverter.TiffYccKVector512.cs
@@ -0,0 +1,142 @@
+// Copyright (c) Six Labors.
+// Licensed under the Six Labors Split License.
+
+using System.Runtime.CompilerServices;
+using System.Runtime.InteropServices;
+using System.Runtime.Intrinsics;
+using SixLabors.ImageSharp.Common.Helpers;
+using SixLabors.ImageSharp.Metadata.Profiles.Icc;
+
+namespace SixLabors.ImageSharp.Formats.Jpeg.Components;
+
+internal abstract partial class JpegColorConverterBase
+{
+    internal sealed class TiffYccKVector512 : JpegColorConverterVector512
+    {
+        public TiffYccKVector512(int precision)
+            : base(JpegColorSpace.TiffYccK, precision)
+        {
+        }
+
+        /// <inheritdoc/>
+        public override void ConvertToRgbInPlaceWithIcc(Configuration configuration, in ComponentValues values, IccProfile profile)
+            => TiffYccKScalar.ConvertToRgbInPlaceWithIcc(configuration, profile, values, this.MaximumValue);
+
+        /// <inheritdoc/>
+        protected override void ConvertToRgbInPlaceVectorized(in ComponentValues values)
+        {
+            ref Vector512<float> c0Base =
+                ref Unsafe.As<float, Vector512<float>>(ref MemoryMarshal.GetReference(values.Component0));
+            ref Vector512<float> c1Base =
+                ref Unsafe.As<float, Vector512<float>>(ref MemoryMarshal.GetReference(values.Component1));
+            ref Vector512<float> c2Base =
+                ref Unsafe.As<float, Vector512<float>>(ref MemoryMarshal.GetReference(values.Component2));
+            ref Vector512<float> c3Base =
+                ref Unsafe.As<float, Vector512<float>>(ref MemoryMarshal.GetReference(values.Component3));
+
+            Vector512<float> scale = Vector512.Create(1F / this.MaximumValue);
+            Vector512<float> chromaOffset = Vector512.Create(this.HalfValue) * scale;
+            Vector512<float> rCrMult = Vector512.Create(YCbCrScalar.RCrMult);
+            Vector512<float> gCbMult = Vector512.Create(-YCbCrScalar.GCbMult);
+            Vector512<float> gCrMult = Vector512.Create(-YCbCrScalar.GCrMult);
+            Vector512<float> bCbMult = Vector512.Create(YCbCrScalar.BCbMult);
+
+            nuint n = values.Component0.Vector512Count<float>();
+            for (nuint i = 0; i < n; i++)
+            {
+                ref Vector512<float> c0 = ref Unsafe.Add(ref c0Base, i);
+                ref Vector512<float> c1 = ref Unsafe.Add(ref c1Base, i);
+                ref Vector512<float> c2 = ref Unsafe.Add(ref c2Base, i);
+                ref Vector512<float> c3 = ref Unsafe.Add(ref c3Base, i);
+
+                Vector512<float> y = c0 * scale;
+                Vector512<float> cb = (c1 * scale) - chromaOffset;
+                Vector512<float> cr = (c2 * scale) - chromaOffset;
+                Vector512<float> scaledK = Vector512<float>.One - (c3 * scale);
+
+                // r = y + (1.402F * cr);
+                // g = y - (0.344136F * cb) - (0.714136F * cr);
+                // b = y + (1.772F * cb);
+                Vector512<float> r = Vector512_.MultiplyAdd(y, cr, rCrMult) * scaledK;
+                Vector512<float> g = Vector512_.MultiplyAdd(Vector512_.MultiplyAdd(y, cb, gCbMult), cr, gCrMult) * scaledK;
+                Vector512<float> b = Vector512_.MultiplyAdd(y, cb, bCbMult) * scaledK;
+
+                c0 = r;
+                c1 = g;
+                c2 = b;
+            }
+        }
+
+        /// <inheritdoc/>
+        protected override void ConvertFromRgbVectorized(in ComponentValues values, Span<float> rLane, Span<float> gLane, Span<float> bLane)
+            => ConvertFromRgbVectorized(in values, this.MaximumValue, this.HalfValue, rLane, gLane, bLane);
+
+        /// <inheritdoc/>
+        protected override void ConvertToRgbInPlaceScalarRemainder(in ComponentValues values)
+             => TiffYccKScalar.ConvertToRgbInPlace(values, this.MaximumValue, this.HalfValue);
+
+        /// <inheritdoc/>
+        protected override void ConvertFromRgbScalarRemainder(in ComponentValues values, Span<float> rLane, Span<float> gLane, Span<float> bLane)
+            => TiffYccKScalar.ConvertFromRgb(values, this.HalfValue, this.MaximumValue, rLane, gLane, bLane);
+
+        internal static void ConvertFromRgbVectorized(in ComponentValues values, float maxValue, float halfValue, Span<float> rLane, Span<float> gLane, Span<float> bLane)
+        {
+            ref Vector512<float> srcR =
+                ref Unsafe.As<float, Vector512<float>>(ref MemoryMarshal.GetReference(rLane));
+            ref Vector512<float> srcG =
+                ref Unsafe.As<float, Vector512<float>>(ref MemoryMarshal.GetReference(gLane));
+            ref Vector512<float> srcB =
+                ref Unsafe.As<float, Vector512<float>>(ref MemoryMarshal.GetReference(bLane));
+
+            ref Vector512<float> destY =
+                ref Unsafe.As<float, Vector512<float>>(ref MemoryMarshal.GetReference(values.Component0));
+            ref Vector512<float> destCb =
+                ref Unsafe.As<float, Vector512<float>>(ref MemoryMarshal.GetReference(values.Component1));
+            ref Vector512<float> destCr =
+                ref Unsafe.As<float, Vector512<float>>(ref MemoryMarshal.GetReference(values.Component2));
+            ref Vector512<float> destK =
+                ref Unsafe.As<float, Vector512<float>>(ref MemoryMarshal.GetReference(values.Component3));
+
+            Vector512<float> maxSourceValue = Vector512.Create(255F);
+            Vector512<float> maxSampleValue = Vector512.Create(maxValue);
+            Vector512<float> chromaOffset = Vector512.Create(halfValue);
+
+            Vector512<float> f0299 = Vector512.Create(0.299f);
+            Vector512<float> f0587 = Vector512.Create(0.587f);
+            Vector512<float> f0114 = Vector512.Create(0.114f);
+            Vector512<float> fn0168736 = Vector512.Create(-0.168736f);
+            Vector512<float> fn0331264 = Vector512.Create(-0.331264f);
+            Vector512<float> fn0418688 = Vector512.Create(-0.418688f);
+            Vector512<float> fn0081312F = Vector512.Create(-0.081312F);
+            Vector512<float> f05 = Vector512.Create(0.5f);
+
+            nuint n = values.Component0.Vector512Count<float>();
+            for (nuint i = 0; i < n; i++)
+            {
+                Vector512<float> r = Unsafe.Add(ref srcR, i) / maxSourceValue;
+                Vector512<float> g = Unsafe.Add(ref srcG, i) / maxSourceValue;
+                Vector512<float> b = Unsafe.Add(ref srcB, i) / maxSourceValue;
+                Vector512<float> ktmp = Vector512<float>.One - Vector512.Max(r, Vector512.Min(g, b));
+
+                Vector512<float> kMask = ~Vector512.Equals(ktmp, Vector512<float>.One);
+                Vector512<float> divisor = Vector512<float>.One / (Vector512<float>.One - ktmp);
+
+                r = (r * divisor) & kMask;
+                g = (g * divisor) & kMask;
+                b = (b * divisor) & kMask;
+
+                // y  =   0 + (0.299 * r) + (0.587 * g) + (0.114 * b)
+                // cb = 128 - (0.168736 * r) - (0.331264 * g) + (0.5 * b)
+                // cr = 128 + (0.5 * r) - (0.418688 * g) - (0.081312 * b)
+                Vector512<float> y = Vector512_.MultiplyAdd(Vector512_.MultiplyAdd(f0114 * b, f0587, g), f0299, r);
+                Vector512<float> cb = chromaOffset + Vector512_.MultiplyAdd(Vector512_.MultiplyAdd(f05 * b, fn0331264, g), fn0168736, r);
+                Vector512<float> cr = chromaOffset + Vector512_.MultiplyAdd(Vector512_.MultiplyAdd(fn0081312F * b, fn0418688, g), f05, r);
+
+                Unsafe.Add(ref destY, i) = y * maxSampleValue;
+                Unsafe.Add(ref destCb, i) = chromaOffset + (cb * maxSampleValue);
+                Unsafe.Add(ref destCr, i) = chromaOffset + (cr * maxSampleValue);
+                Unsafe.Add(ref destK, i) = ktmp * maxSampleValue;
+            }
+        }
+    }
+}
diff --git a/src/ImageSharp/Formats/Jpeg/Components/ColorConverters/JpegColorConverter.YCbCrScalar.cs b/src/ImageSharp/Formats/Jpeg/Components/ColorConverters/JpegColorConverter.YCbCrScalar.cs
index e3e5a452a8..2b1c1dca38 100644
--- a/src/ImageSharp/Formats/Jpeg/Components/ColorConverters/JpegColorConverter.YCbCrScalar.cs
+++ b/src/ImageSharp/Formats/Jpeg/Components/ColorConverters/JpegColorConverter.YCbCrScalar.cs
@@ -1,6 +1,13 @@
 // Copyright (c) Six Labors.
 // Licensed under the Six Labors Split License.
 
+using System.Buffers;
+using System.Numerics;
+using System.Runtime.InteropServices;
+using SixLabors.ImageSharp.ColorProfiles;
+using SixLabors.ImageSharp.ColorProfiles.Icc;
+using SixLabors.ImageSharp.Metadata.Profiles.Icc;
+
 namespace SixLabors.ImageSharp.Formats.Jpeg.Components;
 
 internal abstract partial class JpegColorConverterBase
@@ -19,14 +26,18 @@ internal abstract partial class JpegColorConverterBase
         }
 
         /// <inheritdoc/>
-        public override void ConvertToRgbInplace(in ComponentValues values)
-            => ConvertToRgbInplace(values, this.MaximumValue, this.HalfValue);
+        public override void ConvertToRgbInPlace(in ComponentValues values)
+            => ConvertToRgbInPlace(values, this.MaximumValue, this.HalfValue);
+
+        /// <inheritdoc/>
+        public override void ConvertToRgbInPlaceWithIcc(Configuration configuration, in ComponentValues values, IccProfile profile)
+            => ConvertToRgbInPlaceWithIcc(configuration, profile, values, this.MaximumValue);
 
         /// <inheritdoc/>
-        public override void ConvertFromRgb(in ComponentValues values, Span<float> r, Span<float> g, Span<float> b)
-            => ConvertFromRgb(values, this.HalfValue, r, g, b);
+        public override void ConvertFromRgb(in ComponentValues values, Span<float> rLane, Span<float> gLane, Span<float> bLane)
+            => ConvertFromRgb(values, this.HalfValue, rLane, gLane, bLane);
 
-        public static void ConvertToRgbInplace(in ComponentValues values, float maxValue, float halfValue)
+        public static void ConvertToRgbInPlace(in ComponentValues values, float maxValue, float halfValue)
         {
             Span<float> c0 = values.Component0;
             Span<float> c1 = values.Component1;
@@ -49,6 +60,43 @@ internal abstract partial class JpegColorConverterBase
             }
         }
 
+        public static void ConvertToRgbInPlaceWithIcc(Configuration configuration, IccProfile profile, in ComponentValues values, float maxValue)
+        {
+            using IMemoryOwner<float> memoryOwner = configuration.MemoryAllocator.Allocate<float>(values.Component0.Length * 3);
+            Span<float> packed = memoryOwner.Memory.Span;
+
+            Span<float> c0 = values.Component0;
+            Span<float> c1 = values.Component1;
+            Span<float> c2 = values.Component2;
+
+            // Although YCbCr is a defined ICC color space, in practice ICC profiles
+            // do not implement transforms from it.
+            // Therefore, we first convert JPEG YCbCr to RGB manually, then perform
+            // color-managed conversion to the target profile.
+            //
+            // The YCbCr => RGB conversion is based on BT.601 and is independent of any embedded ICC profile.
+            // Since the same RGB working space is used during conversion to and from XYZ,
+            // colorimetric accuracy is preserved.
+            ColorProfileConverter converter = new();
+
+            PackedNormalizeInterleave3(c0, c1, c2, packed, 1F / maxValue);
+
+            Span<YCbCr> source = MemoryMarshal.Cast<float, YCbCr>(packed);
+            Span<Rgb> destination = MemoryMarshal.Cast<float, Rgb>(packed);
+
+            converter.Convert<YCbCr, Rgb>(source, destination);
+
+            ColorConversionOptions options = new()
+            {
+                SourceIccProfile = profile,
+                TargetIccProfile = CompactSrgbV4Profile.Profile,
+            };
+            converter = new ColorProfileConverter(options);
+            converter.Convert<Rgb, Rgb>(destination, destination);
+
+            UnpackDeinterleave3(MemoryMarshal.Cast<float, Vector3>(packed)[..source.Length], c0, c1, c2);
+        }
+
         public static void ConvertFromRgb(in ComponentValues values, float halfValue, Span<float> rLane, Span<float> gLane, Span<float> bLane)
         {
             Span<float> y = values.Component0;
diff --git a/src/ImageSharp/Formats/Jpeg/Components/ColorConverters/JpegColorConverter.YCbCrVector.cs b/src/ImageSharp/Formats/Jpeg/Components/ColorConverters/JpegColorConverter.YCbCrVector.cs
deleted file mode 100644
index a5d0c889e3..0000000000
--- a/src/ImageSharp/Formats/Jpeg/Components/ColorConverters/JpegColorConverter.YCbCrVector.cs
+++ /dev/null
@@ -1,126 +0,0 @@
-// Copyright (c) Six Labors.
-// Licensed under the Six Labors Split License.
-
-using System.Numerics;
-using System.Runtime.CompilerServices;
-using System.Runtime.InteropServices;
-
-// ReSharper disable ImpureMethodCallOnReadonlyValueField
-namespace SixLabors.ImageSharp.Formats.Jpeg.Components;
-
-internal abstract partial class JpegColorConverterBase
-{
-    internal sealed class YCbCrVector : JpegColorConverterVector
-    {
-        public YCbCrVector(int precision)
-            : base(JpegColorSpace.YCbCr, precision)
-        {
-        }
-
-        /// <inheritdoc/>
-        protected override void ConvertToRgbInplaceVectorized(in ComponentValues values)
-        {
-            ref Vector<float> c0Base =
-                ref Unsafe.As<float, Vector<float>>(ref MemoryMarshal.GetReference(values.Component0));
-            ref Vector<float> c1Base =
-                ref Unsafe.As<float, Vector<float>>(ref MemoryMarshal.GetReference(values.Component1));
-            ref Vector<float> c2Base =
-                ref Unsafe.As<float, Vector<float>>(ref MemoryMarshal.GetReference(values.Component2));
-
-            var chromaOffset = new Vector<float>(-this.HalfValue);
-
-            var scale = new Vector<float>(1 / this.MaximumValue);
-            var rCrMult = new Vector<float>(YCbCrScalar.RCrMult);
-            var gCbMult = new Vector<float>(-YCbCrScalar.GCbMult);
-            var gCrMult = new Vector<float>(-YCbCrScalar.GCrMult);
-            var bCbMult = new Vector<float>(YCbCrScalar.BCbMult);
-
-            nuint n = values.Component0.VectorCount<float>();
-            for (nuint i = 0; i < n; i++)
-            {
-                // y = yVals[i];
-                // cb = cbVals[i] - 128F;
-                // cr = crVals[i] - 128F;
-                ref Vector<float> c0 = ref Unsafe.Add(ref c0Base, i);
-                ref Vector<float> c1 = ref Unsafe.Add(ref c1Base, i);
-                ref Vector<float> c2 = ref Unsafe.Add(ref c2Base, i);
-                Vector<float> y = Unsafe.Add(ref c0Base, i);
-                Vector<float> cb = Unsafe.Add(ref c1Base, i) + chromaOffset;
-                Vector<float> cr = Unsafe.Add(ref c2Base, i) + chromaOffset;
-
-                // r = y + (1.402F * cr);
-                // g = y - (0.344136F * cb) - (0.714136F * cr);
-                // b = y + (1.772F * cb);
-                Vector<float> r = y + (cr * rCrMult);
-                Vector<float> g = y + (cb * gCbMult) + (cr * gCrMult);
-                Vector<float> b = y + (cb * bCbMult);
-
-                r = r.FastRound();
-                g = g.FastRound();
-                b = b.FastRound();
-                r *= scale;
-                g *= scale;
-                b *= scale;
-
-                c0 = r;
-                c1 = g;
-                c2 = b;
-            }
-        }
-
-        /// <inheritdoc/>
-        protected override void ConvertToRgbInplaceScalarRemainder(in ComponentValues values)
-            => YCbCrScalar.ConvertToRgbInplace(values, this.MaximumValue, this.HalfValue);
-
-        /// <inheritdoc/>
-        protected override void ConvertFromRgbVectorized(in ComponentValues values, Span<float> rLane, Span<float> gLane, Span<float> bLane)
-        {
-            ref Vector<float> destY =
-                ref Unsafe.As<float, Vector<float>>(ref MemoryMarshal.GetReference(values.Component0));
-            ref Vector<float> destCb =
-                ref Unsafe.As<float, Vector<float>>(ref MemoryMarshal.GetReference(values.Component1));
-            ref Vector<float> destCr =
-                ref Unsafe.As<float, Vector<float>>(ref MemoryMarshal.GetReference(values.Component2));
-
-            ref Vector<float> srcR =
-                ref Unsafe.As<float, Vector<float>>(ref MemoryMarshal.GetReference(rLane));
-            ref Vector<float> srcG =
-                ref Unsafe.As<float, Vector<float>>(ref MemoryMarshal.GetReference(gLane));
-            ref Vector<float> srcB =
-                ref Unsafe.As<float, Vector<float>>(ref MemoryMarshal.GetReference(bLane));
-
-            var chromaOffset = new Vector<float>(this.HalfValue);
-
-            var rYMult = new Vector<float>(0.299f);
-            var gYMult = new Vector<float>(0.587f);
-            var bYMult = new Vector<float>(0.114f);
-
-            var rCbMult = new Vector<float>(0.168736f);
-            var gCbMult = new Vector<float>(0.331264f);
-            var bCbMult = new Vector<float>(0.5f);
-
-            var rCrMult = new Vector<float>(0.5f);
-            var gCrMult = new Vector<float>(0.418688f);
-            var bCrMult = new Vector<float>(0.081312f);
-
-            nuint n = values.Component0.VectorCount<float>();
-            for (nuint i = 0; i < n; i++)
-            {
-                Vector<float> r = Unsafe.Add(ref srcR, i);
-                Vector<float> g = Unsafe.Add(ref srcG, i);
-                Vector<float> b = Unsafe.Add(ref srcB, i);
-
-                // y  =   0 + (0.299 * r) + (0.587 * g) + (0.114 * b)
-                // cb = 128 - (0.168736 * r) - (0.331264 * g) + (0.5 * b)
-                // cr = 128 + (0.5 * r) - (0.418688 * g) - (0.081312 * b)
-                Unsafe.Add(ref destY, i) = (rYMult * r) + (gYMult * g) + (bYMult * b);
-                Unsafe.Add(ref destCb, i) = chromaOffset - (rCbMult * r) - (gCbMult * g) + (bCbMult * b);
-                Unsafe.Add(ref destCr, i) = chromaOffset + (rCrMult * r) - (gCrMult * g) - (bCrMult * b);
-            }
-        }
-
-        /// <inheritdoc/>
-        protected override void ConvertFromRgbScalarRemainder(in ComponentValues values, Span<float> r, Span<float> g, Span<float> b)
-            => YCbCrScalar.ConvertFromRgb(values, this.HalfValue, r, g, b);
-    }
-}
diff --git a/src/ImageSharp/Formats/Jpeg/Components/ColorConverters/JpegColorConverter.YCbCrArm.cs b/src/ImageSharp/Formats/Jpeg/Components/ColorConverters/JpegColorConverter.YCbCrVector128.cs
similarity index 54%
rename from src/ImageSharp/Formats/Jpeg/Components/ColorConverters/JpegColorConverter.YCbCrArm.cs
rename to src/ImageSharp/Formats/Jpeg/Components/ColorConverters/JpegColorConverter.YCbCrVector128.cs
index 4f7cf1ed65..01c8508edc 100644
--- a/src/ImageSharp/Formats/Jpeg/Components/ColorConverters/JpegColorConverter.YCbCrArm.cs
+++ b/src/ImageSharp/Formats/Jpeg/Components/ColorConverters/JpegColorConverter.YCbCrVector128.cs
@@ -4,24 +4,22 @@
 using System.Runtime.CompilerServices;
 using System.Runtime.InteropServices;
 using System.Runtime.Intrinsics;
-using System.Runtime.Intrinsics.Arm;
-using System.Runtime.Intrinsics.X86;
-using static SixLabors.ImageSharp.SimdUtils;
+using SixLabors.ImageSharp.Common.Helpers;
+using SixLabors.ImageSharp.Metadata.Profiles.Icc;
 
-// ReSharper disable ImpureMethodCallOnReadonlyValueField
 namespace SixLabors.ImageSharp.Formats.Jpeg.Components;
 
 internal abstract partial class JpegColorConverterBase
 {
-    internal sealed class YCbCrArm : JpegColorConverterArm
+    internal sealed class YCbCrVector128 : JpegColorConverterVector128
     {
-        public YCbCrArm(int precision)
+        public YCbCrVector128(int precision)
             : base(JpegColorSpace.YCbCr, precision)
         {
         }
 
         /// <inheritdoc/>
-        public override void ConvertToRgbInplace(in ComponentValues values)
+        public override void ConvertToRgbInPlace(in ComponentValues values)
         {
             ref Vector128<float> c0Base =
                 ref Unsafe.As<float, Vector128<float>>(ref MemoryMarshal.GetReference(values.Component0));
@@ -30,16 +28,15 @@ internal abstract partial class JpegColorConverterBase
             ref Vector128<float> c2Base =
                 ref Unsafe.As<float, Vector128<float>>(ref MemoryMarshal.GetReference(values.Component2));
 
-            // Used for the color conversion
-            var chromaOffset = Vector128.Create(-this.HalfValue);
-            var scale = Vector128.Create(1 / this.MaximumValue);
-            var rCrMult = Vector128.Create(YCbCrScalar.RCrMult);
-            var gCbMult = Vector128.Create(-YCbCrScalar.GCbMult);
-            var gCrMult = Vector128.Create(-YCbCrScalar.GCrMult);
-            var bCbMult = Vector128.Create(YCbCrScalar.BCbMult);
+            Vector128<float> chromaOffset = Vector128.Create(-this.HalfValue);
+            Vector128<float> scale = Vector128.Create(1 / this.MaximumValue);
+            Vector128<float> rCrMult = Vector128.Create(YCbCrScalar.RCrMult);
+            Vector128<float> gCbMult = Vector128.Create(-YCbCrScalar.GCbMult);
+            Vector128<float> gCrMult = Vector128.Create(-YCbCrScalar.GCrMult);
+            Vector128<float> bCbMult = Vector128.Create(YCbCrScalar.BCbMult);
 
             // Walking 8 elements at one step:
-            nuint n = (uint)values.Component0.Length / (uint)Vector128<float>.Count;
+            nuint n = values.Component0.Vector128Count<float>();
             for (nuint i = 0; i < n; i++)
             {
                 // y = yVals[i];
@@ -50,19 +47,19 @@ internal abstract partial class JpegColorConverterBase
                 ref Vector128<float> c2 = ref Unsafe.Add(ref c2Base, i);
 
                 Vector128<float> y = c0;
-                Vector128<float> cb = AdvSimd.Add(c1, chromaOffset);
-                Vector128<float> cr = AdvSimd.Add(c2, chromaOffset);
+                Vector128<float> cb = c1 + chromaOffset;
+                Vector128<float> cr = c2 + chromaOffset;
 
                 // r = y + (1.402F * cr);
                 // g = y - (0.344136F * cb) - (0.714136F * cr);
                 // b = y + (1.772F * cb);
-                Vector128<float> r = HwIntrinsics.MultiplyAdd(y, cr, rCrMult);
-                Vector128<float> g = HwIntrinsics.MultiplyAdd(HwIntrinsics.MultiplyAdd(y, cb, gCbMult), cr, gCrMult);
-                Vector128<float> b = HwIntrinsics.MultiplyAdd(y, cb, bCbMult);
+                Vector128<float> r = Vector128_.MultiplyAdd(y, cr, rCrMult);
+                Vector128<float> g = Vector128_.MultiplyAdd(Vector128_.MultiplyAdd(y, cb, gCbMult), cr, gCrMult);
+                Vector128<float> b = Vector128_.MultiplyAdd(y, cb, bCbMult);
 
-                r = AdvSimd.Multiply(AdvSimd.RoundToNearest(r), scale);
-                g = AdvSimd.Multiply(AdvSimd.RoundToNearest(g), scale);
-                b = AdvSimd.Multiply(AdvSimd.RoundToNearest(b), scale);
+                r = Vector128_.RoundToNearestInteger(r) * scale;
+                g = Vector128_.RoundToNearestInteger(g) * scale;
+                b = Vector128_.RoundToNearestInteger(b) * scale;
 
                 c0 = r;
                 c1 = g;
@@ -70,6 +67,10 @@ internal abstract partial class JpegColorConverterBase
             }
         }
 
+        /// <inheritdoc/>
+        public override void ConvertToRgbInPlaceWithIcc(Configuration configuration, in ComponentValues values, IccProfile profile)
+            => YCbCrScalar.ConvertToRgbInPlaceWithIcc(configuration, profile, values, this.MaximumValue);
+
         /// <inheritdoc/>
         public override void ConvertFromRgb(in ComponentValues values, Span<float> rLane, Span<float> gLane, Span<float> bLane)
         {
@@ -87,19 +88,17 @@ internal abstract partial class JpegColorConverterBase
             ref Vector128<float> srcB =
                 ref Unsafe.As<float, Vector128<float>>(ref MemoryMarshal.GetReference(bLane));
 
-            // Used for the color conversion
-            var chromaOffset = Vector128.Create(this.HalfValue);
-
-            var f0299 = Vector128.Create(0.299f);
-            var f0587 = Vector128.Create(0.587f);
-            var f0114 = Vector128.Create(0.114f);
-            var fn0168736 = Vector128.Create(-0.168736f);
-            var fn0331264 = Vector128.Create(-0.331264f);
-            var fn0418688 = Vector128.Create(-0.418688f);
-            var fn0081312F = Vector128.Create(-0.081312F);
-            var f05 = Vector128.Create(0.5f);
-
-            nuint n = (uint)values.Component0.Length / (uint)Vector128<float>.Count;
+            Vector128<float> chromaOffset = Vector128.Create(this.HalfValue);
+            Vector128<float> f0299 = Vector128.Create(0.299f);
+            Vector128<float> f0587 = Vector128.Create(0.587f);
+            Vector128<float> f0114 = Vector128.Create(0.114f);
+            Vector128<float> fn0168736 = Vector128.Create(-0.168736f);
+            Vector128<float> fn0331264 = Vector128.Create(-0.331264f);
+            Vector128<float> fn0418688 = Vector128.Create(-0.418688f);
+            Vector128<float> fn0081312F = Vector128.Create(-0.081312F);
+            Vector128<float> f05 = Vector128.Create(0.5f);
+
+            nuint n = values.Component0.Vector128Count<float>();
             for (nuint i = 0; i < n; i++)
             {
                 Vector128<float> r = Unsafe.Add(ref srcR, i);
@@ -109,9 +108,9 @@ internal abstract partial class JpegColorConverterBase
                 // y  =   0 + (0.299 * r) + (0.587 * g) + (0.114 * b)
                 // cb = 128 - (0.168736 * r) - (0.331264 * g) + (0.5 * b)
                 // cr = 128 + (0.5 * r) - (0.418688 * g) - (0.081312 * b)
-                Vector128<float> y = HwIntrinsics.MultiplyAdd(HwIntrinsics.MultiplyAdd(AdvSimd.Multiply(f0114, b), f0587, g), f0299, r);
-                Vector128<float> cb = AdvSimd.Add(chromaOffset, HwIntrinsics.MultiplyAdd(HwIntrinsics.MultiplyAdd(AdvSimd.Multiply(f05, b), fn0331264, g), fn0168736, r));
-                Vector128<float> cr = AdvSimd.Add(chromaOffset, HwIntrinsics.MultiplyAdd(HwIntrinsics.MultiplyAdd(AdvSimd.Multiply(fn0081312F, b), fn0418688, g), f05, r));
+                Vector128<float> y = Vector128_.MultiplyAdd(Vector128_.MultiplyAdd(f0114 * b, f0587, g), f0299, r);
+                Vector128<float> cb = chromaOffset + Vector128_.MultiplyAdd(Vector128_.MultiplyAdd(f05 * b, fn0331264, g), fn0168736, r);
+                Vector128<float> cr = chromaOffset + Vector128_.MultiplyAdd(Vector128_.MultiplyAdd(fn0081312F * b, fn0418688, g), f05, r);
 
                 Unsafe.Add(ref destY, i) = y;
                 Unsafe.Add(ref destCb, i) = cb;
diff --git a/src/ImageSharp/Formats/Jpeg/Components/ColorConverters/JpegColorConverter.YCbCrAvx.cs b/src/ImageSharp/Formats/Jpeg/Components/ColorConverters/JpegColorConverter.YCbCrVector256.cs
similarity index 56%
rename from src/ImageSharp/Formats/Jpeg/Components/ColorConverters/JpegColorConverter.YCbCrAvx.cs
rename to src/ImageSharp/Formats/Jpeg/Components/ColorConverters/JpegColorConverter.YCbCrVector256.cs
index c5fa786e2c..8fdf1004d8 100644
--- a/src/ImageSharp/Formats/Jpeg/Components/ColorConverters/JpegColorConverter.YCbCrAvx.cs
+++ b/src/ImageSharp/Formats/Jpeg/Components/ColorConverters/JpegColorConverter.YCbCrVector256.cs
@@ -4,23 +4,22 @@
 using System.Runtime.CompilerServices;
 using System.Runtime.InteropServices;
 using System.Runtime.Intrinsics;
-using System.Runtime.Intrinsics.X86;
-using static SixLabors.ImageSharp.SimdUtils;
+using SixLabors.ImageSharp.Common.Helpers;
+using SixLabors.ImageSharp.Metadata.Profiles.Icc;
 
-// ReSharper disable ImpureMethodCallOnReadonlyValueField
 namespace SixLabors.ImageSharp.Formats.Jpeg.Components;
 
 internal abstract partial class JpegColorConverterBase
 {
-    internal sealed class YCbCrAvx : JpegColorConverterAvx
+    internal sealed class YCbCrVector256 : JpegColorConverterVector256
     {
-        public YCbCrAvx(int precision)
+        public YCbCrVector256(int precision)
             : base(JpegColorSpace.YCbCr, precision)
         {
         }
 
         /// <inheritdoc/>
-        public override void ConvertToRgbInplace(in ComponentValues values)
+        public override void ConvertToRgbInPlace(in ComponentValues values)
         {
             ref Vector256<float> c0Base =
                 ref Unsafe.As<float, Vector256<float>>(ref MemoryMarshal.GetReference(values.Component0));
@@ -29,13 +28,12 @@ internal abstract partial class JpegColorConverterBase
             ref Vector256<float> c2Base =
                 ref Unsafe.As<float, Vector256<float>>(ref MemoryMarshal.GetReference(values.Component2));
 
-            // Used for the color conversion
-            var chromaOffset = Vector256.Create(-this.HalfValue);
-            var scale = Vector256.Create(1 / this.MaximumValue);
-            var rCrMult = Vector256.Create(YCbCrScalar.RCrMult);
-            var gCbMult = Vector256.Create(-YCbCrScalar.GCbMult);
-            var gCrMult = Vector256.Create(-YCbCrScalar.GCrMult);
-            var bCbMult = Vector256.Create(YCbCrScalar.BCbMult);
+            Vector256<float> chromaOffset = Vector256.Create(-this.HalfValue);
+            Vector256<float> scale = Vector256.Create(1 / this.MaximumValue);
+            Vector256<float> rCrMult = Vector256.Create(YCbCrScalar.RCrMult);
+            Vector256<float> gCbMult = Vector256.Create(-YCbCrScalar.GCbMult);
+            Vector256<float> gCrMult = Vector256.Create(-YCbCrScalar.GCrMult);
+            Vector256<float> bCbMult = Vector256.Create(YCbCrScalar.BCbMult);
 
             // Walking 8 elements at one step:
             nuint n = values.Component0.Vector256Count<float>();
@@ -49,19 +47,19 @@ internal abstract partial class JpegColorConverterBase
                 ref Vector256<float> c2 = ref Unsafe.Add(ref c2Base, i);
 
                 Vector256<float> y = c0;
-                Vector256<float> cb = Avx.Add(c1, chromaOffset);
-                Vector256<float> cr = Avx.Add(c2, chromaOffset);
+                Vector256<float> cb = c1 + chromaOffset;
+                Vector256<float> cr = c2 + chromaOffset;
 
                 // r = y + (1.402F * cr);
                 // g = y - (0.344136F * cb) - (0.714136F * cr);
                 // b = y + (1.772F * cb);
-                Vector256<float> r = HwIntrinsics.MultiplyAdd(y, cr, rCrMult);
-                Vector256<float> g = HwIntrinsics.MultiplyAdd(HwIntrinsics.MultiplyAdd(y, cb, gCbMult), cr, gCrMult);
-                Vector256<float> b = HwIntrinsics.MultiplyAdd(y, cb, bCbMult);
+                Vector256<float> r = Vector256_.MultiplyAdd(y, cr, rCrMult);
+                Vector256<float> g = Vector256_.MultiplyAdd(Vector256_.MultiplyAdd(y, cb, gCbMult), cr, gCrMult);
+                Vector256<float> b = Vector256_.MultiplyAdd(y, cb, bCbMult);
 
-                r = Avx.Multiply(Avx.RoundToNearestInteger(r), scale);
-                g = Avx.Multiply(Avx.RoundToNearestInteger(g), scale);
-                b = Avx.Multiply(Avx.RoundToNearestInteger(b), scale);
+                r = Vector256_.RoundToNearestInteger(r) * scale;
+                g = Vector256_.RoundToNearestInteger(g) * scale;
+                b = Vector256_.RoundToNearestInteger(b) * scale;
 
                 c0 = r;
                 c1 = g;
@@ -69,6 +67,10 @@ internal abstract partial class JpegColorConverterBase
             }
         }
 
+        /// <inheritdoc/>
+        public override void ConvertToRgbInPlaceWithIcc(Configuration configuration, in ComponentValues values, IccProfile profile)
+            => YCbCrScalar.ConvertToRgbInPlaceWithIcc(configuration, profile, values, this.MaximumValue);
+
         /// <inheritdoc/>
         public override void ConvertFromRgb(in ComponentValues values, Span<float> rLane, Span<float> gLane, Span<float> bLane)
         {
@@ -86,17 +88,15 @@ internal abstract partial class JpegColorConverterBase
             ref Vector256<float> srcB =
                 ref Unsafe.As<float, Vector256<float>>(ref MemoryMarshal.GetReference(bLane));
 
-            // Used for the color conversion
-            var chromaOffset = Vector256.Create(this.HalfValue);
-
-            var f0299 = Vector256.Create(0.299f);
-            var f0587 = Vector256.Create(0.587f);
-            var f0114 = Vector256.Create(0.114f);
-            var fn0168736 = Vector256.Create(-0.168736f);
-            var fn0331264 = Vector256.Create(-0.331264f);
-            var fn0418688 = Vector256.Create(-0.418688f);
-            var fn0081312F = Vector256.Create(-0.081312F);
-            var f05 = Vector256.Create(0.5f);
+            Vector256<float> chromaOffset = Vector256.Create(this.HalfValue);
+            Vector256<float> f0299 = Vector256.Create(0.299f);
+            Vector256<float> f0587 = Vector256.Create(0.587f);
+            Vector256<float> f0114 = Vector256.Create(0.114f);
+            Vector256<float> fn0168736 = Vector256.Create(-0.168736f);
+            Vector256<float> fn0331264 = Vector256.Create(-0.331264f);
+            Vector256<float> fn0418688 = Vector256.Create(-0.418688f);
+            Vector256<float> fn0081312F = Vector256.Create(-0.081312F);
+            Vector256<float> f05 = Vector256.Create(0.5f);
 
             nuint n = values.Component0.Vector256Count<float>();
             for (nuint i = 0; i < n; i++)
@@ -108,9 +108,9 @@ internal abstract partial class JpegColorConverterBase
                 // y  =   0 + (0.299 * r) + (0.587 * g) + (0.114 * b)
                 // cb = 128 - (0.168736 * r) - (0.331264 * g) + (0.5 * b)
                 // cr = 128 + (0.5 * r) - (0.418688 * g) - (0.081312 * b)
-                Vector256<float> y = HwIntrinsics.MultiplyAdd(HwIntrinsics.MultiplyAdd(Avx.Multiply(f0114, b), f0587, g), f0299, r);
-                Vector256<float> cb = Avx.Add(chromaOffset, HwIntrinsics.MultiplyAdd(HwIntrinsics.MultiplyAdd(Avx.Multiply(f05, b), fn0331264, g), fn0168736, r));
-                Vector256<float> cr = Avx.Add(chromaOffset, HwIntrinsics.MultiplyAdd(HwIntrinsics.MultiplyAdd(Avx.Multiply(fn0081312F, b), fn0418688, g), f05, r));
+                Vector256<float> y = Vector256_.MultiplyAdd(Vector256_.MultiplyAdd(f0114 * b, f0587, g), f0299, r);
+                Vector256<float> cb = chromaOffset + Vector256_.MultiplyAdd(Vector256_.MultiplyAdd(f05 * b, fn0331264, g), fn0168736, r);
+                Vector256<float> cr = chromaOffset + Vector256_.MultiplyAdd(Vector256_.MultiplyAdd(fn0081312F * b, fn0418688, g), f05, r);
 
                 Unsafe.Add(ref destY, i) = y;
                 Unsafe.Add(ref destCb, i) = cb;
diff --git a/src/ImageSharp/Formats/Jpeg/Components/ColorConverters/JpegColorConverter.YCbCrVector512.cs b/src/ImageSharp/Formats/Jpeg/Components/ColorConverters/JpegColorConverter.YCbCrVector512.cs
new file mode 100644
index 0000000000..33cb2496c6
--- /dev/null
+++ b/src/ImageSharp/Formats/Jpeg/Components/ColorConverters/JpegColorConverter.YCbCrVector512.cs
@@ -0,0 +1,128 @@
+// Copyright (c) Six Labors.
+// Licensed under the Six Labors Split License.
+
+using System.Runtime.CompilerServices;
+using System.Runtime.InteropServices;
+using System.Runtime.Intrinsics;
+using SixLabors.ImageSharp.Common.Helpers;
+using SixLabors.ImageSharp.Metadata.Profiles.Icc;
+
+namespace SixLabors.ImageSharp.Formats.Jpeg.Components;
+
+internal abstract partial class JpegColorConverterBase
+{
+    internal sealed class YCbCrVector512 : JpegColorConverterVector512
+    {
+        public YCbCrVector512(int precision)
+            : base(JpegColorSpace.YCbCr, precision)
+        {
+        }
+
+        /// <inheritdoc/>
+        public override void ConvertToRgbInPlaceWithIcc(Configuration configuration, in ComponentValues values, IccProfile profile)
+            => YCbCrScalar.ConvertToRgbInPlaceWithIcc(configuration, profile, values, this.MaximumValue);
+
+        /// <inheritdoc/>
+        protected override void ConvertToRgbInPlaceVectorized(in ComponentValues values)
+        {
+            ref Vector512<float> c0Base =
+                ref Unsafe.As<float, Vector512<float>>(ref MemoryMarshal.GetReference(values.Component0));
+            ref Vector512<float> c1Base =
+                ref Unsafe.As<float, Vector512<float>>(ref MemoryMarshal.GetReference(values.Component1));
+            ref Vector512<float> c2Base =
+                ref Unsafe.As<float, Vector512<float>>(ref MemoryMarshal.GetReference(values.Component2));
+
+            Vector512<float> chromaOffset = Vector512.Create(-this.HalfValue);
+            Vector512<float> scale = Vector512.Create(1 / this.MaximumValue);
+            Vector512<float> rCrMult = Vector512.Create(YCbCrScalar.RCrMult);
+            Vector512<float> gCbMult = Vector512.Create(-YCbCrScalar.GCbMult);
+            Vector512<float> gCrMult = Vector512.Create(-YCbCrScalar.GCrMult);
+            Vector512<float> bCbMult = Vector512.Create(YCbCrScalar.BCbMult);
+
+            nuint n = values.Component0.Vector512Count<float>();
+            for (nuint i = 0; i < n; i++)
+            {
+                // y = yVals[i];
+                // cb = cbVals[i] - 128F;
+                // cr = crVals[i] - 128F;
+                ref Vector512<float> c0 = ref Unsafe.Add(ref c0Base, i);
+                ref Vector512<float> c1 = ref Unsafe.Add(ref c1Base, i);
+                ref Vector512<float> c2 = ref Unsafe.Add(ref c2Base, i);
+
+                Vector512<float> y = c0;
+                Vector512<float> cb = c1 + chromaOffset;
+                Vector512<float> cr = c2 + chromaOffset;
+
+                // r = y + (1.402F * cr);
+                // g = y - (0.344136F * cb) - (0.714136F * cr);
+                // b = y + (1.772F * cb);
+                Vector512<float> r = Vector512_.MultiplyAdd(y, cr, rCrMult);
+                Vector512<float> g = Vector512_.MultiplyAdd(Vector512_.MultiplyAdd(y, cb, gCbMult), cr, gCrMult);
+                Vector512<float> b = Vector512_.MultiplyAdd(y, cb, bCbMult);
+
+                r = Vector512_.RoundToNearestInteger(r) * scale;
+                g = Vector512_.RoundToNearestInteger(g) * scale;
+                b = Vector512_.RoundToNearestInteger(b) * scale;
+
+                c0 = r;
+                c1 = g;
+                c2 = b;
+            }
+        }
+
+        /// <inheritdoc/>
+        protected override void ConvertFromRgbVectorized(in ComponentValues values, Span<float> rLane, Span<float> gLane, Span<float> bLane)
+        {
+            ref Vector512<float> destY =
+                ref Unsafe.As<float, Vector512<float>>(ref MemoryMarshal.GetReference(values.Component0));
+            ref Vector512<float> destCb =
+                ref Unsafe.As<float, Vector512<float>>(ref MemoryMarshal.GetReference(values.Component1));
+            ref Vector512<float> destCr =
+                ref Unsafe.As<float, Vector512<float>>(ref MemoryMarshal.GetReference(values.Component2));
+
+            ref Vector512<float> srcR =
+                ref Unsafe.As<float, Vector512<float>>(ref MemoryMarshal.GetReference(rLane));
+            ref Vector512<float> srcG =
+                ref Unsafe.As<float, Vector512<float>>(ref MemoryMarshal.GetReference(gLane));
+            ref Vector512<float> srcB =
+                ref Unsafe.As<float, Vector512<float>>(ref MemoryMarshal.GetReference(bLane));
+
+            Vector512<float> chromaOffset = Vector512.Create(this.HalfValue);
+            Vector512<float> f0299 = Vector512.Create(0.299f);
+            Vector512<float> f0587 = Vector512.Create(0.587f);
+            Vector512<float> f0114 = Vector512.Create(0.114f);
+            Vector512<float> fn0168736 = Vector512.Create(-0.168736f);
+            Vector512<float> fn0331264 = Vector512.Create(-0.331264f);
+            Vector512<float> fn0418688 = Vector512.Create(-0.418688f);
+            Vector512<float> fn0081312F = Vector512.Create(-0.081312F);
+            Vector512<float> f05 = Vector512.Create(0.5f);
+
+            nuint n = values.Component0.Vector512Count<float>();
+            for (nuint i = 0; i < n; i++)
+            {
+                Vector512<float> r = Unsafe.Add(ref srcR, i);
+                Vector512<float> g = Unsafe.Add(ref srcG, i);
+                Vector512<float> b = Unsafe.Add(ref srcB, i);
+
+                // y  =   0 + (0.299 * r) + (0.587 * g) + (0.114 * b)
+                // cb = 128 - (0.168736 * r) - (0.331264 * g) + (0.5 * b)
+                // cr = 128 + (0.5 * r) - (0.418688 * g) - (0.081312 * b)
+                Vector512<float> y = Vector512_.MultiplyAdd(Vector512_.MultiplyAdd(f0114 * b, f0587, g), f0299, r);
+                Vector512<float> cb = chromaOffset + Vector512_.MultiplyAdd(Vector512_.MultiplyAdd(f05 * b, fn0331264, g), fn0168736, r);
+                Vector512<float> cr = chromaOffset + Vector512_.MultiplyAdd(Vector512_.MultiplyAdd(fn0081312F * b, fn0418688, g), f05, r);
+
+                Unsafe.Add(ref destY, i) = y;
+                Unsafe.Add(ref destCb, i) = cb;
+                Unsafe.Add(ref destCr, i) = cr;
+            }
+        }
+
+        /// <inheritdoc/>
+        protected override void ConvertToRgbInPlaceScalarRemainder(in ComponentValues values)
+            => YCbCrScalar.ConvertToRgbInPlace(values, this.MaximumValue, this.HalfValue);
+
+        /// <inheritdoc/>
+        protected override void ConvertFromRgbScalarRemainder(in ComponentValues values, Span<float> rLane, Span<float> gLane, Span<float> bLane)
+            => YCbCrScalar.ConvertFromRgb(values, this.HalfValue, rLane, gLane, bLane);
+    }
+}
diff --git a/src/ImageSharp/Formats/Jpeg/Components/ColorConverters/JpegColorConverter.YccKArm64.cs b/src/ImageSharp/Formats/Jpeg/Components/ColorConverters/JpegColorConverter.YccKArm64.cs
deleted file mode 100644
index 285ba62cfd..0000000000
--- a/src/ImageSharp/Formats/Jpeg/Components/ColorConverters/JpegColorConverter.YccKArm64.cs
+++ /dev/null
@@ -1,133 +0,0 @@
-// Copyright (c) Six Labors.
-// Licensed under the Six Labors Split License.
-
-using System.Runtime.CompilerServices;
-using System.Runtime.InteropServices;
-using System.Runtime.Intrinsics;
-using System.Runtime.Intrinsics.Arm;
-using System.Runtime.Intrinsics.X86;
-using static SixLabors.ImageSharp.SimdUtils;
-
-namespace SixLabors.ImageSharp.Formats.Jpeg.Components;
-
-internal abstract partial class JpegColorConverterBase
-{
-    internal sealed class YccKArm64 : JpegColorConverterArm64
-    {
-        public YccKArm64(int precision)
-            : base(JpegColorSpace.Ycck, precision)
-        {
-        }
-
-        /// <inheritdoc/>
-        public override void ConvertToRgbInplace(in ComponentValues values)
-        {
-            ref Vector128<float> c0Base =
-                ref Unsafe.As<float, Vector128<float>>(ref MemoryMarshal.GetReference(values.Component0));
-            ref Vector128<float> c1Base =
-                ref Unsafe.As<float, Vector128<float>>(ref MemoryMarshal.GetReference(values.Component1));
-            ref Vector128<float> c2Base =
-                ref Unsafe.As<float, Vector128<float>>(ref MemoryMarshal.GetReference(values.Component2));
-            ref Vector128<float> kBase =
-                ref Unsafe.As<float, Vector128<float>>(ref MemoryMarshal.GetReference(values.Component3));
-
-            // Used for the color conversion
-            var chromaOffset = Vector128.Create(-this.HalfValue);
-            var scale = Vector128.Create(1 / (this.MaximumValue * this.MaximumValue));
-            var max = Vector128.Create(this.MaximumValue);
-            var rCrMult = Vector128.Create(YCbCrScalar.RCrMult);
-            var gCbMult = Vector128.Create(-YCbCrScalar.GCbMult);
-            var gCrMult = Vector128.Create(-YCbCrScalar.GCrMult);
-            var bCbMult = Vector128.Create(YCbCrScalar.BCbMult);
-
-            // Walking 8 elements at one step:
-            nuint n = (uint)values.Component0.Length / (uint)Vector128<float>.Count;
-            for (nuint i = 0; i < n; i++)
-            {
-                // y = yVals[i];
-                // cb = cbVals[i] - 128F;
-                // cr = crVals[i] - 128F;
-                // k = kVals[i] / 256F;
-                ref Vector128<float> c0 = ref Unsafe.Add(ref c0Base, i);
-                ref Vector128<float> c1 = ref Unsafe.Add(ref c1Base, i);
-                ref Vector128<float> c2 = ref Unsafe.Add(ref c2Base, i);
-                Vector128<float> y = c0;
-                Vector128<float> cb = AdvSimd.Add(c1, chromaOffset);
-                Vector128<float> cr = AdvSimd.Add(c2, chromaOffset);
-                Vector128<float> scaledK = AdvSimd.Multiply(Unsafe.Add(ref kBase, i), scale);
-
-                // r = y + (1.402F * cr);
-                // g = y - (0.344136F * cb) - (0.714136F * cr);
-                // b = y + (1.772F * cb);
-                Vector128<float> r = HwIntrinsics.MultiplyAdd(y, cr, rCrMult);
-                Vector128<float> g =
-                    HwIntrinsics.MultiplyAdd(HwIntrinsics.MultiplyAdd(y, cb, gCbMult), cr, gCrMult);
-                Vector128<float> b = HwIntrinsics.MultiplyAdd(y, cb, bCbMult);
-
-                r = AdvSimd.Subtract(max, AdvSimd.RoundToNearest(r));
-                g = AdvSimd.Subtract(max, AdvSimd.RoundToNearest(g));
-                b = AdvSimd.Subtract(max, AdvSimd.RoundToNearest(b));
-
-                r = AdvSimd.Multiply(r, scaledK);
-                g = AdvSimd.Multiply(g, scaledK);
-                b = AdvSimd.Multiply(b, scaledK);
-
-                c0 = r;
-                c1 = g;
-                c2 = b;
-            }
-        }
-
-        /// <inheritdoc/>
-        public override void ConvertFromRgb(in ComponentValues values, Span<float> rLane, Span<float> gLane, Span<float> bLane)
-        {
-            // rgb -> cmyk
-            CmykArm64.ConvertFromRgb(in values, this.MaximumValue, rLane, gLane, bLane);
-
-            // cmyk -> ycck
-            ref Vector128<float> destY =
-                ref Unsafe.As<float, Vector128<float>>(ref MemoryMarshal.GetReference(values.Component0));
-            ref Vector128<float> destCb =
-                ref Unsafe.As<float, Vector128<float>>(ref MemoryMarshal.GetReference(values.Component1));
-            ref Vector128<float> destCr =
-                ref Unsafe.As<float, Vector128<float>>(ref MemoryMarshal.GetReference(values.Component2));
-
-            ref Vector128<float> srcR = ref destY;
-            ref Vector128<float> srcG = ref destCb;
-            ref Vector128<float> srcB = ref destCr;
-
-            // Used for the color conversion
-            var maxSampleValue = Vector128.Create(this.MaximumValue);
-
-            var chromaOffset = Vector128.Create(this.HalfValue);
-
-            var f0299 = Vector128.Create(0.299f);
-            var f0587 = Vector128.Create(0.587f);
-            var f0114 = Vector128.Create(0.114f);
-            var fn0168736 = Vector128.Create(-0.168736f);
-            var fn0331264 = Vector128.Create(-0.331264f);
-            var fn0418688 = Vector128.Create(-0.418688f);
-            var fn0081312F = Vector128.Create(-0.081312F);
-            var f05 = Vector128.Create(0.5f);
-
-            nuint n = (uint)values.Component0.Length / (uint)Vector128<float>.Count;
-            for (nuint i = 0; i < n; i++)
-            {
-                Vector128<float> r = AdvSimd.Subtract(maxSampleValue, Unsafe.Add(ref srcR, i));
-                Vector128<float> g = AdvSimd.Subtract(maxSampleValue, Unsafe.Add(ref srcG, i));
-                Vector128<float> b = AdvSimd.Subtract(maxSampleValue, Unsafe.Add(ref srcB, i));
-
-                // y  =   0 + (0.299 * r) + (0.587 * g) + (0.114 * b)
-                // cb = 128 - (0.168736 * r) - (0.331264 * g) + (0.5 * b)
-                // cr = 128 + (0.5 * r) - (0.418688 * g) - (0.081312 * b)
-                Vector128<float> y = HwIntrinsics.MultiplyAdd(HwIntrinsics.MultiplyAdd(AdvSimd.Multiply(f0114, b), f0587, g), f0299, r);
-                Vector128<float> cb = AdvSimd.Add(chromaOffset, HwIntrinsics.MultiplyAdd(HwIntrinsics.MultiplyAdd(AdvSimd.Multiply(f05, b), fn0331264, g), fn0168736, r));
-                Vector128<float> cr = AdvSimd.Add(chromaOffset, HwIntrinsics.MultiplyAdd(HwIntrinsics.MultiplyAdd(AdvSimd.Multiply(fn0081312F, b), fn0418688, g), f05, r));
-
-                Unsafe.Add(ref destY, i) = y;
-                Unsafe.Add(ref destCb, i) = cb;
-                Unsafe.Add(ref destCr, i) = cr;
-            }
-        }
-    }
-}
diff --git a/src/ImageSharp/Formats/Jpeg/Components/ColorConverters/JpegColorConverter.YccKScalar.cs b/src/ImageSharp/Formats/Jpeg/Components/ColorConverters/JpegColorConverter.YccKScalar.cs
index e47572b02a..3368e52bf0 100644
--- a/src/ImageSharp/Formats/Jpeg/Components/ColorConverters/JpegColorConverter.YccKScalar.cs
+++ b/src/ImageSharp/Formats/Jpeg/Components/ColorConverters/JpegColorConverter.YccKScalar.cs
@@ -1,13 +1,20 @@
 // Copyright (c) Six Labors.
 // Licensed under the Six Labors Split License.
 
+using System.Buffers;
+using System.Numerics;
+using System.Runtime.InteropServices;
+using SixLabors.ImageSharp.ColorProfiles;
+using SixLabors.ImageSharp.ColorProfiles.Icc;
+using SixLabors.ImageSharp.Metadata.Profiles.Icc;
+
 namespace SixLabors.ImageSharp.Formats.Jpeg.Components;
 
 internal abstract partial class JpegColorConverterBase
 {
     internal sealed class YccKScalar : JpegColorConverterScalar
     {
-        // derived from ITU-T Rec. T.871
+        // Derived from ITU-T Rec. T.871
         internal const float RCrMult = 1.402f;
         internal const float GCbMult = (float)(0.114 * 1.772 / 0.587);
         internal const float GCrMult = (float)(0.299 * 1.402 / 0.587);
@@ -19,14 +26,18 @@ internal abstract partial class JpegColorConverterBase
         }
 
         /// <inheritdoc/>
-        public override void ConvertToRgbInplace(in ComponentValues values)
-            => ConvertToRgpInplace(values, this.MaximumValue, this.HalfValue);
+        public override void ConvertToRgbInPlace(in ComponentValues values)
+            => ConvertToRgbInPlace(values, this.MaximumValue, this.HalfValue);
+
+        /// <inheritdoc/>
+        public override void ConvertToRgbInPlaceWithIcc(Configuration configuration, in ComponentValues values, IccProfile profile)
+            => ConvertToRgbInPlaceWithIcc(configuration, profile, values, this.MaximumValue);
 
         /// <inheritdoc/>
-        public override void ConvertFromRgb(in ComponentValues values, Span<float> r, Span<float> g, Span<float> b)
-            => ConvertFromRgb(values, this.HalfValue, this.MaximumValue, r, g, b);
+        public override void ConvertFromRgb(in ComponentValues values, Span<float> rLane, Span<float> gLane, Span<float> bLane)
+            => ConvertFromRgb(values, this.HalfValue, this.MaximumValue, rLane, gLane, bLane);
 
-        public static void ConvertToRgpInplace(in ComponentValues values, float maxValue, float halfValue)
+        public static void ConvertToRgbInPlace(in ComponentValues values, float maxValue, float halfValue)
         {
             Span<float> c0 = values.Component0;
             Span<float> c1 = values.Component1;
@@ -73,5 +84,42 @@ internal abstract partial class JpegColorConverterBase
                 y[i] = halfValue + (0.5f * r) - (0.418688f * g) - (0.081312f * b);
             }
         }
+
+        public static void ConvertToRgbInPlaceWithIcc(Configuration configuration, IccProfile profile, in ComponentValues values, float maxValue)
+        {
+            using IMemoryOwner<float> memoryOwner = configuration.MemoryAllocator.Allocate<float>(values.Component0.Length * 4);
+            Span<float> packed = memoryOwner.Memory.Span;
+
+            Span<float> c0 = values.Component0;
+            Span<float> c1 = values.Component1;
+            Span<float> c2 = values.Component2;
+            Span<float> c3 = values.Component3;
+
+            PackedInvertNormalizeInterleave4(c0, c1, c2, c3, packed, maxValue);
+
+            ColorProfileConverter converter = new();
+            Span<Cmyk> source = MemoryMarshal.Cast<float, Cmyk>(packed);
+
+            // YccK is not a defined ICC color space — it's a JPEG-specific encoding used in Adobe-style CMYK JPEGs.
+            // ICC profiles expect colorimetric CMYK values, so we must first convert YccK to CMYK using a hardcoded inverse transform.
+            // This transform assumes Rec.601 YCbCr coefficients and an inverted K channel.
+            //
+            // The YccK => Cmyk conversion is independent of any embedded ICC profile.
+            // Since the same RGB working space is used during conversion to and from XYZ,
+            // colorimetric accuracy is preserved.
+            converter.Convert<YccK, Cmyk>(MemoryMarshal.Cast<Cmyk, YccK>(source), source);
+
+            Span<Rgb> destination = MemoryMarshal.Cast<float, Rgb>(packed)[..source.Length];
+
+            ColorConversionOptions options = new()
+            {
+                SourceIccProfile = profile,
+                TargetIccProfile = CompactSrgbV4Profile.Profile,
+            };
+            converter = new ColorProfileConverter(options);
+            converter.Convert<Cmyk, Rgb>(source, destination);
+
+            UnpackDeinterleave3(MemoryMarshal.Cast<float, Vector3>(packed)[..source.Length], c0, c1, c2);
+        }
     }
 }
diff --git a/src/ImageSharp/Formats/Jpeg/Components/ColorConverters/JpegColorConverter.YccKVector.cs b/src/ImageSharp/Formats/Jpeg/Components/ColorConverters/JpegColorConverter.YccKVector.cs
deleted file mode 100644
index 570a401adf..0000000000
--- a/src/ImageSharp/Formats/Jpeg/Components/ColorConverters/JpegColorConverter.YccKVector.cs
+++ /dev/null
@@ -1,136 +0,0 @@
-// Copyright (c) Six Labors.
-// Licensed under the Six Labors Split License.
-
-using System.Numerics;
-using System.Runtime.CompilerServices;
-using System.Runtime.InteropServices;
-
-namespace SixLabors.ImageSharp.Formats.Jpeg.Components;
-
-internal abstract partial class JpegColorConverterBase
-{
-    internal sealed class YccKVector : JpegColorConverterVector
-    {
-        public YccKVector(int precision)
-            : base(JpegColorSpace.Ycck, precision)
-        {
-        }
-
-        /// <inheritdoc/>
-        protected override void ConvertToRgbInplaceVectorized(in ComponentValues values)
-        {
-            ref Vector<float> c0Base =
-                ref Unsafe.As<float, Vector<float>>(ref MemoryMarshal.GetReference(values.Component0));
-            ref Vector<float> c1Base =
-                ref Unsafe.As<float, Vector<float>>(ref MemoryMarshal.GetReference(values.Component1));
-            ref Vector<float> c2Base =
-                ref Unsafe.As<float, Vector<float>>(ref MemoryMarshal.GetReference(values.Component2));
-            ref Vector<float> kBase =
-                ref Unsafe.As<float, Vector<float>>(ref MemoryMarshal.GetReference(values.Component3));
-
-            var chromaOffset = new Vector<float>(-this.HalfValue);
-            var scale = new Vector<float>(1 / (this.MaximumValue * this.MaximumValue));
-            var max = new Vector<float>(this.MaximumValue);
-            var rCrMult = new Vector<float>(YCbCrScalar.RCrMult);
-            var gCbMult = new Vector<float>(-YCbCrScalar.GCbMult);
-            var gCrMult = new Vector<float>(-YCbCrScalar.GCrMult);
-            var bCbMult = new Vector<float>(YCbCrScalar.BCbMult);
-
-            nuint n = values.Component0.VectorCount<float>();
-            for (nuint i = 0; i < n; i++)
-            {
-                // y = yVals[i];
-                // cb = cbVals[i] - 128F;
-                // cr = crVals[i] - 128F;
-                // k = kVals[i] / 256F;
-                ref Vector<float> c0 = ref Unsafe.Add(ref c0Base, i);
-                ref Vector<float> c1 = ref Unsafe.Add(ref c1Base, i);
-                ref Vector<float> c2 = ref Unsafe.Add(ref c2Base, i);
-
-                Vector<float> y = c0;
-                Vector<float> cb = c1 + chromaOffset;
-                Vector<float> cr = c2 + chromaOffset;
-                Vector<float> scaledK = Unsafe.Add(ref kBase, i) * scale;
-
-                // r = y + (1.402F * cr);
-                // g = y - (0.344136F * cb) - (0.714136F * cr);
-                // b = y + (1.772F * cb);
-                Vector<float> r = y + (cr * rCrMult);
-                Vector<float> g = y + (cb * gCbMult) + (cr * gCrMult);
-                Vector<float> b = y + (cb * bCbMult);
-
-                r = (max - r.FastRound()) * scaledK;
-                g = (max - g.FastRound()) * scaledK;
-                b = (max - b.FastRound()) * scaledK;
-
-                c0 = r;
-                c1 = g;
-                c2 = b;
-            }
-        }
-
-        /// <inheritdoc/>
-        protected override void ConvertToRgbInplaceScalarRemainder(in ComponentValues values)
-            => YccKScalar.ConvertToRgpInplace(values, this.MaximumValue, this.HalfValue);
-
-        /// <inheritdoc/>
-        protected override void ConvertFromRgbVectorized(in ComponentValues values, Span<float> rLane, Span<float> gLane, Span<float> bLane)
-        {
-            // rgb -> cmyk
-            CmykVector.ConvertFromRgbInplaceVectorized(in values, this.MaximumValue, rLane, gLane, bLane);
-
-            // cmyk -> ycck
-            ref Vector<float> destY =
-                ref Unsafe.As<float, Vector<float>>(ref MemoryMarshal.GetReference(values.Component0));
-            ref Vector<float> destCb =
-                ref Unsafe.As<float, Vector<float>>(ref MemoryMarshal.GetReference(values.Component1));
-            ref Vector<float> destCr =
-                ref Unsafe.As<float, Vector<float>>(ref MemoryMarshal.GetReference(values.Component2));
-
-            ref Vector<float> srcR = ref destY;
-            ref Vector<float> srcG = ref destCb;
-            ref Vector<float> srcB = ref destCr;
-
-            var maxSampleValue = new Vector<float>(this.MaximumValue);
-
-            var chromaOffset = new Vector<float>(this.HalfValue);
-
-            var rYMult = new Vector<float>(0.299f);
-            var gYMult = new Vector<float>(0.587f);
-            var bYMult = new Vector<float>(0.114f);
-
-            var rCbMult = new Vector<float>(0.168736f);
-            var gCbMult = new Vector<float>(0.331264f);
-            var bCbMult = new Vector<float>(0.5f);
-
-            var rCrMult = new Vector<float>(0.5f);
-            var gCrMult = new Vector<float>(0.418688f);
-            var bCrMult = new Vector<float>(0.081312f);
-
-            nuint n = values.Component0.VectorCount<float>();
-            for (nuint i = 0; i < n; i++)
-            {
-                Vector<float> r = maxSampleValue - Unsafe.Add(ref srcR, i);
-                Vector<float> g = maxSampleValue - Unsafe.Add(ref srcG, i);
-                Vector<float> b = maxSampleValue - Unsafe.Add(ref srcB, i);
-
-                // y  =   0 + (0.299 * r) + (0.587 * g) + (0.114 * b)
-                // cb = 128 - (0.168736 * r) - (0.331264 * g) + (0.5 * b)
-                // cr = 128 + (0.5 * r) - (0.418688 * g) - (0.081312 * b)
-                Unsafe.Add(ref destY, i) = (rYMult * r) + (gYMult * g) + (bYMult * b);
-                Unsafe.Add(ref destCb, i) = chromaOffset - (rCbMult * r) - (gCbMult * g) + (bCbMult * b);
-                Unsafe.Add(ref destCr, i) = chromaOffset + (rCrMult * r) - (gCrMult * g) - (bCrMult * b);
-            }
-        }
-
-        /// <inheritdoc/>
-        protected override void ConvertFromRgbScalarRemainder(in ComponentValues values, Span<float> r, Span<float> g, Span<float> b)
-        {
-            // rgb -> cmyk
-            CmykScalar.ConvertFromRgb(in values, this.MaximumValue, r, g, b);
-
-            // cmyk -> ycck
-            YccKScalar.ConvertFromRgb(in values, this.HalfValue, this.MaximumValue, r, g, b);
-        }
-    }
-}
diff --git a/src/ImageSharp/Formats/Jpeg/Components/ColorConverters/JpegColorConverter.YccKVector128.cs b/src/ImageSharp/Formats/Jpeg/Components/ColorConverters/JpegColorConverter.YccKVector128.cs
new file mode 100644
index 0000000000..67b7ee0dc6
--- /dev/null
+++ b/src/ImageSharp/Formats/Jpeg/Components/ColorConverters/JpegColorConverter.YccKVector128.cs
@@ -0,0 +1,135 @@
+// Copyright (c) Six Labors.
+// Licensed under the Six Labors Split License.
+
+using System.Runtime.CompilerServices;
+using System.Runtime.InteropServices;
+using System.Runtime.Intrinsics;
+using SixLabors.ImageSharp.Common.Helpers;
+using SixLabors.ImageSharp.Metadata.Profiles.Icc;
+
+namespace SixLabors.ImageSharp.Formats.Jpeg.Components;
+
+internal abstract partial class JpegColorConverterBase
+{
+    internal sealed class YccKVector128 : JpegColorConverterVector128
+    {
+        public YccKVector128(int precision)
+            : base(JpegColorSpace.Ycck, precision)
+        {
+        }
+
+        /// <inheritdoc/>
+        public override void ConvertToRgbInPlace(in ComponentValues values)
+        {
+            ref Vector128<float> c0Base =
+                ref Unsafe.As<float, Vector128<float>>(ref MemoryMarshal.GetReference(values.Component0));
+            ref Vector128<float> c1Base =
+                ref Unsafe.As<float, Vector128<float>>(ref MemoryMarshal.GetReference(values.Component1));
+            ref Vector128<float> c2Base =
+                ref Unsafe.As<float, Vector128<float>>(ref MemoryMarshal.GetReference(values.Component2));
+            ref Vector128<float> kBase =
+                ref Unsafe.As<float, Vector128<float>>(ref MemoryMarshal.GetReference(values.Component3));
+
+            // Used for the color conversion
+            Vector128<float> chromaOffset = Vector128.Create(-this.HalfValue);
+            Vector128<float> scale = Vector128.Create(1 / (this.MaximumValue * this.MaximumValue));
+            Vector128<float> max = Vector128.Create(this.MaximumValue);
+            Vector128<float> rCrMult = Vector128.Create(YCbCrScalar.RCrMult);
+            Vector128<float> gCbMult = Vector128.Create(-YCbCrScalar.GCbMult);
+            Vector128<float> gCrMult = Vector128.Create(-YCbCrScalar.GCrMult);
+            Vector128<float> bCbMult = Vector128.Create(YCbCrScalar.BCbMult);
+
+            // Walking 8 elements at one step:
+            nuint n = values.Component0.Vector128Count<float>();
+            for (nuint i = 0; i < n; i++)
+            {
+                // y = yVals[i];
+                // cb = cbVals[i] - 128F;
+                // cr = crVals[i] - 128F;
+                // k = kVals[i] / 256F;
+                ref Vector128<float> c0 = ref Unsafe.Add(ref c0Base, i);
+                ref Vector128<float> c1 = ref Unsafe.Add(ref c1Base, i);
+                ref Vector128<float> c2 = ref Unsafe.Add(ref c2Base, i);
+                Vector128<float> y = c0;
+                Vector128<float> cb = c1 + chromaOffset;
+                Vector128<float> cr = c2 + chromaOffset;
+                Vector128<float> scaledK = Unsafe.Add(ref kBase, i) * scale;
+
+                // r = y + (1.402F * cr);
+                // g = y - (0.344136F * cb) - (0.714136F * cr);
+                // b = y + (1.772F * cb);
+                Vector128<float> r = Vector128_.MultiplyAdd(y, cr, rCrMult);
+                Vector128<float> g = Vector128_.MultiplyAdd(Vector128_.MultiplyAdd(y, cb, gCbMult), cr, gCrMult);
+                Vector128<float> b = Vector128_.MultiplyAdd(y, cb, bCbMult);
+
+                r = max - Vector128_.RoundToNearestInteger(r);
+                g = max - Vector128_.RoundToNearestInteger(g);
+                b = max - Vector128_.RoundToNearestInteger(b);
+
+                r *= scaledK;
+                g *= scaledK;
+                b *= scaledK;
+
+                c0 = r;
+                c1 = g;
+                c2 = b;
+            }
+        }
+
+        /// <inheritdoc/>
+        public override void ConvertToRgbInPlaceWithIcc(Configuration configuration, in ComponentValues values, IccProfile profile)
+            => YccKScalar.ConvertToRgbInPlaceWithIcc(configuration, profile, values, this.MaximumValue);
+
+        /// <inheritdoc/>
+        public override void ConvertFromRgb(in ComponentValues values, Span<float> rLane, Span<float> gLane, Span<float> bLane)
+        {
+            // rgb -> cmyk
+            CmykVector128.ConvertFromRgb(in values, this.MaximumValue, rLane, gLane, bLane);
+
+            // cmyk -> ycck
+            ref Vector128<float> destY =
+                ref Unsafe.As<float, Vector128<float>>(ref MemoryMarshal.GetReference(values.Component0));
+            ref Vector128<float> destCb =
+                ref Unsafe.As<float, Vector128<float>>(ref MemoryMarshal.GetReference(values.Component1));
+            ref Vector128<float> destCr =
+                ref Unsafe.As<float, Vector128<float>>(ref MemoryMarshal.GetReference(values.Component2));
+
+            ref Vector128<float> srcR = ref destY;
+            ref Vector128<float> srcG = ref destCb;
+            ref Vector128<float> srcB = ref destCr;
+
+            // Used for the color conversion
+            Vector128<float> maxSampleValue = Vector128.Create(this.MaximumValue);
+
+            Vector128<float> chromaOffset = Vector128.Create(this.HalfValue);
+
+            Vector128<float> f0299 = Vector128.Create(0.299f);
+            Vector128<float> f0587 = Vector128.Create(0.587f);
+            Vector128<float> f0114 = Vector128.Create(0.114f);
+            Vector128<float> fn0168736 = Vector128.Create(-0.168736f);
+            Vector128<float> fn0331264 = Vector128.Create(-0.331264f);
+            Vector128<float> fn0418688 = Vector128.Create(-0.418688f);
+            Vector128<float> fn0081312F = Vector128.Create(-0.081312F);
+            Vector128<float> f05 = Vector128.Create(0.5f);
+
+            nuint n = values.Component0.Vector128Count<float>();
+            for (nuint i = 0; i < n; i++)
+            {
+                Vector128<float> r = maxSampleValue - Unsafe.Add(ref srcR, i);
+                Vector128<float> g = maxSampleValue - Unsafe.Add(ref srcG, i);
+                Vector128<float> b = maxSampleValue - Unsafe.Add(ref srcB, i);
+
+                // y  =   0 + (0.299 * r) + (0.587 * g) + (0.114 * b)
+                // cb = 128 - (0.168736 * r) - (0.331264 * g) + (0.5 * b)
+                // cr = 128 + (0.5 * r) - (0.418688 * g) - (0.081312 * b)
+                Vector128<float> y = Vector128_.MultiplyAdd(Vector128_.MultiplyAdd(f0114 * b, f0587, g), f0299, r);
+                Vector128<float> cb = chromaOffset + Vector128_.MultiplyAdd(Vector128_.MultiplyAdd(f05 * b, fn0331264, g), fn0168736, r);
+                Vector128<float> cr = chromaOffset + Vector128_.MultiplyAdd(Vector128_.MultiplyAdd(fn0081312F * b, fn0418688, g), f05, r);
+
+                Unsafe.Add(ref destY, i) = y;
+                Unsafe.Add(ref destCb, i) = cb;
+                Unsafe.Add(ref destCr, i) = cr;
+            }
+        }
+    }
+}
diff --git a/src/ImageSharp/Formats/Jpeg/Components/ColorConverters/JpegColorConverter.YccKAvx.cs b/src/ImageSharp/Formats/Jpeg/Components/ColorConverters/JpegColorConverter.YccKVector256.cs
similarity index 50%
rename from src/ImageSharp/Formats/Jpeg/Components/ColorConverters/JpegColorConverter.YccKAvx.cs
rename to src/ImageSharp/Formats/Jpeg/Components/ColorConverters/JpegColorConverter.YccKVector256.cs
index efe40ba085..3a586d25fa 100644
--- a/src/ImageSharp/Formats/Jpeg/Components/ColorConverters/JpegColorConverter.YccKAvx.cs
+++ b/src/ImageSharp/Formats/Jpeg/Components/ColorConverters/JpegColorConverter.YccKVector256.cs
@@ -4,22 +4,22 @@
 using System.Runtime.CompilerServices;
 using System.Runtime.InteropServices;
 using System.Runtime.Intrinsics;
-using System.Runtime.Intrinsics.X86;
-using static SixLabors.ImageSharp.SimdUtils;
+using SixLabors.ImageSharp.Common.Helpers;
+using SixLabors.ImageSharp.Metadata.Profiles.Icc;
 
 namespace SixLabors.ImageSharp.Formats.Jpeg.Components;
 
 internal abstract partial class JpegColorConverterBase
 {
-    internal sealed class YccKAvx : JpegColorConverterAvx
+    internal sealed class YccKVector256 : JpegColorConverterVector256
     {
-        public YccKAvx(int precision)
+        public YccKVector256(int precision)
             : base(JpegColorSpace.Ycck, precision)
         {
         }
 
         /// <inheritdoc/>
-        public override void ConvertToRgbInplace(in ComponentValues values)
+        public override void ConvertToRgbInPlace(in ComponentValues values)
         {
             ref Vector256<float> c0Base =
                 ref Unsafe.As<float, Vector256<float>>(ref MemoryMarshal.GetReference(values.Component0));
@@ -31,13 +31,13 @@ internal abstract partial class JpegColorConverterBase
                 ref Unsafe.As<float, Vector256<float>>(ref MemoryMarshal.GetReference(values.Component3));
 
             // Used for the color conversion
-            var chromaOffset = Vector256.Create(-this.HalfValue);
-            var scale = Vector256.Create(1 / (this.MaximumValue * this.MaximumValue));
-            var max = Vector256.Create(this.MaximumValue);
-            var rCrMult = Vector256.Create(YCbCrScalar.RCrMult);
-            var gCbMult = Vector256.Create(-YCbCrScalar.GCbMult);
-            var gCrMult = Vector256.Create(-YCbCrScalar.GCrMult);
-            var bCbMult = Vector256.Create(YCbCrScalar.BCbMult);
+            Vector256<float> chromaOffset = Vector256.Create(-this.HalfValue);
+            Vector256<float> scale = Vector256.Create(1 / (this.MaximumValue * this.MaximumValue));
+            Vector256<float> max = Vector256.Create(this.MaximumValue);
+            Vector256<float> rCrMult = Vector256.Create(YCbCrScalar.RCrMult);
+            Vector256<float> gCbMult = Vector256.Create(-YCbCrScalar.GCbMult);
+            Vector256<float> gCrMult = Vector256.Create(-YCbCrScalar.GCrMult);
+            Vector256<float> bCbMult = Vector256.Create(YCbCrScalar.BCbMult);
 
             // Walking 8 elements at one step:
             nuint n = values.Component0.Vector256Count<float>();
@@ -51,25 +51,24 @@ internal abstract partial class JpegColorConverterBase
                 ref Vector256<float> c1 = ref Unsafe.Add(ref c1Base, i);
                 ref Vector256<float> c2 = ref Unsafe.Add(ref c2Base, i);
                 Vector256<float> y = c0;
-                Vector256<float> cb = Avx.Add(c1, chromaOffset);
-                Vector256<float> cr = Avx.Add(c2, chromaOffset);
-                Vector256<float> scaledK = Avx.Multiply(Unsafe.Add(ref kBase, i), scale);
+                Vector256<float> cb = c1 + chromaOffset;
+                Vector256<float> cr = c2 + chromaOffset;
+                Vector256<float> scaledK = Unsafe.Add(ref kBase, i) * scale;
 
                 // r = y + (1.402F * cr);
                 // g = y - (0.344136F * cb) - (0.714136F * cr);
                 // b = y + (1.772F * cb);
-                Vector256<float> r = HwIntrinsics.MultiplyAdd(y, cr, rCrMult);
-                Vector256<float> g =
-                    HwIntrinsics.MultiplyAdd(HwIntrinsics.MultiplyAdd(y, cb, gCbMult), cr, gCrMult);
-                Vector256<float> b = HwIntrinsics.MultiplyAdd(y, cb, bCbMult);
+                Vector256<float> r = Vector256_.MultiplyAdd(y, cr, rCrMult);
+                Vector256<float> g = Vector256_.MultiplyAdd(Vector256_.MultiplyAdd(y, cb, gCbMult), cr, gCrMult);
+                Vector256<float> b = Vector256_.MultiplyAdd(y, cb, bCbMult);
 
-                r = Avx.Subtract(max, Avx.RoundToNearestInteger(r));
-                g = Avx.Subtract(max, Avx.RoundToNearestInteger(g));
-                b = Avx.Subtract(max, Avx.RoundToNearestInteger(b));
+                r = max - Vector256_.RoundToNearestInteger(r);
+                g = max - Vector256_.RoundToNearestInteger(g);
+                b = max - Vector256_.RoundToNearestInteger(b);
 
-                r = Avx.Multiply(r, scaledK);
-                g = Avx.Multiply(g, scaledK);
-                b = Avx.Multiply(b, scaledK);
+                r *= scaledK;
+                g *= scaledK;
+                b *= scaledK;
 
                 c0 = r;
                 c1 = g;
@@ -77,11 +76,15 @@ internal abstract partial class JpegColorConverterBase
             }
         }
 
+        /// <inheritdoc/>
+        public override void ConvertToRgbInPlaceWithIcc(Configuration configuration, in ComponentValues values, IccProfile profile)
+            => YccKScalar.ConvertToRgbInPlaceWithIcc(configuration, profile, values, this.MaximumValue);
+
         /// <inheritdoc/>
         public override void ConvertFromRgb(in ComponentValues values, Span<float> rLane, Span<float> gLane, Span<float> bLane)
         {
             // rgb -> cmyk
-            CmykAvx.ConvertFromRgb(in values, this.MaximumValue, rLane, gLane, bLane);
+            CmykVector256.ConvertFromRgb(in values, this.MaximumValue, rLane, gLane, bLane);
 
             // cmyk -> ycck
             ref Vector256<float> destY =
@@ -96,32 +99,32 @@ internal abstract partial class JpegColorConverterBase
             ref Vector256<float> srcB = ref destCr;
 
             // Used for the color conversion
-            var maxSampleValue = Vector256.Create(this.MaximumValue);
+            Vector256<float> maxSampleValue = Vector256.Create(this.MaximumValue);
 
-            var chromaOffset = Vector256.Create(this.HalfValue);
+            Vector256<float> chromaOffset = Vector256.Create(this.HalfValue);
 
-            var f0299 = Vector256.Create(0.299f);
-            var f0587 = Vector256.Create(0.587f);
-            var f0114 = Vector256.Create(0.114f);
-            var fn0168736 = Vector256.Create(-0.168736f);
-            var fn0331264 = Vector256.Create(-0.331264f);
-            var fn0418688 = Vector256.Create(-0.418688f);
-            var fn0081312F = Vector256.Create(-0.081312F);
-            var f05 = Vector256.Create(0.5f);
+            Vector256<float> f0299 = Vector256.Create(0.299f);
+            Vector256<float> f0587 = Vector256.Create(0.587f);
+            Vector256<float> f0114 = Vector256.Create(0.114f);
+            Vector256<float> fn0168736 = Vector256.Create(-0.168736f);
+            Vector256<float> fn0331264 = Vector256.Create(-0.331264f);
+            Vector256<float> fn0418688 = Vector256.Create(-0.418688f);
+            Vector256<float> fn0081312F = Vector256.Create(-0.081312F);
+            Vector256<float> f05 = Vector256.Create(0.5f);
 
             nuint n = values.Component0.Vector256Count<float>();
             for (nuint i = 0; i < n; i++)
             {
-                Vector256<float> r = Avx.Subtract(maxSampleValue, Unsafe.Add(ref srcR, i));
-                Vector256<float> g = Avx.Subtract(maxSampleValue, Unsafe.Add(ref srcG, i));
-                Vector256<float> b = Avx.Subtract(maxSampleValue, Unsafe.Add(ref srcB, i));
+                Vector256<float> r = maxSampleValue - Unsafe.Add(ref srcR, i);
+                Vector256<float> g = maxSampleValue - Unsafe.Add(ref srcG, i);
+                Vector256<float> b = maxSampleValue - Unsafe.Add(ref srcB, i);
 
                 // y  =   0 + (0.299 * r) + (0.587 * g) + (0.114 * b)
                 // cb = 128 - (0.168736 * r) - (0.331264 * g) + (0.5 * b)
                 // cr = 128 + (0.5 * r) - (0.418688 * g) - (0.081312 * b)
-                Vector256<float> y = HwIntrinsics.MultiplyAdd(HwIntrinsics.MultiplyAdd(Avx.Multiply(f0114, b), f0587, g), f0299, r);
-                Vector256<float> cb = Avx.Add(chromaOffset, HwIntrinsics.MultiplyAdd(HwIntrinsics.MultiplyAdd(Avx.Multiply(f05, b), fn0331264, g), fn0168736, r));
-                Vector256<float> cr = Avx.Add(chromaOffset, HwIntrinsics.MultiplyAdd(HwIntrinsics.MultiplyAdd(Avx.Multiply(fn0081312F, b), fn0418688, g), f05, r));
+                Vector256<float> y = Vector256_.MultiplyAdd(Vector256_.MultiplyAdd(f0114 * b, f0587, g), f0299, r);
+                Vector256<float> cb = chromaOffset + Vector256_.MultiplyAdd(Vector256_.MultiplyAdd(f05 * b, fn0331264, g), fn0168736, r);
+                Vector256<float> cr = chromaOffset + Vector256_.MultiplyAdd(Vector256_.MultiplyAdd(fn0081312F * b, fn0418688, g), f05, r);
 
                 Unsafe.Add(ref destY, i) = y;
                 Unsafe.Add(ref destCb, i) = cb;
diff --git a/src/ImageSharp/Formats/Jpeg/Components/ColorConverters/JpegColorConverter.YccKVector512.cs b/src/ImageSharp/Formats/Jpeg/Components/ColorConverters/JpegColorConverter.YccKVector512.cs
new file mode 100644
index 0000000000..b81a833cde
--- /dev/null
+++ b/src/ImageSharp/Formats/Jpeg/Components/ColorConverters/JpegColorConverter.YccKVector512.cs
@@ -0,0 +1,143 @@
+// Copyright (c) Six Labors.
+// Licensed under the Six Labors Split License.
+
+using System.Runtime.CompilerServices;
+using System.Runtime.InteropServices;
+using System.Runtime.Intrinsics;
+using SixLabors.ImageSharp.Common.Helpers;
+using SixLabors.ImageSharp.Metadata.Profiles.Icc;
+
+namespace SixLabors.ImageSharp.Formats.Jpeg.Components;
+
+internal abstract partial class JpegColorConverterBase
+{
+    internal sealed class YccKVector512 : JpegColorConverterVector512
+    {
+        public YccKVector512(int precision)
+            : base(JpegColorSpace.Ycck, precision)
+        {
+        }
+
+        /// <inheritdoc/>
+        protected override void ConvertToRgbInPlaceVectorized(in ComponentValues values)
+        {
+            ref Vector512<float> c0Base =
+                ref Unsafe.As<float, Vector512<float>>(ref MemoryMarshal.GetReference(values.Component0));
+            ref Vector512<float> c1Base =
+                ref Unsafe.As<float, Vector512<float>>(ref MemoryMarshal.GetReference(values.Component1));
+            ref Vector512<float> c2Base =
+                ref Unsafe.As<float, Vector512<float>>(ref MemoryMarshal.GetReference(values.Component2));
+            ref Vector512<float> kBase =
+                ref Unsafe.As<float, Vector512<float>>(ref MemoryMarshal.GetReference(values.Component3));
+
+            // Used for the color conversion
+            Vector512<float> chromaOffset = Vector512.Create(-this.HalfValue);
+            Vector512<float> scale = Vector512.Create(1 / (this.MaximumValue * this.MaximumValue));
+            Vector512<float> max = Vector512.Create(this.MaximumValue);
+            Vector512<float> rCrMult = Vector512.Create(YCbCrScalar.RCrMult);
+            Vector512<float> gCbMult = Vector512.Create(-YCbCrScalar.GCbMult);
+            Vector512<float> gCrMult = Vector512.Create(-YCbCrScalar.GCrMult);
+            Vector512<float> bCbMult = Vector512.Create(YCbCrScalar.BCbMult);
+
+            // Walking 8 elements at one step:
+            nuint n = values.Component0.Vector512Count<float>();
+            for (nuint i = 0; i < n; i++)
+            {
+                // y = yVals[i];
+                // cb = cbVals[i] - 128F;
+                // cr = crVals[i] - 128F;
+                // k = kVals[i] / 256F;
+                ref Vector512<float> c0 = ref Unsafe.Add(ref c0Base, i);
+                ref Vector512<float> c1 = ref Unsafe.Add(ref c1Base, i);
+                ref Vector512<float> c2 = ref Unsafe.Add(ref c2Base, i);
+                Vector512<float> y = c0;
+                Vector512<float> cb = c1 + chromaOffset;
+                Vector512<float> cr = c2 + chromaOffset;
+                Vector512<float> scaledK = Unsafe.Add(ref kBase, i) * scale;
+
+                // r = y + (1.402F * cr);
+                // g = y - (0.344136F * cb) - (0.714136F * cr);
+                // b = y + (1.772F * cb);
+                Vector512<float> r = Vector512_.MultiplyAdd(y, cr, rCrMult);
+                Vector512<float> g = Vector512_.MultiplyAdd(Vector512_.MultiplyAdd(y, cb, gCbMult), cr, gCrMult);
+                Vector512<float> b = Vector512_.MultiplyAdd(y, cb, bCbMult);
+
+                r = max - Vector512_.RoundToNearestInteger(r);
+                g = max - Vector512_.RoundToNearestInteger(g);
+                b = max - Vector512_.RoundToNearestInteger(b);
+
+                r *= scaledK;
+                g *= scaledK;
+                b *= scaledK;
+
+                c0 = r;
+                c1 = g;
+                c2 = b;
+            }
+        }
+
+        /// <inheritdoc/>
+        public override void ConvertToRgbInPlaceWithIcc(Configuration configuration, in ComponentValues values, IccProfile profile)
+            => YccKScalar.ConvertToRgbInPlaceWithIcc(configuration, profile, values, this.MaximumValue);
+
+        /// <inheritdoc/>
+        protected override void ConvertToRgbInPlaceScalarRemainder(in ComponentValues values)
+            => YccKScalar.ConvertToRgbInPlace(values, this.MaximumValue, this.HalfValue);
+
+        /// <inheritdoc/>
+        protected override void ConvertFromRgbVectorized(in ComponentValues values, Span<float> rLane, Span<float> gLane, Span<float> bLane)
+        {
+            // rgb -> cmyk
+            CmykVector512.ConvertFromRgbVectorized(in values, this.MaximumValue, rLane, gLane, bLane);
+
+            // cmyk -> ycck
+            ref Vector512<float> destY =
+                ref Unsafe.As<float, Vector512<float>>(ref MemoryMarshal.GetReference(values.Component0));
+            ref Vector512<float> destCb =
+                ref Unsafe.As<float, Vector512<float>>(ref MemoryMarshal.GetReference(values.Component1));
+            ref Vector512<float> destCr =
+                ref Unsafe.As<float, Vector512<float>>(ref MemoryMarshal.GetReference(values.Component2));
+
+            ref Vector512<float> srcR = ref destY;
+            ref Vector512<float> srcG = ref destCb;
+            ref Vector512<float> srcB = ref destCr;
+
+            // Used for the color conversion
+            Vector512<float> maxSampleValue = Vector512.Create(this.MaximumValue);
+
+            Vector512<float> chromaOffset = Vector512.Create(this.HalfValue);
+
+            Vector512<float> f0299 = Vector512.Create(0.299f);
+            Vector512<float> f0587 = Vector512.Create(0.587f);
+            Vector512<float> f0114 = Vector512.Create(0.114f);
+            Vector512<float> fn0168736 = Vector512.Create(-0.168736f);
+            Vector512<float> fn0331264 = Vector512.Create(-0.331264f);
+            Vector512<float> fn0418688 = Vector512.Create(-0.418688f);
+            Vector512<float> fn0081312F = Vector512.Create(-0.081312F);
+            Vector512<float> f05 = Vector512.Create(0.5f);
+
+            nuint n = values.Component0.Vector512Count<float>();
+            for (nuint i = 0; i < n; i++)
+            {
+                Vector512<float> r = maxSampleValue - Unsafe.Add(ref srcR, i);
+                Vector512<float> g = maxSampleValue - Unsafe.Add(ref srcG, i);
+                Vector512<float> b = maxSampleValue - Unsafe.Add(ref srcB, i);
+
+                // y  =   0 + (0.299 * r) + (0.587 * g) + (0.114 * b)
+                // cb = 128 - (0.168736 * r) - (0.331264 * g) + (0.5 * b)
+                // cr = 128 + (0.5 * r) - (0.418688 * g) - (0.081312 * b)
+                Vector512<float> y = Vector512_.MultiplyAdd(Vector512_.MultiplyAdd(f0114 * b, f0587, g), f0299, r);
+                Vector512<float> cb = chromaOffset + Vector512_.MultiplyAdd(Vector512_.MultiplyAdd(f05 * b, fn0331264, g), fn0168736, r);
+                Vector512<float> cr = chromaOffset + Vector512_.MultiplyAdd(Vector512_.MultiplyAdd(fn0081312F * b, fn0418688, g), f05, r);
+
+                Unsafe.Add(ref destY, i) = y;
+                Unsafe.Add(ref destCb, i) = cb;
+                Unsafe.Add(ref destCr, i) = cr;
+            }
+        }
+
+        /// <inheritdoc/>
+        protected override void ConvertFromRgbScalarRemainder(in ComponentValues values, Span<float> rLane, Span<float> gLane, Span<float> bLane)
+            => YccKScalar.ConvertFromRgb(in values, this.HalfValue, this.MaximumValue, rLane, gLane, bLane);
+    }
+}
diff --git a/src/ImageSharp/Formats/Jpeg/Components/ColorConverters/JpegColorConverterArm64.cs b/src/ImageSharp/Formats/Jpeg/Components/ColorConverters/JpegColorConverterArm64.cs
deleted file mode 100644
index d6d4d6ef93..0000000000
--- a/src/ImageSharp/Formats/Jpeg/Components/ColorConverters/JpegColorConverterArm64.cs
+++ /dev/null
@@ -1,35 +0,0 @@
-// Copyright (c) Six Labors.
-// Licensed under the Six Labors Split License.
-using System.Runtime.Intrinsics;
-using System.Runtime.Intrinsics.Arm;
-using System.Runtime.Intrinsics.X86;
-
-namespace SixLabors.ImageSharp.Formats.Jpeg.Components;
-
-internal abstract partial class JpegColorConverterBase
-{
-    /// <summary>
-    /// <see cref="JpegColorConverterBase"/> abstract base for implementations
-    /// based on <see cref="Avx"/> instructions.
-    /// </summary>
-    /// <remarks>
-    /// Converters of this family would expect input buffers lengths to be
-    /// divisible by 8 without a remainder.
-    /// This is guaranteed by real-life data as jpeg stores pixels via 8x8 blocks.
-    /// DO NOT pass test data of invalid size to these converters as they
-    /// potentially won't do a bound check and return a false positive result.
-    /// </remarks>
-    internal abstract class JpegColorConverterArm64 : JpegColorConverterBase
-    {
-        protected JpegColorConverterArm64(JpegColorSpace colorSpace, int precision)
-            : base(colorSpace, precision)
-        {
-        }
-
-        public static bool IsSupported => AdvSimd.Arm64.IsSupported;
-
-        public sealed override bool IsAvailable => IsSupported;
-
-        public sealed override int ElementsPerBatch => Vector128<float>.Count;
-    }
-}
diff --git a/src/ImageSharp/Formats/Jpeg/Components/ColorConverters/JpegColorConverterBase.cs b/src/ImageSharp/Formats/Jpeg/Components/ColorConverters/JpegColorConverterBase.cs
index 041f6b0578..74227c7a6e 100644
--- a/src/ImageSharp/Formats/Jpeg/Components/ColorConverters/JpegColorConverterBase.cs
+++ b/src/ImageSharp/Formats/Jpeg/Components/ColorConverters/JpegColorConverterBase.cs
@@ -2,7 +2,11 @@
 // Licensed under the Six Labors Split License.
 #nullable disable
 
+using System.Numerics;
+using System.Runtime.CompilerServices;
+using System.Runtime.InteropServices;
 using SixLabors.ImageSharp.Memory;
+using SixLabors.ImageSharp.Metadata.Profiles.Icc;
 
 namespace SixLabors.ImageSharp.Formats.Jpeg.Components;
 
@@ -71,25 +75,22 @@ internal abstract partial class JpegColorConverterBase
     /// <param name="precision">The precision in bits.</param>
     /// <exception cref="InvalidImageContentException">Invalid colorspace.</exception>
     public static JpegColorConverterBase GetConverter(JpegColorSpace colorSpace, int precision)
-    {
-        JpegColorConverterBase converter = Array.Find(
-            Converters,
-            c => c.ColorSpace == colorSpace
-            && c.Precision == precision);
-
-        if (converter is null)
-        {
-            throw new InvalidImageContentException($"Could not find any converter for JpegColorSpace {colorSpace}!");
-        }
+        => Array.Find(Converters, c => c.ColorSpace == colorSpace && c.Precision == precision)
+        ?? throw new InvalidImageContentException($"Could not find any converter for JpegColorSpace {colorSpace}!");
 
-        return converter;
-    }
+    /// <summary>
+    /// Converts planar jpeg component values in <paramref name="values"/> to RGB color space in-place.
+    /// </summary>
+    /// <param name="values">The input/output as a stack-only <see cref="ComponentValues"/> struct</param>
+    public abstract void ConvertToRgbInPlace(in ComponentValues values);
 
     /// <summary>
-    /// Converts planar jpeg component values in <paramref name="values"/> to RGB color space inplace.
+    /// Converts planar jpeg component values in <paramref name="values"/> to RGB color space in-place using the given ICC profile.
     /// </summary>
-    /// <param name="values">The input/ouptut as a stack-only <see cref="ComponentValues"/> struct</param>
-    public abstract void ConvertToRgbInplace(in ComponentValues values);
+    /// <param name="configuration">The configuration instance to use for the conversion.</param>
+    /// <param name="values">The input/output as a stack-only <see cref="ComponentValues"/> struct.</param>
+    /// <param name="profile">The ICC profile to use for the conversion.</param>
+    public abstract void ConvertToRgbInPlaceWithIcc(Configuration configuration, in ComponentValues values, IccProfile profile);
 
     /// <summary>
     /// Converts RGB lanes to jpeg component values.
@@ -100,32 +101,148 @@ internal abstract partial class JpegColorConverterBase
     /// <param name="bLane">Blue colors lane.</param>
     public abstract void ConvertFromRgb(in ComponentValues values, Span<float> rLane, Span<float> gLane, Span<float> bLane);
 
+    public static void PackedNormalizeInterleave3(
+        ReadOnlySpan<float> xLane,
+        ReadOnlySpan<float> yLane,
+        ReadOnlySpan<float> zLane,
+        Span<float> packed,
+        float scale)
+    {
+        DebugGuard.IsTrue(packed.Length % 3 == 0, "Packed length must be divisible by 3.");
+        DebugGuard.IsTrue(yLane.Length == xLane.Length, nameof(yLane), "Channels must be of same size!");
+        DebugGuard.IsTrue(zLane.Length == xLane.Length, nameof(zLane), "Channels must be of same size!");
+        DebugGuard.MustBeLessThanOrEqualTo(packed.Length / 3, xLane.Length, nameof(packed));
+
+        // TODO: Investigate SIMD version of this.
+        ref float xLaneRef = ref MemoryMarshal.GetReference(xLane);
+        ref float yLaneRef = ref MemoryMarshal.GetReference(yLane);
+        ref float zLaneRef = ref MemoryMarshal.GetReference(zLane);
+        ref float packedRef = ref MemoryMarshal.GetReference(packed);
+
+        for (nuint i = 0; i < (nuint)xLane.Length; i++)
+        {
+            nuint baseIdx = i * 3;
+            Unsafe.Add(ref packedRef, baseIdx) = Unsafe.Add(ref xLaneRef, i) * scale;
+            Unsafe.Add(ref packedRef, baseIdx + 1) = Unsafe.Add(ref yLaneRef, i) * scale;
+            Unsafe.Add(ref packedRef, baseIdx + 2) = Unsafe.Add(ref zLaneRef, i) * scale;
+        }
+    }
+
+    public static void UnpackDeinterleave3(
+        ReadOnlySpan<Vector3> packed,
+        Span<float> xLane,
+        Span<float> yLane,
+        Span<float> zLane)
+    {
+        DebugGuard.IsTrue(packed.Length == xLane.Length, nameof(packed), "Channels must be of same size!");
+        DebugGuard.IsTrue(yLane.Length == xLane.Length, nameof(yLane), "Channels must be of same size!");
+        DebugGuard.IsTrue(zLane.Length == xLane.Length, nameof(zLane), "Channels must be of same size!");
+
+        // TODO: Investigate SIMD version of this.
+        ref float packedRef = ref MemoryMarshal.GetReference(MemoryMarshal.Cast<Vector3, float>(packed));
+        ref float xLaneRef = ref MemoryMarshal.GetReference(xLane);
+        ref float yLaneRef = ref MemoryMarshal.GetReference(yLane);
+        ref float zLaneRef = ref MemoryMarshal.GetReference(zLane);
+
+        for (nuint i = 0; i < (nuint)packed.Length; i++)
+        {
+            nuint baseIdx = i * 3;
+            Unsafe.Add(ref xLaneRef, i) = Unsafe.Add(ref packedRef, baseIdx);
+            Unsafe.Add(ref yLaneRef, i) = Unsafe.Add(ref packedRef, baseIdx + 1);
+            Unsafe.Add(ref zLaneRef, i) = Unsafe.Add(ref packedRef, baseIdx + 2);
+        }
+    }
+
+    public static void PackedNormalizeInterleave4(
+        ReadOnlySpan<float> xLane,
+        ReadOnlySpan<float> yLane,
+        ReadOnlySpan<float> zLane,
+        ReadOnlySpan<float> wLane,
+        Span<float> packed,
+        float maxValue)
+    {
+        DebugGuard.IsTrue(packed.Length % 4 == 0, "Packed length must be divisible by 4.");
+        DebugGuard.IsTrue(yLane.Length == xLane.Length, nameof(yLane), "Channels must be of same size!");
+        DebugGuard.IsTrue(zLane.Length == xLane.Length, nameof(zLane), "Channels must be of same size!");
+        DebugGuard.IsTrue(wLane.Length == xLane.Length, nameof(wLane), "Channels must be of same size!");
+        DebugGuard.MustBeLessThanOrEqualTo(packed.Length / 4, xLane.Length, nameof(packed));
+
+        float scale = 1F / maxValue;
+
+        // TODO: Investigate SIMD version of this.
+        ref float xLaneRef = ref MemoryMarshal.GetReference(xLane);
+        ref float yLaneRef = ref MemoryMarshal.GetReference(yLane);
+        ref float zLaneRef = ref MemoryMarshal.GetReference(zLane);
+        ref float wLaneRef = ref MemoryMarshal.GetReference(wLane);
+        ref float packedRef = ref MemoryMarshal.GetReference(packed);
+
+        for (nuint i = 0; i < (nuint)xLane.Length; i++)
+        {
+            nuint baseIdx = i * 4;
+            Unsafe.Add(ref packedRef, baseIdx) = Unsafe.Add(ref xLaneRef, i) * scale;
+            Unsafe.Add(ref packedRef, baseIdx + 1) = Unsafe.Add(ref yLaneRef, i) * scale;
+            Unsafe.Add(ref packedRef, baseIdx + 2) = Unsafe.Add(ref zLaneRef, i) * scale;
+            Unsafe.Add(ref packedRef, baseIdx + 3) = Unsafe.Add(ref wLaneRef, i) * scale;
+        }
+    }
+
+    public static void PackedInvertNormalizeInterleave4(
+        ReadOnlySpan<float> xLane,
+        ReadOnlySpan<float> yLane,
+        ReadOnlySpan<float> zLane,
+        ReadOnlySpan<float> wLane,
+        Span<float> packed,
+        float maxValue)
+    {
+        DebugGuard.IsTrue(packed.Length % 4 == 0, "Packed length must be divisible by 4.");
+        DebugGuard.IsTrue(yLane.Length == xLane.Length, nameof(yLane), "Channels must be of same size!");
+        DebugGuard.IsTrue(zLane.Length == xLane.Length, nameof(zLane), "Channels must be of same size!");
+        DebugGuard.IsTrue(wLane.Length == xLane.Length, nameof(wLane), "Channels must be of same size!");
+        DebugGuard.MustBeLessThanOrEqualTo(packed.Length / 4, xLane.Length, nameof(packed));
+
+        float scale = 1F / maxValue;
+
+        // TODO: Investigate SIMD version of this.
+        ref float xLaneRef = ref MemoryMarshal.GetReference(xLane);
+        ref float yLaneRef = ref MemoryMarshal.GetReference(yLane);
+        ref float zLaneRef = ref MemoryMarshal.GetReference(zLane);
+        ref float wLaneRef = ref MemoryMarshal.GetReference(wLane);
+        ref float packedRef = ref MemoryMarshal.GetReference(packed);
+
+        for (nuint i = 0; i < (nuint)xLane.Length; i++)
+        {
+            nuint baseIdx = i * 4;
+            Unsafe.Add(ref packedRef, baseIdx) = (maxValue - Unsafe.Add(ref xLaneRef, i)) * scale;
+            Unsafe.Add(ref packedRef, baseIdx + 1) = (maxValue - Unsafe.Add(ref yLaneRef, i)) * scale;
+            Unsafe.Add(ref packedRef, baseIdx + 2) = (maxValue - Unsafe.Add(ref zLaneRef, i)) * scale;
+            Unsafe.Add(ref packedRef, baseIdx + 3) = (maxValue - Unsafe.Add(ref wLaneRef, i)) * scale;
+        }
+    }
+
     /// <summary>
-    /// Returns the <see cref="JpegColorConverterBase"/>s for all supported colorspaces and precisions.
+    /// Returns the <see cref="JpegColorConverterBase"/>s for all supported color spaces and precisions.
     /// </summary>
     private static JpegColorConverterBase[] CreateConverters()
-    {
-        // 5 color types with 2 supported precisions: 8 bit & 12 bit
-        const int colorConvertersCount = 5 * 2;
-
-        JpegColorConverterBase[] converters = new JpegColorConverterBase[colorConvertersCount];
-
-        // 8-bit converters
-        converters[0] = GetYCbCrConverter(8);
-        converters[1] = GetYccKConverter(8);
-        converters[2] = GetCmykConverter(8);
-        converters[3] = GetGrayScaleConverter(8);
-        converters[4] = GetRgbConverter(8);
-
-        // 12-bit converters
-        converters[5] = GetYCbCrConverter(12);
-        converters[6] = GetYccKConverter(12);
-        converters[7] = GetCmykConverter(12);
-        converters[8] = GetGrayScaleConverter(12);
-        converters[9] = GetRgbConverter(12);
-
-        return converters;
-    }
+        => [
+
+            // 8-bit converters
+            GetYCbCrConverter(8),
+            GetYccKConverter(8),
+            GetCmykConverter(8),
+            GetGrayScaleConverter(8),
+            GetRgbConverter(8),
+            GetTiffCmykConverter(8),
+            GetTiffYccKConverter(8),
+
+            // 12-bit converters
+            GetYCbCrConverter(12),
+            GetYccKConverter(12),
+            GetCmykConverter(12),
+            GetGrayScaleConverter(12),
+            GetRgbConverter(12),
+            GetTiffCmykConverter(12),
+            GetTiffYccKConverter(12),
+        ];
 
     /// <summary>
     /// Returns the <see cref="JpegColorConverterBase"/>s for the YCbCr colorspace.
@@ -133,19 +250,19 @@ internal abstract partial class JpegColorConverterBase
     /// <param name="precision">The precision in bits.</param>
     private static JpegColorConverterBase GetYCbCrConverter(int precision)
     {
-        if (JpegColorConverterAvx.IsSupported)
+        if (JpegColorConverterVector512.IsSupported)
         {
-            return new YCbCrAvx(precision);
+            return new YCbCrVector512(precision);
         }
 
-        if (JpegColorConverterArm.IsSupported)
+        if (JpegColorConverterVector256.IsSupported)
         {
-            return new YCbCrArm(precision);
+            return new YCbCrVector256(precision);
         }
 
-        if (JpegColorConverterVector.IsSupported)
+        if (JpegColorConverterVector128.IsSupported)
         {
-            return new YCbCrVector(precision);
+            return new YCbCrVector128(precision);
         }
 
         return new YCbCrScalar(precision);
@@ -157,19 +274,19 @@ internal abstract partial class JpegColorConverterBase
     /// <param name="precision">The precision in bits.</param>
     private static JpegColorConverterBase GetYccKConverter(int precision)
     {
-        if (JpegColorConverterAvx.IsSupported)
+        if (JpegColorConverterVector512.IsSupported)
         {
-            return new YccKAvx(precision);
+            return new YccKVector512(precision);
         }
 
-        if (JpegColorConverterArm64.IsSupported)
+        if (JpegColorConverterVector256.IsSupported)
         {
-            return new YccKArm64(precision);
+            return new YccKVector256(precision);
         }
 
-        if (JpegColorConverterVector.IsSupported)
+        if (JpegColorConverterVector128.IsSupported)
         {
-            return new YccKVector(precision);
+            return new YccKVector128(precision);
         }
 
         return new YccKScalar(precision);
@@ -181,19 +298,19 @@ internal abstract partial class JpegColorConverterBase
     /// <param name="precision">The precision in bits.</param>
     private static JpegColorConverterBase GetCmykConverter(int precision)
     {
-        if (JpegColorConverterAvx.IsSupported)
+        if (JpegColorConverterVector512.IsSupported)
         {
-            return new CmykAvx(precision);
+            return new CmykVector512(precision);
         }
 
-        if (JpegColorConverterArm64.IsSupported)
+        if (JpegColorConverterVector256.IsSupported)
         {
-            return new CmykArm64(precision);
+            return new CmykVector256(precision);
         }
 
-        if (JpegColorConverterVector.IsSupported)
+        if (JpegColorConverterVector128.IsSupported)
         {
-            return new CmykVector(precision);
+            return new CmykVector128(precision);
         }
 
         return new CmykScalar(precision);
@@ -205,22 +322,22 @@ internal abstract partial class JpegColorConverterBase
     /// <param name="precision">The precision in bits.</param>
     private static JpegColorConverterBase GetGrayScaleConverter(int precision)
     {
-        if (JpegColorConverterAvx.IsSupported)
+        if (JpegColorConverterVector512.IsSupported)
         {
-            return new GrayscaleAvx(precision);
+            return new GrayScaleVector512(precision);
         }
 
-        if (JpegColorConverterArm.IsSupported)
+        if (JpegColorConverterVector256.IsSupported)
         {
-            return new GrayscaleArm(precision);
+            return new GrayScaleVector256(precision);
         }
 
-        if (JpegColorConverterVector.IsSupported)
+        if (JpegColorConverterVector128.IsSupported)
         {
-            return new GrayScaleVector(precision);
+            return new GrayScaleVector128(precision);
         }
 
-        return new GrayscaleScalar(precision);
+        return new GrayScaleScalar(precision);
     }
 
     /// <summary>
@@ -229,24 +346,64 @@ internal abstract partial class JpegColorConverterBase
     /// <param name="precision">The precision in bits.</param>
     private static JpegColorConverterBase GetRgbConverter(int precision)
     {
-        if (JpegColorConverterAvx.IsSupported)
+        if (JpegColorConverterVector512.IsSupported)
         {
-            return new RgbAvx(precision);
+            return new RgbVector512(precision);
         }
 
-        if (JpegColorConverterArm.IsSupported)
+        if (JpegColorConverterVector256.IsSupported)
         {
-            return new RgbArm(precision);
+            return new RgbVector256(precision);
         }
 
-        if (JpegColorConverterVector.IsSupported)
+        if (JpegColorConverterVector128.IsSupported)
         {
-            return new RgbVector(precision);
+            return new RgbVector128(precision);
         }
 
         return new RgbScalar(precision);
     }
 
+    private static JpegColorConverterBase GetTiffCmykConverter(int precision)
+    {
+        if (JpegColorConverterVector512.IsSupported)
+        {
+            return new TiffCmykVector512(precision);
+        }
+
+        if (JpegColorConverterVector256.IsSupported)
+        {
+            return new TiffCmykVector256(precision);
+        }
+
+        if (JpegColorConverterVector128.IsSupported)
+        {
+            return new TiffCmykVector128(precision);
+        }
+
+        return new TiffCmykScalar(precision);
+    }
+
+    private static JpegColorConverterBase GetTiffYccKConverter(int precision)
+    {
+        if (JpegColorConverterVector512.IsSupported)
+        {
+            return new TiffYccKVector512(precision);
+        }
+
+        if (JpegColorConverterVector256.IsSupported)
+        {
+            return new TiffYccKVector256(precision);
+        }
+
+        if (JpegColorConverterVector128.IsSupported)
+        {
+            return new TiffYccKVector128(precision);
+        }
+
+        return new TiffYccKScalar(precision);
+    }
+
     /// <summary>
     /// A stack-only struct to reference the input buffers using <see cref="ReadOnlySpan{T}"/>-s.
     /// </summary>
@@ -295,7 +452,7 @@ internal abstract partial class JpegColorConverterBase
             // In case of grayscale, Component1 and Component2 point to Component0 memory area
             this.Component1 = this.ComponentCount > 1 ? componentBuffers[1].DangerousGetRowSpan(row) : this.Component0;
             this.Component2 = this.ComponentCount > 2 ? componentBuffers[2].DangerousGetRowSpan(row) : this.Component0;
-            this.Component3 = this.ComponentCount > 3 ? componentBuffers[3].DangerousGetRowSpan(row) : Span<float>.Empty;
+            this.Component3 = this.ComponentCount > 3 ? componentBuffers[3].DangerousGetRowSpan(row) : [];
         }
 
         /// <summary>
@@ -314,7 +471,7 @@ internal abstract partial class JpegColorConverterBase
             // In case of grayscale, Component1 and Component2 point to Component0 memory area
             this.Component1 = this.ComponentCount > 1 ? processors[1].GetColorBufferRowSpan(row) : this.Component0;
             this.Component2 = this.ComponentCount > 2 ? processors[2].GetColorBufferRowSpan(row) : this.Component0;
-            this.Component3 = this.ComponentCount > 3 ? processors[3].GetColorBufferRowSpan(row) : Span<float>.Empty;
+            this.Component3 = this.ComponentCount > 3 ? processors[3].GetColorBufferRowSpan(row) : [];
         }
 
         /// <summary>
@@ -333,7 +490,7 @@ internal abstract partial class JpegColorConverterBase
             // In case of grayscale, Component1 and Component2 point to Component0 memory area
             this.Component1 = this.ComponentCount > 1 ? processors[1].GetColorBufferRowSpan(row) : this.Component0;
             this.Component2 = this.ComponentCount > 2 ? processors[2].GetColorBufferRowSpan(row) : this.Component0;
-            this.Component3 = this.ComponentCount > 3 ? processors[3].GetColorBufferRowSpan(row) : Span<float>.Empty;
+            this.Component3 = this.ComponentCount > 3 ? processors[3].GetColorBufferRowSpan(row) : [];
         }
 
         internal ComponentValues(
@@ -353,9 +510,9 @@ internal abstract partial class JpegColorConverterBase
         public ComponentValues Slice(int start, int length)
         {
             Span<float> c0 = this.Component0.Slice(start, length);
-            Span<float> c1 = this.Component1.Length > 0 ? this.Component1.Slice(start, length) : Span<float>.Empty;
-            Span<float> c2 = this.Component2.Length > 0 ? this.Component2.Slice(start, length) : Span<float>.Empty;
-            Span<float> c3 = this.Component3.Length > 0 ? this.Component3.Slice(start, length) : Span<float>.Empty;
+            Span<float> c1 = this.Component1.Length > 0 ? this.Component1.Slice(start, length) : [];
+            Span<float> c2 = this.Component2.Length > 0 ? this.Component2.Slice(start, length) : [];
+            Span<float> c3 = this.Component3.Length > 0 ? this.Component3.Slice(start, length) : [];
 
             return new ComponentValues(this.ComponentCount, c0, c1, c2, c3);
         }
diff --git a/src/ImageSharp/Formats/Jpeg/Components/ColorConverters/JpegColorConverterVector.cs b/src/ImageSharp/Formats/Jpeg/Components/ColorConverters/JpegColorConverterVector.cs
index 5f9688a795..f3c3eb8db5 100644
--- a/src/ImageSharp/Formats/Jpeg/Components/ColorConverters/JpegColorConverterVector.cs
+++ b/src/ImageSharp/Formats/Jpeg/Components/ColorConverters/JpegColorConverterVector.cs
@@ -36,7 +36,7 @@ internal abstract partial class JpegColorConverterBase
         public override int ElementsPerBatch => Vector<float>.Count;
 
         /// <inheritdoc/>
-        public sealed override void ConvertToRgbInplace(in ComponentValues values)
+        public sealed override void ConvertToRgbInPlace(in ComponentValues values)
         {
             DebugGuard.IsTrue(this.IsAvailable, $"{this.GetType().Name} converter is not supported on current hardware.");
 
@@ -46,7 +46,7 @@ internal abstract partial class JpegColorConverterBase
             int simdCount = length - remainder;
             if (simdCount > 0)
             {
-                this.ConvertToRgbInplaceVectorized(values.Slice(0, simdCount));
+                this.ConvertToRgbInPlaceVectorized(values.Slice(0, simdCount));
             }
 
             // Jpeg images width is always divisible by 8 without a remainder
@@ -56,12 +56,12 @@ internal abstract partial class JpegColorConverterBase
             // remainder pixels
             if (remainder > 0)
             {
-                this.ConvertToRgbInplaceScalarRemainder(values.Slice(simdCount, remainder));
+                this.ConvertToRgbInPlaceScalarRemainder(values.Slice(simdCount, remainder));
             }
         }
 
         /// <inheritdoc/>
-        public sealed override void ConvertFromRgb(in ComponentValues values, Span<float> r, Span<float> g, Span<float> b)
+        public sealed override void ConvertFromRgb(in ComponentValues values, Span<float> rLane, Span<float> gLane, Span<float> bLane)
         {
             DebugGuard.IsTrue(this.IsAvailable, $"{this.GetType().Name} converter is not supported on current hardware.");
 
@@ -73,9 +73,9 @@ internal abstract partial class JpegColorConverterBase
             {
                 this.ConvertFromRgbVectorized(
                     values.Slice(0, simdCount),
-                    r.Slice(0, simdCount),
-                    g.Slice(0, simdCount),
-                    b.Slice(0, simdCount));
+                    rLane[..simdCount],
+                    gLane[..simdCount],
+                    bLane[..simdCount]);
             }
 
             // Jpeg images width is always divisible by 8 without a remainder
@@ -87,25 +87,25 @@ internal abstract partial class JpegColorConverterBase
             {
                 this.ConvertFromRgbScalarRemainder(
                     values.Slice(simdCount, remainder),
-                    r.Slice(simdCount, remainder),
-                    g.Slice(simdCount, remainder),
-                    b.Slice(simdCount, remainder));
+                    rLane.Slice(simdCount, remainder),
+                    gLane.Slice(simdCount, remainder),
+                    bLane.Slice(simdCount, remainder));
             }
         }
 
         /// <summary>
         /// Converts planar jpeg component values in <paramref name="values"/>
-        /// to RGB color space inplace using <see cref="Vector"/> API.
+        /// to RGB color space in place using <see cref="Vector"/> API.
         /// </summary>
-        /// <param name="values">The input/ouptut as a stack-only <see cref="ComponentValues"/> struct</param>
-        protected abstract void ConvertToRgbInplaceVectorized(in ComponentValues values);
+        /// <param name="values">The input/output as a stack-only <see cref="ComponentValues"/> struct</param>
+        protected abstract void ConvertToRgbInPlaceVectorized(in ComponentValues values);
 
         /// <summary>
         /// Converts remainder of the planar jpeg component values after
-        /// conversion in <see cref="ConvertToRgbInplaceVectorized(in ComponentValues)"/>.
+        /// conversion in <see cref="ConvertToRgbInPlaceVectorized(in ComponentValues)"/>.
         /// </summary>
-        /// <param name="values">The input/ouptut as a stack-only <see cref="ComponentValues"/> struct</param>
-        protected abstract void ConvertToRgbInplaceScalarRemainder(in ComponentValues values);
+        /// <param name="values">The input/output as a stack-only <see cref="ComponentValues"/> struct</param>
+        protected abstract void ConvertToRgbInPlaceScalarRemainder(in ComponentValues values);
 
         /// <summary>
         /// Converts RGB lanes to jpeg component values using <see cref="Vector"/> API.
diff --git a/src/ImageSharp/Formats/Jpeg/Components/ColorConverters/JpegColorConverterArm.cs b/src/ImageSharp/Formats/Jpeg/Components/ColorConverters/JpegColorConverterVector128.cs
similarity index 71%
rename from src/ImageSharp/Formats/Jpeg/Components/ColorConverters/JpegColorConverterArm.cs
rename to src/ImageSharp/Formats/Jpeg/Components/ColorConverters/JpegColorConverterVector128.cs
index bfbbf200c8..5cbb376c78 100644
--- a/src/ImageSharp/Formats/Jpeg/Components/ColorConverters/JpegColorConverterArm.cs
+++ b/src/ImageSharp/Formats/Jpeg/Components/ColorConverters/JpegColorConverterVector128.cs
@@ -1,8 +1,7 @@
-// Copyright (c) Six Labors.
+// Copyright (c) Six Labors.
 // Licensed under the Six Labors Split License.
+
 using System.Runtime.Intrinsics;
-using System.Runtime.Intrinsics.Arm;
-using System.Runtime.Intrinsics.X86;
 
 namespace SixLabors.ImageSharp.Formats.Jpeg.Components;
 
@@ -10,7 +9,7 @@ internal abstract partial class JpegColorConverterBase
 {
     /// <summary>
     /// <see cref="JpegColorConverterBase"/> abstract base for implementations
-    /// based on <see cref="Avx"/> instructions.
+    /// based on <see cref="Vector128{T}"/> instructions.
     /// </summary>
     /// <remarks>
     /// Converters of this family would expect input buffers lengths to be
@@ -19,14 +18,14 @@ internal abstract partial class JpegColorConverterBase
     /// DO NOT pass test data of invalid size to these converters as they
     /// potentially won't do a bound check and return a false positive result.
     /// </remarks>
-    internal abstract class JpegColorConverterArm : JpegColorConverterBase
+    internal abstract class JpegColorConverterVector128 : JpegColorConverterBase
     {
-        protected JpegColorConverterArm(JpegColorSpace colorSpace, int precision)
+        protected JpegColorConverterVector128(JpegColorSpace colorSpace, int precision)
             : base(colorSpace, precision)
         {
         }
 
-        public static bool IsSupported => AdvSimd.IsSupported;
+        public static bool IsSupported => Vector128.IsHardwareAccelerated;
 
         public sealed override bool IsAvailable => IsSupported;
 
diff --git a/src/ImageSharp/Formats/Jpeg/Components/ColorConverters/JpegColorConverterAvx.cs b/src/ImageSharp/Formats/Jpeg/Components/ColorConverters/JpegColorConverterVector256.cs
similarity index 73%
rename from src/ImageSharp/Formats/Jpeg/Components/ColorConverters/JpegColorConverterAvx.cs
rename to src/ImageSharp/Formats/Jpeg/Components/ColorConverters/JpegColorConverterVector256.cs
index a3e41bdc6b..61c37d846a 100644
--- a/src/ImageSharp/Formats/Jpeg/Components/ColorConverters/JpegColorConverterAvx.cs
+++ b/src/ImageSharp/Formats/Jpeg/Components/ColorConverters/JpegColorConverterVector256.cs
@@ -1,7 +1,7 @@
-// Copyright (c) Six Labors.
+// Copyright (c) Six Labors.
 // Licensed under the Six Labors Split License.
+
 using System.Runtime.Intrinsics;
-using System.Runtime.Intrinsics.X86;
 
 namespace SixLabors.ImageSharp.Formats.Jpeg.Components;
 
@@ -9,7 +9,7 @@ internal abstract partial class JpegColorConverterBase
 {
     /// <summary>
     /// <see cref="JpegColorConverterBase"/> abstract base for implementations
-    /// based on <see cref="Avx"/> instructions.
+    /// based on <see cref="Vector256{T}"/> instructions.
     /// </summary>
     /// <remarks>
     /// Converters of this family would expect input buffers lengths to be
@@ -18,14 +18,14 @@ internal abstract partial class JpegColorConverterBase
     /// DO NOT pass test data of invalid size to these converters as they
     /// potentially won't do a bound check and return a false positive result.
     /// </remarks>
-    internal abstract class JpegColorConverterAvx : JpegColorConverterBase
+    internal abstract class JpegColorConverterVector256 : JpegColorConverterBase
     {
-        protected JpegColorConverterAvx(JpegColorSpace colorSpace, int precision)
+        protected JpegColorConverterVector256(JpegColorSpace colorSpace, int precision)
             : base(colorSpace, precision)
         {
         }
 
-        public static bool IsSupported => Avx.IsSupported;
+        public static bool IsSupported => Vector256.IsHardwareAccelerated;
 
         public sealed override bool IsAvailable => IsSupported;
 
diff --git a/src/ImageSharp/Formats/Jpeg/Components/ColorConverters/JpegColorConverterVector512.cs b/src/ImageSharp/Formats/Jpeg/Components/ColorConverters/JpegColorConverterVector512.cs
new file mode 100644
index 0000000000..0c7d032d4c
--- /dev/null
+++ b/src/ImageSharp/Formats/Jpeg/Components/ColorConverters/JpegColorConverterVector512.cs
@@ -0,0 +1,111 @@
+// Copyright (c) Six Labors.
+// Licensed under the Six Labors Split License.
+
+using System.Numerics;
+using System.Runtime.Intrinsics;
+
+namespace SixLabors.ImageSharp.Formats.Jpeg.Components;
+
+internal abstract partial class JpegColorConverterBase
+{
+    /// <summary>
+    /// <see cref="JpegColorConverterBase"/> abstract base for implementations
+    /// based on <see cref="Vector512{T}"/> instructions.
+    /// </summary>
+    internal abstract class JpegColorConverterVector512 : JpegColorConverterBase
+    {
+        protected JpegColorConverterVector512(JpegColorSpace colorSpace, int precision)
+            : base(colorSpace, precision)
+        {
+        }
+
+        public static bool IsSupported => Vector512.IsHardwareAccelerated;
+
+        /// <inheritdoc/>
+        public override bool IsAvailable => IsSupported;
+
+        /// <inheritdoc/>
+        public override int ElementsPerBatch => Vector512<float>.Count;
+
+        /// <inheritdoc/>
+        public sealed override void ConvertFromRgb(in ComponentValues values, Span<float> rLane, Span<float> gLane, Span<float> bLane)
+        {
+            DebugGuard.IsTrue(this.IsAvailable, $"{this.GetType().Name} converter is not supported on current hardware.");
+
+            int length = values.Component0.Length;
+            int remainder = (int)((uint)length % (uint)Vector512<float>.Count);
+
+            int simdCount = length - remainder;
+            if (simdCount > 0)
+            {
+                this.ConvertFromRgbVectorized(
+                    values.Slice(0, simdCount),
+                    rLane[..simdCount],
+                    gLane[..simdCount],
+                    bLane[..simdCount]);
+            }
+
+            if (remainder > 0)
+            {
+                this.ConvertFromRgbScalarRemainder(
+                    values.Slice(simdCount, remainder),
+                    rLane.Slice(simdCount, remainder),
+                    gLane.Slice(simdCount, remainder),
+                    bLane.Slice(simdCount, remainder));
+            }
+        }
+
+        /// <inheritdoc/>
+        public sealed override void ConvertToRgbInPlace(in ComponentValues values)
+        {
+            DebugGuard.IsTrue(this.IsAvailable, $"{this.GetType().Name} converter is not supported on current hardware.");
+
+            int length = values.Component0.Length;
+            int remainder = (int)((uint)length % (uint)Vector512<float>.Count);
+
+            int simdCount = length - remainder;
+            if (simdCount > 0)
+            {
+                this.ConvertToRgbInPlaceVectorized(values.Slice(0, simdCount));
+            }
+
+            if (remainder > 0)
+            {
+                this.ConvertToRgbInPlaceScalarRemainder(values.Slice(simdCount, remainder));
+            }
+        }
+
+        /// <summary>
+        /// Converts planar jpeg component values in <paramref name="values"/>
+        /// to RGB color space in place using <see cref="Vector"/> API.
+        /// </summary>
+        /// <param name="values">The input/output as a stack-only <see cref="ComponentValues"/> struct</param>
+        protected abstract void ConvertToRgbInPlaceVectorized(in ComponentValues values);
+
+        /// <summary>
+        /// Converts remainder of the planar jpeg component values after
+        /// conversion in <see cref="ConvertToRgbInPlaceVectorized(in ComponentValues)"/>.
+        /// </summary>
+        /// <param name="values">The input/output as a stack-only <see cref="ComponentValues"/> struct</param>
+        protected abstract void ConvertToRgbInPlaceScalarRemainder(in ComponentValues values);
+
+        /// <summary>
+        /// Converts RGB lanes to jpeg component values using <see cref="Vector"/> API.
+        /// </summary>
+        /// <param name="values">Jpeg component values.</param>
+        /// <param name="rLane">Red colors lane.</param>
+        /// <param name="gLane">Green colors lane.</param>
+        /// <param name="bLane">Blue colors lane.</param>
+        protected abstract void ConvertFromRgbVectorized(in ComponentValues values, Span<float> rLane, Span<float> gLane, Span<float> bLane);
+
+        /// <summary>
+        /// Converts remainder of RGB lanes to jpeg component values after
+        ///  conversion in <see cref="ConvertFromRgbVectorized(in ComponentValues, Span{float}, Span{float}, Span{float})"/>.
+        /// </summary>
+        /// <param name="values">Jpeg component values.</param>
+        /// <param name="rLane">Red colors lane.</param>
+        /// <param name="gLane">Green colors lane.</param>
+        /// <param name="bLane">Blue colors lane.</param>
+        protected abstract void ConvertFromRgbScalarRemainder(in ComponentValues values, Span<float> rLane, Span<float> gLane, Span<float> bLane);
+    }
+}
diff --git a/src/ImageSharp/Formats/Jpeg/Components/Decoder/ArithmeticScanDecoder.cs b/src/ImageSharp/Formats/Jpeg/Components/Decoder/ArithmeticScanDecoder.cs
index 02a346ff07..6e83f5b2b4 100644
--- a/src/ImageSharp/Formats/Jpeg/Components/Decoder/ArithmeticScanDecoder.cs
+++ b/src/ImageSharp/Formats/Jpeg/Components/Decoder/ArithmeticScanDecoder.cs
@@ -5,6 +5,7 @@
 using System.Runtime.CompilerServices;
 using System.Runtime.InteropServices;
 using SixLabors.ImageSharp.IO;
+using SixLabors.ImageSharp.Metadata.Profiles.Icc;
 
 namespace SixLabors.ImageSharp.Formats.Jpeg.Components.Decoder;
 
@@ -54,12 +55,12 @@ internal class ArithmeticScanDecoder : IJpegScanDecoder
     private ArithmeticDecodingTable[] acDecodingTables;
 
     // Don't make this a ReadOnlySpan<byte>, as the values need to get updated.
-    private readonly byte[] fixedBin = { 113, 0, 0, 0 };
+    private readonly byte[] fixedBin = [113, 0, 0, 0];
 
     private readonly CancellationToken cancellationToken;
 
     private static readonly int[] ArithmeticTable =
-    {
+    [
         Pack(0x5a1d,   1,   1, 1),
         Pack(0x2586,  14,   2, 0),
         Pack(0x1114,  16,   3, 0),
@@ -177,9 +178,9 @@ internal class ArithmeticScanDecoder : IJpegScanDecoder
         // This last entry is used for fixed probability estimate of 0.5
         // as suggested in Section 10.3 Table 5 of ITU-T Rec. T.851.
         Pack(0x5a1d, 113, 113, 0)
-    };
+    ];
 
-    private readonly List<ArithmeticStatistics> statistics = new();
+    private readonly List<ArithmeticStatistics> statistics = [];
 
     /// <summary>
     /// Initializes a new instance of the <see cref="ArithmeticScanDecoder"/> class.
@@ -234,11 +235,8 @@ internal class ArithmeticScanDecoder : IJpegScanDecoder
 
     private ref byte GetFixedBinReference() => ref MemoryMarshal.GetArrayDataReference(this.fixedBin);
 
-    /// <summary>
-    /// Decodes the entropy coded data.
-    /// </summary>
-    /// <param name="scanComponentCount">Component count in the current scan.</param>
-    public void ParseEntropyCodedData(int scanComponentCount)
+    /// <inheritdoc/>
+    public void ParseEntropyCodedData(int scanComponentCount, IccProfile iccProfile)
     {
         this.cancellationToken.ThrowIfCancellationRequested();
 
@@ -254,7 +252,7 @@ internal class ArithmeticScanDecoder : IJpegScanDecoder
         }
         else
         {
-            this.ParseBaselineData();
+            this.ParseBaselineData(iccProfile);
         }
 
         if (this.scanBuffer.HasBadMarker())
@@ -310,7 +308,7 @@ internal class ArithmeticScanDecoder : IJpegScanDecoder
         return statistic;
     }
 
-    private void ParseBaselineData()
+    private void ParseBaselineData(IccProfile iccProfile)
     {
         for (int i = 0; i < this.components.Length; i++)
         {
@@ -326,13 +324,13 @@ internal class ArithmeticScanDecoder : IJpegScanDecoder
         if (this.scanComponentCount != 1)
         {
             this.spectralConverter.PrepareForDecoding();
-            this.ParseBaselineDataInterleaved();
+            this.ParseBaselineDataInterleaved(iccProfile);
             this.spectralConverter.CommitConversion();
         }
         else if (this.frame.ComponentCount == 1)
         {
             this.spectralConverter.PrepareForDecoding();
-            this.ParseBaselineDataSingleComponent();
+            this.ParseBaselineDataSingleComponent(iccProfile);
             this.spectralConverter.CommitConversion();
         }
         else
@@ -345,8 +343,9 @@ internal class ArithmeticScanDecoder : IJpegScanDecoder
     {
         this.CheckProgressiveData();
 
-        foreach (ArithmeticDecodingComponent component in this.components)
+        for (int i = 0; i < this.components.Length; i++)
         {
+            ArithmeticDecodingComponent component = (ArithmeticDecodingComponent)this.components[i];
             if (this.SpectralStart == 0 && this.SuccessiveHigh == 0)
             {
                 component.DcPredictor = 0;
@@ -422,7 +421,7 @@ internal class ArithmeticScanDecoder : IJpegScanDecoder
         }
     }
 
-    private void ParseBaselineDataInterleaved()
+    private void ParseBaselineDataInterleaved(IccProfile iccProfile)
     {
         int mcu = 0;
         int mcusPerColumn = this.frame.McusPerColumn;
@@ -463,7 +462,7 @@ internal class ArithmeticScanDecoder : IJpegScanDecoder
                             {
                                 // It is very likely that some spectral data was decoded before we've encountered 'end of scan'
                                 // so we need to decode what's left and return (or maybe throw?)
-                                this.spectralConverter.ConvertStrideBaseline();
+                                this.spectralConverter.ConvertStrideBaseline(iccProfile);
                                 return;
                             }
 
@@ -485,11 +484,11 @@ internal class ArithmeticScanDecoder : IJpegScanDecoder
             }
 
             // Convert from spectral to actual pixels via given converter.
-            this.spectralConverter.ConvertStrideBaseline();
+            this.spectralConverter.ConvertStrideBaseline(iccProfile);
         }
     }
 
-    private void ParseBaselineDataSingleComponent()
+    private void ParseBaselineDataSingleComponent(IccProfile iccProfile)
     {
         ArithmeticDecodingComponent component = this.frame.Components[0] as ArithmeticDecodingComponent;
         int mcuLines = this.frame.McusPerColumn;
@@ -516,7 +515,7 @@ internal class ArithmeticScanDecoder : IJpegScanDecoder
                     {
                         // It is very likely that some spectral data was decoded before we've encountered 'end of scan'
                         // so we need to decode what's left and return (or maybe throw?)
-                        this.spectralConverter.ConvertStrideBaseline();
+                        this.spectralConverter.ConvertStrideBaseline(iccProfile);
                         return;
                     }
 
@@ -531,7 +530,7 @@ internal class ArithmeticScanDecoder : IJpegScanDecoder
             }
 
             // Convert from spectral to actual pixels via given converter.
-            this.spectralConverter.ConvertStrideBaseline();
+            this.spectralConverter.ConvertStrideBaseline(iccProfile);
         }
     }
 
@@ -1108,8 +1107,9 @@ internal class ArithmeticScanDecoder : IJpegScanDecoder
 
             this.todo = this.restartInterval;
 
-            foreach (ArithmeticDecodingComponent component in this.components)
+            for (int i = 0; i < this.components.Length; i++)
             {
+                ArithmeticDecodingComponent component = (ArithmeticDecodingComponent)this.components[i];
                 component.DcPredictor = 0;
                 component.DcContext = 0;
                 component.DcStatistics?.Reset();
diff --git a/src/ImageSharp/Formats/Jpeg/Components/Decoder/HuffmanScanDecoder.cs b/src/ImageSharp/Formats/Jpeg/Components/Decoder/HuffmanScanDecoder.cs
index 56e0f1e985..9ee43a2c83 100644
--- a/src/ImageSharp/Formats/Jpeg/Components/Decoder/HuffmanScanDecoder.cs
+++ b/src/ImageSharp/Formats/Jpeg/Components/Decoder/HuffmanScanDecoder.cs
@@ -5,6 +5,7 @@
 using System.Runtime.CompilerServices;
 using System.Runtime.InteropServices;
 using SixLabors.ImageSharp.IO;
+using SixLabors.ImageSharp.Metadata.Profiles.Icc;
 
 namespace SixLabors.ImageSharp.Formats.Jpeg.Components.Decoder;
 
@@ -109,7 +110,7 @@ internal class HuffmanScanDecoder : IJpegScanDecoder
     public int SuccessiveLow { get; set; }
 
     /// <inheritdoc/>
-    public void ParseEntropyCodedData(int scanComponentCount)
+    public void ParseEntropyCodedData(int scanComponentCount, IccProfile iccProfile)
     {
         this.cancellationToken.ThrowIfCancellationRequested();
 
@@ -123,7 +124,7 @@ internal class HuffmanScanDecoder : IJpegScanDecoder
 
         if (!this.frame.Progressive)
         {
-            this.ParseBaselineData();
+            this.ParseBaselineData(iccProfile);
         }
         else
         {
@@ -145,18 +146,18 @@ internal class HuffmanScanDecoder : IJpegScanDecoder
         this.spectralConverter.InjectFrameData(frame, jpegData);
     }
 
-    private void ParseBaselineData()
+    private void ParseBaselineData(IccProfile iccProfile)
     {
         if (this.scanComponentCount != 1)
         {
             this.spectralConverter.PrepareForDecoding();
-            this.ParseBaselineDataInterleaved();
+            this.ParseBaselineDataInterleaved(iccProfile);
             this.spectralConverter.CommitConversion();
         }
         else if (this.frame.ComponentCount == 1)
         {
             this.spectralConverter.PrepareForDecoding();
-            this.ParseBaselineDataSingleComponent();
+            this.ParseBaselineDataSingleComponent(iccProfile);
             this.spectralConverter.CommitConversion();
         }
         else
@@ -165,7 +166,7 @@ internal class HuffmanScanDecoder : IJpegScanDecoder
         }
     }
 
-    private void ParseBaselineDataInterleaved()
+    private void ParseBaselineDataInterleaved(IccProfile iccProfile)
     {
         int mcu = 0;
         int mcusPerColumn = this.frame.McusPerColumn;
@@ -184,7 +185,7 @@ internal class HuffmanScanDecoder : IJpegScanDecoder
                 for (int k = 0; k < this.scanComponentCount; k++)
                 {
                     int order = this.frame.ComponentOrder[k];
-                    var component = this.components[order] as JpegComponent;
+                    JpegComponent component = this.components[order] as JpegComponent;
 
                     ref HuffmanTable dcHuffmanTable = ref this.dcHuffmanTables[component.DcTableId];
                     ref HuffmanTable acHuffmanTable = ref this.acHuffmanTables[component.AcTableId];
@@ -205,7 +206,7 @@ internal class HuffmanScanDecoder : IJpegScanDecoder
                             {
                                 // It is very likely that some spectral data was decoded before we've encountered 'end of scan'
                                 // so we need to decode what's left and return (or maybe throw?)
-                                this.spectralConverter.ConvertStrideBaseline();
+                                this.spectralConverter.ConvertStrideBaseline(iccProfile);
                                 return;
                             }
 
@@ -227,13 +228,13 @@ internal class HuffmanScanDecoder : IJpegScanDecoder
             }
 
             // Convert from spectral to actual pixels via given converter
-            this.spectralConverter.ConvertStrideBaseline();
+            this.spectralConverter.ConvertStrideBaseline(iccProfile);
         }
     }
 
     private void ParseBaselineDataNonInterleaved()
     {
-        var component = this.components[this.frame.ComponentOrder[0]] as JpegComponent;
+        JpegComponent component = this.components[this.frame.ComponentOrder[0]] as JpegComponent;
         ref JpegBitReader buffer = ref this.scanBuffer;
 
         int w = component.WidthInBlocks;
@@ -266,7 +267,7 @@ internal class HuffmanScanDecoder : IJpegScanDecoder
         }
     }
 
-    private void ParseBaselineDataSingleComponent()
+    private void ParseBaselineDataSingleComponent(IccProfile iccProfile)
     {
         JpegComponent component = this.frame.Components[0];
         int mcuLines = this.frame.McusPerColumn;
@@ -293,7 +294,7 @@ internal class HuffmanScanDecoder : IJpegScanDecoder
                     {
                         // It is very likely that some spectral data was decoded before we've encountered 'end of scan'
                         // so we need to decode what's left and return (or maybe throw?)
-                        this.spectralConverter.ConvertStrideBaseline();
+                        this.spectralConverter.ConvertStrideBaseline(iccProfile);
                         return;
                     }
 
@@ -308,7 +309,7 @@ internal class HuffmanScanDecoder : IJpegScanDecoder
             }
 
             // Convert from spectral to actual pixels via given converter
-            this.spectralConverter.ConvertStrideBaseline();
+            this.spectralConverter.ConvertStrideBaseline(iccProfile);
         }
     }
 
@@ -394,7 +395,7 @@ internal class HuffmanScanDecoder : IJpegScanDecoder
                 for (int k = 0; k < this.scanComponentCount; k++)
                 {
                     int order = this.frame.ComponentOrder[k];
-                    var component = this.components[order] as JpegComponent;
+                    JpegComponent component = this.components[order] as JpegComponent;
                     ref HuffmanTable dcHuffmanTable = ref this.dcHuffmanTables[component.DcTableId];
 
                     int h = component.HorizontalSamplingFactor;
@@ -435,7 +436,7 @@ internal class HuffmanScanDecoder : IJpegScanDecoder
 
     private void ParseProgressiveDataNonInterleaved()
     {
-        var component = this.components[this.frame.ComponentOrder[0]] as JpegComponent;
+        JpegComponent component = this.components[this.frame.ComponentOrder[0]] as JpegComponent;
         ref JpegBitReader buffer = ref this.scanBuffer;
 
         int w = component.WidthInBlocks;
@@ -772,7 +773,7 @@ internal class HuffmanScanDecoder : IJpegScanDecoder
     }
 
     /// <summary>
-    /// Build the huffman table using code lengths and code values.
+    /// Build the Huffman table using code lengths and code values.
     /// </summary>
     /// <param name="type">Table type.</param>
     /// <param name="index">Table index.</param>
diff --git a/src/ImageSharp/Formats/Jpeg/Components/Decoder/IJpegScanDecoder.cs b/src/ImageSharp/Formats/Jpeg/Components/Decoder/IJpegScanDecoder.cs
index ecec723a98..588090deb6 100644
--- a/src/ImageSharp/Formats/Jpeg/Components/Decoder/IJpegScanDecoder.cs
+++ b/src/ImageSharp/Formats/Jpeg/Components/Decoder/IJpegScanDecoder.cs
@@ -1,6 +1,8 @@
 // Copyright (c) Six Labors.
 // Licensed under the Six Labors Split License.
 
+using SixLabors.ImageSharp.Metadata.Profiles.Icc;
+
 namespace SixLabors.ImageSharp.Formats.Jpeg.Components.Decoder;
 
 /// <summary>
@@ -11,38 +13,41 @@ internal interface IJpegScanDecoder
     /// <summary>
     /// Sets the reset interval.
     /// </summary>
-    int ResetInterval { set; }
+    public int ResetInterval { set; }
 
     /// <summary>
     /// Gets or sets the spectral selection start.
     /// </summary>
-    int SpectralStart { get; set; }
+    public int SpectralStart { get; set; }
 
     /// <summary>
     /// Gets or sets the spectral selection end.
     /// </summary>
-    int SpectralEnd { get; set; }
+    public int SpectralEnd { get; set; }
 
     /// <summary>
     /// Gets or sets the successive approximation high bit end.
     /// </summary>
-    int SuccessiveHigh { get; set; }
+    public int SuccessiveHigh { get; set; }
 
     /// <summary>
     /// Gets or sets the successive approximation low bit end.
     /// </summary>
-    int SuccessiveLow { get; set; }
+    public int SuccessiveLow { get; set; }
 
     /// <summary>
     /// Decodes the entropy coded data.
     /// </summary>
     /// <param name="scanComponentCount">Component count in the current scan.</param>
-    void ParseEntropyCodedData(int scanComponentCount);
+    /// <param name="iccProfile">
+    /// The ICC profile to use for color conversion. If null, the default color space.
+    /// </param>
+    public void ParseEntropyCodedData(int scanComponentCount, IccProfile? iccProfile);
 
     /// <summary>
     /// Sets the JpegFrame and its components and injects the frame data into the spectral converter.
     /// </summary>
     /// <param name="frame">The frame.</param>
     /// <param name="jpegData">The raw JPEG data.</param>
-    void InjectFrameData(JpegFrame frame, IRawJpegData jpegData);
+    public void InjectFrameData(JpegFrame frame, IRawJpegData jpegData);
 }
diff --git a/src/ImageSharp/Formats/Jpeg/Components/Decoder/JpegBitReader.cs b/src/ImageSharp/Formats/Jpeg/Components/Decoder/JpegBitReader.cs
index e71d86a1d9..f888a8fb7b 100644
--- a/src/ImageSharp/Formats/Jpeg/Components/Decoder/JpegBitReader.cs
+++ b/src/ImageSharp/Formats/Jpeg/Components/Decoder/JpegBitReader.cs
@@ -76,13 +76,13 @@ internal struct JpegBitReader
     /// Whether a RST marker has been detected, I.E. One that is between RST0 and RST7
     /// </summary>
     [MethodImpl(InliningOptions.ShortMethod)]
-    public bool HasRestartMarker() => HasRestart(this.Marker);
+    public readonly bool HasRestartMarker() => HasRestart(this.Marker);
 
     /// <summary>
     /// Whether a bad marker has been detected, I.E. One that is not between RST0 and RST7
     /// </summary>
     [MethodImpl(InliningOptions.ShortMethod)]
-    public bool HasBadMarker() => this.Marker != JpegConstants.Markers.XFF && !this.HasRestartMarker();
+    public readonly bool HasBadMarker() => this.Marker != JpegConstants.Markers.XFF && !this.HasRestartMarker();
 
     [MethodImpl(InliningOptions.AlwaysInline)]
     public void FillBuffer()
@@ -132,7 +132,7 @@ internal struct JpegBitReader
     public int GetBits(int nbits) => (int)ExtractBits(this.data, this.remainingBits -= nbits, nbits);
 
     [MethodImpl(InliningOptions.ShortMethod)]
-    public int PeekBits(int nbits) => (int)ExtractBits(this.data, this.remainingBits - nbits, nbits);
+    public readonly int PeekBits(int nbits) => (int)ExtractBits(this.data, this.remainingBits - nbits, nbits);
 
     [MethodImpl(InliningOptions.AlwaysInline)]
     private static ulong ExtractBits(ulong value, int offset, int size) => (value >> offset) & (ulong)((1 << size) - 1);
diff --git a/src/ImageSharp/Formats/Jpeg/Components/Decoder/ProfileResolver.cs b/src/ImageSharp/Formats/Jpeg/Components/Decoder/ProfileResolver.cs
index c11679feb1..b83c01064a 100644
--- a/src/ImageSharp/Formats/Jpeg/Components/Decoder/ProfileResolver.cs
+++ b/src/ImageSharp/Formats/Jpeg/Components/Decoder/ProfileResolver.cs
@@ -11,80 +11,80 @@ internal static class ProfileResolver
     /// <summary>
     /// Gets the JFIF specific markers.
     /// </summary>
-    public static ReadOnlySpan<byte> JFifMarker => new[]
-    {
+    public static ReadOnlySpan<byte> JFifMarker =>
+    [
         (byte)'J', (byte)'F', (byte)'I', (byte)'F', (byte)'\0'
-    };
+    ];
 
     /// <summary>
     /// Gets the JFXX specific markers.
     /// </summary>
-    public static ReadOnlySpan<byte> JFxxMarker => new[]
-    {
+    public static ReadOnlySpan<byte> JFxxMarker =>
+    [
         (byte)'J', (byte)'F', (byte)'X', (byte)'X', (byte)'\0'
-    };
+    ];
 
     /// <summary>
     /// Gets the ICC specific markers.
     /// </summary>
-    public static ReadOnlySpan<byte> IccMarker => new[]
-    {
+    public static ReadOnlySpan<byte> IccMarker =>
+    [
         (byte)'I', (byte)'C', (byte)'C', (byte)'_',
         (byte)'P', (byte)'R', (byte)'O', (byte)'F',
         (byte)'I', (byte)'L', (byte)'E', (byte)'\0'
-    };
+    ];
 
     /// <summary>
     /// Gets the adobe photoshop APP13 marker which can contain IPTC meta data.
     /// </summary>
-    public static ReadOnlySpan<byte> AdobePhotoshopApp13Marker => new[]
-    {
+    public static ReadOnlySpan<byte> AdobePhotoshopApp13Marker =>
+    [
         (byte)'P', (byte)'h', (byte)'o', (byte)'t', (byte)'o', (byte)'s', (byte)'h', (byte)'o', (byte)'p', (byte)' ', (byte)'3', (byte)'.', (byte)'0', (byte)'\0'
-    };
+    ];
 
     /// <summary>
     /// Gets the 8BIM marker, which signals the start of a adobe specific image resource block.
     /// </summary>
-    public static ReadOnlySpan<byte> AdobeImageResourceBlockMarker => new[]
-    {
+    public static ReadOnlySpan<byte> AdobeImageResourceBlockMarker =>
+    [
         (byte)'8', (byte)'B', (byte)'I', (byte)'M'
-    };
+    ];
 
     /// <summary>
     /// Gets a IPTC Image resource ID.
     /// </summary>
-    public static ReadOnlySpan<byte> AdobeIptcMarker => new[]
-    {
+    public static ReadOnlySpan<byte> AdobeIptcMarker =>
+    [
         (byte)4, (byte)4
-    };
+    ];
 
     /// <summary>
     /// Gets the EXIF specific markers.
     /// </summary>
-    public static ReadOnlySpan<byte> ExifMarker => new[]
-    {
+    public static ReadOnlySpan<byte> ExifMarker =>
+    [
         (byte)'E', (byte)'x', (byte)'i', (byte)'f', (byte)'\0', (byte)'\0'
-    };
+    ];
 
     /// <summary>
     /// Gets the XMP specific markers.
     /// </summary>
-    public static ReadOnlySpan<byte> XmpMarker => new[]
-    {
+    public static ReadOnlySpan<byte> XmpMarker =>
+    [
         (byte)'h', (byte)'t', (byte)'t', (byte)'p', (byte)':', (byte)'/', (byte)'/',
         (byte)'n', (byte)'s', (byte)'.', (byte)'a', (byte)'d', (byte)'o', (byte)'b',
         (byte)'e', (byte)'.', (byte)'c', (byte)'o', (byte)'m', (byte)'/', (byte)'x',
         (byte)'a', (byte)'p', (byte)'/', (byte)'1', (byte)'.', (byte)'0', (byte)'/',
         (byte)0
-    };
+    ];
 
     /// <summary>
     /// Gets the Adobe specific markers <see href="http://www.sno.phy.queensu.ca/~phil/exiftool/TagNames/JPEG.html#Adobe"/>.
     /// </summary>
-    public static ReadOnlySpan<byte> AdobeMarker => new[]
-    {
+    public static ReadOnlySpan<byte> AdobeMarker =>
+    [
         (byte)'A', (byte)'d', (byte)'o', (byte)'b', (byte)'e'
-    };
+    ];
 
     /// <summary>
     /// Returns a value indicating whether the passed bytes are a match to the profile identifier.
diff --git a/src/ImageSharp/Formats/Jpeg/Components/Decoder/SpectralConverter.cs b/src/ImageSharp/Formats/Jpeg/Components/Decoder/SpectralConverter.cs
index 51d9bfbced..0703e4d9e0 100644
--- a/src/ImageSharp/Formats/Jpeg/Components/Decoder/SpectralConverter.cs
+++ b/src/ImageSharp/Formats/Jpeg/Components/Decoder/SpectralConverter.cs
@@ -1,6 +1,8 @@
 // Copyright (c) Six Labors.
 // Licensed under the Six Labors Split License.
 
+using SixLabors.ImageSharp.Metadata.Profiles.Icc;
+
 namespace SixLabors.ImageSharp.Formats.Jpeg.Components.Decoder;
 
 /// <summary>
@@ -11,8 +13,9 @@ internal abstract class SpectralConverter
     /// <summary>
     /// Supported scaled spectral block sizes for scaled IDCT decoding.
     /// </summary>
-    private static readonly int[] ScaledBlockSizes = new int[]
-    {
+    private static readonly int[] ScaledBlockSizes =
+    [
+
         // 8 => 1, 1/8 of the original size
         1,
 
@@ -21,7 +24,7 @@ internal abstract class SpectralConverter
 
         // 8 => 4, 1/2 of the original size
         4,
-    };
+    ];
 
     /// <summary>
     /// Gets a value indicating whether this converter has converted spectral
@@ -50,13 +53,16 @@ internal abstract class SpectralConverter
     /// Converts single spectral jpeg stride to color stride in baseline
     /// decoding mode.
     /// </summary>
+    /// <param name="iccProfile">
+    /// The ICC profile to use for color conversion. If <see langword="null"/>, then the default color space is used.
+    /// </param>
     /// <remarks>
     /// Called once per decoded spectral stride in <see cref="HuffmanScanDecoder"/>
     /// only for baseline interleaved jpeg images.
     /// Spectral 'stride' doesn't particularly mean 'single stride'.
     /// Actual stride height depends on the subsampling factor of the given image.
     /// </remarks>
-    public abstract void ConvertStrideBaseline();
+    public abstract void ConvertStrideBaseline(IccProfile? iccProfile);
 
     /// <summary>
     /// Marks current converter state as 'converted'.
@@ -77,13 +83,14 @@ internal abstract class SpectralConverter
     /// <param name="frame">The jpeg frame with the color space to convert to.</param>
     /// <param name="jpegData">The raw JPEG data.</param>
     /// <returns>The color converter.</returns>
-    protected virtual JpegColorConverterBase GetColorConverter(JpegFrame frame, IRawJpegData jpegData) => JpegColorConverterBase.GetConverter(jpegData.ColorSpace, frame.Precision);
+    protected virtual JpegColorConverterBase GetColorConverter(JpegFrame frame, IRawJpegData jpegData)
+        => JpegColorConverterBase.GetConverter(jpegData.ColorSpace, frame.Precision);
 
     /// <summary>
     /// Calculates image size with optional scaling.
     /// </summary>
     /// <remarks>
-    /// Does not apply scalling if <paramref name="targetSize"/> is null.
+    /// Does not apply scaling if <paramref name="targetSize"/> is null.
     /// </remarks>
     /// <param name="size">Size of the image.</param>
     /// <param name="targetSize">Target size of the image.</param>
diff --git a/src/ImageSharp/Formats/Jpeg/Components/Decoder/SpectralConverter{TPixel}.cs b/src/ImageSharp/Formats/Jpeg/Components/Decoder/SpectralConverter{TPixel}.cs
index 7f89baba58..2bd4b95fdd 100644
--- a/src/ImageSharp/Formats/Jpeg/Components/Decoder/SpectralConverter{TPixel}.cs
+++ b/src/ImageSharp/Formats/Jpeg/Components/Decoder/SpectralConverter{TPixel}.cs
@@ -4,6 +4,7 @@
 
 using System.Buffers;
 using SixLabors.ImageSharp.Memory;
+using SixLabors.ImageSharp.Metadata.Profiles.Icc;
 using SixLabors.ImageSharp.PixelFormats;
 
 namespace SixLabors.ImageSharp.Formats.Jpeg.Components.Decoder;
@@ -98,9 +99,10 @@ internal class SpectralConverter<TPixel> : SpectralConverter, IDisposable
     /// For non-baseline interleaved jpeg this method does a 'lazy' spectral
     /// conversion from spectral to color.
     /// </remarks>
+    /// <param name="iccProfile">Optional ICC profile for color conversion.</param>
     /// <param name="cancellationToken">Cancellation token.</param>
     /// <returns>Pixel buffer.</returns>
-    public Buffer2D<TPixel> GetPixelBuffer(CancellationToken cancellationToken)
+    public Buffer2D<TPixel> GetPixelBuffer(IccProfile iccProfile, CancellationToken cancellationToken)
     {
         if (!this.Converted)
         {
@@ -111,7 +113,7 @@ internal class SpectralConverter<TPixel> : SpectralConverter, IDisposable
             for (int step = 0; step < steps; step++)
             {
                 cancellationToken.ThrowIfCancellationRequested();
-                this.ConvertStride(step);
+                this.ConvertStride(step, iccProfile);
             }
         }
 
@@ -124,7 +126,8 @@ internal class SpectralConverter<TPixel> : SpectralConverter, IDisposable
     /// Converts single spectral jpeg stride to color stride.
     /// </summary>
     /// <param name="spectralStep">Spectral stride index.</param>
-    private void ConvertStride(int spectralStep)
+    /// <param name="iccProfile">Optional ICC profile for color conversion.</param>
+    private void ConvertStride(int spectralStep, IccProfile iccProfile)
     {
         int maxY = Math.Min(this.pixelBuffer.Height, this.pixelRowCounter + this.pixelRowsPerStep);
 
@@ -141,7 +144,15 @@ internal class SpectralConverter<TPixel> : SpectralConverter, IDisposable
 
             JpegColorConverterBase.ComponentValues values = new(this.componentProcessors, y);
 
-            this.colorConverter.ConvertToRgbInplace(values);
+            if (iccProfile != null)
+            {
+                this.colorConverter.ConvertToRgbInPlaceWithIcc(this.Configuration, in values, iccProfile);
+            }
+            else
+            {
+                this.colorConverter.ConvertToRgbInPlace(in values);
+            }
+
             values = values.Slice(0, width); // slice away Jpeg padding
 
             Span<byte> r = this.rgbBuffer.Slice(0, width);
@@ -222,11 +233,11 @@ internal class SpectralConverter<TPixel> : SpectralConverter, IDisposable
     }
 
     /// <inheritdoc/>
-    public override void ConvertStrideBaseline()
+    public override void ConvertStrideBaseline(IccProfile iccProfile)
     {
         // Convert next pixel stride using single spectral `stride'
         // Note that zero passing eliminates extra virtual call
-        this.ConvertStride(spectralStep: 0);
+        this.ConvertStride(spectralStep: 0, iccProfile);
 
         foreach (ComponentProcessor cpp in this.componentProcessors)
         {
diff --git a/src/ImageSharp/Formats/Jpeg/Components/Encoder/ComponentProcessor.cs b/src/ImageSharp/Formats/Jpeg/Components/Encoder/ComponentProcessor.cs
index c33a8a1968..1b0a177049 100644
--- a/src/ImageSharp/Formats/Jpeg/Components/Encoder/ComponentProcessor.cs
+++ b/src/ImageSharp/Formats/Jpeg/Components/Encoder/ComponentProcessor.cs
@@ -241,7 +241,7 @@ internal class ComponentProcessor : IDisposable
                 ref Vector<float> targetVectorRef = ref Unsafe.As<float, Vector<float>>(ref MemoryMarshal.GetReference(target));
 
                 nuint count = target.VectorCount<float>();
-                var multiplierVector = new Vector<float>(multiplier);
+                Vector<float> multiplierVector = new(multiplier);
                 for (nuint i = 0; i < count; i++)
                 {
                     Unsafe.Add(ref targetVectorRef, i) *= multiplierVector;
diff --git a/src/ImageSharp/Formats/Jpeg/Components/Encoder/HuffmanScanEncoder.cs b/src/ImageSharp/Formats/Jpeg/Components/Encoder/HuffmanScanEncoder.cs
index 90e16f6dff..4815fce0cf 100644
--- a/src/ImageSharp/Formats/Jpeg/Components/Encoder/HuffmanScanEncoder.cs
+++ b/src/ImageSharp/Formats/Jpeg/Components/Encoder/HuffmanScanEncoder.cs
@@ -409,7 +409,7 @@ internal class HuffmanScanEncoder
                 {
                     this.FlushRemainingBytes();
                     this.WriteRestart(restarts % 8);
-                    foreach (var component in frame.Components)
+                    foreach (Component component in frame.Components)
                     {
                         component.DcPredictor = 0;
                     }
diff --git a/src/ImageSharp/Formats/Jpeg/Components/Encoder/HuffmanSpec.cs b/src/ImageSharp/Formats/Jpeg/Components/Encoder/HuffmanSpec.cs
index f5666f7799..502b919177 100644
--- a/src/ImageSharp/Formats/Jpeg/Components/Encoder/HuffmanSpec.cs
+++ b/src/ImageSharp/Formats/Jpeg/Components/Encoder/HuffmanSpec.cs
@@ -15,15 +15,13 @@ internal readonly struct HuffmanSpec
     /// This is an example specification taken from the jpeg specification paper.
     /// </remarks>
     public static readonly HuffmanSpec LuminanceDC = new(
-        new byte[]
-        {
+        [
             0, 1, 5, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0,
             0, 0, 0
-        },
-        new byte[]
-        {
+        ],
+        [
             0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11
-        });
+        ]);
 
     /// <summary>
     /// Huffman talbe specification for luminance AC.
@@ -32,13 +30,11 @@ internal readonly struct HuffmanSpec
     /// This is an example specification taken from the jpeg specification paper.
     /// </remarks>
     public static readonly HuffmanSpec LuminanceAC = new(
-        new byte[]
-        {
+        [
             0, 2, 1, 3, 3, 2, 4, 3, 5, 5, 4, 4, 0,
             0, 1, 125
-        },
-        new byte[]
-        {
+        ],
+        [
             0x01, 0x02, 0x03, 0x00, 0x04, 0x11,
             0x05, 0x12, 0x21, 0x31, 0x41, 0x06, 0x13,
             0x51, 0x61, 0x07, 0x22, 0x71, 0x14, 0x32,
@@ -63,7 +59,7 @@ internal readonly struct HuffmanSpec
             0xe5, 0xe6, 0xe7, 0xe8, 0xe9, 0xea, 0xf1,
             0xf2, 0xf3, 0xf4, 0xf5, 0xf6, 0xf7, 0xf8,
             0xf9, 0xfa
-        });
+        ]);
 
     /// <summary>
     /// Huffman talbe specification for chrominance DC.
@@ -72,15 +68,13 @@ internal readonly struct HuffmanSpec
     /// This is an example specification taken from the jpeg specification paper.
     /// </remarks>
     public static readonly HuffmanSpec ChrominanceDC = new(
-        new byte[]
-        {
+        [
             0, 3, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0,
             0, 0, 0
-        },
-        new byte[]
-        {
+        ],
+        [
             0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11
-        });
+        ]);
 
     /// <summary>
     /// Huffman talbe specification for chrominance DC.
@@ -89,13 +83,11 @@ internal readonly struct HuffmanSpec
     /// This is an example specification taken from the jpeg specification paper.
     /// </remarks>
     public static readonly HuffmanSpec ChrominanceAC = new(
-        new byte[]
-        {
+        [
             0, 2, 1, 2, 4, 4, 3, 4, 7, 5, 4, 4, 0,
             1, 2, 119
-        },
-        new byte[]
-        {
+        ],
+        [
             0x00, 0x01, 0x02, 0x03, 0x11, 0x04,
             0x05, 0x21, 0x31, 0x06, 0x12, 0x41, 0x51,
             0x07, 0x61, 0x71, 0x13, 0x22, 0x32, 0x81,
@@ -120,7 +112,7 @@ internal readonly struct HuffmanSpec
             0xe4, 0xe5, 0xe6, 0xe7, 0xe8, 0xe9, 0xea,
             0xf2, 0xf3, 0xf4, 0xf5, 0xf6, 0xf7, 0xf8,
             0xf9, 0xfa
-        });
+        ]);
 
     /// <summary>
     /// Initializes a new instance of the <see cref="HuffmanSpec"/> struct.
diff --git a/src/ImageSharp/Formats/Jpeg/Components/Encoder/SpectralConverter{TPixel}.cs b/src/ImageSharp/Formats/Jpeg/Components/Encoder/SpectralConverter{TPixel}.cs
index fc93db9bb0..b60ef68f11 100644
--- a/src/ImageSharp/Formats/Jpeg/Components/Encoder/SpectralConverter{TPixel}.cs
+++ b/src/ImageSharp/Formats/Jpeg/Components/Encoder/SpectralConverter{TPixel}.cs
@@ -2,7 +2,6 @@
 // Licensed under the Six Labors Split License.
 
 using System.Buffers;
-using SixLabors.ImageSharp.Advanced;
 using SixLabors.ImageSharp.Memory;
 using SixLabors.ImageSharp.PixelFormats;
 
@@ -47,7 +46,7 @@ internal class SpectralConverter<TPixel> : SpectralConverter, IDisposable
         // component processors from spectral to Rgb24
         const int blockPixelWidth = 8;
         this.alignedPixelWidth = majorBlockWidth * blockPixelWidth;
-        var postProcessorBufferSize = new Size(this.alignedPixelWidth, this.pixelRowsPerStep);
+        Size postProcessorBufferSize = new(this.alignedPixelWidth, this.pixelRowsPerStep);
         this.componentProcessors = new ComponentProcessor[frame.Components.Length];
         for (int i = 0; i < this.componentProcessors.Length; i++)
         {
@@ -109,6 +108,8 @@ internal class SpectralConverter<TPixel> : SpectralConverter, IDisposable
             int y = yy - this.pixelRowCounter;
 
             // Unpack TPixel to r/g/b planes
+            // TODO: The individual implementation code would be much easier here if
+            // we scaled to [0-1] before passing to the individual converters.
             int srcIndex = Math.Min(yy, pixelBufferLastVerticalIndex);
             Span<TPixel> sourceRow = this.pixelBuffer.DangerousGetRowSpan(srcIndex);
             PixelOperations<TPixel>.Instance.UnpackIntoRgbPlanes(rLane, gLane, bLane, sourceRow);
@@ -118,7 +119,7 @@ internal class SpectralConverter<TPixel> : SpectralConverter, IDisposable
             bLane.Slice(paddingStartIndex).Fill(bLane[paddingStartIndex - 1]);
 
             // Convert from rgb24 to target pixel type
-            var values = new JpegColorConverterBase.ComponentValues(this.componentProcessors, y);
+            JpegColorConverterBase.ComponentValues values = new(this.componentProcessors, y);
             this.colorConverter.ConvertFromRgb(values, rLane, gLane, bLane);
         }
 
diff --git a/src/ImageSharp/Formats/Jpeg/Components/FloatingPointDCT.Intrinsic.cs b/src/ImageSharp/Formats/Jpeg/Components/FloatingPointDCT.Intrinsic.cs
deleted file mode 100644
index 7e102f696d..0000000000
--- a/src/ImageSharp/Formats/Jpeg/Components/FloatingPointDCT.Intrinsic.cs
+++ /dev/null
@@ -1,142 +0,0 @@
-// Copyright (c) Six Labors.
-// Licensed under the Six Labors Split License.
-
-using System.Runtime.Intrinsics;
-using System.Runtime.Intrinsics.X86;
-
-namespace SixLabors.ImageSharp.Formats.Jpeg.Components;
-
-internal static partial class FloatingPointDCT
-{
-    /// <summary>
-    /// Apply floating point FDCT inplace using simd operations.
-    /// </summary>
-    /// <param name="block">Input block.</param>
-    private static void FDCT8x8_Avx(ref Block8x8F block)
-    {
-        DebugGuard.IsTrue(Avx.IsSupported, "Avx support is required to execute this operation.");
-
-        // First pass - process columns
-        FDCT8x8_1D_Avx(ref block);
-
-        // Second pass - process rows
-        block.TransposeInplace();
-        FDCT8x8_1D_Avx(ref block);
-
-        // Applies 1D floating point FDCT inplace
-        static void FDCT8x8_1D_Avx(ref Block8x8F block)
-        {
-            Vector256<float> tmp0 = Avx.Add(block.V0, block.V7);
-            Vector256<float> tmp7 = Avx.Subtract(block.V0, block.V7);
-            Vector256<float> tmp1 = Avx.Add(block.V1, block.V6);
-            Vector256<float> tmp6 = Avx.Subtract(block.V1, block.V6);
-            Vector256<float> tmp2 = Avx.Add(block.V2, block.V5);
-            Vector256<float> tmp5 = Avx.Subtract(block.V2, block.V5);
-            Vector256<float> tmp3 = Avx.Add(block.V3, block.V4);
-            Vector256<float> tmp4 = Avx.Subtract(block.V3, block.V4);
-
-            // Even part
-            Vector256<float> tmp10 = Avx.Add(tmp0, tmp3);
-            Vector256<float> tmp13 = Avx.Subtract(tmp0, tmp3);
-            Vector256<float> tmp11 = Avx.Add(tmp1, tmp2);
-            Vector256<float> tmp12 = Avx.Subtract(tmp1, tmp2);
-
-            block.V0 = Avx.Add(tmp10, tmp11);
-            block.V4 = Avx.Subtract(tmp10, tmp11);
-
-            var mm256_F_0_7071 = Vector256.Create(0.707106781f);
-            Vector256<float> z1 = Avx.Multiply(Avx.Add(tmp12, tmp13), mm256_F_0_7071);
-            block.V2 = Avx.Add(tmp13, z1);
-            block.V6 = Avx.Subtract(tmp13, z1);
-
-            // Odd part
-            tmp10 = Avx.Add(tmp4, tmp5);
-            tmp11 = Avx.Add(tmp5, tmp6);
-            tmp12 = Avx.Add(tmp6, tmp7);
-
-            Vector256<float> z5 = Avx.Multiply(Avx.Subtract(tmp10, tmp12), Vector256.Create(0.382683433f));         // mm256_F_0_3826
-            Vector256<float> z2 = SimdUtils.HwIntrinsics.MultiplyAdd(z5, Vector256.Create(0.541196100f), tmp10);    // mm256_F_0_5411
-            Vector256<float> z4 = SimdUtils.HwIntrinsics.MultiplyAdd(z5, Vector256.Create(1.306562965f), tmp12);    // mm256_F_1_3065
-            Vector256<float> z3 = Avx.Multiply(tmp11, mm256_F_0_7071);
-
-            Vector256<float> z11 = Avx.Add(tmp7, z3);
-            Vector256<float> z13 = Avx.Subtract(tmp7, z3);
-
-            block.V5 = Avx.Add(z13, z2);
-            block.V3 = Avx.Subtract(z13, z2);
-            block.V1 = Avx.Add(z11, z4);
-            block.V7 = Avx.Subtract(z11, z4);
-        }
-    }
-
-    /// <summary>
-    /// Apply floating point IDCT inplace using simd operations.
-    /// </summary>
-    /// <param name="transposedBlock">Transposed input block.</param>
-    private static void IDCT8x8_Avx(ref Block8x8F transposedBlock)
-    {
-        DebugGuard.IsTrue(Avx.IsSupported, "Avx support is required to execute this operation.");
-
-        // First pass - process columns
-        IDCT8x8_1D_Avx(ref transposedBlock);
-
-        // Second pass - process rows
-        transposedBlock.TransposeInplace();
-        IDCT8x8_1D_Avx(ref transposedBlock);
-
-        // Applies 1D floating point FDCT inplace
-        static void IDCT8x8_1D_Avx(ref Block8x8F block)
-        {
-            // Even part
-            Vector256<float> tmp0 = block.V0;
-            Vector256<float> tmp1 = block.V2;
-            Vector256<float> tmp2 = block.V4;
-            Vector256<float> tmp3 = block.V6;
-
-            Vector256<float> z5 = tmp0;
-            Vector256<float> tmp10 = Avx.Add(z5, tmp2);
-            Vector256<float> tmp11 = Avx.Subtract(z5, tmp2);
-
-            var mm256_F_1_4142 = Vector256.Create(1.414213562f);
-            Vector256<float> tmp13 = Avx.Add(tmp1, tmp3);
-            Vector256<float> tmp12 = SimdUtils.HwIntrinsics.MultiplySubtract(tmp13, Avx.Subtract(tmp1, tmp3), mm256_F_1_4142);
-
-            tmp0 = Avx.Add(tmp10, tmp13);
-            tmp3 = Avx.Subtract(tmp10, tmp13);
-            tmp1 = Avx.Add(tmp11, tmp12);
-            tmp2 = Avx.Subtract(tmp11, tmp12);
-
-            // Odd part
-            Vector256<float> tmp4 = block.V1;
-            Vector256<float> tmp5 = block.V3;
-            Vector256<float> tmp6 = block.V5;
-            Vector256<float> tmp7 = block.V7;
-
-            Vector256<float> z13 = Avx.Add(tmp6, tmp5);
-            Vector256<float> z10 = Avx.Subtract(tmp6, tmp5);
-            Vector256<float> z11 = Avx.Add(tmp4, tmp7);
-            Vector256<float> z12 = Avx.Subtract(tmp4, tmp7);
-
-            tmp7 = Avx.Add(z11, z13);
-            tmp11 = Avx.Multiply(Avx.Subtract(z11, z13), mm256_F_1_4142);
-
-            z5 = Avx.Multiply(Avx.Add(z10, z12), Vector256.Create(1.847759065f));                   // mm256_F_1_8477
-
-            tmp10 = SimdUtils.HwIntrinsics.MultiplyAdd(z5, z12, Vector256.Create(-1.082392200f));   // mm256_F_n1_0823
-            tmp12 = SimdUtils.HwIntrinsics.MultiplyAdd(z5, z10, Vector256.Create(-2.613125930f));   // mm256_F_n2_6131
-
-            tmp6 = Avx.Subtract(tmp12, tmp7);
-            tmp5 = Avx.Subtract(tmp11, tmp6);
-            tmp4 = Avx.Subtract(tmp10, tmp5);
-
-            block.V0 = Avx.Add(tmp0, tmp7);
-            block.V7 = Avx.Subtract(tmp0, tmp7);
-            block.V1 = Avx.Add(tmp1, tmp6);
-            block.V6 = Avx.Subtract(tmp1, tmp6);
-            block.V2 = Avx.Add(tmp2, tmp5);
-            block.V5 = Avx.Subtract(tmp2, tmp5);
-            block.V3 = Avx.Add(tmp3, tmp4);
-            block.V4 = Avx.Subtract(tmp3, tmp4);
-        }
-    }
-}
diff --git a/src/ImageSharp/Formats/Jpeg/Components/FloatingPointDCT.Vector256.cs b/src/ImageSharp/Formats/Jpeg/Components/FloatingPointDCT.Vector256.cs
new file mode 100644
index 0000000000..bcd8c70431
--- /dev/null
+++ b/src/ImageSharp/Formats/Jpeg/Components/FloatingPointDCT.Vector256.cs
@@ -0,0 +1,142 @@
+// Copyright (c) Six Labors.
+// Licensed under the Six Labors Split License.
+
+using System.Runtime.Intrinsics;
+using SixLabors.ImageSharp.Common.Helpers;
+
+namespace SixLabors.ImageSharp.Formats.Jpeg.Components;
+
+internal static partial class FloatingPointDCT
+{
+    /// <summary>
+    /// Apply floating point FDCT in place using simd operations.
+    /// </summary>
+    /// <param name="block">Input block.</param>
+    private static void FDCT8x8_Vector256(ref Block8x8F block)
+    {
+        DebugGuard.IsTrue(Vector256.IsHardwareAccelerated, "Vector256 support is required to execute this operation.");
+
+        // First pass - process columns
+        FDCT8x8_1D_Vector256(ref block);
+
+        // Second pass - process rows
+        block.TransposeInPlace();
+        FDCT8x8_1D_Vector256(ref block);
+
+        // Applies 1D floating point FDCT in place
+        static void FDCT8x8_1D_Vector256(ref Block8x8F block)
+        {
+            Vector256<float> tmp0 = block.V256_0 + block.V256_7;
+            Vector256<float> tmp7 = block.V256_0 - block.V256_7;
+            Vector256<float> tmp1 = block.V256_1 + block.V256_6;
+            Vector256<float> tmp6 = block.V256_1 - block.V256_6;
+            Vector256<float> tmp2 = block.V256_2 + block.V256_5;
+            Vector256<float> tmp5 = block.V256_2 - block.V256_5;
+            Vector256<float> tmp3 = block.V256_3 + block.V256_4;
+            Vector256<float> tmp4 = block.V256_3 - block.V256_4;
+
+            // Even part
+            Vector256<float> tmp10 = tmp0 + tmp3;
+            Vector256<float> tmp13 = tmp0 - tmp3;
+            Vector256<float> tmp11 = tmp1 + tmp2;
+            Vector256<float> tmp12 = tmp1 - tmp2;
+
+            block.V256_0 = tmp10 + tmp11;
+            block.V256_4 = tmp10 - tmp11;
+
+            Vector256<float> mm256_F_0_7071 = Vector256.Create(0.707106781f);
+            Vector256<float> z1 = (tmp12 + tmp13) * mm256_F_0_7071;
+            block.V256_2 = tmp13 + z1;
+            block.V256_6 = tmp13 - z1;
+
+            // Odd part
+            tmp10 = tmp4 + tmp5;
+            tmp11 = tmp5 + tmp6;
+            tmp12 = tmp6 + tmp7;
+
+            Vector256<float> z5 = (tmp10 - tmp12) * Vector256.Create(0.382683433f);    // mm256_F_0_3826
+            Vector256<float> z2 = Vector256_.MultiplyAdd(z5, Vector256.Create(0.541196100f), tmp10);    // mm256_F_0_5411
+            Vector256<float> z4 = Vector256_.MultiplyAdd(z5, Vector256.Create(1.306562965f), tmp12);    // mm256_F_1_3065
+            Vector256<float> z3 = tmp11 * mm256_F_0_7071;
+
+            Vector256<float> z11 = tmp7 + z3;
+            Vector256<float> z13 = tmp7 - z3;
+
+            block.V256_5 = z13 + z2;
+            block.V256_3 = z13 - z2;
+            block.V256_1 = z11 + z4;
+            block.V256_7 = z11 - z4;
+        }
+    }
+
+    /// <summary>
+    /// Apply floating point IDCT in place using simd operations.
+    /// </summary>
+    /// <param name="transposedBlock">Transposed input block.</param>
+    private static void IDCT8x8_Vector256(ref Block8x8F transposedBlock)
+    {
+        DebugGuard.IsTrue(Vector256.IsHardwareAccelerated, "Vector256 support is required to execute this operation.");
+
+        // First pass - process columns
+        IDCT8x8_1D_Vector256(ref transposedBlock);
+
+        // Second pass - process rows
+        transposedBlock.TransposeInPlace();
+        IDCT8x8_1D_Vector256(ref transposedBlock);
+
+        // Applies 1D floating point FDCT in place
+        static void IDCT8x8_1D_Vector256(ref Block8x8F block)
+        {
+            // Even part
+            Vector256<float> tmp0 = block.V256_0;
+            Vector256<float> tmp1 = block.V256_2;
+            Vector256<float> tmp2 = block.V256_4;
+            Vector256<float> tmp3 = block.V256_6;
+
+            Vector256<float> z5 = tmp0;
+            Vector256<float> tmp10 = z5 + tmp2;
+            Vector256<float> tmp11 = z5 - tmp2;
+
+            Vector256<float> mm256_F_1_4142 = Vector256.Create(1.414213562f);
+            Vector256<float> tmp13 = tmp1 + tmp3;
+            Vector256<float> tmp12 = Vector256_.MultiplySubtract(tmp13, tmp1 - tmp3, mm256_F_1_4142);
+
+            tmp0 = tmp10 + tmp13;
+            tmp3 = tmp10 - tmp13;
+            tmp1 = tmp11 + tmp12;
+            tmp2 = tmp11 - tmp12;
+
+            // Odd part
+            Vector256<float> tmp4 = block.V256_1;
+            Vector256<float> tmp5 = block.V256_3;
+            Vector256<float> tmp6 = block.V256_5;
+            Vector256<float> tmp7 = block.V256_7;
+
+            Vector256<float> z13 = tmp6 + tmp5;
+            Vector256<float> z10 = tmp6 - tmp5;
+            Vector256<float> z11 = tmp4 + tmp7;
+            Vector256<float> z12 = tmp4 - tmp7;
+
+            tmp7 = z11 + z13;
+            tmp11 = (z11 - z13) * mm256_F_1_4142;
+
+            z5 = (z10 + z12) * Vector256.Create(1.847759065f);   // mm256_F_1_8477
+
+            tmp10 = Vector256_.MultiplyAdd(z5, z12, Vector256.Create(-1.082392200f));   // mm256_F_n1_0823
+            tmp12 = Vector256_.MultiplyAdd(z5, z10, Vector256.Create(-2.613125930f));   // mm256_F_n2_6131
+
+            tmp6 = tmp12 - tmp7;
+            tmp5 = tmp11 - tmp6;
+            tmp4 = tmp10 - tmp5;
+
+            block.V256_0 = tmp0 + tmp7;
+            block.V256_7 = tmp0 - tmp7;
+            block.V256_1 = tmp1 + tmp6;
+            block.V256_6 = tmp1 - tmp6;
+            block.V256_2 = tmp2 + tmp5;
+            block.V256_5 = tmp2 - tmp5;
+            block.V256_3 = tmp3 + tmp4;
+            block.V256_4 = tmp3 - tmp4;
+        }
+    }
+}
diff --git a/src/ImageSharp/Formats/Jpeg/Components/FloatingPointDCT.cs b/src/ImageSharp/Formats/Jpeg/Components/FloatingPointDCT.cs
index 0aca33b4c9..eb2d0b2eb3 100644
--- a/src/ImageSharp/Formats/Jpeg/Components/FloatingPointDCT.cs
+++ b/src/ImageSharp/Formats/Jpeg/Components/FloatingPointDCT.cs
@@ -4,7 +4,7 @@
 using System.Numerics;
 using System.Runtime.CompilerServices;
 using System.Runtime.InteropServices;
-using System.Runtime.Intrinsics.X86;
+using System.Runtime.Intrinsics;
 
 // ReSharper disable InconsistentNaming
 namespace SixLabors.ImageSharp.Formats.Jpeg.Components;
@@ -49,8 +49,8 @@ internal static partial class FloatingPointDCT
     /// </code>
     /// </para>
     /// </remarks>
-    private static readonly float[] AdjustmentCoefficients = new float[]
-    {
+    private static readonly float[] AdjustmentCoefficients =
+    [
         1f, 1.3870399f, 1.306563f, 1.1758755f, 1f, 0.78569496f, 0.5411961f, 0.27589938f,
         1.3870399f, 1.9238797f, 1.812255f, 1.6309863f, 1.3870399f, 1.0897902f, 0.7506606f, 0.38268346f,
         1.306563f, 1.812255f, 1.707107f, 1.5363555f, 1.306563f, 1.02656f, 0.7071068f, 0.36047992f,
@@ -58,8 +58,8 @@ internal static partial class FloatingPointDCT
         1f, 1.3870399f, 1.306563f, 1.1758755f, 1f, 0.78569496f, 0.5411961f, 0.27589938f,
         0.78569496f, 1.0897902f, 1.02656f, 0.9238795f, 0.78569496f, 0.61731654f, 0.42521507f, 0.21677275f,
         0.5411961f, 0.7506606f, 0.7071068f, 0.63637924f, 0.5411961f, 0.42521507f, 0.29289323f, 0.14931567f,
-        0.27589938f, 0.38268346f, 0.36047992f, 0.32442334f, 0.27589938f, 0.21677275f, 0.14931567f, 0.076120466f,
-    };
+        0.27589938f, 0.38268346f, 0.36047992f, 0.32442334f, 0.27589938f, 0.21677275f, 0.14931567f, 0.076120466f
+    ];
 
     /// <summary>
     /// Adjusts given quantization table for usage with <see cref="TransformIDCT"/>.
@@ -77,7 +77,7 @@ internal static partial class FloatingPointDCT
 
         // Spectral macroblocks are transposed before quantization
         // so we must transpose quantization table
-        quantTable.TransposeInplace();
+        quantTable.TransposeInPlace();
     }
 
     /// <summary>
@@ -97,11 +97,11 @@ internal static partial class FloatingPointDCT
         // Spectral macroblocks are not transposed before quantization
         // Transpose is done after quantization at zig-zag stage
         // so we must transpose quantization table
-        quantTable.TransposeInplace();
+        quantTable.TransposeInPlace();
     }
 
     /// <summary>
-    /// Apply 2D floating point IDCT inplace.
+    /// Apply 2D floating point IDCT in place.
     /// </summary>
     /// <remarks>
     /// Input block must be dequantized with quantization table
@@ -110,9 +110,9 @@ internal static partial class FloatingPointDCT
     /// <param name="block">Input block.</param>
     public static void TransformIDCT(ref Block8x8F block)
     {
-        if (Avx.IsSupported)
+        if (Vector256.IsHardwareAccelerated)
         {
-            IDCT8x8_Avx(ref block);
+            IDCT8x8_Vector256(ref block);
         }
         else
         {
@@ -121,7 +121,7 @@ internal static partial class FloatingPointDCT
     }
 
     /// <summary>
-    /// Apply 2D floating point IDCT inplace.
+    /// Apply 2D floating point IDCT in place.
     /// </summary>
     /// <remarks>
     /// Input block must be quantized after this method with quantization
@@ -130,9 +130,9 @@ internal static partial class FloatingPointDCT
     /// <param name="block">Input block.</param>
     public static void TransformFDCT(ref Block8x8F block)
     {
-        if (Avx.IsSupported)
+        if (Vector256.IsHardwareAccelerated)
         {
-            FDCT8x8_Avx(ref block);
+            FDCT8x8_Vector256(ref block);
         }
         else
         {
@@ -155,7 +155,7 @@ internal static partial class FloatingPointDCT
         IDCT8x4_Vector4(ref transposedBlock.V0R);
 
         // Second pass - process rows
-        transposedBlock.TransposeInplace();
+        transposedBlock.TransposeInPlace();
         IDCT8x4_Vector4(ref transposedBlock.V0L);
         IDCT8x4_Vector4(ref transposedBlock.V0R);
 
@@ -225,7 +225,7 @@ internal static partial class FloatingPointDCT
         FDCT8x4_Vector4(ref block.V0R);
 
         // Second pass - process rows
-        block.TransposeInplace();
+        block.TransposeInPlace();
         FDCT8x4_Vector4(ref block.V0L);
         FDCT8x4_Vector4(ref block.V0R);
 
diff --git a/src/ImageSharp/Formats/Jpeg/Components/JpegColorSpace.cs b/src/ImageSharp/Formats/Jpeg/Components/JpegColorSpace.cs
index a2ec0666b0..c7b9745fd6 100644
--- a/src/ImageSharp/Formats/Jpeg/Components/JpegColorSpace.cs
+++ b/src/ImageSharp/Formats/Jpeg/Components/JpegColorSpace.cs
@@ -23,6 +23,16 @@ internal enum JpegColorSpace
     /// </summary>
     Cmyk,
 
+    /// <summary>
+    /// YccK color space with 4 components, used with tiff images, which use jpeg compression.
+    /// </summary>
+    TiffYccK,
+
+    /// <summary>
+    /// Cmyk color space with 4 components, used with tiff images, which use jpeg compression.
+    /// </summary>
+    TiffCmyk,
+
     /// <summary>
     /// Color space with 3 components.
     /// </summary>
diff --git a/src/ImageSharp/Formats/Jpeg/Components/Quantization.cs b/src/ImageSharp/Formats/Jpeg/Components/Quantization.cs
index 7dca1cf5ea..644cf2df57 100644
--- a/src/ImageSharp/Formats/Jpeg/Components/Quantization.cs
+++ b/src/ImageSharp/Formats/Jpeg/Components/Quantization.cs
@@ -46,8 +46,8 @@ internal static class Quantization
     // The C# compiler emits this as a compile-time constant embedded in the PE file.
     // This is effectively compiled down to: return new ReadOnlySpan<byte>(&data, length)
     // More details can be found: https://github.com/dotnet/roslyn/pull/24621
-    public static ReadOnlySpan<byte> LuminanceTable => new byte[]
-    {
+    public static ReadOnlySpan<byte> LuminanceTable =>
+    [
         16, 11, 10, 16,  24,  40,  51,  61,
         12, 12, 14, 19,  26,  58,  60,  55,
         14, 13, 16, 24,  40,  57,  69,  56,
@@ -55,8 +55,8 @@ internal static class Quantization
         18, 22, 37, 56,  68, 109, 103,  77,
         24, 35, 55, 64,  81, 104, 113,  92,
         49, 64, 78, 87, 103, 121, 120, 101,
-        72, 92, 95, 98, 112, 100, 103,  99,
-    };
+        72, 92, 95, 98, 112, 100, 103,  99
+    ];
 
     /// <summary>
     /// Gets unscaled chrominance quantization table.
@@ -67,8 +67,8 @@ internal static class Quantization
     // The C# compiler emits this as a compile-time constant embedded in the PE file.
     // This is effectively compiled down to: return new ReadOnlySpan<byte>(&data, length)
     // More details can be found: https://github.com/dotnet/roslyn/pull/24621
-    public static ReadOnlySpan<byte> ChrominanceTable => new byte[]
-    {
+    public static ReadOnlySpan<byte> ChrominanceTable =>
+    [
         17, 18, 24, 47, 99, 99, 99, 99,
         18, 21, 26, 66, 99, 99, 99, 99,
         24, 26, 56, 99, 99, 99, 99, 99,
@@ -76,8 +76,8 @@ internal static class Quantization
         99, 99, 99, 99, 99, 99, 99, 99,
         99, 99, 99, 99, 99, 99, 99, 99,
         99, 99, 99, 99, 99, 99, 99, 99,
-        99, 99, 99, 99, 99, 99, 99, 99,
-    };
+        99, 99, 99, 99, 99, 99, 99, 99
+    ];
 
     /// Ported from JPEGsnoop:
     /// https://github.com/ImpulseAdventure/JPEGsnoop/blob/9732ee0961f100eb69bbff4a0c47438d5997abee/source/JfifDecode.cpp#L4570-L4694
diff --git a/src/ImageSharp/Formats/Jpeg/Components/ScaledFloatingPointDCT.cs b/src/ImageSharp/Formats/Jpeg/Components/ScaledFloatingPointDCT.cs
index 98e3857973..b8234ff3e4 100644
--- a/src/ImageSharp/Formats/Jpeg/Components/ScaledFloatingPointDCT.cs
+++ b/src/ImageSharp/Formats/Jpeg/Components/ScaledFloatingPointDCT.cs
@@ -48,7 +48,7 @@ internal static class ScaledFloatingPointDCT
 
         // Spectral macroblocks are transposed before quantization
         // so we must transpose quantization table
-        quantTable.TransposeInplace();
+        quantTable.TransposeInPlace();
     }
 
     /// <summary>
diff --git a/src/ImageSharp/Formats/Jpeg/Components/SizeExtensions.cs b/src/ImageSharp/Formats/Jpeg/Components/SizeExtensions.cs
index c7212fc2df..b5d01fa5ce 100644
--- a/src/ImageSharp/Formats/Jpeg/Components/SizeExtensions.cs
+++ b/src/ImageSharp/Formats/Jpeg/Components/SizeExtensions.cs
@@ -14,20 +14,20 @@ internal static class SizeExtensions
     /// Multiplies 'a.Width' with 'b.Width' and 'a.Height' with 'b.Height'.
     /// TODO: Shouldn't we expose this as operator in SixLabors.Core?
     /// </summary>
-    public static Size MultiplyBy(this Size a, Size b) => new Size(a.Width * b.Width, a.Height * b.Height);
+    public static Size MultiplyBy(this Size a, Size b) => new(a.Width * b.Width, a.Height * b.Height);
 
     /// <summary>
     /// Divides 'a.Width' with 'b.Width' and 'a.Height' with 'b.Height'.
     /// TODO: Shouldn't we expose this as operator in SixLabors.Core?
     /// </summary>
-    public static Size DivideBy(this Size a, Size b) => new Size(a.Width / b.Width, a.Height / b.Height);
+    public static Size DivideBy(this Size a, Size b) => new(a.Width / b.Width, a.Height / b.Height);
 
     /// <summary>
     /// Divide Width and Height as real numbers and return the Ceiling.
     /// </summary>
     public static Size DivideRoundUp(this Size originalSize, int divX, int divY)
     {
-        var sizeVect = (Vector2)(SizeF)originalSize;
+        Vector2 sizeVect = (Vector2)(SizeF)originalSize;
         sizeVect /= new Vector2(divX, divY);
         sizeVect.X = MathF.Ceiling(sizeVect.X);
         sizeVect.Y = MathF.Ceiling(sizeVect.Y);
diff --git a/src/ImageSharp/Formats/Jpeg/Components/ZigZag.Intrinsic.cs b/src/ImageSharp/Formats/Jpeg/Components/ZigZag.Intrinsic.cs
index f6239ad1e0..941edb5c05 100644
--- a/src/ImageSharp/Formats/Jpeg/Components/ZigZag.Intrinsic.cs
+++ b/src/ImageSharp/Formats/Jpeg/Components/ZigZag.Intrinsic.cs
@@ -1,6 +1,9 @@
 // Copyright (c) Six Labors.
 // Licensed under the Six Labors Split License.
 
+using System.Diagnostics;
+using System.Diagnostics.CodeAnalysis;
+using System.Runtime.CompilerServices;
 using System.Runtime.InteropServices;
 using System.Runtime.Intrinsics;
 using System.Runtime.Intrinsics.X86;
@@ -17,11 +20,11 @@ internal static partial class ZigZag
 #pragma warning restore SA1309
 
     /// <summary>
-    /// Gets shuffle vectors for <see cref="ApplyTransposingZigZagOrderingSsse3"/>
+    /// Gets shuffle vectors for <see cref="ApplyTransposingZigZagOrderingVector128"/>
     /// zig zag implementation.
     /// </summary>
-    private static ReadOnlySpan<byte> SseShuffleMasks => new byte[]
-    {
+    private static ReadOnlySpan<byte> SseShuffleMasks =>
+    [
 #pragma warning disable SA1515
         /* row0 - A0 B0 A1 A2 B1 C0 D0 C1 */
         // A
@@ -83,14 +86,14 @@ internal static partial class ZigZag
         // H
         _,  _, _, _,  _,  _,  _,  _, 10, 11, 12, 13,  _,  _, 14, 15,
 #pragma warning restore SA1515
-    };
+    ];
 
     /// <summary>
     /// Gets shuffle vectors for <see cref="ApplyTransposingZigZagOrderingAvx2"/>
     /// zig zag implementation.
     /// </summary>
-    private static ReadOnlySpan<byte> AvxShuffleMasks => new byte[]
-    {
+    private static ReadOnlySpan<byte> AvxShuffleMasks =>
+    [
 #pragma warning disable SA1515
         /* 01 */
         // [cr] crln_01_AB_CD
@@ -138,15 +141,15 @@ internal static partial class ZigZag
         // (in) GH
         _, _, _, _,   _, _, _, _,   0, 1, 10, 11,   12, 13, 2, 3,   _, _, _, _,   _, _, 0, 1,   6, 7, 8, 9,   2, 3, 10, 11,
 #pragma warning restore SA1515
-    };
+    ];
 
     /// <summary>
-    /// Applies zig zag ordering for given 8x8 matrix using SSE cpu intrinsics.
+    /// Applies zig zag ordering for given 8x8 matrix using <see cref="Vector128{T}"/> cpu intrinsics.
     /// </summary>
     /// <param name="block">Input matrix.</param>
-    public static unsafe void ApplyTransposingZigZagOrderingSsse3(ref Block8x8 block)
+    public static unsafe void ApplyTransposingZigZagOrderingVector128(ref Block8x8 block)
     {
-        DebugGuard.IsTrue(Ssse3.IsSupported, "Ssse3 support is required to run this operation!");
+        DebugGuard.IsTrue(Vector128.IsHardwareAccelerated, "Vector128 support is required to run this operation!");
 
         fixed (byte* shuffleVectorsPtr = &MemoryMarshal.GetReference(SseShuffleMasks))
         {
@@ -160,68 +163,68 @@ internal static partial class ZigZag
             Vector128<byte> rowH = block.V7.AsByte();
 
             // row0 - A0 B0 A1 A2 B1 C0 D0 C1
-            Vector128<short> row0_A = Ssse3.Shuffle(rowA, Sse2.LoadVector128(shuffleVectorsPtr + (16 * 0))).AsInt16();
-            Vector128<short> row0_B = Ssse3.Shuffle(rowB, Sse2.LoadVector128(shuffleVectorsPtr + (16 * 1))).AsInt16();
-            Vector128<short> row0_C = Ssse3.Shuffle(rowC, Sse2.LoadVector128(shuffleVectorsPtr + (16 * 2))).AsInt16();
-            Vector128<short> row0 = Sse2.Or(Sse2.Or(row0_A, row0_B), row0_C);
-            row0 = Sse2.Insert(row0.AsUInt16(), Sse2.Extract(rowD.AsUInt16(), 0), 6).AsInt16();
+            Vector128<short> row0_A = ZShuffle(rowA, Vector128.Load(shuffleVectorsPtr + (16 * 0))).AsInt16();
+            Vector128<short> row0_B = ZShuffle(rowB, Vector128.Load(shuffleVectorsPtr + (16 * 1))).AsInt16();
+            Vector128<short> row0_C = ZShuffle(rowC, Vector128.Load(shuffleVectorsPtr + (16 * 2))).AsInt16();
+            Vector128<short> row0 = row0_A | row0_B | row0_C;
+            row0 = row0.AsUInt16().WithElement(6, rowD.AsUInt16().GetElement(0)).AsInt16();
 
             // row1 - B2 A3 A4 B3 C2 D1 E0 F0
-            Vector128<short> row1_A = Ssse3.Shuffle(rowA, Sse2.LoadVector128(shuffleVectorsPtr + (16 * 3))).AsInt16();
-            Vector128<short> row1_B = Ssse3.Shuffle(rowB, Sse2.LoadVector128(shuffleVectorsPtr + (16 * 4))).AsInt16();
-            Vector128<short> row1 = Sse2.Or(row1_A, row1_B);
-            row1 = Sse2.Insert(row1.AsUInt16(), Sse2.Extract(rowC.AsUInt16(), 2), 4).AsInt16();
-            row1 = Sse2.Insert(row1.AsUInt16(), Sse2.Extract(rowD.AsUInt16(), 1), 5).AsInt16();
-            row1 = Sse2.Insert(row1.AsUInt16(), Sse2.Extract(rowE.AsUInt16(), 0), 6).AsInt16();
-            row1 = Sse2.Insert(row1.AsUInt16(), Sse2.Extract(rowF.AsUInt16(), 0), 7).AsInt16();
+            Vector128<short> row1_A = ZShuffle(rowA, Vector128.Load(shuffleVectorsPtr + (16 * 3))).AsInt16();
+            Vector128<short> row1_B = ZShuffle(rowB, Vector128.Load(shuffleVectorsPtr + (16 * 4))).AsInt16();
+            Vector128<short> row1 = row1_A | row1_B;
+            row1 = row1.AsUInt16().WithElement(4, rowC.AsUInt16().GetElement(2)).AsInt16();
+            row1 = row1.AsUInt16().WithElement(5, rowD.AsUInt16().GetElement(1)).AsInt16();
+            row1 = row1.AsUInt16().WithElement(6, rowE.AsUInt16().GetElement(0)).AsInt16();
+            row1 = row1.AsUInt16().WithElement(7, rowF.AsUInt16().GetElement(0)).AsInt16();
 
             // row2 - E1 D2 C3 B4 A5 A6 B5 C4
-            Vector128<short> row2_A = Ssse3.Shuffle(rowA, Sse2.LoadVector128(shuffleVectorsPtr + (16 * 5))).AsInt16();
-            Vector128<short> row2_B = Ssse3.Shuffle(rowB, Sse2.LoadVector128(shuffleVectorsPtr + (16 * 6))).AsInt16();
-            Vector128<short> row2_C = Ssse3.Shuffle(rowC, Sse2.LoadVector128(shuffleVectorsPtr + (16 * 7))).AsInt16();
-            Vector128<short> row2 = Sse2.Or(Sse2.Or(row2_A, row2_B), row2_C);
-            row2 = Sse2.Insert(row2.AsUInt16(), Sse2.Extract(rowD.AsUInt16(), 2), 1).AsInt16();
-            row2 = Sse2.Insert(row2.AsUInt16(), Sse2.Extract(rowE.AsUInt16(), 1), 0).AsInt16();
+            Vector128<short> row2_A = ZShuffle(rowA, Vector128.Load(shuffleVectorsPtr + (16 * 5))).AsInt16();
+            Vector128<short> row2_B = ZShuffle(rowB, Vector128.Load(shuffleVectorsPtr + (16 * 6))).AsInt16();
+            Vector128<short> row2_C = ZShuffle(rowC, Vector128.Load(shuffleVectorsPtr + (16 * 7))).AsInt16();
+            Vector128<short> row2 = row2_A | row2_B | row2_C;
+            row2 = row2.AsUInt16().WithElement(1, rowD.AsUInt16().GetElement(2)).AsInt16();
+            row2 = row2.AsUInt16().WithElement(0, rowE.AsUInt16().GetElement(1)).AsInt16();
 
             // row3 - D3 E2 F1 G0 H0 G1 F2 E3
-            Vector128<short> row3_E = Ssse3.Shuffle(rowE, Sse2.LoadVector128(shuffleVectorsPtr + (16 * 8))).AsInt16();
-            Vector128<short> row3_F = Ssse3.Shuffle(rowF, Sse2.LoadVector128(shuffleVectorsPtr + (16 * 9))).AsInt16();
-            Vector128<short> row3_G = Ssse3.Shuffle(rowG, Sse2.LoadVector128(shuffleVectorsPtr + (16 * 10))).AsInt16();
-            Vector128<short> row3 = Sse2.Or(Sse2.Or(row3_E, row3_F), row3_G);
-            row3 = Sse2.Insert(row3.AsUInt16(), Sse2.Extract(rowD.AsUInt16(), 3), 0).AsInt16();
-            row3 = Sse2.Insert(row3.AsUInt16(), Sse2.Extract(rowH.AsUInt16(), 0), 4).AsInt16();
+            Vector128<short> row3_E = ZShuffle(rowE, Vector128.Load(shuffleVectorsPtr + (16 * 8))).AsInt16();
+            Vector128<short> row3_F = ZShuffle(rowF, Vector128.Load(shuffleVectorsPtr + (16 * 9))).AsInt16();
+            Vector128<short> row3_G = ZShuffle(rowG, Vector128.Load(shuffleVectorsPtr + (16 * 10))).AsInt16();
+            Vector128<short> row3 = row3_E | row3_F | row3_G;
+            row3 = row3.AsUInt16().WithElement(0, rowD.AsUInt16().GetElement(3)).AsInt16();
+            row3 = row3.AsUInt16().WithElement(4, rowH.AsUInt16().GetElement(0)).AsInt16();
 
             // row4 - D4 C5 B6 A7 B7 C6 D5 E4
-            Vector128<short> row4_B = Ssse3.Shuffle(rowB, Sse2.LoadVector128(shuffleVectorsPtr + (16 * 11))).AsInt16();
-            Vector128<short> row4_C = Ssse3.Shuffle(rowC, Sse2.LoadVector128(shuffleVectorsPtr + (16 * 12))).AsInt16();
-            Vector128<short> row4_D = Ssse3.Shuffle(rowD, Sse2.LoadVector128(shuffleVectorsPtr + (16 * 13))).AsInt16();
-            Vector128<short> row4 = Sse2.Or(Sse2.Or(row4_B, row4_C), row4_D);
-            row4 = Sse2.Insert(row4.AsUInt16(), Sse2.Extract(rowA.AsUInt16(), 7), 3).AsInt16();
-            row4 = Sse2.Insert(row4.AsUInt16(), Sse2.Extract(rowE.AsUInt16(), 4), 7).AsInt16();
+            Vector128<short> row4_B = ZShuffle(rowB, Vector128.Load(shuffleVectorsPtr + (16 * 11))).AsInt16();
+            Vector128<short> row4_C = ZShuffle(rowC, Vector128.Load(shuffleVectorsPtr + (16 * 12))).AsInt16();
+            Vector128<short> row4_D = ZShuffle(rowD, Vector128.Load(shuffleVectorsPtr + (16 * 13))).AsInt16();
+            Vector128<short> row4 = row4_B | row4_C | row4_D;
+            row4 = row4.AsUInt16().WithElement(3, rowA.AsUInt16().GetElement(7)).AsInt16();
+            row4 = row4.AsUInt16().WithElement(7, rowE.AsUInt16().GetElement(4)).AsInt16();
 
             // row5 - F3 G2 H1 H2 G3 F4 E5 D6
-            Vector128<short> row5_F = Ssse3.Shuffle(rowF, Sse2.LoadVector128(shuffleVectorsPtr + (16 * 14))).AsInt16();
-            Vector128<short> row5_G = Ssse3.Shuffle(rowG, Sse2.LoadVector128(shuffleVectorsPtr + (16 * 15))).AsInt16();
-            Vector128<short> row5_H = Ssse3.Shuffle(rowH, Sse2.LoadVector128(shuffleVectorsPtr + (16 * 16))).AsInt16();
-            Vector128<short> row5 = Sse2.Or(Sse2.Or(row5_F, row5_G), row5_H);
-            row5 = Sse2.Insert(row5.AsUInt16(), Sse2.Extract(rowD.AsUInt16(), 6), 7).AsInt16();
-            row5 = Sse2.Insert(row5.AsUInt16(), Sse2.Extract(rowE.AsUInt16(), 5), 6).AsInt16();
+            Vector128<short> row5_F = ZShuffle(rowF, Vector128.Load(shuffleVectorsPtr + (16 * 14))).AsInt16();
+            Vector128<short> row5_G = ZShuffle(rowG, Vector128.Load(shuffleVectorsPtr + (16 * 15))).AsInt16();
+            Vector128<short> row5_H = ZShuffle(rowH, Vector128.Load(shuffleVectorsPtr + (16 * 16))).AsInt16();
+            Vector128<short> row5 = row5_F | row5_G | row5_H;
+            row5 = row5.AsUInt16().WithElement(7, rowD.AsUInt16().GetElement(6)).AsInt16();
+            row5 = row5.AsUInt16().WithElement(6, rowE.AsUInt16().GetElement(5)).AsInt16();
 
             // row6 - C7 D7 E6 F5 G4 H3 H4 G5
-            Vector128<short> row6_G = Ssse3.Shuffle(rowG, Sse2.LoadVector128(shuffleVectorsPtr + (16 * 17))).AsInt16();
-            Vector128<short> row6_H = Ssse3.Shuffle(rowH, Sse2.LoadVector128(shuffleVectorsPtr + (16 * 18))).AsInt16();
-            Vector128<short> row6 = Sse2.Or(row6_G, row6_H);
-            row6 = Sse2.Insert(row6.AsUInt16(), Sse2.Extract(rowC.AsUInt16(), 7), 0).AsInt16();
-            row6 = Sse2.Insert(row6.AsUInt16(), Sse2.Extract(rowD.AsUInt16(), 7), 1).AsInt16();
-            row6 = Sse2.Insert(row6.AsUInt16(), Sse2.Extract(rowE.AsUInt16(), 6), 2).AsInt16();
-            row6 = Sse2.Insert(row6.AsUInt16(), Sse2.Extract(rowF.AsUInt16(), 5), 3).AsInt16();
+            Vector128<short> row6_G = ZShuffle(rowG, Vector128.Load(shuffleVectorsPtr + (16 * 17))).AsInt16();
+            Vector128<short> row6_H = ZShuffle(rowH, Vector128.Load(shuffleVectorsPtr + (16 * 18))).AsInt16();
+            Vector128<short> row6 = row6_G | row6_H;
+            row6 = row6.AsUInt16().WithElement(0, rowC.AsUInt16().GetElement(7)).AsInt16();
+            row6 = row6.AsUInt16().WithElement(1, rowD.AsUInt16().GetElement(7)).AsInt16();
+            row6 = row6.AsUInt16().WithElement(2, rowE.AsUInt16().GetElement(6)).AsInt16();
+            row6 = row6.AsUInt16().WithElement(3, rowF.AsUInt16().GetElement(5)).AsInt16();
 
             // row7 - F6 E7 F7 G6 H5 H6 G7 H7
-            Vector128<short> row7_F = Ssse3.Shuffle(rowF, Sse2.LoadVector128(shuffleVectorsPtr + (16 * 19))).AsInt16();
-            Vector128<short> row7_G = Ssse3.Shuffle(rowG, Sse2.LoadVector128(shuffleVectorsPtr + (16 * 20))).AsInt16();
-            Vector128<short> row7_H = Ssse3.Shuffle(rowH, Sse2.LoadVector128(shuffleVectorsPtr + (16 * 21))).AsInt16();
-            Vector128<short> row7 = Sse2.Or(Sse2.Or(row7_F, row7_G), row7_H);
-            row7 = Sse2.Insert(row7.AsUInt16(), Sse2.Extract(rowE.AsUInt16(), 7), 1).AsInt16();
+            Vector128<short> row7_F = ZShuffle(rowF, Vector128.Load(shuffleVectorsPtr + (16 * 19))).AsInt16();
+            Vector128<short> row7_G = ZShuffle(rowG, Vector128.Load(shuffleVectorsPtr + (16 * 20))).AsInt16();
+            Vector128<short> row7_H = ZShuffle(rowH, Vector128.Load(shuffleVectorsPtr + (16 * 21))).AsInt16();
+            Vector128<short> row7 = row7_F | row7_G | row7_H;
+            row7 = row7.AsUInt16().WithElement(1, rowE.AsUInt16().GetElement(7)).AsInt16();
 
             block.V0 = row0;
             block.V1 = row1;
@@ -300,4 +303,20 @@ internal static partial class ZigZag
             block.V67 = row67.AsInt16();
         }
     }
+
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    private static Vector128<byte> ZShuffle(Vector128<byte> source, Vector128<byte> mask)
+    {
+        // For x64 we use the SSSE3 shuffle intrinsic to avoid additional instructions. 3 vs 1.
+        if (Ssse3.IsSupported)
+        {
+            return Ssse3.Shuffle(source, mask);
+        }
+
+        // For ARM and WASM, codegen will be optimal.
+        return Vector128.Shuffle(source, mask);
+    }
+
+    [DoesNotReturn]
+    private static void ThrowUnreachableException() => throw new UnreachableException();
 }
diff --git a/src/ImageSharp/Formats/Jpeg/Components/ZigZag.cs b/src/ImageSharp/Formats/Jpeg/Components/ZigZag.cs
index 7b0e096e2a..630017082d 100644
--- a/src/ImageSharp/Formats/Jpeg/Components/ZigZag.cs
+++ b/src/ImageSharp/Formats/Jpeg/Components/ZigZag.cs
@@ -18,8 +18,8 @@ internal static partial class ZigZag
     /// The worst case would be a run-length of 15, which means we need 16
     /// fake entries.
     /// </remarks>
-    public static ReadOnlySpan<byte> ZigZagOrder => new byte[]
-    {
+    public static ReadOnlySpan<byte> ZigZagOrder =>
+    [
         0,  1,  8, 16,  9,  2,  3, 10,
         17, 24, 32, 25, 18, 11,  4,  5,
         12, 19, 26, 33, 40, 48, 41, 34,
@@ -32,7 +32,7 @@ internal static partial class ZigZag
         // Extra entries for safety in decoder
         63, 63, 63, 63, 63, 63, 63, 63,
         63, 63, 63, 63, 63, 63, 63, 63
-    };
+    ];
 
     /// <summary>
     /// Gets span of zig-zag with fused transpose step ordering indices.
@@ -47,8 +47,8 @@ internal static partial class ZigZag
     /// The worst case would be a run-length of 15, which means we need 16
     /// fake entries.
     /// </remarks>
-    public static ReadOnlySpan<byte> TransposingOrder => new byte[]
-    {
+    public static ReadOnlySpan<byte> TransposingOrder =>
+    [
         0,  8,  1,  2,  9,  16, 24, 17,
         10, 3,  4,  11, 18, 25, 32, 40,
         33, 26, 19, 12, 5,  6,  13, 20,
@@ -61,5 +61,5 @@ internal static partial class ZigZag
         // Extra entries for safety in decoder
         63, 63, 63, 63, 63, 63, 63, 63,
         63, 63, 63, 63, 63, 63, 63, 63
-    };
+    ];
 }
diff --git a/src/ImageSharp/Formats/Jpeg/JpegConstants.cs b/src/ImageSharp/Formats/Jpeg/JpegConstants.cs
index 7a627b7b84..50b7de68e4 100644
--- a/src/ImageSharp/Formats/Jpeg/JpegConstants.cs
+++ b/src/ImageSharp/Formats/Jpeg/JpegConstants.cs
@@ -18,12 +18,12 @@ internal static class JpegConstants
     /// <summary>
     /// The list of mimetypes that equate to a jpeg.
     /// </summary>
-    public static readonly IEnumerable<string> MimeTypes = new[] { "image/jpeg", "image/pjpeg" };
+    public static readonly IEnumerable<string> MimeTypes = ["image/jpeg", "image/pjpeg"];
 
     /// <summary>
     /// The list of file extensions that equate to a jpeg.
     /// </summary>
-    public static readonly IEnumerable<string> FileExtensions = new[] { "jpg", "jpeg", "jfif" };
+    public static readonly IEnumerable<string> FileExtensions = ["jpg", "jpeg", "jfif"];
 
     /// <summary>
     /// Contains marker specific constants.
diff --git a/src/ImageSharp/Formats/Jpeg/JpegDecoder.cs b/src/ImageSharp/Formats/Jpeg/JpegDecoder.cs
index 026c542dd9..c013cdc9c7 100644
--- a/src/ImageSharp/Formats/Jpeg/JpegDecoder.cs
+++ b/src/ImageSharp/Formats/Jpeg/JpegDecoder.cs
@@ -25,7 +25,7 @@ public sealed class JpegDecoder : SpecializedImageDecoder<JpegDecoderOptions>
         Guard.NotNull(options, nameof(options));
         Guard.NotNull(stream, nameof(stream));
 
-        using JpegDecoderCore decoder = new(new() { GeneralOptions = options });
+        using JpegDecoderCore decoder = new(new JpegDecoderOptions { GeneralOptions = options });
         return decoder.Identify(options.Configuration, stream, cancellationToken);
     }
 
diff --git a/src/ImageSharp/Formats/Jpeg/JpegDecoderCore.cs b/src/ImageSharp/Formats/Jpeg/JpegDecoderCore.cs
index 707baa1a88..0ad78b9035 100644
--- a/src/ImageSharp/Formats/Jpeg/JpegDecoderCore.cs
+++ b/src/ImageSharp/Formats/Jpeg/JpegDecoderCore.cs
@@ -115,19 +115,21 @@ internal sealed class JpegDecoderCore : ImageDecoderCore, IRawJpegData
     /// Initializes a new instance of the <see cref="JpegDecoderCore"/> class.
     /// </summary>
     /// <param name="options">The decoder options.</param>
-    public JpegDecoderCore(JpegDecoderOptions options)
+    /// <param name="iccProfile">The ICC profile to use for color conversion.</param>
+    public JpegDecoderCore(JpegDecoderOptions options, IccProfile iccProfile = null)
         : base(options.GeneralOptions)
     {
         this.resizeMode = options.ResizeMode;
         this.configuration = options.GeneralOptions.Configuration;
         this.skipMetadata = options.GeneralOptions.SkipMetadata;
+        this.SetIccMetadata(iccProfile);
     }
 
     /// <summary>
     /// Gets the only supported precisions
     /// </summary>
     // Refers to assembly's static data segment, no allocation occurs.
-    private static ReadOnlySpan<byte> SupportedPrecisions => new byte[] { 8, 12 };
+    private static ReadOnlySpan<byte> SupportedPrecisions => [8, 12];
 
     /// <summary>
     /// Gets the frame
@@ -201,9 +203,11 @@ internal sealed class JpegDecoderCore : ImageDecoderCore, IRawJpegData
         this.InitXmpProfile();
         this.InitDerivedMetadataProperties();
 
+        _ = this.Options.TryGetIccProfileForColorConversion(this.Metadata.IccProfile, out IccProfile profile);
+
         return new Image<TPixel>(
             this.configuration,
-            spectralConverter.GetPixelBuffer(cancellationToken),
+            spectralConverter.GetPixelBuffer(profile, cancellationToken),
             this.Metadata);
     }
 
@@ -218,7 +222,7 @@ internal sealed class JpegDecoderCore : ImageDecoderCore, IRawJpegData
         this.InitDerivedMetadataProperties();
 
         Size pixelSize = this.Frame.PixelSize;
-        return new ImageInfo(new(pixelSize.Width, pixelSize.Height), this.Metadata);
+        return new ImageInfo(new Size(pixelSize.Width, pixelSize.Height), this.Metadata);
     }
 
     /// <summary>
@@ -229,7 +233,7 @@ internal sealed class JpegDecoderCore : ImageDecoderCore, IRawJpegData
     /// <param name="scanDecoder">The scan decoder.</param>
     public void LoadTables(byte[] tableBytes, IJpegScanDecoder scanDecoder)
     {
-        this.Metadata = new ImageMetadata();
+        this.Metadata ??= new ImageMetadata();
         this.QuantizationTables = new Block8x8F[4];
         this.scanDecoder = scanDecoder;
         if (tableBytes.Length < 4)
@@ -312,7 +316,7 @@ internal sealed class JpegDecoderCore : ImageDecoderCore, IRawJpegData
 
         this.scanDecoder ??= new HuffmanScanDecoder(stream, spectralConverter, cancellationToken);
 
-        this.Metadata = new ImageMetadata();
+        this.Metadata ??= new ImageMetadata();
 
         Span<byte> markerBuffer = stackalloc byte[2];
 
@@ -666,7 +670,7 @@ internal sealed class JpegDecoderCore : ImageDecoderCore, IRawJpegData
     /// </summary>
     private void InitIccProfile()
     {
-        if (this.hasIcc)
+        if (this.hasIcc && this.Metadata.IccProfile == null)
         {
             IccProfile profile = new(this.iccData);
             if (profile.CheckIsValid())
@@ -676,6 +680,16 @@ internal sealed class JpegDecoderCore : ImageDecoderCore, IRawJpegData
         }
     }
 
+    private void SetIccMetadata(IccProfile profile)
+    {
+        if (!this.skipMetadata && profile?.CheckIsValid() == true)
+        {
+            this.hasIcc = true;
+            this.Metadata ??= new ImageMetadata();
+            this.Metadata.IccProfile = profile;
+        }
+    }
+
     /// <summary>
     /// Initializes the IPTC profile.
     /// </summary>
@@ -1229,7 +1243,7 @@ internal sealed class JpegDecoderCore : ImageDecoderCore, IRawJpegData
         }
 
         this.Frame = new JpegFrame(frameMarker, precision, frameWidth, frameHeight, componentCount);
-        this.Dimensions = new(frameWidth, frameHeight);
+        this.Dimensions = new Size(frameWidth, frameHeight);
         this.Metadata.GetJpegMetadata().Progressive = this.Frame.Progressive;
 
         remaining -= length;
@@ -1512,7 +1526,9 @@ internal sealed class JpegDecoderCore : ImageDecoderCore, IRawJpegData
             arithmeticScanDecoder.InitDecodingTables(this.arithmeticDecodingTables);
         }
 
-        this.scanDecoder.ParseEntropyCodedData(selectorsCount);
+        this.InitIccProfile();
+        _ = this.Options.TryGetIccProfileForColorConversion(this.Metadata.IccProfile, out IccProfile profile);
+        this.scanDecoder.ParseEntropyCodedData(selectorsCount, profile);
     }
 
     /// <summary>
diff --git a/src/ImageSharp/Formats/Jpeg/JpegEncoderCore.FrameConfig.cs b/src/ImageSharp/Formats/Jpeg/JpegEncoderCore.FrameConfig.cs
index 71f852a092..98b6dd30a6 100644
--- a/src/ImageSharp/Formats/Jpeg/JpegEncoderCore.FrameConfig.cs
+++ b/src/ImageSharp/Formats/Jpeg/JpegEncoderCore.FrameConfig.cs
@@ -13,15 +13,15 @@ internal sealed unsafe partial class JpegEncoderCore
 {
     private static JpegFrameConfig[] CreateFrameConfigs()
     {
-        var defaultLuminanceHuffmanDC = new JpegHuffmanTableConfig(@class: 0, destIndex: 0, HuffmanSpec.LuminanceDC);
-        var defaultLuminanceHuffmanAC = new JpegHuffmanTableConfig(@class: 1, destIndex: 0, HuffmanSpec.LuminanceAC);
-        var defaultChrominanceHuffmanDC = new JpegHuffmanTableConfig(@class: 0, destIndex: 1, HuffmanSpec.ChrominanceDC);
-        var defaultChrominanceHuffmanAC = new JpegHuffmanTableConfig(@class: 1, destIndex: 1, HuffmanSpec.ChrominanceAC);
+        JpegHuffmanTableConfig defaultLuminanceHuffmanDC = new(@class: 0, destIndex: 0, HuffmanSpec.LuminanceDC);
+        JpegHuffmanTableConfig defaultLuminanceHuffmanAC = new(@class: 1, destIndex: 0, HuffmanSpec.LuminanceAC);
+        JpegHuffmanTableConfig defaultChrominanceHuffmanDC = new(@class: 0, destIndex: 1, HuffmanSpec.ChrominanceDC);
+        JpegHuffmanTableConfig defaultChrominanceHuffmanAC = new(@class: 1, destIndex: 1, HuffmanSpec.ChrominanceAC);
 
-        var defaultLuminanceQuantTable = new JpegQuantizationTableConfig(0, Quantization.LuminanceTable);
-        var defaultChrominanceQuantTable = new JpegQuantizationTableConfig(1, Quantization.ChrominanceTable);
+        JpegQuantizationTableConfig defaultLuminanceQuantTable = new(0, Quantization.LuminanceTable);
+        JpegQuantizationTableConfig defaultChrominanceQuantTable = new(1, Quantization.ChrominanceTable);
 
-        var yCbCrHuffmanConfigs = new JpegHuffmanTableConfig[]
+        JpegHuffmanTableConfig[] yCbCrHuffmanConfigs = new JpegHuffmanTableConfig[]
         {
             defaultLuminanceHuffmanDC,
             defaultLuminanceHuffmanAC,
@@ -29,7 +29,7 @@ internal sealed unsafe partial class JpegEncoderCore
             defaultChrominanceHuffmanAC,
         };
 
-        var yCbCrQuantTableConfigs = new JpegQuantizationTableConfig[]
+        JpegQuantizationTableConfig[] yCbCrQuantTableConfigs = new JpegQuantizationTableConfig[]
         {
             defaultLuminanceQuantTable,
             defaultChrominanceQuantTable,
@@ -38,77 +38,77 @@ internal sealed unsafe partial class JpegEncoderCore
         return new JpegFrameConfig[]
         {
             // YCbCr 4:4:4
-            new JpegFrameConfig(
+            new(
                 JpegColorSpace.YCbCr,
                 JpegColorType.YCbCrRatio444,
                 new JpegComponentConfig[]
                 {
-                    new JpegComponentConfig(id: 1, hsf: 1, vsf: 1, quantIndex: 0, dcIndex: 0, acIndex: 0),
-                    new JpegComponentConfig(id: 2, hsf: 1, vsf: 1, quantIndex: 1, dcIndex: 1, acIndex: 1),
-                    new JpegComponentConfig(id: 3, hsf: 1, vsf: 1, quantIndex: 1, dcIndex: 1, acIndex: 1),
+                    new(id: 1, hsf: 1, vsf: 1, quantIndex: 0, dcIndex: 0, acIndex: 0),
+                    new(id: 2, hsf: 1, vsf: 1, quantIndex: 1, dcIndex: 1, acIndex: 1),
+                    new(id: 3, hsf: 1, vsf: 1, quantIndex: 1, dcIndex: 1, acIndex: 1),
                 },
                 yCbCrHuffmanConfigs,
                 yCbCrQuantTableConfigs),
 
             // YCbCr 4:2:2
-            new JpegFrameConfig(
+            new(
                 JpegColorSpace.YCbCr,
                 JpegColorType.YCbCrRatio422,
                 new JpegComponentConfig[]
                 {
-                    new JpegComponentConfig(id: 1, hsf: 2, vsf: 1, quantIndex: 0, dcIndex: 0, acIndex: 0),
-                    new JpegComponentConfig(id: 2, hsf: 1, vsf: 1, quantIndex: 1, dcIndex: 1, acIndex: 1),
-                    new JpegComponentConfig(id: 3, hsf: 1, vsf: 1, quantIndex: 1, dcIndex: 1, acIndex: 1),
+                    new(id: 1, hsf: 2, vsf: 1, quantIndex: 0, dcIndex: 0, acIndex: 0),
+                    new(id: 2, hsf: 1, vsf: 1, quantIndex: 1, dcIndex: 1, acIndex: 1),
+                    new(id: 3, hsf: 1, vsf: 1, quantIndex: 1, dcIndex: 1, acIndex: 1),
                 },
                 yCbCrHuffmanConfigs,
                 yCbCrQuantTableConfigs),
 
             // YCbCr 4:2:0
-            new JpegFrameConfig(
+            new(
                 JpegColorSpace.YCbCr,
                 JpegColorType.YCbCrRatio420,
                 new JpegComponentConfig[]
                 {
-                    new JpegComponentConfig(id: 1, hsf: 2, vsf: 2, quantIndex: 0, dcIndex: 0, acIndex: 0),
-                    new JpegComponentConfig(id: 2, hsf: 1, vsf: 1, quantIndex: 1, dcIndex: 1, acIndex: 1),
-                    new JpegComponentConfig(id: 3, hsf: 1, vsf: 1, quantIndex: 1, dcIndex: 1, acIndex: 1),
+                    new(id: 1, hsf: 2, vsf: 2, quantIndex: 0, dcIndex: 0, acIndex: 0),
+                    new(id: 2, hsf: 1, vsf: 1, quantIndex: 1, dcIndex: 1, acIndex: 1),
+                    new(id: 3, hsf: 1, vsf: 1, quantIndex: 1, dcIndex: 1, acIndex: 1),
                 },
                 yCbCrHuffmanConfigs,
                 yCbCrQuantTableConfigs),
 
             // YCbCr 4:1:1
-            new JpegFrameConfig(
+            new(
                 JpegColorSpace.YCbCr,
                 JpegColorType.YCbCrRatio411,
                 new JpegComponentConfig[]
                 {
-                    new JpegComponentConfig(id: 1, hsf: 4, vsf: 1, quantIndex: 0, dcIndex: 0, acIndex: 0),
-                    new JpegComponentConfig(id: 2, hsf: 1, vsf: 1, quantIndex: 1, dcIndex: 1, acIndex: 1),
-                    new JpegComponentConfig(id: 3, hsf: 1, vsf: 1, quantIndex: 1, dcIndex: 1, acIndex: 1),
+                    new(id: 1, hsf: 4, vsf: 1, quantIndex: 0, dcIndex: 0, acIndex: 0),
+                    new(id: 2, hsf: 1, vsf: 1, quantIndex: 1, dcIndex: 1, acIndex: 1),
+                    new(id: 3, hsf: 1, vsf: 1, quantIndex: 1, dcIndex: 1, acIndex: 1),
                 },
                 yCbCrHuffmanConfigs,
                 yCbCrQuantTableConfigs),
 
             // YCbCr 4:1:0
-            new JpegFrameConfig(
+            new(
                 JpegColorSpace.YCbCr,
                 JpegColorType.YCbCrRatio410,
                 new JpegComponentConfig[]
                 {
-                    new JpegComponentConfig(id: 1, hsf: 4, vsf: 2, quantIndex: 0, dcIndex: 0, acIndex: 0),
-                    new JpegComponentConfig(id: 2, hsf: 1, vsf: 1, quantIndex: 1, dcIndex: 1, acIndex: 1),
-                    new JpegComponentConfig(id: 3, hsf: 1, vsf: 1, quantIndex: 1, dcIndex: 1, acIndex: 1),
+                    new(id: 1, hsf: 4, vsf: 2, quantIndex: 0, dcIndex: 0, acIndex: 0),
+                    new(id: 2, hsf: 1, vsf: 1, quantIndex: 1, dcIndex: 1, acIndex: 1),
+                    new(id: 3, hsf: 1, vsf: 1, quantIndex: 1, dcIndex: 1, acIndex: 1),
                 },
                 yCbCrHuffmanConfigs,
                 yCbCrQuantTableConfigs),
 
             // Luminance
-            new JpegFrameConfig(
+            new(
                 JpegColorSpace.Grayscale,
                 JpegColorType.Luminance,
                 new JpegComponentConfig[]
                 {
-                    new JpegComponentConfig(id: 0, hsf: 1, vsf: 1, quantIndex: 0, dcIndex: 0, acIndex: 0),
+                    new(id: 0, hsf: 1, vsf: 1, quantIndex: 0, dcIndex: 0, acIndex: 0),
                 },
                 new JpegHuffmanTableConfig[]
                 {
@@ -121,14 +121,14 @@ internal sealed unsafe partial class JpegEncoderCore
                 }),
 
             // Rgb
-            new JpegFrameConfig(
+            new(
                 JpegColorSpace.RGB,
                 JpegColorType.Rgb,
                 new JpegComponentConfig[]
                 {
-                    new JpegComponentConfig(id: 82, hsf: 1, vsf: 1, quantIndex: 0, dcIndex: 0, acIndex: 0),
-                    new JpegComponentConfig(id: 71, hsf: 1, vsf: 1, quantIndex: 0, dcIndex: 0, acIndex: 0),
-                    new JpegComponentConfig(id: 66, hsf: 1, vsf: 1, quantIndex: 0, dcIndex: 0, acIndex: 0),
+                    new(id: 82, hsf: 1, vsf: 1, quantIndex: 0, dcIndex: 0, acIndex: 0),
+                    new(id: 71, hsf: 1, vsf: 1, quantIndex: 0, dcIndex: 0, acIndex: 0),
+                    new(id: 66, hsf: 1, vsf: 1, quantIndex: 0, dcIndex: 0, acIndex: 0),
                 },
                 new JpegHuffmanTableConfig[]
                 {
@@ -144,15 +144,15 @@ internal sealed unsafe partial class JpegEncoderCore
             },
 
             // Cmyk
-            new JpegFrameConfig(
+            new(
                 JpegColorSpace.Cmyk,
                 JpegColorType.Cmyk,
                 new JpegComponentConfig[]
                 {
-                    new JpegComponentConfig(id: 1, hsf: 1, vsf: 1, quantIndex: 0, dcIndex: 0, acIndex: 0),
-                    new JpegComponentConfig(id: 2, hsf: 1, vsf: 1, quantIndex: 0, dcIndex: 0, acIndex: 0),
-                    new JpegComponentConfig(id: 3, hsf: 1, vsf: 1, quantIndex: 0, dcIndex: 0, acIndex: 0),
-                    new JpegComponentConfig(id: 4, hsf: 1, vsf: 1, quantIndex: 0, dcIndex: 0, acIndex: 0),
+                    new(id: 1, hsf: 1, vsf: 1, quantIndex: 0, dcIndex: 0, acIndex: 0),
+                    new(id: 2, hsf: 1, vsf: 1, quantIndex: 0, dcIndex: 0, acIndex: 0),
+                    new(id: 3, hsf: 1, vsf: 1, quantIndex: 0, dcIndex: 0, acIndex: 0),
+                    new(id: 4, hsf: 1, vsf: 1, quantIndex: 0, dcIndex: 0, acIndex: 0),
                 },
                 new JpegHuffmanTableConfig[]
                 {
@@ -168,15 +168,15 @@ internal sealed unsafe partial class JpegEncoderCore
             },
 
             // YccK
-            new JpegFrameConfig(
+            new(
                 JpegColorSpace.Ycck,
                 JpegColorType.Ycck,
                 new JpegComponentConfig[]
                 {
-                    new JpegComponentConfig(id: 1, hsf: 1, vsf: 1, quantIndex: 0, dcIndex: 0, acIndex: 0),
-                    new JpegComponentConfig(id: 2, hsf: 1, vsf: 1, quantIndex: 0, dcIndex: 0, acIndex: 0),
-                    new JpegComponentConfig(id: 3, hsf: 1, vsf: 1, quantIndex: 0, dcIndex: 0, acIndex: 0),
-                    new JpegComponentConfig(id: 4, hsf: 1, vsf: 1, quantIndex: 0, dcIndex: 0, acIndex: 0),
+                    new(id: 1, hsf: 1, vsf: 1, quantIndex: 0, dcIndex: 0, acIndex: 0),
+                    new(id: 2, hsf: 1, vsf: 1, quantIndex: 0, dcIndex: 0, acIndex: 0),
+                    new(id: 3, hsf: 1, vsf: 1, quantIndex: 0, dcIndex: 0, acIndex: 0),
+                    new(id: 4, hsf: 1, vsf: 1, quantIndex: 0, dcIndex: 0, acIndex: 0),
                 },
                 new JpegHuffmanTableConfig[]
                 {
diff --git a/src/ImageSharp/Formats/Jpeg/JpegEncoderCore.cs b/src/ImageSharp/Formats/Jpeg/JpegEncoderCore.cs
index 34028c2f83..c9f4258feb 100644
--- a/src/ImageSharp/Formats/Jpeg/JpegEncoderCore.cs
+++ b/src/ImageSharp/Formats/Jpeg/JpegEncoderCore.cs
@@ -58,7 +58,7 @@ internal sealed unsafe partial class JpegEncoderCore
         Guard.NotNull(image, nameof(image));
         Guard.NotNull(stream, nameof(stream));
 
-        if (image.Width >= JpegConstants.MaxLength || image.Height >= JpegConstants.MaxLength)
+        if (image.Width > JpegConstants.MaxLength || image.Height > JpegConstants.MaxLength)
         {
             JpegThrowHelper.ThrowDimensionsTooLarge(image.Width, image.Height);
         }
diff --git a/src/ImageSharp/Formats/Jpeg/JpegFormat.cs b/src/ImageSharp/Formats/Jpeg/JpegFormat.cs
index a07be33fc4..9d5a299817 100644
--- a/src/ImageSharp/Formats/Jpeg/JpegFormat.cs
+++ b/src/ImageSharp/Formats/Jpeg/JpegFormat.cs
@@ -15,7 +15,7 @@ public sealed class JpegFormat : IImageFormat<JpegMetadata>
     /// <summary>
     /// Gets the shared instance.
     /// </summary>
-    public static JpegFormat Instance { get; } = new JpegFormat();
+    public static JpegFormat Instance { get; } = new();
 
     /// <inheritdoc/>
     public string Name => "JPEG";
diff --git a/src/ImageSharp/Formats/Jpeg/JpegMetadata.cs b/src/ImageSharp/Formats/Jpeg/JpegMetadata.cs
index fe4855dc77..c620079bf8 100644
--- a/src/ImageSharp/Formats/Jpeg/JpegMetadata.cs
+++ b/src/ImageSharp/Formats/Jpeg/JpegMetadata.cs
@@ -1,6 +1,7 @@
 // Copyright (c) Six Labors.
 // Licensed under the Six Labors Split License.
 
+using System.Numerics;
 using SixLabors.ImageSharp.Formats.Jpeg.Components;
 using SixLabors.ImageSharp.PixelFormats;
 
@@ -200,7 +201,7 @@ public class JpegMetadata : IFormatMetadata<JpegMetadata>
         };
 
     /// <inheritdoc/>
-    public void AfterImageApply<TPixel>(Image<TPixel> destination)
+    public void AfterImageApply<TPixel>(Image<TPixel> destination, Matrix4x4 matrix)
         where TPixel : unmanaged, IPixel<TPixel>
     {
     }
diff --git a/src/ImageSharp/Formats/Pbm/PbmConstants.cs b/src/ImageSharp/Formats/Pbm/PbmConstants.cs
index fe0088c3ce..4a3a444978 100644
--- a/src/ImageSharp/Formats/Pbm/PbmConstants.cs
+++ b/src/ImageSharp/Formats/Pbm/PbmConstants.cs
@@ -16,10 +16,10 @@ internal static class PbmConstants
     /// <summary>
     /// The list of mimetypes that equate to a ppm.
     /// </summary>
-    public static readonly IEnumerable<string> MimeTypes = new[] { "image/x-portable-pixmap", "image/x-portable-anymap" };
+    public static readonly IEnumerable<string> MimeTypes = ["image/x-portable-pixmap", "image/x-portable-anymap"];
 
     /// <summary>
     /// The list of file extensions that equate to a ppm.
     /// </summary>
-    public static readonly IEnumerable<string> FileExtensions = new[] { "ppm", "pbm", "pgm" };
+    public static readonly IEnumerable<string> FileExtensions = ["ppm", "pbm", "pgm"];
 }
diff --git a/src/ImageSharp/Formats/Pbm/PbmDecoderCore.cs b/src/ImageSharp/Formats/Pbm/PbmDecoderCore.cs
index 9d3dd3ea4c..989eadda7a 100644
--- a/src/ImageSharp/Formats/Pbm/PbmDecoderCore.cs
+++ b/src/ImageSharp/Formats/Pbm/PbmDecoderCore.cs
@@ -80,7 +80,7 @@ internal sealed class PbmDecoderCore : ImageDecoderCore
     {
         this.ProcessHeader(stream);
         return new ImageInfo(
-            new(this.pixelSize.Width, this.pixelSize.Height),
+            new Size(this.pixelSize.Width, this.pixelSize.Height),
             this.metadata);
     }
 
diff --git a/src/ImageSharp/Formats/Pbm/PbmMetadata.cs b/src/ImageSharp/Formats/Pbm/PbmMetadata.cs
index d852f3c8eb..bef5da6054 100644
--- a/src/ImageSharp/Formats/Pbm/PbmMetadata.cs
+++ b/src/ImageSharp/Formats/Pbm/PbmMetadata.cs
@@ -1,6 +1,7 @@
 // Copyright (c) Six Labors.
 // Licensed under the Six Labors Split License.
 
+using System.Numerics;
 using SixLabors.ImageSharp.PixelFormats;
 
 namespace SixLabors.ImageSharp.Formats.Pbm;
@@ -130,7 +131,7 @@ public class PbmMetadata : IFormatMetadata<PbmMetadata>
         };
 
     /// <inheritdoc/>
-    public void AfterImageApply<TPixel>(Image<TPixel> destination)
+    public void AfterImageApply<TPixel>(Image<TPixel> destination, Matrix4x4 matrix)
         where TPixel : unmanaged, IPixel<TPixel>
     {
     }
diff --git a/src/ImageSharp/Formats/Png/Adam7.cs b/src/ImageSharp/Formats/Png/Adam7.cs
index 8310ca64c8..5da2fdd2e7 100644
--- a/src/ImageSharp/Formats/Png/Adam7.cs
+++ b/src/ImageSharp/Formats/Png/Adam7.cs
@@ -13,22 +13,22 @@ internal static class Adam7
     /// <summary>
     /// The amount to increment when processing each column per scanline for each interlaced pass.
     /// </summary>
-    public static readonly int[] ColumnIncrement = { 8, 8, 4, 4, 2, 2, 1 };
+    public static readonly int[] ColumnIncrement = [8, 8, 4, 4, 2, 2, 1];
 
     /// <summary>
     /// The index to start at when processing each column per scanline for each interlaced pass.
     /// </summary>
-    public static readonly int[] FirstColumn = { 0, 4, 0, 2, 0, 1, 0 };
+    public static readonly int[] FirstColumn = [0, 4, 0, 2, 0, 1, 0];
 
     /// <summary>
     /// The index to start at when processing each row per scanline for each interlaced pass.
     /// </summary>
-    public static readonly int[] FirstRow = { 0, 0, 4, 0, 2, 0, 1 };
+    public static readonly int[] FirstRow = [0, 0, 4, 0, 2, 0, 1];
 
     /// <summary>
     /// The amount to increment when processing each row per scanline for each interlaced pass.
     /// </summary>
-    public static readonly int[] RowIncrement = { 8, 8, 8, 4, 4, 2, 2 };
+    public static readonly int[] RowIncrement = [8, 8, 8, 4, 4, 2, 2];
 
     /// <summary>
     /// Gets the width of the block.
diff --git a/src/ImageSharp/Formats/Png/PngConstants.cs b/src/ImageSharp/Formats/Png/PngConstants.cs
index 43f2b0fb25..17d13e86df 100644
--- a/src/ImageSharp/Formats/Png/PngConstants.cs
+++ b/src/ImageSharp/Formats/Png/PngConstants.cs
@@ -28,12 +28,12 @@ internal static class PngConstants
     /// <summary>
     /// The list of mimetypes that equate to a Png.
     /// </summary>
-    public static readonly IEnumerable<string> MimeTypes = new[] { "image/png", "image/apng" };
+    public static readonly IEnumerable<string> MimeTypes = ["image/png", "image/apng"];
 
     /// <summary>
     /// The list of file extensions that equate to a Png.
     /// </summary>
-    public static readonly IEnumerable<string> FileExtensions = new[] { "png", "apng" };
+    public static readonly IEnumerable<string> FileExtensions = ["png", "apng"];
 
     /// <summary>
     /// The header bytes as a big-endian coded ulong.
@@ -45,11 +45,11 @@ internal static class PngConstants
     /// </summary>
     public static readonly Dictionary<PngColorType, byte[]> ColorTypes = new()
     {
-        [PngColorType.Grayscale] = new byte[] { 1, 2, 4, 8, 16 },
-        [PngColorType.Rgb] = new byte[] { 8, 16 },
-        [PngColorType.Palette] = new byte[] { 1, 2, 4, 8 },
-        [PngColorType.GrayscaleWithAlpha] = new byte[] { 8, 16 },
-        [PngColorType.RgbWithAlpha] = new byte[] { 8, 16 }
+        [PngColorType.Grayscale] = [1, 2, 4, 8, 16],
+        [PngColorType.Rgb] = [8, 16],
+        [PngColorType.Palette] = [1, 2, 4, 8],
+        [PngColorType.GrayscaleWithAlpha] = [8, 16],
+        [PngColorType.RgbWithAlpha] = [8, 16]
     };
 
     /// <summary>
@@ -65,8 +65,8 @@ internal static class PngConstants
     /// <summary>
     /// Gets the header bytes identifying a Png.
     /// </summary>
-    public static ReadOnlySpan<byte> HeaderBytes => new byte[]
-    {
+    public static ReadOnlySpan<byte> HeaderBytes =>
+    [
         0x89, // Set the high bit.
         0x50, // P
         0x4E, // N
@@ -75,13 +75,13 @@ internal static class PngConstants
         0x0A, // Line ending CRLF
         0x1A, // EOF
         0x0A // LF
-    };
+    ];
 
     /// <summary>
     /// Gets the keyword of the XMP metadata, encoded in an iTXT chunk.
     /// </summary>
-    public static ReadOnlySpan<byte> XmpKeyword => new[]
-    {
+    public static ReadOnlySpan<byte> XmpKeyword =>
+    [
         (byte)'X',
         (byte)'M',
         (byte)'L',
@@ -99,5 +99,5 @@ internal static class PngConstants
         (byte)'x',
         (byte)'m',
         (byte)'p'
-    };
+    ];
 }
diff --git a/src/ImageSharp/Formats/Png/PngDecoder.cs b/src/ImageSharp/Formats/Png/PngDecoder.cs
index cfea0e6020..df3995294e 100644
--- a/src/ImageSharp/Formats/Png/PngDecoder.cs
+++ b/src/ImageSharp/Formats/Png/PngDecoder.cs
@@ -25,7 +25,7 @@ public sealed class PngDecoder : SpecializedImageDecoder<PngDecoderOptions>
         Guard.NotNull(options, nameof(options));
         Guard.NotNull(stream, nameof(stream));
 
-        return new PngDecoderCore(new PngDecoderOptions() { GeneralOptions = options }).Identify(options.Configuration, stream, cancellationToken);
+        return new PngDecoderCore(new PngDecoderOptions { GeneralOptions = options }).Identify(options.Configuration, stream, cancellationToken);
     }
 
     /// <inheritdoc/>
diff --git a/src/ImageSharp/Formats/Png/PngDecoderCore.cs b/src/ImageSharp/Formats/Png/PngDecoderCore.cs
index 484241d52f..38f964d37b 100644
--- a/src/ImageSharp/Formats/Png/PngDecoderCore.cs
+++ b/src/ImageSharp/Formats/Png/PngDecoderCore.cs
@@ -131,6 +131,11 @@ internal sealed class PngDecoderCore : ImageDecoderCore
     /// </summary>
     private readonly int maxUncompressedLength;
 
+    /// <summary>
+    /// A value indicating whether the image data has been read.
+    /// </summary>
+    private bool hasImageData;
+
     /// <summary>
     /// Initializes a new instance of the <see cref="PngDecoderCore"/> class.
     /// </summary>
@@ -243,7 +248,7 @@ internal sealed class PngDecoderCore : ImageDecoderCore
                             break;
                         case PngChunkType.Data:
                             pngMetadata.AnimateRootFrame = currentFrameControl != null;
-                            currentFrameControl ??= new((uint)this.header.Width, (uint)this.header.Height);
+                            currentFrameControl ??= new FrameControl((uint)this.header.Width, (uint)this.header.Height);
                             if (image is null)
                             {
                                 this.InitializeImage(metadata, currentFrameControl.Value, out image);
@@ -428,7 +433,7 @@ internal sealed class PngDecoderCore : ImageDecoderCore
                             }
 
                             pngMetadata.AnimateRootFrame = currentFrameControl != null;
-                            currentFrameControl ??= new((uint)this.header.Width, (uint)this.header.Height);
+                            currentFrameControl ??= new FrameControl((uint)this.header.Width, (uint)this.header.Height);
                             if (framesMetadata.Count == 0)
                             {
                                 InitializeFrameMetadata(framesMetadata, currentFrameControl.Value);
@@ -520,7 +525,7 @@ internal sealed class PngDecoderCore : ImageDecoderCore
                 PngThrowHelper.ThrowInvalidHeader();
             }
 
-            return new ImageInfo(new(this.header.Width, this.header.Height), metadata, framesMetadata);
+            return new ImageInfo(new Size(this.header.Width, this.header.Height), metadata, framesMetadata);
         }
         finally
         {
@@ -749,7 +754,11 @@ internal sealed class PngDecoderCore : ImageDecoderCore
         where TPixel : unmanaged, IPixel<TPixel>
     {
         using ZlibInflateStream inflateStream = new(this.currentStream, getData);
-        inflateStream.AllocateNewBytes(chunkLength, true);
+        if (!inflateStream.AllocateNewBytes(chunkLength, !this.hasImageData))
+        {
+            return;
+        }
+
         DeflateStream dataStream = inflateStream.CompressedStream!;
 
         if (this.header.InterlaceMethod is PngInterlaceMode.Adam7)
@@ -803,7 +812,7 @@ internal sealed class PngDecoderCore : ImageDecoderCore
                 int bytesRead = compressedStream.Read(scanSpan, currentRowBytesRead, bytesPerFrameScanline - currentRowBytesRead);
                 if (bytesRead <= 0)
                 {
-                    return;
+                    goto EXIT;
                 }
 
                 currentRowBytesRead += bytesRead;
@@ -848,6 +857,7 @@ internal sealed class PngDecoderCore : ImageDecoderCore
         }
 
         EXIT:
+        this.hasImageData = true;
         blendMemory?.Dispose();
     }
 
@@ -906,7 +916,7 @@ internal sealed class PngDecoderCore : ImageDecoderCore
                     int bytesRead = compressedStream.Read(this.scanline.GetSpan(), currentRowBytesRead, bytesPerInterlaceScanline - currentRowBytesRead);
                     if (bytesRead <= 0)
                     {
-                        return;
+                        goto EXIT;
                     }
 
                     currentRowBytesRead += bytesRead;
@@ -979,6 +989,7 @@ internal sealed class PngDecoderCore : ImageDecoderCore
         }
 
         EXIT:
+        this.hasImageData = true;
         blendMemory?.Dispose();
     }
 
@@ -1086,7 +1097,7 @@ internal sealed class PngDecoderCore : ImageDecoderCore
             {
                 PixelBlender<TPixel> blender =
                     PixelOperations<TPixel>.Instance.GetPixelBlender(PixelColorBlendingMode.Normal, PixelAlphaCompositionMode.SrcOver);
-                blender.Blend<TPixel>(this.configuration, destination, destination, rowSpan, 1f);
+                blender.Blend<TPixel>(this.configuration, destination, destination, rowSpan, 1F);
             }
         }
         finally
@@ -1208,7 +1219,7 @@ internal sealed class PngDecoderCore : ImageDecoderCore
             {
                 PixelBlender<TPixel> blender =
                     PixelOperations<TPixel>.Instance.GetPixelBlender(PixelColorBlendingMode.Normal, PixelAlphaCompositionMode.SrcOver);
-                blender.Blend<TPixel>(this.configuration, destination, destination, rowSpan, 1f);
+                blender.Blend<TPixel>(this.configuration, destination, destination, rowSpan, 1F);
             }
         }
         finally
@@ -1332,7 +1343,7 @@ internal sealed class PngDecoderCore : ImageDecoderCore
         pngMetadata.InterlaceMethod = this.header.InterlaceMethod;
 
         this.pngColorType = this.header.ColorType;
-        this.Dimensions = new(this.header.Width, this.header.Height);
+        this.Dimensions = new Size(this.header.Width, this.header.Height);
     }
 
     /// <summary>
@@ -1866,6 +1877,9 @@ internal sealed class PngDecoderCore : ImageDecoderCore
             return false;
         }
 
+        // Capture the current position so we can revert back to it if we fail to read a valid chunk.
+        long position = this.currentStream.Position;
+
         if (!this.TryReadChunkLength(buffer, out int length))
         {
             // IEND
@@ -1884,7 +1898,48 @@ internal sealed class PngDecoderCore : ImageDecoderCore
             }
         }
 
-        PngChunkType type = this.ReadChunkType(buffer);
+        PngChunkType type;
+
+        // Loop until we get a chunk type that is valid.
+        while (true)
+        {
+            type = this.ReadChunkType(buffer);
+            if (!IsValidChunkType(type))
+            {
+                // The chunk type is invalid.
+                // Revert back to the next byte past the previous position and try again.
+                this.currentStream.Position = ++position;
+
+                // If we are now at the end of the stream, we're done.
+                if (this.currentStream.Position >= this.currentStream.Length)
+                {
+                    chunk = default;
+                    return false;
+                }
+
+                // Read the next chunk’s length.
+                if (!this.TryReadChunkLength(buffer, out length))
+                {
+                    chunk = default;
+                    return false;
+                }
+
+                while (length < 0)
+                {
+                    if (!this.TryReadChunkLength(buffer, out length))
+                    {
+                        chunk = default;
+                        return false;
+                    }
+                }
+
+                // Continue to try reading the next chunk.
+                continue;
+            }
+
+            // We have a valid chunk type.
+            break;
+        }
 
         // If we're reading color metadata only we're only interested in the IHDR and tRNS chunks.
         // We can skip most other chunk data in the stream for better performance.
@@ -1901,7 +1956,7 @@ internal sealed class PngDecoderCore : ImageDecoderCore
 
         // A chunk might report a length that exceeds the length of the stream.
         // Take the minimum of the two values to ensure we don't read past the end of the stream.
-        long position = this.currentStream.Position;
+        position = this.currentStream.Position;
         chunk = new PngChunk(
             length: (int)Math.Min(length, this.currentStream.Length - position),
             type: type,
@@ -1919,6 +1974,32 @@ internal sealed class PngDecoderCore : ImageDecoderCore
         return true;
     }
 
+    /// <summary>
+    /// Determines whether the 4-byte chunk type is valid (all ASCII letters).
+    /// </summary>
+    /// <param name="type">The chunk type.</param>
+    [MethodImpl(InliningOptions.ShortMethod)]
+    private static bool IsValidChunkType(PngChunkType type)
+    {
+        uint value = (uint)type;
+        byte b0 = (byte)(value >> 24);
+        byte b1 = (byte)(value >> 16);
+        byte b2 = (byte)(value >> 8);
+        byte b3 = (byte)value;
+        return IsAsciiLetter(b0) && IsAsciiLetter(b1) && IsAsciiLetter(b2) && IsAsciiLetter(b3);
+    }
+
+    /// <summary>
+    /// Returns a value indicating whether the given byte is an ASCII letter.
+    /// </summary>
+    /// <param name="b">The byte to check.</param>
+    /// <returns>
+    /// <see langword="true"/> if the byte is an ASCII letter; otherwise, <see langword="false"/>.
+    /// </returns>
+    [MethodImpl(InliningOptions.ShortMethod)]
+    private static bool IsAsciiLetter(byte b)
+        => (b >= (byte)'A' && b <= (byte)'Z') || (b >= (byte)'a' && b <= (byte)'z');
+
     /// <summary>
     /// Validates the png chunk.
     /// </summary>
diff --git a/src/ImageSharp/Formats/Png/PngDecoderOptions.cs b/src/ImageSharp/Formats/Png/PngDecoderOptions.cs
index a73db87774..e4aeded157 100644
--- a/src/ImageSharp/Formats/Png/PngDecoderOptions.cs
+++ b/src/ImageSharp/Formats/Png/PngDecoderOptions.cs
@@ -9,7 +9,7 @@ namespace SixLabors.ImageSharp.Formats.Png;
 public sealed class PngDecoderOptions : ISpecializedDecoderOptions
 {
     /// <inheritdoc/>
-    public DecoderOptions GeneralOptions { get; init; } = new DecoderOptions();
+    public DecoderOptions GeneralOptions { get; init; } = new();
 
     /// <summary>
     /// Gets the maximum memory in bytes that a zTXt, sPLT, iTXt, iCCP, or unknown chunk can occupy when decompressed.
diff --git a/src/ImageSharp/Formats/Png/PngEncoder.cs b/src/ImageSharp/Formats/Png/PngEncoder.cs
index 63e675b505..b6031c1640 100644
--- a/src/ImageSharp/Formats/Png/PngEncoder.cs
+++ b/src/ImageSharp/Formats/Png/PngEncoder.cs
@@ -1,8 +1,6 @@
 // Copyright (c) Six Labors.
 // Licensed under the Six Labors Split License.
 
-using SixLabors.ImageSharp.Processing.Processors.Quantization;
-
 namespace SixLabors.ImageSharp.Formats.Png;
 
 /// <summary>
@@ -10,16 +8,6 @@ namespace SixLabors.ImageSharp.Formats.Png;
 /// </summary>
 public class PngEncoder : QuantizingAnimatedImageEncoder
 {
-    /// <summary>
-    /// Initializes a new instance of the <see cref="PngEncoder"/> class.
-    /// </summary>
-    public PngEncoder()
-
-        // Hack. TODO: Investigate means to fix/optimize the Wu quantizer.
-        // The Wu quantizer does not handle the default sampling strategy well for some larger images.
-        // It's expensive and the results are not better than the extensive strategy.
-        => this.PixelSamplingStrategy = new ExtensivePixelSamplingStrategy();
-
     /// <summary>
     /// Gets the number of bits per sample or per palette index (not per pixel).
     /// Not all values are allowed for all <see cref="ColorType" /> values.
@@ -53,11 +41,6 @@ public class PngEncoder : QuantizingAnimatedImageEncoder
     /// <value>The gamma value of the image.</value>
     public float? Gamma { get; init; }
 
-    /// <summary>
-    /// Gets the transparency threshold.
-    /// </summary>
-    public byte Threshold { get; init; } = byte.MaxValue;
-
     /// <summary>
     /// Gets a value indicating whether this instance should write an Adam7 interlaced image.
     /// </summary>
diff --git a/src/ImageSharp/Formats/Png/PngEncoderCore.cs b/src/ImageSharp/Formats/Png/PngEncoderCore.cs
index ea36d9fe1e..2b01affea2 100644
--- a/src/ImageSharp/Formats/Png/PngEncoderCore.cs
+++ b/src/ImageSharp/Formats/Png/PngEncoderCore.cs
@@ -3,8 +3,8 @@
 
 using System.Buffers;
 using System.Buffers.Binary;
+using System.Diagnostics.CodeAnalysis;
 using System.IO.Hashing;
-using System.Numerics;
 using System.Runtime.CompilerServices;
 using System.Runtime.InteropServices;
 using System.Runtime.Intrinsics;
@@ -119,18 +119,13 @@ internal sealed class PngEncoderCore : IDisposable
     /// </summary>
     private IQuantizer? quantizer;
 
-    /// <summary>
-    /// Any explicit quantized transparent index provided by the background color.
-    /// </summary>
-    private int derivedTransparencyIndex = -1;
-
     /// <summary>
     /// The default background color of the canvas when animating.
     /// This color may be used to fill the unused space on the canvas around the frames,
     /// as well as the transparent pixels of the first frame.
     /// The background color is also used when a frame disposal mode is <see cref="FrameDisposalMode.RestoreToBackground"/>.
     /// </summary>
-    private readonly Color? backgroundColor;
+    private Color? backgroundColor;
 
     /// <summary>
     /// The number of times any animation is repeated.
@@ -158,7 +153,6 @@ internal sealed class PngEncoderCore : IDisposable
         this.memoryAllocator = configuration.MemoryAllocator;
         this.encoder = encoder;
         this.quantizer = encoder.Quantizer;
-        this.backgroundColor = encoder.BackgroundColor;
         this.repeatCount = encoder.RepeatCount;
         this.animateRootFrame = encoder.AnimateRootFrame;
     }
@@ -187,74 +181,95 @@ internal sealed class PngEncoderCore : IDisposable
 
         ImageFrame<TPixel>? clonedFrame = null;
         ImageFrame<TPixel> currentFrame = image.Frames.RootFrame;
-        int currentFrameIndex = 0;
+        IndexedImageFrame<TPixel>? quantized = null;
+        PaletteQuantizer<TPixel>? paletteQuantizer = null;
+        Buffer2DRegion<TPixel> currentFrameRegion = currentFrame.PixelBuffer.GetRegion();
 
-        bool clearTransparency = EncodingUtilities.ShouldClearTransparentPixels<TPixel>(this.encoder.TransparentColorMode);
-        if (clearTransparency)
+        try
         {
-            currentFrame = clonedFrame = currentFrame.Clone();
-            EncodingUtilities.ClearTransparentPixels(currentFrame, Color.Transparent);
-        }
+            int currentFrameIndex = 0;
 
-        // Do not move this. We require an accurate bit depth for the header chunk.
-        IndexedImageFrame<TPixel>? quantized = this.CreateQuantizedImageAndUpdateBitDepth(
-            pngMetadata,
-            currentFrame,
-            currentFrame.Bounds,
-            null);
-
-        this.WriteHeaderChunk(stream);
-        this.WriteGammaChunk(stream);
-        this.WriteCicpChunk(stream, metadata);
-        this.WriteColorProfileChunk(stream, metadata);
-        this.WritePaletteChunk(stream, quantized);
-        this.WriteTransparencyChunk(stream, pngMetadata);
-        this.WritePhysicalChunk(stream, metadata);
-        this.WriteExifChunk(stream, metadata);
-        this.WriteXmpChunk(stream, metadata);
-        this.WriteTextChunks(stream, pngMetadata);
+            bool clearTransparency = EncodingUtilities.ShouldReplaceTransparentPixels<TPixel>(this.encoder.TransparentColorMode);
 
-        if (image.Frames.Count > 1)
-        {
-            this.WriteAnimationControlChunk(
-                stream,
-                (uint)(image.Frames.Count - (pngMetadata.AnimateRootFrame ? 0 : 1)),
-                this.repeatCount ?? pngMetadata.RepeatCount);
-        }
+            // No need to clone when quantizing. The quantizer will do it for us.
+            // TODO: We should really try to avoid the clone entirely.
+            if (clearTransparency && this.colorType is not PngColorType.Palette)
+            {
+                currentFrame = clonedFrame = currentFrame.Clone();
+                currentFrameRegion = currentFrame.PixelBuffer.GetRegion();
+                EncodingUtilities.ReplaceTransparentPixels(this.configuration, in currentFrameRegion);
+            }
 
-        // If the first frame isn't animated, write it as usual and skip it when writing animated frames
-        bool userAnimateRootFrame = this.animateRootFrame == true;
-        if ((!userAnimateRootFrame && !pngMetadata.AnimateRootFrame) || image.Frames.Count == 1)
-        {
-            cancellationToken.ThrowIfCancellationRequested();
-            FrameControl frameControl = new((uint)this.width, (uint)this.height);
-            this.WriteDataChunks(frameControl, currentFrame.PixelBuffer.GetRegion(), quantized, stream, false);
-            currentFrameIndex++;
-        }
+            // Do not move this. We require an accurate bit depth for the header chunk.
+            quantized = this.CreateQuantizedImageAndUpdateBitDepth(
+                pngMetadata,
+                image,
+                currentFrame,
+                currentFrame.Bounds,
+                null);
+
+            this.WriteHeaderChunk(stream);
+            this.WriteGammaChunk(stream);
+            this.WriteCicpChunk(stream, metadata);
+            this.WriteColorProfileChunk(stream, metadata);
+            this.WritePaletteChunk(stream, quantized);
+            this.WriteTransparencyChunk(stream, pngMetadata);
+            this.WritePhysicalChunk(stream, metadata);
+            this.WriteExifChunk(stream, metadata);
+            this.WriteXmpChunk(stream, metadata);
+            this.WriteTextChunks(stream, pngMetadata);
+
+            if (image.Frames.Count > 1)
+            {
+                this.WriteAnimationControlChunk(
+                    stream,
+                    (uint)(image.Frames.Count - (pngMetadata.AnimateRootFrame ? 0 : 1)),
+                    this.repeatCount ?? pngMetadata.RepeatCount);
+            }
+
+            // If the first frame isn't animated, write it as usual and skip it when writing animated frames
+            bool userAnimateRootFrame = this.animateRootFrame == true;
+            if ((!userAnimateRootFrame && !pngMetadata.AnimateRootFrame) || image.Frames.Count == 1)
+            {
+                cancellationToken.ThrowIfCancellationRequested();
+                FrameControl frameControl = new((uint)this.width, (uint)this.height);
+                this.WriteDataChunks(in frameControl, in currentFrameRegion, quantized, stream, false);
+                currentFrameIndex++;
+            }
 
-        try
-        {
             if (image.Frames.Count > 1)
             {
                 // Write the first animated frame.
                 currentFrame = image.Frames[currentFrameIndex];
+                currentFrameRegion = currentFrame.PixelBuffer.GetRegion();
+
                 PngFrameMetadata frameMetadata = currentFrame.Metadata.GetPngMetadata();
                 FrameDisposalMode previousDisposal = frameMetadata.DisposalMode;
                 FrameControl frameControl = this.WriteFrameControlChunk(stream, frameMetadata, currentFrame.Bounds, 0);
                 uint sequenceNumber = 1;
                 if (pngMetadata.AnimateRootFrame)
                 {
-                    this.WriteDataChunks(frameControl, currentFrame.PixelBuffer.GetRegion(), quantized, stream, false);
+                    this.WriteDataChunks(in frameControl, in currentFrameRegion, quantized, stream, false);
                 }
                 else
                 {
-                    sequenceNumber += this.WriteDataChunks(frameControl, currentFrame.PixelBuffer.GetRegion(), quantized, stream, true);
+                    sequenceNumber += this.WriteDataChunks(in frameControl, in currentFrameRegion, quantized, stream, true);
                 }
 
                 currentFrameIndex++;
 
                 // Capture the global palette for reuse on subsequent frames.
-                ReadOnlyMemory<TPixel>? previousPalette = quantized?.Palette.ToArray();
+                ReadOnlyMemory<TPixel> previousPalette = quantized?.Palette.ToArray();
+
+                if (!previousPalette.IsEmpty)
+                {
+                    // Use the previously derived global palette and a shared quantizer to
+                    // quantize the subsequent frames. This allows us to cache the color matching resolution.
+                    paletteQuantizer ??= new PaletteQuantizer<TPixel>(
+                        this.configuration,
+                        this.quantizer!.Options,
+                        previousPalette);
+                }
 
                 // Write following frames.
                 ImageFrame<TPixel> previousFrame = image.Frames.RootFrame;
@@ -267,13 +282,26 @@ internal sealed class PngEncoderCore : IDisposable
                     cancellationToken.ThrowIfCancellationRequested();
 
                     ImageFrame<TPixel>? prev = previousDisposal == FrameDisposalMode.RestoreToBackground ? null : previousFrame;
+
                     currentFrame = image.Frames[currentFrameIndex];
+                    currentFrameRegion = currentFrame.PixelBuffer.GetRegion();
+
                     ImageFrame<TPixel>? nextFrame = currentFrameIndex < image.Frames.Count - 1 ? image.Frames[currentFrameIndex + 1] : null;
 
                     frameMetadata = currentFrame.Metadata.GetPngMetadata();
-                    bool blend = frameMetadata.BlendMode == FrameBlendMode.Over;
+
+                    // Determine whether to blend the current frame over the existing canvas.
+                    // Blending is applied only when the blend method is 'Over' (source-over blending)
+                    // and when the frame's disposal method is not 'RestoreToPrevious', which indicates that
+                    // the frame should not permanently alter the canvas.
+                    bool blend = frameMetadata.BlendMode == FrameBlendMode.Over
+                                 && frameMetadata.DisposalMode != FrameDisposalMode.RestoreToPrevious;
+
+                    // Establish the background color for the current frame.
+                    // If the disposal method is 'RestoreToBackground', use the predefined background color;
+                    // otherwise, use transparent, as no explicit background restoration is needed.
                     Color background = frameMetadata.DisposalMode == FrameDisposalMode.RestoreToBackground
-                        ? this.backgroundColor ?? Color.Transparent
+                        ? this.backgroundColor.Value
                         : Color.Transparent;
 
                     (bool difference, Rectangle bounds) =
@@ -286,9 +314,9 @@ internal sealed class PngEncoderCore : IDisposable
                             background,
                             blend);
 
-                    if (clearTransparency)
+                    if (clearTransparency && this.colorType is not PngColorType.Palette)
                     {
-                        EncodingUtilities.ClearTransparentPixels(encodingFrame, background);
+                        EncodingUtilities.ReplaceTransparentPixels(encodingFrame);
                     }
 
                     // Each frame control sequence number must be incremented by the number of frame data chunks that follow.
@@ -296,8 +324,20 @@ internal sealed class PngEncoderCore : IDisposable
 
                     // Dispose of previous quantized frame and reassign.
                     quantized?.Dispose();
-                    quantized = this.CreateQuantizedImageAndUpdateBitDepth(pngMetadata, encodingFrame, bounds, previousPalette);
-                    sequenceNumber += this.WriteDataChunks(frameControl, encodingFrame.PixelBuffer.GetRegion(bounds), quantized, stream, true) + 1;
+
+                    quantized = this.CreateQuantizedFrame(
+                        this.encoder,
+                        this.colorType,
+                        this.bitDepth,
+                        pngMetadata,
+                        image,
+                        encodingFrame,
+                        bounds,
+                        paletteQuantizer,
+                        default);
+
+                    Buffer2DRegion<TPixel> encodingFrameRegion = encodingFrame.PixelBuffer.GetRegion(bounds);
+                    sequenceNumber += this.WriteDataChunks(in frameControl, in encodingFrameRegion, quantized, stream, true) + 1;
 
                     previousFrame = currentFrame;
                     previousDisposal = frameMetadata.DisposalMode;
@@ -313,6 +353,7 @@ internal sealed class PngEncoderCore : IDisposable
             // Dispose of allocations from final frame.
             clonedFrame?.Dispose();
             quantized?.Dispose();
+            paletteQuantizer?.Dispose();
         }
     }
 
@@ -328,18 +369,35 @@ internal sealed class PngEncoderCore : IDisposable
     /// </summary>
     /// <typeparam name="TPixel">The type of the pixel.</typeparam>
     /// <param name="metadata">The image metadata.</param>
-    /// <param name="frame">The frame to quantize.</param>
+    /// <param name="image">The image.</param>
+    /// <param name="frame">The current image frame.</param>
     /// <param name="bounds">The area of interest within the frame.</param>
-    /// <param name="previousPalette">Any previously derived palette.</param>
+    /// <param name="paletteQuantizer">The quantizer containing any previously derived palette.</param>
     /// <returns>The quantized image.</returns>
     private IndexedImageFrame<TPixel>? CreateQuantizedImageAndUpdateBitDepth<TPixel>(
         PngMetadata metadata,
+        Image<TPixel> image,
         ImageFrame<TPixel> frame,
         Rectangle bounds,
-        ReadOnlyMemory<TPixel>? previousPalette)
+        PaletteQuantizer<TPixel>? paletteQuantizer)
         where TPixel : unmanaged, IPixel<TPixel>
     {
-        IndexedImageFrame<TPixel>? quantized = this.CreateQuantizedFrame(this.encoder, this.colorType, this.bitDepth, metadata, frame, bounds, previousPalette);
+        PngFrameMetadata frameMetadata = frame.Metadata.GetPngMetadata();
+        Color background = frameMetadata.DisposalMode == FrameDisposalMode.RestoreToBackground
+            ? this.backgroundColor ?? Color.Transparent
+            : Color.Transparent;
+
+        IndexedImageFrame<TPixel>? quantized = this.CreateQuantizedFrame(
+            this.encoder,
+            this.colorType,
+            this.bitDepth,
+            metadata,
+            image,
+            frame,
+            bounds,
+            paletteQuantizer,
+            background);
+
         this.bitDepth = CalculateBitDepth(this.colorType, this.bitDepth, quantized);
         return quantized;
     }
@@ -734,11 +792,6 @@ internal sealed class PngEncoderCore : IDisposable
             byte alpha = rgba.A;
 
             Unsafe.Add(ref colorTableRef, (uint)i) = rgba.Rgb;
-            if (alpha > this.encoder.Threshold)
-            {
-                alpha = byte.MaxValue;
-            }
-
             hasAlpha = hasAlpha || alpha < byte.MaxValue;
             Unsafe.Add(ref alphaTableRef, (uint)i) = alpha;
         }
@@ -1105,7 +1158,7 @@ internal sealed class PngEncoderCore : IDisposable
     /// <param name="quantized">The quantized pixel data. Can be null.</param>
     /// <param name="stream">The stream.</param>
     /// <param name="isFrame">Is writing fdAT or IDAT.</param>
-    private uint WriteDataChunks<TPixel>(FrameControl frameControl, Buffer2DRegion<TPixel> frame, IndexedImageFrame<TPixel>? quantized, Stream stream, bool isFrame)
+    private uint WriteDataChunks<TPixel>(in FrameControl frameControl, in Buffer2DRegion<TPixel> frame, IndexedImageFrame<TPixel>? quantized, Stream stream, bool isFrame)
         where TPixel : unmanaged, IPixel<TPixel>
     {
         byte[] buffer;
@@ -1123,12 +1176,12 @@ internal sealed class PngEncoderCore : IDisposable
                     }
                     else
                     {
-                        this.EncodeAdam7Pixels(frame, deflateStream);
+                        this.EncodeAdam7Pixels(in frame, deflateStream);
                     }
                 }
                 else
                 {
-                    this.EncodePixels(frame, quantized, deflateStream);
+                    this.EncodePixels(in frame, quantized, deflateStream);
                 }
             }
 
@@ -1196,7 +1249,7 @@ internal sealed class PngEncoderCore : IDisposable
     /// <param name="pixels">The image frame pixel buffer.</param>
     /// <param name="quantized">The quantized pixels.</param>
     /// <param name="deflateStream">The deflate stream.</param>
-    private void EncodePixels<TPixel>(Buffer2DRegion<TPixel> pixels, IndexedImageFrame<TPixel>? quantized, ZlibDeflateStream deflateStream)
+    private void EncodePixels<TPixel>(in Buffer2DRegion<TPixel> pixels, IndexedImageFrame<TPixel>? quantized, ZlibDeflateStream deflateStream)
         where TPixel : unmanaged, IPixel<TPixel>
     {
         int bytesPerScanline = this.CalculateScanlineLength(pixels.Width);
@@ -1210,7 +1263,8 @@ internal sealed class PngEncoderCore : IDisposable
         Span<byte> attempt = attemptBuffer.GetSpan();
         for (int y = 0; y < pixels.Height; y++)
         {
-            this.CollectAndFilterPixelRow(pixels.DangerousGetRowSpan(y), ref filter, ref attempt, quantized, y);
+            ReadOnlySpan<TPixel> rowSpan = pixels.DangerousGetRowSpan(y);
+            this.CollectAndFilterPixelRow(rowSpan, ref filter, ref attempt, quantized, y);
             deflateStream.Write(filter);
             this.SwapScanlineBuffers();
         }
@@ -1222,7 +1276,7 @@ internal sealed class PngEncoderCore : IDisposable
     /// <typeparam name="TPixel">The type of the pixel.</typeparam>
     /// <param name="pixels">The image frame pixel buffer.</param>
     /// <param name="deflateStream">The deflate stream.</param>
-    private void EncodeAdam7Pixels<TPixel>(Buffer2DRegion<TPixel> pixels, ZlibDeflateStream deflateStream)
+    private void EncodeAdam7Pixels<TPixel>(in Buffer2DRegion<TPixel> pixels, ZlibDeflateStream deflateStream)
         where TPixel : unmanaged, IPixel<TPixel>
     {
         for (int pass = 0; pass < 7; pass++)
@@ -1258,7 +1312,8 @@ internal sealed class PngEncoderCore : IDisposable
                 // Encode data
                 // Note: quantized parameter not used
                 // Note: row parameter not used
-                this.CollectAndFilterPixelRow<TPixel>(block, ref filter, ref attempt, null, -1);
+                ReadOnlySpan<TPixel> blockSpan = block;
+                this.CollectAndFilterPixelRow(blockSpan, ref filter, ref attempt, null, -1);
                 deflateStream.Write(filter);
 
                 this.SwapScanlineBuffers();
@@ -1432,6 +1487,7 @@ internal sealed class PngEncoderCore : IDisposable
     /// <param name="pngMetadata">The PNG metadata.</param>
     /// <param name="use16Bit">if set to <c>true</c> [use16 bit].</param>
     /// <param name="bytesPerPixel">The bytes per pixel.</param>
+    [MemberNotNull(nameof(backgroundColor))]
     private void SanitizeAndSetEncoderOptions<TPixel>(
         PngEncoder encoder,
         PngMetadata pngMetadata,
@@ -1473,6 +1529,7 @@ internal sealed class PngEncoderCore : IDisposable
 
         this.interlaceMode = encoder.InterlaceMethod ?? pngMetadata.InterlaceMethod;
         this.chunkFilter = encoder.SkipMetadata ? PngChunkFilter.ExcludeAll : encoder.ChunkFilter ?? PngChunkFilter.None;
+        this.backgroundColor = encoder.BackgroundColor ?? pngMetadata.TransparentColor ?? Color.Transparent;
     }
 
     /// <summary>
@@ -1483,17 +1540,21 @@ internal sealed class PngEncoderCore : IDisposable
     /// <param name="colorType">The color type.</param>
     /// <param name="bitDepth">The bits per component.</param>
     /// <param name="metadata">The image metadata.</param>
-    /// <param name="frame">The frame to quantize.</param>
+    /// <param name="image">The image.</param>
+    /// <param name="frame">The current image frame.</param>
     /// <param name="bounds">The frame area of interest.</param>
-    /// <param name="previousPalette">Any previously derived palette.</param>
+    /// <param name="paletteQuantizer">The quantizer containing any previously derived palette.</param>
+    /// <param name="backgroundColor">The background color.</param>
     private IndexedImageFrame<TPixel>? CreateQuantizedFrame<TPixel>(
         QuantizingImageEncoder encoder,
         PngColorType colorType,
         byte bitDepth,
         PngMetadata metadata,
+        Image<TPixel> image,
         ImageFrame<TPixel> frame,
         Rectangle bounds,
-        ReadOnlyMemory<TPixel>? previousPalette)
+        PaletteQuantizer<TPixel>? paletteQuantizer,
+        Color backgroundColor)
         where TPixel : unmanaged, IPixel<TPixel>
     {
         if (colorType is not PngColorType.Palette)
@@ -1501,55 +1562,59 @@ internal sealed class PngEncoderCore : IDisposable
             return null;
         }
 
-        if (previousPalette is not null)
+        if (paletteQuantizer.HasValue)
         {
-            // Use the previously derived palette created by quantizing the root frame to quantize the current frame.
-            using PaletteQuantizer<TPixel> paletteQuantizer = new(
-                this.configuration,
-                this.quantizer!.Options,
-                previousPalette.Value,
-                this.derivedTransparencyIndex);
-            paletteQuantizer.BuildPalette(encoder.PixelSamplingStrategy, frame);
-            return paletteQuantizer.QuantizeFrame(frame, bounds);
+            return paletteQuantizer.Value.QuantizeFrame(frame, bounds);
         }
 
         // Use the metadata to determine what quantization depth to use if no quantizer has been set.
         if (this.quantizer is null)
         {
-            if (metadata.ColorTable is not null)
+            if (metadata.ColorTable?.Length > 0)
             {
                 // We can use the color data from the decoded metadata here.
                 // We avoid dithering by default to preserve the original colors.
-                ReadOnlySpan<Color> palette = metadata.ColorTable.Value.Span;
-
-                // Certain operations perform alpha premultiplication, which can cause the color to change so we
-                // must search for the transparency index in the palette.
-                // Transparent pixels are much more likely to be found at the end of a palette.
-                int index = -1;
-                for (int i = palette.Length - 1; i >= 0; i--)
-                {
-                    Vector4 instance = palette[i].ToScaledVector4();
-                    if (instance.W == 0f)
-                    {
-                        index = i;
-                        break;
-                    }
-                }
-
-                this.derivedTransparencyIndex = index;
-
-                this.quantizer = new PaletteQuantizer(metadata.ColorTable.Value, new() { Dither = null }, this.derivedTransparencyIndex);
+                QuantizerOptions options = new() { Dither = null, TransparentColorMode = encoder.TransparentColorMode };
+                this.quantizer = new PaletteQuantizer(metadata.ColorTable.Value, options);
             }
             else
             {
-                this.quantizer = new WuQuantizer(new QuantizerOptions { MaxColors = ColorNumerics.GetColorCountForBitDepth(bitDepth) });
+                // Don't use the default transparency threshold for quantization as PNG can handle multiple transparent colors.
+                // We choose a value that is close to zero so that edge cases causes by lower bit depths for the alpha channel are handled correctly.
+                QuantizerOptions options = new()
+                {
+                    TransparencyThreshold = 0,
+                    MaxColors = ColorNumerics.GetColorCountForBitDepth(bitDepth),
+                    TransparentColorMode = encoder.TransparentColorMode
+                };
+
+                this.quantizer = new WuQuantizer(options);
             }
         }
 
         // Create quantized frame returning the palette and set the bit depth.
         using IQuantizer<TPixel> frameQuantizer = this.quantizer.CreatePixelSpecificQuantizer<TPixel>(frame.Configuration);
 
-        frameQuantizer.BuildPalette(encoder.PixelSamplingStrategy, frame);
+        if (image.Frames.Count > 1)
+        {
+            // Encoding animated frames with a global palette requires a transparent pixel in the palette
+            // since we only encode the delta between frames. To ensure that we have a transparent pixel
+            // we create a fake frame with a containing only transparent pixels and add it to the palette.
+            using Buffer2D<TPixel> fake = image.Configuration.MemoryAllocator.Allocate2D<TPixel>(Math.Min(256, image.Width), Math.Min(256, image.Height));
+            TPixel backGroundPixel = backgroundColor.ToPixel<TPixel>();
+            for (int i = 0; i < fake.Height; i++)
+            {
+                fake.DangerousGetRowSpan(i).Fill(backGroundPixel);
+            }
+
+            Buffer2DRegion<TPixel> fakeRegion = fake.GetRegion();
+            frameQuantizer.AddPaletteColors(in fakeRegion);
+        }
+
+        frameQuantizer.BuildPalette(
+            encoder.PixelSamplingStrategy,
+            image);
+
         return frameQuantizer.QuantizeFrame(frame, bounds);
     }
 
diff --git a/src/ImageSharp/Formats/Png/PngFormat.cs b/src/ImageSharp/Formats/Png/PngFormat.cs
index e5852affa9..e49b89631f 100644
--- a/src/ImageSharp/Formats/Png/PngFormat.cs
+++ b/src/ImageSharp/Formats/Png/PngFormat.cs
@@ -15,7 +15,7 @@ public sealed class PngFormat : IImageFormat<PngMetadata, PngFrameMetadata>
     /// <summary>
     /// Gets the shared instance.
     /// </summary>
-    public static PngFormat Instance { get; } = new PngFormat();
+    public static PngFormat Instance { get; } = new();
 
     /// <inheritdoc/>
     public string Name => "PNG";
diff --git a/src/ImageSharp/Formats/Png/PngFrameMetadata.cs b/src/ImageSharp/Formats/Png/PngFrameMetadata.cs
index b8086cd6d1..701b9af053 100644
--- a/src/ImageSharp/Formats/Png/PngFrameMetadata.cs
+++ b/src/ImageSharp/Formats/Png/PngFrameMetadata.cs
@@ -1,6 +1,7 @@
 // Copyright (c) Six Labors.
 // Licensed under the Six Labors Split License.
 
+using System.Numerics;
 using SixLabors.ImageSharp.Formats.Png.Chunks;
 using SixLabors.ImageSharp.PixelFormats;
 
@@ -62,7 +63,7 @@ public class PngFrameMetadata : IFormatFrameMetadata<PngFrameMetadata>
     public static PngFrameMetadata FromFormatConnectingFrameMetadata(FormatConnectingFrameMetadata metadata)
         => new()
         {
-            FrameDelay = new(metadata.Duration.TotalMilliseconds / 1000),
+            FrameDelay = new Rational(metadata.Duration.TotalMilliseconds / 1000),
             DisposalMode = GetMode(metadata.DisposalMode),
             BlendMode = metadata.BlendMode,
         };
@@ -76,7 +77,7 @@ public class PngFrameMetadata : IFormatFrameMetadata<PngFrameMetadata>
             delay = 0;
         }
 
-        return new()
+        return new FormatConnectingFrameMetadata
         {
             ColorTableMode = FrameColorTableMode.Global,
             Duration = TimeSpan.FromMilliseconds(delay * 1000),
@@ -86,7 +87,7 @@ public class PngFrameMetadata : IFormatFrameMetadata<PngFrameMetadata>
     }
 
     /// <inheritdoc/>
-    public void AfterFrameApply<TPixel>(ImageFrame<TPixel> source, ImageFrame<TPixel> destination)
+    public void AfterFrameApply<TPixel>(ImageFrame<TPixel> source, ImageFrame<TPixel> destination, Matrix4x4 matrix)
         where TPixel : unmanaged, IPixel<TPixel>
     {
     }
diff --git a/src/ImageSharp/Formats/Png/PngMetadata.cs b/src/ImageSharp/Formats/Png/PngMetadata.cs
index 00cba088cb..cecdf88c9d 100644
--- a/src/ImageSharp/Formats/Png/PngMetadata.cs
+++ b/src/ImageSharp/Formats/Png/PngMetadata.cs
@@ -1,6 +1,7 @@
 // Copyright (c) Six Labors.
 // Licensed under the Six Labors Split License.
 
+using System.Numerics;
 using SixLabors.ImageSharp.Formats.Png.Chunks;
 using SixLabors.ImageSharp.PixelFormats;
 
@@ -93,25 +94,6 @@ public class PngMetadata : IFormatMetadata<PngMetadata>
     /// <inheritdoc/>
     public static PngMetadata FromFormatConnectingMetadata(FormatConnectingMetadata metadata)
     {
-        // Should the conversion be from a format that uses a 24bit palette entries (gif)
-        // we need to clone and adjust the color table to allow for transparency.
-        Color[]? colorTable = metadata.ColorTable?.ToArray();
-        if (colorTable != null)
-        {
-            for (int i = 0; i < colorTable.Length; i++)
-            {
-                ref Color c = ref colorTable[i];
-                if (c != metadata.BackgroundColor)
-                {
-                    continue;
-                }
-
-                // Png treats background as fully empty
-                c = Color.Transparent;
-                break;
-            }
-        }
-
         PngColorType color;
         PixelColorType colorType = metadata.PixelTypeInfo.ColorType;
 
@@ -148,11 +130,10 @@ public class PngMetadata : IFormatMetadata<PngMetadata>
             4 => PngBitDepth.Bit4,
             _ => (bpc <= 8) ? PngBitDepth.Bit8 : PngBitDepth.Bit16,
         };
-        return new()
+        return new PngMetadata
         {
             ColorType = color,
             BitDepth = bitDepth,
-            ColorTable = colorTable,
             RepeatCount = metadata.RepeatCount,
         };
     }
@@ -241,16 +222,31 @@ public class PngMetadata : IFormatMetadata<PngMetadata>
     public FormatConnectingMetadata ToFormatConnectingMetadata()
         => new()
         {
-            ColorTable = this.ColorTable,
             ColorTableMode = FrameColorTableMode.Global,
             PixelTypeInfo = this.GetPixelTypeInfo(),
             RepeatCount = (ushort)Numerics.Clamp(this.RepeatCount, 0, ushort.MaxValue),
         };
 
     /// <inheritdoc/>
-    public void AfterImageApply<TPixel>(Image<TPixel> destination)
+    public void AfterImageApply<TPixel>(Image<TPixel> destination, Matrix4x4 matrix)
         where TPixel : unmanaged, IPixel<TPixel>
     {
+        this.ColorTable = null;
+
+        // If the color type is RGB and we have a transparent color, we need to switch to RGBA
+        // so that we do not incorrectly preserve the obsolete tRNS chunk.
+        if (this.ColorType == PngColorType.Rgb && this.TransparentColor.HasValue)
+        {
+            this.ColorType = PngColorType.RgbWithAlpha;
+            this.TransparentColor = null;
+        }
+
+        // The same applies for Grayscale.
+        if (this.ColorType == PngColorType.Grayscale && this.TransparentColor.HasValue)
+        {
+            this.ColorType = PngColorType.GrayscaleWithAlpha;
+            this.TransparentColor = null;
+        }
     }
 
     /// <inheritdoc/>
diff --git a/src/ImageSharp/Formats/Png/PngScanlineProcessor.cs b/src/ImageSharp/Formats/Png/PngScanlineProcessor.cs
index 820fc0b5cb..33ba58f545 100644
--- a/src/ImageSharp/Formats/Png/PngScanlineProcessor.cs
+++ b/src/ImageSharp/Formats/Png/PngScanlineProcessor.cs
@@ -133,7 +133,7 @@ internal static class PngScanlineProcessor
                 ushort l = BinaryPrimitives.ReadUInt16BigEndian(scanlineSpan.Slice(o, 2));
                 ushort a = BinaryPrimitives.ReadUInt16BigEndian(scanlineSpan.Slice(o + 2, 2));
 
-                Unsafe.Add(ref rowSpanRef, (uint)x) = TPixel.FromLa32(new(l, a));
+                Unsafe.Add(ref rowSpanRef, (uint)x) = TPixel.FromLa32(new La32(l, a));
             }
         }
         else
@@ -143,7 +143,7 @@ internal static class PngScanlineProcessor
             {
                 byte l = Unsafe.Add(ref scanlineSpanRef, offset2);
                 byte a = Unsafe.Add(ref scanlineSpanRef, offset2 + bytesPerSample);
-                Unsafe.Add(ref rowSpanRef, x) = TPixel.FromLa16(new(l, a));
+                Unsafe.Add(ref rowSpanRef, x) = TPixel.FromLa16(new La16(l, a));
                 offset2 += bytesPerPixel;
             }
         }
@@ -239,7 +239,7 @@ internal static class PngScanlineProcessor
                     ushort r = BinaryPrimitives.ReadUInt16BigEndian(scanlineSpan.Slice(o, bytesPerSample));
                     ushort g = BinaryPrimitives.ReadUInt16BigEndian(scanlineSpan.Slice(o + bytesPerSample, bytesPerSample));
                     ushort b = BinaryPrimitives.ReadUInt16BigEndian(scanlineSpan.Slice(o + (2 * bytesPerSample), bytesPerSample));
-                    Unsafe.Add(ref rowSpanRef, x) = TPixel.FromRgb48(new(r, g, b));
+                    Unsafe.Add(ref rowSpanRef, x) = TPixel.FromRgb48(new Rgb48(r, g, b));
                 }
             }
             else if (pixelOffset == 0 && increment == 1)
@@ -258,7 +258,7 @@ internal static class PngScanlineProcessor
                     byte r = Unsafe.Add(ref scanlineSpanRef, (uint)o);
                     byte g = Unsafe.Add(ref scanlineSpanRef, (uint)(o + bytesPerSample));
                     byte b = Unsafe.Add(ref scanlineSpanRef, (uint)(o + (2 * bytesPerSample)));
-                    Unsafe.Add(ref rowSpanRef, x) = TPixel.FromRgb24(new(r, g, b));
+                    Unsafe.Add(ref rowSpanRef, x) = TPixel.FromRgb24(new Rgb24(r, g, b));
                 }
             }
 
@@ -339,7 +339,7 @@ internal static class PngScanlineProcessor
                 ushort g = BinaryPrimitives.ReadUInt16BigEndian(scanlineSpan.Slice(o + bytesPerSample, bytesPerSample));
                 ushort b = BinaryPrimitives.ReadUInt16BigEndian(scanlineSpan.Slice(o + (2 * bytesPerSample), bytesPerSample));
                 ushort a = BinaryPrimitives.ReadUInt16BigEndian(scanlineSpan.Slice(o + (3 * bytesPerSample), bytesPerSample));
-                Unsafe.Add(ref rowSpanRef, x) = TPixel.FromRgba64(new(r, g, b, a));
+                Unsafe.Add(ref rowSpanRef, x) = TPixel.FromRgba64(new Rgba64(r, g, b, a));
             }
         }
         else if (pixelOffset == 0 && increment == 1)
@@ -360,7 +360,7 @@ internal static class PngScanlineProcessor
                 byte g = Unsafe.Add(ref scanlineSpanRef, (uint)(o + bytesPerSample));
                 byte b = Unsafe.Add(ref scanlineSpanRef, (uint)(o + (2 * bytesPerSample)));
                 byte a = Unsafe.Add(ref scanlineSpanRef, (uint)(o + (3 * bytesPerSample)));
-                Unsafe.Add(ref rowSpanRef, x) = TPixel.FromRgba32(new(r, g, b, a));
+                Unsafe.Add(ref rowSpanRef, x) = TPixel.FromRgba32(new Rgba32(r, g, b, a));
             }
         }
     }
diff --git a/src/ImageSharp/Formats/Qoi/QoiConstants.cs b/src/ImageSharp/Formats/Qoi/QoiConstants.cs
index 9643ccef03..3c64128ee1 100644
--- a/src/ImageSharp/Formats/Qoi/QoiConstants.cs
+++ b/src/ImageSharp/Formats/Qoi/QoiConstants.cs
@@ -18,10 +18,10 @@ internal static class QoiConstants
     /// Gets the list of mimetypes that equate to a QOI.
     /// See https://github.com/phoboslab/qoi/issues/167
     /// </summary>
-    public static string[] MimeTypes { get; } = { "image/qoi", "image/x-qoi", "image/vnd.qoi" };
+    public static string[] MimeTypes { get; } = ["image/qoi", "image/x-qoi", "image/vnd.qoi"];
 
     /// <summary>
     /// Gets the list of file extensions that equate to a QOI.
     /// </summary>
-    public static string[] FileExtensions { get; } = { "qoi" };
+    public static string[] FileExtensions { get; } = ["qoi"];
 }
diff --git a/src/ImageSharp/Formats/Qoi/QoiEncoderCore.cs b/src/ImageSharp/Formats/Qoi/QoiEncoderCore.cs
index 872cec3fd0..a5e1596b37 100644
--- a/src/ImageSharp/Formats/Qoi/QoiEncoderCore.cs
+++ b/src/ImageSharp/Formats/Qoi/QoiEncoderCore.cs
@@ -90,10 +90,12 @@ internal class QoiEncoderCore
         ImageFrame<TPixel>? clonedFrame = null;
         try
         {
-            if (EncodingUtilities.ShouldClearTransparentPixels<TPixel>(this.encoder.TransparentColorMode))
+            // TODO: Try to avoid cloning the frame if possible.
+            // We should be cloning individual scanlines instead.
+            if (EncodingUtilities.ShouldReplaceTransparentPixels<TPixel>(this.encoder.TransparentColorMode))
             {
                 clonedFrame = image.Frames.RootFrame.Clone();
-                EncodingUtilities.ClearTransparentPixels(clonedFrame, Color.Transparent);
+                EncodingUtilities.ReplaceTransparentPixels(clonedFrame);
             }
 
             ImageFrame<TPixel> encodingFrame = clonedFrame ?? image.Frames.RootFrame;
diff --git a/src/ImageSharp/Formats/Qoi/QoiFormat.cs b/src/ImageSharp/Formats/Qoi/QoiFormat.cs
index ca2d7ae452..fbee2bc3f4 100644
--- a/src/ImageSharp/Formats/Qoi/QoiFormat.cs
+++ b/src/ImageSharp/Formats/Qoi/QoiFormat.cs
@@ -15,7 +15,7 @@ public sealed class QoiFormat : IImageFormat<QoiMetadata>
     /// <summary>
     /// Gets the shared instance.
     /// </summary>
-    public static QoiFormat Instance { get; } = new QoiFormat();
+    public static QoiFormat Instance { get; } = new();
 
     /// <inheritdoc/>
     public string DefaultMimeType => "image/qoi";
diff --git a/src/ImageSharp/Formats/Qoi/QoiMetadata.cs b/src/ImageSharp/Formats/Qoi/QoiMetadata.cs
index e463d511d2..46ed2f210c 100644
--- a/src/ImageSharp/Formats/Qoi/QoiMetadata.cs
+++ b/src/ImageSharp/Formats/Qoi/QoiMetadata.cs
@@ -1,6 +1,7 @@
 // Copyright (c) Six Labors.
 // Licensed under the Six Labors Split License.
 
+using System.Numerics;
 using SixLabors.ImageSharp.PixelFormats;
 
 namespace SixLabors.ImageSharp.Formats.Qoi;
@@ -89,7 +90,7 @@ public class QoiMetadata : IFormatMetadata<QoiMetadata>
         };
 
     /// <inheritdoc/>
-    public void AfterImageApply<TPixel>(Image<TPixel> destination)
+    public void AfterImageApply<TPixel>(Image<TPixel> destination, Matrix4x4 matrix)
         where TPixel : unmanaged, IPixel<TPixel>
     {
     }
diff --git a/src/ImageSharp/Formats/SpecializedImageDecoder{T}.cs b/src/ImageSharp/Formats/SpecializedImageDecoder{T}.cs
index 59fa59bb97..38bfe817dd 100644
--- a/src/ImageSharp/Formats/SpecializedImageDecoder{T}.cs
+++ b/src/ImageSharp/Formats/SpecializedImageDecoder{T}.cs
@@ -24,6 +24,7 @@ public abstract class SpecializedImageDecoder<T> : ImageDecoder, ISpecializedIma
             s => this.Decode<TPixel>(options, s, default));
 
         this.SetDecoderFormat(options.GeneralOptions.Configuration, image);
+
         return image;
     }
 
@@ -36,6 +37,7 @@ public abstract class SpecializedImageDecoder<T> : ImageDecoder, ISpecializedIma
             s => this.Decode(options, s, default));
 
         this.SetDecoderFormat(options.GeneralOptions.Configuration, image);
+
         return image;
     }
 
@@ -50,6 +52,7 @@ public abstract class SpecializedImageDecoder<T> : ImageDecoder, ISpecializedIma
             cancellationToken).ConfigureAwait(false);
 
         this.SetDecoderFormat(options.GeneralOptions.Configuration, image);
+
         return image;
     }
 
@@ -63,6 +66,7 @@ public abstract class SpecializedImageDecoder<T> : ImageDecoder, ISpecializedIma
             cancellationToken).ConfigureAwait(false);
 
         this.SetDecoderFormat(options.GeneralOptions.Configuration, image);
+
         return image;
     }
 
diff --git a/src/ImageSharp/Formats/Tga/TgaConstants.cs b/src/ImageSharp/Formats/Tga/TgaConstants.cs
index ac7d837985..c4663ac091 100644
--- a/src/ImageSharp/Formats/Tga/TgaConstants.cs
+++ b/src/ImageSharp/Formats/Tga/TgaConstants.cs
@@ -8,12 +8,12 @@ internal static class TgaConstants
     /// <summary>
     /// The list of mimetypes that equate to a targa file.
     /// </summary>
-    public static readonly IEnumerable<string> MimeTypes = new[] { "image/x-tga", "image/x-targa" };
+    public static readonly IEnumerable<string> MimeTypes = ["image/x-tga", "image/x-targa"];
 
     /// <summary>
     /// The list of file extensions that equate to a targa file.
     /// </summary>
-    public static readonly IEnumerable<string> FileExtensions = new[] { "tga", "vda", "icb", "vst" };
+    public static readonly IEnumerable<string> FileExtensions = ["tga", "vda", "icb", "vst"];
 
     /// <summary>
     /// The file header length of a tga image in bytes.
diff --git a/src/ImageSharp/Formats/Tga/TgaDecoderCore.cs b/src/ImageSharp/Formats/Tga/TgaDecoderCore.cs
index dc6b33422f..ead157986a 100644
--- a/src/ImageSharp/Formats/Tga/TgaDecoderCore.cs
+++ b/src/ImageSharp/Formats/Tga/TgaDecoderCore.cs
@@ -639,7 +639,7 @@ internal sealed class TgaDecoderCore : ImageDecoderCore
     {
         this.ReadFileHeader(stream);
         return new ImageInfo(
-            new(this.fileHeader.Width, this.fileHeader.Height),
+            new Size(this.fileHeader.Width, this.fileHeader.Height),
             this.metadata);
     }
 
diff --git a/src/ImageSharp/Formats/Tga/TgaEncoderCore.cs b/src/ImageSharp/Formats/Tga/TgaEncoderCore.cs
index e2ea9c4fe7..a587e19608 100644
--- a/src/ImageSharp/Formats/Tga/TgaEncoderCore.cs
+++ b/src/ImageSharp/Formats/Tga/TgaEncoderCore.cs
@@ -110,10 +110,12 @@ internal sealed class TgaEncoderCore
         ImageFrame<TPixel>? clonedFrame = null;
         try
         {
-            if (EncodingUtilities.ShouldClearTransparentPixels<TPixel>(this.transparentColorMode))
+            // TODO: Try to avoid cloning the frame if possible.
+            // We should be cloning individual scanlines instead.
+            if (EncodingUtilities.ShouldReplaceTransparentPixels<TPixel>(this.transparentColorMode))
             {
                 clonedFrame = image.Frames.RootFrame.Clone();
-                EncodingUtilities.ClearTransparentPixels(clonedFrame, Color.Transparent);
+                EncodingUtilities.ReplaceTransparentPixels(clonedFrame);
             }
 
             ImageFrame<TPixel> encodingFrame = clonedFrame ?? image.Frames.RootFrame;
diff --git a/src/ImageSharp/Formats/Tga/TgaFormat.cs b/src/ImageSharp/Formats/Tga/TgaFormat.cs
index e024dfc621..f5bf76fb4f 100644
--- a/src/ImageSharp/Formats/Tga/TgaFormat.cs
+++ b/src/ImageSharp/Formats/Tga/TgaFormat.cs
@@ -11,7 +11,7 @@ public sealed class TgaFormat : IImageFormat<TgaMetadata>
     /// <summary>
     /// Gets the shared instance.
     /// </summary>
-    public static TgaFormat Instance { get; } = new TgaFormat();
+    public static TgaFormat Instance { get; } = new();
 
     /// <inheritdoc/>
     public string Name => "TGA";
diff --git a/src/ImageSharp/Formats/Tga/TgaImageFormatDetector.cs b/src/ImageSharp/Formats/Tga/TgaImageFormatDetector.cs
index ad76bc3fbd..50d9920302 100644
--- a/src/ImageSharp/Formats/Tga/TgaImageFormatDetector.cs
+++ b/src/ImageSharp/Formats/Tga/TgaImageFormatDetector.cs
@@ -34,7 +34,7 @@ public sealed class TgaImageFormatDetector : IImageFormatDetector
             }
 
             // The third byte is the image type.
-            var imageType = (TgaImageType)header[2];
+            TgaImageType imageType = (TgaImageType)header[2];
             if (!imageType.IsValid())
             {
                 return false;
diff --git a/src/ImageSharp/Formats/Tga/TgaMetadata.cs b/src/ImageSharp/Formats/Tga/TgaMetadata.cs
index 8d40f86464..07aec8c3ee 100644
--- a/src/ImageSharp/Formats/Tga/TgaMetadata.cs
+++ b/src/ImageSharp/Formats/Tga/TgaMetadata.cs
@@ -1,6 +1,7 @@
 // Copyright (c) Six Labors.
 // Licensed under the Six Labors Split License.
 
+using System.Numerics;
 using SixLabors.ImageSharp.PixelFormats;
 
 namespace SixLabors.ImageSharp.Formats.Tga;
@@ -95,7 +96,7 @@ public class TgaMetadata : IFormatMetadata<TgaMetadata>
         };
 
     /// <inheritdoc/>
-    public void AfterImageApply<TPixel>(Image<TPixel> destination)
+    public void AfterImageApply<TPixel>(Image<TPixel> destination, Matrix4x4 matrix)
         where TPixel : unmanaged, IPixel<TPixel>
     {
     }
diff --git a/src/ImageSharp/Formats/Tiff/Compression/Compressors/DeflateCompressor.cs b/src/ImageSharp/Formats/Tiff/Compression/Compressors/DeflateCompressor.cs
index 6881e3a7b3..3debd373c4 100644
--- a/src/ImageSharp/Formats/Tiff/Compression/Compressors/DeflateCompressor.cs
+++ b/src/ImageSharp/Formats/Tiff/Compression/Compressors/DeflateCompressor.cs
@@ -11,7 +11,7 @@ internal sealed class DeflateCompressor : TiffBaseCompressor
 {
     private readonly DeflateCompressionLevel compressionLevel;
 
-    private readonly MemoryStream memoryStream = new MemoryStream();
+    private readonly MemoryStream memoryStream = new();
 
     public DeflateCompressor(Stream output, MemoryAllocator allocator, int width, int bitsPerPixel, TiffPredictor predictor, DeflateCompressionLevel compressionLevel)
         : base(output, allocator, width, bitsPerPixel, predictor)
@@ -29,7 +29,7 @@ internal sealed class DeflateCompressor : TiffBaseCompressor
     public override void CompressStrip(Span<byte> rows, int height)
     {
         this.memoryStream.Seek(0, SeekOrigin.Begin);
-        using (var stream = new ZlibDeflateStream(this.Allocator, this.memoryStream, this.compressionLevel))
+        using (ZlibDeflateStream stream = new(this.Allocator, this.memoryStream, this.compressionLevel))
         {
             if (this.Predictor == TiffPredictor.Horizontal)
             {
diff --git a/src/ImageSharp/Formats/Tiff/Compression/Compressors/PackBitsWriter.cs b/src/ImageSharp/Formats/Tiff/Compression/Compressors/PackBitsWriter.cs
index 1c0a473659..4229cfada5 100644
--- a/src/ImageSharp/Formats/Tiff/Compression/Compressors/PackBitsWriter.cs
+++ b/src/ImageSharp/Formats/Tiff/Compression/Compressors/PackBitsWriter.cs
@@ -101,7 +101,7 @@ internal static class PackBitsWriter
 
     private static int FindRunLength(ReadOnlySpan<byte> rowSpan, int startPos, int maxRunLength)
     {
-        var startByte = rowSpan[startPos];
+        byte startByte = rowSpan[startPos];
         int count = 1;
         for (int i = startPos + 1; i < rowSpan.Length; i++)
         {
diff --git a/src/ImageSharp/Formats/Tiff/Compression/Compressors/T6BitCompressor.cs b/src/ImageSharp/Formats/Tiff/Compression/Compressors/T6BitCompressor.cs
index 692e088d1c..cffc96fcdf 100644
--- a/src/ImageSharp/Formats/Tiff/Compression/Compressors/T6BitCompressor.cs
+++ b/src/ImageSharp/Formats/Tiff/Compression/Compressors/T6BitCompressor.cs
@@ -17,7 +17,7 @@ internal sealed class T6BitCompressor : TiffCcittCompressor
     /// Vertical codes from -3 to +3.
     /// </summary>
     private static readonly (uint Length, uint Code)[] VerticalCodes =
-    {
+    [
         (7u, 3u),
         (6u, 3u),
         (3u, 3u),
@@ -25,7 +25,7 @@ internal sealed class T6BitCompressor : TiffCcittCompressor
         (3u, 2u),
         (6u, 2u),
         (7u, 2u)
-    };
+    ];
 
     private IMemoryOwner<byte> referenceLineBuffer;
 
diff --git a/src/ImageSharp/Formats/Tiff/Compression/Compressors/TiffCcittCompressor.cs b/src/ImageSharp/Formats/Tiff/Compression/Compressors/TiffCcittCompressor.cs
index 4e04f9cf17..8e2227cba5 100644
--- a/src/ImageSharp/Formats/Tiff/Compression/Compressors/TiffCcittCompressor.cs
+++ b/src/ImageSharp/Formats/Tiff/Compression/Compressors/TiffCcittCompressor.cs
@@ -17,9 +17,9 @@ internal abstract class TiffCcittCompressor : TiffBaseCompressor
     protected const uint BlackZeroRunTermCode = 0x37;
 
     private static readonly uint[] MakeupRunLength =
-    {
+    [
         64, 128, 192, 256, 320, 384, 448, 512, 576, 640, 704, 768, 832, 896, 960, 1024, 1088, 1152, 1216, 1280, 1344, 1408, 1472, 1536, 1600, 1664, 1728, 1792, 1856, 1920, 1984, 2048, 2112, 2176, 2240, 2304, 2368, 2432, 2496, 2560
-    };
+    ];
 
     private static readonly Dictionary<uint, uint> WhiteLen4TermCodes = new()
     {
diff --git a/src/ImageSharp/Formats/Tiff/Compression/Compressors/TiffJpegCompressor.cs b/src/ImageSharp/Formats/Tiff/Compression/Compressors/TiffJpegCompressor.cs
index 08faa539a8..1ad69b2c8f 100644
--- a/src/ImageSharp/Formats/Tiff/Compression/Compressors/TiffJpegCompressor.cs
+++ b/src/ImageSharp/Formats/Tiff/Compression/Compressors/TiffJpegCompressor.cs
@@ -29,8 +29,8 @@ internal class TiffJpegCompressor : TiffBaseCompressor
         int pixelCount = rows.Length / 3;
         int width = pixelCount / height;
 
-        using var memoryStream = new MemoryStream();
-        var image = Image.LoadPixelData<Rgb24>(rows, width, height);
+        using MemoryStream memoryStream = new();
+        Image<Rgb24> image = Image.LoadPixelData<Rgb24>(rows, width, height);
         image.Save(memoryStream, new JpegEncoder()
         {
             ColorType = JpegColorType.Rgb
diff --git a/src/ImageSharp/Formats/Tiff/Compression/Decompressors/DeflateTiffCompression.cs b/src/ImageSharp/Formats/Tiff/Compression/Decompressors/DeflateTiffCompression.cs
index 27c311009c..4e176f28d7 100644
--- a/src/ImageSharp/Formats/Tiff/Compression/Decompressors/DeflateTiffCompression.cs
+++ b/src/ImageSharp/Formats/Tiff/Compression/Decompressors/DeflateTiffCompression.cs
@@ -22,6 +22,12 @@ internal sealed class DeflateTiffCompression : TiffBaseDecompressor
 
     private readonly TiffColorType colorType;
 
+    private readonly bool isTiled;
+
+    private readonly int tileWidth;
+
+    private readonly int tileHeight;
+
     /// <summary>
     /// Initializes a new instance of the <see cref="DeflateTiffCompression" /> class.
     /// </summary>
@@ -31,18 +37,24 @@ internal sealed class DeflateTiffCompression : TiffBaseDecompressor
     /// <param name="colorType">The color type of the pixel data.</param>
     /// <param name="predictor">The tiff predictor used.</param>
     /// <param name="isBigEndian">if set to <c>true</c> decodes the pixel data as big endian, otherwise as little endian.</param>
-    public DeflateTiffCompression(MemoryAllocator memoryAllocator, int width, int bitsPerPixel, TiffColorType colorType, TiffPredictor predictor, bool isBigEndian)
+    /// <param name="isTiled">Flag indicates, if the image is a tiled image.</param>
+    /// <param name="tileWidth">Number of pixels in a tile row.</param>
+    /// <param name="tileHeight">Number of rows in a tile.</param>
+    public DeflateTiffCompression(MemoryAllocator memoryAllocator, int width, int bitsPerPixel, TiffColorType colorType, TiffPredictor predictor, bool isBigEndian, bool isTiled, int tileWidth, int tileHeight)
         : base(memoryAllocator, width, bitsPerPixel, predictor)
     {
         this.colorType = colorType;
         this.isBigEndian = isBigEndian;
+        this.isTiled = isTiled;
+        this.tileWidth = tileWidth;
+        this.tileHeight = tileHeight;
     }
 
     /// <inheritdoc/>
     protected override void Decompress(BufferedReadStream stream, int byteCount, int stripHeight, Span<byte> buffer, CancellationToken cancellationToken)
     {
         long pos = stream.Position;
-        using (var deframeStream = new ZlibInflateStream(
+        using (ZlibInflateStream deframeStream = new(
             stream,
             () =>
             {
@@ -70,7 +82,15 @@ internal sealed class DeflateTiffCompression : TiffBaseDecompressor
 
         if (this.Predictor == TiffPredictor.Horizontal)
         {
-            HorizontalPredictor.Undo(buffer, this.Width, this.colorType, this.isBigEndian);
+            if (this.isTiled)
+            {
+                // When the image is tiled, undoing the horizontal predictor will be done for each tile row.
+                HorizontalPredictor.UndoTile(buffer, this.tileWidth, this.tileHeight, this.colorType, this.isBigEndian);
+            }
+            else
+            {
+                HorizontalPredictor.Undo(buffer, this.Width, this.colorType, this.isBigEndian);
+            }
         }
     }
 
diff --git a/src/ImageSharp/Formats/Tiff/Compression/Decompressors/JpegTiffCompression.cs b/src/ImageSharp/Formats/Tiff/Compression/Decompressors/JpegTiffCompression.cs
index 82b26232af..8bdbea616c 100644
--- a/src/ImageSharp/Formats/Tiff/Compression/Decompressors/JpegTiffCompression.cs
+++ b/src/ImageSharp/Formats/Tiff/Compression/Decompressors/JpegTiffCompression.cs
@@ -6,6 +6,8 @@ using SixLabors.ImageSharp.Formats.Jpeg.Components.Decoder;
 using SixLabors.ImageSharp.Formats.Tiff.Constants;
 using SixLabors.ImageSharp.IO;
 using SixLabors.ImageSharp.Memory;
+using SixLabors.ImageSharp.Metadata;
+using SixLabors.ImageSharp.Metadata.Profiles.Icc;
 using SixLabors.ImageSharp.PixelFormats;
 
 namespace SixLabors.ImageSharp.Formats.Tiff.Compression.Decompressors;
@@ -21,6 +23,8 @@ internal sealed class JpegTiffCompression : TiffBaseDecompressor
 
     private readonly TiffPhotometricInterpretation photometricInterpretation;
 
+    private readonly ImageFrameMetadata metadata;
+
     /// <summary>
     /// Initializes a new instance of the <see cref="JpegTiffCompression"/> class.
     /// </summary>
@@ -28,6 +32,7 @@ internal sealed class JpegTiffCompression : TiffBaseDecompressor
     /// <param name="memoryAllocator">The memoryAllocator to use for buffer allocations.</param>
     /// <param name="width">The image width.</param>
     /// <param name="bitsPerPixel">The bits per pixel.</param>
+    /// <param name="metadata">The image frame metadata.</param>
     /// <param name="jpegTables">The JPEG tables containing the quantization and/or Huffman tables.</param>
     /// <param name="photometricInterpretation">The photometric interpretation.</param>
     public JpegTiffCompression(
@@ -35,11 +40,13 @@ internal sealed class JpegTiffCompression : TiffBaseDecompressor
         MemoryAllocator memoryAllocator,
         int width,
         int bitsPerPixel,
+        ImageFrameMetadata metadata,
         byte[] jpegTables,
         TiffPhotometricInterpretation photometricInterpretation)
         : base(memoryAllocator, width, bitsPerPixel)
     {
         this.options = options;
+        this.metadata = metadata;
         this.jpegTables = jpegTables;
         this.photometricInterpretation = photometricInterpretation;
     }
@@ -60,7 +67,7 @@ internal sealed class JpegTiffCompression : TiffBaseDecompressor
 
     private void DecodeJpegData(BufferedReadStream stream, Span<byte> buffer, CancellationToken cancellationToken)
     {
-        using JpegDecoderCore jpegDecoder = new(this.options);
+        using JpegDecoderCore jpegDecoder = new(this.options, this.metadata.IccProfile);
         Configuration configuration = this.options.GeneralOptions.Configuration;
         switch (this.photometricInterpretation)
         {
@@ -73,13 +80,18 @@ internal sealed class JpegTiffCompression : TiffBaseDecompressor
                 jpegDecoder.LoadTables(this.jpegTables, scanDecoderGray);
                 jpegDecoder.ParseStream(stream, spectralConverterGray, cancellationToken);
 
-                using Buffer2D<L8> decompressedBuffer = spectralConverterGray.GetPixelBuffer(cancellationToken);
+                _ = this.options.GeneralOptions.TryGetIccProfileForColorConversion(
+                    jpegDecoder.Metadata?.IccProfile,
+                    out IccProfile? profile);
+
+                using Buffer2D<L8> decompressedBuffer = spectralConverterGray.GetPixelBuffer(profile, cancellationToken);
                 JpegCompressionUtils.CopyImageBytesToBuffer(spectralConverterGray.Configuration, buffer, decompressedBuffer);
                 break;
             }
 
             case TiffPhotometricInterpretation.YCbCr:
             case TiffPhotometricInterpretation.Rgb:
+            case TiffPhotometricInterpretation.Separated:
             {
                 using SpectralConverter<Rgb24> spectralConverter = new TiffJpegSpectralConverter<Rgb24>(configuration, this.photometricInterpretation);
                 HuffmanScanDecoder scanDecoder = new(stream, spectralConverter, cancellationToken);
@@ -87,7 +99,11 @@ internal sealed class JpegTiffCompression : TiffBaseDecompressor
                 jpegDecoder.LoadTables(this.jpegTables, scanDecoder);
                 jpegDecoder.ParseStream(stream, spectralConverter, cancellationToken);
 
-                using Buffer2D<Rgb24> decompressedBuffer = spectralConverter.GetPixelBuffer(cancellationToken);
+                _ = this.options.GeneralOptions.TryGetIccProfileForColorConversion(
+                    jpegDecoder.Metadata?.IccProfile,
+                    out IccProfile? profile);
+
+                using Buffer2D<Rgb24> decompressedBuffer = spectralConverter.GetPixelBuffer(profile, cancellationToken);
                 JpegCompressionUtils.CopyImageBytesToBuffer(spectralConverter.Configuration, buffer, decompressedBuffer);
                 break;
             }
diff --git a/src/ImageSharp/Formats/Tiff/Compression/Decompressors/LzwString.cs b/src/ImageSharp/Formats/Tiff/Compression/Decompressors/LzwString.cs
index 5f18fc2d73..e6895d67cd 100644
--- a/src/ImageSharp/Formats/Tiff/Compression/Decompressors/LzwString.cs
+++ b/src/ImageSharp/Formats/Tiff/Compression/Decompressors/LzwString.cs
@@ -9,7 +9,7 @@ namespace SixLabors.ImageSharp.Formats.Tiff.Compression.Decompressors;
 /// </summary>
 public class LzwString
 {
-    private static readonly LzwString Empty = new LzwString(0, 0, 0, null);
+    private static readonly LzwString Empty = new(0, 0, 0, null);
 
     private readonly LzwString previous;
     private readonly byte value;
diff --git a/src/ImageSharp/Formats/Tiff/Compression/Decompressors/LzwTiffCompression.cs b/src/ImageSharp/Formats/Tiff/Compression/Decompressors/LzwTiffCompression.cs
index 01591e138b..f00c5aa81c 100644
--- a/src/ImageSharp/Formats/Tiff/Compression/Decompressors/LzwTiffCompression.cs
+++ b/src/ImageSharp/Formats/Tiff/Compression/Decompressors/LzwTiffCompression.cs
@@ -17,6 +17,12 @@ internal sealed class LzwTiffCompression : TiffBaseDecompressor
 
     private readonly TiffColorType colorType;
 
+    private readonly bool isTiled;
+
+    private readonly int tileWidth;
+
+    private readonly int tileHeight;
+
     /// <summary>
     /// Initializes a new instance of the <see cref="LzwTiffCompression" /> class.
     /// </summary>
@@ -26,22 +32,36 @@ internal sealed class LzwTiffCompression : TiffBaseDecompressor
     /// <param name="colorType">The color type of the pixel data.</param>
     /// <param name="predictor">The tiff predictor used.</param>
     /// <param name="isBigEndian">if set to <c>true</c> decodes the pixel data as big endian, otherwise as little endian.</param>
-    public LzwTiffCompression(MemoryAllocator memoryAllocator, int width, int bitsPerPixel, TiffColorType colorType, TiffPredictor predictor, bool isBigEndian)
+    /// <param name="isTiled">Flag indicates, if the image is a tiled image.</param>
+    /// <param name="tileWidth">Number of pixels in a tile row.</param>
+    /// <param name="tileHeight">Number of rows in a tile.</param>
+    public LzwTiffCompression(MemoryAllocator memoryAllocator, int width, int bitsPerPixel, TiffColorType colorType, TiffPredictor predictor, bool isBigEndian, bool isTiled, int tileWidth, int tileHeight)
         : base(memoryAllocator, width, bitsPerPixel, predictor)
     {
         this.colorType = colorType;
         this.isBigEndian = isBigEndian;
+        this.isTiled = isTiled;
+        this.tileWidth = tileWidth;
+        this.tileHeight = tileHeight;
     }
 
     /// <inheritdoc/>
     protected override void Decompress(BufferedReadStream stream, int byteCount, int stripHeight, Span<byte> buffer, CancellationToken cancellationToken)
     {
-        var decoder = new TiffLzwDecoder(stream);
+        TiffLzwDecoder decoder = new(stream);
         decoder.DecodePixels(buffer);
 
         if (this.Predictor == TiffPredictor.Horizontal)
         {
-            HorizontalPredictor.Undo(buffer, this.Width, this.colorType, this.isBigEndian);
+            if (this.isTiled)
+            {
+                // When the image is tiled, undoing the horizontal predictor will be done for each tile row.
+                HorizontalPredictor.UndoTile(buffer, this.tileWidth, this.tileHeight, this.colorType, this.isBigEndian);
+            }
+            else
+            {
+                HorizontalPredictor.Undo(buffer, this.Width, this.colorType, this.isBigEndian);
+            }
         }
     }
 
diff --git a/src/ImageSharp/Formats/Tiff/Compression/Decompressors/ModifiedHuffmanTiffCompression.cs b/src/ImageSharp/Formats/Tiff/Compression/Decompressors/ModifiedHuffmanTiffCompression.cs
index d2dbedc9cb..ccdf9b0b7d 100644
--- a/src/ImageSharp/Formats/Tiff/Compression/Decompressors/ModifiedHuffmanTiffCompression.cs
+++ b/src/ImageSharp/Formats/Tiff/Compression/Decompressors/ModifiedHuffmanTiffCompression.cs
@@ -41,7 +41,7 @@ internal sealed class ModifiedHuffmanTiffCompression : TiffBaseDecompressor
     /// <inheritdoc/>
     protected override void Decompress(BufferedReadStream stream, int byteCount, int stripHeight, Span<byte> buffer, CancellationToken cancellationToken)
     {
-        var bitReader = new ModifiedHuffmanBitReader(stream, this.FillOrder, byteCount);
+        ModifiedHuffmanBitReader bitReader = new(stream, this.FillOrder, byteCount);
 
         buffer.Clear();
         nint bitsWritten = 0;
diff --git a/src/ImageSharp/Formats/Tiff/Compression/Decompressors/OldJpegTiffCompression.cs b/src/ImageSharp/Formats/Tiff/Compression/Decompressors/OldJpegTiffCompression.cs
index b58183ff60..c07b93af89 100644
--- a/src/ImageSharp/Formats/Tiff/Compression/Decompressors/OldJpegTiffCompression.cs
+++ b/src/ImageSharp/Formats/Tiff/Compression/Decompressors/OldJpegTiffCompression.cs
@@ -6,6 +6,8 @@ using SixLabors.ImageSharp.Formats.Jpeg.Components.Decoder;
 using SixLabors.ImageSharp.Formats.Tiff.Constants;
 using SixLabors.ImageSharp.IO;
 using SixLabors.ImageSharp.Memory;
+using SixLabors.ImageSharp.Metadata;
+using SixLabors.ImageSharp.Metadata.Profiles.Icc;
 using SixLabors.ImageSharp.PixelFormats;
 
 namespace SixLabors.ImageSharp.Formats.Tiff.Compression.Decompressors;
@@ -16,6 +18,8 @@ internal sealed class OldJpegTiffCompression : TiffBaseDecompressor
 
     private readonly uint startOfImageMarker;
 
+    private readonly ImageFrameMetadata metadata;
+
     private readonly TiffPhotometricInterpretation photometricInterpretation;
 
     public OldJpegTiffCompression(
@@ -23,12 +27,14 @@ internal sealed class OldJpegTiffCompression : TiffBaseDecompressor
         MemoryAllocator memoryAllocator,
         int width,
         int bitsPerPixel,
+        ImageFrameMetadata metadata,
         uint startOfImageMarker,
         TiffPhotometricInterpretation photometricInterpretation)
         : base(memoryAllocator, width, bitsPerPixel)
     {
         this.options = options;
         this.startOfImageMarker = startOfImageMarker;
+        this.metadata = metadata;
         this.photometricInterpretation = photometricInterpretation;
     }
 
@@ -46,7 +52,7 @@ internal sealed class OldJpegTiffCompression : TiffBaseDecompressor
 
     private void DecodeJpegData(BufferedReadStream stream, Span<byte> buffer, CancellationToken cancellationToken)
     {
-        using JpegDecoderCore jpegDecoder = new(this.options);
+        using JpegDecoderCore jpegDecoder = new(this.options, this.metadata.IccProfile);
         Configuration configuration = this.options.GeneralOptions.Configuration;
         switch (this.photometricInterpretation)
         {
@@ -57,19 +63,30 @@ internal sealed class OldJpegTiffCompression : TiffBaseDecompressor
 
                 jpegDecoder.ParseStream(stream, spectralConverterGray, cancellationToken);
 
-                using Buffer2D<L8> decompressedBuffer = spectralConverterGray.GetPixelBuffer(cancellationToken);
+                _ = this.options.GeneralOptions.TryGetIccProfileForColorConversion(
+                    jpegDecoder.Metadata?.IccProfile,
+                    out IccProfile? profile);
+
+                using Buffer2D<L8> decompressedBuffer = spectralConverterGray.GetPixelBuffer(
+                    profile,
+                    cancellationToken);
                 JpegCompressionUtils.CopyImageBytesToBuffer(spectralConverterGray.Configuration, buffer, decompressedBuffer);
                 break;
             }
 
             case TiffPhotometricInterpretation.YCbCr:
             case TiffPhotometricInterpretation.Rgb:
+            case TiffPhotometricInterpretation.Separated:
             {
                 using SpectralConverter<Rgb24> spectralConverter = new TiffOldJpegSpectralConverter<Rgb24>(configuration, this.photometricInterpretation);
 
                 jpegDecoder.ParseStream(stream, spectralConverter, cancellationToken);
 
-                using Buffer2D<Rgb24> decompressedBuffer = spectralConverter.GetPixelBuffer(cancellationToken);
+                _ = this.options.GeneralOptions.TryGetIccProfileForColorConversion(
+                    jpegDecoder.Metadata?.IccProfile,
+                    out IccProfile? profile);
+
+                using Buffer2D<Rgb24> decompressedBuffer = spectralConverter.GetPixelBuffer(profile, cancellationToken);
                 JpegCompressionUtils.CopyImageBytesToBuffer(spectralConverter.Configuration, buffer, decompressedBuffer);
                 break;
             }
diff --git a/src/ImageSharp/Formats/Tiff/Compression/Decompressors/T4TiffCompression.cs b/src/ImageSharp/Formats/Tiff/Compression/Decompressors/T4TiffCompression.cs
index 6bdcad2b81..d9e49aa754 100644
--- a/src/ImageSharp/Formats/Tiff/Compression/Decompressors/T4TiffCompression.cs
+++ b/src/ImageSharp/Formats/Tiff/Compression/Decompressors/T4TiffCompression.cs
@@ -60,7 +60,7 @@ internal sealed class T4TiffCompression : TiffBaseDecompressor
         }
 
         bool eolPadding = this.faxCompressionOptions.HasFlag(FaxCompressionOptions.EolPadding);
-        var bitReader = new T4BitReader(stream, this.FillOrder, byteCount, eolPadding);
+        T4BitReader bitReader = new(stream, this.FillOrder, byteCount, eolPadding);
 
         buffer.Clear();
         nint bitsWritten = 0;
diff --git a/src/ImageSharp/Formats/Tiff/Compression/Decompressors/T6TiffCompression.cs b/src/ImageSharp/Formats/Tiff/Compression/Decompressors/T6TiffCompression.cs
index c868fec626..2020dce479 100644
--- a/src/ImageSharp/Formats/Tiff/Compression/Decompressors/T6TiffCompression.cs
+++ b/src/ImageSharp/Formats/Tiff/Compression/Decompressors/T6TiffCompression.cs
@@ -57,9 +57,9 @@ internal sealed class T6TiffCompression : TiffBaseDecompressor
         Span<byte> scanLine = scanLineBuffer.GetSpan()[..this.width];
         Span<byte> referenceScanLineSpan = scanLineBuffer.GetSpan().Slice(this.width, this.width);
 
-        var bitReader = new T6BitReader(stream, this.FillOrder, byteCount);
+        T6BitReader bitReader = new(stream, this.FillOrder, byteCount);
 
-        var referenceScanLine = new CcittReferenceScanline(this.isWhiteZero, this.width);
+        CcittReferenceScanline referenceScanLine = new(this.isWhiteZero, this.width);
         nint bitsWritten = 0;
         for (int y = 0; y < height; y++)
         {
diff --git a/src/ImageSharp/Formats/Tiff/Compression/Decompressors/TiffJpegSpectralConverter{TPixel}.cs b/src/ImageSharp/Formats/Tiff/Compression/Decompressors/TiffJpegSpectralConverter{TPixel}.cs
index f051aaea1d..c32d1ea6b4 100644
--- a/src/ImageSharp/Formats/Tiff/Compression/Decompressors/TiffJpegSpectralConverter{TPixel}.cs
+++ b/src/ImageSharp/Formats/Tiff/Compression/Decompressors/TiffJpegSpectralConverter{TPixel}.cs
@@ -31,19 +31,30 @@ internal sealed class TiffJpegSpectralConverter<TPixel> : SpectralConverter<TPix
     /// <inheritdoc/>
     protected override JpegColorConverterBase GetColorConverter(JpegFrame frame, IRawJpegData jpegData)
     {
-        JpegColorSpace colorSpace = GetJpegColorSpaceFromPhotometricInterpretation(this.photometricInterpretation);
+        JpegColorSpace colorSpace = GetJpegColorSpace(this.photometricInterpretation, jpegData);
         return JpegColorConverterBase.GetConverter(colorSpace, frame.Precision);
     }
 
     /// <summary>
-    /// This converter must be used only for RGB and YCbCr color spaces for performance reasons.
+    /// Photometric interpretation Rgb and YCbCr will be mapped to RGB colorspace, which means the jpeg decompression will leave the data as is (no color conversion).
+    /// The color conversion will be done after the decompression. For Separated/CMYK/YCCK, the jpeg color converter will handle the color conversion,
+    /// since the jpeg color converter needs to return RGB data and cannot return 4 component data.
     /// For grayscale images <see cref="GrayJpegSpectralConverter{TPixel}"/> must be used.
     /// </summary>
-    private static JpegColorSpace GetJpegColorSpaceFromPhotometricInterpretation(TiffPhotometricInterpretation interpretation)
-        => interpretation switch
-        {
-            TiffPhotometricInterpretation.Rgb => JpegColorSpace.RGB,
-            TiffPhotometricInterpretation.YCbCr => JpegColorSpace.RGB,
-            _ => throw new InvalidImageContentException($"Invalid tiff photometric interpretation for jpeg encoding: {interpretation}"),
-        };
+    /// <param name="interpretation">
+    /// The <see cref="TiffPhotometricInterpretation"/> to convert to a <see cref="JpegColorSpace"/>.
+    /// </param>
+    /// <param name="data">
+    /// The <see cref="IRawJpegData"/> containing the color space information.
+    /// </param>
+    /// <exception cref="InvalidImageContentException">
+    /// Thrown when the <paramref name="interpretation"/> is not supported for JPEG encoding.
+    /// </exception>
+    private static JpegColorSpace GetJpegColorSpace(TiffPhotometricInterpretation interpretation, IRawJpegData data) => interpretation switch
+    {
+        TiffPhotometricInterpretation.Rgb => JpegColorSpace.RGB,
+        TiffPhotometricInterpretation.Separated => data.ColorSpace == JpegColorSpace.Ycck ? JpegColorSpace.TiffYccK : JpegColorSpace.TiffCmyk,
+        TiffPhotometricInterpretation.YCbCr => JpegColorSpace.RGB, // TODO: Why doesn't this use the YCbCr color space?
+        _ => throw new InvalidImageContentException($"Invalid TIFF photometric interpretation for JPEG encoding: {interpretation}"),
+    };
 }
diff --git a/src/ImageSharp/Formats/Tiff/Compression/Decompressors/TiffOldJpegSpectralConverter{TPixel}.cs b/src/ImageSharp/Formats/Tiff/Compression/Decompressors/TiffOldJpegSpectralConverter{TPixel}.cs
index 457c8d79cb..1e97527bc7 100644
--- a/src/ImageSharp/Formats/Tiff/Compression/Decompressors/TiffOldJpegSpectralConverter{TPixel}.cs
+++ b/src/ImageSharp/Formats/Tiff/Compression/Decompressors/TiffOldJpegSpectralConverter{TPixel}.cs
@@ -30,15 +30,16 @@ internal sealed class TiffOldJpegSpectralConverter<TPixel> : SpectralConverter<T
     /// <inheritdoc/>
     protected override JpegColorConverterBase GetColorConverter(JpegFrame frame, IRawJpegData jpegData)
     {
-        JpegColorSpace colorSpace = GetJpegColorSpaceFromPhotometricInterpretation(this.photometricInterpretation);
+        JpegColorSpace colorSpace = GetJpegColorSpaceFromPhotometricInterpretation(this.photometricInterpretation, jpegData);
         return JpegColorConverterBase.GetConverter(colorSpace, frame.Precision);
     }
 
-    private static JpegColorSpace GetJpegColorSpaceFromPhotometricInterpretation(TiffPhotometricInterpretation interpretation)
+    private static JpegColorSpace GetJpegColorSpaceFromPhotometricInterpretation(TiffPhotometricInterpretation interpretation, IRawJpegData data)
         => interpretation switch
         {
             // Like libtiff: Always treat the pixel data as YCbCr when the data is compressed with old jpeg compression.
             TiffPhotometricInterpretation.Rgb => JpegColorSpace.YCbCr,
+            TiffPhotometricInterpretation.Separated => data.ColorSpace == JpegColorSpace.Ycck ? JpegColorSpace.TiffYccK : JpegColorSpace.TiffCmyk,
             TiffPhotometricInterpretation.YCbCr => JpegColorSpace.YCbCr,
             _ => throw new InvalidImageContentException($"Invalid tiff photometric interpretation for jpeg encoding: {interpretation}"),
         };
diff --git a/src/ImageSharp/Formats/Tiff/Compression/Decompressors/WebpTiffCompression.cs b/src/ImageSharp/Formats/Tiff/Compression/Decompressors/WebpTiffCompression.cs
index 76d0bb6418..c0affc50ac 100644
--- a/src/ImageSharp/Formats/Tiff/Compression/Decompressors/WebpTiffCompression.cs
+++ b/src/ImageSharp/Formats/Tiff/Compression/Decompressors/WebpTiffCompression.cs
@@ -32,7 +32,7 @@ internal class WebpTiffCompression : TiffBaseDecompressor
     /// <inheritdoc/>
     protected override void Decompress(BufferedReadStream stream, int byteCount, int stripHeight, Span<byte> buffer, CancellationToken cancellationToken)
     {
-        using WebpDecoderCore decoder = new(new WebpDecoderOptions() { GeneralOptions = this.options });
+        using WebpDecoderCore decoder = new(new WebpDecoderOptions { GeneralOptions = this.options });
         using Image<Rgb24> image = decoder.Decode<Rgb24>(this.options.Configuration, stream, cancellationToken);
         CopyImageBytesToBuffer(buffer, image.Frames.RootFrame.PixelBuffer);
     }
diff --git a/src/ImageSharp/Formats/Tiff/Compression/HorizontalPredictor.cs b/src/ImageSharp/Formats/Tiff/Compression/HorizontalPredictor.cs
index 30a9335286..706e6a38c1 100644
--- a/src/ImageSharp/Formats/Tiff/Compression/HorizontalPredictor.cs
+++ b/src/ImageSharp/Formats/Tiff/Compression/HorizontalPredictor.cs
@@ -16,7 +16,7 @@ namespace SixLabors.ImageSharp.Formats.Tiff.Compression;
 internal static class HorizontalPredictor
 {
     /// <summary>
-    /// Inverts the horizontal prediction.
+    /// Inverts the horizontal predictor.
     /// </summary>
     /// <param name="pixelBytes">Buffer with decompressed pixel data.</param>
     /// <param name="width">The width of the image or strip.</param>
@@ -62,6 +62,126 @@ internal static class HorizontalPredictor
         }
     }
 
+    /// <summary>
+    /// Inverts the horizontal predictor for each tile row.
+    /// </summary>
+    /// <param name="pixelBytes">Buffer with decompressed pixel data for a tile.</param>
+    /// <param name="tileWidth">Tile width in pixels.</param>
+    /// <param name="tileHeight">Tile height in pixels.</param>
+    /// <param name="colorType">The color type of the pixel data.</param>
+    /// <param name="isBigEndian">If set to <c>true</c> decodes the pixel data as big endian, otherwise as little endian.</param>
+    public static void UndoTile(Span<byte> pixelBytes, int tileWidth, int tileHeight, TiffColorType colorType, bool isBigEndian)
+    {
+        for (int y = 0; y < tileHeight; y++)
+        {
+            UndoRow(pixelBytes, tileWidth, y, colorType, isBigEndian);
+        }
+    }
+
+    /// <summary>
+    /// Inverts the horizontal predictor for one row.
+    /// </summary>
+    /// <param name="pixelBytes">Buffer with decompressed pixel data.</param>
+    /// <param name="width">The width in pixels of the row.</param>
+    /// <param name="y">The row index.</param>
+    /// <param name="colorType">The color type of the pixel data.</param>
+    /// <param name="isBigEndian">If set to <c>true</c> decodes the pixel data as big endian, otherwise as little endian.</param>
+    public static void UndoRow(Span<byte> pixelBytes, int width, int y, TiffColorType colorType, bool isBigEndian)
+    {
+        switch (colorType)
+        {
+            case TiffColorType.BlackIsZero8:
+            case TiffColorType.WhiteIsZero8:
+            case TiffColorType.PaletteColor:
+                UndoGray8BitRow(pixelBytes, width, y);
+                break;
+
+            case TiffColorType.BlackIsZero16:
+            case TiffColorType.WhiteIsZero16:
+                if (isBigEndian)
+                {
+                    UndoGray16BitBigEndianRow(pixelBytes, width, y);
+                }
+                else
+                {
+                    UndoGray16BitLittleEndianRow(pixelBytes, width, y);
+                }
+
+                break;
+
+            case TiffColorType.BlackIsZero32:
+            case TiffColorType.WhiteIsZero32:
+                if (isBigEndian)
+                {
+                    UndoGray32BitBigEndianRow(pixelBytes, width, y);
+                }
+                else
+                {
+                    UndoGray32BitLittleEndianRow(pixelBytes, width, y);
+                }
+
+                break;
+
+            case TiffColorType.Rgb888:
+            case TiffColorType.CieLab:
+                UndoRgb24BitRow(pixelBytes, width, y);
+                break;
+
+            case TiffColorType.Rgba8888:
+            case TiffColorType.Cmyk:
+                UndoRgba32BitRow(pixelBytes, width, y);
+                break;
+
+            case TiffColorType.Rgb161616:
+                if (isBigEndian)
+                {
+                    UndoRgb48BitBigEndianRow(pixelBytes, width, y);
+                }
+                else
+                {
+                    UndoRgb48BitLittleEndianRow(pixelBytes, width, y);
+                }
+
+                break;
+
+            case TiffColorType.Rgba16161616:
+                if (isBigEndian)
+                {
+                    UndoRgb64BitBigEndianRow(pixelBytes, width, y);
+                }
+                else
+                {
+                    UndoRgb64BitLittleEndianRow(pixelBytes, width, y);
+                }
+
+                break;
+
+            case TiffColorType.Rgb323232:
+                if (isBigEndian)
+                {
+                    UndoRgb96BitBigEndianRow(pixelBytes, width, y);
+                }
+                else
+                {
+                    UndoRgb96BitLittleEndianRow(pixelBytes, width, y);
+                }
+
+                break;
+
+            case TiffColorType.Rgba32323232:
+                if (isBigEndian)
+                {
+                    UndoRgba128BitBigEndianRow(pixelBytes, width, y);
+                }
+                else
+                {
+                    UndoRgba128BitLittleEndianRow(pixelBytes, width, y);
+                }
+
+                break;
+        }
+    }
+
     public static void ApplyHorizontalPrediction(Span<byte> rows, int width, int bitsPerPixel)
     {
         if (bitsPerPixel == 8)
@@ -152,20 +272,64 @@ internal static class HorizontalPredictor
         }
     }
 
+    private static void UndoGray8BitRow(Span<byte> pixelBytes, int width, int y)
+    {
+        int rowBytesCount = width;
+        int height = pixelBytes.Length / rowBytesCount;
+        Span<byte> rowBytes = pixelBytes.Slice(y * rowBytesCount, rowBytesCount);
+        byte pixelValue = rowBytes[0];
+        for (int x = 1; x < width; x++)
+        {
+            pixelValue += rowBytes[x];
+            rowBytes[x] = pixelValue;
+        }
+    }
+
     private static void UndoGray8Bit(Span<byte> pixelBytes, int width)
     {
         int rowBytesCount = width;
         int height = pixelBytes.Length / rowBytesCount;
         for (int y = 0; y < height; y++)
         {
-            Span<byte> rowBytes = pixelBytes.Slice(y * rowBytesCount, rowBytesCount);
+            UndoGray8BitRow(pixelBytes, width, y);
+        }
+    }
 
-            byte pixelValue = rowBytes[0];
-            for (int x = 1; x < width; x++)
-            {
-                pixelValue += rowBytes[x];
-                rowBytes[x] = pixelValue;
-            }
+    private static void UndoGray16BitBigEndianRow(Span<byte> pixelBytes, int width, int y)
+    {
+        int rowBytesCount = width * 2;
+        int height = pixelBytes.Length / rowBytesCount;
+        int offset = 0;
+        Span<byte> rowBytes = pixelBytes.Slice(y * rowBytesCount, rowBytesCount);
+        ushort pixelValue = TiffUtilities.ConvertToUShortBigEndian(rowBytes.Slice(offset, 2));
+        offset += 2;
+
+        for (int x = 1; x < width; x++)
+        {
+            Span<byte> rowSpan = rowBytes.Slice(offset, 2);
+            ushort diff = TiffUtilities.ConvertToUShortBigEndian(rowSpan);
+            pixelValue += diff;
+            BinaryPrimitives.WriteUInt16BigEndian(rowSpan, pixelValue);
+            offset += 2;
+        }
+    }
+
+    private static void UndoGray16BitLittleEndianRow(Span<byte> pixelBytes, int width, int y)
+    {
+        int rowBytesCount = width * 2;
+        int height = pixelBytes.Length / rowBytesCount;
+        int offset = 0;
+        Span<byte> rowBytes = pixelBytes.Slice(y * rowBytesCount, rowBytesCount);
+        ushort pixelValue = TiffUtilities.ConvertToUShortLittleEndian(rowBytes.Slice(offset, 2));
+        offset += 2;
+
+        for (int x = 1; x < width; x++)
+        {
+            Span<byte> rowSpan = rowBytes.Slice(offset, 2);
+            ushort diff = TiffUtilities.ConvertToUShortLittleEndian(rowSpan);
+            pixelValue += diff;
+            BinaryPrimitives.WriteUInt16LittleEndian(rowSpan, pixelValue);
+            offset += 2;
         }
     }
 
@@ -177,42 +341,58 @@ internal static class HorizontalPredictor
         {
             for (int y = 0; y < height; y++)
             {
-                int offset = 0;
-                Span<byte> rowBytes = pixelBytes.Slice(y * rowBytesCount, rowBytesCount);
-                ushort pixelValue = TiffUtilities.ConvertToUShortBigEndian(rowBytes.Slice(offset, 2));
-                offset += 2;
-
-                for (int x = 1; x < width; x++)
-                {
-                    Span<byte> rowSpan = rowBytes.Slice(offset, 2);
-                    ushort diff = TiffUtilities.ConvertToUShortBigEndian(rowSpan);
-                    pixelValue += diff;
-                    BinaryPrimitives.WriteUInt16BigEndian(rowSpan, pixelValue);
-                    offset += 2;
-                }
+                UndoGray16BitBigEndianRow(pixelBytes, width, y);
             }
         }
         else
         {
             for (int y = 0; y < height; y++)
             {
-                int offset = 0;
-                Span<byte> rowBytes = pixelBytes.Slice(y * rowBytesCount, rowBytesCount);
-                ushort pixelValue = TiffUtilities.ConvertToUShortLittleEndian(rowBytes.Slice(offset, 2));
-                offset += 2;
-
-                for (int x = 1; x < width; x++)
-                {
-                    Span<byte> rowSpan = rowBytes.Slice(offset, 2);
-                    ushort diff = TiffUtilities.ConvertToUShortLittleEndian(rowSpan);
-                    pixelValue += diff;
-                    BinaryPrimitives.WriteUInt16LittleEndian(rowSpan, pixelValue);
-                    offset += 2;
-                }
+                UndoGray16BitLittleEndianRow(pixelBytes, width, y);
             }
         }
     }
 
+    private static void UndoGray32BitBigEndianRow(Span<byte> pixelBytes, int width, int y)
+    {
+        int rowBytesCount = width * 4;
+        int height = pixelBytes.Length / rowBytesCount;
+
+        int offset = 0;
+        Span<byte> rowBytes = pixelBytes.Slice(y * rowBytesCount, rowBytesCount);
+        uint pixelValue = TiffUtilities.ConvertToUIntBigEndian(rowBytes.Slice(offset, 4));
+        offset += 4;
+
+        for (int x = 1; x < width; x++)
+        {
+            Span<byte> rowSpan = rowBytes.Slice(offset, 4);
+            uint diff = TiffUtilities.ConvertToUIntBigEndian(rowSpan);
+            pixelValue += diff;
+            BinaryPrimitives.WriteUInt32BigEndian(rowSpan, pixelValue);
+            offset += 4;
+        }
+    }
+
+    private static void UndoGray32BitLittleEndianRow(Span<byte> pixelBytes, int width, int y)
+    {
+        int rowBytesCount = width * 4;
+        int height = pixelBytes.Length / rowBytesCount;
+
+        int offset = 0;
+        Span<byte> rowBytes = pixelBytes.Slice(y * rowBytesCount, rowBytesCount);
+        uint pixelValue = TiffUtilities.ConvertToUIntLittleEndian(rowBytes.Slice(offset, 4));
+        offset += 4;
+
+        for (int x = 1; x < width; x++)
+        {
+            Span<byte> rowSpan = rowBytes.Slice(offset, 4);
+            uint diff = TiffUtilities.ConvertToUIntLittleEndian(rowSpan);
+            pixelValue += diff;
+            BinaryPrimitives.WriteUInt32LittleEndian(rowSpan, pixelValue);
+            offset += 4;
+        }
+    }
+
     private static void UndoGray32Bit(Span<byte> pixelBytes, int width, bool isBigEndian)
     {
         int rowBytesCount = width * 4;
@@ -221,63 +401,68 @@ internal static class HorizontalPredictor
         {
             for (int y = 0; y < height; y++)
             {
-                int offset = 0;
-                Span<byte> rowBytes = pixelBytes.Slice(y * rowBytesCount, rowBytesCount);
-                uint pixelValue = TiffUtilities.ConvertToUIntBigEndian(rowBytes.Slice(offset, 4));
-                offset += 4;
-
-                for (int x = 1; x < width; x++)
-                {
-                    Span<byte> rowSpan = rowBytes.Slice(offset, 4);
-                    uint diff = TiffUtilities.ConvertToUIntBigEndian(rowSpan);
-                    pixelValue += diff;
-                    BinaryPrimitives.WriteUInt32BigEndian(rowSpan, pixelValue);
-                    offset += 4;
-                }
+                UndoGray32BitBigEndianRow(pixelBytes, width, y);
             }
         }
         else
         {
             for (int y = 0; y < height; y++)
             {
-                int offset = 0;
-                Span<byte> rowBytes = pixelBytes.Slice(y * rowBytesCount, rowBytesCount);
-                uint pixelValue = TiffUtilities.ConvertToUIntLittleEndian(rowBytes.Slice(offset, 4));
-                offset += 4;
-
-                for (int x = 1; x < width; x++)
-                {
-                    Span<byte> rowSpan = rowBytes.Slice(offset, 4);
-                    uint diff = TiffUtilities.ConvertToUIntLittleEndian(rowSpan);
-                    pixelValue += diff;
-                    BinaryPrimitives.WriteUInt32LittleEndian(rowSpan, pixelValue);
-                    offset += 4;
-                }
+                UndoGray32BitLittleEndianRow(pixelBytes, width, y);
             }
         }
     }
 
+    private static void UndoRgb24BitRow(Span<byte> pixelBytes, int width, int y)
+    {
+        int rowBytesCount = width * 3;
+        Span<byte> rowBytes = pixelBytes.Slice(y * rowBytesCount, rowBytesCount);
+        Span<Rgb24> rowRgb = MemoryMarshal.Cast<byte, Rgb24>(rowBytes)[..width];
+        ref Rgb24 rowRgbBase = ref MemoryMarshal.GetReference(rowRgb);
+        byte r = rowRgbBase.R;
+        byte g = rowRgbBase.G;
+        byte b = rowRgbBase.B;
+
+        for (int x = 1; x < rowRgb.Length; x++)
+        {
+            ref Rgb24 pixel = ref rowRgb[x];
+            r += pixel.R;
+            g += pixel.G;
+            b += pixel.B;
+            pixel = new Rgb24(r, g, b);
+        }
+    }
+
     private static void UndoRgb24Bit(Span<byte> pixelBytes, int width)
     {
         int rowBytesCount = width * 3;
         int height = pixelBytes.Length / rowBytesCount;
         for (int y = 0; y < height; y++)
         {
-            Span<byte> rowBytes = pixelBytes.Slice(y * rowBytesCount, rowBytesCount);
-            Span<Rgb24> rowRgb = MemoryMarshal.Cast<byte, Rgb24>(rowBytes)[..width];
-            ref Rgb24 rowRgbBase = ref MemoryMarshal.GetReference(rowRgb);
-            byte r = rowRgbBase.R;
-            byte g = rowRgbBase.G;
-            byte b = rowRgbBase.B;
+            UndoRgb24BitRow(pixelBytes, width, y);
+        }
+    }
 
-            for (int x = 1; x < rowRgb.Length; x++)
-            {
-                ref Rgb24 pixel = ref rowRgb[x];
-                r += pixel.R;
-                g += pixel.G;
-                b += pixel.B;
-                pixel = new Rgb24(r, g, b);
-            }
+    private static void UndoRgba32BitRow(Span<byte> pixelBytes, int width, int y)
+    {
+        int rowBytesCount = width * 4;
+
+        Span<byte> rowBytes = pixelBytes.Slice(y * rowBytesCount, rowBytesCount);
+        Span<Rgba32> rowRgb = MemoryMarshal.Cast<byte, Rgba32>(rowBytes)[..width];
+        ref Rgba32 rowRgbBase = ref MemoryMarshal.GetReference(rowRgb);
+        byte r = rowRgbBase.R;
+        byte g = rowRgbBase.G;
+        byte b = rowRgbBase.B;
+        byte a = rowRgbBase.A;
+
+        for (int x = 1; x < rowRgb.Length; x++)
+        {
+            ref Rgba32 pixel = ref rowRgb[x];
+            r += pixel.R;
+            g += pixel.G;
+            b += pixel.B;
+            a += pixel.A;
+            pixel = new Rgba32(r, g, b, a);
         }
     }
 
@@ -287,23 +472,79 @@ internal static class HorizontalPredictor
         int height = pixelBytes.Length / rowBytesCount;
         for (int y = 0; y < height; y++)
         {
-            Span<byte> rowBytes = pixelBytes.Slice(y * rowBytesCount, rowBytesCount);
-            Span<Rgba32> rowRgb = MemoryMarshal.Cast<byte, Rgba32>(rowBytes)[..width];
-            ref Rgba32 rowRgbBase = ref MemoryMarshal.GetReference(rowRgb);
-            byte r = rowRgbBase.R;
-            byte g = rowRgbBase.G;
-            byte b = rowRgbBase.B;
-            byte a = rowRgbBase.A;
+            UndoRgba32BitRow(pixelBytes, width, y);
+        }
+    }
 
-            for (int x = 1; x < rowRgb.Length; x++)
-            {
-                ref Rgba32 pixel = ref rowRgb[x];
-                r += pixel.R;
-                g += pixel.G;
-                b += pixel.B;
-                a += pixel.A;
-                pixel = new Rgba32(r, g, b, a);
-            }
+    private static void UndoRgb48BitBigEndianRow(Span<byte> pixelBytes, int width, int y)
+    {
+        int rowBytesCount = width * 6;
+        int height = pixelBytes.Length / rowBytesCount;
+
+        int offset = 0;
+        Span<byte> rowBytes = pixelBytes.Slice(y * rowBytesCount, rowBytesCount);
+        ushort r = TiffUtilities.ConvertToUShortBigEndian(rowBytes.Slice(offset, 2));
+        offset += 2;
+        ushort g = TiffUtilities.ConvertToUShortBigEndian(rowBytes.Slice(offset, 2));
+        offset += 2;
+        ushort b = TiffUtilities.ConvertToUShortBigEndian(rowBytes.Slice(offset, 2));
+        offset += 2;
+
+        for (int x = 1; x < width; x++)
+        {
+            Span<byte> rowSpan = rowBytes.Slice(offset, 2);
+            ushort deltaR = TiffUtilities.ConvertToUShortBigEndian(rowSpan);
+            r += deltaR;
+            BinaryPrimitives.WriteUInt16BigEndian(rowSpan, r);
+            offset += 2;
+
+            rowSpan = rowBytes.Slice(offset, 2);
+            ushort deltaG = TiffUtilities.ConvertToUShortBigEndian(rowSpan);
+            g += deltaG;
+            BinaryPrimitives.WriteUInt16BigEndian(rowSpan, g);
+            offset += 2;
+
+            rowSpan = rowBytes.Slice(offset, 2);
+            ushort deltaB = TiffUtilities.ConvertToUShortBigEndian(rowSpan);
+            b += deltaB;
+            BinaryPrimitives.WriteUInt16BigEndian(rowSpan, b);
+            offset += 2;
+        }
+    }
+
+    private static void UndoRgb48BitLittleEndianRow(Span<byte> pixelBytes, int width, int y)
+    {
+        int rowBytesCount = width * 6;
+        int height = pixelBytes.Length / rowBytesCount;
+
+        int offset = 0;
+        Span<byte> rowBytes = pixelBytes.Slice(y * rowBytesCount, rowBytesCount);
+        ushort r = TiffUtilities.ConvertToUShortLittleEndian(rowBytes.Slice(offset, 2));
+        offset += 2;
+        ushort g = TiffUtilities.ConvertToUShortLittleEndian(rowBytes.Slice(offset, 2));
+        offset += 2;
+        ushort b = TiffUtilities.ConvertToUShortLittleEndian(rowBytes.Slice(offset, 2));
+        offset += 2;
+
+        for (int x = 1; x < width; x++)
+        {
+            Span<byte> rowSpan = rowBytes.Slice(offset, 2);
+            ushort deltaR = TiffUtilities.ConvertToUShortLittleEndian(rowSpan);
+            r += deltaR;
+            BinaryPrimitives.WriteUInt16LittleEndian(rowSpan, r);
+            offset += 2;
+
+            rowSpan = rowBytes.Slice(offset, 2);
+            ushort deltaG = TiffUtilities.ConvertToUShortLittleEndian(rowSpan);
+            g += deltaG;
+            BinaryPrimitives.WriteUInt16LittleEndian(rowSpan, g);
+            offset += 2;
+
+            rowSpan = rowBytes.Slice(offset, 2);
+            ushort deltaB = TiffUtilities.ConvertToUShortLittleEndian(rowSpan);
+            b += deltaB;
+            BinaryPrimitives.WriteUInt16LittleEndian(rowSpan, b);
+            offset += 2;
         }
     }
 
@@ -315,74 +556,104 @@ internal static class HorizontalPredictor
         {
             for (int y = 0; y < height; y++)
             {
-                int offset = 0;
-                Span<byte> rowBytes = pixelBytes.Slice(y * rowBytesCount, rowBytesCount);
-                ushort r = TiffUtilities.ConvertToUShortBigEndian(rowBytes.Slice(offset, 2));
-                offset += 2;
-                ushort g = TiffUtilities.ConvertToUShortBigEndian(rowBytes.Slice(offset, 2));
-                offset += 2;
-                ushort b = TiffUtilities.ConvertToUShortBigEndian(rowBytes.Slice(offset, 2));
-                offset += 2;
-
-                for (int x = 1; x < width; x++)
-                {
-                    Span<byte> rowSpan = rowBytes.Slice(offset, 2);
-                    ushort deltaR = TiffUtilities.ConvertToUShortBigEndian(rowSpan);
-                    r += deltaR;
-                    BinaryPrimitives.WriteUInt16BigEndian(rowSpan, r);
-                    offset += 2;
-
-                    rowSpan = rowBytes.Slice(offset, 2);
-                    ushort deltaG = TiffUtilities.ConvertToUShortBigEndian(rowSpan);
-                    g += deltaG;
-                    BinaryPrimitives.WriteUInt16BigEndian(rowSpan, g);
-                    offset += 2;
-
-                    rowSpan = rowBytes.Slice(offset, 2);
-                    ushort deltaB = TiffUtilities.ConvertToUShortBigEndian(rowSpan);
-                    b += deltaB;
-                    BinaryPrimitives.WriteUInt16BigEndian(rowSpan, b);
-                    offset += 2;
-                }
+                UndoRgb48BitBigEndianRow(pixelBytes, width, y);
             }
         }
         else
         {
             for (int y = 0; y < height; y++)
             {
-                int offset = 0;
-                Span<byte> rowBytes = pixelBytes.Slice(y * rowBytesCount, rowBytesCount);
-                ushort r = TiffUtilities.ConvertToUShortLittleEndian(rowBytes.Slice(offset, 2));
-                offset += 2;
-                ushort g = TiffUtilities.ConvertToUShortLittleEndian(rowBytes.Slice(offset, 2));
-                offset += 2;
-                ushort b = TiffUtilities.ConvertToUShortLittleEndian(rowBytes.Slice(offset, 2));
-                offset += 2;
-
-                for (int x = 1; x < width; x++)
-                {
-                    Span<byte> rowSpan = rowBytes.Slice(offset, 2);
-                    ushort deltaR = TiffUtilities.ConvertToUShortLittleEndian(rowSpan);
-                    r += deltaR;
-                    BinaryPrimitives.WriteUInt16LittleEndian(rowSpan, r);
-                    offset += 2;
-
-                    rowSpan = rowBytes.Slice(offset, 2);
-                    ushort deltaG = TiffUtilities.ConvertToUShortLittleEndian(rowSpan);
-                    g += deltaG;
-                    BinaryPrimitives.WriteUInt16LittleEndian(rowSpan, g);
-                    offset += 2;
-
-                    rowSpan = rowBytes.Slice(offset, 2);
-                    ushort deltaB = TiffUtilities.ConvertToUShortLittleEndian(rowSpan);
-                    b += deltaB;
-                    BinaryPrimitives.WriteUInt16LittleEndian(rowSpan, b);
-                    offset += 2;
-                }
+                UndoRgb48BitLittleEndianRow(pixelBytes, width, y);
             }
         }
     }
 
+    private static void UndoRgb64BitBigEndianRow(Span<byte> pixelBytes, int width, int y)
+    {
+        int rowBytesCount = width * 8;
+        int offset = 0;
+
+        Span<byte> rowBytes = pixelBytes.Slice(y * rowBytesCount, rowBytesCount);
+        ushort r = TiffUtilities.ConvertToUShortBigEndian(rowBytes.Slice(offset, 2));
+        offset += 2;
+        ushort g = TiffUtilities.ConvertToUShortBigEndian(rowBytes.Slice(offset, 2));
+        offset += 2;
+        ushort b = TiffUtilities.ConvertToUShortBigEndian(rowBytes.Slice(offset, 2));
+        offset += 2;
+        ushort a = TiffUtilities.ConvertToUShortBigEndian(rowBytes.Slice(offset, 2));
+        offset += 2;
+
+        for (int x = 1; x < width; x++)
+        {
+            Span<byte> rowSpan = rowBytes.Slice(offset, 2);
+            ushort deltaR = TiffUtilities.ConvertToUShortBigEndian(rowSpan);
+            r += deltaR;
+            BinaryPrimitives.WriteUInt16BigEndian(rowSpan, r);
+            offset += 2;
+
+            rowSpan = rowBytes.Slice(offset, 2);
+            ushort deltaG = TiffUtilities.ConvertToUShortBigEndian(rowSpan);
+            g += deltaG;
+            BinaryPrimitives.WriteUInt16BigEndian(rowSpan, g);
+            offset += 2;
+
+            rowSpan = rowBytes.Slice(offset, 2);
+            ushort deltaB = TiffUtilities.ConvertToUShortBigEndian(rowSpan);
+            b += deltaB;
+            BinaryPrimitives.WriteUInt16BigEndian(rowSpan, b);
+            offset += 2;
+
+            rowSpan = rowBytes.Slice(offset, 2);
+            ushort deltaA = TiffUtilities.ConvertToUShortBigEndian(rowSpan);
+            a += deltaA;
+            BinaryPrimitives.WriteUInt16BigEndian(rowSpan, a);
+            offset += 2;
+        }
+    }
+
+    private static void UndoRgb64BitLittleEndianRow(Span<byte> pixelBytes, int width, int y)
+    {
+        int rowBytesCount = width * 8;
+        int offset = 0;
+
+        Span<byte> rowBytes = pixelBytes.Slice(y * rowBytesCount, rowBytesCount);
+        ushort r = TiffUtilities.ConvertToUShortLittleEndian(rowBytes.Slice(offset, 2));
+        offset += 2;
+        ushort g = TiffUtilities.ConvertToUShortLittleEndian(rowBytes.Slice(offset, 2));
+        offset += 2;
+        ushort b = TiffUtilities.ConvertToUShortLittleEndian(rowBytes.Slice(offset, 2));
+        offset += 2;
+        ushort a = TiffUtilities.ConvertToUShortLittleEndian(rowBytes.Slice(offset, 2));
+        offset += 2;
+
+        for (int x = 1; x < width; x++)
+        {
+            Span<byte> rowSpan = rowBytes.Slice(offset, 2);
+            ushort deltaR = TiffUtilities.ConvertToUShortLittleEndian(rowSpan);
+            r += deltaR;
+            BinaryPrimitives.WriteUInt16LittleEndian(rowSpan, r);
+            offset += 2;
+
+            rowSpan = rowBytes.Slice(offset, 2);
+            ushort deltaG = TiffUtilities.ConvertToUShortLittleEndian(rowSpan);
+            g += deltaG;
+            BinaryPrimitives.WriteUInt16LittleEndian(rowSpan, g);
+            offset += 2;
+
+            rowSpan = rowBytes.Slice(offset, 2);
+            ushort deltaB = TiffUtilities.ConvertToUShortLittleEndian(rowSpan);
+            b += deltaB;
+            BinaryPrimitives.WriteUInt16LittleEndian(rowSpan, b);
+            offset += 2;
+
+            rowSpan = rowBytes.Slice(offset, 2);
+            ushort deltaA = TiffUtilities.ConvertToUShortLittleEndian(rowSpan);
+            a += deltaA;
+            BinaryPrimitives.WriteUInt16LittleEndian(rowSpan, a);
+            offset += 2;
+        }
+    }
+
     private static void UndoRgba64Bit(Span<byte> pixelBytes, int width, bool isBigEndian)
     {
         int rowBytesCount = width * 8;
@@ -391,90 +662,88 @@ internal static class HorizontalPredictor
         {
             for (int y = 0; y < height; y++)
             {
-                int offset = 0;
-                Span<byte> rowBytes = pixelBytes.Slice(y * rowBytesCount, rowBytesCount);
-                ushort r = TiffUtilities.ConvertToUShortBigEndian(rowBytes.Slice(offset, 2));
-                offset += 2;
-                ushort g = TiffUtilities.ConvertToUShortBigEndian(rowBytes.Slice(offset, 2));
-                offset += 2;
-                ushort b = TiffUtilities.ConvertToUShortBigEndian(rowBytes.Slice(offset, 2));
-                offset += 2;
-                ushort a = TiffUtilities.ConvertToUShortBigEndian(rowBytes.Slice(offset, 2));
-                offset += 2;
-
-                for (int x = 1; x < width; x++)
-                {
-                    Span<byte> rowSpan = rowBytes.Slice(offset, 2);
-                    ushort deltaR = TiffUtilities.ConvertToUShortBigEndian(rowSpan);
-                    r += deltaR;
-                    BinaryPrimitives.WriteUInt16BigEndian(rowSpan, r);
-                    offset += 2;
-
-                    rowSpan = rowBytes.Slice(offset, 2);
-                    ushort deltaG = TiffUtilities.ConvertToUShortBigEndian(rowSpan);
-                    g += deltaG;
-                    BinaryPrimitives.WriteUInt16BigEndian(rowSpan, g);
-                    offset += 2;
-
-                    rowSpan = rowBytes.Slice(offset, 2);
-                    ushort deltaB = TiffUtilities.ConvertToUShortBigEndian(rowSpan);
-                    b += deltaB;
-                    BinaryPrimitives.WriteUInt16BigEndian(rowSpan, b);
-                    offset += 2;
-
-                    rowSpan = rowBytes.Slice(offset, 2);
-                    ushort deltaA = TiffUtilities.ConvertToUShortBigEndian(rowSpan);
-                    a += deltaA;
-                    BinaryPrimitives.WriteUInt16BigEndian(rowSpan, a);
-                    offset += 2;
-                }
+                UndoRgb64BitBigEndianRow(pixelBytes, width, y);
             }
         }
         else
         {
             for (int y = 0; y < height; y++)
             {
-                int offset = 0;
-                Span<byte> rowBytes = pixelBytes.Slice(y * rowBytesCount, rowBytesCount);
-                ushort r = TiffUtilities.ConvertToUShortLittleEndian(rowBytes.Slice(offset, 2));
-                offset += 2;
-                ushort g = TiffUtilities.ConvertToUShortLittleEndian(rowBytes.Slice(offset, 2));
-                offset += 2;
-                ushort b = TiffUtilities.ConvertToUShortLittleEndian(rowBytes.Slice(offset, 2));
-                offset += 2;
-                ushort a = TiffUtilities.ConvertToUShortLittleEndian(rowBytes.Slice(offset, 2));
-                offset += 2;
-
-                for (int x = 1; x < width; x++)
-                {
-                    Span<byte> rowSpan = rowBytes.Slice(offset, 2);
-                    ushort deltaR = TiffUtilities.ConvertToUShortLittleEndian(rowSpan);
-                    r += deltaR;
-                    BinaryPrimitives.WriteUInt16LittleEndian(rowSpan, r);
-                    offset += 2;
-
-                    rowSpan = rowBytes.Slice(offset, 2);
-                    ushort deltaG = TiffUtilities.ConvertToUShortLittleEndian(rowSpan);
-                    g += deltaG;
-                    BinaryPrimitives.WriteUInt16LittleEndian(rowSpan, g);
-                    offset += 2;
-
-                    rowSpan = rowBytes.Slice(offset, 2);
-                    ushort deltaB = TiffUtilities.ConvertToUShortLittleEndian(rowSpan);
-                    b += deltaB;
-                    BinaryPrimitives.WriteUInt16LittleEndian(rowSpan, b);
-                    offset += 2;
-
-                    rowSpan = rowBytes.Slice(offset, 2);
-                    ushort deltaA = TiffUtilities.ConvertToUShortLittleEndian(rowSpan);
-                    a += deltaA;
-                    BinaryPrimitives.WriteUInt16LittleEndian(rowSpan, a);
-                    offset += 2;
-                }
+                UndoRgb64BitLittleEndianRow(pixelBytes, width, y);
             }
         }
     }
 
+    private static void UndoRgb96BitBigEndianRow(Span<byte> pixelBytes, int width, int y)
+    {
+        int rowBytesCount = width * 12;
+
+        int offset = 0;
+        Span<byte> rowBytes = pixelBytes.Slice(y * rowBytesCount, rowBytesCount);
+        uint r = TiffUtilities.ConvertToUIntBigEndian(rowBytes.Slice(offset, 4));
+        offset += 4;
+        uint g = TiffUtilities.ConvertToUIntBigEndian(rowBytes.Slice(offset, 4));
+        offset += 4;
+        uint b = TiffUtilities.ConvertToUIntBigEndian(rowBytes.Slice(offset, 4));
+        offset += 4;
+
+        for (int x = 1; x < width; x++)
+        {
+            Span<byte> rowSpan = rowBytes.Slice(offset, 4);
+            uint deltaR = TiffUtilities.ConvertToUIntBigEndian(rowSpan);
+            r += deltaR;
+            BinaryPrimitives.WriteUInt32BigEndian(rowSpan, r);
+            offset += 4;
+
+            rowSpan = rowBytes.Slice(offset, 4);
+            uint deltaG = TiffUtilities.ConvertToUIntBigEndian(rowSpan);
+            g += deltaG;
+            BinaryPrimitives.WriteUInt32BigEndian(rowSpan, g);
+            offset += 4;
+
+            rowSpan = rowBytes.Slice(offset, 4);
+            uint deltaB = TiffUtilities.ConvertToUIntBigEndian(rowSpan);
+            b += deltaB;
+            BinaryPrimitives.WriteUInt32BigEndian(rowSpan, b);
+            offset += 4;
+        }
+    }
+
+    private static void UndoRgb96BitLittleEndianRow(Span<byte> pixelBytes, int width, int y)
+    {
+        int rowBytesCount = width * 12;
+
+        int offset = 0;
+        Span<byte> rowBytes = pixelBytes.Slice(y * rowBytesCount, rowBytesCount);
+        uint r = TiffUtilities.ConvertToUIntLittleEndian(rowBytes.Slice(offset, 4));
+        offset += 4;
+        uint g = TiffUtilities.ConvertToUIntLittleEndian(rowBytes.Slice(offset, 4));
+        offset += 4;
+        uint b = TiffUtilities.ConvertToUIntLittleEndian(rowBytes.Slice(offset, 4));
+        offset += 4;
+
+        for (int x = 1; x < width; x++)
+        {
+            Span<byte> rowSpan = rowBytes.Slice(offset, 4);
+            uint deltaR = TiffUtilities.ConvertToUIntLittleEndian(rowSpan);
+            r += deltaR;
+            BinaryPrimitives.WriteUInt32LittleEndian(rowSpan, r);
+            offset += 4;
+
+            rowSpan = rowBytes.Slice(offset, 4);
+            uint deltaG = TiffUtilities.ConvertToUIntLittleEndian(rowSpan);
+            g += deltaG;
+            BinaryPrimitives.WriteUInt32LittleEndian(rowSpan, g);
+            offset += 4;
+
+            rowSpan = rowBytes.Slice(offset, 4);
+            uint deltaB = TiffUtilities.ConvertToUIntLittleEndian(rowSpan);
+            b += deltaB;
+            BinaryPrimitives.WriteUInt32LittleEndian(rowSpan, b);
+            offset += 4;
+        }
+    }
+
     private static void UndoRgb96Bit(Span<byte> pixelBytes, int width, bool isBigEndian)
     {
         int rowBytesCount = width * 12;
@@ -483,74 +752,104 @@ internal static class HorizontalPredictor
         {
             for (int y = 0; y < height; y++)
             {
-                int offset = 0;
-                Span<byte> rowBytes = pixelBytes.Slice(y * rowBytesCount, rowBytesCount);
-                uint r = TiffUtilities.ConvertToUIntBigEndian(rowBytes.Slice(offset, 4));
-                offset += 4;
-                uint g = TiffUtilities.ConvertToUIntBigEndian(rowBytes.Slice(offset, 4));
-                offset += 4;
-                uint b = TiffUtilities.ConvertToUIntBigEndian(rowBytes.Slice(offset, 4));
-                offset += 4;
-
-                for (int x = 1; x < width; x++)
-                {
-                    Span<byte> rowSpan = rowBytes.Slice(offset, 4);
-                    uint deltaR = TiffUtilities.ConvertToUIntBigEndian(rowSpan);
-                    r += deltaR;
-                    BinaryPrimitives.WriteUInt32BigEndian(rowSpan, r);
-                    offset += 4;
-
-                    rowSpan = rowBytes.Slice(offset, 4);
-                    uint deltaG = TiffUtilities.ConvertToUIntBigEndian(rowSpan);
-                    g += deltaG;
-                    BinaryPrimitives.WriteUInt32BigEndian(rowSpan, g);
-                    offset += 4;
-
-                    rowSpan = rowBytes.Slice(offset, 4);
-                    uint deltaB = TiffUtilities.ConvertToUIntBigEndian(rowSpan);
-                    b += deltaB;
-                    BinaryPrimitives.WriteUInt32BigEndian(rowSpan, b);
-                    offset += 4;
-                }
+                UndoRgb96BitBigEndianRow(pixelBytes, width, y);
             }
         }
         else
         {
             for (int y = 0; y < height; y++)
             {
-                int offset = 0;
-                Span<byte> rowBytes = pixelBytes.Slice(y * rowBytesCount, rowBytesCount);
-                uint r = TiffUtilities.ConvertToUIntLittleEndian(rowBytes.Slice(offset, 4));
-                offset += 4;
-                uint g = TiffUtilities.ConvertToUIntLittleEndian(rowBytes.Slice(offset, 4));
-                offset += 4;
-                uint b = TiffUtilities.ConvertToUIntLittleEndian(rowBytes.Slice(offset, 4));
-                offset += 4;
-
-                for (int x = 1; x < width; x++)
-                {
-                    Span<byte> rowSpan = rowBytes.Slice(offset, 4);
-                    uint deltaR = TiffUtilities.ConvertToUIntLittleEndian(rowSpan);
-                    r += deltaR;
-                    BinaryPrimitives.WriteUInt32LittleEndian(rowSpan, r);
-                    offset += 4;
-
-                    rowSpan = rowBytes.Slice(offset, 4);
-                    uint deltaG = TiffUtilities.ConvertToUIntLittleEndian(rowSpan);
-                    g += deltaG;
-                    BinaryPrimitives.WriteUInt32LittleEndian(rowSpan, g);
-                    offset += 4;
-
-                    rowSpan = rowBytes.Slice(offset, 4);
-                    uint deltaB = TiffUtilities.ConvertToUIntLittleEndian(rowSpan);
-                    b += deltaB;
-                    BinaryPrimitives.WriteUInt32LittleEndian(rowSpan, b);
-                    offset += 4;
-                }
+                UndoRgb96BitLittleEndianRow(pixelBytes, width, y);
             }
         }
     }
 
+    private static void UndoRgba128BitBigEndianRow(Span<byte> pixelBytes, int width, int y)
+    {
+        int rowBytesCount = width * 16;
+
+        int offset = 0;
+        Span<byte> rowBytes = pixelBytes.Slice(y * rowBytesCount, rowBytesCount);
+        uint r = TiffUtilities.ConvertToUIntBigEndian(rowBytes.Slice(offset, 4));
+        offset += 4;
+        uint g = TiffUtilities.ConvertToUIntBigEndian(rowBytes.Slice(offset, 4));
+        offset += 4;
+        uint b = TiffUtilities.ConvertToUIntBigEndian(rowBytes.Slice(offset, 4));
+        offset += 4;
+        uint a = TiffUtilities.ConvertToUIntBigEndian(rowBytes.Slice(offset, 4));
+        offset += 4;
+
+        for (int x = 1; x < width; x++)
+        {
+            Span<byte> rowSpan = rowBytes.Slice(offset, 4);
+            uint deltaR = TiffUtilities.ConvertToUIntBigEndian(rowSpan);
+            r += deltaR;
+            BinaryPrimitives.WriteUInt32BigEndian(rowSpan, r);
+            offset += 4;
+
+            rowSpan = rowBytes.Slice(offset, 4);
+            uint deltaG = TiffUtilities.ConvertToUIntBigEndian(rowSpan);
+            g += deltaG;
+            BinaryPrimitives.WriteUInt32BigEndian(rowSpan, g);
+            offset += 4;
+
+            rowSpan = rowBytes.Slice(offset, 4);
+            uint deltaB = TiffUtilities.ConvertToUIntBigEndian(rowSpan);
+            b += deltaB;
+            BinaryPrimitives.WriteUInt32BigEndian(rowSpan, b);
+            offset += 4;
+
+            rowSpan = rowBytes.Slice(offset, 4);
+            uint deltaA = TiffUtilities.ConvertToUIntBigEndian(rowSpan);
+            a += deltaA;
+            BinaryPrimitives.WriteUInt32BigEndian(rowSpan, a);
+            offset += 4;
+        }
+    }
+
+    private static void UndoRgba128BitLittleEndianRow(Span<byte> pixelBytes, int width, int y)
+    {
+        int rowBytesCount = width * 16;
+
+        int offset = 0;
+        Span<byte> rowBytes = pixelBytes.Slice(y * rowBytesCount, rowBytesCount);
+        uint r = TiffUtilities.ConvertToUIntLittleEndian(rowBytes.Slice(offset, 4));
+        offset += 4;
+        uint g = TiffUtilities.ConvertToUIntLittleEndian(rowBytes.Slice(offset, 4));
+        offset += 4;
+        uint b = TiffUtilities.ConvertToUIntLittleEndian(rowBytes.Slice(offset, 4));
+        offset += 4;
+        uint a = TiffUtilities.ConvertToUIntLittleEndian(rowBytes.Slice(offset, 4));
+        offset += 4;
+
+        for (int x = 1; x < width; x++)
+        {
+            Span<byte> rowSpan = rowBytes.Slice(offset, 4);
+            uint deltaR = TiffUtilities.ConvertToUIntLittleEndian(rowSpan);
+            r += deltaR;
+            BinaryPrimitives.WriteUInt32LittleEndian(rowSpan, r);
+            offset += 4;
+
+            rowSpan = rowBytes.Slice(offset, 4);
+            uint deltaG = TiffUtilities.ConvertToUIntLittleEndian(rowSpan);
+            g += deltaG;
+            BinaryPrimitives.WriteUInt32LittleEndian(rowSpan, g);
+            offset += 4;
+
+            rowSpan = rowBytes.Slice(offset, 4);
+            uint deltaB = TiffUtilities.ConvertToUIntLittleEndian(rowSpan);
+            b += deltaB;
+            BinaryPrimitives.WriteUInt32LittleEndian(rowSpan, b);
+            offset += 4;
+
+            rowSpan = rowBytes.Slice(offset, 4);
+            uint deltaA = TiffUtilities.ConvertToUIntLittleEndian(rowSpan);
+            a += deltaA;
+            BinaryPrimitives.WriteUInt32LittleEndian(rowSpan, a);
+            offset += 4;
+        }
+    }
+
     private static void UndoRgba128Bit(Span<byte> pixelBytes, int width, bool isBigEndian)
     {
         int rowBytesCount = width * 16;
@@ -559,86 +858,14 @@ internal static class HorizontalPredictor
         {
             for (int y = 0; y < height; y++)
             {
-                int offset = 0;
-                Span<byte> rowBytes = pixelBytes.Slice(y * rowBytesCount, rowBytesCount);
-                uint r = TiffUtilities.ConvertToUIntBigEndian(rowBytes.Slice(offset, 4));
-                offset += 4;
-                uint g = TiffUtilities.ConvertToUIntBigEndian(rowBytes.Slice(offset, 4));
-                offset += 4;
-                uint b = TiffUtilities.ConvertToUIntBigEndian(rowBytes.Slice(offset, 4));
-                offset += 4;
-                uint a = TiffUtilities.ConvertToUIntBigEndian(rowBytes.Slice(offset, 4));
-                offset += 4;
-
-                for (int x = 1; x < width; x++)
-                {
-                    Span<byte> rowSpan = rowBytes.Slice(offset, 4);
-                    uint deltaR = TiffUtilities.ConvertToUIntBigEndian(rowSpan);
-                    r += deltaR;
-                    BinaryPrimitives.WriteUInt32BigEndian(rowSpan, r);
-                    offset += 4;
-
-                    rowSpan = rowBytes.Slice(offset, 4);
-                    uint deltaG = TiffUtilities.ConvertToUIntBigEndian(rowSpan);
-                    g += deltaG;
-                    BinaryPrimitives.WriteUInt32BigEndian(rowSpan, g);
-                    offset += 4;
-
-                    rowSpan = rowBytes.Slice(offset, 4);
-                    uint deltaB = TiffUtilities.ConvertToUIntBigEndian(rowSpan);
-                    b += deltaB;
-                    BinaryPrimitives.WriteUInt32BigEndian(rowSpan, b);
-                    offset += 4;
-
-                    rowSpan = rowBytes.Slice(offset, 4);
-                    uint deltaA = TiffUtilities.ConvertToUIntBigEndian(rowSpan);
-                    a += deltaA;
-                    BinaryPrimitives.WriteUInt32BigEndian(rowSpan, a);
-                    offset += 4;
-                }
+                UndoRgba128BitBigEndianRow(pixelBytes, width, y);
             }
         }
         else
         {
             for (int y = 0; y < height; y++)
             {
-                int offset = 0;
-                Span<byte> rowBytes = pixelBytes.Slice(y * rowBytesCount, rowBytesCount);
-                uint r = TiffUtilities.ConvertToUIntLittleEndian(rowBytes.Slice(offset, 4));
-                offset += 4;
-                uint g = TiffUtilities.ConvertToUIntLittleEndian(rowBytes.Slice(offset, 4));
-                offset += 4;
-                uint b = TiffUtilities.ConvertToUIntLittleEndian(rowBytes.Slice(offset, 4));
-                offset += 4;
-                uint a = TiffUtilities.ConvertToUIntLittleEndian(rowBytes.Slice(offset, 4));
-                offset += 4;
-
-                for (int x = 1; x < width; x++)
-                {
-                    Span<byte> rowSpan = rowBytes.Slice(offset, 4);
-                    uint deltaR = TiffUtilities.ConvertToUIntLittleEndian(rowSpan);
-                    r += deltaR;
-                    BinaryPrimitives.WriteUInt32LittleEndian(rowSpan, r);
-                    offset += 4;
-
-                    rowSpan = rowBytes.Slice(offset, 4);
-                    uint deltaG = TiffUtilities.ConvertToUIntLittleEndian(rowSpan);
-                    g += deltaG;
-                    BinaryPrimitives.WriteUInt32LittleEndian(rowSpan, g);
-                    offset += 4;
-
-                    rowSpan = rowBytes.Slice(offset, 4);
-                    uint deltaB = TiffUtilities.ConvertToUIntLittleEndian(rowSpan);
-                    b += deltaB;
-                    BinaryPrimitives.WriteUInt32LittleEndian(rowSpan, b);
-                    offset += 4;
-
-                    rowSpan = rowBytes.Slice(offset, 4);
-                    uint deltaA = TiffUtilities.ConvertToUIntLittleEndian(rowSpan);
-                    a += deltaA;
-                    BinaryPrimitives.WriteUInt32LittleEndian(rowSpan, a);
-                    offset += 4;
-                }
+                UndoRgba128BitLittleEndianRow(pixelBytes, width, y);
             }
         }
     }
diff --git a/src/ImageSharp/Formats/Tiff/Compression/TiffDecompressorsFactory.cs b/src/ImageSharp/Formats/Tiff/Compression/TiffDecompressorsFactory.cs
index 720e376b9d..aa207e2b60 100644
--- a/src/ImageSharp/Formats/Tiff/Compression/TiffDecompressorsFactory.cs
+++ b/src/ImageSharp/Formats/Tiff/Compression/TiffDecompressorsFactory.cs
@@ -1,11 +1,12 @@
 // Copyright (c) Six Labors.
 // Licensed under the Six Labors Split License.
 
+using SixLabors.ImageSharp.Formats.Jpeg;
 using SixLabors.ImageSharp.Formats.Tiff.Compression.Decompressors;
 using SixLabors.ImageSharp.Formats.Tiff.Constants;
 using SixLabors.ImageSharp.Formats.Tiff.PhotometricInterpretation;
-using SixLabors.ImageSharp.Formats.Webp;
 using SixLabors.ImageSharp.Memory;
+using SixLabors.ImageSharp.Metadata;
 
 namespace SixLabors.ImageSharp.Formats.Tiff.Compression;
 
@@ -18,13 +19,17 @@ internal static class TiffDecompressorsFactory
         TiffPhotometricInterpretation photometricInterpretation,
         int width,
         int bitsPerPixel,
+        ImageFrameMetadata metadata,
         TiffColorType colorType,
         TiffPredictor predictor,
         FaxCompressionOptions faxOptions,
         byte[] jpegTables,
         uint oldJpegStartOfImageMarker,
         TiffFillOrder fillOrder,
-        ByteOrder byteOrder)
+        ByteOrder byteOrder,
+        bool isTiled = false,
+        int tileWidth = 0,
+        int tileHeight = 0)
     {
         switch (method)
         {
@@ -40,11 +45,11 @@ internal static class TiffDecompressorsFactory
 
             case TiffDecoderCompressionType.Deflate:
                 DebugGuard.IsTrue(faxOptions == FaxCompressionOptions.None, "No fax compression options are expected");
-                return new DeflateTiffCompression(allocator, width, bitsPerPixel, colorType, predictor, byteOrder == ByteOrder.BigEndian);
+                return new DeflateTiffCompression(allocator, width, bitsPerPixel, colorType, predictor, byteOrder == ByteOrder.BigEndian, isTiled, tileWidth, tileHeight);
 
             case TiffDecoderCompressionType.Lzw:
                 DebugGuard.IsTrue(faxOptions == FaxCompressionOptions.None, "No fax compression options are expected");
-                return new LzwTiffCompression(allocator, width, bitsPerPixel, colorType, predictor, byteOrder == ByteOrder.BigEndian);
+                return new LzwTiffCompression(allocator, width, bitsPerPixel, colorType, predictor, byteOrder == ByteOrder.BigEndian, isTiled, tileWidth, tileHeight);
 
             case TiffDecoderCompressionType.T4:
                 DebugGuard.IsTrue(predictor == TiffPredictor.None, "Predictor should only be used with lzw or deflate compression");
@@ -60,11 +65,11 @@ internal static class TiffDecompressorsFactory
 
             case TiffDecoderCompressionType.Jpeg:
                 DebugGuard.IsTrue(predictor == TiffPredictor.None, "Predictor should only be used with lzw or deflate compression");
-                return new JpegTiffCompression(new() { GeneralOptions = options }, allocator, width, bitsPerPixel, jpegTables, photometricInterpretation);
+                return new JpegTiffCompression(new JpegDecoderOptions { GeneralOptions = options }, allocator, width, bitsPerPixel, metadata, jpegTables, photometricInterpretation);
 
             case TiffDecoderCompressionType.OldJpeg:
                 DebugGuard.IsTrue(predictor == TiffPredictor.None, "Predictor should only be used with lzw or deflate compression");
-                return new OldJpegTiffCompression(new() { GeneralOptions = options }, allocator, width, bitsPerPixel, oldJpegStartOfImageMarker, photometricInterpretation);
+                return new OldJpegTiffCompression(new JpegDecoderOptions { GeneralOptions = options }, allocator, width, bitsPerPixel, metadata, oldJpegStartOfImageMarker, photometricInterpretation);
 
             case TiffDecoderCompressionType.Webp:
                 DebugGuard.IsTrue(predictor == TiffPredictor.None, "Predictor should only be used with lzw or deflate compression");
diff --git a/src/ImageSharp/Formats/Tiff/Ifd/DirectoryReader.cs b/src/ImageSharp/Formats/Tiff/Ifd/DirectoryReader.cs
index 114fc12b23..18c0f2e0d3 100644
--- a/src/ImageSharp/Formats/Tiff/Ifd/DirectoryReader.cs
+++ b/src/ImageSharp/Formats/Tiff/Ifd/DirectoryReader.cs
@@ -73,7 +73,7 @@ internal class DirectoryReader
 
     private List<ExifProfile> ReadIfds(bool isBigTiff)
     {
-        List<EntryReader> readers = new();
+        List<EntryReader> readers = [];
         while (this.nextIfdOffset != 0 && this.nextIfdOffset < (ulong)this.stream.Length)
         {
             EntryReader reader = new(this.stream, this.ByteOrder, this.allocator);
diff --git a/src/ImageSharp/Formats/Tiff/Ifd/EntryReader.cs b/src/ImageSharp/Formats/Tiff/Ifd/EntryReader.cs
index 4496de6fb5..49e43e49c4 100644
--- a/src/ImageSharp/Formats/Tiff/Ifd/EntryReader.cs
+++ b/src/ImageSharp/Formats/Tiff/Ifd/EntryReader.cs
@@ -14,7 +14,7 @@ internal class EntryReader : BaseExifReader
         : base(stream, allocator) =>
         this.IsBigEndian = byteOrder == ByteOrder.BigEndian;
 
-    public List<IExifValue> Values { get; } = new();
+    public List<IExifValue> Values { get; } = [];
 
     public ulong NextIfdOffset { get; private set; }
 
@@ -31,8 +31,6 @@ internal class EntryReader : BaseExifReader
         {
             this.ReadValues64(this.Values, ifdOffset);
             this.NextIfdOffset = this.ReadUInt64();
-
-            //// this.ReadSubIfd64(this.Values);
         }
     }
 
@@ -62,9 +60,9 @@ internal class HeaderReader : BaseExifReader
         {
             this.IsBigTiff = true;
 
-            ushort bytesize = this.ReadUInt16();
+            ushort byteSize = this.ReadUInt16();
             ushort reserve = this.ReadUInt16();
-            if (bytesize == TiffConstants.BigTiffByteSize && reserve == 0)
+            if (byteSize == TiffConstants.BigTiffByteSize && reserve == 0)
             {
                 this.FirstIfdOffset = this.ReadUInt64();
                 return;
diff --git a/src/ImageSharp/Formats/Tiff/PhotometricInterpretation/BlackIsZero16TiffColor{TPixel}.cs b/src/ImageSharp/Formats/Tiff/PhotometricInterpretation/BlackIsZero16TiffColor{TPixel}.cs
index 2ef261811b..d818aef1b0 100644
--- a/src/ImageSharp/Formats/Tiff/PhotometricInterpretation/BlackIsZero16TiffColor{TPixel}.cs
+++ b/src/ImageSharp/Formats/Tiff/PhotometricInterpretation/BlackIsZero16TiffColor{TPixel}.cs
@@ -47,7 +47,7 @@ internal class BlackIsZero16TiffColor<TPixel> : TiffBaseColorDecoder<TPixel>
                     ushort intensity = TiffUtilities.ConvertToUShortBigEndian(data.Slice(offset, 2));
                     offset += 2;
 
-                    pixelRow[x] = TPixel.FromL16(new(intensity));
+                    pixelRow[x] = TPixel.FromL16(new L16(intensity));
                 }
             }
             else
diff --git a/src/ImageSharp/Formats/Tiff/PhotometricInterpretation/BlackIsZero4TiffColor{TPixel}.cs b/src/ImageSharp/Formats/Tiff/PhotometricInterpretation/BlackIsZero4TiffColor{TPixel}.cs
index 1d33f1a248..41b2bde1b6 100644
--- a/src/ImageSharp/Formats/Tiff/PhotometricInterpretation/BlackIsZero4TiffColor{TPixel}.cs
+++ b/src/ImageSharp/Formats/Tiff/PhotometricInterpretation/BlackIsZero4TiffColor{TPixel}.cs
@@ -25,14 +25,14 @@ internal class BlackIsZero4TiffColor<TPixel> : TiffBaseColorDecoder<TPixel>
             for (int x = left; x < left + width - 1;)
             {
                 byte byteData = data[offset++];
-                pixelRowSpan[x++] = TPixel.FromL8(new((byte)(((byteData & 0xF0) >> 4) * 17)));
-                pixelRowSpan[x++] = TPixel.FromL8(new((byte)((byteData & 0x0F) * 17)));
+                pixelRowSpan[x++] = TPixel.FromL8(new L8((byte)(((byteData & 0xF0) >> 4) * 17)));
+                pixelRowSpan[x++] = TPixel.FromL8(new L8((byte)((byteData & 0x0F) * 17)));
             }
 
             if (isOddWidth)
             {
                 byte byteData = data[offset++];
-                pixelRowSpan[left + width - 1] = TPixel.FromL8(new((byte)(((byteData & 0xF0) >> 4) * 17)));
+                pixelRowSpan[left + width - 1] = TPixel.FromL8(new L8((byte)(((byteData & 0xF0) >> 4) * 17)));
             }
         }
     }
diff --git a/src/ImageSharp/Formats/Tiff/PhotometricInterpretation/BlackIsZeroTiffColor{TPixel}.cs b/src/ImageSharp/Formats/Tiff/PhotometricInterpretation/BlackIsZeroTiffColor{TPixel}.cs
index 709c2bf649..7428ef0577 100644
--- a/src/ImageSharp/Formats/Tiff/PhotometricInterpretation/BlackIsZeroTiffColor{TPixel}.cs
+++ b/src/ImageSharp/Formats/Tiff/PhotometricInterpretation/BlackIsZeroTiffColor{TPixel}.cs
@@ -1,6 +1,7 @@
 // Copyright (c) Six Labors.
 // Licensed under the Six Labors Split License.
 
+using System.Numerics;
 using SixLabors.ImageSharp.Formats.Tiff.Utils;
 using SixLabors.ImageSharp.Memory;
 using SixLabors.ImageSharp.PixelFormats;
@@ -35,7 +36,7 @@ internal class BlackIsZeroTiffColor<TPixel> : TiffBaseColorDecoder<TPixel>
             {
                 int value = bitReader.ReadBits(this.bitsPerSample0);
                 float intensity = value / this.factor;
-                pixelRow[x] = TPixel.FromScaledVector4(new(intensity, intensity, intensity, 1f));
+                pixelRow[x] = TPixel.FromScaledVector4(new Vector4(intensity, intensity, intensity, 1f));
             }
 
             bitReader.NextRow();
diff --git a/src/ImageSharp/Formats/Tiff/PhotometricInterpretation/CieLabPlanarTiffColor{TPixel}.cs b/src/ImageSharp/Formats/Tiff/PhotometricInterpretation/CieLabPlanarTiffColor{TPixel}.cs
index d6fc7c4870..d23d1e2909 100644
--- a/src/ImageSharp/Formats/Tiff/PhotometricInterpretation/CieLabPlanarTiffColor{TPixel}.cs
+++ b/src/ImageSharp/Formats/Tiff/PhotometricInterpretation/CieLabPlanarTiffColor{TPixel}.cs
@@ -2,6 +2,7 @@
 // Licensed under the Six Labors Split License.
 
 using System.Buffers;
+using System.Numerics;
 using SixLabors.ImageSharp.ColorProfiles;
 using SixLabors.ImageSharp.Memory;
 using SixLabors.ImageSharp.PixelFormats;
@@ -34,7 +35,7 @@ internal class CieLabPlanarTiffColor<TPixel> : TiffBasePlanarColorDecoder<TPixel
             {
                 CieLab lab = new((l[offset] & 0xFF) * 100f * Inv255, (sbyte)a[offset], (sbyte)b[offset]);
                 Rgb rgb = ColorProfileConverter.Convert<CieLab, Rgb>(in lab);
-                pixelRow[x] = TPixel.FromScaledVector4(new(rgb.R, rgb.G, rgb.B, 1.0f));
+                pixelRow[x] = TPixel.FromScaledVector4(new Vector4(rgb.R, rgb.G, rgb.B, 1.0f));
 
                 offset++;
             }
diff --git a/src/ImageSharp/Formats/Tiff/PhotometricInterpretation/CieLabTiffColor{TPixel}.cs b/src/ImageSharp/Formats/Tiff/PhotometricInterpretation/CieLabTiffColor{TPixel}.cs
index b0236022b3..b10d27ccda 100644
--- a/src/ImageSharp/Formats/Tiff/PhotometricInterpretation/CieLabTiffColor{TPixel}.cs
+++ b/src/ImageSharp/Formats/Tiff/PhotometricInterpretation/CieLabTiffColor{TPixel}.cs
@@ -1,6 +1,7 @@
 // Copyright (c) Six Labors.
 // Licensed under the Six Labors Split License.
 
+using System.Numerics;
 using SixLabors.ImageSharp.ColorProfiles;
 using SixLabors.ImageSharp.Memory;
 using SixLabors.ImageSharp.PixelFormats;
@@ -30,7 +31,7 @@ internal class CieLabTiffColor<TPixel> : TiffBaseColorDecoder<TPixel>
                 float l = (data[offset] & 0xFF) * 100f * Inv255;
                 CieLab lab = new(l, (sbyte)data[offset + 1], (sbyte)data[offset + 2]);
                 Rgb rgb = ColorProfileConverter.Convert<CieLab, Rgb>(in lab);
-                pixelRow[x] = TPixel.FromScaledVector4(new(rgb.R, rgb.G, rgb.B, 1f));
+                pixelRow[x] = TPixel.FromScaledVector4(new Vector4(rgb.R, rgb.G, rgb.B, 1f));
 
                 offset += 3;
             }
diff --git a/src/ImageSharp/Formats/Tiff/PhotometricInterpretation/CmykTiffColor{TPixel}.cs b/src/ImageSharp/Formats/Tiff/PhotometricInterpretation/CmykTiffColor{TPixel}.cs
index c7fe2ed075..2e22fcde03 100644
--- a/src/ImageSharp/Formats/Tiff/PhotometricInterpretation/CmykTiffColor{TPixel}.cs
+++ b/src/ImageSharp/Formats/Tiff/PhotometricInterpretation/CmykTiffColor{TPixel}.cs
@@ -1,7 +1,9 @@
 // Copyright (c) Six Labors.
 // Licensed under the Six Labors Split License.
 
+using System.Numerics;
 using SixLabors.ImageSharp.ColorProfiles;
+using SixLabors.ImageSharp.Formats.Tiff.Compression;
 using SixLabors.ImageSharp.Memory;
 using SixLabors.ImageSharp.PixelFormats;
 
@@ -13,10 +15,31 @@ internal class CmykTiffColor<TPixel> : TiffBaseColorDecoder<TPixel>
     private static readonly ColorProfileConverter ColorProfileConverter = new();
     private const float Inv255 = 1f / 255f;
 
+    private readonly TiffDecoderCompressionType compression;
+
+    public CmykTiffColor(TiffDecoderCompressionType compression) => this.compression = compression;
+
     /// <inheritdoc/>
     public override void Decode(ReadOnlySpan<byte> data, Buffer2D<TPixel> pixels, int left, int top, int width, int height)
     {
         int offset = 0;
+
+        if (this.compression == TiffDecoderCompressionType.Jpeg)
+        {
+            for (int y = top; y < top + height; y++)
+            {
+                Span<TPixel> pixelRow = pixels.DangerousGetRowSpan(y).Slice(left, width);
+                for (int x = 0; x < pixelRow.Length; x++)
+                {
+                    pixelRow[x] = TPixel.FromVector4(new Vector4(data[offset] * Inv255, data[offset + 1] * Inv255, data[offset + 2] * Inv255, 1.0f));
+
+                    offset += 3;
+                }
+            }
+
+            return;
+        }
+
         for (int y = top; y < top + height; y++)
         {
             Span<TPixel> pixelRow = pixels.DangerousGetRowSpan(y).Slice(left, width);
@@ -24,7 +47,7 @@ internal class CmykTiffColor<TPixel> : TiffBaseColorDecoder<TPixel>
             {
                 Cmyk cmyk = new(data[offset] * Inv255, data[offset + 1] * Inv255, data[offset + 2] * Inv255, data[offset + 3] * Inv255);
                 Rgb rgb = ColorProfileConverter.Convert<Cmyk, Rgb>(in cmyk);
-                pixelRow[x] = TPixel.FromScaledVector4(new(rgb.R, rgb.G, rgb.B, 1.0f));
+                pixelRow[x] = TPixel.FromScaledVector4(new Vector4(rgb.R, rgb.G, rgb.B, 1.0f));
 
                 offset += 4;
             }
diff --git a/src/ImageSharp/Formats/Tiff/PhotometricInterpretation/PaletteTiffColor{TPixel}.cs b/src/ImageSharp/Formats/Tiff/PhotometricInterpretation/PaletteTiffColor{TPixel}.cs
index 745e5846a9..69113cf937 100644
--- a/src/ImageSharp/Formats/Tiff/PhotometricInterpretation/PaletteTiffColor{TPixel}.cs
+++ b/src/ImageSharp/Formats/Tiff/PhotometricInterpretation/PaletteTiffColor{TPixel}.cs
@@ -1,6 +1,7 @@
 // Copyright (c) Six Labors.
 // Licensed under the Six Labors Split License.
 
+using System.Numerics;
 using SixLabors.ImageSharp.Formats.Tiff.Utils;
 using SixLabors.ImageSharp.Memory;
 using SixLabors.ImageSharp.PixelFormats;
@@ -63,7 +64,7 @@ internal class PaletteTiffColor<TPixel> : TiffBaseColorDecoder<TPixel>
             float r = colorMap[rOffset + i] * InvMax;
             float g = colorMap[gOffset + i] * InvMax;
             float b = colorMap[bOffset + i] * InvMax;
-            palette[i] = TPixel.FromScaledVector4(new(r, g, b, 1f));
+            palette[i] = TPixel.FromScaledVector4(new Vector4(r, g, b, 1f));
         }
 
         return palette;
diff --git a/src/ImageSharp/Formats/Tiff/PhotometricInterpretation/Rgb161616TiffColor{TPixel}.cs b/src/ImageSharp/Formats/Tiff/PhotometricInterpretation/Rgb161616TiffColor{TPixel}.cs
index d8520e307e..c1420b4f4f 100644
--- a/src/ImageSharp/Formats/Tiff/PhotometricInterpretation/Rgb161616TiffColor{TPixel}.cs
+++ b/src/ImageSharp/Formats/Tiff/PhotometricInterpretation/Rgb161616TiffColor{TPixel}.cs
@@ -48,7 +48,7 @@ internal class Rgb161616TiffColor<TPixel> : TiffBaseColorDecoder<TPixel>
                     ushort b = TiffUtilities.ConvertToUShortBigEndian(data.Slice(offset, 2));
                     offset += 2;
 
-                    pixelRow[x] = TPixel.FromRgb48(new(r, g, b));
+                    pixelRow[x] = TPixel.FromRgb48(new Rgb48(r, g, b));
                 }
             }
             else
diff --git a/src/ImageSharp/Formats/Tiff/PhotometricInterpretation/Rgb16PlanarTiffColor{TPixel}.cs b/src/ImageSharp/Formats/Tiff/PhotometricInterpretation/Rgb16PlanarTiffColor{TPixel}.cs
index f55d7225e0..84efb90212 100644
--- a/src/ImageSharp/Formats/Tiff/PhotometricInterpretation/Rgb16PlanarTiffColor{TPixel}.cs
+++ b/src/ImageSharp/Formats/Tiff/PhotometricInterpretation/Rgb16PlanarTiffColor{TPixel}.cs
@@ -44,7 +44,7 @@ internal class Rgb16PlanarTiffColor<TPixel> : TiffBasePlanarColorDecoder<TPixel>
 
                     offset += 2;
 
-                    pixelRow[x] = TPixel.FromRgb48(new(r, g, b));
+                    pixelRow[x] = TPixel.FromRgb48(new Rgb48(r, g, b));
                 }
             }
             else
@@ -57,7 +57,7 @@ internal class Rgb16PlanarTiffColor<TPixel> : TiffBasePlanarColorDecoder<TPixel>
 
                     offset += 2;
 
-                    pixelRow[x] = TPixel.FromRgb48(new(r, g, b));
+                    pixelRow[x] = TPixel.FromRgb48(new Rgb48(r, g, b));
                 }
             }
         }
diff --git a/src/ImageSharp/Formats/Tiff/PhotometricInterpretation/RgbFloat323232TiffColor{TPixel}.cs b/src/ImageSharp/Formats/Tiff/PhotometricInterpretation/RgbFloat323232TiffColor{TPixel}.cs
index 37605ef804..f9c17eb2f5 100644
--- a/src/ImageSharp/Formats/Tiff/PhotometricInterpretation/RgbFloat323232TiffColor{TPixel}.cs
+++ b/src/ImageSharp/Formats/Tiff/PhotometricInterpretation/RgbFloat323232TiffColor{TPixel}.cs
@@ -1,6 +1,7 @@
 // Copyright (c) Six Labors.
 // Licensed under the Six Labors Split License.
 
+using System.Numerics;
 using SixLabors.ImageSharp.Memory;
 using SixLabors.ImageSharp.PixelFormats;
 
@@ -50,7 +51,7 @@ internal class RgbFloat323232TiffColor<TPixel> : TiffBaseColorDecoder<TPixel>
                     float b = BitConverter.ToSingle(buffer);
                     offset += 4;
 
-                    pixelRow[x] = TPixel.FromScaledVector4(new(r, g, b, 1f));
+                    pixelRow[x] = TPixel.FromScaledVector4(new Vector4(r, g, b, 1f));
                 }
             }
             else
@@ -66,7 +67,7 @@ internal class RgbFloat323232TiffColor<TPixel> : TiffBaseColorDecoder<TPixel>
                     float b = BitConverter.ToSingle(data.Slice(offset, 4));
                     offset += 4;
 
-                    pixelRow[x] = TPixel.FromScaledVector4(new(r, g, b, 1f));
+                    pixelRow[x] = TPixel.FromScaledVector4(new Vector4(r, g, b, 1f));
                 }
             }
         }
diff --git a/src/ImageSharp/Formats/Tiff/PhotometricInterpretation/RgbPlanarTiffColor{TPixel}.cs b/src/ImageSharp/Formats/Tiff/PhotometricInterpretation/RgbPlanarTiffColor{TPixel}.cs
index 844b08d3c0..a013abfbdb 100644
--- a/src/ImageSharp/Formats/Tiff/PhotometricInterpretation/RgbPlanarTiffColor{TPixel}.cs
+++ b/src/ImageSharp/Formats/Tiff/PhotometricInterpretation/RgbPlanarTiffColor{TPixel}.cs
@@ -2,6 +2,7 @@
 // Licensed under the Six Labors Split License.
 
 using System.Buffers;
+using System.Numerics;
 using SixLabors.ImageSharp.Formats.Tiff.Utils;
 using SixLabors.ImageSharp.Memory;
 using SixLabors.ImageSharp.PixelFormats;
@@ -62,7 +63,7 @@ internal class RgbPlanarTiffColor<TPixel> : TiffBasePlanarColorDecoder<TPixel>
                 float g = gBitReader.ReadBits(this.bitsPerSampleG) / this.gFactor;
                 float b = bBitReader.ReadBits(this.bitsPerSampleB) / this.bFactor;
 
-                pixelRow[x] = TPixel.FromScaledVector4(new(r, g, b, 1f));
+                pixelRow[x] = TPixel.FromScaledVector4(new Vector4(r, g, b, 1f));
             }
 
             rBitReader.NextRow();
diff --git a/src/ImageSharp/Formats/Tiff/PhotometricInterpretation/Rgba16161616TiffColor{TPixel}.cs b/src/ImageSharp/Formats/Tiff/PhotometricInterpretation/Rgba16161616TiffColor{TPixel}.cs
index e4965887d6..9847f45b54 100644
--- a/src/ImageSharp/Formats/Tiff/PhotometricInterpretation/Rgba16161616TiffColor{TPixel}.cs
+++ b/src/ImageSharp/Formats/Tiff/PhotometricInterpretation/Rgba16161616TiffColor{TPixel}.cs
@@ -67,7 +67,7 @@ internal class Rgba16161616TiffColor<TPixel> : TiffBaseColorDecoder<TPixel>
 
                     pixelRow[x] = hasAssociatedAlpha
                         ? TiffUtilities.ColorFromRgba64Premultiplied<TPixel>(r, g, b, a)
-                        : TPixel.FromRgba64(new(r, g, b, a));
+                        : TPixel.FromRgba64(new Rgba64(r, g, b, a));
                 }
             }
             else
diff --git a/src/ImageSharp/Formats/Tiff/PhotometricInterpretation/Rgba16PlanarTiffColor{TPixel}.cs b/src/ImageSharp/Formats/Tiff/PhotometricInterpretation/Rgba16PlanarTiffColor{TPixel}.cs
index 3d36db17de..12357adc10 100644
--- a/src/ImageSharp/Formats/Tiff/PhotometricInterpretation/Rgba16PlanarTiffColor{TPixel}.cs
+++ b/src/ImageSharp/Formats/Tiff/PhotometricInterpretation/Rgba16PlanarTiffColor{TPixel}.cs
@@ -56,7 +56,7 @@ internal class Rgba16PlanarTiffColor<TPixel> : TiffBasePlanarColorDecoder<TPixel
 
                     pixelRow[x] = hasAssociatedAlpha
                         ? TiffUtilities.ColorFromRgba64Premultiplied<TPixel>(r, g, b, a)
-                        : TPixel.FromRgba64(new(r, g, b, a));
+                        : TPixel.FromRgba64(new Rgba64(r, g, b, a));
                 }
             }
             else
@@ -72,7 +72,7 @@ internal class Rgba16PlanarTiffColor<TPixel> : TiffBasePlanarColorDecoder<TPixel
 
                     pixelRow[x] = hasAssociatedAlpha
                         ? TiffUtilities.ColorFromRgba64Premultiplied<TPixel>(r, g, b, a)
-                        : TPixel.FromRgba64(new(r, g, b, a));
+                        : TPixel.FromRgba64(new Rgba64(r, g, b, a));
                 }
             }
         }
diff --git a/src/ImageSharp/Formats/Tiff/PhotometricInterpretation/RgbaFloat32323232TiffColor{TPixel}.cs b/src/ImageSharp/Formats/Tiff/PhotometricInterpretation/RgbaFloat32323232TiffColor{TPixel}.cs
index 12f1b75b40..87a0196413 100644
--- a/src/ImageSharp/Formats/Tiff/PhotometricInterpretation/RgbaFloat32323232TiffColor{TPixel}.cs
+++ b/src/ImageSharp/Formats/Tiff/PhotometricInterpretation/RgbaFloat32323232TiffColor{TPixel}.cs
@@ -1,6 +1,7 @@
 // Copyright (c) Six Labors.
 // Licensed under the Six Labors Split License.
 
+using System.Numerics;
 using SixLabors.ImageSharp.Memory;
 using SixLabors.ImageSharp.PixelFormats;
 
@@ -55,7 +56,7 @@ internal class RgbaFloat32323232TiffColor<TPixel> : TiffBaseColorDecoder<TPixel>
                     float a = BitConverter.ToSingle(buffer);
                     offset += 4;
 
-                    pixelRow[x] = TPixel.FromScaledVector4(new(r, g, b, a));
+                    pixelRow[x] = TPixel.FromScaledVector4(new Vector4(r, g, b, a));
                 }
             }
             else
@@ -74,7 +75,7 @@ internal class RgbaFloat32323232TiffColor<TPixel> : TiffBaseColorDecoder<TPixel>
                     float a = BitConverter.ToSingle(data.Slice(offset, 4));
                     offset += 4;
 
-                    pixelRow[x] = TPixel.FromScaledVector4(new(r, g, b, a));
+                    pixelRow[x] = TPixel.FromScaledVector4(new Vector4(r, g, b, a));
                 }
             }
         }
diff --git a/src/ImageSharp/Formats/Tiff/PhotometricInterpretation/TiffColorDecoderFactory{TPixel}.cs b/src/ImageSharp/Formats/Tiff/PhotometricInterpretation/TiffColorDecoderFactory{TPixel}.cs
index c59b08a55c..e2eb82e3b4 100644
--- a/src/ImageSharp/Formats/Tiff/PhotometricInterpretation/TiffColorDecoderFactory{TPixel}.cs
+++ b/src/ImageSharp/Formats/Tiff/PhotometricInterpretation/TiffColorDecoderFactory{TPixel}.cs
@@ -1,6 +1,7 @@
 // Copyright (c) Six Labors.
 // Licensed under the Six Labors Split License.
 
+using SixLabors.ImageSharp.Formats.Tiff.Compression;
 using SixLabors.ImageSharp.Memory;
 using SixLabors.ImageSharp.PixelFormats;
 
@@ -19,6 +20,7 @@ internal static class TiffColorDecoderFactory<TPixel>
         Rational[] referenceBlackAndWhite,
         Rational[] ycbcrCoefficients,
         ushort[] ycbcrSubSampling,
+        TiffDecoderCompressionType compression,
         ByteOrder byteOrder)
     {
         switch (colorType)
@@ -410,7 +412,7 @@ internal static class TiffColorDecoderFactory<TPixel>
                     && bitsPerSample.Channel1 == 8
                     && bitsPerSample.Channel0 == 8,
                     "bitsPerSample");
-                return new CmykTiffColor<TPixel>();
+                return new CmykTiffColor<TPixel>(compression);
 
             default:
                 throw TiffThrowHelper.InvalidColorType(colorType.ToString());
diff --git a/src/ImageSharp/Formats/Tiff/PhotometricInterpretation/WhiteIsZero16TiffColor{TPixel}.cs b/src/ImageSharp/Formats/Tiff/PhotometricInterpretation/WhiteIsZero16TiffColor{TPixel}.cs
index 6f1672e1b9..d70873634e 100644
--- a/src/ImageSharp/Formats/Tiff/PhotometricInterpretation/WhiteIsZero16TiffColor{TPixel}.cs
+++ b/src/ImageSharp/Formats/Tiff/PhotometricInterpretation/WhiteIsZero16TiffColor{TPixel}.cs
@@ -36,7 +36,7 @@ internal class WhiteIsZero16TiffColor<TPixel> : TiffBaseColorDecoder<TPixel>
                     ushort intensity = (ushort)(ushort.MaxValue - TiffUtilities.ConvertToUShortBigEndian(data.Slice(offset, 2)));
                     offset += 2;
 
-                    pixelRow[x] = TPixel.FromL16(new(intensity));
+                    pixelRow[x] = TPixel.FromL16(new L16(intensity));
                 }
             }
             else
@@ -46,7 +46,7 @@ internal class WhiteIsZero16TiffColor<TPixel> : TiffBaseColorDecoder<TPixel>
                     ushort intensity = (ushort)(ushort.MaxValue - TiffUtilities.ConvertToUShortLittleEndian(data.Slice(offset, 2)));
                     offset += 2;
 
-                    pixelRow[x] = TPixel.FromL16(new(intensity));
+                    pixelRow[x] = TPixel.FromL16(new L16(intensity));
                 }
             }
         }
diff --git a/src/ImageSharp/Formats/Tiff/PhotometricInterpretation/WhiteIsZero32FloatTiffColor{TPixel}.cs b/src/ImageSharp/Formats/Tiff/PhotometricInterpretation/WhiteIsZero32FloatTiffColor{TPixel}.cs
index 7d31f23abd..6986f25ebd 100644
--- a/src/ImageSharp/Formats/Tiff/PhotometricInterpretation/WhiteIsZero32FloatTiffColor{TPixel}.cs
+++ b/src/ImageSharp/Formats/Tiff/PhotometricInterpretation/WhiteIsZero32FloatTiffColor{TPixel}.cs
@@ -40,7 +40,7 @@ internal class WhiteIsZero32FloatTiffColor<TPixel> : TiffBaseColorDecoder<TPixel
                     float intensity = 1.0f - BitConverter.ToSingle(buffer);
                     offset += 4;
 
-                    pixelRow[x] = TPixel.FromScaledVector4(new(intensity, intensity, intensity, 1f));
+                    pixelRow[x] = TPixel.FromScaledVector4(new Vector4(intensity, intensity, intensity, 1f));
                 }
             }
             else
diff --git a/src/ImageSharp/Formats/Tiff/PhotometricInterpretation/WhiteIsZero4TiffColor{TPixel}.cs b/src/ImageSharp/Formats/Tiff/PhotometricInterpretation/WhiteIsZero4TiffColor{TPixel}.cs
index 7dcbe23c5f..09faafc636 100644
--- a/src/ImageSharp/Formats/Tiff/PhotometricInterpretation/WhiteIsZero4TiffColor{TPixel}.cs
+++ b/src/ImageSharp/Formats/Tiff/PhotometricInterpretation/WhiteIsZero4TiffColor{TPixel}.cs
@@ -25,14 +25,14 @@ internal class WhiteIsZero4TiffColor<TPixel> : TiffBaseColorDecoder<TPixel>
             for (int x = left; x < left + width - 1;)
             {
                 byte byteData = data[offset++];
-                pixelRowSpan[x++] = TPixel.FromL8(new((byte)((15 - ((byteData & 0xF0) >> 4)) * 17)));
-                pixelRowSpan[x++] = TPixel.FromL8(new((byte)((15 - (byteData & 0x0F)) * 17)));
+                pixelRowSpan[x++] = TPixel.FromL8(new L8((byte)((15 - ((byteData & 0xF0) >> 4)) * 17)));
+                pixelRowSpan[x++] = TPixel.FromL8(new L8((byte)((15 - (byteData & 0x0F)) * 17)));
             }
 
             if (isOddWidth)
             {
                 byte byteData = data[offset++];
-                pixelRowSpan[left + width - 1] = TPixel.FromL8(new((byte)((15 - ((byteData & 0xF0) >> 4)) * 17)));
+                pixelRowSpan[left + width - 1] = TPixel.FromL8(new L8((byte)((15 - ((byteData & 0xF0) >> 4)) * 17)));
             }
         }
     }
diff --git a/src/ImageSharp/Formats/Tiff/PhotometricInterpretation/WhiteIsZero8TiffColor{TPixel}.cs b/src/ImageSharp/Formats/Tiff/PhotometricInterpretation/WhiteIsZero8TiffColor{TPixel}.cs
index 5429dbd3b0..ae0dcb753e 100644
--- a/src/ImageSharp/Formats/Tiff/PhotometricInterpretation/WhiteIsZero8TiffColor{TPixel}.cs
+++ b/src/ImageSharp/Formats/Tiff/PhotometricInterpretation/WhiteIsZero8TiffColor{TPixel}.cs
@@ -23,7 +23,7 @@ internal class WhiteIsZero8TiffColor<TPixel> : TiffBaseColorDecoder<TPixel>
             for (int x = 0; x < pixelRow.Length; x++)
             {
                 byte intensity = (byte)(byte.MaxValue - data[offset++]);
-                pixelRow[x] = TPixel.FromL8(new(intensity));
+                pixelRow[x] = TPixel.FromL8(new L8(intensity));
             }
         }
     }
diff --git a/src/ImageSharp/Formats/Tiff/PhotometricInterpretation/YCbCrConverter.cs b/src/ImageSharp/Formats/Tiff/PhotometricInterpretation/YCbCrConverter.cs
index 0a1cf6ab98..744cba35fd 100644
--- a/src/ImageSharp/Formats/Tiff/PhotometricInterpretation/YCbCrConverter.cs
+++ b/src/ImageSharp/Formats/Tiff/PhotometricInterpretation/YCbCrConverter.cs
@@ -17,18 +17,18 @@ internal class YCbCrConverter
     private readonly YCbCrToRgbConverter converter;
 
     private static readonly Rational[] DefaultLuma =
-    {
+    [
         new(299, 1000),
         new(587, 1000),
         new(114, 1000)
-    };
+    ];
 
     private static readonly Rational[] DefaultReferenceBlackWhite =
-    {
+    [
         new(0, 1), new(255, 1),
         new(128, 1), new(255, 1),
         new(128, 1), new(255, 1)
-    };
+    ];
 
     public YCbCrConverter(Rational[] referenceBlackAndWhite, Rational[] coefficients)
     {
@@ -107,7 +107,7 @@ internal class YCbCrConverter
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
         public Rgba32 Convert(float y, float cb, float cr)
         {
-            var pixel = default(Rgba32);
+            Rgba32 pixel = default(Rgba32);
             pixel.R = RoundAndClampTo8Bit((cr * this.cr2R) + y);
             pixel.G = RoundAndClampTo8Bit((this.y2G * y) + (this.cr2G * cr) + (this.cb2G * cb));
             pixel.B = RoundAndClampTo8Bit((cb * this.cb2B) + y);
diff --git a/src/ImageSharp/Formats/Tiff/TiffDecoderCore.cs b/src/ImageSharp/Formats/Tiff/TiffDecoderCore.cs
index 7336924602..fbff352970 100644
--- a/src/ImageSharp/Formats/Tiff/TiffDecoderCore.cs
+++ b/src/ImageSharp/Formats/Tiff/TiffDecoderCore.cs
@@ -11,6 +11,7 @@ using SixLabors.ImageSharp.IO;
 using SixLabors.ImageSharp.Memory;
 using SixLabors.ImageSharp.Metadata;
 using SixLabors.ImageSharp.Metadata.Profiles.Exif;
+using SixLabors.ImageSharp.Metadata.Profiles.Icc;
 using SixLabors.ImageSharp.PixelFormats;
 
 namespace SixLabors.ImageSharp.Formats.Tiff;
@@ -227,7 +228,7 @@ internal class TiffDecoderCore : ImageDecoderCore
 
         ImageMetadata metadata = TiffDecoderMetadataCreator.Create(framesMetadata, this.skipMetadata, reader.ByteOrder, reader.IsBigTiff);
 
-        return new ImageInfo(new(width, height), metadata, framesMetadata);
+        return new ImageInfo(new Size(width, height), metadata, framesMetadata);
     }
 
     /// <summary>
@@ -280,6 +281,12 @@ internal class TiffDecoderCore : ImageDecoderCore
         if (!this.skipMetadata)
         {
             imageFrameMetaData.ExifProfile = tags;
+
+            // We resolve the ICC profile early so that we can use it for color conversion if needed.
+            if (tags.TryGetValue(ExifTag.IccProfile, out IExifValue<byte[]> iccProfileBytes))
+            {
+                imageFrameMetaData.IccProfile = new IccProfile(iccProfileBytes.Value);
+            }
         }
 
         TiffFrameMetadata tiffMetadata = TiffFrameMetadata.Parse(tags);
@@ -438,7 +445,7 @@ internal class TiffDecoderCore : ImageDecoderCore
                 stripBuffers[stripIndex] = this.memoryAllocator.Allocate<byte>(uncompressedStripSize);
             }
 
-            using TiffBaseDecompressor decompressor = this.CreateDecompressor<TPixel>(width, bitsPerPixel);
+            using TiffBaseDecompressor decompressor = this.CreateDecompressor<TPixel>(width, bitsPerPixel, frame.Metadata);
             TiffBasePlanarColorDecoder<TPixel> colorDecoder = this.CreatePlanarColorDecoder<TPixel>();
 
             for (int i = 0; i < stripsPerPlane; i++)
@@ -507,7 +514,7 @@ internal class TiffDecoderCore : ImageDecoderCore
         Span<byte> stripBufferSpan = stripBuffer.GetSpan();
         Buffer2D<TPixel> pixels = frame.PixelBuffer;
 
-        using TiffBaseDecompressor decompressor = this.CreateDecompressor<TPixel>(width, bitsPerPixel);
+        using TiffBaseDecompressor decompressor = this.CreateDecompressor<TPixel>(width, bitsPerPixel, frame.Metadata);
         TiffBaseColorDecoder<TPixel> colorDecoder = this.CreateChunkyColorDecoder<TPixel>();
 
         for (int stripIndex = 0; stripIndex < stripOffsets.Length; stripIndex++)
@@ -578,7 +585,7 @@ internal class TiffDecoderCore : ImageDecoderCore
                 tilesBuffers[i] = this.memoryAllocator.Allocate<byte>(uncompressedTilesSize, AllocationOptions.Clean);
             }
 
-            using TiffBaseDecompressor decompressor = this.CreateDecompressor<TPixel>(frame.Width, bitsPerPixel);
+            using TiffBaseDecompressor decompressor = this.CreateDecompressor<TPixel>(frame.Width, bitsPerPixel, frame.Metadata);
             TiffBasePlanarColorDecoder<TPixel> colorDecoder = this.CreatePlanarColorDecoder<TPixel>();
 
             int tileIndex = 0;
@@ -679,7 +686,7 @@ internal class TiffDecoderCore : ImageDecoderCore
         using IMemoryOwner<byte> tileBuffer = this.memoryAllocator.Allocate<byte>(bytesPerTileRow * tileLength, AllocationOptions.Clean);
         Span<byte> tileBufferSpan = tileBuffer.GetSpan();
 
-        using TiffBaseDecompressor decompressor = this.CreateDecompressor<TPixel>(frame.Width, bitsPerPixel);
+        using TiffBaseDecompressor decompressor = this.CreateDecompressor<TPixel>(frame.Width, bitsPerPixel, frame.Metadata, true, tileWidth, tileLength);
         TiffBaseColorDecoder<TPixel> colorDecoder = this.CreateChunkyColorDecoder<TPixel>();
 
         int tileIndex = 0;
@@ -733,6 +740,7 @@ internal class TiffDecoderCore : ImageDecoderCore
             this.ReferenceBlackAndWhite,
             this.YcbcrCoefficients,
             this.YcbcrSubSampling,
+            this.CompressionType,
             this.byteOrder);
 
     private TiffBasePlanarColorDecoder<TPixel> CreatePlanarColorDecoder<TPixel>()
@@ -747,7 +755,13 @@ internal class TiffDecoderCore : ImageDecoderCore
             this.YcbcrSubSampling,
             this.byteOrder);
 
-    private TiffBaseDecompressor CreateDecompressor<TPixel>(int frameWidth, int bitsPerPixel)
+    private TiffBaseDecompressor CreateDecompressor<TPixel>(
+        int frameWidth,
+        int bitsPerPixel,
+        ImageFrameMetadata metadata,
+        bool isTiled = false,
+        int tileWidth = 0,
+        int tileHeight = 0)
         where TPixel : unmanaged, IPixel<TPixel> =>
         TiffDecompressorsFactory.Create(
             this.Options,
@@ -756,13 +770,17 @@ internal class TiffDecoderCore : ImageDecoderCore
             this.PhotometricInterpretation,
             frameWidth,
             bitsPerPixel,
+            metadata,
             this.ColorType,
             this.Predictor,
             this.FaxCompressionOptions,
             this.JpegTables,
             this.OldJpegCompressionStartOfImageMarker.GetValueOrDefault(),
             this.FillOrder,
-            this.byteOrder);
+            this.byteOrder,
+            isTiled,
+            tileWidth,
+            tileHeight);
 
     private IMemoryOwner<ulong> ConvertNumbers(Array array, out Span<ulong> span)
     {
diff --git a/src/ImageSharp/Formats/Tiff/TiffDecoderMetadataCreator.cs b/src/ImageSharp/Formats/Tiff/TiffDecoderMetadataCreator.cs
index 28565cac47..ebf407f9b5 100644
--- a/src/ImageSharp/Formats/Tiff/TiffDecoderMetadataCreator.cs
+++ b/src/ImageSharp/Formats/Tiff/TiffDecoderMetadataCreator.cs
@@ -5,7 +5,6 @@
 using SixLabors.ImageSharp.Common.Helpers;
 using SixLabors.ImageSharp.Metadata;
 using SixLabors.ImageSharp.Metadata.Profiles.Exif;
-using SixLabors.ImageSharp.Metadata.Profiles.Icc;
 using SixLabors.ImageSharp.Metadata.Profiles.Iptc;
 using SixLabors.ImageSharp.Metadata.Profiles.Xmp;
 
@@ -29,6 +28,8 @@ internal static class TiffDecoderMetadataCreator
         {
             for (int i = 0; i < frames.Count; i++)
             {
+                // ICC profile data has already been resolved in the frame metadata,
+                // as it is required for color conversion.
                 ImageFrameMetadata frameMetaData = frames[i];
                 if (TryGetIptc(frameMetaData.ExifProfile.Values, out byte[] iptcBytes))
                 {
@@ -39,11 +40,6 @@ internal static class TiffDecoderMetadataCreator
                 {
                     frameMetaData.XmpProfile = new XmpProfile(xmpProfileBytes.Value);
                 }
-
-                if (frameMetaData.ExifProfile.TryGetValue(ExifTag.IccProfile, out IExifValue<byte[]> iccProfileBytes))
-                {
-                    frameMetaData.IccProfile = new IccProfile(iccProfileBytes.Value);
-                }
             }
         }
 
diff --git a/src/ImageSharp/Formats/Tiff/TiffDecoderOptionsParser.cs b/src/ImageSharp/Formats/Tiff/TiffDecoderOptionsParser.cs
index ed91755468..7519871b74 100644
--- a/src/ImageSharp/Formats/Tiff/TiffDecoderOptionsParser.cs
+++ b/src/ImageSharp/Formats/Tiff/TiffDecoderOptionsParser.cs
@@ -25,20 +25,22 @@ internal static class TiffDecoderOptionsParser
     /// <returns>True, if the image uses tiles. Otherwise the images has strip's.</returns>
     public static bool VerifyAndParse(this TiffDecoderCore options, ExifProfile exifProfile, TiffFrameMetadata frameMetadata)
     {
-        IExifValue extraSamplesExifValue = exifProfile.GetValueInternal(ExifTag.ExtraSamples);
-        if (extraSamplesExifValue is not null)
+        if (exifProfile.TryGetValue(ExifTag.ExtraSamples, out IExifValue<ushort[]> samples))
         {
-            short[] extraSamples = (short[])extraSamplesExifValue.GetValue();
-            if (extraSamples.Length != 1)
+            // We only support a single sample pertaining to alpha data.
+            // Other information is discarded.
+            TiffExtraSampleType sampleType = (TiffExtraSampleType)samples.Value[0];
+            if (sampleType is TiffExtraSampleType.CorelDrawUnassociatedAlphaData)
             {
-                TiffThrowHelper.ThrowNotSupported("ExtraSamples is only supported with one extra sample for alpha data.");
+                // According to libtiff, this CorelDRAW-specific value indicates unassociated alpha.
+                // Patch required for compatibility with malformed CorelDRAW-generated TIFFs.
+                // https://libtiff.gitlab.io/libtiff/releases/v3.9.0beta.html
+                sampleType = TiffExtraSampleType.UnassociatedAlphaData;
             }
 
-            TiffExtraSampleType extraSamplesType = (TiffExtraSampleType)extraSamples[0];
-            options.ExtraSamplesType = extraSamplesType;
-            if (extraSamplesType is not (TiffExtraSampleType.UnassociatedAlphaData or TiffExtraSampleType.AssociatedAlphaData))
+            if (sampleType is (TiffExtraSampleType.UnassociatedAlphaData or TiffExtraSampleType.AssociatedAlphaData))
             {
-                TiffThrowHelper.ThrowNotSupported("Decoding Tiff images with ExtraSamples is not supported with UnspecifiedData.");
+                options.ExtraSamplesType = sampleType;
             }
         }
 
diff --git a/src/ImageSharp/Formats/Tiff/TiffEncoderCore.cs b/src/ImageSharp/Formats/Tiff/TiffEncoderCore.cs
index da55ef9f9b..d7508b02e8 100644
--- a/src/ImageSharp/Formats/Tiff/TiffEncoderCore.cs
+++ b/src/ImageSharp/Formats/Tiff/TiffEncoderCore.cs
@@ -146,10 +146,12 @@ internal sealed class TiffEncoderCore
             {
                 cancellationToken.ThrowIfCancellationRequested();
 
-                if (EncodingUtilities.ShouldClearTransparentPixels<TPixel>(this.transparentColorMode))
+                // TODO: Try to avoid cloning the frame if possible.
+                // We should be cloning individual scanlines instead.
+                if (EncodingUtilities.ShouldReplaceTransparentPixels<TPixel>(this.transparentColorMode))
                 {
                     clonedFrame = frame.Clone();
-                    EncodingUtilities.ClearTransparentPixels(clonedFrame, Color.Transparent);
+                    EncodingUtilities.ReplaceTransparentPixels(clonedFrame);
                 }
 
                 ImageFrame<TPixel> encodingFrame = clonedFrame ?? frame;
@@ -222,15 +224,6 @@ internal sealed class TiffEncoderCore
         height = Math.Min(height, frame.Height);
         Size encodingSize = new(width, height);
 
-        using TiffBaseCompressor compressor = TiffCompressorFactory.Create(
-            compression,
-            writer.BaseStream,
-            this.memoryAllocator,
-            width,
-            (int)bitsPerPixel,
-            this.compressionLevel,
-            this.HorizontalPredictor == TiffPredictor.Horizontal ? this.HorizontalPredictor.Value : TiffPredictor.None);
-
         TiffEncoderEntriesCollector entriesCollector = new();
         using TiffBaseColorWriter<TPixel> colorWriter = TiffColorWriterFactory.Create(
             this.PhotometricInterpretation,
@@ -243,6 +236,15 @@ internal sealed class TiffEncoderCore
             entriesCollector,
             (int)bitsPerPixel);
 
+        using TiffBaseCompressor compressor = TiffCompressorFactory.Create(
+            compression,
+            writer.BaseStream,
+            this.memoryAllocator,
+            width,
+            colorWriter.BitsPerPixel,
+            this.compressionLevel,
+            this.HorizontalPredictor == TiffPredictor.Horizontal ? this.HorizontalPredictor.Value : TiffPredictor.None);
+
         int rowsPerStrip = CalcRowsPerStrip(height, colorWriter.BytesPerRow, this.CompressionType);
 
         colorWriter.Write(compressor, rowsPerStrip);
diff --git a/src/ImageSharp/Formats/Tiff/TiffEncoderEntriesCollector.cs b/src/ImageSharp/Formats/Tiff/TiffEncoderEntriesCollector.cs
index 803b77fb0a..86c6b0c4a6 100644
--- a/src/ImageSharp/Formats/Tiff/TiffEncoderEntriesCollector.cs
+++ b/src/ImageSharp/Formats/Tiff/TiffEncoderEntriesCollector.cs
@@ -16,7 +16,7 @@ internal class TiffEncoderEntriesCollector
 {
     private const string SoftwareValue = "ImageSharp";
 
-    public List<IExifValue> Entries { get; } = new List<IExifValue>();
+    public List<IExifValue> Entries { get; } = [];
 
     public void ProcessMetadata(Image image, bool skipMetadata)
         => new MetadataProcessor(this).Process(image, skipMetadata);
diff --git a/src/ImageSharp/Formats/Tiff/TiffExtraSampleType.cs b/src/ImageSharp/Formats/Tiff/TiffExtraSampleType.cs
index 484fc993b0..cb7582764c 100644
--- a/src/ImageSharp/Formats/Tiff/TiffExtraSampleType.cs
+++ b/src/ImageSharp/Formats/Tiff/TiffExtraSampleType.cs
@@ -22,5 +22,11 @@ internal enum TiffExtraSampleType
     /// The extra data is unassociated alpha data is transparency information that logically exists independent of an image;
     /// it is commonly called a soft matte.
     /// </summary>
-    UnassociatedAlphaData = 2
+    UnassociatedAlphaData = 2,
+
+    /// <summary>
+    /// A CorelDRAW-specific value observed in damaged files, indicating unassociated alpha.
+    /// Not part of the official TIFF specification; patched in ImageSharp for compatibility.
+    /// </summary>
+    CorelDrawUnassociatedAlphaData = 999,
 }
diff --git a/src/ImageSharp/Formats/Tiff/TiffFormat.cs b/src/ImageSharp/Formats/Tiff/TiffFormat.cs
index 76a06d013d..eb052d1bf2 100644
--- a/src/ImageSharp/Formats/Tiff/TiffFormat.cs
+++ b/src/ImageSharp/Formats/Tiff/TiffFormat.cs
@@ -17,7 +17,7 @@ public sealed class TiffFormat : IImageFormat<TiffMetadata, TiffFrameMetadata>
     /// <summary>
     /// Gets the shared instance.
     /// </summary>
-    public static TiffFormat Instance { get; } = new TiffFormat();
+    public static TiffFormat Instance { get; } = new();
 
     /// <inheritdoc/>
     public string Name => "TIFF";
@@ -32,8 +32,8 @@ public sealed class TiffFormat : IImageFormat<TiffMetadata, TiffFrameMetadata>
     public IEnumerable<string> FileExtensions => TiffConstants.FileExtensions;
 
     /// <inheritdoc/>
-    public TiffMetadata CreateDefaultFormatMetadata() => new TiffMetadata();
+    public TiffMetadata CreateDefaultFormatMetadata() => new();
 
     /// <inheritdoc/>
-    public TiffFrameMetadata CreateDefaultFormatFrameMetadata() => new TiffFrameMetadata();
+    public TiffFrameMetadata CreateDefaultFormatFrameMetadata() => new();
 }
diff --git a/src/ImageSharp/Formats/Tiff/TiffFrameMetadata.cs b/src/ImageSharp/Formats/Tiff/TiffFrameMetadata.cs
index 189fee8b0c..d9dfafbcc6 100644
--- a/src/ImageSharp/Formats/Tiff/TiffFrameMetadata.cs
+++ b/src/ImageSharp/Formats/Tiff/TiffFrameMetadata.cs
@@ -1,6 +1,7 @@
 // Copyright (c) Six Labors.
 // Licensed under the Six Labors Split License.
 
+using System.Numerics;
 using SixLabors.ImageSharp.Formats.Tiff.Constants;
 using SixLabors.ImageSharp.Metadata.Profiles.Exif;
 using SixLabors.ImageSharp.PixelFormats;
@@ -96,7 +97,7 @@ public class TiffFrameMetadata : IFormatFrameMetadata<TiffFrameMetadata>
         };
 
     /// <inheritdoc/>
-    public void AfterFrameApply<TPixel>(ImageFrame<TPixel> source, ImageFrame<TPixel> destination)
+    public void AfterFrameApply<TPixel>(ImageFrame<TPixel> source, ImageFrame<TPixel> destination, Matrix4x4 matrix)
         where TPixel : unmanaged, IPixel<TPixel>
     {
         float ratioX = destination.Width / (float)source.Width;
diff --git a/src/ImageSharp/Formats/Tiff/TiffMetadata.cs b/src/ImageSharp/Formats/Tiff/TiffMetadata.cs
index e965fcb4f6..69b03f36fb 100644
--- a/src/ImageSharp/Formats/Tiff/TiffMetadata.cs
+++ b/src/ImageSharp/Formats/Tiff/TiffMetadata.cs
@@ -1,6 +1,7 @@
 // Copyright (c) Six Labors.
 // Licensed under the Six Labors Split License.
 
+using System.Numerics;
 using SixLabors.ImageSharp.Formats.Tiff.Constants;
 using SixLabors.ImageSharp.PixelFormats;
 
@@ -181,7 +182,7 @@ public class TiffMetadata : IFormatMetadata<TiffMetadata>
         };
 
     /// <inheritdoc/>
-    public void AfterImageApply<TPixel>(Image<TPixel> destination)
+    public void AfterImageApply<TPixel>(Image<TPixel> destination, Matrix4x4 matrix)
         where TPixel : unmanaged, IPixel<TPixel>
     {
     }
diff --git a/src/ImageSharp/Formats/Tiff/Utils/TiffUtilities.cs b/src/ImageSharp/Formats/Tiff/Utils/TiffUtilities.cs
index 8b5e04f276..e30765b1f4 100644
--- a/src/ImageSharp/Formats/Tiff/Utils/TiffUtilities.cs
+++ b/src/ImageSharp/Formats/Tiff/Utils/TiffUtilities.cs
@@ -45,7 +45,7 @@ internal static class TiffUtilities
             return TPixel.FromRgba64(default);
         }
 
-        return TPixel.FromRgba64(new((ushort)(r / a), (ushort)(g / a), (ushort)(b / a), a));
+        return TPixel.FromRgba64(new Rgba64((ushort)(r / a), (ushort)(g / a), (ushort)(b / a), a));
     }
 
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
diff --git a/src/ImageSharp/Formats/Tiff/Writers/TiffPaletteWriter{TPixel}.cs b/src/ImageSharp/Formats/Tiff/Writers/TiffPaletteWriter{TPixel}.cs
index da66373631..ebf75efe8b 100644
--- a/src/ImageSharp/Formats/Tiff/Writers/TiffPaletteWriter{TPixel}.cs
+++ b/src/ImageSharp/Formats/Tiff/Writers/TiffPaletteWriter{TPixel}.cs
@@ -44,7 +44,7 @@ internal sealed class TiffPaletteWriter<TPixel> : TiffBaseColorWriter<TPixel>
         this.colorPaletteBytes = this.colorPaletteSize * 2;
         using IQuantizer<TPixel> frameQuantizer = quantizer.CreatePixelSpecificQuantizer<TPixel>(
             this.Configuration,
-            new QuantizerOptions()
+            new QuantizerOptions
             {
                 MaxColors = this.maxColors
             });
diff --git a/src/ImageSharp/Formats/Tiff/Writers/TiffStreamWriter.cs b/src/ImageSharp/Formats/Tiff/Writers/TiffStreamWriter.cs
index 3c2ad60846..f880834119 100644
--- a/src/ImageSharp/Formats/Tiff/Writers/TiffStreamWriter.cs
+++ b/src/ImageSharp/Formats/Tiff/Writers/TiffStreamWriter.cs
@@ -110,7 +110,7 @@ internal sealed class TiffStreamWriter : IDisposable
         if (value.Length % 4 != 0)
         {
             // No allocation occurs, refers directly to assembly's data segment.
-            ReadOnlySpan<byte> paddingBytes = new byte[4] { 0x00, 0x00, 0x00, 0x00 };
+            ReadOnlySpan<byte> paddingBytes = [0x00, 0x00, 0x00, 0x00];
             paddingBytes = paddingBytes[..(4 - (value.Length % 4))];
             this.BaseStream.Write(paddingBytes);
         }
diff --git a/src/ImageSharp/Formats/TransparentColorMode.cs b/src/ImageSharp/Formats/TransparentColorMode.cs
index 39986b5024..fe88c314f2 100644
--- a/src/ImageSharp/Formats/TransparentColorMode.cs
+++ b/src/ImageSharp/Formats/TransparentColorMode.cs
@@ -4,7 +4,7 @@
 namespace SixLabors.ImageSharp.Formats;
 
 /// <summary>
-/// Specifies how transparent pixels should be handled during encoding.
+/// Specifies how pixels with transparent alpha components should be handled during encoding and quantization.
 /// </summary>
 public enum TransparentColorMode
 {
@@ -18,5 +18,5 @@ public enum TransparentColorMode
     /// to fully transparent pixels (all components set to zero),
     /// which may improve compression.
     /// </summary>
-    Clear = 1,
+    Clear = 1
 }
diff --git a/src/ImageSharp/Formats/Webp/AlphaDecoder.cs b/src/ImageSharp/Formats/Webp/AlphaDecoder.cs
index a9e63a3d0e..accfea948e 100644
--- a/src/ImageSharp/Formats/Webp/AlphaDecoder.cs
+++ b/src/ImageSharp/Formats/Webp/AlphaDecoder.cs
@@ -6,7 +6,6 @@ using System.Diagnostics.CodeAnalysis;
 using System.Runtime.CompilerServices;
 using System.Runtime.InteropServices;
 using System.Runtime.Intrinsics;
-using System.Runtime.Intrinsics.Arm;
 using System.Runtime.Intrinsics.X86;
 using SixLabors.ImageSharp.Common.Helpers;
 using SixLabors.ImageSharp.Formats.Webp.BitReader;
@@ -61,7 +60,7 @@ internal class AlphaDecoder : IDisposable
 
         if (this.Compressed)
         {
-            Vp8LBitReader bitReader = new Vp8LBitReader(data);
+            Vp8LBitReader bitReader = new(data);
             this.LosslessDecoder = new WebpLosslessDecoder(bitReader, memoryAllocator, configuration);
             this.LosslessDecoder.DecodeImageStream(this.Vp8LDec, width, height, true);
 
@@ -314,7 +313,7 @@ internal class AlphaDecoder : IDisposable
 
     private static void HorizontalUnfilter(Span<byte> prev, Span<byte> input, Span<byte> dst, int width)
     {
-        if ((Sse2.IsSupported || AdvSimd.IsSupported) && width >= 9)
+        if (Vector128.IsHardwareAccelerated && width >= 9)
         {
             dst[0] = (byte)(input[0] + (prev.IsEmpty ? 0 : prev[0]));
             nuint i;
@@ -326,11 +325,11 @@ internal class AlphaDecoder : IDisposable
             {
                 Vector128<long> a0 = Vector128.Create(Unsafe.As<byte, long>(ref Unsafe.Add(ref srcRef, i)), 0);
                 Vector128<byte> a1 = a0.AsByte() + last.AsByte();
-                Vector128<byte> a2 = Vector128Utilities.ShiftLeftBytesInVector(a1, 1);
+                Vector128<byte> a2 = Vector128_.ShiftLeftBytesInVector(a1, 1);
                 Vector128<byte> a3 = a1 + a2;
-                Vector128<byte> a4 = Vector128Utilities.ShiftLeftBytesInVector(a3, 2);
+                Vector128<byte> a4 = Vector128_.ShiftLeftBytesInVector(a3, 2);
                 Vector128<byte> a5 = a3 + a4;
-                Vector128<byte> a6 = Vector128Utilities.ShiftLeftBytesInVector(a5, 4);
+                Vector128<byte> a6 = Vector128_.ShiftLeftBytesInVector(a5, 4);
                 Vector128<byte> a7 = a5 + a6;
 
                 ref byte outputRef = ref Unsafe.Add(ref dstRef, i);
@@ -362,7 +361,7 @@ internal class AlphaDecoder : IDisposable
         {
             HorizontalUnfilter(null, input, dst, width);
         }
-        else if (Avx2.IsSupported)
+        else if (Vector256.IsHardwareAccelerated)
         {
             ref byte inputRef = ref MemoryMarshal.GetReference(input);
             ref byte prevRef = ref MemoryMarshal.GetReference(prev);
@@ -374,7 +373,7 @@ internal class AlphaDecoder : IDisposable
             {
                 Vector256<int> a0 = Unsafe.As<byte, Vector256<int>>(ref Unsafe.Add(ref inputRef, i));
                 Vector256<int> b0 = Unsafe.As<byte, Vector256<int>>(ref Unsafe.Add(ref prevRef, i));
-                Vector256<byte> c0 = Avx2.Add(a0.AsByte(), b0.AsByte());
+                Vector256<byte> c0 = a0.AsByte() + b0.AsByte();
                 ref byte outputRef = ref Unsafe.Add(ref dstRef, i);
                 Unsafe.As<byte, Vector256<byte>>(ref outputRef) = c0;
             }
diff --git a/src/ImageSharp/Formats/Webp/BitReader/BitReaderBase.cs b/src/ImageSharp/Formats/Webp/BitReader/BitReaderBase.cs
index 83f9e797ab..2b843cc8f6 100644
--- a/src/ImageSharp/Formats/Webp/BitReader/BitReaderBase.cs
+++ b/src/ImageSharp/Formats/Webp/BitReader/BitReaderBase.cs
@@ -32,7 +32,7 @@ internal abstract class BitReaderBase : IDisposable
     /// <param name="memoryAllocator">Used for allocating memory during reading data from the stream.</param>
     protected static IMemoryOwner<byte> ReadImageDataFromStream(Stream input, int bytesToRead, MemoryAllocator memoryAllocator)
     {
-        IMemoryOwner<byte> data = memoryAllocator.Allocate<byte>(bytesToRead);
+        IMemoryOwner<byte> data = memoryAllocator.Allocate<byte>(bytesToRead, AllocationOptions.Clean);
         Span<byte> dataSpan = data.Memory.Span;
         input.Read(dataSpan[..bytesToRead], 0, bytesToRead);
 
diff --git a/src/ImageSharp/Formats/Webp/BitReader/Vp8LBitReader.cs b/src/ImageSharp/Formats/Webp/BitReader/Vp8LBitReader.cs
index 6d3cab1514..c7e1455911 100644
--- a/src/ImageSharp/Formats/Webp/BitReader/Vp8LBitReader.cs
+++ b/src/ImageSharp/Formats/Webp/BitReader/Vp8LBitReader.cs
@@ -28,7 +28,7 @@ internal class Vp8LBitReader : BitReaderBase
     private const int Wbits = 32;
 
     private static readonly uint[] BitMask =
-    {
+    [
         0,
         0x000001, 0x000003, 0x000007, 0x00000f,
         0x00001f, 0x00003f, 0x00007f, 0x0000ff,
@@ -36,7 +36,7 @@ internal class Vp8LBitReader : BitReaderBase
         0x001fff, 0x003fff, 0x007fff, 0x00ffff,
         0x01ffff, 0x03ffff, 0x07ffff, 0x0fffff,
         0x1fffff, 0x3fffff, 0x7fffff, 0xffffff
-    };
+    ];
 
     /// <summary>
     /// Pre-fetched bits.
diff --git a/src/ImageSharp/Formats/Webp/BitWriter/Vp8BitWriter.cs b/src/ImageSharp/Formats/Webp/BitWriter/Vp8BitWriter.cs
index 81530706d6..e9f50fb493 100644
--- a/src/ImageSharp/Formats/Webp/BitWriter/Vp8BitWriter.cs
+++ b/src/ImageSharp/Formats/Webp/BitWriter/Vp8BitWriter.cs
@@ -399,7 +399,7 @@ internal class Vp8BitWriter : BitWriterBase
         int mbSize = this.enc.Mbw * this.enc.Mbh;
         int expectedSize = (int)((uint)mbSize * 7 / 8);
 
-        Vp8BitWriter bitWriterPartZero = new Vp8BitWriter(expectedSize, this.enc);
+        Vp8BitWriter bitWriterPartZero = new(expectedSize, this.enc);
 
         // Partition #0 with header and partition sizes.
         uint size0 = bitWriterPartZero.GeneratePartition0();
@@ -545,7 +545,7 @@ internal class Vp8BitWriter : BitWriterBase
     // Writes the partition #0 modes (that is: all intra modes)
     private void CodeIntraModes()
     {
-        Vp8EncIterator it = new Vp8EncIterator(this.enc);
+        Vp8EncIterator it = new(this.enc);
         int predsWidth = this.enc.PredsWidth;
 
         do
@@ -604,7 +604,7 @@ internal class Vp8BitWriter : BitWriterBase
         uint profile = 0;
         int width = this.enc.Width;
         int height = this.enc.Height;
-        byte[] vp8FrameHeader = new byte[WebpConstants.Vp8FrameHeaderSize];
+        Span<byte> vp8FrameHeader = stackalloc byte[WebpConstants.Vp8FrameHeaderSize];
 
         // Paragraph 9.1.
         uint bits = 0 // keyframe (1b)
diff --git a/src/ImageSharp/Formats/Webp/Chunks/WebpFrameData.cs b/src/ImageSharp/Formats/Webp/Chunks/WebpFrameData.cs
index 66662569c3..7d22f7f2b3 100644
--- a/src/ImageSharp/Formats/Webp/Chunks/WebpFrameData.cs
+++ b/src/ImageSharp/Formats/Webp/Chunks/WebpFrameData.cs
@@ -124,7 +124,7 @@ internal readonly struct WebpFrameData
     {
         Span<byte> buffer = stackalloc byte[4];
 
-        return new(
+        return new WebpFrameData(
             dataSize: WebpChunkParsingUtils.ReadChunkSize(stream, buffer),
             x: WebpChunkParsingUtils.ReadUInt24LittleEndian(stream, buffer) * 2,
             y: WebpChunkParsingUtils.ReadUInt24LittleEndian(stream, buffer) * 2,
diff --git a/src/ImageSharp/Formats/Webp/Lossless/BackwardReferenceEncoder.cs b/src/ImageSharp/Formats/Webp/Lossless/BackwardReferenceEncoder.cs
index 2e7dd722fc..274d4426f9 100644
--- a/src/ImageSharp/Formats/Webp/Lossless/BackwardReferenceEncoder.cs
+++ b/src/ImageSharp/Formats/Webp/Lossless/BackwardReferenceEncoder.cs
@@ -149,9 +149,8 @@ internal static class BackwardReferenceEncoder
         }
 
         // Find the cacheBits giving the lowest entropy.
-        for (int idx = 0; idx < refs.Refs.Count; idx++)
+        foreach (PixOrCopy v in refs)
         {
-            PixOrCopy v = refs.Refs[idx];
             if (v.IsLiteral())
             {
                 uint pix = bgra[pos++];
@@ -387,7 +386,7 @@ internal static class BackwardReferenceEncoder
             colorCache = new ColorCache(cacheBits);
         }
 
-        backwardRefs.Refs.Clear();
+        backwardRefs.Clear();
         for (int ix = 0; ix < chosenPathSize; ix++)
         {
             int len = chosenPath[ix];
@@ -479,7 +478,7 @@ internal static class BackwardReferenceEncoder
             colorCache = new ColorCache(cacheBits);
         }
 
-        refs.Refs.Clear();
+        refs.Clear();
         for (int i = 0; i < pixCount;)
         {
             // Alternative #1: Code the pixels starting at 'i' using backward reference.
@@ -734,7 +733,7 @@ internal static class BackwardReferenceEncoder
             colorCache = new ColorCache(cacheBits);
         }
 
-        refs.Refs.Clear();
+        refs.Clear();
 
         // Add first pixel as literal.
         AddSingleLiteral(bgra[0], useColorCache, colorCache, refs);
@@ -779,10 +778,9 @@ internal static class BackwardReferenceEncoder
     private static void BackwardRefsWithLocalCache(ReadOnlySpan<uint> bgra, int cacheBits, Vp8LBackwardRefs refs)
     {
         int pixelIndex = 0;
-        ColorCache colorCache = new ColorCache(cacheBits);
-        for (int idx = 0; idx < refs.Refs.Count; idx++)
+        ColorCache colorCache = new(cacheBits);
+        foreach (ref PixOrCopy v in refs)
         {
-            PixOrCopy v = refs.Refs[idx];
             if (v.IsLiteral())
             {
                 uint bgraLiteral = v.BgraOrDistance;
@@ -790,9 +788,7 @@ internal static class BackwardReferenceEncoder
                 if (ix >= 0)
                 {
                     // Color cache contains bgraLiteral
-                    v.Mode = PixOrCopyMode.CacheIdx;
-                    v.BgraOrDistance = (uint)ix;
-                    v.Len = 1;
+                    v = PixOrCopy.CreateCacheIdx(ix);
                 }
                 else
                 {
@@ -814,14 +810,13 @@ internal static class BackwardReferenceEncoder
 
     private static void BackwardReferences2DLocality(int xSize, Vp8LBackwardRefs refs)
     {
-        using List<PixOrCopy>.Enumerator c = refs.Refs.GetEnumerator();
-        while (c.MoveNext())
+        foreach (ref PixOrCopy v in refs)
         {
-            if (c.Current.IsCopy())
+            if (v.IsCopy())
             {
-                int dist = (int)c.Current.BgraOrDistance;
+                int dist = (int)v.BgraOrDistance;
                 int transformedDist = DistanceToPlaneCode(xSize, dist);
-                c.Current.BgraOrDistance = (uint)transformedDist;
+                v = PixOrCopy.CreateCopy((uint)transformedDist, v.Len);
             }
         }
     }
diff --git a/src/ImageSharp/Formats/Webp/Lossless/ColorSpaceTransformUtils.cs b/src/ImageSharp/Formats/Webp/Lossless/ColorSpaceTransformUtils.cs
index 9a6dfb66e8..c701d56d3f 100644
--- a/src/ImageSharp/Formats/Webp/Lossless/ColorSpaceTransformUtils.cs
+++ b/src/ImageSharp/Formats/Webp/Lossless/ColorSpaceTransformUtils.cs
@@ -4,7 +4,7 @@
 using System.Runtime.CompilerServices;
 using System.Runtime.InteropServices;
 using System.Runtime.Intrinsics;
-using System.Runtime.Intrinsics.X86;
+using SixLabors.ImageSharp.Common.Helpers;
 
 namespace SixLabors.ImageSharp.Formats.Webp.Lossless;
 
@@ -12,17 +12,20 @@ internal static class ColorSpaceTransformUtils
 {
     public static void CollectColorBlueTransforms(Span<uint> bgra, int stride, int tileWidth, int tileHeight, int greenToBlue, int redToBlue, Span<int> histo)
     {
-        if (Avx2.IsSupported && tileWidth >= 16)
+        if (Vector256.IsHardwareAccelerated && tileWidth >= 16)
         {
             const int span = 16;
             Span<ushort> values = stackalloc ushort[span];
-            var collectColorBlueTransformsShuffleLowMask256 = Vector256.Create(255, 2, 255, 6, 255, 10, 255, 14, 255, 255, 255, 255, 255, 255, 255, 255, 255, 18, 255, 22, 255, 26, 255, 30, 255, 255, 255, 255, 255, 255, 255, 255);
-            var collectColorBlueTransformsShuffleHighMask256 = Vector256.Create(255, 255, 255, 255, 255, 255, 255, 255, 255, 2, 255, 6, 255, 10, 255, 14, 255, 255, 255, 255, 255, 255, 255, 255, 255, 18, 255, 22, 255, 26, 255, 30);
-            var collectColorBlueTransformsGreenBlueMask256 = Vector256.Create(255, 255, 0, 0, 255, 255, 0, 0, 255, 255, 0, 0, 255, 255, 0, 0, 255, 255, 0, 0, 255, 255, 0, 0, 255, 255, 0, 0, 255, 255, 0, 0);
-            var collectColorBlueTransformsGreenMask256 = Vector256.Create(0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255);
-            var collectColorBlueTransformsBlueMask256 = Vector256.Create(255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0);
-            var multsr = Vector256.Create(LosslessUtils.Cst5b(redToBlue));
-            var multsg = Vector256.Create(LosslessUtils.Cst5b(greenToBlue));
+
+            // These shuffle masks are safe for use with Avx2.Shuffle because all indices are within their respective 128-bit lanes (0–15 for the low mask, 16–31 for the high mask),
+            // and all disabled lanes are set to 0xFF to zero those bytes per the vpshufb specification. This guarantees lane-local shuffling with no cross-lane violations.
+            Vector256<byte> collectColorBlueTransformsShuffleLowMask256 = Vector256.Create(255, 2, 255, 6, 255, 10, 255, 14, 255, 255, 255, 255, 255, 255, 255, 255, 255, 18, 255, 22, 255, 26, 255, 30, 255, 255, 255, 255, 255, 255, 255, 255);
+            Vector256<byte> collectColorBlueTransformsShuffleHighMask256 = Vector256.Create(255, 255, 255, 255, 255, 255, 255, 255, 255, 2, 255, 6, 255, 10, 255, 14, 255, 255, 255, 255, 255, 255, 255, 255, 255, 18, 255, 22, 255, 26, 255, 30);
+            Vector256<byte> collectColorBlueTransformsGreenBlueMask256 = Vector256.Create(255, 255, 0, 0, 255, 255, 0, 0, 255, 255, 0, 0, 255, 255, 0, 0, 255, 255, 0, 0, 255, 255, 0, 0, 255, 255, 0, 0, 255, 255, 0, 0);
+            Vector256<byte> collectColorBlueTransformsGreenMask256 = Vector256.Create(0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255);
+            Vector256<byte> collectColorBlueTransformsBlueMask256 = Vector256.Create(255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0);
+            Vector256<short> multsr = Vector256.Create(LosslessUtils.Cst5b(redToBlue));
+            Vector256<short> multsg = Vector256.Create(LosslessUtils.Cst5b(greenToBlue));
             for (int y = 0; y < tileHeight; y++)
             {
                 Span<uint> srcSpan = bgra[(y * stride)..];
@@ -33,18 +36,18 @@ internal static class ColorSpaceTransformUtils
                     nuint input1Idx = x + (span / 2);
                     Vector256<byte> input0 = Unsafe.As<uint, Vector256<uint>>(ref Unsafe.Add(ref inputRef, input0Idx)).AsByte();
                     Vector256<byte> input1 = Unsafe.As<uint, Vector256<uint>>(ref Unsafe.Add(ref inputRef, input1Idx)).AsByte();
-                    Vector256<byte> r0 = Avx2.Shuffle(input0, collectColorBlueTransformsShuffleLowMask256);
-                    Vector256<byte> r1 = Avx2.Shuffle(input1, collectColorBlueTransformsShuffleHighMask256);
-                    Vector256<byte> r = Avx2.Or(r0, r1);
-                    Vector256<byte> gb0 = Avx2.And(input0, collectColorBlueTransformsGreenBlueMask256);
-                    Vector256<byte> gb1 = Avx2.And(input1, collectColorBlueTransformsGreenBlueMask256);
-                    Vector256<ushort> gb = Avx2.PackUnsignedSaturate(gb0.AsInt32(), gb1.AsInt32());
-                    Vector256<byte> g = Avx2.And(gb.AsByte(), collectColorBlueTransformsGreenMask256);
-                    Vector256<short> a = Avx2.MultiplyHigh(r.AsInt16(), multsr);
-                    Vector256<short> b = Avx2.MultiplyHigh(g.AsInt16(), multsg);
-                    Vector256<byte> c = Avx2.Subtract(gb.AsByte(), b.AsByte());
-                    Vector256<byte> d = Avx2.Subtract(c, a.AsByte());
-                    Vector256<byte> e = Avx2.And(d, collectColorBlueTransformsBlueMask256);
+                    Vector256<byte> r0 = Vector256_.ShufflePerLane(input0, collectColorBlueTransformsShuffleLowMask256);
+                    Vector256<byte> r1 = Vector256_.ShufflePerLane(input1, collectColorBlueTransformsShuffleHighMask256);
+                    Vector256<byte> r = r0 | r1;
+                    Vector256<byte> gb0 = input0 & collectColorBlueTransformsGreenBlueMask256;
+                    Vector256<byte> gb1 = input1 & collectColorBlueTransformsGreenBlueMask256;
+                    Vector256<ushort> gb = Vector256_.PackUnsignedSaturate(gb0.AsInt32(), gb1.AsInt32());
+                    Vector256<byte> g = gb.AsByte() & collectColorBlueTransformsGreenMask256;
+                    Vector256<short> a = Vector256_.MultiplyHigh(r.AsInt16(), multsr);
+                    Vector256<short> b = Vector256_.MultiplyHigh(g.AsInt16(), multsg);
+                    Vector256<byte> c = gb.AsByte() - b.AsByte();
+                    Vector256<byte> d = c - a.AsByte();
+                    Vector256<byte> e = d & collectColorBlueTransformsBlueMask256;
 
                     ref ushort outputRef = ref MemoryMarshal.GetReference(values);
                     Unsafe.As<ushort, Vector256<ushort>>(ref outputRef) = e.AsUInt16();
@@ -59,20 +62,20 @@ internal static class ColorSpaceTransformUtils
             int leftOver = tileWidth & (span - 1);
             if (leftOver > 0)
             {
-                CollectColorBlueTransformsNoneVectorized(bgra[(tileWidth - leftOver)..], stride, leftOver, tileHeight, greenToBlue, redToBlue, histo);
+                CollectColorBlueTransformsScalar(bgra[(tileWidth - leftOver)..], stride, leftOver, tileHeight, greenToBlue, redToBlue, histo);
             }
         }
-        else if (Sse41.IsSupported)
+        else if (Vector128.IsHardwareAccelerated)
         {
             const int span = 8;
             Span<ushort> values = stackalloc ushort[span];
-            var collectColorBlueTransformsShuffleLowMask = Vector128.Create(255, 2, 255, 6, 255, 10, 255, 14, 255, 255, 255, 255, 255, 255, 255, 255);
-            var collectColorBlueTransformsShuffleHighMask = Vector128.Create(255, 255, 255, 255, 255, 255, 255, 255, 255, 2, 255, 6, 255, 10, 255, 14);
-            var collectColorBlueTransformsGreenBlueMask = Vector128.Create(255, 255, 0, 0, 255, 255, 0, 0, 255, 255, 0, 0, 255, 255, 0, 0);
-            var collectColorBlueTransformsGreenMask = Vector128.Create(0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255);
-            var collectColorBlueTransformsBlueMask = Vector128.Create(255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0);
-            var multsr = Vector128.Create(LosslessUtils.Cst5b(redToBlue));
-            var multsg = Vector128.Create(LosslessUtils.Cst5b(greenToBlue));
+            Vector128<byte> collectColorBlueTransformsShuffleLowMask = Vector128.Create(255, 2, 255, 6, 255, 10, 255, 14, 255, 255, 255, 255, 255, 255, 255, 255);
+            Vector128<byte> collectColorBlueTransformsShuffleHighMask = Vector128.Create(255, 255, 255, 255, 255, 255, 255, 255, 255, 2, 255, 6, 255, 10, 255, 14);
+            Vector128<byte> collectColorBlueTransformsGreenBlueMask = Vector128.Create(255, 255, 0, 0, 255, 255, 0, 0, 255, 255, 0, 0, 255, 255, 0, 0);
+            Vector128<byte> collectColorBlueTransformsGreenMask = Vector128.Create(0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255);
+            Vector128<byte> collectColorBlueTransformsBlueMask = Vector128.Create(255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0);
+            Vector128<short> multsr = Vector128.Create(LosslessUtils.Cst5b(redToBlue));
+            Vector128<short> multsg = Vector128.Create(LosslessUtils.Cst5b(greenToBlue));
             for (int y = 0; y < tileHeight; y++)
             {
                 Span<uint> srcSpan = bgra[(y * stride)..];
@@ -83,18 +86,18 @@ internal static class ColorSpaceTransformUtils
                     nuint input1Idx = x + (span / 2);
                     Vector128<byte> input0 = Unsafe.As<uint, Vector128<uint>>(ref Unsafe.Add(ref inputRef, input0Idx)).AsByte();
                     Vector128<byte> input1 = Unsafe.As<uint, Vector128<uint>>(ref Unsafe.Add(ref inputRef, input1Idx)).AsByte();
-                    Vector128<byte> r0 = Ssse3.Shuffle(input0, collectColorBlueTransformsShuffleLowMask);
-                    Vector128<byte> r1 = Ssse3.Shuffle(input1, collectColorBlueTransformsShuffleHighMask);
-                    Vector128<byte> r = Sse2.Or(r0, r1);
-                    Vector128<byte> gb0 = Sse2.And(input0, collectColorBlueTransformsGreenBlueMask);
-                    Vector128<byte> gb1 = Sse2.And(input1, collectColorBlueTransformsGreenBlueMask);
-                    Vector128<ushort> gb = Sse41.PackUnsignedSaturate(gb0.AsInt32(), gb1.AsInt32());
-                    Vector128<byte> g = Sse2.And(gb.AsByte(), collectColorBlueTransformsGreenMask);
-                    Vector128<short> a = Sse2.MultiplyHigh(r.AsInt16(), multsr);
-                    Vector128<short> b = Sse2.MultiplyHigh(g.AsInt16(), multsg);
-                    Vector128<byte> c = Sse2.Subtract(gb.AsByte(), b.AsByte());
-                    Vector128<byte> d = Sse2.Subtract(c, a.AsByte());
-                    Vector128<byte> e = Sse2.And(d, collectColorBlueTransformsBlueMask);
+                    Vector128<byte> r0 = Vector128_.ShuffleNative(input0, collectColorBlueTransformsShuffleLowMask);
+                    Vector128<byte> r1 = Vector128_.ShuffleNative(input1, collectColorBlueTransformsShuffleHighMask);
+                    Vector128<byte> r = r0 | r1;
+                    Vector128<byte> gb0 = input0 & collectColorBlueTransformsGreenBlueMask;
+                    Vector128<byte> gb1 = input1 & collectColorBlueTransformsGreenBlueMask;
+                    Vector128<ushort> gb = Vector128_.PackUnsignedSaturate(gb0.AsInt32(), gb1.AsInt32());
+                    Vector128<byte> g = gb.AsByte() & collectColorBlueTransformsGreenMask;
+                    Vector128<short> a = Vector128_.MultiplyHigh(r.AsInt16(), multsr);
+                    Vector128<short> b = Vector128_.MultiplyHigh(g.AsInt16(), multsg);
+                    Vector128<byte> c = gb.AsByte() - b.AsByte();
+                    Vector128<byte> d = c - a.AsByte();
+                    Vector128<byte> e = d & collectColorBlueTransformsBlueMask;
 
                     ref ushort outputRef = ref MemoryMarshal.GetReference(values);
                     Unsafe.As<ushort, Vector128<ushort>>(ref outputRef) = e.AsUInt16();
@@ -109,16 +112,16 @@ internal static class ColorSpaceTransformUtils
             int leftOver = tileWidth & (span - 1);
             if (leftOver > 0)
             {
-                CollectColorBlueTransformsNoneVectorized(bgra[(tileWidth - leftOver)..], stride, leftOver, tileHeight, greenToBlue, redToBlue, histo);
+                CollectColorBlueTransformsScalar(bgra[(tileWidth - leftOver)..], stride, leftOver, tileHeight, greenToBlue, redToBlue, histo);
             }
         }
         else
         {
-            CollectColorBlueTransformsNoneVectorized(bgra, stride, tileWidth, tileHeight, greenToBlue, redToBlue, histo);
+            CollectColorBlueTransformsScalar(bgra, stride, tileWidth, tileHeight, greenToBlue, redToBlue, histo);
         }
     }
 
-    private static void CollectColorBlueTransformsNoneVectorized(Span<uint> bgra, int stride, int tileWidth, int tileHeight, int greenToBlue, int redToBlue, Span<int> histo)
+    private static void CollectColorBlueTransformsScalar(Span<uint> bgra, int stride, int tileWidth, int tileHeight, int greenToBlue, int redToBlue, Span<int> histo)
     {
         int pos = 0;
         while (tileHeight-- > 0)
@@ -135,11 +138,11 @@ internal static class ColorSpaceTransformUtils
 
     public static void CollectColorRedTransforms(Span<uint> bgra, int stride, int tileWidth, int tileHeight, int greenToRed, Span<int> histo)
     {
-        if (Avx2.IsSupported && tileWidth >= 16)
+        if (Vector256.IsHardwareAccelerated && tileWidth >= 16)
         {
             Vector256<byte> collectColorRedTransformsGreenMask256 = Vector256.Create(0x00ff00).AsByte();
             Vector256<byte> collectColorRedTransformsAndMask256 = Vector256.Create((short)0xff).AsByte();
-            var multsg = Vector256.Create(LosslessUtils.Cst5b(greenToRed));
+            Vector256<short> multsg = Vector256.Create(LosslessUtils.Cst5b(greenToRed));
             const int span = 16;
             Span<ushort> values = stackalloc ushort[span];
             for (int y = 0; y < tileHeight; y++)
@@ -152,15 +155,15 @@ internal static class ColorSpaceTransformUtils
                     nuint input1Idx = x + (span / 2);
                     Vector256<byte> input0 = Unsafe.As<uint, Vector256<uint>>(ref Unsafe.Add(ref inputRef, input0Idx)).AsByte();
                     Vector256<byte> input1 = Unsafe.As<uint, Vector256<uint>>(ref Unsafe.Add(ref inputRef, input1Idx)).AsByte();
-                    Vector256<byte> g0 = Avx2.And(input0, collectColorRedTransformsGreenMask256); // 0 0  | g 0
-                    Vector256<byte> g1 = Avx2.And(input1, collectColorRedTransformsGreenMask256);
-                    Vector256<ushort> g = Avx2.PackUnsignedSaturate(g0.AsInt32(), g1.AsInt32()); // g 0
-                    Vector256<int> a0 = Avx2.ShiftRightLogical(input0.AsInt32(), 16); // 0 0  | x r
-                    Vector256<int> a1 = Avx2.ShiftRightLogical(input1.AsInt32(), 16);
-                    Vector256<ushort> a = Avx2.PackUnsignedSaturate(a0, a1); // x r
-                    Vector256<short> b = Avx2.MultiplyHigh(g.AsInt16(), multsg); // x dr
-                    Vector256<byte> c = Avx2.Subtract(a.AsByte(), b.AsByte()); // x r'
-                    Vector256<byte> d = Avx2.And(c, collectColorRedTransformsAndMask256); // 0 r'
+                    Vector256<byte> g0 = input0 & collectColorRedTransformsGreenMask256; // 0 0  | g 0
+                    Vector256<byte> g1 = input1 & collectColorRedTransformsGreenMask256;
+                    Vector256<ushort> g = Vector256_.PackUnsignedSaturate(g0.AsInt32(), g1.AsInt32()); // g 0
+                    Vector256<int> a0 = Vector256.ShiftRightLogical(input0.AsInt32(), 16); // 0 0  | x r
+                    Vector256<int> a1 = Vector256.ShiftRightLogical(input1.AsInt32(), 16);
+                    Vector256<ushort> a = Vector256_.PackUnsignedSaturate(a0, a1); // x r
+                    Vector256<short> b = Vector256_.MultiplyHigh(g.AsInt16(), multsg); // x dr
+                    Vector256<byte> c = a.AsByte() - b.AsByte(); // x r'
+                    Vector256<byte> d = c & collectColorRedTransformsAndMask256; // 0 r'
 
                     ref ushort outputRef = ref MemoryMarshal.GetReference(values);
                     Unsafe.As<ushort, Vector256<ushort>>(ref outputRef) = d.AsUInt16();
@@ -175,14 +178,14 @@ internal static class ColorSpaceTransformUtils
             int leftOver = tileWidth & (span - 1);
             if (leftOver > 0)
             {
-                CollectColorRedTransformsNoneVectorized(bgra[(tileWidth - leftOver)..], stride, leftOver, tileHeight, greenToRed, histo);
+                CollectColorRedTransformsScalar(bgra[(tileWidth - leftOver)..], stride, leftOver, tileHeight, greenToRed, histo);
             }
         }
-        else if (Sse41.IsSupported)
+        else if (Vector128.IsHardwareAccelerated)
         {
             Vector128<byte> collectColorRedTransformsGreenMask = Vector128.Create(0x00ff00).AsByte();
             Vector128<byte> collectColorRedTransformsAndMask = Vector128.Create((short)0xff).AsByte();
-            var multsg = Vector128.Create(LosslessUtils.Cst5b(greenToRed));
+            Vector128<short> multsg = Vector128.Create(LosslessUtils.Cst5b(greenToRed));
             const int span = 8;
             Span<ushort> values = stackalloc ushort[span];
             for (int y = 0; y < tileHeight; y++)
@@ -195,15 +198,15 @@ internal static class ColorSpaceTransformUtils
                     nuint input1Idx = x + (span / 2);
                     Vector128<byte> input0 = Unsafe.As<uint, Vector128<uint>>(ref Unsafe.Add(ref inputRef, input0Idx)).AsByte();
                     Vector128<byte> input1 = Unsafe.As<uint, Vector128<uint>>(ref Unsafe.Add(ref inputRef, input1Idx)).AsByte();
-                    Vector128<byte> g0 = Sse2.And(input0, collectColorRedTransformsGreenMask); // 0 0  | g 0
-                    Vector128<byte> g1 = Sse2.And(input1, collectColorRedTransformsGreenMask);
-                    Vector128<ushort> g = Sse41.PackUnsignedSaturate(g0.AsInt32(), g1.AsInt32()); // g 0
-                    Vector128<int> a0 = Sse2.ShiftRightLogical(input0.AsInt32(), 16); // 0 0  | x r
-                    Vector128<int> a1 = Sse2.ShiftRightLogical(input1.AsInt32(), 16);
-                    Vector128<ushort> a = Sse41.PackUnsignedSaturate(a0, a1); // x r
-                    Vector128<short> b = Sse2.MultiplyHigh(g.AsInt16(), multsg); // x dr
-                    Vector128<byte> c = Sse2.Subtract(a.AsByte(), b.AsByte()); // x r'
-                    Vector128<byte> d = Sse2.And(c, collectColorRedTransformsAndMask); // 0 r'
+                    Vector128<byte> g0 = input0 & collectColorRedTransformsGreenMask; // 0 0  | g 0
+                    Vector128<byte> g1 = input1 & collectColorRedTransformsGreenMask;
+                    Vector128<ushort> g = Vector128_.PackUnsignedSaturate(g0.AsInt32(), g1.AsInt32()); // g 0
+                    Vector128<int> a0 = Vector128.ShiftRightLogical(input0.AsInt32(), 16); // 0 0  | x r
+                    Vector128<int> a1 = Vector128.ShiftRightLogical(input1.AsInt32(), 16);
+                    Vector128<ushort> a = Vector128_.PackUnsignedSaturate(a0, a1); // x r
+                    Vector128<short> b = Vector128_.MultiplyHigh(g.AsInt16(), multsg); // x dr
+                    Vector128<byte> c = a.AsByte() - b.AsByte(); // x r'
+                    Vector128<byte> d = c & collectColorRedTransformsAndMask; // 0 r'
 
                     ref ushort outputRef = ref MemoryMarshal.GetReference(values);
                     Unsafe.As<ushort, Vector128<ushort>>(ref outputRef) = d.AsUInt16();
@@ -218,16 +221,16 @@ internal static class ColorSpaceTransformUtils
             int leftOver = tileWidth & (span - 1);
             if (leftOver > 0)
             {
-                CollectColorRedTransformsNoneVectorized(bgra[(tileWidth - leftOver)..], stride, leftOver, tileHeight, greenToRed, histo);
+                CollectColorRedTransformsScalar(bgra[(tileWidth - leftOver)..], stride, leftOver, tileHeight, greenToRed, histo);
             }
         }
         else
         {
-            CollectColorRedTransformsNoneVectorized(bgra, stride, tileWidth, tileHeight, greenToRed, histo);
+            CollectColorRedTransformsScalar(bgra, stride, tileWidth, tileHeight, greenToRed, histo);
         }
     }
 
-    private static void CollectColorRedTransformsNoneVectorized(Span<uint> bgra, int stride, int tileWidth, int tileHeight, int greenToRed, Span<int> histo)
+    private static void CollectColorRedTransformsScalar(Span<uint> bgra, int stride, int tileWidth, int tileHeight, int greenToRed, Span<int> histo)
     {
         int pos = 0;
         while (tileHeight-- > 0)
diff --git a/src/ImageSharp/Formats/Webp/Lossless/CostManager.cs b/src/ImageSharp/Formats/Webp/Lossless/CostManager.cs
index 63ce9dbec6..4ab9d7b94c 100644
--- a/src/ImageSharp/Formats/Webp/Lossless/CostManager.cs
+++ b/src/ImageSharp/Formats/Webp/Lossless/CostManager.cs
@@ -17,7 +17,7 @@ internal sealed class CostManager : IDisposable
 
     private const int FreeIntervalsStartCount = 25;
 
-    private readonly Stack<CostInterval> freeIntervals = new Stack<CostInterval>(FreeIntervalsStartCount);
+    private readonly Stack<CostInterval> freeIntervals = new(FreeIntervalsStartCount);
 
     public CostManager(MemoryAllocator memoryAllocator, IMemoryOwner<ushort> distArray, int pixCount, CostModel costModel)
     {
@@ -49,7 +49,7 @@ internal sealed class CostManager : IDisposable
         }
 
         // Fill in the cache intervals.
-        var cur = new CostCacheInterval()
+        CostCacheInterval cur = new()
         {
             Start = 0,
             End = 1,
@@ -62,7 +62,7 @@ internal sealed class CostManager : IDisposable
             double costVal = this.CostCache[i];
             if (costVal != cur.Cost)
             {
-                cur = new CostCacheInterval()
+                cur = new CostCacheInterval
                 {
                     Start = i,
                     Cost = costVal
@@ -258,7 +258,7 @@ internal sealed class CostManager : IDisposable
         }
         else
         {
-            intervalNew = new CostInterval() { Cost = cost, Start = start, End = end, Index = position };
+            intervalNew = new CostInterval { Cost = cost, Start = start, End = end, Index = position };
         }
 
         this.PositionOrphanInterval(intervalNew, intervalIn);
diff --git a/src/ImageSharp/Formats/Webp/Lossless/CostModel.cs b/src/ImageSharp/Formats/Webp/Lossless/CostModel.cs
index beebc48abc..c6131bc2aa 100644
--- a/src/ImageSharp/Formats/Webp/Lossless/CostModel.cs
+++ b/src/ImageSharp/Formats/Webp/Lossless/CostModel.cs
@@ -40,9 +40,9 @@ internal class CostModel
         using OwnedVp8LHistogram histogram = OwnedVp8LHistogram.Create(this.memoryAllocator, cacheBits);
 
         // The following code is similar to HistogramCreate but converts the distance to plane code.
-        for (int i = 0; i < backwardRefs.Refs.Count; i++)
+        foreach (PixOrCopy v in backwardRefs)
         {
-            histogram.AddSinglePixOrCopy(backwardRefs.Refs[i], true, xSize);
+            histogram.AddSinglePixOrCopy(in v, true, xSize);
         }
 
         ConvertPopulationCountTableToBitEstimates(histogram.NumCodes(), histogram.Literal, this.Literal);
diff --git a/src/ImageSharp/Formats/Webp/Lossless/CrunchConfig.cs b/src/ImageSharp/Formats/Webp/Lossless/CrunchConfig.cs
index 7488f03ca4..58394c212f 100644
--- a/src/ImageSharp/Formats/Webp/Lossless/CrunchConfig.cs
+++ b/src/ImageSharp/Formats/Webp/Lossless/CrunchConfig.cs
@@ -7,5 +7,5 @@ internal class CrunchConfig
 {
     public EntropyIx EntropyIdx { get; set; }
 
-    public List<CrunchSubConfig> SubConfigs { get; } = new List<CrunchSubConfig>();
+    public List<CrunchSubConfig> SubConfigs { get; } = new();
 }
diff --git a/src/ImageSharp/Formats/Webp/Lossless/HistogramEncoder.cs b/src/ImageSharp/Formats/Webp/Lossless/HistogramEncoder.cs
index 3a96362cfd..e0d854bb0e 100644
--- a/src/ImageSharp/Formats/Webp/Lossless/HistogramEncoder.cs
+++ b/src/ImageSharp/Formats/Webp/Lossless/HistogramEncoder.cs
@@ -109,12 +109,11 @@ internal static class HistogramEncoder
     {
         int x = 0, y = 0;
         int histoXSize = LosslessUtils.SubSampleSize(xSize, histoBits);
-        using List<PixOrCopy>.Enumerator backwardRefsEnumerator = backwardRefs.Refs.GetEnumerator();
-        while (backwardRefsEnumerator.MoveNext())
+
+        foreach (PixOrCopy v in backwardRefs)
         {
-            PixOrCopy v = backwardRefsEnumerator.Current;
             int ix = ((y >> histoBits) * histoXSize) + (x >> histoBits);
-            histograms[ix].AddSinglePixOrCopy(v, false);
+            histograms[ix].AddSinglePixOrCopy(in v, false);
             x += v.Len;
             while (x >= xSize)
             {
@@ -217,7 +216,7 @@ internal static class HistogramEncoder
             clusterMappings[idx] = (ushort)idx;
         }
 
-        List<int> indicesToRemove = new();
+        List<int> indicesToRemove = [];
         Vp8LStreaks stats = new();
         Vp8LBitEntropy bitsEntropy = new();
         for (int idx = 0; idx < histograms.Count; idx++)
@@ -345,7 +344,7 @@ internal static class HistogramEncoder
 
         // Priority list of histogram pairs. Its size impacts the quality of the compression and the speed:
         // the smaller the faster but the worse for the compression.
-        List<HistogramPair> histoPriorityList = new();
+        List<HistogramPair> histoPriorityList = [];
         const int maxSize = 9;
 
         // Fill the initial mapping.
@@ -465,7 +464,7 @@ internal static class HistogramEncoder
                     }
                 }
 
-                HistoListUpdateHead(histoPriorityList, p);
+                HistoListUpdateHead(histoPriorityList, p, j);
                 j++;
             }
 
@@ -480,7 +479,7 @@ internal static class HistogramEncoder
         int histoSize = histograms.Count(h => h != null);
 
         // Priority list of histogram pairs.
-        List<HistogramPair> histoPriorityList = new();
+        List<HistogramPair> histoPriorityList = [];
         int maxSize = histoSize * histoSize;
         Vp8LStreaks stats = new();
         Vp8LBitEntropy bitsEntropy = new();
@@ -525,7 +524,7 @@ internal static class HistogramEncoder
                 }
                 else
                 {
-                    HistoListUpdateHead(histoPriorityList, p);
+                    HistoListUpdateHead(histoPriorityList, p, i);
                     i++;
                 }
             }
@@ -647,7 +646,7 @@ internal static class HistogramEncoder
 
         histoList.Add(pair);
 
-        HistoListUpdateHead(histoList, pair);
+        HistoListUpdateHead(histoList, pair, histoList.Count - 1);
 
         return pair.CostDiff;
     }
@@ -674,13 +673,11 @@ internal static class HistogramEncoder
     /// <summary>
     /// Check whether a pair in the list should be updated as head or not.
     /// </summary>
-    private static void HistoListUpdateHead(List<HistogramPair> histoList, HistogramPair pair)
+    private static void HistoListUpdateHead(List<HistogramPair> histoList, HistogramPair pair, int idx)
     {
         if (pair.CostDiff < histoList[0].CostDiff)
         {
-            // Replace the best pair.
-            int oldIdx = histoList.IndexOf(pair);
-            histoList[oldIdx] = histoList[0];
+            histoList[idx] = histoList[0];
             histoList[0] = pair;
         }
     }
diff --git a/src/ImageSharp/Formats/Webp/Lossless/HuffmanUtils.cs b/src/ImageSharp/Formats/Webp/Lossless/HuffmanUtils.cs
index 027d4f7ee9..f15bf263f2 100644
--- a/src/ImageSharp/Formats/Webp/Lossless/HuffmanUtils.cs
+++ b/src/ImageSharp/Formats/Webp/Lossless/HuffmanUtils.cs
@@ -20,10 +20,10 @@ internal static class HuffmanUtils
 
     // Pre-reversed 4-bit values.
     private static readonly byte[] ReversedBits =
-    {
+    [
         0x0, 0x8, 0x4, 0xc, 0x2, 0xa, 0x6, 0xe,
         0x1, 0x9, 0x5, 0xd, 0x3, 0xb, 0x7, 0xf
-    };
+    ];
 
     public static void CreateHuffmanTree(Span<uint> histogram, int treeDepthLimit, bool[] bufRle, Span<HuffmanTree> huffTree, HuffmanTreeCode huffCode)
     {
diff --git a/src/ImageSharp/Formats/Webp/Lossless/LosslessUtils.cs b/src/ImageSharp/Formats/Webp/Lossless/LosslessUtils.cs
index 5287f0b753..e573097e53 100644
--- a/src/ImageSharp/Formats/Webp/Lossless/LosslessUtils.cs
+++ b/src/ImageSharp/Formats/Webp/Lossless/LosslessUtils.cs
@@ -6,6 +6,7 @@ using System.Runtime.CompilerServices;
 using System.Runtime.InteropServices;
 using System.Runtime.Intrinsics;
 using System.Runtime.Intrinsics.X86;
+using SixLabors.ImageSharp.Common.Helpers;
 using SixLabors.ImageSharp.Memory;
 
 namespace SixLabors.ImageSharp.Formats.Webp.Lossless;
@@ -94,17 +95,20 @@ internal static unsafe class LosslessUtils
     /// <param name="pixelData">The pixel data to apply the transformation.</param>
     public static void AddGreenToBlueAndRed(Span<uint> pixelData)
     {
-        if (Avx2.IsSupported && pixelData.Length >= 8)
+        if (Vector256.IsHardwareAccelerated && pixelData.Length >= 8)
         {
-            Vector256<byte> addGreenToBlueAndRedMaskAvx2 = Vector256.Create(1, 255, 1, 255, 5, 255, 5, 255, 9, 255, 9, 255, 13, 255, 13, 255, 17, 255, 17, 255, 21, 255, 21, 255, 25, 255, 25, 255, 29, 255, 29, 255);
+            // The `255` values disable the write for alpha (A), since 0x80 is set in the control byte (high bit set).
+            // Each byte index is within its respective 128-bit lane (0–15 and 16–31), so this is safe for per-lane shuffle.
+            // The high bits are not set for the index bytes, and the values are always < 16 per lane, satisfying AVX2 lane rules.
+            Vector256<byte> addGreenToBlueAndRedMask = Vector256.Create(1, 255, 1, 255, 5, 255, 5, 255, 9, 255, 9, 255, 13, 255, 13, 255, 17, 255, 17, 255, 21, 255, 21, 255, 25, 255, 25, 255, 29, 255, 29, 255);
             nuint numPixels = (uint)pixelData.Length;
             nuint i = 0;
             do
             {
                 ref uint pos = ref Unsafe.Add(ref MemoryMarshal.GetReference(pixelData), i);
                 Vector256<byte> input = Unsafe.As<uint, Vector256<uint>>(ref pos).AsByte();
-                Vector256<byte> in0g0g = Avx2.Shuffle(input, addGreenToBlueAndRedMaskAvx2);
-                Vector256<byte> output = Avx2.Add(input, in0g0g);
+                Vector256<byte> in0g0g = Vector256_.ShufflePerLane(input, addGreenToBlueAndRedMask);
+                Vector256<byte> output = input + in0g0g;
                 Unsafe.As<uint, Vector256<uint>>(ref pos) = output.AsUInt32();
                 i += 8;
             }
@@ -115,39 +119,17 @@ internal static unsafe class LosslessUtils
                 AddGreenToBlueAndRedScalar(pixelData[(int)i..]);
             }
         }
-        else if (Ssse3.IsSupported && pixelData.Length >= 4)
-        {
-            Vector128<byte> addGreenToBlueAndRedMaskSsse3 = Vector128.Create(1, 255, 1, 255, 5, 255, 5, 255, 9, 255, 9, 255, 13, 255, 13, 255);
-            nuint numPixels = (uint)pixelData.Length;
-            nuint i = 0;
-            do
-            {
-                ref uint pos = ref Unsafe.Add(ref MemoryMarshal.GetReference(pixelData), i);
-                Vector128<byte> input = Unsafe.As<uint, Vector128<uint>>(ref pos).AsByte();
-                Vector128<byte> in0g0g = Ssse3.Shuffle(input, addGreenToBlueAndRedMaskSsse3);
-                Vector128<byte> output = Sse2.Add(input, in0g0g);
-                Unsafe.As<uint, Vector128<uint>>(ref pos) = output.AsUInt32();
-                i += 4;
-            }
-            while (i <= numPixels - 4);
-
-            if (i != numPixels)
-            {
-                AddGreenToBlueAndRedScalar(pixelData[(int)i..]);
-            }
-        }
-        else if (Sse2.IsSupported && pixelData.Length >= 4)
+        else if (Vector128.IsHardwareAccelerated && pixelData.Length >= 4)
         {
+            Vector128<byte> addGreenToBlueAndRedMask = Vector128.Create(1, 255, 1, 255, 5, 255, 5, 255, 9, 255, 9, 255, 13, 255, 13, 255);
             nuint numPixels = (uint)pixelData.Length;
             nuint i = 0;
             do
             {
                 ref uint pos = ref Unsafe.Add(ref MemoryMarshal.GetReference(pixelData), i);
                 Vector128<byte> input = Unsafe.As<uint, Vector128<uint>>(ref pos).AsByte();
-                Vector128<ushort> a = Sse2.ShiftRightLogical(input.AsUInt16(), 8); // 0 a 0 g
-                Vector128<ushort> b = Sse2.ShuffleLow(a, SimdUtils.Shuffle.MMShuffle2200);
-                Vector128<ushort> c = Sse2.ShuffleHigh(b, SimdUtils.Shuffle.MMShuffle2200); // 0g0g
-                Vector128<byte> output = Sse2.Add(input.AsByte(), c.AsByte());
+                Vector128<byte> in0g0g = Vector128_.ShuffleNative(input, addGreenToBlueAndRedMask);
+                Vector128<byte> output = input + in0g0g;
                 Unsafe.As<uint, Vector128<uint>>(ref pos) = output.AsUInt32();
                 i += 4;
             }
@@ -180,17 +162,17 @@ internal static unsafe class LosslessUtils
 
     public static void SubtractGreenFromBlueAndRed(Span<uint> pixelData)
     {
-        if (Avx2.IsSupported && pixelData.Length >= 8)
+        if (Vector256.IsHardwareAccelerated && pixelData.Length >= 8)
         {
-            Vector256<byte> subtractGreenFromBlueAndRedMaskAvx2 = Vector256.Create(1, 255, 1, 255, 5, 255, 5, 255, 9, 255, 9, 255, 13, 255, 13, 255, 17, 255, 17, 255, 21, 255, 21, 255, 25, 255, 25, 255, 29, 255, 29, 255);
+            Vector256<byte> subtractGreenFromBlueAndRedMask = Vector256.Create(1, 255, 1, 255, 5, 255, 5, 255, 9, 255, 9, 255, 13, 255, 13, 255, 17, 255, 17, 255, 21, 255, 21, 255, 25, 255, 25, 255, 29, 255, 29, 255);
             nuint numPixels = (uint)pixelData.Length;
             nuint i = 0;
             do
             {
                 ref uint pos = ref Unsafe.Add(ref MemoryMarshal.GetReference(pixelData), i);
                 Vector256<byte> input = Unsafe.As<uint, Vector256<uint>>(ref pos).AsByte();
-                Vector256<byte> in0g0g = Avx2.Shuffle(input, subtractGreenFromBlueAndRedMaskAvx2);
-                Vector256<byte> output = Avx2.Subtract(input, in0g0g);
+                Vector256<byte> in0g0g = Vector256_.ShufflePerLane(input, subtractGreenFromBlueAndRedMask);
+                Vector256<byte> output = input - in0g0g;
                 Unsafe.As<uint, Vector256<uint>>(ref pos) = output.AsUInt32();
                 i += 8;
             }
@@ -201,39 +183,17 @@ internal static unsafe class LosslessUtils
                 SubtractGreenFromBlueAndRedScalar(pixelData[(int)i..]);
             }
         }
-        else if (Ssse3.IsSupported && pixelData.Length >= 4)
-        {
-            Vector128<byte> subtractGreenFromBlueAndRedMaskSsse3 = Vector128.Create(1, 255, 1, 255, 5, 255, 5, 255, 9, 255, 9, 255, 13, 255, 13, 255);
-            nuint numPixels = (uint)pixelData.Length;
-            nuint i = 0;
-            do
-            {
-                ref uint pos = ref Unsafe.Add(ref MemoryMarshal.GetReference(pixelData), i);
-                Vector128<byte> input = Unsafe.As<uint, Vector128<uint>>(ref pos).AsByte();
-                Vector128<byte> in0g0g = Ssse3.Shuffle(input, subtractGreenFromBlueAndRedMaskSsse3);
-                Vector128<byte> output = Sse2.Subtract(input, in0g0g);
-                Unsafe.As<uint, Vector128<uint>>(ref pos) = output.AsUInt32();
-                i += 4;
-            }
-            while (i <= numPixels - 4);
-
-            if (i != numPixels)
-            {
-                SubtractGreenFromBlueAndRedScalar(pixelData[(int)i..]);
-            }
-        }
-        else if (Sse2.IsSupported && pixelData.Length >= 4)
+        else if (Vector128.IsHardwareAccelerated && pixelData.Length >= 4)
         {
+            Vector128<byte> subtractGreenFromBlueAndRedMask = Vector128.Create(1, 255, 1, 255, 5, 255, 5, 255, 9, 255, 9, 255, 13, 255, 13, 255);
             nuint numPixels = (uint)pixelData.Length;
             nuint i = 0;
             do
             {
                 ref uint pos = ref Unsafe.Add(ref MemoryMarshal.GetReference(pixelData), i);
                 Vector128<byte> input = Unsafe.As<uint, Vector128<uint>>(ref pos).AsByte();
-                Vector128<ushort> a = Sse2.ShiftRightLogical(input.AsUInt16(), 8); // 0 a 0 g
-                Vector128<ushort> b = Sse2.ShuffleLow(a, SimdUtils.Shuffle.MMShuffle2200);
-                Vector128<ushort> c = Sse2.ShuffleHigh(b, SimdUtils.Shuffle.MMShuffle2200); // 0g0g
-                Vector128<byte> output = Sse2.Subtract(input.AsByte(), c.AsByte());
+                Vector128<byte> in0g0g = Vector128_.ShuffleNative(input, subtractGreenFromBlueAndRedMask);
+                Vector128<byte> output = input - in0g0g;
                 Unsafe.As<uint, Vector128<uint>>(ref pos) = output.AsUInt32();
                 i += 4;
             }
@@ -412,7 +372,7 @@ internal static unsafe class LosslessUtils
                 TransformColorScalar(m, pixelData[(int)idx..], numPixels - (int)idx);
             }
         }
-        else if (Sse2.IsSupported && numPixels >= 4)
+        else if (Vector128.IsHardwareAccelerated && numPixels >= 4)
         {
             Vector128<byte> transformColorAlphaGreenMask = Vector128.Create(0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255);
             Vector128<byte> transformColorRedBlueMask = Vector128.Create(255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0);
@@ -423,16 +383,16 @@ internal static unsafe class LosslessUtils
             {
                 ref uint pos = ref Unsafe.Add(ref MemoryMarshal.GetReference(pixelData), idx);
                 Vector128<uint> input = Unsafe.As<uint, Vector128<uint>>(ref pos);
-                Vector128<byte> a = Sse2.And(input.AsByte(), transformColorAlphaGreenMask);
-                Vector128<short> b = Sse2.ShuffleLow(a.AsInt16(), SimdUtils.Shuffle.MMShuffle2200);
-                Vector128<short> c = Sse2.ShuffleHigh(b.AsInt16(), SimdUtils.Shuffle.MMShuffle2200);
-                Vector128<short> d = Sse2.MultiplyHigh(c.AsInt16(), multsrb.AsInt16());
-                Vector128<short> e = Sse2.ShiftLeftLogical(input.AsInt16(), 8);
-                Vector128<short> f = Sse2.MultiplyHigh(e.AsInt16(), multsb2.AsInt16());
-                Vector128<int> g = Sse2.ShiftRightLogical(f.AsInt32(), 16);
-                Vector128<byte> h = Sse2.Add(g.AsByte(), d.AsByte());
-                Vector128<byte> i = Sse2.And(h, transformColorRedBlueMask);
-                Vector128<byte> output = Sse2.Subtract(input.AsByte(), i);
+                Vector128<byte> a = input.AsByte() & transformColorAlphaGreenMask;
+                Vector128<short> b = Vector128_.ShuffleLow(a.AsInt16(), SimdUtils.Shuffle.MMShuffle2200);
+                Vector128<short> c = Vector128_.ShuffleHigh(b.AsInt16(), SimdUtils.Shuffle.MMShuffle2200);
+                Vector128<short> d = Vector128_.MultiplyHigh(c.AsInt16(), multsrb.AsInt16());
+                Vector128<short> e = Vector128_.ShiftLeftLogical(input.AsInt16(), 8);
+                Vector128<short> f = Vector128_.MultiplyHigh(e.AsInt16(), multsb2.AsInt16());
+                Vector128<int> g = Vector128.ShiftRightLogical(f.AsInt32(), 16);
+                Vector128<byte> h = g.AsByte() + d.AsByte();
+                Vector128<byte> i = h & transformColorRedBlueMask;
+                Vector128<byte> output = input.AsByte() - i;
                 Unsafe.As<uint, Vector128<uint>>(ref pos) = output.AsUInt32();
                 idx += 4;
             }
@@ -503,7 +463,7 @@ internal static unsafe class LosslessUtils
                 TransformColorInverseScalar(m, pixelData[(int)idx..]);
             }
         }
-        else if (Sse2.IsSupported && pixelData.Length >= 4)
+        else if (Vector128.IsHardwareAccelerated && pixelData.Length >= 4)
         {
             Vector128<byte> transformColorInverseAlphaGreenMask = Vector128.Create(0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255);
             Vector128<int> multsrb = MkCst16(Cst5b(m.GreenToRed), Cst5b(m.GreenToBlue));
@@ -514,17 +474,17 @@ internal static unsafe class LosslessUtils
             {
                 ref uint pos = ref Unsafe.Add(ref MemoryMarshal.GetReference(pixelData), idx);
                 Vector128<uint> input = Unsafe.As<uint, Vector128<uint>>(ref pos);
-                Vector128<byte> a = Sse2.And(input.AsByte(), transformColorInverseAlphaGreenMask);
-                Vector128<short> b = Sse2.ShuffleLow(a.AsInt16(), SimdUtils.Shuffle.MMShuffle2200);
-                Vector128<short> c = Sse2.ShuffleHigh(b.AsInt16(), SimdUtils.Shuffle.MMShuffle2200);
-                Vector128<short> d = Sse2.MultiplyHigh(c.AsInt16(), multsrb.AsInt16());
-                Vector128<byte> e = Sse2.Add(input.AsByte(), d.AsByte());
-                Vector128<short> f = Sse2.ShiftLeftLogical(e.AsInt16(), 8);
-                Vector128<short> g = Sse2.MultiplyHigh(f, multsb2.AsInt16());
-                Vector128<int> h = Sse2.ShiftRightLogical(g.AsInt32(), 8);
-                Vector128<byte> i = Sse2.Add(h.AsByte(), f.AsByte());
-                Vector128<short> j = Sse2.ShiftRightLogical(i.AsInt16(), 8);
-                Vector128<byte> output = Sse2.Or(j.AsByte(), a);
+                Vector128<byte> a = input.AsByte() & transformColorInverseAlphaGreenMask;
+                Vector128<short> b = Vector128_.ShuffleLow(a.AsInt16(), SimdUtils.Shuffle.MMShuffle2200);
+                Vector128<short> c = Vector128_.ShuffleHigh(b.AsInt16(), SimdUtils.Shuffle.MMShuffle2200);
+                Vector128<short> d = Vector128_.MultiplyHigh(c.AsInt16(), multsrb.AsInt16());
+                Vector128<byte> e = input.AsByte() + d.AsByte();
+                Vector128<short> f = Vector128_.ShiftLeftLogical(e.AsInt16(), 8);
+                Vector128<short> g = Vector128_.MultiplyHigh(f, multsb2.AsInt16());
+                Vector128<int> h = Vector128.ShiftRightLogical(g.AsInt32(), 8);
+                Vector128<byte> i = h.AsByte() + f.AsByte();
+                Vector128<short> j = Vector128.ShiftRightLogical(i.AsInt16(), 8);
+                Vector128<byte> output = j.AsByte() | a;
                 Unsafe.As<uint, Vector128<uint>>(ref pos) = output.AsUInt32();
             }
 
@@ -1401,15 +1361,15 @@ internal static unsafe class LosslessUtils
 
     private static uint ClampedAddSubtractFull(uint c0, uint c1, uint c2)
     {
-        if (Sse2.IsSupported)
+        if (Vector128.IsHardwareAccelerated)
         {
-            Vector128<byte> c0Vec = Sse2.UnpackLow(Sse2.ConvertScalarToVector128UInt32(c0).AsByte(), Vector128<byte>.Zero);
-            Vector128<byte> c1Vec = Sse2.UnpackLow(Sse2.ConvertScalarToVector128UInt32(c1).AsByte(), Vector128<byte>.Zero);
-            Vector128<byte> c2Vec = Sse2.UnpackLow(Sse2.ConvertScalarToVector128UInt32(c2).AsByte(), Vector128<byte>.Zero);
-            Vector128<short> v1 = Sse2.Add(c0Vec.AsInt16(), c1Vec.AsInt16());
-            Vector128<short> v2 = Sse2.Subtract(v1, c2Vec.AsInt16());
-            Vector128<byte> b = Sse2.PackUnsignedSaturate(v2, v2);
-            return Sse2.ConvertToUInt32(b.AsUInt32());
+            Vector128<byte> c0Vec = Vector128_.UnpackLow(Vector128.CreateScalar(c0).AsByte(), Vector128<byte>.Zero);
+            Vector128<byte> c1Vec = Vector128_.UnpackLow(Vector128.CreateScalar(c1).AsByte(), Vector128<byte>.Zero);
+            Vector128<byte> c2Vec = Vector128_.UnpackLow(Vector128.CreateScalar(c2).AsByte(), Vector128<byte>.Zero);
+            Vector128<short> v1 = c0Vec.AsInt16() + c1Vec.AsInt16();
+            Vector128<short> v2 = v1 - c2Vec.AsInt16();
+            Vector128<byte> b = Vector128_.PackUnsignedSaturate(v2, v2);
+            return b.AsUInt32().ToScalar();
         }
 
         {
@@ -1432,20 +1392,20 @@ internal static unsafe class LosslessUtils
 
     private static uint ClampedAddSubtractHalf(uint c0, uint c1, uint c2)
     {
-        if (Sse2.IsSupported)
+        if (Vector128.IsHardwareAccelerated)
         {
-            Vector128<byte> c0Vec = Sse2.UnpackLow(Sse2.ConvertScalarToVector128UInt32(c0).AsByte(), Vector128<byte>.Zero);
-            Vector128<byte> c1Vec = Sse2.UnpackLow(Sse2.ConvertScalarToVector128UInt32(c1).AsByte(), Vector128<byte>.Zero);
-            Vector128<byte> b0 = Sse2.UnpackLow(Sse2.ConvertScalarToVector128UInt32(c2).AsByte(), Vector128<byte>.Zero);
-            Vector128<short> avg = Sse2.Add(c1Vec.AsInt16(), c0Vec.AsInt16());
-            Vector128<short> a0 = Sse2.ShiftRightLogical(avg, 1);
-            Vector128<short> a1 = Sse2.Subtract(a0, b0.AsInt16());
-            Vector128<short> bgta = Sse2.CompareGreaterThan(b0.AsInt16(), a0.AsInt16());
-            Vector128<short> a2 = Sse2.Subtract(a1, bgta);
-            Vector128<short> a3 = Sse2.ShiftRightArithmetic(a2, 1);
-            Vector128<short> a4 = Sse2.Add(a0, a3).AsInt16();
-            Vector128<byte> a5 = Sse2.PackUnsignedSaturate(a4, a4);
-            return Sse2.ConvertToUInt32(a5.AsUInt32());
+            Vector128<byte> c0Vec = Vector128_.UnpackLow(Vector128.CreateScalar(c0).AsByte(), Vector128<byte>.Zero);
+            Vector128<byte> c1Vec = Vector128_.UnpackLow(Vector128.CreateScalar(c1).AsByte(), Vector128<byte>.Zero);
+            Vector128<byte> b0 = Vector128_.UnpackLow(Vector128.CreateScalar(c2).AsByte(), Vector128<byte>.Zero);
+            Vector128<short> avg = c1Vec.AsInt16() + c0Vec.AsInt16();
+            Vector128<short> a0 = Vector128.ShiftRightLogical(avg, 1);
+            Vector128<short> a1 = a0 - b0.AsInt16();
+            Vector128<short> bgta = Vector128.GreaterThan(b0.AsInt16(), a0.AsInt16());
+            Vector128<short> a2 = a1 - bgta;
+            Vector128<short> a3 = Vector128.ShiftRightArithmetic(a2, 1);
+            Vector128<short> a4 = (a0 + a3).AsInt16();
+            Vector128<byte> a5 = Vector128_.PackUnsignedSaturate(a4, a4);
+            return a5.AsUInt32().ToScalar();
         }
 
         {
@@ -1475,23 +1435,23 @@ internal static unsafe class LosslessUtils
 
     private static uint Select(uint a, uint b, uint c, Span<short> scratch)
     {
-        if (Sse2.IsSupported)
+        if (Vector128.IsHardwareAccelerated)
         {
             fixed (short* ptr = &MemoryMarshal.GetReference(scratch))
             {
-                Vector128<byte> a0 = Sse2.ConvertScalarToVector128UInt32(a).AsByte();
-                Vector128<byte> b0 = Sse2.ConvertScalarToVector128UInt32(b).AsByte();
-                Vector128<byte> c0 = Sse2.ConvertScalarToVector128UInt32(c).AsByte();
-                Vector128<byte> ac0 = Sse2.SubtractSaturate(a0, c0);
-                Vector128<byte> ca0 = Sse2.SubtractSaturate(c0, a0);
-                Vector128<byte> bc0 = Sse2.SubtractSaturate(b0, c0);
-                Vector128<byte> cb0 = Sse2.SubtractSaturate(c0, b0);
-                Vector128<byte> ac = Sse2.Or(ac0, ca0);
-                Vector128<byte> bc = Sse2.Or(bc0, cb0);
-                Vector128<byte> pa = Sse2.UnpackLow(ac, Vector128<byte>.Zero); // |a - c|
-                Vector128<byte> pb = Sse2.UnpackLow(bc, Vector128<byte>.Zero); // |b - c|
-                Vector128<ushort> diff = Sse2.Subtract(pb.AsUInt16(), pa.AsUInt16());
-                Sse2.Store((ushort*)ptr, diff);
+                Vector128<byte> a0 = Vector128.CreateScalar(a).AsByte();
+                Vector128<byte> b0 = Vector128.CreateScalar(b).AsByte();
+                Vector128<byte> c0 = Vector128.CreateScalar(c).AsByte();
+                Vector128<byte> ac0 = Vector128_.SubtractSaturate(a0, c0);
+                Vector128<byte> ca0 = Vector128_.SubtractSaturate(c0, a0);
+                Vector128<byte> bc0 = Vector128_.SubtractSaturate(b0, c0);
+                Vector128<byte> cb0 = Vector128_.SubtractSaturate(c0, b0);
+                Vector128<byte> ac = ac0 | ca0;
+                Vector128<byte> bc = bc0 | cb0;
+                Vector128<byte> pa = Vector128_.UnpackLow(ac, Vector128<byte>.Zero); // |a - c|
+                Vector128<byte> pb = Vector128_.UnpackLow(bc, Vector128<byte>.Zero); // |b - c|
+                Vector128<ushort> diff = pb.AsUInt16() - pa.AsUInt16();
+                diff.Store((ushort*)ptr);
                 int paMinusPb = ptr[3] + ptr[2] + ptr[1] + ptr[0];
                 return (paMinusPb <= 0) ? a : b;
             }
diff --git a/src/ImageSharp/Formats/Webp/Lossless/PixOrCopy.cs b/src/ImageSharp/Formats/Webp/Lossless/PixOrCopy.cs
index d6b10ada55..bb8ce18aad 100644
--- a/src/ImageSharp/Formats/Webp/Lossless/PixOrCopy.cs
+++ b/src/ImageSharp/Formats/Webp/Lossless/PixOrCopy.cs
@@ -6,37 +6,24 @@ using System.Diagnostics;
 namespace SixLabors.ImageSharp.Formats.Webp.Lossless;
 
 [DebuggerDisplay("Mode: {Mode}, Len: {Len}, BgraOrDistance: {BgraOrDistance}")]
-internal sealed class PixOrCopy
+internal readonly struct PixOrCopy
 {
-    public PixOrCopyMode Mode { get; set; }
-
-    public ushort Len { get; set; }
-
-    public uint BgraOrDistance { get; set; }
-
-    public static PixOrCopy CreateCacheIdx(int idx) =>
-        new PixOrCopy
-        {
-            Mode = PixOrCopyMode.CacheIdx,
-            BgraOrDistance = (uint)idx,
-            Len = 1
-        };
-
-    public static PixOrCopy CreateLiteral(uint bgra) =>
-        new PixOrCopy
-        {
-            Mode = PixOrCopyMode.Literal,
-            BgraOrDistance = bgra,
-            Len = 1
-        };
-
-    public static PixOrCopy CreateCopy(uint distance, ushort len) =>
-        new PixOrCopy
+    public readonly PixOrCopyMode Mode;
+    public readonly ushort Len;
+    public readonly uint BgraOrDistance;
+
+    private PixOrCopy(PixOrCopyMode mode, ushort len, uint bgraOrDistance)
     {
-        Mode = PixOrCopyMode.Copy,
-        BgraOrDistance = distance,
-        Len = len
-    };
+        this.Mode = mode;
+        this.Len = len;
+        this.BgraOrDistance = bgraOrDistance;
+    }
+
+    public static PixOrCopy CreateCacheIdx(int idx) => new(PixOrCopyMode.CacheIdx, 1, (uint)idx);
+
+    public static PixOrCopy CreateLiteral(uint bgra) => new(PixOrCopyMode.Literal, 1, bgra);
+
+    public static PixOrCopy CreateCopy(uint distance, ushort len) => new(PixOrCopyMode.Copy, len, distance);
 
     public int Literal(int component) => (int)(this.BgraOrDistance >> (component * 8)) & 0xFF;
 
diff --git a/src/ImageSharp/Formats/Webp/Lossless/PredictorEncoder.cs b/src/ImageSharp/Formats/Webp/Lossless/PredictorEncoder.cs
index 736070a1c9..0e3b274914 100644
--- a/src/ImageSharp/Formats/Webp/Lossless/PredictorEncoder.cs
+++ b/src/ImageSharp/Formats/Webp/Lossless/PredictorEncoder.cs
@@ -12,9 +12,9 @@ namespace SixLabors.ImageSharp.Formats.Webp.Lossless;
 internal static unsafe class PredictorEncoder
 {
     private static readonly sbyte[][] Offset =
-    {
-        new sbyte[] { 0, -1 }, new sbyte[] { 0, 1 }, new sbyte[] { -1, 0 }, new sbyte[] { 1, 0 }, new sbyte[] { -1, -1 }, new sbyte[] { -1, 1 }, new sbyte[] { 1, -1 }, new sbyte[] { 1, 1 }
-    };
+    [
+        [0, -1], [0, 1], [-1, 0], [1, 0], [-1, -1], [-1, 1], [1, -1], [1, 1]
+    ];
 
     private const int GreenRedToBlueNumAxis = 8;
 
@@ -29,7 +29,7 @@ internal static unsafe class PredictorEncoder
     private const int PredLowEffort = 11;
 
     // This uses C#'s compiler optimization to refer to assembly's static data directly.
-    private static ReadOnlySpan<sbyte> DeltaLut => new sbyte[] { 16, 16, 8, 4, 2, 2, 2 };
+    private static ReadOnlySpan<sbyte> DeltaLut => [16, 16, 8, 4, 2, 2, 2];
 
     /// <summary>
     /// Finds the best predictor for each tile, and converts the image to residuals
@@ -58,12 +58,12 @@ internal static unsafe class PredictorEncoder
 
         // TODO: Can we optimize this?
         int[][] histo =
-        {
+        [
             new int[256],
             new int[256],
             new int[256],
             new int[256]
-        };
+        ];
 
         if (lowEffort)
         {
@@ -122,8 +122,8 @@ internal static unsafe class PredictorEncoder
         int tileYSize = LosslessUtils.SubSampleSize(height, bits);
         int[] accumulatedRedHisto = new int[256];
         int[] accumulatedBlueHisto = new int[256];
-        var prevX = default(Vp8LMultipliers);
-        var prevY = default(Vp8LMultipliers);
+        Vp8LMultipliers prevX = default(Vp8LMultipliers);
+        Vp8LMultipliers prevY = default(Vp8LMultipliers);
         for (int tileY = 0; tileY < tileYSize; tileY++)
         {
             for (int tileX = 0; tileX < tileXSize; tileX++)
@@ -856,7 +856,7 @@ internal static unsafe class PredictorEncoder
         int tileHeight = allYMax - tileYOffset;
         Span<uint> tileArgb = argb[((tileYOffset * xSize) + tileXOffset)..];
 
-        var bestTx = default(Vp8LMultipliers);
+        Vp8LMultipliers bestTx = default(Vp8LMultipliers);
 
         GetBestGreenToRed(tileArgb, xSize, scratch, tileWidth, tileHeight, prevX, prevY, quality, accumulatedRedHisto, ref bestTx);
 
diff --git a/src/ImageSharp/Formats/Webp/Lossless/Vp8LBackwardRefs.cs b/src/ImageSharp/Formats/Webp/Lossless/Vp8LBackwardRefs.cs
index ace9d62271..634fac5e82 100644
--- a/src/ImageSharp/Formats/Webp/Lossless/Vp8LBackwardRefs.cs
+++ b/src/ImageSharp/Formats/Webp/Lossless/Vp8LBackwardRefs.cs
@@ -1,21 +1,28 @@
 // Copyright (c) Six Labors.
 // Licensed under the Six Labors Split License.
 
+using System.Buffers;
+using SixLabors.ImageSharp.Memory;
+
 namespace SixLabors.ImageSharp.Formats.Webp.Lossless;
 
-internal class Vp8LBackwardRefs
+internal class Vp8LBackwardRefs : IDisposable
 {
-    public Vp8LBackwardRefs(int pixels) => this.Refs = new List<PixOrCopy>(pixels);
+    private readonly IMemoryOwner<PixOrCopy> refs;
+    private int count;
+
+    public Vp8LBackwardRefs(MemoryAllocator memoryAllocator, int pixels)
+    {
+        this.refs = memoryAllocator.Allocate<PixOrCopy>(pixels);
+        this.count = 0;
+    }
+
+    public void Add(PixOrCopy pixOrCopy) => this.refs.Memory.Span[this.count++] = pixOrCopy;
 
-    /// <summary>
-    /// Gets or sets the common block-size.
-    /// </summary>
-    public int BlockSize { get; set; }
+    public void Clear() => this.count = 0;
 
-    /// <summary>
-    /// Gets the backward references.
-    /// </summary>
-    public List<PixOrCopy> Refs { get; }
+    public Span<PixOrCopy>.Enumerator GetEnumerator() => this.refs.Slice(0, this.count).GetEnumerator();
 
-    public void Add(PixOrCopy pixOrCopy) => this.Refs.Add(pixOrCopy);
+    /// <inheritdoc/>
+    public void Dispose() => this.refs.Dispose();
 }
diff --git a/src/ImageSharp/Formats/Webp/Lossless/Vp8LEncoder.cs b/src/ImageSharp/Formats/Webp/Lossless/Vp8LEncoder.cs
index f088448391..b398554eb1 100644
--- a/src/ImageSharp/Formats/Webp/Lossless/Vp8LEncoder.cs
+++ b/src/ImageSharp/Formats/Webp/Lossless/Vp8LEncoder.cs
@@ -26,9 +26,9 @@ internal class Vp8LEncoder : IDisposable
     /// </summary>
     private ScratchBuffer scratch;  // mutable struct, don't make readonly
 
-    private readonly int[][] histoArgb = { new int[256], new int[256], new int[256], new int[256] };
+    private readonly int[][] histoArgb = [new int[256], new int[256], new int[256], new int[256]];
 
-    private readonly int[][] bestHisto = { new int[256], new int[256], new int[256], new int[256] };
+    private readonly int[][] bestHisto = [new int[256], new int[256], new int[256], new int[256]];
 
     /// <summary>
     /// The <see cref="MemoryAllocator"/> to use for buffer allocations.
@@ -45,11 +45,6 @@ internal class Vp8LEncoder : IDisposable
     /// </summary>
     private const int MaxRefsBlockPerImage = 16;
 
-    /// <summary>
-    /// Minimum block size for backward references.
-    /// </summary>
-    private const int MinBlockSize = 256;
-
     /// <summary>
     /// A bit writer for writing lossless webp streams.
     /// </summary>
@@ -136,14 +131,9 @@ internal class Vp8LEncoder : IDisposable
         this.Refs = new Vp8LBackwardRefs[3];
         this.HashChain = new Vp8LHashChain(memoryAllocator, pixelCount);
 
-        // We round the block size up, so we're guaranteed to have at most MaxRefsBlockPerImage blocks used:
-        int refsBlockSize = ((pixelCount - 1) / MaxRefsBlockPerImage) + 1;
         for (int i = 0; i < this.Refs.Length; i++)
         {
-            this.Refs[i] = new Vp8LBackwardRefs(pixelCount)
-            {
-                BlockSize = refsBlockSize < MinBlockSize ? MinBlockSize : refsBlockSize
-            };
+            this.Refs[i] = new Vp8LBackwardRefs(memoryAllocator, pixelCount);
         }
     }
 
@@ -151,10 +141,10 @@ internal class Vp8LEncoder : IDisposable
     // This sequence is tuned from that, but more weighted for lower symbol count,
     // and more spiking histograms.
     // This uses C#'s compiler optimization to refer to assembly's static data directly.
-    private static ReadOnlySpan<byte> StorageOrder => new byte[] { 17, 18, 0, 1, 2, 3, 4, 5, 16, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15 };
+    private static ReadOnlySpan<byte> StorageOrder => [17, 18, 0, 1, 2, 3, 4, 5, 16, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15];
 
     // This uses C#'s compiler optimization to refer to assembly's static data directly.
-    private static ReadOnlySpan<byte> Order => new byte[] { 1, 2, 0, 3 };
+    private static ReadOnlySpan<byte> Order => [1, 2, 0, 3];
 
     /// <summary>
     /// Gets the memory for the image data as packed bgra values.
@@ -371,9 +361,6 @@ internal class Vp8LEncoder : IDisposable
     /// <param name="inputImgHeight">The input image height.</param>
     private void WriteImageSize(int inputImgWidth, int inputImgHeight)
     {
-        Guard.MustBeLessThan(inputImgWidth, WebpConstants.MaxDimension, nameof(inputImgWidth));
-        Guard.MustBeLessThan(inputImgHeight, WebpConstants.MaxDimension, nameof(inputImgHeight));
-
         uint width = (uint)inputImgWidth - 1;
         uint height = (uint)inputImgHeight - 1;
 
@@ -550,7 +537,7 @@ internal class Vp8LEncoder : IDisposable
         EntropyIx entropyIdx = this.AnalyzeEntropy(bgra, width, height, usePalette, this.PaletteSize, this.TransformBits, out redAndBlueAlwaysZero);
 
         bool doNotCache = false;
-        List<CrunchConfig> crunchConfigs = new();
+        List<CrunchConfig> crunchConfigs = [];
 
         if (this.method == WebpEncodingMethod.BestQuality && this.quality == 100)
         {
@@ -596,7 +583,7 @@ internal class Vp8LEncoder : IDisposable
             }
         }
 
-        return crunchConfigs.ToArray();
+        return [.. crunchConfigs];
     }
 
     private void EncodeImage(int width, int height, bool useCache, CrunchConfig config, int cacheBits, bool lowEffort)
@@ -1071,9 +1058,8 @@ internal class Vp8LEncoder : IDisposable
         int histogramIx = histogramSymbols[0];
         Span<HuffmanTreeCode> codes = huffmanCodes.AsSpan(5 * histogramIx);
 
-        for (int i = 0; i < backwardRefs.Refs.Count; i++)
+        foreach (PixOrCopy v in backwardRefs)
         {
-            PixOrCopy v = backwardRefs.Refs[i];
             if (tileX != (x & tileMask) || tileY != (y & tileMask))
             {
                 tileX = x & tileMask;
@@ -1268,13 +1254,13 @@ internal class Vp8LEncoder : IDisposable
         // non-zero red and blue values. If all are zero, we can later skip
         // the cross color optimization.
         byte[][] histoPairs =
-        {
-            new[] { (byte)HistoIx.HistoRed, (byte)HistoIx.HistoBlue },
-            new[] { (byte)HistoIx.HistoRedPred, (byte)HistoIx.HistoBluePred },
-            new[] { (byte)HistoIx.HistoRedSubGreen, (byte)HistoIx.HistoBlueSubGreen },
-            new[] { (byte)HistoIx.HistoRedPredSubGreen, (byte)HistoIx.HistoBluePredSubGreen },
-            new[] { (byte)HistoIx.HistoRed, (byte)HistoIx.HistoBlue }
-        };
+        [
+            [(byte)HistoIx.HistoRed, (byte)HistoIx.HistoBlue],
+            [(byte)HistoIx.HistoRedPred, (byte)HistoIx.HistoBluePred],
+            [(byte)HistoIx.HistoRedSubGreen, (byte)HistoIx.HistoBlueSubGreen],
+            [(byte)HistoIx.HistoRedPredSubGreen, (byte)HistoIx.HistoBluePredSubGreen],
+            [(byte)HistoIx.HistoRed, (byte)HistoIx.HistoBlue]
+        ];
         Span<uint> redHisto = histo[(256 * histoPairs[(int)minEntropyIx][0])..];
         Span<uint> blueHisto = histo[(256 * histoPairs[(int)minEntropyIx][1])..];
         for (int i = 1; i < 256; i++)
@@ -1328,7 +1314,7 @@ internal class Vp8LEncoder : IDisposable
     /// <returns>The number of palette entries.</returns>
     private static int GetColorPalette(ReadOnlySpan<uint> bgra, int width, int height, Span<uint> palette)
     {
-        HashSet<uint> colors = new();
+        HashSet<uint> colors = [];
         for (int y = 0; y < height; y++)
         {
             ReadOnlySpan<uint> bgraRow = bgra.Slice(y * width, width);
@@ -1907,9 +1893,9 @@ internal class Vp8LEncoder : IDisposable
     /// </summary>
     public void ClearRefs()
     {
-        foreach (Vp8LBackwardRefs t in this.Refs)
+        foreach (Vp8LBackwardRefs refs in this.Refs)
         {
-            t.Refs.Clear();
+            refs.Clear();
         }
     }
 
@@ -1921,6 +1907,12 @@ internal class Vp8LEncoder : IDisposable
         this.BgraScratch?.Dispose();
         this.Palette.Dispose();
         this.TransformData?.Dispose();
+
+        foreach (Vp8LBackwardRefs refs in this.Refs)
+        {
+            refs.Dispose();
+        }
+
         this.HashChain.Dispose();
     }
 
diff --git a/src/ImageSharp/Formats/Webp/Lossless/Vp8LHistogram.cs b/src/ImageSharp/Formats/Webp/Lossless/Vp8LHistogram.cs
index f473977908..03bedfe672 100644
--- a/src/ImageSharp/Formats/Webp/Lossless/Vp8LHistogram.cs
+++ b/src/ImageSharp/Formats/Webp/Lossless/Vp8LHistogram.cs
@@ -138,9 +138,9 @@ internal abstract unsafe class Vp8LHistogram
     /// <param name="refs">The backward references.</param>
     public void StoreRefs(Vp8LBackwardRefs refs)
     {
-        for (int i = 0; i < refs.Refs.Count; i++)
+        foreach (PixOrCopy v in refs)
         {
-            this.AddSinglePixOrCopy(refs.Refs[i], false);
+            this.AddSinglePixOrCopy(in v, false);
         }
     }
 
@@ -150,7 +150,7 @@ internal abstract unsafe class Vp8LHistogram
     /// <param name="v">The token to add.</param>
     /// <param name="useDistanceModifier">Indicates whether to use the distance modifier.</param>
     /// <param name="xSize">xSize is only used when useDistanceModifier is true.</param>
-    public void AddSinglePixOrCopy(PixOrCopy v, bool useDistanceModifier, int xSize = 0)
+    public void AddSinglePixOrCopy(in PixOrCopy v, bool useDistanceModifier, int xSize = 0)
     {
         if (v.IsLiteral())
         {
diff --git a/src/ImageSharp/Formats/Webp/Lossless/Vp8LHistogramSet.cs b/src/ImageSharp/Formats/Webp/Lossless/Vp8LHistogramSet.cs
index a46838ee67..817641393e 100644
--- a/src/ImageSharp/Formats/Webp/Lossless/Vp8LHistogramSet.cs
+++ b/src/ImageSharp/Formats/Webp/Lossless/Vp8LHistogramSet.cs
@@ -49,9 +49,9 @@ internal sealed class Vp8LHistogramSet : IEnumerable<Vp8LHistogram>, IDisposable
         }
     }
 
-    public Vp8LHistogramSet(int capacity) => this.items = new(capacity);
+    public Vp8LHistogramSet(int capacity) => this.items = new List<Vp8LHistogram>(capacity);
 
-    public Vp8LHistogramSet() => this.items = new();
+    public Vp8LHistogramSet() => this.items = new List<Vp8LHistogram>();
 
     public int Count => this.items.Count;
 
diff --git a/src/ImageSharp/Formats/Webp/Lossless/WebpLosslessDecoder.cs b/src/ImageSharp/Formats/Webp/Lossless/WebpLosslessDecoder.cs
index 6de3ae7497..875149b1bb 100644
--- a/src/ImageSharp/Formats/Webp/Lossless/WebpLosslessDecoder.cs
+++ b/src/ImageSharp/Formats/Webp/Lossless/WebpLosslessDecoder.cs
@@ -49,7 +49,7 @@ internal sealed class WebpLosslessDecoder
     private const int FixedTableSize = (630 * 3) + 410;
 
     private static readonly int[] TableSize =
-    {
+    [
         FixedTableSize + 654,
         FixedTableSize + 656,
         FixedTableSize + 658,
@@ -62,7 +62,7 @@ internal sealed class WebpLosslessDecoder
         FixedTableSize + 1168,
         FixedTableSize + 1680,
         FixedTableSize + 2704
-    };
+    ];
 
     private static readonly int NumCodeLengthCodes = CodeLengthCodeOrder.Length;
 
@@ -80,10 +80,11 @@ internal sealed class WebpLosslessDecoder
     }
 
     // This uses C#'s compiler optimization to refer to assembly's static data directly.
-    private static ReadOnlySpan<byte> CodeLengthCodeOrder => new byte[] { 17, 18, 0, 1, 2, 3, 4, 5, 16, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15 };
+    private static ReadOnlySpan<byte> CodeLengthCodeOrder => [17, 18, 0, 1, 2, 3, 4, 5, 16, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15
+    ];
 
     // This uses C#'s compiler optimization to refer to assembly's static data directly.
-    private static ReadOnlySpan<byte> LiteralMap => new byte[] { 0, 1, 1, 1, 0 };
+    private static ReadOnlySpan<byte> LiteralMap => [0, 1, 1, 1, 0];
 
     /// <summary>
     /// Decodes the lossless webp image from the stream.
diff --git a/src/ImageSharp/Formats/Webp/Lossy/LossyUtils.cs b/src/ImageSharp/Formats/Webp/Lossy/LossyUtils.cs
index aae4181ce0..c65861c4b5 100644
--- a/src/ImageSharp/Formats/Webp/Lossy/LossyUtils.cs
+++ b/src/ImageSharp/Formats/Webp/Lossy/LossyUtils.cs
@@ -5,8 +5,7 @@ using System.Buffers.Binary;
 using System.Runtime.CompilerServices;
 using System.Runtime.InteropServices;
 using System.Runtime.Intrinsics;
-using System.Runtime.Intrinsics.Arm;
-using System.Runtime.Intrinsics.X86;
+using SixLabors.ImageSharp.Common.Helpers;
 
 // ReSharper disable InconsistentNaming
 namespace SixLabors.ImageSharp.Formats.Webp.Lossy;
@@ -17,19 +16,14 @@ internal static class LossyUtils
     [MethodImpl(InliningOptions.ShortMethod)]
     public static int Vp8_Sse16x16(Span<byte> a, Span<byte> b)
     {
-        if (Avx2.IsSupported)
+        if (Vector256.IsHardwareAccelerated)
         {
-            return Vp8_Sse16xN_Avx2(a, b, 4);
+            return Vp8_Sse16xN_Vector256(a, b, 4);
         }
 
-        if (Sse2.IsSupported)
+        if (Vector128.IsHardwareAccelerated)
         {
-            return Vp8_Sse16xN_Sse2(a, b, 8);
-        }
-
-        if (AdvSimd.IsSupported)
-        {
-            return Vp8_Sse16x16_Neon(a, b);
+            return Vp8_16xN_Vector128(a, b, 8);
         }
 
         return Vp8_SseNxN(a, b, 16, 16);
@@ -39,19 +33,14 @@ internal static class LossyUtils
     [MethodImpl(InliningOptions.ShortMethod)]
     public static int Vp8_Sse16x8(Span<byte> a, Span<byte> b)
     {
-        if (Avx2.IsSupported)
-        {
-            return Vp8_Sse16xN_Avx2(a, b, 2);
-        }
-
-        if (Sse2.IsSupported)
+        if (Vector256.IsHardwareAccelerated)
         {
-            return Vp8_Sse16xN_Sse2(a, b, 4);
+            return Vp8_Sse16xN_Vector256(a, b, 2);
         }
 
-        if (AdvSimd.IsSupported)
+        if (Vector128.IsHardwareAccelerated)
         {
-            return Vp8_Sse16x8_Neon(a, b);
+            return Vp8_16xN_Vector128(a, b, 4);
         }
 
         return Vp8_SseNxN(a, b, 16, 8);
@@ -61,40 +50,40 @@ internal static class LossyUtils
     [MethodImpl(InliningOptions.ShortMethod)]
     public static int Vp8_Sse4x4(Span<byte> a, Span<byte> b)
     {
-        if (Avx2.IsSupported)
+        if (Vector256.IsHardwareAccelerated)
         {
             // Load values.
             ref byte aRef = ref MemoryMarshal.GetReference(a);
             ref byte bRef = ref MemoryMarshal.GetReference(b);
-            var a0 = Vector256.Create(
+            Vector256<byte> a0 = Vector256.Create(
                 Unsafe.As<byte, Vector128<byte>>(ref aRef),
                 Unsafe.As<byte, Vector128<byte>>(ref Unsafe.Add(ref aRef, WebpConstants.Bps)));
-            var a1 = Vector256.Create(
+            Vector256<byte> a1 = Vector256.Create(
                 Unsafe.As<byte, Vector128<byte>>(ref Unsafe.Add(ref aRef, WebpConstants.Bps * 2)),
                 Unsafe.As<byte, Vector128<byte>>(ref Unsafe.Add(ref aRef, WebpConstants.Bps * 3)));
-            var b0 = Vector256.Create(
+            Vector256<byte> b0 = Vector256.Create(
                 Unsafe.As<byte, Vector128<byte>>(ref bRef),
                 Unsafe.As<byte, Vector128<byte>>(ref Unsafe.Add(ref bRef, WebpConstants.Bps)));
-            var b1 = Vector256.Create(
+            Vector256<byte> b1 = Vector256.Create(
                 Unsafe.As<byte, Vector128<byte>>(ref Unsafe.Add(ref bRef, WebpConstants.Bps * 2)),
                 Unsafe.As<byte, Vector128<byte>>(ref Unsafe.Add(ref bRef, WebpConstants.Bps * 3)));
 
             // Combine pair of lines.
-            Vector256<int> a01 = Avx2.UnpackLow(a0.AsInt32(), a1.AsInt32());
-            Vector256<int> b01 = Avx2.UnpackLow(b0.AsInt32(), b1.AsInt32());
+            Vector256<int> a01 = Vector256_.UnpackLow(a0.AsInt32(), a1.AsInt32());
+            Vector256<int> b01 = Vector256_.UnpackLow(b0.AsInt32(), b1.AsInt32());
 
             // Convert to 16b.
-            Vector256<byte> a01s = Avx2.UnpackLow(a01.AsByte(), Vector256<byte>.Zero);
-            Vector256<byte> b01s = Avx2.UnpackLow(b01.AsByte(), Vector256<byte>.Zero);
+            Vector256<byte> a01s = Vector256_.UnpackLow(a01.AsByte(), Vector256<byte>.Zero);
+            Vector256<byte> b01s = Vector256_.UnpackLow(b01.AsByte(), Vector256<byte>.Zero);
 
             // subtract, square and accumulate.
-            Vector256<short> d0 = Avx2.SubtractSaturate(a01s.AsInt16(), b01s.AsInt16());
-            Vector256<int> e0 = Avx2.MultiplyAddAdjacent(d0, d0);
+            Vector256<short> d0 = Vector256_.SubtractSaturate(a01s.AsInt16(), b01s.AsInt16());
+            Vector256<int> e0 = Vector256_.MultiplyAddAdjacent(d0, d0);
 
-            return Numerics.ReduceSum(e0);
+            return ReduceSumVector256(e0);
         }
 
-        if (Sse2.IsSupported)
+        if (Vector128.IsHardwareAccelerated)
         {
             // Load values.
             ref byte aRef = ref MemoryMarshal.GetReference(a);
@@ -109,30 +98,25 @@ internal static class LossyUtils
             Vector128<byte> b3 = Unsafe.As<byte, Vector128<byte>>(ref Unsafe.Add(ref bRef, WebpConstants.Bps * 3));
 
             // Combine pair of lines.
-            Vector128<int> a01 = Sse2.UnpackLow(a0.AsInt32(), a1.AsInt32());
-            Vector128<int> a23 = Sse2.UnpackLow(a2.AsInt32(), a3.AsInt32());
-            Vector128<int> b01 = Sse2.UnpackLow(b0.AsInt32(), b1.AsInt32());
-            Vector128<int> b23 = Sse2.UnpackLow(b2.AsInt32(), b3.AsInt32());
+            Vector128<int> a01 = Vector128_.UnpackLow(a0.AsInt32(), a1.AsInt32());
+            Vector128<int> a23 = Vector128_.UnpackLow(a2.AsInt32(), a3.AsInt32());
+            Vector128<int> b01 = Vector128_.UnpackLow(b0.AsInt32(), b1.AsInt32());
+            Vector128<int> b23 = Vector128_.UnpackLow(b2.AsInt32(), b3.AsInt32());
 
             // Convert to 16b.
-            Vector128<byte> a01s = Sse2.UnpackLow(a01.AsByte(), Vector128<byte>.Zero);
-            Vector128<byte> a23s = Sse2.UnpackLow(a23.AsByte(), Vector128<byte>.Zero);
-            Vector128<byte> b01s = Sse2.UnpackLow(b01.AsByte(), Vector128<byte>.Zero);
-            Vector128<byte> b23s = Sse2.UnpackLow(b23.AsByte(), Vector128<byte>.Zero);
+            Vector128<byte> a01s = Vector128_.UnpackLow(a01.AsByte(), Vector128<byte>.Zero);
+            Vector128<byte> a23s = Vector128_.UnpackLow(a23.AsByte(), Vector128<byte>.Zero);
+            Vector128<byte> b01s = Vector128_.UnpackLow(b01.AsByte(), Vector128<byte>.Zero);
+            Vector128<byte> b23s = Vector128_.UnpackLow(b23.AsByte(), Vector128<byte>.Zero);
 
             // subtract, square and accumulate.
-            Vector128<short> d0 = Sse2.SubtractSaturate(a01s.AsInt16(), b01s.AsInt16());
-            Vector128<short> d1 = Sse2.SubtractSaturate(a23s.AsInt16(), b23s.AsInt16());
-            Vector128<int> e0 = Sse2.MultiplyAddAdjacent(d0, d0);
-            Vector128<int> e1 = Sse2.MultiplyAddAdjacent(d1, d1);
-            Vector128<int> sum = Sse2.Add(e0, e1);
+            Vector128<short> d0 = Vector128_.SubtractSaturate(a01s.AsInt16(), b01s.AsInt16());
+            Vector128<short> d1 = Vector128_.SubtractSaturate(a23s.AsInt16(), b23s.AsInt16());
+            Vector128<int> e0 = Vector128_.MultiplyAddAdjacent(d0, d0);
+            Vector128<int> e1 = Vector128_.MultiplyAddAdjacent(d1, d1);
+            Vector128<int> sum = e0 + e1;
 
-            return Numerics.ReduceSum(sum);
-        }
-
-        if (AdvSimd.IsSupported)
-        {
-            return Vp8_Sse4x4_Neon(a, b);
+            return ReduceSumVector128(sum);
         }
 
         return Vp8_SseNxN(a, b, 4, 4);
@@ -158,7 +142,7 @@ internal static class LossyUtils
     }
 
     [MethodImpl(InliningOptions.ShortMethod)]
-    private static int Vp8_Sse16xN_Sse2(Span<byte> a, Span<byte> b, int numPairs)
+    private static int Vp8_16xN_Vector128(Span<byte> a, Span<byte> b, int numPairs)
     {
         Vector128<int> sum = Vector128<int>.Zero;
         nuint offset = 0;
@@ -172,18 +156,18 @@ internal static class LossyUtils
             Vector128<byte> a1 = Unsafe.As<byte, Vector128<byte>>(ref Unsafe.Add(ref aRef, offset + WebpConstants.Bps));
             Vector128<byte> b1 = Unsafe.As<byte, Vector128<byte>>(ref Unsafe.Add(ref bRef, offset + WebpConstants.Bps));
 
-            Vector128<int> sum1 = SubtractAndAccumulate(a0, b0);
-            Vector128<int> sum2 = SubtractAndAccumulate(a1, b1);
-            sum = Sse2.Add(sum, Sse2.Add(sum1, sum2));
+            Vector128<int> sum1 = SubtractAndAccumulateVector128(a0, b0);
+            Vector128<int> sum2 = SubtractAndAccumulateVector128(a1, b1);
+            sum += sum1 + sum2;
 
             offset += 2 * WebpConstants.Bps;
         }
 
-        return Numerics.ReduceSum(sum);
+        return ReduceSumVector128(sum);
     }
 
     [MethodImpl(InliningOptions.ShortMethod)]
-    private static int Vp8_Sse16xN_Avx2(Span<byte> a, Span<byte> b, int numPairs)
+    private static int Vp8_Sse16xN_Vector256(Span<byte> a, Span<byte> b, int numPairs)
     {
         Vector256<int> sum = Vector256<int>.Zero;
         nuint offset = 0;
@@ -192,154 +176,65 @@ internal static class LossyUtils
         for (int i = 0; i < numPairs; i++)
         {
             // Load values.
-            var a0 = Vector256.Create(
+            Vector256<byte> a0 = Vector256.Create(
                 Unsafe.As<byte, Vector128<byte>>(ref Unsafe.Add(ref aRef, offset)),
                 Unsafe.As<byte, Vector128<byte>>(ref Unsafe.Add(ref aRef, offset + WebpConstants.Bps)));
-            var b0 = Vector256.Create(
+            Vector256<byte> b0 = Vector256.Create(
                 Unsafe.As<byte, Vector128<byte>>(ref Unsafe.Add(ref bRef, offset)),
                 Unsafe.As<byte, Vector128<byte>>(ref Unsafe.Add(ref bRef, offset + WebpConstants.Bps)));
-            var a1 = Vector256.Create(
+            Vector256<byte> a1 = Vector256.Create(
                 Unsafe.As<byte, Vector128<byte>>(ref Unsafe.Add(ref aRef, offset + (2 * WebpConstants.Bps))),
                 Unsafe.As<byte, Vector128<byte>>(ref Unsafe.Add(ref aRef, offset + (3 * WebpConstants.Bps))));
-            var b1 = Vector256.Create(
+            Vector256<byte> b1 = Vector256.Create(
                 Unsafe.As<byte, Vector128<byte>>(ref Unsafe.Add(ref bRef, offset + (2 * WebpConstants.Bps))),
                 Unsafe.As<byte, Vector128<byte>>(ref Unsafe.Add(ref bRef, offset + (3 * WebpConstants.Bps))));
 
-            Vector256<int> sum1 = SubtractAndAccumulate(a0, b0);
-            Vector256<int> sum2 = SubtractAndAccumulate(a1, b1);
-            sum = Avx2.Add(sum, Avx2.Add(sum1, sum2));
+            Vector256<int> sum1 = SubtractAndAccumulateVector256(a0, b0);
+            Vector256<int> sum2 = SubtractAndAccumulateVector256(a1, b1);
+            sum += sum1 + sum2;
 
             offset += 4 * WebpConstants.Bps;
         }
 
-        return Numerics.ReduceSum(sum);
+        return ReduceSumVector256(sum);
     }
 
     [MethodImpl(InliningOptions.ShortMethod)]
-    private static unsafe int Vp8_Sse16x16_Neon(Span<byte> a, Span<byte> b)
-    {
-        Vector128<uint> sum = Vector128<uint>.Zero;
-        fixed (byte* aRef = &MemoryMarshal.GetReference(a))
-        {
-            fixed (byte* bRef = &MemoryMarshal.GetReference(b))
-            {
-                for (int y = 0; y < 16; y++)
-                {
-                    sum = AccumulateSSE16Neon(aRef + (y * WebpConstants.Bps), bRef + (y * WebpConstants.Bps), sum);
-                }
-            }
-        }
-
-        return (int)Vector128.Sum(sum);
-    }
-
-    [MethodImpl(InliningOptions.ShortMethod)]
-    private static unsafe int Vp8_Sse16x8_Neon(Span<byte> a, Span<byte> b)
-    {
-        Vector128<uint> sum = Vector128<uint>.Zero;
-        fixed (byte* aRef = &MemoryMarshal.GetReference(a))
-        {
-            fixed (byte* bRef = &MemoryMarshal.GetReference(b))
-            {
-                for (int y = 0; y < 8; y++)
-                {
-                    sum = AccumulateSSE16Neon(aRef + (y * WebpConstants.Bps), bRef + (y * WebpConstants.Bps), sum);
-                }
-            }
-        }
-
-        return (int)Vector128.Sum(sum);
-    }
-
-    [MethodImpl(InliningOptions.ShortMethod)]
-    private static int Vp8_Sse4x4_Neon(Span<byte> a, Span<byte> b)
-    {
-        Vector128<byte> a0 = Load4x4Neon(a).AsByte();
-        Vector128<byte> b0 = Load4x4Neon(b).AsByte();
-        Vector128<byte> absDiff = AdvSimd.AbsoluteDifference(a0, b0);
-        Vector64<byte> absDiffLower = absDiff.GetLower().AsByte();
-        Vector64<byte> absDiffUpper = absDiff.GetUpper().AsByte();
-        Vector128<ushort> prod1 = AdvSimd.MultiplyWideningLower(absDiffLower, absDiffLower);
-        Vector128<ushort> prod2 = AdvSimd.MultiplyWideningLower(absDiffUpper, absDiffUpper);
-
-        // pair-wise adds and widen.
-        Vector128<uint> sum1 = AdvSimd.AddPairwiseWidening(prod1);
-        Vector128<uint> sum2 = AdvSimd.AddPairwiseWidening(prod2);
-
-        Vector128<uint> sum = AdvSimd.Add(sum1, sum2);
-
-        return (int)Vector128.Sum(sum);
-    }
-
-    // Load all 4x4 pixels into a single Vector128<uint>
-    [MethodImpl(InliningOptions.ShortMethod)]
-    private static unsafe Vector128<uint> Load4x4Neon(Span<byte> src)
-    {
-        fixed (byte* srcRef = &MemoryMarshal.GetReference(src))
-        {
-            Vector128<uint> output = Vector128<uint>.Zero;
-            output = AdvSimd.LoadAndInsertScalar(output, 0, (uint*)srcRef);
-            output = AdvSimd.LoadAndInsertScalar(output, 1, (uint*)(srcRef + WebpConstants.Bps));
-            output = AdvSimd.LoadAndInsertScalar(output, 2, (uint*)(srcRef + (WebpConstants.Bps * 2)));
-            output = AdvSimd.LoadAndInsertScalar(output, 3, (uint*)(srcRef + (WebpConstants.Bps * 3)));
-            return output;
-        }
-    }
-
-    [MethodImpl(InliningOptions.ShortMethod)]
-    private static unsafe Vector128<uint> AccumulateSSE16Neon(byte* a, byte* b, Vector128<uint> sum)
-    {
-        Vector128<byte> a0 = AdvSimd.LoadVector128(a);
-        Vector128<byte> b0 = AdvSimd.LoadVector128(b);
-
-        Vector128<byte> absDiff = AdvSimd.AbsoluteDifference(a0, b0);
-        Vector64<byte> absDiffLower = absDiff.GetLower();
-        Vector64<byte> absDiffUpper = absDiff.GetUpper();
-        Vector128<ushort> prod1 = AdvSimd.MultiplyWideningLower(absDiffLower, absDiffLower);
-        Vector128<ushort> prod2 = AdvSimd.MultiplyWideningLower(absDiffUpper, absDiffUpper);
-
-        // pair-wise adds and widen.
-        Vector128<uint> sum1 = AdvSimd.AddPairwiseWidening(prod1);
-        Vector128<uint> sum2 = AdvSimd.AddPairwiseWidening(prod2);
-        return AdvSimd.Add(sum, AdvSimd.Add(sum1, sum2));
-    }
-
-    [MethodImpl(InliningOptions.ShortMethod)]
-    private static Vector128<int> SubtractAndAccumulate(Vector128<byte> a, Vector128<byte> b)
+    private static Vector128<int> SubtractAndAccumulateVector128(Vector128<byte> a, Vector128<byte> b)
     {
         // Take abs(a-b) in 8b.
-        Vector128<byte> ab = Sse2.SubtractSaturate(a, b);
-        Vector128<byte> ba = Sse2.SubtractSaturate(b, a);
-        Vector128<byte> absAb = Sse2.Or(ab, ba);
+        Vector128<byte> ab = Vector128_.SubtractSaturate(a, b);
+        Vector128<byte> ba = Vector128_.SubtractSaturate(b, a);
+        Vector128<byte> absAb = ab | ba;
 
         // Zero-extend to 16b.
-        Vector128<byte> c0 = Sse2.UnpackLow(absAb, Vector128<byte>.Zero);
-        Vector128<byte> c1 = Sse2.UnpackHigh(absAb, Vector128<byte>.Zero);
+        Vector128<byte> c0 = Vector128_.UnpackLow(absAb, Vector128<byte>.Zero);
+        Vector128<byte> c1 = Vector128_.UnpackHigh(absAb, Vector128<byte>.Zero);
 
         // Multiply with self.
-        Vector128<int> sum1 = Sse2.MultiplyAddAdjacent(c0.AsInt16(), c0.AsInt16());
-        Vector128<int> sum2 = Sse2.MultiplyAddAdjacent(c1.AsInt16(), c1.AsInt16());
+        Vector128<int> sum1 = Vector128_.MultiplyAddAdjacent(c0.AsInt16(), c0.AsInt16());
+        Vector128<int> sum2 = Vector128_.MultiplyAddAdjacent(c1.AsInt16(), c1.AsInt16());
 
-        return Sse2.Add(sum1, sum2);
+        return sum1 + sum2;
     }
 
     [MethodImpl(InliningOptions.ShortMethod)]
-    private static Vector256<int> SubtractAndAccumulate(Vector256<byte> a, Vector256<byte> b)
+    private static Vector256<int> SubtractAndAccumulateVector256(Vector256<byte> a, Vector256<byte> b)
     {
         // Take abs(a-b) in 8b.
-        Vector256<byte> ab = Avx2.SubtractSaturate(a, b);
-        Vector256<byte> ba = Avx2.SubtractSaturate(b, a);
-        Vector256<byte> absAb = Avx2.Or(ab, ba);
+        Vector256<byte> ab = Vector256_.SubtractSaturate(a, b);
+        Vector256<byte> ba = Vector256_.SubtractSaturate(b, a);
+        Vector256<byte> absAb = ab | ba;
 
         // Zero-extend to 16b.
-        Vector256<byte> c0 = Avx2.UnpackLow(absAb, Vector256<byte>.Zero);
-        Vector256<byte> c1 = Avx2.UnpackHigh(absAb, Vector256<byte>.Zero);
+        Vector256<byte> c0 = Vector256_.UnpackLow(absAb, Vector256<byte>.Zero);
+        Vector256<byte> c1 = Vector256_.UnpackHigh(absAb, Vector256<byte>.Zero);
 
         // Multiply with self.
-        Vector256<int> sum1 = Avx2.MultiplyAddAdjacent(c0.AsInt16(), c0.AsInt16());
-        Vector256<int> sum2 = Avx2.MultiplyAddAdjacent(c1.AsInt16(), c1.AsInt16());
+        Vector256<int> sum1 = Vector256_.MultiplyAddAdjacent(c0.AsInt16(), c0.AsInt16());
+        Vector256<int> sum2 = Vector256_.MultiplyAddAdjacent(c1.AsInt16(), c1.AsInt16());
 
-        return Avx2.Add(sum1, sum2);
+        return sum1 + sum2;
     }
 
     [MethodImpl(InliningOptions.ShortMethod)]
@@ -378,17 +273,16 @@ internal static class LossyUtils
     [MethodImpl(InliningOptions.ShortMethod)]
     public static int Vp8Disto4X4(Span<byte> a, Span<byte> b, Span<ushort> w, Span<int> scratch)
     {
-        if (Sse41.IsSupported)
+        if (Vector128.IsHardwareAccelerated)
         {
-            int diffSum = TTransformSse41(a, b, w);
+            int diffSum = TTransformVector128(a, b, w);
             return Math.Abs(diffSum) >> 5;
         }
-        else
-        {
-            int sum1 = TTransform(a, w, scratch);
-            int sum2 = TTransform(b, w, scratch);
-            return Math.Abs(sum2 - sum1) >> 5;
-        }
+
+        int sum1 = TTransform(a, w, scratch);
+        int sum2 = TTransform(b, w, scratch);
+
+        return Math.Abs(sum2 - sum1) >> 5;
     }
 
     public static void DC16(Span<byte> dst, Span<byte> yuv, int offset)
@@ -905,7 +799,7 @@ internal static class LossyUtils
     /// Returns the weighted sum of the absolute value of transformed coefficients.
     /// w[] contains a row-major 4 by 4 symmetric matrix.
     /// </summary>
-    public static int TTransformSse41(Span<byte> inputA, Span<byte> inputB, Span<ushort> w)
+    public static int TTransformVector128(Span<byte> inputA, Span<byte> inputB, Span<ushort> w)
     {
         // Load and combine inputs.
         Vector128<byte> ina0 = Unsafe.As<byte, Vector128<byte>>(ref MemoryMarshal.GetReference(inputA));
@@ -918,14 +812,14 @@ internal static class LossyUtils
         Vector128<long> inb3 = Unsafe.As<byte, Vector128<byte>>(ref MemoryMarshal.GetReference(inputB.Slice(WebpConstants.Bps * 3, 16))).AsInt64();
 
         // Combine inA and inB (we'll do two transforms in parallel).
-        Vector128<int> inab0 = Sse2.UnpackLow(ina0.AsInt32(), inb0.AsInt32());
-        Vector128<int> inab1 = Sse2.UnpackLow(ina1.AsInt32(), inb1.AsInt32());
-        Vector128<int> inab2 = Sse2.UnpackLow(ina2.AsInt32(), inb2.AsInt32());
-        Vector128<int> inab3 = Sse2.UnpackLow(ina3.AsInt32(), inb3.AsInt32());
-        Vector128<short> tmp0 = Sse41.ConvertToVector128Int16(inab0.AsByte());
-        Vector128<short> tmp1 = Sse41.ConvertToVector128Int16(inab1.AsByte());
-        Vector128<short> tmp2 = Sse41.ConvertToVector128Int16(inab2.AsByte());
-        Vector128<short> tmp3 = Sse41.ConvertToVector128Int16(inab3.AsByte());
+        Vector128<int> inab0 = Vector128_.UnpackLow(ina0.AsInt32(), inb0.AsInt32());
+        Vector128<int> inab1 = Vector128_.UnpackLow(ina1.AsInt32(), inb1.AsInt32());
+        Vector128<int> inab2 = Vector128_.UnpackLow(ina2.AsInt32(), inb2.AsInt32());
+        Vector128<int> inab3 = Vector128_.UnpackLow(ina3.AsInt32(), inb3.AsInt32());
+        Vector128<short> tmp0 = Vector128.WidenLower(inab0.AsByte()).AsInt16();
+        Vector128<short> tmp1 = Vector128.WidenLower(inab1.AsByte()).AsInt16();
+        Vector128<short> tmp2 = Vector128.WidenLower(inab2.AsByte()).AsInt16();
+        Vector128<short> tmp3 = Vector128.WidenLower(inab3.AsByte()).AsInt16();
 
         // a00 a01 a02 a03   b00 b01 b02 b03
         // a10 a11 a12 a13   b10 b11 b12 b13
@@ -934,21 +828,21 @@ internal static class LossyUtils
         // Vertical pass first to avoid a transpose (vertical and horizontal passes
         // are commutative because w/kWeightY is symmetric) and subsequent transpose.
         // Calculate a and b (two 4x4 at once).
-        Vector128<short> a0 = Sse2.Add(tmp0, tmp2);
-        Vector128<short> a1 = Sse2.Add(tmp1, tmp3);
-        Vector128<short> a2 = Sse2.Subtract(tmp1, tmp3);
-        Vector128<short> a3 = Sse2.Subtract(tmp0, tmp2);
-        Vector128<short> b0 = Sse2.Add(a0, a1);
-        Vector128<short> b1 = Sse2.Add(a3, a2);
-        Vector128<short> b2 = Sse2.Subtract(a3, a2);
-        Vector128<short> b3 = Sse2.Subtract(a0, a1);
+        Vector128<short> a0 = tmp0 + tmp2;
+        Vector128<short> a1 = tmp1 + tmp3;
+        Vector128<short> a2 = tmp1 - tmp3;
+        Vector128<short> a3 = tmp0 - tmp2;
+        Vector128<short> b0 = a0 + a1;
+        Vector128<short> b1 = a3 + a2;
+        Vector128<short> b2 = a3 - a2;
+        Vector128<short> b3 = a0 - a1;
 
         // a00 a01 a02 a03   b00 b01 b02 b03
         // a10 a11 a12 a13   b10 b11 b12 b13
         // a20 a21 a22 a23   b20 b21 b22 b23
         // a30 a31 a32 a33   b30 b31 b32 b33
         // Transpose the two 4x4.
-        Vp8Transpose_2_4x4_16b(b0, b1, b2, b3, out Vector128<long> output0, out Vector128<long> output1, out Vector128<long> output2, out Vector128<long> output3);
+        Vp8Transpose_2_4x4_16bVector128(b0, b1, b2, b3, out Vector128<long> output0, out Vector128<long> output1, out Vector128<long> output2, out Vector128<long> output3);
 
         // a00 a10 a20 a30   b00 b10 b20 b30
         // a01 a11 a21 a31   b01 b11 b21 b31
@@ -959,71 +853,71 @@ internal static class LossyUtils
         Vector128<ushort> w8 = Unsafe.As<ushort, Vector128<ushort>>(ref MemoryMarshal.GetReference(w.Slice(8, 8)));
 
         // Calculate a and b (two 4x4 at once).
-        a0 = Sse2.Add(output0.AsInt16(), output2.AsInt16());
-        a1 = Sse2.Add(output1.AsInt16(), output3.AsInt16());
-        a2 = Sse2.Subtract(output1.AsInt16(), output3.AsInt16());
-        a3 = Sse2.Subtract(output0.AsInt16(), output2.AsInt16());
-        b0 = Sse2.Add(a0, a1);
-        b1 = Sse2.Add(a3, a2);
-        b2 = Sse2.Subtract(a3, a2);
-        b3 = Sse2.Subtract(a0, a1);
+        a0 = output0.AsInt16() + output2.AsInt16();
+        a1 = output1.AsInt16() + output3.AsInt16();
+        a2 = output1.AsInt16() - output3.AsInt16();
+        a3 = output0.AsInt16() - output2.AsInt16();
+        b0 = a0 + a1;
+        b1 = a3 + a2;
+        b2 = a3 - a2;
+        b3 = a0 - a1;
 
         // Separate the transforms of inA and inB.
-        Vector128<long> ab0 = Sse2.UnpackLow(b0.AsInt64(), b1.AsInt64());
-        Vector128<long> ab2 = Sse2.UnpackLow(b2.AsInt64(), b3.AsInt64());
-        Vector128<long> bb0 = Sse2.UnpackHigh(b0.AsInt64(), b1.AsInt64());
-        Vector128<long> bb2 = Sse2.UnpackHigh(b2.AsInt64(), b3.AsInt64());
+        Vector128<long> ab0 = Vector128_.UnpackLow(b0.AsInt64(), b1.AsInt64());
+        Vector128<long> ab2 = Vector128_.UnpackLow(b2.AsInt64(), b3.AsInt64());
+        Vector128<long> bb0 = Vector128_.UnpackHigh(b0.AsInt64(), b1.AsInt64());
+        Vector128<long> bb2 = Vector128_.UnpackHigh(b2.AsInt64(), b3.AsInt64());
 
-        Vector128<ushort> ab0Abs = Ssse3.Abs(ab0.AsInt16());
-        Vector128<ushort> ab2Abs = Ssse3.Abs(ab2.AsInt16());
-        Vector128<ushort> b0Abs = Ssse3.Abs(bb0.AsInt16());
-        Vector128<ushort> bb2Abs = Ssse3.Abs(bb2.AsInt16());
+        Vector128<short> ab0Abs = Vector128.Abs(ab0.AsInt16());
+        Vector128<short> ab2Abs = Vector128.Abs(ab2.AsInt16());
+        Vector128<short> b0Abs = Vector128.Abs(bb0.AsInt16());
+        Vector128<short> bb2Abs = Vector128.Abs(bb2.AsInt16());
 
         // weighted sums.
-        Vector128<int> ab0mulw0 = Sse2.MultiplyAddAdjacent(ab0Abs.AsInt16(), w0.AsInt16());
-        Vector128<int> ab2mulw8 = Sse2.MultiplyAddAdjacent(ab2Abs.AsInt16(), w8.AsInt16());
-        Vector128<int> b0mulw0 = Sse2.MultiplyAddAdjacent(b0Abs.AsInt16(), w0.AsInt16());
-        Vector128<int> bb2mulw8 = Sse2.MultiplyAddAdjacent(bb2Abs.AsInt16(), w8.AsInt16());
-        Vector128<int> ab0ab2Sum = Sse2.Add(ab0mulw0, ab2mulw8);
-        Vector128<int> b0w0bb2w8Sum = Sse2.Add(b0mulw0, bb2mulw8);
+        Vector128<int> ab0mulw0 = Vector128_.MultiplyAddAdjacent(ab0Abs, w0.AsInt16());
+        Vector128<int> ab2mulw8 = Vector128_.MultiplyAddAdjacent(ab2Abs, w8.AsInt16());
+        Vector128<int> b0mulw0 = Vector128_.MultiplyAddAdjacent(b0Abs, w0.AsInt16());
+        Vector128<int> bb2mulw8 = Vector128_.MultiplyAddAdjacent(bb2Abs, w8.AsInt16());
+        Vector128<int> ab0ab2Sum = ab0mulw0 + ab2mulw8;
+        Vector128<int> b0w0bb2w8Sum = b0mulw0 + bb2mulw8;
 
         // difference of weighted sums.
-        Vector128<int> result = Sse2.Subtract(ab0ab2Sum.AsInt32(), b0w0bb2w8Sum.AsInt32());
+        Vector128<int> result = ab0ab2Sum - b0w0bb2w8Sum;
 
-        return Numerics.ReduceSum(result);
+        return ReduceSumVector128(result);
     }
 
     // Transpose two 4x4 16b matrices horizontally stored in registers.
     [MethodImpl(InliningOptions.ShortMethod)]
-    public static void Vp8Transpose_2_4x4_16b(Vector128<short> b0, Vector128<short> b1, Vector128<short> b2, Vector128<short> b3, out Vector128<long> output0, out Vector128<long> output1, out Vector128<long> output2, out Vector128<long> output3)
+    public static void Vp8Transpose_2_4x4_16bVector128(Vector128<short> b0, Vector128<short> b1, Vector128<short> b2, Vector128<short> b3, out Vector128<long> output0, out Vector128<long> output1, out Vector128<long> output2, out Vector128<long> output3)
     {
         // Transpose the two 4x4.
         // a00 a01 a02 a03   b00 b01 b02 b03
         // a10 a11 a12 a13   b10 b11 b12 b13
         // a20 a21 a22 a23   b20 b21 b22 b23
         // a30 a31 a32 a33   b30 b31 b32 b33
-        Vector128<short> transpose00 = Sse2.UnpackLow(b0, b1);
-        Vector128<short> transpose01 = Sse2.UnpackLow(b2, b3);
-        Vector128<short> transpose02 = Sse2.UnpackHigh(b0, b1);
-        Vector128<short> transpose03 = Sse2.UnpackHigh(b2, b3);
+        Vector128<short> transpose00 = Vector128_.UnpackLow(b0, b1);
+        Vector128<short> transpose01 = Vector128_.UnpackLow(b2, b3);
+        Vector128<short> transpose02 = Vector128_.UnpackHigh(b0, b1);
+        Vector128<short> transpose03 = Vector128_.UnpackHigh(b2, b3);
 
         // a00 a10 a01 a11   a02 a12 a03 a13
         // a20 a30 a21 a31   a22 a32 a23 a33
         // b00 b10 b01 b11   b02 b12 b03 b13
         // b20 b30 b21 b31   b22 b32 b23 b33
-        Vector128<int> transpose10 = Sse2.UnpackLow(transpose00.AsInt32(), transpose01.AsInt32());
-        Vector128<int> transpose11 = Sse2.UnpackLow(transpose02.AsInt32(), transpose03.AsInt32());
-        Vector128<int> transpose12 = Sse2.UnpackHigh(transpose00.AsInt32(), transpose01.AsInt32());
-        Vector128<int> transpose13 = Sse2.UnpackHigh(transpose02.AsInt32(), transpose03.AsInt32());
+        Vector128<int> transpose10 = Vector128_.UnpackLow(transpose00.AsInt32(), transpose01.AsInt32());
+        Vector128<int> transpose11 = Vector128_.UnpackLow(transpose02.AsInt32(), transpose03.AsInt32());
+        Vector128<int> transpose12 = Vector128_.UnpackHigh(transpose00.AsInt32(), transpose01.AsInt32());
+        Vector128<int> transpose13 = Vector128_.UnpackHigh(transpose02.AsInt32(), transpose03.AsInt32());
 
         // a00 a10 a20 a30 a01 a11 a21 a31
         // b00 b10 b20 b30 b01 b11 b21 b31
         // a02 a12 a22 a32 a03 a13 a23 a33
         // b02 b12 a22 b32 b03 b13 b23 b33
-        output0 = Sse2.UnpackLow(transpose10.AsInt64(), transpose11.AsInt64());
-        output1 = Sse2.UnpackHigh(transpose10.AsInt64(), transpose11.AsInt64());
-        output2 = Sse2.UnpackLow(transpose12.AsInt64(), transpose13.AsInt64());
-        output3 = Sse2.UnpackHigh(transpose12.AsInt64(), transpose13.AsInt64());
+        output0 = Vector128_.UnpackLow(transpose10.AsInt64(), transpose11.AsInt64());
+        output1 = Vector128_.UnpackHigh(transpose10.AsInt64(), transpose11.AsInt64());
+        output2 = Vector128_.UnpackLow(transpose12.AsInt64(), transpose13.AsInt64());
+        output3 = Vector128_.UnpackHigh(transpose12.AsInt64(), transpose13.AsInt64());
 
         // a00 a10 a20 a30   b00 b10 b20 b30
         // a01 a11 a21 a31   b01 b11 b21 b31
@@ -1035,7 +929,7 @@ internal static class LossyUtils
     // Does two transforms.
     public static void TransformTwo(Span<short> src, Span<byte> dst, Span<int> scratch)
     {
-        if (Sse2.IsSupported)
+        if (Vector128.IsHardwareAccelerated)
         {
             // This implementation makes use of 16-bit fixed point versions of two
             // multiply constants:
@@ -1057,24 +951,24 @@ internal static class LossyUtils
             // Load and concatenate the transform coefficients (we'll do two transforms
             // in parallel).
             ref short srcRef = ref MemoryMarshal.GetReference(src);
-            var in0 = Vector128.Create(Unsafe.As<short, long>(ref srcRef), 0);
-            var in1 = Vector128.Create(Unsafe.As<short, long>(ref Unsafe.Add(ref srcRef, 4)), 0);
-            var in2 = Vector128.Create(Unsafe.As<short, long>(ref Unsafe.Add(ref srcRef, 8)), 0);
-            var in3 = Vector128.Create(Unsafe.As<short, long>(ref Unsafe.Add(ref srcRef, 12)), 0);
+            Vector128<long> in0 = Vector128.Create(Unsafe.As<short, long>(ref srcRef), 0);
+            Vector128<long> in1 = Vector128.Create(Unsafe.As<short, long>(ref Unsafe.Add(ref srcRef, 4)), 0);
+            Vector128<long> in2 = Vector128.Create(Unsafe.As<short, long>(ref Unsafe.Add(ref srcRef, 8)), 0);
+            Vector128<long> in3 = Vector128.Create(Unsafe.As<short, long>(ref Unsafe.Add(ref srcRef, 12)), 0);
 
             // a00 a10 a20 a30   x x x x
             // a01 a11 a21 a31   x x x x
             // a02 a12 a22 a32   x x x x
             // a03 a13 a23 a33   x x x x
-            var inb0 = Vector128.Create(Unsafe.As<short, long>(ref Unsafe.Add(ref srcRef, 16)), 0);
-            var inb1 = Vector128.Create(Unsafe.As<short, long>(ref Unsafe.Add(ref srcRef, 20)), 0);
-            var inb2 = Vector128.Create(Unsafe.As<short, long>(ref Unsafe.Add(ref srcRef, 24)), 0);
-            var inb3 = Vector128.Create(Unsafe.As<short, long>(ref Unsafe.Add(ref srcRef, 28)), 0);
+            Vector128<long> inb0 = Vector128.Create(Unsafe.As<short, long>(ref Unsafe.Add(ref srcRef, 16)), 0);
+            Vector128<long> inb1 = Vector128.Create(Unsafe.As<short, long>(ref Unsafe.Add(ref srcRef, 20)), 0);
+            Vector128<long> inb2 = Vector128.Create(Unsafe.As<short, long>(ref Unsafe.Add(ref srcRef, 24)), 0);
+            Vector128<long> inb3 = Vector128.Create(Unsafe.As<short, long>(ref Unsafe.Add(ref srcRef, 28)), 0);
 
-            in0 = Sse2.UnpackLow(in0, inb0);
-            in1 = Sse2.UnpackLow(in1, inb1);
-            in2 = Sse2.UnpackLow(in2, inb2);
-            in3 = Sse2.UnpackLow(in3, inb3);
+            in0 = Vector128_.UnpackLow(in0, inb0);
+            in1 = Vector128_.UnpackLow(in1, inb1);
+            in2 = Vector128_.UnpackLow(in2, inb2);
+            in3 = Vector128_.UnpackLow(in3, inb3);
 
             // a00 a10 a20 a30   b00 b10 b20 b30
             // a01 a11 a21 a31   b01 b11 b21 b31
@@ -1083,67 +977,67 @@ internal static class LossyUtils
 
             // Vertical pass and subsequent transpose.
             // First pass, c and d calculations are longer because of the "trick" multiplications.
-            Vector128<short> a = Sse2.Add(in0.AsInt16(), in2.AsInt16());
-            Vector128<short> b = Sse2.Subtract(in0.AsInt16(), in2.AsInt16());
+            Vector128<short> a = in0.AsInt16() + in2.AsInt16();
+            Vector128<short> b = in0.AsInt16() - in2.AsInt16();
 
-            var k1 = Vector128.Create((short)20091);
-            var k2 = Vector128.Create((short)-30068);
+            Vector128<short> k1 = Vector128.Create((short)20091);
+            Vector128<short> k2 = Vector128.Create((short)-30068);
 
             // c = MUL(in1, K2) - MUL(in3, K1) = MUL(in1, k2) - MUL(in3, k1) + in1 - in3
-            Vector128<short> c1 = Sse2.MultiplyHigh(in1.AsInt16(), k2);
-            Vector128<short> c2 = Sse2.MultiplyHigh(in3.AsInt16(), k1);
-            Vector128<short> c3 = Sse2.Subtract(in1.AsInt16(), in3.AsInt16());
-            Vector128<short> c4 = Sse2.Subtract(c1, c2);
-            Vector128<short> c = Sse2.Add(c3.AsInt16(), c4);
+            Vector128<short> c1 = Vector128_.MultiplyHigh(in1.AsInt16(), k2);
+            Vector128<short> c2 = Vector128_.MultiplyHigh(in3.AsInt16(), k1);
+            Vector128<short> c3 = in1.AsInt16() - in3.AsInt16();
+            Vector128<short> c4 = c1 - c2;
+            Vector128<short> c = c3.AsInt16() + c4;
 
             // d = MUL(in1, K1) + MUL(in3, K2) = MUL(in1, k1) + MUL(in3, k2) + in1 + in3
-            Vector128<short> d1 = Sse2.MultiplyHigh(in1.AsInt16(), k1);
-            Vector128<short> d2 = Sse2.MultiplyHigh(in3.AsInt16(), k2);
-            Vector128<short> d3 = Sse2.Add(in1.AsInt16(), in3.AsInt16());
-            Vector128<short> d4 = Sse2.Add(d1, d2);
-            Vector128<short> d = Sse2.Add(d3, d4);
+            Vector128<short> d1 = Vector128_.MultiplyHigh(in1.AsInt16(), k1);
+            Vector128<short> d2 = Vector128_.MultiplyHigh(in3.AsInt16(), k2);
+            Vector128<short> d3 = in1.AsInt16() + in3.AsInt16();
+            Vector128<short> d4 = d1 + d2;
+            Vector128<short> d = d3 + d4;
 
             // Second pass.
-            Vector128<short> tmp0 = Sse2.Add(a.AsInt16(), d);
-            Vector128<short> tmp1 = Sse2.Add(b.AsInt16(), c);
-            Vector128<short> tmp2 = Sse2.Subtract(b.AsInt16(), c);
-            Vector128<short> tmp3 = Sse2.Subtract(a.AsInt16(), d);
+            Vector128<short> tmp0 = a.AsInt16() + d;
+            Vector128<short> tmp1 = b.AsInt16() + c;
+            Vector128<short> tmp2 = b.AsInt16() - c;
+            Vector128<short> tmp3 = a.AsInt16() - d;
 
             // Transpose the two 4x4.
-            Vp8Transpose_2_4x4_16b(tmp0, tmp1, tmp2, tmp3, out Vector128<long> t0, out Vector128<long> t1, out Vector128<long> t2, out Vector128<long> t3);
+            Vp8Transpose_2_4x4_16bVector128(tmp0, tmp1, tmp2, tmp3, out Vector128<long> t0, out Vector128<long> t1, out Vector128<long> t2, out Vector128<long> t3);
 
             // Horizontal pass and subsequent transpose.
             // First pass, c and d calculations are longer because of the "trick" multiplications.
-            Vector128<short> dc = Sse2.Add(t0.AsInt16(), Vector128.Create((short)4));
-            a = Sse2.Add(dc, t2.AsInt16());
-            b = Sse2.Subtract(dc, t2.AsInt16());
+            Vector128<short> dc = t0.AsInt16() + Vector128.Create((short)4);
+            a = dc + t2.AsInt16();
+            b = dc - t2.AsInt16();
 
             // c = MUL(T1, K2) - MUL(T3, K1) = MUL(T1, k2) - MUL(T3, k1) + T1 - T3
-            c1 = Sse2.MultiplyHigh(t1.AsInt16(), k2);
-            c2 = Sse2.MultiplyHigh(t3.AsInt16(), k1);
-            c3 = Sse2.Subtract(t1.AsInt16(), t3.AsInt16());
-            c4 = Sse2.Subtract(c1, c2);
-            c = Sse2.Add(c3, c4);
+            c1 = Vector128_.MultiplyHigh(t1.AsInt16(), k2);
+            c2 = Vector128_.MultiplyHigh(t3.AsInt16(), k1);
+            c3 = t1.AsInt16() - t3.AsInt16();
+            c4 = c1 - c2;
+            c = c3 + c4;
 
             // d = MUL(T1, K1) + MUL(T3, K2) = MUL(T1, k1) + MUL(T3, k2) + T1 + T3
-            d1 = Sse2.MultiplyHigh(t1.AsInt16(), k1);
-            d2 = Sse2.MultiplyHigh(t3.AsInt16(), k2);
-            d3 = Sse2.Add(t1.AsInt16(), t3.AsInt16());
-            d4 = Sse2.Add(d1, d2);
-            d = Sse2.Add(d3, d4);
+            d1 = Vector128_.MultiplyHigh(t1.AsInt16(), k1);
+            d2 = Vector128_.MultiplyHigh(t3.AsInt16(), k2);
+            d3 = t1.AsInt16() + t3.AsInt16();
+            d4 = d1 + d2;
+            d = d3 + d4;
 
             // Second pass.
-            tmp0 = Sse2.Add(a, d);
-            tmp1 = Sse2.Add(b, c);
-            tmp2 = Sse2.Subtract(b, c);
-            tmp3 = Sse2.Subtract(a, d);
-            Vector128<short> shifted0 = Sse2.ShiftRightArithmetic(tmp0, 3);
-            Vector128<short> shifted1 = Sse2.ShiftRightArithmetic(tmp1, 3);
-            Vector128<short> shifted2 = Sse2.ShiftRightArithmetic(tmp2, 3);
-            Vector128<short> shifted3 = Sse2.ShiftRightArithmetic(tmp3, 3);
+            tmp0 = a + d;
+            tmp1 = b + c;
+            tmp2 = b - c;
+            tmp3 = a - d;
+            Vector128<short> shifted0 = Vector128.ShiftRightArithmetic(tmp0, 3);
+            Vector128<short> shifted1 = Vector128.ShiftRightArithmetic(tmp1, 3);
+            Vector128<short> shifted2 = Vector128.ShiftRightArithmetic(tmp2, 3);
+            Vector128<short> shifted3 = Vector128.ShiftRightArithmetic(tmp3, 3);
 
             // Transpose the two 4x4.
-            Vp8Transpose_2_4x4_16b(shifted0, shifted1, shifted2, shifted3, out t0, out t1, out t2, out t3);
+            Vp8Transpose_2_4x4_16bVector128(shifted0, shifted1, shifted2, shifted3, out t0, out t1, out t2, out t3);
 
             // Add inverse transform to 'dst' and store.
             // Load the reference(s).
@@ -1155,22 +1049,22 @@ internal static class LossyUtils
             Vector128<byte> dst3 = Vector128.Create(Unsafe.As<byte, long>(ref Unsafe.Add(ref dstRef, WebpConstants.Bps * 3)), 0).AsByte();
 
             // Convert to 16b.
-            dst0 = Sse2.UnpackLow(dst0, Vector128<byte>.Zero);
-            dst1 = Sse2.UnpackLow(dst1, Vector128<byte>.Zero);
-            dst2 = Sse2.UnpackLow(dst2, Vector128<byte>.Zero);
-            dst3 = Sse2.UnpackLow(dst3, Vector128<byte>.Zero);
+            dst0 = Vector128_.UnpackLow(dst0, Vector128<byte>.Zero);
+            dst1 = Vector128_.UnpackLow(dst1, Vector128<byte>.Zero);
+            dst2 = Vector128_.UnpackLow(dst2, Vector128<byte>.Zero);
+            dst3 = Vector128_.UnpackLow(dst3, Vector128<byte>.Zero);
 
             // Add the inverse transform(s).
-            dst0 = Sse2.Add(dst0.AsInt16(), t0.AsInt16()).AsByte();
-            dst1 = Sse2.Add(dst1.AsInt16(), t1.AsInt16()).AsByte();
-            dst2 = Sse2.Add(dst2.AsInt16(), t2.AsInt16()).AsByte();
-            dst3 = Sse2.Add(dst3.AsInt16(), t3.AsInt16()).AsByte();
+            dst0 = (dst0.AsInt16() + t0.AsInt16()).AsByte();
+            dst1 = (dst1.AsInt16() + t1.AsInt16()).AsByte();
+            dst2 = (dst2.AsInt16() + t2.AsInt16()).AsByte();
+            dst3 = (dst3.AsInt16() + t3.AsInt16()).AsByte();
 
             // Unsigned saturate to 8b.
-            dst0 = Sse2.PackUnsignedSaturate(dst0.AsInt16(), dst0.AsInt16());
-            dst1 = Sse2.PackUnsignedSaturate(dst1.AsInt16(), dst1.AsInt16());
-            dst2 = Sse2.PackUnsignedSaturate(dst2.AsInt16(), dst2.AsInt16());
-            dst3 = Sse2.PackUnsignedSaturate(dst3.AsInt16(), dst3.AsInt16());
+            dst0 = Vector128_.PackUnsignedSaturate(dst0.AsInt16(), dst0.AsInt16());
+            dst1 = Vector128_.PackUnsignedSaturate(dst1.AsInt16(), dst1.AsInt16());
+            dst2 = Vector128_.PackUnsignedSaturate(dst2.AsInt16(), dst2.AsInt16());
+            dst3 = Vector128_.PackUnsignedSaturate(dst3.AsInt16(), dst3.AsInt16());
 
             // Store the results.
             // Store eight bytes/pixels per line.
@@ -1189,14 +1083,14 @@ internal static class LossyUtils
 
     public static void TransformOne(Span<short> src, Span<byte> dst, Span<int> scratch)
     {
-        if (Sse2.IsSupported)
+        if (Vector128.IsHardwareAccelerated)
         {
             // Load and concatenate the transform coefficients.
             ref short srcRef = ref MemoryMarshal.GetReference(src);
-            var in0 = Vector128.Create(Unsafe.As<short, long>(ref srcRef), 0);
-            var in1 = Vector128.Create(Unsafe.As<short, long>(ref Unsafe.Add(ref srcRef, 4)), 0);
-            var in2 = Vector128.Create(Unsafe.As<short, long>(ref Unsafe.Add(ref srcRef, 8)), 0);
-            var in3 = Vector128.Create(Unsafe.As<short, long>(ref Unsafe.Add(ref srcRef, 12)), 0);
+            Vector128<long> in0 = Vector128.Create(Unsafe.As<short, long>(ref srcRef), 0);
+            Vector128<long> in1 = Vector128.Create(Unsafe.As<short, long>(ref Unsafe.Add(ref srcRef, 4)), 0);
+            Vector128<long> in2 = Vector128.Create(Unsafe.As<short, long>(ref Unsafe.Add(ref srcRef, 8)), 0);
+            Vector128<long> in3 = Vector128.Create(Unsafe.As<short, long>(ref Unsafe.Add(ref srcRef, 12)), 0);
 
             // a00 a10 a20 a30   x x x x
             // a01 a11 a21 a31   x x x x
@@ -1205,102 +1099,102 @@ internal static class LossyUtils
 
             // Vertical pass and subsequent transpose.
             // First pass, c and d calculations are longer because of the "trick" multiplications.
-            Vector128<short> a = Sse2.Add(in0.AsInt16(), in2.AsInt16());
-            Vector128<short> b = Sse2.Subtract(in0.AsInt16(), in2.AsInt16());
+            Vector128<short> a = in0.AsInt16() + in2.AsInt16();
+            Vector128<short> b = in0.AsInt16() - in2.AsInt16();
 
-            var k1 = Vector128.Create((short)20091);
-            var k2 = Vector128.Create((short)-30068);
+            Vector128<short> k1 = Vector128.Create((short)20091);
+            Vector128<short> k2 = Vector128.Create((short)-30068);
 
             // c = MUL(in1, K2) - MUL(in3, K1) = MUL(in1, k2) - MUL(in3, k1) + in1 - in3
-            Vector128<short> c1 = Sse2.MultiplyHigh(in1.AsInt16(), k2);
-            Vector128<short> c2 = Sse2.MultiplyHigh(in3.AsInt16(), k1);
-            Vector128<short> c3 = Sse2.Subtract(in1.AsInt16(), in3.AsInt16());
-            Vector128<short> c4 = Sse2.Subtract(c1, c2);
-            Vector128<short> c = Sse2.Add(c3.AsInt16(), c4);
+            Vector128<short> c1 = Vector128_.MultiplyHigh(in1.AsInt16(), k2);
+            Vector128<short> c2 = Vector128_.MultiplyHigh(in3.AsInt16(), k1);
+            Vector128<short> c3 = in1.AsInt16() - in3.AsInt16();
+            Vector128<short> c4 = c1 - c2;
+            Vector128<short> c = c3.AsInt16() + c4;
 
             // d = MUL(in1, K1) + MUL(in3, K2) = MUL(in1, k1) + MUL(in3, k2) + in1 + in3
-            Vector128<short> d1 = Sse2.MultiplyHigh(in1.AsInt16(), k1);
-            Vector128<short> d2 = Sse2.MultiplyHigh(in3.AsInt16(), k2);
-            Vector128<short> d3 = Sse2.Add(in1.AsInt16(), in3.AsInt16());
-            Vector128<short> d4 = Sse2.Add(d1, d2);
-            Vector128<short> d = Sse2.Add(d3, d4);
+            Vector128<short> d1 = Vector128_.MultiplyHigh(in1.AsInt16(), k1);
+            Vector128<short> d2 = Vector128_.MultiplyHigh(in3.AsInt16(), k2);
+            Vector128<short> d3 = in1.AsInt16() + in3.AsInt16();
+            Vector128<short> d4 = d1 + d2;
+            Vector128<short> d = d3 + d4;
 
             // Second pass.
-            Vector128<short> tmp0 = Sse2.Add(a.AsInt16(), d);
-            Vector128<short> tmp1 = Sse2.Add(b.AsInt16(), c);
-            Vector128<short> tmp2 = Sse2.Subtract(b.AsInt16(), c);
-            Vector128<short> tmp3 = Sse2.Subtract(a.AsInt16(), d);
+            Vector128<short> tmp0 = a.AsInt16() + d;
+            Vector128<short> tmp1 = b.AsInt16() + c;
+            Vector128<short> tmp2 = b.AsInt16() - c;
+            Vector128<short> tmp3 = a.AsInt16() - d;
 
             // Transpose the two 4x4.
-            Vp8Transpose_2_4x4_16b(tmp0, tmp1, tmp2, tmp3, out Vector128<long> t0, out Vector128<long> t1, out Vector128<long> t2, out Vector128<long> t3);
+            Vp8Transpose_2_4x4_16bVector128(tmp0, tmp1, tmp2, tmp3, out Vector128<long> t0, out Vector128<long> t1, out Vector128<long> t2, out Vector128<long> t3);
 
             // Horizontal pass and subsequent transpose.
             // First pass, c and d calculations are longer because of the "trick" multiplications.
-            Vector128<short> dc = Sse2.Add(t0.AsInt16(), Vector128.Create((short)4));
-            a = Sse2.Add(dc, t2.AsInt16());
-            b = Sse2.Subtract(dc, t2.AsInt16());
+            Vector128<short> dc = t0.AsInt16() + Vector128.Create((short)4);
+            a = dc + t2.AsInt16();
+            b = dc - t2.AsInt16();
 
             // c = MUL(T1, K2) - MUL(T3, K1) = MUL(T1, k2) - MUL(T3, k1) + T1 - T3
-            c1 = Sse2.MultiplyHigh(t1.AsInt16(), k2);
-            c2 = Sse2.MultiplyHigh(t3.AsInt16(), k1);
-            c3 = Sse2.Subtract(t1.AsInt16(), t3.AsInt16());
-            c4 = Sse2.Subtract(c1, c2);
-            c = Sse2.Add(c3, c4);
+            c1 = Vector128_.MultiplyHigh(t1.AsInt16(), k2);
+            c2 = Vector128_.MultiplyHigh(t3.AsInt16(), k1);
+            c3 = t1.AsInt16() - t3.AsInt16();
+            c4 = c1 - c2;
+            c = c3 + c4;
 
             // d = MUL(T1, K1) + MUL(T3, K2) = MUL(T1, k1) + MUL(T3, k2) + T1 + T3
-            d1 = Sse2.MultiplyHigh(t1.AsInt16(), k1);
-            d2 = Sse2.MultiplyHigh(t3.AsInt16(), k2);
-            d3 = Sse2.Add(t1.AsInt16(), t3.AsInt16());
-            d4 = Sse2.Add(d1, d2);
-            d = Sse2.Add(d3, d4);
+            d1 = Vector128_.MultiplyHigh(t1.AsInt16(), k1);
+            d2 = Vector128_.MultiplyHigh(t3.AsInt16(), k2);
+            d3 = t1.AsInt16() + t3.AsInt16();
+            d4 = d1 + d2;
+            d = d3 + d4;
 
             // Second pass.
-            tmp0 = Sse2.Add(a, d);
-            tmp1 = Sse2.Add(b, c);
-            tmp2 = Sse2.Subtract(b, c);
-            tmp3 = Sse2.Subtract(a, d);
-            Vector128<short> shifted0 = Sse2.ShiftRightArithmetic(tmp0, 3);
-            Vector128<short> shifted1 = Sse2.ShiftRightArithmetic(tmp1, 3);
-            Vector128<short> shifted2 = Sse2.ShiftRightArithmetic(tmp2, 3);
-            Vector128<short> shifted3 = Sse2.ShiftRightArithmetic(tmp3, 3);
+            tmp0 = a + d;
+            tmp1 = b + c;
+            tmp2 = b - c;
+            tmp3 = a - d;
+            Vector128<short> shifted0 = Vector128.ShiftRightArithmetic(tmp0, 3);
+            Vector128<short> shifted1 = Vector128.ShiftRightArithmetic(tmp1, 3);
+            Vector128<short> shifted2 = Vector128.ShiftRightArithmetic(tmp2, 3);
+            Vector128<short> shifted3 = Vector128.ShiftRightArithmetic(tmp3, 3);
 
             // Transpose the two 4x4.
-            Vp8Transpose_2_4x4_16b(shifted0, shifted1, shifted2, shifted3, out t0, out t1, out t2, out t3);
+            Vp8Transpose_2_4x4_16bVector128(shifted0, shifted1, shifted2, shifted3, out t0, out t1, out t2, out t3);
 
             // Add inverse transform to 'dst' and store.
             // Load the reference(s).
             // Load four bytes/pixels per line.
             ref byte dstRef = ref MemoryMarshal.GetReference(dst);
-            Vector128<byte> dst0 = Sse2.ConvertScalarToVector128Int32(Unsafe.As<byte, int>(ref dstRef)).AsByte();
-            Vector128<byte> dst1 = Sse2.ConvertScalarToVector128Int32(Unsafe.As<byte, int>(ref Unsafe.Add(ref dstRef, WebpConstants.Bps))).AsByte();
-            Vector128<byte> dst2 = Sse2.ConvertScalarToVector128Int32(Unsafe.As<byte, int>(ref Unsafe.Add(ref dstRef, WebpConstants.Bps * 2))).AsByte();
-            Vector128<byte> dst3 = Sse2.ConvertScalarToVector128Int32(Unsafe.As<byte, int>(ref Unsafe.Add(ref dstRef, WebpConstants.Bps * 3))).AsByte();
+            Vector128<byte> dst0 = Vector128.CreateScalar(Unsafe.As<byte, int>(ref dstRef)).AsByte();
+            Vector128<byte> dst1 = Vector128.CreateScalar(Unsafe.As<byte, int>(ref Unsafe.Add(ref dstRef, WebpConstants.Bps))).AsByte();
+            Vector128<byte> dst2 = Vector128.CreateScalar(Unsafe.As<byte, int>(ref Unsafe.Add(ref dstRef, WebpConstants.Bps * 2))).AsByte();
+            Vector128<byte> dst3 = Vector128.CreateScalar(Unsafe.As<byte, int>(ref Unsafe.Add(ref dstRef, WebpConstants.Bps * 3))).AsByte();
 
             // Convert to 16b.
-            dst0 = Sse2.UnpackLow(dst0, Vector128<byte>.Zero);
-            dst1 = Sse2.UnpackLow(dst1, Vector128<byte>.Zero);
-            dst2 = Sse2.UnpackLow(dst2, Vector128<byte>.Zero);
-            dst3 = Sse2.UnpackLow(dst3, Vector128<byte>.Zero);
+            dst0 = Vector128_.UnpackLow(dst0, Vector128<byte>.Zero);
+            dst1 = Vector128_.UnpackLow(dst1, Vector128<byte>.Zero);
+            dst2 = Vector128_.UnpackLow(dst2, Vector128<byte>.Zero);
+            dst3 = Vector128_.UnpackLow(dst3, Vector128<byte>.Zero);
 
             // Add the inverse transform(s).
-            dst0 = Sse2.Add(dst0.AsInt16(), t0.AsInt16()).AsByte();
-            dst1 = Sse2.Add(dst1.AsInt16(), t1.AsInt16()).AsByte();
-            dst2 = Sse2.Add(dst2.AsInt16(), t2.AsInt16()).AsByte();
-            dst3 = Sse2.Add(dst3.AsInt16(), t3.AsInt16()).AsByte();
+            dst0 = (dst0.AsInt16() + t0.AsInt16()).AsByte();
+            dst1 = (dst1.AsInt16() + t1.AsInt16()).AsByte();
+            dst2 = (dst2.AsInt16() + t2.AsInt16()).AsByte();
+            dst3 = (dst3.AsInt16() + t3.AsInt16()).AsByte();
 
             // Unsigned saturate to 8b.
-            dst0 = Sse2.PackUnsignedSaturate(dst0.AsInt16(), dst0.AsInt16());
-            dst1 = Sse2.PackUnsignedSaturate(dst1.AsInt16(), dst1.AsInt16());
-            dst2 = Sse2.PackUnsignedSaturate(dst2.AsInt16(), dst2.AsInt16());
-            dst3 = Sse2.PackUnsignedSaturate(dst3.AsInt16(), dst3.AsInt16());
+            dst0 = Vector128_.PackUnsignedSaturate(dst0.AsInt16(), dst0.AsInt16());
+            dst1 = Vector128_.PackUnsignedSaturate(dst1.AsInt16(), dst1.AsInt16());
+            dst2 = Vector128_.PackUnsignedSaturate(dst2.AsInt16(), dst2.AsInt16());
+            dst3 = Vector128_.PackUnsignedSaturate(dst3.AsInt16(), dst3.AsInt16());
 
             // Store the results.
             // Store four bytes/pixels per line.
             ref byte outputRef = ref MemoryMarshal.GetReference(dst);
-            int output0 = Sse2.ConvertToInt32(dst0.AsInt32());
-            int output1 = Sse2.ConvertToInt32(dst1.AsInt32());
-            int output2 = Sse2.ConvertToInt32(dst2.AsInt32());
-            int output3 = Sse2.ConvertToInt32(dst3.AsInt32());
+            int output0 = dst0.AsInt32().ToScalar();
+            int output1 = dst1.AsInt32().ToScalar();
+            int output2 = dst2.AsInt32().ToScalar();
+            int output3 = dst3.AsInt32().ToScalar();
             Unsafe.As<byte, int>(ref outputRef) = output0;
             Unsafe.As<byte, int>(ref Unsafe.Add(ref outputRef, WebpConstants.Bps)) = output1;
             Unsafe.As<byte, int>(ref Unsafe.Add(ref outputRef, WebpConstants.Bps * 2)) = output2;
@@ -1413,7 +1307,7 @@ internal static class LossyUtils
     // Simple In-loop filtering (Paragraph 15.2)
     public static void SimpleVFilter16(Span<byte> p, int offset, int stride, int thresh)
     {
-        if (Sse2.IsSupported)
+        if (Vector128.IsHardwareAccelerated)
         {
             // Load.
             ref byte pRef = ref Unsafe.Add(ref MemoryMarshal.GetReference(p), (uint)offset);
@@ -1423,7 +1317,7 @@ internal static class LossyUtils
             Vector128<byte> q0 = Unsafe.As<byte, Vector128<byte>>(ref pRef);
             Vector128<byte> q1 = Unsafe.As<byte, Vector128<byte>>(ref Unsafe.Add(ref pRef, (uint)stride));
 
-            DoFilter2Sse2(ref p1, ref p0, ref q0, ref q1, thresh);
+            DoFilter2Vector128(ref p1, ref p0, ref q0, ref q1, thresh);
 
             // Store.
             ref byte outputRef = ref Unsafe.Add(ref MemoryMarshal.GetReference(p), (uint)offset);
@@ -1446,14 +1340,14 @@ internal static class LossyUtils
 
     public static void SimpleHFilter16(Span<byte> p, int offset, int stride, int thresh)
     {
-        if (Sse2.IsSupported)
+        if (Vector128.IsHardwareAccelerated)
         {
             // Beginning of p1
             ref byte pRef = ref Unsafe.Add(ref MemoryMarshal.GetReference(p), (uint)(offset - 2));
 
-            Load16x4(ref pRef, ref Unsafe.Add(ref pRef, 8 * (uint)stride), stride, out Vector128<byte> p1, out Vector128<byte> p0, out Vector128<byte> q0, out Vector128<byte> q1);
-            DoFilter2Sse2(ref p1, ref p0, ref q0, ref q1, thresh);
-            Store16x4(p1, p0, q0, q1, ref pRef, ref Unsafe.Add(ref pRef, 8 * (uint)stride), stride);
+            Load16x4Vector128(ref pRef, ref Unsafe.Add(ref pRef, 8 * (uint)stride), stride, out Vector128<byte> p1, out Vector128<byte> p0, out Vector128<byte> q0, out Vector128<byte> q1);
+            DoFilter2Vector128(ref p1, ref p0, ref q0, ref q1, thresh);
+            Store16x4Vector128(p1, p0, q0, q1, ref pRef, ref Unsafe.Add(ref pRef, 8 * (uint)stride), stride);
         }
         else
         {
@@ -1471,7 +1365,7 @@ internal static class LossyUtils
 
     public static void SimpleVFilter16i(Span<byte> p, int offset, int stride, int thresh)
     {
-        if (Sse2.IsSupported)
+        if (Vector128.IsHardwareAccelerated)
         {
             for (int k = 3; k > 0; k--)
             {
@@ -1491,7 +1385,7 @@ internal static class LossyUtils
 
     public static void SimpleHFilter16i(Span<byte> p, int offset, int stride, int thresh)
     {
-        if (Sse2.IsSupported)
+        if (Vector128.IsHardwareAccelerated)
         {
             for (int k = 3; k > 0; k--)
             {
@@ -1513,7 +1407,7 @@ internal static class LossyUtils
     [MethodImpl(InliningOptions.ShortMethod)]
     public static void VFilter16(Span<byte> p, int offset, int stride, int thresh, int ithresh, int hevThresh)
     {
-        if (Sse2.IsSupported)
+        if (Vector128.IsHardwareAccelerated)
         {
             ref byte pRef = ref MemoryMarshal.GetReference(p);
             Vector128<byte> t1 = Unsafe.As<byte, Vector128<byte>>(ref Unsafe.Add(ref pRef, (uint)(offset - (4 * stride))));
@@ -1521,21 +1415,21 @@ internal static class LossyUtils
             Vector128<byte> p1 = Unsafe.As<byte, Vector128<byte>>(ref Unsafe.Add(ref pRef, (uint)(offset - (2 * stride))));
             Vector128<byte> p0 = Unsafe.As<byte, Vector128<byte>>(ref Unsafe.Add(ref pRef, (uint)(offset - stride)));
 
-            Vector128<byte> mask = Abs(p1, p0);
-            mask = Sse2.Max(mask, Abs(t1, p2));
-            mask = Sse2.Max(mask, Abs(p2, p1));
+            Vector128<byte> mask = AbsVector128(p1, p0);
+            mask = Vector128.Max(mask, AbsVector128(t1, p2));
+            mask = Vector128.Max(mask, AbsVector128(p2, p1));
 
             Vector128<byte> q0 = Unsafe.As<byte, Vector128<byte>>(ref Unsafe.Add(ref pRef, (uint)offset));
             Vector128<byte> q1 = Unsafe.As<byte, Vector128<byte>>(ref Unsafe.Add(ref pRef, (uint)(offset + stride)));
             Vector128<byte> q2 = Unsafe.As<byte, Vector128<byte>>(ref Unsafe.Add(ref pRef, (uint)(offset + (2 * stride))));
             t1 = Unsafe.As<byte, Vector128<byte>>(ref Unsafe.Add(ref pRef, (uint)(offset + (3 * stride))));
 
-            mask = Sse2.Max(mask, Abs(q1, q0));
-            mask = Sse2.Max(mask, Abs(t1, q2));
-            mask = Sse2.Max(mask, Abs(q2, q1));
+            mask = Vector128.Max(mask, AbsVector128(q1, q0));
+            mask = Vector128.Max(mask, AbsVector128(t1, q2));
+            mask = Vector128.Max(mask, AbsVector128(q2, q1));
 
-            ComplexMask(p1, p0, q0, q1, thresh, ithresh, ref mask);
-            DoFilter6Sse2(ref p2, ref p1, ref p0, ref q0, ref q1, ref q2, mask, hevThresh);
+            ComplexMaskVector128(p1, p0, q0, q1, thresh, ithresh, ref mask);
+            DoFilter6Vector128(ref p2, ref p1, ref p0, ref q0, ref q1, ref q2, mask, hevThresh);
 
             // Store.
             ref byte outputRef = ref MemoryMarshal.GetReference(p);
@@ -1555,27 +1449,27 @@ internal static class LossyUtils
     [MethodImpl(InliningOptions.ShortMethod)]
     public static void HFilter16(Span<byte> p, int offset, int stride, int thresh, int ithresh, int hevThresh)
     {
-        if (Sse2.IsSupported)
+        if (Vector128.IsHardwareAccelerated)
         {
             ref byte pRef = ref MemoryMarshal.GetReference(p);
             ref byte bRef = ref Unsafe.Add(ref pRef, (uint)offset - 4);
-            Load16x4(ref bRef, ref Unsafe.Add(ref bRef, 8 * (uint)stride), stride, out Vector128<byte> p3, out Vector128<byte> p2, out Vector128<byte> p1, out Vector128<byte> p0);
+            Load16x4Vector128(ref bRef, ref Unsafe.Add(ref bRef, 8 * (uint)stride), stride, out Vector128<byte> p3, out Vector128<byte> p2, out Vector128<byte> p1, out Vector128<byte> p0);
 
-            Vector128<byte> mask = Abs(p1, p0);
-            mask = Sse2.Max(mask, Abs(p3, p2));
-            mask = Sse2.Max(mask, Abs(p2, p1));
+            Vector128<byte> mask = AbsVector128(p1, p0);
+            mask = Vector128.Max(mask, AbsVector128(p3, p2));
+            mask = Vector128.Max(mask, AbsVector128(p2, p1));
 
-            Load16x4(ref Unsafe.Add(ref pRef, (uint)offset), ref Unsafe.Add(ref pRef, (uint)(offset + (8 * stride))), stride, out Vector128<byte> q0, out Vector128<byte> q1, out Vector128<byte> q2, out Vector128<byte> q3);
+            Load16x4Vector128(ref Unsafe.Add(ref pRef, (uint)offset), ref Unsafe.Add(ref pRef, (uint)(offset + (8 * stride))), stride, out Vector128<byte> q0, out Vector128<byte> q1, out Vector128<byte> q2, out Vector128<byte> q3);
 
-            mask = Sse2.Max(mask, Abs(q1, q0));
-            mask = Sse2.Max(mask, Abs(q3, q2));
-            mask = Sse2.Max(mask, Abs(q2, q1));
+            mask = Vector128.Max(mask, AbsVector128(q1, q0));
+            mask = Vector128.Max(mask, AbsVector128(q3, q2));
+            mask = Vector128.Max(mask, AbsVector128(q2, q1));
 
-            ComplexMask(p1, p0, q0, q1, thresh, ithresh, ref mask);
-            DoFilter6Sse2(ref p2, ref p1, ref p0, ref q0, ref q1, ref q2, mask, hevThresh);
+            ComplexMaskVector128(p1, p0, q0, q1, thresh, ithresh, ref mask);
+            DoFilter6Vector128(ref p2, ref p1, ref p0, ref q0, ref q1, ref q2, mask, hevThresh);
 
-            Store16x4(p3, p2, p1, p0, ref bRef, ref Unsafe.Add(ref bRef, 8 * (uint)stride), stride);
-            Store16x4(q0, q1, q2, q3, ref Unsafe.Add(ref pRef, (uint)offset), ref Unsafe.Add(ref pRef, (uint)(offset + (8 * stride))), stride);
+            Store16x4Vector128(p3, p2, p1, p0, ref bRef, ref Unsafe.Add(ref bRef, 8 * (uint)stride), stride);
+            Store16x4Vector128(q0, q1, q2, q3, ref Unsafe.Add(ref pRef, (uint)offset), ref Unsafe.Add(ref pRef, (uint)(offset + (8 * stride))), stride);
         }
         else
         {
@@ -1585,7 +1479,7 @@ internal static class LossyUtils
 
     public static void VFilter16i(Span<byte> p, int offset, int stride, int thresh, int ithresh, int hevThresh)
     {
-        if (Sse2.IsSupported)
+        if (Vector128.IsHardwareAccelerated)
         {
             ref byte pRef = ref MemoryMarshal.GetReference(p);
             Vector128<byte> p3 = Unsafe.As<byte, Vector128<byte>>(ref Unsafe.Add(ref pRef, (uint)offset));
@@ -1599,23 +1493,23 @@ internal static class LossyUtils
                 Span<byte> b = p[(offset + (2 * stride))..];
                 offset += 4 * stride;
 
-                Vector128<byte> mask = Abs(p0, p1);
-                mask = Sse2.Max(mask, Abs(p3, p2));
-                mask = Sse2.Max(mask, Abs(p2, p1));
+                Vector128<byte> mask = AbsVector128(p0, p1);
+                mask = Vector128.Max(mask, AbsVector128(p3, p2));
+                mask = Vector128.Max(mask, AbsVector128(p2, p1));
 
                 p3 = Unsafe.As<byte, Vector128<byte>>(ref Unsafe.Add(ref pRef, (uint)offset));
                 p2 = Unsafe.As<byte, Vector128<byte>>(ref Unsafe.Add(ref pRef, (uint)(offset + stride)));
                 Vector128<byte> tmp1 = Unsafe.As<byte, Vector128<byte>>(ref Unsafe.Add(ref pRef, (uint)(offset + (2 * stride))));
                 Vector128<byte> tmp2 = Unsafe.As<byte, Vector128<byte>>(ref Unsafe.Add(ref pRef, (uint)(offset + (3 * stride))));
 
-                mask = Sse2.Max(mask, Abs(tmp1, tmp2));
-                mask = Sse2.Max(mask, Abs(p3, p2));
-                mask = Sse2.Max(mask, Abs(p2, tmp1));
+                mask = Vector128.Max(mask, AbsVector128(tmp1, tmp2));
+                mask = Vector128.Max(mask, AbsVector128(p3, p2));
+                mask = Vector128.Max(mask, AbsVector128(p2, tmp1));
 
                 // p3 and p2 are not just temporary variables here: they will be
                 // re-used for next span. And q2/q3 will become p1/p0 accordingly.
-                ComplexMask(p1, p0, p3, p2, thresh, ithresh, ref mask);
-                DoFilter4Sse2(ref p1, ref p0, ref p3, ref p2, mask, hevThresh);
+                ComplexMaskVector128(p1, p0, p3, p2, thresh, ithresh, ref mask);
+                DoFilter4Vector128(ref p1, ref p0, ref p3, ref p2, mask, hevThresh);
 
                 // Store.
                 ref byte outputRef = ref MemoryMarshal.GetReference(b);
@@ -1641,10 +1535,10 @@ internal static class LossyUtils
 
     public static void HFilter16i(Span<byte> p, int offset, int stride, int thresh, int ithresh, int hevThresh)
     {
-        if (Sse2.IsSupported)
+        if (Vector128.IsHardwareAccelerated)
         {
             ref byte pRef = ref MemoryMarshal.GetReference(p);
-            Load16x4(ref Unsafe.Add(ref pRef, (uint)offset), ref Unsafe.Add(ref pRef, (uint)(offset + (8 * stride))), stride, out Vector128<byte> p3, out Vector128<byte> p2, out Vector128<byte> p1, out Vector128<byte> p0);
+            Load16x4Vector128(ref Unsafe.Add(ref pRef, (uint)offset), ref Unsafe.Add(ref pRef, (uint)(offset + (8 * stride))), stride, out Vector128<byte> p3, out Vector128<byte> p2, out Vector128<byte> p1, out Vector128<byte> p0);
 
             Vector128<byte> mask;
             for (int k = 3; k > 0; k--)
@@ -1656,20 +1550,20 @@ internal static class LossyUtils
                 offset += 4;
 
                 // Compute partial mask.
-                mask = Abs(p1, p0);
-                mask = Sse2.Max(mask, Abs(p3, p2));
-                mask = Sse2.Max(mask, Abs(p2, p1));
+                mask = AbsVector128(p1, p0);
+                mask = Vector128.Max(mask, AbsVector128(p3, p2));
+                mask = Vector128.Max(mask, AbsVector128(p2, p1));
 
-                Load16x4(ref Unsafe.Add(ref pRef, (uint)offset), ref Unsafe.Add(ref pRef, (uint)(offset + (8 * stride))), stride, out p3, out p2, out Vector128<byte> tmp1, out Vector128<byte> tmp2);
+                Load16x4Vector128(ref Unsafe.Add(ref pRef, (uint)offset), ref Unsafe.Add(ref pRef, (uint)(offset + (8 * stride))), stride, out p3, out p2, out Vector128<byte> tmp1, out Vector128<byte> tmp2);
 
-                mask = Sse2.Max(mask, Abs(tmp1, tmp2));
-                mask = Sse2.Max(mask, Abs(p3, p2));
-                mask = Sse2.Max(mask, Abs(p2, tmp1));
+                mask = Vector128.Max(mask, AbsVector128(tmp1, tmp2));
+                mask = Vector128.Max(mask, AbsVector128(p3, p2));
+                mask = Vector128.Max(mask, AbsVector128(p2, tmp1));
 
-                ComplexMask(p1, p0, p3, p2, thresh, ithresh, ref mask);
-                DoFilter4Sse2(ref p1, ref p0, ref p3, ref p2, mask, hevThresh);
+                ComplexMaskVector128(p1, p0, p3, p2, thresh, ithresh, ref mask);
+                DoFilter4Vector128(ref p1, ref p0, ref p3, ref p2, mask, hevThresh);
 
-                Store16x4(p1, p0, p3, p2, ref bRef, ref Unsafe.Add(ref bRef, 8 * (uint)stride), stride);
+                Store16x4Vector128(p1, p0, p3, p2, ref bRef, ref Unsafe.Add(ref bRef, 8 * (uint)stride), stride);
 
                 // Rotate samples.
                 p1 = tmp1;
@@ -1690,39 +1584,39 @@ internal static class LossyUtils
     [MethodImpl(InliningOptions.ShortMethod)]
     public static void VFilter8(Span<byte> u, Span<byte> v, int offset, int stride, int thresh, int ithresh, int hevThresh)
     {
-        if (Sse2.IsSupported)
+        if (Vector128.IsHardwareAccelerated)
         {
             // Load uv h-edges.
             ref byte uRef = ref MemoryMarshal.GetReference(u);
             ref byte vRef = ref MemoryMarshal.GetReference(v);
-            Vector128<byte> t1 = LoadUvEdge(ref uRef, ref vRef, offset - (4 * stride));
-            Vector128<byte> p2 = LoadUvEdge(ref uRef, ref vRef, offset - (3 * stride));
-            Vector128<byte> p1 = LoadUvEdge(ref uRef, ref vRef, offset - (2 * stride));
-            Vector128<byte> p0 = LoadUvEdge(ref uRef, ref vRef, offset - stride);
+            Vector128<byte> t1 = LoadUvEdgeVector128(ref uRef, ref vRef, offset - (4 * stride));
+            Vector128<byte> p2 = LoadUvEdgeVector128(ref uRef, ref vRef, offset - (3 * stride));
+            Vector128<byte> p1 = LoadUvEdgeVector128(ref uRef, ref vRef, offset - (2 * stride));
+            Vector128<byte> p0 = LoadUvEdgeVector128(ref uRef, ref vRef, offset - stride);
 
-            Vector128<byte> mask = Abs(p1, p0);
-            mask = Sse2.Max(mask, Abs(t1, p2));
-            mask = Sse2.Max(mask, Abs(p2, p1));
+            Vector128<byte> mask = AbsVector128(p1, p0);
+            mask = Vector128.Max(mask, AbsVector128(t1, p2));
+            mask = Vector128.Max(mask, AbsVector128(p2, p1));
 
-            Vector128<byte> q0 = LoadUvEdge(ref uRef, ref vRef, offset);
-            Vector128<byte> q1 = LoadUvEdge(ref uRef, ref vRef, offset + stride);
-            Vector128<byte> q2 = LoadUvEdge(ref uRef, ref vRef, offset + (2 * stride));
-            t1 = LoadUvEdge(ref uRef, ref vRef, offset + (3 * stride));
+            Vector128<byte> q0 = LoadUvEdgeVector128(ref uRef, ref vRef, offset);
+            Vector128<byte> q1 = LoadUvEdgeVector128(ref uRef, ref vRef, offset + stride);
+            Vector128<byte> q2 = LoadUvEdgeVector128(ref uRef, ref vRef, offset + (2 * stride));
+            t1 = LoadUvEdgeVector128(ref uRef, ref vRef, offset + (3 * stride));
 
-            mask = Sse2.Max(mask, Abs(q1, q0));
-            mask = Sse2.Max(mask, Abs(t1, q2));
-            mask = Sse2.Max(mask, Abs(q2, q1));
+            mask = Vector128.Max(mask, AbsVector128(q1, q0));
+            mask = Vector128.Max(mask, AbsVector128(t1, q2));
+            mask = Vector128.Max(mask, AbsVector128(q2, q1));
 
-            ComplexMask(p1, p0, q0, q1, thresh, ithresh, ref mask);
-            DoFilter6Sse2(ref p2, ref p1, ref p0, ref q0, ref q1, ref q2, mask, hevThresh);
+            ComplexMaskVector128(p1, p0, q0, q1, thresh, ithresh, ref mask);
+            DoFilter6Vector128(ref p2, ref p1, ref p0, ref q0, ref q1, ref q2, mask, hevThresh);
 
             // Store.
-            StoreUv(p2, ref uRef, ref vRef, offset - (3 * stride));
-            StoreUv(p1, ref uRef, ref vRef, offset - (2 * stride));
-            StoreUv(p0, ref uRef, ref vRef, offset - stride);
-            StoreUv(q0, ref uRef, ref vRef, offset);
-            StoreUv(q1, ref uRef, ref vRef, offset + (1 * stride));
-            StoreUv(q2, ref uRef, ref vRef, offset + (2 * stride));
+            StoreUvVector128(p2, ref uRef, ref vRef, offset - (3 * stride));
+            StoreUvVector128(p1, ref uRef, ref vRef, offset - (2 * stride));
+            StoreUvVector128(p0, ref uRef, ref vRef, offset - stride);
+            StoreUvVector128(q0, ref uRef, ref vRef, offset);
+            StoreUvVector128(q1, ref uRef, ref vRef, offset + (1 * stride));
+            StoreUvVector128(q2, ref uRef, ref vRef, offset + (2 * stride));
         }
         else
         {
@@ -1734,27 +1628,27 @@ internal static class LossyUtils
     [MethodImpl(InliningOptions.ShortMethod)]
     public static void HFilter8(Span<byte> u, Span<byte> v, int offset, int stride, int thresh, int ithresh, int hevThresh)
     {
-        if (Sse2.IsSupported)
+        if (Vector128.IsHardwareAccelerated)
         {
             ref byte uRef = ref MemoryMarshal.GetReference(u);
             ref byte vRef = ref MemoryMarshal.GetReference(v);
-            Load16x4(ref Unsafe.Add(ref uRef, (uint)offset - 4), ref Unsafe.Add(ref vRef, (uint)offset - 4), stride, out Vector128<byte> p3, out Vector128<byte> p2, out Vector128<byte> p1, out Vector128<byte> p0);
+            Load16x4Vector128(ref Unsafe.Add(ref uRef, (uint)offset - 4), ref Unsafe.Add(ref vRef, (uint)offset - 4), stride, out Vector128<byte> p3, out Vector128<byte> p2, out Vector128<byte> p1, out Vector128<byte> p0);
 
-            Vector128<byte> mask = Abs(p1, p0);
-            mask = Sse2.Max(mask, Abs(p3, p2));
-            mask = Sse2.Max(mask, Abs(p2, p1));
+            Vector128<byte> mask = AbsVector128(p1, p0);
+            mask = Vector128.Max(mask, AbsVector128(p3, p2));
+            mask = Vector128.Max(mask, AbsVector128(p2, p1));
 
-            Load16x4(ref Unsafe.Add(ref uRef, (uint)offset), ref Unsafe.Add(ref vRef, (uint)offset), stride, out Vector128<byte> q0, out Vector128<byte> q1, out Vector128<byte> q2, out Vector128<byte> q3);
+            Load16x4Vector128(ref Unsafe.Add(ref uRef, (uint)offset), ref Unsafe.Add(ref vRef, (uint)offset), stride, out Vector128<byte> q0, out Vector128<byte> q1, out Vector128<byte> q2, out Vector128<byte> q3);
 
-            mask = Sse2.Max(mask, Abs(q1, q0));
-            mask = Sse2.Max(mask, Abs(q3, q2));
-            mask = Sse2.Max(mask, Abs(q2, q1));
+            mask = Vector128.Max(mask, AbsVector128(q1, q0));
+            mask = Vector128.Max(mask, AbsVector128(q3, q2));
+            mask = Vector128.Max(mask, AbsVector128(q2, q1));
 
-            ComplexMask(p1, p0, q0, q1, thresh, ithresh, ref mask);
-            DoFilter6Sse2(ref p2, ref p1, ref p0, ref q0, ref q1, ref q2, mask, hevThresh);
+            ComplexMaskVector128(p1, p0, q0, q1, thresh, ithresh, ref mask);
+            DoFilter6Vector128(ref p2, ref p1, ref p0, ref q0, ref q1, ref q2, mask, hevThresh);
 
-            Store16x4(p3, p2, p1, p0, ref Unsafe.Add(ref uRef, (uint)offset - 4), ref Unsafe.Add(ref vRef, (uint)offset - 4), stride);
-            Store16x4(q0, q1, q2, q3, ref Unsafe.Add(ref uRef, (uint)offset), ref Unsafe.Add(ref vRef, (uint)offset), stride);
+            Store16x4Vector128(p3, p2, p1, p0, ref Unsafe.Add(ref uRef, (uint)offset - 4), ref Unsafe.Add(ref vRef, (uint)offset - 4), stride);
+            Store16x4Vector128(q0, q1, q2, q3, ref Unsafe.Add(ref uRef, (uint)offset), ref Unsafe.Add(ref vRef, (uint)offset), stride);
         }
         else
         {
@@ -1766,39 +1660,39 @@ internal static class LossyUtils
     [MethodImpl(InliningOptions.ShortMethod)]
     public static void VFilter8i(Span<byte> u, Span<byte> v, int offset, int stride, int thresh, int ithresh, int hevThresh)
     {
-        if (Sse2.IsSupported)
+        if (Vector128.IsHardwareAccelerated)
         {
             // Load uv h-edges.
             ref byte uRef = ref MemoryMarshal.GetReference(u);
             ref byte vRef = ref MemoryMarshal.GetReference(v);
-            Vector128<byte> t2 = LoadUvEdge(ref uRef, ref vRef, offset);
-            Vector128<byte> t1 = LoadUvEdge(ref uRef, ref vRef, offset + stride);
-            Vector128<byte> p1 = LoadUvEdge(ref uRef, ref vRef, offset + (stride * 2));
-            Vector128<byte> p0 = LoadUvEdge(ref uRef, ref vRef, offset + (stride * 3));
+            Vector128<byte> t2 = LoadUvEdgeVector128(ref uRef, ref vRef, offset);
+            Vector128<byte> t1 = LoadUvEdgeVector128(ref uRef, ref vRef, offset + stride);
+            Vector128<byte> p1 = LoadUvEdgeVector128(ref uRef, ref vRef, offset + (stride * 2));
+            Vector128<byte> p0 = LoadUvEdgeVector128(ref uRef, ref vRef, offset + (stride * 3));
 
-            Vector128<byte> mask = Abs(p1, p0);
-            mask = Sse2.Max(mask, Abs(t2, t1));
-            mask = Sse2.Max(mask, Abs(t1, p1));
+            Vector128<byte> mask = AbsVector128(p1, p0);
+            mask = Vector128.Max(mask, AbsVector128(t2, t1));
+            mask = Vector128.Max(mask, AbsVector128(t1, p1));
 
             offset += 4 * stride;
 
-            Vector128<byte> q0 = LoadUvEdge(ref uRef, ref vRef, offset);
-            Vector128<byte> q1 = LoadUvEdge(ref uRef, ref vRef, offset + stride);
-            t1 = LoadUvEdge(ref uRef, ref vRef, offset + (stride * 2));
-            t2 = LoadUvEdge(ref uRef, ref vRef, offset + (stride * 3));
+            Vector128<byte> q0 = LoadUvEdgeVector128(ref uRef, ref vRef, offset);
+            Vector128<byte> q1 = LoadUvEdgeVector128(ref uRef, ref vRef, offset + stride);
+            t1 = LoadUvEdgeVector128(ref uRef, ref vRef, offset + (stride * 2));
+            t2 = LoadUvEdgeVector128(ref uRef, ref vRef, offset + (stride * 3));
 
-            mask = Sse2.Max(mask, Abs(q1, q0));
-            mask = Sse2.Max(mask, Abs(t2, t1));
-            mask = Sse2.Max(mask, Abs(t1, q1));
+            mask = Vector128.Max(mask, AbsVector128(q1, q0));
+            mask = Vector128.Max(mask, AbsVector128(t2, t1));
+            mask = Vector128.Max(mask, AbsVector128(t1, q1));
 
-            ComplexMask(p1, p0, q0, q1, thresh, ithresh, ref mask);
-            DoFilter4Sse2(ref p1, ref p0, ref q0, ref q1, mask, hevThresh);
+            ComplexMaskVector128(p1, p0, q0, q1, thresh, ithresh, ref mask);
+            DoFilter4Vector128(ref p1, ref p0, ref q0, ref q1, mask, hevThresh);
 
             // Store.
-            StoreUv(p1, ref uRef, ref vRef, offset + (-2 * stride));
-            StoreUv(p0, ref uRef, ref vRef, offset + (-1 * stride));
-            StoreUv(q0, ref uRef, ref vRef, offset);
-            StoreUv(q1, ref uRef, ref vRef, offset + stride);
+            StoreUvVector128(p1, ref uRef, ref vRef, offset + (-2 * stride));
+            StoreUvVector128(p0, ref uRef, ref vRef, offset + (-1 * stride));
+            StoreUvVector128(q0, ref uRef, ref vRef, offset);
+            StoreUvVector128(q1, ref uRef, ref vRef, offset + stride);
         }
         else
         {
@@ -1811,31 +1705,31 @@ internal static class LossyUtils
     [MethodImpl(InliningOptions.ShortMethod)]
     public static void HFilter8i(Span<byte> u, Span<byte> v, int offset, int stride, int thresh, int ithresh, int hevThresh)
     {
-        if (Sse2.IsSupported)
+        if (Vector128.IsHardwareAccelerated)
         {
             ref byte uRef = ref MemoryMarshal.GetReference(u);
             ref byte vRef = ref MemoryMarshal.GetReference(v);
-            Load16x4(ref Unsafe.Add(ref uRef, (uint)offset), ref Unsafe.Add(ref vRef, (uint)offset), stride, out Vector128<byte> t2, out Vector128<byte> t1, out Vector128<byte> p1, out Vector128<byte> p0);
+            Load16x4Vector128(ref Unsafe.Add(ref uRef, (uint)offset), ref Unsafe.Add(ref vRef, (uint)offset), stride, out Vector128<byte> t2, out Vector128<byte> t1, out Vector128<byte> p1, out Vector128<byte> p0);
 
-            Vector128<byte> mask = Abs(p1, p0);
-            mask = Sse2.Max(mask, Abs(t2, t1));
-            mask = Sse2.Max(mask, Abs(t1, p1));
+            Vector128<byte> mask = AbsVector128(p1, p0);
+            mask = Vector128.Max(mask, AbsVector128(t2, t1));
+            mask = Vector128.Max(mask, AbsVector128(t1, p1));
 
             // Beginning of q0.
             offset += 4;
 
-            Load16x4(ref Unsafe.Add(ref uRef, (uint)offset), ref Unsafe.Add(ref vRef, (uint)offset), stride, out Vector128<byte> q0, out Vector128<byte> q1, out t1, out t2);
+            Load16x4Vector128(ref Unsafe.Add(ref uRef, (uint)offset), ref Unsafe.Add(ref vRef, (uint)offset), stride, out Vector128<byte> q0, out Vector128<byte> q1, out t1, out t2);
 
-            mask = Sse2.Max(mask, Abs(q1, q0));
-            mask = Sse2.Max(mask, Abs(t2, t1));
-            mask = Sse2.Max(mask, Abs(t1, q1));
+            mask = Vector128.Max(mask, AbsVector128(q1, q0));
+            mask = Vector128.Max(mask, AbsVector128(t2, t1));
+            mask = Vector128.Max(mask, AbsVector128(t1, q1));
 
-            ComplexMask(p1, p0, q0, q1, thresh, ithresh, ref mask);
-            DoFilter4Sse2(ref p1, ref p0, ref q0, ref q1, mask, hevThresh);
+            ComplexMaskVector128(p1, p0, q0, q1, thresh, ithresh, ref mask);
+            DoFilter4Vector128(ref p1, ref p0, ref q0, ref q1, mask, hevThresh);
 
             // Beginning of p1.
             offset -= 2;
-            Store16x4(p1, p0, q0, q1, ref Unsafe.Add(ref uRef, (uint)offset), ref Unsafe.Add(ref vRef, (uint)offset), stride);
+            Store16x4Vector128(p1, p0, q0, q1, ref Unsafe.Add(ref uRef, (uint)offset), ref Unsafe.Add(ref vRef, (uint)offset), stride);
         }
         else
         {
@@ -1847,7 +1741,7 @@ internal static class LossyUtils
 
     public static void Mean16x4(Span<byte> input, Span<uint> dc)
     {
-        if (Ssse3.IsSupported)
+        if (Vector128.IsHardwareAccelerated)
         {
             Vector128<byte> mean16x4Mask = Vector128.Create((short)0x00ff).AsByte();
 
@@ -1855,23 +1749,23 @@ internal static class LossyUtils
             Vector128<byte> a1 = Unsafe.As<byte, Vector128<byte>>(ref MemoryMarshal.GetReference(input.Slice(WebpConstants.Bps, 16)));
             Vector128<byte> a2 = Unsafe.As<byte, Vector128<byte>>(ref MemoryMarshal.GetReference(input.Slice(WebpConstants.Bps * 2, 16)));
             Vector128<byte> a3 = Unsafe.As<byte, Vector128<byte>>(ref MemoryMarshal.GetReference(input.Slice(WebpConstants.Bps * 3, 16)));
-            Vector128<short> b0 = Sse2.ShiftRightLogical(a0.AsInt16(), 8); // hi byte
-            Vector128<short> b1 = Sse2.ShiftRightLogical(a1.AsInt16(), 8);
-            Vector128<short> b2 = Sse2.ShiftRightLogical(a2.AsInt16(), 8);
-            Vector128<short> b3 = Sse2.ShiftRightLogical(a3.AsInt16(), 8);
-            Vector128<byte> c0 = Sse2.And(a0, mean16x4Mask); // lo byte
-            Vector128<byte> c1 = Sse2.And(a1, mean16x4Mask);
-            Vector128<byte> c2 = Sse2.And(a2, mean16x4Mask);
-            Vector128<byte> c3 = Sse2.And(a3, mean16x4Mask);
-            Vector128<int> d0 = Sse2.Add(b0.AsInt32(), c0.AsInt32());
-            Vector128<int> d1 = Sse2.Add(b1.AsInt32(), c1.AsInt32());
-            Vector128<int> d2 = Sse2.Add(b2.AsInt32(), c2.AsInt32());
-            Vector128<int> d3 = Sse2.Add(b3.AsInt32(), c3.AsInt32());
-            Vector128<int> e0 = Sse2.Add(d0, d1);
-            Vector128<int> e1 = Sse2.Add(d2, d3);
-            Vector128<int> f0 = Sse2.Add(e0, e1);
-            Vector128<short> hadd = Ssse3.HorizontalAdd(f0.AsInt16(), f0.AsInt16());
-            Vector128<uint> wide = Sse2.UnpackLow(hadd, Vector128<short>.Zero).AsUInt32();
+            Vector128<short> b0 = Vector128.ShiftRightLogical(a0.AsInt16(), 8); // hi byte
+            Vector128<short> b1 = Vector128.ShiftRightLogical(a1.AsInt16(), 8);
+            Vector128<short> b2 = Vector128.ShiftRightLogical(a2.AsInt16(), 8);
+            Vector128<short> b3 = Vector128.ShiftRightLogical(a3.AsInt16(), 8);
+            Vector128<byte> c0 = a0 & mean16x4Mask; // lo byte
+            Vector128<byte> c1 = a1 & mean16x4Mask;
+            Vector128<byte> c2 = a2 & mean16x4Mask;
+            Vector128<byte> c3 = a3 & mean16x4Mask;
+            Vector128<int> d0 = b0.AsInt32() + c0.AsInt32();
+            Vector128<int> d1 = b1.AsInt32() + c1.AsInt32();
+            Vector128<int> d2 = b2.AsInt32() + c2.AsInt32();
+            Vector128<int> d3 = b3.AsInt32() + c3.AsInt32();
+            Vector128<int> e0 = d0 + d1;
+            Vector128<int> e1 = d2 + d3;
+            Vector128<int> f0 = e0 + e1;
+            Vector128<short> hadd = Vector128_.HorizontalAdd(f0.AsInt16(), f0.AsInt16());
+            Vector128<uint> wide = Vector128_.UnpackLow(hadd, Vector128<short>.Zero).AsUInt32();
 
             ref uint outputRef = ref MemoryMarshal.GetReference(dc);
             Unsafe.As<uint, Vector128<uint>>(ref outputRef) = wide;
@@ -1910,6 +1804,43 @@ internal static class LossyUtils
     // Cost of coding one event with probability 'proba'.
     public static int Vp8BitCost(int bit, byte proba) => bit == 0 ? WebpLookupTables.Vp8EntropyCost[proba] : WebpLookupTables.Vp8EntropyCost[255 - proba];
 
+    /// <summary>
+    /// Reduces elements of the vector into one sum.
+    /// </summary>
+    /// <param name="accumulator">The accumulator to reduce.</param>
+    /// <returns>The sum of all elements.</returns>
+    [MethodImpl(InliningOptions.ShortMethod)]
+    public static int ReduceSumVector256(Vector256<int> accumulator)
+    {
+        // Add upper lane to lower lane.
+        Vector128<int> vsum = accumulator.GetLower() + accumulator.GetUpper();
+
+        // Add odd to even.
+        vsum += Vector128_.ShuffleNative(vsum, 0b_11_11_01_01);
+
+        // Add high to low.
+        vsum += Vector128_.ShuffleNative(vsum, 0b_11_10_11_10);
+
+        return vsum.ToScalar();
+    }
+
+    /// <summary>
+    /// Reduces elements of the vector into one sum.
+    /// </summary>
+    /// <param name="accumulator">The accumulator to reduce.</param>
+    /// <returns>The sum of all elements.</returns>
+    [MethodImpl(InliningOptions.ShortMethod)]
+    private static int ReduceSumVector128(Vector128<int> accumulator)
+    {
+        // Add odd to even.
+        Vector128<int> vsum = accumulator + Vector128_.ShuffleNative(accumulator, 0b_11_11_01_01);
+
+        // Add high to low.
+        vsum += Vector128_.ShuffleNative(vsum, 0b_11_10_11_10);
+
+        return vsum.ToScalar();
+    }
+
     [MethodImpl(InliningOptions.ShortMethod)]
     private static void Put16(int v, Span<byte> dst)
     {
@@ -2015,144 +1946,144 @@ internal static class LossyUtils
     }
 
     // Applies filter on 2 pixels (p0 and q0)
-    private static void DoFilter2Sse2(ref Vector128<byte> p1, ref Vector128<byte> p0, ref Vector128<byte> q0, ref Vector128<byte> q1, int thresh)
+    private static void DoFilter2Vector128(ref Vector128<byte> p1, ref Vector128<byte> p0, ref Vector128<byte> q0, ref Vector128<byte> q1, int thresh)
     {
-        var signBit = Vector128.Create((byte)0x80);
+        Vector128<byte> signBit = Vector128.Create((byte)0x80);
 
         // Convert p1/q1 to byte (for GetBaseDelta).
-        Vector128<byte> p1s = Sse2.Xor(p1, signBit);
-        Vector128<byte> q1s = Sse2.Xor(q1, signBit);
-        Vector128<byte> mask = NeedsFilter(p1, p0, q0, q1, thresh);
+        Vector128<byte> p1s = p1 ^ signBit;
+        Vector128<byte> q1s = q1 ^ signBit;
+        Vector128<byte> mask = NeedsFilterVector128(p1, p0, q0, q1, thresh);
 
         // Flip sign.
-        p0 = Sse2.Xor(p0, signBit);
-        q0 = Sse2.Xor(q0, signBit);
+        p0 ^= signBit;
+        q0 ^= signBit;
 
-        Vector128<byte> a = GetBaseDelta(p1s.AsSByte(), p0.AsSByte(), q0.AsSByte(), q1s.AsSByte()).AsByte();
+        Vector128<byte> a = GetBaseDeltaVector128(p1s.AsSByte(), p0.AsSByte(), q0.AsSByte(), q1s.AsSByte()).AsByte();
 
         // Mask filter values we don't care about.
-        a = Sse2.And(a, mask);
+        a &= mask;
 
-        DoSimpleFilterSse2(ref p0, ref q0, a);
+        DoSimpleFilterVector128(ref p0, ref q0, a);
 
         // Flip sign.
-        p0 = Sse2.Xor(p0, signBit);
-        q0 = Sse2.Xor(q0, signBit);
+        p0 ^= signBit;
+        q0 ^= signBit;
     }
 
     // Applies filter on 4 pixels (p1, p0, q0 and q1)
-    private static void DoFilter4Sse2(ref Vector128<byte> p1, ref Vector128<byte> p0, ref Vector128<byte> q0, ref Vector128<byte> q1, Vector128<byte> mask, int tresh)
+    private static void DoFilter4Vector128(ref Vector128<byte> p1, ref Vector128<byte> p0, ref Vector128<byte> q0, ref Vector128<byte> q1, Vector128<byte> mask, int tresh)
     {
         // Compute hev mask.
-        Vector128<byte> notHev = GetNotHev(ref p1, ref p0, ref q0, ref q1, tresh);
+        Vector128<byte> notHev = GetNotHevVector128(ref p1, ref p0, ref q0, ref q1, tresh);
 
-        var signBit = Vector128.Create((byte)0x80);
+        Vector128<byte> signBit = Vector128.Create((byte)0x80);
 
         // Convert to signed values.
-        p1 = Sse2.Xor(p1, signBit);
-        p0 = Sse2.Xor(p0, signBit);
-        q0 = Sse2.Xor(q0, signBit);
-        q1 = Sse2.Xor(q1, signBit);
-
-        Vector128<sbyte> t1 = Sse2.SubtractSaturate(p1.AsSByte(), q1.AsSByte()); // p1 - q1
-        t1 = Sse2.AndNot(notHev, t1.AsByte()).AsSByte(); // hev(p1 - q1)
-        Vector128<sbyte> t2 = Sse2.SubtractSaturate(q0.AsSByte(), p0.AsSByte()); // q0 - p0
-        t1 = Sse2.AddSaturate(t1, t2); // hev(p1 - q1) + 1 * (q0 - p0)
-        t1 = Sse2.AddSaturate(t1, t2); // hev(p1 - q1) + 2 * (q0 - p0)
-        t1 = Sse2.AddSaturate(t1, t2); // hev(p1 - q1) + 3 * (q0 - p0)
-        t1 = Sse2.And(t1.AsByte(), mask).AsSByte(); // mask filter values we don't care about.
-
-        t2 = Sse2.AddSaturate(t1, Vector128.Create((byte)3).AsSByte());                  // 3 * (q0 - p0) + hev(p1 - q1) + 3
-        Vector128<sbyte> t3 = Sse2.AddSaturate(t1, Vector128.Create((byte)4).AsSByte()); // 3 * (q0 - p0) + hev(p1 - q1) + 4
-        t2 = SignedShift8b(t2.AsByte()); // (3 * (q0 - p0) + hev(p1 - q1) + 3) >> 3
-        t3 = SignedShift8b(t3.AsByte()); // (3 * (q0 - p0) + hev(p1 - q1) + 4) >> 3
-        p0 = Sse2.AddSaturate(p0.AsSByte(), t2).AsByte(); // p0 += t2
-        q0 = Sse2.SubtractSaturate(q0.AsSByte(), t3).AsByte(); // q0 -= t3
-        p0 = Sse2.Xor(p0, signBit);
-        q0 = Sse2.Xor(q0, signBit);
+        p1 ^= signBit;
+        p0 ^= signBit;
+        q0 ^= signBit;
+        q1 ^= signBit;
+
+        Vector128<sbyte> t1 = Vector128_.SubtractSaturate(p1.AsSByte(), q1.AsSByte()); // p1 - q1
+        t1 = (~notHev & t1.AsByte()).AsSByte(); // hev(p1 - q1)
+        Vector128<sbyte> t2 = Vector128_.SubtractSaturate(q0.AsSByte(), p0.AsSByte()); // q0 - p0
+        t1 = Vector128_.AddSaturate(t1, t2); // hev(p1 - q1) + 1 * (q0 - p0)
+        t1 = Vector128_.AddSaturate(t1, t2); // hev(p1 - q1) + 2 * (q0 - p0)
+        t1 = Vector128_.AddSaturate(t1, t2); // hev(p1 - q1) + 3 * (q0 - p0)
+        t1 = (t1.AsByte() & mask).AsSByte(); // mask filter values we don't care about.
+
+        t2 = Vector128_.AddSaturate(t1, Vector128.Create((byte)3).AsSByte());                  // 3 * (q0 - p0) + hev(p1 - q1) + 3
+        Vector128<sbyte> t3 = Vector128_.AddSaturate(t1, Vector128.Create((byte)4).AsSByte()); // 3 * (q0 - p0) + hev(p1 - q1) + 4
+        t2 = SignedShift8bVector128(t2.AsByte()); // (3 * (q0 - p0) + hev(p1 - q1) + 3) >> 3
+        t3 = SignedShift8bVector128(t3.AsByte()); // (3 * (q0 - p0) + hev(p1 - q1) + 4) >> 3
+        p0 = Vector128_.AddSaturate(p0.AsSByte(), t2).AsByte(); // p0 += t2
+        q0 = Vector128_.SubtractSaturate(q0.AsSByte(), t3).AsByte(); // q0 -= t3
+        p0 ^= signBit;
+        q0 ^= signBit;
 
         // This is equivalent to signed (a + 1) >> 1 calculation.
-        t2 = Sse2.Add(t3, signBit.AsSByte());
-        t3 = Sse2.Average(t2.AsByte(), Vector128<byte>.Zero).AsSByte();
-        t3 = Sse2.Subtract(t3, Vector128.Create((sbyte)64));
+        t2 = t3 + signBit.AsSByte();
+        t3 = Vector128_.Average(t2.AsByte(), Vector128<byte>.Zero).AsSByte();
+        t3 -= Vector128.Create((sbyte)64);
 
-        t3 = Sse2.And(notHev, t3.AsByte()).AsSByte(); // if !hev
-        q1 = Sse2.SubtractSaturate(q1.AsSByte(), t3).AsByte(); // q1 -= t3
-        p1 = Sse2.AddSaturate(p1.AsSByte(), t3).AsByte(); // p1 += t3
-        p1 = Sse2.Xor(p1.AsByte(), signBit);
-        q1 = Sse2.Xor(q1.AsByte(), signBit);
+        t3 = (notHev & t3.AsByte()).AsSByte(); // if !hev
+        q1 = Vector128_.SubtractSaturate(q1.AsSByte(), t3).AsByte(); // q1 -= t3
+        p1 = Vector128_.AddSaturate(p1.AsSByte(), t3).AsByte(); // p1 += t3
+        p1 = p1.AsByte() ^ signBit;
+        q1 = q1.AsByte() ^ signBit;
     }
 
     // Applies filter on 6 pixels (p2, p1, p0, q0, q1 and q2)
-    private static void DoFilter6Sse2(ref Vector128<byte> p2, ref Vector128<byte> p1, ref Vector128<byte> p0, ref Vector128<byte> q0, ref Vector128<byte> q1, ref Vector128<byte> q2, Vector128<byte> mask, int tresh)
+    private static void DoFilter6Vector128(ref Vector128<byte> p2, ref Vector128<byte> p1, ref Vector128<byte> p0, ref Vector128<byte> q0, ref Vector128<byte> q1, ref Vector128<byte> q2, Vector128<byte> mask, int tresh)
     {
         // Compute hev mask.
-        Vector128<byte> notHev = GetNotHev(ref p1, ref p0, ref q0, ref q1, tresh);
+        Vector128<byte> notHev = GetNotHevVector128(ref p1, ref p0, ref q0, ref q1, tresh);
 
         // Convert to signed values.
-        var signBit = Vector128.Create((byte)0x80);
-        p1 = Sse2.Xor(p1, signBit);
-        p0 = Sse2.Xor(p0, signBit);
-        q0 = Sse2.Xor(q0, signBit);
-        q1 = Sse2.Xor(q1, signBit);
-        p2 = Sse2.Xor(p2, signBit);
-        q2 = Sse2.Xor(q2, signBit);
+        Vector128<byte> signBit = Vector128.Create((byte)0x80);
+        p1 ^= signBit;
+        p0 ^= signBit;
+        q0 ^= signBit;
+        q1 ^= signBit;
+        p2 ^= signBit;
+        q2 ^= signBit;
 
-        Vector128<sbyte> a = GetBaseDelta(p1.AsSByte(), p0.AsSByte(), q0.AsSByte(), q1.AsSByte());
+        Vector128<sbyte> a = GetBaseDeltaVector128(p1.AsSByte(), p0.AsSByte(), q0.AsSByte(), q1.AsSByte());
 
         // Do simple filter on pixels with hev.
-        Vector128<byte> m = Sse2.AndNot(notHev, mask);
-        Vector128<byte> f = Sse2.And(a.AsByte(), m);
-        DoSimpleFilterSse2(ref p0, ref q0, f);
+        Vector128<byte> m = ~notHev & mask;
+        Vector128<byte> f = a.AsByte() & m;
+        DoSimpleFilterVector128(ref p0, ref q0, f);
 
         // Do strong filter on pixels with not hev.
-        m = Sse2.And(notHev, mask);
-        f = Sse2.And(a.AsByte(), m);
-        Vector128<byte> flow = Sse2.UnpackLow(Vector128<byte>.Zero, f);
-        Vector128<byte> fhigh = Sse2.UnpackHigh(Vector128<byte>.Zero, f);
+        m = notHev & mask;
+        f = a.AsByte() & m;
+        Vector128<byte> flow = Vector128_.UnpackLow(Vector128<byte>.Zero, f);
+        Vector128<byte> fhigh = Vector128_.UnpackHigh(Vector128<byte>.Zero, f);
 
-        var nine = Vector128.Create((short)0x0900);
-        Vector128<short> f9Low = Sse2.MultiplyHigh(flow.AsInt16(), nine); // Filter (lo) * 9
-        Vector128<short> f9High = Sse2.MultiplyHigh(fhigh.AsInt16(), nine); // Filter (hi) * 9
+        Vector128<short> nine = Vector128.Create((short)0x0900);
+        Vector128<short> f9Low = Vector128_.MultiplyHigh(flow.AsInt16(), nine); // Filter (lo) * 9
+        Vector128<short> f9High = Vector128_.MultiplyHigh(fhigh.AsInt16(), nine); // Filter (hi) * 9
 
-        var sixtyThree = Vector128.Create((short)63);
-        Vector128<short> a2Low = Sse2.Add(f9Low, sixtyThree); // Filter * 9 + 63
-        Vector128<short> a2High = Sse2.Add(f9High, sixtyThree); // Filter * 9 + 63
+        Vector128<short> sixtyThree = Vector128.Create((short)63);
+        Vector128<short> a2Low = f9Low + sixtyThree; // Filter * 9 + 63
+        Vector128<short> a2High = f9High + sixtyThree; // Filter * 9 + 63
 
-        Vector128<short> a1Low = Sse2.Add(a2Low, f9Low); // Filter * 18 + 63
-        Vector128<short> a1High = Sse2.Add(a2High, f9High); // // Filter * 18 + 63
+        Vector128<short> a1Low = a2Low + f9Low; // Filter * 18 + 63
+        Vector128<short> a1High = a2High + f9High; // // Filter * 18 + 63
 
-        Vector128<short> a0Low = Sse2.Add(a1Low, f9Low); // Filter * 27 + 63
-        Vector128<short> a0High = Sse2.Add(a1High, f9High); // Filter * 27 + 63
+        Vector128<short> a0Low = a1Low + f9Low; // Filter * 27 + 63
+        Vector128<short> a0High = a1High + f9High; // Filter * 27 + 63
 
-        Update2Pixels(ref p2, ref q2, a2Low, a2High);
-        Update2Pixels(ref p1, ref q1, a1Low, a1High);
-        Update2Pixels(ref p0, ref q0, a0Low, a0High);
+        Update2PixelsVector128(ref p2, ref q2, a2Low, a2High);
+        Update2PixelsVector128(ref p1, ref q1, a1Low, a1High);
+        Update2PixelsVector128(ref p0, ref q0, a0Low, a0High);
     }
 
-    private static void DoSimpleFilterSse2(ref Vector128<byte> p0, ref Vector128<byte> q0, Vector128<byte> fl)
+    private static void DoSimpleFilterVector128(ref Vector128<byte> p0, ref Vector128<byte> q0, Vector128<byte> fl)
     {
-        Vector128<sbyte> v3 = Sse2.AddSaturate(fl.AsSByte(), Vector128.Create((byte)3).AsSByte());
-        Vector128<sbyte> v4 = Sse2.AddSaturate(fl.AsSByte(), Vector128.Create((byte)4).AsSByte());
+        Vector128<sbyte> v3 = Vector128_.AddSaturate(fl.AsSByte(), Vector128.Create((byte)3).AsSByte());
+        Vector128<sbyte> v4 = Vector128_.AddSaturate(fl.AsSByte(), Vector128.Create((byte)4).AsSByte());
 
-        v4 = SignedShift8b(v4.AsByte()).AsSByte(); // v4 >> 3
-        v3 = SignedShift8b(v3.AsByte()).AsSByte(); // v3 >> 3
-        q0 = Sse2.SubtractSaturate(q0.AsSByte(), v4).AsByte(); // q0 -= v4
-        p0 = Sse2.AddSaturate(p0.AsSByte(), v3).AsByte(); // p0 += v3
+        v4 = SignedShift8bVector128(v4.AsByte()).AsSByte(); // v4 >> 3
+        v3 = SignedShift8bVector128(v3.AsByte()).AsSByte(); // v3 >> 3
+        q0 = Vector128_.SubtractSaturate(q0.AsSByte(), v4).AsByte(); // q0 -= v4
+        p0 = Vector128_.AddSaturate(p0.AsSByte(), v3).AsByte(); // p0 += v3
     }
 
-    private static Vector128<byte> GetNotHev(ref Vector128<byte> p1, ref Vector128<byte> p0, ref Vector128<byte> q0, ref Vector128<byte> q1, int hevThresh)
+    private static Vector128<byte> GetNotHevVector128(ref Vector128<byte> p1, ref Vector128<byte> p0, ref Vector128<byte> q0, ref Vector128<byte> q1, int hevThresh)
     {
-        Vector128<byte> t1 = Abs(p1, p0);
-        Vector128<byte> t2 = Abs(q1, q0);
+        Vector128<byte> t1 = AbsVector128(p1, p0);
+        Vector128<byte> t2 = AbsVector128(q1, q0);
 
-        var h = Vector128.Create((byte)hevThresh);
-        Vector128<byte> tMax = Sse2.Max(t1, t2);
+        Vector128<byte> h = Vector128.Create((byte)hevThresh);
+        Vector128<byte> tMax = Vector128.Max(t1, t2);
 
-        Vector128<byte> tMaxH = Sse2.SubtractSaturate(tMax, h);
+        Vector128<byte> tMaxH = Vector128_.SubtractSaturate(tMax, h);
 
         // not_hev <= t1 && not_hev <= t2
-        return Sse2.CompareEqual(tMaxH, Vector128<byte>.Zero);
+        return Vector128.Equals(tMaxH, Vector128<byte>.Zero);
     }
 
     // Applies filter on 4 pixels (p1, p0, q0 and q1)
@@ -2233,24 +2164,24 @@ internal static class LossyUtils
                WebpLookupTables.Abs0(q2 - q1) <= it && WebpLookupTables.Abs0(q1 - q0) <= it;
     }
 
-    private static Vector128<byte> NeedsFilter(Vector128<byte> p1, Vector128<byte> p0, Vector128<byte> q0, Vector128<byte> q1, int thresh)
+    private static Vector128<byte> NeedsFilterVector128(Vector128<byte> p1, Vector128<byte> p0, Vector128<byte> q0, Vector128<byte> q1, int thresh)
     {
-        var mthresh = Vector128.Create((byte)thresh);
-        Vector128<byte> t1 = Abs(p1, q1); // abs(p1 - q1)
-        var fe = Vector128.Create((byte)0xFE);
-        Vector128<byte> t2 = Sse2.And(t1, fe); // set lsb of each byte to zero.
-        Vector128<short> t3 = Sse2.ShiftRightLogical(t2.AsInt16(), 1); // abs(p1 - q1) / 2
+        Vector128<byte> mthresh = Vector128.Create((byte)thresh);
+        Vector128<byte> t1 = AbsVector128(p1, q1); // abs(p1 - q1)
+        Vector128<byte> fe = Vector128.Create((byte)0xFE);
+        Vector128<byte> t2 = t1 & fe; // set lsb of each byte to zero.
+        Vector128<short> t3 = Vector128.ShiftRightLogical(t2.AsInt16(), 1); // abs(p1 - q1) / 2
 
-        Vector128<byte> t4 = Abs(p0, q0); // abs(p0 - q0)
-        Vector128<byte> t5 = Sse2.AddSaturate(t4, t4); // abs(p0 - q0) * 2
-        Vector128<byte> t6 = Sse2.AddSaturate(t5.AsByte(), t3.AsByte()); // abs(p0-q0)*2 + abs(p1-q1)/2
+        Vector128<byte> t4 = AbsVector128(p0, q0); // abs(p0 - q0)
+        Vector128<byte> t5 = Vector128_.AddSaturate(t4, t4); // abs(p0 - q0) * 2
+        Vector128<byte> t6 = Vector128_.AddSaturate(t5.AsByte(), t3.AsByte()); // abs(p0-q0)*2 + abs(p1-q1)/2
 
-        Vector128<byte> t7 = Sse2.SubtractSaturate(t6, mthresh.AsByte()); // mask <= m_thresh
+        Vector128<byte> t7 = Vector128_.SubtractSaturate(t6, mthresh.AsByte()); // mask <= m_thresh
 
-        return Sse2.CompareEqual(t7, Vector128<byte>.Zero);
+        return Vector128.Equals(t7, Vector128<byte>.Zero);
     }
 
-    private static void Load16x4(ref byte r0, ref byte r8, int stride, out Vector128<byte> p1, out Vector128<byte> p0, out Vector128<byte> q0, out Vector128<byte> q1)
+    private static void Load16x4Vector128(ref byte r0, ref byte r8, int stride, out Vector128<byte> p1, out Vector128<byte> p0, out Vector128<byte> q0, out Vector128<byte> q1)
     {
         // Assume the pixels around the edge (|) are numbered as follows
         //                00 01 | 02 03
@@ -2267,21 +2198,21 @@ internal static class LossyUtils
         // q0 = 73 63 53 43 33 23 13 03 72 62 52 42 32 22 12 02
         // p0 = f1 e1 d1 c1 b1 a1 91 81 f0 e0 d0 c0 b0 a0 90 80
         // q1 = f3 e3 d3 c3 b3 a3 93 83 f2 e2 d2 c2 b2 a2 92 82
-        Load8x4(ref r0, (uint)stride, out Vector128<byte> t1, out Vector128<byte> t2);
-        Load8x4(ref r8, (uint)stride, out p0, out q1);
+        Load8x4Vector128(ref r0, (uint)stride, out Vector128<byte> t1, out Vector128<byte> t2);
+        Load8x4Vector128(ref r8, (uint)stride, out p0, out q1);
 
         // p1 = f0 e0 d0 c0 b0 a0 90 80 70 60 50 40 30 20 10 00
         // p0 = f1 e1 d1 c1 b1 a1 91 81 71 61 51 41 31 21 11 01
         // q0 = f2 e2 d2 c2 b2 a2 92 82 72 62 52 42 32 22 12 02
         // q1 = f3 e3 d3 c3 b3 a3 93 83 73 63 53 43 33 23 13 03
-        p1 = Sse2.UnpackLow(t1.AsInt64(), p0.AsInt64()).AsByte();
-        p0 = Sse2.UnpackHigh(t1.AsInt64(), p0.AsInt64()).AsByte();
-        q0 = Sse2.UnpackLow(t2.AsInt64(), q1.AsInt64()).AsByte();
-        q1 = Sse2.UnpackHigh(t2.AsInt64(), q1.AsInt64()).AsByte();
+        p1 = Vector128_.UnpackLow(t1.AsInt64(), p0.AsInt64()).AsByte();
+        p0 = Vector128_.UnpackHigh(t1.AsInt64(), p0.AsInt64()).AsByte();
+        q0 = Vector128_.UnpackLow(t2.AsInt64(), q1.AsInt64()).AsByte();
+        q1 = Vector128_.UnpackHigh(t2.AsInt64(), q1.AsInt64()).AsByte();
     }
 
     // Reads 8 rows across a vertical edge.
-    private static void Load8x4(ref byte bRef, nuint stride, out Vector128<byte> p, out Vector128<byte> q)
+    private static void Load8x4Vector128(ref byte bRef, nuint stride, out Vector128<byte> p, out Vector128<byte> q)
     {
         // A0 = 63 62 61 60 23 22 21 20 43 42 41 40 03 02 01 00
         // A1 = 73 72 71 70 33 32 31 30 53 52 51 50 13 12 11 10
@@ -2298,125 +2229,123 @@ internal static class LossyUtils
 
         // B0 = 53 43 52 42 51 41 50 40 13 03 12 02 11 01 10 00
         // B1 = 73 63 72 62 71 61 70 60 33 23 32 22 31 21 30 20
-        Vector128<sbyte> b0 = Sse2.UnpackLow(a0.AsSByte(), a1.AsSByte());
-        Vector128<sbyte> b1 = Sse2.UnpackHigh(a0.AsSByte(), a1.AsSByte());
+        Vector128<sbyte> b0 = Vector128_.UnpackLow(a0.AsSByte(), a1.AsSByte());
+        Vector128<sbyte> b1 = Vector128_.UnpackHigh(a0.AsSByte(), a1.AsSByte());
 
         // C0 = 33 23 13 03 32 22 12 02 31 21 11 01 30 20 10 00
         // C1 = 73 63 53 43 72 62 52 42 71 61 51 41 70 60 50 40
-        Vector128<short> c0 = Sse2.UnpackLow(b0.AsInt16(), b1.AsInt16());
-        Vector128<short> c1 = Sse2.UnpackHigh(b0.AsInt16(), b1.AsInt16());
+        Vector128<short> c0 = Vector128_.UnpackLow(b0.AsInt16(), b1.AsInt16());
+        Vector128<short> c1 = Vector128_.UnpackHigh(b0.AsInt16(), b1.AsInt16());
 
         // *p = 71 61 51 41 31 21 11 01 70 60 50 40 30 20 10 00
         // *q = 73 63 53 43 33 23 13 03 72 62 52 42 32 22 12 02
-        p = Sse2.UnpackLow(c0.AsInt32(), c1.AsInt32()).AsByte();
-        q = Sse2.UnpackHigh(c0.AsInt32(), c1.AsInt32()).AsByte();
+        p = Vector128_.UnpackLow(c0.AsInt32(), c1.AsInt32()).AsByte();
+        q = Vector128_.UnpackHigh(c0.AsInt32(), c1.AsInt32()).AsByte();
     }
 
     // Transpose back and store
-    private static void Store16x4(Vector128<byte> p1, Vector128<byte> p0, Vector128<byte> q0, Vector128<byte> q1, ref byte r0Ref, ref byte r8Ref, int stride)
+    private static void Store16x4Vector128(Vector128<byte> p1, Vector128<byte> p0, Vector128<byte> q0, Vector128<byte> q1, ref byte r0Ref, ref byte r8Ref, int stride)
     {
         // p0 = 71 70 61 60 51 50 41 40 31 30 21 20 11 10 01 00
         // p1 = f1 f0 e1 e0 d1 d0 c1 c0 b1 b0 a1 a0 91 90 81 80
-        Vector128<byte> p0s = Sse2.UnpackLow(p1, p0);
-        Vector128<byte> p1s = Sse2.UnpackHigh(p1, p0);
+        Vector128<byte> p0s = Vector128_.UnpackLow(p1, p0);
+        Vector128<byte> p1s = Vector128_.UnpackHigh(p1, p0);
 
         // q0 = 73 72 63 62 53 52 43 42 33 32 23 22 13 12 03 02
         // q1 = f3 f2 e3 e2 d3 d2 c3 c2 b3 b2 a3 a2 93 92 83 82
-        Vector128<byte> q0s = Sse2.UnpackLow(q0, q1);
-        Vector128<byte> q1s = Sse2.UnpackHigh(q0, q1);
+        Vector128<byte> q0s = Vector128_.UnpackLow(q0, q1);
+        Vector128<byte> q1s = Vector128_.UnpackHigh(q0, q1);
 
         // p0 = 33 32 31 30 23 22 21 20 13 12 11 10 03 02 01 00
         // q0 = 73 72 71 70 63 62 61 60 53 52 51 50 43 42 41 40
         Vector128<byte> t1 = p0s;
-        p0s = Sse2.UnpackLow(t1.AsInt16(), q0s.AsInt16()).AsByte();
-        q0s = Sse2.UnpackHigh(t1.AsInt16(), q0s.AsInt16()).AsByte();
+        p0s = Vector128_.UnpackLow(t1.AsInt16(), q0s.AsInt16()).AsByte();
+        q0s = Vector128_.UnpackHigh(t1.AsInt16(), q0s.AsInt16()).AsByte();
 
         // p1 = b3 b2 b1 b0 a3 a2 a1 a0 93 92 91 90 83 82 81 80
         // q1 = f3 f2 f1 f0 e3 e2 e1 e0 d3 d2 d1 d0 c3 c2 c1 c0
         t1 = p1s;
-        p1s = Sse2.UnpackLow(t1.AsInt16(), q1s.AsInt16()).AsByte();
-        q1s = Sse2.UnpackHigh(t1.AsInt16(), q1s.AsInt16()).AsByte();
+        p1s = Vector128_.UnpackLow(t1.AsInt16(), q1s.AsInt16()).AsByte();
+        q1s = Vector128_.UnpackHigh(t1.AsInt16(), q1s.AsInt16()).AsByte();
 
-        Store4x4(p0s, ref r0Ref, stride);
-        Store4x4(q0s, ref Unsafe.Add(ref r0Ref, 4 * (uint)stride), stride);
+        Store4x4Vector128(p0s, ref r0Ref, stride);
+        Store4x4Vector128(q0s, ref Unsafe.Add(ref r0Ref, 4 * (uint)stride), stride);
 
-        Store4x4(p1s, ref r8Ref, stride);
-        Store4x4(q1s, ref Unsafe.Add(ref r8Ref, 4 * (uint)stride), stride);
+        Store4x4Vector128(p1s, ref r8Ref, stride);
+        Store4x4Vector128(q1s, ref Unsafe.Add(ref r8Ref, 4 * (uint)stride), stride);
     }
 
-    private static void Store4x4(Vector128<byte> x, ref byte dstRef, int stride)
+    private static void Store4x4Vector128(Vector128<byte> x, ref byte dstRef, int stride)
     {
         int offset = 0;
         for (int i = 0; i < 4; i++)
         {
-            Unsafe.As<byte, int>(ref Unsafe.Add(ref dstRef, (uint)offset)) = Sse2.ConvertToInt32(x.AsInt32());
-            x = Sse2.ShiftRightLogical128BitLane(x, 4);
+            Unsafe.As<byte, int>(ref Unsafe.Add(ref dstRef, (uint)offset)) = x.AsInt32().ToScalar();
+            x = Vector128_.ShiftRightBytesInVector(x, 4);
             offset += stride;
         }
     }
 
     [MethodImpl(InliningOptions.ShortMethod)]
-    private static Vector128<sbyte> GetBaseDelta(Vector128<sbyte> p1, Vector128<sbyte> p0, Vector128<sbyte> q0, Vector128<sbyte> q1)
+    private static Vector128<sbyte> GetBaseDeltaVector128(Vector128<sbyte> p1, Vector128<sbyte> p0, Vector128<sbyte> q0, Vector128<sbyte> q1)
     {
         // Beware of addition order, for saturation!
-        Vector128<sbyte> p1q1 = Sse2.SubtractSaturate(p1, q1); // p1 - q1
-        Vector128<sbyte> q0p0 = Sse2.SubtractSaturate(q0, p0); // q0 - p0
-        Vector128<sbyte> s1 = Sse2.AddSaturate(p1q1, q0p0); // p1 - q1 + 1 * (q0 - p0)
-        Vector128<sbyte> s2 = Sse2.AddSaturate(q0p0, s1); // p1 - q1 + 2 * (q0 - p0)
-        Vector128<sbyte> s3 = Sse2.AddSaturate(q0p0, s2); // p1 - q1 + 3 * (q0 - p0)
-
-        return s3;
+        Vector128<sbyte> p1q1 = Vector128_.SubtractSaturate(p1, q1); // p1 - q1
+        Vector128<sbyte> q0p0 = Vector128_.SubtractSaturate(q0, p0); // q0 - p0
+        Vector128<sbyte> s1 = Vector128_.AddSaturate(p1q1, q0p0); // p1 - q1 + 1 * (q0 - p0)
+        Vector128<sbyte> s2 = Vector128_.AddSaturate(q0p0, s1); // p1 - q1 + 2 * (q0 - p0)
+        return Vector128_.AddSaturate(q0p0, s2); // p1 - q1 + 3 * (q0 - p0)
     }
 
     // Shift each byte of "x" by 3 bits while preserving by the sign bit.
     [MethodImpl(InliningOptions.ShortMethod)]
-    private static Vector128<sbyte> SignedShift8b(Vector128<byte> x)
+    private static Vector128<sbyte> SignedShift8bVector128(Vector128<byte> x)
     {
-        Vector128<byte> low0 = Sse2.UnpackLow(Vector128<byte>.Zero, x);
-        Vector128<byte> high0 = Sse2.UnpackHigh(Vector128<byte>.Zero, x);
-        Vector128<short> low1 = Sse2.ShiftRightArithmetic(low0.AsInt16(), 3 + 8);
-        Vector128<short> high1 = Sse2.ShiftRightArithmetic(high0.AsInt16(), 3 + 8);
+        Vector128<byte> low0 = Vector128_.UnpackLow(Vector128<byte>.Zero, x);
+        Vector128<byte> high0 = Vector128_.UnpackHigh(Vector128<byte>.Zero, x);
+        Vector128<short> low1 = Vector128.ShiftRightArithmetic(low0.AsInt16(), 3 + 8);
+        Vector128<short> high1 = Vector128.ShiftRightArithmetic(high0.AsInt16(), 3 + 8);
 
-        return Sse2.PackSignedSaturate(low1, high1);
+        return Vector128_.PackSignedSaturate(low1, high1);
     }
 
     [MethodImpl(InliningOptions.ShortMethod)]
-    private static void ComplexMask(Vector128<byte> p1, Vector128<byte> p0, Vector128<byte> q0, Vector128<byte> q1, int thresh, int ithresh, ref Vector128<byte> mask)
+    private static void ComplexMaskVector128(Vector128<byte> p1, Vector128<byte> p0, Vector128<byte> q0, Vector128<byte> q1, int thresh, int ithresh, ref Vector128<byte> mask)
     {
-        var it = Vector128.Create((byte)ithresh);
-        Vector128<byte> diff = Sse2.SubtractSaturate(mask, it);
-        Vector128<byte> threshMask = Sse2.CompareEqual(diff, Vector128<byte>.Zero);
-        Vector128<byte> filterMask = NeedsFilter(p1, p0, q0, q1, thresh);
+        Vector128<byte> it = Vector128.Create((byte)ithresh);
+        Vector128<byte> diff = Vector128_.SubtractSaturate(mask, it);
+        Vector128<byte> threshMask = Vector128.Equals(diff, Vector128<byte>.Zero);
+        Vector128<byte> filterMask = NeedsFilterVector128(p1, p0, q0, q1, thresh);
 
-        mask = Sse2.And(threshMask, filterMask);
+        mask = threshMask & filterMask;
     }
 
     // Updates values of 2 pixels at MB edge during complex filtering.
     // Update operations:
     // q = q - delta and p = p + delta; where delta = [(a_hi >> 7), (a_lo >> 7)]
     // Pixels 'pi' and 'qi' are int8_t on input, uint8_t on output (sign flip).
-    private static void Update2Pixels(ref Vector128<byte> pi, ref Vector128<byte> qi, Vector128<short> a0Low, Vector128<short> a0High)
+    private static void Update2PixelsVector128(ref Vector128<byte> pi, ref Vector128<byte> qi, Vector128<short> a0Low, Vector128<short> a0High)
     {
-        var signBit = Vector128.Create((byte)0x80);
-        Vector128<short> a1Low = Sse2.ShiftRightArithmetic(a0Low, 7);
-        Vector128<short> a1High = Sse2.ShiftRightArithmetic(a0High, 7);
-        Vector128<sbyte> delta = Sse2.PackSignedSaturate(a1Low, a1High);
-        pi = Sse2.AddSaturate(pi.AsSByte(), delta).AsByte();
-        qi = Sse2.SubtractSaturate(qi.AsSByte(), delta).AsByte();
-        pi = Sse2.Xor(pi, signBit.AsByte());
-        qi = Sse2.Xor(qi, signBit.AsByte());
+        Vector128<byte> signBit = Vector128.Create((byte)0x80);
+        Vector128<short> a1Low = Vector128.ShiftRightArithmetic(a0Low, 7);
+        Vector128<short> a1High = Vector128.ShiftRightArithmetic(a0High, 7);
+        Vector128<sbyte> delta = Vector128_.PackSignedSaturate(a1Low, a1High);
+        pi = Vector128_.AddSaturate(pi.AsSByte(), delta).AsByte();
+        qi = Vector128_.SubtractSaturate(qi.AsSByte(), delta).AsByte();
+        pi ^= signBit.AsByte();
+        qi ^= signBit.AsByte();
     }
 
     [MethodImpl(InliningOptions.ShortMethod)]
-    private static Vector128<byte> LoadUvEdge(ref byte uRef, ref byte vRef, int offset)
+    private static Vector128<byte> LoadUvEdgeVector128(ref byte uRef, ref byte vRef, int offset)
     {
-        var uVec = Vector128.Create(Unsafe.As<byte, long>(ref Unsafe.Add(ref uRef, (uint)offset)), 0);
-        var vVec = Vector128.Create(Unsafe.As<byte, long>(ref Unsafe.Add(ref vRef, (uint)offset)), 0);
-        return Sse2.UnpackLow(uVec, vVec).AsByte();
+        Vector128<long> uVec = Vector128.Create(Unsafe.As<byte, long>(ref Unsafe.Add(ref uRef, (uint)offset)), 0);
+        Vector128<long> vVec = Vector128.Create(Unsafe.As<byte, long>(ref Unsafe.Add(ref vRef, (uint)offset)), 0);
+        return Vector128_.UnpackLow(uVec, vVec).AsByte();
     }
 
     [MethodImpl(InliningOptions.ShortMethod)]
-    private static void StoreUv(Vector128<byte> x, ref byte uRef, ref byte vRef, int offset)
+    private static void StoreUvVector128(Vector128<byte> x, ref byte uRef, ref byte vRef, int offset)
     {
         Unsafe.As<byte, Vector64<byte>>(ref Unsafe.Add(ref uRef, (uint)offset)) = x.GetLower();
         Unsafe.As<byte, Vector64<byte>>(ref Unsafe.Add(ref vRef, (uint)offset)) = x.GetUpper();
@@ -2424,8 +2353,8 @@ internal static class LossyUtils
 
     // Compute abs(p - q) = subs(p - q) OR subs(q - p)
     [MethodImpl(InliningOptions.ShortMethod)]
-    private static Vector128<byte> Abs(Vector128<byte> p, Vector128<byte> q)
-        => Sse2.Or(Sse2.SubtractSaturate(q, p), Sse2.SubtractSaturate(p, q));
+    private static Vector128<byte> AbsVector128(Vector128<byte> p, Vector128<byte> q)
+        => Vector128_.SubtractSaturate(q, p) | Vector128_.SubtractSaturate(p, q);
 
     [MethodImpl(InliningOptions.ShortMethod)]
     private static bool Hev(Span<byte> p, int offset, int step, int thresh)
@@ -2474,5 +2403,5 @@ internal static class LossyUtils
     private static void Memset(Span<byte> dst, byte value, int startIdx, int count) => dst.Slice(startIdx, count).Fill(value);
 
     [MethodImpl(InliningOptions.ShortMethod)]
-    private static int Clamp255(int x) => x < 0 ? 0 : x > 255 ? 255 : x;
+    private static int Clamp255(int x) => Numerics.Clamp(x, 0, 255);
 }
diff --git a/src/ImageSharp/Formats/Webp/Lossy/QuantEnc.cs b/src/ImageSharp/Formats/Webp/Lossy/QuantEnc.cs
index e9eb1110b0..ab83e1641c 100644
--- a/src/ImageSharp/Formats/Webp/Lossy/QuantEnc.cs
+++ b/src/ImageSharp/Formats/Webp/Lossy/QuantEnc.cs
@@ -14,7 +14,7 @@ namespace SixLabors.ImageSharp.Formats.Webp.Lossy;
 /// </summary>
 internal static unsafe class QuantEnc
 {
-    private static readonly ushort[] WeightY = { 38, 32, 20, 9, 32, 28, 17, 7, 20, 17, 10, 4, 9, 7, 4, 2 };
+    private static readonly ushort[] WeightY = [38, 32, 20, 9, 32, 28, 17, 7, 20, 17, 10, 4, 9, 7, 4, 2];
 
     private const int MaxLevel = 2047;
 
@@ -26,7 +26,7 @@ internal static unsafe class QuantEnc
     private const int DSCALE = 1;   // storage descaling, needed to make the error fit byte
 
     // This uses C#'s optimization to refer to the static data segment of the assembly, no allocation occurs.
-    private static ReadOnlySpan<byte> Zigzag => new byte[] { 0, 1, 4, 8, 5, 2, 3, 6, 9, 12, 13, 10, 7, 11, 14, 15 };
+    private static ReadOnlySpan<byte> Zigzag => [0, 1, 4, 8, 5, 2, 3, 6, 9, 12, 13, 10, 7, 11, 14, 15];
 
     public static void PickBestIntra16(Vp8EncIterator it, ref Vp8ModeScore rd, Vp8SegmentInfo[] segmentInfos, Vp8EncProba proba)
     {
@@ -36,8 +36,8 @@ internal static unsafe class QuantEnc
         int tlambda = dqm.TLambda;
         Span<byte> src = it.YuvIn.AsSpan(Vp8EncIterator.YOffEnc);
         Span<int> scratch = it.Scratch3;
-        var rdTmp = new Vp8ModeScore();
-        var res = new Vp8Residual();
+        Vp8ModeScore rdTmp = new();
+        Vp8Residual res = new();
         Vp8ModeScore rdCur = rdTmp;
         Vp8ModeScore rdBest = rd;
         int mode;
@@ -107,7 +107,7 @@ internal static unsafe class QuantEnc
         Span<byte> bestBlocks = it.YuvOut2.AsSpan(Vp8EncIterator.YOffEnc);
         Span<int> scratch = it.Scratch3;
         int totalHeaderBits = 0;
-        var rdBest = new Vp8ModeScore();
+        Vp8ModeScore rdBest = new();
 
         if (maxI4HeaderBits == 0)
         {
@@ -118,9 +118,9 @@ internal static unsafe class QuantEnc
         rdBest.H = 211;  // '211' is the value of VP8BitCost(0, 145)
         rdBest.SetRdScore(dqm.LambdaMode);
         it.StartI4();
-        var rdi4 = new Vp8ModeScore();
-        var rdTmp = new Vp8ModeScore();
-        var res = new Vp8Residual();
+        Vp8ModeScore rdi4 = new();
+        Vp8ModeScore rdTmp = new();
+        Vp8Residual res = new();
         Span<short> tmpLevels = stackalloc short[16];
         do
         {
@@ -220,9 +220,9 @@ internal static unsafe class QuantEnc
         Span<byte> tmpDst = it.YuvOut2.AsSpan(Vp8EncIterator.UOffEnc);
         Span<byte> dst0 = it.YuvOut.AsSpan(Vp8EncIterator.UOffEnc);
         Span<byte> dst = dst0;
-        var rdBest = new Vp8ModeScore();
-        var rdUv = new Vp8ModeScore();
-        var res = new Vp8Residual();
+        Vp8ModeScore rdBest = new();
+        Vp8ModeScore rdUv = new();
+        Vp8Residual res = new();
         int mode;
 
         rd.ModeUv = -1;
@@ -628,7 +628,7 @@ internal static unsafe class QuantEnc
             Vector128<short> out8 = Sse2.PackSignedSaturate(out08.AsInt32(), out12.AsInt32());
 
             // if (coeff > 2047) coeff = 2047
-            var maxCoeff2047 = Vector128.Create((short)MaxLevel);
+            Vector128<short> maxCoeff2047 = Vector128.Create((short)MaxLevel);
             out0 = Sse2.Min(out0, maxCoeff2047);
             out8 = Sse2.Min(out8, maxCoeff2047);
 
diff --git a/src/ImageSharp/Formats/Webp/Lossy/Vp8Decoder.cs b/src/ImageSharp/Formats/Webp/Lossy/Vp8Decoder.cs
index b3c5bfaf41..3c8bafa1b2 100644
--- a/src/ImageSharp/Formats/Webp/Lossy/Vp8Decoder.cs
+++ b/src/ImageSharp/Formats/Webp/Lossy/Vp8Decoder.cs
@@ -67,14 +67,14 @@ internal class Vp8Decoder : IDisposable
         int extraY = extraRows * this.CacheYStride;
         int extraUv = extraRows / 2 * this.CacheUvStride;
         this.YuvBuffer = memoryAllocator.Allocate<byte>((WebpConstants.Bps * 17) + (WebpConstants.Bps * 9) + extraY);
-        this.CacheY = memoryAllocator.Allocate<byte>((16 * this.CacheYStride) + extraY);
+        this.CacheY = memoryAllocator.Allocate<byte>((16 * this.CacheYStride) + extraY, AllocationOptions.Clean);
         int cacheUvSize = (16 * this.CacheUvStride) + extraUv;
         this.CacheU = memoryAllocator.Allocate<byte>(cacheUvSize);
         this.CacheV = memoryAllocator.Allocate<byte>(cacheUvSize);
         this.TmpYBuffer = memoryAllocator.Allocate<byte>((int)width);
         this.TmpUBuffer = memoryAllocator.Allocate<byte>((int)width);
         this.TmpVBuffer = memoryAllocator.Allocate<byte>((int)width);
-        this.Pixels = memoryAllocator.Allocate<byte>((int)(width * height * 4));
+        this.Pixels = memoryAllocator.Allocate<byte>((int)(width * height * 4), AllocationOptions.Clean);
 
 #if DEBUG
         // Filling those buffers with 205, is only useful for debugging,
diff --git a/src/ImageSharp/Formats/Webp/Lossy/Vp8EncIterator.cs b/src/ImageSharp/Formats/Webp/Lossy/Vp8EncIterator.cs
index 52c7e9703b..fa68144fbc 100644
--- a/src/ImageSharp/Formats/Webp/Lossy/Vp8EncIterator.cs
+++ b/src/ImageSharp/Formats/Webp/Lossy/Vp8EncIterator.cs
@@ -36,12 +36,12 @@ internal class Vp8EncIterator
     /// Array to record the position of the top sample to pass to the prediction functions.
     /// </summary>
     private readonly byte[] vp8TopLeftI4 =
-    {
+    [
         17, 21, 25, 29,
         13, 17, 21, 25,
         9,  13, 17, 21,
         5,   9, 13, 17
-    };
+    ];
 
     private int currentMbIdx;
 
@@ -396,7 +396,7 @@ internal class Vp8EncIterator
         this.MakeLuma16Preds();
         for (mode = 0; mode < maxMode; mode++)
         {
-            Vp8Histogram histo = new Vp8Histogram();
+            Vp8Histogram histo = new();
             histo.CollectHistogram(this.YuvIn.AsSpan(YOffEnc), this.YuvP.AsSpan(Vp8Encoding.Vp8I16ModeOffsets[mode]), 0, 16);
             int alpha = histo.GetAlpha();
             if (alpha > bestAlpha)
@@ -414,7 +414,7 @@ internal class Vp8EncIterator
     {
         Span<byte> modes = stackalloc byte[16];
         const int maxMode = MaxIntra4Mode;
-        Vp8Histogram totalHisto = new Vp8Histogram();
+        Vp8Histogram totalHisto = new();
         int curHisto = 0;
         this.StartI4();
         do
@@ -467,7 +467,7 @@ internal class Vp8EncIterator
         this.MakeChroma8Preds();
         for (mode = 0; mode < maxMode; ++mode)
         {
-            Vp8Histogram histo = new Vp8Histogram();
+            Vp8Histogram histo = new();
             histo.CollectHistogram(this.YuvIn.AsSpan(UOffEnc), this.YuvP.AsSpan(Vp8Encoding.Vp8UvModeOffsets[mode]), 16, 16 + 4 + 4);
             int alpha = histo.GetAlpha();
             if (alpha > bestAlpha)
diff --git a/src/ImageSharp/Formats/Webp/Lossy/Vp8Encoder.cs b/src/ImageSharp/Formats/Webp/Lossy/Vp8Encoder.cs
index e4ebe14731..85739a3e20 100644
--- a/src/ImageSharp/Formats/Webp/Lossy/Vp8Encoder.cs
+++ b/src/ImageSharp/Formats/Webp/Lossy/Vp8Encoder.cs
@@ -196,7 +196,7 @@ internal class Vp8Encoder : IDisposable
     }
 
     // This uses C#'s optimization to refer to the static data segment of the assembly, no allocation occurs.
-    private static ReadOnlySpan<byte> AverageBytesPerMb => new byte[] { 50, 24, 16, 9, 7, 5, 3, 2 };
+    private static ReadOnlySpan<byte> AverageBytesPerMb => [50, 24, 16, 9, 7, 5, 3, 2];
 
     public int BaseQuant { get; set; }
 
diff --git a/src/ImageSharp/Formats/Webp/Lossy/Vp8Encoding.cs b/src/ImageSharp/Formats/Webp/Lossy/Vp8Encoding.cs
index c645816d4b..9085c09293 100644
--- a/src/ImageSharp/Formats/Webp/Lossy/Vp8Encoding.cs
+++ b/src/ImageSharp/Formats/Webp/Lossy/Vp8Encoding.cs
@@ -2,10 +2,11 @@
 // Licensed under the Six Labors Split License.
 
 using System.Buffers.Binary;
+using System.Numerics;
 using System.Runtime.CompilerServices;
 using System.Runtime.InteropServices;
 using System.Runtime.Intrinsics;
-using System.Runtime.Intrinsics.X86;
+using SixLabors.ImageSharp.Common.Helpers;
 
 namespace SixLabors.ImageSharp.Formats.Webp.Lossy;
 
@@ -36,9 +37,9 @@ internal static unsafe class Vp8Encoding
 
     private const int C8HE8 = C8VE8 + (1 * 16);
 
-    public static readonly int[] Vp8I16ModeOffsets = { I16DC16, I16TM16, I16VE16, I16HE16 };
+    public static readonly int[] Vp8I16ModeOffsets = [I16DC16, I16TM16, I16VE16, I16HE16];
 
-    public static readonly int[] Vp8UvModeOffsets = { C8DC8, C8TM8, C8VE8, C8HE8 };
+    public static readonly int[] Vp8UvModeOffsets = [C8DC8, C8TM8, C8VE8, C8HE8];
 
     private const int I4DC4 = (3 * 16 * WebpConstants.Bps) + 0;
 
@@ -60,7 +61,8 @@ internal static unsafe class Vp8Encoding
 
     private const int I4HU4 = I4HD4 + 4;
 
-    public static readonly int[] Vp8I4ModeOffsets = { I4DC4, I4TM4, I4VE4, I4HE4, I4RD4, I4VR4, I4LD4, I4VL4, I4HD4, I4HU4 };
+    public static readonly int[] Vp8I4ModeOffsets = [I4DC4, I4TM4, I4VE4, I4HE4, I4RD4, I4VR4, I4LD4, I4VL4, I4HD4, I4HU4
+    ];
 
     private static byte[] GetClip1()
     {
@@ -78,7 +80,7 @@ internal static unsafe class Vp8Encoding
     // Does two inverse transforms.
     public static void ITransformTwo(Span<byte> reference, Span<short> input, Span<byte> dst, Span<int> scratch)
     {
-        if (Sse2.IsSupported)
+        if (Vector128.IsHardwareAccelerated)
         {
             // This implementation makes use of 16-bit fixed point versions of two
             // multiply constants:
@@ -116,10 +118,10 @@ internal static unsafe class Vp8Encoding
             Vector128<long> inb2 = Vector128.Create(Unsafe.As<short, long>(ref Unsafe.Add(ref inputRef, 24)), 0);
             Vector128<long> inb3 = Vector128.Create(Unsafe.As<short, long>(ref Unsafe.Add(ref inputRef, 28)), 0);
 
-            in0 = Sse2.UnpackLow(in0, inb0);
-            in1 = Sse2.UnpackLow(in1, inb1);
-            in2 = Sse2.UnpackLow(in2, inb2);
-            in3 = Sse2.UnpackLow(in3, inb3);
+            in0 = Vector128_.UnpackLow(in0, inb0);
+            in1 = Vector128_.UnpackLow(in1, inb1);
+            in2 = Vector128_.UnpackLow(in2, inb2);
+            in3 = Vector128_.UnpackLow(in3, inb3);
 
             // a00 a10 a20 a30   b00 b10 b20 b30
             // a01 a11 a21 a31   b01 b11 b21 b31
@@ -128,49 +130,45 @@ internal static unsafe class Vp8Encoding
 
             // Vertical pass and subsequent transpose.
             // First pass, c and d calculations are longer because of the "trick" multiplications.
-            InverseTransformVerticalPass(in0, in2, in1, in3, out Vector128<short> tmp0, out Vector128<short> tmp1, out Vector128<short> tmp2, out Vector128<short> tmp3);
+            InverseTransformVerticalPassVector128(in0, in2, in1, in3, out Vector128<short> tmp0, out Vector128<short> tmp1, out Vector128<short> tmp2, out Vector128<short> tmp3);
 
             // Transpose the two 4x4.
-            LossyUtils.Vp8Transpose_2_4x4_16b(tmp0, tmp1, tmp2, tmp3, out Vector128<long> t0, out Vector128<long> t1, out Vector128<long> t2, out Vector128<long> t3);
+            LossyUtils.Vp8Transpose_2_4x4_16bVector128(tmp0, tmp1, tmp2, tmp3, out Vector128<long> t0, out Vector128<long> t1, out Vector128<long> t2, out Vector128<long> t3);
 
             // Horizontal pass and subsequent transpose.
             // First pass, c and d calculations are longer because of the "trick" multiplications.
-            InverseTransformHorizontalPass(t0, t2, t1, t3, out Vector128<short> shifted0, out Vector128<short> shifted1, out Vector128<short> shifted2, out Vector128<short> shifted3);
+            InverseTransformHorizontalPassVector128(t0, t2, t1, t3, out Vector128<short> shifted0, out Vector128<short> shifted1, out Vector128<short> shifted2, out Vector128<short> shifted3);
 
             // Transpose the two 4x4.
-            LossyUtils.Vp8Transpose_2_4x4_16b(shifted0, shifted1, shifted2, shifted3, out t0, out t1, out t2, out t3);
+            LossyUtils.Vp8Transpose_2_4x4_16bVector128(shifted0, shifted1, shifted2, shifted3, out t0, out t1, out t2, out t3);
 
             // Add inverse transform to 'ref' and store.
             // Load the reference(s).
-            Vector128<byte> ref0 = Vector128<byte>.Zero;
-            Vector128<byte> ref1 = Vector128<byte>.Zero;
-            Vector128<byte> ref2 = Vector128<byte>.Zero;
-            Vector128<byte> ref3 = Vector128<byte>.Zero;
             ref byte referenceRef = ref MemoryMarshal.GetReference(reference);
 
             // Load eight bytes/pixels per line.
-            ref0 = Vector128.Create(Unsafe.As<byte, long>(ref referenceRef), 0).AsByte();
-            ref1 = Vector128.Create(Unsafe.As<byte, long>(ref Unsafe.Add(ref referenceRef, WebpConstants.Bps)), 0).AsByte();
-            ref2 = Vector128.Create(Unsafe.As<byte, long>(ref Unsafe.Add(ref referenceRef, WebpConstants.Bps * 2)), 0).AsByte();
-            ref3 = Vector128.Create(Unsafe.As<byte, long>(ref Unsafe.Add(ref referenceRef, WebpConstants.Bps * 3)), 0).AsByte();
+            Vector128<byte> ref0 = Vector128.Create(Unsafe.As<byte, long>(ref referenceRef), 0).AsByte();
+            Vector128<byte> ref1 = Vector128.Create(Unsafe.As<byte, long>(ref Unsafe.Add(ref referenceRef, WebpConstants.Bps)), 0).AsByte();
+            Vector128<byte> ref2 = Vector128.Create(Unsafe.As<byte, long>(ref Unsafe.Add(ref referenceRef, WebpConstants.Bps * 2)), 0).AsByte();
+            Vector128<byte> ref3 = Vector128.Create(Unsafe.As<byte, long>(ref Unsafe.Add(ref referenceRef, WebpConstants.Bps * 3)), 0).AsByte();
 
             // Convert to 16b.
-            ref0 = Sse2.UnpackLow(ref0, Vector128<byte>.Zero);
-            ref1 = Sse2.UnpackLow(ref1, Vector128<byte>.Zero);
-            ref2 = Sse2.UnpackLow(ref2, Vector128<byte>.Zero);
-            ref3 = Sse2.UnpackLow(ref3, Vector128<byte>.Zero);
+            ref0 = Vector128_.UnpackLow(ref0, Vector128<byte>.Zero);
+            ref1 = Vector128_.UnpackLow(ref1, Vector128<byte>.Zero);
+            ref2 = Vector128_.UnpackLow(ref2, Vector128<byte>.Zero);
+            ref3 = Vector128_.UnpackLow(ref3, Vector128<byte>.Zero);
 
             // Add the inverse transform(s).
-            Vector128<short> ref0InvAdded = Sse2.Add(ref0.AsInt16(), t0.AsInt16());
-            Vector128<short> ref1InvAdded = Sse2.Add(ref1.AsInt16(), t1.AsInt16());
-            Vector128<short> ref2InvAdded = Sse2.Add(ref2.AsInt16(), t2.AsInt16());
-            Vector128<short> ref3InvAdded = Sse2.Add(ref3.AsInt16(), t3.AsInt16());
+            Vector128<short> ref0InvAdded = ref0.AsInt16() + t0.AsInt16();
+            Vector128<short> ref1InvAdded = ref1.AsInt16() + t1.AsInt16();
+            Vector128<short> ref2InvAdded = ref2.AsInt16() + t2.AsInt16();
+            Vector128<short> ref3InvAdded = ref3.AsInt16() + t3.AsInt16();
 
             // Unsigned saturate to 8b.
-            ref0 = Sse2.PackUnsignedSaturate(ref0InvAdded, ref0InvAdded);
-            ref1 = Sse2.PackUnsignedSaturate(ref1InvAdded, ref1InvAdded);
-            ref2 = Sse2.PackUnsignedSaturate(ref2InvAdded, ref2InvAdded);
-            ref3 = Sse2.PackUnsignedSaturate(ref3InvAdded, ref3InvAdded);
+            ref0 = Vector128_.PackUnsignedSaturate(ref0InvAdded, ref0InvAdded);
+            ref1 = Vector128_.PackUnsignedSaturate(ref1InvAdded, ref1InvAdded);
+            ref2 = Vector128_.PackUnsignedSaturate(ref2InvAdded, ref2InvAdded);
+            ref3 = Vector128_.PackUnsignedSaturate(ref3InvAdded, ref3InvAdded);
 
             // Store eight bytes/pixels per line.
             ref byte outputRef = ref MemoryMarshal.GetReference(dst);
@@ -188,7 +186,7 @@ internal static unsafe class Vp8Encoding
 
     public static void ITransformOne(Span<byte> reference, Span<short> input, Span<byte> dst, Span<int> scratch)
     {
-        if (Sse2.IsSupported)
+        if (Vector128.IsHardwareAccelerated)
         {
             // Load and concatenate the transform coefficients (we'll do two inverse
             // transforms in parallel). In the case of only one inverse transform, the
@@ -207,63 +205,59 @@ internal static unsafe class Vp8Encoding
 
             // Vertical pass and subsequent transpose.
             // First pass, c and d calculations are longer because of the "trick" multiplications.
-            InverseTransformVerticalPass(in0, in2, in1, in3, out Vector128<short> tmp0, out Vector128<short> tmp1, out Vector128<short> tmp2, out Vector128<short> tmp3);
+            InverseTransformVerticalPassVector128(in0, in2, in1, in3, out Vector128<short> tmp0, out Vector128<short> tmp1, out Vector128<short> tmp2, out Vector128<short> tmp3);
 
             // Transpose the two 4x4.
-            LossyUtils.Vp8Transpose_2_4x4_16b(tmp0, tmp1, tmp2, tmp3, out Vector128<long> t0, out Vector128<long> t1, out Vector128<long> t2, out Vector128<long> t3);
+            LossyUtils.Vp8Transpose_2_4x4_16bVector128(tmp0, tmp1, tmp2, tmp3, out Vector128<long> t0, out Vector128<long> t1, out Vector128<long> t2, out Vector128<long> t3);
 
             // Horizontal pass and subsequent transpose.
             // First pass, c and d calculations are longer because of the "trick" multiplications.
-            InverseTransformHorizontalPass(t0, t2, t1, t3, out Vector128<short> shifted0, out Vector128<short> shifted1, out Vector128<short> shifted2, out Vector128<short> shifted3);
+            InverseTransformHorizontalPassVector128(t0, t2, t1, t3, out Vector128<short> shifted0, out Vector128<short> shifted1, out Vector128<short> shifted2, out Vector128<short> shifted3);
 
             // Transpose the two 4x4.
-            LossyUtils.Vp8Transpose_2_4x4_16b(shifted0, shifted1, shifted2, shifted3, out t0, out t1, out t2, out t3);
+            LossyUtils.Vp8Transpose_2_4x4_16bVector128(shifted0, shifted1, shifted2, shifted3, out t0, out t1, out t2, out t3);
 
             // Add inverse transform to 'ref' and store.
             // Load the reference(s).
-            Vector128<byte> ref0 = Vector128<byte>.Zero;
-            Vector128<byte> ref1 = Vector128<byte>.Zero;
-            Vector128<byte> ref2 = Vector128<byte>.Zero;
-            Vector128<byte> ref3 = Vector128<byte>.Zero;
             ref byte referenceRef = ref MemoryMarshal.GetReference(reference);
 
             // Load four bytes/pixels per line.
-            ref0 = Sse2.ConvertScalarToVector128Int32(Unsafe.As<byte, int>(ref referenceRef)).AsByte();
-            ref1 = Sse2.ConvertScalarToVector128Int32(Unsafe.As<byte, int>(ref Unsafe.Add(ref referenceRef, WebpConstants.Bps))).AsByte();
-            ref2 = Sse2.ConvertScalarToVector128Int32(Unsafe.As<byte, int>(ref Unsafe.Add(ref referenceRef, WebpConstants.Bps * 2))).AsByte();
-            ref3 = Sse2.ConvertScalarToVector128Int32(Unsafe.As<byte, int>(ref Unsafe.Add(ref referenceRef, WebpConstants.Bps * 3))).AsByte();
+            Vector128<byte> ref0 = Vector128.CreateScalar(Unsafe.ReadUnaligned<int>(ref referenceRef)).AsByte();
+            Vector128<byte> ref1 = Vector128.CreateScalar(Unsafe.ReadUnaligned<int>(ref Unsafe.Add(ref referenceRef, WebpConstants.Bps))).AsByte();
+            Vector128<byte> ref2 = Vector128.CreateScalar(Unsafe.ReadUnaligned<int>(ref Unsafe.Add(ref referenceRef, WebpConstants.Bps * 2))).AsByte();
+            Vector128<byte> ref3 = Vector128.CreateScalar(Unsafe.ReadUnaligned<int>(ref Unsafe.Add(ref referenceRef, WebpConstants.Bps * 3))).AsByte();
 
             // Convert to 16b.
-            ref0 = Sse2.UnpackLow(ref0, Vector128<byte>.Zero);
-            ref1 = Sse2.UnpackLow(ref1, Vector128<byte>.Zero);
-            ref2 = Sse2.UnpackLow(ref2, Vector128<byte>.Zero);
-            ref3 = Sse2.UnpackLow(ref3, Vector128<byte>.Zero);
+            ref0 = Vector128_.UnpackLow(ref0, Vector128<byte>.Zero);
+            ref1 = Vector128_.UnpackLow(ref1, Vector128<byte>.Zero);
+            ref2 = Vector128_.UnpackLow(ref2, Vector128<byte>.Zero);
+            ref3 = Vector128_.UnpackLow(ref3, Vector128<byte>.Zero);
 
             // Add the inverse transform(s).
-            Vector128<short> ref0InvAdded = Sse2.Add(ref0.AsInt16(), t0.AsInt16());
-            Vector128<short> ref1InvAdded = Sse2.Add(ref1.AsInt16(), t1.AsInt16());
-            Vector128<short> ref2InvAdded = Sse2.Add(ref2.AsInt16(), t2.AsInt16());
-            Vector128<short> ref3InvAdded = Sse2.Add(ref3.AsInt16(), t3.AsInt16());
+            Vector128<short> ref0InvAdded = ref0.AsInt16() + t0.AsInt16();
+            Vector128<short> ref1InvAdded = ref1.AsInt16() + t1.AsInt16();
+            Vector128<short> ref2InvAdded = ref2.AsInt16() + t2.AsInt16();
+            Vector128<short> ref3InvAdded = ref3.AsInt16() + t3.AsInt16();
 
             // Unsigned saturate to 8b.
-            ref0 = Sse2.PackUnsignedSaturate(ref0InvAdded, ref0InvAdded);
-            ref1 = Sse2.PackUnsignedSaturate(ref1InvAdded, ref1InvAdded);
-            ref2 = Sse2.PackUnsignedSaturate(ref2InvAdded, ref2InvAdded);
-            ref3 = Sse2.PackUnsignedSaturate(ref3InvAdded, ref3InvAdded);
+            ref0 = Vector128_.PackUnsignedSaturate(ref0InvAdded, ref0InvAdded);
+            ref1 = Vector128_.PackUnsignedSaturate(ref1InvAdded, ref1InvAdded);
+            ref2 = Vector128_.PackUnsignedSaturate(ref2InvAdded, ref2InvAdded);
+            ref3 = Vector128_.PackUnsignedSaturate(ref3InvAdded, ref3InvAdded);
 
             // Unsigned saturate to 8b.
             ref byte outputRef = ref MemoryMarshal.GetReference(dst);
 
             // Store four bytes/pixels per line.
-            int output0 = Sse2.ConvertToInt32(ref0.AsInt32());
-            int output1 = Sse2.ConvertToInt32(ref1.AsInt32());
-            int output2 = Sse2.ConvertToInt32(ref2.AsInt32());
-            int output3 = Sse2.ConvertToInt32(ref3.AsInt32());
-
-            Unsafe.As<byte, int>(ref outputRef) = output0;
-            Unsafe.As<byte, int>(ref Unsafe.Add(ref outputRef, WebpConstants.Bps)) = output1;
-            Unsafe.As<byte, int>(ref Unsafe.Add(ref outputRef, WebpConstants.Bps * 2)) = output2;
-            Unsafe.As<byte, int>(ref Unsafe.Add(ref outputRef, WebpConstants.Bps * 3)) = output3;
+            int output0 = ref0.AsInt32().ToScalar();
+            int output1 = ref1.AsInt32().ToScalar();
+            int output2 = ref2.AsInt32().ToScalar();
+            int output3 = ref3.AsInt32().ToScalar();
+
+            Unsafe.WriteUnaligned(ref outputRef, output0);
+            Unsafe.WriteUnaligned(ref Unsafe.Add(ref outputRef, WebpConstants.Bps), output1);
+            Unsafe.WriteUnaligned(ref Unsafe.Add(ref outputRef, WebpConstants.Bps * 2), output2);
+            Unsafe.WriteUnaligned(ref Unsafe.Add(ref outputRef, WebpConstants.Bps * 3), output3);
         }
         else
         {
@@ -302,72 +296,72 @@ internal static unsafe class Vp8Encoding
         }
     }
 
-    private static void InverseTransformVerticalPass(Vector128<long> in0, Vector128<long> in2, Vector128<long> in1, Vector128<long> in3, out Vector128<short> tmp0, out Vector128<short> tmp1, out Vector128<short> tmp2, out Vector128<short> tmp3)
+    private static void InverseTransformVerticalPassVector128(Vector128<long> in0, Vector128<long> in2, Vector128<long> in1, Vector128<long> in3, out Vector128<short> tmp0, out Vector128<short> tmp1, out Vector128<short> tmp2, out Vector128<short> tmp3)
     {
-        Vector128<short> a = Sse2.Add(in0.AsInt16(), in2.AsInt16());
-        Vector128<short> b = Sse2.Subtract(in0.AsInt16(), in2.AsInt16());
+        Vector128<short> a = in0.AsInt16() + in2.AsInt16();
+        Vector128<short> b = in0.AsInt16() - in2.AsInt16();
 
         Vector128<short> k1 = Vector128.Create((short)20091).AsInt16();
         Vector128<short> k2 = Vector128.Create((short)-30068).AsInt16();
 
         // c = MUL(in1, K2) - MUL(in3, K1) = MUL(in1, k2) - MUL(in3, k1) + in1 - in3
-        Vector128<short> c1 = Sse2.MultiplyHigh(in1.AsInt16(), k2);
-        Vector128<short> c2 = Sse2.MultiplyHigh(in3.AsInt16(), k1);
-        Vector128<short> c3 = Sse2.Subtract(in1.AsInt16(), in3.AsInt16());
-        Vector128<short> c4 = Sse2.Subtract(c1, c2);
-        Vector128<short> c = Sse2.Add(c3, c4);
+        Vector128<short> c1 = Vector128_.MultiplyHigh(in1.AsInt16(), k2);
+        Vector128<short> c2 = Vector128_.MultiplyHigh(in3.AsInt16(), k1);
+        Vector128<short> c3 = in1.AsInt16() - in3.AsInt16();
+        Vector128<short> c4 = c1 - c2;
+        Vector128<short> c = c3 + c4;
 
         // d = MUL(in1, K1) + MUL(in3, K2) = MUL(in1, k1) + MUL(in3, k2) + in1 + in3
-        Vector128<short> d1 = Sse2.MultiplyHigh(in1.AsInt16(), k1);
-        Vector128<short> d2 = Sse2.MultiplyHigh(in3.AsInt16(), k2);
-        Vector128<short> d3 = Sse2.Add(in1.AsInt16(), in3.AsInt16());
-        Vector128<short> d4 = Sse2.Add(d1, d2);
-        Vector128<short> d = Sse2.Add(d3, d4);
+        Vector128<short> d1 = Vector128_.MultiplyHigh(in1.AsInt16(), k1);
+        Vector128<short> d2 = Vector128_.MultiplyHigh(in3.AsInt16(), k2);
+        Vector128<short> d3 = in1.AsInt16() + in3.AsInt16();
+        Vector128<short> d4 = d1 + d2;
+        Vector128<short> d = d3 + d4;
 
         // Second pass.
-        tmp0 = Sse2.Add(a, d);
-        tmp1 = Sse2.Add(b, c);
-        tmp2 = Sse2.Subtract(b, c);
-        tmp3 = Sse2.Subtract(a, d);
+        tmp0 = a + d;
+        tmp1 = b + c;
+        tmp2 = b - c;
+        tmp3 = a - d;
     }
 
-    private static void InverseTransformHorizontalPass(Vector128<long> t0, Vector128<long> t2, Vector128<long> t1, Vector128<long> t3, out Vector128<short> shifted0, out Vector128<short> shifted1, out Vector128<short> shifted2, out Vector128<short> shifted3)
+    private static void InverseTransformHorizontalPassVector128(Vector128<long> t0, Vector128<long> t2, Vector128<long> t1, Vector128<long> t3, out Vector128<short> shifted0, out Vector128<short> shifted1, out Vector128<short> shifted2, out Vector128<short> shifted3)
     {
-        Vector128<short> dc = Sse2.Add(t0.AsInt16(), Vector128.Create((short)4));
-        Vector128<short> a = Sse2.Add(dc, t2.AsInt16());
-        Vector128<short> b = Sse2.Subtract(dc, t2.AsInt16());
+        Vector128<short> dc = t0.AsInt16() + Vector128.Create((short)4);
+        Vector128<short> a = dc + t2.AsInt16();
+        Vector128<short> b = dc - t2.AsInt16();
 
         Vector128<short> k1 = Vector128.Create((short)20091).AsInt16();
         Vector128<short> k2 = Vector128.Create((short)-30068).AsInt16();
 
         // c = MUL(T1, K2) - MUL(T3, K1) = MUL(T1, k2) - MUL(T3, k1) + T1 - T3
-        Vector128<short> c1 = Sse2.MultiplyHigh(t1.AsInt16(), k2);
-        Vector128<short> c2 = Sse2.MultiplyHigh(t3.AsInt16(), k1);
-        Vector128<short> c3 = Sse2.Subtract(t1.AsInt16(), t3.AsInt16());
-        Vector128<short> c4 = Sse2.Subtract(c1, c2);
-        Vector128<short> c = Sse2.Add(c3, c4);
+        Vector128<short> c1 = Vector128_.MultiplyHigh(t1.AsInt16(), k2);
+        Vector128<short> c2 = Vector128_.MultiplyHigh(t3.AsInt16(), k1);
+        Vector128<short> c3 = t1.AsInt16() - t3.AsInt16();
+        Vector128<short> c4 = c1 - c2;
+        Vector128<short> c = c3 + c4;
 
         // d = MUL(T1, K1) + MUL(T3, K2) = MUL(T1, k1) + MUL(T3, k2) + T1 + T3
-        Vector128<short> d1 = Sse2.MultiplyHigh(t1.AsInt16(), k1);
-        Vector128<short> d2 = Sse2.MultiplyHigh(t3.AsInt16(), k2);
-        Vector128<short> d3 = Sse2.Add(t1.AsInt16(), t3.AsInt16());
-        Vector128<short> d4 = Sse2.Add(d1, d2);
-        Vector128<short> d = Sse2.Add(d3, d4);
+        Vector128<short> d1 = Vector128_.MultiplyHigh(t1.AsInt16(), k1);
+        Vector128<short> d2 = Vector128_.MultiplyHigh(t3.AsInt16(), k2);
+        Vector128<short> d3 = t1.AsInt16() + t3.AsInt16();
+        Vector128<short> d4 = d1 + d2;
+        Vector128<short> d = d3 + d4;
 
         // Second pass.
-        Vector128<short> tmp0 = Sse2.Add(a, d);
-        Vector128<short> tmp1 = Sse2.Add(b, c);
-        Vector128<short> tmp2 = Sse2.Subtract(b, c);
-        Vector128<short> tmp3 = Sse2.Subtract(a, d);
-        shifted0 = Sse2.ShiftRightArithmetic(tmp0, 3);
-        shifted1 = Sse2.ShiftRightArithmetic(tmp1, 3);
-        shifted2 = Sse2.ShiftRightArithmetic(tmp2, 3);
-        shifted3 = Sse2.ShiftRightArithmetic(tmp3, 3);
+        Vector128<short> tmp0 = a + d;
+        Vector128<short> tmp1 = b + c;
+        Vector128<short> tmp2 = b - c;
+        Vector128<short> tmp3 = a - d;
+        shifted0 = Vector128.ShiftRightArithmetic(tmp0, 3);
+        shifted1 = Vector128.ShiftRightArithmetic(tmp1, 3);
+        shifted2 = Vector128.ShiftRightArithmetic(tmp2, 3);
+        shifted3 = Vector128.ShiftRightArithmetic(tmp3, 3);
     }
 
     public static void FTransform2(Span<byte> src, Span<byte> reference, Span<short> output, Span<short> output2, Span<int> scratch)
     {
-        if (Sse2.IsSupported)
+        if (Vector128.IsHardwareAccelerated)
         {
             ref byte srcRef = ref MemoryMarshal.GetReference(src);
             ref byte referenceRef = ref MemoryMarshal.GetReference(reference);
@@ -385,38 +379,38 @@ internal static unsafe class Vp8Encoding
             Vector128<long> ref3 = Vector128.Create(Unsafe.As<byte, long>(ref Unsafe.Add(ref referenceRef, WebpConstants.Bps * 3)), 0);
 
             // Convert both to 16 bit.
-            Vector128<byte> srcLow0 = Sse2.UnpackLow(src0.AsByte(), Vector128<byte>.Zero);
-            Vector128<byte> srcLow1 = Sse2.UnpackLow(src1.AsByte(), Vector128<byte>.Zero);
-            Vector128<byte> srcLow2 = Sse2.UnpackLow(src2.AsByte(), Vector128<byte>.Zero);
-            Vector128<byte> srcLow3 = Sse2.UnpackLow(src3.AsByte(), Vector128<byte>.Zero);
-            Vector128<byte> refLow0 = Sse2.UnpackLow(ref0.AsByte(), Vector128<byte>.Zero);
-            Vector128<byte> refLow1 = Sse2.UnpackLow(ref1.AsByte(), Vector128<byte>.Zero);
-            Vector128<byte> refLow2 = Sse2.UnpackLow(ref2.AsByte(), Vector128<byte>.Zero);
-            Vector128<byte> refLow3 = Sse2.UnpackLow(ref3.AsByte(), Vector128<byte>.Zero);
+            Vector128<byte> srcLow0 = Vector128_.UnpackLow(src0.AsByte(), Vector128<byte>.Zero);
+            Vector128<byte> srcLow1 = Vector128_.UnpackLow(src1.AsByte(), Vector128<byte>.Zero);
+            Vector128<byte> srcLow2 = Vector128_.UnpackLow(src2.AsByte(), Vector128<byte>.Zero);
+            Vector128<byte> srcLow3 = Vector128_.UnpackLow(src3.AsByte(), Vector128<byte>.Zero);
+            Vector128<byte> refLow0 = Vector128_.UnpackLow(ref0.AsByte(), Vector128<byte>.Zero);
+            Vector128<byte> refLow1 = Vector128_.UnpackLow(ref1.AsByte(), Vector128<byte>.Zero);
+            Vector128<byte> refLow2 = Vector128_.UnpackLow(ref2.AsByte(), Vector128<byte>.Zero);
+            Vector128<byte> refLow3 = Vector128_.UnpackLow(ref3.AsByte(), Vector128<byte>.Zero);
 
             // Compute difference. -> 00 01 02 03  00' 01' 02' 03'
-            Vector128<short> diff0 = Sse2.Subtract(srcLow0.AsInt16(), refLow0.AsInt16());
-            Vector128<short> diff1 = Sse2.Subtract(srcLow1.AsInt16(), refLow1.AsInt16());
-            Vector128<short> diff2 = Sse2.Subtract(srcLow2.AsInt16(), refLow2.AsInt16());
-            Vector128<short> diff3 = Sse2.Subtract(srcLow3.AsInt16(), refLow3.AsInt16());
+            Vector128<short> diff0 = srcLow0.AsInt16() - refLow0.AsInt16();
+            Vector128<short> diff1 = srcLow1.AsInt16() - refLow1.AsInt16();
+            Vector128<short> diff2 = srcLow2.AsInt16() - refLow2.AsInt16();
+            Vector128<short> diff3 = srcLow3.AsInt16() - refLow3.AsInt16();
 
             // Unpack and shuffle.
             // 00 01 02 03   0 0 0 0
             // 10 11 12 13   0 0 0 0
             // 20 21 22 23   0 0 0 0
             // 30 31 32 33   0 0 0 0
-            Vector128<int> shuf01l = Sse2.UnpackLow(diff0.AsInt32(), diff1.AsInt32());
-            Vector128<int> shuf23l = Sse2.UnpackLow(diff2.AsInt32(), diff3.AsInt32());
-            Vector128<int> shuf01h = Sse2.UnpackHigh(diff0.AsInt32(), diff1.AsInt32());
-            Vector128<int> shuf23h = Sse2.UnpackHigh(diff2.AsInt32(), diff3.AsInt32());
+            Vector128<int> shuf01l = Vector128_.UnpackLow(diff0.AsInt32(), diff1.AsInt32());
+            Vector128<int> shuf23l = Vector128_.UnpackLow(diff2.AsInt32(), diff3.AsInt32());
+            Vector128<int> shuf01h = Vector128_.UnpackHigh(diff0.AsInt32(), diff1.AsInt32());
+            Vector128<int> shuf23h = Vector128_.UnpackHigh(diff2.AsInt32(), diff3.AsInt32());
 
             // First pass.
-            FTransformPass1SSE2(shuf01l.AsInt16(), shuf23l.AsInt16(), out Vector128<int> v01l, out Vector128<int> v32l);
-            FTransformPass1SSE2(shuf01h.AsInt16(), shuf23h.AsInt16(), out Vector128<int> v01h, out Vector128<int> v32h);
+            FTransformPass1Vector128(shuf01l.AsInt16(), shuf23l.AsInt16(), out Vector128<int> v01l, out Vector128<int> v32l);
+            FTransformPass1Vector128(shuf01h.AsInt16(), shuf23h.AsInt16(), out Vector128<int> v01h, out Vector128<int> v32h);
 
             // Second pass.
-            FTransformPass2SSE2(v01l, v32l, output);
-            FTransformPass2SSE2(v01h, v32h, output2);
+            FTransformPass2Vector128(v01l, v32l, output);
+            FTransformPass2Vector128(v01h, v32h, output2);
         }
         else
         {
@@ -427,7 +421,7 @@ internal static unsafe class Vp8Encoding
 
     public static void FTransform(Span<byte> src, Span<byte> reference, Span<short> output, Span<int> scratch)
     {
-        if (Sse2.IsSupported)
+        if (Vector128.IsHardwareAccelerated)
         {
             ref byte srcRef = ref MemoryMarshal.GetReference(src);
             ref byte referenceRef = ref MemoryMarshal.GetReference(reference);
@@ -449,29 +443,29 @@ internal static unsafe class Vp8Encoding
             // 20 21 22 23 *
             // 30 31 32 33 *
             // Shuffle.
-            Vector128<short> srcLow0 = Sse2.UnpackLow(src0.AsInt16(), src1.AsInt16());
-            Vector128<short> srcLow1 = Sse2.UnpackLow(src2.AsInt16(), src3.AsInt16());
-            Vector128<short> refLow0 = Sse2.UnpackLow(ref0.AsInt16(), ref1.AsInt16());
-            Vector128<short> refLow1 = Sse2.UnpackLow(ref2.AsInt16(), ref3.AsInt16());
+            Vector128<short> srcLow0 = Vector128_.UnpackLow(src0.AsInt16(), src1.AsInt16());
+            Vector128<short> srcLow1 = Vector128_.UnpackLow(src2.AsInt16(), src3.AsInt16());
+            Vector128<short> refLow0 = Vector128_.UnpackLow(ref0.AsInt16(), ref1.AsInt16());
+            Vector128<short> refLow1 = Vector128_.UnpackLow(ref2.AsInt16(), ref3.AsInt16());
 
             // 00 01 10 11 02 03 12 13 * * ...
             // 20 21 30 31 22 22 32 33 * * ...
 
             // Convert both to 16 bit.
-            Vector128<byte> src0_16b = Sse2.UnpackLow(srcLow0.AsByte(), Vector128<byte>.Zero);
-            Vector128<byte> src1_16b = Sse2.UnpackLow(srcLow1.AsByte(), Vector128<byte>.Zero);
-            Vector128<byte> ref0_16b = Sse2.UnpackLow(refLow0.AsByte(), Vector128<byte>.Zero);
-            Vector128<byte> ref1_16b = Sse2.UnpackLow(refLow1.AsByte(), Vector128<byte>.Zero);
+            Vector128<byte> src0_16b = Vector128_.UnpackLow(srcLow0.AsByte(), Vector128<byte>.Zero);
+            Vector128<byte> src1_16b = Vector128_.UnpackLow(srcLow1.AsByte(), Vector128<byte>.Zero);
+            Vector128<byte> ref0_16b = Vector128_.UnpackLow(refLow0.AsByte(), Vector128<byte>.Zero);
+            Vector128<byte> ref1_16b = Vector128_.UnpackLow(refLow1.AsByte(), Vector128<byte>.Zero);
 
             // Compute the difference.
-            Vector128<short> row01 = Sse2.Subtract(src0_16b.AsInt16(), ref0_16b.AsInt16());
-            Vector128<short> row23 = Sse2.Subtract(src1_16b.AsInt16(), ref1_16b.AsInt16());
+            Vector128<short> row01 = src0_16b.AsInt16() - ref0_16b.AsInt16();
+            Vector128<short> row23 = src1_16b.AsInt16() - ref1_16b.AsInt16();
 
             // First pass.
-            FTransformPass1SSE2(row01, row23, out Vector128<int> v01, out Vector128<int> v32);
+            FTransformPass1Vector128(row01, row23, out Vector128<int> v01, out Vector128<int> v32);
 
             // Second pass.
-            FTransformPass2SSE2(v01, v32, output);
+            FTransformPass2Vector128(v01, v32, output);
         }
         else
         {
@@ -517,88 +511,88 @@ internal static unsafe class Vp8Encoding
         }
     }
 
-    public static void FTransformPass1SSE2(Vector128<short> row01, Vector128<short> row23, out Vector128<int> out01, out Vector128<int> out32)
+    public static void FTransformPass1Vector128(Vector128<short> row01, Vector128<short> row23, out Vector128<int> out01, out Vector128<int> out32)
     {
         // *in01 = 00 01 10 11 02 03 12 13
         // *in23 = 20 21 30 31 22 23 32 33
-        Vector128<short> shuf01_p = Sse2.ShuffleHigh(row01, SimdUtils.Shuffle.MMShuffle2301);
-        Vector128<short> shuf32_p = Sse2.ShuffleHigh(row23, SimdUtils.Shuffle.MMShuffle2301);
+        Vector128<short> shuf01_p = Vector128_.ShuffleHigh(row01, SimdUtils.Shuffle.MMShuffle2301);
+        Vector128<short> shuf32_p = Vector128_.ShuffleHigh(row23, SimdUtils.Shuffle.MMShuffle2301);
 
         // 00 01 10 11 03 02 13 12
         // 20 21 30 31 23 22 33 32
-        Vector128<long> s01 = Sse2.UnpackLow(shuf01_p.AsInt64(), shuf32_p.AsInt64());
-        Vector128<long> s32 = Sse2.UnpackHigh(shuf01_p.AsInt64(), shuf32_p.AsInt64());
+        Vector128<long> s01 = Vector128_.UnpackLow(shuf01_p.AsInt64(), shuf32_p.AsInt64());
+        Vector128<long> s32 = Vector128_.UnpackHigh(shuf01_p.AsInt64(), shuf32_p.AsInt64());
 
         // 00 01 10 11 20 21 30 31
         // 03 02 13 12 23 22 33 32
-        Vector128<short> a01 = Sse2.Add(s01.AsInt16(), s32.AsInt16());
-        Vector128<short> a32 = Sse2.Subtract(s01.AsInt16(), s32.AsInt16());
+        Vector128<short> a01 = s01.AsInt16() + s32.AsInt16();
+        Vector128<short> a32 = s01.AsInt16() - s32.AsInt16();
 
         // [d0 + d3 | d1 + d2 | ...] = [a0 a1 | a0' a1' | ... ]
         // [d0 - d3 | d1 - d2 | ...] = [a3 a2 | a3' a2' | ... ]
 
         // [ (a0 + a1) << 3, ... ]
-        Vector128<int> tmp0 = Sse2.MultiplyAddAdjacent(a01, Vector128.Create(8, 0, 8, 0, 8, 0, 8, 0, 8, 0, 8, 0, 8, 0, 8, 0).AsInt16()); // K88p
+        Vector128<int> tmp0 = Vector128_.MultiplyAddAdjacent(a01, Vector128.Create(8, 0, 8, 0, 8, 0, 8, 0, 8, 0, 8, 0, 8, 0, 8, 0).AsInt16()); // K88p
 
         // [ (a0 - a1) << 3, ... ]
-        Vector128<int> tmp2 = Sse2.MultiplyAddAdjacent(a01, Vector128.Create(8, 0, 248, 255, 8, 0, 248, 255, 8, 0, 248, 255, 8, 0, 248, 255).AsInt16());        // K88m
-        Vector128<int> tmp11 = Sse2.MultiplyAddAdjacent(a32, Vector128.Create(232, 20, 169, 8, 232, 20, 169, 8, 232, 20, 169, 8, 232, 20, 169, 8).AsInt16());   // K5352_2217p
-        Vector128<int> tmp31 = Sse2.MultiplyAddAdjacent(a32, Vector128.Create(169, 8, 24, 235, 169, 8, 24, 235, 169, 8, 24, 235, 169, 8, 24, 235).AsInt16());   // K5352_2217m
-        Vector128<int> tmp12 = Sse2.Add(tmp11, Vector128.Create(1812));
-        Vector128<int> tmp32 = Sse2.Add(tmp31, Vector128.Create(937));
-        Vector128<int> tmp1 = Sse2.ShiftRightArithmetic(tmp12, 9);
-        Vector128<int> tmp3 = Sse2.ShiftRightArithmetic(tmp32, 9);
-        Vector128<short> s03 = Sse2.PackSignedSaturate(tmp0, tmp2);
-        Vector128<short> s12 = Sse2.PackSignedSaturate(tmp1, tmp3);
-        Vector128<short> slo = Sse2.UnpackLow(s03, s12); // 0 1 0 1 0 1...
-        Vector128<short> shi = Sse2.UnpackHigh(s03, s12); // 2 3 2 3 2 3
-        Vector128<int> v23 = Sse2.UnpackHigh(slo.AsInt32(), shi.AsInt32());
-        out01 = Sse2.UnpackLow(slo.AsInt32(), shi.AsInt32());
-        out32 = Sse2.Shuffle(v23, SimdUtils.Shuffle.MMShuffle1032);
+        Vector128<int> tmp2 = Vector128_.MultiplyAddAdjacent(a01, Vector128.Create(8, 0, 248, 255, 8, 0, 248, 255, 8, 0, 248, 255, 8, 0, 248, 255).AsInt16());        // K88m
+        Vector128<int> tmp11 = Vector128_.MultiplyAddAdjacent(a32, Vector128.Create(232, 20, 169, 8, 232, 20, 169, 8, 232, 20, 169, 8, 232, 20, 169, 8).AsInt16());   // K5352_2217p
+        Vector128<int> tmp31 = Vector128_.MultiplyAddAdjacent(a32, Vector128.Create(169, 8, 24, 235, 169, 8, 24, 235, 169, 8, 24, 235, 169, 8, 24, 235).AsInt16());   // K5352_2217m
+        Vector128<int> tmp12 = tmp11 + Vector128.Create(1812);
+        Vector128<int> tmp32 = tmp31 + Vector128.Create(937);
+        Vector128<int> tmp1 = Vector128.ShiftRightArithmetic(tmp12, 9);
+        Vector128<int> tmp3 = Vector128.ShiftRightArithmetic(tmp32, 9);
+        Vector128<short> s03 = Vector128_.PackSignedSaturate(tmp0, tmp2);
+        Vector128<short> s12 = Vector128_.PackSignedSaturate(tmp1, tmp3);
+        Vector128<short> slo = Vector128_.UnpackLow(s03, s12); // 0 1 0 1 0 1...
+        Vector128<short> shi = Vector128_.UnpackHigh(s03, s12); // 2 3 2 3 2 3
+        Vector128<int> v23 = Vector128_.UnpackHigh(slo.AsInt32(), shi.AsInt32());
+        out01 = Vector128_.UnpackLow(slo.AsInt32(), shi.AsInt32());
+        out32 = Vector128_.ShuffleNative(v23, SimdUtils.Shuffle.MMShuffle1032);
     }
 
-    public static void FTransformPass2SSE2(Vector128<int> v01, Vector128<int> v32, Span<short> output)
+    public static void FTransformPass2Vector128(Vector128<int> v01, Vector128<int> v32, Span<short> output)
     {
         // Same operations are done on the (0,3) and (1,2) pairs.
         // a3 = v0 - v3
         // a2 = v1 - v2
-        Vector128<short> a32 = Sse2.Subtract(v01.AsInt16(), v32.AsInt16());
-        Vector128<long> a22 = Sse2.UnpackHigh(a32.AsInt64(), a32.AsInt64());
+        Vector128<short> a32 = v01.AsInt16() - v32.AsInt16();
+        Vector128<long> a22 = Vector128_.UnpackHigh(a32.AsInt64(), a32.AsInt64());
 
-        Vector128<short> b23 = Sse2.UnpackLow(a22.AsInt16(), a32.AsInt16());
-        Vector128<int> c1 = Sse2.MultiplyAddAdjacent(b23, Vector128.Create(169, 8, 232, 20, 169, 8, 232, 20, 169, 8, 232, 20, 169, 8, 232, 20).AsInt16());  // K5352_2217
-        Vector128<int> c3 = Sse2.MultiplyAddAdjacent(b23, Vector128.Create(24, 235, 169, 8, 24, 235, 169, 8, 24, 235, 169, 8, 24, 235, 169, 8).AsInt16());  // K2217_5352
-        Vector128<int> d1 = Sse2.Add(c1, Vector128.Create(12000 + (1 << 16)));  // K12000PlusOne
-        Vector128<int> d3 = Sse2.Add(c3, Vector128.Create(51000));
-        Vector128<int> e1 = Sse2.ShiftRightArithmetic(d1, 16);
-        Vector128<int> e3 = Sse2.ShiftRightArithmetic(d3, 16);
+        Vector128<short> b23 = Vector128_.UnpackLow(a22.AsInt16(), a32.AsInt16());
+        Vector128<int> c1 = Vector128_.MultiplyAddAdjacent(b23, Vector128.Create(169, 8, 232, 20, 169, 8, 232, 20, 169, 8, 232, 20, 169, 8, 232, 20).AsInt16());  // K5352_2217
+        Vector128<int> c3 = Vector128_.MultiplyAddAdjacent(b23, Vector128.Create(24, 235, 169, 8, 24, 235, 169, 8, 24, 235, 169, 8, 24, 235, 169, 8).AsInt16());  // K2217_5352
+        Vector128<int> d1 = c1 + Vector128.Create(12000 + (1 << 16));  // K12000PlusOne
+        Vector128<int> d3 = c3 + Vector128.Create(51000);
+        Vector128<int> e1 = Vector128.ShiftRightArithmetic(d1, 16);
+        Vector128<int> e3 = Vector128.ShiftRightArithmetic(d3, 16);
 
         // f1 = ((b3 * 5352 + b2 * 2217 + 12000) >> 16)
         // f3 = ((b3 * 2217 - b2 * 5352 + 51000) >> 16)
-        Vector128<short> f1 = Sse2.PackSignedSaturate(e1, e1);
-        Vector128<short> f3 = Sse2.PackSignedSaturate(e3, e3);
+        Vector128<short> f1 = Vector128_.PackSignedSaturate(e1, e1);
+        Vector128<short> f3 = Vector128_.PackSignedSaturate(e3, e3);
 
         // g1 = f1 + (a3 != 0);
         // The compare will return (0xffff, 0) for (==0, !=0). To turn that into the
         // desired (0, 1), we add one earlier through k12000_plus_one.
         // -> g1 = f1 + 1 - (a3 == 0)
-        Vector128<short> g1 = Sse2.Add(f1, Sse2.CompareEqual(a32, Vector128<short>.Zero));
+        Vector128<short> g1 = f1 + Vector128.Equals(a32, Vector128<short>.Zero);
 
         // a0 = v0 + v3
         // a1 = v1 + v2
-        Vector128<short> a01 = Sse2.Add(v01.AsInt16(), v32.AsInt16());
-        Vector128<short> a01Plus7 = Sse2.Add(a01.AsInt16(), Vector128.Create((short)7));
-        Vector128<short> a11 = Sse2.UnpackHigh(a01.AsInt64(), a01.AsInt64()).AsInt16();
-        Vector128<short> c0 = Sse2.Add(a01Plus7, a11);
-        Vector128<short> c2 = Sse2.Subtract(a01Plus7, a11);
+        Vector128<short> a01 = v01.AsInt16() + v32.AsInt16();
+        Vector128<short> a01Plus7 = a01.AsInt16() + Vector128.Create((short)7);
+        Vector128<short> a11 = Vector128_.UnpackHigh(a01.AsInt64(), a01.AsInt64()).AsInt16();
+        Vector128<short> c0 = a01Plus7 + a11;
+        Vector128<short> c2 = a01Plus7 - a11;
 
         // d0 = (a0 + a1 + 7) >> 4;
         // d2 = (a0 - a1 + 7) >> 4;
-        Vector128<short> d0 = Sse2.ShiftRightArithmetic(c0, 4);
-        Vector128<short> d2 = Sse2.ShiftRightArithmetic(c2, 4);
+        Vector128<short> d0 = Vector128.ShiftRightArithmetic(c0, 4);
+        Vector128<short> d2 = Vector128.ShiftRightArithmetic(c2, 4);
 
-        Vector128<long> d0g1 = Sse2.UnpackLow(d0.AsInt64(), g1.AsInt64());
-        Vector128<long> d2f3 = Sse2.UnpackLow(d2.AsInt64(), f3.AsInt64());
+        Vector128<long> d0g1 = Vector128_.UnpackLow(d0.AsInt64(), g1.AsInt64());
+        Vector128<long> d2f3 = Vector128_.UnpackLow(d2.AsInt64(), f3.AsInt64());
 
         ref short outputRef = ref MemoryMarshal.GetReference(output);
         Unsafe.As<short, Vector128<short>>(ref outputRef) = d0g1.AsInt16();
diff --git a/src/ImageSharp/Formats/Webp/Lossy/Vp8Matrix.cs b/src/ImageSharp/Formats/Webp/Lossy/Vp8Matrix.cs
index 7ba15a6d61..5cd8812c95 100644
--- a/src/ImageSharp/Formats/Webp/Lossy/Vp8Matrix.cs
+++ b/src/ImageSharp/Formats/Webp/Lossy/Vp8Matrix.cs
@@ -5,13 +5,13 @@ namespace SixLabors.ImageSharp.Formats.Webp.Lossy;
 
 internal unsafe struct Vp8Matrix
 {
+    // [luma-ac,luma-dc,chroma][dc,ac]
     private static readonly int[][] BiasMatrices =
-    {
-        // [luma-ac,luma-dc,chroma][dc,ac]
-        new[] { 96, 110 },
-        new[] { 96, 108 },
-        new[] { 110, 115 }
-    };
+    [
+        [96, 110],
+        [96, 108],
+        [110, 115]
+    ];
 
     /// <summary>
     /// Number of descaling bits for sharpening bias.
@@ -46,7 +46,7 @@ internal unsafe struct Vp8Matrix
     // Sharpening by (slightly) raising the hi-frequency coeffs.
     // Hack-ish but helpful for mid-bitrate range. Use with care.
     // This uses C#'s optimization to refer to the static data segment of the assembly, no allocation occurs.
-    private static ReadOnlySpan<byte> FreqSharpening => new byte[] { 0, 30, 60, 90, 30, 60, 90, 90, 60, 90, 90, 90, 90, 90, 90, 90 };
+    private static ReadOnlySpan<byte> FreqSharpening => [0, 30, 60, 90, 30, 60, 90, 90, 60, 90, 90, 90, 90, 90, 90, 90];
 
     /// <summary>
     /// Returns the average quantizer.
diff --git a/src/ImageSharp/Formats/Webp/Lossy/WebpLossyDecoder.cs b/src/ImageSharp/Formats/Webp/Lossy/WebpLossyDecoder.cs
index 65d5b65e88..f14df853cd 100644
--- a/src/ImageSharp/Formats/Webp/Lossy/WebpLossyDecoder.cs
+++ b/src/ImageSharp/Formats/Webp/Lossy/WebpLossyDecoder.cs
@@ -150,7 +150,7 @@ internal sealed class WebpLossyDecoder
             {
                 int offset = yMulWidth + x;
                 Bgr24 bgr = pixelsBgr[offset];
-                decodedPixelRow[x] = TPixel.FromBgra32(new(bgr.R, bgr.G, bgr.B, alphaSpan[offset]));
+                decodedPixelRow[x] = TPixel.FromBgra32(new Bgra32(bgr.R, bgr.G, bgr.B, alphaSpan[offset]));
             }
         }
     }
diff --git a/src/ImageSharp/Formats/Webp/Lossy/YuvConversion.cs b/src/ImageSharp/Formats/Webp/Lossy/YuvConversion.cs
index 40146c6af8..d5f91b7c88 100644
--- a/src/ImageSharp/Formats/Webp/Lossy/YuvConversion.cs
+++ b/src/ImageSharp/Formats/Webp/Lossy/YuvConversion.cs
@@ -5,7 +5,7 @@ using System.Buffers;
 using System.Runtime.CompilerServices;
 using System.Runtime.InteropServices;
 using System.Runtime.Intrinsics;
-using System.Runtime.Intrinsics.X86;
+using SixLabors.ImageSharp.Common.Helpers;
 using SixLabors.ImageSharp.Memory;
 using SixLabors.ImageSharp.PixelFormats;
 
@@ -29,9 +29,9 @@ internal static class YuvConversion
     //  ([3*a +   b + 9*c + 3*d      a + 3*b + 3*c + 9*d]   [8 8]) / 16
     public static void UpSample(Span<byte> topY, Span<byte> bottomY, Span<byte> topU, Span<byte> topV, Span<byte> curU, Span<byte> curV, Span<byte> topDst, Span<byte> bottomDst, int len, byte[] uvBuffer)
     {
-        if (Sse41.IsSupported)
+        if (Vector128.IsHardwareAccelerated)
         {
-            UpSampleSse41(topY, bottomY, topU, topV, curU, curV, topDst, bottomDst, len, uvBuffer);
+            UpSampleVector128(topY, bottomY, topU, topV, curU, curV, topDst, bottomDst, len, uvBuffer);
         }
         else
         {
@@ -107,7 +107,7 @@ internal static class YuvConversion
     //
     // Then m can be written as
     // m = (k + t + 1) / 2 - (((b^c) & (s^t)) | (k^t)) & 1
-    private static void UpSampleSse41(Span<byte> topY, Span<byte> bottomY, Span<byte> topU, Span<byte> topV, Span<byte> curU, Span<byte> curV, Span<byte> topDst, Span<byte> bottomDst, int len, byte[] uvBuffer)
+    private static void UpSampleVector128(Span<byte> topY, Span<byte> bottomY, Span<byte> topU, Span<byte> topV, Span<byte> curU, Span<byte> curV, Span<byte> topDst, Span<byte> bottomDst, int len, byte[] uvBuffer)
     {
         const int xStep = 3;
         Array.Clear(uvBuffer);
@@ -138,18 +138,18 @@ internal static class YuvConversion
         {
             for (pos = 1, uvPos = 0; pos + 32 + 1 <= len; pos += 32, uvPos += 16)
             {
-                UpSample32Pixels(ref Unsafe.Add(ref topURef, (uint)uvPos), ref Unsafe.Add(ref curURef, (uint)uvPos), ru);
-                UpSample32Pixels(ref Unsafe.Add(ref topVRef, (uint)uvPos), ref Unsafe.Add(ref curVRef, (uint)uvPos), rv);
-                ConvertYuvToBgrWithBottomYSse41(topY, bottomY, topDst, bottomDst, ru, rv, pos, xStep);
+                UpSample32PixelsVector128(ref Unsafe.Add(ref topURef, (uint)uvPos), ref Unsafe.Add(ref curURef, (uint)uvPos), ru);
+                UpSample32PixelsVector128(ref Unsafe.Add(ref topVRef, (uint)uvPos), ref Unsafe.Add(ref curVRef, (uint)uvPos), rv);
+                ConvertYuvToBgrWithBottomYVector128(topY, bottomY, topDst, bottomDst, ru, rv, pos, xStep);
             }
         }
         else
         {
             for (pos = 1, uvPos = 0; pos + 32 + 1 <= len; pos += 32, uvPos += 16)
             {
-                UpSample32Pixels(ref Unsafe.Add(ref topURef, (uint)uvPos), ref Unsafe.Add(ref curURef, (uint)uvPos), ru);
-                UpSample32Pixels(ref Unsafe.Add(ref topVRef, (uint)uvPos), ref Unsafe.Add(ref curVRef, (uint)uvPos), rv);
-                ConvertYuvToBgrSse41(topY, topDst, ru, rv, pos, xStep);
+                UpSample32PixelsVector128(ref Unsafe.Add(ref topURef, (uint)uvPos), ref Unsafe.Add(ref curURef, (uint)uvPos), ru);
+                UpSample32PixelsVector128(ref Unsafe.Add(ref topVRef, (uint)uvPos), ref Unsafe.Add(ref curVRef, (uint)uvPos), rv);
+                ConvertYuvToBgrVector128(topY, topDst, ru, rv, pos, xStep);
             }
         }
 
@@ -161,18 +161,18 @@ internal static class YuvConversion
             Span<byte> tmpBottomDst = tmpTopDst[(4 * 32)..];
             Span<byte> tmpTop = tmpBottomDst[(4 * 32)..];
             Span<byte> tmpBottom = bottomY.IsEmpty ? null : tmpTop[32..];
-            UpSampleLastBlock(topU[uvPos..], curU[uvPos..], leftOver, ru);
-            UpSampleLastBlock(topV[uvPos..], curV[uvPos..], leftOver, rv);
+            UpSampleLastBlockVector128(topU[uvPos..], curU[uvPos..], leftOver, ru);
+            UpSampleLastBlockVector128(topV[uvPos..], curV[uvPos..], leftOver, rv);
 
             topY[pos..len].CopyTo(tmpTop);
             if (!bottomY.IsEmpty)
             {
                 bottomY[pos..len].CopyTo(tmpBottom);
-                ConvertYuvToBgrWithBottomYSse41(tmpTop, tmpBottom, tmpTopDst, tmpBottomDst, ru, rv, 0, xStep);
+                ConvertYuvToBgrWithBottomYVector128(tmpTop, tmpBottom, tmpTopDst, tmpBottomDst, ru, rv, 0, xStep);
             }
             else
             {
-                ConvertYuvToBgrSse41(tmpTop, tmpTopDst, ru, rv, 0, xStep);
+                ConvertYuvToBgrVector128(tmpTop, tmpTopDst, ru, rv, 0, xStep);
             }
 
             tmpTopDst[..((len - pos) * xStep)].CopyTo(topDst[(pos * xStep)..]);
@@ -184,7 +184,7 @@ internal static class YuvConversion
     }
 
     // Loads 17 pixels each from rows r1 and r2 and generates 32 pixels.
-    private static void UpSample32Pixels(ref byte r1, ref byte r2, Span<byte> output)
+    private static void UpSample32PixelsVector128(ref byte r1, ref byte r2, Span<byte> output)
     {
         // Load inputs.
         Vector128<byte> a = Unsafe.As<byte, Vector128<byte>>(ref r1);
@@ -192,28 +192,28 @@ internal static class YuvConversion
         Vector128<byte> c = Unsafe.As<byte, Vector128<byte>>(ref r2);
         Vector128<byte> d = Unsafe.As<byte, Vector128<byte>>(ref Unsafe.Add(ref r2, 1));
 
-        Vector128<byte> s = Sse2.Average(a, d); // s = (a + d + 1) / 2
-        Vector128<byte> t = Sse2.Average(b, c); // t = (b + c + 1) / 2
-        Vector128<byte> st = Sse2.Xor(s, t); // st = s^t
+        Vector128<byte> s = Vector128_.Average(a, d); // s = (a + d + 1) / 2
+        Vector128<byte> t = Vector128_.Average(b, c); // t = (b + c + 1) / 2
+        Vector128<byte> st = s ^ t; // st = s^t
 
-        Vector128<byte> ad = Sse2.Xor(a, d); // ad = a^d
-        Vector128<byte> bc = Sse2.Xor(b, c); // bc = b^c
+        Vector128<byte> ad = a ^ d; // ad = a^d
+        Vector128<byte> bc = b ^ c; // bc = b^c
 
-        Vector128<byte> t1 = Sse2.Or(ad, bc); // (a^d) | (b^c)
-        Vector128<byte> t2 = Sse2.Or(t1, st); // (a^d) | (b^c) | (s^t)
-        Vector128<byte> t3 = Sse2.And(t2, Vector128.Create((byte)1)); // (a^d) | (b^c) | (s^t) & 1
-        Vector128<byte> t4 = Sse2.Average(s, t);
-        Vector128<byte> k = Sse2.Subtract(t4, t3); // k = (a + b + c + d) / 4
+        Vector128<byte> t1 = ad | bc; // (a^d) | (b^c)
+        Vector128<byte> t2 = t1 | st; // (a^d) | (b^c) | (s^t)
+        Vector128<byte> t3 = t2 & Vector128.Create((byte)1); // (a^d) | (b^c) | (s^t) & 1
+        Vector128<byte> t4 = Vector128_.Average(s, t);
+        Vector128<byte> k = t4 - t3; // k = (a + b + c + d) / 4
 
-        Vector128<byte> diag1 = GetM(k, st, bc, t);
-        Vector128<byte> diag2 = GetM(k, st, ad, s);
+        Vector128<byte> diag1 = GetMVector128(k, st, bc, t);
+        Vector128<byte> diag2 = GetMVector128(k, st, ad, s);
 
         // Pack the alternate pixels.
-        PackAndStore(a, b, diag1, diag2, output); // store top.
-        PackAndStore(c, d, diag2, diag1, output[(2 * 32)..]);
+        PackAndStoreVector128(a, b, diag1, diag2, output); // store top.
+        PackAndStoreVector128(c, d, diag2, diag1, output[(2 * 32)..]);
     }
 
-    private static void UpSampleLastBlock(Span<byte> tb, Span<byte> bb, int numPixels, Span<byte> output)
+    private static void UpSampleLastBlockVector128(Span<byte> tb, Span<byte> bb, int numPixels, Span<byte> output)
     {
         Span<byte> r1 = stackalloc byte[17];
         Span<byte> r2 = stackalloc byte[17];
@@ -230,27 +230,27 @@ internal static class YuvConversion
 
         ref byte r1Ref = ref MemoryMarshal.GetReference(r1);
         ref byte r2Ref = ref MemoryMarshal.GetReference(r2);
-        UpSample32Pixels(ref r1Ref, ref r2Ref, output);
+        UpSample32PixelsVector128(ref r1Ref, ref r2Ref, output);
     }
 
     // Computes out = (k + in + 1) / 2 - ((ij & (s^t)) | (k^in)) & 1
-    private static Vector128<byte> GetM(Vector128<byte> k, Vector128<byte> st, Vector128<byte> ij, Vector128<byte> input)
+    private static Vector128<byte> GetMVector128(Vector128<byte> k, Vector128<byte> st, Vector128<byte> ij, Vector128<byte> input)
     {
-        Vector128<byte> tmp0 = Sse2.Average(k, input); // (k + in + 1) / 2
-        Vector128<byte> tmp1 = Sse2.And(ij, st); // (ij) & (s^t)
-        Vector128<byte> tmp2 = Sse2.Xor(k, input); // (k^in)
-        Vector128<byte> tmp3 = Sse2.Or(tmp1, tmp2); // ((ij) & (s^t)) | (k^in)
-        Vector128<byte> tmp4 = Sse2.And(tmp3, Vector128.Create((byte)1)); // & 1 -> lsb_correction
+        Vector128<byte> tmp0 = Vector128_.Average(k, input); // (k + in + 1) / 2
+        Vector128<byte> tmp1 = ij & st; // (ij) & (s^t)
+        Vector128<byte> tmp2 = k ^ input; // (k^in)
+        Vector128<byte> tmp3 = tmp1 | tmp2; // ((ij) & (s^t)) | (k^in)
+        Vector128<byte> tmp4 = tmp3 & Vector128.Create((byte)1); // & 1 -> lsb_correction
 
-        return Sse2.Subtract(tmp0, tmp4); // (k + in + 1) / 2 - lsb_correction
+        return tmp0 - tmp4; // (k + in + 1) / 2 - lsb_correction
     }
 
-    private static void PackAndStore(Vector128<byte> a, Vector128<byte> b, Vector128<byte> da, Vector128<byte> db, Span<byte> output)
+    private static void PackAndStoreVector128(Vector128<byte> a, Vector128<byte> b, Vector128<byte> da, Vector128<byte> db, Span<byte> output)
     {
-        Vector128<byte> ta = Sse2.Average(a, da); // (9a + 3b + 3c +  d + 8) / 16
-        Vector128<byte> tb = Sse2.Average(b, db); // (3a + 9b +  c + 3d + 8) / 16
-        Vector128<byte> t1 = Sse2.UnpackLow(ta, tb);
-        Vector128<byte> t2 = Sse2.UnpackHigh(ta, tb);
+        Vector128<byte> ta = Vector128_.Average(a, da); // (9a + 3b + 3c +  d + 8) / 16
+        Vector128<byte> tb = Vector128_.Average(b, db); // (3a + 9b +  c + 3d + 8) / 16
+        Vector128<byte> t1 = Vector128_.UnpackLow(ta, tb);
+        Vector128<byte> t2 = Vector128_.UnpackHigh(ta, tb);
 
         ref byte output0Ref = ref MemoryMarshal.GetReference(output);
         ref byte output1Ref = ref Unsafe.Add(ref output0Ref, 16);
@@ -562,41 +562,42 @@ internal static class YuvConversion
     }
 
     [MethodImpl(InliningOptions.ShortMethod)]
-    private static void ConvertYuvToBgrSse41(Span<byte> topY, Span<byte> topDst, Span<byte> ru, Span<byte> rv, int curX, int step) => YuvToBgrSse41(topY[curX..], ru, rv, topDst[(curX * step)..]);
+    private static void ConvertYuvToBgrVector128(Span<byte> topY, Span<byte> topDst, Span<byte> ru, Span<byte> rv, int curX, int step)
+        => YuvToBgrVector128(topY[curX..], ru, rv, topDst[(curX * step)..]);
 
     [MethodImpl(InliningOptions.ShortMethod)]
-    private static void ConvertYuvToBgrWithBottomYSse41(Span<byte> topY, Span<byte> bottomY, Span<byte> topDst, Span<byte> bottomDst, Span<byte> ru, Span<byte> rv, int curX, int step)
+    private static void ConvertYuvToBgrWithBottomYVector128(Span<byte> topY, Span<byte> bottomY, Span<byte> topDst, Span<byte> bottomDst, Span<byte> ru, Span<byte> rv, int curX, int step)
     {
-        YuvToBgrSse41(topY[curX..], ru, rv, topDst[(curX * step)..]);
-        YuvToBgrSse41(bottomY[curX..], ru[64..], rv[64..], bottomDst[(curX * step)..]);
+        YuvToBgrVector128(topY[curX..], ru, rv, topDst[(curX * step)..]);
+        YuvToBgrVector128(bottomY[curX..], ru[64..], rv[64..], bottomDst[(curX * step)..]);
     }
 
-    private static void YuvToBgrSse41(Span<byte> y, Span<byte> u, Span<byte> v, Span<byte> dst)
+    private static void YuvToBgrVector128(Span<byte> y, Span<byte> u, Span<byte> v, Span<byte> dst)
     {
         ref byte yRef = ref MemoryMarshal.GetReference(y);
         ref byte uRef = ref MemoryMarshal.GetReference(u);
         ref byte vRef = ref MemoryMarshal.GetReference(v);
-        ConvertYuv444ToBgrSse41(ref yRef, ref uRef, ref vRef, out Vector128<short> r0, out Vector128<short> g0, out Vector128<short> b0);
-        ConvertYuv444ToBgrSse41(ref Unsafe.Add(ref yRef, 8), ref Unsafe.Add(ref uRef, 8), ref Unsafe.Add(ref vRef, 8), out Vector128<short> r1, out Vector128<short> g1, out Vector128<short> b1);
-        ConvertYuv444ToBgrSse41(ref Unsafe.Add(ref yRef, 16), ref Unsafe.Add(ref uRef, 16), ref Unsafe.Add(ref vRef, 16), out Vector128<short> r2, out Vector128<short> g2, out Vector128<short> b2);
-        ConvertYuv444ToBgrSse41(ref Unsafe.Add(ref yRef, 24), ref Unsafe.Add(ref uRef, 24), ref Unsafe.Add(ref vRef, 24), out Vector128<short> r3, out Vector128<short> g3, out Vector128<short> b3);
+        ConvertYuv444ToBgrVector128(ref yRef, ref uRef, ref vRef, out Vector128<short> r0, out Vector128<short> g0, out Vector128<short> b0);
+        ConvertYuv444ToBgrVector128(ref Unsafe.Add(ref yRef, 8), ref Unsafe.Add(ref uRef, 8), ref Unsafe.Add(ref vRef, 8), out Vector128<short> r1, out Vector128<short> g1, out Vector128<short> b1);
+        ConvertYuv444ToBgrVector128(ref Unsafe.Add(ref yRef, 16), ref Unsafe.Add(ref uRef, 16), ref Unsafe.Add(ref vRef, 16), out Vector128<short> r2, out Vector128<short> g2, out Vector128<short> b2);
+        ConvertYuv444ToBgrVector128(ref Unsafe.Add(ref yRef, 24), ref Unsafe.Add(ref uRef, 24), ref Unsafe.Add(ref vRef, 24), out Vector128<short> r3, out Vector128<short> g3, out Vector128<short> b3);
 
         // Cast to 8b and store as BBBBGGGGRRRR.
-        Vector128<byte> bgr0 = Sse2.PackUnsignedSaturate(b0, b1);
-        Vector128<byte> bgr1 = Sse2.PackUnsignedSaturate(b2, b3);
-        Vector128<byte> bgr2 = Sse2.PackUnsignedSaturate(g0, g1);
-        Vector128<byte> bgr3 = Sse2.PackUnsignedSaturate(g2, g3);
-        Vector128<byte> bgr4 = Sse2.PackUnsignedSaturate(r0, r1);
-        Vector128<byte> bgr5 = Sse2.PackUnsignedSaturate(r2, r3);
+        Vector128<byte> bgr0 = Vector128_.PackUnsignedSaturate(b0, b1);
+        Vector128<byte> bgr1 = Vector128_.PackUnsignedSaturate(b2, b3);
+        Vector128<byte> bgr2 = Vector128_.PackUnsignedSaturate(g0, g1);
+        Vector128<byte> bgr3 = Vector128_.PackUnsignedSaturate(g2, g3);
+        Vector128<byte> bgr4 = Vector128_.PackUnsignedSaturate(r0, r1);
+        Vector128<byte> bgr5 = Vector128_.PackUnsignedSaturate(r2, r3);
 
         // Pack as BGRBGRBGRBGR.
-        PlanarTo24bSse41(bgr0, bgr1, bgr2, bgr3, bgr4, bgr5, dst);
+        PlanarTo24bVector128(bgr0, bgr1, bgr2, bgr3, bgr4, bgr5, dst);
     }
 
     // Pack the planar buffers
     // rrrr... rrrr... gggg... gggg... bbbb... bbbb....
     // triplet by triplet in the output buffer rgb as rgbrgbrgbrgb ...
-    private static void PlanarTo24bSse41(Vector128<byte> input0, Vector128<byte> input1, Vector128<byte> input2, Vector128<byte> input3, Vector128<byte> input4, Vector128<byte> input5, Span<byte> rgb)
+    private static void PlanarTo24bVector128(Vector128<byte> input0, Vector128<byte> input1, Vector128<byte> input2, Vector128<byte> input3, Vector128<byte> input4, Vector128<byte> input5, Span<byte> rgb)
     {
         // The input is 6 registers of sixteen 8b but for the sake of explanation,
         // let's take 6 registers of four 8b values.
@@ -612,7 +613,7 @@ internal static class YuvConversion
         //   r0g0b0r1 | g1b1r2g2 | b2r3g3b3 | r4g4b4r5 | g5b5r6g6 | b6r7g7b7
 
         // Process R.
-        ChannelMixing(
+        ChannelMixingVector128(
             input0,
             input1,
             Vector128.Create(0, 255, 255, 1, 255, 255, 2, 255, 255, 3, 255, 255, 4, 255, 255, 5),        // PlanarTo24Shuffle0
@@ -627,7 +628,7 @@ internal static class YuvConversion
 
         // Process G.
         // Same as before, just shifted to the left by one and including the right padding.
-        ChannelMixing(
+        ChannelMixingVector128(
             input2,
             input3,
             Vector128.Create(255, 0, 255, 255, 1, 255, 255, 2, 255, 255, 3, 255, 255, 4, 255, 255),      // PlanarTo24Shuffle3
@@ -641,7 +642,7 @@ internal static class YuvConversion
             out Vector128<byte> g5);
 
         // Process B.
-        ChannelMixing(
+        ChannelMixingVector128(
             input4,
             input5,
             Vector128.Create(255, 255, 0, 255, 255, 1, 255, 255, 2, 255, 255, 3, 255, 255, 4, 255),     // PlanarTo24Shuffle6
@@ -655,24 +656,24 @@ internal static class YuvConversion
             out Vector128<byte> b5);
 
         // OR the different channels.
-        Vector128<byte> rg0 = Sse2.Or(r0, g0);
-        Vector128<byte> rg1 = Sse2.Or(r1, g1);
-        Vector128<byte> rg2 = Sse2.Or(r2, g2);
-        Vector128<byte> rg3 = Sse2.Or(r3, g3);
-        Vector128<byte> rg4 = Sse2.Or(r4, g4);
-        Vector128<byte> rg5 = Sse2.Or(r5, g5);
+        Vector128<byte> rg0 = r0 | g0;
+        Vector128<byte> rg1 = r1 | g1;
+        Vector128<byte> rg2 = r2 | g2;
+        Vector128<byte> rg3 = r3 | g3;
+        Vector128<byte> rg4 = r4 | g4;
+        Vector128<byte> rg5 = r5 | g5;
 
         ref byte outputRef = ref MemoryMarshal.GetReference(rgb);
-        Unsafe.As<byte, Vector128<byte>>(ref outputRef) = Sse2.Or(rg0, b0);
-        Unsafe.As<byte, Vector128<byte>>(ref Unsafe.Add(ref outputRef, 16)) = Sse2.Or(rg1, b1);
-        Unsafe.As<byte, Vector128<byte>>(ref Unsafe.Add(ref outputRef, 32)) = Sse2.Or(rg2, b2);
-        Unsafe.As<byte, Vector128<byte>>(ref Unsafe.Add(ref outputRef, 48)) = Sse2.Or(rg3, b3);
-        Unsafe.As<byte, Vector128<byte>>(ref Unsafe.Add(ref outputRef, 64)) = Sse2.Or(rg4, b4);
-        Unsafe.As<byte, Vector128<byte>>(ref Unsafe.Add(ref outputRef, 80)) = Sse2.Or(rg5, b5);
+        Unsafe.As<byte, Vector128<byte>>(ref outputRef) = rg0 | b0;
+        Unsafe.As<byte, Vector128<byte>>(ref Unsafe.Add(ref outputRef, 16)) = rg1 | b1;
+        Unsafe.As<byte, Vector128<byte>>(ref Unsafe.Add(ref outputRef, 32)) = rg2 | b2;
+        Unsafe.As<byte, Vector128<byte>>(ref Unsafe.Add(ref outputRef, 48)) = rg3 | b3;
+        Unsafe.As<byte, Vector128<byte>>(ref Unsafe.Add(ref outputRef, 64)) = rg4 | b4;
+        Unsafe.As<byte, Vector128<byte>>(ref Unsafe.Add(ref outputRef, 80)) = rg5 | b5;
     }
 
     // Shuffles the input buffer as A0 0 0 A1 0 0 A2
-    private static void ChannelMixing(
+    private static void ChannelMixingVector128(
         Vector128<byte> input0,
         Vector128<byte> input1,
         Vector128<byte> shuffle0,
@@ -685,53 +686,53 @@ internal static class YuvConversion
         out Vector128<byte> output4,
         out Vector128<byte> output5)
     {
-        output0 = Ssse3.Shuffle(input0, shuffle0);
-        output1 = Ssse3.Shuffle(input0, shuffle1);
-        output2 = Ssse3.Shuffle(input0, shuffle2);
-        output3 = Ssse3.Shuffle(input1, shuffle0);
-        output4 = Ssse3.Shuffle(input1, shuffle1);
-        output5 = Ssse3.Shuffle(input1, shuffle2);
+        output0 = Vector128_.ShuffleNative(input0, shuffle0);
+        output1 = Vector128_.ShuffleNative(input0, shuffle1);
+        output2 = Vector128_.ShuffleNative(input0, shuffle2);
+        output3 = Vector128_.ShuffleNative(input1, shuffle0);
+        output4 = Vector128_.ShuffleNative(input1, shuffle1);
+        output5 = Vector128_.ShuffleNative(input1, shuffle2);
     }
 
     // Convert 32 samples of YUV444 to B/G/R
-    private static void ConvertYuv444ToBgrSse41(ref byte y, ref byte u, ref byte v, out Vector128<short> r, out Vector128<short> g, out Vector128<short> b)
+    private static void ConvertYuv444ToBgrVector128(ref byte y, ref byte u, ref byte v, out Vector128<short> r, out Vector128<short> g, out Vector128<short> b)
     {
         // Load the bytes into the *upper* part of 16b words. That's "<< 8", basically.
         Vector128<byte> y0 = Unsafe.As<byte, Vector128<byte>>(ref y);
         Vector128<byte> u0 = Unsafe.As<byte, Vector128<byte>>(ref u);
         Vector128<byte> v0 = Unsafe.As<byte, Vector128<byte>>(ref v);
-        y0 = Sse2.UnpackLow(Vector128<byte>.Zero, y0);
-        u0 = Sse2.UnpackLow(Vector128<byte>.Zero, u0);
-        v0 = Sse2.UnpackLow(Vector128<byte>.Zero, v0);
+        y0 = Vector128_.UnpackLow(Vector128<byte>.Zero, y0);
+        u0 = Vector128_.UnpackLow(Vector128<byte>.Zero, u0);
+        v0 = Vector128_.UnpackLow(Vector128<byte>.Zero, v0);
 
         // These constants are 14b fixed-point version of ITU-R BT.601 constants.
         // R = (19077 * y             + 26149 * v - 14234) >> 6
         // G = (19077 * y -  6419 * u - 13320 * v +  8708) >> 6
         // B = (19077 * y + 33050 * u             - 17685) >> 6
-        var k19077 = Vector128.Create((ushort)19077);
-        var k26149 = Vector128.Create((ushort)26149);
-        var k14234 = Vector128.Create((ushort)14234);
+        Vector128<ushort> k19077 = Vector128.Create((ushort)19077);
+        Vector128<ushort> k26149 = Vector128.Create((ushort)26149);
+        Vector128<ushort> k14234 = Vector128.Create((ushort)14234);
 
-        Vector128<ushort> y1 = Sse2.MultiplyHigh(y0.AsUInt16(), k19077);
-        Vector128<ushort> r0 = Sse2.MultiplyHigh(v0.AsUInt16(), k26149);
-        Vector128<ushort> g0 = Sse2.MultiplyHigh(u0.AsUInt16(), Vector128.Create((ushort)6419));
-        Vector128<ushort> g1 = Sse2.MultiplyHigh(v0.AsUInt16(), Vector128.Create((ushort)13320));
+        Vector128<ushort> y1 = Vector128_.MultiplyHigh(y0.AsUInt16(), k19077);
+        Vector128<ushort> r0 = Vector128_.MultiplyHigh(v0.AsUInt16(), k26149);
+        Vector128<ushort> g0 = Vector128_.MultiplyHigh(u0.AsUInt16(), Vector128.Create((ushort)6419));
+        Vector128<ushort> g1 = Vector128_.MultiplyHigh(v0.AsUInt16(), Vector128.Create((ushort)13320));
 
-        Vector128<ushort> r1 = Sse2.Subtract(y1.AsUInt16(), k14234);
-        Vector128<ushort> r2 = Sse2.Add(r1, r0);
+        Vector128<ushort> r1 = y1.AsUInt16() - k14234;
+        Vector128<ushort> r2 = r1 + r0;
 
-        Vector128<ushort> g2 = Sse2.Add(y1.AsUInt16(), Vector128.Create((ushort)8708));
-        Vector128<ushort> g3 = Sse2.Add(g0, g1);
-        Vector128<ushort> g4 = Sse2.Subtract(g2, g3);
+        Vector128<ushort> g2 = y1.AsUInt16() + Vector128.Create((ushort)8708);
+        Vector128<ushort> g3 = g0 + g1;
+        Vector128<ushort> g4 = g2 - g3;
 
-        Vector128<ushort> b0 = Sse2.MultiplyHigh(u0.AsUInt16(), Vector128.Create(26, 129, 26, 129, 26, 129, 26, 129, 26, 129, 26, 129, 26, 129, 26, 129).AsUInt16());
-        Vector128<ushort> b1 = Sse2.AddSaturate(b0, y1);
-        Vector128<ushort> b2 = Sse2.SubtractSaturate(b1, Vector128.Create((ushort)17685));
+        Vector128<ushort> b0 = Vector128_.MultiplyHigh(u0.AsUInt16(), Vector128.Create(26, 129, 26, 129, 26, 129, 26, 129, 26, 129, 26, 129, 26, 129, 26, 129).AsUInt16());
+        Vector128<ushort> b1 = Vector128_.AddSaturate(b0, y1);
+        Vector128<ushort> b2 = Vector128_.SubtractSaturate(b1, Vector128.Create((ushort)17685));
 
         // Use logical shift for B2, which can be larger than 32767.
-        r = Sse2.ShiftRightArithmetic(r2.AsInt16(), 6); // range: [-14234, 30815]
-        g = Sse2.ShiftRightArithmetic(g4.AsInt16(), 6); // range: [-10953, 27710]
-        b = Sse2.ShiftRightLogical(b2.AsInt16(), 6); // range: [0, 34238]
+        r = Vector128.ShiftRightArithmetic(r2.AsInt16(), 6); // range: [-14234, 30815]
+        g = Vector128.ShiftRightArithmetic(g4.AsInt16(), 6); // range: [-10953, 27710]
+        b = Vector128.ShiftRightLogical(b2.AsInt16(), 6); // range: [0, 34238]
     }
 
     [MethodImpl(InliningOptions.ShortMethod)]
diff --git a/src/ImageSharp/Formats/Webp/WebpAnimationDecoder.cs b/src/ImageSharp/Formats/Webp/WebpAnimationDecoder.cs
index b74337ef37..173d9436dd 100644
--- a/src/ImageSharp/Formats/Webp/WebpAnimationDecoder.cs
+++ b/src/ImageSharp/Formats/Webp/WebpAnimationDecoder.cs
@@ -81,16 +81,29 @@ internal class WebpAnimationDecoder : IDisposable
     /// <param name="width">The width of the image.</param>
     /// <param name="height">The height of the image.</param>
     /// <param name="completeDataSize">The size of the image data in bytes.</param>
-    public Image<TPixel> Decode<TPixel>(BufferedReadStream stream, WebpFeatures features, uint width, uint height, uint completeDataSize)
+    public Image<TPixel> Decode<TPixel>(
+        BufferedReadStream stream,
+        WebpFeatures features,
+        uint width,
+        uint height,
+        uint completeDataSize)
         where TPixel : unmanaged, IPixel<TPixel>
     {
         Image<TPixel>? image = null;
         ImageFrame<TPixel>? previousFrame = null;
+        WebpFrameData? prevFrameData = null;
 
         this.metadata = new ImageMetadata();
         this.webpMetadata = this.metadata.GetWebpMetadata();
         this.webpMetadata.RepeatCount = features.AnimationLoopCount;
 
+        Color backgroundColor = this.backgroundColorHandling == BackgroundColorHandling.Ignore
+            ? Color.Transparent
+            : features.AnimationBackgroundColor!.Value;
+
+        this.webpMetadata.BackgroundColor = backgroundColor;
+        TPixel backgroundPixel = backgroundColor.ToPixel<TPixel>();
+
         Span<byte> buffer = stackalloc byte[4];
         uint frameCount = 0;
         int remainingBytes = (int)completeDataSize;
@@ -101,10 +114,16 @@ internal class WebpAnimationDecoder : IDisposable
             switch (chunkType)
             {
                 case WebpChunkType.FrameData:
-                    Color backgroundColor = this.backgroundColorHandling == BackgroundColorHandling.Ignore
-                        ? Color.FromPixel(new Bgra32(0, 0, 0, 0))
-                        : features.AnimationBackgroundColor!.Value;
-                    uint dataSize = this.ReadFrame(stream, ref image, ref previousFrame, width, height, backgroundColor);
+
+                    uint dataSize = this.ReadFrame(
+                        stream,
+                        ref image,
+                        ref previousFrame,
+                        ref prevFrameData,
+                        width,
+                        height,
+                        backgroundPixel);
+
                     remainingBytes -= (int)dataSize;
                     break;
                 case WebpChunkType.Xmp:
@@ -132,10 +151,18 @@ internal class WebpAnimationDecoder : IDisposable
     /// <param name="stream">The stream, where the image should be decoded from. Cannot be null.</param>
     /// <param name="image">The image to decode the information to.</param>
     /// <param name="previousFrame">The previous frame.</param>
+    /// <param name="prevFrameData">The previous frame data.</param>
     /// <param name="width">The width of the image.</param>
     /// <param name="height">The height of the image.</param>
     /// <param name="backgroundColor">The default background color of the canvas in.</param>
-    private uint ReadFrame<TPixel>(BufferedReadStream stream, ref Image<TPixel>? image, ref ImageFrame<TPixel>? previousFrame, uint width, uint height, Color backgroundColor)
+    private uint ReadFrame<TPixel>(
+        BufferedReadStream stream,
+        ref Image<TPixel>? image,
+        ref ImageFrame<TPixel>? previousFrame,
+        ref WebpFrameData? prevFrameData,
+        uint width,
+        uint height,
+        TPixel backgroundColor)
         where TPixel : unmanaged, IPixel<TPixel>
     {
         WebpFrameData frameData = WebpFrameData.Parse(stream);
@@ -174,40 +201,51 @@ internal class WebpAnimationDecoder : IDisposable
                 break;
         }
 
-        ImageFrame<TPixel>? currentFrame = null;
-        ImageFrame<TPixel> imageFrame;
+        ImageFrame<TPixel> currentFrame;
         if (previousFrame is null)
         {
-            image = new Image<TPixel>(this.configuration, (int)width, (int)height, backgroundColor.ToPixel<TPixel>(), this.metadata);
-
-            SetFrameMetadata(image.Frames.RootFrame.Metadata, frameData);
+            image = new Image<TPixel>(this.configuration, (int)width, (int)height, backgroundColor, this.metadata);
 
-            imageFrame = image.Frames.RootFrame;
+            currentFrame = image.Frames.RootFrame;
+            SetFrameMetadata(currentFrame.Metadata, frameData);
         }
         else
         {
-            currentFrame = image!.Frames.AddFrame(previousFrame); // This clones the frame and adds it the collection.
+            // If the frame is a key frame we do not need to clone the frame or clear it.
+            bool isKeyFrame = prevFrameData?.DisposalMethod is FrameDisposalMode.RestoreToBackground
+                 && this.restoreArea == image!.Bounds;
 
-            SetFrameMetadata(currentFrame.Metadata, frameData);
+            if (isKeyFrame)
+            {
+                currentFrame = image!.Frames.CreateFrame(backgroundColor);
+            }
+            else
+            {
+                // This clones the frame and adds it the collection.
+                currentFrame = image!.Frames.AddFrame(previousFrame);
+                if (prevFrameData?.DisposalMethod is FrameDisposalMode.RestoreToBackground)
+                {
+                    this.RestoreToBackground(currentFrame, backgroundColor);
+                }
+            }
 
-            imageFrame = currentFrame;
+            SetFrameMetadata(currentFrame.Metadata, frameData);
         }
 
-        Rectangle regionRectangle = frameData.Bounds;
+        Rectangle interest = frameData.Bounds;
+        bool blend = previousFrame != null && frameData.BlendingMethod == FrameBlendMode.Over;
+        using Buffer2D<TPixel> pixelData = this.DecodeImageFrameData<TPixel>(frameData, webpInfo);
+        DrawDecodedImageFrameOnCanvas(pixelData, currentFrame, interest, blend);
+
+        webpInfo?.Dispose();
+        previousFrame = currentFrame;
+        prevFrameData = frameData;
 
         if (frameData.DisposalMethod is FrameDisposalMode.RestoreToBackground)
         {
-            this.RestoreToBackground(imageFrame, backgroundColor);
+            this.restoreArea = interest;
         }
 
-        using Buffer2D<TPixel> decodedImageFrame = this.DecodeImageFrameData<TPixel>(frameData, webpInfo);
-
-        bool blend = previousFrame != null && frameData.BlendingMethod == FrameBlendMode.Over;
-        DrawDecodedImageFrameOnCanvas(decodedImageFrame, imageFrame, regionRectangle, blend);
-
-        previousFrame = currentFrame ?? image.Frames.RootFrame;
-        this.restoreArea = regionRectangle;
-
         return (uint)(stream.Position - streamStartPosition);
     }
 
@@ -257,31 +295,26 @@ internal class WebpAnimationDecoder : IDisposable
 
         try
         {
-            Buffer2D<TPixel> pixelBufferDecoded = decodedFrame.PixelBuffer;
+            Buffer2D<TPixel> decodeBuffer = decodedFrame.PixelBuffer;
             if (webpInfo.IsLossless)
             {
-                WebpLosslessDecoder losslessDecoder =
-                    new(webpInfo.Vp8LBitReader, this.memoryAllocator, this.configuration);
-                losslessDecoder.Decode(pixelBufferDecoded, (int)webpInfo.Width, (int)webpInfo.Height);
+                WebpLosslessDecoder losslessDecoder = new(webpInfo.Vp8LBitReader, this.memoryAllocator, this.configuration);
+                losslessDecoder.Decode(decodeBuffer, (int)webpInfo.Width, (int)webpInfo.Height);
             }
             else
             {
                 WebpLossyDecoder lossyDecoder =
                     new(webpInfo.Vp8BitReader, this.memoryAllocator, this.configuration);
-                lossyDecoder.Decode(pixelBufferDecoded, (int)webpInfo.Width, (int)webpInfo.Height, webpInfo, this.alphaData);
+                lossyDecoder.Decode(decodeBuffer, (int)webpInfo.Width, (int)webpInfo.Height, webpInfo, this.alphaData);
             }
 
-            return pixelBufferDecoded;
+            return decodeBuffer;
         }
         catch
         {
             decodedFrame?.Dispose();
             throw;
         }
-        finally
-        {
-            webpInfo.Dispose();
-        }
     }
 
     /// <summary>
@@ -335,7 +368,7 @@ internal class WebpAnimationDecoder : IDisposable
     /// <typeparam name="TPixel">The pixel format.</typeparam>
     /// <param name="imageFrame">The image frame.</param>
     /// <param name="backgroundColor">Color of the background.</param>
-    private void RestoreToBackground<TPixel>(ImageFrame<TPixel> imageFrame, Color backgroundColor)
+    private void RestoreToBackground<TPixel>(ImageFrame<TPixel> imageFrame, TPixel backgroundColor)
         where TPixel : unmanaged, IPixel<TPixel>
     {
         if (!this.restoreArea.HasValue)
@@ -345,8 +378,9 @@ internal class WebpAnimationDecoder : IDisposable
 
         Rectangle interest = Rectangle.Intersect(imageFrame.Bounds, this.restoreArea.Value);
         Buffer2DRegion<TPixel> pixelRegion = imageFrame.PixelBuffer.GetRegion(interest);
-        TPixel backgroundPixel = backgroundColor.ToPixel<TPixel>();
-        pixelRegion.Fill(backgroundPixel);
+        pixelRegion.Fill(backgroundColor);
+
+        this.restoreArea = null;
     }
 
     /// <inheritdoc/>
diff --git a/src/ImageSharp/Formats/Webp/WebpChunkParsingUtils.cs b/src/ImageSharp/Formats/Webp/WebpChunkParsingUtils.cs
index 4ccaf65031..8df159dbff 100644
--- a/src/ImageSharp/Formats/Webp/WebpChunkParsingUtils.cs
+++ b/src/ImageSharp/Formats/Webp/WebpChunkParsingUtils.cs
@@ -118,7 +118,7 @@ internal static class WebpChunkParsingUtils
 
         Vp8BitReader bitReader = new(stream, remaining, memoryAllocator, partitionLength) { Remaining = remaining };
 
-        return new()
+        return new WebpImageInfo
         {
             Width = width,
             Height = height,
@@ -176,7 +176,7 @@ internal static class WebpChunkParsingUtils
             WebpThrowHelper.ThrowNotSupportedException($"Unexpected version number {version} found in VP8L header");
         }
 
-        return new()
+        return new WebpImageInfo
         {
             Width = width,
             Height = height,
@@ -239,7 +239,7 @@ internal static class WebpChunkParsingUtils
         uint height = ReadUInt24LittleEndian(stream, buffer) + 1;
 
         // Read all the chunks in the order they occur.
-        return new()
+        return new WebpImageInfo
         {
             Width = width,
             Height = height,
diff --git a/src/ImageSharp/Formats/Webp/WebpCommonUtils.cs b/src/ImageSharp/Formats/Webp/WebpCommonUtils.cs
index a1e9821c09..acfa26b4ff 100644
--- a/src/ImageSharp/Formats/Webp/WebpCommonUtils.cs
+++ b/src/ImageSharp/Formats/Webp/WebpCommonUtils.cs
@@ -3,7 +3,7 @@
 
 using System.Runtime.InteropServices;
 using System.Runtime.Intrinsics;
-using System.Runtime.Intrinsics.X86;
+using SixLabors.ImageSharp.Common.Helpers;
 using SixLabors.ImageSharp.PixelFormats;
 
 namespace SixLabors.ImageSharp.Formats.Webp;
@@ -18,9 +18,9 @@ internal static class WebpCommonUtils
     /// </summary>
     /// <param name="row">The row to check.</param>
     /// <returns>Returns true if alpha has non-0xff values.</returns>
-    public static unsafe bool CheckNonOpaque(Span<Bgra32> row)
+    public static unsafe bool CheckNonOpaque(ReadOnlySpan<Bgra32> row)
     {
-        if (Avx2.IsSupported)
+        if (Vector256.IsHardwareAccelerated)
         {
             ReadOnlySpan<byte> rowBytes = MemoryMarshal.AsBytes(row);
             int i = 0;
@@ -32,20 +32,20 @@ internal static class WebpCommonUtils
 
                 for (; i + 128 <= length; i += 128)
                 {
-                    Vector256<byte> a0 = Avx.LoadVector256(src + i).AsByte();
-                    Vector256<byte> a1 = Avx.LoadVector256(src + i + 32).AsByte();
-                    Vector256<byte> a2 = Avx.LoadVector256(src + i + 64).AsByte();
-                    Vector256<byte> a3 = Avx.LoadVector256(src + i + 96).AsByte();
-                    Vector256<int> b0 = Avx2.And(a0, alphaMaskVector256).AsInt32();
-                    Vector256<int> b1 = Avx2.And(a1, alphaMaskVector256).AsInt32();
-                    Vector256<int> b2 = Avx2.And(a2, alphaMaskVector256).AsInt32();
-                    Vector256<int> b3 = Avx2.And(a3, alphaMaskVector256).AsInt32();
-                    Vector256<short> c0 = Avx2.PackSignedSaturate(b0, b1).AsInt16();
-                    Vector256<short> c1 = Avx2.PackSignedSaturate(b2, b3).AsInt16();
-                    Vector256<byte> d = Avx2.PackSignedSaturate(c0, c1).AsByte();
-                    Vector256<byte> bits = Avx2.CompareEqual(d, all0x80Vector256);
-                    int mask = Avx2.MoveMask(bits);
-                    if (mask != -1)
+                    Vector256<byte> a0 = Vector256.Load(src + i).AsByte();
+                    Vector256<byte> a1 = Vector256.Load(src + i + 32).AsByte();
+                    Vector256<byte> a2 = Vector256.Load(src + i + 64).AsByte();
+                    Vector256<byte> a3 = Vector256.Load(src + i + 96).AsByte();
+                    Vector256<int> b0 = (a0 & alphaMaskVector256).AsInt32();
+                    Vector256<int> b1 = (a1 & alphaMaskVector256).AsInt32();
+                    Vector256<int> b2 = (a2 & alphaMaskVector256).AsInt32();
+                    Vector256<int> b3 = (a3 & alphaMaskVector256).AsInt32();
+                    Vector256<short> c0 = Vector256_.PackSignedSaturate(b0, b1).AsInt16();
+                    Vector256<short> c1 = Vector256_.PackSignedSaturate(b2, b3).AsInt16();
+                    Vector256<byte> d = Vector256_.PackSignedSaturate(c0, c1).AsByte();
+                    Vector256<byte> bits = Vector256.Equals(d, all0x80Vector256);
+                    uint mask = bits.ExtractMostSignificantBits();
+                    if (mask != 0xFFFF_FFFF)
                     {
                         return true;
                     }
@@ -53,7 +53,7 @@ internal static class WebpCommonUtils
 
                 for (; i + 64 <= length; i += 64)
                 {
-                    if (IsNoneOpaque64Bytes(src, i))
+                    if (IsNoneOpaque64BytesVector128(src, i))
                     {
                         return true;
                     }
@@ -61,7 +61,7 @@ internal static class WebpCommonUtils
 
                 for (; i + 32 <= length; i += 32)
                 {
-                    if (IsNoneOpaque32Bytes(src, i))
+                    if (IsNonOpaque32BytesVector128(src, i))
                     {
                         return true;
                     }
@@ -76,7 +76,7 @@ internal static class WebpCommonUtils
                 }
             }
         }
-        else if (Sse2.IsSupported)
+        else if (Vector128.IsHardwareAccelerated)
         {
             ReadOnlySpan<byte> rowBytes = MemoryMarshal.AsBytes(row);
             int i = 0;
@@ -85,7 +85,7 @@ internal static class WebpCommonUtils
             {
                 for (; i + 64 <= length; i += 64)
                 {
-                    if (IsNoneOpaque64Bytes(src, i))
+                    if (IsNoneOpaque64BytesVector128(src, i))
                     {
                         return true;
                     }
@@ -93,7 +93,7 @@ internal static class WebpCommonUtils
 
                 for (; i + 32 <= length; i += 32)
                 {
-                    if (IsNoneOpaque32Bytes(src, i))
+                    if (IsNonOpaque32BytesVector128(src, i))
                     {
                         return true;
                     }
@@ -122,38 +122,38 @@ internal static class WebpCommonUtils
         return false;
     }
 
-    private static unsafe bool IsNoneOpaque64Bytes(byte* src, int i)
+    private static unsafe bool IsNoneOpaque64BytesVector128(byte* src, int i)
     {
         Vector128<byte> alphaMask = Vector128.Create(0, 0, 0, 255, 0, 0, 0, 255, 0, 0, 0, 255, 0, 0, 0, 255);
 
-        Vector128<byte> a0 = Sse2.LoadVector128(src + i).AsByte();
-        Vector128<byte> a1 = Sse2.LoadVector128(src + i + 16).AsByte();
-        Vector128<byte> a2 = Sse2.LoadVector128(src + i + 32).AsByte();
-        Vector128<byte> a3 = Sse2.LoadVector128(src + i + 48).AsByte();
-        Vector128<int> b0 = Sse2.And(a0, alphaMask).AsInt32();
-        Vector128<int> b1 = Sse2.And(a1, alphaMask).AsInt32();
-        Vector128<int> b2 = Sse2.And(a2, alphaMask).AsInt32();
-        Vector128<int> b3 = Sse2.And(a3, alphaMask).AsInt32();
-        Vector128<short> c0 = Sse2.PackSignedSaturate(b0, b1).AsInt16();
-        Vector128<short> c1 = Sse2.PackSignedSaturate(b2, b3).AsInt16();
-        Vector128<byte> d = Sse2.PackSignedSaturate(c0, c1).AsByte();
-        Vector128<byte> bits = Sse2.CompareEqual(d, Vector128.Create((byte)0x80).AsByte());
-        int mask = Sse2.MoveMask(bits);
+        Vector128<byte> a0 = Vector128.Load(src + i).AsByte();
+        Vector128<byte> a1 = Vector128.Load(src + i + 16).AsByte();
+        Vector128<byte> a2 = Vector128.Load(src + i + 32).AsByte();
+        Vector128<byte> a3 = Vector128.Load(src + i + 48).AsByte();
+        Vector128<int> b0 = (a0 & alphaMask).AsInt32();
+        Vector128<int> b1 = (a1 & alphaMask).AsInt32();
+        Vector128<int> b2 = (a2 & alphaMask).AsInt32();
+        Vector128<int> b3 = (a3 & alphaMask).AsInt32();
+        Vector128<short> c0 = Vector128_.PackSignedSaturate(b0, b1).AsInt16();
+        Vector128<short> c1 = Vector128_.PackSignedSaturate(b2, b3).AsInt16();
+        Vector128<byte> d = Vector128_.PackSignedSaturate(c0, c1).AsByte();
+        Vector128<byte> bits = Vector128.Equals(d, Vector128.Create((byte)0x80).AsByte());
+        uint mask = bits.ExtractMostSignificantBits();
         return mask != 0xFFFF;
     }
 
-    private static unsafe bool IsNoneOpaque32Bytes(byte* src, int i)
+    private static unsafe bool IsNonOpaque32BytesVector128(byte* src, int i)
     {
         Vector128<byte> alphaMask = Vector128.Create(0, 0, 0, 255, 0, 0, 0, 255, 0, 0, 0, 255, 0, 0, 0, 255);
 
-        Vector128<byte> a0 = Sse2.LoadVector128(src + i).AsByte();
-        Vector128<byte> a1 = Sse2.LoadVector128(src + i + 16).AsByte();
-        Vector128<int> b0 = Sse2.And(a0, alphaMask).AsInt32();
-        Vector128<int> b1 = Sse2.And(a1, alphaMask).AsInt32();
-        Vector128<short> c = Sse2.PackSignedSaturate(b0, b1).AsInt16();
-        Vector128<byte> d = Sse2.PackSignedSaturate(c, c).AsByte();
-        Vector128<byte> bits = Sse2.CompareEqual(d, Vector128.Create((byte)0x80).AsByte());
-        int mask = Sse2.MoveMask(bits);
+        Vector128<byte> a0 = Vector128.Load(src + i).AsByte();
+        Vector128<byte> a1 = Vector128.Load(src + i + 16).AsByte();
+        Vector128<int> b0 = (a0 & alphaMask).AsInt32();
+        Vector128<int> b1 = (a1 & alphaMask).AsInt32();
+        Vector128<short> c = Vector128_.PackSignedSaturate(b0, b1).AsInt16();
+        Vector128<byte> d = Vector128_.PackSignedSaturate(c, c).AsByte();
+        Vector128<byte> bits = Vector128.Equals(d, Vector128.Create((byte)0x80).AsByte());
+        uint mask = bits.ExtractMostSignificantBits();
         return mask != 0xFFFF;
     }
 }
diff --git a/src/ImageSharp/Formats/Webp/WebpConstants.cs b/src/ImageSharp/Formats/Webp/WebpConstants.cs
index 818c843ea9..f489899c68 100644
--- a/src/ImageSharp/Formats/Webp/WebpConstants.cs
+++ b/src/ImageSharp/Formats/Webp/WebpConstants.cs
@@ -11,22 +11,22 @@ internal static class WebpConstants
     /// <summary>
     /// The list of file extensions that equate to Webp.
     /// </summary>
-    public static readonly IEnumerable<string> FileExtensions = new[] { "webp" };
+    public static readonly IEnumerable<string> FileExtensions = ["webp"];
 
     /// <summary>
     /// The list of mimetypes that equate to a jpeg.
     /// </summary>
-    public static readonly IEnumerable<string> MimeTypes = new[] { "image/webp", };
+    public static readonly IEnumerable<string> MimeTypes = ["image/webp"];
 
     /// <summary>
     /// Signature which identifies a VP8 header.
     /// </summary>
     public static readonly byte[] Vp8HeaderMagicBytes =
-    {
+    [
         0x9D,
         0x01,
         0x2A
-    };
+    ];
 
     /// <summary>
     /// Signature byte which identifies a VP8L header.
@@ -37,23 +37,23 @@ internal static class WebpConstants
     /// The header bytes identifying RIFF file.
     /// </summary>
     public static readonly byte[] RiffFourCc =
-    {
+    [
         0x52, // R
         0x49, // I
         0x46, // F
         0x46 // F
-    };
+    ];
 
     /// <summary>
     /// The header bytes identifying a Webp.
     /// </summary>
     public static readonly byte[] WebpHeader =
-    {
+    [
         0x57, // W
         0x45, // E
         0x42, // B
         0x50 // P
-    };
+    ];
 
     /// <summary>
     /// The header bytes identifying a Webp.
@@ -164,16 +164,16 @@ internal static class WebpConstants
 
     public const int CodeLengthRepeatCode = 16;
 
-    public static readonly int[] CodeLengthExtraBits = { 2, 3, 7 };
+    public static readonly int[] CodeLengthExtraBits = [2, 3, 7];
 
-    public static readonly int[] CodeLengthRepeatOffsets = { 3, 3, 11 };
+    public static readonly int[] CodeLengthRepeatOffsets = [3, 3, 11];
 
     public static readonly int[] AlphabetSize =
-    {
+    [
         NumLiteralCodes + NumLengthCodes,
         NumLiteralCodes, NumLiteralCodes, NumLiteralCodes,
         NumDistanceCodes
-    };
+    ];
 
     public const int NumMbSegments = 4;
 
@@ -270,9 +270,9 @@ internal static class WebpConstants
     /// </summary>
     public const int Vp8MaxPartition0Size = 1 << 19;
 
-    public static readonly short[] Vp8FixedCostsUv = { 302, 984, 439, 642 };
+    public static readonly short[] Vp8FixedCostsUv = [302, 984, 439, 642];
 
-    public static readonly short[] Vp8FixedCostsI16 = { 663, 919, 872, 919 };
+    public static readonly short[] Vp8FixedCostsI16 = [663, 919, 872, 919];
 
     /// <summary>
     /// Distortion multiplier (equivalent of lambda).
@@ -284,31 +284,31 @@ internal static class WebpConstants
     /// Simple filter(1):  up to 2 luma samples are read and 1 is written.
     /// Complex filter(2): up to 4 luma samples are read and 3 are written. Same for U/V, so it's 8 samples total (because of the 2x upsampling).
     /// </summary>
-    public static readonly byte[] FilterExtraRows = { 0, 2, 8 };
+    public static readonly byte[] FilterExtraRows = [0, 2, 8];
 
     // Paragraph 9.9
     public static readonly int[] Vp8EncBands =
-    {
+    [
         0, 1, 2, 3, 6, 4, 5, 6, 6, 6, 6, 6, 6, 6, 6, 7, 0
-    };
+    ];
 
     public static readonly short[] Scan =
-    {
+    [
         0 + (0 * Bps), 4 + (0 * Bps), 8 + (0 * Bps), 12 + (0 * Bps),
         0 + (4 * Bps), 4 + (4 * Bps), 8 + (4 * Bps), 12 + (4 * Bps),
         0 + (8 * Bps), 4 + (8 * Bps), 8 + (8 * Bps), 12 + (8 * Bps),
         0 + (12 * Bps), 4 + (12 * Bps), 8 + (12 * Bps), 12 + (12 * Bps)
-    };
+    ];
 
     // Residual decoding (Paragraph 13.2 / 13.3)
-    public static readonly byte[] Cat3 = { 173, 148, 140 };
-    public static readonly byte[] Cat4 = { 176, 155, 140, 135 };
-    public static readonly byte[] Cat5 = { 180, 157, 141, 134, 130 };
-    public static readonly byte[] Cat6 = { 254, 254, 243, 230, 196, 177, 153, 140, 133, 130, 129 };
-    public static readonly byte[] Zigzag = { 0, 1, 4, 8, 5, 2, 3, 6, 9, 12, 13, 10, 7, 11, 14, 15 };
+    public static readonly byte[] Cat3 = [173, 148, 140];
+    public static readonly byte[] Cat4 = [176, 155, 140, 135];
+    public static readonly byte[] Cat5 = [180, 157, 141, 134, 130];
+    public static readonly byte[] Cat6 = [254, 254, 243, 230, 196, 177, 153, 140, 133, 130, 129];
+    public static readonly byte[] Zigzag = [0, 1, 4, 8, 5, 2, 3, 6, 9, 12, 13, 10, 7, 11, 14, 15];
 
     public static readonly sbyte[] YModesIntra4 =
-    {
+    [
         -0, 1,
         -1, 2,
         -2, 3,
@@ -318,5 +318,5 @@ internal static class WebpConstants
         -6, 7,
         -7, 8,
         -8, -9
-    };
+    ];
 }
diff --git a/src/ImageSharp/Formats/Webp/WebpDecoder.cs b/src/ImageSharp/Formats/Webp/WebpDecoder.cs
index dfbf4ef0e6..48d725b26e 100644
--- a/src/ImageSharp/Formats/Webp/WebpDecoder.cs
+++ b/src/ImageSharp/Formats/Webp/WebpDecoder.cs
@@ -17,7 +17,7 @@ public sealed class WebpDecoder : SpecializedImageDecoder<WebpDecoderOptions>
     /// <summary>
     /// Gets the shared instance.
     /// </summary>
-    public static WebpDecoder Instance { get; } = new WebpDecoder();
+    public static WebpDecoder Instance { get; } = new();
 
     /// <inheritdoc/>
     protected override ImageInfo Identify(DecoderOptions options, Stream stream, CancellationToken cancellationToken)
@@ -25,7 +25,7 @@ public sealed class WebpDecoder : SpecializedImageDecoder<WebpDecoderOptions>
         Guard.NotNull(options, nameof(options));
         Guard.NotNull(stream, nameof(stream));
 
-        using WebpDecoderCore decoder = new WebpDecoderCore(new WebpDecoderOptions() { GeneralOptions = options });
+        using WebpDecoderCore decoder = new(new WebpDecoderOptions { GeneralOptions = options });
         return decoder.Identify(options.Configuration, stream, cancellationToken);
     }
 
@@ -35,7 +35,7 @@ public sealed class WebpDecoder : SpecializedImageDecoder<WebpDecoderOptions>
         Guard.NotNull(options, nameof(options));
         Guard.NotNull(stream, nameof(stream));
 
-        using WebpDecoderCore decoder = new WebpDecoderCore(options);
+        using WebpDecoderCore decoder = new(options);
         Image<TPixel> image = decoder.Decode<TPixel>(options.GeneralOptions.Configuration, stream, cancellationToken);
 
         ScaleToTargetSize(options.GeneralOptions, image);
@@ -52,5 +52,5 @@ public sealed class WebpDecoder : SpecializedImageDecoder<WebpDecoderOptions>
         => this.Decode<Rgba32>(options, stream, cancellationToken);
 
     /// <inheritdoc/>
-    protected override WebpDecoderOptions CreateDefaultSpecializedOptions(DecoderOptions options) => new WebpDecoderOptions { GeneralOptions = options };
+    protected override WebpDecoderOptions CreateDefaultSpecializedOptions(DecoderOptions options) => new() { GeneralOptions = options };
 }
diff --git a/src/ImageSharp/Formats/Webp/WebpDecoderCore.cs b/src/ImageSharp/Formats/Webp/WebpDecoderCore.cs
index 9ca6e2bee3..51379a32ae 100644
--- a/src/ImageSharp/Formats/Webp/WebpDecoderCore.cs
+++ b/src/ImageSharp/Formats/Webp/WebpDecoderCore.cs
@@ -220,7 +220,7 @@ internal sealed class WebpDecoderCore : ImageDecoderCore, IDisposable
                     else
                     {
                         // Ignore unknown chunks.
-                        uint chunkSize = ReadChunkSize(stream, buffer);
+                        uint chunkSize = ReadChunkSize(stream, buffer, false);
                         stream.Skip((int)chunkSize);
                     }
                 }
@@ -498,9 +498,10 @@ internal sealed class WebpDecoderCore : ImageDecoderCore, IDisposable
     /// </summary>
     /// <param name="stream">The stream to decode from.</param>
     /// <param name="buffer">Temporary buffer.</param>
+    /// <param name="required">If true, the chunk size is required to be read, otherwise it can be skipped.</param>
     /// <returns>The chunk size in bytes.</returns>
     /// <exception cref="ImageFormatException">Invalid data.</exception>
-    private static uint ReadChunkSize(BufferedReadStream stream, Span<byte> buffer)
+    private static uint ReadChunkSize(BufferedReadStream stream, Span<byte> buffer, bool required = true)
     {
         if (stream.Read(buffer, 0, 4) == 4)
         {
@@ -508,7 +509,13 @@ internal sealed class WebpDecoderCore : ImageDecoderCore, IDisposable
             return (chunkSize % 2 == 0) ? chunkSize : chunkSize + 1;
         }
 
-        throw new ImageFormatException("Invalid Webp data.");
+        if (required)
+        {
+            throw new ImageFormatException("Invalid Webp data.");
+        }
+
+        // Return the size of the remaining data in the stream.
+        return (uint)(stream.Length - stream.Position);
     }
 
     /// <inheritdoc/>
diff --git a/src/ImageSharp/Formats/Webp/WebpDecoderOptions.cs b/src/ImageSharp/Formats/Webp/WebpDecoderOptions.cs
index 8840805b1f..6fb15acbb4 100644
--- a/src/ImageSharp/Formats/Webp/WebpDecoderOptions.cs
+++ b/src/ImageSharp/Formats/Webp/WebpDecoderOptions.cs
@@ -9,7 +9,7 @@ namespace SixLabors.ImageSharp.Formats.Webp;
 public sealed class WebpDecoderOptions : ISpecializedDecoderOptions
 {
     /// <inheritdoc/>
-    public DecoderOptions GeneralOptions { get; init; } = new DecoderOptions();
+    public DecoderOptions GeneralOptions { get; init; } = new();
 
     /// <summary>
     /// Gets the flag to decide how to handle the background color Animation Chunk.
diff --git a/src/ImageSharp/Formats/Webp/WebpEncoderCore.cs b/src/ImageSharp/Formats/Webp/WebpEncoderCore.cs
index b3270786d7..788a90a829 100644
--- a/src/ImageSharp/Formats/Webp/WebpEncoderCore.cs
+++ b/src/ImageSharp/Formats/Webp/WebpEncoderCore.cs
@@ -132,6 +132,11 @@ internal sealed class WebpEncoderCore
         Guard.NotNull(image, nameof(image));
         Guard.NotNull(stream, nameof(stream));
 
+        if (image.Width > WebpConstants.MaxDimension || image.Height > WebpConstants.MaxDimension)
+        {
+            WebpThrowHelper.ThrowDimensionsTooLarge(image.Width, image.Height);
+        }
+
         bool lossless;
         if (this.fileFormat is not null)
         {
diff --git a/src/ImageSharp/Formats/Webp/WebpFormat.cs b/src/ImageSharp/Formats/Webp/WebpFormat.cs
index 1764182c51..9853ce7d79 100644
--- a/src/ImageSharp/Formats/Webp/WebpFormat.cs
+++ b/src/ImageSharp/Formats/Webp/WebpFormat.cs
@@ -15,7 +15,7 @@ public sealed class WebpFormat : IImageFormat<WebpMetadata, WebpFrameMetadata>
     /// <summary>
     /// Gets the shared instance.
     /// </summary>
-    public static WebpFormat Instance { get; } = new WebpFormat();
+    public static WebpFormat Instance { get; } = new();
 
     /// <inheritdoc/>
     public string Name => "WEBP";
@@ -30,8 +30,8 @@ public sealed class WebpFormat : IImageFormat<WebpMetadata, WebpFrameMetadata>
     public IEnumerable<string> FileExtensions => WebpConstants.FileExtensions;
 
     /// <inheritdoc/>
-    public WebpMetadata CreateDefaultFormatMetadata() => new WebpMetadata();
+    public WebpMetadata CreateDefaultFormatMetadata() => new();
 
     /// <inheritdoc/>
-    public WebpFrameMetadata CreateDefaultFormatFrameMetadata() => new WebpFrameMetadata();
+    public WebpFrameMetadata CreateDefaultFormatFrameMetadata() => new();
 }
diff --git a/src/ImageSharp/Formats/Webp/WebpFrameMetadata.cs b/src/ImageSharp/Formats/Webp/WebpFrameMetadata.cs
index 3f976a6401..8a6b30ab44 100644
--- a/src/ImageSharp/Formats/Webp/WebpFrameMetadata.cs
+++ b/src/ImageSharp/Formats/Webp/WebpFrameMetadata.cs
@@ -1,6 +1,7 @@
 // Copyright (c) Six Labors.
 // Licensed under the Six Labors Split License.
 
+using System.Numerics;
 using SixLabors.ImageSharp.PixelFormats;
 
 namespace SixLabors.ImageSharp.Formats.Webp;
@@ -66,7 +67,7 @@ public class WebpFrameMetadata : IFormatFrameMetadata<WebpFrameMetadata>
         };
 
     /// <inheritdoc/>
-    public void AfterFrameApply<TPixel>(ImageFrame<TPixel> source, ImageFrame<TPixel> destination)
+    public void AfterFrameApply<TPixel>(ImageFrame<TPixel> source, ImageFrame<TPixel> destination, Matrix4x4 matrix)
         where TPixel : unmanaged, IPixel<TPixel>
     {
     }
diff --git a/src/ImageSharp/Formats/Webp/WebpLookupTables.cs b/src/ImageSharp/Formats/Webp/WebpLookupTables.cs
index a69bcfd006..64c97f7d8a 100644
--- a/src/ImageSharp/Formats/Webp/WebpLookupTables.cs
+++ b/src/ImageSharp/Formats/Webp/WebpLookupTables.cs
@@ -19,7 +19,8 @@ internal static class WebpLookupTables
     // Compute susceptibility based on DCT-coeff histograms:
     // the higher, the "easier" the macroblock is to compress.
     public static readonly int[] Vp8DspScan =
-    {
+    [
+
         // Luma
         0 + (0 * WebpConstants.Bps),  4 + (0 * WebpConstants.Bps), 8 + (0 * WebpConstants.Bps), 12 + (0 * WebpConstants.Bps),
         0 + (4 * WebpConstants.Bps),  4 + (4 * WebpConstants.Bps), 8 + (4 * WebpConstants.Bps), 12 + (4 * WebpConstants.Bps),
@@ -28,22 +29,23 @@ internal static class WebpLookupTables
 
         0 + (0 * WebpConstants.Bps),   4 + (0 * WebpConstants.Bps), 0 + (4 * WebpConstants.Bps),  4 + (4 * WebpConstants.Bps), // U
         8 + (0 * WebpConstants.Bps),  12 + (0 * WebpConstants.Bps), 8 + (4 * WebpConstants.Bps), 12 + (4 * WebpConstants.Bps) // V
-    };
+    ];
 
     public static readonly short[] Vp8Scan =
-    {
+    [
+
         // Luma
         0 + (0 * WebpConstants.Bps), 4 + (0 * WebpConstants.Bps), 8 + (0 * WebpConstants.Bps), 12 + (0 * WebpConstants.Bps),
         0 + (4 * WebpConstants.Bps), 4 + (4 * WebpConstants.Bps), 8 + (4 * WebpConstants.Bps), 12 + (4 * WebpConstants.Bps),
         0 + (8 * WebpConstants.Bps), 4 + (8 * WebpConstants.Bps), 8 + (8 * WebpConstants.Bps), 12 + (8 * WebpConstants.Bps),
-        0 + (12 * WebpConstants.Bps), 4 + (12 * WebpConstants.Bps), 8 + (12 * WebpConstants.Bps), 12 + (12 * WebpConstants.Bps),
-    };
+        0 + (12 * WebpConstants.Bps), 4 + (12 * WebpConstants.Bps), 8 + (12 * WebpConstants.Bps), 12 + (12 * WebpConstants.Bps)
+    ];
 
     public static readonly short[] Vp8ScanUv =
-    {
+    [
         0 + (0 * WebpConstants.Bps), 4 + (0 * WebpConstants.Bps), 0 + (4 * WebpConstants.Bps),  4 + (4 * WebpConstants.Bps), // U
         8 + (0 * WebpConstants.Bps), 12 + (0 * WebpConstants.Bps), 8 + (4 * WebpConstants.Bps), 12 + (4 * WebpConstants.Bps) // V
-    };
+    ];
 
     [MethodImpl(InliningOptions.ShortMethod)]
     public static byte Abs0(int x) => Abs0Table[x + 255];
@@ -60,7 +62,7 @@ internal static class WebpLookupTables
     // fixed costs for coding levels, deduce from the coding tree.
     // This is only the part that doesn't depend on the probability state.
     public static readonly short[] Vp8LevelFixedCosts =
-    {
+    [
         0, 256, 256, 256, 256, 432, 618, 630, 731, 640, 640, 828, 901, 948, 1021, 1101, 1174, 1221, 1294, 1042,
         1085, 1115, 1158, 1202, 1245, 1275, 1318, 1337, 1380, 1410, 1453, 1497, 1540, 1570, 1613, 1280, 1295,
         1317, 1332, 1358, 1373, 1395, 1410, 1454, 1469, 1491, 1506, 1532, 1547, 1569, 1584, 1601, 1616, 1638,
@@ -182,7 +184,7 @@ internal static class WebpLookupTables
         7403, 7409, 7429, 7435, 7444, 7450, 7461, 7467, 7476, 7482, 7505, 7511, 7520, 7526, 7537, 7543, 7552,
         7558, 7578, 7584, 7593, 7599, 7610, 7616, 7625, 7631, 7656, 7662, 7671, 7677, 7688, 7694, 7703, 7709,
         7729, 7735, 7744, 7750, 7761
-    };
+    ];
 
     // This table gives, for a given sharpness, the filtering strength to be
     // used (at least) in order to filter a given edge step delta.
@@ -239,8 +241,9 @@ internal static class WebpLookupTables
     };
 
     // This uses C#'s compiler optimization to refer to assembly's static data directly.
-    public static ReadOnlySpan<byte> Norm => new byte[]
-    {
+    public static ReadOnlySpan<byte> Norm =>
+    [
+
         // renorm_sizes[i] = 8 - log2(i)
         7, 6, 6, 5, 5, 5, 5, 4, 4, 4, 4, 4, 4, 4, 4,
         3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3,
@@ -251,11 +254,12 @@ internal static class WebpLookupTables
         1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
         1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
         0
-    };
+    ];
 
     // This uses C#'s compiler optimization to refer to assembly's static data directly.
-    public static ReadOnlySpan<byte> NewRange => new byte[]
-    {
+    public static ReadOnlySpan<byte> NewRange =>
+    [
+
         // range = ((range + 1) << kVP8Log2Range[range]) - 1
         127, 127, 191, 127, 159, 191, 223, 127, 143, 159, 175, 191, 207, 223, 239,
         127, 135, 143, 151, 159, 167, 175, 183, 191, 199, 207, 215, 223, 231, 239,
@@ -266,10 +270,10 @@ internal static class WebpLookupTables
         181, 183, 185, 187, 189, 191, 193, 195, 197, 199, 201, 203, 205, 207, 209,
         211, 213, 215, 217, 219, 221, 223, 225, 227, 229, 231, 233, 235, 237, 239,
         241, 243, 245, 247, 249, 251, 253, 127
-    };
+    ];
 
     public static readonly ushort[] Vp8EntropyCost =
-    {
+    [
         1792, 1792, 1792, 1536, 1536, 1408, 1366, 1280, 1280, 1216,
         1178, 1152, 1110, 1076, 1061, 1024, 1024,  992,  968,  951,
         939,  911,  896,  878,  871,  854,  838,  820,  811,  794,
@@ -296,35 +300,35 @@ internal static class WebpLookupTables
         41,   40,   38,   36,   35,   33,   32,   30,   29,   27,
         25,   24,   22,   21,   19,   18,   16,   15,   13,   12,
         10,    9,    7,    6,    4,    3
-    };
+    ];
 
     public static readonly ushort[][] Vp8LevelCodes =
-    {
-        new ushort[] { 0x001, 0x000 }, new ushort[] { 0x007, 0x001 }, new ushort[] { 0x00f, 0x005 },
-        new ushort[] { 0x00f, 0x00d }, new ushort[] { 0x033, 0x003 }, new ushort[] { 0x033, 0x003 }, new ushort[] { 0x033, 0x023 },
-        new ushort[] { 0x033, 0x023 }, new ushort[] { 0x033, 0x023 }, new ushort[] { 0x033, 0x023 }, new ushort[] { 0x0d3, 0x013 },
-        new ushort[] { 0x0d3, 0x013 }, new ushort[] { 0x0d3, 0x013 }, new ushort[] { 0x0d3, 0x013 }, new ushort[] { 0x0d3, 0x013 },
-        new ushort[] { 0x0d3, 0x013 }, new ushort[] { 0x0d3, 0x013 }, new ushort[] { 0x0d3, 0x013 }, new ushort[] { 0x0d3, 0x093 },
-        new ushort[] { 0x0d3, 0x093 }, new ushort[] { 0x0d3, 0x093 }, new ushort[] { 0x0d3, 0x093 }, new ushort[] { 0x0d3, 0x093 },
-        new ushort[] { 0x0d3, 0x093 }, new ushort[] { 0x0d3, 0x093 }, new ushort[] { 0x0d3, 0x093 }, new ushort[] { 0x0d3, 0x093 },
-        new ushort[] { 0x0d3, 0x093 }, new ushort[] { 0x0d3, 0x093 }, new ushort[] { 0x0d3, 0x093 }, new ushort[] { 0x0d3, 0x093 },
-        new ushort[] { 0x0d3, 0x093 }, new ushort[] { 0x0d3, 0x093 }, new ushort[] { 0x0d3, 0x093 }, new ushort[] { 0x153, 0x053 },
-        new ushort[] { 0x153, 0x053 }, new ushort[] { 0x153, 0x053 }, new ushort[] { 0x153, 0x053 }, new ushort[] { 0x153, 0x053 },
-        new ushort[] { 0x153, 0x053 }, new ushort[] { 0x153, 0x053 }, new ushort[] { 0x153, 0x053 }, new ushort[] { 0x153, 0x053 },
-        new ushort[] { 0x153, 0x053 }, new ushort[] { 0x153, 0x053 }, new ushort[] { 0x153, 0x053 }, new ushort[] { 0x153, 0x053 },
-        new ushort[] { 0x153, 0x053 }, new ushort[] { 0x153, 0x053 }, new ushort[] { 0x153, 0x053 }, new ushort[] { 0x153, 0x053 },
-        new ushort[] { 0x153, 0x053 }, new ushort[] { 0x153, 0x053 }, new ushort[] { 0x153, 0x053 }, new ushort[] { 0x153, 0x053 },
-        new ushort[] { 0x153, 0x053 }, new ushort[] { 0x153, 0x053 }, new ushort[] { 0x153, 0x053 }, new ushort[] { 0x153, 0x053 },
-        new ushort[] { 0x153, 0x053 }, new ushort[] { 0x153, 0x053 }, new ushort[] { 0x153, 0x053 }, new ushort[] { 0x153, 0x053 },
-        new ushort[] { 0x153, 0x053 }, new ushort[] { 0x153, 0x053 }, new ushort[] { 0x153, 0x053 }, new ushort[] { 0x153, 0x153 },
-    };
+    [
+        [0x001, 0x000], [0x007, 0x001], [0x00f, 0x005],
+        [0x00f, 0x00d], [0x033, 0x003], [0x033, 0x003], [0x033, 0x023],
+        [0x033, 0x023], [0x033, 0x023], [0x033, 0x023], [0x0d3, 0x013],
+        [0x0d3, 0x013], [0x0d3, 0x013], [0x0d3, 0x013], [0x0d3, 0x013],
+        [0x0d3, 0x013], [0x0d3, 0x013], [0x0d3, 0x013], [0x0d3, 0x093],
+        [0x0d3, 0x093], [0x0d3, 0x093], [0x0d3, 0x093], [0x0d3, 0x093],
+        [0x0d3, 0x093], [0x0d3, 0x093], [0x0d3, 0x093], [0x0d3, 0x093],
+        [0x0d3, 0x093], [0x0d3, 0x093], [0x0d3, 0x093], [0x0d3, 0x093],
+        [0x0d3, 0x093], [0x0d3, 0x093], [0x0d3, 0x093], [0x153, 0x053],
+        [0x153, 0x053], [0x153, 0x053], [0x153, 0x053], [0x153, 0x053],
+        [0x153, 0x053], [0x153, 0x053], [0x153, 0x053], [0x153, 0x053],
+        [0x153, 0x053], [0x153, 0x053], [0x153, 0x053], [0x153, 0x053],
+        [0x153, 0x053], [0x153, 0x053], [0x153, 0x053], [0x153, 0x053],
+        [0x153, 0x053], [0x153, 0x053], [0x153, 0x053], [0x153, 0x053],
+        [0x153, 0x053], [0x153, 0x053], [0x153, 0x053], [0x153, 0x053],
+        [0x153, 0x053], [0x153, 0x053], [0x153, 0x053], [0x153, 0x053],
+        [0x153, 0x053], [0x153, 0x053], [0x153, 0x053], [0x153, 0x153]
+    ];
 
     /// <summary>
     /// Lookup table for small values of log2(int).
     /// </summary>
     public static readonly float[] Log2Table =
-    {
-      0.0000000000000000f, 0.0000000000000000f,
+    [
+        0.0000000000000000f, 0.0000000000000000f,
       1.0000000000000000f, 1.5849625007211560f,
       2.0000000000000000f, 2.3219280948873621f,
       2.5849625007211560f, 2.8073549220576041f,
@@ -452,11 +456,11 @@ internal static class WebpLookupTables
       7.9657842846620869f, 7.9715435539507719f,
       7.9772799234999167f, 7.9829935746943103f,
       7.9886846867721654f, 7.9943534368588577f
-    };
+    ];
 
     public static readonly float[] SLog2Table =
-    {
-      0.00000000f,    0.00000000f,  2.00000000f,   4.75488750f,
+    [
+        0.00000000f,    0.00000000f,  2.00000000f,   4.75488750f,
       8.00000000f,   11.60964047f,  15.50977500f,  19.65148445f,
       24.00000000f,  28.52932501f,  33.21928095f,  38.05374781f,
       43.01955001f,  48.10571634f,  53.30296891f,  58.60335893f,
@@ -520,10 +524,10 @@ internal static class WebpLookupTables
       1935.09991037f, 1944.47629506f, 1953.85856831f, 1963.24670620f,
       1972.64068498f, 1982.04048108f, 1991.44607117f, 2000.85743204f,
       2010.27454072f, 2019.69737440f, 2029.12591044f, 2038.56012640f
-    };
+    ];
 
     public static readonly int[] CodeToPlane =
-    {
+    [
         0x18, 0x07, 0x17, 0x19, 0x28, 0x06, 0x27, 0x29, 0x16, 0x1a,
         0x26, 0x2a, 0x38, 0x05, 0x37, 0x39, 0x15, 0x1b, 0x36, 0x3a,
         0x25, 0x2b, 0x48, 0x04, 0x47, 0x49, 0x14, 0x1c, 0x35, 0x3b,
@@ -536,10 +540,10 @@ internal static class WebpLookupTables
         0x31, 0x3f, 0x63, 0x6d, 0x52, 0x5e, 0x00, 0x74, 0x7c, 0x41,
         0x4f, 0x10, 0x20, 0x62, 0x6e, 0x30, 0x73, 0x7d, 0x51, 0x5f,
         0x40, 0x72, 0x7e, 0x61, 0x6f, 0x50, 0x71, 0x7f, 0x60, 0x70
-    };
+    ];
 
     public static readonly uint[] PlaneToCodeLut =
-    {
+    [
         96,   73,  55,  39,  23,  13,   5,  1,  255, 255, 255, 255, 255, 255, 255, 255,
         101,  78,  58,  42,  26,  16,   8,  2,    0,   3,  9,   17,  27,  43,  59,  79,
         102,  86,  62,  46,  32,  20,  10,  6,    4,   7,  11,  21,  33,  47,  63,  87,
@@ -548,11 +552,11 @@ internal static class WebpLookupTables
         115, 108,  94,  76,  64,  50,  44,  40,  34,  41,  45,  51,  65,  77,  95, 109,
         118, 113, 103,  92,  80,  68,  60,  56,  54,  57,  61,  69,  81,  93, 104, 114,
         119, 116, 111, 106,  97,  88,  84,  74,  72,  75,  85,  89,  98, 107, 112, 117
-    };
+    ];
 
     // 31 ^ clz(i)
-    public static ReadOnlySpan<byte> LogTable8Bit => new byte[]
-    {
+    public static ReadOnlySpan<byte> LogTable8Bit =>
+    [
         0, 0, 1, 1, 2, 2, 2, 2, 3, 3, 3, 3, 3, 3, 3, 3,
         4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4,
         5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5,
@@ -569,12 +573,12 @@ internal static class WebpLookupTables
         7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7,
         7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7,
         7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7
-    };
+    ];
 
     // Paragraph 14.1
     // This uses C#'s compiler optimization to refer to assembly's static data directly.
-    public static ReadOnlySpan<byte> DcTable => new byte[]
-    {
+    public static ReadOnlySpan<byte> DcTable =>
+    [
         4,     5,   6,   7,   8,   9,  10,  10,
         11,   12,  13,  14,  15,  16,  17,  17,
         18,   19,  20,  20,  21,  21,  22,  22,
@@ -591,11 +595,11 @@ internal static class WebpLookupTables
         104, 106, 108, 110, 112, 114, 116, 118,
         122, 124, 126, 128, 130, 132, 134, 136,
         138, 140, 143, 145, 148, 151, 154, 157
-    };
+    ];
 
     // Paragraph 14.1
     public static readonly ushort[] AcTable =
-    {
+    [
         4,     5,   6,   7,   8,   9,  10,  11,
         12,   13,  14,  15,  16,  17,  18,  19,
         20,   21,  22,  23,  24,  25,  26,  27,
@@ -612,10 +616,10 @@ internal static class WebpLookupTables
         181, 185, 189, 193, 197, 201, 205, 209,
         213, 217, 221, 225, 229, 234, 239, 245,
         249, 254, 259, 264, 269, 274, 279, 284
-    };
+    ];
 
     public static readonly ushort[] AcTable2 =
-    {
+    [
         8,     8,   9,  10,  12,  13,  15,  17,
         18,   20,  21,  23,  24,  26,  27,  29,
         31,   32,  34,  35,  37,  38,  40,  41,
@@ -632,7 +636,7 @@ internal static class WebpLookupTables
         280, 286, 292, 299, 305, 311, 317, 323,
         330, 336, 342, 348, 354, 362, 370, 379,
         385, 393, 401, 409, 416, 424, 432, 440
-    };
+    ];
 
     // Paragraph 13
     public static readonly byte[,,,] CoeffsUpdateProba =
@@ -981,7 +985,7 @@ internal static class WebpLookupTables
     };
 
     public static readonly (int Code, int ExtraBits)[] PrefixEncodeCode =
-    {
+    [
         (0, 0), (0, 0), (1, 0), (2, 0), (3, 0), (4, 1), (4, 1), (5, 1),
         (5, 1), (6, 2), (6, 2), (6, 2), (6, 2), (7, 2), (7, 2), (7, 2),
         (7, 2), (8, 3), (8, 3), (8, 3), (8, 3), (8, 3), (8, 3), (8, 3),
@@ -1045,13 +1049,13 @@ internal static class WebpLookupTables
         (17, 7), (17, 7), (17, 7), (17, 7), (17, 7), (17, 7), (17, 7), (17, 7),
         (17, 7), (17, 7), (17, 7), (17, 7), (17, 7), (17, 7), (17, 7), (17, 7),
         (17, 7), (17, 7), (17, 7), (17, 7), (17, 7), (17, 7), (17, 7), (17, 7),
-        (17, 7), (17, 7), (17, 7), (17, 7), (17, 7), (17, 7), (17, 7), (17, 7),
-    };
+        (17, 7), (17, 7), (17, 7), (17, 7), (17, 7), (17, 7), (17, 7), (17, 7)
+    ];
 
     // This uses C#'s compiler optimization to refer to assembly's static data directly.
-    public static ReadOnlySpan<byte> PrefixEncodeExtraBitsValue => new byte[]
-    {
-       0,  0,  0,  0,  0,  0,  1,  0,  1,  0,  1,  2,  3,  0,  1,  2,  3,
+    public static ReadOnlySpan<byte> PrefixEncodeExtraBitsValue =>
+    [
+        0,  0,  0,  0,  0,  0,  1,  0,  1,  0,  1,  2,  3,  0,  1,  2,  3,
        0,  1,  2,  3,  4,  5,  6,  7,  0,  1,  2,  3,  4,  5,  6,  7,
        0,  1,  2,  3,  4,  5,  6,  7,  8,  9, 10, 11, 12, 13, 14, 15,
        0,  1,  2,  3,  4,  5,  6,  7,  8,  9, 10, 11, 12, 13, 14, 15,
@@ -1084,7 +1088,7 @@ internal static class WebpLookupTables
        90, 91, 92, 93, 94, 95, 96, 97, 98, 99, 100, 101, 102, 103, 104,
        105, 106, 107, 108, 109, 110, 111, 112, 113, 114, 115, 116, 117,
        118, 119, 120, 121, 122, 123, 124, 125, 126
-    };
+    ];
 
     // Following table is (1 << AlphaFix) / a. The (v * InvAlpha[a]) >> AlphaFix
     // formula is then equal to v / a in most (99.6%) cases. Note that this table
@@ -1094,7 +1098,7 @@ internal static class WebpLookupTables
     // with ai in [0..255] and pi in [0..1<<GammaFix). The constraint to avoid
     // overflow is: GammaFix + AlphaFix <= 31.
     public static readonly uint[] InvAlpha =
-    {
+    [
         0,  /* alpha = 0 */
         524288, 262144, 174762, 131072, 104857, 87381, 74898, 65536,
         58254, 52428, 47662, 43690, 40329, 37449, 34952, 32768,
@@ -1224,7 +1228,7 @@ internal static class WebpLookupTables
         523, 523, 522, 522, 521, 521, 520, 520,
         519, 519, 518, 518, 517, 517, 516, 516,
         515, 515, 514, 514
-    };
+    ];
 
     static WebpLookupTables()
     {
@@ -1245,8 +1249,8 @@ internal static class WebpLookupTables
     }
 
     // This uses C#'s compiler optimization to refer to assembly's static data directly.
-    private static ReadOnlySpan<byte> Abs0Table => new byte[]
-    {
+    private static ReadOnlySpan<byte> Abs0Table =>
+    [
         0xff, 0xfe, 0xfd, 0xfc, 0xfb, 0xfa, 0xf9, 0xf8, 0xf7, 0xf6, 0xf5, 0xf4, 0xf3, 0xf2, 0xf1, 0xf0, 0xef,
         0xee, 0xed, 0xec, 0xeb, 0xea, 0xe9, 0xe8, 0xe7, 0xe6, 0xe5, 0xe4, 0xe3, 0xe2, 0xe1, 0xe0, 0xdf, 0xde,
         0xdd, 0xdc, 0xdb, 0xda, 0xd9, 0xd8, 0xd7, 0xd6, 0xd5, 0xd4, 0xd3, 0xd2, 0xd1, 0xd0, 0xcf, 0xce, 0xcd,
@@ -1278,11 +1282,11 @@ internal static class WebpLookupTables
         0xdd, 0xde, 0xdf, 0xe0, 0xe1, 0xe2, 0xe3, 0xe4, 0xe5, 0xe6, 0xe7, 0xe8, 0xe9, 0xea, 0xeb, 0xec, 0xed,
         0xee, 0xef, 0xf0, 0xf1, 0xf2, 0xf3, 0xf4, 0xf5, 0xf6, 0xf7, 0xf8, 0xf9, 0xfa, 0xfb, 0xfc, 0xfd, 0xfe,
         0xff
-    };
+    ];
 
     // This uses C#'s compiler optimization to refer to assembly's static data directly.
-    private static ReadOnlySpan<byte> Clip1Table => new byte[]
-    {
+    private static ReadOnlySpan<byte> Clip1Table =>
+    [
         0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
         0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
         0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
@@ -1329,11 +1333,11 @@ internal static class WebpLookupTables
         0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
         0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
         0xff
-    };
+    ];
 
     // This uses C#'s compiler optimization to refer to assembly's static data directly.
-    private static ReadOnlySpan<sbyte> Sclip1Table => new sbyte[]
-    {
+    private static ReadOnlySpan<sbyte> Sclip1Table =>
+    [
         -128, -128, -128, -128, -128, -128, -128, -128, -128, -128, -128, -128, -128, -128, -128, -128, -128,
         -128, -128, -128, -128, -128, -128, -128, -128, -128, -128, -128, -128, -128, -128, -128, -128, -128,
         -128, -128, -128, -128, -128, -128, -128, -128, -128, -128, -128, -128, -128, -128, -128, -128, -128,
@@ -1441,11 +1445,11 @@ internal static class WebpLookupTables
         127, 127, 127, 127, 127, 127, 127, 127, 127, 127, 127, 127, 127, 127, 127, 127, 127, 127, 127, 127, 127,
         127, 127, 127, 127, 127, 127, 127, 127, 127, 127, 127, 127, 127, 127, 127, 127, 127, 127, 127, 127, 127,
         127, 127, 127, 127, 127, 127, 127, 127, 127
-    };
+    ];
 
     // This uses C#'s compiler optimization to refer to assembly's static data directly.
-    private static ReadOnlySpan<sbyte> Sclip2Table => new sbyte[]
-    {
+    private static ReadOnlySpan<sbyte> Sclip2Table =>
+    [
         -16, -16, -16, -16, -16, -16, -16, -16, -16, -16, -16, -16, -16, -16, -16, -16, -16, -16, -16, -16, -16,
         -16, -16, -16, -16, -16, -16, -16, -16, -16, -16, -16, -16, -16, -16, -16, -16, -16, -16, -16, -16, -16,
         -16, -16, -16, -16, -16, -16, -16, -16, -16, -16, -16, -16, -16, -16, -16, -16, -16, -16, -16, -16, -16,
@@ -1456,214 +1460,214 @@ internal static class WebpLookupTables
         15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
         15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
         15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15
-    };
+    ];
 
     private static void InitializeModesProbabilities()
     {
         // Paragraph 11.5
-        ModesProba[0, 0] = new byte[] { 231, 120, 48, 89, 115, 113, 120, 152, 112 };
-        ModesProba[0, 1] = new byte[] { 152, 179, 64, 126, 170, 118, 46, 70, 95 };
-        ModesProba[0, 2] = new byte[] { 175, 69, 143, 80, 85, 82, 72, 155, 103 };
-        ModesProba[0, 3] = new byte[] { 56, 58, 10, 171, 218, 189, 17, 13, 152 };
-        ModesProba[0, 4] = new byte[] { 114, 26, 17, 163, 44, 195, 21, 10, 173 };
-        ModesProba[0, 5] = new byte[] { 121, 24, 80, 195, 26, 62, 44, 64, 85 };
-        ModesProba[0, 6] = new byte[] { 144, 71, 10, 38, 171, 213, 144, 34, 26 };
-        ModesProba[0, 7] = new byte[] { 170, 46, 55, 19, 136, 160, 33, 206, 71 };
-        ModesProba[0, 8] = new byte[] { 63, 20, 8, 114, 114, 208, 12, 9, 226 };
-        ModesProba[0, 9] = new byte[] { 81, 40, 11, 96, 182, 84, 29, 16, 36 };
-        ModesProba[1, 0] = new byte[] { 134, 183, 89, 137, 98, 101, 106, 165, 148 };
-        ModesProba[1, 1] = new byte[] { 72, 187, 100, 130, 157, 111, 32, 75, 80 };
-        ModesProba[1, 2] = new byte[] { 66, 102, 167, 99, 74, 62, 40, 234, 128 };
-        ModesProba[1, 3] = new byte[] { 41, 53, 9, 178, 241, 141, 26, 8, 107 };
-        ModesProba[1, 4] = new byte[] { 74, 43, 26, 146, 73, 166, 49, 23, 157 };
-        ModesProba[1, 5] = new byte[] { 65, 38, 105, 160, 51, 52, 31, 115, 128 };
-        ModesProba[1, 6] = new byte[] { 104, 79, 12, 27, 217, 255, 87, 17, 7 };
-        ModesProba[1, 7] = new byte[] { 87, 68, 71, 44, 114, 51, 15, 186, 23 };
-        ModesProba[1, 8] = new byte[] { 47, 41, 14, 110, 182, 183, 21, 17, 194 };
-        ModesProba[1, 9] = new byte[] { 66, 45, 25, 102, 197, 189, 23, 18, 22 };
-        ModesProba[2, 0] = new byte[] { 88, 88, 147, 150, 42, 46, 45, 196, 205 };
-        ModesProba[2, 1] = new byte[] { 43, 97, 183, 117, 85, 38, 35, 179, 61 };
-        ModesProba[2, 2] = new byte[] { 39, 53, 200, 87, 26, 21, 43, 232, 171 };
-        ModesProba[2, 3] = new byte[] { 56, 34, 51, 104, 114, 102, 29, 93, 77 };
-        ModesProba[2, 4] = new byte[] { 39, 28, 85, 171, 58, 165, 90, 98, 64 };
-        ModesProba[2, 5] = new byte[] { 34, 22, 116, 206, 23, 34, 43, 166, 73 };
-        ModesProba[2, 6] = new byte[] { 107, 54, 32, 26, 51, 1, 81, 43, 31 };
-        ModesProba[2, 7] = new byte[] { 68, 25, 106, 22, 64, 171, 36, 225, 114 };
-        ModesProba[2, 8] = new byte[] { 34, 19, 21, 102, 132, 188, 16, 76, 124 };
-        ModesProba[2, 9] = new byte[] { 62, 18, 78, 95, 85, 57, 50, 48, 51 };
-        ModesProba[3, 0] = new byte[] { 193, 101, 35, 159, 215, 111, 89, 46, 111 };
-        ModesProba[3, 1] = new byte[] { 60, 148, 31, 172, 219, 228, 21, 18, 111 };
-        ModesProba[3, 2] = new byte[] { 112, 113, 77, 85, 179, 255, 38, 120, 114 };
-        ModesProba[3, 3] = new byte[] { 40, 42, 1, 196, 245, 209, 10, 25, 109 };
-        ModesProba[3, 4] = new byte[] { 88, 43, 29, 140, 166, 213, 37, 43, 154 };
-        ModesProba[3, 5] = new byte[] { 61, 63, 30, 155, 67, 45, 68, 1, 209 };
-        ModesProba[3, 6] = new byte[] { 100, 80, 8, 43, 154, 1, 51, 26, 71 };
-        ModesProba[3, 7] = new byte[] { 142, 78, 78, 16, 255, 128, 34, 197, 171 };
-        ModesProba[3, 8] = new byte[] { 41, 40, 5, 102, 211, 183, 4, 1, 221 };
-        ModesProba[3, 9] = new byte[] { 51, 50, 17, 168, 209, 192, 23, 25, 82 };
-        ModesProba[4, 0] = new byte[] { 138, 31, 36, 171, 27, 166, 38, 44, 229 };
-        ModesProba[4, 1] = new byte[] { 67, 87, 58, 169, 82, 115, 26, 59, 179 };
-        ModesProba[4, 2] = new byte[] { 63, 59, 90, 180, 59, 166, 93, 73, 154 };
-        ModesProba[4, 3] = new byte[] { 40, 40, 21, 116, 143, 209, 34, 39, 175 };
-        ModesProba[4, 4] = new byte[] { 47, 15, 16, 183, 34, 223, 49, 45, 183 };
-        ModesProba[4, 5] = new byte[] { 46, 17, 33, 183, 6, 98, 15, 32, 183 };
-        ModesProba[4, 6] = new byte[] { 57, 46, 22, 24, 128, 1, 54, 17, 37 };
-        ModesProba[4, 7] = new byte[] { 65, 32, 73, 115, 28, 128, 23, 128, 205 };
-        ModesProba[4, 8] = new byte[] { 40, 3, 9, 115, 51, 192, 18, 6, 223 };
-        ModesProba[4, 9] = new byte[] { 87, 37, 9, 115, 59, 77, 64, 21, 47 };
-        ModesProba[5, 0] = new byte[] { 104, 55, 44, 218, 9, 54, 53, 130, 226 };
-        ModesProba[5, 1] = new byte[] { 64, 90, 70, 205, 40, 41, 23, 26, 57 };
-        ModesProba[5, 2] = new byte[] { 54, 57, 112, 184, 5, 41, 38, 166, 213 };
-        ModesProba[5, 3] = new byte[] { 30, 34, 26, 133, 152, 116, 10, 32, 134 };
-        ModesProba[5, 4] = new byte[] { 39, 19, 53, 221, 26, 114, 32, 73, 255 };
-        ModesProba[5, 5] = new byte[] { 31, 9, 65, 234, 2, 15, 1, 118, 73 };
-        ModesProba[5, 6] = new byte[] { 75, 32, 12, 51, 192, 255, 160, 43, 51 };
-        ModesProba[5, 7] = new byte[] { 88, 31, 35, 67, 102, 85, 55, 186, 85 };
-        ModesProba[5, 8] = new byte[] { 56, 21, 23, 111, 59, 205, 45, 37, 192 };
-        ModesProba[5, 9] = new byte[] { 55, 38, 70, 124, 73, 102, 1, 34, 98 };
-        ModesProba[6, 0] = new byte[] { 125, 98, 42, 88, 104, 85, 117, 175, 82 };
-        ModesProba[6, 1] = new byte[] { 95, 84, 53, 89, 128, 100, 113, 101, 45 };
-        ModesProba[6, 2] = new byte[] { 75, 79, 123, 47, 51, 128, 81, 171, 1 };
-        ModesProba[6, 3] = new byte[] { 57, 17, 5, 71, 102, 57, 53, 41, 49 };
-        ModesProba[6, 4] = new byte[] { 38, 33, 13, 121, 57, 73, 26, 1, 85 };
-        ModesProba[6, 5] = new byte[] { 41, 10, 67, 138, 77, 110, 90, 47, 114 };
-        ModesProba[6, 6] = new byte[] { 115, 21, 2, 10, 102, 255, 166, 23, 6 };
-        ModesProba[6, 7] = new byte[] { 101, 29, 16, 10, 85, 128, 101, 196, 26 };
-        ModesProba[6, 8] = new byte[] { 57, 18, 10, 102, 102, 213, 34, 20, 43 };
-        ModesProba[6, 9] = new byte[] { 117, 20, 15, 36, 163, 128, 68, 1, 26 };
-        ModesProba[7, 0] = new byte[] { 102, 61, 71, 37, 34, 53, 31, 243, 192 };
-        ModesProba[7, 1] = new byte[] { 69, 60, 71, 38, 73, 119, 28, 222, 37 };
-        ModesProba[7, 2] = new byte[] { 68, 45, 128, 34, 1, 47, 11, 245, 171 };
-        ModesProba[7, 3] = new byte[] { 62, 17, 19, 70, 146, 85, 55, 62, 70 };
-        ModesProba[7, 4] = new byte[] { 37, 43, 37, 154, 100, 163, 85, 160, 1 };
-        ModesProba[7, 5] = new byte[] { 63, 9, 92, 136, 28, 64, 32, 201, 85 };
-        ModesProba[7, 6] = new byte[] { 75, 15, 9, 9, 64, 255, 184, 119, 16 };
-        ModesProba[7, 7] = new byte[] { 86, 6, 28, 5, 64, 255, 25, 248, 1 };
-        ModesProba[7, 8] = new byte[] { 56, 8, 17, 132, 137, 255, 55, 116, 128 };
-        ModesProba[7, 9] = new byte[] { 58, 15, 20, 82, 135, 57, 26, 121, 40 };
-        ModesProba[8, 0] = new byte[] { 164, 50, 31, 137, 154, 133, 25, 35, 218 };
-        ModesProba[8, 1] = new byte[] { 51, 103, 44, 131, 131, 123, 31, 6, 158 };
-        ModesProba[8, 2] = new byte[] { 86, 40, 64, 135, 148, 224, 45, 183, 128 };
-        ModesProba[8, 3] = new byte[] { 22, 26, 17, 131, 240, 154, 14, 1, 209 };
-        ModesProba[8, 4] = new byte[] { 45, 16, 21, 91, 64, 222, 7, 1, 197 };
-        ModesProba[8, 5] = new byte[] { 56, 21, 39, 155, 60, 138, 23, 102, 213 };
-        ModesProba[8, 6] = new byte[] { 83, 12, 13, 54, 192, 255, 68, 47, 28 };
-        ModesProba[8, 7] = new byte[] { 85, 26, 85, 85, 128, 128, 32, 146, 171 };
-        ModesProba[8, 8] = new byte[] { 18, 11, 7, 63, 144, 171, 4, 4, 246 };
-        ModesProba[8, 9] = new byte[] { 35, 27, 10, 146, 174, 171, 12, 26, 128 };
-        ModesProba[9, 0] = new byte[] { 190, 80, 35, 99, 180, 80, 126, 54, 45 };
-        ModesProba[9, 1] = new byte[] { 85, 126, 47, 87, 176, 51, 41, 20, 32 };
-        ModesProba[9, 2] = new byte[] { 101, 75, 128, 139, 118, 146, 116, 128, 85 };
-        ModesProba[9, 3] = new byte[] { 56, 41, 15, 176, 236, 85, 37, 9, 62 };
-        ModesProba[9, 4] = new byte[] { 71, 30, 17, 119, 118, 255, 17, 18, 138 };
-        ModesProba[9, 5] = new byte[] { 101, 38, 60, 138, 55, 70, 43, 26, 142 };
-        ModesProba[9, 6] = new byte[] { 146, 36, 19, 30, 171, 255, 97, 27, 20 };
-        ModesProba[9, 7] = new byte[] { 138, 45, 61, 62, 219, 1, 81, 188, 64 };
-        ModesProba[9, 8] = new byte[] { 32, 41, 20, 117, 151, 142, 20, 21, 163 };
-        ModesProba[9, 9] = new byte[] { 112, 19, 12, 61, 195, 128, 48, 4, 24 };
+        ModesProba[0, 0] = [231, 120, 48, 89, 115, 113, 120, 152, 112];
+        ModesProba[0, 1] = [152, 179, 64, 126, 170, 118, 46, 70, 95];
+        ModesProba[0, 2] = [175, 69, 143, 80, 85, 82, 72, 155, 103];
+        ModesProba[0, 3] = [56, 58, 10, 171, 218, 189, 17, 13, 152];
+        ModesProba[0, 4] = [114, 26, 17, 163, 44, 195, 21, 10, 173];
+        ModesProba[0, 5] = [121, 24, 80, 195, 26, 62, 44, 64, 85];
+        ModesProba[0, 6] = [144, 71, 10, 38, 171, 213, 144, 34, 26];
+        ModesProba[0, 7] = [170, 46, 55, 19, 136, 160, 33, 206, 71];
+        ModesProba[0, 8] = [63, 20, 8, 114, 114, 208, 12, 9, 226];
+        ModesProba[0, 9] = [81, 40, 11, 96, 182, 84, 29, 16, 36];
+        ModesProba[1, 0] = [134, 183, 89, 137, 98, 101, 106, 165, 148];
+        ModesProba[1, 1] = [72, 187, 100, 130, 157, 111, 32, 75, 80];
+        ModesProba[1, 2] = [66, 102, 167, 99, 74, 62, 40, 234, 128];
+        ModesProba[1, 3] = [41, 53, 9, 178, 241, 141, 26, 8, 107];
+        ModesProba[1, 4] = [74, 43, 26, 146, 73, 166, 49, 23, 157];
+        ModesProba[1, 5] = [65, 38, 105, 160, 51, 52, 31, 115, 128];
+        ModesProba[1, 6] = [104, 79, 12, 27, 217, 255, 87, 17, 7];
+        ModesProba[1, 7] = [87, 68, 71, 44, 114, 51, 15, 186, 23];
+        ModesProba[1, 8] = [47, 41, 14, 110, 182, 183, 21, 17, 194];
+        ModesProba[1, 9] = [66, 45, 25, 102, 197, 189, 23, 18, 22];
+        ModesProba[2, 0] = [88, 88, 147, 150, 42, 46, 45, 196, 205];
+        ModesProba[2, 1] = [43, 97, 183, 117, 85, 38, 35, 179, 61];
+        ModesProba[2, 2] = [39, 53, 200, 87, 26, 21, 43, 232, 171];
+        ModesProba[2, 3] = [56, 34, 51, 104, 114, 102, 29, 93, 77];
+        ModesProba[2, 4] = [39, 28, 85, 171, 58, 165, 90, 98, 64];
+        ModesProba[2, 5] = [34, 22, 116, 206, 23, 34, 43, 166, 73];
+        ModesProba[2, 6] = [107, 54, 32, 26, 51, 1, 81, 43, 31];
+        ModesProba[2, 7] = [68, 25, 106, 22, 64, 171, 36, 225, 114];
+        ModesProba[2, 8] = [34, 19, 21, 102, 132, 188, 16, 76, 124];
+        ModesProba[2, 9] = [62, 18, 78, 95, 85, 57, 50, 48, 51];
+        ModesProba[3, 0] = [193, 101, 35, 159, 215, 111, 89, 46, 111];
+        ModesProba[3, 1] = [60, 148, 31, 172, 219, 228, 21, 18, 111];
+        ModesProba[3, 2] = [112, 113, 77, 85, 179, 255, 38, 120, 114];
+        ModesProba[3, 3] = [40, 42, 1, 196, 245, 209, 10, 25, 109];
+        ModesProba[3, 4] = [88, 43, 29, 140, 166, 213, 37, 43, 154];
+        ModesProba[3, 5] = [61, 63, 30, 155, 67, 45, 68, 1, 209];
+        ModesProba[3, 6] = [100, 80, 8, 43, 154, 1, 51, 26, 71];
+        ModesProba[3, 7] = [142, 78, 78, 16, 255, 128, 34, 197, 171];
+        ModesProba[3, 8] = [41, 40, 5, 102, 211, 183, 4, 1, 221];
+        ModesProba[3, 9] = [51, 50, 17, 168, 209, 192, 23, 25, 82];
+        ModesProba[4, 0] = [138, 31, 36, 171, 27, 166, 38, 44, 229];
+        ModesProba[4, 1] = [67, 87, 58, 169, 82, 115, 26, 59, 179];
+        ModesProba[4, 2] = [63, 59, 90, 180, 59, 166, 93, 73, 154];
+        ModesProba[4, 3] = [40, 40, 21, 116, 143, 209, 34, 39, 175];
+        ModesProba[4, 4] = [47, 15, 16, 183, 34, 223, 49, 45, 183];
+        ModesProba[4, 5] = [46, 17, 33, 183, 6, 98, 15, 32, 183];
+        ModesProba[4, 6] = [57, 46, 22, 24, 128, 1, 54, 17, 37];
+        ModesProba[4, 7] = [65, 32, 73, 115, 28, 128, 23, 128, 205];
+        ModesProba[4, 8] = [40, 3, 9, 115, 51, 192, 18, 6, 223];
+        ModesProba[4, 9] = [87, 37, 9, 115, 59, 77, 64, 21, 47];
+        ModesProba[5, 0] = [104, 55, 44, 218, 9, 54, 53, 130, 226];
+        ModesProba[5, 1] = [64, 90, 70, 205, 40, 41, 23, 26, 57];
+        ModesProba[5, 2] = [54, 57, 112, 184, 5, 41, 38, 166, 213];
+        ModesProba[5, 3] = [30, 34, 26, 133, 152, 116, 10, 32, 134];
+        ModesProba[5, 4] = [39, 19, 53, 221, 26, 114, 32, 73, 255];
+        ModesProba[5, 5] = [31, 9, 65, 234, 2, 15, 1, 118, 73];
+        ModesProba[5, 6] = [75, 32, 12, 51, 192, 255, 160, 43, 51];
+        ModesProba[5, 7] = [88, 31, 35, 67, 102, 85, 55, 186, 85];
+        ModesProba[5, 8] = [56, 21, 23, 111, 59, 205, 45, 37, 192];
+        ModesProba[5, 9] = [55, 38, 70, 124, 73, 102, 1, 34, 98];
+        ModesProba[6, 0] = [125, 98, 42, 88, 104, 85, 117, 175, 82];
+        ModesProba[6, 1] = [95, 84, 53, 89, 128, 100, 113, 101, 45];
+        ModesProba[6, 2] = [75, 79, 123, 47, 51, 128, 81, 171, 1];
+        ModesProba[6, 3] = [57, 17, 5, 71, 102, 57, 53, 41, 49];
+        ModesProba[6, 4] = [38, 33, 13, 121, 57, 73, 26, 1, 85];
+        ModesProba[6, 5] = [41, 10, 67, 138, 77, 110, 90, 47, 114];
+        ModesProba[6, 6] = [115, 21, 2, 10, 102, 255, 166, 23, 6];
+        ModesProba[6, 7] = [101, 29, 16, 10, 85, 128, 101, 196, 26];
+        ModesProba[6, 8] = [57, 18, 10, 102, 102, 213, 34, 20, 43];
+        ModesProba[6, 9] = [117, 20, 15, 36, 163, 128, 68, 1, 26];
+        ModesProba[7, 0] = [102, 61, 71, 37, 34, 53, 31, 243, 192];
+        ModesProba[7, 1] = [69, 60, 71, 38, 73, 119, 28, 222, 37];
+        ModesProba[7, 2] = [68, 45, 128, 34, 1, 47, 11, 245, 171];
+        ModesProba[7, 3] = [62, 17, 19, 70, 146, 85, 55, 62, 70];
+        ModesProba[7, 4] = [37, 43, 37, 154, 100, 163, 85, 160, 1];
+        ModesProba[7, 5] = [63, 9, 92, 136, 28, 64, 32, 201, 85];
+        ModesProba[7, 6] = [75, 15, 9, 9, 64, 255, 184, 119, 16];
+        ModesProba[7, 7] = [86, 6, 28, 5, 64, 255, 25, 248, 1];
+        ModesProba[7, 8] = [56, 8, 17, 132, 137, 255, 55, 116, 128];
+        ModesProba[7, 9] = [58, 15, 20, 82, 135, 57, 26, 121, 40];
+        ModesProba[8, 0] = [164, 50, 31, 137, 154, 133, 25, 35, 218];
+        ModesProba[8, 1] = [51, 103, 44, 131, 131, 123, 31, 6, 158];
+        ModesProba[8, 2] = [86, 40, 64, 135, 148, 224, 45, 183, 128];
+        ModesProba[8, 3] = [22, 26, 17, 131, 240, 154, 14, 1, 209];
+        ModesProba[8, 4] = [45, 16, 21, 91, 64, 222, 7, 1, 197];
+        ModesProba[8, 5] = [56, 21, 39, 155, 60, 138, 23, 102, 213];
+        ModesProba[8, 6] = [83, 12, 13, 54, 192, 255, 68, 47, 28];
+        ModesProba[8, 7] = [85, 26, 85, 85, 128, 128, 32, 146, 171];
+        ModesProba[8, 8] = [18, 11, 7, 63, 144, 171, 4, 4, 246];
+        ModesProba[8, 9] = [35, 27, 10, 146, 174, 171, 12, 26, 128];
+        ModesProba[9, 0] = [190, 80, 35, 99, 180, 80, 126, 54, 45];
+        ModesProba[9, 1] = [85, 126, 47, 87, 176, 51, 41, 20, 32];
+        ModesProba[9, 2] = [101, 75, 128, 139, 118, 146, 116, 128, 85];
+        ModesProba[9, 3] = [56, 41, 15, 176, 236, 85, 37, 9, 62];
+        ModesProba[9, 4] = [71, 30, 17, 119, 118, 255, 17, 18, 138];
+        ModesProba[9, 5] = [101, 38, 60, 138, 55, 70, 43, 26, 142];
+        ModesProba[9, 6] = [146, 36, 19, 30, 171, 255, 97, 27, 20];
+        ModesProba[9, 7] = [138, 45, 61, 62, 219, 1, 81, 188, 64];
+        ModesProba[9, 8] = [32, 41, 20, 117, 151, 142, 20, 21, 163];
+        ModesProba[9, 9] = [112, 19, 12, 61, 195, 128, 48, 4, 24];
     }
 
     private static void InitializeFixedCostsI4()
     {
-        Vp8FixedCostsI4[0, 0] = new short[] { 40, 1151, 1723, 1874, 2103, 2019, 1628, 1777, 2226, 2137 };
-        Vp8FixedCostsI4[0, 1] = new short[] { 192, 469, 1296, 1308, 1849, 1794, 1781, 1703, 1713, 1522 };
-        Vp8FixedCostsI4[0, 2] = new short[] { 142, 910, 762, 1684, 1849, 1576, 1460, 1305, 1801, 1657 };
-        Vp8FixedCostsI4[0, 3] = new short[] { 559, 641, 1370, 421, 1182, 1569, 1612, 1725, 863, 1007 };
-        Vp8FixedCostsI4[0, 4] = new short[] { 299, 1059, 1256, 1108, 636, 1068, 1581, 1883, 869, 1142 };
-        Vp8FixedCostsI4[0, 5] = new short[] { 277, 1111, 707, 1362, 1089, 672, 1603, 1541, 1545, 1291 };
-        Vp8FixedCostsI4[0, 6] = new short[] { 214, 781, 1609, 1303, 1632, 2229, 726, 1560, 1713, 918 };
-        Vp8FixedCostsI4[0, 7] = new short[] { 152, 1037, 1046, 1759, 1983, 2174, 1358, 742, 1740, 1390 };
-        Vp8FixedCostsI4[0, 8] = new short[] { 512, 1046, 1420, 753, 752, 1297, 1486, 1613, 460, 1207 };
-        Vp8FixedCostsI4[0, 9] = new short[] { 424, 827, 1362, 719, 1462, 1202, 1199, 1476, 1199, 538 };
-        Vp8FixedCostsI4[1, 0] = new short[] { 240, 402, 1134, 1491, 1659, 1505, 1517, 1555, 1979, 2099 };
-        Vp8FixedCostsI4[1, 1] = new short[] { 467, 242, 960, 1232, 1714, 1620, 1834, 1570, 1676, 1391 };
-        Vp8FixedCostsI4[1, 2] = new short[] { 500, 455, 463, 1507, 1699, 1282, 1564, 982, 2114, 2114 };
-        Vp8FixedCostsI4[1, 3] = new short[] { 672, 643, 1372, 331, 1589, 1667, 1453, 1938, 996, 876 };
-        Vp8FixedCostsI4[1, 4] = new short[] { 458, 783, 1037, 911, 738, 968, 1165, 1518, 859, 1033 };
-        Vp8FixedCostsI4[1, 5] = new short[] { 504, 815, 504, 1139, 1219, 719, 1506, 1085, 1268, 1268 };
-        Vp8FixedCostsI4[1, 6] = new short[] { 333, 630, 1445, 1239, 1883, 3672, 799, 1548, 1865, 598 };
-        Vp8FixedCostsI4[1, 7] = new short[] { 399, 644, 746, 1342, 1856, 1350, 1493, 613, 1855, 1015 };
-        Vp8FixedCostsI4[1, 8] = new short[] { 622, 749, 1205, 608, 1066, 1408, 1290, 1406, 546, 971 };
-        Vp8FixedCostsI4[1, 9] = new short[] { 500, 753, 1041, 668, 1230, 1617, 1297, 1425, 1383, 523 };
-        Vp8FixedCostsI4[2, 0] = new short[] { 394, 553, 523, 1502, 1536, 981, 1608, 1142, 1666, 2181 };
-        Vp8FixedCostsI4[2, 1] = new short[] { 655, 430, 375, 1411, 1861, 1220, 1677, 1135, 1978, 1553 };
-        Vp8FixedCostsI4[2, 2] = new short[] { 690, 640, 245, 1954, 2070, 1194, 1528, 982, 1972, 2232 };
-        Vp8FixedCostsI4[2, 3] = new short[] { 559, 834, 741, 867, 1131, 980, 1225, 852, 1092, 784 };
-        Vp8FixedCostsI4[2, 4] = new short[] { 690, 875, 516, 959, 673, 894, 1056, 1190, 1528, 1126 };
-        Vp8FixedCostsI4[2, 5] = new short[] { 740, 951, 384, 1277, 1177, 492, 1579, 1155, 1846, 1513 };
-        Vp8FixedCostsI4[2, 6] = new short[] { 323, 775, 1062, 1776, 3062, 1274, 813, 1188, 1372, 655 };
-        Vp8FixedCostsI4[2, 7] = new short[] { 488, 971, 484, 1767, 1515, 1775, 1115, 503, 1539, 1461 };
-        Vp8FixedCostsI4[2, 8] = new short[] { 740, 1006, 998, 709, 851, 1230, 1337, 788, 741, 721 };
-        Vp8FixedCostsI4[2, 9] = new short[] { 522, 1073, 573, 1045, 1346, 887, 1046, 1146, 1203, 697 };
-        Vp8FixedCostsI4[3, 0] = new short[] { 105, 864, 1442, 1009, 1934, 1840, 1519, 1920, 1673, 1579 };
-        Vp8FixedCostsI4[3, 1] = new short[] { 534, 305, 1193, 683, 1388, 2164, 1802, 1894, 1264, 1170 };
-        Vp8FixedCostsI4[3, 2] = new short[] { 305, 518, 877, 1108, 1426, 3215, 1425, 1064, 1320, 1242 };
-        Vp8FixedCostsI4[3, 3] = new short[] { 683, 732, 1927, 257, 1493, 2048, 1858, 1552, 1055, 947 };
-        Vp8FixedCostsI4[3, 4] = new short[] { 394, 814, 1024, 660, 959, 1556, 1282, 1289, 893, 1047 };
-        Vp8FixedCostsI4[3, 5] = new short[] { 528, 615, 996, 940, 1201, 635, 1094, 2515, 803, 1358 };
-        Vp8FixedCostsI4[3, 6] = new short[] { 347, 614, 1609, 1187, 3133, 1345, 1007, 1339, 1017, 667 };
-        Vp8FixedCostsI4[3, 7] = new short[] { 218, 740, 878, 1605, 3650, 3650, 1345, 758, 1357, 1617 };
-        Vp8FixedCostsI4[3, 8] = new short[] { 672, 750, 1541, 558, 1257, 1599, 1870, 2135, 402, 1087 };
-        Vp8FixedCostsI4[3, 9] = new short[] { 592, 684, 1161, 430, 1092, 1497, 1475, 1489, 1095, 822 };
-        Vp8FixedCostsI4[4, 0] = new short[] { 228, 1056, 1059, 1368, 752, 982, 1512, 1518, 987, 1782 };
-        Vp8FixedCostsI4[4, 1] = new short[] { 494, 514, 818, 942, 965, 892, 1610, 1356, 1048, 1363 };
-        Vp8FixedCostsI4[4, 2] = new short[] { 512, 648, 591, 1042, 761, 991, 1196, 1454, 1309, 1463 };
-        Vp8FixedCostsI4[4, 3] = new short[] { 683, 749, 1043, 676, 841, 1396, 1133, 1138, 654, 939 };
-        Vp8FixedCostsI4[4, 4] = new short[] { 622, 1101, 1126, 994, 361, 1077, 1203, 1318, 877, 1219 };
-        Vp8FixedCostsI4[4, 5] = new short[] { 631, 1068, 857, 1650, 651, 477, 1650, 1419, 828, 1170 };
-        Vp8FixedCostsI4[4, 6] = new short[] { 555, 727, 1068, 1335, 3127, 1339, 820, 1331, 1077, 429 };
-        Vp8FixedCostsI4[4, 7] = new short[] { 504, 879, 624, 1398, 889, 889, 1392, 808, 891, 1406 };
-        Vp8FixedCostsI4[4, 8] = new short[] { 683, 1602, 1289, 977, 578, 983, 1280, 1708, 406, 1122 };
-        Vp8FixedCostsI4[4, 9] = new short[] { 399, 865, 1433, 1070, 1072, 764, 968, 1477, 1223, 678 };
-        Vp8FixedCostsI4[5, 0] = new short[] { 333, 760, 935, 1638, 1010, 529, 1646, 1410, 1472, 2219 };
-        Vp8FixedCostsI4[5, 1] = new short[] { 512, 494, 750, 1160, 1215, 610, 1870, 1868, 1628, 1169 };
-        Vp8FixedCostsI4[5, 2] = new short[] { 572, 646, 492, 1934, 1208, 603, 1580, 1099, 1398, 1995 };
-        Vp8FixedCostsI4[5, 3] = new short[] { 786, 789, 942, 581, 1018, 951, 1599, 1207, 731, 768 };
-        Vp8FixedCostsI4[5, 4] = new short[] { 690, 1015, 672, 1078, 582, 504, 1693, 1438, 1108, 2897 };
-        Vp8FixedCostsI4[5, 5] = new short[] { 768, 1267, 571, 2005, 1243, 244, 2881, 1380, 1786, 1453 };
-        Vp8FixedCostsI4[5, 6] = new short[] { 452, 899, 1293, 903, 1311, 3100, 465, 1311, 1319, 813 };
-        Vp8FixedCostsI4[5, 7] = new short[] { 394, 927, 942, 1103, 1358, 1104, 946, 593, 1363, 1109 };
-        Vp8FixedCostsI4[5, 8] = new short[] { 559, 1005, 1007, 1016, 658, 1173, 1021, 1164, 623, 1028 };
-        Vp8FixedCostsI4[5, 9] = new short[] { 564, 796, 632, 1005, 1014, 863, 2316, 1268, 938, 764 };
-        Vp8FixedCostsI4[6, 0] = new short[] { 266, 606, 1098, 1228, 1497, 1243, 948, 1030, 1734, 1461 };
-        Vp8FixedCostsI4[6, 1] = new short[] { 366, 585, 901, 1060, 1407, 1247, 876, 1134, 1620, 1054 };
-        Vp8FixedCostsI4[6, 2] = new short[] { 452, 565, 542, 1729, 1479, 1479, 1016, 886, 2938, 1150 };
-        Vp8FixedCostsI4[6, 3] = new short[] { 555, 1088, 1533, 950, 1354, 895, 834, 1019, 1021, 496 };
-        Vp8FixedCostsI4[6, 4] = new short[] { 704, 815, 1193, 971, 973, 640, 1217, 2214, 832, 578 };
-        Vp8FixedCostsI4[6, 5] = new short[] { 672, 1245, 579, 871, 875, 774, 872, 1273, 1027, 949 };
-        Vp8FixedCostsI4[6, 6] = new short[] { 296, 1134, 2050, 1784, 1636, 3425, 442, 1550, 2076, 722 };
-        Vp8FixedCostsI4[6, 7] = new short[] { 342, 982, 1259, 1846, 1848, 1848, 622, 568, 1847, 1052 };
-        Vp8FixedCostsI4[6, 8] = new short[] { 555, 1064, 1304, 828, 746, 1343, 1075, 1329, 1078, 494 };
-        Vp8FixedCostsI4[6, 9] = new short[] { 288, 1167, 1285, 1174, 1639, 1639, 833, 2254, 1304, 509 };
-        Vp8FixedCostsI4[7, 0] = new short[] { 342, 719, 767, 1866, 1757, 1270, 1246, 550, 1746, 2151 };
-        Vp8FixedCostsI4[7, 1] = new short[] { 483, 653, 694, 1509, 1459, 1410, 1218, 507, 1914, 1266 };
-        Vp8FixedCostsI4[7, 2] = new short[] { 488, 757, 447, 2979, 1813, 1268, 1654, 539, 1849, 2109 };
-        Vp8FixedCostsI4[7, 3] = new short[] { 522, 1097, 1085, 851, 1365, 1111, 851, 901, 961, 605 };
-        Vp8FixedCostsI4[7, 4] = new short[] { 709, 716, 841, 728, 736, 945, 941, 862, 2845, 1057 };
-        Vp8FixedCostsI4[7, 5] = new short[] { 512, 1323, 500, 1336, 1083, 681, 1342, 717, 1604, 1350 };
-        Vp8FixedCostsI4[7, 6] = new short[] { 452, 1155, 1372, 1900, 1501, 3290, 311, 944, 1919, 922 };
-        Vp8FixedCostsI4[7, 7] = new short[] { 403, 1520, 977, 2132, 1733, 3522, 1076, 276, 3335, 1547 };
-        Vp8FixedCostsI4[7, 8] = new short[] { 559, 1374, 1101, 615, 673, 2462, 974, 795, 984, 984 };
-        Vp8FixedCostsI4[7, 9] = new short[] { 547, 1122, 1062, 812, 1410, 951, 1140, 622, 1268, 651 };
-        Vp8FixedCostsI4[8, 0] = new short[] { 165, 982, 1235, 938, 1334, 1366, 1659, 1578, 964, 1612 };
-        Vp8FixedCostsI4[8, 1] = new short[] { 592, 422, 925, 847, 1139, 1112, 1387, 2036, 861, 1041 };
-        Vp8FixedCostsI4[8, 2] = new short[] { 403, 837, 732, 770, 941, 1658, 1250, 809, 1407, 1407 };
-        Vp8FixedCostsI4[8, 3] = new short[] { 896, 874, 1071, 381, 1568, 1722, 1437, 2192, 480, 1035 };
-        Vp8FixedCostsI4[8, 4] = new short[] { 640, 1098, 1012, 1032, 684, 1382, 1581, 2106, 416, 865 };
-        Vp8FixedCostsI4[8, 5] = new short[] { 559, 1005, 819, 914, 710, 770, 1418, 920, 838, 1435 };
-        Vp8FixedCostsI4[8, 6] = new short[] { 415, 1258, 1245, 870, 1278, 3067, 770, 1021, 1287, 522 };
-        Vp8FixedCostsI4[8, 7] = new short[] { 406, 990, 601, 1009, 1265, 1265, 1267, 759, 1017, 1277 };
-        Vp8FixedCostsI4[8, 8] = new short[] { 968, 1182, 1329, 788, 1032, 1292, 1705, 1714, 203, 1403 };
-        Vp8FixedCostsI4[8, 9] = new short[] { 732, 877, 1279, 471, 901, 1161, 1545, 1294, 755, 755 };
-        Vp8FixedCostsI4[9, 0] = new short[] { 111, 931, 1378, 1185, 1933, 1648, 1148, 1714, 1873, 1307 };
-        Vp8FixedCostsI4[9, 1] = new short[] { 406, 414, 1030, 1023, 1910, 1404, 1313, 1647, 1509, 793 };
-        Vp8FixedCostsI4[9, 2] = new short[] { 342, 640, 575, 1088, 1241, 1349, 1161, 1350, 1756, 1502 };
-        Vp8FixedCostsI4[9, 3] = new short[] { 559, 766, 1185, 357, 1682, 1428, 1329, 1897, 1219, 802 };
-        Vp8FixedCostsI4[9, 4] = new short[] { 473, 909, 1164, 771, 719, 2508, 1427, 1432, 722, 782 };
-        Vp8FixedCostsI4[9, 5] = new short[] { 342, 892, 785, 1145, 1150, 794, 1296, 1550, 973, 1057 };
-        Vp8FixedCostsI4[9, 6] = new short[] { 208, 1036, 1326, 1343, 1606, 3395, 815, 1455, 1618, 712 };
-        Vp8FixedCostsI4[9, 7] = new short[] { 228, 928, 890, 1046, 3499, 1711, 994, 829, 1720, 1318 };
-        Vp8FixedCostsI4[9, 8] = new short[] { 768, 724, 1058, 636, 991, 1075, 1319, 1324, 616, 825 };
-        Vp8FixedCostsI4[9, 9] = new short[] { 305, 1167, 1358, 899, 1587, 1587, 987, 1988, 1332, 501 };
+        Vp8FixedCostsI4[0, 0] = [40, 1151, 1723, 1874, 2103, 2019, 1628, 1777, 2226, 2137];
+        Vp8FixedCostsI4[0, 1] = [192, 469, 1296, 1308, 1849, 1794, 1781, 1703, 1713, 1522];
+        Vp8FixedCostsI4[0, 2] = [142, 910, 762, 1684, 1849, 1576, 1460, 1305, 1801, 1657];
+        Vp8FixedCostsI4[0, 3] = [559, 641, 1370, 421, 1182, 1569, 1612, 1725, 863, 1007];
+        Vp8FixedCostsI4[0, 4] = [299, 1059, 1256, 1108, 636, 1068, 1581, 1883, 869, 1142];
+        Vp8FixedCostsI4[0, 5] = [277, 1111, 707, 1362, 1089, 672, 1603, 1541, 1545, 1291];
+        Vp8FixedCostsI4[0, 6] = [214, 781, 1609, 1303, 1632, 2229, 726, 1560, 1713, 918];
+        Vp8FixedCostsI4[0, 7] = [152, 1037, 1046, 1759, 1983, 2174, 1358, 742, 1740, 1390];
+        Vp8FixedCostsI4[0, 8] = [512, 1046, 1420, 753, 752, 1297, 1486, 1613, 460, 1207];
+        Vp8FixedCostsI4[0, 9] = [424, 827, 1362, 719, 1462, 1202, 1199, 1476, 1199, 538];
+        Vp8FixedCostsI4[1, 0] = [240, 402, 1134, 1491, 1659, 1505, 1517, 1555, 1979, 2099];
+        Vp8FixedCostsI4[1, 1] = [467, 242, 960, 1232, 1714, 1620, 1834, 1570, 1676, 1391];
+        Vp8FixedCostsI4[1, 2] = [500, 455, 463, 1507, 1699, 1282, 1564, 982, 2114, 2114];
+        Vp8FixedCostsI4[1, 3] = [672, 643, 1372, 331, 1589, 1667, 1453, 1938, 996, 876];
+        Vp8FixedCostsI4[1, 4] = [458, 783, 1037, 911, 738, 968, 1165, 1518, 859, 1033];
+        Vp8FixedCostsI4[1, 5] = [504, 815, 504, 1139, 1219, 719, 1506, 1085, 1268, 1268];
+        Vp8FixedCostsI4[1, 6] = [333, 630, 1445, 1239, 1883, 3672, 799, 1548, 1865, 598];
+        Vp8FixedCostsI4[1, 7] = [399, 644, 746, 1342, 1856, 1350, 1493, 613, 1855, 1015];
+        Vp8FixedCostsI4[1, 8] = [622, 749, 1205, 608, 1066, 1408, 1290, 1406, 546, 971];
+        Vp8FixedCostsI4[1, 9] = [500, 753, 1041, 668, 1230, 1617, 1297, 1425, 1383, 523];
+        Vp8FixedCostsI4[2, 0] = [394, 553, 523, 1502, 1536, 981, 1608, 1142, 1666, 2181];
+        Vp8FixedCostsI4[2, 1] = [655, 430, 375, 1411, 1861, 1220, 1677, 1135, 1978, 1553];
+        Vp8FixedCostsI4[2, 2] = [690, 640, 245, 1954, 2070, 1194, 1528, 982, 1972, 2232];
+        Vp8FixedCostsI4[2, 3] = [559, 834, 741, 867, 1131, 980, 1225, 852, 1092, 784];
+        Vp8FixedCostsI4[2, 4] = [690, 875, 516, 959, 673, 894, 1056, 1190, 1528, 1126];
+        Vp8FixedCostsI4[2, 5] = [740, 951, 384, 1277, 1177, 492, 1579, 1155, 1846, 1513];
+        Vp8FixedCostsI4[2, 6] = [323, 775, 1062, 1776, 3062, 1274, 813, 1188, 1372, 655];
+        Vp8FixedCostsI4[2, 7] = [488, 971, 484, 1767, 1515, 1775, 1115, 503, 1539, 1461];
+        Vp8FixedCostsI4[2, 8] = [740, 1006, 998, 709, 851, 1230, 1337, 788, 741, 721];
+        Vp8FixedCostsI4[2, 9] = [522, 1073, 573, 1045, 1346, 887, 1046, 1146, 1203, 697];
+        Vp8FixedCostsI4[3, 0] = [105, 864, 1442, 1009, 1934, 1840, 1519, 1920, 1673, 1579];
+        Vp8FixedCostsI4[3, 1] = [534, 305, 1193, 683, 1388, 2164, 1802, 1894, 1264, 1170];
+        Vp8FixedCostsI4[3, 2] = [305, 518, 877, 1108, 1426, 3215, 1425, 1064, 1320, 1242];
+        Vp8FixedCostsI4[3, 3] = [683, 732, 1927, 257, 1493, 2048, 1858, 1552, 1055, 947];
+        Vp8FixedCostsI4[3, 4] = [394, 814, 1024, 660, 959, 1556, 1282, 1289, 893, 1047];
+        Vp8FixedCostsI4[3, 5] = [528, 615, 996, 940, 1201, 635, 1094, 2515, 803, 1358];
+        Vp8FixedCostsI4[3, 6] = [347, 614, 1609, 1187, 3133, 1345, 1007, 1339, 1017, 667];
+        Vp8FixedCostsI4[3, 7] = [218, 740, 878, 1605, 3650, 3650, 1345, 758, 1357, 1617];
+        Vp8FixedCostsI4[3, 8] = [672, 750, 1541, 558, 1257, 1599, 1870, 2135, 402, 1087];
+        Vp8FixedCostsI4[3, 9] = [592, 684, 1161, 430, 1092, 1497, 1475, 1489, 1095, 822];
+        Vp8FixedCostsI4[4, 0] = [228, 1056, 1059, 1368, 752, 982, 1512, 1518, 987, 1782];
+        Vp8FixedCostsI4[4, 1] = [494, 514, 818, 942, 965, 892, 1610, 1356, 1048, 1363];
+        Vp8FixedCostsI4[4, 2] = [512, 648, 591, 1042, 761, 991, 1196, 1454, 1309, 1463];
+        Vp8FixedCostsI4[4, 3] = [683, 749, 1043, 676, 841, 1396, 1133, 1138, 654, 939];
+        Vp8FixedCostsI4[4, 4] = [622, 1101, 1126, 994, 361, 1077, 1203, 1318, 877, 1219];
+        Vp8FixedCostsI4[4, 5] = [631, 1068, 857, 1650, 651, 477, 1650, 1419, 828, 1170];
+        Vp8FixedCostsI4[4, 6] = [555, 727, 1068, 1335, 3127, 1339, 820, 1331, 1077, 429];
+        Vp8FixedCostsI4[4, 7] = [504, 879, 624, 1398, 889, 889, 1392, 808, 891, 1406];
+        Vp8FixedCostsI4[4, 8] = [683, 1602, 1289, 977, 578, 983, 1280, 1708, 406, 1122];
+        Vp8FixedCostsI4[4, 9] = [399, 865, 1433, 1070, 1072, 764, 968, 1477, 1223, 678];
+        Vp8FixedCostsI4[5, 0] = [333, 760, 935, 1638, 1010, 529, 1646, 1410, 1472, 2219];
+        Vp8FixedCostsI4[5, 1] = [512, 494, 750, 1160, 1215, 610, 1870, 1868, 1628, 1169];
+        Vp8FixedCostsI4[5, 2] = [572, 646, 492, 1934, 1208, 603, 1580, 1099, 1398, 1995];
+        Vp8FixedCostsI4[5, 3] = [786, 789, 942, 581, 1018, 951, 1599, 1207, 731, 768];
+        Vp8FixedCostsI4[5, 4] = [690, 1015, 672, 1078, 582, 504, 1693, 1438, 1108, 2897];
+        Vp8FixedCostsI4[5, 5] = [768, 1267, 571, 2005, 1243, 244, 2881, 1380, 1786, 1453];
+        Vp8FixedCostsI4[5, 6] = [452, 899, 1293, 903, 1311, 3100, 465, 1311, 1319, 813];
+        Vp8FixedCostsI4[5, 7] = [394, 927, 942, 1103, 1358, 1104, 946, 593, 1363, 1109];
+        Vp8FixedCostsI4[5, 8] = [559, 1005, 1007, 1016, 658, 1173, 1021, 1164, 623, 1028];
+        Vp8FixedCostsI4[5, 9] = [564, 796, 632, 1005, 1014, 863, 2316, 1268, 938, 764];
+        Vp8FixedCostsI4[6, 0] = [266, 606, 1098, 1228, 1497, 1243, 948, 1030, 1734, 1461];
+        Vp8FixedCostsI4[6, 1] = [366, 585, 901, 1060, 1407, 1247, 876, 1134, 1620, 1054];
+        Vp8FixedCostsI4[6, 2] = [452, 565, 542, 1729, 1479, 1479, 1016, 886, 2938, 1150];
+        Vp8FixedCostsI4[6, 3] = [555, 1088, 1533, 950, 1354, 895, 834, 1019, 1021, 496];
+        Vp8FixedCostsI4[6, 4] = [704, 815, 1193, 971, 973, 640, 1217, 2214, 832, 578];
+        Vp8FixedCostsI4[6, 5] = [672, 1245, 579, 871, 875, 774, 872, 1273, 1027, 949];
+        Vp8FixedCostsI4[6, 6] = [296, 1134, 2050, 1784, 1636, 3425, 442, 1550, 2076, 722];
+        Vp8FixedCostsI4[6, 7] = [342, 982, 1259, 1846, 1848, 1848, 622, 568, 1847, 1052];
+        Vp8FixedCostsI4[6, 8] = [555, 1064, 1304, 828, 746, 1343, 1075, 1329, 1078, 494];
+        Vp8FixedCostsI4[6, 9] = [288, 1167, 1285, 1174, 1639, 1639, 833, 2254, 1304, 509];
+        Vp8FixedCostsI4[7, 0] = [342, 719, 767, 1866, 1757, 1270, 1246, 550, 1746, 2151];
+        Vp8FixedCostsI4[7, 1] = [483, 653, 694, 1509, 1459, 1410, 1218, 507, 1914, 1266];
+        Vp8FixedCostsI4[7, 2] = [488, 757, 447, 2979, 1813, 1268, 1654, 539, 1849, 2109];
+        Vp8FixedCostsI4[7, 3] = [522, 1097, 1085, 851, 1365, 1111, 851, 901, 961, 605];
+        Vp8FixedCostsI4[7, 4] = [709, 716, 841, 728, 736, 945, 941, 862, 2845, 1057];
+        Vp8FixedCostsI4[7, 5] = [512, 1323, 500, 1336, 1083, 681, 1342, 717, 1604, 1350];
+        Vp8FixedCostsI4[7, 6] = [452, 1155, 1372, 1900, 1501, 3290, 311, 944, 1919, 922];
+        Vp8FixedCostsI4[7, 7] = [403, 1520, 977, 2132, 1733, 3522, 1076, 276, 3335, 1547];
+        Vp8FixedCostsI4[7, 8] = [559, 1374, 1101, 615, 673, 2462, 974, 795, 984, 984];
+        Vp8FixedCostsI4[7, 9] = [547, 1122, 1062, 812, 1410, 951, 1140, 622, 1268, 651];
+        Vp8FixedCostsI4[8, 0] = [165, 982, 1235, 938, 1334, 1366, 1659, 1578, 964, 1612];
+        Vp8FixedCostsI4[8, 1] = [592, 422, 925, 847, 1139, 1112, 1387, 2036, 861, 1041];
+        Vp8FixedCostsI4[8, 2] = [403, 837, 732, 770, 941, 1658, 1250, 809, 1407, 1407];
+        Vp8FixedCostsI4[8, 3] = [896, 874, 1071, 381, 1568, 1722, 1437, 2192, 480, 1035];
+        Vp8FixedCostsI4[8, 4] = [640, 1098, 1012, 1032, 684, 1382, 1581, 2106, 416, 865];
+        Vp8FixedCostsI4[8, 5] = [559, 1005, 819, 914, 710, 770, 1418, 920, 838, 1435];
+        Vp8FixedCostsI4[8, 6] = [415, 1258, 1245, 870, 1278, 3067, 770, 1021, 1287, 522];
+        Vp8FixedCostsI4[8, 7] = [406, 990, 601, 1009, 1265, 1265, 1267, 759, 1017, 1277];
+        Vp8FixedCostsI4[8, 8] = [968, 1182, 1329, 788, 1032, 1292, 1705, 1714, 203, 1403];
+        Vp8FixedCostsI4[8, 9] = [732, 877, 1279, 471, 901, 1161, 1545, 1294, 755, 755];
+        Vp8FixedCostsI4[9, 0] = [111, 931, 1378, 1185, 1933, 1648, 1148, 1714, 1873, 1307];
+        Vp8FixedCostsI4[9, 1] = [406, 414, 1030, 1023, 1910, 1404, 1313, 1647, 1509, 793];
+        Vp8FixedCostsI4[9, 2] = [342, 640, 575, 1088, 1241, 1349, 1161, 1350, 1756, 1502];
+        Vp8FixedCostsI4[9, 3] = [559, 766, 1185, 357, 1682, 1428, 1329, 1897, 1219, 802];
+        Vp8FixedCostsI4[9, 4] = [473, 909, 1164, 771, 719, 2508, 1427, 1432, 722, 782];
+        Vp8FixedCostsI4[9, 5] = [342, 892, 785, 1145, 1150, 794, 1296, 1550, 973, 1057];
+        Vp8FixedCostsI4[9, 6] = [208, 1036, 1326, 1343, 1606, 3395, 815, 1455, 1618, 712];
+        Vp8FixedCostsI4[9, 7] = [228, 928, 890, 1046, 3499, 1711, 994, 829, 1720, 1318];
+        Vp8FixedCostsI4[9, 8] = [768, 724, 1058, 636, 991, 1075, 1319, 1324, 616, 825];
+        Vp8FixedCostsI4[9, 9] = [305, 1167, 1358, 899, 1587, 1587, 987, 1988, 1332, 501];
     }
 }
diff --git a/src/ImageSharp/Formats/Webp/WebpMetadata.cs b/src/ImageSharp/Formats/Webp/WebpMetadata.cs
index db57bd8f27..9461acaf7f 100644
--- a/src/ImageSharp/Formats/Webp/WebpMetadata.cs
+++ b/src/ImageSharp/Formats/Webp/WebpMetadata.cs
@@ -1,6 +1,7 @@
 // Copyright (c) Six Labors.
 // Licensed under the Six Labors Split License.
 
+using System.Numerics;
 using SixLabors.ImageSharp.PixelFormats;
 
 namespace SixLabors.ImageSharp.Formats.Webp;
@@ -88,7 +89,7 @@ public class WebpMetadata : IFormatMetadata<WebpMetadata>
                 break;
         }
 
-        return new()
+        return new WebpMetadata
         {
             BitsPerPixel = bitsPerPixel,
             ColorType = color,
@@ -146,7 +147,7 @@ public class WebpMetadata : IFormatMetadata<WebpMetadata>
         };
 
     /// <inheritdoc/>
-    public void AfterImageApply<TPixel>(Image<TPixel> destination)
+    public void AfterImageApply<TPixel>(Image<TPixel> destination, Matrix4x4 matrix)
         where TPixel : unmanaged, IPixel<TPixel>
     {
     }
diff --git a/src/ImageSharp/Formats/Webp/WebpThrowHelper.cs b/src/ImageSharp/Formats/Webp/WebpThrowHelper.cs
index c633c52738..d730953829 100644
--- a/src/ImageSharp/Formats/Webp/WebpThrowHelper.cs
+++ b/src/ImageSharp/Formats/Webp/WebpThrowHelper.cs
@@ -18,4 +18,7 @@ internal static class WebpThrowHelper
 
     [DoesNotReturn]
     public static void ThrowInvalidImageDimensions(string errorMessage) => throw new InvalidImageContentException(errorMessage);
+
+    [DoesNotReturn]
+    public static void ThrowDimensionsTooLarge(int width, int height) => throw new ImageFormatException($"Image is too large to encode at {width}x{height} for WEBP format.");
 }
diff --git a/src/ImageSharp/Formats/_Generated/_Formats.ttinclude b/src/ImageSharp/Formats/_Generated/_Formats.ttinclude
index 89940d406e..2d6129c4c0 100644
--- a/src/ImageSharp/Formats/_Generated/_Formats.ttinclude
+++ b/src/ImageSharp/Formats/_Generated/_Formats.ttinclude
@@ -3,7 +3,7 @@
 // Copyright (c) Six Labors.
 // Licensed under the Six Labors Split License.
 <#+
-    private static readonly string[] formats = new []{
+    private static readonly string[] formats = [
         "Bmp",
         "Cur",
         "Gif",
@@ -14,15 +14,15 @@
         "Qoi",
         "Tga",
         "Tiff",
-        "Webp",
-    };
+        "Webp"
+        ];
 
-    private static readonly string[] frameFormats = new []{
+    private static readonly string[] frameFormats = [
         "Cur",
         "Ico",
         "Gif",
         "Png",
         "Tiff",
-        "Webp",
-    };
+        "Webp"
+        ];
 #>
diff --git a/src/ImageSharp/GraphicOptionsDefaultsExtensions.cs b/src/ImageSharp/GraphicOptionsDefaultsExtensions.cs
index 4220b3df77..9412062ccc 100644
--- a/src/ImageSharp/GraphicOptionsDefaultsExtensions.cs
+++ b/src/ImageSharp/GraphicOptionsDefaultsExtensions.cs
@@ -18,7 +18,7 @@ public static class GraphicOptionsDefaultsExtensions
     /// <returns>The passed in <paramref name="context"/> to allow chaining.</returns>
     public static IImageProcessingContext SetGraphicsOptions(this IImageProcessingContext context, Action<GraphicsOptions> optionsBuilder)
     {
-        var cloned = context.GetGraphicsOptions().DeepClone();
+        GraphicsOptions cloned = context.GetGraphicsOptions().DeepClone();
         optionsBuilder(cloned);
         context.Properties[typeof(GraphicsOptions)] = cloned;
         return context;
@@ -31,7 +31,7 @@ public static class GraphicOptionsDefaultsExtensions
     /// <param name="optionsBuilder">The default options to use.</param>
     public static void SetGraphicsOptions(this Configuration configuration, Action<GraphicsOptions> optionsBuilder)
     {
-        var cloned = configuration.GetGraphicsOptions().DeepClone();
+        GraphicsOptions cloned = configuration.GetGraphicsOptions().DeepClone();
         optionsBuilder(cloned);
         configuration.Properties[typeof(GraphicsOptions)] = cloned;
     }
@@ -65,7 +65,7 @@ public static class GraphicOptionsDefaultsExtensions
     /// <returns>The globaly configued default options.</returns>
     public static GraphicsOptions GetGraphicsOptions(this IImageProcessingContext context)
     {
-        if (context.Properties.TryGetValue(typeof(GraphicsOptions), out var options) && options is GraphicsOptions go)
+        if (context.Properties.TryGetValue(typeof(GraphicsOptions), out object? options) && options is GraphicsOptions go)
         {
             return go;
         }
@@ -82,12 +82,12 @@ public static class GraphicOptionsDefaultsExtensions
     /// <returns>The globaly configued default options.</returns>
     public static GraphicsOptions GetGraphicsOptions(this Configuration configuration)
     {
-        if (configuration.Properties.TryGetValue(typeof(GraphicsOptions), out var options) && options is GraphicsOptions go)
+        if (configuration.Properties.TryGetValue(typeof(GraphicsOptions), out object? options) && options is GraphicsOptions go)
         {
             return go;
         }
 
-        var configOptions = new GraphicsOptions();
+        GraphicsOptions configOptions = new();
 
         // capture the fallback so the same instance will always be returned in case its mutated
         configuration.Properties[typeof(GraphicsOptions)] = configOptions;
diff --git a/src/ImageSharp/GraphicsOptions.cs b/src/ImageSharp/GraphicsOptions.cs
index 4ac8585c3c..dc3d179027 100644
--- a/src/ImageSharp/GraphicsOptions.cs
+++ b/src/ImageSharp/GraphicsOptions.cs
@@ -84,5 +84,5 @@ public class GraphicsOptions : IDeepCloneable<GraphicsOptions>
     public PixelAlphaCompositionMode AlphaCompositionMode { get; set; } = PixelAlphaCompositionMode.SrcOver;
 
     /// <inheritdoc/>
-    public GraphicsOptions DeepClone() => new GraphicsOptions(this);
+    public GraphicsOptions DeepClone() => new(this);
 }
diff --git a/src/ImageSharp/IDeepCloneable.cs b/src/ImageSharp/IDeepCloneable.cs
index 3d00d627e0..8b225da0c7 100644
--- a/src/ImageSharp/IDeepCloneable.cs
+++ b/src/ImageSharp/IDeepCloneable.cs
@@ -1,4 +1,4 @@
-// Copyright (c) Six Labors.
+// Copyright (c) Six Labors.
 // Licensed under the Six Labors Split License.
 
 namespace SixLabors.ImageSharp;
@@ -14,7 +14,7 @@ public interface IDeepCloneable<out T>
     /// Creates a new <typeparamref name="T"/> that is a deep copy of the current instance.
     /// </summary>
     /// <returns>The <typeparamref name="T"/>.</returns>
-    T DeepClone();
+    public T DeepClone();
 }
 
 /// <summary>
@@ -26,5 +26,5 @@ public interface IDeepCloneable
     /// Creates a new object that is a deep copy of the current instance.
     /// </summary>
     /// <returns>The <see cref="IDeepCloneable"/>.</returns>
-    IDeepCloneable DeepClone();
+    public IDeepCloneable DeepClone();
 }
diff --git a/src/ImageSharp/IO/BufferedReadStream.cs b/src/ImageSharp/IO/BufferedReadStream.cs
index 1aa53d65e1..8080aab87f 100644
--- a/src/ImageSharp/IO/BufferedReadStream.cs
+++ b/src/ImageSharp/IO/BufferedReadStream.cs
@@ -69,7 +69,7 @@ internal sealed class BufferedReadStream : Stream
     }
 
     /// <summary>
-    /// Gets the number indicating the EOF hits occured while reading from this instance.
+    /// Gets the number indicating the EOF hits occurred while reading from this instance.
     /// </summary>
     public int EofHitCount { get; private set; }
 
@@ -213,20 +213,13 @@ internal sealed class BufferedReadStream : Stream
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
     public override long Seek(long offset, SeekOrigin origin)
     {
-        switch (origin)
+        this.Position = origin switch
         {
-            case SeekOrigin.Begin:
-                this.Position = offset;
-                break;
-
-            case SeekOrigin.Current:
-                this.Position += offset;
-                break;
-
-            case SeekOrigin.End:
-                this.Position = this.Length - offset;
-                break;
-        }
+            SeekOrigin.Begin => offset,
+            SeekOrigin.Current => this.Position + offset,
+            SeekOrigin.End => this.Length + offset,
+            _ => throw new ArgumentOutOfRangeException(nameof(offset)),
+        };
 
         return this.readerPosition;
     }
diff --git a/src/ImageSharp/IO/ChunkedMemoryStream.cs b/src/ImageSharp/IO/ChunkedMemoryStream.cs
index 760d1d3345..c164045df5 100644
--- a/src/ImageSharp/IO/ChunkedMemoryStream.cs
+++ b/src/ImageSharp/IO/ChunkedMemoryStream.cs
@@ -27,7 +27,7 @@ internal sealed class ChunkedMemoryStream : Stream
     /// </summary>
     /// <param name="allocator">The memory allocator.</param>
     public ChunkedMemoryStream(MemoryAllocator allocator)
-        => this.memoryChunkBuffer = new(allocator);
+        => this.memoryChunkBuffer = new MemoryChunkBuffer(allocator);
 
     /// <inheritdoc/>
     public override bool CanRead => !this.isDisposed;
@@ -76,9 +76,9 @@ internal sealed class ChunkedMemoryStream : Stream
 
         this.Position = origin switch
         {
-            SeekOrigin.Begin => (int)offset,
-            SeekOrigin.Current => (int)(this.Position + offset),
-            SeekOrigin.End => (int)(this.Length + offset),
+            SeekOrigin.Begin => offset,
+            SeekOrigin.Current => this.Position + offset,
+            SeekOrigin.End => this.Length + offset,
             _ => throw new ArgumentOutOfRangeException(nameof(offset)),
         };
 
@@ -387,7 +387,7 @@ internal sealed class ChunkedMemoryStream : Stream
 
     private sealed class MemoryChunkBuffer : IDisposable
     {
-        private readonly List<MemoryChunk> memoryChunks = new();
+        private readonly List<MemoryChunk> memoryChunks = [];
         private readonly MemoryAllocator allocator;
         private readonly int allocatorCapacity;
         private bool isDisposed;
diff --git a/src/ImageSharp/ImageExtensions.cs b/src/ImageSharp/ImageExtensions.cs
index 6c769a9d17..c6853b40ca 100644
--- a/src/ImageSharp/ImageExtensions.cs
+++ b/src/ImageSharp/ImageExtensions.cs
@@ -179,6 +179,6 @@ public static partial class ImageExtensions
 
         // Always available.
         stream.TryGetBuffer(out ArraySegment<byte> buffer);
-        return $"data:{format.DefaultMimeType};base64,{Convert.ToBase64String(buffer.Array ?? Array.Empty<byte>(), 0, (int)stream.Length)}";
+        return $"data:{format.DefaultMimeType};base64,{Convert.ToBase64String(buffer.Array ?? [], 0, (int)stream.Length)}";
     }
 }
diff --git a/src/ImageSharp/ImageFrame.LoadPixelData.cs b/src/ImageSharp/ImageFrame.LoadPixelData.cs
index 61f4c0ea9d..003a0349ae 100644
--- a/src/ImageSharp/ImageFrame.LoadPixelData.cs
+++ b/src/ImageSharp/ImageFrame.LoadPixelData.cs
@@ -40,7 +40,7 @@ public partial class ImageFrame
         int count = width * height;
         Guard.MustBeGreaterThanOrEqualTo(data.Length, count, nameof(data));
 
-        var image = new ImageFrame<TPixel>(configuration, width, height);
+        ImageFrame<TPixel> image = new(configuration, width, height);
 
         data = data[..count];
         data.CopyTo(image.PixelBuffer.FastMemoryGroup);
diff --git a/src/ImageSharp/ImageFrame.cs b/src/ImageSharp/ImageFrame.cs
index 686292bc7f..3d4b63fad5 100644
--- a/src/ImageSharp/ImageFrame.cs
+++ b/src/ImageSharp/ImageFrame.cs
@@ -25,7 +25,7 @@ public abstract partial class ImageFrame : IConfigurationProvider, IDisposable
     protected ImageFrame(Configuration configuration, int width, int height, ImageFrameMetadata metadata)
     {
         this.Configuration = configuration;
-        this.Size = new(width, height);
+        this.Size = new Size(width, height);
         this.Metadata = metadata;
     }
 
diff --git a/src/ImageSharp/ImageSharp.csproj b/src/ImageSharp/ImageSharp.csproj
index 36f28f5df8..9a48873fc6 100644
--- a/src/ImageSharp/ImageSharp.csproj
+++ b/src/ImageSharp/ImageSharp.csproj
@@ -55,21 +55,15 @@
       <DesignTime>True</DesignTime>
       <AutoGen>True</AutoGen>
       <DependentUpon>Heif4CharCode.tt</DependentUpon>
-    </Compile>
-    <Compile Update="Formats\_Generated\ImageMetadataExtensions.cs">
+    <Compile Update="Common\InlineArray.cs">
       <DesignTime>True</DesignTime>
       <AutoGen>True</AutoGen>
-      <DependentUpon>ImageMetadataExtensions.tt</DependentUpon>
+      <DependentUpon>InlineArray.tt</DependentUpon>
     </Compile>
-    <Compile Update="Formats\Jpeg\Components\Block8x8F.Generated.cs">
-      <DesignTime>True</DesignTime>
-      <AutoGen>True</AutoGen>
-      <DependentUpon>Block8x8F.Generated.tt</DependentUpon>
-    </Compile>
-    <Compile Update="Formats\Jpeg\Components\Block8x8F.Generated.cs">
+    <Compile Update="Formats\_Generated\ImageMetadataExtensions.cs">
       <DesignTime>True</DesignTime>
       <AutoGen>True</AutoGen>
-      <DependentUpon>Block8x8F.Generated.tt</DependentUpon>
+      <DependentUpon>ImageMetadataExtensions.tt</DependentUpon>
     </Compile>
     <Compile Update="PixelFormats\PixelImplementations\PixelOperations\Generated\Abgr32.PixelOperations.Generated.cs">
       <DesignTime>True</DesignTime>
@@ -162,19 +156,14 @@
     <None Update="Formats\Heif\Heif4CharCode.tt">
       <Generator>TextTemplatingFileGenerator</Generator>
       <LastGenOutput>Heif4CharCode.cs</LastGenOutput>
+    <None Update="Common\InlineArray.tt">
+      <Generator>TextTemplatingFileGenerator</Generator>
+      <LastGenOutput>InlineArray.cs</LastGenOutput>
     </None>
     <None Update="Formats\_Generated\ImageMetadataExtensions.tt">
       <LastGenOutput>ImageMetadataExtensions.cs</LastGenOutput>
       <Generator>TextTemplatingFileGenerator</Generator>
     </None>
-    <None Update="Formats\Jpeg\Components\Block8x8F.Generated.tt">
-      <Generator>TextTemplatingFileGenerator</Generator>
-      <LastGenOutput>Block8x8F.Generated.cs</LastGenOutput>
-    </None>
-    <None Update="Formats\Jpeg\Components\Block8x8F.Generated.tt">
-      <Generator>TextTemplatingFileGenerator</Generator>
-      <LastGenOutput>Block8x8F.Generated.cs</LastGenOutput>
-    </None>
     <None Update="PixelFormats\PixelImplementations\PixelOperations\Generated\Abgr32.PixelOperations.Generated.tt">
       <Generator>TextTemplatingFileGenerator</Generator>
       <LastGenOutput>Abgr32.PixelOperations.Generated.cs</LastGenOutput>
diff --git a/src/ImageSharp/Image{TPixel}.cs b/src/ImageSharp/Image{TPixel}.cs
index 7ec7918381..dff8f577fd 100644
--- a/src/ImageSharp/Image{TPixel}.cs
+++ b/src/ImageSharp/Image{TPixel}.cs
@@ -77,7 +77,7 @@ public sealed class Image<TPixel> : Image
     /// <param name="height">The height of the image in pixels.</param>
     /// <param name="metadata">The images metadata.</param>
     internal Image(Configuration configuration, int width, int height, ImageMetadata? metadata)
-        : base(configuration, TPixel.GetPixelTypeInfo(), metadata ?? new(), width, height)
+        : base(configuration, TPixel.GetPixelTypeInfo(), metadata ?? new ImageMetadata(), width, height)
         => this.frames = new ImageFrameCollection<TPixel>(this, width, height, default(TPixel));
 
     /// <summary>
@@ -128,7 +128,7 @@ public sealed class Image<TPixel> : Image
         int height,
         TPixel backgroundColor,
         ImageMetadata? metadata)
-        : base(configuration, TPixel.GetPixelTypeInfo(), metadata ?? new(), width, height)
+        : base(configuration, TPixel.GetPixelTypeInfo(), metadata ?? new ImageMetadata(), width, height)
         => this.frames = new ImageFrameCollection<TPixel>(this, width, height, backgroundColor);
 
     /// <summary>
diff --git a/src/ImageSharp/IndexedImageFrame{TPixel}.cs b/src/ImageSharp/IndexedImageFrame{TPixel}.cs
index 6807e77ad2..a88cdb524e 100644
--- a/src/ImageSharp/IndexedImageFrame{TPixel}.cs
+++ b/src/ImageSharp/IndexedImageFrame{TPixel}.cs
@@ -25,12 +25,12 @@ public sealed class IndexedImageFrame<TPixel> : IPixelSource, IDisposable
     /// Initializes a new instance of the <see cref="IndexedImageFrame{TPixel}"/> class.
     /// </summary>
     /// <param name="configuration">
-    /// The configuration which allows altering default behaviour or extending the library.
+    /// The configuration which allows altering default behavior or extending the library.
     /// </param>
     /// <param name="width">The frame width.</param>
     /// <param name="height">The frame height.</param>
     /// <param name="palette">The color palette.</param>
-    internal IndexedImageFrame(Configuration configuration, int width, int height, ReadOnlyMemory<TPixel> palette)
+    public IndexedImageFrame(Configuration configuration, int width, int height, ReadOnlyMemory<TPixel> palette)
     {
         Guard.NotNull(configuration, nameof(configuration));
         Guard.MustBeLessThanOrEqualTo(palette.Length, QuantizerConstants.MaxColors, nameof(palette));
@@ -42,14 +42,14 @@ public sealed class IndexedImageFrame<TPixel> : IPixelSource, IDisposable
         this.Height = height;
         this.pixelBuffer = configuration.MemoryAllocator.Allocate2D<byte>(width, height);
 
-        // Copy the palette over. We want the lifetime of this frame to be independant of any palette source.
+        // Copy the palette over. We want the lifetime of this frame to be independent of any palette source.
         this.paletteOwner = configuration.MemoryAllocator.Allocate<TPixel>(palette.Length);
         palette.Span.CopyTo(this.paletteOwner.GetSpan());
         this.Palette = this.paletteOwner.Memory[..palette.Length];
     }
 
     /// <summary>
-    /// Gets the configuration which allows altering default behaviour or extending the library.
+    /// Gets the configuration which allows altering default behavior or extending the library.
     /// </summary>
     public Configuration Configuration { get; }
 
diff --git a/src/ImageSharp/Memory/Allocators/Internals/UniformUnmanagedMemoryPool.LifetimeGuards.cs b/src/ImageSharp/Memory/Allocators/Internals/UniformUnmanagedMemoryPool.LifetimeGuards.cs
index 24bf52b1f9..e3b73204de 100644
--- a/src/ImageSharp/Memory/Allocators/Internals/UniformUnmanagedMemoryPool.LifetimeGuards.cs
+++ b/src/ImageSharp/Memory/Allocators/Internals/UniformUnmanagedMemoryPool.LifetimeGuards.cs
@@ -11,7 +11,7 @@ internal partial class UniformUnmanagedMemoryPool
         bool clear)
         where T : struct
     {
-        var buffer = new UnmanagedBuffer<T>(lengthInElements, new ReturnToPoolBufferLifetimeGuard(this, handle));
+        UnmanagedBuffer<T> buffer = new(lengthInElements, new ReturnToPoolBufferLifetimeGuard(this, handle));
         if (clear)
         {
             buffer.Clear();
diff --git a/src/ImageSharp/Memory/Allocators/Internals/UniformUnmanagedMemoryPool.cs b/src/ImageSharp/Memory/Allocators/Internals/UniformUnmanagedMemoryPool.cs
index aa8bcd3859..d4ad22060d 100644
--- a/src/ImageSharp/Memory/Allocators/Internals/UniformUnmanagedMemoryPool.cs
+++ b/src/ImageSharp/Memory/Allocators/Internals/UniformUnmanagedMemoryPool.cs
@@ -11,7 +11,7 @@ namespace SixLabors.ImageSharp.Memory.Internals;
 internal partial class UniformUnmanagedMemoryPool : System.Runtime.ConstrainedExecution.CriticalFinalizerObject
 {
     private static int minTrimPeriodMilliseconds = int.MaxValue;
-    private static readonly List<WeakReference<UniformUnmanagedMemoryPool>> AllPools = new();
+    private static readonly List<WeakReference<UniformUnmanagedMemoryPool>> AllPools = [];
     private static Timer? trimTimer;
 
     private static readonly Stopwatch Stopwatch = Stopwatch.StartNew();
@@ -337,6 +337,6 @@ internal partial class UniformUnmanagedMemoryPool : System.Runtime.ConstrainedEx
 
         public bool Enabled => this.Rate > 0;
 
-        public static TrimSettings Default => new TrimSettings();
+        public static TrimSettings Default => new();
     }
 }
diff --git a/src/ImageSharp/Memory/Allocators/Internals/UnmanagedBuffer{T}.cs b/src/ImageSharp/Memory/Allocators/Internals/UnmanagedBuffer{T}.cs
index de09647261..854b40e0c7 100644
--- a/src/ImageSharp/Memory/Allocators/Internals/UnmanagedBuffer{T}.cs
+++ b/src/ImageSharp/Memory/Allocators/Internals/UnmanagedBuffer{T}.cs
@@ -35,7 +35,7 @@ internal sealed unsafe class UnmanagedBuffer<T> : MemoryManager<T>, IRefCounted
     {
         DebugGuard.NotDisposed(this.disposed == 1, this.GetType().Name);
         DebugGuard.NotDisposed(this.lifetimeGuard.IsDisposed, this.lifetimeGuard.GetType().Name);
-        return new(this.Pointer, this.lengthInElements);
+        return new Span<T>(this.Pointer, this.lengthInElements);
     }
 
     /// <inheritdoc />
diff --git a/src/ImageSharp/Memory/Allocators/UniformUnmanagedMemoryPoolMemoryAllocator.cs b/src/ImageSharp/Memory/Allocators/UniformUnmanagedMemoryPoolMemoryAllocator.cs
index 621073a3db..10defe6cdf 100644
--- a/src/ImageSharp/Memory/Allocators/UniformUnmanagedMemoryPoolMemoryAllocator.cs
+++ b/src/ImageSharp/Memory/Allocators/UniformUnmanagedMemoryPoolMemoryAllocator.cs
@@ -96,7 +96,7 @@ internal sealed class UniformUnmanagedMemoryPoolMemoryAllocator : MemoryAllocato
 
         if (lengthInBytes <= (ulong)this.sharedArrayPoolThresholdInBytes)
         {
-            var buffer = new SharedArrayPoolBuffer<T>(length);
+            SharedArrayPoolBuffer<T> buffer = new(length);
             if (options.Has(AllocationOptions.Clean))
             {
                 buffer.GetSpan().Clear();
@@ -127,7 +127,7 @@ internal sealed class UniformUnmanagedMemoryPoolMemoryAllocator : MemoryAllocato
     {
         if (totalLengthInBytes <= this.sharedArrayPoolThresholdInBytes)
         {
-            var buffer = new SharedArrayPoolBuffer<T>((int)totalLengthInElements);
+            SharedArrayPoolBuffer<T> buffer = new((int)totalLengthInElements);
             return MemoryGroup<T>.CreateContiguous(buffer, options.Has(AllocationOptions.Clean));
         }
 
diff --git a/src/ImageSharp/Memory/Allocators/UnmanagedMemoryAllocator.cs b/src/ImageSharp/Memory/Allocators/UnmanagedMemoryAllocator.cs
index da202aa596..daf1a79925 100644
--- a/src/ImageSharp/Memory/Allocators/UnmanagedMemoryAllocator.cs
+++ b/src/ImageSharp/Memory/Allocators/UnmanagedMemoryAllocator.cs
@@ -20,7 +20,7 @@ internal class UnmanagedMemoryAllocator : MemoryAllocator
 
     public override IMemoryOwner<T> Allocate<T>(int length, AllocationOptions options = AllocationOptions.None)
     {
-        var buffer = UnmanagedBuffer<T>.Allocate(length);
+        UnmanagedBuffer<T> buffer = UnmanagedBuffer<T>.Allocate(length);
         if (options.Has(AllocationOptions.Clean))
         {
             buffer.GetSpan().Clear();
diff --git a/src/ImageSharp/Memory/DiscontiguousBuffers/MemoryGroupExtensions.cs b/src/ImageSharp/Memory/DiscontiguousBuffers/MemoryGroupExtensions.cs
index e2e933f3cc..148b5f6bfb 100644
--- a/src/ImageSharp/Memory/DiscontiguousBuffers/MemoryGroupExtensions.cs
+++ b/src/ImageSharp/Memory/DiscontiguousBuffers/MemoryGroupExtensions.cs
@@ -77,7 +77,7 @@ internal static class MemoryGroupExtensions
         Guard.NotNull(source, nameof(source));
         Guard.MustBeGreaterThanOrEqualTo(target.Length, source.TotalLength, nameof(target));
 
-        var cur = new MemoryGroupCursor<T>(source);
+        MemoryGroupCursor<T> cur = new(source);
         long position = 0;
         while (position < source.TotalLength)
         {
@@ -100,7 +100,7 @@ internal static class MemoryGroupExtensions
         Guard.NotNull(target, nameof(target));
         Guard.MustBeGreaterThanOrEqualTo(target.TotalLength, source.Length, nameof(target));
 
-        var cur = new MemoryGroupCursor<T>(target);
+        MemoryGroupCursor<T> cur = new(target);
 
         while (!source.IsEmpty)
         {
@@ -126,8 +126,8 @@ internal static class MemoryGroupExtensions
         }
 
         long position = 0;
-        var srcCur = new MemoryGroupCursor<T>(source);
-        var trgCur = new MemoryGroupCursor<T>(target);
+        MemoryGroupCursor<T> srcCur = new(source);
+        MemoryGroupCursor<T> trgCur = new(target);
 
         while (position < source.TotalLength)
         {
@@ -162,8 +162,8 @@ internal static class MemoryGroupExtensions
         }
 
         long position = 0;
-        var srcCur = new MemoryGroupCursor<TSource>(source);
-        var trgCur = new MemoryGroupCursor<TTarget>(target);
+        MemoryGroupCursor<TSource> srcCur = new(source);
+        MemoryGroupCursor<TTarget> trgCur = new(target);
 
         while (position < source.TotalLength)
         {
diff --git a/src/ImageSharp/Memory/DiscontiguousBuffers/MemoryGroup{T}.Owned.cs b/src/ImageSharp/Memory/DiscontiguousBuffers/MemoryGroup{T}.Owned.cs
index 9da0139e6e..af896ee0e1 100644
--- a/src/ImageSharp/Memory/DiscontiguousBuffers/MemoryGroup{T}.Owned.cs
+++ b/src/ImageSharp/Memory/DiscontiguousBuffers/MemoryGroup{T}.Owned.cs
@@ -66,14 +66,14 @@ internal abstract partial class MemoryGroup<T>
             int sizeOfLastBuffer,
             AllocationOptions options)
         {
-            var result = new IMemoryOwner<T>[pooledBuffers.Length];
+            IMemoryOwner<T>[] result = new IMemoryOwner<T>[pooledBuffers.Length];
             for (int i = 0; i < pooledBuffers.Length - 1; i++)
             {
-                var currentBuffer = ObservedBuffer.Create(pooledBuffers[i], bufferLength, options);
+                ObservedBuffer currentBuffer = ObservedBuffer.Create(pooledBuffers[i], bufferLength, options);
                 result[i] = currentBuffer;
             }
 
-            var lastBuffer = ObservedBuffer.Create(pooledBuffers[pooledBuffers.Length - 1], sizeOfLastBuffer, options);
+            ObservedBuffer lastBuffer = ObservedBuffer.Create(pooledBuffers[pooledBuffers.Length - 1], sizeOfLastBuffer, options);
             result[result.Length - 1] = lastBuffer;
             return result;
         }
@@ -193,7 +193,7 @@ internal abstract partial class MemoryGroup<T>
                 int lengthInElements,
                 AllocationOptions options)
             {
-                var buffer = new ObservedBuffer(handle, lengthInElements);
+                ObservedBuffer buffer = new(handle, lengthInElements);
                 if (options.Has(AllocationOptions.Clean))
                 {
                     buffer.GetSpan().Clear();
diff --git a/src/ImageSharp/Memory/DiscontiguousBuffers/MemoryGroup{T}.cs b/src/ImageSharp/Memory/DiscontiguousBuffers/MemoryGroup{T}.cs
index 03c29a7231..6dd99fcb02 100644
--- a/src/ImageSharp/Memory/DiscontiguousBuffers/MemoryGroup{T}.cs
+++ b/src/ImageSharp/Memory/DiscontiguousBuffers/MemoryGroup{T}.cs
@@ -97,7 +97,7 @@ internal abstract partial class MemoryGroup<T> : IMemoryGroup<T>, IDisposable
 
         if (totalLengthInElements == 0)
         {
-            var buffers0 = new IMemoryOwner<T>[1] { allocator.Allocate<T>(0, options) };
+            IMemoryOwner<T>[] buffers0 = [allocator.Allocate<T>(0, options)];
             return new Owned(buffers0, 0, 0, true);
         }
 
@@ -120,7 +120,7 @@ internal abstract partial class MemoryGroup<T> : IMemoryGroup<T>, IDisposable
             bufferCount++;
         }
 
-        var buffers = new IMemoryOwner<T>[bufferCount];
+        IMemoryOwner<T>[] buffers = new IMemoryOwner<T>[bufferCount];
         for (int i = 0; i < buffers.Length - 1; i++)
         {
             buffers[i] = allocator.Allocate<T>(bufferLength, options);
@@ -142,7 +142,7 @@ internal abstract partial class MemoryGroup<T> : IMemoryGroup<T>, IDisposable
         }
 
         int length = buffer.Memory.Length;
-        var buffers = new IMemoryOwner<T>[1] { buffer };
+        IMemoryOwner<T>[] buffers = [buffer];
         return new Owned(buffers, length, length, true);
     }
 
diff --git a/src/ImageSharp/Memory/RowInterval.cs b/src/ImageSharp/Memory/RowInterval.cs
index 90a88d735a..f27dc74411 100644
--- a/src/ImageSharp/Memory/RowInterval.cs
+++ b/src/ImageSharp/Memory/RowInterval.cs
@@ -79,7 +79,7 @@ public readonly struct RowInterval : IEquatable<RowInterval>
     /// <inheritdoc />
     public override string ToString() => $"RowInterval [{this.Min}->{this.Max}]";
 
-    internal RowInterval Slice(int start) => new RowInterval(this.Min + start, this.Max);
+    internal RowInterval Slice(int start) => new(this.Min + start, this.Max);
 
-    internal RowInterval Slice(int start, int length) => new RowInterval(this.Min + start, this.Min + start + length);
+    internal RowInterval Slice(int start, int length) => new(this.Min + start, this.Min + start + length);
 }
diff --git a/src/ImageSharp/Metadata/ImageFrameMetadata.cs b/src/ImageSharp/Metadata/ImageFrameMetadata.cs
index b24aa140fc..554afd69aa 100644
--- a/src/ImageSharp/Metadata/ImageFrameMetadata.cs
+++ b/src/ImageSharp/Metadata/ImageFrameMetadata.cs
@@ -1,6 +1,7 @@
 // Copyright (c) Six Labors.
 // Licensed under the Six Labors Split License.
 
+using System.Numerics;
 using SixLabors.ImageSharp.Formats;
 using SixLabors.ImageSharp.Metadata.Profiles.Cicp;
 using SixLabors.ImageSharp.Metadata.Profiles.Exif;
@@ -158,16 +159,21 @@ public sealed class ImageFrameMetadata : IDeepCloneable<ImageFrameMetadata>
     /// <typeparam name="TPixel">The type of pixel format.</typeparam>
     /// <param name="source">The source image frame.</param>
     /// <param name="destination">The destination image frame.</param>
-    internal void AfterFrameApply<TPixel>(ImageFrame<TPixel> source, ImageFrame<TPixel> destination)
+    /// <param name="matrix">The transformation matrix applied to the frame.</param>
+    internal void AfterFrameApply<TPixel>(
+        ImageFrame<TPixel> source,
+        ImageFrame<TPixel> destination,
+        Matrix4x4 matrix)
         where TPixel : unmanaged, IPixel<TPixel>
     {
         // Always updated using the full frame dimensions.
         // Individual format frame metadata will update with sub region dimensions if appropriate.
         this.ExifProfile?.SyncDimensions(destination.Width, destination.Height);
+        this.ExifProfile?.SyncSubject(destination.Width, destination.Height, matrix);
 
         foreach (KeyValuePair<IImageFormat, IFormatFrameMetadata> meta in this.formatMetadata)
         {
-            meta.Value.AfterFrameApply(source, destination);
+            meta.Value.AfterFrameApply(source, destination, matrix);
         }
     }
 }
diff --git a/src/ImageSharp/Metadata/ImageMetadata.cs b/src/ImageSharp/Metadata/ImageMetadata.cs
index 1961dbf192..918cf162a5 100644
--- a/src/ImageSharp/Metadata/ImageMetadata.cs
+++ b/src/ImageSharp/Metadata/ImageMetadata.cs
@@ -1,6 +1,7 @@
 // Copyright (c) Six Labors.
 // Licensed under the Six Labors Split License.
 
+using System.Numerics;
 using SixLabors.ImageSharp.Formats;
 using SixLabors.ImageSharp.Metadata.Profiles.Cicp;
 using SixLabors.ImageSharp.Metadata.Profiles.Exif;
@@ -235,14 +236,16 @@ public sealed class ImageMetadata : IDeepCloneable<ImageMetadata>
     /// </summary>
     /// <typeparam name="TPixel">The type of pixel format.</typeparam>
     /// <param name="destination">The destination image.</param>
-    internal void AfterImageApply<TPixel>(Image<TPixel> destination)
+    /// <param name="matrix">The transformation matrix applied to the image.</param>
+    internal void AfterImageApply<TPixel>(Image<TPixel> destination, Matrix4x4 matrix)
         where TPixel : unmanaged, IPixel<TPixel>
     {
         this.ExifProfile?.SyncDimensions(destination.Width, destination.Height);
+        this.ExifProfile?.SyncSubject(destination.Width, destination.Height, matrix);
 
         foreach (KeyValuePair<IImageFormat, IFormatMetadata> meta in this.formatMetadata)
         {
-            meta.Value.AfterImageApply(destination);
+            meta.Value.AfterImageApply(destination, matrix);
         }
     }
 
diff --git a/src/ImageSharp/Metadata/Profiles/Exif/ExifConstants.cs b/src/ImageSharp/Metadata/Profiles/Exif/ExifConstants.cs
index 725533ea5f..df6f7bdf83 100644
--- a/src/ImageSharp/Metadata/Profiles/Exif/ExifConstants.cs
+++ b/src/ImageSharp/Metadata/Profiles/Exif/ExifConstants.cs
@@ -7,21 +7,21 @@ namespace SixLabors.ImageSharp.Metadata.Profiles.Exif;
 
 internal static class ExifConstants
 {
-    public static ReadOnlySpan<byte> LittleEndianByteOrderMarker => new byte[]
-    {
+    public static ReadOnlySpan<byte> LittleEndianByteOrderMarker =>
+    [
         (byte)'I',
         (byte)'I',
         0x2A,
-        0x00,
-    };
+        0x00
+    ];
 
-    public static ReadOnlySpan<byte> BigEndianByteOrderMarker => new byte[]
-    {
+    public static ReadOnlySpan<byte> BigEndianByteOrderMarker =>
+    [
         (byte)'M',
         (byte)'M',
         0x00,
         0x2A
-    };
+    ];
 
     // UTF-8 is better than ASCII, UTF-8 encodes the ASCII codes the same way
     public static Encoding DefaultEncoding => Encoding.UTF8;
diff --git a/src/ImageSharp/Metadata/Profiles/Exif/ExifDataType.cs b/src/ImageSharp/Metadata/Profiles/Exif/ExifDataType.cs
index 90a5d15b74..e0b549362d 100644
--- a/src/ImageSharp/Metadata/Profiles/Exif/ExifDataType.cs
+++ b/src/ImageSharp/Metadata/Profiles/Exif/ExifDataType.cs
@@ -4,7 +4,7 @@
 namespace SixLabors.ImageSharp.Metadata.Profiles.Exif;
 
 /// <summary>
-/// Specifies exif data types.
+/// Specifies Exif data types.
 /// </summary>
 public enum ExifDataType
 {
diff --git a/src/ImageSharp/Metadata/Profiles/Exif/ExifEncodedStringHelpers.cs b/src/ImageSharp/Metadata/Profiles/Exif/ExifEncodedStringHelpers.cs
index e9f46731c8..d2b88cbfff 100644
--- a/src/ImageSharp/Metadata/Profiles/Exif/ExifEncodedStringHelpers.cs
+++ b/src/ImageSharp/Metadata/Profiles/Exif/ExifEncodedStringHelpers.cs
@@ -16,13 +16,13 @@ internal static class ExifEncodedStringHelpers
     private const ulong UnicodeCode = 0x_45_44_4F_43_49_4E_55;
     private const ulong UndefinedCode = 0x_00_00_00_00_00_00_00_00;
 
-    private static ReadOnlySpan<byte> AsciiCodeBytes => new byte[] { 0x41, 0x53, 0x43, 0x49, 0x49, 0, 0, 0 };
+    private static ReadOnlySpan<byte> AsciiCodeBytes => [0x41, 0x53, 0x43, 0x49, 0x49, 0, 0, 0];
 
-    private static ReadOnlySpan<byte> JISCodeBytes => new byte[] { 0x4A, 0x49, 0x53, 0, 0, 0, 0, 0 };
+    private static ReadOnlySpan<byte> JISCodeBytes => [0x4A, 0x49, 0x53, 0, 0, 0, 0, 0];
 
-    private static ReadOnlySpan<byte> UnicodeCodeBytes => new byte[] { 0x55, 0x4E, 0x49, 0x43, 0x4F, 0x44, 0x45, 0 };
+    private static ReadOnlySpan<byte> UnicodeCodeBytes => [0x55, 0x4E, 0x49, 0x43, 0x4F, 0x44, 0x45, 0];
 
-    private static ReadOnlySpan<byte> UndefinedCodeBytes => new byte[] { 0, 0, 0, 0, 0, 0, 0, 0 };
+    private static ReadOnlySpan<byte> UndefinedCodeBytes => [0, 0, 0, 0, 0, 0, 0, 0];
 
     // 20932 EUC-JP Japanese (JIS 0208-1990 and 0212-1990)
     // https://docs.microsoft.com/en-us/dotnet/api/system.text.encoding?view=net-6.0
@@ -50,22 +50,45 @@ internal static class ExifEncodedStringHelpers
         _ => UndefinedCodeBytes
     };
 
-    public static Encoding GetEncoding(CharacterCode code) => code switch
+    public static Encoding GetEncoding(CharacterCode code, ByteOrder order) => code switch
     {
         CharacterCode.ASCII => Encoding.ASCII,
         CharacterCode.JIS => JIS0208Encoding,
-        CharacterCode.Unicode => Encoding.Unicode,
+        CharacterCode.Unicode => order is ByteOrder.BigEndian ? Encoding.BigEndianUnicode : Encoding.Unicode,
         CharacterCode.Undefined => Encoding.UTF8,
         _ => Encoding.UTF8
     };
 
-    public static bool TryParse(ReadOnlySpan<byte> buffer, out EncodedString encodedString)
+    public static bool TryParse(ReadOnlySpan<byte> buffer, ByteOrder order, out EncodedString encodedString)
     {
         if (TryDetect(buffer, out CharacterCode code))
         {
-            string text = GetEncoding(code).GetString(buffer[CharacterCodeBytesLength..]);
-            encodedString = new EncodedString(code, text);
-            return true;
+            ReadOnlySpan<byte> textBuffer = buffer[CharacterCodeBytesLength..];
+            if (code == CharacterCode.Unicode && textBuffer.Length >= 2)
+            {
+                // Check BOM
+                if (textBuffer.StartsWith((ReadOnlySpan<byte>)[0xFF, 0xFE]))
+                {
+                    // Little-endian BOM
+                    string text = Encoding.Unicode.GetString(textBuffer[2..]);
+                    encodedString = new EncodedString(code, text);
+                    return true;
+                }
+
+                if (textBuffer.StartsWith((ReadOnlySpan<byte>)[0xFE, 0xFF]))
+                {
+                    // Big-endian BOM
+                    string text = Encoding.BigEndianUnicode.GetString(textBuffer[2..]);
+                    encodedString = new EncodedString(code, text);
+                    return true;
+                }
+            }
+
+            {
+                string text = GetEncoding(code, order).GetString(textBuffer);
+                encodedString = new EncodedString(code, text);
+                return true;
+            }
         }
 
         encodedString = default;
@@ -73,14 +96,14 @@ internal static class ExifEncodedStringHelpers
     }
 
     public static uint GetDataLength(EncodedString encodedString) =>
-        (uint)GetEncoding(encodedString.Code).GetByteCount(encodedString.Text) + CharacterCodeBytesLength;
+        (uint)GetEncoding(encodedString.Code, ByteOrder.LittleEndian).GetByteCount(encodedString.Text) + CharacterCodeBytesLength;
 
     public static int Write(EncodedString encodedString, Span<byte> destination)
     {
         GetCodeBytes(encodedString.Code).CopyTo(destination);
 
         string text = encodedString.Text;
-        int count = Write(GetEncoding(encodedString.Code), text, destination[CharacterCodeBytesLength..]);
+        int count = Write(GetEncoding(encodedString.Code, ByteOrder.LittleEndian), text, destination[CharacterCodeBytesLength..]);
 
         return CharacterCodeBytesLength + count;
     }
@@ -92,8 +115,7 @@ internal static class ExifEncodedStringHelpers
     {
         if (buffer.Length >= CharacterCodeBytesLength)
         {
-            ulong test = BinaryPrimitives.ReadUInt64LittleEndian(buffer);
-            switch (test)
+            switch (BinaryPrimitives.ReadUInt64LittleEndian(buffer))
             {
                 case AsciiCode:
                     code = CharacterCode.ASCII;
@@ -108,7 +130,8 @@ internal static class ExifEncodedStringHelpers
                     code = CharacterCode.Undefined;
                     return true;
                 default:
-                    break;
+                    code = default;
+                    return false;
             }
         }
 
diff --git a/src/ImageSharp/Metadata/Profiles/Exif/ExifProfile.cs b/src/ImageSharp/Metadata/Profiles/Exif/ExifProfile.cs
index e91a69444d..d7932f90b6 100644
--- a/src/ImageSharp/Metadata/Profiles/Exif/ExifProfile.cs
+++ b/src/ImageSharp/Metadata/Profiles/Exif/ExifProfile.cs
@@ -2,8 +2,9 @@
 // Licensed under the Six Labors Split License.
 
 using System.Diagnostics.CodeAnalysis;
+using System.Numerics;
 using SixLabors.ImageSharp.PixelFormats;
-using static System.Runtime.InteropServices.JavaScript.JSType;
+using SixLabors.ImageSharp.Processing.Processors.Transforms;
 
 namespace SixLabors.ImageSharp.Metadata.Profiles.Exif;
 
@@ -48,7 +49,7 @@ public sealed class ExifProfile : IDeepCloneable<ExifProfile>
     {
         this.Parts = ExifParts.All;
         this.data = data;
-        this.InvalidTags = Array.Empty<ExifTag>();
+        this.InvalidTags = [];
     }
 
     /// <summary>
@@ -161,17 +162,15 @@ public sealed class ExifProfile : IDeepCloneable<ExifProfile>
             return false;
         }
 
-        using (MemoryStream memStream = new(this.data, this.thumbnailOffset, this.thumbnailLength))
-        {
-            image = Image.Load<TPixel>(memStream);
-            return true;
-        }
+        using MemoryStream memStream = new(this.data, this.thumbnailOffset, this.thumbnailLength);
+        image = Image.Load<TPixel>(memStream);
+        return true;
     }
 
     /// <summary>
     /// Returns the value with the specified tag.
     /// </summary>
-    /// <param name="tag">The tag of the exif value.</param>
+    /// <param name="tag">The tag of the Exif value.</param>
     /// <param name="exifValue">The value with the specified tag.</param>
     /// <returns>True when found, otherwise false</returns>
     /// <typeparam name="TValueType">The data type of the tag.</typeparam>
@@ -215,7 +214,7 @@ public sealed class ExifProfile : IDeepCloneable<ExifProfile>
     /// <summary>
     /// Sets the value of the specified tag.
     /// </summary>
-    /// <param name="tag">The tag of the exif value.</param>
+    /// <param name="tag">The tag of the Exif value.</param>
     /// <param name="value">The value.</param>
     /// <typeparam name="TValueType">The data type of the tag.</typeparam>
     public void SetValue<TValueType>(ExifTag<TValueType> tag, TValueType value)
@@ -234,7 +233,7 @@ public sealed class ExifProfile : IDeepCloneable<ExifProfile>
 
         if (this.values.Count == 0)
         {
-            return Array.Empty<byte>();
+            return [];
         }
 
         ExifWriter writer = new(this.values, this.Parts);
@@ -247,7 +246,7 @@ public sealed class ExifProfile : IDeepCloneable<ExifProfile>
     /// <summary>
     /// Returns the value with the specified tag.
     /// </summary>
-    /// <param name="tag">The tag of the exif value.</param>
+    /// <param name="tag">The tag of the Exif value.</param>
     /// <returns>The value with the specified tag.</returns>
     internal IExifValue? GetValueInternal(ExifTag tag)
     {
@@ -265,9 +264,9 @@ public sealed class ExifProfile : IDeepCloneable<ExifProfile>
     /// <summary>
     /// Sets the value of the specified tag.
     /// </summary>
-    /// <param name="tag">The tag of the exif value.</param>
+    /// <param name="tag">The tag of the Exif value.</param>
     /// <param name="value">The value.</param>
-    /// <exception cref="NotSupportedException">Newly created value is null.</exception>
+    /// <exception cref="NotSupportedException">The newly created value is null.</exception>
     internal void SetValueInternal(ExifTag tag, object? value)
     {
         foreach (IExifValue exifValue in this.Values)
@@ -279,11 +278,7 @@ public sealed class ExifProfile : IDeepCloneable<ExifProfile>
             }
         }
 
-        ExifValue? newExifValue = ExifValues.Create(tag);
-        if (newExifValue is null)
-        {
-            throw new NotSupportedException($"Newly created value for tag {tag} is null.");
-        }
+        ExifValue? newExifValue = ExifValues.Create(tag) ?? throw new NotSupportedException($"Newly created value for tag {tag} is null.");
 
         newExifValue.TrySetValue(value);
         this.values.Add(newExifValue);
@@ -312,6 +307,60 @@ public sealed class ExifProfile : IDeepCloneable<ExifProfile>
         }
     }
 
+    internal void SyncSubject(int width, int height, Matrix4x4 matrix)
+    {
+        if (matrix.IsIdentity)
+        {
+            return;
+        }
+
+        if (this.TryGetValue(ExifTag.SubjectLocation, out IExifValue<ushort[]>? location))
+        {
+            if (location.Value?.Length == 2)
+            {
+                Vector2 point = TransformUtils.ProjectiveTransform2D(location.Value[0], location.Value[1], matrix);
+
+                // Ensure the point is within the image dimensions.
+                point = Vector2.Clamp(point, Vector2.Zero, new Vector2(width - 1, height - 1));
+
+                // Floor the point to the nearest pixel.
+                location.Value[0] = (ushort)Math.Floor(point.X);
+                location.Value[1] = (ushort)Math.Floor(point.Y);
+
+                this.SetValue(ExifTag.SubjectLocation, location.Value);
+            }
+            else
+            {
+                this.RemoveValue(ExifTag.SubjectLocation);
+            }
+        }
+
+        if (this.TryGetValue(ExifTag.SubjectArea, out IExifValue<ushort[]>? area))
+        {
+            if (area.Value?.Length == 4)
+            {
+                RectangleF rectangle = new(area.Value[0], area.Value[1], area.Value[2], area.Value[3]);
+                if (!TransformUtils.TryGetTransformedRectangle(rectangle, matrix, out Rectangle bounds))
+                {
+                    return;
+                }
+
+                // Ensure the bounds are within the image dimensions.
+                bounds = Rectangle.Intersect(bounds, new Rectangle(0, 0, width, height));
+
+                area.Value[0] = (ushort)bounds.X;
+                area.Value[1] = (ushort)bounds.Y;
+                area.Value[2] = (ushort)bounds.Width;
+                area.Value[3] = (ushort)bounds.Height;
+                this.SetValue(ExifTag.SubjectArea, area.Value);
+            }
+            else
+            {
+                this.RemoveValue(ExifTag.SubjectArea);
+            }
+        }
+    }
+
     /// <summary>
     /// Synchronizes the profiles with the specified metadata.
     /// </summary>
@@ -349,7 +398,7 @@ public sealed class ExifProfile : IDeepCloneable<ExifProfile>
 
         if (this.data is null)
         {
-            this.values = new List<IExifValue>();
+            this.values = [];
             return;
         }
 
diff --git a/src/ImageSharp/Metadata/Profiles/Exif/ExifReader.cs b/src/ImageSharp/Metadata/Profiles/Exif/ExifReader.cs
index a4fcd9275b..4cd4b4aac9 100644
--- a/src/ImageSharp/Metadata/Profiles/Exif/ExifReader.cs
+++ b/src/ImageSharp/Metadata/Profiles/Exif/ExifReader.cs
@@ -7,6 +7,7 @@ using System.Collections.ObjectModel;
 using System.Diagnostics;
 using System.Globalization;
 using System.Runtime.CompilerServices;
+using System.Runtime.InteropServices;
 using System.Text;
 using SixLabors.ImageSharp.Memory;
 
@@ -33,7 +34,7 @@ internal class ExifReader : BaseExifReader
     /// </returns>
     public List<IExifValue> ReadValues()
     {
-        List<IExifValue> values = new();
+        List<IExifValue> values = [];
 
         // II == 0x4949
         this.IsBigEndian = this.ReadUInt16() != 0x4949;
@@ -63,7 +64,7 @@ internal class ExifReader : BaseExifReader
             return;
         }
 
-        List<IExifValue> values = new();
+        List<IExifValue> values = [];
         this.ReadValues(values, offset);
 
         for (int i = 0; i < values.Count; i++)
@@ -89,8 +90,8 @@ internal abstract class BaseExifReader
     private readonly MemoryAllocator? allocator;
     private readonly Stream data;
     private List<ExifTag>? invalidTags;
-
     private List<ulong>? subIfds;
+    private bool isBigEndian;
 
     protected BaseExifReader(Stream stream, MemoryAllocator? allocator)
     {
@@ -103,7 +104,7 @@ internal abstract class BaseExifReader
     /// <summary>
     /// Gets the invalid tags.
     /// </summary>
-    public IReadOnlyList<ExifTag> InvalidTags => this.invalidTags ?? (IReadOnlyList<ExifTag>)Array.Empty<ExifTag>();
+    public IReadOnlyList<ExifTag> InvalidTags => this.invalidTags ?? (IReadOnlyList<ExifTag>)[];
 
     /// <summary>
     /// Gets or sets the thumbnail length in the byte stream.
@@ -115,9 +116,19 @@ internal abstract class BaseExifReader
     /// </summary>
     public uint ThumbnailOffset { get; protected set; }
 
-    public bool IsBigEndian { get; protected set; }
+    public bool IsBigEndian
+    {
+        get => this.isBigEndian;
+        protected set
+        {
+            this.isBigEndian = value;
+            this.ByteOrder = value ? ByteOrder.BigEndian : ByteOrder.LittleEndian;
+        }
+    }
+
+    protected ByteOrder ByteOrder { get; private set; }
 
-    public List<(ulong Offset, ExifDataType DataType, ulong NumberOfComponents, ExifValue Exif)> BigValues { get; } = new();
+    public List<(ulong Offset, ExifDataType DataType, ulong NumberOfComponents, ExifValue Exif)> BigValues { get; } = [];
 
     protected void ReadBigValues(List<IExifValue> values)
     {
@@ -187,11 +198,21 @@ internal abstract class BaseExifReader
 
     protected void ReadSubIfd(List<IExifValue> values)
     {
-        if (this.subIfds is not null)
+        if (this.subIfds != null)
         {
-            foreach (ulong subIfdOffset in this.subIfds)
+            const int maxSubIfds = 8;
+            const int maxNestingLevel = 8;
+            Span<ulong> buf = stackalloc ulong[maxSubIfds];
+            for (int i = 0; i < maxNestingLevel && this.subIfds.Count > 0; i++)
             {
-                this.ReadValues(values, (uint)subIfdOffset);
+                int sz = Math.Min(this.subIfds.Count, maxSubIfds);
+                CollectionsMarshal.AsSpan(this.subIfds)[..sz].CopyTo(buf);
+
+                this.subIfds.Clear();
+                foreach (ulong subIfdOffset in buf[..sz])
+                {
+                    this.ReadValues(values, (uint)subIfdOffset);
+                }
             }
         }
     }
@@ -447,6 +468,7 @@ internal abstract class BaseExifReader
             ExifTagValue.TileByteCounts => new ExifLong8Array(ExifTagValue.TileByteCounts),
             _ => ExifValues.Create(tag) ?? ExifValues.Create(tag, dataType, numberOfComponents),
         };
+
         if (exifValue is null)
         {
             this.AddInvalidTag(new UnkownExifTag(tag));
@@ -474,15 +496,23 @@ internal abstract class BaseExifReader
 
     private void Add(IList<IExifValue> values, ExifValue exif, object? value)
     {
-        if (!exif.TrySetValue(value))
+        if (exif is ExifEncodedString encodedString)
+        {
+            if (!encodedString.TrySetValue(value, this.ByteOrder))
+            {
+                return;
+            }
+        }
+        else if (!exif.TrySetValue(value))
         {
             return;
         }
 
         foreach (IExifValue val in values)
         {
-            // Sometimes duplicates appear, can compare val.Tag == exif.Tag
-            if (val == exif)
+            // To skip duplicates must be used Equals method,
+            // == operator not defined for ExifValue and IExifValue
+            if (exif.Equals(val))
             {
                 Debug.WriteLine($"Duplicate Exif tag: tag={exif.Tag}, dataType={exif.DataType}");
                 return;
@@ -504,10 +534,10 @@ internal abstract class BaseExifReader
     }
 
     private void AddInvalidTag(ExifTag tag)
-        => (this.invalidTags ??= new List<ExifTag>()).Add(tag);
+        => (this.invalidTags ??= []).Add(tag);
 
     private void AddSubIfd(object? val)
-        => (this.subIfds ??= new List<ulong>()).Add(Convert.ToUInt64(val, CultureInfo.InvariantCulture));
+        => (this.subIfds ??= []).Add(Convert.ToUInt64(val, CultureInfo.InvariantCulture));
 
     private void Seek(ulong pos)
         => this.data.Seek((long)pos, SeekOrigin.Begin);
diff --git a/src/ImageSharp/Metadata/Profiles/Exif/ExifWriter.cs b/src/ImageSharp/Metadata/Profiles/Exif/ExifWriter.cs
index cf4a421b44..732e3eab27 100644
--- a/src/ImageSharp/Metadata/Profiles/Exif/ExifWriter.cs
+++ b/src/ImageSharp/Metadata/Profiles/Exif/ExifWriter.cs
@@ -55,7 +55,7 @@ internal sealed class ExifWriter
 
         if (length == 0)
         {
-            return Array.Empty<byte>();
+            return [];
         }
 
         // two bytes for the byte Order marker 'II' or 'MM', followed by the number 42 (0x2A) and a 0, making 4 bytes total
@@ -197,7 +197,7 @@ internal sealed class ExifWriter
 
     private List<IExifValue> GetPartValues(ExifParts part)
     {
-        List<IExifValue> result = new();
+        List<IExifValue> result = [];
 
         if (!EnumUtils.HasFlag(this.allowedParts, part))
         {
@@ -332,7 +332,7 @@ internal sealed class ExifWriter
 
     private int WriteHeaders(List<IExifValue> values, Span<byte> destination, int offset)
     {
-        this.dataOffsets = new List<int>();
+        this.dataOffsets = [];
 
         int newOffset = WriteUInt16((ushort)values.Count, destination, offset);
 
diff --git a/src/ImageSharp/Metadata/Profiles/Exif/Tags/ExifTag.Byte.cs b/src/ImageSharp/Metadata/Profiles/Exif/Tags/ExifTag.Byte.cs
index 9ee2cf2f45..ff74ecd19d 100644
--- a/src/ImageSharp/Metadata/Profiles/Exif/Tags/ExifTag.Byte.cs
+++ b/src/ImageSharp/Metadata/Profiles/Exif/Tags/ExifTag.Byte.cs
@@ -9,15 +9,15 @@ public abstract partial class ExifTag
     /// <summary>
     /// Gets the FaxProfile exif tag.
     /// </summary>
-    public static ExifTag<byte> FaxProfile { get; } = new ExifTag<byte>(ExifTagValue.FaxProfile);
+    public static ExifTag<byte> FaxProfile { get; } = new(ExifTagValue.FaxProfile);
 
     /// <summary>
     /// Gets the ModeNumber exif tag.
     /// </summary>
-    public static ExifTag<byte> ModeNumber { get; } = new ExifTag<byte>(ExifTagValue.ModeNumber);
+    public static ExifTag<byte> ModeNumber { get; } = new(ExifTagValue.ModeNumber);
 
     /// <summary>
     /// Gets the GPSAltitudeRef exif tag.
     /// </summary>
-    public static ExifTag<byte> GPSAltitudeRef { get; } = new ExifTag<byte>(ExifTagValue.GPSAltitudeRef);
+    public static ExifTag<byte> GPSAltitudeRef { get; } = new(ExifTagValue.GPSAltitudeRef);
 }
diff --git a/src/ImageSharp/Metadata/Profiles/Exif/Tags/ExifTag.ByteArray.cs b/src/ImageSharp/Metadata/Profiles/Exif/Tags/ExifTag.ByteArray.cs
index 00a9056d34..64d8e14371 100644
--- a/src/ImageSharp/Metadata/Profiles/Exif/Tags/ExifTag.ByteArray.cs
+++ b/src/ImageSharp/Metadata/Profiles/Exif/Tags/ExifTag.ByteArray.cs
@@ -9,40 +9,40 @@ public abstract partial class ExifTag
     /// <summary>
     /// Gets the ClipPath exif tag.
     /// </summary>
-    public static ExifTag<byte[]> ClipPath => new ExifTag<byte[]>(ExifTagValue.ClipPath);
+    public static ExifTag<byte[]> ClipPath => new(ExifTagValue.ClipPath);
 
     /// <summary>
     /// Gets the VersionYear exif tag.
     /// </summary>
-    public static ExifTag<byte[]> VersionYear => new ExifTag<byte[]>(ExifTagValue.VersionYear);
+    public static ExifTag<byte[]> VersionYear => new(ExifTagValue.VersionYear);
 
     /// <summary>
     /// Gets the XMP exif tag.
     /// </summary>
-    public static ExifTag<byte[]> XMP => new ExifTag<byte[]>(ExifTagValue.XMP);
+    public static ExifTag<byte[]> XMP => new(ExifTagValue.XMP);
 
     /// <summary>
     /// Gets the IPTC exif tag.
     /// </summary>
-    public static ExifTag<byte[]> IPTC => new ExifTag<byte[]>(ExifTagValue.IPTC);
+    public static ExifTag<byte[]> IPTC => new(ExifTagValue.IPTC);
 
     /// <summary>
     /// Gets the IccProfile exif tag.
     /// </summary>
-    public static ExifTag<byte[]> IccProfile => new ExifTag<byte[]>(ExifTagValue.IccProfile);
+    public static ExifTag<byte[]> IccProfile => new(ExifTagValue.IccProfile);
 
     /// <summary>
     /// Gets the CFAPattern2 exif tag.
     /// </summary>
-    public static ExifTag<byte[]> CFAPattern2 => new ExifTag<byte[]>(ExifTagValue.CFAPattern2);
+    public static ExifTag<byte[]> CFAPattern2 => new(ExifTagValue.CFAPattern2);
 
     /// <summary>
     /// Gets the TIFFEPStandardID exif tag.
     /// </summary>
-    public static ExifTag<byte[]> TIFFEPStandardID => new ExifTag<byte[]>(ExifTagValue.TIFFEPStandardID);
+    public static ExifTag<byte[]> TIFFEPStandardID => new(ExifTagValue.TIFFEPStandardID);
 
     /// <summary>
     /// Gets the GPSVersionID exif tag.
     /// </summary>
-    public static ExifTag<byte[]> GPSVersionID => new ExifTag<byte[]>(ExifTagValue.GPSVersionID);
+    public static ExifTag<byte[]> GPSVersionID => new(ExifTagValue.GPSVersionID);
 }
diff --git a/src/ImageSharp/Metadata/Profiles/Exif/Tags/ExifTag.DoubleArray.cs b/src/ImageSharp/Metadata/Profiles/Exif/Tags/ExifTag.DoubleArray.cs
index 91d0c97b38..fded122613 100644
--- a/src/ImageSharp/Metadata/Profiles/Exif/Tags/ExifTag.DoubleArray.cs
+++ b/src/ImageSharp/Metadata/Profiles/Exif/Tags/ExifTag.DoubleArray.cs
@@ -9,20 +9,20 @@ public abstract partial class ExifTag
     /// <summary>
     /// Gets the PixelScale exif tag.
     /// </summary>
-    public static ExifTag<double[]> PixelScale { get; } = new ExifTag<double[]>(ExifTagValue.PixelScale);
+    public static ExifTag<double[]> PixelScale { get; } = new(ExifTagValue.PixelScale);
 
     /// <summary>
     /// Gets the IntergraphMatrix exif tag.
     /// </summary>
-    public static ExifTag<double[]> IntergraphMatrix { get; } = new ExifTag<double[]>(ExifTagValue.IntergraphMatrix);
+    public static ExifTag<double[]> IntergraphMatrix { get; } = new(ExifTagValue.IntergraphMatrix);
 
     /// <summary>
     /// Gets the ModelTiePoint exif tag.
     /// </summary>
-    public static ExifTag<double[]> ModelTiePoint { get; } = new ExifTag<double[]>(ExifTagValue.ModelTiePoint);
+    public static ExifTag<double[]> ModelTiePoint { get; } = new(ExifTagValue.ModelTiePoint);
 
     /// <summary>
     /// Gets the ModelTransform exif tag.
     /// </summary>
-    public static ExifTag<double[]> ModelTransform { get; } = new ExifTag<double[]>(ExifTagValue.ModelTransform);
+    public static ExifTag<double[]> ModelTransform { get; } = new(ExifTagValue.ModelTransform);
 }
diff --git a/src/ImageSharp/Metadata/Profiles/Exif/Tags/ExifTag.EncodedString.cs b/src/ImageSharp/Metadata/Profiles/Exif/Tags/ExifTag.EncodedString.cs
index 4b53ba6360..4cac0d0cab 100644
--- a/src/ImageSharp/Metadata/Profiles/Exif/Tags/ExifTag.EncodedString.cs
+++ b/src/ImageSharp/Metadata/Profiles/Exif/Tags/ExifTag.EncodedString.cs
@@ -9,15 +9,15 @@ public abstract partial class ExifTag
     /// <summary>
     /// Gets the UserComment exif tag.
     /// </summary>
-    public static ExifTag<EncodedString> UserComment { get; } = new ExifTag<EncodedString>(ExifTagValue.UserComment);
+    public static ExifTag<EncodedString> UserComment { get; } = new(ExifTagValue.UserComment);
 
     /// <summary>
     /// Gets the GPSProcessingMethod exif tag.
     /// </summary>
-    public static ExifTag<EncodedString> GPSProcessingMethod { get; } = new ExifTag<EncodedString>(ExifTagValue.GPSProcessingMethod);
+    public static ExifTag<EncodedString> GPSProcessingMethod { get; } = new(ExifTagValue.GPSProcessingMethod);
 
     /// <summary>
     /// Gets the GPSAreaInformation exif tag.
     /// </summary>
-    public static ExifTag<EncodedString> GPSAreaInformation { get; } = new ExifTag<EncodedString>(ExifTagValue.GPSAreaInformation);
+    public static ExifTag<EncodedString> GPSAreaInformation { get; } = new(ExifTagValue.GPSAreaInformation);
 }
diff --git a/src/ImageSharp/Metadata/Profiles/Exif/Tags/ExifTag.Long.cs b/src/ImageSharp/Metadata/Profiles/Exif/Tags/ExifTag.Long.cs
index f6c7c8ea73..5f9dfb4cde 100644
--- a/src/ImageSharp/Metadata/Profiles/Exif/Tags/ExifTag.Long.cs
+++ b/src/ImageSharp/Metadata/Profiles/Exif/Tags/ExifTag.Long.cs
@@ -9,105 +9,105 @@ public abstract partial class ExifTag
     /// <summary>
     /// Gets the SubfileType exif tag.
     /// </summary>
-    public static ExifTag<uint> SubfileType { get; } = new ExifTag<uint>(ExifTagValue.SubfileType);
+    public static ExifTag<uint> SubfileType { get; } = new(ExifTagValue.SubfileType);
 
     /// <summary>
     /// Gets the SubIFDOffset exif tag.
     /// </summary>
-    public static ExifTag<uint> SubIFDOffset { get; } = new ExifTag<uint>(ExifTagValue.SubIFDOffset);
+    public static ExifTag<uint> SubIFDOffset { get; } = new(ExifTagValue.SubIFDOffset);
 
     /// <summary>
     /// Gets the GPSIFDOffset exif tag.
     /// </summary>
-    public static ExifTag<uint> GPSIFDOffset { get; } = new ExifTag<uint>(ExifTagValue.GPSIFDOffset);
+    public static ExifTag<uint> GPSIFDOffset { get; } = new(ExifTagValue.GPSIFDOffset);
 
     /// <summary>
     /// Gets the T4Options exif tag.
     /// </summary>
-    public static ExifTag<uint> T4Options { get; } = new ExifTag<uint>(ExifTagValue.T4Options);
+    public static ExifTag<uint> T4Options { get; } = new(ExifTagValue.T4Options);
 
     /// <summary>
     /// Gets the T6Options exif tag.
     /// </summary>
-    public static ExifTag<uint> T6Options { get; } = new ExifTag<uint>(ExifTagValue.T6Options);
+    public static ExifTag<uint> T6Options { get; } = new(ExifTagValue.T6Options);
 
     /// <summary>
     /// Gets the XClipPathUnits exif tag.
     /// </summary>
-    public static ExifTag<uint> XClipPathUnits { get; } = new ExifTag<uint>(ExifTagValue.XClipPathUnits);
+    public static ExifTag<uint> XClipPathUnits { get; } = new(ExifTagValue.XClipPathUnits);
 
     /// <summary>
     /// Gets the YClipPathUnits exif tag.
     /// </summary>
-    public static ExifTag<uint> YClipPathUnits { get; } = new ExifTag<uint>(ExifTagValue.YClipPathUnits);
+    public static ExifTag<uint> YClipPathUnits { get; } = new(ExifTagValue.YClipPathUnits);
 
     /// <summary>
     /// Gets the ProfileType exif tag.
     /// </summary>
-    public static ExifTag<uint> ProfileType { get; } = new ExifTag<uint>(ExifTagValue.ProfileType);
+    public static ExifTag<uint> ProfileType { get; } = new(ExifTagValue.ProfileType);
 
     /// <summary>
     /// Gets the CodingMethods exif tag.
     /// </summary>
-    public static ExifTag<uint> CodingMethods { get; } = new ExifTag<uint>(ExifTagValue.CodingMethods);
+    public static ExifTag<uint> CodingMethods { get; } = new(ExifTagValue.CodingMethods);
 
     /// <summary>
     /// Gets the T82ptions exif tag.
     /// </summary>
-    public static ExifTag<uint> T82ptions { get; } = new ExifTag<uint>(ExifTagValue.T82ptions);
+    public static ExifTag<uint> T82ptions { get; } = new(ExifTagValue.T82ptions);
 
     /// <summary>
     /// Gets the JPEGInterchangeFormat exif tag.
     /// </summary>
-    public static ExifTag<uint> JPEGInterchangeFormat { get; } = new ExifTag<uint>(ExifTagValue.JPEGInterchangeFormat);
+    public static ExifTag<uint> JPEGInterchangeFormat { get; } = new(ExifTagValue.JPEGInterchangeFormat);
 
     /// <summary>
     /// Gets the JPEGInterchangeFormatLength exif tag.
     /// </summary>
-    public static ExifTag<uint> JPEGInterchangeFormatLength { get; } = new ExifTag<uint>(ExifTagValue.JPEGInterchangeFormatLength);
+    public static ExifTag<uint> JPEGInterchangeFormatLength { get; } = new(ExifTagValue.JPEGInterchangeFormatLength);
 
     /// <summary>
     /// Gets the MDFileTag exif tag.
     /// </summary>
-    public static ExifTag<uint> MDFileTag { get; } = new ExifTag<uint>(ExifTagValue.MDFileTag);
+    public static ExifTag<uint> MDFileTag { get; } = new(ExifTagValue.MDFileTag);
 
     /// <summary>
     /// Gets the StandardOutputSensitivity exif tag.
     /// </summary>
-    public static ExifTag<uint> StandardOutputSensitivity { get; } = new ExifTag<uint>(ExifTagValue.StandardOutputSensitivity);
+    public static ExifTag<uint> StandardOutputSensitivity { get; } = new(ExifTagValue.StandardOutputSensitivity);
 
     /// <summary>
     /// Gets the RecommendedExposureIndex exif tag.
     /// </summary>
-    public static ExifTag<uint> RecommendedExposureIndex { get; } = new ExifTag<uint>(ExifTagValue.RecommendedExposureIndex);
+    public static ExifTag<uint> RecommendedExposureIndex { get; } = new(ExifTagValue.RecommendedExposureIndex);
 
     /// <summary>
     /// Gets the ISOSpeed exif tag.
     /// </summary>
-    public static ExifTag<uint> ISOSpeed { get; } = new ExifTag<uint>(ExifTagValue.ISOSpeed);
+    public static ExifTag<uint> ISOSpeed { get; } = new(ExifTagValue.ISOSpeed);
 
     /// <summary>
     /// Gets the ISOSpeedLatitudeyyy exif tag.
     /// </summary>
-    public static ExifTag<uint> ISOSpeedLatitudeyyy { get; } = new ExifTag<uint>(ExifTagValue.ISOSpeedLatitudeyyy);
+    public static ExifTag<uint> ISOSpeedLatitudeyyy { get; } = new(ExifTagValue.ISOSpeedLatitudeyyy);
 
     /// <summary>
     /// Gets the ISOSpeedLatitudezzz exif tag.
     /// </summary>
-    public static ExifTag<uint> ISOSpeedLatitudezzz { get; } = new ExifTag<uint>(ExifTagValue.ISOSpeedLatitudezzz);
+    public static ExifTag<uint> ISOSpeedLatitudezzz { get; } = new(ExifTagValue.ISOSpeedLatitudezzz);
 
     /// <summary>
     /// Gets the FaxRecvParams exif tag.
     /// </summary>
-    public static ExifTag<uint> FaxRecvParams { get; } = new ExifTag<uint>(ExifTagValue.FaxRecvParams);
+    public static ExifTag<uint> FaxRecvParams { get; } = new(ExifTagValue.FaxRecvParams);
 
     /// <summary>
     /// Gets the FaxRecvTime exif tag.
     /// </summary>
-    public static ExifTag<uint> FaxRecvTime { get; } = new ExifTag<uint>(ExifTagValue.FaxRecvTime);
+    public static ExifTag<uint> FaxRecvTime { get; } = new(ExifTagValue.FaxRecvTime);
 
     /// <summary>
     /// Gets the ImageNumber exif tag.
     /// </summary>
-    public static ExifTag<uint> ImageNumber { get; } = new ExifTag<uint>(ExifTagValue.ImageNumber);
+    public static ExifTag<uint> ImageNumber { get; } = new(ExifTagValue.ImageNumber);
 }
diff --git a/src/ImageSharp/Metadata/Profiles/Exif/Tags/ExifTag.LongArray.cs b/src/ImageSharp/Metadata/Profiles/Exif/Tags/ExifTag.LongArray.cs
index 4767ca852e..e6821651ac 100644
--- a/src/ImageSharp/Metadata/Profiles/Exif/Tags/ExifTag.LongArray.cs
+++ b/src/ImageSharp/Metadata/Profiles/Exif/Tags/ExifTag.LongArray.cs
@@ -9,55 +9,55 @@ public abstract partial class ExifTag
     /// <summary>
     /// Gets the FreeOffsets exif tag.
     /// </summary>
-    public static ExifTag<uint[]> FreeOffsets { get; } = new ExifTag<uint[]>(ExifTagValue.FreeOffsets);
+    public static ExifTag<uint[]> FreeOffsets { get; } = new(ExifTagValue.FreeOffsets);
 
     /// <summary>
     /// Gets the FreeByteCounts exif tag.
     /// </summary>
-    public static ExifTag<uint[]> FreeByteCounts { get; } = new ExifTag<uint[]>(ExifTagValue.FreeByteCounts);
+    public static ExifTag<uint[]> FreeByteCounts { get; } = new(ExifTagValue.FreeByteCounts);
 
     /// <summary>
     /// Gets the ColorResponseUnit exif tag.
     /// </summary>
-    public static ExifTag<uint[]> ColorResponseUnit { get; } = new ExifTag<uint[]>(ExifTagValue.ColorResponseUnit);
+    public static ExifTag<uint[]> ColorResponseUnit { get; } = new(ExifTagValue.ColorResponseUnit);
 
     /// <summary>
     /// Gets the SMinSampleValue exif tag.
     /// </summary>
-    public static ExifTag<uint[]> SMinSampleValue { get; } = new ExifTag<uint[]>(ExifTagValue.SMinSampleValue);
+    public static ExifTag<uint[]> SMinSampleValue { get; } = new(ExifTagValue.SMinSampleValue);
 
     /// <summary>
     /// Gets the SMaxSampleValue exif tag.
     /// </summary>
-    public static ExifTag<uint[]> SMaxSampleValue { get; } = new ExifTag<uint[]>(ExifTagValue.SMaxSampleValue);
+    public static ExifTag<uint[]> SMaxSampleValue { get; } = new(ExifTagValue.SMaxSampleValue);
 
     /// <summary>
     /// Gets the JPEGQTables exif tag.
     /// </summary>
-    public static ExifTag<uint[]> JPEGQTables { get; } = new ExifTag<uint[]>(ExifTagValue.JPEGQTables);
+    public static ExifTag<uint[]> JPEGQTables { get; } = new(ExifTagValue.JPEGQTables);
 
     /// <summary>
     /// Gets the JPEGDCTables exif tag.
     /// </summary>
-    public static ExifTag<uint[]> JPEGDCTables { get; } = new ExifTag<uint[]>(ExifTagValue.JPEGDCTables);
+    public static ExifTag<uint[]> JPEGDCTables { get; } = new(ExifTagValue.JPEGDCTables);
 
     /// <summary>
     /// Gets the JPEGACTables exif tag.
     /// </summary>
-    public static ExifTag<uint[]> JPEGACTables { get; } = new ExifTag<uint[]>(ExifTagValue.JPEGACTables);
+    public static ExifTag<uint[]> JPEGACTables { get; } = new(ExifTagValue.JPEGACTables);
 
     /// <summary>
     /// Gets the StripRowCounts exif tag.
     /// </summary>
-    public static ExifTag<uint[]> StripRowCounts { get; } = new ExifTag<uint[]>(ExifTagValue.StripRowCounts);
+    public static ExifTag<uint[]> StripRowCounts { get; } = new(ExifTagValue.StripRowCounts);
 
     /// <summary>
     /// Gets the IntergraphRegisters exif tag.
     /// </summary>
-    public static ExifTag<uint[]> IntergraphRegisters { get; } = new ExifTag<uint[]>(ExifTagValue.IntergraphRegisters);
+    public static ExifTag<uint[]> IntergraphRegisters { get; } = new(ExifTagValue.IntergraphRegisters);
 
     /// <summary>
     /// Gets the offset to child IFDs exif tag.
     /// </summary>
-    public static ExifTag<uint[]> SubIFDs { get; } = new ExifTag<uint[]>(ExifTagValue.SubIFDs);
+    public static ExifTag<uint[]> SubIFDs { get; } = new(ExifTagValue.SubIFDs);
 }
diff --git a/src/ImageSharp/Metadata/Profiles/Exif/Tags/ExifTag.Number.cs b/src/ImageSharp/Metadata/Profiles/Exif/Tags/ExifTag.Number.cs
index 2018e4cea0..e023beeb7a 100644
--- a/src/ImageSharp/Metadata/Profiles/Exif/Tags/ExifTag.Number.cs
+++ b/src/ImageSharp/Metadata/Profiles/Exif/Tags/ExifTag.Number.cs
@@ -9,45 +9,45 @@ public abstract partial class ExifTag
     /// <summary>
     /// Gets the ImageWidth exif tag.
     /// </summary>
-    public static ExifTag<Number> ImageWidth { get; } = new ExifTag<Number>(ExifTagValue.ImageWidth);
+    public static ExifTag<Number> ImageWidth { get; } = new(ExifTagValue.ImageWidth);
 
     /// <summary>
     /// Gets the ImageLength exif tag.
     /// </summary>
-    public static ExifTag<Number> ImageLength { get; } = new ExifTag<Number>(ExifTagValue.ImageLength);
+    public static ExifTag<Number> ImageLength { get; } = new(ExifTagValue.ImageLength);
 
     /// <summary>
     /// Gets the RowsPerStrip exif tag.
     /// </summary>
-    public static ExifTag<Number> RowsPerStrip { get; } = new ExifTag<Number>(ExifTagValue.RowsPerStrip);
+    public static ExifTag<Number> RowsPerStrip { get; } = new(ExifTagValue.RowsPerStrip);
 
     /// <summary>
     /// Gets the TileWidth exif tag.
     /// </summary>
-    public static ExifTag<Number> TileWidth { get; } = new ExifTag<Number>(ExifTagValue.TileWidth);
+    public static ExifTag<Number> TileWidth { get; } = new(ExifTagValue.TileWidth);
 
     /// <summary>
     /// Gets the TileLength exif tag.
     /// </summary>
-    public static ExifTag<Number> TileLength { get; } = new ExifTag<Number>(ExifTagValue.TileLength);
+    public static ExifTag<Number> TileLength { get; } = new(ExifTagValue.TileLength);
 
     /// <summary>
     /// Gets the BadFaxLines exif tag.
     /// </summary>
-    public static ExifTag<Number> BadFaxLines { get; } = new ExifTag<Number>(ExifTagValue.BadFaxLines);
+    public static ExifTag<Number> BadFaxLines { get; } = new(ExifTagValue.BadFaxLines);
 
     /// <summary>
     /// Gets the ConsecutiveBadFaxLines exif tag.
     /// </summary>
-    public static ExifTag<Number> ConsecutiveBadFaxLines { get; } = new ExifTag<Number>(ExifTagValue.ConsecutiveBadFaxLines);
+    public static ExifTag<Number> ConsecutiveBadFaxLines { get; } = new(ExifTagValue.ConsecutiveBadFaxLines);
 
     /// <summary>
     /// Gets the PixelXDimension exif tag.
     /// </summary>
-    public static ExifTag<Number> PixelXDimension { get; } = new ExifTag<Number>(ExifTagValue.PixelXDimension);
+    public static ExifTag<Number> PixelXDimension { get; } = new(ExifTagValue.PixelXDimension);
 
     /// <summary>
     /// Gets the PixelYDimension exif tag.
     /// </summary>
-    public static ExifTag<Number> PixelYDimension { get; } = new ExifTag<Number>(ExifTagValue.PixelYDimension);
+    public static ExifTag<Number> PixelYDimension { get; } = new(ExifTagValue.PixelYDimension);
 }
diff --git a/src/ImageSharp/Metadata/Profiles/Exif/Tags/ExifTag.NumberArray.cs b/src/ImageSharp/Metadata/Profiles/Exif/Tags/ExifTag.NumberArray.cs
index cd89681413..6a7438fc6e 100644
--- a/src/ImageSharp/Metadata/Profiles/Exif/Tags/ExifTag.NumberArray.cs
+++ b/src/ImageSharp/Metadata/Profiles/Exif/Tags/ExifTag.NumberArray.cs
@@ -9,25 +9,25 @@ public abstract partial class ExifTag
     /// <summary>
     /// Gets the StripOffsets exif tag.
     /// </summary>
-    public static ExifTag<Number[]> StripOffsets { get; } = new ExifTag<Number[]>(ExifTagValue.StripOffsets);
+    public static ExifTag<Number[]> StripOffsets { get; } = new(ExifTagValue.StripOffsets);
 
     /// <summary>
     /// Gets the StripByteCounts exif tag.
     /// </summary>
-    public static ExifTag<Number[]> StripByteCounts { get; } = new ExifTag<Number[]>(ExifTagValue.StripByteCounts);
+    public static ExifTag<Number[]> StripByteCounts { get; } = new(ExifTagValue.StripByteCounts);
 
     /// <summary>
     /// Gets the TileByteCounts exif tag.
     /// </summary>
-    public static ExifTag<Number[]> TileByteCounts { get; } = new ExifTag<Number[]>(ExifTagValue.TileByteCounts);
+    public static ExifTag<Number[]> TileByteCounts { get; } = new(ExifTagValue.TileByteCounts);
 
     /// <summary>
     /// Gets the TileOffsets exif tag.
     /// </summary>
-    public static ExifTag<Number[]> TileOffsets { get; } = new ExifTag<Number[]>(ExifTagValue.TileOffsets);
+    public static ExifTag<Number[]> TileOffsets { get; } = new(ExifTagValue.TileOffsets);
 
     /// <summary>
     /// Gets the ImageLayer exif tag.
     /// </summary>
-    public static ExifTag<Number[]> ImageLayer { get; } = new ExifTag<Number[]>(ExifTagValue.ImageLayer);
+    public static ExifTag<Number[]> ImageLayer { get; } = new(ExifTagValue.ImageLayer);
 }
diff --git a/src/ImageSharp/Metadata/Profiles/Exif/Tags/ExifTag.Rational.cs b/src/ImageSharp/Metadata/Profiles/Exif/Tags/ExifTag.Rational.cs
index e4fe13fe57..02526ac34d 100644
--- a/src/ImageSharp/Metadata/Profiles/Exif/Tags/ExifTag.Rational.cs
+++ b/src/ImageSharp/Metadata/Profiles/Exif/Tags/ExifTag.Rational.cs
@@ -9,165 +9,165 @@ public abstract partial class ExifTag
     /// <summary>
     /// Gets the XPosition exif tag.
     /// </summary>
-    public static ExifTag<Rational> XPosition { get; } = new ExifTag<Rational>(ExifTagValue.XPosition);
+    public static ExifTag<Rational> XPosition { get; } = new(ExifTagValue.XPosition);
 
     /// <summary>
     /// Gets the YPosition exif tag.
     /// </summary>
-    public static ExifTag<Rational> YPosition { get; } = new ExifTag<Rational>(ExifTagValue.YPosition);
+    public static ExifTag<Rational> YPosition { get; } = new(ExifTagValue.YPosition);
 
     /// <summary>
     /// Gets the XResolution exif tag.
     /// </summary>
-    public static ExifTag<Rational> XResolution { get; } = new ExifTag<Rational>(ExifTagValue.XResolution);
+    public static ExifTag<Rational> XResolution { get; } = new(ExifTagValue.XResolution);
 
     /// <summary>
     /// Gets the YResolution exif tag.
     /// </summary>
-    public static ExifTag<Rational> YResolution { get; } = new ExifTag<Rational>(ExifTagValue.YResolution);
+    public static ExifTag<Rational> YResolution { get; } = new(ExifTagValue.YResolution);
 
     /// <summary>
     /// Gets the BatteryLevel exif tag.
     /// </summary>
-    public static ExifTag<Rational> BatteryLevel { get; } = new ExifTag<Rational>(ExifTagValue.BatteryLevel);
+    public static ExifTag<Rational> BatteryLevel { get; } = new(ExifTagValue.BatteryLevel);
 
     /// <summary>
     /// Gets the ExposureTime exif tag.
     /// </summary>
-    public static ExifTag<Rational> ExposureTime { get; } = new ExifTag<Rational>(ExifTagValue.ExposureTime);
+    public static ExifTag<Rational> ExposureTime { get; } = new(ExifTagValue.ExposureTime);
 
     /// <summary>
     /// Gets the FNumber exif tag.
     /// </summary>
-    public static ExifTag<Rational> FNumber { get; } = new ExifTag<Rational>(ExifTagValue.FNumber);
+    public static ExifTag<Rational> FNumber { get; } = new(ExifTagValue.FNumber);
 
     /// <summary>
     /// Gets the MDScalePixel exif tag.
     /// </summary>
-    public static ExifTag<Rational> MDScalePixel { get; } = new ExifTag<Rational>(ExifTagValue.MDScalePixel);
+    public static ExifTag<Rational> MDScalePixel { get; } = new(ExifTagValue.MDScalePixel);
 
     /// <summary>
     /// Gets the CompressedBitsPerPixel exif tag.
     /// </summary>
-    public static ExifTag<Rational> CompressedBitsPerPixel { get; } = new ExifTag<Rational>(ExifTagValue.CompressedBitsPerPixel);
+    public static ExifTag<Rational> CompressedBitsPerPixel { get; } = new(ExifTagValue.CompressedBitsPerPixel);
 
     /// <summary>
     /// Gets the ApertureValue exif tag.
     /// </summary>
-    public static ExifTag<Rational> ApertureValue { get; } = new ExifTag<Rational>(ExifTagValue.ApertureValue);
+    public static ExifTag<Rational> ApertureValue { get; } = new(ExifTagValue.ApertureValue);
 
     /// <summary>
     /// Gets the MaxApertureValue exif tag.
     /// </summary>
-    public static ExifTag<Rational> MaxApertureValue { get; } = new ExifTag<Rational>(ExifTagValue.MaxApertureValue);
+    public static ExifTag<Rational> MaxApertureValue { get; } = new(ExifTagValue.MaxApertureValue);
 
     /// <summary>
     /// Gets the SubjectDistance exif tag.
     /// </summary>
-    public static ExifTag<Rational> SubjectDistance { get; } = new ExifTag<Rational>(ExifTagValue.SubjectDistance);
+    public static ExifTag<Rational> SubjectDistance { get; } = new(ExifTagValue.SubjectDistance);
 
     /// <summary>
     /// Gets the FocalLength exif tag.
     /// </summary>
-    public static ExifTag<Rational> FocalLength { get; } = new ExifTag<Rational>(ExifTagValue.FocalLength);
+    public static ExifTag<Rational> FocalLength { get; } = new(ExifTagValue.FocalLength);
 
     /// <summary>
     /// Gets the FlashEnergy2 exif tag.
     /// </summary>
-    public static ExifTag<Rational> FlashEnergy2 { get; } = new ExifTag<Rational>(ExifTagValue.FlashEnergy2);
+    public static ExifTag<Rational> FlashEnergy2 { get; } = new(ExifTagValue.FlashEnergy2);
 
     /// <summary>
     /// Gets the FocalPlaneXResolution2 exif tag.
     /// </summary>
-    public static ExifTag<Rational> FocalPlaneXResolution2 { get; } = new ExifTag<Rational>(ExifTagValue.FocalPlaneXResolution2);
+    public static ExifTag<Rational> FocalPlaneXResolution2 { get; } = new(ExifTagValue.FocalPlaneXResolution2);
 
     /// <summary>
     /// Gets the FocalPlaneYResolution2 exif tag.
     /// </summary>
-    public static ExifTag<Rational> FocalPlaneYResolution2 { get; } = new ExifTag<Rational>(ExifTagValue.FocalPlaneYResolution2);
+    public static ExifTag<Rational> FocalPlaneYResolution2 { get; } = new(ExifTagValue.FocalPlaneYResolution2);
 
     /// <summary>
     /// Gets the ExposureIndex2 exif tag.
     /// </summary>
-    public static ExifTag<Rational> ExposureIndex2 { get; } = new ExifTag<Rational>(ExifTagValue.ExposureIndex2);
+    public static ExifTag<Rational> ExposureIndex2 { get; } = new(ExifTagValue.ExposureIndex2);
 
     /// <summary>
     /// Gets the Humidity exif tag.
     /// </summary>
-    public static ExifTag<Rational> Humidity { get; } = new ExifTag<Rational>(ExifTagValue.Humidity);
+    public static ExifTag<Rational> Humidity { get; } = new(ExifTagValue.Humidity);
 
     /// <summary>
     /// Gets the Pressure exif tag.
     /// </summary>
-    public static ExifTag<Rational> Pressure { get; } = new ExifTag<Rational>(ExifTagValue.Pressure);
+    public static ExifTag<Rational> Pressure { get; } = new(ExifTagValue.Pressure);
 
     /// <summary>
     /// Gets the Acceleration exif tag.
     /// </summary>
-    public static ExifTag<Rational> Acceleration { get; } = new ExifTag<Rational>(ExifTagValue.Acceleration);
+    public static ExifTag<Rational> Acceleration { get; } = new(ExifTagValue.Acceleration);
 
     /// <summary>
     /// Gets the FlashEnergy exif tag.
     /// </summary>
-    public static ExifTag<Rational> FlashEnergy { get; } = new ExifTag<Rational>(ExifTagValue.FlashEnergy);
+    public static ExifTag<Rational> FlashEnergy { get; } = new(ExifTagValue.FlashEnergy);
 
     /// <summary>
     /// Gets the FocalPlaneXResolution exif tag.
     /// </summary>
-    public static ExifTag<Rational> FocalPlaneXResolution { get; } = new ExifTag<Rational>(ExifTagValue.FocalPlaneXResolution);
+    public static ExifTag<Rational> FocalPlaneXResolution { get; } = new(ExifTagValue.FocalPlaneXResolution);
 
     /// <summary>
     /// Gets the FocalPlaneYResolution exif tag.
     /// </summary>
-    public static ExifTag<Rational> FocalPlaneYResolution { get; } = new ExifTag<Rational>(ExifTagValue.FocalPlaneYResolution);
+    public static ExifTag<Rational> FocalPlaneYResolution { get; } = new(ExifTagValue.FocalPlaneYResolution);
 
     /// <summary>
     /// Gets the ExposureIndex exif tag.
     /// </summary>
-    public static ExifTag<Rational> ExposureIndex { get; } = new ExifTag<Rational>(ExifTagValue.ExposureIndex);
+    public static ExifTag<Rational> ExposureIndex { get; } = new(ExifTagValue.ExposureIndex);
 
     /// <summary>
     /// Gets the DigitalZoomRatio exif tag.
     /// </summary>
-    public static ExifTag<Rational> DigitalZoomRatio { get; } = new ExifTag<Rational>(ExifTagValue.DigitalZoomRatio);
+    public static ExifTag<Rational> DigitalZoomRatio { get; } = new(ExifTagValue.DigitalZoomRatio);
 
     /// <summary>
     /// Gets the GPSAltitude exif tag.
     /// </summary>
-    public static ExifTag<Rational> GPSAltitude { get; } = new ExifTag<Rational>(ExifTagValue.GPSAltitude);
+    public static ExifTag<Rational> GPSAltitude { get; } = new(ExifTagValue.GPSAltitude);
 
     /// <summary>
     /// Gets the GPSDOP exif tag.
     /// </summary>
-    public static ExifTag<Rational> GPSDOP { get; } = new ExifTag<Rational>(ExifTagValue.GPSDOP);
+    public static ExifTag<Rational> GPSDOP { get; } = new(ExifTagValue.GPSDOP);
 
     /// <summary>
     /// Gets the GPSSpeed exif tag.
     /// </summary>
-    public static ExifTag<Rational> GPSSpeed { get; } = new ExifTag<Rational>(ExifTagValue.GPSSpeed);
+    public static ExifTag<Rational> GPSSpeed { get; } = new(ExifTagValue.GPSSpeed);
 
     /// <summary>
     /// Gets the GPSTrack exif tag.
     /// </summary>
-    public static ExifTag<Rational> GPSTrack { get; } = new ExifTag<Rational>(ExifTagValue.GPSTrack);
+    public static ExifTag<Rational> GPSTrack { get; } = new(ExifTagValue.GPSTrack);
 
     /// <summary>
     /// Gets the GPSImgDirection exif tag.
     /// </summary>
-    public static ExifTag<Rational> GPSImgDirection { get; } = new ExifTag<Rational>(ExifTagValue.GPSImgDirection);
+    public static ExifTag<Rational> GPSImgDirection { get; } = new(ExifTagValue.GPSImgDirection);
 
     /// <summary>
     /// Gets the GPSDestBearing exif tag.
     /// </summary>
-    public static ExifTag<Rational> GPSDestBearing { get; } = new ExifTag<Rational>(ExifTagValue.GPSDestBearing);
+    public static ExifTag<Rational> GPSDestBearing { get; } = new(ExifTagValue.GPSDestBearing);
 
     /// <summary>
     /// Gets the GPSDestDistance exif tag.
     /// </summary>
-    public static ExifTag<Rational> GPSDestDistance { get; } = new ExifTag<Rational>(ExifTagValue.GPSDestDistance);
+    public static ExifTag<Rational> GPSDestDistance { get; } = new(ExifTagValue.GPSDestDistance);
 
     /// <summary>
     /// Gets the GPSHPositioningError exif tag.
     /// </summary>
-    public static ExifTag<Rational> GPSHPositioningError { get; } = new ExifTag<Rational>(ExifTagValue.GPSHPositioningError);
+    public static ExifTag<Rational> GPSHPositioningError { get; } = new(ExifTagValue.GPSHPositioningError);
 }
diff --git a/src/ImageSharp/Metadata/Profiles/Exif/Tags/ExifTag.RationalArray.cs b/src/ImageSharp/Metadata/Profiles/Exif/Tags/ExifTag.RationalArray.cs
index 8b764c3f77..4ba140441d 100644
--- a/src/ImageSharp/Metadata/Profiles/Exif/Tags/ExifTag.RationalArray.cs
+++ b/src/ImageSharp/Metadata/Profiles/Exif/Tags/ExifTag.RationalArray.cs
@@ -9,50 +9,50 @@ public abstract partial class ExifTag
     /// <summary>
     /// Gets the WhitePoint exif tag.
     /// </summary>
-    public static ExifTag<Rational[]> WhitePoint { get; } = new ExifTag<Rational[]>(ExifTagValue.WhitePoint);
+    public static ExifTag<Rational[]> WhitePoint { get; } = new(ExifTagValue.WhitePoint);
 
     /// <summary>
     /// Gets the PrimaryChromaticities exif tag.
     /// </summary>
-    public static ExifTag<Rational[]> PrimaryChromaticities { get; } = new ExifTag<Rational[]>(ExifTagValue.PrimaryChromaticities);
+    public static ExifTag<Rational[]> PrimaryChromaticities { get; } = new(ExifTagValue.PrimaryChromaticities);
 
     /// <summary>
     /// Gets the YCbCrCoefficients exif tag.
     /// </summary>
-    public static ExifTag<Rational[]> YCbCrCoefficients { get; } = new ExifTag<Rational[]>(ExifTagValue.YCbCrCoefficients);
+    public static ExifTag<Rational[]> YCbCrCoefficients { get; } = new(ExifTagValue.YCbCrCoefficients);
 
     /// <summary>
     /// Gets the ReferenceBlackWhite exif tag.
     /// </summary>
-    public static ExifTag<Rational[]> ReferenceBlackWhite { get; } = new ExifTag<Rational[]>(ExifTagValue.ReferenceBlackWhite);
+    public static ExifTag<Rational[]> ReferenceBlackWhite { get; } = new(ExifTagValue.ReferenceBlackWhite);
 
     /// <summary>
     /// Gets the GPSLatitude exif tag.
     /// </summary>
-    public static ExifTag<Rational[]> GPSLatitude { get; } = new ExifTag<Rational[]>(ExifTagValue.GPSLatitude);
+    public static ExifTag<Rational[]> GPSLatitude { get; } = new(ExifTagValue.GPSLatitude);
 
     /// <summary>
     /// Gets the GPSLongitude exif tag.
     /// </summary>
-    public static ExifTag<Rational[]> GPSLongitude { get; } = new ExifTag<Rational[]>(ExifTagValue.GPSLongitude);
+    public static ExifTag<Rational[]> GPSLongitude { get; } = new(ExifTagValue.GPSLongitude);
 
     /// <summary>
     /// Gets the GPSTimestamp exif tag.
     /// </summary>
-    public static ExifTag<Rational[]> GPSTimestamp { get; } = new ExifTag<Rational[]>(ExifTagValue.GPSTimestamp);
+    public static ExifTag<Rational[]> GPSTimestamp { get; } = new(ExifTagValue.GPSTimestamp);
 
     /// <summary>
     /// Gets the GPSDestLatitude exif tag.
     /// </summary>
-    public static ExifTag<Rational[]> GPSDestLatitude { get; } = new ExifTag<Rational[]>(ExifTagValue.GPSDestLatitude);
+    public static ExifTag<Rational[]> GPSDestLatitude { get; } = new(ExifTagValue.GPSDestLatitude);
 
     /// <summary>
     /// Gets the GPSDestLongitude exif tag.
     /// </summary>
-    public static ExifTag<Rational[]> GPSDestLongitude { get; } = new ExifTag<Rational[]>(ExifTagValue.GPSDestLongitude);
+    public static ExifTag<Rational[]> GPSDestLongitude { get; } = new(ExifTagValue.GPSDestLongitude);
 
     /// <summary>
     /// Gets the LensSpecification exif tag.
     /// </summary>
-    public static ExifTag<Rational[]> LensSpecification { get; } = new ExifTag<Rational[]>(ExifTagValue.LensSpecification);
+    public static ExifTag<Rational[]> LensSpecification { get; } = new(ExifTagValue.LensSpecification);
 }
diff --git a/src/ImageSharp/Metadata/Profiles/Exif/Tags/ExifTag.Short.cs b/src/ImageSharp/Metadata/Profiles/Exif/Tags/ExifTag.Short.cs
index aeeda58bb0..52972811e6 100644
--- a/src/ImageSharp/Metadata/Profiles/Exif/Tags/ExifTag.Short.cs
+++ b/src/ImageSharp/Metadata/Profiles/Exif/Tags/ExifTag.Short.cs
@@ -9,235 +9,235 @@ public abstract partial class ExifTag
     /// <summary>
     /// Gets the OldSubfileType exif tag.
     /// </summary>
-    public static ExifTag<ushort> OldSubfileType { get; } = new ExifTag<ushort>(ExifTagValue.OldSubfileType);
+    public static ExifTag<ushort> OldSubfileType { get; } = new(ExifTagValue.OldSubfileType);
 
     /// <summary>
     /// Gets the Compression exif tag.
     /// </summary>
-    public static ExifTag<ushort> Compression { get; } = new ExifTag<ushort>(ExifTagValue.Compression);
+    public static ExifTag<ushort> Compression { get; } = new(ExifTagValue.Compression);
 
     /// <summary>
     /// Gets the PhotometricInterpretation exif tag.
     /// </summary>
-    public static ExifTag<ushort> PhotometricInterpretation { get; } = new ExifTag<ushort>(ExifTagValue.PhotometricInterpretation);
+    public static ExifTag<ushort> PhotometricInterpretation { get; } = new(ExifTagValue.PhotometricInterpretation);
 
     /// <summary>
     /// Gets the Thresholding exif tag.
     /// </summary>
-    public static ExifTag<ushort> Thresholding { get; } = new ExifTag<ushort>(ExifTagValue.Thresholding);
+    public static ExifTag<ushort> Thresholding { get; } = new(ExifTagValue.Thresholding);
 
     /// <summary>
     /// Gets the CellWidth exif tag.
     /// </summary>
-    public static ExifTag<ushort> CellWidth { get; } = new ExifTag<ushort>(ExifTagValue.CellWidth);
+    public static ExifTag<ushort> CellWidth { get; } = new(ExifTagValue.CellWidth);
 
     /// <summary>
     /// Gets the CellLength exif tag.
     /// </summary>
-    public static ExifTag<ushort> CellLength { get; } = new ExifTag<ushort>(ExifTagValue.CellLength);
+    public static ExifTag<ushort> CellLength { get; } = new(ExifTagValue.CellLength);
 
     /// <summary>
     /// Gets the FillOrder exif tag.
     /// </summary>
-    public static ExifTag<ushort> FillOrder { get; } = new ExifTag<ushort>(ExifTagValue.FillOrder);
+    public static ExifTag<ushort> FillOrder { get; } = new(ExifTagValue.FillOrder);
 
     /// <summary>
     /// Gets the Orientation exif tag.
     /// </summary>
-    public static ExifTag<ushort> Orientation { get; } = new ExifTag<ushort>(ExifTagValue.Orientation);
+    public static ExifTag<ushort> Orientation { get; } = new(ExifTagValue.Orientation);
 
     /// <summary>
     /// Gets the SamplesPerPixel exif tag.
     /// </summary>
-    public static ExifTag<ushort> SamplesPerPixel { get; } = new ExifTag<ushort>(ExifTagValue.SamplesPerPixel);
+    public static ExifTag<ushort> SamplesPerPixel { get; } = new(ExifTagValue.SamplesPerPixel);
 
     /// <summary>
     /// Gets the PlanarConfiguration exif tag.
     /// </summary>
-    public static ExifTag<ushort> PlanarConfiguration { get; } = new ExifTag<ushort>(ExifTagValue.PlanarConfiguration);
+    public static ExifTag<ushort> PlanarConfiguration { get; } = new(ExifTagValue.PlanarConfiguration);
 
     /// <summary>
     /// Gets the Predictor exif tag.
     /// </summary>
-    public static ExifTag<ushort> Predictor { get; } = new ExifTag<ushort>(ExifTagValue.Predictor);
+    public static ExifTag<ushort> Predictor { get; } = new(ExifTagValue.Predictor);
 
     /// <summary>
     /// Gets the GrayResponseUnit exif tag.
     /// </summary>
-    public static ExifTag<ushort> GrayResponseUnit { get; } = new ExifTag<ushort>(ExifTagValue.GrayResponseUnit);
+    public static ExifTag<ushort> GrayResponseUnit { get; } = new(ExifTagValue.GrayResponseUnit);
 
     /// <summary>
     /// Gets the ResolutionUnit exif tag.
     /// </summary>
-    public static ExifTag<ushort> ResolutionUnit { get; } = new ExifTag<ushort>(ExifTagValue.ResolutionUnit);
+    public static ExifTag<ushort> ResolutionUnit { get; } = new(ExifTagValue.ResolutionUnit);
 
     /// <summary>
     /// Gets the CleanFaxData exif tag.
     /// </summary>
-    public static ExifTag<ushort> CleanFaxData { get; } = new ExifTag<ushort>(ExifTagValue.CleanFaxData);
+    public static ExifTag<ushort> CleanFaxData { get; } = new(ExifTagValue.CleanFaxData);
 
     /// <summary>
     /// Gets the InkSet exif tag.
     /// </summary>
-    public static ExifTag<ushort> InkSet { get; } = new ExifTag<ushort>(ExifTagValue.InkSet);
+    public static ExifTag<ushort> InkSet { get; } = new(ExifTagValue.InkSet);
 
     /// <summary>
     /// Gets the NumberOfInks exif tag.
     /// </summary>
-    public static ExifTag<ushort> NumberOfInks { get; } = new ExifTag<ushort>(ExifTagValue.NumberOfInks);
+    public static ExifTag<ushort> NumberOfInks { get; } = new(ExifTagValue.NumberOfInks);
 
     /// <summary>
     /// Gets the DotRange exif tag.
     /// </summary>
-    public static ExifTag<ushort> DotRange { get; } = new ExifTag<ushort>(ExifTagValue.DotRange);
+    public static ExifTag<ushort> DotRange { get; } = new(ExifTagValue.DotRange);
 
     /// <summary>
     /// Gets the Indexed exif tag.
     /// </summary>
-    public static ExifTag<ushort> Indexed { get; } = new ExifTag<ushort>(ExifTagValue.Indexed);
+    public static ExifTag<ushort> Indexed { get; } = new(ExifTagValue.Indexed);
 
     /// <summary>
     /// Gets the OPIProxy exif tag.
     /// </summary>
-    public static ExifTag<ushort> OPIProxy { get; } = new ExifTag<ushort>(ExifTagValue.OPIProxy);
+    public static ExifTag<ushort> OPIProxy { get; } = new(ExifTagValue.OPIProxy);
 
     /// <summary>
     /// Gets the JPEGProc exif tag.
     /// </summary>
-    public static ExifTag<ushort> JPEGProc { get; } = new ExifTag<ushort>(ExifTagValue.JPEGProc);
+    public static ExifTag<ushort> JPEGProc { get; } = new(ExifTagValue.JPEGProc);
 
     /// <summary>
     /// Gets the JPEGRestartInterval exif tag.
     /// </summary>
-    public static ExifTag<ushort> JPEGRestartInterval { get; } = new ExifTag<ushort>(ExifTagValue.JPEGRestartInterval);
+    public static ExifTag<ushort> JPEGRestartInterval { get; } = new(ExifTagValue.JPEGRestartInterval);
 
     /// <summary>
     /// Gets the YCbCrPositioning exif tag.
     /// </summary>
-    public static ExifTag<ushort> YCbCrPositioning { get; } = new ExifTag<ushort>(ExifTagValue.YCbCrPositioning);
+    public static ExifTag<ushort> YCbCrPositioning { get; } = new(ExifTagValue.YCbCrPositioning);
 
     /// <summary>
     /// Gets the Rating exif tag.
     /// </summary>
-    public static ExifTag<ushort> Rating { get; } = new ExifTag<ushort>(ExifTagValue.Rating);
+    public static ExifTag<ushort> Rating { get; } = new(ExifTagValue.Rating);
 
     /// <summary>
     /// Gets the RatingPercent exif tag.
     /// </summary>
-    public static ExifTag<ushort> RatingPercent { get; } = new ExifTag<ushort>(ExifTagValue.RatingPercent);
+    public static ExifTag<ushort> RatingPercent { get; } = new(ExifTagValue.RatingPercent);
 
     /// <summary>
     /// Gets the ExposureProgram exif tag.
     /// </summary>
-    public static ExifTag<ushort> ExposureProgram { get; } = new ExifTag<ushort>(ExifTagValue.ExposureProgram);
+    public static ExifTag<ushort> ExposureProgram { get; } = new(ExifTagValue.ExposureProgram);
 
     /// <summary>
     /// Gets the Interlace exif tag.
     /// </summary>
-    public static ExifTag<ushort> Interlace { get; } = new ExifTag<ushort>(ExifTagValue.Interlace);
+    public static ExifTag<ushort> Interlace { get; } = new(ExifTagValue.Interlace);
 
     /// <summary>
     /// Gets the SelfTimerMode exif tag.
     /// </summary>
-    public static ExifTag<ushort> SelfTimerMode { get; } = new ExifTag<ushort>(ExifTagValue.SelfTimerMode);
+    public static ExifTag<ushort> SelfTimerMode { get; } = new(ExifTagValue.SelfTimerMode);
 
     /// <summary>
     /// Gets the SensitivityType exif tag.
     /// </summary>
-    public static ExifTag<ushort> SensitivityType { get; } = new ExifTag<ushort>(ExifTagValue.SensitivityType);
+    public static ExifTag<ushort> SensitivityType { get; } = new(ExifTagValue.SensitivityType);
 
     /// <summary>
     /// Gets the MeteringMode exif tag.
     /// </summary>
-    public static ExifTag<ushort> MeteringMode { get; } = new ExifTag<ushort>(ExifTagValue.MeteringMode);
+    public static ExifTag<ushort> MeteringMode { get; } = new(ExifTagValue.MeteringMode);
 
     /// <summary>
     /// Gets the LightSource exif tag.
     /// </summary>
-    public static ExifTag<ushort> LightSource { get; } = new ExifTag<ushort>(ExifTagValue.LightSource);
+    public static ExifTag<ushort> LightSource { get; } = new(ExifTagValue.LightSource);
 
     /// <summary>
     /// Gets the FocalPlaneResolutionUnit2 exif tag.
     /// </summary>
-    public static ExifTag<ushort> FocalPlaneResolutionUnit2 { get; } = new ExifTag<ushort>(ExifTagValue.FocalPlaneResolutionUnit2);
+    public static ExifTag<ushort> FocalPlaneResolutionUnit2 { get; } = new(ExifTagValue.FocalPlaneResolutionUnit2);
 
     /// <summary>
     /// Gets the SensingMethod2 exif tag.
     /// </summary>
-    public static ExifTag<ushort> SensingMethod2 { get; } = new ExifTag<ushort>(ExifTagValue.SensingMethod2);
+    public static ExifTag<ushort> SensingMethod2 { get; } = new(ExifTagValue.SensingMethod2);
 
     /// <summary>
     /// Gets the Flash exif tag.
     /// </summary>
-    public static ExifTag<ushort> Flash { get; } = new ExifTag<ushort>(ExifTagValue.Flash);
+    public static ExifTag<ushort> Flash { get; } = new(ExifTagValue.Flash);
 
     /// <summary>
     /// Gets the ColorSpace exif tag.
     /// </summary>
-    public static ExifTag<ushort> ColorSpace { get; } = new ExifTag<ushort>(ExifTagValue.ColorSpace);
+    public static ExifTag<ushort> ColorSpace { get; } = new(ExifTagValue.ColorSpace);
 
     /// <summary>
     /// Gets the FocalPlaneResolutionUnit exif tag.
     /// </summary>
-    public static ExifTag<ushort> FocalPlaneResolutionUnit { get; } = new ExifTag<ushort>(ExifTagValue.FocalPlaneResolutionUnit);
+    public static ExifTag<ushort> FocalPlaneResolutionUnit { get; } = new(ExifTagValue.FocalPlaneResolutionUnit);
 
     /// <summary>
     /// Gets the SensingMethod exif tag.
     /// </summary>
-    public static ExifTag<ushort> SensingMethod { get; } = new ExifTag<ushort>(ExifTagValue.SensingMethod);
+    public static ExifTag<ushort> SensingMethod { get; } = new(ExifTagValue.SensingMethod);
 
     /// <summary>
     /// Gets the CustomRendered exif tag.
     /// </summary>
-    public static ExifTag<ushort> CustomRendered { get; } = new ExifTag<ushort>(ExifTagValue.CustomRendered);
+    public static ExifTag<ushort> CustomRendered { get; } = new(ExifTagValue.CustomRendered);
 
     /// <summary>
     /// Gets the ExposureMode exif tag.
     /// </summary>
-    public static ExifTag<ushort> ExposureMode { get; } = new ExifTag<ushort>(ExifTagValue.ExposureMode);
+    public static ExifTag<ushort> ExposureMode { get; } = new(ExifTagValue.ExposureMode);
 
     /// <summary>
     /// Gets the WhiteBalance exif tag.
     /// </summary>
-    public static ExifTag<ushort> WhiteBalance { get; } = new ExifTag<ushort>(ExifTagValue.WhiteBalance);
+    public static ExifTag<ushort> WhiteBalance { get; } = new(ExifTagValue.WhiteBalance);
 
     /// <summary>
     /// Gets the FocalLengthIn35mmFilm exif tag.
     /// </summary>
-    public static ExifTag<ushort> FocalLengthIn35mmFilm { get; } = new ExifTag<ushort>(ExifTagValue.FocalLengthIn35mmFilm);
+    public static ExifTag<ushort> FocalLengthIn35mmFilm { get; } = new(ExifTagValue.FocalLengthIn35mmFilm);
 
     /// <summary>
     /// Gets the SceneCaptureType exif tag.
     /// </summary>
-    public static ExifTag<ushort> SceneCaptureType { get; } = new ExifTag<ushort>(ExifTagValue.SceneCaptureType);
+    public static ExifTag<ushort> SceneCaptureType { get; } = new(ExifTagValue.SceneCaptureType);
 
     /// <summary>
     /// Gets the GainControl exif tag.
     /// </summary>
-    public static ExifTag<ushort> GainControl { get; } = new ExifTag<ushort>(ExifTagValue.GainControl);
+    public static ExifTag<ushort> GainControl { get; } = new(ExifTagValue.GainControl);
 
     /// <summary>
     /// Gets the Contrast exif tag.
     /// </summary>
-    public static ExifTag<ushort> Contrast { get; } = new ExifTag<ushort>(ExifTagValue.Contrast);
+    public static ExifTag<ushort> Contrast { get; } = new(ExifTagValue.Contrast);
 
     /// <summary>
     /// Gets the Saturation exif tag.
     /// </summary>
-    public static ExifTag<ushort> Saturation { get; } = new ExifTag<ushort>(ExifTagValue.Saturation);
+    public static ExifTag<ushort> Saturation { get; } = new(ExifTagValue.Saturation);
 
     /// <summary>
     /// Gets the Sharpness exif tag.
     /// </summary>
-    public static ExifTag<ushort> Sharpness { get; } = new ExifTag<ushort>(ExifTagValue.Sharpness);
+    public static ExifTag<ushort> Sharpness { get; } = new(ExifTagValue.Sharpness);
 
     /// <summary>
     /// Gets the SubjectDistanceRange exif tag.
     /// </summary>
-    public static ExifTag<ushort> SubjectDistanceRange { get; } = new ExifTag<ushort>(ExifTagValue.SubjectDistanceRange);
+    public static ExifTag<ushort> SubjectDistanceRange { get; } = new(ExifTagValue.SubjectDistanceRange);
 
     /// <summary>
     /// Gets the GPSDifferential exif tag.
     /// </summary>
-    public static ExifTag<ushort> GPSDifferential { get; } = new ExifTag<ushort>(ExifTagValue.GPSDifferential);
+    public static ExifTag<ushort> GPSDifferential { get; } = new(ExifTagValue.GPSDifferential);
 }
diff --git a/src/ImageSharp/Metadata/Profiles/Exif/Tags/ExifTag.ShortArray.cs b/src/ImageSharp/Metadata/Profiles/Exif/Tags/ExifTag.ShortArray.cs
index dc708c50f1..55e65517f1 100644
--- a/src/ImageSharp/Metadata/Profiles/Exif/Tags/ExifTag.ShortArray.cs
+++ b/src/ImageSharp/Metadata/Profiles/Exif/Tags/ExifTag.ShortArray.cs
@@ -9,100 +9,100 @@ public abstract partial class ExifTag
     /// <summary>
     /// Gets the BitsPerSample exif tag.
     /// </summary>
-    public static ExifTag<ushort[]> BitsPerSample { get; } = new ExifTag<ushort[]>(ExifTagValue.BitsPerSample);
+    public static ExifTag<ushort[]> BitsPerSample { get; } = new(ExifTagValue.BitsPerSample);
 
     /// <summary>
     /// Gets the MinSampleValue exif tag.
     /// </summary>
-    public static ExifTag<ushort[]> MinSampleValue { get; } = new ExifTag<ushort[]>(ExifTagValue.MinSampleValue);
+    public static ExifTag<ushort[]> MinSampleValue { get; } = new(ExifTagValue.MinSampleValue);
 
     /// <summary>
     /// Gets the MaxSampleValue exif tag.
     /// </summary>
-    public static ExifTag<ushort[]> MaxSampleValue { get; } = new ExifTag<ushort[]>(ExifTagValue.MaxSampleValue);
+    public static ExifTag<ushort[]> MaxSampleValue { get; } = new(ExifTagValue.MaxSampleValue);
 
     /// <summary>
     /// Gets the GrayResponseCurve exif tag.
     /// </summary>
-    public static ExifTag<ushort[]> GrayResponseCurve { get; } = new ExifTag<ushort[]>(ExifTagValue.GrayResponseCurve);
+    public static ExifTag<ushort[]> GrayResponseCurve { get; } = new(ExifTagValue.GrayResponseCurve);
 
     /// <summary>
     /// Gets the ColorMap exif tag.
     /// </summary>
-    public static ExifTag<ushort[]> ColorMap { get; } = new ExifTag<ushort[]>(ExifTagValue.ColorMap);
+    public static ExifTag<ushort[]> ColorMap { get; } = new(ExifTagValue.ColorMap);
 
     /// <summary>
     /// Gets the ExtraSamples exif tag.
     /// </summary>
-    public static ExifTag<ushort[]> ExtraSamples { get; } = new ExifTag<ushort[]>(ExifTagValue.ExtraSamples);
+    public static ExifTag<ushort[]> ExtraSamples { get; } = new(ExifTagValue.ExtraSamples);
 
     /// <summary>
     /// Gets the PageNumber exif tag.
     /// </summary>
-    public static ExifTag<ushort[]> PageNumber { get; } = new ExifTag<ushort[]>(ExifTagValue.PageNumber);
+    public static ExifTag<ushort[]> PageNumber { get; } = new(ExifTagValue.PageNumber);
 
     /// <summary>
     /// Gets the TransferFunction exif tag.
     /// </summary>
-    public static ExifTag<ushort[]> TransferFunction { get; } = new ExifTag<ushort[]>(ExifTagValue.TransferFunction);
+    public static ExifTag<ushort[]> TransferFunction { get; } = new(ExifTagValue.TransferFunction);
 
     /// <summary>
     /// Gets the HalftoneHints exif tag.
     /// </summary>
-    public static ExifTag<ushort[]> HalftoneHints { get; } = new ExifTag<ushort[]>(ExifTagValue.HalftoneHints);
+    public static ExifTag<ushort[]> HalftoneHints { get; } = new(ExifTagValue.HalftoneHints);
 
     /// <summary>
     /// Gets the SampleFormat exif tag.
     /// </summary>
-    public static ExifTag<ushort[]> SampleFormat { get; } = new ExifTag<ushort[]>(ExifTagValue.SampleFormat);
+    public static ExifTag<ushort[]> SampleFormat { get; } = new(ExifTagValue.SampleFormat);
 
     /// <summary>
     /// Gets the TransferRange exif tag.
     /// </summary>
-    public static ExifTag<ushort[]> TransferRange { get; } = new ExifTag<ushort[]>(ExifTagValue.TransferRange);
+    public static ExifTag<ushort[]> TransferRange { get; } = new(ExifTagValue.TransferRange);
 
     /// <summary>
     /// Gets the DefaultImageColor exif tag.
     /// </summary>
-    public static ExifTag<ushort[]> DefaultImageColor { get; } = new ExifTag<ushort[]>(ExifTagValue.DefaultImageColor);
+    public static ExifTag<ushort[]> DefaultImageColor { get; } = new(ExifTagValue.DefaultImageColor);
 
     /// <summary>
     /// Gets the JPEGLosslessPredictors exif tag.
     /// </summary>
-    public static ExifTag<ushort[]> JPEGLosslessPredictors { get; } = new ExifTag<ushort[]>(ExifTagValue.JPEGLosslessPredictors);
+    public static ExifTag<ushort[]> JPEGLosslessPredictors { get; } = new(ExifTagValue.JPEGLosslessPredictors);
 
     /// <summary>
     /// Gets the JPEGPointTransforms exif tag.
     /// </summary>
-    public static ExifTag<ushort[]> JPEGPointTransforms { get; } = new ExifTag<ushort[]>(ExifTagValue.JPEGPointTransforms);
+    public static ExifTag<ushort[]> JPEGPointTransforms { get; } = new(ExifTagValue.JPEGPointTransforms);
 
     /// <summary>
     /// Gets the YCbCrSubsampling exif tag.
     /// </summary>
-    public static ExifTag<ushort[]> YCbCrSubsampling { get; } = new ExifTag<ushort[]>(ExifTagValue.YCbCrSubsampling);
+    public static ExifTag<ushort[]> YCbCrSubsampling { get; } = new(ExifTagValue.YCbCrSubsampling);
 
     /// <summary>
     /// Gets the CFARepeatPatternDim exif tag.
     /// </summary>
-    public static ExifTag<ushort[]> CFARepeatPatternDim { get; } = new ExifTag<ushort[]>(ExifTagValue.CFARepeatPatternDim);
+    public static ExifTag<ushort[]> CFARepeatPatternDim { get; } = new(ExifTagValue.CFARepeatPatternDim);
 
     /// <summary>
     /// Gets the IntergraphPacketData exif tag.
     /// </summary>
-    public static ExifTag<ushort[]> IntergraphPacketData { get; } = new ExifTag<ushort[]>(ExifTagValue.IntergraphPacketData);
+    public static ExifTag<ushort[]> IntergraphPacketData { get; } = new(ExifTagValue.IntergraphPacketData);
 
     /// <summary>
     /// Gets the ISOSpeedRatings exif tag.
     /// </summary>
-    public static ExifTag<ushort[]> ISOSpeedRatings { get; } = new ExifTag<ushort[]>(ExifTagValue.ISOSpeedRatings);
+    public static ExifTag<ushort[]> ISOSpeedRatings { get; } = new(ExifTagValue.ISOSpeedRatings);
 
     /// <summary>
     /// Gets the SubjectArea exif tag.
     /// </summary>
-    public static ExifTag<ushort[]> SubjectArea { get; } = new ExifTag<ushort[]>(ExifTagValue.SubjectArea);
+    public static ExifTag<ushort[]> SubjectArea { get; } = new(ExifTagValue.SubjectArea);
 
     /// <summary>
     /// Gets the SubjectLocation exif tag.
     /// </summary>
-    public static ExifTag<ushort[]> SubjectLocation { get; } = new ExifTag<ushort[]>(ExifTagValue.SubjectLocation);
+    public static ExifTag<ushort[]> SubjectLocation { get; } = new(ExifTagValue.SubjectLocation);
 }
diff --git a/src/ImageSharp/Metadata/Profiles/Exif/Tags/ExifTag.SignedRational.cs b/src/ImageSharp/Metadata/Profiles/Exif/Tags/ExifTag.SignedRational.cs
index d645b5176a..8fbbba2177 100644
--- a/src/ImageSharp/Metadata/Profiles/Exif/Tags/ExifTag.SignedRational.cs
+++ b/src/ImageSharp/Metadata/Profiles/Exif/Tags/ExifTag.SignedRational.cs
@@ -9,30 +9,30 @@ public abstract partial class ExifTag
     /// <summary>
     /// Gets the ShutterSpeedValue exif tag.
     /// </summary>
-    public static ExifTag<SignedRational> ShutterSpeedValue { get; } = new ExifTag<SignedRational>(ExifTagValue.ShutterSpeedValue);
+    public static ExifTag<SignedRational> ShutterSpeedValue { get; } = new(ExifTagValue.ShutterSpeedValue);
 
     /// <summary>
     /// Gets the BrightnessValue exif tag.
     /// </summary>
-    public static ExifTag<SignedRational> BrightnessValue { get; } = new ExifTag<SignedRational>(ExifTagValue.BrightnessValue);
+    public static ExifTag<SignedRational> BrightnessValue { get; } = new(ExifTagValue.BrightnessValue);
 
     /// <summary>
     /// Gets the ExposureBiasValue exif tag.
     /// </summary>
-    public static ExifTag<SignedRational> ExposureBiasValue { get; } = new ExifTag<SignedRational>(ExifTagValue.ExposureBiasValue);
+    public static ExifTag<SignedRational> ExposureBiasValue { get; } = new(ExifTagValue.ExposureBiasValue);
 
     /// <summary>
     /// Gets the AmbientTemperature exif tag.
     /// </summary>
-    public static ExifTag<SignedRational> AmbientTemperature { get; } = new ExifTag<SignedRational>(ExifTagValue.AmbientTemperature);
+    public static ExifTag<SignedRational> AmbientTemperature { get; } = new(ExifTagValue.AmbientTemperature);
 
     /// <summary>
     /// Gets the WaterDepth exif tag.
     /// </summary>
-    public static ExifTag<SignedRational> WaterDepth { get; } = new ExifTag<SignedRational>(ExifTagValue.WaterDepth);
+    public static ExifTag<SignedRational> WaterDepth { get; } = new(ExifTagValue.WaterDepth);
 
     /// <summary>
     /// Gets the CameraElevationAngle exif tag.
     /// </summary>
-    public static ExifTag<SignedRational> CameraElevationAngle { get; } = new ExifTag<SignedRational>(ExifTagValue.CameraElevationAngle);
+    public static ExifTag<SignedRational> CameraElevationAngle { get; } = new(ExifTagValue.CameraElevationAngle);
 }
diff --git a/src/ImageSharp/Metadata/Profiles/Exif/Tags/ExifTag.SignedRationalArray.cs b/src/ImageSharp/Metadata/Profiles/Exif/Tags/ExifTag.SignedRationalArray.cs
index ef1e8afea4..a27108f8a0 100644
--- a/src/ImageSharp/Metadata/Profiles/Exif/Tags/ExifTag.SignedRationalArray.cs
+++ b/src/ImageSharp/Metadata/Profiles/Exif/Tags/ExifTag.SignedRationalArray.cs
@@ -9,5 +9,5 @@ public abstract partial class ExifTag
     /// <summary>
     /// Gets the Decode exif tag.
     /// </summary>
-    public static ExifTag<SignedRational[]> Decode { get; } = new ExifTag<SignedRational[]>(ExifTagValue.Decode);
+    public static ExifTag<SignedRational[]> Decode { get; } = new(ExifTagValue.Decode);
 }
diff --git a/src/ImageSharp/Metadata/Profiles/Exif/Tags/ExifTag.SignedShortArray.cs b/src/ImageSharp/Metadata/Profiles/Exif/Tags/ExifTag.SignedShortArray.cs
index d6a9205143..0868426987 100644
--- a/src/ImageSharp/Metadata/Profiles/Exif/Tags/ExifTag.SignedShortArray.cs
+++ b/src/ImageSharp/Metadata/Profiles/Exif/Tags/ExifTag.SignedShortArray.cs
@@ -9,5 +9,5 @@ public abstract partial class ExifTag
     /// <summary>
     /// Gets the TimeZoneOffset exif tag.
     /// </summary>
-    public static ExifTag<short[]> TimeZoneOffset { get; } = new ExifTag<short[]>(ExifTagValue.TimeZoneOffset);
+    public static ExifTag<short[]> TimeZoneOffset { get; } = new(ExifTagValue.TimeZoneOffset);
 }
diff --git a/src/ImageSharp/Metadata/Profiles/Exif/Tags/ExifTag.String.cs b/src/ImageSharp/Metadata/Profiles/Exif/Tags/ExifTag.String.cs
index 498dad3ebb..688403a65a 100644
--- a/src/ImageSharp/Metadata/Profiles/Exif/Tags/ExifTag.String.cs
+++ b/src/ImageSharp/Metadata/Profiles/Exif/Tags/ExifTag.String.cs
@@ -9,270 +9,270 @@ public abstract partial class ExifTag
     /// <summary>
     /// Gets the ImageDescription exif tag.
     /// </summary>
-    public static ExifTag<string> ImageDescription { get; } = new ExifTag<string>(ExifTagValue.ImageDescription);
+    public static ExifTag<string> ImageDescription { get; } = new(ExifTagValue.ImageDescription);
 
     /// <summary>
     /// Gets the Make exif tag.
     /// </summary>
-    public static ExifTag<string> Make { get; } = new ExifTag<string>(ExifTagValue.Make);
+    public static ExifTag<string> Make { get; } = new(ExifTagValue.Make);
 
     /// <summary>
     /// Gets the Model exif tag.
     /// </summary>
-    public static ExifTag<string> Model { get; } = new ExifTag<string>(ExifTagValue.Model);
+    public static ExifTag<string> Model { get; } = new(ExifTagValue.Model);
 
     /// <summary>
     /// Gets the Software exif tag.
     /// </summary>
-    public static ExifTag<string> Software { get; } = new ExifTag<string>(ExifTagValue.Software);
+    public static ExifTag<string> Software { get; } = new(ExifTagValue.Software);
 
     /// <summary>
     /// Gets the DateTime exif tag.
     /// </summary>
-    public static ExifTag<string> DateTime { get; } = new ExifTag<string>(ExifTagValue.DateTime);
+    public static ExifTag<string> DateTime { get; } = new(ExifTagValue.DateTime);
 
     /// <summary>
     /// Gets the Artist exif tag.
     /// </summary>
-    public static ExifTag<string> Artist { get; } = new ExifTag<string>(ExifTagValue.Artist);
+    public static ExifTag<string> Artist { get; } = new(ExifTagValue.Artist);
 
     /// <summary>
     /// Gets the HostComputer exif tag.
     /// </summary>
-    public static ExifTag<string> HostComputer { get; } = new ExifTag<string>(ExifTagValue.HostComputer);
+    public static ExifTag<string> HostComputer { get; } = new(ExifTagValue.HostComputer);
 
     /// <summary>
     /// Gets the Copyright exif tag.
     /// </summary>
-    public static ExifTag<string> Copyright { get; } = new ExifTag<string>(ExifTagValue.Copyright);
+    public static ExifTag<string> Copyright { get; } = new(ExifTagValue.Copyright);
 
     /// <summary>
     /// Gets the DocumentName exif tag.
     /// </summary>
-    public static ExifTag<string> DocumentName { get; } = new ExifTag<string>(ExifTagValue.DocumentName);
+    public static ExifTag<string> DocumentName { get; } = new(ExifTagValue.DocumentName);
 
     /// <summary>
     /// Gets the PageName exif tag.
     /// </summary>
-    public static ExifTag<string> PageName { get; } = new ExifTag<string>(ExifTagValue.PageName);
+    public static ExifTag<string> PageName { get; } = new(ExifTagValue.PageName);
 
     /// <summary>
     /// Gets the InkNames exif tag.
     /// </summary>
-    public static ExifTag<string> InkNames { get; } = new ExifTag<string>(ExifTagValue.InkNames);
+    public static ExifTag<string> InkNames { get; } = new(ExifTagValue.InkNames);
 
     /// <summary>
     /// Gets the TargetPrinter exif tag.
     /// </summary>
-    public static ExifTag<string> TargetPrinter { get; } = new ExifTag<string>(ExifTagValue.TargetPrinter);
+    public static ExifTag<string> TargetPrinter { get; } = new(ExifTagValue.TargetPrinter);
 
     /// <summary>
     /// Gets the ImageID exif tag.
     /// </summary>
-    public static ExifTag<string> ImageID { get; } = new ExifTag<string>(ExifTagValue.ImageID);
+    public static ExifTag<string> ImageID { get; } = new(ExifTagValue.ImageID);
 
     /// <summary>
     /// Gets the MDLabName exif tag.
     /// </summary>
-    public static ExifTag<string> MDLabName { get; } = new ExifTag<string>(ExifTagValue.MDLabName);
+    public static ExifTag<string> MDLabName { get; } = new(ExifTagValue.MDLabName);
 
     /// <summary>
     /// Gets the MDSampleInfo exif tag.
     /// </summary>
-    public static ExifTag<string> MDSampleInfo { get; } = new ExifTag<string>(ExifTagValue.MDSampleInfo);
+    public static ExifTag<string> MDSampleInfo { get; } = new(ExifTagValue.MDSampleInfo);
 
     /// <summary>
     /// Gets the MDPrepDate exif tag.
     /// </summary>
-    public static ExifTag<string> MDPrepDate { get; } = new ExifTag<string>(ExifTagValue.MDPrepDate);
+    public static ExifTag<string> MDPrepDate { get; } = new(ExifTagValue.MDPrepDate);
 
     /// <summary>
     /// Gets the MDPrepTime exif tag.
     /// </summary>
-    public static ExifTag<string> MDPrepTime { get; } = new ExifTag<string>(ExifTagValue.MDPrepTime);
+    public static ExifTag<string> MDPrepTime { get; } = new(ExifTagValue.MDPrepTime);
 
     /// <summary>
     /// Gets the MDFileUnits exif tag.
     /// </summary>
-    public static ExifTag<string> MDFileUnits { get; } = new ExifTag<string>(ExifTagValue.MDFileUnits);
+    public static ExifTag<string> MDFileUnits { get; } = new(ExifTagValue.MDFileUnits);
 
     /// <summary>
     /// Gets the SEMInfo exif tag.
     /// </summary>
-    public static ExifTag<string> SEMInfo { get; } = new ExifTag<string>(ExifTagValue.SEMInfo);
+    public static ExifTag<string> SEMInfo { get; } = new(ExifTagValue.SEMInfo);
 
     /// <summary>
     /// Gets the SpectralSensitivity exif tag.
     /// </summary>
-    public static ExifTag<string> SpectralSensitivity { get; } = new ExifTag<string>(ExifTagValue.SpectralSensitivity);
+    public static ExifTag<string> SpectralSensitivity { get; } = new(ExifTagValue.SpectralSensitivity);
 
     /// <summary>
     /// Gets the DateTimeOriginal exif tag.
     /// </summary>
-    public static ExifTag<string> DateTimeOriginal { get; } = new ExifTag<string>(ExifTagValue.DateTimeOriginal);
+    public static ExifTag<string> DateTimeOriginal { get; } = new(ExifTagValue.DateTimeOriginal);
 
     /// <summary>
     /// Gets the DateTimeDigitized exif tag.
     /// </summary>
-    public static ExifTag<string> DateTimeDigitized { get; } = new ExifTag<string>(ExifTagValue.DateTimeDigitized);
+    public static ExifTag<string> DateTimeDigitized { get; } = new(ExifTagValue.DateTimeDigitized);
 
     /// <summary>
     /// Gets the SubsecTime exif tag.
     /// </summary>
-    public static ExifTag<string> SubsecTime { get; } = new ExifTag<string>(ExifTagValue.SubsecTime);
+    public static ExifTag<string> SubsecTime { get; } = new(ExifTagValue.SubsecTime);
 
     /// <summary>
     /// Gets the SubsecTimeOriginal exif tag.
     /// </summary>
-    public static ExifTag<string> SubsecTimeOriginal { get; } = new ExifTag<string>(ExifTagValue.SubsecTimeOriginal);
+    public static ExifTag<string> SubsecTimeOriginal { get; } = new(ExifTagValue.SubsecTimeOriginal);
 
     /// <summary>
     /// Gets the SubsecTimeDigitized exif tag.
     /// </summary>
-    public static ExifTag<string> SubsecTimeDigitized { get; } = new ExifTag<string>(ExifTagValue.SubsecTimeDigitized);
+    public static ExifTag<string> SubsecTimeDigitized { get; } = new(ExifTagValue.SubsecTimeDigitized);
 
     /// <summary>
     /// Gets the RelatedSoundFile exif tag.
     /// </summary>
-    public static ExifTag<string> RelatedSoundFile { get; } = new ExifTag<string>(ExifTagValue.RelatedSoundFile);
+    public static ExifTag<string> RelatedSoundFile { get; } = new(ExifTagValue.RelatedSoundFile);
 
     /// <summary>
     /// Gets the FaxSubaddress exif tag.
     /// </summary>
-    public static ExifTag<string> FaxSubaddress { get; } = new ExifTag<string>(ExifTagValue.FaxSubaddress);
+    public static ExifTag<string> FaxSubaddress { get; } = new(ExifTagValue.FaxSubaddress);
 
     /// <summary>
     /// Gets the OffsetTime exif tag.
     /// </summary>
-    public static ExifTag<string> OffsetTime { get; } = new ExifTag<string>(ExifTagValue.OffsetTime);
+    public static ExifTag<string> OffsetTime { get; } = new(ExifTagValue.OffsetTime);
 
     /// <summary>
     /// Gets the OffsetTimeOriginal exif tag.
     /// </summary>
-    public static ExifTag<string> OffsetTimeOriginal { get; } = new ExifTag<string>(ExifTagValue.OffsetTimeOriginal);
+    public static ExifTag<string> OffsetTimeOriginal { get; } = new(ExifTagValue.OffsetTimeOriginal);
 
     /// <summary>
     /// Gets the OffsetTimeDigitized exif tag.
     /// </summary>
-    public static ExifTag<string> OffsetTimeDigitized { get; } = new ExifTag<string>(ExifTagValue.OffsetTimeDigitized);
+    public static ExifTag<string> OffsetTimeDigitized { get; } = new(ExifTagValue.OffsetTimeDigitized);
 
     /// <summary>
     /// Gets the SecurityClassification exif tag.
     /// </summary>
-    public static ExifTag<string> SecurityClassification { get; } = new ExifTag<string>(ExifTagValue.SecurityClassification);
+    public static ExifTag<string> SecurityClassification { get; } = new(ExifTagValue.SecurityClassification);
 
     /// <summary>
     /// Gets the ImageHistory exif tag.
     /// </summary>
-    public static ExifTag<string> ImageHistory { get; } = new ExifTag<string>(ExifTagValue.ImageHistory);
+    public static ExifTag<string> ImageHistory { get; } = new(ExifTagValue.ImageHistory);
 
     /// <summary>
     /// Gets the ImageUniqueID exif tag.
     /// </summary>
-    public static ExifTag<string> ImageUniqueID { get; } = new ExifTag<string>(ExifTagValue.ImageUniqueID);
+    public static ExifTag<string> ImageUniqueID { get; } = new(ExifTagValue.ImageUniqueID);
 
     /// <summary>
     /// Gets the OwnerName exif tag.
     /// </summary>
-    public static ExifTag<string> OwnerName { get; } = new ExifTag<string>(ExifTagValue.OwnerName);
+    public static ExifTag<string> OwnerName { get; } = new(ExifTagValue.OwnerName);
 
     /// <summary>
     /// Gets the SerialNumber exif tag.
     /// </summary>
-    public static ExifTag<string> SerialNumber { get; } = new ExifTag<string>(ExifTagValue.SerialNumber);
+    public static ExifTag<string> SerialNumber { get; } = new(ExifTagValue.SerialNumber);
 
     /// <summary>
     /// Gets the LensMake exif tag.
     /// </summary>
-    public static ExifTag<string> LensMake { get; } = new ExifTag<string>(ExifTagValue.LensMake);
+    public static ExifTag<string> LensMake { get; } = new(ExifTagValue.LensMake);
 
     /// <summary>
     /// Gets the LensModel exif tag.
     /// </summary>
-    public static ExifTag<string> LensModel { get; } = new ExifTag<string>(ExifTagValue.LensModel);
+    public static ExifTag<string> LensModel { get; } = new(ExifTagValue.LensModel);
 
     /// <summary>
     /// Gets the LensSerialNumber exif tag.
     /// </summary>
-    public static ExifTag<string> LensSerialNumber { get; } = new ExifTag<string>(ExifTagValue.LensSerialNumber);
+    public static ExifTag<string> LensSerialNumber { get; } = new(ExifTagValue.LensSerialNumber);
 
     /// <summary>
     /// Gets the GDALMetadata exif tag.
     /// </summary>
-    public static ExifTag<string> GDALMetadata { get; } = new ExifTag<string>(ExifTagValue.GDALMetadata);
+    public static ExifTag<string> GDALMetadata { get; } = new(ExifTagValue.GDALMetadata);
 
     /// <summary>
     /// Gets the GDALNoData exif tag.
     /// </summary>
-    public static ExifTag<string> GDALNoData { get; } = new ExifTag<string>(ExifTagValue.GDALNoData);
+    public static ExifTag<string> GDALNoData { get; } = new(ExifTagValue.GDALNoData);
 
     /// <summary>
     /// Gets the GPSLatitudeRef exif tag.
     /// </summary>
-    public static ExifTag<string> GPSLatitudeRef { get; } = new ExifTag<string>(ExifTagValue.GPSLatitudeRef);
+    public static ExifTag<string> GPSLatitudeRef { get; } = new(ExifTagValue.GPSLatitudeRef);
 
     /// <summary>
     /// Gets the GPSLongitudeRef exif tag.
     /// </summary>
-    public static ExifTag<string> GPSLongitudeRef { get; } = new ExifTag<string>(ExifTagValue.GPSLongitudeRef);
+    public static ExifTag<string> GPSLongitudeRef { get; } = new(ExifTagValue.GPSLongitudeRef);
 
     /// <summary>
     /// Gets the GPSSatellites exif tag.
     /// </summary>
-    public static ExifTag<string> GPSSatellites { get; } = new ExifTag<string>(ExifTagValue.GPSSatellites);
+    public static ExifTag<string> GPSSatellites { get; } = new(ExifTagValue.GPSSatellites);
 
     /// <summary>
     /// Gets the GPSStatus exif tag.
     /// </summary>
-    public static ExifTag<string> GPSStatus { get; } = new ExifTag<string>(ExifTagValue.GPSStatus);
+    public static ExifTag<string> GPSStatus { get; } = new(ExifTagValue.GPSStatus);
 
     /// <summary>
     /// Gets the GPSMeasureMode exif tag.
     /// </summary>
-    public static ExifTag<string> GPSMeasureMode { get; } = new ExifTag<string>(ExifTagValue.GPSMeasureMode);
+    public static ExifTag<string> GPSMeasureMode { get; } = new(ExifTagValue.GPSMeasureMode);
 
     /// <summary>
     /// Gets the GPSSpeedRef exif tag.
     /// </summary>
-    public static ExifTag<string> GPSSpeedRef { get; } = new ExifTag<string>(ExifTagValue.GPSSpeedRef);
+    public static ExifTag<string> GPSSpeedRef { get; } = new(ExifTagValue.GPSSpeedRef);
 
     /// <summary>
     /// Gets the GPSTrackRef exif tag.
     /// </summary>
-    public static ExifTag<string> GPSTrackRef { get; } = new ExifTag<string>(ExifTagValue.GPSTrackRef);
+    public static ExifTag<string> GPSTrackRef { get; } = new(ExifTagValue.GPSTrackRef);
 
     /// <summary>
     /// Gets the GPSImgDirectionRef exif tag.
     /// </summary>
-    public static ExifTag<string> GPSImgDirectionRef { get; } = new ExifTag<string>(ExifTagValue.GPSImgDirectionRef);
+    public static ExifTag<string> GPSImgDirectionRef { get; } = new(ExifTagValue.GPSImgDirectionRef);
 
     /// <summary>
     /// Gets the GPSMapDatum exif tag.
     /// </summary>
-    public static ExifTag<string> GPSMapDatum { get; } = new ExifTag<string>(ExifTagValue.GPSMapDatum);
+    public static ExifTag<string> GPSMapDatum { get; } = new(ExifTagValue.GPSMapDatum);
 
     /// <summary>
     /// Gets the GPSDestLatitudeRef exif tag.
     /// </summary>
-    public static ExifTag<string> GPSDestLatitudeRef { get; } = new ExifTag<string>(ExifTagValue.GPSDestLatitudeRef);
+    public static ExifTag<string> GPSDestLatitudeRef { get; } = new(ExifTagValue.GPSDestLatitudeRef);
 
     /// <summary>
     /// Gets the GPSDestLongitudeRef exif tag.
     /// </summary>
-    public static ExifTag<string> GPSDestLongitudeRef { get; } = new ExifTag<string>(ExifTagValue.GPSDestLongitudeRef);
+    public static ExifTag<string> GPSDestLongitudeRef { get; } = new(ExifTagValue.GPSDestLongitudeRef);
 
     /// <summary>
     /// Gets the GPSDestBearingRef exif tag.
     /// </summary>
-    public static ExifTag<string> GPSDestBearingRef { get; } = new ExifTag<string>(ExifTagValue.GPSDestBearingRef);
+    public static ExifTag<string> GPSDestBearingRef { get; } = new(ExifTagValue.GPSDestBearingRef);
 
     /// <summary>
     /// Gets the GPSDestDistanceRef exif tag.
     /// </summary>
-    public static ExifTag<string> GPSDestDistanceRef { get; } = new ExifTag<string>(ExifTagValue.GPSDestDistanceRef);
+    public static ExifTag<string> GPSDestDistanceRef { get; } = new(ExifTagValue.GPSDestDistanceRef);
 
     /// <summary>
     /// Gets the GPSDateStamp exif tag.
     /// </summary>
-    public static ExifTag<string> GPSDateStamp { get; } = new ExifTag<string>(ExifTagValue.GPSDateStamp);
+    public static ExifTag<string> GPSDateStamp { get; } = new(ExifTagValue.GPSDateStamp);
 }
diff --git a/src/ImageSharp/Metadata/Profiles/Exif/Tags/ExifTag.Ucs2String.cs b/src/ImageSharp/Metadata/Profiles/Exif/Tags/ExifTag.Ucs2String.cs
index 65acc4bd75..e13b3b30e4 100644
--- a/src/ImageSharp/Metadata/Profiles/Exif/Tags/ExifTag.Ucs2String.cs
+++ b/src/ImageSharp/Metadata/Profiles/Exif/Tags/ExifTag.Ucs2String.cs
@@ -9,25 +9,25 @@ public abstract partial class ExifTag
     /// <summary>
     /// Gets the title tag used by Windows (encoded in UCS2).
     /// </summary>
-    public static ExifTag<string> XPTitle => new ExifTag<string>(ExifTagValue.XPTitle);
+    public static ExifTag<string> XPTitle => new(ExifTagValue.XPTitle);
 
     /// <summary>
     /// Gets the comment tag used by Windows (encoded in UCS2).
     /// </summary>
-    public static ExifTag<string> XPComment => new ExifTag<string>(ExifTagValue.XPComment);
+    public static ExifTag<string> XPComment => new(ExifTagValue.XPComment);
 
     /// <summary>
     /// Gets the author tag used by Windows (encoded in UCS2).
     /// </summary>
-    public static ExifTag<string> XPAuthor => new ExifTag<string>(ExifTagValue.XPAuthor);
+    public static ExifTag<string> XPAuthor => new(ExifTagValue.XPAuthor);
 
     /// <summary>
     /// Gets the keywords tag used by Windows (encoded in UCS2).
     /// </summary>
-    public static ExifTag<string> XPKeywords => new ExifTag<string>(ExifTagValue.XPKeywords);
+    public static ExifTag<string> XPKeywords => new(ExifTagValue.XPKeywords);
 
     /// <summary>
     /// Gets the subject tag used by Windows (encoded in UCS2).
     /// </summary>
-    public static ExifTag<string> XPSubject => new ExifTag<string>(ExifTagValue.XPSubject);
+    public static ExifTag<string> XPSubject => new(ExifTagValue.XPSubject);
 }
diff --git a/src/ImageSharp/Metadata/Profiles/Exif/Tags/ExifTag.Undefined.cs b/src/ImageSharp/Metadata/Profiles/Exif/Tags/ExifTag.Undefined.cs
index 417673b4ae..e822c2a111 100644
--- a/src/ImageSharp/Metadata/Profiles/Exif/Tags/ExifTag.Undefined.cs
+++ b/src/ImageSharp/Metadata/Profiles/Exif/Tags/ExifTag.Undefined.cs
@@ -9,70 +9,70 @@ public abstract partial class ExifTag
     /// <summary>
     /// Gets the JPEGTables exif tag.
     /// </summary>
-    public static ExifTag<byte[]> JPEGTables { get; } = new ExifTag<byte[]>(ExifTagValue.JPEGTables);
+    public static ExifTag<byte[]> JPEGTables { get; } = new(ExifTagValue.JPEGTables);
 
     /// <summary>
     /// Gets the OECF exif tag.
     /// </summary>
-    public static ExifTag<byte[]> OECF { get; } = new ExifTag<byte[]>(ExifTagValue.OECF);
+    public static ExifTag<byte[]> OECF { get; } = new(ExifTagValue.OECF);
 
     /// <summary>
     /// Gets the ExifVersion exif tag.
     /// </summary>
-    public static ExifTag<byte[]> ExifVersion { get; } = new ExifTag<byte[]>(ExifTagValue.ExifVersion);
+    public static ExifTag<byte[]> ExifVersion { get; } = new(ExifTagValue.ExifVersion);
 
     /// <summary>
     /// Gets the ComponentsConfiguration exif tag.
     /// </summary>
-    public static ExifTag<byte[]> ComponentsConfiguration { get; } = new ExifTag<byte[]>(ExifTagValue.ComponentsConfiguration);
+    public static ExifTag<byte[]> ComponentsConfiguration { get; } = new(ExifTagValue.ComponentsConfiguration);
 
     /// <summary>
     /// Gets the MakerNote exif tag.
     /// </summary>
-    public static ExifTag<byte[]> MakerNote { get; } = new ExifTag<byte[]>(ExifTagValue.MakerNote);
+    public static ExifTag<byte[]> MakerNote { get; } = new(ExifTagValue.MakerNote);
 
     /// <summary>
     /// Gets the FlashpixVersion exif tag.
     /// </summary>
-    public static ExifTag<byte[]> FlashpixVersion { get; } = new ExifTag<byte[]>(ExifTagValue.FlashpixVersion);
+    public static ExifTag<byte[]> FlashpixVersion { get; } = new(ExifTagValue.FlashpixVersion);
 
     /// <summary>
     /// Gets the SpatialFrequencyResponse exif tag.
     /// </summary>
-    public static ExifTag<byte[]> SpatialFrequencyResponse { get; } = new ExifTag<byte[]>(ExifTagValue.SpatialFrequencyResponse);
+    public static ExifTag<byte[]> SpatialFrequencyResponse { get; } = new(ExifTagValue.SpatialFrequencyResponse);
 
     /// <summary>
     /// Gets the SpatialFrequencyResponse2 exif tag.
     /// </summary>
-    public static ExifTag<byte[]> SpatialFrequencyResponse2 { get; } = new ExifTag<byte[]>(ExifTagValue.SpatialFrequencyResponse2);
+    public static ExifTag<byte[]> SpatialFrequencyResponse2 { get; } = new(ExifTagValue.SpatialFrequencyResponse2);
 
     /// <summary>
     /// Gets the Noise exif tag.
     /// </summary>
-    public static ExifTag<byte[]> Noise { get; } = new ExifTag<byte[]>(ExifTagValue.Noise);
+    public static ExifTag<byte[]> Noise { get; } = new(ExifTagValue.Noise);
 
     /// <summary>
     /// Gets the CFAPattern exif tag.
     /// </summary>
-    public static ExifTag<byte[]> CFAPattern { get; } = new ExifTag<byte[]>(ExifTagValue.CFAPattern);
+    public static ExifTag<byte[]> CFAPattern { get; } = new(ExifTagValue.CFAPattern);
 
     /// <summary>
     /// Gets the DeviceSettingDescription exif tag.
     /// </summary>
-    public static ExifTag<byte[]> DeviceSettingDescription { get; } = new ExifTag<byte[]>(ExifTagValue.DeviceSettingDescription);
+    public static ExifTag<byte[]> DeviceSettingDescription { get; } = new(ExifTagValue.DeviceSettingDescription);
 
     /// <summary>
     /// Gets the ImageSourceData exif tag.
     /// </summary>
-    public static ExifTag<byte[]> ImageSourceData { get; } = new ExifTag<byte[]>(ExifTagValue.ImageSourceData);
+    public static ExifTag<byte[]> ImageSourceData { get; } = new(ExifTagValue.ImageSourceData);
 
     /// <summary>
     /// Gets the FileSource exif tag.
     /// </summary>
-    public static ExifTag<byte> FileSource { get; } = new ExifTag<byte>(ExifTagValue.FileSource);
+    public static ExifTag<byte> FileSource { get; } = new(ExifTagValue.FileSource);
 
     /// <summary>
     /// Gets the ImageDescription exif tag.
     /// </summary>
-    public static ExifTag<byte> SceneType { get; } = new ExifTag<byte>(ExifTagValue.SceneType);
+    public static ExifTag<byte> SceneType { get; } = new(ExifTagValue.SceneType);
 }
diff --git a/src/ImageSharp/Metadata/Profiles/Exif/Tags/ExifTag.cs b/src/ImageSharp/Metadata/Profiles/Exif/Tags/ExifTag.cs
index ea0b8060d5..ec30f21cd4 100644
--- a/src/ImageSharp/Metadata/Profiles/Exif/Tags/ExifTag.cs
+++ b/src/ImageSharp/Metadata/Profiles/Exif/Tags/ExifTag.cs
@@ -4,7 +4,7 @@
 namespace SixLabors.ImageSharp.Metadata.Profiles.Exif;
 
 /// <summary>
-/// Class that represents an exif tag from the Exif standard 2.31.
+/// Class that represents an Exif tag from the Exif standard 2.31.
 /// </summary>
 public abstract partial class ExifTag : IEquatable<ExifTag>
 {
@@ -16,21 +16,21 @@ public abstract partial class ExifTag : IEquatable<ExifTag>
     /// Converts the specified <see cref="ExifTag"/> to a <see cref="ushort"/>.
     /// </summary>
     /// <param name="tag">The <see cref="ExifTag"/> to convert.</param>
-    public static explicit operator ushort(ExifTag tag) => tag?.value ?? (ushort)ExifTagValue.Unknown;
+    public static explicit operator ushort(ExifTag? tag) => tag?.value ?? (ushort)ExifTagValue.Unknown;
 
     /// <summary>
     /// Determines whether the specified <see cref="ExifTag"/> instances are considered equal.
     /// </summary>
     /// <param name="left">The first <see cref="ExifTag"/> to compare.</param>
     /// <param name="right"> The second <see cref="ExifTag"/> to compare.</param>
-    public static bool operator ==(ExifTag left, ExifTag right) => Equals(left, right);
+    public static bool operator ==(ExifTag? left, ExifTag? right) => left?.Equals(right) == true;
 
     /// <summary>
     /// Determines whether the specified <see cref="ExifTag"/> instances are not considered equal.
     /// </summary>
     /// <param name="left">The first <see cref="ExifTag"/> to compare.</param>
     /// <param name="right"> The second <see cref="ExifTag"/> to compare.</param>
-    public static bool operator !=(ExifTag left, ExifTag right) => !Equals(left, right);
+    public static bool operator !=(ExifTag? left, ExifTag? right) => !(left == right);
 
     /// <inheritdoc/>
     public override bool Equals(object? obj)
diff --git a/src/ImageSharp/Metadata/Profiles/Exif/Tags/ExifTagValue.cs b/src/ImageSharp/Metadata/Profiles/Exif/Tags/ExifTagValue.cs
index 56e8a3ffd1..07dbc51e7d 100644
--- a/src/ImageSharp/Metadata/Profiles/Exif/Tags/ExifTagValue.cs
+++ b/src/ImageSharp/Metadata/Profiles/Exif/Tags/ExifTagValue.cs
@@ -23,14 +23,6 @@ internal enum ExifTagValue
     /// </summary>
     GPSIFDOffset = 0x8825,
 
-    /// <summary>
-    /// Indicates the identification of the Interoperability rule.
-    /// See https://www.awaresystems.be/imaging/tiff/tifftags/privateifd/interoperability/interoperabilityindex.html
-    /// </summary>
-    [ExifTagDescription("R98", "Indicates a file conforming to R98 file specification of Recommended Exif Interoperability Rules (ExifR98) or to DCF basic file stipulated by Design Rule for Camera File System.")]
-    [ExifTagDescription("THM", "Indicates a file conforming to DCF thumbnail file stipulated by Design rule for Camera File System.")]
-    InteroperabilityIndex = 0x0001,
-
     /// <summary>
     /// A general indication of the kind of data contained in this subfile.
     /// See Section 8: Baseline Fields.
diff --git a/src/ImageSharp/Metadata/Profiles/Exif/Values/ExifArrayValue{TValueType}.cs b/src/ImageSharp/Metadata/Profiles/Exif/Values/ExifArrayValue{TValueType}.cs
index 64b8d23137..630709beca 100644
--- a/src/ImageSharp/Metadata/Profiles/Exif/Values/ExifArrayValue{TValueType}.cs
+++ b/src/ImageSharp/Metadata/Profiles/Exif/Values/ExifArrayValue{TValueType}.cs
@@ -43,7 +43,7 @@ internal abstract class ExifArrayValue<TValueType> : ExifValue, IExifValue<TValu
 
         if (type == typeof(TValueType))
         {
-            this.Value = new TValueType[] { (TValueType)value };
+            this.Value = [(TValueType)value];
             return true;
         }
 
diff --git a/src/ImageSharp/Metadata/Profiles/Exif/Values/ExifByte.cs b/src/ImageSharp/Metadata/Profiles/Exif/Values/ExifByte.cs
index eb69c43897..a261ca657c 100644
--- a/src/ImageSharp/Metadata/Profiles/Exif/Values/ExifByte.cs
+++ b/src/ImageSharp/Metadata/Profiles/Exif/Values/ExifByte.cs
@@ -30,7 +30,7 @@ internal sealed class ExifByte : ExifValue<byte>
         switch (value)
         {
             case int intValue:
-                if (intValue >= byte.MinValue && intValue <= byte.MaxValue)
+                if (intValue is >= byte.MinValue and <= byte.MaxValue)
                 {
                     this.Value = (byte)intValue;
                     return true;
diff --git a/src/ImageSharp/Metadata/Profiles/Exif/Values/ExifByteArray.cs b/src/ImageSharp/Metadata/Profiles/Exif/Values/ExifByteArray.cs
index 6811fc6f9c..c0bbb5bee2 100644
--- a/src/ImageSharp/Metadata/Profiles/Exif/Values/ExifByteArray.cs
+++ b/src/ImageSharp/Metadata/Profiles/Exif/Values/ExifByteArray.cs
@@ -30,9 +30,9 @@ internal sealed class ExifByteArray : ExifArrayValue<byte>
 
         if (value is int intValue)
         {
-            if (intValue >= byte.MinValue && intValue <= byte.MaxValue)
+            if (intValue is >= byte.MinValue and <= byte.MaxValue)
             {
-                this.Value = new byte[] { (byte)intValue };
+                this.Value = [(byte)intValue];
             }
 
             return true;
diff --git a/src/ImageSharp/Metadata/Profiles/Exif/Values/ExifEncodedString.cs b/src/ImageSharp/Metadata/Profiles/Exif/Values/ExifEncodedString.cs
index cce7cf3e89..14b097f816 100644
--- a/src/ImageSharp/Metadata/Profiles/Exif/Values/ExifEncodedString.cs
+++ b/src/ImageSharp/Metadata/Profiles/Exif/Values/ExifEncodedString.cs
@@ -24,7 +24,7 @@ internal sealed class ExifEncodedString : ExifValue<EncodedString>
 
     protected override string StringValue => this.Value.Text;
 
-    public override bool TrySetValue(object? value)
+    public bool TrySetValue(object? value, ByteOrder order)
     {
         if (base.TrySetValue(value))
         {
@@ -38,7 +38,7 @@ internal sealed class ExifEncodedString : ExifValue<EncodedString>
         }
         else if (value is byte[] buffer)
         {
-            if (ExifEncodedStringHelpers.TryParse(buffer, out EncodedString encodedString))
+            if (ExifEncodedStringHelpers.TryParse(buffer, order, out EncodedString encodedString))
             {
                 this.Value = encodedString;
                 return true;
@@ -48,5 +48,8 @@ internal sealed class ExifEncodedString : ExifValue<EncodedString>
         return false;
     }
 
+    public override bool TrySetValue(object? value)
+        => this.TrySetValue(value, ByteOrder.LittleEndian);
+
     public override IExifValue DeepClone() => new ExifEncodedString(this);
 }
diff --git a/src/ImageSharp/Metadata/Profiles/Exif/Values/ExifLong8Array.cs b/src/ImageSharp/Metadata/Profiles/Exif/Values/ExifLong8Array.cs
index b7756e62bd..3266e538ab 100644
--- a/src/ImageSharp/Metadata/Profiles/Exif/Values/ExifLong8Array.cs
+++ b/src/ImageSharp/Metadata/Profiles/Exif/Values/ExifLong8Array.cs
@@ -47,46 +47,40 @@ internal sealed class ExifLong8Array : ExifArrayValue<ulong>
                 return this.SetSingle((ulong)Numerics.Clamp(val, 0, int.MaxValue));
 
             case uint val:
-                return this.SetSingle((ulong)val);
+                return this.SetSingle(val);
 
             case short val:
                 return this.SetSingle((ulong)Numerics.Clamp(val, 0, short.MaxValue));
 
             case ushort val:
-                return this.SetSingle((ulong)val);
+                return this.SetSingle(val);
 
             case long val:
                 return this.SetSingle((ulong)Numerics.Clamp(val, 0, long.MaxValue));
 
             case long[] array:
-            {
                 if (value.GetType() == typeof(ulong[]))
                 {
                     return this.SetArray((ulong[])value);
                 }
 
                 return this.SetArray(array);
-            }
 
             case int[] array:
-            {
                 if (value.GetType() == typeof(uint[]))
                 {
                     return this.SetArray((uint[])value);
                 }
 
                 return this.SetArray(array);
-            }
 
             case short[] array:
-            {
                 if (value.GetType() == typeof(ushort[]))
                 {
                     return this.SetArray((ushort[])value);
                 }
 
                 return this.SetArray(array);
-            }
         }
 
         return false;
@@ -96,13 +90,13 @@ internal sealed class ExifLong8Array : ExifArrayValue<ulong>
 
     private bool SetSingle(ulong value)
     {
-        this.Value = new[] { value };
+        this.Value = [value];
         return true;
     }
 
     private bool SetArray(long[] values)
     {
-        var numbers = new ulong[values.Length];
+        ulong[] numbers = new ulong[values.Length];
         for (int i = 0; i < values.Length; i++)
         {
             numbers[i] = (ulong)(values[i] < 0 ? 0 : values[i]);
@@ -120,7 +114,7 @@ internal sealed class ExifLong8Array : ExifArrayValue<ulong>
 
     private bool SetArray(int[] values)
     {
-        var numbers = new ulong[values.Length];
+        ulong[] numbers = new ulong[values.Length];
         for (int i = 0; i < values.Length; i++)
         {
             numbers[i] = (ulong)Numerics.Clamp(values[i], 0, int.MaxValue);
@@ -132,10 +126,10 @@ internal sealed class ExifLong8Array : ExifArrayValue<ulong>
 
     private bool SetArray(uint[] values)
     {
-        var numbers = new ulong[values.Length];
+        ulong[] numbers = new ulong[values.Length];
         for (int i = 0; i < values.Length; i++)
         {
-            numbers[i] = (ulong)values[i];
+            numbers[i] = values[i];
         }
 
         this.Value = numbers;
@@ -144,7 +138,7 @@ internal sealed class ExifLong8Array : ExifArrayValue<ulong>
 
     private bool SetArray(short[] values)
     {
-        var numbers = new ulong[values.Length];
+        ulong[] numbers = new ulong[values.Length];
         for (int i = 0; i < values.Length; i++)
         {
             numbers[i] = (ulong)Numerics.Clamp(values[i], 0, short.MaxValue);
@@ -156,10 +150,10 @@ internal sealed class ExifLong8Array : ExifArrayValue<ulong>
 
     private bool SetArray(ushort[] values)
     {
-        var numbers = new ulong[values.Length];
+        ulong[] numbers = new ulong[values.Length];
         for (int i = 0; i < values.Length; i++)
         {
-            numbers[i] = (ulong)values[i];
+            numbers[i] = values[i];
         }
 
         this.Value = numbers;
diff --git a/src/ImageSharp/Metadata/Profiles/Exif/Values/ExifNumberArray.cs b/src/ImageSharp/Metadata/Profiles/Exif/Values/ExifNumberArray.cs
index 1162c25ea9..3c8e4fc333 100644
--- a/src/ImageSharp/Metadata/Profiles/Exif/Values/ExifNumberArray.cs
+++ b/src/ImageSharp/Metadata/Profiles/Exif/Values/ExifNumberArray.cs
@@ -52,7 +52,6 @@ internal sealed class ExifNumberArray : ExifArrayValue<Number>
             case ushort val:
                 return this.SetSingle(val);
             case int[] array:
-            {
                 // workaround for inconsistent covariance of value-typed arrays
                 if (value.GetType() == typeof(uint[]))
                 {
@@ -60,17 +59,14 @@ internal sealed class ExifNumberArray : ExifArrayValue<Number>
                 }
 
                 return this.SetArray(array);
-            }
 
             case short[] array:
-            {
                 if (value.GetType() == typeof(ushort[]))
                 {
                     return this.SetArray((ushort[])value);
                 }
 
                 return this.SetArray(array);
-            }
         }
 
         return false;
@@ -80,13 +76,13 @@ internal sealed class ExifNumberArray : ExifArrayValue<Number>
 
     private bool SetSingle(Number value)
     {
-        this.Value = new[] { value };
+        this.Value = [value];
         return true;
     }
 
     private bool SetArray(int[] values)
     {
-        var numbers = new Number[values.Length];
+        Number[] numbers = new Number[values.Length];
         for (int i = 0; i < values.Length; i++)
         {
             numbers[i] = values[i];
@@ -98,7 +94,7 @@ internal sealed class ExifNumberArray : ExifArrayValue<Number>
 
     private bool SetArray(uint[] values)
     {
-        var numbers = new Number[values.Length];
+        Number[] numbers = new Number[values.Length];
         for (int i = 0; i < values.Length; i++)
         {
             numbers[i] = values[i];
@@ -110,7 +106,7 @@ internal sealed class ExifNumberArray : ExifArrayValue<Number>
 
     private bool SetArray(short[] values)
     {
-        var numbers = new Number[values.Length];
+        Number[] numbers = new Number[values.Length];
         for (int i = 0; i < values.Length; i++)
         {
             numbers[i] = values[i];
@@ -122,7 +118,7 @@ internal sealed class ExifNumberArray : ExifArrayValue<Number>
 
     private bool SetArray(ushort[] values)
     {
-        var numbers = new Number[values.Length];
+        Number[] numbers = new Number[values.Length];
         for (int i = 0; i < values.Length; i++)
         {
             numbers[i] = values[i];
diff --git a/src/ImageSharp/Metadata/Profiles/Exif/Values/ExifRationalArray.cs b/src/ImageSharp/Metadata/Profiles/Exif/Values/ExifRationalArray.cs
index ac6453edc7..e8b2006df1 100644
--- a/src/ImageSharp/Metadata/Profiles/Exif/Values/ExifRationalArray.cs
+++ b/src/ImageSharp/Metadata/Profiles/Exif/Values/ExifRationalArray.cs
@@ -38,7 +38,7 @@ internal sealed class ExifRationalArray : ExifArrayValue<Rational>
         {
             if (signed.Numerator >= 0 && signed.Denominator >= 0)
             {
-                this.Value = new[] { new Rational((uint)signed.Numerator, (uint)signed.Denominator) };
+                this.Value = [new Rational((uint)signed.Numerator, (uint)signed.Denominator)];
             }
 
             return true;
@@ -56,7 +56,7 @@ internal sealed class ExifRationalArray : ExifArrayValue<Rational>
             return false;
         }
 
-        var unsigned = new Rational[signed.Length];
+        Rational[] unsigned = new Rational[signed.Length];
         for (int i = 0; i < signed.Length; i++)
         {
             SignedRational s = signed[i];
diff --git a/src/ImageSharp/Metadata/Profiles/Exif/Values/ExifShort.cs b/src/ImageSharp/Metadata/Profiles/Exif/Values/ExifShort.cs
index d35b21422b..7dfd7aed1d 100644
--- a/src/ImageSharp/Metadata/Profiles/Exif/Values/ExifShort.cs
+++ b/src/ImageSharp/Metadata/Profiles/Exif/Values/ExifShort.cs
@@ -36,7 +36,7 @@ internal sealed class ExifShort : ExifValue<ushort>
         switch (value)
         {
             case int intValue:
-                if (intValue >= ushort.MinValue && intValue <= ushort.MaxValue)
+                if (intValue is >= ushort.MinValue and <= ushort.MaxValue)
                 {
                     this.Value = (ushort)intValue;
                     return true;
diff --git a/src/ImageSharp/Metadata/Profiles/Exif/Values/ExifShortArray.cs b/src/ImageSharp/Metadata/Profiles/Exif/Values/ExifShortArray.cs
index a205e77dee..18ab5a162e 100644
--- a/src/ImageSharp/Metadata/Profiles/Exif/Values/ExifShortArray.cs
+++ b/src/ImageSharp/Metadata/Profiles/Exif/Values/ExifShortArray.cs
@@ -41,9 +41,9 @@ internal sealed class ExifShortArray : ExifArrayValue<ushort>
 
         if (value is int signedInt)
         {
-            if (signedInt >= ushort.MinValue && signedInt <= ushort.MaxValue)
+            if (signedInt is >= ushort.MinValue and <= ushort.MaxValue)
             {
-                this.Value = new ushort[] { (ushort)signedInt };
+                this.Value = [(ushort)signedInt];
             }
 
             return true;
@@ -53,7 +53,7 @@ internal sealed class ExifShortArray : ExifArrayValue<ushort>
         {
             if (signedShort >= ushort.MinValue)
             {
-                this.Value = new ushort[] { (ushort)signedShort };
+                this.Value = [(ushort)signedShort];
             }
 
             return true;
@@ -66,12 +66,12 @@ internal sealed class ExifShortArray : ExifArrayValue<ushort>
 
     private bool TrySetSignedIntArray(int[] signed)
     {
-        if (Array.FindIndex(signed, x => x < ushort.MinValue || x > ushort.MaxValue) > -1)
+        if (Array.FindIndex(signed, x => x is < ushort.MinValue or > ushort.MaxValue) > -1)
         {
             return false;
         }
 
-        var unsigned = new ushort[signed.Length];
+        ushort[] unsigned = new ushort[signed.Length];
         for (int i = 0; i < signed.Length; i++)
         {
             int s = signed[i];
@@ -89,7 +89,7 @@ internal sealed class ExifShortArray : ExifArrayValue<ushort>
             return false;
         }
 
-        var unsigned = new ushort[signed.Length];
+        ushort[] unsigned = new ushort[signed.Length];
         for (int i = 0; i < signed.Length; i++)
         {
             short s = signed[i];
diff --git a/src/ImageSharp/Metadata/Profiles/Exif/Values/ExifSignedByte.cs b/src/ImageSharp/Metadata/Profiles/Exif/Values/ExifSignedByte.cs
index 95a239b70d..206f8bd41b 100644
--- a/src/ImageSharp/Metadata/Profiles/Exif/Values/ExifSignedByte.cs
+++ b/src/ImageSharp/Metadata/Profiles/Exif/Values/ExifSignedByte.cs
@@ -31,7 +31,7 @@ internal sealed class ExifSignedByte : ExifValue<sbyte>
         switch (value)
         {
             case int intValue:
-                if (intValue >= sbyte.MinValue && intValue <= sbyte.MaxValue)
+                if (intValue is >= sbyte.MinValue and <= sbyte.MaxValue)
                 {
                     this.Value = (sbyte)intValue;
                     return true;
diff --git a/src/ImageSharp/Metadata/Profiles/Exif/Values/ExifSignedShort.cs b/src/ImageSharp/Metadata/Profiles/Exif/Values/ExifSignedShort.cs
index 6726febef0..5b008ea4a7 100644
--- a/src/ImageSharp/Metadata/Profiles/Exif/Values/ExifSignedShort.cs
+++ b/src/ImageSharp/Metadata/Profiles/Exif/Values/ExifSignedShort.cs
@@ -31,7 +31,7 @@ internal sealed class ExifSignedShort : ExifValue<short>
         switch (value)
         {
             case int intValue:
-                if (intValue >= short.MinValue && intValue <= short.MaxValue)
+                if (intValue is >= short.MinValue and <= short.MaxValue)
                 {
                     this.Value = (short)intValue;
                     return true;
diff --git a/src/ImageSharp/Metadata/Profiles/Exif/Values/ExifSignedShortArray.cs b/src/ImageSharp/Metadata/Profiles/Exif/Values/ExifSignedShortArray.cs
index 206417f667..d3993ac0dc 100644
--- a/src/ImageSharp/Metadata/Profiles/Exif/Values/ExifSignedShortArray.cs
+++ b/src/ImageSharp/Metadata/Profiles/Exif/Values/ExifSignedShortArray.cs
@@ -36,9 +36,9 @@ internal sealed class ExifSignedShortArray : ExifArrayValue<short>
 
         if (value is int intValue)
         {
-            if (intValue >= short.MinValue && intValue <= short.MaxValue)
+            if (intValue is >= short.MinValue and <= short.MaxValue)
             {
-                this.Value = new short[] { (short)intValue };
+                this.Value = [(short)intValue];
             }
 
             return true;
@@ -51,12 +51,12 @@ internal sealed class ExifSignedShortArray : ExifArrayValue<short>
 
     private bool TrySetSignedArray(int[] intArray)
     {
-        if (Array.FindIndex(intArray, x => x < short.MinValue || x > short.MaxValue) > -1)
+        if (Array.FindIndex(intArray, x => x is < short.MinValue or > short.MaxValue) > -1)
         {
             return false;
         }
 
-        var value = new short[intArray.Length];
+        short[] value = new short[intArray.Length];
         for (int i = 0; i < intArray.Length; i++)
         {
             int s = intArray[i];
diff --git a/src/ImageSharp/Metadata/Profiles/Exif/Values/ExifValues.cs b/src/ImageSharp/Metadata/Profiles/Exif/Values/ExifValues.cs
index 93f67d46ad..1c054fcba9 100644
--- a/src/ImageSharp/Metadata/Profiles/Exif/Values/ExifValues.cs
+++ b/src/ImageSharp/Metadata/Profiles/Exif/Values/ExifValues.cs
@@ -3,7 +3,7 @@
 
 namespace SixLabors.ImageSharp.Metadata.Profiles.Exif;
 
-internal static partial class ExifValues
+internal static class ExifValues
 {
     public static ExifValue? Create(ExifTagValue tag) => (ExifValue?)CreateValue(tag);
 
@@ -12,573 +12,281 @@ internal static partial class ExifValues
     public static ExifValue? Create(ExifTagValue tag, ExifDataType dataType, ulong numberOfComponents) => Create(tag, dataType, numberOfComponents != 1);
 
     public static ExifValue? Create(ExifTagValue tag, ExifDataType dataType, bool isArray)
-    {
-        switch (dataType)
+        => dataType switch
         {
-            case ExifDataType.Byte:
-                return isArray ? new ExifByteArray(tag, dataType) : new ExifByte(tag, dataType);
-            case ExifDataType.DoubleFloat:
-                return isArray ? new ExifDoubleArray(tag) : new ExifDouble(tag);
-            case ExifDataType.SingleFloat:
-                return isArray ? new ExifFloatArray(tag) : new ExifFloat(tag);
-            case ExifDataType.Long:
-                return isArray ? new ExifLongArray(tag) : new ExifLong(tag);
-            case ExifDataType.Long8:
-                return isArray ? new ExifLong8Array(tag) : new ExifLong8(tag);
-            case ExifDataType.Rational:
-                return isArray ? new ExifRationalArray(tag) : new ExifRational(tag);
-            case ExifDataType.Short:
-                return isArray ? new ExifShortArray(tag) : new ExifShort(tag);
-            case ExifDataType.SignedByte:
-                return isArray ? new ExifSignedByteArray(tag) : new ExifSignedByte(tag);
-            case ExifDataType.SignedLong:
-                return isArray ? new ExifSignedLongArray(tag) : new ExifSignedLong(tag);
-            case ExifDataType.SignedLong8:
-                return isArray ? new ExifSignedLong8Array(tag) : new ExifSignedLong8(tag);
-            case ExifDataType.SignedRational:
-                return isArray ? new ExifSignedRationalArray(tag) : new ExifSignedRational(tag);
-            case ExifDataType.SignedShort:
-                return isArray ? new ExifSignedShortArray(tag) : new ExifSignedShort(tag);
-            case ExifDataType.Ascii:
-                return new ExifString(tag);
-            case ExifDataType.Undefined:
-                return isArray ? new ExifByteArray(tag, dataType) : new ExifByte(tag, dataType);
-            default:
-                return null;
-        }
-    }
+            ExifDataType.Byte => isArray ? new ExifByteArray(tag, dataType) : new ExifByte(tag, dataType),
+            ExifDataType.DoubleFloat => isArray ? new ExifDoubleArray(tag) : new ExifDouble(tag),
+            ExifDataType.SingleFloat => isArray ? new ExifFloatArray(tag) : new ExifFloat(tag),
+            ExifDataType.Long => isArray ? new ExifLongArray(tag) : new ExifLong(tag),
+            ExifDataType.Long8 => isArray ? new ExifLong8Array(tag) : new ExifLong8(tag),
+            ExifDataType.Rational => isArray ? new ExifRationalArray(tag) : new ExifRational(tag),
+            ExifDataType.Short => isArray ? new ExifShortArray(tag) : new ExifShort(tag),
+            ExifDataType.SignedByte => isArray ? new ExifSignedByteArray(tag) : new ExifSignedByte(tag),
+            ExifDataType.SignedLong => isArray ? new ExifSignedLongArray(tag) : new ExifSignedLong(tag),
+            ExifDataType.SignedLong8 => isArray ? new ExifSignedLong8Array(tag) : new ExifSignedLong8(tag),
+            ExifDataType.SignedRational => isArray ? new ExifSignedRationalArray(tag) : new ExifSignedRational(tag),
+            ExifDataType.SignedShort => isArray ? new ExifSignedShortArray(tag) : new ExifSignedShort(tag),
+            ExifDataType.Ascii => new ExifString(tag),
+            ExifDataType.Undefined => isArray ? new ExifByteArray(tag, dataType) : new ExifByte(tag, dataType),
+            _ => null,
+        };
 
     private static object? CreateValue(ExifTagValue tag)
-    {
-        switch (tag)
+        => tag switch
         {
-            case ExifTagValue.FaxProfile:
-                return new ExifByte(ExifTag.FaxProfile, ExifDataType.Byte);
-            case ExifTagValue.ModeNumber:
-                return new ExifByte(ExifTag.ModeNumber, ExifDataType.Byte);
-            case ExifTagValue.GPSAltitudeRef:
-                return new ExifByte(ExifTag.GPSAltitudeRef, ExifDataType.Byte);
-
-            case ExifTagValue.ClipPath:
-                return new ExifByteArray(ExifTag.ClipPath, ExifDataType.Byte);
-            case ExifTagValue.VersionYear:
-                return new ExifByteArray(ExifTag.VersionYear, ExifDataType.Byte);
-            case ExifTagValue.XMP:
-                return new ExifByteArray(ExifTag.XMP, ExifDataType.Byte);
-            case ExifTagValue.CFAPattern2:
-                return new ExifByteArray(ExifTag.CFAPattern2, ExifDataType.Byte);
-            case ExifTagValue.TIFFEPStandardID:
-                return new ExifByteArray(ExifTag.TIFFEPStandardID, ExifDataType.Byte);
-            case ExifTagValue.GPSVersionID:
-                return new ExifByteArray(ExifTag.GPSVersionID, ExifDataType.Byte);
-
-            case ExifTagValue.PixelScale:
-                return new ExifDoubleArray(ExifTag.PixelScale);
-            case ExifTagValue.IntergraphMatrix:
-                return new ExifDoubleArray(ExifTag.IntergraphMatrix);
-            case ExifTagValue.ModelTiePoint:
-                return new ExifDoubleArray(ExifTag.ModelTiePoint);
-            case ExifTagValue.ModelTransform:
-                return new ExifDoubleArray(ExifTag.ModelTransform);
-
-            case ExifTagValue.SubfileType:
-                return new ExifLong(ExifTag.SubfileType);
-            case ExifTagValue.SubIFDOffset:
-                return new ExifLong(ExifTag.SubIFDOffset);
-            case ExifTagValue.GPSIFDOffset:
-                return new ExifLong(ExifTag.GPSIFDOffset);
-            case ExifTagValue.T4Options:
-                return new ExifLong(ExifTag.T4Options);
-            case ExifTagValue.T6Options:
-                return new ExifLong(ExifTag.T6Options);
-            case ExifTagValue.XClipPathUnits:
-                return new ExifLong(ExifTag.XClipPathUnits);
-            case ExifTagValue.YClipPathUnits:
-                return new ExifLong(ExifTag.YClipPathUnits);
-            case ExifTagValue.ProfileType:
-                return new ExifLong(ExifTag.ProfileType);
-            case ExifTagValue.CodingMethods:
-                return new ExifLong(ExifTag.CodingMethods);
-            case ExifTagValue.T82ptions:
-                return new ExifLong(ExifTag.T82ptions);
-            case ExifTagValue.JPEGInterchangeFormat:
-                return new ExifLong(ExifTag.JPEGInterchangeFormat);
-            case ExifTagValue.JPEGInterchangeFormatLength:
-                return new ExifLong(ExifTag.JPEGInterchangeFormatLength);
-            case ExifTagValue.MDFileTag:
-                return new ExifLong(ExifTag.MDFileTag);
-            case ExifTagValue.StandardOutputSensitivity:
-                return new ExifLong(ExifTag.StandardOutputSensitivity);
-            case ExifTagValue.RecommendedExposureIndex:
-                return new ExifLong(ExifTag.RecommendedExposureIndex);
-            case ExifTagValue.ISOSpeed:
-                return new ExifLong(ExifTag.ISOSpeed);
-            case ExifTagValue.ISOSpeedLatitudeyyy:
-                return new ExifLong(ExifTag.ISOSpeedLatitudeyyy);
-            case ExifTagValue.ISOSpeedLatitudezzz:
-                return new ExifLong(ExifTag.ISOSpeedLatitudezzz);
-            case ExifTagValue.FaxRecvParams:
-                return new ExifLong(ExifTag.FaxRecvParams);
-            case ExifTagValue.FaxRecvTime:
-                return new ExifLong(ExifTag.FaxRecvTime);
-            case ExifTagValue.ImageNumber:
-                return new ExifLong(ExifTag.ImageNumber);
-
-            case ExifTagValue.FreeOffsets:
-                return new ExifLongArray(ExifTag.FreeOffsets);
-            case ExifTagValue.FreeByteCounts:
-                return new ExifLongArray(ExifTag.FreeByteCounts);
-            case ExifTagValue.ColorResponseUnit:
-                return new ExifLongArray(ExifTag.ColorResponseUnit);
-            case ExifTagValue.SMinSampleValue:
-                return new ExifLongArray(ExifTag.SMinSampleValue);
-            case ExifTagValue.SMaxSampleValue:
-                return new ExifLongArray(ExifTag.SMaxSampleValue);
-            case ExifTagValue.JPEGQTables:
-                return new ExifLongArray(ExifTag.JPEGQTables);
-            case ExifTagValue.JPEGDCTables:
-                return new ExifLongArray(ExifTag.JPEGDCTables);
-            case ExifTagValue.JPEGACTables:
-                return new ExifLongArray(ExifTag.JPEGACTables);
-            case ExifTagValue.StripRowCounts:
-                return new ExifLongArray(ExifTag.StripRowCounts);
-            case ExifTagValue.IntergraphRegisters:
-                return new ExifLongArray(ExifTag.IntergraphRegisters);
-            case ExifTagValue.SubIFDs:
-                return new ExifLongArray(ExifTag.SubIFDs);
-
-            case ExifTagValue.ImageWidth:
-                return new ExifNumber(ExifTag.ImageWidth);
-            case ExifTagValue.ImageLength:
-                return new ExifNumber(ExifTag.ImageLength);
-            case ExifTagValue.RowsPerStrip:
-                return new ExifNumber(ExifTag.RowsPerStrip);
-            case ExifTagValue.TileWidth:
-                return new ExifNumber(ExifTag.TileWidth);
-            case ExifTagValue.TileLength:
-                return new ExifNumber(ExifTag.TileLength);
-            case ExifTagValue.BadFaxLines:
-                return new ExifNumber(ExifTag.BadFaxLines);
-            case ExifTagValue.ConsecutiveBadFaxLines:
-                return new ExifNumber(ExifTag.ConsecutiveBadFaxLines);
-            case ExifTagValue.PixelXDimension:
-                return new ExifNumber(ExifTag.PixelXDimension);
-            case ExifTagValue.PixelYDimension:
-                return new ExifNumber(ExifTag.PixelYDimension);
-
-            case ExifTagValue.StripByteCounts:
-                return new ExifNumberArray(ExifTag.StripByteCounts);
-            case ExifTagValue.StripOffsets:
-                return new ExifNumberArray(ExifTag.StripOffsets);
-            case ExifTagValue.TileByteCounts:
-                return new ExifNumberArray(ExifTag.TileByteCounts);
-            case ExifTagValue.TileOffsets:
-                return new ExifNumberArray(ExifTag.TileOffsets);
-            case ExifTagValue.ImageLayer:
-                return new ExifNumberArray(ExifTag.ImageLayer);
-
-            case ExifTagValue.XPosition:
-                return new ExifRational(ExifTag.XPosition);
-            case ExifTagValue.YPosition:
-                return new ExifRational(ExifTag.YPosition);
-            case ExifTagValue.XResolution:
-                return new ExifRational(ExifTag.XResolution);
-            case ExifTagValue.YResolution:
-                return new ExifRational(ExifTag.YResolution);
-            case ExifTagValue.BatteryLevel:
-                return new ExifRational(ExifTag.BatteryLevel);
-            case ExifTagValue.ExposureTime:
-                return new ExifRational(ExifTag.ExposureTime);
-            case ExifTagValue.FNumber:
-                return new ExifRational(ExifTag.FNumber);
-            case ExifTagValue.MDScalePixel:
-                return new ExifRational(ExifTag.MDScalePixel);
-            case ExifTagValue.CompressedBitsPerPixel:
-                return new ExifRational(ExifTag.CompressedBitsPerPixel);
-            case ExifTagValue.ApertureValue:
-                return new ExifRational(ExifTag.ApertureValue);
-            case ExifTagValue.MaxApertureValue:
-                return new ExifRational(ExifTag.MaxApertureValue);
-            case ExifTagValue.SubjectDistance:
-                return new ExifRational(ExifTag.SubjectDistance);
-            case ExifTagValue.FocalLength:
-                return new ExifRational(ExifTag.FocalLength);
-            case ExifTagValue.FlashEnergy2:
-                return new ExifRational(ExifTag.FlashEnergy2);
-            case ExifTagValue.FocalPlaneXResolution2:
-                return new ExifRational(ExifTag.FocalPlaneXResolution2);
-            case ExifTagValue.FocalPlaneYResolution2:
-                return new ExifRational(ExifTag.FocalPlaneYResolution2);
-            case ExifTagValue.ExposureIndex2:
-                return new ExifRational(ExifTag.ExposureIndex2);
-            case ExifTagValue.Humidity:
-                return new ExifRational(ExifTag.Humidity);
-            case ExifTagValue.Pressure:
-                return new ExifRational(ExifTag.Pressure);
-            case ExifTagValue.Acceleration:
-                return new ExifRational(ExifTag.Acceleration);
-            case ExifTagValue.FlashEnergy:
-                return new ExifRational(ExifTag.FlashEnergy);
-            case ExifTagValue.FocalPlaneXResolution:
-                return new ExifRational(ExifTag.FocalPlaneXResolution);
-            case ExifTagValue.FocalPlaneYResolution:
-                return new ExifRational(ExifTag.FocalPlaneYResolution);
-            case ExifTagValue.ExposureIndex:
-                return new ExifRational(ExifTag.ExposureIndex);
-            case ExifTagValue.DigitalZoomRatio:
-                return new ExifRational(ExifTag.DigitalZoomRatio);
-            case ExifTagValue.GPSAltitude:
-                return new ExifRational(ExifTag.GPSAltitude);
-            case ExifTagValue.GPSDOP:
-                return new ExifRational(ExifTag.GPSDOP);
-            case ExifTagValue.GPSSpeed:
-                return new ExifRational(ExifTag.GPSSpeed);
-            case ExifTagValue.GPSTrack:
-                return new ExifRational(ExifTag.GPSTrack);
-            case ExifTagValue.GPSImgDirection:
-                return new ExifRational(ExifTag.GPSImgDirection);
-            case ExifTagValue.GPSDestBearing:
-                return new ExifRational(ExifTag.GPSDestBearing);
-            case ExifTagValue.GPSDestDistance:
-                return new ExifRational(ExifTag.GPSDestDistance);
-            case ExifTagValue.GPSHPositioningError:
-                return new ExifRational(ExifTag.GPSHPositioningError);
-
-            case ExifTagValue.WhitePoint:
-                return new ExifRationalArray(ExifTag.WhitePoint);
-            case ExifTagValue.PrimaryChromaticities:
-                return new ExifRationalArray(ExifTag.PrimaryChromaticities);
-            case ExifTagValue.YCbCrCoefficients:
-                return new ExifRationalArray(ExifTag.YCbCrCoefficients);
-            case ExifTagValue.ReferenceBlackWhite:
-                return new ExifRationalArray(ExifTag.ReferenceBlackWhite);
-            case ExifTagValue.GPSLatitude:
-                return new ExifRationalArray(ExifTag.GPSLatitude);
-            case ExifTagValue.GPSLongitude:
-                return new ExifRationalArray(ExifTag.GPSLongitude);
-            case ExifTagValue.GPSTimestamp:
-                return new ExifRationalArray(ExifTag.GPSTimestamp);
-            case ExifTagValue.GPSDestLatitude:
-                return new ExifRationalArray(ExifTag.GPSDestLatitude);
-            case ExifTagValue.GPSDestLongitude:
-                return new ExifRationalArray(ExifTag.GPSDestLongitude);
-            case ExifTagValue.LensSpecification:
-                return new ExifRationalArray(ExifTag.LensSpecification);
-
-            case ExifTagValue.OldSubfileType:
-                return new ExifShort(ExifTag.OldSubfileType);
-            case ExifTagValue.Compression:
-                return new ExifShort(ExifTag.Compression);
-            case ExifTagValue.PhotometricInterpretation:
-                return new ExifShort(ExifTag.PhotometricInterpretation);
-            case ExifTagValue.Thresholding:
-                return new ExifShort(ExifTag.Thresholding);
-            case ExifTagValue.CellWidth:
-                return new ExifShort(ExifTag.CellWidth);
-            case ExifTagValue.CellLength:
-                return new ExifShort(ExifTag.CellLength);
-            case ExifTagValue.FillOrder:
-                return new ExifShort(ExifTag.FillOrder);
-            case ExifTagValue.Orientation:
-                return new ExifShort(ExifTag.Orientation);
-            case ExifTagValue.SamplesPerPixel:
-                return new ExifShort(ExifTag.SamplesPerPixel);
-            case ExifTagValue.PlanarConfiguration:
-                return new ExifShort(ExifTag.PlanarConfiguration);
-            case ExifTagValue.Predictor:
-                return new ExifShort(ExifTag.Predictor);
-            case ExifTagValue.GrayResponseUnit:
-                return new ExifShort(ExifTag.GrayResponseUnit);
-            case ExifTagValue.ResolutionUnit:
-                return new ExifShort(ExifTag.ResolutionUnit);
-            case ExifTagValue.CleanFaxData:
-                return new ExifShort(ExifTag.CleanFaxData);
-            case ExifTagValue.InkSet:
-                return new ExifShort(ExifTag.InkSet);
-            case ExifTagValue.NumberOfInks:
-                return new ExifShort(ExifTag.NumberOfInks);
-            case ExifTagValue.DotRange:
-                return new ExifShort(ExifTag.DotRange);
-            case ExifTagValue.Indexed:
-                return new ExifShort(ExifTag.Indexed);
-            case ExifTagValue.OPIProxy:
-                return new ExifShort(ExifTag.OPIProxy);
-            case ExifTagValue.JPEGProc:
-                return new ExifShort(ExifTag.JPEGProc);
-            case ExifTagValue.JPEGRestartInterval:
-                return new ExifShort(ExifTag.JPEGRestartInterval);
-            case ExifTagValue.YCbCrPositioning:
-                return new ExifShort(ExifTag.YCbCrPositioning);
-            case ExifTagValue.Rating:
-                return new ExifShort(ExifTag.Rating);
-            case ExifTagValue.RatingPercent:
-                return new ExifShort(ExifTag.RatingPercent);
-            case ExifTagValue.ExposureProgram:
-                return new ExifShort(ExifTag.ExposureProgram);
-            case ExifTagValue.Interlace:
-                return new ExifShort(ExifTag.Interlace);
-            case ExifTagValue.SelfTimerMode:
-                return new ExifShort(ExifTag.SelfTimerMode);
-            case ExifTagValue.SensitivityType:
-                return new ExifShort(ExifTag.SensitivityType);
-            case ExifTagValue.MeteringMode:
-                return new ExifShort(ExifTag.MeteringMode);
-            case ExifTagValue.LightSource:
-                return new ExifShort(ExifTag.LightSource);
-            case ExifTagValue.FocalPlaneResolutionUnit2:
-                return new ExifShort(ExifTag.FocalPlaneResolutionUnit2);
-            case ExifTagValue.SensingMethod2:
-                return new ExifShort(ExifTag.SensingMethod2);
-            case ExifTagValue.Flash:
-                return new ExifShort(ExifTag.Flash);
-            case ExifTagValue.ColorSpace:
-                return new ExifShort(ExifTag.ColorSpace);
-            case ExifTagValue.FocalPlaneResolutionUnit:
-                return new ExifShort(ExifTag.FocalPlaneResolutionUnit);
-            case ExifTagValue.SensingMethod:
-                return new ExifShort(ExifTag.SensingMethod);
-            case ExifTagValue.CustomRendered:
-                return new ExifShort(ExifTag.CustomRendered);
-            case ExifTagValue.ExposureMode:
-                return new ExifShort(ExifTag.ExposureMode);
-            case ExifTagValue.WhiteBalance:
-                return new ExifShort(ExifTag.WhiteBalance);
-            case ExifTagValue.FocalLengthIn35mmFilm:
-                return new ExifShort(ExifTag.FocalLengthIn35mmFilm);
-            case ExifTagValue.SceneCaptureType:
-                return new ExifShort(ExifTag.SceneCaptureType);
-            case ExifTagValue.GainControl:
-                return new ExifShort(ExifTag.GainControl);
-            case ExifTagValue.Contrast:
-                return new ExifShort(ExifTag.Contrast);
-            case ExifTagValue.Saturation:
-                return new ExifShort(ExifTag.Saturation);
-            case ExifTagValue.Sharpness:
-                return new ExifShort(ExifTag.Sharpness);
-            case ExifTagValue.SubjectDistanceRange:
-                return new ExifShort(ExifTag.SubjectDistanceRange);
-            case ExifTagValue.GPSDifferential:
-                return new ExifShort(ExifTag.GPSDifferential);
-
-            case ExifTagValue.BitsPerSample:
-                return new ExifShortArray(ExifTag.BitsPerSample);
-            case ExifTagValue.MinSampleValue:
-                return new ExifShortArray(ExifTag.MinSampleValue);
-            case ExifTagValue.MaxSampleValue:
-                return new ExifShortArray(ExifTag.MaxSampleValue);
-            case ExifTagValue.GrayResponseCurve:
-                return new ExifShortArray(ExifTag.GrayResponseCurve);
-            case ExifTagValue.ColorMap:
-                return new ExifShortArray(ExifTag.ColorMap);
-            case ExifTagValue.ExtraSamples:
-                return new ExifShortArray(ExifTag.ExtraSamples);
-            case ExifTagValue.PageNumber:
-                return new ExifShortArray(ExifTag.PageNumber);
-            case ExifTagValue.TransferFunction:
-                return new ExifShortArray(ExifTag.TransferFunction);
-            case ExifTagValue.HalftoneHints:
-                return new ExifShortArray(ExifTag.HalftoneHints);
-            case ExifTagValue.SampleFormat:
-                return new ExifShortArray(ExifTag.SampleFormat);
-            case ExifTagValue.TransferRange:
-                return new ExifShortArray(ExifTag.TransferRange);
-            case ExifTagValue.DefaultImageColor:
-                return new ExifShortArray(ExifTag.DefaultImageColor);
-            case ExifTagValue.JPEGLosslessPredictors:
-                return new ExifShortArray(ExifTag.JPEGLosslessPredictors);
-            case ExifTagValue.JPEGPointTransforms:
-                return new ExifShortArray(ExifTag.JPEGPointTransforms);
-            case ExifTagValue.YCbCrSubsampling:
-                return new ExifShortArray(ExifTag.YCbCrSubsampling);
-            case ExifTagValue.CFARepeatPatternDim:
-                return new ExifShortArray(ExifTag.CFARepeatPatternDim);
-            case ExifTagValue.IntergraphPacketData:
-                return new ExifShortArray(ExifTag.IntergraphPacketData);
-            case ExifTagValue.ISOSpeedRatings:
-                return new ExifShortArray(ExifTag.ISOSpeedRatings);
-            case ExifTagValue.SubjectArea:
-                return new ExifShortArray(ExifTag.SubjectArea);
-            case ExifTagValue.SubjectLocation:
-                return new ExifShortArray(ExifTag.SubjectLocation);
-
-            case ExifTagValue.ShutterSpeedValue:
-                return new ExifSignedRational(ExifTag.ShutterSpeedValue);
-            case ExifTagValue.BrightnessValue:
-                return new ExifSignedRational(ExifTag.BrightnessValue);
-            case ExifTagValue.ExposureBiasValue:
-                return new ExifSignedRational(ExifTag.ExposureBiasValue);
-            case ExifTagValue.AmbientTemperature:
-                return new ExifSignedRational(ExifTag.AmbientTemperature);
-            case ExifTagValue.WaterDepth:
-                return new ExifSignedRational(ExifTag.WaterDepth);
-            case ExifTagValue.CameraElevationAngle:
-                return new ExifSignedRational(ExifTag.CameraElevationAngle);
-
-            case ExifTagValue.Decode:
-                return new ExifSignedRationalArray(ExifTag.Decode);
-
-            case ExifTagValue.TimeZoneOffset:
-                return new ExifSignedShortArray(ExifTag.TimeZoneOffset);
-
-            case ExifTagValue.ImageDescription:
-                return new ExifString(ExifTag.ImageDescription);
-            case ExifTagValue.Make:
-                return new ExifString(ExifTag.Make);
-            case ExifTagValue.Model:
-                return new ExifString(ExifTag.Model);
-            case ExifTagValue.Software:
-                return new ExifString(ExifTag.Software);
-            case ExifTagValue.DateTime:
-                return new ExifString(ExifTag.DateTime);
-            case ExifTagValue.Artist:
-                return new ExifString(ExifTag.Artist);
-            case ExifTagValue.HostComputer:
-                return new ExifString(ExifTag.HostComputer);
-            case ExifTagValue.Copyright:
-                return new ExifString(ExifTag.Copyright);
-            case ExifTagValue.DocumentName:
-                return new ExifString(ExifTag.DocumentName);
-            case ExifTagValue.PageName:
-                return new ExifString(ExifTag.PageName);
-            case ExifTagValue.InkNames:
-                return new ExifString(ExifTag.InkNames);
-            case ExifTagValue.TargetPrinter:
-                return new ExifString(ExifTag.TargetPrinter);
-            case ExifTagValue.ImageID:
-                return new ExifString(ExifTag.ImageID);
-            case ExifTagValue.MDLabName:
-                return new ExifString(ExifTag.MDLabName);
-            case ExifTagValue.MDSampleInfo:
-                return new ExifString(ExifTag.MDSampleInfo);
-            case ExifTagValue.MDPrepDate:
-                return new ExifString(ExifTag.MDPrepDate);
-            case ExifTagValue.MDPrepTime:
-                return new ExifString(ExifTag.MDPrepTime);
-            case ExifTagValue.MDFileUnits:
-                return new ExifString(ExifTag.MDFileUnits);
-            case ExifTagValue.SEMInfo:
-                return new ExifString(ExifTag.SEMInfo);
-            case ExifTagValue.SpectralSensitivity:
-                return new ExifString(ExifTag.SpectralSensitivity);
-            case ExifTagValue.DateTimeOriginal:
-                return new ExifString(ExifTag.DateTimeOriginal);
-            case ExifTagValue.DateTimeDigitized:
-                return new ExifString(ExifTag.DateTimeDigitized);
-            case ExifTagValue.SubsecTime:
-                return new ExifString(ExifTag.SubsecTime);
-            case ExifTagValue.SubsecTimeOriginal:
-                return new ExifString(ExifTag.SubsecTimeOriginal);
-            case ExifTagValue.SubsecTimeDigitized:
-                return new ExifString(ExifTag.SubsecTimeDigitized);
-            case ExifTagValue.RelatedSoundFile:
-                return new ExifString(ExifTag.RelatedSoundFile);
-            case ExifTagValue.FaxSubaddress:
-                return new ExifString(ExifTag.FaxSubaddress);
-            case ExifTagValue.OffsetTime:
-                return new ExifString(ExifTag.OffsetTime);
-            case ExifTagValue.OffsetTimeOriginal:
-                return new ExifString(ExifTag.OffsetTimeOriginal);
-            case ExifTagValue.OffsetTimeDigitized:
-                return new ExifString(ExifTag.OffsetTimeDigitized);
-            case ExifTagValue.SecurityClassification:
-                return new ExifString(ExifTag.SecurityClassification);
-            case ExifTagValue.ImageHistory:
-                return new ExifString(ExifTag.ImageHistory);
-            case ExifTagValue.ImageUniqueID:
-                return new ExifString(ExifTag.ImageUniqueID);
-            case ExifTagValue.OwnerName:
-                return new ExifString(ExifTag.OwnerName);
-            case ExifTagValue.SerialNumber:
-                return new ExifString(ExifTag.SerialNumber);
-            case ExifTagValue.LensMake:
-                return new ExifString(ExifTag.LensMake);
-            case ExifTagValue.LensModel:
-                return new ExifString(ExifTag.LensModel);
-            case ExifTagValue.LensSerialNumber:
-                return new ExifString(ExifTag.LensSerialNumber);
-            case ExifTagValue.GDALMetadata:
-                return new ExifString(ExifTag.GDALMetadata);
-            case ExifTagValue.GDALNoData:
-                return new ExifString(ExifTag.GDALNoData);
-            case ExifTagValue.GPSLatitudeRef:
-                return new ExifString(ExifTag.GPSLatitudeRef);
-            case ExifTagValue.GPSLongitudeRef:
-                return new ExifString(ExifTag.GPSLongitudeRef);
-            case ExifTagValue.GPSSatellites:
-                return new ExifString(ExifTag.GPSSatellites);
-            case ExifTagValue.GPSStatus:
-                return new ExifString(ExifTag.GPSStatus);
-            case ExifTagValue.GPSMeasureMode:
-                return new ExifString(ExifTag.GPSMeasureMode);
-            case ExifTagValue.GPSSpeedRef:
-                return new ExifString(ExifTag.GPSSpeedRef);
-            case ExifTagValue.GPSTrackRef:
-                return new ExifString(ExifTag.GPSTrackRef);
-            case ExifTagValue.GPSImgDirectionRef:
-                return new ExifString(ExifTag.GPSImgDirectionRef);
-            case ExifTagValue.GPSMapDatum:
-                return new ExifString(ExifTag.GPSMapDatum);
-            case ExifTagValue.GPSDestLatitudeRef:
-                return new ExifString(ExifTag.GPSDestLatitudeRef);
-            case ExifTagValue.GPSDestLongitudeRef:
-                return new ExifString(ExifTag.GPSDestLongitudeRef);
-            case ExifTagValue.GPSDestBearingRef:
-                return new ExifString(ExifTag.GPSDestBearingRef);
-            case ExifTagValue.GPSDestDistanceRef:
-                return new ExifString(ExifTag.GPSDestDistanceRef);
-            case ExifTagValue.GPSDateStamp:
-                return new ExifString(ExifTag.GPSDateStamp);
-
-            case ExifTagValue.FileSource:
-                return new ExifByte(ExifTag.FileSource, ExifDataType.Undefined);
-            case ExifTagValue.SceneType:
-                return new ExifByte(ExifTag.SceneType, ExifDataType.Undefined);
-
-            case ExifTagValue.JPEGTables:
-                return new ExifByteArray(ExifTag.JPEGTables, ExifDataType.Undefined);
-            case ExifTagValue.OECF:
-                return new ExifByteArray(ExifTag.OECF, ExifDataType.Undefined);
-            case ExifTagValue.ExifVersion:
-                return new ExifByteArray(ExifTag.ExifVersion, ExifDataType.Undefined);
-            case ExifTagValue.ComponentsConfiguration:
-                return new ExifByteArray(ExifTag.ComponentsConfiguration, ExifDataType.Undefined);
-            case ExifTagValue.MakerNote:
-                return new ExifByteArray(ExifTag.MakerNote, ExifDataType.Undefined);
-            case ExifTagValue.FlashpixVersion:
-                return new ExifByteArray(ExifTag.FlashpixVersion, ExifDataType.Undefined);
-            case ExifTagValue.SpatialFrequencyResponse:
-                return new ExifByteArray(ExifTag.SpatialFrequencyResponse, ExifDataType.Undefined);
-            case ExifTagValue.SpatialFrequencyResponse2:
-                return new ExifByteArray(ExifTag.SpatialFrequencyResponse2, ExifDataType.Undefined);
-            case ExifTagValue.Noise:
-                return new ExifByteArray(ExifTag.Noise, ExifDataType.Undefined);
-            case ExifTagValue.CFAPattern:
-                return new ExifByteArray(ExifTag.CFAPattern, ExifDataType.Undefined);
-            case ExifTagValue.DeviceSettingDescription:
-                return new ExifByteArray(ExifTag.DeviceSettingDescription, ExifDataType.Undefined);
-            case ExifTagValue.ImageSourceData:
-                return new ExifByteArray(ExifTag.ImageSourceData, ExifDataType.Undefined);
-
-            case ExifTagValue.XPTitle:
-                return new ExifUcs2String(ExifTag.XPTitle);
-            case ExifTagValue.XPComment:
-                return new ExifUcs2String(ExifTag.XPComment);
-            case ExifTagValue.XPAuthor:
-                return new ExifUcs2String(ExifTag.XPAuthor);
-            case ExifTagValue.XPKeywords:
-                return new ExifUcs2String(ExifTag.XPKeywords);
-            case ExifTagValue.XPSubject:
-                return new ExifUcs2String(ExifTag.XPSubject);
-
-            case ExifTagValue.UserComment:
-                return new ExifEncodedString(ExifTag.UserComment);
-            case ExifTagValue.GPSProcessingMethod:
-                return new ExifEncodedString(ExifTag.GPSProcessingMethod);
-            case ExifTagValue.GPSAreaInformation:
-                return new ExifEncodedString(ExifTag.GPSAreaInformation);
-
-            default:
-                return null;
-        }
-    }
+            ExifTagValue.FaxProfile => new ExifByte(ExifTag.FaxProfile, ExifDataType.Byte),
+            ExifTagValue.ModeNumber => new ExifByte(ExifTag.ModeNumber, ExifDataType.Byte),
+            ExifTagValue.GPSAltitudeRef => new ExifByte(ExifTag.GPSAltitudeRef, ExifDataType.Byte),
+            ExifTagValue.ClipPath => new ExifByteArray(ExifTag.ClipPath, ExifDataType.Byte),
+            ExifTagValue.VersionYear => new ExifByteArray(ExifTag.VersionYear, ExifDataType.Byte),
+            ExifTagValue.XMP => new ExifByteArray(ExifTag.XMP, ExifDataType.Byte),
+            ExifTagValue.CFAPattern2 => new ExifByteArray(ExifTag.CFAPattern2, ExifDataType.Byte),
+            ExifTagValue.TIFFEPStandardID => new ExifByteArray(ExifTag.TIFFEPStandardID, ExifDataType.Byte),
+            ExifTagValue.GPSVersionID => new ExifByteArray(ExifTag.GPSVersionID, ExifDataType.Byte),
+            ExifTagValue.PixelScale => new ExifDoubleArray(ExifTag.PixelScale),
+            ExifTagValue.IntergraphMatrix => new ExifDoubleArray(ExifTag.IntergraphMatrix),
+            ExifTagValue.ModelTiePoint => new ExifDoubleArray(ExifTag.ModelTiePoint),
+            ExifTagValue.ModelTransform => new ExifDoubleArray(ExifTag.ModelTransform),
+            ExifTagValue.SubfileType => new ExifLong(ExifTag.SubfileType),
+            ExifTagValue.SubIFDOffset => new ExifLong(ExifTag.SubIFDOffset),
+            ExifTagValue.GPSIFDOffset => new ExifLong(ExifTag.GPSIFDOffset),
+            ExifTagValue.T4Options => new ExifLong(ExifTag.T4Options),
+            ExifTagValue.T6Options => new ExifLong(ExifTag.T6Options),
+            ExifTagValue.XClipPathUnits => new ExifLong(ExifTag.XClipPathUnits),
+            ExifTagValue.YClipPathUnits => new ExifLong(ExifTag.YClipPathUnits),
+            ExifTagValue.ProfileType => new ExifLong(ExifTag.ProfileType),
+            ExifTagValue.CodingMethods => new ExifLong(ExifTag.CodingMethods),
+            ExifTagValue.T82ptions => new ExifLong(ExifTag.T82ptions),
+            ExifTagValue.JPEGInterchangeFormat => new ExifLong(ExifTag.JPEGInterchangeFormat),
+            ExifTagValue.JPEGInterchangeFormatLength => new ExifLong(ExifTag.JPEGInterchangeFormatLength),
+            ExifTagValue.MDFileTag => new ExifLong(ExifTag.MDFileTag),
+            ExifTagValue.StandardOutputSensitivity => new ExifLong(ExifTag.StandardOutputSensitivity),
+            ExifTagValue.RecommendedExposureIndex => new ExifLong(ExifTag.RecommendedExposureIndex),
+            ExifTagValue.ISOSpeed => new ExifLong(ExifTag.ISOSpeed),
+            ExifTagValue.ISOSpeedLatitudeyyy => new ExifLong(ExifTag.ISOSpeedLatitudeyyy),
+            ExifTagValue.ISOSpeedLatitudezzz => new ExifLong(ExifTag.ISOSpeedLatitudezzz),
+            ExifTagValue.FaxRecvParams => new ExifLong(ExifTag.FaxRecvParams),
+            ExifTagValue.FaxRecvTime => new ExifLong(ExifTag.FaxRecvTime),
+            ExifTagValue.ImageNumber => new ExifLong(ExifTag.ImageNumber),
+            ExifTagValue.FreeOffsets => new ExifLongArray(ExifTag.FreeOffsets),
+            ExifTagValue.FreeByteCounts => new ExifLongArray(ExifTag.FreeByteCounts),
+            ExifTagValue.ColorResponseUnit => new ExifLongArray(ExifTag.ColorResponseUnit),
+            ExifTagValue.SMinSampleValue => new ExifLongArray(ExifTag.SMinSampleValue),
+            ExifTagValue.SMaxSampleValue => new ExifLongArray(ExifTag.SMaxSampleValue),
+            ExifTagValue.JPEGQTables => new ExifLongArray(ExifTag.JPEGQTables),
+            ExifTagValue.JPEGDCTables => new ExifLongArray(ExifTag.JPEGDCTables),
+            ExifTagValue.JPEGACTables => new ExifLongArray(ExifTag.JPEGACTables),
+            ExifTagValue.StripRowCounts => new ExifLongArray(ExifTag.StripRowCounts),
+            ExifTagValue.IntergraphRegisters => new ExifLongArray(ExifTag.IntergraphRegisters),
+            ExifTagValue.SubIFDs => new ExifLongArray(ExifTag.SubIFDs),
+            ExifTagValue.ImageWidth => new ExifNumber(ExifTag.ImageWidth),
+            ExifTagValue.ImageLength => new ExifNumber(ExifTag.ImageLength),
+            ExifTagValue.RowsPerStrip => new ExifNumber(ExifTag.RowsPerStrip),
+            ExifTagValue.TileWidth => new ExifNumber(ExifTag.TileWidth),
+            ExifTagValue.TileLength => new ExifNumber(ExifTag.TileLength),
+            ExifTagValue.BadFaxLines => new ExifNumber(ExifTag.BadFaxLines),
+            ExifTagValue.ConsecutiveBadFaxLines => new ExifNumber(ExifTag.ConsecutiveBadFaxLines),
+            ExifTagValue.PixelXDimension => new ExifNumber(ExifTag.PixelXDimension),
+            ExifTagValue.PixelYDimension => new ExifNumber(ExifTag.PixelYDimension),
+            ExifTagValue.StripByteCounts => new ExifNumberArray(ExifTag.StripByteCounts),
+            ExifTagValue.StripOffsets => new ExifNumberArray(ExifTag.StripOffsets),
+            ExifTagValue.TileByteCounts => new ExifNumberArray(ExifTag.TileByteCounts),
+            ExifTagValue.TileOffsets => new ExifNumberArray(ExifTag.TileOffsets),
+            ExifTagValue.ImageLayer => new ExifNumberArray(ExifTag.ImageLayer),
+            ExifTagValue.XPosition => new ExifRational(ExifTag.XPosition),
+            ExifTagValue.YPosition => new ExifRational(ExifTag.YPosition),
+            ExifTagValue.XResolution => new ExifRational(ExifTag.XResolution),
+            ExifTagValue.YResolution => new ExifRational(ExifTag.YResolution),
+            ExifTagValue.BatteryLevel => new ExifRational(ExifTag.BatteryLevel),
+            ExifTagValue.ExposureTime => new ExifRational(ExifTag.ExposureTime),
+            ExifTagValue.FNumber => new ExifRational(ExifTag.FNumber),
+            ExifTagValue.MDScalePixel => new ExifRational(ExifTag.MDScalePixel),
+            ExifTagValue.CompressedBitsPerPixel => new ExifRational(ExifTag.CompressedBitsPerPixel),
+            ExifTagValue.ApertureValue => new ExifRational(ExifTag.ApertureValue),
+            ExifTagValue.MaxApertureValue => new ExifRational(ExifTag.MaxApertureValue),
+            ExifTagValue.SubjectDistance => new ExifRational(ExifTag.SubjectDistance),
+            ExifTagValue.FocalLength => new ExifRational(ExifTag.FocalLength),
+            ExifTagValue.FlashEnergy2 => new ExifRational(ExifTag.FlashEnergy2),
+            ExifTagValue.FocalPlaneXResolution2 => new ExifRational(ExifTag.FocalPlaneXResolution2),
+            ExifTagValue.FocalPlaneYResolution2 => new ExifRational(ExifTag.FocalPlaneYResolution2),
+            ExifTagValue.ExposureIndex2 => new ExifRational(ExifTag.ExposureIndex2),
+            ExifTagValue.Humidity => new ExifRational(ExifTag.Humidity),
+            ExifTagValue.Pressure => new ExifRational(ExifTag.Pressure),
+            ExifTagValue.Acceleration => new ExifRational(ExifTag.Acceleration),
+            ExifTagValue.FlashEnergy => new ExifRational(ExifTag.FlashEnergy),
+            ExifTagValue.FocalPlaneXResolution => new ExifRational(ExifTag.FocalPlaneXResolution),
+            ExifTagValue.FocalPlaneYResolution => new ExifRational(ExifTag.FocalPlaneYResolution),
+            ExifTagValue.ExposureIndex => new ExifRational(ExifTag.ExposureIndex),
+            ExifTagValue.DigitalZoomRatio => new ExifRational(ExifTag.DigitalZoomRatio),
+            ExifTagValue.GPSAltitude => new ExifRational(ExifTag.GPSAltitude),
+            ExifTagValue.GPSDOP => new ExifRational(ExifTag.GPSDOP),
+            ExifTagValue.GPSSpeed => new ExifRational(ExifTag.GPSSpeed),
+            ExifTagValue.GPSTrack => new ExifRational(ExifTag.GPSTrack),
+            ExifTagValue.GPSImgDirection => new ExifRational(ExifTag.GPSImgDirection),
+            ExifTagValue.GPSDestBearing => new ExifRational(ExifTag.GPSDestBearing),
+            ExifTagValue.GPSDestDistance => new ExifRational(ExifTag.GPSDestDistance),
+            ExifTagValue.GPSHPositioningError => new ExifRational(ExifTag.GPSHPositioningError),
+            ExifTagValue.WhitePoint => new ExifRationalArray(ExifTag.WhitePoint),
+            ExifTagValue.PrimaryChromaticities => new ExifRationalArray(ExifTag.PrimaryChromaticities),
+            ExifTagValue.YCbCrCoefficients => new ExifRationalArray(ExifTag.YCbCrCoefficients),
+            ExifTagValue.ReferenceBlackWhite => new ExifRationalArray(ExifTag.ReferenceBlackWhite),
+            ExifTagValue.GPSLatitude => new ExifRationalArray(ExifTag.GPSLatitude),
+            ExifTagValue.GPSLongitude => new ExifRationalArray(ExifTag.GPSLongitude),
+            ExifTagValue.GPSTimestamp => new ExifRationalArray(ExifTag.GPSTimestamp),
+            ExifTagValue.GPSDestLatitude => new ExifRationalArray(ExifTag.GPSDestLatitude),
+            ExifTagValue.GPSDestLongitude => new ExifRationalArray(ExifTag.GPSDestLongitude),
+            ExifTagValue.LensSpecification => new ExifRationalArray(ExifTag.LensSpecification),
+            ExifTagValue.OldSubfileType => new ExifShort(ExifTag.OldSubfileType),
+            ExifTagValue.Compression => new ExifShort(ExifTag.Compression),
+            ExifTagValue.PhotometricInterpretation => new ExifShort(ExifTag.PhotometricInterpretation),
+            ExifTagValue.Thresholding => new ExifShort(ExifTag.Thresholding),
+            ExifTagValue.CellWidth => new ExifShort(ExifTag.CellWidth),
+            ExifTagValue.CellLength => new ExifShort(ExifTag.CellLength),
+            ExifTagValue.FillOrder => new ExifShort(ExifTag.FillOrder),
+            ExifTagValue.Orientation => new ExifShort(ExifTag.Orientation),
+            ExifTagValue.SamplesPerPixel => new ExifShort(ExifTag.SamplesPerPixel),
+            ExifTagValue.PlanarConfiguration => new ExifShort(ExifTag.PlanarConfiguration),
+            ExifTagValue.Predictor => new ExifShort(ExifTag.Predictor),
+            ExifTagValue.GrayResponseUnit => new ExifShort(ExifTag.GrayResponseUnit),
+            ExifTagValue.ResolutionUnit => new ExifShort(ExifTag.ResolutionUnit),
+            ExifTagValue.CleanFaxData => new ExifShort(ExifTag.CleanFaxData),
+            ExifTagValue.InkSet => new ExifShort(ExifTag.InkSet),
+            ExifTagValue.NumberOfInks => new ExifShort(ExifTag.NumberOfInks),
+            ExifTagValue.DotRange => new ExifShort(ExifTag.DotRange),
+            ExifTagValue.Indexed => new ExifShort(ExifTag.Indexed),
+            ExifTagValue.OPIProxy => new ExifShort(ExifTag.OPIProxy),
+            ExifTagValue.JPEGProc => new ExifShort(ExifTag.JPEGProc),
+            ExifTagValue.JPEGRestartInterval => new ExifShort(ExifTag.JPEGRestartInterval),
+            ExifTagValue.YCbCrPositioning => new ExifShort(ExifTag.YCbCrPositioning),
+            ExifTagValue.Rating => new ExifShort(ExifTag.Rating),
+            ExifTagValue.RatingPercent => new ExifShort(ExifTag.RatingPercent),
+            ExifTagValue.ExposureProgram => new ExifShort(ExifTag.ExposureProgram),
+            ExifTagValue.Interlace => new ExifShort(ExifTag.Interlace),
+            ExifTagValue.SelfTimerMode => new ExifShort(ExifTag.SelfTimerMode),
+            ExifTagValue.SensitivityType => new ExifShort(ExifTag.SensitivityType),
+            ExifTagValue.MeteringMode => new ExifShort(ExifTag.MeteringMode),
+            ExifTagValue.LightSource => new ExifShort(ExifTag.LightSource),
+            ExifTagValue.FocalPlaneResolutionUnit2 => new ExifShort(ExifTag.FocalPlaneResolutionUnit2),
+            ExifTagValue.SensingMethod2 => new ExifShort(ExifTag.SensingMethod2),
+            ExifTagValue.Flash => new ExifShort(ExifTag.Flash),
+            ExifTagValue.ColorSpace => new ExifShort(ExifTag.ColorSpace),
+            ExifTagValue.FocalPlaneResolutionUnit => new ExifShort(ExifTag.FocalPlaneResolutionUnit),
+            ExifTagValue.SensingMethod => new ExifShort(ExifTag.SensingMethod),
+            ExifTagValue.CustomRendered => new ExifShort(ExifTag.CustomRendered),
+            ExifTagValue.ExposureMode => new ExifShort(ExifTag.ExposureMode),
+            ExifTagValue.WhiteBalance => new ExifShort(ExifTag.WhiteBalance),
+            ExifTagValue.FocalLengthIn35mmFilm => new ExifShort(ExifTag.FocalLengthIn35mmFilm),
+            ExifTagValue.SceneCaptureType => new ExifShort(ExifTag.SceneCaptureType),
+            ExifTagValue.GainControl => new ExifShort(ExifTag.GainControl),
+            ExifTagValue.Contrast => new ExifShort(ExifTag.Contrast),
+            ExifTagValue.Saturation => new ExifShort(ExifTag.Saturation),
+            ExifTagValue.Sharpness => new ExifShort(ExifTag.Sharpness),
+            ExifTagValue.SubjectDistanceRange => new ExifShort(ExifTag.SubjectDistanceRange),
+            ExifTagValue.GPSDifferential => new ExifShort(ExifTag.GPSDifferential),
+            ExifTagValue.BitsPerSample => new ExifShortArray(ExifTag.BitsPerSample),
+            ExifTagValue.MinSampleValue => new ExifShortArray(ExifTag.MinSampleValue),
+            ExifTagValue.MaxSampleValue => new ExifShortArray(ExifTag.MaxSampleValue),
+            ExifTagValue.GrayResponseCurve => new ExifShortArray(ExifTag.GrayResponseCurve),
+            ExifTagValue.ColorMap => new ExifShortArray(ExifTag.ColorMap),
+            ExifTagValue.ExtraSamples => new ExifShortArray(ExifTag.ExtraSamples),
+            ExifTagValue.PageNumber => new ExifShortArray(ExifTag.PageNumber),
+            ExifTagValue.TransferFunction => new ExifShortArray(ExifTag.TransferFunction),
+            ExifTagValue.HalftoneHints => new ExifShortArray(ExifTag.HalftoneHints),
+            ExifTagValue.SampleFormat => new ExifShortArray(ExifTag.SampleFormat),
+            ExifTagValue.TransferRange => new ExifShortArray(ExifTag.TransferRange),
+            ExifTagValue.DefaultImageColor => new ExifShortArray(ExifTag.DefaultImageColor),
+            ExifTagValue.JPEGLosslessPredictors => new ExifShortArray(ExifTag.JPEGLosslessPredictors),
+            ExifTagValue.JPEGPointTransforms => new ExifShortArray(ExifTag.JPEGPointTransforms),
+            ExifTagValue.YCbCrSubsampling => new ExifShortArray(ExifTag.YCbCrSubsampling),
+            ExifTagValue.CFARepeatPatternDim => new ExifShortArray(ExifTag.CFARepeatPatternDim),
+            ExifTagValue.IntergraphPacketData => new ExifShortArray(ExifTag.IntergraphPacketData),
+            ExifTagValue.ISOSpeedRatings => new ExifShortArray(ExifTag.ISOSpeedRatings),
+            ExifTagValue.SubjectArea => new ExifShortArray(ExifTag.SubjectArea),
+            ExifTagValue.SubjectLocation => new ExifShortArray(ExifTag.SubjectLocation),
+            ExifTagValue.ShutterSpeedValue => new ExifSignedRational(ExifTag.ShutterSpeedValue),
+            ExifTagValue.BrightnessValue => new ExifSignedRational(ExifTag.BrightnessValue),
+            ExifTagValue.ExposureBiasValue => new ExifSignedRational(ExifTag.ExposureBiasValue),
+            ExifTagValue.AmbientTemperature => new ExifSignedRational(ExifTag.AmbientTemperature),
+            ExifTagValue.WaterDepth => new ExifSignedRational(ExifTag.WaterDepth),
+            ExifTagValue.CameraElevationAngle => new ExifSignedRational(ExifTag.CameraElevationAngle),
+            ExifTagValue.Decode => new ExifSignedRationalArray(ExifTag.Decode),
+            ExifTagValue.TimeZoneOffset => new ExifSignedShortArray(ExifTag.TimeZoneOffset),
+            ExifTagValue.ImageDescription => new ExifString(ExifTag.ImageDescription),
+            ExifTagValue.Make => new ExifString(ExifTag.Make),
+            ExifTagValue.Model => new ExifString(ExifTag.Model),
+            ExifTagValue.Software => new ExifString(ExifTag.Software),
+            ExifTagValue.DateTime => new ExifString(ExifTag.DateTime),
+            ExifTagValue.Artist => new ExifString(ExifTag.Artist),
+            ExifTagValue.HostComputer => new ExifString(ExifTag.HostComputer),
+            ExifTagValue.Copyright => new ExifString(ExifTag.Copyright),
+            ExifTagValue.DocumentName => new ExifString(ExifTag.DocumentName),
+            ExifTagValue.PageName => new ExifString(ExifTag.PageName),
+            ExifTagValue.InkNames => new ExifString(ExifTag.InkNames),
+            ExifTagValue.TargetPrinter => new ExifString(ExifTag.TargetPrinter),
+            ExifTagValue.ImageID => new ExifString(ExifTag.ImageID),
+            ExifTagValue.MDLabName => new ExifString(ExifTag.MDLabName),
+            ExifTagValue.MDSampleInfo => new ExifString(ExifTag.MDSampleInfo),
+            ExifTagValue.MDPrepDate => new ExifString(ExifTag.MDPrepDate),
+            ExifTagValue.MDPrepTime => new ExifString(ExifTag.MDPrepTime),
+            ExifTagValue.MDFileUnits => new ExifString(ExifTag.MDFileUnits),
+            ExifTagValue.SEMInfo => new ExifString(ExifTag.SEMInfo),
+            ExifTagValue.SpectralSensitivity => new ExifString(ExifTag.SpectralSensitivity),
+            ExifTagValue.DateTimeOriginal => new ExifString(ExifTag.DateTimeOriginal),
+            ExifTagValue.DateTimeDigitized => new ExifString(ExifTag.DateTimeDigitized),
+            ExifTagValue.SubsecTime => new ExifString(ExifTag.SubsecTime),
+            ExifTagValue.SubsecTimeOriginal => new ExifString(ExifTag.SubsecTimeOriginal),
+            ExifTagValue.SubsecTimeDigitized => new ExifString(ExifTag.SubsecTimeDigitized),
+            ExifTagValue.RelatedSoundFile => new ExifString(ExifTag.RelatedSoundFile),
+            ExifTagValue.FaxSubaddress => new ExifString(ExifTag.FaxSubaddress),
+            ExifTagValue.OffsetTime => new ExifString(ExifTag.OffsetTime),
+            ExifTagValue.OffsetTimeOriginal => new ExifString(ExifTag.OffsetTimeOriginal),
+            ExifTagValue.OffsetTimeDigitized => new ExifString(ExifTag.OffsetTimeDigitized),
+            ExifTagValue.SecurityClassification => new ExifString(ExifTag.SecurityClassification),
+            ExifTagValue.ImageHistory => new ExifString(ExifTag.ImageHistory),
+            ExifTagValue.ImageUniqueID => new ExifString(ExifTag.ImageUniqueID),
+            ExifTagValue.OwnerName => new ExifString(ExifTag.OwnerName),
+            ExifTagValue.SerialNumber => new ExifString(ExifTag.SerialNumber),
+            ExifTagValue.LensMake => new ExifString(ExifTag.LensMake),
+            ExifTagValue.LensModel => new ExifString(ExifTag.LensModel),
+            ExifTagValue.LensSerialNumber => new ExifString(ExifTag.LensSerialNumber),
+            ExifTagValue.GDALMetadata => new ExifString(ExifTag.GDALMetadata),
+            ExifTagValue.GDALNoData => new ExifString(ExifTag.GDALNoData),
+            ExifTagValue.GPSLatitudeRef => new ExifString(ExifTag.GPSLatitudeRef),
+            ExifTagValue.GPSLongitudeRef => new ExifString(ExifTag.GPSLongitudeRef),
+            ExifTagValue.GPSSatellites => new ExifString(ExifTag.GPSSatellites),
+            ExifTagValue.GPSStatus => new ExifString(ExifTag.GPSStatus),
+            ExifTagValue.GPSMeasureMode => new ExifString(ExifTag.GPSMeasureMode),
+            ExifTagValue.GPSSpeedRef => new ExifString(ExifTag.GPSSpeedRef),
+            ExifTagValue.GPSTrackRef => new ExifString(ExifTag.GPSTrackRef),
+            ExifTagValue.GPSImgDirectionRef => new ExifString(ExifTag.GPSImgDirectionRef),
+            ExifTagValue.GPSMapDatum => new ExifString(ExifTag.GPSMapDatum),
+            ExifTagValue.GPSDestLatitudeRef => new ExifString(ExifTag.GPSDestLatitudeRef),
+            ExifTagValue.GPSDestLongitudeRef => new ExifString(ExifTag.GPSDestLongitudeRef),
+            ExifTagValue.GPSDestBearingRef => new ExifString(ExifTag.GPSDestBearingRef),
+            ExifTagValue.GPSDestDistanceRef => new ExifString(ExifTag.GPSDestDistanceRef),
+            ExifTagValue.GPSDateStamp => new ExifString(ExifTag.GPSDateStamp),
+            ExifTagValue.FileSource => new ExifByte(ExifTag.FileSource, ExifDataType.Undefined),
+            ExifTagValue.SceneType => new ExifByte(ExifTag.SceneType, ExifDataType.Undefined),
+            ExifTagValue.JPEGTables => new ExifByteArray(ExifTag.JPEGTables, ExifDataType.Undefined),
+            ExifTagValue.OECF => new ExifByteArray(ExifTag.OECF, ExifDataType.Undefined),
+            ExifTagValue.ExifVersion => new ExifByteArray(ExifTag.ExifVersion, ExifDataType.Undefined),
+            ExifTagValue.ComponentsConfiguration => new ExifByteArray(ExifTag.ComponentsConfiguration, ExifDataType.Undefined),
+            ExifTagValue.MakerNote => new ExifByteArray(ExifTag.MakerNote, ExifDataType.Undefined),
+            ExifTagValue.FlashpixVersion => new ExifByteArray(ExifTag.FlashpixVersion, ExifDataType.Undefined),
+            ExifTagValue.SpatialFrequencyResponse => new ExifByteArray(ExifTag.SpatialFrequencyResponse, ExifDataType.Undefined),
+            ExifTagValue.SpatialFrequencyResponse2 => new ExifByteArray(ExifTag.SpatialFrequencyResponse2, ExifDataType.Undefined),
+            ExifTagValue.Noise => new ExifByteArray(ExifTag.Noise, ExifDataType.Undefined),
+            ExifTagValue.CFAPattern => new ExifByteArray(ExifTag.CFAPattern, ExifDataType.Undefined),
+            ExifTagValue.DeviceSettingDescription => new ExifByteArray(ExifTag.DeviceSettingDescription, ExifDataType.Undefined),
+            ExifTagValue.ImageSourceData => new ExifByteArray(ExifTag.ImageSourceData, ExifDataType.Undefined),
+            ExifTagValue.XPTitle => new ExifUcs2String(ExifTag.XPTitle),
+            ExifTagValue.XPComment => new ExifUcs2String(ExifTag.XPComment),
+            ExifTagValue.XPAuthor => new ExifUcs2String(ExifTag.XPAuthor),
+            ExifTagValue.XPKeywords => new ExifUcs2String(ExifTag.XPKeywords),
+            ExifTagValue.XPSubject => new ExifUcs2String(ExifTag.XPSubject),
+            ExifTagValue.UserComment => new ExifEncodedString(ExifTag.UserComment),
+            ExifTagValue.GPSProcessingMethod => new ExifEncodedString(ExifTag.GPSProcessingMethod),
+            ExifTagValue.GPSAreaInformation => new ExifEncodedString(ExifTag.GPSAreaInformation),
+            _ => null,
+        };
 }
diff --git a/src/ImageSharp/Metadata/Profiles/Exif/Values/IExifValue.cs b/src/ImageSharp/Metadata/Profiles/Exif/Values/IExifValue.cs
index c5b1574f30..3bb5551920 100644
--- a/src/ImageSharp/Metadata/Profiles/Exif/Values/IExifValue.cs
+++ b/src/ImageSharp/Metadata/Profiles/Exif/Values/IExifValue.cs
@@ -4,35 +4,35 @@
 namespace SixLabors.ImageSharp.Metadata.Profiles.Exif;
 
 /// <summary>
-/// A value of the exif profile.
+/// A value of the Exif profile.
 /// </summary>
 public interface IExifValue : IDeepCloneable<IExifValue>
 {
     /// <summary>
-    /// Gets the data type of the exif value.
+    /// Gets the data type of the Exif value.
     /// </summary>
-    ExifDataType DataType { get; }
+    public ExifDataType DataType { get; }
 
     /// <summary>
     /// Gets a value indicating whether the value is an array.
     /// </summary>
-    bool IsArray { get; }
+    public bool IsArray { get; }
 
     /// <summary>
-    /// Gets the tag of the exif value.
+    /// Gets the tag of the Exif value.
     /// </summary>
-    ExifTag Tag { get; }
+    public ExifTag Tag { get; }
 
     /// <summary>
-    /// Gets the value of this exif value.
+    /// Gets the value of this Exif value.
     /// </summary>
-    /// <returns>The value of this exif value.</returns>
-    object? GetValue();
+    /// <returns>The value of this Exif value.</returns>
+    public object? GetValue();
 
     /// <summary>
-    /// Sets the value of this exif value.
+    /// Sets the value of this Exif value.
     /// </summary>
-    /// <param name="value">The value of this exif value.</param>
+    /// <param name="value">The value of this Exif value.</param>
     /// <returns>A value indicating whether the value could be set.</returns>
-    bool TrySetValue(object? value);
+    public bool TrySetValue(object? value);
 }
diff --git a/src/ImageSharp/Metadata/Profiles/ICC/DataReader/IccDataReader.Curves.cs b/src/ImageSharp/Metadata/Profiles/ICC/DataReader/IccDataReader.Curves.cs
index 3cf66c0c16..8663ebccc2 100644
--- a/src/ImageSharp/Metadata/Profiles/ICC/DataReader/IccDataReader.Curves.cs
+++ b/src/ImageSharp/Metadata/Profiles/ICC/DataReader/IccDataReader.Curves.cs
@@ -18,13 +18,13 @@ internal sealed partial class IccDataReader
     {
         ushort segmentCount = this.ReadUInt16();
         this.AddIndex(2);   // 2 bytes reserved
-        var breakPoints = new float[segmentCount - 1];
+        float[] breakPoints = new float[segmentCount - 1];
         for (int i = 0; i < breakPoints.Length; i++)
         {
             breakPoints[i] = this.ReadSingle();
         }
 
-        var segments = new IccCurveSegment[segmentCount];
+        IccCurveSegment[] segments = new IccCurveSegment[segmentCount];
         for (int i = 0; i < segmentCount; i++)
         {
             segments[i] = this.ReadCurveSegment();
@@ -40,20 +40,20 @@ internal sealed partial class IccDataReader
     /// <returns>The read curve</returns>
     public IccResponseCurve ReadResponseCurve(int channelCount)
     {
-        var type = (IccCurveMeasurementEncodings)this.ReadUInt32();
-        var measurement = new uint[channelCount];
+        IccCurveMeasurementEncodings type = (IccCurveMeasurementEncodings)this.ReadUInt32();
+        uint[] measurement = new uint[channelCount];
         for (int i = 0; i < channelCount; i++)
         {
             measurement[i] = this.ReadUInt32();
         }
 
-        var xyzValues = new Vector3[channelCount];
+        Vector3[] xyzValues = new Vector3[channelCount];
         for (int i = 0; i < channelCount; i++)
         {
             xyzValues[i] = this.ReadXyzNumber();
         }
 
-        var response = new IccResponseNumber[channelCount][];
+        IccResponseNumber[][] response = new IccResponseNumber[channelCount][];
         for (int i = 0; i < channelCount; i++)
         {
             response[i] = new IccResponseNumber[measurement[i]];
@@ -121,7 +121,7 @@ internal sealed partial class IccDataReader
     /// <returns>The read segment</returns>
     public IccCurveSegment ReadCurveSegment()
     {
-        var signature = (IccCurveSegmentSignature)this.ReadUInt32();
+        IccCurveSegmentSignature signature = (IccCurveSegmentSignature)this.ReadUInt32();
         this.AddIndex(4);   // 4 bytes reserved
 
         switch (signature)
@@ -141,7 +141,7 @@ internal sealed partial class IccDataReader
     /// <returns>The read segment</returns>
     public IccFormulaCurveElement ReadFormulaCurveElement()
     {
-        var type = (IccFormulaCurveType)this.ReadUInt16();
+        IccFormulaCurveType type = (IccFormulaCurveType)this.ReadUInt16();
         this.AddIndex(2);   // 2 bytes reserved
         float gamma, a, b, c, d, e;
         gamma = d = e = 0;
@@ -175,7 +175,7 @@ internal sealed partial class IccDataReader
     public IccSampledCurveElement ReadSampledCurveElement()
     {
         uint count = this.ReadUInt32();
-        var entries = new float[count];
+        float[] entries = new float[count];
         for (int i = 0; i < count; i++)
         {
             entries[i] = this.ReadSingle();
@@ -191,7 +191,7 @@ internal sealed partial class IccDataReader
     /// <returns>The curve data</returns>
     private IccTagDataEntry[] ReadCurves(int count)
     {
-        var tdata = new IccTagDataEntry[count];
+        IccTagDataEntry[] tdata = new IccTagDataEntry[count];
         for (int i = 0; i < count; i++)
         {
             IccTypeSignature type = this.ReadTagDataEntryHeader();
diff --git a/src/ImageSharp/Metadata/Profiles/ICC/DataReader/IccDataReader.Lut.cs b/src/ImageSharp/Metadata/Profiles/ICC/DataReader/IccDataReader.Lut.cs
index e88dd8d9e1..700e43f972 100644
--- a/src/ImageSharp/Metadata/Profiles/ICC/DataReader/IccDataReader.Lut.cs
+++ b/src/ImageSharp/Metadata/Profiles/ICC/DataReader/IccDataReader.Lut.cs
@@ -4,27 +4,24 @@
 namespace SixLabors.ImageSharp.Metadata.Profiles.Icc;
 
 /// <summary>
-/// Provides methods to read ICC data types
+/// Provides methods to read ICC data types.
 /// </summary>
 internal sealed partial class IccDataReader
 {
     /// <summary>
-    /// Reads an 8bit lookup table
+    /// Reads an 8bit lookup table.
     /// </summary>
-    /// <returns>The read LUT</returns>
-    public IccLut ReadLut8()
-    {
-        return new IccLut(this.ReadBytes(256));
-    }
+    /// <returns>The read LUT.</returns>
+    public IccLut ReadLut8() => new(this.ReadBytes(256));
 
     /// <summary>
-    /// Reads a 16bit lookup table
+    /// Reads a 16bit lookup table.
     /// </summary>
-    /// <param name="count">The number of entries</param>
-    /// <returns>The read LUT</returns>
+    /// <param name="count">The number of entries.</param>
+    /// <returns>The read LUT.</returns>
     public IccLut ReadLut16(int count)
     {
-        var values = new ushort[count];
+        ushort[] values = new ushort[count];
         for (int i = 0; i < count; i++)
         {
             values[i] = this.ReadUInt16();
@@ -34,17 +31,17 @@ internal sealed partial class IccDataReader
     }
 
     /// <summary>
-    /// Reads a CLUT depending on type
+    /// Reads a CLUT depending on type.
     /// </summary>
-    /// <param name="inChannelCount">Input channel count</param>
-    /// <param name="outChannelCount">Output channel count</param>
+    /// <param name="inChannelCount">Input channel count.</param>
+    /// <param name="outChannelCount">Output channel count.</param>
     /// <param name="isFloat">If true, it's read as CLUTf32,
-    /// else read as either CLUT8 or CLUT16 depending on embedded information</param>
-    /// <returns>The read CLUT</returns>
+    /// else read as either CLUT8 or CLUT16 depending on embedded information.</param>
+    /// <returns>The read CLUT.</returns>
     public IccClut ReadClut(int inChannelCount, int outChannelCount, bool isFloat)
     {
-        // Grid-points are always 16 bytes long but only 0-inChCount are used
-        var gridPointCount = new byte[inChannelCount];
+        // Grid-points are always 16 bytes long but only 0-inChCount are used.
+        byte[] gridPointCount = new byte[inChannelCount];
         Buffer.BlockCopy(this.data, this.AddIndex(16), gridPointCount, 0, inChannelCount);
 
         if (!isFloat)
@@ -67,15 +64,14 @@ internal sealed partial class IccDataReader
     }
 
     /// <summary>
-    /// Reads an 8 bit CLUT
+    /// Reads an 8 bit CLUT.
     /// </summary>
-    /// <param name="inChannelCount">Input channel count</param>
-    /// <param name="outChannelCount">Output channel count</param>
-    /// <param name="gridPointCount">Grid point count for each CLUT channel</param>
-    /// <returns>The read CLUT8</returns>
+    /// <param name="inChannelCount">Input channel count.</param>
+    /// <param name="outChannelCount">Output channel count.</param>
+    /// <param name="gridPointCount">Grid point count for each CLUT channel.</param>
+    /// <returns>The read CLUT8.</returns>
     public IccClut ReadClut8(int inChannelCount, int outChannelCount, byte[] gridPointCount)
     {
-        int start = this.currentIndex;
         int length = 0;
         for (int i = 0; i < inChannelCount; i++)
         {
@@ -86,27 +82,26 @@ internal sealed partial class IccDataReader
 
         const float Max = byte.MaxValue;
 
-        var values = new float[length][];
+        float[] values = new float[length * outChannelCount];
+        int offset = 0;
         for (int i = 0; i < length; i++)
         {
-            values[i] = new float[outChannelCount];
             for (int j = 0; j < outChannelCount; j++)
             {
-                values[i][j] = this.data[this.currentIndex++] / Max;
+                values[offset++] = this.data[this.currentIndex++] / Max;
             }
         }
 
-        this.currentIndex = start + (length * outChannelCount);
-        return new IccClut(values, gridPointCount, IccClutDataType.UInt8);
+        return new IccClut(values, gridPointCount, IccClutDataType.UInt8, outChannelCount);
     }
 
     /// <summary>
-    /// Reads a 16 bit CLUT
+    /// Reads a 16 bit CLUT.
     /// </summary>
-    /// <param name="inChannelCount">Input channel count</param>
-    /// <param name="outChannelCount">Output channel count</param>
-    /// <param name="gridPointCount">Grid point count for each CLUT channel</param>
-    /// <returns>The read CLUT16</returns>
+    /// <param name="inChannelCount">Input channel count.</param>
+    /// <param name="outChannelCount">Output channel count.</param>
+    /// <param name="gridPointCount">Grid point count for each CLUT channel.</param>
+    /// <returns>The read CLUT16.</returns>
     public IccClut ReadClut16(int inChannelCount, int outChannelCount, byte[] gridPointCount)
     {
         int start = this.currentIndex;
@@ -120,27 +115,27 @@ internal sealed partial class IccDataReader
 
         const float Max = ushort.MaxValue;
 
-        var values = new float[length][];
+        float[] values = new float[length * outChannelCount];
+        int offset = 0;
         for (int i = 0; i < length; i++)
         {
-            values[i] = new float[outChannelCount];
             for (int j = 0; j < outChannelCount; j++)
             {
-                values[i][j] = this.ReadUInt16() / Max;
+                values[offset++] = this.ReadUInt16() / Max;
             }
         }
 
         this.currentIndex = start + (length * outChannelCount * 2);
-        return new IccClut(values, gridPointCount, IccClutDataType.UInt16);
+        return new IccClut(values, gridPointCount, IccClutDataType.UInt16, outChannelCount);
     }
 
     /// <summary>
-    /// Reads a 32bit floating point CLUT
+    /// Reads a 32bit floating point CLUT.
     /// </summary>
-    /// <param name="inChCount">Input channel count</param>
-    /// <param name="outChCount">Output channel count</param>
-    /// <param name="gridPointCount">Grid point count for each CLUT channel</param>
-    /// <returns>The read CLUTf32</returns>
+    /// <param name="inChCount">Input channel count.</param>
+    /// <param name="outChCount">Output channel count.</param>
+    /// <param name="gridPointCount">Grid point count for each CLUT channel.</param>
+    /// <returns>The read CLUTf32.</returns>
     public IccClut ReadClutF32(int inChCount, int outChCount, byte[] gridPointCount)
     {
         int start = this.currentIndex;
@@ -152,17 +147,17 @@ internal sealed partial class IccDataReader
 
         length /= inChCount;
 
-        var values = new float[length][];
+        float[] values = new float[length * outChCount];
+        int offset = 0;
         for (int i = 0; i < length; i++)
         {
-            values[i] = new float[outChCount];
             for (int j = 0; j < outChCount; j++)
             {
-                values[i][j] = this.ReadSingle();
+                values[offset++] = this.ReadSingle();
             }
         }
 
         this.currentIndex = start + (length * outChCount * 4);
-        return new IccClut(values, gridPointCount, IccClutDataType.Float);
+        return new IccClut(values, gridPointCount, IccClutDataType.Float, outChCount);
     }
 }
diff --git a/src/ImageSharp/Metadata/Profiles/ICC/DataReader/IccDataReader.Matrix.cs b/src/ImageSharp/Metadata/Profiles/ICC/DataReader/IccDataReader.Matrix.cs
index 61ecda4aab..ecc9bfbffb 100644
--- a/src/ImageSharp/Metadata/Profiles/ICC/DataReader/IccDataReader.Matrix.cs
+++ b/src/ImageSharp/Metadata/Profiles/ICC/DataReader/IccDataReader.Matrix.cs
@@ -17,16 +17,23 @@ internal sealed partial class IccDataReader
     /// <returns>The read matrix</returns>
     public float[,] ReadMatrix(int xCount, int yCount, bool isSingle)
     {
-        var matrix = new float[xCount, yCount];
-        for (int y = 0; y < yCount; y++)
+        float[,] matrix = new float[xCount, yCount];
+
+        if (isSingle)
         {
-            for (int x = 0; x < xCount; x++)
+            for (int y = 0; y < yCount; y++)
             {
-                if (isSingle)
+                for (int x = 0; x < xCount; x++)
                 {
                     matrix[x, y] = this.ReadSingle();
                 }
-                else
+            }
+        }
+        else
+        {
+            for (int y = 0; y < yCount; y++)
+            {
+                for (int x = 0; x < xCount; x++)
                 {
                     matrix[x, y] = this.ReadFix16();
                 }
@@ -44,14 +51,17 @@ internal sealed partial class IccDataReader
     /// <returns>The read matrix</returns>
     public float[] ReadMatrix(int yCount, bool isSingle)
     {
-        var matrix = new float[yCount];
-        for (int i = 0; i < yCount; i++)
+        float[] matrix = new float[yCount];
+        if (isSingle)
         {
-            if (isSingle)
+            for (int i = 0; i < yCount; i++)
             {
                 matrix[i] = this.ReadSingle();
             }
-            else
+        }
+        else
+        {
+            for (int i = 0; i < yCount; i++)
             {
                 matrix[i] = this.ReadFix16();
             }
diff --git a/src/ImageSharp/Metadata/Profiles/ICC/DataReader/IccDataReader.MultiProcessElement.cs b/src/ImageSharp/Metadata/Profiles/ICC/DataReader/IccDataReader.MultiProcessElement.cs
index 5baa904048..98b269f0bf 100644
--- a/src/ImageSharp/Metadata/Profiles/ICC/DataReader/IccDataReader.MultiProcessElement.cs
+++ b/src/ImageSharp/Metadata/Profiles/ICC/DataReader/IccDataReader.MultiProcessElement.cs
@@ -48,7 +48,7 @@ internal sealed partial class IccDataReader
     /// <returns>The read <see cref="IccCurveSetProcessElement"/></returns>
     public IccCurveSetProcessElement ReadCurveSetProcessElement(int inChannelCount, int outChannelCount)
     {
-        var curves = new IccOneDimensionalCurve[inChannelCount];
+        IccOneDimensionalCurve[] curves = new IccOneDimensionalCurve[inChannelCount];
         for (int i = 0; i < inChannelCount; i++)
         {
             curves[i] = this.ReadOneDimensionalCurve();
diff --git a/src/ImageSharp/Metadata/Profiles/ICC/DataReader/IccDataReader.NonPrimitives.cs b/src/ImageSharp/Metadata/Profiles/ICC/DataReader/IccDataReader.NonPrimitives.cs
index d5369e5fc4..219e785590 100644
--- a/src/ImageSharp/Metadata/Profiles/ICC/DataReader/IccDataReader.NonPrimitives.cs
+++ b/src/ImageSharp/Metadata/Profiles/ICC/DataReader/IccDataReader.NonPrimitives.cs
@@ -103,8 +103,8 @@ internal sealed partial class IccDataReader
     public IccNamedColor ReadNamedColor(uint deviceCoordCount)
     {
         string name = this.ReadAsciiString(32);
-        ushort[] pcsCoord = { this.ReadUInt16(), this.ReadUInt16(), this.ReadUInt16() };
-        var deviceCoord = new ushort[deviceCoordCount];
+        ushort[] pcsCoord = [this.ReadUInt16(), this.ReadUInt16(), this.ReadUInt16()];
+        ushort[] deviceCoord = new ushort[deviceCoordCount];
 
         for (int i = 0; i < deviceCoordCount; i++)
         {
@@ -122,8 +122,8 @@ internal sealed partial class IccDataReader
     {
         uint manufacturer = this.ReadUInt32();
         uint model = this.ReadUInt32();
-        var attributes = (IccDeviceAttribute)this.ReadInt64();
-        var technologyInfo = (IccProfileTag)this.ReadUInt32();
+        IccDeviceAttribute attributes = (IccDeviceAttribute)this.ReadInt64();
+        IccProfileTag technologyInfo = (IccProfileTag)this.ReadUInt32();
 
         IccMultiLocalizedUnicodeTagDataEntry manufacturerInfo = ReadText();
         IccMultiLocalizedUnicodeTagDataEntry modelInfo = ReadText();
diff --git a/src/ImageSharp/Metadata/Profiles/ICC/DataReader/IccDataReader.Primitives.cs b/src/ImageSharp/Metadata/Profiles/ICC/DataReader/IccDataReader.Primitives.cs
index 47d946d443..99dc3ce3c2 100644
--- a/src/ImageSharp/Metadata/Profiles/ICC/DataReader/IccDataReader.Primitives.cs
+++ b/src/ImageSharp/Metadata/Profiles/ICC/DataReader/IccDataReader.Primitives.cs
@@ -16,55 +16,37 @@ internal sealed partial class IccDataReader
     /// Reads an ushort
     /// </summary>
     /// <returns>the value</returns>
-    public ushort ReadUInt16()
-    {
-        return BinaryPrimitives.ReadUInt16BigEndian(this.data.AsSpan(this.AddIndex(2), 2));
-    }
+    public ushort ReadUInt16() => BinaryPrimitives.ReadUInt16BigEndian(this.data.AsSpan(this.AddIndex(2), 2));
 
     /// <summary>
     /// Reads a short
     /// </summary>
     /// <returns>the value</returns>
-    public short ReadInt16()
-    {
-        return BinaryPrimitives.ReadInt16BigEndian(this.data.AsSpan(this.AddIndex(2), 2));
-    }
+    public short ReadInt16() => BinaryPrimitives.ReadInt16BigEndian(this.data.AsSpan(this.AddIndex(2), 2));
 
     /// <summary>
     /// Reads an uint
     /// </summary>
     /// <returns>the value</returns>
-    public uint ReadUInt32()
-    {
-        return BinaryPrimitives.ReadUInt32BigEndian(this.data.AsSpan(this.AddIndex(4), 4));
-    }
+    public uint ReadUInt32() => BinaryPrimitives.ReadUInt32BigEndian(this.data.AsSpan(this.AddIndex(4), 4));
 
     /// <summary>
     /// Reads an int
     /// </summary>
     /// <returns>the value</returns>
-    public int ReadInt32()
-    {
-        return BinaryPrimitives.ReadInt32BigEndian(this.data.AsSpan(this.AddIndex(4), 4));
-    }
+    public int ReadInt32() => BinaryPrimitives.ReadInt32BigEndian(this.data.AsSpan(this.AddIndex(4), 4));
 
     /// <summary>
     /// Reads an ulong
     /// </summary>
     /// <returns>the value</returns>
-    public ulong ReadUInt64()
-    {
-        return BinaryPrimitives.ReadUInt64BigEndian(this.data.AsSpan(this.AddIndex(8), 8));
-    }
+    public ulong ReadUInt64() => BinaryPrimitives.ReadUInt64BigEndian(this.data.AsSpan(this.AddIndex(8), 8));
 
     /// <summary>
     /// Reads a long
     /// </summary>
     /// <returns>the value</returns>
-    public long ReadInt64()
-    {
-        return BinaryPrimitives.ReadInt64BigEndian(this.data.AsSpan(this.AddIndex(8), 8));
-    }
+    public long ReadInt64() => BinaryPrimitives.ReadInt64BigEndian(this.data.AsSpan(this.AddIndex(8), 8));
 
     /// <summary>
     /// Reads a float.
@@ -152,10 +134,7 @@ internal sealed partial class IccDataReader
     /// Reads an unsigned 16bit number with 8 value bits and 8 fractional bits.
     /// </summary>
     /// <returns>The number as double</returns>
-    public float ReadUFix8()
-    {
-        return this.ReadUInt16() / 256f;
-    }
+    public float ReadUFix8() => this.ReadUInt16() / 256f;
 
     /// <summary>
     /// Reads a number of bytes and advances the index.
@@ -164,7 +143,7 @@ internal sealed partial class IccDataReader
     /// <returns>The read bytes</returns>
     public byte[] ReadBytes(int count)
     {
-        var bytes = new byte[count];
+        byte[] bytes = new byte[count];
         Buffer.BlockCopy(this.data, this.AddIndex(count), bytes, 0, count);
         return bytes;
     }
diff --git a/src/ImageSharp/Metadata/Profiles/ICC/DataReader/IccDataReader.TagDataEntry.cs b/src/ImageSharp/Metadata/Profiles/ICC/DataReader/IccDataReader.TagDataEntry.cs
index ddfc625152..9e89d24ff4 100644
--- a/src/ImageSharp/Metadata/Profiles/ICC/DataReader/IccDataReader.TagDataEntry.cs
+++ b/src/ImageSharp/Metadata/Profiles/ICC/DataReader/IccDataReader.TagDataEntry.cs
@@ -8,21 +8,19 @@ using System.Numerics;
 namespace SixLabors.ImageSharp.Metadata.Profiles.Icc;
 
 /// <summary>
-/// Provides methods to read ICC data types
+/// Provides methods to read ICC data types.
 /// </summary>
 internal sealed partial class IccDataReader
 {
     /// <summary>
-    /// Reads a tag data entry
+    /// Reads a tag data entry.
     /// </summary>
-    /// <param name="info">The table entry with reading information</param>
-    /// <returns>the tag data entry</returns>
+    /// <param name="info">The table entry with reading information.</param>
+    /// <returns>The tag data entry.</returns>
     public IccTagDataEntry ReadTagDataEntry(IccTagTableEntry info)
     {
         this.currentIndex = (int)info.Offset;
-        IccTypeSignature type = this.ReadTagDataEntryHeader();
-
-        switch (type)
+        switch (this.ReadTagDataEntryHeader())
         {
             case IccTypeSignature.Chromaticity:
                 return this.ReadChromaticityTagDataEntry();
@@ -103,10 +101,10 @@ internal sealed partial class IccDataReader
     /// <summary>
     /// Reads the header of a <see cref="IccTagDataEntry"/>
     /// </summary>
-    /// <returns>The read signature</returns>
+    /// <returns>The read signature.</returns>
     public IccTypeSignature ReadTagDataEntryHeader()
     {
-        var type = (IccTypeSignature)this.ReadUInt32();
+        IccTypeSignature type = (IccTypeSignature)this.ReadUInt32();
         this.AddIndex(4); // 4 bytes are not used
         return type;
     }
@@ -114,7 +112,7 @@ internal sealed partial class IccDataReader
     /// <summary>
     /// Reads the header of a <see cref="IccTagDataEntry"/> and checks if it's the expected value
     /// </summary>
-    /// <param name="expected">expected value to check against</param>
+    /// <param name="expected">The expected value to check against.</param>
     public void ReadCheckTagDataEntryHeader(IccTypeSignature expected)
     {
         IccTypeSignature type = this.ReadTagDataEntryHeader();
@@ -127,8 +125,8 @@ internal sealed partial class IccDataReader
     /// <summary>
     /// Reads a <see cref="IccTagDataEntry"/> with an unknown <see cref="IccTypeSignature"/>
     /// </summary>
-    /// <param name="size">The size of the entry in bytes</param>
-    /// <returns>The read entry</returns>
+    /// <param name="size">The size of the entry in bytes.</param>
+    /// <returns>The read entry.</returns>
     public IccUnknownTagDataEntry ReadUnknownTagDataEntry(uint size)
     {
         int count = (int)size - 8;  // 8 is the tag header size
@@ -138,11 +136,11 @@ internal sealed partial class IccDataReader
     /// <summary>
     /// Reads a <see cref="IccChromaticityTagDataEntry"/>
     /// </summary>
-    /// <returns>The read entry</returns>
+    /// <returns>The read entry.</returns>
     public IccChromaticityTagDataEntry ReadChromaticityTagDataEntry()
     {
         ushort channelCount = this.ReadUInt16();
-        var colorant = (IccColorantEncoding)this.ReadUInt16();
+        IccColorantEncoding colorant = (IccColorantEncoding)this.ReadUInt16();
 
         if (Enum.IsDefined(colorant) && colorant != IccColorantEncoding.Unknown)
         {
@@ -152,11 +150,11 @@ internal sealed partial class IccDataReader
         }
         else
         {
-            // The type is not know, so the values need be read
+            // The type is not know, so the values need be read.
             double[][] values = new double[channelCount][];
             for (int i = 0; i < channelCount; i++)
             {
-                values[i] = new double[] { this.ReadUFix16(), this.ReadUFix16() };
+                values[i] = [this.ReadUFix16(), this.ReadUFix16()];
             }
 
             return new IccChromaticityTagDataEntry(values);
@@ -166,7 +164,7 @@ internal sealed partial class IccDataReader
     /// <summary>
     /// Reads a <see cref="IccColorantOrderTagDataEntry"/>
     /// </summary>
-    /// <returns>The read entry</returns>
+    /// <returns>The read entry.</returns>
     public IccColorantOrderTagDataEntry ReadColorantOrderTagDataEntry()
     {
         uint colorantCount = this.ReadUInt32();
@@ -177,11 +175,11 @@ internal sealed partial class IccDataReader
     /// <summary>
     /// Reads a <see cref="IccColorantTableTagDataEntry"/>
     /// </summary>
-    /// <returns>The read entry</returns>
+    /// <returns>The read entry.</returns>
     public IccColorantTableTagDataEntry ReadColorantTableTagDataEntry()
     {
         uint colorantCount = this.ReadUInt32();
-        var cdata = new IccColorantTableEntry[colorantCount];
+        IccColorantTableEntry[] cdata = new IccColorantTableEntry[colorantCount];
         for (int i = 0; i < colorantCount; i++)
         {
             cdata[i] = this.ReadColorantTableEntry();
@@ -193,7 +191,7 @@ internal sealed partial class IccDataReader
     /// <summary>
     /// Reads a <see cref="IccCurveTagDataEntry"/>
     /// </summary>
-    /// <returns>The read entry</returns>
+    /// <returns>The read entry.</returns>
     public IccCurveTagDataEntry ReadCurveTagDataEntry()
     {
         uint pointCount = this.ReadUInt32();
@@ -222,7 +220,7 @@ internal sealed partial class IccDataReader
     /// <summary>
     /// Reads a <see cref="IccDataTagDataEntry"/>
     /// </summary>
-    /// <param name="size">The size of the entry in bytes</param>
+    /// <param name="size">The size of the entry in bytes.</param>
     /// <returns>The read entry</returns>
     public IccDataTagDataEntry ReadDataTagDataEntry(uint size)
     {
@@ -240,16 +238,13 @@ internal sealed partial class IccDataReader
     /// <summary>
     /// Reads a <see cref="IccDateTimeTagDataEntry"/>
     /// </summary>
-    /// <returns>The read entry</returns>
-    public IccDateTimeTagDataEntry ReadDateTimeTagDataEntry()
-    {
-        return new IccDateTimeTagDataEntry(this.ReadDateTime());
-    }
+    /// <returns>The read entry.</returns>
+    public IccDateTimeTagDataEntry ReadDateTimeTagDataEntry() => new(this.ReadDateTime());
 
     /// <summary>
     /// Reads a <see cref="IccLut16TagDataEntry"/>
     /// </summary>
-    /// <returns>The read entry</returns>
+    /// <returns>The read entry.</returns>
     public IccLut16TagDataEntry ReadLut16TagDataEntry()
     {
         byte inChCount = this.data[this.AddIndex(1)];
@@ -263,7 +258,7 @@ internal sealed partial class IccDataReader
         ushort outTableCount = this.ReadUInt16();
 
         // Input LUT
-        var inValues = new IccLut[inChCount];
+        IccLut[] inValues = new IccLut[inChCount];
         byte[] gridPointCount = new byte[inChCount];
         for (int i = 0; i < inChCount; i++)
         {
@@ -275,7 +270,7 @@ internal sealed partial class IccDataReader
         IccClut clut = this.ReadClut16(inChCount, outChCount, gridPointCount);
 
         // Output LUT
-        var outValues = new IccLut[outChCount];
+        IccLut[] outValues = new IccLut[outChCount];
         for (int i = 0; i < outChCount; i++)
         {
             outValues[i] = this.ReadLut16(outTableCount);
@@ -287,7 +282,7 @@ internal sealed partial class IccDataReader
     /// <summary>
     /// Reads a <see cref="IccLut8TagDataEntry"/>
     /// </summary>
-    /// <returns>The read entry</returns>
+    /// <returns>The read entry.</returns>
     public IccLut8TagDataEntry ReadLut8TagDataEntry()
     {
         byte inChCount = this.data[this.AddIndex(1)];
@@ -298,7 +293,7 @@ internal sealed partial class IccDataReader
         float[,] matrix = this.ReadMatrix(3, 3, false);
 
         // Input LUT
-        var inValues = new IccLut[inChCount];
+        IccLut[] inValues = new IccLut[inChCount];
         byte[] gridPointCount = new byte[inChCount];
         for (int i = 0; i < inChCount; i++)
         {
@@ -310,7 +305,7 @@ internal sealed partial class IccDataReader
         IccClut clut = this.ReadClut8(inChCount, outChCount, gridPointCount);
 
         // Output LUT
-        var outValues = new IccLut[outChCount];
+        IccLut[] outValues = new IccLut[outChCount];
         for (int i = 0; i < outChCount; i++)
         {
             outValues[i] = this.ReadLut8();
@@ -322,7 +317,7 @@ internal sealed partial class IccDataReader
     /// <summary>
     /// Reads a <see cref="IccLutAToBTagDataEntry"/>
     /// </summary>
-    /// <returns>The read entry</returns>
+    /// <returns>The read entry.</returns>
     public IccLutAToBTagDataEntry ReadLutAtoBTagDataEntry()
     {
         int start = this.currentIndex - 8; // 8 is the tag header size
@@ -381,7 +376,7 @@ internal sealed partial class IccDataReader
     /// <summary>
     /// Reads a <see cref="IccLutBToATagDataEntry"/>
     /// </summary>
-    /// <returns>The read entry</returns>
+    /// <returns>The read entry.</returns>
     public IccLutBToATagDataEntry ReadLutBtoATagDataEntry()
     {
         int start = this.currentIndex - 8; // 8 is the tag header size
@@ -440,30 +435,27 @@ internal sealed partial class IccDataReader
     /// <summary>
     /// Reads a <see cref="IccMeasurementTagDataEntry"/>
     /// </summary>
-    /// <returns>The read entry</returns>
-    public IccMeasurementTagDataEntry ReadMeasurementTagDataEntry()
-    {
-        return new IccMeasurementTagDataEntry(
+    /// <returns>The read entry.</returns>
+    public IccMeasurementTagDataEntry ReadMeasurementTagDataEntry() => new(
             observer: (IccStandardObserver)this.ReadUInt32(),
             xyzBacking: this.ReadXyzNumber(),
             geometry: (IccMeasurementGeometry)this.ReadUInt32(),
             flare: this.ReadUFix16(),
             illuminant: (IccStandardIlluminant)this.ReadUInt32());
-    }
 
     /// <summary>
     /// Reads a <see cref="IccMultiLocalizedUnicodeTagDataEntry"/>
     /// </summary>
-    /// <returns>The read entry</returns>
+    /// <returns>The read entry.</returns>
     public IccMultiLocalizedUnicodeTagDataEntry ReadMultiLocalizedUnicodeTagDataEntry()
     {
         int start = this.currentIndex - 8; // 8 is the tag header size
         uint recordCount = this.ReadUInt32();
 
         this.ReadUInt32();  // Record size (always 12)
-        var text = new IccLocalizedString[recordCount];
+        IccLocalizedString[] text = new IccLocalizedString[recordCount];
 
-        var culture = new CultureInfo[recordCount];
+        CultureInfo[] culture = new CultureInfo[recordCount];
         uint[] length = new uint[recordCount];
         uint[] offset = new uint[recordCount];
 
@@ -519,7 +511,7 @@ internal sealed partial class IccDataReader
     /// <summary>
     /// Reads a <see cref="IccMultiProcessElementsTagDataEntry"/>
     /// </summary>
-    /// <returns>The read entry</returns>
+    /// <returns>The read entry.</returns>
     public IccMultiProcessElementsTagDataEntry ReadMultiProcessElementsTagDataEntry()
     {
         int start = this.currentIndex - 8;
@@ -528,13 +520,13 @@ internal sealed partial class IccDataReader
         this.ReadUInt16();
         uint elementCount = this.ReadUInt32();
 
-        var positionTable = new IccPositionNumber[elementCount];
+        IccPositionNumber[] positionTable = new IccPositionNumber[elementCount];
         for (int i = 0; i < elementCount; i++)
         {
             positionTable[i] = this.ReadPositionNumber();
         }
 
-        var elements = new IccMultiProcessElement[elementCount];
+        IccMultiProcessElement[] elements = new IccMultiProcessElement[elementCount];
         for (int i = 0; i < elementCount; i++)
         {
             this.currentIndex = (int)positionTable[i].Offset + start;
@@ -547,7 +539,7 @@ internal sealed partial class IccDataReader
     /// <summary>
     /// Reads a <see cref="IccNamedColor2TagDataEntry"/>
     /// </summary>
-    /// <returns>The read entry</returns>
+    /// <returns>The read entry.</returns>
     public IccNamedColor2TagDataEntry ReadNamedColor2TagDataEntry()
     {
         int vendorFlag = this.ReadInt32();
@@ -556,7 +548,7 @@ internal sealed partial class IccDataReader
         string prefix = this.ReadAsciiString(32);
         string suffix = this.ReadAsciiString(32);
 
-        var colors = new IccNamedColor[colorCount];
+        IccNamedColor[] colors = new IccNamedColor[colorCount];
         for (int i = 0; i < colorCount; i++)
         {
             colors[i] = this.ReadNamedColor(coordCount);
@@ -569,19 +561,16 @@ internal sealed partial class IccDataReader
     /// Reads a <see cref="IccParametricCurveTagDataEntry"/>
     /// </summary>
     /// <returns>The read entry</returns>
-    public IccParametricCurveTagDataEntry ReadParametricCurveTagDataEntry()
-    {
-        return new IccParametricCurveTagDataEntry(this.ReadParametricCurve());
-    }
+    public IccParametricCurveTagDataEntry ReadParametricCurveTagDataEntry() => new(this.ReadParametricCurve());
 
     /// <summary>
     /// Reads a <see cref="IccProfileSequenceDescTagDataEntry"/>
     /// </summary>
-    /// <returns>The read entry</returns>
+    /// <returns>The read entry.</returns>
     public IccProfileSequenceDescTagDataEntry ReadProfileSequenceDescTagDataEntry()
     {
         uint count = this.ReadUInt32();
-        var description = new IccProfileDescription[count];
+        IccProfileDescription[] description = new IccProfileDescription[count];
         for (int i = 0; i < count; i++)
         {
             description[i] = this.ReadProfileDescription();
@@ -593,18 +582,18 @@ internal sealed partial class IccDataReader
     /// <summary>
     /// Reads a <see cref="IccProfileSequenceIdentifierTagDataEntry"/>
     /// </summary>
-    /// <returns>The read entry</returns>
+    /// <returns>The read entry.</returns>
     public IccProfileSequenceIdentifierTagDataEntry ReadProfileSequenceIdentifierTagDataEntry()
     {
         int start = this.currentIndex - 8; // 8 is the tag header size
         uint count = this.ReadUInt32();
-        var table = new IccPositionNumber[count];
+        IccPositionNumber[] table = new IccPositionNumber[count];
         for (int i = 0; i < count; i++)
         {
             table[i] = this.ReadPositionNumber();
         }
 
-        var entries = new IccProfileSequenceIdentifier[count];
+        IccProfileSequenceIdentifier[] entries = new IccProfileSequenceIdentifier[count];
         for (int i = 0; i < count; i++)
         {
             this.currentIndex = (int)(start + table[i].Offset);
@@ -620,7 +609,7 @@ internal sealed partial class IccDataReader
     /// <summary>
     /// Reads a <see cref="IccResponseCurveSet16TagDataEntry"/>
     /// </summary>
-    /// <returns>The read entry</returns>
+    /// <returns>The read entry.</returns>
     public IccResponseCurveSet16TagDataEntry ReadResponseCurveSet16TagDataEntry()
     {
         int start = this.currentIndex - 8; // 8 is the tag header size
@@ -633,7 +622,7 @@ internal sealed partial class IccDataReader
             offset[i] = this.ReadUInt32();
         }
 
-        var curves = new IccResponseCurve[measurementCount];
+        IccResponseCurve[] curves = new IccResponseCurve[measurementCount];
         for (int i = 0; i < measurementCount; i++)
         {
             this.currentIndex = (int)(start + offset[i]);
@@ -646,8 +635,8 @@ internal sealed partial class IccDataReader
     /// <summary>
     /// Reads a <see cref="IccFix16ArrayTagDataEntry"/>
     /// </summary>
-    /// <param name="size">The size of the entry in bytes</param>
-    /// <returns>The read entry</returns>
+    /// <param name="size">The size of the entry in bytes.</param>
+    /// <returns>The read entry.</returns>
     public IccFix16ArrayTagDataEntry ReadFix16ArrayTagDataEntry(uint size)
     {
         uint count = (size - 8) / 4;
@@ -663,27 +652,21 @@ internal sealed partial class IccDataReader
     /// <summary>
     /// Reads a <see cref="IccSignatureTagDataEntry"/>
     /// </summary>
-    /// <returns>The read entry</returns>
-    public IccSignatureTagDataEntry ReadSignatureTagDataEntry()
-    {
-        return new IccSignatureTagDataEntry(this.ReadAsciiString(4));
-    }
+    /// <returns>The read entry.</returns>
+    public IccSignatureTagDataEntry ReadSignatureTagDataEntry() => new(this.ReadAsciiString(4));
 
     /// <summary>
     /// Reads a <see cref="IccTextTagDataEntry"/>
     /// </summary>
-    /// <param name="size">The size of the entry in bytes</param>
-    /// <returns>The read entry</returns>
-    public IccTextTagDataEntry ReadTextTagDataEntry(uint size)
-    {
-        return new IccTextTagDataEntry(this.ReadAsciiString((int)size - 8)); // 8 is the tag header size
-    }
+    /// <param name="size">The size of the entry in bytes.</param>
+    /// <returns>The read entry.</returns>
+    public IccTextTagDataEntry ReadTextTagDataEntry(uint size) => new(this.ReadAsciiString((int)size - 8)); // 8 is the tag header size
 
     /// <summary>
     /// Reads a <see cref="IccUFix16ArrayTagDataEntry"/>
     /// </summary>
-    /// <param name="size">The size of the entry in bytes</param>
-    /// <returns>The read entry</returns>
+    /// <param name="size">The size of the entry in bytes.</param>
+    /// <returns>The read entry.</returns>
     public IccUFix16ArrayTagDataEntry ReadUFix16ArrayTagDataEntry(uint size)
     {
         uint count = (size - 8) / 4;
@@ -699,8 +682,8 @@ internal sealed partial class IccDataReader
     /// <summary>
     /// Reads a <see cref="IccUInt16ArrayTagDataEntry"/>
     /// </summary>
-    /// <param name="size">The size of the entry in bytes</param>
-    /// <returns>The read entry</returns>
+    /// <param name="size">The size of the entry in bytes.</param>
+    /// <returns>The read entry.</returns>
     public IccUInt16ArrayTagDataEntry ReadUInt16ArrayTagDataEntry(uint size)
     {
         uint count = (size - 8) / 2;
@@ -716,8 +699,8 @@ internal sealed partial class IccDataReader
     /// <summary>
     /// Reads a <see cref="IccUInt32ArrayTagDataEntry"/>
     /// </summary>
-    /// <param name="size">The size of the entry in bytes</param>
-    /// <returns>The read entry</returns>
+    /// <param name="size">The size of the entry in bytes.</param>
+    /// <returns>The read entry.</returns>
     public IccUInt32ArrayTagDataEntry ReadUInt32ArrayTagDataEntry(uint size)
     {
         uint count = (size - 8) / 4;
@@ -733,8 +716,8 @@ internal sealed partial class IccDataReader
     /// <summary>
     /// Reads a <see cref="IccUInt64ArrayTagDataEntry"/>
     /// </summary>
-    /// <param name="size">The size of the entry in bytes</param>
-    /// <returns>The read entry</returns>
+    /// <param name="size">The size of the entry in bytes.</param>
+    /// <returns>The read entry.</returns>
     public IccUInt64ArrayTagDataEntry ReadUInt64ArrayTagDataEntry(uint size)
     {
         uint count = (size - 8) / 8;
@@ -750,8 +733,8 @@ internal sealed partial class IccDataReader
     /// <summary>
     /// Reads a <see cref="IccUInt8ArrayTagDataEntry"/>
     /// </summary>
-    /// <param name="size">The size of the entry in bytes</param>
-    /// <returns>The read entry</returns>
+    /// <param name="size">The size of the entry in bytes.</param>
+    /// <returns>The read entry.</returns>
     public IccUInt8ArrayTagDataEntry ReadUInt8ArrayTagDataEntry(uint size)
     {
         int count = (int)size - 8; // 8 is the tag header size
@@ -763,24 +746,21 @@ internal sealed partial class IccDataReader
     /// <summary>
     /// Reads a <see cref="IccViewingConditionsTagDataEntry"/>
     /// </summary>
-    /// <returns>The read entry</returns>
-    public IccViewingConditionsTagDataEntry ReadViewingConditionsTagDataEntry()
-    {
-        return new IccViewingConditionsTagDataEntry(
+    /// <returns>The read entry.</returns>
+    public IccViewingConditionsTagDataEntry ReadViewingConditionsTagDataEntry() => new(
             illuminantXyz: this.ReadXyzNumber(),
             surroundXyz: this.ReadXyzNumber(),
             illuminant: (IccStandardIlluminant)this.ReadUInt32());
-    }
 
     /// <summary>
     /// Reads a <see cref="IccXyzTagDataEntry"/>
     /// </summary>
-    /// <param name="size">The size of the entry in bytes</param>
-    /// <returns>The read entry</returns>
+    /// <param name="size">The size of the entry in bytes.</param>
+    /// <returns>The read entry.</returns>
     public IccXyzTagDataEntry ReadXyzTagDataEntry(uint size)
     {
         uint count = (size - 8) / 12;
-        var arrayData = new Vector3[count];
+        Vector3[] arrayData = new Vector3[count];
         for (int i = 0; i < count; i++)
         {
             arrayData[i] = this.ReadXyzNumber();
@@ -792,7 +772,7 @@ internal sealed partial class IccDataReader
     /// <summary>
     /// Reads a <see cref="IccTextDescriptionTagDataEntry"/>
     /// </summary>
-    /// <returns>The read entry</returns>
+    /// <returns>The read entry.</returns>
     public IccTextDescriptionTagDataEntry ReadTextDescriptionTagDataEntry()
     {
         string unicodeValue, scriptcodeValue;
@@ -832,7 +812,7 @@ internal sealed partial class IccDataReader
     /// <summary>
     /// Reads a <see cref="IccTextDescriptionTagDataEntry"/>
     /// </summary>
-    /// <returns>The read entry</returns>
+    /// <returns>The read entry.</returns>
     public IccCrdInfoTagDataEntry ReadCrdInfoTagDataEntry()
     {
         uint productNameCount = this.ReadUInt32();
@@ -856,12 +836,12 @@ internal sealed partial class IccDataReader
     /// <summary>
     /// Reads a <see cref="IccScreeningTagDataEntry"/>
     /// </summary>
-    /// <returns>The read entry</returns>
+    /// <returns>The read entry.</returns>
     public IccScreeningTagDataEntry ReadScreeningTagDataEntry()
     {
-        var flags = (IccScreeningFlag)this.ReadInt32();
+        IccScreeningFlag flags = (IccScreeningFlag)this.ReadInt32();
         uint channelCount = this.ReadUInt32();
-        var channels = new IccScreeningChannel[channelCount];
+        IccScreeningChannel[] channels = new IccScreeningChannel[channelCount];
         for (int i = 0; i < channels.Length; i++)
         {
             channels[i] = this.ReadScreeningChannel();
@@ -873,7 +853,7 @@ internal sealed partial class IccDataReader
     /// <summary>
     /// Reads a <see cref="IccUcrBgTagDataEntry"/>
     /// </summary>
-    /// <param name="size">The size of the entry in bytes</param>
+    /// <param name="size">The size of the entry in bytes.</param>
     /// <returns>The read entry</returns>
     public IccUcrBgTagDataEntry ReadUcrBgTagDataEntry(uint size)
     {
diff --git a/src/ImageSharp/Metadata/Profiles/ICC/DataWriter/IccDataWriter.Lut.cs b/src/ImageSharp/Metadata/Profiles/ICC/DataWriter/IccDataWriter.Lut.cs
index 703a3896bb..29394c0820 100644
--- a/src/ImageSharp/Metadata/Profiles/ICC/DataWriter/IccDataWriter.Lut.cs
+++ b/src/ImageSharp/Metadata/Profiles/ICC/DataWriter/IccDataWriter.Lut.cs
@@ -4,15 +4,15 @@
 namespace SixLabors.ImageSharp.Metadata.Profiles.Icc;
 
 /// <content>
-/// Provides methods to write ICC data types
+/// Provides methods to write ICC data types.
 /// </content>
 internal sealed partial class IccDataWriter
 {
     /// <summary>
-    /// Writes an 8bit lookup table
+    /// Writes an 8bit lookup table.
     /// </summary>
-    /// <param name="value">The LUT to write</param>
-    /// <returns>The number of bytes written</returns>
+    /// <param name="value">The LUT to write.</param>
+    /// <returns>The number of bytes written.</returns>
     public int WriteLut8(IccLut value)
     {
         foreach (float item in value.Values)
@@ -24,10 +24,10 @@ internal sealed partial class IccDataWriter
     }
 
     /// <summary>
-    /// Writes an 16bit lookup table
+    /// Writes an 16bit lookup table.
     /// </summary>
-    /// <param name="value">The LUT to write</param>
-    /// <returns>The number of bytes written</returns>
+    /// <param name="value">The LUT to write.</param>
+    /// <returns>The number of bytes written.</returns>
     public int WriteLut16(IccLut value)
     {
         foreach (float item in value.Values)
@@ -39,10 +39,10 @@ internal sealed partial class IccDataWriter
     }
 
     /// <summary>
-    /// Writes an color lookup table
+    /// Writes an color lookup table.
     /// </summary>
-    /// <param name="value">The CLUT to write</param>
-    /// <returns>The number of bytes written</returns>
+    /// <param name="value">The CLUT to write.</param>
+    /// <returns>The number of bytes written.</returns>
     public int WriteClut(IccClut value)
     {
         int count = this.WriteArray(value.GridPointCount);
@@ -67,57 +67,48 @@ internal sealed partial class IccDataWriter
     }
 
     /// <summary>
-    /// Writes a 8bit color lookup table
+    /// Writes a 8bit color lookup table.
     /// </summary>
-    /// <param name="value">The CLUT to write</param>
-    /// <returns>The number of bytes written</returns>
+    /// <param name="value">The CLUT to write.</param>
+    /// <returns>The number of bytes written.</returns>
     public int WriteClut8(IccClut value)
     {
         int count = 0;
-        foreach (float[] inArray in value.Values)
+        foreach (float item in value.Values)
         {
-            foreach (float item in inArray)
-            {
-                count += this.WriteByte((byte)Numerics.Clamp((item * byte.MaxValue) + 0.5F, 0, byte.MaxValue));
-            }
+            count += this.WriteByte((byte)Numerics.Clamp((item * byte.MaxValue) + 0.5F, 0, byte.MaxValue));
         }
 
         return count;
     }
 
     /// <summary>
-    /// Writes a 16bit color lookup table
+    /// Writes a 16bit color lookup table.
     /// </summary>
-    /// <param name="value">The CLUT to write</param>
-    /// <returns>The number of bytes written</returns>
+    /// <param name="value">The CLUT to write.</param>
+    /// <returns>The number of bytes written.</returns>
     public int WriteClut16(IccClut value)
     {
         int count = 0;
-        foreach (float[] inArray in value.Values)
+        foreach (float item in value.Values)
         {
-            foreach (float item in inArray)
-            {
-                count += this.WriteUInt16((ushort)Numerics.Clamp((item * ushort.MaxValue) + 0.5F, 0, ushort.MaxValue));
-            }
+            count += this.WriteUInt16((ushort)Numerics.Clamp((item * ushort.MaxValue) + 0.5F, 0, ushort.MaxValue));
         }
 
         return count;
     }
 
     /// <summary>
-    /// Writes a 32bit float color lookup table
+    /// Writes a 32bit float color lookup table.
     /// </summary>
-    /// <param name="value">The CLUT to write</param>
-    /// <returns>The number of bytes written</returns>
+    /// <param name="value">The CLUT to write.</param>
+    /// <returns>The number of bytes written.</returns>
     public int WriteClutF32(IccClut value)
     {
         int count = 0;
-        foreach (float[] inArray in value.Values)
+        foreach (float item in value.Values)
         {
-            foreach (float item in inArray)
-            {
-                count += this.WriteSingle(item);
-            }
+            count += this.WriteSingle(item);
         }
 
         return count;
diff --git a/src/ImageSharp/Metadata/Profiles/ICC/DataWriter/IccDataWriter.Matrix.cs b/src/ImageSharp/Metadata/Profiles/ICC/DataWriter/IccDataWriter.Matrix.cs
index 1e5f359e09..636cc90a57 100644
--- a/src/ImageSharp/Metadata/Profiles/ICC/DataWriter/IccDataWriter.Matrix.cs
+++ b/src/ImageSharp/Metadata/Profiles/ICC/DataWriter/IccDataWriter.Matrix.cs
@@ -1,4 +1,4 @@
-// Copyright (c) Six Labors.
+// Copyright (c) Six Labors.
 // Licensed under the Six Labors Split License.
 
 using System.Numerics;
@@ -61,15 +61,21 @@ internal sealed partial class IccDataWriter
     public int WriteMatrix(in DenseMatrix<float> value, bool isSingle)
     {
         int count = 0;
-        for (int y = 0; y < value.Rows; y++)
+        if (isSingle)
         {
-            for (int x = 0; x < value.Columns; x++)
+            for (int y = 0; y < value.Rows; y++)
             {
-                if (isSingle)
+                for (int x = 0; x < value.Columns; x++)
                 {
                     count += this.WriteSingle(value[x, y]);
                 }
-                else
+            }
+        }
+        else
+        {
+            for (int y = 0; y < value.Rows; y++)
+            {
+                for (int x = 0; x < value.Columns; x++)
                 {
                     count += this.WriteFix16(value[x, y]);
                 }
@@ -88,15 +94,22 @@ internal sealed partial class IccDataWriter
     public int WriteMatrix(float[,] value, bool isSingle)
     {
         int count = 0;
-        for (int y = 0; y < value.GetLength(1); y++)
+
+        if (isSingle)
         {
-            for (int x = 0; x < value.GetLength(0); x++)
+            for (int y = 0; y < value.GetLength(1); y++)
             {
-                if (isSingle)
+                for (int x = 0; x < value.GetLength(0); x++)
                 {
                     count += this.WriteSingle(value[x, y]);
                 }
-                else
+            }
+        }
+        else
+        {
+            for (int y = 0; y < value.GetLength(1); y++)
+            {
+                for (int x = 0; x < value.GetLength(0); x++)
                 {
                     count += this.WriteFix16(value[x, y]);
                 }
diff --git a/src/ImageSharp/Metadata/Profiles/ICC/DataWriter/IccDataWriter.TagDataEntry.cs b/src/ImageSharp/Metadata/Profiles/ICC/DataWriter/IccDataWriter.TagDataEntry.cs
index 1f9c101fb5..6019a0bff7 100644
--- a/src/ImageSharp/Metadata/Profiles/ICC/DataWriter/IccDataWriter.TagDataEntry.cs
+++ b/src/ImageSharp/Metadata/Profiles/ICC/DataWriter/IccDataWriter.TagDataEntry.cs
@@ -231,7 +231,7 @@ internal sealed partial class IccDataWriter
     {
         int count = this.WriteByte((byte)value.InputChannelCount);
         count += this.WriteByte((byte)value.OutputChannelCount);
-        count += this.WriteByte((byte)value.ClutValues.Values[0].Length);
+        count += this.WriteByte((byte)value.ClutValues.OutputChannelCount);
         count += this.WriteEmpty(1);
 
         count += this.WriteMatrix(value.Matrix, false);
diff --git a/src/ImageSharp/Metadata/Profiles/ICC/Enums/IccFormulaCurveType.cs b/src/ImageSharp/Metadata/Profiles/ICC/Enums/IccFormulaCurveType.cs
index e0c6f4c962..27af2a91f7 100644
--- a/src/ImageSharp/Metadata/Profiles/ICC/Enums/IccFormulaCurveType.cs
+++ b/src/ImageSharp/Metadata/Profiles/ICC/Enums/IccFormulaCurveType.cs
@@ -14,7 +14,7 @@ internal enum IccFormulaCurveType : ushort
     Type1 = 0,
 
     /// <summary>
-    /// Type 1: Y = a * log10 (b * X^γ + c) + d
+    /// Type 2: Y = a * log10 (b * X^γ + c) + d
     /// </summary>
     Type2 = 1,
 
diff --git a/src/ImageSharp/Metadata/Profiles/ICC/Exceptions/InvalidIccProfileException.cs b/src/ImageSharp/Metadata/Profiles/ICC/Exceptions/InvalidIccProfileException.cs
index c1cb3f10f0..c6b4b65773 100644
--- a/src/ImageSharp/Metadata/Profiles/ICC/Exceptions/InvalidIccProfileException.cs
+++ b/src/ImageSharp/Metadata/Profiles/ICC/Exceptions/InvalidIccProfileException.cs
@@ -1,4 +1,4 @@
-// Copyright (c) Six Labors.
+// Copyright (c) Six Labors.
 // Licensed under the Six Labors Split License.
 
 namespace SixLabors.ImageSharp.Metadata.Profiles.Icc;
diff --git a/src/ImageSharp/Metadata/Profiles/ICC/IccProfile.cs b/src/ImageSharp/Metadata/Profiles/ICC/IccProfile.cs
index ac78318f2b..392ccb3062 100644
--- a/src/ImageSharp/Metadata/Profiles/ICC/IccProfile.cs
+++ b/src/ImageSharp/Metadata/Profiles/ICC/IccProfile.cs
@@ -190,7 +190,6 @@ public sealed class IccProfile : IDeepCloneable<IccProfile>
             return;
         }
 
-        IccReader reader = new();
         this.header = IccReader.ReadHeader(this.data);
     }
 
@@ -203,11 +202,10 @@ public sealed class IccProfile : IDeepCloneable<IccProfile>
 
         if (this.data is null)
         {
-            this.entries = Array.Empty<IccTagDataEntry>();
+            this.entries = [];
             return;
         }
 
-        IccReader reader = new();
         this.entries = IccReader.ReadTagData(this.data);
     }
 }
diff --git a/src/ImageSharp/Metadata/Profiles/ICC/IccProfileHeader.cs b/src/ImageSharp/Metadata/Profiles/ICC/IccProfileHeader.cs
index 4da5a6aa56..b50885d025 100644
--- a/src/ImageSharp/Metadata/Profiles/ICC/IccProfileHeader.cs
+++ b/src/ImageSharp/Metadata/Profiles/ICC/IccProfileHeader.cs
@@ -1,4 +1,4 @@
-// Copyright (c) Six Labors.
+// Copyright (c) Six Labors.
 // Licensed under the Six Labors Split License.
 #nullable disable
 
@@ -11,6 +11,17 @@ namespace SixLabors.ImageSharp.Metadata.Profiles.Icc;
 /// </summary>
 public sealed class IccProfileHeader
 {
+    private static readonly Vector3 TruncatedD50 = new(0.9642029F, 1F, 0.8249054F);
+
+    // sRGB v2 Preference
+    private static readonly IccProfileId StandardRgbV2 = new(0x3D0EB2DE, 0xAE9397BE, 0x9B6726CE, 0x8C0A43CE);
+
+    // sRGB v4 Preference
+    private static readonly IccProfileId StandardRgbV4 = new(0x34562ABF, 0x994CCD06, 0x6D2C5721, 0xD0D68C5D);
+
+    // sRGB v4 Appearance
+    private static readonly IccProfileId StandardRgbV4A = new(0xDF1132A1, 0x746E97B0, 0xAD85719, 0xBE711E08);
+
     /// <summary>
     /// Gets or sets the profile size in bytes (will be ignored when writing a profile).
     /// </summary>
@@ -97,4 +108,31 @@ public sealed class IccProfileHeader
     /// Gets or sets the profile ID (hash).
     /// </summary>
     public IccProfileId Id { get; set; }
+
+    internal static bool IsLikelySrgb(IccProfileHeader header)
+    {
+        // Reject known perceptual-appearance profile
+        // This profile employs perceptual rendering intents to maintain color appearance across different
+        // devices and media, which can lead to variations from standard sRGB representations.
+        if (header.Id == StandardRgbV4A)
+        {
+            return false;
+        }
+
+        // Accept known sRGB profile IDs
+        if (header.Id == StandardRgbV2 || header.Id == StandardRgbV4)
+        {
+            return true;
+        }
+
+        // Fallback: best-guess heuristic
+        return
+            header.FileSignature == "acsp" &&
+            header.DataColorSpace == IccColorSpaceType.Rgb &&
+            (header.ProfileConnectionSpace == IccColorSpaceType.CieXyz || header.ProfileConnectionSpace == IccColorSpaceType.CieLab) &&
+            (header.Class == IccProfileClass.DisplayDevice || header.Class == IccProfileClass.ColorSpace) &&
+            header.PcsIlluminant == TruncatedD50 &&
+            (header.Version.Major == 2 || header.Version.Major == 4) &&
+            !string.Equals(header.CmmType, "ADBE", StringComparison.Ordinal);
+    }
 }
diff --git a/src/ImageSharp/Metadata/Profiles/ICC/IccReader.cs b/src/ImageSharp/Metadata/Profiles/ICC/IccReader.cs
index 45074c9a6e..084ec388d6 100644
--- a/src/ImageSharp/Metadata/Profiles/ICC/IccReader.cs
+++ b/src/ImageSharp/Metadata/Profiles/ICC/IccReader.cs
@@ -83,28 +83,19 @@ internal sealed class IccReader
     {
         IccTagTableEntry[] tagTable = ReadTagTable(reader);
         List<IccTagDataEntry> entries = new(tagTable.Length);
-        Dictionary<uint, IccTagDataEntry> store = new();
 
         foreach (IccTagTableEntry tag in tagTable)
         {
             IccTagDataEntry entry;
-            if (store.TryGetValue(tag.Offset, out IccTagDataEntry? value))
+
+            try
             {
-                entry = value;
+                entry = reader.ReadTagDataEntry(tag);
             }
-            else
+            catch
             {
-                try
-                {
-                    entry = reader.ReadTagDataEntry(tag);
-                }
-                catch
-                {
-                    // Ignore tags that could not be read
-                    continue;
-                }
-
-                store.Add(tag.Offset, entry);
+                // Ignore tags that could not be read
+                continue;
             }
 
             entry.TagSignature = tag.Signature;
@@ -124,7 +115,7 @@ internal sealed class IccReader
         // A normal profile usually has 5-15 entries
         if (tagCount > 100)
         {
-            return Array.Empty<IccTagTableEntry>();
+            return [];
         }
 
         List<IccTagTableEntry> table = new((int)tagCount);
diff --git a/src/ImageSharp/Metadata/Profiles/ICC/IccTagDataEntry.cs b/src/ImageSharp/Metadata/Profiles/ICC/IccTagDataEntry.cs
index 12228f3f58..f7a99645bb 100644
--- a/src/ImageSharp/Metadata/Profiles/ICC/IccTagDataEntry.cs
+++ b/src/ImageSharp/Metadata/Profiles/ICC/IccTagDataEntry.cs
@@ -1,4 +1,4 @@
-// Copyright (c) Six Labors.
+// Copyright (c) Six Labors.
 // Licensed under the Six Labors Split License.
 
 namespace SixLabors.ImageSharp.Metadata.Profiles.Icc;
@@ -41,9 +41,7 @@ public abstract class IccTagDataEntry : IEquatable<IccTagDataEntry>
 
     /// <inheritdoc/>
     public override bool Equals(object? obj)
-    {
-        return obj is IccTagDataEntry entry && this.Equals(entry);
-    }
+        => obj is IccTagDataEntry entry && this.Equals(entry);
 
     /// <inheritdoc/>
     public virtual bool Equals(IccTagDataEntry? other)
diff --git a/src/ImageSharp/Metadata/Profiles/ICC/IccWriter.cs b/src/ImageSharp/Metadata/Profiles/ICC/IccWriter.cs
index 5e73e2dd00..6bc0560f02 100644
--- a/src/ImageSharp/Metadata/Profiles/ICC/IccWriter.cs
+++ b/src/ImageSharp/Metadata/Profiles/ICC/IccWriter.cs
@@ -71,7 +71,7 @@ internal sealed class IccWriter
         // (Header size) + (entry count) + (nr of entries) * (size of table entry)
         writer.SetIndex(128 + 4 + (entries.Length * 12));
 
-        List<IccTagTableEntry> table = new();
+        List<IccTagTableEntry> table = [];
         foreach (IGrouping<IccTagDataEntry, IccTagDataEntry> group in grouped)
         {
             writer.WriteTagDataEntry(group.Key, out IccTagTableEntry tableEntry);
diff --git a/src/ImageSharp/Metadata/Profiles/ICC/TagDataEntries/IccChromaticityTagDataEntry.cs b/src/ImageSharp/Metadata/Profiles/ICC/TagDataEntries/IccChromaticityTagDataEntry.cs
index cc44762919..1938ad6302 100644
--- a/src/ImageSharp/Metadata/Profiles/ICC/TagDataEntries/IccChromaticityTagDataEntry.cs
+++ b/src/ImageSharp/Metadata/Profiles/ICC/TagDataEntries/IccChromaticityTagDataEntry.cs
@@ -112,33 +112,33 @@ internal sealed class IccChromaticityTagDataEntry : IccTagDataEntry, IEquatable<
         switch (colorantType)
         {
             case IccColorantEncoding.EbuTech3213E:
-                return new[]
-                {
-                    new[] { 0.640, 0.330 },
-                    new[] { 0.290, 0.600 },
-                    new[] { 0.150, 0.060 },
-                };
+                return
+                [
+                    [0.640, 0.330],
+                    [0.290, 0.600],
+                    [0.150, 0.060]
+                ];
             case IccColorantEncoding.ItuRBt709_2:
-                return new[]
-                {
-                    new[] { 0.640, 0.330 },
-                    new[] { 0.300, 0.600 },
-                    new[] { 0.150, 0.060 },
-                };
+                return
+                [
+                    [0.640, 0.330],
+                    [0.300, 0.600],
+                    [0.150, 0.060]
+                ];
             case IccColorantEncoding.P22:
-                return new[]
-                {
-                    new[] { 0.625, 0.340 },
-                    new[] { 0.280, 0.605 },
-                    new[] { 0.155, 0.070 },
-                };
+                return
+                [
+                    [0.625, 0.340],
+                    [0.280, 0.605],
+                    [0.155, 0.070]
+                ];
             case IccColorantEncoding.SmpteRp145:
-                return new[]
-                {
-                    new[] { 0.630, 0.340 },
-                    new[] { 0.310, 0.595 },
-                    new[] { 0.155, 0.070 },
-                };
+                return
+                [
+                    [0.630, 0.340],
+                    [0.310, 0.595],
+                    [0.155, 0.070]
+                ];
             default:
                 throw new ArgumentException("Unrecognized colorant encoding");
         }
diff --git a/src/ImageSharp/Metadata/Profiles/ICC/TagDataEntries/IccCurveTagDataEntry.cs b/src/ImageSharp/Metadata/Profiles/ICC/TagDataEntries/IccCurveTagDataEntry.cs
index 5605d92559..7330cbdf00 100644
--- a/src/ImageSharp/Metadata/Profiles/ICC/TagDataEntries/IccCurveTagDataEntry.cs
+++ b/src/ImageSharp/Metadata/Profiles/ICC/TagDataEntries/IccCurveTagDataEntry.cs
@@ -12,7 +12,7 @@ internal sealed class IccCurveTagDataEntry : IccTagDataEntry, IEquatable<IccCurv
     /// Initializes a new instance of the <see cref="IccCurveTagDataEntry"/> class.
     /// </summary>
     public IccCurveTagDataEntry()
-        : this(Array.Empty<float>(), IccProfileTag.Unknown)
+        : this([], IccProfileTag.Unknown)
     {
     }
 
@@ -21,7 +21,7 @@ internal sealed class IccCurveTagDataEntry : IccTagDataEntry, IEquatable<IccCurv
     /// </summary>
     /// <param name="gamma">Gamma value</param>
     public IccCurveTagDataEntry(float gamma)
-        : this(new[] { gamma }, IccProfileTag.Unknown)
+        : this([gamma], IccProfileTag.Unknown)
     {
     }
 
@@ -39,7 +39,7 @@ internal sealed class IccCurveTagDataEntry : IccTagDataEntry, IEquatable<IccCurv
     /// </summary>
     /// <param name="tagSignature">Tag Signature</param>
     public IccCurveTagDataEntry(IccProfileTag tagSignature)
-        : this(Array.Empty<float>(), tagSignature)
+        : this([], tagSignature)
     {
     }
 
@@ -49,7 +49,7 @@ internal sealed class IccCurveTagDataEntry : IccTagDataEntry, IEquatable<IccCurv
     /// <param name="gamma">Gamma value</param>
     /// <param name="tagSignature">Tag Signature</param>
     public IccCurveTagDataEntry(float gamma, IccProfileTag tagSignature)
-        : this(new[] { gamma }, tagSignature)
+        : this([gamma], tagSignature)
     {
     }
 
@@ -61,7 +61,7 @@ internal sealed class IccCurveTagDataEntry : IccTagDataEntry, IEquatable<IccCurv
     public IccCurveTagDataEntry(float[] curveData, IccProfileTag tagSignature)
         : base(IccTypeSignature.Curve, tagSignature)
     {
-        this.CurveData = curveData ?? Array.Empty<float>();
+        this.CurveData = curveData ?? [];
     }
 
     /// <summary>
diff --git a/src/ImageSharp/Metadata/Profiles/ICC/Various/IccClut.cs b/src/ImageSharp/Metadata/Profiles/ICC/Various/IccClut.cs
index 26a882810e..22165ec5b6 100644
--- a/src/ImageSharp/Metadata/Profiles/ICC/Various/IccClut.cs
+++ b/src/ImageSharp/Metadata/Profiles/ICC/Various/IccClut.cs
@@ -1,20 +1,21 @@
-// Copyright (c) Six Labors.
+// Copyright (c) Six Labors.
 // Licensed under the Six Labors Split License.
 
 namespace SixLabors.ImageSharp.Metadata.Profiles.Icc;
 
 /// <summary>
-/// Color Lookup Table
+/// Color Lookup Table.
 /// </summary>
 internal sealed class IccClut : IEquatable<IccClut>
 {
     /// <summary>
     /// Initializes a new instance of the <see cref="IccClut"/> class.
     /// </summary>
-    /// <param name="values">The CLUT values</param>
-    /// <param name="gridPointCount">The gridpoint count</param>
-    /// <param name="type">The data type of this CLUT</param>
-    public IccClut(float[][] values, byte[] gridPointCount, IccClutDataType type)
+    /// <param name="values">The CLUT values.</param>
+    /// <param name="gridPointCount">The gridpoint count.</param>
+    /// <param name="type">The data type of this CLUT.</param>
+    /// <param name="outputChannelCount">The output channels count.</param>
+    public IccClut(float[] values, byte[] gridPointCount, IccClutDataType type, int outputChannelCount)
     {
         Guard.NotNull(values, nameof(values));
         Guard.NotNull(gridPointCount, nameof(gridPointCount));
@@ -22,91 +23,33 @@ internal sealed class IccClut : IEquatable<IccClut>
         this.Values = values;
         this.DataType = type;
         this.InputChannelCount = gridPointCount.Length;
-        this.OutputChannelCount = values[0].Length;
+        this.OutputChannelCount = outputChannelCount;
         this.GridPointCount = gridPointCount;
         this.CheckValues();
     }
 
     /// <summary>
-    /// Initializes a new instance of the <see cref="IccClut"/> class.
+    /// Gets the values that make up this table.
     /// </summary>
-    /// <param name="values">The CLUT values</param>
-    /// <param name="gridPointCount">The gridpoint count</param>
-    public IccClut(ushort[][] values, byte[] gridPointCount)
-    {
-        Guard.NotNull(values, nameof(values));
-        Guard.NotNull(gridPointCount, nameof(gridPointCount));
-
-        const float Max = ushort.MaxValue;
-
-        this.Values = new float[values.Length][];
-        for (int i = 0; i < values.Length; i++)
-        {
-            this.Values[i] = new float[values[i].Length];
-            for (int j = 0; j < values[i].Length; j++)
-            {
-                this.Values[i][j] = values[i][j] / Max;
-            }
-        }
-
-        this.DataType = IccClutDataType.UInt16;
-        this.InputChannelCount = gridPointCount.Length;
-        this.OutputChannelCount = values[0].Length;
-        this.GridPointCount = gridPointCount;
-        this.CheckValues();
-    }
+    public float[] Values { get; }
 
     /// <summary>
-    /// Initializes a new instance of the <see cref="IccClut"/> class.
-    /// </summary>
-    /// <param name="values">The CLUT values</param>
-    /// <param name="gridPointCount">The gridpoint count</param>
-    public IccClut(byte[][] values, byte[] gridPointCount)
-    {
-        Guard.NotNull(values, nameof(values));
-        Guard.NotNull(gridPointCount, nameof(gridPointCount));
-
-        const float Max = byte.MaxValue;
-
-        this.Values = new float[values.Length][];
-        for (int i = 0; i < values.Length; i++)
-        {
-            this.Values[i] = new float[values[i].Length];
-            for (int j = 0; j < values[i].Length; j++)
-            {
-                this.Values[i][j] = values[i][j] / Max;
-            }
-        }
-
-        this.DataType = IccClutDataType.UInt8;
-        this.InputChannelCount = gridPointCount.Length;
-        this.OutputChannelCount = values[0].Length;
-        this.GridPointCount = gridPointCount;
-        this.CheckValues();
-    }
-
-    /// <summary>
-    /// Gets the values that make up this table
-    /// </summary>
-    public float[][] Values { get; }
-
-    /// <summary>
-    /// Gets the CLUT data type (important when writing a profile)
+    /// Gets the CLUT data type (important when writing a profile).
     /// </summary>
     public IccClutDataType DataType { get; }
 
     /// <summary>
-    /// Gets the number of input channels
+    /// Gets the number of input channels.
     /// </summary>
     public int InputChannelCount { get; }
 
     /// <summary>
-    /// Gets the number of output channels
+    /// Gets the number of output channels.
     /// </summary>
     public int OutputChannelCount { get; }
 
     /// <summary>
-    /// Gets the number of grid points per input channel
+    /// Gets the number of grid points per input channel.
     /// </summary>
     public byte[] GridPointCount { get; }
 
@@ -134,15 +77,12 @@ internal sealed class IccClut : IEquatable<IccClut>
     public override bool Equals(object? obj) => obj is IccClut other && this.Equals(other);
 
     /// <inheritdoc/>
-    public override int GetHashCode()
-    {
-        return HashCode.Combine(
+    public override int GetHashCode() => HashCode.Combine(
             this.Values,
             this.DataType,
             this.InputChannelCount,
             this.OutputChannelCount,
             this.GridPointCount);
-    }
 
     private bool EqualsValuesArray(IccClut other)
     {
@@ -151,15 +91,7 @@ internal sealed class IccClut : IEquatable<IccClut>
             return false;
         }
 
-        for (int i = 0; i < this.Values.Length; i++)
-        {
-            if (!this.Values[i].AsSpan().SequenceEqual(other.Values[i]))
-            {
-                return false;
-            }
-        }
-
-        return true;
+        return this.Values.SequenceEqual(other.Values);
     }
 
     private void CheckValues()
@@ -167,17 +99,13 @@ internal sealed class IccClut : IEquatable<IccClut>
         Guard.MustBeBetweenOrEqualTo(this.InputChannelCount, 1, 15, nameof(this.InputChannelCount));
         Guard.MustBeBetweenOrEqualTo(this.OutputChannelCount, 1, 15, nameof(this.OutputChannelCount));
 
-        bool isLengthDifferent = this.Values.Any(t => t.Length != this.OutputChannelCount);
-        Guard.IsFalse(isLengthDifferent, nameof(this.Values), "The number of output values varies");
-
         int length = 0;
         for (int i = 0; i < this.InputChannelCount; i++)
         {
             length += (int)Math.Pow(this.GridPointCount[i], this.InputChannelCount);
         }
 
-        length /= this.InputChannelCount;
-
-        Guard.IsTrue(this.Values.Length == length, nameof(this.Values), "Length of values array does not match the grid points");
+        // TODO: Disabled this check, not sure if this check is correct.
+        // Guard.IsTrue(this.Values.Length == length, nameof(this.Values), "Length of values array does not match the grid points");
     }
 }
diff --git a/src/ImageSharp/Metadata/Profiles/ICC/Various/IccTagTableEntry.cs b/src/ImageSharp/Metadata/Profiles/ICC/Various/IccTagTableEntry.cs
index e7d7461d5d..a71cbfaf5a 100644
--- a/src/ImageSharp/Metadata/Profiles/ICC/Various/IccTagTableEntry.cs
+++ b/src/ImageSharp/Metadata/Profiles/ICC/Various/IccTagTableEntry.cs
@@ -1,4 +1,4 @@
-// Copyright (c) Six Labors.
+// Copyright (c) Six Labors.
 // Licensed under the Six Labors Split License.
 
 namespace SixLabors.ImageSharp.Metadata.Profiles.Icc;
@@ -49,9 +49,7 @@ internal readonly struct IccTagTableEntry : IEquatable<IccTagTableEntry>
     /// True if the <paramref name="left"/> parameter is equal to the <paramref name="right"/> parameter; otherwise, false.
     /// </returns>
     public static bool operator ==(IccTagTableEntry left, IccTagTableEntry right)
-    {
-        return left.Equals(right);
-    }
+        => left.Equals(right);
 
     /// <summary>
     /// Compares two <see cref="IccTagTableEntry"/> objects for equality.
@@ -62,9 +60,7 @@ internal readonly struct IccTagTableEntry : IEquatable<IccTagTableEntry>
     /// True if the <paramref name="left"/> parameter is not equal to the <paramref name="right"/> parameter; otherwise, false.
     /// </returns>
     public static bool operator !=(IccTagTableEntry left, IccTagTableEntry right)
-    {
-        return !left.Equals(right);
-    }
+        => !left.Equals(right);
 
     /// <inheritdoc/>
     public override bool Equals(object? obj) => obj is IccTagTableEntry other && this.Equals(other);
diff --git a/src/ImageSharp/Metadata/Profiles/IPTC/IptcProfile.cs b/src/ImageSharp/Metadata/Profiles/IPTC/IptcProfile.cs
index 162fae96b3..306924e62c 100644
--- a/src/ImageSharp/Metadata/Profiles/IPTC/IptcProfile.cs
+++ b/src/ImageSharp/Metadata/Profiles/IPTC/IptcProfile.cs
@@ -3,7 +3,6 @@
 
 using System.Buffers.Binary;
 using System.Collections.ObjectModel;
-using System.Diagnostics.CodeAnalysis;
 using System.Globalization;
 using System.Text;
 using SixLabors.ImageSharp.Metadata.Profiles.IPTC;
@@ -15,7 +14,7 @@ namespace SixLabors.ImageSharp.Metadata.Profiles.Iptc;
 /// </summary>
 public sealed class IptcProfile : IDeepCloneable<IptcProfile>
 {
-    private readonly Collection<IptcValue> values = new();
+    private readonly Collection<IptcValue> values = [];
 
     private const byte IptcTagMarkerByte = 0x1c;
 
@@ -68,7 +67,7 @@ public sealed class IptcProfile : IDeepCloneable<IptcProfile>
     /// <summary>
     /// Gets a byte array marking that UTF-8 encoding is used in application records.
     /// </summary>
-    private static ReadOnlySpan<byte> CodedCharacterSetUtf8Value => new byte[] { 0x1B, 0x25, 0x47 }; // Uses C#'s optimization to refer to the data segment in the assembly directly, no allocation occurs.
+    private static ReadOnlySpan<byte> CodedCharacterSetUtf8Value => [0x1B, 0x25, 0x47]; // Uses C#'s optimization to refer to the data segment in the assembly directly, no allocation occurs.
 
     /// <summary>
     /// Gets the byte data of the IPTC profile.
@@ -90,7 +89,7 @@ public sealed class IptcProfile : IDeepCloneable<IptcProfile>
     /// <returns>The values found with the specified tag.</returns>
     public List<IptcValue> GetValues(IptcTag tag)
     {
-        List<IptcValue> iptcValues = new();
+        List<IptcValue> iptcValues = [];
         foreach (IptcValue iptcValue in this.Values)
         {
             if (iptcValue.Tag == tag)
diff --git a/src/ImageSharp/Metadata/Profiles/IPTC/IptcValue.cs b/src/ImageSharp/Metadata/Profiles/IPTC/IptcValue.cs
index 78f7f6de08..7735810b3f 100644
--- a/src/ImageSharp/Metadata/Profiles/IPTC/IptcValue.cs
+++ b/src/ImageSharp/Metadata/Profiles/IPTC/IptcValue.cs
@@ -12,7 +12,7 @@ namespace SixLabors.ImageSharp.Metadata.Profiles.Iptc;
 [DebuggerDisplay("{Tag} = {ToString(),nq} ({GetType().Name,nq})")]
 public sealed class IptcValue : IDeepCloneable<IptcValue>
 {
-    private byte[] data = Array.Empty<byte>();
+    private byte[] data = [];
     private Encoding encoding;
 
     internal IptcValue(IptcValue other)
@@ -91,7 +91,7 @@ public sealed class IptcValue : IDeepCloneable<IptcValue>
         {
             if (string.IsNullOrEmpty(value))
             {
-                this.data = Array.Empty<byte>();
+                this.data = [];
             }
             else
             {
@@ -124,7 +124,7 @@ public sealed class IptcValue : IDeepCloneable<IptcValue>
     public int Length => this.data.Length;
 
     /// <inheritdoc/>
-    public IptcValue DeepClone() => new IptcValue(this);
+    public IptcValue DeepClone() => new(this);
 
     /// <summary>
     /// Determines whether the specified object is equal to the current <see cref="IptcValue"/>.
@@ -191,7 +191,7 @@ public sealed class IptcValue : IDeepCloneable<IptcValue>
     /// <returns>A <see cref="byte"/> array.</returns>
     public byte[] ToByteArray()
     {
-        var result = new byte[this.data.Length];
+        byte[] result = new byte[this.data.Length];
         this.data.CopyTo(result, 0);
         return result;
     }
diff --git a/src/ImageSharp/PixelFormats/IPixel.cs b/src/ImageSharp/PixelFormats/IPixel.cs
index adf386614d..528b3e76d4 100644
--- a/src/ImageSharp/PixelFormats/IPixel.cs
+++ b/src/ImageSharp/PixelFormats/IPixel.cs
@@ -23,7 +23,8 @@ public interface IPixel<TSelf> : IPixel, IEquatable<TSelf>
     static abstract PixelOperations<TSelf> CreatePixelOperations();
 
     /// <summary>
-    /// Initializes the pixel instance from a generic scaled <see cref="Vector4"/>.
+    /// Initializes the pixel instance from a generic a generic ("scaled") <see cref="Vector4"/> representation
+    /// with values scaled and clamped between <value>0</value> and <value>1</value>
     /// </summary>
     /// <param name="source">The vector to load the pixel from.</param>
     /// <returns>The <typeparamref name="TSelf"/>.</returns>
diff --git a/src/ImageSharp/PixelFormats/PixelImplementations/Abgr32.cs b/src/ImageSharp/PixelFormats/PixelImplementations/Abgr32.cs
index 453a392289..1190d307a7 100644
--- a/src/ImageSharp/PixelFormats/PixelImplementations/Abgr32.cs
+++ b/src/ImageSharp/PixelFormats/PixelImplementations/Abgr32.cs
@@ -231,7 +231,7 @@ public partial struct Abgr32 : IPixel<Abgr32>, IPackedVector<uint>
     public static Abgr32 FromL16(L16 source)
     {
         byte rgb = ColorNumerics.From16BitTo8Bit(source.PackedValue);
-        return new(rgb, rgb, rgb);
+        return new Abgr32(rgb, rgb, rgb);
     }
 
     /// <inheritdoc/>
@@ -243,7 +243,7 @@ public partial struct Abgr32 : IPixel<Abgr32>, IPackedVector<uint>
     public static Abgr32 FromLa32(La32 source)
     {
         byte rgb = ColorNumerics.From16BitTo8Bit(source.L);
-        return new(rgb, rgb, rgb, ColorNumerics.From16BitTo8Bit(source.A));
+        return new Abgr32(rgb, rgb, rgb, ColorNumerics.From16BitTo8Bit(source.A));
     }
 
     /// <inheritdoc/>
@@ -320,6 +320,6 @@ public partial struct Abgr32 : IPixel<Abgr32>, IPackedVector<uint>
         vector = Numerics.Clamp(vector, Vector4.Zero, MaxBytes);
 
         Vector128<byte> result = Vector128.ConvertToInt32(vector.AsVector128()).AsByte();
-        return new(result.GetElement(0), result.GetElement(4), result.GetElement(8), result.GetElement(12));
+        return new Abgr32(result.GetElement(0), result.GetElement(4), result.GetElement(8), result.GetElement(12));
     }
 }
diff --git a/src/ImageSharp/PixelFormats/PixelImplementations/Argb32.cs b/src/ImageSharp/PixelFormats/PixelImplementations/Argb32.cs
index f8608ecc52..b74f5db718 100644
--- a/src/ImageSharp/PixelFormats/PixelImplementations/Argb32.cs
+++ b/src/ImageSharp/PixelFormats/PixelImplementations/Argb32.cs
@@ -224,7 +224,7 @@ public partial struct Argb32 : IPixel<Argb32>, IPackedVector<uint>
     public static Argb32 FromL16(L16 source)
     {
         byte rgb = ColorNumerics.From16BitTo8Bit(source.PackedValue);
-        return new(rgb, rgb, rgb);
+        return new Argb32(rgb, rgb, rgb);
     }
 
     /// <inheritdoc/>
@@ -236,7 +236,7 @@ public partial struct Argb32 : IPixel<Argb32>, IPackedVector<uint>
     public static Argb32 FromLa32(La32 source)
     {
         byte rgb = ColorNumerics.From16BitTo8Bit(source.L);
-        return new(rgb, rgb, rgb, ColorNumerics.From16BitTo8Bit(source.A));
+        return new Argb32(rgb, rgb, rgb, ColorNumerics.From16BitTo8Bit(source.A));
     }
 
     /// <inheritdoc/>
@@ -296,6 +296,6 @@ public partial struct Argb32 : IPixel<Argb32>, IPackedVector<uint>
         vector = Numerics.Clamp(vector, Vector4.Zero, MaxBytes);
 
         Vector128<byte> result = Vector128.ConvertToInt32(vector.AsVector128()).AsByte();
-        return new(result.GetElement(0), result.GetElement(4), result.GetElement(8), result.GetElement(12));
+        return new Argb32(result.GetElement(0), result.GetElement(4), result.GetElement(8), result.GetElement(12));
     }
 }
diff --git a/src/ImageSharp/PixelFormats/PixelImplementations/Bgr24.cs b/src/ImageSharp/PixelFormats/PixelImplementations/Bgr24.cs
index a860edc567..944cdf7bf5 100644
--- a/src/ImageSharp/PixelFormats/PixelImplementations/Bgr24.cs
+++ b/src/ImageSharp/PixelFormats/PixelImplementations/Bgr24.cs
@@ -110,7 +110,7 @@ public partial struct Bgr24 : IPixel<Bgr24>
         source = Numerics.Clamp(source, Vector4.Zero, MaxBytes);
 
         Vector128<byte> result = Vector128.ConvertToInt32(source.AsVector128()).AsByte();
-        return new(result.GetElement(0), result.GetElement(4), result.GetElement(8));
+        return new Bgr24(result.GetElement(0), result.GetElement(4), result.GetElement(8));
     }
 
     /// <inheritdoc/>
@@ -142,7 +142,7 @@ public partial struct Bgr24 : IPixel<Bgr24>
     public static Bgr24 FromL16(L16 source)
     {
         byte rgb = ColorNumerics.From16BitTo8Bit(source.PackedValue);
-        return new(rgb, rgb, rgb);
+        return new Bgr24(rgb, rgb, rgb);
     }
 
     /// <inheritdoc/>
@@ -154,7 +154,7 @@ public partial struct Bgr24 : IPixel<Bgr24>
     public static Bgr24 FromLa32(La32 source)
     {
         byte rgb = ColorNumerics.From16BitTo8Bit(source.L);
-        return new(rgb, rgb, rgb);
+        return new Bgr24(rgb, rgb, rgb);
     }
 
     /// <inheritdoc/>
diff --git a/src/ImageSharp/PixelFormats/PixelImplementations/Bgra32.cs b/src/ImageSharp/PixelFormats/PixelImplementations/Bgra32.cs
index 0fe7e4cc2c..903d9dc8cb 100644
--- a/src/ImageSharp/PixelFormats/PixelImplementations/Bgra32.cs
+++ b/src/ImageSharp/PixelFormats/PixelImplementations/Bgra32.cs
@@ -173,7 +173,7 @@ public partial struct Bgra32 : IPixel<Bgra32>, IPackedVector<uint>
     public static Bgra32 FromL16(L16 source)
     {
         byte rgb = ColorNumerics.From16BitTo8Bit(source.PackedValue);
-        return new(rgb, rgb, rgb);
+        return new Bgra32(rgb, rgb, rgb);
     }
 
     /// <inheritdoc/>
@@ -185,7 +185,7 @@ public partial struct Bgra32 : IPixel<Bgra32>, IPackedVector<uint>
     public static Bgra32 FromLa32(La32 source)
     {
         byte rgb = ColorNumerics.From16BitTo8Bit(source.L);
-        return new(rgb, rgb, rgb, ColorNumerics.From16BitTo8Bit(source.A));
+        return new Bgra32(rgb, rgb, rgb, ColorNumerics.From16BitTo8Bit(source.A));
     }
 
     /// <inheritdoc/>
@@ -242,6 +242,6 @@ public partial struct Bgra32 : IPixel<Bgra32>, IPackedVector<uint>
         vector = Numerics.Clamp(vector, Vector4.Zero, MaxBytes);
 
         Vector128<byte> result = Vector128.ConvertToInt32(vector.AsVector128()).AsByte();
-        return new(result.GetElement(0), result.GetElement(4), result.GetElement(8), result.GetElement(12));
+        return new Bgra32(result.GetElement(0), result.GetElement(4), result.GetElement(8), result.GetElement(12));
     }
 }
diff --git a/src/ImageSharp/PixelFormats/PixelImplementations/HalfSingle.cs b/src/ImageSharp/PixelFormats/PixelImplementations/HalfSingle.cs
index 888d992d8c..00deadb128 100644
--- a/src/ImageSharp/PixelFormats/PixelImplementations/HalfSingle.cs
+++ b/src/ImageSharp/PixelFormats/PixelImplementations/HalfSingle.cs
@@ -79,7 +79,7 @@ public partial struct HalfSingle : IPixel<HalfSingle>, IPackedVector<ushort>
         float scaled = source.X;
         scaled *= 2F;
         scaled--;
-        return new() { PackedValue = HalfTypeHelper.Pack(scaled) };
+        return new HalfSingle { PackedValue = HalfTypeHelper.Pack(scaled) };
     }
 
     /// <inheritdoc />
diff --git a/src/ImageSharp/PixelFormats/PixelImplementations/HalfVector2.cs b/src/ImageSharp/PixelFormats/PixelImplementations/HalfVector2.cs
index 861a8480aa..03d4dee892 100644
--- a/src/ImageSharp/PixelFormats/PixelImplementations/HalfVector2.cs
+++ b/src/ImageSharp/PixelFormats/PixelImplementations/HalfVector2.cs
@@ -63,7 +63,7 @@ public partial struct HalfVector2 : IPixel<HalfVector2>, IPackedVector<uint>
         Vector2 scaled = this.ToVector2();
         scaled += Vector2.One;
         scaled /= 2F;
-        return new(scaled, 0F, 1F);
+        return new Vector4(scaled, 0F, 1F);
     }
 
     /// <inheritdoc />
@@ -71,7 +71,7 @@ public partial struct HalfVector2 : IPixel<HalfVector2>, IPackedVector<uint>
     public readonly Vector4 ToVector4()
     {
         Vector2 vector = this.ToVector2();
-        return new(vector.X, vector.Y, 0F, 1F);
+        return new Vector4(vector.X, vector.Y, 0F, 1F);
     }
 
     /// <inheritdoc />
@@ -90,7 +90,7 @@ public partial struct HalfVector2 : IPixel<HalfVector2>, IPackedVector<uint>
     {
         Vector2 scaled = new Vector2(source.X, source.Y) * 2F;
         scaled -= Vector2.One;
-        return new() { PackedValue = Pack(scaled.X, scaled.Y) };
+        return new HalfVector2 { PackedValue = Pack(scaled.X, scaled.Y) };
     }
 
     /// <inheritdoc />
diff --git a/src/ImageSharp/PixelFormats/PixelImplementations/L16.cs b/src/ImageSharp/PixelFormats/PixelImplementations/L16.cs
index 64a22060c0..c5893f7706 100644
--- a/src/ImageSharp/PixelFormats/PixelImplementations/L16.cs
+++ b/src/ImageSharp/PixelFormats/PixelImplementations/L16.cs
@@ -52,7 +52,7 @@ public partial struct L16 : IPixel<L16>, IPackedVector<ushort>
     public readonly Rgba32 ToRgba32()
     {
         byte rgb = ColorNumerics.From16BitTo8Bit(this.PackedValue);
-        return new(rgb, rgb, rgb);
+        return new Rgba32(rgb, rgb, rgb);
     }
 
     /// <inheritdoc/>
diff --git a/src/ImageSharp/PixelFormats/PixelImplementations/L8.cs b/src/ImageSharp/PixelFormats/PixelImplementations/L8.cs
index cf8646cfa0..008eed459d 100644
--- a/src/ImageSharp/PixelFormats/PixelImplementations/L8.cs
+++ b/src/ImageSharp/PixelFormats/PixelImplementations/L8.cs
@@ -54,7 +54,7 @@ public partial struct L8 : IPixel<L8>, IPackedVector<byte>
     public readonly Rgba32 ToRgba32()
     {
         byte rgb = this.PackedValue;
-        return new(rgb, rgb, rgb);
+        return new Rgba32(rgb, rgb, rgb);
     }
 
     /// <inheritdoc/>
diff --git a/src/ImageSharp/PixelFormats/PixelImplementations/La16.cs b/src/ImageSharp/PixelFormats/PixelImplementations/La16.cs
index 026d0c299d..6c3fa78295 100644
--- a/src/ImageSharp/PixelFormats/PixelImplementations/La16.cs
+++ b/src/ImageSharp/PixelFormats/PixelImplementations/La16.cs
@@ -188,6 +188,6 @@ public partial struct La16 : IPixel<La16>, IPackedVector<ushort>
         byte l = ColorNumerics.Get8BitBT709Luminance(result.GetElement(0), result.GetElement(4), result.GetElement(8));
         byte a = result.GetElement(12);
 
-        return new(l, a);
+        return new La16(l, a);
     }
 }
diff --git a/src/ImageSharp/PixelFormats/PixelImplementations/La32.cs b/src/ImageSharp/PixelFormats/PixelImplementations/La32.cs
index 0ddcf16a1f..c99f6fe603 100644
--- a/src/ImageSharp/PixelFormats/PixelImplementations/La32.cs
+++ b/src/ImageSharp/PixelFormats/PixelImplementations/La32.cs
@@ -78,7 +78,7 @@ public partial struct La32 : IPixel<La32>, IPackedVector<uint>
     public readonly Rgba32 ToRgba32()
     {
         byte rgb = ColorNumerics.From16BitTo8Bit(this.L);
-        return new(rgb, rgb, rgb, ColorNumerics.From16BitTo8Bit(this.A));
+        return new Rgba32(rgb, rgb, rgb, ColorNumerics.From16BitTo8Bit(this.A));
     }
 
     /// <inheritdoc/>
@@ -117,7 +117,7 @@ public partial struct La32 : IPixel<La32>, IPackedVector<uint>
     {
         ushort l = ColorNumerics.Get16BitBT709Luminance(source.R, source.G, source.B);
         ushort a = ColorNumerics.From8BitTo16Bit(source.A);
-        return new(l, a);
+        return new La32(l, a);
     }
 
     /// <inheritdoc/>
@@ -126,7 +126,7 @@ public partial struct La32 : IPixel<La32>, IPackedVector<uint>
     {
         ushort l = ColorNumerics.Get16BitBT709Luminance(source.R, source.G, source.B);
         ushort a = ColorNumerics.From8BitTo16Bit(source.A);
-        return new(l, a);
+        return new La32(l, a);
     }
 
     /// <inheritdoc />
@@ -143,7 +143,7 @@ public partial struct La32 : IPixel<La32>, IPackedVector<uint>
     {
         ushort l = ColorNumerics.Get16BitBT709Luminance(source.R, source.G, source.B);
         ushort a = ColorNumerics.From8BitTo16Bit(source.A);
-        return new(l, a);
+        return new La32(l, a);
     }
 
     /// <inheritdoc/>
@@ -160,7 +160,7 @@ public partial struct La32 : IPixel<La32>, IPackedVector<uint>
     {
         ushort l = ColorNumerics.From8BitTo16Bit(source.L);
         ushort a = ColorNumerics.From8BitTo16Bit(source.A);
-        return new(l, a);
+        return new La32(l, a);
     }
 
     /// <inheritdoc/>
@@ -176,7 +176,7 @@ public partial struct La32 : IPixel<La32>, IPackedVector<uint>
     public static La32 FromRgb48(Rgb48 source)
     {
         ushort l = ColorNumerics.Get16BitBT709Luminance(source.R, source.G, source.B);
-        return new(l, ushort.MaxValue);
+        return new La32(l, ushort.MaxValue);
     }
 
     /// <inheritdoc/>
@@ -185,7 +185,7 @@ public partial struct La32 : IPixel<La32>, IPackedVector<uint>
     {
         ushort l = ColorNumerics.Get16BitBT709Luminance(source.R, source.G, source.B);
         ushort a = ColorNumerics.From8BitTo16Bit(source.A);
-        return new(l, a);
+        return new La32(l, a);
     }
 
     /// <inheritdoc/>
@@ -210,6 +210,6 @@ public partial struct La32 : IPixel<La32>, IPackedVector<uint>
         vector = Numerics.Clamp(vector, Vector4.Zero, Vector4.One) * Max;
         ushort l = ColorNumerics.Get16BitBT709Luminance(vector.X, vector.Y, vector.Z);
         ushort a = (ushort)MathF.Round(vector.W);
-        return new(l, a);
+        return new La32(l, a);
     }
 }
diff --git a/src/ImageSharp/PixelFormats/PixelImplementations/NormalizedByte2.cs b/src/ImageSharp/PixelFormats/PixelImplementations/NormalizedByte2.cs
index 9551d7242f..da2ab2440c 100644
--- a/src/ImageSharp/PixelFormats/PixelImplementations/NormalizedByte2.cs
+++ b/src/ImageSharp/PixelFormats/PixelImplementations/NormalizedByte2.cs
@@ -93,7 +93,7 @@ public partial struct NormalizedByte2 : IPixel<NormalizedByte2>, IPackedVector<u
     {
         Vector2 scaled = new Vector2(source.X, source.Y) * 2f;
         scaled -= Vector2.One;
-        return new() { PackedValue = Pack(scaled) };
+        return new NormalizedByte2 { PackedValue = Pack(scaled) };
     }
 
     /// <inheritdoc />
diff --git a/src/ImageSharp/PixelFormats/PixelImplementations/NormalizedShort2.cs b/src/ImageSharp/PixelFormats/PixelImplementations/NormalizedShort2.cs
index a17868f6df..0942c3a767 100644
--- a/src/ImageSharp/PixelFormats/PixelImplementations/NormalizedShort2.cs
+++ b/src/ImageSharp/PixelFormats/PixelImplementations/NormalizedShort2.cs
@@ -95,7 +95,7 @@ public partial struct NormalizedShort2 : IPixel<NormalizedShort2>, IPackedVector
     {
         Vector2 scaled = new Vector2(source.X, source.Y) * 2f;
         scaled -= Vector2.One;
-        return new() { PackedValue = Pack(scaled) };
+        return new NormalizedShort2 { PackedValue = Pack(scaled) };
     }
 
     /// <inheritdoc />
diff --git a/src/ImageSharp/PixelFormats/PixelImplementations/PixelOperations/Generated/_Common.ttinclude b/src/ImageSharp/PixelFormats/PixelImplementations/PixelOperations/Generated/_Common.ttinclude
index c4d5a6b95d..ae29223deb 100644
--- a/src/ImageSharp/PixelFormats/PixelImplementations/PixelOperations/Generated/_Common.ttinclude
+++ b/src/ImageSharp/PixelFormats/PixelImplementations/PixelOperations/Generated/_Common.ttinclude
@@ -14,8 +14,8 @@ using System.Runtime.InteropServices;
 using SixLabors.ImageSharp.PixelFormats.Utils;
 <#+
     private static readonly string[] CommonPixelTypes =
-    {
-        "Argb32",
+        [
+            "Argb32",
         "Abgr32",
         "Bgr24",
         "Bgra32",
@@ -28,27 +28,27 @@ using SixLabors.ImageSharp.PixelFormats.Utils;
         "Rgb48",
         "Rgba64",
         "Bgra5551"
-    };
+            ];
 
     private static readonly string[] OptimizedPixelTypes =
-    {
-        "Rgba32",
+        [
+            "Rgba32",
         "Argb32",
         "Abgr32",
         "Bgra32",
         "Rgb24",
         "Bgr24"
-    };
+            ];
 
     // Types with Rgba32-combatable to/from Vector4 conversion
     private static readonly string[] Rgba32CompatibleTypes =
-    {
-        "Argb32",
+        [
+            "Argb32",
         "Abgr32",
         "Bgra32",
         "Rgb24",
         "Bgr24"
-    };
+            ];
 
     void GenerateGenericConverterMethods(string pixelType)
     {
@@ -187,7 +187,7 @@ using SixLabors.ImageSharp.PixelFormats.Utils;
 
         var matching32BitTypes = OptimizedPixelTypes.Contains(pixelType) ?
             OptimizedPixelTypes.Where(p => p != pixelType) :
-            Enumerable.Empty<string>();
+            [];
 
         foreach (string destPixelType in matching32BitTypes)
         {
diff --git a/src/ImageSharp/PixelFormats/PixelImplementations/Rgb24.cs b/src/ImageSharp/PixelFormats/PixelImplementations/Rgb24.cs
index 0aa7bad237..190407296c 100644
--- a/src/ImageSharp/PixelFormats/PixelImplementations/Rgb24.cs
+++ b/src/ImageSharp/PixelFormats/PixelImplementations/Rgb24.cs
@@ -61,7 +61,8 @@ public partial struct Rgb24 : IPixel<Rgb24>
     /// <param name="color">The instance of <see cref="Rgb"/> to convert.</param>
     /// <returns>An instance of <see cref="Rgb24"/>.</returns>
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
-    public static implicit operator Rgb24(Rgb color) => FromScaledVector4(new Vector4(color.ToVector3(), 1f));
+    public static implicit operator Rgb24(Rgb color)
+        => FromScaledVector4(new Vector4(color.ToScaledVector3(), 1F));
 
     /// <summary>
     /// Compares two <see cref="Rgb24"/> objects for equality.
@@ -120,7 +121,7 @@ public partial struct Rgb24 : IPixel<Rgb24>
         source = Numerics.Clamp(source, Vector4.Zero, MaxBytes);
 
         Vector128<byte> result = Vector128.ConvertToInt32(source.AsVector128()).AsByte();
-        return new(result.GetElement(0), result.GetElement(4), result.GetElement(8));
+        return new Rgb24(result.GetElement(0), result.GetElement(4), result.GetElement(8));
     }
 
     /// <inheritdoc/>
@@ -152,7 +153,7 @@ public partial struct Rgb24 : IPixel<Rgb24>
     public static Rgb24 FromL16(L16 source)
     {
         byte rgb = ColorNumerics.From16BitTo8Bit(source.PackedValue);
-        return new(rgb, rgb, rgb);
+        return new Rgb24(rgb, rgb, rgb);
     }
 
     /// <inheritdoc/>
@@ -164,7 +165,7 @@ public partial struct Rgb24 : IPixel<Rgb24>
     public static Rgb24 FromLa32(La32 source)
     {
         byte rgb = ColorNumerics.From16BitTo8Bit(source.L);
-        return new(rgb, rgb, rgb);
+        return new Rgb24(rgb, rgb, rgb);
     }
 
     /// <inheritdoc/>
diff --git a/src/ImageSharp/PixelFormats/PixelImplementations/Rgb48.cs b/src/ImageSharp/PixelFormats/PixelImplementations/Rgb48.cs
index e822d2abc8..ed6f57abb3 100644
--- a/src/ImageSharp/PixelFormats/PixelImplementations/Rgb48.cs
+++ b/src/ImageSharp/PixelFormats/PixelImplementations/Rgb48.cs
@@ -100,7 +100,7 @@ public partial struct Rgb48 : IPixel<Rgb48>
     public static Rgb48 FromVector4(Vector4 source)
     {
         source = Numerics.Clamp(source, Vector4.Zero, Vector4.One) * Max;
-        return new((ushort)MathF.Round(source.X), (ushort)MathF.Round(source.Y), (ushort)MathF.Round(source.Z));
+        return new Rgb48((ushort)MathF.Round(source.X), (ushort)MathF.Round(source.Y), (ushort)MathF.Round(source.Z));
     }
 
     /// <inheritdoc />
@@ -132,7 +132,7 @@ public partial struct Rgb48 : IPixel<Rgb48>
     public static Rgb48 FromL8(L8 source)
     {
         ushort rgb = ColorNumerics.From8BitTo16Bit(source.PackedValue);
-        return new(rgb, rgb, rgb);
+        return new Rgb48(rgb, rgb, rgb);
     }
 
     /// <inheritdoc/>
@@ -144,7 +144,7 @@ public partial struct Rgb48 : IPixel<Rgb48>
     public static Rgb48 FromLa16(La16 source)
     {
         ushort rgb = ColorNumerics.From8BitTo16Bit(source.L);
-        return new(rgb, rgb, rgb);
+        return new Rgb48(rgb, rgb, rgb);
     }
 
     /// <inheritdoc/>
diff --git a/src/ImageSharp/PixelFormats/PixelImplementations/Rgba32.cs b/src/ImageSharp/PixelFormats/PixelImplementations/Rgba32.cs
index 0491553430..199754c690 100644
--- a/src/ImageSharp/PixelFormats/PixelImplementations/Rgba32.cs
+++ b/src/ImageSharp/PixelFormats/PixelImplementations/Rgba32.cs
@@ -1,7 +1,6 @@
 // Copyright (c) Six Labors.
 // Licensed under the Six Labors Split License.
 
-using System.Buffers.Binary;
 using System.Globalization;
 using System.Numerics;
 using System.Runtime.CompilerServices;
@@ -187,7 +186,7 @@ public partial struct Rgba32 : IPixel<Rgba32>, IPackedVector<uint>
     /// <param name="color">The instance of <see cref="Rgb"/> to convert.</param>
     /// <returns>An instance of <see cref="Rgba32"/>.</returns>
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
-    public static implicit operator Rgba32(Rgb color) => FromScaledVector4(new Vector4(color.ToVector3(), 1F));
+    public static implicit operator Rgba32(Rgb color) => FromScaledVector4(new Vector4(color.ToScaledVector3(), 1F));
 
     /// <summary>
     /// Compares two <see cref="Rgba32"/> objects for equality.
@@ -211,64 +210,6 @@ public partial struct Rgba32 : IPixel<Rgba32>, IPackedVector<uint>
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
     public static bool operator !=(Rgba32 left, Rgba32 right) => !left.Equals(right);
 
-    /// <summary>
-    /// Creates a new instance of the <see cref="Rgba32"/> struct
-    /// from the given hexadecimal string.
-    /// </summary>
-    /// <param name="hex">
-    /// The hexadecimal representation of the combined color components arranged
-    /// in rgb, rgba, rrggbb, or rrggbbaa format to match web syntax.
-    /// </param>
-    /// <returns>
-    /// The <see cref="Rgba32"/>.
-    /// </returns>
-    /// <exception cref="ArgumentException">Hexadecimal string is not in the correct format.</exception>
-    [MethodImpl(MethodImplOptions.AggressiveInlining)]
-    public static Rgba32 ParseHex(string hex)
-    {
-        Guard.NotNull(hex, nameof(hex));
-
-        if (!TryParseHex(hex, out Rgba32 rgba))
-        {
-            throw new ArgumentException("Hexadecimal string is not in the correct format.", nameof(hex));
-        }
-
-        return rgba;
-    }
-
-    /// <summary>
-    /// Attempts to creates a new instance of the <see cref="Rgba32"/> struct
-    /// from the given hexadecimal string.
-    /// </summary>
-    /// <param name="hex">
-    /// The hexadecimal representation of the combined color components arranged
-    /// in rgb, rgba, rrggbb, or rrggbbaa format to match web syntax.
-    /// </param>
-    /// <param name="result">When this method returns, contains the <see cref="Rgba32"/> equivalent of the hexadecimal input.</param>
-    /// <returns>
-    /// The <see cref="bool"/>.
-    /// </returns>
-    [MethodImpl(MethodImplOptions.AggressiveInlining)]
-    public static bool TryParseHex(string? hex, out Rgba32 result)
-    {
-        result = default;
-        if (string.IsNullOrWhiteSpace(hex))
-        {
-            return false;
-        }
-
-        hex = ToRgbaHex(hex);
-
-        if (hex is null || !uint.TryParse(hex, NumberStyles.HexNumber, CultureInfo.InvariantCulture, out uint packedValue))
-        {
-            return false;
-        }
-
-        packedValue = BinaryPrimitives.ReverseEndianness(packedValue);
-        result = Unsafe.As<uint, Rgba32>(ref packedValue);
-        return true;
-    }
-
     /// <inheritdoc />
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
     public readonly Rgba32 ToRgba32() => this;
@@ -328,7 +269,7 @@ public partial struct Rgba32 : IPixel<Rgba32>, IPackedVector<uint>
     public static Rgba32 FromL16(L16 source)
     {
         byte rgb = ColorNumerics.From16BitTo8Bit(source.PackedValue);
-        return new(rgb, rgb, rgb);
+        return new Rgba32(rgb, rgb, rgb);
     }
 
     /// <inheritdoc/>
@@ -340,7 +281,7 @@ public partial struct Rgba32 : IPixel<Rgba32>, IPackedVector<uint>
     public static Rgba32 FromLa32(La32 source)
     {
         byte rgb = ColorNumerics.From16BitTo8Bit(source.L);
-        return new(rgb, rgb, rgb, ColorNumerics.From16BitTo8Bit(source.A));
+        return new Rgba32(rgb, rgb, rgb, ColorNumerics.From16BitTo8Bit(source.A));
     }
 
     /// <inheritdoc/>
@@ -407,43 +348,6 @@ public partial struct Rgba32 : IPixel<Rgba32>, IPackedVector<uint>
         vector = Numerics.Clamp(vector, Vector4.Zero, MaxBytes);
 
         Vector128<byte> result = Vector128.ConvertToInt32(vector.AsVector128()).AsByte();
-        return new(result.GetElement(0), result.GetElement(4), result.GetElement(8), result.GetElement(12));
-    }
-
-    /// <summary>
-    /// Converts the specified hex value to an rrggbbaa hex value.
-    /// </summary>
-    /// <param name="hex">The hex value to convert.</param>
-    /// <returns>
-    /// A rrggbbaa hex value.
-    /// </returns>
-    private static string? ToRgbaHex(string hex)
-    {
-        if (hex[0] == '#')
-        {
-            hex = hex[1..];
-        }
-
-        if (hex.Length == 8)
-        {
-            return hex;
-        }
-
-        if (hex.Length == 6)
-        {
-            return hex + "FF";
-        }
-
-        if (hex.Length is < 3 or > 4)
-        {
-            return null;
-        }
-
-        char a = hex.Length == 3 ? 'F' : hex[3];
-        char b = hex[2];
-        char g = hex[1];
-        char r = hex[0];
-
-        return new string(new[] { r, r, g, g, b, b, a, a });
+        return new Rgba32(result.GetElement(0), result.GetElement(4), result.GetElement(8), result.GetElement(12));
     }
 }
diff --git a/src/ImageSharp/PixelFormats/PixelImplementations/Rgba64.cs b/src/ImageSharp/PixelFormats/PixelImplementations/Rgba64.cs
index 27c4752e10..c73daaf86b 100644
--- a/src/ImageSharp/PixelFormats/PixelImplementations/Rgba64.cs
+++ b/src/ImageSharp/PixelFormats/PixelImplementations/Rgba64.cs
@@ -245,7 +245,7 @@ public partial struct Rgba64 : IPixel<Rgba64>, IPackedVector<ulong>
     public static Rgba64 FromL8(L8 source)
     {
         ushort rgb = ColorNumerics.From8BitTo16Bit(source.PackedValue);
-        return new(rgb, rgb, rgb, ushort.MaxValue);
+        return new Rgba64(rgb, rgb, rgb, ushort.MaxValue);
     }
 
     /// <inheritdoc />
@@ -257,7 +257,7 @@ public partial struct Rgba64 : IPixel<Rgba64>, IPackedVector<ulong>
     public static Rgba64 FromLa16(La16 source)
     {
         ushort rgb = ColorNumerics.From8BitTo16Bit(source.L);
-        return new(rgb, rgb, rgb, ColorNumerics.From8BitTo16Bit(source.A));
+        return new Rgba64(rgb, rgb, rgb, ColorNumerics.From8BitTo16Bit(source.A));
     }
 
     /// <inheritdoc/>
diff --git a/src/ImageSharp/PixelFormats/PixelImplementations/RgbaVector.cs b/src/ImageSharp/PixelFormats/PixelImplementations/RgbaVector.cs
index a27cffad83..3f9cab32f6 100644
--- a/src/ImageSharp/PixelFormats/PixelImplementations/RgbaVector.cs
+++ b/src/ImageSharp/PixelFormats/PixelImplementations/RgbaVector.cs
@@ -115,7 +115,7 @@ public partial struct RgbaVector : IPixel<RgbaVector>
     public static RgbaVector FromVector4(Vector4 source)
     {
         source = Numerics.Clamp(source, Vector4.Zero, Vector4.One);
-        return new(source.X, source.Y, source.Z, source.W);
+        return new RgbaVector(source.X, source.Y, source.Z, source.W);
     }
 
     /// <inheritdoc />
diff --git a/src/ImageSharp/PixelFormats/PixelImplementations/Short2.cs b/src/ImageSharp/PixelFormats/PixelImplementations/Short2.cs
index 403d3fbea3..39c853a5e8 100644
--- a/src/ImageSharp/PixelFormats/PixelImplementations/Short2.cs
+++ b/src/ImageSharp/PixelFormats/PixelImplementations/Short2.cs
@@ -98,7 +98,7 @@ public partial struct Short2 : IPixel<Short2>, IPackedVector<uint>
     {
         Vector2 scaled = new Vector2(source.X, source.Y) * 65534F;
         scaled -= new Vector2(32767F);
-        return new() { PackedValue = Pack(scaled) };
+        return new Short2 { PackedValue = Pack(scaled) };
     }
 
     /// <inheritdoc />
diff --git a/src/ImageSharp/PixelFormats/PixelOperations{TPixel}.cs b/src/ImageSharp/PixelFormats/PixelOperations{TPixel}.cs
index c769b389d2..ea970a7181 100644
--- a/src/ImageSharp/PixelFormats/PixelOperations{TPixel}.cs
+++ b/src/ImageSharp/PixelFormats/PixelOperations{TPixel}.cs
@@ -210,6 +210,8 @@ public partial class PixelOperations<TPixel>
     {
         GuardUnpackIntoRgbPlanes(redChannel, greenChannel, blueChannel, source);
 
+        // TODO: This can be much faster.
+        // Convert to Rgba32 first using pixel operations then use the R, G, B properties.
         int count = source.Length;
 
         ref float r = ref MemoryMarshal.GetReference(redChannel);
diff --git a/src/ImageSharp/Primitives/Complex64.cs b/src/ImageSharp/Primitives/Complex64.cs
index 4baedd9bae..061e2bd804 100644
--- a/src/ImageSharp/Primitives/Complex64.cs
+++ b/src/ImageSharp/Primitives/Complex64.cs
@@ -42,7 +42,7 @@ internal readonly struct Complex64 : IEquatable<Complex64>
     /// <param name="scalar">The <see cref="float"/> scalar to use to multiply the <see cref="Complex64"/> value.</param>
     /// <returns>The <see cref="Complex64"/> result</returns>
     [MethodImpl(InliningOptions.ShortMethod)]
-    public static Complex64 operator *(Complex64 value, float scalar) => new Complex64(value.Real * scalar, value.Imaginary * scalar);
+    public static Complex64 operator *(Complex64 value, float scalar) => new(value.Real * scalar, value.Imaginary * scalar);
 
     /// <summary>
     /// Performs the multiplication operation between a <see cref="Complex64"/> instance and a <see cref="Vector4"/>.
diff --git a/src/ImageSharp/Primitives/DenseMatrix{T}.cs b/src/ImageSharp/Primitives/DenseMatrix{T}.cs
index 9849e0211f..6925070964 100644
--- a/src/ImageSharp/Primitives/DenseMatrix{T}.cs
+++ b/src/ImageSharp/Primitives/DenseMatrix{T}.cs
@@ -198,7 +198,7 @@ public readonly struct DenseMatrix<T> : IEquatable<DenseMatrix<T>>
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
     public DenseMatrix<T> Transpose()
     {
-        DenseMatrix<T> result = new DenseMatrix<T>(this.Rows, this.Columns);
+        DenseMatrix<T> result = new(this.Rows, this.Columns);
 
         for (int y = 0; y < this.Rows; y++)
         {
diff --git a/src/ImageSharp/Primitives/Number.cs b/src/ImageSharp/Primitives/Number.cs
index fae67bbea1..a996a94f4d 100644
--- a/src/ImageSharp/Primitives/Number.cs
+++ b/src/ImageSharp/Primitives/Number.cs
@@ -47,19 +47,19 @@ public struct Number : IEquatable<Number>, IComparable<Number>
     /// Converts the specified <see cref="int"/> to an instance of this type.
     /// </summary>
     /// <param name="value">The value.</param>
-    public static implicit operator Number(int value) => new Number(value);
+    public static implicit operator Number(int value) => new(value);
 
     /// <summary>
     /// Converts the specified <see cref="uint"/> to an instance of this type.
     /// </summary>
     /// <param name="value">The value.</param>
-    public static implicit operator Number(uint value) => new Number(value);
+    public static implicit operator Number(uint value) => new(value);
 
     /// <summary>
     /// Converts the specified <see cref="ushort"/> to an instance of this type.
     /// </summary>
     /// <param name="value">The value.</param>
-    public static implicit operator Number(ushort value) => new Number((uint)value);
+    public static implicit operator Number(ushort value) => new((uint)value);
 
     /// <summary>
     /// Converts the specified <see cref="Number"/> to a <see cref="int"/>.
diff --git a/src/ImageSharp/Primitives/SignedRational.cs b/src/ImageSharp/Primitives/SignedRational.cs
index d56ea825e6..0f8e6518ad 100644
--- a/src/ImageSharp/Primitives/SignedRational.cs
+++ b/src/ImageSharp/Primitives/SignedRational.cs
@@ -42,7 +42,7 @@ public readonly struct SignedRational : IEquatable<SignedRational>
     {
         if (simplify)
         {
-            var rational = new LongRational(numerator, denominator).Simplify();
+            LongRational rational = new LongRational(numerator, denominator).Simplify();
 
             this.Numerator = (int)rational.Numerator;
             this.Denominator = (int)rational.Denominator;
@@ -70,7 +70,7 @@ public readonly struct SignedRational : IEquatable<SignedRational>
     /// <param name="bestPrecision">Whether to use the best possible precision when parsing the value.</param>
     public SignedRational(double value, bool bestPrecision)
     {
-        var rational = LongRational.FromDouble(value, bestPrecision);
+        LongRational rational = LongRational.FromDouble(value, bestPrecision);
 
         this.Numerator = (int)rational.Numerator;
         this.Denominator = (int)rational.Denominator;
@@ -142,8 +142,8 @@ public readonly struct SignedRational : IEquatable<SignedRational>
     /// <inheritdoc/>
     public bool Equals(SignedRational other)
     {
-        var left = new LongRational(this.Numerator, this.Denominator);
-        var right = new LongRational(other.Numerator, other.Denominator);
+        LongRational left = new(this.Numerator, this.Denominator);
+        LongRational right = new(other.Numerator, other.Denominator);
 
         return left.Equals(right);
     }
@@ -151,7 +151,7 @@ public readonly struct SignedRational : IEquatable<SignedRational>
     /// <inheritdoc/>
     public override int GetHashCode()
     {
-        var self = new LongRational(this.Numerator, this.Denominator);
+        LongRational self = new(this.Numerator, this.Denominator);
         return self.GetHashCode();
     }
 
@@ -182,7 +182,7 @@ public readonly struct SignedRational : IEquatable<SignedRational>
     /// <returns>The <see cref="string"/></returns>
     public string ToString(IFormatProvider provider)
     {
-        var rational = new LongRational(this.Numerator, this.Denominator);
+        LongRational rational = new(this.Numerator, this.Denominator);
         return rational.ToString(provider);
     }
 }
diff --git a/src/ImageSharp/Primitives/Size.cs b/src/ImageSharp/Primitives/Size.cs
index 945b680daa..0e65a81388 100644
--- a/src/ImageSharp/Primitives/Size.cs
+++ b/src/ImageSharp/Primitives/Size.cs
@@ -85,14 +85,14 @@ public struct Size : IEquatable<Size>
     /// </summary>
     /// <param name="size">The point.</param>
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
-    public static implicit operator SizeF(Size size) => new SizeF(size.Width, size.Height);
+    public static implicit operator SizeF(Size size) => new(size.Width, size.Height);
 
     /// <summary>
     /// Converts the given <see cref="Size"/> into a <see cref="Point"/>.
     /// </summary>
     /// <param name="size">The size.</param>
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
-    public static explicit operator Point(Size size) => new Point(size.Width, size.Height);
+    public static explicit operator Point(Size size) => new(size.Width, size.Height);
 
     /// <summary>
     /// Computes the sum of adding two sizes.
@@ -138,7 +138,7 @@ public struct Size : IEquatable<Size>
     /// <param name="left">Dividend of type <see cref="Size"/>.</param>
     /// <param name="right">Divisor of type <see cref="int"/>.</param>
     /// <returns>Result of type <see cref="Size"/>.</returns>
-    public static Size operator /(Size left, int right) => new Size(unchecked(left.Width / right), unchecked(left.Height / right));
+    public static Size operator /(Size left, int right) => new(unchecked(left.Width / right), unchecked(left.Height / right));
 
     /// <summary>
     /// Multiplies <see cref="Size"/> by a <see cref="float"/> producing <see cref="SizeF"/>.
@@ -163,7 +163,7 @@ public struct Size : IEquatable<Size>
     /// <param name="right">Divisor of type <see cref="int"/>.</param>
     /// <returns>Result of type <see cref="SizeF"/>.</returns>
     public static SizeF operator /(Size left, float right)
-        => new SizeF(left.Width / right, left.Height / right);
+        => new(left.Width / right, left.Height / right);
 
     /// <summary>
     /// Compares two <see cref="Size"/> objects for equality.
@@ -202,7 +202,7 @@ public struct Size : IEquatable<Size>
     /// <param name="right">The size on the right hand of the operand.</param>
     /// <returns>The <see cref="Size"/>.</returns>
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
-    public static Size Add(Size left, Size right) => new Size(unchecked(left.Width + right.Width), unchecked(left.Height + right.Height));
+    public static Size Add(Size left, Size right) => new(unchecked(left.Width + right.Width), unchecked(left.Height + right.Height));
 
     /// <summary>
     /// Contracts a <see cref="Size"/> by another <see cref="Size"/>.
@@ -211,7 +211,7 @@ public struct Size : IEquatable<Size>
     /// <param name="right">The size on the right hand of the operand.</param>
     /// <returns>The <see cref="Size"/>.</returns>
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
-    public static Size Subtract(Size left, Size right) => new Size(unchecked(left.Width - right.Width), unchecked(left.Height - right.Height));
+    public static Size Subtract(Size left, Size right) => new(unchecked(left.Width - right.Width), unchecked(left.Height - right.Height));
 
     /// <summary>
     /// Converts a <see cref="SizeF"/> to a <see cref="Size"/> by performing a ceiling operation on all the dimensions.
@@ -219,7 +219,7 @@ public struct Size : IEquatable<Size>
     /// <param name="size">The size.</param>
     /// <returns>The <see cref="Size"/>.</returns>
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
-    public static Size Ceiling(SizeF size) => new Size(unchecked((int)MathF.Ceiling(size.Width)), unchecked((int)MathF.Ceiling(size.Height)));
+    public static Size Ceiling(SizeF size) => new(unchecked((int)MathF.Ceiling(size.Width)), unchecked((int)MathF.Ceiling(size.Height)));
 
     /// <summary>
     /// Converts a <see cref="SizeF"/> to a <see cref="Size"/> by performing a round operation on all the dimensions.
@@ -227,7 +227,7 @@ public struct Size : IEquatable<Size>
     /// <param name="size">The size.</param>
     /// <returns>The <see cref="Size"/>.</returns>
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
-    public static Size Round(SizeF size) => new Size(unchecked((int)MathF.Round(size.Width)), unchecked((int)MathF.Round(size.Height)));
+    public static Size Round(SizeF size) => new(unchecked((int)MathF.Round(size.Width)), unchecked((int)MathF.Round(size.Height)));
 
     /// <summary>
     /// Transforms a size by the given matrix.
@@ -237,7 +237,7 @@ public struct Size : IEquatable<Size>
     /// <returns>A transformed size.</returns>
     public static SizeF Transform(Size size, Matrix3x2 matrix)
     {
-        var v = Vector2.Transform(new Vector2(size.Width, size.Height), matrix);
+        Vector2 v = Vector2.Transform(new Vector2(size.Width, size.Height), matrix);
 
         return new SizeF(v.X, v.Y);
     }
@@ -248,7 +248,7 @@ public struct Size : IEquatable<Size>
     /// <param name="size">The size.</param>
     /// <returns>The <see cref="Size"/>.</returns>
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
-    public static Size Truncate(SizeF size) => new Size(unchecked((int)size.Width), unchecked((int)size.Height));
+    public static Size Truncate(SizeF size) => new(unchecked((int)size.Width), unchecked((int)size.Height));
 
     /// <summary>
     /// Deconstructs this size into two integers.
@@ -281,7 +281,7 @@ public struct Size : IEquatable<Size>
     /// <param name="multiplier">Multiplier of type <see cref="int"/>.</param>
     /// <returns>Product of type <see cref="Size"/>.</returns>
     private static Size Multiply(Size size, int multiplier) =>
-        new Size(unchecked(size.Width * multiplier), unchecked(size.Height * multiplier));
+        new(unchecked(size.Width * multiplier), unchecked(size.Height * multiplier));
 
     /// <summary>
     /// Multiplies <see cref="Size"/> by a <see cref="float"/> producing <see cref="SizeF"/>.
@@ -290,5 +290,5 @@ public struct Size : IEquatable<Size>
     /// <param name="multiplier">Multiplier of type <see cref="float"/>.</param>
     /// <returns>Product of type SizeF.</returns>
     private static SizeF Multiply(Size size, float multiplier) =>
-        new SizeF(size.Width * multiplier, size.Height * multiplier);
+        new(size.Width * multiplier, size.Height * multiplier);
 }
diff --git a/src/ImageSharp/Primitives/SizeF.cs b/src/ImageSharp/Primitives/SizeF.cs
index 36cf9eb8ef..81c749875f 100644
--- a/src/ImageSharp/Primitives/SizeF.cs
+++ b/src/ImageSharp/Primitives/SizeF.cs
@@ -191,7 +191,7 @@ public struct SizeF : IEquatable<SizeF>
     /// <returns>A transformed size.</returns>
     public static SizeF Transform(SizeF size, Matrix3x2 matrix)
     {
-        var v = Vector2.Transform(new Vector2(size.Width, size.Height), matrix);
+        Vector2 v = Vector2.Transform(new Vector2(size.Width, size.Height), matrix);
 
         return new SizeF(v.X, v.Y);
     }
diff --git a/src/ImageSharp/Processing/Extensions/Transforms/PadExtensions.cs b/src/ImageSharp/Processing/Extensions/Transforms/PadExtensions.cs
index b6db0172dc..96b30d4f8e 100644
--- a/src/ImageSharp/Processing/Extensions/Transforms/PadExtensions.cs
+++ b/src/ImageSharp/Processing/Extensions/Transforms/PadExtensions.cs
@@ -30,7 +30,7 @@ public static class PadExtensions
     public static IImageProcessingContext Pad(this IImageProcessingContext source, int width, int height, Color color)
     {
         Size size = source.GetCurrentSize();
-        var options = new ResizeOptions
+        ResizeOptions options = new()
         {
             // Prevent downsizing.
             Size = new Size(Math.Max(width, size.Width), Math.Max(height, size.Height)),
diff --git a/src/ImageSharp/Processing/Extensions/Transforms/ResizeExtensions.cs b/src/ImageSharp/Processing/Extensions/Transforms/ResizeExtensions.cs
index 01f296d096..4a09639f88 100644
--- a/src/ImageSharp/Processing/Extensions/Transforms/ResizeExtensions.cs
+++ b/src/ImageSharp/Processing/Extensions/Transforms/ResizeExtensions.cs
@@ -118,7 +118,7 @@ public static class ResizeExtensions
         Rectangle targetRectangle,
         bool compand)
     {
-        var options = new ResizeOptions
+        ResizeOptions options = new()
         {
             Size = new Size(width, height),
             Mode = ResizeMode.Manual,
@@ -151,7 +151,7 @@ public static class ResizeExtensions
         Rectangle targetRectangle,
         bool compand)
     {
-        var options = new ResizeOptions
+        ResizeOptions options = new()
         {
             Size = new Size(width, height),
             Mode = ResizeMode.Manual,
diff --git a/src/ImageSharp/Processing/KnownFilterMatrices.cs b/src/ImageSharp/Processing/KnownFilterMatrices.cs
index b312287b52..fd512557d9 100644
--- a/src/ImageSharp/Processing/KnownFilterMatrices.cs
+++ b/src/ImageSharp/Processing/KnownFilterMatrices.cs
@@ -20,7 +20,7 @@ public static class KnownFilterMatrices
     /// <summary>
     /// Gets a filter recreating Achromatomaly (Color desensitivity) color blindness
     /// </summary>
-    public static ColorMatrix AchromatomalyFilter { get; } = new ColorMatrix
+    public static ColorMatrix AchromatomalyFilter { get; } = new()
     {
         M11 = .618F,
         M12 = .163F,
@@ -37,7 +37,7 @@ public static class KnownFilterMatrices
     /// <summary>
     /// Gets a filter recreating Achromatopsia (Monochrome) color blindness.
     /// </summary>
-    public static ColorMatrix AchromatopsiaFilter { get; } = new ColorMatrix
+    public static ColorMatrix AchromatopsiaFilter { get; } = new()
     {
         M11 = .299F,
         M12 = .299F,
@@ -54,7 +54,7 @@ public static class KnownFilterMatrices
     /// <summary>
     /// Gets a filter recreating Deuteranomaly (Green-Weak) color blindness.
     /// </summary>
-    public static ColorMatrix DeuteranomalyFilter { get; } = new ColorMatrix
+    public static ColorMatrix DeuteranomalyFilter { get; } = new()
     {
         M11 = .8F,
         M12 = .258F,
@@ -68,7 +68,7 @@ public static class KnownFilterMatrices
     /// <summary>
     /// Gets a filter recreating Deuteranopia (Green-Blind) color blindness.
     /// </summary>
-    public static ColorMatrix DeuteranopiaFilter { get; } = new ColorMatrix
+    public static ColorMatrix DeuteranopiaFilter { get; } = new()
     {
         M11 = .625F,
         M12 = .7F,
@@ -82,7 +82,7 @@ public static class KnownFilterMatrices
     /// <summary>
     /// Gets a filter recreating Protanomaly (Red-Weak) color blindness.
     /// </summary>
-    public static ColorMatrix ProtanomalyFilter { get; } = new ColorMatrix
+    public static ColorMatrix ProtanomalyFilter { get; } = new()
     {
         M11 = .817F,
         M12 = .333F,
@@ -96,7 +96,7 @@ public static class KnownFilterMatrices
     /// <summary>
     /// Gets a filter recreating Protanopia (Red-Blind) color blindness.
     /// </summary>
-    public static ColorMatrix ProtanopiaFilter { get; } = new ColorMatrix
+    public static ColorMatrix ProtanopiaFilter { get; } = new()
     {
         M11 = .567F,
         M12 = .558F,
@@ -110,7 +110,7 @@ public static class KnownFilterMatrices
     /// <summary>
     /// Gets a filter recreating Tritanomaly (Blue-Weak) color blindness.
     /// </summary>
-    public static ColorMatrix TritanomalyFilter { get; } = new ColorMatrix
+    public static ColorMatrix TritanomalyFilter { get; } = new()
     {
         M11 = .967F,
         M21 = .33F,
@@ -124,7 +124,7 @@ public static class KnownFilterMatrices
     /// <summary>
     /// Gets a filter recreating Tritanopia (Blue-Blind) color blindness.
     /// </summary>
-    public static ColorMatrix TritanopiaFilter { get; } = new ColorMatrix
+    public static ColorMatrix TritanopiaFilter { get; } = new()
     {
         M11 = .95F,
         M21 = .05F,
@@ -138,7 +138,7 @@ public static class KnownFilterMatrices
     /// <summary>
     /// Gets an approximated black and white filter
     /// </summary>
-    public static ColorMatrix BlackWhiteFilter { get; } = new ColorMatrix
+    public static ColorMatrix BlackWhiteFilter { get; } = new()
     {
         M11 = 1.5F,
         M12 = 1.5F,
@@ -190,7 +190,7 @@ public static class KnownFilterMatrices
     /// <summary>
     /// Gets a filter recreating an old Polaroid camera effect.
     /// </summary>
-    public static ColorMatrix PolaroidFilter { get; } = new ColorMatrix
+    public static ColorMatrix PolaroidFilter { get; } = new()
     {
         M11 = 1.538F,
         M12 = -.062F,
diff --git a/src/ImageSharp/Processing/Processors/CloningImageProcessor{TPixel}.cs b/src/ImageSharp/Processing/Processors/CloningImageProcessor{TPixel}.cs
index abe32e3882..b641dceb5f 100644
--- a/src/ImageSharp/Processing/Processors/CloningImageProcessor{TPixel}.cs
+++ b/src/ImageSharp/Processing/Processors/CloningImageProcessor{TPixel}.cs
@@ -1,6 +1,7 @@
 // Copyright (c) Six Labors.
 // Licensed under the Six Labors Split License.
 
+using System.Numerics;
 using SixLabors.ImageSharp.PixelFormats;
 
 namespace SixLabors.ImageSharp.Processing.Processors;
@@ -132,16 +133,14 @@ public abstract class CloningImageProcessor<TPixel> : ICloningImageProcessor<TPi
     /// <param name="source">The source image. Cannot be null.</param>
     /// <param name="destination">The cloned/destination image. Cannot be null.</param>
     protected virtual void AfterFrameApply(ImageFrame<TPixel> source, ImageFrame<TPixel> destination)
-    {
-    }
+        => destination.Metadata.AfterFrameApply(source, destination, Matrix4x4.Identity);
 
     /// <summary>
     /// This method is called after the process is applied to prepare the processor.
     /// </summary>
     /// <param name="destination">The cloned/destination image. Cannot be null.</param>
     protected virtual void AfterImageApply(Image<TPixel> destination)
-    {
-    }
+        => destination.Metadata.AfterImageApply(destination, Matrix4x4.Identity);
 
     /// <summary>
     /// Disposes the object and frees resources for the Garbage Collector.
diff --git a/src/ImageSharp/Processing/Processors/Convolution/BoxBlurProcessor{TPixel}.cs b/src/ImageSharp/Processing/Processors/Convolution/BoxBlurProcessor{TPixel}.cs
index ff3b30e9c1..727e8e96aa 100644
--- a/src/ImageSharp/Processing/Processors/Convolution/BoxBlurProcessor{TPixel}.cs
+++ b/src/ImageSharp/Processing/Processors/Convolution/BoxBlurProcessor{TPixel}.cs
@@ -68,7 +68,7 @@ internal class BoxBlurProcessor<TPixel> : ImageProcessor<TPixel>
     /// <inheritdoc/>
     protected override void OnFrameApply(ImageFrame<TPixel> source)
     {
-        using var processor = new Convolution2PassProcessor<TPixel>(this.Configuration, this.Kernel, false, this.Source, this.SourceRectangle, this.BorderWrapModeX, this.BorderWrapModeY);
+        using Convolution2PassProcessor<TPixel> processor = new(this.Configuration, this.Kernel, false, this.Source, this.SourceRectangle, this.BorderWrapModeX, this.BorderWrapModeY);
 
         processor.Apply(source);
     }
@@ -80,7 +80,7 @@ internal class BoxBlurProcessor<TPixel> : ImageProcessor<TPixel>
     /// <returns>The <see cref="DenseMatrix{T}"/>.</returns>
     private static float[] CreateBoxKernel(int kernelSize)
     {
-        var kernel = new float[kernelSize];
+        float[] kernel = new float[kernelSize];
 
         kernel.AsSpan().Fill(1F / kernelSize);
 
diff --git a/src/ImageSharp/Processing/Processors/Convolution/Convolution2DRowOperation{TPixel}.cs b/src/ImageSharp/Processing/Processors/Convolution/Convolution2DRowOperation{TPixel}.cs
index 2a4a1abf02..bccf191748 100644
--- a/src/ImageSharp/Processing/Processors/Convolution/Convolution2DRowOperation{TPixel}.cs
+++ b/src/ImageSharp/Processing/Processors/Convolution/Convolution2DRowOperation{TPixel}.cs
@@ -75,7 +75,7 @@ internal readonly struct Convolution2DRowOperation<TPixel> : IRowOperation<Vecto
         Span<Vector4> targetYBuffer = span.Slice(boundsWidth, boundsWidth);
         Span<Vector4> targetXBuffer = span.Slice(boundsWidth * 2, boundsWidth);
 
-        var state = new Convolution2DState(in this.kernelMatrixY, in this.kernelMatrixX, this.map);
+        Convolution2DState state = new(in this.kernelMatrixY, in this.kernelMatrixX, this.map);
         ref int sampleRowBase = ref state.GetSampleRow((uint)(y - this.bounds.Y));
 
         // Clear the target buffers for each row run.
@@ -141,7 +141,7 @@ internal readonly struct Convolution2DRowOperation<TPixel> : IRowOperation<Vecto
         Span<Vector4> targetYBuffer = span.Slice(boundsWidth, boundsWidth);
         Span<Vector4> targetXBuffer = span.Slice(boundsWidth * 2, boundsWidth);
 
-        var state = new Convolution2DState(in this.kernelMatrixY, in this.kernelMatrixX, this.map);
+        Convolution2DState state = new(in this.kernelMatrixY, in this.kernelMatrixX, this.map);
         ref int sampleRowBase = ref state.GetSampleRow((uint)(y - this.bounds.Y));
 
         // Clear the target buffers for each row run.
diff --git a/src/ImageSharp/Processing/Processors/Convolution/EdgeDetector2DProcessor{TPixel}.cs b/src/ImageSharp/Processing/Processors/Convolution/EdgeDetector2DProcessor{TPixel}.cs
index 5af4360442..502c344028 100644
--- a/src/ImageSharp/Processing/Processors/Convolution/EdgeDetector2DProcessor{TPixel}.cs
+++ b/src/ImageSharp/Processing/Processors/Convolution/EdgeDetector2DProcessor{TPixel}.cs
@@ -55,7 +55,7 @@ internal class EdgeDetector2DProcessor<TPixel> : ImageProcessor<TPixel>
     /// <inheritdoc />
     protected override void OnFrameApply(ImageFrame<TPixel> source)
     {
-        using var processor = new Convolution2DProcessor<TPixel>(
+        using Convolution2DProcessor<TPixel> processor = new(
             this.Configuration,
             in this.kernelX,
             in this.kernelY,
diff --git a/src/ImageSharp/Processing/Processors/Convolution/Kernels/EdgeDetectorCompassKernel.cs b/src/ImageSharp/Processing/Processors/Convolution/Kernels/EdgeDetectorCompassKernel.cs
index 0c456eb88e..1dbc666f6f 100644
--- a/src/ImageSharp/Processing/Processors/Convolution/Kernels/EdgeDetectorCompassKernel.cs
+++ b/src/ImageSharp/Processing/Processors/Convolution/Kernels/EdgeDetectorCompassKernel.cs
@@ -152,9 +152,8 @@ public readonly struct EdgeDetectorCompassKernel : IEquatable<EdgeDetectorCompas
             this.NorthEast);
 
     internal DenseMatrix<float>[] Flatten() =>
-         new[]
-             {
-                this.North, this.NorthWest, this.West, this.SouthWest,
+    [
+        this.North, this.NorthWest, this.West, this.SouthWest,
                 this.South, this.SouthEast, this.East, this.NorthEast
-             };
+    ];
 }
diff --git a/src/ImageSharp/Processing/Processors/Convolution/Kernels/Implementation/LaplacianKernelFactory.cs b/src/ImageSharp/Processing/Processors/Convolution/Kernels/Implementation/LaplacianKernelFactory.cs
index 7efcbf3a6c..b51ed1819e 100644
--- a/src/ImageSharp/Processing/Processors/Convolution/Kernels/Implementation/LaplacianKernelFactory.cs
+++ b/src/ImageSharp/Processing/Processors/Convolution/Kernels/Implementation/LaplacianKernelFactory.cs
@@ -19,7 +19,7 @@ internal static class LaplacianKernelFactory
         Guard.MustBeGreaterThanOrEqualTo(length, 3u, nameof(length));
         Guard.IsFalse(length % 2 == 0, nameof(length), "The kernel length must be an odd number.");
 
-        var kernel = new DenseMatrix<float>((int)length);
+        DenseMatrix<float> kernel = new((int)length);
         kernel.Fill(-1);
 
         int mid = (int)(length / 2);
diff --git a/src/ImageSharp/Processing/Processors/Convolution/Parameters/BokehBlurKernelDataProvider.cs b/src/ImageSharp/Processing/Processors/Convolution/Parameters/BokehBlurKernelDataProvider.cs
index 565a5746d1..4b3dd7fe73 100644
--- a/src/ImageSharp/Processing/Processors/Convolution/Parameters/BokehBlurKernelDataProvider.cs
+++ b/src/ImageSharp/Processing/Processors/Convolution/Parameters/BokehBlurKernelDataProvider.cs
@@ -16,66 +16,62 @@ internal static class BokehBlurKernelDataProvider
     /// <summary>
     /// The mapping of initialized complex kernels and parameters, to speed up the initialization of new <see cref="BokehBlurProcessor{TPixel}"/> instances
     /// </summary>
-    private static readonly ConcurrentDictionary<BokehBlurParameters, BokehBlurKernelData> Cache = new ConcurrentDictionary<BokehBlurParameters, BokehBlurKernelData>();
+    private static readonly ConcurrentDictionary<BokehBlurParameters, BokehBlurKernelData> Cache = new();
 
     /// <summary>
     /// Gets the kernel scales to adjust the component values in each kernel
     /// </summary>
-    private static float[] KernelScales { get; } = new[] { 1.4f, 1.2f, 1.2f, 1.2f, 1.2f, 1.2f };
+    private static float[] KernelScales { get; } = [1.4f, 1.2f, 1.2f, 1.2f, 1.2f, 1.2f];
 
     /// <summary>
     /// Gets the available bokeh blur kernel parameters
     /// </summary>
-    private static Vector4[][] KernelComponents { get; } = new[]
-    {
+    private static Vector4[][] KernelComponents { get; } =
+    [
+
         // 1 component
-        new[] { new Vector4(0.862325f, 1.624835f, 0.767583f, 1.862321f) },
+        [new Vector4(0.862325f, 1.624835f, 0.767583f, 1.862321f)],
 
         // 2 components
-        new[]
-        {
+        [
             new Vector4(0.886528f, 5.268909f, 0.411259f, -0.548794f),
             new Vector4(1.960518f, 1.558213f, 0.513282f, 4.56111f)
-        },
+        ],
 
         // 3 components
-        new[]
-        {
+        [
             new Vector4(2.17649f, 5.043495f, 1.621035f, -2.105439f),
             new Vector4(1.019306f, 9.027613f, -0.28086f, -0.162882f),
             new Vector4(2.81511f, 1.597273f, -0.366471f, 10.300301f)
-        },
+        ],
 
         // 4 components
-        new[]
-        {
+        [
             new Vector4(4.338459f, 1.553635f, -5.767909f, 46.164397f),
             new Vector4(3.839993f, 4.693183f, 9.795391f, -15.227561f),
             new Vector4(2.791880f, 8.178137f, -3.048324f, 0.302959f),
             new Vector4(1.342190f, 12.328289f, 0.010001f, 0.244650f)
-        },
+        ],
 
         // 5 components
-        new[]
-        {
+        [
             new Vector4(4.892608f, 1.685979f, -22.356787f, 85.91246f),
             new Vector4(4.71187f, 4.998496f, 35.918936f, -28.875618f),
             new Vector4(4.052795f, 8.244168f, -13.212253f, -1.578428f),
             new Vector4(2.929212f, 11.900859f, 0.507991f, 1.816328f),
             new Vector4(1.512961f, 16.116382f, 0.138051f, -0.01f)
-        },
+        ],
 
         // 6 components
-        new[]
-        {
+        [
             new Vector4(5.143778f, 2.079813f, -82.326596f, 111.231024f),
             new Vector4(5.612426f, 6.153387f, 113.878661f, 58.004879f),
             new Vector4(5.982921f, 9.802895f, 39.479083f, -162.028887f),
             new Vector4(6.505167f, 11.059237f, -71.286026f, 95.027069f),
             new Vector4(3.869579f, 14.81052f, 1.405746f, -3.704914f),
             new Vector4(2.201904f, 19.032909f, -0.152784f, -0.107988f)
-        }
-    };
+        ]
+    ];
 
     /// <summary>
     /// Gets the bokeh blur kernel data for the specified parameters.
@@ -90,7 +86,7 @@ internal static class BokehBlurKernelDataProvider
         int componentsCount)
     {
         // Reuse the initialized values from the cache, if possible
-        var parameters = new BokehBlurParameters(radius, componentsCount);
+        BokehBlurParameters parameters = new(radius, componentsCount);
         if (!Cache.TryGetValue(parameters, out BokehBlurKernelData info))
         {
             // Initialize the complex kernels and parameters with the current arguments
@@ -130,7 +126,7 @@ internal static class BokehBlurKernelDataProvider
         int kernelSize,
         float kernelsScale)
     {
-        var kernels = new Complex64[kernelParameters.Length][];
+        Complex64[][] kernels = new Complex64[kernelParameters.Length][];
         ref Vector4 baseRef = ref MemoryMarshal.GetReference(kernelParameters.AsSpan());
         for (int i = 0; i < kernelParameters.Length; i++)
         {
@@ -156,7 +152,7 @@ internal static class BokehBlurKernelDataProvider
         float a,
         float b)
     {
-        var kernel = new Complex64[kernelSize];
+        Complex64[] kernel = new Complex64[kernelSize];
         ref Complex64 baseRef = ref MemoryMarshal.GetReference(kernel.AsSpan());
         int r = radius, n = -r;
 
diff --git a/src/ImageSharp/Processing/Processors/Dithering/ErroDither.KnownTypes.cs b/src/ImageSharp/Processing/Processors/Dithering/ErrorDither.KnownTypes.cs
similarity index 100%
rename from src/ImageSharp/Processing/Processors/Dithering/ErroDither.KnownTypes.cs
rename to src/ImageSharp/Processing/Processors/Dithering/ErrorDither.KnownTypes.cs
diff --git a/src/ImageSharp/Processing/Processors/Dithering/IDither.cs b/src/ImageSharp/Processing/Processors/Dithering/IDither.cs
index ac2921b98d..3217601270 100644
--- a/src/ImageSharp/Processing/Processors/Dithering/IDither.cs
+++ b/src/ImageSharp/Processing/Processors/Dithering/IDither.cs
@@ -21,7 +21,7 @@ public interface IDither
     /// <param name="source">The source image.</param>
     /// <param name="destination">The destination quantized frame.</param>
     /// <param name="bounds">The region of interest bounds.</param>
-    void ApplyQuantizationDither<TFrameQuantizer, TPixel>(
+    public void ApplyQuantizationDither<TFrameQuantizer, TPixel>(
         ref TFrameQuantizer quantizer,
         ImageFrame<TPixel> source,
         IndexedImageFrame<TPixel> destination,
@@ -38,7 +38,7 @@ public interface IDither
     /// <param name="processor">The palette dithering processor.</param>
     /// <param name="source">The source image.</param>
     /// <param name="bounds">The region of interest bounds.</param>
-    void ApplyPaletteDither<TPaletteDitherImageProcessor, TPixel>(
+    public void ApplyPaletteDither<TPaletteDitherImageProcessor, TPixel>(
         in TPaletteDitherImageProcessor processor,
         ImageFrame<TPixel> source,
         Rectangle bounds)
diff --git a/src/ImageSharp/Processing/Processors/Dithering/IPaletteDitherImageProcessor{TPixel}.cs b/src/ImageSharp/Processing/Processors/Dithering/IPaletteDitherImageProcessor{TPixel}.cs
index e406d82c69..347e2f0ef6 100644
--- a/src/ImageSharp/Processing/Processors/Dithering/IPaletteDitherImageProcessor{TPixel}.cs
+++ b/src/ImageSharp/Processing/Processors/Dithering/IPaletteDitherImageProcessor{TPixel}.cs
@@ -15,22 +15,22 @@ public interface IPaletteDitherImageProcessor<TPixel>
     /// <summary>
     /// Gets the configuration instance to use when performing operations.
     /// </summary>
-    Configuration Configuration { get; }
+    public Configuration Configuration { get; }
 
     /// <summary>
     /// Gets the dithering palette.
     /// </summary>
-    ReadOnlyMemory<TPixel> Palette { get; }
+    public ReadOnlyMemory<TPixel> Palette { get; }
 
     /// <summary>
     /// Gets the dithering scale used to adjust the amount of dither. Range 0..1.
     /// </summary>
-    float DitherScale { get; }
+    public float DitherScale { get; }
 
     /// <summary>
     /// Returns the color from the dithering palette corresponding to the given color.
     /// </summary>
     /// <param name="color">The color to match.</param>
     /// <returns>The <typeparamref name="TPixel"/> match.</returns>
-    TPixel GetPaletteColor(TPixel color);
+    public TPixel GetPaletteColor(TPixel color);
 }
diff --git a/src/ImageSharp/Processing/Processors/Dithering/OrderedDither.cs b/src/ImageSharp/Processing/Processors/Dithering/OrderedDither.cs
index d1f46c7441..b0622cac58 100644
--- a/src/ImageSharp/Processing/Processors/Dithering/OrderedDither.cs
+++ b/src/ImageSharp/Processing/Processors/Dithering/OrderedDither.cs
@@ -32,7 +32,7 @@ public readonly partial struct OrderedDither : IDither, IEquatable<OrderedDither
         // We don't want to adjust the original matrix generation code as that
         // creates known, easy to test values.
         // https://en.wikipedia.org/wiki/Ordered_dithering#Algorithm
-        var thresholdMatrix = new DenseMatrix<float>((int)length);
+        DenseMatrix<float> thresholdMatrix = new((int)length);
         float m2 = length * length;
         for (int y = 0; y < length; y++)
         {
diff --git a/src/ImageSharp/Processing/Processors/Dithering/OrderedDitherFactory.cs b/src/ImageSharp/Processing/Processors/Dithering/OrderedDitherFactory.cs
index 7f8b347243..ec82f01d7a 100644
--- a/src/ImageSharp/Processing/Processors/Dithering/OrderedDitherFactory.cs
+++ b/src/ImageSharp/Processing/Processors/Dithering/OrderedDitherFactory.cs
@@ -29,7 +29,7 @@ internal static class OrderedDitherFactory
         while (length > bayerLength);
 
         // Create our Bayer matrix that matches the given exponent and dimensions
-        var matrix = new DenseMatrix<uint>((int)length);
+        DenseMatrix<uint> matrix = new((int)length);
         uint i = 0;
         for (int y = 0; y < length; y++)
         {
diff --git a/src/ImageSharp/Processing/Processors/Dithering/PaletteDitherProcessor{TPixel}.cs b/src/ImageSharp/Processing/Processors/Dithering/PaletteDitherProcessor{TPixel}.cs
index 7e672393c7..0d4680e21f 100644
--- a/src/ImageSharp/Processing/Processors/Dithering/PaletteDitherProcessor{TPixel}.cs
+++ b/src/ImageSharp/Processing/Processors/Dithering/PaletteDitherProcessor{TPixel}.cs
@@ -80,7 +80,7 @@ internal sealed class PaletteDitherProcessor<TPixel> : ImageProcessor<TPixel>
         Justification = "https://github.com/dotnet/roslyn-analyzers/issues/6151")]
     internal readonly struct DitherProcessor : IPaletteDitherImageProcessor<TPixel>, IDisposable
     {
-        private readonly EuclideanPixelMap<TPixel> pixelMap;
+        private readonly PixelMap<TPixel> pixelMap;
 
         [MethodImpl(InliningOptions.ShortMethod)]
         public DitherProcessor(
@@ -89,7 +89,7 @@ internal sealed class PaletteDitherProcessor<TPixel> : ImageProcessor<TPixel>
             float ditherScale)
         {
             this.Configuration = configuration;
-            this.pixelMap = new EuclideanPixelMap<TPixel>(configuration, palette);
+            this.pixelMap = PixelMapFactory.Create(configuration, palette, ColorMatchingMode.Coarse);
             this.Palette = palette;
             this.DitherScale = ditherScale;
         }
diff --git a/src/ImageSharp/Processing/Processors/Drawing/DrawImageProcessor{TPixelBg,TPixelFg}.cs b/src/ImageSharp/Processing/Processors/Drawing/DrawImageProcessor{TPixelBg,TPixelFg}.cs
index d5499d5865..d2a99ce921 100644
--- a/src/ImageSharp/Processing/Processors/Drawing/DrawImageProcessor{TPixelBg,TPixelFg}.cs
+++ b/src/ImageSharp/Processing/Processors/Drawing/DrawImageProcessor{TPixelBg,TPixelFg}.cs
@@ -112,7 +112,7 @@ internal class DrawImageProcessor<TPixelBg, TPixelFg> : ImageProcessor<TPixelBg>
         }
 
         // Sanitize the dimensions so that we don't try and sample outside the image.
-        Rectangle backgroundRectangle = Rectangle.Intersect(new(left, top, width, height), this.SourceRectangle);
+        Rectangle backgroundRectangle = Rectangle.Intersect(new Rectangle(left, top, width, height), this.SourceRectangle);
         Configuration configuration = this.Configuration;
 
         DrawImageProcessor<TPixelBg, TPixelFg>.RowOperation operation =
@@ -127,7 +127,7 @@ internal class DrawImageProcessor<TPixelBg, TPixelFg> : ImageProcessor<TPixelBg>
 
         ParallelRowIterator.IterateRows(
             configuration,
-            new(0, 0, foregroundRectangle.Width, foregroundRectangle.Height),
+            new Rectangle(0, 0, foregroundRectangle.Width, foregroundRectangle.Height),
             in operation);
     }
 
diff --git a/src/ImageSharp/Processing/Processors/ImageProcessor{TPixel}.cs b/src/ImageSharp/Processing/Processors/ImageProcessor{TPixel}.cs
index 2fa79220e5..3510fe7a8e 100644
--- a/src/ImageSharp/Processing/Processors/ImageProcessor{TPixel}.cs
+++ b/src/ImageSharp/Processing/Processors/ImageProcessor{TPixel}.cs
@@ -1,6 +1,7 @@
 // Copyright (c) Six Labors.
 // Licensed under the Six Labors Split License.
 
+using System.Numerics;
 using SixLabors.ImageSharp.PixelFormats;
 
 namespace SixLabors.ImageSharp.Processing.Processors;
@@ -95,19 +96,17 @@ public abstract class ImageProcessor<TPixel> : IImageProcessor<TPixel>
     protected abstract void OnFrameApply(ImageFrame<TPixel> source);
 
     /// <summary>
-    /// This method is called after the process is applied to prepare the processor.
+    /// This method is called after the process is applied to each frame.
     /// </summary>
     /// <param name="source">The source image. Cannot be null.</param>
     protected virtual void AfterFrameApply(ImageFrame<TPixel> source)
-    {
-    }
+        => source.Metadata.AfterFrameApply(source, source, Matrix4x4.Identity);
 
     /// <summary>
-    /// This method is called after the process is applied to prepare the processor.
+    /// This method is called after the process is applied to the complete image.
     /// </summary>
     protected virtual void AfterImageApply()
-    {
-    }
+        => this.Source.Metadata.AfterImageApply(this.Source, Matrix4x4.Identity);
 
     /// <summary>
     /// Disposes the object and frees resources for the Garbage Collector.
diff --git a/src/ImageSharp/Processing/Processors/Normalization/AdaptiveHistogramEqualizationProcessor{TPixel}.cs b/src/ImageSharp/Processing/Processors/Normalization/AdaptiveHistogramEqualizationProcessor{TPixel}.cs
index 78085eaab5..3d54836c5b 100644
--- a/src/ImageSharp/Processing/Processors/Normalization/AdaptiveHistogramEqualizationProcessor{TPixel}.cs
+++ b/src/ImageSharp/Processing/Processors/Normalization/AdaptiveHistogramEqualizationProcessor{TPixel}.cs
@@ -145,7 +145,7 @@ internal class AdaptiveHistogramEqualizationProcessor<TPixel> : HistogramEqualiz
             {
                 ref TPixel pixel = ref rowSpan[dx];
                 float luminanceEqualized = cdfData.RemapGreyValue(cdfX, cdfY, GetLuminance(pixel, luminanceLevels));
-                pixel = TPixel.FromVector4(new(luminanceEqualized, luminanceEqualized, luminanceEqualized, pixel.ToVector4().W));
+                pixel = TPixel.FromVector4(new Vector4(luminanceEqualized, luminanceEqualized, luminanceEqualized, pixel.ToVector4().W));
             }
         }
     }
diff --git a/src/ImageSharp/Processing/Processors/Normalization/AdaptiveHistogramEqualizationSlidingWindowProcessor{TPixel}.cs b/src/ImageSharp/Processing/Processors/Normalization/AdaptiveHistogramEqualizationSlidingWindowProcessor{TPixel}.cs
index 93144653e3..8ca4a86a28 100644
--- a/src/ImageSharp/Processing/Processors/Normalization/AdaptiveHistogramEqualizationSlidingWindowProcessor{TPixel}.cs
+++ b/src/ImageSharp/Processing/Processors/Normalization/AdaptiveHistogramEqualizationSlidingWindowProcessor{TPixel}.cs
@@ -383,7 +383,7 @@ internal class AdaptiveHistogramEqualizationSlidingWindowProcessor<TPixel> : His
                     // Map the current pixel to the new equalized value.
                     int luminance = GetLuminance(this.source[x, y], this.processor.LuminanceLevels);
                     float luminanceEqualized = Unsafe.Add(ref cdfBase, (uint)luminance) / numberOfPixelsMinusCdfMin;
-                    this.targetPixels[x, y] = TPixel.FromVector4(new(luminanceEqualized, luminanceEqualized, luminanceEqualized, this.source[x, y].ToVector4().W));
+                    this.targetPixels[x, y] = TPixel.FromVector4(new Vector4(luminanceEqualized, luminanceEqualized, luminanceEqualized, this.source[x, y].ToVector4().W));
 
                     // Remove top most row from the histogram, mirroring rows which exceeds the borders.
                     if (this.useFastPath)
diff --git a/src/ImageSharp/Processing/Processors/Normalization/AutoLevelProcessor{TPixel}.cs b/src/ImageSharp/Processing/Processors/Normalization/AutoLevelProcessor{TPixel}.cs
index 606789af96..e830cc55fc 100644
--- a/src/ImageSharp/Processing/Processors/Normalization/AutoLevelProcessor{TPixel}.cs
+++ b/src/ImageSharp/Processing/Processors/Normalization/AutoLevelProcessor{TPixel}.cs
@@ -150,7 +150,7 @@ internal class AutoLevelProcessor<TPixel> : HistogramEqualizationProcessor<TPixe
                 int luminance = ColorNumerics.GetBT709Luminance(ref vector, levels);
                 float scaledLuminance = Unsafe.Add(ref cdfBase, (uint)luminance) / noOfPixelsMinusCdfMin;
                 float scalingFactor = scaledLuminance * levels / luminance;
-                Unsafe.Add(ref vectorRef, (uint)x) = new(scalingFactor * vector.X, scalingFactor * vector.Y, scalingFactor * vector.Z, vector.W);
+                Unsafe.Add(ref vectorRef, (uint)x) = new Vector4(scalingFactor * vector.X, scalingFactor * vector.Y, scalingFactor * vector.Z, vector.W);
             }
 
             PixelOperations<TPixel>.Instance.FromVector4Destructive(this.configuration, vectorBuffer, pixelRow);
diff --git a/src/ImageSharp/Processing/Processors/Normalization/GrayscaleLevelsRowOperation{TPixel}.cs b/src/ImageSharp/Processing/Processors/Normalization/GrayscaleLevelsRowOperation{TPixel}.cs
index 0a8690ba70..3584f2954a 100644
--- a/src/ImageSharp/Processing/Processors/Normalization/GrayscaleLevelsRowOperation{TPixel}.cs
+++ b/src/ImageSharp/Processing/Processors/Normalization/GrayscaleLevelsRowOperation{TPixel}.cs
@@ -56,7 +56,7 @@ internal readonly struct GrayscaleLevelsRowOperation<TPixel> : IRowOperation<Vec
 
         for (int x = 0; x < this.bounds.Width; x++)
         {
-            var vector = Unsafe.Add(ref vectorRef, (uint)x);
+            Vector4 vector = Unsafe.Add(ref vectorRef, (uint)x);
             int luminance = ColorNumerics.GetBT709Luminance(ref vector, levels);
             Interlocked.Increment(ref Unsafe.Add(ref histogramBase, (uint)luminance));
         }
diff --git a/src/ImageSharp/Processing/Processors/Quantization/ColorMatchingMode.cs b/src/ImageSharp/Processing/Processors/Quantization/ColorMatchingMode.cs
new file mode 100644
index 0000000000..26fd7d5d76
--- /dev/null
+++ b/src/ImageSharp/Processing/Processors/Quantization/ColorMatchingMode.cs
@@ -0,0 +1,28 @@
+// Copyright (c) Six Labors.
+// Licensed under the Six Labors Split License.
+
+namespace SixLabors.ImageSharp.Processing.Processors.Quantization;
+
+/// <summary>
+/// Defines the precision level used when matching colors during quantization.
+/// </summary>
+public enum ColorMatchingMode
+{
+    /// <summary>
+    /// Uses a coarse caching strategy optimized for performance at the expense of exact matches.
+    /// This provides the fastest matching but may yield approximate results.
+    /// </summary>
+    Coarse,
+
+    /// <summary>
+    /// Enables an exact color match cache for the first 512 unique colors encountered,
+    /// falling back to coarse matching thereafter.
+    /// </summary>
+    Hybrid,
+
+    /// <summary>
+    /// Performs exact color matching without any caching optimizations.
+    /// This is the slowest but most accurate matching strategy.
+    /// </summary>
+    Exact
+}
diff --git a/src/ImageSharp/Processing/Processors/Quantization/EuclideanPixelMap{TPixel,TCache}.cs b/src/ImageSharp/Processing/Processors/Quantization/EuclideanPixelMap{TPixel,TCache}.cs
new file mode 100644
index 0000000000..5b0c7252cb
--- /dev/null
+++ b/src/ImageSharp/Processing/Processors/Quantization/EuclideanPixelMap{TPixel,TCache}.cs
@@ -0,0 +1,184 @@
+// Copyright (c) Six Labors.
+// Licensed under the Six Labors Split License.
+
+using System.Runtime.CompilerServices;
+using System.Runtime.InteropServices;
+using SixLabors.ImageSharp.PixelFormats;
+
+namespace SixLabors.ImageSharp.Processing.Processors.Quantization;
+
+/// <summary>
+/// Gets the closest color to the supplied color based upon the Euclidean distance.
+/// </summary>
+/// <typeparam name="TPixel">The pixel format.</typeparam>
+/// <typeparam name="TCache">The cache type.</typeparam>
+/// <para>
+/// This class is not thread safe and should not be accessed in parallel.
+/// Doing so will result in non-idempotent results.
+/// </para>
+internal sealed class EuclideanPixelMap<TPixel, TCache> : PixelMap<TPixel>
+    where TPixel : unmanaged, IPixel<TPixel>
+    where TCache : struct, IColorIndexCache<TCache>
+{
+    private Rgba32[] rgbaPalette;
+
+    // Do not make readonly. It's a mutable struct.
+#pragma warning disable IDE0044 // Add readonly modifier
+    private TCache cache;
+#pragma warning restore IDE0044 // Add readonly modifier
+
+    private readonly Configuration configuration;
+
+    /// <summary>
+    /// Initializes a new instance of the <see cref="EuclideanPixelMap{TPixel, TCache}"/> class.
+    /// </summary>
+    /// <param name="configuration">Specifies the settings and resources for the pixel map's operations.</param>
+    /// <param name="palette">Defines the color palette used for pixel mapping.</param>
+    public EuclideanPixelMap(Configuration configuration, ReadOnlyMemory<TPixel> palette)
+    {
+        this.configuration = configuration;
+        this.Palette = palette;
+        this.rgbaPalette = new Rgba32[palette.Length];
+        this.cache = TCache.Create(configuration.MemoryAllocator);
+        PixelOperations<TPixel>.Instance.ToRgba32(configuration, this.Palette.Span, this.rgbaPalette);
+    }
+
+    /// <inheritdoc/>
+    [MethodImpl(InliningOptions.ShortMethod)]
+    public override int GetClosestColor(TPixel color, out TPixel match)
+    {
+        ref TPixel paletteRef = ref MemoryMarshal.GetReference(this.Palette.Span);
+        Rgba32 rgba = color.ToRgba32();
+
+        if (this.cache.TryGetValue(rgba, out short index))
+        {
+            match = Unsafe.Add(ref paletteRef, (ushort)index);
+            return index;
+        }
+
+        return this.GetClosestColorSlow(rgba, ref paletteRef, out match);
+    }
+
+    /// <inheritdoc/>
+    public override void Clear(ReadOnlyMemory<TPixel> palette)
+    {
+        this.Palette = palette;
+        this.rgbaPalette = new Rgba32[palette.Length];
+        PixelOperations<TPixel>.Instance.ToRgba32(this.configuration, this.Palette.Span, this.rgbaPalette);
+        this.cache.Clear();
+    }
+
+    [MethodImpl(InliningOptions.ColdPath)]
+    private int GetClosestColorSlow(Rgba32 rgba, ref TPixel paletteRef, out TPixel match)
+    {
+        // Loop through the palette and find the nearest match.
+        int index = 0;
+        float leastDistance = float.MaxValue;
+        for (int i = 0; i < this.rgbaPalette.Length; i++)
+        {
+            Rgba32 candidate = this.rgbaPalette[i];
+            if (candidate.PackedValue == rgba.PackedValue)
+            {
+                index = i;
+                break;
+            }
+
+            float distance = DistanceSquared(rgba, candidate);
+            if (distance == 0)
+            {
+                index = i;
+                break;
+            }
+
+            if (distance < leastDistance)
+            {
+                index = i;
+                leastDistance = distance;
+            }
+        }
+
+        // Now I have the index, pop it into the cache for next time
+        _ = this.cache.TryAdd(rgba, (short)index);
+        match = Unsafe.Add(ref paletteRef, (uint)index);
+
+        return index;
+    }
+
+    /// <summary>
+    /// Returns the Euclidean distance squared between two specified points.
+    /// </summary>
+    /// <param name="a">The first point.</param>
+    /// <param name="b">The second point.</param>
+    /// <returns>The distance squared.</returns>
+    [MethodImpl(InliningOptions.ShortMethod)]
+    private static float DistanceSquared(Rgba32 a, Rgba32 b)
+    {
+        float deltaR = a.R - b.R;
+        float deltaG = a.G - b.G;
+        float deltaB = a.B - b.B;
+        float deltaA = a.A - b.A;
+        return (deltaR * deltaR) + (deltaG * deltaG) + (deltaB * deltaB) + (deltaA * deltaA);
+    }
+
+    /// <inheritdoc/>
+    public override void Dispose() => this.cache.Dispose();
+}
+
+/// <summary>
+/// Represents a map of colors to indices.
+/// </summary>
+/// <typeparam name="TPixel">The pixel format.</typeparam>
+internal abstract class PixelMap<TPixel> : IDisposable
+    where TPixel : unmanaged, IPixel<TPixel>
+{
+    /// <summary>
+    /// Gets the color palette of this <see cref="PixelMap{TPixel}"/>.
+    /// </summary>
+    public ReadOnlyMemory<TPixel> Palette { get; private protected set; }
+
+    /// <summary>
+    /// Returns the closest color in the palette and the index of that pixel.
+    /// </summary>
+    /// <param name="color">The color to match.</param>
+    /// <param name="match">The matched color.</param>
+    /// <returns>
+    /// The <see cref="int"/> index.
+    /// </returns>
+    public abstract int GetClosestColor(TPixel color, out TPixel match);
+
+    /// <summary>
+    /// Clears the map, resetting it to use the given palette.
+    /// </summary>
+    /// <param name="palette">The color palette to map from.</param>
+    public abstract void Clear(ReadOnlyMemory<TPixel> palette);
+
+    /// <inheritdoc/>
+    public abstract void Dispose();
+}
+
+/// <summary>
+/// A factory for creating <see cref="PixelMap{TPixel}"/> instances.
+/// </summary>
+internal static class PixelMapFactory
+{
+    /// <summary>
+    /// Creates a new <see cref="PixelMap{TPixel}"/> instance.
+    /// </summary>
+    /// <typeparam name="TPixel">The pixel format.</typeparam>
+    /// <param name="configuration">The configuration.</param>
+    /// <param name="palette">The color palette to map from.</param>
+    /// <param name="colorMatchingMode">The color matching mode.</param>
+    /// <returns>
+    /// The <see cref="PixelMap{TPixel}"/>.
+    /// </returns>
+    public static PixelMap<TPixel> Create<TPixel>(
+        Configuration configuration,
+        ReadOnlyMemory<TPixel> palette,
+        ColorMatchingMode colorMatchingMode)
+        where TPixel : unmanaged, IPixel<TPixel> => colorMatchingMode switch
+        {
+            ColorMatchingMode.Hybrid => new EuclideanPixelMap<TPixel, HybridCache>(configuration, palette),
+            ColorMatchingMode.Exact => new EuclideanPixelMap<TPixel, NullCache>(configuration, palette),
+            _ => new EuclideanPixelMap<TPixel, CoarseCache>(configuration, palette),
+        };
+}
diff --git a/src/ImageSharp/Processing/Processors/Quantization/EuclideanPixelMap{TPixel}.cs b/src/ImageSharp/Processing/Processors/Quantization/EuclideanPixelMap{TPixel}.cs
deleted file mode 100644
index 4fd37d479d..0000000000
--- a/src/ImageSharp/Processing/Processors/Quantization/EuclideanPixelMap{TPixel}.cs
+++ /dev/null
@@ -1,258 +0,0 @@
-// Copyright (c) Six Labors.
-// Licensed under the Six Labors Split License.
-
-using System.Buffers;
-using System.Runtime.CompilerServices;
-using System.Runtime.InteropServices;
-using SixLabors.ImageSharp.Memory;
-using SixLabors.ImageSharp.PixelFormats;
-
-namespace SixLabors.ImageSharp.Processing.Processors.Quantization;
-
-/// <summary>
-/// Gets the closest color to the supplied color based upon the Euclidean distance.
-/// </summary>
-/// <typeparam name="TPixel">The pixel format.</typeparam>
-/// <para>
-/// This class is not thread safe and should not be accessed in parallel.
-/// Doing so will result in non-idempotent results.
-/// </para>
-internal sealed class EuclideanPixelMap<TPixel> : IDisposable
-    where TPixel : unmanaged, IPixel<TPixel>
-{
-    private Rgba32[] rgbaPalette;
-    private int transparentIndex;
-    private readonly TPixel transparentMatch;
-
-    /// <summary>
-    /// Do not make this readonly! Struct value would be always copied on non-readonly method calls.
-    /// </summary>
-    private ColorDistanceCache cache;
-    private readonly Configuration configuration;
-
-    /// <summary>
-    /// Initializes a new instance of the <see cref="EuclideanPixelMap{TPixel}"/> class.
-    /// </summary>
-    /// <param name="configuration">The configuration.</param>
-    /// <param name="palette">The color palette to map from.</param>
-    public EuclideanPixelMap(Configuration configuration, ReadOnlyMemory<TPixel> palette)
-        : this(configuration, palette, -1)
-    {
-    }
-
-    /// <summary>
-    /// Initializes a new instance of the <see cref="EuclideanPixelMap{TPixel}"/> class.
-    /// </summary>
-    /// <param name="configuration">The configuration.</param>
-    /// <param name="palette">The color palette to map from.</param>
-    /// <param name="transparentIndex">An explicit index at which to match transparent pixels.</param>
-    public EuclideanPixelMap(Configuration configuration, ReadOnlyMemory<TPixel> palette, int transparentIndex = -1)
-    {
-        this.configuration = configuration;
-        this.Palette = palette;
-        this.rgbaPalette = new Rgba32[palette.Length];
-        this.cache = new ColorDistanceCache(configuration.MemoryAllocator);
-        PixelOperations<TPixel>.Instance.ToRgba32(configuration, this.Palette.Span, this.rgbaPalette);
-
-        this.transparentIndex = transparentIndex;
-        this.transparentMatch = TPixel.FromRgba32(default);
-    }
-
-    /// <summary>
-    /// Gets the color palette of this <see cref="EuclideanPixelMap{TPixel}"/>.
-    /// The palette memory is owned by the palette source that created it.
-    /// </summary>
-    public ReadOnlyMemory<TPixel> Palette { get; private set; }
-
-    /// <summary>
-    /// Returns the closest color in the palette and the index of that pixel.
-    /// The palette contents must match the one used in the constructor.
-    /// </summary>
-    /// <param name="color">The color to match.</param>
-    /// <param name="match">The matched color.</param>
-    /// <returns>The <see cref="int"/> index.</returns>
-    [MethodImpl(InliningOptions.ShortMethod)]
-    public int GetClosestColor(TPixel color, out TPixel match)
-    {
-        ref TPixel paletteRef = ref MemoryMarshal.GetReference(this.Palette.Span);
-        Rgba32 rgba = color.ToRgba32();
-
-        // Check if the color is in the lookup table
-        if (!this.cache.TryGetValue(rgba, out short index))
-        {
-            return this.GetClosestColorSlow(rgba, ref paletteRef, out match);
-        }
-
-        match = Unsafe.Add(ref paletteRef, (ushort)index);
-        return index;
-    }
-
-    /// <summary>
-    /// Clears the map, resetting it to use the given palette.
-    /// </summary>
-    /// <param name="palette">The color palette to map from.</param>
-    public void Clear(ReadOnlyMemory<TPixel> palette)
-    {
-        this.Palette = palette;
-        this.rgbaPalette = new Rgba32[palette.Length];
-        PixelOperations<TPixel>.Instance.ToRgba32(this.configuration, this.Palette.Span, this.rgbaPalette);
-        this.transparentIndex = -1;
-        this.cache.Clear();
-    }
-
-    /// <summary>
-    /// Allows setting the transparent index after construction.
-    /// </summary>
-    /// <param name="index">An explicit index at which to match transparent pixels.</param>
-    public void SetTransparentIndex(int index)
-    {
-        if (index != this.transparentIndex)
-        {
-            this.cache.Clear();
-        }
-
-        this.transparentIndex = index;
-    }
-
-    [MethodImpl(InliningOptions.ShortMethod)]
-    private int GetClosestColorSlow(Rgba32 rgba, ref TPixel paletteRef, out TPixel match)
-    {
-        // Loop through the palette and find the nearest match.
-        int index = 0;
-
-        if (this.transparentIndex >= 0 && rgba == default)
-        {
-            // We have explicit instructions. No need to search.
-            index = this.transparentIndex;
-            this.cache.Add(rgba, (byte)index);
-            match = this.transparentMatch;
-            return index;
-        }
-
-        float leastDistance = float.MaxValue;
-        for (int i = 0; i < this.rgbaPalette.Length; i++)
-        {
-            Rgba32 candidate = this.rgbaPalette[i];
-            float distance = DistanceSquared(rgba, candidate);
-
-            // If it's an exact match, exit the loop
-            if (distance == 0)
-            {
-                index = i;
-                break;
-            }
-
-            if (distance < leastDistance)
-            {
-                // Less than... assign.
-                index = i;
-                leastDistance = distance;
-            }
-        }
-
-        // Now I have the index, pop it into the cache for next time
-        this.cache.Add(rgba, (byte)index);
-        match = Unsafe.Add(ref paletteRef, (uint)index);
-        return index;
-    }
-
-    /// <summary>
-    /// Returns the Euclidean distance squared between two specified points.
-    /// </summary>
-    /// <param name="a">The first point.</param>
-    /// <param name="b">The second point.</param>
-    /// <returns>The distance squared.</returns>
-    [MethodImpl(InliningOptions.ShortMethod)]
-    private static float DistanceSquared(Rgba32 a, Rgba32 b)
-    {
-        float deltaR = a.R - b.R;
-        float deltaG = a.G - b.G;
-        float deltaB = a.B - b.B;
-        float deltaA = a.A - b.A;
-        return (deltaR * deltaR) + (deltaG * deltaG) + (deltaB * deltaB) + (deltaA * deltaA);
-    }
-
-    public void Dispose() => this.cache.Dispose();
-
-    /// <summary>
-    /// A cache for storing color distance matching results.
-    /// </summary>
-    /// <remarks>
-    /// <para>
-    /// The granularity of the cache has been determined based upon the current
-    /// suite of test images and provides the lowest possible memory usage while
-    /// providing enough match accuracy.
-    /// Entry count is currently limited to 2335905 entries (4MB).
-    /// </para>
-    /// </remarks>
-    private unsafe struct ColorDistanceCache : IDisposable
-    {
-        private const int IndexRBits = 5;
-        private const int IndexGBits = 5;
-        private const int IndexBBits = 5;
-        private const int IndexABits = 6;
-        private const int IndexRCount = (1 << IndexRBits) + 1;
-        private const int IndexGCount = (1 << IndexGBits) + 1;
-        private const int IndexBCount = (1 << IndexBBits) + 1;
-        private const int IndexACount = (1 << IndexABits) + 1;
-        private const int RShift = 8 - IndexRBits;
-        private const int GShift = 8 - IndexGBits;
-        private const int BShift = 8 - IndexBBits;
-        private const int AShift = 8 - IndexABits;
-        private const int Entries = IndexRCount * IndexGCount * IndexBCount * IndexACount;
-        private MemoryHandle tableHandle;
-        private readonly IMemoryOwner<short> table;
-        private readonly short* tablePointer;
-
-        public ColorDistanceCache(MemoryAllocator allocator)
-        {
-            this.table = allocator.Allocate<short>(Entries);
-            this.table.GetSpan().Fill(-1);
-            this.tableHandle = this.table.Memory.Pin();
-            this.tablePointer = (short*)this.tableHandle.Pointer;
-        }
-
-        [MethodImpl(InliningOptions.ShortMethod)]
-        public readonly void Add(Rgba32 rgba, byte index)
-        {
-            int idx = GetPaletteIndex(rgba);
-            this.tablePointer[idx] = index;
-        }
-
-        [MethodImpl(InliningOptions.ShortMethod)]
-        public readonly bool TryGetValue(Rgba32 rgba, out short match)
-        {
-            int idx = GetPaletteIndex(rgba);
-            match = this.tablePointer[idx];
-            return match > -1;
-        }
-
-        /// <summary>
-        /// Clears the cache resetting each entry to empty.
-        /// </summary>
-        [MethodImpl(InliningOptions.ShortMethod)]
-        public readonly void Clear() => this.table.GetSpan().Fill(-1);
-
-        [MethodImpl(InliningOptions.ShortMethod)]
-        private static int GetPaletteIndex(Rgba32 rgba)
-        {
-            int rIndex = rgba.R >> RShift;
-            int gIndex = rgba.G >> GShift;
-            int bIndex = rgba.B >> BShift;
-            int aIndex = rgba.A >> AShift;
-
-            return (aIndex * (IndexRCount * IndexGCount * IndexBCount)) +
-                   (rIndex * (IndexGCount * IndexBCount)) +
-                   (gIndex * IndexBCount) + bIndex;
-        }
-
-        public void Dispose()
-        {
-            if (this.table != null)
-            {
-                this.tableHandle.Dispose();
-                this.table.Dispose();
-            }
-        }
-    }
-}
diff --git a/src/ImageSharp/Processing/Processors/Quantization/IColorIndexCache.cs b/src/ImageSharp/Processing/Processors/Quantization/IColorIndexCache.cs
new file mode 100644
index 0000000000..32d95137bc
--- /dev/null
+++ b/src/ImageSharp/Processing/Processors/Quantization/IColorIndexCache.cs
@@ -0,0 +1,569 @@
+// Copyright (c) Six Labors.
+// Licensed under the Six Labors Split License.
+
+using System.Buffers;
+using System.Runtime.CompilerServices;
+using SixLabors.ImageSharp.Memory;
+using SixLabors.ImageSharp.PixelFormats;
+
+namespace SixLabors.ImageSharp.Processing.Processors.Quantization;
+
+/// <summary>
+/// Represents a cache used for efficiently retrieving palette indices for colors.
+/// </summary>
+internal interface IColorIndexCache : IDisposable
+{
+    /// <summary>
+    /// Adds a color to the cache.
+    /// </summary>
+    /// <param name="color">The color to add.</param>
+    /// <param name="value">The index of the color in the palette.</param>
+    /// <returns>
+    /// <see langword="true"/> if the color was added; otherwise, <see langword="false"/>.
+    /// </returns>
+    public bool TryAdd(Rgba32 color, short value);
+
+    /// <summary>
+    /// Gets the index of the color in the palette.
+    /// </summary>
+    /// <param name="color">The color to get the index for.</param>
+    /// <param name="value">The index of the color in the palette.</param>
+    /// <returns>
+    /// <see langword="true"/> if the color is in the palette; otherwise, <see langword="false"/>.
+    /// </returns>
+    public bool TryGetValue(Rgba32 color, out short value);
+
+    /// <summary>
+    /// Clears the cache.
+    /// </summary>
+    public void Clear();
+}
+
+/// <summary>
+/// Represents a cache used for efficiently retrieving palette indices for colors.
+/// </summary>
+/// <typeparam name="T">The type of the cache.</typeparam>
+internal interface IColorIndexCache<T> : IColorIndexCache
+   where T : struct, IColorIndexCache
+{
+    /// <summary>
+    /// Creates a new instance of the cache.
+    /// </summary>
+    /// <param name="allocator">The memory allocator to use.</param>
+    /// <returns>
+    /// The new instance of the cache.
+    /// </returns>
+    public static abstract T Create(MemoryAllocator allocator);
+}
+
+/// <summary>
+/// A hybrid color distance cache that combines a small, fixed-capacity exact-match dictionary
+/// (ExactCache, ~4–5 KB for up to 512 entries) with a coarse lookup table (CoarseCache) for 5,5,5,6 precision.
+/// </summary>
+/// <remarks>
+/// ExactCache provides O(1) lookup for common cases using a simple 256-entry hash-based dictionary, while CoarseCache
+/// quantizes RGB channels to 5 bits (yielding 32^3 buckets) and alpha to 6 bits, storing up to 4 alpha entries per bucket
+/// (a design chosen based on probability theory to capture most real-world variations) for a total memory footprint of
+/// roughly 576 KB. Lookups and insertions are performed in constant time, making the overall design both fast and memory-predictable.
+/// </remarks>
+internal unsafe struct HybridCache : IColorIndexCache<HybridCache>
+{
+    private CoarseCache coarseCache;
+    private AccurateCache accurateCache;
+
+    public HybridCache(MemoryAllocator allocator)
+    {
+        this.accurateCache = AccurateCache.Create(allocator);
+        this.coarseCache = CoarseCache.Create(allocator);
+    }
+
+    /// <inheritdoc/>
+    public static HybridCache Create(MemoryAllocator allocator) => new(allocator);
+
+    /// <inheritdoc/>
+    [MethodImpl(InliningOptions.ShortMethod)]
+    public bool TryAdd(Rgba32 color, short index)
+    {
+        if (this.accurateCache.TryAdd(color, index))
+        {
+            return true;
+        }
+
+        return this.coarseCache.TryAdd(color, index);
+    }
+
+    /// <inheritdoc/>
+    [MethodImpl(InliningOptions.ShortMethod)]
+    public readonly bool TryGetValue(Rgba32 color, out short value)
+    {
+        if (this.accurateCache.TryGetValue(color, out value))
+        {
+            return true;
+        }
+
+        return this.coarseCache.TryGetValue(color, out value);
+    }
+
+    /// <inheritdoc/>
+    public readonly void Clear()
+    {
+        this.accurateCache.Clear();
+        this.coarseCache.Clear();
+    }
+
+    /// <inheritdoc/>
+    public void Dispose()
+    {
+        this.accurateCache.Dispose();
+        this.coarseCache.Dispose();
+    }
+}
+
+/// <summary>
+/// A coarse cache for color distance lookups that uses a fixed-size lookup table.
+/// </summary>
+/// <remarks>
+/// This cache uses a fixed lookup table with 2,097,152 bins, each storing a 2-byte value,
+/// resulting in a memory usage of approximately 4 MB. Lookups and insertions are
+/// performed in constant time (O(1)) via direct table indexing. This design is optimized for
+/// speed while maintaining a predictable, fixed memory footprint.
+/// </remarks>
+internal unsafe struct CoarseCache : IColorIndexCache<CoarseCache>
+{
+    private const int IndexRBits = 5;
+    private const int IndexGBits = 5;
+    private const int IndexBBits = 5;
+    private const int IndexABits = 6;
+    private const int IndexRCount = 1 << IndexRBits; // 32 bins for red
+    private const int IndexGCount = 1 << IndexGBits; // 32 bins for green
+    private const int IndexBCount = 1 << IndexBBits; // 32 bins for blue
+    private const int IndexACount = 1 << IndexABits; // 64 bins for alpha
+    private const int TotalBins = IndexRCount * IndexGCount * IndexBCount * IndexACount; // 2,097,152 bins
+
+    private readonly IMemoryOwner<short> binsOwner;
+    private readonly short* binsPointer;
+    private MemoryHandle binsHandle;
+
+    private CoarseCache(MemoryAllocator allocator)
+    {
+        this.binsOwner = allocator.Allocate<short>(TotalBins);
+        this.binsOwner.GetSpan().Fill(-1);
+        this.binsHandle = this.binsOwner.Memory.Pin();
+        this.binsPointer = (short*)this.binsHandle.Pointer;
+    }
+
+    /// <inheritdoc/>
+    public static CoarseCache Create(MemoryAllocator allocator) => new(allocator);
+
+    /// <inheritdoc/>
+    [MethodImpl(InliningOptions.ShortMethod)]
+    public readonly bool TryAdd(Rgba32 color, short value)
+    {
+        this.binsPointer[GetCoarseIndex(color)] = value;
+        return true;
+    }
+
+    /// <inheritdoc/>
+    [MethodImpl(InliningOptions.ShortMethod)]
+    public readonly bool TryGetValue(Rgba32 color, out short value)
+    {
+        value = this.binsPointer[GetCoarseIndex(color)];
+        return value > -1; // Coarse match found
+    }
+
+    [MethodImpl(InliningOptions.ShortMethod)]
+    private static int GetCoarseIndex(Rgba32 color)
+    {
+        int rIndex = color.R >> (8 - IndexRBits);
+        int gIndex = color.G >> (8 - IndexGBits);
+        int bIndex = color.B >> (8 - IndexBBits);
+        int aIndex = color.A >> (8 - IndexABits);
+
+        return (aIndex * IndexRCount * IndexGCount * IndexBCount) +
+               (rIndex * IndexGCount * IndexBCount) +
+               (gIndex * IndexBCount) +
+               bIndex;
+    }
+
+    /// <inheritdoc/>
+    public readonly void Clear()
+        => this.binsOwner.GetSpan().Fill(-1);
+
+    /// <inheritdoc/>
+    public void Dispose()
+    {
+        this.binsHandle.Dispose();
+        this.binsOwner.Dispose();
+    }
+}
+
+/// <summary>
+/// <para>
+/// CoarseCache is a fast, low-memory lookup structure for caching palette indices associated with RGBA values,
+/// using a quantized representation of 5,5,5,6 (RGB: 5 bits each, Alpha: 6 bits).
+/// </para>
+/// <para>
+/// The cache quantizes the RGB channels to 5 bits each, resulting in 32 levels per channel and a total of 32³ = 32,768 buckets.
+/// Each bucket is represented by an <see cref="AlphaBucket"/>, which holds a small, inline array of alpha entries.
+/// Each alpha entry stores the alpha value quantized to 6 bits (0–63) along with a palette index (a 16-bit value).
+/// </para>
+/// <para>
+/// Performance Characteristics:
+///   - Lookup: O(1) for computing the bucket index from the RGB channels, plus a small constant time (up to 8 iterations)
+///     to search through the alpha entries in the bucket.
+///   - Insertion: O(1) for bucket index computation and a quick linear search over a very small (fixed) number of entries.
+/// </para>
+/// <para>
+/// Memory Characteristics:
+///   - The cache consists of 32,768 buckets.
+///   - Each <see cref="AlphaBucket"/> is implemented using an inline array with a capacity of 8 entries.
+///   - Each bucket occupies approximately 1 byte (Count) + (8 entries × 3 bytes each) ≈ 25 bytes.
+///   - Overall, the buckets occupy roughly 32,768 × 25 bytes = 819,200 bytes (≈ 800 KB).
+/// </para>
+/// <para>
+/// This design provides nearly constant-time lookup and insertion with minimal memory usage,
+/// making it ideal for applications such as color distance caching in images with a limited palette (up to 256 entries).
+/// </para>
+/// </summary>
+internal unsafe struct CoarseCacheLite : IColorIndexCache<CoarseCacheLite>
+{
+    // Use 5 bits per channel for R, G, and B: 32 levels each.
+    // Total buckets = 32^3 = 32768.
+    private const int RgbBits = 5;
+    private const int RgbShift = 8 - RgbBits; // 3
+    private const int BucketCount = 1 << (RgbBits * 3); // 32768
+    private readonly IMemoryOwner<AlphaBucket> bucketsOwner;
+    private readonly AlphaBucket* buckets;
+    private MemoryHandle bucketHandle;
+
+    private CoarseCacheLite(MemoryAllocator allocator)
+    {
+        this.bucketsOwner = allocator.Allocate<AlphaBucket>(BucketCount, AllocationOptions.Clean);
+        this.bucketHandle = this.bucketsOwner.Memory.Pin();
+        this.buckets = (AlphaBucket*)this.bucketHandle.Pointer;
+    }
+
+    /// <inheritdoc/>
+    public static CoarseCacheLite Create(MemoryAllocator allocator) => new(allocator);
+
+    /// <inheritdoc/>
+    public readonly bool TryAdd(Rgba32 color, short paletteIndex)
+    {
+        int bucketIndex = GetBucketIndex(color.R, color.G, color.B);
+        byte quantAlpha = QuantizeAlpha(color.A);
+        this.buckets[bucketIndex].Add(quantAlpha, paletteIndex);
+        return true;
+    }
+
+    /// <inheritdoc/>
+    public readonly bool TryGetValue(Rgba32 color, out short paletteIndex)
+    {
+        int bucketIndex = GetBucketIndex(color.R, color.G, color.B);
+        byte quantAlpha = QuantizeAlpha(color.A);
+        return this.buckets[bucketIndex].TryGetValue(quantAlpha, out paletteIndex);
+    }
+
+    /// <inheritdoc/>
+    public readonly void Clear()
+    {
+        Span<AlphaBucket> bucketsSpan = this.bucketsOwner.GetSpan();
+        bucketsSpan.Clear();
+    }
+
+    /// <inheritdoc/>
+    public void Dispose()
+    {
+        this.bucketHandle.Dispose();
+        this.bucketsOwner.Dispose();
+    }
+
+    [MethodImpl(InliningOptions.ShortMethod)]
+    private static int GetBucketIndex(byte r, byte g, byte b)
+    {
+        int qr = r >> RgbShift;
+        int qg = g >> RgbShift;
+        int qb = b >> RgbShift;
+
+        // Combine the quantized channels into a single index.
+        return (qr << (RgbBits << 1)) | (qg << RgbBits) | qb;
+    }
+
+    [MethodImpl(InliningOptions.ShortMethod)]
+    private static byte QuantizeAlpha(byte a)
+
+        // Quantize to 6 bits: shift right by (8 - 6) = 2 bits.
+        => (byte)(a >> 2);
+
+    public struct AlphaEntry
+    {
+        // Store the alpha value quantized to 6 bits (0..63)
+        public byte QuantizedAlpha;
+        public short PaletteIndex;
+    }
+
+    public struct AlphaBucket
+    {
+        // Fixed capacity for alpha entries in this bucket.
+        // We choose a capacity of 8 for several reasons:
+        //
+        // 1. The alpha channel is quantized to 6 bits, so there are 64 possible distinct values.
+        //    In the worst-case, a given RGB bucket might encounter up to 64 different alpha values.
+        //
+        // 2. However, in practice (based on probability theory and typical image data),
+        //    the number of unique alpha values that actually occur for a given quantized RGB
+        //    bucket is usually very small. If you randomly sample 8 values out of 64,
+        //    the probability that these 4 samples are all unique is high if the distribution
+        //    of alpha values is skewed or if only a few alpha values are used.
+        //
+        // 3. Statistically, for many real-world images, most RGB buckets will have only a couple
+        //    of unique alpha values. Allocating 8 slots per bucket provides a good trade-off:
+        //    it captures the common-case scenario while keeping overall memory usage low.
+        //
+        // 4. Even if more than 8 unique alpha values occur in a bucket,
+        //    our design overwrites the first entry. This behavior gives us some "wriggle room"
+        //    while preserving the most frequently encountered or most recent values.
+        public const int Capacity = 8;
+        public byte Count;
+        private InlineArray8<AlphaEntry> entries;
+
+        [MethodImpl(InliningOptions.ShortMethod)]
+        public bool TryGetValue(byte quantizedAlpha, out short paletteIndex)
+        {
+            for (int i = 0; i < this.Count; i++)
+            {
+                ref AlphaEntry entry = ref this.entries[i];
+                if (entry.QuantizedAlpha == quantizedAlpha)
+                {
+                    paletteIndex = entry.PaletteIndex;
+                    return true;
+                }
+            }
+
+            paletteIndex = -1;
+            return false;
+        }
+
+        [MethodImpl(InliningOptions.ShortMethod)]
+        public void Add(byte quantizedAlpha, short paletteIndex)
+        {
+            // Check for an existing entry with the same quantized alpha.
+            for (int i = 0; i < this.Count; i++)
+            {
+                ref AlphaEntry entry = ref this.entries[i];
+                if (entry.QuantizedAlpha == quantizedAlpha)
+                {
+                    // Update palette index if found.
+                    entry.PaletteIndex = paletteIndex;
+                    return;
+                }
+            }
+
+            // If there's room, add a new entry.
+            if (this.Count < Capacity)
+            {
+                ref AlphaEntry newEntry = ref this.entries[this.Count];
+                newEntry.QuantizedAlpha = quantizedAlpha;
+                newEntry.PaletteIndex = paletteIndex;
+                this.Count++;
+            }
+            else
+            {
+                // Bucket is full. Overwrite the first entry to give us some wriggle room.
+                this.entries[0].QuantizedAlpha = quantizedAlpha;
+                this.entries[0].PaletteIndex = paletteIndex;
+            }
+        }
+    }
+}
+
+/// <summary>
+/// A fixed-capacity dictionary with exactly 512 entries mapping a <see cref="uint"/> key
+/// to a <see cref="short"/> value.
+/// </summary>
+/// <remarks>
+/// The dictionary is implemented using a fixed array of 512 buckets and an entries array
+/// of the same size. The bucket for a key is computed as (key &amp; 0x1FF), and collisions are
+/// resolved through a linked chain stored in the <see cref="Entry.Next"/> field.
+/// The overall memory usage is approximately 4–5 KB. Both lookup and insertion operations are,
+/// on average, O(1) since the bucket is determined via a simple bitmask and collision chains are
+/// typically very short; in the worst-case, the number of iterations is bounded by 256.
+/// This guarantees highly efficient and predictable performance for small, fixed-size color palettes.
+/// </remarks>
+internal unsafe struct AccurateCache : IColorIndexCache<AccurateCache>
+{
+    // Buckets array: each bucket holds the index (0-based) into the entries array
+    // of the first entry in the chain, or -1 if empty.
+    private readonly IMemoryOwner<short> bucketsOwner;
+    private MemoryHandle bucketsHandle;
+    private short* buckets;
+
+    // Entries array: stores up to 256 entries.
+    private readonly IMemoryOwner<Entry> entriesOwner;
+    private MemoryHandle entriesHandle;
+    private Entry* entries;
+
+    public const int Capacity = 512;
+
+    private AccurateCache(MemoryAllocator allocator)
+    {
+        this.Count = 0;
+
+        // Allocate exactly 512 indexes for buckets.
+        this.bucketsOwner = allocator.Allocate<short>(Capacity, AllocationOptions.Clean);
+        Span<short> bucketSpan = this.bucketsOwner.GetSpan();
+        bucketSpan.Fill(-1);
+        this.bucketsHandle = this.bucketsOwner.Memory.Pin();
+        this.buckets = (short*)this.bucketsHandle.Pointer;
+
+        // Allocate exactly 512 entries.
+        this.entriesOwner = allocator.Allocate<Entry>(Capacity, AllocationOptions.Clean);
+        this.entriesHandle = this.entriesOwner.Memory.Pin();
+        this.entries = (Entry*)this.entriesHandle.Pointer;
+    }
+
+    public int Count { get; private set; }
+
+    /// <inheritdoc/>
+    public static AccurateCache Create(MemoryAllocator allocator) => new(allocator);
+
+    /// <inheritdoc/>
+    [MethodImpl(InliningOptions.ShortMethod)]
+    public bool TryAdd(Rgba32 color, short value)
+    {
+        if (this.Count == Capacity)
+        {
+            return false; // Dictionary is full.
+        }
+
+        uint key = color.PackedValue;
+
+        // The key is a 32-bit unsigned integer representing an RGBA color, where the bytes are laid out as R|G|B|A
+        // (with R in the most significant byte and A in the least significant).
+        // To compute the bucket index:
+        // 1. (key >> 16) extracts the top 16 bits, effectively giving us the R and G channels.
+        // 2. (key >> 8) shifts the key right by 8 bits, bringing R, G, and B into the lower 24 bits (dropping A).
+        // 3. XORing these two values with the original key mixes bits from all four channels (R, G, B, and A),
+        //    which helps to counteract situations where one or more channels have a limited range.
+        // 4. Finally, we apply a bitmask of 0x1FF to keep only the lowest 9 bits, ensuring the result is between 0 and 511,
+        //    which corresponds to our fixed bucket count of 512.
+        int bucket = (int)(((key >> 16) ^ (key >> 8) ^ key) & 0x1FF);
+        int i = this.buckets[bucket];
+
+        // Traverse the collision chain.
+        Entry* entries = this.entries;
+        while (i != -1)
+        {
+            Entry e = entries[i];
+            if (e.Key == key)
+            {
+                // Key already exists; do not overwrite.
+                return false;
+            }
+
+            i = e.Next;
+        }
+
+        short index = (short)this.Count;
+        this.Count++;
+
+        // Insert the new entry:
+        entries[index].Key = key;
+        entries[index].Value = value;
+
+        // Link this new entry into the bucket chain.
+        entries[index].Next = this.buckets[bucket];
+        this.buckets[bucket] = index;
+        return true;
+    }
+
+    /// <inheritdoc/>
+    [MethodImpl(InliningOptions.ShortMethod)]
+    public bool TryGetValue(Rgba32 color, out short value)
+    {
+        uint key = color.PackedValue;
+        int bucket = (int)(((key >> 16) ^ (key >> 8) ^ key) & 0x1FF);
+        int i = this.buckets[bucket];
+
+        // If the bucket is empty, return immediately.
+        if (i == -1)
+        {
+            value = -1;
+            return false;
+        }
+
+        // Traverse the chain.
+        Entry* entries = this.entries;
+        do
+        {
+            Entry e = entries[i];
+            if (e.Key == key)
+            {
+                value = e.Value;
+                return true;
+            }
+
+            i = e.Next;
+        }
+        while (i != -1);
+
+        value = -1;
+        return false;
+    }
+
+    /// <summary>
+    /// Clears the dictionary.
+    /// </summary>
+    public void Clear()
+    {
+        Span<short> bucketSpan = this.bucketsOwner.GetSpan();
+        bucketSpan.Fill(-1);
+        this.Count = 0;
+    }
+
+    public void Dispose()
+    {
+        this.bucketsHandle.Dispose();
+        this.bucketsOwner.Dispose();
+        this.entriesHandle.Dispose();
+        this.entriesOwner.Dispose();
+        this.buckets = null;
+        this.entries = null;
+    }
+
+    private struct Entry
+    {
+        public uint Key;     // The key (packed RGBA)
+        public short Value;  // The value; -1 means unused.
+        public short Next;     // Index of the next entry in the chain, or -1 if none.
+    }
+}
+
+/// <summary>
+/// Represents a cache that does not store any values.
+/// It allows adding colors, but always returns false when trying to retrieve them.
+/// </summary>
+internal readonly struct NullCache : IColorIndexCache<NullCache>
+{
+    /// <inheritdoc/>
+    public static NullCache Create(MemoryAllocator allocator) => default;
+
+    /// <inheritdoc/>
+    public bool TryAdd(Rgba32 color, short value) => true;
+
+    /// <inheritdoc/>
+    public bool TryGetValue(Rgba32 color, out short value)
+    {
+        value = -1;
+        return false;
+    }
+
+    /// <inheritdoc/>
+    public void Clear()
+    {
+    }
+
+    /// <inheritdoc/>
+    public void Dispose()
+    {
+    }
+}
diff --git a/src/ImageSharp/Processing/Processors/Quantization/IQuantizer.cs b/src/ImageSharp/Processing/Processors/Quantization/IQuantizer.cs
index 9d5b606040..02dce8ca48 100644
--- a/src/ImageSharp/Processing/Processors/Quantization/IQuantizer.cs
+++ b/src/ImageSharp/Processing/Processors/Quantization/IQuantizer.cs
@@ -13,7 +13,7 @@ public interface IQuantizer
     /// <summary>
     /// Gets the quantizer options defining quantization rules.
     /// </summary>
-    QuantizerOptions Options { get; }
+    public QuantizerOptions Options { get; }
 
     /// <summary>
     /// Creates the generic frame quantizer.
@@ -21,7 +21,7 @@ public interface IQuantizer
     /// <param name="configuration">The <see cref="Configuration"/> to configure internal operations.</param>
     /// <typeparam name="TPixel">The pixel format.</typeparam>
     /// <returns>The <see cref="IQuantizer{TPixel}"/>.</returns>
-    IQuantizer<TPixel> CreatePixelSpecificQuantizer<TPixel>(Configuration configuration)
+    public IQuantizer<TPixel> CreatePixelSpecificQuantizer<TPixel>(Configuration configuration)
         where TPixel : unmanaged, IPixel<TPixel>;
 
     /// <summary>
@@ -31,6 +31,6 @@ public interface IQuantizer
     /// <param name="configuration">The <see cref="Configuration"/> to configure internal operations.</param>
     /// <param name="options">The options to create the quantizer with.</param>
     /// <returns>The <see cref="IQuantizer{TPixel}"/>.</returns>
-    IQuantizer<TPixel> CreatePixelSpecificQuantizer<TPixel>(Configuration configuration, QuantizerOptions options)
+    public IQuantizer<TPixel> CreatePixelSpecificQuantizer<TPixel>(Configuration configuration, QuantizerOptions options)
         where TPixel : unmanaged, IPixel<TPixel>;
 }
diff --git a/src/ImageSharp/Processing/Processors/Quantization/IQuantizer{TPixel}.cs b/src/ImageSharp/Processing/Processors/Quantization/IQuantizer{TPixel}.cs
index 35bbb1289e..1e6420eaa9 100644
--- a/src/ImageSharp/Processing/Processors/Quantization/IQuantizer{TPixel}.cs
+++ b/src/ImageSharp/Processing/Processors/Quantization/IQuantizer{TPixel}.cs
@@ -16,26 +16,26 @@ public interface IQuantizer<TPixel> : IDisposable
     /// <summary>
     /// Gets the configuration.
     /// </summary>
-    Configuration Configuration { get; }
+    public Configuration Configuration { get; }
 
     /// <summary>
     /// Gets the quantizer options defining quantization rules.
     /// </summary>
-    QuantizerOptions Options { get; }
+    public QuantizerOptions Options { get; }
 
     /// <summary>
     /// Gets the quantized color palette.
     /// </summary>
     /// <exception cref="InvalidOperationException">
-    /// The palette has not been built via <see cref="AddPaletteColors"/>.
+    /// The palette has not been built via <see cref="AddPaletteColors(in Buffer2DRegion{TPixel})"/>.
     /// </exception>
-    ReadOnlyMemory<TPixel> Palette { get; }
+    public ReadOnlyMemory<TPixel> Palette { get; }
 
     /// <summary>
     /// Adds colors to the quantized palette from the given pixel source.
     /// </summary>
     /// <param name="pixelRegion">The <see cref="Buffer2DRegion{T}"/> of source pixels to register.</param>
-    void AddPaletteColors(Buffer2DRegion<TPixel> pixelRegion);
+    public void AddPaletteColors(in Buffer2DRegion<TPixel> pixelRegion);
 
     /// <summary>
     /// Quantizes an image frame and return the resulting output pixels.
@@ -46,10 +46,10 @@ public interface IQuantizer<TPixel> : IDisposable
     /// A <see cref="IndexedImageFrame{TPixel}"/> representing a quantized version of the source frame pixels.
     /// </returns>
     /// <remarks>
-    /// Only executes the second (quantization) step. The palette has to be built by calling <see cref="AddPaletteColors"/>.
-    /// To run both steps, use <see cref="QuantizerUtilities.BuildPaletteAndQuantizeFrame{TPixel}"/>.
+    /// Only executes the second (quantization) step. The palette has to be built by calling <see cref="AddPaletteColors(in Buffer2DRegion{TPixel})"/>.
+    /// To run both steps, use <see cref="QuantizerUtilities.BuildPaletteAndQuantizeFrame{TPixel}(IQuantizer{TPixel}, ImageFrame{TPixel}, Rectangle)"/>.
     /// </remarks>
-    IndexedImageFrame<TPixel> QuantizeFrame(ImageFrame<TPixel> source, Rectangle bounds);
+    public IndexedImageFrame<TPixel> QuantizeFrame(ImageFrame<TPixel> source, Rectangle bounds);
 
     /// <summary>
     /// Returns the index and color from the quantized palette corresponding to the given color.
@@ -57,7 +57,7 @@ public interface IQuantizer<TPixel> : IDisposable
     /// <param name="color">The color to match.</param>
     /// <param name="match">The matched color.</param>
     /// <returns>The <see cref="byte"/> index.</returns>
-    byte GetQuantizedColor(TPixel color, out TPixel match);
+    public byte GetQuantizedColor(TPixel color, out TPixel match);
 
     // TODO: Enable bulk operations.
     // void GetQuantizedColors(ReadOnlySpan<TPixel> colors, ReadOnlySpan<TPixel> palette, Span<byte> indices, Span<TPixel> matches);
diff --git a/src/ImageSharp/Processing/Processors/Quantization/IQuantizingPixelRowDelegate{TPixel}.cs b/src/ImageSharp/Processing/Processors/Quantization/IQuantizingPixelRowDelegate{TPixel}.cs
new file mode 100644
index 0000000000..3cf4c93d62
--- /dev/null
+++ b/src/ImageSharp/Processing/Processors/Quantization/IQuantizingPixelRowDelegate{TPixel}.cs
@@ -0,0 +1,21 @@
+// Copyright (c) Six Labors.
+// Licensed under the Six Labors Split License.
+
+using SixLabors.ImageSharp.PixelFormats;
+
+namespace SixLabors.ImageSharp.Processing.Processors.Quantization;
+
+/// <summary>
+/// Defines a delegate for processing a row of pixels in an image for quantization.
+/// </summary>
+/// <typeparam name="TPixel">Represents a pixel type that can be processed in a quantizing operation.</typeparam>
+internal interface IQuantizingPixelRowDelegate<TPixel>
+    where TPixel : unmanaged, IPixel<TPixel>
+{
+    /// <summary>
+    /// Processes a row of pixels for quantization.
+    /// </summary>
+    /// <param name="row">The row of pixels to process.</param>
+    /// <param name="rowIndex">The index of the row being processed.</param>
+    public void Invoke(ReadOnlySpan<TPixel> row, int rowIndex);
+}
diff --git a/src/ImageSharp/Processing/Processors/Quantization/OctreeQuantizer{TPixel}.cs b/src/ImageSharp/Processing/Processors/Quantization/OctreeQuantizer{TPixel}.cs
index 8b39b74579..07596b68a8 100644
--- a/src/ImageSharp/Processing/Processors/Quantization/OctreeQuantizer{TPixel}.cs
+++ b/src/ImageSharp/Processing/Processors/Quantization/OctreeQuantizer{TPixel}.cs
@@ -16,11 +16,10 @@ namespace SixLabors.ImageSharp.Processing.Processors.Quantization;
 /// <see href="http://msdn.microsoft.com/en-us/library/aa479306.aspx"/>
 /// </summary>
 /// <typeparam name="TPixel">The pixel format.</typeparam>
-[SuppressMessage(
-    "Design",
-    "CA1001:Types that own disposable fields should be disposable",
-    Justification = "https://github.com/dotnet/roslyn-analyzers/issues/6151")]
+#pragma warning disable CA1001 // Types that own disposable fields should be disposable
+// See https://github.com/dotnet/roslyn-analyzers/issues/6151
 public struct OctreeQuantizer<TPixel> : IQuantizer<TPixel>
+#pragma warning restore CA1001 // Types that own disposable fields should be disposable
     where TPixel : unmanaged, IPixel<TPixel>
 {
     private readonly int maxColors;
@@ -28,14 +27,14 @@ public struct OctreeQuantizer<TPixel> : IQuantizer<TPixel>
     private readonly Octree octree;
     private readonly IMemoryOwner<TPixel> paletteOwner;
     private ReadOnlyMemory<TPixel> palette;
-    private EuclideanPixelMap<TPixel>? pixelMap;
+    private PixelMap<TPixel>? pixelMap;
     private readonly bool isDithering;
     private bool isDisposed;
 
     /// <summary>
     /// Initializes a new instance of the <see cref="OctreeQuantizer{TPixel}"/> struct.
     /// </summary>
-    /// <param name="configuration">The configuration which allows altering default behaviour or extending the library.</param>
+    /// <param name="configuration">The configuration which allows altering default behavior or extending the library.</param>
     /// <param name="options">The quantizer options defining quantization rules.</param>
     [MethodImpl(InliningOptions.ShortMethod)]
     public OctreeQuantizer(Configuration configuration, QuantizerOptions options)
@@ -45,7 +44,7 @@ public struct OctreeQuantizer<TPixel> : IQuantizer<TPixel>
 
         this.maxColors = this.Options.MaxColors;
         this.bitDepth = Numerics.Clamp(ColorNumerics.GetBitsNeededForColorDepth(this.maxColors), 1, 8);
-        this.octree = new Octree(this.bitDepth);
+        this.octree = new Octree(configuration, this.bitDepth, this.maxColors, this.Options.TransparencyThreshold);
         this.paletteOwner = configuration.MemoryAllocator.Allocate<TPixel>(this.maxColors, AllocationOptions.Clean);
         this.pixelMap = default;
         this.palette = default;
@@ -60,64 +59,41 @@ public struct OctreeQuantizer<TPixel> : IQuantizer<TPixel>
     public QuantizerOptions Options { get; }
 
     /// <inheritdoc/>
-    public readonly ReadOnlyMemory<TPixel> Palette
+    public ReadOnlyMemory<TPixel> Palette
     {
         get
         {
-            QuantizerUtilities.CheckPaletteState(in this.palette);
+            if (this.palette.IsEmpty)
+            {
+                this.ResolvePalette();
+                QuantizerUtilities.CheckPaletteState(in this.palette);
+            }
+
             return this.palette;
         }
     }
 
     /// <inheritdoc/>
-    public void AddPaletteColors(Buffer2DRegion<TPixel> pixelRegion)
+    public readonly void AddPaletteColors(in Buffer2DRegion<TPixel> pixelRegion)
     {
-        using (IMemoryOwner<Rgba32> buffer = this.Configuration.MemoryAllocator.Allocate<Rgba32>(pixelRegion.Width))
-        {
-            Span<Rgba32> bufferSpan = buffer.GetSpan();
-
-            // Loop through each row
-            for (int y = 0; y < pixelRegion.Height; y++)
-            {
-                Span<TPixel> row = pixelRegion.DangerousGetRowSpan(y);
-                PixelOperations<TPixel>.Instance.ToRgba32(this.Configuration, row, bufferSpan);
-
-                for (int x = 0; x < bufferSpan.Length; x++)
-                {
-                    Rgba32 rgba = bufferSpan[x];
-
-                    // Add the color to the Octree
-                    this.octree.AddColor(rgba);
-                }
-            }
-        }
+        PixelRowDelegate pixelRowDelegate = new(this.octree);
+        QuantizerUtilities.AddPaletteColors<OctreeQuantizer<TPixel>, TPixel, Rgba32, PixelRowDelegate>(
+            ref Unsafe.AsRef(in this),
+            in pixelRegion,
+            in pixelRowDelegate);
+    }
 
-        int paletteIndex = 0;
+    private void ResolvePalette()
+    {
+        short paletteIndex = 0;
         Span<TPixel> paletteSpan = this.paletteOwner.GetSpan();
 
-        // On very rare occasions, (blur.png), the quantizer does not preserve a
-        // transparent entry when palletizing the captured colors.
-        // To workaround this we ensure the palette ends with the default color
-        // for higher bit depths. Lower bit depths will correctly reduce the palette.
-        // TODO: Investigate more evenly reduced palette reduction.
-        int max = this.maxColors;
-        if (this.bitDepth >= 4)
-        {
-            max--;
-        }
-
-        this.octree.Palletize(paletteSpan, max, ref paletteIndex);
+        this.octree.Palettize(paletteSpan, ref paletteIndex);
         ReadOnlyMemory<TPixel> result = this.paletteOwner.Memory[..paletteSpan.Length];
 
-        // When called multiple times by QuantizerUtilities.BuildPalette
-        // this prevents memory churn caused by reallocation.
-        if (this.pixelMap is null)
-        {
-            this.pixelMap = new EuclideanPixelMap<TPixel>(this.Configuration, result);
-        }
-        else
+        if (this.isDithering)
         {
-            this.pixelMap.Clear(result);
+            this.pixelMap = PixelMapFactory.Create(this.Configuration, result, this.Options.ColorMatchingMode);
         }
 
         this.palette = result;
@@ -132,18 +108,19 @@ public struct OctreeQuantizer<TPixel> : IQuantizer<TPixel>
     [MethodImpl(InliningOptions.ShortMethod)]
     public readonly byte GetQuantizedColor(TPixel color, out TPixel match)
     {
-        // Octree only maps the RGB component of a color
-        // so cannot tell the difference between a fully transparent
-        // pixel and a black one.
-        if (this.isDithering || color.Equals(default))
+        // Due to the addition of new colors by dithering that are not part of the original histogram,
+        // the octree nodes might not match the correct color.
+        // In this case, we must use the pixel map to get the closest color.
+        if (this.isDithering)
         {
             return (byte)this.pixelMap!.GetClosestColor(color, out match);
         }
 
         ref TPixel paletteRef = ref MemoryMarshal.GetReference(this.palette.Span);
-        byte index = (byte)this.octree.GetPaletteIndex(color);
-        match = Unsafe.Add(ref paletteRef, index);
-        return index;
+
+        int index = this.octree.GetPaletteIndex(color);
+        match = Unsafe.Add(ref paletteRef, (nuint)index);
+        return (byte)index;
     }
 
     /// <inheritdoc/>
@@ -155,413 +132,529 @@ public struct OctreeQuantizer<TPixel> : IQuantizer<TPixel>
             this.paletteOwner.Dispose();
             this.pixelMap?.Dispose();
             this.pixelMap = null;
+            this.octree.Dispose();
         }
     }
 
+    private readonly struct PixelRowDelegate : IQuantizingPixelRowDelegate<Rgba32>
+    {
+        private readonly Octree octree;
+
+        public PixelRowDelegate(Octree octree) => this.octree = octree;
+
+        public void Invoke(ReadOnlySpan<Rgba32> row, int rowIndex) => this.octree.AddColors(row);
+    }
+
     /// <summary>
-    /// Class which does the actual quantization.
+    /// A hexadecatree-based color quantization structure used for fast color distance lookups and palette generation.
+    /// This tree maintains a fixed pool of nodes (capacity 4096) where each node can have up to 16 children, stores
+    /// color accumulation data, and supports dynamic node allocation and reduction. It offers near-constant-time insertions
+    /// and lookups while consuming roughly 240 KB for the node pool.
     /// </summary>
-    private sealed class Octree
+    internal sealed class Octree : IDisposable
     {
-        /// <summary>
-        /// The root of the Octree
-        /// </summary>
-        private readonly OctreeNode root;
+        // The memory allocator.
+        private readonly MemoryAllocator allocator;
 
-        /// <summary>
-        /// Maximum number of significant bits in the image
-        /// </summary>
+        // Pooled buffer for OctreeNodes.
+        private readonly IMemoryOwner<OctreeNode> nodesOwner;
+
+        // Reducible nodes: one per level; we use an integer index; -1 means “no node.�
+        private readonly short[] reducibleNodes;
+
+        // Maximum number of allowable colors.
+        private readonly int maxColors;
+
+        // Maximum significant bits.
         private readonly int maxColorBits;
 
-        /// <summary>
-        /// Store the last node quantized
-        /// </summary>
-        private OctreeNode? previousNode;
+        // The threshold for transparent colors.
+        private readonly int transparencyThreshold255;
 
-        /// <summary>
-        /// Cache the previous color quantized
-        /// </summary>
+        // Instead of a reference to the root, we store the index of the root node.
+        // Index 0 is reserved for the root.
+        private readonly short rootIndex;
+
+        // Running index for node allocation. Start at 1 so that index 0 is reserved for the root.
+        private short nextNode = 1;
+
+        // Previously quantized node (index; -1 if none) and its color.
+        private int previousNode;
         private Rgba32 previousColor;
 
+        // Free list for reclaimed node indices.
+        private readonly Stack<short> freeIndices = new();
+
         /// <summary>
         /// Initializes a new instance of the <see cref="Octree"/> class.
         /// </summary>
-        /// <param name="maxColorBits">
-        /// The maximum number of significant bits in the image
-        /// </param>
-        public Octree(int maxColorBits)
+        /// <param name="configuration">The configuration which allows altering default behavior or extending the library.</param>
+        /// <param name="maxColorBits">The maximum number of significant bits in the image.</param>
+        /// <param name="maxColors">The maximum number of colors to allow in the palette.</param>
+        /// <param name="transparencyThreshold">The threshold for transparent colors.</param>
+        public Octree(
+            Configuration configuration,
+            int maxColorBits,
+            int maxColors,
+            float transparencyThreshold)
         {
             this.maxColorBits = maxColorBits;
+            this.maxColors = maxColors;
+            this.transparencyThreshold255 = (int)(transparencyThreshold * 255F);
             this.Leaves = 0;
-            this.ReducibleNodes = new OctreeNode[9];
-            this.root = new OctreeNode(0, this.maxColorBits, this);
+            this.previousNode = -1;
             this.previousColor = default;
-            this.previousNode = null;
+
+            // Allocate a conservative buffer for nodes.
+            const int capacity = 4096;
+            this.allocator = configuration.MemoryAllocator;
+            this.nodesOwner = this.allocator.Allocate<OctreeNode>(capacity, AllocationOptions.Clean);
+
+            // Create the reducible nodes array (one per level 0 .. maxColorBits-1).
+            this.reducibleNodes = new short[this.maxColorBits];
+            this.reducibleNodes.AsSpan().Fill(-1);
+
+            // Reserve index 0 for the root.
+            this.rootIndex = 0;
+            ref OctreeNode root = ref this.Nodes[this.rootIndex];
+            root.Initialize(0, this.maxColorBits, this, this.rootIndex);
         }
 
         /// <summary>
-        /// Gets or sets the number of leaves in the tree
+        /// Gets or sets the number of leaves in the tree.
         /// </summary>
-        public int Leaves
-        {
-            [MethodImpl(InliningOptions.ShortMethod)]
-            get;
+        public int Leaves { get; set; }
 
-            [MethodImpl(InliningOptions.ShortMethod)]
-            set;
-        }
+        /// <summary>
+        /// Gets the full collection of nodes as a span.
+        /// </summary>
+        internal Span<OctreeNode> Nodes => this.nodesOwner.Memory.Span;
 
         /// <summary>
-        /// Gets the array of reducible nodes
+        /// Adds a span of colors to the octree.
         /// </summary>
-        private OctreeNode?[] ReducibleNodes
+        /// <param name="row">A span of color values to be added.</param>
+        public void AddColors(ReadOnlySpan<Rgba32> row)
         {
-            [MethodImpl(InliningOptions.ShortMethod)]
-            get;
+            for (int x = 0; x < row.Length; x++)
+            {
+                this.AddColor(row[x]);
+            }
         }
 
         /// <summary>
-        /// Add a given color value to the Octree
+        /// Add a color to the Octree.
         /// </summary>
         /// <param name="color">The color to add.</param>
-        public void AddColor(Rgba32 color)
+        private void AddColor(Rgba32 color)
         {
-            // Check if this request is for the same color as the last
+            // Ensure that the tree is not already full.
+            if (this.nextNode >= this.Nodes.Length && this.freeIndices.Count == 0)
+            {
+                while (this.Leaves > this.maxColors)
+                {
+                    this.Reduce();
+                }
+            }
+
+            // If the color is the same as the previous color, increment the node.
+            // Otherwise, add a new node.
             if (this.previousColor.Equals(color))
             {
-                // If so, check if I have a previous node setup.
-                // This will only occur if the first color in the image
-                // happens to be black, with an alpha component of zero.
-                if (this.previousNode is null)
+                if (this.previousNode == -1)
                 {
                     this.previousColor = color;
-                    this.root.AddColor(ref color, this.maxColorBits, 0, this);
+                    OctreeNode.AddColor(this.rootIndex, color, this.maxColorBits, 0, this);
                 }
                 else
                 {
-                    // Just update the previous node
-                    this.previousNode.Increment(ref color);
+                    OctreeNode.Increment(this.previousNode, color, this);
                 }
             }
             else
             {
                 this.previousColor = color;
-                this.root.AddColor(ref color, this.maxColorBits, 0, this);
+                OctreeNode.AddColor(this.rootIndex, color, this.maxColorBits, 0, this);
             }
         }
 
         /// <summary>
-        /// Convert the nodes in the Octree to a palette with a maximum of colorCount colors
+        /// Construct the palette from the octree.
         /// </summary>
-        /// <param name="palette">The palette to fill.</param>
-        /// <param name="colorCount">The maximum number of colors</param>
-        /// <param name="paletteIndex">The palette index, used to calculate the final size of the palette.</param>
-        [MethodImpl(InliningOptions.ShortMethod)]
-        public void Palletize(Span<TPixel> palette, int colorCount, ref int paletteIndex)
+        /// <param name="palette">The palette to construct.</param>
+        /// <param name="paletteIndex">The current palette index.</param>
+        public void Palettize(Span<TPixel> palette, ref short paletteIndex)
         {
-            while (this.Leaves > colorCount)
+            while (this.Leaves > this.maxColors)
             {
                 this.Reduce();
             }
 
-            this.root.ConstructPalette(palette, ref paletteIndex);
+            this.Nodes[this.rootIndex].ConstructPalette(this, palette, ref paletteIndex);
         }
 
         /// <summary>
-        /// Get the palette index for the passed color
+        /// Get the palette index for the passed color.
         /// </summary>
-        /// <param name="color">The color to match.</param>
-        /// <returns>
-        /// The <see cref="int"/> index.
-        /// </returns>
-        [MethodImpl(InliningOptions.ShortMethod)]
+        /// <param name="color">The color to get the palette index for.</param>
+        /// <returns>The <see cref="int"/>.</returns>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
         public int GetPaletteIndex(TPixel color)
-        {
-            Rgba32 rgba = color.ToRgba32();
-            return this.root.GetPaletteIndex(ref rgba, 0);
-        }
+            => this.Nodes[this.rootIndex].GetPaletteIndex(color.ToRgba32(), 0, this);
 
         /// <summary>
-        /// Keep track of the previous node that was quantized
+        /// Track the previous node and color.
         /// </summary>
-        /// <param name="node">
-        /// The node last quantized
-        /// </param>
-        [MethodImpl(InliningOptions.ShortMethod)]
-        public void TrackPrevious(OctreeNode node) => this.previousNode = node;
+        /// <param name="nodeIndex">The node index.</param>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public void TrackPrevious(int nodeIndex)
+            => this.previousNode = nodeIndex;
 
         /// <summary>
-        /// Reduce the depth of the tree
+        /// Reduce the depth of the tree.
         /// </summary>
         private void Reduce()
         {
             // Find the deepest level containing at least one reducible node
             int index = this.maxColorBits - 1;
-            while ((index > 0) && (this.ReducibleNodes[index] is null))
+            while ((index > 0) && (this.reducibleNodes[index] == -1))
             {
                 index--;
             }
 
             // Reduce the node most recently added to the list at level 'index'
-            OctreeNode node = this.ReducibleNodes[index]!;
-            this.ReducibleNodes[index] = node.NextReducible;
+            ref OctreeNode node = ref this.Nodes[this.reducibleNodes[index]];
+            this.reducibleNodes[index] = node.NextReducibleIndex;
 
             // Decrement the leaf count after reducing the node
-            this.Leaves -= node.Reduce();
+            node.Reduce(this);
 
             // And just in case I've reduced the last color to be added, and the next color to
             // be added is the same, invalidate the previousNode...
-            this.previousNode = null;
+            this.previousNode = -1;
         }
 
-        /// <summary>
-        /// Class which encapsulates each node in the tree
-        /// </summary>
-        public sealed class OctreeNode
+        // Allocate a new OctreeNode from the pooled buffer.
+        // First check the freeIndices stack.
+        internal short AllocateNode()
         {
-            /// <summary>
-            /// Pointers to any child nodes
-            /// </summary>
-            private readonly OctreeNode?[]? children;
-
-            /// <summary>
-            /// Flag indicating that this is a leaf node
-            /// </summary>
-            private bool leaf;
+            if (this.freeIndices.Count > 0)
+            {
+                return this.freeIndices.Pop();
+            }
 
-            /// <summary>
-            /// Number of pixels in this node
-            /// </summary>
-            private int pixelCount;
+            if (this.nextNode >= this.Nodes.Length)
+            {
+                return -1;
+            }
 
-            /// <summary>
-            /// Red component
-            /// </summary>
-            private int red;
+            short newIndex = this.nextNode;
+            this.nextNode++;
+            return newIndex;
+        }
 
-            /// <summary>
-            /// Green Component
-            /// </summary>
-            private int green;
+        /// <summary>
+        /// Free a node index, making it available for re-allocation.
+        /// </summary>
+        /// <param name="index">The index to free.</param>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        internal void FreeNode(short index)
+        {
+            this.freeIndices.Push(index);
+            this.Leaves--;
+        }
 
-            /// <summary>
-            /// Blue component
-            /// </summary>
-            private int blue;
+        /// <inheritdoc/>
+        public void Dispose() => this.nodesOwner.Dispose();
 
-            /// <summary>
-            /// The index of this node in the palette
-            /// </summary>
-            private int paletteIndex;
+        [StructLayout(LayoutKind.Sequential)]
+        internal unsafe struct OctreeNode
+        {
+            public bool Leaf;
+            public int PixelCount;
+            public int Red;
+            public int Green;
+            public int Blue;
+            public int Alpha;
+            public short PaletteIndex;
+            public short NextReducibleIndex;
+            private InlineArray16<short> children;
+
+            [UnscopedRef]
+            public Span<short> Children => this.children;
 
             /// <summary>
-            /// Initializes a new instance of the <see cref="OctreeNode"/> class.
+            /// Initialize the <see cref="OctreeNode"/>.
             /// </summary>
-            /// <param name="level">The level in the tree = 0 - 7.</param>
+            /// <param name="level">The level of the node.</param>
             /// <param name="colorBits">The number of significant color bits in the image.</param>
-            /// <param name="octree">The tree to which this node belongs.</param>
-            public OctreeNode(int level, int colorBits, Octree octree)
+            /// <param name="octree">The parent octree.</param>
+            /// <param name="index">The index of the node.</param>
+            public void Initialize(int level, int colorBits, Octree octree, short index)
             {
-                // Construct the new node
-                this.leaf = level == colorBits;
-
-                this.red = this.green = this.blue = 0;
-                this.pixelCount = 0;
-
-                // If a leaf, increment the leaf count
-                if (this.leaf)
+                // Construct the new node.
+                this.Leaf = level == colorBits;
+                this.Red = 0;
+                this.Green = 0;
+                this.Blue = 0;
+                this.Alpha = 0;
+                this.PixelCount = 0;
+                this.PaletteIndex = 0;
+                this.NextReducibleIndex = -1;
+
+                // Always clear the Children array.
+                this.Children.Fill(-1);
+
+                if (this.Leaf)
                 {
                     octree.Leaves++;
-                    this.NextReducible = null;
-                    this.children = null;
                 }
                 else
                 {
-                    // Otherwise add this to the reducible nodes
-                    this.NextReducible = octree.ReducibleNodes[level];
-                    octree.ReducibleNodes[level] = this;
-                    this.children = new OctreeNode[8];
+                    // Add this node to the reducible nodes list for its level.
+                    this.NextReducibleIndex = octree.reducibleNodes[level];
+                    octree.reducibleNodes[level] = index;
                 }
             }
 
             /// <summary>
-            /// Gets the next reducible node
-            /// </summary>
-            public OctreeNode? NextReducible
-            {
-                [MethodImpl(InliningOptions.ShortMethod)]
-                get;
-            }
-
-            /// <summary>
-            /// Add a color into the tree
+            /// Add a color to the Octree.
             /// </summary>
+            /// <param name="nodeIndex">The node index.</param>
             /// <param name="color">The color to add.</param>
-            /// <param name="colorBits">The number of significant color bits.</param>
-            /// <param name="level">The level in the tree.</param>
-            /// <param name="octree">The tree to which this node belongs.</param>
-            public void AddColor(ref Rgba32 color, int colorBits, int level, Octree octree)
+            /// <param name="colorBits">The number of significant color bits in the image.</param>
+            /// <param name="level">The level of the node.</param>
+            /// <param name="octree">The parent octree.</param>
+            public static void AddColor(int nodeIndex, Rgba32 color, int colorBits, int level, Octree octree)
             {
-                // Update the color information if this is a leaf
-                if (this.leaf)
+                ref OctreeNode node = ref octree.Nodes[nodeIndex];
+                if (node.Leaf)
                 {
-                    this.Increment(ref color);
-
-                    // Setup the previous node
-                    octree.TrackPrevious(this);
+                    Increment(nodeIndex, color, octree);
+                    octree.TrackPrevious(nodeIndex);
                 }
                 else
                 {
-                    // Go to the next level down in the tree
-                    int index = GetColorIndex(ref color, level);
+                    int index = GetColorIndex(color, level);
+                    short childIndex;
 
-                    OctreeNode? child = this.children![index];
-                    if (child is null)
+                    Span<short> children = node.Children;
+                    childIndex = children[index];
+
+                    if (childIndex == -1)
                     {
-                        // Create a new child node and store it in the array
-                        child = new OctreeNode(level + 1, colorBits, octree);
-                        this.children[index] = child;
+                        childIndex = octree.AllocateNode();
+
+                        if (childIndex == -1)
+                        {
+                            // No room in the tree, so increment the count and return.
+                            Increment(nodeIndex, color, octree);
+                            octree.TrackPrevious(nodeIndex);
+                            return;
+                        }
+
+                        ref OctreeNode child = ref octree.Nodes[childIndex];
+                        child.Initialize(level + 1, colorBits, octree, childIndex);
+                        children[index] = childIndex;
                     }
 
-                    // Add the color to the child node
-                    child.AddColor(ref color, colorBits, level + 1, octree);
+                    AddColor(childIndex, color, colorBits, level + 1, octree);
                 }
             }
 
             /// <summary>
-            /// Reduce this node by removing all of its children
+            /// Increment the color components of this node.
+            /// </summary>
+            /// <param name="nodeIndex">The node index.</param>
+            /// <param name="color">The color to increment by.</param>
+            /// <param name="octree">The parent octree.</param>
+            public static void Increment(int nodeIndex, Rgba32 color, Octree octree)
+            {
+                ref OctreeNode node = ref octree.Nodes[nodeIndex];
+                node.PixelCount++;
+                node.Red += color.R;
+                node.Green += color.G;
+                node.Blue += color.B;
+                node.Alpha += color.A;
+            }
+
+            /// <summary>
+            /// Reduce this node by ensuring its children are all reduced (i.e. leaves) and then merging their data.
             /// </summary>
-            /// <returns>The number of leaves removed</returns>
-            public int Reduce()
+            /// <param name="octree">The parent octree.</param>
+            public void Reduce(Octree octree)
             {
-                this.red = this.green = this.blue = 0;
-                int childNodes = 0;
+                // If already a leaf, do nothing.
+                if (this.Leaf)
+                {
+                    return;
+                }
 
-                // Loop through all children and add their information to this node
-                for (int index = 0; index < 8; index++)
+                // Now merge the (presumably reduced) children.
+                int pixelCount = 0;
+                int sumRed = 0, sumGreen = 0, sumBlue = 0, sumAlpha = 0;
+                Span<short> children = this.Children;
+                for (int i = 0; i < children.Length; i++)
                 {
-                    OctreeNode? child = this.children![index];
-                    if (child != null)
+                    short childIndex = children[i];
+                    if (childIndex != -1)
                     {
-                        this.red += child.red;
-                        this.green += child.green;
-                        this.blue += child.blue;
-                        this.pixelCount += child.pixelCount;
-                        ++childNodes;
-                        this.children[index] = null;
+                        ref OctreeNode child = ref octree.Nodes[childIndex];
+                        int pixels = child.PixelCount;
+
+                        sumRed += child.Red;
+                        sumGreen += child.Green;
+                        sumBlue += child.Blue;
+                        sumAlpha += child.Alpha;
+                        pixelCount += pixels;
+
+                        // Free the child immediately.
+                        children[i] = -1;
+                        octree.FreeNode(childIndex);
                     }
                 }
 
-                // Now change this to a leaf node
-                this.leaf = true;
+                if (pixelCount > 0)
+                {
+                    this.Red = sumRed;
+                    this.Green = sumGreen;
+                    this.Blue = sumBlue;
+                    this.Alpha = sumAlpha;
+                    this.PixelCount = pixelCount;
+                }
+                else
+                {
+                    this.Red = this.Green = this.Blue = this.Alpha = 0;
+                    this.PixelCount = 0;
+                }
 
-                // Return the number of nodes to decrement the leaf count by
-                return childNodes - 1;
+                this.Leaf = true;
+                octree.Leaves++;
             }
 
             /// <summary>
-            /// Traverse the tree, building up the color palette
+            /// Traverse the tree to construct the palette.
             /// </summary>
-            /// <param name="palette">The palette</param>
-            /// <param name="index">The current palette index</param>
-            [MethodImpl(InliningOptions.ColdPath)]
-            public void ConstructPalette(Span<TPixel> palette, ref int index)
+            /// <param name="octree">The parent octree.</param>
+            /// <param name="palette">The palette to construct.</param>
+            /// <param name="paletteIndex">The current palette index.</param>
+            public void ConstructPalette(Octree octree, Span<TPixel> palette, ref short paletteIndex)
             {
-                if (this.leaf)
+                if (this.Leaf)
                 {
-                    // Set the color of the palette entry
-                    Vector3 vector = Vector3.Clamp(
-                        new Vector3(this.red, this.green, this.blue) / this.pixelCount,
-                        Vector3.Zero,
-                        new Vector3(255));
+                    Vector4 sum = new(this.Red, this.Green, this.Blue, this.Alpha);
+                    Vector4 offset = new(this.PixelCount >> 1);
+                    Vector4 vector = Vector4.Clamp(
+                        (sum + offset) / this.PixelCount,
+                        Vector4.Zero,
+                        new Vector4(255));
+
+                    if (vector.W < octree.transparencyThreshold255)
+                    {
+                        vector = Vector4.Zero;
+                    }
 
-                    palette[index] = TPixel.FromRgba32(new Rgba32((byte)vector.X, (byte)vector.Y, (byte)vector.Z));
+                    palette[paletteIndex] = TPixel.FromRgba32(new Rgba32((byte)vector.X, (byte)vector.Y, (byte)vector.Z, (byte)vector.W));
 
-                    // Consume the next palette index
-                    this.paletteIndex = index++;
+                    this.PaletteIndex = paletteIndex++;
                 }
                 else
                 {
-                    // Loop through children looking for leaves
-                    for (int i = 0; i < 8; i++)
+                    Span<short> children = this.Children;
+                    for (int i = 0; i < children.Length; i++)
                     {
-                        this.children![i]?.ConstructPalette(palette, ref index);
+                        int childIndex = children[i];
+                        if (childIndex != -1)
+                        {
+                            octree.Nodes[childIndex].ConstructPalette(octree, palette, ref paletteIndex);
+                        }
                     }
                 }
             }
 
             /// <summary>
-            /// Return the palette index for the passed color
+            /// Get the palette index for the passed color.
             /// </summary>
-            /// <param name="pixel">The pixel data.</param>
-            /// <param name="level">The level.</param>
-            /// <returns>
-            /// The <see cref="int"/> representing the index of the pixel in the palette.
-            /// </returns>
-            [MethodImpl(InliningOptions.ColdPath)]
-            public int GetPaletteIndex(ref Rgba32 pixel, int level)
+            /// <param name="color">The color to get the palette index for.</param>
+            /// <param name="level">The level of the node.</param>
+            /// <param name="octree">The parent octree.</param>
+            public int GetPaletteIndex(Rgba32 color, int level, Octree octree)
             {
-                if (this.leaf)
+                if (this.Leaf)
                 {
-                    return this.paletteIndex;
+                    return this.PaletteIndex;
                 }
 
-                int colorIndex = GetColorIndex(ref pixel, level);
-                OctreeNode? child = this.children![colorIndex];
-
-                int index = 0;
-                if (child != null)
+                int colorIndex = GetColorIndex(color, level);
+                Span<short> children = this.Children;
+                int childIndex = children[colorIndex];
+                if (childIndex != -1)
                 {
-                    index = child.GetPaletteIndex(ref pixel, level + 1);
+                    return octree.Nodes[childIndex].GetPaletteIndex(color, level + 1, octree);
                 }
-                else
+
+                for (int i = 0; i < children.Length; i++)
                 {
-                    // Check other children.
-                    for (int i = 0; i < this.children.Length; i++)
+                    childIndex = children[i];
+                    if (childIndex != -1)
                     {
-                        child = this.children[i];
-                        if (child != null)
+                        int childPaletteIndex = octree.Nodes[childIndex].GetPaletteIndex(color, level + 1, octree);
+                        if (childPaletteIndex != -1)
                         {
-                            int childIndex = child.GetPaletteIndex(ref pixel, level + 1);
-                            if (childIndex != 0)
-                            {
-                                return childIndex;
-                            }
+                            return childPaletteIndex;
                         }
                     }
                 }
 
-                return index;
+                return -1;
             }
 
             /// <summary>
             /// Gets the color index at the given level.
             /// </summary>
-            /// <param name="color">The color.</param>
-            /// <param name="level">The node level.</param>
-            /// <returns>The <see cref="int"/> index.</returns>
-            [MethodImpl(InliningOptions.ShortMethod)]
-            private static int GetColorIndex(ref Rgba32 color, int level)
+            /// <param name="color">The color to get the index for.</param>
+            /// <param name="level">The level to get the index at.</param>
+            public static int GetColorIndex(Rgba32 color, int level)
             {
+                // Determine how many bits to shift based on the current tree level.
+                // At level 0, shift = 7; as level increases, the shift decreases.
                 int shift = 7 - level;
                 byte mask = (byte)(1 << shift);
 
-                return ((color.R & mask) >> shift)
-                    | (((color.G & mask) >> shift) << 1)
-                    | (((color.B & mask) >> shift) << 2);
-            }
+                // Compute the luminance of the RGB components using the BT.709 standard.
+                // This gives a measure of brightness for the color.
+                int luminance = ColorNumerics.Get8BitBT709Luminance(color.R, color.G, color.B);
 
-            /// <summary>
-            /// Increment the color count and add to the color information
-            /// </summary>
-            /// <param name="color">The pixel to add.</param>
-            [MethodImpl(InliningOptions.ShortMethod)]
-            public void Increment(ref Rgba32 color)
-            {
-                this.pixelCount++;
-                this.red += color.R;
-                this.green += color.G;
-                this.blue += color.B;
+                // Define thresholds for determining when to include the alpha bit in the index.
+                // The thresholds are scaled according to the current level.
+                // 128 is the midpoint of the 8-bit range (0–255), so shifting it right by 'level'
+                // produces a threshold that scales with the color cube subdivision.
+                int darkThreshold = 128 >> level;
+
+                // The light threshold is set symmetrically: 255 minus the scaled midpoint.
+                int lightThreshold = 255 - (128 >> level);
+
+                // If the pixel is fully opaque and its brightness falls between the dark and light thresholds,
+                // ignore the alpha channel to maximize RGB resolution.
+                // Otherwise (if the pixel is dark, light, or semi-transparent), include the alpha bit
+                // to preserve any gradient that may be present.
+                if (color.A == 255 && luminance > darkThreshold && luminance < lightThreshold)
+                {
+                    // Extract one bit each from R, G, and B channels and combine them into a 3-bit index.
+                    int rBits = ((color.R & mask) >> shift) << 2;
+                    int gBits = ((color.G & mask) >> shift) << 1;
+                    int bBits = (color.B & mask) >> shift;
+                    return rBits | gBits | bBits;
+                }
+                else
+                {
+                    // Extract one bit from each channel including alpha (alpha becomes the most significant bit).
+                    int aBits = ((color.A & mask) >> shift) << 3;
+                    int rBits = ((color.R & mask) >> shift) << 2;
+                    int gBits = ((color.G & mask) >> shift) << 1;
+                    int bBits = (color.B & mask) >> shift;
+                    return aBits | rBits | gBits | bBits;
+                }
             }
         }
     }
diff --git a/src/ImageSharp/Processing/Processors/Quantization/PaletteQuantizer.cs b/src/ImageSharp/Processing/Processors/Quantization/PaletteQuantizer.cs
index 13a59a26de..a49691515a 100644
--- a/src/ImageSharp/Processing/Processors/Quantization/PaletteQuantizer.cs
+++ b/src/ImageSharp/Processing/Processors/Quantization/PaletteQuantizer.cs
@@ -11,7 +11,8 @@ namespace SixLabors.ImageSharp.Processing.Processors.Quantization;
 public class PaletteQuantizer : IQuantizer
 {
     private readonly ReadOnlyMemory<Color> colorPalette;
-    private readonly int transparentIndex;
+    private readonly int transparencyIndex;
+    private readonly Color transparentColor;
 
     /// <summary>
     /// Initializes a new instance of the <see cref="PaletteQuantizer"/> class.
@@ -25,27 +26,33 @@ public class PaletteQuantizer : IQuantizer
     /// <summary>
     /// Initializes a new instance of the <see cref="PaletteQuantizer"/> class.
     /// </summary>
-    /// <param name="palette">The color palette.</param>
+    /// <param name="palette">The color palette to use.</param>
     /// <param name="options">The quantizer options defining quantization rules.</param>
     public PaletteQuantizer(ReadOnlyMemory<Color> palette, QuantizerOptions options)
-        : this(palette, options, -1)
+        : this(palette, options, -1, default)
     {
     }
 
     /// <summary>
     /// Initializes a new instance of the <see cref="PaletteQuantizer"/> class.
     /// </summary>
-    /// <param name="palette">The color palette.</param>
+    /// <param name="palette">The color palette to use.</param>
     /// <param name="options">The quantizer options defining quantization rules.</param>
-    /// <param name="transparentIndex">An explicit index at which to match transparent pixels.</param>
-    internal PaletteQuantizer(ReadOnlyMemory<Color> palette, QuantizerOptions options, int transparentIndex)
+    /// <param name="transparencyIndex">The index of the color in the palette that should be considered as transparent.</param>
+    /// <param name="transparentColor">The color that should be considered as transparent.</param>
+    internal PaletteQuantizer(
+        ReadOnlyMemory<Color> palette,
+        QuantizerOptions options,
+        int transparencyIndex,
+        Color transparentColor)
     {
         Guard.MustBeGreaterThan(palette.Length, 0, nameof(palette));
         Guard.NotNull(options, nameof(options));
 
         this.colorPalette = palette;
         this.Options = options;
-        this.transparentIndex = transparentIndex;
+        this.transparencyIndex = transparencyIndex;
+        this.transparentColor = transparentColor;
     }
 
     /// <inheritdoc />
@@ -66,6 +73,6 @@ public class PaletteQuantizer : IQuantizer
         // treat the buffer as FILO.
         TPixel[] palette = new TPixel[Math.Min(options.MaxColors, this.colorPalette.Length)];
         Color.ToPixel(this.colorPalette.Span[..palette.Length], palette.AsSpan());
-        return new PaletteQuantizer<TPixel>(configuration, options, palette, this.transparentIndex);
+        return new PaletteQuantizer<TPixel>(configuration, options, palette, this.transparencyIndex, this.transparentColor.ToPixel<TPixel>());
     }
 }
diff --git a/src/ImageSharp/Processing/Processors/Quantization/PaletteQuantizer{TPixel}.cs b/src/ImageSharp/Processing/Processors/Quantization/PaletteQuantizer{TPixel}.cs
index 092975d28a..4fd044ab40 100644
--- a/src/ImageSharp/Processing/Processors/Quantization/PaletteQuantizer{TPixel}.cs
+++ b/src/ImageSharp/Processing/Processors/Quantization/PaletteQuantizer{TPixel}.cs
@@ -17,10 +17,12 @@ 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 readonly struct PaletteQuantizer<TPixel> : IQuantizer<TPixel>
+internal struct PaletteQuantizer<TPixel> : IQuantizer<TPixel>
     where TPixel : unmanaged, IPixel<TPixel>
 {
-    private readonly EuclideanPixelMap<TPixel> pixelMap;
+    private readonly PixelMap<TPixel> pixelMap;
+    private int transparencyIndex;
+    private TPixel transparentColor;
 
     /// <summary>
     /// Initializes a new instance of the <see cref="PaletteQuantizer{TPixel}"/> struct.
@@ -28,20 +30,37 @@ internal readonly struct PaletteQuantizer<TPixel> : IQuantizer<TPixel>
     /// <param name="configuration">The configuration which allows altering default behavior or extending the library.</param>
     /// <param name="options">The quantizer options defining quantization rules.</param>
     /// <param name="palette">The palette to use.</param>
-    /// <param name="transparentIndex">An explicit index at which to match transparent pixels.</param>
     [MethodImpl(InliningOptions.ShortMethod)]
+    public PaletteQuantizer(Configuration configuration, QuantizerOptions options, ReadOnlyMemory<TPixel> palette)
+        : this(configuration, options, palette, -1, default)
+    {
+        Guard.NotNull(configuration, nameof(configuration));
+        Guard.NotNull(options, nameof(options));
+    }
+
+    /// <summary>
+    /// Initializes a new instance of the <see cref="PaletteQuantizer{TPixel}"/> struct.
+    /// </summary>
+    /// <param name="configuration">The configuration which allows altering default behavior or extending the library.</param>
+    /// <param name="options">The quantizer options defining quantization rules.</param>
+    /// <param name="palette">The palette to use.</param>
+    /// <param name="transparencyIndex">The index of the color in the palette that should be considered as transparent.</param>
+    /// <param name="transparentColor">The color that should be considered as transparent.</param>
     public PaletteQuantizer(
         Configuration configuration,
         QuantizerOptions options,
         ReadOnlyMemory<TPixel> palette,
-        int transparentIndex)
+        int transparencyIndex,
+        TPixel transparentColor)
     {
         Guard.NotNull(configuration, nameof(configuration));
         Guard.NotNull(options, nameof(options));
 
         this.Configuration = configuration;
         this.Options = options;
-        this.pixelMap = new EuclideanPixelMap<TPixel>(configuration, palette, transparentIndex);
+        this.pixelMap = PixelMapFactory.Create(this.Configuration, palette, options.ColorMatchingMode);
+        this.transparencyIndex = transparencyIndex;
+        this.transparentColor = transparentColor;
     }
 
     /// <inheritdoc/>
@@ -51,7 +70,13 @@ internal readonly struct PaletteQuantizer<TPixel> : IQuantizer<TPixel>
     public QuantizerOptions Options { get; }
 
     /// <inheritdoc/>
-    public ReadOnlyMemory<TPixel> Palette => this.pixelMap.Palette;
+    public readonly ReadOnlyMemory<TPixel> Palette => this.pixelMap.Palette;
+
+    /// <inheritdoc/>
+    [MethodImpl(InliningOptions.ShortMethod)]
+    public readonly void AddPaletteColors(in Buffer2DRegion<TPixel> pixelRegion)
+    {
+    }
 
     /// <inheritdoc/>
     [MethodImpl(InliningOptions.ShortMethod)]
@@ -60,21 +85,23 @@ internal readonly struct PaletteQuantizer<TPixel> : IQuantizer<TPixel>
 
     /// <inheritdoc/>
     [MethodImpl(InliningOptions.ShortMethod)]
-    public void AddPaletteColors(Buffer2DRegion<TPixel> pixelRegion)
+    public readonly byte GetQuantizedColor(TPixel color, out TPixel match)
     {
-    }
+        if (this.transparencyIndex >= 0 && color.Equals(this.transparentColor))
+        {
+            match = this.transparentColor;
+            return (byte)this.transparencyIndex;
+        }
 
-    /// <summary>
-    /// Allows setting the transparent index after construction.
-    /// </summary>
-    /// <param name="index">An explicit index at which to match transparent pixels.</param>
-    public void SetTransparentIndex(int index) => this.pixelMap.SetTransparentIndex(index);
+        return (byte)this.pixelMap.GetClosestColor(color, out match);
+    }
 
-    /// <inheritdoc/>
-    [MethodImpl(InliningOptions.ShortMethod)]
-    public readonly byte GetQuantizedColor(TPixel color, out TPixel match)
-        => (byte)this.pixelMap.GetClosestColor(color, out match);
+    public void SetTransparencyIndex(int transparencyIndex, TPixel transparentColor)
+    {
+        this.transparencyIndex = transparencyIndex;
+        this.transparentColor = transparentColor;
+    }
 
     /// <inheritdoc/>
-    public void Dispose() => this.pixelMap.Dispose();
+    public readonly void Dispose() => this.pixelMap.Dispose();
 }
diff --git a/src/ImageSharp/Processing/Processors/Quantization/QuantizerConstants.cs b/src/ImageSharp/Processing/Processors/Quantization/QuantizerConstants.cs
index 2bf4c6d56d..3b515e372d 100644
--- a/src/ImageSharp/Processing/Processors/Quantization/QuantizerConstants.cs
+++ b/src/ImageSharp/Processing/Processors/Quantization/QuantizerConstants.cs
@@ -21,15 +21,30 @@ public static class QuantizerConstants
     public const int MaxColors = 256;
 
     /// <summary>
-    /// The minumim dithering scale used to adjust the amount of dither.
+    /// The minimum dithering scale used to adjust the amount of dither.
     /// </summary>
     public const float MinDitherScale = 0;
 
     /// <summary>
-    /// The max dithering scale used to adjust the amount of dither.
+    /// The maximum dithering scale used to adjust the amount of dither.
     /// </summary>
     public const float MaxDitherScale = 1F;
 
+    /// <summary>
+    /// The default threshold at which to consider a pixel transparent.
+    /// </summary>
+    public const float DefaultTransparencyThreshold = 64 / 255F;
+
+    /// <summary>
+    /// The minimum threshold at which to consider a pixel transparent.
+    /// </summary>
+    public const float MinTransparencyThreshold = 0F;
+
+    /// <summary>
+    /// The maximum threshold at which to consider a pixel transparent.
+    /// </summary>
+    public const float MaxTransparencyThreshold = 1F;
+
     /// <summary>
     /// Gets the default dithering algorithm to use.
     /// </summary>
diff --git a/src/ImageSharp/Processing/Processors/Quantization/QuantizerOptions.cs b/src/ImageSharp/Processing/Processors/Quantization/QuantizerOptions.cs
index a6bb265a81..16dfd5b330 100644
--- a/src/ImageSharp/Processing/Processors/Quantization/QuantizerOptions.cs
+++ b/src/ImageSharp/Processing/Processors/Quantization/QuantizerOptions.cs
@@ -1,6 +1,7 @@
 // Copyright (c) Six Labors.
 // Licensed under the Six Labors Split License.
 
+using SixLabors.ImageSharp.Formats;
 using SixLabors.ImageSharp.Processing.Processors.Dithering;
 
 namespace SixLabors.ImageSharp.Processing.Processors.Quantization;
@@ -8,10 +9,34 @@ namespace SixLabors.ImageSharp.Processing.Processors.Quantization;
 /// <summary>
 /// Defines options for quantization.
 /// </summary>
-public class QuantizerOptions
+public class QuantizerOptions : IDeepCloneable<QuantizerOptions>
 {
+#pragma warning disable IDE0032 // Use auto property
     private float ditherScale = QuantizerConstants.MaxDitherScale;
     private int maxColors = QuantizerConstants.MaxColors;
+    private float threshold = QuantizerConstants.DefaultTransparencyThreshold;
+#pragma warning restore IDE0032 // Use auto property
+
+    /// <summary>
+    /// Initializes a new instance of the <see cref="QuantizerOptions"/> class.
+    /// </summary>
+    public QuantizerOptions()
+    {
+    }
+
+    /// <summary>
+    /// Initializes a new instance of the <see cref="QuantizerOptions"/> class.
+    /// </summary>
+    /// <param name="options">The options to clone.</param>
+    private QuantizerOptions(QuantizerOptions options)
+    {
+        this.Dither = options.Dither;
+        this.DitherScale = options.DitherScale;
+        this.MaxColors = options.MaxColors;
+        this.TransparencyThreshold = options.TransparencyThreshold;
+        this.ColorMatchingMode = options.ColorMatchingMode;
+        this.TransparentColorMode = options.TransparentColorMode;
+    }
 
     /// <summary>
     /// Gets or sets the  algorithm to apply to the output image.
@@ -38,4 +63,30 @@ public class QuantizerOptions
         get => this.maxColors;
         set => this.maxColors = Numerics.Clamp(value, QuantizerConstants.MinColors, QuantizerConstants.MaxColors);
     }
+
+    /// <summary>
+    /// Gets or sets the color matching mode used for matching pixel values to palette colors.
+    /// Defaults to <see cref="ColorMatchingMode.Coarse"/>.
+    /// </summary>
+    public ColorMatchingMode ColorMatchingMode { get; set; } = ColorMatchingMode.Coarse;
+
+    /// <summary>
+    /// Gets or sets the threshold at which to consider a pixel transparent. Range 0..1.
+    /// Defaults to <see cref="QuantizerConstants.DefaultTransparencyThreshold"/>.
+    /// </summary>
+    public float TransparencyThreshold
+    {
+        get => this.threshold;
+        set => this.threshold = Numerics.Clamp(value, QuantizerConstants.MinTransparencyThreshold, QuantizerConstants.MaxTransparencyThreshold);
+    }
+
+    /// <summary>
+    /// Gets or sets the transparent color mode used for handling transparent colors
+    /// when not using thresholding.
+    /// Defaults to <see cref="TransparentColorMode.Preserve"/>.
+    /// </summary>
+    public TransparentColorMode TransparentColorMode { get; set; } = TransparentColorMode.Preserve;
+
+    /// <inheritdoc/>
+    public QuantizerOptions DeepClone() => new(this);
 }
diff --git a/src/ImageSharp/Processing/Processors/Quantization/QuantizerUtilities.cs b/src/ImageSharp/Processing/Processors/Quantization/QuantizerUtilities.cs
index 6d2200b8a7..e121aff90b 100644
--- a/src/ImageSharp/Processing/Processors/Quantization/QuantizerUtilities.cs
+++ b/src/ImageSharp/Processing/Processors/Quantization/QuantizerUtilities.cs
@@ -1,7 +1,11 @@
 // Copyright (c) Six Labors.
 // Licensed under the Six Labors Split License.
 
+using System.Buffers;
+using System.Numerics;
 using System.Runtime.CompilerServices;
+using System.Runtime.InteropServices;
+using System.Runtime.Intrinsics;
 using SixLabors.ImageSharp.Formats;
 using SixLabors.ImageSharp.Memory;
 using SixLabors.ImageSharp.PixelFormats;
@@ -14,6 +18,130 @@ namespace SixLabors.ImageSharp.Processing.Processors.Quantization;
 /// </summary>
 public static class QuantizerUtilities
 {
+    /// <summary>
+    /// Performs a deep clone the <see cref="QuantizerOptions"/> instance and optionally mutates the clone.
+    /// </summary>
+    /// <param name="options">The <see cref="QuantizerOptions"/> instance to clone.</param>
+    /// <param name="mutate">An optional delegate to mutate the cloned instance.</param>
+    /// <returns>The cloned <see cref="QuantizerOptions"/> instance.</returns>
+    public static QuantizerOptions DeepClone(this QuantizerOptions options, Action<QuantizerOptions>? mutate)
+    {
+        QuantizerOptions clone = options.DeepClone();
+        mutate?.Invoke(clone);
+        return clone;
+    }
+
+    /// <summary>
+    /// Determines if transparent pixels can be replaced based on the specified color mode and pixel type.
+    /// </summary>
+    /// <typeparam name="TPixel">The type of the pixel.</typeparam>
+    /// <param name="threshold">The alpha threshold used to determine if a pixel is transparent.</param>
+    /// <returns>Returns true if transparent pixels can be replaced; otherwise, false.</returns>
+    public static bool ShouldReplacePixelsByAlphaThreshold<TPixel>(float threshold)
+        where TPixel : unmanaged, IPixel<TPixel>
+        => threshold > 0 && TPixel.GetPixelTypeInfo().AlphaRepresentation == PixelAlphaRepresentation.Unassociated;
+
+    /// <summary>
+    /// Replaces pixels in a span with fully transparent pixels based on an alpha threshold.
+    /// </summary>
+    /// <param name="source">A span of color vectors that will be checked for transparency and potentially modified.</param>
+    /// <param name="threshold">The alpha threshold used to determine if a pixel is transparent.</param>
+    public static void ReplacePixelsByAlphaThreshold(Span<Vector4> source, float threshold)
+    {
+        if (Vector512.IsHardwareAccelerated && source.Length >= 4)
+        {
+            Vector512<float> threshold512 = Vector512.Create(threshold);
+            Span<Vector512<float>> source512 = MemoryMarshal.Cast<Vector4, Vector512<float>>(source);
+            for (int i = 0; i < source512.Length; i++)
+            {
+                ref Vector512<float> v = ref source512[i];
+
+                // Do `vector < threshold`
+                Vector512<float> mask = Vector512.LessThan(v, threshold512);
+
+                // Replicate the result for W to all elements (is AllBitsSet if the W was less than threshold and Zero otherwise)
+                mask = Vector512.Shuffle(mask, Vector512.Create(3, 3, 3, 3, 7, 7, 7, 7, 11, 11, 11, 11, 15, 15, 15, 15));
+
+                // Use the mask to select the replacement vector
+                // (replacement & mask) | (v512 & ~mask)
+                v = Vector512.ConditionalSelect(mask, Vector512<float>.Zero, v);
+            }
+
+            int m = Numerics.Modulo4(source.Length);
+            if (m != 0)
+            {
+                for (int i = source.Length - m; i < source.Length; i++)
+                {
+                    if (source[i].W < threshold)
+                    {
+                        source[i] = Vector4.Zero;
+                    }
+                }
+            }
+        }
+        else if (Vector256.IsHardwareAccelerated && source.Length >= 2)
+        {
+            Vector256<float> threshold256 = Vector256.Create(threshold);
+            Span<Vector256<float>> source256 = MemoryMarshal.Cast<Vector4, Vector256<float>>(source);
+            for (int i = 0; i < source256.Length; i++)
+            {
+                ref Vector256<float> v = ref source256[i];
+
+                // Do `vector < threshold`
+                Vector256<float> mask = Vector256.LessThan(v, threshold256);
+
+                // Replicate the result for W to all elements (is AllBitsSet if the W was less than threshold and Zero otherwise)
+                mask = Vector256.Shuffle(mask, Vector256.Create(3, 3, 3, 3, 7, 7, 7, 7));
+
+                // Use the mask to select the replacement vector
+                // (replacement & mask) | (v256 & ~mask)
+                v = Vector256.ConditionalSelect(mask, Vector256<float>.Zero, v);
+            }
+
+            int m = Numerics.Modulo2(source.Length);
+            if (m != 0)
+            {
+                for (int i = source.Length - m; i < source.Length; i++)
+                {
+                    if (source[i].W < threshold)
+                    {
+                        source[i] = Vector4.Zero;
+                    }
+                }
+            }
+        }
+        else if (Vector128.IsHardwareAccelerated)
+        {
+            Vector128<float> threshold128 = Vector128.Create(threshold);
+
+            for (int i = 0; i < source.Length; i++)
+            {
+                ref Vector4 v = ref source[i];
+                Vector128<float> v128 = v.AsVector128();
+
+                // Do `vector < threshold`
+                Vector128<float> mask = Vector128.LessThan(v128, threshold128);
+
+                // Replicate the result for W to all elements (is AllBitsSet if the W was less than threshold and Zero otherwise)
+                mask = Vector128.Shuffle(mask, Vector128.Create(3, 3, 3, 3));
+
+                // Use the mask to select the replacement vector
+                // (replacement & mask) | (v128 & ~mask)
+                v = Vector128.ConditionalSelect(mask, Vector128<float>.Zero, v128).AsVector4();
+            }
+        }
+        else
+        {
+            for (int i = 0; i < source.Length; i++)
+            {
+                if (source[i].W < threshold)
+                {
+                    source[i] = Vector4.Zero;
+                }
+            }
+        }
+    }
+
     /// <summary>
     /// Helper method for throwing an exception when a frame quantizer palette has
     /// been requested but not built yet.
@@ -21,12 +149,13 @@ public static class QuantizerUtilities
     /// <typeparam name="TPixel">The pixel format.</typeparam>
     /// <param name="palette">The frame quantizer palette.</param>
     /// <exception cref="InvalidOperationException">
-    /// The palette has not been built via <see cref="IQuantizer{TPixel}.AddPaletteColors"/>
+    /// The palette has not been built via <see cref="IQuantizer{TPixel}.AddPaletteColors(in Buffer2DRegion{TPixel})"/>
     /// </exception>
+    [MethodImpl(InliningOptions.ColdPath)]
     public static void CheckPaletteState<TPixel>(in ReadOnlyMemory<TPixel> palette)
         where TPixel : unmanaged, IPixel<TPixel>
     {
-        if (palette.Equals(default))
+        if (palette.IsEmpty)
         {
             throw new InvalidOperationException("Frame Quantizer palette has not been built.");
         }
@@ -54,8 +183,7 @@ public static class QuantizerUtilities
         Rectangle interest = Rectangle.Intersect(source.Bounds, bounds);
         Buffer2DRegion<TPixel> region = source.PixelBuffer.GetRegion(interest);
 
-        // Collect the palette. Required before the second pass runs.
-        quantizer.AddPaletteColors(region);
+        quantizer.AddPaletteColors(in region);
         return quantizer.QuantizeFrame(source, bounds);
     }
 
@@ -112,39 +240,10 @@ public static class QuantizerUtilities
         IPixelSamplingStrategy pixelSamplingStrategy,
         Image<TPixel> source)
         where TPixel : unmanaged, IPixel<TPixel>
-        => quantizer.BuildPalette(source.Configuration, TransparentColorMode.Preserve, pixelSamplingStrategy, source);
-
-    /// <summary>
-    /// Adds colors to the quantized palette from the given pixel regions.
-    /// </summary>
-    /// <typeparam name="TPixel">The pixel format.</typeparam>
-    /// <param name="quantizer">The pixel specific quantizer.</param>
-    /// <param name="configuration">The configuration.</param>
-    /// <param name="mode">The transparent color mode.</param>
-    /// <param name="pixelSamplingStrategy">The pixel sampling strategy.</param>
-    /// <param name="source">The source image to sample from.</param>
-    public static void BuildPalette<TPixel>(
-        this IQuantizer<TPixel> quantizer,
-        Configuration configuration,
-        TransparentColorMode mode,
-        IPixelSamplingStrategy pixelSamplingStrategy,
-        Image<TPixel> source)
-        where TPixel : unmanaged, IPixel<TPixel>
     {
-        if (EncodingUtilities.ShouldClearTransparentPixels<TPixel>(mode))
-        {
-            foreach (Buffer2DRegion<TPixel> region in pixelSamplingStrategy.EnumeratePixelRegions(source))
-            {
-                using Buffer2D<TPixel> clone = region.Buffer.CloneRegion(configuration, region.Rectangle);
-                quantizer.AddPaletteColors(clone.GetRegion());
-            }
-        }
-        else
+        foreach (Buffer2DRegion<TPixel> region in pixelSamplingStrategy.EnumeratePixelRegions(source))
         {
-            foreach (Buffer2DRegion<TPixel> region in pixelSamplingStrategy.EnumeratePixelRegions(source))
-            {
-                quantizer.AddPaletteColors(region);
-            }
+            quantizer.AddPaletteColors(in region);
         }
     }
 
@@ -160,43 +259,75 @@ public static class QuantizerUtilities
         IPixelSamplingStrategy pixelSamplingStrategy,
         ImageFrame<TPixel> source)
         where TPixel : unmanaged, IPixel<TPixel>
-        => quantizer.BuildPalette(source.Configuration, TransparentColorMode.Preserve, pixelSamplingStrategy, source);
+    {
+        foreach (Buffer2DRegion<TPixel> region in pixelSamplingStrategy.EnumeratePixelRegions(source))
+        {
+            quantizer.AddPaletteColors(in region);
+        }
+    }
 
-    /// <summary>
-    /// Adds colors to the quantized palette from the given pixel regions.
-    /// </summary>
-    /// <typeparam name="TPixel">The pixel format.</typeparam>
-    /// <param name="quantizer">The pixel specific quantizer.</param>
-    /// <param name="configuration">The configuration.</param>
-    /// <param name="mode">The transparent color mode.</param>
-    /// <param name="pixelSamplingStrategy">The pixel sampling strategy.</param>
-    /// <param name="source">The source image frame to sample from.</param>
-    public static void BuildPalette<TPixel>(
-        this IQuantizer<TPixel> quantizer,
-        Configuration configuration,
-        TransparentColorMode mode,
-        IPixelSamplingStrategy pixelSamplingStrategy,
-        ImageFrame<TPixel> source)
+    internal static void AddPaletteColors<TFrameQuantizer, TPixel, TPixel2, TDelegate>(
+        ref TFrameQuantizer quantizer,
+        in Buffer2DRegion<TPixel> source,
+        in TDelegate rowDelegate)
+        where TFrameQuantizer : struct, IQuantizer<TPixel>
         where TPixel : unmanaged, IPixel<TPixel>
+        where TPixel2 : unmanaged, IPixel<TPixel2>
+        where TDelegate : struct, IQuantizingPixelRowDelegate<TPixel2>
     {
-        if (EncodingUtilities.ShouldClearTransparentPixels<TPixel>(mode))
+        Configuration configuration = quantizer.Configuration;
+        float threshold = quantizer.Options.TransparencyThreshold;
+        TransparentColorMode mode = quantizer.Options.TransparentColorMode;
+
+        using IMemoryOwner<TPixel2> delegateRowOwner = configuration.MemoryAllocator.Allocate<TPixel2>(source.Width);
+        Span<TPixel2> delegateRow = delegateRowOwner.Memory.Span;
+
+        bool replaceByThreshold = ShouldReplacePixelsByAlphaThreshold<TPixel>(threshold);
+        bool replaceTransparent = EncodingUtilities.ShouldReplaceTransparentPixels<TPixel>(mode);
+
+        if (replaceByThreshold || replaceTransparent)
         {
-            foreach (Buffer2DRegion<TPixel> region in pixelSamplingStrategy.EnumeratePixelRegions(source))
+            using IMemoryOwner<Vector4> vectorRowOwner = configuration.MemoryAllocator.Allocate<Vector4>(source.Width);
+            Span<Vector4> vectorRow = vectorRowOwner.Memory.Span;
+
+            if (replaceByThreshold)
             {
-                using Buffer2D<TPixel> clone = region.Buffer.CloneRegion(configuration, region.Rectangle);
-                quantizer.AddPaletteColors(clone.GetRegion());
+                for (int y = 0; y < source.Height; y++)
+                {
+                    Span<TPixel> sourceRow = source.DangerousGetRowSpan(y);
+                    PixelOperations<TPixel>.Instance.ToVector4(configuration, sourceRow, vectorRow, PixelConversionModifiers.Scale);
+
+                    ReplacePixelsByAlphaThreshold(vectorRow, threshold);
+
+                    PixelOperations<TPixel2>.Instance.FromVector4Destructive(configuration, vectorRow, delegateRow, PixelConversionModifiers.Scale);
+                    rowDelegate.Invoke(delegateRow, y);
+                }
+            }
+            else
+            {
+                for (int y = 0; y < source.Height; y++)
+                {
+                    Span<TPixel> sourceRow = source.DangerousGetRowSpan(y);
+                    PixelOperations<TPixel>.Instance.ToVector4(configuration, sourceRow, vectorRow, PixelConversionModifiers.Scale);
+
+                    EncodingUtilities.ReplaceTransparentPixels(vectorRow);
+
+                    PixelOperations<TPixel2>.Instance.FromVector4Destructive(configuration, vectorRow, delegateRow, PixelConversionModifiers.Scale);
+                    rowDelegate.Invoke(delegateRow, y);
+                }
             }
         }
         else
         {
-            foreach (Buffer2DRegion<TPixel> region in pixelSamplingStrategy.EnumeratePixelRegions(source))
+            for (int y = 0; y < source.Height; y++)
             {
-                quantizer.AddPaletteColors(region);
+                Span<TPixel> sourceRow = source.DangerousGetRowSpan(y);
+                PixelOperations<TPixel>.Instance.To(configuration, sourceRow, delegateRow);
+                rowDelegate.Invoke(delegateRow, y);
             }
         }
     }
 
-    [MethodImpl(InliningOptions.ShortMethod)]
     private static void SecondPass<TFrameQuantizer, TPixel>(
         ref TFrameQuantizer quantizer,
         ImageFrame<TPixel> source,
@@ -205,28 +336,111 @@ public static class QuantizerUtilities
         where TFrameQuantizer : struct, IQuantizer<TPixel>
         where TPixel : unmanaged, IPixel<TPixel>
     {
+        float threshold = quantizer.Options.TransparencyThreshold;
+        bool replaceByThreshold = ShouldReplacePixelsByAlphaThreshold<TPixel>(threshold);
+
+        TransparentColorMode mode = quantizer.Options.TransparentColorMode;
+        bool replaceTransparent = EncodingUtilities.ShouldReplaceTransparentPixels<TPixel>(mode);
+
         IDither? dither = quantizer.Options.Dither;
         Buffer2D<TPixel> sourceBuffer = source.PixelBuffer;
+        Buffer2DRegion<TPixel> region = sourceBuffer.GetRegion(bounds);
+
+        Configuration configuration = quantizer.Configuration;
+        using IMemoryOwner<Vector4> vectorOwner = configuration.MemoryAllocator.Allocate<Vector4>(region.Width);
+        Span<Vector4> vectorRow = vectorOwner.Memory.Span;
 
         if (dither is null)
         {
-            int offsetY = bounds.Top;
-            int offsetX = bounds.Left;
+            using IMemoryOwner<TPixel> quantizingRowOwner = configuration.MemoryAllocator.Allocate<TPixel>(region.Width);
+            Span<TPixel> quantizingRow = quantizingRowOwner.Memory.Span;
+
+            // This is NOT a clone so we DO NOT write back to the source.
+            if (replaceByThreshold || replaceTransparent)
+            {
+                if (replaceByThreshold)
+                {
+                    for (int y = 0; y < region.Height; y++)
+                    {
+                        Span<TPixel> sourceRow = region.DangerousGetRowSpan(y);
+                        PixelOperations<TPixel>.Instance.ToVector4(configuration, sourceRow, vectorRow, PixelConversionModifiers.Scale);
+
+                        ReplacePixelsByAlphaThreshold(vectorRow, threshold);
+
+                        PixelOperations<TPixel>.Instance.FromVector4Destructive(configuration, vectorRow, quantizingRow, PixelConversionModifiers.Scale);
+
+                        Span<byte> destinationRow = destination.GetWritablePixelRowSpanUnsafe(y);
+                        for (int x = 0; x < destinationRow.Length; x++)
+                        {
+                            destinationRow[x] = quantizer.GetQuantizedColor(quantizingRow[x], out TPixel _);
+                        }
+                    }
+                }
+                else
+                {
+                    for (int y = 0; y < region.Height; y++)
+                    {
+                        Span<TPixel> sourceRow = region.DangerousGetRowSpan(y);
+                        PixelOperations<TPixel>.Instance.ToVector4(configuration, sourceRow, vectorRow, PixelConversionModifiers.Scale);
+
+                        EncodingUtilities.ReplaceTransparentPixels(vectorRow);
+
+                        PixelOperations<TPixel>.Instance.FromVector4Destructive(configuration, vectorRow, quantizingRow, PixelConversionModifiers.Scale);
+
+                        Span<byte> destinationRow = destination.GetWritablePixelRowSpanUnsafe(y);
+                        for (int x = 0; x < destinationRow.Length; x++)
+                        {
+                            destinationRow[x] = quantizer.GetQuantizedColor(quantizingRow[x], out TPixel _);
+                        }
+                    }
+                }
 
-            for (int y = 0; y < destination.Height; y++)
+                return;
+            }
+
+            for (int y = 0; y < region.Height; y++)
             {
-                ReadOnlySpan<TPixel> sourceRow = sourceBuffer.DangerousGetRowSpan(y + offsetY);
+                ReadOnlySpan<TPixel> sourceRow = region.DangerousGetRowSpan(y);
                 Span<byte> destinationRow = destination.GetWritablePixelRowSpanUnsafe(y);
 
                 for (int x = 0; x < destinationRow.Length; x++)
                 {
-                    destinationRow[x] = Unsafe.AsRef(in quantizer).GetQuantizedColor(sourceRow[x + offsetX], out TPixel _);
+                    destinationRow[x] = quantizer.GetQuantizedColor(sourceRow[x], out TPixel _);
                 }
             }
 
             return;
         }
 
+        // This is a clone so we write back to the source.
+        if (replaceByThreshold || replaceTransparent)
+        {
+            if (replaceByThreshold)
+            {
+                for (int y = 0; y < region.Height; y++)
+                {
+                    Span<TPixel> sourceRow = region.DangerousGetRowSpan(y);
+                    PixelOperations<TPixel>.Instance.ToVector4(configuration, sourceRow, vectorRow, PixelConversionModifiers.Scale);
+
+                    ReplacePixelsByAlphaThreshold(vectorRow, threshold);
+
+                    PixelOperations<TPixel>.Instance.FromVector4Destructive(configuration, vectorRow, sourceRow, PixelConversionModifiers.Scale);
+                }
+            }
+            else
+            {
+                for (int y = 0; y < region.Height; y++)
+                {
+                    Span<TPixel> sourceRow = region.DangerousGetRowSpan(y);
+                    PixelOperations<TPixel>.Instance.ToVector4(configuration, sourceRow, vectorRow, PixelConversionModifiers.Scale);
+
+                    EncodingUtilities.ReplaceTransparentPixels(vectorRow);
+
+                    PixelOperations<TPixel>.Instance.FromVector4Destructive(configuration, vectorRow, sourceRow, PixelConversionModifiers.Scale);
+                }
+            }
+        }
+
         dither.ApplyQuantizationDither(ref quantizer, source, destination, bounds);
     }
 }
diff --git a/src/ImageSharp/Processing/Processors/Quantization/WebSafePaletteQuantizer.cs b/src/ImageSharp/Processing/Processors/Quantization/WebSafePaletteQuantizer.cs
index 604cae6681..fa1763367c 100644
--- a/src/ImageSharp/Processing/Processors/Quantization/WebSafePaletteQuantizer.cs
+++ b/src/ImageSharp/Processing/Processors/Quantization/WebSafePaletteQuantizer.cs
@@ -6,7 +6,7 @@ namespace SixLabors.ImageSharp.Processing.Processors.Quantization;
 /// <summary>
 /// A palette quantizer consisting of web safe colors as defined in the CSS Color Module Level 4.
 /// </summary>
-public class WebSafePaletteQuantizer : PaletteQuantizer
+public sealed class WebSafePaletteQuantizer : PaletteQuantizer
 {
     /// <summary>
     /// Initializes a new instance of the <see cref="WebSafePaletteQuantizer" /> class.
diff --git a/src/ImageSharp/Processing/Processors/Quantization/WernerPaletteQuantizer.cs b/src/ImageSharp/Processing/Processors/Quantization/WernerPaletteQuantizer.cs
index 023ee7f2e0..cd7b80e81d 100644
--- a/src/ImageSharp/Processing/Processors/Quantization/WernerPaletteQuantizer.cs
+++ b/src/ImageSharp/Processing/Processors/Quantization/WernerPaletteQuantizer.cs
@@ -7,7 +7,7 @@ namespace SixLabors.ImageSharp.Processing.Processors.Quantization;
 /// A palette quantizer consisting of colors as defined in the original second edition of Werner’s Nomenclature of Colours 1821.
 /// The hex codes were collected and defined by Nicholas Rougeux <see href="https://www.c82.net/werner"/>
 /// </summary>
-public class WernerPaletteQuantizer : PaletteQuantizer
+public sealed class WernerPaletteQuantizer : PaletteQuantizer
 {
     /// <summary>
     /// Initializes a new instance of the <see cref="WernerPaletteQuantizer" /> class.
diff --git a/src/ImageSharp/Processing/Processors/Quantization/WuQuantizer{TPixel}.cs b/src/ImageSharp/Processing/Processors/Quantization/WuQuantizer{TPixel}.cs
index ba2ab825ad..03d6ac0da6 100644
--- a/src/ImageSharp/Processing/Processors/Quantization/WuQuantizer{TPixel}.cs
+++ b/src/ImageSharp/Processing/Processors/Quantization/WuQuantizer{TPixel}.cs
@@ -43,30 +43,10 @@ internal struct WuQuantizer<TPixel> : IQuantizer<TPixel>
     // 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!
-
-    /// <summary>
-    /// The index bits. 6 in original code.
-    /// </summary>
     private const int IndexBits = 5;
-
-    /// <summary>
-    /// The index alpha bits. 3 in original code.
-    /// </summary>
     private const int IndexAlphaBits = 5;
-
-    /// <summary>
-    /// The index count.
-    /// </summary>
     private const int IndexCount = (1 << IndexBits) + 1;
-
-    /// <summary>
-    /// The index alpha count.
-    /// </summary>
     private const int IndexAlphaCount = (1 << IndexAlphaBits) + 1;
-
-    /// <summary>
-    /// The table length. Now 1185921. originally 2471625.
-    /// </summary>
     private const int TableLength = IndexCount * IndexCount * IndexCount * IndexAlphaCount;
 
     private readonly IMemoryOwner<Moment> momentsOwner;
@@ -75,14 +55,14 @@ internal struct WuQuantizer<TPixel> : IQuantizer<TPixel>
     private ReadOnlyMemory<TPixel> palette;
     private int maxColors;
     private readonly Box[] colorCube;
-    private EuclideanPixelMap<TPixel>? pixelMap;
+    private PixelMap<TPixel>? pixelMap;
     private readonly bool isDithering;
     private bool isDisposed;
 
     /// <summary>
     /// Initializes a new instance of the <see cref="WuQuantizer{TPixel}"/> struct.
     /// </summary>
-    /// <param name="configuration">The configuration which allows altering default behaviour or extending the library.</param>
+    /// <param name="configuration">The configuration which allows altering default behavior or extending the library.</param>
     /// <param name="options">The quantizer options defining quantization rules.</param>
     [MethodImpl(InliningOptions.ShortMethod)]
     public WuQuantizer(Configuration configuration, QuantizerOptions options)
@@ -101,7 +81,7 @@ internal struct WuQuantizer<TPixel> : IQuantizer<TPixel>
         this.isDisposed = false;
         this.pixelMap = default;
         this.palette = default;
-        this.isDithering = this.isDithering = this.Options.Dither is not null;
+        this.isDithering = this.Options.Dither is not null;
     }
 
     /// <inheritdoc/>
@@ -111,57 +91,71 @@ internal struct WuQuantizer<TPixel> : IQuantizer<TPixel>
     public QuantizerOptions Options { get; }
 
     /// <inheritdoc/>
-    public readonly ReadOnlyMemory<TPixel> Palette
+    public ReadOnlyMemory<TPixel> Palette
     {
         get
         {
-            QuantizerUtilities.CheckPaletteState(in this.palette);
+            if (this.palette.IsEmpty)
+            {
+                this.ResolvePalette();
+                QuantizerUtilities.CheckPaletteState(in this.palette);
+            }
+
             return this.palette;
         }
     }
 
     /// <inheritdoc/>
-    public void AddPaletteColors(Buffer2DRegion<TPixel> pixelRegion)
+    public readonly void AddPaletteColors(in Buffer2DRegion<TPixel> pixelRegion)
+    {
+        PixelRowDelegate pixelRowDelegate = new(ref Unsafe.AsRef(in this));
+        QuantizerUtilities.AddPaletteColors<WuQuantizer<TPixel>, TPixel, Rgba32, PixelRowDelegate>(
+            ref Unsafe.AsRef(in this),
+            in pixelRegion,
+            in pixelRowDelegate);
+    }
+
+    /// <summary>
+    /// Once all histogram data has been accumulated, this method computes the moments,
+    /// splits the color cube, and resolves the final palette from the accumulated histogram.
+    /// </summary>
+    private void ResolvePalette()
     {
-        // TODO: Something is destroying the existing palette when adding new colors.
-        // When the QuantizingImageEncoder.PixelSamplingStrategy is DefaultPixelSamplingStrategy
-        // this leads to performance issues + the palette is not preserved.
-        // https://github.com/SixLabors/ImageSharp/issues/2498
-        this.Build3DHistogram(pixelRegion);
+        // Calculate the cumulative moments from the accumulated histogram.
         this.Get3DMoments(this.memoryAllocator);
+
+        // Partition the histogram into color cubes.
         this.BuildCube();
 
-        // Slice again since maxColors has been updated since the buffer was created.
+        // Compute the palette colors from the resolved cubes.
         Span<TPixel> paletteSpan = this.paletteOwner.GetSpan()[..this.maxColors];
         ReadOnlySpan<Moment> momentsSpan = this.momentsOwner.GetSpan();
+
+        float transparencyThreshold = this.Options.TransparencyThreshold;
         for (int k = 0; k < paletteSpan.Length; k++)
         {
             this.Mark(ref this.colorCube[k], (byte)k);
-
             Moment moment = Volume(ref this.colorCube[k], momentsSpan);
-
             if (moment.Weight > 0)
             {
-                paletteSpan[k] = TPixel.FromScaledVector4(moment.Normalize());
+                Vector4 normalized = moment.Normalize();
+                if (normalized.W < transparencyThreshold)
+                {
+                    normalized = Vector4.Zero;
+                }
+
+                paletteSpan[k] = TPixel.FromScaledVector4(normalized);
             }
         }
 
-        ReadOnlyMemory<TPixel> result = this.paletteOwner.Memory[..paletteSpan.Length];
-        if (this.isDithering)
+        // Update the palette to the new computed colors.
+        this.palette = this.paletteOwner.Memory[..paletteSpan.Length];
+
+        // Create the pixel map if dithering is enabled.
+        if (this.isDithering && this.pixelMap is null)
         {
-            // When called multiple times by QuantizerUtilities.BuildPalette
-            // this prevents memory churn caused by reallocation.
-            if (this.pixelMap is null)
-            {
-                this.pixelMap = new EuclideanPixelMap<TPixel>(this.Configuration, result);
-            }
-            else
-            {
-                this.pixelMap.Clear(result);
-            }
+            this.pixelMap = PixelMapFactory.Create(this.Configuration, this.palette, this.Options.ColorMatchingMode);
         }
-
-        this.palette = result;
     }
 
     /// <inheritdoc/>
@@ -172,6 +166,9 @@ internal struct WuQuantizer<TPixel> : IQuantizer<TPixel>
     /// <inheritdoc/>
     public readonly byte GetQuantizedColor(TPixel color, out TPixel match)
     {
+        // Due to the addition of new colors by dithering that are not part of the original histogram,
+        // the color cube might not match the correct color.
+        // In this case, we must use the pixel map to get the closest color.
         if (this.isDithering)
         {
             return (byte)this.pixelMap!.GetClosestColor(color, out match);
@@ -188,7 +185,7 @@ internal struct WuQuantizer<TPixel> : IQuantizer<TPixel>
         ReadOnlySpan<byte> tagSpan = this.tagsOwner.GetSpan();
         byte index = tagSpan[GetPaletteIndex(r + 1, g + 1, b + 1, a + 1)];
         ref TPixel paletteRef = ref MemoryMarshal.GetReference(this.palette.Span);
-        match = Unsafe.Add(ref paletteRef, index);
+        match = Unsafe.Add(ref paletteRef, (nuint)index);
         return index;
     }
 
@@ -359,31 +356,19 @@ internal struct WuQuantizer<TPixel> : IQuantizer<TPixel>
     /// <summary>
     /// Builds a 3-D color histogram of <c>counts, r/g/b, c^2</c>.
     /// </summary>
-    /// <param name="source">The source pixel data.</param>
-    private readonly void Build3DHistogram(Buffer2DRegion<TPixel> source)
+    /// <param name="pixels">The source pixel data.</param>
+    private readonly void Build3DHistogram(ReadOnlySpan<Rgba32> pixels)
     {
-        Span<Moment> momentSpan = this.momentsOwner.GetSpan();
-
-        // Build up the 3-D color histogram
-        using IMemoryOwner<Rgba32> buffer = this.memoryAllocator.Allocate<Rgba32>(source.Width);
-        Span<Rgba32> bufferSpan = buffer.GetSpan();
-
-        for (int y = 0; y < source.Height; y++)
+        Span<Moment> moments = this.momentsOwner.GetSpan();
+        for (int x = 0; x < pixels.Length; x++)
         {
-            Span<TPixel> row = source.DangerousGetRowSpan(y);
-            PixelOperations<TPixel>.Instance.ToRgba32(this.Configuration, row, bufferSpan);
-
-            for (int x = 0; x < bufferSpan.Length; x++)
-            {
-                Rgba32 rgba = bufferSpan[x];
-
-                int r = (rgba.R >> (8 - IndexBits)) + 1;
-                int g = (rgba.G >> (8 - IndexBits)) + 1;
-                int b = (rgba.B >> (8 - IndexBits)) + 1;
-                int a = (rgba.A >> (8 - IndexAlphaBits)) + 1;
+            Rgba32 rgba = pixels[x];
+            int r = (rgba.R >> (8 - IndexBits)) + 1;
+            int g = (rgba.G >> (8 - IndexBits)) + 1;
+            int b = (rgba.B >> (8 - IndexBits)) + 1;
+            int a = (rgba.A >> (8 - IndexAlphaBits)) + 1;
 
-                momentSpan[GetPaletteIndex(r, g, b, a)] += rgba;
-            }
+            moments[GetPaletteIndex(r, g, b, a)] += rgba;
         }
     }
 
@@ -895,4 +880,13 @@ internal struct WuQuantizer<TPixel> : IQuantizer<TPixel>
             return hash.ToHashCode();
         }
     }
+
+    private readonly struct PixelRowDelegate : IQuantizingPixelRowDelegate<Rgba32>
+    {
+        private readonly WuQuantizer<TPixel> quantizer;
+
+        public PixelRowDelegate(ref WuQuantizer<TPixel> quantizer) => this.quantizer = quantizer;
+
+        public void Invoke(ReadOnlySpan<Rgba32> row, int rowIndex) => this.quantizer.Build3DHistogram(row);
+    }
 }
diff --git a/src/ImageSharp/Processing/Processors/Transforms/CropProcessor{TPixel}.cs b/src/ImageSharp/Processing/Processors/Transforms/CropProcessor{TPixel}.cs
index 1d82dd12ad..96c350c6c8 100644
--- a/src/ImageSharp/Processing/Processors/Transforms/CropProcessor{TPixel}.cs
+++ b/src/ImageSharp/Processing/Processors/Transforms/CropProcessor{TPixel}.cs
@@ -1,6 +1,7 @@
 // Copyright (c) Six Labors.
 // Licensed under the Six Labors Split License.
 
+using System.Numerics;
 using System.Runtime.CompilerServices;
 using SixLabors.ImageSharp.Advanced;
 using SixLabors.ImageSharp.Memory;
@@ -16,6 +17,7 @@ internal class CropProcessor<TPixel> : TransformProcessor<TPixel>
     where TPixel : unmanaged, IPixel<TPixel>
 {
     private readonly Rectangle cropRectangle;
+    private readonly Matrix4x4 transformMatrix;
 
     /// <summary>
     /// Initializes a new instance of the <see cref="CropProcessor{TPixel}"/> class.
@@ -26,10 +28,21 @@ internal class CropProcessor<TPixel> : TransformProcessor<TPixel>
     /// <param name="sourceRectangle">The source area to process for the current processor instance.</param>
     public CropProcessor(Configuration configuration, CropProcessor definition, Image<TPixel> source, Rectangle sourceRectangle)
         : base(configuration, source, sourceRectangle)
-        => this.cropRectangle = definition.CropRectangle;
+    {
+        this.cropRectangle = definition.CropRectangle;
+
+        // Calculate the transform matrix from the crop operation to allow us
+        // to update any metadata that represents pixel coordinates in the source image.
+        this.transformMatrix = new ProjectiveTransformBuilder()
+            .AppendTranslation(new PointF(-this.cropRectangle.X, -this.cropRectangle.Y))
+            .BuildMatrix(sourceRectangle);
+    }
+
+    /// <inheritdoc/>
+    protected override Size GetDestinationSize() => new(this.cropRectangle.Width, this.cropRectangle.Height);
 
     /// <inheritdoc/>
-    protected override Size GetDestinationSize() => new Size(this.cropRectangle.Width, this.cropRectangle.Height);
+    protected override Matrix4x4 GetTransformMatrix() => this.transformMatrix;
 
     /// <inheritdoc/>
     protected override void OnFrameApply(ImageFrame<TPixel> source, ImageFrame<TPixel> destination)
@@ -50,7 +63,7 @@ internal class CropProcessor<TPixel> : TransformProcessor<TPixel>
         ParallelExecutionSettings parallelSettings =
             ParallelExecutionSettings.FromConfiguration(this.Configuration).MultiplyMinimumPixelsPerTask(4);
 
-        var operation = new RowOperation(bounds, source.PixelBuffer, destination.PixelBuffer);
+        RowOperation operation = new(bounds, source.PixelBuffer, destination.PixelBuffer);
 
         ParallelRowIterator.IterateRows(
             bounds,
diff --git a/src/ImageSharp/Processing/Processors/Transforms/EntropyCropProcessor{TPixel}.cs b/src/ImageSharp/Processing/Processors/Transforms/EntropyCropProcessor{TPixel}.cs
index 2eda61e41d..8a76ca42f3 100644
--- a/src/ImageSharp/Processing/Processors/Transforms/EntropyCropProcessor{TPixel}.cs
+++ b/src/ImageSharp/Processing/Processors/Transforms/EntropyCropProcessor{TPixel}.cs
@@ -2,7 +2,6 @@
 // Licensed under the Six Labors Split License.
 
 using System.Runtime.CompilerServices;
-using SixLabors.ImageSharp.Advanced;
 using SixLabors.ImageSharp.PixelFormats;
 using SixLabors.ImageSharp.Processing.Processors.Binarization;
 using SixLabors.ImageSharp.Processing.Processors.Convolution;
@@ -36,7 +35,7 @@ internal class EntropyCropProcessor<TPixel> : ImageProcessor<TPixel>
 
         // TODO: This is clunky. We should add behavior enum to ExtractFrame.
         // All frames have be the same size so we only need to calculate the correct dimensions for the first frame
-        using (Image<TPixel> temp = new(this.Configuration, this.Source.Metadata.DeepClone(), new[] { this.Source.Frames.RootFrame.Clone() }))
+        using (Image<TPixel> temp = new(this.Configuration, this.Source.Metadata.DeepClone(), [this.Source.Frames.RootFrame.Clone()]))
         {
             Configuration configuration = this.Source.Configuration;
 
diff --git a/src/ImageSharp/Processing/Processors/Transforms/ISwizzler.cs b/src/ImageSharp/Processing/Processors/Transforms/ISwizzler.cs
index 321ecf9684..3c11c32b44 100644
--- a/src/ImageSharp/Processing/Processors/Transforms/ISwizzler.cs
+++ b/src/ImageSharp/Processing/Processors/Transforms/ISwizzler.cs
@@ -11,12 +11,12 @@ public interface ISwizzler
     /// <summary>
     /// Gets the size of the image after transformation.
     /// </summary>
-    Size DestinationSize { get; }
+    public Size DestinationSize { get; }
 
     /// <summary>
     /// Applies the swizzle transformation to a given point.
     /// </summary>
     /// <param name="point">Point to transform.</param>
     /// <returns>The transformed point.</returns>
-    Point Transform(Point point);
+    public Point Transform(Point point);
 }
diff --git a/src/ImageSharp/Processing/Processors/Transforms/Linear/AffineTransformProcessor{TPixel}.cs b/src/ImageSharp/Processing/Processors/Transforms/Linear/AffineTransformProcessor{TPixel}.cs
index b3919e5844..59f5773cf1 100644
--- a/src/ImageSharp/Processing/Processors/Transforms/Linear/AffineTransformProcessor{TPixel}.cs
+++ b/src/ImageSharp/Processing/Processors/Transforms/Linear/AffineTransformProcessor{TPixel}.cs
@@ -18,6 +18,7 @@ internal class AffineTransformProcessor<TPixel> : TransformProcessor<TPixel>, IR
 {
     private readonly Size destinationSize;
     private readonly Matrix3x2 transformMatrix;
+    private readonly Matrix4x4 transformMatrix4x4;
     private readonly IResampler resampler;
     private ImageFrame<TPixel>? source;
     private ImageFrame<TPixel>? destination;
@@ -34,6 +35,7 @@ internal class AffineTransformProcessor<TPixel> : TransformProcessor<TPixel>, IR
     {
         this.destinationSize = definition.DestinationSize;
         this.transformMatrix = definition.TransformMatrix;
+        this.transformMatrix4x4 = new(this.transformMatrix);
         this.resampler = definition.Sampler;
     }
 
@@ -47,6 +49,9 @@ internal class AffineTransformProcessor<TPixel> : TransformProcessor<TPixel>, IR
         this.resampler.ApplyTransform(this);
     }
 
+    /// <inheritdoc/>
+    protected override Matrix4x4 GetTransformMatrix() => this.transformMatrix4x4;
+
     /// <inheritdoc/>
     public void ApplyTransform<TResampler>(in TResampler sampler)
         where TResampler : struct, IResampler
diff --git a/src/ImageSharp/Processing/Processors/Transforms/Linear/FlipProcessor{TPixel}.cs b/src/ImageSharp/Processing/Processors/Transforms/Linear/FlipProcessor{TPixel}.cs
index 1adda1d043..86ba2f0f9a 100644
--- a/src/ImageSharp/Processing/Processors/Transforms/Linear/FlipProcessor{TPixel}.cs
+++ b/src/ImageSharp/Processing/Processors/Transforms/Linear/FlipProcessor{TPixel}.cs
@@ -2,6 +2,7 @@
 // Licensed under the Six Labors Split License.
 
 using System.Buffers;
+using System.Numerics;
 using System.Runtime.CompilerServices;
 using SixLabors.ImageSharp.Advanced;
 using SixLabors.ImageSharp.Memory;
@@ -17,16 +18,45 @@ internal class FlipProcessor<TPixel> : ImageProcessor<TPixel>
     where TPixel : unmanaged, IPixel<TPixel>
 {
     private readonly FlipProcessor definition;
+    private readonly Matrix4x4 transformMatrix;
 
     /// <summary>
     /// Initializes a new instance of the <see cref="FlipProcessor{TPixel}"/> class.
     /// </summary>
-    /// <param name="configuration">The configuration which allows altering default behaviour or extending the library.</param>
+    /// <param name="configuration">The configuration which allows altering default behavior or extending the library.</param>
     /// <param name="definition">The <see cref="FlipProcessor"/>.</param>
     /// <param name="source">The source <see cref="Image{TPixel}"/> for the current processor instance.</param>
     /// <param name="sourceRectangle">The source area to process for the current processor instance.</param>
     public FlipProcessor(Configuration configuration, FlipProcessor definition, Image<TPixel> source, Rectangle sourceRectangle)
-        : base(configuration, source, sourceRectangle) => this.definition = definition;
+        : base(configuration, source, sourceRectangle)
+    {
+        this.definition = definition;
+
+        // Calculate the transform matrix from the flip operation to allow us
+        // to update any metadata that represents pixel coordinates in the source image.
+        ProjectiveTransformBuilder builder = new();
+        switch (this.definition.FlipMode)
+        {
+            // No default needed as we have already set the pixels.
+            case FlipMode.Vertical:
+
+                // Flip vertically by scaling the Y axis by -1 and translating the Y coordinate.
+                builder.AppendScale(new Vector2(1, -1))
+                       .AppendTranslation(new PointF(0, this.SourceRectangle.Height - 1));
+                break;
+            case FlipMode.Horizontal:
+
+                // Flip horizontally by scaling the X axis by -1 and translating the X coordinate.
+                builder.AppendScale(new Vector2(-1, 1))
+                       .AppendTranslation(new PointF(this.SourceRectangle.Width - 1, 0));
+                break;
+            default:
+                this.transformMatrix = Matrix4x4.Identity;
+                return;
+        }
+
+        this.transformMatrix = builder.BuildMatrix(sourceRectangle);
+    }
 
     /// <inheritdoc/>
     protected override void OnFrameApply(ImageFrame<TPixel> source)
@@ -43,6 +73,14 @@ internal class FlipProcessor<TPixel> : ImageProcessor<TPixel>
         }
     }
 
+    /// <inheritdoc/>
+    protected override void AfterFrameApply(ImageFrame<TPixel> source)
+        => source.Metadata.AfterFrameApply(source, source, this.transformMatrix);
+
+    /// <inheritdoc/>
+    protected override void AfterImageApply()
+        => this.Source.Metadata.AfterImageApply(this.Source, this.transformMatrix);
+
     /// <summary>
     /// Swaps the image at the X-axis, which goes horizontally through the middle at half the height of the image.
     /// </summary>
diff --git a/src/ImageSharp/Processing/Processors/Transforms/Linear/ProjectiveTransformProcessor{TPixel}.cs b/src/ImageSharp/Processing/Processors/Transforms/Linear/ProjectiveTransformProcessor{TPixel}.cs
index 16b0070e90..1c30fd1145 100644
--- a/src/ImageSharp/Processing/Processors/Transforms/Linear/ProjectiveTransformProcessor{TPixel}.cs
+++ b/src/ImageSharp/Processing/Processors/Transforms/Linear/ProjectiveTransformProcessor{TPixel}.cs
@@ -47,6 +47,9 @@ internal class ProjectiveTransformProcessor<TPixel> : TransformProcessor<TPixel>
         this.resampler.ApplyTransform(this);
     }
 
+    /// <inheritdoc/>
+    protected override Matrix4x4 GetTransformMatrix() => this.transformMatrix;
+
     /// <inheritdoc/>
     public void ApplyTransform<TResampler>(in TResampler sampler)
         where TResampler : struct, IResampler
diff --git a/src/ImageSharp/Processing/Processors/Transforms/Resize/ResizeKernel.cs b/src/ImageSharp/Processing/Processors/Transforms/Resize/ResizeKernel.cs
index 51a739d35e..26cf60034d 100644
--- a/src/ImageSharp/Processing/Processors/Transforms/Resize/ResizeKernel.cs
+++ b/src/ImageSharp/Processing/Processors/Transforms/Resize/ResizeKernel.cs
@@ -74,13 +74,13 @@ internal readonly unsafe struct ResizeKernel
             float* bufferEnd = bufferStart + (this.Length & ~3);
             Vector256<float> result256_0 = Vector256<float>.Zero;
             Vector256<float> result256_1 = Vector256<float>.Zero;
-            ReadOnlySpan<byte> maskBytes = new byte[]
-            {
+            ReadOnlySpan<byte> maskBytes =
+            [
                 0, 0, 0, 0, 0, 0, 0, 0,
                 0, 0, 0, 0, 0, 0, 0, 0,
                 1, 0, 0, 0, 1, 0, 0, 0,
-                1, 0, 0, 0, 1, 0, 0, 0,
-            };
+                1, 0, 0, 0, 1, 0, 0, 0
+            ];
             Vector256<int> mask = Unsafe.ReadUnaligned<Vector256<int>>(ref MemoryMarshal.GetReference(maskBytes));
 
             while (bufferStart < bufferEnd)
diff --git a/src/ImageSharp/Processing/Processors/Transforms/Resize/ResizeProcessor{TPixel}.cs b/src/ImageSharp/Processing/Processors/Transforms/Resize/ResizeProcessor{TPixel}.cs
index cfc30edc0f..49439545b3 100644
--- a/src/ImageSharp/Processing/Processors/Transforms/Resize/ResizeProcessor{TPixel}.cs
+++ b/src/ImageSharp/Processing/Processors/Transforms/Resize/ResizeProcessor{TPixel}.cs
@@ -1,6 +1,7 @@
 // Copyright (c) Six Labors.
 // Licensed under the Six Labors Split License.
 
+using System.Numerics;
 using System.Runtime.CompilerServices;
 using SixLabors.ImageSharp.Advanced;
 using SixLabors.ImageSharp.Memory;
@@ -21,6 +22,7 @@ internal class ResizeProcessor<TPixel> : TransformProcessor<TPixel>, IResampling
     private readonly IResampler resampler;
     private readonly Rectangle destinationRectangle;
     private Image<TPixel>? destination;
+    private readonly Matrix4x4 transformMatrix;
 
     public ResizeProcessor(Configuration configuration, ResizeProcessor definition, Image<TPixel> source, Rectangle sourceRectangle)
         : base(configuration, source, sourceRectangle)
@@ -30,6 +32,17 @@ internal class ResizeProcessor<TPixel> : TransformProcessor<TPixel>, IResampling
         this.destinationRectangle = definition.DestinationRectangle;
         this.options = definition.Options;
         this.resampler = definition.Options.Sampler;
+
+        // Calculate the transform matrix from the resize operation to allow us
+        // to update any metadata that represents pixel coordinates in the source image.
+        Vector2 scale = new(
+            this.destinationRectangle.Width / (float)this.SourceRectangle.Width,
+            this.destinationRectangle.Height / (float)this.SourceRectangle.Height);
+
+        this.transformMatrix = new ProjectiveTransformBuilder()
+                                    .AppendScale(scale)
+                                    .AppendTranslation((PointF)this.destinationRectangle.Location)
+                                    .BuildMatrix(sourceRectangle);
     }
 
     /// <inheritdoc/>
@@ -50,6 +63,9 @@ internal class ResizeProcessor<TPixel> : TransformProcessor<TPixel>, IResampling
         // Everything happens in BeforeImageApply.
     }
 
+    /// <inheritdoc/>
+    protected override Matrix4x4 GetTransformMatrix() => this.transformMatrix;
+
     public void ApplyTransform<TResampler>(in TResampler sampler)
         where TResampler : struct, IResampler
     {
@@ -81,7 +97,7 @@ internal class ResizeProcessor<TPixel> : TransformProcessor<TPixel>, IResampling
             return;
         }
 
-        var interest = Rectangle.Intersect(destinationRectangle, destination.Bounds);
+        Rectangle interest = Rectangle.Intersect(destinationRectangle, destination.Bounds);
 
         if (sampler is NearestNeighborResampler)
         {
@@ -110,13 +126,13 @@ internal class ResizeProcessor<TPixel> : TransformProcessor<TPixel>, IResampling
         // Since all image frame dimensions have to be the same we can calculate
         // the kernel maps and reuse for all frames.
         MemoryAllocator allocator = configuration.MemoryAllocator;
-        using var horizontalKernelMap = ResizeKernelMap.Calculate(
+        using ResizeKernelMap horizontalKernelMap = ResizeKernelMap.Calculate(
             in sampler,
             destinationRectangle.Width,
             sourceRectangle.Width,
             allocator);
 
-        using var verticalKernelMap = ResizeKernelMap.Calculate(
+        using ResizeKernelMap verticalKernelMap = ResizeKernelMap.Calculate(
             in sampler,
             destinationRectangle.Height,
             sourceRectangle.Height,
@@ -158,7 +174,7 @@ internal class ResizeProcessor<TPixel> : TransformProcessor<TPixel>, IResampling
         float widthFactor = sourceRectangle.Width / (float)destinationRectangle.Width;
         float heightFactor = sourceRectangle.Height / (float)destinationRectangle.Height;
 
-        var operation = new NNRowOperation(
+        NNRowOperation operation = new(
             sourceRectangle,
             destinationRectangle,
             interest,
@@ -179,10 +195,8 @@ internal class ResizeProcessor<TPixel> : TransformProcessor<TPixel>, IResampling
         {
             return PixelConversionModifiers.Premultiply.ApplyCompanding(compand);
         }
-        else
-        {
-            return PixelConversionModifiers.None.ApplyCompanding(compand);
-        }
+
+        return PixelConversionModifiers.None.ApplyCompanding(compand);
     }
 
     private static void ApplyResizeFrameTransform(
@@ -208,7 +222,7 @@ internal class ResizeProcessor<TPixel> : TransformProcessor<TPixel>, IResampling
 
         // To reintroduce parallel processing, we would launch multiple workers
         // for different row intervals of the image.
-        using var worker = new ResizeWorker<TPixel>(
+        using ResizeWorker<TPixel> worker = new(
             configuration,
             sourceRegion,
             conversionModifiers,
@@ -218,7 +232,7 @@ internal class ResizeProcessor<TPixel> : TransformProcessor<TPixel>, IResampling
             destinationRectangle.Location);
         worker.Initialize();
 
-        var workingInterval = new RowInterval(interest.Top, interest.Bottom);
+        RowInterval workingInterval = new(interest.Top, interest.Bottom);
         worker.FillDestinationPixels(workingInterval, destination.PixelBuffer);
     }
 
diff --git a/src/ImageSharp/Processing/Processors/Transforms/SwizzleProcessor{TSwizzler,TPixel}.cs b/src/ImageSharp/Processing/Processors/Transforms/SwizzleProcessor{TSwizzler,TPixel}.cs
index 1ea2156c8f..3bec82cce5 100644
--- a/src/ImageSharp/Processing/Processors/Transforms/SwizzleProcessor{TSwizzler,TPixel}.cs
+++ b/src/ImageSharp/Processing/Processors/Transforms/SwizzleProcessor{TSwizzler,TPixel}.cs
@@ -1,6 +1,7 @@
 // Copyright (c) Six Labors.
 // Licensed under the Six Labors Split License.
 
+using System.Numerics;
 using SixLabors.ImageSharp.Memory;
 using SixLabors.ImageSharp.PixelFormats;
 
@@ -12,17 +13,28 @@ internal class SwizzleProcessor<TSwizzler, TPixel> : TransformProcessor<TPixel>
 {
     private readonly TSwizzler swizzler;
     private readonly Size destinationSize;
+    private readonly Matrix4x4 transformMatrix;
 
     public SwizzleProcessor(Configuration configuration, TSwizzler swizzler, Image<TPixel> source, Rectangle sourceRectangle)
         : base(configuration, source, sourceRectangle)
     {
         this.swizzler = swizzler;
         this.destinationSize = swizzler.DestinationSize;
+
+        // Calculate the transform matrix from the swizzle operation to allow us
+        // to update any metadata that represents pixel coordinates in the source image.
+        this.transformMatrix = new ProjectiveTransformBuilder()
+            .AppendMatrix(TransformUtils.GetSwizzlerMatrix(swizzler, sourceRectangle))
+            .BuildMatrix(sourceRectangle);
     }
 
-    protected override Size GetDestinationSize()
-        => this.destinationSize;
+    /// <inheritdoc />
+    protected override Size GetDestinationSize() => this.destinationSize;
+
+    /// <inheritdoc />
+    protected override Matrix4x4 GetTransformMatrix() => this.transformMatrix;
 
+    /// <inheritdoc />
     protected override void OnFrameApply(ImageFrame<TPixel> source, ImageFrame<TPixel> destination)
     {
         Point p = default;
diff --git a/src/ImageSharp/Processing/Processors/Transforms/SwizzleProcessor{TSwizzler}.cs b/src/ImageSharp/Processing/Processors/Transforms/SwizzleProcessor{TSwizzler}.cs
index 0b8274aff7..d00e01711e 100644
--- a/src/ImageSharp/Processing/Processors/Transforms/SwizzleProcessor{TSwizzler}.cs
+++ b/src/ImageSharp/Processing/Processors/Transforms/SwizzleProcessor{TSwizzler}.cs
@@ -16,10 +16,7 @@ public sealed class SwizzleProcessor<TSwizzler> : IImageProcessor
     /// Initializes a new instance of the <see cref="SwizzleProcessor{TSwizzler}"/> class.
     /// </summary>
     /// <param name="swizzler">The swizzler operation.</param>
-    public SwizzleProcessor(TSwizzler swizzler)
-    {
-        this.Swizzler = swizzler;
-    }
+    public SwizzleProcessor(TSwizzler swizzler) => this.Swizzler = swizzler;
 
     /// <summary>
     /// Gets the swizzler operation.
diff --git a/src/ImageSharp/Processing/Processors/Transforms/TransformProcessor{TPixel}.cs b/src/ImageSharp/Processing/Processors/Transforms/TransformProcessor{TPixel}.cs
index bdfac00366..0d40cd32fd 100644
--- a/src/ImageSharp/Processing/Processors/Transforms/TransformProcessor{TPixel}.cs
+++ b/src/ImageSharp/Processing/Processors/Transforms/TransformProcessor{TPixel}.cs
@@ -1,6 +1,7 @@
 // Copyright (c) Six Labors.
 // Licensed under the Six Labors Split License.
 
+using System.Numerics;
 using SixLabors.ImageSharp.PixelFormats;
 
 namespace SixLabors.ImageSharp.Processing.Processors.Transforms;
@@ -23,17 +24,19 @@ internal abstract class TransformProcessor<TPixel> : CloningImageProcessor<TPixe
     {
     }
 
+    /// <summary>
+    /// Gets the transform matrix that will be applied to the image.
+    /// </summary>
+    /// <returns>
+    /// The <see cref="Matrix4x4"/> that represents the transformation to be applied to the image.
+    /// </returns>
+    protected abstract Matrix4x4 GetTransformMatrix();
+
     /// <inheritdoc/>
     protected override void AfterFrameApply(ImageFrame<TPixel> source, ImageFrame<TPixel> destination)
-    {
-        base.AfterFrameApply(source, destination);
-        destination.Metadata.AfterFrameApply(source, destination);
-    }
+        => destination.Metadata.AfterFrameApply(source, destination, this.GetTransformMatrix());
 
     /// <inheritdoc/>
     protected override void AfterImageApply(Image<TPixel> destination)
-    {
-        base.AfterImageApply(destination);
-        destination.Metadata.AfterImageApply(destination);
-    }
+        => destination.Metadata.AfterImageApply(destination, this.GetTransformMatrix());
 }
diff --git a/src/ImageSharp/Processing/Processors/Transforms/TransformUtils.cs b/src/ImageSharp/Processing/Processors/Transforms/TransformUtils.cs
index 47b3250b87..d25d4f4749 100644
--- a/src/ImageSharp/Processing/Processors/Transforms/TransformUtils.cs
+++ b/src/ImageSharp/Processing/Processors/Transforms/TransformUtils.cs
@@ -419,6 +419,28 @@ internal static class TransformUtils
         return size;
     }
 
+    /// <summary>
+    /// Attempts to derive a 4x4 projective transform matrix that approximates the behavior of an <typeparamref name="T"/>.
+    /// </summary>
+    /// <param name="swizzler">
+    /// The swizzler to use for the transformation.
+    /// </param>
+    /// <param name="sourceRectangle">
+    /// The source rectangle that defines the area to be transformed.
+    /// </param>
+    /// <typeparam name="T">
+    /// The type of the swizzler, which must implement <see cref="ISwizzler"/>.
+    /// </typeparam>
+    public static Matrix4x4 GetSwizzlerMatrix<T>(T swizzler, Rectangle sourceRectangle)
+        where T : struct, ISwizzler
+        => CreateQuadDistortionMatrix(
+            sourceRectangle,
+            swizzler.Transform(new Point(sourceRectangle.Left, sourceRectangle.Top)),
+            swizzler.Transform(new Point(sourceRectangle.Right, sourceRectangle.Top)),
+            swizzler.Transform(new Point(sourceRectangle.Right, sourceRectangle.Bottom)),
+            swizzler.Transform(new Point(sourceRectangle.Left, sourceRectangle.Bottom)),
+            TransformSpace.Pixel);
+
     /// <summary>
     /// Returns the size relative to the source for the given transformation matrix.
     /// </summary>
@@ -455,7 +477,7 @@ internal static class TransformUtils
         {
             float scaleX = 1F / new Vector2(matrix.M11, matrix.M21).Length(); // sqrt(M11^2 + M21^2)
             float scaleY = 1F / new Vector2(matrix.M12, matrix.M22).Length(); // sqrt(M12^2 + M22^2)
-            offsetSize = new(scaleX, scaleY);
+            offsetSize = new SizeF(scaleX, scaleY);
         }
 
         // Subtract the offset size to translate to the pixel space.
@@ -504,7 +526,7 @@ internal static class TransformUtils
     /// <see langword="true"/> if the transformation was successful; otherwise, <see langword="false"/>.
     /// </returns>
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
-    private static bool TryGetTransformedRectangle(RectangleF rectangle, Matrix4x4 matrix, out Rectangle bounds)
+    internal static bool TryGetTransformedRectangle(RectangleF rectangle, Matrix4x4 matrix, out Rectangle bounds)
     {
         if (matrix.IsIdentity || rectangle.Equals(default))
         {
diff --git a/tests/ImageSharp.Benchmarks/Bulk/FromVector4.cs b/tests/ImageSharp.Benchmarks/Bulk/FromVector4.cs
index 53c26a57ea..80b0963440 100644
--- a/tests/ImageSharp.Benchmarks/Bulk/FromVector4.cs
+++ b/tests/ImageSharp.Benchmarks/Bulk/FromVector4.cs
@@ -73,7 +73,8 @@ public class FromVector4Rgba32 : FromVector4<Rgba32>
         SimdUtils.HwIntrinsics.NormalizedFloatToByteSaturate(sBytes, dFloats);
     }
 
-    private static ReadOnlySpan<byte> PermuteMaskDeinterleave8x32 => new byte[] { 0, 0, 0, 0, 4, 0, 0, 0, 1, 0, 0, 0, 5, 0, 0, 0, 2, 0, 0, 0, 6, 0, 0, 0, 3, 0, 0, 0, 7, 0, 0, 0 };
+    private static ReadOnlySpan<byte> PermuteMaskDeinterleave8x32 => [0, 0, 0, 0, 4, 0, 0, 0, 1, 0, 0, 0, 5, 0, 0, 0, 2, 0, 0, 0, 6, 0, 0, 0, 3, 0, 0, 0, 7, 0, 0, 0
+    ];
 
     [Benchmark]
     public void UseAvx2_Grouped()
diff --git a/tests/ImageSharp.Benchmarks/Codecs/Bmp/EncodeBmpMultiple.cs b/tests/ImageSharp.Benchmarks/Codecs/Bmp/EncodeBmpMultiple.cs
index fdef1b2bfc..ce54c133b0 100644
--- a/tests/ImageSharp.Benchmarks/Codecs/Bmp/EncodeBmpMultiple.cs
+++ b/tests/ImageSharp.Benchmarks/Codecs/Bmp/EncodeBmpMultiple.cs
@@ -10,7 +10,7 @@ namespace SixLabors.ImageSharp.Benchmarks.Codecs;
 [Config(typeof(Config.Short))]
 public class EncodeBmpMultiple : MultiImageBenchmarkBase.WithImagesPreloaded
 {
-    protected override IEnumerable<string> InputImageSubfoldersOrFiles => new[] { "Bmp/", "Jpg/baseline" };
+    protected override IEnumerable<string> InputImageSubfoldersOrFiles => ["Bmp/", "Jpg/baseline"];
 
     [Benchmark(Description = "EncodeBmpMultiple - ImageSharp")]
     public void EncodeBmpImageSharp()
diff --git a/tests/ImageSharp.Benchmarks/Codecs/Gif/DecodeEncodeGif.cs b/tests/ImageSharp.Benchmarks/Codecs/Gif/DecodeEncodeGif.cs
new file mode 100644
index 0000000000..3238e8dac2
--- /dev/null
+++ b/tests/ImageSharp.Benchmarks/Codecs/Gif/DecodeEncodeGif.cs
@@ -0,0 +1,59 @@
+// Copyright (c) Six Labors.
+// Licensed under the Six Labors Split License.
+
+using System.Drawing.Imaging;
+using BenchmarkDotNet.Attributes;
+using SixLabors.ImageSharp.Formats.Gif;
+using SixLabors.ImageSharp.Processing;
+using SixLabors.ImageSharp.Processing.Processors.Quantization;
+using SixLabors.ImageSharp.Tests;
+using SDImage = System.Drawing.Image;
+
+namespace SixLabors.ImageSharp.Benchmarks.Codecs;
+
+public abstract class DecodeEncodeGif
+{
+    private MemoryStream outputStream;
+
+    protected abstract GifEncoder Encoder { get; }
+
+    [Params(TestImages.Gif.Leo, TestImages.Gif.Cheers)]
+    public string TestImage { get; set; }
+
+    private string TestImageFullPath => Path.Combine(TestEnvironment.InputImagesDirectoryFullPath, this.TestImage);
+
+    [GlobalSetup]
+    public void Setup() => this.outputStream = new MemoryStream();
+
+    [GlobalCleanup]
+    public void Cleanup() => this.outputStream.Close();
+
+    [Benchmark(Baseline = true)]
+    public void SystemDrawing()
+    {
+        this.outputStream.Position = 0;
+        using SDImage image = SDImage.FromFile(this.TestImageFullPath);
+        image.Save(this.outputStream, ImageFormat.Gif);
+    }
+
+    [Benchmark]
+    public void ImageSharp()
+    {
+        this.outputStream.Position = 0;
+        using Image image = Image.Load(this.TestImageFullPath);
+        image.SaveAsGif(this.outputStream, this.Encoder);
+    }
+}
+
+public class DecodeEncodeGif_DefaultEncoder : DecodeEncodeGif
+{
+    protected override GifEncoder Encoder => new();
+}
+
+public class DecodeEncodeGif_CoarsePaletteEncoder : DecodeEncodeGif
+{
+    protected override GifEncoder Encoder => new()
+    {
+        Quantizer = new WebSafePaletteQuantizer(new QuantizerOptions { Dither = KnownDitherings.Bayer4x4, ColorMatchingMode = ColorMatchingMode.Coarse })
+    };
+}
diff --git a/tests/ImageSharp.Benchmarks/Codecs/Gif/EncodeGif.cs b/tests/ImageSharp.Benchmarks/Codecs/Gif/EncodeGif.cs
index beedbbe07c..b8f8f78517 100644
--- a/tests/ImageSharp.Benchmarks/Codecs/Gif/EncodeGif.cs
+++ b/tests/ImageSharp.Benchmarks/Codecs/Gif/EncodeGif.cs
@@ -3,6 +3,7 @@
 
 using System.Drawing.Imaging;
 using BenchmarkDotNet.Attributes;
+using ImageMagick;
 using SixLabors.ImageSharp.Formats.Gif;
 using SixLabors.ImageSharp.PixelFormats;
 using SixLabors.ImageSharp.Processing;
@@ -12,21 +13,17 @@ using SDImage = System.Drawing.Image;
 
 namespace SixLabors.ImageSharp.Benchmarks.Codecs;
 
-[Config(typeof(Config.Short))]
-public class EncodeGif
+public abstract class EncodeGif
 {
     // System.Drawing needs this.
     private FileStream bmpStream;
     private SDImage bmpDrawing;
     private Image<Rgba32> bmpCore;
+    private MagickImageCollection magickImage;
 
-    // Try to get as close to System.Drawing's output as possible
-    private readonly GifEncoder encoder = new()
-    {
-        Quantizer = new WebSafePaletteQuantizer(new QuantizerOptions { Dither = KnownDitherings.Bayer4x4 })
-    };
+    protected abstract GifEncoder Encoder { get; }
 
-    [Params(TestImages.Bmp.Car, TestImages.Png.Rgb48Bpp)]
+    [Params(TestImages.Gif.Leo, TestImages.Gif.Cheers)]
     public string TestImage { get; set; }
 
     [GlobalSetup]
@@ -34,10 +31,14 @@ public class EncodeGif
     {
         if (this.bmpStream == null)
         {
-            this.bmpStream = File.OpenRead(Path.Combine(TestEnvironment.InputImagesDirectoryFullPath, this.TestImage));
+            string filePath = Path.Combine(TestEnvironment.InputImagesDirectoryFullPath, this.TestImage);
+            this.bmpStream = File.OpenRead(filePath);
             this.bmpCore = Image.Load<Rgba32>(this.bmpStream);
             this.bmpStream.Position = 0;
             this.bmpDrawing = SDImage.FromStream(this.bmpStream);
+
+            this.bmpStream.Position = 0;
+            this.magickImage = new MagickImageCollection(this.bmpStream);
         }
     }
 
@@ -48,6 +49,7 @@ public class EncodeGif
         this.bmpStream = null;
         this.bmpCore.Dispose();
         this.bmpDrawing.Dispose();
+        this.magickImage.Dispose();
     }
 
     [Benchmark(Baseline = true, Description = "System.Drawing Gif")]
@@ -61,6 +63,26 @@ public class EncodeGif
     public void GifImageSharp()
     {
         using MemoryStream memoryStream = new();
-        this.bmpCore.SaveAsGif(memoryStream, this.encoder);
+        this.bmpCore.SaveAsGif(memoryStream, this.Encoder);
     }
+
+    [Benchmark(Description = "Magick.NET Gif")]
+    public void GifMagickNet()
+    {
+        using MemoryStream ms = new();
+        this.magickImage.Write(ms, MagickFormat.Gif);
+    }
+}
+
+public class EncodeGif_DefaultEncoder : EncodeGif
+{
+    protected override GifEncoder Encoder => new();
+}
+
+public class EncodeGif_CoarsePaletteEncoder : EncodeGif
+{
+    protected override GifEncoder Encoder => new()
+    {
+        Quantizer = new WebSafePaletteQuantizer(new QuantizerOptions { Dither = KnownDitherings.Bayer4x4, ColorMatchingMode = ColorMatchingMode.Coarse })
+    };
 }
diff --git a/tests/ImageSharp.Benchmarks/Codecs/Gif/EncodeGifMultiple.cs b/tests/ImageSharp.Benchmarks/Codecs/Gif/EncodeGifMultiple.cs
index 303272837b..1eca07ec79 100644
--- a/tests/ImageSharp.Benchmarks/Codecs/Gif/EncodeGifMultiple.cs
+++ b/tests/ImageSharp.Benchmarks/Codecs/Gif/EncodeGifMultiple.cs
@@ -15,7 +15,7 @@ public class EncodeGifMultiple : MultiImageBenchmarkBase.WithImagesPreloaded
     [Params(InputImageCategory.AllImages)]
     public override InputImageCategory InputCategory { get; set; }
 
-    protected override IEnumerable<string> InputImageSubfoldersOrFiles => new[] { "Gif/" };
+    protected override IEnumerable<string> InputImageSubfoldersOrFiles => ["Gif/"];
 
     [Benchmark(Description = "EncodeGifMultiple - ImageSharp")]
     public void EncodeGifImageSharp()
diff --git a/tests/ImageSharp.Benchmarks/Codecs/Jpeg/BlockOperations/Block8x8F_CopyTo2x2.cs b/tests/ImageSharp.Benchmarks/Codecs/Jpeg/BlockOperations/Block8x8F_CopyTo2x2.cs
index 72b6bb72e8..4ea0a92f19 100644
--- a/tests/ImageSharp.Benchmarks/Codecs/Jpeg/BlockOperations/Block8x8F_CopyTo2x2.cs
+++ b/tests/ImageSharp.Benchmarks/Codecs/Jpeg/BlockOperations/Block8x8F_CopyTo2x2.cs
@@ -185,15 +185,15 @@ public class Block8x8F_CopyTo2x2
         ref Vector2 dBottomLeft = ref Unsafe.Add(ref dTopLeft, (uint)destStride);
         ref Vector2 dBottomRight = ref Unsafe.Add(ref dBottomLeft, 4);
 
-        var xLeft = new Vector2(sLeft.X);
-        var yLeft = new Vector2(sLeft.Y);
-        var zLeft = new Vector2(sLeft.Z);
-        var wLeft = new Vector2(sLeft.W);
+        Vector2 xLeft = new(sLeft.X);
+        Vector2 yLeft = new(sLeft.Y);
+        Vector2 zLeft = new(sLeft.Z);
+        Vector2 wLeft = new(sLeft.W);
 
-        var xRight = new Vector2(sRight.X);
-        var yRight = new Vector2(sRight.Y);
-        var zRight = new Vector2(sRight.Z);
-        var wRight = new Vector2(sRight.W);
+        Vector2 xRight = new(sRight.X);
+        Vector2 yRight = new(sRight.Y);
+        Vector2 zRight = new(sRight.Z);
+        Vector2 wRight = new(sRight.W);
 
         dTopLeft = xLeft;
         Unsafe.Add(ref dTopLeft, 1) = yLeft;
@@ -245,15 +245,15 @@ public class Block8x8F_CopyTo2x2
         ref Vector2 dBottomLeft = ref Unsafe.Add(ref dTopLeft, (uint)destStride);
         ref Vector2 dBottomRight = ref Unsafe.Add(ref dBottomLeft, 4);
 
-        var xLeft = new Vector4(sLeft.X);
-        var yLeft = new Vector4(sLeft.Y);
-        var zLeft = new Vector4(sLeft.Z);
-        var wLeft = new Vector4(sLeft.W);
+        Vector4 xLeft = new(sLeft.X);
+        Vector4 yLeft = new(sLeft.Y);
+        Vector4 zLeft = new(sLeft.Z);
+        Vector4 wLeft = new(sLeft.W);
 
-        var xRight = new Vector4(sRight.X);
-        var yRight = new Vector4(sRight.Y);
-        var zRight = new Vector4(sRight.Z);
-        var wRight = new Vector4(sRight.W);
+        Vector4 xRight = new(sRight.X);
+        Vector4 yRight = new(sRight.Y);
+        Vector4 zRight = new(sRight.Z);
+        Vector4 wRight = new(sRight.W);
 
         Unsafe.As<Vector2, Vector4>(ref dTopLeft) = xLeft;
         Unsafe.As<Vector2, Vector4>(ref Unsafe.Add(ref dTopLeft, 1)) = yLeft;
@@ -303,15 +303,15 @@ public class Block8x8F_CopyTo2x2
         ref Vector2 dTopLeft = ref Unsafe.Add(ref destBase, (uint)(2 * row * destStride));
         ref Vector2 dBottomLeft = ref Unsafe.Add(ref dTopLeft, (uint)destStride);
 
-        var xLeft = new Vector4(sLeft.X);
-        var yLeft = new Vector4(sLeft.Y);
-        var zLeft = new Vector4(sLeft.Z);
-        var wLeft = new Vector4(sLeft.W);
+        Vector4 xLeft = new(sLeft.X);
+        Vector4 yLeft = new(sLeft.Y);
+        Vector4 zLeft = new(sLeft.Z);
+        Vector4 wLeft = new(sLeft.W);
 
-        var xRight = new Vector4(sRight.X);
-        var yRight = new Vector4(sRight.Y);
-        var zRight = new Vector4(sRight.Z);
-        var wRight = new Vector2(sRight.W);
+        Vector4 xRight = new(sRight.X);
+        Vector4 yRight = new(sRight.Y);
+        Vector4 zRight = new(sRight.Z);
+        Vector2 wRight = new(sRight.W);
 
         Unsafe.As<Vector2, Vector4>(ref dTopLeft) = xLeft;
         Unsafe.As<Vector2, Vector4>(ref Unsafe.Add(ref dTopLeft, 1)) = yLeft;
@@ -362,25 +362,25 @@ public class Block8x8F_CopyTo2x2
         ref Vector4 dTopLeft = ref Unsafe.As<Vector2, Vector4>(ref Unsafe.Add(ref destBase, (uint)offset));
         ref Vector4 dBottomLeft = ref Unsafe.As<Vector2, Vector4>(ref Unsafe.Add(ref destBase, (uint)(offset + destStride)));
 
-        var xyLeft = new Vector4(sLeft.X)
+        Vector4 xyLeft = new(sLeft.X)
         {
             Z = sLeft.Y,
             W = sLeft.Y
         };
 
-        var zwLeft = new Vector4(sLeft.Z)
+        Vector4 zwLeft = new(sLeft.Z)
         {
             Z = sLeft.W,
             W = sLeft.W
         };
 
-        var xyRight = new Vector4(sRight.X)
+        Vector4 xyRight = new(sRight.X)
         {
             Z = sRight.Y,
             W = sRight.Y
         };
 
-        var zwRight = new Vector4(sRight.Z)
+        Vector4 zwRight = new(sRight.Z)
         {
             Z = sRight.W,
             W = sRight.W
diff --git a/tests/ImageSharp.Benchmarks/Codecs/Jpeg/BlockOperations/Block8x8F_DivideRound.cs b/tests/ImageSharp.Benchmarks/Codecs/Jpeg/BlockOperations/Block8x8F_DivideRound.cs
index efc347586c..45c6f63b9c 100644
--- a/tests/ImageSharp.Benchmarks/Codecs/Jpeg/BlockOperations/Block8x8F_DivideRound.cs
+++ b/tests/ImageSharp.Benchmarks/Codecs/Jpeg/BlockOperations/Block8x8F_DivideRound.cs
@@ -19,8 +19,8 @@ namespace SixLabors.ImageSharp.Benchmarks.Codecs.Jpeg.BlockOperations;
 public unsafe class Block8x8F_DivideRound
 {
     private const int ExecutionCount = 5; // Added this to reduce the effect of copying the blocks
-    private static readonly Vector4 MinusOne = new Vector4(-1);
-    private static readonly Vector4 Half = new Vector4(0.5f);
+    private static readonly Vector4 MinusOne = new(-1);
+    private static readonly Vector4 Half = new(0.5f);
 
     private Block8x8F inputDividend;
     private Block8x8F inputDivisor;
@@ -140,7 +140,7 @@ public unsafe class Block8x8F_DivideRound
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
     private static Vector4 DivideRound(Vector4 dividend, Vector4 divisor)
     {
-        var sign = Vector4.Min(dividend, Vector4.One);
+        Vector4 sign = Vector4.Min(dividend, Vector4.One);
         sign = Vector4.Max(sign, MinusOne);
 
         return (dividend / divisor) + (sign * Half);
diff --git a/tests/ImageSharp.Benchmarks/Codecs/Jpeg/BlockOperations/Block8x8F_LoadFromInt16.cs b/tests/ImageSharp.Benchmarks/Codecs/Jpeg/BlockOperations/Block8x8F_LoadFromInt16.cs
index 7a8502c2cf..25b5e973e7 100644
--- a/tests/ImageSharp.Benchmarks/Codecs/Jpeg/BlockOperations/Block8x8F_LoadFromInt16.cs
+++ b/tests/ImageSharp.Benchmarks/Codecs/Jpeg/BlockOperations/Block8x8F_LoadFromInt16.cs
@@ -32,7 +32,7 @@ public class Block8x8F_LoadFromInt16
     public void Scalar() => this.destination.LoadFromInt16Scalar(ref this.source);
 
     [Benchmark]
-    public void ExtendedAvx2() => this.destination.LoadFromInt16ExtendedAvx2(ref this.source);
+    public void ExtendedAvx2() => this.destination.LoadFromInt16ExtendedVector256(ref this.source);
 
     // RESULT:
     //        Method |     Mean |     Error |    StdDev | Scaled |
diff --git a/tests/ImageSharp.Benchmarks/Codecs/Jpeg/BlockOperations/Block8x8F_MultiplyInPlaceBlock.cs b/tests/ImageSharp.Benchmarks/Codecs/Jpeg/BlockOperations/Block8x8F_MultiplyInPlaceBlock.cs
index 722b095870..3c03f3e056 100644
--- a/tests/ImageSharp.Benchmarks/Codecs/Jpeg/BlockOperations/Block8x8F_MultiplyInPlaceBlock.cs
+++ b/tests/ImageSharp.Benchmarks/Codecs/Jpeg/BlockOperations/Block8x8F_MultiplyInPlaceBlock.cs
@@ -20,7 +20,7 @@ public class Block8x8F_MultiplyInPlaceBlock
 
     private static Block8x8F Create8x8FloatData()
     {
-        var result = new float[64];
+        float[] result = new float[64];
         for (int i = 0; i < 8; i++)
         {
             for (int j = 0; j < 8; j++)
diff --git a/tests/ImageSharp.Benchmarks/Codecs/Jpeg/BlockOperations/Block8x8F_Transpose.cs b/tests/ImageSharp.Benchmarks/Codecs/Jpeg/BlockOperations/Block8x8F_Transpose.cs
index 07907f21d7..caca630bc2 100644
--- a/tests/ImageSharp.Benchmarks/Codecs/Jpeg/BlockOperations/Block8x8F_Transpose.cs
+++ b/tests/ImageSharp.Benchmarks/Codecs/Jpeg/BlockOperations/Block8x8F_Transpose.cs
@@ -14,7 +14,7 @@ public class Block8x8F_Transpose
     [Benchmark]
     public float TransposeInplace()
     {
-        this.source.TransposeInplace();
+        this.source.TransposeInPlace();
         return this.source[0];
     }
 
diff --git a/tests/ImageSharp.Benchmarks/Codecs/Jpeg/ColorConversion/CmykColorConversion.cs b/tests/ImageSharp.Benchmarks/Codecs/Jpeg/ColorConversion/CmykColorConversion.cs
index 9189bec376..a1ba3fb8d6 100644
--- a/tests/ImageSharp.Benchmarks/Codecs/Jpeg/ColorConversion/CmykColorConversion.cs
+++ b/tests/ImageSharp.Benchmarks/Codecs/Jpeg/ColorConversion/CmykColorConversion.cs
@@ -17,32 +17,32 @@ public class CmykColorConversion : ColorConversionBenchmark
     [Benchmark(Baseline = true)]
     public void Scalar()
     {
-        var values = new JpegColorConverterBase.ComponentValues(this.Input, 0);
+        JpegColorConverterBase.ComponentValues values = new(this.Input, 0);
 
-        new JpegColorConverterBase.CmykScalar(8).ConvertToRgbInplace(values);
+        new JpegColorConverterBase.CmykScalar(8).ConvertToRgbInPlace(values);
     }
 
     [Benchmark]
-    public void SimdVector8()
+    public void SimdVector128()
     {
-        var values = new JpegColorConverterBase.ComponentValues(this.Input, 0);
+        JpegColorConverterBase.ComponentValues values = new(this.Input, 0);
 
-        new JpegColorConverterBase.CmykVector(8).ConvertToRgbInplace(values);
+        new JpegColorConverterBase.CmykVector128(8).ConvertToRgbInPlace(values);
     }
 
     [Benchmark]
-    public void SimdVectorAvx()
+    public void SimdVector256()
     {
-        var values = new JpegColorConverterBase.ComponentValues(this.Input, 0);
+        JpegColorConverterBase.ComponentValues values = new(this.Input, 0);
 
-        new JpegColorConverterBase.CmykAvx(8).ConvertToRgbInplace(values);
+        new JpegColorConverterBase.CmykVector256(8).ConvertToRgbInPlace(values);
     }
 
     [Benchmark]
-    public void SimdVectorArm64()
+    public void SimdVector512()
     {
-        var values = new JpegColorConverterBase.ComponentValues(this.Input, 0);
+        JpegColorConverterBase.ComponentValues values = new(this.Input, 0);
 
-        new JpegColorConverterBase.CmykArm64(8).ConvertToRgbInplace(values);
+        new JpegColorConverterBase.CmykVector512(8).ConvertToRgbInPlace(values);
     }
 }
diff --git a/tests/ImageSharp.Benchmarks/Codecs/Jpeg/ColorConversion/ColorConversionBenchmark.cs b/tests/ImageSharp.Benchmarks/Codecs/Jpeg/ColorConversion/ColorConversionBenchmark.cs
index 8964667b74..436aa9bcda 100644
--- a/tests/ImageSharp.Benchmarks/Codecs/Jpeg/ColorConversion/ColorConversionBenchmark.cs
+++ b/tests/ImageSharp.Benchmarks/Codecs/Jpeg/ColorConversion/ColorConversionBenchmark.cs
@@ -38,11 +38,11 @@ public abstract class ColorConversionBenchmark
         float minVal = 0f,
         float maxVal = 255f)
     {
-        var rnd = new Random(42);
-        var buffers = new Buffer2D<float>[componentCount];
+        Random rnd = new(42);
+        Buffer2D<float>[] buffers = new Buffer2D<float>[componentCount];
         for (int i = 0; i < componentCount; i++)
         {
-            var values = new float[inputBufferLength];
+            float[] values = new float[inputBufferLength];
 
             for (int j = 0; j < inputBufferLength; j++)
             {
diff --git a/tests/ImageSharp.Benchmarks/Codecs/Jpeg/ColorConversion/GrayscaleColorConversion.cs b/tests/ImageSharp.Benchmarks/Codecs/Jpeg/ColorConversion/GrayscaleColorConversion.cs
index a1d85ef466..3ade4279fd 100644
--- a/tests/ImageSharp.Benchmarks/Codecs/Jpeg/ColorConversion/GrayscaleColorConversion.cs
+++ b/tests/ImageSharp.Benchmarks/Codecs/Jpeg/ColorConversion/GrayscaleColorConversion.cs
@@ -7,9 +7,9 @@ using SixLabors.ImageSharp.Formats.Jpeg.Components;
 namespace SixLabors.ImageSharp.Benchmarks.Codecs.Jpeg;
 
 [Config(typeof(Config.Short))]
-public class GrayscaleColorConversion : ColorConversionBenchmark
+public class GrayScaleColorConversion : ColorConversionBenchmark
 {
-    public GrayscaleColorConversion()
+    public GrayScaleColorConversion()
         : base(1)
     {
     }
@@ -17,24 +17,32 @@ public class GrayscaleColorConversion : ColorConversionBenchmark
     [Benchmark(Baseline = true)]
     public void Scalar()
     {
-        var values = new JpegColorConverterBase.ComponentValues(this.Input, 0);
+        JpegColorConverterBase.ComponentValues values = new(this.Input, 0);
 
-        new JpegColorConverterBase.GrayscaleScalar(8).ConvertToRgbInplace(values);
+        new JpegColorConverterBase.GrayScaleScalar(8).ConvertToRgbInPlace(values);
     }
 
     [Benchmark]
-    public void SimdVectorAvx()
+    public void SimdVector128()
     {
-        var values = new JpegColorConverterBase.ComponentValues(this.Input, 0);
+        JpegColorConverterBase.ComponentValues values = new(this.Input, 0);
 
-        new JpegColorConverterBase.GrayscaleAvx(8).ConvertToRgbInplace(values);
+        new JpegColorConverterBase.GrayScaleVector128(8).ConvertToRgbInPlace(values);
     }
 
     [Benchmark]
-    public void SimdVectorArm()
+    public void SimdVector256()
     {
-        var values = new JpegColorConverterBase.ComponentValues(this.Input, 0);
+        JpegColorConverterBase.ComponentValues values = new(this.Input, 0);
 
-        new JpegColorConverterBase.GrayscaleArm(8).ConvertToRgbInplace(values);
+        new JpegColorConverterBase.GrayScaleVector256(8).ConvertToRgbInPlace(values);
+    }
+
+    [Benchmark]
+    public void SimdVector512()
+    {
+        JpegColorConverterBase.ComponentValues values = new(this.Input, 0);
+
+        new JpegColorConverterBase.GrayScaleVector512(8).ConvertToRgbInPlace(values);
     }
 }
diff --git a/tests/ImageSharp.Benchmarks/Codecs/Jpeg/ColorConversion/RgbColorConversion.cs b/tests/ImageSharp.Benchmarks/Codecs/Jpeg/ColorConversion/RgbColorConversion.cs
index 5e2b6fe860..2916dcdce7 100644
--- a/tests/ImageSharp.Benchmarks/Codecs/Jpeg/ColorConversion/RgbColorConversion.cs
+++ b/tests/ImageSharp.Benchmarks/Codecs/Jpeg/ColorConversion/RgbColorConversion.cs
@@ -17,32 +17,32 @@ public class RgbColorConversion : ColorConversionBenchmark
     [Benchmark(Baseline = true)]
     public void Scalar()
     {
-        var values = new JpegColorConverterBase.ComponentValues(this.Input, 0);
+        JpegColorConverterBase.ComponentValues values = new(this.Input, 0);
 
-        new JpegColorConverterBase.RgbScalar(8).ConvertToRgbInplace(values);
+        new JpegColorConverterBase.RgbScalar(8).ConvertToRgbInPlace(values);
     }
 
     [Benchmark]
-    public void SimdVector8()
+    public void SimdVector128()
     {
-        var values = new JpegColorConverterBase.ComponentValues(this.Input, 0);
+        JpegColorConverterBase.ComponentValues values = new(this.Input, 0);
 
-        new JpegColorConverterBase.RgbVector(8).ConvertToRgbInplace(values);
+        new JpegColorConverterBase.RgbVector128(8).ConvertToRgbInPlace(values);
     }
 
     [Benchmark]
-    public void SimdVectorAvx()
+    public void SimdVector256()
     {
-        var values = new JpegColorConverterBase.ComponentValues(this.Input, 0);
+        JpegColorConverterBase.ComponentValues values = new(this.Input, 0);
 
-        new JpegColorConverterBase.RgbAvx(8).ConvertToRgbInplace(values);
+        new JpegColorConverterBase.RgbVector256(8).ConvertToRgbInPlace(values);
     }
 
     [Benchmark]
-    public void SimdVectorArm()
+    public void SimdVector512()
     {
-        var values = new JpegColorConverterBase.ComponentValues(this.Input, 0);
+        JpegColorConverterBase.ComponentValues values = new(this.Input, 0);
 
-        new JpegColorConverterBase.RgbArm(8).ConvertToRgbInplace(values);
+        new JpegColorConverterBase.RgbVector512(8).ConvertToRgbInPlace(values);
     }
 }
diff --git a/tests/ImageSharp.Benchmarks/Codecs/Jpeg/ColorConversion/YCbCrColorConversion.cs b/tests/ImageSharp.Benchmarks/Codecs/Jpeg/ColorConversion/YCbCrColorConversion.cs
index f8621c2500..fbd762af41 100644
--- a/tests/ImageSharp.Benchmarks/Codecs/Jpeg/ColorConversion/YCbCrColorConversion.cs
+++ b/tests/ImageSharp.Benchmarks/Codecs/Jpeg/ColorConversion/YCbCrColorConversion.cs
@@ -17,32 +17,32 @@ public class YCbCrColorConversion : ColorConversionBenchmark
     [Benchmark]
     public void Scalar()
     {
-        var values = new JpegColorConverterBase.ComponentValues(this.Input, 0);
+        JpegColorConverterBase.ComponentValues values = new(this.Input, 0);
 
-        new JpegColorConverterBase.YCbCrScalar(8).ConvertToRgbInplace(values);
+        new JpegColorConverterBase.YCbCrScalar(8).ConvertToRgbInPlace(values);
     }
 
     [Benchmark]
-    public void SimdVector8()
+    public void SimdVector128()
     {
-        var values = new JpegColorConverterBase.ComponentValues(this.Input, 0);
+        JpegColorConverterBase.ComponentValues values = new(this.Input, 0);
 
-        new JpegColorConverterBase.YCbCrVector(8).ConvertToRgbInplace(values);
+        new JpegColorConverterBase.YCbCrVector128(8).ConvertToRgbInPlace(values);
     }
 
     [Benchmark]
-    public void SimdVectorAvx()
+    public void SimdVector256()
     {
-        var values = new JpegColorConverterBase.ComponentValues(this.Input, 0);
+        JpegColorConverterBase.ComponentValues values = new(this.Input, 0);
 
-        new JpegColorConverterBase.YCbCrAvx(8).ConvertToRgbInplace(values);
+        new JpegColorConverterBase.YCbCrVector256(8).ConvertToRgbInPlace(values);
     }
 
     [Benchmark]
-    public void SimdVectorArm()
+    public void SimdVector512()
     {
-        var values = new JpegColorConverterBase.ComponentValues(this.Input, 0);
+        JpegColorConverterBase.ComponentValues values = new(this.Input, 0);
 
-        new JpegColorConverterBase.YCbCrArm(8).ConvertToRgbInplace(values);
+        new JpegColorConverterBase.YCbCrVector512(8).ConvertToRgbInPlace(values);
     }
 }
diff --git a/tests/ImageSharp.Benchmarks/Codecs/Jpeg/ColorConversion/YccKColorConverter.cs b/tests/ImageSharp.Benchmarks/Codecs/Jpeg/ColorConversion/YccKColorConverter.cs
index a414b6ed47..e6b04c1526 100644
--- a/tests/ImageSharp.Benchmarks/Codecs/Jpeg/ColorConversion/YccKColorConverter.cs
+++ b/tests/ImageSharp.Benchmarks/Codecs/Jpeg/ColorConversion/YccKColorConverter.cs
@@ -17,32 +17,32 @@ public class YccKColorConverter : ColorConversionBenchmark
     [Benchmark(Baseline = true)]
     public void Scalar()
     {
-        var values = new JpegColorConverterBase.ComponentValues(this.Input, 0);
+        JpegColorConverterBase.ComponentValues values = new(this.Input, 0);
 
-        new JpegColorConverterBase.YccKScalar(8).ConvertToRgbInplace(values);
+        new JpegColorConverterBase.YccKScalar(8).ConvertToRgbInPlace(values);
     }
 
     [Benchmark]
-    public void SimdVector8()
+    public void SimdVector128()
     {
-        var values = new JpegColorConverterBase.ComponentValues(this.Input, 0);
+        JpegColorConverterBase.ComponentValues values = new(this.Input, 0);
 
-        new JpegColorConverterBase.YccKVector(8).ConvertToRgbInplace(values);
+        new JpegColorConverterBase.YccKVector128(8).ConvertToRgbInPlace(values);
     }
 
     [Benchmark]
-    public void SimdVectorAvx2()
+    public void SimdVector256()
     {
-        var values = new JpegColorConverterBase.ComponentValues(this.Input, 0);
+        JpegColorConverterBase.ComponentValues values = new(this.Input, 0);
 
-        new JpegColorConverterBase.YccKAvx(8).ConvertToRgbInplace(values);
+        new JpegColorConverterBase.YccKVector256(8).ConvertToRgbInPlace(values);
     }
 
     [Benchmark]
-    public void SimdVectorArm64()
+    public void SimdVector512()
     {
-        var values = new JpegColorConverterBase.ComponentValues(this.Input, 0);
+        JpegColorConverterBase.ComponentValues values = new(this.Input, 0);
 
-        new JpegColorConverterBase.YccKArm64(8).ConvertToRgbInplace(values);
+        new JpegColorConverterBase.YccKVector512(8).ConvertToRgbInPlace(values);
     }
 }
diff --git a/tests/ImageSharp.Benchmarks/Codecs/Jpeg/DecodeJpeg.cs b/tests/ImageSharp.Benchmarks/Codecs/Jpeg/DecodeJpeg.cs
index 0dc6d26bc7..dbd2557225 100644
--- a/tests/ImageSharp.Benchmarks/Codecs/Jpeg/DecodeJpeg.cs
+++ b/tests/ImageSharp.Benchmarks/Codecs/Jpeg/DecodeJpeg.cs
@@ -8,6 +8,7 @@ using SixLabors.ImageSharp.Tests;
 
 namespace SixLabors.ImageSharp.Benchmarks.Codecs.Jpeg;
 
+[Config(typeof(Config.HwIntrinsics_SSE_AVX))]
 public class DecodeJpeg
 {
     private JpegDecoder decoder;
@@ -21,7 +22,7 @@ public class DecodeJpeg
         this.preloadedImageStream = new MemoryStream(bytes);
     }
 
-    private void GenericBechmark()
+    private void GenericBenchmark()
     {
         this.preloadedImageStream.Position = 0;
         using Image img = this.decoder.Decode(DecoderOptions.Default, this.preloadedImageStream);
@@ -51,16 +52,16 @@ public class DecodeJpeg
     }
 
     [Benchmark(Description = "Baseline 4:4:4 Interleaved")]
-    public void JpegBaselineInterleaved444() => this.GenericBechmark();
+    public void JpegBaselineInterleaved444() => this.GenericBenchmark();
 
     [Benchmark(Description = "Baseline 4:2:0 Interleaved")]
-    public void JpegBaselineInterleaved420() => this.GenericBechmark();
+    public void JpegBaselineInterleaved420() => this.GenericBenchmark();
 
     [Benchmark(Description = "Baseline 4:0:0 (grayscale)")]
-    public void JpegBaseline400() => this.GenericBechmark();
+    public void JpegBaseline400() => this.GenericBenchmark();
 
     [Benchmark(Description = "Progressive 4:2:0 Non-Interleaved")]
-    public void JpegProgressiveNonInterleaved420() => this.GenericBechmark();
+    public void JpegProgressiveNonInterleaved420() => this.GenericBenchmark();
 }
 
 /*
diff --git a/tests/ImageSharp.Benchmarks/Codecs/Jpeg/DecodeJpegParseStreamOnly.cs b/tests/ImageSharp.Benchmarks/Codecs/Jpeg/DecodeJpegParseStreamOnly.cs
index 5f6dbbdf72..e7b66576d1 100644
--- a/tests/ImageSharp.Benchmarks/Codecs/Jpeg/DecodeJpegParseStreamOnly.cs
+++ b/tests/ImageSharp.Benchmarks/Codecs/Jpeg/DecodeJpegParseStreamOnly.cs
@@ -2,9 +2,11 @@
 // Licensed under the Six Labors Split License.
 
 using BenchmarkDotNet.Attributes;
+using SixLabors.ImageSharp.Formats;
 using SixLabors.ImageSharp.Formats.Jpeg;
 using SixLabors.ImageSharp.Formats.Jpeg.Components.Decoder;
 using SixLabors.ImageSharp.IO;
+using SixLabors.ImageSharp.Metadata.Profiles.Icc;
 using SixLabors.ImageSharp.Tests;
 using SDSize = System.Drawing.Size;
 
@@ -37,7 +39,7 @@ public class DecodeJpegParseStreamOnly
     {
         using MemoryStream memoryStream = new(this.jpegBytes);
         using BufferedReadStream bufferedStream = new(Configuration.Default, memoryStream);
-        JpegDecoderOptions options = new() { GeneralOptions = new() { SkipMetadata = true } };
+        JpegDecoderOptions options = new() { GeneralOptions = new DecoderOptions { SkipMetadata = true } };
 
         using JpegDecoderCore decoder = new(options);
         NoopSpectralConverter spectralConverter = new();
@@ -50,7 +52,7 @@ public class DecodeJpegParseStreamOnly
     // There's no way to eliminate it as spectral conversion is built into the scan decoding loop for memory footprint reduction
     private sealed class NoopSpectralConverter : SpectralConverter
     {
-        public override void ConvertStrideBaseline()
+        public override void ConvertStrideBaseline(IccProfile iccProfile)
         {
         }
 
diff --git a/tests/ImageSharp.Benchmarks/Codecs/Jpeg/DecodeJpeg_ImageSpecific.cs b/tests/ImageSharp.Benchmarks/Codecs/Jpeg/DecodeJpeg_ImageSpecific.cs
index 257e44cc40..9a4ee39676 100644
--- a/tests/ImageSharp.Benchmarks/Codecs/Jpeg/DecodeJpeg_ImageSpecific.cs
+++ b/tests/ImageSharp.Benchmarks/Codecs/Jpeg/DecodeJpeg_ImageSpecific.cs
@@ -49,7 +49,7 @@ public class DecodeJpeg_ImageSpecific
     public Size ImageSharp()
     {
         using MemoryStream memoryStream = new(this.jpegBytes);
-        using Image image = Image.Load(new DecoderOptions() { SkipMetadata = true }, memoryStream);
+        using Image image = Image.Load(new DecoderOptions { SkipMetadata = true }, memoryStream);
         return new Size(image.Width, image.Height);
     }
 
diff --git a/tests/ImageSharp.Benchmarks/Color/RgbWorkingSpaceAdapt.cs b/tests/ImageSharp.Benchmarks/Color/RgbWorkingSpaceAdapt.cs
index 6cd8df3fc7..b847e3ac54 100644
--- a/tests/ImageSharp.Benchmarks/Color/RgbWorkingSpaceAdapt.cs
+++ b/tests/ImageSharp.Benchmarks/Color/RgbWorkingSpaceAdapt.cs
@@ -13,7 +13,7 @@ public class RgbWorkingSpaceAdapt
 
     private static readonly RGBColor RGBColor = new(0.206162, 0.260277, 0.746717);
 
-    private static readonly ColorProfileConverter ColorProfileConverter = new(new ColorConversionOptions { RgbWorkingSpace = KnownRgbWorkingSpaces.WideGamutRgb, TargetRgbWorkingSpace = KnownRgbWorkingSpaces.SRgb });
+    private static readonly ColorProfileConverter ColorProfileConverter = new(new ColorConversionOptions { SourceRgbWorkingSpace = KnownRgbWorkingSpaces.WideGamutRgb, TargetRgbWorkingSpace = KnownRgbWorkingSpaces.SRgb });
 
     private static readonly IColorConverter<RGBColor, RGBColor> ColourfulConverter = new ConverterBuilder().FromRGB(RGBWorkingSpaces.WideGamutRGB).ToRGB(RGBWorkingSpaces.sRGB).Build();
 
diff --git a/tests/ImageSharp.Benchmarks/Config.HwIntrinsics.cs b/tests/ImageSharp.Benchmarks/Config.HwIntrinsics.cs
index e21d0c76d8..9fd48301ea 100644
--- a/tests/ImageSharp.Benchmarks/Config.HwIntrinsics.cs
+++ b/tests/ImageSharp.Benchmarks/Config.HwIntrinsics.cs
@@ -34,6 +34,7 @@ public partial class Config
     // like `LZCNT`, `BMI1`, or `BMI2`
     // `EnableSSE3_4` is a legacy switch that exists for compat and is basically the same as `EnableSSE3`
     private const string EnableAES = "DOTNET_EnableAES";
+    private const string EnableAVX512F = "DOTNET_EnableAVX512F";
     private const string EnableAVX = "DOTNET_EnableAVX";
     private const string EnableAVX2 = "DOTNET_EnableAVX2";
     private const string EnableBMI1 = "DOTNET_EnableBMI1";
@@ -76,4 +77,36 @@ public partial class Config
             }
         }
     }
+
+    public class HwIntrinsics_SSE_AVX_AVX512F : Config
+    {
+        public HwIntrinsics_SSE_AVX_AVX512F()
+        {
+            this.AddJob(Job.Default.WithRuntime(CoreRuntime.Core80)
+                .WithEnvironmentVariables(
+                    new EnvironmentVariable(EnableHWIntrinsic, Off),
+                    new EnvironmentVariable(FeatureSIMD, Off))
+                .WithId("1. No HwIntrinsics").AsBaseline());
+
+            if (Sse.IsSupported)
+            {
+                this.AddJob(Job.Default.WithRuntime(CoreRuntime.Core80)
+                    .WithEnvironmentVariables(new EnvironmentVariable(EnableAVX, Off))
+                    .WithId("2. SSE"));
+            }
+
+            if (Avx.IsSupported)
+            {
+                this.AddJob(Job.Default.WithRuntime(CoreRuntime.Core80)
+                    .WithEnvironmentVariables(new EnvironmentVariable(EnableAVX512F, Off))
+                    .WithId("3. AVX"));
+            }
+
+            if (Avx512F.IsSupported)
+            {
+                this.AddJob(Job.Default.WithRuntime(CoreRuntime.Core80)
+                    .WithId("3. AVX512F"));
+            }
+        }
+    }
 }
diff --git a/tests/ImageSharp.Benchmarks/General/Adler32Benchmark.cs b/tests/ImageSharp.Benchmarks/General/Adler32Benchmark.cs
index 30023feca8..64a8092c63 100644
--- a/tests/ImageSharp.Benchmarks/General/Adler32Benchmark.cs
+++ b/tests/ImageSharp.Benchmarks/General/Adler32Benchmark.cs
@@ -11,7 +11,7 @@ namespace SixLabors.ImageSharp.Benchmarks.General;
 public class Adler32Benchmark
 {
     private byte[] data;
-    private readonly SharpAdler32 adler = new SharpAdler32();
+    private readonly SharpAdler32 adler = new();
 
     [Params(1024, 2048, 4096)]
     public int Count { get; set; }
diff --git a/tests/ImageSharp.Benchmarks/General/BasicMath/ClampFloat.cs b/tests/ImageSharp.Benchmarks/General/BasicMath/ClampFloat.cs
index dd0bc28785..317295144f 100644
--- a/tests/ImageSharp.Benchmarks/General/BasicMath/ClampFloat.cs
+++ b/tests/ImageSharp.Benchmarks/General/BasicMath/ClampFloat.cs
@@ -10,7 +10,7 @@ public class ClampFloat
 {
     private readonly float min = -1.5f;
     private readonly float max = 2.5f;
-    private static readonly float[] Values = { -10, -5, -3, -1.5f, -0.5f, 0f, 1f, 1.5f, 2.5f, 3, 10 };
+    private static readonly float[] Values = [-10, -5, -3, -1.5f, -0.5f, 0f, 1f, 1.5f, 2.5f, 3, 10];
 
     [Benchmark(Baseline = true)]
     public float UsingMathF()
diff --git a/tests/ImageSharp.Benchmarks/General/BasicMath/ClampSpan.cs b/tests/ImageSharp.Benchmarks/General/BasicMath/ClampSpan.cs
index d47fcb687e..b61ba27ffb 100644
--- a/tests/ImageSharp.Benchmarks/General/BasicMath/ClampSpan.cs
+++ b/tests/ImageSharp.Benchmarks/General/BasicMath/ClampSpan.cs
@@ -12,7 +12,7 @@ public class ClampSpan
 
     public void Setup()
     {
-        var r = new Random();
+        Random r = new();
 
         for (int i = 0; i < A.Length; i++)
         {
diff --git a/tests/ImageSharp.Benchmarks/General/BasicMath/ClampVector4.cs b/tests/ImageSharp.Benchmarks/General/BasicMath/ClampVector4.cs
index 186f88bb71..4969c3ef7a 100644
--- a/tests/ImageSharp.Benchmarks/General/BasicMath/ClampVector4.cs
+++ b/tests/ImageSharp.Benchmarks/General/BasicMath/ClampVector4.cs
@@ -11,7 +11,7 @@ public class ClampVector4
 {
     private readonly float min = -1.5f;
     private readonly float max = 2.5f;
-    private static readonly float[] Values = { -10, -5, -3, -1.5f, -0.5f, 0f, 1f, 1.5f, 2.5f, 3, 10 };
+    private static readonly float[] Values = [-10, -5, -3, -1.5f, -0.5f, 0f, 1f, 1.5f, 2.5f, 3, 10];
 
     [Benchmark(Baseline = true)]
     public Vector4 UsingVectorClamp()
diff --git a/tests/ImageSharp.Benchmarks/General/PixelConversion/PixelConversion_PackFromRgbPlanes.cs b/tests/ImageSharp.Benchmarks/General/PixelConversion/PixelConversion_PackFromRgbPlanes.cs
index a42c6c253c..226dcc7775 100644
--- a/tests/ImageSharp.Benchmarks/General/PixelConversion/PixelConversion_PackFromRgbPlanes.cs
+++ b/tests/ImageSharp.Benchmarks/General/PixelConversion/PixelConversion_PackFromRgbPlanes.cs
@@ -209,7 +209,7 @@ public unsafe class PixelConversion_PackFromRgbPlanes
 
         Vector256<int> vcontrol = SimdUtils.HwIntrinsics.PermuteMaskEvenOdd8x32().AsInt32();
 
-        var va = Vector256.Create(1F);
+        Vector256<float> va = Vector256.Create(1F);
 
         for (nuint i = 0; i < count; i++)
         {
diff --git a/tests/ImageSharp.Benchmarks/General/PixelConversion/PixelConversion_Rgba32_To_Bgra32.cs b/tests/ImageSharp.Benchmarks/General/PixelConversion/PixelConversion_Rgba32_To_Bgra32.cs
index f4fb9e4204..232d8b3e27 100644
--- a/tests/ImageSharp.Benchmarks/General/PixelConversion/PixelConversion_Rgba32_To_Bgra32.cs
+++ b/tests/ImageSharp.Benchmarks/General/PixelConversion/PixelConversion_Rgba32_To_Bgra32.cs
@@ -252,8 +252,8 @@ public class PixelConversion_Rgba32_To_Bgra32
     private static void BitopsSimdImpl(ref Octet<uint> s, ref Octet<uint> d)
     {
         Vector<uint> sVec = Unsafe.As<Octet<uint>, Vector<uint>>(ref s);
-        var aMask = new Vector<uint>(0xFF00FF00);
-        var bMask = new Vector<uint>(0x00FF00FF);
+        Vector<uint> aMask = new(0xFF00FF00);
+        Vector<uint> bMask = new(0x00FF00FF);
 
         Vector<uint> aa = sVec & aMask;
         Vector<uint> bb = sVec & bMask;
diff --git a/tests/ImageSharp.Benchmarks/General/PixelConversion/TestArgb.cs b/tests/ImageSharp.Benchmarks/General/PixelConversion/TestArgb.cs
index 21bef5a156..8698f82231 100644
--- a/tests/ImageSharp.Benchmarks/General/PixelConversion/TestArgb.cs
+++ b/tests/ImageSharp.Benchmarks/General/PixelConversion/TestArgb.cs
@@ -103,6 +103,6 @@ public struct TestArgb : ITestPixel<TestArgb>
         vector = Numerics.Clamp(vector, Vector4.Zero, MaxBytes);
 
         Vector128<byte> result = Vector128.ConvertToInt32(vector.AsVector128()).AsByte();
-        return new(result.GetElement(0), result.GetElement(4), result.GetElement(8), result.GetElement(12));
+        return new TestArgb(result.GetElement(0), result.GetElement(4), result.GetElement(8), result.GetElement(12));
     }
 }
diff --git a/tests/ImageSharp.Benchmarks/General/PixelConversion/TestRgba.cs b/tests/ImageSharp.Benchmarks/General/PixelConversion/TestRgba.cs
index 1499fb7d3d..751cd68b48 100644
--- a/tests/ImageSharp.Benchmarks/General/PixelConversion/TestRgba.cs
+++ b/tests/ImageSharp.Benchmarks/General/PixelConversion/TestRgba.cs
@@ -79,6 +79,6 @@ public struct TestRgba : ITestPixel<TestRgba>
         vector = Numerics.Clamp(vector, Vector4.Zero, MaxBytes);
 
         Vector128<byte> result = Vector128.ConvertToInt32(vector.AsVector128()).AsByte();
-        return new(result.GetElement(0), result.GetElement(4), result.GetElement(8), result.GetElement(12));
+        return new TestRgba(result.GetElement(0), result.GetElement(4), result.GetElement(8), result.GetElement(12));
     }
 }
diff --git a/tests/ImageSharp.Benchmarks/General/Vector4Constants.cs b/tests/ImageSharp.Benchmarks/General/Vector4Constants.cs
index 2cd6a5a52a..5919137bf2 100644
--- a/tests/ImageSharp.Benchmarks/General/Vector4Constants.cs
+++ b/tests/ImageSharp.Benchmarks/General/Vector4Constants.cs
@@ -12,10 +12,10 @@ namespace SixLabors.ImageSharp.Benchmarks.General;
 /// </summary>
 public class Vector4Constants
 {
-    private static readonly Vector4 A = new Vector4(1.2f);
-    private static readonly Vector4 B = new Vector4(3.4f);
-    private static readonly Vector4 C = new Vector4(5.6f);
-    private static readonly Vector4 D = new Vector4(7.8f);
+    private static readonly Vector4 A = new(1.2f);
+    private static readonly Vector4 B = new(3.4f);
+    private static readonly Vector4 C = new(5.6f);
+    private static readonly Vector4 D = new(7.8f);
 
     private Random random;
 
@@ -39,8 +39,8 @@ public class Vector4Constants
 
         Vector4 x = (p * A / B) + (p * C / D);
         Vector4 y = (p / A * B) + (p / C * D);
-        var z = Vector4.Min(p, A);
-        var w = Vector4.Max(p, B);
+        Vector4 z = Vector4.Min(p, A);
+        Vector4 w = Vector4.Max(p, B);
         return x + y + z + w;
     }
 
@@ -51,8 +51,8 @@ public class Vector4Constants
 
         Vector4 x = (p * new Vector4(1.2f) / new Vector4(2.3f)) + (p * new Vector4(4.5f) / new Vector4(6.7f));
         Vector4 y = (p / new Vector4(1.2f) * new Vector4(2.3f)) + (p / new Vector4(4.5f) * new Vector4(6.7f));
-        var z = Vector4.Min(p, new Vector4(1.2f));
-        var w = Vector4.Max(p, new Vector4(2.3f));
+        Vector4 z = Vector4.Min(p, new Vector4(1.2f));
+        Vector4 w = Vector4.Max(p, new Vector4(2.3f));
         return x + y + z + w;
     }
 
diff --git a/tests/ImageSharp.Benchmarks/General/Vectorization/BitwiseOrUint32.cs b/tests/ImageSharp.Benchmarks/General/Vectorization/BitwiseOrUint32.cs
index 4d8d9b1ed6..2f9b02b59f 100644
--- a/tests/ImageSharp.Benchmarks/General/Vectorization/BitwiseOrUint32.cs
+++ b/tests/ImageSharp.Benchmarks/General/Vectorization/BitwiseOrUint32.cs
@@ -43,11 +43,11 @@ public class BitwiseOrUInt32
     [Benchmark]
     public void Simd()
     {
-        var v = new Vector<uint>(this.testValue);
+        Vector<uint> v = new(this.testValue);
 
         for (int i = 0; i < this.input.Length; i += Vector<uint>.Count)
         {
-            var a = new Vector<uint>(this.input, i);
+            Vector<uint> a = new(this.input, i);
             a = Vector.BitwiseOr(a, v);
             a.CopyTo(this.result, i);
         }
diff --git a/tests/ImageSharp.Benchmarks/General/Vectorization/DivFloat.cs b/tests/ImageSharp.Benchmarks/General/Vectorization/DivFloat.cs
index 1b2c56ab97..fd243638b2 100644
--- a/tests/ImageSharp.Benchmarks/General/Vectorization/DivFloat.cs
+++ b/tests/ImageSharp.Benchmarks/General/Vectorization/DivFloat.cs
@@ -43,11 +43,11 @@ public class DivFloat
     [Benchmark]
     public void Simd()
     {
-        var v = new Vector<float>(this.testValue);
+        Vector<float> v = new(this.testValue);
 
         for (int i = 0; i < this.input.Length; i += Vector<uint>.Count)
         {
-            var a = new Vector<float>(this.input, i);
+            Vector<float> a = new(this.input, i);
             a = a / v;
             a.CopyTo(this.result, i);
         }
diff --git a/tests/ImageSharp.Benchmarks/General/Vectorization/DivUInt32.cs b/tests/ImageSharp.Benchmarks/General/Vectorization/DivUInt32.cs
index d102164e2c..0d2923b619 100644
--- a/tests/ImageSharp.Benchmarks/General/Vectorization/DivUInt32.cs
+++ b/tests/ImageSharp.Benchmarks/General/Vectorization/DivUInt32.cs
@@ -44,11 +44,11 @@ public class DivUInt32
     [Benchmark]
     public void Simd()
     {
-        var v = new Vector<uint>(this.testValue);
+        Vector<uint> v = new(this.testValue);
 
         for (int i = 0; i < this.input.Length; i += Vector<uint>.Count)
         {
-            var a = new Vector<uint>(this.input, i);
+            Vector<uint> a = new(this.input, i);
 
             a = a / v;
             a.CopyTo(this.result, i);
diff --git a/tests/ImageSharp.Benchmarks/General/Vectorization/Divide.cs b/tests/ImageSharp.Benchmarks/General/Vectorization/Divide.cs
index 5277897bb2..61ff9466ee 100644
--- a/tests/ImageSharp.Benchmarks/General/Vectorization/Divide.cs
+++ b/tests/ImageSharp.Benchmarks/General/Vectorization/Divide.cs
@@ -57,7 +57,7 @@ public class DivInt16 : SIMDBenchmarkBase<short>.Divide
 {
     protected override short GetTestValue() => 42;
 
-    protected override Vector<short> GetTestVector() => new Vector<short>(new short[] { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17 });
+    protected override Vector<short> GetTestVector() => new(new short[] { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17 });
 
     [Benchmark(Baseline = true)]
     public void Standard()
diff --git a/tests/ImageSharp.Benchmarks/General/Vectorization/MulFloat.cs b/tests/ImageSharp.Benchmarks/General/Vectorization/MulFloat.cs
index a2eb8d417a..801b0e1613 100644
--- a/tests/ImageSharp.Benchmarks/General/Vectorization/MulFloat.cs
+++ b/tests/ImageSharp.Benchmarks/General/Vectorization/MulFloat.cs
@@ -43,11 +43,11 @@ public class MulFloat
     [Benchmark]
     public void SimdMultiplyByVector()
     {
-        var v = new Vector<float>(this.testValue);
+        Vector<float> v = new(this.testValue);
 
         for (int i = 0; i < this.input.Length; i += Vector<uint>.Count)
         {
-            var a = new Vector<float>(this.input, i);
+            Vector<float> a = new(this.input, i);
             a = a * v;
             a.CopyTo(this.result, i);
         }
@@ -60,7 +60,7 @@ public class MulFloat
 
         for (int i = 0; i < this.input.Length; i += Vector<uint>.Count)
         {
-            var a = new Vector<float>(this.input, i);
+            Vector<float> a = new(this.input, i);
             a = a * v;
             a.CopyTo(this.result, i);
         }
diff --git a/tests/ImageSharp.Benchmarks/General/Vectorization/MulUInt32.cs b/tests/ImageSharp.Benchmarks/General/Vectorization/MulUInt32.cs
index a234970a51..db64486ada 100644
--- a/tests/ImageSharp.Benchmarks/General/Vectorization/MulUInt32.cs
+++ b/tests/ImageSharp.Benchmarks/General/Vectorization/MulUInt32.cs
@@ -43,11 +43,11 @@ public class MulUInt32
     [Benchmark]
     public void Simd()
     {
-        var v = new Vector<uint>(this.testValue);
+        Vector<uint> v = new(this.testValue);
 
         for (int i = 0; i < this.input.Length; i += Vector<uint>.Count)
         {
-            var a = new Vector<uint>(this.input, i);
+            Vector<uint> a = new(this.input, i);
             a = a * v;
             a.CopyTo(this.result, i);
         }
diff --git a/tests/ImageSharp.Benchmarks/General/Vectorization/Multiply.cs b/tests/ImageSharp.Benchmarks/General/Vectorization/Multiply.cs
index 7e890cb925..d9542bc3f7 100644
--- a/tests/ImageSharp.Benchmarks/General/Vectorization/Multiply.cs
+++ b/tests/ImageSharp.Benchmarks/General/Vectorization/Multiply.cs
@@ -40,7 +40,7 @@ public class MulInt16 : SIMDBenchmarkBase<short>.Multiply
 {
     protected override short GetTestValue() => 42;
 
-    protected override Vector<short> GetTestVector() => new Vector<short>(new short[] { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17 });
+    protected override Vector<short> GetTestVector() => new(new short[] { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17 });
 
     [Benchmark(Baseline = true)]
     public void Standard()
diff --git a/tests/ImageSharp.Benchmarks/General/Vectorization/Premultiply.cs b/tests/ImageSharp.Benchmarks/General/Vectorization/Premultiply.cs
index 29b90accc5..f99b141b4e 100644
--- a/tests/ImageSharp.Benchmarks/General/Vectorization/Premultiply.cs
+++ b/tests/ImageSharp.Benchmarks/General/Vectorization/Premultiply.cs
@@ -12,14 +12,14 @@ public class Premultiply
     [Benchmark(Baseline = true)]
     public Vector4 PremultiplyByVal()
     {
-        var input = new Vector4(.5F);
+        Vector4 input = new(.5F);
         return Vector4Utils.Premultiply(input);
     }
 
     [Benchmark]
     public Vector4 PremultiplyByRef()
     {
-        var input = new Vector4(.5F);
+        Vector4 input = new(.5F);
         Vector4Utils.PremultiplyRef(ref input);
         return input;
     }
@@ -27,7 +27,7 @@ public class Premultiply
     [Benchmark]
     public Vector4 PremultiplyRefWithPropertyAssign()
     {
-        var input = new Vector4(.5F);
+        Vector4 input = new(.5F);
         Vector4Utils.PremultiplyRefWithPropertyAssign(ref input);
         return input;
     }
diff --git a/tests/ImageSharp.Benchmarks/General/Vectorization/ReinterpretUInt32AsFloat.cs b/tests/ImageSharp.Benchmarks/General/Vectorization/ReinterpretUInt32AsFloat.cs
index 7d626d7856..557d8ff38b 100644
--- a/tests/ImageSharp.Benchmarks/General/Vectorization/ReinterpretUInt32AsFloat.cs
+++ b/tests/ImageSharp.Benchmarks/General/Vectorization/ReinterpretUInt32AsFloat.cs
@@ -53,8 +53,8 @@ public class ReinterpretUInt32AsFloat
     {
         for (int i = 0; i < this.input.Length; i += Vector<uint>.Count)
         {
-            var a = new Vector<uint>(this.input, i);
-            var b = Vector.AsVectorSingle(a);
+            Vector<uint> a = new(this.input, i);
+            Vector<float> b = Vector.AsVectorSingle(a);
             b.CopyTo(this.result, i);
         }
     }
diff --git a/tests/ImageSharp.Benchmarks/General/Vectorization/UInt32ToSingle.cs b/tests/ImageSharp.Benchmarks/General/Vectorization/UInt32ToSingle.cs
index 5f1f5666de..4048bc210e 100644
--- a/tests/ImageSharp.Benchmarks/General/Vectorization/UInt32ToSingle.cs
+++ b/tests/ImageSharp.Benchmarks/General/Vectorization/UInt32ToSingle.cs
@@ -27,20 +27,20 @@ public class UInt32ToSingle
 
         nuint n = Count / (uint)Vector<float>.Count;
 
-        var bVec = new Vector<float>(256.0f / 255.0f);
-        var magicFloat = new Vector<float>(32768.0f);
-        var magicInt = new Vector<uint>(1191182336); // reinterpreted value of 32768.0f
-        var mask = new Vector<uint>(255);
+        Vector<float> bVec = new(256.0f / 255.0f);
+        Vector<float> magicFloat = new(32768.0f);
+        Vector<uint> magicInt = new(1191182336); // reinterpreted value of 32768.0f
+        Vector<uint> mask = new(255);
 
         for (nuint i = 0; i < n; i++)
         {
             ref Vector<float> df = ref Unsafe.Add(ref b, i);
 
-            var vi = Vector.AsVectorUInt32(df);
+            Vector<uint> vi = Vector.AsVectorUInt32(df);
             vi &= mask;
             vi |= magicInt;
 
-            var vf = Vector.AsVectorSingle(vi);
+            Vector<float> vf = Vector.AsVectorSingle(vi);
             vf = (vf - magicFloat) * bVec;
 
             df = vf;
@@ -55,7 +55,7 @@ public class UInt32ToSingle
         ref Vector<float> bf = ref Unsafe.As<float, Vector<float>>(ref this.data[0]);
         ref Vector<uint> bu = ref Unsafe.As<Vector<float>, Vector<uint>>(ref bf);
 
-        var scale = new Vector<float>(1f / 255f);
+        Vector<float> scale = new(1f / 255f);
 
         for (nuint i = 0; i < n; i++)
         {
@@ -74,7 +74,7 @@ public class UInt32ToSingle
         ref Vector<float> bf = ref Unsafe.As<float, Vector<float>>(ref this.data[0]);
         ref Vector<int> bu = ref Unsafe.As<Vector<float>, Vector<int>>(ref bf);
 
-        var scale = new Vector<float>(1f / 255f);
+        Vector<float> scale = new(1f / 255f);
 
         for (nuint i = 0; i < n; i++)
         {
@@ -91,7 +91,7 @@ public class UInt32ToSingle
         nuint n = Count / (uint)Vector<float>.Count;
 
         ref Vector<float> bf = ref Unsafe.As<float, Vector<float>>(ref this.data[0]);
-        var scale = new Vector<float>(1f / 255f);
+        Vector<float> scale = new(1f / 255f);
 
         for (nuint i = 0; i < n; i++)
         {
diff --git a/tests/ImageSharp.Benchmarks/General/Vectorization/VectorFetching.cs b/tests/ImageSharp.Benchmarks/General/Vectorization/VectorFetching.cs
index 5d20f29d18..9c7fd5b6cc 100644
--- a/tests/ImageSharp.Benchmarks/General/Vectorization/VectorFetching.cs
+++ b/tests/ImageSharp.Benchmarks/General/Vectorization/VectorFetching.cs
@@ -47,11 +47,11 @@ public class VectorFetching
     [Benchmark]
     public void FetchWithVectorConstructor()
     {
-        var v = new Vector<float>(this.testValue);
+        Vector<float> v = new(this.testValue);
 
         for (int i = 0; i < this.data.Length; i += Vector<uint>.Count)
         {
-            var a = new Vector<float>(this.data, i);
+            Vector<float> a = new(this.data, i);
             a = a * v;
             a.CopyTo(this.data, i);
         }
@@ -60,7 +60,7 @@ public class VectorFetching
     [Benchmark]
     public void FetchWithUnsafeCast()
     {
-        var v = new Vector<float>(this.testValue);
+        Vector<float> v = new(this.testValue);
         ref Vector<float> start = ref Unsafe.As<float, Vector<float>>(ref this.data[0]);
 
         nuint n = (uint)this.InputSize / (uint)Vector<uint>.Count;
@@ -79,7 +79,7 @@ public class VectorFetching
     [Benchmark]
     public void FetchWithUnsafeCastNoTempVector()
     {
-        var v = new Vector<float>(this.testValue);
+        Vector<float> v = new(this.testValue);
         ref Vector<float> start = ref Unsafe.As<float, Vector<float>>(ref this.data[0]);
 
         nuint n = (uint)this.InputSize / (uint)Vector<uint>.Count;
@@ -94,9 +94,9 @@ public class VectorFetching
     [Benchmark]
     public void FetchWithUnsafeCastFromReference()
     {
-        var v = new Vector<float>(this.testValue);
+        Vector<float> v = new(this.testValue);
 
-        var span = new Span<float>(this.data);
+        Span<float> span = new(this.data);
 
         ref Vector<float> start = ref Unsafe.As<float, Vector<float>>(ref MemoryMarshal.GetReference(span));
 
diff --git a/tests/ImageSharp.Benchmarks/LoadResizeSave/LoadResizeSaveStressBenchmarks.cs b/tests/ImageSharp.Benchmarks/LoadResizeSave/LoadResizeSaveStressBenchmarks.cs
index 04621695c6..0731c7c004 100644
--- a/tests/ImageSharp.Benchmarks/LoadResizeSave/LoadResizeSaveStressBenchmarks.cs
+++ b/tests/ImageSharp.Benchmarks/LoadResizeSave/LoadResizeSaveStressBenchmarks.cs
@@ -18,7 +18,7 @@ public class LoadResizeSaveStressBenchmarks
     [GlobalSetup]
     public void Setup()
     {
-        this.runner = new LoadResizeSaveStressRunner()
+        this.runner = new LoadResizeSaveStressRunner
         {
             ImageCount = Environment.ProcessorCount,
             Filter = Filter
@@ -34,12 +34,12 @@ public class LoadResizeSaveStressBenchmarks
     }
 
     public int[] ParallelismValues { get; } =
-    {
+    [
         // Environment.ProcessorCount,
         // Environment.ProcessorCount / 2,
         // Environment.ProcessorCount / 4,
         1
-    };
+    ];
 
     [Benchmark]
     [ArgumentsSource(nameof(ParallelismValues))]
diff --git a/tests/ImageSharp.Benchmarks/LoadResizeSave/LoadResizeSaveStressRunner.cs b/tests/ImageSharp.Benchmarks/LoadResizeSave/LoadResizeSaveStressRunner.cs
index 44c248dc98..f8bf19d576 100644
--- a/tests/ImageSharp.Benchmarks/LoadResizeSave/LoadResizeSaveStressRunner.cs
+++ b/tests/ImageSharp.Benchmarks/LoadResizeSave/LoadResizeSaveStressRunner.cs
@@ -53,7 +53,7 @@ public class LoadResizeSaveStressRunner
     public int ThumbnailSize { get; set; } = 150;
 
     private static readonly string[] ProgressiveFiles =
-    {
+    [
         "ancyloscelis-apiformis-m-paraguay-face_2014-08-08-095255-zs-pmax_15046500892_o.jpg",
         "acanthopus-excellens-f-face-brasil_2014-08-06-132105-zs-pmax_14792513890_o.jpg",
         "bee-ceratina-monster-f-ukraine-face_2014-08-09-123342-zs-pmax_15068816101_o.jpg",
@@ -84,8 +84,8 @@ public class LoadResizeSaveStressRunner
         "triepeolus-simplex-m-face-md-kent-county_2014-07-22-100937-zs-pmax_14805405233_o.jpg",
         "washed-megachile-f-face-chile_2014-08-06-103414-zs-pmax_14977843152_o.jpg",
         "xylocopa-balck-violetwing-f-kyrgystan-angle_2014-08-09-182433-zs-pmax_15123416061_o.jpg",
-        "xylocopa-india-yellow-m-india-face_2014-08-10-111701-zs-pmax_15166559172_o.jpg",
-    };
+        "xylocopa-india-yellow-m-india-face_2014-08-10-111701-zs-pmax_15166559172_o.jpg"
+    ];
 
     public void Init()
     {
@@ -148,7 +148,7 @@ public class LoadResizeSaveStressRunner
 
     private void LogImageProcessed(int width, int height)
     {
-        this.LastProcessedImageSize = new Size(width, height);
+        this.LastProcessedImageSize = new ImageSharpSize(width, height);
         double pixels = width * (double)height;
         this.TotalProcessedMegapixels += pixels / 1_000_000.0;
     }
diff --git a/tests/ImageSharp.Benchmarks/Processing/HistogramEqualization.cs b/tests/ImageSharp.Benchmarks/Processing/HistogramEqualization.cs
index 135145a312..93ac9fc0e3 100644
--- a/tests/ImageSharp.Benchmarks/Processing/HistogramEqualization.cs
+++ b/tests/ImageSharp.Benchmarks/Processing/HistogramEqualization.cs
@@ -33,7 +33,7 @@ public class HistogramEqualization
     [Benchmark(Description = "Global Histogram Equalization")]
     public void GlobalHistogramEqualization()
         => this.image.Mutate(img => img.HistogramEqualization(
-            new HistogramEqualizationOptions()
+            new HistogramEqualizationOptions
             {
                 LuminanceLevels = 256,
                 Method = HistogramEqualizationMethod.Global
@@ -42,7 +42,7 @@ public class HistogramEqualization
     [Benchmark(Description = "AdaptiveHistogramEqualization (Tile interpolation)")]
     public void AdaptiveHistogramEqualization()
         => this.image.Mutate(img => img.HistogramEqualization(
-            new HistogramEqualizationOptions()
+            new HistogramEqualizationOptions
             {
                 LuminanceLevels = 256,
                 Method = HistogramEqualizationMethod.AdaptiveTileInterpolation
diff --git a/tests/ImageSharp.Benchmarks/Processing/OilPaint.cs b/tests/ImageSharp.Benchmarks/Processing/OilPaint.cs
index e3e413fe49..7077484998 100644
--- a/tests/ImageSharp.Benchmarks/Processing/OilPaint.cs
+++ b/tests/ImageSharp.Benchmarks/Processing/OilPaint.cs
@@ -13,7 +13,7 @@ public class OilPaint
     [Benchmark]
     public void DoOilPaint()
     {
-        using Image<RgbaVector> image = new Image<RgbaVector>(1920, 1200, new(127, 191, 255));
+        using Image<RgbaVector> image = new(1920, 1200, new RgbaVector(127, 191, 255));
         image.Mutate(ctx => ctx.OilPaint());
     }
 }
diff --git a/tests/ImageSharp.Benchmarks/Processing/Resize.cs b/tests/ImageSharp.Benchmarks/Processing/Resize.cs
index 09673cb96a..356027221c 100644
--- a/tests/ImageSharp.Benchmarks/Processing/Resize.cs
+++ b/tests/ImageSharp.Benchmarks/Processing/Resize.cs
@@ -22,7 +22,7 @@ public abstract class Resize<TPixel>
 
     private SDImage sourceBitmap;
 
-    protected Configuration Configuration { get; } = new Configuration(new JpegConfigurationModule());
+    protected Configuration Configuration { get; } = new(new JpegConfigurationModule());
 
     protected int DestSize { get; private set; }
 
diff --git a/tests/ImageSharp.Tests.ProfilingSandbox/LoadResizeSaveParallelMemoryStress.cs b/tests/ImageSharp.Tests.ProfilingSandbox/LoadResizeSaveParallelMemoryStress.cs
index 248912b14f..6850756dfe 100644
--- a/tests/ImageSharp.Tests.ProfilingSandbox/LoadResizeSaveParallelMemoryStress.cs
+++ b/tests/ImageSharp.Tests.ProfilingSandbox/LoadResizeSaveParallelMemoryStress.cs
@@ -17,7 +17,7 @@ internal class LoadResizeSaveParallelMemoryStress
 {
     private LoadResizeSaveParallelMemoryStress()
     {
-        this.Benchmarks = new LoadResizeSaveStressRunner()
+        this.Benchmarks = new LoadResizeSaveStressRunner
         {
             Filter = JpegKind.Baseline,
         };
@@ -38,7 +38,7 @@ internal class LoadResizeSaveParallelMemoryStress
         Console.WriteLine($"64 bit: {Environment.Is64BitProcess}");
         CommandLineOptions options = args.Length > 0 ? CommandLineOptions.Parse(args) : null;
 
-        var lrs = new LoadResizeSaveParallelMemoryStress();
+        LoadResizeSaveParallelMemoryStress lrs = new();
         if (options != null)
         {
             lrs.Benchmarks.MaxDegreeOfParallelism = options.MaxDegreeOfParallelism;
@@ -108,7 +108,7 @@ internal class LoadResizeSaveParallelMemoryStress
             }
         }
 
-        var stats = new Stats(timer, lrs.Benchmarks.TotalProcessedMegapixels);
+        Stats stats = new(timer, lrs.Benchmarks.TotalProcessedMegapixels);
         Console.WriteLine($"Total Megapixels: {stats.TotalMegapixels}, TotalOomRetries: {UnmanagedMemoryHandle.TotalOomRetries}, TotalOutstandingHandles: {UnmanagedMemoryHandle.TotalOutstandingHandles}, Total Gen2 GC count: {GC.CollectionCount(2)}");
         Console.WriteLine(stats.GetMarkdown());
         if (options?.FileOutput != null)
@@ -203,7 +203,7 @@ internal class LoadResizeSaveParallelMemoryStress
 
         public string GetMarkdown()
         {
-            var bld = new StringBuilder();
+            StringBuilder bld = new();
             bld.AppendLine($"| {nameof(this.TotalSeconds)} | {nameof(this.MegapixelsPerSec)} | {nameof(this.MegapixelsPerSecPerCpu)} |");
             bld.AppendLine(
                 $"| {L(nameof(this.TotalSeconds))} | {L(nameof(this.MegapixelsPerSec))} | {L(nameof(this.MegapixelsPerSecPerCpu))} |");
diff --git a/tests/ImageSharp.Tests.ProfilingSandbox/Program.cs b/tests/ImageSharp.Tests.ProfilingSandbox/Program.cs
index b5c8b70cde..8ba862560b 100644
--- a/tests/ImageSharp.Tests.ProfilingSandbox/Program.cs
+++ b/tests/ImageSharp.Tests.ProfilingSandbox/Program.cs
@@ -52,7 +52,7 @@ public class Program
     {
         Assembly assembly = typeof(System.Runtime.GCSettings).GetTypeInfo().Assembly;
         Console.WriteLine(assembly.Location);
-        string[] assemblyPath = assembly.Location.Split(new[] { '/', '\\' }, StringSplitOptions.RemoveEmptyEntries);
+        string[] assemblyPath = assembly.Location.Split(['/', '\\'], StringSplitOptions.RemoveEmptyEntries);
         int netCoreAppIndex = Array.IndexOf(assemblyPath, "Microsoft.NETCore.App");
         if (netCoreAppIndex > 0 && netCoreAppIndex < assemblyPath.Length - 2)
         {
@@ -64,13 +64,13 @@ public class Program
 
     private static void RunResizeProfilingTest()
     {
-        var test = new ResizeProfilingBenchmarks(new ConsoleOutput());
+        ResizeProfilingBenchmarks test = new(new ConsoleOutput());
         test.ResizeBicubic(4000, 4000);
     }
 
     private static void RunToVector4ProfilingTest()
     {
-        var tests = new PixelOperationsTests.Rgba32_OperationsTests(new ConsoleOutput());
+        PixelOperationsTests.Rgba32_OperationsTests tests = new(new ConsoleOutput());
         tests.Benchmark_ToVector4();
     }
 }
diff --git a/tests/ImageSharp.Tests/Color/ColorTests.CastTo.cs b/tests/ImageSharp.Tests/Color/ColorTests.CastTo.cs
index 4247345c7b..2e2f0d07db 100644
--- a/tests/ImageSharp.Tests/Color/ColorTests.CastTo.cs
+++ b/tests/ImageSharp.Tests/Color/ColorTests.CastTo.cs
@@ -13,10 +13,10 @@ public partial class ColorTests
         [Fact]
         public void Rgba64()
         {
-            var source = new Rgba64(100, 2222, 3333, 4444);
+            Rgba64 source = new(100, 2222, 3333, 4444);
 
             // Act:
-            var color = Color.FromPixel(source);
+            Color color = Color.FromPixel(source);
 
             // Assert:
             Rgba64 data = color.ToPixel<Rgba64>();
@@ -26,10 +26,10 @@ public partial class ColorTests
         [Fact]
         public void Rgba32()
         {
-            var source = new Rgba32(1, 22, 33, 231);
+            Rgba32 source = new(1, 22, 33, 231);
 
             // Act:
-            var color = Color.FromPixel(source);
+            Color color = Color.FromPixel(source);
 
             // Assert:
             Rgba32 data = color.ToPixel<Rgba32>();
@@ -39,10 +39,10 @@ public partial class ColorTests
         [Fact]
         public void Argb32()
         {
-            var source = new Argb32(1, 22, 33, 231);
+            Argb32 source = new(1, 22, 33, 231);
 
             // Act:
-            var color = Color.FromPixel(source);
+            Color color = Color.FromPixel(source);
 
             // Assert:
             Argb32 data = color.ToPixel<Argb32>();
@@ -52,10 +52,10 @@ public partial class ColorTests
         [Fact]
         public void Bgra32()
         {
-            var source = new Bgra32(1, 22, 33, 231);
+            Bgra32 source = new(1, 22, 33, 231);
 
             // Act:
-            var color = Color.FromPixel(source);
+            Color color = Color.FromPixel(source);
 
             // Assert:
             Bgra32 data = color.ToPixel<Bgra32>();
@@ -65,10 +65,10 @@ public partial class ColorTests
         [Fact]
         public void Abgr32()
         {
-            var source = new Abgr32(1, 22, 33, 231);
+            Abgr32 source = new(1, 22, 33, 231);
 
             // Act:
-            var color = Color.FromPixel(source);
+            Color color = Color.FromPixel(source);
 
             // Assert:
             Abgr32 data = color.ToPixel<Abgr32>();
@@ -78,10 +78,10 @@ public partial class ColorTests
         [Fact]
         public void Rgb24()
         {
-            var source = new Rgb24(1, 22, 231);
+            Rgb24 source = new(1, 22, 231);
 
             // Act:
-            var color = Color.FromPixel(source);
+            Color color = Color.FromPixel(source);
 
             // Assert:
             Rgb24 data = color.ToPixel<Rgb24>();
@@ -91,10 +91,10 @@ public partial class ColorTests
         [Fact]
         public void Bgr24()
         {
-            var source = new Bgr24(1, 22, 231);
+            Bgr24 source = new(1, 22, 231);
 
             // Act:
-            var color = Color.FromPixel(source);
+            Color color = Color.FromPixel(source);
 
             // Assert:
             Bgr24 data = color.ToPixel<Bgr24>();
@@ -129,7 +129,7 @@ public partial class ColorTests
             where TPixel : unmanaged, IPixel<TPixel>
         {
             // Act:
-            var color = Color.FromPixel(source);
+            Color color = Color.FromPixel(source);
 
             // Assert:
             TPixel actual = color.ToPixel<TPixel>();
@@ -150,7 +150,7 @@ public partial class ColorTests
             where TPixel2 : unmanaged, IPixel<TPixel2>
         {
             // Act:
-            var color = Color.FromPixel(source);
+            Color color = Color.FromPixel(source);
 
             // Assert:
             TPixel2 actual = color.ToPixel<TPixel2>();
diff --git a/tests/ImageSharp.Tests/Color/ColorTests.cs b/tests/ImageSharp.Tests/Color/ColorTests.cs
index d430df5b44..c482fc9986 100644
--- a/tests/ImageSharp.Tests/Color/ColorTests.cs
+++ b/tests/ImageSharp.Tests/Color/ColorTests.cs
@@ -67,9 +67,9 @@ public partial class ColorTests
     [Theory]
     [InlineData(false)]
     [InlineData(true)]
-    public void ToHex(bool highPrecision)
+    public void ToHexRgba(bool highPrecision)
     {
-        string expected = "ABCD1234";
+        const string expected = "AABBCCDD";
         Color color = Color.ParseHex(expected);
 
         if (highPrecision)
@@ -81,10 +81,27 @@ public partial class ColorTests
         Assert.Equal(expected, actual);
     }
 
+    [Theory]
+    [InlineData(false)]
+    [InlineData(true)]
+    public void ToHexArgb(bool highPrecision)
+    {
+        const string expected = "AABBCCDD";
+        Color color = Color.ParseHex(expected, ColorHexFormat.Argb);
+
+        if (highPrecision)
+        {
+            color = Color.FromPixel(color.ToPixel<RgbaDouble>());
+        }
+
+        string actual = color.ToHex(ColorHexFormat.Argb);
+        Assert.Equal(expected, actual);
+    }
+
     [Fact]
     public void WebSafePalette_IsCorrect()
     {
-        Rgba32[] actualPalette = Color.WebSafePalette.ToArray().Select(c => c.ToPixel<Rgba32>()).ToArray();
+        Rgba32[] actualPalette = [.. Color.WebSafePalette.ToArray().Select(c => c.ToPixel<Rgba32>())];
 
         for (int i = 0; i < ReferencePalette.WebSafeColors.Length; i++)
         {
@@ -95,7 +112,7 @@ public partial class ColorTests
     [Fact]
     public void WernerPalette_IsCorrect()
     {
-        Rgba32[] actualPalette = Color.WernerPalette.ToArray().Select(c => c.ToPixel<Rgba32>()).ToArray();
+        Rgba32[] actualPalette = [.. Color.WernerPalette.ToArray().Select(c => c.ToPixel<Rgba32>())];
 
         for (int i = 0; i < ReferencePalette.WernerColors.Length; i++)
         {
@@ -103,7 +120,7 @@ public partial class ColorTests
         }
     }
 
-    public class FromHex
+    public class FromHexRgba
     {
         [Fact]
         public void ShortHex()
@@ -126,6 +143,23 @@ public partial class ColorTests
             Assert.Equal(new Rgba32(0, 0, 0, 255), actual.ToPixel<Rgba32>());
         }
 
+        [Fact]
+        public void LongHex()
+        {
+            Assert.Equal(new Rgba32(255, 255, 255, 0), Color.ParseHex("#FFFFFF00").ToPixel<Rgba32>());
+            Assert.Equal(new Rgba32(255, 255, 255, 128), Color.ParseHex("#FFFFFF80").ToPixel<Rgba32>());
+        }
+
+        [Fact]
+        public void TryLongHex()
+        {
+            Assert.True(Color.TryParseHex("#FFFFFF00", out Color actual));
+            Assert.Equal(new Rgba32(255, 255, 255, 0), actual.ToPixel<Rgba32>());
+
+            Assert.True(Color.TryParseHex("#FFFFFF80", out actual));
+            Assert.Equal(new Rgba32(255, 255, 255, 128), actual.ToPixel<Rgba32>());
+        }
+
         [Fact]
         public void LeadingPoundIsOptional()
         {
@@ -152,6 +186,72 @@ public partial class ColorTests
         public void FalseOnNull() => Assert.False(Color.TryParseHex(null, out Color _));
     }
 
+    public class FromHexArgb
+    {
+        [Fact]
+        public void ShortHex()
+        {
+            Assert.Equal(new Rgb24(255, 255, 255), Color.ParseHex("#fff", ColorHexFormat.Argb).ToPixel<Rgb24>());
+            Assert.Equal(new Rgb24(255, 255, 255), Color.ParseHex("fff", ColorHexFormat.Argb).ToPixel<Rgb24>());
+            Assert.Equal(new Argb32(0, 0, 255, 0), Color.ParseHex("000f", ColorHexFormat.Argb).ToPixel<Argb32>());
+        }
+
+        [Fact]
+        public void TryShortHex()
+        {
+            Assert.True(Color.TryParseHex("#fff", out Color actual, ColorHexFormat.Argb));
+            Assert.Equal(new Rgb24(255, 255, 255), actual.ToPixel<Rgb24>());
+
+            Assert.True(Color.TryParseHex("fff", out actual, ColorHexFormat.Argb));
+            Assert.Equal(new Rgb24(255, 255, 255), actual.ToPixel<Rgb24>());
+
+            Assert.True(Color.TryParseHex("000f", out actual, ColorHexFormat.Argb));
+            Assert.Equal(new Argb32(0, 0, 255, 0), actual.ToPixel<Argb32>());
+        }
+
+        [Fact]
+        public void LongHex()
+        {
+            Assert.Equal(new Argb32(255, 255, 255, 0), Color.ParseHex("#00FFFFFF", ColorHexFormat.Argb).ToPixel<Argb32>());
+            Assert.Equal(new Argb32(255, 255, 255, 128), Color.ParseHex("#80FFFFFF", ColorHexFormat.Argb).ToPixel<Argb32>());
+        }
+
+        [Fact]
+        public void TryLongHex()
+        {
+            Assert.True(Color.TryParseHex("#00FFFFFF", out Color actual, ColorHexFormat.Argb));
+            Assert.Equal(new Argb32(255, 255, 255, 0), actual.ToPixel<Argb32>());
+
+            Assert.True(Color.TryParseHex("#80FFFFFF", out actual, ColorHexFormat.Argb));
+            Assert.Equal(new Argb32(255, 255, 255, 128), actual.ToPixel<Argb32>());
+        }
+
+        [Fact]
+        public void LeadingPoundIsOptional()
+        {
+            Assert.Equal(new Rgb24(0, 128, 128), Color.ParseHex("#008080", ColorHexFormat.Argb).ToPixel<Rgb24>());
+            Assert.Equal(new Rgb24(0, 128, 128), Color.ParseHex("008080", ColorHexFormat.Argb).ToPixel<Rgb24>());
+        }
+
+        [Fact]
+        public void ThrowsOnEmpty() => Assert.Throws<ArgumentException>(() => Color.ParseHex(string.Empty, ColorHexFormat.Argb));
+
+        [Fact]
+        public void ThrowsOnInvalid() => Assert.Throws<ArgumentException>(() => Color.ParseHex("!", ColorHexFormat.Argb));
+
+        [Fact]
+        public void ThrowsOnNull() => Assert.Throws<ArgumentNullException>(() => Color.ParseHex(null, ColorHexFormat.Argb));
+
+        [Fact]
+        public void FalseOnEmpty() => Assert.False(Color.TryParseHex(string.Empty, out Color _, ColorHexFormat.Argb));
+
+        [Fact]
+        public void FalseOnInvalid() => Assert.False(Color.TryParseHex("!", out Color _, ColorHexFormat.Argb));
+
+        [Fact]
+        public void FalseOnNull() => Assert.False(Color.TryParseHex(null, out Color _, ColorHexFormat.Argb));
+    }
+
     public class FromString
     {
         [Fact]
diff --git a/tests/ImageSharp.Tests/Color/ReferencePalette.cs b/tests/ImageSharp.Tests/Color/ReferencePalette.cs
index 8e26961092..88787afd4f 100644
--- a/tests/ImageSharp.Tests/Color/ReferencePalette.cs
+++ b/tests/ImageSharp.Tests/Color/ReferencePalette.cs
@@ -9,7 +9,7 @@ internal static class ReferencePalette
     /// Gets a collection of named, web safe, colors as defined in the CSS Color Module Level 4.
     /// </summary>
     public static readonly Color[] WebSafeColors =
-    {
+    [
         Color.AliceBlue,
         Color.AntiqueWhite,
         Color.Aqua,
@@ -152,14 +152,14 @@ internal static class ReferencePalette
         Color.WhiteSmoke,
         Color.Yellow,
         Color.YellowGreen
-    };
+    ];
 
     /// <summary>
     /// Gets a collection of colors as defined in the original second edition of Werner’s Nomenclature of Colours 1821.
     /// The hex codes were collected and defined by Nicholas Rougeux <see href="https://www.c82.net/werner"/>
     /// </summary>
     public static readonly Color[] WernerColors =
-    {
+    [
         Color.ParseHex("#f1e9cd"),
         Color.ParseHex("#f2e7cf"),
         Color.ParseHex("#ece6d0"),
@@ -270,10 +270,10 @@ internal static class ReferencePalette
         Color.ParseHex("#9b856b"),
         Color.ParseHex("#766051"),
         Color.ParseHex("#453b32")
-    };
+    ];
 
     public static readonly Dictionary<string, Color> ColorNames =
-        new Dictionary<string, Color>(StringComparer.OrdinalIgnoreCase)
+        new(StringComparer.OrdinalIgnoreCase)
         {
             { nameof(Color.AliceBlue), Color.AliceBlue },
             { nameof(Color.AntiqueWhite), Color.AntiqueWhite },
diff --git a/tests/ImageSharp.Tests/Color/RgbaDouble.cs b/tests/ImageSharp.Tests/Color/RgbaDouble.cs
index 9a751e8791..76fdf365c4 100644
--- a/tests/ImageSharp.Tests/Color/RgbaDouble.cs
+++ b/tests/ImageSharp.Tests/Color/RgbaDouble.cs
@@ -115,7 +115,7 @@ public struct RgbaDouble : IPixel<RgbaDouble>
     public static RgbaDouble FromVector4(Vector4 source)
     {
         source = Numerics.Clamp(source, Vector4.Zero, Vector4.One);
-        return new(source.X, source.Y, source.Z, source.W);
+        return new RgbaDouble(source.X, source.Y, source.Z, source.W);
     }
 
     /// <inheritdoc />
diff --git a/tests/ImageSharp.Tests/ColorProfiles/ApproximateColorProfileComparer.cs b/tests/ImageSharp.Tests/ColorProfiles/ApproximateColorProfileComparer.cs
index 56d495a87a..f4078887c7 100644
--- a/tests/ImageSharp.Tests/ColorProfiles/ApproximateColorProfileComparer.cs
+++ b/tests/ImageSharp.Tests/ColorProfiles/ApproximateColorProfileComparer.cs
@@ -22,7 +22,9 @@ internal readonly struct ApproximateColorProfileComparer :
     IEqualityComparer<Cmyk>,
     IEqualityComparer<Hsl>,
     IEqualityComparer<Hsv>,
-    IEqualityComparer<HunterLab>
+    IEqualityComparer<HunterLab>,
+    IEqualityComparer<Y>,
+    IEqualityComparer<YccK>
 {
     private readonly float epsilon;
 
@@ -58,6 +60,10 @@ internal readonly struct ApproximateColorProfileComparer :
 
     public bool Equals(HunterLab x, HunterLab y) => this.Equals(x.L, y.L) && this.Equals(x.A, y.A) && this.Equals(x.B, y.B);
 
+    public bool Equals(Y x, Y y) => this.Equals(x.L, y.L);
+
+    public bool Equals(YccK x, YccK y) => this.Equals(x.Y, y.Y) && this.Equals(x.Cb, y.Cb) && this.Equals(x.Cr, y.Cr) && this.Equals(x.K, y.K);
+
     public int GetHashCode([DisallowNull] CieLab obj) => obj.GetHashCode();
 
     public int GetHashCode([DisallowNull] CieXyz obj) => obj.GetHashCode();
@@ -84,6 +90,10 @@ internal readonly struct ApproximateColorProfileComparer :
 
     public int GetHashCode([DisallowNull] HunterLab obj) => obj.GetHashCode();
 
+    public int GetHashCode([DisallowNull] Y obj) => obj.GetHashCode();
+
+    public int GetHashCode([DisallowNull] YccK obj) => obj.GetHashCode();
+
     private bool Equals(float x, float y)
     {
         float d = x - y;
diff --git a/tests/ImageSharp.Tests/ColorProfiles/CieLabAndCieLchConversionTests.cs b/tests/ImageSharp.Tests/ColorProfiles/CieLabAndCieLchConversionTests.cs
index 9a894c7760..d6e3738952 100644
--- a/tests/ImageSharp.Tests/ColorProfiles/CieLabAndCieLchConversionTests.cs
+++ b/tests/ImageSharp.Tests/ColorProfiles/CieLabAndCieLchConversionTests.cs
@@ -12,6 +12,7 @@ namespace SixLabors.ImageSharp.Tests.ColorProfiles;
 /// Test data generated using:
 /// <see href="http://www.brucelindbloom.com/index.html?ColorCalculator.html"/>
 /// </remarks>
+[Trait("Color", "Conversion")]
 public class CieLabAndCieLchConversionTests
 {
     private static readonly ApproximateColorProfileComparer Comparer = new(.0001f);
@@ -30,7 +31,7 @@ public class CieLabAndCieLchConversionTests
         // Arrange
         CieLch input = new(l, c, h);
         CieLab expected = new(l2, a, b);
-        ColorConversionOptions options = new() { WhitePoint = KnownIlluminants.D50, TargetWhitePoint = KnownIlluminants.D50 };
+        ColorConversionOptions options = new() { SourceWhitePoint = KnownIlluminants.D50, TargetWhitePoint = KnownIlluminants.D50 };
         ColorProfileConverter converter = new(options);
 
         Span<CieLch> inputSpan = new CieLch[5];
@@ -65,7 +66,7 @@ public class CieLabAndCieLchConversionTests
         // Arrange
         CieLab input = new(l, a, b);
         CieLch expected = new(l2, c, h);
-        ColorConversionOptions options = new() { WhitePoint = KnownIlluminants.D50, TargetWhitePoint = KnownIlluminants.D50 };
+        ColorConversionOptions options = new() { SourceWhitePoint = KnownIlluminants.D50, TargetWhitePoint = KnownIlluminants.D50 };
         ColorProfileConverter converter = new(options);
 
         Span<CieLab> inputSpan = new CieLab[5];
diff --git a/tests/ImageSharp.Tests/ColorProfiles/CieLabAndCieLchuvConversionTests.cs b/tests/ImageSharp.Tests/ColorProfiles/CieLabAndCieLchuvConversionTests.cs
index 4b1b5e1a56..73fa7128fa 100644
--- a/tests/ImageSharp.Tests/ColorProfiles/CieLabAndCieLchuvConversionTests.cs
+++ b/tests/ImageSharp.Tests/ColorProfiles/CieLabAndCieLchuvConversionTests.cs
@@ -24,7 +24,7 @@ public class CieLabAndCieLchuvConversionTests
         // Arrange
         CieLchuv input = new(l, c, h);
         CieLab expected = new(l2, a, b);
-        ColorConversionOptions options = new() { WhitePoint = KnownIlluminants.D65, TargetWhitePoint = KnownIlluminants.D50 };
+        ColorConversionOptions options = new() { SourceWhitePoint = KnownIlluminants.D65, TargetWhitePoint = KnownIlluminants.D50 };
         ColorProfileConverter converter = new(options);
 
         Span<CieLchuv> inputSpan = new CieLchuv[5];
@@ -53,7 +53,7 @@ public class CieLabAndCieLchuvConversionTests
         // Arrange
         CieLab input = new(l, a, b);
         CieLchuv expected = new(l2, c, h);
-        ColorConversionOptions options = new() { WhitePoint = KnownIlluminants.D50, TargetWhitePoint = KnownIlluminants.D65 };
+        ColorConversionOptions options = new() { SourceWhitePoint = KnownIlluminants.D50, TargetWhitePoint = KnownIlluminants.D65 };
         ColorProfileConverter converter = new(options);
 
         Span<CieLab> inputSpan = new CieLab[5];
diff --git a/tests/ImageSharp.Tests/ColorProfiles/CieLabAndCieLuvConversionTests.cs b/tests/ImageSharp.Tests/ColorProfiles/CieLabAndCieLuvConversionTests.cs
index 44756c779a..0846bdda3f 100644
--- a/tests/ImageSharp.Tests/ColorProfiles/CieLabAndCieLuvConversionTests.cs
+++ b/tests/ImageSharp.Tests/ColorProfiles/CieLabAndCieLuvConversionTests.cs
@@ -24,7 +24,7 @@ public class CieLabAndCieLuvConversionTests
         // Arrange
         CieLuv input = new(l, u, v);
         CieLab expected = new(l2, a, b);
-        ColorConversionOptions options = new() { WhitePoint = KnownIlluminants.D65, TargetWhitePoint = KnownIlluminants.D50 };
+        ColorConversionOptions options = new() { SourceWhitePoint = KnownIlluminants.D65, TargetWhitePoint = KnownIlluminants.D50 };
         ColorProfileConverter converter = new(options);
 
         Span<CieLuv> inputSpan = new CieLuv[5];
@@ -53,7 +53,7 @@ public class CieLabAndCieLuvConversionTests
         // Arrange
         CieLab input = new(l, a, b);
         CieLuv expected = new(l2, u, v);
-        ColorConversionOptions options = new() { WhitePoint = KnownIlluminants.D50, TargetWhitePoint = KnownIlluminants.D65 };
+        ColorConversionOptions options = new() { SourceWhitePoint = KnownIlluminants.D50, TargetWhitePoint = KnownIlluminants.D65 };
         ColorProfileConverter converter = new(options);
 
         Span<CieLab> inputSpan = new CieLab[5];
diff --git a/tests/ImageSharp.Tests/ColorProfiles/CieLabAndYCbCrConversionTests.cs b/tests/ImageSharp.Tests/ColorProfiles/CieLabAndYCbCrConversionTests.cs
index 9a29b15398..15677c46f0 100644
--- a/tests/ImageSharp.Tests/ColorProfiles/CieLabAndYCbCrConversionTests.cs
+++ b/tests/ImageSharp.Tests/ColorProfiles/CieLabAndYCbCrConversionTests.cs
@@ -13,8 +13,9 @@ public class CieLabAndYCbCrConversionTests
     private static readonly ApproximateColorProfileComparer Comparer = new(.0002F);
 
     [Theory]
-    [InlineData(0, 128, 128, 0, 0, 0)]
-    [InlineData(87.4179, 133.9763, 247.5308, 55.06287, 82.54838, 23.1697)]
+    [InlineData(1, .5F, .5F, 100, 0, 0)]
+    [InlineData(0, .5F, .5F, 0, 0, 0)]
+    [InlineData(.5F, .5F, .5F, 53.38897F, 0, 0)]
     public void Convert_YCbCr_to_CieLab(float y, float cb, float cr, float l, float a, float b)
     {
         // Arrange
@@ -41,8 +42,9 @@ public class CieLabAndYCbCrConversionTests
     }
 
     [Theory]
-    [InlineData(0, 0, 0, 0, 128, 128)]
-    [InlineData(55.06287, 82.54838, 23.1697, 87.41701, 133.97232, 247.5314)]
+    [InlineData(100, 0, 0, 1, .5F, .5F)]
+    [InlineData(0, 0, 0, 0, .5F, .5F)]
+    [InlineData(53.38897F, 0, 0, .5F, .5F, .5F)]
     public void Convert_CieLab_to_YCbCr(float l, float a, float b, float y, float cb, float cr)
     {
         // Arrange
diff --git a/tests/ImageSharp.Tests/ColorProfiles/CieLabTests.cs b/tests/ImageSharp.Tests/ColorProfiles/CieLabTests.cs
index 3c015259b1..69fabc7508 100644
--- a/tests/ImageSharp.Tests/ColorProfiles/CieLabTests.cs
+++ b/tests/ImageSharp.Tests/ColorProfiles/CieLabTests.cs
@@ -9,6 +9,7 @@ namespace SixLabors.ImageSharp.Tests.ColorProfiles;
 /// <summary>
 /// Tests the <see cref="CieLab"/> struct.
 /// </summary>
+[Trait("Color", "Conversion")]
 public class CieLabTests
 {
     [Fact]
diff --git a/tests/ImageSharp.Tests/ColorProfiles/CieLchAndCieLuvConversionTests.cs b/tests/ImageSharp.Tests/ColorProfiles/CieLchAndCieLuvConversionTests.cs
index 598d4af335..12313281fa 100644
--- a/tests/ImageSharp.Tests/ColorProfiles/CieLchAndCieLuvConversionTests.cs
+++ b/tests/ImageSharp.Tests/ColorProfiles/CieLchAndCieLuvConversionTests.cs
@@ -20,7 +20,7 @@ public class CieLchAndCieLuvConversionTests
         // Arrange
         CieLch input = new(l, c, h);
         CieLuv expected = new(l2, u, v);
-        ColorConversionOptions options = new() { WhitePoint = KnownIlluminants.D50, TargetWhitePoint = KnownIlluminants.D65 };
+        ColorConversionOptions options = new() { SourceWhitePoint = KnownIlluminants.D50, TargetWhitePoint = KnownIlluminants.D65 };
         ColorProfileConverter converter = new(options);
 
         Span<CieLch> inputSpan = new CieLch[5];
@@ -48,7 +48,7 @@ public class CieLchAndCieLuvConversionTests
         // Arrange
         CieLuv input = new(l2, u, v);
         CieLch expected = new(l, c, h);
-        ColorConversionOptions options = new() { WhitePoint = KnownIlluminants.D65, TargetWhitePoint = KnownIlluminants.D50 };
+        ColorConversionOptions options = new() { SourceWhitePoint = KnownIlluminants.D65, TargetWhitePoint = KnownIlluminants.D50 };
         ColorProfileConverter converter = new(options);
 
         Span<CieLuv> inputSpan = new CieLuv[5];
diff --git a/tests/ImageSharp.Tests/ColorProfiles/CieLchuvAndCieLchConversionTests.cs b/tests/ImageSharp.Tests/ColorProfiles/CieLchuvAndCieLchConversionTests.cs
index a3e0b45e0d..857bdb3da1 100644
--- a/tests/ImageSharp.Tests/ColorProfiles/CieLchuvAndCieLchConversionTests.cs
+++ b/tests/ImageSharp.Tests/ColorProfiles/CieLchuvAndCieLchConversionTests.cs
@@ -20,7 +20,7 @@ public class CieLchuvAndCieLchConversionTests
         // Arrange
         CieLch input = new(l2, c2, h2);
         CieLchuv expected = new(l, c, h);
-        ColorConversionOptions options = new() { WhitePoint = KnownIlluminants.D50, TargetWhitePoint = KnownIlluminants.D65 };
+        ColorConversionOptions options = new() { SourceWhitePoint = KnownIlluminants.D50, TargetWhitePoint = KnownIlluminants.D65 };
         ColorProfileConverter converter = new(options);
 
         Span<CieLch> inputSpan = new CieLch[5];
@@ -48,7 +48,7 @@ public class CieLchuvAndCieLchConversionTests
         // Arrange
         CieLchuv input = new(l, c, h);
         CieLch expected = new(l2, c2, h2);
-        ColorConversionOptions options = new() { WhitePoint = KnownIlluminants.D65, TargetWhitePoint = KnownIlluminants.D50 };
+        ColorConversionOptions options = new() { SourceWhitePoint = KnownIlluminants.D65, TargetWhitePoint = KnownIlluminants.D50 };
         ColorProfileConverter converter = new(options);
 
         Span<CieLchuv> inputSpan = new CieLchuv[5];
diff --git a/tests/ImageSharp.Tests/ColorProfiles/CieLchuvAndCieLuvConversionTests.cs b/tests/ImageSharp.Tests/ColorProfiles/CieLchuvAndCieLuvConversionTests.cs
index 465237490d..424cb8cc77 100644
--- a/tests/ImageSharp.Tests/ColorProfiles/CieLchuvAndCieLuvConversionTests.cs
+++ b/tests/ImageSharp.Tests/ColorProfiles/CieLchuvAndCieLuvConversionTests.cs
@@ -12,6 +12,7 @@ namespace SixLabors.ImageSharp.Tests.ColorProfiles;
 /// Test data generated using:
 /// <see href="http://www.brucelindbloom.com/index.html?ColorCalculator.html"/>
 /// </remarks>
+[Trait("Color", "Conversion")]
 public class CieLchuvAndCieLuvConversionTests
 {
     private static readonly ApproximateColorProfileComparer Comparer = new(.0001F);
@@ -30,7 +31,7 @@ public class CieLchuvAndCieLuvConversionTests
         // Arrange
         CieLchuv input = new(l, c, h);
         CieLuv expected = new(l2, u, v);
-        ColorConversionOptions options = new() { WhitePoint = KnownIlluminants.D65, TargetWhitePoint = KnownIlluminants.D65 };
+        ColorConversionOptions options = new() { SourceWhitePoint = KnownIlluminants.D65, TargetWhitePoint = KnownIlluminants.D65 };
         ColorProfileConverter converter = new(options);
 
         Span<CieLchuv> inputSpan = new CieLchuv[5];
@@ -66,7 +67,7 @@ public class CieLchuvAndCieLuvConversionTests
         // Arrange
         CieLuv input = new(l, u, v);
         CieLchuv expected = new(l2, c, h);
-        ColorConversionOptions options = new() { WhitePoint = KnownIlluminants.D65, TargetWhitePoint = KnownIlluminants.D65 };
+        ColorConversionOptions options = new() { SourceWhitePoint = KnownIlluminants.D65, TargetWhitePoint = KnownIlluminants.D65 };
         ColorProfileConverter converter = new(options);
 
         Span<CieLuv> inputSpan = new CieLuv[5];
diff --git a/tests/ImageSharp.Tests/ColorProfiles/CieLchuvAndCmykConversionTests.cs b/tests/ImageSharp.Tests/ColorProfiles/CieLchuvAndCmykConversionTests.cs
index 60ac3da16e..3c8a93ee12 100644
--- a/tests/ImageSharp.Tests/ColorProfiles/CieLchuvAndCmykConversionTests.cs
+++ b/tests/ImageSharp.Tests/ColorProfiles/CieLchuvAndCmykConversionTests.cs
@@ -20,7 +20,7 @@ public class CieLchuvAndCmykConversionTests
         // Arrange
         Cmyk input = new(c2, m, y, k);
         CieLchuv expected = new(l, c, h);
-        ColorConversionOptions options = new() { WhitePoint = KnownIlluminants.D65, TargetWhitePoint = KnownIlluminants.D65 };
+        ColorConversionOptions options = new() { SourceWhitePoint = KnownIlluminants.D65, TargetWhitePoint = KnownIlluminants.D65 };
         ColorProfileConverter converter = new(options);
 
         Span<Cmyk> inputSpan = new Cmyk[5];
@@ -49,7 +49,7 @@ public class CieLchuvAndCmykConversionTests
         // Arrange
         CieLchuv input = new(l, c, h);
         Cmyk expected = new(c2, m, y, k);
-        ColorConversionOptions options = new() { WhitePoint = KnownIlluminants.D65, TargetWhitePoint = KnownIlluminants.D65 };
+        ColorConversionOptions options = new() { SourceWhitePoint = KnownIlluminants.D65, TargetWhitePoint = KnownIlluminants.D65 };
         ColorProfileConverter converter = new(options);
 
         Span<CieLchuv> inputSpan = new CieLchuv[5];
diff --git a/tests/ImageSharp.Tests/ColorProfiles/CieLchuvTests.cs b/tests/ImageSharp.Tests/ColorProfiles/CieLchuvTests.cs
index 0b737cdfca..3fe550a5ba 100644
--- a/tests/ImageSharp.Tests/ColorProfiles/CieLchuvTests.cs
+++ b/tests/ImageSharp.Tests/ColorProfiles/CieLchuvTests.cs
@@ -9,6 +9,7 @@ namespace SixLabors.ImageSharp.Tests.ColorProfiles;
 /// <summary>
 /// Tests the <see cref="CieLchuv"/> struct.
 /// </summary>
+[Trait("Color", "Conversion")]
 public class CieLchuvTests
 {
     [Fact]
diff --git a/tests/ImageSharp.Tests/ColorProfiles/CieLuvAndCieXyyConversionTests.cs b/tests/ImageSharp.Tests/ColorProfiles/CieLuvAndCieXyyConversionTests.cs
index e73edcda7c..08e73a1a71 100644
--- a/tests/ImageSharp.Tests/ColorProfiles/CieLuvAndCieXyyConversionTests.cs
+++ b/tests/ImageSharp.Tests/ColorProfiles/CieLuvAndCieXyyConversionTests.cs
@@ -20,7 +20,7 @@ public class CieLuvAndCieXyyConversionTests
         // Arrange
         CieLuv input = new(l, u, v);
         CieXyy expected = new(x, y, yl);
-        ColorConversionOptions options = new() { WhitePoint = KnownIlluminants.D65, TargetWhitePoint = KnownIlluminants.D65 };
+        ColorConversionOptions options = new() { SourceWhitePoint = KnownIlluminants.D65, TargetWhitePoint = KnownIlluminants.D65 };
         ColorProfileConverter converter = new(options);
 
         Span<CieLuv> inputSpan = new CieLuv[5];
@@ -49,7 +49,7 @@ public class CieLuvAndCieXyyConversionTests
         // Arrange
         CieXyy input = new(x, y, yl);
         CieLuv expected = new(l, u, v);
-        ColorConversionOptions options = new() { WhitePoint = KnownIlluminants.D65, TargetWhitePoint = KnownIlluminants.D65 };
+        ColorConversionOptions options = new() { SourceWhitePoint = KnownIlluminants.D65, TargetWhitePoint = KnownIlluminants.D65 };
         ColorProfileConverter converter = new(options);
 
         Span<CieXyy> inputSpan = new CieXyy[5];
diff --git a/tests/ImageSharp.Tests/ColorProfiles/CieLuvAndHslConversionTests.cs b/tests/ImageSharp.Tests/ColorProfiles/CieLuvAndHslConversionTests.cs
index b178b22b20..bfcd236c75 100644
--- a/tests/ImageSharp.Tests/ColorProfiles/CieLuvAndHslConversionTests.cs
+++ b/tests/ImageSharp.Tests/ColorProfiles/CieLuvAndHslConversionTests.cs
@@ -20,7 +20,7 @@ public class CieLuvAndHslConversionTests
         // Arrange
         CieLuv input = new(l, u, v);
         Hsl expected = new(h, s, l2);
-        ColorConversionOptions options = new() { WhitePoint = KnownIlluminants.D65, TargetWhitePoint = KnownIlluminants.D65 };
+        ColorConversionOptions options = new() { SourceWhitePoint = KnownIlluminants.D65, TargetWhitePoint = KnownIlluminants.D65 };
         ColorProfileConverter converter = new(options);
 
         Span<CieLuv> inputSpan = new CieLuv[5];
@@ -49,7 +49,7 @@ public class CieLuvAndHslConversionTests
         // Arrange
         Hsl input = new(h, s, l2);
         CieLuv expected = new(l, u, v);
-        ColorConversionOptions options = new() { WhitePoint = KnownIlluminants.D65, TargetWhitePoint = KnownIlluminants.D65 };
+        ColorConversionOptions options = new() { SourceWhitePoint = KnownIlluminants.D65, TargetWhitePoint = KnownIlluminants.D65 };
         ColorProfileConverter converter = new(options);
 
         Span<Hsl> inputSpan = new Hsl[5];
diff --git a/tests/ImageSharp.Tests/ColorProfiles/CieLuvAndHsvConversionTests.cs b/tests/ImageSharp.Tests/ColorProfiles/CieLuvAndHsvConversionTests.cs
index 2866093377..8a25f95b7b 100644
--- a/tests/ImageSharp.Tests/ColorProfiles/CieLuvAndHsvConversionTests.cs
+++ b/tests/ImageSharp.Tests/ColorProfiles/CieLuvAndHsvConversionTests.cs
@@ -20,7 +20,7 @@ public class CieLuvAndHsvConversionTests
         // Arrange
         CieLuv input = new(l, u, v);
         Hsv expected = new(h, s, v2);
-        ColorConversionOptions options = new() { WhitePoint = KnownIlluminants.D65, TargetWhitePoint = KnownIlluminants.D65 };
+        ColorConversionOptions options = new() { SourceWhitePoint = KnownIlluminants.D65, TargetWhitePoint = KnownIlluminants.D65 };
         ColorProfileConverter converter = new(options);
 
         Span<CieLuv> inputSpan = new CieLuv[5];
@@ -49,7 +49,7 @@ public class CieLuvAndHsvConversionTests
         // Arrange
         Hsv input = new(h, s, v2);
         CieLuv expected = new(l, u, v);
-        ColorConversionOptions options = new() { WhitePoint = KnownIlluminants.D65, TargetWhitePoint = KnownIlluminants.D65 };
+        ColorConversionOptions options = new() { SourceWhitePoint = KnownIlluminants.D65, TargetWhitePoint = KnownIlluminants.D65 };
         ColorProfileConverter converter = new(options);
 
         Span<Hsv> inputSpan = new Hsv[5];
diff --git a/tests/ImageSharp.Tests/ColorProfiles/CieLuvAndHunterLabConversionTests.cs b/tests/ImageSharp.Tests/ColorProfiles/CieLuvAndHunterLabConversionTests.cs
index 73b605fb62..1c667f6794 100644
--- a/tests/ImageSharp.Tests/ColorProfiles/CieLuvAndHunterLabConversionTests.cs
+++ b/tests/ImageSharp.Tests/ColorProfiles/CieLuvAndHunterLabConversionTests.cs
@@ -20,7 +20,7 @@ public class CieLuvAndHunterLabConversionTests
         // Arrange
         CieLuv input = new(l, u, v);
         HunterLab expected = new(l2, a, b);
-        ColorConversionOptions options = new() { WhitePoint = KnownIlluminants.D65, TargetWhitePoint = KnownIlluminants.D50 };
+        ColorConversionOptions options = new() { SourceWhitePoint = KnownIlluminants.D65, TargetWhitePoint = KnownIlluminants.D50 };
         ColorProfileConverter converter = new(options);
 
         Span<CieLuv> inputSpan = new CieLuv[5];
@@ -49,7 +49,7 @@ public class CieLuvAndHunterLabConversionTests
         // Arrange
         HunterLab input = new(l2, a, b);
         CieLuv expected = new(l, u, v);
-        ColorConversionOptions options = new() { WhitePoint = KnownIlluminants.D50, TargetWhitePoint = KnownIlluminants.D65 };
+        ColorConversionOptions options = new() { SourceWhitePoint = KnownIlluminants.D50, TargetWhitePoint = KnownIlluminants.D65 };
         ColorProfileConverter converter = new(options);
 
         Span<HunterLab> inputSpan = new HunterLab[5];
diff --git a/tests/ImageSharp.Tests/ColorProfiles/CieLuvAndLmsConversionTests.cs b/tests/ImageSharp.Tests/ColorProfiles/CieLuvAndLmsConversionTests.cs
index 812ca44ddc..812b2b61e5 100644
--- a/tests/ImageSharp.Tests/ColorProfiles/CieLuvAndLmsConversionTests.cs
+++ b/tests/ImageSharp.Tests/ColorProfiles/CieLuvAndLmsConversionTests.cs
@@ -20,7 +20,7 @@ public class CieLuvAndLmsConversionTests
         // Arrange
         CieLuv input = new(l, u, v);
         Lms expected = new(l2, m, s);
-        ColorConversionOptions options = new() { WhitePoint = KnownIlluminants.D65, TargetWhitePoint = KnownIlluminants.D65 };
+        ColorConversionOptions options = new() { SourceWhitePoint = KnownIlluminants.D65, TargetWhitePoint = KnownIlluminants.D65 };
         ColorProfileConverter converter = new(options);
 
         Span<CieLuv> inputSpan = new CieLuv[5];
@@ -49,7 +49,7 @@ public class CieLuvAndLmsConversionTests
         // Arrange
         Lms input = new(l2, m, s);
         CieLuv expected = new(l, u, v);
-        ColorConversionOptions options = new() { WhitePoint = KnownIlluminants.D65, TargetWhitePoint = KnownIlluminants.D65 };
+        ColorConversionOptions options = new() { SourceWhitePoint = KnownIlluminants.D65, TargetWhitePoint = KnownIlluminants.D65 };
         ColorProfileConverter converter = new(options);
 
         Span<Lms> inputSpan = new Lms[5];
diff --git a/tests/ImageSharp.Tests/ColorProfiles/CieLuvAndRgbConversionTests.cs b/tests/ImageSharp.Tests/ColorProfiles/CieLuvAndRgbConversionTests.cs
index f1da6e33fd..1af802326e 100644
--- a/tests/ImageSharp.Tests/ColorProfiles/CieLuvAndRgbConversionTests.cs
+++ b/tests/ImageSharp.Tests/ColorProfiles/CieLuvAndRgbConversionTests.cs
@@ -20,7 +20,7 @@ public class CieLuvAndRgbConversionTests
         // Arrange
         CieLuv input = new(l, u, v);
         Rgb expected = new(r, g, b);
-        ColorConversionOptions options = new() { WhitePoint = KnownIlluminants.D65, TargetWhitePoint = KnownIlluminants.D65 };
+        ColorConversionOptions options = new() { SourceWhitePoint = KnownIlluminants.D65, TargetWhitePoint = KnownIlluminants.D65 };
         ColorProfileConverter converter = new(options);
 
         Span<CieLuv> inputSpan = new CieLuv[5];
@@ -49,7 +49,7 @@ public class CieLuvAndRgbConversionTests
         // Arrange
         Rgb input = new(r, g, b);
         CieLuv expected = new(l, u, v);
-        ColorConversionOptions options = new() { WhitePoint = KnownIlluminants.D65, TargetWhitePoint = KnownIlluminants.D65 };
+        ColorConversionOptions options = new() { SourceWhitePoint = KnownIlluminants.D65, TargetWhitePoint = KnownIlluminants.D65 };
         ColorProfileConverter converter = new(options);
 
         Span<Rgb> inputSpan = new Rgb[5];
diff --git a/tests/ImageSharp.Tests/ColorProfiles/CieLuvAndYCbCrConversionTests.cs b/tests/ImageSharp.Tests/ColorProfiles/CieLuvAndYCbCrConversionTests.cs
index fa7e2ece3f..62b276a1f1 100644
--- a/tests/ImageSharp.Tests/ColorProfiles/CieLuvAndYCbCrConversionTests.cs
+++ b/tests/ImageSharp.Tests/ColorProfiles/CieLuvAndYCbCrConversionTests.cs
@@ -13,14 +13,15 @@ public class CieLuvAndYCbCrConversionTests
     private static readonly ApproximateColorProfileComparer Comparer = new(.0002F);
 
     [Theory]
-    [InlineData(0, 0, 0, 0, 128, 128)]
-    [InlineData(36.0555, 93.6901, 10.01514, 71.8283, 119.3174, 193.9839)]
+    [InlineData(100, 0, 0, 1, .5F, .5F)]
+    [InlineData(0, 0, 0, 0, .5F, .5F)]
+    [InlineData(53.38897F, 0, 0, .5F, .5F, .5F)]
     public void Convert_CieLuv_to_YCbCr(float l, float u, float v, float y, float cb, float cr)
     {
         // Arrange
         CieLuv input = new(l, u, v);
         YCbCr expected = new(y, cb, cr);
-        ColorConversionOptions options = new() { WhitePoint = KnownIlluminants.D65, TargetWhitePoint = KnownIlluminants.D65 };
+        ColorConversionOptions options = new() { SourceWhitePoint = KnownIlluminants.D65, TargetWhitePoint = KnownIlluminants.D65 };
         ColorProfileConverter converter = new(options);
 
         Span<CieLuv> inputSpan = new CieLuv[5];
@@ -42,14 +43,15 @@ public class CieLuvAndYCbCrConversionTests
     }
 
     [Theory]
-    [InlineData(0, 128, 128, 0, 0, 0)]
-    [InlineData(71.8283, 119.3174, 193.9839, 36.00565, 93.44593, 10.2234)]
+    [InlineData(1, .5F, .5F, 100, 0, 0)]
+    [InlineData(0, .5F, .5F, 0, 0, 0)]
+    [InlineData(.5F, .5F, .5F, 53.38897F, 0, 0)]
     public void Convert_YCbCr_to_CieLuv(float y, float cb, float cr, float l, float u, float v)
     {
         // Arrange
         YCbCr input = new(y, cb, cr);
         CieLuv expected = new(l, u, v);
-        ColorConversionOptions options = new() { WhitePoint = KnownIlluminants.D65, TargetWhitePoint = KnownIlluminants.D65 };
+        ColorConversionOptions options = new() { SourceWhitePoint = KnownIlluminants.D65, TargetWhitePoint = KnownIlluminants.D65 };
         ColorProfileConverter converter = new(options);
 
         Span<YCbCr> inputSpan = new YCbCr[5];
diff --git a/tests/ImageSharp.Tests/ColorProfiles/CieLuvTests.cs b/tests/ImageSharp.Tests/ColorProfiles/CieLuvTests.cs
index db903a0bf5..173491081d 100644
--- a/tests/ImageSharp.Tests/ColorProfiles/CieLuvTests.cs
+++ b/tests/ImageSharp.Tests/ColorProfiles/CieLuvTests.cs
@@ -9,6 +9,7 @@ namespace SixLabors.ImageSharp.Tests.ColorProfiles;
 /// <summary>
 /// Tests the <see cref="CieLuv"/> struct.
 /// </summary>
+[Trait("Color", "Conversion")]
 public class CieLuvTests
 {
     [Fact]
diff --git a/tests/ImageSharp.Tests/ColorProfiles/CieXyChromaticityCoordinatesTests.cs b/tests/ImageSharp.Tests/ColorProfiles/CieXyChromaticityCoordinatesTests.cs
index a85a08a21e..8bc71f1e18 100644
--- a/tests/ImageSharp.Tests/ColorProfiles/CieXyChromaticityCoordinatesTests.cs
+++ b/tests/ImageSharp.Tests/ColorProfiles/CieXyChromaticityCoordinatesTests.cs
@@ -8,6 +8,7 @@ namespace SixLabors.ImageSharp.Tests.ColorProfiles;
 /// <summary>
 /// Tests the <see cref="CieXyChromaticityCoordinates"/> struct.
 /// </summary>
+[Trait("Color", "Conversion")]
 public class CieXyChromaticityCoordinatesTests
 {
     [Fact]
diff --git a/tests/ImageSharp.Tests/ColorProfiles/CieXyyAndYCbCrConversionTests.cs b/tests/ImageSharp.Tests/ColorProfiles/CieXyyAndYCbCrConversionTests.cs
index 1fe3596036..f9d571e036 100644
--- a/tests/ImageSharp.Tests/ColorProfiles/CieXyyAndYCbCrConversionTests.cs
+++ b/tests/ImageSharp.Tests/ColorProfiles/CieXyyAndYCbCrConversionTests.cs
@@ -13,8 +13,9 @@ public class CieXyyAndYCbCrConversionTests
     private static readonly ApproximateColorProfileComparer Comparer = new(.0002f);
 
     [Theory]
-    [InlineData(0, 0, 0, 0, 128, 128)]
-    [InlineData(0.360555, 0.936901, 0.1001514, 64.0204849, 91.87107, 82.33627)]
+    [InlineData(.34566915F, .358496159F, .99999994F, 1, .5F, .5F)]
+    [InlineData(0, 0, 0, 0, .5F, .5F)]
+    [InlineData(.34566915F, .358496159F, .214041144F, .5F, .5F, .5F)]
     public void Convert_CieXyy_to_YCbCr(float x, float y, float yl, float y2, float cb, float cr)
     {
         // Arrange
@@ -41,8 +42,9 @@ public class CieXyyAndYCbCrConversionTests
     }
 
     [Theory]
-    [InlineData(0, 128, 128, 0, 0, 0)]
-    [InlineData(64.0204849, 91.87107, 82.33627, 0.32114, 0.59787, 0.10976)]
+    [InlineData(1, .5F, .5F, .34566915F, .358496159F, .99999994F)]
+    [InlineData(0, .5F, .5F, 0, 0, 0)]
+    [InlineData(.5F, .5F, .5F, .34566915F, .358496159F, .214041144F)]
     public void Convert_YCbCr_to_CieXyy(float y2, float cb, float cr, float x, float y, float yl)
     {
         // Arrange
diff --git a/tests/ImageSharp.Tests/ColorProfiles/CieXyyTests.cs b/tests/ImageSharp.Tests/ColorProfiles/CieXyyTests.cs
index 245512f8a8..80904c5df1 100644
--- a/tests/ImageSharp.Tests/ColorProfiles/CieXyyTests.cs
+++ b/tests/ImageSharp.Tests/ColorProfiles/CieXyyTests.cs
@@ -9,6 +9,7 @@ namespace SixLabors.ImageSharp.Tests.ColorProfiles;
 /// <summary>
 /// Tests the <see cref="CieXyy"/> struct.
 /// </summary>
+[Trait("Color", "Conversion")]
 public class CieXyyTests
 {
     [Fact]
diff --git a/tests/ImageSharp.Tests/ColorProfiles/CieXyzAndCieLabConversionTest.cs b/tests/ImageSharp.Tests/ColorProfiles/CieXyzAndCieLabConversionTest.cs
index cb4d028895..76fceec413 100644
--- a/tests/ImageSharp.Tests/ColorProfiles/CieXyzAndCieLabConversionTest.cs
+++ b/tests/ImageSharp.Tests/ColorProfiles/CieXyzAndCieLabConversionTest.cs
@@ -12,6 +12,7 @@ namespace SixLabors.ImageSharp.Tests.ColorProfiles;
 /// Test data generated using:
 /// <see href="http://www.brucelindbloom.com/index.html?ColorCalculator.html"/>
 /// </remarks>
+[Trait("Color", "Conversion")]
 public class CieXyzAndCieLabConversionTest
 {
     private static readonly ApproximateColorProfileComparer Comparer = new(.0001f);
@@ -29,7 +30,7 @@ public class CieXyzAndCieLabConversionTest
     {
         // Arrange
         CieLab input = new(l, a, b);
-        ColorConversionOptions options = new() { WhitePoint = KnownIlluminants.D65, TargetWhitePoint = KnownIlluminants.D65 };
+        ColorConversionOptions options = new() { SourceWhitePoint = KnownIlluminants.D65, TargetWhitePoint = KnownIlluminants.D65 };
         ColorProfileConverter converter = new(options);
         CieXyz expected = new(x, y, z);
 
@@ -62,7 +63,7 @@ public class CieXyzAndCieLabConversionTest
     {
         // Arrange
         CieXyz input = new(x, y, z);
-        ColorConversionOptions options = new() { WhitePoint = KnownIlluminants.D65, TargetWhitePoint = KnownIlluminants.D65 };
+        ColorConversionOptions options = new() { SourceWhitePoint = KnownIlluminants.D65, TargetWhitePoint = KnownIlluminants.D65 };
         ColorProfileConverter converter = new(options);
         CieLab expected = new(l, a, b);
 
diff --git a/tests/ImageSharp.Tests/ColorProfiles/CieXyzAndCieLuvConversionTest.cs b/tests/ImageSharp.Tests/ColorProfiles/CieXyzAndCieLuvConversionTest.cs
index 944b990054..b269818ae8 100644
--- a/tests/ImageSharp.Tests/ColorProfiles/CieXyzAndCieLuvConversionTest.cs
+++ b/tests/ImageSharp.Tests/ColorProfiles/CieXyzAndCieLuvConversionTest.cs
@@ -29,7 +29,7 @@ public class CieXyzAndCieLuvConversionTest
         CieXyz input = new(x, y, z);
         CieLuv expected = new(l, u, v);
 
-        ColorConversionOptions options = new() { WhitePoint = KnownIlluminants.D65, TargetWhitePoint = KnownIlluminants.D65 };
+        ColorConversionOptions options = new() { SourceWhitePoint = KnownIlluminants.D65, TargetWhitePoint = KnownIlluminants.D65 };
         ColorProfileConverter converter = new(options);
 
         Span<CieXyz> inputSpan = new CieXyz[5];
@@ -64,7 +64,7 @@ public class CieXyzAndCieLuvConversionTest
         CieLuv input = new(l, u, v);
         CieXyz expected = new(x, y, z);
 
-        ColorConversionOptions options = new() { WhitePoint = KnownIlluminants.D65, TargetWhitePoint = KnownIlluminants.D65 };
+        ColorConversionOptions options = new() { SourceWhitePoint = KnownIlluminants.D65, TargetWhitePoint = KnownIlluminants.D65 };
         ColorProfileConverter converter = new(options);
 
         Span<CieLuv> inputSpan = new CieLuv[5];
diff --git a/tests/ImageSharp.Tests/ColorProfiles/CieXyzAndCieXyyConversionTest.cs b/tests/ImageSharp.Tests/ColorProfiles/CieXyzAndCieXyyConversionTest.cs
index 7b1d0ac781..48bb6c1e16 100644
--- a/tests/ImageSharp.Tests/ColorProfiles/CieXyzAndCieXyyConversionTest.cs
+++ b/tests/ImageSharp.Tests/ColorProfiles/CieXyzAndCieXyyConversionTest.cs
@@ -12,6 +12,7 @@ namespace SixLabors.ImageSharp.Tests.ColorProfiles;
 /// Test data generated using:
 /// <see href="http://www.brucelindbloom.com/index.html?ColorCalculator.html"/>
 /// </remarks>
+[Trait("Color", "Conversion")]
 public class CieXyzAndCieXyyConversionTest
 {
     private static readonly ApproximateColorProfileComparer Comparer = new(.0001F);
diff --git a/tests/ImageSharp.Tests/ColorProfiles/CieXyzAndLmsConversionTest.cs b/tests/ImageSharp.Tests/ColorProfiles/CieXyzAndLmsConversionTest.cs
index 185fcd256c..c7898904da 100644
--- a/tests/ImageSharp.Tests/ColorProfiles/CieXyzAndLmsConversionTest.cs
+++ b/tests/ImageSharp.Tests/ColorProfiles/CieXyzAndLmsConversionTest.cs
@@ -11,6 +11,7 @@ namespace SixLabors.ImageSharp.Tests.ColorProfiles;
 /// <remarks>
 /// Test data generated using original colorful library.
 /// </remarks>
+[Trait("Color", "Conversion")]
 public class CieXyzAndLmsConversionTest
 {
     private static readonly ApproximateColorProfileComparer Comparer = new(.0001f);
diff --git a/tests/ImageSharp.Tests/ColorProfiles/CieXyzAndYCbCrConversionTests.cs b/tests/ImageSharp.Tests/ColorProfiles/CieXyzAndYCbCrConversionTests.cs
index 475673da84..90175a0585 100644
--- a/tests/ImageSharp.Tests/ColorProfiles/CieXyzAndYCbCrConversionTests.cs
+++ b/tests/ImageSharp.Tests/ColorProfiles/CieXyzAndYCbCrConversionTests.cs
@@ -13,8 +13,8 @@ public class CieXyzAndYCbCrConversionTests
     private static readonly ApproximateColorProfileComparer Comparer = new(.0002f);
 
     [Theory]
-    [InlineData(0, 0, 0, 0, 128, 128)]
-    [InlineData(0.360555, 0.936901, 0.1001514, 149.685, 43.52769, 21.23457)]
+    [InlineData(0, 0, 0, 0, .5F, .5F)]
+    [InlineData(.206382737F, .214041144F, .176628917F, .5F, .5F, .5F)]
     public void Convert_CieXyz_to_YCbCr(float x, float y, float z, float y2, float cb, float cr)
     {
         // Arrange
@@ -41,8 +41,8 @@ public class CieXyzAndYCbCrConversionTests
     }
 
     [Theory]
-    [InlineData(0, 128, 128, 0, 0, 0)]
-    [InlineData(149.685, 43.52769, 21.23457, 0.38506496, 0.716878653, 0.0971045)]
+    [InlineData(0, .5F, .5F, 0, 0, 0)]
+    [InlineData(.5F, .5F, .5F, .206382737F, .214041144F, .176628917F)]
     public void Convert_YCbCr_to_CieXyz(float y2, float cb, float cr, float x, float y, float z)
     {
         // Arrange
diff --git a/tests/ImageSharp.Tests/ColorProfiles/CieXyzTests.cs b/tests/ImageSharp.Tests/ColorProfiles/CieXyzTests.cs
index 88138304a8..683b3b6611 100644
--- a/tests/ImageSharp.Tests/ColorProfiles/CieXyzTests.cs
+++ b/tests/ImageSharp.Tests/ColorProfiles/CieXyzTests.cs
@@ -9,6 +9,7 @@ namespace SixLabors.ImageSharp.Tests.ColorProfiles;
 /// <summary>
 /// Tests the <see cref="CieXyz"/> struct.
 /// </summary>
+[Trait("Color", "Conversion")]
 public class CieXyzTests
 {
     [Fact]
diff --git a/tests/ImageSharp.Tests/ColorProfiles/CmykAndYCbCrConversionTests.cs b/tests/ImageSharp.Tests/ColorProfiles/CmykAndYCbCrConversionTests.cs
index 64b47e2b97..3a5fe7c15c 100644
--- a/tests/ImageSharp.Tests/ColorProfiles/CmykAndYCbCrConversionTests.cs
+++ b/tests/ImageSharp.Tests/ColorProfiles/CmykAndYCbCrConversionTests.cs
@@ -13,8 +13,9 @@ public class CmykAndYCbCrConversionTests
     private static readonly ApproximateColorProfileComparer Comparer = new(.0002F);
 
     [Theory]
-    [InlineData(0, 0, 0, 0, 255, 128, 128)]
-    [InlineData(0.360555, 0.1036901, 0.818514, 0.274615, 136.5134, 69.90555, 114.9948)]
+    [InlineData(0, 0, 0, 1, 0, .5F, .5F)]
+    [InlineData(0, 0, 0, 0, 1, .5F, .5F)]
+    [InlineData(0, .8570679F, .49999997F, 0, .439901F, .5339159F, .899500132F)]
     public void Convert_Cmyk_To_YCbCr(float c, float m, float y, float k, float y2, float cb, float cr)
     {
         // Arrange
@@ -41,8 +42,9 @@ public class CmykAndYCbCrConversionTests
     }
 
     [Theory]
-    [InlineData(255, 128, 128, 0, 0, 0, 5.960464E-08)]
-    [InlineData(136.5134, 69.90555, 114.9948, 0.2891567, 0, 0.7951807, 0.3490196)]
+    [InlineData(0, .5F, .5F, 0, 0, 0, 1)]
+    [InlineData(1, .5F, .5F, 0, 0, 0, 0)]
+    [InlineData(.5F, .5F, 1F, 0, .8570679F, .49999997F, 0)]
     public void Convert_YCbCr_To_Cmyk(float y2, float cb, float cr, float c, float m, float y, float k)
     {
         // Arrange
diff --git a/tests/ImageSharp.Tests/ColorProfiles/CmykTests.cs b/tests/ImageSharp.Tests/ColorProfiles/CmykTests.cs
index e2044a75d0..22b7a7f70c 100644
--- a/tests/ImageSharp.Tests/ColorProfiles/CmykTests.cs
+++ b/tests/ImageSharp.Tests/ColorProfiles/CmykTests.cs
@@ -9,6 +9,7 @@ namespace SixLabors.ImageSharp.Tests.ColorProfiles;
 /// <summary>
 /// Tests the <see cref="Cmyk"/> struct.
 /// </summary>
+[Trait("Color", "Conversion")]
 public class CmykTests
 {
     [Fact]
diff --git a/tests/ImageSharp.Tests/ColorProfiles/ColorProfileConverterChomaticAdaptationTests.cs b/tests/ImageSharp.Tests/ColorProfiles/ColorProfileConverterChomaticAdaptationTests.cs
index a90e5b9e86..525220d8e0 100644
--- a/tests/ImageSharp.Tests/ColorProfiles/ColorProfileConverterChomaticAdaptationTests.cs
+++ b/tests/ImageSharp.Tests/ColorProfiles/ColorProfileConverterChomaticAdaptationTests.cs
@@ -26,7 +26,7 @@ public class ColorProfileConverterChomaticAdaptationTests
         Rgb expected = new(r2, g2, b2);
         ColorConversionOptions options = new()
         {
-            RgbWorkingSpace = KnownRgbWorkingSpaces.WideGamutRgb,
+            SourceRgbWorkingSpace = KnownRgbWorkingSpaces.WideGamutRgb,
             TargetRgbWorkingSpace = KnownRgbWorkingSpaces.SRgb
         };
         ColorProfileConverter converter = new(options);
@@ -49,7 +49,7 @@ public class ColorProfileConverterChomaticAdaptationTests
         Rgb expected = new(r2, g2, b2);
         ColorConversionOptions options = new()
         {
-            RgbWorkingSpace = KnownRgbWorkingSpaces.SRgb,
+            SourceRgbWorkingSpace = KnownRgbWorkingSpaces.SRgb,
             TargetRgbWorkingSpace = KnownRgbWorkingSpaces.WideGamutRgb
         };
         ColorProfileConverter converter = new(options);
@@ -71,7 +71,7 @@ public class ColorProfileConverterChomaticAdaptationTests
         CieLab expected = new(l2, a2, b2);
         ColorConversionOptions options = new()
         {
-            WhitePoint = KnownIlluminants.D65,
+            SourceWhitePoint = KnownIlluminants.D65,
             TargetWhitePoint = KnownIlluminants.D50
         };
         ColorProfileConverter converter = new(options);
@@ -93,7 +93,7 @@ public class ColorProfileConverterChomaticAdaptationTests
         CieXyz expected = new(x2, y2, z2);
         ColorConversionOptions options = new()
         {
-            WhitePoint = KnownIlluminants.D65,
+            SourceWhitePoint = KnownIlluminants.D65,
             TargetWhitePoint = KnownIlluminants.D50,
             AdaptationMatrix = KnownChromaticAdaptationMatrices.Bradford
         };
@@ -117,7 +117,7 @@ public class ColorProfileConverterChomaticAdaptationTests
         CieXyz expected = new(x2, y2, z2);
         ColorConversionOptions options = new()
         {
-            WhitePoint = KnownIlluminants.D65,
+            SourceWhitePoint = KnownIlluminants.D65,
             TargetWhitePoint = KnownIlluminants.D50,
             AdaptationMatrix = KnownChromaticAdaptationMatrices.XyzScaling
         };
@@ -141,7 +141,7 @@ public class ColorProfileConverterChomaticAdaptationTests
         HunterLab expected = new(l2, a2, b2);
         ColorConversionOptions options = new()
         {
-            WhitePoint = KnownIlluminants.D65,
+            SourceWhitePoint = KnownIlluminants.D65,
             TargetWhitePoint = KnownIlluminants.D50,
         };
 
@@ -164,7 +164,7 @@ public class ColorProfileConverterChomaticAdaptationTests
         CieLchuv expected = new(l2, c2, h2);
         ColorConversionOptions options = new()
         {
-            WhitePoint = KnownIlluminants.D65,
+            SourceWhitePoint = KnownIlluminants.D65,
             TargetWhitePoint = KnownIlluminants.D50,
             AdaptationMatrix = KnownChromaticAdaptationMatrices.XyzScaling
         };
@@ -187,7 +187,7 @@ public class ColorProfileConverterChomaticAdaptationTests
         CieLch expected = new(l2, c2, h2);
         ColorConversionOptions options = new()
         {
-            WhitePoint = KnownIlluminants.D65,
+            SourceWhitePoint = KnownIlluminants.D65,
             TargetWhitePoint = KnownIlluminants.D50,
             AdaptationMatrix = KnownChromaticAdaptationMatrices.XyzScaling
         };
diff --git a/tests/ImageSharp.Tests/ColorProfiles/HslTests.cs b/tests/ImageSharp.Tests/ColorProfiles/HslTests.cs
index d18e65117e..6697cbfde2 100644
--- a/tests/ImageSharp.Tests/ColorProfiles/HslTests.cs
+++ b/tests/ImageSharp.Tests/ColorProfiles/HslTests.cs
@@ -9,6 +9,7 @@ namespace SixLabors.ImageSharp.Tests.ColorProfiles;
 /// <summary>
 /// Tests the <see cref="Hsl"/> struct.
 /// </summary>
+[Trait("Color", "Conversion")]
 public class HslTests
 {
     [Fact]
diff --git a/tests/ImageSharp.Tests/ColorProfiles/HsvTests.cs b/tests/ImageSharp.Tests/ColorProfiles/HsvTests.cs
index 46f58b18e2..dd71fcd3ff 100644
--- a/tests/ImageSharp.Tests/ColorProfiles/HsvTests.cs
+++ b/tests/ImageSharp.Tests/ColorProfiles/HsvTests.cs
@@ -9,6 +9,7 @@ namespace SixLabors.ImageSharp.Tests.ColorProfiles;
 /// <summary>
 /// Tests the <see cref="Hsv"/> struct.
 /// </summary>
+[Trait("Color", "Conversion")]
 public class HsvTests
 {
     [Fact]
diff --git a/tests/ImageSharp.Tests/ColorProfiles/HunterLabTests.cs b/tests/ImageSharp.Tests/ColorProfiles/HunterLabTests.cs
index 5fbdd0788f..af06b3c91f 100644
--- a/tests/ImageSharp.Tests/ColorProfiles/HunterLabTests.cs
+++ b/tests/ImageSharp.Tests/ColorProfiles/HunterLabTests.cs
@@ -9,6 +9,7 @@ namespace SixLabors.ImageSharp.Tests.ColorProfiles;
 /// <summary>
 /// Tests the <see cref="HunterLab"/> struct.
 /// </summary>
+[Trait("Color", "Conversion")]
 public class HunterLabTests
 {
     [Fact]
diff --git a/tests/ImageSharp.Tests/ColorProfiles/Icc/Calculators/ClutCalculatorTests.cs b/tests/ImageSharp.Tests/ColorProfiles/Icc/Calculators/ClutCalculatorTests.cs
new file mode 100644
index 0000000000..249e7f4ed1
--- /dev/null
+++ b/tests/ImageSharp.Tests/ColorProfiles/Icc/Calculators/ClutCalculatorTests.cs
@@ -0,0 +1,27 @@
+// Copyright (c) Six Labors.
+// Licensed under the Six Labors Split License.
+
+using System.Numerics;
+using SixLabors.ImageSharp.ColorProfiles.Icc.Calculators;
+using SixLabors.ImageSharp.Metadata.Profiles.Icc;
+using SixLabors.ImageSharp.Tests.TestDataIcc.Conversion;
+
+namespace SixLabors.ImageSharp.Tests.ColorProfiles.Icc.Calculators;
+
+/// <summary>
+/// Tests ICC <see cref="ClutCalculator"/>
+/// </summary>
+[Trait("Color", "Conversion")]
+public class ClutCalculatorTests
+{
+    [Theory]
+    [MemberData(nameof(IccConversionDataClut.ClutConversionTestData), MemberType = typeof(IccConversionDataClut))]
+    internal void ClutCalculator_WithClut_ReturnsResult(IccClut lut, Vector4 input, Vector4 expected)
+    {
+        ClutCalculator calculator = new(lut);
+
+        Vector4 result = calculator.Calculate(input);
+
+        VectorAssert.Equal(expected, result, 4);
+    }
+}
diff --git a/tests/ImageSharp.Tests/ColorProfiles/Icc/Calculators/CurveCalculatorTests.cs b/tests/ImageSharp.Tests/ColorProfiles/Icc/Calculators/CurveCalculatorTests.cs
new file mode 100644
index 0000000000..8f48277d6c
--- /dev/null
+++ b/tests/ImageSharp.Tests/ColorProfiles/Icc/Calculators/CurveCalculatorTests.cs
@@ -0,0 +1,26 @@
+// Copyright (c) Six Labors.
+// Licensed under the Six Labors Split License.
+
+using SixLabors.ImageSharp.ColorProfiles.Conversion.Icc;
+using SixLabors.ImageSharp.Metadata.Profiles.Icc;
+using SixLabors.ImageSharp.Tests.TestDataIcc.Conversion;
+
+namespace SixLabors.ImageSharp.Tests.ColorProfiles.Icc.Calculators;
+
+/// <summary>
+/// Tests ICC <see cref="CurveCalculator"/>
+/// </summary>
+[Trait("Color", "Conversion")]
+public class CurveCalculatorTests
+{
+    [Theory]
+    [MemberData(nameof(IccConversionDataTrc.CurveConversionTestData), MemberType = typeof(IccConversionDataTrc))]
+    internal void CurveCalculator_WithCurveEntry_ReturnsResult(IccCurveTagDataEntry curve, bool inverted, float input, float expected)
+    {
+        CurveCalculator calculator = new(curve, inverted);
+
+        float result = calculator.Calculate(input);
+
+        Assert.Equal(expected, result, 4f);
+    }
+}
diff --git a/tests/ImageSharp.Tests/ColorProfiles/Icc/Calculators/LutABCalculatorTests.cs b/tests/ImageSharp.Tests/ColorProfiles/Icc/Calculators/LutABCalculatorTests.cs
new file mode 100644
index 0000000000..de2b4f5fae
--- /dev/null
+++ b/tests/ImageSharp.Tests/ColorProfiles/Icc/Calculators/LutABCalculatorTests.cs
@@ -0,0 +1,38 @@
+// Copyright (c) Six Labors.
+// Licensed under the Six Labors Split License.
+
+using System.Numerics;
+using SixLabors.ImageSharp.ColorProfiles.Conversion.Icc;
+using SixLabors.ImageSharp.Metadata.Profiles.Icc;
+using SixLabors.ImageSharp.Tests.TestDataIcc.Conversion;
+
+namespace SixLabors.ImageSharp.Tests.ColorProfiles.Icc.Calculators;
+
+/// <summary>
+/// Tests ICC <see cref="LutABCalculator"/>
+/// </summary>
+[Trait("Color", "Conversion")]
+public class LutABCalculatorTests
+{
+    [Theory]
+    [MemberData(nameof(IccConversionDataLutAB.LutAToBConversionTestData), MemberType = typeof(IccConversionDataLutAB))]
+    internal void LutABCalculator_WithLutAToB_ReturnsResult(IccLutAToBTagDataEntry lut, Vector4 input, Vector4 expected)
+    {
+        LutABCalculator calculator = new(lut);
+
+        Vector4 result = calculator.Calculate(input);
+
+        VectorAssert.Equal(expected, result, 4);
+    }
+
+    [Theory]
+    [MemberData(nameof(IccConversionDataLutAB.LutBToAConversionTestData), MemberType = typeof(IccConversionDataLutAB))]
+    internal void LutABCalculator_WithLutBToA_ReturnsResult(IccLutBToATagDataEntry lut, Vector4 input, Vector4 expected)
+    {
+        LutABCalculator calculator = new(lut);
+
+        Vector4 result = calculator.Calculate(input);
+
+        VectorAssert.Equal(expected, result, 4);
+    }
+}
diff --git a/tests/ImageSharp.Tests/ColorProfiles/Icc/Calculators/LutCalculatorTests.cs b/tests/ImageSharp.Tests/ColorProfiles/Icc/Calculators/LutCalculatorTests.cs
new file mode 100644
index 0000000000..6cc77247a9
--- /dev/null
+++ b/tests/ImageSharp.Tests/ColorProfiles/Icc/Calculators/LutCalculatorTests.cs
@@ -0,0 +1,25 @@
+// Copyright (c) Six Labors.
+// Licensed under the Six Labors Split License.
+
+using SixLabors.ImageSharp.ColorProfiles.Icc.Calculators;
+using SixLabors.ImageSharp.Tests.TestDataIcc.Conversion;
+
+namespace SixLabors.ImageSharp.Tests.ColorProfiles.Icc.Calculators;
+
+/// <summary>
+/// Tests ICC <see cref="LutCalculator"/>
+/// </summary>
+[Trait("Color", "Conversion")]
+public class LutCalculatorTests
+{
+    [Theory]
+    [MemberData(nameof(IccConversionDataLut.LutConversionTestData), MemberType = typeof(IccConversionDataLut))]
+    internal void LutCalculator_WithLut_ReturnsResult(float[] lut, bool inverted, float input, float expected)
+    {
+        LutCalculator calculator = new(lut, inverted);
+
+        float result = calculator.Calculate(input);
+
+        Assert.Equal(expected, result, 4f);
+    }
+}
diff --git a/tests/ImageSharp.Tests/ColorProfiles/Icc/Calculators/LutEntryCalculatorTests.cs b/tests/ImageSharp.Tests/ColorProfiles/Icc/Calculators/LutEntryCalculatorTests.cs
new file mode 100644
index 0000000000..14f1386eb8
--- /dev/null
+++ b/tests/ImageSharp.Tests/ColorProfiles/Icc/Calculators/LutEntryCalculatorTests.cs
@@ -0,0 +1,38 @@
+// Copyright (c) Six Labors.
+// Licensed under the Six Labors Split License.
+
+using System.Numerics;
+using SixLabors.ImageSharp.ColorProfiles.Icc.Calculators;
+using SixLabors.ImageSharp.Metadata.Profiles.Icc;
+using SixLabors.ImageSharp.Tests.TestDataIcc.Conversion;
+
+namespace SixLabors.ImageSharp.Tests.ColorProfiles.Icc.Calculators;
+
+/// <summary>
+/// Tests ICC <see cref="LutEntryCalculator"/>
+/// </summary>
+[Trait("Color", "Conversion")]
+public class LutEntryCalculatorTests
+{
+    [Theory]
+    [MemberData(nameof(IccConversionDataLutEntry.Lut8ConversionTestData), MemberType = typeof(IccConversionDataLutEntry))]
+    internal void LutEntryCalculator_WithLut8_ReturnsResult(IccLut8TagDataEntry lut, Vector4 input, Vector4 expected)
+    {
+        LutEntryCalculator calculator = new(lut);
+
+        Vector4 result = calculator.Calculate(input);
+
+        VectorAssert.Equal(expected, result, 4);
+    }
+
+    [Theory]
+    [MemberData(nameof(IccConversionDataLutEntry.Lut16ConversionTestData), MemberType = typeof(IccConversionDataLutEntry))]
+    internal void LutEntryCalculator_WithLut16_ReturnsResult(IccLut16TagDataEntry lut, Vector4 input, Vector4 expected)
+    {
+        LutEntryCalculator calculator = new(lut);
+
+        Vector4 result = calculator.Calculate(input);
+
+        VectorAssert.Equal(expected, result, 4);
+    }
+}
diff --git a/tests/ImageSharp.Tests/ColorProfiles/Icc/Calculators/MatrixCalculatorTests.cs b/tests/ImageSharp.Tests/ColorProfiles/Icc/Calculators/MatrixCalculatorTests.cs
new file mode 100644
index 0000000000..f56bf5873e
--- /dev/null
+++ b/tests/ImageSharp.Tests/ColorProfiles/Icc/Calculators/MatrixCalculatorTests.cs
@@ -0,0 +1,26 @@
+// Copyright (c) Six Labors.
+// Licensed under the Six Labors Split License.
+
+using System.Numerics;
+using SixLabors.ImageSharp.ColorProfiles.Icc.Calculators;
+using SixLabors.ImageSharp.Tests.TestDataIcc.Conversion;
+
+namespace SixLabors.ImageSharp.Tests.ColorProfiles.Icc.Calculators;
+
+/// <summary>
+/// Tests ICC <see cref="MatrixCalculator"/>
+/// </summary>
+[Trait("Color", "Conversion")]
+public class MatrixCalculatorTests
+{
+    [Theory]
+    [MemberData(nameof(IccConversionDataMatrix.MatrixConversionTestData), MemberType = typeof(IccConversionDataMatrix))]
+    internal void MatrixCalculator_WithMatrix_ReturnsResult(Matrix4x4 matrix2D, Vector3 matrix1D, Vector4 input, Vector4 expected)
+    {
+        MatrixCalculator calculator = new(matrix2D, matrix1D);
+
+        Vector4 result = calculator.Calculate(input);
+
+        VectorAssert.Equal(expected, result, 4);
+    }
+}
diff --git a/tests/ImageSharp.Tests/ColorProfiles/Icc/Calculators/ParametricCurveCalculatorTests.cs b/tests/ImageSharp.Tests/ColorProfiles/Icc/Calculators/ParametricCurveCalculatorTests.cs
new file mode 100644
index 0000000000..aac3f42c9b
--- /dev/null
+++ b/tests/ImageSharp.Tests/ColorProfiles/Icc/Calculators/ParametricCurveCalculatorTests.cs
@@ -0,0 +1,26 @@
+// Copyright (c) Six Labors.
+// Licensed under the Six Labors Split License.
+
+using SixLabors.ImageSharp.ColorProfiles.Icc.Calculators;
+using SixLabors.ImageSharp.Metadata.Profiles.Icc;
+using SixLabors.ImageSharp.Tests.TestDataIcc.Conversion;
+
+namespace SixLabors.ImageSharp.Tests.ColorProfiles.Icc.Calculators;
+
+/// <summary>
+/// Tests ICC <see cref="ParametricCurveCalculator"/>
+/// </summary>
+[Trait("Color", "Conversion")]
+public class ParametricCurveCalculatorTests
+{
+    [Theory]
+    [MemberData(nameof(IccConversionDataTrc.ParametricCurveConversionTestData), MemberType = typeof(IccConversionDataTrc))]
+    internal void ParametricCurveCalculator_WithCurveEntry_ReturnsResult(IccParametricCurveTagDataEntry curve, bool inverted, float input, float expected)
+    {
+        ParametricCurveCalculator calculator = new(curve, inverted);
+
+        float result = calculator.Calculate(input);
+
+        Assert.Equal(expected, result, 4f);
+    }
+}
diff --git a/tests/ImageSharp.Tests/ColorProfiles/Icc/Calculators/TrcCalculatorTests.cs b/tests/ImageSharp.Tests/ColorProfiles/Icc/Calculators/TrcCalculatorTests.cs
new file mode 100644
index 0000000000..65f02c3fb7
--- /dev/null
+++ b/tests/ImageSharp.Tests/ColorProfiles/Icc/Calculators/TrcCalculatorTests.cs
@@ -0,0 +1,27 @@
+// Copyright (c) Six Labors.
+// Licensed under the Six Labors Split License.
+
+using System.Numerics;
+using SixLabors.ImageSharp.ColorProfiles.Icc.Calculators;
+using SixLabors.ImageSharp.Metadata.Profiles.Icc;
+using SixLabors.ImageSharp.Tests.TestDataIcc.Conversion;
+
+namespace SixLabors.ImageSharp.Tests.ColorProfiles.Icc.Calculators;
+
+/// <summary>
+/// Tests ICC <see cref="TrcCalculator"/>
+/// </summary>
+[Trait("Color", "Conversion")]
+public class TrcCalculatorTests
+{
+    [Theory]
+    [MemberData(nameof(IccConversionDataTrc.TrcArrayConversionTestData), MemberType = typeof(IccConversionDataTrc))]
+    internal void TrcCalculator_WithCurvesArray_ReturnsResult(IccTagDataEntry[] entries, bool inverted, Vector4 input, Vector4 expected)
+    {
+        TrcCalculator calculator = new(entries, inverted);
+
+        Vector4 result = calculator.Calculate(input);
+
+        VectorAssert.Equal(expected, result, 4);
+    }
+}
diff --git a/tests/ImageSharp.Tests/ColorProfiles/Icc/ColorProfileConverterTests.Icc.cs b/tests/ImageSharp.Tests/ColorProfiles/Icc/ColorProfileConverterTests.Icc.cs
new file mode 100644
index 0000000000..6c56dc682d
--- /dev/null
+++ b/tests/ImageSharp.Tests/ColorProfiles/Icc/ColorProfileConverterTests.Icc.cs
@@ -0,0 +1,263 @@
+// Copyright (c) Six Labors.
+// Licensed under the Six Labors Split License.
+
+using System.Numerics;
+using SixLabors.ImageSharp.ColorProfiles;
+using SixLabors.ImageSharp.Metadata.Profiles.Icc;
+using Wacton.Unicolour;
+using Wacton.Unicolour.Icc;
+using Xunit.Abstractions;
+using Rgb = SixLabors.ImageSharp.ColorProfiles.Rgb;
+
+namespace SixLabors.ImageSharp.Tests.ColorProfiles.Icc;
+
+public class ColorProfileConverterTests(ITestOutputHelper testOutputHelper)
+{
+    // for 3-channel spaces, 4th item is ignored
+    private static readonly List<float[]> Inputs =
+    [
+        [0, 0, 0, 0],
+        [1, 0, 0, 0],
+        [0, 1, 0, 0],
+        [0, 0, 1, 0],
+        [0, 0, 0, 1],
+        [1, 1, 1, 1],
+        [0.5f, 0.5f, 0.5f, 0.5f],
+        [0.199678659f, 0.67982769f, 0.805381715f, 0.982666492f], // requires clipping before source is PCS adjusted for Fogra39 -> sRGBv2
+        [0.776568174f, 0.961630166f, 0.31032759f, 0.895294666f], // requires clipping after target is PCS adjusted for Fogra39 -> sRGBv2
+        [GetNormalizedRandomValue(), GetNormalizedRandomValue(), GetNormalizedRandomValue(), GetNormalizedRandomValue()]
+    ];
+
+    [Theory]
+    [InlineData(TestIccProfiles.Fogra39, TestIccProfiles.Fogra39)] // CMYK -> LAB -> CMYK (commonly used v2 profiles)
+    [InlineData(TestIccProfiles.Fogra39, TestIccProfiles.Swop2006)] // CMYK -> LAB -> CMYK (commonly used v2 profiles)
+    [InlineData(TestIccProfiles.Swop2006, TestIccProfiles.Fogra39)] // CMYK -> LAB -> CMYK (commonly used v2 profiles)
+    [InlineData(TestIccProfiles.Swop2006, TestIccProfiles.Swop2006)] // CMYK -> LAB -> CMYK (commonly used v2 profiles)
+    [InlineData(TestIccProfiles.Fogra39, TestIccProfiles.JapanColor2003)] // CMYK -> LAB -> CMYK (different bit depth v2 LUTs, 8-bit vs 16-bit)
+    [InlineData(TestIccProfiles.JapanColor2011, TestIccProfiles.Fogra39)] // CMYK -> LAB -> CMYK (different LUT versions, v2 vs v4)
+    [InlineData(TestIccProfiles.Fogra39, TestIccProfiles.Cgats21)] // CMYK -> LAB -> RGB (different LUT versions, v2 vs v4)
+    [InlineData(TestIccProfiles.Fogra39, TestIccProfiles.StandardRgbV4)] // RGB -> LAB -> CMYK (different LUT versions, v4 vs v2)
+    [InlineData(TestIccProfiles.StandardRgbV4, TestIccProfiles.Fogra39)] // RGB -> LAB -> XYZ -> RGB (different LUT elements, B-Matrix-M-CLUT-A vs B-Matrix-M)
+    [InlineData(TestIccProfiles.StandardRgbV4, TestIccProfiles.RommRgb)] // RGB -> XYZ -> LAB -> RGB (different LUT elements, B-Matrix-M vs B-Matrix-M-CLUT-A)
+    [InlineData(TestIccProfiles.RommRgb, TestIccProfiles.StandardRgbV4)] // CMYK -> LAB -> CMYK (different bit depth v2 LUTs, 16-bit vs 8-bit)
+    [InlineData(TestIccProfiles.Fogra39, TestIccProfiles.StandardRgbV2, 0.0005)] // CMYK -> LAB -> XYZ -> RGB (different LUT tags, A2B vs TRC) --- tolerance slightly higher due to difference in inverse curve implementation
+    [InlineData(TestIccProfiles.StandardRgbV2, TestIccProfiles.Fogra39)] // RGB -> XYZ -> LAB -> CMYK (different LUT tags, TRC vs A2B)
+    public void CanConvertIccProfiles(string sourceProfile, string targetProfile, double tolerance = 0.00005)
+    {
+        List<Vector4> actual = Inputs.ConvertAll(input => GetActualTargetValues(input, sourceProfile, targetProfile));
+        AssertConversion(sourceProfile, targetProfile, actual, tolerance, testOutputHelper);
+    }
+
+    [Theory]
+    [InlineData(TestIccProfiles.Fogra39, TestIccProfiles.Fogra39)] // CMYK -> LAB -> CMYK (commonly used v2 profiles)
+    [InlineData(TestIccProfiles.Fogra39, TestIccProfiles.Swop2006)] // CMYK -> LAB -> CMYK (commonly used v2 profiles)
+    [InlineData(TestIccProfiles.Swop2006, TestIccProfiles.Fogra39)] // CMYK -> LAB -> CMYK (commonly used v2 profiles)
+    [InlineData(TestIccProfiles.Swop2006, TestIccProfiles.Swop2006)] // CMYK -> LAB -> CMYK (commonly used v2 profiles)
+    [InlineData(TestIccProfiles.Fogra39, TestIccProfiles.JapanColor2003)] // CMYK -> LAB -> CMYK (different bit depth v2 LUTs, 8-bit vs 16-bit)
+    [InlineData(TestIccProfiles.JapanColor2011, TestIccProfiles.Fogra39)] // CMYK -> LAB -> CMYK (different LUT versions, v2 vs v4)
+    [InlineData(TestIccProfiles.Fogra39, TestIccProfiles.Cgats21)] // CMYK -> LAB -> RGB (different LUT versions, v2 vs v4)
+    [InlineData(TestIccProfiles.Fogra39, TestIccProfiles.StandardRgbV4)] // RGB -> LAB -> CMYK (different LUT versions, v4 vs v2)
+    [InlineData(TestIccProfiles.StandardRgbV4, TestIccProfiles.Fogra39)] // RGB -> LAB -> XYZ -> RGB (different LUT elements, B-Matrix-M-CLUT-A vs B-Matrix-M)
+    [InlineData(TestIccProfiles.StandardRgbV4, TestIccProfiles.RommRgb)] // RGB -> XYZ -> LAB -> RGB (different LUT elements, B-Matrix-M vs B-Matrix-M-CLUT-A)
+    [InlineData(TestIccProfiles.RommRgb, TestIccProfiles.StandardRgbV4)] // CMYK -> LAB -> CMYK (different bit depth v2 LUTs, 16-bit vs 8-bit)
+    [InlineData(TestIccProfiles.Fogra39, TestIccProfiles.StandardRgbV2, 0.0005)] // CMYK -> LAB -> XYZ -> RGB (different LUT tags, A2B vs TRC) --- tolerance slightly higher due to difference in inverse curve implementation
+    [InlineData(TestIccProfiles.StandardRgbV2, TestIccProfiles.Fogra39)] // RGB -> XYZ -> LAB -> CMYK (different LUT tags, TRC vs A2B)
+    [InlineData(TestIccProfiles.Issue129, TestIccProfiles.StandardRgbV4)] // CMYK -> LAB -> -> XYZ -> RGB
+    public void CanBulkConvertIccProfiles(string sourceProfile, string targetProfile, double tolerance = 0.00005)
+    {
+        List<Vector4> actual = GetBulkActualTargetValues(Inputs, sourceProfile, targetProfile);
+        AssertConversion(sourceProfile, targetProfile, actual, tolerance, testOutputHelper);
+    }
+
+    private static void AssertConversion(string sourceProfile, string targetProfile, List<Vector4> actual, double tolerance, ITestOutputHelper testOutputHelper)
+    {
+        List<double[]> expected = Inputs.ConvertAll(input => GetExpectedTargetValues(sourceProfile, targetProfile, input, testOutputHelper));
+        Assert.Equal(expected.Count, actual.Count);
+
+        for (int i = 0; i < expected.Count; i++)
+        {
+            Log(testOutputHelper, Inputs[i], expected[i], actual[i]);
+            for (int j = 0; j < expected[i].Length; j++)
+            {
+                Assert.Equal(expected[i][j], actual[i][j], tolerance);
+            }
+        }
+    }
+
+    private static double[] GetExpectedTargetValues(string sourceProfile, string targetProfile, float[] input, ITestOutputHelper testOutputHelper)
+    {
+        Wacton.Unicolour.Configuration sourceConfig = TestIccProfiles.GetUnicolourConfiguration(sourceProfile);
+        Wacton.Unicolour.Configuration targetConfig = TestIccProfiles.GetUnicolourConfiguration(targetProfile);
+
+        if (sourceConfig.Icc.Error != null || targetConfig.Icc.Error != null)
+        {
+            Assert.Fail("Unicolour does not support the ICC profile - test values will need to be calculated manually");
+        }
+
+        /* This is a hack to trick Unicolour to work in the same way as ImageSharp.
+         * ImageSharp bypasses PCS adjustment for v2 perceptual intent if source and target both need it
+         * as they both share the same understanding of what the PCS is (see ColorProfileConverterExtensionsIcc.GetTargetPcsWithPerceptualAdjustment)
+         * Unicolour does not support a direct profile-to-profile conversion so will always perform PCS adjustment for v2 perceptual intent.
+         * However, PCS adjustment clips negative XYZ values, causing those particular values in Unicolour and ImageSharp to diverge.
+         * It's unclear to me if there's a fundamental correct answer here.
+         *
+         * There are two obvious ways to keep Unicolour and ImageSharp values aligned:
+         * 1. Make ImageSharp always perform PCS adjustment, clipping negative XYZ values during the process - but creates a lot more calculations
+         * 2. Make Unicolour stop performing PCS adjustment, allowing negative XYZ values during conversion
+         *
+         * Option 2 is implemented by modifying the profiles so they claim to be v4 profiles
+         * since v4 perceptual profiles do not apply PCS adjustment.
+         */
+        bool isSourcePerceptualV2 = sourceConfig.Icc.Intent == Intent.Perceptual && sourceConfig.Icc.Profile!.Header.ProfileVersion.Major == 2;
+        bool isTargetPerceptualV2 = targetConfig.Icc.Intent == Intent.Perceptual && targetConfig.Icc.Profile!.Header.ProfileVersion.Major == 2;
+        if (isSourcePerceptualV2 && isTargetPerceptualV2)
+        {
+            sourceConfig = GetUnicolourConfigAsV4Header(sourceConfig);
+            targetConfig = GetUnicolourConfigAsV4Header(targetConfig);
+        }
+
+        Channels channels = new([.. input.Select(value => (double)value)]);
+        Unicolour source = new(sourceConfig, channels);
+        Unicolour target = source.ConvertToConfiguration(targetConfig);
+        if (target.Icc.Error != null)
+        {
+            testOutputHelper.WriteLine($"Error during Unicolour ICC conversion of supported profile: {target.Icc.Error}");
+        }
+
+        return target.Icc.Values;
+    }
+
+    private static Wacton.Unicolour.Configuration GetUnicolourConfigAsV4Header(Wacton.Unicolour.Configuration config)
+    {
+        string profilePath = config.Icc.Profile!.FileInfo.FullName;
+        string modifiedFilename = $"{Path.GetFileNameWithoutExtension(profilePath)}_modified.icc";
+        string modifiedProfile = Path.Combine(Path.GetDirectoryName(profilePath)!, modifiedFilename);
+
+        Wacton.Unicolour.Configuration modifiedConfig;
+        if (!TestIccProfiles.HasUnicolourConfiguration(modifiedProfile))
+        {
+            byte[] bytes = File.ReadAllBytes(profilePath);
+            bytes[8] = 4; // byte 8 of profile is major version
+            File.WriteAllBytes(modifiedProfile, bytes);
+            modifiedConfig = TestIccProfiles.GetUnicolourConfiguration(modifiedProfile);
+            File.Delete(modifiedProfile);
+        }
+        else
+        {
+            modifiedConfig = TestIccProfiles.GetUnicolourConfiguration(modifiedProfile);
+        }
+
+        return modifiedConfig;
+    }
+
+    private static Vector4 GetActualTargetValues(float[] input, string sourceProfile, string targetProfile)
+    {
+        ColorProfileConverter converter = new(new ColorConversionOptions
+        {
+            SourceIccProfile = TestIccProfiles.GetProfile(sourceProfile),
+            TargetIccProfile = TestIccProfiles.GetProfile(targetProfile)
+        });
+
+        IccColorSpaceType sourceDataSpace = converter.Options.SourceIccProfile!.Header.DataColorSpace;
+        IccColorSpaceType targetDataSpace = converter.Options.TargetIccProfile!.Header.DataColorSpace;
+        return sourceDataSpace switch
+        {
+            IccColorSpaceType.Cmyk when targetDataSpace == IccColorSpaceType.Cmyk
+                => converter.Convert<Cmyk, Cmyk>(new Cmyk(new Vector4(input))).ToScaledVector4(),
+            IccColorSpaceType.Cmyk when targetDataSpace == IccColorSpaceType.Rgb
+                => converter.Convert<Cmyk, Rgb>(new Cmyk(new Vector4(input))).ToScaledVector4(),
+            IccColorSpaceType.Rgb when targetDataSpace == IccColorSpaceType.Cmyk
+                => converter.Convert<Rgb, Cmyk>(new Rgb(new Vector3(input))).ToScaledVector4(),
+            IccColorSpaceType.Rgb when targetDataSpace == IccColorSpaceType.Rgb
+                => converter.Convert<Rgb, Rgb>(new Rgb(new Vector3(input))).ToScaledVector4(),
+            _ => throw new NotSupportedException($"Unsupported ICC profile data color space conversion: {sourceDataSpace} -> {targetDataSpace}")
+        };
+    }
+
+    private static List<Vector4> GetBulkActualTargetValues(List<float[]> inputs, string sourceProfile, string targetProfile)
+    {
+        ColorProfileConverter converter = new(new ColorConversionOptions
+        {
+            SourceIccProfile = TestIccProfiles.GetProfile(sourceProfile),
+            TargetIccProfile = TestIccProfiles.GetProfile(targetProfile)
+        });
+
+        IccColorSpaceType sourceDataSpace = converter.Options.SourceIccProfile!.Header.DataColorSpace;
+        IccColorSpaceType targetDataSpace = converter.Options.TargetIccProfile!.Header.DataColorSpace;
+
+        switch (sourceDataSpace)
+        {
+            case IccColorSpaceType.Cmyk:
+            {
+                Span<Cmyk> inputSpan = inputs.Select(x => new Cmyk(new Vector4(x))).ToArray();
+
+                switch (targetDataSpace)
+                {
+                    case IccColorSpaceType.Cmyk:
+                    {
+                        Span<Cmyk> outputSpan = stackalloc Cmyk[inputs.Count];
+                        converter.Convert<Cmyk, Cmyk>(inputSpan, outputSpan);
+                        return [.. outputSpan.ToArray().Select(x => x.ToScaledVector4())];
+                    }
+
+                    case IccColorSpaceType.Rgb:
+                    {
+                        Span<Rgb> outputSpan = stackalloc Rgb[inputs.Count];
+                        converter.Convert<Cmyk, Rgb>(inputSpan, outputSpan);
+                        return [.. outputSpan.ToArray().Select(x => x.ToScaledVector4())];
+                    }
+
+                    default:
+                        throw new NotSupportedException($"Unsupported ICC profile data color space conversion: {sourceDataSpace} -> {targetDataSpace}");
+                }
+            }
+
+            case IccColorSpaceType.Rgb:
+            {
+                Span<Rgb> inputSpan = inputs.Select(x => new Rgb(new Vector3(x))).ToArray();
+
+                switch (targetDataSpace)
+                {
+                    case IccColorSpaceType.Cmyk:
+                    {
+                        Span<Cmyk> outputSpan = stackalloc Cmyk[inputs.Count];
+                        converter.Convert<Rgb, Cmyk>(inputSpan, outputSpan);
+                        return [.. outputSpan.ToArray().Select(x => x.ToScaledVector4())];
+                    }
+
+                    case IccColorSpaceType.Rgb:
+                    {
+                        Span<Rgb> outputSpan = stackalloc Rgb[inputs.Count];
+                        converter.Convert<Rgb, Rgb>(inputSpan, outputSpan);
+                        return [.. outputSpan.ToArray().Select(x => x.ToScaledVector4())];
+                    }
+
+                    default:
+                        throw new NotSupportedException($"Unsupported ICC profile data color space conversion: {sourceDataSpace} -> {targetDataSpace}");
+                }
+            }
+
+            default:
+                throw new NotSupportedException($"Unsupported ICC profile data color space conversion: {sourceDataSpace} -> {targetDataSpace}");
+        }
+    }
+
+    private static float GetNormalizedRandomValue()
+    {
+        // Generate a random value between 0 (inclusive) and 1 (exclusive).
+        double value = Random.Shared.NextDouble();
+
+        // If the random value is exactly 0, return 0F to ensure inclusivity at the lower bound.
+        // For non-zero values, add a small increment (0.0000001F) to ensure the range
+        // is inclusive at the upper bound while retaining precision.
+        // Clamp the result between 0 and 1 to ensure it does not exceed the bounds.
+        return value == 0 ? 0F : Math.Clamp((float)value + 0.0000001F, 0, 1);
+    }
+
+    private static void Log(ITestOutputHelper testOutputHelper, float[] input, double[] expected, Vector4 actual)
+    {
+        string inputText = string.Join(", ", input);
+        string expectedText = string.Join(", ", expected.Select(x => $"{x:f8}"));
+        testOutputHelper.WriteLine($"Input {inputText} · Expected output {expectedText} · Actual output {actual}");
+    }
+}
diff --git a/tests/ImageSharp.Tests/ColorProfiles/Icc/TestIccProfiles.cs b/tests/ImageSharp.Tests/ColorProfiles/Icc/TestIccProfiles.cs
new file mode 100644
index 0000000000..eec27fcd76
--- /dev/null
+++ b/tests/ImageSharp.Tests/ColorProfiles/Icc/TestIccProfiles.cs
@@ -0,0 +1,74 @@
+// Copyright (c) Six Labors.
+// Licensed under the Six Labors Split License.
+
+using System.Collections.Concurrent;
+using SixLabors.ImageSharp.Metadata.Profiles.Icc;
+using Wacton.Unicolour;
+using Wacton.Unicolour.Icc;
+
+namespace SixLabors.ImageSharp.Tests.ColorProfiles.Icc;
+
+internal static class TestIccProfiles
+{
+    private static readonly ConcurrentDictionary<string, IccProfile> ProfileCache = new();
+    private static readonly ConcurrentDictionary<string, Wacton.Unicolour.Configuration> UnicolourConfigurationCache = new();
+
+    /// <summary>
+    /// v2 CMYK -> LAB, output, lut16
+    /// </summary>
+    public const string Fogra39 = "Coated_Fogra39L_VIGC_300.icc";
+
+    /// <summary>
+    /// v2 CMYK -> LAB, output, lut16
+    /// </summary>
+    public const string Swop2006 = "SWOP2006_Coated5v2.icc";
+
+    /// <summary>
+    /// v2 CMYK -> LAB, output, lut8 (A2B tags)
+    /// </summary>
+    public const string JapanColor2011 = "JapanColor2011Coated.icc";
+
+    /// <summary>
+    /// v2 CMYK -> LAB, output, lut8 (B2A tags)
+    /// </summary>
+    public const string JapanColor2003 = "JapanColor2003WebCoated.icc";
+
+    /// <summary>
+    /// v4 CMYK -> LAB, output, lutAToB: B-CLUT-A
+    /// </summary>
+    public const string Cgats21 = "CGATS21_CRPC7.icc";
+
+    /// <summary>
+    /// v4 RGB -> XYZ, colorspace, lutAToB: B-Matrix-M [only intent 0]
+    /// </summary>
+    public const string RommRgb = "ISO22028-2_ROMM-RGB.icc";
+
+    /// <summary>
+    /// v4 RGB -> LAB, colorspace, lutAToB: B-Matrix-M-CLUT-A [only intent 0 & 1]
+    /// </summary>
+    public const string StandardRgbV4 = "sRGB_v4_ICC_preference.icc";
+
+    /// <summary>
+    /// v2 CMYK -> LAB, output
+    /// </summary>
+    public const string Issue129 = "issue-129.icc";
+
+    /// <summary>
+    /// v2 RGB -> XYZ, display, TRCs
+    /// </summary>
+    public const string StandardRgbV2 = "sRGB2014.icc";
+
+    public static IccProfile GetProfile(string file)
+        => ProfileCache.GetOrAdd(file, f => new IccProfile(File.ReadAllBytes(GetFullPath(f))));
+
+    public static Wacton.Unicolour.Configuration GetUnicolourConfiguration(string file)
+        => UnicolourConfigurationCache.GetOrAdd(
+            file,
+            f => new Wacton.Unicolour.Configuration(iccConfig: new IccConfiguration(GetFullPath(f), Intent.Unspecified, f)));
+
+    public static bool HasUnicolourConfiguration(string file)
+        => UnicolourConfigurationCache.ContainsKey(file);
+
+    private static string GetFullPath(string file)
+        => Path.GetFullPath(Path.Combine(".", "TestDataIcc", "Profiles", file));
+}
diff --git a/tests/ImageSharp.Tests/ColorProfiles/LmsTests.cs b/tests/ImageSharp.Tests/ColorProfiles/LmsTests.cs
index 138fd544da..395b547fdb 100644
--- a/tests/ImageSharp.Tests/ColorProfiles/LmsTests.cs
+++ b/tests/ImageSharp.Tests/ColorProfiles/LmsTests.cs
@@ -9,6 +9,7 @@ namespace SixLabors.ImageSharp.Tests.ColorProfiles;
 /// <summary>
 /// Tests the <see cref="Lms"/> struct.
 /// </summary>
+[Trait("Color", "Conversion")]
 public class LmsTests
 {
     [Fact]
diff --git a/tests/ImageSharp.Tests/ColorProfiles/RbgAndYConversionTests.cs b/tests/ImageSharp.Tests/ColorProfiles/RbgAndYConversionTests.cs
new file mode 100644
index 0000000000..017ba78d0b
--- /dev/null
+++ b/tests/ImageSharp.Tests/ColorProfiles/RbgAndYConversionTests.cs
@@ -0,0 +1,84 @@
+// Copyright (c) Six Labors.
+// Licensed under the Six Labors Split License.
+
+using SixLabors.ImageSharp.ColorProfiles;
+
+namespace SixLabors.ImageSharp.Tests.ColorProfiles;
+
+/// <summary>
+/// Tests <see cref="Rgb"/>-<see cref="Y"/> conversions.
+/// </summary>
+/// <remarks>
+/// Test data generated mathematically
+/// </remarks>
+public class RbgAndYConversionTests
+{
+    private static readonly ApproximateColorProfileComparer Comparer = new(.001F);
+
+    [Theory]
+    [InlineData(0F, 0F, 0F, 0F)]
+    [InlineData(0.5F, 0.5F, 0.5F, 0.5F)]
+    [InlineData(1F, 1F, 1F, 1F)]
+    public void Convert_Rgb_To_Y_BT601(float r, float g, float b, float y)
+    {
+        ColorConversionOptions options = new()
+        {
+            YCbCrTransform = KnownYCbCrMatrices.BT601
+        };
+
+        Convert_Rgb_To_Y_Core(r, g, b, y, options);
+    }
+
+    [Theory]
+    [InlineData(0F, 0F, 0F, 0F)]
+    [InlineData(0.5F, 0.5F, 0.5F, 0.5F)]
+    [InlineData(1F, 1F, 1F, 1F)]
+    public void Convert_Rgb_To_Y_BT709(float r, float g, float b, float y)
+    {
+        ColorConversionOptions options = new()
+        {
+            YCbCrTransform = KnownYCbCrMatrices.BT709
+        };
+
+        Convert_Rgb_To_Y_Core(r, g, b, y, options);
+    }
+
+    [Theory]
+    [InlineData(0F, 0F, 0F, 0F)]
+    [InlineData(0.5F, 0.5F, 0.5F, 0.49999997F)]
+    [InlineData(1F, 1F, 1F, 0.99999994F)]
+    public void Convert_Rgb_To_Y_BT2020(float r, float g, float b, float y)
+    {
+        ColorConversionOptions options = new()
+        {
+            YCbCrTransform = KnownYCbCrMatrices.BT2020
+        };
+
+        Convert_Rgb_To_Y_Core(r, g, b, y, options);
+    }
+
+    private static void Convert_Rgb_To_Y_Core(float r, float g, float b, float y, ColorConversionOptions options)
+    {
+        // Arrange
+        Rgb input = new(r, g, b);
+        Y expected = new(y);
+        ColorProfileConverter converter = new(options);
+
+        Span<Rgb> inputSpan = new Rgb[5];
+        inputSpan.Fill(input);
+
+        Span<Y> actualSpan = new Y[5];
+
+        // Act
+        Y actual = converter.Convert<Rgb, Y>(input);
+        converter.Convert<Rgb, Y>(inputSpan, actualSpan);
+
+        // Assert
+        Assert.Equal(expected, actual, Comparer);
+
+        for (int i = 0; i < actualSpan.Length; i++)
+        {
+            Assert.Equal(expected, actualSpan[i], Comparer);
+        }
+    }
+}
diff --git a/tests/ImageSharp.Tests/ColorProfiles/RgbAndCieXyzConversionTest.cs b/tests/ImageSharp.Tests/ColorProfiles/RgbAndCieXyzConversionTest.cs
index c10aa2c3c5..7b48089c7c 100644
--- a/tests/ImageSharp.Tests/ColorProfiles/RgbAndCieXyzConversionTest.cs
+++ b/tests/ImageSharp.Tests/ColorProfiles/RgbAndCieXyzConversionTest.cs
@@ -27,7 +27,7 @@ public class RgbAndCieXyzConversionTest
     {
         // Arrange
         CieXyz input = new(x, y, z);
-        ColorConversionOptions options = new() { WhitePoint = KnownIlluminants.D50, TargetRgbWorkingSpace = KnownRgbWorkingSpaces.SRgb };
+        ColorConversionOptions options = new() { SourceWhitePoint = KnownIlluminants.D50, TargetRgbWorkingSpace = KnownRgbWorkingSpaces.SRgb };
         ColorProfileConverter converter = new(options);
         Rgb expected = new(r, g, b);
 
@@ -60,7 +60,7 @@ public class RgbAndCieXyzConversionTest
     {
         // Arrange
         CieXyz input = new(x, y, z);
-        ColorConversionOptions options = new() { WhitePoint = KnownIlluminants.D65, TargetRgbWorkingSpace = KnownRgbWorkingSpaces.SRgb };
+        ColorConversionOptions options = new() { SourceWhitePoint = KnownIlluminants.D65, TargetRgbWorkingSpace = KnownRgbWorkingSpaces.SRgb };
         ColorProfileConverter converter = new(options);
         Rgb expected = new(r, g, b);
 
@@ -93,7 +93,7 @@ public class RgbAndCieXyzConversionTest
     {
         // Arrange
         Rgb input = new(r, g, b);
-        ColorConversionOptions options = new() { TargetWhitePoint = KnownIlluminants.D50, RgbWorkingSpace = KnownRgbWorkingSpaces.SRgb };
+        ColorConversionOptions options = new() { TargetWhitePoint = KnownIlluminants.D50, SourceRgbWorkingSpace = KnownRgbWorkingSpaces.SRgb };
         ColorProfileConverter converter = new(options);
         CieXyz expected = new(x, y, z);
 
@@ -126,7 +126,7 @@ public class RgbAndCieXyzConversionTest
     {
         // Arrange
         Rgb input = new(r, g, b);
-        ColorConversionOptions options = new() { TargetWhitePoint = KnownIlluminants.D65, RgbWorkingSpace = KnownRgbWorkingSpaces.SRgb };
+        ColorConversionOptions options = new() { TargetWhitePoint = KnownIlluminants.D65, SourceRgbWorkingSpace = KnownRgbWorkingSpaces.SRgb };
         ColorProfileConverter converter = new(options);
         CieXyz expected = new(x, y, z);
 
diff --git a/tests/ImageSharp.Tests/ColorProfiles/RgbAndCmykConversionTest.cs b/tests/ImageSharp.Tests/ColorProfiles/RgbAndCmykConversionTest.cs
index 4f4ecb70be..bd35fb7751 100644
--- a/tests/ImageSharp.Tests/ColorProfiles/RgbAndCmykConversionTest.cs
+++ b/tests/ImageSharp.Tests/ColorProfiles/RgbAndCmykConversionTest.cs
@@ -13,6 +13,7 @@ namespace SixLabors.ImageSharp.Tests.ColorProfiles;
 /// <see href="http://www.colorhexa.com"/>
 /// <see href="http://www.rapidtables.com/convert/color/cmyk-to-rgb.htm"/>
 /// </remarks>
+[Trait("Color", "Conversion")]
 public class RgbAndCmykConversionTest
 {
     private static readonly ApproximateColorProfileComparer Comparer = new(.0001F);
diff --git a/tests/ImageSharp.Tests/ColorProfiles/RgbAndHslConversionTest.cs b/tests/ImageSharp.Tests/ColorProfiles/RgbAndHslConversionTest.cs
index 0dc95628b9..e5874c3d13 100644
--- a/tests/ImageSharp.Tests/ColorProfiles/RgbAndHslConversionTest.cs
+++ b/tests/ImageSharp.Tests/ColorProfiles/RgbAndHslConversionTest.cs
@@ -13,6 +13,7 @@ namespace SixLabors.ImageSharp.Tests.ColorProfiles;
 /// <see href="http://www.colorhexa.com"/>
 /// <see href="http://www.rapidtables.com/convert/color/hsl-to-rgb"/>
 /// </remarks>
+[Trait("Color", "Conversion")]
 public class RgbAndHslConversionTest
 {
     private static readonly ApproximateColorProfileComparer Comparer = new(.0001f);
diff --git a/tests/ImageSharp.Tests/ColorProfiles/RgbAndHsvConversionTest.cs b/tests/ImageSharp.Tests/ColorProfiles/RgbAndHsvConversionTest.cs
index b89b576b6c..4a685abe5f 100644
--- a/tests/ImageSharp.Tests/ColorProfiles/RgbAndHsvConversionTest.cs
+++ b/tests/ImageSharp.Tests/ColorProfiles/RgbAndHsvConversionTest.cs
@@ -12,6 +12,7 @@ namespace SixLabors.ImageSharp.Tests.ColorProfiles;
 /// Test data generated using:
 /// <see href="http://www.colorhexa.com"/>
 /// </remarks>
+[Trait("Color", "Conversion")]
 public class RgbAndHsvConversionTest
 {
     private static readonly ApproximateColorProfileComparer Comparer = new(.0001f);
diff --git a/tests/ImageSharp.Tests/ColorProfiles/RgbAndYCbCrConversionTest.cs b/tests/ImageSharp.Tests/ColorProfiles/RgbAndYCbCrConversionTest.cs
index 91f7fc08ee..ede8226e40 100644
--- a/tests/ImageSharp.Tests/ColorProfiles/RgbAndYCbCrConversionTest.cs
+++ b/tests/ImageSharp.Tests/ColorProfiles/RgbAndYCbCrConversionTest.cs
@@ -16,9 +16,9 @@ public class RgbAndYCbCrConversionTest
     private static readonly ApproximateColorProfileComparer Comparer = new(.001F);
 
     [Theory]
-    [InlineData(255, 128, 128, 1, 1, 1)]
-    [InlineData(0, 128, 128, 0, 0, 0)]
-    [InlineData(128, 128, 128, 0.502, 0.502, 0.502)]
+    [InlineData(1, .5F, .5F, 1, 1, 1)]
+    [InlineData(0, .5F, .5F, 0, 0, 0)]
+    [InlineData(.5F, .5F, .5F, .5F, .5F, .5F)]
     public void Convert_YCbCr_To_Rgb(float y, float cb, float cr, float r, float g, float b)
     {
         // Arrange
@@ -45,10 +45,9 @@ public class RgbAndYCbCrConversionTest
     }
 
     [Theory]
-    [InlineData(0, 0, 0, 0, 128, 128)]
-    [InlineData(1, 1, 1, 255, 128, 128)]
-    [InlineData(0.5, 0.5, 0.5, 127.5, 128, 128)]
-    [InlineData(1, 0, 0, 76.245, 84.972, 255)]
+    [InlineData(1, 1, 1, 1, .5F, .5F)]
+    [InlineData(0, 0, 0, 0, .5F, .5F)]
+    [InlineData(.5F, .5F, .5F, .5F, .5F, .5F)]
     public void Convert_Rgb_To_YCbCr(float r, float g, float b, float y, float cb, float cr)
     {
         // Arrange
diff --git a/tests/ImageSharp.Tests/ColorProfiles/RgbAndYccKConversionTests.cs b/tests/ImageSharp.Tests/ColorProfiles/RgbAndYccKConversionTests.cs
new file mode 100644
index 0000000000..78f424cc28
--- /dev/null
+++ b/tests/ImageSharp.Tests/ColorProfiles/RgbAndYccKConversionTests.cs
@@ -0,0 +1,80 @@
+// Copyright (c) Six Labors.
+// Licensed under the Six Labors Split License.
+
+using SixLabors.ImageSharp.ColorProfiles;
+
+namespace SixLabors.ImageSharp.Tests.ColorProfiles;
+
+/// <summary>
+/// Tests <see cref="Rgb"/>-<see cref="YccK"/> conversions.
+/// </summary>
+/// <remarks>
+/// Test data generated mathematically
+/// </remarks>
+public class RgbAndYccKConversionTests
+{
+    private static readonly ApproximateColorProfileComparer Comparer = new(.001F);
+
+    [Theory]
+    [InlineData(1, .5F, .5F, 0, 1, 1, 1)]
+    [InlineData(0, .5F, .5F, 1, 0, 0, 0)]
+    [InlineData(.5F, .5F, .5F, 0, .5F, .5F, .5F)]
+    public void Convert_YccK_To_Rgb(float y, float cb, float cr, float k, float r, float g, float b)
+    {
+        // Arrange
+        YccK input = new(y, cb, cr, k);
+        Rgb expected = new(r, g, b);
+        ColorProfileConverter converter = new();
+
+        Span<YccK> inputSpan = new YccK[5];
+        inputSpan.Fill(input);
+
+        Span<Rgb> actualSpan = new Rgb[5];
+
+        // Act
+        Rgb actual = converter.Convert<YccK, Rgb>(input);
+        converter.Convert<YccK, Rgb>(inputSpan, actualSpan);
+
+        // Assert
+        Assert.Equal(expected, actual, Comparer);
+
+        for (int i = 0; i < actualSpan.Length; i++)
+        {
+            Assert.Equal(expected, actualSpan[i], Comparer);
+        }
+    }
+
+    [Theory]
+    [InlineData(1, 1, 1, 1, .5F, .5F, 0)]
+    [InlineData(0, 0, 0, 0, .5F, .5F, 1)]
+    [InlineData(.5F, .5F, .5F, 1, .5F, .5F, .5F)]
+    public void Convert_Rgb_To_YccK(float r, float g, float b, float y, float cb, float cr, float k)
+    {
+        // Multiple YccK representations can decode to the same RGB value.
+        // For example, (Y=1.0, Cb=0.5, Cr=0.5, K=0.5) and (Y=0.5, Cb=0.5, Cr=0.5, K=0.0) both yield RGB (0.5, 0.5, 0.5).
+        // This is expected because YccK is not a unique encoding — K modulates RGB after YCbCr decoding.
+        // Round-tripping RGB -> YccK -> RGB is stable, but YccK -> RGB -> YccK is not injective.
+
+        // Arrange
+        Rgb input = new(r, g, b);
+        YccK expected = new(y, cb, cr, k);
+        ColorProfileConverter converter = new();
+
+        Span<Rgb> inputSpan = new Rgb[5];
+        inputSpan.Fill(input);
+
+        Span<YccK> actualSpan = new YccK[5];
+
+        // Act
+        YccK actual = converter.Convert<Rgb, YccK>(input);
+        converter.Convert<Rgb, YccK>(inputSpan, actualSpan);
+
+        // Assert
+        Assert.Equal(expected, actual, Comparer);
+
+        for (int i = 0; i < actualSpan.Length; i++)
+        {
+            Assert.Equal(expected, actualSpan[i], Comparer);
+        }
+    }
+}
diff --git a/tests/ImageSharp.Tests/ColorProfiles/RgbTests.cs b/tests/ImageSharp.Tests/ColorProfiles/RgbTests.cs
index 7e4d4ee0e7..707b3e2a7d 100644
--- a/tests/ImageSharp.Tests/ColorProfiles/RgbTests.cs
+++ b/tests/ImageSharp.Tests/ColorProfiles/RgbTests.cs
@@ -10,6 +10,7 @@ namespace SixLabors.ImageSharp.Tests.ColorProfiles;
 /// <summary>
 /// Tests the <see cref="Rgb"/> struct.
 /// </summary>
+[Trait("Color", "Conversion")]
 public class RgbTests
 {
     [Fact]
diff --git a/tests/ImageSharp.Tests/ColorProfiles/StringRepresentationTests.cs b/tests/ImageSharp.Tests/ColorProfiles/StringRepresentationTests.cs
index 770c987dba..f61124d8f5 100644
--- a/tests/ImageSharp.Tests/ColorProfiles/StringRepresentationTests.cs
+++ b/tests/ImageSharp.Tests/ColorProfiles/StringRepresentationTests.cs
@@ -6,11 +6,13 @@ using SixLabors.ImageSharp.ColorProfiles;
 
 namespace SixLabors.ImageSharp.Tests.ColorProfiles;
 
+[Trait("Color", "Conversion")]
 public class StringRepresentationTests
 {
     private static readonly Vector3 One = new(1);
     private static readonly Vector3 Zero = new(0);
     private static readonly Vector3 Random = new(42.4F, 94.5F, 83.4F);
+    private static readonly Vector4 Random4 = new(42.4F, 94.5F, 83.4F, 1);
 
     public static readonly TheoryData<object, string> TestData = new()
     {
@@ -51,7 +53,10 @@ public class StringRepresentationTests
         { Rgb.Clamp(new Rgb(Random)), "Rgb(1, 1, 1)" },
         { new Hsl(Random), "Hsl(42.4, 1, 1)" },           // clamping to 1 is expected
         { new Hsv(Random), "Hsv(42.4, 1, 1)" },           // clamping to 1 is expected
-        { new YCbCr(Random), "YCbCr(42.4, 94.5, 83.4)" },
+        { new Y(Random.X), "Y(1)" },
+        { new YCbCr(Random), "YCbCr(1, 1, 1)" },
+        { new YccK(Random4), "YccK(1, 1, 1, 1)" },
+        { new Cmyk(Random4), "Cmyk(1, 1, 1, 1)" },
     };
 
     [Theory]
diff --git a/tests/ImageSharp.Tests/ColorProfiles/VonKriesChromaticAdaptationTests.cs b/tests/ImageSharp.Tests/ColorProfiles/VonKriesChromaticAdaptationTests.cs
index 7f5687dee2..1622af1bfb 100644
--- a/tests/ImageSharp.Tests/ColorProfiles/VonKriesChromaticAdaptationTests.cs
+++ b/tests/ImageSharp.Tests/ColorProfiles/VonKriesChromaticAdaptationTests.cs
@@ -20,7 +20,7 @@ public class VonKriesChromaticAdaptationTests
     {
         ColorConversionOptions options = new()
         {
-            WhitePoint = from,
+            SourceWhitePoint = from,
             TargetWhitePoint = to
         };
 
diff --git a/tests/ImageSharp.Tests/ColorProfiles/YCbCrTests.cs b/tests/ImageSharp.Tests/ColorProfiles/YCbCrTests.cs
index f8404ad948..64558a3f8a 100644
--- a/tests/ImageSharp.Tests/ColorProfiles/YCbCrTests.cs
+++ b/tests/ImageSharp.Tests/ColorProfiles/YCbCrTests.cs
@@ -9,14 +9,15 @@ namespace SixLabors.ImageSharp.Tests.ColorProfiles;
 /// <summary>
 /// Tests the <see cref="YCbCr"/> struct.
 /// </summary>
+[Trait("Color", "Conversion")]
 public class YCbCrTests
 {
     [Fact]
     public void YCbCrConstructorAssignsFields()
     {
-        const float y = 75F;
-        const float cb = 64F;
-        const float cr = 87F;
+        const float y = .75F;
+        const float cb = .64F;
+        const float cr = .87F;
         YCbCr yCbCr = new(y, cb, cr);
 
         Assert.Equal(y, yCbCr.Y);
diff --git a/tests/ImageSharp.Tests/ColorProfiles/YTests.cs b/tests/ImageSharp.Tests/ColorProfiles/YTests.cs
new file mode 100644
index 0000000000..7e5e48b69e
--- /dev/null
+++ b/tests/ImageSharp.Tests/ColorProfiles/YTests.cs
@@ -0,0 +1,38 @@
+// Copyright (c) Six Labors.
+// Licensed under the Six Labors Split License.
+
+using SixLabors.ImageSharp.ColorProfiles;
+
+namespace SixLabors.ImageSharp.Tests.ColorProfiles;
+
+/// <summary>
+/// Tests the <see cref="Y"/> struct.
+/// </summary>
+[Trait("Color", "Conversion")]
+public class YTests
+{
+    [Fact]
+    public void YConstructorAssignsFields()
+    {
+        const float y = .75F;
+        Y yValue = new(y);
+
+        Assert.Equal(y, yValue.L);
+    }
+
+    [Fact]
+    public void YEquality()
+    {
+        Y x = default;
+        Y y = new(1F);
+        Assert.True(default == default(Y));
+        Assert.False(default != default(Y));
+        Assert.Equal(default, default(Y));
+        Assert.Equal(new Y(1), new Y(1));
+
+        Assert.Equal(new Y(.5F), new Y(.5F));
+        Assert.False(x.Equals(y));
+        Assert.False(x.Equals((object)y));
+        Assert.False(x.GetHashCode().Equals(y.GetHashCode()));
+    }
+}
diff --git a/tests/ImageSharp.Tests/ColorProfiles/YccKTests.cs b/tests/ImageSharp.Tests/ColorProfiles/YccKTests.cs
new file mode 100644
index 0000000000..bfe0bdb175
--- /dev/null
+++ b/tests/ImageSharp.Tests/ColorProfiles/YccKTests.cs
@@ -0,0 +1,44 @@
+// Copyright (c) Six Labors.
+// Licensed under the Six Labors Split License.
+
+using SixLabors.ImageSharp.ColorProfiles;
+
+namespace SixLabors.ImageSharp.Tests.ColorProfiles;
+
+/// <summary>
+/// Tests the <see cref="YccK"/> struct.
+/// </summary>
+[Trait("Color", "Conversion")]
+public class YccKTests
+{
+    [Fact]
+    public void YccKConstructorAssignsFields()
+    {
+        const float y = .75F;
+        const float cb = .5F;
+        const float cr = .25F;
+        const float k = .125F;
+
+        YccK ycckValue = new(y, cb, cr, k);
+        Assert.Equal(y, ycckValue.Y);
+        Assert.Equal(cb, ycckValue.Cb);
+        Assert.Equal(cr, ycckValue.Cr);
+        Assert.Equal(k, ycckValue.K);
+    }
+
+    [Fact]
+    public void YccKEquality()
+    {
+        YccK x = default;
+        YccK y = new(1F, 1F, 1F, 1F);
+        Assert.True(default == default(YccK));
+        Assert.False(default != default(YccK));
+        Assert.Equal(default, default(YccK));
+        Assert.Equal(new YccK(1, 1, 1, 1), new YccK(1, 1, 1, 1));
+        Assert.Equal(new YccK(.5F, .5F, .5F, .5F), new YccK(.5F, .5F, .5F, .5F));
+
+        Assert.False(x.Equals(y));
+        Assert.False(x.Equals((object)y));
+        Assert.False(x.GetHashCode().Equals(y.GetHashCode()));
+    }
+}
diff --git a/tests/ImageSharp.Tests/Common/EncoderExtensionsTests.cs b/tests/ImageSharp.Tests/Common/EncoderExtensionsTests.cs
index 190bfe1dc6..8421c1fd74 100644
--- a/tests/ImageSharp.Tests/Common/EncoderExtensionsTests.cs
+++ b/tests/ImageSharp.Tests/Common/EncoderExtensionsTests.cs
@@ -10,7 +10,7 @@ public class EncoderExtensionsTests
     [Fact]
     public void GetString_EmptyBuffer_ReturnsEmptyString()
     {
-        var buffer = default(ReadOnlySpan<byte>);
+        ReadOnlySpan<byte> buffer = default(ReadOnlySpan<byte>);
 
         string result = Encoding.UTF8.GetString(buffer);
 
@@ -20,7 +20,7 @@ public class EncoderExtensionsTests
     [Fact]
     public void GetString_Buffer_ReturnsString()
     {
-        var buffer = new ReadOnlySpan<byte>(new byte[] { 73, 109, 97, 103, 101, 83, 104, 97, 114, 112 });
+        ReadOnlySpan<byte> buffer = new(new byte[] { 73, 109, 97, 103, 101, 83, 104, 97, 114, 112 });
 
         string result = Encoding.UTF8.GetString(buffer);
 
diff --git a/tests/ImageSharp.Tests/Common/NumericsTests.cs b/tests/ImageSharp.Tests/Common/NumericsTests.cs
index 2b92769436..ebee570600 100644
--- a/tests/ImageSharp.Tests/Common/NumericsTests.cs
+++ b/tests/ImageSharp.Tests/Common/NumericsTests.cs
@@ -28,7 +28,7 @@ public class NumericsTests
     [InlineData(1, 100)]
     public void DivideCeil_RandomValues(int seed, int count)
     {
-        var rng = new Random(seed);
+        Random rng = new(seed);
         for (int i = 0; i < count; i++)
         {
             uint value = (uint)rng.Next();
diff --git a/tests/ImageSharp.Tests/Common/StreamExtensionsTests.cs b/tests/ImageSharp.Tests/Common/StreamExtensionsTests.cs
index 1931109448..5ea7afaf80 100644
--- a/tests/ImageSharp.Tests/Common/StreamExtensionsTests.cs
+++ b/tests/ImageSharp.Tests/Common/StreamExtensionsTests.cs
@@ -10,7 +10,7 @@ public class StreamExtensionsTests
     [InlineData(-1)]
     public void Skip_CountZeroOrLower_PositionNotChanged(int count)
     {
-        using (var memStream = new MemoryStream(5))
+        using (MemoryStream memStream = new(5))
         {
             memStream.Position = 4;
             memStream.Skip(count);
@@ -22,7 +22,7 @@ public class StreamExtensionsTests
     [Fact]
     public void Skip_SeekableStream_SeekIsCalled()
     {
-        using (var seekableStream = new SeekableStream(4))
+        using (SeekableStream seekableStream = new(4))
         {
             seekableStream.Skip(4);
 
@@ -34,7 +34,7 @@ public class StreamExtensionsTests
     [Fact]
     public void Skip_NonSeekableStream_BytesAreRead()
     {
-        using (var nonSeekableStream = new NonSeekableStream())
+        using (NonSeekableStream nonSeekableStream = new())
         {
             nonSeekableStream.Skip(5);
 
@@ -49,7 +49,7 @@ public class StreamExtensionsTests
     [Fact]
     public void Skip_EofStream_NoExceptionIsThrown()
     {
-        using (var eofStream = new EofStream(7))
+        using (EofStream eofStream = new(7))
         {
             eofStream.Skip(7);
 
@@ -79,7 +79,7 @@ public class StreamExtensionsTests
     {
         public override bool CanSeek => false;
 
-        public List<int> Counts = new List<int>();
+        public List<int> Counts = new();
 
         public NonSeekableStream()
             : base(4)
diff --git a/tests/ImageSharp.Tests/ConfigurationTests.cs b/tests/ImageSharp.Tests/ConfigurationTests.cs
index a75c63f9c2..bd65200844 100644
--- a/tests/ImageSharp.Tests/ConfigurationTests.cs
+++ b/tests/ImageSharp.Tests/ConfigurationTests.cs
@@ -58,7 +58,7 @@ public class ConfigurationTests
     {
         Assert.True(this.DefaultConfiguration.MaxDegreeOfParallelism == Environment.ProcessorCount);
 
-        var cfg = new Configuration();
+        Configuration cfg = new();
         Assert.True(cfg.MaxDegreeOfParallelism == Environment.ProcessorCount);
     }
 
@@ -71,7 +71,7 @@ public class ConfigurationTests
     [InlineData(5, false)]
     public void MaxDegreeOfParallelism_CompatibleWith_ParallelOptions(int maxDegreeOfParallelism, bool throws)
     {
-        var cfg = new Configuration();
+        Configuration cfg = new();
         if (throws)
         {
             Assert.Throws<ArgumentOutOfRangeException>(
@@ -87,8 +87,8 @@ public class ConfigurationTests
     [Fact]
     public void ConstructorCallConfigureOnFormatProvider()
     {
-        var provider = new Mock<IImageFormatConfigurationModule>();
-        var config = new Configuration(provider.Object);
+        Mock<IImageFormatConfigurationModule> provider = new();
+        Configuration config = new(provider.Object);
 
         provider.Verify(x => x.Configure(config));
     }
@@ -96,8 +96,8 @@ public class ConfigurationTests
     [Fact]
     public void AddFormatCallsConfig()
     {
-        var provider = new Mock<IImageFormatConfigurationModule>();
-        var config = new Configuration();
+        Mock<IImageFormatConfigurationModule> provider = new();
+        Configuration config = new();
         config.Configure(provider.Object);
 
         provider.Verify(x => x.Configure(config));
@@ -118,7 +118,7 @@ public class ConfigurationTests
     [Fact]
     public void DefaultConfigurationHasCorrectFormatCount()
     {
-        var config = Configuration.CreateDefaultInstance();
+        Configuration config = Configuration.CreateDefaultInstance();
 
         Assert.Equal(this.expectedDefaultConfigurationCount, config.ImageFormats.Count());
     }
@@ -140,7 +140,7 @@ public class ConfigurationTests
     [Fact]
     public void StreamBufferSize_CannotGoBelowMinimum()
     {
-        var config = new Configuration();
+        Configuration config = new();
 
         Assert.Throws<ArgumentOutOfRangeException>(
                 () => config.StreamProcessingBufferSize = 0);
@@ -150,14 +150,14 @@ public class ConfigurationTests
     public void MemoryAllocator_Setter_Roundtrips()
     {
         MemoryAllocator customAllocator = new SimpleGcMemoryAllocator();
-        var config = new Configuration() { MemoryAllocator = customAllocator };
+        Configuration config = new() { MemoryAllocator = customAllocator };
         Assert.Same(customAllocator, config.MemoryAllocator);
     }
 
     [Fact]
     public void MemoryAllocator_SetNull_ThrowsArgumentNullException()
     {
-        var config = new Configuration();
+        Configuration config = new();
         Assert.Throws<ArgumentNullException>(() => config.MemoryAllocator = null);
     }
 
@@ -168,9 +168,9 @@ public class ConfigurationTests
 
         static void RunTest()
         {
-            var c1 = new Configuration();
-            var c2 = new Configuration(new MockConfigurationModule());
-            var c3 = Configuration.CreateDefaultInstance();
+            Configuration c1 = new();
+            Configuration c2 = new(new MockConfigurationModule());
+            Configuration c3 = Configuration.CreateDefaultInstance();
 
             Assert.Same(MemoryAllocator.Default, Configuration.Default.MemoryAllocator);
             Assert.Same(MemoryAllocator.Default, c1.MemoryAllocator);
diff --git a/tests/ImageSharp.Tests/Drawing/DrawImageTests.cs b/tests/ImageSharp.Tests/Drawing/DrawImageTests.cs
index 88f4cde7ac..1d0fdf62d3 100644
--- a/tests/ImageSharp.Tests/Drawing/DrawImageTests.cs
+++ b/tests/ImageSharp.Tests/Drawing/DrawImageTests.cs
@@ -77,11 +77,11 @@ public class DrawImageTests
         PngEncoder encoder;
         if (provider.PixelType == PixelTypes.Rgba64)
         {
-            encoder = new() { BitDepth = PngBitDepth.Bit16 };
+            encoder = new PngEncoder { BitDepth = PngBitDepth.Bit16 };
         }
         else
         {
-            encoder = new();
+            encoder = new PngEncoder();
         }
 
         image.DebugSave(provider, testInfo, encoder: encoder);
diff --git a/tests/ImageSharp.Tests/Formats/Bmp/BmpEncoderTests.cs b/tests/ImageSharp.Tests/Formats/Bmp/BmpEncoderTests.cs
index 09ef49a61e..5ebcc8bb96 100644
--- a/tests/ImageSharp.Tests/Formats/Bmp/BmpEncoderTests.cs
+++ b/tests/ImageSharp.Tests/Formats/Bmp/BmpEncoderTests.cs
@@ -332,7 +332,7 @@ public class BmpEncoderTests
     public void Encode_PreservesColorProfile<TPixel>(TestImageProvider<TPixel> provider)
         where TPixel : unmanaged, IPixel<TPixel>
     {
-        using Image<TPixel> input = provider.GetImage(BmpDecoder.Instance, new());
+        using Image<TPixel> input = provider.GetImage(BmpDecoder.Instance, new BmpDecoderOptions());
         ImageSharp.Metadata.Profiles.Icc.IccProfile expectedProfile = input.Metadata.IccProfile;
         byte[] expectedProfileBytes = expectedProfile.ToByteArray();
 
diff --git a/tests/ImageSharp.Tests/Formats/Bmp/BmpFileHeaderTests.cs b/tests/ImageSharp.Tests/Formats/Bmp/BmpFileHeaderTests.cs
index d8ec7c9009..00a19466a3 100644
--- a/tests/ImageSharp.Tests/Formats/Bmp/BmpFileHeaderTests.cs
+++ b/tests/ImageSharp.Tests/Formats/Bmp/BmpFileHeaderTests.cs
@@ -11,9 +11,9 @@ public class BmpFileHeaderTests
     [Fact]
     public void TestWrite()
     {
-        var header = new BmpFileHeader(1, 2, 3, 4);
+        BmpFileHeader header = new(1, 2, 3, 4);
 
-        var buffer = new byte[14];
+        byte[] buffer = new byte[14];
 
         header.WriteTo(buffer);
 
diff --git a/tests/ImageSharp.Tests/Formats/GeneralFormatTests.cs b/tests/ImageSharp.Tests/Formats/GeneralFormatTests.cs
index 27511f7beb..072b04fa0d 100644
--- a/tests/ImageSharp.Tests/Formats/GeneralFormatTests.cs
+++ b/tests/ImageSharp.Tests/Formats/GeneralFormatTests.cs
@@ -16,24 +16,23 @@ public class GeneralFormatTests
     /// A collection made up of one file for each image format.
     /// </summary>
     public static readonly IEnumerable<string> DefaultFiles =
-        new[]
-        {
-            TestImages.Bmp.Car,
+    [
+        TestImages.Bmp.Car,
             TestImages.Jpeg.Baseline.Calliphora,
             TestImages.Png.Splash,
             TestImages.Gif.Trans
-        };
+    ];
 
     /// <summary>
     /// The collection of image files to test against.
     /// </summary>
-    protected static readonly List<TestFile> Files = new()
-    {
+    protected static readonly List<TestFile> Files =
+    [
         TestFile.Create(TestImages.Jpeg.Baseline.Calliphora),
         TestFile.Create(TestImages.Bmp.Car),
         TestFile.Create(TestImages.Png.Splash),
-        TestFile.Create(TestImages.Gif.Rings),
-    };
+        TestFile.Create(TestImages.Gif.Rings)
+    ];
 
     [Theory]
     [WithFileCollection(nameof(DefaultFiles), PixelTypes.Rgba32)]
@@ -151,7 +150,7 @@ public class GeneralFormatTests
     private static IQuantizer GetQuantizer(string name)
     {
         PropertyInfo property = typeof(KnownQuantizers).GetTypeInfo().GetProperty(name);
-        return (IQuantizer)property.GetMethod.Invoke(null, Array.Empty<object>());
+        return (IQuantizer)property.GetMethod.Invoke(null, []);
     }
 
     [Fact]
diff --git a/tests/ImageSharp.Tests/Formats/Gif/GifDecoderTests.cs b/tests/ImageSharp.Tests/Formats/Gif/GifDecoderTests.cs
index bc6eeedcbe..7bb711f3f8 100644
--- a/tests/ImageSharp.Tests/Formats/Gif/GifDecoderTests.cs
+++ b/tests/ImageSharp.Tests/Formats/Gif/GifDecoderTests.cs
@@ -20,9 +20,9 @@ public class GifDecoderTests
     private const PixelTypes TestPixelTypes = PixelTypes.Rgba32 | PixelTypes.RgbaVector | PixelTypes.Argb32;
 
     public static readonly string[] MultiFrameTestFiles =
-    {
+    [
         TestImages.Gif.Giphy, TestImages.Gif.Kumin
-    };
+    ];
 
     [Theory]
     [WithFileCollection(nameof(MultiFrameTestFiles), PixelTypes.Rgba32)]
@@ -34,6 +34,41 @@ public class GifDecoderTests
         image.CompareToReferenceOutputMultiFrame(provider, ImageComparer.Exact);
     }
 
+    [Theory]
+    [WithFile(TestImages.Gif.AnimatedLoop, PixelTypes.Rgba32)]
+    [WithFile(TestImages.Gif.AnimatedLoopInterlaced, PixelTypes.Rgba32)]
+    public void Decode_Animated<TPixel>(TestImageProvider<TPixel> provider)
+        where TPixel : unmanaged, IPixel<TPixel>
+    {
+        using Image<TPixel> image = provider.GetImage();
+        image.DebugSaveMultiFrame(provider);
+        image.CompareToReferenceOutputMultiFrame(provider, ImageComparer.Exact);
+    }
+
+    [Theory]
+    [WithFile(TestImages.Gif.AnimatedTransparentNoRestore, PixelTypes.Rgba32)]
+    [WithFile(TestImages.Gif.AnimatedTransparentRestorePrevious, PixelTypes.Rgba32)]
+    [WithFile(TestImages.Gif.AnimatedTransparentLoop, PixelTypes.Rgba32)]
+    [WithFile(TestImages.Gif.AnimatedTransparentFirstFrameRestorePrev, PixelTypes.Rgba32)]
+    public void Decode_Animated_WithTransparency<TPixel>(TestImageProvider<TPixel> provider)
+        where TPixel : unmanaged, IPixel<TPixel>
+    {
+        using Image<TPixel> image = provider.GetImage();
+        image.DebugSaveMultiFrame(provider);
+        image.CompareToReferenceOutputMultiFrame(provider, ImageComparer.Exact);
+    }
+
+    [Theory]
+    [WithFile(TestImages.Gif.StaticNontransparent, PixelTypes.Rgba32)]
+    [WithFile(TestImages.Gif.StaticTransparent, PixelTypes.Rgba32)]
+    public void Decode_Static_No_Animation<TPixel>(TestImageProvider<TPixel> provider)
+        where TPixel : unmanaged, IPixel<TPixel>
+    {
+        using Image<TPixel> image = provider.GetImage();
+        image.DebugSave(provider);
+        image.CompareFirstFrameToReferenceOutput(ImageComparer.Exact, provider);
+    }
+
     [Theory]
     [WithFile(TestImages.Gif.Issues.Issue2450_A, PixelTypes.Rgba32)]
     [WithFile(TestImages.Gif.Issues.Issue2450_B, PixelTypes.Rgba32)]
@@ -55,7 +90,7 @@ public class GifDecoderTests
     {
         DecoderOptions options = new()
         {
-            TargetSize = new() { Width = 150, Height = 150 },
+            TargetSize = new Size { Width = 150, Height = 150 },
             MaxFrames = 1
         };
 
@@ -222,7 +257,7 @@ public class GifDecoderTests
     public void Issue405_BadApplicationExtensionBlockLength<TPixel>(TestImageProvider<TPixel> provider)
         where TPixel : unmanaged, IPixel<TPixel>
     {
-        using Image<TPixel> image = provider.GetImage(GifDecoder.Instance, new() { MaxFrames = 1 });
+        using Image<TPixel> image = provider.GetImage(GifDecoder.Instance, new DecoderOptions { MaxFrames = 1 });
         image.DebugSave(provider);
 
         image.CompareFirstFrameToReferenceOutput(ImageComparer.Exact, provider);
@@ -234,7 +269,7 @@ public class GifDecoderTests
     public void Issue1668_InvalidColorIndex<TPixel>(TestImageProvider<TPixel> provider)
         where TPixel : unmanaged, IPixel<TPixel>
     {
-        using Image<TPixel> image = provider.GetImage(GifDecoder.Instance, new() { MaxFrames = 1 });
+        using Image<TPixel> image = provider.GetImage(GifDecoder.Instance, new DecoderOptions { MaxFrames = 1 });
         image.DebugSave(provider);
 
         image.CompareFirstFrameToReferenceOutput(ImageComparer.Exact, provider);
@@ -283,7 +318,7 @@ public class GifDecoderTests
     public void Issue1962<TPixel>(TestImageProvider<TPixel> provider)
         where TPixel : unmanaged, IPixel<TPixel>
     {
-        using Image<TPixel> image = provider.GetImage(GifDecoder.Instance, new() { MaxFrames = 1 });
+        using Image<TPixel> image = provider.GetImage(GifDecoder.Instance, new DecoderOptions { MaxFrames = 1 });
         image.DebugSave(provider);
 
         image.CompareFirstFrameToReferenceOutput(ImageComparer.Exact, provider);
@@ -295,7 +330,7 @@ public class GifDecoderTests
     public void Issue2012EmptyXmp<TPixel>(TestImageProvider<TPixel> provider)
         where TPixel : unmanaged, IPixel<TPixel>
     {
-        using Image<TPixel> image = provider.GetImage(GifDecoder.Instance, new() { MaxFrames = 1 });
+        using Image<TPixel> image = provider.GetImage(GifDecoder.Instance, new DecoderOptions { MaxFrames = 1 });
 
         image.DebugSave(provider);
         image.CompareFirstFrameToReferenceOutput(ImageComparer.Exact, provider);
@@ -346,4 +381,21 @@ public class GifDecoderTests
         image.DebugSaveMultiFrame(provider);
         image.CompareToReferenceOutputMultiFrame(provider, ImageComparer.Exact);
     }
+
+    // https://github.com/SixLabors/ImageSharp/issues/2953
+    [Theory]
+    [WithFile(TestImages.Gif.Issues.Issue2953, PixelTypes.Rgba32)]
+    public void Issue2953<TPixel>(TestImageProvider<TPixel> provider)
+        where TPixel : unmanaged, IPixel<TPixel>
+    {
+        // We should throw a InvalidImageContentException when trying to identify or load an invalid GIF file.
+        TestFile testFile = TestFile.Create(provider.SourceFileOrDescription);
+
+        Assert.Throws<InvalidImageContentException>(() => Image.Identify(testFile.FullPath));
+        Assert.Throws<InvalidImageContentException>(() => Image.Load(testFile.FullPath));
+
+        DecoderOptions options = new() { SkipMetadata = true };
+        Assert.Throws<InvalidImageContentException>(() => Image.Identify(options, testFile.FullPath));
+        Assert.Throws<InvalidImageContentException>(() => Image.Load(options, testFile.FullPath));
+    }
 }
diff --git a/tests/ImageSharp.Tests/Formats/Gif/GifEncoderTests.cs b/tests/ImageSharp.Tests/Formats/Gif/GifEncoderTests.cs
index f12f66186e..370106ca30 100644
--- a/tests/ImageSharp.Tests/Formats/Gif/GifEncoderTests.cs
+++ b/tests/ImageSharp.Tests/Formats/Gif/GifEncoderTests.cs
@@ -56,7 +56,7 @@ public class GifEncoderTests
             {
                 // Use the palette quantizer without dithering to ensure results
                 // are consistent
-                Quantizer = new WebSafePaletteQuantizer(new QuantizerOptions { Dither = null })
+                Quantizer = new WebSafePaletteQuantizer(new QuantizerOptions { Dither = null, TransparencyThreshold = 0 })
             };
 
             // Always save as we need to compare the encoded output.
@@ -121,7 +121,7 @@ public class GifEncoderTests
         // Always save as we need to compare the encoded output.
         provider.Utility.SaveTestOutputFile(image, "gif", encoder, "global");
 
-        encoder = new()
+        encoder = new GifEncoder
         {
             ColorTableMode = FrameColorTableMode.Local,
             Quantizer = new OctreeQuantizer(new QuantizerOptions { Dither = null }),
@@ -419,4 +419,21 @@ public class GifEncoderTests
             }
         });
     }
+
+    [Theory]
+    [WithFile(TestImages.Gif.Issues.Issue2866, PixelTypes.Rgba32)]
+    public void GifEncoder_CanDecode_AndEncode_Issue2866<TPixel>(TestImageProvider<TPixel> provider)
+        where TPixel : unmanaged, IPixel<TPixel>
+    {
+        using Image<TPixel> image = provider.GetImage();
+
+        // Save the image for visual inspection.
+        provider.Utility.SaveTestOutputFile(image, "gif", new GifEncoder(), "animated");
+
+        // Now compare the debug output with the reference output.
+        // We do this because the gif encoding is lossy and encoding will lead to differences in the 10s of percent.
+        // From the unencoded image, we can see that the image is visually the same.
+        static bool Predicate(int i, int _) => i % 8 == 0; // Image has many frames, only compare a selection of them.
+        image.CompareDebugOutputToReferenceOutputMultiFrame(provider, ImageComparer.Exact, extension: "gif", predicate: Predicate);
+    }
 }
diff --git a/tests/ImageSharp.Tests/Formats/Icon/Cur/CurEncoderTests.cs b/tests/ImageSharp.Tests/Formats/Icon/Cur/CurEncoderTests.cs
index bf94e1d489..f895afbd51 100644
--- a/tests/ImageSharp.Tests/Formats/Icon/Cur/CurEncoderTests.cs
+++ b/tests/ImageSharp.Tests/Formats/Icon/Cur/CurEncoderTests.cs
@@ -4,6 +4,7 @@
 using SixLabors.ImageSharp.Formats;
 using SixLabors.ImageSharp.Formats.Cur;
 using SixLabors.ImageSharp.Formats.Ico;
+using SixLabors.ImageSharp.Formats.Png;
 using SixLabors.ImageSharp.PixelFormats;
 using SixLabors.ImageSharp.Tests.TestUtilities.ImageComparison;
 using static SixLabors.ImageSharp.Tests.TestImages.Cur;
@@ -49,8 +50,8 @@ public class CurEncoderTests
         using Image<TPixel> encoded = Image.Load<TPixel>(memStream);
         encoded.DebugSaveMultiFrame(provider);
 
-        // Despite preservation of the palette. The process can still be lossy
-        encoded.CompareToOriginalMultiFrame(provider, ImageComparer.TolerantPercentage(.23f), IcoDecoder.Instance);
+        // Color palettes are not preserved when transcoding.
+        encoded.CompareToOriginalMultiFrame(provider, ImageComparer.TolerantPercentage(.05F), IcoDecoder.Instance);
 
         for (int i = 0; i < image.Frames.Count; i++)
         {
@@ -121,7 +122,7 @@ public class CurEncoderTests
                 {
                     if (expectedColor != rowSpan[x])
                     {
-                        var xx = 0;
+                        int xx = 0;
                     }
 
 
diff --git a/tests/ImageSharp.Tests/Formats/Icon/Ico/IcoDecoderTests.cs b/tests/ImageSharp.Tests/Formats/Icon/Ico/IcoDecoderTests.cs
index e076ccab60..85ff51b185 100644
--- a/tests/ImageSharp.Tests/Formats/Icon/Ico/IcoDecoderTests.cs
+++ b/tests/ImageSharp.Tests/Formats/Icon/Ico/IcoDecoderTests.cs
@@ -1,6 +1,7 @@
 // Copyright (c) Six Labors.
 // Licensed under the Six Labors Split License.
 
+using SixLabors.ImageSharp.Formats;
 using SixLabors.ImageSharp.Formats.Bmp;
 using SixLabors.ImageSharp.Formats.Ico;
 using SixLabors.ImageSharp.Formats.Icon;
@@ -277,7 +278,7 @@ public class IcoDecoderTests
     [WithFile(MultiSizeF, PixelTypes.Rgba32)]
     public void MultiSize_CanDecodeSingleFrame(TestImageProvider<Rgba32> provider)
     {
-        using Image<Rgba32> image = provider.GetImage(IcoDecoder.Instance, new() { MaxFrames = 1 });
+        using Image<Rgba32> image = provider.GetImage(IcoDecoder.Instance, new DecoderOptions { MaxFrames = 1 });
         Assert.Single(image.Frames);
     }
 
@@ -293,7 +294,7 @@ public class IcoDecoderTests
         TestFile testFile = TestFile.Create(imagePath);
         using MemoryStream stream = new(testFile.Bytes, false);
 
-        ImageInfo imageInfo = Image.Identify(new() { MaxFrames = 1 }, stream);
+        ImageInfo imageInfo = Image.Identify(new DecoderOptions { MaxFrames = 1 }, stream);
 
         Assert.Single(imageInfo.FrameMetadataCollection);
     }
diff --git a/tests/ImageSharp.Tests/Formats/ImageFormatManagerTests.cs b/tests/ImageSharp.Tests/Formats/ImageFormatManagerTests.cs
index c7cdc4d3a6..a8ee56c8f7 100644
--- a/tests/ImageSharp.Tests/Formats/ImageFormatManagerTests.cs
+++ b/tests/ImageSharp.Tests/Formats/ImageFormatManagerTests.cs
@@ -126,7 +126,7 @@ public class ImageFormatManagerTests
         IImageFormat format = Image.DetectFormat(jpegImage);
         Assert.IsType<JpegFormat>(format);
 
-        byte[] invalidImage = { 1, 2, 3 };
+        byte[] invalidImage = [1, 2, 3];
         Assert.Throws<UnknownImageFormatException>(() => Image.DetectFormat(invalidImage));
     }
 }
diff --git a/tests/ImageSharp.Tests/Formats/Jpg/AdobeMarkerTests.cs b/tests/ImageSharp.Tests/Formats/Jpg/AdobeMarkerTests.cs
index 740b410feb..aee064ccc6 100644
--- a/tests/ImageSharp.Tests/Formats/Jpg/AdobeMarkerTests.cs
+++ b/tests/ImageSharp.Tests/Formats/Jpg/AdobeMarkerTests.cs
@@ -10,10 +10,10 @@ namespace SixLabors.ImageSharp.Tests.Formats.Jpg;
 public class AdobeMarkerTests
 {
     // Taken from actual test image
-    private readonly byte[] bytes = { 0x41, 0x64, 0x6F, 0x62, 0x65, 0x0, 0x64, 0x0, 0x0, 0x0, 0x0, 0x2 };
+    private readonly byte[] bytes = [0x41, 0x64, 0x6F, 0x62, 0x65, 0x0, 0x64, 0x0, 0x0, 0x0, 0x0, 0x2];
 
     // Altered components
-    private readonly byte[] bytes2 = { 0x41, 0x64, 0x6F, 0x62, 0x65, 0x0, 0x64, 0x0, 0x0, 0x1, 0x1, 0x1 };
+    private readonly byte[] bytes2 = [0x41, 0x64, 0x6F, 0x62, 0x65, 0x0, 0x64, 0x0, 0x0, 0x1, 0x1, 0x1];
 
     [Fact]
     public void MarkerLengthIsCorrect()
@@ -36,7 +36,7 @@ public class AdobeMarkerTests
     [Fact]
     public void MarkerIgnoresIncorrectValue()
     {
-        bool isAdobe = AdobeMarker.TryParse(new byte[] { 0, 0, 0, 0 }, out AdobeMarker marker);
+        bool isAdobe = AdobeMarker.TryParse([0, 0, 0, 0], out AdobeMarker marker);
 
         Assert.False(isAdobe);
         Assert.Equal(default, marker);
diff --git a/tests/ImageSharp.Tests/Formats/Jpg/Block8x8FTests.cs b/tests/ImageSharp.Tests/Formats/Jpg/Block8x8FTests.cs
index cde9e776b2..ab205c8a30 100644
--- a/tests/ImageSharp.Tests/Formats/Jpg/Block8x8FTests.cs
+++ b/tests/ImageSharp.Tests/Formats/Jpg/Block8x8FTests.cs
@@ -3,6 +3,7 @@
 
 // Uncomment this to turn unit tests into benchmarks:
 // #define BENCHMARKING
+using System.Runtime.Intrinsics;
 using SixLabors.ImageSharp.Formats.Jpeg.Components;
 using SixLabors.ImageSharp.Tests.Formats.Jpg.Utils;
 using SixLabors.ImageSharp.Tests.TestUtilities;
@@ -24,11 +25,22 @@ public partial class Block8x8FTests : JpegFixture
     {
     }
 
-    private bool SkipOnNonAvx2Runner()
+    private bool SkipOnNonVector256Runner()
     {
-        if (!SimdUtils.HasVector8)
+        if (!Vector256.IsHardwareAccelerated)
         {
-            this.Output.WriteLine("AVX2 not supported, skipping!");
+            this.Output.WriteLine("Vector256 not supported, skipping!");
+            return true;
+        }
+
+        return false;
+    }
+
+    private bool SkipOnNonVector128Runner()
+    {
+        if (!Vector128.IsHardwareAccelerated)
+        {
+            this.Output.WriteLine("Vector128 not supported, skipping!");
             return true;
         }
 
@@ -43,7 +55,7 @@ public partial class Block8x8FTests : JpegFixture
             Times,
             () =>
             {
-                var block = default(Block8x8F);
+                Block8x8F block = default;
 
                 for (int i = 0; i < Block8x8F.Size; i++)
                 {
@@ -56,7 +68,7 @@ public partial class Block8x8FTests : JpegFixture
                     sum += block[i];
                 }
             });
-        Assert.Equal(sum, 64f * 63f * 0.5f);
+        Assert.Equal(64f * 63f * 0.5f, sum);
     }
 
     [Fact]
@@ -81,7 +93,7 @@ public partial class Block8x8FTests : JpegFixture
                     sum += block[i];
                 }
             });
-        Assert.Equal(sum, 64f * 63f * 0.5f);
+        Assert.Equal(64f * 63f * 0.5f, sum);
     }
 
     [Fact]
@@ -109,7 +121,7 @@ public partial class Block8x8FTests : JpegFixture
     }
 
     [Fact]
-    public void TransposeInplace()
+    public void TransposeInPlace()
     {
         static void RunTest()
         {
@@ -118,7 +130,7 @@ public partial class Block8x8FTests : JpegFixture
 
             Block8x8F block8x8 = Block8x8F.Load(Create8x8FloatData());
 
-            block8x8.TransposeInplace();
+            block8x8.TransposeInPlace();
 
             float[] actual = new float[64];
             block8x8.ScaledCopyTo(actual);
@@ -172,9 +184,33 @@ public partial class Block8x8FTests : JpegFixture
     [Theory]
     [InlineData(1)]
     [InlineData(2)]
-    public void NormalizeColorsAndRoundAvx2(int seed)
+    public void NormalizeColorsAndRoundVector256(int seed)
+    {
+        if (this.SkipOnNonVector256Runner())
+        {
+            return;
+        }
+
+        Block8x8F source = CreateRandomFloatBlock(-200, 200, seed);
+
+        Block8x8F expected = source;
+        expected.NormalizeColorsInPlace(255);
+        expected.RoundInPlace();
+
+        Block8x8F actual = source;
+        actual.NormalizeColorsAndRoundInPlaceVector256(255);
+
+        this.Output.WriteLine(expected.ToString());
+        this.Output.WriteLine(actual.ToString());
+        this.CompareBlocks(expected, actual, 0);
+    }
+
+    [Theory]
+    [InlineData(1)]
+    [InlineData(2)]
+    public void NormalizeColorsAndRoundVector128(int seed)
     {
-        if (this.SkipOnNonAvx2Runner())
+        if (this.SkipOnNonVector128Runner())
         {
             return;
         }
@@ -186,7 +222,7 @@ public partial class Block8x8FTests : JpegFixture
         expected.RoundInPlace();
 
         Block8x8F actual = source;
-        actual.NormalizeColorsAndRoundInPlaceVector8(255);
+        actual.NormalizeColorsAndRoundInPlaceVector128(255);
 
         this.Output.WriteLine(expected.ToString());
         this.Output.WriteLine(actual.ToString());
@@ -206,7 +242,7 @@ public partial class Block8x8FTests : JpegFixture
             Block8x8F source = CreateRandomFloatBlock(-2000, 2000, srcSeed);
 
             // Quantization code is used only in jpeg where it's guaranteed that
-            // qunatization valus are greater than 1
+            // quantization values are greater than 1
             // Quantize method supports negative numbers by very small numbers can cause troubles
             Block8x8F quant = CreateRandomFloatBlock(1, 2000, qtSeed);
 
@@ -240,7 +276,7 @@ public partial class Block8x8FTests : JpegFixture
         float[] data = Create8x8RandomFloatData(-1000, 1000);
 
         Block8x8F source = Block8x8F.Load(data);
-        var dest = default(Block8x8);
+        Block8x8 dest = default;
 
         source.RoundInto(ref dest);
 
@@ -345,14 +381,14 @@ public partial class Block8x8FTests : JpegFixture
     [Fact]
     public void LoadFromUInt16Scalar()
     {
-        if (this.SkipOnNonAvx2Runner())
+        if (this.SkipOnNonVector256Runner())
         {
             return;
         }
 
         short[] data = Create8x8ShortData();
 
-        var source = Block8x8.Load(data);
+        Block8x8 source = Block8x8.Load(data);
 
         Block8x8F dest = default;
         dest.LoadFromInt16Scalar(ref source);
@@ -363,20 +399,41 @@ public partial class Block8x8FTests : JpegFixture
         }
     }
 
+    [Fact]
+    public void LoadFromUInt16ExtendedVector128()
+    {
+        if (this.SkipOnNonVector128Runner())
+        {
+            return;
+        }
+
+        short[] data = Create8x8ShortData();
+
+        Block8x8 source = Block8x8.Load(data);
+
+        Block8x8F dest = default;
+        dest.LoadFromInt16ExtendedVector128(ref source);
+
+        for (int i = 0; i < Block8x8F.Size; i++)
+        {
+            Assert.Equal(data[i], dest[i]);
+        }
+    }
+
     [Fact]
     public void LoadFromUInt16ExtendedAvx2()
     {
-        if (this.SkipOnNonAvx2Runner())
+        if (this.SkipOnNonVector256Runner())
         {
             return;
         }
 
         short[] data = Create8x8ShortData();
 
-        var source = Block8x8.Load(data);
+        Block8x8 source = Block8x8.Load(data);
 
         Block8x8F dest = default;
-        dest.LoadFromInt16ExtendedAvx2(ref source);
+        dest.LoadFromInt16ExtendedVector256(ref source);
 
         for (int i = 0; i < Block8x8F.Size; i++)
         {
@@ -405,7 +462,7 @@ public partial class Block8x8FTests : JpegFixture
         // 3. DisableAvx2 - call fallback code of float implementation
         FeatureTestRunner.RunWithHwIntrinsicsFeature(
             RunTest,
-            HwIntrinsics.AllowAll | HwIntrinsics.DisableAVX2);
+            HwIntrinsics.AllowAll | HwIntrinsics.DisableAVX | HwIntrinsics.DisableSSE);
     }
 
     [Theory]
diff --git a/tests/ImageSharp.Tests/Formats/Jpg/Block8x8Tests.cs b/tests/ImageSharp.Tests/Formats/Jpg/Block8x8Tests.cs
index b5d364dd38..fb1e062f20 100644
--- a/tests/ImageSharp.Tests/Formats/Jpg/Block8x8Tests.cs
+++ b/tests/ImageSharp.Tests/Formats/Jpg/Block8x8Tests.cs
@@ -21,7 +21,7 @@ public class Block8x8Tests : JpegFixture
     {
         short[] data = Create8x8ShortData();
 
-        var block = Block8x8.Load(data);
+        Block8x8 block = Block8x8.Load(data);
 
         for (int i = 0; i < Block8x8.Size; i++)
         {
@@ -47,7 +47,7 @@ public class Block8x8Tests : JpegFixture
     {
         short[] data = Create8x8ShortData();
 
-        var source = Block8x8.Load(data);
+        Block8x8 source = Block8x8.Load(data);
 
         Block8x8F dest = source.AsFloatBlock();
 
@@ -61,7 +61,7 @@ public class Block8x8Tests : JpegFixture
     public void ToArray()
     {
         short[] data = Create8x8ShortData();
-        var block = Block8x8.Load(data);
+        Block8x8 block = Block8x8.Load(data);
 
         short[] result = block.ToArray();
 
@@ -72,8 +72,8 @@ public class Block8x8Tests : JpegFixture
     public void Equality_WhenFalse()
     {
         short[] data = Create8x8ShortData();
-        var block1 = Block8x8.Load(data);
-        var block2 = Block8x8.Load(data);
+        Block8x8 block1 = Block8x8.Load(data);
+        Block8x8 block2 = Block8x8.Load(data);
 
         block1[0] = 42;
         block2[0] = 666;
@@ -96,8 +96,8 @@ public class Block8x8Tests : JpegFixture
     public void TotalDifference()
     {
         short[] data = Create8x8ShortData();
-        var block1 = Block8x8.Load(data);
-        var block2 = Block8x8.Load(data);
+        Block8x8 block1 = Block8x8.Load(data);
+        Block8x8 block2 = Block8x8.Load(data);
 
         block2[10] += 7;
         block2[63] += 8;
@@ -157,7 +157,7 @@ public class Block8x8Tests : JpegFixture
         static void RunTest(string seedSerialized)
         {
             int seed = FeatureTestRunner.Deserialize<int>(seedSerialized);
-            var rng = new Random(seed);
+            Random rng = new(seed);
 
             for (int i = 0; i < 1000; i++)
             {
@@ -188,7 +188,7 @@ public class Block8x8Tests : JpegFixture
         static void RunTest(string seedSerialized)
         {
             int seed = FeatureTestRunner.Deserialize<int>(seedSerialized);
-            var rng = new Random(seed);
+            Random rng = new(seed);
 
             for (int i = 0; i < 1000; i++)
             {
@@ -223,7 +223,7 @@ public class Block8x8Tests : JpegFixture
         static void RunTest(string seedSerialized)
         {
             int seed = FeatureTestRunner.Deserialize<int>(seedSerialized);
-            var rng = new Random(seed);
+            Random rng = new(seed);
 
             for (int i = 0; i < 1000; i++)
             {
@@ -271,7 +271,7 @@ public class Block8x8Tests : JpegFixture
 
             Block8x8 block8x8 = Block8x8.Load(Create8x8ShortData());
 
-            block8x8.TransposeInplace();
+            block8x8.TransposeInPlace();
 
             short[] actual = new short[64];
             block8x8.CopyTo(actual);
diff --git a/tests/ImageSharp.Tests/Formats/Jpg/DCTTests.cs b/tests/ImageSharp.Tests/Formats/Jpg/DCTTests.cs
index 5a1488c411..062a8a5ee5 100644
--- a/tests/ImageSharp.Tests/Formats/Jpg/DCTTests.cs
+++ b/tests/ImageSharp.Tests/Formats/Jpg/DCTTests.cs
@@ -46,7 +46,7 @@ public static class DCTTests
         {
             float[] sourceArray = Create8x8RandomFloatData(MinInputValue, MaxInputValue, seed);
 
-            var srcBlock = Block8x8F.Load(sourceArray);
+            Block8x8F srcBlock = Block8x8F.Load(sourceArray);
 
             // reference
             Block8x8F expected = ReferenceImplementations.LLM_FloatingPoint_DCT.TransformIDCT(ref srcBlock);
@@ -62,7 +62,7 @@ public static class DCTTests
             FloatingPointDCT.AdjustToIDCT(ref dequantMatrix);
 
             // IDCT implementation tranforms blocks after transposition
-            srcBlock.TransposeInplace();
+            srcBlock.TransposeInPlace();
             srcBlock.MultiplyInPlace(ref dequantMatrix);
 
             // IDCT calculation
@@ -79,7 +79,7 @@ public static class DCTTests
         {
             float[] sourceArray = Create8x8RandomFloatData(MinInputValue, MaxInputValue, seed);
 
-            var srcBlock = Block8x8F.Load(sourceArray);
+            Block8x8F srcBlock = Block8x8F.Load(sourceArray);
 
             // reference
             Block8x8F expected = ReferenceImplementations.AccurateDCT.TransformIDCT(ref srcBlock);
@@ -95,7 +95,7 @@ public static class DCTTests
             FloatingPointDCT.AdjustToIDCT(ref dequantMatrix);
 
             // IDCT implementation tranforms blocks after transposition
-            srcBlock.TransposeInplace();
+            srcBlock.TransposeInPlace();
             srcBlock.MultiplyInPlace(ref dequantMatrix);
 
             // IDCT calculation
@@ -136,7 +136,7 @@ public static class DCTTests
 
                 // testee
                 // IDCT implementation tranforms blocks after transposition
-                srcBlock.TransposeInplace();
+                srcBlock.TransposeInPlace();
                 FloatingPointDCT.TransformIDCT(ref srcBlock);
 
                 float[] actualDest = srcBlock.ToArray();
@@ -182,7 +182,7 @@ public static class DCTTests
 
             // testee
             // IDCT implementation tranforms blocks after transposition
-            srcBlock.TransposeInplace();
+            srcBlock.TransposeInPlace();
             ScaledFloatingPointDCT.TransformIDCT_4x4(ref srcBlock, ref dequantMatrix, NormalizationValue, MaxOutputValue);
 
             Span<float> expectedSpan = expectedDest.AsSpan();
@@ -243,7 +243,7 @@ public static class DCTTests
 
             // testee
             // IDCT implementation tranforms blocks after transposition
-            srcBlock.TransposeInplace();
+            srcBlock.TransposeInPlace();
             ScaledFloatingPointDCT.TransformIDCT_2x2(ref srcBlock, ref dequantMatrix, NormalizationValue, MaxOutputValue);
 
             Span<float> expectedSpan = expectedDest.AsSpan();
@@ -338,7 +338,7 @@ public static class DCTTests
                 // Second transpose call is done by Quantize step
                 // Do this manually here just to be complient to the reference implementation
                 FloatingPointDCT.TransformFDCT(ref block);
-                block.TransposeInplace();
+                block.TransposeInPlace();
 
                 // Part of the IDCT calculations is fused into the quantization step
                 // We must multiply input block with adjusted no-quantization matrix
diff --git a/tests/ImageSharp.Tests/Formats/Jpg/HuffmanScanEncoderTests.cs b/tests/ImageSharp.Tests/Formats/Jpg/HuffmanScanEncoderTests.cs
index b89d9ad27a..36b792fa1c 100644
--- a/tests/ImageSharp.Tests/Formats/Jpg/HuffmanScanEncoderTests.cs
+++ b/tests/ImageSharp.Tests/Formats/Jpg/HuffmanScanEncoderTests.cs
@@ -69,7 +69,7 @@ public class HuffmanScanEncoderTests
     {
         int maxNumber = 1 << 16;
 
-        var rng = new Random(seed);
+        Random rng = new(seed);
         for (int i = 0; i < 1000; i++)
         {
             uint number = (uint)rng.Next(0, maxNumber);
diff --git a/tests/ImageSharp.Tests/Formats/Jpg/JFifMarkerTests.cs b/tests/ImageSharp.Tests/Formats/Jpg/JFifMarkerTests.cs
index 3b7e20eb4e..22b25a2bef 100644
--- a/tests/ImageSharp.Tests/Formats/Jpg/JFifMarkerTests.cs
+++ b/tests/ImageSharp.Tests/Formats/Jpg/JFifMarkerTests.cs
@@ -10,13 +10,13 @@ namespace SixLabors.ImageSharp.Tests.Formats.Jpg;
 public class JFifMarkerTests
 {
     // Taken from actual test image
-    private readonly byte[] bytes = { 0x4A, 0x46, 0x49, 0x46, 0x0, 0x1, 0x1, 0x1, 0x0, 0x60, 0x0, 0x60, 0x0 };
+    private readonly byte[] bytes = [0x4A, 0x46, 0x49, 0x46, 0x0, 0x1, 0x1, 0x1, 0x0, 0x60, 0x0, 0x60, 0x0];
 
     // Altered components
-    private readonly byte[] bytes2 = { 0x4A, 0x46, 0x49, 0x46, 0x0, 0x1, 0x1, 0x1, 0x0, 0x48, 0x0, 0x48, 0x0 };
+    private readonly byte[] bytes2 = [0x4A, 0x46, 0x49, 0x46, 0x0, 0x1, 0x1, 0x1, 0x0, 0x48, 0x0, 0x48, 0x0];
 
     // Incorrect density values. Zero is invalid.
-    private readonly byte[] bytes3 = { 0x4A, 0x46, 0x49, 0x46, 0x0, 0x1, 0x1, 0x1, 0x0, 0x0, 0x0, 0x0, 0x0 };
+    private readonly byte[] bytes3 = [0x4A, 0x46, 0x49, 0x46, 0x0, 0x1, 0x1, 0x1, 0x0, 0x0, 0x0, 0x0, 0x0];
 
     [Fact]
     public void MarkerLengthIsCorrect()
@@ -40,7 +40,7 @@ public class JFifMarkerTests
     [Fact]
     public void MarkerIgnoresIncorrectValue()
     {
-        bool isJFif = JFifMarker.TryParse(new byte[] { 0, 0, 0, 0 }, out JFifMarker marker);
+        bool isJFif = JFifMarker.TryParse([0, 0, 0, 0], out JFifMarker marker);
 
         Assert.False(isJFif);
         Assert.Equal(default, marker);
diff --git a/tests/ImageSharp.Tests/Formats/Jpg/JpegColorConverterTests.cs b/tests/ImageSharp.Tests/Formats/Jpg/JpegColorConverterTests.cs
index 7aabdaa588..d58ff98237 100644
--- a/tests/ImageSharp.Tests/Formats/Jpg/JpegColorConverterTests.cs
+++ b/tests/ImageSharp.Tests/Formats/Jpg/JpegColorConverterTests.cs
@@ -1,8 +1,6 @@
 // Copyright (c) Six Labors.
 // Licensed under the Six Labors Split License.
 
-using System.Runtime.Intrinsics.Arm;
-using System.Runtime.Intrinsics.X86;
 using SixLabors.ImageSharp.ColorProfiles;
 using SixLabors.ImageSharp.Formats.Jpeg.Components;
 using SixLabors.ImageSharp.Memory;
@@ -15,13 +13,13 @@ namespace SixLabors.ImageSharp.Tests.Formats.Jpg;
 [Trait("Format", "Jpg")]
 public class JpegColorConverterTests
 {
-    private const float MaxColorChannelValue = 255f;
+    private const float MaxColorChannelValue = 255F;
 
     private const float Precision = 0.1F / 255;
 
     private const int TestBufferLength = 40;
 
-    private const HwIntrinsics IntrinsicsConfig = HwIntrinsics.AllowAll | HwIntrinsics.DisableAVX2;
+    private const HwIntrinsics IntrinsicsConfig = HwIntrinsics.AllowAll | HwIntrinsics.DisableAVX512F | HwIntrinsics.DisableAVX2;
 
     private static readonly ApproximateColorProfileComparer ColorSpaceComparer = new(epsilon: Precision);
 
@@ -75,23 +73,23 @@ public class JpegColorConverterTests
     {
         FeatureTestRunner.RunWithHwIntrinsicsFeature(
             RunTest,
-            HwIntrinsics.AllowAll | HwIntrinsics.DisableAVX2 | HwIntrinsics.DisableSSE2 | HwIntrinsics.DisableHWIntrinsic);
+            HwIntrinsics.AllowAll | HwIntrinsics.DisableAVX512F | HwIntrinsics.DisableAVX2 | HwIntrinsics.DisableSSE2 | HwIntrinsics.DisableHWIntrinsic);
 
         static void RunTest(string arg)
         {
             // arrange
             Type expectedType = typeof(JpegColorConverterBase.RgbScalar);
-            if (Avx.IsSupported)
+            if (JpegColorConverterBase.JpegColorConverterVector512.IsSupported)
             {
-                expectedType = typeof(JpegColorConverterBase.RgbAvx);
+                expectedType = typeof(JpegColorConverterBase.RgbVector512);
             }
-            else if (Sse2.IsSupported)
+            else if (JpegColorConverterBase.JpegColorConverterVector256.IsSupported)
             {
-                expectedType = typeof(JpegColorConverterBase.RgbVector);
+                expectedType = typeof(JpegColorConverterBase.RgbVector256);
             }
-            else if (AdvSimd.IsSupported)
+            else if (JpegColorConverterBase.JpegColorConverterVector128.IsSupported)
             {
-                expectedType = typeof(JpegColorConverterBase.RgbArm);
+                expectedType = typeof(JpegColorConverterBase.RgbVector128);
             }
 
             // act
@@ -108,23 +106,23 @@ public class JpegColorConverterTests
     {
         FeatureTestRunner.RunWithHwIntrinsicsFeature(
             RunTest,
-            HwIntrinsics.AllowAll | HwIntrinsics.DisableAVX2 | HwIntrinsics.DisableSSE2 | HwIntrinsics.DisableHWIntrinsic);
+            HwIntrinsics.AllowAll | HwIntrinsics.DisableAVX512F | HwIntrinsics.DisableAVX2 | HwIntrinsics.DisableSSE2 | HwIntrinsics.DisableHWIntrinsic);
 
         static void RunTest(string arg)
         {
             // arrange
-            Type expectedType = typeof(JpegColorConverterBase.GrayscaleScalar);
-            if (Avx.IsSupported)
+            Type expectedType = typeof(JpegColorConverterBase.GrayScaleScalar);
+            if (JpegColorConverterBase.JpegColorConverterVector512.IsSupported)
             {
-                expectedType = typeof(JpegColorConverterBase.GrayscaleAvx);
+                expectedType = typeof(JpegColorConverterBase.GrayScaleVector512);
             }
-            else if (Sse2.IsSupported)
+            else if (JpegColorConverterBase.JpegColorConverterVector256.IsSupported)
             {
-                expectedType = typeof(JpegColorConverterBase.GrayScaleVector);
+                expectedType = typeof(JpegColorConverterBase.GrayScaleVector256);
             }
-            else if (AdvSimd.IsSupported)
+            else if (JpegColorConverterBase.JpegColorConverterVector128.IsSupported)
             {
-                expectedType = typeof(JpegColorConverterBase.GrayscaleArm);
+                expectedType = typeof(JpegColorConverterBase.GrayScaleVector128);
             }
 
             // act
@@ -147,17 +145,17 @@ public class JpegColorConverterTests
         {
             // arrange
             Type expectedType = typeof(JpegColorConverterBase.CmykScalar);
-            if (Avx.IsSupported)
+            if (JpegColorConverterBase.JpegColorConverterVector512.IsSupported)
             {
-                expectedType = typeof(JpegColorConverterBase.CmykAvx);
+                expectedType = typeof(JpegColorConverterBase.CmykVector512);
             }
-            else if (Sse2.IsSupported)
+            else if (JpegColorConverterBase.JpegColorConverterVector256.IsSupported)
             {
-                expectedType = typeof(JpegColorConverterBase.CmykVector);
+                expectedType = typeof(JpegColorConverterBase.CmykVector256);
             }
-            else if (AdvSimd.Arm64.IsSupported)
+            else if (JpegColorConverterBase.JpegColorConverterVector128.IsSupported)
             {
-                expectedType = typeof(JpegColorConverterBase.CmykArm64);
+                expectedType = typeof(JpegColorConverterBase.CmykVector128);
             }
 
             // act
@@ -174,23 +172,23 @@ public class JpegColorConverterTests
     {
         FeatureTestRunner.RunWithHwIntrinsicsFeature(
             RunTest,
-            HwIntrinsics.AllowAll | HwIntrinsics.DisableAVX2 | HwIntrinsics.DisableSSE2 | HwIntrinsics.DisableHWIntrinsic);
+            HwIntrinsics.AllowAll | HwIntrinsics.DisableAVX512F | HwIntrinsics.DisableAVX2 | HwIntrinsics.DisableSSE2 | HwIntrinsics.DisableHWIntrinsic);
 
         static void RunTest(string arg)
         {
             // arrange
             Type expectedType = typeof(JpegColorConverterBase.YCbCrScalar);
-            if (Avx.IsSupported)
+            if (JpegColorConverterBase.JpegColorConverterVector512.IsSupported)
             {
-                expectedType = typeof(JpegColorConverterBase.YCbCrAvx);
+                expectedType = typeof(JpegColorConverterBase.YCbCrVector512);
             }
-            else if (Sse2.IsSupported)
+            else if (JpegColorConverterBase.JpegColorConverterVector256.IsSupported)
             {
-                expectedType = typeof(JpegColorConverterBase.YCbCrVector);
+                expectedType = typeof(JpegColorConverterBase.YCbCrVector256);
             }
-            else if (AdvSimd.IsSupported)
+            else if (JpegColorConverterBase.JpegColorConverterVector128.IsSupported)
             {
-                expectedType = typeof(JpegColorConverterBase.YCbCrArm);
+                expectedType = typeof(JpegColorConverterBase.YCbCrVector128);
             }
 
             // act
@@ -207,23 +205,23 @@ public class JpegColorConverterTests
     {
         FeatureTestRunner.RunWithHwIntrinsicsFeature(
             RunTest,
-            HwIntrinsics.AllowAll | HwIntrinsics.DisableAVX2 | HwIntrinsics.DisableSSE2 | HwIntrinsics.DisableHWIntrinsic);
+            HwIntrinsics.AllowAll | HwIntrinsics.DisableAVX512F | HwIntrinsics.DisableAVX2 | HwIntrinsics.DisableSSE2 | HwIntrinsics.DisableHWIntrinsic);
 
         static void RunTest(string arg)
         {
             // arrange
             Type expectedType = typeof(JpegColorConverterBase.YccKScalar);
-            if (Avx.IsSupported)
+            if (JpegColorConverterBase.JpegColorConverterVector512.IsSupported)
             {
-                expectedType = typeof(JpegColorConverterBase.YccKAvx);
+                expectedType = typeof(JpegColorConverterBase.YccKVector512);
             }
-            else if (Sse2.IsSupported)
+            else if (JpegColorConverterBase.JpegColorConverterVector256.IsSupported)
             {
-                expectedType = typeof(JpegColorConverterBase.YccKVector);
+                expectedType = typeof(JpegColorConverterBase.YccKVector256);
             }
-            else if (AdvSimd.Arm64.IsSupported)
+            else if (JpegColorConverterBase.JpegColorConverterVector128.IsSupported)
             {
-                expectedType = typeof(JpegColorConverterBase.YccKArm64);
+                expectedType = typeof(JpegColorConverterBase.YccKVector128);
             }
 
             // act
@@ -257,323 +255,308 @@ public class JpegColorConverterTests
 
     [Theory]
     [MemberData(nameof(Seeds))]
-    public void FromYCbCrVector(int seed)
-    {
-        JpegColorConverterBase.YCbCrVector converter = new(8);
-
-        if (!converter.IsAvailable)
-        {
-            this.Output.WriteLine(
-                $"Skipping test - {converter.GetType().Name} is not supported on current hardware.");
-            return;
-        }
-
-        FeatureTestRunner.RunWithHwIntrinsicsFeature(
-            RunTest,
+    public void FromYCbCrVector512(int seed) =>
+        this.TestConversionToRgb(
+            new JpegColorConverterBase.YCbCrVector512(8),
+            3,
             seed,
-            IntrinsicsConfig);
-
-        static void RunTest(string arg) =>
-            ValidateConversionToRgb(
-                new JpegColorConverterBase.YCbCrVector(8),
-                3,
-                FeatureTestRunner.Deserialize<int>(arg),
-                new JpegColorConverterBase.YCbCrScalar(8));
-    }
-
-    [Theory]
-    [MemberData(nameof(Seeds))]
-    public void FromCmykBasic(int seed) =>
-        this.TestConversionToRgb(new JpegColorConverterBase.CmykScalar(8), 4, seed);
+            new JpegColorConverterBase.YCbCrScalar(8));
 
     [Theory]
     [MemberData(nameof(Seeds))]
-    public void FromCmykVector(int seed)
-    {
-        JpegColorConverterBase.CmykVector converter = new(8);
-
-        if (!converter.IsAvailable)
-        {
-            this.Output.WriteLine(
-                $"Skipping test - {converter.GetType().Name} is not supported on current hardware.");
-            return;
-        }
-
-        FeatureTestRunner.RunWithHwIntrinsicsFeature(
-            RunTest,
+    public void FromYCbCrVector256(int seed) =>
+        this.TestConversionToRgb(
+            new JpegColorConverterBase.YCbCrVector256(8),
+            3,
             seed,
-            IntrinsicsConfig);
-
-        static void RunTest(string arg) =>
-            ValidateConversionToRgb(
-                new JpegColorConverterBase.CmykVector(8),
-                4,
-                FeatureTestRunner.Deserialize<int>(arg),
-                new JpegColorConverterBase.CmykScalar(8));
-    }
+            new JpegColorConverterBase.YCbCrScalar(8));
 
     [Theory]
     [MemberData(nameof(Seeds))]
-    public void FromGrayscaleBasic(int seed) =>
-        this.TestConversionToRgb(new JpegColorConverterBase.GrayscaleScalar(8), 1, seed);
+    public void FromYCbCrVector128(int seed) =>
+        this.TestConversionToRgb(
+            new JpegColorConverterBase.YCbCrVector128(8),
+            3,
+            seed,
+            new JpegColorConverterBase.YCbCrScalar(8));
 
     [Theory]
     [MemberData(nameof(Seeds))]
-    public void FromGrayscaleVector(int seed)
-    {
-        JpegColorConverterBase.GrayScaleVector converter = new(8);
-
-        if (!converter.IsAvailable)
-        {
-            this.Output.WriteLine(
-                $"Skipping test - {converter.GetType().Name} is not supported on current hardware.");
-            return;
-        }
-
-        FeatureTestRunner.RunWithHwIntrinsicsFeature(
-            RunTest,
+    public void FromRgbToYCbCrVector512(int seed) =>
+        this.TestConversionFromRgb(
+            new JpegColorConverterBase.YCbCrVector512(8),
+            3,
             seed,
-            IntrinsicsConfig);
-
-        static void RunTest(string arg) =>
-            ValidateConversionToRgb(
-                new JpegColorConverterBase.GrayScaleVector(8),
-                1,
-                FeatureTestRunner.Deserialize<int>(arg),
-                new JpegColorConverterBase.GrayscaleScalar(8));
-    }
+            new JpegColorConverterBase.YCbCrScalar(8),
+            precision: 2);
 
     [Theory]
     [MemberData(nameof(Seeds))]
-    public void FromRgbBasic(int seed) =>
-        this.TestConversionToRgb(new JpegColorConverterBase.RgbScalar(8), 3, seed);
+    public void FromRgbToYCbCrVector256(int seed) =>
+    this.TestConversionFromRgb(
+        new JpegColorConverterBase.YCbCrVector256(8),
+        3,
+        seed,
+        new JpegColorConverterBase.YCbCrScalar(8),
+        precision: 2);
 
     [Theory]
     [MemberData(nameof(Seeds))]
-    public void FromRgbVector(int seed)
-    {
-        JpegColorConverterBase.RgbVector converter = new(8);
-
-        if (!converter.IsAvailable)
-        {
-            this.Output.WriteLine(
-                $"Skipping test - {converter.GetType().Name} is not supported on current hardware.");
-            return;
-        }
-
-        FeatureTestRunner.RunWithHwIntrinsicsFeature(
-            RunTest,
-            seed,
-            IntrinsicsConfig);
-
-        static void RunTest(string arg) =>
-            ValidateConversionToRgb(
-                new JpegColorConverterBase.RgbVector(8),
-                3,
-                FeatureTestRunner.Deserialize<int>(arg),
-                new JpegColorConverterBase.RgbScalar(8));
-    }
+    public void FromRgbToYCbCrVector128(int seed) =>
+    this.TestConversionFromRgb(
+        new JpegColorConverterBase.YCbCrVector128(8),
+        3,
+        seed,
+        new JpegColorConverterBase.YCbCrScalar(8),
+        precision: 2);
 
     [Theory]
     [MemberData(nameof(Seeds))]
-    public void FromYccKBasic(int seed) =>
-        this.TestConversionToRgb(new JpegColorConverterBase.YccKScalar(8), 4, seed);
+    public void FromCmykBasic(int seed) =>
+        this.TestConversionToRgb(new JpegColorConverterBase.CmykScalar(8), 4, seed);
 
     [Theory]
     [MemberData(nameof(Seeds))]
-    public void FromYccKVector(int seed)
-    {
-        JpegColorConverterBase.YccKVector converter = new(8);
-
-        if (!converter.IsAvailable)
-        {
-            this.Output.WriteLine(
-                $"Skipping test - {converter.GetType().Name} is not supported on current hardware.");
-            return;
-        }
-
-        FeatureTestRunner.RunWithHwIntrinsicsFeature(
-            RunTest,
+    public void FromCmykVector512(int seed) =>
+        this.TestConversionToRgb(
+            new JpegColorConverterBase.CmykVector512(8),
+            4,
             seed,
-            IntrinsicsConfig);
-
-        static void RunTest(string arg) =>
-            ValidateConversionToRgb(
-                new JpegColorConverterBase.YccKVector(8),
-                4,
-                FeatureTestRunner.Deserialize<int>(arg),
-                new JpegColorConverterBase.YccKScalar(8));
-    }
+            new JpegColorConverterBase.CmykScalar(8));
 
     [Theory]
     [MemberData(nameof(Seeds))]
-    public void FromYCbCrAvx2(int seed) =>
+    public void FromCmykVector256(int seed) =>
         this.TestConversionToRgb(
-            new JpegColorConverterBase.YCbCrAvx(8),
-            3,
+            new JpegColorConverterBase.CmykVector256(8),
+            4,
             seed,
-            new JpegColorConverterBase.YCbCrScalar(8));
+            new JpegColorConverterBase.CmykScalar(8));
 
     [Theory]
     [MemberData(nameof(Seeds))]
-    public void FromRgbToYCbCrAvx2(int seed) =>
-        this.TestConversionFromRgb(
-            new JpegColorConverterBase.YCbCrAvx(8),
-            3,
+    public void FromCmykVector128(int seed) =>
+        this.TestConversionToRgb(
+            new JpegColorConverterBase.CmykVector128(8),
+            4,
             seed,
-            new JpegColorConverterBase.YCbCrScalar(8),
-            precísion: 2);
+            new JpegColorConverterBase.CmykScalar(8));
 
     [Theory]
     [MemberData(nameof(Seeds))]
-    public void FromYCbCrArm(int seed) =>
-        this.TestConversionToRgb(
-            new JpegColorConverterBase.YCbCrArm(8),
-            3,
+    public void FromRgbToCmykVector512(int seed) =>
+        this.TestConversionFromRgb(
+            new JpegColorConverterBase.CmykVector512(8),
+            4,
             seed,
-            new JpegColorConverterBase.YCbCrScalar(8));
+            new JpegColorConverterBase.CmykScalar(8),
+            precision: 2);
 
     [Theory]
     [MemberData(nameof(Seeds))]
-    public void FromRgbToYCbCrArm(int seed) =>
-        this.TestConversionFromRgb(
-            new JpegColorConverterBase.YCbCrArm(8),
-            3,
-            seed,
-            new JpegColorConverterBase.YCbCrScalar(8),
-            precísion: 2);
+    public void FromRgbToCmykVector256(int seed) =>
+    this.TestConversionFromRgb(
+        new JpegColorConverterBase.CmykVector256(8),
+        4,
+        seed,
+        new JpegColorConverterBase.CmykScalar(8),
+        precision: 2);
 
     [Theory]
     [MemberData(nameof(Seeds))]
-    public void FromCmykAvx2(int seed) =>
-        this.TestConversionToRgb(
-            new JpegColorConverterBase.CmykAvx(8),
-            4,
-            seed,
-            new JpegColorConverterBase.CmykScalar(8));
+    public void FromRgbToCmykVector128(int seed) =>
+    this.TestConversionFromRgb(
+        new JpegColorConverterBase.CmykVector128(8),
+        4,
+        seed,
+        new JpegColorConverterBase.CmykScalar(8),
+        precision: 2);
 
     [Theory]
     [MemberData(nameof(Seeds))]
-    public void FromRgbToCmykAvx2(int seed) =>
-        this.TestConversionFromRgb(
-            new JpegColorConverterBase.CmykAvx(8),
-            4,
-            seed,
-            new JpegColorConverterBase.CmykScalar(8),
-            precísion: 4);
+    public void FromGrayScaleBasic(int seed) =>
+        this.TestConversionToRgb(new JpegColorConverterBase.GrayScaleScalar(8), 1, seed);
 
     [Theory]
     [MemberData(nameof(Seeds))]
-    public void FromCmykArm(int seed) =>
+    public void FromGrayScaleVector512(int seed) =>
         this.TestConversionToRgb(
-            new JpegColorConverterBase.CmykArm64(8),
-            4,
+            new JpegColorConverterBase.GrayScaleVector512(8),
+            1,
             seed,
-            new JpegColorConverterBase.CmykScalar(8));
+            new JpegColorConverterBase.GrayScaleScalar(8));
 
     [Theory]
     [MemberData(nameof(Seeds))]
-    public void FromRgbToCmykArm(int seed) =>
-        this.TestConversionFromRgb(
-            new JpegColorConverterBase.CmykArm64(8),
-            4,
+    public void FromGrayScaleVector256(int seed) =>
+        this.TestConversionToRgb(
+            new JpegColorConverterBase.GrayScaleVector256(8),
+            1,
             seed,
-            new JpegColorConverterBase.CmykScalar(8),
-            precísion: 4);
+            new JpegColorConverterBase.GrayScaleScalar(8));
 
     [Theory]
     [MemberData(nameof(Seeds))]
-    public void FromGrayscaleAvx2(int seed) =>
+    public void FromGrayScaleVector128(int seed) =>
         this.TestConversionToRgb(
-            new JpegColorConverterBase.GrayscaleAvx(8),
+            new JpegColorConverterBase.GrayScaleVector128(8),
             1,
             seed,
-            new JpegColorConverterBase.GrayscaleScalar(8));
+            new JpegColorConverterBase.GrayScaleScalar(8));
 
     [Theory]
     [MemberData(nameof(Seeds))]
-    public void FromRgbToGrayscaleAvx2(int seed) =>
+    public void FromRgbToGrayScaleVector512(int seed) =>
         this.TestConversionFromRgb(
-            new JpegColorConverterBase.GrayscaleAvx(8),
+            new JpegColorConverterBase.GrayScaleVector512(8),
             1,
             seed,
-            new JpegColorConverterBase.GrayscaleScalar(8),
-            precísion: 3);
+            new JpegColorConverterBase.GrayScaleScalar(8),
+            precision: 2);
 
     [Theory]
     [MemberData(nameof(Seeds))]
-    public void FromGrayscaleArm(int seed) =>
-        this.TestConversionToRgb(
-            new JpegColorConverterBase.GrayscaleArm(8),
-            1,
-            seed,
-            new JpegColorConverterBase.GrayscaleScalar(8));
+    public void FromRgbToGrayScaleVector256(int seed) =>
+    this.TestConversionFromRgb(
+        new JpegColorConverterBase.GrayScaleVector256(8),
+        1,
+        seed,
+        new JpegColorConverterBase.GrayScaleScalar(8),
+        precision: 2);
 
     [Theory]
     [MemberData(nameof(Seeds))]
-    public void FromRgbToGrayscaleArm(int seed) =>
-        this.TestConversionFromRgb(
-            new JpegColorConverterBase.GrayscaleArm(8),
-            1,
+    public void FromRgbToGrayScaleVector128(int seed) =>
+    this.TestConversionFromRgb(
+        new JpegColorConverterBase.GrayScaleVector128(8),
+        1,
+        seed,
+        new JpegColorConverterBase.GrayScaleScalar(8),
+        precision: 2);
+
+    [Theory]
+    [MemberData(nameof(Seeds))]
+    public void FromRgbBasic(int seed) =>
+        this.TestConversionToRgb(new JpegColorConverterBase.RgbScalar(8), 3, seed);
+
+    [Theory]
+    [MemberData(nameof(Seeds))]
+    public void FromRgbVector512(int seed) =>
+        this.TestConversionToRgb(
+            new JpegColorConverterBase.RgbVector512(8),
+            3,
             seed,
-            new JpegColorConverterBase.GrayscaleScalar(8),
-            precísion: 3);
+            new JpegColorConverterBase.RgbScalar(8));
 
     [Theory]
     [MemberData(nameof(Seeds))]
-    public void FromRgbAvx2(int seed) =>
+    public void FromRgbVector256(int seed) =>
         this.TestConversionToRgb(
-            new JpegColorConverterBase.RgbAvx(8),
+            new JpegColorConverterBase.RgbVector256(8),
             3,
             seed,
             new JpegColorConverterBase.RgbScalar(8));
 
     [Theory]
     [MemberData(nameof(Seeds))]
-    public void FromRgbArm(int seed) =>
+    public void FromRgbVector128(int seed) =>
         this.TestConversionToRgb(
-            new JpegColorConverterBase.RgbArm(8),
+            new JpegColorConverterBase.RgbVector128(8),
             3,
             seed,
             new JpegColorConverterBase.RgbScalar(8));
 
     [Theory]
     [MemberData(nameof(Seeds))]
-    public void FromYccKAvx2(int seed) =>
+    public void FromRgbToRgbVector512(int seed) =>
+        this.TestConversionFromRgb(
+            new JpegColorConverterBase.RgbVector512(8),
+            3,
+            seed,
+            new JpegColorConverterBase.RgbScalar(8),
+            precision: 2);
+
+    [Theory]
+    [MemberData(nameof(Seeds))]
+    public void FromRgbToRgbVector256(int seed) =>
+    this.TestConversionFromRgb(
+        new JpegColorConverterBase.RgbVector256(8),
+        3,
+        seed,
+        new JpegColorConverterBase.RgbScalar(8),
+        precision: 2);
+
+    [Theory]
+    [MemberData(nameof(Seeds))]
+    public void FromRgbToRgbVector128(int seed) =>
+    this.TestConversionFromRgb(
+        new JpegColorConverterBase.RgbVector128(8),
+        3,
+        seed,
+        new JpegColorConverterBase.RgbScalar(8),
+        precision: 2);
+
+    [Theory]
+    [MemberData(nameof(Seeds))]
+    public void FromYccKBasic(int seed) =>
+        this.TestConversionToRgb(new JpegColorConverterBase.YccKScalar(8), 4, seed);
+
+    [Theory]
+    [MemberData(nameof(Seeds))]
+    public void FromYccKVector512(int seed) =>
         this.TestConversionToRgb(
-            new JpegColorConverterBase.YccKAvx(8),
+            new JpegColorConverterBase.YccKVector512(8),
             4,
             seed,
             new JpegColorConverterBase.YccKScalar(8));
 
     [Theory]
     [MemberData(nameof(Seeds))]
-    public void FromRgbToYccKAvx2(int seed) =>
-        this.TestConversionFromRgb(
-            new JpegColorConverterBase.YccKAvx(8),
+    public void FromYccKVector256(int seed) =>
+        this.TestConversionToRgb(
+            new JpegColorConverterBase.YccKVector256(8),
             4,
             seed,
-            new JpegColorConverterBase.YccKScalar(8),
-            precísion: 4);
+            new JpegColorConverterBase.YccKScalar(8));
 
     [Theory]
     [MemberData(nameof(Seeds))]
-    public void FromYccKArm64(int seed) =>
+    public void FromYccKVector128(int seed) =>
         this.TestConversionToRgb(
-            new JpegColorConverterBase.YccKArm64(8),
+            new JpegColorConverterBase.YccKVector128(8),
             4,
             seed,
             new JpegColorConverterBase.YccKScalar(8));
 
     [Theory]
     [MemberData(nameof(Seeds))]
-    public void FromRgbToYccKArm64(int seed) =>
+    public void FromRgbToYccKVector512(int seed) =>
         this.TestConversionFromRgb(
-            new JpegColorConverterBase.YccKArm64(8),
+            new JpegColorConverterBase.YccKVector512(8),
             4,
             seed,
             new JpegColorConverterBase.YccKScalar(8),
-            precísion: 4);
+            precision: 2);
+
+    [Theory]
+    [MemberData(nameof(Seeds))]
+    public void FromRgbToYccKVector256(int seed) =>
+    this.TestConversionFromRgb(
+        new JpegColorConverterBase.YccKVector256(8),
+        4,
+        seed,
+        new JpegColorConverterBase.YccKScalar(8),
+        precision: 2);
+
+    [Theory]
+    [MemberData(nameof(Seeds))]
+    public void FromRgbToYccKVector128(int seed) =>
+    this.TestConversionFromRgb(
+        new JpegColorConverterBase.YccKVector128(8),
+        4,
+        seed,
+        new JpegColorConverterBase.YccKScalar(8),
+        precision: 2);
 
     private void TestConversionToRgb(
         JpegColorConverterBase converter,
@@ -600,7 +583,7 @@ public class JpegColorConverterTests
         int componentCount,
         int seed,
         JpegColorConverterBase baseLineConverter,
-        int precísion)
+        int precision)
     {
         if (!converter.IsAvailable)
         {
@@ -614,7 +597,7 @@ public class JpegColorConverterTests
             componentCount,
             seed,
             baseLineConverter,
-            precísion);
+            precision);
     }
 
     private static JpegColorConverterBase.ComponentValues CreateRandomValues(
@@ -669,7 +652,7 @@ public class JpegColorConverterTests
                 original.Component2.ToArray(),
                 original.Component3.ToArray());
 
-        converter.ConvertToRgbInplace(actual);
+        converter.ConvertToRgbInPlace(actual);
 
         for (int i = 0; i < TestBufferLength; i++)
         {
@@ -685,7 +668,7 @@ public class JpegColorConverterTests
                 original.Component1.ToArray(),
                 original.Component2.ToArray(),
                 original.Component3.ToArray());
-            baseLineConverter.ConvertToRgbInplace(expected);
+            baseLineConverter.ConvertToRgbInPlace(expected);
             if (componentCount == 1)
             {
                 Assert.True(expected.Component0.SequenceEqual(actual.Component0));
@@ -769,7 +752,7 @@ public class JpegColorConverterTests
                 ValidateGrayScale(original, result, i);
                 break;
             case JpegColorSpace.Ycck:
-                ValidateCyyK(original, result, i);
+                ValidateYccK(original, result, i);
                 break;
             case JpegColorSpace.Cmyk:
                 ValidateCmyk(original, result, i);
@@ -781,7 +764,7 @@ public class JpegColorConverterTests
                 ValidateYCbCr(original, result, i);
                 break;
             default:
-                Assert.True(false, $"Invalid Colorspace enum value: {colorSpace}.");
+                Assert.Fail($"Invalid Colorspace enum value: {colorSpace}.");
                 break;
         }
     }
@@ -789,17 +772,25 @@ public class JpegColorConverterTests
     private static void ValidateYCbCr(in JpegColorConverterBase.ComponentValues values, in JpegColorConverterBase.ComponentValues result, int i)
     {
         float y = values.Component0[i];
-        float cb = values.Component1[i];
-        float cr = values.Component2[i];
-        Rgb expected = ColorSpaceConverter.Convert<YCbCr, Rgb>(new YCbCr(y, cb, cr));
+        float cb = values.Component1[i] - 128;
+        float cr = values.Component2[i] - 128;
+
+        float r = (float)Math.Round(y + (1.402F * cr), MidpointRounding.AwayFromZero);
+        float g = (float)Math.Round(y - (0.344136F * cb) - (0.714136F * cr), MidpointRounding.AwayFromZero);
+        float b = (float)Math.Round(y + (1.772F * cb), MidpointRounding.AwayFromZero);
+
+        r /= MaxColorChannelValue;
+        g /= MaxColorChannelValue;
+        b /= MaxColorChannelValue;
 
-        Rgb actual = Rgb.Clamp(new(result.Component0[i], result.Component1[i], result.Component2[i]));
+        Rgb expected = Rgb.Clamp(new Rgb(r, g, b));
+        Rgb actual = Rgb.Clamp(new Rgb(result.Component0[i], result.Component1[i], result.Component2[i]));
 
         bool equal = ColorSpaceComparer.Equals(expected, actual);
         Assert.True(equal, $"Colors {expected} and {actual} are not equal at index {i}");
     }
 
-    private static void ValidateCyyK(in JpegColorConverterBase.ComponentValues values, in JpegColorConverterBase.ComponentValues result, int i)
+    private static void ValidateYccK(in JpegColorConverterBase.ComponentValues values, in JpegColorConverterBase.ComponentValues result, int i)
     {
         float y = values.Component0[i];
         float cb = values.Component1[i] - 128F;
@@ -807,17 +798,15 @@ public class JpegColorConverterTests
         float k = values.Component3[i] / 255F;
 
         float r = (255F - (float)Math.Round(y + (1.402F * cr), MidpointRounding.AwayFromZero)) * k;
-        float g = (255F - (float)Math.Round(
-            y - (0.344136F * cb) - (0.714136F * cr),
-            MidpointRounding.AwayFromZero)) * k;
+        float g = (255F - (float)Math.Round(y - (0.344136F * cb) - (0.714136F * cr), MidpointRounding.AwayFromZero)) * k;
         float b = (255F - (float)Math.Round(y + (1.772F * cb), MidpointRounding.AwayFromZero)) * k;
 
         r /= MaxColorChannelValue;
         g /= MaxColorChannelValue;
         b /= MaxColorChannelValue;
-        Rgb expected = Rgb.Clamp(new(r, g, b));
+        Rgb expected = Rgb.Clamp(new Rgb(r, g, b));
 
-        Rgb actual = Rgb.Clamp(new(result.Component0[i], result.Component1[i], result.Component2[i]));
+        Rgb actual = Rgb.Clamp(new Rgb(result.Component0[i], result.Component1[i], result.Component2[i]));
 
         bool equal = ColorSpaceComparer.Equals(expected, actual);
         Assert.True(equal, $"Colors {expected} and {actual} are not equal at index {i}");
@@ -828,9 +817,9 @@ public class JpegColorConverterTests
         float r = values.Component0[i] / MaxColorChannelValue;
         float g = values.Component1[i] / MaxColorChannelValue;
         float b = values.Component2[i] / MaxColorChannelValue;
-        Rgb expected = Rgb.Clamp(new(r, g, b));
+        Rgb expected = Rgb.Clamp(new Rgb(r, g, b));
 
-        Rgb actual = Rgb.Clamp(new(result.Component0[i], result.Component1[i], result.Component2[i]));
+        Rgb actual = Rgb.Clamp(new Rgb(result.Component0[i], result.Component1[i], result.Component2[i]));
 
         bool equal = ColorSpaceComparer.Equals(expected, actual);
         Assert.True(equal, $"Colors {expected} and {actual} are not equal at index {i}");
@@ -839,9 +828,9 @@ public class JpegColorConverterTests
     private static void ValidateGrayScale(in JpegColorConverterBase.ComponentValues values, in JpegColorConverterBase.ComponentValues result, int i)
     {
         float y = values.Component0[i] / MaxColorChannelValue;
-        Rgb expected = Rgb.Clamp(new(y, y, y));
+        Rgb expected = Rgb.Clamp(new Rgb(y, y, y));
 
-        Rgb actual = Rgb.Clamp(new(result.Component0[i], result.Component0[i], result.Component0[i]));
+        Rgb actual = Rgb.Clamp(new Rgb(result.Component0[i], result.Component0[i], result.Component0[i]));
 
         bool equal = ColorSpaceComparer.Equals(expected, actual);
         Assert.True(equal, $"Colors {expected} and {actual} are not equal at index {i}");
@@ -857,9 +846,9 @@ public class JpegColorConverterTests
         float r = c * k / MaxColorChannelValue;
         float g = m * k / MaxColorChannelValue;
         float b = y * k / MaxColorChannelValue;
-        Rgb expected = Rgb.Clamp(new(r, g, b));
+        Rgb expected = Rgb.Clamp(new Rgb(r, g, b));
 
-        Rgb actual = Rgb.Clamp(new(result.Component0[i], result.Component1[i], result.Component2[i]));
+        Rgb actual = Rgb.Clamp(new Rgb(result.Component0[i], result.Component1[i], result.Component2[i]));
 
         bool equal = ColorSpaceComparer.Equals(expected, actual);
         Assert.True(equal, $"Colors {expected} and {actual} are not equal at index {i}");
diff --git a/tests/ImageSharp.Tests/Formats/Jpg/JpegDecoderTests.Images.cs b/tests/ImageSharp.Tests/Formats/Jpg/JpegDecoderTests.Images.cs
index 85fad3f826..a4a71c6731 100644
--- a/tests/ImageSharp.Tests/Formats/Jpg/JpegDecoderTests.Images.cs
+++ b/tests/ImageSharp.Tests/Formats/Jpg/JpegDecoderTests.Images.cs
@@ -7,7 +7,7 @@ namespace SixLabors.ImageSharp.Tests.Formats.Jpg;
 public partial class JpegDecoderTests
 {
     public static string[] BaselineTestJpegs =
-    {
+    [
         TestImages.Jpeg.Baseline.Calliphora,
         TestImages.Jpeg.Baseline.Cmyk,
         TestImages.Jpeg.Baseline.Ycck,
@@ -41,11 +41,11 @@ public partial class JpegDecoderTests
         TestImages.Jpeg.Baseline.Testorig12bit,
 
         // Grayscale jpeg with 2x2 sampling factors (not a usual thing to encounter in the wild)
-        TestImages.Jpeg.Baseline.GrayscaleSampling2x2,
-    };
+        TestImages.Jpeg.Baseline.GrayscaleSampling2x2
+    ];
 
     public static string[] ProgressiveTestJpegs =
-    {
+    [
         TestImages.Jpeg.Progressive.Fb,
         TestImages.Jpeg.Progressive.Progress,
         TestImages.Jpeg.Progressive.Festzug,
@@ -61,20 +61,20 @@ public partial class JpegDecoderTests
         TestImages.Jpeg.Issues.OrderedInterleavedProgressive723A,
         TestImages.Jpeg.Issues.OrderedInterleavedProgressive723B,
         TestImages.Jpeg.Issues.OrderedInterleavedProgressive723C
-    };
+    ];
 
     public static string[] UnsupportedTestJpegs =
-    {
+    [
         // Invalid componentCount value (2 or > 4)
         TestImages.Jpeg.Issues.Fuzz.NullReferenceException823,
         TestImages.Jpeg.Issues.MalformedUnsupportedComponentCount,
 
         // Lossless jpeg
         TestImages.Jpeg.Baseline.Lossless
-    };
+    ];
 
     public static string[] UnrecoverableTestJpegs =
-    {
+    [
         TestImages.Jpeg.Issues.CriticalEOF214,
         TestImages.Jpeg.Issues.Fuzz.NullReferenceException797,
         TestImages.Jpeg.Issues.Fuzz.AccessViolationException798,
@@ -98,8 +98,8 @@ public partial class JpegDecoderTests
         TestImages.Jpeg.Issues.Fuzz.IndexOutOfRangeException1693A,
         TestImages.Jpeg.Issues.Fuzz.IndexOutOfRangeException1693B,
         TestImages.Jpeg.Issues.Fuzz.IndexOutOfRangeException824C,
-        TestImages.Jpeg.Issues.Fuzz.NullReferenceException2085,
-    };
+        TestImages.Jpeg.Issues.Fuzz.NullReferenceException2085
+    ];
 
     private static readonly Dictionary<string, float> CustomToleranceValues = new()
     {
diff --git a/tests/ImageSharp.Tests/Formats/Jpg/JpegDecoderTests.Internal.cs b/tests/ImageSharp.Tests/Formats/Jpg/JpegDecoderTests.Internal.cs
index 6cf6250cb1..b780b14fb1 100644
--- a/tests/ImageSharp.Tests/Formats/Jpg/JpegDecoderTests.Internal.cs
+++ b/tests/ImageSharp.Tests/Formats/Jpg/JpegDecoderTests.Internal.cs
@@ -19,7 +19,7 @@ public partial class JpegDecoderTests
     [InlineData(4, JpegConstants.Adobe.ColorTransformYcck, JpegColorSpace.Ycck)]
     internal void DeduceJpegColorSpaceAdobeMarker_ShouldReturnValidColorSpace(byte componentCount, byte adobeFlag, JpegColorSpace expectedColorSpace)
     {
-        byte[] adobeMarkerPayload = new byte[] { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, adobeFlag };
+        byte[] adobeMarkerPayload = [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, adobeFlag];
         ProfileResolver.AdobeMarker.CopyTo(adobeMarkerPayload);
         _ = AdobeMarker.TryParse(adobeMarkerPayload, out AdobeMarker adobeMarker);
 
diff --git a/tests/ImageSharp.Tests/Formats/Jpg/JpegDecoderTests.Metadata.cs b/tests/ImageSharp.Tests/Formats/Jpg/JpegDecoderTests.Metadata.cs
index a803372537..11c7dc86d1 100644
--- a/tests/ImageSharp.Tests/Formats/Jpg/JpegDecoderTests.Metadata.cs
+++ b/tests/ImageSharp.Tests/Formats/Jpg/JpegDecoderTests.Metadata.cs
@@ -439,9 +439,8 @@ public partial class JpegDecoderTests
         Assert.Equal(expectedComment, metadata.Comments.ElementAtOrDefault(0).ToString());
         image.DebugSave(provider);
         image.CompareToOriginal(provider);
-
     }
-    
+
     // https://github.com/SixLabors/ImageSharp/issues/2758
     [Theory]
     [WithFile(TestImages.Jpeg.Issues.Issue2758, PixelTypes.L8)]
@@ -462,12 +461,51 @@ public partial class JpegDecoderTests
         // We want to test the encoder to ensure the determined values can be encoded but not by encoding
         // the full size image as it would be too slow.
         // We will crop the image to a smaller size and then encode it.
-        image.Mutate(x => x.Crop(new(0, 0, 100, 100)));
+        image.Mutate(x => x.Crop(new Rectangle(0, 0, 100, 100)));
 
         using MemoryStream ms = new();
         image.Save(ms, new JpegEncoder());
     }
 
+    // https://github.com/SixLabors/ImageSharp/issues/2857
+    [Theory]
+    [WithFile(TestImages.Jpeg.Issues.Issue2857, PixelTypes.Rgb24)]
+    public void Issue2857_SubSubIfds<TPixel>(TestImageProvider<TPixel> provider)
+        where TPixel : unmanaged, IPixel<TPixel>
+    {
+        using Image<TPixel> image = provider.GetImage(JpegDecoder.Instance);
+
+        Assert.Equal(5616, image.Width);
+        Assert.Equal(3744, image.Height);
+
+        JpegMetadata meta = image.Metadata.GetJpegMetadata();
+        Assert.Equal(92, meta.LuminanceQuality);
+        Assert.Equal(93, meta.ChrominanceQuality);
+
+        ExifProfile exifProfile = image.Metadata.ExifProfile;
+        Assert.NotNull(exifProfile);
+
+        using MemoryStream ms = new();
+        bool hasThumbnail = exifProfile.TryCreateThumbnail(out _);
+        Assert.False(hasThumbnail);
+
+        Assert.Equal("BilderBox - Erwin Wodicka / wodicka@aon.at", exifProfile.GetValue(ExifTag.Copyright).Value);
+        Assert.Equal("Adobe Photoshop CS3 Windows", exifProfile.GetValue(ExifTag.Software).Value);
+
+        Assert.Equal("Carers; seniors; caregiver; senior care; retirement home; hands; old; elderly; elderly caregiver; elder care; elderly care; geriatric care; nursing home; age; old age care; outpatient; needy; health care; home nurse; home care; sick; retirement; medical; mobile; the elderly; nursing department; nursing treatment; nursing; care services; nursing services; nursing care; nursing allowance; nursing homes; home nursing; care category; nursing class; care; nursing shortage; nursing patient care staff\0", exifProfile.GetValue(ExifTag.XPKeywords).Value);
+
+        Assert.Equal(
+            new EncodedString(EncodedString.CharacterCode.ASCII, "StockSubmitter|Miscellaneous||Miscellaneous$|00|0000330000000110000000000000000|22$@NA_1005010.460@145$$@Miscellaneous.Miscellaneous$$@$@26$$@$@$@$@205$@$@$@$@$@$@$@$@$@43$@$@$@$$@Miscellaneous.Miscellaneous$$@90$$@22$@$@$@$@$@$@$|||"),
+            exifProfile.GetValue(ExifTag.UserComment).Value);
+
+        // the profile contains 4 duplicated UserComment
+        Assert.Equal(1, exifProfile.Values.Count(t => t.Tag == ExifTag.UserComment));
+
+        image.Mutate(x => x.Crop(new Rectangle(0, 0, 100, 100)));
+
+        image.Save(ms, new JpegEncoder());
+    }
+
     private static void VerifyEncodedStrings(ExifProfile exif)
     {
         Assert.NotNull(exif);
diff --git a/tests/ImageSharp.Tests/Formats/Jpg/JpegDecoderTests.cs b/tests/ImageSharp.Tests/Formats/Jpg/JpegDecoderTests.cs
index 950265bd56..2856abe5c1 100644
--- a/tests/ImageSharp.Tests/Formats/Jpg/JpegDecoderTests.cs
+++ b/tests/ImageSharp.Tests/Formats/Jpg/JpegDecoderTests.cs
@@ -3,7 +3,6 @@
 
 using SixLabors.ImageSharp.Formats;
 using SixLabors.ImageSharp.Formats.Jpeg;
-using SixLabors.ImageSharp.IO;
 using SixLabors.ImageSharp.Memory;
 using SixLabors.ImageSharp.PixelFormats;
 using SixLabors.ImageSharp.Processing;
@@ -45,8 +44,8 @@ public partial class JpegDecoderTests
     private static bool SkipTest(ITestImageProvider provider)
     {
         string[] largeImagesToSkipOn32Bit =
-            {
-                TestImages.Jpeg.Baseline.Jpeg420Exif,
+        [
+            TestImages.Jpeg.Baseline.Jpeg420Exif,
                 TestImages.Jpeg.Issues.MissingFF00ProgressiveBedroom159,
                 TestImages.Jpeg.Issues.BadZigZagProgressive385,
                 TestImages.Jpeg.Issues.NoEoiProgressive517,
@@ -54,7 +53,7 @@ public partial class JpegDecoderTests
                 TestImages.Jpeg.Issues.InvalidEOI695,
                 TestImages.Jpeg.Issues.ExifResizeOutOfRange696,
                 TestImages.Jpeg.Issues.ExifGetString750Transform
-            };
+        ];
 
         return !TestEnvironment.Is64BitProcess && largeImagesToSkipOn32Bit.Contains(provider.SourceFileOrDescription);
     }
@@ -117,7 +116,7 @@ public partial class JpegDecoderTests
     public void JpegDecoder_Decode_Resize<TPixel>(TestImageProvider<TPixel> provider)
         where TPixel : unmanaged, IPixel<TPixel>
     {
-        DecoderOptions options = new() { TargetSize = new() { Width = 150, Height = 150 } };
+        DecoderOptions options = new() { TargetSize = new Size { Width = 150, Height = 150 } };
         using Image<TPixel> image = provider.GetImage(JpegDecoder.Instance, options);
 
         FormattableString details = $"{options.TargetSize.Value.Width}_{options.TargetSize.Value.Height}";
@@ -137,7 +136,7 @@ public partial class JpegDecoderTests
     {
         DecoderOptions options = new()
         {
-            TargetSize = new() { Width = 150, Height = 150 },
+            TargetSize = new Size { Width = 150, Height = 150 },
             Sampler = KnownResamplers.Bicubic
         };
         using Image<TPixel> image = provider.GetImage(JpegDecoder.Instance, options);
@@ -157,7 +156,7 @@ public partial class JpegDecoderTests
     public void JpegDecoder_Decode_Specialized_IDCT_Resize<TPixel>(TestImageProvider<TPixel> provider)
         where TPixel : unmanaged, IPixel<TPixel>
     {
-        DecoderOptions options = new() { TargetSize = new() { Width = 150, Height = 150 } };
+        DecoderOptions options = new() { TargetSize = new Size { Width = 150, Height = 150 } };
         JpegDecoderOptions specializedOptions = new()
         {
             GeneralOptions = options,
@@ -181,7 +180,7 @@ public partial class JpegDecoderTests
     public void JpegDecoder_Decode_Specialized_Scale_Resize<TPixel>(TestImageProvider<TPixel> provider)
         where TPixel : unmanaged, IPixel<TPixel>
     {
-        DecoderOptions options = new() { TargetSize = new() { Width = 150, Height = 150 } };
+        DecoderOptions options = new() { TargetSize = new Size { Width = 150, Height = 150 } };
         JpegDecoderOptions specializedOptions = new()
         {
             GeneralOptions = options,
@@ -205,7 +204,7 @@ public partial class JpegDecoderTests
     public void JpegDecoder_Decode_Specialized_Combined_Resize<TPixel>(TestImageProvider<TPixel> provider)
         where TPixel : unmanaged, IPixel<TPixel>
     {
-        DecoderOptions options = new() { TargetSize = new() { Width = 150, Height = 150 } };
+        DecoderOptions options = new() { TargetSize = new Size { Width = 150, Height = 150 } };
         JpegDecoderOptions specializedOptions = new()
         {
             GeneralOptions = options,
@@ -365,4 +364,54 @@ public partial class JpegDecoderTests
         image.DebugSave(provider);
         image.CompareToOriginal(provider);
     }
+
+    [Theory]
+    [WithFile(TestImages.Jpeg.ICC.CMYK, PixelTypes.Rgba32)]
+    public void Decode_CMYK_ICC_Jpeg<TPixel>(TestImageProvider<TPixel> provider)
+        where TPixel : unmanaged, IPixel<TPixel>
+    {
+        JpegDecoderOptions options = new()
+        {
+            GeneralOptions = new DecoderOptions { ColorProfileHandling = ColorProfileHandling.Convert }
+        };
+
+        using Image<TPixel> image = provider.GetImage(JpegDecoder.Instance, options);
+        image.DebugSave(provider);
+        image.CompareToReferenceOutput(provider);
+    }
+
+    [Theory]
+    [WithFile(TestImages.Jpeg.ICC.YCCK, PixelTypes.Rgba32)]
+    public void Decode_YCCK_ICC_Jpeg<TPixel>(TestImageProvider<TPixel> provider)
+        where TPixel : unmanaged, IPixel<TPixel>
+    {
+        JpegDecoderOptions options = new()
+        {
+            GeneralOptions = new DecoderOptions { ColorProfileHandling = ColorProfileHandling.Convert }
+        };
+
+        using Image<TPixel> image = provider.GetImage(JpegDecoder.Instance, options);
+        image.DebugSave(provider);
+        image.CompareToReferenceOutput(provider);
+    }
+
+    [Theory]
+    [WithFile(TestImages.Jpeg.ICC.SRgb, PixelTypes.Rgba32)]
+    [WithFile(TestImages.Jpeg.ICC.AdobeRgb, PixelTypes.Rgba32)]
+    [WithFile(TestImages.Jpeg.ICC.ColorMatch, PixelTypes.Rgba32)]
+    [WithFile(TestImages.Jpeg.ICC.ProPhoto, PixelTypes.Rgba32)]
+    [WithFile(TestImages.Jpeg.ICC.WideRGB, PixelTypes.Rgba32)]
+    [WithFile(TestImages.Jpeg.ICC.AppleRGB, PixelTypes.Rgba32)]
+    public void Decode_RGB_ICC_Jpeg<TPixel>(TestImageProvider<TPixel> provider)
+        where TPixel : unmanaged, IPixel<TPixel>
+    {
+        JpegDecoderOptions options = new()
+        {
+            GeneralOptions = new DecoderOptions { ColorProfileHandling = ColorProfileHandling.Convert }
+        };
+
+        using Image<TPixel> image = provider.GetImage(JpegDecoder.Instance, options);
+        image.DebugSave(provider);
+        image.CompareToReferenceOutput(provider);
+    }
 }
diff --git a/tests/ImageSharp.Tests/Formats/Jpg/JpegEncoderTests.Metadata.cs b/tests/ImageSharp.Tests/Formats/Jpg/JpegEncoderTests.Metadata.cs
index 039215bbc5..99322687cc 100644
--- a/tests/ImageSharp.Tests/Formats/Jpg/JpegEncoderTests.Metadata.cs
+++ b/tests/ImageSharp.Tests/Formats/Jpg/JpegEncoderTests.Metadata.cs
@@ -7,6 +7,7 @@ using SixLabors.ImageSharp.Metadata.Profiles.Exif;
 using SixLabors.ImageSharp.Metadata.Profiles.Icc;
 using SixLabors.ImageSharp.Metadata.Profiles.Iptc;
 using SixLabors.ImageSharp.PixelFormats;
+using SixLabors.ImageSharp.Tests.TestDataIcc;
 
 namespace SixLabors.ImageSharp.Tests.Formats.Jpg;
 
@@ -77,7 +78,7 @@ public partial class JpegEncoderTests
     {
         // arrange
         using Image<Rgba32> input = new(1, 1);
-        input.Metadata.IccProfile = new IccProfile(IccTestDataProfiles.Profile_Random_Array);
+        input.Metadata.IccProfile = new IccProfile(IccTestDataProfiles.ProfileRandomArray);
 
         // act
         using MemoryStream memStream = new();
diff --git a/tests/ImageSharp.Tests/Formats/Jpg/JpegEncoderTests.cs b/tests/ImageSharp.Tests/Formats/Jpg/JpegEncoderTests.cs
index 58b437af0f..ede147dbe9 100644
--- a/tests/ImageSharp.Tests/Formats/Jpg/JpegEncoderTests.cs
+++ b/tests/ImageSharp.Tests/Formats/Jpg/JpegEncoderTests.cs
@@ -258,8 +258,8 @@ where TPixel : unmanaged, IPixel<TPixel>
         using Image<TPixel> image = provider.GetImage();
         image.Mutate(x => x.Crop(132, 1606));
 
-        int[] quality = new int[] { 100, 50 };
-        JpegColorType[] colors = new[] { JpegColorType.YCbCrRatio444, JpegColorType.YCbCrRatio420 };
+        int[] quality = [100, 50];
+        JpegColorType[] colors = [JpegColorType.YCbCrRatio444, JpegColorType.YCbCrRatio420];
         for (int i = 0; i < quality.Length; i++)
         {
             int q = quality[i];
diff --git a/tests/ImageSharp.Tests/Formats/Jpg/JpegFileMarkerTests.cs b/tests/ImageSharp.Tests/Formats/Jpg/JpegFileMarkerTests.cs
index df74d266cb..62362ec801 100644
--- a/tests/ImageSharp.Tests/Formats/Jpg/JpegFileMarkerTests.cs
+++ b/tests/ImageSharp.Tests/Formats/Jpg/JpegFileMarkerTests.cs
@@ -14,7 +14,7 @@ public class JpegFileMarkerTests
     {
         const byte app1 = JpegConstants.Markers.APP1;
         const int position = 5;
-        var marker = new JpegFileMarker(app1, position);
+        JpegFileMarker marker = new(app1, position);
 
         Assert.Equal(app1, marker.Marker);
         Assert.Equal(position, marker.Position);
diff --git a/tests/ImageSharp.Tests/Formats/Jpg/JpegMetadataTests.cs b/tests/ImageSharp.Tests/Formats/Jpg/JpegMetadataTests.cs
index 19b5265a17..37be0f8f56 100644
--- a/tests/ImageSharp.Tests/Formats/Jpg/JpegMetadataTests.cs
+++ b/tests/ImageSharp.Tests/Formats/Jpg/JpegMetadataTests.cs
@@ -12,8 +12,8 @@ public class JpegMetadataTests
     [Fact]
     public void CloneIsDeep()
     {
-        var meta = new JpegMetadata { ColorType = JpegColorType.Luminance };
-        var clone = (JpegMetadata)meta.DeepClone();
+        JpegMetadata meta = new() { ColorType = JpegColorType.Luminance };
+        JpegMetadata clone = (JpegMetadata)meta.DeepClone();
 
         clone.ColorType = JpegColorType.YCbCrRatio420;
 
@@ -23,7 +23,7 @@ public class JpegMetadataTests
     [Fact]
     public void Quality_DefaultQuality()
     {
-        var meta = new JpegMetadata();
+        JpegMetadata meta = new();
 
         Assert.Equal(meta.Quality, ImageSharp.Formats.Jpeg.Components.Quantization.DefaultQualityFactor);
     }
@@ -33,7 +33,7 @@ public class JpegMetadataTests
     {
         int quality = 50;
 
-        var meta = new JpegMetadata { LuminanceQuality = quality };
+        JpegMetadata meta = new() { LuminanceQuality = quality };
 
         Assert.Equal(meta.Quality, quality);
     }
@@ -43,7 +43,7 @@ public class JpegMetadataTests
     {
         int quality = 50;
 
-        var meta = new JpegMetadata { LuminanceQuality = quality, ChrominanceQuality = quality };
+        JpegMetadata meta = new() { LuminanceQuality = quality, ChrominanceQuality = quality };
 
         Assert.Equal(meta.Quality, quality);
     }
@@ -54,7 +54,7 @@ public class JpegMetadataTests
         int qualityLuma = 50;
         int qualityChroma = 30;
 
-        var meta = new JpegMetadata { LuminanceQuality = qualityLuma, ChrominanceQuality = qualityChroma };
+        JpegMetadata meta = new() { LuminanceQuality = qualityLuma, ChrominanceQuality = qualityChroma };
 
         Assert.Equal(meta.Quality, qualityLuma);
     }
@@ -62,7 +62,7 @@ public class JpegMetadataTests
     [Fact]
     public void Comment_EmptyComment()
     {
-        var meta = new JpegMetadata();
+        JpegMetadata meta = new();
 
         Assert.True(Array.Empty<JpegComData>().SequenceEqual(meta.Comments));
     }
@@ -71,9 +71,9 @@ public class JpegMetadataTests
     public void Comment_OnlyComment()
     {
         string comment = "test comment";
-        var expectedCollection = new Collection<string> { comment };
+        Collection<string> expectedCollection = new() { comment };
 
-        var meta = new JpegMetadata();
+        JpegMetadata meta = new();
         meta.Comments.Add(JpegComData.FromString(comment));
 
         Assert.Equal(1, meta.Comments.Count);
diff --git a/tests/ImageSharp.Tests/Formats/Jpg/ParseStreamTests.cs b/tests/ImageSharp.Tests/Formats/Jpg/ParseStreamTests.cs
index b202fd9ec3..b6a59fa93e 100644
--- a/tests/ImageSharp.Tests/Formats/Jpg/ParseStreamTests.cs
+++ b/tests/ImageSharp.Tests/Formats/Jpg/ParseStreamTests.cs
@@ -27,7 +27,7 @@ public class ParseStreamTests
     [InlineData(TestImages.Jpeg.Baseline.Cmyk, JpegColorSpace.Cmyk)]
     public void ColorSpace_IsDeducedCorrectly(string imageFile, object expectedColorSpaceValue)
     {
-        var expectedColorSpace = (JpegColorSpace)expectedColorSpaceValue;
+        JpegColorSpace expectedColorSpace = (JpegColorSpace)expectedColorSpaceValue;
 
         using (JpegDecoderCore decoder = JpegFixture.ParseJpegStream(imageFile, metaDataOnly: true))
         {
@@ -47,7 +47,7 @@ public class ParseStreamTests
 
             Assert.Equal(expectedSizeInBlocks, decoder.Frame.McuSize);
 
-            var uniform1 = new Size(1, 1);
+            Size uniform1 = new(1, 1);
             IJpegComponent c0 = decoder.Components[0];
             VerifyJpeg.VerifyComponent(c0, expectedSizeInBlocks, uniform1, uniform1);
         }
@@ -62,7 +62,7 @@ public class ParseStreamTests
     [InlineData(TestImages.Jpeg.Baseline.Cmyk)]
     public void PrintComponentData(string imageFile)
     {
-        var sb = new StringBuilder();
+        StringBuilder sb = new();
 
         using (JpegDecoderCore decoder = JpegFixture.ParseJpegStream(imageFile))
         {
@@ -98,8 +98,8 @@ public class ParseStreamTests
         object expectedLumaFactors,
         object expectedChromaFactors)
     {
-        var fLuma = (Size)expectedLumaFactors;
-        var fChroma = (Size)expectedChromaFactors;
+        Size fLuma = (Size)expectedLumaFactors;
+        Size fChroma = (Size)expectedChromaFactors;
 
         using (JpegDecoderCore decoder = JpegFixture.ParseJpegStream(imageFile))
         {
@@ -110,7 +110,7 @@ public class ParseStreamTests
             IJpegComponent c1 = decoder.Components[1];
             IJpegComponent c2 = decoder.Components[2];
 
-            var uniform1 = new Size(1, 1);
+            Size uniform1 = new(1, 1);
 
             Size expectedLumaSizeInBlocks = decoder.Frame.McuSize.MultiplyBy(fLuma);
 
diff --git a/tests/ImageSharp.Tests/Formats/Jpg/ReferenceImplementationsTests.FastFloatingPointDCT.cs b/tests/ImageSharp.Tests/Formats/Jpg/ReferenceImplementationsTests.FastFloatingPointDCT.cs
index f5d7c159ba..2fcd953ae0 100644
--- a/tests/ImageSharp.Tests/Formats/Jpg/ReferenceImplementationsTests.FastFloatingPointDCT.cs
+++ b/tests/ImageSharp.Tests/Formats/Jpg/ReferenceImplementationsTests.FastFloatingPointDCT.cs
@@ -53,7 +53,7 @@ public partial class ReferenceImplementationsTests
         {
             float[] sourceArray = Create8x8RandomFloatData(-range, range, seed);
 
-            var source = Block8x8F.Load(sourceArray);
+            Block8x8F source = Block8x8F.Load(sourceArray);
 
             Block8x8F expected = ReferenceImplementations.AccurateDCT.TransformIDCT(ref source);
 
diff --git a/tests/ImageSharp.Tests/Formats/Jpg/SpectralJpegTests.cs b/tests/ImageSharp.Tests/Formats/Jpg/SpectralJpegTests.cs
index 805ee586a8..903a6b0762 100644
--- a/tests/ImageSharp.Tests/Formats/Jpg/SpectralJpegTests.cs
+++ b/tests/ImageSharp.Tests/Formats/Jpg/SpectralJpegTests.cs
@@ -6,6 +6,7 @@ using SixLabors.ImageSharp.Formats.Jpeg.Components;
 using SixLabors.ImageSharp.Formats.Jpeg.Components.Decoder;
 using SixLabors.ImageSharp.IO;
 using SixLabors.ImageSharp.Memory;
+using SixLabors.ImageSharp.Metadata.Profiles.Icc;
 using SixLabors.ImageSharp.PixelFormats;
 using SixLabors.ImageSharp.Tests.Formats.Jpg.Utils;
 using Xunit.Abstractions;
@@ -21,19 +22,19 @@ public class SpectralJpegTests
     private ITestOutputHelper Output { get; }
 
     public static readonly string[] BaselineTestJpegs =
-        {
-            TestImages.Jpeg.Baseline.Calliphora, TestImages.Jpeg.Baseline.Cmyk, TestImages.Jpeg.Baseline.Jpeg400,
+    [
+        TestImages.Jpeg.Baseline.Calliphora, TestImages.Jpeg.Baseline.Cmyk, TestImages.Jpeg.Baseline.Jpeg400,
             TestImages.Jpeg.Baseline.Jpeg444, TestImages.Jpeg.Baseline.Testorig420,
             TestImages.Jpeg.Baseline.Jpeg420Small, TestImages.Jpeg.Baseline.Bad.BadEOF,
             TestImages.Jpeg.Baseline.MultiScanBaselineCMYK
-        };
+    ];
 
     public static readonly string[] ProgressiveTestJpegs =
-        {
-            TestImages.Jpeg.Progressive.Fb, TestImages.Jpeg.Progressive.Progress,
+    [
+        TestImages.Jpeg.Progressive.Fb, TestImages.Jpeg.Progressive.Progress,
             TestImages.Jpeg.Progressive.Festzug, TestImages.Jpeg.Progressive.Bad.BadEOF,
-            TestImages.Jpeg.Progressive.Bad.ExifUndefType,
-        };
+            TestImages.Jpeg.Progressive.Bad.ExifUndefType
+    ];
 
     public static readonly string[] AllTestJpegs = BaselineTestJpegs.Concat(ProgressiveTestJpegs).ToArray();
 
@@ -46,13 +47,13 @@ public class SpectralJpegTests
         byte[] sourceBytes = TestFile.Create(provider.SourceFileOrDescription).Bytes;
         JpegDecoderOptions option = new();
 
-        using var decoder = new JpegDecoderCore(option);
-        using var ms = new MemoryStream(sourceBytes);
-        using var bufferedStream = new BufferedReadStream(Configuration.Default, ms);
+        using JpegDecoderCore decoder = new(option);
+        using MemoryStream ms = new(sourceBytes);
+        using BufferedReadStream bufferedStream = new(Configuration.Default, ms);
 
         // internal scan decoder which we substitute to assert spectral correctness
-        var debugConverter = new DebugSpectralConverter<TPixel>();
-        var scanDecoder = new HuffmanScanDecoder(bufferedStream, debugConverter, cancellationToken: default);
+        DebugSpectralConverter<TPixel> debugConverter = new();
+        HuffmanScanDecoder scanDecoder = new(bufferedStream, debugConverter, cancellationToken: default);
 
         // This would parse entire image
         decoder.ParseStream(bufferedStream, debugConverter, cancellationToken: default);
@@ -76,12 +77,12 @@ public class SpectralJpegTests
         byte[] sourceBytes = TestFile.Create(provider.SourceFileOrDescription).Bytes;
         JpegDecoderOptions options = new();
 
-        using var decoder = new JpegDecoderCore(options);
-        using var ms = new MemoryStream(sourceBytes);
-        using var bufferedStream = new BufferedReadStream(Configuration.Default, ms);
+        using JpegDecoderCore decoder = new(options);
+        using MemoryStream ms = new(sourceBytes);
+        using BufferedReadStream bufferedStream = new(Configuration.Default, ms);
 
         // internal scan decoder which we substitute to assert spectral correctness
-        var debugConverter = new DebugSpectralConverter<TPixel>();
+        DebugSpectralConverter<TPixel> debugConverter = new();
 
         // This would parse entire image
         decoder.ParseStream(bufferedStream, debugConverter, cancellationToken: default);
@@ -164,7 +165,7 @@ public class SpectralJpegTests
             }
         }
 
-        public override void ConvertStrideBaseline()
+        public override void ConvertStrideBaseline(IccProfile iccProfile)
         {
             // This would be called only for baseline non-interleaved images
             // We must copy spectral strides here
@@ -197,7 +198,7 @@ public class SpectralJpegTests
 
         public override void PrepareForDecoding()
         {
-            var spectralComponents = new LibJpegTools.ComponentData[this.frame.ComponentCount];
+            LibJpegTools.ComponentData[] spectralComponents = new LibJpegTools.ComponentData[this.frame.ComponentCount];
             for (int i = 0; i < spectralComponents.Length; i++)
             {
                 JpegComponent component = this.frame.Components[i];
diff --git a/tests/ImageSharp.Tests/Formats/Jpg/SpectralToPixelConversionTests.cs b/tests/ImageSharp.Tests/Formats/Jpg/SpectralToPixelConversionTests.cs
index 25929182fb..13300ee804 100644
--- a/tests/ImageSharp.Tests/Formats/Jpg/SpectralToPixelConversionTests.cs
+++ b/tests/ImageSharp.Tests/Formats/Jpg/SpectralToPixelConversionTests.cs
@@ -15,12 +15,12 @@ namespace SixLabors.ImageSharp.Tests.Formats.Jpg;
 public class SpectralToPixelConversionTests
 {
     public static readonly string[] BaselineTestJpegs =
-    {
+    [
         TestImages.Jpeg.Baseline.Calliphora, TestImages.Jpeg.Baseline.Cmyk, TestImages.Jpeg.Baseline.Jpeg400,
         TestImages.Jpeg.Baseline.Jpeg444, TestImages.Jpeg.Baseline.Testorig420,
         TestImages.Jpeg.Baseline.Jpeg420Small, TestImages.Jpeg.Baseline.Bad.BadEOF,
         TestImages.Jpeg.Baseline.MultiScanBaselineCMYK
-    };
+    ];
 
     public SpectralToPixelConversionTests(ITestOutputHelper output) => this.Output = output;
 
@@ -33,14 +33,14 @@ public class SpectralToPixelConversionTests
     {
         // Stream
         byte[] sourceBytes = TestFile.Create(provider.SourceFileOrDescription).Bytes;
-        using var ms = new MemoryStream(sourceBytes);
-        using var bufferedStream = new BufferedReadStream(Configuration.Default, ms);
+        using MemoryStream ms = new(sourceBytes);
+        using BufferedReadStream bufferedStream = new(Configuration.Default, ms);
 
         // Decoding
         JpegDecoderOptions options = new();
-        using var converter = new SpectralConverter<TPixel>(Configuration.Default);
-        using var decoder = new JpegDecoderCore(options);
-        var scanDecoder = new HuffmanScanDecoder(bufferedStream, converter, cancellationToken: default);
+        using SpectralConverter<TPixel> converter = new(Configuration.Default);
+        using JpegDecoderCore decoder = new(options);
+        HuffmanScanDecoder scanDecoder = new(bufferedStream, converter, cancellationToken: default);
         decoder.ParseStream(bufferedStream, converter, cancellationToken: default);
 
         // Test metadata
@@ -48,7 +48,7 @@ public class SpectralToPixelConversionTests
         provider.Utility.TestName = JpegDecoderTests.DecodeBaselineJpegOutputName;
 
         // Comparison
-        using var image = new Image<TPixel>(Configuration.Default, converter.GetPixelBuffer(CancellationToken.None), new ImageMetadata());
+        using Image<TPixel> image = new(Configuration.Default, converter.GetPixelBuffer(null, CancellationToken.None), new ImageMetadata());
         using Image<TPixel> referenceImage = provider.GetReferenceOutputImage<TPixel>(appendPixelTypeToFileName: false);
         ImageSimilarityReport report = ImageComparer.Exact.CompareImagesOrFrames(referenceImage, image);
 
diff --git a/tests/ImageSharp.Tests/Formats/Jpg/Utils/JpegFixture.cs b/tests/ImageSharp.Tests/Formats/Jpg/Utils/JpegFixture.cs
index a3fbe4018e..33e95c5aa0 100644
--- a/tests/ImageSharp.Tests/Formats/Jpg/Utils/JpegFixture.cs
+++ b/tests/ImageSharp.Tests/Formats/Jpg/Utils/JpegFixture.cs
@@ -72,7 +72,7 @@ public class JpegFixture : MeasureFixture
     // ReSharper disable once InconsistentNaming
     public static int[] Create8x8RandomIntData(int minValue, int maxValue, int seed = 42)
     {
-        var rnd = new Random(seed);
+        Random rnd = new(seed);
         int[] result = new int[64];
         for (int i = 0; i < 8; i++)
         {
@@ -87,7 +87,7 @@ public class JpegFixture : MeasureFixture
 
     public static float[] Create8x8RandomFloatData(float minValue, float maxValue, int seed = 42, int xBorder = 8, int yBorder = 8)
     {
-        var rnd = new Random(seed);
+        Random rnd = new(seed);
         float[] result = new float[64];
         for (int y = 0; y < yBorder; y++)
         {
@@ -112,7 +112,7 @@ public class JpegFixture : MeasureFixture
 
     internal void Print8x8Data<T>(Span<T> data)
     {
-        var bld = new StringBuilder();
+        StringBuilder bld = new();
         for (int i = 0; i < 8; i++)
         {
             for (int j = 0; j < 8; j++)
@@ -135,7 +135,7 @@ public class JpegFixture : MeasureFixture
             count = data.Length;
         }
 
-        var sb = new StringBuilder();
+        StringBuilder sb = new();
         for (int i = 0; i < count; i++)
         {
             sb.Append($"{data[i],3} ");
@@ -158,7 +158,7 @@ public class JpegFixture : MeasureFixture
 
     internal void CompareBlocks(Span<float> a, Span<float> b, float tolerance)
     {
-        var comparer = new ApproximateFloatComparer(tolerance);
+        ApproximateFloatComparer comparer = new(tolerance);
         double totalDifference = 0.0;
 
         bool failed = false;
@@ -192,7 +192,7 @@ public class JpegFixture : MeasureFixture
 
     internal static bool CompareBlocks(Span<float> a, Span<float> b, float tolerance, out float diff)
     {
-        var comparer = new ApproximateFloatComparer(tolerance);
+        ApproximateFloatComparer comparer = new(tolerance);
         bool failed = false;
 
         diff = 0;
diff --git a/tests/ImageSharp.Tests/Formats/Jpg/Utils/LibJpegTools.ComponentData.cs b/tests/ImageSharp.Tests/Formats/Jpg/Utils/LibJpegTools.ComponentData.cs
index 65d0a01ffe..975378b5f8 100644
--- a/tests/ImageSharp.Tests/Formats/Jpg/Utils/LibJpegTools.ComponentData.cs
+++ b/tests/ImageSharp.Tests/Formats/Jpg/Utils/LibJpegTools.ComponentData.cs
@@ -60,7 +60,7 @@ internal static partial class LibJpegTools
 
         internal void MakeBlock(Block8x8 block, int y, int x)
         {
-            block.TransposeInplace();
+            block.TransposeInPlace();
             this.MakeBlock(block.ToArray(), y, x);
         }
 
diff --git a/tests/ImageSharp.Tests/Formats/Jpg/Utils/LibJpegTools.cs b/tests/ImageSharp.Tests/Formats/Jpg/Utils/LibJpegTools.cs
index bd1df33772..8884591128 100644
--- a/tests/ImageSharp.Tests/Formats/Jpg/Utils/LibJpegTools.cs
+++ b/tests/ImageSharp.Tests/Formats/Jpg/Utils/LibJpegTools.cs
@@ -65,7 +65,7 @@ internal static partial class LibJpegTools
         }
 
         string args = $@"""{sourceFile}"" ""{destFile}""";
-        var process = new Process
+        Process process = new()
         {
             StartInfo =
                                   {
@@ -95,21 +95,21 @@ internal static partial class LibJpegTools
         {
             RunDumpJpegCoeffsTool(testFile.FullPath, coeffFileFullPath);
 
-            using (var dumpStream = new FileStream(coeffFileFullPath, FileMode.Open))
-            using (var rdr = new BinaryReader(dumpStream))
+            using (FileStream dumpStream = new(coeffFileFullPath, FileMode.Open))
+            using (BinaryReader rdr = new(dumpStream))
             {
                 int componentCount = rdr.ReadInt16();
-                var result = new ComponentData[componentCount];
+                ComponentData[] result = new ComponentData[componentCount];
 
                 for (int i = 0; i < componentCount; i++)
                 {
                     int widthInBlocks = rdr.ReadInt16();
                     int heightInBlocks = rdr.ReadInt16();
-                    var resultComponent = new ComponentData(widthInBlocks, heightInBlocks, i);
+                    ComponentData resultComponent = new(widthInBlocks, heightInBlocks, i);
                     result[i] = resultComponent;
                 }
 
-                var buffer = new byte[64 * sizeof(short)];
+                byte[] buffer = new byte[64 * sizeof(short)];
 
                 for (int i = 0; i < result.Length; i++)
                 {
diff --git a/tests/ImageSharp.Tests/Formats/Jpg/Utils/ReferenceImplementations.AccurateDCT.cs b/tests/ImageSharp.Tests/Formats/Jpg/Utils/ReferenceImplementations.AccurateDCT.cs
index b6e7b29a62..2d4db15dfc 100644
--- a/tests/ImageSharp.Tests/Formats/Jpg/Utils/ReferenceImplementations.AccurateDCT.cs
+++ b/tests/ImageSharp.Tests/Formats/Jpg/Utils/ReferenceImplementations.AccurateDCT.cs
@@ -30,7 +30,7 @@ internal static partial class ReferenceImplementations
 
         public static void TransformIDCTInplace(Span<int> span)
         {
-            var temp = default(Block8x8);
+            Block8x8 temp = default(Block8x8);
             temp.LoadFrom(span);
             Block8x8 result = TransformIDCT(ref temp);
             result.CopyTo(span);
@@ -45,7 +45,7 @@ internal static partial class ReferenceImplementations
 
         public static void TransformFDCTInplace(Span<int> span)
         {
-            var temp = default(Block8x8);
+            Block8x8 temp = default(Block8x8);
             temp.LoadFrom(span);
             Block8x8 result = TransformFDCT(ref temp);
             result.CopyTo(span);
diff --git a/tests/ImageSharp.Tests/Formats/Jpg/Utils/ReferenceImplementations.LLM_FloatingPoint_DCT.cs b/tests/ImageSharp.Tests/Formats/Jpg/Utils/ReferenceImplementations.LLM_FloatingPoint_DCT.cs
index 0d5f3114d1..7c7f47f946 100644
--- a/tests/ImageSharp.Tests/Formats/Jpg/Utils/ReferenceImplementations.LLM_FloatingPoint_DCT.cs
+++ b/tests/ImageSharp.Tests/Formats/Jpg/Utils/ReferenceImplementations.LLM_FloatingPoint_DCT.cs
@@ -208,8 +208,8 @@ internal static partial class ReferenceImplementations
             /*y[0] = c0 + c1;
             y[4] = c0 - c1;*/
 
-            var w0 = new Vector4(0.541196f);
-            var w1 = new Vector4(1.306563f);
+            Vector4 w0 = new(0.541196f);
+            Vector4 w1 = new(1.306563f);
 
             _mm_store_ps(d, 16, (w0 * c2) + (w1 * c3));
 
@@ -242,7 +242,7 @@ internal static partial class ReferenceImplementations
             _mm_store_ps(d, 40, c3 - c1);
 
             // y[5] = c3 - c1; y[3] = c0 - c2;
-            var invsqrt2 = new Vector4(0.707107f);
+            Vector4 invsqrt2 = new(0.707107f);
             c0 = (c0 + c2) * invsqrt2;
             c3 = (c3 + c1) * invsqrt2;
 
@@ -272,7 +272,7 @@ internal static partial class ReferenceImplementations
 
             FDCT2D8x4_32f(temp.Slice(4), d.Slice(4));
 
-            var c = new Vector4(0.1250f);
+            Vector4 c = new(0.1250f);
 
 #pragma warning disable SA1107 // Code should not contain multiple statements on one line
             _mm_store_ps(d, 0, _mm_load_ps(d, 0) * c); d = d.Slice(4); // 0
@@ -318,29 +318,29 @@ internal static partial class ReferenceImplementations
         // Accurate variants of constants from:
         // https://github.com/mozilla/mozjpeg/blob/master/simd/jfdctint-altivec.c
 #pragma warning disable SA1309 // Field names should not begin with underscore
-        private static readonly Vector4 _1_175876 = new Vector4(1.175875602f);
+        private static readonly Vector4 _1_175876 = new(1.175875602f);
 
-        private static readonly Vector4 _1_961571 = new Vector4(-1.961570560f);
+        private static readonly Vector4 _1_961571 = new(-1.961570560f);
 
-        private static readonly Vector4 _0_390181 = new Vector4(-0.390180644f);
+        private static readonly Vector4 _0_390181 = new(-0.390180644f);
 
-        private static readonly Vector4 _0_899976 = new Vector4(-0.899976223f);
+        private static readonly Vector4 _0_899976 = new(-0.899976223f);
 
-        private static readonly Vector4 _2_562915 = new Vector4(-2.562915447f);
+        private static readonly Vector4 _2_562915 = new(-2.562915447f);
 
-        private static readonly Vector4 _0_298631 = new Vector4(0.298631336f);
+        private static readonly Vector4 _0_298631 = new(0.298631336f);
 
-        private static readonly Vector4 _2_053120 = new Vector4(2.053119869f);
+        private static readonly Vector4 _2_053120 = new(2.053119869f);
 
-        private static readonly Vector4 _3_072711 = new Vector4(3.072711026f);
+        private static readonly Vector4 _3_072711 = new(3.072711026f);
 
-        private static readonly Vector4 _1_501321 = new Vector4(1.501321110f);
+        private static readonly Vector4 _1_501321 = new(1.501321110f);
 
-        private static readonly Vector4 _0_541196 = new Vector4(0.541196100f);
+        private static readonly Vector4 _0_541196 = new(0.541196100f);
 
-        private static readonly Vector4 _1_847759 = new Vector4(-1.847759065f);
+        private static readonly Vector4 _1_847759 = new(-1.847759065f);
 
-        private static readonly Vector4 _0_765367 = new Vector4(0.765366865f);
+        private static readonly Vector4 _0_765367 = new(0.765366865f);
 #pragma warning restore SA1309 // Field names should not begin with underscore
 
         /// <summary>
diff --git a/tests/ImageSharp.Tests/Formats/Jpg/Utils/ReferenceImplementations.StandardIntegerDCT.cs b/tests/ImageSharp.Tests/Formats/Jpg/Utils/ReferenceImplementations.StandardIntegerDCT.cs
index 95ab076b0b..10019c609e 100644
--- a/tests/ImageSharp.Tests/Formats/Jpg/Utils/ReferenceImplementations.StandardIntegerDCT.cs
+++ b/tests/ImageSharp.Tests/Formats/Jpg/Utils/ReferenceImplementations.StandardIntegerDCT.cs
@@ -71,10 +71,10 @@ internal static partial class ReferenceImplementations
 
         public static Block8x8 Subtract128_TransformFDCT_Upscale8(ref Block8x8 block)
         {
-            var temp = new int[Block8x8.Size];
+            int[] temp = new int[Block8x8.Size];
             block.CopyTo(temp);
             Subtract128_TransformFDCT_Upscale8_Inplace(temp);
-            var result = default(Block8x8);
+            Block8x8 result = default(Block8x8);
             result.LoadFrom(temp);
             return result;
         }
@@ -82,10 +82,10 @@ internal static partial class ReferenceImplementations
         // [Obsolete("Looks like this method produces really bad results for bigger values!")]
         public static Block8x8 TransformIDCT(ref Block8x8 block)
         {
-            var temp = new int[Block8x8.Size];
+            int[] temp = new int[Block8x8.Size];
             block.CopyTo(temp);
             TransformIDCTInplace(temp);
-            var result = default(Block8x8);
+            Block8x8 result = default(Block8x8);
             result.LoadFrom(temp);
             return result;
         }
diff --git a/tests/ImageSharp.Tests/Formats/Jpg/Utils/SpanExtensions.cs b/tests/ImageSharp.Tests/Formats/Jpg/Utils/SpanExtensions.cs
index 240a338f9b..d7c2c0bbbb 100644
--- a/tests/ImageSharp.Tests/Formats/Jpg/Utils/SpanExtensions.cs
+++ b/tests/ImageSharp.Tests/Formats/Jpg/Utils/SpanExtensions.cs
@@ -74,7 +74,7 @@ internal static class SpanExtensions
     /// <returns>A new <see cref="Span{T}"/> with float values</returns>
     public static float[] ConvertAllToFloat(this int[] src)
     {
-        var result = new float[src.Length];
+        float[] result = new float[src.Length];
         for (int i = 0; i < src.Length; i++)
         {
             result[i] = src[i];
@@ -91,7 +91,7 @@ internal static class SpanExtensions
     /// <returns>A new instance of <see cref="Span{T}"/></returns>
     public static Span<float> AddScalarToAllValues(this Span<float> src, float scalar)
     {
-        var result = new float[src.Length];
+        float[] result = new float[src.Length];
         for (int i = 0; i < src.Length; i++)
         {
             result[i] = src[i] + scalar;
@@ -108,7 +108,7 @@ internal static class SpanExtensions
     /// <returns>A new instance of <see cref="Span{T}"/></returns>
     public static Span<int> AddScalarToAllValues(this Span<int> src, int scalar)
     {
-        var result = new int[src.Length];
+        int[] result = new int[src.Length];
         for (int i = 0; i < src.Length; i++)
         {
             result[i] = src[i] + scalar;
diff --git a/tests/ImageSharp.Tests/Formats/Pbm/PbmDecoderTests.cs b/tests/ImageSharp.Tests/Formats/Pbm/PbmDecoderTests.cs
index 11dd1cd58c..476538ccdf 100644
--- a/tests/ImageSharp.Tests/Formats/Pbm/PbmDecoderTests.cs
+++ b/tests/ImageSharp.Tests/Formats/Pbm/PbmDecoderTests.cs
@@ -29,11 +29,11 @@ public class PbmDecoderTests
     public void ImageLoadCanDecode(string imagePath, PbmColorType expectedColorType, PbmComponentType expectedComponentType)
     {
         // Arrange
-        var testFile = TestFile.Create(imagePath);
-        using var stream = new MemoryStream(testFile.Bytes, false);
+        TestFile testFile = TestFile.Create(imagePath);
+        using MemoryStream stream = new(testFile.Bytes, false);
 
         // Act
-        using var image = Image.Load(stream);
+        using Image image = Image.Load(stream);
 
         // Assert
         Assert.NotNull(image);
@@ -53,11 +53,11 @@ public class PbmDecoderTests
     public void ImageLoadL8CanDecode(string imagePath)
     {
         // Arrange
-        var testFile = TestFile.Create(imagePath);
-        using var stream = new MemoryStream(testFile.Bytes, false);
+        TestFile testFile = TestFile.Create(imagePath);
+        using MemoryStream stream = new(testFile.Bytes, false);
 
         // Act
-        using var image = Image.Load<L8>(stream);
+        using Image<L8> image = Image.Load<L8>(stream);
 
         // Assert
         Assert.NotNull(image);
@@ -70,11 +70,11 @@ public class PbmDecoderTests
     public void ImageLoadRgb24CanDecode(string imagePath)
     {
         // Arrange
-        var testFile = TestFile.Create(imagePath);
-        using var stream = new MemoryStream(testFile.Bytes, false);
+        TestFile testFile = TestFile.Create(imagePath);
+        using MemoryStream stream = new(testFile.Bytes, false);
 
         // Act
-        using var image = Image.Load<Rgb24>(stream);
+        using Image<Rgb24> image = Image.Load<Rgb24>(stream);
 
         // Assert
         Assert.NotNull(image);
@@ -108,7 +108,7 @@ public class PbmDecoderTests
     {
         DecoderOptions options = new()
         {
-            TargetSize = new() { Width = 150, Height = 150 }
+            TargetSize = new Size { Width = 150, Height = 150 }
         };
 
         using Image<TPixel> image = provider.GetImage(PbmDecoder.Instance, options);
diff --git a/tests/ImageSharp.Tests/Formats/Pbm/PbmEncoderTests.cs b/tests/ImageSharp.Tests/Formats/Pbm/PbmEncoderTests.cs
index 05f1d963b2..0fea65f6ea 100644
--- a/tests/ImageSharp.Tests/Formats/Pbm/PbmEncoderTests.cs
+++ b/tests/ImageSharp.Tests/Formats/Pbm/PbmEncoderTests.cs
@@ -38,16 +38,16 @@ public class PbmEncoderTests
     [MemberData(nameof(PbmColorTypeFiles))]
     public void PbmEncoder_PreserveColorType(string imagePath, PbmColorType pbmColorType)
     {
-        var options = new PbmEncoder();
+        PbmEncoder options = new();
 
-        var testFile = TestFile.Create(imagePath);
+        TestFile testFile = TestFile.Create(imagePath);
         using (Image<Rgba32> input = testFile.CreateRgba32Image())
         {
-            using (var memStream = new MemoryStream())
+            using (MemoryStream memStream = new())
             {
                 input.Save(memStream, options);
                 memStream.Position = 0;
-                using (var output = Image.Load<Rgba32>(memStream))
+                using (Image<Rgba32> output = Image.Load<Rgba32>(memStream))
                 {
                     PbmMetadata meta = output.Metadata.GetPbmMetadata();
                     Assert.Equal(pbmColorType, meta.ColorType);
@@ -60,15 +60,15 @@ public class PbmEncoderTests
     [MemberData(nameof(PbmColorTypeFiles))]
     public void PbmEncoder_WithPlainEncoding_PreserveBitsPerPixel(string imagePath, PbmColorType pbmColorType)
     {
-        var options = new PbmEncoder()
+        PbmEncoder options = new()
         {
             Encoding = PbmEncoding.Plain
         };
 
-        var testFile = TestFile.Create(imagePath);
+        TestFile testFile = TestFile.Create(imagePath);
         using (Image<Rgba32> input = testFile.CreateRgba32Image())
         {
-            using (var memStream = new MemoryStream())
+            using (MemoryStream memStream = new())
             {
                 input.Save(memStream, options);
 
@@ -78,7 +78,7 @@ public class PbmEncoderTests
                 Assert.Equal(0x20, lastByte);
 
                 memStream.Seek(0, SeekOrigin.Begin);
-                using (var output = Image.Load<Rgba32>(memStream))
+                using (Image<Rgba32> output = Image.Load<Rgba32>(memStream))
                 {
                     PbmMetadata meta = output.Metadata.GetPbmMetadata();
                     Assert.Equal(pbmColorType, meta.ColorType);
@@ -132,13 +132,13 @@ public class PbmEncoderTests
     {
         using (Image<TPixel> image = provider.GetImage())
         {
-            var encoder = new PbmEncoder { ColorType = colorType, Encoding = encoding };
+            PbmEncoder encoder = new() { ColorType = colorType, Encoding = encoding };
 
-            using (var memStream = new MemoryStream())
+            using (MemoryStream memStream = new())
             {
                 image.Save(memStream, encoder);
                 memStream.Position = 0;
-                using (var encodedImage = (Image<TPixel>)Image.Load(memStream))
+                using (Image<TPixel> encodedImage = (Image<TPixel>)Image.Load(memStream))
                 {
                     ImageComparingUtils.CompareWithReferenceDecoder(provider, encodedImage, useExactComparer, compareTolerance);
                 }
diff --git a/tests/ImageSharp.Tests/Formats/Pbm/PbmRoundTripTests.cs b/tests/ImageSharp.Tests/Formats/Pbm/PbmRoundTripTests.cs
index b7ce32ed8f..6524b35065 100644
--- a/tests/ImageSharp.Tests/Formats/Pbm/PbmRoundTripTests.cs
+++ b/tests/ImageSharp.Tests/Formats/Pbm/PbmRoundTripTests.cs
@@ -21,11 +21,11 @@ public class PbmRoundTripTests
     public void PbmGrayscaleImageCanRoundTrip(string imagePath)
     {
         // Arrange
-        var testFile = TestFile.Create(imagePath);
-        using var stream = new MemoryStream(testFile.Bytes, false);
+        TestFile testFile = TestFile.Create(imagePath);
+        using MemoryStream stream = new(testFile.Bytes, false);
 
         // Act
-        using var originalImage = Image.Load(stream);
+        using Image originalImage = Image.Load(stream);
         using Image<Rgb24> colorImage = originalImage.CloneAs<Rgb24>();
         using Image<Rgb24> encodedImage = this.RoundTrip(colorImage);
 
@@ -42,11 +42,11 @@ public class PbmRoundTripTests
     public void PbmColorImageCanRoundTrip(string imagePath)
     {
         // Arrange
-        var testFile = TestFile.Create(imagePath);
-        using var stream = new MemoryStream(testFile.Bytes, false);
+        TestFile testFile = TestFile.Create(imagePath);
+        using MemoryStream stream = new(testFile.Bytes, false);
 
         // Act
-        using var originalImage = Image.Load<Rgb24>(stream);
+        using Image<Rgb24> originalImage = Image.Load<Rgb24>(stream);
         using Image<Rgb24> encodedImage = this.RoundTrip(originalImage);
 
         // Assert
@@ -57,10 +57,10 @@ public class PbmRoundTripTests
     private Image<TPixel> RoundTrip<TPixel>(Image<TPixel> originalImage)
         where TPixel : unmanaged, IPixel<TPixel>
     {
-        using var decodedStream = new MemoryStream();
+        using MemoryStream decodedStream = new();
         originalImage.SaveAsPbm(decodedStream);
         decodedStream.Seek(0, SeekOrigin.Begin);
-        var encodedImage = Image.Load<TPixel>(decodedStream);
+        Image<TPixel> encodedImage = Image.Load<TPixel>(decodedStream);
         return encodedImage;
     }
 }
diff --git a/tests/ImageSharp.Tests/Formats/Png/Adler32Tests.cs b/tests/ImageSharp.Tests/Formats/Png/Adler32Tests.cs
index 1b66c4cc3c..c2b640a1de 100644
--- a/tests/ImageSharp.Tests/Formats/Png/Adler32Tests.cs
+++ b/tests/ImageSharp.Tests/Formats/Png/Adler32Tests.cs
@@ -30,7 +30,7 @@ public class Adler32Tests
     {
         // arrange
         byte[] data = GetBuffer(length);
-        var adler = new SharpAdler32();
+        SharpAdler32 adler = new();
         adler.Update(data);
         long expected = adler.Value;
 
@@ -60,7 +60,7 @@ public class Adler32Tests
 
     private static void RunCalculateAdlerTest()
     {
-        int[] testData = { 0, 8, 215, 1024, 1024 + 15, 2034, 4096 };
+        int[] testData = [0, 8, 215, 1024, 1024 + 15, 2034, 4096];
         for (int i = 0; i < testData.Length; i++)
         {
             CalculateAdlerAndCompareToReference(testData[i]);
diff --git a/tests/ImageSharp.Tests/Formats/Png/PngDecoderFilterTests.cs b/tests/ImageSharp.Tests/Formats/Png/PngDecoderFilterTests.cs
index f5c42c734b..00db13d4b2 100644
--- a/tests/ImageSharp.Tests/Formats/Png/PngDecoderFilterTests.cs
+++ b/tests/ImageSharp.Tests/Formats/Png/PngDecoderFilterTests.cs
@@ -13,33 +13,33 @@ public class PngDecoderFilterTests
     {
         // arrange
         byte[] scanline =
-        {
+        [
             3, 39, 39, 39, 0, 4, 4, 4, 0, 1, 1, 1, 0, 1, 1, 1, 0, 2, 2, 2, 0, 2, 2, 2, 0, 2, 2, 2, 0, 4, 4, 4,
             0, 2, 2, 2, 0, 3, 3, 3, 0, 1, 1, 1, 0, 3, 3, 3, 0, 3, 3, 3, 0, 1, 1, 1, 0, 3, 3, 3, 0, 2, 2, 2, 0,
             1, 1, 1, 0, 3, 3, 3, 0, 1, 1, 1, 0, 3, 3, 3, 0, 1, 1, 1, 0, 3, 3, 3, 0, 3, 3, 3, 0, 254, 254, 254,
             0, 6, 6, 6, 14, 71, 71, 71, 157, 254, 254, 254, 28, 251, 251, 251, 0, 4, 4, 4, 0, 2, 2, 2, 0, 11,
             11, 11, 0, 226, 226, 226, 0, 255, 128, 234
-        };
+        ];
 
         byte[] previousScanline =
-        {
+        [
             3, 74, 74, 74, 0, 73, 73, 73, 0, 73, 73, 73, 0, 74, 74, 74, 0, 74, 74, 74, 0, 73, 73, 73, 0, 72, 72,
             72, 0, 72, 72, 72, 0, 73, 73, 73, 0, 74, 74, 74, 0, 73, 73, 73, 0, 72, 72, 72, 0, 72, 72, 72, 0, 74,
             74, 74, 0, 72, 72, 72, 0, 73, 73, 73, 0, 75, 75, 75, 0, 73, 73, 73, 0, 74, 74, 74, 0, 72, 72, 72, 0,
             73, 73, 73, 0, 73, 73, 73, 0, 72, 72, 72, 0, 74, 74, 74, 0, 61, 61, 61, 0, 101, 101, 101, 78, 197,
             197, 197, 251, 152, 152, 152, 255, 155, 155, 155, 255, 162, 162, 162, 255, 175, 175, 175, 255, 160,
             160, 160, 255, 139, 128, 134
-        };
+        ];
 
         byte[] expected =
-        {
+        [
             3, 76, 76, 76, 0, 78, 78, 78, 0, 76, 76, 76, 0, 76, 76, 76, 0, 77, 77, 77, 0, 77, 77, 77, 0, 76, 76,
             76, 0, 78, 78, 78, 0, 77, 77, 77, 0, 78, 78, 78, 0, 76, 76, 76, 0, 77, 77, 77, 0, 77, 77, 77, 0, 76,
             76, 76, 0, 77, 77, 77, 0, 77, 77, 77, 0, 77, 77, 77, 0, 78, 78, 78, 0, 77, 77, 77, 0, 77, 77, 77, 0,
             76, 76, 76, 0, 77, 77, 77, 0, 77, 77, 77, 0, 73, 73, 73, 0, 73, 73, 73, 14, 158, 158, 158, 203, 175,
             175, 175, 255, 158, 158, 158, 255, 160, 160, 160, 255, 163, 163, 163, 255, 180, 180, 180, 255, 140,
             140, 140, 255, 138, 6, 115
-        };
+        ];
 
         // act
         AverageFilter.Decode(scanline, previousScanline, 4);
@@ -52,25 +52,25 @@ public class PngDecoderFilterTests
     {
         // arrange
         byte[] scanline =
-        {
+        [
             62, 23, 186, 150, 174, 4, 205, 59, 153, 134, 158, 86, 240, 173, 191, 58, 111, 183, 77, 37, 85, 23,
             93, 204, 110, 139, 9, 20, 87, 154, 176, 54, 207, 214, 40, 11, 179, 199, 7, 219, 174, 242, 112, 220,
             149, 5, 9, 110, 103, 107, 231, 241, 13, 70, 216, 39, 186, 237, 39, 34, 251, 185, 228, 254
-        };
+        ];
 
         byte[] previousScanline =
-        {
+        [
             214, 103, 135, 26, 133, 179, 134, 168, 175, 114, 118, 99, 167, 129, 55, 105, 129, 154, 173, 235,
             179, 191, 41, 137, 253, 0, 81, 198, 159, 228, 224, 245, 14, 113, 5, 45, 126, 239, 233, 179, 229, 62,
             66, 155, 207, 117, 128, 56, 181, 190, 160, 96, 11, 248, 74, 23, 62, 253, 29, 132, 98, 192, 9, 202
-        };
+        ];
 
         byte[] expected =
-        {
+        [
             62, 126, 65, 176, 51, 183, 83, 227, 72, 248, 20, 185, 151, 46, 246, 163, 240, 81, 250, 16, 8, 214,
             134, 85, 107, 139, 90, 218, 246, 126, 144, 43, 221, 71, 45, 56, 49, 182, 240, 142, 147, 48, 178,
             119, 100, 122, 137, 166, 28, 41, 135, 81, 24, 62, 34, 62, 248, 234, 68, 166, 93, 121, 237, 200
-        };
+        ];
 
         // act
         UpFilter.Decode(scanline, previousScanline);
@@ -83,18 +83,18 @@ public class PngDecoderFilterTests
     {
         // arrange
         byte[] scanline =
-        {
+        [
             62, 23, 186, 150, 174, 4, 205, 59, 153, 134, 158, 86, 240, 173, 191, 58, 111, 183, 77, 37, 85, 23,
             93, 204, 110, 139, 9, 20, 87, 154, 176, 54, 207, 214, 40, 11, 179, 199, 7, 219, 174, 242, 112, 220,
             149, 5, 9, 110, 103, 107, 231, 241, 13, 70, 216, 39, 186, 237, 39, 34, 251, 185, 228, 254
-        };
+        ];
 
         byte[] expected =
-        {
+        [
             62, 23, 186, 150, 174, 27, 135, 209, 71, 161, 37, 39, 55, 78, 228, 97, 166, 5, 49, 134, 251, 28,
             142, 82, 105, 167, 151, 102, 192, 65, 71, 156, 143, 23, 111, 167, 66, 222, 118, 130, 240, 208, 230,
             94, 133, 213, 239, 204, 236, 64, 214, 189, 249, 134, 174, 228, 179, 115, 213, 6, 174, 44, 185, 4
-        };
+        ];
 
         // act
         SubFilter.Decode(scanline, 4);
@@ -107,25 +107,25 @@ public class PngDecoderFilterTests
     {
         // arrange
         byte[] scanline =
-        {
+        [
             62, 23, 186, 150, 174, 4, 205, 59, 153, 134, 158, 86, 240, 173, 191, 58, 111, 183, 77, 37, 85, 23,
             93, 204, 110, 139, 9, 20, 87, 154, 176, 54, 207, 214, 40, 11, 179, 199, 7, 219, 174, 242, 112, 220,
             149, 5, 9, 110, 103, 107, 231, 241, 13, 70, 216, 39, 186, 237, 39, 34, 251, 185, 228, 254
-        };
+        ];
 
         byte[] previousScanline =
-        {
+        [
             214, 103, 135, 26, 133, 179, 134, 168, 175, 114, 118, 99, 167, 129, 55, 105, 129, 154, 173, 235,
             179, 191, 41, 137, 253, 0, 81, 198, 159, 228, 224, 245, 14, 113, 5, 45, 126, 239, 233, 179, 229, 62,
             66, 155, 207, 117, 128, 56, 181, 190, 160, 96, 11, 248, 74, 23, 62, 253, 29, 132, 98, 192, 9, 202
-        };
+        ];
 
         byte[] expected =
-        {
+        [
             62, 126, 65, 176, 51, 183, 14, 235, 30, 248, 172, 254, 14, 165, 53, 56, 125, 92, 250, 16, 8, 177,
             10, 220, 118, 139, 50, 240, 205, 126, 144, 43, 221, 71, 45, 54, 144, 182, 240, 142, 147, 48, 178,
             106, 40, 122, 187, 166, 143, 41, 162, 151, 24, 111, 34, 135, 248, 92, 68, 169, 243, 21, 1, 200
-        };
+        ];
 
         // act
         PaethFilter.Decode(scanline, previousScanline, 4);
diff --git a/tests/ImageSharp.Tests/Formats/Png/PngDecoderTests.Chunks.cs b/tests/ImageSharp.Tests/Formats/Png/PngDecoderTests.Chunks.cs
index aff8bc12a2..8dfa987488 100644
--- a/tests/ImageSharp.Tests/Formats/Png/PngDecoderTests.Chunks.cs
+++ b/tests/ImageSharp.Tests/Formats/Png/PngDecoderTests.Chunks.cs
@@ -14,12 +14,12 @@ namespace SixLabors.ImageSharp.Tests.Formats.Png;
 public partial class PngDecoderTests
 {
     // Represents ASCII string of "123456789"
-    private readonly byte[] check = { 49, 50, 51, 52, 53, 54, 55, 56, 57 };
+    private readonly byte[] check = [49, 50, 51, 52, 53, 54, 55, 56, 57];
 
     // Contains the png marker, IHDR and pHYs chunks of a 1x1 pixel 32bit png 1 a single black pixel.
     private static readonly byte[] Raw1X1PngIhdrAndpHYs =
-        {
-            // PNG Identifier
+    [
+        // PNG Identifier
             0x89, 0x50, 0x4E, 0x47, 0x0D, 0x0A, 0x1A, 0x0A,
 
             // IHDR
@@ -36,12 +36,12 @@ public partial class PngDecoderTests
 
             // pHYS CRC
             0xC7, 0x6F, 0xA8, 0x64
-        };
+    ];
 
     // Contains the png marker, IDAT and IEND chunks of a 1x1 pixel 32bit png 1 a single black pixel.
     private static readonly byte[] Raw1X1PngIdatAndIend =
-        {
-            // IDAT
+    [
+        // IDAT
             0x00, 0x00, 0x00, 0x0C, 0x49, 0x44, 0x41, 0x54, 0x18,
             0x57, 0x63, 0x60, 0x60, 0x60, 0x00, 0x00, 0x00, 0x04,
             0x00, 0x01,
@@ -54,7 +54,7 @@ public partial class PngDecoderTests
 
             // IEND CRC
             0xAE, 0x42, 0x60, 0x82
-        };
+    ];
 
     [Theory]
     [InlineData((uint)PngChunkType.Header)] // IHDR
@@ -64,7 +64,7 @@ public partial class PngDecoderTests
     {
         string chunkName = GetChunkTypeName(chunkType);
 
-        using (var memStream = new MemoryStream())
+        using (MemoryStream memStream = new())
         {
             WriteHeaderChunk(memStream);
             WriteChunk(memStream, chunkName);
@@ -94,10 +94,10 @@ public partial class PngDecoderTests
     private static void WriteChunk(MemoryStream memStream, string chunkName)
     {
         // Needs a minimum length of 9 for pHYs chunk.
-        memStream.Write(new byte[] { 0, 0, 0, 9 }, 0, 4);
+        memStream.Write([0, 0, 0, 9], 0, 4);
         memStream.Write(Encoding.ASCII.GetBytes(chunkName), 0, 4); // 4 bytes chunk header
-        memStream.Write(new byte[] { 0, 0, 0, 0, 0, 0, 0, 0, 0 }, 0, 9); // 9 bytes of chunk data
-        memStream.Write(new byte[] { 0, 0, 0, 0 }, 0, 4); // Junk Crc
+        memStream.Write([0, 0, 0, 0, 0, 0, 0, 0, 0], 0, 9); // 9 bytes of chunk data
+        memStream.Write([0, 0, 0, 0], 0, 4); // Junk Crc
     }
 
     private static void WriteDataChunk(MemoryStream memStream)
diff --git a/tests/ImageSharp.Tests/Formats/Png/PngDecoderTests.cs b/tests/ImageSharp.Tests/Formats/Png/PngDecoderTests.cs
index 9f3c5f6828..3589a25a2d 100644
--- a/tests/ImageSharp.Tests/Formats/Png/PngDecoderTests.cs
+++ b/tests/ImageSharp.Tests/Formats/Png/PngDecoderTests.cs
@@ -21,7 +21,7 @@ public partial class PngDecoderTests
     private const PixelTypes TestPixelTypes = PixelTypes.Rgba32 | PixelTypes.RgbaVector | PixelTypes.Argb32;
 
     public static readonly string[] CommonTestImages =
-    {
+    [
         TestImages.Png.Splash,
         TestImages.Png.FilterVar,
 
@@ -35,29 +35,29 @@ public partial class PngDecoderTests
         TestImages.Png.Rgb24BppTrans,
 
         TestImages.Png.Bad.ChunkLength1,
-        TestImages.Png.Bad.ChunkLength2,
-    };
+        TestImages.Png.Bad.ChunkLength2
+    ];
 
     public static readonly string[] TestImagesIssue1014 =
-    {
+    [
         TestImages.Png.Issue1014_1, TestImages.Png.Issue1014_2,
         TestImages.Png.Issue1014_3, TestImages.Png.Issue1014_4,
         TestImages.Png.Issue1014_5, TestImages.Png.Issue1014_6
-    };
+    ];
 
     public static readonly string[] TestImagesIssue1177 =
-    {
+    [
         TestImages.Png.Issue1177_1,
         TestImages.Png.Issue1177_2
-    };
+    ];
 
     public static readonly string[] CorruptedTestImages =
-    {
+    [
         TestImages.Png.Bad.CorruptedChunk,
         TestImages.Png.Bad.ZlibOverflow,
         TestImages.Png.Bad.ZlibOverflow2,
-        TestImages.Png.Bad.ZlibZtxtBadHeader,
-    };
+        TestImages.Png.Bad.ZlibZtxtBadHeader
+    ];
 
     public static readonly TheoryData<string, Type> PixelFormatRange = new()
     {
@@ -79,7 +79,7 @@ public partial class PngDecoderTests
     };
 
     public static readonly string[] MultiFrameTestFiles =
-    {
+    [
         TestImages.Png.APng,
         TestImages.Png.SplitIDatZeroLength,
         TestImages.Png.DisposeNone,
@@ -90,7 +90,7 @@ public partial class PngDecoderTests
         TestImages.Png.BlendOverMultiple,
         TestImages.Png.FrameOffset,
         TestImages.Png.DefaultNotAnimated
-    };
+    ];
 
     [Theory]
     [MemberData(nameof(PixelFormatRange))]
@@ -140,7 +140,7 @@ public partial class PngDecoderTests
     {
         DecoderOptions options = new()
         {
-            TargetSize = new() { Width = 150, Height = 150 }
+            TargetSize = new Size { Width = 150, Height = 150 }
         };
 
         using Image<TPixel> image = provider.GetImage(PngDecoder.Instance, options);
@@ -178,7 +178,7 @@ public partial class PngDecoderTests
 
             DecoderOptions options = new()
             {
-                TargetSize = new() { Width = 150, Height = 150 }
+                TargetSize = new Size { Width = 150, Height = 150 }
             };
 
             using Image<Rgba32> image = provider.GetImage(PngDecoder.Instance, options);
@@ -389,7 +389,7 @@ public partial class PngDecoderTests
         TestFile testFile = TestFile.Create(imagePath);
         using MemoryStream stream = new(testFile.Bytes, false);
 
-        ImageInfo imageInfo = Image.Identify(new DecoderOptions() { SegmentIntegrityHandling = SegmentIntegrityHandling.IgnoreData }, stream);
+        ImageInfo imageInfo = Image.Identify(new DecoderOptions { SegmentIntegrityHandling = SegmentIntegrityHandling.IgnoreData }, stream);
 
         Assert.NotNull(imageInfo);
         Assert.Equal(expectedPixelSize, imageInfo.PixelType.BitsPerPixel);
@@ -674,7 +674,7 @@ public partial class PngDecoderTests
     public void Binary_PrematureEof()
     {
         PngDecoder decoder = PngDecoder.Instance;
-        PngDecoderOptions options = new() { GeneralOptions = new() { SegmentIntegrityHandling = SegmentIntegrityHandling.IgnoreData } };
+        PngDecoderOptions options = new() { GeneralOptions = new DecoderOptions { SegmentIntegrityHandling = SegmentIntegrityHandling.IgnoreData } };
         using EofHitCounter eofHitCounter = EofHitCounter.RunDecoder(TestImages.Png.Bad.FlagOfGermany0000016446, decoder, options);
 
         // TODO: Try to reduce this to 1.
@@ -719,10 +719,20 @@ public partial class PngDecoderTests
     [Theory]
     [WithFile(TestImages.Png.Issue2752, PixelTypes.Rgba32)]
     public void CanDecodeJustOneFrame<TPixel>(TestImageProvider<TPixel> provider)
-    where TPixel : unmanaged, IPixel<TPixel>
+        where TPixel : unmanaged, IPixel<TPixel>
     {
         DecoderOptions options = new() { MaxFrames = 1 };
         using Image<TPixel> image = provider.GetImage(PngDecoder.Instance, options);
         Assert.Equal(1, image.Frames.Count);
     }
+
+    [Theory]
+    [WithFile(TestImages.Png.Issue2924, PixelTypes.Rgba32)]
+    public void CanDecode_Issue2924<TPixel>(TestImageProvider<TPixel> provider)
+        where TPixel : unmanaged, IPixel<TPixel>
+    {
+        using Image<TPixel> image = provider.GetImage(PngDecoder.Instance);
+        image.DebugSave(provider);
+        image.CompareToReferenceOutput(provider);
+    }
 }
diff --git a/tests/ImageSharp.Tests/Formats/Png/PngEncoderFilterTests.cs b/tests/ImageSharp.Tests/Formats/Png/PngEncoderFilterTests.cs
index 796d35bf72..a930426b6d 100644
--- a/tests/ImageSharp.Tests/Formats/Png/PngEncoderFilterTests.cs
+++ b/tests/ImageSharp.Tests/Formats/Png/PngEncoderFilterTests.cs
@@ -31,7 +31,7 @@ public class PngEncoderFilterTests : MeasureFixture
     {
         static void RunTest()
         {
-            var data = new TestData(PngFilterMethod.Average, Size);
+            TestData data = new(PngFilterMethod.Average, Size);
             data.TestFilter();
         }
 
@@ -45,7 +45,7 @@ public class PngEncoderFilterTests : MeasureFixture
     {
         static void RunTest()
         {
-            var data = new TestData(PngFilterMethod.Average, Size);
+            TestData data = new(PngFilterMethod.Average, Size);
             data.TestFilter();
         }
 
@@ -59,7 +59,7 @@ public class PngEncoderFilterTests : MeasureFixture
     {
         static void RunTest()
         {
-            var data = new TestData(PngFilterMethod.Average, Size);
+            TestData data = new(PngFilterMethod.Average, Size);
             data.TestFilter();
         }
 
@@ -73,7 +73,7 @@ public class PngEncoderFilterTests : MeasureFixture
     {
         static void RunTest()
         {
-            var data = new TestData(PngFilterMethod.Average, Size);
+            TestData data = new(PngFilterMethod.Average, Size);
             data.TestFilter();
         }
 
@@ -87,7 +87,7 @@ public class PngEncoderFilterTests : MeasureFixture
     {
         static void RunTest()
         {
-            var data = new TestData(PngFilterMethod.Paeth, Size);
+            TestData data = new(PngFilterMethod.Paeth, Size);
             data.TestFilter();
         }
 
@@ -101,7 +101,7 @@ public class PngEncoderFilterTests : MeasureFixture
     {
         static void RunTest()
         {
-            var data = new TestData(PngFilterMethod.Paeth, Size);
+            TestData data = new(PngFilterMethod.Paeth, Size);
             data.TestFilter();
         }
 
@@ -115,7 +115,7 @@ public class PngEncoderFilterTests : MeasureFixture
     {
         static void RunTest()
         {
-            var data = new TestData(PngFilterMethod.Paeth, Size);
+            TestData data = new(PngFilterMethod.Paeth, Size);
             data.TestFilter();
         }
 
@@ -129,7 +129,7 @@ public class PngEncoderFilterTests : MeasureFixture
     {
         static void RunTest()
         {
-            var data = new TestData(PngFilterMethod.Up, Size);
+            TestData data = new(PngFilterMethod.Up, Size);
             data.TestFilter();
         }
 
@@ -143,7 +143,7 @@ public class PngEncoderFilterTests : MeasureFixture
     {
         static void RunTest()
         {
-            var data = new TestData(PngFilterMethod.Up, Size);
+            TestData data = new(PngFilterMethod.Up, Size);
             data.TestFilter();
         }
 
@@ -157,7 +157,7 @@ public class PngEncoderFilterTests : MeasureFixture
     {
         static void RunTest()
         {
-            var data = new TestData(PngFilterMethod.Up, Size);
+            TestData data = new(PngFilterMethod.Up, Size);
             data.TestFilter();
         }
 
@@ -171,7 +171,7 @@ public class PngEncoderFilterTests : MeasureFixture
     {
         static void RunTest()
         {
-            var data = new TestData(PngFilterMethod.Sub, Size);
+            TestData data = new(PngFilterMethod.Sub, Size);
             data.TestFilter();
         }
 
@@ -185,7 +185,7 @@ public class PngEncoderFilterTests : MeasureFixture
     {
         static void RunTest()
         {
-            var data = new TestData(PngFilterMethod.Sub, Size);
+            TestData data = new(PngFilterMethod.Sub, Size);
             data.TestFilter();
         }
 
@@ -199,7 +199,7 @@ public class PngEncoderFilterTests : MeasureFixture
     {
         static void RunTest()
         {
-            var data = new TestData(PngFilterMethod.Sub, Size);
+            TestData data = new(PngFilterMethod.Sub, Size);
             data.TestFilter();
         }
 
@@ -227,7 +227,7 @@ public class PngEncoderFilterTests : MeasureFixture
             this.expectedResult = new byte[1 + (size * size * bpp)];
             this.resultBuffer = new byte[1 + (size * size * bpp)];
 
-            var rng = new Random(12345678);
+            Random rng = new(12345678);
             byte[] tmp = new byte[6];
             for (int i = 0; i < this.previousScanline.Length; i += bpp)
             {
diff --git a/tests/ImageSharp.Tests/Formats/Png/PngEncoderTests.Chunks.cs b/tests/ImageSharp.Tests/Formats/Png/PngEncoderTests.Chunks.cs
index 76fd260dd5..fdaa70e031 100644
--- a/tests/ImageSharp.Tests/Formats/Png/PngEncoderTests.Chunks.cs
+++ b/tests/ImageSharp.Tests/Formats/Png/PngEncoderTests.Chunks.cs
@@ -188,15 +188,15 @@ public partial class PngEncoderTests
             { PngChunkType.Data, false },
             { PngChunkType.End, false }
         };
-        List<PngChunkType> excludedChunkTypes = new()
-        {
+        List<PngChunkType> excludedChunkTypes =
+        [
             PngChunkType.Gamma,
             PngChunkType.Exif,
             PngChunkType.Physical,
             PngChunkType.Text,
             PngChunkType.InternationalText,
-            PngChunkType.CompressedText,
-        };
+            PngChunkType.CompressedText
+        ];
 
         // act
         input.Save(memStream, encoder);
@@ -252,7 +252,7 @@ public partial class PngEncoderTests
             { PngChunkType.Data, false },
             { PngChunkType.End, false }
         };
-        List<PngChunkType> excludedChunkTypes = new();
+        List<PngChunkType> excludedChunkTypes = [];
         switch (chunkFilter)
         {
             case PngChunkFilter.ExcludeGammaChunk:
@@ -326,8 +326,8 @@ public partial class PngEncoderTests
         using Image<Rgba32> input = testFile.CreateRgba32Image();
         using MemoryStream memStream = new();
         PngEncoder encoder = new() { ChunkFilter = PngChunkFilter.None, TextCompressionThreshold = 8 };
-        List<PngChunkType> expectedChunkTypes = new()
-        {
+        List<PngChunkType> expectedChunkTypes =
+        [
             PngChunkType.Header,
             PngChunkType.Gamma,
             PngChunkType.EmbeddedColorProfile,
@@ -338,8 +338,8 @@ public partial class PngEncoderTests
             PngChunkType.Exif,
             PngChunkType.Physical,
             PngChunkType.Data,
-            PngChunkType.End,
-        };
+            PngChunkType.End
+        ];
 
         // act
         input.Save(memStream, encoder);
diff --git a/tests/ImageSharp.Tests/Formats/Png/PngEncoderTests.cs b/tests/ImageSharp.Tests/Formats/Png/PngEncoderTests.cs
index b4995d77b6..0d666d8c8d 100644
--- a/tests/ImageSharp.Tests/Formats/Png/PngEncoderTests.cs
+++ b/tests/ImageSharp.Tests/Formats/Png/PngEncoderTests.cs
@@ -88,11 +88,11 @@ public partial class PngEncoderTests
         80, 100, 120, 230
     };
 
-    public static readonly PngInterlaceMode[] InterlaceMode = new[]
-    {
+    public static readonly PngInterlaceMode[] InterlaceMode =
+    [
         PngInterlaceMode.None,
         PngInterlaceMode.Adam7
-    };
+    ];
 
     public static readonly TheoryData<string, int, int, PixelResolutionUnit> RatioFiles =
     new()
@@ -289,8 +289,8 @@ public partial class PngEncoderTests
 
         byte[] data = ms.ToArray().Take(8).ToArray();
         byte[] expected =
-        {
-                0x89, // Set the high bit.
+        [
+            0x89, // Set the high bit.
                 0x50, // P
                 0x4E, // N
                 0x47, // G
@@ -298,7 +298,7 @@ public partial class PngEncoderTests
                 0x0A, // Line ending CRLF
                 0x1A, // EOF
                 0x0A // LF
-        };
+        ];
 
         Assert.Equal(expected, data);
     }
@@ -407,6 +407,7 @@ public partial class PngEncoderTests
     [WithFile(TestImages.Png.APng, PixelTypes.Rgba32)]
     [WithFile(TestImages.Png.DefaultNotAnimated, PixelTypes.Rgba32)]
     [WithFile(TestImages.Png.FrameOffset, PixelTypes.Rgba32)]
+    [WithFile(TestImages.Png.Issue2882, PixelTypes.Rgba32)]
     public void Encode_APng<TPixel>(TestImageProvider<TPixel> provider)
         where TPixel : unmanaged, IPixel<TPixel>
     {
@@ -419,8 +420,8 @@ public partial class PngEncoderTests
 
         using Image<Rgba32> output = Image.Load<Rgba32>(memStream);
 
-        // some loss from original, due to compositing
-        ImageComparer.TolerantPercentage(0.01f).VerifySimilarity(output, image);
+        // Some loss from original, due to palette matching accuracy.
+        ImageComparer.TolerantPercentage(0.172F).VerifySimilarity(output, image);
 
         Assert.Equal(image.Frames.Count, output.Frames.Count);
 
@@ -443,6 +444,7 @@ public partial class PngEncoderTests
 
     [Theory]
     [WithFile(TestImages.Gif.Leo, PixelTypes.Rgba32)]
+    [WithFile(TestImages.Gif.Issues.Issue2866, PixelTypes.Rgba32)]
     public void Encode_AnimatedFormatTransform_FromGif<TPixel>(TestImageProvider<TPixel> provider)
         where TPixel : unmanaged, IPixel<TPixel>
     {
@@ -453,26 +455,30 @@ public partial class PngEncoderTests
 
         using Image<TPixel> image = provider.GetImage(GifDecoder.Instance);
 
+        // Save the image for visual inspection.
+        provider.Utility.SaveTestOutputFile(image, "png", PngEncoder, "animated");
+
+        // Now compare the debug output with the reference output.
+        // We do this because the transcoding encoding is lossy and encoding will lead to differences.
+        // From the unencoded image, we can see that the image is visually the same.
+        static bool Predicate(int i, int _) => i % 8 == 0; // Image has many frames, only compare a selection of them.
+        image.CompareDebugOutputToReferenceOutputMultiFrame(provider, ImageComparer.Exact, extension: "png", encoder: PngEncoder, predicate: Predicate);
+
+        // Now save the image and load it again to compare the metadata.
         using MemoryStream memStream = new();
         image.Save(memStream, PngEncoder);
         memStream.Position = 0;
 
-        using Image<TPixel> output = Image.Load<TPixel>(memStream);
-
-        // TODO: Find a better way to compare.
-        // The image has been visually checked but the quantization pattern used in the png encoder
-        // means we cannot use an exact comparison nor replicate using the quantizing processor.
-        ImageComparer.TolerantPercentage(0.613f).VerifySimilarity(output, image);
-
+        using Image<TPixel> encoded = Image.Load<TPixel>(memStream);
         GifMetadata gif = image.Metadata.GetGifMetadata();
-        PngMetadata png = output.Metadata.GetPngMetadata();
+        PngMetadata png = encoded.Metadata.GetPngMetadata();
 
         Assert.Equal(gif.RepeatCount, png.RepeatCount);
 
         for (int i = 0; i < image.Frames.Count; i++)
         {
             GifFrameMetadata gifF = image.Frames[i].Metadata.GetGifMetadata();
-            PngFrameMetadata pngF = output.Frames[i].Metadata.GetPngMetadata();
+            PngFrameMetadata pngF = encoded.Frames[i].Metadata.GetPngMetadata();
 
             Assert.Equal(gifF.FrameDelay, (int)(pngF.FrameDelay.ToDouble() * 100));
 
@@ -641,7 +647,7 @@ public partial class PngEncoderTests
         encoded.CompareToReferenceOutput(ImageComparer.Exact, provider);
     }
 
-    // https://github.com/SixLabors/ImageSharp/issues/2469
+    // https://github.com/SixLabors/ImageSharp/issues/2668
     [Theory]
     [WithFile(TestImages.Png.Issue2668, PixelTypes.Rgba32)]
     public void Issue2668_Quantized_Encode_Alpha<TPixel>(TestImageProvider<TPixel> provider)
@@ -657,6 +663,39 @@ public partial class PngEncoderTests
         encoded.CompareToReferenceOutput(ImageComparer.Exact, provider);
     }
 
+    [Fact]
+    public void Issue_2862()
+    {
+        // Create a grayscale palette (or any other palette with colors that are very close to each other):
+        Rgba32[] palette = [.. Enumerable.Range(0, 256).Select(i => new Rgba32((byte)i, (byte)i, (byte)i))];
+
+        using Image<Rgba32> image = new(254, 4);
+        for (int y = 0; y < image.Height; y++)
+        {
+            for (int x = 0; x < image.Width; x++)
+            {
+                image[x, y] = palette[x];
+            }
+        }
+
+        PaletteQuantizer quantizer = new(
+            palette.Select(Color.FromPixel).ToArray(),
+            new QuantizerOptions { ColorMatchingMode = ColorMatchingMode.Hybrid });
+
+        using MemoryStream ms = new();
+        image.Save(ms, new PngEncoder
+        {
+            ColorType = PngColorType.Palette,
+            BitDepth = PngBitDepth.Bit8,
+            Quantizer = quantizer
+        });
+
+        ms.Position = 0;
+
+        using Image<Rgba32> encoded = Image.Load<Rgba32>(ms);
+        ImageComparer.Exact.VerifySimilarity(image, encoded);
+    }
+
     private static void TestPngEncoderCore<TPixel>(
         TestImageProvider<TPixel> provider,
         PngColorType pngColorType,
diff --git a/tests/ImageSharp.Tests/Formats/Png/PngFrameMetadataTests.cs b/tests/ImageSharp.Tests/Formats/Png/PngFrameMetadataTests.cs
index 8fde216545..efc18c16ae 100644
--- a/tests/ImageSharp.Tests/Formats/Png/PngFrameMetadataTests.cs
+++ b/tests/ImageSharp.Tests/Formats/Png/PngFrameMetadataTests.cs
@@ -14,7 +14,7 @@ public class PngFrameMetadataTests
     {
         PngFrameMetadata meta = new()
         {
-            FrameDelay = new(1, 0),
+            FrameDelay = new Rational(1, 0),
             DisposalMode = FrameDisposalMode.RestoreToBackground,
             BlendMode = FrameBlendMode.Over,
         };
@@ -25,7 +25,7 @@ public class PngFrameMetadataTests
         Assert.True(meta.DisposalMode.Equals(clone.DisposalMode));
         Assert.True(meta.BlendMode.Equals(clone.BlendMode));
 
-        clone.FrameDelay = new(2, 1);
+        clone.FrameDelay = new Rational(2, 1);
         clone.DisposalMode = FrameDisposalMode.RestoreToPrevious;
         clone.BlendMode = FrameBlendMode.Source;
 
diff --git a/tests/ImageSharp.Tests/Formats/Png/PngMetadataTests.cs b/tests/ImageSharp.Tests/Formats/Png/PngMetadataTests.cs
index 225e4deef2..5cbc27611a 100644
--- a/tests/ImageSharp.Tests/Formats/Png/PngMetadataTests.cs
+++ b/tests/ImageSharp.Tests/Formats/Png/PngMetadataTests.cs
@@ -31,7 +31,7 @@ public class PngMetadataTests
             ColorType = PngColorType.GrayscaleWithAlpha,
             InterlaceMethod = PngInterlaceMode.Adam7,
             Gamma = 2,
-            TextData = new List<PngTextData> { new PngTextData("name", "value", "foo", "bar") },
+            TextData = new List<PngTextData> { new("name", "value", "foo", "bar") },
             RepeatCount = 123,
             AnimateRootFrame = false
         };
diff --git a/tests/ImageSharp.Tests/Formats/Png/PngTextDataTests.cs b/tests/ImageSharp.Tests/Formats/Png/PngTextDataTests.cs
index 878f3fb8d4..4c46692f36 100644
--- a/tests/ImageSharp.Tests/Formats/Png/PngTextDataTests.cs
+++ b/tests/ImageSharp.Tests/Formats/Png/PngTextDataTests.cs
@@ -17,8 +17,8 @@ public class PngTextDataTests
     [Fact]
     public void AreEqual()
     {
-        var property1 = new PngTextData("Foo", "Bar", "foo", "bar");
-        var property2 = new PngTextData("Foo", "Bar", "foo", "bar");
+        PngTextData property1 = new("Foo", "Bar", "foo", "bar");
+        PngTextData property2 = new("Foo", "Bar", "foo", "bar");
 
         Assert.Equal(property1, property2);
         Assert.True(property1 == property2);
@@ -30,10 +30,10 @@ public class PngTextDataTests
     [Fact]
     public void AreNotEqual()
     {
-        var property1 = new PngTextData("Foo", "Bar", "foo", "bar");
-        var property2 = new PngTextData("Foo", "Foo", string.Empty, string.Empty);
-        var property3 = new PngTextData("Bar", "Bar", "unit", "test");
-        var property4 = new PngTextData("Foo", null, "test", "case");
+        PngTextData property1 = new("Foo", "Bar", "foo", "bar");
+        PngTextData property2 = new("Foo", "Foo", string.Empty, string.Empty);
+        PngTextData property3 = new("Bar", "Bar", "unit", "test");
+        PngTextData property4 = new("Foo", null, "test", "case");
 
         Assert.NotEqual(property1, property2);
         Assert.True(property1 != property2);
@@ -59,7 +59,7 @@ public class PngTextDataTests
     [Fact]
     public void ConstructorAssignsProperties()
     {
-        var property = new PngTextData("Foo", null, "unit", "test");
+        PngTextData property = new("Foo", null, "unit", "test");
         Assert.Equal("Foo", property.Keyword);
         Assert.Null(property.Value);
         Assert.Equal("unit", property.LanguageTag);
diff --git a/tests/ImageSharp.Tests/Formats/Tga/TgaDecoderTests.cs b/tests/ImageSharp.Tests/Formats/Tga/TgaDecoderTests.cs
index dbd7885e52..03669908ed 100644
--- a/tests/ImageSharp.Tests/Formats/Tga/TgaDecoderTests.cs
+++ b/tests/ImageSharp.Tests/Formats/Tga/TgaDecoderTests.cs
@@ -749,7 +749,7 @@ public class TgaDecoderTests
     {
         DecoderOptions options = new()
         {
-            TargetSize = new() { Width = 150, Height = 150 }
+            TargetSize = new Size { Width = 150, Height = 150 }
         };
 
         using Image<TPixel> image = provider.GetImage(TgaDecoder.Instance, options);
diff --git a/tests/ImageSharp.Tests/Formats/Tiff/BigTiffMetadataTests.cs b/tests/ImageSharp.Tests/Formats/Tiff/BigTiffMetadataTests.cs
index 4646de7f82..d19f27807e 100644
--- a/tests/ImageSharp.Tests/Formats/Tiff/BigTiffMetadataTests.cs
+++ b/tests/ImageSharp.Tests/Formats/Tiff/BigTiffMetadataTests.cs
@@ -16,7 +16,7 @@ public class BigTiffMetadataTests
     [Fact]
     public void ExifLong8()
     {
-        var long8 = new ExifLong8(ExifTagValue.StripByteCounts);
+        ExifLong8 long8 = new(ExifTagValue.StripByteCounts);
 
         Assert.True(long8.TrySetValue(0));
         Assert.Equal(0UL, long8.GetValue());
@@ -34,7 +34,7 @@ public class BigTiffMetadataTests
     [Fact]
     public void ExifSignedLong8()
     {
-        var long8 = new ExifSignedLong8(ExifTagValue.ImageID);
+        ExifSignedLong8 long8 = new(ExifTagValue.ImageID);
 
         Assert.False(long8.TrySetValue(0));
 
@@ -53,7 +53,7 @@ public class BigTiffMetadataTests
     [Fact]
     public void ExifLong8Array()
     {
-        var long8 = new ExifLong8Array(ExifTagValue.StripOffsets);
+        ExifLong8Array long8 = new(ExifTagValue.StripOffsets);
 
         Assert.True(long8.TrySetValue((short)-123));
         Assert.Equal(new[] { 0UL }, long8.GetValue());
@@ -91,7 +91,7 @@ public class BigTiffMetadataTests
     [Fact]
     public void ExifSignedLong8Array()
     {
-        var long8 = new ExifSignedLong8Array(ExifTagValue.StripOffsets);
+        ExifSignedLong8Array long8 = new(ExifTagValue.StripOffsets);
 
         Assert.True(long8.TrySetValue(new[] { 0L }));
         Assert.Equal(new[] { 0L }, long8.GetValue());
@@ -105,9 +105,9 @@ public class BigTiffMetadataTests
     [Fact]
     public void NotCoveredTags()
     {
-        using var input = new Image<Rgba32>(10, 10);
+        using Image<Rgba32> input = new(10, 10);
 
-        var testTags = new Dictionary<ExifTag, (ExifDataType DataType, object Value)>
+        Dictionary<ExifTag, (ExifDataType DataType, object Value)> testTags = new()
         {
             { new ExifTag<float[]>((ExifTagValue)0xdd01), (ExifDataType.SingleFloat, new float[] { 1.2f, 2.3f, 4.5f }) },
             { new ExifTag<float>((ExifTagValue)0xdd02), (ExifDataType.SingleFloat, 2.345f) },
@@ -122,7 +122,7 @@ public class BigTiffMetadataTests
         };
 
         // arrange
-        var values = new List<IExifValue>();
+        List<IExifValue> values = new();
         foreach (KeyValuePair<ExifTag, (ExifDataType DataType, object Value)> tag in testTags)
         {
             ExifValue newExifValue = ExifValues.Create((ExifTagValue)(ushort)tag.Key, tag.Value.DataType, tag.Value.Value is Array);
@@ -134,13 +134,13 @@ public class BigTiffMetadataTests
         input.Frames.RootFrame.Metadata.ExifProfile = new ExifProfile(values, Array.Empty<ExifTag>());
 
         // act
-        var encoder = new TiffEncoder();
-        using var memStream = new MemoryStream();
+        TiffEncoder encoder = new();
+        using MemoryStream memStream = new();
         input.Save(memStream, encoder);
 
         // assert
         memStream.Position = 0;
-        using var output = Image.Load<Rgba32>(memStream);
+        using Image<Rgba32> output = Image.Load<Rgba32>(memStream);
         ImageFrameMetadata loadedFrameMetadata = output.Frames.RootFrame.Metadata;
         foreach (KeyValuePair<ExifTag, (ExifDataType DataType, object Value)> tag in testTags)
         {
@@ -158,7 +158,7 @@ public class BigTiffMetadataTests
     [Fact]
     public void NotCoveredTags64bit()
     {
-        var testTags = new Dictionary<ExifTag, (ExifDataType DataType, object Value)>
+        Dictionary<ExifTag, (ExifDataType DataType, object Value)> testTags = new()
         {
             { new ExifTag<ulong>((ExifTagValue)0xdd11), (ExifDataType.Long8, ulong.MaxValue) },
             { new ExifTag<long>((ExifTagValue)0xdd12), (ExifDataType.SignedLong8, long.MaxValue) },
@@ -167,7 +167,7 @@ public class BigTiffMetadataTests
             ////{ new ExifTag<long[]>((ExifTagValue)0xdd14), (ExifDataType.SignedLong8, new long[] { -1234, 56789L, long.MaxValue }) },
         };
 
-        var values = new List<IExifValue>();
+        List<IExifValue> values = new();
         foreach (KeyValuePair<ExifTag, (ExifDataType DataType, object Value)> tag in testTags)
         {
             ExifValue newExifValue = ExifValues.Create((ExifTagValue)(ushort)tag.Key, tag.Value.DataType, tag.Value.Value is Array);
@@ -179,7 +179,7 @@ public class BigTiffMetadataTests
         // act
         byte[] inputBytes = WriteIfdTags64Bit(values);
         Configuration config = Configuration.Default;
-        var reader = new EntryReader(
+        EntryReader reader = new(
             new MemoryStream(inputBytes),
             BitConverter.IsLittleEndian ? ByteOrder.LittleEndian : ByteOrder.BigEndian,
             config.MemoryAllocator);
@@ -205,8 +205,8 @@ public class BigTiffMetadataTests
     private static byte[] WriteIfdTags64Bit(List<IExifValue> values)
     {
         byte[] buffer = new byte[8];
-        var ms = new MemoryStream();
-        var writer = new TiffStreamWriter(ms);
+        MemoryStream ms = new();
+        TiffStreamWriter writer = new(ms);
         WriteLong8(writer, buffer, (ulong)values.Count);
 
         foreach (IExifValue entry in values)
diff --git a/tests/ImageSharp.Tests/Formats/Tiff/Compression/DeflateTiffCompressionTests.cs b/tests/ImageSharp.Tests/Formats/Tiff/Compression/DeflateTiffCompressionTests.cs
index 1b12adac23..cc2faeab71 100644
--- a/tests/ImageSharp.Tests/Formats/Tiff/Compression/DeflateTiffCompressionTests.cs
+++ b/tests/ImageSharp.Tests/Formats/Tiff/Compression/DeflateTiffCompressionTests.cs
@@ -23,7 +23,7 @@ public class DeflateTiffCompressionTests
         using BufferedReadStream stream = CreateCompressedStream(data);
         byte[] buffer = new byte[data.Length];
 
-        using var decompressor = new DeflateTiffCompression(Configuration.Default.MemoryAllocator, 10, 8, TiffColorType.BlackIsZero8, TiffPredictor.None, false);
+        using DeflateTiffCompression decompressor = new(Configuration.Default.MemoryAllocator, 10, 8, TiffColorType.BlackIsZero8, TiffPredictor.None, false, false, 0, 0);
 
         decompressor.Decompress(stream, 0, (uint)stream.Length, 1, buffer, default);
 
diff --git a/tests/ImageSharp.Tests/Formats/Tiff/Compression/LzwTiffCompressionTests.cs b/tests/ImageSharp.Tests/Formats/Tiff/Compression/LzwTiffCompressionTests.cs
index 635a3a33e4..25c9633c14 100644
--- a/tests/ImageSharp.Tests/Formats/Tiff/Compression/LzwTiffCompressionTests.cs
+++ b/tests/ImageSharp.Tests/Formats/Tiff/Compression/LzwTiffCompressionTests.cs
@@ -37,7 +37,7 @@ public class LzwTiffCompressionTests
         using BufferedReadStream stream = CreateCompressedStream(data);
         byte[] buffer = new byte[data.Length];
 
-        using var decompressor = new LzwTiffCompression(Configuration.Default.MemoryAllocator, 10, 8, TiffColorType.BlackIsZero8, TiffPredictor.None, false);
+        using LzwTiffCompression decompressor = new(Configuration.Default.MemoryAllocator, 10, 8, TiffColorType.BlackIsZero8, TiffPredictor.None, false, false, 0, 0);
         decompressor.Decompress(stream, 0, (uint)stream.Length, 1, buffer, default);
 
         Assert.Equal(data, buffer);
@@ -47,7 +47,7 @@ public class LzwTiffCompressionTests
     {
         Stream compressedStream = new MemoryStream();
 
-        using (var encoder = new TiffLzwEncoder(Configuration.Default.MemoryAllocator))
+        using (TiffLzwEncoder encoder = new(Configuration.Default.MemoryAllocator))
         {
             encoder.Encode(inputData, compressedStream);
         }
diff --git a/tests/ImageSharp.Tests/Formats/Tiff/Compression/NoneTiffCompressionTests.cs b/tests/ImageSharp.Tests/Formats/Tiff/Compression/NoneTiffCompressionTests.cs
index e79ed7ce77..b911d1b177 100644
--- a/tests/ImageSharp.Tests/Formats/Tiff/Compression/NoneTiffCompressionTests.cs
+++ b/tests/ImageSharp.Tests/Formats/Tiff/Compression/NoneTiffCompressionTests.cs
@@ -14,11 +14,11 @@ public class NoneTiffCompressionTests
     [InlineData(new byte[] { 10, 15, 20, 25, 30, 35, 40, 45 }, 5, new byte[] { 10, 15, 20, 25, 30 })]
     public void Decompress_ReadsData(byte[] inputData, uint byteCount, byte[] expectedResult)
     {
-        using var memoryStream = new MemoryStream(inputData);
-        using var stream = new BufferedReadStream(Configuration.Default, memoryStream);
+        using MemoryStream memoryStream = new(inputData);
+        using BufferedReadStream stream = new(Configuration.Default, memoryStream);
         byte[] buffer = new byte[expectedResult.Length];
 
-        using var decompressor = new NoneTiffCompression(default, default, default);
+        using NoneTiffCompression decompressor = new(default, default, default);
         decompressor.Decompress(stream, 0, byteCount, 1, buffer, default);
 
         Assert.Equal(expectedResult, buffer);
diff --git a/tests/ImageSharp.Tests/Formats/Tiff/Compression/PackBitsTiffCompressionTests.cs b/tests/ImageSharp.Tests/Formats/Tiff/Compression/PackBitsTiffCompressionTests.cs
index c91ab0e7fe..8f71cdda74 100644
--- a/tests/ImageSharp.Tests/Formats/Tiff/Compression/PackBitsTiffCompressionTests.cs
+++ b/tests/ImageSharp.Tests/Formats/Tiff/Compression/PackBitsTiffCompressionTests.cs
@@ -22,11 +22,11 @@ public class PackBitsTiffCompressionTests
     [InlineData(new byte[] { 0xFE, 0xAA, 0x02, 0x80, 0x00, 0x2A, 0xFD, 0xAA, 0x03, 0x80, 0x00, 0x2A, 0x22, 0xF7, 0xAA }, new byte[] { 0xAA, 0xAA, 0xAA, 0x80, 0x00, 0x2A, 0xAA, 0xAA, 0xAA, 0xAA, 0x80, 0x00, 0x2A, 0x22, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA })] // Apple PackBits sample
     public void Decompress_ReadsData(byte[] inputData, byte[] expectedResult)
     {
-        using var memoryStream = new MemoryStream(inputData);
-        using var stream = new BufferedReadStream(Configuration.Default, memoryStream);
+        using MemoryStream memoryStream = new(inputData);
+        using BufferedReadStream stream = new(Configuration.Default, memoryStream);
         byte[] buffer = new byte[expectedResult.Length];
 
-        using var decompressor = new PackBitsTiffCompression(MemoryAllocator.Create(), default, default);
+        using PackBitsTiffCompression decompressor = new(MemoryAllocator.Create(), default, default);
         decompressor.Decompress(stream, 0, (uint)inputData.Length, 1, buffer, default);
 
         Assert.Equal(expectedResult, buffer);
diff --git a/tests/ImageSharp.Tests/Formats/Tiff/PhotometricInterpretation/BlackIsZeroTiffColorTests.cs b/tests/ImageSharp.Tests/Formats/Tiff/PhotometricInterpretation/BlackIsZeroTiffColorTests.cs
index 0fa7e01e8e..54c8172b86 100644
--- a/tests/ImageSharp.Tests/Formats/Tiff/PhotometricInterpretation/BlackIsZeroTiffColorTests.cs
+++ b/tests/ImageSharp.Tests/Formats/Tiff/PhotometricInterpretation/BlackIsZeroTiffColorTests.cs
@@ -20,100 +20,100 @@ public class BlackIsZeroTiffColorTests : PhotometricInterpretationTestBase
     private static readonly Rgba32 Bit1 = new(255, 255, 255, 255);
 
     private static readonly byte[] BilevelBytes4X4 =
-    {
+    [
         0b01010000,
         0b11110000,
         0b01110000,
         0b10010000
-    };
+    ];
 
     private static readonly Rgba32[][] BilevelResult4X4 =
-    {
-        new[] { Bit0, Bit1, Bit0, Bit1 },
-        new[] { Bit1, Bit1, Bit1, Bit1 },
-        new[] { Bit0, Bit1, Bit1, Bit1 },
-        new[] { Bit1, Bit0, Bit0, Bit1 }
-    };
+    [
+        [Bit0, Bit1, Bit0, Bit1],
+        [Bit1, Bit1, Bit1, Bit1],
+        [Bit0, Bit1, Bit1, Bit1],
+        [Bit1, Bit0, Bit0, Bit1]
+    ];
 
     private static readonly byte[] BilevelBytes12X4 =
-    {
+    [
         0b01010101, 0b01010000,
         0b11111111, 0b11111111,
         0b01101001, 0b10100000,
         0b10010000, 0b01100000
-    };
+    ];
 
     private static readonly Rgba32[][] BilevelResult12X4 =
-    {
-        new[] { Bit0, Bit1, Bit0, Bit1, Bit0, Bit1, Bit0, Bit1, Bit0, Bit1, Bit0, Bit1 },
-        new[] { Bit1, Bit1, Bit1, Bit1, Bit1, Bit1, Bit1, Bit1, Bit1, Bit1, Bit1, Bit1 },
-        new[] { Bit0, Bit1, Bit1, Bit0, Bit1, Bit0, Bit0, Bit1, Bit1, Bit0, Bit1, Bit0 },
-        new[] { Bit1, Bit0, Bit0, Bit1, Bit0, Bit0, Bit0, Bit0, Bit0, Bit1, Bit1, Bit0 }
-    };
+    [
+        [Bit0, Bit1, Bit0, Bit1, Bit0, Bit1, Bit0, Bit1, Bit0, Bit1, Bit0, Bit1],
+        [Bit1, Bit1, Bit1, Bit1, Bit1, Bit1, Bit1, Bit1, Bit1, Bit1, Bit1, Bit1],
+        [Bit0, Bit1, Bit1, Bit0, Bit1, Bit0, Bit0, Bit1, Bit1, Bit0, Bit1, Bit0],
+        [Bit1, Bit0, Bit0, Bit1, Bit0, Bit0, Bit0, Bit0, Bit0, Bit1, Bit1, Bit0]
+    ];
 
     private static readonly byte[] Grayscale4Bytes4X4 =
-    {
+    [
         0x8F, 0x0F,
         0xFF, 0xFF,
         0x08, 0x8F,
         0xF0, 0xF8
-    };
+    ];
 
     private static readonly Rgba32[][] Grayscale4Result4X4 =
-    {
-        new[] { Gray8, GrayF, Gray0, GrayF },
-        new[] { GrayF, GrayF, GrayF, GrayF },
-        new[] { Gray0, Gray8, Gray8, GrayF },
-        new[] { GrayF, Gray0, GrayF, Gray8 }
-    };
+    [
+        [Gray8, GrayF, Gray0, GrayF],
+        [GrayF, GrayF, GrayF, GrayF],
+        [Gray0, Gray8, Gray8, GrayF],
+        [GrayF, Gray0, GrayF, Gray8]
+    ];
 
     private static readonly byte[] Grayscale4Bytes3X4 =
-    {
+    [
         0x8F, 0x00,
         0xFF, 0xF0,
         0x08, 0x80,
         0xF0, 0xF0
-    };
+    ];
 
     private static readonly Rgba32[][] Grayscale4Result3X4 =
-    {
-        new[] { Gray8, GrayF, Gray0 },
-        new[] { GrayF, GrayF, GrayF },
-        new[] { Gray0, Gray8, Gray8 },
-        new[] { GrayF, Gray0, GrayF }
-    };
+    [
+        [Gray8, GrayF, Gray0],
+        [GrayF, GrayF, GrayF],
+        [Gray0, Gray8, Gray8],
+        [GrayF, Gray0, GrayF]
+    ];
 
     private static readonly byte[] Grayscale8Bytes4X4 =
-    {
+    [
         128, 255, 000, 255,
         255, 255, 255, 255,
         000, 128, 128, 255,
         255, 000, 255, 128
-    };
+    ];
 
     private static readonly Rgba32[][] Grayscale8Result4X4 =
-    {
-        new[] { Gray128, Gray255, Gray000, Gray255 },
-        new[] { Gray255, Gray255, Gray255, Gray255 },
-        new[] { Gray000, Gray128, Gray128, Gray255 },
-        new[] { Gray255, Gray000, Gray255, Gray128 }
-    };
+    [
+        [Gray128, Gray255, Gray000, Gray255],
+        [Gray255, Gray255, Gray255, Gray255],
+        [Gray000, Gray128, Gray128, Gray255],
+        [Gray255, Gray000, Gray255, Gray128]
+    ];
 
     public static IEnumerable<object[]> BilevelData
     {
         get
         {
-            yield return new object[] { BilevelBytes4X4, 1, 0, 0, 4, 4, BilevelResult4X4 };
-            yield return new object[] { BilevelBytes4X4, 1, 0, 0, 4, 4, Offset(BilevelResult4X4, 0, 0, 6, 6) };
-            yield return new object[] { BilevelBytes4X4, 1, 1, 0, 4, 4, Offset(BilevelResult4X4, 1, 0, 6, 6) };
-            yield return new object[] { BilevelBytes4X4, 1, 0, 1, 4, 4, Offset(BilevelResult4X4, 0, 1, 6, 6) };
-            yield return new object[] { BilevelBytes4X4, 1, 1, 1, 4, 4, Offset(BilevelResult4X4, 1, 1, 6, 6) };
-
-            yield return new object[] { BilevelBytes12X4, 1, 0, 0, 12, 4, BilevelResult12X4 };
-            yield return new object[] { BilevelBytes12X4, 1, 0, 0, 12, 4, Offset(BilevelResult12X4, 0, 0, 18, 6) };
-            yield return new object[] { BilevelBytes12X4, 1, 1, 0, 12, 4, Offset(BilevelResult12X4, 1, 0, 18, 6) };
-            yield return new object[] { BilevelBytes12X4, 1, 0, 1, 12, 4, Offset(BilevelResult12X4, 0, 1, 18, 6) };
-            yield return new object[] { BilevelBytes12X4, 1, 1, 1, 12, 4, Offset(BilevelResult12X4, 1, 1, 18, 6) };
+            yield return [BilevelBytes4X4, 1, 0, 0, 4, 4, BilevelResult4X4];
+            yield return [BilevelBytes4X4, 1, 0, 0, 4, 4, Offset(BilevelResult4X4, 0, 0, 6, 6)];
+            yield return [BilevelBytes4X4, 1, 1, 0, 4, 4, Offset(BilevelResult4X4, 1, 0, 6, 6)];
+            yield return [BilevelBytes4X4, 1, 0, 1, 4, 4, Offset(BilevelResult4X4, 0, 1, 6, 6)];
+            yield return [BilevelBytes4X4, 1, 1, 1, 4, 4, Offset(BilevelResult4X4, 1, 1, 6, 6)];
+
+            yield return [BilevelBytes12X4, 1, 0, 0, 12, 4, BilevelResult12X4];
+            yield return [BilevelBytes12X4, 1, 0, 0, 12, 4, Offset(BilevelResult12X4, 0, 0, 18, 6)];
+            yield return [BilevelBytes12X4, 1, 1, 0, 12, 4, Offset(BilevelResult12X4, 1, 0, 18, 6)];
+            yield return [BilevelBytes12X4, 1, 0, 1, 12, 4, Offset(BilevelResult12X4, 0, 1, 18, 6)];
+            yield return [BilevelBytes12X4, 1, 1, 1, 12, 4, Offset(BilevelResult12X4, 1, 1, 18, 6)];
         }
     }
 
@@ -121,17 +121,17 @@ public class BlackIsZeroTiffColorTests : PhotometricInterpretationTestBase
     {
         get
         {
-            yield return new object[] { Grayscale4Bytes4X4, 4, 0, 0, 4, 4, Grayscale4Result4X4 };
-            yield return new object[] { Grayscale4Bytes4X4, 4, 0, 0, 4, 4, Offset(Grayscale4Result4X4, 0, 0, 6, 6) };
-            yield return new object[] { Grayscale4Bytes4X4, 4, 1, 0, 4, 4, Offset(Grayscale4Result4X4, 1, 0, 6, 6) };
-            yield return new object[] { Grayscale4Bytes4X4, 4, 0, 1, 4, 4, Offset(Grayscale4Result4X4, 0, 1, 6, 6) };
-            yield return new object[] { Grayscale4Bytes4X4, 4, 1, 1, 4, 4, Offset(Grayscale4Result4X4, 1, 1, 6, 6) };
-
-            yield return new object[] { Grayscale4Bytes3X4, 4, 0, 0, 3, 4, Grayscale4Result3X4 };
-            yield return new object[] { Grayscale4Bytes3X4, 4, 0, 0, 3, 4, Offset(Grayscale4Result3X4, 0, 0, 6, 6) };
-            yield return new object[] { Grayscale4Bytes3X4, 4, 1, 0, 3, 4, Offset(Grayscale4Result3X4, 1, 0, 6, 6) };
-            yield return new object[] { Grayscale4Bytes3X4, 4, 0, 1, 3, 4, Offset(Grayscale4Result3X4, 0, 1, 6, 6) };
-            yield return new object[] { Grayscale4Bytes3X4, 4, 1, 1, 3, 4, Offset(Grayscale4Result3X4, 1, 1, 6, 6) };
+            yield return [Grayscale4Bytes4X4, 4, 0, 0, 4, 4, Grayscale4Result4X4];
+            yield return [Grayscale4Bytes4X4, 4, 0, 0, 4, 4, Offset(Grayscale4Result4X4, 0, 0, 6, 6)];
+            yield return [Grayscale4Bytes4X4, 4, 1, 0, 4, 4, Offset(Grayscale4Result4X4, 1, 0, 6, 6)];
+            yield return [Grayscale4Bytes4X4, 4, 0, 1, 4, 4, Offset(Grayscale4Result4X4, 0, 1, 6, 6)];
+            yield return [Grayscale4Bytes4X4, 4, 1, 1, 4, 4, Offset(Grayscale4Result4X4, 1, 1, 6, 6)];
+
+            yield return [Grayscale4Bytes3X4, 4, 0, 0, 3, 4, Grayscale4Result3X4];
+            yield return [Grayscale4Bytes3X4, 4, 0, 0, 3, 4, Offset(Grayscale4Result3X4, 0, 0, 6, 6)];
+            yield return [Grayscale4Bytes3X4, 4, 1, 0, 3, 4, Offset(Grayscale4Result3X4, 1, 0, 6, 6)];
+            yield return [Grayscale4Bytes3X4, 4, 0, 1, 3, 4, Offset(Grayscale4Result3X4, 0, 1, 6, 6)];
+            yield return [Grayscale4Bytes3X4, 4, 1, 1, 3, 4, Offset(Grayscale4Result3X4, 1, 1, 6, 6)];
         }
     }
 
@@ -139,11 +139,11 @@ public class BlackIsZeroTiffColorTests : PhotometricInterpretationTestBase
     {
         get
         {
-            yield return new object[] { Grayscale8Bytes4X4, 8, 0, 0, 4, 4, Grayscale8Result4X4 };
-            yield return new object[] { Grayscale8Bytes4X4, 8, 0, 0, 4, 4, Offset(Grayscale8Result4X4, 0, 0, 6, 6) };
-            yield return new object[] { Grayscale8Bytes4X4, 8, 1, 0, 4, 4, Offset(Grayscale8Result4X4, 1, 0, 6, 6) };
-            yield return new object[] { Grayscale8Bytes4X4, 8, 0, 1, 4, 4, Offset(Grayscale8Result4X4, 0, 1, 6, 6) };
-            yield return new object[] { Grayscale8Bytes4X4, 8, 1, 1, 4, 4, Offset(Grayscale8Result4X4, 1, 1, 6, 6) };
+            yield return [Grayscale8Bytes4X4, 8, 0, 0, 4, 4, Grayscale8Result4X4];
+            yield return [Grayscale8Bytes4X4, 8, 0, 0, 4, 4, Offset(Grayscale8Result4X4, 0, 0, 6, 6)];
+            yield return [Grayscale8Bytes4X4, 8, 1, 0, 4, 4, Offset(Grayscale8Result4X4, 1, 0, 6, 6)];
+            yield return [Grayscale8Bytes4X4, 8, 0, 1, 4, 4, Offset(Grayscale8Result4X4, 0, 1, 6, 6)];
+            yield return [Grayscale8Bytes4X4, 8, 1, 1, 4, 4, Offset(Grayscale8Result4X4, 1, 1, 6, 6)];
         }
     }
 
diff --git a/tests/ImageSharp.Tests/Formats/Tiff/PhotometricInterpretation/PaletteTiffColorTests.cs b/tests/ImageSharp.Tests/Formats/Tiff/PhotometricInterpretation/PaletteTiffColorTests.cs
index c809c6c7f9..a645f2edd3 100644
--- a/tests/ImageSharp.Tests/Formats/Tiff/PhotometricInterpretation/PaletteTiffColorTests.cs
+++ b/tests/ImageSharp.Tests/Formats/Tiff/PhotometricInterpretation/PaletteTiffColorTests.cs
@@ -15,39 +15,43 @@ public class PaletteTiffColorTests : PhotometricInterpretationTestBase
     public static ushort[] Palette4ColorMap => GenerateColorMap(Palette4ColorPalette);
 
     private static readonly byte[] Palette4Bytes4X4 =
-    {
+    [
         0x01, 0x23, 0x4A, 0xD2, 0x12, 0x34, 0xAB, 0xEF
-    };
+    ];
 
     private static readonly Rgba32[][] Palette4Result4X4 = GenerateResult(
         Palette4ColorPalette,
-        new[] { new[] { 0x00, 0x01, 0x02, 0x03 }, new[] { 0x04, 0x0A, 0x0D, 0x02 }, new[] { 0x01, 0x02, 0x03, 0x04 }, new[] { 0x0A, 0x0B, 0x0E, 0x0F } });
+        [
+            [0x00, 0x01, 0x02, 0x03], [0x04, 0x0A, 0x0D, 0x02], [0x01, 0x02, 0x03, 0x04], [0x0A, 0x0B, 0x0E, 0x0F]
+        ]);
 
     private static readonly byte[] Palette4Bytes3X4 =
-    {
+    [
         0x01, 0x20,
         0x4A, 0xD0,
         0x12, 0x30,
         0xAB, 0xE0
-    };
+    ];
 
-    private static readonly Rgba32[][] Palette4Result3X4 = GenerateResult(Palette4ColorPalette, new[] { new[] { 0x00, 0x01, 0x02 }, new[] { 0x04, 0x0A, 0x0D }, new[] { 0x01, 0x02, 0x03 }, new[] { 0x0A, 0x0B, 0x0E } });
+    private static readonly Rgba32[][] Palette4Result3X4 = GenerateResult(Palette4ColorPalette, [
+        [0x00, 0x01, 0x02], [0x04, 0x0A, 0x0D], [0x01, 0x02, 0x03], [0x0A, 0x0B, 0x0E]
+    ]);
 
     public static IEnumerable<object[]> Palette4Data
     {
         get
         {
-            yield return new object[] { Palette4Bytes4X4, 4, Palette4ColorMap, 0, 0, 4, 4, Palette4Result4X4 };
-            yield return new object[] { Palette4Bytes4X4, 4, Palette4ColorMap, 0, 0, 4, 4, Offset(Palette4Result4X4, 0, 0, 6, 6) };
-            yield return new object[] { Palette4Bytes4X4, 4, Palette4ColorMap, 1, 0, 4, 4, Offset(Palette4Result4X4, 1, 0, 6, 6) };
-            yield return new object[] { Palette4Bytes4X4, 4, Palette4ColorMap, 0, 1, 4, 4, Offset(Palette4Result4X4, 0, 1, 6, 6) };
-            yield return new object[] { Palette4Bytes4X4, 4, Palette4ColorMap, 1, 1, 4, 4, Offset(Palette4Result4X4, 1, 1, 6, 6) };
-
-            yield return new object[] { Palette4Bytes3X4, 4, Palette4ColorMap, 0, 0, 3, 4, Palette4Result3X4 };
-            yield return new object[] { Palette4Bytes3X4, 4, Palette4ColorMap, 0, 0, 3, 4, Offset(Palette4Result3X4, 0, 0, 6, 6) };
-            yield return new object[] { Palette4Bytes3X4, 4, Palette4ColorMap, 1, 0, 3, 4, Offset(Palette4Result3X4, 1, 0, 6, 6) };
-            yield return new object[] { Palette4Bytes3X4, 4, Palette4ColorMap, 0, 1, 3, 4, Offset(Palette4Result3X4, 0, 1, 6, 6) };
-            yield return new object[] { Palette4Bytes3X4, 4, Palette4ColorMap, 1, 1, 3, 4, Offset(Palette4Result3X4, 1, 1, 6, 6) };
+            yield return [Palette4Bytes4X4, 4, Palette4ColorMap, 0, 0, 4, 4, Palette4Result4X4];
+            yield return [Palette4Bytes4X4, 4, Palette4ColorMap, 0, 0, 4, 4, Offset(Palette4Result4X4, 0, 0, 6, 6)];
+            yield return [Palette4Bytes4X4, 4, Palette4ColorMap, 1, 0, 4, 4, Offset(Palette4Result4X4, 1, 0, 6, 6)];
+            yield return [Palette4Bytes4X4, 4, Palette4ColorMap, 0, 1, 4, 4, Offset(Palette4Result4X4, 0, 1, 6, 6)];
+            yield return [Palette4Bytes4X4, 4, Palette4ColorMap, 1, 1, 4, 4, Offset(Palette4Result4X4, 1, 1, 6, 6)];
+
+            yield return [Palette4Bytes3X4, 4, Palette4ColorMap, 0, 0, 3, 4, Palette4Result3X4];
+            yield return [Palette4Bytes3X4, 4, Palette4ColorMap, 0, 0, 3, 4, Offset(Palette4Result3X4, 0, 0, 6, 6)];
+            yield return [Palette4Bytes3X4, 4, Palette4ColorMap, 1, 0, 3, 4, Offset(Palette4Result3X4, 1, 0, 6, 6)];
+            yield return [Palette4Bytes3X4, 4, Palette4ColorMap, 0, 1, 3, 4, Offset(Palette4Result3X4, 0, 1, 6, 6)];
+            yield return [Palette4Bytes3X4, 4, Palette4ColorMap, 1, 1, 3, 4, Offset(Palette4Result3X4, 1, 1, 6, 6)];
         }
     }
 
@@ -56,24 +60,26 @@ public class PaletteTiffColorTests : PhotometricInterpretationTestBase
     public static ushort[] Palette8ColorMap => GenerateColorMap(Palette8ColorPalette);
 
     private static readonly byte[] Palette8Bytes4X4 =
-    {
+    [
         000, 001, 002, 003,
         100, 110, 120, 130,
         000, 255, 128, 255,
         050, 100, 150, 200
-    };
+    ];
 
-    private static readonly Rgba32[][] Palette8Result4X4 = GenerateResult(Palette8ColorPalette, new[] { new[] { 000, 001, 002, 003 }, new[] { 100, 110, 120, 130 }, new[] { 000, 255, 128, 255 }, new[] { 050, 100, 150, 200 } });
+    private static readonly Rgba32[][] Palette8Result4X4 = GenerateResult(Palette8ColorPalette, [
+        [000, 001, 002, 003], [100, 110, 120, 130], [000, 255, 128, 255], [050, 100, 150, 200]
+    ]);
 
     public static IEnumerable<object[]> Palette8Data
     {
         get
         {
-            yield return new object[] { Palette8Bytes4X4, 8, Palette8ColorMap, 0, 0, 4, 4, Palette8Result4X4 };
-            yield return new object[] { Palette8Bytes4X4, 8, Palette8ColorMap, 0, 0, 4, 4, Offset(Palette8Result4X4, 0, 0, 6, 6) };
-            yield return new object[] { Palette8Bytes4X4, 8, Palette8ColorMap, 1, 0, 4, 4, Offset(Palette8Result4X4, 1, 0, 6, 6) };
-            yield return new object[] { Palette8Bytes4X4, 8, Palette8ColorMap, 0, 1, 4, 4, Offset(Palette8Result4X4, 0, 1, 6, 6) };
-            yield return new object[] { Palette8Bytes4X4, 8, Palette8ColorMap, 1, 1, 4, 4, Offset(Palette8Result4X4, 1, 1, 6, 6) };
+            yield return [Palette8Bytes4X4, 8, Palette8ColorMap, 0, 0, 4, 4, Palette8Result4X4];
+            yield return [Palette8Bytes4X4, 8, Palette8ColorMap, 0, 0, 4, 4, Offset(Palette8Result4X4, 0, 0, 6, 6)];
+            yield return [Palette8Bytes4X4, 8, Palette8ColorMap, 1, 0, 4, 4, Offset(Palette8Result4X4, 1, 0, 6, 6)];
+            yield return [Palette8Bytes4X4, 8, Palette8ColorMap, 0, 1, 4, 4, Offset(Palette8Result4X4, 0, 1, 6, 6)];
+            yield return [Palette8Bytes4X4, 8, Palette8ColorMap, 1, 1, 4, 4, Offset(Palette8Result4X4, 1, 1, 6, 6)];
         }
     }
 
@@ -88,11 +94,11 @@ public class PaletteTiffColorTests : PhotometricInterpretationTestBase
 
     private static uint[][] GeneratePalette(int count)
     {
-        var palette = new uint[count][];
+        uint[][] palette = new uint[count][];
 
         for (uint i = 0; i < count; i++)
         {
-            palette[i] = new[] { (i * 2u) % 65536u, (i * 2625u) % 65536u, (i * 29401u) % 65536u };
+            palette[i] = [(i * 2u) % 65536u, (i * 2625u) % 65536u, (i * 29401u) % 65536u];
         }
 
         return palette;
@@ -101,7 +107,7 @@ public class PaletteTiffColorTests : PhotometricInterpretationTestBase
     private static ushort[] GenerateColorMap(uint[][] colorPalette)
     {
         int colorCount = colorPalette.Length;
-        var colorMap = new ushort[colorCount * 3];
+        ushort[] colorMap = new ushort[colorCount * 3];
 
         for (int i = 0; i < colorCount; i++)
         {
@@ -115,7 +121,7 @@ public class PaletteTiffColorTests : PhotometricInterpretationTestBase
 
     private static Rgba32[][] GenerateResult(uint[][] colorPalette, int[][] pixelLookup)
     {
-        var result = new Rgba32[pixelLookup.Length][];
+        Rgba32[][] result = new Rgba32[pixelLookup.Length][];
 
         for (int y = 0; y < pixelLookup.Length; y++)
         {
diff --git a/tests/ImageSharp.Tests/Formats/Tiff/PhotometricInterpretation/PhotometricInterpretationTestBase.cs b/tests/ImageSharp.Tests/Formats/Tiff/PhotometricInterpretation/PhotometricInterpretationTestBase.cs
index 3582dc75a6..7040e167df 100644
--- a/tests/ImageSharp.Tests/Formats/Tiff/PhotometricInterpretation/PhotometricInterpretationTestBase.cs
+++ b/tests/ImageSharp.Tests/Formats/Tiff/PhotometricInterpretation/PhotometricInterpretationTestBase.cs
@@ -10,14 +10,14 @@ namespace SixLabors.ImageSharp.Tests.Formats.Tiff.PhotometricInterpretation;
 [Trait("Format", "Tiff")]
 public abstract class PhotometricInterpretationTestBase
 {
-    public static Rgba32 DefaultColor = new Rgba32(42, 96, 18, 128);
+    public static Rgba32 DefaultColor = new(42, 96, 18, 128);
 
     public static Rgba32[][] Offset(Rgba32[][] input, int xOffset, int yOffset, int width, int height)
     {
         int inputHeight = input.Length;
         int inputWidth = input[0].Length;
 
-        var output = new Rgba32[height][];
+        Rgba32[][] output = new Rgba32[height][];
 
         for (int y = 0; y < output.Length; y++)
         {
@@ -45,7 +45,7 @@ public abstract class PhotometricInterpretationTestBase
         int resultWidth = expectedResult[0].Length;
         int resultHeight = expectedResult.Length;
 
-        using (var image = new Image<Rgba32>(resultWidth, resultHeight))
+        using (Image<Rgba32> image = new(resultWidth, resultHeight))
         {
             image.Mutate(x => x.BackgroundColor(Color.FromPixel(DefaultColor)));
             Buffer2D<Rgba32> pixels = image.GetRootFramePixelBuffer();
diff --git a/tests/ImageSharp.Tests/Formats/Tiff/PhotometricInterpretation/RgbPlanarTiffColorTests.cs b/tests/ImageSharp.Tests/Formats/Tiff/PhotometricInterpretation/RgbPlanarTiffColorTests.cs
index d8249c3619..5df7c4d62f 100644
--- a/tests/ImageSharp.Tests/Formats/Tiff/PhotometricInterpretation/RgbPlanarTiffColorTests.cs
+++ b/tests/ImageSharp.Tests/Formats/Tiff/PhotometricInterpretation/RgbPlanarTiffColorTests.cs
@@ -12,226 +12,230 @@ namespace SixLabors.ImageSharp.Tests.Formats.Tiff.PhotometricInterpretation;
 [Trait("Format", "Tiff")]
 public class RgbPlanarTiffColorTests : PhotometricInterpretationTestBase
 {
-    private static readonly Rgba32 Rgb4_000 = new Rgba32(0, 0, 0, 255);
-    private static readonly Rgba32 Rgb4_444 = new Rgba32(68, 68, 68, 255);
-    private static readonly Rgba32 Rgb4_888 = new Rgba32(136, 136, 136, 255);
-    private static readonly Rgba32 Rgb4_CCC = new Rgba32(204, 204, 204, 255);
-    private static readonly Rgba32 Rgb4_FFF = new Rgba32(255, 255, 255, 255);
-    private static readonly Rgba32 Rgb4_F00 = new Rgba32(255, 0, 0, 255);
-    private static readonly Rgba32 Rgb4_0F0 = new Rgba32(0, 255, 0, 255);
-    private static readonly Rgba32 Rgb4_00F = new Rgba32(0, 0, 255, 255);
-    private static readonly Rgba32 Rgb4_F0F = new Rgba32(255, 0, 255, 255);
-    private static readonly Rgba32 Rgb4_400 = new Rgba32(68, 0, 0, 255);
-    private static readonly Rgba32 Rgb4_800 = new Rgba32(136, 0, 0, 255);
-    private static readonly Rgba32 Rgb4_C00 = new Rgba32(204, 0, 0, 255);
-    private static readonly Rgba32 Rgb4_48C = new Rgba32(68, 136, 204, 255);
+    private static readonly Rgba32 Rgb4_000 = new(0, 0, 0, 255);
+    private static readonly Rgba32 Rgb4_444 = new(68, 68, 68, 255);
+    private static readonly Rgba32 Rgb4_888 = new(136, 136, 136, 255);
+    private static readonly Rgba32 Rgb4_CCC = new(204, 204, 204, 255);
+    private static readonly Rgba32 Rgb4_FFF = new(255, 255, 255, 255);
+    private static readonly Rgba32 Rgb4_F00 = new(255, 0, 0, 255);
+    private static readonly Rgba32 Rgb4_0F0 = new(0, 255, 0, 255);
+    private static readonly Rgba32 Rgb4_00F = new(0, 0, 255, 255);
+    private static readonly Rgba32 Rgb4_F0F = new(255, 0, 255, 255);
+    private static readonly Rgba32 Rgb4_400 = new(68, 0, 0, 255);
+    private static readonly Rgba32 Rgb4_800 = new(136, 0, 0, 255);
+    private static readonly Rgba32 Rgb4_C00 = new(204, 0, 0, 255);
+    private static readonly Rgba32 Rgb4_48C = new(68, 136, 204, 255);
 
     private static readonly byte[] Rgb4Bytes4X4R =
-    {
+    [
         0x0F, 0x0F,
         0xF0, 0x0F,
         0x48, 0xC4,
         0x04, 0x8C
-    };
+    ];
 
     private static readonly byte[] Rgb4Bytes4X4G =
-    {
+    [
         0x0F, 0x0F,
         0x0F, 0x00,
         0x00, 0x08,
         0x04, 0x8C
-    };
+    ];
 
     private static readonly byte[] Rgb4Bytes4X4B =
-    {
+    [
         0x0F, 0x0F,
         0x00, 0xFF,
         0x00, 0x0C,
         0x04, 0x8C
-    };
+    ];
 
-    private static readonly byte[][] Rgb4Bytes4X4 = { Rgb4Bytes4X4R, Rgb4Bytes4X4G, Rgb4Bytes4X4B };
+    private static readonly byte[][] Rgb4Bytes4X4 = [Rgb4Bytes4X4R, Rgb4Bytes4X4G, Rgb4Bytes4X4B];
 
     private static readonly Rgba32[][] Rgb4Result4X4 =
-    {
-        new[] { Rgb4_000, Rgb4_FFF, Rgb4_000, Rgb4_FFF },
-        new[] { Rgb4_F00, Rgb4_0F0, Rgb4_00F, Rgb4_F0F },
-        new[] { Rgb4_400, Rgb4_800, Rgb4_C00, Rgb4_48C },
-        new[] { Rgb4_000, Rgb4_444, Rgb4_888, Rgb4_CCC }
-    };
+    [
+        [Rgb4_000, Rgb4_FFF, Rgb4_000, Rgb4_FFF],
+        [Rgb4_F00, Rgb4_0F0, Rgb4_00F, Rgb4_F0F],
+        [Rgb4_400, Rgb4_800, Rgb4_C00, Rgb4_48C],
+        [Rgb4_000, Rgb4_444, Rgb4_888, Rgb4_CCC]
+    ];
 
     private static readonly byte[] Rgb4Bytes3X4R =
-    {
+    [
         0x0F, 0x00,
         0xF0, 0x00,
         0x48, 0xC0,
         0x04, 0x80
-    };
+    ];
 
     private static readonly byte[] Rgb4Bytes3X4G =
-    {
+    [
         0x0F, 0x00,
         0x0F, 0x00,
         0x00, 0x00,
         0x04, 0x80
-    };
+    ];
 
     private static readonly byte[] Rgb4Bytes3X4B =
-    {
+    [
         0x0F, 0x00,
         0x00, 0xF0,
         0x00, 0x00,
         0x04, 0x80
-    };
+    ];
 
-    private static readonly byte[][] Rgb4Bytes3X4 = { Rgb4Bytes3X4R, Rgb4Bytes3X4G, Rgb4Bytes3X4B };
+    private static readonly byte[][] Rgb4Bytes3X4 = [Rgb4Bytes3X4R, Rgb4Bytes3X4G, Rgb4Bytes3X4B];
 
     private static readonly Rgba32[][] Rgb4Result3X4 =
-    {
-        new[] { Rgb4_000, Rgb4_FFF, Rgb4_000 },
-        new[] { Rgb4_F00, Rgb4_0F0, Rgb4_00F },
-        new[] { Rgb4_400, Rgb4_800, Rgb4_C00 },
-        new[] { Rgb4_000, Rgb4_444, Rgb4_888 }
-    };
+    [
+        [Rgb4_000, Rgb4_FFF, Rgb4_000],
+        [Rgb4_F00, Rgb4_0F0, Rgb4_00F],
+        [Rgb4_400, Rgb4_800, Rgb4_C00],
+        [Rgb4_000, Rgb4_444, Rgb4_888]
+    ];
 
     public static IEnumerable<object[]> Rgb4Data
     {
         get
         {
-            yield return new object[] { Rgb4Bytes4X4, new TiffBitsPerSample(4, 4, 4), 0, 0, 4, 4, Rgb4Result4X4 };
-            yield return new object[] { Rgb4Bytes4X4, new TiffBitsPerSample(4, 4, 4), 0, 0, 4, 4, Offset(Rgb4Result4X4, 0, 0, 6, 6) };
-            yield return new object[] { Rgb4Bytes4X4, new TiffBitsPerSample(4, 4, 4), 1, 0, 4, 4, Offset(Rgb4Result4X4, 1, 0, 6, 6) };
-            yield return new object[] { Rgb4Bytes4X4, new TiffBitsPerSample(4, 4, 4), 0, 1, 4, 4, Offset(Rgb4Result4X4, 0, 1, 6, 6) };
-            yield return new object[] { Rgb4Bytes4X4, new TiffBitsPerSample(4, 4, 4), 1, 1, 4, 4, Offset(Rgb4Result4X4, 1, 1, 6, 6) };
-
-            yield return new object[] { Rgb4Bytes3X4, new TiffBitsPerSample(4, 4, 4), 0, 0, 3, 4, Rgb4Result3X4 };
-            yield return new object[] { Rgb4Bytes3X4, new TiffBitsPerSample(4, 4, 4), 0, 0, 3, 4, Offset(Rgb4Result3X4, 0, 0, 6, 6) };
-            yield return new object[] { Rgb4Bytes3X4, new TiffBitsPerSample(4, 4, 4), 1, 0, 3, 4, Offset(Rgb4Result3X4, 1, 0, 6, 6) };
-            yield return new object[] { Rgb4Bytes3X4, new TiffBitsPerSample(4, 4, 4), 0, 1, 3, 4, Offset(Rgb4Result3X4, 0, 1, 6, 6) };
-            yield return new object[] { Rgb4Bytes3X4, new TiffBitsPerSample(4, 4, 4), 1, 1, 3, 4, Offset(Rgb4Result3X4, 1, 1, 6, 6) };
+            yield return [Rgb4Bytes4X4, new TiffBitsPerSample(4, 4, 4), 0, 0, 4, 4, Rgb4Result4X4];
+            yield return [Rgb4Bytes4X4, new TiffBitsPerSample(4, 4, 4), 0, 0, 4, 4, Offset(Rgb4Result4X4, 0, 0, 6, 6)];
+            yield return [Rgb4Bytes4X4, new TiffBitsPerSample(4, 4, 4), 1, 0, 4, 4, Offset(Rgb4Result4X4, 1, 0, 6, 6)];
+            yield return [Rgb4Bytes4X4, new TiffBitsPerSample(4, 4, 4), 0, 1, 4, 4, Offset(Rgb4Result4X4, 0, 1, 6, 6)];
+            yield return [Rgb4Bytes4X4, new TiffBitsPerSample(4, 4, 4), 1, 1, 4, 4, Offset(Rgb4Result4X4, 1, 1, 6, 6)];
+
+            yield return [Rgb4Bytes3X4, new TiffBitsPerSample(4, 4, 4), 0, 0, 3, 4, Rgb4Result3X4];
+            yield return [Rgb4Bytes3X4, new TiffBitsPerSample(4, 4, 4), 0, 0, 3, 4, Offset(Rgb4Result3X4, 0, 0, 6, 6)];
+            yield return [Rgb4Bytes3X4, new TiffBitsPerSample(4, 4, 4), 1, 0, 3, 4, Offset(Rgb4Result3X4, 1, 0, 6, 6)];
+            yield return [Rgb4Bytes3X4, new TiffBitsPerSample(4, 4, 4), 0, 1, 3, 4, Offset(Rgb4Result3X4, 0, 1, 6, 6)];
+            yield return [Rgb4Bytes3X4, new TiffBitsPerSample(4, 4, 4), 1, 1, 3, 4, Offset(Rgb4Result3X4, 1, 1, 6, 6)];
         }
     }
 
-    private static readonly Rgba32 Rgb8_000 = new Rgba32(0, 0, 0, 255);
-    private static readonly Rgba32 Rgb8_444 = new Rgba32(64, 64, 64, 255);
-    private static readonly Rgba32 Rgb8_888 = new Rgba32(128, 128, 128, 255);
-    private static readonly Rgba32 Rgb8_CCC = new Rgba32(192, 192, 192, 255);
-    private static readonly Rgba32 Rgb8_FFF = new Rgba32(255, 255, 255, 255);
-    private static readonly Rgba32 Rgb8_F00 = new Rgba32(255, 0, 0, 255);
-    private static readonly Rgba32 Rgb8_0F0 = new Rgba32(0, 255, 0, 255);
-    private static readonly Rgba32 Rgb8_00F = new Rgba32(0, 0, 255, 255);
-    private static readonly Rgba32 Rgb8_F0F = new Rgba32(255, 0, 255, 255);
-    private static readonly Rgba32 Rgb8_400 = new Rgba32(64, 0, 0, 255);
-    private static readonly Rgba32 Rgb8_800 = new Rgba32(128, 0, 0, 255);
-    private static readonly Rgba32 Rgb8_C00 = new Rgba32(192, 0, 0, 255);
-    private static readonly Rgba32 Rgb8_48C = new Rgba32(64, 128, 192, 255);
+    private static readonly Rgba32 Rgb8_000 = new(0, 0, 0, 255);
+    private static readonly Rgba32 Rgb8_444 = new(64, 64, 64, 255);
+    private static readonly Rgba32 Rgb8_888 = new(128, 128, 128, 255);
+    private static readonly Rgba32 Rgb8_CCC = new(192, 192, 192, 255);
+    private static readonly Rgba32 Rgb8_FFF = new(255, 255, 255, 255);
+    private static readonly Rgba32 Rgb8_F00 = new(255, 0, 0, 255);
+    private static readonly Rgba32 Rgb8_0F0 = new(0, 255, 0, 255);
+    private static readonly Rgba32 Rgb8_00F = new(0, 0, 255, 255);
+    private static readonly Rgba32 Rgb8_F0F = new(255, 0, 255, 255);
+    private static readonly Rgba32 Rgb8_400 = new(64, 0, 0, 255);
+    private static readonly Rgba32 Rgb8_800 = new(128, 0, 0, 255);
+    private static readonly Rgba32 Rgb8_C00 = new(192, 0, 0, 255);
+    private static readonly Rgba32 Rgb8_48C = new(64, 128, 192, 255);
 
     private static readonly byte[] Rgb8Bytes4X4R =
-    {
+    [
         000, 255, 000, 255,
         255, 000, 000, 255,
         064, 128, 192, 064,
         000, 064, 128, 192
-    };
+    ];
 
     private static readonly byte[] Rgb8Bytes4X4G =
-    {
+    [
         000, 255, 000, 255,
         000, 255, 000, 000,
         000, 000, 000, 128,
         000, 064, 128, 192
-    };
+    ];
 
     private static readonly byte[] Rgb8Bytes4X4B =
-    {
+    [
         000, 255, 000, 255,
         000, 000, 255, 255,
         000, 000, 000, 192,
         000, 064, 128, 192
-    };
+    ];
 
     private static readonly byte[][] Rgb8Bytes4X4 =
-    {
+    [
         Rgb8Bytes4X4R, Rgb8Bytes4X4G, Rgb8Bytes4X4B
-    };
+    ];
 
     private static readonly Rgba32[][] Rgb8Result4X4 =
-    {
-        new[] { Rgb8_000, Rgb8_FFF, Rgb8_000, Rgb8_FFF },
-        new[] { Rgb8_F00, Rgb8_0F0, Rgb8_00F, Rgb8_F0F },
-        new[] { Rgb8_400, Rgb8_800, Rgb8_C00, Rgb8_48C },
-        new[] { Rgb8_000, Rgb8_444, Rgb8_888, Rgb8_CCC }
-    };
+    [
+        [Rgb8_000, Rgb8_FFF, Rgb8_000, Rgb8_FFF],
+        [Rgb8_F00, Rgb8_0F0, Rgb8_00F, Rgb8_F0F],
+        [Rgb8_400, Rgb8_800, Rgb8_C00, Rgb8_48C],
+        [Rgb8_000, Rgb8_444, Rgb8_888, Rgb8_CCC]
+    ];
 
     public static IEnumerable<object[]> Rgb8Data
     {
         get
         {
-            yield return new object[] { Rgb8Bytes4X4, new TiffBitsPerSample(8, 8, 8), 0, 0, 4, 4, Rgb8Result4X4 };
-            yield return new object[] { Rgb8Bytes4X4, new TiffBitsPerSample(8, 8, 8), 0, 0, 4, 4, Offset(Rgb8Result4X4, 0, 0, 6, 6) };
-            yield return new object[] { Rgb8Bytes4X4, new TiffBitsPerSample(8, 8, 8), 1, 0, 4, 4, Offset(Rgb8Result4X4, 1, 0, 6, 6) };
-            yield return new object[] { Rgb8Bytes4X4, new TiffBitsPerSample(8, 8, 8), 0, 1, 4, 4, Offset(Rgb8Result4X4, 0, 1, 6, 6) };
-            yield return new object[] { Rgb8Bytes4X4, new TiffBitsPerSample(8, 8, 8), 1, 1, 4, 4, Offset(Rgb8Result4X4, 1, 1, 6, 6) };
+            yield return [Rgb8Bytes4X4, new TiffBitsPerSample(8, 8, 8), 0, 0, 4, 4, Rgb8Result4X4];
+            yield return [Rgb8Bytes4X4, new TiffBitsPerSample(8, 8, 8), 0, 0, 4, 4, Offset(Rgb8Result4X4, 0, 0, 6, 6)];
+            yield return [Rgb8Bytes4X4, new TiffBitsPerSample(8, 8, 8), 1, 0, 4, 4, Offset(Rgb8Result4X4, 1, 0, 6, 6)];
+            yield return [Rgb8Bytes4X4, new TiffBitsPerSample(8, 8, 8), 0, 1, 4, 4, Offset(Rgb8Result4X4, 0, 1, 6, 6)];
+            yield return [Rgb8Bytes4X4, new TiffBitsPerSample(8, 8, 8), 1, 1, 4, 4, Offset(Rgb8Result4X4, 1, 1, 6, 6)];
         }
     }
 
-    private static readonly Rgba32 Rgb484_000 = new Rgba32(0, 0, 0, 255);
-    private static readonly Rgba32 Rgb484_444 = new Rgba32(68, 64, 68, 255);
-    private static readonly Rgba32 Rgb484_888 = new Rgba32(136, 128, 136, 255);
-    private static readonly Rgba32 Rgb484_CCC = new Rgba32(204, 192, 204, 255);
-    private static readonly Rgba32 Rgb484_FFF = new Rgba32(255, 255, 255, 255);
-    private static readonly Rgba32 Rgb484_F00 = new Rgba32(255, 0, 0, 255);
-    private static readonly Rgba32 Rgb484_0F0 = new Rgba32(0, 255, 0, 255);
-    private static readonly Rgba32 Rgb484_00F = new Rgba32(0, 0, 255, 255);
-    private static readonly Rgba32 Rgb484_F0F = new Rgba32(255, 0, 255, 255);
-    private static readonly Rgba32 Rgb484_400 = new Rgba32(68, 0, 0, 255);
-    private static readonly Rgba32 Rgb484_800 = new Rgba32(136, 0, 0, 255);
-    private static readonly Rgba32 Rgb484_C00 = new Rgba32(204, 0, 0, 255);
-    private static readonly Rgba32 Rgb484_48C = new Rgba32(68, 128, 204, 255);
+    private static readonly Rgba32 Rgb484_000 = new(0, 0, 0, 255);
+    private static readonly Rgba32 Rgb484_444 = new(68, 64, 68, 255);
+    private static readonly Rgba32 Rgb484_888 = new(136, 128, 136, 255);
+    private static readonly Rgba32 Rgb484_CCC = new(204, 192, 204, 255);
+    private static readonly Rgba32 Rgb484_FFF = new(255, 255, 255, 255);
+    private static readonly Rgba32 Rgb484_F00 = new(255, 0, 0, 255);
+    private static readonly Rgba32 Rgb484_0F0 = new(0, 255, 0, 255);
+    private static readonly Rgba32 Rgb484_00F = new(0, 0, 255, 255);
+    private static readonly Rgba32 Rgb484_F0F = new(255, 0, 255, 255);
+    private static readonly Rgba32 Rgb484_400 = new(68, 0, 0, 255);
+    private static readonly Rgba32 Rgb484_800 = new(136, 0, 0, 255);
+    private static readonly Rgba32 Rgb484_C00 = new(204, 0, 0, 255);
+    private static readonly Rgba32 Rgb484_48C = new(68, 128, 204, 255);
 
     private static readonly byte[] Rgb484Bytes4X4R =
-    {
+    [
         0x0F, 0x0F,
         0xF0, 0x0F,
         0x48, 0xC4,
         0x04, 0x8C
-    };
+    ];
 
     private static readonly byte[] Rgb484Bytes4X4G =
-    {
+    [
         0x00, 0xFF, 0x00, 0xFF,
         0x00, 0xFF, 0x00, 0x00,
         0x00, 0x00, 0x00, 0x80,
         0x00, 0x40, 0x80, 0xC0
-    };
+    ];
 
     private static readonly byte[] Rgb484Bytes4X4B =
-    {
+    [
         0x0F, 0x0F,
         0x00, 0xFF,
         0x00, 0x0C,
         0x04, 0x8C
-    };
+    ];
 
     private static readonly Rgba32[][] Rgb484Result4X4 =
-    {
-        new[] { Rgb484_000, Rgb484_FFF, Rgb484_000, Rgb484_FFF },
-        new[] { Rgb484_F00, Rgb484_0F0, Rgb484_00F, Rgb484_F0F },
-        new[] { Rgb484_400, Rgb484_800, Rgb484_C00, Rgb484_48C },
-        new[] { Rgb484_000, Rgb484_444, Rgb484_888, Rgb484_CCC }
-    };
+    [
+        [Rgb484_000, Rgb484_FFF, Rgb484_000, Rgb484_FFF],
+        [Rgb484_F00, Rgb484_0F0, Rgb484_00F, Rgb484_F0F],
+        [Rgb484_400, Rgb484_800, Rgb484_C00, Rgb484_48C],
+        [Rgb484_000, Rgb484_444, Rgb484_888, Rgb484_CCC]
+    ];
 
-    private static readonly byte[][] Rgb484Bytes4X4 = { Rgb484Bytes4X4R, Rgb484Bytes4X4G, Rgb484Bytes4X4B };
+    private static readonly byte[][] Rgb484Bytes4X4 = [Rgb484Bytes4X4R, Rgb484Bytes4X4G, Rgb484Bytes4X4B];
 
     public static IEnumerable<object[]> Rgb484_Data
     {
         get
         {
-            yield return new object[] { Rgb484Bytes4X4, new TiffBitsPerSample(4, 8, 4), 0, 0, 4, 4, Rgb484Result4X4 };
-            yield return new object[] { Rgb484Bytes4X4, new TiffBitsPerSample(4, 8, 4), 0, 0, 4, 4, Offset(Rgb484Result4X4, 0, 0, 6, 6) };
-            yield return new object[] { Rgb484Bytes4X4, new TiffBitsPerSample(4, 8, 4), 1, 0, 4, 4, Offset(Rgb484Result4X4, 1, 0, 6, 6) };
-            yield return new object[] { Rgb484Bytes4X4, new TiffBitsPerSample(4, 8, 4), 0, 1, 4, 4, Offset(Rgb484Result4X4, 0, 1, 6, 6) };
-            yield return new object[] { Rgb484Bytes4X4, new TiffBitsPerSample(4, 8, 4), 1, 1, 4, 4, Offset(Rgb484Result4X4, 1, 1, 6, 6) };
+            yield return [Rgb484Bytes4X4, new TiffBitsPerSample(4, 8, 4), 0, 0, 4, 4, Rgb484Result4X4];
+            yield return [Rgb484Bytes4X4, new TiffBitsPerSample(4, 8, 4), 0, 0, 4, 4, Offset(Rgb484Result4X4, 0, 0, 6, 6)
+            ];
+            yield return [Rgb484Bytes4X4, new TiffBitsPerSample(4, 8, 4), 1, 0, 4, 4, Offset(Rgb484Result4X4, 1, 0, 6, 6)
+            ];
+            yield return [Rgb484Bytes4X4, new TiffBitsPerSample(4, 8, 4), 0, 1, 4, 4, Offset(Rgb484Result4X4, 0, 1, 6, 6)
+            ];
+            yield return [Rgb484Bytes4X4, new TiffBitsPerSample(4, 8, 4), 1, 1, 4, 4, Offset(Rgb484Result4X4, 1, 1, 6, 6)
+            ];
         }
     }
 
@@ -251,7 +255,7 @@ public class RgbPlanarTiffColorTests : PhotometricInterpretationTestBase
             expectedResult,
             pixels =>
             {
-                var buffers = new IMemoryOwner<byte>[inputData.Length];
+                IMemoryOwner<byte>[] buffers = new IMemoryOwner<byte>[inputData.Length];
                 for (int i = 0; i < buffers.Length; i++)
                 {
                     buffers[i] = Configuration.Default.MemoryAllocator.Allocate<byte>(inputData[i].Length);
diff --git a/tests/ImageSharp.Tests/Formats/Tiff/PhotometricInterpretation/RgbTiffColorTests.cs b/tests/ImageSharp.Tests/Formats/Tiff/PhotometricInterpretation/RgbTiffColorTests.cs
index aeb135773c..6935d504ed 100644
--- a/tests/ImageSharp.Tests/Formats/Tiff/PhotometricInterpretation/RgbTiffColorTests.cs
+++ b/tests/ImageSharp.Tests/Formats/Tiff/PhotometricInterpretation/RgbTiffColorTests.cs
@@ -10,151 +10,155 @@ namespace SixLabors.ImageSharp.Tests.Formats.Tiff.PhotometricInterpretation;
 [Trait("Format", "Tiff")]
 public class RgbTiffColorTests : PhotometricInterpretationTestBase
 {
-    private static readonly Rgba32 Rgb4_000 = new Rgba32(0, 0, 0, 255);
-    private static readonly Rgba32 Rgb4_444 = new Rgba32(68, 68, 68, 255);
-    private static readonly Rgba32 Rgb4_888 = new Rgba32(136, 136, 136, 255);
-    private static readonly Rgba32 Rgb4_CCC = new Rgba32(204, 204, 204, 255);
-    private static readonly Rgba32 Rgb4_FFF = new Rgba32(255, 255, 255, 255);
-    private static readonly Rgba32 Rgb4_F00 = new Rgba32(255, 0, 0, 255);
-    private static readonly Rgba32 Rgb4_0F0 = new Rgba32(0, 255, 0, 255);
-    private static readonly Rgba32 Rgb4_00F = new Rgba32(0, 0, 255, 255);
-    private static readonly Rgba32 Rgb4_F0F = new Rgba32(255, 0, 255, 255);
-    private static readonly Rgba32 Rgb4_400 = new Rgba32(68, 0, 0, 255);
-    private static readonly Rgba32 Rgb4_800 = new Rgba32(136, 0, 0, 255);
-    private static readonly Rgba32 Rgb4_C00 = new Rgba32(204, 0, 0, 255);
-    private static readonly Rgba32 Rgb4_48C = new Rgba32(68, 136, 204, 255);
+    private static readonly Rgba32 Rgb4_000 = new(0, 0, 0, 255);
+    private static readonly Rgba32 Rgb4_444 = new(68, 68, 68, 255);
+    private static readonly Rgba32 Rgb4_888 = new(136, 136, 136, 255);
+    private static readonly Rgba32 Rgb4_CCC = new(204, 204, 204, 255);
+    private static readonly Rgba32 Rgb4_FFF = new(255, 255, 255, 255);
+    private static readonly Rgba32 Rgb4_F00 = new(255, 0, 0, 255);
+    private static readonly Rgba32 Rgb4_0F0 = new(0, 255, 0, 255);
+    private static readonly Rgba32 Rgb4_00F = new(0, 0, 255, 255);
+    private static readonly Rgba32 Rgb4_F0F = new(255, 0, 255, 255);
+    private static readonly Rgba32 Rgb4_400 = new(68, 0, 0, 255);
+    private static readonly Rgba32 Rgb4_800 = new(136, 0, 0, 255);
+    private static readonly Rgba32 Rgb4_C00 = new(204, 0, 0, 255);
+    private static readonly Rgba32 Rgb4_48C = new(68, 136, 204, 255);
 
     private static readonly byte[] Rgb4Bytes4X4 =
-    {
+    [
         0x00, 0x0F, 0xFF, 0x00, 0x0F, 0xFF,
         0xF0, 0x00, 0xF0, 0x00, 0xFF, 0x0F,
         0x40, 0x08, 0x00, 0xC0, 0x04, 0x8C,
         0x00, 0x04, 0x44, 0x88, 0x8C, 0xCC
-    };
+    ];
 
     private static readonly Rgba32[][] Rgb4Result4X4 =
-    {
-        new[] { Rgb4_000, Rgb4_FFF, Rgb4_000, Rgb4_FFF },
-        new[] { Rgb4_F00, Rgb4_0F0, Rgb4_00F, Rgb4_F0F },
-        new[] { Rgb4_400, Rgb4_800, Rgb4_C00, Rgb4_48C },
-        new[] { Rgb4_000, Rgb4_444, Rgb4_888, Rgb4_CCC }
-    };
+    [
+        [Rgb4_000, Rgb4_FFF, Rgb4_000, Rgb4_FFF],
+        [Rgb4_F00, Rgb4_0F0, Rgb4_00F, Rgb4_F0F],
+        [Rgb4_400, Rgb4_800, Rgb4_C00, Rgb4_48C],
+        [Rgb4_000, Rgb4_444, Rgb4_888, Rgb4_CCC]
+    ];
 
     private static readonly byte[] Rgb4Bytes3X4 =
-    {
+    [
         0x00, 0x0F, 0xFF, 0x00, 0x00,
         0xF0, 0x00, 0xF0, 0x00, 0xF0,
         0x40, 0x08, 0x00, 0xC0, 0x00,
         0x00, 0x04, 0x44, 0x88, 0x80
-    };
+    ];
 
     private static readonly Rgba32[][] Rgb4Result3X4 =
-    {
-        new[] { Rgb4_000, Rgb4_FFF, Rgb4_000 },
-        new[] { Rgb4_F00, Rgb4_0F0, Rgb4_00F },
-        new[] { Rgb4_400, Rgb4_800, Rgb4_C00 },
-        new[] { Rgb4_000, Rgb4_444, Rgb4_888 }
-    };
+    [
+        [Rgb4_000, Rgb4_FFF, Rgb4_000],
+        [Rgb4_F00, Rgb4_0F0, Rgb4_00F],
+        [Rgb4_400, Rgb4_800, Rgb4_C00],
+        [Rgb4_000, Rgb4_444, Rgb4_888]
+    ];
 
     public static IEnumerable<object[]> Rgb4Data
     {
         get
         {
-            yield return new object[] { Rgb4Bytes4X4, new TiffBitsPerSample(4, 4, 4), 0, 0, 4, 4, Rgb4Result4X4 };
-            yield return new object[] { Rgb4Bytes4X4, new TiffBitsPerSample(4, 4, 4), 0, 0, 4, 4, Offset(Rgb4Result4X4, 0, 0, 6, 6) };
-            yield return new object[] { Rgb4Bytes4X4, new TiffBitsPerSample(4, 4, 4), 1, 0, 4, 4, Offset(Rgb4Result4X4, 1, 0, 6, 6) };
-            yield return new object[] { Rgb4Bytes4X4, new TiffBitsPerSample(4, 4, 4), 0, 1, 4, 4, Offset(Rgb4Result4X4, 0, 1, 6, 6) };
-            yield return new object[] { Rgb4Bytes4X4, new TiffBitsPerSample(4, 4, 4), 1, 1, 4, 4, Offset(Rgb4Result4X4, 1, 1, 6, 6) };
-
-            yield return new object[] { Rgb4Bytes3X4, new TiffBitsPerSample(4, 4, 4), 0, 0, 3, 4, Rgb4Result3X4 };
-            yield return new object[] { Rgb4Bytes3X4, new TiffBitsPerSample(4, 4, 4), 0, 0, 3, 4, Offset(Rgb4Result3X4, 0, 0, 6, 6) };
-            yield return new object[] { Rgb4Bytes3X4, new TiffBitsPerSample(4, 4, 4), 1, 0, 3, 4, Offset(Rgb4Result3X4, 1, 0, 6, 6) };
-            yield return new object[] { Rgb4Bytes3X4, new TiffBitsPerSample(4, 4, 4), 0, 1, 3, 4, Offset(Rgb4Result3X4, 0, 1, 6, 6) };
-            yield return new object[] { Rgb4Bytes3X4, new TiffBitsPerSample(4, 4, 4), 1, 1, 3, 4, Offset(Rgb4Result3X4, 1, 1, 6, 6) };
+            yield return [Rgb4Bytes4X4, new TiffBitsPerSample(4, 4, 4), 0, 0, 4, 4, Rgb4Result4X4];
+            yield return [Rgb4Bytes4X4, new TiffBitsPerSample(4, 4, 4), 0, 0, 4, 4, Offset(Rgb4Result4X4, 0, 0, 6, 6)];
+            yield return [Rgb4Bytes4X4, new TiffBitsPerSample(4, 4, 4), 1, 0, 4, 4, Offset(Rgb4Result4X4, 1, 0, 6, 6)];
+            yield return [Rgb4Bytes4X4, new TiffBitsPerSample(4, 4, 4), 0, 1, 4, 4, Offset(Rgb4Result4X4, 0, 1, 6, 6)];
+            yield return [Rgb4Bytes4X4, new TiffBitsPerSample(4, 4, 4), 1, 1, 4, 4, Offset(Rgb4Result4X4, 1, 1, 6, 6)];
+
+            yield return [Rgb4Bytes3X4, new TiffBitsPerSample(4, 4, 4), 0, 0, 3, 4, Rgb4Result3X4];
+            yield return [Rgb4Bytes3X4, new TiffBitsPerSample(4, 4, 4), 0, 0, 3, 4, Offset(Rgb4Result3X4, 0, 0, 6, 6)];
+            yield return [Rgb4Bytes3X4, new TiffBitsPerSample(4, 4, 4), 1, 0, 3, 4, Offset(Rgb4Result3X4, 1, 0, 6, 6)];
+            yield return [Rgb4Bytes3X4, new TiffBitsPerSample(4, 4, 4), 0, 1, 3, 4, Offset(Rgb4Result3X4, 0, 1, 6, 6)];
+            yield return [Rgb4Bytes3X4, new TiffBitsPerSample(4, 4, 4), 1, 1, 3, 4, Offset(Rgb4Result3X4, 1, 1, 6, 6)];
         }
     }
 
-    private static readonly Rgba32 Rgb8_000 = new Rgba32(0, 0, 0, 255);
-    private static readonly Rgba32 Rgb8_444 = new Rgba32(64, 64, 64, 255);
-    private static readonly Rgba32 Rgb8_888 = new Rgba32(128, 128, 128, 255);
-    private static readonly Rgba32 Rgb8_CCC = new Rgba32(192, 192, 192, 255);
-    private static readonly Rgba32 Rgb8_FFF = new Rgba32(255, 255, 255, 255);
-    private static readonly Rgba32 Rgb8_F00 = new Rgba32(255, 0, 0, 255);
-    private static readonly Rgba32 Rgb8_0F0 = new Rgba32(0, 255, 0, 255);
-    private static readonly Rgba32 Rgb8_00F = new Rgba32(0, 0, 255, 255);
-    private static readonly Rgba32 Rgb8_F0F = new Rgba32(255, 0, 255, 255);
-    private static readonly Rgba32 Rgb8_400 = new Rgba32(64, 0, 0, 255);
-    private static readonly Rgba32 Rgb8_800 = new Rgba32(128, 0, 0, 255);
-    private static readonly Rgba32 Rgb8_C00 = new Rgba32(192, 0, 0, 255);
-    private static readonly Rgba32 Rgb8_48C = new Rgba32(64, 128, 192, 255);
+    private static readonly Rgba32 Rgb8_000 = new(0, 0, 0, 255);
+    private static readonly Rgba32 Rgb8_444 = new(64, 64, 64, 255);
+    private static readonly Rgba32 Rgb8_888 = new(128, 128, 128, 255);
+    private static readonly Rgba32 Rgb8_CCC = new(192, 192, 192, 255);
+    private static readonly Rgba32 Rgb8_FFF = new(255, 255, 255, 255);
+    private static readonly Rgba32 Rgb8_F00 = new(255, 0, 0, 255);
+    private static readonly Rgba32 Rgb8_0F0 = new(0, 255, 0, 255);
+    private static readonly Rgba32 Rgb8_00F = new(0, 0, 255, 255);
+    private static readonly Rgba32 Rgb8_F0F = new(255, 0, 255, 255);
+    private static readonly Rgba32 Rgb8_400 = new(64, 0, 0, 255);
+    private static readonly Rgba32 Rgb8_800 = new(128, 0, 0, 255);
+    private static readonly Rgba32 Rgb8_C00 = new(192, 0, 0, 255);
+    private static readonly Rgba32 Rgb8_48C = new(64, 128, 192, 255);
 
     private static readonly byte[] Rgb8Bytes4X4 =
-    {
+    [
         000, 000, 000, 255, 255, 255, 000, 000, 000, 255, 255, 255,
         255, 000, 000, 000, 255, 000, 000, 000, 255, 255, 000, 255,
         064, 000, 000, 128, 000, 000, 192, 000, 000, 064, 128, 192,
         000, 000, 000, 064, 064, 064, 128, 128, 128, 192, 192, 192
-    };
+    ];
 
     private static readonly Rgba32[][] Rgb8Result4X4 =
-    {
-        new[] { Rgb8_000, Rgb8_FFF, Rgb8_000, Rgb8_FFF },
-        new[] { Rgb8_F00, Rgb8_0F0, Rgb8_00F, Rgb8_F0F },
-        new[] { Rgb8_400, Rgb8_800, Rgb8_C00, Rgb8_48C },
-        new[] { Rgb8_000, Rgb8_444, Rgb8_888, Rgb8_CCC }
-    };
+    [
+        [Rgb8_000, Rgb8_FFF, Rgb8_000, Rgb8_FFF],
+        [Rgb8_F00, Rgb8_0F0, Rgb8_00F, Rgb8_F0F],
+        [Rgb8_400, Rgb8_800, Rgb8_C00, Rgb8_48C],
+        [Rgb8_000, Rgb8_444, Rgb8_888, Rgb8_CCC]
+    ];
 
     public static IEnumerable<object[]> Rgb8Data
     {
         get
         {
-            yield return new object[] { Rgb8Bytes4X4, new TiffBitsPerSample(8, 8, 8), 0, 0, 4, 4, Rgb8Result4X4 };
-            yield return new object[] { Rgb8Bytes4X4, new TiffBitsPerSample(8, 8, 8), 0, 0, 4, 4, Offset(Rgb8Result4X4, 0, 0, 6, 6) };
-            yield return new object[] { Rgb8Bytes4X4, new TiffBitsPerSample(8, 8, 8), 1, 0, 4, 4, Offset(Rgb8Result4X4, 1, 0, 6, 6) };
-            yield return new object[] { Rgb8Bytes4X4, new TiffBitsPerSample(8, 8, 8), 0, 1, 4, 4, Offset(Rgb8Result4X4, 0, 1, 6, 6) };
-            yield return new object[] { Rgb8Bytes4X4, new TiffBitsPerSample(8, 8, 8), 1, 1, 4, 4, Offset(Rgb8Result4X4, 1, 1, 6, 6) };
+            yield return [Rgb8Bytes4X4, new TiffBitsPerSample(8, 8, 8), 0, 0, 4, 4, Rgb8Result4X4];
+            yield return [Rgb8Bytes4X4, new TiffBitsPerSample(8, 8, 8), 0, 0, 4, 4, Offset(Rgb8Result4X4, 0, 0, 6, 6)];
+            yield return [Rgb8Bytes4X4, new TiffBitsPerSample(8, 8, 8), 1, 0, 4, 4, Offset(Rgb8Result4X4, 1, 0, 6, 6)];
+            yield return [Rgb8Bytes4X4, new TiffBitsPerSample(8, 8, 8), 0, 1, 4, 4, Offset(Rgb8Result4X4, 0, 1, 6, 6)];
+            yield return [Rgb8Bytes4X4, new TiffBitsPerSample(8, 8, 8), 1, 1, 4, 4, Offset(Rgb8Result4X4, 1, 1, 6, 6)];
         }
     }
 
-    private static readonly Rgba32 Rgb484_000 = new Rgba32(0, 0, 0, 255);
-    private static readonly Rgba32 Rgb484_444 = new Rgba32(68, 64, 68, 255);
-    private static readonly Rgba32 Rgb484_888 = new Rgba32(136, 128, 136, 255);
-    private static readonly Rgba32 Rgb484_CCC = new Rgba32(204, 192, 204, 255);
-    private static readonly Rgba32 Rgb484_FFF = new Rgba32(255, 255, 255, 255);
-    private static readonly Rgba32 Rgb484_F00 = new Rgba32(255, 0, 0, 255);
-    private static readonly Rgba32 Rgb484_0F0 = new Rgba32(0, 255, 0, 255);
-    private static readonly Rgba32 Rgb484_00F = new Rgba32(0, 0, 255, 255);
-    private static readonly Rgba32 Rgb484_F0F = new Rgba32(255, 0, 255, 255);
-    private static readonly Rgba32 Rgb484_400 = new Rgba32(68, 0, 0, 255);
-    private static readonly Rgba32 Rgb484_800 = new Rgba32(136, 0, 0, 255);
-    private static readonly Rgba32 Rgb484_C00 = new Rgba32(204, 0, 0, 255);
-    private static readonly Rgba32 Rgb484_48C = new Rgba32(68, 128, 204, 255);
+    private static readonly Rgba32 Rgb484_000 = new(0, 0, 0, 255);
+    private static readonly Rgba32 Rgb484_444 = new(68, 64, 68, 255);
+    private static readonly Rgba32 Rgb484_888 = new(136, 128, 136, 255);
+    private static readonly Rgba32 Rgb484_CCC = new(204, 192, 204, 255);
+    private static readonly Rgba32 Rgb484_FFF = new(255, 255, 255, 255);
+    private static readonly Rgba32 Rgb484_F00 = new(255, 0, 0, 255);
+    private static readonly Rgba32 Rgb484_0F0 = new(0, 255, 0, 255);
+    private static readonly Rgba32 Rgb484_00F = new(0, 0, 255, 255);
+    private static readonly Rgba32 Rgb484_F0F = new(255, 0, 255, 255);
+    private static readonly Rgba32 Rgb484_400 = new(68, 0, 0, 255);
+    private static readonly Rgba32 Rgb484_800 = new(136, 0, 0, 255);
+    private static readonly Rgba32 Rgb484_C00 = new(204, 0, 0, 255);
+    private static readonly Rgba32 Rgb484_48C = new(68, 128, 204, 255);
 
     private static readonly byte[] Rgb484Bytes4X4 =
-    {
+    [
         0x00, 0x00, 0xFF, 0xFF, 0x00, 0x00, 0xFF, 0xFF,
         0xF0, 0x00, 0x0F, 0xF0, 0x00, 0x0F, 0xF0, 0x0F,
         0x40, 0x00, 0x80, 0x00, 0xC0, 0x00, 0x48, 0x0C,
         0x00, 0x00, 0x44, 0x04, 0x88, 0x08, 0xCC, 0x0C
-    };
+    ];
 
     private static readonly Rgba32[][] Rgb484Result4X4 =
-    {
-        new[] { Rgb484_000, Rgb484_FFF, Rgb484_000, Rgb484_FFF },
-        new[] { Rgb484_F00, Rgb484_0F0, Rgb484_00F, Rgb484_F0F },
-        new[] { Rgb484_400, Rgb484_800, Rgb484_C00, Rgb484_48C },
-        new[] { Rgb484_000, Rgb484_444, Rgb484_888, Rgb484_CCC }
-    };
+    [
+        [Rgb484_000, Rgb484_FFF, Rgb484_000, Rgb484_FFF],
+        [Rgb484_F00, Rgb484_0F0, Rgb484_00F, Rgb484_F0F],
+        [Rgb484_400, Rgb484_800, Rgb484_C00, Rgb484_48C],
+        [Rgb484_000, Rgb484_444, Rgb484_888, Rgb484_CCC]
+    ];
 
     public static IEnumerable<object[]> Rgb484Data
     {
         get
         {
-            yield return new object[] { Rgb484Bytes4X4, new TiffBitsPerSample(4, 8, 4), 0, 0, 4, 4, Rgb484Result4X4 };
-            yield return new object[] { Rgb484Bytes4X4, new TiffBitsPerSample(4, 8, 4), 0, 0, 4, 4, Offset(Rgb484Result4X4, 0, 0, 6, 6) };
-            yield return new object[] { Rgb484Bytes4X4, new TiffBitsPerSample(4, 8, 4), 1, 0, 4, 4, Offset(Rgb484Result4X4, 1, 0, 6, 6) };
-            yield return new object[] { Rgb484Bytes4X4, new TiffBitsPerSample(4, 8, 4), 0, 1, 4, 4, Offset(Rgb484Result4X4, 0, 1, 6, 6) };
-            yield return new object[] { Rgb484Bytes4X4, new TiffBitsPerSample(4, 8, 4), 1, 1, 4, 4, Offset(Rgb484Result4X4, 1, 1, 6, 6) };
+            yield return [Rgb484Bytes4X4, new TiffBitsPerSample(4, 8, 4), 0, 0, 4, 4, Rgb484Result4X4];
+            yield return [Rgb484Bytes4X4, new TiffBitsPerSample(4, 8, 4), 0, 0, 4, 4, Offset(Rgb484Result4X4, 0, 0, 6, 6)
+            ];
+            yield return [Rgb484Bytes4X4, new TiffBitsPerSample(4, 8, 4), 1, 0, 4, 4, Offset(Rgb484Result4X4, 1, 0, 6, 6)
+            ];
+            yield return [Rgb484Bytes4X4, new TiffBitsPerSample(4, 8, 4), 0, 1, 4, 4, Offset(Rgb484Result4X4, 0, 1, 6, 6)
+            ];
+            yield return [Rgb484Bytes4X4, new TiffBitsPerSample(4, 8, 4), 1, 1, 4, 4, Offset(Rgb484Result4X4, 1, 1, 6, 6)
+            ];
         }
     }
 
diff --git a/tests/ImageSharp.Tests/Formats/Tiff/PhotometricInterpretation/WhiteIsZeroTiffColorTests.cs b/tests/ImageSharp.Tests/Formats/Tiff/PhotometricInterpretation/WhiteIsZeroTiffColorTests.cs
index 0b58e3891e..7a09bfae7f 100644
--- a/tests/ImageSharp.Tests/Formats/Tiff/PhotometricInterpretation/WhiteIsZeroTiffColorTests.cs
+++ b/tests/ImageSharp.Tests/Formats/Tiff/PhotometricInterpretation/WhiteIsZeroTiffColorTests.cs
@@ -10,110 +10,110 @@ namespace SixLabors.ImageSharp.Tests.Formats.Tiff.PhotometricInterpretation;
 [Trait("Format", "Tiff")]
 public class WhiteIsZeroTiffColorTests : PhotometricInterpretationTestBase
 {
-    private static readonly Rgba32 Gray000 = new Rgba32(255, 255, 255, 255);
-    private static readonly Rgba32 Gray128 = new Rgba32(127, 127, 127, 255);
-    private static readonly Rgba32 Gray255 = new Rgba32(0, 0, 0, 255);
-    private static readonly Rgba32 Gray0 = new Rgba32(255, 255, 255, 255);
-    private static readonly Rgba32 Gray8 = new Rgba32(119, 119, 119, 255);
-    private static readonly Rgba32 GrayF = new Rgba32(0, 0, 0, 255);
-    private static readonly Rgba32 Bit0 = new Rgba32(255, 255, 255, 255);
-    private static readonly Rgba32 Bit1 = new Rgba32(0, 0, 0, 255);
+    private static readonly Rgba32 Gray000 = new(255, 255, 255, 255);
+    private static readonly Rgba32 Gray128 = new(127, 127, 127, 255);
+    private static readonly Rgba32 Gray255 = new(0, 0, 0, 255);
+    private static readonly Rgba32 Gray0 = new(255, 255, 255, 255);
+    private static readonly Rgba32 Gray8 = new(119, 119, 119, 255);
+    private static readonly Rgba32 GrayF = new(0, 0, 0, 255);
+    private static readonly Rgba32 Bit0 = new(255, 255, 255, 255);
+    private static readonly Rgba32 Bit1 = new(0, 0, 0, 255);
 
     private static readonly byte[] BilevelBytes4X4 =
-    {
+    [
         0b01010000,
         0b11110000,
         0b01110000,
         0b10010000
-    };
+    ];
 
     private static readonly Rgba32[][] BilevelResult4X4 =
-    {
-        new[] { Bit0, Bit1, Bit0, Bit1 },
-        new[] { Bit1, Bit1, Bit1, Bit1 },
-        new[] { Bit0, Bit1, Bit1, Bit1 },
-        new[] { Bit1, Bit0, Bit0, Bit1 }
-    };
+    [
+        [Bit0, Bit1, Bit0, Bit1],
+        [Bit1, Bit1, Bit1, Bit1],
+        [Bit0, Bit1, Bit1, Bit1],
+        [Bit1, Bit0, Bit0, Bit1]
+    ];
 
     private static readonly byte[] BilevelBytes12X4 =
-    {
+    [
         0b01010101, 0b01010000,
         0b11111111, 0b11111111,
         0b01101001, 0b10100000,
         0b10010000, 0b01100000
-    };
+    ];
 
     private static readonly Rgba32[][] BilevelResult12X4 =
-    {
-        new[] { Bit0, Bit1, Bit0, Bit1, Bit0, Bit1, Bit0, Bit1, Bit0, Bit1, Bit0, Bit1 },
-        new[] { Bit1, Bit1, Bit1, Bit1, Bit1, Bit1, Bit1, Bit1, Bit1, Bit1, Bit1, Bit1 },
-        new[] { Bit0, Bit1, Bit1, Bit0, Bit1, Bit0, Bit0, Bit1, Bit1, Bit0, Bit1, Bit0 },
-        new[] { Bit1, Bit0, Bit0, Bit1, Bit0, Bit0, Bit0, Bit0, Bit0, Bit1, Bit1, Bit0 }
-    };
+    [
+        [Bit0, Bit1, Bit0, Bit1, Bit0, Bit1, Bit0, Bit1, Bit0, Bit1, Bit0, Bit1],
+        [Bit1, Bit1, Bit1, Bit1, Bit1, Bit1, Bit1, Bit1, Bit1, Bit1, Bit1, Bit1],
+        [Bit0, Bit1, Bit1, Bit0, Bit1, Bit0, Bit0, Bit1, Bit1, Bit0, Bit1, Bit0],
+        [Bit1, Bit0, Bit0, Bit1, Bit0, Bit0, Bit0, Bit0, Bit0, Bit1, Bit1, Bit0]
+    ];
 
     private static readonly byte[] Grayscale4Bytes4X4 =
-    {
+    [
         0x8F, 0x0F,
         0xFF, 0xFF,
         0x08, 0x8F,
         0xF0, 0xF8
-    };
+    ];
 
     private static readonly Rgba32[][] Grayscale4Result4X4 =
-    {
-        new[] { Gray8, GrayF, Gray0, GrayF },
-        new[] { GrayF, GrayF, GrayF, GrayF },
-        new[] { Gray0, Gray8, Gray8, GrayF },
-        new[] { GrayF, Gray0, GrayF, Gray8 }
-    };
+    [
+        [Gray8, GrayF, Gray0, GrayF],
+        [GrayF, GrayF, GrayF, GrayF],
+        [Gray0, Gray8, Gray8, GrayF],
+        [GrayF, Gray0, GrayF, Gray8]
+    ];
 
     private static readonly byte[] Grayscale4Bytes3X4 =
-    {
+    [
         0x8F, 0x00,
         0xFF, 0xF0,
         0x08, 0x80,
         0xF0, 0xF0
-    };
+    ];
 
     private static readonly Rgba32[][] Grayscale4Result3X4 =
-    {
-        new[] { Gray8, GrayF, Gray0 },
-        new[] { GrayF, GrayF, GrayF },
-        new[] { Gray0, Gray8, Gray8 },
-        new[] { GrayF, Gray0, GrayF }
-    };
+    [
+        [Gray8, GrayF, Gray0],
+        [GrayF, GrayF, GrayF],
+        [Gray0, Gray8, Gray8],
+        [GrayF, Gray0, GrayF]
+    ];
 
     private static readonly byte[] Grayscale8Bytes4X4 =
-    {
+    [
         128, 255, 000, 255,
         255, 255, 255, 255,
         000, 128, 128, 255,
         255, 000, 255, 128
-    };
+    ];
 
     private static readonly Rgba32[][] Grayscale8Result4X4 =
-    {
-        new[] { Gray128, Gray255, Gray000, Gray255 },
-        new[] { Gray255, Gray255, Gray255, Gray255 },
-        new[] { Gray000, Gray128, Gray128, Gray255 },
-        new[] { Gray255, Gray000, Gray255, Gray128 }
-    };
+    [
+        [Gray128, Gray255, Gray000, Gray255],
+        [Gray255, Gray255, Gray255, Gray255],
+        [Gray000, Gray128, Gray128, Gray255],
+        [Gray255, Gray000, Gray255, Gray128]
+    ];
 
     public static IEnumerable<object[]> BilevelData
     {
         get
         {
-            yield return new object[] { BilevelBytes4X4, 1, 0, 0, 4, 4, BilevelResult4X4 };
-            yield return new object[] { BilevelBytes4X4, 1, 0, 0, 4, 4, Offset(BilevelResult4X4, 0, 0, 6, 6) };
-            yield return new object[] { BilevelBytes4X4, 1, 1, 0, 4, 4, Offset(BilevelResult4X4, 1, 0, 6, 6) };
-            yield return new object[] { BilevelBytes4X4, 1, 0, 1, 4, 4, Offset(BilevelResult4X4, 0, 1, 6, 6) };
-            yield return new object[] { BilevelBytes4X4, 1, 1, 1, 4, 4, Offset(BilevelResult4X4, 1, 1, 6, 6) };
-
-            yield return new object[] { BilevelBytes12X4, 1, 0, 0, 12, 4, BilevelResult12X4 };
-            yield return new object[] { BilevelBytes12X4, 1, 0, 0, 12, 4, Offset(BilevelResult12X4, 0, 0, 18, 6) };
-            yield return new object[] { BilevelBytes12X4, 1, 1, 0, 12, 4, Offset(BilevelResult12X4, 1, 0, 18, 6) };
-            yield return new object[] { BilevelBytes12X4, 1, 0, 1, 12, 4, Offset(BilevelResult12X4, 0, 1, 18, 6) };
-            yield return new object[] { BilevelBytes12X4, 1, 1, 1, 12, 4, Offset(BilevelResult12X4, 1, 1, 18, 6) };
+            yield return [BilevelBytes4X4, 1, 0, 0, 4, 4, BilevelResult4X4];
+            yield return [BilevelBytes4X4, 1, 0, 0, 4, 4, Offset(BilevelResult4X4, 0, 0, 6, 6)];
+            yield return [BilevelBytes4X4, 1, 1, 0, 4, 4, Offset(BilevelResult4X4, 1, 0, 6, 6)];
+            yield return [BilevelBytes4X4, 1, 0, 1, 4, 4, Offset(BilevelResult4X4, 0, 1, 6, 6)];
+            yield return [BilevelBytes4X4, 1, 1, 1, 4, 4, Offset(BilevelResult4X4, 1, 1, 6, 6)];
+
+            yield return [BilevelBytes12X4, 1, 0, 0, 12, 4, BilevelResult12X4];
+            yield return [BilevelBytes12X4, 1, 0, 0, 12, 4, Offset(BilevelResult12X4, 0, 0, 18, 6)];
+            yield return [BilevelBytes12X4, 1, 1, 0, 12, 4, Offset(BilevelResult12X4, 1, 0, 18, 6)];
+            yield return [BilevelBytes12X4, 1, 0, 1, 12, 4, Offset(BilevelResult12X4, 0, 1, 18, 6)];
+            yield return [BilevelBytes12X4, 1, 1, 1, 12, 4, Offset(BilevelResult12X4, 1, 1, 18, 6)];
         }
     }
 
@@ -121,17 +121,17 @@ public class WhiteIsZeroTiffColorTests : PhotometricInterpretationTestBase
     {
         get
         {
-            yield return new object[] { Grayscale4Bytes4X4, 4, 0, 0, 4, 4, Grayscale4Result4X4 };
-            yield return new object[] { Grayscale4Bytes4X4, 4, 0, 0, 4, 4, Offset(Grayscale4Result4X4, 0, 0, 6, 6) };
-            yield return new object[] { Grayscale4Bytes4X4, 4, 1, 0, 4, 4, Offset(Grayscale4Result4X4, 1, 0, 6, 6) };
-            yield return new object[] { Grayscale4Bytes4X4, 4, 0, 1, 4, 4, Offset(Grayscale4Result4X4, 0, 1, 6, 6) };
-            yield return new object[] { Grayscale4Bytes4X4, 4, 1, 1, 4, 4, Offset(Grayscale4Result4X4, 1, 1, 6, 6) };
-
-            yield return new object[] { Grayscale4Bytes3X4, 4, 0, 0, 3, 4, Grayscale4Result3X4 };
-            yield return new object[] { Grayscale4Bytes3X4, 4, 0, 0, 3, 4, Offset(Grayscale4Result3X4, 0, 0, 6, 6) };
-            yield return new object[] { Grayscale4Bytes3X4, 4, 1, 0, 3, 4, Offset(Grayscale4Result3X4, 1, 0, 6, 6) };
-            yield return new object[] { Grayscale4Bytes3X4, 4, 0, 1, 3, 4, Offset(Grayscale4Result3X4, 0, 1, 6, 6) };
-            yield return new object[] { Grayscale4Bytes3X4, 4, 1, 1, 3, 4, Offset(Grayscale4Result3X4, 1, 1, 6, 6) };
+            yield return [Grayscale4Bytes4X4, 4, 0, 0, 4, 4, Grayscale4Result4X4];
+            yield return [Grayscale4Bytes4X4, 4, 0, 0, 4, 4, Offset(Grayscale4Result4X4, 0, 0, 6, 6)];
+            yield return [Grayscale4Bytes4X4, 4, 1, 0, 4, 4, Offset(Grayscale4Result4X4, 1, 0, 6, 6)];
+            yield return [Grayscale4Bytes4X4, 4, 0, 1, 4, 4, Offset(Grayscale4Result4X4, 0, 1, 6, 6)];
+            yield return [Grayscale4Bytes4X4, 4, 1, 1, 4, 4, Offset(Grayscale4Result4X4, 1, 1, 6, 6)];
+
+            yield return [Grayscale4Bytes3X4, 4, 0, 0, 3, 4, Grayscale4Result3X4];
+            yield return [Grayscale4Bytes3X4, 4, 0, 0, 3, 4, Offset(Grayscale4Result3X4, 0, 0, 6, 6)];
+            yield return [Grayscale4Bytes3X4, 4, 1, 0, 3, 4, Offset(Grayscale4Result3X4, 1, 0, 6, 6)];
+            yield return [Grayscale4Bytes3X4, 4, 0, 1, 3, 4, Offset(Grayscale4Result3X4, 0, 1, 6, 6)];
+            yield return [Grayscale4Bytes3X4, 4, 1, 1, 3, 4, Offset(Grayscale4Result3X4, 1, 1, 6, 6)];
         }
     }
 
@@ -139,11 +139,11 @@ public class WhiteIsZeroTiffColorTests : PhotometricInterpretationTestBase
     {
         get
         {
-            yield return new object[] { Grayscale8Bytes4X4, 8, 0, 0, 4, 4, Grayscale8Result4X4 };
-            yield return new object[] { Grayscale8Bytes4X4, 8, 0, 0, 4, 4, Offset(Grayscale8Result4X4, 0, 0, 6, 6) };
-            yield return new object[] { Grayscale8Bytes4X4, 8, 1, 0, 4, 4, Offset(Grayscale8Result4X4, 1, 0, 6, 6) };
-            yield return new object[] { Grayscale8Bytes4X4, 8, 0, 1, 4, 4, Offset(Grayscale8Result4X4, 0, 1, 6, 6) };
-            yield return new object[] { Grayscale8Bytes4X4, 8, 1, 1, 4, 4, Offset(Grayscale8Result4X4, 1, 1, 6, 6) };
+            yield return [Grayscale8Bytes4X4, 8, 0, 0, 4, 4, Grayscale8Result4X4];
+            yield return [Grayscale8Bytes4X4, 8, 0, 0, 4, 4, Offset(Grayscale8Result4X4, 0, 0, 6, 6)];
+            yield return [Grayscale8Bytes4X4, 8, 1, 0, 4, 4, Offset(Grayscale8Result4X4, 1, 0, 6, 6)];
+            yield return [Grayscale8Bytes4X4, 8, 0, 1, 4, 4, Offset(Grayscale8Result4X4, 0, 1, 6, 6)];
+            yield return [Grayscale8Bytes4X4, 8, 1, 1, 4, 4, Offset(Grayscale8Result4X4, 1, 1, 6, 6)];
         }
     }
 
diff --git a/tests/ImageSharp.Tests/Formats/Tiff/TiffDecoderTests.cs b/tests/ImageSharp.Tests/Formats/Tiff/TiffDecoderTests.cs
index 09cfe2cbea..5dd1f7884f 100644
--- a/tests/ImageSharp.Tests/Formats/Tiff/TiffDecoderTests.cs
+++ b/tests/ImageSharp.Tests/Formats/Tiff/TiffDecoderTests.cs
@@ -90,6 +90,40 @@ public class TiffDecoderTests : TiffDecoderBaseTester
     public void TiffDecoder_CanDecode_Tiled<TPixel>(TestImageProvider<TPixel> provider)
         where TPixel : unmanaged, IPixel<TPixel> => TestTiffDecoder(provider);
 
+    [Theory]
+    [WithFile(TiledRgbaDeflateCompressedWithPredictor, PixelTypes.Rgba32)]
+    [WithFile(TiledRgbDeflateCompressedWithPredictor, PixelTypes.Rgba32)]
+    [WithFile(TiledGrayDeflateCompressedWithPredictor, PixelTypes.Rgba32)]
+    [WithFile(TiledGray16BitLittleEndianDeflateCompressedWithPredictor, PixelTypes.Rgba32)]
+    [WithFile(TiledGray16BitBigEndianDeflateCompressedWithPredictor, PixelTypes.Rgba32)]
+    [WithFile(TiledGray32BitLittleEndianDeflateCompressedWithPredictor, PixelTypes.Rgba32)]
+    [WithFile(TiledGray32BitBigEndianDeflateCompressedWithPredictor, PixelTypes.Rgba32)]
+    [WithFile(TiledRgb48BitLittleEndianDeflateCompressedWithPredictor, PixelTypes.Rgba32)]
+    [WithFile(TiledRgb48BitBigEndianDeflateCompressedWithPredictor, PixelTypes.Rgba32)]
+    [WithFile(TiledRgba64BitLittleEndianDeflateCompressedWithPredictor, PixelTypes.Rgba32)]
+    [WithFile(TiledRgba64BitBigEndianDeflateCompressedWithPredictor, PixelTypes.Rgba32)]
+    [WithFile(TiledRgb96BitLittleEndianDeflateCompressedWithPredictor, PixelTypes.Rgba32)]
+    [WithFile(TiledRgb96BitBigEndianDeflateCompressedWithPredictor, PixelTypes.Rgba32)]
+    public void TiffDecoder_CanDecode_Tiled_Deflate_Compressed<TPixel>(TestImageProvider<TPixel> provider)
+        where TPixel : unmanaged, IPixel<TPixel> => TestTiffDecoder(provider);
+
+    [Theory]
+    [WithFile(TiledRgbaLzwCompressedWithPredictor, PixelTypes.Rgba32)]
+    [WithFile(TiledRgbLzwCompressedWithPredictor, PixelTypes.Rgba32)]
+    [WithFile(TiledGrayLzwCompressedWithPredictor, PixelTypes.Rgba32)]
+    [WithFile(TiledGray16BitLittleEndianLzwCompressedWithPredictor, PixelTypes.Rgba32)]
+    [WithFile(TiledGray16BitBigEndianLzwCompressedWithPredictor, PixelTypes.Rgba32)]
+    [WithFile(TiledGray32BitLittleEndianLzwCompressedWithPredictor, PixelTypes.Rgba32)]
+    [WithFile(TiledGray32BitBigEndianLzwCompressedWithPredictor, PixelTypes.Rgba32)]
+    [WithFile(TiledRgb48BitLittleEndianLzwCompressedWithPredictor, PixelTypes.Rgba32)]
+    [WithFile(TiledRgb48BitBigEndianLzwCompressedWithPredictor, PixelTypes.Rgba32)]
+    [WithFile(TiledRgba64BitLittleEndianLzwCompressedWithPredictor, PixelTypes.Rgba32)]
+    [WithFile(TiledRgba64BitBigEndianLzwCompressedWithPredictor, PixelTypes.Rgba32)]
+    [WithFile(TiledRgb96BitLittleEndianLzwCompressedWithPredictor, PixelTypes.Rgba32)]
+    [WithFile(TiledRgb96BitBigEndianDeflateCompressedWithPredictor, PixelTypes.Rgba32)]
+    public void TiffDecoder_CanDecode_Tiled_Lzw_Compressed<TPixel>(TestImageProvider<TPixel> provider)
+        where TPixel : unmanaged, IPixel<TPixel> => TestTiffDecoder(provider);
+
     [Theory]
     [WithFile(Rgba8BitPlanarUnassociatedAlpha, PixelTypes.Rgba32)]
     public void TiffDecoder_CanDecode_Planar_32Bit<TPixel>(TestImageProvider<TPixel> provider)
@@ -307,16 +341,46 @@ public class TiffDecoderTests : TiffDecoderBaseTester
     [Theory]
     [WithFile(Cmyk, PixelTypes.Rgba32)]
     [WithFile(CmykLzwPredictor, PixelTypes.Rgba32)]
+    [WithFile(CmykJpeg, PixelTypes.Rgba32)]
     public void TiffDecoder_CanDecode_Cmyk<TPixel>(TestImageProvider<TPixel> provider)
         where TPixel : unmanaged, IPixel<TPixel>
     {
         // Note: The image from MagickReferenceDecoder does not look right, maybe we are doing something wrong
         // converting the pixel data from Magick.NET to our format with CMYK?
-        using Image<TPixel> image = provider.GetImage();
+        using Image<TPixel> image = provider.GetImage(TiffDecoder.Instance);
+        image.DebugSave(provider);
+        image.CompareToReferenceOutput(ImageComparer.Exact, provider);
+    }
+
+    [Theory]
+    [WithFile(Issues2454_A, PixelTypes.Rgba32)]
+    [WithFile(Issues2454_B, PixelTypes.Rgba32)]
+    public void TiffDecoder_CanDecode_YccK<TPixel>(TestImageProvider<TPixel> provider)
+        where TPixel : unmanaged, IPixel<TPixel>
+    {
+        using Image<TPixel> image = provider.GetImage(TiffDecoder.Instance);
         image.DebugSave(provider);
         image.CompareToReferenceOutput(ImageComparer.Exact, provider);
     }
 
+    [Theory]
+    [WithFile(Issues2454_A, PixelTypes.Rgba32)]
+    [WithFile(Issues2454_B, PixelTypes.Rgba32)]
+    public void TiffDecoder_CanDecode_YccK_ICC<TPixel>(TestImageProvider<TPixel> provider)
+        where TPixel : unmanaged, IPixel<TPixel>
+    {
+        DecoderOptions options = new()
+        {
+            ColorProfileHandling = ColorProfileHandling.Convert,
+        };
+
+        using Image<TPixel> image = provider.GetImage(TiffDecoder.Instance, options);
+        image.DebugSave(provider);
+
+        // Linux reports a 0.0000% difference, so we use a tolerant comparer here.
+        image.CompareToReferenceOutput(ImageComparer.TolerantPercentage(0.0001F), provider);
+    }
+
     [Theory]
     [WithFile(FlowerRgb101010Contiguous, PixelTypes.Rgba32)]
     [WithFile(FlowerRgb101010Planar, PixelTypes.Rgba32)]
@@ -746,7 +810,7 @@ public class TiffDecoderTests : TiffDecoderBaseTester
     {
         DecoderOptions options = new()
         {
-            TargetSize = new() { Width = 150, Height = 150 }
+            TargetSize = new Size { Width = 150, Height = 150 }
         };
 
         using Image<TPixel> image = provider.GetImage(TiffDecoder.Instance, options);
@@ -764,4 +828,9 @@ public class TiffDecoderTests : TiffDecoderBaseTester
             testOutputDetails: details,
             appendPixelTypeToFileName: false);
     }
+
+    [Theory]
+    [WithFile(ExtraSamplesUnspecified, PixelTypes.Rgba32)]
+    public void TiffDecoder_CanDecode_ExtraSamplesUnspecified<TPixel>(TestImageProvider<TPixel> provider)
+        where TPixel : unmanaged, IPixel<TPixel> => TestTiffDecoder(provider);
 }
diff --git a/tests/ImageSharp.Tests/Formats/Tiff/TiffEncoderBaseTester.cs b/tests/ImageSharp.Tests/Formats/Tiff/TiffEncoderBaseTester.cs
index 1bf9f5a400..158a0d4730 100644
--- a/tests/ImageSharp.Tests/Formats/Tiff/TiffEncoderBaseTester.cs
+++ b/tests/ImageSharp.Tests/Formats/Tiff/TiffEncoderBaseTester.cs
@@ -26,9 +26,9 @@ public abstract class TiffEncoderBaseTester
         where TPixel : unmanaged, IPixel<TPixel>
     {
         // arrange
-        var tiffEncoder = new TiffEncoder() { PhotometricInterpretation = photometricInterpretation, Compression = compression };
+        TiffEncoder tiffEncoder = new() { PhotometricInterpretation = photometricInterpretation, Compression = compression };
         using Image<TPixel> input = provider.GetImage();
-        using var memStream = new MemoryStream();
+        using MemoryStream memStream = new();
         TiffFrameMetadata inputMeta = input.Frames.RootFrame.Metadata.GetTiffMetadata();
         TiffCompression inputCompression = inputMeta.Compression;
 
@@ -37,7 +37,7 @@ public abstract class TiffEncoderBaseTester
 
         // assert
         memStream.Position = 0;
-        using var output = Image.Load<Rgba32>(memStream);
+        using Image<Rgba32> output = Image.Load<Rgba32>(memStream);
         ExifProfile exifProfileOutput = output.Frames.RootFrame.Metadata.ExifProfile;
         TiffFrameMetadata outputMeta = output.Frames.RootFrame.Metadata.GetTiffMetadata();
         ImageFrame<Rgba32> rootFrame = output.Frames.RootFrame;
@@ -89,7 +89,7 @@ public abstract class TiffEncoderBaseTester
         where TPixel : unmanaged, IPixel<TPixel>
     {
         using Image<TPixel> image = provider.GetImage();
-        var encoder = new TiffEncoder
+        TiffEncoder encoder = new()
         {
             PhotometricInterpretation = photometricInterpretation,
             BitsPerPixel = bitsPerPixel,
diff --git a/tests/ImageSharp.Tests/Formats/Tiff/TiffEncoderMultiframeTests.cs b/tests/ImageSharp.Tests/Formats/Tiff/TiffEncoderMultiframeTests.cs
index 716b978a71..9f6e74183f 100644
--- a/tests/ImageSharp.Tests/Formats/Tiff/TiffEncoderMultiframeTests.cs
+++ b/tests/ImageSharp.Tests/Formats/Tiff/TiffEncoderMultiframeTests.cs
@@ -46,7 +46,7 @@ public class TiffEncoderMultiframeTests : TiffEncoderBaseTester
         image.Frames.RemoveFrame(0);
 
         TiffBitsPerPixel bitsPerPixel = TiffBitsPerPixel.Bit24;
-        var encoder = new TiffEncoder
+        TiffEncoder encoder = new()
         {
             PhotometricInterpretation = TiffPhotometricInterpretation.Rgb,
             BitsPerPixel = bitsPerPixel,
@@ -69,27 +69,27 @@ public class TiffEncoderMultiframeTests : TiffEncoderBaseTester
         using Image<TPixel> image = provider.GetImage();
         Assert.Equal(1, image.Frames.Count);
 
-        using var image1 = new Image<Rgba32>(image.Width, image.Height, Color.Green.ToPixel<Rgba32>());
+        using Image<Rgba32> image1 = new(image.Width, image.Height, Color.Green.ToPixel<Rgba32>());
 
-        using var image2 = new Image<Rgba32>(image.Width, image.Height, Color.Yellow.ToPixel<Rgba32>());
+        using Image<Rgba32> image2 = new(image.Width, image.Height, Color.Yellow.ToPixel<Rgba32>());
 
         image.Frames.AddFrame(image1.Frames.RootFrame);
         image.Frames.AddFrame(image2.Frames.RootFrame);
 
         TiffBitsPerPixel bitsPerPixel = TiffBitsPerPixel.Bit24;
-        var encoder = new TiffEncoder
+        TiffEncoder encoder = new()
         {
             PhotometricInterpretation = TiffPhotometricInterpretation.Rgb,
             BitsPerPixel = bitsPerPixel,
             Compression = TiffCompression.Deflate
         };
 
-        using (var ms = new System.IO.MemoryStream())
+        using (MemoryStream ms = new())
         {
             image.Save(ms, encoder);
 
             ms.Position = 0;
-            using var output = Image.Load<Rgba32>(ms);
+            using Image<Rgba32> output = Image.Load<Rgba32>(ms);
 
             Assert.Equal(3, output.Frames.Count);
 
@@ -121,11 +121,11 @@ public class TiffEncoderMultiframeTests : TiffEncoderBaseTester
     {
         using Image<TPixel> image = provider.GetImage();
 
-        using var image0 = new Image<Rgba32>(image.Width, image.Height, Color.Red.ToPixel<Rgba32>());
+        using Image<Rgba32> image0 = new(image.Width, image.Height, Color.Red.ToPixel<Rgba32>());
 
-        using var image1 = new Image<Rgba32>(image.Width, image.Height, Color.Green.ToPixel<Rgba32>());
+        using Image<Rgba32> image1 = new(image.Width, image.Height, Color.Green.ToPixel<Rgba32>());
 
-        using var image2 = new Image<Rgba32>(image.Width, image.Height, Color.Yellow.ToPixel<Rgba32>());
+        using Image<Rgba32> image2 = new(image.Width, image.Height, Color.Yellow.ToPixel<Rgba32>());
 
         image.Frames.AddFrame(image0.Frames.RootFrame);
         image.Frames.AddFrame(image1.Frames.RootFrame);
@@ -133,19 +133,19 @@ public class TiffEncoderMultiframeTests : TiffEncoderBaseTester
         image.Frames.RemoveFrame(0);
 
         TiffBitsPerPixel bitsPerPixel = TiffBitsPerPixel.Bit8;
-        var encoder = new TiffEncoder
+        TiffEncoder encoder = new()
         {
             PhotometricInterpretation = TiffPhotometricInterpretation.PaletteColor,
             BitsPerPixel = bitsPerPixel,
             Compression = TiffCompression.Lzw
         };
 
-        using (var ms = new System.IO.MemoryStream())
+        using (MemoryStream ms = new())
         {
             image.Save(ms, encoder);
 
             ms.Position = 0;
-            using var output = Image.Load<Rgba32>(ms);
+            using Image<Rgba32> output = Image.Load<Rgba32>(ms);
 
             Assert.Equal(3, output.Frames.Count);
 
diff --git a/tests/ImageSharp.Tests/Formats/Tiff/TiffEncoderTests.cs b/tests/ImageSharp.Tests/Formats/Tiff/TiffEncoderTests.cs
index 674ca5c5bb..4317c2714d 100644
--- a/tests/ImageSharp.Tests/Formats/Tiff/TiffEncoderTests.cs
+++ b/tests/ImageSharp.Tests/Formats/Tiff/TiffEncoderTests.cs
@@ -579,6 +579,16 @@ public class TiffEncoderTests : TiffEncoderBaseTester
     public void TiffEncoder_EncodeBiColor_WithModifiedHuffmanCompression_BlackIsZero_Works<TPixel>(TestImageProvider<TPixel> provider)
         where TPixel : unmanaged, IPixel<TPixel> => TestTiffEncoderCore(provider, TiffBitsPerPixel.Bit1, TiffPhotometricInterpretation.BlackIsZero, TiffCompression.Ccitt1D);
 
+    [Theory]
+    [WithFile(Issue2909, PixelTypes.Rgba32)]
+    public void TiffEncoder_WithLzwCompression_Works<TPixel>(TestImageProvider<TPixel> provider)
+        where TPixel : unmanaged, IPixel<TPixel> => TestTiffEncoderCore(provider, TiffBitsPerPixel.Bit24, null, TiffCompression.Lzw, imageDecoder: TiffDecoder.Instance);
+
+    [Theory]
+    [WithFile(Issue2909, PixelTypes.Rgba32)]
+    public void TiffEncoder_WithDeflateCompression_Works<TPixel>(TestImageProvider<TPixel> provider)
+        where TPixel : unmanaged, IPixel<TPixel> => TestTiffEncoderCore(provider, TiffBitsPerPixel.Bit24, null, TiffCompression.Deflate, imageDecoder: TiffDecoder.Instance);
+
     [Theory]
     [WithFile(GrayscaleUncompressed, PixelTypes.L8, TiffPhotometricInterpretation.BlackIsZero, TiffCompression.PackBits)]
     [WithFile(GrayscaleUncompressed16Bit, PixelTypes.L16, TiffPhotometricInterpretation.BlackIsZero, TiffCompression.PackBits)]
diff --git a/tests/ImageSharp.Tests/Formats/Tiff/TiffMetadataTests.cs b/tests/ImageSharp.Tests/Formats/Tiff/TiffMetadataTests.cs
index e31487cd23..20b3ec2bb2 100644
--- a/tests/ImageSharp.Tests/Formats/Tiff/TiffMetadataTests.cs
+++ b/tests/ImageSharp.Tests/Formats/Tiff/TiffMetadataTests.cs
@@ -208,8 +208,8 @@ public class TiffMetadataTests
         Rational expectedResolution = new(10, 1, simplify: false);
         Assert.Equal(expectedResolution, exifProfile.GetValue(ExifTag.XResolution).Value);
         Assert.Equal(expectedResolution, exifProfile.GetValue(ExifTag.YResolution).Value);
-        Assert.Equal(new Number[] { 8u }, exifProfile.GetValue(ExifTag.StripOffsets)?.Value, new NumberComparer());
-        Assert.Equal(new Number[] { 285u }, exifProfile.GetValue(ExifTag.StripByteCounts)?.Value, new NumberComparer());
+        Assert.Equal([8u], exifProfile.GetValue(ExifTag.StripOffsets)?.Value, new NumberComparer());
+        Assert.Equal([285u], exifProfile.GetValue(ExifTag.StripByteCounts)?.Value, new NumberComparer());
         Assert.Null(exifProfile.GetValue(ExifTag.ExtraSamples, false)?.Value);
         Assert.Equal(32u, exifProfile.GetValue(ExifTag.RowsPerStrip).Value);
         Assert.Null(exifProfile.GetValue(ExifTag.SampleFormat, false));
diff --git a/tests/ImageSharp.Tests/Formats/Tiff/Utils/TiffWriterTests.cs b/tests/ImageSharp.Tests/Formats/Tiff/Utils/TiffWriterTests.cs
index 9b26ab2702..939baeeb68 100644
--- a/tests/ImageSharp.Tests/Formats/Tiff/Utils/TiffWriterTests.cs
+++ b/tests/ImageSharp.Tests/Formats/Tiff/Utils/TiffWriterTests.cs
@@ -11,8 +11,8 @@ public class TiffWriterTests
     [Fact]
     public void IsLittleEndian_IsTrueOnWindows()
     {
-        using var stream = new MemoryStream();
-        using var writer = new TiffStreamWriter(stream);
+        using MemoryStream stream = new();
+        using TiffStreamWriter writer = new(stream);
         Assert.True(TiffStreamWriter.IsLittleEndian);
     }
 
@@ -22,8 +22,8 @@ public class TiffWriterTests
     [InlineData(new byte[] { 1, 2, 3, 4, 5 }, 5)]
     public void Position_EqualsTheStreamPosition(byte[] data, long expectedResult)
     {
-        using var stream = new MemoryStream();
-        using var writer = new TiffStreamWriter(stream);
+        using MemoryStream stream = new();
+        using TiffStreamWriter writer = new(stream);
         writer.Write(data);
         Assert.Equal(writer.Position, expectedResult);
     }
@@ -31,8 +31,8 @@ public class TiffWriterTests
     [Fact]
     public void Write_WritesByte()
     {
-        using var stream = new MemoryStream();
-        using var writer = new TiffStreamWriter(stream);
+        using MemoryStream stream = new();
+        using TiffStreamWriter writer = new(stream);
         writer.Write(42);
 
         Assert.Equal(new byte[] { 42 }, stream.ToArray());
@@ -41,8 +41,8 @@ public class TiffWriterTests
     [Fact]
     public void Write_WritesByteArray()
     {
-        using var stream = new MemoryStream();
-        using var writer = new TiffStreamWriter(stream);
+        using MemoryStream stream = new();
+        using TiffStreamWriter writer = new(stream);
         writer.Write(new byte[] { 2, 4, 6, 8 });
 
         Assert.Equal(new byte[] { 2, 4, 6, 8 }, stream.ToArray());
@@ -51,8 +51,8 @@ public class TiffWriterTests
     [Fact]
     public void Write_WritesUInt16()
     {
-        using var stream = new MemoryStream();
-        using var writer = new TiffStreamWriter(stream);
+        using MemoryStream stream = new();
+        using TiffStreamWriter writer = new(stream);
         writer.Write(1234, stackalloc byte[2]);
 
         Assert.Equal(new byte[] { 0xD2, 0x04 }, stream.ToArray());
@@ -61,8 +61,8 @@ public class TiffWriterTests
     [Fact]
     public void Write_WritesUInt32()
     {
-        using var stream = new MemoryStream();
-        using var writer = new TiffStreamWriter(stream);
+        using MemoryStream stream = new();
+        using TiffStreamWriter writer = new(stream);
         writer.Write(12345678U, stackalloc byte[4]);
 
         Assert.Equal(new byte[] { 0x4E, 0x61, 0xBC, 0x00 }, stream.ToArray());
@@ -78,8 +78,8 @@ public class TiffWriterTests
 
     public void WritePadded_WritesByteArray(byte[] bytes, byte[] expectedResult)
     {
-        using var stream = new MemoryStream();
-        using var writer = new TiffStreamWriter(stream);
+        using MemoryStream stream = new();
+        using TiffStreamWriter writer = new(stream);
         writer.WritePadded(bytes);
 
         Assert.Equal(expectedResult, stream.ToArray());
@@ -88,10 +88,10 @@ public class TiffWriterTests
     [Fact]
     public void WriteMarker_WritesToPlacedPosition()
     {
-        using var stream = new MemoryStream();
+        using MemoryStream stream = new();
         Span<byte> buffer = stackalloc byte[4];
 
-        using (var writer = new TiffStreamWriter(stream))
+        using (TiffStreamWriter writer = new(stream))
         {
             writer.Write(0x11111111, buffer);
             long marker = writer.PlaceMarker(buffer);
diff --git a/tests/ImageSharp.Tests/Formats/WebP/ColorSpaceTransformUtilsTests.cs b/tests/ImageSharp.Tests/Formats/WebP/ColorSpaceTransformUtilsTests.cs
index c5e8c975f1..66f3201436 100644
--- a/tests/ImageSharp.Tests/Formats/WebP/ColorSpaceTransformUtilsTests.cs
+++ b/tests/ImageSharp.Tests/Formats/WebP/ColorSpaceTransformUtilsTests.cs
@@ -12,13 +12,13 @@ public class ColorSpaceTransformUtilsTests
     private static void RunCollectColorBlueTransformsTest()
     {
         uint[] pixelData =
-        {
+        [
             3074, 256, 256, 256, 0, 65280, 65280, 65280, 256, 256, 0, 256, 0, 65280, 0, 65280, 16711680, 256,
             256, 0, 65024, 0, 256, 256, 0, 65280, 0, 65280, 0, 256, 0, 256
-        };
+        ];
 
         int[] expectedOutput =
-        {
+        [
             31, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
             0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
             0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
@@ -27,7 +27,7 @@ public class ColorSpaceTransformUtilsTests
             0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
             0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
             0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
-        };
+        ];
 
         int[] histo = new int[256];
         ColorSpaceTransformUtils.CollectColorBlueTransforms(pixelData, 0, 32, 1, 0, 0, histo);
@@ -38,13 +38,13 @@ public class ColorSpaceTransformUtilsTests
     private static void RunCollectColorRedTransformsTest()
     {
         uint[] pixelData =
-        {
+        [
             3074, 256, 256, 256, 0, 65280, 65280, 65280, 256, 256, 0, 256, 0, 65280, 0, 65280, 16711680, 256,
             256, 0, 65024, 0, 256, 256, 0, 65280, 0, 65280, 0, 256, 0, 256
-        };
+        ];
 
         int[] expectedOutput =
-        {
+        [
             31, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
             0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
             0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
@@ -53,7 +53,7 @@ public class ColorSpaceTransformUtilsTests
             0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
             0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
             0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1
-        };
+        ];
 
         int[] histo = new int[256];
         ColorSpaceTransformUtils.CollectColorRedTransforms(pixelData, 0, 32, 1, 0, histo);
@@ -71,17 +71,17 @@ public class ColorSpaceTransformUtilsTests
     public void CollectColorBlueTransforms_WithHardwareIntrinsics_Works() => FeatureTestRunner.RunWithHwIntrinsicsFeature(RunCollectColorBlueTransformsTest, HwIntrinsics.AllowAll);
 
     [Fact]
-    public void CollectColorBlueTransforms_WithoutSSE41_Works() => FeatureTestRunner.RunWithHwIntrinsicsFeature(RunCollectColorBlueTransformsTest, HwIntrinsics.DisableSSE41);
+    public void CollectColorBlueTransforms_WithoutVector128_Works() => FeatureTestRunner.RunWithHwIntrinsicsFeature(RunCollectColorBlueTransformsTest, HwIntrinsics.DisableSSE41);
 
     [Fact]
-    public void CollectColorBlueTransforms_WithoutAvx2_Works() => FeatureTestRunner.RunWithHwIntrinsicsFeature(RunCollectColorBlueTransformsTest, HwIntrinsics.DisableAVX2);
+    public void CollectColorBlueTransforms_WithoutVector256_Works() => FeatureTestRunner.RunWithHwIntrinsicsFeature(RunCollectColorBlueTransformsTest, HwIntrinsics.DisableAVX2);
 
     [Fact]
     public void CollectColorRedTransforms_WithHardwareIntrinsics_Works() => FeatureTestRunner.RunWithHwIntrinsicsFeature(RunCollectColorRedTransformsTest, HwIntrinsics.AllowAll);
 
     [Fact]
-    public void CollectColorRedTransforms_WithoutSSE41_Works() => FeatureTestRunner.RunWithHwIntrinsicsFeature(RunCollectColorRedTransformsTest, HwIntrinsics.DisableSSE41);
+    public void CollectColorRedTransforms_WithoutVector128_Works() => FeatureTestRunner.RunWithHwIntrinsicsFeature(RunCollectColorRedTransformsTest, HwIntrinsics.DisableSSE41);
 
     [Fact]
-    public void CollectColorRedTransforms_WithoutAvx2_Works() => FeatureTestRunner.RunWithHwIntrinsicsFeature(RunCollectColorRedTransformsTest, HwIntrinsics.DisableAVX2);
+    public void CollectColorRedTransforms_WithoutVector256_Works() => FeatureTestRunner.RunWithHwIntrinsicsFeature(RunCollectColorRedTransformsTest, HwIntrinsics.DisableAVX2);
 }
diff --git a/tests/ImageSharp.Tests/Formats/WebP/LosslessUtilsTests.cs b/tests/ImageSharp.Tests/Formats/WebP/LosslessUtilsTests.cs
index 4551e3e23e..982f0a5d5c 100644
--- a/tests/ImageSharp.Tests/Formats/WebP/LosslessUtilsTests.cs
+++ b/tests/ImageSharp.Tests/Formats/WebP/LosslessUtilsTests.cs
@@ -11,8 +11,10 @@ public class LosslessUtilsTests
 {
     private static void RunCombinedShannonEntropyTest()
     {
-        int[] x = { 3, 5, 2, 5, 3, 1, 2, 2, 3, 3, 1, 2, 1, 2, 1, 1, 0, 0, 0, 1, 1, 2, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 2, 0, 1, 1, 0, 0, 2, 1, 1, 0, 3, 1, 2, 3, 2, 3 };
-        int[] y = { 11, 12, 8, 3, 4, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 2, 2, 1, 1, 2, 4, 6, 4 };
+        int[] x = [3, 5, 2, 5, 3, 1, 2, 2, 3, 3, 1, 2, 1, 2, 1, 1, 0, 0, 0, 1, 1, 2, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 2, 0, 1, 1, 0, 0, 2, 1, 1, 0, 3, 1, 2, 3, 2, 3
+        ];
+        int[] y = [11, 12, 8, 3, 4, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 2, 2, 1, 1, 2, 4, 6, 4
+        ];
         const float expected = 884.7585f;
 
         float actual = LosslessUtils.CombinedShannonEntropy(x, y);
@@ -23,7 +25,7 @@ public class LosslessUtilsTests
     private static void RunSubtractGreenTest()
     {
         uint[] pixelData =
-        {
+        [
             4293035898, 4293101432, 4292903793, 4292838511, 4292837995, 4292771950, 4292903791, 4293299316,
             4293563769, 4293629303, 4293363312, 4291913575, 4289282905, 4288692313, 4289349210, 4289809240,
             4289743703, 4289874775, 4289940567, 4289743701, 4290137943, 4290860378, 4291058267, 4291386715,
@@ -31,10 +33,10 @@ public class LosslessUtilsTests
             4291913571, 4292044130, 4291978850, 4291847521, 4291847524, 4291847779, 4291913571, 4291848293,
             4291651689, 4291585895, 4291519584, 4291715936, 4291520355, 4291650658, 4291847263, 4291913313,
             4291847777, 4291781731, 4291783015
-        };
+        ];
 
         uint[] expectedOutput =
-        {
+        [
             4284188659, 4284254193, 4284318702, 4284187883, 4284318441, 4284383470, 4284318700, 4284124392,
             4283799012, 4283864546, 4284581610, 4285163264, 4284891926, 4284497945, 4284761620, 4284893965,
             4284828428, 4284959500, 4284959755, 4284828426, 4284960520, 4285289733, 4285159937, 4285292030,
@@ -42,7 +44,7 @@ public class LosslessUtilsTests
             4285163516, 4285425149, 4285294332, 4285228540, 4285228543, 4285163261, 4285163516, 4285032701,
             4284835841, 4284835584, 4284966140, 4285228029, 4284770300, 4285097214, 4285293819, 4285228795,
             4285163259, 4285228287, 4284901886
-        };
+        ];
 
         LosslessUtils.SubtractGreenFromBlueAndRed(pixelData);
 
@@ -52,7 +54,7 @@ public class LosslessUtilsTests
     private static void RunAddGreenToBlueAndRedTest()
     {
         uint[] pixelData =
-        {
+        [
             4284188659, 4284254193, 4284318702, 4284187883, 4284318441, 4284383470, 4284318700, 4284124392,
             4283799012, 4283864546, 4284581610, 4285163264, 4284891926, 4284497945, 4284761620, 4284893965,
             4284828428, 4284959500, 4284959755, 4284828426, 4284960520, 4285289733, 4285159937, 4285292030,
@@ -60,10 +62,10 @@ public class LosslessUtilsTests
             4285163516, 4285425149, 4285294332, 4285228540, 4285228543, 4285163261, 4285163516, 4285032701,
             4284835841, 4284835584, 4284966140, 4285228029, 4284770300, 4285097214, 4285293819, 4285228795,
             4285163259, 4285228287, 4284901886
-        };
+        ];
 
         uint[] expectedOutput =
-        {
+        [
             4293035898, 4293101432, 4292903793, 4292838511, 4292837995, 4292771950, 4292903791, 4293299316,
             4293563769, 4293629303, 4293363312, 4291913575, 4289282905, 4288692313, 4289349210, 4289809240,
             4289743703, 4289874775, 4289940567, 4289743701, 4290137943, 4290860378, 4291058267, 4291386715,
@@ -71,7 +73,7 @@ public class LosslessUtilsTests
             4291913571, 4292044130, 4291978850, 4291847521, 4291847524, 4291847779, 4291913571, 4291848293,
             4291651689, 4291585895, 4291519584, 4291715936, 4291520355, 4291650658, 4291847263, 4291913313,
             4291847777, 4291781731, 4291783015
-        };
+        ];
 
         LosslessUtils.AddGreenToBlueAndRed(pixelData);
 
@@ -81,15 +83,15 @@ public class LosslessUtilsTests
     private static void RunTransformColorTest()
     {
         uint[] pixelData =
-        {
+        [
             5998579, 65790, 130301, 16646653, 196350, 130565, 16712702, 16583164, 16452092, 65790, 782600,
             647446, 16571414, 16448771, 263931, 132601, 16711935, 131072, 511, 16711679, 132350, 329469,
             16647676, 132093, 66303, 16647169, 16515584, 196607, 196096, 16646655, 514, 131326, 16712192,
             327169, 16646655, 16776960, 3, 16712190, 511, 16646401, 16580612, 65535, 196092, 327425, 16319743,
             392450, 196861, 16712192, 16711680, 130564, 16451071
-        };
+        ];
 
-        var m = new Vp8LMultipliers()
+        Vp8LMultipliers m = new()
         {
             GreenToBlue = 240,
             GreenToRed = 232,
@@ -97,13 +99,13 @@ public class LosslessUtilsTests
         };
 
         uint[] expectedOutput =
-        {
+        [
             100279, 65790, 16710907, 16712190, 130813, 65028, 131840, 264449, 133377, 65790, 61697, 15917319,
             14801924, 16317698, 591614, 394748, 16711935, 131072, 65792, 16711679, 328704, 656896, 132607,
             328703, 197120, 66563, 16646657, 196607, 130815, 16711936, 131587, 131326, 66049, 261632, 16711936,
             16776960, 3, 511, 65792, 16711938, 16580612, 65535, 65019, 327425, 16516097, 261377, 196861, 66049,
             16711680, 65027, 16712962
-        };
+        ];
 
         LosslessUtils.TransformColor(m, pixelData, pixelData.Length);
 
@@ -113,15 +115,15 @@ public class LosslessUtilsTests
     private static void RunTransformColorInverseTest()
     {
         uint[] pixelData =
-        {
+        [
             100279, 65790, 16710907, 16712190, 130813, 65028, 131840, 264449, 133377, 65790, 61697, 15917319,
             14801924, 16317698, 591614, 394748, 16711935, 131072, 65792, 16711679, 328704, 656896, 132607,
             328703, 197120, 66563, 16646657, 196607, 130815, 16711936, 131587, 131326, 66049, 261632, 16711936,
             16776960, 3, 511, 65792, 16711938, 16580612, 65535, 65019, 327425, 16516097, 261377, 196861, 66049,
             16711680, 65027, 16712962
-        };
+        ];
 
-        var m = new Vp8LMultipliers()
+        Vp8LMultipliers m = new()
         {
             GreenToBlue = 240,
             GreenToRed = 232,
@@ -129,13 +131,13 @@ public class LosslessUtilsTests
         };
 
         uint[] expectedOutput =
-        {
+        [
             5998579, 65790, 130301, 16646653, 196350, 130565, 16712702, 16583164, 16452092, 65790, 782600,
             647446, 16571414, 16448771, 263931, 132601, 16711935, 131072, 511, 16711679, 132350, 329469,
             16647676, 132093, 66303, 16647169, 16515584, 196607, 196096, 16646655, 514, 131326, 16712192,
             327169, 16646655, 16776960, 3, 16712190, 511, 16646401, 16580612, 65535, 196092, 327425, 16319743,
             392450, 196861, 16712192, 16711680, 130564, 16451071
-        };
+        ];
 
         LosslessUtils.TransformColorInverse(m, pixelData);
 
@@ -145,7 +147,7 @@ public class LosslessUtilsTests
     private static void RunPredictor11Test()
     {
         // arrange
-        uint[] topData = { 4278258949, 4278258949 };
+        uint[] topData = [4278258949, 4278258949];
         const uint left = 4294839812;
         short[] scratch = new short[8];
         const uint expectedResult = 4294839812;
@@ -166,7 +168,7 @@ public class LosslessUtilsTests
     private static void RunPredictor12Test()
     {
         // arrange
-        uint[] topData = { 4294844413, 4294779388 };
+        uint[] topData = [4294844413, 4294779388];
         const uint left = 4294844413;
         const uint expectedResult = 4294779388;
 
@@ -186,10 +188,10 @@ public class LosslessUtilsTests
     private static void RunPredictor13Test()
     {
         // arrange
-        uint[] topData0 = { 4278193922, 4278193666 };
+        uint[] topData0 = [4278193922, 4278193666];
         const uint left0 = 4278193410;
         const uint expectedResult0 = 4278193154;
-        uint[] topData1 = { 4294933015, 4278219803 };
+        uint[] topData1 = [4294933015, 4278219803];
         const uint left1 = 4278236686;
         const uint expectedResult1 = 4278231571;
         uint actual0 = 0;
@@ -218,17 +220,18 @@ public class LosslessUtilsTests
     public void BundleColorMap_WithXbitsZero_Works()
     {
         // arrange
-        byte[] row = { 238, 238, 238, 238, 238, 238, 240, 237, 240, 235, 223, 223, 218, 220, 226, 219, 220, 204, 218, 211, 218, 221, 254, 255 };
+        byte[] row = [238, 238, 238, 238, 238, 238, 240, 237, 240, 235, 223, 223, 218, 220, 226, 219, 220, 204, 218, 211, 218, 221, 254, 255
+        ];
         int xBits = 0;
         uint[] actual = new uint[row.Length];
         uint[] expected =
-        {
+        [
             4278251008, 4278251008, 4278251008, 4278251008, 4278251008,
             4278251008, 4278251520, 4278250752, 4278251520, 4278250240,
             4278247168, 4278247168, 4278245888, 4278246400, 4278247936,
             4278246144, 4278246400, 4278242304, 4278245888, 4278244096,
             4278245888, 4278246656, 4278255104, 4278255360
-        };
+        ];
 
         // act
         LosslessUtils.BundleColorMap(row, actual.Length, xBits, actual);
@@ -242,7 +245,7 @@ public class LosslessUtilsTests
     {
         // arrange
         byte[] row =
-        {
+        [
             2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
             3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3,
             2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
@@ -251,17 +254,17 @@ public class LosslessUtilsTests
             3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3,
             3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3,
             3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3
-        };
+        ];
         int xBits = 2;
         uint[] actual = new uint[row.Length];
         uint[] expected =
-        {
+        [
             4278233600, 4278233600, 4278233600, 4278233600, 4278255360, 4278255360, 4278255360, 4278255360, 4278233600, 4278233600, 4278233600, 4278233600,
             4278255360, 4278255360, 4278255360, 4278255360, 4278211840, 4278211840, 4278211840, 4278211840, 4278255360, 4278255360, 4278255360, 4278255360,
             4278255360, 4278255360, 4278255360, 4278255360, 4278255360, 4278255360, 4278255360, 4278206208, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
             0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
             0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
-        };
+        ];
 
         // act
         LosslessUtils.BundleColorMap(row, actual.Length, xBits, actual);
diff --git a/tests/ImageSharp.Tests/Formats/WebP/LossyUtilsTests.cs b/tests/ImageSharp.Tests/Formats/WebP/LossyUtilsTests.cs
index 73e7044f5b..f4189933fa 100644
--- a/tests/ImageSharp.Tests/Formats/WebP/LossyUtilsTests.cs
+++ b/tests/ImageSharp.Tests/Formats/WebP/LossyUtilsTests.cs
@@ -13,9 +13,10 @@ public class LossyUtilsTests
     private static void RunTransformTwoTest()
     {
         // arrange
-        short[] src = { 19, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 19, 23, 0, 0, -23, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 };
+        short[] src = [19, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 19, 23, 0, 0, -23, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
+        ];
         byte[] dst =
-        {
+        [
             103, 103, 103, 103, 103, 103, 103, 103, 0, 0, 0, 0, 169, 169, 169, 169, 171, 171, 171, 171,
             171, 171, 171, 171, 0, 0, 0, 0, 103, 103, 103, 103, 103, 103, 103, 103, 103, 103, 103, 103,
             0, 0, 0, 0, 169, 169, 169, 169, 171, 171, 171, 171, 171, 171, 171, 171, 0, 0, 0, 0,
@@ -23,16 +24,16 @@ public class LossyUtilsTests
             171, 171, 171, 171, 171, 171, 171, 171, 0, 0, 0, 0, 103, 103, 103, 103, 103, 103, 103, 103,
             103, 103, 103, 103, 0, 0, 0, 0, 169, 169, 169, 169, 171, 171, 171, 171, 171, 171, 171, 171,
             0, 0, 0, 0, 0, 0, 0, 0
-        };
+        ];
         byte[] expected =
-        {
+        [
             105, 105, 105, 105, 105, 103, 100, 98, 0, 0, 0, 0, 169, 169, 169, 169, 171, 171, 171, 171, 171, 171,
             171, 171, 0, 0, 0, 0, 103, 103, 103, 103, 105, 105, 105, 105, 108, 105, 102, 100, 0, 0, 0, 0, 169,
             169, 169, 169, 171, 171, 171, 171, 171, 171, 171, 171, 0, 0, 0, 0, 103, 103, 103, 103, 105, 105,
             105, 105, 111, 109, 106, 103, 0, 0, 0, 0, 169, 169, 169, 169, 171, 171, 171, 171, 171, 171, 171,
             171, 0, 0, 0, 0, 103, 103, 103, 103, 105, 105, 105, 105, 113, 111, 108, 106, 0, 0, 0, 0, 169, 169,
             169, 169, 171, 171, 171, 171, 171, 171, 171, 171, 0, 0, 0, 0, 0, 0, 0, 0
-        };
+        ];
         int[] scratch = new int[16];
 
         // act
@@ -45,9 +46,9 @@ public class LossyUtilsTests
     private static void RunTransformOneTest()
     {
         // arrange
-        short[] src = { -176, 0, 0, 0, 29, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 };
+        short[] src = [-176, 0, 0, 0, 29, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0];
         byte[] dst =
-        {
+        [
             128, 128, 128, 128, 128, 128, 128, 128, 0, 0, 0, 0, 0, 0, 0, 129, 128, 128, 128, 128,
             128, 128, 128, 128, 0, 0, 0, 0, 0, 0, 0, 129, 128, 128, 128, 128, 128, 128, 128, 128,
             0, 0, 0, 0, 0, 0, 0, 129, 128, 128, 128, 128, 128, 128, 128, 128, 0, 0, 0, 0,
@@ -55,9 +56,9 @@ public class LossyUtilsTests
             128, 128, 128, 128, 128, 128, 128, 128, 0, 0, 0, 0, 0, 0, 0, 129, 128, 128, 128, 128,
             128, 128, 128, 128, 0, 0, 0, 0, 0, 0, 0, 129, 128, 128, 128, 128, 128, 128, 128, 128,
             0, 0, 0, 0, 0, 0, 0, 129
-        };
+        ];
         byte[] expected =
-        {
+        [
             111, 111, 111, 111, 128, 128, 128, 128, 0, 0, 0, 0, 0, 0, 0, 129, 128, 128, 128, 128,
             128, 128, 128, 128, 0, 0, 0, 0, 0, 0, 0, 129, 108, 108, 108, 108, 128, 128, 128, 128,
             0, 0, 0, 0, 0, 0, 0, 129, 128, 128, 128, 128, 128, 128, 128, 128, 0, 0, 0, 0,
@@ -65,7 +66,7 @@ public class LossyUtilsTests
             128, 128, 128, 128, 128, 128, 128, 128, 0, 0, 0, 0, 0, 0, 0, 129, 101, 101, 101, 101,
             128, 128, 128, 128, 0, 0, 0, 0, 0, 0, 0, 129, 128, 128, 128, 128, 128, 128, 128, 128,
             0, 0, 0, 0, 0, 0, 0, 129
-        };
+        ];
         int[] scratch = new int[16];
 
         // act
@@ -86,7 +87,7 @@ public class LossyUtilsTests
             a[i] = (byte)rand.Next(byte.MaxValue);
             b[i] = (byte)rand.Next(byte.MaxValue);
         }
-        int[] expected = { 2533110, 2818581, 2984663, 2891188, 2855134, 2634604, 2466504, 3061747, 2626010, 2640965 };
+        int[] expected = [2533110, 2818581, 2984663, 2891188, 2855134, 2634604, 2466504, 3061747, 2626010, 2640965];
 
         // act + assert
         int offset = 0;
@@ -110,7 +111,7 @@ public class LossyUtilsTests
             a[i] = (byte)rand.Next(byte.MaxValue);
             b[i] = (byte)rand.Next(byte.MaxValue);
         }
-        int[] expected = { 1298274, 1234836, 1325264, 1493317, 1551995, 1432668, 1407891, 1483297, 1537930, 1317204 };
+        int[] expected = [1298274, 1234836, 1325264, 1493317, 1551995, 1432668, 1407891, 1483297, 1537930, 1317204];
 
         // act + assert
         int offset = 0;
@@ -134,7 +135,7 @@ public class LossyUtilsTests
             a[i] = (byte)rand.Next(byte.MaxValue);
             b[i] = (byte)rand.Next(byte.MaxValue);
         }
-        int[] expected = { 194133, 125861, 165966, 195688, 106491, 173015, 266960, 200272, 311224, 122545 };
+        int[] expected = [194133, 125861, 165966, 195688, 106491, 173015, 266960, 200272, 311224, 122545];
 
         // act + assert
         int offset = 0;
@@ -151,7 +152,7 @@ public class LossyUtilsTests
     {
         // arrange
         byte[] input =
-        {
+        [
             154, 145, 102, 115, 127, 129, 126, 125, 126, 120, 133, 152, 157, 153, 119, 94, 104, 116, 111, 113,
             113, 109, 105, 124, 173, 175, 177, 170, 175, 172, 166, 164, 151, 141, 99, 114, 125, 126, 135, 150,
             133, 115, 127, 149, 141, 168, 100, 54, 110, 117, 115, 116, 119, 115, 117, 130, 174, 174, 174, 157,
@@ -159,9 +160,9 @@ public class LossyUtilsTests
             109, 115, 113, 120, 120, 117, 128, 115, 174, 173, 173, 161, 152, 148, 153, 162, 105, 140, 96, 114,
             115, 122, 141, 173, 190, 190, 142, 106, 151, 78, 66, 141, 110, 117, 123, 136, 118, 124, 127, 114,
             173, 175, 166, 155, 155, 159, 159, 158
-        };
+        ];
         uint[] dc = new uint[4];
-        uint[] expectedDc = { 1940, 2139, 2252, 1813 };
+        uint[] expectedDc = [1940, 2139, 2252, 1813];
 
         // act
         LossyUtils.Mean16x4(input, dc);
@@ -174,24 +175,24 @@ public class LossyUtilsTests
     {
         // arrange
         byte[] a =
-        {
+        [
             27, 27, 28, 29, 29, 28, 27, 27, 27, 28, 28, 29, 29, 28, 28, 27, 129, 129, 129, 129, 129, 129, 129,
             129, 128, 128, 128, 128, 128, 128, 128, 128, 27, 27, 27, 27, 27, 27, 27, 27, 27, 28, 28, 29, 29, 28,
             28, 27, 129, 129, 129, 129, 129, 129, 129, 129, 128, 128, 128, 128, 128, 128, 128, 128, 27, 27, 26,
             26, 26, 26, 27, 27, 27, 28, 28, 29, 29, 28, 28, 27, 129, 129, 129, 129, 129, 129, 129, 129, 128,
             128, 128, 128, 128, 128, 128, 128, 28, 27, 27, 26, 26, 27, 27, 28, 27, 28, 28, 29, 29, 28, 28, 27
-        };
+        ];
 
         byte[] b =
-        {
+        [
             28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 204, 204, 204, 204, 204, 204, 204,
             204, 204, 204, 204, 204, 204, 204, 204, 204, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28,
             28, 28, 204, 204, 204, 204, 204, 204, 204, 204, 204, 204, 204, 204, 204, 204, 204, 204, 28, 28, 28,
             28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 204, 204, 204, 204, 204, 204, 204, 204, 204,
             204, 204, 204, 204, 204, 204, 204, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28
-        };
+        ];
 
-        ushort[] w = { 38, 32, 20, 9, 32, 28, 17, 7, 20, 17, 10, 4, 9, 7, 4, 2 };
+        ushort[] w = [38, 32, 20, 9, 32, 28, 17, 7, 20, 17, 10, 4, 9, 7, 4, 2];
         int expected = 2;
 
         // act
diff --git a/tests/ImageSharp.Tests/Formats/WebP/PredictorEncoderTests.cs b/tests/ImageSharp.Tests/Formats/WebP/PredictorEncoderTests.cs
index b4279b0454..23ef8e7b12 100644
--- a/tests/ImageSharp.Tests/Formats/WebP/PredictorEncoderTests.cs
+++ b/tests/ImageSharp.Tests/Formats/WebP/PredictorEncoderTests.cs
@@ -43,7 +43,7 @@ public class PredictorEncoderTests
     {
         // arrange
         uint[] expectedData =
-        {
+        [
             4278191104, 4278191104, 4278191104, 4278191104, 4278191104, 4278191104, 4278191104, 4294577152,
             4294707200, 4294707200, 4294707200, 4294707200, 4294837248, 4294837248, 4293926912, 4294316544,
             4278191104, 4278191104, 4294837248, 4294837248, 4280287232, 4280350720, 4294447104, 4294707200,
@@ -76,7 +76,7 @@ public class PredictorEncoderTests
             4280287232, 4280287232, 4280287232, 4280287232, 4280287232, 4279503872, 4279503872, 4280288256,
             4280287232, 4280287232, 4280287232, 4280287232, 4280287232, 4280287232, 4280287232, 4280287232,
             4280287232, 4280287232, 4280287232, 4280287232, 4280287232, 4280287232, 4280287232, 4280287232
-        };
+        ];
 
         // Convert image pixels to bgra array.
         byte[] imgBytes = File.ReadAllBytes(TestImageFullPath(TestImages.Webp.Peak));
@@ -100,13 +100,13 @@ public class PredictorEncoderTests
     {
         // arrange
         uint[] expectedData =
-        {
+        [
             4278714368, 4278192876, 4278198304, 4278198304, 4278190304, 4278190080, 4278190080, 4278198272,
             4278197760, 4278198816, 4278197794, 4278197774, 4278190080, 4278190080, 4278198816, 4278197281,
             4278197280, 4278197792, 4278200353, 4278191343, 4278190304, 4294713873, 4278198784, 4294844416,
             4278201578, 4278200044, 4278191343, 4278190288, 4294705200, 4294717139, 4278203628, 4278201064,
             4278201586, 4278197792, 4279240909
-        };
+        ];
 
         // Convert image pixels to bgra array.
         byte[] imgBytes = File.ReadAllBytes(TestImageFullPath(TestImages.Webp.Lossy.BikeSmall));
diff --git a/tests/ImageSharp.Tests/Formats/WebP/QuantEncTests.cs b/tests/ImageSharp.Tests/Formats/WebP/QuantEncTests.cs
index 59691204be..fc7da8cf67 100644
--- a/tests/ImageSharp.Tests/Formats/WebP/QuantEncTests.cs
+++ b/tests/ImageSharp.Tests/Formats/WebP/QuantEncTests.cs
@@ -12,13 +12,14 @@ public class QuantEncTests
     private static unsafe void RunQuantizeBlockTest()
     {
         // arrange
-        short[] input = { 378, 777, -851, 888, 259, 148, 0, -111, -185, -185, -74, -37, 148, 74, 111, 74 };
+        short[] input = [378, 777, -851, 888, 259, 148, 0, -111, -185, -185, -74, -37, 148, 74, 111, 74];
         short[] output = new short[16];
-        ushort[] q = { 42, 37, 37, 37, 37, 37, 37, 37, 37, 37, 37, 37, 37, 37, 37, 37 };
-        ushort[] iq = { 3120, 3542, 3542, 3542, 3542, 3542, 3542, 3542, 3542, 3542, 3542, 3542, 3542, 3542, 3542, 3542 };
-        uint[] bias = { 49152, 55296, 55296, 55296, 55296, 55296, 55296, 55296, 55296, 55296, 55296, 55296, 55296, 55296, 55296, 55296 };
-        uint[] zthresh = { 26, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21 };
-        short[] expectedOutput = { 9, 21, 7, -5, 4, -23, 24, 0, -5, 4, 2, -2, -3, -1, 3, 2 };
+        ushort[] q = [42, 37, 37, 37, 37, 37, 37, 37, 37, 37, 37, 37, 37, 37, 37, 37];
+        ushort[] iq = [3120, 3542, 3542, 3542, 3542, 3542, 3542, 3542, 3542, 3542, 3542, 3542, 3542, 3542, 3542, 3542];
+        uint[] bias = [49152, 55296, 55296, 55296, 55296, 55296, 55296, 55296, 55296, 55296, 55296, 55296, 55296, 55296, 55296, 55296
+        ];
+        uint[] zthresh = [26, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21];
+        short[] expectedOutput = [9, 21, 7, -5, 4, -23, 24, 0, -5, 4, 2, -2, -3, -1, 3, 2];
         int expectedResult = 1;
         Vp8Matrix vp8Matrix = default;
         for (int i = 0; i < 16; i++)
diff --git a/tests/ImageSharp.Tests/Formats/WebP/Vp8EncodingTests.cs b/tests/ImageSharp.Tests/Formats/WebP/Vp8EncodingTests.cs
index dab0716927..c0b14cdd7e 100644
--- a/tests/ImageSharp.Tests/Formats/WebP/Vp8EncodingTests.cs
+++ b/tests/ImageSharp.Tests/Formats/WebP/Vp8EncodingTests.cs
@@ -12,12 +12,14 @@ public class Vp8EncodingTests
     private static void RunFTransform2Test()
     {
         // arrange
-        byte[] src = { 154, 154, 151, 151, 149, 148, 151, 157, 163, 163, 154, 132, 102, 98, 104, 108, 107, 104, 104, 103, 101, 106, 123, 119, 170, 171, 172, 171, 168, 175, 171, 173, 151, 151, 149, 150, 147, 147, 146, 159, 164, 165, 154, 129, 92, 90, 101, 105, 104, 103, 104, 101, 100, 105, 123, 117, 172, 172, 172, 168, 170, 177, 170, 175, 151, 149, 150, 150, 147, 147, 156, 161, 161, 161, 151, 126, 93, 90, 102, 107, 104, 103, 104, 101, 104, 104, 122, 117, 172, 172, 170, 168, 170, 177, 172, 175, 150, 149, 152, 151, 148, 151, 160, 159, 157, 157, 148, 133, 96, 90, 103, 107, 104, 104, 101, 100, 102, 102, 121, 117, 170, 170, 169, 171, 171, 179, 173, 175 };
-        byte[] reference = { 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 129, 129, 129, 129, 129, 129, 129, 129, 129, 129, 129, 129, 129, 129, 129, 129, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 129, 129, 129, 129, 129, 129, 129, 129, 129, 129, 129, 129, 129, 129, 129, 129, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 129, 129, 129, 129, 129, 129, 129, 129, 129, 129, 129, 129, 129, 129, 129, 129, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 129, 129, 129, 129, 129, 129, 129, 129, 129, 129, 129, 129, 129, 129, 129, 129 };
+        byte[] src = [154, 154, 151, 151, 149, 148, 151, 157, 163, 163, 154, 132, 102, 98, 104, 108, 107, 104, 104, 103, 101, 106, 123, 119, 170, 171, 172, 171, 168, 175, 171, 173, 151, 151, 149, 150, 147, 147, 146, 159, 164, 165, 154, 129, 92, 90, 101, 105, 104, 103, 104, 101, 100, 105, 123, 117, 172, 172, 172, 168, 170, 177, 170, 175, 151, 149, 150, 150, 147, 147, 156, 161, 161, 161, 151, 126, 93, 90, 102, 107, 104, 103, 104, 101, 104, 104, 122, 117, 172, 172, 170, 168, 170, 177, 172, 175, 150, 149, 152, 151, 148, 151, 160, 159, 157, 157, 148, 133, 96, 90, 103, 107, 104, 104, 101, 100, 102, 102, 121, 117, 170, 170, 169, 171, 171, 179, 173, 175
+        ];
+        byte[] reference = [128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 129, 129, 129, 129, 129, 129, 129, 129, 129, 129, 129, 129, 129, 129, 129, 129, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 129, 129, 129, 129, 129, 129, 129, 129, 129, 129, 129, 129, 129, 129, 129, 129, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 129, 129, 129, 129, 129, 129, 129, 129, 129, 129, 129, 129, 129, 129, 129, 129, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 129, 129, 129, 129, 129, 129, 129, 129, 129, 129, 129, 129, 129, 129, 129, 129
+        ];
         short[] actualOutput1 = new short[16];
         short[] actualOutput2 = new short[16];
-        short[] expectedOutput1 = { 182, 4, 1, 1, 6, 7, -1, -4, 5, 0, -2, 1, 2, 1, 1, 1 };
-        short[] expectedOutput2 = { 192, -34, 10, 1, -11, 8, 10, -7, 6, 3, -8, 4, 5, -3, -2, 6 };
+        short[] expectedOutput1 = [182, 4, 1, 1, 6, 7, -1, -4, 5, 0, -2, 1, 2, 1, 1, 1];
+        short[] expectedOutput2 = [192, -34, 10, 1, -11, 8, 10, -7, 6, 3, -8, 4, 5, -3, -2, 6];
 
         // act
         Vp8Encoding.FTransform2(src, reference, actualOutput1, actualOutput2, new int[16]);
@@ -31,7 +33,7 @@ public class Vp8EncodingTests
     {
         // arrange
         byte[] src =
-        {
+        [
             154, 154, 151, 151, 149, 148, 151, 157, 163, 163, 154, 132, 102, 98, 104, 108, 107, 104, 104, 103,
             101, 106, 123, 119, 170, 171, 172, 171, 168, 175, 171, 173, 151, 151, 149, 150, 147, 147, 146, 159,
             164, 165, 154, 129, 92, 90, 101, 105, 104, 103, 104, 101, 100, 105, 123, 117, 172, 172, 172, 168,
@@ -39,9 +41,9 @@ public class Vp8EncodingTests
             104, 103, 104, 101, 104, 104, 122, 117, 172, 172, 170, 168, 170, 177, 172, 175, 150, 149, 152, 151,
             148, 151, 160, 159, 157, 157, 148, 133, 96, 90, 103, 107, 104, 104, 101, 100, 102, 102, 121, 117,
             170, 170, 169, 171, 171, 179, 173, 175
-        };
+        ];
         byte[] reference =
-        {
+        [
             128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 129, 129, 129, 129,
             129, 129, 129, 129, 129, 129, 129, 129, 129, 129, 129, 129, 128, 128, 128, 128, 128, 128, 128, 128,
             128, 128, 128, 128, 128, 128, 128, 128, 129, 129, 129, 129, 129, 129, 129, 129, 129, 129, 129, 129,
@@ -49,9 +51,9 @@ public class Vp8EncodingTests
             129, 129, 129, 129, 129, 129, 129, 129, 129, 129, 129, 129, 129, 129, 129, 129, 128, 128, 128, 128,
             128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 129, 129, 129, 129, 129, 129, 129, 129,
             129, 129, 129, 129, 129, 129, 129, 129
-        };
+        ];
         short[] actualOutput = new short[16];
-        short[] expectedOutput = { 182, 4, 1, 1, 6, 7, -1, -4, 5, 0, -2, 1, 2, 1, 1, 1 };
+        short[] expectedOutput = [182, 4, 1, 1, 6, 7, -1, -4, 5, 0, -2, 1, 2, 1, 1, 1];
 
         // act
         Vp8Encoding.FTransform(src, reference, actualOutput, new int[16]);
@@ -64,7 +66,7 @@ public class Vp8EncodingTests
     {
         // arrange
         byte[] reference =
-        {
+        [
             128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 129, 129, 129, 129,
             129, 129, 129, 129, 129, 129, 129, 129, 129, 129, 129, 129, 128, 128, 128, 128, 128, 128, 128, 128,
             128, 128, 128, 128, 128, 128, 128, 128, 129, 129, 129, 129, 129, 129, 129, 129, 129, 129, 129, 129,
@@ -72,17 +74,18 @@ public class Vp8EncodingTests
             129, 129, 129, 129, 129, 129, 129, 129, 129, 129, 129, 129, 129, 129, 129, 129, 128, 128, 128, 128,
             128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 129, 129, 129, 129, 129, 129, 129, 129,
             129, 129, 129, 129, 129, 129, 129, 129
-        };
-        short[] input = { 1, 216, -48, 0, 96, -24, -48, 24, 0, -24, 24, 0, 0, 0, 0, 0, 38, -240, -72, -24, 0, -24, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 };
+        ];
+        short[] input = [1, 216, -48, 0, 96, -24, -48, 24, 0, -24, 24, 0, 0, 0, 0, 0, 38, -240, -72, -24, 0, -24, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
+        ];
         byte[] dst = new byte[128];
         byte[] expected =
-        {
+        [
             161, 160, 149, 105, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
             0, 160, 160, 133, 85, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
             0, 0, 156, 147, 109, 76, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
             0, 0, 0, 152, 128, 87, 83, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
             0, 0, 0, 0
-        };
+        ];
         int[] scratch = new int[16];
 
         // act
@@ -96,7 +99,7 @@ public class Vp8EncodingTests
     {
         // arrange
         byte[] reference =
-        {
+        [
             128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 129, 129, 129, 129,
             129, 129, 129, 129, 129, 129, 129, 129, 129, 129, 129, 129, 128, 128, 128, 128, 128, 128, 128, 128,
             128, 128, 128, 128, 128, 128, 128, 128, 129, 129, 129, 129, 129, 129, 129, 129, 129, 129, 129, 129,
@@ -104,17 +107,18 @@ public class Vp8EncodingTests
             129, 129, 129, 129, 129, 129, 129, 129, 129, 129, 129, 129, 129, 129, 129, 129, 128, 128, 128, 128,
             128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 129, 129, 129, 129, 129, 129, 129, 129,
             129, 129, 129, 129, 129, 129, 129, 129
-        };
-        short[] input = { 1, 216, -48, 0, 96, -24, -48, 24, 0, -24, 24, 0, 0, 0, 0, 0, 38, -240, -72, -24, 0, -24, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 };
+        ];
+        short[] input = [1, 216, -48, 0, 96, -24, -48, 24, 0, -24, 24, 0, 0, 0, 0, 0, 38, -240, -72, -24, 0, -24, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
+        ];
         byte[] dst = new byte[128];
         byte[] expected =
-        {
+        [
             161, 160, 149, 105, 78, 127, 156, 170, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
             0, 0, 0, 0, 160, 160, 133, 85, 81, 129, 155, 167, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
             0, 0, 0, 0, 0, 0, 0, 156, 147, 109, 76, 85, 130, 153, 163, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
             0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 152, 128, 87, 83, 88, 132, 152, 159, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
             0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
-        };
+        ];
         int[] scratch = new int[16];
 
         // act
diff --git a/tests/ImageSharp.Tests/Formats/WebP/Vp8HistogramTests.cs b/tests/ImageSharp.Tests/Formats/WebP/Vp8HistogramTests.cs
index a18eff73ce..990c583856 100644
--- a/tests/ImageSharp.Tests/Formats/WebP/Vp8HistogramTests.cs
+++ b/tests/ImageSharp.Tests/Formats/WebP/Vp8HistogramTests.cs
@@ -13,7 +13,7 @@ public class Vp8HistogramTests
     {
         get
         {
-            var result = new List<object[]>();
+            List<object[]> result = new();
             result.Add(new object[]
             {
                 new byte[]
@@ -69,7 +69,7 @@ public class Vp8HistogramTests
     private static void RunCollectHistogramTest()
     {
         // arrange
-        var histogram = new Vp8Histogram();
+        Vp8Histogram histogram = new();
 
         byte[] reference =
         {
@@ -172,7 +172,7 @@ public class Vp8HistogramTests
     public void GetAlpha_WithEmptyHistogram_Works()
     {
         // arrange
-        var histogram = new Vp8Histogram();
+        Vp8Histogram histogram = new();
 
         // act
         int alpha = histogram.GetAlpha();
@@ -186,7 +186,7 @@ public class Vp8HistogramTests
     public void GetAlpha_Works(byte[] reference, byte[] pred)
     {
         // arrange
-        var histogram = new Vp8Histogram();
+        Vp8Histogram histogram = new();
         histogram.CollectHistogram(reference, pred, 0, 1);
 
         // act
@@ -201,9 +201,9 @@ public class Vp8HistogramTests
     public void Merge_Works(byte[] reference, byte[] pred)
     {
         // arrange
-        var histogram1 = new Vp8Histogram();
+        Vp8Histogram histogram1 = new();
         histogram1.CollectHistogram(reference, pred, 0, 1);
-        var histogram2 = new Vp8Histogram();
+        Vp8Histogram histogram2 = new();
         histogram1.Merge(histogram2);
 
         // act
diff --git a/tests/ImageSharp.Tests/Formats/WebP/Vp8LHistogramTests.cs b/tests/ImageSharp.Tests/Formats/WebP/Vp8LHistogramTests.cs
index cfe79e49e6..8d8bcb57c3 100644
--- a/tests/ImageSharp.Tests/Formats/WebP/Vp8LHistogramTests.cs
+++ b/tests/ImageSharp.Tests/Formats/WebP/Vp8LHistogramTests.cs
@@ -14,7 +14,7 @@ public class Vp8LHistogramTests
     {
         // arrange
         uint[] pixelData =
-        {
+        [
             4278191104, 4278191104, 4278191104, 4278191104, 4278191104, 4278191104, 4278191104, 4294577152,
             4294707200, 4294707200, 4294707200, 4294707200, 4294837248, 4294837248, 4293926912, 4294316544,
             4278191104, 4278191104, 4294837248, 4294837248, 4280287232, 4280350720, 4294447104, 4294707200,
@@ -47,10 +47,10 @@ public class Vp8LHistogramTests
             4280287232, 4280287232, 4280287232, 4280287232, 4280287232, 4279503872, 4279503872, 4280288256,
             4280287232, 4280287232, 4280287232, 4280287232, 4280287232, 4280287232, 4280287232, 4280287232,
             4280287232, 4280287232, 4280287232, 4280287232, 4280287232, 4280287232, 4280287232, 4280287232
-        };
+        ];
 
         uint[] literals =
-        {
+        [
             198, 0, 14, 0, 46, 0, 22, 0, 36, 0, 24, 0, 12, 0, 10, 0, 10, 0, 2, 0, 2, 0, 0, 0, 0, 0, 6, 0, 0, 0,
             10, 0, 24, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 2, 0, 0, 0, 4, 0, 2, 0, 0, 0, 0, 0, 0, 0, 0,
             0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
@@ -59,25 +59,21 @@ public class Vp8LHistogramTests
             0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 2, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
             0, 0, 0, 0, 0, 6, 0, 2, 0, 0, 0, 0, 0, 6, 0, 0, 0, 2, 0, 0, 0, 2, 0, 2, 0, 0, 0, 0, 0, 0, 0, 0, 0,
             0, 0, 0, 0, 2, 0, 0, 0, 0, 0, 6, 0, 2, 0, 2, 0, 2, 0, 0, 0, 8, 0, 2, 0, 38, 0, 4
-        };
+        ];
 
         uint[] expectedLiterals = new uint[1305];
 
         // All remaining values are expected to be zero.
         literals.AsSpan().CopyTo(expectedLiterals);
 
-        Vp8LBackwardRefs backwardRefs = new(pixelData.Length);
+        MemoryAllocator memoryAllocator = Configuration.Default.MemoryAllocator;
+
+        using Vp8LBackwardRefs backwardRefs = new(memoryAllocator, pixelData.Length);
         for (int i = 0; i < pixelData.Length; i++)
         {
-            backwardRefs.Add(new PixOrCopy()
-            {
-                BgraOrDistance = pixelData[i],
-                Len = 1,
-                Mode = PixOrCopyMode.Literal
-            });
+            backwardRefs.Add(PixOrCopy.CreateLiteral(pixelData[i]));
         }
 
-        MemoryAllocator memoryAllocator = Configuration.Default.MemoryAllocator;
         using OwnedVp8LHistogram histogram0 = OwnedVp8LHistogram.Create(memoryAllocator, backwardRefs, 3);
         using OwnedVp8LHistogram histogram1 = OwnedVp8LHistogram.Create(memoryAllocator, backwardRefs, 3);
         for (int i = 0; i < 5; i++)
diff --git a/tests/ImageSharp.Tests/Formats/WebP/Vp8ModeScoreTests.cs b/tests/ImageSharp.Tests/Formats/WebP/Vp8ModeScoreTests.cs
index 0b85ececb9..ded637967a 100644
--- a/tests/ImageSharp.Tests/Formats/WebP/Vp8ModeScoreTests.cs
+++ b/tests/ImageSharp.Tests/Formats/WebP/Vp8ModeScoreTests.cs
@@ -11,7 +11,7 @@ public class Vp8ModeScoreTests
     [Fact]
     public void InitScore_Works()
     {
-        var score = new Vp8ModeScore();
+        Vp8ModeScore score = new();
         score.InitScore();
         Assert.Equal(0, score.D);
         Assert.Equal(0, score.SD);
@@ -25,7 +25,7 @@ public class Vp8ModeScoreTests
     public void CopyScore_Works()
     {
         // arrange
-        var score1 = new Vp8ModeScore
+        Vp8ModeScore score1 = new()
         {
             Score = 123,
             Nz = 1,
@@ -36,7 +36,7 @@ public class Vp8ModeScoreTests
             R = 6,
             SD = 7
         };
-        var score2 = new Vp8ModeScore();
+        Vp8ModeScore score2 = new();
         score2.InitScore();
 
         // act
@@ -55,7 +55,7 @@ public class Vp8ModeScoreTests
     public void AddScore_Works()
     {
         // arrange
-        var score1 = new Vp8ModeScore
+        Vp8ModeScore score1 = new()
         {
             Score = 123,
             Nz = 1,
@@ -66,7 +66,7 @@ public class Vp8ModeScoreTests
             R = 6,
             SD = 7
         };
-        var score2 = new Vp8ModeScore
+        Vp8ModeScore score2 = new()
         {
             Score = 123,
             Nz = 1,
diff --git a/tests/ImageSharp.Tests/Formats/WebP/Vp8ResidualTests.cs b/tests/ImageSharp.Tests/Formats/WebP/Vp8ResidualTests.cs
index 4982929c2c..62c67c2e0f 100644
--- a/tests/ImageSharp.Tests/Formats/WebP/Vp8ResidualTests.cs
+++ b/tests/ImageSharp.Tests/Formats/WebP/Vp8ResidualTests.cs
@@ -239,7 +239,7 @@ public class Vp8ResidualTests
     {
         // arrange
         Vp8Residual residual = new();
-        short[] coeffs = { 110, 0, -2, 0, 0, 0, 0, 0, 0, -1, 0, 0, 0, 0, 0, 0 };
+        short[] coeffs = [110, 0, -2, 0, 0, 0, 0, 0, 0, -1, 0, 0, 0, 0, 0, 0];
 
         // act
         residual.SetCoeffs(coeffs);
diff --git a/tests/ImageSharp.Tests/Formats/WebP/WebpCommonUtilsTests.cs b/tests/ImageSharp.Tests/Formats/WebP/WebpCommonUtilsTests.cs
index 80302db393..ca1859e543 100644
--- a/tests/ImageSharp.Tests/Formats/WebP/WebpCommonUtilsTests.cs
+++ b/tests/ImageSharp.Tests/Formats/WebP/WebpCommonUtilsTests.cs
@@ -45,7 +45,7 @@ public class WebpCommonUtilsTests
     {
         // arrange
         byte[] rowBytes =
-        {
+        [
             122, 120, 101, 255,
             171, 165, 151, 255,
             209, 208, 210, 255,
@@ -104,9 +104,9 @@ public class WebpCommonUtilsTests
             171, 165, 151, 0,
             209, 208, 210, 100,
             174, 183, 189, 255,
-            148, 158, 158, 255,
-        };
-        Span<Bgra32> row = MemoryMarshal.Cast<byte, Bgra32>((Span<byte>)rowBytes);
+            148, 158, 158, 255
+        ];
+        ReadOnlySpan<Bgra32> row = MemoryMarshal.Cast<byte, Bgra32>(rowBytes);
 
         bool noneOpaque;
         for (int length = 8; length < row.Length; length += 8)
@@ -127,7 +127,7 @@ public class WebpCommonUtilsTests
     {
         // arrange
         byte[] rowBytes =
-        {
+        [
             122, 120, 101, 255,
             171, 165, 151, 255,
             209, 208, 210, 255,
@@ -186,9 +186,9 @@ public class WebpCommonUtilsTests
             171, 165, 151, 255,
             209, 208, 210, 255,
             174, 183, 189, 255,
-            148, 158, 158, 255,
-        };
-        Span<Bgra32> row = MemoryMarshal.Cast<byte, Bgra32>((Span<byte>)rowBytes);
+            148, 158, 158, 255
+        ];
+        ReadOnlySpan<Bgra32> row = MemoryMarshal.Cast<byte, Bgra32>(rowBytes);
 
         bool noneOpaque;
         for (int length = 8; length < row.Length; length += 8)
diff --git a/tests/ImageSharp.Tests/Formats/WebP/WebpDecoderTests.cs b/tests/ImageSharp.Tests/Formats/WebP/WebpDecoderTests.cs
index 657ab25546..111544f7f5 100644
--- a/tests/ImageSharp.Tests/Formats/WebP/WebpDecoderTests.cs
+++ b/tests/ImageSharp.Tests/Formats/WebP/WebpDecoderTests.cs
@@ -5,6 +5,7 @@ using System.Runtime.Intrinsics.X86;
 using SixLabors.ImageSharp.Formats;
 using SixLabors.ImageSharp.Formats.Webp;
 using SixLabors.ImageSharp.Metadata;
+using SixLabors.ImageSharp.Metadata.Profiles.Exif;
 using SixLabors.ImageSharp.PixelFormats;
 using SixLabors.ImageSharp.Tests.TestUtilities;
 using SixLabors.ImageSharp.Tests.TestUtilities.ImageComparison;
@@ -348,7 +349,7 @@ public class WebpDecoderTests
         WebpDecoderOptions options = new()
         {
             BackgroundColorHandling = BackgroundColorHandling.Ignore,
-            GeneralOptions = new DecoderOptions()
+            GeneralOptions = new DecoderOptions
             {
                 MaxFrames = 1
             }
@@ -387,7 +388,7 @@ public class WebpDecoderTests
     {
         DecoderOptions options = new()
         {
-            TargetSize = new() { Width = 150, Height = 150 }
+            TargetSize = new Size { Width = 150, Height = 150 }
         };
 
         using Image<TPixel> image = provider.GetImage(WebpDecoder.Instance, options);
@@ -450,6 +451,22 @@ public class WebpDecoderTests
         image.CompareToOriginal(provider, ReferenceDecoder);
     }
 
+    // https://github.com/SixLabors/ImageSharp/issues/2866
+    [Theory]
+    [WithFile(Lossy.Issue2866, PixelTypes.Rgba32)]
+    public void WebpDecoder_CanDecode_Issue2866<TPixel>(TestImageProvider<TPixel> provider)
+        where TPixel : unmanaged, IPixel<TPixel>
+    {
+        // Web
+        using Image<TPixel> image = provider.GetImage(
+            WebpDecoder.Instance,
+            new WebpDecoderOptions { BackgroundColorHandling = BackgroundColorHandling.Ignore });
+
+        // We can't use the reference decoder here.
+        // It creates frames of different size without blending the frames.
+        image.DebugSave(provider, extension: "webp", encoder: new WebpEncoder());
+    }
+
     [Theory]
     [WithFile(Lossless.LossLessCorruptImage3, PixelTypes.Rgba32)]
     public void WebpDecoder_ThrowImageFormatException_OnInvalidImages<TPixel>(TestImageProvider<TPixel> provider)
@@ -533,4 +550,32 @@ public class WebpDecoderTests
         Assert.Equal(37.8, meta.VerticalResolution);
         Assert.Equal(PixelResolutionUnit.PixelsPerCentimeter, meta.ResolutionUnits);
     }
+
+    [Theory]
+    [WithFile(Lossy.Issue2925, PixelTypes.Rgba32)]
+    public void WebpDecoder_CanDecode_Issue2925<TPixel>(TestImageProvider<TPixel> provider)
+        where TPixel : unmanaged, IPixel<TPixel>
+    {
+        using Image<TPixel> image = provider.GetImage(WebpDecoder.Instance);
+        image.DebugSave(provider);
+        image.CompareToOriginal(provider, ReferenceDecoder);
+    }
+
+    [Theory]
+    [WithFile(Lossy.Issue2906, PixelTypes.Rgba32)]
+    public void WebpDecoder_CanDecode_Issue2906<TPixel>(TestImageProvider<TPixel> provider)
+        where TPixel : unmanaged, IPixel<TPixel>
+    {
+        using Image<TPixel> image = provider.GetImage(WebpDecoder.Instance);
+
+        ExifProfile exifProfile = image.Metadata.ExifProfile;
+        IExifValue<EncodedString> comment = exifProfile.GetValue(ExifTag.UserComment);
+
+        Assert.NotNull(comment);
+        Assert.Equal(EncodedString.CharacterCode.Unicode, comment.Value.Code);
+        Assert.StartsWith("1girl, pariya, ", comment.Value.Text);
+
+        image.DebugSave(provider);
+        image.CompareToOriginal(provider, ReferenceDecoder);
+    }
 }
diff --git a/tests/ImageSharp.Tests/Formats/WebP/WebpEncoderTests.cs b/tests/ImageSharp.Tests/Formats/WebP/WebpEncoderTests.cs
index f82fa65df8..f9836ffb13 100644
--- a/tests/ImageSharp.Tests/Formats/WebP/WebpEncoderTests.cs
+++ b/tests/ImageSharp.Tests/Formats/WebP/WebpEncoderTests.cs
@@ -8,6 +8,8 @@ using SixLabors.ImageSharp.Formats.Png;
 using SixLabors.ImageSharp.Formats.Webp;
 using SixLabors.ImageSharp.Metadata;
 using SixLabors.ImageSharp.PixelFormats;
+using SixLabors.ImageSharp.Processing;
+using SixLabors.ImageSharp.Processing.Processors.Quantization;
 using SixLabors.ImageSharp.Tests.TestUtilities;
 using SixLabors.ImageSharp.Tests.TestUtilities.ImageComparison;
 using SixLabors.ImageSharp.Tests.TestUtilities.ReferenceCodecs;
@@ -110,6 +112,63 @@ public class WebpEncoderTests
         }
     }
 
+    [Theory]
+    // [WithFile(AlphaBlend, PixelTypes.Rgba32)]
+    // [WithFile(AlphaBlend2, PixelTypes.Rgba32)]
+    [WithFile(AlphaBlend3, PixelTypes.Rgba32)]
+    // [WithFile(AlphaBlend4, PixelTypes.Rgba32)]
+    public void Encode_AlphaBlended<TPixel>(TestImageProvider<TPixel> provider)
+        where TPixel : unmanaged, IPixel<TPixel>
+    {
+        using Image<TPixel> image = provider.GetImage();
+        WebpEncoder encoder = new()
+        {
+            FileFormat = WebpFileFormatType.Lossless
+        };
+
+        QuantizerOptions options = new()
+        {
+            TransparencyThreshold = 128 / 255F
+        };
+
+        // First save as gif to gif using different quantizers with default options.
+        // Alpha thresholding is 64/255F.
+        GifEncoder gifEncoder = new()
+        {
+            Quantizer = new OctreeQuantizer(options)
+        };
+        provider.Utility.SaveTestOutputFile(image, "gif", gifEncoder, "octree");
+
+        gifEncoder = new GifEncoder
+        {
+            Quantizer = new WuQuantizer(options)
+        };
+        provider.Utility.SaveTestOutputFile(image, "gif", gifEncoder, "wu");
+
+        // Now clone and quantize the image using the same quantizers  without alpha thresholding and save as webp.
+        options = new QuantizerOptions
+        {
+            TransparencyThreshold = 0
+        };
+
+        using Image<TPixel> cloned1 = image.Clone();
+        cloned1.Mutate(c => c.Quantize(new OctreeQuantizer(options)));
+        provider.Utility.SaveTestOutputFile(cloned1, "webp", encoder, "octree");
+
+        using Image<TPixel> cloned2 = image.Clone();
+        cloned2.Mutate(c => c.Quantize(new WuQuantizer(options)));
+        provider.Utility.SaveTestOutputFile(cloned2, "webp", encoder, "wu");
+
+        // Now blend the images with a blue background and save as webp.
+        using Image<Rgba32> background1 = new(image.Width, image.Height, Color.White.ToPixel<Rgba32>());
+        background1.Mutate(c => c.DrawImage(cloned1, 1));
+        provider.Utility.SaveTestOutputFile(background1, "webp", encoder, "octree-blended");
+
+        using Image<Rgba32> background2 = new(image.Width, image.Height, Color.White.ToPixel<Rgba32>());
+        background2.Mutate(c => c.DrawImage(cloned2, 1));
+        provider.Utility.SaveTestOutputFile(background2, "webp", encoder, "wu-blended");
+    }
+
     [Theory]
     [WithFile(TestImages.Png.APng, PixelTypes.Rgba32)]
     public void Encode_AnimatedFormatTransform_FromPng<TPixel>(TestImageProvider<TPixel> provider)
diff --git a/tests/ImageSharp.Tests/Formats/WebP/WebpMetaDataTests.cs b/tests/ImageSharp.Tests/Formats/WebP/WebpMetaDataTests.cs
index ab8fef60f7..020b42f377 100644
--- a/tests/ImageSharp.Tests/Formats/WebP/WebpMetaDataTests.cs
+++ b/tests/ImageSharp.Tests/Formats/WebP/WebpMetaDataTests.cs
@@ -103,9 +103,9 @@ public class WebpMetaDataTests
     public void Encode_WritesExifWithPadding(WebpFileFormatType fileFormatType)
     {
         // arrange
-        using var input = new Image<Rgba32>(25, 25);
-        using var memoryStream = new MemoryStream();
-        var expectedExif = new ExifProfile();
+        using Image<Rgba32> input = new(25, 25);
+        using MemoryStream memoryStream = new();
+        ExifProfile expectedExif = new();
         string expectedSoftware = "ImageSharp";
         expectedExif.SetValue(ExifTag.Software, expectedSoftware);
         input.Metadata.ExifProfile = expectedExif;
@@ -115,7 +115,7 @@ public class WebpMetaDataTests
         memoryStream.Position = 0;
 
         // assert
-        using var image = Image.Load<Rgba32>(memoryStream);
+        using Image<Rgba32> image = Image.Load<Rgba32>(memoryStream);
         ExifProfile actualExif = image.Metadata.ExifProfile;
         Assert.NotNull(actualExif);
         Assert.Equal(expectedExif.Values.Count, actualExif.Values.Count);
@@ -129,7 +129,7 @@ public class WebpMetaDataTests
     {
         // arrange
         using Image<TPixel> input = provider.GetImage(WebpDecoder.Instance);
-        using var memoryStream = new MemoryStream();
+        using MemoryStream memoryStream = new();
         ExifProfile expectedExif = input.Metadata.ExifProfile;
 
         // act
@@ -137,7 +137,7 @@ public class WebpMetaDataTests
         memoryStream.Position = 0;
 
         // assert
-        using var image = Image.Load<Rgba32>(memoryStream);
+        using Image<Rgba32> image = Image.Load<Rgba32>(memoryStream);
         ExifProfile actualExif = image.Metadata.ExifProfile;
         Assert.NotNull(actualExif);
         Assert.Equal(expectedExif.Values.Count, actualExif.Values.Count);
@@ -150,7 +150,7 @@ public class WebpMetaDataTests
     {
         // arrange
         using Image<TPixel> input = provider.GetImage(WebpDecoder.Instance);
-        using var memoryStream = new MemoryStream();
+        using MemoryStream memoryStream = new();
         ExifProfile expectedExif = input.Metadata.ExifProfile;
 
         // act
@@ -158,7 +158,7 @@ public class WebpMetaDataTests
         memoryStream.Position = 0;
 
         // assert
-        using var image = Image.Load<Rgba32>(memoryStream);
+        using Image<Rgba32> image = Image.Load<Rgba32>(memoryStream);
         ExifProfile actualExif = image.Metadata.ExifProfile;
         Assert.NotNull(actualExif);
         Assert.Equal(expectedExif.Values.Count, actualExif.Values.Count);
@@ -174,14 +174,14 @@ public class WebpMetaDataTests
         ImageSharp.Metadata.Profiles.Icc.IccProfile expectedProfile = input.Metadata.IccProfile;
         byte[] expectedProfileBytes = expectedProfile.ToByteArray();
 
-        using var memStream = new MemoryStream();
+        using MemoryStream memStream = new();
         input.Save(memStream, new WebpEncoder()
         {
             FileFormat = fileFormat
         });
 
         memStream.Position = 0;
-        using var output = Image.Load<Rgba32>(memStream);
+        using Image<Rgba32> output = Image.Load<Rgba32>(memStream);
         ImageSharp.Metadata.Profiles.Icc.IccProfile actualProfile = output.Metadata.IccProfile;
         byte[] actualProfileBytes = actualProfile.ToByteArray();
 
diff --git a/tests/ImageSharp.Tests/Formats/WebP/YuvConversionTests.cs b/tests/ImageSharp.Tests/Formats/WebP/YuvConversionTests.cs
index f50bc89335..e86642fea9 100644
--- a/tests/ImageSharp.Tests/Formats/WebP/YuvConversionTests.cs
+++ b/tests/ImageSharp.Tests/Formats/WebP/YuvConversionTests.cs
@@ -19,7 +19,7 @@ public class YuvConversionTests
 
     public static void RunUpSampleYuvToRgbTest()
     {
-        var provider = TestImageProvider<Rgba32>.File(TestImageLossyFullPath);
+        TestImageProvider<Rgba32> provider = TestImageProvider<Rgba32>.File(TestImageLossyFullPath);
         using Image<Rgba32> image = provider.GetImage(WebpDecoder.Instance);
         image.DebugSave(provider);
         image.CompareToOriginal(provider, ReferenceDecoder);
@@ -52,7 +52,7 @@ public class YuvConversionTests
         Span<byte> u = uBuffer.GetSpan();
         Span<byte> v = vBuffer.GetSpan();
         byte[] expectedY =
-        {
+        [
             82, 82, 82, 82, 128, 135, 134, 129, 167, 179, 176, 172, 192, 201, 200, 204, 188, 172, 175, 177, 168,
             151, 154, 154, 153, 152, 151, 151, 152, 160, 160, 160, 160, 82, 82, 82, 82, 140, 137, 135, 116, 174,
             183, 176, 162, 196, 199, 199, 210, 188, 166, 176, 181, 170, 145, 155, 154, 153, 154, 151, 151, 150,
@@ -106,9 +106,9 @@ public class YuvConversionTests
             86, 75, 72, 77, 106, 96, 97, 96, 97, 100, 100, 100, 160, 160, 160, 159, 169, 170, 168, 170, 129,
             115, 117, 123, 90, 71, 76, 79, 62, 51, 51, 47, 59, 79, 75, 74, 81, 100, 97, 98, 98, 100, 100, 100,
             100
-        };
+        ];
         byte[] expectedU =
-        {
+        [
             90, 90, 59, 63, 36, 38, 23, 20, 34, 35, 47, 48, 70, 82, 104, 121, 121, 90, 90, 61, 69, 37, 42, 22,
             18, 33, 32, 47, 47, 67, 75, 97, 113, 120, 59, 61, 30, 37, 22, 20, 38, 36, 50, 50, 78, 83, 113, 122,
             142, 166, 164, 63, 69, 37, 43, 20, 18, 34, 32, 48, 47, 70, 73, 102, 110, 136, 166, 166, 36, 37, 22,
@@ -123,9 +123,9 @@ public class YuvConversionTests
             184, 212, 208, 227, 228, 227, 229, 218, 214, 196, 185, 188, 121, 113, 166, 166, 197, 191, 220, 217,
             232, 237, 223, 222, 211, 208, 185, 173, 172, 121, 120, 164, 166, 193, 194, 217, 219, 232, 235, 224,
             220, 212, 207, 188, 172, 172
-        };
+        ];
         byte[] expectedV =
-        {
+        [
             240, 240, 201, 206, 172, 174, 136, 136, 92, 90, 55, 50, 37, 30, 26, 23, 23, 240, 240, 204, 213, 173,
             179, 141, 141, 96, 98, 56, 54, 38, 31, 27, 25, 23, 201, 204, 164, 172, 129, 135, 82, 87, 46, 47, 33,
             29, 25, 23, 20, 16, 16, 206, 213, 172, 180, 137, 141, 93, 99, 54, 54, 36, 31, 26, 25, 21, 17, 16,
@@ -139,7 +139,7 @@ public class YuvConversionTests
             118, 151, 164, 188, 205, 206, 26, 27, 20, 21, 43, 39, 74, 69, 103, 102, 138, 143, 174, 188, 204,
             216, 218, 23, 25, 16, 17, 55, 48, 85, 81, 117, 118, 159, 164, 195, 205, 216, 227, 227, 23, 23, 16,
             16, 51, 52, 81, 83, 116, 122, 157, 168, 194, 206, 218, 227, 227
-        };
+        ];
 
         // act
         YuvConversion.ConvertRgbToYuv(image.Frames.RootFrame.PixelBuffer.GetRegion(), config, memoryAllocator, y, u, v);
@@ -169,7 +169,7 @@ public class YuvConversionTests
         Span<byte> u = uBuffer.GetSpan();
         Span<byte> v = vBuffer.GetSpan();
         byte[] expectedY =
-        {
+        [
             16, 16, 16, 16, 16, 235, 235, 235, 235, 235, 16, 16, 16, 16, 16, 152, 41, 41, 152, 152, 41, 41, 152,
             152, 41, 41, 152, 152, 41, 41, 152, 16, 16, 16, 16, 16, 235, 235, 235, 235, 235, 16, 16, 16, 16, 16,
             152, 41, 41, 152, 152, 41, 41, 152, 152, 41, 41, 152, 152, 41, 41, 152, 16, 16, 16, 16, 16, 235,
@@ -213,9 +213,9 @@ public class YuvConversionTests
             41, 41, 41, 41, 41, 41, 41, 41, 41, 41, 41, 41, 41, 41, 41, 29, 106, 183, 66, 143, 130, 78, 90, 168,
             116, 103, 180, 63, 140, 152, 75, 41, 41, 41, 41, 41, 41, 41, 41, 41, 41, 41, 41, 41, 41, 41, 93,
             171, 53, 131, 118, 66, 78, 155, 103, 90, 167, 50, 128, 140, 63, 75
-        };
+        ];
         byte[] expectedU =
-        {
+        [
             128, 128, 128, 128, 128, 128, 128, 139, 240, 139, 240, 139, 240, 139, 240, 139, 128, 128, 128, 128,
             128, 128, 128, 139, 240, 139, 240, 139, 240, 139, 240, 139, 128, 128, 128, 128, 128, 128, 128, 139,
             240, 139, 240, 139, 240, 139, 240, 139, 128, 128, 128, 128, 128, 128, 128, 139, 240, 139, 240, 139,
@@ -229,9 +229,9 @@ public class YuvConversionTests
             159, 159, 159, 159, 159, 159, 159, 161, 112, 113, 138, 87, 143, 112, 88, 161, 240, 240, 240, 240,
             240, 240, 240, 137, 110, 162, 110, 140, 158, 104, 159, 137, 240, 240, 240, 240, 240, 240, 240, 109,
             150, 108, 140, 161, 80, 157, 162, 128
-        };
+        ];
         byte[] expectedV =
-        {
+        [
             128, 128, 128, 128, 128, 128, 128, 189, 110, 189, 110, 189, 110, 189, 110, 189, 128, 128, 128, 128,
             128, 128, 128, 189, 110, 189, 110, 189, 110, 189, 110, 189, 128, 128, 128, 128, 128, 128, 128, 189,
             110, 189, 110, 189, 110, 189, 110, 189, 128, 128, 128, 128, 128, 128, 128, 189, 110, 189, 110, 189,
@@ -245,7 +245,7 @@ public class YuvConversionTests
             141, 165, 126, 147, 173, 101, 101, 101, 101, 101, 101, 101, 135, 109, 129, 122, 124, 107, 108, 128,
             138, 110, 110, 110, 110, 110, 110, 110, 117, 137, 151, 127, 114, 131, 139, 142, 120, 110, 110, 110,
             110, 110, 110, 110, 142, 156, 119, 137, 167, 141, 151, 66, 85
-        };
+        ];
 
         // act
         YuvConversion.ConvertRgbToYuv(image.Frames.RootFrame.PixelBuffer.GetRegion(), config, memoryAllocator, y, u, v);
diff --git a/tests/ImageSharp.Tests/GraphicOptionsDefaultsExtensionsTests.cs b/tests/ImageSharp.Tests/GraphicOptionsDefaultsExtensionsTests.cs
index d663a803b3..682f5373db 100644
--- a/tests/ImageSharp.Tests/GraphicOptionsDefaultsExtensionsTests.cs
+++ b/tests/ImageSharp.Tests/GraphicOptionsDefaultsExtensionsTests.cs
@@ -12,9 +12,9 @@ public class GraphicOptionsDefaultsExtensionsTests
     [Fact]
     public void SetDefaultOptionsOnProcessingContext()
     {
-        var option = new GraphicsOptions();
-        var config = new Configuration();
-        var context = new FakeImageOperationsProvider.FakeImageOperations<Rgba32>(config, null, true);
+        GraphicsOptions option = new();
+        Configuration config = new();
+        FakeImageOperationsProvider.FakeImageOperations<Rgba32> context = new(config, null, true);
 
         context.SetGraphicsOptions(option);
 
@@ -26,12 +26,12 @@ public class GraphicOptionsDefaultsExtensionsTests
     [Fact]
     public void UpdateDefaultOptionsOnProcessingContext_AlwaysNewInstance()
     {
-        var option = new GraphicsOptions()
+        GraphicsOptions option = new()
         {
             BlendPercentage = 0.9f
         };
-        var config = new Configuration();
-        var context = new FakeImageOperationsProvider.FakeImageOperations<Rgba32>(config, null, true);
+        Configuration config = new();
+        FakeImageOperationsProvider.FakeImageOperations<Rgba32> context = new(config, null, true);
         context.SetGraphicsOptions(option);
 
         context.SetGraphicsOptions(o =>
@@ -40,7 +40,7 @@ public class GraphicOptionsDefaultsExtensionsTests
             o.BlendPercentage = 0.4f;
         });
 
-        var returnedOption = context.GetGraphicsOptions();
+        GraphicsOptions returnedOption = context.GetGraphicsOptions();
         Assert.Equal(0.4f, returnedOption.BlendPercentage);
         Assert.Equal(0.9f, option.BlendPercentage); // hasn't been mutated
     }
@@ -48,8 +48,8 @@ public class GraphicOptionsDefaultsExtensionsTests
     [Fact]
     public void SetDefaultOptionsOnConfiguration()
     {
-        var option = new GraphicsOptions();
-        var config = new Configuration();
+        GraphicsOptions option = new();
+        Configuration config = new();
 
         config.SetGraphicsOptions(option);
 
@@ -59,11 +59,11 @@ public class GraphicOptionsDefaultsExtensionsTests
     [Fact]
     public void UpdateDefaultOptionsOnConfiguration_AlwaysNewInstance()
     {
-        var option = new GraphicsOptions()
+        GraphicsOptions option = new()
         {
             BlendPercentage = 0.9f
         };
-        var config = new Configuration();
+        Configuration config = new();
         config.SetGraphicsOptions(option);
 
         config.SetGraphicsOptions(o =>
@@ -72,7 +72,7 @@ public class GraphicOptionsDefaultsExtensionsTests
             o.BlendPercentage = 0.4f;
         });
 
-        var returnedOption = config.GetGraphicsOptions();
+        GraphicsOptions returnedOption = config.GetGraphicsOptions();
         Assert.Equal(0.4f, returnedOption.BlendPercentage);
         Assert.Equal(0.9f, option.BlendPercentage); // hasn't been mutated
     }
@@ -80,13 +80,13 @@ public class GraphicOptionsDefaultsExtensionsTests
     [Fact]
     public void GetDefaultOptionsFromConfiguration_SettingNullThenReturnsNewInstance()
     {
-        var config = new Configuration();
+        Configuration config = new();
 
-        var options = config.GetGraphicsOptions();
+        GraphicsOptions options = config.GetGraphicsOptions();
         Assert.NotNull(options);
         config.SetGraphicsOptions((GraphicsOptions)null);
 
-        var options2 = config.GetGraphicsOptions();
+        GraphicsOptions options2 = config.GetGraphicsOptions();
         Assert.NotNull(options2);
 
         // we set it to null should now be a new instance
@@ -96,10 +96,10 @@ public class GraphicOptionsDefaultsExtensionsTests
     [Fact]
     public void GetDefaultOptionsFromConfiguration_IgnoreIncorectlyTypesDictionEntry()
     {
-        var config = new Configuration();
+        Configuration config = new();
 
         config.Properties[typeof(GraphicsOptions)] = "wronge type";
-        var options = config.GetGraphicsOptions();
+        GraphicsOptions options = config.GetGraphicsOptions();
         Assert.NotNull(options);
         Assert.IsType<GraphicsOptions>(options);
     }
@@ -107,63 +107,63 @@ public class GraphicOptionsDefaultsExtensionsTests
     [Fact]
     public void GetDefaultOptionsFromConfiguration_AlwaysReturnsInstance()
     {
-        var config = new Configuration();
+        Configuration config = new();
 
         Assert.DoesNotContain(typeof(GraphicsOptions), config.Properties.Keys);
-        var options = config.GetGraphicsOptions();
+        GraphicsOptions options = config.GetGraphicsOptions();
         Assert.NotNull(options);
     }
 
     [Fact]
     public void GetDefaultOptionsFromConfiguration_AlwaysReturnsSameValue()
     {
-        var config = new Configuration();
+        Configuration config = new();
 
-        var options = config.GetGraphicsOptions();
-        var options2 = config.GetGraphicsOptions();
+        GraphicsOptions options = config.GetGraphicsOptions();
+        GraphicsOptions options2 = config.GetGraphicsOptions();
         Assert.Equal(options, options2);
     }
 
     [Fact]
     public void GetDefaultOptionsFromProcessingContext_AlwaysReturnsInstance()
     {
-        var config = new Configuration();
-        var context = new FakeImageOperationsProvider.FakeImageOperations<Rgba32>(config, null, true);
+        Configuration config = new();
+        FakeImageOperationsProvider.FakeImageOperations<Rgba32> context = new(config, null, true);
 
-        var ctxOptions = context.GetGraphicsOptions();
+        GraphicsOptions ctxOptions = context.GetGraphicsOptions();
         Assert.NotNull(ctxOptions);
     }
 
     [Fact]
     public void GetDefaultOptionsFromProcessingContext_AlwaysReturnsInstanceEvenIfSetToNull()
     {
-        var config = new Configuration();
-        var context = new FakeImageOperationsProvider.FakeImageOperations<Rgba32>(config, null, true);
+        Configuration config = new();
+        FakeImageOperationsProvider.FakeImageOperations<Rgba32> context = new(config, null, true);
 
         context.SetGraphicsOptions((GraphicsOptions)null);
-        var ctxOptions = context.GetGraphicsOptions();
+        GraphicsOptions ctxOptions = context.GetGraphicsOptions();
         Assert.NotNull(ctxOptions);
     }
 
     [Fact]
     public void GetDefaultOptionsFromProcessingContext_FallbackToConfigsInstance()
     {
-        var option = new GraphicsOptions();
-        var config = new Configuration();
+        GraphicsOptions option = new();
+        Configuration config = new();
         config.SetGraphicsOptions(option);
-        var context = new FakeImageOperationsProvider.FakeImageOperations<Rgba32>(config, null, true);
+        FakeImageOperationsProvider.FakeImageOperations<Rgba32> context = new(config, null, true);
 
-        var ctxOptions = context.GetGraphicsOptions();
+        GraphicsOptions ctxOptions = context.GetGraphicsOptions();
         Assert.Equal(option, ctxOptions);
     }
 
     [Fact]
     public void GetDefaultOptionsFromProcessingContext_IgnoreIncorectlyTypesDictionEntry()
     {
-        var config = new Configuration();
-        var context = new FakeImageOperationsProvider.FakeImageOperations<Rgba32>(config, null, true);
+        Configuration config = new();
+        FakeImageOperationsProvider.FakeImageOperations<Rgba32> context = new(config, null, true);
         context.Properties[typeof(GraphicsOptions)] = "wronge type";
-        var options = context.GetGraphicsOptions();
+        GraphicsOptions options = context.GetGraphicsOptions();
         Assert.NotNull(options);
         Assert.IsType<GraphicsOptions>(options);
     }
diff --git a/tests/ImageSharp.Tests/GraphicsOptionsTests.cs b/tests/ImageSharp.Tests/GraphicsOptionsTests.cs
index 3531599866..0ccb80d3f5 100644
--- a/tests/ImageSharp.Tests/GraphicsOptionsTests.cs
+++ b/tests/ImageSharp.Tests/GraphicsOptionsTests.cs
@@ -8,8 +8,8 @@ namespace SixLabors.ImageSharp.Tests;
 
 public class GraphicsOptionsTests
 {
-    private static readonly GraphicsOptionsComparer GraphicsOptionsComparer = new GraphicsOptionsComparer();
-    private readonly GraphicsOptions newGraphicsOptions = new GraphicsOptions();
+    private static readonly GraphicsOptionsComparer GraphicsOptionsComparer = new();
+    private readonly GraphicsOptions newGraphicsOptions = new();
     private readonly GraphicsOptions cloneGraphicsOptions = new GraphicsOptions().DeepClone();
 
     [Fact]
@@ -57,7 +57,7 @@ public class GraphicsOptionsTests
     [Fact]
     public void NonDefaultClone()
     {
-        var expected = new GraphicsOptions
+        GraphicsOptions expected = new()
         {
             AlphaCompositionMode = PixelAlphaCompositionMode.DestAtop,
             Antialias = false,
@@ -74,7 +74,7 @@ public class GraphicsOptionsTests
     [Fact]
     public void CloneIsDeep()
     {
-        var expected = new GraphicsOptions();
+        GraphicsOptions expected = new();
         GraphicsOptions actual = expected.DeepClone();
 
         actual.AlphaCompositionMode = PixelAlphaCompositionMode.DestAtop;
diff --git a/tests/ImageSharp.Tests/Helpers/ColorNumericsTests.cs b/tests/ImageSharp.Tests/Helpers/ColorNumericsTests.cs
index 4c06d0cd55..1bf137f34d 100644
--- a/tests/ImageSharp.Tests/Helpers/ColorNumericsTests.cs
+++ b/tests/ImageSharp.Tests/Helpers/ColorNumericsTests.cs
@@ -15,7 +15,7 @@ public class ColorNumericsTests
     public void GetBT709Luminance_WithVector4(float x, float y, float z, int luminanceLevels, int expected)
     {
         // arrange
-        var vector = new Vector4(x, y, z, 0.0f);
+        Vector4 vector = new(x, y, z, 0.0f);
 
         // act
         int actual = ColorNumerics.GetBT709Luminance(ref vector, luminanceLevels);
diff --git a/tests/ImageSharp.Tests/Helpers/NumericsTests.cs b/tests/ImageSharp.Tests/Helpers/NumericsTests.cs
index 75f988a4cb..1106144c4f 100644
--- a/tests/ImageSharp.Tests/Helpers/NumericsTests.cs
+++ b/tests/ImageSharp.Tests/Helpers/NumericsTests.cs
@@ -9,7 +9,7 @@ public class NumericsTests
 {
     private delegate void SpanAction<T, in TArg, in TArg1>(Span<T> span, TArg arg, TArg1 arg1);
 
-    private readonly ApproximateFloatComparer approximateFloatComparer = new ApproximateFloatComparer(1e-6f);
+    private readonly ApproximateFloatComparer approximateFloatComparer = new(1e-6f);
 
     [Theory]
     [InlineData(0)]
@@ -162,7 +162,7 @@ public class NumericsTests
     [InlineData(63)]
     public void PremultiplyVectorSpan(int length)
     {
-        var rnd = new Random(42);
+        Random rnd = new(42);
         Vector4[] source = rnd.GenerateRandomVectorArray(length, 0, 1);
         Vector4[] expected = source.Select(v =>
         {
@@ -182,7 +182,7 @@ public class NumericsTests
     [InlineData(63)]
     public void UnPremultiplyVectorSpan(int length)
     {
-        var rnd = new Random(42);
+        Random rnd = new(42);
         Vector4[] source = rnd.GenerateRandomVectorArray(length, 0, 1);
         Vector4[] expected = source.Select(v =>
         {
@@ -280,7 +280,7 @@ public class NumericsTests
     {
         Span<T> actual = new T[length];
 
-        var r = new Random();
+        Random r = new();
         for (int i = 0; i < length; i++)
         {
             actual[i] = (T)Convert.ChangeType(r.Next(byte.MinValue, byte.MaxValue), typeof(T));
diff --git a/tests/ImageSharp.Tests/Helpers/ParallelExecutionSettingsTests.cs b/tests/ImageSharp.Tests/Helpers/ParallelExecutionSettingsTests.cs
index c13a30052c..983c3cc2b9 100644
--- a/tests/ImageSharp.Tests/Helpers/ParallelExecutionSettingsTests.cs
+++ b/tests/ImageSharp.Tests/Helpers/ParallelExecutionSettingsTests.cs
@@ -28,7 +28,7 @@ public class ParallelExecutionSettingsTests
         }
         else
         {
-            var parallelSettings = new ParallelExecutionSettings(
+            ParallelExecutionSettings parallelSettings = new(
                 maxDegreeOfParallelism,
                 Configuration.Default.MemoryAllocator);
             Assert.Equal(maxDegreeOfParallelism, parallelSettings.MaxDegreeOfParallelism);
diff --git a/tests/ImageSharp.Tests/Helpers/ParallelRowIteratorTests.cs b/tests/ImageSharp.Tests/Helpers/ParallelRowIteratorTests.cs
index d393850d6b..4b06f877fc 100644
--- a/tests/ImageSharp.Tests/Helpers/ParallelRowIteratorTests.cs
+++ b/tests/ImageSharp.Tests/Helpers/ParallelRowIteratorTests.cs
@@ -26,7 +26,7 @@ public class ParallelRowIteratorTests
     /// maxDegreeOfParallelism, minY, maxY, expectedStepLength, expectedLastStepLength
     /// </summary>
     public static TheoryData<int, int, int, int, int, int> IterateRows_OverMinimumPixelsLimit_Data =
-        new TheoryData<int, int, int, int, int, int>
+        new()
         {
             { 1, 0, 100, -1, 100, 1 },
             { 2, 0, 9, 5, 4, 2 },
@@ -52,12 +52,12 @@ public class ParallelRowIteratorTests
         int expectedLastStepLength,
         int expectedNumberOfSteps)
     {
-        var parallelSettings = new ParallelExecutionSettings(
+        ParallelExecutionSettings parallelSettings = new(
             maxDegreeOfParallelism,
             1,
             Configuration.Default.MemoryAllocator);
 
-        var rectangle = new Rectangle(0, minY, 10, maxY - minY);
+        Rectangle rectangle = new(0, minY, 10, maxY - minY);
 
         int actualNumberOfSteps = 0;
 
@@ -73,7 +73,7 @@ public class ParallelRowIteratorTests
             Assert.Equal(expected, step);
         }
 
-        var operation = new TestRowIntervalOperation(RowAction);
+        TestRowIntervalOperation operation = new(RowAction);
 
         ParallelRowIterator.IterateRowIntervals(
             rectangle,
@@ -93,15 +93,15 @@ public class ParallelRowIteratorTests
         int expectedLastStepLength,
         int expectedNumberOfSteps)
     {
-        var parallelSettings = new ParallelExecutionSettings(
+        ParallelExecutionSettings parallelSettings = new(
             maxDegreeOfParallelism,
             1,
             Configuration.Default.MemoryAllocator);
 
-        var rectangle = new Rectangle(0, minY, 10, maxY - minY);
+        Rectangle rectangle = new(0, minY, 10, maxY - minY);
 
         int[] expectedData = Enumerable.Repeat(0, minY).Concat(Enumerable.Range(minY, maxY - minY)).ToArray();
-        var actualData = new int[maxY];
+        int[] actualData = new int[maxY];
 
         void RowAction(RowInterval rows)
         {
@@ -111,7 +111,7 @@ public class ParallelRowIteratorTests
             }
         }
 
-        var operation = new TestRowIntervalOperation(RowAction);
+        TestRowIntervalOperation operation = new(RowAction);
 
         ParallelRowIterator.IterateRowIntervals(
             rectangle,
@@ -131,12 +131,12 @@ public class ParallelRowIteratorTests
         int expectedLastStepLength,
         int expectedNumberOfSteps)
     {
-        var parallelSettings = new ParallelExecutionSettings(
+        ParallelExecutionSettings parallelSettings = new(
             maxDegreeOfParallelism,
             1,
             Configuration.Default.MemoryAllocator);
 
-        var rectangle = new Rectangle(0, minY, 10, maxY - minY);
+        Rectangle rectangle = new(0, minY, 10, maxY - minY);
 
         int actualNumberOfSteps = 0;
 
@@ -152,7 +152,7 @@ public class ParallelRowIteratorTests
             Assert.Equal(expected, step);
         }
 
-        var operation = new TestRowIntervalOperation<Vector4>(RowAction);
+        TestRowIntervalOperation<Vector4> operation = new(RowAction);
 
         ParallelRowIterator.IterateRowIntervals<TestRowIntervalOperation<Vector4>, Vector4>(
             rectangle,
@@ -172,15 +172,15 @@ public class ParallelRowIteratorTests
         int expectedLastStepLength,
         int expectedNumberOfSteps)
     {
-        var parallelSettings = new ParallelExecutionSettings(
+        ParallelExecutionSettings parallelSettings = new(
             maxDegreeOfParallelism,
             1,
             Configuration.Default.MemoryAllocator);
 
-        var rectangle = new Rectangle(0, minY, 10, maxY - minY);
+        Rectangle rectangle = new(0, minY, 10, maxY - minY);
 
         int[] expectedData = Enumerable.Repeat(0, minY).Concat(Enumerable.Range(minY, maxY - minY)).ToArray();
-        var actualData = new int[maxY];
+        int[] actualData = new int[maxY];
 
         void RowAction(RowInterval rows, Span<Vector4> buffer)
         {
@@ -190,7 +190,7 @@ public class ParallelRowIteratorTests
             }
         }
 
-        var operation = new TestRowIntervalOperation<Vector4>(RowAction);
+        TestRowIntervalOperation<Vector4> operation = new(RowAction);
 
         ParallelRowIterator.IterateRowIntervals<TestRowIntervalOperation<Vector4>, Vector4>(
             rectangle,
@@ -201,7 +201,7 @@ public class ParallelRowIteratorTests
     }
 
     public static TheoryData<int, int, int, int, int, int, int> IterateRows_WithEffectiveMinimumPixelsLimit_Data =
-        new TheoryData<int, int, int, int, int, int, int>
+        new()
         {
             { 2, 200, 50, 2, 1, -1, 2 },
             { 2, 200, 200, 1, 1, -1, 1 },
@@ -223,12 +223,12 @@ public class ParallelRowIteratorTests
         int expectedStepLength,
         int expectedLastStepLength)
     {
-        var parallelSettings = new ParallelExecutionSettings(
+        ParallelExecutionSettings parallelSettings = new(
             maxDegreeOfParallelism,
             minimumPixelsProcessedPerTask,
             Configuration.Default.MemoryAllocator);
 
-        var rectangle = new Rectangle(0, 0, width, height);
+        Rectangle rectangle = new(0, 0, width, height);
 
         int actualNumberOfSteps = 0;
 
@@ -244,7 +244,7 @@ public class ParallelRowIteratorTests
             Assert.Equal(expected, step);
         }
 
-        var operation = new TestRowIntervalOperation(RowAction);
+        TestRowIntervalOperation operation = new(RowAction);
 
         ParallelRowIterator.IterateRowIntervals(
             rectangle,
@@ -265,12 +265,12 @@ public class ParallelRowIteratorTests
         int expectedStepLength,
         int expectedLastStepLength)
     {
-        var parallelSettings = new ParallelExecutionSettings(
+        ParallelExecutionSettings parallelSettings = new(
             maxDegreeOfParallelism,
             minimumPixelsProcessedPerTask,
             Configuration.Default.MemoryAllocator);
 
-        var rectangle = new Rectangle(0, 0, width, height);
+        Rectangle rectangle = new(0, 0, width, height);
 
         int actualNumberOfSteps = 0;
 
@@ -286,7 +286,7 @@ public class ParallelRowIteratorTests
             Assert.Equal(expected, step);
         }
 
-        var operation = new TestRowIntervalOperation<Vector4>(RowAction);
+        TestRowIntervalOperation<Vector4> operation = new(RowAction);
 
         ParallelRowIterator.IterateRowIntervals<TestRowIntervalOperation<Vector4>, Vector4>(
             rectangle,
@@ -297,7 +297,7 @@ public class ParallelRowIteratorTests
     }
 
     public static readonly TheoryData<int, int, int, int, int, int, int> IterateRectangularBuffer_Data =
-        new TheoryData<int, int, int, int, int, int, int>
+        new()
         {
             { 8, 582, 453, 10, 10, 291, 226 }, // boundary data from DetectEdgesTest.DetectEdges_InBox
             { 2, 582, 453, 10, 10, 291, 226 },
@@ -322,7 +322,7 @@ public class ParallelRowIteratorTests
         using (Buffer2D<Point> expected = memoryAllocator.Allocate2D<Point>(bufferWidth, bufferHeight, AllocationOptions.Clean))
         using (Buffer2D<Point> actual = memoryAllocator.Allocate2D<Point>(bufferWidth, bufferHeight, AllocationOptions.Clean))
         {
-            var rect = new Rectangle(rectX, rectY, rectWidth, rectHeight);
+            Rectangle rect = new(rectX, rectY, rectWidth, rectHeight);
 
             void FillRow(int y, Buffer2D<Point> buffer)
             {
@@ -339,7 +339,7 @@ public class ParallelRowIteratorTests
             }
 
             // Fill actual data using IterateRows:
-            var settings = new ParallelExecutionSettings(maxDegreeOfParallelism, memoryAllocator);
+            ParallelExecutionSettings settings = new(maxDegreeOfParallelism, memoryAllocator);
 
             void RowAction(RowInterval rows)
             {
@@ -350,7 +350,7 @@ public class ParallelRowIteratorTests
                 }
             }
 
-            var operation = new TestRowIntervalOperation(RowAction);
+            TestRowIntervalOperation operation = new(RowAction);
 
             ParallelRowIterator.IterateRowIntervals(
                 rect,
@@ -369,15 +369,15 @@ public class ParallelRowIteratorTests
     [InlineData(10, -10)]
     public void IterateRowsRequiresValidRectangle(int width, int height)
     {
-        var parallelSettings = default(ParallelExecutionSettings);
+        ParallelExecutionSettings parallelSettings = default(ParallelExecutionSettings);
 
-        var rect = new Rectangle(0, 0, width, height);
+        Rectangle rect = new(0, 0, width, height);
 
         void RowAction(RowInterval rows)
         {
         }
 
-        var operation = new TestRowIntervalOperation(RowAction);
+        TestRowIntervalOperation operation = new(RowAction);
 
         ArgumentOutOfRangeException ex = Assert.Throws<ArgumentOutOfRangeException>(
             () => ParallelRowIterator.IterateRowIntervals(rect, in parallelSettings, in operation));
@@ -392,15 +392,15 @@ public class ParallelRowIteratorTests
     [InlineData(10, -10)]
     public void IterateRowsWithTempBufferRequiresValidRectangle(int width, int height)
     {
-        var parallelSettings = default(ParallelExecutionSettings);
+        ParallelExecutionSettings parallelSettings = default(ParallelExecutionSettings);
 
-        var rect = new Rectangle(0, 0, width, height);
+        Rectangle rect = new(0, 0, width, height);
 
         void RowAction(RowInterval rows, Span<Rgba32> memory)
         {
         }
 
-        var operation = new TestRowIntervalOperation<Rgba32>(RowAction);
+        TestRowIntervalOperation<Rgba32> operation = new(RowAction);
 
         ArgumentOutOfRangeException ex = Assert.Throws<ArgumentOutOfRangeException>(
             () => ParallelRowIterator.IterateRowIntervals<TestRowIntervalOperation<Rgba32>, Rgba32>(rect, in parallelSettings, in operation));
@@ -434,7 +434,7 @@ public class ParallelRowIteratorTests
         {
         }
 
-        public StrongBox<int> MaxY { get; } = new StrongBox<int>();
+        public StrongBox<int> MaxY { get; } = new();
 
         public void Invoke(int y)
         {
diff --git a/tests/ImageSharp.Tests/Helpers/RowIntervalTests.cs b/tests/ImageSharp.Tests/Helpers/RowIntervalTests.cs
index 95f1d4e289..215cd58bcf 100644
--- a/tests/ImageSharp.Tests/Helpers/RowIntervalTests.cs
+++ b/tests/ImageSharp.Tests/Helpers/RowIntervalTests.cs
@@ -10,7 +10,7 @@ public class RowIntervalTests
     [Fact]
     public void Slice1()
     {
-        var rowInterval = new RowInterval(10, 20);
+        RowInterval rowInterval = new(10, 20);
         RowInterval sliced = rowInterval.Slice(5);
 
         Assert.Equal(15, sliced.Min);
@@ -20,7 +20,7 @@ public class RowIntervalTests
     [Fact]
     public void Slice2()
     {
-        var rowInterval = new RowInterval(10, 20);
+        RowInterval rowInterval = new(10, 20);
         RowInterval sliced = rowInterval.Slice(3, 5);
 
         Assert.Equal(13, sliced.Min);
@@ -30,8 +30,8 @@ public class RowIntervalTests
     [Fact]
     public void Equality_WhenTrue()
     {
-        var a = new RowInterval(42, 123);
-        var b = new RowInterval(42, 123);
+        RowInterval a = new(42, 123);
+        RowInterval b = new(42, 123);
 
         Assert.True(a.Equals(b));
         Assert.True(a.Equals((object)b));
@@ -42,9 +42,9 @@ public class RowIntervalTests
     [Fact]
     public void Equality_WhenFalse()
     {
-        var a = new RowInterval(42, 123);
-        var b = new RowInterval(42, 125);
-        var c = new RowInterval(40, 123);
+        RowInterval a = new(42, 123);
+        RowInterval b = new(42, 125);
+        RowInterval c = new(40, 123);
 
         Assert.False(a.Equals(b));
         Assert.False(c.Equals(a));
diff --git a/tests/ImageSharp.Tests/Helpers/TolerantMathTests.cs b/tests/ImageSharp.Tests/Helpers/TolerantMathTests.cs
index 64f79840ca..0cacbdc87a 100644
--- a/tests/ImageSharp.Tests/Helpers/TolerantMathTests.cs
+++ b/tests/ImageSharp.Tests/Helpers/TolerantMathTests.cs
@@ -7,7 +7,7 @@ namespace SixLabors.ImageSharp.Tests.Helpers;
 
 public class TolerantMathTests
 {
-    private readonly TolerantMath tolerantMath = new TolerantMath(0.1);
+    private readonly TolerantMath tolerantMath = new(0.1);
 
     [Theory]
     [InlineData(0)]
diff --git a/tests/ImageSharp.Tests/IO/ChunkedMemoryStreamTests.cs b/tests/ImageSharp.Tests/IO/ChunkedMemoryStreamTests.cs
index 390170cfef..89256507ed 100644
--- a/tests/ImageSharp.Tests/IO/ChunkedMemoryStreamTests.cs
+++ b/tests/ImageSharp.Tests/IO/ChunkedMemoryStreamTests.cs
@@ -47,14 +47,14 @@ public class ChunkedMemoryStreamTests
         ChunkedMemoryStream ms2 = new(this.allocator);
 
         Assert.Throws<ArgumentNullException>(() => ms2.Read(null, 0, 0));
-        Assert.Throws<ArgumentOutOfRangeException>(() => ms2.Read(new byte[] { 1 }, -1, 0));
-        Assert.Throws<ArgumentOutOfRangeException>(() => ms2.Read(new byte[] { 1 }, 0, -1));
-        Assert.Throws<ArgumentException>(() => ms2.Read(new byte[] { 1 }, 2, 0));
-        Assert.Throws<ArgumentException>(() => ms2.Read(new byte[] { 1 }, 0, 2));
+        Assert.Throws<ArgumentOutOfRangeException>(() => ms2.Read([1], -1, 0));
+        Assert.Throws<ArgumentOutOfRangeException>(() => ms2.Read([1], 0, -1));
+        Assert.Throws<ArgumentException>(() => ms2.Read([1], 2, 0));
+        Assert.Throws<ArgumentException>(() => ms2.Read([1], 0, 2));
 
         ms2.Dispose();
 
-        Assert.Throws<ObjectDisposedException>(() => ms2.Read(new byte[] { 1 }, 0, 1));
+        Assert.Throws<ObjectDisposedException>(() => ms2.Read([1], 0, 1));
     }
 
     [Theory]
@@ -229,7 +229,7 @@ public class ChunkedMemoryStreamTests
     {
         using ChunkedMemoryStream ms2 = new(this.allocator);
         byte[] bytArrRet;
-        byte[] bytArr = new byte[] { byte.MinValue, byte.MaxValue, 1, 2, 3, 4, 5, 6, 128, 250 };
+        byte[] bytArr = [byte.MinValue, byte.MaxValue, 1, 2, 3, 4, 5, 6, 128, 250];
 
         for (int i = 0; i < bytArr.Length; i++)
         {
@@ -254,7 +254,7 @@ public class ChunkedMemoryStreamTests
         using ChunkedMemoryStream ms2 = new(this.allocator);
         Assert.Throws<ArgumentNullException>(() => ms2.WriteTo(null));
 
-        ms2.Write(new byte[] { 1 }, 0, 1);
+        ms2.Write([1], 0, 1);
         MemoryStream readonlyStream = new(new byte[1028], false);
         Assert.Throws<NotSupportedException>(() => ms2.WriteTo(readonlyStream));
 
@@ -313,7 +313,7 @@ public class ChunkedMemoryStreamTests
         IEnumerable<string> allImageFiles = Directory.EnumerateFiles(TestEnvironment.InputImagesDirectoryFullPath, "*.*", SearchOption.AllDirectories)
             .Where(s => !s.EndsWith("txt", StringComparison.OrdinalIgnoreCase));
 
-        List<string> result = new();
+        List<string> result = [];
         foreach (string path in allImageFiles)
         {
             result.Add(path[TestEnvironment.InputImagesDirectoryFullPath.Length..]);
@@ -396,22 +396,22 @@ public class ChunkedMemoryStreamTests
     public static IEnumerable<object[]> CopyToData()
     {
         // Stream is positioned @ beginning of data
-        byte[] data1 = new byte[] { 1, 2, 3 };
+        byte[] data1 = [1, 2, 3];
         MemoryStream stream1 = new(data1);
 
-        yield return new object[] { stream1, data1 };
+        yield return [stream1, data1];
 
         // Stream is positioned in the middle of data
-        byte[] data2 = new byte[] { 0xff, 0xf3, 0xf0 };
+        byte[] data2 = [0xff, 0xf3, 0xf0];
         MemoryStream stream2 = new(data2) { Position = 1 };
 
-        yield return new object[] { stream2, new byte[] { 0xf3, 0xf0 } };
+        yield return [stream2, new byte[] { 0xf3, 0xf0 }];
 
         // Stream is positioned after end of data
         byte[] data3 = data2;
         MemoryStream stream3 = new(data3) { Position = data3.Length + 1 };
 
-        yield return new object[] { stream3, Array.Empty<byte>() };
+        yield return [stream3, Array.Empty<byte>()];
     }
 
     private byte[] CreateTestBuffer(int length)
diff --git a/tests/ImageSharp.Tests/Image/ImageCloneTests.cs b/tests/ImageSharp.Tests/Image/ImageCloneTests.cs
index 25674e6a8d..0680c9a823 100644
--- a/tests/ImageSharp.Tests/Image/ImageCloneTests.cs
+++ b/tests/ImageSharp.Tests/Image/ImageCloneTests.cs
@@ -10,7 +10,7 @@ public class ImageCloneTests
     [Fact]
     public void CloneAs_WhenDisposed_Throws()
     {
-        var image = new Image<Rgba32>(5, 5);
+        Image<Rgba32> image = new(5, 5);
         image.Dispose();
 
         Assert.Throws<ObjectDisposedException>(() => image.CloneAs<Bgra32>());
@@ -19,7 +19,7 @@ public class ImageCloneTests
     [Fact]
     public void Clone_WhenDisposed_Throws()
     {
-        var image = new Image<Rgba32>(5, 5);
+        Image<Rgba32> image = new(5, 5);
         image.Dispose();
 
         Assert.Throws<ObjectDisposedException>(() => image.Clone());
diff --git a/tests/ImageSharp.Tests/Image/ImageFrameCollectionTests.Generic.cs b/tests/ImageSharp.Tests/Image/ImageFrameCollectionTests.Generic.cs
index 71c9e07fc3..d7f2c7d28e 100644
--- a/tests/ImageSharp.Tests/Image/ImageFrameCollectionTests.Generic.cs
+++ b/tests/ImageSharp.Tests/Image/ImageFrameCollectionTests.Generic.cs
@@ -102,7 +102,7 @@ public abstract partial class ImageFrameCollectionTests
                     using ImageFrame<Rgba32> imageFrame2 = new(Configuration.Default, 1, 1);
                     new ImageFrameCollection<Rgba32>(
                         this.Image,
-                        new[] { imageFrame1, imageFrame2 });
+                        [imageFrame1, imageFrame2]);
                 });
 
             Assert.StartsWith("Frame must have the same dimensions as the image.", ex.Message);
@@ -114,7 +114,7 @@ public abstract partial class ImageFrameCollectionTests
             using ImageFrame<Rgba32> imageFrame = new(Configuration.Default, 10, 10);
             ImageFrameCollection<Rgba32> collection = new(
                 this.Image,
-                new[] { imageFrame });
+                [imageFrame]);
 
             InvalidOperationException ex = Assert.Throws<InvalidOperationException>(
                 () => collection.RemoveFrame(0));
@@ -128,7 +128,7 @@ public abstract partial class ImageFrameCollectionTests
             using ImageFrame<Rgba32> imageFrame2 = new(Configuration.Default, 10, 10);
             ImageFrameCollection<Rgba32> collection = new(
                 this.Image,
-                new[] { imageFrame1, imageFrame2 });
+                [imageFrame1, imageFrame2]);
 
             collection.RemoveFrame(0);
             Assert.Equal(1, collection.Count);
@@ -141,7 +141,7 @@ public abstract partial class ImageFrameCollectionTests
             using ImageFrame<Rgba32> imageFrame2 = new(Configuration.Default, 10, 10);
             ImageFrameCollection<Rgba32> collection = new(
                 this.Image,
-                new[] { imageFrame1, imageFrame2 });
+                [imageFrame1, imageFrame2]);
 
             Assert.Equal(collection.RootFrame, collection[0]);
         }
@@ -153,7 +153,7 @@ public abstract partial class ImageFrameCollectionTests
             using ImageFrame<Rgba32> imageFrame2 = new(Configuration.Default, 10, 10);
             ImageFrameCollection<Rgba32> collection = new(
                 this.Image,
-                new[] { imageFrame1, imageFrame2 });
+                [imageFrame1, imageFrame2]);
 
             Assert.Equal(2, collection.Count);
         }
@@ -165,7 +165,7 @@ public abstract partial class ImageFrameCollectionTests
             using ImageFrame<Rgba32> imageFrame2 = new(Configuration.Default, 10, 10);
             ImageFrameCollection<Rgba32> collection = new(
                 this.Image,
-                new[] { imageFrame1, imageFrame2 });
+                [imageFrame1, imageFrame2]);
 
             collection.Dispose();
 
@@ -179,7 +179,7 @@ public abstract partial class ImageFrameCollectionTests
             using ImageFrame<Rgba32> imageFrame2 = new(Configuration.Default, 10, 10);
             ImageFrameCollection<Rgba32> collection = new(
                 this.Image,
-                new[] { imageFrame1, imageFrame2 });
+                [imageFrame1, imageFrame2]);
 
             IPixelSource<Rgba32>[] framesSnapShot = collection.OfType<IPixelSource<Rgba32>>().ToArray();
 
diff --git a/tests/ImageSharp.Tests/Image/ImageFrameCollectionTests.NonGeneric.cs b/tests/ImageSharp.Tests/Image/ImageFrameCollectionTests.NonGeneric.cs
index f70623f515..cd1213c230 100644
--- a/tests/ImageSharp.Tests/Image/ImageFrameCollectionTests.NonGeneric.cs
+++ b/tests/ImageSharp.Tests/Image/ImageFrameCollectionTests.NonGeneric.cs
@@ -247,7 +247,7 @@ public abstract partial class ImageFrameCollectionTests
         {
             Image<Rgba32> image = new(Configuration.Default, 10, 10);
             ImageFrameCollection<Rgba32> frameCollection = image.Frames;
-            Rgba32[] rgba32Array = Array.Empty<Rgba32>();
+            Rgba32[] rgba32Array = [];
 
             image.Dispose(); // this should invalidate underlying collection as well
 
diff --git a/tests/ImageSharp.Tests/Image/ImageFrameCollectionTests.cs b/tests/ImageSharp.Tests/Image/ImageFrameCollectionTests.cs
index 14c38d1f70..887a67dd30 100644
--- a/tests/ImageSharp.Tests/Image/ImageFrameCollectionTests.cs
+++ b/tests/ImageSharp.Tests/Image/ImageFrameCollectionTests.cs
@@ -1,6 +1,7 @@
 // Copyright (c) Six Labors.
 // Licensed under the Six Labors Split License.
 
+using System.Globalization;
 using SixLabors.ImageSharp.PixelFormats;
 
 namespace SixLabors.ImageSharp.Tests;
@@ -14,7 +15,7 @@ public abstract partial class ImageFrameCollectionTests : IDisposable
     public ImageFrameCollectionTests()
     {
         // Needed to get English exception messages, which are checked in several tests.
-        System.Threading.Thread.CurrentThread.CurrentUICulture = new System.Globalization.CultureInfo("en-US");
+        System.Threading.Thread.CurrentThread.CurrentUICulture = new CultureInfo("en-US");
 
         this.Image = new Image<Rgba32>(10, 10);
         this.Collection = new ImageFrameCollection<Rgba32>(this.Image, 10, 10, default(Rgba32));
diff --git a/tests/ImageSharp.Tests/Image/ImageFrameTests.cs b/tests/ImageSharp.Tests/Image/ImageFrameTests.cs
index ef5b5f4def..f8146363c7 100644
--- a/tests/ImageSharp.Tests/Image/ImageFrameTests.cs
+++ b/tests/ImageSharp.Tests/Image/ImageFrameTests.cs
@@ -16,7 +16,7 @@ public class ImageFrameTests
 
         private void LimitBufferCapacity(int bufferCapacityInBytes)
         {
-            var allocator = new TestMemoryAllocator();
+            TestMemoryAllocator allocator = new();
             allocator.BufferCapacityInBytes = bufferCapacityInBytes;
             this.configuration.MemoryAllocator = allocator;
         }
@@ -31,7 +31,7 @@ public class ImageFrameTests
                 this.LimitBufferCapacity(100);
             }
 
-            using var image = new Image<Rgba32>(this.configuration, 10, 10);
+            using Image<Rgba32> image = new(this.configuration, 10, 10);
             ImageFrame<Rgba32> frame = image.Frames.RootFrame;
             Rgba32 val = frame[3, 4];
             Assert.Equal(default(Rgba32), val);
@@ -40,7 +40,7 @@ public class ImageFrameTests
             Assert.Equal(Color.Red.ToPixel<Rgba32>(), val);
         }
 
-        public static TheoryData<bool, int> OutOfRangeData = new TheoryData<bool, int>()
+        public static TheoryData<bool, int> OutOfRangeData = new()
         {
             { false, -1 },
             { false, 10 },
@@ -57,7 +57,7 @@ public class ImageFrameTests
                 this.LimitBufferCapacity(100);
             }
 
-            using var image = new Image<Rgba32>(this.configuration, 10, 10);
+            using Image<Rgba32> image = new(this.configuration, 10, 10);
             ImageFrame<Rgba32> frame = image.Frames.RootFrame;
             ArgumentOutOfRangeException ex = Assert.Throws<ArgumentOutOfRangeException>(() => _ = frame[x, 3]);
             Assert.Equal("x", ex.ParamName);
@@ -72,7 +72,7 @@ public class ImageFrameTests
                 this.LimitBufferCapacity(100);
             }
 
-            using var image = new Image<Rgba32>(this.configuration, 10, 10);
+            using Image<Rgba32> image = new(this.configuration, 10, 10);
             ImageFrame<Rgba32> frame = image.Frames.RootFrame;
             ArgumentOutOfRangeException ex = Assert.Throws<ArgumentOutOfRangeException>(() => frame[x, 3] = default);
             Assert.Equal("x", ex.ParamName);
@@ -87,7 +87,7 @@ public class ImageFrameTests
                 this.LimitBufferCapacity(100);
             }
 
-            using var image = new Image<Rgba32>(this.configuration, 10, 10);
+            using Image<Rgba32> image = new(this.configuration, 10, 10);
             ImageFrame<Rgba32> frame = image.Frames.RootFrame;
             ArgumentOutOfRangeException ex = Assert.Throws<ArgumentOutOfRangeException>(() => frame[3, y] = default);
             Assert.Equal("y", ex.ParamName);
@@ -105,7 +105,7 @@ public class ImageFrameTests
                 this.LimitBufferCapacity(20);
             }
 
-            using var image = new Image<La16>(this.configuration, 10, 10);
+            using Image<La16> image = new(this.configuration, 10, 10);
             if (disco)
             {
                 Assert.True(image.GetPixelMemoryGroup().Count > 1);
@@ -131,7 +131,7 @@ public class ImageFrameTests
         [InlineData(true)]
         public void CopyPixelDataTo_DestinationTooShort_Throws(bool byteSpan)
         {
-            using var image = new Image<La16>(this.configuration, 10, 10);
+            using Image<La16> image = new(this.configuration, 10, 10);
 
             Assert.ThrowsAny<ArgumentOutOfRangeException>(() =>
             {
@@ -173,7 +173,7 @@ public class ImageFrameTests
         [Fact]
         public void NullReference_Throws()
         {
-            using var img = new Image<Rgb24>(1, 1);
+            using Image<Rgb24> img = new(1, 1);
             ImageFrame<Rgb24> frame = img.Frames.RootFrame;
 
             Assert.Throws<ArgumentNullException>(() => frame.ProcessPixelRows(null));
diff --git a/tests/ImageSharp.Tests/Image/ImageSaveTests.cs b/tests/ImageSharp.Tests/Image/ImageSaveTests.cs
index f9c01ab564..e2f3c6337b 100644
--- a/tests/ImageSharp.Tests/Image/ImageSaveTests.cs
+++ b/tests/ImageSharp.Tests/Image/ImageSaveTests.cs
@@ -32,7 +32,7 @@ public class ImageSaveTests : IDisposable
         this.encoderNotInFormat = new Mock<IImageEncoder>();
 
         this.fileSystem = new Mock<IFileSystem>();
-        var config = new Configuration
+        Configuration config = new()
         {
             FileSystem = this.fileSystem.Object
         };
diff --git a/tests/ImageSharp.Tests/Image/ImageTests.DetectFormat.cs b/tests/ImageSharp.Tests/Image/ImageTests.DetectFormat.cs
index f9a68c8bf6..a1966e2bb0 100644
--- a/tests/ImageSharp.Tests/Image/ImageTests.DetectFormat.cs
+++ b/tests/ImageSharp.Tests/Image/ImageTests.DetectFormat.cs
@@ -114,7 +114,7 @@ public partial class ImageTests
         {
             DecoderOptions options = new()
             {
-                Configuration = new()
+                Configuration = new Configuration()
             };
 
             Assert.Throws<UnknownImageFormatException>(() => Image.DetectFormat(options, this.DataStream));
@@ -145,7 +145,7 @@ public partial class ImageTests
         {
             DecoderOptions options = new()
             {
-                Configuration = new()
+                Configuration = new Configuration()
             };
 
             return Assert.ThrowsAsync<UnknownImageFormatException>(async () => await Image.DetectFormatAsync(options, new AsyncStreamWrapper(this.DataStream, () => false)));
diff --git a/tests/ImageSharp.Tests/Image/ImageTests.Identify.cs b/tests/ImageSharp.Tests/Image/ImageTests.Identify.cs
index 7f6651d909..490fa3b0b0 100644
--- a/tests/ImageSharp.Tests/Image/ImageTests.Identify.cs
+++ b/tests/ImageSharp.Tests/Image/ImageTests.Identify.cs
@@ -131,7 +131,7 @@ public partial class ImageTests
         [Fact]
         public void WhenNoMatchingFormatFound_Throws_UnknownImageFormatException()
         {
-            DecoderOptions options = new() { Configuration = new() };
+            DecoderOptions options = new() { Configuration = new Configuration() };
 
             Assert.Throws<UnknownImageFormatException>(() => Image.Identify(options, this.DataStream));
         }
@@ -141,9 +141,8 @@ public partial class ImageTests
         {
             // https://github.com/SixLabors/ImageSharp/issues/1903
             using ZipArchive zipFile = new(new MemoryStream(
-                new byte[]
-                {
-                    0x50, 0x4B, 0x03, 0x04, 0x0A, 0x00, 0x00, 0x00, 0x00, 0x00, 0x77, 0xAF, 0x94, 0x53, 0x00, 0x00,
+            [
+                0x50, 0x4B, 0x03, 0x04, 0x0A, 0x00, 0x00, 0x00, 0x00, 0x00, 0x77, 0xAF, 0x94, 0x53, 0x00, 0x00,
                     0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x07, 0x00, 0x00, 0x00, 0x6D, 0x79,
                     0x73, 0x74, 0x65, 0x72, 0x79, 0x50, 0x4B, 0x01, 0x02, 0x3F, 0x00, 0x0A, 0x00, 0x00, 0x00, 0x00,
                     0x00, 0x77, 0xAF, 0x94, 0x53, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
@@ -153,7 +152,7 @@ public partial class ImageTests
                     0xF9, 0x91, 0x27, 0xF6, 0xD7, 0x01, 0x55, 0xA1, 0xF9, 0x91, 0x27, 0xF6, 0xD7, 0x01, 0x50, 0x4B,
                     0x05, 0x06, 0x00, 0x00, 0x00, 0x00, 0x01, 0x00, 0x01, 0x00, 0x59, 0x00, 0x00, 0x00, 0x25, 0x00,
                     0x00, 0x00, 0x00, 0x00
-                }));
+            ]));
             using Stream stream = zipFile.Entries[0].Open();
 
             Assert.Throws<UnknownImageFormatException>(() => Image.Identify(stream));
@@ -210,9 +209,8 @@ public partial class ImageTests
         {
             // https://github.com/SixLabors/ImageSharp/issues/1903
             using ZipArchive zipFile = new(new MemoryStream(
-                new byte[]
-                {
-                    0x50, 0x4B, 0x03, 0x04, 0x0A, 0x00, 0x00, 0x00, 0x00, 0x00, 0x77, 0xAF, 0x94, 0x53, 0x00, 0x00,
+            [
+                0x50, 0x4B, 0x03, 0x04, 0x0A, 0x00, 0x00, 0x00, 0x00, 0x00, 0x77, 0xAF, 0x94, 0x53, 0x00, 0x00,
                     0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x07, 0x00, 0x00, 0x00, 0x6D, 0x79,
                     0x73, 0x74, 0x65, 0x72, 0x79, 0x50, 0x4B, 0x01, 0x02, 0x3F, 0x00, 0x0A, 0x00, 0x00, 0x00, 0x00,
                     0x00, 0x77, 0xAF, 0x94, 0x53, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
@@ -222,7 +220,7 @@ public partial class ImageTests
                     0xF9, 0x91, 0x27, 0xF6, 0xD7, 0x01, 0x55, 0xA1, 0xF9, 0x91, 0x27, 0xF6, 0xD7, 0x01, 0x50, 0x4B,
                     0x05, 0x06, 0x00, 0x00, 0x00, 0x00, 0x01, 0x00, 0x01, 0x00, 0x59, 0x00, 0x00, 0x00, 0x25, 0x00,
                     0x00, 0x00, 0x00, 0x00
-                }));
+            ]));
             using Stream stream = zipFile.Entries[0].Open();
 
             await Assert.ThrowsAsync<UnknownImageFormatException>(async () => await Image.IdentifyAsync(stream));
@@ -279,7 +277,7 @@ public partial class ImageTests
         [Fact]
         public Task WhenNoMatchingFormatFoundAsync_Throws_UnknownImageFormatException()
         {
-            DecoderOptions options = new() { Configuration = new() };
+            DecoderOptions options = new() { Configuration = new Configuration() };
 
             AsyncStreamWrapper asyncStream = new(this.DataStream, () => false);
             return Assert.ThrowsAsync<UnknownImageFormatException>(async () => await Image.IdentifyAsync(options, asyncStream));
diff --git a/tests/ImageSharp.Tests/Image/ImageTests.ImageLoadTestBase.cs b/tests/ImageSharp.Tests/Image/ImageTests.ImageLoadTestBase.cs
index 51e2a01a28..b0875a1e63 100644
--- a/tests/ImageSharp.Tests/Image/ImageTests.ImageLoadTestBase.cs
+++ b/tests/ImageSharp.Tests/Image/ImageTests.ImageLoadTestBase.cs
@@ -35,7 +35,7 @@ public partial class ImageTests
 
         public Configuration LocalConfiguration { get; }
 
-        public TestFormat TestFormat { get; } = new TestFormat();
+        public TestFormat TestFormat { get; } = new();
 
         /// <summary>
         /// Gets the top-level configuration in the context of this test case.
@@ -58,7 +58,7 @@ public partial class ImageTests
             // TODO: Remove all this mocking. It's too complicated and we can now use fakes.
             this.localStreamReturnImageRgba32 = new Image<Rgba32>(1, 1);
             this.localStreamReturnImageAgnostic = new Image<Bgra4444>(1, 1);
-            this.LocalImageInfo = new(new(1, 1), new ImageMetadata() { DecodedImageFormat = PngFormat.Instance });
+            this.LocalImageInfo = new ImageInfo(new Size(1, 1), new ImageMetadata { DecodedImageFormat = PngFormat.Instance });
 
             this.localImageFormatMock = new Mock<IImageFormat>();
 
diff --git a/tests/ImageSharp.Tests/Image/ImageTests.LoadPixelData.cs b/tests/ImageSharp.Tests/Image/ImageTests.LoadPixelData.cs
index 5762264d21..47ae0daf72 100644
--- a/tests/ImageSharp.Tests/Image/ImageTests.LoadPixelData.cs
+++ b/tests/ImageSharp.Tests/Image/ImageTests.LoadPixelData.cs
@@ -15,7 +15,8 @@ public partial class ImageTests
         [ValidateDisposedMemoryAllocations]
         public void FromPixels(bool useSpan)
         {
-            Rgba32[] data = { Color.Black.ToPixel<Rgba32>(), Color.White.ToPixel<Rgba32>(), Color.White.ToPixel<Rgba32>(), Color.Black.ToPixel<Rgba32>(), };
+            Rgba32[] data = [Color.Black.ToPixel<Rgba32>(), Color.White.ToPixel<Rgba32>(), Color.White.ToPixel<Rgba32>(), Color.Black.ToPixel<Rgba32>()
+            ];
 
             using Image<Rgba32> img = useSpan
                 ? Image.LoadPixelData<Rgba32>(data.AsSpan(), 2, 2)
@@ -34,12 +35,12 @@ public partial class ImageTests
         public void FromBytes(bool useSpan)
         {
             byte[] data =
-            {
+            [
                 0, 0, 0, 255, // 0,0
                 255, 255, 255, 255, // 0,1
                 255, 255, 255, 255, // 1,0
-                0, 0, 0, 255, // 1,1
-            };
+                0, 0, 0, 255 // 1,1
+            ];
 
             using Image<Rgba32> img = useSpan
                 ? Image.LoadPixelData<Rgba32>(data.AsSpan(), 2, 2)
diff --git a/tests/ImageSharp.Tests/Image/ImageTests.Load_FromStream_ThrowsRightException.cs b/tests/ImageSharp.Tests/Image/ImageTests.Load_FromStream_ThrowsRightException.cs
index 9b9f968bb4..a064b64723 100644
--- a/tests/ImageSharp.Tests/Image/ImageTests.Load_FromStream_ThrowsRightException.cs
+++ b/tests/ImageSharp.Tests/Image/ImageTests.Load_FromStream_ThrowsRightException.cs
@@ -10,9 +10,9 @@ public partial class ImageTests
 {
     public class Load_FromStream_Throws : IDisposable
     {
-        private static readonly byte[] Data = new byte[] { 0x01 };
+        private static readonly byte[] Data = [0x01];
 
-        private MemoryStream Stream { get; } = new MemoryStream(Data);
+        private MemoryStream Stream { get; } = new(Data);
 
         [Fact]
         public void Image_Load_Throws_UnknownImageFormatException()
diff --git a/tests/ImageSharp.Tests/Image/ImageTests.WrapMemory.cs b/tests/ImageSharp.Tests/Image/ImageTests.WrapMemory.cs
index e3c4a7df18..6322e65aaa 100644
--- a/tests/ImageSharp.Tests/Image/ImageTests.WrapMemory.cs
+++ b/tests/ImageSharp.Tests/Image/ImageTests.WrapMemory.cs
@@ -39,7 +39,7 @@ public partial class ImageTests
                 }
 
                 this.bitmap = bitmap;
-                var rectangle = new System.Drawing.Rectangle(0, 0, bitmap.Width, bitmap.Height);
+                System.Drawing.Rectangle rectangle = new(0, 0, bitmap.Width, bitmap.Height);
                 this.bmpData = bitmap.LockBits(rectangle, ImageLockMode.ReadWrite, bitmap.PixelFormat);
                 this.length = bitmap.Width * bitmap.Height;
             }
@@ -124,13 +124,13 @@ public partial class ImageTests
         [Fact]
         public void WrapMemory_CreatedImageIsCorrect()
         {
-            var cfg = Configuration.CreateDefaultInstance();
-            var metaData = new ImageMetadata();
+            Configuration cfg = Configuration.CreateDefaultInstance();
+            ImageMetadata metaData = new();
 
-            var array = new Rgba32[25];
-            var memory = new Memory<Rgba32>(array);
+            Rgba32[] array = new Rgba32[25];
+            Memory<Rgba32> memory = new(array);
 
-            using (var image = Image.WrapMemory(cfg, memory, 5, 5, metaData))
+            using (Image<Rgba32> image = Image.WrapMemory(cfg, memory, 5, 5, metaData))
             {
                 Assert.True(image.DangerousTryGetSinglePixelMemory(out Memory<Rgba32> imageMem));
                 ref Rgba32 pixel0 = ref imageMem.Span[0];
@@ -149,22 +149,22 @@ public partial class ImageTests
                 return;
             }
 
-            using (var bmp = new Bitmap(51, 23))
+            using (Bitmap bmp = new(51, 23))
             {
-                using (var memoryManager = new BitmapMemoryManager(bmp))
+                using (BitmapMemoryManager memoryManager = new(bmp))
                 {
                     Memory<Bgra32> memory = memoryManager.Memory;
                     Bgra32 bg = Color.Red.ToPixel<Bgra32>();
                     Bgra32 fg = Color.Green.ToPixel<Bgra32>();
 
-                    using (var image = Image.WrapMemory(memory, bmp.Width, bmp.Height))
+                    using (Image<Bgra32> image = Image.WrapMemory(memory, bmp.Width, bmp.Height))
                     {
                         Assert.Equal(memory, image.GetRootFramePixelBuffer().DangerousGetSingleMemory());
                         image.GetPixelMemoryGroup().Fill(bg);
 
                         image.ProcessPixelRows(accessor =>
                         {
-                            for (var i = 10; i < 20; i++)
+                            for (int i = 10; i < 20; i++)
                             {
                                 accessor.GetRowSpan(i).Slice(10, 10).Fill(fg);
                             }
@@ -195,19 +195,19 @@ public partial class ImageTests
                 return;
             }
 
-            using (var bmp = new Bitmap(51, 23))
+            using (Bitmap bmp = new(51, 23))
             {
-                var memoryManager = new BitmapMemoryManager(bmp);
+                BitmapMemoryManager memoryManager = new(bmp);
                 Bgra32 bg = Color.Red.ToPixel<Bgra32>();
                 Bgra32 fg = Color.Green.ToPixel<Bgra32>();
 
-                using (var image = Image.WrapMemory(memoryManager, bmp.Width, bmp.Height))
+                using (Image<Bgra32> image = Image.WrapMemory(memoryManager, bmp.Width, bmp.Height))
                 {
                     Assert.Equal(memoryManager.Memory, image.GetRootFramePixelBuffer().DangerousGetSingleMemory());
                     image.GetPixelMemoryGroup().Fill(bg);
                     image.ProcessPixelRows(accessor =>
                     {
-                        for (var i = 10; i < 20; i++)
+                        for (int i = 10; i < 20; i++)
                         {
                             accessor.GetRowSpan(i).Slice(10, 10).Fill(fg);
                         }
@@ -227,13 +227,13 @@ public partial class ImageTests
         [Fact]
         public void WrapMemory_FromBytes_CreatedImageIsCorrect()
         {
-            var cfg = Configuration.CreateDefaultInstance();
-            var metaData = new ImageMetadata();
+            Configuration cfg = Configuration.CreateDefaultInstance();
+            ImageMetadata metaData = new();
 
-            var array = new byte[25 * Unsafe.SizeOf<Rgba32>()];
-            var memory = new Memory<byte>(array);
+            byte[] array = new byte[25 * Unsafe.SizeOf<Rgba32>()];
+            Memory<byte> memory = new(array);
 
-            using (var image = Image.WrapMemory<Rgba32>(cfg, memory, 5, 5, metaData))
+            using (Image<Rgba32> image = Image.WrapMemory<Rgba32>(cfg, memory, 5, 5, metaData))
             {
                 Assert.True(image.DangerousTryGetSinglePixelMemory(out Memory<Rgba32> imageMem));
                 ref Rgba32 pixel0 = ref imageMem.Span[0];
@@ -252,16 +252,16 @@ public partial class ImageTests
                 return;
             }
 
-            using (var bmp = new Bitmap(51, 23))
+            using (Bitmap bmp = new(51, 23))
             {
-                using (var memoryManager = new BitmapMemoryManager(bmp))
+                using (BitmapMemoryManager memoryManager = new(bmp))
                 {
                     Memory<Bgra32> pixelMemory = memoryManager.Memory;
                     Memory<byte> byteMemory = new CastMemoryManager<Bgra32, byte>(pixelMemory).Memory;
                     Bgra32 bg = Color.Red.ToPixel<Bgra32>();
                     Bgra32 fg = Color.Green.ToPixel<Bgra32>();
 
-                    using (var image = Image.WrapMemory<Bgra32>(byteMemory, bmp.Width, bmp.Height))
+                    using (Image<Bgra32> image = Image.WrapMemory<Bgra32>(byteMemory, bmp.Width, bmp.Height))
                     {
                         Span<Bgra32> pixelSpan = pixelMemory.Span;
                         Span<Bgra32> imageSpan = image.GetRootFramePixelBuffer().DangerousGetSingleMemory().Span;
@@ -276,7 +276,7 @@ public partial class ImageTests
                         image.GetPixelMemoryGroup().Fill(bg);
                         image.ProcessPixelRows(accessor =>
                         {
-                            for (var i = 10; i < 20; i++)
+                            for (int i = 10; i < 20; i++)
                             {
                                 accessor.GetRowSpan(i).Slice(10, 10).Fill(fg);
                             }
@@ -300,16 +300,16 @@ public partial class ImageTests
         [InlineData(65536, 65537, 65536)]
         public unsafe void WrapMemory_Throws_OnTooLessWrongSize(int size, int width, int height)
         {
-            var cfg = Configuration.CreateDefaultInstance();
-            var metaData = new ImageMetadata();
+            Configuration cfg = Configuration.CreateDefaultInstance();
+            ImageMetadata metaData = new();
 
-            var array = new Rgba32[size];
+            Rgba32[] array = new Rgba32[size];
             Exception thrownException = null;
             fixed (void* ptr = array)
             {
                 try
                 {
-                    using var image = Image.WrapMemory<Rgba32>(cfg, ptr, size * sizeof(Rgba32), width, height, metaData);
+                    using Image<Rgba32> image = Image.WrapMemory<Rgba32>(cfg, ptr, size * sizeof(Rgba32), width, height, metaData);
                 }
                 catch (Exception e)
                 {
@@ -328,14 +328,14 @@ public partial class ImageTests
         [InlineData(2048, 32, 32)]
         public unsafe void WrapMemory_FromPointer_CreatedImageIsCorrect(int size, int width, int height)
         {
-            var cfg = Configuration.CreateDefaultInstance();
-            var metaData = new ImageMetadata();
+            Configuration cfg = Configuration.CreateDefaultInstance();
+            ImageMetadata metaData = new();
 
-            var array = new Rgba32[size];
+            Rgba32[] array = new Rgba32[size];
 
             fixed (void* ptr = array)
             {
-                using (var image = Image.WrapMemory<Rgba32>(cfg, ptr, size * sizeof(Rgba32), width, height, metaData))
+                using (Image<Rgba32> image = Image.WrapMemory<Rgba32>(cfg, ptr, size * sizeof(Rgba32), width, height, metaData))
                 {
                     Assert.True(image.DangerousTryGetSinglePixelMemory(out Memory<Rgba32> imageMem));
                     Span<Rgba32> imageSpan = imageMem.Span;
@@ -359,9 +359,9 @@ public partial class ImageTests
                 return;
             }
 
-            using (var bmp = new Bitmap(51, 23))
+            using (Bitmap bmp = new(51, 23))
             {
-                using (var memoryManager = new BitmapMemoryManager(bmp))
+                using (BitmapMemoryManager memoryManager = new(bmp))
                 {
                     Memory<Bgra32> pixelMemory = memoryManager.Memory;
                     Bgra32 bg = Color.Red.ToPixel<Bgra32>();
@@ -369,7 +369,7 @@ public partial class ImageTests
 
                     fixed (void* p = pixelMemory.Span)
                     {
-                        using (var image = Image.WrapMemory<Bgra32>(p, pixelMemory.Length, bmp.Width, bmp.Height))
+                        using (Image<Bgra32> image = Image.WrapMemory<Bgra32>(p, pixelMemory.Length, bmp.Width, bmp.Height))
                         {
                             Span<Bgra32> pixelSpan = pixelMemory.Span;
                             Span<Bgra32> imageSpan = image.GetRootFramePixelBuffer().DangerousGetSingleMemory().Span;
@@ -381,7 +381,7 @@ public partial class ImageTests
                             image.GetPixelMemoryGroup().Fill(bg);
                             image.ProcessPixelRows(accessor =>
                             {
-                                for (var i = 10; i < 20; i++)
+                                for (int i = 10; i < 20; i++)
                                 {
                                     accessor.GetRowSpan(i).Slice(10, 10).Fill(fg);
                                 }
@@ -407,8 +407,8 @@ public partial class ImageTests
         [InlineData(65536, 65537, 65536)]
         public void WrapMemory_MemoryOfT_InvalidSize(int size, int height, int width)
         {
-            var array = new Rgba32[size];
-            var memory = new Memory<Rgba32>(array);
+            Rgba32[] array = new Rgba32[size];
+            Memory<Rgba32> memory = new(array);
 
             Assert.Throws<ArgumentException>(() => Image.WrapMemory(memory, height, width));
         }
@@ -421,8 +421,8 @@ public partial class ImageTests
         [InlineData(2048, 32, 32)]
         public void WrapMemory_MemoryOfT_ValidSize(int size, int height, int width)
         {
-            var array = new Rgba32[size];
-            var memory = new Memory<Rgba32>(array);
+            Rgba32[] array = new Rgba32[size];
+            Memory<Rgba32> memory = new(array);
 
             Image.WrapMemory(memory, height, width);
         }
@@ -443,8 +443,8 @@ public partial class ImageTests
         [InlineData(65536, 65537, 65536)]
         public void WrapMemory_IMemoryOwnerOfT_InvalidSize(int size, int height, int width)
         {
-            var array = new Rgba32[size];
-            var memory = new TestMemoryOwner<Rgba32> { Memory = array };
+            Rgba32[] array = new Rgba32[size];
+            TestMemoryOwner<Rgba32> memory = new() { Memory = array };
 
             Assert.Throws<ArgumentException>(() => Image.WrapMemory(memory, height, width));
         }
@@ -457,10 +457,10 @@ public partial class ImageTests
         [InlineData(2048, 32, 32)]
         public void WrapMemory_IMemoryOwnerOfT_ValidSize(int size, int height, int width)
         {
-            var array = new Rgba32[size];
-            var memory = new TestMemoryOwner<Rgba32> { Memory = array };
+            Rgba32[] array = new Rgba32[size];
+            TestMemoryOwner<Rgba32> memory = new() { Memory = array };
 
-            using (var img = Image.WrapMemory<Rgba32>(memory, width, height))
+            using (Image<Rgba32> img = Image.WrapMemory<Rgba32>(memory, width, height))
             {
                 Assert.Equal(width, img.Width);
                 Assert.Equal(height, img.Height);
@@ -469,7 +469,7 @@ public partial class ImageTests
                 {
                     for (int i = 0; i < height; ++i)
                     {
-                        var arrayIndex = width * i;
+                        int arrayIndex = width * i;
 
                         Span<Rgba32> rowSpan = accessor.GetRowSpan(i);
                         ref Rgba32 r0 = ref rowSpan[0];
@@ -490,8 +490,8 @@ public partial class ImageTests
         [InlineData(65536, 65537, 65536)]
         public void WrapMemory_IMemoryOwnerOfByte_InvalidSize(int size, int height, int width)
         {
-            var array = new byte[size * Unsafe.SizeOf<Rgba32>()];
-            var memory = new TestMemoryOwner<byte> { Memory = array };
+            byte[] array = new byte[size * Unsafe.SizeOf<Rgba32>()];
+            TestMemoryOwner<byte> memory = new() { Memory = array };
 
             Assert.Throws<ArgumentException>(() => Image.WrapMemory<Rgba32>(memory, height, width));
         }
@@ -504,11 +504,11 @@ public partial class ImageTests
         [InlineData(2048, 32, 32)]
         public void WrapMemory_IMemoryOwnerOfByte_ValidSize(int size, int height, int width)
         {
-            var pixelSize = Unsafe.SizeOf<Rgba32>();
-            var array = new byte[size * pixelSize];
-            var memory = new TestMemoryOwner<byte> { Memory = array };
+            int pixelSize = Unsafe.SizeOf<Rgba32>();
+            byte[] array = new byte[size * pixelSize];
+            TestMemoryOwner<byte> memory = new() { Memory = array };
 
-            using (var img = Image.WrapMemory<Rgba32>(memory, width, height))
+            using (Image<Rgba32> img = Image.WrapMemory<Rgba32>(memory, width, height))
             {
                 Assert.Equal(width, img.Width);
                 Assert.Equal(height, img.Height);
@@ -517,7 +517,7 @@ public partial class ImageTests
                 {
                     for (int i = 0; i < height; ++i)
                     {
-                        var arrayIndex = pixelSize * width * i;
+                        int arrayIndex = pixelSize * width * i;
 
                         Span<Rgba32> rowSpan = acccessor.GetRowSpan(i);
                         ref Rgba32 r0 = ref rowSpan[0];
@@ -538,8 +538,8 @@ public partial class ImageTests
         [InlineData(65536, 65537, 65536)]
         public void WrapMemory_MemoryOfByte_InvalidSize(int size, int height, int width)
         {
-            var array = new byte[size * Unsafe.SizeOf<Rgba32>()];
-            var memory = new Memory<byte>(array);
+            byte[] array = new byte[size * Unsafe.SizeOf<Rgba32>()];
+            Memory<byte> memory = new(array);
 
             Assert.Throws<ArgumentException>(() => Image.WrapMemory<Rgba32>(memory, height, width));
         }
@@ -552,8 +552,8 @@ public partial class ImageTests
         [InlineData(2048, 32, 32)]
         public void WrapMemory_MemoryOfByte_ValidSize(int size, int height, int width)
         {
-            var array = new byte[size * Unsafe.SizeOf<Rgba32>()];
-            var memory = new Memory<byte>(array);
+            byte[] array = new byte[size * Unsafe.SizeOf<Rgba32>()];
+            Memory<byte> memory = new(array);
 
             Image.WrapMemory<Rgba32>(memory, height, width);
         }
diff --git a/tests/ImageSharp.Tests/Image/LargeImageIntegrationTests.cs b/tests/ImageSharp.Tests/Image/LargeImageIntegrationTests.cs
index 12caa6e7a9..8d1b54658f 100644
--- a/tests/ImageSharp.Tests/Image/LargeImageIntegrationTests.cs
+++ b/tests/ImageSharp.Tests/Image/LargeImageIntegrationTests.cs
@@ -31,7 +31,7 @@ public class LargeImageIntegrationTests
             Configuration configuration = Configuration.Default.Clone();
             configuration.PreferContiguousImageBuffers = true;
 
-            using var image = new Image<Rgba32>(configuration, 2048, 2048);
+            using Image<Rgba32> image = new(configuration, 2048, 2048);
             Assert.True(image.DangerousTryGetSinglePixelMemory(out Memory<Rgba32> mem));
             Assert.Equal(2048 * 2048, mem.Length);
         }
@@ -69,7 +69,7 @@ public class LargeImageIntegrationTests
                 Configuration = configuration
             };
 
-            using var image = Image.Load<Rgba32>(options, path);
+            using Image<Rgba32> image = Image.Load<Rgba32>(options, path);
             File.Delete(path);
             Assert.Equal(1, image.GetPixelMemoryGroup().Count);
         }
diff --git a/tests/ImageSharp.Tests/Image/ProcessPixelRowsTestBase.cs b/tests/ImageSharp.Tests/Image/ProcessPixelRowsTestBase.cs
index 27cbe1a7ea..27e42f84e2 100644
--- a/tests/ImageSharp.Tests/Image/ProcessPixelRowsTestBase.cs
+++ b/tests/ImageSharp.Tests/Image/ProcessPixelRowsTestBase.cs
@@ -32,7 +32,7 @@ public abstract class ProcessPixelRowsTestBase
     [Fact]
     public void PixelAccessorDimensionsAreCorrect()
     {
-        using var image = new Image<Rgb24>(123, 456);
+        using Image<Rgb24> image = new(123, 456);
         this.ProcessPixelRowsImpl(image, accessor =>
         {
             Assert.Equal(123, accessor.Width);
@@ -43,7 +43,7 @@ public abstract class ProcessPixelRowsTestBase
     [Fact]
     public void WriteImagePixels_SingleImage()
     {
-        using var image = new Image<L16>(256, 256);
+        using Image<L16> image = new(256, 256);
         this.ProcessPixelRowsImpl(image, accessor =>
         {
             for (int y = 0; y < accessor.Height; y++)
@@ -71,7 +71,7 @@ public abstract class ProcessPixelRowsTestBase
     [Fact]
     public void WriteImagePixels_MultiImage2()
     {
-        using var img1 = new Image<L16>(256, 256);
+        using Image<L16> img1 = new(256, 256);
         Buffer2D<L16> buffer = img1.Frames.RootFrame.PixelBuffer;
         for (int y = 0; y < 256; y++)
         {
@@ -82,7 +82,7 @@ public abstract class ProcessPixelRowsTestBase
             }
         }
 
-        using var img2 = new Image<L16>(256, 256);
+        using Image<L16> img2 = new(256, 256);
 
         this.ProcessPixelRowsImpl(img1, img2, (accessor1, accessor2) =>
         {
@@ -109,7 +109,7 @@ public abstract class ProcessPixelRowsTestBase
     [Fact]
     public void WriteImagePixels_MultiImage3()
     {
-        using var img1 = new Image<L16>(256, 256);
+        using Image<L16> img1 = new(256, 256);
         Buffer2D<L16> buffer2 = img1.Frames.RootFrame.PixelBuffer;
         for (int y = 0; y < 256; y++)
         {
@@ -120,8 +120,8 @@ public abstract class ProcessPixelRowsTestBase
             }
         }
 
-        using var img2 = new Image<L16>(256, 256);
-        using var img3 = new Image<L16>(256, 256);
+        using Image<L16> img2 = new(256, 256);
+        using Image<L16> img3 = new(256, 256);
 
         this.ProcessPixelRowsImpl(img1, img2, img3, (accessor1, accessor2, accessor3) =>
         {
@@ -154,8 +154,8 @@ public abstract class ProcessPixelRowsTestBase
     [Fact]
     public void Disposed_ThrowsObjectDisposedException()
     {
-        using var nonDisposed = new Image<L16>(1, 1);
-        var disposed = new Image<L16>(1, 1);
+        using Image<L16> nonDisposed = new(1, 1);
+        Image<L16> disposed = new(1, 1);
         disposed.Dispose();
 
         Assert.Throws<ObjectDisposedException>(() => this.ProcessPixelRowsImpl(disposed, _ => { }));
@@ -178,11 +178,11 @@ public abstract class ProcessPixelRowsTestBase
         static void RunTest(string testTypeName, string throwExceptionStr)
         {
             bool throwExceptionInner = bool.Parse(throwExceptionStr);
-            var buffer = UnmanagedBuffer<L8>.Allocate(100);
-            var allocator = new MockUnmanagedMemoryAllocator<L8>(buffer);
+            UnmanagedBuffer<L8> buffer = UnmanagedBuffer<L8>.Allocate(100);
+            MockUnmanagedMemoryAllocator<L8> allocator = new(buffer);
             Configuration.Default.MemoryAllocator = allocator;
 
-            var image = new Image<L8>(10, 10);
+            Image<L8> image = new(10, 10);
 
             Assert.Equal(1, UnmanagedMemoryHandle.TotalOutstandingHandles);
             try
@@ -215,13 +215,13 @@ public abstract class ProcessPixelRowsTestBase
         static void RunTest(string testTypeName, string throwExceptionStr)
         {
             bool throwExceptionInner = bool.Parse(throwExceptionStr);
-            var buffer1 = UnmanagedBuffer<L8>.Allocate(100);
-            var buffer2 = UnmanagedBuffer<L8>.Allocate(100);
-            var allocator = new MockUnmanagedMemoryAllocator<L8>(buffer1, buffer2);
+            UnmanagedBuffer<L8> buffer1 = UnmanagedBuffer<L8>.Allocate(100);
+            UnmanagedBuffer<L8> buffer2 = UnmanagedBuffer<L8>.Allocate(100);
+            MockUnmanagedMemoryAllocator<L8> allocator = new(buffer1, buffer2);
             Configuration.Default.MemoryAllocator = allocator;
 
-            var image1 = new Image<L8>(10, 10);
-            var image2 = new Image<L8>(10, 10);
+            Image<L8> image1 = new(10, 10);
+            Image<L8> image2 = new(10, 10);
 
             Assert.Equal(2, UnmanagedMemoryHandle.TotalOutstandingHandles);
             try
@@ -255,15 +255,15 @@ public abstract class ProcessPixelRowsTestBase
         static void RunTest(string testTypeName, string throwExceptionStr)
         {
             bool throwExceptionInner = bool.Parse(throwExceptionStr);
-            var buffer1 = UnmanagedBuffer<L8>.Allocate(100);
-            var buffer2 = UnmanagedBuffer<L8>.Allocate(100);
-            var buffer3 = UnmanagedBuffer<L8>.Allocate(100);
-            var allocator = new MockUnmanagedMemoryAllocator<L8>(buffer1, buffer2, buffer3);
+            UnmanagedBuffer<L8> buffer1 = UnmanagedBuffer<L8>.Allocate(100);
+            UnmanagedBuffer<L8> buffer2 = UnmanagedBuffer<L8>.Allocate(100);
+            UnmanagedBuffer<L8> buffer3 = UnmanagedBuffer<L8>.Allocate(100);
+            MockUnmanagedMemoryAllocator<L8> allocator = new(buffer1, buffer2, buffer3);
             Configuration.Default.MemoryAllocator = allocator;
 
-            var image1 = new Image<L8>(10, 10);
-            var image2 = new Image<L8>(10, 10);
-            var image3 = new Image<L8>(10, 10);
+            Image<L8> image1 = new(10, 10);
+            Image<L8> image2 = new(10, 10);
+            Image<L8> image3 = new(10, 10);
 
             Assert.Equal(3, UnmanagedMemoryHandle.TotalOutstandingHandles);
             try
diff --git a/tests/ImageSharp.Tests/ImageSharp.Tests.csproj b/tests/ImageSharp.Tests/ImageSharp.Tests.csproj
index 9af4f41a81..ce391fad2c 100644
--- a/tests/ImageSharp.Tests/ImageSharp.Tests.csproj
+++ b/tests/ImageSharp.Tests/ImageSharp.Tests.csproj
@@ -32,6 +32,9 @@
       <AutoGen>True</AutoGen>
       <DependentUpon>PixelOperationsTests.Specialized.Generated.tt</DependentUpon>
     </None>
+    <None Update="TestDataIcc\Profiles\*">
+      <CopyToOutputDirectory>PreserveNewest</CopyToOutputDirectory>
+    </None>
   </ItemGroup>
 
   <ItemGroup>
@@ -47,6 +50,7 @@
     <PackageReference Include="runtime.osx.10.10-x64.CoreCompat.System.Drawing" Condition="'$(IsOSX)'=='true'" />
     <PackageReference Include="SharpZipLib" />
     <PackageReference Include="System.Drawing.Common" />
+    <PackageReference Include="Wacton.Unicolour" Version="6.0.0" />
   </ItemGroup>
 
   <ItemGroup>
diff --git a/tests/ImageSharp.Tests/Issues/Issue594.cs b/tests/ImageSharp.Tests/Issues/Issue594.cs
index 7f976a3731..36308edaeb 100644
--- a/tests/ImageSharp.Tests/Issues/Issue594.cs
+++ b/tests/ImageSharp.Tests/Issues/Issue594.cs
@@ -40,7 +40,7 @@ public class Issue594
         const float z = 0.5f;
         const float w = -0.7f;
 
-        pixel = new(x, y, z, w);
+        pixel = new NormalizedByte4(x, y, z, w);
         Assert.Equal(0xA740DA0D, pixel.PackedValue);
         NormalizedByte4 n = NormalizedByte4.FromRgba32(pixel.ToRgba32());
         Assert.Equal(0xA740DA0D, n.PackedValue);
diff --git a/tests/ImageSharp.Tests/Memory/Allocators/BufferTestSuite.cs b/tests/ImageSharp.Tests/Memory/Allocators/BufferTestSuite.cs
index 33950c4697..c4cef5d93e 100644
--- a/tests/ImageSharp.Tests/Memory/Allocators/BufferTestSuite.cs
+++ b/tests/ImageSharp.Tests/Memory/Allocators/BufferTestSuite.cs
@@ -58,7 +58,7 @@ public abstract class BufferTestSuite
         }
     }
 
-    public static readonly TheoryData<int> LengthValues = new TheoryData<int> { 0, 1, 7, 1023, 1024 };
+    public static readonly TheoryData<int> LengthValues = new() { 0, 1, 7, 1023, 1024 };
 
     [Theory]
     [MemberData(nameof(LengthValues))]
@@ -172,7 +172,7 @@ public abstract class BufferTestSuite
     {
         using (IMemoryOwner<T> buffer = this.MemoryAllocator.Allocate<T>(desiredLength))
         {
-            var expectedVals = new T[buffer.Length()];
+            T[] expectedVals = new T[buffer.Length()];
 
             for (int i = 0; i < buffer.Length(); i++)
             {
@@ -213,7 +213,7 @@ public abstract class BufferTestSuite
     private T TestIndexOutOfRangeShouldThrow<T>(int desiredLength)
         where T : struct, IEquatable<T>
     {
-        var dummy = default(T);
+        T dummy = default(T);
 
         using (IMemoryOwner<T> buffer = this.MemoryAllocator.Allocate<T>(desiredLength))
         {
diff --git a/tests/ImageSharp.Tests/Memory/Allocators/MemoryDiagnosticsTests.cs b/tests/ImageSharp.Tests/Memory/Allocators/MemoryDiagnosticsTests.cs
index b8dd4be8df..c4b75b5cfa 100644
--- a/tests/ImageSharp.Tests/Memory/Allocators/MemoryDiagnosticsTests.cs
+++ b/tests/ImageSharp.Tests/Memory/Allocators/MemoryDiagnosticsTests.cs
@@ -27,7 +27,7 @@ public class MemoryDiagnosticsTests
             int leakCounter = 0;
             MemoryDiagnostics.UndisposedAllocation += _ => Interlocked.Increment(ref leakCounter);
 
-            List<IDisposable> buffers = new();
+            List<IDisposable> buffers = [];
 
             Assert.Equal(0, MemoryDiagnostics.TotalUndisposedAllocationCount);
             for (int length = 1024; length <= 64 * OneMb; length *= 2)
diff --git a/tests/ImageSharp.Tests/Memory/Allocators/RefCountedLifetimeGuardTests.cs b/tests/ImageSharp.Tests/Memory/Allocators/RefCountedLifetimeGuardTests.cs
index 517eda7076..8eb364828e 100644
--- a/tests/ImageSharp.Tests/Memory/Allocators/RefCountedLifetimeGuardTests.cs
+++ b/tests/ImageSharp.Tests/Memory/Allocators/RefCountedLifetimeGuardTests.cs
@@ -14,7 +14,7 @@ public class RefCountedLifetimeGuardTests
     [InlineData(3)]
     public void Dispose_ResultsInSingleRelease(int disposeCount)
     {
-        var guard = new MockLifetimeGuard();
+        MockLifetimeGuard guard = new();
         Assert.Equal(0, guard.ReleaseInvocationCount);
 
         for (int i = 0; i < disposeCount; i++)
@@ -45,7 +45,7 @@ public class RefCountedLifetimeGuardTests
     [InlineData(3)]
     public void AddRef_PreventsReleaseOnDispose(int addRefCount)
     {
-        var guard = new MockLifetimeGuard();
+        MockLifetimeGuard guard = new();
 
         for (int i = 0; i < addRefCount; i++)
         {
@@ -80,7 +80,7 @@ public class RefCountedLifetimeGuardTests
     [Fact]
     public void AddRefReleaseRefMisuse_DoesntLeadToMultipleReleases()
     {
-        var guard = new MockLifetimeGuard();
+        MockLifetimeGuard guard = new();
         guard.Dispose();
         guard.AddRef();
         guard.ReleaseRef();
@@ -91,8 +91,8 @@ public class RefCountedLifetimeGuardTests
     [Fact]
     public void UnmanagedBufferLifetimeGuard_Handle_IsReturnedByRef()
     {
-        var h = UnmanagedMemoryHandle.Allocate(10);
-        using var guard = new UnmanagedBufferLifetimeGuard.FreeHandle(h);
+        UnmanagedMemoryHandle h = UnmanagedMemoryHandle.Allocate(10);
+        using UnmanagedBufferLifetimeGuard.FreeHandle guard = new(h);
         Assert.True(guard.Handle.IsValid);
         guard.Handle.Free();
         Assert.False(guard.Handle.IsValid);
@@ -101,7 +101,7 @@ public class RefCountedLifetimeGuardTests
     [MethodImpl(MethodImplOptions.NoInlining)]
     private static void LeakGuard(bool addRef)
     {
-        var guard = new MockLifetimeGuard();
+        MockLifetimeGuard guard = new();
         if (addRef)
         {
             guard.AddRef();
diff --git a/tests/ImageSharp.Tests/Memory/Allocators/SharedArrayPoolBufferTests.cs b/tests/ImageSharp.Tests/Memory/Allocators/SharedArrayPoolBufferTests.cs
index a956190cd2..72b90c2387 100644
--- a/tests/ImageSharp.Tests/Memory/Allocators/SharedArrayPoolBufferTests.cs
+++ b/tests/ImageSharp.Tests/Memory/Allocators/SharedArrayPoolBufferTests.cs
@@ -16,7 +16,7 @@ public class SharedArrayPoolBufferTests
 
         static void RunTest()
         {
-            using (var buffer = new SharedArrayPoolBuffer<byte>(900))
+            using (SharedArrayPoolBuffer<byte> buffer = new(900))
             {
                 Assert.Equal(900, buffer.GetSpan().Length);
                 buffer.GetSpan().Fill(42);
@@ -36,7 +36,7 @@ public class SharedArrayPoolBufferTests
 
         static void RunTest()
         {
-            var buffer = new SharedArrayPoolBuffer<byte>(900);
+            SharedArrayPoolBuffer<byte> buffer = new(900);
             Span<byte> span = buffer.GetSpan();
 
             buffer.AddRef();
diff --git a/tests/ImageSharp.Tests/Memory/Allocators/SimpleGcMemoryAllocatorTests.cs b/tests/ImageSharp.Tests/Memory/Allocators/SimpleGcMemoryAllocatorTests.cs
index 665f34a342..0e791c5d97 100644
--- a/tests/ImageSharp.Tests/Memory/Allocators/SimpleGcMemoryAllocatorTests.cs
+++ b/tests/ImageSharp.Tests/Memory/Allocators/SimpleGcMemoryAllocatorTests.cs
@@ -17,7 +17,7 @@ public class SimpleGcMemoryAllocatorTests
         }
     }
 
-    protected SimpleGcMemoryAllocator MemoryAllocator { get; } = new SimpleGcMemoryAllocator();
+    protected SimpleGcMemoryAllocator MemoryAllocator { get; } = new();
 
     public static TheoryData<int> InvalidLengths { get; set; } = new()
     {
diff --git a/tests/ImageSharp.Tests/Memory/Allocators/UniformUnmanagedMemoryPoolTests.Trim.cs b/tests/ImageSharp.Tests/Memory/Allocators/UniformUnmanagedMemoryPoolTests.Trim.cs
index fd8b6af591..fd9760f48f 100644
--- a/tests/ImageSharp.Tests/Memory/Allocators/UniformUnmanagedMemoryPoolTests.Trim.cs
+++ b/tests/ImageSharp.Tests/Memory/Allocators/UniformUnmanagedMemoryPoolTests.Trim.cs
@@ -24,8 +24,8 @@ public partial class UniformUnmanagedMemoryPoolTests
             RemoteExecutor.Invoke(RunTest).Dispose();
             static void RunTest()
             {
-                var trimSettings = new UniformUnmanagedMemoryPool.TrimSettings { TrimPeriodMilliseconds = 5_000 };
-                var pool = new UniformUnmanagedMemoryPool(128, 256, trimSettings);
+                UniformUnmanagedMemoryPool.TrimSettings trimSettings = new() { TrimPeriodMilliseconds = 5_000 };
+                UniformUnmanagedMemoryPool pool = new(128, 256, trimSettings);
 
                 UnmanagedMemoryHandle[] a = pool.Rent(64);
                 UnmanagedMemoryHandle[] b = pool.Rent(64);
@@ -77,11 +77,11 @@ public partial class UniformUnmanagedMemoryPoolTests
 
                 static void RunTest()
                 {
-                    var trimSettings1 = new UniformUnmanagedMemoryPool.TrimSettings { TrimPeriodMilliseconds = 6_000 };
-                    var pool1 = new UniformUnmanagedMemoryPool(128, 256, trimSettings1);
+                    UniformUnmanagedMemoryPool.TrimSettings trimSettings1 = new() { TrimPeriodMilliseconds = 6_000 };
+                    UniformUnmanagedMemoryPool pool1 = new(128, 256, trimSettings1);
                     Thread.Sleep(8_000); // Let some callbacks fire already
-                    var trimSettings2 = new UniformUnmanagedMemoryPool.TrimSettings { TrimPeriodMilliseconds = 3_000 };
-                    var pool2 = new UniformUnmanagedMemoryPool(128, 256, trimSettings2);
+                    UniformUnmanagedMemoryPool.TrimSettings trimSettings2 = new() { TrimPeriodMilliseconds = 3_000 };
+                    UniformUnmanagedMemoryPool pool2 = new(128, 256, trimSettings2);
 
                     pool1.Return(pool1.Rent(64));
                     pool2.Return(pool2.Rent(64));
@@ -104,14 +104,14 @@ public partial class UniformUnmanagedMemoryPoolTests
                 [MethodImpl(MethodImplOptions.NoInlining)]
                 static void LeakPoolInstance()
                 {
-                    var trimSettings = new UniformUnmanagedMemoryPool.TrimSettings { TrimPeriodMilliseconds = 4_000 };
+                    UniformUnmanagedMemoryPool.TrimSettings trimSettings = new() { TrimPeriodMilliseconds = 4_000 };
                     _ = new UniformUnmanagedMemoryPool(128, 256, trimSettings);
                 }
             }
         }
 
         public static readonly bool Is32BitProcess = !Environment.Is64BitProcess;
-        private static readonly List<byte[]> PressureArrays = new();
+        private static readonly List<byte[]> PressureArrays = [];
 
         [Fact]
         public static void GC_Collect_OnHighLoad_TrimsEntirePool()
@@ -129,13 +129,13 @@ public partial class UniformUnmanagedMemoryPoolTests
                 Assert.False(Environment.Is64BitProcess);
                 const int oneMb = 1 << 20;
 
-                var trimSettings = new UniformUnmanagedMemoryPool.TrimSettings { HighPressureThresholdRate = 0.2f };
+                UniformUnmanagedMemoryPool.TrimSettings trimSettings = new() { HighPressureThresholdRate = 0.2f };
 
                 GCMemoryInfo memInfo = GC.GetGCMemoryInfo();
                 int highLoadThreshold = (int)(memInfo.HighMemoryLoadThresholdBytes / oneMb);
                 highLoadThreshold = (int)(trimSettings.HighPressureThresholdRate * highLoadThreshold);
 
-                var pool = new UniformUnmanagedMemoryPool(oneMb, 16, trimSettings);
+                UniformUnmanagedMemoryPool pool = new(oneMb, 16, trimSettings);
                 pool.Return(pool.Rent(16));
                 Assert.Equal(16, UnmanagedMemoryHandle.TotalOutstandingHandles);
 
diff --git a/tests/ImageSharp.Tests/Memory/Allocators/UniformUnmanagedMemoryPoolTests.cs b/tests/ImageSharp.Tests/Memory/Allocators/UniformUnmanagedMemoryPoolTests.cs
index 69fc1a5f7d..ec79d91c3d 100644
--- a/tests/ImageSharp.Tests/Memory/Allocators/UniformUnmanagedMemoryPoolTests.cs
+++ b/tests/ImageSharp.Tests/Memory/Allocators/UniformUnmanagedMemoryPoolTests.cs
@@ -55,7 +55,7 @@ public partial class UniformUnmanagedMemoryPoolTests
     [InlineData(7, 4)]
     public void Constructor_InitializesProperties(int arrayLength, int capacity)
     {
-        var pool = new UniformUnmanagedMemoryPool(arrayLength, capacity);
+        UniformUnmanagedMemoryPool pool = new(arrayLength, capacity);
         Assert.Equal(arrayLength, pool.BufferLength);
         Assert.Equal(capacity, pool.Capacity);
     }
@@ -65,8 +65,8 @@ public partial class UniformUnmanagedMemoryPoolTests
     [InlineData(8, 10)]
     public void Rent_SingleBuffer_ReturnsCorrectBuffer(int length, int capacity)
     {
-        var pool = new UniformUnmanagedMemoryPool(length, capacity);
-        using var cleanup = new CleanupUtil(pool);
+        UniformUnmanagedMemoryPool pool = new(length, capacity);
+        using CleanupUtil cleanup = new(pool);
 
         for (int i = 0; i < capacity; i++)
         {
@@ -83,7 +83,7 @@ public partial class UniformUnmanagedMemoryPoolTests
 
         static void RunTest()
         {
-            var pool = new UniformUnmanagedMemoryPool(16, 16);
+            UniformUnmanagedMemoryPool pool = new(16, 16);
             UnmanagedMemoryHandle a = pool.Rent();
             UnmanagedMemoryHandle[] b = pool.Rent(2);
 
@@ -105,7 +105,7 @@ public partial class UniformUnmanagedMemoryPoolTests
         Assert.True(span.SequenceEqual(expected));
     }
 
-    private static unsafe Span<byte> GetSpan(UnmanagedMemoryHandle h, int length) => new Span<byte>(h.Pointer, length);
+    private static unsafe Span<byte> GetSpan(UnmanagedMemoryHandle h, int length) => new(h.Pointer, length);
 
     [Theory]
     [InlineData(1, 1)]
@@ -114,8 +114,8 @@ public partial class UniformUnmanagedMemoryPoolTests
     [InlineData(5, 10)]
     public void Rent_MultiBuffer_ReturnsCorrectBuffers(int length, int bufferCount)
     {
-        var pool = new UniformUnmanagedMemoryPool(length, 10);
-        using var cleanup = new CleanupUtil(pool);
+        UniformUnmanagedMemoryPool pool = new(length, 10);
+        using CleanupUtil cleanup = new(pool);
         UnmanagedMemoryHandle[] handles = pool.Rent(bufferCount);
         cleanup.Register(handles);
 
@@ -131,8 +131,8 @@ public partial class UniformUnmanagedMemoryPoolTests
     [Fact]
     public void Rent_MultipleTimesWithoutReturn_ReturnsDifferentHandles()
     {
-        var pool = new UniformUnmanagedMemoryPool(128, 10);
-        using var cleanup = new CleanupUtil(pool);
+        UniformUnmanagedMemoryPool pool = new(128, 10);
+        using CleanupUtil cleanup = new(pool);
         UnmanagedMemoryHandle[] a = pool.Rent(2);
         cleanup.Register(a);
         UnmanagedMemoryHandle b = pool.Rent();
@@ -149,10 +149,10 @@ public partial class UniformUnmanagedMemoryPoolTests
     [InlineData(12, 4, 12)]
     public void RentReturnRent_SameBuffers(int totalCount, int rentUnit, int capacity)
     {
-        var pool = new UniformUnmanagedMemoryPool(128, capacity);
-        using var cleanup = new CleanupUtil(pool);
-        var allHandles = new HashSet<UnmanagedMemoryHandle>();
-        var handleUnits = new List<UnmanagedMemoryHandle[]>();
+        UniformUnmanagedMemoryPool pool = new(128, capacity);
+        using CleanupUtil cleanup = new(pool);
+        HashSet<UnmanagedMemoryHandle> allHandles = new();
+        List<UnmanagedMemoryHandle[]> handleUnits = new();
 
         UnmanagedMemoryHandle[] handles;
         for (int i = 0; i < totalCount; i += rentUnit)
@@ -197,8 +197,8 @@ public partial class UniformUnmanagedMemoryPoolTests
     [Fact]
     public void Rent_SingleBuffer_OverCapacity_ReturnsInvalidBuffer()
     {
-        var pool = new UniformUnmanagedMemoryPool(7, 1000);
-        using var cleanup = new CleanupUtil(pool);
+        UniformUnmanagedMemoryPool pool = new(7, 1000);
+        using CleanupUtil cleanup = new(pool);
         UnmanagedMemoryHandle[] initial = pool.Rent(1000);
         Assert.NotNull(initial);
         cleanup.Register(initial);
@@ -212,8 +212,8 @@ public partial class UniformUnmanagedMemoryPoolTests
     [InlineData(4, 7, 10)]
     public void Rent_MultiBuffer_OverCapacity_ReturnsNull(int initialRent, int attempt, int capacity)
     {
-        var pool = new UniformUnmanagedMemoryPool(128, capacity);
-        using var cleanup = new CleanupUtil(pool);
+        UniformUnmanagedMemoryPool pool = new(128, capacity);
+        using CleanupUtil cleanup = new(pool);
         UnmanagedMemoryHandle[] initial = pool.Rent(initialRent);
         Assert.NotNull(initial);
         cleanup.Register(initial);
@@ -228,8 +228,8 @@ public partial class UniformUnmanagedMemoryPoolTests
     [InlineData(3, 3, 7)]
     public void Rent_MultiBuff_BelowCapacity_Succeeds(int initialRent, int attempt, int capacity)
     {
-        var pool = new UniformUnmanagedMemoryPool(128, capacity);
-        using var cleanup = new CleanupUtil(pool);
+        UniformUnmanagedMemoryPool pool = new(128, capacity);
+        using CleanupUtil cleanup = new(pool);
         UnmanagedMemoryHandle[] b0 = pool.Rent(initialRent);
         Assert.NotNull(b0);
         cleanup.Register(b0);
@@ -250,8 +250,8 @@ public partial class UniformUnmanagedMemoryPoolTests
 
         static void RunTest(string multipleInner)
         {
-            var pool = new UniformUnmanagedMemoryPool(16, 16);
-            using var cleanup = new CleanupUtil(pool);
+            UniformUnmanagedMemoryPool pool = new(16, 16);
+            using CleanupUtil cleanup = new(pool);
             UnmanagedMemoryHandle b0 = pool.Rent();
             IntPtr h0 = b0.Handle;
             UnmanagedMemoryHandle b1 = pool.Rent();
@@ -290,7 +290,7 @@ public partial class UniformUnmanagedMemoryPoolTests
 
         static void RunTest()
         {
-            var pool = new UniformUnmanagedMemoryPool(16, 16);
+            UniformUnmanagedMemoryPool pool = new(16, 16);
             UnmanagedMemoryHandle a = pool.Rent();
             UnmanagedMemoryHandle[] b = pool.Rent(2);
             pool.Return(a);
@@ -306,13 +306,13 @@ public partial class UniformUnmanagedMemoryPoolTests
     public void RentReturn_IsThreadSafe()
     {
         int count = Environment.ProcessorCount * 200;
-        var pool = new UniformUnmanagedMemoryPool(8, count);
-        using var cleanup = new CleanupUtil(pool);
-        var rnd = new Random(0);
+        UniformUnmanagedMemoryPool pool = new(8, count);
+        using CleanupUtil cleanup = new(pool);
+        Random rnd = new(0);
 
         Parallel.For(0, Environment.ProcessorCount, (int i) =>
         {
-            var allHandles = new List<UnmanagedMemoryHandle>();
+            List<UnmanagedMemoryHandle> allHandles = new();
             int pauseAt = rnd.Next(100);
             for (int j = 0; j < 100; j++)
             {
@@ -359,7 +359,7 @@ public partial class UniformUnmanagedMemoryPoolTests
         [MethodImpl(MethodImplOptions.NoInlining)]
         static void LeakPoolInstance(bool withGuardedBuffers)
         {
-            var pool = new UniformUnmanagedMemoryPool(16, 128);
+            UniformUnmanagedMemoryPool pool = new(16, 128);
             if (withGuardedBuffers)
             {
                 UnmanagedMemoryHandle h = pool.Rent();
diff --git a/tests/ImageSharp.Tests/Memory/Allocators/UniformUnmanagedPoolMemoryAllocatorTests.cs b/tests/ImageSharp.Tests/Memory/Allocators/UniformUnmanagedPoolMemoryAllocatorTests.cs
index aa34a5c108..6e7e9fea73 100644
--- a/tests/ImageSharp.Tests/Memory/Allocators/UniformUnmanagedPoolMemoryAllocatorTests.cs
+++ b/tests/ImageSharp.Tests/Memory/Allocators/UniformUnmanagedPoolMemoryAllocatorTests.cs
@@ -44,7 +44,7 @@ public class UniformUnmanagedPoolMemoryAllocatorTests
     }
 
     public static TheoryData<object, int, int, int, int, long, int, int, int, int> AllocateData =
-        new TheoryData<object, int, int, int, int, long, int, int, int, int>()
+        new()
         {
             { default(S4), 16, 256, 256, 1024, 64, 64, 1, -1, 64 },
             { default(S4), 16, 256, 256, 1024, 256, 256, 1, -1, 256 },
@@ -69,7 +69,7 @@ public class UniformUnmanagedPoolMemoryAllocatorTests
         int expectedSizeOfLastBuffer)
         where T : struct
     {
-        var allocator = new UniformUnmanagedMemoryPoolMemoryAllocator(
+        UniformUnmanagedMemoryPoolMemoryAllocator allocator = new(
             sharedArrayPoolThresholdInBytes,
             maxContiguousPoolBufferInBytes,
             maxPoolSizeInBytes,
@@ -86,13 +86,13 @@ public class UniformUnmanagedPoolMemoryAllocatorTests
     [Fact]
     public void AllocateGroup_MultipleTimes_ExceedPoolLimit()
     {
-        var allocator = new UniformUnmanagedMemoryPoolMemoryAllocator(
+        UniformUnmanagedMemoryPoolMemoryAllocator allocator = new(
             64,
             128,
             1024,
             1024);
 
-        var groups = new List<MemoryGroup<S4>>();
+        List<MemoryGroup<S4>> groups = [];
         for (int i = 0; i < 16; i++)
         {
             int lengthInElements = 128 / Unsafe.SizeOf<S4>();
@@ -110,7 +110,7 @@ public class UniformUnmanagedPoolMemoryAllocatorTests
     [Fact]
     public void AllocateGroup_SizeInBytesOverLongMaxValue_ThrowsInvalidMemoryOperationException()
     {
-        var allocator = new UniformUnmanagedMemoryPoolMemoryAllocator(null);
+        UniformUnmanagedMemoryPoolMemoryAllocator allocator = new(null);
         Assert.Throws<InvalidMemoryOperationException>(() => allocator.AllocateGroup<byte>(int.MaxValue * (long)int.MaxValue, int.MaxValue));
     }
 
@@ -128,7 +128,7 @@ public class UniformUnmanagedPoolMemoryAllocatorTests
     [Fact]
     public unsafe void Allocate_MemoryIsPinnableMultipleTimes()
     {
-        var allocator = new UniformUnmanagedMemoryPoolMemoryAllocator(null);
+        UniformUnmanagedMemoryPoolMemoryAllocator allocator = new(null);
         using IMemoryOwner<byte> memoryOwner = allocator.Allocate<byte>(100);
 
         using (MemoryHandle pin = memoryOwner.Memory.Pin())
@@ -149,7 +149,7 @@ public class UniformUnmanagedPoolMemoryAllocatorTests
 
         static void RunTest()
         {
-            var allocator = MemoryAllocator.Create();
+            MemoryAllocator allocator = MemoryAllocator.Create();
             long sixteenMegabytes = 16 * (1 << 20);
 
             // Should allocate 4 times 4MB discontiguos blocks:
@@ -165,7 +165,7 @@ public class UniformUnmanagedPoolMemoryAllocatorTests
 
         static void RunTest()
         {
-            var allocator = MemoryAllocator.Create(new MemoryAllocatorOptions()
+            MemoryAllocator allocator = MemoryAllocator.Create(new MemoryAllocatorOptions
             {
                 MaximumPoolSizeMegabytes = 8
             });
@@ -205,7 +205,7 @@ public class UniformUnmanagedPoolMemoryAllocatorTests
 
         static void RunTest(string sharedStr)
         {
-            var allocator = new UniformUnmanagedMemoryPoolMemoryAllocator(512, 1024, 16 * 1024, 1024);
+            UniformUnmanagedMemoryPoolMemoryAllocator allocator = new(512, 1024, 16 * 1024, 1024);
             IMemoryOwner<byte> buffer0 = allocator.Allocate<byte>(bool.Parse(sharedStr) ? 300 : 600);
             buffer0.GetSpan()[0] = 42;
             buffer0.Dispose();
@@ -223,7 +223,7 @@ public class UniformUnmanagedPoolMemoryAllocatorTests
 
         static void RunTest(string sharedStr)
         {
-            var allocator = new UniformUnmanagedMemoryPoolMemoryAllocator(512, 1024, 16 * 1024, 1024);
+            UniformUnmanagedMemoryPoolMemoryAllocator allocator = new(512, 1024, 16 * 1024, 1024);
             MemoryGroup<byte> g0 = allocator.AllocateGroup<byte>(bool.Parse(sharedStr) ? 300 : 600, 100);
             g0.Single().Span[0] = 42;
             g0.Dispose();
@@ -238,7 +238,7 @@ public class UniformUnmanagedPoolMemoryAllocatorTests
         RemoteExecutor.Invoke(RunTest).Dispose();
         static void RunTest()
         {
-            var allocator = new UniformUnmanagedMemoryPoolMemoryAllocator(128, 512, 16 * 512, 1024);
+            UniformUnmanagedMemoryPoolMemoryAllocator allocator = new(128, 512, 16 * 512, 1024);
             MemoryGroup<byte> g = allocator.AllocateGroup<byte>(2048, 128);
             g.Dispose();
             Assert.Equal(4, UnmanagedMemoryHandle.TotalOutstandingHandles);
@@ -253,7 +253,7 @@ public class UniformUnmanagedPoolMemoryAllocatorTests
         RemoteExecutor.Invoke(RunTest).Dispose();
         static void RunTest()
         {
-            var allocator = new UniformUnmanagedMemoryPoolMemoryAllocator(128, 512, 16 * 512, 1024);
+            UniformUnmanagedMemoryPoolMemoryAllocator allocator = new(128, 512, 16 * 512, 1024);
             IMemoryOwner<byte> b = allocator.Allocate<byte>(256);
             MemoryGroup<byte> g = allocator.AllocateGroup<byte>(2048, 128);
             Assert.Equal(5, UnmanagedMemoryHandle.TotalOutstandingHandles);
@@ -297,7 +297,7 @@ public class UniformUnmanagedPoolMemoryAllocatorTests
 
         static void RunTest(string lengthStr)
         {
-            var allocator = new UniformUnmanagedMemoryPoolMemoryAllocator(512, 1024, 16 * 1024, 1024);
+            UniformUnmanagedMemoryPoolMemoryAllocator allocator = new(512, 1024, 16 * 1024, 1024);
             int lengthInner = int.Parse(lengthStr);
 
             AllocateGroupAndForget(allocator, lengthInner);
@@ -365,7 +365,7 @@ public class UniformUnmanagedPoolMemoryAllocatorTests
 
         static void RunTest(string lengthStr)
         {
-            var allocator = new UniformUnmanagedMemoryPoolMemoryAllocator(512, 1024, 16 * 1024, 1024);
+            UniformUnmanagedMemoryPoolMemoryAllocator allocator = new(512, 1024, 16 * 1024, 1024);
             int lengthInner = int.Parse(lengthStr);
 
             AllocateSingleAndForget(allocator, lengthInner);
@@ -422,7 +422,7 @@ public class UniformUnmanagedPoolMemoryAllocatorTests
     [Fact]
     public void Allocate_OverLimit_ThrowsInvalidMemoryOperationException()
     {
-        MemoryAllocator allocator = MemoryAllocator.Create(new MemoryAllocatorOptions()
+        MemoryAllocator allocator = MemoryAllocator.Create(new MemoryAllocatorOptions
         {
             AllocationLimitMegabytes = 4
         });
@@ -434,7 +434,7 @@ public class UniformUnmanagedPoolMemoryAllocatorTests
     [Fact]
     public void AllocateGroup_OverLimit_ThrowsInvalidMemoryOperationException()
     {
-        MemoryAllocator allocator = MemoryAllocator.Create(new MemoryAllocatorOptions()
+        MemoryAllocator allocator = MemoryAllocator.Create(new MemoryAllocatorOptions
         {
             AllocationLimitMegabytes = 4
         });
@@ -450,7 +450,7 @@ public class UniformUnmanagedPoolMemoryAllocatorTests
         static void RunTest()
         {
             const long threeGB = 3L * (1 << 30);
-            MemoryAllocator allocator = MemoryAllocator.Create(new MemoryAllocatorOptions()
+            MemoryAllocator allocator = MemoryAllocator.Create(new MemoryAllocatorOptions
             {
                 AllocationLimitMegabytes = (int)(threeGB / 1024)
             });
diff --git a/tests/ImageSharp.Tests/Memory/Allocators/UnmanagedBufferTests.cs b/tests/ImageSharp.Tests/Memory/Allocators/UnmanagedBufferTests.cs
index d0a5cfa9a7..3b33eae5e9 100644
--- a/tests/ImageSharp.Tests/Memory/Allocators/UnmanagedBufferTests.cs
+++ b/tests/ImageSharp.Tests/Memory/Allocators/UnmanagedBufferTests.cs
@@ -21,7 +21,7 @@ public class UnmanagedBufferTests
     [Fact]
     public void Allocate_CreatesValidBuffer()
     {
-        using var buffer = UnmanagedBuffer<int>.Allocate(10);
+        using UnmanagedBuffer<int> buffer = UnmanagedBuffer<int>.Allocate(10);
         Span<int> span = buffer.GetSpan();
         Assert.Equal(10, span.Length);
         span[9] = 123;
@@ -35,7 +35,7 @@ public class UnmanagedBufferTests
 
         static void RunTest()
         {
-            var buffer = UnmanagedBuffer<int>.Allocate(10);
+            UnmanagedBuffer<int> buffer = UnmanagedBuffer<int>.Allocate(10);
             Assert.Equal(1, UnmanagedMemoryHandle.TotalOutstandingHandles);
             Span<int> span = buffer.GetSpan();
 
@@ -76,10 +76,10 @@ public class UnmanagedBufferTests
 
         static List<UnmanagedBuffer<byte>> FillList(int countInner)
         {
-            var l = new List<UnmanagedBuffer<byte>>();
+            List<UnmanagedBuffer<byte>> l = new();
             for (int i = 0; i < countInner; i++)
             {
-                var h = UnmanagedBuffer<byte>.Allocate(42);
+                UnmanagedBuffer<byte> h = UnmanagedBuffer<byte>.Allocate(42);
                 l.Add(h);
             }
 
diff --git a/tests/ImageSharp.Tests/Memory/Allocators/UnmanagedMemoryHandleTests.cs b/tests/ImageSharp.Tests/Memory/Allocators/UnmanagedMemoryHandleTests.cs
index 7a0736b545..59b793e012 100644
--- a/tests/ImageSharp.Tests/Memory/Allocators/UnmanagedMemoryHandleTests.cs
+++ b/tests/ImageSharp.Tests/Memory/Allocators/UnmanagedMemoryHandleTests.cs
@@ -11,7 +11,7 @@ public class UnmanagedMemoryHandleTests
     [Fact]
     public unsafe void Allocate_AllocatesReadWriteMemory()
     {
-        var h = UnmanagedMemoryHandle.Allocate(128);
+        UnmanagedMemoryHandle h = UnmanagedMemoryHandle.Allocate(128);
         Assert.False(h.IsInvalid);
         Assert.True(h.IsValid);
         byte* ptr = (byte*)h.Handle;
@@ -31,7 +31,7 @@ public class UnmanagedMemoryHandleTests
     [Fact]
     public void Free_ClosesHandle()
     {
-        var h = UnmanagedMemoryHandle.Allocate(128);
+        UnmanagedMemoryHandle h = UnmanagedMemoryHandle.Allocate(128);
         h.Free();
         Assert.True(h.IsInvalid);
         Assert.Equal(IntPtr.Zero, h.Handle);
@@ -47,11 +47,11 @@ public class UnmanagedMemoryHandleTests
         static void RunTest(string countStr)
         {
             int countInner = int.Parse(countStr);
-            var l = new List<UnmanagedMemoryHandle>();
+            List<UnmanagedMemoryHandle> l = new();
             for (int i = 0; i < countInner; i++)
             {
                 Assert.Equal(i, UnmanagedMemoryHandle.TotalOutstandingHandles);
-                var h = UnmanagedMemoryHandle.Allocate(42);
+                UnmanagedMemoryHandle h = UnmanagedMemoryHandle.Allocate(42);
                 Assert.Equal(i + 1, UnmanagedMemoryHandle.TotalOutstandingHandles);
                 l.Add(h);
             }
@@ -68,7 +68,7 @@ public class UnmanagedMemoryHandleTests
     [Fact]
     public void Equality_WhenTrue()
     {
-        var h1 = UnmanagedMemoryHandle.Allocate(10);
+        UnmanagedMemoryHandle h1 = UnmanagedMemoryHandle.Allocate(10);
         UnmanagedMemoryHandle h2 = h1;
 
         Assert.True(h1.Equals(h2));
@@ -82,8 +82,8 @@ public class UnmanagedMemoryHandleTests
     [Fact]
     public void Equality_WhenFalse()
     {
-        var h1 = UnmanagedMemoryHandle.Allocate(10);
-        var h2 = UnmanagedMemoryHandle.Allocate(10);
+        UnmanagedMemoryHandle h1 = UnmanagedMemoryHandle.Allocate(10);
+        UnmanagedMemoryHandle h2 = UnmanagedMemoryHandle.Allocate(10);
 
         Assert.False(h1.Equals(h2));
         Assert.False(h2.Equals(h1));
diff --git a/tests/ImageSharp.Tests/Memory/Buffer2DTests.SwapOrCopyContent.cs b/tests/ImageSharp.Tests/Memory/Buffer2DTests.SwapOrCopyContent.cs
index 88c05fdd0e..e17c8c46f7 100644
--- a/tests/ImageSharp.Tests/Memory/Buffer2DTests.SwapOrCopyContent.cs
+++ b/tests/ImageSharp.Tests/Memory/Buffer2DTests.SwapOrCopyContent.cs
@@ -10,7 +10,7 @@ public partial class Buffer2DTests
 {
     public class SwapOrCopyContent
     {
-        private readonly TestMemoryAllocator memoryAllocator = new TestMemoryAllocator();
+        private readonly TestMemoryAllocator memoryAllocator = new();
 
         [Fact]
         public void SwapOrCopyContent_WhenBothAllocated()
@@ -40,8 +40,8 @@ public partial class Buffer2DTests
         [Fact]
         public void SwapOrCopyContent_WhenDestinationIsOwned_ShouldNotSwapInDisposedSourceBuffer()
         {
-            using var destData = MemoryGroup<int>.Wrap(new int[100]);
-            using var dest = new Buffer2D<int>(destData, 10, 10);
+            using MemoryGroup<int> destData = MemoryGroup<int>.Wrap(new int[100]);
+            using Buffer2D<int> dest = new(destData, 10, 10);
 
             using (Buffer2D<int> source = this.memoryAllocator.Allocate2D<int>(10, 10, AllocationOptions.Clean))
             {
@@ -112,11 +112,11 @@ public partial class Buffer2DTests
         [InlineData(true)]
         public void WhenDestIsNotAllocated_SameSize_ShouldCopy(bool sourceIsAllocated)
         {
-            var data = new Rgba32[21];
-            var color = new Rgba32(1, 2, 3, 4);
+            Rgba32[] data = new Rgba32[21];
+            Rgba32 color = new(1, 2, 3, 4);
 
-            using var destOwner = new TestMemoryManager<Rgba32>(data);
-            using var dest = new Buffer2D<Rgba32>(MemoryGroup<Rgba32>.Wrap(destOwner.Memory), 21, 1);
+            using TestMemoryManager<Rgba32> destOwner = new(data);
+            using Buffer2D<Rgba32> dest = new(MemoryGroup<Rgba32>.Wrap(destOwner.Memory), 21, 1);
 
             using Buffer2D<Rgba32> source = this.memoryAllocator.Allocate2D<Rgba32>(21, 1);
 
@@ -136,11 +136,11 @@ public partial class Buffer2DTests
         [InlineData(true)]
         public void WhenDestIsNotMemoryOwner_DifferentSize_Throws(bool sourceIsOwner)
         {
-            var data = new Rgba32[21];
-            var color = new Rgba32(1, 2, 3, 4);
+            Rgba32[] data = new Rgba32[21];
+            Rgba32 color = new(1, 2, 3, 4);
 
-            using var destOwner = new TestMemoryManager<Rgba32>(data);
-            using var dest = new Buffer2D<Rgba32>(MemoryGroup<Rgba32>.Wrap(destOwner.Memory), 21, 1);
+            using TestMemoryManager<Rgba32> destOwner = new(data);
+            using Buffer2D<Rgba32> dest = new(MemoryGroup<Rgba32>.Wrap(destOwner.Memory), 21, 1);
 
             using Buffer2D<Rgba32> source = this.memoryAllocator.Allocate2D<Rgba32>(22, 1);
 
diff --git a/tests/ImageSharp.Tests/Memory/Buffer2DTests.cs b/tests/ImageSharp.Tests/Memory/Buffer2DTests.cs
index 8ba3bf70a2..6dfdd294c7 100644
--- a/tests/ImageSharp.Tests/Memory/Buffer2DTests.cs
+++ b/tests/ImageSharp.Tests/Memory/Buffer2DTests.cs
@@ -24,7 +24,7 @@ public partial class Buffer2DTests
         }
     }
 
-    private TestMemoryAllocator MemoryAllocator { get; } = new TestMemoryAllocator();
+    private TestMemoryAllocator MemoryAllocator { get; } = new();
 
     private const int Big = 99999;
 
@@ -147,7 +147,7 @@ public partial class Buffer2DTests
         const int unpooledBufferSize = 8_000;
 
         int elementSize = sizeof(TestStructs.Foo);
-        var allocator = new UniformUnmanagedMemoryPoolMemoryAllocator(
+        UniformUnmanagedMemoryPoolMemoryAllocator allocator = new(
             sharedPoolThreshold * elementSize,
             poolBufferSize * elementSize,
             maxPoolSize * elementSize,
@@ -155,7 +155,7 @@ public partial class Buffer2DTests
 
         using Buffer2D<TestStructs.Foo> buffer = allocator.Allocate2D<TestStructs.Foo>(width, height);
 
-        var rnd = new Random(42);
+        Random rnd = new(42);
 
         for (int y = 0; y < buffer.Height; y++)
         {
@@ -208,7 +208,7 @@ public partial class Buffer2DTests
         }
     }
 
-    public static TheoryData<int, int, int, int> GetRowSpanY_OutOfRange_Data = new TheoryData<int, int, int, int>()
+    public static TheoryData<int, int, int, int> GetRowSpanY_OutOfRange_Data = new()
     {
         { Big, 10, 8, -1 },
         { Big, 10, 8, 8 },
@@ -227,7 +227,7 @@ public partial class Buffer2DTests
         Assert.True(ex is ArgumentOutOfRangeException || ex is IndexOutOfRangeException);
     }
 
-    public static TheoryData<int, int, int, int, int> Indexer_OutOfRange_Data = new TheoryData<int, int, int, int, int>()
+    public static TheoryData<int, int, int, int, int> Indexer_OutOfRange_Data = new()
     {
         { Big, 10, 8, 1, -1 },
         { Big, 10, 8, 1, 8 },
@@ -284,7 +284,7 @@ public partial class Buffer2DTests
     [InlineData(5, 1, 1, 3, 2)]
     public void CopyColumns(int width, int height, int startIndex, int destIndex, int columnCount)
     {
-        var rnd = new Random(123);
+        Random rnd = new(123);
         using (Buffer2D<float> b = this.MemoryAllocator.Allocate2D<float>(width, height))
         {
             rnd.RandomFill(b.DangerousGetSingleSpan(), 0, 1);
@@ -306,7 +306,7 @@ public partial class Buffer2DTests
     [Fact]
     public void CopyColumns_InvokeMultipleTimes()
     {
-        var rnd = new Random(123);
+        Random rnd = new(123);
         using (Buffer2D<float> b = this.MemoryAllocator.Allocate2D<float>(100, 100))
         {
             rnd.RandomFill(b.DangerousGetSingleSpan(), 0, 1);
@@ -341,9 +341,9 @@ public partial class Buffer2DTests
 
     public static TheoryData<Size> InvalidLengths { get; set; } = new()
     {
-        { new(-1, -1) },
-        { new(32768, 32769) },
-        { new(32769, 32768) }
+        { new Size(-1, -1) },
+        { new Size(32768, 32769) },
+        { new Size(32769, 32768) }
     };
 
     [Theory]
diff --git a/tests/ImageSharp.Tests/Memory/BufferAreaTests.cs b/tests/ImageSharp.Tests/Memory/BufferAreaTests.cs
index 46907b9c0e..be7edbacca 100644
--- a/tests/ImageSharp.Tests/Memory/BufferAreaTests.cs
+++ b/tests/ImageSharp.Tests/Memory/BufferAreaTests.cs
@@ -7,14 +7,14 @@ namespace SixLabors.ImageSharp.Tests.Memory;
 
 public class BufferAreaTests
 {
-    private readonly TestMemoryAllocator memoryAllocator = new TestMemoryAllocator();
+    private readonly TestMemoryAllocator memoryAllocator = new();
 
     [Fact]
     public void Construct()
     {
         using Buffer2D<int> buffer = this.memoryAllocator.Allocate2D<int>(10, 20);
-        var rectangle = new Rectangle(3, 2, 5, 6);
-        var area = new Buffer2DRegion<int>(buffer, rectangle);
+        Rectangle rectangle = new(3, 2, 5, 6);
+        Buffer2DRegion<int> area = new(buffer, rectangle);
 
         Assert.Equal(buffer, area.Buffer);
         Assert.Equal(rectangle, area.Rectangle);
@@ -43,7 +43,7 @@ public class BufferAreaTests
     {
         this.memoryAllocator.BufferCapacityInBytes = sizeof(int) * bufferCapacity;
         using Buffer2D<int> buffer = this.CreateTestBuffer(20, 30);
-        var r = new Rectangle(rx, ry, 5, 6);
+        Rectangle r = new(rx, ry, 5, 6);
 
         Buffer2DRegion<int> region = buffer.GetRegion(r);
 
@@ -62,7 +62,7 @@ public class BufferAreaTests
         this.memoryAllocator.BufferCapacityInBytes = sizeof(int) * bufferCapacity;
 
         using Buffer2D<int> buffer = this.CreateTestBuffer(20, 30);
-        var r = new Rectangle(rx, ry, w, h);
+        Rectangle r = new(rx, ry, w, h);
 
         Buffer2DRegion<int> region = buffer.GetRegion(r);
 
@@ -87,7 +87,7 @@ public class BufferAreaTests
 
         Buffer2DRegion<int> area1 = area0.GetSubRegion(4, 4, 5, 5);
 
-        var expectedRect = new Rectangle(10, 12, 5, 5);
+        Rectangle expectedRect = new(10, 12, 5, 5);
 
         Assert.Equal(buffer, area1.Buffer);
         Assert.Equal(expectedRect, area1.Rectangle);
@@ -120,7 +120,7 @@ public class BufferAreaTests
         this.memoryAllocator.BufferCapacityInBytes = sizeof(int) * bufferCapacity;
 
         using Buffer2D<int> buffer = this.CreateTestBuffer(22, 13);
-        var emptyRow = new int[22];
+        int[] emptyRow = new int[22];
         buffer.GetRegion().Clear();
 
         for (int y = 0; y < 13; y++)
diff --git a/tests/ImageSharp.Tests/Memory/DiscontiguousBuffers/MemoryGroupIndexTests.cs b/tests/ImageSharp.Tests/Memory/DiscontiguousBuffers/MemoryGroupIndexTests.cs
index a49ab77781..4e67df53b1 100644
--- a/tests/ImageSharp.Tests/Memory/DiscontiguousBuffers/MemoryGroupIndexTests.cs
+++ b/tests/ImageSharp.Tests/Memory/DiscontiguousBuffers/MemoryGroupIndexTests.cs
@@ -8,8 +8,8 @@ public class MemoryGroupIndexTests
     [Fact]
     public void Equal()
     {
-        var a = new MemoryGroupIndex(10, 1, 3);
-        var b = new MemoryGroupIndex(10, 1, 3);
+        MemoryGroupIndex a = new(10, 1, 3);
+        MemoryGroupIndex b = new(10, 1, 3);
 
         Assert.True(a.Equals(b));
         Assert.True(a == b);
@@ -21,8 +21,8 @@ public class MemoryGroupIndexTests
     [Fact]
     public void SmallerBufferIndex()
     {
-        var a = new MemoryGroupIndex(10, 3, 3);
-        var b = new MemoryGroupIndex(10, 5, 3);
+        MemoryGroupIndex a = new(10, 3, 3);
+        MemoryGroupIndex b = new(10, 5, 3);
 
         Assert.False(a == b);
         Assert.True(a != b);
@@ -33,8 +33,8 @@ public class MemoryGroupIndexTests
     [Fact]
     public void SmallerElementIndex()
     {
-        var a = new MemoryGroupIndex(10, 3, 3);
-        var b = new MemoryGroupIndex(10, 3, 9);
+        MemoryGroupIndex a = new(10, 3, 3);
+        MemoryGroupIndex b = new(10, 3, 9);
 
         Assert.False(a == b);
         Assert.True(a != b);
@@ -45,7 +45,7 @@ public class MemoryGroupIndexTests
     [Fact]
     public void Increment()
     {
-        var a = new MemoryGroupIndex(10, 3, 3);
+        MemoryGroupIndex a = new(10, 3, 3);
         a += 1;
         Assert.Equal(new MemoryGroupIndex(10, 3, 4), a);
     }
@@ -53,8 +53,8 @@ public class MemoryGroupIndexTests
     [Fact]
     public void Increment_OverflowBuffer()
     {
-        var a = new MemoryGroupIndex(10, 5, 3);
-        var b = new MemoryGroupIndex(10, 5, 9);
+        MemoryGroupIndex a = new(10, 5, 3);
+        MemoryGroupIndex b = new(10, 5, 9);
         a += 8;
         b += 1;
 
diff --git a/tests/ImageSharp.Tests/Memory/DiscontiguousBuffers/MemoryGroupTests.Allocate.cs b/tests/ImageSharp.Tests/Memory/DiscontiguousBuffers/MemoryGroupTests.Allocate.cs
index 4c7de5412c..678a089a85 100644
--- a/tests/ImageSharp.Tests/Memory/DiscontiguousBuffers/MemoryGroupTests.Allocate.cs
+++ b/tests/ImageSharp.Tests/Memory/DiscontiguousBuffers/MemoryGroupTests.Allocate.cs
@@ -59,7 +59,7 @@ public partial class MemoryGroupTests
             this.MemoryAllocator.BufferCapacityInBytes = bufferCapacity;
 
             // Act:
-            using var g = MemoryGroup<T>.Allocate(this.MemoryAllocator, totalLength, bufferAlignment);
+            using MemoryGroup<T> g = MemoryGroup<T>.Allocate(this.MemoryAllocator, totalLength, bufferAlignment);
 
             // Assert:
             ValidateAllocateMemoryGroup(expectedNumberOfBuffers, expectedBufferSize, expectedSizeOfLastBuffer, g);
@@ -83,7 +83,7 @@ public partial class MemoryGroupTests
                 return;
             }
 
-            var pool = new UniformUnmanagedMemoryPool(bufferCapacity, expectedNumberOfBuffers);
+            UniformUnmanagedMemoryPool pool = new(bufferCapacity, expectedNumberOfBuffers);
 
             // Act:
             Assert.True(MemoryGroup<T>.TryAllocate(pool, totalLength, bufferAlignment, AllocationOptions.None, out MemoryGroup<T> g));
@@ -98,7 +98,7 @@ public partial class MemoryGroupTests
         [InlineData(AllocationOptions.Clean)]
         public unsafe void Allocate_FromPool_AllocationOptionsAreApplied(AllocationOptions options)
         {
-            var pool = new UniformUnmanagedMemoryPool(10, 5);
+            UniformUnmanagedMemoryPool pool = new(10, 5);
             UnmanagedMemoryHandle[] buffers = pool.Rent(5);
             foreach (UnmanagedMemoryHandle b in buffers)
             {
@@ -128,7 +128,7 @@ public partial class MemoryGroupTests
             int requestBytes,
             bool shouldSucceed)
         {
-            var pool = new UniformUnmanagedMemoryPool(bufferCapacityBytes, poolCapacity);
+            UniformUnmanagedMemoryPool pool = new(bufferCapacityBytes, poolCapacity);
             int alignmentElements = alignmentBytes / Unsafe.SizeOf<S4>();
             int requestElements = requestBytes / Unsafe.SizeOf<S4>();
 
@@ -194,7 +194,7 @@ public partial class MemoryGroupTests
             HashSet<int> bufferHashes;
 
             int expectedBlockCount = 5;
-            using (var g = MemoryGroup<short>.Allocate(this.MemoryAllocator, 500, 100, allocationOptions))
+            using (MemoryGroup<short> g = MemoryGroup<short>.Allocate(this.MemoryAllocator, 500, 100, allocationOptions))
             {
                 IReadOnlyList<TestMemoryAllocator.AllocationRequest> allocationLog = this.MemoryAllocator.AllocationLog;
                 Assert.Equal(expectedBlockCount, allocationLog.Count);
diff --git a/tests/ImageSharp.Tests/Memory/DiscontiguousBuffers/MemoryGroupTests.CopyTo.cs b/tests/ImageSharp.Tests/Memory/DiscontiguousBuffers/MemoryGroupTests.CopyTo.cs
index 23aaf3c559..c140571fcc 100644
--- a/tests/ImageSharp.Tests/Memory/DiscontiguousBuffers/MemoryGroupTests.CopyTo.cs
+++ b/tests/ImageSharp.Tests/Memory/DiscontiguousBuffers/MemoryGroupTests.CopyTo.cs
@@ -50,7 +50,7 @@ public partial class MemoryGroupTests
         public void GroupToSpan_Success(long totalLength, int bufferLength, int spanLength)
         {
             using MemoryGroup<int> src = this.CreateTestGroup(totalLength, bufferLength, true);
-            var trg = new int[spanLength];
+            int[] trg = new int[spanLength];
             src.CopyTo(trg);
 
             int expected = 1;
@@ -67,7 +67,7 @@ public partial class MemoryGroupTests
         public void GroupToSpan_OutOfRange(long totalLength, int bufferLength, int spanLength)
         {
             using MemoryGroup<int> src = this.CreateTestGroup(totalLength, bufferLength, true);
-            var trg = new int[spanLength];
+            int[] trg = new int[spanLength];
             Assert.ThrowsAny<ArgumentOutOfRangeException>(() => src.CopyTo(trg));
         }
 
@@ -78,7 +78,7 @@ public partial class MemoryGroupTests
         [InlineData(0, 3, 0)]
         public void SpanToGroup_Success(long totalLength, int bufferLength, int spanLength)
         {
-            var src = new int[spanLength];
+            int[] src = new int[spanLength];
             for (int i = 0; i < src.Length; i++)
             {
                 src[i] = i + 1;
@@ -100,7 +100,7 @@ public partial class MemoryGroupTests
         [InlineData(0, 3, 1)]
         public void SpanToGroup_OutOfRange(long totalLength, int bufferLength, int spanLength)
         {
-            var src = new int[spanLength];
+            int[] src = new int[spanLength];
             using MemoryGroup<int> trg = this.CreateTestGroup(totalLength, bufferLength, true);
             Assert.ThrowsAny<ArgumentOutOfRangeException>(() => src.AsSpan().CopyTo(trg));
         }
diff --git a/tests/ImageSharp.Tests/Memory/DiscontiguousBuffers/MemoryGroupTests.cs b/tests/ImageSharp.Tests/Memory/DiscontiguousBuffers/MemoryGroupTests.cs
index 316150c305..fe1867f20c 100644
--- a/tests/ImageSharp.Tests/Memory/DiscontiguousBuffers/MemoryGroupTests.cs
+++ b/tests/ImageSharp.Tests/Memory/DiscontiguousBuffers/MemoryGroupTests.cs
@@ -12,7 +12,7 @@ public partial class MemoryGroupTests : MemoryGroupTestsBase
     [Fact]
     public void IsValid_TrueAfterCreation()
     {
-        using var g = MemoryGroup<byte>.Allocate(this.MemoryAllocator, 10, 100);
+        using MemoryGroup<byte> g = MemoryGroup<byte>.Allocate(this.MemoryAllocator, 10, 100);
 
         Assert.True(g.IsValid);
     }
@@ -20,7 +20,7 @@ public partial class MemoryGroupTests : MemoryGroupTestsBase
     [Fact]
     public void IsValid_FalseAfterDisposal()
     {
-        using var g = MemoryGroup<byte>.Allocate(this.MemoryAllocator, 10, 100);
+        using MemoryGroup<byte> g = MemoryGroup<byte>.Allocate(this.MemoryAllocator, 10, 100);
 
         g.Dispose();
         Assert.False(g.IsValid);
@@ -28,7 +28,7 @@ public partial class MemoryGroupTests : MemoryGroupTestsBase
 
 #pragma warning disable SA1509
     private static readonly TheoryData<int, int, int, int> CopyAndTransformData =
-        new TheoryData<int, int, int, int>()
+        new()
         {
             { 20, 10, 20, 10 },
             { 20, 5, 20, 4 },
@@ -102,10 +102,10 @@ public partial class MemoryGroupTests : MemoryGroupTestsBase
         int[] data0 = { 1, 2, 3, 4 };
         int[] data1 = { 5, 6, 7, 8 };
         int[] data2 = { 9, 10 };
-        using var mgr0 = new TestMemoryManager<int>(data0);
-        using var mgr1 = new TestMemoryManager<int>(data1);
+        using TestMemoryManager<int> mgr0 = new(data0);
+        using TestMemoryManager<int> mgr1 = new(data1);
 
-        using var group = MemoryGroup<int>.Wrap(mgr0.Memory, mgr1.Memory, data2);
+        using MemoryGroup<int> group = MemoryGroup<int>.Wrap(mgr0.Memory, mgr1.Memory, data2);
 
         Assert.Equal(3, group.Count);
         Assert.Equal(4, group.BufferLength);
@@ -124,7 +124,7 @@ public partial class MemoryGroupTests : MemoryGroupTestsBase
         }
     }
 
-    public static TheoryData<long, int, long, int> GetBoundedSlice_SuccessData = new TheoryData<long, int, long, int>()
+    public static TheoryData<long, int, long, int> GetBoundedSlice_SuccessData = new()
     {
         { 300, 100, 110, 80 },
         { 300, 100, 100, 100 },
@@ -153,7 +153,7 @@ public partial class MemoryGroupTests : MemoryGroupTestsBase
         }
     }
 
-    public static TheoryData<long, int, long, int> GetBoundedSlice_ErrorData = new TheoryData<long, int, long, int>()
+    public static TheoryData<long, int, long, int> GetBoundedSlice_ErrorData = new()
     {
         { 300, 100, -1, 91 },
         { 300, 100, 110, 91 },
@@ -217,7 +217,7 @@ public partial class MemoryGroupTests : MemoryGroupTestsBase
         using MemoryGroup<int> group = this.CreateTestGroup(100, 10, true);
         group.Clear();
 
-        var expectedRow = new int[10];
+        int[] expectedRow = new int[10];
         foreach (Memory<int> memory in group)
         {
             Assert.True(memory.Span.SequenceEqual(expectedRow));
diff --git a/tests/ImageSharp.Tests/Memory/DiscontiguousBuffers/MemoryGroupTestsBase.cs b/tests/ImageSharp.Tests/Memory/DiscontiguousBuffers/MemoryGroupTestsBase.cs
index 8fe6ef3ddb..0eaebbfef5 100644
--- a/tests/ImageSharp.Tests/Memory/DiscontiguousBuffers/MemoryGroupTestsBase.cs
+++ b/tests/ImageSharp.Tests/Memory/DiscontiguousBuffers/MemoryGroupTestsBase.cs
@@ -7,7 +7,7 @@ namespace SixLabors.ImageSharp.Tests.Memory.DiscontiguousBuffers;
 
 public abstract class MemoryGroupTestsBase
 {
-    internal readonly TestMemoryAllocator MemoryAllocator = new TestMemoryAllocator();
+    internal readonly TestMemoryAllocator MemoryAllocator = new();
 
     /// <summary>
     /// Create a group, either uninitialized or filled with incrementing numbers starting with 1.
@@ -15,7 +15,7 @@ public abstract class MemoryGroupTestsBase
     internal MemoryGroup<int> CreateTestGroup(long totalLength, int bufferLength, bool fillSequence = false)
     {
         this.MemoryAllocator.BufferCapacityInBytes = bufferLength * sizeof(int);
-        var g = MemoryGroup<int>.Allocate(this.MemoryAllocator, totalLength, bufferLength);
+        MemoryGroup<int> g = MemoryGroup<int>.Allocate(this.MemoryAllocator, totalLength, bufferLength);
 
         if (!fillSequence)
         {
diff --git a/tests/ImageSharp.Tests/Memory/TestStructs.cs b/tests/ImageSharp.Tests/Memory/TestStructs.cs
index ccbee5bd51..bb6a07ec96 100644
--- a/tests/ImageSharp.Tests/Memory/TestStructs.cs
+++ b/tests/ImageSharp.Tests/Memory/TestStructs.cs
@@ -19,7 +19,7 @@ public static class TestStructs
 
         internal static Foo[] CreateArray(int size)
         {
-            var result = new Foo[size];
+            Foo[] result = new Foo[size];
             for (int i = 0; i < size; i++)
             {
                 result[i] = new Foo(i + 1, i + 1);
@@ -70,7 +70,7 @@ public static class TestStructs
 
         internal static AlignedFoo[] CreateArray(int size)
         {
-            var result = new AlignedFoo[size];
+            AlignedFoo[] result = new AlignedFoo[size];
             for (int i = 0; i < size; i++)
             {
                 result[i] = new AlignedFoo(i + 1, i + 1);
diff --git a/tests/ImageSharp.Tests/MemoryAllocatorValidator.cs b/tests/ImageSharp.Tests/MemoryAllocatorValidator.cs
index 252784a7c5..395dfd455f 100644
--- a/tests/ImageSharp.Tests/MemoryAllocatorValidator.cs
+++ b/tests/ImageSharp.Tests/MemoryAllocatorValidator.cs
@@ -38,7 +38,7 @@ public static class MemoryAllocatorValidator
 
     public static TestMemoryDiagnostics MonitorAllocations()
     {
-        var diag = new TestMemoryDiagnostics();
+        TestMemoryDiagnostics diag = new();
         LocalInstance.Value = diag;
         return diag;
     }
diff --git a/tests/ImageSharp.Tests/Metadata/ImageFrameMetadataTests.cs b/tests/ImageSharp.Tests/Metadata/ImageFrameMetadataTests.cs
index cdd6f0cc4f..cee37ca56e 100644
--- a/tests/ImageSharp.Tests/Metadata/ImageFrameMetadataTests.cs
+++ b/tests/ImageSharp.Tests/Metadata/ImageFrameMetadataTests.cs
@@ -45,10 +45,10 @@ public class ImageFrameMetadataTests
         ExifProfile exifProfile = new();
         exifProfile.SetValue(ExifTag.Software, "UnitTest");
         exifProfile.SetValue(ExifTag.Artist, "UnitTest");
-        XmpProfile xmpProfile = new(Array.Empty<byte>());
+        XmpProfile xmpProfile = new([]);
         IccProfile iccProfile = new()
         {
-            Header = new IccProfileHeader()
+            Header = new IccProfileHeader
             {
                 CmmType = "Unittest"
             }
diff --git a/tests/ImageSharp.Tests/Metadata/Profiles/CICP/CicpProfileTests.cs b/tests/ImageSharp.Tests/Metadata/Profiles/CICP/CicpProfileTests.cs
index 76e2d35c45..ff8b034c56 100644
--- a/tests/ImageSharp.Tests/Metadata/Profiles/CICP/CicpProfileTests.cs
+++ b/tests/ImageSharp.Tests/Metadata/Profiles/CICP/CicpProfileTests.cs
@@ -25,10 +25,10 @@ public class CicpProfileTests
     public void WritingPng_PreservesCicpProfile()
     {
         // arrange
-        using var image = new Image<Rgba32>(1, 1);
-        var original = CreateCicpProfile();
+        using Image<Rgba32> image = new(1, 1);
+        CicpProfile original = CreateCicpProfile();
         image.Metadata.CicpProfile = original;
-        var encoder = new PngEncoder();
+        PngEncoder encoder = new();
 
         // act
         using Image<Rgba32> reloadedImage = WriteAndRead(image, encoder);
@@ -49,7 +49,7 @@ public class CicpProfileTests
 
     private static CicpProfile CreateCicpProfile()
     {
-        var profile = new CicpProfile()
+        CicpProfile profile = new()
         {
             ColorPrimaries = CicpColorPrimaries.ItuRBt2020_2,
             TransferCharacteristics = CicpTransferCharacteristics.SmpteSt2084,
@@ -70,7 +70,7 @@ public class CicpProfileTests
 
     private static Image<Rgba32> WriteAndRead(Image<Rgba32> image, IImageEncoder encoder)
     {
-        using (var memStream = new MemoryStream())
+        using (MemoryStream memStream = new())
         {
             image.Save(memStream, encoder);
             image.Dispose();
diff --git a/tests/ImageSharp.Tests/Metadata/Profiles/Exif/ExifProfileTests.cs b/tests/ImageSharp.Tests/Metadata/Profiles/Exif/ExifProfileTests.cs
index 8072bebd77..c098ace09a 100644
--- a/tests/ImageSharp.Tests/Metadata/Profiles/Exif/ExifProfileTests.cs
+++ b/tests/ImageSharp.Tests/Metadata/Profiles/Exif/ExifProfileTests.cs
@@ -82,13 +82,13 @@ public class ExifProfileTests
     public void ConstructorEmpty()
     {
         new ExifProfile(null);
-        new ExifProfile(Array.Empty<byte>());
+        new ExifProfile([]);
     }
 
     [Fact]
     public void EmptyWriter()
     {
-        var profile = new ExifProfile() { Parts = ExifParts.GpsTags };
+        ExifProfile profile = new() { Parts = ExifParts.GpsTags };
         profile.SetValue(ExifTag.Copyright, "Copyright text");
 
         byte[] bytes = profile.ToByteArray();
@@ -120,14 +120,14 @@ public class ExifProfileTests
     [InlineData(TestImageWriteFormat.WebpLossy)]
     public void WriteFraction(TestImageWriteFormat imageFormat)
     {
-        using var memStream = new MemoryStream();
+        using MemoryStream memStream = new();
         double exposureTime = 1.0 / 1600;
 
         ExifProfile profile = GetExifProfile();
 
         profile.SetValue(ExifTag.ExposureTime, new Rational(exposureTime));
 
-        var image = new Image<Rgba32>(1, 1);
+        Image<Rgba32> image = new(1, 1);
         image.Metadata.ExifProfile = profile;
 
         image = WriteAndRead(image, imageFormat);
@@ -231,7 +231,7 @@ public class ExifProfileTests
         IExifValue<Rational[]> referenceBlackWhite = image.Metadata.ExifProfile.GetValue(ExifTag.ReferenceBlackWhite);
         Assert.Null(referenceBlackWhite.Value);
 
-        var expectedLatitude = new Rational[] { new Rational(12.3), new Rational(4.56), new Rational(789.0) };
+        Rational[] expectedLatitude = [new(12.3), new(4.56), new(789.0)];
         image.Metadata.ExifProfile.SetValue(ExifTag.GPSLatitude, expectedLatitude);
 
         IExifValue<Rational[]> latitude = image.Metadata.ExifProfile.GetValue(ExifTag.GPSLatitude);
@@ -308,11 +308,11 @@ public class ExifProfileTests
     [Fact]
     public void Syncs()
     {
-        var exifProfile = new ExifProfile();
+        ExifProfile exifProfile = new();
         exifProfile.SetValue(ExifTag.XResolution, new Rational(200));
         exifProfile.SetValue(ExifTag.YResolution, new Rational(300));
 
-        var metaData = new ImageMetadata
+        ImageMetadata metaData = new()
         {
             ExifProfile = exifProfile,
             HorizontalResolution = 200,
@@ -362,19 +362,19 @@ public class ExifProfileTests
     [Fact]
     public void ReadWriteLargeProfileJpg()
     {
-        ExifTag<string>[] tags = { ExifTag.Software, ExifTag.Copyright, ExifTag.Model, ExifTag.ImageDescription };
+        ExifTag<string>[] tags = [ExifTag.Software, ExifTag.Copyright, ExifTag.Model, ExifTag.ImageDescription];
         foreach (ExifTag<string> tag in tags)
         {
             // Arrange
-            var junk = new StringBuilder();
+            StringBuilder junk = new();
             for (int i = 0; i < 65600; i++)
             {
                 junk.Append('a');
             }
 
-            var image = new Image<Rgba32>(100, 100);
+            Image<Rgba32> image = new(100, 100);
             ExifProfile expectedProfile = CreateExifProfile();
-            var expectedProfileTags = expectedProfile.Values.Select(x => x.Tag).ToList();
+            List<ExifTag> expectedProfileTags = expectedProfile.Values.Select(x => x.Tag).ToList();
             expectedProfile.SetValue(tag, junk.ToString());
             image.Metadata.ExifProfile = expectedProfile;
 
@@ -437,7 +437,7 @@ public class ExifProfileTests
         byte[] bytes = profile.ToByteArray();
         Assert.Equal(531, bytes.Length);
 
-        var profile2 = new ExifProfile(bytes);
+        ExifProfile profile2 = new(bytes);
         Assert.Equal(25, profile2.Values.Count);
     }
 
@@ -449,7 +449,7 @@ public class ExifProfileTests
     public void WritingImagePreservesExifProfile(TestImageWriteFormat imageFormat)
     {
         // Arrange
-        var image = new Image<Rgba32>(1, 1);
+        Image<Rgba32> image = new(1, 1);
         image.Metadata.ExifProfile = CreateExifProfile();
 
         // Act
@@ -472,11 +472,11 @@ public class ExifProfileTests
         // Arrange
         byte[] exifBytesWithoutExifCode = ExifConstants.LittleEndianByteOrderMarker.ToArray();
         ExifProfile expectedProfile = CreateExifProfile();
-        var expectedProfileTags = expectedProfile.Values.Select(x => x.Tag).ToList();
+        List<ExifTag> expectedProfileTags = expectedProfile.Values.Select(x => x.Tag).ToList();
 
         // Act
         byte[] actualBytes = expectedProfile.ToByteArray();
-        var actualProfile = new ExifProfile(actualBytes);
+        ExifProfile actualProfile = new(actualBytes);
 
         // Assert
         Assert.NotNull(actualBytes);
@@ -492,7 +492,7 @@ public class ExifProfileTests
 
     private static ExifProfile CreateExifProfile()
     {
-        var profile = new ExifProfile();
+        ExifProfile profile = new();
 
         foreach (KeyValuePair<ExifTag, object> exifProfileValue in TestProfileValues)
         {
@@ -505,7 +505,7 @@ public class ExifProfileTests
     [Fact]
     public void IfdStructure()
     {
-        var exif = new ExifProfile();
+        ExifProfile exif = new();
         exif.SetValue(ExifTag.XPAuthor, "Dan Petitt");
 
         Span<byte> actualBytes = exif.ToByteArray();
@@ -547,7 +547,7 @@ public class ExifProfileTests
 
     private static Image<Rgba32> WriteAndReadJpeg(Image<Rgba32> image)
     {
-        using var memStream = new MemoryStream();
+        using MemoryStream memStream = new();
         image.SaveAsJpeg(memStream);
         image.Dispose();
 
@@ -557,7 +557,7 @@ public class ExifProfileTests
 
     private static Image<Rgba32> WriteAndReadPng(Image<Rgba32> image)
     {
-        using var memStream = new MemoryStream();
+        using MemoryStream memStream = new();
         image.SaveAsPng(memStream);
         image.Dispose();
 
@@ -567,8 +567,8 @@ public class ExifProfileTests
 
     private static Image<Rgba32> WriteAndReadWebp(Image<Rgba32> image, WebpFileFormatType fileFormat)
     {
-        using var memStream = new MemoryStream();
-        image.SaveAsWebp(memStream, new WebpEncoder() { FileFormat = fileFormat });
+        using MemoryStream memStream = new();
+        image.SaveAsWebp(memStream, new WebpEncoder { FileFormat = fileFormat });
         image.Dispose();
 
         memStream.Position = 0;
diff --git a/tests/ImageSharp.Tests/Metadata/Profiles/Exif/ExifReaderTests.cs b/tests/ImageSharp.Tests/Metadata/Profiles/Exif/ExifReaderTests.cs
index 8fe19b37de..983ff44937 100644
--- a/tests/ImageSharp.Tests/Metadata/Profiles/Exif/ExifReaderTests.cs
+++ b/tests/ImageSharp.Tests/Metadata/Profiles/Exif/ExifReaderTests.cs
@@ -11,7 +11,7 @@ public class ExifReaderTests
     [Fact]
     public void Read_DataIsEmpty_ReturnsEmptyCollection()
     {
-        var reader = new ExifReader(Array.Empty<byte>());
+        ExifReader reader = new(Array.Empty<byte>());
 
         IList<IExifValue> result = reader.ReadValues();
 
@@ -21,7 +21,7 @@ public class ExifReaderTests
     [Fact]
     public void Read_DataIsMinimal_ReturnsEmptyCollection()
     {
-        var reader = new ExifReader(new byte[] { 69, 120, 105, 102, 0, 0 });
+        ExifReader reader = new(new byte[] { 69, 120, 105, 102, 0, 0 });
 
         IList<IExifValue> result = reader.ReadValues();
 
diff --git a/tests/ImageSharp.Tests/Metadata/Profiles/Exif/ExifTagDescriptionAttributeTests.cs b/tests/ImageSharp.Tests/Metadata/Profiles/Exif/ExifTagDescriptionAttributeTests.cs
index 1154b3439c..3f13afa6fc 100644
--- a/tests/ImageSharp.Tests/Metadata/Profiles/Exif/ExifTagDescriptionAttributeTests.cs
+++ b/tests/ImageSharp.Tests/Metadata/Profiles/Exif/ExifTagDescriptionAttributeTests.cs
@@ -12,7 +12,7 @@ public class ExifTagDescriptionAttributeTests
     [Fact]
     public void TestExifTag()
     {
-        var exifProfile = new ExifProfile();
+        ExifProfile exifProfile = new();
 
         exifProfile.SetValue(ExifTag.ResolutionUnit, (ushort)1);
         IExifValue value = exifProfile.GetValue(ExifTag.ResolutionUnit);
diff --git a/tests/ImageSharp.Tests/Metadata/Profiles/Exif/Values/ExifValuesTests.cs b/tests/ImageSharp.Tests/Metadata/Profiles/Exif/Values/ExifValuesTests.cs
index 99cafa8960..d7d6741baf 100644
--- a/tests/ImageSharp.Tests/Metadata/Profiles/Exif/Values/ExifValuesTests.cs
+++ b/tests/ImageSharp.Tests/Metadata/Profiles/Exif/Values/ExifValuesTests.cs
@@ -9,14 +9,14 @@ namespace SixLabors.ImageSharp.Tests.Metadata.Profiles.Exif.Values;
 [Trait("Profile", "Exif")]
 public class ExifValuesTests
 {
-    public static TheoryData<ExifTag> ByteTags => new TheoryData<ExifTag>
+    public static TheoryData<ExifTag> ByteTags => new()
     {
         { ExifTag.FaxProfile },
         { ExifTag.ModeNumber },
         { ExifTag.GPSAltitudeRef }
     };
 
-    public static TheoryData<ExifTag> ByteArrayTags => new TheoryData<ExifTag>
+    public static TheoryData<ExifTag> ByteArrayTags => new()
     {
         { ExifTag.ClipPath },
         { ExifTag.VersionYear },
@@ -26,7 +26,7 @@ public class ExifValuesTests
         { ExifTag.GPSVersionID },
     };
 
-    public static TheoryData<ExifTag> DoubleArrayTags => new TheoryData<ExifTag>
+    public static TheoryData<ExifTag> DoubleArrayTags => new()
     {
         { ExifTag.PixelScale },
         { ExifTag.IntergraphMatrix },
@@ -34,7 +34,7 @@ public class ExifValuesTests
         { ExifTag.ModelTransform }
     };
 
-    public static TheoryData<ExifTag> LongTags => new TheoryData<ExifTag>
+    public static TheoryData<ExifTag> LongTags => new()
     {
         { ExifTag.SubfileType },
         { ExifTag.SubIFDOffset },
@@ -59,7 +59,7 @@ public class ExifValuesTests
         { ExifTag.ImageNumber },
     };
 
-    public static TheoryData<ExifTag> LongArrayTags => new TheoryData<ExifTag>
+    public static TheoryData<ExifTag> LongArrayTags => new()
     {
         { ExifTag.FreeOffsets },
         { ExifTag.FreeByteCounts },
@@ -73,7 +73,7 @@ public class ExifValuesTests
         { ExifTag.IntergraphRegisters }
     };
 
-    public static TheoryData<ExifTag> NumberTags => new TheoryData<ExifTag>
+    public static TheoryData<ExifTag> NumberTags => new()
     {
         { ExifTag.ImageWidth },
         { ExifTag.ImageLength },
@@ -85,7 +85,7 @@ public class ExifValuesTests
         { ExifTag.PixelYDimension }
     };
 
-    public static TheoryData<ExifTag> NumberArrayTags => new TheoryData<ExifTag>
+    public static TheoryData<ExifTag> NumberArrayTags => new()
     {
         { ExifTag.StripOffsets },
         { ExifTag.StripByteCounts },
@@ -94,7 +94,7 @@ public class ExifValuesTests
         { ExifTag.ImageLayer }
     };
 
-    public static TheoryData<ExifTag> RationalTags => new TheoryData<ExifTag>
+    public static TheoryData<ExifTag> RationalTags => new()
     {
         { ExifTag.XPosition },
         { ExifTag.YPosition },
@@ -131,7 +131,7 @@ public class ExifValuesTests
         { ExifTag.GPSHPositioningError },
     };
 
-    public static TheoryData<ExifTag> RationalArrayTags => new TheoryData<ExifTag>
+    public static TheoryData<ExifTag> RationalArrayTags => new()
     {
         { ExifTag.WhitePoint },
         { ExifTag.PrimaryChromaticities },
@@ -145,7 +145,7 @@ public class ExifValuesTests
         { ExifTag.LensSpecification }
     };
 
-    public static TheoryData<ExifTag> ShortTags => new TheoryData<ExifTag>
+    public static TheoryData<ExifTag> ShortTags => new()
     {
         { ExifTag.OldSubfileType },
         { ExifTag.Compression },
@@ -196,7 +196,7 @@ public class ExifValuesTests
         { ExifTag.GPSDifferential }
     };
 
-    public static TheoryData<ExifTag> ShortArrayTags => new TheoryData<ExifTag>
+    public static TheoryData<ExifTag> ShortArrayTags => new()
     {
         { ExifTag.BitsPerSample },
         { ExifTag.MinSampleValue },
@@ -220,7 +220,7 @@ public class ExifValuesTests
         { ExifTag.SubjectLocation }
     };
 
-    public static TheoryData<ExifTag> SignedRationalTags => new TheoryData<ExifTag>
+    public static TheoryData<ExifTag> SignedRationalTags => new()
     {
         { ExifTag.ShutterSpeedValue },
         { ExifTag.BrightnessValue },
@@ -230,17 +230,17 @@ public class ExifValuesTests
         { ExifTag.CameraElevationAngle }
     };
 
-    public static TheoryData<ExifTag> SignedRationalArrayTags => new TheoryData<ExifTag>
+    public static TheoryData<ExifTag> SignedRationalArrayTags => new()
     {
         { ExifTag.Decode }
     };
 
-    public static TheoryData<ExifTag> SignedShortArrayTags => new TheoryData<ExifTag>
+    public static TheoryData<ExifTag> SignedShortArrayTags => new()
     {
         { ExifTag.TimeZoneOffset }
     };
 
-    public static TheoryData<ExifTag> StringTags => new TheoryData<ExifTag>
+    public static TheoryData<ExifTag> StringTags => new()
     {
         { ExifTag.ImageDescription },
         { ExifTag.Make },
@@ -298,13 +298,13 @@ public class ExifValuesTests
         { ExifTag.GPSDateStamp },
     };
 
-    public static TheoryData<ExifTag> UndefinedTags => new TheoryData<ExifTag>
+    public static TheoryData<ExifTag> UndefinedTags => new()
     {
         { ExifTag.FileSource },
         { ExifTag.SceneType }
     };
 
-    public static TheoryData<ExifTag> UndefinedArrayTags => new TheoryData<ExifTag>
+    public static TheoryData<ExifTag> UndefinedArrayTags => new()
     {
         { ExifTag.JPEGTables },
         { ExifTag.OECF },
@@ -320,14 +320,14 @@ public class ExifValuesTests
         { ExifTag.ImageSourceData },
     };
 
-    public static TheoryData<ExifTag> EncodedStringTags => new TheoryData<ExifTag>
+    public static TheoryData<ExifTag> EncodedStringTags => new()
     {
         { ExifTag.UserComment },
         { ExifTag.GPSProcessingMethod },
         { ExifTag.GPSAreaInformation }
     };
 
-    public static TheoryData<ExifTag> Ucs2StringTags => new TheoryData<ExifTag>
+    public static TheoryData<ExifTag> Ucs2StringTags => new()
     {
         { ExifTag.XPTitle },
         { ExifTag.XPComment },
@@ -347,7 +347,7 @@ public class ExifValuesTests
         Assert.True(value.TrySetValue((int)expected));
         Assert.True(value.TrySetValue(expected));
 
-        var typed = (ExifByte)value;
+        ExifByte typed = (ExifByte)value;
         Assert.Equal(expected, typed.Value);
     }
 
@@ -355,13 +355,13 @@ public class ExifValuesTests
     [MemberData(nameof(ByteArrayTags))]
     public void ExifByteArrayTests(ExifTag tag)
     {
-        byte[] expected = new[] { byte.MaxValue };
+        byte[] expected = [byte.MaxValue];
         ExifValue value = ExifValues.Create(tag);
 
         Assert.False(value.TrySetValue(expected.ToString()));
         Assert.True(value.TrySetValue(expected));
 
-        var typed = (ExifByteArray)value;
+        ExifByteArray typed = (ExifByteArray)value;
         Assert.Equal(expected, typed.Value);
     }
 
@@ -369,13 +369,13 @@ public class ExifValuesTests
     [MemberData(nameof(DoubleArrayTags))]
     public void ExifDoubleArrayTests(ExifTag tag)
     {
-        double[] expected = new[] { double.MaxValue };
+        double[] expected = [double.MaxValue];
         ExifValue value = ExifValues.Create(tag);
 
         Assert.False(value.TrySetValue(expected.ToString()));
         Assert.True(value.TrySetValue(expected));
 
-        var typed = (ExifDoubleArray)value;
+        ExifDoubleArray typed = (ExifDoubleArray)value;
         Assert.Equal(expected, typed.Value);
     }
 
@@ -389,7 +389,7 @@ public class ExifValuesTests
         Assert.False(value.TrySetValue(expected.ToString()));
         Assert.True(value.TrySetValue(expected));
 
-        var typed = (ExifLong)value;
+        ExifLong typed = (ExifLong)value;
         Assert.Equal(expected, typed.Value);
     }
 
@@ -397,13 +397,13 @@ public class ExifValuesTests
     [MemberData(nameof(LongArrayTags))]
     public void ExifLongArrayTests(ExifTag tag)
     {
-        uint[] expected = new[] { uint.MaxValue };
+        uint[] expected = [uint.MaxValue];
         ExifValue value = ExifValues.Create(tag);
 
         Assert.False(value.TrySetValue(expected.ToString()));
         Assert.True(value.TrySetValue(expected));
 
-        var typed = (ExifLongArray)value;
+        ExifLongArray typed = (ExifLongArray)value;
         Assert.Equal(expected, typed.Value);
     }
 
@@ -447,7 +447,7 @@ public class ExifValuesTests
         Assert.True(value.TrySetValue((int)expected));
         Assert.True(value.TrySetValue(expected));
 
-        var typed = (ExifNumber)value;
+        ExifNumber typed = (ExifNumber)value;
         Assert.Equal(expected, typed.Value);
 
         typed.Value = ushort.MaxValue + 1;
@@ -458,13 +458,13 @@ public class ExifValuesTests
     [MemberData(nameof(NumberArrayTags))]
     public void ExifNumberArrayTests(ExifTag tag)
     {
-        Number[] expected = new[] { new Number(uint.MaxValue) };
+        Number[] expected = [new Number(uint.MaxValue)];
         ExifValue value = ExifValues.Create(tag);
 
         Assert.False(value.TrySetValue(expected.ToString()));
         Assert.True(value.TrySetValue(expected));
 
-        var typed = (ExifNumberArray)value;
+        ExifNumberArray typed = (ExifNumberArray)value;
         Assert.Equal(expected, typed.Value);
 
         Assert.True(value.TrySetValue(int.MaxValue));
@@ -481,14 +481,14 @@ public class ExifValuesTests
     [MemberData(nameof(RationalTags))]
     public void ExifRationalTests(ExifTag tag)
     {
-        var expected = new Rational(21, 42);
+        Rational expected = new(21, 42);
         ExifValue value = ExifValues.Create(tag);
 
         Assert.False(value.TrySetValue(expected.ToString()));
         Assert.True(value.TrySetValue(new SignedRational(expected.ToDouble())));
         Assert.True(value.TrySetValue(expected));
 
-        var typed = (ExifRational)value;
+        ExifRational typed = (ExifRational)value;
         Assert.Equal(expected, typed.Value);
     }
 
@@ -496,13 +496,13 @@ public class ExifValuesTests
     [MemberData(nameof(RationalArrayTags))]
     public void ExifRationalArrayTests(ExifTag tag)
     {
-        Rational[] expected = new[] { new Rational(21, 42) };
+        Rational[] expected = [new Rational(21, 42)];
         ExifValue value = ExifValues.Create(tag);
 
         Assert.False(value.TrySetValue(expected.ToString()));
         Assert.True(value.TrySetValue(expected));
 
-        var typed = (ExifRationalArray)value;
+        ExifRationalArray typed = (ExifRationalArray)value;
         Assert.Equal(expected, typed.Value);
     }
 
@@ -518,7 +518,7 @@ public class ExifValuesTests
         Assert.True(value.TrySetValue((short)expected));
         Assert.True(value.TrySetValue(expected));
 
-        var typed = (ExifShort)value;
+        ExifShort typed = (ExifShort)value;
         Assert.Equal(expected, typed.Value);
     }
 
@@ -526,13 +526,13 @@ public class ExifValuesTests
     [MemberData(nameof(ShortArrayTags))]
     public void ExifShortArrayTests(ExifTag tag)
     {
-        ushort[] expected = new[] { ushort.MaxValue };
+        ushort[] expected = [ushort.MaxValue];
         ExifValue value = ExifValues.Create(tag);
 
         Assert.False(value.TrySetValue(expected.ToString()));
         Assert.True(value.TrySetValue(expected));
 
-        var typed = (ExifShortArray)value;
+        ExifShortArray typed = (ExifShortArray)value;
         Assert.Equal(expected, typed.Value);
     }
 
@@ -540,13 +540,13 @@ public class ExifValuesTests
     [MemberData(nameof(SignedRationalTags))]
     public void ExifSignedRationalTests(ExifTag tag)
     {
-        var expected = new SignedRational(21, 42);
+        SignedRational expected = new(21, 42);
         ExifValue value = ExifValues.Create(tag);
 
         Assert.False(value.TrySetValue(expected.ToString()));
         Assert.True(value.TrySetValue(expected));
 
-        var typed = (ExifSignedRational)value;
+        ExifSignedRational typed = (ExifSignedRational)value;
         Assert.Equal(expected, typed.Value);
     }
 
@@ -554,13 +554,13 @@ public class ExifValuesTests
     [MemberData(nameof(SignedRationalArrayTags))]
     public void ExifSignedRationalArrayTests(ExifTag tag)
     {
-        SignedRational[] expected = new[] { new SignedRational(21, 42) };
+        SignedRational[] expected = [new SignedRational(21, 42)];
         ExifValue value = ExifValues.Create(tag);
 
         Assert.False(value.TrySetValue(expected.ToString()));
         Assert.True(value.TrySetValue(expected));
 
-        var typed = (ExifSignedRationalArray)value;
+        ExifSignedRationalArray typed = (ExifSignedRationalArray)value;
         Assert.Equal(expected, typed.Value);
     }
 
@@ -569,13 +569,13 @@ public class ExifValuesTests
     [MemberData(nameof(SignedShortArrayTags))]
     public void ExifSignedShortArrayTests(ExifTag tag)
     {
-        short[] expected = new short[] { 21, 42 };
+        short[] expected = [21, 42];
         ExifValue value = ExifValues.Create(tag);
 
         Assert.False(value.TrySetValue(expected.ToString()));
         Assert.True(value.TrySetValue(expected));
 
-        var typed = (ExifSignedShortArray)value;
+        ExifSignedShortArray typed = (ExifSignedShortArray)value;
         Assert.Equal(expected, typed.Value);
     }
 
@@ -589,7 +589,7 @@ public class ExifValuesTests
         Assert.False(value.TrySetValue(0M));
         Assert.True(value.TrySetValue(expected));
 
-        var typed = (ExifString)value;
+        ExifString typed = (ExifString)value;
         Assert.Equal(expected, typed.Value);
     }
 
@@ -604,7 +604,7 @@ public class ExifValuesTests
         Assert.True(value.TrySetValue((int)expected));
         Assert.True(value.TrySetValue(expected));
 
-        var typed = (ExifByte)value;
+        ExifByte typed = (ExifByte)value;
         Assert.Equal(expected, typed.Value);
     }
 
@@ -612,13 +612,13 @@ public class ExifValuesTests
     [MemberData(nameof(UndefinedArrayTags))]
     public void ExifUndefinedArrayTests(ExifTag tag)
     {
-        byte[] expected = new[] { byte.MaxValue };
+        byte[] expected = [byte.MaxValue];
         ExifValue value = ExifValues.Create(tag);
 
         Assert.False(value.TrySetValue(expected.ToString()));
         Assert.True(value.TrySetValue(expected));
 
-        var typed = (ExifByteArray)value;
+        ExifByteArray typed = (ExifByteArray)value;
         Assert.Equal(expected, typed.Value);
     }
 
@@ -628,18 +628,18 @@ public class ExifValuesTests
     {
         foreach (object code in Enum.GetValues(typeof(EncodedString.CharacterCode)))
         {
-            var charCode = (EncodedString.CharacterCode)code;
+            EncodedString.CharacterCode charCode = (EncodedString.CharacterCode)code;
 
             Assert.Equal(ExifEncodedStringHelpers.CharacterCodeBytesLength, ExifEncodedStringHelpers.GetCodeBytes(charCode).Length);
 
             const string expectedText = "test string";
-            var expected = new EncodedString(charCode, expectedText);
+            EncodedString expected = new(charCode, expectedText);
             ExifValue value = ExifValues.Create(tag);
 
             Assert.False(value.TrySetValue(123));
             Assert.True(value.TrySetValue(expected));
 
-            var typed = (ExifEncodedString)value;
+            ExifEncodedString typed = (ExifEncodedString)value;
             Assert.Equal(expected, typed.Value);
             Assert.Equal(expectedText, (string)typed.Value);
             Assert.Equal(charCode, typed.Value.Code);
@@ -656,7 +656,7 @@ public class ExifValuesTests
         Assert.False(value.TrySetValue(123));
         Assert.True(value.TrySetValue(expected));
 
-        var typed = (ExifUcs2String)value;
+        ExifUcs2String typed = (ExifUcs2String)value;
         Assert.Equal(expected, typed.Value);
 
         Assert.True(value.TrySetValue(Encoding.GetEncoding("UCS-2").GetBytes(expected)));
diff --git a/tests/ImageSharp.Tests/Metadata/Profiles/ICC/DataReader/IccDataReaderCurvesTests.cs b/tests/ImageSharp.Tests/Metadata/Profiles/ICC/DataReader/IccDataReaderCurvesTests.cs
index 73ae46c2c9..86c6a5e9f2 100644
--- a/tests/ImageSharp.Tests/Metadata/Profiles/ICC/DataReader/IccDataReaderCurvesTests.cs
+++ b/tests/ImageSharp.Tests/Metadata/Profiles/ICC/DataReader/IccDataReaderCurvesTests.cs
@@ -2,6 +2,7 @@
 // Licensed under the Six Labors Split License.
 
 using SixLabors.ImageSharp.Metadata.Profiles.Icc;
+using SixLabors.ImageSharp.Tests.TestDataIcc;
 
 namespace SixLabors.ImageSharp.Tests.Metadata.Profiles.ICC.DataReader;
 
diff --git a/tests/ImageSharp.Tests/Metadata/Profiles/ICC/DataReader/IccDataReaderLutTests.cs b/tests/ImageSharp.Tests/Metadata/Profiles/ICC/DataReader/IccDataReaderLutTests.cs
index 63585a3bd4..a686d44872 100644
--- a/tests/ImageSharp.Tests/Metadata/Profiles/ICC/DataReader/IccDataReaderLutTests.cs
+++ b/tests/ImageSharp.Tests/Metadata/Profiles/ICC/DataReader/IccDataReaderLutTests.cs
@@ -2,6 +2,7 @@
 // Licensed under the Six Labors Split License.
 
 using SixLabors.ImageSharp.Metadata.Profiles.Icc;
+using SixLabors.ImageSharp.Tests.TestDataIcc;
 
 namespace SixLabors.ImageSharp.Tests.Metadata.Profiles.ICC.DataReader;
 
diff --git a/tests/ImageSharp.Tests/Metadata/Profiles/ICC/DataReader/IccDataReaderMatrixTests.cs b/tests/ImageSharp.Tests/Metadata/Profiles/ICC/DataReader/IccDataReaderMatrixTests.cs
index b81395bb2e..5ef102cd93 100644
--- a/tests/ImageSharp.Tests/Metadata/Profiles/ICC/DataReader/IccDataReaderMatrixTests.cs
+++ b/tests/ImageSharp.Tests/Metadata/Profiles/ICC/DataReader/IccDataReaderMatrixTests.cs
@@ -2,6 +2,7 @@
 // Licensed under the Six Labors Split License.
 
 using SixLabors.ImageSharp.Metadata.Profiles.Icc;
+using SixLabors.ImageSharp.Tests.TestDataIcc;
 
 namespace SixLabors.ImageSharp.Tests.Metadata.Profiles.ICC.DataReader;
 
@@ -9,7 +10,7 @@ namespace SixLabors.ImageSharp.Tests.Metadata.Profiles.ICC.DataReader;
 public class IccDataReaderMatrixTests
 {
     [Theory]
-    [MemberData(nameof(IccTestDataMatrix.Matrix2D_FloatArrayTestData), MemberType = typeof(IccTestDataMatrix))]
+    [MemberData(nameof(IccTestDataMatrix.Matrix2DFloatArrayTestData), MemberType = typeof(IccTestDataMatrix))]
     public void ReadMatrix2D(byte[] data, int xCount, int yCount, bool isSingle, float[,] expected)
     {
         IccDataReader reader = CreateReader(data);
@@ -20,7 +21,7 @@ public class IccDataReaderMatrixTests
     }
 
     [Theory]
-    [MemberData(nameof(IccTestDataMatrix.Matrix1D_ArrayTestData), MemberType = typeof(IccTestDataMatrix))]
+    [MemberData(nameof(IccTestDataMatrix.Matrix1DArrayTestData), MemberType = typeof(IccTestDataMatrix))]
     public void ReadMatrix1D(byte[] data, int yCount, bool isSingle, float[] expected)
     {
         IccDataReader reader = CreateReader(data);
@@ -30,8 +31,5 @@ public class IccDataReaderMatrixTests
         Assert.Equal(expected, output);
     }
 
-    private static IccDataReader CreateReader(byte[] data)
-    {
-        return new IccDataReader(data);
-    }
+    private static IccDataReader CreateReader(byte[] data) => new(data);
 }
diff --git a/tests/ImageSharp.Tests/Metadata/Profiles/ICC/DataReader/IccDataReaderMultiProcessElementTests.cs b/tests/ImageSharp.Tests/Metadata/Profiles/ICC/DataReader/IccDataReaderMultiProcessElementTests.cs
index 9023b1b723..930665a07c 100644
--- a/tests/ImageSharp.Tests/Metadata/Profiles/ICC/DataReader/IccDataReaderMultiProcessElementTests.cs
+++ b/tests/ImageSharp.Tests/Metadata/Profiles/ICC/DataReader/IccDataReaderMultiProcessElementTests.cs
@@ -2,6 +2,7 @@
 // Licensed under the Six Labors Split License.
 
 using SixLabors.ImageSharp.Metadata.Profiles.Icc;
+using SixLabors.ImageSharp.Tests.TestDataIcc;
 
 namespace SixLabors.ImageSharp.Tests.Metadata.Profiles.ICC.DataReader;
 
diff --git a/tests/ImageSharp.Tests/Metadata/Profiles/ICC/DataReader/IccDataReaderNonPrimitivesTests.cs b/tests/ImageSharp.Tests/Metadata/Profiles/ICC/DataReader/IccDataReaderNonPrimitivesTests.cs
index 91294a3dab..ee0464bb23 100644
--- a/tests/ImageSharp.Tests/Metadata/Profiles/ICC/DataReader/IccDataReaderNonPrimitivesTests.cs
+++ b/tests/ImageSharp.Tests/Metadata/Profiles/ICC/DataReader/IccDataReaderNonPrimitivesTests.cs
@@ -3,6 +3,7 @@
 
 using System.Numerics;
 using SixLabors.ImageSharp.Metadata.Profiles.Icc;
+using SixLabors.ImageSharp.Tests.TestDataIcc;
 
 namespace SixLabors.ImageSharp.Tests.Metadata.Profiles.ICC.DataReader;
 
diff --git a/tests/ImageSharp.Tests/Metadata/Profiles/ICC/DataReader/IccDataReaderPrimitivesTests.cs b/tests/ImageSharp.Tests/Metadata/Profiles/ICC/DataReader/IccDataReaderPrimitivesTests.cs
index b6135cd197..9c5be4c675 100644
--- a/tests/ImageSharp.Tests/Metadata/Profiles/ICC/DataReader/IccDataReaderPrimitivesTests.cs
+++ b/tests/ImageSharp.Tests/Metadata/Profiles/ICC/DataReader/IccDataReaderPrimitivesTests.cs
@@ -2,6 +2,7 @@
 // Licensed under the Six Labors Split License.
 
 using SixLabors.ImageSharp.Metadata.Profiles.Icc;
+using SixLabors.ImageSharp.Tests.TestDataIcc;
 
 namespace SixLabors.ImageSharp.Tests.Metadata.Profiles.ICC.DataReader;
 
diff --git a/tests/ImageSharp.Tests/Metadata/Profiles/ICC/DataReader/IccDataReaderTagDataEntryTests.cs b/tests/ImageSharp.Tests/Metadata/Profiles/ICC/DataReader/IccDataReaderTagDataEntryTests.cs
index d41707b7ce..e0cfa65431 100644
--- a/tests/ImageSharp.Tests/Metadata/Profiles/ICC/DataReader/IccDataReaderTagDataEntryTests.cs
+++ b/tests/ImageSharp.Tests/Metadata/Profiles/ICC/DataReader/IccDataReaderTagDataEntryTests.cs
@@ -2,6 +2,7 @@
 // Licensed under the Six Labors Split License.
 
 using SixLabors.ImageSharp.Metadata.Profiles.Icc;
+using SixLabors.ImageSharp.Tests.TestDataIcc;
 
 namespace SixLabors.ImageSharp.Tests.Metadata.Profiles.ICC.DataReader;
 
@@ -166,7 +167,7 @@ public class IccDataReaderTagDataEntryTests
 
     [Theory]
     [MemberData(
-        nameof(IccTestDataTagDataEntry.MultiLocalizedUnicodeTagDataEntryTestData_Read),
+        nameof(IccTestDataTagDataEntry.MultiLocalizedUnicodeTagDataEntryTestDataRead),
         MemberType = typeof(IccTestDataTagDataEntry))]
     internal void ReadMultiLocalizedUnicodeTagDataEntry(byte[] data, IccMultiLocalizedUnicodeTagDataEntry expected)
     {
diff --git a/tests/ImageSharp.Tests/Metadata/Profiles/ICC/DataReader/IccDataReaderTests.cs b/tests/ImageSharp.Tests/Metadata/Profiles/ICC/DataReader/IccDataReaderTests.cs
index f2150cc03a..6f2e868c56 100644
--- a/tests/ImageSharp.Tests/Metadata/Profiles/ICC/DataReader/IccDataReaderTests.cs
+++ b/tests/ImageSharp.Tests/Metadata/Profiles/ICC/DataReader/IccDataReaderTests.cs
@@ -9,8 +9,5 @@ namespace SixLabors.ImageSharp.Tests.Metadata.Profiles.ICC.DataReader;
 public class IccDataReaderTests
 {
     [Fact]
-    public void ConstructorThrowsNullException()
-    {
-        Assert.Throws<ArgumentNullException>(() => new IccDataReader(null));
-    }
+    public void ConstructorThrowsNullException() => Assert.Throws<ArgumentNullException>(() => new IccDataReader(null));
 }
diff --git a/tests/ImageSharp.Tests/Metadata/Profiles/ICC/DataWriter/IccDataWriterCurvesTests.cs b/tests/ImageSharp.Tests/Metadata/Profiles/ICC/DataWriter/IccDataWriterCurvesTests.cs
index 1a23c8d002..79578f1ada 100644
--- a/tests/ImageSharp.Tests/Metadata/Profiles/ICC/DataWriter/IccDataWriterCurvesTests.cs
+++ b/tests/ImageSharp.Tests/Metadata/Profiles/ICC/DataWriter/IccDataWriterCurvesTests.cs
@@ -2,6 +2,7 @@
 // Licensed under the Six Labors Split License.
 
 using SixLabors.ImageSharp.Metadata.Profiles.Icc;
+using SixLabors.ImageSharp.Tests.TestDataIcc;
 
 namespace SixLabors.ImageSharp.Tests.Metadata.Profiles.ICC.DataWriter;
 
@@ -80,8 +81,5 @@ public class IccDataWriterCurvesTests
         Assert.Equal(expected, output);
     }
 
-    private static IccDataWriter CreateWriter()
-    {
-        return new IccDataWriter();
-    }
+    private static IccDataWriter CreateWriter() => new();
 }
diff --git a/tests/ImageSharp.Tests/Metadata/Profiles/ICC/DataWriter/IccDataWriterLutTests.cs b/tests/ImageSharp.Tests/Metadata/Profiles/ICC/DataWriter/IccDataWriterLutTests.cs
index 4a3dc48bcb..27db7e4e61 100644
--- a/tests/ImageSharp.Tests/Metadata/Profiles/ICC/DataWriter/IccDataWriterLutTests.cs
+++ b/tests/ImageSharp.Tests/Metadata/Profiles/ICC/DataWriter/IccDataWriterLutTests.cs
@@ -2,6 +2,7 @@
 // Licensed under the Six Labors Split License.
 
 using SixLabors.ImageSharp.Metadata.Profiles.Icc;
+using SixLabors.ImageSharp.Tests.TestDataIcc;
 
 namespace SixLabors.ImageSharp.Tests.Metadata.Profiles.ICC.DataWriter;
 
@@ -80,8 +81,5 @@ public class IccDataWriterLutTests
         Assert.Equal(expected, output);
     }
 
-    private static IccDataWriter CreateWriter()
-    {
-        return new IccDataWriter();
-    }
+    private static IccDataWriter CreateWriter() => new();
 }
diff --git a/tests/ImageSharp.Tests/Metadata/Profiles/ICC/DataWriter/IccDataWriterLutTests1.cs b/tests/ImageSharp.Tests/Metadata/Profiles/ICC/DataWriter/IccDataWriterLutTests1.cs
index 1973d94b89..9317b45034 100644
--- a/tests/ImageSharp.Tests/Metadata/Profiles/ICC/DataWriter/IccDataWriterLutTests1.cs
+++ b/tests/ImageSharp.Tests/Metadata/Profiles/ICC/DataWriter/IccDataWriterLutTests1.cs
@@ -2,6 +2,7 @@
 // Licensed under the Six Labors Split License.
 
 using SixLabors.ImageSharp.Metadata.Profiles.Icc;
+using SixLabors.ImageSharp.Tests.TestDataIcc;
 
 namespace SixLabors.ImageSharp.Tests.Metadata.Profiles.ICC.DataWriter;
 
@@ -80,8 +81,5 @@ public class IccDataWriterLutTests1
         Assert.Equal(expected, output);
     }
 
-    private static IccDataWriter CreateWriter()
-    {
-        return new IccDataWriter();
-    }
+    private static IccDataWriter CreateWriter() => new();
 }
diff --git a/tests/ImageSharp.Tests/Metadata/Profiles/ICC/DataWriter/IccDataWriterLutTests2.cs b/tests/ImageSharp.Tests/Metadata/Profiles/ICC/DataWriter/IccDataWriterLutTests2.cs
index 4ffc9e0c36..147a332c39 100644
--- a/tests/ImageSharp.Tests/Metadata/Profiles/ICC/DataWriter/IccDataWriterLutTests2.cs
+++ b/tests/ImageSharp.Tests/Metadata/Profiles/ICC/DataWriter/IccDataWriterLutTests2.cs
@@ -2,6 +2,7 @@
 // Licensed under the Six Labors Split License.
 
 using SixLabors.ImageSharp.Metadata.Profiles.Icc;
+using SixLabors.ImageSharp.Tests.TestDataIcc;
 
 namespace SixLabors.ImageSharp.Tests.Metadata.Profiles.ICC.DataWriter;
 
@@ -80,8 +81,5 @@ public class IccDataWriterLutTests2
         Assert.Equal(expected, output);
     }
 
-    private static IccDataWriter CreateWriter()
-    {
-        return new IccDataWriter();
-    }
+    private static IccDataWriter CreateWriter() => new();
 }
diff --git a/tests/ImageSharp.Tests/Metadata/Profiles/ICC/DataWriter/IccDataWriterMatrixTests.cs b/tests/ImageSharp.Tests/Metadata/Profiles/ICC/DataWriter/IccDataWriterMatrixTests.cs
index 7d046aa49b..c72d4386ad 100644
--- a/tests/ImageSharp.Tests/Metadata/Profiles/ICC/DataWriter/IccDataWriterMatrixTests.cs
+++ b/tests/ImageSharp.Tests/Metadata/Profiles/ICC/DataWriter/IccDataWriterMatrixTests.cs
@@ -3,6 +3,7 @@
 
 using System.Numerics;
 using SixLabors.ImageSharp.Metadata.Profiles.Icc;
+using SixLabors.ImageSharp.Tests.TestDataIcc;
 
 namespace SixLabors.ImageSharp.Tests.Metadata.Profiles.ICC.DataWriter;
 
@@ -10,7 +11,7 @@ namespace SixLabors.ImageSharp.Tests.Metadata.Profiles.ICC.DataWriter;
 public class IccDataWriterMatrixTests
 {
     [Theory]
-    [MemberData(nameof(IccTestDataMatrix.Matrix2D_FloatArrayTestData), MemberType = typeof(IccTestDataMatrix))]
+    [MemberData(nameof(IccTestDataMatrix.Matrix2DFloatArrayTestData), MemberType = typeof(IccTestDataMatrix))]
     public void WriteMatrix2D_Array(byte[] expected, int xCount, int yCount, bool isSingle, float[,] data)
     {
         using IccDataWriter writer = CreateWriter();
@@ -22,7 +23,7 @@ public class IccDataWriterMatrixTests
     }
 
     [Theory]
-    [MemberData(nameof(IccTestDataMatrix.Matrix2D_Matrix4x4TestData), MemberType = typeof(IccTestDataMatrix))]
+    [MemberData(nameof(IccTestDataMatrix.Matrix2DMatrix4X4TestData), MemberType = typeof(IccTestDataMatrix))]
     public void WriteMatrix2D_Matrix4x4(byte[] expected, int xCount, int yCount, bool isSingle, Matrix4x4 data)
     {
         using IccDataWriter writer = CreateWriter();
@@ -34,7 +35,7 @@ public class IccDataWriterMatrixTests
     }
 
     [Theory]
-    [MemberData(nameof(IccTestDataMatrix.Matrix2D_DenseMatrixTestData), MemberType = typeof(IccTestDataMatrix))]
+    [MemberData(nameof(IccTestDataMatrix.Matrix2DDenseMatrixTestData), MemberType = typeof(IccTestDataMatrix))]
     internal void WriteMatrix2D_DenseMatrix(byte[] expected, int xCount, int yCount, bool isSingle, in DenseMatrix<float> data)
     {
         using IccDataWriter writer = CreateWriter();
@@ -46,7 +47,7 @@ public class IccDataWriterMatrixTests
     }
 
     [Theory]
-    [MemberData(nameof(IccTestDataMatrix.Matrix1D_ArrayTestData), MemberType = typeof(IccTestDataMatrix))]
+    [MemberData(nameof(IccTestDataMatrix.Matrix1DArrayTestData), MemberType = typeof(IccTestDataMatrix))]
     public void WriteMatrix1D_Array(byte[] expected, int yCount, bool isSingle, float[] data)
     {
         using IccDataWriter writer = CreateWriter();
@@ -58,7 +59,7 @@ public class IccDataWriterMatrixTests
     }
 
     [Theory]
-    [MemberData(nameof(IccTestDataMatrix.Matrix1D_Vector3TestData), MemberType = typeof(IccTestDataMatrix))]
+    [MemberData(nameof(IccTestDataMatrix.Matrix1DVector3TestData), MemberType = typeof(IccTestDataMatrix))]
     public void WriteMatrix1D_Vector3(byte[] expected, int yCount, bool isSingle, Vector3 data)
     {
         using IccDataWriter writer = CreateWriter();
@@ -69,8 +70,5 @@ public class IccDataWriterMatrixTests
         Assert.Equal(expected, output);
     }
 
-    private static IccDataWriter CreateWriter()
-    {
-        return new IccDataWriter();
-    }
+    private static IccDataWriter CreateWriter() => new();
 }
diff --git a/tests/ImageSharp.Tests/Metadata/Profiles/ICC/DataWriter/IccDataWriterMultiProcessElementTests.cs b/tests/ImageSharp.Tests/Metadata/Profiles/ICC/DataWriter/IccDataWriterMultiProcessElementTests.cs
index ba2add5eb9..b7259d536a 100644
--- a/tests/ImageSharp.Tests/Metadata/Profiles/ICC/DataWriter/IccDataWriterMultiProcessElementTests.cs
+++ b/tests/ImageSharp.Tests/Metadata/Profiles/ICC/DataWriter/IccDataWriterMultiProcessElementTests.cs
@@ -2,6 +2,7 @@
 // Licensed under the Six Labors Split License.
 
 using SixLabors.ImageSharp.Metadata.Profiles.Icc;
+using SixLabors.ImageSharp.Tests.TestDataIcc;
 
 namespace SixLabors.ImageSharp.Tests.Metadata.Profiles.ICC.DataWriter;
 
@@ -56,8 +57,5 @@ public class IccDataWriterMultiProcessElementTests
         Assert.Equal(expected, output);
     }
 
-    private static IccDataWriter CreateWriter()
-    {
-        return new IccDataWriter();
-    }
+    private static IccDataWriter CreateWriter() => new();
 }
diff --git a/tests/ImageSharp.Tests/Metadata/Profiles/ICC/DataWriter/IccDataWriterNonPrimitivesTests.cs b/tests/ImageSharp.Tests/Metadata/Profiles/ICC/DataWriter/IccDataWriterNonPrimitivesTests.cs
index b17ed44419..b1b30d49fa 100644
--- a/tests/ImageSharp.Tests/Metadata/Profiles/ICC/DataWriter/IccDataWriterNonPrimitivesTests.cs
+++ b/tests/ImageSharp.Tests/Metadata/Profiles/ICC/DataWriter/IccDataWriterNonPrimitivesTests.cs
@@ -3,6 +3,7 @@
 
 using System.Numerics;
 using SixLabors.ImageSharp.Metadata.Profiles.Icc;
+using SixLabors.ImageSharp.Tests.TestDataIcc;
 
 namespace SixLabors.ImageSharp.Tests.Metadata.Profiles.ICC.DataWriter;
 
@@ -117,8 +118,5 @@ public class IccDataWriterNonPrimitivesTests
         Assert.Equal(expected, output);
     }
 
-    private static IccDataWriter CreateWriter()
-    {
-        return new IccDataWriter();
-    }
+    private static IccDataWriter CreateWriter() => new();
 }
diff --git a/tests/ImageSharp.Tests/Metadata/Profiles/ICC/DataWriter/IccDataWriterPrimitivesTests.cs b/tests/ImageSharp.Tests/Metadata/Profiles/ICC/DataWriter/IccDataWriterPrimitivesTests.cs
index fbe8fe1ced..0a9b888ed4 100644
--- a/tests/ImageSharp.Tests/Metadata/Profiles/ICC/DataWriter/IccDataWriterPrimitivesTests.cs
+++ b/tests/ImageSharp.Tests/Metadata/Profiles/ICC/DataWriter/IccDataWriterPrimitivesTests.cs
@@ -2,6 +2,7 @@
 // Licensed under the Six Labors Split License.
 
 using SixLabors.ImageSharp.Metadata.Profiles.Icc;
+using SixLabors.ImageSharp.Tests.TestDataIcc;
 
 namespace SixLabors.ImageSharp.Tests.Metadata.Profiles.ICC.DataWriter;
 
@@ -41,7 +42,7 @@ public class IccDataWriterPrimitivesTests
         byte[] output = writer.GetData();
 
         Assert.Equal(0, count);
-        Assert.Equal(Array.Empty<byte>(), output);
+        Assert.Equal([], output);
     }
 
     [Fact]
@@ -61,7 +62,7 @@ public class IccDataWriterPrimitivesTests
         byte[] output = writer.GetData();
 
         Assert.Equal(0, count);
-        Assert.Equal(Array.Empty<byte>(), output);
+        Assert.Equal([], output);
     }
 
     [Theory]
@@ -112,8 +113,5 @@ public class IccDataWriterPrimitivesTests
         Assert.Equal(expected, output);
     }
 
-    private static IccDataWriter CreateWriter()
-    {
-        return new IccDataWriter();
-    }
+    private static IccDataWriter CreateWriter() => new();
 }
diff --git a/tests/ImageSharp.Tests/Metadata/Profiles/ICC/DataWriter/IccDataWriterTagDataEntryTests.cs b/tests/ImageSharp.Tests/Metadata/Profiles/ICC/DataWriter/IccDataWriterTagDataEntryTests.cs
index 7eda24c8cf..791bcee5e6 100644
--- a/tests/ImageSharp.Tests/Metadata/Profiles/ICC/DataWriter/IccDataWriterTagDataEntryTests.cs
+++ b/tests/ImageSharp.Tests/Metadata/Profiles/ICC/DataWriter/IccDataWriterTagDataEntryTests.cs
@@ -2,6 +2,7 @@
 // Licensed under the Six Labors Split License.
 
 using SixLabors.ImageSharp.Metadata.Profiles.Icc;
+using SixLabors.ImageSharp.Tests.TestDataIcc;
 
 namespace SixLabors.ImageSharp.Tests.Metadata.Profiles.ICC.DataWriter;
 
@@ -153,7 +154,7 @@ public class IccDataWriterTagDataEntryTests
     }
 
     [Theory]
-    [MemberData(nameof(IccTestDataTagDataEntry.MultiLocalizedUnicodeTagDataEntryTestData_Write), MemberType = typeof(IccTestDataTagDataEntry))]
+    [MemberData(nameof(IccTestDataTagDataEntry.MultiLocalizedUnicodeTagDataEntryTestDataWrite), MemberType = typeof(IccTestDataTagDataEntry))]
     internal void WriteMultiLocalizedUnicodeTagDataEntry(byte[] expected, IccMultiLocalizedUnicodeTagDataEntry data)
     {
         using IccDataWriter writer = CreateWriter();
@@ -404,8 +405,5 @@ public class IccDataWriterTagDataEntryTests
         Assert.Equal(expected, output);
     }
 
-    private static IccDataWriter CreateWriter()
-    {
-        return new IccDataWriter();
-    }
+    private static IccDataWriter CreateWriter() => new();
 }
diff --git a/tests/ImageSharp.Tests/Metadata/Profiles/ICC/DataWriter/IccDataWriterTests.cs b/tests/ImageSharp.Tests/Metadata/Profiles/ICC/DataWriter/IccDataWriterTests.cs
index 205941fcec..606a69d390 100644
--- a/tests/ImageSharp.Tests/Metadata/Profiles/ICC/DataWriter/IccDataWriterTests.cs
+++ b/tests/ImageSharp.Tests/Metadata/Profiles/ICC/DataWriter/IccDataWriterTests.cs
@@ -2,6 +2,7 @@
 // Licensed under the Six Labors Split License.
 
 using SixLabors.ImageSharp.Metadata.Profiles.Icc;
+using SixLabors.ImageSharp.Tests.TestDataIcc;
 
 namespace SixLabors.ImageSharp.Tests.Metadata.Profiles.ICC.DataWriter;
 
@@ -105,8 +106,5 @@ public class IccDataWriterTests
         Assert.Equal(expected, output);
     }
 
-    private static IccDataWriter CreateWriter()
-    {
-        return new IccDataWriter();
-    }
+    private static IccDataWriter CreateWriter() => new();
 }
diff --git a/tests/ImageSharp.Tests/Metadata/Profiles/ICC/IccProfileTests.cs b/tests/ImageSharp.Tests/Metadata/Profiles/ICC/IccProfileTests.cs
index fbbea97fb3..27ce0ffa86 100644
--- a/tests/ImageSharp.Tests/Metadata/Profiles/ICC/IccProfileTests.cs
+++ b/tests/ImageSharp.Tests/Metadata/Profiles/ICC/IccProfileTests.cs
@@ -2,6 +2,7 @@
 // Licensed under the Six Labors Split License.
 
 using SixLabors.ImageSharp.Metadata.Profiles.Icc;
+using SixLabors.ImageSharp.Tests.TestDataIcc;
 
 namespace SixLabors.ImageSharp.Tests.Metadata.Profiles.Icc;
 
@@ -20,8 +21,8 @@ public class IccProfileTests
     [Fact]
     public void CalculateHash_WithByteArray_DoesNotModifyData()
     {
-        byte[] data = IccTestDataProfiles.Profile_Random_Array;
-        var copy = new byte[data.Length];
+        byte[] data = IccTestDataProfiles.ProfileRandomArray;
+        byte[] copy = new byte[data.Length];
         Buffer.BlockCopy(data, 0, copy, 0, data.Length);
 
         IccProfile.CalculateHash(data);
@@ -33,7 +34,7 @@ public class IccProfileTests
     [MemberData(nameof(IccTestDataProfiles.ProfileValidityTestData), MemberType = typeof(IccTestDataProfiles))]
     public void CheckIsValid_WithProfiles_ReturnsValidity(byte[] data, bool expected)
     {
-        var profile = new IccProfile(data);
+        IccProfile profile = new(data);
 
         bool result = profile.CheckIsValid();
 
diff --git a/tests/ImageSharp.Tests/Metadata/Profiles/ICC/IccReaderTests.cs b/tests/ImageSharp.Tests/Metadata/Profiles/ICC/IccReaderTests.cs
index 9b2ca2a275..2a80ae9e9c 100644
--- a/tests/ImageSharp.Tests/Metadata/Profiles/ICC/IccReaderTests.cs
+++ b/tests/ImageSharp.Tests/Metadata/Profiles/ICC/IccReaderTests.cs
@@ -2,24 +2,45 @@
 // Licensed under the Six Labors Split License.
 
 using SixLabors.ImageSharp.Metadata.Profiles.Icc;
+using SixLabors.ImageSharp.PixelFormats;
+using SixLabors.ImageSharp.Tests.TestDataIcc;
 
 namespace SixLabors.ImageSharp.Tests.Metadata.Profiles.Icc;
 
 [Trait("Profile", "Icc")]
 public class IccReaderTests
 {
+    [Theory]
+    [WithFile(TestImages.Jpeg.ICC.AdobeRgb, PixelTypes.Rgb24, 10, IccColorSpaceType.Rgb, IccColorSpaceType.CieXyz, 560)]
+    [WithFile(TestImages.Jpeg.ICC.AppleRGB, PixelTypes.Rgb24, 10, IccColorSpaceType.Rgb, IccColorSpaceType.CieXyz, 552)]
+    [WithFile(TestImages.Jpeg.ICC.ColorMatch, PixelTypes.Rgb24, 10, IccColorSpaceType.Rgb, IccColorSpaceType.CieXyz, 560)]
+    [WithFile(TestImages.Jpeg.ICC.WideRGB, PixelTypes.Rgb24, 10, IccColorSpaceType.Rgb, IccColorSpaceType.CieXyz, 560)]
+    [WithFile(TestImages.Jpeg.ICC.SRgb, PixelTypes.Rgb24, 17, IccColorSpaceType.Rgb, IccColorSpaceType.CieXyz, 3144)]
+    [WithFile(TestImages.Jpeg.ICC.ProPhoto, PixelTypes.Rgb24, 12, IccColorSpaceType.Rgb, IccColorSpaceType.CieXyz, 940)]
+    [WithFile(TestImages.Jpeg.ICC.CMYK, PixelTypes.Rgb24, 10, IccColorSpaceType.Cmyk, IccColorSpaceType.CieLab, 557168)]
+    public void ReadProfile_Works<TPixel>(TestImageProvider<TPixel> provider, int expectedEntries, IccColorSpaceType expectedDataColorSpace, IccColorSpaceType expectedConnectionSpace, uint expectedDataSize)
+        where TPixel : unmanaged, IPixel<TPixel>
+    {
+        using Image<TPixel> image = provider.GetImage();
+        IccProfile profile = image.Metadata.IccProfile;
+
+        Assert.NotNull(profile);
+        Assert.Equal(expectedEntries, profile.Entries.Length);
+        Assert.Equal(expectedDataColorSpace, profile.Header.DataColorSpace);
+        Assert.Equal(expectedConnectionSpace, profile.Header.ProfileConnectionSpace);
+        Assert.Equal(expectedDataSize, profile.Header.Size);
+    }
+
     [Fact]
     public void ReadProfile_NoEntries()
     {
-        IccReader reader = this.CreateReader();
-
-        IccProfile output = IccReader.Read(IccTestDataProfiles.Header_Random_Array);
+        IccProfile output = IccReader.Read(IccTestDataProfiles.HeaderRandomArray);
 
         Assert.Equal(0, output.Entries.Length);
         Assert.NotNull(output.Header);
 
         IccProfileHeader header = output.Header;
-        IccProfileHeader expected = IccTestDataProfiles.Header_Random_Read;
+        IccProfileHeader expected = IccTestDataProfiles.HeaderRandomRead;
         Assert.Equal(header.Class, expected.Class);
         Assert.Equal(header.CmmType, expected.CmmType);
         Assert.Equal(header.CreationDate, expected.CreationDate);
@@ -38,20 +59,4 @@ public class IccReaderTests
         Assert.Equal(header.Size, expected.Size);
         Assert.Equal(header.Version, expected.Version);
     }
-
-    [Fact]
-    public void ReadProfile_DuplicateEntry()
-    {
-        IccReader reader = this.CreateReader();
-
-        IccProfile output = IccReader.Read(IccTestDataProfiles.Profile_Random_Array);
-
-        Assert.Equal(2, output.Entries.Length);
-        Assert.True(ReferenceEquals(output.Entries[0], output.Entries[1]));
-    }
-
-    private IccReader CreateReader()
-    {
-        return new IccReader();
-    }
 }
diff --git a/tests/ImageSharp.Tests/Metadata/Profiles/ICC/IccWriterTests.cs b/tests/ImageSharp.Tests/Metadata/Profiles/ICC/IccWriterTests.cs
index 89b63b7dcc..71c58c25dd 100644
--- a/tests/ImageSharp.Tests/Metadata/Profiles/ICC/IccWriterTests.cs
+++ b/tests/ImageSharp.Tests/Metadata/Profiles/ICC/IccWriterTests.cs
@@ -2,6 +2,7 @@
 // Licensed under the Six Labors Split License.
 
 using SixLabors.ImageSharp.Metadata.Profiles.Icc;
+using SixLabors.ImageSharp.Tests.TestDataIcc;
 
 namespace SixLabors.ImageSharp.Tests.Metadata.Profiles.Icc;
 
@@ -11,29 +12,20 @@ public class IccWriterTests
     [Fact]
     public void WriteProfile_NoEntries()
     {
-        IccWriter writer = this.CreateWriter();
-
-        var profile = new IccProfile
+        IccProfile profile = new()
         {
-            Header = IccTestDataProfiles.Header_Random_Write
+            Header = IccTestDataProfiles.HeaderRandomWrite
         };
         byte[] output = IccWriter.Write(profile);
 
-        Assert.Equal(IccTestDataProfiles.Header_Random_Array, output);
+        Assert.Equal(IccTestDataProfiles.HeaderRandomArray, output);
     }
 
     [Fact]
     public void WriteProfile_DuplicateEntry()
     {
-        IccWriter writer = this.CreateWriter();
-
-        byte[] output = IccWriter.Write(IccTestDataProfiles.Profile_Random_Val);
+        byte[] output = IccWriter.Write(IccTestDataProfiles.ProfileRandomVal);
 
-        Assert.Equal(IccTestDataProfiles.Profile_Random_Array, output);
-    }
-
-    private IccWriter CreateWriter()
-    {
-        return new IccWriter();
+        Assert.Equal(IccTestDataProfiles.ProfileRandomArray, output);
     }
 }
diff --git a/tests/ImageSharp.Tests/Metadata/Profiles/ICC/Various/IccProfileIdTests.cs b/tests/ImageSharp.Tests/Metadata/Profiles/ICC/Various/IccProfileIdTests.cs
index 968fa86c4e..5af672c210 100644
--- a/tests/ImageSharp.Tests/Metadata/Profiles/ICC/Various/IccProfileIdTests.cs
+++ b/tests/ImageSharp.Tests/Metadata/Profiles/ICC/Various/IccProfileIdTests.cs
@@ -19,7 +19,7 @@ public class IccProfileIdTests
     [Fact]
     public void SetIsTrueWhenNonDefaultValue()
     {
-        var id = new IccProfileId(1, 2, 3, 4);
+        IccProfileId id = new(1, 2, 3, 4);
 
         Assert.True(id.IsSet);
 
diff --git a/tests/ImageSharp.Tests/Metadata/Profiles/IPTC/IptcProfileTests.cs b/tests/ImageSharp.Tests/Metadata/Profiles/IPTC/IptcProfileTests.cs
index 1a52ade629..2dbe5d343d 100644
--- a/tests/ImageSharp.Tests/Metadata/Profiles/IPTC/IptcProfileTests.cs
+++ b/tests/ImageSharp.Tests/Metadata/Profiles/IPTC/IptcProfileTests.cs
@@ -14,7 +14,7 @@ public class IptcProfileTests
     {
         foreach (object tag in Enum.GetValues(typeof(IptcTag)))
         {
-            yield return new object[] { tag };
+            yield return [tag];
         }
     }
 
@@ -22,10 +22,10 @@ public class IptcProfileTests
     public void IptcProfile_WithUtf8Data_WritesEnvelopeRecord_Works()
     {
         // arrange
-        var profile = new IptcProfile();
+        IptcProfile profile = new();
         profile.SetValue(IptcTag.City, "ESPAÑA");
         profile.UpdateData();
-        byte[] expectedEnvelopeData = { 28, 1, 90, 0, 3, 27, 37, 71 };
+        byte[] expectedEnvelopeData = [28, 1, 90, 0, 3, 27, 37, 71];
 
         // act
         byte[] profileBytes = profile.Data;
@@ -39,7 +39,7 @@ public class IptcProfileTests
     public void IptcProfile_SetValue_WithStrictEnabled_Works(IptcTag tag)
     {
         // arrange
-        var profile = new IptcProfile();
+        IptcProfile profile = new();
         string value = new('s', tag.MaxLength() + 1);
         int expectedLength = tag.MaxLength();
 
@@ -56,7 +56,7 @@ public class IptcProfileTests
     public void IptcProfile_SetValue_WithStrictDisabled_Works(IptcTag tag)
     {
         // arrange
-        var profile = new IptcProfile();
+        IptcProfile profile = new();
         string value = new('s', tag.MaxLength() + 1);
         int expectedLength = value.Length;
 
@@ -77,8 +77,8 @@ public class IptcProfileTests
     public void IptcProfile_SetDateValue_Works(IptcTag tag)
     {
         // arrange
-        var profile = new IptcProfile();
-        var datetime = new DateTimeOffset(new DateTime(1994, 3, 17));
+        IptcProfile profile = new();
+        DateTimeOffset datetime = new(new DateTime(1994, 3, 17));
 
         // act
         profile.SetDateTimeValue(tag, datetime);
@@ -96,8 +96,8 @@ public class IptcProfileTests
     public void IptcProfile_SetTimeValue_Works(IptcTag tag)
     {
         // arrange
-        var profile = new IptcProfile();
-        var dateTimeUtc = new DateTime(1994, 3, 17, 14, 15, 16, DateTimeKind.Utc);
+        IptcProfile profile = new();
+        DateTime dateTimeUtc = new(1994, 3, 17, 14, 15, 16, DateTimeKind.Utc);
         DateTimeOffset dateTimeOffset = new DateTimeOffset(dateTimeUtc).ToOffset(TimeSpan.FromHours(2));
 
         // act
@@ -116,7 +116,7 @@ public class IptcProfileTests
         using (Image<TPixel> image = provider.GetImage(JpegDecoder.Instance))
         {
             Assert.NotNull(image.Metadata.IptcProfile);
-            var iptcValues = image.Metadata.IptcProfile.Values.ToList();
+            List<IptcValue> iptcValues = image.Metadata.IptcProfile.Values.ToList();
             IptcProfileContainsExpectedValues(iptcValues);
         }
     }
@@ -130,7 +130,7 @@ public class IptcProfileTests
         {
             IptcProfile iptc = image.Frames.RootFrame.Metadata.IptcProfile;
             Assert.NotNull(iptc);
-            var iptcValues = iptc.Values.ToList();
+            List<IptcValue> iptcValues = iptc.Values.ToList();
             IptcProfileContainsExpectedValues(iptcValues);
         }
     }
@@ -170,7 +170,7 @@ public class IptcProfileTests
     public void IptcProfile_ToAndFromByteArray_Works()
     {
         // arrange
-        var profile = new IptcProfile();
+        IptcProfile profile = new();
         const string expectedCaptionWriter = "unittest";
         const string expectedCaption = "test";
         profile.SetValue(IptcTag.CaptionWriter, expectedCaptionWriter);
@@ -179,10 +179,10 @@ public class IptcProfileTests
         // act
         profile.UpdateData();
         byte[] profileBytes = profile.Data;
-        var profileFromBytes = new IptcProfile(profileBytes);
+        IptcProfile profileFromBytes = new(profileBytes);
 
         // assert
-        var iptcValues = profileFromBytes.Values.ToList();
+        List<IptcValue> iptcValues = profileFromBytes.Values.ToList();
         ContainsIptcValue(iptcValues, IptcTag.CaptionWriter, expectedCaptionWriter);
         ContainsIptcValue(iptcValues, IptcTag.Caption, expectedCaption);
     }
@@ -191,7 +191,7 @@ public class IptcProfileTests
     public void IptcProfile_CloneIsDeep()
     {
         // arrange
-        var profile = new IptcProfile();
+        IptcProfile profile = new();
         const string captionWriter = "unittest";
         const string caption = "test";
         profile.SetValue(IptcTag.CaptionWriter, captionWriter);
@@ -203,7 +203,7 @@ public class IptcProfileTests
 
         // assert
         Assert.Equal(2, clone.Values.Count());
-        var cloneValues = clone.Values.ToList();
+        List<IptcValue> cloneValues = clone.Values.ToList();
         ContainsIptcValue(cloneValues, IptcTag.CaptionWriter, captionWriter);
         ContainsIptcValue(cloneValues, IptcTag.Caption, "changed");
         ContainsIptcValue(profile.Values.ToList(), IptcTag.Caption, caption);
@@ -213,7 +213,7 @@ public class IptcProfileTests
     public void IptcValue_CloneIsDeep()
     {
         // arrange
-        var iptcValue = new IptcValue(IptcTag.Caption, System.Text.Encoding.UTF8, "test", true);
+        IptcValue iptcValue = new(IptcTag.Caption, System.Text.Encoding.UTF8, "test", true);
 
         // act
         IptcValue clone = iptcValue.DeepClone();
@@ -240,7 +240,7 @@ public class IptcProfileTests
         // assert
         IptcProfile actual = reloadedImage.Metadata.IptcProfile;
         Assert.NotNull(actual);
-        var iptcValues = actual.Values.ToList();
+        List<IptcValue> iptcValues = actual.Values.ToList();
         ContainsIptcValue(iptcValues, IptcTag.CaptionWriter, expectedCaptionWriter);
         ContainsIptcValue(iptcValues, IptcTag.Caption, expectedCaption);
     }
@@ -263,7 +263,7 @@ public class IptcProfileTests
     public void IptcProfile_AddRepeatable_Works(IptcTag tag)
     {
         // arrange
-        var profile = new IptcProfile();
+        IptcProfile profile = new();
         const string expectedValue1 = "test";
         const string expectedValue2 = "another one";
         profile.SetValue(tag, expectedValue1, false);
@@ -272,7 +272,7 @@ public class IptcProfileTests
         profile.SetValue(tag, expectedValue2, false);
 
         // assert
-        var values = profile.Values.ToList();
+        List<IptcValue> values = profile.Values.ToList();
         Assert.Equal(2, values.Count);
         ContainsIptcValue(values, tag, expectedValue1);
         ContainsIptcValue(values, tag, expectedValue2);
@@ -315,7 +315,7 @@ public class IptcProfileTests
     public void IptcProfile_AddNoneRepeatable_DoesOverrideOldValue(IptcTag tag)
     {
         // arrange
-        var profile = new IptcProfile();
+        IptcProfile profile = new();
         const string expectedValue = "another one";
         profile.SetValue(tag, "test", false);
 
@@ -323,7 +323,7 @@ public class IptcProfileTests
         profile.SetValue(tag, expectedValue, false);
 
         // assert
-        var values = profile.Values.ToList();
+        List<IptcValue> values = profile.Values.ToList();
         Assert.Equal(1, values.Count);
         ContainsIptcValue(values, tag, expectedValue);
     }
@@ -332,7 +332,7 @@ public class IptcProfileTests
     public void IptcProfile_RemoveByTag_RemovesAllEntrys()
     {
         // arrange
-        var profile = new IptcProfile();
+        IptcProfile profile = new();
         profile.SetValue(IptcTag.Byline, "test");
         profile.SetValue(IptcTag.Byline, "test2");
 
@@ -348,7 +348,7 @@ public class IptcProfileTests
     public void IptcProfile_RemoveByTagAndValue_Works()
     {
         // arrange
-        var profile = new IptcProfile();
+        IptcProfile profile = new();
         profile.SetValue(IptcTag.Byline, "test");
         profile.SetValue(IptcTag.Byline, "test2");
 
@@ -364,7 +364,7 @@ public class IptcProfileTests
     public void IptcProfile_GetValue_RetrievesAllEntries()
     {
         // arrange
-        var profile = new IptcProfile();
+        IptcProfile profile = new();
         profile.SetValue(IptcTag.Byline, "test");
         profile.SetValue(IptcTag.Byline, "test2");
         profile.SetValue(IptcTag.Caption, "test");
@@ -385,7 +385,7 @@ public class IptcProfileTests
 
     private static Image<Rgba32> WriteAndReadJpeg(Image<Rgba32> image)
     {
-        using (var memStream = new MemoryStream())
+        using (MemoryStream memStream = new())
         {
             image.SaveAsJpeg(memStream);
             image.Dispose();
diff --git a/tests/ImageSharp.Tests/Metadata/Profiles/XMP/XmpProfileTests.cs b/tests/ImageSharp.Tests/Metadata/Profiles/XMP/XmpProfileTests.cs
index 5dc6ac6db7..e121d24f91 100644
--- a/tests/ImageSharp.Tests/Metadata/Profiles/XMP/XmpProfileTests.cs
+++ b/tests/ImageSharp.Tests/Metadata/Profiles/XMP/XmpProfileTests.cs
@@ -111,10 +111,10 @@ public class XmpProfileTests
     public void WritingGif_PreservesXmpProfile()
     {
         // arrange
-        using var image = new Image<Rgba32>(1, 1);
+        using Image<Rgba32> image = new(1, 1);
         XmpProfile original = CreateMinimalXmlProfile();
         image.Metadata.XmpProfile = original;
-        var encoder = new GifEncoder();
+        GifEncoder encoder = new();
 
         // act
         using Image<Rgba32> reloadedImage = WriteAndRead(image, encoder);
@@ -129,10 +129,10 @@ public class XmpProfileTests
     public void WritingJpeg_PreservesXmpProfile()
     {
         // arrange
-        using var image = new Image<Rgba32>(1, 1);
+        using Image<Rgba32> image = new(1, 1);
         XmpProfile original = CreateMinimalXmlProfile();
         image.Metadata.XmpProfile = original;
-        var encoder = new JpegEncoder();
+        JpegEncoder encoder = new();
 
         // act
         using Image<Rgba32> reloadedImage = WriteAndRead(image, encoder);
@@ -147,10 +147,10 @@ public class XmpProfileTests
     public async Task WritingJpeg_PreservesExtendedXmpProfile()
     {
         // arrange
-        var provider = TestImageProvider<Rgba32>.File(TestImages.Jpeg.Baseline.ExtendedXmp);
+        TestImageProvider<Rgba32> provider = TestImageProvider<Rgba32>.File(TestImages.Jpeg.Baseline.ExtendedXmp);
         using Image<Rgba32> image = await provider.GetImageAsync(JpegDecoder.Instance);
         XmpProfile original = image.Metadata.XmpProfile;
-        var encoder = new JpegEncoder();
+        JpegEncoder encoder = new();
 
         // act
         using Image<Rgba32> reloadedImage = WriteAndRead(image, encoder);
@@ -165,10 +165,10 @@ public class XmpProfileTests
     public void WritingPng_PreservesXmpProfile()
     {
         // arrange
-        using var image = new Image<Rgba32>(1, 1);
+        using Image<Rgba32> image = new(1, 1);
         XmpProfile original = CreateMinimalXmlProfile();
         image.Metadata.XmpProfile = original;
-        var encoder = new PngEncoder();
+        PngEncoder encoder = new();
 
         // act
         using Image<Rgba32> reloadedImage = WriteAndRead(image, encoder);
@@ -183,10 +183,10 @@ public class XmpProfileTests
     public void WritingTiff_PreservesXmpProfile()
     {
         // arrange
-        using var image = new Image<Rgba32>(1, 1);
+        using Image<Rgba32> image = new(1, 1);
         XmpProfile original = CreateMinimalXmlProfile();
         image.Frames.RootFrame.Metadata.XmpProfile = original;
-        var encoder = new TiffEncoder();
+        TiffEncoder encoder = new();
 
         // act
         using Image<Rgba32> reloadedImage = WriteAndRead(image, encoder);
@@ -201,10 +201,10 @@ public class XmpProfileTests
     public void WritingWebp_PreservesXmpProfile()
     {
         // arrange
-        using var image = new Image<Rgba32>(1, 1);
+        using Image<Rgba32> image = new(1, 1);
         XmpProfile original = CreateMinimalXmlProfile();
         image.Metadata.XmpProfile = original;
-        var encoder = new WebpEncoder();
+        WebpEncoder encoder = new();
 
         // act
         using Image<Rgba32> reloadedImage = WriteAndRead(image, encoder);
@@ -228,13 +228,13 @@ public class XmpProfileTests
     {
         string content = $"<?xpacket begin='' id='{Guid.NewGuid()}'?><x:xmpmeta xmlns:x='adobe:ns:meta/'></x:xmpmeta><?xpacket end='w'?> ";
         byte[] data = Encoding.UTF8.GetBytes(content);
-        var profile = new XmpProfile(data);
+        XmpProfile profile = new(data);
         return profile;
     }
 
     private static Image<Rgba32> WriteAndRead(Image<Rgba32> image, IImageEncoder encoder)
     {
-        using (var memStream = new MemoryStream())
+        using (MemoryStream memStream = new())
         {
             image.Save(memStream, encoder);
             image.Dispose();
diff --git a/tests/ImageSharp.Tests/Numerics/SignedRationalTests.cs b/tests/ImageSharp.Tests/Numerics/SignedRationalTests.cs
index 04183571b5..f194484c4a 100644
--- a/tests/ImageSharp.Tests/Numerics/SignedRationalTests.cs
+++ b/tests/ImageSharp.Tests/Numerics/SignedRationalTests.cs
@@ -14,15 +14,15 @@ public class SignedRationalTests
     [Fact]
     public void AreEqual()
     {
-        var r1 = new SignedRational(3, 2);
-        var r2 = new SignedRational(3, 2);
+        SignedRational r1 = new(3, 2);
+        SignedRational r2 = new(3, 2);
 
         Assert.Equal(r1, r2);
         Assert.True(r1 == r2);
 
-        var r3 = new SignedRational(7.55);
-        var r4 = new SignedRational(755, 100);
-        var r5 = new SignedRational(151, 20);
+        SignedRational r3 = new(7.55);
+        SignedRational r4 = new(755, 100);
+        SignedRational r5 = new(151, 20);
 
         Assert.Equal(r3, r4);
         Assert.Equal(r4, r5);
@@ -34,8 +34,8 @@ public class SignedRationalTests
     [Fact]
     public void AreNotEqual()
     {
-        var first = new SignedRational(0, 100);
-        var second = new SignedRational(100, 100);
+        SignedRational first = new(0, 100);
+        SignedRational second = new(100, 100);
 
         Assert.NotEqual(first, second);
         Assert.True(first != second);
@@ -47,7 +47,7 @@ public class SignedRationalTests
     [Fact]
     public void ConstructorAssignsProperties()
     {
-        var rational = new SignedRational(7, -55);
+        SignedRational rational = new(7, -55);
         Assert.Equal(7, rational.Numerator);
         Assert.Equal(-55, rational.Denominator);
 
@@ -75,15 +75,15 @@ public class SignedRationalTests
     [Fact]
     public void Fraction()
     {
-        var first = new SignedRational(1.0 / 1600);
-        var second = new SignedRational(1.0 / 1600, true);
+        SignedRational first = new(1.0 / 1600);
+        SignedRational second = new(1.0 / 1600, true);
         Assert.False(first.Equals(second));
     }
 
     [Fact]
     public void ToDouble()
     {
-        var rational = new SignedRational(0, 0);
+        SignedRational rational = new(0, 0);
         Assert.Equal(double.NaN, rational.ToDouble());
 
         rational = new SignedRational(2, 0);
@@ -96,7 +96,7 @@ public class SignedRationalTests
     [Fact]
     public void ToStringRepresentation()
     {
-        var rational = new SignedRational(0, 0);
+        SignedRational rational = new(0, 0);
         Assert.Equal("[ Indeterminate ]", rational.ToString());
 
         rational = new SignedRational(double.PositiveInfinity);
diff --git a/tests/ImageSharp.Tests/PixelFormats/PixelBlenders/PorterDuffFunctionsTestsTPixel.cs b/tests/ImageSharp.Tests/PixelFormats/PixelBlenders/PorterDuffFunctionsTestsTPixel.cs
index d375a74c67..2c97cbde07 100644
--- a/tests/ImageSharp.Tests/PixelFormats/PixelBlenders/PorterDuffFunctionsTestsTPixel.cs
+++ b/tests/ImageSharp.Tests/PixelFormats/PixelBlenders/PorterDuffFunctionsTestsTPixel.cs
@@ -15,7 +15,7 @@ public class PorterDuffFunctionsTestsTPixel
         return new Span<T>(new[] { value });
     }
 
-    public static TheoryData<object, object, float, object> NormalBlendFunctionData = new TheoryData<object, object, float, object>
+    public static TheoryData<object, object, float, object> NormalBlendFunctionData = new()
     {
         { new TestPixel<Rgba32>(1, 1, 1, 1), new TestPixel<Rgba32>(1, 1, 1, 1), 1, new TestPixel<Rgba32>(1, 1, 1, 1) },
         { new TestPixel<Rgba32>(1, 1, 1, 1), new TestPixel<Rgba32>(0, 0, 0, .8f), .5f, new TestPixel<Rgba32>(0.6f, 0.6f, 0.6f, 1) }
@@ -46,12 +46,12 @@ public class PorterDuffFunctionsTestsTPixel
     public void NormalBlendFunctionBlenderBulk<TPixel>(TestPixel<TPixel> back, TestPixel<TPixel> source, float amount, TestPixel<TPixel> expected)
         where TPixel : unmanaged, IPixel<TPixel>
     {
-        var dest = new Span<TPixel>(new TPixel[1]);
+        Span<TPixel> dest = new(new TPixel[1]);
         new DefaultPixelBlenders<TPixel>.NormalSrcOver().Blend(this.Configuration, dest, back.AsSpan(), source.AsSpan(), AsSpan(amount));
         VectorAssert.Equal(expected.AsPixel(), dest[0], 2);
     }
 
-    public static TheoryData<object, object, float, object> MultiplyFunctionData = new TheoryData<object, object, float, object>
+    public static TheoryData<object, object, float, object> MultiplyFunctionData = new()
     {
         { new TestPixel<Rgba32>(1, 1, 1, 1), new TestPixel<Rgba32>(1, 1, 1, 1), 1, new TestPixel<Rgba32>(1, 1, 1, 1) },
         { new TestPixel<Rgba32>(1, 1, 1, 1), new TestPixel<Rgba32>(0, 0, 0, .8f), .5f, new TestPixel<Rgba32>(0.6f, 0.6f, 0.6f, 1) },
@@ -86,12 +86,12 @@ public class PorterDuffFunctionsTestsTPixel
     public void MultiplyFunctionBlenderBulk<TPixel>(TestPixel<TPixel> back, TestPixel<TPixel> source, float amount, TestPixel<TPixel> expected)
         where TPixel : unmanaged, IPixel<TPixel>
     {
-        var dest = new Span<TPixel>(new TPixel[1]);
+        Span<TPixel> dest = new(new TPixel[1]);
         new DefaultPixelBlenders<TPixel>.MultiplySrcOver().Blend(this.Configuration, dest, back.AsSpan(), source.AsSpan(), AsSpan(amount));
         VectorAssert.Equal(expected.AsPixel(), dest[0], 2);
     }
 
-    public static TheoryData<object, object, float, object> AddFunctionData = new TheoryData<object, object, float, object>
+    public static TheoryData<object, object, float, object> AddFunctionData = new()
     {
         {
             new TestPixel<Rgba32>(1, 1, 1, 1),
@@ -136,12 +136,12 @@ public class PorterDuffFunctionsTestsTPixel
     public void AddFunctionBlenderBulk<TPixel>(TestPixel<TPixel> back, TestPixel<TPixel> source, float amount, TestPixel<TPixel> expected)
         where TPixel : unmanaged, IPixel<TPixel>
     {
-        var dest = new Span<TPixel>(new TPixel[1]);
+        Span<TPixel> dest = new(new TPixel[1]);
         new DefaultPixelBlenders<TPixel>.AddSrcOver().Blend(this.Configuration, dest, back.AsSpan(), source.AsSpan(), AsSpan(amount));
         VectorAssert.Equal(expected.AsPixel(), dest[0], 2);
     }
 
-    public static TheoryData<object, object, float, object> SubtractFunctionData = new TheoryData<object, object, float, object>
+    public static TheoryData<object, object, float, object> SubtractFunctionData = new()
     {
         { new TestPixel<Rgba32>(1, 1, 1, 1), new TestPixel<Rgba32>(1, 1, 1, 1), 1, new TestPixel<Rgba32>(0, 0, 0, 1) },
         { new TestPixel<Rgba32>(1, 1, 1, 1), new TestPixel<Rgba32>(0, 0, 0, .8f), .5f, new TestPixel<Rgba32>(1, 1, 1, 1f) },
@@ -176,12 +176,12 @@ public class PorterDuffFunctionsTestsTPixel
     public void SubtractFunctionBlenderBulk<TPixel>(TestPixel<TPixel> back, TestPixel<TPixel> source, float amount, TestPixel<TPixel> expected)
         where TPixel : unmanaged, IPixel<TPixel>
     {
-        var dest = new Span<TPixel>(new TPixel[1]);
+        Span<TPixel> dest = new(new TPixel[1]);
         new DefaultPixelBlenders<TPixel>.SubtractSrcOver().Blend(this.Configuration, dest, back.AsSpan(), source.AsSpan(), AsSpan(amount));
         VectorAssert.Equal(expected.AsPixel(), dest[0], 2);
     }
 
-    public static TheoryData<object, object, float, object> ScreenFunctionData = new TheoryData<object, object, float, object>
+    public static TheoryData<object, object, float, object> ScreenFunctionData = new()
     {
         { new TestPixel<Rgba32>(1, 1, 1, 1), new TestPixel<Rgba32>(1, 1, 1, 1), 1, new TestPixel<Rgba32>(1, 1, 1, 1) },
         { new TestPixel<Rgba32>(1, 1, 1, 1), new TestPixel<Rgba32>(0, 0, 0, .8f), .5f, new TestPixel<Rgba32>(1, 1, 1, 1f) },
@@ -216,12 +216,12 @@ public class PorterDuffFunctionsTestsTPixel
     public void ScreenFunctionBlenderBulk<TPixel>(TestPixel<TPixel> back, TestPixel<TPixel> source, float amount, TestPixel<TPixel> expected)
         where TPixel : unmanaged, IPixel<TPixel>
     {
-        var dest = new Span<TPixel>(new TPixel[1]);
+        Span<TPixel> dest = new(new TPixel[1]);
         new DefaultPixelBlenders<TPixel>.ScreenSrcOver().Blend(this.Configuration, dest, back.AsSpan(), source.AsSpan(), AsSpan(amount));
         VectorAssert.Equal(expected.AsPixel(), dest[0], 2);
     }
 
-    public static TheoryData<object, object, float, object> DarkenFunctionData = new TheoryData<object, object, float, object>
+    public static TheoryData<object, object, float, object> DarkenFunctionData = new()
     {
         { new TestPixel<Rgba32>(1, 1, 1, 1), new TestPixel<Rgba32>(1, 1, 1, 1), 1, new TestPixel<Rgba32>(1, 1, 1, 1) },
         { new TestPixel<Rgba32>(1, 1, 1, 1), new TestPixel<Rgba32>(0, 0, 0, .8f), .5f, new TestPixel<Rgba32>(.6f, .6f, .6f, 1f) },
@@ -256,12 +256,12 @@ public class PorterDuffFunctionsTestsTPixel
     public void DarkenFunctionBlenderBulk<TPixel>(TestPixel<TPixel> back, TestPixel<TPixel> source, float amount, TestPixel<TPixel> expected)
         where TPixel : unmanaged, IPixel<TPixel>
     {
-        var dest = new Span<TPixel>(new TPixel[1]);
+        Span<TPixel> dest = new(new TPixel[1]);
         new DefaultPixelBlenders<TPixel>.DarkenSrcOver().Blend(this.Configuration, dest, back.AsSpan(), source.AsSpan(), AsSpan(amount));
         VectorAssert.Equal(expected.AsPixel(), dest[0], 2);
     }
 
-    public static TheoryData<object, object, float, object> LightenFunctionData = new TheoryData<object, object, float, object>
+    public static TheoryData<object, object, float, object> LightenFunctionData = new()
     {
         { new TestPixel<Rgba32>(1, 1, 1, 1), new TestPixel<Rgba32>(1, 1, 1, 1), 1, new TestPixel<Rgba32>(1, 1, 1, 1) },
         { new TestPixel<Rgba32>(1, 1, 1, 1), new TestPixel<Rgba32>(0, 0, 0, .8f), .5f, new TestPixel<Rgba32>(1, 1, 1, 1f) },
@@ -296,12 +296,12 @@ public class PorterDuffFunctionsTestsTPixel
     public void LightenFunctionBlenderBulk<TPixel>(TestPixel<TPixel> back, TestPixel<TPixel> source, float amount, TestPixel<TPixel> expected)
         where TPixel : unmanaged, IPixel<TPixel>
     {
-        var dest = new Span<TPixel>(new TPixel[1]);
+        Span<TPixel> dest = new(new TPixel[1]);
         new DefaultPixelBlenders<TPixel>.LightenSrcOver().Blend(this.Configuration, dest, back.AsSpan(), source.AsSpan(), AsSpan(amount));
         VectorAssert.Equal(expected.AsPixel(), dest[0], 2);
     }
 
-    public static TheoryData<object, object, float, object> OverlayFunctionData = new TheoryData<object, object, float, object>
+    public static TheoryData<object, object, float, object> OverlayFunctionData = new()
     {
         { new TestPixel<Rgba32>(1, 1, 1, 1), new TestPixel<Rgba32>(1, 1, 1, 1), 1, new TestPixel<Rgba32>(1, 1, 1, 1) },
         { new TestPixel<Rgba32>(1, 1, 1, 1), new TestPixel<Rgba32>(0, 0, 0, .8f), .5f, new TestPixel<Rgba32>(1, 1, 1, 1f) },
@@ -336,12 +336,12 @@ public class PorterDuffFunctionsTestsTPixel
     public void OverlayFunctionBlenderBulk<TPixel>(TestPixel<TPixel> back, TestPixel<TPixel> source, float amount, TestPixel<TPixel> expected)
         where TPixel : unmanaged, IPixel<TPixel>
     {
-        var dest = new Span<TPixel>(new TPixel[1]);
+        Span<TPixel> dest = new(new TPixel[1]);
         new DefaultPixelBlenders<TPixel>.OverlaySrcOver().Blend(this.Configuration, dest, back.AsSpan(), source.AsSpan(), AsSpan(amount));
         VectorAssert.Equal(expected.AsPixel(), dest[0], 2);
     }
 
-    public static TheoryData<object, object, float, object> HardLightFunctionData = new TheoryData<object, object, float, object>
+    public static TheoryData<object, object, float, object> HardLightFunctionData = new()
     {
         { new TestPixel<Rgba32>(1, 1, 1, 1), new TestPixel<Rgba32>(1, 1, 1, 1), 1, new TestPixel<Rgba32>(1, 1, 1, 1) },
         { new TestPixel<Rgba32>(1, 1, 1, 1), new TestPixel<Rgba32>(0, 0, 0, .8f), .5f, new TestPixel<Rgba32>(0.6f, 0.6f, 0.6f, 1f) },
@@ -376,7 +376,7 @@ public class PorterDuffFunctionsTestsTPixel
     public void HardLightFunctionBlenderBulk<TPixel>(TestPixel<TPixel> back, TestPixel<TPixel> source, float amount, TestPixel<TPixel> expected)
         where TPixel : unmanaged, IPixel<TPixel>
     {
-        var dest = new Span<TPixel>(new TPixel[1]);
+        Span<TPixel> dest = new(new TPixel[1]);
         new DefaultPixelBlenders<TPixel>.HardLightSrcOver().Blend(this.Configuration, dest, back.AsSpan(), source.AsSpan(), AsSpan(amount));
         VectorAssert.Equal(expected.AsPixel(), dest[0], 2);
     }
diff --git a/tests/ImageSharp.Tests/PixelFormats/PixelOperations/Generated/_Common.ttinclude b/tests/ImageSharp.Tests/PixelFormats/PixelOperations/Generated/_Common.ttinclude
index 90cb3a8665..ccf90fe40f 100644
--- a/tests/ImageSharp.Tests/PixelFormats/PixelOperations/Generated/_Common.ttinclude
+++ b/tests/ImageSharp.Tests/PixelFormats/PixelOperations/Generated/_Common.ttinclude
@@ -13,8 +13,8 @@ using Xunit;
 using Xunit.Abstractions;
 <#+
     private static readonly string[] UnassociatedAlphaPixelTypes =
-    {
-        "A8",
+        [
+            "A8",
         "Argb32",
         "Abgr32",
         "Bgra32",
@@ -31,13 +31,13 @@ using Xunit.Abstractions;
         "Rgba64",
         "RgbaVector",
         "Short4"
-    };
+            ];
 
-    private static readonly string[] AssociatedAlphaPixelTypes = Array.Empty<string>();
+    private static readonly string[] AssociatedAlphaPixelTypes = [];
 
     private static readonly string[] CommonPixelTypes =
-    {
-        "A8",
+        [
+            "A8",
         "Argb32",
         "Abgr32",
         "Bgr24",
@@ -65,8 +65,8 @@ using Xunit.Abstractions;
         "Rgba64",
         "RgbaVector",
         "Short2",
-        "Short4",
-    };
+        "Short4"
+            ];
 
     void GenerateSpecializedClass(string pixelType, string alpha)
     {#>
diff --git a/tests/ImageSharp.Tests/PixelFormats/Rgba32Tests.cs b/tests/ImageSharp.Tests/PixelFormats/Rgba32Tests.cs
index 6d56185ecf..3bb1fead1c 100644
--- a/tests/ImageSharp.Tests/PixelFormats/Rgba32Tests.cs
+++ b/tests/ImageSharp.Tests/PixelFormats/Rgba32Tests.cs
@@ -21,10 +21,10 @@ public class Rgba32Tests
     {
         Rgba32 color1 = new(0, 0, 0);
         Rgba32 color2 = new(0, 0, 0, 1F);
-        Rgba32 color3 = Rgba32.ParseHex("#000");
-        Rgba32 color4 = Rgba32.ParseHex("#000F");
-        Rgba32 color5 = Rgba32.ParseHex("#000000");
-        Rgba32 color6 = Rgba32.ParseHex("#000000FF");
+        Rgba32 color3 = Color.ParseHex("#000").ToPixel<Rgba32>();
+        Rgba32 color4 = Color.ParseHex("#000F").ToPixel<Rgba32>();
+        Rgba32 color5 = Color.ParseHex("#000000").ToPixel<Rgba32>();
+        Rgba32 color6 = Color.ParseHex("#000000FF").ToPixel<Rgba32>();
 
         Assert.Equal(color1, color2);
         Assert.Equal(color1, color3);
@@ -41,9 +41,9 @@ public class Rgba32Tests
     {
         Rgba32 color1 = new(255, 0, 0, 255);
         Rgba32 color2 = new(0, 0, 0, 255);
-        Rgba32 color3 = Rgba32.ParseHex("#000");
-        Rgba32 color4 = Rgba32.ParseHex("#000000");
-        Rgba32 color5 = Rgba32.ParseHex("#FF000000");
+        Rgba32 color3 = Color.ParseHex("#000").ToPixel<Rgba32>();
+        Rgba32 color4 = Color.ParseHex("#000000").ToPixel<Rgba32>();
+        Rgba32 color5 = Color.ParseHex("#FF000000").ToPixel<Rgba32>();
 
         Assert.NotEqual(color1, color2);
         Assert.NotEqual(color1, color3);
@@ -82,30 +82,6 @@ public class Rgba32Tests
         Assert.Equal(Math.Round(.5f * 255), color5.A);
     }
 
-    /// <summary>
-    /// Tests whether FromHex and ToHex work correctly.
-    /// </summary>
-    [Fact]
-    public void FromAndToHex()
-    {
-        // 8 digit hex matches css4 spec. RRGGBBAA
-        Rgba32 color = Rgba32.ParseHex("#AABBCCDD"); // 170, 187, 204, 221
-        Assert.Equal(170, color.R);
-        Assert.Equal(187, color.G);
-        Assert.Equal(204, color.B);
-        Assert.Equal(221, color.A);
-
-        Assert.Equal("AABBCCDD", color.ToHex());
-
-        color.R = 0;
-
-        Assert.Equal("00BBCCDD", color.ToHex());
-
-        color.A = 255;
-
-        Assert.Equal("00BBCCFF", color.ToHex());
-    }
-
     /// <summary>
     /// Tests that the individual byte elements are laid out in RGBA order.
     /// </summary>
diff --git a/tests/ImageSharp.Tests/PixelFormats/UnPackedPixelTests.cs b/tests/ImageSharp.Tests/PixelFormats/UnPackedPixelTests.cs
index 651f6fe7f8..eb93ba230e 100644
--- a/tests/ImageSharp.Tests/PixelFormats/UnPackedPixelTests.cs
+++ b/tests/ImageSharp.Tests/PixelFormats/UnPackedPixelTests.cs
@@ -60,7 +60,7 @@ public class UnPackedPixelTests
     [Fact]
     public void Color_Types_From_Hex_Produce_Equal_Scaled_Component_OutPut()
     {
-        Rgba32 color = Rgba32.ParseHex("183060C0");
+        Rgba32 color = Color.ParseHex("183060C0").ToPixel<Rgba32>();
         RgbaVector colorVector = RgbaVector.FromHex("183060C0");
 
         Assert.Equal(color.R, (byte)(colorVector.R * 255));
diff --git a/tests/ImageSharp.Tests/Primitives/ColorMatrixTests.cs b/tests/ImageSharp.Tests/Primitives/ColorMatrixTests.cs
index 9c0e83a7fe..0ea429a771 100644
--- a/tests/ImageSharp.Tests/Primitives/ColorMatrixTests.cs
+++ b/tests/ImageSharp.Tests/Primitives/ColorMatrixTests.cs
@@ -49,7 +49,7 @@ public class ColorMatrixTests
         ColorMatrix value1 = CreateAllTwos();
         ColorMatrix value2 = CreateAllThrees();
 
-        var m = default(ColorMatrix);
+        ColorMatrix m = default(ColorMatrix);
 
         // First row
         m.M11 = (value1.M11 * value2.M11) + (value1.M12 * value2.M21) + (value1.M13 * value2.M31) + (value1.M14 * value2.M41);
diff --git a/tests/ImageSharp.Tests/Primitives/DenseMatrixTests.cs b/tests/ImageSharp.Tests/Primitives/DenseMatrixTests.cs
index ecc5923264..f83ebc53c5 100644
--- a/tests/ImageSharp.Tests/Primitives/DenseMatrixTests.cs
+++ b/tests/ImageSharp.Tests/Primitives/DenseMatrixTests.cs
@@ -38,7 +38,7 @@ public class DenseMatrixTests
     [Fact]
     public void DenseMatrixReturnsCorrectDimensions()
     {
-        var dense = new DenseMatrix<float>(FloydSteinbergMatrix);
+        DenseMatrix<float> dense = new(FloydSteinbergMatrix);
         Assert.True(dense.Columns == FloydSteinbergMatrix.GetLength(1));
         Assert.True(dense.Rows == FloydSteinbergMatrix.GetLength(0));
         Assert.Equal(3, dense.Columns);
@@ -63,7 +63,7 @@ public class DenseMatrixTests
     [Fact]
     public void DenseMatrixGetSetReturnsCorrectResults()
     {
-        var dense = new DenseMatrix<int>(4, 4);
+        DenseMatrix<int> dense = new(4, 4);
         const int Val = 5;
 
         dense[3, 3] = Val;
@@ -74,7 +74,7 @@ public class DenseMatrixTests
     [Fact]
     public void DenseMatrixCanFillAndClear()
     {
-        var dense = new DenseMatrix<int>(9);
+        DenseMatrix<int> dense = new(9);
         dense.Fill(4);
 
         for (int i = 0; i < dense.Data.Length; i++)
@@ -100,7 +100,7 @@ public class DenseMatrixTests
     [Fact]
     public void DenseMatrixCanTranspose()
     {
-        var dense = new DenseMatrix<int>(3, 1);
+        DenseMatrix<int> dense = new(3, 1);
         dense[0, 0] = 1;
         dense[0, 1] = 2;
         dense[0, 2] = 3;
@@ -117,9 +117,9 @@ public class DenseMatrixTests
     [Fact]
     public void DenseMatrixEquality()
     {
-        var dense = new DenseMatrix<int>(3, 1);
-        var dense2 = new DenseMatrix<int>(3, 1);
-        var dense3 = new DenseMatrix<int>(1, 3);
+        DenseMatrix<int> dense = new(3, 1);
+        DenseMatrix<int> dense2 = new(3, 1);
+        DenseMatrix<int> dense3 = new(1, 3);
 
         Assert.True(dense == dense2);
         Assert.False(dense != dense2);
diff --git a/tests/ImageSharp.Tests/Primitives/PointFTests.cs b/tests/ImageSharp.Tests/Primitives/PointFTests.cs
index c3d9e8176b..8b574daf0d 100644
--- a/tests/ImageSharp.Tests/Primitives/PointFTests.cs
+++ b/tests/ImageSharp.Tests/Primitives/PointFTests.cs
@@ -9,13 +9,12 @@ namespace SixLabors.ImageSharp.Tests;
 
 public class PointFTests
 {
-    private static readonly ApproximateFloatComparer ApproximateFloatComparer =
-        new ApproximateFloatComparer(1e-6f);
+    private static readonly ApproximateFloatComparer ApproximateFloatComparer = new(1e-6f);
 
     [Fact]
     public void CanReinterpretCastFromVector2()
     {
-        var vector = new Vector2(1, 2);
+        Vector2 vector = new(1, 2);
 
         PointF point = Unsafe.As<Vector2, PointF>(ref vector);
 
@@ -37,7 +36,7 @@ public class PointFTests
     [InlineData(0.0, 0.0)]
     public void NonDefaultConstructorTest(float x, float y)
     {
-        var p1 = new PointF(x, y);
+        PointF p1 = new(x, y);
 
         Assert.Equal(x, p1.X);
         Assert.Equal(y, p1.Y);
@@ -67,7 +66,7 @@ public class PointFTests
     [InlineData(0, 0)]
     public void CoordinatesTest(float x, float y)
     {
-        var p = new PointF(x, y);
+        PointF p = new(x, y);
         Assert.Equal(x, p.X);
         Assert.Equal(y, p.Y);
 
@@ -84,11 +83,11 @@ public class PointFTests
     [InlineData(0, 0, 0, 0)]
     public void ArithmeticTestWithSize(float x, float y, int x1, int y1)
     {
-        var p = new PointF(x, y);
-        var s = new Size(x1, y1);
+        PointF p = new(x, y);
+        Size s = new(x1, y1);
 
-        var addExpected = new PointF(x + x1, y + y1);
-        var subExpected = new PointF(x - x1, y - y1);
+        PointF addExpected = new(x + x1, y + y1);
+        PointF subExpected = new(x - x1, y - y1);
         Assert.Equal(addExpected, p + s);
         Assert.Equal(subExpected, p - s);
         Assert.Equal(addExpected, PointF.Add(p, s));
@@ -101,11 +100,11 @@ public class PointFTests
     [InlineData(0, 0)]
     public void ArithmeticTestWithSizeF(float x, float y)
     {
-        var p = new PointF(x, y);
-        var s = new SizeF(y, x);
+        PointF p = new(x, y);
+        SizeF s = new(y, x);
 
-        var addExpected = new PointF(x + y, y + x);
-        var subExpected = new PointF(x - y, y - x);
+        PointF addExpected = new(x + y, y + x);
+        PointF subExpected = new(x - y, y - x);
         Assert.Equal(addExpected, p + s);
         Assert.Equal(subExpected, p - s);
         Assert.Equal(addExpected, PointF.Add(p, s));
@@ -115,10 +114,10 @@ public class PointFTests
     [Fact]
     public void RotateTest()
     {
-        var p = new PointF(13, 17);
+        PointF p = new(13, 17);
         Matrix3x2 matrix = Matrix3x2Extensions.CreateRotationDegrees(45, PointF.Empty);
 
-        var pout = PointF.Transform(p, matrix);
+        PointF pout = PointF.Transform(p, matrix);
 
         Assert.Equal(-2.82842732F, pout.X, ApproximateFloatComparer);
         Assert.Equal(21.2132034F, pout.Y, ApproximateFloatComparer);
@@ -127,10 +126,10 @@ public class PointFTests
     [Fact]
     public void SkewTest()
     {
-        var p = new PointF(13, 17);
+        PointF p = new(13, 17);
         Matrix3x2 matrix = Matrix3x2Extensions.CreateSkewDegrees(45, 45, PointF.Empty);
 
-        var pout = PointF.Transform(p, matrix);
+        PointF pout = PointF.Transform(p, matrix);
         Assert.Equal(new PointF(30, 30), pout);
     }
 
@@ -142,8 +141,8 @@ public class PointFTests
     [InlineData(0, 0)]
     public void EqualityTest(float x, float y)
     {
-        var pLeft = new PointF(x, y);
-        var pRight = new PointF(y, x);
+        PointF pLeft = new(x, y);
+        PointF pRight = new(y, x);
 
         if (x == y)
         {
@@ -164,7 +163,7 @@ public class PointFTests
     [Fact]
     public void EqualityTest_NotPointF()
     {
-        var point = new PointF(0, 0);
+        PointF point = new(0, 0);
         Assert.False(point.Equals(null));
         Assert.False(point.Equals(0));
 
@@ -180,7 +179,7 @@ public class PointFTests
     [Fact]
     public void GetHashCodeTest()
     {
-        var point = new PointF(10, 10);
+        PointF point = new(10, 10);
         Assert.Equal(point.GetHashCode(), new PointF(10, 10).GetHashCode());
         Assert.NotEqual(point.GetHashCode(), new PointF(20, 10).GetHashCode());
         Assert.NotEqual(point.GetHashCode(), new PointF(10, 20).GetHashCode());
@@ -189,7 +188,7 @@ public class PointFTests
     [Fact]
     public void ToStringTest()
     {
-        var p = new PointF(5.1F, -5.123F);
+        PointF p = new(5.1F, -5.123F);
         Assert.Equal(string.Format(CultureInfo.CurrentCulture, "PointF [ X={0}, Y={1} ]", p.X, p.Y), p.ToString());
     }
 
@@ -200,7 +199,7 @@ public class PointFTests
     [InlineData(0, 0)]
     public void DeconstructTest(float x, float y)
     {
-        PointF p = new PointF(x, y);
+        PointF p = new(x, y);
 
         (float deconstructedX, float deconstructedY) = p;
 
diff --git a/tests/ImageSharp.Tests/Primitives/PointTests.cs b/tests/ImageSharp.Tests/Primitives/PointTests.cs
index 2921b6fb8b..34e4f4d8fa 100644
--- a/tests/ImageSharp.Tests/Primitives/PointTests.cs
+++ b/tests/ImageSharp.Tests/Primitives/PointTests.cs
@@ -21,8 +21,8 @@ public class PointTests
     [InlineData(0, 0)]
     public void NonDefaultConstructorTest(int x, int y)
     {
-        var p1 = new Point(x, y);
-        var p2 = new Point(new Size(x, y));
+        Point p1 = new(x, y);
+        Point p2 = new(new Size(x, y));
 
         Assert.Equal(p1, p2);
     }
@@ -33,8 +33,8 @@ public class PointTests
     [InlineData(0)]
     public void SingleIntConstructorTest(int x)
     {
-        var p1 = new Point(x);
-        var p2 = new Point(unchecked((short)(x & 0xFFFF)), unchecked((short)((x >> 16) & 0xFFFF)));
+        Point p1 = new(x);
+        Point p2 = new(unchecked((short)(x & 0xFFFF)), unchecked((short)((x >> 16) & 0xFFFF)));
 
         Assert.Equal(p1, p2);
     }
@@ -63,7 +63,7 @@ public class PointTests
     [InlineData(0, 0)]
     public void CoordinatesTest(int x, int y)
     {
-        var p = new Point(x, y);
+        Point p = new(x, y);
         Assert.Equal(x, p.X);
         Assert.Equal(y, p.Y);
     }
@@ -86,7 +86,7 @@ public class PointTests
     [InlineData(0, 0)]
     public void SizeConversionTest(int x, int y)
     {
-        var sz = (Size)new Point(x, y);
+        Size sz = (Size)new Point(x, y);
         Assert.Equal(new Size(x, y), sz);
     }
 
@@ -97,8 +97,8 @@ public class PointTests
     [InlineData(0, 0)]
     public void ArithmeticTest(int x, int y)
     {
-        Point addExpected, subExpected, p = new Point(x, y);
-        var s = new Size(y, x);
+        Point addExpected, subExpected, p = new(x, y);
+        Size s = new(y, x);
 
         unchecked
         {
@@ -140,7 +140,7 @@ public class PointTests
     [InlineData(0, 0)]
     public void PointFMathematicalTest(float x, float y)
     {
-        var pf = new PointF(x, y);
+        PointF pf = new(x, y);
         Point pCeiling, pTruncate, pRound;
 
         unchecked
@@ -162,8 +162,8 @@ public class PointTests
     [InlineData(0, 0)]
     public void OffsetTest(int x, int y)
     {
-        var p1 = new Point(x, y);
-        var p2 = new Point(y, x);
+        Point p1 = new(x, y);
+        Point p2 = new(y, x);
 
         p1.Offset(p2);
 
@@ -177,10 +177,10 @@ public class PointTests
     [Fact]
     public void RotateTest()
     {
-        var p = new Point(13, 17);
+        Point p = new(13, 17);
         Matrix3x2 matrix = Matrix3x2Extensions.CreateRotationDegrees(45, Point.Empty);
 
-        var pout = Point.Transform(p, matrix);
+        Point pout = Point.Transform(p, matrix);
 
         Assert.Equal(new Point(-3, 21), pout);
     }
@@ -188,10 +188,10 @@ public class PointTests
     [Fact]
     public void SkewTest()
     {
-        var p = new Point(13, 17);
+        Point p = new(13, 17);
         Matrix3x2 matrix = Matrix3x2Extensions.CreateSkewDegrees(45, 45, Point.Empty);
 
-        var pout = Point.Transform(p, matrix);
+        Point pout = Point.Transform(p, matrix);
         Assert.Equal(new Point(30, 30), pout);
     }
 
@@ -202,9 +202,9 @@ public class PointTests
     [InlineData(0, 0)]
     public void EqualityTest(int x, int y)
     {
-        var p1 = new Point(x, y);
-        var p2 = new Point((x / 2) - 1, (y / 2) - 1);
-        var p3 = new Point(x, y);
+        Point p1 = new(x, y);
+        Point p2 = new((x / 2) - 1, (y / 2) - 1);
+        Point p3 = new(x, y);
 
         Assert.True(p1 == p3);
         Assert.True(p1 != p2);
@@ -224,7 +224,7 @@ public class PointTests
     [Fact]
     public void EqualityTest_NotPoint()
     {
-        var point = new Point(0, 0);
+        Point point = new(0, 0);
         Assert.False(point.Equals(null));
         Assert.False(point.Equals(0));
         Assert.False(point.Equals(new PointF(0, 0)));
@@ -233,7 +233,7 @@ public class PointTests
     [Fact]
     public void GetHashCodeTest()
     {
-        var point = new Point(10, 10);
+        Point point = new(10, 10);
         Assert.Equal(point.GetHashCode(), new Point(10, 10).GetHashCode());
         Assert.NotEqual(point.GetHashCode(), new Point(20, 10).GetHashCode());
         Assert.NotEqual(point.GetHashCode(), new Point(10, 20).GetHashCode());
@@ -244,7 +244,7 @@ public class PointTests
     [InlineData(1, -2, 3, -4)]
     public void ConversionTest(int x, int y, int width, int height)
     {
-        var rect = new Rectangle(x, y, width, height);
+        Rectangle rect = new(x, y, width, height);
         RectangleF rectF = rect;
         Assert.Equal(x, rectF.X);
         Assert.Equal(y, rectF.Y);
@@ -255,7 +255,7 @@ public class PointTests
     [Fact]
     public void ToStringTest()
     {
-        var p = new Point(5, -5);
+        Point p = new(5, -5);
         Assert.Equal(string.Format(CultureInfo.CurrentCulture, "Point [ X={0}, Y={1} ]", p.X, p.Y), p.ToString());
     }
 
@@ -266,7 +266,7 @@ public class PointTests
     [InlineData(0, 0)]
     public void DeconstructTest(int x, int y)
     {
-        Point p = new Point(x, y);
+        Point p = new(x, y);
 
         (int deconstructedX, int deconstructedY) = p;
 
diff --git a/tests/ImageSharp.Tests/Primitives/RectangleFTests.cs b/tests/ImageSharp.Tests/Primitives/RectangleFTests.cs
index a9b3251ca3..4122daaa52 100644
--- a/tests/ImageSharp.Tests/Primitives/RectangleFTests.cs
+++ b/tests/ImageSharp.Tests/Primitives/RectangleFTests.cs
@@ -23,10 +23,10 @@ public class RectangleFTests
     [InlineData(0, float.MinValue, float.MaxValue, 0)]
     public void NonDefaultConstructorTest(float x, float y, float width, float height)
     {
-        var rect1 = new RectangleF(x, y, width, height);
-        var p = new PointF(x, y);
-        var s = new SizeF(width, height);
-        var rect2 = new RectangleF(p, s);
+        RectangleF rect1 = new(x, y, width, height);
+        PointF p = new(x, y);
+        SizeF s = new(width, height);
+        RectangleF rect2 = new(p, s);
 
         Assert.Equal(rect1, rect2);
     }
@@ -38,8 +38,8 @@ public class RectangleFTests
     [InlineData(0, float.MinValue, float.MaxValue, 0)]
     public void FromLTRBTest(float left, float top, float right, float bottom)
     {
-        var expected = new RectangleF(left, top, right - left, bottom - top);
-        var actual = RectangleF.FromLTRB(left, top, right, bottom);
+        RectangleF expected = new(left, top, right - left, bottom - top);
+        RectangleF actual = RectangleF.FromLTRB(left, top, right, bottom);
 
         Assert.Equal(expected, actual);
     }
@@ -51,9 +51,9 @@ public class RectangleFTests
     [InlineData(0, float.MinValue, float.MaxValue, 0)]
     public void DimensionsTest(float x, float y, float width, float height)
     {
-        var rect = new RectangleF(x, y, width, height);
-        var p = new PointF(x, y);
-        var s = new SizeF(width, height);
+        RectangleF rect = new(x, y, width, height);
+        PointF p = new(x, y);
+        SizeF s = new(width, height);
 
         Assert.Equal(p, rect.Location);
         Assert.Equal(s, rect.Size);
@@ -84,8 +84,8 @@ public class RectangleFTests
     [InlineData(float.MaxValue, float.MinValue)]
     public void LocationSetTest(float x, float y)
     {
-        var point = new PointF(x, y);
-        var rect = new RectangleF(10, 10, 10, 10) { Location = point };
+        PointF point = new(x, y);
+        RectangleF rect = new(10, 10, 10, 10) { Location = point };
         Assert.Equal(point, rect.Location);
         Assert.Equal(point.X, rect.X);
         Assert.Equal(point.Y, rect.Y);
@@ -96,8 +96,8 @@ public class RectangleFTests
     [InlineData(float.MaxValue, float.MinValue)]
     public void SizeSetTest(float x, float y)
     {
-        var size = new SizeF(x, y);
-        var rect = new RectangleF(10, 10, 10, 10) { Size = size };
+        SizeF size = new(x, y);
+        RectangleF rect = new(10, 10, 10, 10) { Size = size };
         Assert.Equal(size, rect.Size);
         Assert.Equal(size.Width, rect.Width);
         Assert.Equal(size.Height, rect.Height);
@@ -109,8 +109,8 @@ public class RectangleFTests
     [InlineData(0, float.MinValue, float.MaxValue, 0)]
     public void EqualityTest(float x, float y, float width, float height)
     {
-        var rect1 = new RectangleF(x, y, width, height);
-        var rect2 = new RectangleF(width, height, x, y);
+        RectangleF rect1 = new(x, y, width, height);
+        RectangleF rect2 = new(width, height, x, y);
 
         Assert.True(rect1 != rect2);
         Assert.False(rect1 == rect2);
@@ -121,7 +121,7 @@ public class RectangleFTests
     [Fact]
     public void EqualityTestNotRectangleF()
     {
-        var rectangle = new RectangleF(0, 0, 0, 0);
+        RectangleF rectangle = new(0, 0, 0, 0);
         Assert.False(rectangle.Equals(null));
         Assert.False(rectangle.Equals(0));
 
@@ -137,8 +137,8 @@ public class RectangleFTests
     [Fact]
     public void GetHashCodeTest()
     {
-        var rect1 = new RectangleF(10, 10, 10, 10);
-        var rect2 = new RectangleF(10, 10, 10, 10);
+        RectangleF rect1 = new(10, 10, 10, 10);
+        RectangleF rect2 = new(10, 10, 10, 10);
         Assert.Equal(rect1.GetHashCode(), rect2.GetHashCode());
         Assert.NotEqual(rect1.GetHashCode(), new RectangleF(20, 10, 10, 10).GetHashCode());
         Assert.NotEqual(rect1.GetHashCode(), new RectangleF(10, 20, 10, 10).GetHashCode());
@@ -151,11 +151,11 @@ public class RectangleFTests
     [InlineData(0, float.MinValue, float.MaxValue, 0)]
     public void ContainsTest(float x, float y, float width, float height)
     {
-        var rect = new RectangleF(x, y, width, height);
+        RectangleF rect = new(x, y, width, height);
         float x1 = (x + width) / 2;
         float y1 = (y + height) / 2;
-        var p = new PointF(x1, y1);
-        var r = new RectangleF(x1, y1, width / 2, height / 2);
+        PointF p = new(x1, y1);
+        RectangleF r = new(x1, y1, width / 2, height / 2);
 
         Assert.False(rect.Contains(x1, y1));
         Assert.False(rect.Contains(p));
@@ -168,13 +168,13 @@ public class RectangleFTests
     [InlineData(0, float.MinValue, float.MaxValue, 0)]
     public void InflateTest(float x, float y, float width, float height)
     {
-        var rect = new RectangleF(x, y, width, height);
-        var inflatedRect = new RectangleF(x - width, y - height, width + (2 * width), height + (2 * height));
+        RectangleF rect = new(x, y, width, height);
+        RectangleF inflatedRect = new(x - width, y - height, width + (2 * width), height + (2 * height));
 
         rect.Inflate(width, height);
         Assert.Equal(inflatedRect, rect);
 
-        var s = new SizeF(x, y);
+        SizeF s = new(x, y);
         inflatedRect = RectangleF.Inflate(rect, x, y);
 
         rect.Inflate(s);
@@ -186,9 +186,9 @@ public class RectangleFTests
     [InlineData(0, float.MinValue, float.MaxValue, 0)]
     public void IntersectTest(float x, float y, float width, float height)
     {
-        var rect1 = new RectangleF(x, y, width, height);
-        var rect2 = new RectangleF(y, x, width, height);
-        var expectedRect = RectangleF.Intersect(rect1, rect2);
+        RectangleF rect1 = new(x, y, width, height);
+        RectangleF rect2 = new(y, x, width, height);
+        RectangleF expectedRect = RectangleF.Intersect(rect1, rect2);
         rect1.Intersect(rect2);
         Assert.Equal(expectedRect, rect1);
         Assert.False(rect1.IntersectsWith(expectedRect));
@@ -197,9 +197,9 @@ public class RectangleFTests
     [Fact]
     public void IntersectIntersectingRectsTest()
     {
-        var rect1 = new RectangleF(0, 0, 5, 5);
-        var rect2 = new RectangleF(1, 1, 3, 3);
-        var expected = new RectangleF(1, 1, 3, 3);
+        RectangleF rect1 = new(0, 0, 5, 5);
+        RectangleF rect2 = new(1, 1, 3, 3);
+        RectangleF expected = new(1, 1, 3, 3);
 
         Assert.Equal(expected, RectangleF.Intersect(rect1, rect2));
     }
@@ -211,15 +211,15 @@ public class RectangleFTests
     [InlineData(0, float.MinValue, float.MaxValue, 0)]
     public void UnionTest(float x, float y, float width, float height)
     {
-        var a = new RectangleF(x, y, width, height);
-        var b = new RectangleF(width, height, x, y);
+        RectangleF a = new(x, y, width, height);
+        RectangleF b = new(width, height, x, y);
 
         float x1 = Math.Min(a.X, b.X);
         float x2 = Math.Max(a.X + a.Width, b.X + b.Width);
         float y1 = Math.Min(a.Y, b.Y);
         float y2 = Math.Max(a.Y + a.Height, b.Y + b.Height);
 
-        var expectedRectangle = new RectangleF(x1, y1, x2 - x1, y2 - y1);
+        RectangleF expectedRectangle = new(x1, y1, x2 - x1, y2 - y1);
 
         Assert.Equal(expectedRectangle, RectangleF.Union(a, b));
     }
@@ -231,9 +231,9 @@ public class RectangleFTests
     [InlineData(0, float.MinValue, float.MaxValue, 0)]
     public void OffsetTest(float x, float y, float width, float height)
     {
-        var r1 = new RectangleF(x, y, width, height);
-        var expectedRect = new RectangleF(x + width, y + height, width, height);
-        var p = new PointF(width, height);
+        RectangleF r1 = new(x, y, width, height);
+        RectangleF expectedRect = new(x + width, y + height, width, height);
+        PointF p = new(width, height);
 
         r1.Offset(p);
         Assert.Equal(expectedRect, r1);
@@ -246,7 +246,7 @@ public class RectangleFTests
     [Fact]
     public void ToStringTest()
     {
-        var r = new RectangleF(5, 5.1F, 1.3F, 1);
+        RectangleF r = new(5, 5.1F, 1.3F, 1);
         Assert.Equal(string.Format(CultureInfo.CurrentCulture, "RectangleF [ X={0}, Y={1}, Width={2}, Height={3} ]", r.X, r.Y, r.Width, r.Height), r.ToString());
     }
 
@@ -270,7 +270,7 @@ public class RectangleFTests
     [InlineData(0, 0, 0, 0)]
     public void DeconstructTest(float x, float y, float width, float height)
     {
-        RectangleF r = new RectangleF(x, y, width, height);
+        RectangleF r = new(x, y, width, height);
 
         (float dx, float dy, float dw, float dh) = r;
 
diff --git a/tests/ImageSharp.Tests/Primitives/RectangleTests.cs b/tests/ImageSharp.Tests/Primitives/RectangleTests.cs
index 2ba3a77315..2800852afd 100644
--- a/tests/ImageSharp.Tests/Primitives/RectangleTests.cs
+++ b/tests/ImageSharp.Tests/Primitives/RectangleTests.cs
@@ -23,8 +23,8 @@ public class RectangleTests
     [InlineData(0, int.MinValue, 0, int.MaxValue)]
     public void NonDefaultConstructorTest(int x, int y, int width, int height)
     {
-        var rect1 = new Rectangle(x, y, width, height);
-        var rect2 = new Rectangle(new Point(x, y), new Size(width, height));
+        Rectangle rect1 = new(x, y, width, height);
+        Rectangle rect2 = new(new Point(x, y), new Size(width, height));
 
         Assert.Equal(rect1, rect2);
     }
@@ -36,8 +36,8 @@ public class RectangleTests
     [InlineData(0, int.MinValue, 0, int.MaxValue)]
     public void FromLTRBTest(int left, int top, int right, int bottom)
     {
-        var rect1 = new Rectangle(left, top, unchecked(right - left), unchecked(bottom - top));
-        var rect2 = Rectangle.FromLTRB(left, top, right, bottom);
+        Rectangle rect1 = new(left, top, unchecked(right - left), unchecked(bottom - top));
+        Rectangle rect2 = Rectangle.FromLTRB(left, top, right, bottom);
 
         Assert.Equal(rect1, rect2);
     }
@@ -68,7 +68,7 @@ public class RectangleTests
     [InlineData(int.MinValue, int.MaxValue, int.MinValue, int.MaxValue)]
     public void DimensionsTest(int x, int y, int width, int height)
     {
-        var rect = new Rectangle(x, y, width, height);
+        Rectangle rect = new(x, y, width, height);
         Assert.Equal(new Point(x, y), rect.Location);
         Assert.Equal(new Size(width, height), rect.Size);
 
@@ -81,8 +81,8 @@ public class RectangleTests
         Assert.Equal(unchecked(x + width), rect.Right);
         Assert.Equal(unchecked(y + height), rect.Bottom);
 
-        var p = new Point(width, height);
-        var s = new Size(x, y);
+        Point p = new(width, height);
+        Size s = new(x, y);
         rect.Location = p;
         rect.Size = s;
 
@@ -104,8 +104,8 @@ public class RectangleTests
     [InlineData(int.MaxValue, int.MinValue)]
     public void LocationSetTest(int x, int y)
     {
-        var point = new Point(x, y);
-        var rect = new Rectangle(10, 10, 10, 10) { Location = point };
+        Point point = new(x, y);
+        Rectangle rect = new(10, 10, 10, 10) { Location = point };
         Assert.Equal(point, rect.Location);
         Assert.Equal(point.X, rect.X);
         Assert.Equal(point.Y, rect.Y);
@@ -116,8 +116,8 @@ public class RectangleTests
     [InlineData(int.MaxValue, int.MinValue)]
     public void SizeSetTest(int x, int y)
     {
-        var size = new Size(x, y);
-        var rect = new Rectangle(10, 10, 10, 10) { Size = size };
+        Size size = new(x, y);
+        Rectangle rect = new(10, 10, 10, 10) { Size = size };
         Assert.Equal(size, rect.Size);
         Assert.Equal(size.Width, rect.Width);
         Assert.Equal(size.Height, rect.Height);
@@ -130,8 +130,8 @@ public class RectangleTests
     [InlineData(int.MinValue, int.MaxValue, int.MinValue, int.MaxValue)]
     public void EqualityTest(int x, int y, int width, int height)
     {
-        var rect1 = new Rectangle(x, y, width, height);
-        var rect2 = new Rectangle(width / 2, height / 2, x, y);
+        Rectangle rect1 = new(x, y, width, height);
+        Rectangle rect2 = new(width / 2, height / 2, x, y);
 
         Assert.True(rect1 != rect2);
         Assert.False(rect1 == rect2);
@@ -142,7 +142,7 @@ public class RectangleTests
     [Fact]
     public void EqualityTestNotRectangle()
     {
-        var rectangle = new Rectangle(0, 0, 0, 0);
+        Rectangle rectangle = new(0, 0, 0, 0);
         Assert.False(rectangle.Equals(null));
         Assert.False(rectangle.Equals(0));
         Assert.False(rectangle.Equals(new RectangleF(0, 0, 0, 0)));
@@ -151,8 +151,8 @@ public class RectangleTests
     [Fact]
     public void GetHashCodeTest()
     {
-        var rect1 = new Rectangle(10, 10, 10, 10);
-        var rect2 = new Rectangle(10, 10, 10, 10);
+        Rectangle rect1 = new(10, 10, 10, 10);
+        Rectangle rect2 = new(10, 10, 10, 10);
         Assert.Equal(rect1.GetHashCode(), rect2.GetHashCode());
         Assert.NotEqual(rect1.GetHashCode(), new Rectangle(20, 10, 10, 10).GetHashCode());
         Assert.NotEqual(rect1.GetHashCode(), new Rectangle(10, 20, 10, 10).GetHashCode());
@@ -166,7 +166,7 @@ public class RectangleTests
     [InlineData(0, 0, 0, 0)]
     public void RectangleFConversionTest(float x, float y, float width, float height)
     {
-        var rect = new RectangleF(x, y, width, height);
+        RectangleF rect = new(x, y, width, height);
         Rectangle rCeiling, rTruncate, rRound;
 
         unchecked
@@ -196,9 +196,9 @@ public class RectangleTests
     [InlineData(0, int.MinValue, int.MaxValue, 0)]
     public void ContainsTest(int x, int y, int width, int height)
     {
-        var rect = new Rectangle(unchecked((2 * x) - width), unchecked((2 * y) - height), width, height);
-        var p = new Point(x, y);
-        var r = new Rectangle(x, y, width / 2, height / 2);
+        Rectangle rect = new(unchecked((2 * x) - width), unchecked((2 * y) - height), width, height);
+        Point p = new(x, y);
+        Rectangle r = new(x, y, width / 2, height / 2);
 
         Assert.False(rect.Contains(x, y));
         Assert.False(rect.Contains(p));
@@ -211,7 +211,7 @@ public class RectangleTests
     [InlineData(0, int.MinValue, int.MaxValue, 0)]
     public void InflateTest(int x, int y, int width, int height)
     {
-        Rectangle inflatedRect, rect = new Rectangle(x, y, width, height);
+        Rectangle inflatedRect, rect = new(x, y, width, height);
         unchecked
         {
             inflatedRect = new Rectangle(x - width, y - height, width + (2 * width), height + (2 * height));
@@ -222,7 +222,7 @@ public class RectangleTests
         rect.Inflate(width, height);
         Assert.Equal(inflatedRect, rect);
 
-        var s = new Size(x, y);
+        Size s = new(x, y);
         unchecked
         {
             inflatedRect = new Rectangle(rect.X - x, rect.Y - y, rect.Width + (2 * x), rect.Height + (2 * y));
@@ -238,8 +238,8 @@ public class RectangleTests
     [InlineData(0, int.MinValue, int.MaxValue, 0)]
     public void IntersectTest(int x, int y, int width, int height)
     {
-        var rect = new Rectangle(x, y, width, height);
-        var expectedRect = Rectangle.Intersect(rect, rect);
+        Rectangle rect = new(x, y, width, height);
+        Rectangle expectedRect = Rectangle.Intersect(rect, rect);
         rect.Intersect(rect);
         Assert.Equal(expectedRect, rect);
         Assert.False(rect.IntersectsWith(expectedRect));
@@ -248,9 +248,9 @@ public class RectangleTests
     [Fact]
     public void IntersectIntersectingRectsTest()
     {
-        var rect1 = new Rectangle(0, 0, 5, 5);
-        var rect2 = new Rectangle(1, 1, 3, 3);
-        var expected = new Rectangle(1, 1, 3, 3);
+        Rectangle rect1 = new(0, 0, 5, 5);
+        Rectangle rect2 = new(1, 1, 3, 3);
+        Rectangle expected = new(1, 1, 3, 3);
 
         Assert.Equal(expected, Rectangle.Intersect(rect1, rect2));
     }
@@ -262,15 +262,15 @@ public class RectangleTests
     [InlineData(0, int.MinValue, int.MaxValue, 0)]
     public void UnionTest(int x, int y, int width, int height)
     {
-        var a = new Rectangle(x, y, width, height);
-        var b = new Rectangle(width, height, x, y);
+        Rectangle a = new(x, y, width, height);
+        Rectangle b = new(width, height, x, y);
 
         int x1 = Math.Min(a.X, b.X);
         int x2 = Math.Max(a.X + a.Width, b.X + b.Width);
         int y1 = Math.Min(a.Y, b.Y);
         int y2 = Math.Max(a.Y + a.Height, b.Y + b.Height);
 
-        var expectedRectangle = new Rectangle(x1, y1, x2 - x1, y2 - y1);
+        Rectangle expectedRectangle = new(x1, y1, x2 - x1, y2 - y1);
 
         Assert.Equal(expectedRectangle, Rectangle.Union(a, b));
     }
@@ -282,9 +282,9 @@ public class RectangleTests
     [InlineData(0, int.MinValue, int.MaxValue, 0)]
     public void OffsetTest(int x, int y, int width, int height)
     {
-        var r1 = new Rectangle(x, y, width, height);
-        var expectedRect = new Rectangle(x + width, y + height, width, height);
-        var p = new Point(width, height);
+        Rectangle r1 = new(x, y, width, height);
+        Rectangle expectedRect = new(x + width, y + height, width, height);
+        Point p = new(width, height);
 
         r1.Offset(p);
         Assert.Equal(expectedRect, r1);
@@ -297,7 +297,7 @@ public class RectangleTests
     [Fact]
     public void ToStringTest()
     {
-        var r = new Rectangle(5, -5, 0, 1);
+        Rectangle r = new(5, -5, 0, 1);
         Assert.Equal(string.Format(CultureInfo.CurrentCulture, "Rectangle [ X={0}, Y={1}, Width={2}, Height={3} ]", r.X, r.Y, r.Width, r.Height), r.ToString());
     }
 
@@ -321,7 +321,7 @@ public class RectangleTests
     [InlineData(0, 0, 0, 0)]
     public void DeconstructTest(int x, int y, int width, int height)
     {
-        var r = new Rectangle(x, y, width, height);
+        Rectangle r = new(x, y, width, height);
 
         (int dx, int dy, int dw, int dh) = r;
 
diff --git a/tests/ImageSharp.Tests/Primitives/SizeFTests.cs b/tests/ImageSharp.Tests/Primitives/SizeFTests.cs
index 1a36b4921a..2893a7c715 100644
--- a/tests/ImageSharp.Tests/Primitives/SizeFTests.cs
+++ b/tests/ImageSharp.Tests/Primitives/SizeFTests.cs
@@ -20,9 +20,9 @@ public class SizeFTests
     [InlineData(0, 0)]
     public void NonDefaultConstructorAndDimensionsTest(float width, float height)
     {
-        var s1 = new SizeF(width, height);
-        var p1 = new PointF(width, height);
-        var s2 = new SizeF(s1);
+        SizeF s1 = new(width, height);
+        PointF p1 = new(width, height);
+        SizeF s2 = new(s1);
 
         Assert.Equal(s1, s2);
         Assert.Equal(s1, new SizeF(p1));
@@ -62,10 +62,10 @@ public class SizeFTests
     [InlineData(0, 0)]
     public void ArithmeticTest(float width, float height)
     {
-        var s1 = new SizeF(width, height);
-        var s2 = new SizeF(height, width);
-        var addExpected = new SizeF(width + height, width + height);
-        var subExpected = new SizeF(width - height, height - width);
+        SizeF s1 = new(width, height);
+        SizeF s2 = new(height, width);
+        SizeF addExpected = new(width + height, width + height);
+        SizeF subExpected = new(width - height, height - width);
 
         Assert.Equal(addExpected, s1 + s2);
         Assert.Equal(addExpected, SizeF.Add(s1, s2));
@@ -81,8 +81,8 @@ public class SizeFTests
     [InlineData(0, 0)]
     public void EqualityTest(float width, float height)
     {
-        var sLeft = new SizeF(width, height);
-        var sRight = new SizeF(height, width);
+        SizeF sLeft = new(width, height);
+        SizeF sRight = new(height, width);
 
         if (width == height)
         {
@@ -103,7 +103,7 @@ public class SizeFTests
     [Fact]
     public void EqualityTest_NotSizeF()
     {
-        var size = new SizeF(0, 0);
+        SizeF size = new(0, 0);
         Assert.False(size.Equals(null));
         Assert.False(size.Equals(0));
 
@@ -119,7 +119,7 @@ public class SizeFTests
     [Fact]
     public void GetHashCodeTest()
     {
-        var size = new SizeF(10, 10);
+        SizeF size = new(10, 10);
         Assert.Equal(size.GetHashCode(), new SizeF(10, 10).GetHashCode());
         Assert.NotEqual(size.GetHashCode(), new SizeF(20, 10).GetHashCode());
         Assert.NotEqual(size.GetHashCode(), new SizeF(10, 20).GetHashCode());
@@ -132,9 +132,9 @@ public class SizeFTests
     [InlineData(0, 0)]
     public void ConversionTest(float width, float height)
     {
-        var s1 = new SizeF(width, height);
-        var p1 = (PointF)s1;
-        var s2 = new Size(unchecked((int)width), unchecked((int)height));
+        SizeF s1 = new(width, height);
+        PointF p1 = (PointF)s1;
+        Size s2 = new(unchecked((int)width), unchecked((int)height));
 
         Assert.Equal(new PointF(width, height), p1);
         Assert.Equal(p1, (PointF)s1);
@@ -144,7 +144,7 @@ public class SizeFTests
     [Fact]
     public void ToStringTest()
     {
-        var sz = new SizeF(10, 5);
+        SizeF sz = new(10, 5);
         Assert.Equal(string.Format(CultureInfo.CurrentCulture, "SizeF [ Width={0}, Height={1} ]", sz.Width, sz.Height), sz.ToString());
     }
 
@@ -172,7 +172,7 @@ public class SizeFTests
     [InlineData(float.MinValue, float.MinValue)]
     public void MultiplicationTest(float dimension, float multiplier)
     {
-        SizeF sz1 = new SizeF(dimension, dimension);
+        SizeF sz1 = new(dimension, dimension);
         SizeF mulExpected;
 
         mulExpected = new SizeF(dimension * multiplier, dimension * multiplier);
@@ -185,7 +185,7 @@ public class SizeFTests
     [InlineData(1111.1111f, 2222.2222f, 3333.3333f)]
     public void MultiplicationTestWidthHeightMultiplier(float width, float height, float multiplier)
     {
-        SizeF sz1 = new SizeF(width, height);
+        SizeF sz1 = new(width, height);
         SizeF mulExpected;
 
         mulExpected = new SizeF(width * multiplier, height * multiplier);
@@ -215,8 +215,8 @@ public class SizeFTests
     [InlineData(-1.0f, float.MaxValue)]
     public void DivideTestSizeFloat(float dimension, float divisor)
     {
-        SizeF size = new SizeF(dimension, dimension);
-        SizeF expected = new SizeF(dimension / divisor, dimension / divisor);
+        SizeF size = new(dimension, dimension);
+        SizeF expected = new(dimension / divisor, dimension / divisor);
         Assert.Equal(expected, size / divisor);
     }
 
@@ -224,8 +224,8 @@ public class SizeFTests
     [InlineData(-111.111f, 222.222f, 333.333f)]
     public void DivideTestSizeFloatWidthHeightDivisor(float width, float height, float divisor)
     {
-        SizeF size = new SizeF(width, height);
-        SizeF expected = new SizeF(width / divisor, height / divisor);
+        SizeF size = new(width, height);
+        SizeF expected = new(width / divisor, height / divisor);
         Assert.Equal(expected, size / divisor);
     }
 
@@ -236,7 +236,7 @@ public class SizeFTests
     [InlineData(0, 0)]
     public void DeconstructTest(float width, float height)
     {
-        SizeF s = new SizeF(width, height);
+        SizeF s = new(width, height);
 
         (float deconstructedWidth, float deconstructedHeight) = s;
 
diff --git a/tests/ImageSharp.Tests/Primitives/SizeTests.cs b/tests/ImageSharp.Tests/Primitives/SizeTests.cs
index eec1fb63b0..63320796a1 100644
--- a/tests/ImageSharp.Tests/Primitives/SizeTests.cs
+++ b/tests/ImageSharp.Tests/Primitives/SizeTests.cs
@@ -23,8 +23,8 @@ public class SizeTests
     [InlineData(0, 0)]
     public void NonDefaultConstructorTest(int width, int height)
     {
-        var s1 = new Size(width, height);
-        var s2 = new Size(new Point(width, height));
+        Size s1 = new(width, height);
+        Size s2 = new(new Point(width, height));
 
         Assert.Equal(s1, s2);
 
@@ -59,7 +59,7 @@ public class SizeTests
     [InlineData(0, 0)]
     public void DimensionsTest(int width, int height)
     {
-        var p = new Size(width, height);
+        Size p = new(width, height);
         Assert.Equal(width, p.Width);
         Assert.Equal(height, p.Height);
     }
@@ -82,7 +82,7 @@ public class SizeTests
     [InlineData(0, 0)]
     public void SizeConversionTest(int width, int height)
     {
-        var sz = (Point)new Size(width, height);
+        Point sz = (Point)new Size(width, height);
         Assert.Equal(new Point(width, height), sz);
     }
 
@@ -93,8 +93,8 @@ public class SizeTests
     [InlineData(0, 0)]
     public void ArithmeticTest(int width, int height)
     {
-        var sz1 = new Size(width, height);
-        var sz2 = new Size(height, width);
+        Size sz1 = new(width, height);
+        Size sz2 = new(height, width);
         Size addExpected, subExpected;
 
         unchecked
@@ -116,7 +116,7 @@ public class SizeTests
     [InlineData(0, 0)]
     public void PointFMathematicalTest(float width, float height)
     {
-        var szF = new SizeF(width, height);
+        SizeF szF = new(width, height);
         Size pCeiling, pTruncate, pRound;
 
         unchecked
@@ -138,9 +138,9 @@ public class SizeTests
     [InlineData(0, 0)]
     public void EqualityTest(int width, int height)
     {
-        var p1 = new Size(width, height);
-        var p2 = new Size(unchecked(width - 1), unchecked(height - 1));
-        var p3 = new Size(width, height);
+        Size p1 = new(width, height);
+        Size p2 = new(unchecked(width - 1), unchecked(height - 1));
+        Size p3 = new(width, height);
 
         Assert.True(p1 == p3);
         Assert.True(p1 != p2);
@@ -160,7 +160,7 @@ public class SizeTests
     [Fact]
     public void EqualityTest_NotSize()
     {
-        var size = new Size(0, 0);
+        Size size = new(0, 0);
         Assert.False(size.Equals(null));
         Assert.False(size.Equals(0));
         Assert.False(size.Equals(new SizeF(0, 0)));
@@ -169,7 +169,7 @@ public class SizeTests
     [Fact]
     public void GetHashCodeTest()
     {
-        var size = new Size(10, 10);
+        Size size = new(10, 10);
         Assert.Equal(size.GetHashCode(), new Size(10, 10).GetHashCode());
         Assert.NotEqual(size.GetHashCode(), new Size(20, 10).GetHashCode());
         Assert.NotEqual(size.GetHashCode(), new Size(10, 20).GetHashCode());
@@ -178,7 +178,7 @@ public class SizeTests
     [Fact]
     public void ToStringTest()
     {
-        var sz = new Size(10, 5);
+        Size sz = new(10, 5);
         Assert.Equal(string.Format(CultureInfo.CurrentCulture, "Size [ Width={0}, Height={1} ]", sz.Width, sz.Height), sz.ToString());
     }
 
@@ -206,7 +206,7 @@ public class SizeTests
     [InlineData(int.MinValue, int.MinValue)]
     public void MultiplicationTestSizeInt(int dimension, int multiplier)
     {
-        Size sz1 = new Size(dimension, dimension);
+        Size sz1 = new(dimension, dimension);
         Size mulExpected;
 
         unchecked
@@ -222,7 +222,7 @@ public class SizeTests
     [InlineData(1000, 2000, 3000)]
     public void MultiplicationTestSizeIntWidthHeightMultiplier(int width, int height, int multiplier)
     {
-        Size sz1 = new Size(width, height);
+        Size sz1 = new(width, height);
         Size mulExpected;
 
         unchecked
@@ -258,7 +258,7 @@ public class SizeTests
     [InlineData(int.MinValue, float.MinValue)]
     public void MultiplicationTestSizeFloat(int dimension, float multiplier)
     {
-        Size sz1 = new Size(dimension, dimension);
+        Size sz1 = new(dimension, dimension);
         SizeF mulExpected;
 
         mulExpected = new SizeF(dimension * multiplier, dimension * multiplier);
@@ -271,7 +271,7 @@ public class SizeTests
     [InlineData(1000, 2000, 30.33f)]
     public void MultiplicationTestSizeFloatWidthHeightMultiplier(int width, int height, float multiplier)
     {
-        Size sz1 = new Size(width, height);
+        Size sz1 = new(width, height);
         SizeF mulExpected;
 
         mulExpected = new SizeF(width * multiplier, height * multiplier);
@@ -283,10 +283,10 @@ public class SizeTests
     [Fact]
     public void DivideByZeroChecks()
     {
-        Size size = new Size(100, 100);
+        Size size = new(100, 100);
         Assert.Throws<DivideByZeroException>(() => size / 0);
 
-        SizeF expectedSizeF = new SizeF(float.PositiveInfinity, float.PositiveInfinity);
+        SizeF expectedSizeF = new(float.PositiveInfinity, float.PositiveInfinity);
         Assert.Equal(expectedSizeF, size / 0.0f);
     }
 
@@ -305,7 +305,7 @@ public class SizeTests
     [InlineData(int.MaxValue, -1)]
     public void DivideTestSizeInt(int dimension, int divisor)
     {
-        Size size = new Size(dimension, dimension);
+        Size size = new(dimension, dimension);
         Size expected;
 
         expected = new Size(dimension / divisor, dimension / divisor);
@@ -317,7 +317,7 @@ public class SizeTests
     [InlineData(1111, 2222, 3333)]
     public void DivideTestSizeIntWidthHeightDivisor(int width, int height, int divisor)
     {
-        Size size = new Size(width, height);
+        Size size = new(width, height);
         Size expected;
 
         expected = new Size(width / divisor, height / divisor);
@@ -341,7 +341,7 @@ public class SizeTests
     [InlineData(int.MinValue, -1.0f)]
     public void DivideTestSizeFloat(int dimension, float divisor)
     {
-        SizeF size = new SizeF(dimension, dimension);
+        SizeF size = new(dimension, dimension);
         SizeF expected;
 
         expected = new SizeF(dimension / divisor, dimension / divisor);
@@ -352,7 +352,7 @@ public class SizeTests
     [InlineData(1111, 2222, -333.33f)]
     public void DivideTestSizeFloatWidthHeightDivisor(int width, int height, float divisor)
     {
-        SizeF size = new SizeF(width, height);
+        SizeF size = new(width, height);
         SizeF expected;
 
         expected = new SizeF(width / divisor, height / divisor);
@@ -366,7 +366,7 @@ public class SizeTests
     [InlineData(0, 0)]
     public void DeconstructTest(int width, int height)
     {
-        Size s = new Size(width, height);
+        Size s = new(width, height);
 
         (int deconstructedWidth, int deconstructedHeight) = s;
 
diff --git a/tests/ImageSharp.Tests/Processing/Binarization/OrderedDitherFactoryTests.cs b/tests/ImageSharp.Tests/Processing/Binarization/OrderedDitherFactoryTests.cs
index c7eb959535..32b8bf276a 100644
--- a/tests/ImageSharp.Tests/Processing/Binarization/OrderedDitherFactoryTests.cs
+++ b/tests/ImageSharp.Tests/Processing/Binarization/OrderedDitherFactoryTests.cs
@@ -10,14 +10,14 @@ public class OrderedDitherFactoryTests
 {
 #pragma warning disable SA1025 // Code should not contain multiple whitespace in a row
 
-    private static readonly DenseMatrix<uint> Expected2x2Matrix = new DenseMatrix<uint>(
+    private static readonly DenseMatrix<uint> Expected2x2Matrix = new(
     new uint[2, 2]
     {
         { 0, 2 },
         { 3, 1 }
     });
 
-    private static readonly DenseMatrix<uint> Expected3x3Matrix = new DenseMatrix<uint>(
+    private static readonly DenseMatrix<uint> Expected3x3Matrix = new(
     new uint[3, 3]
     {
         { 0, 5, 2 },
@@ -25,7 +25,7 @@ public class OrderedDitherFactoryTests
         { 3, 6, 1 }
     });
 
-    private static readonly DenseMatrix<uint> Expected4x4Matrix = new DenseMatrix<uint>(
+    private static readonly DenseMatrix<uint> Expected4x4Matrix = new(
     new uint[4, 4]
     {
         {  0, 8, 2, 10 },
@@ -34,7 +34,7 @@ public class OrderedDitherFactoryTests
         { 15, 7, 13, 5 }
     });
 
-    private static readonly DenseMatrix<uint> Expected8x8Matrix = new DenseMatrix<uint>(
+    private static readonly DenseMatrix<uint> Expected8x8Matrix = new(
     new uint[8, 8]
     {
         {  0, 32,  8, 40,  2, 34, 10, 42 },
diff --git a/tests/ImageSharp.Tests/Processing/Convolution/BoxBlurTest.cs b/tests/ImageSharp.Tests/Processing/Convolution/BoxBlurTest.cs
index da2bc465f6..2337e4567d 100644
--- a/tests/ImageSharp.Tests/Processing/Convolution/BoxBlurTest.cs
+++ b/tests/ImageSharp.Tests/Processing/Convolution/BoxBlurTest.cs
@@ -13,7 +13,7 @@ public class BoxBlurTest : BaseImageOperationsExtensionTest
     public void BoxBlur_BoxBlurProcessorDefaultsSet()
     {
         this.operations.BoxBlur();
-        var processor = this.Verify<BoxBlurProcessor>();
+        BoxBlurProcessor processor = this.Verify<BoxBlurProcessor>();
 
         Assert.Equal(7, processor.Radius);
     }
@@ -22,7 +22,7 @@ public class BoxBlurTest : BaseImageOperationsExtensionTest
     public void BoxBlur_amount_BoxBlurProcessorDefaultsSet()
     {
         this.operations.BoxBlur(34);
-        var processor = this.Verify<BoxBlurProcessor>();
+        BoxBlurProcessor processor = this.Verify<BoxBlurProcessor>();
 
         Assert.Equal(34, processor.Radius);
     }
@@ -31,7 +31,7 @@ public class BoxBlurTest : BaseImageOperationsExtensionTest
     public void BoxBlur_amount_rect_BoxBlurProcessorDefaultsSet()
     {
         this.operations.BoxBlur(5, this.rect);
-        var processor = this.Verify<BoxBlurProcessor>(this.rect);
+        BoxBlurProcessor processor = this.Verify<BoxBlurProcessor>(this.rect);
 
         Assert.Equal(5, processor.Radius);
     }
diff --git a/tests/ImageSharp.Tests/Processing/Convolution/KernelSamplingMapTest.cs b/tests/ImageSharp.Tests/Processing/Convolution/KernelSamplingMapTest.cs
index 476e5b0a90..eb1d3031a4 100644
--- a/tests/ImageSharp.Tests/Processing/Convolution/KernelSamplingMapTest.cs
+++ b/tests/ImageSharp.Tests/Processing/Convolution/KernelSamplingMapTest.cs
@@ -11,87 +11,87 @@ public class KernelSamplingMapTest
     [Fact]
     public void KernalSamplingMap_Kernel5Image7x7RepeatBorder()
     {
-        var kernelSize = new Size(5, 5);
-        var bounds = new Rectangle(0, 0, 7, 7);
-        var mode = BorderWrappingMode.Repeat;
+        Size kernelSize = new(5, 5);
+        Rectangle bounds = new(0, 0, 7, 7);
+        BorderWrappingMode mode = BorderWrappingMode.Repeat;
         int[] expected =
-        {
+        [
             0, 0, 0, 1, 2,
             0, 0, 1, 2, 3,
             0, 1, 2, 3, 4,
             1, 2, 3, 4, 5,
             2, 3, 4, 5, 6,
             3, 4, 5, 6, 6,
-            4, 5, 6, 6, 6,
-        };
+            4, 5, 6, 6, 6
+        ];
         this.AssertOffsets(kernelSize, bounds, mode, mode, expected, expected);
     }
 
     [Fact]
     public void KernalSamplingMap_Kernel5Image7x7BounceBorder()
     {
-        var kernelSize = new Size(5, 5);
-        var bounds = new Rectangle(0, 0, 7, 7);
-        var mode = BorderWrappingMode.Bounce;
+        Size kernelSize = new(5, 5);
+        Rectangle bounds = new(0, 0, 7, 7);
+        BorderWrappingMode mode = BorderWrappingMode.Bounce;
         int[] expected =
-        {
+        [
             2, 1, 0, 1, 2,
             1, 0, 1, 2, 3,
             0, 1, 2, 3, 4,
             1, 2, 3, 4, 5,
             2, 3, 4, 5, 6,
             3, 4, 5, 6, 5,
-            4, 5, 6, 5, 4,
-        };
+            4, 5, 6, 5, 4
+        ];
         this.AssertOffsets(kernelSize, bounds, mode, mode, expected, expected);
     }
 
     [Fact]
     public void KernalSamplingMap_Kernel5Image7x7MirrorBorder()
     {
-        var kernelSize = new Size(5, 5);
-        var bounds = new Rectangle(0, 0, 7, 7);
-        var mode = BorderWrappingMode.Mirror;
+        Size kernelSize = new(5, 5);
+        Rectangle bounds = new(0, 0, 7, 7);
+        BorderWrappingMode mode = BorderWrappingMode.Mirror;
         int[] expected =
-        {
+        [
             1, 0, 0, 1, 2,
             0, 0, 1, 2, 3,
             0, 1, 2, 3, 4,
             1, 2, 3, 4, 5,
             2, 3, 4, 5, 6,
             3, 4, 5, 6, 6,
-            4, 5, 6, 6, 5,
-        };
+            4, 5, 6, 6, 5
+        ];
         this.AssertOffsets(kernelSize, bounds, mode, mode, expected, expected);
     }
 
     [Fact]
     public void KernalSamplingMap_Kernel5Image7x7WrapBorder()
     {
-        var kernelSize = new Size(5, 5);
-        var bounds = new Rectangle(0, 0, 7, 7);
-        var mode = BorderWrappingMode.Wrap;
+        Size kernelSize = new(5, 5);
+        Rectangle bounds = new(0, 0, 7, 7);
+        BorderWrappingMode mode = BorderWrappingMode.Wrap;
         int[] expected =
-        {
+        [
             5, 6, 0, 1, 2,
             6, 0, 1, 2, 3,
             0, 1, 2, 3, 4,
             1, 2, 3, 4, 5,
             2, 3, 4, 5, 6,
             3, 4, 5, 6, 0,
-            4, 5, 6, 0, 1,
-        };
+            4, 5, 6, 0, 1
+        ];
         this.AssertOffsets(kernelSize, bounds, mode, mode, expected, expected);
     }
 
     [Fact]
     public void KernalSamplingMap_Kernel5Image9x9BounceBorder()
     {
-        var kernelSize = new Size(5, 5);
-        var bounds = new Rectangle(1, 1, 9, 9);
-        var mode = BorderWrappingMode.Bounce;
+        Size kernelSize = new(5, 5);
+        Rectangle bounds = new(1, 1, 9, 9);
+        BorderWrappingMode mode = BorderWrappingMode.Bounce;
         int[] expected =
-        {
+        [
             3, 2, 1, 2, 3,
             2, 1, 2, 3, 4,
             1, 2, 3, 4, 5,
@@ -100,19 +100,19 @@ public class KernelSamplingMapTest
             4, 5, 6, 7, 8,
             5, 6, 7, 8, 9,
             6, 7, 8, 9, 8,
-            7, 8, 9, 8, 7,
-        };
+            7, 8, 9, 8, 7
+        ];
         this.AssertOffsets(kernelSize, bounds, mode, mode, expected, expected);
     }
 
     [Fact]
     public void KernalSamplingMap_Kernel5Image9x9MirrorBorder()
     {
-        var kernelSize = new Size(5, 5);
-        var bounds = new Rectangle(1, 1, 9, 9);
-        var mode = BorderWrappingMode.Mirror;
+        Size kernelSize = new(5, 5);
+        Rectangle bounds = new(1, 1, 9, 9);
+        BorderWrappingMode mode = BorderWrappingMode.Mirror;
         int[] expected =
-        {
+        [
             2, 1, 1, 2, 3,
             1, 1, 2, 3, 4,
             1, 2, 3, 4, 5,
@@ -121,19 +121,19 @@ public class KernelSamplingMapTest
             4, 5, 6, 7, 8,
             5, 6, 7, 8, 9,
             6, 7, 8, 9, 9,
-            7, 8, 9, 9, 8,
-        };
+            7, 8, 9, 9, 8
+        ];
         this.AssertOffsets(kernelSize, bounds, mode, mode, expected, expected);
     }
 
     [Fact]
     public void KernalSamplingMap_Kernel5Image9x9WrapBorder()
     {
-        var kernelSize = new Size(5, 5);
-        var bounds = new Rectangle(1, 1, 9, 9);
-        var mode = BorderWrappingMode.Wrap;
+        Size kernelSize = new(5, 5);
+        Rectangle bounds = new(1, 1, 9, 9);
+        BorderWrappingMode mode = BorderWrappingMode.Wrap;
         int[] expected =
-        {
+        [
             8, 9, 1, 2, 3,
             9, 1, 2, 3, 4,
             1, 2, 3, 4, 5,
@@ -142,278 +142,278 @@ public class KernelSamplingMapTest
             4, 5, 6, 7, 8,
             5, 6, 7, 8, 9,
             6, 7, 8, 9, 1,
-            7, 8, 9, 1, 2,
-        };
+            7, 8, 9, 1, 2
+        ];
         this.AssertOffsets(kernelSize, bounds, mode, mode, expected, expected);
     }
 
     [Fact]
     public void KernalSamplingMap_Kernel5Image7x7RepeatBorderTile()
     {
-        var kernelSize = new Size(5, 5);
-        var bounds = new Rectangle(2, 2, 7, 7);
-        var mode = BorderWrappingMode.Repeat;
+        Size kernelSize = new(5, 5);
+        Rectangle bounds = new(2, 2, 7, 7);
+        BorderWrappingMode mode = BorderWrappingMode.Repeat;
         int[] expected =
-        {
+        [
             2, 2, 2, 3, 4,
             2, 2, 3, 4, 5,
             2, 3, 4, 5, 6,
             3, 4, 5, 6, 7,
             4, 5, 6, 7, 8,
             5, 6, 7, 8, 8,
-            6, 7, 8, 8, 8,
-        };
+            6, 7, 8, 8, 8
+        ];
         this.AssertOffsets(kernelSize, bounds, mode, mode, expected, expected);
     }
 
     [Fact]
     public void KernalSamplingMap_Kernel5Image7x7BounceBorderTile()
     {
-        var kernelSize = new Size(5, 5);
-        var bounds = new Rectangle(2, 2, 7, 7);
-        var mode = BorderWrappingMode.Bounce;
+        Size kernelSize = new(5, 5);
+        Rectangle bounds = new(2, 2, 7, 7);
+        BorderWrappingMode mode = BorderWrappingMode.Bounce;
         int[] expected =
-        {
+        [
             4, 3, 2, 3, 4,
             3, 2, 3, 4, 5,
             2, 3, 4, 5, 6,
             3, 4, 5, 6, 7,
             4, 5, 6, 7, 8,
             5, 6, 7, 8, 7,
-            6, 7, 8, 7, 6,
-        };
+            6, 7, 8, 7, 6
+        ];
         this.AssertOffsets(kernelSize, bounds, mode, mode, expected, expected);
     }
 
     [Fact]
     public void KernalSamplingMap_Kernel5Image7x7MirrorBorderTile()
     {
-        var kernelSize = new Size(5, 5);
-        var bounds = new Rectangle(2, 2, 7, 7);
-        var mode = BorderWrappingMode.Mirror;
+        Size kernelSize = new(5, 5);
+        Rectangle bounds = new(2, 2, 7, 7);
+        BorderWrappingMode mode = BorderWrappingMode.Mirror;
         int[] expected =
-        {
+        [
             3, 2, 2, 3, 4,
             2, 2, 3, 4, 5,
             2, 3, 4, 5, 6,
             3, 4, 5, 6, 7,
             4, 5, 6, 7, 8,
             5, 6, 7, 8, 8,
-            6, 7, 8, 8, 7,
-        };
+            6, 7, 8, 8, 7
+        ];
         this.AssertOffsets(kernelSize, bounds, mode, mode, expected, expected);
     }
 
     [Fact]
     public void KernalSamplingMap_Kernel5Image7x7WrapBorderTile()
     {
-        var kernelSize = new Size(5, 5);
-        var bounds = new Rectangle(2, 2, 7, 7);
-        var mode = BorderWrappingMode.Wrap;
+        Size kernelSize = new(5, 5);
+        Rectangle bounds = new(2, 2, 7, 7);
+        BorderWrappingMode mode = BorderWrappingMode.Wrap;
         int[] expected =
-        {
+        [
             7, 8, 2, 3, 4,
             8, 2, 3, 4, 5,
             2, 3, 4, 5, 6,
             3, 4, 5, 6, 7,
             4, 5, 6, 7, 8,
             5, 6, 7, 8, 2,
-            6, 7, 8, 2, 3,
-        };
+            6, 7, 8, 2, 3
+        ];
         this.AssertOffsets(kernelSize, bounds, mode, mode, expected, expected);
     }
 
     [Fact]
     public void KernalSamplingMap_Kernel3Image7x7RepeatBorder()
     {
-        var kernelSize = new Size(3, 3);
-        var bounds = new Rectangle(0, 0, 7, 7);
-        var mode = BorderWrappingMode.Repeat;
+        Size kernelSize = new(3, 3);
+        Rectangle bounds = new(0, 0, 7, 7);
+        BorderWrappingMode mode = BorderWrappingMode.Repeat;
         int[] expected =
-        {
+        [
             0, 0, 1,
             0, 1, 2,
             1, 2, 3,
             2, 3, 4,
             3, 4, 5,
             4, 5, 6,
-            5, 6, 6,
-        };
+            5, 6, 6
+        ];
         this.AssertOffsets(kernelSize, bounds, mode, mode, expected, expected);
     }
 
     [Fact]
     public void KernalSamplingMap_Kernel3Image7x7BounceBorder()
     {
-        var kernelSize = new Size(3, 3);
-        var bounds = new Rectangle(0, 0, 7, 7);
-        var mode = BorderWrappingMode.Bounce;
+        Size kernelSize = new(3, 3);
+        Rectangle bounds = new(0, 0, 7, 7);
+        BorderWrappingMode mode = BorderWrappingMode.Bounce;
         int[] expected =
-        {
+        [
             1, 0, 1,
             0, 1, 2,
             1, 2, 3,
             2, 3, 4,
             3, 4, 5,
             4, 5, 6,
-            5, 6, 5,
-        };
+            5, 6, 5
+        ];
         this.AssertOffsets(kernelSize, bounds, mode, mode, expected, expected);
     }
 
     [Fact]
     public void KernalSamplingMap_Kernel3Image7x7MirrorBorder()
     {
-        var kernelSize = new Size(3, 3);
-        var bounds = new Rectangle(0, 0, 7, 7);
-        var mode = BorderWrappingMode.Mirror;
+        Size kernelSize = new(3, 3);
+        Rectangle bounds = new(0, 0, 7, 7);
+        BorderWrappingMode mode = BorderWrappingMode.Mirror;
         int[] expected =
-        {
+        [
             0, 0, 1,
             0, 1, 2,
             1, 2, 3,
             2, 3, 4,
             3, 4, 5,
             4, 5, 6,
-            5, 6, 6,
-        };
+            5, 6, 6
+        ];
         this.AssertOffsets(kernelSize, bounds, mode, mode, expected, expected);
     }
 
     [Fact]
     public void KernalSamplingMap_Kernel3Image7x7WrapBorder()
     {
-        var kernelSize = new Size(3, 3);
-        var bounds = new Rectangle(0, 0, 7, 7);
-        var mode = BorderWrappingMode.Wrap;
+        Size kernelSize = new(3, 3);
+        Rectangle bounds = new(0, 0, 7, 7);
+        BorderWrappingMode mode = BorderWrappingMode.Wrap;
         int[] expected =
-        {
+        [
             6, 0, 1,
             0, 1, 2,
             1, 2, 3,
             2, 3, 4,
             3, 4, 5,
             4, 5, 6,
-            5, 6, 0,
-        };
+            5, 6, 0
+        ];
         this.AssertOffsets(kernelSize, bounds, mode, mode, expected, expected);
     }
 
     [Fact]
     public void KernalSamplingMap_Kernel3Image7x7RepeatBorderTile()
     {
-        var kernelSize = new Size(3, 3);
-        var bounds = new Rectangle(2, 2, 7, 7);
-        var mode = BorderWrappingMode.Repeat;
+        Size kernelSize = new(3, 3);
+        Rectangle bounds = new(2, 2, 7, 7);
+        BorderWrappingMode mode = BorderWrappingMode.Repeat;
         int[] expected =
-        {
+        [
             2, 2, 3,
             2, 3, 4,
             3, 4, 5,
             4, 5, 6,
             5, 6, 7,
             6, 7, 8,
-            7, 8, 8,
-        };
+            7, 8, 8
+        ];
         this.AssertOffsets(kernelSize, bounds, mode, mode, expected, expected);
     }
 
     [Fact]
     public void KernalSamplingMap_Kernel3Image7BounceBorderTile()
     {
-        var kernelSize = new Size(3, 3);
-        var bounds = new Rectangle(2, 2, 7, 7);
-        var mode = BorderWrappingMode.Bounce;
+        Size kernelSize = new(3, 3);
+        Rectangle bounds = new(2, 2, 7, 7);
+        BorderWrappingMode mode = BorderWrappingMode.Bounce;
         int[] expected =
-        {
+        [
             3, 2, 3,
             2, 3, 4,
             3, 4, 5,
             4, 5, 6,
             5, 6, 7,
             6, 7, 8,
-            7, 8, 7,
-        };
+            7, 8, 7
+        ];
         this.AssertOffsets(kernelSize, bounds, mode, mode, expected, expected);
     }
 
     [Fact]
     public void KernalSamplingMap_Kernel3Image7MirrorBorderTile()
     {
-        var kernelSize = new Size(3, 3);
-        var bounds = new Rectangle(2, 2, 7, 7);
-        var mode = BorderWrappingMode.Mirror;
+        Size kernelSize = new(3, 3);
+        Rectangle bounds = new(2, 2, 7, 7);
+        BorderWrappingMode mode = BorderWrappingMode.Mirror;
         int[] expected =
-        {
+        [
             2, 2, 3,
             2, 3, 4,
             3, 4, 5,
             4, 5, 6,
             5, 6, 7,
             6, 7, 8,
-            7, 8, 8,
-        };
+            7, 8, 8
+        ];
         this.AssertOffsets(kernelSize, bounds, mode, mode, expected, expected);
     }
 
     [Fact]
     public void KernalSamplingMap_Kernel3Image7x7WrapBorderTile()
     {
-        var kernelSize = new Size(3, 3);
-        var bounds = new Rectangle(2, 2, 7, 7);
-        var mode = BorderWrappingMode.Wrap;
+        Size kernelSize = new(3, 3);
+        Rectangle bounds = new(2, 2, 7, 7);
+        BorderWrappingMode mode = BorderWrappingMode.Wrap;
         int[] expected =
-        {
+        [
             8, 2, 3,
             2, 3, 4,
             3, 4, 5,
             4, 5, 6,
             5, 6, 7,
             6, 7, 8,
-            7, 8, 2,
-        };
+            7, 8, 2
+        ];
         this.AssertOffsets(kernelSize, bounds, mode, mode, expected, expected);
     }
 
     [Fact]
     public void KernalSamplingMap_Kernel3Image7x5WrapBorderTile()
     {
-        var kernelSize = new Size(3, 3);
-        var bounds = new Rectangle(2, 2, 7, 5);
-        var mode = BorderWrappingMode.Wrap;
+        Size kernelSize = new(3, 3);
+        Rectangle bounds = new(2, 2, 7, 5);
+        BorderWrappingMode mode = BorderWrappingMode.Wrap;
         int[] xExpected =
-        {
+        [
             8, 2, 3,
             2, 3, 4,
             3, 4, 5,
             4, 5, 6,
             5, 6, 7,
             6, 7, 8,
-            7, 8, 2,
-        };
+            7, 8, 2
+        ];
         int[] yExpected =
-        {
+        [
             6, 2, 3,
             2, 3, 4,
             3, 4, 5,
             4, 5, 6,
-            5, 6, 2,
-        };
+            5, 6, 2
+        ];
         this.AssertOffsets(kernelSize, bounds, mode, mode, xExpected, yExpected);
     }
 
     private void AssertOffsets(Size kernelSize, Rectangle bounds, BorderWrappingMode xBorderMode, BorderWrappingMode yBorderMode, int[] xExpected, int[] yExpected)
     {
         // Arrange
-        var map = new KernelSamplingMap(Configuration.Default.MemoryAllocator);
+        KernelSamplingMap map = new(Configuration.Default.MemoryAllocator);
 
         // Act
         map.BuildSamplingOffsetMap(kernelSize.Height, kernelSize.Width, bounds, xBorderMode, yBorderMode);
 
         // Assert
-        var xOffsets = map.GetColumnOffsetSpan().ToArray();
+        int[] xOffsets = map.GetColumnOffsetSpan().ToArray();
         Assert.Equal(xExpected, xOffsets);
-        var yOffsets = map.GetRowOffsetSpan().ToArray();
+        int[] yOffsets = map.GetRowOffsetSpan().ToArray();
         Assert.Equal(yExpected, yOffsets);
     }
 }
diff --git a/tests/ImageSharp.Tests/Processing/Convolution/Processors/LaplacianKernelFactoryTests.cs b/tests/ImageSharp.Tests/Processing/Convolution/Processors/LaplacianKernelFactoryTests.cs
index 800cb06ac1..6c6fa6b2be 100644
--- a/tests/ImageSharp.Tests/Processing/Convolution/Processors/LaplacianKernelFactoryTests.cs
+++ b/tests/ImageSharp.Tests/Processing/Convolution/Processors/LaplacianKernelFactoryTests.cs
@@ -7,9 +7,9 @@ namespace SixLabors.ImageSharp.Tests.Processing.Convolution.Processors;
 
 public class LaplacianKernelFactoryTests
 {
-    private static readonly ApproximateFloatComparer ApproximateComparer = new ApproximateFloatComparer(0.0001F);
+    private static readonly ApproximateFloatComparer ApproximateComparer = new(0.0001F);
 
-    private static readonly DenseMatrix<float> Expected3x3Matrix = new DenseMatrix<float>(
+    private static readonly DenseMatrix<float> Expected3x3Matrix = new(
         new float[,]
             {
                 { -1, -1, -1 },
@@ -17,7 +17,7 @@ public class LaplacianKernelFactoryTests
                 { -1, -1, -1 }
             });
 
-    private static readonly DenseMatrix<float> Expected5x5Matrix = new DenseMatrix<float>(
+    private static readonly DenseMatrix<float> Expected5x5Matrix = new(
         new float[,]
             {
                 { -1, -1, -1, -1, -1 },
diff --git a/tests/ImageSharp.Tests/Processing/Dithering/DitherTest.cs b/tests/ImageSharp.Tests/Processing/Dithering/DitherTest.cs
index 1b3d1bd9ac..43785da6e7 100644
--- a/tests/ImageSharp.Tests/Processing/Dithering/DitherTest.cs
+++ b/tests/ImageSharp.Tests/Processing/Dithering/DitherTest.cs
@@ -20,11 +20,11 @@ public class DitherTest : BaseImageOperationsExtensionTest
     private readonly IDither orderedDither;
     private readonly IDither errorDiffuser;
     private readonly Color[] testPalette =
-    {
+    [
         Color.Red,
         Color.Green,
         Color.Blue
-    };
+    ];
 
     public DitherTest()
     {
diff --git a/tests/ImageSharp.Tests/Processing/Effects/OilPaintTest.cs b/tests/ImageSharp.Tests/Processing/Effects/OilPaintTest.cs
index 6d5973dbbb..b24ab6c817 100644
--- a/tests/ImageSharp.Tests/Processing/Effects/OilPaintTest.cs
+++ b/tests/ImageSharp.Tests/Processing/Effects/OilPaintTest.cs
@@ -13,7 +13,7 @@ public class OilPaintTest : BaseImageOperationsExtensionTest
     public void OilPaint_OilPaintingProcessorDefaultsSet()
     {
         this.operations.OilPaint();
-        var processor = this.Verify<OilPaintingProcessor>();
+        OilPaintingProcessor processor = this.Verify<OilPaintingProcessor>();
 
         Assert.Equal(10, processor.Levels);
         Assert.Equal(15, processor.BrushSize);
@@ -23,7 +23,7 @@ public class OilPaintTest : BaseImageOperationsExtensionTest
     public void OilPaint_rect_OilPaintingProcessorDefaultsSet()
     {
         this.operations.OilPaint(this.rect);
-        var processor = this.Verify<OilPaintingProcessor>(this.rect);
+        OilPaintingProcessor processor = this.Verify<OilPaintingProcessor>(this.rect);
 
         Assert.Equal(10, processor.Levels);
         Assert.Equal(15, processor.BrushSize);
@@ -33,7 +33,7 @@ public class OilPaintTest : BaseImageOperationsExtensionTest
     public void OilPaint_Levels_Brush_OilPaintingProcessorDefaultsSet()
     {
         this.operations.OilPaint(34, 65);
-        var processor = this.Verify<OilPaintingProcessor>();
+        OilPaintingProcessor processor = this.Verify<OilPaintingProcessor>();
 
         Assert.Equal(34, processor.Levels);
         Assert.Equal(65, processor.BrushSize);
@@ -43,7 +43,7 @@ public class OilPaintTest : BaseImageOperationsExtensionTest
     public void OilPaint_Levels_Brush_rect_OilPaintingProcessorDefaultsSet()
     {
         this.operations.OilPaint(54, 43, this.rect);
-        var processor = this.Verify<OilPaintingProcessor>(this.rect);
+        OilPaintingProcessor processor = this.Verify<OilPaintingProcessor>(this.rect);
 
         Assert.Equal(54, processor.Levels);
         Assert.Equal(43, processor.BrushSize);
diff --git a/tests/ImageSharp.Tests/Processing/Effects/PixelateTest.cs b/tests/ImageSharp.Tests/Processing/Effects/PixelateTest.cs
index 6531f7b442..f557183d6e 100644
--- a/tests/ImageSharp.Tests/Processing/Effects/PixelateTest.cs
+++ b/tests/ImageSharp.Tests/Processing/Effects/PixelateTest.cs
@@ -13,7 +13,7 @@ public class PixelateTest : BaseImageOperationsExtensionTest
     public void Pixelate_PixelateProcessorDefaultsSet()
     {
         this.operations.Pixelate();
-        var processor = this.Verify<PixelateProcessor>();
+        PixelateProcessor processor = this.Verify<PixelateProcessor>();
 
         Assert.Equal(4, processor.Size);
     }
@@ -22,7 +22,7 @@ public class PixelateTest : BaseImageOperationsExtensionTest
     public void Pixelate_Size_PixelateProcessorDefaultsSet()
     {
         this.operations.Pixelate(12);
-        var processor = this.Verify<PixelateProcessor>();
+        PixelateProcessor processor = this.Verify<PixelateProcessor>();
 
         Assert.Equal(12, processor.Size);
     }
@@ -31,7 +31,7 @@ public class PixelateTest : BaseImageOperationsExtensionTest
     public void Pixelate_Size_rect_PixelateProcessorDefaultsSet()
     {
         this.operations.Pixelate(23, this.rect);
-        var processor = this.Verify<PixelateProcessor>(this.rect);
+        PixelateProcessor processor = this.Verify<PixelateProcessor>(this.rect);
 
         Assert.Equal(23, processor.Size);
     }
diff --git a/tests/ImageSharp.Tests/Processing/FakeImageOperationsProvider.cs b/tests/ImageSharp.Tests/Processing/FakeImageOperationsProvider.cs
index 17f63384e0..f55500f99f 100644
--- a/tests/ImageSharp.Tests/Processing/FakeImageOperationsProvider.cs
+++ b/tests/ImageSharp.Tests/Processing/FakeImageOperationsProvider.cs
@@ -10,7 +10,7 @@ namespace SixLabors.ImageSharp.Tests.Processing;
 
 internal class FakeImageOperationsProvider : IImageProcessingContextFactory
 {
-    private readonly List<object> imageOperators = new List<object>();
+    private readonly List<object> imageOperators = [];
 
     public bool HasCreated<TPixel>(Image<TPixel> source)
         where TPixel : unmanaged, IPixel<TPixel>
@@ -35,7 +35,7 @@ internal class FakeImageOperationsProvider : IImageProcessingContextFactory
     public IInternalImageProcessingContext<TPixel> CreateImageProcessingContext<TPixel>(Configuration configuration, Image<TPixel> source, bool mutate)
         where TPixel : unmanaged, IPixel<TPixel>
     {
-        var op = new FakeImageOperations<TPixel>(configuration, source, mutate);
+        FakeImageOperations<TPixel> op = new(configuration, source, mutate);
         this.imageOperators.Add(op);
         return op;
     }
@@ -51,7 +51,7 @@ internal class FakeImageOperationsProvider : IImageProcessingContextFactory
 
         public Image<TPixel> Source { get; }
 
-        public List<AppliedOperation> Applied { get; } = new List<AppliedOperation>();
+        public List<AppliedOperation> Applied { get; } = [];
 
         public Configuration Configuration { get; }
 
diff --git a/tests/ImageSharp.Tests/Processing/Filters/BrightnessTest.cs b/tests/ImageSharp.Tests/Processing/Filters/BrightnessTest.cs
index 87436e4a35..1352124004 100644
--- a/tests/ImageSharp.Tests/Processing/Filters/BrightnessTest.cs
+++ b/tests/ImageSharp.Tests/Processing/Filters/BrightnessTest.cs
@@ -31,7 +31,7 @@ public class BrightnessTest : BaseImageOperationsExtensionTest
     [Fact]
     public void Brightness_scaled_vector()
     {
-        var rgbImage = new Image<Rgb24>(Configuration.Default, 100, 100, new Rgb24(0, 0, 0));
+        Image<Rgb24> rgbImage = new(Configuration.Default, 100, 100, new Rgb24(0, 0, 0));
 
         rgbImage.Mutate(x => x.ApplyProcessor(new BrightnessProcessor(2)));
 
@@ -43,7 +43,7 @@ public class BrightnessTest : BaseImageOperationsExtensionTest
 
         Assert.Equal(new Rgb24(20, 20, 20), rgbImage[0, 0]);
 
-        var halfSingleImage = new Image<HalfSingle>(Configuration.Default, 100, 100, new HalfSingle(-1));
+        Image<HalfSingle> halfSingleImage = new(Configuration.Default, 100, 100, new HalfSingle(-1));
 
         halfSingleImage.Mutate(x => x.ApplyProcessor(new BrightnessProcessor(2)));
 
diff --git a/tests/ImageSharp.Tests/Processing/Filters/ColorBlindnessTest.cs b/tests/ImageSharp.Tests/Processing/Filters/ColorBlindnessTest.cs
index 7fb93bba54..f00087e1c0 100644
--- a/tests/ImageSharp.Tests/Processing/Filters/ColorBlindnessTest.cs
+++ b/tests/ImageSharp.Tests/Processing/Filters/ColorBlindnessTest.cs
@@ -11,17 +11,17 @@ namespace SixLabors.ImageSharp.Tests.Processing.Filters;
 [Trait("Category", "Processors")]
 public class ColorBlindnessTest : BaseImageOperationsExtensionTest
 {
-    public static IEnumerable<object[]> TheoryData = new[]
-    {
-        new object[] { new TestType<AchromatomalyProcessor>(), ColorBlindnessMode.Achromatomaly },
-        new object[] { new TestType<AchromatopsiaProcessor>(), ColorBlindnessMode.Achromatopsia },
-        new object[] { new TestType<DeuteranomalyProcessor>(), ColorBlindnessMode.Deuteranomaly },
-        new object[] { new TestType<DeuteranopiaProcessor>(), ColorBlindnessMode.Deuteranopia },
-        new object[] { new TestType<ProtanomalyProcessor>(), ColorBlindnessMode.Protanomaly },
-        new object[] { new TestType<ProtanopiaProcessor>(), ColorBlindnessMode.Protanopia },
-        new object[] { new TestType<TritanomalyProcessor>(), ColorBlindnessMode.Tritanomaly },
-        new object[] { new TestType<TritanopiaProcessor>(), ColorBlindnessMode.Tritanopia }
-    };
+    public static IEnumerable<object[]> TheoryData =
+    [
+        [new TestType<AchromatomalyProcessor>(), ColorBlindnessMode.Achromatomaly],
+        [new TestType<AchromatopsiaProcessor>(), ColorBlindnessMode.Achromatopsia],
+        [new TestType<DeuteranomalyProcessor>(), ColorBlindnessMode.Deuteranomaly],
+        [new TestType<DeuteranopiaProcessor>(), ColorBlindnessMode.Deuteranopia],
+        [new TestType<ProtanomalyProcessor>(), ColorBlindnessMode.Protanomaly],
+        [new TestType<ProtanopiaProcessor>(), ColorBlindnessMode.Protanopia],
+        [new TestType<TritanomalyProcessor>(), ColorBlindnessMode.Tritanomaly],
+        [new TestType<TritanopiaProcessor>(), ColorBlindnessMode.Tritanopia]
+    ];
 
     [Theory]
     [MemberData(nameof(TheoryData))]
diff --git a/tests/ImageSharp.Tests/Processing/Filters/GrayscaleTest.cs b/tests/ImageSharp.Tests/Processing/Filters/GrayscaleTest.cs
index 36edc10e5d..6f0f06535f 100644
--- a/tests/ImageSharp.Tests/Processing/Filters/GrayscaleTest.cs
+++ b/tests/ImageSharp.Tests/Processing/Filters/GrayscaleTest.cs
@@ -11,10 +11,10 @@ namespace SixLabors.ImageSharp.Tests.Processing.Filters;
 [Trait("Category", "Processors")]
 public class GrayscaleTest : BaseImageOperationsExtensionTest
 {
-    public static IEnumerable<object[]> ModeTheoryData = new[]
-    {
-        new object[] { new TestType<GrayscaleBt709Processor>(), GrayscaleMode.Bt709 }
-    };
+    public static IEnumerable<object[]> ModeTheoryData =
+    [
+        [new TestType<GrayscaleBt709Processor>(), GrayscaleMode.Bt709]
+    ];
 
     [Theory]
     [MemberData(nameof(ModeTheoryData))]
diff --git a/tests/ImageSharp.Tests/Processing/Filters/HueTest.cs b/tests/ImageSharp.Tests/Processing/Filters/HueTest.cs
index 0c197a96f7..33deb715ba 100644
--- a/tests/ImageSharp.Tests/Processing/Filters/HueTest.cs
+++ b/tests/ImageSharp.Tests/Processing/Filters/HueTest.cs
@@ -13,7 +13,7 @@ public class HueTest : BaseImageOperationsExtensionTest
     public void Hue_amount_HueProcessorDefaultsSet()
     {
         this.operations.Hue(34f);
-        var processor = this.Verify<HueProcessor>();
+        HueProcessor processor = this.Verify<HueProcessor>();
 
         Assert.Equal(34f, processor.Degrees);
     }
@@ -22,7 +22,7 @@ public class HueTest : BaseImageOperationsExtensionTest
     public void Hue_amount_rect_HueProcessorDefaultsSet()
     {
         this.operations.Hue(5f, this.rect);
-        var processor = this.Verify<HueProcessor>(this.rect);
+        HueProcessor processor = this.Verify<HueProcessor>(this.rect);
 
         Assert.Equal(5f, processor.Degrees);
     }
diff --git a/tests/ImageSharp.Tests/Processing/Filters/LomographTest.cs b/tests/ImageSharp.Tests/Processing/Filters/LomographTest.cs
index e84bd243e4..f68ecef08f 100644
--- a/tests/ImageSharp.Tests/Processing/Filters/LomographTest.cs
+++ b/tests/ImageSharp.Tests/Processing/Filters/LomographTest.cs
@@ -13,7 +13,7 @@ public class LomographTest : BaseImageOperationsExtensionTest
     public void Lomograph_amount_LomographProcessorDefaultsSet()
     {
         this.operations.Lomograph();
-        var processor = this.Verify<LomographProcessor>();
+        LomographProcessor processor = this.Verify<LomographProcessor>();
         Assert.Equal(processor.GraphicsOptions, this.options);
     }
 
@@ -21,7 +21,7 @@ public class LomographTest : BaseImageOperationsExtensionTest
     public void Lomograph_amount_rect_LomographProcessorDefaultsSet()
     {
         this.operations.Lomograph(this.rect);
-        var processor = this.Verify<LomographProcessor>(this.rect);
+        LomographProcessor processor = this.Verify<LomographProcessor>(this.rect);
         Assert.Equal(processor.GraphicsOptions, this.options);
     }
 }
diff --git a/tests/ImageSharp.Tests/Processing/Filters/PolaroidTest.cs b/tests/ImageSharp.Tests/Processing/Filters/PolaroidTest.cs
index 7d3e0aed0f..89d8d47bcf 100644
--- a/tests/ImageSharp.Tests/Processing/Filters/PolaroidTest.cs
+++ b/tests/ImageSharp.Tests/Processing/Filters/PolaroidTest.cs
@@ -13,7 +13,7 @@ public class PolaroidTest : BaseImageOperationsExtensionTest
     public void Polaroid_amount_PolaroidProcessorDefaultsSet()
     {
         this.operations.Polaroid();
-        var processor = this.Verify<PolaroidProcessor>();
+        PolaroidProcessor processor = this.Verify<PolaroidProcessor>();
         Assert.Equal(processor.GraphicsOptions, this.options);
     }
 
@@ -21,7 +21,7 @@ public class PolaroidTest : BaseImageOperationsExtensionTest
     public void Polaroid_amount_rect_PolaroidProcessorDefaultsSet()
     {
         this.operations.Polaroid(this.rect);
-        var processor = this.Verify<PolaroidProcessor>(this.rect);
+        PolaroidProcessor processor = this.Verify<PolaroidProcessor>(this.rect);
         Assert.Equal(processor.GraphicsOptions, this.options);
     }
 }
diff --git a/tests/ImageSharp.Tests/Processing/ImageOperationTests.cs b/tests/ImageSharp.Tests/Processing/ImageOperationTests.cs
index 744e26d8f7..09fbcdc70c 100644
--- a/tests/ImageSharp.Tests/Processing/ImageOperationTests.cs
+++ b/tests/ImageSharp.Tests/Processing/ImageOperationTests.cs
@@ -24,7 +24,7 @@ public class ImageOperationTests : IDisposable
     {
         this.provider = new FakeImageOperationsProvider();
 
-        var processorMock = new Mock<IImageProcessor>();
+        Mock<IImageProcessor> processorMock = new();
         this.processorDefinition = processorMock.Object;
 
         this.image = new Image<Rgba32>(
@@ -103,7 +103,7 @@ public class ImageOperationTests : IDisposable
     [Fact]
     public void ApplyProcessors_ListOfProcessors_AppliesAllProcessorsToOperation()
     {
-        var operations = new FakeImageOperationsProvider.FakeImageOperations<Rgba32>(Configuration.Default, null, false);
+        FakeImageOperationsProvider.FakeImageOperations<Rgba32> operations = new(Configuration.Default, null, false);
         operations.ApplyProcessors(this.processorDefinition);
         Assert.Contains(this.processorDefinition, operations.Applied.Select(x => x.NonGenericProcessor));
     }
@@ -152,7 +152,7 @@ public class ImageOperationTests : IDisposable
     {
         try
         {
-            var img = new Image<Rgba32>(1, 1);
+            Image<Rgba32> img = new(1, 1);
             img.Dispose();
             img.EnsureNotDisposed();
         }
diff --git a/tests/ImageSharp.Tests/Processing/ImageProcessingContextTests.cs b/tests/ImageSharp.Tests/Processing/ImageProcessingContextTests.cs
index 88707c60ff..e39d8075ba 100644
--- a/tests/ImageSharp.Tests/Processing/ImageProcessingContextTests.cs
+++ b/tests/ImageSharp.Tests/Processing/ImageProcessingContextTests.cs
@@ -23,7 +23,7 @@ public class ImageProcessingContextTests : IDisposable
 
     private readonly Mock<ICloningImageProcessor<Rgba32>> cloningProcessorImpl;
 
-    private static readonly Rectangle Bounds = new Rectangle(3, 3, 5, 5);
+    private static readonly Rectangle Bounds = new(3, 3, 5, 5);
 
     public ImageProcessingContextTests()
     {
@@ -34,7 +34,7 @@ public class ImageProcessingContextTests : IDisposable
     }
 
     // bool throwException, bool useBounds
-    public static readonly TheoryData<bool, bool> ProcessorTestData = new TheoryData<bool, bool>()
+    public static readonly TheoryData<bool, bool> ProcessorTestData = new()
     {
         { false, false },
         { false, true },
diff --git a/tests/ImageSharp.Tests/Processing/Normalization/HistogramEqualizationTests.cs b/tests/ImageSharp.Tests/Processing/Normalization/HistogramEqualizationTests.cs
index 60e33835af..c39648d014 100644
--- a/tests/ImageSharp.Tests/Processing/Normalization/HistogramEqualizationTests.cs
+++ b/tests/ImageSharp.Tests/Processing/Normalization/HistogramEqualizationTests.cs
@@ -21,7 +21,7 @@ public class HistogramEqualizationTests
     {
         // Arrange
         byte[] pixels =
-        {
+        [
             52,  55,  61,  59,  70,  61,  76,  61,
             62,  59,  55, 104,  94,  85,  59,  71,
             63,  65,  66, 113, 144, 104,  63,  72,
@@ -30,9 +30,9 @@ public class HistogramEqualizationTests
             68,  79,  60,  79,  77,  66,  58,  75,
             69,  85,  64,  58,  55,  61,  65,  83,
             70,  87,  69,  68,  65,  73,  78,  90
-        };
+        ];
 
-        using (var image = new Image<Rgba32>(8, 8))
+        using (Image<Rgba32> image = new(8, 8))
         {
             for (int y = 0; y < 8; y++)
             {
@@ -44,7 +44,7 @@ public class HistogramEqualizationTests
             }
 
             byte[] expected =
-            {
+            [
                 0,    12,   53,   32,  146,   53,  174,   53,
                 57,   32,   12,  227,  219,  202,   32,  154,
                 65,   85,   93,  239,  251,  227,   65,  158,
@@ -53,7 +53,7 @@ public class HistogramEqualizationTests
                 117, 190,   36,  190,  178,   93,   20,  170,
                 130, 202,   73,   20,   12,   53,   85,  194,
                 146, 206,  130,  117,   85,  166,  182,  215
-            };
+            ];
 
             // Act
             image.Mutate(x => x.HistogramEqualization(new HistogramEqualizationOptions
@@ -83,7 +83,7 @@ public class HistogramEqualizationTests
     {
         using (Image<TPixel> image = provider.GetImage())
         {
-            var options = new HistogramEqualizationOptions
+            HistogramEqualizationOptions options = new()
             {
                 Method = HistogramEqualizationMethod.Global,
                 LuminanceLevels = 256,
@@ -101,7 +101,7 @@ public class HistogramEqualizationTests
     {
         using (Image<TPixel> image = provider.GetImage())
         {
-            var options = new HistogramEqualizationOptions
+            HistogramEqualizationOptions options = new()
             {
                 Method = HistogramEqualizationMethod.AdaptiveSlidingWindow,
                 LuminanceLevels = 256,
@@ -121,7 +121,7 @@ public class HistogramEqualizationTests
     {
         using (Image<TPixel> image = provider.GetImage())
         {
-            var options = new HistogramEqualizationOptions
+            HistogramEqualizationOptions options = new()
             {
                 Method = HistogramEqualizationMethod.AdaptiveTileInterpolation,
                 LuminanceLevels = 256,
@@ -141,7 +141,7 @@ public class HistogramEqualizationTests
     {
         using (Image<TPixel> image = provider.GetImage())
         {
-            var options = new HistogramEqualizationOptions
+            HistogramEqualizationOptions options = new()
             {
                 Method = HistogramEqualizationMethod.AutoLevel,
                 LuminanceLevels = 256,
@@ -160,7 +160,7 @@ public class HistogramEqualizationTests
     {
         using (Image<TPixel> image = provider.GetImage())
         {
-            var options = new HistogramEqualizationOptions
+            HistogramEqualizationOptions options = new()
             {
                 Method = HistogramEqualizationMethod.AutoLevel,
                 LuminanceLevels = 256,
@@ -187,7 +187,7 @@ public class HistogramEqualizationTests
     {
         using (Image<TPixel> image = provider.GetImage())
         {
-            var options = new HistogramEqualizationOptions()
+            HistogramEqualizationOptions options = new()
             {
                 Method = HistogramEqualizationMethod.AdaptiveTileInterpolation,
                 LuminanceLevels = 256,
@@ -214,7 +214,7 @@ public class HistogramEqualizationTests
         // https://github.com/SixLabors/ImageSharp/discussions/1640
         // Test using isolated memory to ensure clean buffers for reference
         provider.Configuration = Configuration.CreateDefaultInstance();
-        var options = new HistogramEqualizationOptions
+        HistogramEqualizationOptions options = new()
         {
             Method = HistogramEqualizationMethod.AdaptiveTileInterpolation,
             LuminanceLevels = 4096,
diff --git a/tests/ImageSharp.Tests/Processing/Overlays/GlowTest.cs b/tests/ImageSharp.Tests/Processing/Overlays/GlowTest.cs
index 7eec6eb0c1..c7881597ab 100644
--- a/tests/ImageSharp.Tests/Processing/Overlays/GlowTest.cs
+++ b/tests/ImageSharp.Tests/Processing/Overlays/GlowTest.cs
@@ -45,7 +45,7 @@ public class GlowTest : BaseImageOperationsExtensionTest
     [Fact]
     public void Glow_Rect_GlowProcessorWithDefaultValues()
     {
-        var rect = new Rectangle(12, 123, 43, 65);
+        Rectangle rect = new(12, 123, 43, 65);
         this.operations.Glow(rect);
         GlowProcessor p = this.Verify<GlowProcessor>(rect);
 
diff --git a/tests/ImageSharp.Tests/Processing/Overlays/VignetteTest.cs b/tests/ImageSharp.Tests/Processing/Overlays/VignetteTest.cs
index 1602b5c7a2..e222c566ff 100644
--- a/tests/ImageSharp.Tests/Processing/Overlays/VignetteTest.cs
+++ b/tests/ImageSharp.Tests/Processing/Overlays/VignetteTest.cs
@@ -48,7 +48,7 @@ public class VignetteTest : BaseImageOperationsExtensionTest
     [Fact]
     public void Vignette_Rect_VignetteProcessorWithDefaultValues()
     {
-        var rect = new Rectangle(12, 123, 43, 65);
+        Rectangle rect = new(12, 123, 43, 65);
         this.operations.Vignette(rect);
         VignetteProcessor p = this.Verify<VignetteProcessor>(rect);
 
diff --git a/tests/ImageSharp.Tests/Processing/Processors/Binarization/BinaryDitherTests.cs b/tests/ImageSharp.Tests/Processing/Processors/Binarization/BinaryDitherTests.cs
index 9694aeb222..62682e837c 100644
--- a/tests/ImageSharp.Tests/Processing/Processors/Binarization/BinaryDitherTests.cs
+++ b/tests/ImageSharp.Tests/Processing/Processors/Binarization/BinaryDitherTests.cs
@@ -13,11 +13,11 @@ namespace SixLabors.ImageSharp.Tests.Processing.Processors.Binarization;
 public class BinaryDitherTests
 {
     public static readonly string[] CommonTestImages =
-        {
-            TestImages.Png.CalliphoraPartial, TestImages.Png.Bike
-        };
+    [
+        TestImages.Png.CalliphoraPartial, TestImages.Png.Bike
+    ];
 
-    public static readonly TheoryData<string, IDither> OrderedDitherers = new TheoryData<string, IDither>
+    public static readonly TheoryData<string, IDither> OrderedDitherers = new()
     {
         { "Bayer8x8", KnownDitherings.Bayer8x8 },
         { "Bayer4x4", KnownDitherings.Bayer4x4 },
@@ -25,7 +25,7 @@ public class BinaryDitherTests
         { "Bayer2x2", KnownDitherings.Bayer2x2 }
     };
 
-    public static readonly TheoryData<string, IDither> ErrorDiffusers = new TheoryData<string, IDither>
+    public static readonly TheoryData<string, IDither> ErrorDiffusers = new()
     {
         { "Atkinson", KnownDitherings.Atkinson },
         { "Burks", KnownDitherings.Burks },
@@ -102,7 +102,7 @@ public class BinaryDitherTests
         using (Image<TPixel> source = provider.GetImage())
         using (Image<TPixel> image = source.Clone())
         {
-            var bounds = new Rectangle(10, 10, image.Width / 2, image.Height / 2);
+            Rectangle bounds = new(10, 10, image.Width / 2, image.Height / 2);
 
             image.Mutate(x => x.BinaryDither(DefaultDitherer, bounds));
             image.DebugSave(provider);
@@ -119,7 +119,7 @@ public class BinaryDitherTests
         using (Image<TPixel> source = provider.GetImage())
         using (Image<TPixel> image = source.Clone())
         {
-            var bounds = new Rectangle(10, 10, image.Width / 2, image.Height / 2);
+            Rectangle bounds = new(10, 10, image.Width / 2, image.Height / 2);
 
             image.Mutate(x => x.BinaryDither(DefaultErrorDiffuser, bounds));
             image.DebugSave(provider);
diff --git a/tests/ImageSharp.Tests/Processing/Processors/Binarization/BinaryThresholdTest.cs b/tests/ImageSharp.Tests/Processing/Processors/Binarization/BinaryThresholdTest.cs
index ecbbb21abd..c9d3f69143 100644
--- a/tests/ImageSharp.Tests/Processing/Processors/Binarization/BinaryThresholdTest.cs
+++ b/tests/ImageSharp.Tests/Processing/Processors/Binarization/BinaryThresholdTest.cs
@@ -12,17 +12,17 @@ namespace SixLabors.ImageSharp.Tests.Processing.Processors.Binarization;
 public class BinaryThresholdTest
 {
     public static readonly TheoryData<float> BinaryThresholdValues
-        = new TheoryData<float>
-    {
+        = new()
+        {
         .25F,
         .75F
     };
 
     public static readonly string[] CommonTestImages =
-    {
+    [
         TestImages.Png.Rgb48Bpp,
-        TestImages.Png.ColorsSaturationLightness,
-    };
+        TestImages.Png.ColorsSaturationLightness
+    ];
 
     public const PixelTypes TestPixelTypes = PixelTypes.Rgba32 | PixelTypes.Bgra32 | PixelTypes.Rgb24;
 
@@ -46,7 +46,7 @@ public class BinaryThresholdTest
         using (Image<TPixel> source = provider.GetImage())
         using (Image<TPixel> image = source.Clone())
         {
-            var bounds = new Rectangle(image.Width / 8, image.Height / 8, 6 * image.Width / 8, 6 * image.Width / 8);
+            Rectangle bounds = new(image.Width / 8, image.Height / 8, 6 * image.Width / 8, 6 * image.Width / 8);
 
             image.Mutate(x => x.BinaryThreshold(value, bounds));
             image.DebugSave(provider, value);
@@ -76,7 +76,7 @@ public class BinaryThresholdTest
         using (Image<TPixel> source = provider.GetImage())
         using (Image<TPixel> image = source.Clone())
         {
-            var bounds = new Rectangle(image.Width / 8, image.Height / 8, 6 * image.Width / 8, 6 * image.Width / 8);
+            Rectangle bounds = new(image.Width / 8, image.Height / 8, 6 * image.Width / 8, 6 * image.Width / 8);
 
             image.Mutate(x => x.BinaryThreshold(value, BinaryThresholdMode.Saturation, bounds));
             image.DebugSave(provider, value);
@@ -96,7 +96,7 @@ public class BinaryThresholdTest
 
             if (!TestEnvironment.Is64BitProcess && TestEnvironment.IsFramework)
             {
-                var comparer = ImageComparer.TolerantPercentage(0.0004F);
+                ImageComparer comparer = ImageComparer.TolerantPercentage(0.0004F);
                 image.CompareToReferenceOutput(comparer, provider, value.ToString("0.00", NumberFormatInfo.InvariantInfo));
             }
             else
@@ -114,14 +114,14 @@ public class BinaryThresholdTest
         using (Image<TPixel> source = provider.GetImage())
         using (Image<TPixel> image = source.Clone())
         {
-            var bounds = new Rectangle(image.Width / 8, image.Height / 8, 6 * image.Width / 8, 6 * image.Width / 8);
+            Rectangle bounds = new(image.Width / 8, image.Height / 8, 6 * image.Width / 8, 6 * image.Width / 8);
 
             image.Mutate(x => x.BinaryThreshold(value, BinaryThresholdMode.MaxChroma, bounds));
             image.DebugSave(provider, value);
 
             if (!TestEnvironment.Is64BitProcess && TestEnvironment.IsFramework)
             {
-                var comparer = ImageComparer.TolerantPercentage(0.0004F);
+                ImageComparer comparer = ImageComparer.TolerantPercentage(0.0004F);
                 image.CompareToReferenceOutput(comparer, provider, value.ToString("0.00", NumberFormatInfo.InvariantInfo));
             }
             else
diff --git a/tests/ImageSharp.Tests/Processing/Processors/Convolution/Basic1ParameterConvolutionTests.cs b/tests/ImageSharp.Tests/Processing/Processors/Convolution/Basic1ParameterConvolutionTests.cs
index 13ddf85c1e..1eec353689 100644
--- a/tests/ImageSharp.Tests/Processing/Processors/Convolution/Basic1ParameterConvolutionTests.cs
+++ b/tests/ImageSharp.Tests/Processing/Processors/Convolution/Basic1ParameterConvolutionTests.cs
@@ -12,14 +12,14 @@ public abstract class Basic1ParameterConvolutionTests
 {
     private static readonly ImageComparer ValidatorComparer = ImageComparer.TolerantPercentage(0.05F);
 
-    public static readonly TheoryData<int> Values = new TheoryData<int> { 3, 5 };
+    public static readonly TheoryData<int> Values = new() { 3, 5 };
 
     public static readonly string[] InputImages =
-    {
+    [
         TestImages.Bmp.Car,
         TestImages.Png.CalliphoraPartial,
         TestImages.Png.Blur
-    };
+    ];
 
     [Theory]
     [WithFileCollection(nameof(InputImages), nameof(Values), PixelTypes.Rgba32)]
diff --git a/tests/ImageSharp.Tests/Processing/Processors/Convolution/ConvolutionTests.cs b/tests/ImageSharp.Tests/Processing/Processors/Convolution/ConvolutionTests.cs
index 0cb56b732d..468965f1e2 100644
--- a/tests/ImageSharp.Tests/Processing/Processors/Convolution/ConvolutionTests.cs
+++ b/tests/ImageSharp.Tests/Processing/Processors/Convolution/ConvolutionTests.cs
@@ -12,7 +12,7 @@ public class ConvolutionTests
 {
     private static readonly ImageComparer ValidatorComparer = ImageComparer.TolerantPercentage(0.05F);
 
-    public static readonly TheoryData<DenseMatrix<float>> Values = new TheoryData<DenseMatrix<float>>
+    public static readonly TheoryData<DenseMatrix<float>> Values = new()
     {
         // Sharpening kernel.
         new float[,]
diff --git a/tests/ImageSharp.Tests/Processing/Processors/Convolution/DetectEdgesTest.cs b/tests/ImageSharp.Tests/Processing/Processors/Convolution/DetectEdgesTest.cs
index d51012f9ec..be3fc1e500 100644
--- a/tests/ImageSharp.Tests/Processing/Processors/Convolution/DetectEdgesTest.cs
+++ b/tests/ImageSharp.Tests/Processing/Processors/Convolution/DetectEdgesTest.cs
@@ -17,21 +17,21 @@ public class DetectEdgesTest
 
     private static readonly ImageComparer TransparentComparer = ImageComparer.TolerantPercentage(0.5F);
 
-    public static readonly string[] TestImages = { Tests.TestImages.Png.Bike };
+    public static readonly string[] TestImages = [Tests.TestImages.Png.Bike];
 
     public const PixelTypes CommonNonDefaultPixelTypes = PixelTypes.Rgba32 | PixelTypes.Bgra32 | PixelTypes.RgbaVector;
 
     public static readonly TheoryData<EdgeDetectorKernel, string> DetectEdgesFilters
-        = new TheoryData<EdgeDetectorKernel, string>
-    {
+        = new()
+        {
         { KnownEdgeDetectorKernels.Laplacian3x3, nameof(KnownEdgeDetectorKernels.Laplacian3x3) },
         { KnownEdgeDetectorKernels.Laplacian5x5, nameof(KnownEdgeDetectorKernels.Laplacian5x5) },
         { KnownEdgeDetectorKernels.LaplacianOfGaussian, nameof(KnownEdgeDetectorKernels.LaplacianOfGaussian) },
     };
 
     public static readonly TheoryData<EdgeDetector2DKernel, string> DetectEdges2DFilters
-        = new TheoryData<EdgeDetector2DKernel, string>
-    {
+        = new()
+        {
         { KnownEdgeDetectorKernels.Kayyali, nameof(KnownEdgeDetectorKernels.Kayyali) },
         { KnownEdgeDetectorKernels.Prewitt, nameof(KnownEdgeDetectorKernels.Prewitt) },
         { KnownEdgeDetectorKernels.RobertsCross, nameof(KnownEdgeDetectorKernels.RobertsCross) },
@@ -40,8 +40,8 @@ public class DetectEdgesTest
     };
 
     public static readonly TheoryData<EdgeDetectorCompassKernel, string> DetectEdgesCompassFilters
-        = new TheoryData<EdgeDetectorCompassKernel, string>
-    {
+        = new()
+        {
         { KnownEdgeDetectorKernels.Kirsch, nameof(KnownEdgeDetectorKernels.Kirsch) },
         { KnownEdgeDetectorKernels.Robinson, nameof(KnownEdgeDetectorKernels.Robinson) },
     };
@@ -55,7 +55,7 @@ public class DetectEdgesTest
             ctx =>
                 {
                     Size size = ctx.GetCurrentSize();
-                    var bounds = new Rectangle(10, 10, size.Width / 2, size.Height / 2);
+                    Rectangle bounds = new(10, 10, size.Width / 2, size.Height / 2);
                     ctx.DetectEdges(bounds);
                 },
             comparer: OpaqueComparer,
@@ -158,7 +158,7 @@ public class DetectEdgesTest
     {
         using (Image<TPixel> image = provider.GetImage())
         {
-            var bounds = new Rectangle(10, 10, image.Width / 2, image.Height / 2);
+            Rectangle bounds = new(10, 10, image.Width / 2, image.Height / 2);
 
             image.Mutate(x => x.DetectEdges(bounds));
             image.DebugSave(provider);
diff --git a/tests/ImageSharp.Tests/Processing/Processors/Dithering/DitherTests.cs b/tests/ImageSharp.Tests/Processing/Processors/Dithering/DitherTests.cs
index b8e968f73a..25acd3aa67 100644
--- a/tests/ImageSharp.Tests/Processing/Processors/Dithering/DitherTests.cs
+++ b/tests/ImageSharp.Tests/Processing/Processors/Dithering/DitherTests.cs
@@ -14,10 +14,10 @@ public class DitherTests
     public const PixelTypes CommonNonDefaultPixelTypes =
         PixelTypes.Rgba32 | PixelTypes.Bgra32 | PixelTypes.Rgb24 | PixelTypes.RgbaVector;
 
-    public static readonly string[] CommonTestImages = { TestImages.Png.CalliphoraPartial, TestImages.Png.Bike };
+    public static readonly string[] CommonTestImages = [TestImages.Png.CalliphoraPartial, TestImages.Png.Bike];
 
     public static readonly TheoryData<IDither, string> ErrorDiffusers
-        = new TheoryData<IDither, string>
+        = new()
         {
             { KnownDitherings.Atkinson, nameof(KnownDitherings.Atkinson) },
             { KnownDitherings.Burks, nameof(KnownDitherings.Burks) },
@@ -31,7 +31,7 @@ public class DitherTests
         };
 
     public static readonly TheoryData<IDither, string> OrderedDitherers
-        = new TheoryData<IDither, string>
+        = new()
         {
             { KnownDitherings.Bayer2x2, nameof(KnownDitherings.Bayer2x2) },
             { KnownDitherings.Bayer4x4, nameof(KnownDitherings.Bayer4x4) },
@@ -41,7 +41,7 @@ public class DitherTests
         };
 
     public static readonly TheoryData<IDither> DefaultInstanceDitherers
-        = new TheoryData<IDither>
+        = new()
         {
             default(ErrorDither),
             default(OrderedDither)
@@ -101,7 +101,7 @@ public class DitherTests
         }
 
         // Increased tolerance because of compatibility issues on .NET 4.6.2:
-        var comparer = ImageComparer.TolerantPercentage(1f);
+        ImageComparer comparer = ImageComparer.TolerantPercentage(1f);
         provider.RunValidatingProcessorTest(x => x.Dither(DefaultErrorDiffuser), comparer: comparer);
     }
 
@@ -186,7 +186,7 @@ public class DitherTests
     {
         void Command()
         {
-            using var image = new Image<Rgba32>(10, 10);
+            using Image<Rgba32> image = new(10, 10);
             image.Mutate(x => x.Dither(dither));
         }
 
diff --git a/tests/ImageSharp.Tests/Processing/Processors/Effects/BackgroundColorTest.cs b/tests/ImageSharp.Tests/Processing/Processors/Effects/BackgroundColorTest.cs
index ed3be0f677..ab379ad7ca 100644
--- a/tests/ImageSharp.Tests/Processing/Processors/Effects/BackgroundColorTest.cs
+++ b/tests/ImageSharp.Tests/Processing/Processors/Effects/BackgroundColorTest.cs
@@ -11,10 +11,10 @@ namespace SixLabors.ImageSharp.Tests.Processing.Processors.Effects;
 public class BackgroundColorTest
 {
     public static readonly string[] InputImages =
-        {
-            TestImages.Png.Splash,
+    [
+        TestImages.Png.Splash,
             TestImages.Png.Ducky
-        };
+    ];
 
     [Theory]
     [WithFileCollection(nameof(InputImages), PixelTypes.Rgba32)]
diff --git a/tests/ImageSharp.Tests/Processing/Processors/Effects/OilPaintTest.cs b/tests/ImageSharp.Tests/Processing/Processors/Effects/OilPaintTest.cs
index 10811a559e..b7e8597859 100644
--- a/tests/ImageSharp.Tests/Processing/Processors/Effects/OilPaintTest.cs
+++ b/tests/ImageSharp.Tests/Processing/Processors/Effects/OilPaintTest.cs
@@ -11,17 +11,17 @@ namespace SixLabors.ImageSharp.Tests.Processing.Processors.Effects;
 [GroupOutput("Effects")]
 public class OilPaintTest
 {
-    public static readonly TheoryData<int, int> OilPaintValues = new TheoryData<int, int>
-                                                                     {
+    public static readonly TheoryData<int, int> OilPaintValues = new()
+    {
                                                                          { 15, 10 },
                                                                          { 6, 5 }
                                                                      };
 
     public static readonly string[] InputImages =
-        {
-            TestImages.Png.CalliphoraPartial,
+    [
+        TestImages.Png.CalliphoraPartial,
             TestImages.Bmp.Car
-        };
+    ];
 
     [Theory]
     [WithFileCollection(nameof(InputImages), nameof(OilPaintValues), PixelTypes.Rgba32)]
diff --git a/tests/ImageSharp.Tests/Processing/Processors/Effects/PixelShaderTest.cs b/tests/ImageSharp.Tests/Processing/Processors/Effects/PixelShaderTest.cs
index fd732f570f..b88ab37fe7 100644
--- a/tests/ImageSharp.Tests/Processing/Processors/Effects/PixelShaderTest.cs
+++ b/tests/ImageSharp.Tests/Processing/Processors/Effects/PixelShaderTest.cs
@@ -71,7 +71,7 @@ public class PixelShaderTest
 
                         Vector4 v4 = span[i];
                         float avg = (v4.X + v4.Y + v4.Z) / 3f;
-                        var gray = new Vector4(avg, avg, avg, a);
+                        Vector4 gray = new(avg, avg, avg, a);
 
                         span[i] = Vector4.Clamp(gray, Vector4.Zero, Vector4.One);
                     }
@@ -101,7 +101,7 @@ public class PixelShaderTest
 
                         Vector4 v4 = span[i];
                         float avg = (v4.X + v4.Y + v4.Z) / 3f;
-                        var gray = new Vector4(avg, avg, avg, a);
+                        Vector4 gray = new(avg, avg, avg, a);
 
                         span[i] = Vector4.Clamp(gray, Vector4.Zero, Vector4.One);
                     }
diff --git a/tests/ImageSharp.Tests/Processing/Processors/Effects/PixelateTest.cs b/tests/ImageSharp.Tests/Processing/Processors/Effects/PixelateTest.cs
index 29b9524030..fff7ba0182 100644
--- a/tests/ImageSharp.Tests/Processing/Processors/Effects/PixelateTest.cs
+++ b/tests/ImageSharp.Tests/Processing/Processors/Effects/PixelateTest.cs
@@ -10,7 +10,7 @@ namespace SixLabors.ImageSharp.Tests.Processing.Processors.Effects;
 [GroupOutput("Effects")]
 public class PixelateTest
 {
-    public static readonly TheoryData<int> PixelateValues = new TheoryData<int> { 4, 8 };
+    public static readonly TheoryData<int> PixelateValues = new() { 4, 8 };
 
     [Theory]
     [WithFile(TestImages.Png.Ducky, nameof(PixelateValues), PixelTypes.Rgba32)]
diff --git a/tests/ImageSharp.Tests/Processing/Processors/Filters/BrightnessTest.cs b/tests/ImageSharp.Tests/Processing/Processors/Filters/BrightnessTest.cs
index 7da96d13dd..4663aa868d 100644
--- a/tests/ImageSharp.Tests/Processing/Processors/Filters/BrightnessTest.cs
+++ b/tests/ImageSharp.Tests/Processing/Processors/Filters/BrightnessTest.cs
@@ -14,7 +14,7 @@ public class BrightnessTest
     private readonly ImageComparer imageComparer = ImageComparer.Tolerant(0.007F);
 
     public static readonly TheoryData<float> BrightnessValues
-    = new TheoryData<float>
+    = new()
     {
         .5F,
         1.5F
diff --git a/tests/ImageSharp.Tests/Processing/Processors/Filters/ColorBlindnessTest.cs b/tests/ImageSharp.Tests/Processing/Processors/Filters/ColorBlindnessTest.cs
index 0727a5b979..1f2afb97f5 100644
--- a/tests/ImageSharp.Tests/Processing/Processors/Filters/ColorBlindnessTest.cs
+++ b/tests/ImageSharp.Tests/Processing/Processors/Filters/ColorBlindnessTest.cs
@@ -14,7 +14,7 @@ public class ColorBlindnessTest
     private readonly ImageComparer imageComparer = ImageComparer.Tolerant(0.03F);
 
     public static readonly TheoryData<ColorBlindnessMode> ColorBlindnessFilters
-    = new TheoryData<ColorBlindnessMode>
+    = new()
     {
         ColorBlindnessMode.Achromatomaly,
         ColorBlindnessMode.Achromatopsia,
diff --git a/tests/ImageSharp.Tests/Processing/Processors/Filters/ContrastTest.cs b/tests/ImageSharp.Tests/Processing/Processors/Filters/ContrastTest.cs
index 5e2a7f55d1..6ff10bbd8e 100644
--- a/tests/ImageSharp.Tests/Processing/Processors/Filters/ContrastTest.cs
+++ b/tests/ImageSharp.Tests/Processing/Processors/Filters/ContrastTest.cs
@@ -11,7 +11,7 @@ namespace SixLabors.ImageSharp.Tests.Processing.Processors.Filters;
 public class ContrastTest
 {
     public static readonly TheoryData<float> ContrastValues
-    = new TheoryData<float>
+    = new()
     {
         .5F,
         1.5F
diff --git a/tests/ImageSharp.Tests/Processing/Processors/Filters/GrayscaleTest.cs b/tests/ImageSharp.Tests/Processing/Processors/Filters/GrayscaleTest.cs
index 50a2621524..15ef7f7c37 100644
--- a/tests/ImageSharp.Tests/Processing/Processors/Filters/GrayscaleTest.cs
+++ b/tests/ImageSharp.Tests/Processing/Processors/Filters/GrayscaleTest.cs
@@ -11,7 +11,7 @@ namespace SixLabors.ImageSharp.Tests.Processing.Processors.Filters;
 public class GrayscaleTest
 {
     public static readonly TheoryData<GrayscaleMode> GrayscaleModeTypes
-        = new TheoryData<GrayscaleMode>
+        = new()
         {
             GrayscaleMode.Bt601,
             GrayscaleMode.Bt709
diff --git a/tests/ImageSharp.Tests/Processing/Processors/Filters/HueTest.cs b/tests/ImageSharp.Tests/Processing/Processors/Filters/HueTest.cs
index 65ac4245d7..1838cc33db 100644
--- a/tests/ImageSharp.Tests/Processing/Processors/Filters/HueTest.cs
+++ b/tests/ImageSharp.Tests/Processing/Processors/Filters/HueTest.cs
@@ -11,7 +11,7 @@ namespace SixLabors.ImageSharp.Tests.Processing.Processors.Filters;
 public class HueTest
 {
     public static readonly TheoryData<int> HueValues
-    = new TheoryData<int>
+    = new()
     {
         180,
         -180
diff --git a/tests/ImageSharp.Tests/Processing/Processors/Filters/LightnessTest.cs b/tests/ImageSharp.Tests/Processing/Processors/Filters/LightnessTest.cs
index 39e69aa4a5..49e2c85467 100644
--- a/tests/ImageSharp.Tests/Processing/Processors/Filters/LightnessTest.cs
+++ b/tests/ImageSharp.Tests/Processing/Processors/Filters/LightnessTest.cs
@@ -14,7 +14,7 @@ public class LightnessTest
     private readonly ImageComparer imageComparer = ImageComparer.Tolerant(0.007F);
 
     public static readonly TheoryData<float> LightnessValues
-    = new TheoryData<float>
+    = new()
     {
         .5F,
         1.5F
diff --git a/tests/ImageSharp.Tests/Processing/Processors/Filters/OpacityTest.cs b/tests/ImageSharp.Tests/Processing/Processors/Filters/OpacityTest.cs
index 10ddf3a47d..8a1bbfe3f9 100644
--- a/tests/ImageSharp.Tests/Processing/Processors/Filters/OpacityTest.cs
+++ b/tests/ImageSharp.Tests/Processing/Processors/Filters/OpacityTest.cs
@@ -11,7 +11,7 @@ namespace SixLabors.ImageSharp.Tests.Processing.Processors.Filters;
 public class OpacityTest
 {
     public static readonly TheoryData<float> AlphaValues
-    = new TheoryData<float>
+    = new()
     {
         20 / 100F,
         80 / 100F
diff --git a/tests/ImageSharp.Tests/Processing/Processors/Filters/SaturateTest.cs b/tests/ImageSharp.Tests/Processing/Processors/Filters/SaturateTest.cs
index 8632d46259..642c798196 100644
--- a/tests/ImageSharp.Tests/Processing/Processors/Filters/SaturateTest.cs
+++ b/tests/ImageSharp.Tests/Processing/Processors/Filters/SaturateTest.cs
@@ -11,7 +11,7 @@ namespace SixLabors.ImageSharp.Tests.Processing.Processors.Filters;
 public class SaturateTest
 {
     public static readonly TheoryData<float> SaturationValues
-    = new TheoryData<float>
+    = new()
     {
         .5F,
         1.5F,
diff --git a/tests/ImageSharp.Tests/Processing/Processors/Overlays/OverlayTestBase.cs b/tests/ImageSharp.Tests/Processing/Processors/Overlays/OverlayTestBase.cs
index cf2b7d4dad..3005867ca8 100644
--- a/tests/ImageSharp.Tests/Processing/Processors/Overlays/OverlayTestBase.cs
+++ b/tests/ImageSharp.Tests/Processing/Processors/Overlays/OverlayTestBase.cs
@@ -11,9 +11,9 @@ namespace SixLabors.ImageSharp.Tests.Processing.Processors.Overlays;
 [GroupOutput("Overlays")]
 public abstract class OverlayTestBase
 {
-    public static string[] ColorNames = { "Blue", "White" };
+    public static string[] ColorNames = ["Blue", "White"];
 
-    public static string[] InputImages = { TestImages.Png.Ducky, TestImages.Png.Splash };
+    public static string[] InputImages = [TestImages.Png.Ducky, TestImages.Png.Splash];
 
     private static readonly ImageComparer ValidatorComparer = ImageComparer.TolerantPercentage(0.05f);
 
diff --git a/tests/ImageSharp.Tests/Processing/Processors/Quantization/OctreeQuantizerTests.cs b/tests/ImageSharp.Tests/Processing/Processors/Quantization/OctreeQuantizerTests.cs
index c6880d3a81..c9f3daf0f2 100644
--- a/tests/ImageSharp.Tests/Processing/Processors/Quantization/OctreeQuantizerTests.cs
+++ b/tests/ImageSharp.Tests/Processing/Processors/Quantization/OctreeQuantizerTests.cs
@@ -13,8 +13,8 @@ public class OctreeQuantizerTests
     [Fact]
     public void OctreeQuantizerConstructor()
     {
-        var expected = new QuantizerOptions { MaxColors = 128 };
-        var quantizer = new OctreeQuantizer(expected);
+        QuantizerOptions expected = new() { MaxColors = 128 };
+        OctreeQuantizer quantizer = new(expected);
 
         Assert.Equal(expected.MaxColors, quantizer.Options.MaxColors);
         Assert.Equal(QuantizerConstants.DefaultDither, quantizer.Options.Dither);
@@ -38,7 +38,7 @@ public class OctreeQuantizerTests
     [Fact]
     public void OctreeQuantizerCanCreateFrameQuantizer()
     {
-        var quantizer = new OctreeQuantizer();
+        OctreeQuantizer quantizer = new();
         IQuantizer<Rgba32> frameQuantizer = quantizer.CreatePixelSpecificQuantizer<Rgba32>(Configuration.Default);
 
         Assert.NotNull(frameQuantizer);
diff --git a/tests/ImageSharp.Tests/Processing/Processors/Quantization/PaletteQuantizerTests.cs b/tests/ImageSharp.Tests/Processing/Processors/Quantization/PaletteQuantizerTests.cs
index 91cf90bc46..f2a4b079b5 100644
--- a/tests/ImageSharp.Tests/Processing/Processors/Quantization/PaletteQuantizerTests.cs
+++ b/tests/ImageSharp.Tests/Processing/Processors/Quantization/PaletteQuantizerTests.cs
@@ -10,13 +10,13 @@ namespace SixLabors.ImageSharp.Tests.Processing.Processors.Quantization;
 [Trait("Category", "Processors")]
 public class PaletteQuantizerTests
 {
-    private static readonly Color[] Palette = { Color.Red, Color.Green, Color.Blue };
+    private static readonly Color[] Palette = [Color.Red, Color.Green, Color.Blue];
 
     [Fact]
     public void PaletteQuantizerConstructor()
     {
-        var expected = new QuantizerOptions { MaxColors = 128 };
-        var quantizer = new PaletteQuantizer(Palette, expected);
+        QuantizerOptions expected = new() { MaxColors = 128 };
+        PaletteQuantizer quantizer = new(Palette, expected);
 
         Assert.Equal(expected.MaxColors, quantizer.Options.MaxColors);
         Assert.Equal(QuantizerConstants.DefaultDither, quantizer.Options.Dither);
@@ -40,7 +40,7 @@ public class PaletteQuantizerTests
     [Fact]
     public void PaletteQuantizerCanCreateFrameQuantizer()
     {
-        var quantizer = new PaletteQuantizer(Palette);
+        PaletteQuantizer quantizer = new(Palette);
         IQuantizer<Rgba32> frameQuantizer = quantizer.CreatePixelSpecificQuantizer<Rgba32>(Configuration.Default);
 
         Assert.NotNull(frameQuantizer);
diff --git a/tests/ImageSharp.Tests/Processing/Processors/Quantization/QuantizerTests.cs b/tests/ImageSharp.Tests/Processing/Processors/Quantization/QuantizerTests.cs
index b8b4615b94..2ba757c117 100644
--- a/tests/ImageSharp.Tests/Processing/Processors/Quantization/QuantizerTests.cs
+++ b/tests/ImageSharp.Tests/Processing/Processors/Quantization/QuantizerTests.cs
@@ -13,10 +13,10 @@ namespace SixLabors.ImageSharp.Tests.Processing.Processors.Quantization;
 public class QuantizerTests
 {
     public static readonly string[] CommonTestImages =
-    {
+    [
         TestImages.Png.CalliphoraPartial,
         TestImages.Png.Bike
-    };
+    ];
 
     private static readonly QuantizerOptions NoDitherOptions = new() { Dither = null };
     private static readonly QuantizerOptions DiffuserDitherOptions = new() { Dither = KnownDitherings.FloydSteinberg };
diff --git a/tests/ImageSharp.Tests/Processing/Processors/Quantization/WuQuantizerTests.cs b/tests/ImageSharp.Tests/Processing/Processors/Quantization/WuQuantizerTests.cs
index ab4304d898..2d270b2a47 100644
--- a/tests/ImageSharp.Tests/Processing/Processors/Quantization/WuQuantizerTests.cs
+++ b/tests/ImageSharp.Tests/Processing/Processors/Quantization/WuQuantizerTests.cs
@@ -13,8 +13,8 @@ public class WuQuantizerTests
     [Fact]
     public void WuQuantizerConstructor()
     {
-        var expected = new QuantizerOptions { MaxColors = 128 };
-        var quantizer = new WuQuantizer(expected);
+        QuantizerOptions expected = new() { MaxColors = 128 };
+        WuQuantizer quantizer = new(expected);
 
         Assert.Equal(expected.MaxColors, quantizer.Options.MaxColors);
         Assert.Equal(QuantizerConstants.DefaultDither, quantizer.Options.Dither);
@@ -38,7 +38,7 @@ public class WuQuantizerTests
     [Fact]
     public void WuQuantizerCanCreateFrameQuantizer()
     {
-        var quantizer = new WuQuantizer();
+        WuQuantizer quantizer = new();
         IQuantizer<Rgba32> frameQuantizer = quantizer.CreatePixelSpecificQuantizer<Rgba32>(Configuration.Default);
 
         Assert.NotNull(frameQuantizer);
diff --git a/tests/ImageSharp.Tests/Processing/Processors/Transforms/AutoOrientTests.cs b/tests/ImageSharp.Tests/Processing/Processors/Transforms/AutoOrientTests.cs
index 6a61538ea1..ee21920d4d 100644
--- a/tests/ImageSharp.Tests/Processing/Processors/Transforms/AutoOrientTests.cs
+++ b/tests/ImageSharp.Tests/Processing/Processors/Transforms/AutoOrientTests.cs
@@ -17,8 +17,8 @@ public class AutoOrientTests
     public static readonly TheoryData<ExifDataType, byte[]> InvalidOrientationValues
         = new()
         {
-            { ExifDataType.Byte, new byte[] { 1 } },
-            { ExifDataType.SignedByte, new byte[] { 2 } },
+            { ExifDataType.Byte, [1] },
+            { ExifDataType.SignedByte, [2] },
             { ExifDataType.SignedShort, BitConverter.GetBytes((short)3) },
             { ExifDataType.Long, BitConverter.GetBytes(4U) },
             { ExifDataType.SignedLong, BitConverter.GetBytes(5) }
@@ -57,7 +57,7 @@ public class AutoOrientTests
     public void AutoOrient_WorksWithCorruptExifData<TPixel>(TestImageProvider<TPixel> provider, ExifDataType dataType, byte[] orientation)
         where TPixel : unmanaged, IPixel<TPixel>
     {
-        var profile = new ExifProfile();
+        ExifProfile profile = new();
         profile.SetValue(ExifTag.JPEGTables, orientation);
 
         byte[] bytes = profile.ToByteArray();
diff --git a/tests/ImageSharp.Tests/Processing/Processors/Transforms/CropTest.cs b/tests/ImageSharp.Tests/Processing/Processors/Transforms/CropTest.cs
index 18a7a9bd09..56e9a5201b 100644
--- a/tests/ImageSharp.Tests/Processing/Processors/Transforms/CropTest.cs
+++ b/tests/ImageSharp.Tests/Processing/Processors/Transforms/CropTest.cs
@@ -1,8 +1,10 @@
 // Copyright (c) Six Labors.
 // Licensed under the Six Labors Split License.
 
+using SixLabors.ImageSharp.Metadata.Profiles.Exif;
 using SixLabors.ImageSharp.PixelFormats;
 using SixLabors.ImageSharp.Processing;
+using SixLabors.ImageSharp.Tests.TestUtilities;
 using SixLabors.ImageSharp.Tests.TestUtilities.ImageComparison;
 
 namespace SixLabors.ImageSharp.Tests.Processing.Processors.Transforms;
@@ -17,12 +19,36 @@ public class CropTest
     public void Crop<TPixel>(TestImageProvider<TPixel> provider, int x, int y, int w, int h)
         where TPixel : unmanaged, IPixel<TPixel>
     {
-        var rect = new Rectangle(x, y, w, h);
+        Rectangle rect = new(x, y, w, h);
         FormattableString info = $"X{x}Y{y}.W{w}H{h}";
         provider.RunValidatingProcessorTest(
             ctx => ctx.Crop(rect),
             info,
-            appendPixelTypeToFileName: false,
-            comparer: ImageComparer.Exact);
+            comparer: ImageComparer.Exact,
+            appendPixelTypeToFileName: false);
+    }
+
+    [Theory]
+    [WithTestPatternImages(100, 100, PixelTypes.Rgba32)]
+    public void CropUpdatesSubject<TPixel>(TestImageProvider<TPixel> provider)
+        where TPixel : unmanaged, IPixel<TPixel>
+    {
+        using Image<TPixel> image = provider.GetImage();
+
+        image.Metadata.ExifProfile = new();
+        image.Metadata.ExifProfile.SetValue(ExifTag.SubjectLocation, [5, 15]);
+        image.Metadata.ExifProfile.SetValue(ExifTag.SubjectArea, [5, 15, 50, 50]);
+
+        image.Mutate(ctx => ctx.Crop(Rectangle.FromLTRB(20, 20, 50, 50)));
+
+        // The new subject area is now relative to the cropped area.
+        // overhanging pixels are constrained to the dimensions of the image.
+        Assert.Equal(
+            [0, 0],
+            image.Metadata.ExifProfile.GetValue(ExifTag.SubjectLocation).Value);
+
+        Assert.Equal(
+            [0, 0, 30, 30],
+            image.Metadata.ExifProfile.GetValue(ExifTag.SubjectArea).Value);
     }
 }
diff --git a/tests/ImageSharp.Tests/Processing/Processors/Transforms/EntropyCropTest.cs b/tests/ImageSharp.Tests/Processing/Processors/Transforms/EntropyCropTest.cs
index ca4b00d8aa..ffa9be6ea7 100644
--- a/tests/ImageSharp.Tests/Processing/Processors/Transforms/EntropyCropTest.cs
+++ b/tests/ImageSharp.Tests/Processing/Processors/Transforms/EntropyCropTest.cs
@@ -10,14 +10,14 @@ namespace SixLabors.ImageSharp.Tests.Processing.Processors.Transforms;
 [GroupOutput("Transforms")]
 public class EntropyCropTest
 {
-    public static readonly TheoryData<float> EntropyCropValues = new TheoryData<float> { .25F, .75F };
+    public static readonly TheoryData<float> EntropyCropValues = new() { .25F, .75F };
 
     public static readonly string[] InputImages =
-        {
-            TestImages.Png.Ducky,
+    [
+        TestImages.Png.Ducky,
             TestImages.Jpeg.Baseline.Jpeg400,
             TestImages.Jpeg.Baseline.MultiScanBaselineCMYK
-        };
+    ];
 
     [Theory]
     [WithFileCollection(nameof(InputImages), nameof(EntropyCropValues), PixelTypes.Rgba32)]
@@ -35,8 +35,8 @@ public class EntropyCropTest
     {
         // arrange
         using Image<TPixel> image = provider.GetImage();
-        var expectedHeight = image.Height;
-        var expectedWidth = image.Width;
+        int expectedHeight = image.Height;
+        int expectedWidth = image.Width;
 
         // act
         image.Mutate(img => img.EntropyCrop());
diff --git a/tests/ImageSharp.Tests/Processing/Processors/Transforms/FlipTests.cs b/tests/ImageSharp.Tests/Processing/Processors/Transforms/FlipTests.cs
index 717582274f..9aa04e370a 100644
--- a/tests/ImageSharp.Tests/Processing/Processors/Transforms/FlipTests.cs
+++ b/tests/ImageSharp.Tests/Processing/Processors/Transforms/FlipTests.cs
@@ -1,8 +1,10 @@
 // Copyright (c) Six Labors.
 // Licensed under the Six Labors Split License.
 
+using SixLabors.ImageSharp.Metadata.Profiles.Exif;
 using SixLabors.ImageSharp.PixelFormats;
 using SixLabors.ImageSharp.Processing;
+using SixLabors.ImageSharp.Tests.TestUtilities;
 
 // ReSharper disable InconsistentNaming
 namespace SixLabors.ImageSharp.Tests.Processing.Processors.Transforms;
@@ -12,12 +14,12 @@ namespace SixLabors.ImageSharp.Tests.Processing.Processors.Transforms;
 public class FlipTests
 {
     public static readonly TheoryData<FlipMode> FlipValues =
-        new TheoryData<FlipMode>
-            {
-                FlipMode.None,
-                FlipMode.Vertical,
-                FlipMode.Horizontal,
-            };
+        new()
+        {
+            FlipMode.None,
+            FlipMode.Vertical,
+            FlipMode.Horizontal
+        };
 
     [Theory]
     [WithTestPatternImages(nameof(FlipValues), 20, 37, PixelTypes.Rgba32)]
@@ -25,23 +27,77 @@ public class FlipTests
     [WithTestPatternImages(nameof(FlipValues), 17, 32, PixelTypes.Rgba32)]
     public void Flip<TPixel>(TestImageProvider<TPixel> provider, FlipMode flipMode)
         where TPixel : unmanaged, IPixel<TPixel>
-    {
-        provider.RunValidatingProcessorTest(
+        => provider.RunValidatingProcessorTest(
             ctx => ctx.Flip(flipMode),
             testOutputDetails: flipMode,
             appendPixelTypeToFileName: false);
-    }
 
     [Theory]
     [WithTestPatternImages(nameof(FlipValues), 53, 37, PixelTypes.Rgba32)]
     [WithTestPatternImages(nameof(FlipValues), 17, 32, PixelTypes.Rgba32)]
     public void Flip_WorksOnWrappedMemoryImage<TPixel>(TestImageProvider<TPixel> provider, FlipMode flipMode)
         where TPixel : unmanaged, IPixel<TPixel>
-    {
-        provider.RunValidatingProcessorTestOnWrappedMemoryImage(
+        => provider.RunValidatingProcessorTestOnWrappedMemoryImage(
             ctx => ctx.Flip(flipMode),
             testOutputDetails: flipMode,
             useReferenceOutputFrom: nameof(this.Flip),
             appendPixelTypeToFileName: false);
+
+    [Theory]
+    [WithTestPatternImages(100, 100, PixelTypes.Rgba32)]
+    public void FlipVerticalUpdatesSubject<TPixel>(TestImageProvider<TPixel> provider)
+        where TPixel : unmanaged, IPixel<TPixel>
+    {
+        using Image<TPixel> image = provider.GetImage();
+
+        image.Metadata.ExifProfile = new();
+        image.Metadata.ExifProfile.SetValue(ExifTag.SubjectLocation, [5, 15]);
+        image.Metadata.ExifProfile.SetValue(ExifTag.SubjectArea, [5, 15, 50, 50]);
+
+        image.Mutate(ctx => ctx.Flip(FlipMode.Vertical));
+
+        // The subject location is a single coordinate, so a vertical flip simply reflects its Y position:
+        // newY = imageHeight - originalY - 1
+        // This mirrors the point vertically around the image's horizontal axis, preserving its X coordinate.
+        Assert.Equal(
+            [5, 84],
+            image.Metadata.ExifProfile.GetValue(ExifTag.SubjectLocation).Value);
+
+        // The subject area is now inverted because a vertical flip reflects the image across
+        // the horizontal axis passing through the image center.
+        // The Y-coordinate of the top edge is recalculated as:
+        // newY = imageHeight - originalY - height - 1
+        Assert.Equal(
+            [5, 34, 50, 50],
+            image.Metadata.ExifProfile.GetValue(ExifTag.SubjectArea).Value);
+    }
+
+    [Theory]
+    [WithTestPatternImages(100, 100, PixelTypes.Rgba32)]
+    public void FlipHorizontalUpdatesSubject<TPixel>(TestImageProvider<TPixel> provider)
+        where TPixel : unmanaged, IPixel<TPixel>
+    {
+        using Image<TPixel> image = provider.GetImage();
+
+        image.Metadata.ExifProfile = new();
+        image.Metadata.ExifProfile.SetValue(ExifTag.SubjectLocation, [5, 15]);
+        image.Metadata.ExifProfile.SetValue(ExifTag.SubjectArea, [5, 15, 50, 50]);
+
+        image.Mutate(ctx => ctx.Flip(FlipMode.Horizontal));
+
+        // The subject location is a single coordinate, so a horizontal flip simply reflects its X position:
+        // newX = imageWidth - originalX - 1
+        // This mirrors the point horizontally around the image's vertical axis, preserving its Y coordinate.
+        Assert.Equal(
+            [94, 15],
+            image.Metadata.ExifProfile.GetValue(ExifTag.SubjectLocation).Value);
+
+        // The subject area is now inverted because a horizontal flip reflects the image across
+        // the vertical axis passing through the image center.
+        // The X-coordinate of the left edge is recalculated as:
+        // newX = imageWidth - originalX - width - 1
+        Assert.Equal(
+            [44, 15, 50, 50],
+            image.Metadata.ExifProfile.GetValue(ExifTag.SubjectArea).Value);
     }
 }
diff --git a/tests/ImageSharp.Tests/Processing/Processors/Transforms/PadTest.cs b/tests/ImageSharp.Tests/Processing/Processors/Transforms/PadTest.cs
index 8949049fbc..0b6f5702f3 100644
--- a/tests/ImageSharp.Tests/Processing/Processors/Transforms/PadTest.cs
+++ b/tests/ImageSharp.Tests/Processing/Processors/Transforms/PadTest.cs
@@ -10,9 +10,9 @@ namespace SixLabors.ImageSharp.Tests.Processing.Processors.Transforms;
 public class PadTest
 {
     public static readonly string[] CommonTestImages =
-    {
+    [
         TestImages.Png.CalliphoraPartial, TestImages.Png.Bike
-    };
+    ];
 
     [Theory]
     [WithFileCollection(nameof(CommonTestImages), PixelTypes.Rgba32)]
diff --git a/tests/ImageSharp.Tests/Processing/Transforms/ProjectiveTransformTests.cs b/tests/ImageSharp.Tests/Processing/Processors/Transforms/ProjectiveTransformTests.cs
similarity index 66%
rename from tests/ImageSharp.Tests/Processing/Transforms/ProjectiveTransformTests.cs
rename to tests/ImageSharp.Tests/Processing/Processors/Transforms/ProjectiveTransformTests.cs
index 6b6db69c11..2e580ea9fa 100644
--- a/tests/ImageSharp.Tests/Processing/Transforms/ProjectiveTransformTests.cs
+++ b/tests/ImageSharp.Tests/Processing/Processors/Transforms/ProjectiveTransformTests.cs
@@ -3,14 +3,16 @@
 
 using System.Numerics;
 using System.Reflection;
+using SixLabors.ImageSharp.Metadata.Profiles.Exif;
 using SixLabors.ImageSharp.PixelFormats;
 using SixLabors.ImageSharp.Processing;
 using SixLabors.ImageSharp.Processing.Processors.Transforms;
+using SixLabors.ImageSharp.Tests.TestUtilities;
 using SixLabors.ImageSharp.Tests.TestUtilities.ImageComparison;
 using Xunit.Abstractions;
 
 // ReSharper disable InconsistentNaming
-namespace SixLabors.ImageSharp.Tests.Processing.Transforms;
+namespace SixLabors.ImageSharp.Tests.Processing.Processors.Transforms;
 
 [Trait("Category", "Processors")]
 public class ProjectiveTransformTests
@@ -20,7 +22,7 @@ public class ProjectiveTransformTests
 
     private ITestOutputHelper Output { get; }
 
-    public static readonly TheoryData<string> ResamplerNames = new TheoryData<string>
+    public static readonly TheoryData<string> ResamplerNames = new()
     {
         nameof(KnownResamplers.Bicubic),
         nameof(KnownResamplers.Box),
@@ -39,7 +41,7 @@ public class ProjectiveTransformTests
         nameof(KnownResamplers.Welch),
     };
 
-    public static readonly TheoryData<TaperSide, TaperCorner> TaperMatrixData = new TheoryData<TaperSide, TaperCorner>
+    public static readonly TheoryData<TaperSide, TaperCorner> TaperMatrixData = new()
     {
         { TaperSide.Bottom, TaperCorner.Both },
         { TaperSide.Bottom, TaperCorner.LeftOrTop },
@@ -71,16 +73,14 @@ public class ProjectiveTransformTests
         where TPixel : unmanaged, IPixel<TPixel>
     {
         IResampler sampler = GetResampler(resamplerName);
-        using (Image<TPixel> image = provider.GetImage())
-        {
-            ProjectiveTransformBuilder builder = new ProjectiveTransformBuilder()
-                .AppendTaper(TaperSide.Right, TaperCorner.Both, .5F);
+        using Image<TPixel> image = provider.GetImage();
+        ProjectiveTransformBuilder builder = new ProjectiveTransformBuilder()
+            .AppendTaper(TaperSide.Right, TaperCorner.Both, .5F);
 
-            image.Mutate(i => i.Transform(builder, sampler));
+        image.Mutate(i => i.Transform(builder, sampler));
 
-            image.DebugSave(provider, resamplerName);
-            image.CompareToReferenceOutput(ValidatorComparer, provider, resamplerName);
-        }
+        image.DebugSave(provider, resamplerName);
+        image.CompareToReferenceOutput(ValidatorComparer, provider, resamplerName);
     }
 
     [Theory]
@@ -88,17 +88,15 @@ public class ProjectiveTransformTests
     public void Transform_WithTaperMatrix<TPixel>(TestImageProvider<TPixel> provider, TaperSide taperSide, TaperCorner taperCorner)
         where TPixel : unmanaged, IPixel<TPixel>
     {
-        using (Image<TPixel> image = provider.GetImage())
-        {
-            ProjectiveTransformBuilder builder = new ProjectiveTransformBuilder()
-                .AppendTaper(taperSide, taperCorner, .5F);
+        using Image<TPixel> image = provider.GetImage();
+        ProjectiveTransformBuilder builder = new ProjectiveTransformBuilder()
+            .AppendTaper(taperSide, taperCorner, .5F);
 
-            image.Mutate(i => i.Transform(builder));
+        image.Mutate(i => i.Transform(builder));
 
-            FormattableString testOutputDetails = $"{taperSide}-{taperCorner}";
-            image.DebugSave(provider, testOutputDetails);
-            image.CompareFirstFrameToReferenceOutput(TolerantComparer, provider, testOutputDetails);
-        }
+        FormattableString testOutputDetails = $"{taperSide}-{taperCorner}";
+        image.DebugSave(provider, testOutputDetails);
+        image.CompareFirstFrameToReferenceOutput(TolerantComparer, provider, testOutputDetails);
     }
 
     [Theory]
@@ -106,17 +104,15 @@ public class ProjectiveTransformTests
     public void Transform_WithQuadDistortion<TPixel>(TestImageProvider<TPixel> provider, PointF topLeft, PointF topRight, PointF bottomRight, PointF bottomLeft)
         where TPixel : unmanaged, IPixel<TPixel>
     {
-        using (Image<TPixel> image = provider.GetImage())
-        {
-            ProjectiveTransformBuilder builder = new ProjectiveTransformBuilder()
-                .AppendQuadDistortion(topLeft, topRight, bottomRight, bottomLeft);
+        using Image<TPixel> image = provider.GetImage();
+        ProjectiveTransformBuilder builder = new ProjectiveTransformBuilder()
+            .AppendQuadDistortion(topLeft, topRight, bottomRight, bottomLeft);
 
-            image.Mutate(i => i.Transform(builder));
+        image.Mutate(i => i.Transform(builder));
 
-            FormattableString testOutputDetails = $"{topLeft}-{topRight}-{bottomRight}-{bottomLeft}";
-            image.DebugSave(provider, testOutputDetails);
-            image.CompareFirstFrameToReferenceOutput(TolerantComparer, provider, testOutputDetails);
-        }
+        FormattableString testOutputDetails = $"{topLeft}-{topRight}-{bottomRight}-{bottomLeft}";
+        image.DebugSave(provider, testOutputDetails);
+        image.CompareFirstFrameToReferenceOutput(TolerantComparer, provider, testOutputDetails);
     }
 
     [Theory]
@@ -129,19 +125,17 @@ public class ProjectiveTransformTests
 
         // This test matches the output described in the example at
         // https://docs.microsoft.com/en-us/xamarin/xamarin-forms/user-interface/graphics/skiasharp/transforms/non-affine
-        using (Image<TPixel> image = provider.GetImage())
-        {
-            Matrix4x4 matrix = Matrix4x4.Identity;
-            matrix.M14 = 0.01F;
+        using Image<TPixel> image = provider.GetImage();
+        Matrix4x4 matrix = Matrix4x4.Identity;
+        matrix.M14 = 0.01F;
 
-            ProjectiveTransformBuilder builder = new ProjectiveTransformBuilder()
+        ProjectiveTransformBuilder builder = new ProjectiveTransformBuilder()
             .AppendMatrix(matrix);
 
-            image.Mutate(i => i.Transform(builder));
+        image.Mutate(i => i.Transform(builder));
 
-            image.DebugSave(provider);
-            image.CompareToReferenceOutput(TolerantComparer, provider);
-        }
+        image.DebugSave(provider);
+        image.CompareToReferenceOutput(TolerantComparer, provider);
     }
 
     [Theory]
@@ -151,30 +145,28 @@ public class ProjectiveTransformTests
     {
         // https://jsfiddle.net/dFrHS/545/
         // https://github.com/SixLabors/ImageSharp/issues/787
-        using (Image<TPixel> image = provider.GetImage())
-        {
+        using Image<TPixel> image = provider.GetImage();
 #pragma warning disable SA1117 // Parameters should be on same line or separate lines
-            Matrix4x4 matrix = new(
-                0.260987f, -0.434909f, 0, -0.0022184f,
-                0.373196f, 0.949882f, 0, -0.000312129f,
-                0, 0, 1, 0,
-                52, 165, 0, 1);
+        Matrix4x4 matrix = new(
+            0.260987f, -0.434909f, 0, -0.0022184f,
+            0.373196f, 0.949882f, 0, -0.000312129f,
+            0, 0, 1, 0,
+            52, 165, 0, 1);
 #pragma warning restore SA1117 // Parameters should be on same line or separate lines
 
-            ProjectiveTransformBuilder builder = new ProjectiveTransformBuilder()
+        ProjectiveTransformBuilder builder = new ProjectiveTransformBuilder()
             .AppendMatrix(matrix);
 
-            image.Mutate(i => i.Transform(builder));
+        image.Mutate(i => i.Transform(builder));
 
-            image.DebugSave(provider);
-            image.CompareToReferenceOutput(TolerantComparer, provider);
-        }
+        image.DebugSave(provider);
+        image.CompareToReferenceOutput(TolerantComparer, provider);
     }
 
     [Fact]
     public void Issue1911()
     {
-        using var image = new Image<Rgba32>(100, 100);
+        using Image<Rgba32> image = new(100, 100);
         image.Mutate(x => x = x.Transform(new Rectangle(0, 0, 99, 100), Matrix4x4.Identity, new Size(99, 100), KnownResamplers.Lanczos2));
 
         Assert.Equal(99, image.Width);
@@ -240,13 +232,44 @@ public class ProjectiveTransformTests
         ImageComparer.Exact.VerifySimilarity(img, img3);
     }
 
+    [Theory]
+    [WithTestPatternImages(100, 100, PixelTypes.Rgba32)]
+    public void TransformUpdatesSubject<TPixel>(TestImageProvider<TPixel> provider)
+        where TPixel : unmanaged, IPixel<TPixel>
+    {
+        using Image<TPixel> image = provider.GetImage();
+
+        image.Metadata.ExifProfile = new();
+        image.Metadata.ExifProfile.SetValue(ExifTag.SubjectLocation, [5, 15]);
+        image.Metadata.ExifProfile.SetValue(ExifTag.SubjectArea, [5, 15, 50, 50]);
+
+        ProjectiveTransformBuilder builder = new ProjectiveTransformBuilder()
+            .AppendRotationDegrees(180);
+
+        image.Mutate(ctx => ctx.Transform(builder));
+
+        // A 180-degree rotation inverts both axes around the image center.
+        // The subject location (5, 15) becomes (imageWidth - 5 - 1, imageHeight - 15 - 1) = (94, 84)
+        Assert.Equal(
+            [94, 84],
+            image.Metadata.ExifProfile.GetValue(ExifTag.SubjectLocation).Value);
+
+        // The subject area is also mirrored around the center.
+        // New X = imageWidth - originalX - width
+        // New Y = imageHeight - originalY - height
+        // (5, 15, 50, 50) becomes (44, 34, 50, 50)
+        Assert.Equal(
+            [44, 34, 50, 50],
+            image.Metadata.ExifProfile.GetValue(ExifTag.SubjectArea).Value);
+    }
+
     private static IResampler GetResampler(string name)
     {
         PropertyInfo property = typeof(KnownResamplers).GetTypeInfo().GetProperty(name);
 
         if (property is null)
         {
-            throw new Exception($"No resampler named {name}");
+            throw new InvalidOperationException($"No resampler named {name}");
         }
 
         return (IResampler)property.GetValue(null);
diff --git a/tests/ImageSharp.Tests/Processing/Processors/Transforms/ResizeHelperTests.cs b/tests/ImageSharp.Tests/Processing/Processors/Transforms/ResizeHelperTests.cs
index 84d834cc50..e3e7118c0c 100644
--- a/tests/ImageSharp.Tests/Processing/Processors/Transforms/ResizeHelperTests.cs
+++ b/tests/ImageSharp.Tests/Processing/Processors/Transforms/ResizeHelperTests.cs
@@ -34,8 +34,8 @@ public class ResizeHelperTests
     [Fact]
     public void CalculateMinRectangleWhenSourceIsSmallerThanTarget()
     {
-        var sourceSize = new Size(200, 100);
-        var target = new Size(400, 200);
+        Size sourceSize = new(200, 100);
+        Size target = new(400, 200);
 
         (Size size, Rectangle rectangle) = ResizeHelper.CalculateTargetLocationAndBounds(
             sourceSize,
@@ -52,11 +52,11 @@ public class ResizeHelperTests
     [Fact]
     public void MaxSizeAndRectangleAreCorrect()
     {
-        var sourceSize = new Size(5072, 6761);
-        var target = new Size(0, 450);
+        Size sourceSize = new(5072, 6761);
+        Size target = new(0, 450);
 
-        var expectedSize = new Size(338, 450);
-        var expectedRectangle = new Rectangle(Point.Empty, expectedSize);
+        Size expectedSize = new(338, 450);
+        Rectangle expectedRectangle = new(Point.Empty, expectedSize);
 
         (Size size, Rectangle rectangle) = ResizeHelper.CalculateTargetLocationAndBounds(
             sourceSize,
@@ -73,11 +73,11 @@ public class ResizeHelperTests
     [Fact]
     public void CropSizeAndRectangleAreCorrect()
     {
-        var sourceSize = new Size(100, 100);
-        var target = new Size(25, 50);
+        Size sourceSize = new(100, 100);
+        Size target = new(25, 50);
 
-        var expectedSize = new Size(25, 50);
-        var expectedRectangle = new Rectangle(-12, 0, 50, 50);
+        Size expectedSize = new(25, 50);
+        Rectangle expectedRectangle = new(-12, 0, 50, 50);
 
         (Size size, Rectangle rectangle) = ResizeHelper.CalculateTargetLocationAndBounds(
             sourceSize,
@@ -94,11 +94,11 @@ public class ResizeHelperTests
     [Fact]
     public void BoxPadSizeAndRectangleAreCorrect()
     {
-        var sourceSize = new Size(100, 100);
-        var target = new Size(120, 110);
+        Size sourceSize = new(100, 100);
+        Size target = new(120, 110);
 
-        var expectedSize = new Size(120, 110);
-        var expectedRectangle = new Rectangle(10, 5, 100, 100);
+        Size expectedSize = new(120, 110);
+        Rectangle expectedRectangle = new(10, 5, 100, 100);
 
         (Size size, Rectangle rectangle) = ResizeHelper.CalculateTargetLocationAndBounds(
             sourceSize,
@@ -115,11 +115,11 @@ public class ResizeHelperTests
     [Fact]
     public void PadSizeAndRectangleAreCorrect()
     {
-        var sourceSize = new Size(100, 100);
-        var target = new Size(120, 110);
+        Size sourceSize = new(100, 100);
+        Size target = new(120, 110);
 
-        var expectedSize = new Size(120, 110);
-        var expectedRectangle = new Rectangle(5, 0, 110, 110);
+        Size expectedSize = new(120, 110);
+        Rectangle expectedRectangle = new(5, 0, 110, 110);
 
         (Size size, Rectangle rectangle) = ResizeHelper.CalculateTargetLocationAndBounds(
             sourceSize,
@@ -136,11 +136,11 @@ public class ResizeHelperTests
     [Fact]
     public void StretchSizeAndRectangleAreCorrect()
     {
-        var sourceSize = new Size(100, 100);
-        var target = new Size(57, 32);
+        Size sourceSize = new(100, 100);
+        Size target = new(57, 32);
 
-        var expectedSize = new Size(57, 32);
-        var expectedRectangle = new Rectangle(Point.Empty, expectedSize);
+        Size expectedSize = new(57, 32);
+        Rectangle expectedRectangle = new(Point.Empty, expectedSize);
 
         (Size size, Rectangle rectangle) = ResizeHelper.CalculateTargetLocationAndBounds(
             sourceSize,
diff --git a/tests/ImageSharp.Tests/Processing/Processors/Transforms/ResizeKernelMapTests.ReferenceKernelMap.cs b/tests/ImageSharp.Tests/Processing/Processors/Transforms/ResizeKernelMapTests.ReferenceKernelMap.cs
index 290a3b37ac..00ad71b4ca 100644
--- a/tests/ImageSharp.Tests/Processing/Processors/Transforms/ResizeKernelMapTests.ReferenceKernelMap.cs
+++ b/tests/ImageSharp.Tests/Processing/Processors/Transforms/ResizeKernelMapTests.ReferenceKernelMap.cs
@@ -39,7 +39,7 @@ public partial class ResizeKernelMapTests
 
             double radius = tolerantMath.Ceiling(scale * sampler.Radius);
 
-            var result = new List<ReferenceKernel>();
+            List<ReferenceKernel> result = [];
 
             for (int i = 0; i < destinationSize; i++)
             {
diff --git a/tests/ImageSharp.Tests/Processing/Processors/Transforms/ResizeKernelMapTests.cs b/tests/ImageSharp.Tests/Processing/Processors/Transforms/ResizeKernelMapTests.cs
index c6da46ee2f..0357dda046 100644
--- a/tests/ImageSharp.Tests/Processing/Processors/Transforms/ResizeKernelMapTests.cs
+++ b/tests/ImageSharp.Tests/Processing/Processors/Transforms/ResizeKernelMapTests.cs
@@ -22,8 +22,8 @@ public partial class ResizeKernelMapTests
     /// resamplerName, srcSize, destSize
     /// </summary>
     public static readonly TheoryData<IResampler, int, int> KernelMapData
-        = new TheoryData<IResampler, int, int>
-    {
+        = new()
+        {
         { KnownResamplers.Bicubic, 15, 10 },
         { KnownResamplers.Bicubic, 10, 15 },
         { KnownResamplers.Bicubic, 20, 20 },
@@ -88,7 +88,7 @@ public partial class ResizeKernelMapTests
     public void PrintNonNormalizedKernelMap<TResampler>(TResampler resampler, int srcSize, int destSize)
         where TResampler : struct, IResampler
     {
-        var kernelMap = ReferenceKernelMap.Calculate<TResampler>(in resampler, destSize, srcSize, false);
+        ReferenceKernelMap kernelMap = ReferenceKernelMap.Calculate<TResampler>(in resampler, destSize, srcSize, false);
 
         this.Output.WriteLine($"Actual KernelMap:\n{PrintKernelMap(kernelMap)}\n");
     }
@@ -116,15 +116,15 @@ public partial class ResizeKernelMapTests
     private void VerifyKernelMapContentIsCorrect<TResampler>(TResampler resampler, int srcSize, int destSize)
         where TResampler : struct, IResampler
     {
-        var referenceMap = ReferenceKernelMap.Calculate(in resampler, destSize, srcSize);
-        var kernelMap = ResizeKernelMap.Calculate(in resampler, destSize, srcSize, Configuration.Default.MemoryAllocator);
+        ReferenceKernelMap referenceMap = ReferenceKernelMap.Calculate(in resampler, destSize, srcSize);
+        ResizeKernelMap kernelMap = ResizeKernelMap.Calculate(in resampler, destSize, srcSize, Configuration.Default.MemoryAllocator);
 
 #if DEBUG
         this.Output.WriteLine(kernelMap.Info);
         this.Output.WriteLine($"Expected KernelMap:\n{PrintKernelMap(referenceMap)}\n");
         this.Output.WriteLine($"Actual KernelMap:\n{PrintKernelMap(kernelMap)}\n");
 #endif
-        var comparer = new ApproximateFloatComparer(1e-6f);
+        ApproximateFloatComparer comparer = new(1e-6f);
 
         for (int i = 0; i < kernelMap.DestinationLength; i++)
         {
@@ -163,7 +163,7 @@ public partial class ResizeKernelMapTests
         Func<TKernelMap, int> getDestinationSize,
         Func<TKernelMap, int, ReferenceKernel> getKernel)
     {
-        var bld = new StringBuilder();
+        StringBuilder bld = new();
 
         if (kernelMap is ResizeKernelMap actualMap)
         {
@@ -193,19 +193,19 @@ public partial class ResizeKernelMapTests
 
     private static TheoryData<string, int, int> GenerateImageResizeData()
     {
-        var result = new TheoryData<string, int, int>();
+        TheoryData<string, int, int> result = new();
 
         string[] resamplerNames = TestUtils.GetAllResamplerNames(false);
 
         int[] dimensionVals =
-            {
-                // Arbitrary, small dimensions:
+        [
+            // Arbitrary, small dimensions:
                 9, 10, 11, 13, 49, 50, 53, 99, 100, 199, 200, 201, 299, 300, 301,
 
                 // Typical image sizes:
                 640, 480, 800, 600, 1024, 768, 1280, 960, 1536, 1180, 1600, 1200, 2048, 1536, 2240, 1680, 2560,
                 1920, 3032, 2008, 3072, 2304, 3264, 2448
-            };
+        ];
 
         IOrderedEnumerable<(int S, int D)> source2Dest = dimensionVals
             .SelectMany(s => dimensionVals.Select(d => (s, d)))
diff --git a/tests/ImageSharp.Tests/Processing/Processors/Transforms/ResizeTests.cs b/tests/ImageSharp.Tests/Processing/Processors/Transforms/ResizeTests.cs
index d1b005ee4e..1e0e66965a 100644
--- a/tests/ImageSharp.Tests/Processing/Processors/Transforms/ResizeTests.cs
+++ b/tests/ImageSharp.Tests/Processing/Processors/Transforms/ResizeTests.cs
@@ -3,10 +3,12 @@
 
 using System.Numerics;
 using System.Runtime.CompilerServices;
+using SixLabors.ImageSharp.Metadata.Profiles.Exif;
 using SixLabors.ImageSharp.PixelFormats;
 using SixLabors.ImageSharp.Processing;
 using SixLabors.ImageSharp.Processing.Processors.Transforms;
 using SixLabors.ImageSharp.Tests.Memory;
+using SixLabors.ImageSharp.Tests.TestUtilities;
 using SixLabors.ImageSharp.Tests.TestUtilities.ImageComparison;
 
 // ReSharper disable InconsistentNaming
@@ -20,15 +22,15 @@ public class ResizeTests
 
     public static readonly string[] AllResamplerNames = TestUtils.GetAllResamplerNames();
 
-    public static readonly string[] CommonTestImages = { TestImages.Png.CalliphoraPartial };
+    public static readonly string[] CommonTestImages = [TestImages.Png.CalliphoraPartial];
 
     public static readonly string[] SmokeTestResamplerNames =
-        {
+        [
             nameof(KnownResamplers.NearestNeighbor),
             nameof(KnownResamplers.Bicubic),
             nameof(KnownResamplers.Box),
             nameof(KnownResamplers.Lanczos5),
-        };
+        ];
 
     private static readonly ImageComparer ValidatorComparer =
         ImageComparer.TolerantPercentage(0.07F);
@@ -78,7 +80,7 @@ public class ResizeTests
         // resizing: (15, 12) -> (10, 6)
         // kernel dimensions: (3, 4)
         using Image<TPixel> image = provider.GetImage();
-        Size destSize = new Size(image.Width * wN / wD, image.Height * hN / hD);
+        Size destSize = new(image.Width * wN / wD, image.Height * hN / hD);
         image.Mutate(x => x.Resize(destSize, KnownResamplers.Bicubic, false));
         FormattableString outputInfo = $"({wN}÷{wD},{hN}÷{hD})";
         image.DebugSave(provider, outputInfo, appendPixelTypeToFileName: false);
@@ -106,7 +108,7 @@ public class ResizeTests
         Configuration configuration = Configuration.CreateDefaultInstance();
 
         int workingBufferSizeHintInBytes = workingBufferLimitInRows * destSize.Width * SizeOfVector4;
-        TestMemoryAllocator allocator = new TestMemoryAllocator();
+        TestMemoryAllocator allocator = new();
         allocator.EnableNonThreadSafeLogging();
         configuration.MemoryAllocator = allocator;
         configuration.WorkingBufferSizeHintInBytes = workingBufferSizeHintInBytes;
@@ -211,7 +213,7 @@ public class ResizeTests
         provider.RunValidatingProcessorTest(
             x =>
             {
-                ResizeOptions resizeOptions = new ResizeOptions()
+                ResizeOptions resizeOptions = new()
                 {
                     Size = x.GetCurrentSize() / 2,
                     Mode = ResizeMode.Crop,
@@ -242,9 +244,7 @@ public class ResizeTests
     [WithTestPatternImages(50, 50, CommonNonDefaultPixelTypes)]
     public void Resize_IsNotBoundToSinglePixelType<TPixel>(TestImageProvider<TPixel> provider)
         where TPixel : unmanaged, IPixel<TPixel>
-    {
-        provider.RunValidatingProcessorTest(x => x.Resize(x.GetCurrentSize() / 2), comparer: ValidatorComparer);
-    }
+        => provider.RunValidatingProcessorTest(x => x.Resize(x.GetCurrentSize() / 2), comparer: ValidatorComparer);
 
     [Theory]
     [WithFileCollection(nameof(CommonTestImages), PixelTypes.Rgba32)]
@@ -257,7 +257,7 @@ public class ResizeTests
 
         using Image<TPixel> image1 = Image.WrapMemory(mmg.Memory, image0.Width, image0.Height);
         Assert.ThrowsAny<Exception>(
-            () => { image1.Mutate(x => x.Resize(image0.Width / 2, image0.Height / 2, true)); });
+            () => image1.Mutate(x => x.Resize(image0.Width / 2, image0.Height / 2, true)));
     }
 
     [Theory]
@@ -365,12 +365,12 @@ public class ResizeTests
         where TPixel : unmanaged, IPixel<TPixel>
     {
         using Image<TPixel> image = provider.GetImage();
-        Rectangle sourceRectangle = new Rectangle(
+        Rectangle sourceRectangle = new(
             image.Width / 8,
             image.Height / 8,
             image.Width / 4,
             image.Height / 4);
-        Rectangle destRectangle = new Rectangle(image.Width / 4, image.Height / 4, image.Width / 2, image.Height / 2);
+        Rectangle destRectangle = new(image.Width / 4, image.Height / 4, image.Width / 2, image.Height / 2);
 
         image.Mutate(
             x => x.Resize(
@@ -437,7 +437,7 @@ public class ResizeTests
         where TPixel : unmanaged, IPixel<TPixel>
     {
         using Image<TPixel> image = provider.GetImage();
-        ResizeOptions options = new ResizeOptions
+        ResizeOptions options = new()
         {
             Size = new Size(image.Width + 200, image.Height + 200),
             Mode = ResizeMode.BoxPad,
@@ -456,7 +456,7 @@ public class ResizeTests
         where TPixel : unmanaged, IPixel<TPixel>
     {
         using Image<TPixel> image = provider.GetImage();
-        ResizeOptions options = new ResizeOptions { Size = new Size(image.Width, image.Height / 2) };
+        ResizeOptions options = new() { Size = new Size(image.Width, image.Height / 2) };
 
         image.Mutate(x => x.Resize(options));
 
@@ -470,7 +470,7 @@ public class ResizeTests
         where TPixel : unmanaged, IPixel<TPixel>
     {
         using Image<TPixel> image = provider.GetImage();
-        ResizeOptions options = new ResizeOptions { Size = new Size(image.Width / 2, image.Height) };
+        ResizeOptions options = new() { Size = new Size(image.Width / 2, image.Height) };
 
         image.Mutate(x => x.Resize(options));
 
@@ -484,7 +484,7 @@ public class ResizeTests
         where TPixel : unmanaged, IPixel<TPixel>
     {
         using Image<TPixel> image = provider.GetImage();
-        ResizeOptions options = new ResizeOptions
+        ResizeOptions options = new()
         {
             Size = new Size(480, 600),
             Mode = ResizeMode.Crop
@@ -502,7 +502,7 @@ public class ResizeTests
         where TPixel : unmanaged, IPixel<TPixel>
     {
         using Image<TPixel> image = provider.GetImage();
-        ResizeOptions options = new ResizeOptions { Size = new Size(300, 300), Mode = ResizeMode.Max };
+        ResizeOptions options = new() { Size = new Size(300, 300), Mode = ResizeMode.Max };
 
         image.Mutate(x => x.Resize(options));
 
@@ -516,7 +516,7 @@ public class ResizeTests
         where TPixel : unmanaged, IPixel<TPixel>
     {
         using Image<TPixel> image = provider.GetImage();
-        ResizeOptions options = new ResizeOptions
+        ResizeOptions options = new()
         {
             Size = new Size((int)Math.Round(image.Width * .75F), (int)Math.Round(image.Height * .95F)),
             Mode = ResizeMode.Min
@@ -534,7 +534,7 @@ public class ResizeTests
         where TPixel : unmanaged, IPixel<TPixel>
     {
         using Image<TPixel> image = provider.GetImage();
-        ResizeOptions options = new ResizeOptions
+        ResizeOptions options = new()
         {
             Size = new Size(image.Width + 200, image.Height),
             Mode = ResizeMode.Pad,
@@ -553,7 +553,7 @@ public class ResizeTests
         where TPixel : unmanaged, IPixel<TPixel>
     {
         using Image<TPixel> image = provider.GetImage();
-        ResizeOptions options = new ResizeOptions
+        ResizeOptions options = new()
         {
             Size = new Size(image.Width / 2, image.Height),
             Mode = ResizeMode.Stretch
@@ -579,6 +579,7 @@ public class ResizeTests
         }
 
         using Image<TPixel> image = provider.GetImage();
+
         // Don't bother saving, we're testing the EXIF metadata updates.
         image.Mutate(x => x.Resize(image.Width / 2, image.Height / 2));
     }
@@ -586,8 +587,8 @@ public class ResizeTests
     [Fact]
     public void Issue1195()
     {
-        using Image<Rgba32> image = new Image<Rgba32>(2, 300);
-        Size size = new Size(50, 50);
+        using Image<Rgba32> image = new(2, 300);
+        Size size = new(50, 50);
         image.Mutate(x => x
             .Resize(
                 new ResizeOptions
@@ -605,8 +606,8 @@ public class ResizeTests
     [InlineData(3, 7)]
     public void Issue1342(int width, int height)
     {
-        using Image<Rgba32> image = new Image<Rgba32>(1, 1);
-        Size size = new Size(width, height);
+        using Image<Rgba32> image = new(1, 1);
+        Size size = new(width, height);
         image.Mutate(x => x
             .Resize(
                 new ResizeOptions
@@ -630,4 +631,28 @@ public class ResizeTests
             appendPixelTypeToFileName: false,
             appendSourceFileOrDescription: false);
     }
+
+    [Theory]
+    [WithTestPatternImages(100, 100, PixelTypes.Rgba32)]
+    public void ResizeUpdatesSubject<TPixel>(TestImageProvider<TPixel> provider)
+        where TPixel : unmanaged, IPixel<TPixel>
+    {
+        using Image<TPixel> image = provider.GetImage();
+
+        image.Metadata.ExifProfile = new();
+        image.Metadata.ExifProfile.SetValue(ExifTag.SubjectLocation, [5, 15]);
+        image.Metadata.ExifProfile.SetValue(ExifTag.SubjectArea, [5, 15, 20, 20]);
+
+        image.Mutate(ctx => ctx.Resize(new Size(image.Width / 2, image.Height / 2)));
+
+        // The transform operates in pixel space, so the resulting values correspond to the
+        // scaled pixel centers, producing whole-number coordinates after resizing.
+        Assert.Equal(
+            [2, 7],
+            image.Metadata.ExifProfile.GetValue(ExifTag.SubjectLocation).Value);
+
+        Assert.Equal(
+            [2, 7, 11, 11],
+            image.Metadata.ExifProfile.GetValue(ExifTag.SubjectArea).Value);
+    }
 }
diff --git a/tests/ImageSharp.Tests/Processing/Processors/Transforms/RotateFlipTests.cs b/tests/ImageSharp.Tests/Processing/Processors/Transforms/RotateFlipTests.cs
index 55d26974aa..523fd2bdd1 100644
--- a/tests/ImageSharp.Tests/Processing/Processors/Transforms/RotateFlipTests.cs
+++ b/tests/ImageSharp.Tests/Processing/Processors/Transforms/RotateFlipTests.cs
@@ -9,11 +9,11 @@ namespace SixLabors.ImageSharp.Tests.Processing.Processors.Transforms;
 [Trait("Category", "Processors")]
 public class RotateFlipTests
 {
-    public static readonly string[] FlipFiles = { TestImages.Bmp.F };
+    public static readonly string[] FlipFiles = [TestImages.Bmp.F];
 
     public static readonly TheoryData<RotateMode, FlipMode> RotateFlipValues
-        = new TheoryData<RotateMode, FlipMode>
-    {
+        = new()
+        {
         { RotateMode.None, FlipMode.Vertical },
         { RotateMode.None, FlipMode.Horizontal },
         { RotateMode.Rotate90, FlipMode.None },
diff --git a/tests/ImageSharp.Tests/Processing/Processors/Transforms/RotateTests.cs b/tests/ImageSharp.Tests/Processing/Processors/Transforms/RotateTests.cs
index b150da1d8e..dfa263fec0 100644
--- a/tests/ImageSharp.Tests/Processing/Processors/Transforms/RotateTests.cs
+++ b/tests/ImageSharp.Tests/Processing/Processors/Transforms/RotateTests.cs
@@ -1,8 +1,10 @@
 // Copyright (c) Six Labors.
 // Licensed under the Six Labors Split License.
 
+using SixLabors.ImageSharp.Metadata.Profiles.Exif;
 using SixLabors.ImageSharp.PixelFormats;
 using SixLabors.ImageSharp.Processing;
+using SixLabors.ImageSharp.Tests.TestUtilities;
 
 namespace SixLabors.ImageSharp.Tests.Processing.Processors.Transforms;
 
@@ -11,35 +13,59 @@ namespace SixLabors.ImageSharp.Tests.Processing.Processors.Transforms;
 public class RotateTests
 {
     public static readonly TheoryData<float> RotateAngles
-        = new TheoryData<float>
-    {
-        50, -50, 170, -170
-    };
+        = new()
+        {
+            50, -50, 170, -170
+        };
 
     public static readonly TheoryData<RotateMode> RotateEnumValues
-        = new TheoryData<RotateMode>
-    {
-        RotateMode.None,
-        RotateMode.Rotate90,
-        RotateMode.Rotate180,
-        RotateMode.Rotate270
-    };
+        = new()
+        {
+            RotateMode.None,
+            RotateMode.Rotate90,
+            RotateMode.Rotate180,
+            RotateMode.Rotate270
+        };
 
     [Theory]
     [WithTestPatternImages(nameof(RotateAngles), 100, 50, PixelTypes.Rgba32)]
     [WithTestPatternImages(nameof(RotateAngles), 50, 100, PixelTypes.Rgba32)]
     public void Rotate_WithAngle<TPixel>(TestImageProvider<TPixel> provider, float value)
         where TPixel : unmanaged, IPixel<TPixel>
-    {
-        provider.RunValidatingProcessorTest(ctx => ctx.Rotate(value), value, appendPixelTypeToFileName: false);
-    }
+        => provider.RunValidatingProcessorTest(ctx => ctx.Rotate(value), value, appendPixelTypeToFileName: false);
 
     [Theory]
     [WithTestPatternImages(nameof(RotateEnumValues), 100, 50, PixelTypes.Rgba32)]
     [WithTestPatternImages(nameof(RotateEnumValues), 50, 100, PixelTypes.Rgba32)]
     public void Rotate_WithRotateTypeEnum<TPixel>(TestImageProvider<TPixel> provider, RotateMode value)
         where TPixel : unmanaged, IPixel<TPixel>
+        => provider.RunValidatingProcessorTest(ctx => ctx.Rotate(value), value, appendPixelTypeToFileName: false);
+
+    [Theory]
+    [WithTestPatternImages(100, 100, PixelTypes.Rgba32)]
+    public void RotateUpdatesSubject<TPixel>(TestImageProvider<TPixel> provider)
+        where TPixel : unmanaged, IPixel<TPixel>
     {
-        provider.RunValidatingProcessorTest(ctx => ctx.Rotate(value), value, appendPixelTypeToFileName: false);
+        using Image<TPixel> image = provider.GetImage();
+
+        image.Metadata.ExifProfile = new();
+        image.Metadata.ExifProfile.SetValue(ExifTag.SubjectLocation, [5, 15]);
+        image.Metadata.ExifProfile.SetValue(ExifTag.SubjectArea, [5, 15, 50, 50]);
+
+        image.Mutate(ctx => ctx.Rotate(180));
+
+        // A 180-degree rotation inverts both axes around the image center.
+        // The subject location (5, 15) becomes (imageWidth - 5 - 1, imageHeight - 15 - 1) = (94, 84)
+        Assert.Equal(
+            [94, 84],
+            image.Metadata.ExifProfile.GetValue(ExifTag.SubjectLocation).Value);
+
+        // The subject area is also mirrored around the center.
+        // New X = imageWidth - originalX - width
+        // New Y = imageHeight - originalY - height
+        // (5, 15, 50, 50) becomes (44, 34, 50, 50)
+        Assert.Equal(
+            [44, 34, 50, 50],
+            image.Metadata.ExifProfile.GetValue(ExifTag.SubjectArea).Value);
     }
 }
diff --git a/tests/ImageSharp.Tests/Processing/Processors/Transforms/SkewTests.cs b/tests/ImageSharp.Tests/Processing/Processors/Transforms/SkewTests.cs
index 1e217ae24a..84401e8468 100644
--- a/tests/ImageSharp.Tests/Processing/Processors/Transforms/SkewTests.cs
+++ b/tests/ImageSharp.Tests/Processing/Processors/Transforms/SkewTests.cs
@@ -14,9 +14,9 @@ public class SkewTests
 {
     private const PixelTypes CommonPixelTypes = PixelTypes.Bgra32 | PixelTypes.Rgb24;
 
-    public static readonly string[] ResamplerNames = new[]
-                                                         {
-                                                             nameof(KnownResamplers.Bicubic),
+    public static readonly string[] ResamplerNames =
+    [
+        nameof(KnownResamplers.Bicubic),
                                                              nameof(KnownResamplers.Box),
                                                              nameof(KnownResamplers.CatmullRom),
                                                              nameof(KnownResamplers.Hermite),
@@ -30,11 +30,11 @@ public class SkewTests
                                                              nameof(KnownResamplers.RobidouxSharp),
                                                              nameof(KnownResamplers.Spline),
                                                              nameof(KnownResamplers.Triangle),
-                                                             nameof(KnownResamplers.Welch),
-                                                         };
+                                                             nameof(KnownResamplers.Welch)
+    ];
 
-    public static readonly TheoryData<float, float> SkewValues = new TheoryData<float, float>
-                                                                     {
+    public static readonly TheoryData<float, float> SkewValues = new()
+    {
                                                                          { 20, 10 },
                                                                          { -20, -10 }
                                                                      };
diff --git a/tests/ImageSharp.Tests/Processing/Processors/Transforms/SwizzleTests.cs b/tests/ImageSharp.Tests/Processing/Processors/Transforms/SwizzleTests.cs
index de02502e2b..33e22d3644 100644
--- a/tests/ImageSharp.Tests/Processing/Processors/Transforms/SwizzleTests.cs
+++ b/tests/ImageSharp.Tests/Processing/Processors/Transforms/SwizzleTests.cs
@@ -1,9 +1,11 @@
 // Copyright (c) Six Labors.
 // Licensed under the Six Labors Split License.
 
+using SixLabors.ImageSharp.Metadata.Profiles.Exif;
 using SixLabors.ImageSharp.PixelFormats;
 using SixLabors.ImageSharp.Processing;
 using SixLabors.ImageSharp.Processing.Processors.Transforms;
+using SixLabors.ImageSharp.Tests.TestUtilities;
 using SixLabors.ImageSharp.Tests.TestUtilities.ImageComparison;
 
 namespace SixLabors.ImageSharp.Tests.Processing.Processors.Transforms;
@@ -12,17 +14,14 @@ namespace SixLabors.ImageSharp.Tests.Processing.Processors.Transforms;
 [GroupOutput("Transforms")]
 public class SwizzleTests
 {
-    private struct InvertXAndYSwizzler : ISwizzler
+    private readonly struct SwapXAndYSwizzler : ISwizzler
     {
-        public InvertXAndYSwizzler(Size sourceSize)
-        {
-            this.DestinationSize = new Size(sourceSize.Height, sourceSize.Width);
-        }
+        public SwapXAndYSwizzler(Size sourceSize)
+            => this.DestinationSize = new Size(sourceSize.Height, sourceSize.Width);
 
         public Size DestinationSize { get; }
 
-        public Point Transform(Point point)
-            => new Point(point.Y, point.X);
+        public Point Transform(Point point) => new(point.Y, point.X);
     }
 
     [Theory]
@@ -35,15 +34,15 @@ public class SwizzleTests
         using Image<TPixel> expectedImage = provider.GetImage();
         using Image<TPixel> image = provider.GetImage();
 
-        image.Mutate(ctx => ctx.Swizzle(new InvertXAndYSwizzler(new Size(image.Width, image.Height))));
+        image.Mutate(ctx => ctx.Swizzle(new SwapXAndYSwizzler(new Size(image.Width, image.Height))));
 
         image.DebugSave(
             provider,
-            nameof(InvertXAndYSwizzler),
+            nameof(SwapXAndYSwizzler),
             appendPixelTypeToFileName: false,
             appendSourceFileOrDescription: true);
 
-        image.Mutate(ctx => ctx.Swizzle(new InvertXAndYSwizzler(new Size(image.Width, image.Height))));
+        image.Mutate(ctx => ctx.Swizzle(new SwapXAndYSwizzler(new Size(image.Width, image.Height))));
 
         image.DebugSave(
             provider,
@@ -53,4 +52,26 @@ public class SwizzleTests
 
         ImageComparer.Exact.VerifySimilarity(expectedImage, image);
     }
+
+    [Theory]
+    [WithTestPatternImages(100, 100, PixelTypes.Rgba32)]
+    public void SwizzleUpdatesSubject<TPixel>(TestImageProvider<TPixel> provider)
+        where TPixel : unmanaged, IPixel<TPixel>
+    {
+        using Image<TPixel> image = provider.GetImage();
+
+        image.Metadata.ExifProfile = new();
+        image.Metadata.ExifProfile.SetValue(ExifTag.SubjectLocation, [5, 15]);
+        image.Metadata.ExifProfile.SetValue(ExifTag.SubjectArea, [5, 15, 20, 20]);
+
+        image.Mutate(ctx => ctx.Swizzle(new SwapXAndYSwizzler(new Size(image.Width, image.Height))));
+
+        Assert.Equal(
+            [15, 5],
+            image.Metadata.ExifProfile.GetValue(ExifTag.SubjectLocation).Value);
+
+        Assert.Equal(
+            [15, 5, 20, 20],
+            image.Metadata.ExifProfile.GetValue(ExifTag.SubjectArea).Value);
+    }
 }
diff --git a/tests/ImageSharp.Tests/Processing/Transforms/AffineTransformBuilderTests.cs b/tests/ImageSharp.Tests/Processing/Transforms/AffineTransformBuilderTests.cs
index 4b1ca92dd6..232571d4d0 100644
--- a/tests/ImageSharp.Tests/Processing/Transforms/AffineTransformBuilderTests.cs
+++ b/tests/ImageSharp.Tests/Processing/Transforms/AffineTransformBuilderTests.cs
@@ -8,8 +8,7 @@ namespace SixLabors.ImageSharp.Tests.Processing.Transforms;
 
 public class AffineTransformBuilderTests : TransformBuilderTestBase<AffineTransformBuilder>
 {
-    protected override AffineTransformBuilder CreateBuilder()
-        => new AffineTransformBuilder();
+    protected override AffineTransformBuilder CreateBuilder() => new();
 
     protected override void AppendRotationDegrees(AffineTransformBuilder builder, float degrees)
         => builder.AppendRotationDegrees(degrees);
diff --git a/tests/ImageSharp.Tests/Processing/Transforms/CropTest.cs b/tests/ImageSharp.Tests/Processing/Transforms/CropTest.cs
index 30c89ec339..c56df3152b 100644
--- a/tests/ImageSharp.Tests/Processing/Transforms/CropTest.cs
+++ b/tests/ImageSharp.Tests/Processing/Transforms/CropTest.cs
@@ -25,7 +25,7 @@ public class CropTest : BaseImageOperationsExtensionTest
     [InlineData(12, 123, 6, 2)]
     public void CropRectangleCropProcessorWithRectangleSet(int x, int y, int width, int height)
     {
-        var cropRectangle = new Rectangle(x, y, width, height);
+        Rectangle cropRectangle = new(x, y, width, height);
         this.operations.Crop(cropRectangle);
         CropProcessor processor = this.Verify<CropProcessor>();
 
@@ -35,7 +35,7 @@ public class CropTest : BaseImageOperationsExtensionTest
     [Fact]
     public void CropRectangleWithInvalidBoundsThrowsException()
     {
-        var cropRectangle = Rectangle.Inflate(this.SourceBounds(), 5, 5);
+        Rectangle cropRectangle = Rectangle.Inflate(this.SourceBounds(), 5, 5);
         Assert.Throws<ArgumentException>(() => this.operations.Crop(cropRectangle));
     }
 }
diff --git a/tests/ImageSharp.Tests/Processing/Transforms/ProjectiveTransformBuilderTests.cs b/tests/ImageSharp.Tests/Processing/Transforms/ProjectiveTransformBuilderTests.cs
index 7d0c0dc58f..a0380033fd 100644
--- a/tests/ImageSharp.Tests/Processing/Transforms/ProjectiveTransformBuilderTests.cs
+++ b/tests/ImageSharp.Tests/Processing/Transforms/ProjectiveTransformBuilderTests.cs
@@ -9,8 +9,7 @@ namespace SixLabors.ImageSharp.Tests.Processing.Transforms;
 [Trait("Category", "Processors")]
 public class ProjectiveTransformBuilderTests : TransformBuilderTestBase<ProjectiveTransformBuilder>
 {
-    protected override ProjectiveTransformBuilder CreateBuilder()
-        => new ProjectiveTransformBuilder();
+    protected override ProjectiveTransformBuilder CreateBuilder() => new();
 
     protected override void AppendRotationDegrees(ProjectiveTransformBuilder builder, float degrees)
         => builder.AppendRotationDegrees(degrees);
diff --git a/tests/ImageSharp.Tests/Processing/Transforms/ResizeTests.cs b/tests/ImageSharp.Tests/Processing/Transforms/ResizeTests.cs
index f6c93ffd0e..1d445b980c 100644
--- a/tests/ImageSharp.Tests/Processing/Transforms/ResizeTests.cs
+++ b/tests/ImageSharp.Tests/Processing/Transforms/ResizeTests.cs
@@ -64,7 +64,7 @@ public class ResizeTests : BaseImageOperationsExtensionTest
         bool compand = true;
         ResizeMode mode = ResizeMode.Stretch;
 
-        var resizeOptions = new ResizeOptions
+        ResizeOptions resizeOptions = new()
         {
             Size = new Size(width, height),
             Sampler = sampler,
@@ -93,7 +93,7 @@ public class ResizeTests : BaseImageOperationsExtensionTest
     {
         static void RunTest()
         {
-            using var image = new Image<Rgba32>(50, 50);
+            using Image<Rgba32> image = new(50, 50);
             image.Mutate(img => img.Resize(25, 25));
 
             Assert.Equal(25, image.Width);
diff --git a/tests/ImageSharp.Tests/Processing/Transforms/SwizzleTests.cs b/tests/ImageSharp.Tests/Processing/Transforms/SwizzleTests.cs
index 432bb5cacb..8475ce5abb 100644
--- a/tests/ImageSharp.Tests/Processing/Transforms/SwizzleTests.cs
+++ b/tests/ImageSharp.Tests/Processing/Transforms/SwizzleTests.cs
@@ -18,8 +18,7 @@ public class SwizzleTests : BaseImageOperationsExtensionTest
 
         public Size DestinationSize { get; }
 
-        public Point Transform(Point point)
-            => new Point(point.Y, point.X);
+        public Point Transform(Point point) => new(point.Y, point.X);
     }
 
     [Fact]
diff --git a/tests/ImageSharp.Tests/Processing/Transforms/TransformBuilderTestBase.cs b/tests/ImageSharp.Tests/Processing/Transforms/TransformBuilderTestBase.cs
index f046c2503c..5caf071aca 100644
--- a/tests/ImageSharp.Tests/Processing/Transforms/TransformBuilderTestBase.cs
+++ b/tests/ImageSharp.Tests/Processing/Transforms/TransformBuilderTestBase.cs
@@ -10,11 +10,11 @@ namespace SixLabors.ImageSharp.Tests.Processing.Transforms;
 [Trait("Category", "Processors")]
 public abstract class TransformBuilderTestBase<TBuilder>
 {
-    private static readonly ApproximateFloatComparer Comparer = new ApproximateFloatComparer(1e-6f);
+    private static readonly ApproximateFloatComparer Comparer = new(1e-6f);
 
     public static readonly TheoryData<Vector2, Vector2, Vector2, Vector2> ScaleTranslate_Data =
-        new TheoryData<Vector2, Vector2, Vector2, Vector2>
-            {
+        new()
+        {
                 // scale, translate, source, expectedDest
                 { Vector2.One, Vector2.Zero, Vector2.Zero, Vector2.Zero },
                 { Vector2.One, Vector2.Zero, new Vector2(10, 20), new Vector2(10, 20) },
@@ -29,7 +29,7 @@ public abstract class TransformBuilderTestBase<TBuilder>
 #pragma warning restore SA1300 // Element should begin with upper-case letter
     {
         // These operations should be size-agnostic:
-        var size = new Size(123, 321);
+        Size size = new(123, 321);
         TBuilder builder = this.CreateBuilder();
 
         this.AppendScale(builder, new SizeF(scale));
@@ -40,8 +40,8 @@ public abstract class TransformBuilderTestBase<TBuilder>
     }
 
     public static readonly TheoryData<Vector2, Vector2, Vector2, Vector2> TranslateScale_Data =
-        new TheoryData<Vector2, Vector2, Vector2, Vector2>
-            {
+        new()
+        {
                 // translate, scale, source, expectedDest
                 { Vector2.Zero, Vector2.One, Vector2.Zero, Vector2.Zero },
                 { Vector2.Zero, Vector2.One, new Vector2(10, 20), new Vector2(10, 20) },
@@ -55,7 +55,7 @@ public abstract class TransformBuilderTestBase<TBuilder>
 #pragma warning restore SA1300 // Element should begin with upper-case letter
     {
         // Translate ans scale are size-agnostic:
-        var size = new Size(456, 432);
+        Size size = new(456, 432);
         TBuilder builder = this.CreateBuilder();
 
         this.AppendTranslation(builder, translate);
@@ -70,7 +70,7 @@ public abstract class TransformBuilderTestBase<TBuilder>
     [InlineData(-20, 10)]
     public void LocationOffsetIsPrepended(int locationX, int locationY)
     {
-        var rectangle = new Rectangle(locationX, locationY, 10, 10);
+        Rectangle rectangle = new(locationX, locationY, 10, 10);
         TBuilder builder = this.CreateBuilder();
 
         this.AppendScale(builder, new SizeF(2, 2));
@@ -92,7 +92,7 @@ public abstract class TransformBuilderTestBase<TBuilder>
         float x,
         float y)
     {
-        var size = new Size(width, height);
+        Size size = new(width, height);
         TBuilder builder = this.CreateBuilder();
 
         this.AppendRotationDegrees(builder, degrees);
@@ -100,8 +100,8 @@ public abstract class TransformBuilderTestBase<TBuilder>
         // TODO: We should also test CreateRotationMatrixDegrees() (and all TransformUtils stuff!) for correctness
         Matrix3x2 matrix = TransformUtils.CreateRotationTransformMatrixDegrees(degrees, size, TransformSpace.Pixel);
 
-        var position = new Vector2(x, y);
-        var expected = Vector2.Transform(position, matrix);
+        Vector2 position = new(x, y);
+        Vector2 expected = Vector2.Transform(position, matrix);
         Vector2 actual = this.Execute(builder, new Rectangle(Point.Empty, size), position);
 
         Assert.Equal(actual, expected, Comparer);
@@ -120,16 +120,16 @@ public abstract class TransformBuilderTestBase<TBuilder>
         float x,
         float y)
     {
-        var size = new Size(width, height);
+        Size size = new(width, height);
         TBuilder builder = this.CreateBuilder();
 
-        var centerPoint = new Vector2(cx, cy);
+        Vector2 centerPoint = new(cx, cy);
         this.AppendRotationDegrees(builder, degrees, centerPoint);
 
-        var matrix = Matrix3x2.CreateRotation(GeometryUtilities.DegreeToRadian(degrees), centerPoint);
+        Matrix3x2 matrix = Matrix3x2.CreateRotation(GeometryUtilities.DegreeToRadian(degrees), centerPoint);
 
-        var position = new Vector2(x, y);
-        var expected = Vector2.Transform(position, matrix);
+        Vector2 position = new(x, y);
+        Vector2 expected = Vector2.Transform(position, matrix);
         Vector2 actual = this.Execute(builder, new Rectangle(Point.Empty, size), position);
 
         Assert.Equal(actual, expected, Comparer);
@@ -147,15 +147,15 @@ public abstract class TransformBuilderTestBase<TBuilder>
         float x,
         float y)
     {
-        var size = new Size(width, height);
+        Size size = new(width, height);
         TBuilder builder = this.CreateBuilder();
 
         this.AppendSkewDegrees(builder, degreesX, degreesY);
 
         Matrix3x2 matrix = TransformUtils.CreateSkewTransformMatrixDegrees(degreesX, degreesY, size, TransformSpace.Pixel);
 
-        var position = new Vector2(x, y);
-        var expected = Vector2.Transform(position, matrix);
+        Vector2 position = new(x, y);
+        Vector2 expected = Vector2.Transform(position, matrix);
         Vector2 actual = this.Execute(builder, new Rectangle(Point.Empty, size), position);
         Assert.Equal(actual, expected, Comparer);
     }
@@ -174,16 +174,16 @@ public abstract class TransformBuilderTestBase<TBuilder>
         float x,
         float y)
     {
-        var size = new Size(width, height);
+        Size size = new(width, height);
         TBuilder builder = this.CreateBuilder();
 
-        var centerPoint = new Vector2(cx, cy);
+        Vector2 centerPoint = new(cx, cy);
         this.AppendSkewDegrees(builder, degreesX, degreesY, centerPoint);
 
-        var matrix = Matrix3x2.CreateSkew(GeometryUtilities.DegreeToRadian(degreesX), GeometryUtilities.DegreeToRadian(degreesY), centerPoint);
+        Matrix3x2 matrix = Matrix3x2.CreateSkew(GeometryUtilities.DegreeToRadian(degreesX), GeometryUtilities.DegreeToRadian(degreesY), centerPoint);
 
-        var position = new Vector2(x, y);
-        var expected = Vector2.Transform(position, matrix);
+        Vector2 position = new(x, y);
+        Vector2 expected = Vector2.Transform(position, matrix);
         Vector2 actual = this.Execute(builder, new Rectangle(Point.Empty, size), position);
 
         Assert.Equal(actual, expected, Comparer);
@@ -192,7 +192,7 @@ public abstract class TransformBuilderTestBase<TBuilder>
     [Fact]
     public void AppendPrependOpposite()
     {
-        var rectangle = new Rectangle(-1, -1, 3, 3);
+        Rectangle rectangle = new(-1, -1, 3, 3);
         TBuilder b1 = this.CreateBuilder();
         TBuilder b2 = this.CreateBuilder();
 
@@ -226,7 +226,7 @@ public abstract class TransformBuilderTestBase<TBuilder>
     [InlineData(-1, 0)]
     public void ThrowsForInvalidSizes(int width, int height)
     {
-        var size = new Size(width, height);
+        Size size = new(width, height);
 
         Assert.ThrowsAny<ArgumentOutOfRangeException>(
             () =>
diff --git a/tests/ImageSharp.Tests/ProfilingBenchmarks/LoadResizeSaveProfilingBenchmarks.cs b/tests/ImageSharp.Tests/ProfilingBenchmarks/LoadResizeSaveProfilingBenchmarks.cs
index a1d7e358b6..209dd361ec 100644
--- a/tests/ImageSharp.Tests/ProfilingBenchmarks/LoadResizeSaveProfilingBenchmarks.cs
+++ b/tests/ImageSharp.Tests/ProfilingBenchmarks/LoadResizeSaveProfilingBenchmarks.cs
@@ -18,7 +18,7 @@ public class LoadResizeSaveProfilingBenchmarks : MeasureFixture
     [InlineData(TestImages.Jpeg.Baseline.Jpeg420Exif)]
     public void LoadResizeSave(string imagePath)
     {
-        var configuration = Configuration.CreateDefaultInstance();
+        Configuration configuration = Configuration.CreateDefaultInstance();
         configuration.MaxDegreeOfParallelism = 1;
 
         DecoderOptions options = new()
@@ -28,12 +28,12 @@ public class LoadResizeSaveProfilingBenchmarks : MeasureFixture
 
         byte[] imageBytes = TestFile.Create(imagePath).Bytes;
 
-        using var ms = new MemoryStream();
+        using MemoryStream ms = new();
         this.Measure(
             30,
             () =>
                 {
-                    using (var image = Image.Load(options, imageBytes))
+                    using (Image image = Image.Load(options, imageBytes))
                     {
                         image.Mutate(x => x.Resize(image.Size / 4));
                         image.SaveAsJpeg(ms);
diff --git a/tests/ImageSharp.Tests/ProfilingBenchmarks/ResizeProfilingBenchmarks.cs b/tests/ImageSharp.Tests/ProfilingBenchmarks/ResizeProfilingBenchmarks.cs
index f20ca8ce18..bab11b0f9d 100644
--- a/tests/ImageSharp.Tests/ProfilingBenchmarks/ResizeProfilingBenchmarks.cs
+++ b/tests/ImageSharp.Tests/ProfilingBenchmarks/ResizeProfilingBenchmarks.cs
@@ -28,7 +28,7 @@ public class ResizeProfilingBenchmarks : MeasureFixture
             this.ExecutionCount,
             () =>
                 {
-                    using (var image = new Image<Rgba32>(this.configuration, width, height))
+                    using (Image<Rgba32> image = new(this.configuration, width, height))
                     {
                         image.Mutate(x => x.Resize(width / 5, height / 5));
                     }
diff --git a/tests/ImageSharp.Tests/Quantization/QuantizedImageTests.cs b/tests/ImageSharp.Tests/Quantization/QuantizedImageTests.cs
index b59542482b..75c096b1f0 100644
--- a/tests/ImageSharp.Tests/Quantization/QuantizedImageTests.cs
+++ b/tests/ImageSharp.Tests/Quantization/QuantizedImageTests.cs
@@ -106,7 +106,7 @@ public class QuantizedImageTests
     {
         using Image<TPixel> image = provider.GetImage();
         OctreeQuantizer octreeQuantizer = new();
-        IQuantizer<TPixel> quantizer = octreeQuantizer.CreatePixelSpecificQuantizer<TPixel>(Configuration.Default, new QuantizerOptions() { MaxColors = 128 });
+        IQuantizer<TPixel> quantizer = octreeQuantizer.CreatePixelSpecificQuantizer<TPixel>(Configuration.Default, new QuantizerOptions { MaxColors = 128 });
         ImageFrame<TPixel> frame = image.Frames[0];
         quantizer.BuildPaletteAndQuantizeFrame(frame, frame.Bounds);
     }
diff --git a/tests/ImageSharp.Tests/Quantization/WuQuantizerTests.cs b/tests/ImageSharp.Tests/Quantization/WuQuantizerTests.cs
index 74f2fc3b42..28a7c49e51 100644
--- a/tests/ImageSharp.Tests/Quantization/WuQuantizerTests.cs
+++ b/tests/ImageSharp.Tests/Quantization/WuQuantizerTests.cs
@@ -79,7 +79,7 @@ public class WuQuantizerTests
         }
 
         Configuration config = Configuration.Default;
-        WuQuantizer quantizer = new(new QuantizerOptions { Dither = null });
+        WuQuantizer quantizer = new(new QuantizerOptions { Dither = null, TransparencyThreshold = 0 });
 
         ImageFrame<Rgba32> frame = image.Frames.RootFrame;
 
@@ -152,7 +152,7 @@ public class WuQuantizerTests
         }
 
         Configuration config = Configuration.Default;
-        WuQuantizer quantizer = new(new QuantizerOptions { Dither = null });
+        WuQuantizer quantizer = new(new QuantizerOptions { Dither = null, TransparencyThreshold = 0 });
 
         ImageFrame<Rgba32> frame = image.Frames.RootFrame;
         using (IQuantizer<Rgba32> frameQuantizer = quantizer.CreatePixelSpecificQuantizer<Rgba32>(config))
diff --git a/tests/ImageSharp.Tests/TestDataIcc/Conversion/IccConversionDataClut.cs b/tests/ImageSharp.Tests/TestDataIcc/Conversion/IccConversionDataClut.cs
new file mode 100644
index 0000000000..397986a189
--- /dev/null
+++ b/tests/ImageSharp.Tests/TestDataIcc/Conversion/IccConversionDataClut.cs
@@ -0,0 +1,162 @@
+// Copyright (c) Six Labors.
+// Licensed under the Six Labors Split License.
+
+using System.Numerics;
+using SixLabors.ImageSharp.Metadata.Profiles.Icc;
+
+namespace SixLabors.ImageSharp.Tests.TestDataIcc.Conversion;
+
+public class IccConversionDataClut
+{
+    internal static IccClut Clut3x2 = new(
+        [
+            0.1f, 0.1f,
+            0.2f, 0.2f,
+            0.3f, 0.3f,
+
+            0.11f, 0.11f,
+            0.21f, 0.21f,
+            0.31f, 0.31f,
+
+            0.12f, 0.12f,
+            0.22f, 0.22f,
+            0.32f, 0.32f,
+
+            0.13f, 0.13f,
+            0.23f, 0.23f,
+            0.33f, 0.33f,
+
+            0.14f, 0.14f,
+            0.24f, 0.24f,
+            0.34f, 0.34f,
+
+            0.15f, 0.15f,
+            0.25f, 0.25f,
+            0.35f, 0.35f,
+
+            0.16f, 0.16f,
+            0.26f, 0.26f,
+            0.36f, 0.36f,
+
+            0.17f, 0.17f,
+            0.27f, 0.27f,
+            0.37f, 0.37f,
+
+            0.18f, 0.18f,
+            0.28f, 0.28f,
+            0.38f, 0.38f,
+        ],
+        [3, 3, 3],
+        IccClutDataType.Float,
+        outputChannelCount: 2);
+
+    internal static IccClut Clut3x1 = new(
+        [
+             0.10f,
+             0.20f,
+             0.30f,
+
+             0.11f,
+             0.21f,
+             0.31f,
+
+             0.12f,
+             0.22f,
+             0.32f,
+
+             0.13f,
+             0.23f,
+             0.33f,
+
+             0.14f,
+             0.24f,
+             0.34f,
+
+             0.15f,
+             0.25f,
+             0.35f,
+
+             0.16f,
+             0.26f,
+             0.36f,
+
+             0.17f,
+             0.27f,
+             0.37f,
+
+             0.18f,
+             0.28f,
+             0.38f,
+        ],
+        [3, 3, 3],
+        IccClutDataType.Float,
+        outputChannelCount: 1);
+
+    internal static IccClut Clut2x2 = new(
+        [
+            0.1f, 0.9f,
+            0.2f, 0.8f,
+            0.3f, 0.7f,
+
+            0.4f, 0.6f,
+            0.5f, 0.5f,
+            0.6f, 0.4f,
+
+            0.7f, 0.3f,
+            0.8f, 0.2f,
+            0.9f, 0.1f,
+        ],
+        [3, 3],
+        IccClutDataType.Float,
+        outputChannelCount: 2);
+
+    internal static IccClut Clut2x1 = new(
+        [
+            0.1f,
+            0.2f,
+            0.3f,
+
+            0.4f,
+            0.5f,
+            0.6f,
+
+            0.7f,
+            0.8f,
+            0.9f,
+        ],
+        [3, 3],
+        IccClutDataType.Float,
+        outputChannelCount: 1);
+
+    internal static IccClut Clut1x2 = new(
+        [
+            0f, 0.5f,
+            0.25f, 0.75f,
+            0.5f, 1f,
+        ],
+        [3],
+        IccClutDataType.Float,
+        outputChannelCount: 2);
+
+    internal static IccClut Clut1x1 = new(
+        [
+            0f,
+            0.5f,
+            1f,
+        ],
+        [3],
+        IccClutDataType.Float,
+        outputChannelCount: 1);
+
+    public static object[][] ClutConversionTestData =
+    [
+        [Clut3x2, new Vector4(0.75f, 0.75f, 0.75f, 0), new Vector4(0.31f, 0.31f, 0, 0)],
+        [Clut3x1, new Vector4(0.2f, 0.6f, 0.8f, 0), new Vector4(0.284f, 0, 0, 0)],
+        [Clut3x1, new Vector4(0.75f, 0.75f, 0.75f, 0), new Vector4(0.31f, 0, 0, 0)],
+        [Clut2x2, new Vector4(0.2f, 0.6f, 0, 0), new Vector4(0.34f, 0.66f, 0, 0)],
+        [Clut2x2, new Vector4(0.25f, 0.75f, 0, 0), new Vector4(0.4f, 0.6f, 0, 0)],
+        [Clut2x1, new Vector4(0.25f, 0.75f, 0, 0), new Vector4(0.4f, 0, 0, 0)],
+        [Clut1x2, new Vector4(0.25f, 0, 0, 0), new Vector4(0.125f, 0.625f, 0, 0)],
+        [Clut1x1, new Vector4(0.25f, 0, 0, 0), new Vector4(0.25f, 0, 0, 0)],
+    ];
+}
diff --git a/tests/ImageSharp.Tests/TestDataIcc/Conversion/IccConversionDataLut.cs b/tests/ImageSharp.Tests/TestDataIcc/Conversion/IccConversionDataLut.cs
new file mode 100644
index 0000000000..e3bc3bba6e
--- /dev/null
+++ b/tests/ImageSharp.Tests/TestDataIcc/Conversion/IccConversionDataLut.cs
@@ -0,0 +1,30 @@
+// Copyright (c) Six Labors.
+// Licensed under the Six Labors Split License.
+
+namespace SixLabors.ImageSharp.Tests.TestDataIcc.Conversion;
+
+public class IccConversionDataLut
+{
+    private static readonly float[] LutEven = [0, 0.5f, 1];
+
+    private static readonly float[] LutUneven = [0, 0.7f, 1];
+
+    public static object[][] LutConversionTestData =
+    [
+        [LutEven, false,  0.5f, 0.5f],
+        [LutEven, false,  0.25f, 0.25f],
+        [LutEven, false,  0.75f, 0.75f],
+
+        [LutEven, true,  0.5f, 0.5f],
+        [LutEven, true,  0.25f, 0.25f],
+        [LutEven, true,  0.75f, 0.75f],
+
+        [LutUneven, false, 0.1, 0.14],
+        [LutUneven, false, 0.5, 0.7],
+        [LutUneven, false, 0.75, 0.85],
+
+        [LutUneven, true, 0.14, 0.1],
+        [LutUneven, true, 0.7, 0.5],
+        [LutUneven, true, 0.85, 0.75]
+    ];
+}
diff --git a/tests/ImageSharp.Tests/TestDataIcc/Conversion/IccConversionDataLutAB.cs b/tests/ImageSharp.Tests/TestDataIcc/Conversion/IccConversionDataLutAB.cs
new file mode 100644
index 0000000000..f38bc68d10
--- /dev/null
+++ b/tests/ImageSharp.Tests/TestDataIcc/Conversion/IccConversionDataLutAB.cs
@@ -0,0 +1,48 @@
+// Copyright (c) Six Labors.
+// Licensed under the Six Labors Split License.
+
+using System.Numerics;
+using SixLabors.ImageSharp.Metadata.Profiles.Icc;
+
+namespace SixLabors.ImageSharp.Tests.TestDataIcc.Conversion;
+
+public class IccConversionDataLutAB
+{
+    private static readonly IccLutAToBTagDataEntry LutAtoBSingleCurve = new(
+        [
+            IccConversionDataTrc.IdentityCurve,
+           IccConversionDataTrc.IdentityCurve,
+           IccConversionDataTrc.IdentityCurve
+        ],
+       null,
+       null,
+       null,
+       null,
+       null);
+
+    // also need:
+    // # CurveM + matrix
+    // # CurveA + CLUT + CurveB
+    // # CurveA + CLUT + CurveM + Matrix + CurveB
+    private static readonly IccLutBToATagDataEntry LutBtoASingleCurve = new(
+        [
+            IccConversionDataTrc.IdentityCurve,
+           IccConversionDataTrc.IdentityCurve,
+           IccConversionDataTrc.IdentityCurve
+        ],
+       null,
+       null,
+       null,
+       null,
+       null);
+
+    public static object[][] LutAToBConversionTestData =
+    [
+        [LutAtoBSingleCurve, new Vector4(0.2f, 0.3f, 0.4f, 0), new Vector4(0.2f, 0.3f, 0.4f, 0)]
+    ];
+
+    public static object[][] LutBToAConversionTestData =
+    [
+        [LutBtoASingleCurve, new Vector4(0.2f, 0.3f, 0.4f, 0), new Vector4(0.2f, 0.3f, 0.4f, 0)]
+    ];
+}
diff --git a/tests/ImageSharp.Tests/TestDataIcc/Conversion/IccConversionDataLutEntry.cs b/tests/ImageSharp.Tests/TestDataIcc/Conversion/IccConversionDataLutEntry.cs
new file mode 100644
index 0000000000..40f54ea74c
--- /dev/null
+++ b/tests/ImageSharp.Tests/TestDataIcc/Conversion/IccConversionDataLutEntry.cs
@@ -0,0 +1,71 @@
+// Copyright (c) Six Labors.
+// Licensed under the Six Labors Split License.
+
+using System.Numerics;
+using SixLabors.ImageSharp.Metadata.Profiles.Icc;
+
+namespace SixLabors.ImageSharp.Tests.TestDataIcc.Conversion;
+
+public class IccConversionDataLutEntry
+{
+    private static readonly IccLut Lut256 = CreateLut(256);
+    private static readonly IccLut Lut32 = CreateLut(32);
+    private static readonly IccLut LutIdentity = CreateIdentityLut(0, 1);
+
+    // test cases were originally calculated unaware that
+    // IccConversionDataMatrix.Matrix3x3Random is actually the row-major transposed matrix
+    // of the typical column-major matrix
+    public static float[,] TestMatrix =
+    {
+        { 0.1f, 0.4f, 0.7f },
+        { 0.2f, 0.5f, 0.8f },
+        { 0.3f, 0.6f, 0.9f }
+    };
+
+    private static readonly IccLut8TagDataEntry Lut8 = new(
+        [Lut256, Lut256],
+        IccConversionDataClut.Clut2x1,
+        [Lut256]);
+
+    private static readonly IccLut16TagDataEntry Lut16 = new(
+        [Lut32, Lut32],
+        IccConversionDataClut.Clut2x1,
+        [LutIdentity]);
+
+    private static readonly IccLut8TagDataEntry Lut8Matrix = new(
+        TestMatrix,
+        [Lut256, Lut256, Lut256],
+        IccConversionDataClut.Clut3x1,
+        [Lut256]);
+
+    private static readonly IccLut16TagDataEntry Lut16Matrix = new(
+        TestMatrix,
+        [Lut32, Lut32, Lut32],
+        IccConversionDataClut.Clut3x1,
+        [LutIdentity]);
+
+    private static IccLut CreateLut(int length)
+    {
+        float[] values = new float[length];
+        for (int i = 0; i < values.Length; i++)
+        {
+            values[i] = 0.1f + (i / (float)length);
+        }
+
+        return new IccLut(values);
+    }
+
+    private static IccLut CreateIdentityLut(float min, float max) => new([min, max]);
+
+    public static object[][] Lut8ConversionTestData =
+    [
+        [Lut8, new Vector4(0.2f, 0.3f, 0, 0), new Vector4(0.4578933760499877f, 0, 0, 0)],
+        [Lut8Matrix, new Vector4(0.21f, 0.31f, 0.41f, 0), new Vector4(0.40099657491875312f, 0, 0, 0)]
+    ];
+
+    public static object[][] Lut16ConversionTestData =
+    [
+        [Lut16, new Vector4(0.2f, 0.3f, 0, 0), new Vector4(0.3543750030529918f, 0, 0, 0)],
+        [Lut16Matrix, new Vector4(0.21f, 0.31f, 0.41f, 0), new Vector4(0.29739562389689594f, 0, 0, 0)]
+    ];
+}
diff --git a/tests/ImageSharp.Tests/TestDataIcc/Conversion/IccConversionDataMatrix.cs b/tests/ImageSharp.Tests/TestDataIcc/Conversion/IccConversionDataMatrix.cs
new file mode 100644
index 0000000000..5f14174616
--- /dev/null
+++ b/tests/ImageSharp.Tests/TestDataIcc/Conversion/IccConversionDataMatrix.cs
@@ -0,0 +1,59 @@
+// Copyright (c) Six Labors.
+// Licensed under the Six Labors Split License.
+
+using System.Numerics;
+
+namespace SixLabors.ImageSharp.Tests.TestDataIcc.Conversion;
+
+public class IccConversionDataMatrix
+{
+    private static readonly Vector3 Vector3Zero = new(0.0f, 0.0f, 0.0f);
+
+    public static float[,] Matrix3x3Random =
+    {
+        { 0.1f, 0.2f, 0.3f },
+        { 0.4f, 0.5f, 0.6f },
+        { 0.7f, 0.8f, 0.9f }
+    };
+
+    public static float[,] Matrix3x3Identity =
+    {
+        { 1, 0, 0 },
+        { 0, 1, 0 },
+        { 0, 0, 1 }
+    };
+
+    public static object[][] MatrixConversionTestData =
+    [
+        [CreateMatrix(Matrix3x3Identity), Vector3Zero, new Vector4(0.5f, 0.5f, 0.5f, 0), new Vector4(0.5f, 0.5f, 0.5f, 0)
+        ],
+        [CreateMatrix(Matrix3x3Identity), new Vector3(0.2f, 0.2f, 0.2f), new Vector4(0.5f, 0.5f, 0.5f, 0), new Vector4(0.7f, 0.7f, 0.7f, 0)
+        ],
+        [CreateMatrix(Matrix3x3Random), Vector3Zero, new Vector4(0.5f, 0.5f, 0.5f, 0), new Vector4(0.6f, 0.75f, 0.9f, 0)
+        ],
+        [CreateMatrix(Matrix3x3Random), new Vector3(0.1f, 0.2f, 0.3f), new Vector4(0.5f, 0.5f, 0.5f, 0), new Vector4(0.7f, 0.95f, 1.2f, 0)
+        ],
+        [CreateMatrix(Matrix3x3Random), Vector3Zero, new Vector4(0.2f, 0.4f, 0.7f, 0), new Vector4(0.67f, 0.8f, 0.93f, 0)
+        ],
+        [CreateMatrix(Matrix3x3Random), new Vector3(0.1f, 0.2f, 0.3f), new Vector4(0.2f, 0.4f, 0.7f, 0), new Vector4(0.77f, 1, 1.23f, 0)
+        ]
+    ];
+
+    private static Matrix4x4 CreateMatrix(float[,] matrix) => new(
+            matrix[0, 0],
+            matrix[0, 1],
+            matrix[0, 2],
+            0,
+            matrix[1, 0],
+            matrix[1, 1],
+            matrix[1, 2],
+            0,
+            matrix[2, 0],
+            matrix[2, 1],
+            matrix[2, 2],
+            0,
+            0,
+            0,
+            0,
+            1);
+}
diff --git a/tests/ImageSharp.Tests/TestDataIcc/Conversion/IccConversionDataMultiProcessElement.cs b/tests/ImageSharp.Tests/TestDataIcc/Conversion/IccConversionDataMultiProcessElement.cs
new file mode 100644
index 0000000000..f79666e3e3
--- /dev/null
+++ b/tests/ImageSharp.Tests/TestDataIcc/Conversion/IccConversionDataMultiProcessElement.cs
@@ -0,0 +1,80 @@
+// Copyright (c) Six Labors.
+// Licensed under the Six Labors Split License.
+
+using SixLabors.ImageSharp.Metadata.Profiles.Icc;
+
+namespace SixLabors.ImageSharp.Tests.TestDataIcc.Conversion;
+
+public class IccConversionDataMultiProcessElement
+{
+    private static readonly IccMatrixProcessElement Matrix = new(
+        new float[,]
+    {
+        { 2, 4, 6 },
+        { 3, 5, 7 },
+    },
+        new float[] { 3, 4, 5 });
+
+    private static readonly IccClut Clut = new(
+        new[]
+        {
+            0.2f, 0.3f,
+            0.4f, 0.2f,
+
+            0.21f, 0.31f,
+            0.41f, 0.51f,
+
+            0.22f, 0.32f,
+            0.42f, 0.52f,
+
+            0.23f, 0.33f,
+            0.43f, 0.53f,
+        },
+        new byte[] { 2, 2, 2 },
+        IccClutDataType.Float,
+        outputChannelCount: 2);
+
+    private static readonly IccFormulaCurveElement FormulaCurveElement1 = new(IccFormulaCurveType.Type1, 2.2f, 0.7f, 0.2f, 0.3f, 0, 0);
+    private static readonly IccFormulaCurveElement FormulaCurveElement2 = new(IccFormulaCurveType.Type2, 2.2f, 0.9f, 0.9f, 0.02f, 0.1f, 0);
+    private static readonly IccFormulaCurveElement FormulaCurveElement3 = new(IccFormulaCurveType.Type3, 0, 0.9f, 0.9f, 1.02f, 0.1f, 0.02f);
+
+    private static readonly IccCurveSetProcessElement CurveSet1DFormula1 = Create1DSingleCurveSet(FormulaCurveElement1);
+    private static readonly IccCurveSetProcessElement CurveSet1DFormula2 = Create1DSingleCurveSet(FormulaCurveElement2);
+    private static readonly IccCurveSetProcessElement CurveSet1DFormula3 = Create1DSingleCurveSet(FormulaCurveElement3);
+
+    private static readonly IccCurveSetProcessElement CurveSet1DFormula1And2 = Create1DMultiCurveSet(new[] { 0.5f }, FormulaCurveElement1, FormulaCurveElement2);
+
+    private static readonly IccClutProcessElement ClutElement = new(Clut);
+
+    private static IccCurveSetProcessElement Create1DSingleCurveSet(IccCurveSegment segment)
+    {
+        IccOneDimensionalCurve curve = new(new float[0], new[] { segment });
+        return new IccCurveSetProcessElement(new[] { curve });
+    }
+
+    private static IccCurveSetProcessElement Create1DMultiCurveSet(float[] breakPoints, params IccCurveSegment[] segments)
+    {
+        IccOneDimensionalCurve curve = new(breakPoints, segments);
+        return new IccCurveSetProcessElement(new[] { curve });
+    }
+
+    public static object[][] MpeCurveConversionTestData =
+    {
+        new object[] { CurveSet1DFormula1, new[] { 0.51f }, new[] { 0.575982451f } },
+        new object[] { CurveSet1DFormula2, new[] { 0.52f }, new[] { -0.4684991f } },
+        new object[] { CurveSet1DFormula3, new[] { 0.53f }, new[] { 0.86126f } },
+
+        new object[] { CurveSet1DFormula1And2, new[] { 0.31f }, new[] { 0.445982f } },
+        new object[] { CurveSet1DFormula1And2, new[] { 0.61f }, new[] { -0.341274023f } },
+    };
+
+    public static object[][] MpeMatrixConversionTestData =
+    {
+        new object[] { Matrix, new float[] { 2, 4 }, new float[] { 19, 32, 45 } }
+    };
+
+    public static object[][] MpeClutConversionTestData =
+    {
+        new object[] { ClutElement, new[] { 0.5f, 0.5f, 0.5f }, new[] { 0.5f, 0.5f } }
+    };
+}
diff --git a/tests/ImageSharp.Tests/TestDataIcc/Conversion/IccConversionDataTrc.cs b/tests/ImageSharp.Tests/TestDataIcc/Conversion/IccConversionDataTrc.cs
new file mode 100644
index 0000000000..d0ba39e4c7
--- /dev/null
+++ b/tests/ImageSharp.Tests/TestDataIcc/Conversion/IccConversionDataTrc.cs
@@ -0,0 +1,74 @@
+// Copyright (c) Six Labors.
+// Licensed under the Six Labors Split License.
+
+using System.Numerics;
+using SixLabors.ImageSharp.Metadata.Profiles.Icc;
+
+namespace SixLabors.ImageSharp.Tests.TestDataIcc.Conversion;
+
+public static class IccConversionDataTrc
+{
+    internal static IccCurveTagDataEntry IdentityCurve = new();
+    internal static IccCurveTagDataEntry Gamma2Curve = new(2);
+    internal static IccCurveTagDataEntry LutCurve = new([0, 0.7f, 1]);
+
+    internal static IccParametricCurveTagDataEntry ParamCurve1 = new(new IccParametricCurve(2.2f));
+    internal static IccParametricCurveTagDataEntry ParamCurve2 = new(new IccParametricCurve(2.2f, 1.5f, -0.5f));
+    internal static IccParametricCurveTagDataEntry ParamCurve3 = new(new IccParametricCurve(2.2f, 1.5f, -0.5f, 0.3f));
+    internal static IccParametricCurveTagDataEntry ParamCurve4 = new(new IccParametricCurve(2.4f, 1 / 1.055f, 0.055f / 1.055f, 1 / 12.92f, 0.04045f));
+    internal static IccParametricCurveTagDataEntry ParamCurve5 = new(new IccParametricCurve(2.2f, 0.7f, 0.2f, 0.3f, 0.1f, 0.5f, 0.2f));
+
+    public static object[][] TrcArrayConversionTestData { get; } =
+    [
+        [
+            new IccTagDataEntry[] { IdentityCurve, Gamma2Curve, ParamCurve1 },
+            false,
+            new Vector4(2, 2, 0.5f, 0),
+            new Vector4(2, 4, 0.217637628f, 0)
+        ],
+        [
+            new IccTagDataEntry[] { IdentityCurve, Gamma2Curve, ParamCurve1 },
+            true,
+            new Vector4(1, 4, 0.217637628f, 0),
+            new Vector4(1, 2, 0.5f, 0)
+        ]
+    ];
+
+    public static object[][] CurveConversionTestData { get; } =
+    [
+        [IdentityCurve, false, 2, 2],
+        [Gamma2Curve, false, 2, 4],
+        [LutCurve, false, 0.1, 0.14],
+        [LutCurve, false, 0.5, 0.7],
+        [LutCurve, false, 0.75, 0.85],
+
+        [IdentityCurve, true, 2, 2],
+        [Gamma2Curve, true, 4, 2],
+        [LutCurve, true, 0.14, 0.1],
+        [LutCurve, true, 0.7, 0.5],
+        [LutCurve, true, 0.85, 0.75]
+    ];
+
+    public static object[][] ParametricCurveConversionTestData { get; } =
+    [
+        [ParamCurve1, false, 0.5f, 0.217637628f],
+        [ParamCurve2, false, 0.6f, 0.133208528f],
+        [ParamCurve2, false, 0.21f, 0],
+        [ParamCurve3, false, 0.61f, 0.444446117f],
+        [ParamCurve3, false, 0.22f, 0.3f],
+        [ParamCurve4, false, 0.3f, 0.0732389539f],
+        [ParamCurve4, false, 0.03f, 0.00232198136f],
+        [ParamCurve5, false, 0.2f, 0.593165159f],
+        [ParamCurve5, false, 0.05f, 0.215f],
+
+        [ParamCurve1, true, 0.217637628f, 0.5f],
+        [ParamCurve2, true, 0.133208528f, 0.6f],
+        [ParamCurve2, true, 0, 1 / 3f],
+        [ParamCurve3, true, 0.444446117f, 0.61f],
+        [ParamCurve3, true, 0.3f, 1 / 3f],
+        [ParamCurve4, true, 0.0732389539f, 0.3f],
+        [ParamCurve4, true, 0.00232198136f, 0.03f],
+        [ParamCurve5, true, 0.593165159f, 0.2f],
+        [ParamCurve5, true, 0.215f, 0.05f]
+    ];
+}
diff --git a/tests/ImageSharp.Tests/TestDataIcc/IccTestDataArray.cs b/tests/ImageSharp.Tests/TestDataIcc/IccTestDataArray.cs
index 8288a294dd..3799641810 100644
--- a/tests/ImageSharp.Tests/TestDataIcc/IccTestDataArray.cs
+++ b/tests/ImageSharp.Tests/TestDataIcc/IccTestDataArray.cs
@@ -1,109 +1,109 @@
 // Copyright (c) Six Labors.
 // Licensed under the Six Labors Split License.
 
-namespace SixLabors.ImageSharp.Tests;
+namespace SixLabors.ImageSharp.Tests.TestDataIcc;
 
 internal static class IccTestDataArray
 {
-    public static readonly byte[] UInt8 = { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9 };
+    public static readonly byte[] UInt8 = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9];
 
     public static readonly object[][] UInt8TestData =
-    {
-        new object[] { UInt8, UInt8 }
-    };
-
-    public static readonly ushort[] UInt16_Val = { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9 };
-
-    public static readonly byte[] UInt16_Arr = ArrayHelper.Concat(
-        IccTestDataPrimitives.UInt16_0,
-        IccTestDataPrimitives.UInt16_1,
-        IccTestDataPrimitives.UInt16_2,
-        IccTestDataPrimitives.UInt16_3,
-        IccTestDataPrimitives.UInt16_4,
-        IccTestDataPrimitives.UInt16_5,
-        IccTestDataPrimitives.UInt16_6,
-        IccTestDataPrimitives.UInt16_7,
-        IccTestDataPrimitives.UInt16_8,
-        IccTestDataPrimitives.UInt16_9);
+    [
+        [UInt8, UInt8]
+    ];
+
+    public static readonly ushort[] UInt16Val = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9];
+
+    public static readonly byte[] UInt16Arr = ArrayHelper.Concat(
+        IccTestDataPrimitives.UInt160,
+        IccTestDataPrimitives.UInt161,
+        IccTestDataPrimitives.UInt162,
+        IccTestDataPrimitives.UInt163,
+        IccTestDataPrimitives.UInt164,
+        IccTestDataPrimitives.UInt165,
+        IccTestDataPrimitives.UInt166,
+        IccTestDataPrimitives.UInt167,
+        IccTestDataPrimitives.UInt168,
+        IccTestDataPrimitives.UInt169);
 
     public static readonly object[][] UInt16TestData =
-    {
-        new object[] { UInt16_Arr, UInt16_Val }
-    };
-
-    public static readonly short[] Int16_Val = { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9 };
-
-    public static readonly byte[] Int16_Arr = ArrayHelper.Concat(
-        IccTestDataPrimitives.Int16_0,
-        IccTestDataPrimitives.Int16_1,
-        IccTestDataPrimitives.Int16_2,
-        IccTestDataPrimitives.Int16_3,
-        IccTestDataPrimitives.Int16_4,
-        IccTestDataPrimitives.Int16_5,
-        IccTestDataPrimitives.Int16_6,
-        IccTestDataPrimitives.Int16_7,
-        IccTestDataPrimitives.Int16_8,
-        IccTestDataPrimitives.Int16_9);
+    [
+        [UInt16Arr, UInt16Val]
+    ];
+
+    public static readonly short[] Int16Val = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9];
+
+    public static readonly byte[] Int16Arr = ArrayHelper.Concat(
+        IccTestDataPrimitives.Int160,
+        IccTestDataPrimitives.Int161,
+        IccTestDataPrimitives.Int162,
+        IccTestDataPrimitives.Int163,
+        IccTestDataPrimitives.Int164,
+        IccTestDataPrimitives.Int165,
+        IccTestDataPrimitives.Int166,
+        IccTestDataPrimitives.Int167,
+        IccTestDataPrimitives.Int168,
+        IccTestDataPrimitives.Int169);
 
     public static readonly object[][] Int16TestData =
-    {
-        new object[] { Int16_Arr, Int16_Val }
-    };
-
-    public static readonly uint[] UInt32_Val = { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9 };
-
-    public static readonly byte[] UInt32_Arr = ArrayHelper.Concat(
-        IccTestDataPrimitives.UInt32_0,
-        IccTestDataPrimitives.UInt32_1,
-        IccTestDataPrimitives.UInt32_2,
-        IccTestDataPrimitives.UInt32_3,
-        IccTestDataPrimitives.UInt32_4,
-        IccTestDataPrimitives.UInt32_5,
-        IccTestDataPrimitives.UInt32_6,
-        IccTestDataPrimitives.UInt32_7,
-        IccTestDataPrimitives.UInt32_8,
-        IccTestDataPrimitives.UInt32_9);
+    [
+        [Int16Arr, Int16Val]
+    ];
+
+    public static readonly uint[] UInt32Val = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9];
+
+    public static readonly byte[] UInt32Arr = ArrayHelper.Concat(
+        IccTestDataPrimitives.UInt320,
+        IccTestDataPrimitives.UInt321,
+        IccTestDataPrimitives.UInt322,
+        IccTestDataPrimitives.UInt323,
+        IccTestDataPrimitives.UInt324,
+        IccTestDataPrimitives.UInt325,
+        IccTestDataPrimitives.UInt326,
+        IccTestDataPrimitives.UInt327,
+        IccTestDataPrimitives.UInt328,
+        IccTestDataPrimitives.UInt329);
 
     public static readonly object[][] UInt32TestData =
-    {
-        new object[] { UInt32_Arr, UInt32_Val }
-    };
-
-    public static readonly int[] Int32_Val = { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9 };
-
-    public static readonly byte[] Int32_Arr = ArrayHelper.Concat(
-        IccTestDataPrimitives.Int32_0,
-        IccTestDataPrimitives.Int32_1,
-        IccTestDataPrimitives.Int32_2,
-        IccTestDataPrimitives.Int32_3,
-        IccTestDataPrimitives.Int32_4,
-        IccTestDataPrimitives.Int32_5,
-        IccTestDataPrimitives.Int32_6,
-        IccTestDataPrimitives.Int32_7,
-        IccTestDataPrimitives.Int32_8,
-        IccTestDataPrimitives.Int32_9);
+    [
+        [UInt32Arr, UInt32Val]
+    ];
+
+    public static readonly int[] Int32Val = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9];
+
+    public static readonly byte[] Int32Arr = ArrayHelper.Concat(
+        IccTestDataPrimitives.Int320,
+        IccTestDataPrimitives.Int321,
+        IccTestDataPrimitives.Int322,
+        IccTestDataPrimitives.Int323,
+        IccTestDataPrimitives.Int324,
+        IccTestDataPrimitives.Int325,
+        IccTestDataPrimitives.Int326,
+        IccTestDataPrimitives.Int327,
+        IccTestDataPrimitives.Int328,
+        IccTestDataPrimitives.Int329);
 
     public static readonly object[][] Int32TestData =
-    {
-        new object[] { Int32_Arr, Int32_Val }
-    };
-
-    public static readonly ulong[] UInt64_Val = { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9 };
-
-    public static readonly byte[] UInt64_Arr = ArrayHelper.Concat(
-        IccTestDataPrimitives.UInt64_0,
-        IccTestDataPrimitives.UInt64_1,
-        IccTestDataPrimitives.UInt64_2,
-        IccTestDataPrimitives.UInt64_3,
-        IccTestDataPrimitives.UInt64_4,
-        IccTestDataPrimitives.UInt64_5,
-        IccTestDataPrimitives.UInt64_6,
-        IccTestDataPrimitives.UInt64_7,
-        IccTestDataPrimitives.UInt64_8,
-        IccTestDataPrimitives.UInt64_9);
+    [
+        [Int32Arr, Int32Val]
+    ];
+
+    public static readonly ulong[] UInt64Val = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9];
+
+    public static readonly byte[] UInt64Arr = ArrayHelper.Concat(
+        IccTestDataPrimitives.UInt640,
+        IccTestDataPrimitives.UInt641,
+        IccTestDataPrimitives.UInt642,
+        IccTestDataPrimitives.UInt643,
+        IccTestDataPrimitives.UInt644,
+        IccTestDataPrimitives.UInt645,
+        IccTestDataPrimitives.UInt646,
+        IccTestDataPrimitives.UInt647,
+        IccTestDataPrimitives.UInt648,
+        IccTestDataPrimitives.UInt649);
 
     public static readonly object[][] UInt64TestData =
-    {
-        new object[] { UInt64_Arr, UInt64_Val }
-    };
+    [
+        [UInt64Arr, UInt64Val]
+    ];
 }
diff --git a/tests/ImageSharp.Tests/TestDataIcc/IccTestDataCurves.cs b/tests/ImageSharp.Tests/TestDataIcc/IccTestDataCurves.cs
index f76d2ba036..be0d077b6a 100644
--- a/tests/ImageSharp.Tests/TestDataIcc/IccTestDataCurves.cs
+++ b/tests/ImageSharp.Tests/TestDataIcc/IccTestDataCurves.cs
@@ -3,309 +3,307 @@
 
 using SixLabors.ImageSharp.Metadata.Profiles.Icc;
 
-namespace SixLabors.ImageSharp.Tests;
+namespace SixLabors.ImageSharp.Tests.TestDataIcc;
 
 internal static class IccTestDataCurves
 {
     /// <summary>
     /// Channels: 3
     /// </summary>
-    public static readonly IccResponseCurve Response_ValGrad = new IccResponseCurve(
+    public static readonly IccResponseCurve ResponseValGrad = new(
         IccCurveMeasurementEncodings.StatusA,
-        new[]
-        {
-            IccTestDataNonPrimitives.XyzNumber_ValVar1,
-            IccTestDataNonPrimitives.XyzNumber_ValVar2,
-            IccTestDataNonPrimitives.XyzNumber_ValVar3
-        },
-        new IccResponseNumber[][]
-        {
-            new IccResponseNumber[] { IccTestDataNonPrimitives.ResponseNumber_Val1, IccTestDataNonPrimitives.ResponseNumber_Val2 },
-            new IccResponseNumber[] { IccTestDataNonPrimitives.ResponseNumber_Val3, IccTestDataNonPrimitives.ResponseNumber_Val4 },
-            new IccResponseNumber[] { IccTestDataNonPrimitives.ResponseNumber_Val5, IccTestDataNonPrimitives.ResponseNumber_Val6 },
-        });
+        [
+            IccTestDataNonPrimitives.XyzNumberValVar1,
+            IccTestDataNonPrimitives.XyzNumberValVar2,
+            IccTestDataNonPrimitives.XyzNumberValVar3
+        ],
+        [
+            [IccTestDataNonPrimitives.ResponseNumberVal1, IccTestDataNonPrimitives.ResponseNumberVal2],
+            [IccTestDataNonPrimitives.ResponseNumberVal3, IccTestDataNonPrimitives.ResponseNumberVal4],
+            [IccTestDataNonPrimitives.ResponseNumberVal5, IccTestDataNonPrimitives.ResponseNumberVal6]
+        ]);
 
     /// <summary>
     /// Channels: 3
     /// </summary>
-    public static readonly byte[] Response_Grad = ArrayHelper.Concat(
+    public static readonly byte[] ResponseGrad = ArrayHelper.Concat(
         new byte[] { 0x53, 0x74, 0x61, 0x41 },
-        IccTestDataPrimitives.UInt32_2,
-        IccTestDataPrimitives.UInt32_2,
-        IccTestDataPrimitives.UInt32_2,
-        IccTestDataNonPrimitives.XyzNumber_Var1,
-        IccTestDataNonPrimitives.XyzNumber_Var2,
-        IccTestDataNonPrimitives.XyzNumber_Var3,
-        IccTestDataNonPrimitives.ResponseNumber_1,
-        IccTestDataNonPrimitives.ResponseNumber_2,
-        IccTestDataNonPrimitives.ResponseNumber_3,
-        IccTestDataNonPrimitives.ResponseNumber_4,
-        IccTestDataNonPrimitives.ResponseNumber_5,
-        IccTestDataNonPrimitives.ResponseNumber_6);
+        IccTestDataPrimitives.UInt322,
+        IccTestDataPrimitives.UInt322,
+        IccTestDataPrimitives.UInt322,
+        IccTestDataNonPrimitives.XyzNumberVar1,
+        IccTestDataNonPrimitives.XyzNumberVar2,
+        IccTestDataNonPrimitives.XyzNumberVar3,
+        IccTestDataNonPrimitives.ResponseNumber1,
+        IccTestDataNonPrimitives.ResponseNumber2,
+        IccTestDataNonPrimitives.ResponseNumber3,
+        IccTestDataNonPrimitives.ResponseNumber4,
+        IccTestDataNonPrimitives.ResponseNumber5,
+        IccTestDataNonPrimitives.ResponseNumber6);
 
     public static readonly object[][] ResponseCurveTestData =
-    {
-        new object[] { Response_Grad, Response_ValGrad, 3 },
-    };
+    [
+        [ResponseGrad, ResponseValGrad, 3]
+    ];
 
-    public static readonly IccParametricCurve Parametric_ValVar1 = new IccParametricCurve(1);
-    public static readonly IccParametricCurve Parametric_ValVar2 = new IccParametricCurve(1, 2, 3);
-    public static readonly IccParametricCurve Parametric_ValVar3 = new IccParametricCurve(1, 2, 3, 4);
-    public static readonly IccParametricCurve Parametric_ValVar4 = new IccParametricCurve(1, 2, 3, 4, 5);
-    public static readonly IccParametricCurve Parametric_ValVar5 = new IccParametricCurve(1, 2, 3, 4, 5, 6, 7);
+    public static readonly IccParametricCurve ParametricValVar1 = new(1);
+    public static readonly IccParametricCurve ParametricValVar2 = new(1, 2, 3);
+    public static readonly IccParametricCurve ParametricValVar3 = new(1, 2, 3, 4);
+    public static readonly IccParametricCurve ParametricValVar4 = new(1, 2, 3, 4, 5);
+    public static readonly IccParametricCurve ParametricValVar5 = new(1, 2, 3, 4, 5, 6, 7);
 
-    public static readonly byte[] Parametric_Var1 = ArrayHelper.Concat(
+    public static readonly byte[] ParametricVar1 = ArrayHelper.Concat(
         new byte[]
         {
             0x00, 0x00,
             0x00, 0x00,
         },
-        IccTestDataPrimitives.Fix16_1);
+        IccTestDataPrimitives.Fix161);
 
-    public static readonly byte[] Parametric_Var2 = ArrayHelper.Concat(
+    public static readonly byte[] ParametricVar2 = ArrayHelper.Concat(
         new byte[]
         {
             0x00, 0x01,
             0x00, 0x00,
         },
-        IccTestDataPrimitives.Fix16_1,
-        IccTestDataPrimitives.Fix16_2,
-        IccTestDataPrimitives.Fix16_3);
+        IccTestDataPrimitives.Fix161,
+        IccTestDataPrimitives.Fix162,
+        IccTestDataPrimitives.Fix163);
 
-    public static readonly byte[] Parametric_Var3 = ArrayHelper.Concat(
+    public static readonly byte[] ParametricVar3 = ArrayHelper.Concat(
         new byte[]
         {
             0x00, 0x02,
             0x00, 0x00,
         },
-        IccTestDataPrimitives.Fix16_1,
-        IccTestDataPrimitives.Fix16_2,
-        IccTestDataPrimitives.Fix16_3,
-        IccTestDataPrimitives.Fix16_4);
+        IccTestDataPrimitives.Fix161,
+        IccTestDataPrimitives.Fix162,
+        IccTestDataPrimitives.Fix163,
+        IccTestDataPrimitives.Fix164);
 
-    public static readonly byte[] Parametric_Var4 = ArrayHelper.Concat(
+    public static readonly byte[] ParametricVar4 = ArrayHelper.Concat(
         new byte[]
         {
             0x00, 0x03,
             0x00, 0x00,
         },
-        IccTestDataPrimitives.Fix16_1,
-        IccTestDataPrimitives.Fix16_2,
-        IccTestDataPrimitives.Fix16_3,
-        IccTestDataPrimitives.Fix16_4,
-        IccTestDataPrimitives.Fix16_5);
+        IccTestDataPrimitives.Fix161,
+        IccTestDataPrimitives.Fix162,
+        IccTestDataPrimitives.Fix163,
+        IccTestDataPrimitives.Fix164,
+        IccTestDataPrimitives.Fix165);
 
-    public static readonly byte[] Parametric_Var5 = ArrayHelper.Concat(
+    public static readonly byte[] ParametricVar5 = ArrayHelper.Concat(
         new byte[]
         {
             0x00, 0x04,
             0x00, 0x00,
         },
-        IccTestDataPrimitives.Fix16_1,
-        IccTestDataPrimitives.Fix16_2,
-        IccTestDataPrimitives.Fix16_3,
-        IccTestDataPrimitives.Fix16_4,
-        IccTestDataPrimitives.Fix16_5,
-        IccTestDataPrimitives.Fix16_6,
-        IccTestDataPrimitives.Fix16_7);
+        IccTestDataPrimitives.Fix161,
+        IccTestDataPrimitives.Fix162,
+        IccTestDataPrimitives.Fix163,
+        IccTestDataPrimitives.Fix164,
+        IccTestDataPrimitives.Fix165,
+        IccTestDataPrimitives.Fix166,
+        IccTestDataPrimitives.Fix167);
 
     public static readonly object[][] ParametricCurveTestData =
-    {
-        new object[] { Parametric_Var1, Parametric_ValVar1 },
-        new object[] { Parametric_Var2, Parametric_ValVar2 },
-        new object[] { Parametric_Var3, Parametric_ValVar3 },
-        new object[] { Parametric_Var4, Parametric_ValVar4 },
-        new object[] { Parametric_Var5, Parametric_ValVar5 },
-    };
+    [
+        [ParametricVar1, ParametricValVar1],
+        [ParametricVar2, ParametricValVar2],
+        [ParametricVar3, ParametricValVar3],
+        [ParametricVar4, ParametricValVar4],
+        [ParametricVar5, ParametricValVar5]
+    ];
 
     // Formula Segment
-    public static readonly IccFormulaCurveElement Formula_ValVar1 = new IccFormulaCurveElement(IccFormulaCurveType.Type1, 1, 2, 3, 4, 0, 0);
-    public static readonly IccFormulaCurveElement Formula_ValVar2 = new IccFormulaCurveElement(IccFormulaCurveType.Type2, 1, 2, 3, 4, 5, 0);
-    public static readonly IccFormulaCurveElement Formula_ValVar3 = new IccFormulaCurveElement(IccFormulaCurveType.Type3, 0, 2, 3, 4, 5, 6);
+    public static readonly IccFormulaCurveElement FormulaValVar1 = new(IccFormulaCurveType.Type1, 1, 2, 3, 4, 0, 0);
+    public static readonly IccFormulaCurveElement FormulaValVar2 = new(IccFormulaCurveType.Type2, 1, 2, 3, 4, 5, 0);
+    public static readonly IccFormulaCurveElement FormulaValVar3 = new(IccFormulaCurveType.Type3, 0, 2, 3, 4, 5, 6);
 
-    public static readonly byte[] Formula_Var1 = ArrayHelper.Concat(
+    public static readonly byte[] FormulaVar1 = ArrayHelper.Concat(
         new byte[]
         {
             0x00, 0x00,
             0x00, 0x00,
         },
-        IccTestDataPrimitives.Single_1,
-        IccTestDataPrimitives.Single_2,
-        IccTestDataPrimitives.Single_3,
-        IccTestDataPrimitives.Single_4);
+        IccTestDataPrimitives.Single1,
+        IccTestDataPrimitives.Single2,
+        IccTestDataPrimitives.Single3,
+        IccTestDataPrimitives.Single4);
 
-    public static readonly byte[] Formula_Var2 = ArrayHelper.Concat(
+    public static readonly byte[] FormulaVar2 = ArrayHelper.Concat(
         new byte[]
         {
             0x00, 0x01,
             0x00, 0x00,
         },
-        IccTestDataPrimitives.Single_1,
-        IccTestDataPrimitives.Single_2,
-        IccTestDataPrimitives.Single_3,
-        IccTestDataPrimitives.Single_4,
-        IccTestDataPrimitives.Single_5);
+        IccTestDataPrimitives.Single1,
+        IccTestDataPrimitives.Single2,
+        IccTestDataPrimitives.Single3,
+        IccTestDataPrimitives.Single4,
+        IccTestDataPrimitives.Single5);
 
-    public static readonly byte[] Formula_Var3 = ArrayHelper.Concat(
+    public static readonly byte[] FormulaVar3 = ArrayHelper.Concat(
         new byte[]
         {
             0x00, 0x02,
             0x00, 0x00,
         },
-        IccTestDataPrimitives.Single_2,
-        IccTestDataPrimitives.Single_3,
-        IccTestDataPrimitives.Single_4,
-        IccTestDataPrimitives.Single_5,
-        IccTestDataPrimitives.Single_6);
+        IccTestDataPrimitives.Single2,
+        IccTestDataPrimitives.Single3,
+        IccTestDataPrimitives.Single4,
+        IccTestDataPrimitives.Single5,
+        IccTestDataPrimitives.Single6);
 
     public static readonly object[][] FormulaCurveSegmentTestData =
-    {
-        new object[] { Formula_Var1, Formula_ValVar1 },
-        new object[] { Formula_Var2, Formula_ValVar2 },
-        new object[] { Formula_Var3, Formula_ValVar3 },
-    };
+    [
+        [FormulaVar1, FormulaValVar1],
+        [FormulaVar2, FormulaValVar2],
+        [FormulaVar3, FormulaValVar3]
+    ];
 
     // Sampled Segment
-    public static readonly IccSampledCurveElement Sampled_ValGrad1 = new IccSampledCurveElement(new float[] { 1, 2, 3, 4, 5, 6, 7, 8, 9 });
-    public static readonly IccSampledCurveElement Sampled_ValGrad2 = new IccSampledCurveElement(new float[] { 9, 8, 7, 6, 5, 4, 3, 2, 1 });
-
-    public static readonly byte[] Sampled_Grad1 = ArrayHelper.Concat(
-        IccTestDataPrimitives.UInt32_9,
-        IccTestDataPrimitives.Single_1,
-        IccTestDataPrimitives.Single_2,
-        IccTestDataPrimitives.Single_3,
-        IccTestDataPrimitives.Single_4,
-        IccTestDataPrimitives.Single_5,
-        IccTestDataPrimitives.Single_6,
-        IccTestDataPrimitives.Single_7,
-        IccTestDataPrimitives.Single_8,
-        IccTestDataPrimitives.Single_9);
-
-    public static readonly byte[] Sampled_Grad2 = ArrayHelper.Concat(
-        IccTestDataPrimitives.UInt32_9,
-        IccTestDataPrimitives.Single_9,
-        IccTestDataPrimitives.Single_8,
-        IccTestDataPrimitives.Single_7,
-        IccTestDataPrimitives.Single_6,
-        IccTestDataPrimitives.Single_5,
-        IccTestDataPrimitives.Single_4,
-        IccTestDataPrimitives.Single_3,
-        IccTestDataPrimitives.Single_2,
-        IccTestDataPrimitives.Single_1);
+    public static readonly IccSampledCurveElement SampledValGrad1 = new([1, 2, 3, 4, 5, 6, 7, 8, 9]);
+    public static readonly IccSampledCurveElement SampledValGrad2 = new([9, 8, 7, 6, 5, 4, 3, 2, 1]);
+
+    public static readonly byte[] SampledGrad1 = ArrayHelper.Concat(
+        IccTestDataPrimitives.UInt329,
+        IccTestDataPrimitives.Single1,
+        IccTestDataPrimitives.Single2,
+        IccTestDataPrimitives.Single3,
+        IccTestDataPrimitives.Single4,
+        IccTestDataPrimitives.Single5,
+        IccTestDataPrimitives.Single6,
+        IccTestDataPrimitives.Single7,
+        IccTestDataPrimitives.Single8,
+        IccTestDataPrimitives.Single9);
+
+    public static readonly byte[] SampledGrad2 = ArrayHelper.Concat(
+        IccTestDataPrimitives.UInt329,
+        IccTestDataPrimitives.Single9,
+        IccTestDataPrimitives.Single8,
+        IccTestDataPrimitives.Single7,
+        IccTestDataPrimitives.Single6,
+        IccTestDataPrimitives.Single5,
+        IccTestDataPrimitives.Single4,
+        IccTestDataPrimitives.Single3,
+        IccTestDataPrimitives.Single2,
+        IccTestDataPrimitives.Single1);
 
     public static readonly object[][] SampledCurveSegmentTestData =
-    {
-        new object[] { Sampled_Grad1, Sampled_ValGrad1 },
-        new object[] { Sampled_Grad2, Sampled_ValGrad2 },
-    };
-
-    public static readonly IccCurveSegment Segment_ValFormula1 = Formula_ValVar1;
-    public static readonly IccCurveSegment Segment_ValFormula2 = Formula_ValVar2;
-    public static readonly IccCurveSegment Segment_ValFormula3 = Formula_ValVar3;
-    public static readonly IccCurveSegment Segment_ValSampled1 = Sampled_ValGrad1;
-    public static readonly IccCurveSegment Segment_ValSampled2 = Sampled_ValGrad2;
-
-    public static readonly byte[] Segment_Formula1 = ArrayHelper.Concat(
+    [
+        [SampledGrad1, SampledValGrad1],
+        [SampledGrad2, SampledValGrad2]
+    ];
+
+    public static readonly IccCurveSegment SegmentValFormula1 = FormulaValVar1;
+    public static readonly IccCurveSegment SegmentValFormula2 = FormulaValVar2;
+    public static readonly IccCurveSegment SegmentValFormula3 = FormulaValVar3;
+    public static readonly IccCurveSegment SegmentValSampled1 = SampledValGrad1;
+    public static readonly IccCurveSegment SegmentValSampled2 = SampledValGrad2;
+
+    public static readonly byte[] SegmentFormula1 = ArrayHelper.Concat(
         new byte[]
         {
             0x70, 0x61, 0x72, 0x66,
             0x00, 0x00, 0x00, 0x00,
         },
-        Formula_Var1);
+        FormulaVar1);
 
-    public static readonly byte[] Segment_Formula2 = ArrayHelper.Concat(
+    public static readonly byte[] SegmentFormula2 = ArrayHelper.Concat(
         new byte[]
         {
             0x70, 0x61, 0x72, 0x66,
             0x00, 0x00, 0x00, 0x00,
         },
-        Formula_Var2);
+        FormulaVar2);
 
-    public static readonly byte[] Segment_Formula3 = ArrayHelper.Concat(
+    public static readonly byte[] SegmentFormula3 = ArrayHelper.Concat(
         new byte[]
         {
             0x70, 0x61, 0x72, 0x66,
             0x00, 0x00, 0x00, 0x00,
         },
-        Formula_Var3);
+        FormulaVar3);
 
-    public static readonly byte[] Segment_Sampled1 = ArrayHelper.Concat(
+    public static readonly byte[] SegmentSampled1 = ArrayHelper.Concat(
         new byte[]
         {
             0x73, 0x61, 0x6D, 0x66,
             0x00, 0x00, 0x00, 0x00,
         },
-        Sampled_Grad1);
+        SampledGrad1);
 
-    public static readonly byte[] Segment_Sampled2 = ArrayHelper.Concat(
+    public static readonly byte[] SegmentSampled2 = ArrayHelper.Concat(
         new byte[]
         {
             0x73, 0x61, 0x6D, 0x66,
             0x00, 0x00, 0x00, 0x00,
         },
-        Sampled_Grad2);
+        SampledGrad2);
 
     public static readonly object[][] CurveSegmentTestData =
-    {
-        new object[] { Segment_Formula1, Segment_ValFormula1 },
-        new object[] { Segment_Formula2, Segment_ValFormula2 },
-        new object[] { Segment_Formula3, Segment_ValFormula3 },
-        new object[] { Segment_Sampled1, Segment_ValSampled1 },
-        new object[] { Segment_Sampled2, Segment_ValSampled2 },
-    };
-
-    public static readonly IccOneDimensionalCurve OneDimensional_ValFormula1 = new IccOneDimensionalCurve(
-        new float[] { 0, 1 },
-        new IccCurveSegment[] { Segment_ValFormula1, Segment_ValFormula2, Segment_ValFormula3 });
-
-    public static readonly IccOneDimensionalCurve OneDimensional_ValFormula2 = new IccOneDimensionalCurve(
-        new float[] { 0, 1 },
-        new IccCurveSegment[] { Segment_ValFormula3, Segment_ValFormula2, Segment_ValFormula1 });
-
-    public static readonly IccOneDimensionalCurve OneDimensional_ValSampled = new IccOneDimensionalCurve(
-        new float[] { 0, 1 },
-        new IccCurveSegment[] { Segment_ValSampled1, Segment_ValSampled2, Segment_ValSampled1 });
-
-    public static readonly byte[] OneDimensional_Formula1 = ArrayHelper.Concat(
+    [
+        [SegmentFormula1, SegmentValFormula1],
+        [SegmentFormula2, SegmentValFormula2],
+        [SegmentFormula3, SegmentValFormula3],
+        [SegmentSampled1, SegmentValSampled1],
+        [SegmentSampled2, SegmentValSampled2]
+    ];
+
+    public static readonly IccOneDimensionalCurve OneDimensionalValFormula1 = new(
+        [0, 1],
+        [SegmentValFormula1, SegmentValFormula2, SegmentValFormula3]);
+
+    public static readonly IccOneDimensionalCurve OneDimensionalValFormula2 = new(
+        [0, 1],
+        [SegmentValFormula3, SegmentValFormula2, SegmentValFormula1]);
+
+    public static readonly IccOneDimensionalCurve OneDimensionalValSampled = new(
+        [0, 1],
+        [SegmentValSampled1, SegmentValSampled2, SegmentValSampled1]);
+
+    public static readonly byte[] OneDimensionalFormula1 = ArrayHelper.Concat(
         new byte[]
         {
             0x00, 0x03,
             0x00, 0x00,
         },
-        IccTestDataPrimitives.Single_0,
-        IccTestDataPrimitives.Single_1,
-        Segment_Formula1,
-        Segment_Formula2,
-        Segment_Formula3);
+        IccTestDataPrimitives.Single0,
+        IccTestDataPrimitives.Single1,
+        SegmentFormula1,
+        SegmentFormula2,
+        SegmentFormula3);
 
-    public static readonly byte[] OneDimensional_Formula2 = ArrayHelper.Concat(
+    public static readonly byte[] OneDimensionalFormula2 = ArrayHelper.Concat(
         new byte[]
         {
             0x00, 0x03,
             0x00, 0x00,
         },
-        IccTestDataPrimitives.Single_0,
-        IccTestDataPrimitives.Single_1,
-        Segment_Formula3,
-        Segment_Formula2,
-        Segment_Formula1);
+        IccTestDataPrimitives.Single0,
+        IccTestDataPrimitives.Single1,
+        SegmentFormula3,
+        SegmentFormula2,
+        SegmentFormula1);
 
-    public static readonly byte[] OneDimensional_Sampled = ArrayHelper.Concat(
+    public static readonly byte[] OneDimensionalSampled = ArrayHelper.Concat(
         new byte[]
         {
             0x00, 0x03,
             0x00, 0x00,
         },
-        IccTestDataPrimitives.Single_0,
-        IccTestDataPrimitives.Single_1,
-        Segment_Sampled1,
-        Segment_Sampled2,
-        Segment_Sampled1);
+        IccTestDataPrimitives.Single0,
+        IccTestDataPrimitives.Single1,
+        SegmentSampled1,
+        SegmentSampled2,
+        SegmentSampled1);
 
     public static readonly object[][] OneDimensionalCurveTestData =
-    {
-        new object[] { OneDimensional_Formula1, OneDimensional_ValFormula1 },
-        new object[] { OneDimensional_Formula2, OneDimensional_ValFormula2 },
-        new object[] { OneDimensional_Sampled, OneDimensional_ValSampled },
-    };
+    [
+        [OneDimensionalFormula1, OneDimensionalValFormula1],
+        [OneDimensionalFormula2, OneDimensionalValFormula2],
+        [OneDimensionalSampled, OneDimensionalValSampled]
+    ];
 }
diff --git a/tests/ImageSharp.Tests/TestDataIcc/IccTestDataLut.cs b/tests/ImageSharp.Tests/TestDataIcc/IccTestDataLut.cs
index 7a778f269b..c0404d5f12 100644
--- a/tests/ImageSharp.Tests/TestDataIcc/IccTestDataLut.cs
+++ b/tests/ImageSharp.Tests/TestDataIcc/IccTestDataLut.cs
@@ -3,14 +3,14 @@
 
 using SixLabors.ImageSharp.Metadata.Profiles.Icc;
 
-namespace SixLabors.ImageSharp.Tests;
+namespace SixLabors.ImageSharp.Tests.TestDataIcc;
 
 internal static class IccTestDataLut
 {
-    public static readonly IccLut LUT8_ValGrad = CreateLUT8Val();
-    public static readonly byte[] LUT8_Grad = CreateLUT8();
+    public static readonly IccLut Lut8ValGrad = CreateLut8Val();
+    public static readonly byte[] Lut8Grad = CreateLut8();
 
-    private static IccLut CreateLUT8Val()
+    private static IccLut CreateLut8Val()
     {
         float[] result = new float[256];
         for (int i = 0; i < 256; i++)
@@ -21,7 +21,7 @@ internal static class IccTestDataLut
         return new IccLut(result);
     }
 
-    private static byte[] CreateLUT8()
+    private static byte[] CreateLut8()
     {
         byte[] result = new byte[256];
         for (int i = 0; i < 256; i++)
@@ -33,12 +33,11 @@ internal static class IccTestDataLut
     }
 
     public static readonly object[][] Lut8TestData =
-    {
-        new object[] { LUT8_Grad, LUT8_ValGrad },
-    };
+    [
+        [Lut8Grad, Lut8ValGrad]
+    ];
 
-    public static readonly IccLut LUT16_ValGrad = new IccLut(new float[]
-    {
+    public static readonly IccLut Lut16ValGrad = new([
         1f / ushort.MaxValue,
         2f / ushort.MaxValue,
         3f / ushort.MaxValue,
@@ -50,51 +49,51 @@ internal static class IccTestDataLut
         9f / ushort.MaxValue,
         32768f / ushort.MaxValue,
         1f
-    });
-
-    public static readonly byte[] LUT16_Grad = ArrayHelper.Concat(
-        IccTestDataPrimitives.UInt16_1,
-        IccTestDataPrimitives.UInt16_2,
-        IccTestDataPrimitives.UInt16_3,
-        IccTestDataPrimitives.UInt16_4,
-        IccTestDataPrimitives.UInt16_5,
-        IccTestDataPrimitives.UInt16_6,
-        IccTestDataPrimitives.UInt16_7,
-        IccTestDataPrimitives.UInt16_8,
-        IccTestDataPrimitives.UInt16_9,
-        IccTestDataPrimitives.UInt16_32768,
-        IccTestDataPrimitives.UInt16_Max);
+    ]);
+
+    public static readonly byte[] Lut16Grad = ArrayHelper.Concat(
+        IccTestDataPrimitives.UInt161,
+        IccTestDataPrimitives.UInt162,
+        IccTestDataPrimitives.UInt163,
+        IccTestDataPrimitives.UInt164,
+        IccTestDataPrimitives.UInt165,
+        IccTestDataPrimitives.UInt166,
+        IccTestDataPrimitives.UInt167,
+        IccTestDataPrimitives.UInt168,
+        IccTestDataPrimitives.UInt169,
+        IccTestDataPrimitives.UInt1632768,
+        IccTestDataPrimitives.UInt16Max);
 
     public static readonly object[][] Lut16TestData =
-    {
-        new object[] { LUT16_Grad, LUT16_ValGrad, 11 },
-    };
-
-    public static readonly IccClut CLUT8_ValGrad = new IccClut(
-        new float[][]
-        {
-            new float[] { 1f / byte.MaxValue, 2f / byte.MaxValue, 3f / byte.MaxValue },
-            new float[] { 4f / byte.MaxValue, 5f / byte.MaxValue, 6f / byte.MaxValue },
-            new float[] { 7f / byte.MaxValue, 8f / byte.MaxValue, 9f / byte.MaxValue },
-
-            new float[] { 10f / byte.MaxValue, 11f / byte.MaxValue, 12f / byte.MaxValue },
-            new float[] { 13f / byte.MaxValue, 14f / byte.MaxValue, 15f / byte.MaxValue },
-            new float[] { 16f / byte.MaxValue, 17f / byte.MaxValue, 18f / byte.MaxValue },
-
-            new float[] { 19f / byte.MaxValue, 20f / byte.MaxValue, 21f / byte.MaxValue },
-            new float[] { 22f / byte.MaxValue, 23f / byte.MaxValue, 24f / byte.MaxValue },
-            new float[] { 25f / byte.MaxValue, 26f / byte.MaxValue, 27f / byte.MaxValue },
-        },
-        new byte[] { 3, 3 },
-        IccClutDataType.UInt8);
+    [
+        [Lut16Grad, Lut16ValGrad, 11]
+    ];
+
+    public static readonly IccClut Clut8ValGrad = new(
+        [
+            1f / byte.MaxValue, 2f / byte.MaxValue, 3f / byte.MaxValue,
+            4f / byte.MaxValue, 5f / byte.MaxValue, 6f / byte.MaxValue,
+            7f / byte.MaxValue, 8f / byte.MaxValue, 9f / byte.MaxValue,
+
+            10f / byte.MaxValue, 11f / byte.MaxValue, 12f / byte.MaxValue,
+            13f / byte.MaxValue, 14f / byte.MaxValue, 15f / byte.MaxValue,
+            16f / byte.MaxValue, 17f / byte.MaxValue, 18f / byte.MaxValue,
+
+            19f / byte.MaxValue, 20f / byte.MaxValue, 21f / byte.MaxValue,
+            22f / byte.MaxValue, 23f / byte.MaxValue, 24f / byte.MaxValue,
+            25f / byte.MaxValue, 26f / byte.MaxValue, 27f / byte.MaxValue
+        ],
+        [3, 3],
+        IccClutDataType.UInt8,
+        outputChannelCount: 3);
 
     /// <summary>
     /// <para>Input Channel Count: 2</para>
     /// <para>Output Channel Count: 3</para>
     /// <para>Grid-point Count: { 3, 3 }</para>
     /// </summary>
-    public static readonly byte[] CLUT8_Grad =
-    {
+    public static readonly byte[] Clut8Grad =
+    [
         0x01, 0x02, 0x03,
         0x04, 0x05, 0x06,
         0x07, 0x08, 0x09,
@@ -105,39 +104,39 @@ internal static class IccTestDataLut
 
         0x13, 0x14, 0x15,
         0x16, 0x17, 0x18,
-        0x19, 0x1A, 0x1B,
-    };
+        0x19, 0x1A, 0x1B
+    ];
 
     public static readonly object[][] Clut8TestData =
-    {
-        new object[] { CLUT8_Grad, CLUT8_ValGrad, 2, 3, new byte[] { 3, 3 } },
-    };
-
-    public static readonly IccClut CLUT16_ValGrad = new IccClut(
-        new float[][]
-        {
-            new float[] { 1f / ushort.MaxValue, 2f / ushort.MaxValue, 3f / ushort.MaxValue },
-            new float[] { 4f / ushort.MaxValue, 5f / ushort.MaxValue, 6f / ushort.MaxValue },
-            new float[] { 7f / ushort.MaxValue, 8f / ushort.MaxValue, 9f / ushort.MaxValue },
-
-            new float[] { 10f / ushort.MaxValue, 11f / ushort.MaxValue, 12f / ushort.MaxValue },
-            new float[] { 13f / ushort.MaxValue, 14f / ushort.MaxValue, 15f / ushort.MaxValue },
-            new float[] { 16f / ushort.MaxValue, 17f / ushort.MaxValue, 18f / ushort.MaxValue },
-
-            new float[] { 19f / ushort.MaxValue, 20f / ushort.MaxValue, 21f / ushort.MaxValue },
-            new float[] { 22f / ushort.MaxValue, 23f / ushort.MaxValue, 24f / ushort.MaxValue },
-            new float[] { 25f / ushort.MaxValue, 26f / ushort.MaxValue, 27f / ushort.MaxValue },
-        },
-        new byte[] { 3, 3 },
-        IccClutDataType.UInt16);
+    [
+        [Clut8Grad, Clut8ValGrad, 2, 3, new byte[] { 3, 3 }]
+    ];
+
+    public static readonly IccClut Clut16ValGrad = new(
+        [
+            1f / ushort.MaxValue, 2f / ushort.MaxValue, 3f / ushort.MaxValue,
+            4f / ushort.MaxValue, 5f / ushort.MaxValue, 6f / ushort.MaxValue,
+            7f / ushort.MaxValue, 8f / ushort.MaxValue, 9f / ushort.MaxValue,
+
+            10f / ushort.MaxValue, 11f / ushort.MaxValue, 12f / ushort.MaxValue,
+            13f / ushort.MaxValue, 14f / ushort.MaxValue, 15f / ushort.MaxValue,
+            16f / ushort.MaxValue, 17f / ushort.MaxValue, 18f / ushort.MaxValue,
+
+            19f / ushort.MaxValue, 20f / ushort.MaxValue, 21f / ushort.MaxValue,
+            22f / ushort.MaxValue, 23f / ushort.MaxValue, 24f / ushort.MaxValue,
+            25f / ushort.MaxValue, 26f / ushort.MaxValue, 27f / ushort.MaxValue
+        ],
+        [3, 3],
+        IccClutDataType.UInt16,
+        outputChannelCount: 3);
 
     /// <summary>
     /// <para>Input Channel Count: 2</para>
     /// <para>Output Channel Count: 3</para>
     /// <para>Grid-point Count: { 3, 3 }</para>
     /// </summary>
-    public static readonly byte[] CLUT16_Grad =
-    {
+    public static readonly byte[] Clut16Grad =
+    [
         0x00, 0x01, 0x00, 0x02, 0x00, 0x03,
         0x00, 0x04, 0x00, 0x05, 0x00, 0x06,
         0x00, 0x07, 0x00, 0x08, 0x00, 0x09,
@@ -148,93 +147,93 @@ internal static class IccTestDataLut
 
         0x00, 0x13, 0x00, 0x14, 0x00, 0x15,
         0x00, 0x16, 0x00, 0x17, 0x00, 0x18,
-        0x00, 0x19, 0x00, 0x1A, 0x00, 0x1B,
-    };
+        0x00, 0x19, 0x00, 0x1A, 0x00, 0x1B
+    ];
 
     public static readonly object[][] Clut16TestData =
-    {
-        new object[] { CLUT16_Grad, CLUT16_ValGrad, 2, 3, new byte[] { 3, 3 } },
-    };
-
-    public static readonly IccClut CLUTf32_ValGrad = new IccClut(
-        new float[][]
-        {
-            new float[] { 1f, 2f, 3f },
-            new float[] { 4f, 5f, 6f },
-            new float[] { 7f, 8f, 9f },
-
-            new float[] { 1f, 2f, 3f },
-            new float[] { 4f, 5f, 6f },
-            new float[] { 7f, 8f, 9f },
-
-            new float[] { 1f, 2f, 3f },
-            new float[] { 4f, 5f, 6f },
-            new float[] { 7f, 8f, 9f },
-        },
-        new byte[] { 3, 3 },
-        IccClutDataType.Float);
+    [
+        [Clut16Grad, Clut16ValGrad, 2, 3, new byte[] { 3, 3 }]
+    ];
+
+    public static readonly IccClut CluTf32ValGrad = new(
+        [
+            1f, 2f, 3f,
+            4f, 5f, 6f,
+            7f, 8f, 9f,
+
+            1f, 2f, 3f,
+            4f, 5f, 6f,
+            7f, 8f, 9f,
+
+            1f, 2f, 3f,
+            4f, 5f, 6f,
+            7f, 8f, 9f
+        ],
+        [3, 3],
+        IccClutDataType.Float,
+        outputChannelCount: 3);
 
     /// <summary>
     /// <para>Input Channel Count: 2</para>
     /// <para>Output Channel Count: 3</para>
     /// <para>Grid-point Count: { 3, 3 }</para>
     /// </summary>
-    public static readonly byte[] CLUTf32_Grad = ArrayHelper.Concat(
-        IccTestDataPrimitives.Single_1,
-        IccTestDataPrimitives.Single_2,
-        IccTestDataPrimitives.Single_3,
-        IccTestDataPrimitives.Single_4,
-        IccTestDataPrimitives.Single_5,
-        IccTestDataPrimitives.Single_6,
-        IccTestDataPrimitives.Single_7,
-        IccTestDataPrimitives.Single_8,
-        IccTestDataPrimitives.Single_9,
-        IccTestDataPrimitives.Single_1,
-        IccTestDataPrimitives.Single_2,
-        IccTestDataPrimitives.Single_3,
-        IccTestDataPrimitives.Single_4,
-        IccTestDataPrimitives.Single_5,
-        IccTestDataPrimitives.Single_6,
-        IccTestDataPrimitives.Single_7,
-        IccTestDataPrimitives.Single_8,
-        IccTestDataPrimitives.Single_9,
-        IccTestDataPrimitives.Single_1,
-        IccTestDataPrimitives.Single_2,
-        IccTestDataPrimitives.Single_3,
-        IccTestDataPrimitives.Single_4,
-        IccTestDataPrimitives.Single_5,
-        IccTestDataPrimitives.Single_6,
-        IccTestDataPrimitives.Single_7,
-        IccTestDataPrimitives.Single_8,
-        IccTestDataPrimitives.Single_9);
+    public static readonly byte[] CluTf32Grad = ArrayHelper.Concat(
+        IccTestDataPrimitives.Single1,
+        IccTestDataPrimitives.Single2,
+        IccTestDataPrimitives.Single3,
+        IccTestDataPrimitives.Single4,
+        IccTestDataPrimitives.Single5,
+        IccTestDataPrimitives.Single6,
+        IccTestDataPrimitives.Single7,
+        IccTestDataPrimitives.Single8,
+        IccTestDataPrimitives.Single9,
+        IccTestDataPrimitives.Single1,
+        IccTestDataPrimitives.Single2,
+        IccTestDataPrimitives.Single3,
+        IccTestDataPrimitives.Single4,
+        IccTestDataPrimitives.Single5,
+        IccTestDataPrimitives.Single6,
+        IccTestDataPrimitives.Single7,
+        IccTestDataPrimitives.Single8,
+        IccTestDataPrimitives.Single9,
+        IccTestDataPrimitives.Single1,
+        IccTestDataPrimitives.Single2,
+        IccTestDataPrimitives.Single3,
+        IccTestDataPrimitives.Single4,
+        IccTestDataPrimitives.Single5,
+        IccTestDataPrimitives.Single6,
+        IccTestDataPrimitives.Single7,
+        IccTestDataPrimitives.Single8,
+        IccTestDataPrimitives.Single9);
 
     public static readonly object[][] ClutF32TestData =
-    {
-        new object[] { CLUTf32_Grad, CLUTf32_ValGrad, 2, 3, new byte[] { 3, 3 } },
-    };
+    [
+        [CluTf32Grad, CluTf32ValGrad, 2, 3, new byte[] { 3, 3 }]
+    ];
 
-    public static readonly IccClut CLUT_Val8 = CLUT8_ValGrad;
-    public static readonly IccClut CLUT_Val16 = CLUT16_ValGrad;
-    public static readonly IccClut CLUT_Valf32 = CLUTf32_ValGrad;
+    public static readonly IccClut ClutVal8 = Clut8ValGrad;
+    public static readonly IccClut ClutVal16 = Clut16ValGrad;
+    public static readonly IccClut ClutValf32 = CluTf32ValGrad;
 
-    public static readonly byte[] CLUT_8 = ArrayHelper.Concat(
+    public static readonly byte[] Clut8 = ArrayHelper.Concat(
         new byte[16] { 0x03, 0x03, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 },
         new byte[4] { 0x01, 0x00, 0x00, 0x00 },
-        CLUT8_Grad);
+        Clut8Grad);
 
-    public static readonly byte[] CLUT_16 = ArrayHelper.Concat(
+    public static readonly byte[] Clut16 = ArrayHelper.Concat(
         new byte[16] { 0x03, 0x03, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 },
         new byte[4] { 0x02, 0x00, 0x00, 0x00 },
-        CLUT16_Grad);
+        Clut16Grad);
 
-    public static readonly byte[] CLUT_f32 = ArrayHelper.Concat(
+    public static readonly byte[] ClutF32 = ArrayHelper.Concat(
         new byte[16] { 0x03, 0x03, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 },
-        CLUTf32_Grad);
+        CluTf32Grad);
 
     public static readonly object[][] ClutTestData =
-    {
-        new object[] { CLUT_8, CLUT_Val8, 2, 3, false },
-        new object[] { CLUT_16, CLUT_Val16, 2, 3, false },
-        new object[] { CLUT_f32, CLUT_Valf32, 2, 3, true },
-    };
+    [
+        [Clut8, ClutVal8, 2, 3, false],
+        [Clut16, ClutVal16, 2, 3, false],
+        [ClutF32, ClutValf32, 2, 3, true]
+    ];
 }
diff --git a/tests/ImageSharp.Tests/TestDataIcc/IccTestDataMatrix.cs b/tests/ImageSharp.Tests/TestDataIcc/IccTestDataMatrix.cs
index 94df8d69a6..6a900a0154 100644
--- a/tests/ImageSharp.Tests/TestDataIcc/IccTestDataMatrix.cs
+++ b/tests/ImageSharp.Tests/TestDataIcc/IccTestDataMatrix.cs
@@ -3,16 +3,14 @@
 
 using System.Numerics;
 
-namespace SixLabors.ImageSharp.Tests;
-
-using SixLabors.ImageSharp;
+namespace SixLabors.ImageSharp.Tests.TestDataIcc;
 
 internal static class IccTestDataMatrix
 {
     /// <summary>
     /// 3x3 Matrix
     /// </summary>
-    public static readonly float[,] Single_2DArray_ValGrad =
+    public static readonly float[,] Single2DArrayValGrad =
     {
         { 1, 2, 3 },
         { 4, 5, 6 },
@@ -22,7 +20,7 @@ internal static class IccTestDataMatrix
     /// <summary>
     /// 3x3 Matrix
     /// </summary>
-    public static readonly float[,] Single_2DArray_ValIdentity =
+    public static readonly float[,] Single2DArrayValIdentity =
     {
         { 1, 0, 0 },
         { 0, 1, 0 },
@@ -32,121 +30,121 @@ internal static class IccTestDataMatrix
     /// <summary>
     /// 3x3 Matrix
     /// </summary>
-    public static readonly Matrix4x4 Single_Matrix4x4_ValGrad = new Matrix4x4(1, 2, 3, 0, 4, 5, 6, 0, 7, 8, 9, 0, 0, 0, 0, 1);
+    public static readonly Matrix4x4 SingleMatrix4X4ValGrad = new(1, 2, 3, 0, 4, 5, 6, 0, 7, 8, 9, 0, 0, 0, 0, 1);
 
     /// <summary>
     /// 3x3 Matrix
     /// </summary>
-    public static readonly Matrix4x4 Single_Matrix4x4_ValIdentity = Matrix4x4.Identity;
+    public static readonly Matrix4x4 SingleMatrix4X4ValIdentity = Matrix4x4.Identity;
 
     /// <summary>
     /// 3x3 Matrix
     /// </summary>
-    public static readonly DenseMatrix<float> Single_DenseMatrix_ValGrad = new DenseMatrix<float>(Single_2DArray_ValGrad);
+    public static readonly DenseMatrix<float> SingleDenseMatrixValGrad = new(Single2DArrayValGrad);
 
     /// <summary>
     /// 3x3 Matrix
     /// </summary>
-    public static readonly DenseMatrix<float> Single_DenseMatrix_ValIdentity = new DenseMatrix<float>(Single_2DArray_ValIdentity);
+    public static readonly DenseMatrix<float> SingleDenseMatrixValIdentity = new(Single2DArrayValIdentity);
 
     /// <summary>
     /// 3x3 Matrix
     /// </summary>
-    public static readonly byte[] Fix16_2D_Grad = ArrayHelper.Concat(
-        IccTestDataPrimitives.Fix16_1,
-        IccTestDataPrimitives.Fix16_4,
-        IccTestDataPrimitives.Fix16_7,
-        IccTestDataPrimitives.Fix16_2,
-        IccTestDataPrimitives.Fix16_5,
-        IccTestDataPrimitives.Fix16_8,
-        IccTestDataPrimitives.Fix16_3,
-        IccTestDataPrimitives.Fix16_6,
-        IccTestDataPrimitives.Fix16_9);
+    public static readonly byte[] Fix162DGrad = ArrayHelper.Concat(
+        IccTestDataPrimitives.Fix161,
+        IccTestDataPrimitives.Fix164,
+        IccTestDataPrimitives.Fix167,
+        IccTestDataPrimitives.Fix162,
+        IccTestDataPrimitives.Fix165,
+        IccTestDataPrimitives.Fix168,
+        IccTestDataPrimitives.Fix163,
+        IccTestDataPrimitives.Fix166,
+        IccTestDataPrimitives.Fix169);
 
     /// <summary>
     /// 3x3 Matrix
     /// </summary>
-    public static readonly byte[] Fix16_2D_Identity = ArrayHelper.Concat(
-        IccTestDataPrimitives.Fix16_1,
-        IccTestDataPrimitives.Fix16_0,
-        IccTestDataPrimitives.Fix16_0,
-        IccTestDataPrimitives.Fix16_0,
-        IccTestDataPrimitives.Fix16_1,
-        IccTestDataPrimitives.Fix16_0,
-        IccTestDataPrimitives.Fix16_0,
-        IccTestDataPrimitives.Fix16_0,
-        IccTestDataPrimitives.Fix16_1);
+    public static readonly byte[] Fix162DIdentity = ArrayHelper.Concat(
+        IccTestDataPrimitives.Fix161,
+        IccTestDataPrimitives.Fix160,
+        IccTestDataPrimitives.Fix160,
+        IccTestDataPrimitives.Fix160,
+        IccTestDataPrimitives.Fix161,
+        IccTestDataPrimitives.Fix160,
+        IccTestDataPrimitives.Fix160,
+        IccTestDataPrimitives.Fix160,
+        IccTestDataPrimitives.Fix161);
 
     /// <summary>
     /// 3x3 Matrix
     /// </summary>
-    public static readonly byte[] Single_2D_Grad = ArrayHelper.Concat(
-        IccTestDataPrimitives.Single_1,
-        IccTestDataPrimitives.Single_4,
-        IccTestDataPrimitives.Single_7,
-        IccTestDataPrimitives.Single_2,
-        IccTestDataPrimitives.Single_5,
-        IccTestDataPrimitives.Single_8,
-        IccTestDataPrimitives.Single_3,
-        IccTestDataPrimitives.Single_6,
-        IccTestDataPrimitives.Single_9);
-
-    public static readonly object[][] Matrix2D_FloatArrayTestData =
-    {
-        new object[] { Fix16_2D_Grad, 3, 3, false, Single_2DArray_ValGrad },
-        new object[] { Fix16_2D_Identity, 3, 3, false, Single_2DArray_ValIdentity },
-        new object[] { Single_2D_Grad, 3, 3, true, Single_2DArray_ValGrad },
-    };
-
-    public static readonly object[][] Matrix2D_DenseMatrixTestData =
-    {
-        new object[] { Fix16_2D_Grad, 3, 3, false, Single_DenseMatrix_ValGrad },
-        new object[] { Fix16_2D_Identity, 3, 3, false, Single_DenseMatrix_ValIdentity },
-        new object[] { Single_2D_Grad, 3, 3, true, Single_DenseMatrix_ValGrad },
-    };
-
-    public static readonly object[][] Matrix2D_Matrix4x4TestData =
-    {
-        new object[] { Fix16_2D_Grad, 3, 3, false, Single_Matrix4x4_ValGrad },
-        new object[] { Fix16_2D_Identity, 3, 3, false, Single_Matrix4x4_ValIdentity },
-        new object[] { Single_2D_Grad, 3, 3, true, Single_Matrix4x4_ValGrad },
-    };
+    public static readonly byte[] Single2DGrad = ArrayHelper.Concat(
+        IccTestDataPrimitives.Single1,
+        IccTestDataPrimitives.Single4,
+        IccTestDataPrimitives.Single7,
+        IccTestDataPrimitives.Single2,
+        IccTestDataPrimitives.Single5,
+        IccTestDataPrimitives.Single8,
+        IccTestDataPrimitives.Single3,
+        IccTestDataPrimitives.Single6,
+        IccTestDataPrimitives.Single9);
+
+    public static readonly object[][] Matrix2DFloatArrayTestData =
+    [
+        [Fix162DGrad, 3, 3, false, Single2DArrayValGrad],
+        [Fix162DIdentity, 3, 3, false, Single2DArrayValIdentity],
+        [Single2DGrad, 3, 3, true, Single2DArrayValGrad]
+    ];
+
+    public static readonly object[][] Matrix2DDenseMatrixTestData =
+    [
+        [Fix162DGrad, 3, 3, false, SingleDenseMatrixValGrad],
+        [Fix162DIdentity, 3, 3, false, SingleDenseMatrixValIdentity],
+        [Single2DGrad, 3, 3, true, SingleDenseMatrixValGrad]
+    ];
+
+    public static readonly object[][] Matrix2DMatrix4X4TestData =
+    [
+        [Fix162DGrad, 3, 3, false, SingleMatrix4X4ValGrad],
+        [Fix162DIdentity, 3, 3, false, SingleMatrix4X4ValIdentity],
+        [Single2DGrad, 3, 3, true, SingleMatrix4X4ValGrad]
+    ];
 
     /// <summary>
     /// 3x1 Matrix
     /// </summary>
-    public static readonly float[] Single_1DArray_ValGrad = { 1, 4, 7 };
+    public static readonly float[] Single1DArrayValGrad = [1, 4, 7];
 
     /// <summary>
     /// 3x1 Matrix
     /// </summary>
-    public static readonly Vector3 Single_Vector3_ValGrad = new Vector3(1, 4, 7);
+    public static readonly Vector3 SingleVector3ValGrad = new(1, 4, 7);
 
     /// <summary>
     /// 3x1 Matrix
     /// </summary>
-    public static readonly byte[] Fix16_1D_Grad = ArrayHelper.Concat(
-        IccTestDataPrimitives.Fix16_1,
-        IccTestDataPrimitives.Fix16_4,
-        IccTestDataPrimitives.Fix16_7);
+    public static readonly byte[] Fix161DGrad = ArrayHelper.Concat(
+        IccTestDataPrimitives.Fix161,
+        IccTestDataPrimitives.Fix164,
+        IccTestDataPrimitives.Fix167);
 
     /// <summary>
     /// 3x1 Matrix
     /// </summary>
-    public static readonly byte[] Single_1D_Grad = ArrayHelper.Concat(
-        IccTestDataPrimitives.Single_1,
-        IccTestDataPrimitives.Single_4,
-        IccTestDataPrimitives.Single_7);
-
-    public static readonly object[][] Matrix1D_ArrayTestData =
-    {
-        new object[] { Fix16_1D_Grad, 3, false, Single_1DArray_ValGrad },
-        new object[] { Single_1D_Grad, 3, true, Single_1DArray_ValGrad },
-    };
-
-    public static readonly object[][] Matrix1D_Vector3TestData =
-    {
-        new object[] { Fix16_1D_Grad, 3, false, Single_Vector3_ValGrad },
-        new object[] { Single_1D_Grad, 3, true, Single_Vector3_ValGrad },
-    };
+    public static readonly byte[] Single1DGrad = ArrayHelper.Concat(
+        IccTestDataPrimitives.Single1,
+        IccTestDataPrimitives.Single4,
+        IccTestDataPrimitives.Single7);
+
+    public static readonly object[][] Matrix1DArrayTestData =
+    [
+        [Fix161DGrad, 3, false, Single1DArrayValGrad],
+        [Single1DGrad, 3, true, Single1DArrayValGrad]
+    ];
+
+    public static readonly object[][] Matrix1DVector3TestData =
+    [
+        [Fix161DGrad, 3, false, SingleVector3ValGrad],
+        [Single1DGrad, 3, true, SingleVector3ValGrad]
+    ];
 }
diff --git a/tests/ImageSharp.Tests/TestDataIcc/IccTestDataMultiProcessElements.cs b/tests/ImageSharp.Tests/TestDataIcc/IccTestDataMultiProcessElements.cs
index 2c5c432710..5219dfdacd 100644
--- a/tests/ImageSharp.Tests/TestDataIcc/IccTestDataMultiProcessElements.cs
+++ b/tests/ImageSharp.Tests/TestDataIcc/IccTestDataMultiProcessElements.cs
@@ -3,7 +3,7 @@
 
 using SixLabors.ImageSharp.Metadata.Profiles.Icc;
 
-namespace SixLabors.ImageSharp.Tests;
+namespace SixLabors.ImageSharp.Tests.TestDataIcc;
 
 internal static class IccTestDataMultiProcessElements
 {
@@ -11,120 +11,119 @@ internal static class IccTestDataMultiProcessElements
     /// <para>Input Channel Count: 3</para>
     /// <para>Output Channel Count: 3</para>
     /// </summary>
-    public static readonly IccCurveSetProcessElement CurvePE_ValGrad = new IccCurveSetProcessElement(new IccOneDimensionalCurve[]
-    {
-        IccTestDataCurves.OneDimensional_ValFormula1,
-        IccTestDataCurves.OneDimensional_ValFormula2,
-        IccTestDataCurves.OneDimensional_ValFormula1
-    });
+    public static readonly IccCurveSetProcessElement CurvePeValGrad = new([
+        IccTestDataCurves.OneDimensionalValFormula1,
+        IccTestDataCurves.OneDimensionalValFormula2,
+        IccTestDataCurves.OneDimensionalValFormula1
+    ]);
 
     /// <summary>
     /// <para>Input Channel Count: 3</para>
     /// <para>Output Channel Count: 3</para>
     /// </summary>
-    public static readonly byte[] CurvePE_Grad = ArrayHelper.Concat(
-        IccTestDataCurves.OneDimensional_Formula1,
-        IccTestDataCurves.OneDimensional_Formula2,
-        IccTestDataCurves.OneDimensional_Formula1);
+    public static readonly byte[] CurvePeGrad = ArrayHelper.Concat(
+        IccTestDataCurves.OneDimensionalFormula1,
+        IccTestDataCurves.OneDimensionalFormula2,
+        IccTestDataCurves.OneDimensionalFormula1);
 
     public static readonly object[][] CurveSetTestData =
-    {
-        new object[] { CurvePE_Grad, CurvePE_ValGrad, 3, 3 },
-    };
+    [
+        [CurvePeGrad, CurvePeValGrad, 3, 3]
+    ];
 
     /// <summary>
     /// <para>Input Channel Count: 3</para>
     /// <para>Output Channel Count: 3</para>
     /// </summary>
-    public static readonly IccMatrixProcessElement MatrixPE_ValGrad = new IccMatrixProcessElement(
-        IccTestDataMatrix.Single_2DArray_ValGrad,
-        IccTestDataMatrix.Single_1DArray_ValGrad);
+    public static readonly IccMatrixProcessElement MatrixPeValGrad = new(
+        IccTestDataMatrix.Single2DArrayValGrad,
+        IccTestDataMatrix.Single1DArrayValGrad);
 
     /// <summary>
     /// <para>Input Channel Count: 3</para>
     /// <para>Output Channel Count: 3</para>
     /// </summary>
-    public static readonly byte[] MatrixPE_Grad = ArrayHelper.Concat(
-        IccTestDataMatrix.Single_2D_Grad,
-        IccTestDataMatrix.Single_1D_Grad);
+    public static readonly byte[] MatrixPeGrad = ArrayHelper.Concat(
+        IccTestDataMatrix.Single2DGrad,
+        IccTestDataMatrix.Single1DGrad);
 
     public static readonly object[][] MatrixTestData =
-    {
-        new object[] { MatrixPE_Grad, MatrixPE_ValGrad, 3, 3 },
-    };
+    [
+        [MatrixPeGrad, MatrixPeValGrad, 3, 3]
+    ];
 
     /// <summary>
     /// <para>Input Channel Count: 2</para>
     /// <para>Output Channel Count: 3</para>
     /// </summary>
-    public static readonly IccClutProcessElement CLUTPE_ValGrad = new IccClutProcessElement(IccTestDataLut.CLUT_Valf32);
+    public static readonly IccClutProcessElement ClutpeValGrad = new(IccTestDataLut.ClutValf32);
 
     /// <summary>
     /// <para>Input Channel Count: 2</para>
     /// <para>Output Channel Count: 3</para>
     /// </summary>
-    public static readonly byte[] CLUTPE_Grad = IccTestDataLut.CLUT_f32;
+    public static readonly byte[] ClutpeGrad = IccTestDataLut.ClutF32;
 
     public static readonly object[][] ClutTestData =
-    {
-        new object[] { CLUTPE_Grad, CLUTPE_ValGrad, 2, 3 },
-    };
+    [
+        [ClutpeGrad, ClutpeValGrad, 2, 3]
+    ];
 
-    public static readonly IccMultiProcessElement MPE_ValMatrix = MatrixPE_ValGrad;
-    public static readonly IccMultiProcessElement MPE_ValCLUT = CLUTPE_ValGrad;
-    public static readonly IccMultiProcessElement MPE_ValCurve = CurvePE_ValGrad;
-    public static readonly IccMultiProcessElement MPE_ValbACS = new IccBAcsProcessElement(3, 3);
-    public static readonly IccMultiProcessElement MPE_ValeACS = new IccEAcsProcessElement(3, 3);
+    public static readonly IccMultiProcessElement MpeValMatrix = MatrixPeValGrad;
+    public static readonly IccMultiProcessElement MpeValClut = ClutpeValGrad;
+    public static readonly IccMultiProcessElement MpeValCurve = CurvePeValGrad;
+    public static readonly IccMultiProcessElement MpeValbAcs = new IccBAcsProcessElement(3, 3);
+    public static readonly IccMultiProcessElement MpeValeAcs = new IccEAcsProcessElement(3, 3);
 
-    public static readonly byte[] MPE_Matrix = ArrayHelper.Concat(
+    public static readonly byte[] MpeMatrix = ArrayHelper.Concat(
         new byte[]
         {
             0x6D, 0x61, 0x74, 0x66,
             0x00, 0x03,
             0x00, 0x03,
         },
-        MatrixPE_Grad);
+        MatrixPeGrad);
 
-    public static readonly byte[] MPE_CLUT = ArrayHelper.Concat(
+    public static readonly byte[] MpeClut = ArrayHelper.Concat(
         new byte[]
         {
             0x63, 0x6C, 0x75, 0x74,
             0x00, 0x02,
             0x00, 0x03,
         },
-        CLUTPE_Grad);
+        ClutpeGrad);
 
-    public static readonly byte[] MPE_Curve = ArrayHelper.Concat(
+    public static readonly byte[] MpeCurve = ArrayHelper.Concat(
         new byte[]
         {
             0x6D, 0x66, 0x6C, 0x74,
             0x00, 0x03,
             0x00, 0x03,
         },
-        CurvePE_Grad);
+        CurvePeGrad);
 
-    public static readonly byte[] MPE_bACS =
-    {
+    public static readonly byte[] MpeBAcs =
+    [
         0x62, 0x41, 0x43, 0x53,
         0x00, 0x03,
         0x00, 0x03,
-        0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-    };
+        0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00
+    ];
 
-    public static readonly byte[] MPE_eACS =
-    {
+    public static readonly byte[] MpeEAcs =
+    [
         0x65, 0x41, 0x43, 0x53,
         0x00, 0x03,
         0x00, 0x03,
-        0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-    };
+        0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00
+    ];
 
     public static readonly object[][] MultiProcessElementTestData =
-    {
-        new object[] { MPE_Matrix, MPE_ValMatrix },
-        new object[] { MPE_CLUT, MPE_ValCLUT },
-        new object[] { MPE_Curve, MPE_ValCurve },
-        new object[] { MPE_bACS, MPE_ValbACS },
-        new object[] { MPE_eACS, MPE_ValeACS },
-    };
+    [
+        [MpeMatrix, MpeValMatrix],
+        [MpeClut, MpeValClut],
+        [MpeCurve, MpeValCurve],
+        [MpeBAcs, MpeValbAcs],
+        [MpeEAcs, MpeValeAcs]
+    ];
 }
diff --git a/tests/ImageSharp.Tests/TestDataIcc/IccTestDataNonPrimitives.cs b/tests/ImageSharp.Tests/TestDataIcc/IccTestDataNonPrimitives.cs
index c476f2e6c7..34625aa1c5 100644
--- a/tests/ImageSharp.Tests/TestDataIcc/IccTestDataNonPrimitives.cs
+++ b/tests/ImageSharp.Tests/TestDataIcc/IccTestDataNonPrimitives.cs
@@ -5,185 +5,185 @@ using System.Globalization;
 using System.Numerics;
 using SixLabors.ImageSharp.Metadata.Profiles.Icc;
 
-namespace SixLabors.ImageSharp.Tests;
+namespace SixLabors.ImageSharp.Tests.TestDataIcc;
 
 internal static class IccTestDataNonPrimitives
 {
-    public static readonly DateTime DateTime_ValMin = new DateTime(1, 1, 1, 0, 0, 0, DateTimeKind.Utc);
-    public static readonly DateTime DateTime_ValMax = new DateTime(9999, 12, 31, 23, 59, 59, DateTimeKind.Utc);
-    public static readonly DateTime DateTime_ValRand1 = new DateTime(1990, 11, 26, 3, 19, 47, DateTimeKind.Utc);
+    public static readonly DateTime DateTimeValMin = new(1, 1, 1, 0, 0, 0, DateTimeKind.Utc);
+    public static readonly DateTime DateTimeValMax = new(9999, 12, 31, 23, 59, 59, DateTimeKind.Utc);
+    public static readonly DateTime DateTimeValRand1 = new(1990, 11, 26, 3, 19, 47, DateTimeKind.Utc);
 
-    public static readonly byte[] DateTime_Min =
-    {
+    public static readonly byte[] DateTimeMin =
+    [
         0x00, 0x01, // Year      1
         0x00, 0x01, // Month     1
         0x00, 0x01, // Day       1
         0x00, 0x00, // Hour      0
         0x00, 0x00, // Minute    0
-        0x00, 0x00, // Second    0
-    };
+        0x00, 0x00 // Second    0
+    ];
 
-    public static readonly byte[] DateTime_Max =
-    {
-            0x27, 0x0F, // Year      9999
+    public static readonly byte[] DateTimeMax =
+    [
+        0x27, 0x0F, // Year      9999
             0x00, 0x0C, // Month     12
             0x00, 0x1F, // Day       31
             0x00, 0x17, // Hour      23
             0x00, 0x3B, // Minute    59
-            0x00, 0x3B, // Second    59
-    };
+            0x00, 0x3B // Second    59
+    ];
 
-    public static readonly byte[] DateTime_Invalid =
-    {
-            0xFF, 0xFF, // Year      65535
+    public static readonly byte[] DateTimeInvalid =
+    [
+        0xFF, 0xFF, // Year      65535
             0x00, 0x0E, // Month     14
             0x00, 0x21, // Day       33
             0x00, 0x19, // Hour      25
             0x00, 0x3D, // Minute    61
-            0x00, 0x3D, // Second    61
-    };
+            0x00, 0x3D // Second    61
+    ];
 
-    public static readonly byte[] DateTime_Rand1 =
-    {
-            0x07, 0xC6, // Year      1990
+    public static readonly byte[] DateTimeRand1 =
+    [
+        0x07, 0xC6, // Year      1990
             0x00, 0x0B, // Month     11
             0x00, 0x1A, // Day       26
             0x00, 0x03, // Hour      3
             0x00, 0x13, // Minute    19
-            0x00, 0x2F, // Second    47
-    };
+            0x00, 0x2F // Second    47
+    ];
 
     public static readonly object[][] DateTimeTestData =
-    {
-        new object[] { DateTime_Min, DateTime_ValMin },
-        new object[] { DateTime_Max, DateTime_ValMax },
-        new object[] { DateTime_Rand1, DateTime_ValRand1 },
-    };
-
-    public static readonly IccVersion VersionNumber_ValMin = new IccVersion(0, 0, 0);
-    public static readonly IccVersion VersionNumber_Val211 = new IccVersion(2, 1, 1);
-    public static readonly IccVersion VersionNumber_Val430 = new IccVersion(4, 3, 0);
-    public static readonly IccVersion VersionNumber_ValMax = new IccVersion(255, 15, 15);
-
-    public static readonly byte[] VersionNumber_Min = { 0x00, 0x00, 0x00, 0x00 };
-    public static readonly byte[] VersionNumber_211 = { 0x02, 0x11, 0x00, 0x00 };
-    public static readonly byte[] VersionNumber_430 = { 0x04, 0x30, 0x00, 0x00 };
-    public static readonly byte[] VersionNumber_Max = { 0xFF, 0xFF, 0x00, 0x00 };
+    [
+        [DateTimeMin, DateTimeValMin],
+        [DateTimeMax, DateTimeValMax],
+        [DateTimeRand1, DateTimeValRand1]
+    ];
+
+    public static readonly IccVersion VersionNumberValMin = new(0, 0, 0);
+    public static readonly IccVersion VersionNumberVal211 = new(2, 1, 1);
+    public static readonly IccVersion VersionNumberVal430 = new(4, 3, 0);
+    public static readonly IccVersion VersionNumberValMax = new(255, 15, 15);
+
+    public static readonly byte[] VersionNumberMin = [0x00, 0x00, 0x00, 0x00];
+    public static readonly byte[] VersionNumber211 = [0x02, 0x11, 0x00, 0x00];
+    public static readonly byte[] VersionNumber430 = [0x04, 0x30, 0x00, 0x00];
+    public static readonly byte[] VersionNumberMax = [0xFF, 0xFF, 0x00, 0x00];
 
     public static readonly object[][] VersionNumberTestData =
-    {
-        new object[] { VersionNumber_Min, VersionNumber_ValMin },
-        new object[] { VersionNumber_211, VersionNumber_Val211 },
-        new object[] { VersionNumber_430, VersionNumber_Val430 },
-        new object[] { VersionNumber_Max, VersionNumber_ValMax },
-    };
-
-    public static readonly Vector3 XyzNumber_ValMin = new Vector3(IccTestDataPrimitives.Fix16_ValMin, IccTestDataPrimitives.Fix16_ValMin, IccTestDataPrimitives.Fix16_ValMin);
-    public static readonly Vector3 XyzNumber_Val0 = new Vector3(0, 0, 0);
-    public static readonly Vector3 XyzNumber_Val1 = new Vector3(1, 1, 1);
-    public static readonly Vector3 XyzNumber_ValVar1 = new Vector3(1, 2, 3);
-    public static readonly Vector3 XyzNumber_ValVar2 = new Vector3(4, 5, 6);
-    public static readonly Vector3 XyzNumber_ValVar3 = new Vector3(7, 8, 9);
-    public static readonly Vector3 XyzNumber_ValMax = new Vector3(IccTestDataPrimitives.Fix16_ValMax, IccTestDataPrimitives.Fix16_ValMax, IccTestDataPrimitives.Fix16_ValMax);
-
-    public static readonly byte[] XyzNumber_Min = ArrayHelper.Concat(IccTestDataPrimitives.Fix16_Min, IccTestDataPrimitives.Fix16_Min, IccTestDataPrimitives.Fix16_Min);
-    public static readonly byte[] XyzNumber_0 = ArrayHelper.Concat(IccTestDataPrimitives.Fix16_0, IccTestDataPrimitives.Fix16_0, IccTestDataPrimitives.Fix16_0);
-    public static readonly byte[] XyzNumber_1 = ArrayHelper.Concat(IccTestDataPrimitives.Fix16_1, IccTestDataPrimitives.Fix16_1, IccTestDataPrimitives.Fix16_1);
-    public static readonly byte[] XyzNumber_Var1 = ArrayHelper.Concat(IccTestDataPrimitives.Fix16_1, IccTestDataPrimitives.Fix16_2, IccTestDataPrimitives.Fix16_3);
-    public static readonly byte[] XyzNumber_Var2 = ArrayHelper.Concat(IccTestDataPrimitives.Fix16_4, IccTestDataPrimitives.Fix16_5, IccTestDataPrimitives.Fix16_6);
-    public static readonly byte[] XyzNumber_Var3 = ArrayHelper.Concat(IccTestDataPrimitives.Fix16_7, IccTestDataPrimitives.Fix16_8, IccTestDataPrimitives.Fix16_9);
-    public static readonly byte[] XyzNumber_Max = ArrayHelper.Concat(IccTestDataPrimitives.Fix16_Max, IccTestDataPrimitives.Fix16_Max, IccTestDataPrimitives.Fix16_Max);
+    [
+        [VersionNumberMin, VersionNumberValMin],
+        [VersionNumber211, VersionNumberVal211],
+        [VersionNumber430, VersionNumberVal430],
+        [VersionNumberMax, VersionNumberValMax]
+    ];
+
+    public static readonly Vector3 XyzNumberValMin = new(IccTestDataPrimitives.Fix16ValMin, IccTestDataPrimitives.Fix16ValMin, IccTestDataPrimitives.Fix16ValMin);
+    public static readonly Vector3 XyzNumberVal0 = new(0, 0, 0);
+    public static readonly Vector3 XyzNumberVal1 = new(1, 1, 1);
+    public static readonly Vector3 XyzNumberValVar1 = new(1, 2, 3);
+    public static readonly Vector3 XyzNumberValVar2 = new(4, 5, 6);
+    public static readonly Vector3 XyzNumberValVar3 = new(7, 8, 9);
+    public static readonly Vector3 XyzNumberValMax = new(IccTestDataPrimitives.Fix16ValMax, IccTestDataPrimitives.Fix16ValMax, IccTestDataPrimitives.Fix16ValMax);
+
+    public static readonly byte[] XyzNumberMin = ArrayHelper.Concat(IccTestDataPrimitives.Fix16Min, IccTestDataPrimitives.Fix16Min, IccTestDataPrimitives.Fix16Min);
+    public static readonly byte[] XyzNumber0 = ArrayHelper.Concat(IccTestDataPrimitives.Fix160, IccTestDataPrimitives.Fix160, IccTestDataPrimitives.Fix160);
+    public static readonly byte[] XyzNumber1 = ArrayHelper.Concat(IccTestDataPrimitives.Fix161, IccTestDataPrimitives.Fix161, IccTestDataPrimitives.Fix161);
+    public static readonly byte[] XyzNumberVar1 = ArrayHelper.Concat(IccTestDataPrimitives.Fix161, IccTestDataPrimitives.Fix162, IccTestDataPrimitives.Fix163);
+    public static readonly byte[] XyzNumberVar2 = ArrayHelper.Concat(IccTestDataPrimitives.Fix164, IccTestDataPrimitives.Fix165, IccTestDataPrimitives.Fix166);
+    public static readonly byte[] XyzNumberVar3 = ArrayHelper.Concat(IccTestDataPrimitives.Fix167, IccTestDataPrimitives.Fix168, IccTestDataPrimitives.Fix169);
+    public static readonly byte[] XyzNumberMax = ArrayHelper.Concat(IccTestDataPrimitives.Fix16Max, IccTestDataPrimitives.Fix16Max, IccTestDataPrimitives.Fix16Max);
 
     public static readonly object[][] XyzNumberTestData =
-    {
-        new object[] { XyzNumber_Min, XyzNumber_ValMin },
-        new object[] { XyzNumber_0, XyzNumber_Val0 },
-        new object[] { XyzNumber_Var1, XyzNumber_ValVar1 },
-        new object[] { XyzNumber_Max, XyzNumber_ValMax },
-    };
+    [
+        [XyzNumberMin, XyzNumberValMin],
+        [XyzNumber0, XyzNumberVal0],
+        [XyzNumberVar1, XyzNumberValVar1],
+        [XyzNumberMax, XyzNumberValMax]
+    ];
 
-    public static readonly IccProfileId ProfileId_ValMin = new IccProfileId(0, 0, 0, 0);
-    public static readonly IccProfileId ProfileId_ValRand = new IccProfileId(IccTestDataPrimitives.UInt32_ValRand1, IccTestDataPrimitives.UInt32_ValRand2, IccTestDataPrimitives.UInt32_ValRand3, IccTestDataPrimitives.UInt32_ValRand4);
-    public static readonly IccProfileId ProfileId_ValMax = new IccProfileId(uint.MaxValue, uint.MaxValue, uint.MaxValue, uint.MaxValue);
+    public static readonly IccProfileId ProfileIdValMin = new(0, 0, 0, 0);
+    public static readonly IccProfileId ProfileIdValRand = new(IccTestDataPrimitives.UInt32ValRand1, IccTestDataPrimitives.UInt32ValRand2, IccTestDataPrimitives.UInt32ValRand3, IccTestDataPrimitives.UInt32ValRand4);
+    public static readonly IccProfileId ProfileIdValMax = new(uint.MaxValue, uint.MaxValue, uint.MaxValue, uint.MaxValue);
 
-    public static readonly byte[] ProfileId_Min = ArrayHelper.Concat(IccTestDataPrimitives.UInt32_0, IccTestDataPrimitives.UInt32_0, IccTestDataPrimitives.UInt32_0, IccTestDataPrimitives.UInt32_0);
-    public static readonly byte[] ProfileId_Rand = ArrayHelper.Concat(IccTestDataPrimitives.UInt32_Rand1, IccTestDataPrimitives.UInt32_Rand2, IccTestDataPrimitives.UInt32_Rand3, IccTestDataPrimitives.UInt32_Rand4);
-    public static readonly byte[] ProfileId_Max = ArrayHelper.Concat(IccTestDataPrimitives.UInt32_Max, IccTestDataPrimitives.UInt32_Max, IccTestDataPrimitives.UInt32_Max, IccTestDataPrimitives.UInt32_Max);
+    public static readonly byte[] ProfileIdMin = ArrayHelper.Concat(IccTestDataPrimitives.UInt320, IccTestDataPrimitives.UInt320, IccTestDataPrimitives.UInt320, IccTestDataPrimitives.UInt320);
+    public static readonly byte[] ProfileIdRand = ArrayHelper.Concat(IccTestDataPrimitives.UInt32Rand1, IccTestDataPrimitives.UInt32Rand2, IccTestDataPrimitives.UInt32Rand3, IccTestDataPrimitives.UInt32Rand4);
+    public static readonly byte[] ProfileIdMax = ArrayHelper.Concat(IccTestDataPrimitives.UInt32Max, IccTestDataPrimitives.UInt32Max, IccTestDataPrimitives.UInt32Max, IccTestDataPrimitives.UInt32Max);
 
     public static readonly object[][] ProfileIdTestData =
-    {
-        new object[] { ProfileId_Min, ProfileId_ValMin },
-        new object[] { ProfileId_Rand, ProfileId_ValRand },
-        new object[] { ProfileId_Max, ProfileId_ValMax },
-    };
+    [
+        [ProfileIdMin, ProfileIdValMin],
+        [ProfileIdRand, ProfileIdValRand],
+        [ProfileIdMax, ProfileIdValMax]
+    ];
 
-    public static readonly IccPositionNumber PositionNumber_ValMin = new IccPositionNumber(0, 0);
-    public static readonly IccPositionNumber PositionNumber_ValRand = new IccPositionNumber(IccTestDataPrimitives.UInt32_ValRand1, IccTestDataPrimitives.UInt32_ValRand2);
-    public static readonly IccPositionNumber PositionNumber_ValMax = new IccPositionNumber(uint.MaxValue, uint.MaxValue);
+    public static readonly IccPositionNumber PositionNumberValMin = new(0, 0);
+    public static readonly IccPositionNumber PositionNumberValRand = new(IccTestDataPrimitives.UInt32ValRand1, IccTestDataPrimitives.UInt32ValRand2);
+    public static readonly IccPositionNumber PositionNumberValMax = new(uint.MaxValue, uint.MaxValue);
 
-    public static readonly byte[] PositionNumber_Min = ArrayHelper.Concat(IccTestDataPrimitives.UInt32_0, IccTestDataPrimitives.UInt32_0);
-    public static readonly byte[] PositionNumber_Rand = ArrayHelper.Concat(IccTestDataPrimitives.UInt32_Rand1, IccTestDataPrimitives.UInt32_Rand2);
-    public static readonly byte[] PositionNumber_Max = ArrayHelper.Concat(IccTestDataPrimitives.UInt32_Max, IccTestDataPrimitives.UInt32_Max);
+    public static readonly byte[] PositionNumberMin = ArrayHelper.Concat(IccTestDataPrimitives.UInt320, IccTestDataPrimitives.UInt320);
+    public static readonly byte[] PositionNumberRand = ArrayHelper.Concat(IccTestDataPrimitives.UInt32Rand1, IccTestDataPrimitives.UInt32Rand2);
+    public static readonly byte[] PositionNumberMax = ArrayHelper.Concat(IccTestDataPrimitives.UInt32Max, IccTestDataPrimitives.UInt32Max);
 
     public static readonly object[][] PositionNumberTestData =
-    {
-        new object[] { PositionNumber_Min, PositionNumber_ValMin },
-        new object[] { PositionNumber_Rand, PositionNumber_ValRand },
-        new object[] { PositionNumber_Max, PositionNumber_ValMax },
-    };
-
-    public static readonly IccResponseNumber ResponseNumber_ValMin = new IccResponseNumber(0, IccTestDataPrimitives.Fix16_ValMin);
-    public static readonly IccResponseNumber ResponseNumber_Val1 = new IccResponseNumber(1, 1);
-    public static readonly IccResponseNumber ResponseNumber_Val2 = new IccResponseNumber(2, 2);
-    public static readonly IccResponseNumber ResponseNumber_Val3 = new IccResponseNumber(3, 3);
-    public static readonly IccResponseNumber ResponseNumber_Val4 = new IccResponseNumber(4, 4);
-    public static readonly IccResponseNumber ResponseNumber_Val5 = new IccResponseNumber(5, 5);
-    public static readonly IccResponseNumber ResponseNumber_Val6 = new IccResponseNumber(6, 6);
-    public static readonly IccResponseNumber ResponseNumber_Val7 = new IccResponseNumber(7, 7);
-    public static readonly IccResponseNumber ResponseNumber_Val8 = new IccResponseNumber(8, 8);
-    public static readonly IccResponseNumber ResponseNumber_Val9 = new IccResponseNumber(9, 9);
-    public static readonly IccResponseNumber ResponseNumber_ValMax = new IccResponseNumber(ushort.MaxValue, IccTestDataPrimitives.Fix16_ValMax);
-
-    public static readonly byte[] ResponseNumber_Min = ArrayHelper.Concat(IccTestDataPrimitives.UInt16_0, IccTestDataPrimitives.Fix16_Min);
-    public static readonly byte[] ResponseNumber_1 = ArrayHelper.Concat(IccTestDataPrimitives.UInt16_1, IccTestDataPrimitives.Fix16_1);
-    public static readonly byte[] ResponseNumber_2 = ArrayHelper.Concat(IccTestDataPrimitives.UInt16_2, IccTestDataPrimitives.Fix16_2);
-    public static readonly byte[] ResponseNumber_3 = ArrayHelper.Concat(IccTestDataPrimitives.UInt16_3, IccTestDataPrimitives.Fix16_3);
-    public static readonly byte[] ResponseNumber_4 = ArrayHelper.Concat(IccTestDataPrimitives.UInt16_4, IccTestDataPrimitives.Fix16_4);
-    public static readonly byte[] ResponseNumber_5 = ArrayHelper.Concat(IccTestDataPrimitives.UInt16_5, IccTestDataPrimitives.Fix16_5);
-    public static readonly byte[] ResponseNumber_6 = ArrayHelper.Concat(IccTestDataPrimitives.UInt16_6, IccTestDataPrimitives.Fix16_6);
-    public static readonly byte[] ResponseNumber_7 = ArrayHelper.Concat(IccTestDataPrimitives.UInt16_7, IccTestDataPrimitives.Fix16_7);
-    public static readonly byte[] ResponseNumber_8 = ArrayHelper.Concat(IccTestDataPrimitives.UInt16_8, IccTestDataPrimitives.Fix16_8);
-    public static readonly byte[] ResponseNumber_9 = ArrayHelper.Concat(IccTestDataPrimitives.UInt16_9, IccTestDataPrimitives.Fix16_9);
-    public static readonly byte[] ResponseNumber_Max = ArrayHelper.Concat(IccTestDataPrimitives.UInt16_Max, IccTestDataPrimitives.Fix16_Max);
+    [
+        [PositionNumberMin, PositionNumberValMin],
+        [PositionNumberRand, PositionNumberValRand],
+        [PositionNumberMax, PositionNumberValMax]
+    ];
+
+    public static readonly IccResponseNumber ResponseNumberValMin = new(0, IccTestDataPrimitives.Fix16ValMin);
+    public static readonly IccResponseNumber ResponseNumberVal1 = new(1, 1);
+    public static readonly IccResponseNumber ResponseNumberVal2 = new(2, 2);
+    public static readonly IccResponseNumber ResponseNumberVal3 = new(3, 3);
+    public static readonly IccResponseNumber ResponseNumberVal4 = new(4, 4);
+    public static readonly IccResponseNumber ResponseNumberVal5 = new(5, 5);
+    public static readonly IccResponseNumber ResponseNumberVal6 = new(6, 6);
+    public static readonly IccResponseNumber ResponseNumberVal7 = new(7, 7);
+    public static readonly IccResponseNumber ResponseNumberVal8 = new(8, 8);
+    public static readonly IccResponseNumber ResponseNumberVal9 = new(9, 9);
+    public static readonly IccResponseNumber ResponseNumberValMax = new(ushort.MaxValue, IccTestDataPrimitives.Fix16ValMax);
+
+    public static readonly byte[] ResponseNumberMin = ArrayHelper.Concat(IccTestDataPrimitives.UInt160, IccTestDataPrimitives.Fix16Min);
+    public static readonly byte[] ResponseNumber1 = ArrayHelper.Concat(IccTestDataPrimitives.UInt161, IccTestDataPrimitives.Fix161);
+    public static readonly byte[] ResponseNumber2 = ArrayHelper.Concat(IccTestDataPrimitives.UInt162, IccTestDataPrimitives.Fix162);
+    public static readonly byte[] ResponseNumber3 = ArrayHelper.Concat(IccTestDataPrimitives.UInt163, IccTestDataPrimitives.Fix163);
+    public static readonly byte[] ResponseNumber4 = ArrayHelper.Concat(IccTestDataPrimitives.UInt164, IccTestDataPrimitives.Fix164);
+    public static readonly byte[] ResponseNumber5 = ArrayHelper.Concat(IccTestDataPrimitives.UInt165, IccTestDataPrimitives.Fix165);
+    public static readonly byte[] ResponseNumber6 = ArrayHelper.Concat(IccTestDataPrimitives.UInt166, IccTestDataPrimitives.Fix166);
+    public static readonly byte[] ResponseNumber7 = ArrayHelper.Concat(IccTestDataPrimitives.UInt167, IccTestDataPrimitives.Fix167);
+    public static readonly byte[] ResponseNumber8 = ArrayHelper.Concat(IccTestDataPrimitives.UInt168, IccTestDataPrimitives.Fix168);
+    public static readonly byte[] ResponseNumber9 = ArrayHelper.Concat(IccTestDataPrimitives.UInt169, IccTestDataPrimitives.Fix169);
+    public static readonly byte[] ResponseNumberMax = ArrayHelper.Concat(IccTestDataPrimitives.UInt16Max, IccTestDataPrimitives.Fix16Max);
 
     public static readonly object[][] ResponseNumberTestData =
-    {
-        new object[] { ResponseNumber_Min, ResponseNumber_ValMin },
-        new object[] { ResponseNumber_1, ResponseNumber_Val1 },
-        new object[] { ResponseNumber_4, ResponseNumber_Val4 },
-        new object[] { ResponseNumber_Max, ResponseNumber_ValMax },
-    };
-
-    public static readonly IccNamedColor NamedColor_ValMin = new IccNamedColor(
+    [
+        [ResponseNumberMin, ResponseNumberValMin],
+        [ResponseNumber1, ResponseNumberVal1],
+        [ResponseNumber4, ResponseNumberVal4],
+        [ResponseNumberMax, ResponseNumberValMax]
+    ];
+
+    public static readonly IccNamedColor NamedColorValMin = new(
         ArrayHelper.Fill('A', 31),
-        new ushort[] { 0, 0, 0 },
-        new ushort[] { 0, 0, 0 });
+        [0, 0, 0],
+        [0, 0, 0]);
 
-    public static readonly IccNamedColor NamedColor_ValRand = new IccNamedColor(
+    public static readonly IccNamedColor NamedColorValRand = new(
         ArrayHelper.Fill('5', 31),
-        new ushort[] { 10794, 10794, 10794 },
-        new ushort[] { 17219, 17219, 17219, 17219, 17219 });
+        [10794, 10794, 10794],
+        [17219, 17219, 17219, 17219, 17219]);
 
-    public static readonly IccNamedColor NamedColor_ValMax = new IccNamedColor(
+    public static readonly IccNamedColor NamedColorValMax = new(
         ArrayHelper.Fill('4', 31),
-        new ushort[] { ushort.MaxValue, ushort.MaxValue, ushort.MaxValue },
-        new ushort[] { ushort.MaxValue, ushort.MaxValue, ushort.MaxValue, ushort.MaxValue });
+        [ushort.MaxValue, ushort.MaxValue, ushort.MaxValue],
+        [ushort.MaxValue, ushort.MaxValue, ushort.MaxValue, ushort.MaxValue]);
 
-    public static readonly byte[] NamedColor_Min = CreateNamedColor(3, 0x41, 0x00, 0x00);
-    public static readonly byte[] NamedColor_Rand = CreateNamedColor(5, 0x35, 42, 67);
-    public static readonly byte[] NamedColor_Max = CreateNamedColor(4, 0x34, 0xFF, 0xFF);
+    public static readonly byte[] NamedColorMin = CreateNamedColor(3, 0x41, 0x00, 0x00);
+    public static readonly byte[] NamedColorRand = CreateNamedColor(5, 0x35, 42, 67);
+    public static readonly byte[] NamedColorMax = CreateNamedColor(4, 0x34, 0xFF, 0xFF);
 
-    private static byte[] CreateNamedColor(int devCoordCount, byte name, byte pCS, byte device)
+    private static byte[] CreateNamedColor(int devCoordCount, byte name, byte pCs, byte device)
     {
         byte[] data = new byte[32 + 6 + (devCoordCount * 2)];
         for (int i = 0; i < data.Length; i++)
@@ -198,7 +198,7 @@ internal static class IccTestDataNonPrimitives
             }
             else if (i < 32 + 6)
             {
-                data[i] = pCS; // PCS Coordinates
+                data[i] = pCs; // PCS Coordinates
             }
             else
             {
@@ -210,146 +210,146 @@ internal static class IccTestDataNonPrimitives
     }
 
     public static readonly object[][] NamedColorTestData =
-    {
-        new object[] { NamedColor_Min, NamedColor_ValMin, 3u },
-        new object[] { NamedColor_Rand, NamedColor_ValRand, 5u },
-        new object[] { NamedColor_Max, NamedColor_ValMax, 4u },
-    };
-
-    private static readonly CultureInfo CultureEnUs = new CultureInfo("en-US");
-    private static readonly CultureInfo CultureDeAT = new CultureInfo("de-AT");
-
-    private static readonly IccLocalizedString LocalizedString_Rand1 = new IccLocalizedString(CultureEnUs, IccTestDataPrimitives.Unicode_ValRand2);
-    private static readonly IccLocalizedString LocalizedString_Rand2 = new IccLocalizedString(CultureDeAT, IccTestDataPrimitives.Unicode_ValRand3);
-
-    private static readonly IccLocalizedString[] LocalizedString_RandArr1 = new IccLocalizedString[]
-    {
-        LocalizedString_Rand1,
-        LocalizedString_Rand2,
-    };
-
-    private static readonly IccMultiLocalizedUnicodeTagDataEntry MultiLocalizedUnicode_Val = new IccMultiLocalizedUnicodeTagDataEntry(LocalizedString_RandArr1);
-    private static readonly byte[] MultiLocalizedUnicode_Arr = ArrayHelper.Concat(
-        IccTestDataPrimitives.UInt32_2,
+    [
+        [NamedColorMin, NamedColorValMin, 3u],
+        [NamedColorRand, NamedColorValRand, 5u],
+        [NamedColorMax, NamedColorValMax, 4u]
+    ];
+
+    private static readonly CultureInfo CultureEnUs = new("en-US");
+    private static readonly CultureInfo CultureDeAt = new("de-AT");
+
+    private static readonly IccLocalizedString LocalizedStringRand1 = new(CultureEnUs, IccTestDataPrimitives.UnicodeValRand2);
+    private static readonly IccLocalizedString LocalizedStringRand2 = new(CultureDeAt, IccTestDataPrimitives.UnicodeValRand3);
+
+    private static readonly IccLocalizedString[] LocalizedStringRandArr1 =
+    [
+        LocalizedStringRand1,
+        LocalizedStringRand2
+    ];
+
+    private static readonly IccMultiLocalizedUnicodeTagDataEntry MultiLocalizedUnicodeVal = new(LocalizedStringRandArr1);
+    private static readonly byte[] MultiLocalizedUnicodeArr = ArrayHelper.Concat(
+        IccTestDataPrimitives.UInt322,
         new byte[] { 0x00, 0x00, 0x00, 0x0C }, // 12
-        new byte[] { (byte)'e', (byte)'n', (byte)'U', (byte)'S' },
+        [(byte)'e', (byte)'n', (byte)'U', (byte)'S'],
         new byte[] { 0x00, 0x00, 0x00, 0x0C },  // 12
         new byte[] { 0x00, 0x00, 0x00, 0x28 },  // 40
-        new byte[] { (byte)'d', (byte)'e', (byte)'A', (byte)'T' },
+        [(byte)'d', (byte)'e', (byte)'A', (byte)'T'],
         new byte[] { 0x00, 0x00, 0x00, 0x0E },  // 14
         new byte[] { 0x00, 0x00, 0x00, 0x34 },  // 52
-        IccTestDataPrimitives.Unicode_Rand2,
-        IccTestDataPrimitives.Unicode_Rand3);
+        IccTestDataPrimitives.UnicodeRand2,
+        IccTestDataPrimitives.UnicodeRand3);
 
-    public static readonly IccTextDescriptionTagDataEntry TextDescription_Val1 = new IccTextDescriptionTagDataEntry(
-        IccTestDataPrimitives.Ascii_ValRand,
-        IccTestDataPrimitives.Unicode_ValRand1,
+    public static readonly IccTextDescriptionTagDataEntry TextDescriptionVal1 = new(
+        IccTestDataPrimitives.AsciiValRand,
+        IccTestDataPrimitives.UnicodeValRand1,
         ArrayHelper.Fill('A', 66),
         1701729619,
         2);
 
-    public static readonly byte[] TextDescription_Arr1 = ArrayHelper.Concat(
+    public static readonly byte[] TextDescriptionArr1 = ArrayHelper.Concat(
         new byte[] { 0x00, 0x00, 0x00, 0x0B },  // 11
-        IccTestDataPrimitives.Ascii_Rand,
+        IccTestDataPrimitives.AsciiRand,
         new byte[] { 0x00 },                    // Null terminator
-        new byte[] { (byte)'e', (byte)'n', (byte)'U', (byte)'S' },
+        [(byte)'e', (byte)'n', (byte)'U', (byte)'S'],
         new byte[] { 0x00, 0x00, 0x00, 0x07 },  // 7
-        IccTestDataPrimitives.Unicode_Rand2,
+        IccTestDataPrimitives.UnicodeRand2,
         new byte[] { 0x00, 0x00 },              // Null terminator
         new byte[] { 0x00, 0x02, 0x43 },        // 2, 67
         ArrayHelper.Fill((byte)0x41, 66),
         new byte[] { 0x00 }); // Null terminator
 
-    public static readonly IccProfileDescription ProfileDescription_ValRand1 = new IccProfileDescription(
+    public static readonly IccProfileDescription ProfileDescriptionValRand1 = new(
         1,
         2,
         IccDeviceAttribute.ChromaBlackWhite | IccDeviceAttribute.ReflectivityMatte,
         IccProfileTag.ProfileDescription,
-        MultiLocalizedUnicode_Val.Texts,
-        MultiLocalizedUnicode_Val.Texts);
+        MultiLocalizedUnicodeVal.Texts,
+        MultiLocalizedUnicodeVal.Texts);
 
-    public static readonly IccProfileDescription ProfileDescription_ValRand2 = new IccProfileDescription(
+    public static readonly IccProfileDescription ProfileDescriptionValRand2 = new(
         1,
         2,
         IccDeviceAttribute.ChromaBlackWhite | IccDeviceAttribute.ReflectivityMatte,
         IccProfileTag.ProfileDescription,
-        new IccLocalizedString[] { LocalizedString_Rand1 },
-        new IccLocalizedString[] { LocalizedString_Rand1 });
+        [LocalizedStringRand1],
+        [LocalizedStringRand1]);
 
-    public static readonly byte[] ProfileDescription_Rand1 = ArrayHelper.Concat(
-        IccTestDataPrimitives.UInt32_1,
-        IccTestDataPrimitives.UInt32_2,
+    public static readonly byte[] ProfileDescriptionRand1 = ArrayHelper.Concat(
+        IccTestDataPrimitives.UInt321,
+        IccTestDataPrimitives.UInt322,
         new byte[] { 0, 0, 0, 0, 0, 0, 0, 10 },
         new byte[] { 0x64, 0x65, 0x73, 0x63 },
         new byte[] { 0x6D, 0x6C, 0x75, 0x63 },
         new byte[] { 0x00, 0x00, 0x00, 0x00 },
-        MultiLocalizedUnicode_Arr,
+        MultiLocalizedUnicodeArr,
         new byte[] { 0x6D, 0x6C, 0x75, 0x63 },
         new byte[] { 0x00, 0x00, 0x00, 0x00 },
-        MultiLocalizedUnicode_Arr);
+        MultiLocalizedUnicodeArr);
 
-    public static readonly byte[] ProfileDescription_Rand2 = ArrayHelper.Concat(
-        IccTestDataPrimitives.UInt32_1,
-        IccTestDataPrimitives.UInt32_2,
+    public static readonly byte[] ProfileDescriptionRand2 = ArrayHelper.Concat(
+        IccTestDataPrimitives.UInt321,
+        IccTestDataPrimitives.UInt322,
         new byte[] { 0, 0, 0, 0, 0, 0, 0, 10 },
         new byte[] { 0x64, 0x65, 0x73, 0x63 },
         new byte[] { 0x64, 0x65, 0x73, 0x63 },
         new byte[] { 0x00, 0x00, 0x00, 0x00 },
-        TextDescription_Arr1,
+        TextDescriptionArr1,
         new byte[] { 0x64, 0x65, 0x73, 0x63 },
         new byte[] { 0x00, 0x00, 0x00, 0x00 },
-        TextDescription_Arr1);
+        TextDescriptionArr1);
 
     public static readonly object[][] ProfileDescriptionReadTestData =
-    {
-        new object[] { ProfileDescription_Rand1, ProfileDescription_ValRand1 },
-        new object[] { ProfileDescription_Rand2, ProfileDescription_ValRand2 },
-    };
+    [
+        [ProfileDescriptionRand1, ProfileDescriptionValRand1],
+        [ProfileDescriptionRand2, ProfileDescriptionValRand2]
+    ];
 
     public static readonly object[][] ProfileDescriptionWriteTestData =
-    {
-        new object[] { ProfileDescription_Rand1, ProfileDescription_ValRand1 },
-    };
+    [
+        [ProfileDescriptionRand1, ProfileDescriptionValRand1]
+    ];
 
-    public static readonly IccColorantTableEntry ColorantTableEntry_ValRand1 = new IccColorantTableEntry(ArrayHelper.Fill('A', 31), 1, 2, 3);
-    public static readonly IccColorantTableEntry ColorantTableEntry_ValRand2 = new IccColorantTableEntry(ArrayHelper.Fill('4', 31), 4, 5, 6);
+    public static readonly IccColorantTableEntry ColorantTableEntryValRand1 = new(ArrayHelper.Fill('A', 31), 1, 2, 3);
+    public static readonly IccColorantTableEntry ColorantTableEntryValRand2 = new(ArrayHelper.Fill('4', 31), 4, 5, 6);
 
-    public static readonly byte[] ColorantTableEntry_Rand1 = ArrayHelper.Concat(
+    public static readonly byte[] ColorantTableEntryRand1 = ArrayHelper.Concat(
         ArrayHelper.Fill((byte)0x41, 31),
         new byte[1],    // null terminator
-        IccTestDataPrimitives.UInt16_1,
-        IccTestDataPrimitives.UInt16_2,
-        IccTestDataPrimitives.UInt16_3);
+        IccTestDataPrimitives.UInt161,
+        IccTestDataPrimitives.UInt162,
+        IccTestDataPrimitives.UInt163);
 
-    public static readonly byte[] ColorantTableEntry_Rand2 = ArrayHelper.Concat(
+    public static readonly byte[] ColorantTableEntryRand2 = ArrayHelper.Concat(
         ArrayHelper.Fill((byte)0x34, 31),
         new byte[1],    // null terminator
-        IccTestDataPrimitives.UInt16_4,
-        IccTestDataPrimitives.UInt16_5,
-        IccTestDataPrimitives.UInt16_6);
+        IccTestDataPrimitives.UInt164,
+        IccTestDataPrimitives.UInt165,
+        IccTestDataPrimitives.UInt166);
 
     public static readonly object[][] ColorantTableEntryTestData =
-    {
-        new object[] { ColorantTableEntry_Rand1, ColorantTableEntry_ValRand1 },
-        new object[] { ColorantTableEntry_Rand2, ColorantTableEntry_ValRand2 },
-    };
+    [
+        [ColorantTableEntryRand1, ColorantTableEntryValRand1],
+        [ColorantTableEntryRand2, ColorantTableEntryValRand2]
+    ];
 
-    public static readonly IccScreeningChannel ScreeningChannel_ValRand1 = new IccScreeningChannel(4, 6, IccScreeningSpotType.Cross);
-    public static readonly IccScreeningChannel ScreeningChannel_ValRand2 = new IccScreeningChannel(8, 5, IccScreeningSpotType.Diamond);
+    public static readonly IccScreeningChannel ScreeningChannelValRand1 = new(4, 6, IccScreeningSpotType.Cross);
+    public static readonly IccScreeningChannel ScreeningChannelValRand2 = new(8, 5, IccScreeningSpotType.Diamond);
 
-    public static readonly byte[] ScreeningChannel_Rand1 = ArrayHelper.Concat(
-        IccTestDataPrimitives.Fix16_4,
-        IccTestDataPrimitives.Fix16_6,
-        IccTestDataPrimitives.Int32_7);
+    public static readonly byte[] ScreeningChannelRand1 = ArrayHelper.Concat(
+        IccTestDataPrimitives.Fix164,
+        IccTestDataPrimitives.Fix166,
+        IccTestDataPrimitives.Int327);
 
-    public static readonly byte[] ScreeningChannel_Rand2 = ArrayHelper.Concat(
-        IccTestDataPrimitives.Fix16_8,
-        IccTestDataPrimitives.Fix16_5,
-        IccTestDataPrimitives.Int32_3);
+    public static readonly byte[] ScreeningChannelRand2 = ArrayHelper.Concat(
+        IccTestDataPrimitives.Fix168,
+        IccTestDataPrimitives.Fix165,
+        IccTestDataPrimitives.Int323);
 
     public static readonly object[][] ScreeningChannelTestData =
-    {
-        new object[] { ScreeningChannel_Rand1, ScreeningChannel_ValRand1 },
-        new object[] { ScreeningChannel_Rand2, ScreeningChannel_ValRand2 },
-    };
+    [
+        [ScreeningChannelRand1, ScreeningChannelValRand1],
+        [ScreeningChannelRand2, ScreeningChannelValRand2]
+    ];
 }
diff --git a/tests/ImageSharp.Tests/TestDataIcc/IccTestDataPrimitives.cs b/tests/ImageSharp.Tests/TestDataIcc/IccTestDataPrimitives.cs
index f8e8717273..5f9d70fb23 100644
--- a/tests/ImageSharp.Tests/TestDataIcc/IccTestDataPrimitives.cs
+++ b/tests/ImageSharp.Tests/TestDataIcc/IccTestDataPrimitives.cs
@@ -1,243 +1,243 @@
 // Copyright (c) Six Labors.
 // Licensed under the Six Labors Split License.
 
-namespace SixLabors.ImageSharp.Tests;
+namespace SixLabors.ImageSharp.Tests.TestDataIcc;
 
 internal static class IccTestDataPrimitives
 {
-    public static readonly byte[] UInt16_0 = { 0x00, 0x00 };
-    public static readonly byte[] UInt16_1 = { 0x00, 0x01 };
-    public static readonly byte[] UInt16_2 = { 0x00, 0x02 };
-    public static readonly byte[] UInt16_3 = { 0x00, 0x03 };
-    public static readonly byte[] UInt16_4 = { 0x00, 0x04 };
-    public static readonly byte[] UInt16_5 = { 0x00, 0x05 };
-    public static readonly byte[] UInt16_6 = { 0x00, 0x06 };
-    public static readonly byte[] UInt16_7 = { 0x00, 0x07 };
-    public static readonly byte[] UInt16_8 = { 0x00, 0x08 };
-    public static readonly byte[] UInt16_9 = { 0x00, 0x09 };
-    public static readonly byte[] UInt16_32768 = { 0x80, 0x00 };
-    public static readonly byte[] UInt16_Max = { 0xFF, 0xFF };
-
-    public static readonly byte[] Int16_Min = { 0x80, 0x00 };
-    public static readonly byte[] Int16_0 = { 0x00, 0x00 };
-    public static readonly byte[] Int16_1 = { 0x00, 0x01 };
-    public static readonly byte[] Int16_2 = { 0x00, 0x02 };
-    public static readonly byte[] Int16_3 = { 0x00, 0x03 };
-    public static readonly byte[] Int16_4 = { 0x00, 0x04 };
-    public static readonly byte[] Int16_5 = { 0x00, 0x05 };
-    public static readonly byte[] Int16_6 = { 0x00, 0x06 };
-    public static readonly byte[] Int16_7 = { 0x00, 0x07 };
-    public static readonly byte[] Int16_8 = { 0x00, 0x08 };
-    public static readonly byte[] Int16_9 = { 0x00, 0x09 };
-    public static readonly byte[] Int16_Max = { 0x7F, 0xFF };
-
-    public static readonly byte[] UInt32_0 = { 0x00, 0x00, 0x00, 0x00 };
-    public static readonly byte[] UInt32_1 = { 0x00, 0x00, 0x00, 0x01 };
-    public static readonly byte[] UInt32_2 = { 0x00, 0x00, 0x00, 0x02 };
-    public static readonly byte[] UInt32_3 = { 0x00, 0x00, 0x00, 0x03 };
-    public static readonly byte[] UInt32_4 = { 0x00, 0x00, 0x00, 0x04 };
-    public static readonly byte[] UInt32_5 = { 0x00, 0x00, 0x00, 0x05 };
-    public static readonly byte[] UInt32_6 = { 0x00, 0x00, 0x00, 0x06 };
-    public static readonly byte[] UInt32_7 = { 0x00, 0x00, 0x00, 0x07 };
-    public static readonly byte[] UInt32_8 = { 0x00, 0x00, 0x00, 0x08 };
-    public static readonly byte[] UInt32_9 = { 0x00, 0x00, 0x00, 0x09 };
-    public static readonly byte[] UInt32_Max = { 0xFF, 0xFF, 0xFF, 0xFF };
-
-    public static readonly uint UInt32_ValRand1 = 1749014123;
-    public static readonly uint UInt32_ValRand2 = 3870560989;
-    public static readonly uint UInt32_ValRand3 = 1050090334;
-    public static readonly uint UInt32_ValRand4 = 3550252874;
-
-    public static readonly byte[] UInt32_Rand1 = { 0x68, 0x3F, 0xD6, 0x6B };
-    public static readonly byte[] UInt32_Rand2 = { 0xE6, 0xB4, 0x12, 0xDD };
-    public static readonly byte[] UInt32_Rand3 = { 0x3E, 0x97, 0x1B, 0x5E };
-    public static readonly byte[] UInt32_Rand4 = { 0xD3, 0x9C, 0x8F, 0x4A };
-
-    public static readonly byte[] Int32_Min = { 0x80, 0x00, 0x00, 0x00 };
-    public static readonly byte[] Int32_0 = { 0x00, 0x00, 0x00, 0x00 };
-    public static readonly byte[] Int32_1 = { 0x00, 0x00, 0x00, 0x01 };
-    public static readonly byte[] Int32_2 = { 0x00, 0x00, 0x00, 0x02 };
-    public static readonly byte[] Int32_3 = { 0x00, 0x00, 0x00, 0x03 };
-    public static readonly byte[] Int32_4 = { 0x00, 0x00, 0x00, 0x04 };
-    public static readonly byte[] Int32_5 = { 0x00, 0x00, 0x00, 0x05 };
-    public static readonly byte[] Int32_6 = { 0x00, 0x00, 0x00, 0x06 };
-    public static readonly byte[] Int32_7 = { 0x00, 0x00, 0x00, 0x07 };
-    public static readonly byte[] Int32_8 = { 0x00, 0x00, 0x00, 0x08 };
-    public static readonly byte[] Int32_9 = { 0x00, 0x00, 0x00, 0x09 };
-    public static readonly byte[] Int32_Max = { 0x7F, 0xFF, 0xFF, 0xFF };
-
-    public static readonly byte[] UInt64_0 = { 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 };
-    public static readonly byte[] UInt64_1 = { 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01 };
-    public static readonly byte[] UInt64_2 = { 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02 };
-    public static readonly byte[] UInt64_3 = { 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x03 };
-    public static readonly byte[] UInt64_4 = { 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x04 };
-    public static readonly byte[] UInt64_5 = { 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x05 };
-    public static readonly byte[] UInt64_6 = { 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x06 };
-    public static readonly byte[] UInt64_7 = { 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x07 };
-    public static readonly byte[] UInt64_8 = { 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08 };
-    public static readonly byte[] UInt64_9 = { 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x09 };
-    public static readonly byte[] UInt64_Max = { 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF };
-
-    public static readonly byte[] Int64_Min = { 0x80, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 };
-    public static readonly byte[] Int64_0 = { 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 };
-    public static readonly byte[] Int64_1 = { 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01 };
-    public static readonly byte[] Int64_2 = { 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02 };
-    public static readonly byte[] Int64_3 = { 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x03 };
-    public static readonly byte[] Int64_4 = { 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x04 };
-    public static readonly byte[] Int64_5 = { 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x05 };
-    public static readonly byte[] Int64_6 = { 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x06 };
-    public static readonly byte[] Int64_7 = { 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x07 };
-    public static readonly byte[] Int64_8 = { 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08 };
-    public static readonly byte[] Int64_9 = { 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x09 };
-    public static readonly byte[] Int64_Max = { 0x7F, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF };
-
-    public static readonly byte[] Single_Min = { 0xFF, 0x7F, 0xFF, 0xFF };
-    public static readonly byte[] Single_0 = { 0x00, 0x00, 0x00, 0x00 };
-    public static readonly byte[] Single_1 = { 0x3F, 0x80, 0x00, 0x00 };
-    public static readonly byte[] Single_2 = { 0x40, 0x00, 0x00, 0x00 };
-    public static readonly byte[] Single_3 = { 0x40, 0x40, 0x00, 0x00 };
-    public static readonly byte[] Single_4 = { 0x40, 0x80, 0x00, 0x00 };
-    public static readonly byte[] Single_5 = { 0x40, 0xA0, 0x00, 0x00 };
-    public static readonly byte[] Single_6 = { 0x40, 0xC0, 0x00, 0x00 };
-    public static readonly byte[] Single_7 = { 0x40, 0xE0, 0x00, 0x00 };
-    public static readonly byte[] Single_8 = { 0x41, 0x00, 0x00, 0x00 };
-    public static readonly byte[] Single_9 = { 0x41, 0x10, 0x00, 0x00 };
-    public static readonly byte[] Single_Max = { 0x7F, 0x7F, 0xFF, 0xFF };
-
-    public static readonly byte[] Double_Min = { 0xFF, 0xEF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF };
-    public static readonly byte[] Double_0 = { 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 };
-    public static readonly byte[] Double_1 = { 0x3F, 0xF0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 };
-    public static readonly byte[] Double_Max = { 0x7F, 0xEF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF };
-
-    public const float Fix16_ValMin = short.MinValue;
-    public const float Fix16_ValMax = short.MaxValue + (65535f / 65536f);
-
-    public static readonly byte[] Fix16_Min = { 0x80, 0x00, 0x00, 0x00 };
-    public static readonly byte[] Fix16_0 = { 0x00, 0x00, 0x00, 0x00 };
-    public static readonly byte[] Fix16_1 = { 0x00, 0x01, 0x00, 0x00 };
-    public static readonly byte[] Fix16_2 = { 0x00, 0x02, 0x00, 0x00 };
-    public static readonly byte[] Fix16_3 = { 0x00, 0x03, 0x00, 0x00 };
-    public static readonly byte[] Fix16_4 = { 0x00, 0x04, 0x00, 0x00 };
-    public static readonly byte[] Fix16_5 = { 0x00, 0x05, 0x00, 0x00 };
-    public static readonly byte[] Fix16_6 = { 0x00, 0x06, 0x00, 0x00 };
-    public static readonly byte[] Fix16_7 = { 0x00, 0x07, 0x00, 0x00 };
-    public static readonly byte[] Fix16_8 = { 0x00, 0x08, 0x00, 0x00 };
-    public static readonly byte[] Fix16_9 = { 0x00, 0x09, 0x00, 0x00 };
-    public static readonly byte[] Fix16_Max = { 0x7F, 0xFF, 0xFF, 0xFF };
+    public static readonly byte[] UInt160 = [0x00, 0x00];
+    public static readonly byte[] UInt161 = [0x00, 0x01];
+    public static readonly byte[] UInt162 = [0x00, 0x02];
+    public static readonly byte[] UInt163 = [0x00, 0x03];
+    public static readonly byte[] UInt164 = [0x00, 0x04];
+    public static readonly byte[] UInt165 = [0x00, 0x05];
+    public static readonly byte[] UInt166 = [0x00, 0x06];
+    public static readonly byte[] UInt167 = [0x00, 0x07];
+    public static readonly byte[] UInt168 = [0x00, 0x08];
+    public static readonly byte[] UInt169 = [0x00, 0x09];
+    public static readonly byte[] UInt1632768 = [0x80, 0x00];
+    public static readonly byte[] UInt16Max = [0xFF, 0xFF];
+
+    public static readonly byte[] Int16Min = [0x80, 0x00];
+    public static readonly byte[] Int160 = [0x00, 0x00];
+    public static readonly byte[] Int161 = [0x00, 0x01];
+    public static readonly byte[] Int162 = [0x00, 0x02];
+    public static readonly byte[] Int163 = [0x00, 0x03];
+    public static readonly byte[] Int164 = [0x00, 0x04];
+    public static readonly byte[] Int165 = [0x00, 0x05];
+    public static readonly byte[] Int166 = [0x00, 0x06];
+    public static readonly byte[] Int167 = [0x00, 0x07];
+    public static readonly byte[] Int168 = [0x00, 0x08];
+    public static readonly byte[] Int169 = [0x00, 0x09];
+    public static readonly byte[] Int16Max = [0x7F, 0xFF];
+
+    public static readonly byte[] UInt320 = [0x00, 0x00, 0x00, 0x00];
+    public static readonly byte[] UInt321 = [0x00, 0x00, 0x00, 0x01];
+    public static readonly byte[] UInt322 = [0x00, 0x00, 0x00, 0x02];
+    public static readonly byte[] UInt323 = [0x00, 0x00, 0x00, 0x03];
+    public static readonly byte[] UInt324 = [0x00, 0x00, 0x00, 0x04];
+    public static readonly byte[] UInt325 = [0x00, 0x00, 0x00, 0x05];
+    public static readonly byte[] UInt326 = [0x00, 0x00, 0x00, 0x06];
+    public static readonly byte[] UInt327 = [0x00, 0x00, 0x00, 0x07];
+    public static readonly byte[] UInt328 = [0x00, 0x00, 0x00, 0x08];
+    public static readonly byte[] UInt329 = [0x00, 0x00, 0x00, 0x09];
+    public static readonly byte[] UInt32Max = [0xFF, 0xFF, 0xFF, 0xFF];
+
+    public static readonly uint UInt32ValRand1 = 1749014123;
+    public static readonly uint UInt32ValRand2 = 3870560989;
+    public static readonly uint UInt32ValRand3 = 1050090334;
+    public static readonly uint UInt32ValRand4 = 3550252874;
+
+    public static readonly byte[] UInt32Rand1 = [0x68, 0x3F, 0xD6, 0x6B];
+    public static readonly byte[] UInt32Rand2 = [0xE6, 0xB4, 0x12, 0xDD];
+    public static readonly byte[] UInt32Rand3 = [0x3E, 0x97, 0x1B, 0x5E];
+    public static readonly byte[] UInt32Rand4 = [0xD3, 0x9C, 0x8F, 0x4A];
+
+    public static readonly byte[] Int32Min = [0x80, 0x00, 0x00, 0x00];
+    public static readonly byte[] Int320 = [0x00, 0x00, 0x00, 0x00];
+    public static readonly byte[] Int321 = [0x00, 0x00, 0x00, 0x01];
+    public static readonly byte[] Int322 = [0x00, 0x00, 0x00, 0x02];
+    public static readonly byte[] Int323 = [0x00, 0x00, 0x00, 0x03];
+    public static readonly byte[] Int324 = [0x00, 0x00, 0x00, 0x04];
+    public static readonly byte[] Int325 = [0x00, 0x00, 0x00, 0x05];
+    public static readonly byte[] Int326 = [0x00, 0x00, 0x00, 0x06];
+    public static readonly byte[] Int327 = [0x00, 0x00, 0x00, 0x07];
+    public static readonly byte[] Int328 = [0x00, 0x00, 0x00, 0x08];
+    public static readonly byte[] Int329 = [0x00, 0x00, 0x00, 0x09];
+    public static readonly byte[] Int32Max = [0x7F, 0xFF, 0xFF, 0xFF];
+
+    public static readonly byte[] UInt640 = [0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00];
+    public static readonly byte[] UInt641 = [0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01];
+    public static readonly byte[] UInt642 = [0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02];
+    public static readonly byte[] UInt643 = [0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x03];
+    public static readonly byte[] UInt644 = [0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x04];
+    public static readonly byte[] UInt645 = [0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x05];
+    public static readonly byte[] UInt646 = [0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x06];
+    public static readonly byte[] UInt647 = [0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x07];
+    public static readonly byte[] UInt648 = [0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08];
+    public static readonly byte[] UInt649 = [0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x09];
+    public static readonly byte[] UInt64Max = [0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF];
+
+    public static readonly byte[] Int64Min = [0x80, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00];
+    public static readonly byte[] Int640 = [0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00];
+    public static readonly byte[] Int641 = [0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01];
+    public static readonly byte[] Int642 = [0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02];
+    public static readonly byte[] Int643 = [0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x03];
+    public static readonly byte[] Int644 = [0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x04];
+    public static readonly byte[] Int645 = [0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x05];
+    public static readonly byte[] Int646 = [0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x06];
+    public static readonly byte[] Int647 = [0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x07];
+    public static readonly byte[] Int648 = [0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08];
+    public static readonly byte[] Int649 = [0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x09];
+    public static readonly byte[] Int64Max = [0x7F, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF];
+
+    public static readonly byte[] SingleMin = [0xFF, 0x7F, 0xFF, 0xFF];
+    public static readonly byte[] Single0 = [0x00, 0x00, 0x00, 0x00];
+    public static readonly byte[] Single1 = [0x3F, 0x80, 0x00, 0x00];
+    public static readonly byte[] Single2 = [0x40, 0x00, 0x00, 0x00];
+    public static readonly byte[] Single3 = [0x40, 0x40, 0x00, 0x00];
+    public static readonly byte[] Single4 = [0x40, 0x80, 0x00, 0x00];
+    public static readonly byte[] Single5 = [0x40, 0xA0, 0x00, 0x00];
+    public static readonly byte[] Single6 = [0x40, 0xC0, 0x00, 0x00];
+    public static readonly byte[] Single7 = [0x40, 0xE0, 0x00, 0x00];
+    public static readonly byte[] Single8 = [0x41, 0x00, 0x00, 0x00];
+    public static readonly byte[] Single9 = [0x41, 0x10, 0x00, 0x00];
+    public static readonly byte[] SingleMax = [0x7F, 0x7F, 0xFF, 0xFF];
+
+    public static readonly byte[] DoubleMin = [0xFF, 0xEF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF];
+    public static readonly byte[] Double0 = [0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00];
+    public static readonly byte[] Double1 = [0x3F, 0xF0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00];
+    public static readonly byte[] DoubleMax = [0x7F, 0xEF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF];
+
+    public const float Fix16ValMin = short.MinValue;
+    public const float Fix16ValMax = short.MaxValue + (65535f / 65536f);
+
+    public static readonly byte[] Fix16Min = [0x80, 0x00, 0x00, 0x00];
+    public static readonly byte[] Fix160 = [0x00, 0x00, 0x00, 0x00];
+    public static readonly byte[] Fix161 = [0x00, 0x01, 0x00, 0x00];
+    public static readonly byte[] Fix162 = [0x00, 0x02, 0x00, 0x00];
+    public static readonly byte[] Fix163 = [0x00, 0x03, 0x00, 0x00];
+    public static readonly byte[] Fix164 = [0x00, 0x04, 0x00, 0x00];
+    public static readonly byte[] Fix165 = [0x00, 0x05, 0x00, 0x00];
+    public static readonly byte[] Fix166 = [0x00, 0x06, 0x00, 0x00];
+    public static readonly byte[] Fix167 = [0x00, 0x07, 0x00, 0x00];
+    public static readonly byte[] Fix168 = [0x00, 0x08, 0x00, 0x00];
+    public static readonly byte[] Fix169 = [0x00, 0x09, 0x00, 0x00];
+    public static readonly byte[] Fix16Max = [0x7F, 0xFF, 0xFF, 0xFF];
 
     public static readonly object[][] Fix16TestData =
-    {
-        new object[] { Fix16_Min, Fix16_ValMin },
-        new object[] { Fix16_0, 0 },
-        new object[] { Fix16_4, 4 },
-        new object[] { Fix16_Max, Fix16_ValMax },
-    };
-
-    public const float UFix16_ValMin = 0;
-    public const float UFix16_ValMax = ushort.MaxValue + (65535f / 65536f);
-
-    public static readonly byte[] UFix16_0 = { 0x00, 0x00, 0x00, 0x00 };
-    public static readonly byte[] UFix16_1 = { 0x00, 0x01, 0x00, 0x00 };
-    public static readonly byte[] UFix16_2 = { 0x00, 0x02, 0x00, 0x00 };
-    public static readonly byte[] UFix16_3 = { 0x00, 0x03, 0x00, 0x00 };
-    public static readonly byte[] UFix16_4 = { 0x00, 0x04, 0x00, 0x00 };
-    public static readonly byte[] UFix16_5 = { 0x00, 0x05, 0x00, 0x00 };
-    public static readonly byte[] UFix16_6 = { 0x00, 0x06, 0x00, 0x00 };
-    public static readonly byte[] UFix16_7 = { 0x00, 0x07, 0x00, 0x00 };
-    public static readonly byte[] UFix16_8 = { 0x00, 0x08, 0x00, 0x00 };
-    public static readonly byte[] UFix16_9 = { 0x00, 0x09, 0x00, 0x00 };
-    public static readonly byte[] UFix16_Max = { 0xFF, 0xFF, 0xFF, 0xFF };
+    [
+        [Fix16Min, Fix16ValMin],
+        [Fix160, 0],
+        [Fix164, 4],
+        [Fix16Max, Fix16ValMax]
+    ];
+
+    public const float UFix16ValMin = 0;
+    public const float UFix16ValMax = ushort.MaxValue + (65535f / 65536f);
+
+    public static readonly byte[] UFix160 = [0x00, 0x00, 0x00, 0x00];
+    public static readonly byte[] UFix161 = [0x00, 0x01, 0x00, 0x00];
+    public static readonly byte[] UFix162 = [0x00, 0x02, 0x00, 0x00];
+    public static readonly byte[] UFix163 = [0x00, 0x03, 0x00, 0x00];
+    public static readonly byte[] UFix164 = [0x00, 0x04, 0x00, 0x00];
+    public static readonly byte[] UFix165 = [0x00, 0x05, 0x00, 0x00];
+    public static readonly byte[] UFix166 = [0x00, 0x06, 0x00, 0x00];
+    public static readonly byte[] UFix167 = [0x00, 0x07, 0x00, 0x00];
+    public static readonly byte[] UFix168 = [0x00, 0x08, 0x00, 0x00];
+    public static readonly byte[] UFix169 = [0x00, 0x09, 0x00, 0x00];
+    public static readonly byte[] UFix16Max = [0xFF, 0xFF, 0xFF, 0xFF];
 
     public static readonly object[][] UFix16TestData =
-    {
-        new object[] { UFix16_0, 0 },
-        new object[] { UFix16_4, 4 },
-        new object[] { UFix16_Max, UFix16_ValMax },
-    };
+    [
+        [UFix160, 0],
+        [UFix164, 4],
+        [UFix16Max, UFix16ValMax]
+    ];
 
-    public const float U1Fix15_ValMin = 0;
-    public const float U1Fix15_ValMax = 1f + (32767f / 32768f);
+    public const float U1Fix15ValMin = 0;
+    public const float U1Fix15ValMax = 1f + (32767f / 32768f);
 
-    public static readonly byte[] U1Fix15_0 = { 0x00, 0x00 };
-    public static readonly byte[] U1Fix15_1 = { 0x80, 0x00 };
-    public static readonly byte[] U1Fix15_Max = { 0xFF, 0xFF };
+    public static readonly byte[] U1Fix150 = [0x00, 0x00];
+    public static readonly byte[] U1Fix151 = [0x80, 0x00];
+    public static readonly byte[] U1Fix15Max = [0xFF, 0xFF];
 
     public static readonly object[][] U1Fix15TestData =
-    {
-        new object[] { U1Fix15_0, 0 },
-        new object[] { U1Fix15_1, 1 },
-        new object[] { U1Fix15_Max, U1Fix15_ValMax },
-    };
-
-    public const float UFix8_ValMin = 0;
-    public const float UFix8_ValMax = byte.MaxValue + (255f / 256f);
-
-    public static readonly byte[] UFix8_0 = { 0x00, 0x00 };
-    public static readonly byte[] UFix8_1 = { 0x01, 0x00 };
-    public static readonly byte[] UFix8_2 = { 0x02, 0x00 };
-    public static readonly byte[] UFix8_3 = { 0x03, 0x00 };
-    public static readonly byte[] UFix8_4 = { 0x04, 0x00 };
-    public static readonly byte[] UFix8_5 = { 0x05, 0x00 };
-    public static readonly byte[] UFix8_6 = { 0x06, 0x00 };
-    public static readonly byte[] UFix8_7 = { 0x07, 0x00 };
-    public static readonly byte[] UFix8_8 = { 0x08, 0x00 };
-    public static readonly byte[] UFix8_9 = { 0x09, 0x00 };
-    public static readonly byte[] UFix8_Max = { 0xFF, 0xFF };
+    [
+        [U1Fix150, 0],
+        [U1Fix151, 1],
+        [U1Fix15Max, U1Fix15ValMax]
+    ];
+
+    public const float UFix8ValMin = 0;
+    public const float UFix8ValMax = byte.MaxValue + (255f / 256f);
+
+    public static readonly byte[] UFix80 = [0x00, 0x00];
+    public static readonly byte[] UFix81 = [0x01, 0x00];
+    public static readonly byte[] UFix82 = [0x02, 0x00];
+    public static readonly byte[] UFix83 = [0x03, 0x00];
+    public static readonly byte[] UFix84 = [0x04, 0x00];
+    public static readonly byte[] UFix85 = [0x05, 0x00];
+    public static readonly byte[] UFix86 = [0x06, 0x00];
+    public static readonly byte[] UFix87 = [0x07, 0x00];
+    public static readonly byte[] UFix88 = [0x08, 0x00];
+    public static readonly byte[] UFix89 = [0x09, 0x00];
+    public static readonly byte[] UFix8Max = [0xFF, 0xFF];
 
     public static readonly object[][] UFix8TestData =
-    {
-        new object[] { UFix8_0, 0 },
-        new object[] { UFix8_4, 4 },
-        new object[] { UFix8_Max, UFix8_ValMax },
-    };
-
-    public const string Ascii_ValRand = "aBcdEf1234";
-    public const string Ascii_ValRand1 = "Ecf3a";
-    public const string Ascii_ValRand2 = "2Bd4c";
-    public const string Ascii_ValRand3 = "cad14";
-    public const string Ascii_ValRand4 = "fd4E1";
-    public const string Ascii_ValRandLength4 = "aBcd";
-    public const string Ascii_ValNullRand = "aBcd\0Ef\0123";
-
-    public static readonly byte[] Ascii_Rand = { 97, 66, 99, 100, 69, 102, 49, 50, 51, 52 };
-    public static readonly byte[] Ascii_Rand1 = { 69, 99, 102, 51, 97 };
-    public static readonly byte[] Ascii_Rand2 = { 50, 66, 100, 52, 99 };
-    public static readonly byte[] Ascii_Rand3 = { 99, 97, 100, 49, 52 };
-    public static readonly byte[] Ascii_Rand4 = { 102, 100, 52, 69, 49 };
-    public static readonly byte[] Ascii_RandLength4 = { 97, 66, 99, 100 };
-    public static readonly byte[] Ascii_PaddedRand = { 97, 66, 99, 100, 69, 102, 49, 50, 51, 52, 0, 0, 0, 0 };
-    public static readonly byte[] Ascii_NullRand = { 97, 66, 99, 100, 0, 69, 102, 0, 49, 50, 51 };
-
-    public const int Ascii_Rand_Length = 10;
-    public const int Ascii_PaddedRand_Length = 14;
-    public const int Ascii_NullRand_Length = 11;
-    public const int Ascii_NullRand_LengthNoNull = 4;
+    [
+        [UFix80, 0],
+        [UFix84, 4],
+        [UFix8Max, UFix8ValMax]
+    ];
+
+    public const string AsciiValRand = "aBcdEf1234";
+    public const string AsciiValRand1 = "Ecf3a";
+    public const string AsciiValRand2 = "2Bd4c";
+    public const string AsciiValRand3 = "cad14";
+    public const string AsciiValRand4 = "fd4E1";
+    public const string AsciiValRandLength4 = "aBcd";
+    public const string AsciiValNullRand = "aBcd\0Ef\0123";
+
+    public static readonly byte[] AsciiRand = [97, 66, 99, 100, 69, 102, 49, 50, 51, 52];
+    public static readonly byte[] AsciiRand1 = [69, 99, 102, 51, 97];
+    public static readonly byte[] AsciiRand2 = [50, 66, 100, 52, 99];
+    public static readonly byte[] AsciiRand3 = [99, 97, 100, 49, 52];
+    public static readonly byte[] AsciiRand4 = [102, 100, 52, 69, 49];
+    public static readonly byte[] AsciiRandLength4 = [97, 66, 99, 100];
+    public static readonly byte[] AsciiPaddedRand = [97, 66, 99, 100, 69, 102, 49, 50, 51, 52, 0, 0, 0, 0];
+    public static readonly byte[] AsciiNullRand = [97, 66, 99, 100, 0, 69, 102, 0, 49, 50, 51];
+
+    public const int AsciiRandLength = 10;
+    public const int AsciiPaddedRandLength = 14;
+    public const int AsciiNullRandLength = 11;
+    public const int AsciiNullRandLengthNoNull = 4;
 
     public static readonly object[][] AsciiTestData =
-    {
-        new object[] { Ascii_Rand, Ascii_Rand_Length, Ascii_ValRand },
-        new object[] { Ascii_Rand, 4, Ascii_ValRandLength4 },
-        new object[] { Ascii_NullRand, Ascii_NullRand_LengthNoNull, Ascii_ValRandLength4 },
-    };
+    [
+        [AsciiRand, AsciiRandLength, AsciiValRand],
+        [AsciiRand, 4, AsciiValRandLength4],
+        [AsciiNullRand, AsciiNullRandLengthNoNull, AsciiValRandLength4]
+    ];
 
     public static readonly object[][] AsciiWriteTestData =
-    {
-        new object[] { Ascii_Rand, Ascii_ValRand },
-        new object[] { Ascii_NullRand, Ascii_ValNullRand },
-    };
+    [
+        [AsciiRand, AsciiValRand],
+        [AsciiNullRand, AsciiValNullRand]
+    ];
 
     public static readonly object[][] AsciiPaddingTestData =
-    {
-        new object[] { Ascii_PaddedRand, Ascii_PaddedRand_Length, Ascii_ValRand, true },
-        new object[] { Ascii_RandLength4, 4, Ascii_ValRand, false },
-    };
+    [
+        [AsciiPaddedRand, AsciiPaddedRandLength, AsciiValRand, true],
+        [AsciiRandLength4, 4, AsciiValRand, false]
+    ];
 
-    public const string Unicode_ValRand1 = ".6Abäñ$€β�𤭢";
-    public const string Unicode_ValRand2 = ".6Abäñ";
-    public const string Unicode_ValRand3 = "$€β�𤭢";
+    public const string UnicodeValRand1 = ".6Abäñ$€β�𤭢";
+    public const string UnicodeValRand2 = ".6Abäñ";
+    public const string UnicodeValRand3 = "$€β�𤭢";
 
-    public static readonly byte[] Unicode_Rand1 =
-    {
+    public static readonly byte[] UnicodeRand1 =
+    [
         0x00, 0x2e, // .
         0x00, 0x36, // 6
         0x00, 0x41, // A
@@ -248,25 +248,25 @@ internal static class IccTestDataPrimitives
         0x20, 0xAC, // €
         0x03, 0xb2, // β
         0xD8, 0x01, 0xDC, 0x37, // �
-        0xD8, 0x52, 0xDF, 0x62, // 𤭢
-    };
+        0xD8, 0x52, 0xDF, 0x62 // 𤭢
+    ];
 
-    public static readonly byte[] Unicode_Rand2 =
-    {
+    public static readonly byte[] UnicodeRand2 =
+    [
         0x00, 0x2e, // .
         0x00, 0x36, // 6
         0x00, 0x41, // A
         0x00, 0x62, // b
         0x00, 0xe4, // ä
-        0x00, 0xf1, // ñ
-    };
+        0x00, 0xf1 // ñ
+    ];
 
-    public static readonly byte[] Unicode_Rand3 =
-    {
+    public static readonly byte[] UnicodeRand3 =
+    [
         0x00, 0x24, // $
         0x20, 0xAC, // €
         0x03, 0xb2, // β
         0xD8, 0x01, 0xDC, 0x37, // �
-        0xD8, 0x52, 0xDF, 0x62, // 𤭢
-    };
+        0xD8, 0x52, 0xDF, 0x62 // 𤭢
+    ];
 }
diff --git a/tests/ImageSharp.Tests/TestDataIcc/IccTestDataProfiles.cs b/tests/ImageSharp.Tests/TestDataIcc/IccTestDataProfiles.cs
index 8fd6f7e4ae..6e097a0bea 100644
--- a/tests/ImageSharp.Tests/TestDataIcc/IccTestDataProfiles.cs
+++ b/tests/ImageSharp.Tests/TestDataIcc/IccTestDataProfiles.cs
@@ -4,59 +4,54 @@
 using System.Numerics;
 using SixLabors.ImageSharp.Metadata.Profiles.Icc;
 
-namespace SixLabors.ImageSharp.Tests;
+namespace SixLabors.ImageSharp.Tests.TestDataIcc;
 
 internal static class IccTestDataProfiles
 {
-    public static readonly IccProfileId Header_Random_Id_Value = new IccProfileId(0x84A8D460, 0xC716B6F3, 0x9B0E4C3D, 0xAB95F838);
-    public static readonly IccProfileId Profile_Random_Id_Value = new IccProfileId(0x917D6DE6, 0x84C958D1, 0x3BB0F5BB, 0xADD1134F);
+    public static readonly IccProfileId HeaderRandomIdValue = new(0x84A8D460, 0xC716B6F3, 0x9B0E4C3D, 0xAB95F838);
+    public static readonly IccProfileId ProfileRandomIdValue = new(0x917D6DE6, 0x84C958D1, 0x3BB0F5BB, 0xADD1134F);
 
-    public static readonly byte[] Header_Random_Id_Array =
-    {
-        0x84, 0xA8, 0xD4, 0x60, 0xC7, 0x16, 0xB6, 0xF3, 0x9B, 0x0E, 0x4C, 0x3D, 0xAB, 0x95, 0xF8, 0x38,
-    };
+    public static readonly byte[] HeaderRandomIdArray =
+    [
+        0x84, 0xA8, 0xD4, 0x60, 0xC7, 0x16, 0xB6, 0xF3, 0x9B, 0x0E, 0x4C, 0x3D, 0xAB, 0x95, 0xF8, 0x38
+    ];
 
-    public static readonly byte[] Profile_Random_Id_Array =
-    {
-        0x91, 0x7D, 0x6D, 0xE6, 0x84, 0xC9, 0x58, 0xD1, 0x3B, 0xB0, 0xF5, 0xBB, 0xAD, 0xD1, 0x13, 0x4F,
-    };
+    public static readonly byte[] ProfileRandomIdArray =
+    [
+        0x91, 0x7D, 0x6D, 0xE6, 0x84, 0xC9, 0x58, 0xD1, 0x3B, 0xB0, 0xF5, 0xBB, 0xAD, 0xD1, 0x13, 0x4F
+    ];
 
-    public static readonly IccProfileHeader Header_Random_Write = CreateHeaderRandomValue(
+    public static readonly IccProfileHeader HeaderRandomWrite = CreateHeaderRandomValue(
         562,        // should be overwritten
         new IccProfileId(1, 2, 3, 4),   // should be overwritten
         "ijkl");    // should be overwritten to "acsp"
 
-    public static readonly IccProfileHeader Header_Random_Read = CreateHeaderRandomValue(132, Header_Random_Id_Value, "acsp");
+    public static readonly IccProfileHeader HeaderRandomRead = CreateHeaderRandomValue(132, HeaderRandomIdValue, "acsp");
 
-    public static readonly byte[] Header_Random_Array = CreateHeaderRandomArray(132, 0, Header_Random_Id_Array);
+    public static readonly byte[] HeaderRandomArray = CreateHeaderRandomArray(132, 0, HeaderRandomIdArray);
 
-    public static IccProfileHeader CreateHeaderRandomValue(uint size, IccProfileId id, string fileSignature)
+    public static IccProfileHeader CreateHeaderRandomValue(uint size, IccProfileId id, string fileSignature) => new()
     {
-        return new IccProfileHeader
-        {
-            Class = IccProfileClass.DisplayDevice,
-            CmmType = "abcd",
-            CreationDate = new DateTime(1990, 11, 26, 7, 21, 42),
-            CreatorSignature = "dcba",
-            DataColorSpace = IccColorSpaceType.Rgb,
-            DeviceAttributes = IccDeviceAttribute.ChromaBlackWhite | IccDeviceAttribute.OpacityTransparent,
-            DeviceManufacturer = 123456789u,
-            DeviceModel = 987654321u,
-            FileSignature = "acsp",
-            Flags = IccProfileFlag.Embedded | IccProfileFlag.Independent,
-            Id = id,
-            PcsIlluminant = new Vector3(4, 5, 6),
-            PrimaryPlatformSignature = IccPrimaryPlatformType.MicrosoftCorporation,
-            ProfileConnectionSpace = IccColorSpaceType.CieXyz,
-            RenderingIntent = IccRenderingIntent.AbsoluteColorimetric,
-            Size = size,
-            Version = new IccVersion(4, 3, 0),
-        };
-    }
-
-    public static byte[] CreateHeaderRandomArray(uint size, uint nrOfEntries, byte[] profileId)
-    {
-        return ArrayHelper.Concat(
+        Class = IccProfileClass.DisplayDevice,
+        CmmType = "abcd",
+        CreationDate = new DateTime(1990, 11, 26, 7, 21, 42),
+        CreatorSignature = "dcba",
+        DataColorSpace = IccColorSpaceType.Rgb,
+        DeviceAttributes = IccDeviceAttribute.ChromaBlackWhite | IccDeviceAttribute.OpacityTransparent,
+        DeviceManufacturer = 123456789u,
+        DeviceModel = 987654321u,
+        FileSignature = "acsp",
+        Flags = IccProfileFlag.Embedded | IccProfileFlag.Independent,
+        Id = id,
+        PcsIlluminant = new Vector3(4, 5, 6),
+        PrimaryPlatformSignature = IccPrimaryPlatformType.MicrosoftCorporation,
+        ProfileConnectionSpace = IccColorSpaceType.CieXyz,
+        RenderingIntent = IccRenderingIntent.AbsoluteColorimetric,
+        Size = size,
+        Version = new IccVersion(4, 3, 0),
+    };
+
+    public static byte[] CreateHeaderRandomArray(uint size, uint nrOfEntries, byte[] profileId) => ArrayHelper.Concat(
              new byte[]
              {
                 (byte)(size >> 24), (byte)(size >> 16), (byte)(size >> 8), (byte)size,     // Size
@@ -91,10 +86,9 @@ internal static class IccTestDataProfiles
                 (byte)(nrOfEntries >> 8),
                 (byte)nrOfEntries
              });
-    }
 
-    public static readonly byte[] Profile_Random_Array = ArrayHelper.Concat(
-        CreateHeaderRandomArray(168, 2, Profile_Random_Id_Array),
+    public static readonly byte[] ProfileRandomArray = ArrayHelper.Concat(
+        CreateHeaderRandomArray(168, 2, ProfileRandomIdArray),
         new byte[]
         {
             0x00, 0x00, 0x00, 0x00,     // tag signature (Unknown)
@@ -104,18 +98,18 @@ internal static class IccTestDataProfiles
             0x00, 0x00, 0x00, 0x9C,     // tag offset (156)
             0x00, 0x00, 0x00, 0x0C,     // tag size (12)
         },
-        IccTestDataTagDataEntry.TagDataEntryHeader_UnknownArr,
-        IccTestDataTagDataEntry.Unknown_Arr);
+        IccTestDataTagDataEntry.TagDataEntryHeaderUnknownArr,
+        IccTestDataTagDataEntry.UnknownArr);
 
-    public static readonly IccProfile Profile_Random_Val = new IccProfile(
+    public static readonly IccProfile ProfileRandomVal = new(
         CreateHeaderRandomValue(
             168,
-            Profile_Random_Id_Value,
+            ProfileRandomIdValue,
             "acsp"),
-        new IccTagDataEntry[] { IccTestDataTagDataEntry.Unknown_Val, IccTestDataTagDataEntry.Unknown_Val });
+        [IccTestDataTagDataEntry.UnknownVal, IccTestDataTagDataEntry.UnknownVal]);
 
-    public static readonly byte[] Header_CorruptDataColorSpace_Array =
-    {
+    public static readonly byte[] HeaderCorruptDataColorSpaceArray =
+    [
         0x00, 0x00, 0x00, 0x80,     // Size
         0x61, 0x62, 0x63, 0x64,     // CmmType
         0x04, 0x30, 0x00, 0x00,     // Version
@@ -140,11 +134,11 @@ internal static class IccTestDataProfiles
         0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
         0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
         0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-        0x00, 0x00, 0x00, 0x00,
-    };
+        0x00, 0x00, 0x00, 0x00
+    ];
 
-    public static readonly byte[] Header_CorruptProfileConnectionSpace_Array =
-    {
+    public static readonly byte[] HeaderCorruptProfileConnectionSpaceArray =
+    [
         0x00, 0x00, 0x00, 0x80,     // Size
         0x62, 0x63, 0x64, 0x65,     // CmmType
         0x04, 0x30, 0x00, 0x00,     // Version
@@ -169,11 +163,11 @@ internal static class IccTestDataProfiles
         0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
         0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
         0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-        0x00, 0x00, 0x00, 0x00,
-    };
+        0x00, 0x00, 0x00, 0x00
+    ];
 
-    public static readonly byte[] Header_CorruptRenderingIntent_Array =
-    {
+    public static readonly byte[] HeaderCorruptRenderingIntentArray =
+    [
         0x00, 0x00, 0x00, 0x80,     // Size
         0x63, 0x64, 0x65, 0x66,     // CmmType
         0x04, 0x30, 0x00, 0x00,     // Version
@@ -198,32 +192,32 @@ internal static class IccTestDataProfiles
         0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
         0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
         0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-        0x00, 0x00, 0x00, 0x00,
-    };
+        0x00, 0x00, 0x00, 0x00
+    ];
 
-    public static readonly byte[] Header_DataTooSmall_Array = new byte[127];
+    public static readonly byte[] HeaderDataTooSmallArray = new byte[127];
 
-    public static readonly byte[] Header_InvalidSizeSmall_Array = CreateHeaderRandomArray(127, 0, Header_Random_Id_Array);
+    public static readonly byte[] HeaderInvalidSizeSmallArray = CreateHeaderRandomArray(127, 0, HeaderRandomIdArray);
 
-    public static readonly byte[] Header_InvalidSizeBig_Array = CreateHeaderRandomArray(50_000_000, 0, Header_Random_Id_Array);
+    public static readonly byte[] HeaderInvalidSizeBigArray = CreateHeaderRandomArray(50_000_000, 0, HeaderRandomIdArray);
 
-    public static readonly byte[] Header_SizeBiggerThanData_Array = CreateHeaderRandomArray(160, 0, Header_Random_Id_Array);
+    public static readonly byte[] HeaderSizeBiggerThanDataArray = CreateHeaderRandomArray(160, 0, HeaderRandomIdArray);
 
     public static readonly object[][] ProfileIdTestData =
-    {
-        new object[] { Header_Random_Array, Header_Random_Id_Value },
-        new object[] { Profile_Random_Array, Profile_Random_Id_Value },
-    };
+    [
+        [HeaderRandomArray, HeaderRandomIdValue],
+        [ProfileRandomArray, ProfileRandomIdValue]
+    ];
 
     public static readonly object[][] ProfileValidityTestData =
-    {
-        new object[] { Header_CorruptDataColorSpace_Array, false },
-        new object[] { Header_CorruptProfileConnectionSpace_Array, false },
-        new object[] { Header_CorruptRenderingIntent_Array, false },
-        new object[] { Header_DataTooSmall_Array, false },
-        new object[] { Header_InvalidSizeSmall_Array, false },
-        new object[] { Header_InvalidSizeBig_Array, false },
-        new object[] { Header_SizeBiggerThanData_Array, false },
-        new object[] { Header_Random_Array, true },
-    };
+    [
+        [HeaderCorruptDataColorSpaceArray, false],
+        [HeaderCorruptProfileConnectionSpaceArray, false],
+        [HeaderCorruptRenderingIntentArray, false],
+        [HeaderDataTooSmallArray, false],
+        [HeaderInvalidSizeSmallArray, false],
+        [HeaderInvalidSizeBigArray, false],
+        [HeaderSizeBiggerThanDataArray, false],
+        [HeaderRandomArray, true]
+    ];
 }
diff --git a/tests/ImageSharp.Tests/TestDataIcc/IccTestDataTagDataEntry.cs b/tests/ImageSharp.Tests/TestDataIcc/IccTestDataTagDataEntry.cs
index 69d375cedf..979b0044dc 100644
--- a/tests/ImageSharp.Tests/TestDataIcc/IccTestDataTagDataEntry.cs
+++ b/tests/ImageSharp.Tests/TestDataIcc/IccTestDataTagDataEntry.cs
@@ -2,54 +2,53 @@
 // Licensed under the Six Labors Split License.
 
 using System.Globalization;
-using System.Numerics;
 using SixLabors.ImageSharp.Metadata.Profiles.Icc;
 
-namespace SixLabors.ImageSharp.Tests;
+namespace SixLabors.ImageSharp.Tests.TestDataIcc;
 
 internal static class IccTestDataTagDataEntry
 {
-    public static readonly IccTypeSignature TagDataEntryHeader_UnknownVal = IccTypeSignature.Unknown;
-    public static readonly byte[] TagDataEntryHeader_UnknownArr =
-    {
-        0x00, 0x00, 0x00, 0x00,
+    public static readonly IccTypeSignature TagDataEntryHeaderUnknownVal = IccTypeSignature.Unknown;
+    public static readonly byte[] TagDataEntryHeaderUnknownArr =
+    [
         0x00, 0x00, 0x00, 0x00,
-    };
+        0x00, 0x00, 0x00, 0x00
+    ];
 
-    public static readonly IccTypeSignature TagDataEntryHeader_MultiLocalizedUnicodeVal = IccTypeSignature.MultiLocalizedUnicode;
-    public static readonly byte[] TagDataEntryHeader_MultiLocalizedUnicodeArr =
-    {
+    public static readonly IccTypeSignature TagDataEntryHeaderMultiLocalizedUnicodeVal = IccTypeSignature.MultiLocalizedUnicode;
+    public static readonly byte[] TagDataEntryHeaderMultiLocalizedUnicodeArr =
+    [
         0x6D, 0x6C, 0x75, 0x63,
-        0x00, 0x00, 0x00, 0x00,
-    };
+        0x00, 0x00, 0x00, 0x00
+    ];
 
-    public static readonly IccTypeSignature TagDataEntryHeader_CurveVal = IccTypeSignature.Curve;
-    public static readonly byte[] TagDataEntryHeader_CurveArr =
-    {
+    public static readonly IccTypeSignature TagDataEntryHeaderCurveVal = IccTypeSignature.Curve;
+    public static readonly byte[] TagDataEntryHeaderCurveArr =
+    [
         0x63, 0x75, 0x72, 0x76,
-        0x00, 0x00, 0x00, 0x00,
-    };
+        0x00, 0x00, 0x00, 0x00
+    ];
 
     public static readonly object[][] TagDataEntryHeaderTestData =
-    {
-        new object[] { TagDataEntryHeader_UnknownArr, TagDataEntryHeader_UnknownVal },
-        new object[] { TagDataEntryHeader_MultiLocalizedUnicodeArr, TagDataEntryHeader_MultiLocalizedUnicodeVal },
-        new object[] { TagDataEntryHeader_CurveArr, TagDataEntryHeader_CurveVal },
-    };
+    [
+        [TagDataEntryHeaderUnknownArr, TagDataEntryHeaderUnknownVal],
+        [TagDataEntryHeaderMultiLocalizedUnicodeArr, TagDataEntryHeaderMultiLocalizedUnicodeVal],
+        [TagDataEntryHeaderCurveArr, TagDataEntryHeaderCurveVal]
+    ];
 
-    public static readonly IccUnknownTagDataEntry Unknown_Val = new(new byte[] { 0x00, 0x01, 0x02, 0x03 });
+    public static readonly IccUnknownTagDataEntry UnknownVal = new([0x00, 0x01, 0x02, 0x03]);
 
-    public static readonly byte[] Unknown_Arr = { 0x00, 0x01, 0x02, 0x03 };
+    public static readonly byte[] UnknownArr = [0x00, 0x01, 0x02, 0x03];
 
     public static readonly object[][] UnknownTagDataEntryTestData =
-    {
-        new object[] { Unknown_Arr, Unknown_Val, 12u },
-    };
-
-    public static readonly IccChromaticityTagDataEntry Chromaticity_Val1 = new(IccColorantEncoding.ItuRBt709_2);
-    public static readonly byte[] Chromaticity_Arr1 = ArrayHelper.Concat(
-        IccTestDataPrimitives.UInt16_3,
-        IccTestDataPrimitives.UInt16_1,
+    [
+        [UnknownArr, UnknownVal, 12u]
+    ];
+
+    public static readonly IccChromaticityTagDataEntry ChromaticityVal1 = new(IccColorantEncoding.ItuRBt709_2);
+    public static readonly byte[] ChromaticityArr1 = ArrayHelper.Concat(
+        IccTestDataPrimitives.UInt163,
+        IccTestDataPrimitives.UInt161,
         new byte[] { 0x00, 0x00, 0xA3, 0xD7 },  // 0.640
         new byte[] { 0x00, 0x00, 0x54, 0x7B },  // 0.330
         new byte[] { 0x00, 0x00, 0x4C, 0xCD },  // 0.300
@@ -57,190 +56,175 @@ internal static class IccTestDataTagDataEntry
         new byte[] { 0x00, 0x00, 0x26, 0x66 },  // 0.150
         new byte[] { 0x00, 0x00, 0x0F, 0x5C }); // 0.060
 
-    public static readonly IccChromaticityTagDataEntry Chromaticity_Val2 = new(
-        new double[][]
-        {
-            new double[] { 1, 2 },
-            new double[] { 3, 4 },
-        });
-
-    public static readonly byte[] Chromaticity_Arr2 = ArrayHelper.Concat(
-        IccTestDataPrimitives.UInt16_2,
-        IccTestDataPrimitives.UInt16_0,
-        IccTestDataPrimitives.UFix16_1,
-        IccTestDataPrimitives.UFix16_2,
-        IccTestDataPrimitives.UFix16_3,
-        IccTestDataPrimitives.UFix16_4);
+    public static readonly IccChromaticityTagDataEntry ChromaticityVal2 = new(
+    [
+        [1, 2],
+        [3, 4]
+    ]);
+
+    public static readonly byte[] ChromaticityArr2 = ArrayHelper.Concat(
+        IccTestDataPrimitives.UInt162,
+        IccTestDataPrimitives.UInt160,
+        IccTestDataPrimitives.UFix161,
+        IccTestDataPrimitives.UFix162,
+        IccTestDataPrimitives.UFix163,
+        IccTestDataPrimitives.UFix164);
 
     /// <summary>
     /// <see cref="InvalidIccProfileException"/>: channel count must be 3 for any enum other than <see cref="ColorantEncoding.Unknown"/>
     /// </summary>
-    public static readonly byte[] Chromaticity_ArrInvalid1 = ArrayHelper.Concat(
-        IccTestDataPrimitives.UInt16_5,
-        IccTestDataPrimitives.UInt16_1);
+    public static readonly byte[] ChromaticityArrInvalid1 = ArrayHelper.Concat(
+        IccTestDataPrimitives.UInt165,
+        IccTestDataPrimitives.UInt161);
 
     /// <summary>
     /// <see cref="InvalidIccProfileException"/>: invalid enum value
     /// </summary>
-    public static readonly byte[] Chromaticity_ArrInvalid2 = ArrayHelper.Concat(
-        IccTestDataPrimitives.UInt16_3,
-        IccTestDataPrimitives.UInt16_9);
+    public static readonly byte[] ChromaticityArrInvalid2 = ArrayHelper.Concat(
+        IccTestDataPrimitives.UInt163,
+        IccTestDataPrimitives.UInt169);
 
     public static readonly object[][] ChromaticityTagDataEntryTestData =
-    {
-        new object[] { Chromaticity_Arr1, Chromaticity_Val1 },
-        new object[] { Chromaticity_Arr2, Chromaticity_Val2 },
-    };
+    [
+        [ChromaticityArr1, ChromaticityVal1],
+        [ChromaticityArr2, ChromaticityVal2]
+    ];
 
-    public static readonly IccColorantOrderTagDataEntry ColorantOrder_Val = new(new byte[] { 0x00, 0x01, 0x02 });
-    public static readonly byte[] ColorantOrder_Arr = ArrayHelper.Concat(IccTestDataPrimitives.UInt32_3, new byte[] { 0x00, 0x01, 0x02 });
+    public static readonly IccColorantOrderTagDataEntry ColorantOrderVal = new([0x00, 0x01, 0x02]);
+    public static readonly byte[] ColorantOrderArr = ArrayHelper.Concat(IccTestDataPrimitives.UInt323, new byte[] { 0x00, 0x01, 0x02 });
 
     public static readonly object[][] ColorantOrderTagDataEntryTestData =
-    {
-        new object[] { ColorantOrder_Arr, ColorantOrder_Val },
-    };
+    [
+        [ColorantOrderArr, ColorantOrderVal]
+    ];
 
-    public static readonly IccColorantTableTagDataEntry ColorantTable_Val = new(
-        new IccColorantTableEntry[]
-        {
-            IccTestDataNonPrimitives.ColorantTableEntry_ValRand1,
-            IccTestDataNonPrimitives.ColorantTableEntry_ValRand2
-        });
+    public static readonly IccColorantTableTagDataEntry ColorantTableVal = new(
+    [
+        IccTestDataNonPrimitives.ColorantTableEntryValRand1,
+            IccTestDataNonPrimitives.ColorantTableEntryValRand2
+    ]);
 
-    public static readonly byte[] ColorantTable_Arr = ArrayHelper.Concat(
-        IccTestDataPrimitives.UInt32_2,
-        IccTestDataNonPrimitives.ColorantTableEntry_Rand1,
-        IccTestDataNonPrimitives.ColorantTableEntry_Rand2);
+    public static readonly byte[] ColorantTableArr = ArrayHelper.Concat(
+        IccTestDataPrimitives.UInt322,
+        IccTestDataNonPrimitives.ColorantTableEntryRand1,
+        IccTestDataNonPrimitives.ColorantTableEntryRand2);
 
     public static readonly object[][] ColorantTableTagDataEntryTestData =
-    {
-        new object[] { ColorantTable_Arr, ColorantTable_Val },
-    };
+    [
+        [ColorantTableArr, ColorantTableVal]
+    ];
 
-    public static readonly IccCurveTagDataEntry Curve_Val_0 = new();
-    public static readonly byte[] Curve_Arr_0 = IccTestDataPrimitives.UInt32_0;
+    public static readonly IccCurveTagDataEntry CurveVal0 = new();
+    public static readonly byte[] CurveArr0 = IccTestDataPrimitives.UInt320;
 
-    public static readonly IccCurveTagDataEntry Curve_Val_1 = new(1f);
-    public static readonly byte[] Curve_Arr_1 = ArrayHelper.Concat(
-        IccTestDataPrimitives.UInt32_1,
-        IccTestDataPrimitives.UFix8_1);
+    public static readonly IccCurveTagDataEntry CurveVal1 = new(1f);
+    public static readonly byte[] CurveArr1 = ArrayHelper.Concat(
+        IccTestDataPrimitives.UInt321,
+        IccTestDataPrimitives.UFix81);
 
-    public static readonly IccCurveTagDataEntry Curve_Val_2 = new(new float[] { 1 / 65535f, 2 / 65535f, 3 / 65535f });
-    public static readonly byte[] Curve_Arr_2 = ArrayHelper.Concat(
-        IccTestDataPrimitives.UInt32_3,
-        IccTestDataPrimitives.UInt16_1,
-        IccTestDataPrimitives.UInt16_2,
-        IccTestDataPrimitives.UInt16_3);
+    public static readonly IccCurveTagDataEntry CurveVal2 = new([1 / 65535f, 2 / 65535f, 3 / 65535f]);
+    public static readonly byte[] CurveArr2 = ArrayHelper.Concat(
+        IccTestDataPrimitives.UInt323,
+        IccTestDataPrimitives.UInt161,
+        IccTestDataPrimitives.UInt162,
+        IccTestDataPrimitives.UInt163);
 
     public static readonly object[][] CurveTagDataEntryTestData =
-    {
-        new object[] { Curve_Arr_0, Curve_Val_0 },
-        new object[] { Curve_Arr_1, Curve_Val_1 },
-        new object[] { Curve_Arr_2, Curve_Val_2 },
-    };
+    [
+        [CurveArr0, CurveVal0],
+        [CurveArr1, CurveVal1],
+        [CurveArr2, CurveVal2]
+    ];
 
-    public static readonly IccDataTagDataEntry Data_ValNoASCII = new(
-        new byte[] { 0x01, 0x02, 0x03, 0x04 },
-        false);
+    public static readonly IccDataTagDataEntry DataValNoAscii = new([0x01, 0x02, 0x03, 0x04], false);
 
-    public static readonly byte[] Data_ArrNoASCII =
-    {
+    public static readonly byte[] DataArrNoAscii =
+    [
         0x00, 0x00, 0x00, 0x00,
         0x01, 0x02, 0x03, 0x04
-    };
+    ];
 
-    public static readonly IccDataTagDataEntry Data_ValASCII = new(
-        new byte[] { (byte)'A', (byte)'S', (byte)'C', (byte)'I', (byte)'I' },
-        true);
+    public static readonly IccDataTagDataEntry DataValAscii = new([(byte)'A', (byte)'S', (byte)'C', (byte)'I', (byte)'I'
+    ], true);
 
-    public static readonly byte[] Data_ArrASCII =
-    {
+    public static readonly byte[] DataArrAscii =
+    [
         0x00, 0x00, 0x00, 0x01,
         (byte)'A', (byte)'S', (byte)'C', (byte)'I', (byte)'I'
-    };
+    ];
 
     public static readonly object[][] DataTagDataEntryTestData =
-    {
-        new object[] { Data_ArrNoASCII, Data_ValNoASCII, 16u },
-        new object[] { Data_ArrASCII, Data_ValASCII, 17u },
-    };
+    [
+        [DataArrNoAscii, DataValNoAscii, 16u],
+        [DataArrAscii, DataValAscii, 17u]
+    ];
 
-    public static readonly IccDateTimeTagDataEntry DateTime_Val = new(IccTestDataNonPrimitives.DateTime_ValRand1);
-    public static readonly byte[] DateTime_Arr = IccTestDataNonPrimitives.DateTime_Rand1;
+    public static readonly IccDateTimeTagDataEntry DateTimeVal = new(IccTestDataNonPrimitives.DateTimeValRand1);
+    public static readonly byte[] DateTimeArr = IccTestDataNonPrimitives.DateTimeRand1;
 
     public static readonly object[][] DateTimeTagDataEntryTestData =
-    {
-        new object[] { DateTime_Arr, DateTime_Val },
-    };
+    [
+        [DateTimeArr, DateTimeVal]
+    ];
 
-    public static readonly IccLut16TagDataEntry Lut16_Val = new(
-        new IccLut[] { IccTestDataLut.LUT16_ValGrad, IccTestDataLut.LUT16_ValGrad },
-        IccTestDataLut.CLUT16_ValGrad,
-        new IccLut[] { IccTestDataLut.LUT16_ValGrad, IccTestDataLut.LUT16_ValGrad, IccTestDataLut.LUT16_ValGrad });
+    public static readonly IccLut16TagDataEntry Lut16Val = new(
+        [IccTestDataLut.Lut16ValGrad, IccTestDataLut.Lut16ValGrad],
+        IccTestDataLut.Clut16ValGrad,
+        [IccTestDataLut.Lut16ValGrad, IccTestDataLut.Lut16ValGrad, IccTestDataLut.Lut16ValGrad]);
 
-    public static readonly byte[] Lut16_Arr = ArrayHelper.Concat(
+    public static readonly byte[] Lut16Arr = ArrayHelper.Concat(
         new byte[] { 0x02, 0x03, 0x03, 0x00 },
-        IccTestDataMatrix.Fix16_2D_Identity,
-        new byte[] { 0x00, (byte)IccTestDataLut.LUT16_ValGrad.Values.Length, 0x00, (byte)IccTestDataLut.LUT16_ValGrad.Values.Length },
-        IccTestDataLut.LUT16_Grad,
-        IccTestDataLut.LUT16_Grad,
-        IccTestDataLut.CLUT16_Grad,
-        IccTestDataLut.LUT16_Grad,
-        IccTestDataLut.LUT16_Grad,
-        IccTestDataLut.LUT16_Grad);
+        IccTestDataMatrix.Fix162DIdentity,
+        new byte[] { 0x00, (byte)IccTestDataLut.Lut16ValGrad.Values.Length, 0x00, (byte)IccTestDataLut.Lut16ValGrad.Values.Length },
+        IccTestDataLut.Lut16Grad,
+        IccTestDataLut.Lut16Grad,
+        IccTestDataLut.Clut16Grad,
+        IccTestDataLut.Lut16Grad,
+        IccTestDataLut.Lut16Grad,
+        IccTestDataLut.Lut16Grad);
 
     public static readonly object[][] Lut16TagDataEntryTestData =
-    {
-        new object[] { Lut16_Arr, Lut16_Val },
-    };
+    [
+        [Lut16Arr, Lut16Val]
+    ];
 
-    public static readonly IccLut8TagDataEntry Lut8_Val = new(
-        new IccLut[] { IccTestDataLut.LUT8_ValGrad, IccTestDataLut.LUT8_ValGrad },
-        IccTestDataLut.CLUT8_ValGrad,
-        new IccLut[] { IccTestDataLut.LUT8_ValGrad, IccTestDataLut.LUT8_ValGrad, IccTestDataLut.LUT8_ValGrad });
+    public static readonly IccLut8TagDataEntry Lut8Val = new(
+        [IccTestDataLut.Lut8ValGrad, IccTestDataLut.Lut8ValGrad],
+        IccTestDataLut.Clut8ValGrad,
+        [IccTestDataLut.Lut8ValGrad, IccTestDataLut.Lut8ValGrad, IccTestDataLut.Lut8ValGrad]);
 
-    public static readonly byte[] Lut8_Arr = ArrayHelper.Concat(
+    public static readonly byte[] Lut8Arr = ArrayHelper.Concat(
         new byte[] { 0x02, 0x03, 0x03, 0x00 },
-        IccTestDataMatrix.Fix16_2D_Identity,
-        IccTestDataLut.LUT8_Grad,
-        IccTestDataLut.LUT8_Grad,
-        IccTestDataLut.CLUT8_Grad,
-        IccTestDataLut.LUT8_Grad,
-        IccTestDataLut.LUT8_Grad,
-        IccTestDataLut.LUT8_Grad);
-
-    public static readonly object[][] Lut8TagDataEntryTestData =
-    {
-        new object[] { Lut8_Arr, Lut8_Val },
-    };
+        IccTestDataMatrix.Fix162DIdentity,
+        IccTestDataLut.Lut8Grad,
+        IccTestDataLut.Lut8Grad,
+        IccTestDataLut.Clut8Grad,
+        IccTestDataLut.Lut8Grad,
+        IccTestDataLut.Lut8Grad,
+        IccTestDataLut.Lut8Grad);
 
-    private static readonly byte[] CurveFull_0 = ArrayHelper.Concat(
-        TagDataEntryHeader_CurveArr,
-        Curve_Arr_0);
+    public static readonly object[][] Lut8TagDataEntryTestData = [[Lut8Arr, Lut8Val]];
 
-    private static readonly byte[] CurveFull_1 = ArrayHelper.Concat(
-        TagDataEntryHeader_CurveArr,
-        Curve_Arr_1);
+    private static readonly byte[] CurveFull0 = ArrayHelper.Concat(TagDataEntryHeaderCurveArr, CurveArr0);
 
-    private static readonly byte[] CurveFull_2 = ArrayHelper.Concat(
-        TagDataEntryHeader_CurveArr,
-        Curve_Arr_2);
+    private static readonly byte[] CurveFull1 = ArrayHelper.Concat(TagDataEntryHeaderCurveArr, CurveArr1);
 
-    public static readonly IccLutAToBTagDataEntry LutAToB_Val
+    private static readonly byte[] CurveFull2 = ArrayHelper.Concat(TagDataEntryHeaderCurveArr, CurveArr2);
+
+    public static readonly IccLutAToBTagDataEntry LutAToBVal
         = new(
-            new IccCurveTagDataEntry[]
-        {
-            Curve_Val_0,
-            Curve_Val_1,
-            Curve_Val_2,
-        },
-            IccTestDataMatrix.Single_2DArray_ValGrad,
-            IccTestDataMatrix.Single_1DArray_ValGrad,
-            new IccCurveTagDataEntry[] { Curve_Val_1, Curve_Val_2, Curve_Val_0 },
-            IccTestDataLut.CLUT_Val16,
-            new IccCurveTagDataEntry[] { Curve_Val_2, Curve_Val_1 });
-
-    public static readonly byte[] LutAToB_Arr = ArrayHelper.Concat(
+            [
+                CurveVal0,
+            CurveVal1,
+            CurveVal2
+            ],
+            IccTestDataMatrix.Single2DArrayValGrad,
+            IccTestDataMatrix.Single1DArrayValGrad,
+            [CurveVal1, CurveVal2, CurveVal0],
+            IccTestDataLut.ClutVal16,
+            [CurveVal2, CurveVal1]);
+
+    public static readonly byte[] LutAToBArr = ArrayHelper.Concat(
         new byte[] { 0x02, 0x03, 0x00, 0x00 },
         new byte[] { 0x00, 0x00, 0x00, 0x20 },  // b:        32
         new byte[] { 0x00, 0x00, 0x00, 0x50 },  // matrix:   80
@@ -249,51 +233,47 @@ internal static class IccTestDataTagDataEntry
         new byte[] { 0x00, 0x00, 0x00, 0xFC },  // a:        252
 
         // B
-        CurveFull_0,                // 12 bytes
-        CurveFull_1,                // 14 bytes
+        CurveFull0,                // 12 bytes
+        CurveFull1,                // 14 bytes
         new byte[] { 0x00, 0x00 },  // Padding
-        CurveFull_2,                // 18 bytes
+        CurveFull2,                // 18 bytes
         new byte[] { 0x00, 0x00 },  // Padding
 
         // Matrix
-        IccTestDataMatrix.Fix16_2D_Grad,   // 36 bytes
-        IccTestDataMatrix.Fix16_1D_Grad,   // 12 bytes
+        IccTestDataMatrix.Fix162DGrad,   // 36 bytes
+        IccTestDataMatrix.Fix161DGrad,   // 12 bytes
 
         // M
-        CurveFull_1,                // 14 bytes
+        CurveFull1,                // 14 bytes
         new byte[] { 0x00, 0x00 },  // Padding
-        CurveFull_2,                // 18 bytes
+        CurveFull2,                // 18 bytes
         new byte[] { 0x00, 0x00 },  // Padding
-        CurveFull_0,                // 12 bytes
+        CurveFull0,                // 12 bytes
 
         // CLUT
-        IccTestDataLut.CLUT_16,     // 74 bytes
+        IccTestDataLut.Clut16,     // 74 bytes
         new byte[] { 0x00, 0x00 },  // Padding
 
         // A
-        CurveFull_2,                // 18 bytes
+        CurveFull2,                // 18 bytes
         new byte[] { 0x00, 0x00 },  // Padding
-        CurveFull_1,                // 14 bytes
+        CurveFull1,                // 14 bytes
         new byte[] { 0x00, 0x00 }); // Padding
 
-    public static readonly object[][] LutAToBTagDataEntryTestData =
-    {
-        new object[] { LutAToB_Arr, LutAToB_Val },
-    };
+    public static readonly object[][] LutAToBTagDataEntryTestData = [[LutAToBArr, LutAToBVal]];
 
-    public static readonly IccLutBToATagDataEntry LutBToA_Val = new(
-        new[]
-        {
-            Curve_Val_0,
-            Curve_Val_1,
-        },
+    public static readonly IccLutBToATagDataEntry LutBToAVal = new(
+        [
+            CurveVal0,
+            CurveVal1
+        ],
         null,
         null,
         null,
-        IccTestDataLut.CLUT_Val16,
-        new[] { Curve_Val_2, Curve_Val_1, Curve_Val_0 });
+        IccTestDataLut.ClutVal16,
+        [CurveVal2, CurveVal1, CurveVal0]);
 
-    public static readonly byte[] LutBToA_Arr = ArrayHelper.Concat(
+    public static readonly byte[] LutBToAArr = ArrayHelper.Concat(
         new byte[] { 0x02, 0x03, 0x00, 0x00 },
         new byte[] { 0x00, 0x00, 0x00, 0x20 },  // b:        32
         new byte[] { 0x00, 0x00, 0x00, 0x00 },  // matrix:   0
@@ -302,52 +282,52 @@ internal static class IccTestDataTagDataEntry
         new byte[] { 0x00, 0x00, 0x00, 0x88 },  // a:        136
 
         // B
-        CurveFull_0,    // 12 bytes
-        CurveFull_1,    // 14 bytes
+        CurveFull0,    // 12 bytes
+        CurveFull1,    // 14 bytes
         new byte[] { 0x00, 0x00 }, // Padding
 
         // CLUT
-        IccTestDataLut.CLUT_16,     // 74 bytes
+        IccTestDataLut.Clut16,     // 74 bytes
         new byte[] { 0x00, 0x00 },  // Padding
 
         // A
-        CurveFull_2,                // 18 bytes
+        CurveFull2,                // 18 bytes
         new byte[] { 0x00, 0x00 },  // Padding
-        CurveFull_1,                // 14 bytes
+        CurveFull1,                // 14 bytes
         new byte[] { 0x00, 0x00 },  // Padding
-        CurveFull_0); // 12 bytes
+        CurveFull0); // 12 bytes
 
     public static readonly object[][] LutBToATagDataEntryTestData =
-    {
-        new object[] { LutBToA_Arr, LutBToA_Val },
-    };
+    [
+        [LutBToAArr, LutBToAVal]
+    ];
 
-    public static readonly IccMeasurementTagDataEntry Measurement_Val = new(
+    public static readonly IccMeasurementTagDataEntry MeasurementVal = new(
         IccStandardObserver.Cie1931Observer,
-        IccTestDataNonPrimitives.XyzNumber_ValVar1,
+        IccTestDataNonPrimitives.XyzNumberValVar1,
         IccMeasurementGeometry.Degree0ToDOrDTo0,
         1f,
         IccStandardIlluminant.D50);
 
-    public static readonly byte[] Measurement_Arr = ArrayHelper.Concat(
-        IccTestDataPrimitives.UInt32_1,
-        IccTestDataNonPrimitives.XyzNumber_Var1,
-        IccTestDataPrimitives.UInt32_2,
-        IccTestDataPrimitives.UFix16_1,
-        IccTestDataPrimitives.UInt32_1);
+    public static readonly byte[] MeasurementArr = ArrayHelper.Concat(
+        IccTestDataPrimitives.UInt321,
+        IccTestDataNonPrimitives.XyzNumberVar1,
+        IccTestDataPrimitives.UInt322,
+        IccTestDataPrimitives.UFix161,
+        IccTestDataPrimitives.UInt321);
 
     public static readonly object[][] MeasurementTagDataEntryTestData =
-    {
-        new object[] { Measurement_Arr, Measurement_Val },
-    };
-
-    private static readonly IccLocalizedString LocalizedString_Rand_enUS = CreateLocalizedString("en", "US", IccTestDataPrimitives.Unicode_ValRand2);
-    private static readonly IccLocalizedString LocalizedString_Rand_deDE = CreateLocalizedString("de", "DE", IccTestDataPrimitives.Unicode_ValRand3);
-    private static readonly IccLocalizedString LocalizedString_Rand2_deDE = CreateLocalizedString("de", "DE", IccTestDataPrimitives.Unicode_ValRand2);
-    private static readonly IccLocalizedString LocalizedString_Rand2_esXL = CreateLocalizedString("es", "XL", IccTestDataPrimitives.Unicode_ValRand2);
-    private static readonly IccLocalizedString LocalizedString_Rand2_xyXL = CreateLocalizedString("xy", "XL", IccTestDataPrimitives.Unicode_ValRand2);
-    private static readonly IccLocalizedString LocalizedString_Rand_en = CreateLocalizedString("en", null, IccTestDataPrimitives.Unicode_ValRand2);
-    private static readonly IccLocalizedString LocalizedString_Rand_Invariant = new(CultureInfo.InvariantCulture, IccTestDataPrimitives.Unicode_ValRand3);
+    [
+        [MeasurementArr, MeasurementVal]
+    ];
+
+    private static readonly IccLocalizedString LocalizedStringRandEnUs = CreateLocalizedString("en", "US", IccTestDataPrimitives.UnicodeValRand2);
+    private static readonly IccLocalizedString LocalizedStringRandDeDe = CreateLocalizedString("de", "DE", IccTestDataPrimitives.UnicodeValRand3);
+    private static readonly IccLocalizedString LocalizedStringRand2DeDe = CreateLocalizedString("de", "DE", IccTestDataPrimitives.UnicodeValRand2);
+    private static readonly IccLocalizedString LocalizedStringRand2EsXl = CreateLocalizedString("es", "XL", IccTestDataPrimitives.UnicodeValRand2);
+    private static readonly IccLocalizedString LocalizedStringRand2XyXl = CreateLocalizedString("xy", "XL", IccTestDataPrimitives.UnicodeValRand2);
+    private static readonly IccLocalizedString LocalizedStringRandEn = CreateLocalizedString("en", null, IccTestDataPrimitives.UnicodeValRand2);
+    private static readonly IccLocalizedString LocalizedStringRandInvariant = new(CultureInfo.InvariantCulture, IccTestDataPrimitives.UnicodeValRand3);
 
     private static IccLocalizedString CreateLocalizedString(string language, string country, string text)
     {
@@ -378,42 +358,42 @@ internal static class IccTestDataTagDataEntry
         return new IccLocalizedString(culture, text);
     }
 
-    private static readonly IccLocalizedString[] LocalizedString_RandArr_enUS_deDE = new IccLocalizedString[]
-    {
-        LocalizedString_Rand_enUS,
-        LocalizedString_Rand_deDE,
-    };
-
-    private static readonly IccLocalizedString[] LocalizedString_RandArr_en_Invariant = new IccLocalizedString[]
-    {
-        LocalizedString_Rand_en,
-        LocalizedString_Rand_Invariant,
-    };
-
-    private static readonly IccLocalizedString[] LocalizedString_SameArr_enUS_deDE_esXL_xyXL = new IccLocalizedString[]
-    {
-        LocalizedString_Rand_enUS,
-        LocalizedString_Rand2_deDE,
-        LocalizedString_Rand2_esXL,
-        LocalizedString_Rand2_xyXL,
-    };
-
-    public static readonly IccMultiLocalizedUnicodeTagDataEntry MultiLocalizedUnicode_Val = new(LocalizedString_RandArr_enUS_deDE);
-    public static readonly byte[] MultiLocalizedUnicode_Arr = ArrayHelper.Concat(
-        IccTestDataPrimitives.UInt32_2,
+    private static readonly IccLocalizedString[] LocalizedStringRandArrEnUsDeDe =
+    [
+        LocalizedStringRandEnUs,
+        LocalizedStringRandDeDe
+    ];
+
+    private static readonly IccLocalizedString[] LocalizedStringRandArrEnInvariant =
+    [
+        LocalizedStringRandEn,
+        LocalizedStringRandInvariant
+    ];
+
+    private static readonly IccLocalizedString[] LocalizedStringSameArrEnUsDeDeEsXlXyXl =
+    [
+        LocalizedStringRandEnUs,
+        LocalizedStringRand2DeDe,
+        LocalizedStringRand2EsXl,
+        LocalizedStringRand2XyXl
+    ];
+
+    public static readonly IccMultiLocalizedUnicodeTagDataEntry MultiLocalizedUnicodeVal = new(LocalizedStringRandArrEnUsDeDe);
+    public static readonly byte[] MultiLocalizedUnicodeArr = ArrayHelper.Concat(
+        IccTestDataPrimitives.UInt322,
         new byte[] { 0x00, 0x00, 0x00, 0x0C },  // 12
-        new byte[] { (byte)'e', (byte)'n', (byte)'U', (byte)'S' },
+        [(byte)'e', (byte)'n', (byte)'U', (byte)'S'],
         new byte[] { 0x00, 0x00, 0x00, 0x0C },  // 12
         new byte[] { 0x00, 0x00, 0x00, 0x28 },  // 40
-        new byte[] { (byte)'d', (byte)'e', (byte)'D', (byte)'E' },
+        [(byte)'d', (byte)'e', (byte)'D', (byte)'E'],
         new byte[] { 0x00, 0x00, 0x00, 0x0E },  // 14
         new byte[] { 0x00, 0x00, 0x00, 0x34 },  // 52
-        IccTestDataPrimitives.Unicode_Rand2,
-        IccTestDataPrimitives.Unicode_Rand3);
+        IccTestDataPrimitives.UnicodeRand2,
+        IccTestDataPrimitives.UnicodeRand3);
 
-    public static readonly IccMultiLocalizedUnicodeTagDataEntry MultiLocalizedUnicode_Val2 = new(LocalizedString_RandArr_en_Invariant);
-    public static readonly byte[] MultiLocalizedUnicode_Arr2_Read = ArrayHelper.Concat(
-        IccTestDataPrimitives.UInt32_2,
+    public static readonly IccMultiLocalizedUnicodeTagDataEntry MultiLocalizedUnicodeVal2 = new(LocalizedStringRandArrEnInvariant);
+    public static readonly byte[] MultiLocalizedUnicodeArr2Read = ArrayHelper.Concat(
+        IccTestDataPrimitives.UInt322,
         new byte[] { 0x00, 0x00, 0x00, 0x0C },  // 12
         new byte[] { (byte)'e', (byte)'n', 0x00, 0x00 },
         new byte[] { 0x00, 0x00, 0x00, 0x0C },  // 12
@@ -421,11 +401,11 @@ internal static class IccTestDataTagDataEntry
         new byte[] { 0x00, 0x00, 0x00, 0x00 },
         new byte[] { 0x00, 0x00, 0x00, 0x0E },  // 14
         new byte[] { 0x00, 0x00, 0x00, 0x34 },  // 52
-        IccTestDataPrimitives.Unicode_Rand2,
-        IccTestDataPrimitives.Unicode_Rand3);
+        IccTestDataPrimitives.UnicodeRand2,
+        IccTestDataPrimitives.UnicodeRand3);
 
-    public static readonly byte[] MultiLocalizedUnicode_Arr2_Write = ArrayHelper.Concat(
-        IccTestDataPrimitives.UInt32_2,
+    public static readonly byte[] MultiLocalizedUnicodeArr2Write = ArrayHelper.Concat(
+        IccTestDataPrimitives.UInt322,
         new byte[] { 0x00, 0x00, 0x00, 0x0C },  // 12
         new byte[] { (byte)'e', (byte)'n', 0x00, 0x00 },
         new byte[] { 0x00, 0x00, 0x00, 0x0C },  // 12
@@ -433,393 +413,388 @@ internal static class IccTestDataTagDataEntry
         new byte[] { (byte)'x', (byte)'x', 0x00, 0x00 },
         new byte[] { 0x00, 0x00, 0x00, 0x0E },  // 14
         new byte[] { 0x00, 0x00, 0x00, 0x34 },  // 52
-        IccTestDataPrimitives.Unicode_Rand2,
-        IccTestDataPrimitives.Unicode_Rand3);
+        IccTestDataPrimitives.UnicodeRand2,
+        IccTestDataPrimitives.UnicodeRand3);
 
-    public static readonly IccMultiLocalizedUnicodeTagDataEntry MultiLocalizedUnicode_Val3 = new(LocalizedString_SameArr_enUS_deDE_esXL_xyXL);
-    public static readonly byte[] MultiLocalizedUnicode_Arr3 = ArrayHelper.Concat(
-        IccTestDataPrimitives.UInt32_4,
+    public static readonly IccMultiLocalizedUnicodeTagDataEntry MultiLocalizedUnicodeVal3 = new(LocalizedStringSameArrEnUsDeDeEsXlXyXl);
+    public static readonly byte[] MultiLocalizedUnicodeArr3 = ArrayHelper.Concat(
+        IccTestDataPrimitives.UInt324,
         new byte[] { 0x00, 0x00, 0x00, 0x0C },  // 12
-        new byte[] { (byte)'e', (byte)'n', (byte)'U', (byte)'S' },
+        [(byte)'e', (byte)'n', (byte)'U', (byte)'S'],
         new byte[] { 0x00, 0x00, 0x00, 0x0C },  // 12
         new byte[] { 0x00, 0x00, 0x00, 0x40 },  // 64
-        new byte[] { (byte)'d', (byte)'e', (byte)'D', (byte)'E' },
+        [(byte)'d', (byte)'e', (byte)'D', (byte)'E'],
         new byte[] { 0x00, 0x00, 0x00, 0x0C },  // 12
         new byte[] { 0x00, 0x00, 0x00, 0x40 },  // 64
-        new byte[] { (byte)'e', (byte)'s', (byte)'X', (byte)'L' },
+        [(byte)'e', (byte)'s', (byte)'X', (byte)'L'],
         new byte[] { 0x00, 0x00, 0x00, 0x0C },  // 12
         new byte[] { 0x00, 0x00, 0x00, 0x40 },  // 64
-        new byte[] { (byte)'x', (byte)'y', (byte)'X', (byte)'L' },
+        [(byte)'x', (byte)'y', (byte)'X', (byte)'L'],
         new byte[] { 0x00, 0x00, 0x00, 0x0C },  // 12
         new byte[] { 0x00, 0x00, 0x00, 0x40 },  // 64
-        IccTestDataPrimitives.Unicode_Rand2);
-
-    public static readonly object[][] MultiLocalizedUnicodeTagDataEntryTestData_Read =
-    {
-        new object[] { MultiLocalizedUnicode_Arr, MultiLocalizedUnicode_Val },
-        new object[] { MultiLocalizedUnicode_Arr2_Read, MultiLocalizedUnicode_Val2 },
-        new object[] { MultiLocalizedUnicode_Arr3, MultiLocalizedUnicode_Val3 },
-    };
-
-    public static readonly object[][] MultiLocalizedUnicodeTagDataEntryTestData_Write =
-    {
-        new object[] { MultiLocalizedUnicode_Arr, MultiLocalizedUnicode_Val },
-        new object[] { MultiLocalizedUnicode_Arr2_Write, MultiLocalizedUnicode_Val2 },
-        new object[] { MultiLocalizedUnicode_Arr3, MultiLocalizedUnicode_Val3 },
-    };
-
-    public static readonly IccMultiProcessElementsTagDataEntry MultiProcessElements_Val = new(
-        new IccMultiProcessElement[]
-        {
-            IccTestDataMultiProcessElements.MPE_ValCLUT,
-            IccTestDataMultiProcessElements.MPE_ValCLUT,
-        });
-
-    public static readonly byte[] MultiProcessElements_Arr = ArrayHelper.Concat(
-        IccTestDataPrimitives.UInt16_2,
-        IccTestDataPrimitives.UInt16_3,
-        IccTestDataPrimitives.UInt32_2,
+        IccTestDataPrimitives.UnicodeRand2);
+
+    public static readonly object[][] MultiLocalizedUnicodeTagDataEntryTestDataRead =
+    [
+        [MultiLocalizedUnicodeArr, MultiLocalizedUnicodeVal],
+        [MultiLocalizedUnicodeArr2Read, MultiLocalizedUnicodeVal2],
+        [MultiLocalizedUnicodeArr3, MultiLocalizedUnicodeVal3]
+    ];
+
+    public static readonly object[][] MultiLocalizedUnicodeTagDataEntryTestDataWrite =
+    [
+        [MultiLocalizedUnicodeArr, MultiLocalizedUnicodeVal],
+        [MultiLocalizedUnicodeArr2Write, MultiLocalizedUnicodeVal2],
+        [MultiLocalizedUnicodeArr3, MultiLocalizedUnicodeVal3]
+    ];
+
+    public static readonly IccMultiProcessElementsTagDataEntry MultiProcessElementsVal = new(
+    [
+        IccTestDataMultiProcessElements.MpeValClut,
+            IccTestDataMultiProcessElements.MpeValClut
+    ]);
+
+    public static readonly byte[] MultiProcessElementsArr = ArrayHelper.Concat(
+        IccTestDataPrimitives.UInt162,
+        IccTestDataPrimitives.UInt163,
+        IccTestDataPrimitives.UInt322,
         new byte[] { 0x00, 0x00, 0x00, 0x20 },  // 32
         new byte[] { 0x00, 0x00, 0x00, 0x84 },  // 132
         new byte[] { 0x00, 0x00, 0x00, 0xA4 },  // 164
         new byte[] { 0x00, 0x00, 0x00, 0x84 },  // 132
-        IccTestDataMultiProcessElements.MPE_CLUT,
-        IccTestDataMultiProcessElements.MPE_CLUT);
+        IccTestDataMultiProcessElements.MpeClut,
+        IccTestDataMultiProcessElements.MpeClut);
 
     public static readonly object[][] MultiProcessElementsTagDataEntryTestData =
-    {
-        new object[] { MultiProcessElements_Arr, MultiProcessElements_Val },
-    };
+    [
+        [MultiProcessElementsArr, MultiProcessElementsVal]
+    ];
 
-    public static readonly IccNamedColor2TagDataEntry NamedColor2_Val = new(
+    public static readonly IccNamedColor2TagDataEntry NamedColor2Val = new(
         16909060,
         ArrayHelper.Fill('A', 31),
         ArrayHelper.Fill('4', 31),
-        new IccNamedColor[] { IccTestDataNonPrimitives.NamedColor_ValMin, IccTestDataNonPrimitives.NamedColor_ValMin });
+        [IccTestDataNonPrimitives.NamedColorValMin, IccTestDataNonPrimitives.NamedColorValMin]);
 
-    public static readonly byte[] NamedColor2_Arr = ArrayHelper.Concat(
+    public static readonly byte[] NamedColor2Arr = ArrayHelper.Concat(
         new byte[] { 0x01, 0x02, 0x03, 0x04 },
-        IccTestDataPrimitives.UInt32_2,
-        IccTestDataPrimitives.UInt32_3,
+        IccTestDataPrimitives.UInt322,
+        IccTestDataPrimitives.UInt323,
         ArrayHelper.Fill((byte)0x41, 31),
         new byte[] { 0x00 },
         ArrayHelper.Fill((byte)0x34, 31),
         new byte[] { 0x00 },
-        IccTestDataNonPrimitives.NamedColor_Min,
-        IccTestDataNonPrimitives.NamedColor_Min);
+        IccTestDataNonPrimitives.NamedColorMin,
+        IccTestDataNonPrimitives.NamedColorMin);
 
     public static readonly object[][] NamedColor2TagDataEntryTestData =
-    {
-        new object[] { NamedColor2_Arr, NamedColor2_Val },
-    };
+    [
+        [NamedColor2Arr, NamedColor2Val]
+    ];
 
-    public static readonly IccParametricCurveTagDataEntry ParametricCurve_Val = new(IccTestDataCurves.Parametric_ValVar1);
-    public static readonly byte[] ParametricCurve_Arr = IccTestDataCurves.Parametric_Var1;
+    public static readonly IccParametricCurveTagDataEntry ParametricCurveVal = new(IccTestDataCurves.ParametricValVar1);
+    public static readonly byte[] ParametricCurveArr = IccTestDataCurves.ParametricVar1;
 
     public static readonly object[][] ParametricCurveTagDataEntryTestData =
-    {
-        new object[] { ParametricCurve_Arr, ParametricCurve_Val },
-    };
+    [
+        [ParametricCurveArr, ParametricCurveVal]
+    ];
 
-    public static readonly IccProfileSequenceDescTagDataEntry ProfileSequenceDesc_Val = new(
-        new IccProfileDescription[]
-        {
-            IccTestDataNonPrimitives.ProfileDescription_ValRand1,
-            IccTestDataNonPrimitives.ProfileDescription_ValRand1
-        });
+    public static readonly IccProfileSequenceDescTagDataEntry ProfileSequenceDescVal = new(
+    [
+        IccTestDataNonPrimitives.ProfileDescriptionValRand1,
+            IccTestDataNonPrimitives.ProfileDescriptionValRand1
+    ]);
 
-    public static readonly byte[] ProfileSequenceDesc_Arr = ArrayHelper.Concat(
-        IccTestDataPrimitives.UInt32_2,
-        IccTestDataNonPrimitives.ProfileDescription_Rand1,
-        IccTestDataNonPrimitives.ProfileDescription_Rand1);
+    public static readonly byte[] ProfileSequenceDescArr = ArrayHelper.Concat(
+        IccTestDataPrimitives.UInt322,
+        IccTestDataNonPrimitives.ProfileDescriptionRand1,
+        IccTestDataNonPrimitives.ProfileDescriptionRand1);
 
     public static readonly object[][] ProfileSequenceDescTagDataEntryTestData =
-    {
-        new object[] { ProfileSequenceDesc_Arr, ProfileSequenceDesc_Val },
-    };
+    [
+        [ProfileSequenceDescArr, ProfileSequenceDescVal]
+    ];
 
     public static readonly IccProfileSequenceIdentifierTagDataEntry ProfileSequenceIdentifier_Val = new(
-        new IccProfileSequenceIdentifier[]
-        {
-            new IccProfileSequenceIdentifier(IccTestDataNonPrimitives.ProfileId_ValRand, LocalizedString_RandArr_enUS_deDE),
-            new IccProfileSequenceIdentifier(IccTestDataNonPrimitives.ProfileId_ValRand, LocalizedString_RandArr_enUS_deDE),
-        });
+    [
+        new IccProfileSequenceIdentifier(IccTestDataNonPrimitives.ProfileIdValRand, LocalizedStringRandArrEnUsDeDe),
+            new IccProfileSequenceIdentifier(IccTestDataNonPrimitives.ProfileIdValRand, LocalizedStringRandArrEnUsDeDe)
+    ]);
 
-    public static readonly byte[] ProfileSequenceIdentifier_Arr = ArrayHelper.Concat(
-        IccTestDataPrimitives.UInt32_2,
+    public static readonly byte[] ProfileSequenceIdentifierArr = ArrayHelper.Concat(
+        IccTestDataPrimitives.UInt322,
         new byte[] { 0x00, 0x00, 0x00, 0x1C },  // 28
         new byte[] { 0x00, 0x00, 0x00, 0x54 },  // 84
         new byte[] { 0x00, 0x00, 0x00, 0x70 },  // 112
         new byte[] { 0x00, 0x00, 0x00, 0x54 },  // 84
-        IccTestDataNonPrimitives.ProfileId_Rand,        // 16 bytes
-        TagDataEntryHeader_MultiLocalizedUnicodeArr,    // 8  bytes
-        MultiLocalizedUnicode_Arr,                      // 58 bytes
+        IccTestDataNonPrimitives.ProfileIdRand,        // 16 bytes
+        TagDataEntryHeaderMultiLocalizedUnicodeArr,    // 8  bytes
+        MultiLocalizedUnicodeArr,                      // 58 bytes
         new byte[] { 0x00, 0x00 },                      // 2  bytes (padding)
-        IccTestDataNonPrimitives.ProfileId_Rand,
-        TagDataEntryHeader_MultiLocalizedUnicodeArr,
-        MultiLocalizedUnicode_Arr,
+        IccTestDataNonPrimitives.ProfileIdRand,
+        TagDataEntryHeaderMultiLocalizedUnicodeArr,
+        MultiLocalizedUnicodeArr,
         new byte[] { 0x00, 0x00 });
 
     public static readonly object[][] ProfileSequenceIdentifierTagDataEntryTestData =
-    {
-        new object[] { ProfileSequenceIdentifier_Arr, ProfileSequenceIdentifier_Val },
-    };
-
-    public static readonly IccResponseCurveSet16TagDataEntry ResponseCurveSet16_Val = new(
-        new IccResponseCurve[]
-        {
-            IccTestDataCurves.Response_ValGrad,
-            IccTestDataCurves.Response_ValGrad,
-        });
-
-    public static readonly byte[] ResponseCurveSet16_Arr = ArrayHelper.Concat(
-        IccTestDataPrimitives.UInt16_3,
-        IccTestDataPrimitives.UInt16_2,
+    [
+        [ProfileSequenceIdentifierArr, ProfileSequenceIdentifier_Val]
+    ];
+
+    public static readonly IccResponseCurveSet16TagDataEntry ResponseCurveSet16Val = new(
+    [
+        IccTestDataCurves.ResponseValGrad,
+            IccTestDataCurves.ResponseValGrad
+    ]);
+
+    public static readonly byte[] ResponseCurveSet16Arr = ArrayHelper.Concat(
+        IccTestDataPrimitives.UInt163,
+        IccTestDataPrimitives.UInt162,
         new byte[] { 0x00, 0x00, 0x00, 0x14 },  // 20
         new byte[] { 0x00, 0x00, 0x00, 0x6C },  // 108
-        IccTestDataCurves.Response_Grad, // 88 bytes
-        IccTestDataCurves.Response_Grad); // 88 bytes
+        IccTestDataCurves.ResponseGrad, // 88 bytes
+        IccTestDataCurves.ResponseGrad); // 88 bytes
 
     public static readonly object[][] ResponseCurveSet16TagDataEntryTestData =
-    {
-        new object[] { ResponseCurveSet16_Arr, ResponseCurveSet16_Val },
-    };
+    [
+        [ResponseCurveSet16Arr, ResponseCurveSet16Val]
+    ];
 
-    public static readonly IccFix16ArrayTagDataEntry Fix16Array_Val = new(new float[] { 1 / 256f, 2 / 256f, 3 / 256f });
-    public static readonly byte[] Fix16Array_Arr = ArrayHelper.Concat(
-        IccTestDataPrimitives.Fix16_1,
-        IccTestDataPrimitives.Fix16_2,
-        IccTestDataPrimitives.Fix16_3);
+    public static readonly IccFix16ArrayTagDataEntry Fix16ArrayVal = new([1 / 256f, 2 / 256f, 3 / 256f]);
+    public static readonly byte[] Fix16ArrayArr = ArrayHelper.Concat(
+        IccTestDataPrimitives.Fix161,
+        IccTestDataPrimitives.Fix162,
+        IccTestDataPrimitives.Fix163);
 
     public static readonly object[][] Fix16ArrayTagDataEntryTestData =
-    {
-        new object[] { Fix16Array_Arr, Fix16Array_Val, 20u },
-    };
+    [
+        [Fix16ArrayArr, Fix16ArrayVal, 20u]
+    ];
 
-    public static readonly IccSignatureTagDataEntry Signature_Val = new("ABCD");
-    public static readonly byte[] Signature_Arr = { 0x41, 0x42, 0x43, 0x44, };
+    public static readonly IccSignatureTagDataEntry SignatureVal = new("ABCD");
+    public static readonly byte[] SignatureArr = [0x41, 0x42, 0x43, 0x44];
 
     public static readonly object[][] SignatureTagDataEntryTestData =
-    {
-        new object[] { Signature_Arr, Signature_Val },
-    };
+    [
+        [SignatureArr, SignatureVal]
+    ];
 
-    public static readonly IccTextTagDataEntry Text_Val = new("ABCD");
-    public static readonly byte[] Text_Arr = { 0x41, 0x42, 0x43, 0x44 };
+    public static readonly IccTextTagDataEntry TextVal = new("ABCD");
+    public static readonly byte[] TextArr = [0x41, 0x42, 0x43, 0x44];
 
     public static readonly object[][] TextTagDataEntryTestData =
-    {
-        new object[] { Text_Arr, Text_Val, 12u },
-    };
+    [
+        [TextArr, TextVal, 12u]
+    ];
 
-    public static readonly IccUFix16ArrayTagDataEntry UFix16Array_Val = new(new float[] { 1, 2, 3 });
-    public static readonly byte[] UFix16Array_Arr = ArrayHelper.Concat(
-        IccTestDataPrimitives.UFix16_1,
-        IccTestDataPrimitives.UFix16_2,
-        IccTestDataPrimitives.UFix16_3);
+    public static readonly IccUFix16ArrayTagDataEntry UFix16ArrayVal = new([1, 2, 3]);
+    public static readonly byte[] UFix16ArrayArr = ArrayHelper.Concat(
+        IccTestDataPrimitives.UFix161,
+        IccTestDataPrimitives.UFix162,
+        IccTestDataPrimitives.UFix163);
 
     public static readonly object[][] UFix16ArrayTagDataEntryTestData =
-    {
-        new object[] { UFix16Array_Arr, UFix16Array_Val, 20u },
-    };
+    [
+        [UFix16ArrayArr, UFix16ArrayVal, 20u]
+    ];
 
-    public static readonly IccUInt16ArrayTagDataEntry UInt16Array_Val = new(new ushort[] { 1, 2, 3 });
-    public static readonly byte[] UInt16Array_Arr = ArrayHelper.Concat(
-        IccTestDataPrimitives.UInt16_1,
-        IccTestDataPrimitives.UInt16_2,
-        IccTestDataPrimitives.UInt16_3);
+    public static readonly IccUInt16ArrayTagDataEntry UInt16ArrayVal = new([1, 2, 3]);
+    public static readonly byte[] UInt16ArrayArr = ArrayHelper.Concat(
+        IccTestDataPrimitives.UInt161,
+        IccTestDataPrimitives.UInt162,
+        IccTestDataPrimitives.UInt163);
 
     public static readonly object[][] UInt16ArrayTagDataEntryTestData =
-    {
-        new object[] { UInt16Array_Arr, UInt16Array_Val, 14u },
-    };
+    [
+        [UInt16ArrayArr, UInt16ArrayVal, 14u]
+    ];
 
-    public static readonly IccUInt32ArrayTagDataEntry UInt32Array_Val = new(new uint[] { 1, 2, 3 });
-    public static readonly byte[] UInt32Array_Arr = ArrayHelper.Concat(
-        IccTestDataPrimitives.UInt32_1,
-        IccTestDataPrimitives.UInt32_2,
-        IccTestDataPrimitives.UInt32_3);
+    public static readonly IccUInt32ArrayTagDataEntry UInt32ArrayVal = new([1, 2, 3]);
+    public static readonly byte[] UInt32ArrayArr = ArrayHelper.Concat(
+        IccTestDataPrimitives.UInt321,
+        IccTestDataPrimitives.UInt322,
+        IccTestDataPrimitives.UInt323);
 
     public static readonly object[][] UInt32ArrayTagDataEntryTestData =
-    {
-        new object[] { UInt32Array_Arr, UInt32Array_Val, 20u },
-    };
+    [
+        [UInt32ArrayArr, UInt32ArrayVal, 20u]
+    ];
 
-    public static readonly IccUInt64ArrayTagDataEntry UInt64Array_Val = new(new ulong[] { 1, 2, 3 });
-    public static readonly byte[] UInt64Array_Arr = ArrayHelper.Concat(
-        IccTestDataPrimitives.UInt64_1,
-        IccTestDataPrimitives.UInt64_2,
-        IccTestDataPrimitives.UInt64_3);
+    public static readonly IccUInt64ArrayTagDataEntry UInt64ArrayVal = new([1, 2, 3]);
+    public static readonly byte[] UInt64ArrayArr = ArrayHelper.Concat(
+        IccTestDataPrimitives.UInt641,
+        IccTestDataPrimitives.UInt642,
+        IccTestDataPrimitives.UInt643);
 
     public static readonly object[][] UInt64ArrayTagDataEntryTestData =
-    {
-        new object[] { UInt64Array_Arr, UInt64Array_Val, 32u },
-    };
+    [
+        [UInt64ArrayArr, UInt64ArrayVal, 32u]
+    ];
 
-    public static readonly IccUInt8ArrayTagDataEntry UInt8Array_Val = new(new byte[] { 1, 2, 3 });
-    public static readonly byte[] UInt8Array_Arr = { 1, 2, 3 };
+    public static readonly IccUInt8ArrayTagDataEntry UInt8ArrayVal = new([1, 2, 3]);
+    public static readonly byte[] UInt8ArrayArr = [1, 2, 3];
 
     public static readonly object[][] UInt8ArrayTagDataEntryTestData =
-    {
-        new object[] { UInt8Array_Arr, UInt8Array_Val, 11u },
-    };
+    [
+        [UInt8ArrayArr, UInt8ArrayVal, 11u]
+    ];
 
-    public static readonly IccViewingConditionsTagDataEntry ViewingConditions_Val = new(
-        IccTestDataNonPrimitives.XyzNumber_ValVar1,
-        IccTestDataNonPrimitives.XyzNumber_ValVar2,
+    public static readonly IccViewingConditionsTagDataEntry ViewingConditionsVal = new(
+        IccTestDataNonPrimitives.XyzNumberValVar1,
+        IccTestDataNonPrimitives.XyzNumberValVar2,
         IccStandardIlluminant.D50);
 
-    public static readonly byte[] ViewingConditions_Arr = ArrayHelper.Concat(
-        IccTestDataNonPrimitives.XyzNumber_Var1,
-        IccTestDataNonPrimitives.XyzNumber_Var2,
-        IccTestDataPrimitives.UInt32_1);
+    public static readonly byte[] ViewingConditionsArr = ArrayHelper.Concat(
+        IccTestDataNonPrimitives.XyzNumberVar1,
+        IccTestDataNonPrimitives.XyzNumberVar2,
+        IccTestDataPrimitives.UInt321);
 
     public static readonly object[][] ViewingConditionsTagDataEntryTestData =
-    {
-        new object[] { ViewingConditions_Arr, ViewingConditions_Val },
-    };
+    [
+        [ViewingConditionsArr, ViewingConditionsVal]
+    ];
 
-    public static readonly IccXyzTagDataEntry XYZ_Val = new(new Vector3[]
-    {
-        IccTestDataNonPrimitives.XyzNumber_ValVar1,
-        IccTestDataNonPrimitives.XyzNumber_ValVar2,
-        IccTestDataNonPrimitives.XyzNumber_ValVar3,
-    });
+    public static readonly IccXyzTagDataEntry XyzVal = new([
+        IccTestDataNonPrimitives.XyzNumberValVar1,
+        IccTestDataNonPrimitives.XyzNumberValVar2,
+        IccTestDataNonPrimitives.XyzNumberValVar3
+    ]);
 
-    public static readonly byte[] XYZ_Arr = ArrayHelper.Concat(
-        IccTestDataNonPrimitives.XyzNumber_Var1,
-        IccTestDataNonPrimitives.XyzNumber_Var2,
-        IccTestDataNonPrimitives.XyzNumber_Var3);
+    public static readonly byte[] XyzArr = ArrayHelper.Concat(
+        IccTestDataNonPrimitives.XyzNumberVar1,
+        IccTestDataNonPrimitives.XyzNumberVar2,
+        IccTestDataNonPrimitives.XyzNumberVar3);
 
     public static readonly object[][] XYZTagDataEntryTestData =
-    {
-        new object[] { XYZ_Arr, XYZ_Val, 44u },
-    };
+    [
+        [XyzArr, XyzVal, 44u]
+    ];
 
-    public static readonly IccTextDescriptionTagDataEntry TextDescription_Val1 = new(
-        IccTestDataPrimitives.Ascii_ValRand,
-        IccTestDataPrimitives.Unicode_ValRand1,
+    public static readonly IccTextDescriptionTagDataEntry TextDescriptionVal1 = new(
+        IccTestDataPrimitives.AsciiValRand,
+        IccTestDataPrimitives.UnicodeValRand1,
         ArrayHelper.Fill('A', 66),
         1701729619,
         2);
 
-    public static readonly byte[] TextDescription_Arr1 = ArrayHelper.Concat(
+    public static readonly byte[] TextDescriptionArr1 = ArrayHelper.Concat(
         new byte[] { 0x00, 0x00, 0x00, 0x0B }, // 11
-        IccTestDataPrimitives.Ascii_Rand,
+        IccTestDataPrimitives.AsciiRand,
         new byte[] { 0x00 }, // Null terminator
         new byte[] { 0x65, 0x6E, 0x55, 0x53 }, // enUS
         new byte[] { 0x00, 0x00, 0x00, 0x0E }, // 14
-        IccTestDataPrimitives.Unicode_Rand1,
+        IccTestDataPrimitives.UnicodeRand1,
         new byte[] { 0x00, 0x00 }, // Null terminator
         new byte[] { 0x00, 0x02, 0x43 }, // 2, 67
         ArrayHelper.Fill((byte)0x41, 66),
         new byte[] { 0x00 }); // Null terminator
 
-    public static readonly IccTextDescriptionTagDataEntry TextDescription_Val2 = new(IccTestDataPrimitives.Ascii_ValRand, null, null, 0, 0);
-    public static readonly byte[] TextDescription_Arr2 = ArrayHelper.Concat(
+    public static readonly IccTextDescriptionTagDataEntry TextDescriptionVal2 = new(IccTestDataPrimitives.AsciiValRand, null, null, 0, 0);
+    public static readonly byte[] TextDescriptionArr2 = ArrayHelper.Concat(
         new byte[] { 0x00, 0x00, 0x00, 0x0B },  // 11
-        IccTestDataPrimitives.Ascii_Rand,
+        IccTestDataPrimitives.AsciiRand,
         new byte[] { 0x00 },                    // Null terminator
-        IccTestDataPrimitives.UInt32_0,
-        IccTestDataPrimitives.UInt32_0,
+        IccTestDataPrimitives.UInt320,
+        IccTestDataPrimitives.UInt320,
         new byte[] { 0x00, 0x00, 0x00 },        // 0, 0
         ArrayHelper.Fill((byte)0x00, 67));
 
     public static readonly object[][] TextDescriptionTagDataEntryTestData =
-    {
-        new object[] { TextDescription_Arr1, TextDescription_Val1 },
-        new object[] { TextDescription_Arr2, TextDescription_Val2 },
-    };
-
-    public static readonly IccCrdInfoTagDataEntry CrdInfo_Val = new(
-        IccTestDataPrimitives.Ascii_ValRand4,
-        IccTestDataPrimitives.Ascii_ValRand1,
-        IccTestDataPrimitives.Ascii_ValRand2,
-        IccTestDataPrimitives.Ascii_ValRand3,
-        IccTestDataPrimitives.Ascii_ValRand4);
-
-    public static readonly byte[] CrdInfo_Arr = ArrayHelper.Concat(
-        IccTestDataPrimitives.UInt32_6,
-        IccTestDataPrimitives.Ascii_Rand4,
+    [
+        [TextDescriptionArr1, TextDescriptionVal1],
+        [TextDescriptionArr2, TextDescriptionVal2]
+    ];
+
+    public static readonly IccCrdInfoTagDataEntry CrdInfoVal = new(
+        IccTestDataPrimitives.AsciiValRand4,
+        IccTestDataPrimitives.AsciiValRand1,
+        IccTestDataPrimitives.AsciiValRand2,
+        IccTestDataPrimitives.AsciiValRand3,
+        IccTestDataPrimitives.AsciiValRand4);
+
+    public static readonly byte[] CrdInfoArr = ArrayHelper.Concat(
+        IccTestDataPrimitives.UInt326,
+        IccTestDataPrimitives.AsciiRand4,
         new byte[] { 0 },
-        IccTestDataPrimitives.UInt32_6,
-        IccTestDataPrimitives.Ascii_Rand1,
+        IccTestDataPrimitives.UInt326,
+        IccTestDataPrimitives.AsciiRand1,
         new byte[] { 0 },
-        IccTestDataPrimitives.UInt32_6,
-        IccTestDataPrimitives.Ascii_Rand2,
+        IccTestDataPrimitives.UInt326,
+        IccTestDataPrimitives.AsciiRand2,
         new byte[] { 0 },
-        IccTestDataPrimitives.UInt32_6,
-        IccTestDataPrimitives.Ascii_Rand3,
+        IccTestDataPrimitives.UInt326,
+        IccTestDataPrimitives.AsciiRand3,
         new byte[] { 0 },
-        IccTestDataPrimitives.UInt32_6,
-        IccTestDataPrimitives.Ascii_Rand4,
+        IccTestDataPrimitives.UInt326,
+        IccTestDataPrimitives.AsciiRand4,
         new byte[] { 0 });
 
     public static readonly object[][] CrdInfoTagDataEntryTestData =
-    {
-        new object[] { CrdInfo_Arr, CrdInfo_Val },
-    };
+    [
+        [CrdInfoArr, CrdInfoVal]
+    ];
 
-    public static readonly IccScreeningTagDataEntry Screening_Val = new(
+    public static readonly IccScreeningTagDataEntry ScreeningVal = new(
         IccScreeningFlag.DefaultScreens | IccScreeningFlag.UnitLinesPerCm,
-        new IccScreeningChannel[] { IccTestDataNonPrimitives.ScreeningChannel_ValRand1, IccTestDataNonPrimitives.ScreeningChannel_ValRand2 });
+        [IccTestDataNonPrimitives.ScreeningChannelValRand1, IccTestDataNonPrimitives.ScreeningChannelValRand2]);
 
-    public static readonly byte[] Screening_Arr = ArrayHelper.Concat(
-        IccTestDataPrimitives.Int32_1,
-        IccTestDataPrimitives.UInt32_2,
-        IccTestDataNonPrimitives.ScreeningChannel_Rand1,
-        IccTestDataNonPrimitives.ScreeningChannel_Rand2);
+    public static readonly byte[] ScreeningArr = ArrayHelper.Concat(
+        IccTestDataPrimitives.Int321,
+        IccTestDataPrimitives.UInt322,
+        IccTestDataNonPrimitives.ScreeningChannelRand1,
+        IccTestDataNonPrimitives.ScreeningChannelRand2);
 
     public static readonly object[][] ScreeningTagDataEntryTestData =
-    {
-        new object[] { Screening_Arr, Screening_Val },
-    };
-
-    public static readonly IccUcrBgTagDataEntry UcrBg_Val = new(
-        new ushort[] { 3, 4, 6 },
-        new ushort[] { 9, 7, 2, 5 },
-        IccTestDataPrimitives.Ascii_ValRand);
-
-    public static readonly byte[] UcrBg_Arr = ArrayHelper.Concat(
-        IccTestDataPrimitives.UInt32_3,
-        IccTestDataPrimitives.UInt16_3,
-        IccTestDataPrimitives.UInt16_4,
-        IccTestDataPrimitives.UInt16_6,
-        IccTestDataPrimitives.UInt32_4,
-        IccTestDataPrimitives.UInt16_9,
-        IccTestDataPrimitives.UInt16_7,
-        IccTestDataPrimitives.UInt16_2,
-        IccTestDataPrimitives.UInt16_5,
-        IccTestDataPrimitives.Ascii_Rand,
+    [
+        [ScreeningArr, ScreeningVal]
+    ];
+
+    public static readonly IccUcrBgTagDataEntry UcrBgVal = new(
+        [3, 4, 6],
+        [9, 7, 2, 5],
+        IccTestDataPrimitives.AsciiValRand);
+
+    public static readonly byte[] UcrBgArr = ArrayHelper.Concat(
+        IccTestDataPrimitives.UInt323,
+        IccTestDataPrimitives.UInt163,
+        IccTestDataPrimitives.UInt164,
+        IccTestDataPrimitives.UInt166,
+        IccTestDataPrimitives.UInt324,
+        IccTestDataPrimitives.UInt169,
+        IccTestDataPrimitives.UInt167,
+        IccTestDataPrimitives.UInt162,
+        IccTestDataPrimitives.UInt165,
+        IccTestDataPrimitives.AsciiRand,
         new byte[] { 0 });
 
     public static readonly object[][] UcrBgTagDataEntryTestData =
-    {
-        new object[] { UcrBg_Arr, UcrBg_Val, 41 },
-    };
-
-    public static readonly IccTagDataEntry TagDataEntry_CurveVal = Curve_Val_2;
-    public static readonly byte[] TagDataEntry_CurveArr = ArrayHelper.Concat(
-        TagDataEntryHeader_CurveArr,
-        Curve_Arr_2,
+    [
+        [UcrBgArr, UcrBgVal, 41]
+    ];
+
+    public static readonly IccTagDataEntry TagDataEntryCurveVal = CurveVal2;
+    public static readonly byte[] TagDataEntryCurveArr = ArrayHelper.Concat(
+        TagDataEntryHeaderCurveArr,
+        CurveArr2,
         new byte[] { 0x00, 0x00 }); // padding
 
-    public static readonly IccTagDataEntry TagDataEntry_MultiLocalizedUnicodeVal = MultiLocalizedUnicode_Val;
-    public static readonly byte[] TagDataEntry_MultiLocalizedUnicodeArr = ArrayHelper.Concat(
-        TagDataEntryHeader_MultiLocalizedUnicodeArr,
-        MultiLocalizedUnicode_Arr,
+    public static readonly IccTagDataEntry TagDataEntryMultiLocalizedUnicodeVal = MultiLocalizedUnicodeVal;
+    public static readonly byte[] TagDataEntryMultiLocalizedUnicodeArr = ArrayHelper.Concat(
+        TagDataEntryHeaderMultiLocalizedUnicodeArr,
+        MultiLocalizedUnicodeArr,
         new byte[] { 0x00, 0x00 }); // padding
 
-    public static readonly IccTagTableEntry TagDataEntry_MultiLocalizedUnicodeTable = new(
+    public static readonly IccTagTableEntry TagDataEntryMultiLocalizedUnicodeTable = new(
         IccProfileTag.Unknown,
         0,
-        (uint)TagDataEntry_MultiLocalizedUnicodeArr.Length - 2);
+        (uint)TagDataEntryMultiLocalizedUnicodeArr.Length - 2);
 
-    public static readonly IccTagTableEntry TagDataEntry_CurveTable = new(IccProfileTag.Unknown, 0, (uint)TagDataEntry_CurveArr.Length - 2);
+    public static readonly IccTagTableEntry TagDataEntryCurveTable = new(IccProfileTag.Unknown, 0, (uint)TagDataEntryCurveArr.Length - 2);
 
     public static readonly object[][] TagDataEntryTestData =
-    {
-        new object[] { TagDataEntry_CurveArr, TagDataEntry_CurveVal },
-        new object[] { TagDataEntry_MultiLocalizedUnicodeArr, TagDataEntry_MultiLocalizedUnicodeVal },
-    };
+    [
+        [TagDataEntryCurveArr, TagDataEntryCurveVal],
+        [TagDataEntryMultiLocalizedUnicodeArr, TagDataEntryMultiLocalizedUnicodeVal]
+    ];
 }
diff --git a/tests/ImageSharp.Tests/TestDataIcc/Profiles/CGATS21_CRPC7.icc b/tests/ImageSharp.Tests/TestDataIcc/Profiles/CGATS21_CRPC7.icc
new file mode 100644
index 0000000000..c4b7084721
--- /dev/null
+++ b/tests/ImageSharp.Tests/TestDataIcc/Profiles/CGATS21_CRPC7.icc
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:2b186e6dadc38883138ccd30203b2870fb71db6451d3a5d24f9590cfabd26689
+size 3462496
diff --git a/tests/ImageSharp.Tests/TestDataIcc/Profiles/Coated_Fogra39L_VIGC_300.icc b/tests/ImageSharp.Tests/TestDataIcc/Profiles/Coated_Fogra39L_VIGC_300.icc
new file mode 100644
index 0000000000..a21b7f657d
--- /dev/null
+++ b/tests/ImageSharp.Tests/TestDataIcc/Profiles/Coated_Fogra39L_VIGC_300.icc
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:6df43849a84d2632e7900a125f657bd09364ed56775bc4740c1e39a5492d47e3
+size 8652444
diff --git a/tests/ImageSharp.Tests/TestDataIcc/Profiles/ISO22028-2_ROMM-RGB.icc b/tests/ImageSharp.Tests/TestDataIcc/Profiles/ISO22028-2_ROMM-RGB.icc
new file mode 100644
index 0000000000..b06abf217a
--- /dev/null
+++ b/tests/ImageSharp.Tests/TestDataIcc/Profiles/ISO22028-2_ROMM-RGB.icc
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:96b2f2987f83e2a545e607799fbfdff43ef8158fb9b215b187c574db8f145aaf
+size 864
diff --git a/tests/ImageSharp.Tests/TestDataIcc/Profiles/JapanColor2003WebCoated.icc b/tests/ImageSharp.Tests/TestDataIcc/Profiles/JapanColor2003WebCoated.icc
new file mode 100644
index 0000000000..028a3cde63
--- /dev/null
+++ b/tests/ImageSharp.Tests/TestDataIcc/Profiles/JapanColor2003WebCoated.icc
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:662a345063b2853a66ed12dc54215e513e8485cbf4cb7f673971c834979eb25f
+size 654432
diff --git a/tests/ImageSharp.Tests/TestDataIcc/Profiles/JapanColor2011Coated.icc b/tests/ImageSharp.Tests/TestDataIcc/Profiles/JapanColor2011Coated.icc
new file mode 100644
index 0000000000..ee8dde35aa
--- /dev/null
+++ b/tests/ImageSharp.Tests/TestDataIcc/Profiles/JapanColor2011Coated.icc
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:73202ea802e57a63a0be05ed993fde8e4d51cc436120e6c47815ce785ff42916
+size 1979304
diff --git a/tests/ImageSharp.Tests/TestDataIcc/Profiles/SWOP2006_Coated5v2.icc b/tests/ImageSharp.Tests/TestDataIcc/Profiles/SWOP2006_Coated5v2.icc
new file mode 100644
index 0000000000..e24f272f35
--- /dev/null
+++ b/tests/ImageSharp.Tests/TestDataIcc/Profiles/SWOP2006_Coated5v2.icc
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:0ac00fe6f03901bfd06ef70e72ec2c55fa3c043c6c34c0b6d70f06cc7a40a822
+size 2747952
diff --git a/tests/ImageSharp.Tests/TestDataIcc/Profiles/issue-129.icc b/tests/ImageSharp.Tests/TestDataIcc/Profiles/issue-129.icc
new file mode 100644
index 0000000000..9dee961653
--- /dev/null
+++ b/tests/ImageSharp.Tests/TestDataIcc/Profiles/issue-129.icc
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:35f401731df11a4eba3502af632e51d68bc394bcb7d34632a331c1ba3f4a0bf6
+size 557168
diff --git a/tests/ImageSharp.Tests/TestDataIcc/Profiles/sRGB2014.icc b/tests/ImageSharp.Tests/TestDataIcc/Profiles/sRGB2014.icc
new file mode 100644
index 0000000000..46916dd8ce
--- /dev/null
+++ b/tests/ImageSharp.Tests/TestDataIcc/Profiles/sRGB2014.icc
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:384b832de3412066743b52a75ee906b6fb9fb8d9e09e936fc2c43223815c6e0a
+size 3024
diff --git a/tests/ImageSharp.Tests/TestDataIcc/Profiles/sRGB_v4_ICC_preference.icc b/tests/ImageSharp.Tests/TestDataIcc/Profiles/sRGB_v4_ICC_preference.icc
new file mode 100644
index 0000000000..8ddb31b2b8
--- /dev/null
+++ b/tests/ImageSharp.Tests/TestDataIcc/Profiles/sRGB_v4_ICC_preference.icc
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:83174717332326ddc198d9df188a4daec27b8979ba152cebbfc470c793d0bb11
+size 60960
diff --git a/tests/ImageSharp.Tests/TestFile.cs b/tests/ImageSharp.Tests/TestFile.cs
index a53e508067..1177152c03 100644
--- a/tests/ImageSharp.Tests/TestFile.cs
+++ b/tests/ImageSharp.Tests/TestFile.cs
@@ -117,7 +117,7 @@ public sealed class TestFile
     /// The <see cref="Image{Rgba32}"/>.
     /// </returns>
     public Image<Rgba32> CreateRgba32Image(IImageDecoder decoder)
-        => this.CreateRgba32Image(decoder, new());
+        => this.CreateRgba32Image(decoder, new DecoderOptions());
 
     /// <summary>
     /// Creates a new <see cref="Rgba32"/> image.
diff --git a/tests/ImageSharp.Tests/TestFontUtilities.cs b/tests/ImageSharp.Tests/TestFontUtilities.cs
index 01b1faa45a..a2c2032672 100644
--- a/tests/ImageSharp.Tests/TestFontUtilities.cs
+++ b/tests/ImageSharp.Tests/TestFontUtilities.cs
@@ -37,13 +37,13 @@ public static class TestFontUtilities
     /// </returns>
     private static string GetFontsDirectory()
     {
-        List<string> directories = new List<string>
-        {
-             "TestFonts/", // Here for code coverage tests.
-             "tests/ImageSharp.Tests/TestFonts/", // from travis/build script
-             "../../../../../ImageSharp.Tests/TestFonts/", // from Sandbox46
-             "../../../../TestFonts/"
-        };
+        List<string> directories =
+        [
+            "TestFonts/", // Here for code coverage tests.
+            "tests/ImageSharp.Tests/TestFonts/", // from travis/build script
+            "../../../../../ImageSharp.Tests/TestFonts/", // from Sandbox46
+            "../../../../TestFonts/"
+        ];
 
         directories = directories.SelectMany(x => new[]
                                  {
@@ -59,7 +59,7 @@ public static class TestFontUtilities
             return directory;
         }
 
-        throw new System.Exception($"Unable to find Fonts directory at any of these locations [{string.Join(", ", directories)}]");
+        throw new Exception($"Unable to find Fonts directory at any of these locations [{string.Join(", ", directories)}]");
     }
 
     /// <summary>
diff --git a/tests/ImageSharp.Tests/TestFormat.cs b/tests/ImageSharp.Tests/TestFormat.cs
index d30ce7846d..28bfcfaa8d 100644
--- a/tests/ImageSharp.Tests/TestFormat.cs
+++ b/tests/ImageSharp.Tests/TestFormat.cs
@@ -28,7 +28,7 @@ public class TestFormat : IImageFormatConfigurationModule, IImageFormat
         this.Decoder = new TestDecoder(this);
     }
 
-    public List<DecodeOperation> DecodeCalls { get; } = new();
+    public List<DecodeOperation> DecodeCalls { get; } = [];
 
     public TestEncoder Encoder { get; }
 
@@ -38,7 +38,7 @@ public class TestFormat : IImageFormatConfigurationModule, IImageFormat
 
     public MemoryStream CreateStream(byte[] marker = null)
     {
-        var ms = new MemoryStream();
+        MemoryStream ms = new();
         byte[] data = this.header;
         ms.Write(data, 0, data.Length);
         if (marker != null)
@@ -54,7 +54,7 @@ public class TestFormat : IImageFormatConfigurationModule, IImageFormat
     {
         byte[] buffer = new byte[size];
         this.header.CopyTo(buffer, 0);
-        var semaphoreStream = new SemaphoreReadMemoryStream(buffer, waitAfterPosition, notifyWaitPositionReachedSemaphore, continueSemaphore);
+        SemaphoreReadMemoryStream semaphoreStream = new(buffer, waitAfterPosition, notifyWaitPositionReachedSemaphore, continueSemaphore);
         return seeakable ? semaphoreStream : new AsyncStreamWrapper(semaphoreStream, () => false);
     }
 
@@ -103,7 +103,7 @@ public class TestFormat : IImageFormatConfigurationModule, IImageFormat
 
     public string Extension => "test_ext";
 
-    public IEnumerable<string> SupportedExtensions => new[] { "test_ext" };
+    public IEnumerable<string> SupportedExtensions => ["test_ext"];
 
     public int HeaderSize => this.header.Length;
 
@@ -111,7 +111,7 @@ public class TestFormat : IImageFormatConfigurationModule, IImageFormat
 
     public string DefaultMimeType => this.MimeType;
 
-    public IEnumerable<string> MimeTypes => new[] { this.MimeType };
+    public IEnumerable<string> MimeTypes => [this.MimeType];
 
     public IEnumerable<string> FileExtensions => this.SupportedExtensions;
 
@@ -193,7 +193,7 @@ public class TestFormat : IImageFormatConfigurationModule, IImageFormat
 
         public TestDecoder(TestFormat testFormat) => this.testFormat = testFormat;
 
-        public IEnumerable<string> MimeTypes => new[] { this.testFormat.MimeType };
+        public IEnumerable<string> MimeTypes => [this.testFormat.MimeType];
 
         public IEnumerable<string> FileExtensions => this.testFormat.SupportedExtensions;
 
@@ -205,7 +205,7 @@ public class TestFormat : IImageFormatConfigurationModule, IImageFormat
         {
             using Image<TestPixelForAgnosticDecode> image = this.Decode<TestPixelForAgnosticDecode>(this.CreateDefaultSpecializedOptions(options), stream, cancellationToken);
             ImageMetadata metadata = image.Metadata;
-            return new(image.Size, metadata, new List<ImageFrameMetadata>(image.Frames.Select(x => x.Metadata)))
+            return new ImageInfo(image.Size, metadata, new List<ImageFrameMetadata>(image.Frames.Select(x => x.Metadata)))
             {
                 PixelType = metadata.GetDecodedPixelTypeInfo()
             };
@@ -246,7 +246,7 @@ public class TestFormat : IImageFormatConfigurationModule, IImageFormat
 
         public TestEncoder(TestFormat testFormat) => this.testFormat = testFormat;
 
-        public IEnumerable<string> MimeTypes => new[] { this.testFormat.MimeType };
+        public IEnumerable<string> MimeTypes => [this.testFormat.MimeType];
 
         public IEnumerable<string> FileExtensions => this.testFormat.SupportedExtensions;
 
diff --git a/tests/ImageSharp.Tests/TestImages.cs b/tests/ImageSharp.Tests/TestImages.cs
index 5f6680528e..c74e12b217 100644
--- a/tests/ImageSharp.Tests/TestImages.cs
+++ b/tests/ImageSharp.Tests/TestImages.cs
@@ -76,6 +76,7 @@ public static class TestImages
         public const string FrameOffset = "Png/animated/frame-offset.png";
         public const string DefaultNotAnimated = "Png/animated/default-not-animated.png";
         public const string Issue2666 = "Png/issues/Issue_2666.png";
+        public const string Issue2882 = "Png/issues/Issue_2882.png";
 
         // Filtered test images from http://www.schaik.com/pngsuite/pngsuite_fil_png.html
         public const string Filter0 = "Png/filter0.png";
@@ -159,6 +160,9 @@ public static class TestImages
         // Issue 2752: https://github.com/SixLabors/ImageSharp/issues/2752
         public const string Issue2752 = "Png/issues/Issue_2752.png";
 
+        // Issue 2924: https://github.com/SixLabors/ImageSharp/issues/2924
+        public const string Issue2924 = "Png/issues/Issue_2924.png";
+
         public static class Bad
         {
             public const string MissingDataChunk = "Png/xdtn0g01.png";
@@ -202,6 +206,18 @@ public static class TestImages
 
     public static class Jpeg
     {
+        public static class ICC
+        {
+            public const string SRgb = "Jpg/icc-profiles/Momiji-sRGB-yes.jpg";
+            public const string AdobeRgb = "Jpg/icc-profiles/Momiji-AdobeRGB-yes.jpg";
+            public const string ColorMatch = "Jpg/icc-profiles/Momiji-ColorMatch-yes.jpg";
+            public const string ProPhoto = "Jpg/icc-profiles/Momiji-ProPhoto-yes.jpg";
+            public const string WideRGB = "Jpg/icc-profiles/Momiji-WideRGB-yes.jpg";
+            public const string AppleRGB = "Jpg/icc-profiles/Momiji-AppleRGB-yes.jpg";
+            public const string CMYK = "Jpg/icc-profiles/issue-129.jpg";
+            public const string YCCK = "Jpg/icc-profiles/issue_2723.jpg";
+        }
+
         public static class Progressive
         {
             public const string Fb = "Jpg/progressive/fb.jpg";
@@ -215,7 +231,7 @@ public static class TestImages
                 public const string ExifUndefType = "Jpg/progressive/ExifUndefType.jpg";
             }
 
-            public static readonly string[] All = { Fb, Progress, Festzug };
+            public static readonly string[] All = [Fb, Progress, Festzug];
         }
 
         public static class Baseline
@@ -271,12 +287,12 @@ public static class TestImages
             public const string ArithmeticCodingWithRestart = "Jpg/baseline/Calliphora-arithmetic-restart.jpg";
 
             public static readonly string[] All =
-            {
+            [
                 Cmyk, Ycck, Exif, Floorplan,
                 Calliphora, Turtle420, GammaDalaiLamaGray,
                 Hiyamugi, Jpeg400, Jpeg420Exif, Jpeg444,
                 Ratio1x1, Testorig12bit, YcckSubsample1222
-            };
+            ];
         }
 
         public static class Issues
@@ -325,6 +341,7 @@ public static class TestImages
             public const string Issue2067_CommentMarker = "Jpg/issues/issue-2067-comment.jpg";
             public const string Issue2638 = "Jpg/issues/Issue2638.jpg";
             public const string Issue2758 = "Jpg/issues/issue-2758.jpg";
+            public const string Issue2857 = "Jpg/issues/issue-2857-subsub-ifds.jpg";
 
             public static class Fuzz
             {
@@ -453,24 +470,24 @@ public static class TestImages
         public const string BlackWhitePalletDataMatrix = "Bmp/bit1datamatrix.bmp";
 
         public static readonly string[] BitFields =
-        {
-              Rgb32bfdef,
+        [
+            Rgb32bfdef,
               Rgb32bf,
               Rgb16565,
               Rgb16bfdef,
               Rgb16565pal,
-              Issue735,
-        };
+              Issue735
+        ];
 
         public static readonly string[] Miscellaneous =
-        {
+        [
             Car,
             F,
             NegHeight
-        };
+        ];
 
         public static readonly string[] Benchmark =
-        {
+        [
             Car,
             F,
             NegHeight,
@@ -487,7 +504,7 @@ public static class TestImages
             Bit16,
             Bit16Inverted,
             Bit32Rgb
-        };
+        ];
     }
 
     public static class Gif
@@ -508,6 +525,31 @@ public static class TestImages
         public const string Bit18RGBCube = "Gif/18-bit_RGB_Cube.gif";
         public const string Global256NoTrans = "Gif/global-256-no-trans.gif";
 
+        // Test images from: https://github.com/peterdn/gif-test-suite.git
+        // Animated gif with 4 frames, looping forever, no transparency.
+        public const string AnimatedLoop = "Gif/animated_loop.gif";
+
+        // Animated gif with 4 frames, interlaced, looping forever, no transparency.
+        public const string AnimatedLoopInterlaced = "Gif/animated_loop_interlaced.gif";
+
+        // Transparent gif with 4 frames, loops forever.
+        public const string AnimatedTransparentLoop = "Gif/animated_transparent_loop.gif";
+
+        // Transparent gif with 4 frames, loops forever, first frame restore previous.
+        public const string AnimatedTransparentFirstFrameRestorePrev = "Gif/animated_transparent_firstframerestoreprev_loop.gif";
+
+        // Transparent gif with 4 transparent frames, loops forever, no dispose
+        public const string AnimatedTransparentNoRestore = "Gif/animated_transparent_frame_norestore_loop.gif";
+
+        // Transparent gif with 4 transparent frames, loops forever, restore previous.
+        public const string AnimatedTransparentRestorePrevious = "Gif/animated_transparent_frame_restoreprev_loop.gif";
+
+        // Static gif with no animation, no transparency.
+        public const string StaticNontransparent = "Gif/static_nontransparent.gif";
+
+        // Static transparent gif with no animation.
+        public const string StaticTransparent = "Gif/static_transparent.gif";
+
         // Test images from https://github.com/robert-ancell/pygif/tree/master/test-suite
         public const string ZeroSize = "Gif/image-zero-size.gif";
         public const string ZeroHeight = "Gif/image-zero-height.gif";
@@ -536,12 +578,14 @@ public static class TestImages
             public const string Issue2450_B = "Gif/issues/issue_2450_2.gif";
             public const string Issue2198 = "Gif/issues/issue_2198.gif";
             public const string Issue2758 = "Gif/issues/issue_2758.gif";
+            public const string Issue2866 = "Gif/issues/issue_2866.gif";
             public const string Issue2859_A = "Gif/issues/issue_2859_A.gif";
             public const string Issue2859_B = "Gif/issues/issue_2859_B.gif";
+            public const string Issue2953 = "Gif/issues/issue_2953.gif";
         }
 
         public static readonly string[] Animated =
-        {
+        [
             M4nb,
             Giphy,
             Cheers,
@@ -560,7 +604,7 @@ public static class TestImages
             Issues.Issue1530,
             Bit18RGBCube,
             Global256NoTrans
-        };
+        ];
     }
 
     public static class Tga
@@ -830,7 +874,15 @@ public static class TestImages
             public const string Issue2670 = "Webp/issues/Issue2670.webp";
             public const string Issue2763 = "Webp/issues/Issue2763.png";
             public const string Issue2801 = "Webp/issues/Issue2801.webp";
+            public const string Issue2866 = "Webp/issues/Issue2866.webp";
+            public const string Issue2925 = "Webp/issues/Issue2925.webp";
+            public const string Issue2906 = "Webp/issues/Issue2906.webp";
         }
+
+        public const string AlphaBlend = "Webp/alpha-blend.webp";
+        public const string AlphaBlend2 = "Webp/alpha-blend-2.webp";
+        public const string AlphaBlend3 = "Webp/alpha-blend-3.webp";
+        public const string AlphaBlend4 = "Webp/alpha-blend-4.webp";
     }
 
     public static class Tiff
@@ -988,6 +1040,36 @@ public static class TestImages
         public const string QuadTile = "Tiff/quad-tile.tiff";
         public const string TiledChunky = "Tiff/rgb_uncompressed_tiled_chunky.tiff";
         public const string TiledPlanar = "Tiff/rgb_uncompressed_tiled_planar.tiff";
+        public const string TiledRgbaDeflateCompressedWithPredictor = "Tiff/tiled_rgba_deflate_compressed_predictor.tiff";
+        public const string TiledRgbDeflateCompressedWithPredictor = "Tiff/tiled_rgb_deflate_compressed_predictor.tiff";
+        public const string TiledGrayDeflateCompressedWithPredictor = "Tiff/tiled_gray_deflate_compressed_predictor.tiff";
+        public const string TiledGray16BitLittleEndianDeflateCompressedWithPredictor = "Tiff/tiled_gray_16bit_little_endian_deflate_compressed_predictor.tiff";
+        public const string TiledGray16BitBigEndianDeflateCompressedWithPredictor = "Tiff/tiled_gray_16bit_big_endian_deflate_compressed_predictor.tiff";
+        public const string TiledGray32BitLittleEndianDeflateCompressedWithPredictor = "Tiff/tiled_gray_32bit_little_endian_deflate_compressed_predictor.tiff";
+        public const string TiledGray32BitBigEndianDeflateCompressedWithPredictor = "Tiff/tiled_gray_32bit_big_endian_deflate_compressed_predictor.tiff";
+        public const string TiledRgb48BitLittleEndianDeflateCompressedWithPredictor = "Tiff/tiled_rgb_48bit_little_endian_deflate_compressed_predictor.tiff";
+        public const string TiledRgb48BitBigEndianDeflateCompressedWithPredictor = "Tiff/tiled_rgb_48bit_big_endian_deflate_compressed_predictor.tiff";
+        public const string TiledRgba64BitLittleEndianDeflateCompressedWithPredictor = "Tiff/tiled_rgba_64bit_little_endian_deflate_compressed_predictor.tiff";
+        public const string TiledRgba64BitBigEndianDeflateCompressedWithPredictor = "Tiff/tiled_rgba_64bit_big_endian_deflate_compressed_predictor.tiff";
+        public const string TiledRgb96BitLittleEndianDeflateCompressedWithPredictor = "Tiff/tiled_rgb_96bit_little_endian_deflate_compressed_predictor.tiff";
+        public const string TiledRgb96BitBigEndianDeflateCompressedWithPredictor = "Tiff/tiled_rgb_96bit_big_endian_deflate_compressed_predictor.tiff";
+        public const string TiledRgba128BitLittleEndianDeflateCompressedWithPredictor = "Tiff/tiled_rgba_128bit_little_endian_deflate_compressed_predictor.tiff";
+        public const string TiledRgba128BitBigEndianDeflateCompressedWithPredictor = "Tiff/tiled_rgba_128bit_big_endian_deflate_compressed_predictor.tiff";
+        public const string TiledRgbaLzwCompressedWithPredictor = "Tiff/tiled_rgba_lzw_compressed_predictor.tiff";
+        public const string TiledRgbLzwCompressedWithPredictor = "Tiff/tiled_rgb_lzw_compressed_predictor.tiff";
+        public const string TiledGrayLzwCompressedWithPredictor = "Tiff/tiled_gray_lzw_compressed_predictor.tiff";
+        public const string TiledGray16BitLittleEndianLzwCompressedWithPredictor = "Tiff/tiled_gray_16bit_little_endian_lzw_compressed_predictor.tiff";
+        public const string TiledGray16BitBigEndianLzwCompressedWithPredictor = "Tiff/tiled_gray_16bit_big_endian_lzw_compressed_predictor.tiff";
+        public const string TiledGray32BitLittleEndianLzwCompressedWithPredictor = "Tiff/tiled_gray_32bit_little_endian_lzw_compressed_predictor.tiff";
+        public const string TiledGray32BitBigEndianLzwCompressedWithPredictor = "Tiff/tiled_gray_32bit_big_endian_lzw_compressed_predictor.tiff";
+        public const string TiledRgb48BitLittleEndianLzwCompressedWithPredictor = "Tiff/tiled_rgb_48bit_little_endian_lzw_compressed_predictor.tiff";
+        public const string TiledRgb48BitBigEndianLzwCompressedWithPredictor = "Tiff/tiled_rgb_48bit_big_endian_lzw_compressed_predictor.tiff";
+        public const string TiledRgba64BitLittleEndianLzwCompressedWithPredictor = "Tiff/tiled_rgba_64bit_little_endian_lzw_compressed_predictor.tiff";
+        public const string TiledRgba64BitBigEndianLzwCompressedWithPredictor = "Tiff/tiled_rgba_64bit_big_endian_lzw_compressed_predictor.tiff";
+        public const string TiledRgb96BitLittleEndianLzwCompressedWithPredictor = "Tiff/tiled_rgb_96bit_little_endian_lzw_compressed_predictor.tiff";
+        public const string TiledRgb96BitBigEndianLzwCompressedWithPredictor = "Tiff/tiled_rgb_96bit_big_endian_lzw_compressed_predictor.tiff";
+        public const string TiledRgba128BitLittleEndianLzwCompressedWithPredictor = "Tiff/tiled_rgba_128bit_little_endian_lzw_compressed_predictor.tiff";
+        public const string TiledRgba128BitBigEndianLzwCompressedWithPredictor = "Tiff/tiled_rgba_128bit_big_endian_lzw_compressed_predictor.tiff";
 
         // Images with alpha channel.
         public const string Rgba2BitUnassociatedAlpha = "Tiff/RgbaUnassociatedAlpha2bit.tiff";
@@ -1042,6 +1124,7 @@ public static class TestImages
         public const string Cmyk = "Tiff/Cmyk.tiff";
         public const string Cmyk64BitDeflate = "Tiff/cmyk_deflate_64bit.tiff";
         public const string CmykLzwPredictor = "Tiff/Cmyk-lzw-predictor.tiff";
+        public const string CmykJpeg = "Tiff/Cmyk-jpeg.tiff";
 
         public const string Issues1716Rgb161616BitLittleEndian = "Tiff/Issues/Issue1716.tiff";
         public const string Issues1891 = "Tiff/Issues/Issue1891.tiff";
@@ -1049,10 +1132,13 @@ public static class TestImages
         public const string Issues2149 = "Tiff/Issues/Group4CompressionWithStrips.tiff";
         public const string Issues2255 = "Tiff/Issues/Issue2255.png";
         public const string Issues2435 = "Tiff/Issues/Issue2435.tiff";
+        public const string Issues2454_A = "Tiff/Issues/Issue2454_A.tif";
+        public const string Issues2454_B = "Tiff/Issues/Issue2454_B.tif";
         public const string Issues2587 = "Tiff/Issues/Issue2587.tiff";
         public const string Issues2679 = "Tiff/Issues/Issue2679.tiff";
         public const string JpegCompressedGray0000539558 = "Tiff/Issues/JpegCompressedGray-0000539558.tiff";
         public const string Tiled0000023664 = "Tiff/Issues/tiled-0000023664.tiff";
+        public const string ExtraSamplesUnspecified = "Tiff/Issues/ExtraSamplesUnspecified.tif";
 
         public const string SmallRgbDeflate = "Tiff/rgb_small_deflate.tiff";
         public const string SmallRgbLzw = "Tiff/rgb_small_lzw.tiff";
@@ -1076,9 +1162,12 @@ public static class TestImages
         public const string InvalidIptcData = "Tiff/7324fcaff3aad96f27899da51c1bb5d9.tiff";
         public const string IptcData = "Tiff/iptc.tiff";
 
-        public static readonly string[] Multiframes = { MultiframeDeflateWithPreview, MultiframeLzwPredictor /*, MultiFrameDifferentSize, MultiframeDifferentSizeTiled, MultiFrameDifferentVariants,*/ };
+        public const string Issue2909 = "Tiff/Issues/Issue2909.tiff";
+
+        public static readonly string[] Multiframes = [MultiframeDeflateWithPreview, MultiframeLzwPredictor /*, MultiFrameDifferentSize, MultiframeDifferentSizeTiled, MultiFrameDifferentVariants,*/
+        ];
 
-        public static readonly string[] Metadata = { SampleMetadata };
+        public static readonly string[] Metadata = [SampleMetadata];
     }
 
     public static class BigTiff
diff --git a/tests/ImageSharp.Tests/TestUtilities/ArrayHelper.cs b/tests/ImageSharp.Tests/TestUtilities/ArrayHelper.cs
index 8ff2abd90b..90a98d1c81 100644
--- a/tests/ImageSharp.Tests/TestUtilities/ArrayHelper.cs
+++ b/tests/ImageSharp.Tests/TestUtilities/ArrayHelper.cs
@@ -13,7 +13,7 @@ public static class ArrayHelper
     /// <returns>The concatenated array</returns>
     public static T[] Concat<T>(params T[][] arrays)
     {
-        var result = new T[arrays.Sum(t => t.Length)];
+        T[] result = new T[arrays.Sum(t => t.Length)];
         int offset = 0;
         for (int i = 0; i < arrays.Length; i++)
         {
@@ -33,7 +33,7 @@ public static class ArrayHelper
     /// <returns>The created array filled with the given value</returns>
     public static T[] Fill<T>(T value, int length)
     {
-        var result = new T[length];
+        T[] result = new T[length];
         for (int i = 0; i < length; i++)
         {
             result[i] = value;
diff --git a/tests/ImageSharp.Tests/TestUtilities/Attributes/ImageDataAttributeBase.cs b/tests/ImageSharp.Tests/TestUtilities/Attributes/ImageDataAttributeBase.cs
index 592ebb4ebe..7191f3ba74 100644
--- a/tests/ImageSharp.Tests/TestUtilities/Attributes/ImageDataAttributeBase.cs
+++ b/tests/ImageSharp.Tests/TestUtilities/Attributes/ImageDataAttributeBase.cs
@@ -70,7 +70,7 @@ public abstract class ImageDataAttributeBase : DataAttribute
 
         if (!addedRows.Any())
         {
-            addedRows = new[] { Array.Empty<object>() };
+            addedRows = [[]];
         }
 
         bool firstIsProvider = this.FirstIsProvider(testMethod);
diff --git a/tests/ImageSharp.Tests/TestUtilities/Attributes/WithBasicTestPatternImagesAttribute.cs b/tests/ImageSharp.Tests/TestUtilities/Attributes/WithBasicTestPatternImagesAttribute.cs
index d82d5cd910..349db60f20 100644
--- a/tests/ImageSharp.Tests/TestUtilities/Attributes/WithBasicTestPatternImagesAttribute.cs
+++ b/tests/ImageSharp.Tests/TestUtilities/Attributes/WithBasicTestPatternImagesAttribute.cs
@@ -31,5 +31,6 @@ public class WithBasicTestPatternImagesAttribute : ImageDataAttributeBase
 
     protected override string GetFactoryMethodName(MethodInfo testMethod) => "BasicTestPattern";
 
-    protected override object[] GetFactoryMethodArgs(MethodInfo testMethod, Type factoryType) => new object[] { this.Width, this.Height };
+    protected override object[] GetFactoryMethodArgs(MethodInfo testMethod, Type factoryType) => [this.Width, this.Height
+    ];
 }
diff --git a/tests/ImageSharp.Tests/TestUtilities/Attributes/WithBlankImagesAttribute.cs b/tests/ImageSharp.Tests/TestUtilities/Attributes/WithBlankImagesAttribute.cs
index e9f57a7abe..ec637a7b6b 100644
--- a/tests/ImageSharp.Tests/TestUtilities/Attributes/WithBlankImagesAttribute.cs
+++ b/tests/ImageSharp.Tests/TestUtilities/Attributes/WithBlankImagesAttribute.cs
@@ -46,5 +46,6 @@ public class WithBlankImagesAttribute : ImageDataAttributeBase
 
     protected override string GetFactoryMethodName(MethodInfo testMethod) => "Blank";
 
-    protected override object[] GetFactoryMethodArgs(MethodInfo testMethod, Type factoryType) => new object[] { this.Width, this.Height };
+    protected override object[] GetFactoryMethodArgs(MethodInfo testMethod, Type factoryType) => [this.Width, this.Height
+    ];
 }
diff --git a/tests/ImageSharp.Tests/TestUtilities/Attributes/WithFileAttribute.cs b/tests/ImageSharp.Tests/TestUtilities/Attributes/WithFileAttribute.cs
index cf472699a7..3392d97ab9 100644
--- a/tests/ImageSharp.Tests/TestUtilities/Attributes/WithFileAttribute.cs
+++ b/tests/ImageSharp.Tests/TestUtilities/Attributes/WithFileAttribute.cs
@@ -39,7 +39,7 @@ public class WithFileAttribute : ImageDataAttributeBase
         this.fileName = fileName;
     }
 
-    protected override object[] GetFactoryMethodArgs(MethodInfo testMethod, Type factoryType) => new object[] { this.fileName };
+    protected override object[] GetFactoryMethodArgs(MethodInfo testMethod, Type factoryType) => [this.fileName];
 
     protected override string GetFactoryMethodName(MethodInfo testMethod) => "File";
 }
diff --git a/tests/ImageSharp.Tests/TestUtilities/Attributes/WithFileCollectionAttribute.cs b/tests/ImageSharp.Tests/TestUtilities/Attributes/WithFileCollectionAttribute.cs
index 57949e7b11..87f6f0479d 100644
--- a/tests/ImageSharp.Tests/TestUtilities/Attributes/WithFileCollectionAttribute.cs
+++ b/tests/ImageSharp.Tests/TestUtilities/Attributes/WithFileCollectionAttribute.cs
@@ -58,7 +58,7 @@ public class WithFileCollectionAttribute : ImageDataAttributeBase
         Func<object> accessor = this.GetPropertyAccessor(testMethod.DeclaringType, this.fileEnumeratorMemberName);
         accessor = accessor ?? this.GetFieldAccessor(testMethod.DeclaringType, this.fileEnumeratorMemberName);
 
-        var files = (IEnumerable<string>)accessor();
+        IEnumerable<string> files = (IEnumerable<string>)accessor();
         return files.Select(f => new object[] { f });
     }
 
diff --git a/tests/ImageSharp.Tests/TestUtilities/Attributes/WithMemberFactoryAttribute.cs b/tests/ImageSharp.Tests/TestUtilities/Attributes/WithMemberFactoryAttribute.cs
index cd27eaf0ba..59c092b409 100644
--- a/tests/ImageSharp.Tests/TestUtilities/Attributes/WithMemberFactoryAttribute.cs
+++ b/tests/ImageSharp.Tests/TestUtilities/Attributes/WithMemberFactoryAttribute.cs
@@ -29,7 +29,7 @@ public class WithMemberFactoryAttribute : ImageDataAttributeBase
 
     protected override object[] GetFactoryMethodArgs(MethodInfo testMethod, Type factoryType)
     {
-        return new object[] { testMethod.DeclaringType.FullName, this.memberMethodName };
+        return [testMethod.DeclaringType.FullName, this.memberMethodName];
     }
 
     protected override string GetFactoryMethodName(MethodInfo testMethod) => "Lambda";
diff --git a/tests/ImageSharp.Tests/TestUtilities/Attributes/WithSolidFilledImagesAttribute.cs b/tests/ImageSharp.Tests/TestUtilities/Attributes/WithSolidFilledImagesAttribute.cs
index a4149f7356..cc4f6f7f3c 100644
--- a/tests/ImageSharp.Tests/TestUtilities/Attributes/WithSolidFilledImagesAttribute.cs
+++ b/tests/ImageSharp.Tests/TestUtilities/Attributes/WithSolidFilledImagesAttribute.cs
@@ -160,7 +160,7 @@ public class WithSolidFilledImagesAttribute : WithBlankImagesAttribute
     public byte A { get; }
 
     protected override object[] GetFactoryMethodArgs(MethodInfo testMethod, Type factoryType)
-        => new object[] { this.Width, this.Height, this.R, this.G, this.B, this.A };
+        => [this.Width, this.Height, this.R, this.G, this.B, this.A];
 
     protected override string GetFactoryMethodName(MethodInfo testMethod) => "Solid";
 }
diff --git a/tests/ImageSharp.Tests/TestUtilities/Attributes/WithTestPatternImagesAttribute.cs b/tests/ImageSharp.Tests/TestUtilities/Attributes/WithTestPatternImagesAttribute.cs
index 4b016d5eae..2630acea80 100644
--- a/tests/ImageSharp.Tests/TestUtilities/Attributes/WithTestPatternImagesAttribute.cs
+++ b/tests/ImageSharp.Tests/TestUtilities/Attributes/WithTestPatternImagesAttribute.cs
@@ -50,5 +50,6 @@ public class WithTestPatternImagesAttribute : ImageDataAttributeBase
 
     protected override string GetFactoryMethodName(MethodInfo testMethod) => "TestPattern";
 
-    protected override object[] GetFactoryMethodArgs(MethodInfo testMethod, Type factoryType) => new object[] { this.Width, this.Height };
+    protected override object[] GetFactoryMethodArgs(MethodInfo testMethod, Type factoryType) => [this.Width, this.Height
+    ];
 }
diff --git a/tests/ImageSharp.Tests/TestUtilities/ByteArrayUtility.cs b/tests/ImageSharp.Tests/TestUtilities/ByteArrayUtility.cs
index 963c3c7835..2fb75444e3 100644
--- a/tests/ImageSharp.Tests/TestUtilities/ByteArrayUtility.cs
+++ b/tests/ImageSharp.Tests/TestUtilities/ByteArrayUtility.cs
@@ -11,7 +11,7 @@ public static class ByteArrayUtility
     {
         if (isLittleEndian != BitConverter.IsLittleEndian)
         {
-            var reversedBytes = new byte[bytes.Length];
+            byte[] reversedBytes = new byte[bytes.Length];
             Array.Copy(bytes, reversedBytes, bytes.Length);
             Array.Reverse(reversedBytes);
             return reversedBytes;
diff --git a/tests/ImageSharp.Tests/TestUtilities/ByteBuffer.cs b/tests/ImageSharp.Tests/TestUtilities/ByteBuffer.cs
index 45e1425c75..548354450c 100644
--- a/tests/ImageSharp.Tests/TestUtilities/ByteBuffer.cs
+++ b/tests/ImageSharp.Tests/TestUtilities/ByteBuffer.cs
@@ -8,7 +8,7 @@ using System.Collections.Generic;
 
 public class ByteBuffer
 {
-    private readonly List<byte> bytes = new List<byte>();
+    private readonly List<byte> bytes = new();
     private readonly bool isLittleEndian;
 
     public ByteBuffer(bool isLittleEndian)
diff --git a/tests/ImageSharp.Tests/TestUtilities/ImageComparison/ExactImageComparer.cs b/tests/ImageSharp.Tests/TestUtilities/ImageComparison/ExactImageComparer.cs
index 92fc06eff5..c6bb38dd83 100644
--- a/tests/ImageSharp.Tests/TestUtilities/ImageComparison/ExactImageComparer.cs
+++ b/tests/ImageSharp.Tests/TestUtilities/ImageComparison/ExactImageComparer.cs
@@ -8,7 +8,7 @@ namespace SixLabors.ImageSharp.Tests.TestUtilities.ImageComparison;
 
 public class ExactImageComparer : ImageComparer
 {
-    public static ExactImageComparer Instance { get; } = new ExactImageComparer();
+    public static ExactImageComparer Instance { get; } = new();
 
     public override ImageSimilarityReport<TPixelA, TPixelB> CompareImagesOrFrames<TPixelA, TPixelB>(
         int index,
@@ -23,10 +23,10 @@ public class ExactImageComparer : ImageComparer
         int width = actual.Width;
 
         // TODO: Comparing through Rgba64 may not be robust enough because of the existence of super high precision pixel types.
-        var aBuffer = new Rgba64[width];
-        var bBuffer = new Rgba64[width];
+        Rgba64[] aBuffer = new Rgba64[width];
+        Rgba64[] bBuffer = new Rgba64[width];
 
-        var differences = new List<PixelDifference>();
+        List<PixelDifference> differences = [];
         Configuration configuration = expected.Configuration;
         Buffer2D<TPixelA> expectedBuffer = expected.PixelBuffer;
         Buffer2D<TPixelB> actualBuffer = actual.PixelBuffer;
@@ -46,7 +46,7 @@ public class ExactImageComparer : ImageComparer
 
                 if (aPixel != bPixel)
                 {
-                    var diff = new PixelDifference(new Point(x, y), aPixel, bPixel);
+                    PixelDifference diff = new(new Point(x, y), aPixel, bPixel);
                     differences.Add(diff);
                 }
             }
diff --git a/tests/ImageSharp.Tests/TestUtilities/ImageComparison/ImageComparer.cs b/tests/ImageSharp.Tests/TestUtilities/ImageComparison/ImageComparer.cs
index 7153674e6b..d7352de580 100644
--- a/tests/ImageSharp.Tests/TestUtilities/ImageComparison/ImageComparer.cs
+++ b/tests/ImageSharp.Tests/TestUtilities/ImageComparison/ImageComparer.cs
@@ -51,7 +51,7 @@ public static class ImageComparerExtensions
         where TPixelA : unmanaged, IPixel<TPixelA>
         where TPixelB : unmanaged, IPixel<TPixelB>
     {
-        List<ImageSimilarityReport<TPixelA, TPixelB>> result = new();
+        List<ImageSimilarityReport<TPixelA, TPixelB>> result = [];
 
         int expectedFrameCount = actual.Frames.Count;
         if (predicate != null)
@@ -147,7 +147,7 @@ public static class ImageComparerExtensions
         IEnumerable<ImageSimilarityReport<TPixelA, TPixelB>> reports = comparer.CompareImages(expected, actual);
         if (reports.Any())
         {
-            var cleanedReports = new List<ImageSimilarityReport<TPixelA, TPixelB>>(reports.Count());
+            List<ImageSimilarityReport<TPixelA, TPixelB>> cleanedReports = new(reports.Count());
             foreach (ImageSimilarityReport<TPixelA, TPixelB> r in reports)
             {
                 IEnumerable<PixelDifference> outsideChanges = r.Differences.Where(
diff --git a/tests/ImageSharp.Tests/TestUtilities/ImageComparison/ImageSimilarityReport.cs b/tests/ImageSharp.Tests/TestUtilities/ImageComparison/ImageSimilarityReport.cs
index c50ae5e219..1594258e04 100644
--- a/tests/ImageSharp.Tests/TestUtilities/ImageComparison/ImageSimilarityReport.cs
+++ b/tests/ImageSharp.Tests/TestUtilities/ImageComparison/ImageSimilarityReport.cs
@@ -61,7 +61,7 @@ public class ImageSimilarityReport
 
     private string PrintDifference()
     {
-        var sb = new StringBuilder();
+        StringBuilder sb = new();
         if (this.TotalNormalizedDifference.HasValue)
         {
             sb.AppendLine();
@@ -103,7 +103,7 @@ public class ImageSimilarityReport<TPixelA, TPixelB> : ImageSimilarityReport
     }
 
     public static ImageSimilarityReport<TPixelA, TPixelB> Empty =>
-        new ImageSimilarityReport<TPixelA, TPixelB>(0, null, null, Enumerable.Empty<PixelDifference>(), 0f);
+        new(0, null, null, Enumerable.Empty<PixelDifference>(), 0f);
 
     public new ImageFrame<TPixelA> ExpectedImage => (ImageFrame<TPixelA>)base.ExpectedImage;
 
diff --git a/tests/ImageSharp.Tests/TestUtilities/ImageComparison/TolerantImageComparer.cs b/tests/ImageSharp.Tests/TestUtilities/ImageComparison/TolerantImageComparer.cs
index d057267da7..47cf7e6a5d 100644
--- a/tests/ImageSharp.Tests/TestUtilities/ImageComparison/TolerantImageComparer.cs
+++ b/tests/ImageSharp.Tests/TestUtilities/ImageComparison/TolerantImageComparer.cs
@@ -65,12 +65,12 @@ public class TolerantImageComparer : ImageComparer
         int width = actual.Width;
 
         // TODO: Comparing through Rgba64 may not robust enough because of the existence of super high precision pixel types.
-        var aBuffer = new Rgba64[width];
-        var bBuffer = new Rgba64[width];
+        Rgba64[] aBuffer = new Rgba64[width];
+        Rgba64[] bBuffer = new Rgba64[width];
 
         float totalDifference = 0F;
 
-        var differences = new List<PixelDifference>();
+        List<PixelDifference> differences = [];
         Configuration configuration = expected.Configuration;
         Buffer2D<TPixelA> expectedBuffer = expected.PixelBuffer;
         Buffer2D<TPixelB> actualBuffer = actual.PixelBuffer;
@@ -89,7 +89,7 @@ public class TolerantImageComparer : ImageComparer
 
                 if (d > this.PerPixelManhattanThreshold)
                 {
-                    var diff = new PixelDifference(new Point(x, y), aBuffer[x], bBuffer[x]);
+                    PixelDifference diff = new(new Point(x, y), aBuffer[x], bBuffer[x]);
                     differences.Add(diff);
 
                     totalDifference += d;
diff --git a/tests/ImageSharp.Tests/TestUtilities/ImageProviders/BlankProvider.cs b/tests/ImageSharp.Tests/TestUtilities/ImageProviders/BlankProvider.cs
index 5a31707bf9..c8c3e09c34 100644
--- a/tests/ImageSharp.Tests/TestUtilities/ImageProviders/BlankProvider.cs
+++ b/tests/ImageSharp.Tests/TestUtilities/ImageProviders/BlankProvider.cs
@@ -33,7 +33,7 @@ public abstract partial class TestImageProvider<TPixel> : IXunitSerializable
 
         protected int Width { get; private set; }
 
-        public override Image<TPixel> GetImage() => new Image<TPixel>(this.Configuration, this.Width, this.Height);
+        public override Image<TPixel> GetImage() => new(this.Configuration, this.Width, this.Height);
 
         public override void Deserialize(IXunitSerializationInfo info)
         {
diff --git a/tests/ImageSharp.Tests/TestUtilities/ImageProviders/FileProvider.cs b/tests/ImageSharp.Tests/TestUtilities/ImageProviders/FileProvider.cs
index 3652d77a1e..3f6e78a348 100644
--- a/tests/ImageSharp.Tests/TestUtilities/ImageProviders/FileProvider.cs
+++ b/tests/ImageSharp.Tests/TestUtilities/ImageProviders/FileProvider.cs
@@ -45,7 +45,7 @@ public abstract partial class TestImageProvider<TPixel> : IXunitSerializable
             {
                 Type type = options.GetType();
 
-                var data = new Dictionary<string, object>();
+                Dictionary<string, object> data = new();
 
                 while (type != null && type != typeof(object))
                 {
@@ -196,7 +196,7 @@ public abstract partial class TestImageProvider<TPixel> : IXunitSerializable
                 return this.DecodeImage(decoder, options);
             }
 
-            var key = new Key(this.PixelType, this.FilePath, decoder, options, null);
+            Key key = new(this.PixelType, this.FilePath, decoder, options, null);
             Image<TPixel> cachedImage = Cache.GetOrAdd(key, _ => this.DecodeImage(decoder, options));
 
             return cachedImage.Clone(this.Configuration);
@@ -233,7 +233,7 @@ public abstract partial class TestImageProvider<TPixel> : IXunitSerializable
                 return this.DecodeImage(decoder, options);
             }
 
-            var key = new Key(this.PixelType, this.FilePath, decoder, options.GeneralOptions, options);
+            Key key = new(this.PixelType, this.FilePath, decoder, options.GeneralOptions, options);
             Image<TPixel> cachedImage = Cache.GetOrAdd(key, _ => this.DecodeImage(decoder, options));
 
             return cachedImage.Clone(this.Configuration);
@@ -270,7 +270,7 @@ public abstract partial class TestImageProvider<TPixel> : IXunitSerializable
         {
             options.SetConfiguration(this.Configuration);
 
-            var testFile = TestFile.Create(this.FilePath);
+            TestFile testFile = TestFile.Create(this.FilePath);
             using Stream stream = new MemoryStream(testFile.Bytes);
             return decoder.Decode<TPixel>(options, stream);
         }
@@ -280,7 +280,7 @@ public abstract partial class TestImageProvider<TPixel> : IXunitSerializable
         {
             options.GeneralOptions.SetConfiguration(this.Configuration);
 
-            var testFile = TestFile.Create(this.FilePath);
+            TestFile testFile = TestFile.Create(this.FilePath);
             using Stream stream = new MemoryStream(testFile.Bytes);
             return decoder.Decode<TPixel>(options, stream);
         }
@@ -288,7 +288,7 @@ public abstract partial class TestImageProvider<TPixel> : IXunitSerializable
 
     public static string GetFilePathOrNull(ITestImageProvider provider)
     {
-        var fileProvider = provider as FileProvider;
+        FileProvider fileProvider = provider as FileProvider;
         return fileProvider?.FilePath;
     }
 }
diff --git a/tests/ImageSharp.Tests/TestUtilities/ImageProviders/MemberMethodProvider.cs b/tests/ImageSharp.Tests/TestUtilities/ImageProviders/MemberMethodProvider.cs
index 390195274f..6da5b75f0d 100644
--- a/tests/ImageSharp.Tests/TestUtilities/ImageProviders/MemberMethodProvider.cs
+++ b/tests/ImageSharp.Tests/TestUtilities/ImageProviders/MemberMethodProvider.cs
@@ -54,7 +54,7 @@ public abstract partial class TestImageProvider<TPixel> : IXunitSerializable
 
         private Func<Image<TPixel>> GetFactory()
         {
-            var declaringType = Type.GetType(this.declaringTypeName);
+            Type declaringType = Type.GetType(this.declaringTypeName);
             MethodInfo m = declaringType.GetMethod(this.methodName);
             Type pixelType = typeof(TPixel);
             Type imgType = typeof(Image<>).MakeGenericType(pixelType);
diff --git a/tests/ImageSharp.Tests/TestUtilities/ImageProviders/TestImageProvider.cs b/tests/ImageSharp.Tests/TestUtilities/ImageProviders/TestImageProvider.cs
index 8f22fb2b29..ab624126b9 100644
--- a/tests/ImageSharp.Tests/TestUtilities/ImageProviders/TestImageProvider.cs
+++ b/tests/ImageSharp.Tests/TestUtilities/ImageProviders/TestImageProvider.cs
@@ -88,10 +88,10 @@ public abstract partial class TestImageProvider<TPixel> : ITestImageProvider, IX
     public abstract Image<TPixel> GetImage();
 
     public Image<TPixel> GetImage(IImageDecoder decoder)
-        => this.GetImage(decoder, new());
+        => this.GetImage(decoder, new DecoderOptions());
 
     public Task<Image<TPixel>> GetImageAsync(IImageDecoder decoder)
-         => this.GetImageAsync(decoder, new());
+         => this.GetImageAsync(decoder, new DecoderOptions());
 
     public virtual Image<TPixel> GetImage(IImageDecoder decoder, DecoderOptions options)
         => throw new NotSupportedException($"Decoder specific GetImage() is not supported with {this.GetType().Name}!");
diff --git a/tests/ImageSharp.Tests/TestUtilities/ImagingTestCaseUtility.cs b/tests/ImageSharp.Tests/TestUtilities/ImagingTestCaseUtility.cs
index 78e5c90204..73777ef60a 100644
--- a/tests/ImageSharp.Tests/TestUtilities/ImagingTestCaseUtility.cs
+++ b/tests/ImageSharp.Tests/TestUtilities/ImagingTestCaseUtility.cs
@@ -50,8 +50,8 @@ public class ImagingTestCaseUtility
         }
 
         string fn = appendSourceFileOrDescription
-                        ? Path.GetFileNameWithoutExtension(this.SourceFileOrDescription)
-                        : string.Empty;
+            ? Path.GetFileNameWithoutExtension(this.SourceFileOrDescription)
+            : string.Empty;
 
         if (string.IsNullOrWhiteSpace(extension))
         {
@@ -63,7 +63,7 @@ public class ImagingTestCaseUtility
             extension = ".bmp";
         }
 
-        extension = extension.ToLower(CultureInfo.InvariantCulture);
+        extension = extension.ToLowerInvariant();
 
         if (extension[0] != '.')
         {
diff --git a/tests/ImageSharp.Tests/TestUtilities/MeasureFixture.cs b/tests/ImageSharp.Tests/TestUtilities/MeasureFixture.cs
index de42ba0ccf..81f16cf6b9 100644
--- a/tests/ImageSharp.Tests/TestUtilities/MeasureFixture.cs
+++ b/tests/ImageSharp.Tests/TestUtilities/MeasureFixture.cs
@@ -30,7 +30,7 @@ public class MeasureFixture
             this.Output?.WriteLine($"{operationName} X {times} ...");
         }
 
-        var sw = Stopwatch.StartNew();
+        Stopwatch sw = Stopwatch.StartNew();
 
         for (int i = 0; i < times; i++)
         {
@@ -60,7 +60,7 @@ public class MeasureGuard : IDisposable
 {
     private readonly string operation;
 
-    private readonly Stopwatch stopwatch = new Stopwatch();
+    private readonly Stopwatch stopwatch = new();
 
     public MeasureGuard(ITestOutputHelper output, string operation)
     {
diff --git a/tests/ImageSharp.Tests/TestUtilities/ReferenceCodecs/MagickReferenceDecoder.cs b/tests/ImageSharp.Tests/TestUtilities/ReferenceCodecs/MagickReferenceDecoder.cs
index 74015a4eff..862d4b64d3 100644
--- a/tests/ImageSharp.Tests/TestUtilities/ReferenceCodecs/MagickReferenceDecoder.cs
+++ b/tests/ImageSharp.Tests/TestUtilities/ReferenceCodecs/MagickReferenceDecoder.cs
@@ -32,15 +32,15 @@ public class MagickReferenceDecoder : ImageDecoder
         this.validate = validate;
     }
 
-    public static MagickReferenceDecoder Png { get; } = new MagickReferenceDecoder(PngFormat.Instance);
+    public static MagickReferenceDecoder Png { get; } = new(PngFormat.Instance);
 
-    public static MagickReferenceDecoder Bmp { get; } = new MagickReferenceDecoder(BmpFormat.Instance);
+    public static MagickReferenceDecoder Bmp { get; } = new(BmpFormat.Instance);
 
-    public static MagickReferenceDecoder Jpeg { get; } = new MagickReferenceDecoder(JpegFormat.Instance);
+    public static MagickReferenceDecoder Jpeg { get; } = new(JpegFormat.Instance);
 
-    public static MagickReferenceDecoder Tiff { get; } = new MagickReferenceDecoder(TiffFormat.Instance);
+    public static MagickReferenceDecoder Tiff { get; } = new(TiffFormat.Instance);
 
-    public static MagickReferenceDecoder WebP { get; } = new MagickReferenceDecoder(WebpFormat.Instance);
+    public static MagickReferenceDecoder WebP { get; } = new(WebpFormat.Instance);
 
     protected override Image<TPixel> Decode<TPixel>(DecoderOptions options, Stream stream, CancellationToken cancellationToken)
     {
@@ -64,22 +64,29 @@ public class MagickReferenceDecoder : ImageDecoder
         settings.SetDefines(pngReadDefines);
 
         using MagickImageCollection magickImageCollection = new(stream, settings);
+        int imageWidth = magickImageCollection.Max(x => x.Width);
+        int imageHeight = magickImageCollection.Max(x => x.Height);
+
         List<ImageFrame<TPixel>> framesList = [];
         foreach (IMagickImage<ushort> magicFrame in magickImageCollection)
         {
-            ImageFrame<TPixel> frame = new(configuration, (int)magicFrame.Width, (int)magicFrame.Height);
+            ImageFrame<TPixel> frame = new(configuration, imageWidth, imageHeight);
             framesList.Add(frame);
 
-            MemoryGroup<TPixel> framePixels = frame.PixelBuffer.FastMemoryGroup;
+            Buffer2DRegion<TPixel> buffer = frame.PixelBuffer.GetRegion(
+                imageWidth - magicFrame.Width,
+                imageHeight - magicFrame.Height,
+                magicFrame.Width,
+                magicFrame.Height);
 
             using IUnsafePixelCollection<ushort> pixels = magicFrame.GetPixelsUnsafe();
             if (magicFrame.Depth is 12 or 10 or 8 or 6 or 5 or 4 or 3 or 2 or 1)
             {
                 byte[] data = pixels.ToByteArray(PixelMapping.RGBA);
 
-                FromRgba32Bytes(configuration, data, framePixels);
+                FromRgba32Bytes(configuration, data, buffer);
             }
-            else if (magicFrame.Depth is 16 or 14)
+            else if (magicFrame.Depth is 14 or 16 or 32)
             {
                 if (this.imageFormat is PngFormat png)
                 {
@@ -88,7 +95,7 @@ public class MagickReferenceDecoder : ImageDecoder
 
                 ushort[] data = pixels.ToShortArray(PixelMapping.RGBA);
                 Span<byte> bytes = MemoryMarshal.Cast<ushort, byte>(data.AsSpan());
-                FromRgba64Bytes(configuration, bytes, framePixels);
+                FromRgba64Bytes(configuration, bytes, buffer);
             }
             else
             {
@@ -96,7 +103,7 @@ public class MagickReferenceDecoder : ImageDecoder
             }
         }
 
-        return ReferenceCodecUtilities.EnsureDecodedMetadata<TPixel>(new(configuration, metadata, framesList), this.imageFormat);
+        return ReferenceCodecUtilities.EnsureDecodedMetadata<TPixel>(new Image<TPixel>(configuration, metadata, framesList), this.imageFormat);
     }
 
     protected override Image Decode(DecoderOptions options, Stream stream, CancellationToken cancellationToken)
@@ -106,38 +113,45 @@ public class MagickReferenceDecoder : ImageDecoder
     {
         using Image<Rgba32> image = this.Decode<Rgba32>(options, stream, cancellationToken);
         ImageMetadata metadata = image.Metadata;
-        return new(image.Size, metadata, new List<ImageFrameMetadata>(image.Frames.Select(x => x.Metadata)))
+        return new ImageInfo(image.Size, metadata, new List<ImageFrameMetadata>(image.Frames.Select(x => x.Metadata)))
         {
             PixelType = metadata.GetDecodedPixelTypeInfo()
         };
     }
-
-    private static void FromRgba32Bytes<TPixel>(Configuration configuration, Span<byte> rgbaBytes, IMemoryGroup<TPixel> destinationGroup)
+    private static void FromRgba32Bytes<TPixel>(
+        Configuration configuration,
+        Span<byte> rgbaBytes,
+        Buffer2DRegion<TPixel> destinationGroup)
         where TPixel : unmanaged, ImageSharp.PixelFormats.IPixel<TPixel>
     {
         Span<Rgba32> sourcePixels = MemoryMarshal.Cast<byte, Rgba32>(rgbaBytes);
-        foreach (Memory<TPixel> m in destinationGroup)
+        for (int y = 0; y < destinationGroup.Height; y++)
         {
-            Span<TPixel> destBuffer = m.Span;
+            Span<TPixel> destBuffer = destinationGroup.DangerousGetRowSpan(y);
             PixelOperations<TPixel>.Instance.FromRgba32(
                 configuration,
                 sourcePixels[..destBuffer.Length],
                 destBuffer);
+
             sourcePixels = sourcePixels[destBuffer.Length..];
         }
     }
 
-    private static void FromRgba64Bytes<TPixel>(Configuration configuration, Span<byte> rgbaBytes, IMemoryGroup<TPixel> destinationGroup)
+    private static void FromRgba64Bytes<TPixel>(
+        Configuration configuration,
+        Span<byte> rgbaBytes,
+        Buffer2DRegion<TPixel> destinationGroup)
         where TPixel : unmanaged, ImageSharp.PixelFormats.IPixel<TPixel>
     {
-        foreach (Memory<TPixel> m in destinationGroup)
+        for (int y = 0; y < destinationGroup.Height; y++)
         {
-            Span<TPixel> destBuffer = m.Span;
+            Span<TPixel> destBuffer = destinationGroup.DangerousGetRowSpan(y);
             PixelOperations<TPixel>.Instance.FromRgba64Bytes(
                 configuration,
                 rgbaBytes,
                 destBuffer,
                 destBuffer.Length);
+
             rgbaBytes = rgbaBytes[(destBuffer.Length * 8)..];
         }
     }
diff --git a/tests/ImageSharp.Tests/TestUtilities/ReferenceCodecs/SystemDrawingBridge.cs b/tests/ImageSharp.Tests/TestUtilities/ReferenceCodecs/SystemDrawingBridge.cs
index 04f59979f7..84be9e3a9a 100644
--- a/tests/ImageSharp.Tests/TestUtilities/ReferenceCodecs/SystemDrawingBridge.cs
+++ b/tests/ImageSharp.Tests/TestUtilities/ReferenceCodecs/SystemDrawingBridge.cs
@@ -27,7 +27,7 @@ public static class SystemDrawingBridge
         int w = bmp.Width;
         int h = bmp.Height;
 
-        var fullRect = new System.Drawing.Rectangle(0, 0, w, h);
+        System.Drawing.Rectangle fullRect = new(0, 0, w, h);
 
         if (bmp.PixelFormat != PixelFormat.Format32bppArgb)
         {
@@ -37,7 +37,7 @@ public static class SystemDrawingBridge
         }
 
         BitmapData data = bmp.LockBits(fullRect, ImageLockMode.ReadWrite, bmp.PixelFormat);
-        var image = new Image<TPixel>(w, h);
+        Image<TPixel> image = new(w, h);
         try
         {
             byte* sourcePtrBase = (byte*)data.Scan0;
@@ -86,7 +86,7 @@ public static class SystemDrawingBridge
         int w = bmp.Width;
         int h = bmp.Height;
 
-        var fullRect = new System.Drawing.Rectangle(0, 0, w, h);
+        System.Drawing.Rectangle fullRect = new(0, 0, w, h);
 
         if (bmp.PixelFormat != PixelFormat.Format24bppRgb)
         {
@@ -96,7 +96,7 @@ public static class SystemDrawingBridge
         }
 
         BitmapData data = bmp.LockBits(fullRect, ImageLockMode.ReadWrite, bmp.PixelFormat);
-        var image = new Image<TPixel>(w, h);
+        Image<TPixel> image = new(w, h);
         try
         {
             byte* sourcePtrBase = (byte*)data.Scan0;
@@ -138,8 +138,8 @@ public static class SystemDrawingBridge
         int w = image.Width;
         int h = image.Height;
 
-        var resultBitmap = new Bitmap(w, h, PixelFormat.Format32bppArgb);
-        var fullRect = new System.Drawing.Rectangle(0, 0, w, h);
+        Bitmap resultBitmap = new(w, h, PixelFormat.Format32bppArgb);
+        System.Drawing.Rectangle fullRect = new(0, 0, w, h);
         BitmapData data = resultBitmap.LockBits(fullRect, ImageLockMode.ReadWrite, resultBitmap.PixelFormat);
         try
         {
diff --git a/tests/ImageSharp.Tests/TestUtilities/ReferenceCodecs/SystemDrawingReferenceDecoder.cs b/tests/ImageSharp.Tests/TestUtilities/ReferenceCodecs/SystemDrawingReferenceDecoder.cs
index 14a655823d..fce2da05f3 100644
--- a/tests/ImageSharp.Tests/TestUtilities/ReferenceCodecs/SystemDrawingReferenceDecoder.cs
+++ b/tests/ImageSharp.Tests/TestUtilities/ReferenceCodecs/SystemDrawingReferenceDecoder.cs
@@ -18,15 +18,15 @@ public class SystemDrawingReferenceDecoder : ImageDecoder
     public SystemDrawingReferenceDecoder(IImageFormat imageFormat)
         => this.imageFormat = imageFormat;
 
-    public static SystemDrawingReferenceDecoder Png { get; } = new SystemDrawingReferenceDecoder(PngFormat.Instance);
+    public static SystemDrawingReferenceDecoder Png { get; } = new(PngFormat.Instance);
 
-    public static SystemDrawingReferenceDecoder Bmp { get; } = new SystemDrawingReferenceDecoder(BmpFormat.Instance);
+    public static SystemDrawingReferenceDecoder Bmp { get; } = new(BmpFormat.Instance);
 
     protected override ImageInfo Identify(DecoderOptions options, Stream stream, CancellationToken cancellationToken)
     {
         using Image<Rgba32> image = this.Decode<Rgba32>(options, stream, cancellationToken);
         ImageMetadata metadata = image.Metadata;
-        return new(image.Size, metadata, new List<ImageFrameMetadata>(image.Frames.Select(x => x.Metadata)))
+        return new ImageInfo(image.Size, metadata, new List<ImageFrameMetadata>(image.Frames.Select(x => x.Metadata)))
         {
             PixelType = metadata.GetDecodedPixelTypeInfo()
         };
diff --git a/tests/ImageSharp.Tests/TestUtilities/ReferenceCodecs/SystemDrawingReferenceEncoder.cs b/tests/ImageSharp.Tests/TestUtilities/ReferenceCodecs/SystemDrawingReferenceEncoder.cs
index 0789ab2634..f9769b891e 100644
--- a/tests/ImageSharp.Tests/TestUtilities/ReferenceCodecs/SystemDrawingReferenceEncoder.cs
+++ b/tests/ImageSharp.Tests/TestUtilities/ReferenceCodecs/SystemDrawingReferenceEncoder.cs
@@ -15,9 +15,9 @@ public class SystemDrawingReferenceEncoder : IImageEncoder
     public SystemDrawingReferenceEncoder(ImageFormat imageFormat)
         => this.imageFormat = imageFormat;
 
-    public static SystemDrawingReferenceEncoder Png { get; } = new SystemDrawingReferenceEncoder(ImageFormat.Png);
+    public static SystemDrawingReferenceEncoder Png { get; } = new(ImageFormat.Png);
 
-    public static SystemDrawingReferenceEncoder Bmp { get; } = new SystemDrawingReferenceEncoder(ImageFormat.Bmp);
+    public static SystemDrawingReferenceEncoder Bmp { get; } = new(ImageFormat.Bmp);
 
     public bool SkipMetadata { get; init; }
 
diff --git a/tests/ImageSharp.Tests/TestUtilities/SixLaborsXunitTestFramework.cs b/tests/ImageSharp.Tests/TestUtilities/SixLaborsXunitTestFramework.cs
index edae08ce16..d8b0ff7856 100644
--- a/tests/ImageSharp.Tests/TestUtilities/SixLaborsXunitTestFramework.cs
+++ b/tests/ImageSharp.Tests/TestUtilities/SixLaborsXunitTestFramework.cs
@@ -18,7 +18,7 @@ public class SixLaborsXunitTestFramework : XunitTestFramework
     public SixLaborsXunitTestFramework(IMessageSink messageSink)
         : base(messageSink)
     {
-        var message = new DiagnosticMessage(HostEnvironmentInfo.GetInformation());
+        DiagnosticMessage message = new(HostEnvironmentInfo.GetInformation());
         messageSink.OnMessage(message);
     }
 }
diff --git a/tests/ImageSharp.Tests/TestUtilities/TestDataGenerator.cs b/tests/ImageSharp.Tests/TestUtilities/TestDataGenerator.cs
index 31de3909e1..53f0f06486 100644
--- a/tests/ImageSharp.Tests/TestUtilities/TestDataGenerator.cs
+++ b/tests/ImageSharp.Tests/TestUtilities/TestDataGenerator.cs
@@ -20,7 +20,7 @@ internal static class TestDataGenerator
     /// <returns>The <see cref="float[]"/>.</returns>
     public static float[] GenerateRandomFloatArray(this Random rnd, int length, float minVal, float maxVal)
     {
-        var values = new float[length];
+        float[] values = new float[length];
 
         RandomFill(rnd, values, minVal, maxVal);
 
@@ -45,7 +45,7 @@ internal static class TestDataGenerator
     /// <returns>The <see cref="Vector4[]"/>.</returns>
     public static Vector4[] GenerateRandomVectorArray(this Random rnd, int length, float minVal, float maxVal)
     {
-        var values = new Vector4[length];
+        Vector4[] values = new Vector4[length];
 
         for (int i = 0; i < length; i++)
         {
@@ -69,7 +69,7 @@ internal static class TestDataGenerator
     /// <returns>The <see cref="float[]"/>.</returns>
     public static float[] GenerateRandomRoundedFloatArray(this Random rnd, int length, float minVal, float maxVal)
     {
-        var values = new float[length];
+        float[] values = new float[length];
 
         for (int i = 0; i < length; i++)
         {
@@ -87,14 +87,14 @@ internal static class TestDataGenerator
     /// <returns>The <see cref="byte[]"/>.</returns>
     public static byte[] GenerateRandomByteArray(this Random rnd, int length)
     {
-        var values = new byte[length];
+        byte[] values = new byte[length];
         rnd.NextBytes(values);
         return values;
     }
 
     public static short[] GenerateRandomInt16Array(this Random rnd, int length, short minVal, short maxVal)
     {
-        var values = new short[length];
+        short[] values = new short[length];
         for (int i = 0; i < values.Length; i++)
         {
             values[i] = (short)rnd.Next(minVal, maxVal);
diff --git a/tests/ImageSharp.Tests/TestUtilities/TestEnvironment.cs b/tests/ImageSharp.Tests/TestUtilities/TestEnvironment.cs
index 8818830351..5eb5be0d9a 100644
--- a/tests/ImageSharp.Tests/TestUtilities/TestEnvironment.cs
+++ b/tests/ImageSharp.Tests/TestUtilities/TestEnvironment.cs
@@ -19,9 +19,9 @@ public static partial class TestEnvironment
 
     private const string ToolsDirectoryRelativePath = @"tests\Images\External\tools";
 
-    private static readonly Lazy<string> SolutionDirectoryFullPathLazy = new Lazy<string>(GetSolutionDirectoryFullPathImpl);
+    private static readonly Lazy<string> SolutionDirectoryFullPathLazy = new(GetSolutionDirectoryFullPathImpl);
 
-    private static readonly Lazy<Version> NetCoreVersionLazy = new Lazy<Version>(GetNetCoreVersion);
+    private static readonly Lazy<Version> NetCoreVersionLazy = new(GetNetCoreVersion);
 
     static TestEnvironment() => PrepareRemoteExecutor();
 
@@ -52,8 +52,7 @@ public static partial class TestEnvironment
 
     internal static string SolutionDirectoryFullPath => SolutionDirectoryFullPathLazy.Value;
 
-    private static readonly FileInfo TestAssemblyFile =
-        new FileInfo(typeof(TestEnvironment).GetTypeInfo().Assembly.Location);
+    private static readonly FileInfo TestAssemblyFile = new(typeof(TestEnvironment).GetTypeInfo().Assembly.Location);
 
     private static string GetSolutionDirectoryFullPathImpl()
     {
@@ -215,7 +214,7 @@ public static partial class TestEnvironment
 
         string args = $"{remoteExecutorTmpPath} /32Bit+ /Force";
 
-        var si = new ProcessStartInfo()
+        ProcessStartInfo si = new()
         {
             FileName = corFlagsFile.FullName,
             Arguments = args,
@@ -224,7 +223,7 @@ public static partial class TestEnvironment
             RedirectStandardError = true
         };
 
-        using var proc = Process.Start(si);
+        using Process proc = Process.Start(si);
         proc.WaitForExit();
         string standardOutput = proc.StandardOutput.ReadToEnd();
         string standardError = proc.StandardError.ReadToEnd();
@@ -266,7 +265,7 @@ public static partial class TestEnvironment
     private static Version GetNetCoreVersion()
     {
         Assembly assembly = typeof(System.Runtime.GCSettings).GetTypeInfo().Assembly;
-        string[] assemblyPath = assembly.Location.Split(new[] { '/', '\\' }, StringSplitOptions.RemoveEmptyEntries);
+        string[] assemblyPath = assembly.Location.Split(['/', '\\'], StringSplitOptions.RemoveEmptyEntries);
         int netCoreAppIndex = Array.IndexOf(assemblyPath, "Microsoft.NETCore.App");
         if (netCoreAppIndex > 0 && netCoreAppIndex < assemblyPath.Length - 2)
         {
diff --git a/tests/ImageSharp.Tests/TestUtilities/TestImageExtensions.cs b/tests/ImageSharp.Tests/TestUtilities/TestImageExtensions.cs
index 05abedbd8e..4a34529dd3 100644
--- a/tests/ImageSharp.Tests/TestUtilities/TestImageExtensions.cs
+++ b/tests/ImageSharp.Tests/TestUtilities/TestImageExtensions.cs
@@ -59,11 +59,6 @@ public static class TestImageExtensions
         bool appendSourceFileOrDescription = true,
         IImageEncoder encoder = null)
     {
-        if (TestEnvironment.RunsWithCodeCoverage)
-        {
-            return image;
-        }
-
         provider.Utility.SaveTestOutputFile(
             image,
             extension,
@@ -107,18 +102,15 @@ public static class TestImageExtensions
         ITestImageProvider provider,
         object testOutputDetails = null,
         string extension = "png",
+        IImageEncoder encoder = null,
         bool appendPixelTypeToFileName = true,
         Func<int, int, bool> predicate = null)
         where TPixel : unmanaged, IPixel<TPixel>
     {
-        if (TestEnvironment.RunsWithCodeCoverage)
-        {
-            return image;
-        }
-
         provider.Utility.SaveTestOutputFileMultiFrame(
             image,
             extension,
+            encoder: encoder,
             testOutputDetails: testOutputDetails,
             appendPixelTypeToFileName: appendPixelTypeToFileName,
             predicate: predicate);
@@ -277,6 +269,46 @@ public static class TestImageExtensions
         return image;
     }
 
+    public static Image<TPixel> CompareDebugOutputToReferenceOutputMultiFrame<TPixel>(
+        this Image<TPixel> image,
+        ITestImageProvider provider,
+        ImageComparer comparer,
+        object testOutputDetails = null,
+        string extension = "png",
+        IImageEncoder encoder = null,
+        bool appendPixelTypeToFileName = true,
+        Func<int, int, bool> predicate = null)
+    where TPixel : unmanaged, IPixel<TPixel>
+    {
+        image.DebugSaveMultiFrame(
+            provider,
+            testOutputDetails,
+            extension,
+            encoder,
+            appendPixelTypeToFileName,
+            predicate: predicate);
+
+        using Image<TPixel> debugImage = GetDebugOutputImageMultiFrame<TPixel>(
+            provider,
+            image.Frames.Count,
+            testOutputDetails,
+            extension,
+            appendPixelTypeToFileName,
+            predicate: predicate);
+
+        using Image<TPixel> referenceImage = GetReferenceOutputImageMultiFrame<TPixel>(
+            provider,
+            image.Frames.Count,
+            testOutputDetails,
+            extension,
+            appendPixelTypeToFileName,
+            predicate: predicate);
+
+        comparer.VerifySimilarity(referenceImage, debugImage);
+
+        return image;
+    }
+
     public static Image<TPixel> CompareToReferenceOutputMultiFrame<TPixel>(
         this Image<TPixel> image,
         ITestImageProvider provider,
@@ -343,7 +375,55 @@ public static class TestImageExtensions
             appendPixelTypeToFileName,
             predicate);
 
-        List<Image<TPixel>> temporaryFrameImages = new();
+        List<Image<TPixel>> temporaryFrameImages = [];
+
+        IImageDecoder decoder = TestEnvironment.GetReferenceDecoder(frameFiles[0].FileName);
+
+        for (int i = 0; i < frameFiles.Length; i++)
+        {
+            string path = frameFiles[i].FileName;
+            if (!File.Exists(path))
+            {
+                throw new FileNotFoundException("Reference output file missing: " + path);
+            }
+
+            using FileStream stream = File.OpenRead(path);
+            Image<TPixel> tempImage = decoder.Decode<TPixel>(DecoderOptions.Default, stream);
+            temporaryFrameImages.Add(tempImage);
+        }
+
+        Image<TPixel> firstTemp = temporaryFrameImages[0];
+
+        Image<TPixel> result = new(firstTemp.Width, firstTemp.Height);
+
+        foreach (Image<TPixel> fi in temporaryFrameImages)
+        {
+            result.Frames.AddFrame(fi.Frames.RootFrame);
+            fi.Dispose();
+        }
+
+        // Remove the initial empty frame:
+        result.Frames.RemoveFrame(0);
+        return result;
+    }
+
+    public static Image<TPixel> GetDebugOutputImageMultiFrame<TPixel>(
+        this ITestImageProvider provider,
+        int frameCount,
+        object testOutputDetails = null,
+        string extension = "png",
+        bool appendPixelTypeToFileName = true,
+        Func<int, int, bool> predicate = null)
+        where TPixel : unmanaged, IPixel<TPixel>
+    {
+        (int Index, string FileName)[] frameFiles = [.. provider.Utility.GetTestOutputFileNamesMultiFrame(
+            frameCount,
+            extension,
+            testOutputDetails,
+            appendPixelTypeToFileName,
+            predicate: predicate)];
+
+        List<Image<TPixel>> temporaryFrameImages = [];
 
         IImageDecoder decoder = TestEnvironment.GetReferenceDecoder(frameFiles[0].FileName);
 
diff --git a/tests/ImageSharp.Tests/TestUtilities/TestMemoryAllocator.cs b/tests/ImageSharp.Tests/TestUtilities/TestMemoryAllocator.cs
index fe94cffc43..a0ff4a466e 100644
--- a/tests/ImageSharp.Tests/TestUtilities/TestMemoryAllocator.cs
+++ b/tests/ImageSharp.Tests/TestUtilities/TestMemoryAllocator.cs
@@ -46,7 +46,7 @@ internal class TestMemoryAllocator : MemoryAllocator
     private T[] AllocateArray<T>(int length, AllocationOptions options)
         where T : struct
     {
-        var array = new T[length + 42];
+        T[] array = new T[length + 42];
         this.allocationLog?.Add(AllocationRequest.Create<T>(options, length, array));
 
         if (options == AllocationOptions.None)
diff --git a/tests/ImageSharp.Tests/TestUtilities/TestMemoryManager.cs b/tests/ImageSharp.Tests/TestUtilities/TestMemoryManager.cs
index 50e086d579..7f25fd5aa1 100644
--- a/tests/ImageSharp.Tests/TestUtilities/TestMemoryManager.cs
+++ b/tests/ImageSharp.Tests/TestUtilities/TestMemoryManager.cs
@@ -34,7 +34,7 @@ public class TestMemoryManager<T> : MemoryManager<T>
 
     public static TestMemoryManager<T> CreateAsCopyOf(Span<T> copyThisBuffer)
     {
-        var pixelArray = new T[copyThisBuffer.Length];
+        T[] pixelArray = new T[copyThisBuffer.Length];
         copyThisBuffer.CopyTo(pixelArray);
         return new TestMemoryManager<T>(pixelArray);
     }
diff --git a/tests/ImageSharp.Tests/TestUtilities/TestUtils.cs b/tests/ImageSharp.Tests/TestUtilities/TestUtils.cs
index fbdfb9d619..2e2416952d 100644
--- a/tests/ImageSharp.Tests/TestUtilities/TestUtils.cs
+++ b/tests/ImageSharp.Tests/TestUtilities/TestUtils.cs
@@ -26,7 +26,7 @@ public static class TestUtils
     private static readonly Dictionary<PixelTypes, Type> PixelTypes2ClrTypes = new();
 
     private static readonly PixelTypes[] AllConcretePixelTypes = GetAllPixelTypes()
-        .Except(new[] { PixelTypes.Undefined, PixelTypes.All })
+        .Except([PixelTypes.Undefined, PixelTypes.All])
         .ToArray();
 
     static TestUtils()
@@ -133,7 +133,7 @@ public static class TestUtils
     {
         if (pixelTypes == PixelTypes.Undefined)
         {
-            return Enumerable.Empty<KeyValuePair<PixelTypes, Type>>();
+            return [];
         }
         else if (pixelTypes == PixelTypes.All)
         {
diff --git a/tests/ImageSharp.Tests/TestUtilities/Tests/BasicSerializerTests.cs b/tests/ImageSharp.Tests/TestUtilities/Tests/BasicSerializerTests.cs
index 52447b6c2c..1b5b43f033 100644
--- a/tests/ImageSharp.Tests/TestUtilities/Tests/BasicSerializerTests.cs
+++ b/tests/ImageSharp.Tests/TestUtilities/Tests/BasicSerializerTests.cs
@@ -51,7 +51,7 @@ public class BasicSerializerTests
     [Fact]
     public void SerializeDeserialize_ShouldPreserveValues()
     {
-        var obj = new DerivedObj() { Length = 123.1, Name = "Lol123!", Lives = 7, Strength = 4.8 };
+        DerivedObj obj = new() { Length = 123.1, Name = "Lol123!", Lives = 7, Strength = 4.8 };
 
         string str = BasicSerializer.Serialize(obj);
         BaseObj mirrorBase = BasicSerializer.Deserialize<BaseObj>(str);
diff --git a/tests/ImageSharp.Tests/TestUtilities/Tests/FeatureTestRunnerTests.cs b/tests/ImageSharp.Tests/TestUtilities/Tests/FeatureTestRunnerTests.cs
index 34337600eb..82b247d9df 100644
--- a/tests/ImageSharp.Tests/TestUtilities/Tests/FeatureTestRunnerTests.cs
+++ b/tests/ImageSharp.Tests/TestUtilities/Tests/FeatureTestRunnerTests.cs
@@ -14,9 +14,9 @@ public class FeatureTestRunnerTests
     public static TheoryData<HwIntrinsics, string[]> Intrinsics =>
         new()
         {
-            { HwIntrinsics.DisableAES | HwIntrinsics.AllowAll, new[] { "EnableAES", "AllowAll" } },
-            { HwIntrinsics.DisableHWIntrinsic, new[] { "EnableHWIntrinsic" } },
-            { HwIntrinsics.DisableSSE42 | HwIntrinsics.DisableAVX, new[] { "EnableSSE42", "EnableAVX" } }
+            { HwIntrinsics.DisableAES | HwIntrinsics.AllowAll, ["EnableAES", "AllowAll"] },
+            { HwIntrinsics.DisableHWIntrinsic, ["EnableHWIntrinsic"] },
+            { HwIntrinsics.DisableSSE42 | HwIntrinsics.DisableAVX, ["EnableSSE42", "EnableAVX"] }
         };
 
     [Theory]
diff --git a/tests/ImageSharp.Tests/TestUtilities/Tests/ImageComparerTests.cs b/tests/ImageSharp.Tests/TestUtilities/Tests/ImageComparerTests.cs
index 4c1a740e2b..349dd258eb 100644
--- a/tests/ImageSharp.Tests/TestUtilities/Tests/ImageComparerTests.cs
+++ b/tests/ImageSharp.Tests/TestUtilities/Tests/ImageComparerTests.cs
@@ -31,7 +31,7 @@ public class ImageComparerTests
         {
             using (Image<TPixel> clone = image.Clone())
             {
-                var comparer = ImageComparer.Tolerant(imageThreshold, pixelThreshold);
+                ImageComparer comparer = ImageComparer.Tolerant(imageThreshold, pixelThreshold);
                 comparer.VerifySimilarity(image, clone);
             }
         }
@@ -48,7 +48,7 @@ public class ImageComparerTests
             {
                 ImagingTestCaseUtility.ModifyPixel(clone, 0, 0, 1);
 
-                var comparer = ImageComparer.Tolerant();
+                ImageComparer comparer = ImageComparer.Tolerant();
                 comparer.VerifySimilarity(image, clone);
             }
         }
@@ -66,7 +66,7 @@ public class ImageComparerTests
                 byte perChannelChange = 20;
                 ImagingTestCaseUtility.ModifyPixel(clone, 3, 1, perChannelChange);
 
-                var comparer = ImageComparer.Tolerant();
+                ImageComparer comparer = ImageComparer.Tolerant();
 
                 ImageDifferenceIsOverThresholdException ex = Assert.ThrowsAny<ImageDifferenceIsOverThresholdException>(
                     () => comparer.VerifySimilarity(image, clone));
@@ -90,7 +90,7 @@ public class ImageComparerTests
                 ImagingTestCaseUtility.ModifyPixel(clone, 1, 0, 1);
                 ImagingTestCaseUtility.ModifyPixel(clone, 2, 0, 1);
 
-                var comparer = ImageComparer.Tolerant(perPixelManhattanThreshold: 257 * 3);
+                ImageComparer comparer = ImageComparer.Tolerant(perPixelManhattanThreshold: 257 * 3);
                 comparer.VerifySimilarity(image, clone);
             }
         }
diff --git a/tests/ImageSharp.Tests/TestUtilities/Tests/ReferenceDecoderBenchmarks.cs b/tests/ImageSharp.Tests/TestUtilities/Tests/ReferenceDecoderBenchmarks.cs
index 6e1eba28e8..a145e7365e 100644
--- a/tests/ImageSharp.Tests/TestUtilities/Tests/ReferenceDecoderBenchmarks.cs
+++ b/tests/ImageSharp.Tests/TestUtilities/Tests/ReferenceDecoderBenchmarks.cs
@@ -22,20 +22,20 @@ public class ReferenceDecoderBenchmarks
     public const int DefaultExecutionCount = 50;
 
     public static readonly string[] PngBenchmarkFiles =
-        {
-            TestImages.Png.CalliphoraPartial,
+    [
+        TestImages.Png.CalliphoraPartial,
             TestImages.Png.Kaboom,
             TestImages.Png.Bike,
             TestImages.Png.Splash,
             TestImages.Png.SplashInterlaced
-        };
+    ];
 
     public static readonly string[] BmpBenchmarkFiles =
-        {
-            TestImages.Bmp.NegHeight,
+    [
+        TestImages.Bmp.NegHeight,
             TestImages.Bmp.Car,
             TestImages.Bmp.V5Header
-        };
+    ];
 
     public ReferenceDecoderBenchmarks(ITestOutputHelper output)
     {
@@ -76,7 +76,7 @@ public class ReferenceDecoderBenchmarks
 
     private void BenchmarkDecoderImpl(IEnumerable<string> testFiles, IImageDecoder decoder, string info, int times = DefaultExecutionCount)
     {
-        var measure = new MeasureFixture(this.Output);
+        MeasureFixture measure = new(this.Output);
         measure.Measure(
             times,
             () =>
diff --git a/tests/ImageSharp.Tests/TestUtilities/Tests/SemaphoreReadMemoryStreamTests.cs b/tests/ImageSharp.Tests/TestUtilities/Tests/SemaphoreReadMemoryStreamTests.cs
index e080bda9b6..f0a5f4eb42 100644
--- a/tests/ImageSharp.Tests/TestUtilities/Tests/SemaphoreReadMemoryStreamTests.cs
+++ b/tests/ImageSharp.Tests/TestUtilities/Tests/SemaphoreReadMemoryStreamTests.cs
@@ -5,8 +5,8 @@ namespace SixLabors.ImageSharp.Tests.TestUtilities.Tests;
 
 public class SemaphoreReadMemoryStreamTests
 {
-    private readonly SemaphoreSlim continueSemaphore = new SemaphoreSlim(0);
-    private readonly SemaphoreSlim notifyWaitPositionReachedSemaphore = new SemaphoreSlim(0);
+    private readonly SemaphoreSlim continueSemaphore = new(0);
+    private readonly SemaphoreSlim notifyWaitPositionReachedSemaphore = new(0);
     private readonly byte[] buffer = new byte[128];
 
     [Fact]
diff --git a/tests/ImageSharp.Tests/TestUtilities/Tests/SystemDrawingReferenceCodecTests.cs b/tests/ImageSharp.Tests/TestUtilities/Tests/SystemDrawingReferenceCodecTests.cs
index 4608583791..555041890a 100644
--- a/tests/ImageSharp.Tests/TestUtilities/Tests/SystemDrawingReferenceCodecTests.cs
+++ b/tests/ImageSharp.Tests/TestUtilities/Tests/SystemDrawingReferenceCodecTests.cs
@@ -1,6 +1,7 @@
 // Copyright (c) Six Labors.
 // Licensed under the Six Labors Split License.
 
+using System.Drawing;
 using SixLabors.ImageSharp.Formats;
 using SixLabors.ImageSharp.Formats.Png;
 using SixLabors.ImageSharp.PixelFormats;
@@ -35,7 +36,7 @@ public class SystemDrawingReferenceCodecTests
     {
         string path = TestFile.GetInputFileFullPath(TestImages.Png.Splash);
 
-        using var sdBitmap = new System.Drawing.Bitmap(path);
+        using Bitmap sdBitmap = new(path);
         using Image<TPixel> image = SystemDrawingBridge.From32bppArgbSystemDrawingBitmap<TPixel>(sdBitmap);
         image.DebugSave(dummyProvider);
     }
@@ -49,7 +50,7 @@ public class SystemDrawingReferenceCodecTests
             sourceImage.Mutate(c => c.MakeOpaque());
         }
 
-        var encoder = new PngEncoder { ColorType = pngColorType };
+        PngEncoder encoder = new() { ColorType = pngColorType };
         return provider.Utility.SaveTestOutputFile(sourceImage, "png", encoder);
     }
 
@@ -65,7 +66,7 @@ public class SystemDrawingReferenceCodecTests
 
         string path = SavePng(provider, PngColorType.RgbWithAlpha);
 
-        using var sdBitmap = new System.Drawing.Bitmap(path);
+        using Bitmap sdBitmap = new(path);
         using Image<TPixel> original = provider.GetImage();
         using Image<TPixel> resaved = SystemDrawingBridge.From32bppArgbSystemDrawingBitmap<TPixel>(sdBitmap);
         ImageComparer comparer = ImageComparer.Exact;
@@ -80,7 +81,7 @@ public class SystemDrawingReferenceCodecTests
         string path = SavePng(provider, PngColorType.Rgb);
 
         using Image<TPixel> original = provider.GetImage();
-        using var sdBitmap = new System.Drawing.Bitmap(path);
+        using Bitmap sdBitmap = new(path);
         using Image<TPixel> resaved = SystemDrawingBridge.From24bppRgbSystemDrawingBitmap<TPixel>(sdBitmap);
         ImageComparer comparer = ImageComparer.Exact;
         comparer.VerifySimilarity(original, resaved);
diff --git a/tests/ImageSharp.Tests/TestUtilities/Tests/TestImageProviderTests.cs b/tests/ImageSharp.Tests/TestUtilities/Tests/TestImageProviderTests.cs
index f33811206a..72ed27e8e8 100644
--- a/tests/ImageSharp.Tests/TestUtilities/Tests/TestImageProviderTests.cs
+++ b/tests/ImageSharp.Tests/TestUtilities/Tests/TestImageProviderTests.cs
@@ -368,7 +368,7 @@ public class TestImageProviderTests
         {
             using Image<Rgba32> image = this.Decode<Rgba32>(this.CreateDefaultSpecializedOptions(options), stream, cancellationToken);
             ImageMetadata metadata = image.Metadata;
-            return new(image.Size, metadata, new List<ImageFrameMetadata>(image.Frames.Select(x => x.Metadata)))
+            return new ImageInfo(image.Size, metadata, new List<ImageFrameMetadata>(image.Frames.Select(x => x.Metadata)))
             {
                 PixelType = metadata.GetDecodedPixelTypeInfo()
             };
@@ -415,7 +415,7 @@ public class TestImageProviderTests
         {
             using Image<Rgba32> image = this.Decode<Rgba32>(this.CreateDefaultSpecializedOptions(options), stream, cancellationToken);
             ImageMetadata metadata = image.Metadata;
-            return new(image.Size, metadata, new List<ImageFrameMetadata>(image.Frames.Select(x => x.Metadata)))
+            return new ImageInfo(image.Size, metadata, new List<ImageFrameMetadata>(image.Frames.Select(x => x.Metadata)))
             {
                 PixelType = metadata.GetDecodedPixelTypeInfo()
             };
diff --git a/tests/Images/External/ReferenceOutput/BmpEncoderTests/Encode_8BitColor_WithOctreeQuantizer_rgb32.bmp b/tests/Images/External/ReferenceOutput/BmpEncoderTests/Encode_8BitColor_WithOctreeQuantizer_rgb32.bmp
index 2b8e05b070..f4ae3b9b68 100644
--- a/tests/Images/External/ReferenceOutput/BmpEncoderTests/Encode_8BitColor_WithOctreeQuantizer_rgb32.bmp
+++ b/tests/Images/External/ReferenceOutput/BmpEncoderTests/Encode_8BitColor_WithOctreeQuantizer_rgb32.bmp
@@ -1,3 +1,3 @@
 version https://git-lfs.github.com/spec/v1
-oid sha256:11375b15df083d98335f4a4baf0717e7fdd6b21ab2132a6815cadc787ac17e7d
+oid sha256:a98b1ec707af066f77fad7d1a64b858d460986beb6d27682717dd5e221310fd4
 size 9270
diff --git a/tests/Images/External/ReferenceOutput/DitherTests/ApplyDitherFilterInBox_Rgba32_CalliphoraPartial - Copy.png b/tests/Images/External/ReferenceOutput/DitherTests/ApplyDitherFilterInBox_Rgba32_CalliphoraPartial - Copy.png
new file mode 100644
index 0000000000..43e414da6d
--- /dev/null
+++ b/tests/Images/External/ReferenceOutput/DitherTests/ApplyDitherFilterInBox_Rgba32_CalliphoraPartial - Copy.png	
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:a899a84c6af24bfad89f9fde75957c7a979d65bcf096ab667cb976efd71cb560
+size 271171
diff --git a/tests/Images/External/ReferenceOutput/DitherTests/DiffusionFilter_WorksWithAllErrorDiffusers_CalliphoraPartial_Atkinson.png b/tests/Images/External/ReferenceOutput/DitherTests/DiffusionFilter_WorksWithAllErrorDiffusers_CalliphoraPartial_Atkinson.png
index cc2327b23f..70acb3f32e 100644
--- a/tests/Images/External/ReferenceOutput/DitherTests/DiffusionFilter_WorksWithAllErrorDiffusers_CalliphoraPartial_Atkinson.png
+++ b/tests/Images/External/ReferenceOutput/DitherTests/DiffusionFilter_WorksWithAllErrorDiffusers_CalliphoraPartial_Atkinson.png
@@ -1,3 +1,3 @@
 version https://git-lfs.github.com/spec/v1
-oid sha256:7e22401dddf6552cd91517c1cdd142d3b9a66a7ad5c80d2e52ae07a7f583708e
-size 57657
+oid sha256:e44c49a8f2ab1280c38e6ba71da29a93803b2aa4cf117e1e919909521b0373e6
+size 57636
diff --git a/tests/Images/External/ReferenceOutput/DitherTests/DiffusionFilter_WorksWithAllErrorDiffusers_CalliphoraPartial_Burks.png b/tests/Images/External/ReferenceOutput/DitherTests/DiffusionFilter_WorksWithAllErrorDiffusers_CalliphoraPartial_Burks.png
index e3ae6508e1..af35177491 100644
--- a/tests/Images/External/ReferenceOutput/DitherTests/DiffusionFilter_WorksWithAllErrorDiffusers_CalliphoraPartial_Burks.png
+++ b/tests/Images/External/ReferenceOutput/DitherTests/DiffusionFilter_WorksWithAllErrorDiffusers_CalliphoraPartial_Burks.png
@@ -1,3 +1,3 @@
 version https://git-lfs.github.com/spec/v1
-oid sha256:819a0ce38e27e2adfa454d8c5ad5b24e818bf8954c9f2406f608dcecf506c2c4
-size 59838
+oid sha256:359a44bb957481c85d5acd65559b43ffc0acf806d4f4e57d6a791ca65b28295b
+size 59839
diff --git a/tests/Images/External/ReferenceOutput/DitherTests/DiffusionFilter_WorksWithAllErrorDiffusers_CalliphoraPartial_FloydSteinberg.png b/tests/Images/External/ReferenceOutput/DitherTests/DiffusionFilter_WorksWithAllErrorDiffusers_CalliphoraPartial_FloydSteinberg.png
index 2b897a5d6d..a14c2cb1f6 100644
--- a/tests/Images/External/ReferenceOutput/DitherTests/DiffusionFilter_WorksWithAllErrorDiffusers_CalliphoraPartial_FloydSteinberg.png
+++ b/tests/Images/External/ReferenceOutput/DitherTests/DiffusionFilter_WorksWithAllErrorDiffusers_CalliphoraPartial_FloydSteinberg.png
@@ -1,3 +1,3 @@
 version https://git-lfs.github.com/spec/v1
-oid sha256:007ac609ec61b39c7bdd04bc87a698f5cdc76eadd834c1457f41eb9c135c3f7b
+oid sha256:7fb3743098a8147fd24294d933d93a61ec0155d754f52544650f6589719905be
 size 60688
diff --git a/tests/Images/External/ReferenceOutput/DitherTests/DiffusionFilter_WorksWithAllErrorDiffusers_CalliphoraPartial_JarvisJudiceNinke.png b/tests/Images/External/ReferenceOutput/DitherTests/DiffusionFilter_WorksWithAllErrorDiffusers_CalliphoraPartial_JarvisJudiceNinke.png
index 10ba90ae86..683f59ea1e 100644
--- a/tests/Images/External/ReferenceOutput/DitherTests/DiffusionFilter_WorksWithAllErrorDiffusers_CalliphoraPartial_JarvisJudiceNinke.png
+++ b/tests/Images/External/ReferenceOutput/DitherTests/DiffusionFilter_WorksWithAllErrorDiffusers_CalliphoraPartial_JarvisJudiceNinke.png
@@ -1,3 +1,3 @@
 version https://git-lfs.github.com/spec/v1
-oid sha256:46892c07e9a93f1df71f0e38b331a437fb9b7c52d8f40cf62780cb6bd35d3b13
-size 58963
+oid sha256:41fa7d92a10db450f3b3729ab9e36074224baaefeda21cffd0466e37a111e138
+size 59113
diff --git a/tests/Images/External/ReferenceOutput/DitherTests/DiffusionFilter_WorksWithAllErrorDiffusers_CalliphoraPartial_Sierra2.png b/tests/Images/External/ReferenceOutput/DitherTests/DiffusionFilter_WorksWithAllErrorDiffusers_CalliphoraPartial_Sierra2.png
index 9608289e84..813289a26d 100644
--- a/tests/Images/External/ReferenceOutput/DitherTests/DiffusionFilter_WorksWithAllErrorDiffusers_CalliphoraPartial_Sierra2.png
+++ b/tests/Images/External/ReferenceOutput/DitherTests/DiffusionFilter_WorksWithAllErrorDiffusers_CalliphoraPartial_Sierra2.png
@@ -1,3 +1,3 @@
 version https://git-lfs.github.com/spec/v1
-oid sha256:1b83345ca3de8d1fc0fbb5d8e68329b94ad79fc29b9f10a1392a97ffe9a0733e
-size 58985
+oid sha256:bebf3b3762b339874891e3d434511e5f2557be90d66d6d7fe827b50334ede6c2
+size 58976
diff --git a/tests/Images/External/ReferenceOutput/DitherTests/DiffusionFilter_WorksWithAllErrorDiffusers_CalliphoraPartial_Sierra3.png b/tests/Images/External/ReferenceOutput/DitherTests/DiffusionFilter_WorksWithAllErrorDiffusers_CalliphoraPartial_Sierra3.png
index 79d2c5eb14..d4da100376 100644
--- a/tests/Images/External/ReferenceOutput/DitherTests/DiffusionFilter_WorksWithAllErrorDiffusers_CalliphoraPartial_Sierra3.png
+++ b/tests/Images/External/ReferenceOutput/DitherTests/DiffusionFilter_WorksWithAllErrorDiffusers_CalliphoraPartial_Sierra3.png
@@ -1,3 +1,3 @@
 version https://git-lfs.github.com/spec/v1
-oid sha256:c775a5b19ba09e1b335389e0dc12cb0c3feaff6072e904da750a676fcd6b07dc
-size 59202
+oid sha256:fd4358826739db2c22064e8aa90597f8b6403b9d7e2866ec280e743c51d2f41f
+size 59203
diff --git a/tests/Images/External/ReferenceOutput/DitherTests/DiffusionFilter_WorksWithAllErrorDiffusers_CalliphoraPartial_Stucki.png b/tests/Images/External/ReferenceOutput/DitherTests/DiffusionFilter_WorksWithAllErrorDiffusers_CalliphoraPartial_Stucki.png
index edec46a92a..fa8eea57a9 100644
--- a/tests/Images/External/ReferenceOutput/DitherTests/DiffusionFilter_WorksWithAllErrorDiffusers_CalliphoraPartial_Stucki.png
+++ b/tests/Images/External/ReferenceOutput/DitherTests/DiffusionFilter_WorksWithAllErrorDiffusers_CalliphoraPartial_Stucki.png
@@ -1,3 +1,3 @@
 version https://git-lfs.github.com/spec/v1
-oid sha256:8cc216ed952216d203836dc559234216614f1ed059651677cc0ea714010bd932
-size 58855
+oid sha256:174ee39c08eb9a174b48b19dc618d043bf6b71eee68ab7127407eb713e164e61
+size 58934
diff --git a/tests/Images/External/ReferenceOutput/DitherTests/DitherFilter_ShouldNotDependOnSinglePixelType_Bgra32_filter0.png b/tests/Images/External/ReferenceOutput/DitherTests/DitherFilter_ShouldNotDependOnSinglePixelType_Bgra32_filter0.png
index e2e4147f68..2c67b3bf23 100644
--- a/tests/Images/External/ReferenceOutput/DitherTests/DitherFilter_ShouldNotDependOnSinglePixelType_Bgra32_filter0.png
+++ b/tests/Images/External/ReferenceOutput/DitherTests/DitherFilter_ShouldNotDependOnSinglePixelType_Bgra32_filter0.png
@@ -1,3 +1,3 @@
 version https://git-lfs.github.com/spec/v1
-oid sha256:a3253003b088c9975725cf321c2fc827547a5feb199f2d1aa515c69bde59deb7
-size 871
+oid sha256:1110b46ec3296a1631420e0bb915f6fdc3d1cead4b0fc5a63a7a280fbf841ea2
+size 870
diff --git a/tests/Images/External/ReferenceOutput/DitherTests/DitherFilter_ShouldNotDependOnSinglePixelType_Rgb24_filter0.png b/tests/Images/External/ReferenceOutput/DitherTests/DitherFilter_ShouldNotDependOnSinglePixelType_Rgb24_filter0.png
index aa0e9a4824..1305c5ede9 100644
--- a/tests/Images/External/ReferenceOutput/DitherTests/DitherFilter_ShouldNotDependOnSinglePixelType_Rgb24_filter0.png
+++ b/tests/Images/External/ReferenceOutput/DitherTests/DitherFilter_ShouldNotDependOnSinglePixelType_Rgb24_filter0.png
@@ -1,3 +1,3 @@
 version https://git-lfs.github.com/spec/v1
-oid sha256:bb3e3b9b3001e76505fb0e2db7ad200cad2a016c06f1993c60c3cab42c134863
-size 867
+oid sha256:e51abcab66201997deda99637de604330ef977fd2d1dbebaa0416c621d03b8f9
+size 869
diff --git a/tests/Images/External/ReferenceOutput/DitherTests/DitherFilter_ShouldNotDependOnSinglePixelType_Rgba32_filter0.png b/tests/Images/External/ReferenceOutput/DitherTests/DitherFilter_ShouldNotDependOnSinglePixelType_Rgba32_filter0.png
index e2e4147f68..2c67b3bf23 100644
--- a/tests/Images/External/ReferenceOutput/DitherTests/DitherFilter_ShouldNotDependOnSinglePixelType_Rgba32_filter0.png
+++ b/tests/Images/External/ReferenceOutput/DitherTests/DitherFilter_ShouldNotDependOnSinglePixelType_Rgba32_filter0.png
@@ -1,3 +1,3 @@
 version https://git-lfs.github.com/spec/v1
-oid sha256:a3253003b088c9975725cf321c2fc827547a5feb199f2d1aa515c69bde59deb7
-size 871
+oid sha256:1110b46ec3296a1631420e0bb915f6fdc3d1cead4b0fc5a63a7a280fbf841ea2
+size 870
diff --git a/tests/Images/External/ReferenceOutput/DitherTests/DitherFilter_ShouldNotDependOnSinglePixelType_RgbaVector_filter0.png b/tests/Images/External/ReferenceOutput/DitherTests/DitherFilter_ShouldNotDependOnSinglePixelType_RgbaVector_filter0.png
index e2e4147f68..2c67b3bf23 100644
--- a/tests/Images/External/ReferenceOutput/DitherTests/DitherFilter_ShouldNotDependOnSinglePixelType_RgbaVector_filter0.png
+++ b/tests/Images/External/ReferenceOutput/DitherTests/DitherFilter_ShouldNotDependOnSinglePixelType_RgbaVector_filter0.png
@@ -1,3 +1,3 @@
 version https://git-lfs.github.com/spec/v1
-oid sha256:a3253003b088c9975725cf321c2fc827547a5feb199f2d1aa515c69bde59deb7
-size 871
+oid sha256:1110b46ec3296a1631420e0bb915f6fdc3d1cead4b0fc5a63a7a280fbf841ea2
+size 870
diff --git a/tests/Images/External/ReferenceOutput/DitherTests/DitherFilter_WorksWithAllDitherers_CalliphoraPartial_Bayer16x16.png b/tests/Images/External/ReferenceOutput/DitherTests/DitherFilter_WorksWithAllDitherers_CalliphoraPartial_Bayer16x16.png
index 4175cf40b7..da1f62b728 100644
--- a/tests/Images/External/ReferenceOutput/DitherTests/DitherFilter_WorksWithAllDitherers_CalliphoraPartial_Bayer16x16.png
+++ b/tests/Images/External/ReferenceOutput/DitherTests/DitherFilter_WorksWithAllDitherers_CalliphoraPartial_Bayer16x16.png
@@ -1,3 +1,3 @@
 version https://git-lfs.github.com/spec/v1
-oid sha256:9316cbbcb137ae6ff31646f6a5ba1d0aec100db4512509f7684187e74d16a111
-size 51074
+oid sha256:eb86f2037a0aff48a84c0161f22eb2e2495daadbfa9c33185ddfd7b8429a4ea9
+size 51266
diff --git a/tests/Images/External/ReferenceOutput/DitherTests/DitherFilter_WorksWithAllDitherers_CalliphoraPartial_Bayer8x8.png b/tests/Images/External/ReferenceOutput/DitherTests/DitherFilter_WorksWithAllDitherers_CalliphoraPartial_Bayer8x8.png
index ac56fa9236..03848e81ce 100644
--- a/tests/Images/External/ReferenceOutput/DitherTests/DitherFilter_WorksWithAllDitherers_CalliphoraPartial_Bayer8x8.png
+++ b/tests/Images/External/ReferenceOutput/DitherTests/DitherFilter_WorksWithAllDitherers_CalliphoraPartial_Bayer8x8.png
@@ -1,3 +1,3 @@
 version https://git-lfs.github.com/spec/v1
-oid sha256:6d2289ed4fa0c679f0f120d260fec8ab40b1599043cc0a1fbebc6b67e238ff87
-size 51428
+oid sha256:ef033a419e2e1b06b57a66175bad9068f71ae4c862a66c5734f65cdaae8a27f0
+size 51461
diff --git a/tests/Images/External/ReferenceOutput/GifDecoderTests/Decode_Animated_Rgba32_animated_loop.gif/00.png b/tests/Images/External/ReferenceOutput/GifDecoderTests/Decode_Animated_Rgba32_animated_loop.gif/00.png
new file mode 100644
index 0000000000..65b2c6ff72
--- /dev/null
+++ b/tests/Images/External/ReferenceOutput/GifDecoderTests/Decode_Animated_Rgba32_animated_loop.gif/00.png
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:0b980fb1927a70f88bd26b039c54e4ea20a6a1ad68aacd6f1a68a46eb1997a29
+size 1180
diff --git a/tests/Images/External/ReferenceOutput/GifDecoderTests/Decode_Animated_Rgba32_animated_loop.gif/01.png b/tests/Images/External/ReferenceOutput/GifDecoderTests/Decode_Animated_Rgba32_animated_loop.gif/01.png
new file mode 100644
index 0000000000..8c9e125ade
--- /dev/null
+++ b/tests/Images/External/ReferenceOutput/GifDecoderTests/Decode_Animated_Rgba32_animated_loop.gif/01.png
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:4006374b88ff4c4ed665333608a19e693fc083ae72beb71850d0e39ad45c9943
+size 1144
diff --git a/tests/Images/External/ReferenceOutput/GifDecoderTests/Decode_Animated_Rgba32_animated_loop.gif/02.png b/tests/Images/External/ReferenceOutput/GifDecoderTests/Decode_Animated_Rgba32_animated_loop.gif/02.png
new file mode 100644
index 0000000000..a2fc2ab3bc
--- /dev/null
+++ b/tests/Images/External/ReferenceOutput/GifDecoderTests/Decode_Animated_Rgba32_animated_loop.gif/02.png
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:1f5054e1e464c9e9fc999eec00b9949a6dc256ee062e9910b5718b6d4658661a
+size 1303
diff --git a/tests/Images/External/ReferenceOutput/GifDecoderTests/Decode_Animated_Rgba32_animated_loop.gif/03.png b/tests/Images/External/ReferenceOutput/GifDecoderTests/Decode_Animated_Rgba32_animated_loop.gif/03.png
new file mode 100644
index 0000000000..9d5b54c718
--- /dev/null
+++ b/tests/Images/External/ReferenceOutput/GifDecoderTests/Decode_Animated_Rgba32_animated_loop.gif/03.png
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:49e8bcbcc5dc63fbd555f90a52b4e111cfc058f3adba2ca9c52dec966dbbae8f
+size 1371
diff --git a/tests/Images/External/ReferenceOutput/GifDecoderTests/Decode_Animated_Rgba32_animated_loop_interlaced.gif/00.png b/tests/Images/External/ReferenceOutput/GifDecoderTests/Decode_Animated_Rgba32_animated_loop_interlaced.gif/00.png
new file mode 100644
index 0000000000..65b2c6ff72
--- /dev/null
+++ b/tests/Images/External/ReferenceOutput/GifDecoderTests/Decode_Animated_Rgba32_animated_loop_interlaced.gif/00.png
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:0b980fb1927a70f88bd26b039c54e4ea20a6a1ad68aacd6f1a68a46eb1997a29
+size 1180
diff --git a/tests/Images/External/ReferenceOutput/GifDecoderTests/Decode_Animated_Rgba32_animated_loop_interlaced.gif/01.png b/tests/Images/External/ReferenceOutput/GifDecoderTests/Decode_Animated_Rgba32_animated_loop_interlaced.gif/01.png
new file mode 100644
index 0000000000..8c9e125ade
--- /dev/null
+++ b/tests/Images/External/ReferenceOutput/GifDecoderTests/Decode_Animated_Rgba32_animated_loop_interlaced.gif/01.png
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:4006374b88ff4c4ed665333608a19e693fc083ae72beb71850d0e39ad45c9943
+size 1144
diff --git a/tests/Images/External/ReferenceOutput/GifDecoderTests/Decode_Animated_Rgba32_animated_loop_interlaced.gif/02.png b/tests/Images/External/ReferenceOutput/GifDecoderTests/Decode_Animated_Rgba32_animated_loop_interlaced.gif/02.png
new file mode 100644
index 0000000000..a2fc2ab3bc
--- /dev/null
+++ b/tests/Images/External/ReferenceOutput/GifDecoderTests/Decode_Animated_Rgba32_animated_loop_interlaced.gif/02.png
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:1f5054e1e464c9e9fc999eec00b9949a6dc256ee062e9910b5718b6d4658661a
+size 1303
diff --git a/tests/Images/External/ReferenceOutput/GifDecoderTests/Decode_Animated_Rgba32_animated_loop_interlaced.gif/03.png b/tests/Images/External/ReferenceOutput/GifDecoderTests/Decode_Animated_Rgba32_animated_loop_interlaced.gif/03.png
new file mode 100644
index 0000000000..9d5b54c718
--- /dev/null
+++ b/tests/Images/External/ReferenceOutput/GifDecoderTests/Decode_Animated_Rgba32_animated_loop_interlaced.gif/03.png
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:49e8bcbcc5dc63fbd555f90a52b4e111cfc058f3adba2ca9c52dec966dbbae8f
+size 1371
diff --git a/tests/Images/External/ReferenceOutput/GifDecoderTests/Decode_Animated_WithTransparency_Rgba32_animated_transparent_firstframerestoreprev_loop.gif/00.png b/tests/Images/External/ReferenceOutput/GifDecoderTests/Decode_Animated_WithTransparency_Rgba32_animated_transparent_firstframerestoreprev_loop.gif/00.png
new file mode 100644
index 0000000000..193cde24d9
--- /dev/null
+++ b/tests/Images/External/ReferenceOutput/GifDecoderTests/Decode_Animated_WithTransparency_Rgba32_animated_transparent_firstframerestoreprev_loop.gif/00.png
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:18b60d2066cb53d41988da37b8c521ddcb5355b995320a8413b95522a0492140
+size 687
diff --git a/tests/Images/External/ReferenceOutput/GifDecoderTests/Decode_Animated_WithTransparency_Rgba32_animated_transparent_firstframerestoreprev_loop.gif/01.png b/tests/Images/External/ReferenceOutput/GifDecoderTests/Decode_Animated_WithTransparency_Rgba32_animated_transparent_firstframerestoreprev_loop.gif/01.png
new file mode 100644
index 0000000000..4d2d255108
--- /dev/null
+++ b/tests/Images/External/ReferenceOutput/GifDecoderTests/Decode_Animated_WithTransparency_Rgba32_animated_transparent_firstframerestoreprev_loop.gif/01.png
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:30ff7708250c5f02dc02d74238d398b319d8fc6c071178f32f82a17e3b637afd
+size 542
diff --git a/tests/Images/External/ReferenceOutput/GifDecoderTests/Decode_Animated_WithTransparency_Rgba32_animated_transparent_firstframerestoreprev_loop.gif/02.png b/tests/Images/External/ReferenceOutput/GifDecoderTests/Decode_Animated_WithTransparency_Rgba32_animated_transparent_firstframerestoreprev_loop.gif/02.png
new file mode 100644
index 0000000000..0654e49d45
--- /dev/null
+++ b/tests/Images/External/ReferenceOutput/GifDecoderTests/Decode_Animated_WithTransparency_Rgba32_animated_transparent_firstframerestoreprev_loop.gif/02.png
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:d21f4576486692122b6ee719d75883849f65ddb07f632ea1c62b42651c289688
+size 591
diff --git a/tests/Images/External/ReferenceOutput/GifDecoderTests/Decode_Animated_WithTransparency_Rgba32_animated_transparent_firstframerestoreprev_loop.gif/03.png b/tests/Images/External/ReferenceOutput/GifDecoderTests/Decode_Animated_WithTransparency_Rgba32_animated_transparent_firstframerestoreprev_loop.gif/03.png
new file mode 100644
index 0000000000..0c1090f662
--- /dev/null
+++ b/tests/Images/External/ReferenceOutput/GifDecoderTests/Decode_Animated_WithTransparency_Rgba32_animated_transparent_firstframerestoreprev_loop.gif/03.png
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:88db68f2d59301b8ff9326143455a03c94cb616220f6e8e3832f13effe0c09bc
+size 545
diff --git a/tests/Images/External/ReferenceOutput/GifDecoderTests/Decode_Animated_WithTransparency_Rgba32_animated_transparent_frame_norestore_loop.gif/00.png b/tests/Images/External/ReferenceOutput/GifDecoderTests/Decode_Animated_WithTransparency_Rgba32_animated_transparent_frame_norestore_loop.gif/00.png
new file mode 100644
index 0000000000..193cde24d9
--- /dev/null
+++ b/tests/Images/External/ReferenceOutput/GifDecoderTests/Decode_Animated_WithTransparency_Rgba32_animated_transparent_frame_norestore_loop.gif/00.png
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:18b60d2066cb53d41988da37b8c521ddcb5355b995320a8413b95522a0492140
+size 687
diff --git a/tests/Images/External/ReferenceOutput/GifDecoderTests/Decode_Animated_WithTransparency_Rgba32_animated_transparent_frame_norestore_loop.gif/01.png b/tests/Images/External/ReferenceOutput/GifDecoderTests/Decode_Animated_WithTransparency_Rgba32_animated_transparent_frame_norestore_loop.gif/01.png
new file mode 100644
index 0000000000..f289fdca31
--- /dev/null
+++ b/tests/Images/External/ReferenceOutput/GifDecoderTests/Decode_Animated_WithTransparency_Rgba32_animated_transparent_frame_norestore_loop.gif/01.png
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:034b0b6b94c13fbef8c44d650daa07362f113aae6600d63230a3f96e29b16dec
+size 790
diff --git a/tests/Images/External/ReferenceOutput/GifDecoderTests/Decode_Animated_WithTransparency_Rgba32_animated_transparent_frame_norestore_loop.gif/02.png b/tests/Images/External/ReferenceOutput/GifDecoderTests/Decode_Animated_WithTransparency_Rgba32_animated_transparent_frame_norestore_loop.gif/02.png
new file mode 100644
index 0000000000..07537b9df0
--- /dev/null
+++ b/tests/Images/External/ReferenceOutput/GifDecoderTests/Decode_Animated_WithTransparency_Rgba32_animated_transparent_frame_norestore_loop.gif/02.png
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:f4b3684db6e3df52a9eb520d562b51b54632e897e9e39bff5ce904ae00799f2f
+size 924
diff --git a/tests/Images/External/ReferenceOutput/GifDecoderTests/Decode_Animated_WithTransparency_Rgba32_animated_transparent_frame_norestore_loop.gif/03.png b/tests/Images/External/ReferenceOutput/GifDecoderTests/Decode_Animated_WithTransparency_Rgba32_animated_transparent_frame_norestore_loop.gif/03.png
new file mode 100644
index 0000000000..e376be6890
--- /dev/null
+++ b/tests/Images/External/ReferenceOutput/GifDecoderTests/Decode_Animated_WithTransparency_Rgba32_animated_transparent_frame_norestore_loop.gif/03.png
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:6e33c564f55b653a693105612949401002014821abaecaf654c96d0f2b5d59b4
+size 962
diff --git a/tests/Images/External/ReferenceOutput/GifDecoderTests/Decode_Animated_WithTransparency_Rgba32_animated_transparent_frame_restoreprev_loop.gif/00.png b/tests/Images/External/ReferenceOutput/GifDecoderTests/Decode_Animated_WithTransparency_Rgba32_animated_transparent_frame_restoreprev_loop.gif/00.png
new file mode 100644
index 0000000000..193cde24d9
--- /dev/null
+++ b/tests/Images/External/ReferenceOutput/GifDecoderTests/Decode_Animated_WithTransparency_Rgba32_animated_transparent_frame_restoreprev_loop.gif/00.png
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:18b60d2066cb53d41988da37b8c521ddcb5355b995320a8413b95522a0492140
+size 687
diff --git a/tests/Images/External/ReferenceOutput/GifDecoderTests/Decode_Animated_WithTransparency_Rgba32_animated_transparent_frame_restoreprev_loop.gif/01.png b/tests/Images/External/ReferenceOutput/GifDecoderTests/Decode_Animated_WithTransparency_Rgba32_animated_transparent_frame_restoreprev_loop.gif/01.png
new file mode 100644
index 0000000000..f289fdca31
--- /dev/null
+++ b/tests/Images/External/ReferenceOutput/GifDecoderTests/Decode_Animated_WithTransparency_Rgba32_animated_transparent_frame_restoreprev_loop.gif/01.png
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:034b0b6b94c13fbef8c44d650daa07362f113aae6600d63230a3f96e29b16dec
+size 790
diff --git a/tests/Images/External/ReferenceOutput/GifDecoderTests/Decode_Animated_WithTransparency_Rgba32_animated_transparent_frame_restoreprev_loop.gif/02.png b/tests/Images/External/ReferenceOutput/GifDecoderTests/Decode_Animated_WithTransparency_Rgba32_animated_transparent_frame_restoreprev_loop.gif/02.png
new file mode 100644
index 0000000000..27f29acbb0
--- /dev/null
+++ b/tests/Images/External/ReferenceOutput/GifDecoderTests/Decode_Animated_WithTransparency_Rgba32_animated_transparent_frame_restoreprev_loop.gif/02.png
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:a4f4eb12da36cd43c620aa5ad1c793bb6eb8431c61d2cc1b77c1118f35a741cc
+size 876
diff --git a/tests/Images/External/ReferenceOutput/GifDecoderTests/Decode_Animated_WithTransparency_Rgba32_animated_transparent_frame_restoreprev_loop.gif/03.png b/tests/Images/External/ReferenceOutput/GifDecoderTests/Decode_Animated_WithTransparency_Rgba32_animated_transparent_frame_restoreprev_loop.gif/03.png
new file mode 100644
index 0000000000..684c2fa389
--- /dev/null
+++ b/tests/Images/External/ReferenceOutput/GifDecoderTests/Decode_Animated_WithTransparency_Rgba32_animated_transparent_frame_restoreprev_loop.gif/03.png
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:15bf02e06c6819d74a0a79cbfc5c86913c248a8812ff0ec613c0e747a000241b
+size 789
diff --git a/tests/Images/External/ReferenceOutput/GifDecoderTests/Decode_Animated_WithTransparency_Rgba32_animated_transparent_loop.gif/00.png b/tests/Images/External/ReferenceOutput/GifDecoderTests/Decode_Animated_WithTransparency_Rgba32_animated_transparent_loop.gif/00.png
new file mode 100644
index 0000000000..193cde24d9
--- /dev/null
+++ b/tests/Images/External/ReferenceOutput/GifDecoderTests/Decode_Animated_WithTransparency_Rgba32_animated_transparent_loop.gif/00.png
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:18b60d2066cb53d41988da37b8c521ddcb5355b995320a8413b95522a0492140
+size 687
diff --git a/tests/Images/External/ReferenceOutput/GifDecoderTests/Decode_Animated_WithTransparency_Rgba32_animated_transparent_loop.gif/01.png b/tests/Images/External/ReferenceOutput/GifDecoderTests/Decode_Animated_WithTransparency_Rgba32_animated_transparent_loop.gif/01.png
new file mode 100644
index 0000000000..7818cf380f
--- /dev/null
+++ b/tests/Images/External/ReferenceOutput/GifDecoderTests/Decode_Animated_WithTransparency_Rgba32_animated_transparent_loop.gif/01.png
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:01f389a2e93023f3132927a9565c04c8c1f827e36111ebe682177adecc3a27ee
+size 774
diff --git a/tests/Images/External/ReferenceOutput/GifDecoderTests/Decode_Animated_WithTransparency_Rgba32_animated_transparent_loop.gif/02.png b/tests/Images/External/ReferenceOutput/GifDecoderTests/Decode_Animated_WithTransparency_Rgba32_animated_transparent_loop.gif/02.png
new file mode 100644
index 0000000000..18bc408639
--- /dev/null
+++ b/tests/Images/External/ReferenceOutput/GifDecoderTests/Decode_Animated_WithTransparency_Rgba32_animated_transparent_loop.gif/02.png
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:00ef57db2fef89112ac7d1808afb6803612c6a20fc589166be6d6b7007c46400
+size 946
diff --git a/tests/Images/External/ReferenceOutput/GifDecoderTests/Decode_Animated_WithTransparency_Rgba32_animated_transparent_loop.gif/03.png b/tests/Images/External/ReferenceOutput/GifDecoderTests/Decode_Animated_WithTransparency_Rgba32_animated_transparent_loop.gif/03.png
new file mode 100644
index 0000000000..bd2ea67aed
--- /dev/null
+++ b/tests/Images/External/ReferenceOutput/GifDecoderTests/Decode_Animated_WithTransparency_Rgba32_animated_transparent_loop.gif/03.png
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:deafa4d4f8fd84489c061ca1042c2ad9e655fff3b6419248cfb35fa4ea40d9e6
+size 1000
diff --git a/tests/Images/External/ReferenceOutput/GifDecoderTests/Decode_Static_No_Animation_Rgba32_static_nontransparent.png b/tests/Images/External/ReferenceOutput/GifDecoderTests/Decode_Static_No_Animation_Rgba32_static_nontransparent.png
new file mode 100644
index 0000000000..65b2c6ff72
--- /dev/null
+++ b/tests/Images/External/ReferenceOutput/GifDecoderTests/Decode_Static_No_Animation_Rgba32_static_nontransparent.png
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:0b980fb1927a70f88bd26b039c54e4ea20a6a1ad68aacd6f1a68a46eb1997a29
+size 1180
diff --git a/tests/Images/External/ReferenceOutput/GifDecoderTests/Decode_Static_No_Animation_Rgba32_static_transparent.png b/tests/Images/External/ReferenceOutput/GifDecoderTests/Decode_Static_No_Animation_Rgba32_static_transparent.png
new file mode 100644
index 0000000000..193cde24d9
--- /dev/null
+++ b/tests/Images/External/ReferenceOutput/GifDecoderTests/Decode_Static_No_Animation_Rgba32_static_transparent.png
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:18b60d2066cb53d41988da37b8c521ddcb5355b995320a8413b95522a0492140
+size 687
diff --git a/tests/Images/External/ReferenceOutput/GifDecoderTests/Issue1962_Rgba32_issue1962_tiniest_gif_1st.png b/tests/Images/External/ReferenceOutput/GifDecoderTests/Issue1962_Rgba32_issue1962_tiniest_gif_1st.png
index 24f5e9c0cd..a52b27708a 100644
--- a/tests/Images/External/ReferenceOutput/GifDecoderTests/Issue1962_Rgba32_issue1962_tiniest_gif_1st.png
+++ b/tests/Images/External/ReferenceOutput/GifDecoderTests/Issue1962_Rgba32_issue1962_tiniest_gif_1st.png
@@ -1,3 +1,3 @@
 version https://git-lfs.github.com/spec/v1
-oid sha256:4f8c6d416f09671777934e57bc67fb52ccc97145dc6f1869e628d9ffd7d8f6e7
-size 119
+oid sha256:9ab8374e77865606a2426e3d22628f717914472431de1d9d8ee9690d319850a0
+size 118
diff --git a/tests/Images/External/ReferenceOutput/GifDecoderTests/Issue2012BadMinCode_Rgba32_issue2012_drona1.png b/tests/Images/External/ReferenceOutput/GifDecoderTests/Issue2012BadMinCode_Rgba32_issue2012_drona1.png
index b07e806620..5d443b52aa 100644
--- a/tests/Images/External/ReferenceOutput/GifDecoderTests/Issue2012BadMinCode_Rgba32_issue2012_drona1.png
+++ b/tests/Images/External/ReferenceOutput/GifDecoderTests/Issue2012BadMinCode_Rgba32_issue2012_drona1.png
@@ -1,3 +1,3 @@
 version https://git-lfs.github.com/spec/v1
-oid sha256:588d055a93c7b4fdb62e8b77f3ae08753a9e8990151cb0523f5e761996189b70
-size 142244
+oid sha256:a0e1677baade797de1eaec390f2e475865d24de8bd344edddbb3fce200d6bcb0
+size 135418
diff --git a/tests/Images/External/ReferenceOutput/GifDecoderTests/IssueTooLargeLzwBits_Rgba32_issue_2743.gif/00.png b/tests/Images/External/ReferenceOutput/GifDecoderTests/IssueTooLargeLzwBits_Rgba32_issue_2743.gif/00.png
index 923fbc1225..52f14e0f72 100644
--- a/tests/Images/External/ReferenceOutput/GifDecoderTests/IssueTooLargeLzwBits_Rgba32_issue_2743.gif/00.png
+++ b/tests/Images/External/ReferenceOutput/GifDecoderTests/IssueTooLargeLzwBits_Rgba32_issue_2743.gif/00.png
@@ -1,3 +1,3 @@
 version https://git-lfs.github.com/spec/v1
-oid sha256:800d1ec2d7c7c99d449db1f49ef202cf18214016eae65ebc4216d6f4b1f4d328
-size 537
+oid sha256:473c5629d7a9f8b3d6c809e8ede40f8fd38e90beddf71851b352c726fc0570d6
+size 534
diff --git a/tests/Images/External/ReferenceOutput/GifDecoderTests/IssueTooLargeLzwBits_Rgba32_issue_2743.gif/01.png b/tests/Images/External/ReferenceOutput/GifDecoderTests/IssueTooLargeLzwBits_Rgba32_issue_2743.gif/01.png
index 6c2134d8b8..b47f34ba04 100644
--- a/tests/Images/External/ReferenceOutput/GifDecoderTests/IssueTooLargeLzwBits_Rgba32_issue_2743.gif/01.png
+++ b/tests/Images/External/ReferenceOutput/GifDecoderTests/IssueTooLargeLzwBits_Rgba32_issue_2743.gif/01.png
@@ -1,3 +1,3 @@
 version https://git-lfs.github.com/spec/v1
-oid sha256:94dcd97831b16165f3331e429d72d7ef546e04038cab754c7918f9cf535ff30a
-size 542
+oid sha256:4b9b9f856c0347b460f824d6b027b343c65c67a29360793181c9a29a76f9002b
+size 538
diff --git a/tests/Images/External/ReferenceOutput/GifDecoderTests/IssueTooLargeLzwBits_Rgba32_issue_2743.gif/02.png b/tests/Images/External/ReferenceOutput/GifDecoderTests/IssueTooLargeLzwBits_Rgba32_issue_2743.gif/02.png
index 6f50397ea4..64869ca3c6 100644
--- a/tests/Images/External/ReferenceOutput/GifDecoderTests/IssueTooLargeLzwBits_Rgba32_issue_2743.gif/02.png
+++ b/tests/Images/External/ReferenceOutput/GifDecoderTests/IssueTooLargeLzwBits_Rgba32_issue_2743.gif/02.png
@@ -1,3 +1,3 @@
 version https://git-lfs.github.com/spec/v1
-oid sha256:ec1a589a8fae1b17a82b70a9583ea2ee012a476b1fa8fdba27fee2b7ce0403b2
-size 540
+oid sha256:74b8015c60d215808b1d663ae4af956d1454414206ba21326ad35b8952b0cab6
+size 534
diff --git a/tests/Images/External/ReferenceOutput/GifDecoderTests/IssueTooLargeLzwBits_Rgba32_issue_2743.gif/03.png b/tests/Images/External/ReferenceOutput/GifDecoderTests/IssueTooLargeLzwBits_Rgba32_issue_2743.gif/03.png
index 82061ba0aa..ab52225f8b 100644
--- a/tests/Images/External/ReferenceOutput/GifDecoderTests/IssueTooLargeLzwBits_Rgba32_issue_2743.gif/03.png
+++ b/tests/Images/External/ReferenceOutput/GifDecoderTests/IssueTooLargeLzwBits_Rgba32_issue_2743.gif/03.png
@@ -1,3 +1,3 @@
 version https://git-lfs.github.com/spec/v1
-oid sha256:0c8751f4fafd5c56066dbb8d64a3890fc420a3bd66881a55e309ba274b6d14e4
-size 542
+oid sha256:8dacb6a468d3cdc94613d56264ddf34d3649846edf33619fc13b9522fcf982d6
+size 539
diff --git a/tests/Images/External/ReferenceOutput/GifDecoderTests/IssueTooLargeLzwBits_Rgba32_issue_2743.gif/04.png b/tests/Images/External/ReferenceOutput/GifDecoderTests/IssueTooLargeLzwBits_Rgba32_issue_2743.gif/04.png
index 8902eb824a..78988aa60a 100644
--- a/tests/Images/External/ReferenceOutput/GifDecoderTests/IssueTooLargeLzwBits_Rgba32_issue_2743.gif/04.png
+++ b/tests/Images/External/ReferenceOutput/GifDecoderTests/IssueTooLargeLzwBits_Rgba32_issue_2743.gif/04.png
@@ -1,3 +1,3 @@
 version https://git-lfs.github.com/spec/v1
-oid sha256:b78516c9874cb15de4c4b98ed307e8105d962fc6bfa7aa3490b2c7e13b455a2d
-size 544
+oid sha256:8af74db6e01928ad54444fa122e4b87929741052c85abe9c0ffc998adffcbdfc
+size 542
diff --git a/tests/Images/External/ReferenceOutput/GifDecoderTests/IssueTooLargeLzwBits_Rgba32_issue_2743.gif/05.png b/tests/Images/External/ReferenceOutput/GifDecoderTests/IssueTooLargeLzwBits_Rgba32_issue_2743.gif/05.png
index 82061ba0aa..ab52225f8b 100644
--- a/tests/Images/External/ReferenceOutput/GifDecoderTests/IssueTooLargeLzwBits_Rgba32_issue_2743.gif/05.png
+++ b/tests/Images/External/ReferenceOutput/GifDecoderTests/IssueTooLargeLzwBits_Rgba32_issue_2743.gif/05.png
@@ -1,3 +1,3 @@
 version https://git-lfs.github.com/spec/v1
-oid sha256:0c8751f4fafd5c56066dbb8d64a3890fc420a3bd66881a55e309ba274b6d14e4
-size 542
+oid sha256:8dacb6a468d3cdc94613d56264ddf34d3649846edf33619fc13b9522fcf982d6
+size 539
diff --git a/tests/Images/External/ReferenceOutput/GifDecoderTests/IssueTooLargeLzwBits_Rgba32_issue_2743.gif/06.png b/tests/Images/External/ReferenceOutput/GifDecoderTests/IssueTooLargeLzwBits_Rgba32_issue_2743.gif/06.png
index 6f50397ea4..64869ca3c6 100644
--- a/tests/Images/External/ReferenceOutput/GifDecoderTests/IssueTooLargeLzwBits_Rgba32_issue_2743.gif/06.png
+++ b/tests/Images/External/ReferenceOutput/GifDecoderTests/IssueTooLargeLzwBits_Rgba32_issue_2743.gif/06.png
@@ -1,3 +1,3 @@
 version https://git-lfs.github.com/spec/v1
-oid sha256:ec1a589a8fae1b17a82b70a9583ea2ee012a476b1fa8fdba27fee2b7ce0403b2
-size 540
+oid sha256:74b8015c60d215808b1d663ae4af956d1454414206ba21326ad35b8952b0cab6
+size 534
diff --git a/tests/Images/External/ReferenceOutput/GifDecoderTests/IssueTooLargeLzwBits_Rgba32_issue_2743.gif/07.png b/tests/Images/External/ReferenceOutput/GifDecoderTests/IssueTooLargeLzwBits_Rgba32_issue_2743.gif/07.png
index efba40c99d..97610dbc00 100644
--- a/tests/Images/External/ReferenceOutput/GifDecoderTests/IssueTooLargeLzwBits_Rgba32_issue_2743.gif/07.png
+++ b/tests/Images/External/ReferenceOutput/GifDecoderTests/IssueTooLargeLzwBits_Rgba32_issue_2743.gif/07.png
@@ -1,3 +1,3 @@
 version https://git-lfs.github.com/spec/v1
-oid sha256:5016a323018f09e292165ad5392d82dcbad5e79c2b6b93aff3322dffff80b309
-size 126
+oid sha256:c816ca1e58d14361b84ba47454e4cbf4d3e4d29dfb7827756eb52ef2604f297c
+size 161
diff --git a/tests/Images/External/ReferenceOutput/GifEncoderTests/GifEncoder_CanDecode_AndEncode_Issue2866_Rgba32_issue_2866.gif/00.gif b/tests/Images/External/ReferenceOutput/GifEncoderTests/GifEncoder_CanDecode_AndEncode_Issue2866_Rgba32_issue_2866.gif/00.gif
new file mode 100644
index 0000000000..b219975ade
--- /dev/null
+++ b/tests/Images/External/ReferenceOutput/GifEncoderTests/GifEncoder_CanDecode_AndEncode_Issue2866_Rgba32_issue_2866.gif/00.gif
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:cb4bbef09dc6618380e34c5dcf8612fa5a51ba81a09edc5500be9191f0554d9c
+size 49665
diff --git a/tests/Images/External/ReferenceOutput/GifEncoderTests/GifEncoder_CanDecode_AndEncode_Issue2866_Rgba32_issue_2866.gif/08.gif b/tests/Images/External/ReferenceOutput/GifEncoderTests/GifEncoder_CanDecode_AndEncode_Issue2866_Rgba32_issue_2866.gif/08.gif
new file mode 100644
index 0000000000..2d50761636
--- /dev/null
+++ b/tests/Images/External/ReferenceOutput/GifEncoderTests/GifEncoder_CanDecode_AndEncode_Issue2866_Rgba32_issue_2866.gif/08.gif
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:81a0d629326bb39cfced1a261542e5f94b423527f95bc45422670091b91583b4
+size 50730
diff --git a/tests/Images/External/ReferenceOutput/GifEncoderTests/GifEncoder_CanDecode_AndEncode_Issue2866_Rgba32_issue_2866.gif/104.gif b/tests/Images/External/ReferenceOutput/GifEncoderTests/GifEncoder_CanDecode_AndEncode_Issue2866_Rgba32_issue_2866.gif/104.gif
new file mode 100644
index 0000000000..b1b7781a21
--- /dev/null
+++ b/tests/Images/External/ReferenceOutput/GifEncoderTests/GifEncoder_CanDecode_AndEncode_Issue2866_Rgba32_issue_2866.gif/104.gif
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:e64d9f2f7a8346f62c9b41a14b3e6b71f76a48e07fa42ac9e0d4a5b146a8a9da
+size 58856
diff --git a/tests/Images/External/ReferenceOutput/GifEncoderTests/GifEncoder_CanDecode_AndEncode_Issue2866_Rgba32_issue_2866.gif/112.gif b/tests/Images/External/ReferenceOutput/GifEncoderTests/GifEncoder_CanDecode_AndEncode_Issue2866_Rgba32_issue_2866.gif/112.gif
new file mode 100644
index 0000000000..f058764b4f
--- /dev/null
+++ b/tests/Images/External/ReferenceOutput/GifEncoderTests/GifEncoder_CanDecode_AndEncode_Issue2866_Rgba32_issue_2866.gif/112.gif
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:b01517c53b19f6b151a76cc75142ba3a8a45da8c6e94416447703cbd54ce1a8a
+size 48282
diff --git a/tests/Images/External/ReferenceOutput/GifEncoderTests/GifEncoder_CanDecode_AndEncode_Issue2866_Rgba32_issue_2866.gif/16.gif b/tests/Images/External/ReferenceOutput/GifEncoderTests/GifEncoder_CanDecode_AndEncode_Issue2866_Rgba32_issue_2866.gif/16.gif
new file mode 100644
index 0000000000..b9f1e2d099
--- /dev/null
+++ b/tests/Images/External/ReferenceOutput/GifEncoderTests/GifEncoder_CanDecode_AndEncode_Issue2866_Rgba32_issue_2866.gif/16.gif
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:1db212159613778c962883de9067852da3bea5f3483dd9f967c0aabbcdc1b2f6
+size 64655
diff --git a/tests/Images/External/ReferenceOutput/GifEncoderTests/GifEncoder_CanDecode_AndEncode_Issue2866_Rgba32_issue_2866.gif/24.gif b/tests/Images/External/ReferenceOutput/GifEncoderTests/GifEncoder_CanDecode_AndEncode_Issue2866_Rgba32_issue_2866.gif/24.gif
new file mode 100644
index 0000000000..c7a1368ce1
--- /dev/null
+++ b/tests/Images/External/ReferenceOutput/GifEncoderTests/GifEncoder_CanDecode_AndEncode_Issue2866_Rgba32_issue_2866.gif/24.gif
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:9d09ddfff1f26ed7842df5bf4b8938373700658322c85b154a878dd5e3a90dc1
+size 64432
diff --git a/tests/Images/External/ReferenceOutput/GifEncoderTests/GifEncoder_CanDecode_AndEncode_Issue2866_Rgba32_issue_2866.gif/32.gif b/tests/Images/External/ReferenceOutput/GifEncoderTests/GifEncoder_CanDecode_AndEncode_Issue2866_Rgba32_issue_2866.gif/32.gif
new file mode 100644
index 0000000000..ffd61e5123
--- /dev/null
+++ b/tests/Images/External/ReferenceOutput/GifEncoderTests/GifEncoder_CanDecode_AndEncode_Issue2866_Rgba32_issue_2866.gif/32.gif
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:18ca31ff631ecc33fe33a893e94e23af8b086a78c3684461e449c02800fffb2b
+size 66510
diff --git a/tests/Images/External/ReferenceOutput/GifEncoderTests/GifEncoder_CanDecode_AndEncode_Issue2866_Rgba32_issue_2866.gif/40.gif b/tests/Images/External/ReferenceOutput/GifEncoderTests/GifEncoder_CanDecode_AndEncode_Issue2866_Rgba32_issue_2866.gif/40.gif
new file mode 100644
index 0000000000..eb93ea4d4a
--- /dev/null
+++ b/tests/Images/External/ReferenceOutput/GifEncoderTests/GifEncoder_CanDecode_AndEncode_Issue2866_Rgba32_issue_2866.gif/40.gif
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:823358342cbc25a9f7ae34abc2669096acd7c0e0c93a8a0b371e548822ed0897
+size 66912
diff --git a/tests/Images/External/ReferenceOutput/GifEncoderTests/GifEncoder_CanDecode_AndEncode_Issue2866_Rgba32_issue_2866.gif/48.gif b/tests/Images/External/ReferenceOutput/GifEncoderTests/GifEncoder_CanDecode_AndEncode_Issue2866_Rgba32_issue_2866.gif/48.gif
new file mode 100644
index 0000000000..99f0e64dc6
--- /dev/null
+++ b/tests/Images/External/ReferenceOutput/GifEncoderTests/GifEncoder_CanDecode_AndEncode_Issue2866_Rgba32_issue_2866.gif/48.gif
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:90558311a7b7127d9f970a17ae0630d81507be246f511f1cc3b10c6ee953a25c
+size 61986
diff --git a/tests/Images/External/ReferenceOutput/GifEncoderTests/GifEncoder_CanDecode_AndEncode_Issue2866_Rgba32_issue_2866.gif/56.gif b/tests/Images/External/ReferenceOutput/GifEncoderTests/GifEncoder_CanDecode_AndEncode_Issue2866_Rgba32_issue_2866.gif/56.gif
new file mode 100644
index 0000000000..8e6410f9bf
--- /dev/null
+++ b/tests/Images/External/ReferenceOutput/GifEncoderTests/GifEncoder_CanDecode_AndEncode_Issue2866_Rgba32_issue_2866.gif/56.gif
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:9514b736d946d4e93ba3f59b586d2c29e0c031155f7824756ecf468ef87ea8e6
+size 61367
diff --git a/tests/Images/External/ReferenceOutput/GifEncoderTests/GifEncoder_CanDecode_AndEncode_Issue2866_Rgba32_issue_2866.gif/64.gif b/tests/Images/External/ReferenceOutput/GifEncoderTests/GifEncoder_CanDecode_AndEncode_Issue2866_Rgba32_issue_2866.gif/64.gif
new file mode 100644
index 0000000000..2257625c41
--- /dev/null
+++ b/tests/Images/External/ReferenceOutput/GifEncoderTests/GifEncoder_CanDecode_AndEncode_Issue2866_Rgba32_issue_2866.gif/64.gif
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:0334c551b9efcaa9f5c16c4599884b4aabe5129e3f023222be3214cf8623242e
+size 60825
diff --git a/tests/Images/External/ReferenceOutput/GifEncoderTests/GifEncoder_CanDecode_AndEncode_Issue2866_Rgba32_issue_2866.gif/72.gif b/tests/Images/External/ReferenceOutput/GifEncoderTests/GifEncoder_CanDecode_AndEncode_Issue2866_Rgba32_issue_2866.gif/72.gif
new file mode 100644
index 0000000000..efc9569f4d
--- /dev/null
+++ b/tests/Images/External/ReferenceOutput/GifEncoderTests/GifEncoder_CanDecode_AndEncode_Issue2866_Rgba32_issue_2866.gif/72.gif
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:32a9fecdad6508c1c6beae839717d1854cca1f7b247bff36a00a93cc953f608c
+size 57370
diff --git a/tests/Images/External/ReferenceOutput/GifEncoderTests/GifEncoder_CanDecode_AndEncode_Issue2866_Rgba32_issue_2866.gif/80.gif b/tests/Images/External/ReferenceOutput/GifEncoderTests/GifEncoder_CanDecode_AndEncode_Issue2866_Rgba32_issue_2866.gif/80.gif
new file mode 100644
index 0000000000..9f7ae53fb0
--- /dev/null
+++ b/tests/Images/External/ReferenceOutput/GifEncoderTests/GifEncoder_CanDecode_AndEncode_Issue2866_Rgba32_issue_2866.gif/80.gif
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:5d50d4ccba947ef95b9e8a2c4acd08f57c414f4e38a0d03d65b5fee093e4481a
+size 67784
diff --git a/tests/Images/External/ReferenceOutput/GifEncoderTests/GifEncoder_CanDecode_AndEncode_Issue2866_Rgba32_issue_2866.gif/88.gif b/tests/Images/External/ReferenceOutput/GifEncoderTests/GifEncoder_CanDecode_AndEncode_Issue2866_Rgba32_issue_2866.gif/88.gif
new file mode 100644
index 0000000000..22dc30784c
--- /dev/null
+++ b/tests/Images/External/ReferenceOutput/GifEncoderTests/GifEncoder_CanDecode_AndEncode_Issue2866_Rgba32_issue_2866.gif/88.gif
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:840780f2916cb9d010a95802d9c123c3051bcee5dde7b173a50854e3b5f3636a
+size 72552
diff --git a/tests/Images/External/ReferenceOutput/GifEncoderTests/GifEncoder_CanDecode_AndEncode_Issue2866_Rgba32_issue_2866.gif/96.gif b/tests/Images/External/ReferenceOutput/GifEncoderTests/GifEncoder_CanDecode_AndEncode_Issue2866_Rgba32_issue_2866.gif/96.gif
new file mode 100644
index 0000000000..53e1a35cbf
--- /dev/null
+++ b/tests/Images/External/ReferenceOutput/GifEncoderTests/GifEncoder_CanDecode_AndEncode_Issue2866_Rgba32_issue_2866.gif/96.gif
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:41db6ded3de84d43dec1175c1481f75a045c5ad126369e4e82ae29ec4bad0bc4
+size 76868
diff --git a/tests/Images/External/ReferenceOutput/IccProfileConverterTests/CanConvertToSRGB_Momiji-AdobeRGB-yes.png b/tests/Images/External/ReferenceOutput/IccProfileConverterTests/CanConvertToSRGB_Momiji-AdobeRGB-yes.png
new file mode 100644
index 0000000000..46d728c8d6
--- /dev/null
+++ b/tests/Images/External/ReferenceOutput/IccProfileConverterTests/CanConvertToSRGB_Momiji-AdobeRGB-yes.png
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:650256637c7039c59e135bbdabd31bee1ad99c9d9ff014562300945d41b6ac3a
+size 459515
diff --git a/tests/Images/External/ReferenceOutput/IccProfileConverterTests/CanConvertToSRGB_Momiji-AppleRGB-yes.png b/tests/Images/External/ReferenceOutput/IccProfileConverterTests/CanConvertToSRGB_Momiji-AppleRGB-yes.png
new file mode 100644
index 0000000000..3c856c2c32
--- /dev/null
+++ b/tests/Images/External/ReferenceOutput/IccProfileConverterTests/CanConvertToSRGB_Momiji-AppleRGB-yes.png
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:4e2d477de13a3767a364260b7b54b1f2a46c833e8df7aa1fded7990a3ac60563
+size 483943
diff --git a/tests/Images/External/ReferenceOutput/IccProfileConverterTests/CanConvertToSRGB_Momiji-ColorMatch-yes.png b/tests/Images/External/ReferenceOutput/IccProfileConverterTests/CanConvertToSRGB_Momiji-ColorMatch-yes.png
new file mode 100644
index 0000000000..408f52e11e
--- /dev/null
+++ b/tests/Images/External/ReferenceOutput/IccProfileConverterTests/CanConvertToSRGB_Momiji-ColorMatch-yes.png
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:7ee8f5c7f658b11a380e6da2130dc8563da3255f3ff5d9fd9cc98ec87bb1852b
+size 465348
diff --git a/tests/Images/External/ReferenceOutput/IccProfileConverterTests/CanConvertToSRGB_Momiji-ProPhoto-yes.png b/tests/Images/External/ReferenceOutput/IccProfileConverterTests/CanConvertToSRGB_Momiji-ProPhoto-yes.png
new file mode 100644
index 0000000000..714340ad6f
--- /dev/null
+++ b/tests/Images/External/ReferenceOutput/IccProfileConverterTests/CanConvertToSRGB_Momiji-ProPhoto-yes.png
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:c702f52b08ac5be9eb65fd1f4e841fc46c897db45c709974954265b93d46b854
+size 478310
diff --git a/tests/Images/External/ReferenceOutput/IccProfileConverterTests/CanConvertToSRGB_Momiji-WideRGB-yes.png b/tests/Images/External/ReferenceOutput/IccProfileConverterTests/CanConvertToSRGB_Momiji-WideRGB-yes.png
new file mode 100644
index 0000000000..c678bf52b3
--- /dev/null
+++ b/tests/Images/External/ReferenceOutput/IccProfileConverterTests/CanConvertToSRGB_Momiji-WideRGB-yes.png
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:f06f61eca4187823cfb76255caaa9f9f9d43e9ea56da3cd0fac830f6198d9d8a
+size 469400
diff --git a/tests/Images/External/ReferenceOutput/IccProfileConverterTests/CanConvertToSRGB_Momiji-sRGB-yes.png b/tests/Images/External/ReferenceOutput/IccProfileConverterTests/CanConvertToSRGB_Momiji-sRGB-yes.png
new file mode 100644
index 0000000000..786937c2bb
--- /dev/null
+++ b/tests/Images/External/ReferenceOutput/IccProfileConverterTests/CanConvertToSRGB_Momiji-sRGB-yes.png
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:dc3657d9aa0e36beee1d24144ace5bdd1198c0249ac661f302ae38b7d478d374
+size 436479
diff --git a/tests/Images/External/ReferenceOutput/IccProfileConverterTests/CanConvertToSRGB_issue-129.png b/tests/Images/External/ReferenceOutput/IccProfileConverterTests/CanConvertToSRGB_issue-129.png
new file mode 100644
index 0000000000..52dd0e0f3a
--- /dev/null
+++ b/tests/Images/External/ReferenceOutput/IccProfileConverterTests/CanConvertToSRGB_issue-129.png
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:d423959ad2f5c9a3fc8df0ca1ff9b3d6d6751bb552cee65dbda29623581cb816
+size 2043144
diff --git a/tests/Images/External/ReferenceOutput/JpegDecoderTests/Decode_CMYK_ICC_Jpeg_Rgba32_issue-129.png b/tests/Images/External/ReferenceOutput/JpegDecoderTests/Decode_CMYK_ICC_Jpeg_Rgba32_issue-129.png
new file mode 100644
index 0000000000..77a9d0d9cb
--- /dev/null
+++ b/tests/Images/External/ReferenceOutput/JpegDecoderTests/Decode_CMYK_ICC_Jpeg_Rgba32_issue-129.png
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:215cba73dfb0e19f75f6dc0c3fefca474bd65f57684a207a11d896e1637bb643
+size 1240827
diff --git a/tests/Images/External/ReferenceOutput/JpegDecoderTests/Decode_RGB_ICC_Jpeg_Rgba32_Momiji-AdobeRGB-yes.png b/tests/Images/External/ReferenceOutput/JpegDecoderTests/Decode_RGB_ICC_Jpeg_Rgba32_Momiji-AdobeRGB-yes.png
new file mode 100644
index 0000000000..0963e90b74
--- /dev/null
+++ b/tests/Images/External/ReferenceOutput/JpegDecoderTests/Decode_RGB_ICC_Jpeg_Rgba32_Momiji-AdobeRGB-yes.png
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:c942b534baa51b8e46e88bd38d1ced319bccf1b55a5711ae5761697b7437fe4e
+size 458321
diff --git a/tests/Images/External/ReferenceOutput/JpegDecoderTests/Decode_RGB_ICC_Jpeg_Rgba32_Momiji-AppleRGB-yes.png b/tests/Images/External/ReferenceOutput/JpegDecoderTests/Decode_RGB_ICC_Jpeg_Rgba32_Momiji-AppleRGB-yes.png
new file mode 100644
index 0000000000..1e5eaca4da
--- /dev/null
+++ b/tests/Images/External/ReferenceOutput/JpegDecoderTests/Decode_RGB_ICC_Jpeg_Rgba32_Momiji-AppleRGB-yes.png
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:163711226bdfa2f102b314435baea9f69ad1be1b11ef5ad8348358cd09a029ae
+size 482963
diff --git a/tests/Images/External/ReferenceOutput/JpegDecoderTests/Decode_RGB_ICC_Jpeg_Rgba32_Momiji-ColorMatch-yes.png b/tests/Images/External/ReferenceOutput/JpegDecoderTests/Decode_RGB_ICC_Jpeg_Rgba32_Momiji-ColorMatch-yes.png
new file mode 100644
index 0000000000..06bee00d7a
--- /dev/null
+++ b/tests/Images/External/ReferenceOutput/JpegDecoderTests/Decode_RGB_ICC_Jpeg_Rgba32_Momiji-ColorMatch-yes.png
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:6f7981f40bab5bffff3e7c9ea1676d224c173fabbaa6e7a920d7a9dabd58655f
+size 464917
diff --git a/tests/Images/External/ReferenceOutput/JpegDecoderTests/Decode_RGB_ICC_Jpeg_Rgba32_Momiji-ProPhoto-yes.png b/tests/Images/External/ReferenceOutput/JpegDecoderTests/Decode_RGB_ICC_Jpeg_Rgba32_Momiji-ProPhoto-yes.png
new file mode 100644
index 0000000000..3ae12c657a
--- /dev/null
+++ b/tests/Images/External/ReferenceOutput/JpegDecoderTests/Decode_RGB_ICC_Jpeg_Rgba32_Momiji-ProPhoto-yes.png
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:11b02b982c024e295915e88f56a428ad73068217a7ae625f705127ab8c35a4bf
+size 477061
diff --git a/tests/Images/External/ReferenceOutput/JpegDecoderTests/Decode_RGB_ICC_Jpeg_Rgba32_Momiji-WideRGB-yes.png b/tests/Images/External/ReferenceOutput/JpegDecoderTests/Decode_RGB_ICC_Jpeg_Rgba32_Momiji-WideRGB-yes.png
new file mode 100644
index 0000000000..0a2eb91cc5
--- /dev/null
+++ b/tests/Images/External/ReferenceOutput/JpegDecoderTests/Decode_RGB_ICC_Jpeg_Rgba32_Momiji-WideRGB-yes.png
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:a49967c20cccf824df4de3f105f5ddb44d7a602c072ce22caa38939f21f62505
+size 469827
diff --git a/tests/Images/External/ReferenceOutput/JpegDecoderTests/Decode_RGB_ICC_Jpeg_Rgba32_Momiji-sRGB-yes.png b/tests/Images/External/ReferenceOutput/JpegDecoderTests/Decode_RGB_ICC_Jpeg_Rgba32_Momiji-sRGB-yes.png
new file mode 100644
index 0000000000..fa554484bb
--- /dev/null
+++ b/tests/Images/External/ReferenceOutput/JpegDecoderTests/Decode_RGB_ICC_Jpeg_Rgba32_Momiji-sRGB-yes.png
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:4b33fc8fd03142aaaf8aabc39e084acd9e82e9222292e281953d92d65edcc1a7
+size 436111
diff --git a/tests/Images/External/ReferenceOutput/JpegDecoderTests/Decode_YCCK_ICC_Jpeg_Rgba32_issue_2723.png b/tests/Images/External/ReferenceOutput/JpegDecoderTests/Decode_YCCK_ICC_Jpeg_Rgba32_issue_2723.png
new file mode 100644
index 0000000000..bf95566838
--- /dev/null
+++ b/tests/Images/External/ReferenceOutput/JpegDecoderTests/Decode_YCCK_ICC_Jpeg_Rgba32_issue_2723.png
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:cef85199e8560d6669766c094d078831024e44ac7fc537f8696f802c8e06138b
+size 420141
diff --git a/tests/Images/External/ReferenceOutput/PngDecoderTests/CanDecode_Issue2924_Rgba32_Issue_2924.png b/tests/Images/External/ReferenceOutput/PngDecoderTests/CanDecode_Issue2924_Rgba32_Issue_2924.png
new file mode 100644
index 0000000000..023f346e03
--- /dev/null
+++ b/tests/Images/External/ReferenceOutput/PngDecoderTests/CanDecode_Issue2924_Rgba32_Issue_2924.png
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:4347cd89196c09496288724afdd876b227063149bba33615c338ebb474a0cb19
+size 47260
diff --git a/tests/Images/External/ReferenceOutput/PngEncoderTests/Encode_AnimatedFormatTransform_FromGif_Rgba32_issue_2866.gif/00.png b/tests/Images/External/ReferenceOutput/PngEncoderTests/Encode_AnimatedFormatTransform_FromGif_Rgba32_issue_2866.gif/00.png
new file mode 100644
index 0000000000..17c8e35c6f
--- /dev/null
+++ b/tests/Images/External/ReferenceOutput/PngEncoderTests/Encode_AnimatedFormatTransform_FromGif_Rgba32_issue_2866.gif/00.png
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:4aa1dea5da7a94fddd2259cd86e7171a57cb5cd2198decedd86149778b9aa20a
+size 64030
diff --git a/tests/Images/External/ReferenceOutput/PngEncoderTests/Encode_AnimatedFormatTransform_FromGif_Rgba32_issue_2866.gif/08.png b/tests/Images/External/ReferenceOutput/PngEncoderTests/Encode_AnimatedFormatTransform_FromGif_Rgba32_issue_2866.gif/08.png
new file mode 100644
index 0000000000..f2ec385a88
--- /dev/null
+++ b/tests/Images/External/ReferenceOutput/PngEncoderTests/Encode_AnimatedFormatTransform_FromGif_Rgba32_issue_2866.gif/08.png
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:16d4159e492162372a16b08fb3a4fdf36908ce759c6a0ad72a0da4bbeb477b72
+size 68619
diff --git a/tests/Images/External/ReferenceOutput/PngEncoderTests/Encode_AnimatedFormatTransform_FromGif_Rgba32_issue_2866.gif/104.png b/tests/Images/External/ReferenceOutput/PngEncoderTests/Encode_AnimatedFormatTransform_FromGif_Rgba32_issue_2866.gif/104.png
new file mode 100644
index 0000000000..dc57ed717f
--- /dev/null
+++ b/tests/Images/External/ReferenceOutput/PngEncoderTests/Encode_AnimatedFormatTransform_FromGif_Rgba32_issue_2866.gif/104.png
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:1095bc829b8fab3c5fda66b90cdd751b81439ad80e9fc7d564a5212c75155b2c
+size 76100
diff --git a/tests/Images/External/ReferenceOutput/PngEncoderTests/Encode_AnimatedFormatTransform_FromGif_Rgba32_issue_2866.gif/112.png b/tests/Images/External/ReferenceOutput/PngEncoderTests/Encode_AnimatedFormatTransform_FromGif_Rgba32_issue_2866.gif/112.png
new file mode 100644
index 0000000000..0158b28407
--- /dev/null
+++ b/tests/Images/External/ReferenceOutput/PngEncoderTests/Encode_AnimatedFormatTransform_FromGif_Rgba32_issue_2866.gif/112.png
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:0212cd29319c0d90c18a5f90716156a888c9925e4a36a6d9bbbe8d67a706db8f
+size 66282
diff --git a/tests/Images/External/ReferenceOutput/PngEncoderTests/Encode_AnimatedFormatTransform_FromGif_Rgba32_issue_2866.gif/16.png b/tests/Images/External/ReferenceOutput/PngEncoderTests/Encode_AnimatedFormatTransform_FromGif_Rgba32_issue_2866.gif/16.png
new file mode 100644
index 0000000000..52867f468e
--- /dev/null
+++ b/tests/Images/External/ReferenceOutput/PngEncoderTests/Encode_AnimatedFormatTransform_FromGif_Rgba32_issue_2866.gif/16.png
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:620ea89afc2e41b6199c47b2e4777f5ef9afe139e22bfabca9ec094b0adcbdc2
+size 73862
diff --git a/tests/Images/External/ReferenceOutput/PngEncoderTests/Encode_AnimatedFormatTransform_FromGif_Rgba32_issue_2866.gif/24.png b/tests/Images/External/ReferenceOutput/PngEncoderTests/Encode_AnimatedFormatTransform_FromGif_Rgba32_issue_2866.gif/24.png
new file mode 100644
index 0000000000..26ae147489
--- /dev/null
+++ b/tests/Images/External/ReferenceOutput/PngEncoderTests/Encode_AnimatedFormatTransform_FromGif_Rgba32_issue_2866.gif/24.png
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:d39997f18af5b97ed32ea30c15da879f70906b4f5cf12439ea6ff2d229e40199
+size 75734
diff --git a/tests/Images/External/ReferenceOutput/PngEncoderTests/Encode_AnimatedFormatTransform_FromGif_Rgba32_issue_2866.gif/32.png b/tests/Images/External/ReferenceOutput/PngEncoderTests/Encode_AnimatedFormatTransform_FromGif_Rgba32_issue_2866.gif/32.png
new file mode 100644
index 0000000000..6cd5074ecf
--- /dev/null
+++ b/tests/Images/External/ReferenceOutput/PngEncoderTests/Encode_AnimatedFormatTransform_FromGif_Rgba32_issue_2866.gif/32.png
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:4b459edf763ffff8a8a016c1b7d9e13b7e99f6752e4452b52539d2eb0f7f31be
+size 79505
diff --git a/tests/Images/External/ReferenceOutput/PngEncoderTests/Encode_AnimatedFormatTransform_FromGif_Rgba32_issue_2866.gif/40.png b/tests/Images/External/ReferenceOutput/PngEncoderTests/Encode_AnimatedFormatTransform_FromGif_Rgba32_issue_2866.gif/40.png
new file mode 100644
index 0000000000..8b9ea7c239
--- /dev/null
+++ b/tests/Images/External/ReferenceOutput/PngEncoderTests/Encode_AnimatedFormatTransform_FromGif_Rgba32_issue_2866.gif/40.png
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:f1957c82709b22abbaa354ecd679159eeddf135aabb301c266518c23ff4918f9
+size 77588
diff --git a/tests/Images/External/ReferenceOutput/PngEncoderTests/Encode_AnimatedFormatTransform_FromGif_Rgba32_issue_2866.gif/48.png b/tests/Images/External/ReferenceOutput/PngEncoderTests/Encode_AnimatedFormatTransform_FromGif_Rgba32_issue_2866.gif/48.png
new file mode 100644
index 0000000000..4430290427
--- /dev/null
+++ b/tests/Images/External/ReferenceOutput/PngEncoderTests/Encode_AnimatedFormatTransform_FromGif_Rgba32_issue_2866.gif/48.png
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:ae33b303bd1feae301cf645ee6596c499ad4eaa9164c52a37fca760169f9f363
+size 80317
diff --git a/tests/Images/External/ReferenceOutput/PngEncoderTests/Encode_AnimatedFormatTransform_FromGif_Rgba32_issue_2866.gif/56.png b/tests/Images/External/ReferenceOutput/PngEncoderTests/Encode_AnimatedFormatTransform_FromGif_Rgba32_issue_2866.gif/56.png
new file mode 100644
index 0000000000..8feae54c6a
--- /dev/null
+++ b/tests/Images/External/ReferenceOutput/PngEncoderTests/Encode_AnimatedFormatTransform_FromGif_Rgba32_issue_2866.gif/56.png
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:d86360bd43de392a9cf4b671a4cf3cd7ba9f61952a6d0400a5baab7dbb5eeb6d
+size 78578
diff --git a/tests/Images/External/ReferenceOutput/PngEncoderTests/Encode_AnimatedFormatTransform_FromGif_Rgba32_issue_2866.gif/64.png b/tests/Images/External/ReferenceOutput/PngEncoderTests/Encode_AnimatedFormatTransform_FromGif_Rgba32_issue_2866.gif/64.png
new file mode 100644
index 0000000000..284ad99233
--- /dev/null
+++ b/tests/Images/External/ReferenceOutput/PngEncoderTests/Encode_AnimatedFormatTransform_FromGif_Rgba32_issue_2866.gif/64.png
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:60e1694b121d0d3fa17d62f4477de349376aa6c2a98b83f9a4525da9ea471662
+size 75204
diff --git a/tests/Images/External/ReferenceOutput/PngEncoderTests/Encode_AnimatedFormatTransform_FromGif_Rgba32_issue_2866.gif/72.png b/tests/Images/External/ReferenceOutput/PngEncoderTests/Encode_AnimatedFormatTransform_FromGif_Rgba32_issue_2866.gif/72.png
new file mode 100644
index 0000000000..d09b77afca
--- /dev/null
+++ b/tests/Images/External/ReferenceOutput/PngEncoderTests/Encode_AnimatedFormatTransform_FromGif_Rgba32_issue_2866.gif/72.png
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:9348ef330a239bea501f41a3256107fc10a6bb323642118b1fcbe5227b742c88
+size 79048
diff --git a/tests/Images/External/ReferenceOutput/PngEncoderTests/Encode_AnimatedFormatTransform_FromGif_Rgba32_issue_2866.gif/80.png b/tests/Images/External/ReferenceOutput/PngEncoderTests/Encode_AnimatedFormatTransform_FromGif_Rgba32_issue_2866.gif/80.png
new file mode 100644
index 0000000000..d31fd5a808
--- /dev/null
+++ b/tests/Images/External/ReferenceOutput/PngEncoderTests/Encode_AnimatedFormatTransform_FromGif_Rgba32_issue_2866.gif/80.png
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:452dd2339b6ad3e35528601c289d88eafcc7e9a6e717f25da2bbf4267b85be97
+size 81553
diff --git a/tests/Images/External/ReferenceOutput/PngEncoderTests/Encode_AnimatedFormatTransform_FromGif_Rgba32_issue_2866.gif/88.png b/tests/Images/External/ReferenceOutput/PngEncoderTests/Encode_AnimatedFormatTransform_FromGif_Rgba32_issue_2866.gif/88.png
new file mode 100644
index 0000000000..669dfb8600
--- /dev/null
+++ b/tests/Images/External/ReferenceOutput/PngEncoderTests/Encode_AnimatedFormatTransform_FromGif_Rgba32_issue_2866.gif/88.png
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:b67e3b57b62f9e1c924de6fbd2699f93a6594812ad8c4cafd6160323547b1a88
+size 86402
diff --git a/tests/Images/External/ReferenceOutput/PngEncoderTests/Encode_AnimatedFormatTransform_FromGif_Rgba32_issue_2866.gif/96.png b/tests/Images/External/ReferenceOutput/PngEncoderTests/Encode_AnimatedFormatTransform_FromGif_Rgba32_issue_2866.gif/96.png
new file mode 100644
index 0000000000..f9a5aee191
--- /dev/null
+++ b/tests/Images/External/ReferenceOutput/PngEncoderTests/Encode_AnimatedFormatTransform_FromGif_Rgba32_issue_2866.gif/96.png
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:887e94402f93a491820d3d25d641c5901cf796c1275a2feb9e1c072a6a63ce28
+size 87335
diff --git a/tests/Images/External/ReferenceOutput/PngEncoderTests/Encode_AnimatedFormatTransform_FromGif_Rgba32_leo.gif/00.png b/tests/Images/External/ReferenceOutput/PngEncoderTests/Encode_AnimatedFormatTransform_FromGif_Rgba32_leo.gif/00.png
new file mode 100644
index 0000000000..961e205f9f
--- /dev/null
+++ b/tests/Images/External/ReferenceOutput/PngEncoderTests/Encode_AnimatedFormatTransform_FromGif_Rgba32_leo.gif/00.png
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:a6baac5db47ef2ee3ba72c7e8d5e04fc888c5e1460d4d7e348f63b597e1b5ff7
+size 23660
diff --git a/tests/Images/External/ReferenceOutput/PngEncoderTests/Encode_AnimatedFormatTransform_FromGif_Rgba32_leo.gif/08.png b/tests/Images/External/ReferenceOutput/PngEncoderTests/Encode_AnimatedFormatTransform_FromGif_Rgba32_leo.gif/08.png
new file mode 100644
index 0000000000..82cb6168e8
--- /dev/null
+++ b/tests/Images/External/ReferenceOutput/PngEncoderTests/Encode_AnimatedFormatTransform_FromGif_Rgba32_leo.gif/08.png
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:7fad45a0682a70a1fb84eec76d4a80ee054e85df59e6729508f3698d39999e31
+size 29509
diff --git a/tests/Images/External/ReferenceOutput/PngEncoderTests/Issue2668_Quantized_Encode_Alpha_Rgba32_Issue_2668.png b/tests/Images/External/ReferenceOutput/PngEncoderTests/Issue2668_Quantized_Encode_Alpha_Rgba32_Issue_2668.png
index 7af5391f70..b292138707 100644
--- a/tests/Images/External/ReferenceOutput/PngEncoderTests/Issue2668_Quantized_Encode_Alpha_Rgba32_Issue_2668.png
+++ b/tests/Images/External/ReferenceOutput/PngEncoderTests/Issue2668_Quantized_Encode_Alpha_Rgba32_Issue_2668.png
@@ -1,3 +1,3 @@
 version https://git-lfs.github.com/spec/v1
-oid sha256:f934af128b85b9e8f557d71ac8b1f1473a0922d0754fc0c4ece0d0e3d8d94c39
-size 7702
+oid sha256:df34f8f3640b145add4f24f8003c288fe7991373b079a87b4be90842e18c82ae
+size 8236
diff --git a/tests/Images/External/ReferenceOutput/QuantizerTests/ApplyQuantizationInBox_Bike_OctreeQuantizer_ErrorDither.png b/tests/Images/External/ReferenceOutput/QuantizerTests/ApplyQuantizationInBox_Bike_OctreeQuantizer_ErrorDither.png
index 4948c7adee..327366f5b6 100644
--- a/tests/Images/External/ReferenceOutput/QuantizerTests/ApplyQuantizationInBox_Bike_OctreeQuantizer_ErrorDither.png
+++ b/tests/Images/External/ReferenceOutput/QuantizerTests/ApplyQuantizationInBox_Bike_OctreeQuantizer_ErrorDither.png
@@ -1,3 +1,3 @@
 version https://git-lfs.github.com/spec/v1
-oid sha256:a51d04953c1c82d99884af62912d2271108c6bc62f18d4b32d0b5290c01fa7f7
-size 247462
+oid sha256:0086044f12a7c58e49733f203af29a8aff2826ea654730274720eada15669254
+size 249163
diff --git a/tests/Images/External/ReferenceOutput/QuantizerTests/ApplyQuantizationInBox_Bike_OctreeQuantizer_NoDither.png b/tests/Images/External/ReferenceOutput/QuantizerTests/ApplyQuantizationInBox_Bike_OctreeQuantizer_NoDither.png
index d993923d48..3e0be536e3 100644
--- a/tests/Images/External/ReferenceOutput/QuantizerTests/ApplyQuantizationInBox_Bike_OctreeQuantizer_NoDither.png
+++ b/tests/Images/External/ReferenceOutput/QuantizerTests/ApplyQuantizationInBox_Bike_OctreeQuantizer_NoDither.png
@@ -1,3 +1,3 @@
 version https://git-lfs.github.com/spec/v1
-oid sha256:9f165908729d723818b6c5843bd75298d987448e2cd4278dfe3f388a62025add
-size 238396
+oid sha256:85ee8479984aa52f837badbc49085c5448597fbfd987438fe25b58bad475e85f
+size 239498
diff --git a/tests/Images/External/ReferenceOutput/QuantizerTests/ApplyQuantizationInBox_Bike_OctreeQuantizer_OrderedDither.png b/tests/Images/External/ReferenceOutput/QuantizerTests/ApplyQuantizationInBox_Bike_OctreeQuantizer_OrderedDither.png
index 223d3bc012..816fdf704b 100644
--- a/tests/Images/External/ReferenceOutput/QuantizerTests/ApplyQuantizationInBox_Bike_OctreeQuantizer_OrderedDither.png
+++ b/tests/Images/External/ReferenceOutput/QuantizerTests/ApplyQuantizationInBox_Bike_OctreeQuantizer_OrderedDither.png
@@ -1,3 +1,3 @@
 version https://git-lfs.github.com/spec/v1
-oid sha256:34eaa0696da00838e591b2c48e7797641521f7f3feb01abbd774591c4dd6f200
-size 265546
+oid sha256:4ee35a7c21e90a2de1bf953e1c0be96d4f63492d0c8b2809fe9f39a9d0e64191
+size 266755
diff --git a/tests/Images/External/ReferenceOutput/QuantizerTests/ApplyQuantizationInBox_CalliphoraPartial_OctreeQuantizer_ErrorDither.png b/tests/Images/External/ReferenceOutput/QuantizerTests/ApplyQuantizationInBox_CalliphoraPartial_OctreeQuantizer_ErrorDither.png
index ebb9ff6b00..f29db004f5 100644
--- a/tests/Images/External/ReferenceOutput/QuantizerTests/ApplyQuantizationInBox_CalliphoraPartial_OctreeQuantizer_ErrorDither.png
+++ b/tests/Images/External/ReferenceOutput/QuantizerTests/ApplyQuantizationInBox_CalliphoraPartial_OctreeQuantizer_ErrorDither.png
@@ -1,3 +1,3 @@
 version https://git-lfs.github.com/spec/v1
-oid sha256:f414473561bfa792c2e6342ff5e5dddffbdec5286932781b11a093803593b52a
-size 313787
+oid sha256:ce381c2d261b9b1ca61d8f6e2ff07b992283c327dc6b7cf53c7e5c9317abb7d3
+size 316443
diff --git a/tests/Images/External/ReferenceOutput/QuantizerTests/ApplyQuantizationInBox_CalliphoraPartial_OctreeQuantizer_NoDither.png b/tests/Images/External/ReferenceOutput/QuantizerTests/ApplyQuantizationInBox_CalliphoraPartial_OctreeQuantizer_NoDither.png
index 7e3080562c..284c3a2702 100644
--- a/tests/Images/External/ReferenceOutput/QuantizerTests/ApplyQuantizationInBox_CalliphoraPartial_OctreeQuantizer_NoDither.png
+++ b/tests/Images/External/ReferenceOutput/QuantizerTests/ApplyQuantizationInBox_CalliphoraPartial_OctreeQuantizer_NoDither.png
@@ -1,3 +1,3 @@
 version https://git-lfs.github.com/spec/v1
-oid sha256:0203ecb9e4665e7c3992b7da4777c6d35b539790506fc9ca2acbcbc2bdb5db18
-size 303979
+oid sha256:2bfc23a95df8a88ac6e2777d67f381e800d23647c162a9a97131a101bbb97143
+size 306703
diff --git a/tests/Images/External/ReferenceOutput/QuantizerTests/ApplyQuantizationInBox_CalliphoraPartial_OctreeQuantizer_OrderedDither.png b/tests/Images/External/ReferenceOutput/QuantizerTests/ApplyQuantizationInBox_CalliphoraPartial_OctreeQuantizer_OrderedDither.png
index 5626fa1b83..5911faa723 100644
--- a/tests/Images/External/ReferenceOutput/QuantizerTests/ApplyQuantizationInBox_CalliphoraPartial_OctreeQuantizer_OrderedDither.png
+++ b/tests/Images/External/ReferenceOutput/QuantizerTests/ApplyQuantizationInBox_CalliphoraPartial_OctreeQuantizer_OrderedDither.png
@@ -1,3 +1,3 @@
 version https://git-lfs.github.com/spec/v1
-oid sha256:62cdce27fc46a38a16995df8ed1501f65091d69315288479b1d613b1d87c8239
-size 321123
+oid sha256:9d3f58a108d933ec9ac0a5271af5b65d0a8ab9d521d54e48312b280cc42d71ac
+size 322049
diff --git a/tests/Images/External/ReferenceOutput/QuantizerTests/ApplyQuantizationWithDitheringScale_david_OctreeQuantizer_ErrorDither_0.25.png b/tests/Images/External/ReferenceOutput/QuantizerTests/ApplyQuantizationWithDitheringScale_david_OctreeQuantizer_ErrorDither_0.25.png
index 82b965123d..a2fb2a6760 100644
--- a/tests/Images/External/ReferenceOutput/QuantizerTests/ApplyQuantizationWithDitheringScale_david_OctreeQuantizer_ErrorDither_0.25.png
+++ b/tests/Images/External/ReferenceOutput/QuantizerTests/ApplyQuantizationWithDitheringScale_david_OctreeQuantizer_ErrorDither_0.25.png
@@ -1,3 +1,3 @@
 version https://git-lfs.github.com/spec/v1
-oid sha256:4bed69d43856ebd4b1af4055f8d3aacabd50c361a4e1e1f9cad080d799d6b744
-size 13853
+oid sha256:18a47a6fa0f7949daef6969a847d8bc04deeb16bb482211ec3a958bc63f23f89
+size 13158
diff --git a/tests/Images/External/ReferenceOutput/QuantizerTests/ApplyQuantizationWithDitheringScale_david_OctreeQuantizer_ErrorDither_0.5.png b/tests/Images/External/ReferenceOutput/QuantizerTests/ApplyQuantizationWithDitheringScale_david_OctreeQuantizer_ErrorDither_0.5.png
index 571b0db4b9..8d99eb49b2 100644
--- a/tests/Images/External/ReferenceOutput/QuantizerTests/ApplyQuantizationWithDitheringScale_david_OctreeQuantizer_ErrorDither_0.5.png
+++ b/tests/Images/External/ReferenceOutput/QuantizerTests/ApplyQuantizationWithDitheringScale_david_OctreeQuantizer_ErrorDither_0.5.png
@@ -1,3 +1,3 @@
 version https://git-lfs.github.com/spec/v1
-oid sha256:4c8c8393708002f06f9d8ed1ff8979db820035585c08b66ae463d94724fa64d3
-size 14330
+oid sha256:abfdd1e40c2c1d7fde419bda1da6e534ed989598e790b8ae4de35152a83f77a0
+size 13686
diff --git a/tests/Images/External/ReferenceOutput/QuantizerTests/ApplyQuantizationWithDitheringScale_david_OctreeQuantizer_ErrorDither_0.75.png b/tests/Images/External/ReferenceOutput/QuantizerTests/ApplyQuantizationWithDitheringScale_david_OctreeQuantizer_ErrorDither_0.75.png
index a1b3da6816..bf93c39ff8 100644
--- a/tests/Images/External/ReferenceOutput/QuantizerTests/ApplyQuantizationWithDitheringScale_david_OctreeQuantizer_ErrorDither_0.75.png
+++ b/tests/Images/External/ReferenceOutput/QuantizerTests/ApplyQuantizationWithDitheringScale_david_OctreeQuantizer_ErrorDither_0.75.png
@@ -1,3 +1,3 @@
 version https://git-lfs.github.com/spec/v1
-oid sha256:fda13875f4c762a95001426487cc04c9add39821eb793168fdbe5cc18e705643
-size 14566
+oid sha256:60c28eb1dc3c0416b20cec230917c0e4a70dd2929467bbab796ecbb04fe5a178
+size 13886
diff --git a/tests/Images/External/ReferenceOutput/QuantizerTests/ApplyQuantizationWithDitheringScale_david_OctreeQuantizer_ErrorDither_0.png b/tests/Images/External/ReferenceOutput/QuantizerTests/ApplyQuantizationWithDitheringScale_david_OctreeQuantizer_ErrorDither_0.png
index 82b965123d..a2fb2a6760 100644
--- a/tests/Images/External/ReferenceOutput/QuantizerTests/ApplyQuantizationWithDitheringScale_david_OctreeQuantizer_ErrorDither_0.png
+++ b/tests/Images/External/ReferenceOutput/QuantizerTests/ApplyQuantizationWithDitheringScale_david_OctreeQuantizer_ErrorDither_0.png
@@ -1,3 +1,3 @@
 version https://git-lfs.github.com/spec/v1
-oid sha256:4bed69d43856ebd4b1af4055f8d3aacabd50c361a4e1e1f9cad080d799d6b744
-size 13853
+oid sha256:18a47a6fa0f7949daef6969a847d8bc04deeb16bb482211ec3a958bc63f23f89
+size 13158
diff --git a/tests/Images/External/ReferenceOutput/QuantizerTests/ApplyQuantizationWithDitheringScale_david_OctreeQuantizer_ErrorDither_1.png b/tests/Images/External/ReferenceOutput/QuantizerTests/ApplyQuantizationWithDitheringScale_david_OctreeQuantizer_ErrorDither_1.png
index e0fc792026..457298b544 100644
--- a/tests/Images/External/ReferenceOutput/QuantizerTests/ApplyQuantizationWithDitheringScale_david_OctreeQuantizer_ErrorDither_1.png
+++ b/tests/Images/External/ReferenceOutput/QuantizerTests/ApplyQuantizationWithDitheringScale_david_OctreeQuantizer_ErrorDither_1.png
@@ -1,3 +1,3 @@
 version https://git-lfs.github.com/spec/v1
-oid sha256:cb826afb127fe4175e6e47253b8a8313b9d10aee193c316731f34e5d327a2591
-size 14580
+oid sha256:a523f097bf3b155f3823c5e400190b5d5e0d4470db7136576472c3257db76600
+size 13909
diff --git a/tests/Images/External/ReferenceOutput/QuantizerTests/ApplyQuantizationWithDitheringScale_david_OctreeQuantizer_OrderedDither_0.25.png b/tests/Images/External/ReferenceOutput/QuantizerTests/ApplyQuantizationWithDitheringScale_david_OctreeQuantizer_OrderedDither_0.25.png
index 491847e491..5431ffdefd 100644
--- a/tests/Images/External/ReferenceOutput/QuantizerTests/ApplyQuantizationWithDitheringScale_david_OctreeQuantizer_OrderedDither_0.25.png
+++ b/tests/Images/External/ReferenceOutput/QuantizerTests/ApplyQuantizationWithDitheringScale_david_OctreeQuantizer_OrderedDither_0.25.png
@@ -1,3 +1,3 @@
 version https://git-lfs.github.com/spec/v1
-oid sha256:37018ecc499651833208d846a0f446db94cc11eae002ab6e7ce45b3e7c09e86c
-size 17734
+oid sha256:dd8b648b89f9420a0004a5f95dd54dc3769d1f78816b6708c5c6e1c14e8533a1
+size 17802
diff --git a/tests/Images/External/ReferenceOutput/QuantizerTests/ApplyQuantizationWithDitheringScale_david_OctreeQuantizer_OrderedDither_0.5.png b/tests/Images/External/ReferenceOutput/QuantizerTests/ApplyQuantizationWithDitheringScale_david_OctreeQuantizer_OrderedDither_0.5.png
index 013bb4a3b7..02ade5b868 100644
--- a/tests/Images/External/ReferenceOutput/QuantizerTests/ApplyQuantizationWithDitheringScale_david_OctreeQuantizer_OrderedDither_0.5.png
+++ b/tests/Images/External/ReferenceOutput/QuantizerTests/ApplyQuantizationWithDitheringScale_david_OctreeQuantizer_OrderedDither_0.5.png
@@ -1,3 +1,3 @@
 version https://git-lfs.github.com/spec/v1
-oid sha256:c2f9ed902882f58704b22460bc64a7b27bc6f47fc2c822ee09f52345cc0d6ebf
-size 19255
+oid sha256:7e559263bd8c293797d59166e723fdaf8b1b6ff9ae20fabac0efc86d8306123e
+size 19266
diff --git a/tests/Images/External/ReferenceOutput/QuantizerTests/ApplyQuantizationWithDitheringScale_david_OctreeQuantizer_OrderedDither_0.75.png b/tests/Images/External/ReferenceOutput/QuantizerTests/ApplyQuantizationWithDitheringScale_david_OctreeQuantizer_OrderedDither_0.75.png
index 31fd7a5445..cfbb9c2d5c 100644
--- a/tests/Images/External/ReferenceOutput/QuantizerTests/ApplyQuantizationWithDitheringScale_david_OctreeQuantizer_OrderedDither_0.75.png
+++ b/tests/Images/External/ReferenceOutput/QuantizerTests/ApplyQuantizationWithDitheringScale_david_OctreeQuantizer_OrderedDither_0.75.png
@@ -1,3 +1,3 @@
 version https://git-lfs.github.com/spec/v1
-oid sha256:aad3f26f2939f3679afa2b6165db29885fff40bbb1d171d5ffecc7861b5fac31
-size 19654
+oid sha256:5ae4ba533dd19271937d7e02e8ed3d243f164820b7d3bb20a4390e2deaa1d0d6
+size 19639
diff --git a/tests/Images/External/ReferenceOutput/QuantizerTests/ApplyQuantizationWithDitheringScale_david_OctreeQuantizer_OrderedDither_0.png b/tests/Images/External/ReferenceOutput/QuantizerTests/ApplyQuantizationWithDitheringScale_david_OctreeQuantizer_OrderedDither_0.png
index 82b965123d..a2fb2a6760 100644
--- a/tests/Images/External/ReferenceOutput/QuantizerTests/ApplyQuantizationWithDitheringScale_david_OctreeQuantizer_OrderedDither_0.png
+++ b/tests/Images/External/ReferenceOutput/QuantizerTests/ApplyQuantizationWithDitheringScale_david_OctreeQuantizer_OrderedDither_0.png
@@ -1,3 +1,3 @@
 version https://git-lfs.github.com/spec/v1
-oid sha256:4bed69d43856ebd4b1af4055f8d3aacabd50c361a4e1e1f9cad080d799d6b744
-size 13853
+oid sha256:18a47a6fa0f7949daef6969a847d8bc04deeb16bb482211ec3a958bc63f23f89
+size 13158
diff --git a/tests/Images/External/ReferenceOutput/QuantizerTests/ApplyQuantizationWithDitheringScale_david_OctreeQuantizer_OrderedDither_1.png b/tests/Images/External/ReferenceOutput/QuantizerTests/ApplyQuantizationWithDitheringScale_david_OctreeQuantizer_OrderedDither_1.png
index e2a05b9bd5..ce546cbfe1 100644
--- a/tests/Images/External/ReferenceOutput/QuantizerTests/ApplyQuantizationWithDitheringScale_david_OctreeQuantizer_OrderedDither_1.png
+++ b/tests/Images/External/ReferenceOutput/QuantizerTests/ApplyQuantizationWithDitheringScale_david_OctreeQuantizer_OrderedDither_1.png
@@ -1,3 +1,3 @@
 version https://git-lfs.github.com/spec/v1
-oid sha256:6d21029fa22dbe72cdc60b90c758cb9becd9fce03a33580d9466c1aedd323c1c
-size 20000
+oid sha256:ac17dd1abc6405cb84e9d8a6404da2c2bdb220b3390d09613d3644baad6e8e99
+size 20128
diff --git a/tests/Images/External/ReferenceOutput/QuantizerTests/ApplyQuantizationWithDitheringScale_david_WuQuantizer_ErrorDither_0.25.png b/tests/Images/External/ReferenceOutput/QuantizerTests/ApplyQuantizationWithDitheringScale_david_WuQuantizer_ErrorDither_0.25.png
index dba9232097..eaf7e8241d 100644
--- a/tests/Images/External/ReferenceOutput/QuantizerTests/ApplyQuantizationWithDitheringScale_david_WuQuantizer_ErrorDither_0.25.png
+++ b/tests/Images/External/ReferenceOutput/QuantizerTests/ApplyQuantizationWithDitheringScale_david_WuQuantizer_ErrorDither_0.25.png
@@ -1,3 +1,3 @@
 version https://git-lfs.github.com/spec/v1
-oid sha256:faa91657288e6a6797d8459d41d5fecca3c0a2e8e63317ebaf47df28688d13d7
-size 13853
+oid sha256:4baf0e7bc4ae8b8a911d87f3a7af2bf3ef0235f77f3f509251f2d2f26cfb639d
+size 13158
diff --git a/tests/Images/External/ReferenceOutput/QuantizerTests/ApplyQuantizationWithDitheringScale_david_WuQuantizer_ErrorDither_0.5.png b/tests/Images/External/ReferenceOutput/QuantizerTests/ApplyQuantizationWithDitheringScale_david_WuQuantizer_ErrorDither_0.5.png
index ea062d5be6..02879b7a38 100644
--- a/tests/Images/External/ReferenceOutput/QuantizerTests/ApplyQuantizationWithDitheringScale_david_WuQuantizer_ErrorDither_0.5.png
+++ b/tests/Images/External/ReferenceOutput/QuantizerTests/ApplyQuantizationWithDitheringScale_david_WuQuantizer_ErrorDither_0.5.png
@@ -1,3 +1,3 @@
 version https://git-lfs.github.com/spec/v1
-oid sha256:79e48506430f3a9b25f484ef191fd820819c438392a4e588c2ecafb6db9a2210
-size 13775
+oid sha256:c4ac8b88b317281738d833fc71f52348d9f4f45ea5a1303dd91fdb8b42be4267
+size 13186
diff --git a/tests/Images/External/ReferenceOutput/QuantizerTests/ApplyQuantizationWithDitheringScale_david_WuQuantizer_ErrorDither_0.75.png b/tests/Images/External/ReferenceOutput/QuantizerTests/ApplyQuantizationWithDitheringScale_david_WuQuantizer_ErrorDither_0.75.png
index ae90ea9b5f..ba05094800 100644
--- a/tests/Images/External/ReferenceOutput/QuantizerTests/ApplyQuantizationWithDitheringScale_david_WuQuantizer_ErrorDither_0.75.png
+++ b/tests/Images/External/ReferenceOutput/QuantizerTests/ApplyQuantizationWithDitheringScale_david_WuQuantizer_ErrorDither_0.75.png
@@ -1,3 +1,3 @@
 version https://git-lfs.github.com/spec/v1
-oid sha256:f56c884a0e4666cd662d36ec3a0d4e751c899c0122595378154507fffc69fda4
-size 14010
+oid sha256:1305d54f2139d4577490317051d6ce94a7fc8dd45b902d87a30fb04098dd4594
+size 13407
diff --git a/tests/Images/External/ReferenceOutput/QuantizerTests/ApplyQuantizationWithDitheringScale_david_WuQuantizer_ErrorDither_0.png b/tests/Images/External/ReferenceOutput/QuantizerTests/ApplyQuantizationWithDitheringScale_david_WuQuantizer_ErrorDither_0.png
index dba9232097..eaf7e8241d 100644
--- a/tests/Images/External/ReferenceOutput/QuantizerTests/ApplyQuantizationWithDitheringScale_david_WuQuantizer_ErrorDither_0.png
+++ b/tests/Images/External/ReferenceOutput/QuantizerTests/ApplyQuantizationWithDitheringScale_david_WuQuantizer_ErrorDither_0.png
@@ -1,3 +1,3 @@
 version https://git-lfs.github.com/spec/v1
-oid sha256:faa91657288e6a6797d8459d41d5fecca3c0a2e8e63317ebaf47df28688d13d7
-size 13853
+oid sha256:4baf0e7bc4ae8b8a911d87f3a7af2bf3ef0235f77f3f509251f2d2f26cfb639d
+size 13158
diff --git a/tests/Images/External/ReferenceOutput/QuantizerTests/ApplyQuantizationWithDitheringScale_david_WuQuantizer_ErrorDither_1.png b/tests/Images/External/ReferenceOutput/QuantizerTests/ApplyQuantizationWithDitheringScale_david_WuQuantizer_ErrorDither_1.png
index 1e1795063b..b16a5a5c7b 100644
--- a/tests/Images/External/ReferenceOutput/QuantizerTests/ApplyQuantizationWithDitheringScale_david_WuQuantizer_ErrorDither_1.png
+++ b/tests/Images/External/ReferenceOutput/QuantizerTests/ApplyQuantizationWithDitheringScale_david_WuQuantizer_ErrorDither_1.png
@@ -1,3 +1,3 @@
 version https://git-lfs.github.com/spec/v1
-oid sha256:4095927693b3cd49df58c0c1d7c5430255350c9ae595408a52ad83b1a65614ac
-size 14269
+oid sha256:a3fc3a7ace123c330ea06072eb36dd5d65ed9154d4d0f55a828fc542c8a422c1
+size 13472
diff --git a/tests/Images/External/ReferenceOutput/QuantizerTests/ApplyQuantizationWithDitheringScale_david_WuQuantizer_OrderedDither_0.25.png b/tests/Images/External/ReferenceOutput/QuantizerTests/ApplyQuantizationWithDitheringScale_david_WuQuantizer_OrderedDither_0.25.png
index 29a3ed7ffd..6adac16cf5 100644
--- a/tests/Images/External/ReferenceOutput/QuantizerTests/ApplyQuantizationWithDitheringScale_david_WuQuantizer_OrderedDither_0.25.png
+++ b/tests/Images/External/ReferenceOutput/QuantizerTests/ApplyQuantizationWithDitheringScale_david_WuQuantizer_OrderedDither_0.25.png
@@ -1,3 +1,3 @@
 version https://git-lfs.github.com/spec/v1
-oid sha256:d062d4b79ee01942776ae13467e9bcbb529a7eeb5ad7c28ff3d0ccd3d88dcde6
-size 15962
+oid sha256:35757f2e0831cae2fbd3cc11ffaaae855e853ebaa9a1a5564b6568a5e1c442e9
+size 16031
diff --git a/tests/Images/External/ReferenceOutput/QuantizerTests/ApplyQuantizationWithDitheringScale_david_WuQuantizer_OrderedDither_0.png b/tests/Images/External/ReferenceOutput/QuantizerTests/ApplyQuantizationWithDitheringScale_david_WuQuantizer_OrderedDither_0.png
index dba9232097..eaf7e8241d 100644
--- a/tests/Images/External/ReferenceOutput/QuantizerTests/ApplyQuantizationWithDitheringScale_david_WuQuantizer_OrderedDither_0.png
+++ b/tests/Images/External/ReferenceOutput/QuantizerTests/ApplyQuantizationWithDitheringScale_david_WuQuantizer_OrderedDither_0.png
@@ -1,3 +1,3 @@
 version https://git-lfs.github.com/spec/v1
-oid sha256:faa91657288e6a6797d8459d41d5fecca3c0a2e8e63317ebaf47df28688d13d7
-size 13853
+oid sha256:4baf0e7bc4ae8b8a911d87f3a7af2bf3ef0235f77f3f509251f2d2f26cfb639d
+size 13158
diff --git a/tests/Images/External/ReferenceOutput/QuantizerTests/ApplyQuantization_Bike_OctreeQuantizer_ErrorDither.png b/tests/Images/External/ReferenceOutput/QuantizerTests/ApplyQuantization_Bike_OctreeQuantizer_ErrorDither.png
index 09c471914a..e9782bc076 100644
--- a/tests/Images/External/ReferenceOutput/QuantizerTests/ApplyQuantization_Bike_OctreeQuantizer_ErrorDither.png
+++ b/tests/Images/External/ReferenceOutput/QuantizerTests/ApplyQuantization_Bike_OctreeQuantizer_ErrorDither.png
@@ -1,3 +1,3 @@
 version https://git-lfs.github.com/spec/v1
-oid sha256:a40b319d264f046159722cb57599eda51de9ba3795272b3785901cdc51053fab
-size 83010
+oid sha256:b380eda5646fe97ee217ef711103001e54ee023fb8d95f7f3bbad19d886130da
+size 83702
diff --git a/tests/Images/External/ReferenceOutput/QuantizerTests/ApplyQuantization_Bike_OctreeQuantizer_NoDither.png b/tests/Images/External/ReferenceOutput/QuantizerTests/ApplyQuantization_Bike_OctreeQuantizer_NoDither.png
index 3bd7cbabbb..5e1556dc45 100644
--- a/tests/Images/External/ReferenceOutput/QuantizerTests/ApplyQuantization_Bike_OctreeQuantizer_NoDither.png
+++ b/tests/Images/External/ReferenceOutput/QuantizerTests/ApplyQuantization_Bike_OctreeQuantizer_NoDither.png
@@ -1,3 +1,3 @@
 version https://git-lfs.github.com/spec/v1
-oid sha256:3bc93509a983e20986614f4937f66d5d979bbb433a30a7736150934cf14b452a
-size 55213
+oid sha256:af9e6c3b9e9e90186fb66be188bad9f3f0738d558aab915b3c8dd78652010674
+size 55419
diff --git a/tests/Images/External/ReferenceOutput/QuantizerTests/ApplyQuantization_Bike_OctreeQuantizer_OrderedDither.png b/tests/Images/External/ReferenceOutput/QuantizerTests/ApplyQuantization_Bike_OctreeQuantizer_OrderedDither.png
index 34490e602d..601abdeb4c 100644
--- a/tests/Images/External/ReferenceOutput/QuantizerTests/ApplyQuantization_Bike_OctreeQuantizer_OrderedDither.png
+++ b/tests/Images/External/ReferenceOutput/QuantizerTests/ApplyQuantization_Bike_OctreeQuantizer_OrderedDither.png
@@ -1,3 +1,3 @@
 version https://git-lfs.github.com/spec/v1
-oid sha256:b92f3320120d53444cefc79b4684933cfe2b933dc79c2414496785743b5c8f18
-size 80808
+oid sha256:aba024f962e5dc96e118b68c19903045f43a327c6cf45643da195382ef79a778
+size 84368
diff --git a/tests/Images/External/ReferenceOutput/QuantizerTests/ApplyQuantization_Bike_WuQuantizer_ErrorDither.png b/tests/Images/External/ReferenceOutput/QuantizerTests/ApplyQuantization_Bike_WuQuantizer_ErrorDither.png
index 747ca70c1d..37e5035d86 100644
--- a/tests/Images/External/ReferenceOutput/QuantizerTests/ApplyQuantization_Bike_WuQuantizer_ErrorDither.png
+++ b/tests/Images/External/ReferenceOutput/QuantizerTests/ApplyQuantization_Bike_WuQuantizer_ErrorDither.png
@@ -1,3 +1,3 @@
 version https://git-lfs.github.com/spec/v1
-oid sha256:d58c425ce5b1ca56450095a66dea24b379935b0087aec7b4102f15a99f95a017
-size 101999
+oid sha256:3802cfe67638a24869d6cc9ace1d94460b4c0c26f2c91b12b95fa8f979de64bb
+size 101579
diff --git a/tests/Images/External/ReferenceOutput/QuantizerTests/ApplyQuantization_Bike_WuQuantizer_NoDither.png b/tests/Images/External/ReferenceOutput/QuantizerTests/ApplyQuantization_Bike_WuQuantizer_NoDither.png
index de464b94cc..e72ea4b246 100644
--- a/tests/Images/External/ReferenceOutput/QuantizerTests/ApplyQuantization_Bike_WuQuantizer_NoDither.png
+++ b/tests/Images/External/ReferenceOutput/QuantizerTests/ApplyQuantization_Bike_WuQuantizer_NoDither.png
@@ -1,3 +1,3 @@
 version https://git-lfs.github.com/spec/v1
-oid sha256:93a4822e39babba059a88536a965e4f3207e4402d2b92d7d18485fec5e9e69da
-size 84378
+oid sha256:bf2021eba9edbb2295924f8394472ac0bb237f0c462c39aa32a2074ef15f9acc
+size 81771
diff --git a/tests/Images/External/ReferenceOutput/QuantizerTests/ApplyQuantization_Bike_WuQuantizer_OrderedDither.png b/tests/Images/External/ReferenceOutput/QuantizerTests/ApplyQuantization_Bike_WuQuantizer_OrderedDither.png
index ce54548279..0997945e52 100644
--- a/tests/Images/External/ReferenceOutput/QuantizerTests/ApplyQuantization_Bike_WuQuantizer_OrderedDither.png
+++ b/tests/Images/External/ReferenceOutput/QuantizerTests/ApplyQuantization_Bike_WuQuantizer_OrderedDither.png
@@ -1,3 +1,3 @@
 version https://git-lfs.github.com/spec/v1
-oid sha256:35969c8dc96de4dacc3048ae760a0681278a2011993a0edbceaacc93d6fc3a67
-size 102713
+oid sha256:2d11b18946d373b995ecbb449c8c4cfcc7078aad1c8705997bcbf83131acde03
+size 102439
diff --git a/tests/Images/External/ReferenceOutput/QuantizerTests/ApplyQuantization_CalliphoraPartial_OctreeQuantizer_ErrorDither.png b/tests/Images/External/ReferenceOutput/QuantizerTests/ApplyQuantization_CalliphoraPartial_OctreeQuantizer_ErrorDither.png
index 5efcaedc94..314a056060 100644
--- a/tests/Images/External/ReferenceOutput/QuantizerTests/ApplyQuantization_CalliphoraPartial_OctreeQuantizer_ErrorDither.png
+++ b/tests/Images/External/ReferenceOutput/QuantizerTests/ApplyQuantization_CalliphoraPartial_OctreeQuantizer_ErrorDither.png
@@ -1,3 +1,3 @@
 version https://git-lfs.github.com/spec/v1
-oid sha256:40d012f4ecb4e36c94d086f8ec7bc199fbfd9fb30a9427a07b35df1b1e430a71
-size 95601
+oid sha256:2236e81d33fcfb50afb9d5fd1a38c5ddf5d33fbb52de1c3204a4a9892fd334ce
+size 99084
diff --git a/tests/Images/External/ReferenceOutput/QuantizerTests/ApplyQuantization_CalliphoraPartial_OctreeQuantizer_NoDither.png b/tests/Images/External/ReferenceOutput/QuantizerTests/ApplyQuantization_CalliphoraPartial_OctreeQuantizer_NoDither.png
index 916dc37566..5293046724 100644
--- a/tests/Images/External/ReferenceOutput/QuantizerTests/ApplyQuantization_CalliphoraPartial_OctreeQuantizer_NoDither.png
+++ b/tests/Images/External/ReferenceOutput/QuantizerTests/ApplyQuantization_CalliphoraPartial_OctreeQuantizer_NoDither.png
@@ -1,3 +1,3 @@
 version https://git-lfs.github.com/spec/v1
-oid sha256:fa64863f73dfd1c5daef645c54e9275136f66513a87750bee0ec8e13ac357da5
-size 79649
+oid sha256:c4b59097d1507236af2556ae5f2638360b223b7752cd4c8f760bc14673d811d0
+size 81709
diff --git a/tests/Images/External/ReferenceOutput/QuantizerTests/ApplyQuantization_CalliphoraPartial_OctreeQuantizer_OrderedDither.png b/tests/Images/External/ReferenceOutput/QuantizerTests/ApplyQuantization_CalliphoraPartial_OctreeQuantizer_OrderedDither.png
index f039dd222e..d253a321d5 100644
--- a/tests/Images/External/ReferenceOutput/QuantizerTests/ApplyQuantization_CalliphoraPartial_OctreeQuantizer_OrderedDither.png
+++ b/tests/Images/External/ReferenceOutput/QuantizerTests/ApplyQuantization_CalliphoraPartial_OctreeQuantizer_OrderedDither.png
@@ -1,3 +1,3 @@
 version https://git-lfs.github.com/spec/v1
-oid sha256:8f5138589c606de20ba193d4279f049ee1ecb3f1801b949d3436995bbf242cbe
-size 92683
+oid sha256:3fa41128fd3f7a6b4b74b758186494ce7ed780561b9825277fae0c345116b1d7
+size 95067
diff --git a/tests/Images/External/ReferenceOutput/QuantizerTests/ApplyQuantization_CalliphoraPartial_WebSafePaletteQuantizer_ErrorDither.png b/tests/Images/External/ReferenceOutput/QuantizerTests/ApplyQuantization_CalliphoraPartial_WebSafePaletteQuantizer_ErrorDither.png
index 2b897a5d6d..a14c2cb1f6 100644
--- a/tests/Images/External/ReferenceOutput/QuantizerTests/ApplyQuantization_CalliphoraPartial_WebSafePaletteQuantizer_ErrorDither.png
+++ b/tests/Images/External/ReferenceOutput/QuantizerTests/ApplyQuantization_CalliphoraPartial_WebSafePaletteQuantizer_ErrorDither.png
@@ -1,3 +1,3 @@
 version https://git-lfs.github.com/spec/v1
-oid sha256:007ac609ec61b39c7bdd04bc87a698f5cdc76eadd834c1457f41eb9c135c3f7b
+oid sha256:7fb3743098a8147fd24294d933d93a61ec0155d754f52544650f6589719905be
 size 60688
diff --git a/tests/Images/External/ReferenceOutput/QuantizerTests/ApplyQuantization_CalliphoraPartial_WebSafePaletteQuantizer_OrderedDither.png b/tests/Images/External/ReferenceOutput/QuantizerTests/ApplyQuantization_CalliphoraPartial_WebSafePaletteQuantizer_OrderedDither.png
index ac56fa9236..03848e81ce 100644
--- a/tests/Images/External/ReferenceOutput/QuantizerTests/ApplyQuantization_CalliphoraPartial_WebSafePaletteQuantizer_OrderedDither.png
+++ b/tests/Images/External/ReferenceOutput/QuantizerTests/ApplyQuantization_CalliphoraPartial_WebSafePaletteQuantizer_OrderedDither.png
@@ -1,3 +1,3 @@
 version https://git-lfs.github.com/spec/v1
-oid sha256:6d2289ed4fa0c679f0f120d260fec8ab40b1599043cc0a1fbebc6b67e238ff87
-size 51428
+oid sha256:ef033a419e2e1b06b57a66175bad9068f71ae4c862a66c5734f65cdaae8a27f0
+size 51461
diff --git a/tests/Images/External/ReferenceOutput/QuantizerTests/ApplyQuantization_CalliphoraPartial_WernerPaletteQuantizer_ErrorDither.png b/tests/Images/External/ReferenceOutput/QuantizerTests/ApplyQuantization_CalliphoraPartial_WernerPaletteQuantizer_ErrorDither.png
index 8b79a19e05..0d548ca79d 100644
--- a/tests/Images/External/ReferenceOutput/QuantizerTests/ApplyQuantization_CalliphoraPartial_WernerPaletteQuantizer_ErrorDither.png
+++ b/tests/Images/External/ReferenceOutput/QuantizerTests/ApplyQuantization_CalliphoraPartial_WernerPaletteQuantizer_ErrorDither.png
@@ -1,3 +1,3 @@
 version https://git-lfs.github.com/spec/v1
-oid sha256:ef2b6073b75a2de97a78d47d3b3e40c264687c5756f153d3d85bc5b2714cf85a
-size 68226
+oid sha256:e2f4f4e2237925403fd0228344f9fce9be96c0f26e3465775763aca775779763
+size 68222
diff --git a/tests/Images/External/ReferenceOutput/QuantizerTests/ApplyQuantization_CalliphoraPartial_WernerPaletteQuantizer_OrderedDither.png b/tests/Images/External/ReferenceOutput/QuantizerTests/ApplyQuantization_CalliphoraPartial_WernerPaletteQuantizer_OrderedDither.png
index 88cf83a306..b51076bd17 100644
--- a/tests/Images/External/ReferenceOutput/QuantizerTests/ApplyQuantization_CalliphoraPartial_WernerPaletteQuantizer_OrderedDither.png
+++ b/tests/Images/External/ReferenceOutput/QuantizerTests/ApplyQuantization_CalliphoraPartial_WernerPaletteQuantizer_OrderedDither.png
@@ -1,3 +1,3 @@
 version https://git-lfs.github.com/spec/v1
-oid sha256:513844ed95c2b50e792d3346398256846b8b280dbadf7ef3f4e11d58c1e679c0
-size 69529
+oid sha256:7a8d9c0d81525d9f37d2f36946939040aea30edfc2b7ec0bf329fb49f6c7d73f
+size 69896
diff --git a/tests/Images/External/ReferenceOutput/QuantizerTests/ApplyQuantization_CalliphoraPartial_WuQuantizer_ErrorDither.png b/tests/Images/External/ReferenceOutput/QuantizerTests/ApplyQuantization_CalliphoraPartial_WuQuantizer_ErrorDither.png
index a3eefcba20..7204abff47 100644
--- a/tests/Images/External/ReferenceOutput/QuantizerTests/ApplyQuantization_CalliphoraPartial_WuQuantizer_ErrorDither.png
+++ b/tests/Images/External/ReferenceOutput/QuantizerTests/ApplyQuantization_CalliphoraPartial_WuQuantizer_ErrorDither.png
@@ -1,3 +1,3 @@
 version https://git-lfs.github.com/spec/v1
-oid sha256:32b269d62d4eebe555d5d9f12b9958b41206848504bb985dcd1ff9c81a5003c6
-size 117073
+oid sha256:4474b94e2d563938e10ec0526e7d94ba06b440db51b910604e752f7f9e814d66
+size 110757
diff --git a/tests/Images/External/ReferenceOutput/QuantizerTests/ApplyQuantization_CalliphoraPartial_WuQuantizer_NoDither.png b/tests/Images/External/ReferenceOutput/QuantizerTests/ApplyQuantization_CalliphoraPartial_WuQuantizer_NoDither.png
index 3b0c46ac38..691623fc88 100644
--- a/tests/Images/External/ReferenceOutput/QuantizerTests/ApplyQuantization_CalliphoraPartial_WuQuantizer_NoDither.png
+++ b/tests/Images/External/ReferenceOutput/QuantizerTests/ApplyQuantization_CalliphoraPartial_WuQuantizer_NoDither.png
@@ -1,3 +1,3 @@
 version https://git-lfs.github.com/spec/v1
-oid sha256:12f58b00a16913cd85ffa18fcea580a59550dcc201295b060d55a870230f37f7
-size 113995
+oid sha256:58a61c1d9a1d05acd484948c3e5c0496dbc74c0060f5de71741de39eae04ffa8
+size 103875
diff --git a/tests/Images/External/ReferenceOutput/QuantizerTests/ApplyQuantization_CalliphoraPartial_WuQuantizer_OrderedDither.png b/tests/Images/External/ReferenceOutput/QuantizerTests/ApplyQuantization_CalliphoraPartial_WuQuantizer_OrderedDither.png
index 328f863307..e80e6c6e81 100644
--- a/tests/Images/External/ReferenceOutput/QuantizerTests/ApplyQuantization_CalliphoraPartial_WuQuantizer_OrderedDither.png
+++ b/tests/Images/External/ReferenceOutput/QuantizerTests/ApplyQuantization_CalliphoraPartial_WuQuantizer_OrderedDither.png
@@ -1,3 +1,3 @@
 version https://git-lfs.github.com/spec/v1
-oid sha256:867d7b727de278cbc01b7d2b8e968f1fc0d0a81a3e4af636ce4a6598a8709be6
-size 114630
+oid sha256:b6649918c0394ead13c016a57b6a08561290651bccac88f7f15ba0e29dc5faa4
+size 110422
diff --git a/tests/Images/External/ReferenceOutput/TiffDecoderTests/TiffDecoder_CanDecode_Cmyk_Rgba32_Cmyk-jpeg.png b/tests/Images/External/ReferenceOutput/TiffDecoderTests/TiffDecoder_CanDecode_Cmyk_Rgba32_Cmyk-jpeg.png
new file mode 100644
index 0000000000..06d60e0303
--- /dev/null
+++ b/tests/Images/External/ReferenceOutput/TiffDecoderTests/TiffDecoder_CanDecode_Cmyk_Rgba32_Cmyk-jpeg.png
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:7f68db78d765a7f36570cd7b57a1f06cfca24c3b4916d0692a4aa051209ec327
+size 616
diff --git a/tests/Images/External/ReferenceOutput/TiffDecoderTests/TiffDecoder_CanDecode_YccK_ICC_Rgba32_Issue2454_A.png b/tests/Images/External/ReferenceOutput/TiffDecoderTests/TiffDecoder_CanDecode_YccK_ICC_Rgba32_Issue2454_A.png
new file mode 100644
index 0000000000..97118c15b0
--- /dev/null
+++ b/tests/Images/External/ReferenceOutput/TiffDecoderTests/TiffDecoder_CanDecode_YccK_ICC_Rgba32_Issue2454_A.png
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:c4f77673028643af0ac02a8f6a1e2db14052177e3401c369391a8ff7e943770c
+size 7679254
diff --git a/tests/Images/External/ReferenceOutput/TiffDecoderTests/TiffDecoder_CanDecode_YccK_ICC_Rgba32_Issue2454_B.png b/tests/Images/External/ReferenceOutput/TiffDecoderTests/TiffDecoder_CanDecode_YccK_ICC_Rgba32_Issue2454_B.png
new file mode 100644
index 0000000000..52accc22dc
--- /dev/null
+++ b/tests/Images/External/ReferenceOutput/TiffDecoderTests/TiffDecoder_CanDecode_YccK_ICC_Rgba32_Issue2454_B.png
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:e616895c21fd8b19a216e8a3ef4968bd413589b5875efdac29860f019a710527
+size 7517284
diff --git a/tests/Images/External/ReferenceOutput/TiffDecoderTests/TiffDecoder_CanDecode_YccK_Rgba32_Issue2454_A.png b/tests/Images/External/ReferenceOutput/TiffDecoderTests/TiffDecoder_CanDecode_YccK_Rgba32_Issue2454_A.png
new file mode 100644
index 0000000000..350d1af68c
--- /dev/null
+++ b/tests/Images/External/ReferenceOutput/TiffDecoderTests/TiffDecoder_CanDecode_YccK_Rgba32_Issue2454_A.png
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:d7911e059049c427229136479740fd62e2e09907549ec3e1421a6a60da6167cc
+size 7840892
diff --git a/tests/Images/External/ReferenceOutput/TiffDecoderTests/TiffDecoder_CanDecode_YccK_Rgba32_Issue2454_B.png b/tests/Images/External/ReferenceOutput/TiffDecoderTests/TiffDecoder_CanDecode_YccK_Rgba32_Issue2454_B.png
new file mode 100644
index 0000000000..3dc99e604e
--- /dev/null
+++ b/tests/Images/External/ReferenceOutput/TiffDecoderTests/TiffDecoder_CanDecode_YccK_Rgba32_Issue2454_B.png
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:291f2033a7b4cfc10fb3301283c167b3fbc288bc173c95b21bc726bf076865af
+size 7649213
diff --git a/tests/Images/Input/Gif/animated_loop.gif b/tests/Images/Input/Gif/animated_loop.gif
new file mode 100644
index 0000000000..5fad702a10
--- /dev/null
+++ b/tests/Images/Input/Gif/animated_loop.gif
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:a8750149c953e9e910472684158c07a2cb551c1f7e95744ab48db1a67f63f342
+size 873
diff --git a/tests/Images/Input/Gif/animated_loop_interlaced.gif b/tests/Images/Input/Gif/animated_loop_interlaced.gif
new file mode 100644
index 0000000000..9577a84658
--- /dev/null
+++ b/tests/Images/Input/Gif/animated_loop_interlaced.gif
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:c2bc2f895f03092b1c26381a32b5dd5838aacd3331e07f7e4dae55d5cbb4e149
+size 878
diff --git a/tests/Images/Input/Gif/animated_transparent_firstframerestoreprev_loop.gif b/tests/Images/Input/Gif/animated_transparent_firstframerestoreprev_loop.gif
new file mode 100644
index 0000000000..5012324caf
--- /dev/null
+++ b/tests/Images/Input/Gif/animated_transparent_firstframerestoreprev_loop.gif
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:6b0cf18d386dc979fcf853d6a9adac673a2709a8751d31a94930199dededa25f
+size 536
diff --git a/tests/Images/Input/Gif/animated_transparent_frame_norestore_loop.gif b/tests/Images/Input/Gif/animated_transparent_frame_norestore_loop.gif
new file mode 100644
index 0000000000..712f334aba
--- /dev/null
+++ b/tests/Images/Input/Gif/animated_transparent_frame_norestore_loop.gif
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:ad7359801fa6ed89fb041de1e88faea856b1028d9f477fdc4eda774df6e5f1ce
+size 685
diff --git a/tests/Images/Input/Gif/animated_transparent_frame_restorebackground_loop.gif b/tests/Images/Input/Gif/animated_transparent_frame_restorebackground_loop.gif
new file mode 100644
index 0000000000..b6f675dcaf
--- /dev/null
+++ b/tests/Images/Input/Gif/animated_transparent_frame_restorebackground_loop.gif
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:12254f22eeee9eac6babbfbfb34b6ae9302342454fd6677e8c7c9937656cc127
+size 685
diff --git a/tests/Images/Input/Gif/animated_transparent_frame_restoreprev_loop.gif b/tests/Images/Input/Gif/animated_transparent_frame_restoreprev_loop.gif
new file mode 100644
index 0000000000..be7fdf85d8
--- /dev/null
+++ b/tests/Images/Input/Gif/animated_transparent_frame_restoreprev_loop.gif
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:0cdfba6efea653bb94ede6edd0577ba6af1f7c130307b94903dd94f0f8bbc4f9
+size 685
diff --git a/tests/Images/Input/Gif/animated_transparent_loop.gif b/tests/Images/Input/Gif/animated_transparent_loop.gif
new file mode 100644
index 0000000000..cb001ece8f
--- /dev/null
+++ b/tests/Images/Input/Gif/animated_transparent_loop.gif
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:3297987894ba27c2acc6a5c447c3d3a52cc169447b451409535decccc1743e55
+size 536
diff --git a/tests/Images/Input/Gif/animated_transparent_restoreprev_loop.gif b/tests/Images/Input/Gif/animated_transparent_restoreprev_loop.gif
new file mode 100644
index 0000000000..f51d02433e
--- /dev/null
+++ b/tests/Images/Input/Gif/animated_transparent_restoreprev_loop.gif
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:9418561ef2f2307456bb068ecc1a9d5aa02da5e314e7aadd722985e27503926b
+size 536
diff --git a/tests/Images/Input/Gif/issues/issue_2866.gif b/tests/Images/Input/Gif/issues/issue_2866.gif
new file mode 100644
index 0000000000..0ead86bf89
--- /dev/null
+++ b/tests/Images/Input/Gif/issues/issue_2866.gif
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:0b2a9e3728c41e1b45d6f865e4692eadbed28dcaec65806e6bda22a9a16f930f
+size 7526725
diff --git a/tests/Images/Input/Gif/issues/issue_2953.gif b/tests/Images/Input/Gif/issues/issue_2953.gif
new file mode 100644
index 0000000000..98c06e5c58
--- /dev/null
+++ b/tests/Images/Input/Gif/issues/issue_2953.gif
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:4fa4a002b264a41677cc10f115f3572111852993a53ee8cea5f4ec0bf8dec195
+size 40
diff --git a/tests/Images/Input/Gif/static_nontransparent.gif b/tests/Images/Input/Gif/static_nontransparent.gif
new file mode 100644
index 0000000000..17ab1e2ec7
--- /dev/null
+++ b/tests/Images/Input/Gif/static_nontransparent.gif
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:d0a5e1b2f0c5c1763eb950a1d92c5317f048875e04e88dca7f1a966552c2774c
+size 678
diff --git a/tests/Images/Input/Gif/static_transparent.gif b/tests/Images/Input/Gif/static_transparent.gif
new file mode 100644
index 0000000000..89039a732a
--- /dev/null
+++ b/tests/Images/Input/Gif/static_transparent.gif
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:f73f56bbe2206bd1cd8a4625b6a4d61506214b37b61ff3e8194e2030b28abca5
+size 341
diff --git a/tests/Images/Input/Jpg/icc-profiles/Momiji-AdobeRGB-yes.jpg b/tests/Images/Input/Jpg/icc-profiles/Momiji-AdobeRGB-yes.jpg
new file mode 100644
index 0000000000..077ee22beb
--- /dev/null
+++ b/tests/Images/Input/Jpg/icc-profiles/Momiji-AdobeRGB-yes.jpg
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:cb8bdcc137efa3e28db69e48612230b3a9fec17267de9ce29757d9bacc181d28
+size 42001
diff --git a/tests/Images/Input/Jpg/icc-profiles/Momiji-AppleRGB-yes.jpg b/tests/Images/Input/Jpg/icc-profiles/Momiji-AppleRGB-yes.jpg
new file mode 100644
index 0000000000..188faa2bdd
--- /dev/null
+++ b/tests/Images/Input/Jpg/icc-profiles/Momiji-AppleRGB-yes.jpg
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:7129f5485e997b75cff143021522cc8ab94e2c3c1912689bc765ce2b3b937441
+size 72150
diff --git a/tests/Images/Input/Jpg/icc-profiles/Momiji-ColorMatch-yes.jpg b/tests/Images/Input/Jpg/icc-profiles/Momiji-ColorMatch-yes.jpg
new file mode 100644
index 0000000000..befc3d1170
--- /dev/null
+++ b/tests/Images/Input/Jpg/icc-profiles/Momiji-ColorMatch-yes.jpg
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:fe7fa60a53893836200c62f34492c7a0c931692dd073dffa4afc49fe3826e433
+size 44446
diff --git a/tests/Images/Input/Jpg/icc-profiles/Momiji-ProPhoto-yes.jpg b/tests/Images/Input/Jpg/icc-profiles/Momiji-ProPhoto-yes.jpg
new file mode 100644
index 0000000000..645ad2869a
--- /dev/null
+++ b/tests/Images/Input/Jpg/icc-profiles/Momiji-ProPhoto-yes.jpg
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:bb686b44e3253143a32db890823f63c79026c9ac9badc4ad9de21f6cb2fa2f2a
+size 40703
diff --git a/tests/Images/Input/Jpg/icc-profiles/Momiji-WideRGB-yes.jpg b/tests/Images/Input/Jpg/icc-profiles/Momiji-WideRGB-yes.jpg
new file mode 100644
index 0000000000..57727aaa29
--- /dev/null
+++ b/tests/Images/Input/Jpg/icc-profiles/Momiji-WideRGB-yes.jpg
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:928b854a9629d1532d37095c4744da6bc2fc986f878a76aea373f69490f4b586
+size 40505
diff --git a/tests/Images/Input/Jpg/icc-profiles/Momiji-sRGB-yes.jpg b/tests/Images/Input/Jpg/icc-profiles/Momiji-sRGB-yes.jpg
new file mode 100644
index 0000000000..4b7b612be0
--- /dev/null
+++ b/tests/Images/Input/Jpg/icc-profiles/Momiji-sRGB-yes.jpg
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:faf67048c2b7bd3fb5fa9b69bd53943d63a216ef371c5dc9d062ac443c9d2d34
+size 47434
diff --git a/tests/Images/Input/Jpg/icc-profiles/issue-129.jpg b/tests/Images/Input/Jpg/icc-profiles/issue-129.jpg
new file mode 100644
index 0000000000..98949f43f1
--- /dev/null
+++ b/tests/Images/Input/Jpg/icc-profiles/issue-129.jpg
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:e1728dd548d862ef3f960c82528716e0ad1b8eb0119a5eed4dfde51026d7bb74
+size 2903429
diff --git a/tests/Images/Input/Jpg/icc-profiles/issue_2723.jpg b/tests/Images/Input/Jpg/icc-profiles/issue_2723.jpg
new file mode 100644
index 0000000000..4a342e07ed
--- /dev/null
+++ b/tests/Images/Input/Jpg/icc-profiles/issue_2723.jpg
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:56dc6400d8f4c42c505ec562e4ade0b23e613b2c16e1666eccbbaa8e997efcc7
+size 766523
diff --git a/tests/Images/Input/Jpg/issues/issue-2857-subsub-ifds.jpg b/tests/Images/Input/Jpg/issues/issue-2857-subsub-ifds.jpg
new file mode 100644
index 0000000000..5e5288f22e
--- /dev/null
+++ b/tests/Images/Input/Jpg/issues/issue-2857-subsub-ifds.jpg
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:ab45137ded01a42658aa94421165a358b184a536b6ab64427d8255e8d78c25b9
+size 2829977
diff --git a/tests/Images/Input/Png/issues/Issue_2882.png b/tests/Images/Input/Png/issues/Issue_2882.png
new file mode 100644
index 0000000000..2d7a51dacb
--- /dev/null
+++ b/tests/Images/Input/Png/issues/Issue_2882.png
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:cebc98e62bcfe31df73ae7b6980382f4b56bdf7e7e6e9037946f5a84cb51c7d2
+size 1117
diff --git a/tests/Images/Input/Png/issues/Issue_2924.png b/tests/Images/Input/Png/issues/Issue_2924.png
new file mode 100644
index 0000000000..0454642190
--- /dev/null
+++ b/tests/Images/Input/Png/issues/Issue_2924.png
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:fd366a2de522041c706729b01a6030df6c82a4e87ea3509cc78a47486f097044
+size 49376
diff --git a/tests/Images/Input/Png/issues/issue_2469-i.png b/tests/Images/Input/Png/issues/issue_2469-i.png
new file mode 100644
index 0000000000..bd651a3f2d
--- /dev/null
+++ b/tests/Images/Input/Png/issues/issue_2469-i.png
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:d4e0da0601ca5f479684359633c4dbd82881a35631d63477c01e8fd180e31482
+size 2521324
diff --git a/tests/Images/Input/Tiff/Cmyk-jpeg.tiff b/tests/Images/Input/Tiff/Cmyk-jpeg.tiff
new file mode 100644
index 0000000000..e486403e4f
--- /dev/null
+++ b/tests/Images/Input/Tiff/Cmyk-jpeg.tiff
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:abb923e457acc31a7f18c46a7d58fc5a42f5c3d197236403921e3ee623fa4fac
+size 2046
diff --git a/tests/Images/Input/Tiff/Cmyk-planar-jpg.tiff b/tests/Images/Input/Tiff/Cmyk-planar-jpg.tiff
new file mode 100644
index 0000000000..e486403e4f
--- /dev/null
+++ b/tests/Images/Input/Tiff/Cmyk-planar-jpg.tiff
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:abb923e457acc31a7f18c46a7d58fc5a42f5c3d197236403921e3ee623fa4fac
+size 2046
diff --git a/tests/Images/Input/Tiff/Issues/ExtraSamplesUnspecified.tif b/tests/Images/Input/Tiff/Issues/ExtraSamplesUnspecified.tif
new file mode 100644
index 0000000000..b5835c1ed8
--- /dev/null
+++ b/tests/Images/Input/Tiff/Issues/ExtraSamplesUnspecified.tif
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:71d28f17d2d56481faa4d241fae882eae4f8303c70f85bc3759f6a0c2074979e
+size 1426558
diff --git a/tests/Images/Input/Tiff/Issues/Issue2454_A.tif b/tests/Images/Input/Tiff/Issues/Issue2454_A.tif
new file mode 100644
index 0000000000..99e13be550
--- /dev/null
+++ b/tests/Images/Input/Tiff/Issues/Issue2454_A.tif
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:868fbf7fc7a61bc6b1226160c8dc3bb1faebd8d4a2a6fe9494962f3fbe3a7fdc
+size 5024256
diff --git a/tests/Images/Input/Tiff/Issues/Issue2454_B.tif b/tests/Images/Input/Tiff/Issues/Issue2454_B.tif
new file mode 100644
index 0000000000..9c322b7653
--- /dev/null
+++ b/tests/Images/Input/Tiff/Issues/Issue2454_B.tif
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:867851192f540742ba1481f503834f8aa77caa03ac59f8204d098bf940b0bb3a
+size 4387646
diff --git a/tests/Images/Input/Tiff/Issues/Issue2909.tiff b/tests/Images/Input/Tiff/Issues/Issue2909.tiff
new file mode 100644
index 0000000000..99f1f088ee
--- /dev/null
+++ b/tests/Images/Input/Tiff/Issues/Issue2909.tiff
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:3c69a7e7c7920766e98fccd273424a34e9094550e2176a7b4757ab2c0756d084
+size 1272
diff --git a/tests/Images/Input/Tiff/tiled_gray_16bit_big_endian_deflate_compressed_predictor.tiff b/tests/Images/Input/Tiff/tiled_gray_16bit_big_endian_deflate_compressed_predictor.tiff
new file mode 100644
index 0000000000..f99c06f3fa
--- /dev/null
+++ b/tests/Images/Input/Tiff/tiled_gray_16bit_big_endian_deflate_compressed_predictor.tiff
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:af45780d252025f690e039738f37a6656fea72ecdc8b816eea354259af46ebed
+size 87491
diff --git a/tests/Images/Input/Tiff/tiled_gray_16bit_big_endian_lzw_compressed_predictor.tiff b/tests/Images/Input/Tiff/tiled_gray_16bit_big_endian_lzw_compressed_predictor.tiff
new file mode 100644
index 0000000000..fbeb462fbc
--- /dev/null
+++ b/tests/Images/Input/Tiff/tiled_gray_16bit_big_endian_lzw_compressed_predictor.tiff
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:190a4968abd4bbd39273020f0f8bee0e0e48573931653eaea5e49b49d3961206
+size 87301
diff --git a/tests/Images/Input/Tiff/tiled_gray_16bit_little_endian_deflate_compressed_predictor.tiff b/tests/Images/Input/Tiff/tiled_gray_16bit_little_endian_deflate_compressed_predictor.tiff
new file mode 100644
index 0000000000..2fbe32e6fa
--- /dev/null
+++ b/tests/Images/Input/Tiff/tiled_gray_16bit_little_endian_deflate_compressed_predictor.tiff
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:19b4a2ee8761e0016a598f66f12eb62edf4c4d30f33694d30986ce84516ac454
+size 80177
diff --git a/tests/Images/Input/Tiff/tiled_gray_16bit_little_endian_lzw_compressed_predictor.tiff b/tests/Images/Input/Tiff/tiled_gray_16bit_little_endian_lzw_compressed_predictor.tiff
new file mode 100644
index 0000000000..d4508e32ad
--- /dev/null
+++ b/tests/Images/Input/Tiff/tiled_gray_16bit_little_endian_lzw_compressed_predictor.tiff
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:879bacee73f5fea767439071aa6057d66d2d61bc554b109abb7b79765873730b
+size 78795
diff --git a/tests/Images/Input/Tiff/tiled_gray_32bit_big_endian_deflate_compressed_predictor.tiff b/tests/Images/Input/Tiff/tiled_gray_32bit_big_endian_deflate_compressed_predictor.tiff
new file mode 100644
index 0000000000..e7c527c9cb
--- /dev/null
+++ b/tests/Images/Input/Tiff/tiled_gray_32bit_big_endian_deflate_compressed_predictor.tiff
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:ac571a8aa1274bd11f79d7d428d72e46d25ffcb331630f5eb114b94283055f7e
+size 90547
diff --git a/tests/Images/Input/Tiff/tiled_gray_32bit_big_endian_lzw_compressed_predictor.tiff b/tests/Images/Input/Tiff/tiled_gray_32bit_big_endian_lzw_compressed_predictor.tiff
new file mode 100644
index 0000000000..76f83f3973
--- /dev/null
+++ b/tests/Images/Input/Tiff/tiled_gray_32bit_big_endian_lzw_compressed_predictor.tiff
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:f4bebd7e62dbe54456923981b27dcc1415362c30a7c3c0ca665acf8dbdfe1cc8
+size 115129
diff --git a/tests/Images/Input/Tiff/tiled_gray_32bit_little_endian_deflate_compressed_predictor.tiff b/tests/Images/Input/Tiff/tiled_gray_32bit_little_endian_deflate_compressed_predictor.tiff
new file mode 100644
index 0000000000..8ca8fba8f5
--- /dev/null
+++ b/tests/Images/Input/Tiff/tiled_gray_32bit_little_endian_deflate_compressed_predictor.tiff
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:bec8072a0062101c08e0c1c1f4265150a53276d2568ada482b0ad554b13d658d
+size 90585
diff --git a/tests/Images/Input/Tiff/tiled_gray_32bit_little_endian_lzw_compressed_predictor.tiff b/tests/Images/Input/Tiff/tiled_gray_32bit_little_endian_lzw_compressed_predictor.tiff
new file mode 100644
index 0000000000..53aac39e78
--- /dev/null
+++ b/tests/Images/Input/Tiff/tiled_gray_32bit_little_endian_lzw_compressed_predictor.tiff
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:e618556125236e2b0034b8654ab7b3e8956cf6db3c7c35ae365445ce85b2ea3d
+size 114137
diff --git a/tests/Images/Input/Tiff/tiled_gray_deflate_compressed_predictor.tiff b/tests/Images/Input/Tiff/tiled_gray_deflate_compressed_predictor.tiff
new file mode 100644
index 0000000000..563af83ac2
--- /dev/null
+++ b/tests/Images/Input/Tiff/tiled_gray_deflate_compressed_predictor.tiff
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:ce5c12864099fa02c5702a5da3f5af8cadcf7822ff95ee117a3b8d846518d9d8
+size 59361
diff --git a/tests/Images/Input/Tiff/tiled_gray_lzw_compressed_predictor.tiff b/tests/Images/Input/Tiff/tiled_gray_lzw_compressed_predictor.tiff
new file mode 100644
index 0000000000..ed05c4b526
--- /dev/null
+++ b/tests/Images/Input/Tiff/tiled_gray_lzw_compressed_predictor.tiff
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:2942e3a2e83ee1e10cc238299c21dcc9ccad7058b0b389f69dcf3186cbd215a1
+size 67849
diff --git a/tests/Images/Input/Tiff/tiled_rgb_48bit_big_endian_deflate_compressed_predictor.tiff b/tests/Images/Input/Tiff/tiled_rgb_48bit_big_endian_deflate_compressed_predictor.tiff
new file mode 100644
index 0000000000..c9a2e6fd22
--- /dev/null
+++ b/tests/Images/Input/Tiff/tiled_rgb_48bit_big_endian_deflate_compressed_predictor.tiff
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:e5ffcad0698d5485dfaffc8fa8368e62e45ec54b715f82c93b0854a41875ea11
+size 220425
diff --git a/tests/Images/Input/Tiff/tiled_rgb_48bit_big_endian_lzw_compressed_predictor.tiff b/tests/Images/Input/Tiff/tiled_rgb_48bit_big_endian_lzw_compressed_predictor.tiff
new file mode 100644
index 0000000000..d3dc3f332a
--- /dev/null
+++ b/tests/Images/Input/Tiff/tiled_rgb_48bit_big_endian_lzw_compressed_predictor.tiff
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:8f69c65b66041cc34bfe894628bbe39a9e09cc9a8e7eccaefad42b672b2d2e3b
+size 234705
diff --git a/tests/Images/Input/Tiff/tiled_rgb_48bit_little_endian_deflate_compressed_predictor.tiff b/tests/Images/Input/Tiff/tiled_rgb_48bit_little_endian_deflate_compressed_predictor.tiff
new file mode 100644
index 0000000000..cf11248642
--- /dev/null
+++ b/tests/Images/Input/Tiff/tiled_rgb_48bit_little_endian_deflate_compressed_predictor.tiff
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:c3ea3976405c5512d676a0830c5d2d7a4d2c12128e56b0cf1c722b7152f4e255
+size 220415
diff --git a/tests/Images/Input/Tiff/tiled_rgb_48bit_little_endian_lzw_compressed_predictor.tiff b/tests/Images/Input/Tiff/tiled_rgb_48bit_little_endian_lzw_compressed_predictor.tiff
new file mode 100644
index 0000000000..b8d98e5d77
--- /dev/null
+++ b/tests/Images/Input/Tiff/tiled_rgb_48bit_little_endian_lzw_compressed_predictor.tiff
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:c6715b725ac4ac2ba57f7c9f6b8fd89182b6d2c5a6b8d9141f204783bc44a8c5
+size 234697
diff --git a/tests/Images/Input/Tiff/tiled_rgb_64bit_big_endian_deflate_compressed_predictor.tiff b/tests/Images/Input/Tiff/tiled_rgb_64bit_big_endian_deflate_compressed_predictor.tiff
new file mode 100644
index 0000000000..827584750d
--- /dev/null
+++ b/tests/Images/Input/Tiff/tiled_rgb_64bit_big_endian_deflate_compressed_predictor.tiff
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:f4b95d268817cfd2e261d76a6698b51f2ccb7fbda39dc26737c9572d445f3e0e
+size 240737
diff --git a/tests/Images/Input/Tiff/tiled_rgb_64bit_big_endian_lzw_compressed_predictor.tiff b/tests/Images/Input/Tiff/tiled_rgb_64bit_big_endian_lzw_compressed_predictor.tiff
new file mode 100644
index 0000000000..2cb3db6007
--- /dev/null
+++ b/tests/Images/Input/Tiff/tiled_rgb_64bit_big_endian_lzw_compressed_predictor.tiff
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:74dbdcc550fd0c9a425a02bb48a458e2c285030fd3fdaa8e6359bae1f4e06096
+size 270201
diff --git a/tests/Images/Input/Tiff/tiled_rgb_64bit_little_endian_deflate_compressed_predictor.tiff b/tests/Images/Input/Tiff/tiled_rgb_64bit_little_endian_deflate_compressed_predictor.tiff
new file mode 100644
index 0000000000..61f2d10271
--- /dev/null
+++ b/tests/Images/Input/Tiff/tiled_rgb_64bit_little_endian_deflate_compressed_predictor.tiff
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:8601908cea23f1cb15d46472c53424a7222213a8f1a3aa8df984f64068c6654c
+size 240651
diff --git a/tests/Images/Input/Tiff/tiled_rgb_64bit_little_endian_lzw_compressed_predictor.tiff b/tests/Images/Input/Tiff/tiled_rgb_64bit_little_endian_lzw_compressed_predictor.tiff
new file mode 100644
index 0000000000..93d046f1c5
--- /dev/null
+++ b/tests/Images/Input/Tiff/tiled_rgb_64bit_little_endian_lzw_compressed_predictor.tiff
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:e7364b83b36201d4f40144a619c7bf551f0ff27509aba3db3c7a1dbc01a881d8
+size 270305
diff --git a/tests/Images/Input/Tiff/tiled_rgb_96bit_big_endian_deflate_compressed_predictor.tiff b/tests/Images/Input/Tiff/tiled_rgb_96bit_big_endian_deflate_compressed_predictor.tiff
new file mode 100644
index 0000000000..9863b2271b
--- /dev/null
+++ b/tests/Images/Input/Tiff/tiled_rgb_96bit_big_endian_deflate_compressed_predictor.tiff
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:1ad32fab0240fdd87752857d349768802305a4eed73cc42146ad92a25525963e
+size 232587
diff --git a/tests/Images/Input/Tiff/tiled_rgb_96bit_big_endian_lzw_compressed_predictor.tiff b/tests/Images/Input/Tiff/tiled_rgb_96bit_big_endian_lzw_compressed_predictor.tiff
new file mode 100644
index 0000000000..107a311535
--- /dev/null
+++ b/tests/Images/Input/Tiff/tiled_rgb_96bit_big_endian_lzw_compressed_predictor.tiff
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:1c0b50066a4480b02c36ee97885e30498b0c9a702de6d317c648a7908a2d119d
+size 313111
diff --git a/tests/Images/Input/Tiff/tiled_rgb_96bit_little_endian_deflate_compressed_predictor.tiff b/tests/Images/Input/Tiff/tiled_rgb_96bit_little_endian_deflate_compressed_predictor.tiff
new file mode 100644
index 0000000000..28ee6d3f61
--- /dev/null
+++ b/tests/Images/Input/Tiff/tiled_rgb_96bit_little_endian_deflate_compressed_predictor.tiff
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:6022edc75314270ca5afb198113d74d5598b50663eda27a9a40563b7384d5976
+size 232667
diff --git a/tests/Images/Input/Tiff/tiled_rgb_96bit_little_endian_lzw_compressed_predictor.tiff b/tests/Images/Input/Tiff/tiled_rgb_96bit_little_endian_lzw_compressed_predictor.tiff
new file mode 100644
index 0000000000..c636b5872c
--- /dev/null
+++ b/tests/Images/Input/Tiff/tiled_rgb_96bit_little_endian_lzw_compressed_predictor.tiff
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:02e12574235e0861f4cad850869f53893b35334142c36d7c27d317382167ed68
+size 311165
diff --git a/tests/Images/Input/Tiff/tiled_rgb_deflate_compressed_predictor.tiff b/tests/Images/Input/Tiff/tiled_rgb_deflate_compressed_predictor.tiff
new file mode 100644
index 0000000000..71b4b29ce5
--- /dev/null
+++ b/tests/Images/Input/Tiff/tiled_rgb_deflate_compressed_predictor.tiff
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:ba8740738c2d86a22cc1bf43b1036e296e7caca8dad1ae70fd090edd9579f2cd
+size 163803
diff --git a/tests/Images/Input/Tiff/tiled_rgb_lzw_compressed_predictor.tiff b/tests/Images/Input/Tiff/tiled_rgb_lzw_compressed_predictor.tiff
new file mode 100644
index 0000000000..a1b1bbfdd5
--- /dev/null
+++ b/tests/Images/Input/Tiff/tiled_rgb_lzw_compressed_predictor.tiff
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:c47d681bfefa0cb12a25d685f13cc9fd01b3e0cb99828b97ccd948b43c138cfa
+size 180641
diff --git a/tests/Images/Input/Tiff/tiled_rgba_128bit_big_endian_deflate_compressed_predictor.tiff b/tests/Images/Input/Tiff/tiled_rgba_128bit_big_endian_deflate_compressed_predictor.tiff
new file mode 100644
index 0000000000..c980ae69fe
--- /dev/null
+++ b/tests/Images/Input/Tiff/tiled_rgba_128bit_big_endian_deflate_compressed_predictor.tiff
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:a8b7aad5756525ba52e43e309a982bc318197b68a168d2cf08bae6ee4422f59c
+size 264637
diff --git a/tests/Images/Input/Tiff/tiled_rgba_128bit_big_endian_lzw_compressed_predictor.tiff b/tests/Images/Input/Tiff/tiled_rgba_128bit_big_endian_lzw_compressed_predictor.tiff
new file mode 100644
index 0000000000..09edf13030
--- /dev/null
+++ b/tests/Images/Input/Tiff/tiled_rgba_128bit_big_endian_lzw_compressed_predictor.tiff
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:9b8e0812543f47ce79701ddc57a6473f8f3c6e016520cdc76cf4c1c11a5f54a0
+size 370941
diff --git a/tests/Images/Input/Tiff/tiled_rgba_128bit_little_endian_deflate_compressed_predictor.tiff b/tests/Images/Input/Tiff/tiled_rgba_128bit_little_endian_deflate_compressed_predictor.tiff
new file mode 100644
index 0000000000..5f589070a8
--- /dev/null
+++ b/tests/Images/Input/Tiff/tiled_rgba_128bit_little_endian_deflate_compressed_predictor.tiff
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:0405c620eb35ce375a2a3e198ab4208e450d420a1eea17846d69fd810b7bf0aa
+size 264749
diff --git a/tests/Images/Input/Tiff/tiled_rgba_128bit_little_endian_lzw_compressed_predictor.tiff b/tests/Images/Input/Tiff/tiled_rgba_128bit_little_endian_lzw_compressed_predictor.tiff
new file mode 100644
index 0000000000..5eb324e931
--- /dev/null
+++ b/tests/Images/Input/Tiff/tiled_rgba_128bit_little_endian_lzw_compressed_predictor.tiff
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:50620e1aeeb1d99fc108d08215f51eb7ef648cba506a1b657a74ee138b9e3a5f
+size 369133
diff --git a/tests/Images/Input/Tiff/tiled_rgba_64bit_big_endian_deflate_compressed_predictor.tiff b/tests/Images/Input/Tiff/tiled_rgba_64bit_big_endian_deflate_compressed_predictor.tiff
new file mode 100644
index 0000000000..0def244601
--- /dev/null
+++ b/tests/Images/Input/Tiff/tiled_rgba_64bit_big_endian_deflate_compressed_predictor.tiff
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:f456272c6948159ea17d6fa7d2a89e30521c1d4e29f0ad0b1a79894f122d2153
+size 220119
diff --git a/tests/Images/Input/Tiff/tiled_rgba_64bit_big_endian_lzw_compressed_predictor.tiff b/tests/Images/Input/Tiff/tiled_rgba_64bit_big_endian_lzw_compressed_predictor.tiff
new file mode 100644
index 0000000000..9c442bf340
--- /dev/null
+++ b/tests/Images/Input/Tiff/tiled_rgba_64bit_big_endian_lzw_compressed_predictor.tiff
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:a0ddd2ec8f73c784b060ff790e70f586bba70905b75f3cf8ae18f2b054e1eb06
+size 244677
diff --git a/tests/Images/Input/Tiff/tiled_rgba_64bit_little_endian_deflate_compressed_predictor.tiff b/tests/Images/Input/Tiff/tiled_rgba_64bit_little_endian_deflate_compressed_predictor.tiff
new file mode 100644
index 0000000000..bcd96a88bb
--- /dev/null
+++ b/tests/Images/Input/Tiff/tiled_rgba_64bit_little_endian_deflate_compressed_predictor.tiff
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:ee63d8b0d63fd091390678a4a2600df5c14a122002a4d9c93e7d01082a2ee347
+size 220045
diff --git a/tests/Images/Input/Tiff/tiled_rgba_64bit_little_endian_lzw_compressed_predictor.tiff b/tests/Images/Input/Tiff/tiled_rgba_64bit_little_endian_lzw_compressed_predictor.tiff
new file mode 100644
index 0000000000..456f57cbd6
--- /dev/null
+++ b/tests/Images/Input/Tiff/tiled_rgba_64bit_little_endian_lzw_compressed_predictor.tiff
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:d8e05d9ca953045d732c4304575588d2db2ead50177b2ed9416922568760ee1f
+size 244625
diff --git a/tests/Images/Input/Tiff/tiled_rgba_deflate_compressed_predictor.tiff b/tests/Images/Input/Tiff/tiled_rgba_deflate_compressed_predictor.tiff
new file mode 100644
index 0000000000..79bf1f6b76
--- /dev/null
+++ b/tests/Images/Input/Tiff/tiled_rgba_deflate_compressed_predictor.tiff
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:c0a3ecf077c701f450ce363633583134a79fd9d4d91fff0bd79f4bebe5f18649
+size 185503
diff --git a/tests/Images/Input/Tiff/tiled_rgba_lzw_compressed_predictor.tiff b/tests/Images/Input/Tiff/tiled_rgba_lzw_compressed_predictor.tiff
new file mode 100644
index 0000000000..6cc0f28dc7
--- /dev/null
+++ b/tests/Images/Input/Tiff/tiled_rgba_lzw_compressed_predictor.tiff
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:183e011bc22048d65cd1945d60dc25dc9cb688d9141afefa1c66ae0edfca8309
+size 202825
diff --git a/tests/Images/Input/Webp/alpha-blend-2.webp b/tests/Images/Input/Webp/alpha-blend-2.webp
new file mode 100644
index 0000000000..3ca4c77cff
--- /dev/null
+++ b/tests/Images/Input/Webp/alpha-blend-2.webp
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:b07a49ab8b3af82fa123faf897ec537cd26d57175b1d6301b617372c06432899
+size 1580484
diff --git a/tests/Images/Input/Webp/alpha-blend-3.webp b/tests/Images/Input/Webp/alpha-blend-3.webp
new file mode 100644
index 0000000000..1922f561d5
--- /dev/null
+++ b/tests/Images/Input/Webp/alpha-blend-3.webp
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:b7244a2cfb42285a196fc7846c49da65fac47e5b85f735bc07b131707c8a2d46
+size 948
diff --git a/tests/Images/Input/Webp/alpha-blend-4.webp b/tests/Images/Input/Webp/alpha-blend-4.webp
new file mode 100644
index 0000000000..6f4db231f6
--- /dev/null
+++ b/tests/Images/Input/Webp/alpha-blend-4.webp
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:8c8b98f188d006715bd5bc60593ff2a379078f28a7fc14a51d28ae1cfb279aac
+size 2185502
diff --git a/tests/Images/Input/Webp/alpha-blend.webp b/tests/Images/Input/Webp/alpha-blend.webp
new file mode 100644
index 0000000000..110d2a594c
--- /dev/null
+++ b/tests/Images/Input/Webp/alpha-blend.webp
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:5dc2762d1c1030fb951e1af57eaa7e66035a7b5e63bd9dc9f9bd50f0ff5c4c3a
+size 1297692
diff --git a/tests/Images/Input/Webp/issues/Issue2866.webp b/tests/Images/Input/Webp/issues/Issue2866.webp
new file mode 100644
index 0000000000..845569624d
--- /dev/null
+++ b/tests/Images/Input/Webp/issues/Issue2866.webp
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:15e8a52a6d528fe071e73b037543b682bf62da7bab6d98ab690f25dd97f7298e
+size 248688
diff --git a/tests/Images/Input/Webp/issues/Issue2906.webp b/tests/Images/Input/Webp/issues/Issue2906.webp
new file mode 100644
index 0000000000..0911da0472
--- /dev/null
+++ b/tests/Images/Input/Webp/issues/Issue2906.webp
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:56fe6a91feb9545c0a15966e0f6bc560890b193073c96ae9e39bf387c7e0cbca
+size 157092
diff --git a/tests/Images/Input/Webp/issues/Issue2925.webp b/tests/Images/Input/Webp/issues/Issue2925.webp
new file mode 100644
index 0000000000..414a06caad
--- /dev/null
+++ b/tests/Images/Input/Webp/issues/Issue2925.webp
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:e12207babf122af7a62246938c2e78faa0d3f730edb3182f4f9d6adae6bfc602
+size 262144