Merge branch 'master' into icc-color-conversion

.gitattributes

@@ -87,7 +87,6 @@
 *.eot               binary
 *.exe               binary
 *.otf               binary
-*.pbm               binary
 *.pdf               binary
 *.ppt               binary
 *.pptx              binary
@@ -95,7 +94,6 @@
 *.snk               binary
 *.ttc               binary
 *.ttf               binary
-*.wbmp              binary
 *.woff              binary
 *.woff2             binary
 *.xls               binary
@@ -126,3 +124,9 @@
 *.dds               filter=lfs diff=lfs merge=lfs -text
 *.ktx               filter=lfs diff=lfs merge=lfs -text
 *.ktx2              filter=lfs diff=lfs merge=lfs -text
+*.pam               filter=lfs diff=lfs merge=lfs -text
+*.pbm               filter=lfs diff=lfs merge=lfs -text
+*.pgm               filter=lfs diff=lfs merge=lfs -text
+*.ppm               filter=lfs diff=lfs merge=lfs -text
+*.pnm               filter=lfs diff=lfs merge=lfs -text
+*.wbmp              filter=lfs diff=lfs merge=lfs -text

.github/ISSUE_TEMPLATE/config.yml

@@ -1,8 +1,5 @@
 blank_issues_enabled: false
 contact_links:
-    - name: Ask a Question
-      url: https://github.com/SixLabors/ImageSharp/discussions?discussions_q=category%3AQ%26A
-      about: Ask a question about this project.
     - name: Feature Request
       url: https://github.com/SixLabors/ImageSharp/discussions?discussions_q=category%3AIdeas
       about: Share ideas for new features for this project.

.github/ISSUE_TEMPLATE/oss-bug-report.md

@@ -1,6 +1,6 @@
 ---
 name: "OSS : Bug Report"
-about: Create a report to help us improve the project.
+about: Create a report to help us improve the project. OSS Issues are not guaranteed to be triaged.
 labels: needs triage
 
 ---

.github/workflows/build-and-test.yml

@@ -1,202 +1,196 @@
 name: Build
 
 on:
-   push:
-       branches:
-           - master
-       tags:
-           - "v*"
-   pull_request:
-       branches:
-          - master
+  push:
+    branches:
+      - master
+    tags:
+      - "v*"
+  pull_request:
+    branches:
+      - master
 jobs:
-    Build:
-        strategy:
-            matrix:
-                options:
-                    - os: ubuntu-latest
-                      framework: net6.0
-                      sdk: 6.0.x
-                      sdk-preview: true
-                      runtime: -x64
-                      codecov: false
-                    - os: macos-latest
-                      framework: net6.0
-                      sdk: 6.0.x
-                      sdk-preview: true
-                      runtime: -x64
-                      codecov: false
-                    - os: windows-latest
-                      framework: net6.0
-                      sdk: 6.0.x
-                      sdk-preview: true
-                      runtime: -x64
-                      codecov: false
-                    - os: ubuntu-latest
-                      framework: net5.0
-                      runtime: -x64
-                      codecov: false
-                    - os: macos-latest
-                      framework: net5.0
-                      runtime: -x64
-                      codecov: false
-                    - os: windows-latest
-                      framework: net5.0
-                      runtime: -x64
-                      codecov: false
-                    - os: ubuntu-latest
-                      framework: netcoreapp3.1
-                      runtime: -x64
-                      codecov: true
-                    - os: macos-latest
-                      framework: netcoreapp3.1
-                      runtime: -x64
-                      codecov: false
-                    - os: windows-latest
-                      framework: netcoreapp3.1
-                      runtime: -x64
-                      codecov: false
-                    - os: windows-latest
-                      framework: netcoreapp2.1
-                      runtime: -x64
-                      codecov: false
-                    - os: windows-latest
-                      framework: net472
-                      runtime: -x64
-                      codecov: false
-                    - os: windows-latest
-                      framework: net472
-                      runtime: -x86
-                      codecov: false
-
-        runs-on: ${{matrix.options.os}}
-
-        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@v2
-              with:
-                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
-
-            - name: Git Setup LFS Cache
-              uses: actions/cache@v2
-              id: lfs-cache
-              with:
-                path: .git/lfs
-                key: ${{ runner.os }}-lfs-${{ hashFiles('.lfs-assets-id') }}-v1
-
-            - name: Git Pull LFS
-              run: git lfs pull
-
-            - name: NuGet Install
-              uses: NuGet/setup-nuget@v1
-
-            - name: NuGet Setup Cache
-              uses: actions/cache@v2
-              id: nuget-cache
-              with:
-                  path: ~/.nuget
-                  key: ${{ runner.os }}-nuget-${{ hashFiles('**/*.csproj', '**/*.props', '**/*.targets') }}
-                  restore-keys: ${{ runner.os }}-nuget-
-
-            - name: DotNet Setup Preview
-              if: ${{ matrix.options.sdk-preview == true }}
-              uses: actions/setup-dotnet@v1
-              with:
-                dotnet-version: ${{ matrix.options.sdk }}
-                include-prerelease: true
-
-            - name: DotNet Build
-              if: ${{ matrix.options.sdk-preview != true }}
-              shell: pwsh
-              run: ./ci-build.ps1 "${{matrix.options.framework}}"
-              env:
-                SIXLABORS_TESTING: True
-
-            - name: DotNet Build Preview
-              if: ${{ matrix.options.sdk-preview == true }}
-              shell: pwsh
-              run: ./ci-build.ps1 "${{matrix.options.framework}}"
-              env:
-                SIXLABORS_TESTING_PREVIEW: True
-
-            - name: DotNet Test
-              if: ${{ matrix.options.sdk-preview != true }}
-              shell: pwsh
-              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
-
-            - name: DotNet Test Preview
-              if: ${{ matrix.options.sdk-preview == true }}
-              shell: pwsh
-              run: ./ci-test.ps1 "${{matrix.options.os}}" "${{matrix.options.framework}}" "${{matrix.options.runtime}}" "${{matrix.options.codecov}}"
-              env:
-                SIXLABORS_TESTING_PREVIEW: True
-                XUNIT_PATH: .\tests\ImageSharp.Tests # Required for xunit
-
-            - name: Export Failed Output
-              uses: actions/upload-artifact@v2
-              if: failure()
-              with:
-                name: actual_output_${{ runner.os }}_${{ matrix.options.framework }}${{ matrix.options.runtime }}.zip
-                path: tests/Images/ActualOutput/
-
-            - name: Codecov Update
-              uses: codecov/codecov-action@v1
-              if: matrix.options.codecov == true && startsWith(github.repository, 'SixLabors')
-              with:
-                flags: unittests
-
-    Publish:
-        needs: [Build]
-
-        runs-on: ubuntu-latest
-
-        if: (github.event_name == 'push')
-
-        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@v2
-              with:
-                fetch-depth: 0
-                submodules: recursive
-
-            - name: NuGet Install
-              uses: NuGet/setup-nuget@v1
-
-            - name: NuGet Setup Cache
-              uses: actions/cache@v2
-              id: nuget-cache
-              with:
-                  path: ~/.nuget
-                  key: ${{ runner.os }}-nuget-${{ hashFiles('**/*.csproj', '**/*.props', '**/*.targets') }}
-                  restore-keys: ${{ runner.os }}-nuget-
-
-            - name: DotNet Pack
-              shell: pwsh
-              run: ./ci-pack.ps1
-
-            - name: MyGet Publish
-              shell: pwsh
-              run: |
-                  dotnet nuget push .\artifacts\*.nupkg -k ${{secrets.MYGET_TOKEN}} -s https://www.myget.org/F/sixlabors/api/v2/package
-                  dotnet nuget push .\artifacts\*.snupkg -k ${{secrets.MYGET_TOKEN}} -s https://www.myget.org/F/sixlabors/api/v3/index.json
-              # TODO: If github.ref starts with 'refs/tags' then it was tag push and we can optionally push out package to nuget.org
+  Build:
+    strategy:
+      matrix:
+        options:
+          - os: ubuntu-latest
+            framework: net6.0
+            sdk: 6.0.x
+            sdk-preview: true
+            runtime: -x64
+            codecov: false
+          - os: macos-latest
+            framework: net6.0
+            sdk: 6.0.x
+            sdk-preview: true
+            runtime: -x64
+            codecov: false
+          - os: windows-latest
+            framework: net6.0
+            sdk: 6.0.x
+            sdk-preview: true
+            runtime: -x64
+            codecov: false
+          - os: ubuntu-latest
+            framework: net5.0
+            runtime: -x64
+            codecov: false
+          - os: macos-latest
+            framework: net5.0
+            runtime: -x64
+            codecov: false
+          - os: windows-latest
+            framework: net5.0
+            runtime: -x64
+            codecov: false
+          - os: ubuntu-latest
+            framework: netcoreapp3.1
+            runtime: -x64
+            codecov: false
+          - os: macos-latest
+            framework: netcoreapp3.1
+            runtime: -x64
+            codecov: false
+          - os: windows-latest
+            framework: netcoreapp3.1
+            runtime: -x64
+            codecov: false
+          - os: windows-latest
+            framework: netcoreapp2.1
+            runtime: -x64
+            codecov: false
+          - os: windows-latest
+            framework: net472
+            runtime: -x64
+            codecov: false
+          - os: windows-latest
+            framework: net472
+            runtime: -x86
+            codecov: false
+
+    runs-on: ${{matrix.options.os}}
+
+    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@v2
+        with:
+          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
+
+      - name: Git Setup LFS Cache
+        uses: actions/cache@v2
+        id: lfs-cache
+        with:
+          path: .git/lfs
+          key: ${{ runner.os }}-lfs-${{ hashFiles('.lfs-assets-id') }}-v1
+
+      - name: Git Pull LFS
+        run: git lfs pull
+
+      - name: NuGet Install
+        uses: NuGet/setup-nuget@v1
+
+      - name: NuGet Setup Cache
+        uses: actions/cache@v2
+        id: nuget-cache
+        with:
+          path: ~/.nuget
+          key: ${{ runner.os }}-nuget-${{ hashFiles('**/*.csproj', '**/*.props', '**/*.targets') }}
+          restore-keys: ${{ runner.os }}-nuget-
+
+      - name: DotNet Setup Preview
+        if: ${{ matrix.options.sdk-preview == true }}
+        uses: actions/setup-dotnet@v1
+        with:
+          dotnet-version: ${{ matrix.options.sdk }}
+          include-prerelease: true
+
+      - name: DotNet Build
+        if: ${{ matrix.options.sdk-preview != true }}
+        shell: pwsh
+        run: ./ci-build.ps1 "${{matrix.options.framework}}"
+        env:
+          SIXLABORS_TESTING: True
+
+      - name: DotNet Build Preview
+        if: ${{ matrix.options.sdk-preview == true }}
+        shell: pwsh
+        run: ./ci-build.ps1 "${{matrix.options.framework}}"
+        env:
+          SIXLABORS_TESTING_PREVIEW: True
+
+      - name: DotNet Test
+        if: ${{ matrix.options.sdk-preview != true }}
+        shell: pwsh
+        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
+
+      - name: DotNet Test Preview
+        if: ${{ matrix.options.sdk-preview == true }}
+        shell: pwsh
+        run: ./ci-test.ps1 "${{matrix.options.os}}" "${{matrix.options.framework}}" "${{matrix.options.runtime}}" "${{matrix.options.codecov}}"
+        env:
+          SIXLABORS_TESTING_PREVIEW: True
+          XUNIT_PATH: .\tests\ImageSharp.Tests # Required for xunit
+
+      - name: Export Failed Output
+        uses: actions/upload-artifact@v2
+        if: failure()
+        with:
+          name: actual_output_${{ runner.os }}_${{ matrix.options.framework }}${{ matrix.options.runtime }}.zip
+          path: tests/Images/ActualOutput/
+
+  Publish:
+    needs: [Build]
+
+    runs-on: ubuntu-latest
+
+    if: (github.event_name == 'push')
+
+    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@v2
+        with:
+          fetch-depth: 0
+          submodules: recursive
+
+      - name: NuGet Install
+        uses: NuGet/setup-nuget@v1
+
+      - name: NuGet Setup Cache
+        uses: actions/cache@v2
+        id: nuget-cache
+        with:
+          path: ~/.nuget
+          key: ${{ runner.os }}-nuget-${{ hashFiles('**/*.csproj', '**/*.props', '**/*.targets') }}
+          restore-keys: ${{ runner.os }}-nuget-
+
+      - name: DotNet Pack
+        shell: pwsh
+        run: ./ci-pack.ps1
+
+      - name: MyGet Publish
+        shell: pwsh
+        run: |
+          dotnet nuget push .\artifacts\*.nupkg -k ${{secrets.MYGET_TOKEN}} -s https://www.myget.org/F/sixlabors/api/v2/package
+          dotnet nuget push .\artifacts\*.snupkg -k ${{secrets.MYGET_TOKEN}} -s https://www.myget.org/F/sixlabors/api/v3/index.json
+        # TODO: If github.ref starts with 'refs/tags' then it was tag push and we can optionally push out package to nuget.org

.github/workflows/code-coverage.yml

@@ -0,0 +1,81 @@
+name: CodeCoverage
+
+on:
+  schedule:
+    # 2AM every Tuesday/Thursday
+    - cron: "0 2 * * 2,4"
+jobs:
+  Build:
+    strategy:
+      matrix:
+        options:
+          - os: ubuntu-latest
+            framework: netcoreapp3.1
+            runtime: -x64
+            codecov: true
+
+    runs-on: ${{matrix.options.os}}
+
+    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@v2
+        with:
+          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
+
+      - name: Git Setup LFS Cache
+        uses: actions/cache@v2
+        id: lfs-cache
+        with:
+          path: .git/lfs
+          key: ${{ runner.os }}-lfs-${{ hashFiles('.lfs-assets-id') }}-v1
+
+      - name: Git Pull LFS
+        run: git lfs pull
+
+      - name: NuGet Install
+        uses: NuGet/setup-nuget@v1
+
+      - name: NuGet Setup Cache
+        uses: actions/cache@v2
+        id: nuget-cache
+        with:
+          path: ~/.nuget
+          key: ${{ runner.os }}-nuget-${{ hashFiles('**/*.csproj', '**/*.props', '**/*.targets') }}
+          restore-keys: ${{ runner.os }}-nuget-
+
+      - name: DotNet Build
+        shell: pwsh
+        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}}"
+        env:
+          SIXLABORS_TESTING: True
+          XUNIT_PATH: .\tests\ImageSharp.Tests # Required for xunit
+
+      - name: Export Failed Output
+        uses: actions/upload-artifact@v2
+        if: failure()
+        with:
+          name: actual_output_${{ runner.os }}_${{ matrix.options.framework }}${{ matrix.options.runtime }}.zip
+          path: tests/Images/ActualOutput/
+
+      - name: Codecov Update
+        uses: codecov/codecov-action@v1
+        if: matrix.options.codecov == true && startsWith(github.repository, 'SixLabors')
+        with:
+          flags: unittests

Directory.Build.props

@@ -13,6 +13,9 @@
   <PropertyGroup>
     <!-- This MUST be defined before importing props. -->
     <SixLaborsSolutionDirectory>$(MSBuildThisFileDirectory)</SixLaborsSolutionDirectory>
+
+    <!-- For some reason Debug-InnerLoop doesn't define DEBUG by default. -->
+    <DefineConstants Condition="'$(Configuration)' == 'Debug-InnerLoop'">$(DefineConstants);DEBUG</DefineConstants>
   </PropertyGroup>
 
   <!-- Import the shared global .props file -->
@@ -30,5 +33,4 @@
   <PropertyGroup Condition="$(Configuration.StartsWith('Release')) == true">
     <Optimize>true</Optimize>
   </PropertyGroup>
-
 </Project>

ImageSharp.sln

@@ -551,6 +551,7 @@ EndProject
 Project("{2150E333-8FDC-42A3-9474-1A3956D46DE8}") = "workflows", "workflows", "{C0D7754B-5277-438E-ABEB-2BA34401B5A7}"
 	ProjectSection(SolutionItems) = preProject
 		.github\workflows\build-and-test.yml = .github\workflows\build-and-test.yml
+		.github\workflows\code-coverage.yml = .github\workflows\code-coverage.yml
 	EndProjectSection
 EndProject
 Project("{D954291E-2A0B-460D-934E-DC6B0785DB48}") = "SharedInfrastructure", "shared-infrastructure\src\SharedInfrastructure\SharedInfrastructure.shproj", "{68A8CC40-6AED-4E96-B524-31B1158FDEEA}"

README.md

@@ -20,7 +20,7 @@ ImageSharp is a new, fully featured, fully managed, cross-platform, 2D graphics
 
 ImageSharp is designed from the ground up to be flexible and extensible. The library provides API endpoints for common image processing operations and the building blocks to allow for the development of additional operations.
 
-Built against [.NET Standard 1.3](https://docs.microsoft.com/en-us/dotnet/standard/net-standard), ImageSharp can be used in device, cloud, and embedded/IoT scenarios.
+Built against [.NET Standard 2.0](https://docs.microsoft.com/en-us/dotnet/standard/net-standard), ImageSharp can be used in device, cloud, and embedded/IoT scenarios.
 
 
 ## License

shared-infrastructure

@@ -1 +1 @@
-Subproject commit 33cb12ca77f919b44de56f344d2627cc2a108c3a
+Subproject commit 59ce17f5a4e1f956811133f41add7638e74c2836

src/ImageSharp/Advanced/AdvancedImageExtensions.cs

@@ -143,7 +143,7 @@ namespace SixLabors.ImageSharp.Advanced
         /// <param name="source">The source.</param>
         /// <param name="rowIndex">The row.</param>
         /// <returns>The <see cref="Span{TPixel}"/></returns>
-        public static Memory<TPixel> GetPixelRowMemory<TPixel>(this ImageFrame<TPixel> source, int rowIndex)
+        public static Memory<TPixel> DangerousGetPixelRowMemory<TPixel>(this ImageFrame<TPixel> source, int rowIndex)
             where TPixel : unmanaged, IPixel<TPixel>
         {
             Guard.NotNull(source, nameof(source));
@@ -161,7 +161,7 @@ namespace SixLabors.ImageSharp.Advanced
         /// <param name="source">The source.</param>
         /// <param name="rowIndex">The row.</param>
         /// <returns>The <see cref="Span{TPixel}"/></returns>
-        public static Memory<TPixel> GetPixelRowMemory<TPixel>(this Image<TPixel> source, int rowIndex)
+        public static Memory<TPixel> DangerousGetPixelRowMemory<TPixel>(this Image<TPixel> source, int rowIndex)
             where TPixel : unmanaged, IPixel<TPixel>
         {
             Guard.NotNull(source, nameof(source));

src/ImageSharp/Advanced/AotCompilerTools.cs

@@ -10,6 +10,7 @@ using SixLabors.ImageSharp.Formats.Bmp;
 using SixLabors.ImageSharp.Formats.Gif;
 using SixLabors.ImageSharp.Formats.Jpeg;
 using SixLabors.ImageSharp.Formats.Jpeg.Components;
+using SixLabors.ImageSharp.Formats.Pbm;
 using SixLabors.ImageSharp.Formats.Png;
 using SixLabors.ImageSharp.Formats.Tga;
 using SixLabors.ImageSharp.Formats.Tiff;
@@ -74,6 +75,7 @@ namespace SixLabors.ImageSharp.Advanced
 
                 Seed<A8>();
                 Seed<Argb32>();
+                Seed<Abgr32>();
                 Seed<Bgr24>();
                 Seed<Bgr565>();
                 Seed<Bgra32>();
@@ -148,6 +150,7 @@ namespace SixLabors.ImageSharp.Advanced
             Image<TPixel> img = default;
             img.CloneAs<A8>(default);
             img.CloneAs<Argb32>(default);
+            img.CloneAs<Abgr32>(default);
             img.CloneAs<Bgr24>(default);
             img.CloneAs<Bgr565>(default);
             img.CloneAs<Bgra32>(default);
@@ -200,6 +203,7 @@ namespace SixLabors.ImageSharp.Advanced
             default(BmpEncoderCore).Encode<TPixel>(default, default, default);
             default(GifEncoderCore).Encode<TPixel>(default, default, default);
             default(JpegEncoderCore).Encode<TPixel>(default, default, default);
+            default(PbmEncoderCore).Encode<TPixel>(default, default, default);
             default(PngEncoderCore).Encode<TPixel>(default, default, default);
             default(TgaEncoderCore).Encode<TPixel>(default, default, default);
             default(TiffEncoderCore).Encode<TPixel>(default, default, default);
@@ -217,6 +221,7 @@ namespace SixLabors.ImageSharp.Advanced
             default(BmpDecoderCore).Decode<TPixel>(default, default, default);
             default(GifDecoderCore).Decode<TPixel>(default, default, default);
             default(JpegDecoderCore).Decode<TPixel>(default, default, default);
+            default(PbmDecoderCore).Decode<TPixel>(default, default, default);
             default(PngDecoderCore).Decode<TPixel>(default, default, default);
             default(TgaDecoderCore).Decode<TPixel>(default, default, default);
             default(TiffDecoderCore).Decode<TPixel>(default, default, default);
@@ -234,6 +239,7 @@ namespace SixLabors.ImageSharp.Advanced
             AotCompileImageEncoder<TPixel, BmpEncoder>();
             AotCompileImageEncoder<TPixel, GifEncoder>();
             AotCompileImageEncoder<TPixel, JpegEncoder>();
+            AotCompileImageEncoder<TPixel, PbmEncoder>();
             AotCompileImageEncoder<TPixel, PngEncoder>();
             AotCompileImageEncoder<TPixel, TgaEncoder>();
             AotCompileImageEncoder<TPixel, TiffEncoder>();
@@ -251,6 +257,7 @@ namespace SixLabors.ImageSharp.Advanced
             AotCompileImageDecoder<TPixel, BmpDecoder>();
             AotCompileImageDecoder<TPixel, GifDecoder>();
             AotCompileImageDecoder<TPixel, JpegDecoder>();
+            AotCompileImageDecoder<TPixel, PbmDecoder>();
             AotCompileImageDecoder<TPixel, PngDecoder>();
             AotCompileImageDecoder<TPixel, TgaDecoder>();
             AotCompileImageDecoder<TPixel, TiffDecoder>();
@@ -529,7 +536,7 @@ namespace SixLabors.ImageSharp.Advanced
         private static void AotCompileMemoryManagers<TPixel>()
             where TPixel : unmanaged, IPixel<TPixel>
         {
-            AotCompileMemoryManager<TPixel, ArrayPoolMemoryAllocator>();
+            AotCompileMemoryManager<TPixel, UniformUnmanagedMemoryPoolMemoryAllocator>();
             AotCompileMemoryManager<TPixel, SimpleGcMemoryAllocator>();
         }
 

src/ImageSharp/Color/Color.Conversions.cs

@@ -89,6 +89,17 @@ namespace SixLabors.ImageSharp
             this.boxedHighPrecisionPixel = null;
         }
 
+        /// <summary>
+        /// Initializes a new instance of the <see cref="Color"/> struct.
+        /// </summary>
+        /// <param name="pixel">The <see cref="Abgr32"/> containing the color information.</param>
+        [MethodImpl(InliningOptions.ShortMethod)]
+        public Color(Abgr32 pixel)
+        {
+            this.data = new Rgba64(pixel);
+            this.boxedHighPrecisionPixel = null;
+        }
+
         /// <summary>
         /// Initializes a new instance of the <see cref="Color"/> struct.
         /// </summary>
@@ -177,6 +188,19 @@ namespace SixLabors.ImageSharp
             return value;
         }
 
+        [MethodImpl(InliningOptions.ShortMethod)]
+        internal Abgr32 ToAbgr32()
+        {
+            if (this.boxedHighPrecisionPixel is null)
+            {
+                return this.data.ToAbgr32();
+            }
+
+            Abgr32 value = default;
+            value.FromScaledVector4(this.boxedHighPrecisionPixel.ToScaledVector4());
+            return value;
+        }
+
         [MethodImpl(InliningOptions.ShortMethod)]
         internal Rgb24 ToRgb24()
         {

src/ImageSharp/Color/Color.cs

@@ -270,8 +270,15 @@ namespace SixLabors.ImageSharp
                 return pixel;
             }
 
+            if (this.boxedHighPrecisionPixel is null)
+            {
+                pixel = default;
+                pixel.FromRgba64(this.data);
+                return pixel;
+            }
+
             pixel = default;
-            pixel.FromRgba64(this.data);
+            pixel.FromScaledVector4(this.boxedHighPrecisionPixel.ToScaledVector4());
             return pixel;
         }
 

src/ImageSharp/Common/Helpers/DebugGuard.cs

@@ -26,6 +26,20 @@ namespace SixLabors
             }
         }
 
+        /// <summary>
+        /// Verifies whether a condition (indicating disposed state) is met, throwing an ObjectDisposedException if it's true.
+        /// </summary>
+        /// <param name="isDisposed">Whether the object is disposed.</param>
+        /// <param name="objectName">The name of the object.</param>
+        [Conditional("DEBUG")]
+        public static void NotDisposed(bool isDisposed, string objectName)
+        {
+            if (isDisposed)
+            {
+                throw new ObjectDisposedException(objectName);
+            }
+        }
+
         /// <summary>
         /// Verifies, that the target span is of same size than the 'other' span.
         /// </summary>

src/ImageSharp/Common/Helpers/Guard.cs

@@ -2,9 +2,6 @@
 // Licensed under the Apache License, Version 2.0.
 
 using System;
-#if NETSTANDARD1_3
-using System.Reflection;
-#endif
 using System.Runtime.CompilerServices;
 using SixLabors.ImageSharp;
 
@@ -22,11 +19,7 @@ namespace SixLabors
         [MethodImpl(InliningOptions.ShortMethod)]
         public static void MustBeValueType<TValue>(TValue value, string parameterName)
         {
-            if (value.GetType()
-#if NETSTANDARD1_3
-                .GetTypeInfo()
-#endif
-                .IsValueType)
+            if (value.GetType().IsValueType)
             {
                 return;
             }

src/ImageSharp/Common/Helpers/HexConverter.cs

@@ -0,0 +1,98 @@
+// Copyright (c) Six Labors.
+// Licensed under the Apache License, Version 2.0.
+
+using System;
+using System.Runtime.CompilerServices;
+
+namespace SixLabors.ImageSharp.Common.Helpers
+{
+    internal static class HexConverter
+    {
+        /// <summary>
+        /// Parses a hexadecimal string into a byte array without allocations. Throws on non-hexadecimal character.
+        /// Adapted from https://source.dot.net/#System.Private.CoreLib/Convert.cs,c9e4fbeaca708991.
+        /// </summary>
+        /// <param name="chars">The hexadecimal string to parse.</param>
+        /// <param name="bytes">The destination for the parsed bytes. Must be at least <paramref name="chars"/>.Length / 2 bytes long.</param>
+        /// <returns>The number of bytes written to <paramref name="bytes"/>.</returns>
+        public static int HexStringToBytes(ReadOnlySpan<char> chars, Span<byte> bytes)
+        {
+            if ((chars.Length % 2) != 0)
+            {
+                throw new ArgumentException("Input string length must be a multiple of 2", nameof(chars));
+            }
+
+            if ((bytes.Length * 2) < chars.Length)
+            {
+                throw new ArgumentException("Output span must be at least half the length of the input string");
+            }
+            else
+            {
+                // Slightly better performance in the loop below, allows us to skip a bounds check
+                // while still supporting output buffers that are larger than necessary
+                bytes = bytes.Slice(0, chars.Length / 2);
+            }
+
+            [MethodImpl(MethodImplOptions.AggressiveInlining)]
+            static int FromChar(int c)
+            {
+                // 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[]
+                {
+                    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
+                    0x0,  0x1,  0x2,  0x3,  0x4,  0x5,  0x6,  0x7,  0x8,  0x9,  0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, // 63
+                    0xFF, 0xA,  0xB,  0xC,  0xD,  0xE,  0xF,  0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, // 79
+                    0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, // 95
+                    0xFF, 0xa,  0xb,  0xc,  0xd,  0xe,  0xf,  0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, // 111
+                    0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, // 127
+                    0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, // 143
+                    0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, // 159
+                    0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, // 175
+                    0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, // 191
+                    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
+                };
+
+                return c >= charToHexLookup.Length ? 0xFF : charToHexLookup[c];
+            }
+
+            // See https://source.dot.net/#System.Private.CoreLib/HexConverter.cs,4681d45a0aa0b361
+            int i = 0;
+            int j = 0;
+            int byteLo = 0;
+            int byteHi = 0;
+            while (j < bytes.Length)
+            {
+                byteLo = FromChar(chars[i + 1]);
+                byteHi = FromChar(chars[i]);
+
+                // byteHi hasn't been shifted to the high half yet, so the only way the bitwise or produces this pattern
+                // is if either byteHi or byteLo was not a hex character.
+                if ((byteLo | byteHi) == 0xFF)
+                {
+                    break;
+                }
+
+                bytes[j++] = (byte)((byteHi << 4) | byteLo);
+                i += 2;
+            }
+
+            if (byteLo == 0xFF)
+            {
+                i++;
+            }
+
+            if ((byteLo | byteHi) == 0xFF)
+            {
+                throw new ArgumentException("Input string contained non-hexadecimal characters", nameof(chars));
+            }
+
+            return j;
+        }
+    }
+}

src/ImageSharp/Common/Helpers/Numerics.cs

@@ -820,6 +820,26 @@ namespace SixLabors.ImageSharp
             }
         }
 
+        /// <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(Vector256<int> accumulator)
+        {
+            // Add upper lane to lower lane.
+            Vector128<int> vsum = Sse2.Add(accumulator.GetLower(), accumulator.GetUpper());
+
+            // Add odd to even.
+            vsum = Sse2.Add(vsum, Sse2.Shuffle(vsum, 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 even elements of the vector into one sum.
         /// </summary>
@@ -887,5 +907,71 @@ namespace SixLabors.ImageSharp
         /// <param name="divisor">Divisor value.</param>
         /// <returns>Ceiled division result.</returns>
         public static uint DivideCeil(uint value, uint divisor) => (value + divisor - 1) / divisor;
+
+        /// <summary>
+        /// Rotates the specified value left by the specified number of bits.
+        /// </summary>
+        /// <param name="value">The value to rotate.</param>
+        /// <param name="offset">The number of bits to rotate with.</param>
+        /// <returns>The rotated value.</returns>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static uint RotateLeft(uint value, int offset)
+        {
+#if SUPPORTS_BITOPERATIONS
+            return BitOperations.RotateLeft(value, offset);
+#else
+            return RotateLeftSoftwareFallback(value, offset);
+#endif
+        }
+
+#if !SUPPORTS_BITOPERATIONS
+        /// <summary>
+        /// Rotates the specified value left by the specified number of bits.
+        /// </summary>
+        /// <param name="value">The value to rotate.</param>
+        /// <param name="offset">The number of bits to rotate with.</param>
+        /// <returns>The rotated value.</returns>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static uint RotateLeftSoftwareFallback(uint value, int offset)
+            => (value << offset) | (value >> (32 - offset));
+#endif
+
+        /// <summary>
+        /// Rotates the specified value right by the specified number of bits.
+        /// </summary>
+        /// <param name="value">The value to rotate.</param>
+        /// <param name="offset">The number of bits to rotate with.</param>
+        /// <returns>The rotated value.</returns>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static uint RotateRight(uint value, int offset)
+        {
+#if SUPPORTS_BITOPERATIONS
+            return BitOperations.RotateRight(value, offset);
+#else
+            return RotateRightSoftwareFallback(value, offset);
+#endif
+        }
+
+#if !SUPPORTS_BITOPERATIONS
+        /// <summary>
+        /// Rotates the specified value right by the specified number of bits.
+        /// </summary>
+        /// <param name="value">The value to rotate.</param>
+        /// <param name="offset">The number of bits to rotate with.</param>
+        /// <returns>The rotated value.</returns>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static uint RotateRightSoftwareFallback(uint value, int offset)
+            => (value >> offset) | (value << (32 - offset));
+#endif
+
+        /// <summary>
+        /// Tells whether input value is outside of the given range.
+        /// </summary>
+        /// <param name="value">Value.</param>
+        /// <param name="min">Mininum value, inclusive.</param>
+        /// <param name="max">Maximum value, inclusive.</param>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static bool IsOutOfRange(int value, int min, int max)
+            => (uint)(value - min) > (uint)(max - min);
     }
 }

src/ImageSharp/Common/Helpers/Shuffle/IComponentShuffle.cs

@@ -28,6 +28,10 @@ namespace SixLabors.ImageSharp
         /// </summary>
         /// <param name="source">The source span of bytes.</param>
         /// <param name="dest">The destination span of bytes.</param>
+        /// <remarks>
+        /// Implementation can assume that source.Length is less or equal than dest.Length.
+        /// Loops should iterate using source.Length.
+        /// </remarks>
         void RunFallbackShuffle(ReadOnlySpan<byte> source, Span<byte> dest);
     }
 
@@ -153,7 +157,7 @@ namespace SixLabors.ImageSharp
 
                 // packed              = [W Z Y X]
                 // ROTR(8, packedArgb) = [Y Z W X]
-                Unsafe.Add(ref dBase, i) = (packed >> 8) | (packed << 24);
+                Unsafe.Add(ref dBase, i) = Numerics.RotateRight(packed, 8);
             }
         }
     }
@@ -184,7 +188,40 @@ namespace SixLabors.ImageSharp
                 // tmp1 + tmp3         = [W X Y Z]
                 uint tmp1 = packed & 0xFF00FF00;
                 uint tmp2 = packed & 0x00FF00FF;
-                uint tmp3 = (tmp2 << 16) | (tmp2 >> 16);
+                uint tmp3 = Numerics.RotateLeft(tmp2, 16);
+
+                Unsafe.Add(ref dBase, i) = tmp1 + tmp3;
+            }
+        }
+    }
+
+    internal readonly struct XWZYShuffle4 : IShuffle4
+    {
+        public byte Control
+        {
+            [MethodImpl(InliningOptions.ShortMethod)]
+            get => SimdUtils.Shuffle.MmShuffle(1, 2, 3, 0);
+        }
+
+        [MethodImpl(InliningOptions.ShortMethod)]
+        public void RunFallbackShuffle(ReadOnlySpan<byte> source, Span<byte> dest)
+        {
+            ref uint sBase = ref Unsafe.As<byte, uint>(ref MemoryMarshal.GetReference(source));
+            ref uint dBase = ref Unsafe.As<byte, uint>(ref MemoryMarshal.GetReference(dest));
+            int n = source.Length / 4;
+
+            for (int i = 0; i < n; i++)
+            {
+                uint packed = Unsafe.Add(ref sBase, i);
+
+                // packed              = [W Z Y X]
+                // tmp1                = [0 Z 0 X]
+                // tmp2                = [W 0 Y 0]
+                // tmp3=ROTL(16, tmp2) = [Y 0 W 0]
+                // tmp1 + tmp3         = [Y Z W X]
+                uint tmp1 = packed & 0x00FF00FF;
+                uint tmp2 = packed & 0xFF00FF00;
+                uint tmp3 = Numerics.RotateLeft(tmp2, 16);
 
                 Unsafe.Add(ref dBase, i) = tmp1 + tmp3;
             }

src/ImageSharp/Common/Helpers/SimdUtils.Shuffle.cs

@@ -77,6 +77,7 @@ namespace SixLabors.ImageSharp
             TShuffle shuffle)
             where TShuffle : struct, IShuffle3
         {
+            // Source length should be smaller than dest length, and divisible by 3.
             VerifyShuffle3SpanInput(source, dest);
 
 #if SUPPORTS_RUNTIME_INTRINSICS
@@ -182,9 +183,9 @@ namespace SixLabors.ImageSharp
             where T : struct
         {
             DebugGuard.IsTrue(
-                source.Length == dest.Length,
+                source.Length <= dest.Length,
                 nameof(source),
-                "Input spans must be of same length!");
+                "Source should fit into dest!");
 
             DebugGuard.IsTrue(
                 source.Length % 3 == 0,

src/ImageSharp/Common/Helpers/SimdUtils.cs

@@ -33,18 +33,6 @@ namespace SixLabors.ImageSharp
         public static bool HasVector4 { get; } =
             Vector.IsHardwareAccelerated && Vector<float>.Count == 4;
 
-        public static bool HasAvx2
-        {
-            get
-            {
-#if SUPPORTS_RUNTIME_INTRINSICS
-                return Avx2.IsSupported;
-#else
-                return false;
-#endif
-            }
-        }
-
         /// <summary>
         /// Transform all scalars in 'v' in a way that converting them to <see cref="int"/> would have rounding semantics.
         /// </summary>

src/ImageSharp/Common/Tuples/Vector4Pair.cs

@@ -1,82 +0,0 @@
-// Copyright (c) Six Labors.
-// Licensed under the Apache License, Version 2.0.
-
-using System.Numerics;
-using System.Runtime.CompilerServices;
-using System.Runtime.InteropServices;
-
-namespace SixLabors.ImageSharp.Tuples
-{
-    /// <summary>
-    /// Its faster to process multiple Vector4-s together, so let's pair them!
-    /// On AVX2 this pair should be convertible to <see cref="Vector{T}"/> of <see cref="float"/>!
-    /// TODO: Investigate defining this as union with an Octet.OfSingle type.
-    /// </summary>
-    [StructLayout(LayoutKind.Sequential)]
-    internal struct Vector4Pair
-    {
-        public Vector4 A;
-
-        public Vector4 B;
-
-        [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public void MultiplyInplace(float value)
-        {
-            this.A *= value;
-            this.B *= value;
-        }
-
-        [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public void AddInplace(Vector4 value)
-        {
-            this.A += value;
-            this.B += value;
-        }
-
-        [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public void AddInplace(ref Vector4Pair other)
-        {
-            this.A += other.A;
-            this.B += other.B;
-        }
-
-        /// <summary>.
-        /// Downscale method, specific to Jpeg color conversion. Works only if Vector{float}.Count == 4!        /// TODO: Move it somewhere else.
-        /// </summary>
-        [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        internal void RoundAndDownscalePreVector8(float downscaleFactor)
-        {
-            ref Vector<float> a = ref Unsafe.As<Vector4, Vector<float>>(ref this.A);
-            a = a.FastRound();
-
-            ref Vector<float> b = ref Unsafe.As<Vector4, Vector<float>>(ref this.B);
-            b = b.FastRound();
-
-            // Downscale by 1/factor
-            var scale = new Vector4(1 / downscaleFactor);
-            this.A *= scale;
-            this.B *= scale;
-        }
-
-        /// <summary>
-        /// AVX2-only Downscale method, specific to Jpeg color conversion.
-        /// TODO: Move it somewhere else.
-        /// </summary>
-        [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        internal void RoundAndDownscaleVector8(float downscaleFactor)
-        {
-            ref Vector<float> self = ref Unsafe.As<Vector4Pair, Vector<float>>(ref this);
-            Vector<float> v = self;
-            v = v.FastRound();
-
-            // Downscale by 1/factor
-            v *= new Vector<float>(1 / downscaleFactor);
-            self = v;
-        }
-
-        public override string ToString()
-        {
-            return $"{nameof(Vector4Pair)}({this.A}, {this.B})";
-        }
-    }
-}

src/ImageSharp/Configuration.cs

@@ -8,6 +8,7 @@ using SixLabors.ImageSharp.Formats;
 using SixLabors.ImageSharp.Formats.Bmp;
 using SixLabors.ImageSharp.Formats.Gif;
 using SixLabors.ImageSharp.Formats.Jpeg;
+using SixLabors.ImageSharp.Formats.Pbm;
 using SixLabors.ImageSharp.Formats.Png;
 using SixLabors.ImageSharp.Formats.Tga;
 using SixLabors.ImageSharp.Formats.Tiff;
@@ -26,10 +27,11 @@ namespace SixLabors.ImageSharp
         /// <summary>
         /// A lazily initialized configuration default instance.
         /// </summary>
-        private static readonly Lazy<Configuration> Lazy = new Lazy<Configuration>(CreateDefaultInstance);
+        private static readonly Lazy<Configuration> Lazy = new(CreateDefaultInstance);
         private const int DefaultStreamProcessingBufferSize = 8096;
         private int streamProcessingBufferSize = DefaultStreamProcessingBufferSize;
         private int maxDegreeOfParallelism = Environment.ProcessorCount;
+        private MemoryAllocator memoryAllocator = MemoryAllocator.Default;
 
         /// <summary>
         /// Initializes a new instance of the <see cref="Configuration" /> class.
@@ -95,6 +97,14 @@ namespace SixLabors.ImageSharp
             }
         }
 
+        /// <summary>
+        /// Gets or sets a value indicating whether to force image buffers to be contiguous whenever possible.
+        /// </summary>
+        /// <remarks>
+        /// Contiguous allocations are not possible, if the image needs a buffer larger than <see cref="int.MaxValue"/>.
+        /// </remarks>
+        public bool PreferContiguousImageBuffers { get; set; }
+
         /// <summary>
         /// Gets a set of properties for the Configuration.
         /// </summary>
@@ -112,14 +122,36 @@ namespace SixLabors.ImageSharp
         public ReadOrigin ReadOrigin { get; set; } = ReadOrigin.Current;
 
         /// <summary>
-        /// Gets or sets the <see cref="ImageFormatManager"/> that is currently in use.
+        /// Gets or the <see cref="ImageFormatManager"/> that is currently in use.
         /// </summary>
-        public ImageFormatManager ImageFormatsManager { get; set; } = new ImageFormatManager();
+        public ImageFormatManager ImageFormatsManager { get; private set; } = new ImageFormatManager();
 
         /// <summary>
-        /// Gets or sets the <see cref="MemoryAllocator"/> that is currently in use.
+        /// Gets or sets the <see cref="Memory.MemoryAllocator"/> that is currently in use.
+        /// Defaults to <see cref="MemoryAllocator.Default"/>.
+        /// <para />
+        /// Allocators are expensive, so it is strongly recommended to use only one busy instance per process.
+        /// In case you need to customize it, you can ensure this by changing
         /// </summary>
-        public MemoryAllocator MemoryAllocator { get; set; } = ArrayPoolMemoryAllocator.CreateDefault();
+        /// <remarks>
+        /// It's possible to reduce allocator footprint by assigning a custom instance created with
+        /// <see cref="MemoryAllocator.Create(MemoryAllocatorOptions)"/>, but note that since the default pooling
+        /// allocators are expensive, it is strictly recommended to use a single process-wide allocator.
+        /// You can ensure this by altering the allocator of <see cref="Default"/>, or by implementing custom application logic that
+        /// manages allocator lifetime.
+        /// <para />
+        /// If an allocator has to be dropped for some reason, <see cref="MemoryAllocator.ReleaseRetainedResources"/>
+        /// shall be invoked after disposing all associated <see cref="Image"/> instances.
+        /// </remarks>
+        public MemoryAllocator MemoryAllocator
+        {
+            get => this.memoryAllocator;
+            set
+            {
+                Guard.NotNull(value, nameof(this.MemoryAllocator));
+                this.memoryAllocator = value;
+            }
+        }
 
         /// <summary>
         /// Gets the maximum header size of all the formats.
@@ -160,12 +192,12 @@ namespace SixLabors.ImageSharp
         /// Creates a shallow copy of the <see cref="Configuration"/>.
         /// </summary>
         /// <returns>A new configuration instance.</returns>
-        public Configuration Clone() => new Configuration
+        public Configuration Clone() => new()
         {
             MaxDegreeOfParallelism = this.MaxDegreeOfParallelism,
             StreamProcessingBufferSize = this.StreamProcessingBufferSize,
             ImageFormatsManager = this.ImageFormatsManager,
-            MemoryAllocator = this.MemoryAllocator,
+            memoryAllocator = this.memoryAllocator,
             ImageOperationsProvider = this.ImageOperationsProvider,
             ReadOrigin = this.ReadOrigin,
             FileSystem = this.FileSystem,
@@ -178,16 +210,18 @@ namespace SixLabors.ImageSharp
         /// <see cref="JpegConfigurationModule"/>
         /// <see cref="GifConfigurationModule"/>
         /// <see cref="BmpConfigurationModule"/>.
+        /// <see cref="PbmConfigurationModule"/>.
         /// <see cref="TgaConfigurationModule"/>.
         /// <see cref="TiffConfigurationModule"/>.
         /// <see cref="WebpConfigurationModule"/>.
         /// </summary>
         /// <returns>The default configuration of <see cref="Configuration"/>.</returns>
-        internal static Configuration CreateDefaultInstance() => new Configuration(
+        internal static Configuration CreateDefaultInstance() => new(
                 new PngConfigurationModule(),
                 new JpegConfigurationModule(),
                 new GifConfigurationModule(),
                 new BmpConfigurationModule(),
+                new PbmConfigurationModule(),
                 new TgaConfigurationModule(),
                 new TiffConfigurationModule(),
                 new WebpConfigurationModule());

src/ImageSharp/Formats/Bmp/BmpDecoderCore.cs

@@ -306,7 +306,7 @@ namespace SixLabors.ImageSharp.Formats.Bmp
                     int newY = Invert(y, height, inverted);
                     int rowStartIdx = y * width;
                     Span<byte> bufferRow = bufferSpan.Slice(rowStartIdx, width);
-                    Span<TPixel> pixelRow = pixels.GetRowSpan(newY);
+                    Span<TPixel> pixelRow = pixels.DangerousGetRowSpan(newY);
 
                     bool rowHasUndefinedPixels = rowsWithUndefinedPixelsSpan[y];
                     if (rowHasUndefinedPixels)
@@ -377,7 +377,7 @@ namespace SixLabors.ImageSharp.Formats.Bmp
                 for (int y = 0; y < height; y++)
                 {
                     int newY = Invert(y, height, inverted);
-                    Span<TPixel> pixelRow = pixels.GetRowSpan(newY);
+                    Span<TPixel> pixelRow = pixels.DangerousGetRowSpan(newY);
                     bool rowHasUndefinedPixels = rowsWithUndefinedPixelsSpan[y];
                     if (rowHasUndefinedPixels)
                     {
@@ -826,7 +826,7 @@ namespace SixLabors.ImageSharp.Formats.Bmp
                 int newY = Invert(y, height, inverted);
                 this.stream.Read(rowSpan);
                 int offset = 0;
-                Span<TPixel> pixelRow = pixels.GetRowSpan(newY);
+                Span<TPixel> pixelRow = pixels.DangerousGetRowSpan(newY);
 
                 for (int x = 0; x < arrayWidth; x++)
                 {
@@ -878,7 +878,7 @@ namespace SixLabors.ImageSharp.Formats.Bmp
             {
                 this.stream.Read(bufferSpan);
                 int newY = Invert(y, height, inverted);
-                Span<TPixel> pixelRow = pixels.GetRowSpan(newY);
+                Span<TPixel> pixelRow = pixels.DangerousGetRowSpan(newY);
 
                 int offset = 0;
                 for (int x = 0; x < width; x++)
@@ -933,7 +933,7 @@ namespace SixLabors.ImageSharp.Formats.Bmp
             {
                 this.stream.Read(rowSpan);
                 int newY = Invert(y, height, inverted);
-                Span<TPixel> pixelSpan = pixels.GetRowSpan(newY);
+                Span<TPixel> pixelSpan = pixels.DangerousGetRowSpan(newY);
                 PixelOperations<TPixel>.Instance.FromBgr24Bytes(
                     this.Configuration,
                     rowSpan,
@@ -961,7 +961,7 @@ namespace SixLabors.ImageSharp.Formats.Bmp
             {
                 this.stream.Read(rowSpan);
                 int newY = Invert(y, height, inverted);
-                Span<TPixel> pixelSpan = pixels.GetRowSpan(newY);
+                Span<TPixel> pixelSpan = pixels.DangerousGetRowSpan(newY);
                 PixelOperations<TPixel>.Instance.FromBgra32Bytes(
                     this.Configuration,
                     rowSpan,
@@ -1031,7 +1031,7 @@ namespace SixLabors.ImageSharp.Formats.Bmp
                     this.stream.Read(rowSpan);
 
                     int newY = Invert(y, height, inverted);
-                    Span<TPixel> pixelSpan = pixels.GetRowSpan(newY);
+                    Span<TPixel> pixelSpan = pixels.DangerousGetRowSpan(newY);
 
                     PixelOperations<TPixel>.Instance.FromBgra32Bytes(
                         this.Configuration,
@@ -1054,7 +1054,7 @@ namespace SixLabors.ImageSharp.Formats.Bmp
                     width);
 
                 int newY = Invert(y, height, inverted);
-                Span<TPixel> pixelSpan = pixels.GetRowSpan(newY);
+                Span<TPixel> pixelSpan = pixels.DangerousGetRowSpan(newY);
 
                 for (int x = 0; x < width; x++)
                 {
@@ -1109,7 +1109,7 @@ namespace SixLabors.ImageSharp.Formats.Bmp
             {
                 this.stream.Read(bufferSpan);
                 int newY = Invert(y, height, inverted);
-                Span<TPixel> pixelRow = pixels.GetRowSpan(newY);
+                Span<TPixel> pixelRow = pixels.DangerousGetRowSpan(newY);
 
                 int offset = 0;
                 for (int x = 0; x < width; x++)

src/ImageSharp/Formats/Bmp/BmpEncoderCore.cs

@@ -274,7 +274,7 @@ namespace SixLabors.ImageSharp.Formats.Bmp
 
             for (int y = pixels.Height - 1; y >= 0; y--)
             {
-                Span<TPixel> pixelSpan = pixels.GetRowSpan(y);
+                Span<TPixel> pixelSpan = pixels.DangerousGetRowSpan(y);
                 PixelOperations<TPixel>.Instance.ToBgra32Bytes(
                     this.configuration,
                     pixelSpan,
@@ -300,7 +300,7 @@ namespace SixLabors.ImageSharp.Formats.Bmp
 
             for (int y = pixels.Height - 1; y >= 0; y--)
             {
-                Span<TPixel> pixelSpan = pixels.GetRowSpan(y);
+                Span<TPixel> pixelSpan = pixels.DangerousGetRowSpan(y);
                 PixelOperations<TPixel>.Instance.ToBgr24Bytes(
                     this.configuration,
                     pixelSpan,
@@ -326,7 +326,7 @@ namespace SixLabors.ImageSharp.Formats.Bmp
 
             for (int y = pixels.Height - 1; y >= 0; y--)
             {
-                Span<TPixel> pixelSpan = pixels.GetRowSpan(y);
+                Span<TPixel> pixelSpan = pixels.DangerousGetRowSpan(y);
 
                 PixelOperations<TPixel>.Instance.ToBgra5551Bytes(
                     this.configuration,
@@ -379,7 +379,7 @@ namespace SixLabors.ImageSharp.Formats.Bmp
 
             for (int y = image.Height - 1; y >= 0; y--)
             {
-                ReadOnlySpan<byte> pixelSpan = quantized.GetPixelRowSpan(y);
+                ReadOnlySpan<byte> pixelSpan = quantized.DangerousGetRowSpan(y);
                 stream.Write(pixelSpan);
 
                 for (int i = 0; i < this.padding; i++)
@@ -413,10 +413,10 @@ namespace SixLabors.ImageSharp.Formats.Bmp
             }
 
             stream.Write(colorPalette);
-
+            Buffer2D<TPixel> imageBuffer = image.PixelBuffer;
             for (int y = image.Height - 1; y >= 0; y--)
             {
-                ReadOnlySpan<TPixel> inputPixelRow = image.GetPixelRowSpan(y);
+                ReadOnlySpan<TPixel> inputPixelRow = imageBuffer.DangerousGetRowSpan(y);
                 ReadOnlySpan<byte> outputPixelRow = MemoryMarshal.AsBytes(inputPixelRow);
                 stream.Write(outputPixelRow);
 
@@ -447,11 +447,11 @@ namespace SixLabors.ImageSharp.Formats.Bmp
             ReadOnlySpan<TPixel> quantizedColorPalette = quantized.Palette.Span;
             this.WriteColorPalette(stream, quantizedColorPalette, colorPalette);
 
-            ReadOnlySpan<byte> pixelRowSpan = quantized.GetPixelRowSpan(0);
+            ReadOnlySpan<byte> pixelRowSpan = quantized.DangerousGetRowSpan(0);
             int rowPadding = pixelRowSpan.Length % 2 != 0 ? this.padding - 1 : this.padding;
             for (int y = image.Height - 1; y >= 0; y--)
             {
-                pixelRowSpan = quantized.GetPixelRowSpan(y);
+                pixelRowSpan = quantized.DangerousGetRowSpan(y);
 
                 int endIdx = pixelRowSpan.Length % 2 == 0 ? pixelRowSpan.Length : pixelRowSpan.Length - 1;
                 for (int i = 0; i < endIdx; i += 2)
@@ -491,11 +491,11 @@ namespace SixLabors.ImageSharp.Formats.Bmp
             ReadOnlySpan<TPixel> quantizedColorPalette = quantized.Palette.Span;
             this.WriteColorPalette(stream, quantizedColorPalette, colorPalette);
 
-            ReadOnlySpan<byte> quantizedPixelRow = quantized.GetPixelRowSpan(0);
+            ReadOnlySpan<byte> quantizedPixelRow = quantized.DangerousGetRowSpan(0);
             int rowPadding = quantizedPixelRow.Length % 8 != 0 ? this.padding - 1 : this.padding;
             for (int y = image.Height - 1; y >= 0; y--)
             {
-                quantizedPixelRow = quantized.GetPixelRowSpan(y);
+                quantizedPixelRow = quantized.DangerousGetRowSpan(y);
 
                 int endIdx = quantizedPixelRow.Length % 8 == 0 ? quantizedPixelRow.Length : quantizedPixelRow.Length - 8;
                 for (int i = 0; i < endIdx; i += 8)

src/ImageSharp/Formats/Gif/GifConstants.cs

@@ -121,5 +121,16 @@ namespace SixLabors.ImageSharp.Formats.Gif
             (byte)'P', (byte)'E',
             (byte)'2', (byte)'.', (byte)'0'
         };
+
+        /// <summary>
+        /// Gets the ASCII encoded application identification bytes.
+        /// </summary>
+        internal static ReadOnlySpan<byte> XmpApplicationIdentificationBytes => new[]
+        {
+            (byte)'X', (byte)'M', (byte)'P',
+            (byte)' ', (byte)'D', (byte)'a',
+            (byte)'t', (byte)'a',
+            (byte)'X', (byte)'M', (byte)'P'
+        };
     }
 }

src/ImageSharp/Formats/Gif/GifDecoderCore.cs

@@ -11,6 +11,7 @@ using System.Threading;
 using SixLabors.ImageSharp.IO;
 using SixLabors.ImageSharp.Memory;
 using SixLabors.ImageSharp.Metadata;
+using SixLabors.ImageSharp.Metadata.Profiles.Xmp;
 using SixLabors.ImageSharp.PixelFormats;
 
 namespace SixLabors.ImageSharp.Formats.Gif
@@ -250,7 +251,7 @@ namespace SixLabors.ImageSharp.Formats.Gif
         }
 
         /// <summary>
-        /// Reads the application extension block parsing any animation information
+        /// Reads the application extension block parsing any animation or XMP information
         /// if present.
         /// </summary>
         private void ReadApplicationExtension()
@@ -258,25 +259,37 @@ namespace SixLabors.ImageSharp.Formats.Gif
             int appLength = this.stream.ReadByte();
 
             // If the length is 11 then it's a valid extension and most likely
-            // a NETSCAPE or ANIMEXTS extension. We want the loop count from this.
+            // a NETSCAPE, XMP or ANIMEXTS extension. We want the loop count from this.
             if (appLength == GifConstants.ApplicationBlockSize)
             {
-                this.stream.Skip(appLength);
-                int subBlockSize = this.stream.ReadByte();
+                this.stream.Read(this.buffer, 0, GifConstants.ApplicationBlockSize);
+                bool isXmp = this.buffer.AsSpan().StartsWith(GifConstants.XmpApplicationIdentificationBytes);
 
-                // TODO: There's also a NETSCAPE buffer extension.
-                // http://www.vurdalakov.net/misc/gif/netscape-buffering-application-extension
-                if (subBlockSize == GifConstants.NetscapeLoopingSubBlockSize)
+                if (isXmp)
                 {
-                    this.stream.Read(this.buffer, 0, GifConstants.NetscapeLoopingSubBlockSize);
-                    this.gifMetadata.RepeatCount = GifNetscapeLoopingApplicationExtension.Parse(this.buffer.AsSpan(1)).RepeatCount;
-                    this.stream.Skip(1); // Skip the terminator.
+                    var extension = GifXmpApplicationExtension.Read(this.stream);
+                    this.metadata.XmpProfile = new XmpProfile(extension.Data);
                     return;
                 }
+                else
+                {
+                    int subBlockSize = this.stream.ReadByte();
+
+                    // TODO: There's also a NETSCAPE buffer extension.
+                    // http://www.vurdalakov.net/misc/gif/netscape-buffering-application-extension
+                    if (subBlockSize == GifConstants.NetscapeLoopingSubBlockSize)
+                    {
+                        this.stream.Read(this.buffer, 0, GifConstants.NetscapeLoopingSubBlockSize);
+                        this.gifMetadata.RepeatCount = GifNetscapeLoopingApplicationExtension.Parse(this.buffer.AsSpan(1)).RepeatCount;
+                        this.stream.Skip(1); // Skip the terminator.
+                        return;
+                    }
+
+                    // Could be something else not supported yet.
+                    // Skip the subblock and terminator.
+                    this.SkipBlock(subBlockSize);
+                }
 
-                // Could be XMP or something else not supported yet.
-                // Skip the subblock and terminator.
-                this.SkipBlock(subBlockSize);
                 return;
             }
 
@@ -445,7 +458,7 @@ namespace SixLabors.ImageSharp.Formats.Gif
 
             for (int y = descriptorTop; y < descriptorBottom && y < imageHeight; y++)
             {
-                ref byte indicesRowRef = ref MemoryMarshal.GetReference(indices.GetRowSpan(y - descriptorTop));
+                ref byte indicesRowRef = ref MemoryMarshal.GetReference(indices.DangerousGetRowSpan(y - descriptorTop));
 
                 // Check if this image is interlaced.
                 int writeY; // the target y offset to write to
@@ -481,7 +494,7 @@ namespace SixLabors.ImageSharp.Formats.Gif
                     writeY = y;
                 }
 
-                ref TPixel rowRef = ref MemoryMarshal.GetReference(imageFrame.GetPixelRowSpan(writeY));
+                ref TPixel rowRef = ref MemoryMarshal.GetReference(imageFrame.PixelBuffer.DangerousGetRowSpan(writeY));
 
                 if (!transFlag)
                 {

src/ImageSharp/Formats/Gif/GifEncoderCore.cs

@@ -10,6 +10,7 @@ using System.Threading;
 using SixLabors.ImageSharp.Advanced;
 using SixLabors.ImageSharp.Memory;
 using SixLabors.ImageSharp.Metadata;
+using SixLabors.ImageSharp.Metadata.Profiles.Xmp;
 using SixLabors.ImageSharp.PixelFormats;
 using SixLabors.ImageSharp.Processing.Processors.Quantization;
 
@@ -121,11 +122,8 @@ namespace SixLabors.ImageSharp.Formats.Gif
             // Write the comments.
             this.WriteComments(gifMetadata, stream);
 
-            // Write application extension to allow additional frames.
-            if (image.Frames.Count > 1)
-            {
-                this.WriteApplicationExtension(stream, gifMetadata.RepeatCount);
-            }
+            // Write application extensions.
+            this.WriteApplicationExtensions(stream, image.Frames.Count, gifMetadata.RepeatCount, metadata.XmpProfile);
 
             if (useGlobalTable)
             {
@@ -326,15 +324,24 @@ namespace SixLabors.ImageSharp.Formats.Gif
         /// Writes the application extension to the stream.
         /// </summary>
         /// <param name="stream">The stream to write to.</param>
+        /// <param name="frameCount">The frame count fo this image.</param>
         /// <param name="repeatCount">The animated image repeat count.</param>
-        private void WriteApplicationExtension(Stream stream, ushort repeatCount)
+        /// <param name="xmpProfile">The XMP metadata profile. Null if profile is not to be written.</param>
+        private void WriteApplicationExtensions(Stream stream, int frameCount, ushort repeatCount, XmpProfile xmpProfile)
         {
-            // Application Extension Header
-            if (repeatCount != 1)
+            // Application Extension: Loop repeat count.
+            if (frameCount > 1 && repeatCount != 1)
             {
                 var loopingExtension = new GifNetscapeLoopingApplicationExtension(repeatCount);
                 this.WriteExtension(loopingExtension, stream);
             }
+
+            // Application Extension: XMP Profile.
+            if (xmpProfile != null)
+            {
+                var xmpExtension = new GifXmpApplicationExtension(xmpProfile.Data);
+                this.WriteExtension(xmpExtension, stream);
+            }
         }
 
         /// <summary>
@@ -420,14 +427,28 @@ namespace SixLabors.ImageSharp.Formats.Gif
         private void WriteExtension<TGifExtension>(TGifExtension extension, Stream stream)
             where TGifExtension : struct, IGifExtension
         {
-            this.buffer[0] = GifConstants.ExtensionIntroducer;
-            this.buffer[1] = extension.Label;
+            IMemoryOwner<byte> owner = null;
+            Span<byte> buffer;
+            int extensionSize = extension.ContentLength;
+            if (extensionSize > this.buffer.Length - 3)
+            {
+                owner = this.memoryAllocator.Allocate<byte>(extensionSize + 3);
+                buffer = owner.GetSpan();
+            }
+            else
+            {
+                buffer = this.buffer;
+            }
+
+            buffer[0] = GifConstants.ExtensionIntroducer;
+            buffer[1] = extension.Label;
 
-            int extensionSize = extension.WriteTo(this.buffer.AsSpan(2));
+            extension.WriteTo(buffer.Slice(2));
 
-            this.buffer[extensionSize + 2] = GifConstants.Terminator;
+            buffer[extensionSize + 2] = GifConstants.Terminator;
 
-            stream.Write(this.buffer, 0, extensionSize + 3);
+            stream.Write(buffer, 0, extensionSize + 3);
+            owner?.Dispose();
         }
 
         /// <summary>

src/ImageSharp/Formats/Gif/LzwDecoder.cs

@@ -115,14 +115,14 @@ namespace SixLabors.ImageSharp.Formats.Gif
             int y = 0;
             int x = 0;
             int rowMax = width;
-            ref byte pixelsRowRef = ref MemoryMarshal.GetReference(pixels.GetRowSpan(y));
+            ref byte pixelsRowRef = ref MemoryMarshal.GetReference(pixels.DangerousGetRowSpan(y));
             while (xyz < length)
             {
                 // Reset row reference.
                 if (xyz == rowMax)
                 {
                     x = 0;
-                    pixelsRowRef = ref MemoryMarshal.GetReference(pixels.GetRowSpan(++y));
+                    pixelsRowRef = ref MemoryMarshal.GetReference(pixels.DangerousGetRowSpan(++y));
                     rowMax = (y * width) + width;
                 }
 

src/ImageSharp/Formats/Gif/LzwEncoder.cs

@@ -275,7 +275,7 @@ namespace SixLabors.ImageSharp.Formats.Gif
 
             for (int y = 0; y < indexedPixels.Height; y++)
             {
-                ref byte rowSpanRef = ref MemoryMarshal.GetReference(indexedPixels.GetRowSpan(y));
+                ref byte rowSpanRef = ref MemoryMarshal.GetReference(indexedPixels.DangerousGetRowSpan(y));
                 int offsetX = y == 0 ? 1 : 0;
 
                 for (int x = offsetX; x < indexedPixels.Width; x++)

src/ImageSharp/Formats/Gif/Sections/GifGraphicControlExtension.cs

@@ -1,4 +1,4 @@
-// Copyright (c) Six Labors.
+// Copyright (c) Six Labors.
 // Licensed under the Apache License, Version 2.0.
 
 using System;
@@ -63,6 +63,8 @@ namespace SixLabors.ImageSharp.Formats.Gif
 
         byte IGifExtension.Label => GifConstants.GraphicControlLabel;
 
+        int IGifExtension.ContentLength => 5;
+
         public int WriteTo(Span<byte> buffer)
         {
             ref GifGraphicControlExtension dest = ref Unsafe.As<byte, GifGraphicControlExtension>(ref MemoryMarshal.GetReference(buffer));

src/ImageSharp/Formats/Gif/Sections/GifNetscapeLoopingApplicationExtension.cs

@@ -12,6 +12,8 @@ namespace SixLabors.ImageSharp.Formats.Gif
 
         public byte Label => GifConstants.ApplicationExtensionLabel;
 
+        public int ContentLength => 16;
+
         /// <summary>
         /// Gets the repeat count.
         /// 0 means loop indefinitely. Count is set as play n + 1 times.

src/ImageSharp/Formats/Gif/Sections/GifXmpApplicationExtension.cs

@@ -0,0 +1,97 @@
+// Copyright (c) Six Labors.
+// Licensed under the Apache License, Version 2.0.
+
+using System;
+using System.Collections.Generic;
+using System.IO;
+using SixLabors.ImageSharp.Metadata.Profiles.Xmp;
+
+namespace SixLabors.ImageSharp.Formats.Gif
+{
+    internal readonly struct GifXmpApplicationExtension : IGifExtension
+    {
+        public GifXmpApplicationExtension(byte[] data) => this.Data = data;
+
+        public byte Label => GifConstants.ApplicationExtensionLabel;
+
+        public int ContentLength => this.Data.Length + 269; // 12 + Data Length + 1 + 256
+
+        /// <summary>
+        /// Gets the raw Data.
+        /// </summary>
+        public byte[] Data { get; }
+
+        /// <summary>
+        /// Reads the XMP metadata from the specified stream.
+        /// </summary>
+        /// <param name="stream">The stream to read from.</param>
+        /// <returns>The XMP metadata</returns>
+        /// <exception cref="ImageFormatException">Thrown if the XMP block is not properly terminated.</exception>
+        public static GifXmpApplicationExtension Read(Stream stream)
+        {
+            // Read data in blocks, until an \0 character is encountered.
+            // We overshoot, indicated by the terminatorIndex variable.
+            const int bufferSize = 256;
+            var list = new List<byte[]>();
+            int terminationIndex = -1;
+            while (terminationIndex < 0)
+            {
+                byte[] temp = new byte[bufferSize];
+                int bytesRead = stream.Read(temp);
+                list.Add(temp);
+                terminationIndex = Array.IndexOf(temp, (byte)1);
+            }
+
+            // Pack all the blocks (except magic trailer) into one single array again.
+            int dataSize = ((list.Count - 1) * bufferSize) + terminationIndex;
+            byte[] buffer = new byte[dataSize];
+            Span<byte> bufferSpan = buffer;
+            int pos = 0;
+            for (int j = 0; j < list.Count - 1; j++)
+            {
+                list[j].CopyTo(bufferSpan.Slice(pos));
+                pos += bufferSize;
+            }
+
+            // Last one only needs the portion until terminationIndex copied over.
+            Span<byte> lastBytes = list[list.Count - 1];
+            lastBytes.Slice(0, terminationIndex).CopyTo(bufferSpan.Slice(pos));
+
+            // Skip the remainder of the magic trailer.
+            stream.Skip(258 - (bufferSize - terminationIndex));
+            return new GifXmpApplicationExtension(buffer);
+        }
+
+        public int WriteTo(Span<byte> buffer)
+        {
+            int totalSize = this.ContentLength;
+            if (buffer.Length < totalSize)
+            {
+                throw new InsufficientMemoryException("Unable to write XMP metadata to GIF image");
+            }
+
+            int bytesWritten = 0;
+            buffer[bytesWritten++] = GifConstants.ApplicationBlockSize;
+
+            // Write "XMP DataXMP"
+            ReadOnlySpan<byte> idBytes = GifConstants.XmpApplicationIdentificationBytes;
+            idBytes.CopyTo(buffer.Slice(bytesWritten));
+            bytesWritten += idBytes.Length;
+
+            // XMP Data itself
+            this.Data.CopyTo(buffer.Slice(bytesWritten));
+            bytesWritten += this.Data.Length;
+
+            // Write the Magic Trailer
+            buffer[bytesWritten++] = 0x01;
+            for (byte i = 255; i > 0; i--)
+            {
+                buffer[bytesWritten++] = i;
+            }
+
+            buffer[bytesWritten++] = 0x00;
+
+            return totalSize;
+        }
+    }
+}

src/ImageSharp/Formats/Gif/Sections/IGifExtension.cs

@@ -1,4 +1,4 @@
-// Copyright (c) Six Labors.
+// Copyright (c) Six Labors.
 // Licensed under the Apache License, Version 2.0.
 
 using System;
@@ -15,6 +15,11 @@ namespace SixLabors.ImageSharp.Formats.Gif
         /// </summary>
         byte Label { get; }
 
+        /// <summary>
+        /// Gets the length of the contents of this extension.
+        /// </summary>
+        int ContentLength { get; }
+
         /// <summary>
         /// Writes the extension data to the buffer.
         /// </summary>

src/ImageSharp/Formats/ImageExtensions.Save.cs

@@ -10,6 +10,7 @@ using SixLabors.ImageSharp.Advanced;
 using SixLabors.ImageSharp.Formats.Bmp;
 using SixLabors.ImageSharp.Formats.Gif;
 using SixLabors.ImageSharp.Formats.Jpeg;
+using SixLabors.ImageSharp.Formats.Pbm;
 using SixLabors.ImageSharp.Formats.Png;
 using SixLabors.ImageSharp.Formats.Tga;
 using SixLabors.ImageSharp.Formats.Webp;
@@ -104,7 +105,6 @@ namespace SixLabors.ImageSharp
         /// <param name="stream">The stream to save the image to.</param>
         /// <param name="encoder">The encoder to save the image with.</param>
         /// <exception cref="System.ArgumentNullException">Thrown if the stream is null.</exception>
-        /// <returns>A <see cref="Task"/> representing the asynchronous operation.</returns>
         public static void SaveAsBmp(this Image source, Stream stream, BmpEncoder encoder)
             => source.Save(
                 stream,
@@ -207,7 +207,6 @@ namespace SixLabors.ImageSharp
         /// <param name="stream">The stream to save the image to.</param>
         /// <param name="encoder">The encoder to save the image with.</param>
         /// <exception cref="System.ArgumentNullException">Thrown if the stream is null.</exception>
-        /// <returns>A <see cref="Task"/> representing the asynchronous operation.</returns>
         public static void SaveAsGif(this Image source, Stream stream, GifEncoder encoder)
             => source.Save(
                 stream,
@@ -310,7 +309,6 @@ namespace SixLabors.ImageSharp
         /// <param name="stream">The stream to save the image to.</param>
         /// <param name="encoder">The encoder to save the image with.</param>
         /// <exception cref="System.ArgumentNullException">Thrown if the stream is null.</exception>
-        /// <returns>A <see cref="Task"/> representing the asynchronous operation.</returns>
         public static void SaveAsJpeg(this Image source, Stream stream, JpegEncoder encoder)
             => source.Save(
                 stream,
@@ -331,6 +329,108 @@ namespace SixLabors.ImageSharp
                 encoder ?? source.GetConfiguration().ImageFormatsManager.FindEncoder(JpegFormat.Instance),
                 cancellationToken);
 
+        /// <summary>
+        /// Saves the image to the given stream with the Pbm format.
+        /// </summary>
+        /// <param name="source">The image this method extends.</param>
+        /// <param name="path">The file path to save the image to.</param>
+        /// <exception cref="System.ArgumentNullException">Thrown if the path is null.</exception>
+        public static void SaveAsPbm(this Image source, string path) => SaveAsPbm(source, path, null);
+
+        /// <summary>
+        /// Saves the image to the given stream with the Pbm format.
+        /// </summary>
+        /// <param name="source">The image this method extends.</param>
+        /// <param name="path">The file path to save the image to.</param>
+        /// <exception cref="System.ArgumentNullException">Thrown if the path is null.</exception>
+        /// <returns>A <see cref="Task"/> representing the asynchronous operation.</returns>
+        public static Task SaveAsPbmAsync(this Image source, string path) => SaveAsPbmAsync(source, path, null);
+
+        /// <summary>
+        /// Saves the image to the given stream with the Pbm format.
+        /// </summary>
+        /// <param name="source">The image this method extends.</param>
+        /// <param name="path">The file path to save the image to.</param>
+        /// <param name="cancellationToken">The token to monitor for cancellation requests.</param>
+        /// <exception cref="System.ArgumentNullException">Thrown if the path is null.</exception>
+        /// <returns>A <see cref="Task"/> representing the asynchronous operation.</returns>
+        public static Task SaveAsPbmAsync(this Image source, string path, CancellationToken cancellationToken)
+            => SaveAsPbmAsync(source, path, null, cancellationToken);
+
+        /// <summary>
+        /// Saves the image to the given stream with the Pbm format.
+        /// </summary>
+        /// <param name="source">The image this method extends.</param>
+        /// <param name="path">The file path to save the image to.</param>
+        /// <param name="encoder">The encoder to save the image with.</param>
+        /// <exception cref="System.ArgumentNullException">Thrown if the path is null.</exception>
+        public static void SaveAsPbm(this Image source, string path, PbmEncoder encoder) =>
+            source.Save(
+                path,
+                encoder ?? source.GetConfiguration().ImageFormatsManager.FindEncoder(PbmFormat.Instance));
+
+        /// <summary>
+        /// Saves the image to the given stream with the Pbm format.
+        /// </summary>
+        /// <param name="source">The image this method extends.</param>
+        /// <param name="path">The file path to save the image to.</param>
+        /// <param name="encoder">The encoder to save the image with.</param>
+        /// <param name="cancellationToken">The token to monitor for cancellation requests.</param>
+        /// <exception cref="System.ArgumentNullException">Thrown if the path is null.</exception>
+        /// <returns>A <see cref="Task"/> representing the asynchronous operation.</returns>
+        public static Task SaveAsPbmAsync(this Image source, string path, PbmEncoder encoder, CancellationToken cancellationToken = default) =>
+            source.SaveAsync(
+                path,
+                encoder ?? source.GetConfiguration().ImageFormatsManager.FindEncoder(PbmFormat.Instance),
+                cancellationToken);
+
+        /// <summary>
+        /// Saves the image to the given stream with the Pbm format.
+        /// </summary>
+        /// <param name="source">The image this method extends.</param>
+        /// <param name="stream">The stream to save the image to.</param>
+        /// <exception cref="System.ArgumentNullException">Thrown if the stream is null.</exception>
+        public static void SaveAsPbm(this Image source, Stream stream)
+            => SaveAsPbm(source, stream, null);
+
+        /// <summary>
+        /// Saves the image to the given stream with the Pbm format.
+        /// </summary>
+        /// <param name="source">The image this method extends.</param>
+        /// <param name="stream">The stream to save the image to.</param>
+        /// <param name="cancellationToken">The token to monitor for cancellation requests.</param>
+        /// <exception cref="System.ArgumentNullException">Thrown if the stream is null.</exception>
+        /// <returns>A <see cref="Task"/> representing the asynchronous operation.</returns>
+        public static Task SaveAsPbmAsync(this Image source, Stream stream, CancellationToken cancellationToken = default)
+            => SaveAsPbmAsync(source, stream, null, cancellationToken);
+
+        /// <summary>
+        /// Saves the image to the given stream with the Pbm format.
+        /// </summary>
+        /// <param name="source">The image this method extends.</param>
+        /// <param name="stream">The stream to save the image to.</param>
+        /// <param name="encoder">The encoder to save the image with.</param>
+        /// <exception cref="System.ArgumentNullException">Thrown if the stream is null.</exception>
+        public static void SaveAsPbm(this Image source, Stream stream, PbmEncoder encoder)
+            => source.Save(
+                stream,
+                encoder ?? source.GetConfiguration().ImageFormatsManager.FindEncoder(PbmFormat.Instance));
+
+        /// <summary>
+        /// Saves the image to the given stream with the Pbm format.
+        /// </summary>
+        /// <param name="source">The image this method extends.</param>
+        /// <param name="stream">The stream to save the image to.</param>
+        /// <param name="encoder">The encoder to save the image with.</param>
+        /// <param name="cancellationToken">The token to monitor for cancellation requests.</param>
+        /// <exception cref="System.ArgumentNullException">Thrown if the stream is null.</exception>
+        /// <returns>A <see cref="Task"/> representing the asynchronous operation.</returns>
+        public static Task SaveAsPbmAsync(this Image source, Stream stream, PbmEncoder encoder, CancellationToken cancellationToken = default) =>
+            source.SaveAsync(
+                stream,
+                encoder ?? source.GetConfiguration().ImageFormatsManager.FindEncoder(PbmFormat.Instance),
+                cancellationToken);
+
         /// <summary>
         /// Saves the image to the given stream with the Png format.
         /// </summary>
@@ -413,7 +513,6 @@ namespace SixLabors.ImageSharp
         /// <param name="stream">The stream to save the image to.</param>
         /// <param name="encoder">The encoder to save the image with.</param>
         /// <exception cref="System.ArgumentNullException">Thrown if the stream is null.</exception>
-        /// <returns>A <see cref="Task"/> representing the asynchronous operation.</returns>
         public static void SaveAsPng(this Image source, Stream stream, PngEncoder encoder)
             => source.Save(
                 stream,
@@ -516,7 +615,6 @@ namespace SixLabors.ImageSharp
         /// <param name="stream">The stream to save the image to.</param>
         /// <param name="encoder">The encoder to save the image with.</param>
         /// <exception cref="System.ArgumentNullException">Thrown if the stream is null.</exception>
-        /// <returns>A <see cref="Task"/> representing the asynchronous operation.</returns>
         public static void SaveAsTga(this Image source, Stream stream, TgaEncoder encoder)
             => source.Save(
                 stream,
@@ -619,7 +717,6 @@ namespace SixLabors.ImageSharp
         /// <param name="stream">The stream to save the image to.</param>
         /// <param name="encoder">The encoder to save the image with.</param>
         /// <exception cref="System.ArgumentNullException">Thrown if the stream is null.</exception>
-        /// <returns>A <see cref="Task"/> representing the asynchronous operation.</returns>
         public static void SaveAsWebp(this Image source, Stream stream, WebpEncoder encoder)
             => source.Save(
                 stream,
@@ -722,7 +819,6 @@ namespace SixLabors.ImageSharp
         /// <param name="stream">The stream to save the image to.</param>
         /// <param name="encoder">The encoder to save the image with.</param>
         /// <exception cref="System.ArgumentNullException">Thrown if the stream is null.</exception>
-        /// <returns>A <see cref="Task"/> representing the asynchronous operation.</returns>
         public static void SaveAsTiff(this Image source, Stream stream, TiffEncoder encoder)
             => source.Save(
                 stream,

src/ImageSharp/Formats/ImageExtensions.Save.tt

@@ -15,6 +15,7 @@ using SixLabors.ImageSharp.Advanced;
         "Bmp",
         "Gif",
         "Jpeg",
+        "Pbm",
         "Png",
         "Tga",
         "Webp",
@@ -123,7 +124,6 @@ namespace SixLabors.ImageSharp
         /// <param name="stream">The stream to save the image to.</param>
         /// <param name="encoder">The encoder to save the image with.</param>
         /// <exception cref="System.ArgumentNullException">Thrown if the stream is null.</exception>
-        /// <returns>A <see cref="Task"/> representing the asynchronous operation.</returns>
         public static void SaveAs<#= fmt #>(this Image source, Stream stream, <#= fmt #>Encoder encoder)
             => source.Save(
                 stream,

src/ImageSharp/Formats/ImageFormatManager.cs

@@ -1,4 +1,4 @@
-// Copyright (c) Six Labors.
+// Copyright (c) Six Labors.
 // Licensed under the Apache License, Version 2.0.
 
 using System;
@@ -17,27 +17,27 @@ namespace SixLabors.ImageSharp.Formats
         /// Used for locking against as there is no ConcurrentSet type.
         /// <see href="https://github.com/dotnet/corefx/issues/6318"/>
         /// </summary>
-        private static readonly object HashLock = new object();
+        private static readonly object HashLock = new();
 
         /// <summary>
         /// The list of supported <see cref="IImageEncoder"/> keyed to mime types.
         /// </summary>
-        private readonly ConcurrentDictionary<IImageFormat, IImageEncoder> mimeTypeEncoders = new ConcurrentDictionary<IImageFormat, IImageEncoder>();
+        private readonly ConcurrentDictionary<IImageFormat, IImageEncoder> mimeTypeEncoders = new();
 
         /// <summary>
         /// The list of supported <see cref="IImageEncoder"/> keyed to mime types.
         /// </summary>
-        private readonly ConcurrentDictionary<IImageFormat, IImageDecoder> mimeTypeDecoders = new ConcurrentDictionary<IImageFormat, IImageDecoder>();
+        private readonly ConcurrentDictionary<IImageFormat, IImageDecoder> mimeTypeDecoders = new();
 
         /// <summary>
         /// The list of supported <see cref="IImageFormat"/>s.
         /// </summary>
-        private readonly HashSet<IImageFormat> imageFormats = new HashSet<IImageFormat>();
+        private readonly HashSet<IImageFormat> imageFormats = new();
 
         /// <summary>
         /// The list of supported <see cref="IImageFormatDetector"/>s.
         /// </summary>
-        private ConcurrentBag<IImageFormatDetector> imageFormatDetectors = new ConcurrentBag<IImageFormatDetector>();
+        private ConcurrentBag<IImageFormatDetector> imageFormatDetectors = new();
 
         /// <summary>
         /// Initializes a new instance of the <see cref="ImageFormatManager" /> class.
@@ -113,9 +113,7 @@ namespace SixLabors.ImageSharp.Formats
         /// <param name="mimeType">The mime-type to discover</param>
         /// <returns>The <see cref="IImageFormat"/> if found; otherwise null</returns>
         public IImageFormat FindFormatByMimeType(string mimeType)
-        {
-            return this.imageFormats.FirstOrDefault(x => x.MimeTypes.Contains(mimeType, StringComparer.OrdinalIgnoreCase));
-        }
+            => this.imageFormats.FirstOrDefault(x => x.MimeTypes.Contains(mimeType, StringComparer.OrdinalIgnoreCase));
 
         /// <summary>
         /// Sets a specific image encoder as the encoder for a specific image format.
@@ -146,10 +144,7 @@ namespace SixLabors.ImageSharp.Formats
         /// <summary>
         /// Removes all the registered image format detectors.
         /// </summary>
-        public void ClearImageFormatDetectors()
-        {
-            this.imageFormatDetectors = new ConcurrentBag<IImageFormatDetector>();
-        }
+        public void ClearImageFormatDetectors() => this.imageFormatDetectors = new();
 
         /// <summary>
         /// Adds a new detector for detecting mime types.
@@ -193,9 +188,6 @@ namespace SixLabors.ImageSharp.Formats
         /// <summary>
         /// Sets the max header size.
         /// </summary>
-        private void SetMaxHeaderSize()
-        {
-            this.MaxHeaderSize = this.imageFormatDetectors.Max(x => x.HeaderSize);
-        }
+        private void SetMaxHeaderSize() => this.MaxHeaderSize = this.imageFormatDetectors.Max(x => x.HeaderSize);
     }
 }

src/ImageSharp/Formats/Jpeg/Components/Block8x8.Intrinsic.cs

@@ -0,0 +1,39 @@
+// Copyright (c) Six Labors.
+// Licensed under the Apache License, Version 2.0.
+
+#if SUPPORTS_RUNTIME_INTRINSICS
+using System.Runtime.InteropServices;
+using System.Runtime.Intrinsics;
+
+namespace SixLabors.ImageSharp.Formats.Jpeg.Components
+{
+    internal unsafe partial struct Block8x8
+    {
+        [FieldOffset(0)]
+        public Vector128<short> V0;
+        [FieldOffset(16)]
+        public Vector128<short> V1;
+        [FieldOffset(32)]
+        public Vector128<short> V2;
+        [FieldOffset(48)]
+        public Vector128<short> V3;
+        [FieldOffset(64)]
+        public Vector128<short> V4;
+        [FieldOffset(80)]
+        public Vector128<short> V5;
+        [FieldOffset(96)]
+        public Vector128<short> V6;
+        [FieldOffset(112)]
+        public Vector128<short> V7;
+
+        [FieldOffset(0)]
+        public Vector256<short> V01;
+        [FieldOffset(32)]
+        public Vector256<short> V23;
+        [FieldOffset(64)]
+        public Vector256<short> V45;
+        [FieldOffset(96)]
+        public Vector256<short> V67;
+    }
+}
+#endif

src/ImageSharp/Formats/Jpeg/Components/Block8x8.cs

@@ -18,7 +18,7 @@ namespace SixLabors.ImageSharp.Formats.Jpeg.Components
     /// </summary>
     // ReSharper disable once InconsistentNaming
     [StructLayout(LayoutKind.Explicit)]
-    internal unsafe struct Block8x8 : IEquatable<Block8x8>
+    internal unsafe partial struct Block8x8
     {
         /// <summary>
         /// A number of scalar coefficients in a <see cref="Block8x8F"/>
@@ -36,34 +36,6 @@ namespace SixLabors.ImageSharp.Formats.Jpeg.Components
         private fixed short data[Size];
 #pragma warning restore IDE0051
 
-#if SUPPORTS_RUNTIME_INTRINSICS
-        [FieldOffset(0)]
-        public Vector128<short> V0;
-        [FieldOffset(16)]
-        public Vector128<short> V1;
-        [FieldOffset(32)]
-        public Vector128<short> V2;
-        [FieldOffset(48)]
-        public Vector128<short> V3;
-        [FieldOffset(64)]
-        public Vector128<short> V4;
-        [FieldOffset(80)]
-        public Vector128<short> V5;
-        [FieldOffset(96)]
-        public Vector128<short> V6;
-        [FieldOffset(112)]
-        public Vector128<short> V7;
-
-        [FieldOffset(0)]
-        public Vector256<short> V01;
-        [FieldOffset(32)]
-        public Vector256<short> V23;
-        [FieldOffset(64)]
-        public Vector256<short> V45;
-        [FieldOffset(96)]
-        public Vector256<short> V67;
-#endif
-
         /// <summary>
         /// Gets or sets a <see cref="short"/> value at the given index
         /// </summary>
@@ -102,74 +74,6 @@ namespace SixLabors.ImageSharp.Formats.Jpeg.Components
             set => this[(y * 8) + x] = value;
         }
 
-        public static bool operator ==(Block8x8 left, Block8x8 right) => left.Equals(right);
-
-        public static bool operator !=(Block8x8 left, Block8x8 right) => !left.Equals(right);
-
-        /// <summary>
-        /// Multiply all elements by a given <see cref="int"/>
-        /// </summary>
-        public static Block8x8 operator *(Block8x8 block, int value)
-        {
-            Block8x8 result = block;
-            for (int i = 0; i < Size; i++)
-            {
-                int val = result[i];
-                val *= value;
-                result[i] = (short)val;
-            }
-
-            return result;
-        }
-
-        /// <summary>
-        /// Divide all elements by a given <see cref="int"/>
-        /// </summary>
-        public static Block8x8 operator /(Block8x8 block, int value)
-        {
-            Block8x8 result = block;
-            for (int i = 0; i < Size; i++)
-            {
-                int val = result[i];
-                val /= value;
-                result[i] = (short)val;
-            }
-
-            return result;
-        }
-
-        /// <summary>
-        /// Add an <see cref="int"/> to all elements
-        /// </summary>
-        public static Block8x8 operator +(Block8x8 block, int value)
-        {
-            Block8x8 result = block;
-            for (int i = 0; i < Size; i++)
-            {
-                int val = result[i];
-                val += value;
-                result[i] = (short)val;
-            }
-
-            return result;
-        }
-
-        /// <summary>
-        /// Subtract an <see cref="int"/> from all elements
-        /// </summary>
-        public static Block8x8 operator -(Block8x8 block, int value)
-        {
-            Block8x8 result = block;
-            for (int i = 0; i < Size; i++)
-            {
-                int val = result[i];
-                val -= value;
-                result[i] = (short)val;
-            }
-
-            return result;
-        }
-
         public static Block8x8 Load(Span<short> data)
         {
             Unsafe.SkipInit(out Block8x8 result);
@@ -260,26 +164,6 @@ namespace SixLabors.ImageSharp.Formats.Jpeg.Components
             return sb.ToString();
         }
 
-        /// <inheritdoc />
-        public bool Equals(Block8x8 other)
-        {
-            for (int i = 0; i < Size; i++)
-            {
-                if (this[i] != other[i])
-                {
-                    return false;
-                }
-            }
-
-            return true;
-        }
-
-        /// <inheritdoc />
-        public override bool Equals(object obj) => obj is Block8x8 other && this.Equals(other);
-
-        /// <inheritdoc />
-        public override int GetHashCode() => (this[0] * 31) + this[1];
-
         /// <summary>
         /// Returns index of the last non-zero element in given matrix.
         /// </summary>
@@ -337,6 +221,64 @@ namespace SixLabors.ImageSharp.Formats.Jpeg.Components
             }
         }
 
+        /// <summary>
+        /// Transpose the block inplace.
+        /// </summary>
+        [MethodImpl(InliningOptions.ShortMethod)]
+        public void TransposeInplace()
+        {
+            ref short elemRef = ref Unsafe.As<Block8x8, short>(ref this);
+
+            // row #0
+            Swap(ref Unsafe.Add(ref elemRef, 1), ref Unsafe.Add(ref elemRef, 8));
+            Swap(ref Unsafe.Add(ref elemRef, 2), ref Unsafe.Add(ref elemRef, 16));
+            Swap(ref Unsafe.Add(ref elemRef, 3), ref Unsafe.Add(ref elemRef, 24));
+            Swap(ref Unsafe.Add(ref elemRef, 4), ref Unsafe.Add(ref elemRef, 32));
+            Swap(ref Unsafe.Add(ref elemRef, 5), ref Unsafe.Add(ref elemRef, 40));
+            Swap(ref Unsafe.Add(ref elemRef, 6), ref Unsafe.Add(ref elemRef, 48));
+            Swap(ref Unsafe.Add(ref elemRef, 7), ref Unsafe.Add(ref elemRef, 56));
+
+            // row #1
+            Swap(ref Unsafe.Add(ref elemRef, 10), ref Unsafe.Add(ref elemRef, 17));
+            Swap(ref Unsafe.Add(ref elemRef, 11), ref Unsafe.Add(ref elemRef, 25));
+            Swap(ref Unsafe.Add(ref elemRef, 12), ref Unsafe.Add(ref elemRef, 33));
+            Swap(ref Unsafe.Add(ref elemRef, 13), ref Unsafe.Add(ref elemRef, 41));
+            Swap(ref Unsafe.Add(ref elemRef, 14), ref Unsafe.Add(ref elemRef, 49));
+            Swap(ref Unsafe.Add(ref elemRef, 15), ref Unsafe.Add(ref elemRef, 57));
+
+            // row #2
+            Swap(ref Unsafe.Add(ref elemRef, 19), ref Unsafe.Add(ref elemRef, 26));
+            Swap(ref Unsafe.Add(ref elemRef, 20), ref Unsafe.Add(ref elemRef, 34));
+            Swap(ref Unsafe.Add(ref elemRef, 21), ref Unsafe.Add(ref elemRef, 42));
+            Swap(ref Unsafe.Add(ref elemRef, 22), ref Unsafe.Add(ref elemRef, 50));
+            Swap(ref Unsafe.Add(ref elemRef, 23), ref Unsafe.Add(ref elemRef, 58));
+
+            // row #3
+            Swap(ref Unsafe.Add(ref elemRef, 28), ref Unsafe.Add(ref elemRef, 35));
+            Swap(ref Unsafe.Add(ref elemRef, 29), ref Unsafe.Add(ref elemRef, 43));
+            Swap(ref Unsafe.Add(ref elemRef, 30), ref Unsafe.Add(ref elemRef, 51));
+            Swap(ref Unsafe.Add(ref elemRef, 31), ref Unsafe.Add(ref elemRef, 59));
+
+            // row #4
+            Swap(ref Unsafe.Add(ref elemRef, 37), ref Unsafe.Add(ref elemRef, 44));
+            Swap(ref Unsafe.Add(ref elemRef, 38), ref Unsafe.Add(ref elemRef, 52));
+            Swap(ref Unsafe.Add(ref elemRef, 39), ref Unsafe.Add(ref elemRef, 60));
+
+            // row #5
+            Swap(ref Unsafe.Add(ref elemRef, 46), ref Unsafe.Add(ref elemRef, 53));
+            Swap(ref Unsafe.Add(ref elemRef, 47), ref Unsafe.Add(ref elemRef, 61));
+
+            // row #6
+            Swap(ref Unsafe.Add(ref elemRef, 55), ref Unsafe.Add(ref elemRef, 62));
+
+            static void Swap(ref short a, ref short b)
+            {
+                short tmp = a;
+                a = b;
+                b = tmp;
+            }
+        }
+
         /// <summary>
         /// Calculate the total sum of absolute differences of elements in 'a' and 'b'.
         /// </summary>

src/ImageSharp/Formats/Jpeg/Components/Block8x8F.cs

@@ -2,7 +2,6 @@
 // Licensed under the Apache License, Version 2.0.
 
 using System;
-using System.Diagnostics;
 using System.Numerics;
 using System.Runtime.CompilerServices;
 using System.Runtime.InteropServices;
@@ -98,58 +97,6 @@ namespace SixLabors.ImageSharp.Formats.Jpeg.Components
             set => this[(y * 8) + x] = value;
         }
 
-        public static Block8x8F operator *(Block8x8F block, float value)
-        {
-            Block8x8F result = block;
-            for (int i = 0; i < Size; i++)
-            {
-                float val = result[i];
-                val *= value;
-                result[i] = val;
-            }
-
-            return result;
-        }
-
-        public static Block8x8F operator /(Block8x8F block, float value)
-        {
-            Block8x8F result = block;
-            for (int i = 0; i < Size; i++)
-            {
-                float val = result[i];
-                val /= value;
-                result[i] = val;
-            }
-
-            return result;
-        }
-
-        public static Block8x8F operator +(Block8x8F block, float value)
-        {
-            Block8x8F result = block;
-            for (int i = 0; i < Size; i++)
-            {
-                float val = result[i];
-                val += value;
-                result[i] = val;
-            }
-
-            return result;
-        }
-
-        public static Block8x8F operator -(Block8x8F block, float value)
-        {
-            Block8x8F result = block;
-            for (int i = 0; i < Size; i++)
-            {
-                float val = result[i];
-                val -= value;
-                result[i] = val;
-            }
-
-            return result;
-        }
-
         public static Block8x8F Load(Span<float> data)
         {
             Block8x8F result = default;
@@ -157,13 +104,6 @@ namespace SixLabors.ImageSharp.Formats.Jpeg.Components
             return result;
         }
 
-        public static Block8x8F Load(Span<int> data)
-        {
-            Block8x8F result = default;
-            result.LoadFrom(data);
-            return result;
-        }
-
         /// <summary>
         /// Load raw 32bit floating point data from source.
         /// </summary>
@@ -177,15 +117,6 @@ namespace SixLabors.ImageSharp.Formats.Jpeg.Components
             Unsafe.CopyBlock(ref d, ref s, Size * sizeof(float));
         }
 
-        /// <summary>
-        /// Load raw 32bit floating point data from source.
-        /// </summary>
-        /// <param name="blockPtr">Block pointer</param>
-        /// <param name="source">Source</param>
-        [MethodImpl(InliningOptions.ShortMethod)]
-        public static unsafe void LoadFrom(Block8x8F* blockPtr, Span<float> source)
-            => blockPtr->LoadFrom(source);
-
         /// <summary>
         /// Load raw 32bit floating point data from source
         /// </summary>
@@ -202,44 +133,6 @@ namespace SixLabors.ImageSharp.Formats.Jpeg.Components
             }
         }
 
-        /// <summary>
-        /// Copy raw 32bit floating point data to dest,
-        /// </summary>
-        /// <param name="dest">Destination</param>
-        [MethodImpl(InliningOptions.ShortMethod)]
-        public void ScaledCopyTo(Span<float> dest)
-        {
-            ref byte d = ref Unsafe.As<float, byte>(ref MemoryMarshal.GetReference(dest));
-            ref byte s = ref Unsafe.As<Block8x8F, byte>(ref this);
-
-            Unsafe.CopyBlock(ref d, ref s, Size * sizeof(float));
-        }
-
-        /// <summary>
-        /// Convert scalars to byte-s and copy to dest,
-        /// </summary>
-        /// <param name="blockPtr">Pointer to block</param>
-        /// <param name="dest">Destination</param>
-        [MethodImpl(InliningOptions.ShortMethod)]
-        public static unsafe void ScaledCopyTo(Block8x8F* blockPtr, Span<byte> dest)
-        {
-            float* fPtr = (float*)blockPtr;
-            for (int i = 0; i < Size; i++)
-            {
-                dest[i] = (byte)*fPtr;
-                fPtr++;
-            }
-        }
-
-        /// <summary>
-        /// Copy raw 32bit floating point data to dest.
-        /// </summary>
-        /// <param name="blockPtr">The block pointer.</param>
-        /// <param name="dest">The destination.</param>
-        [MethodImpl(InliningOptions.ShortMethod)]
-        public static unsafe void ScaledCopyTo(Block8x8F* blockPtr, Span<float> dest)
-            => blockPtr->ScaledCopyTo(dest);
-
         /// <summary>
         /// Copy raw 32bit floating point data to dest
         /// </summary>
@@ -253,22 +146,6 @@ namespace SixLabors.ImageSharp.Formats.Jpeg.Components
             }
         }
 
-        /// <summary>
-        /// Copy raw 32bit floating point data to dest
-        /// </summary>
-        /// <param name="dest">Destination</param>
-        public unsafe void ScaledCopyTo(Span<int> dest)
-        {
-            fixed (Vector4* ptr = &this.V0L)
-            {
-                var fp = (float*)ptr;
-                for (int i = 0; i < Size; i++)
-                {
-                    dest[i] = (int)fp[i];
-                }
-            }
-        }
-
         public float[] ToArray()
         {
             float[] result = new float[Size];

src/ImageSharp/Formats/Jpeg/Components/Decoder/ColorConverters/JpegColorConverter.Avx2JpegColorConverter.cs

@@ -1,18 +0,0 @@
-// Copyright (c) Six Labors.
-// Licensed under the Apache License, Version 2.0.
-
-namespace SixLabors.ImageSharp.Formats.Jpeg.Components.Decoder.ColorConverters
-{
-    internal abstract partial class JpegColorConverter
-    {
-        internal abstract class Avx2JpegColorConverter : VectorizedJpegColorConverter
-        {
-            protected Avx2JpegColorConverter(JpegColorSpace colorSpace, int precision)
-                : base(colorSpace, precision, 8)
-            {
-            }
-
-            protected sealed override bool IsAvailable => SimdUtils.HasAvx2;
-        }
-    }
-}

src/ImageSharp/Formats/Jpeg/Components/Decoder/ColorConverters/JpegColorConverter.BasicJpegColorConverter.cs

@@ -1,18 +0,0 @@
-// Copyright (c) Six Labors.
-// Licensed under the Apache License, Version 2.0.
-
-namespace SixLabors.ImageSharp.Formats.Jpeg.Components.Decoder.ColorConverters
-{
-    internal abstract partial class JpegColorConverter
-    {
-        internal abstract class BasicJpegColorConverter : JpegColorConverter
-        {
-            protected BasicJpegColorConverter(JpegColorSpace colorSpace, int precision)
-                : base(colorSpace, precision)
-            {
-            }
-
-            protected override bool IsAvailable => true;
-        }
-    }
-}

src/ImageSharp/Formats/Jpeg/Components/Decoder/ColorConverters/JpegColorConverter.FromCmykAvx.cs

@@ -0,0 +1,52 @@
+// Copyright (c) Six Labors.
+// Licensed under the Apache License, Version 2.0.
+
+#if SUPPORTS_RUNTIME_INTRINSICS
+using System.Runtime.CompilerServices;
+using System.Runtime.InteropServices;
+using System.Runtime.Intrinsics;
+using System.Runtime.Intrinsics.X86;
+
+namespace SixLabors.ImageSharp.Formats.Jpeg.Components.Decoder.ColorConverters
+{
+    internal abstract partial class JpegColorConverterBase
+    {
+        internal sealed class FromCmykAvx : JpegColorConverterAvx
+        {
+            public FromCmykAvx(int precision)
+                : base(JpegColorSpace.Cmyk, precision)
+            {
+            }
+
+            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));
+
+                // Used for the color conversion
+                var scale = Vector256.Create(1 / (this.MaximumValue * this.MaximumValue));
+
+                nint n = values.Component0.Length / Vector256<float>.Count;
+                for (nint 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 = Avx.Multiply(k, scale);
+                    c = Avx.Multiply(c, k);
+                    m = Avx.Multiply(m, k);
+                    y = Avx.Multiply(y, k);
+                }
+            }
+        }
+    }
+}
+#endif

src/ImageSharp/Formats/Jpeg/Components/Decoder/ColorConverters/JpegColorConverter.FromCmykAvx2.cs

@@ -1,60 +0,0 @@
-// Copyright (c) Six Labors.
-// Licensed under the Apache License, Version 2.0.
-
-using System;
-using System.Numerics;
-using System.Runtime.CompilerServices;
-using System.Runtime.InteropServices;
-#if SUPPORTS_RUNTIME_INTRINSICS
-using System.Runtime.Intrinsics;
-using System.Runtime.Intrinsics.X86;
-using static SixLabors.ImageSharp.SimdUtils;
-#endif
-
-namespace SixLabors.ImageSharp.Formats.Jpeg.Components.Decoder.ColorConverters
-{
-    internal abstract partial class JpegColorConverter
-    {
-        internal sealed class FromCmykAvx2 : Avx2JpegColorConverter
-        {
-            public FromCmykAvx2(int precision)
-                : base(JpegColorSpace.Cmyk, precision)
-            {
-            }
-
-            protected override void ConvertCoreVectorizedInplace(in ComponentValues values)
-            {
-#if SUPPORTS_RUNTIME_INTRINSICS
-                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));
-
-                // Used for the color conversion
-                var scale = Vector256.Create(1 / this.MaximumValue);
-
-                nint n = values.Component0.Length / 8;
-                for (nint 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 = Avx.Multiply(k, scale);
-                    c = Avx.Multiply(Avx.Multiply(c, k), scale);
-                    m = Avx.Multiply(Avx.Multiply(m, k), scale);
-                    y = Avx.Multiply(Avx.Multiply(y, k), scale);
-                }
-#endif
-            }
-
-            protected override void ConvertCoreInplace(in ComponentValues values) =>
-                FromCmykBasic.ConvertCoreInplace(values, this.MaximumValue);
-        }
-    }
-}

src/ImageSharp/Formats/Jpeg/Components/Decoder/ColorConverters/JpegColorConverter.FromCmykBasic.cs → src/ImageSharp/Formats/Jpeg/Components/Decoder/ColorConverters/JpegColorConverter.FromCmykScalar.cs

@@ -1,16 +1,15 @@
-// Copyright (c) Six Labors.
+// Copyright (c) Six Labors.
 // Licensed under the Apache License, Version 2.0.
 
 using System;
-using System.Numerics;
 
 namespace SixLabors.ImageSharp.Formats.Jpeg.Components.Decoder.ColorConverters
 {
-    internal abstract partial class JpegColorConverter
+    internal abstract partial class JpegColorConverterBase
     {
-        internal sealed class FromCmykBasic : BasicJpegColorConverter
+        internal sealed class FromCmykScalar : JpegColorConverterScalar
         {
-            public FromCmykBasic(int precision)
+            public FromCmykScalar(int precision)
                 : base(JpegColorSpace.Cmyk, precision)
             {
             }
@@ -25,17 +24,18 @@ namespace SixLabors.ImageSharp.Formats.Jpeg.Components.Decoder.ColorConverters
                 Span<float> c2 = values.Component2;
                 Span<float> c3 = values.Component3;
 
-                float scale = 1 / maxValue;
+                float scale = 1 / (maxValue * maxValue);
                 for (int i = 0; i < c0.Length; i++)
                 {
                     float c = c0[i];
                     float m = c1[i];
                     float y = c2[i];
-                    float k = c3[i] / maxValue;
+                    float k = c3[i];
 
-                    c0[i] = c * k * scale;
-                    c1[i] = m * k * scale;
-                    c2[i] = y * k * scale;
+                    k *= scale;
+                    c0[i] = c * k;
+                    c1[i] = m * k;
+                    c2[i] = y * k;
                 }
             }
         }

src/ImageSharp/Formats/Jpeg/Components/Decoder/ColorConverters/JpegColorConverter.FromCmykVector.cs

@@ -0,0 +1,51 @@
+// Copyright (c) Six Labors.
+// Licensed under the Apache License, Version 2.0.
+
+using System.Numerics;
+using System.Runtime.CompilerServices;
+using System.Runtime.InteropServices;
+
+namespace SixLabors.ImageSharp.Formats.Jpeg.Components.Decoder.ColorConverters
+{
+    internal abstract partial class JpegColorConverterBase
+    {
+        internal sealed class FromCmykVector : JpegColorConverterVector
+        {
+            public FromCmykVector(int precision)
+                : base(JpegColorSpace.Cmyk, precision)
+            {
+            }
+
+            protected override void ConvertCoreVectorizedInplace(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));
+
+                nint n = values.Component0.Length / Vector<float>.Count;
+                for (nint 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;
+                }
+            }
+
+            protected override void ConvertCoreInplace(in ComponentValues values) =>
+                FromCmykScalar.ConvertCoreInplace(values, this.MaximumValue);
+        }
+    }
+}

src/ImageSharp/Formats/Jpeg/Components/Decoder/ColorConverters/JpegColorConverter.FromCmykVector8.cs

@@ -1,53 +0,0 @@
-// Copyright (c) Six Labors.
-// Licensed under the Apache License, Version 2.0.
-
-using System;
-using System.Numerics;
-using System.Runtime.CompilerServices;
-using System.Runtime.InteropServices;
-using SixLabors.ImageSharp.Tuples;
-
-namespace SixLabors.ImageSharp.Formats.Jpeg.Components.Decoder.ColorConverters
-{
-    internal abstract partial class JpegColorConverter
-    {
-        internal sealed class FromCmykVector8 : Vector8JpegColorConverter
-        {
-            public FromCmykVector8(int precision)
-                : base(JpegColorSpace.Cmyk, precision)
-            {
-            }
-
-            protected override void ConvertCoreVectorizedInplace(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);
-
-                // Walking 8 elements at one step:
-                nint n = values.Component0.Length / 8;
-                for (nint 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) * scale;
-
-                    c = (c * k) * scale;
-                    m = (m * k) * scale;
-                    y = (y * k) * scale;
-                }
-            }
-
-            protected override void ConvertCoreInplace(in ComponentValues values) =>
-                FromCmykBasic.ConvertCoreInplace(values, this.MaximumValue);
-        }
-    }
-}

src/ImageSharp/Formats/Jpeg/Components/Decoder/ColorConverters/JpegColorConverter.FromGrayScaleAvx2.cs → src/ImageSharp/Formats/Jpeg/Components/Decoder/ColorConverters/JpegColorConverter.FromGrayScaleAvx.cs

@@ -1,47 +1,39 @@
-// Copyright (c) Six Labors.
+// Copyright (c) Six Labors.
 // Licensed under the Apache License, Version 2.0.
 
-using System;
-using System.Numerics;
+#if SUPPORTS_RUNTIME_INTRINSICS
 using System.Runtime.CompilerServices;
 using System.Runtime.InteropServices;
-#if SUPPORTS_RUNTIME_INTRINSICS
 using System.Runtime.Intrinsics;
 using System.Runtime.Intrinsics.X86;
-using static SixLabors.ImageSharp.SimdUtils;
-#endif
 
 namespace SixLabors.ImageSharp.Formats.Jpeg.Components.Decoder.ColorConverters
 {
-    internal abstract partial class JpegColorConverter
+    internal abstract partial class JpegColorConverterBase
     {
-        internal sealed class FromGrayscaleAvx2 : Avx2JpegColorConverter
+        internal sealed class FromGrayscaleAvx : JpegColorConverterAvx
         {
-            public FromGrayscaleAvx2(int precision)
+            public FromGrayscaleAvx(int precision)
                 : base(JpegColorSpace.Grayscale, precision)
             {
             }
 
-            protected override void ConvertCoreVectorizedInplace(in ComponentValues values)
+            public override void ConvertToRgbInplace(in ComponentValues values)
             {
-#if SUPPORTS_RUNTIME_INTRINSICS
                 ref Vector256<float> c0Base =
                     ref Unsafe.As<float, Vector256<float>>(ref MemoryMarshal.GetReference(values.Component0));
 
                 // Used for the color conversion
                 var scale = Vector256.Create(1 / this.MaximumValue);
 
-                nint n = values.Component0.Length / 8;
+                nint n = values.Component0.Length / Vector256<float>.Count;
                 for (nint i = 0; i < n; i++)
                 {
                     ref Vector256<float> c0 = ref Unsafe.Add(ref c0Base, i);
                     c0 = Avx.Multiply(c0, scale);
                 }
-#endif
             }
-
-            protected override void ConvertCoreInplace(in ComponentValues values) =>
-                FromGrayscaleBasic.ScaleValues(values.Component0, this.MaximumValue);
         }
     }
 }
+#endif

src/ImageSharp/Formats/Jpeg/Components/Decoder/ColorConverters/JpegColorConverter.FromGrayScaleBasic.cs

@@ -1,53 +0,0 @@
-// Copyright (c) Six Labors.
-// Licensed under the Apache License, Version 2.0.
-
-using System;
-using System.Numerics;
-using System.Runtime.CompilerServices;
-using System.Runtime.InteropServices;
-
-namespace SixLabors.ImageSharp.Formats.Jpeg.Components.Decoder.ColorConverters
-{
-    internal abstract partial class JpegColorConverter
-    {
-        internal sealed class FromGrayscaleBasic : BasicJpegColorConverter
-        {
-            public FromGrayscaleBasic(int precision)
-                : base(JpegColorSpace.Grayscale, precision)
-            {
-            }
-
-            public override void ConvertToRgbInplace(in ComponentValues values) =>
-                ScaleValues(values.Component0, this.MaximumValue);
-
-            internal static void ScaleValues(Span<float> values, float maxValue)
-            {
-                Span<Vector4> vecValues = MemoryMarshal.Cast<float, Vector4>(values);
-
-                var scaleVector = new Vector4(1 / maxValue);
-
-                for (int i = 0; i < vecValues.Length; i++)
-                {
-                    vecValues[i] *= scaleVector;
-                }
-
-                values = values.Slice(vecValues.Length * 4);
-                if (!values.IsEmpty)
-                {
-                    float scaleValue = 1f / maxValue;
-                    values[0] *= scaleValue;
-
-                    if ((uint)values.Length > 1)
-                    {
-                        values[1] *= scaleValue;
-
-                        if ((uint)values.Length > 2)
-                        {
-                            values[2] *= scaleValue;
-                        }
-                    }
-                }
-            }
-        }
-    }
-}

src/ImageSharp/Formats/Jpeg/Components/Decoder/ColorConverters/JpegColorConverter.FromGrayScaleScalar.cs

@@ -0,0 +1,34 @@
+// Copyright (c) Six Labors.
+// Licensed under the Apache License, Version 2.0.
+
+using System;
+using System.Runtime.CompilerServices;
+using System.Runtime.InteropServices;
+
+namespace SixLabors.ImageSharp.Formats.Jpeg.Components.Decoder.ColorConverters
+{
+    internal abstract partial class JpegColorConverterBase
+    {
+        internal sealed class FromGrayscaleScalar : JpegColorConverterScalar
+        {
+            public FromGrayscaleScalar(int precision)
+                : base(JpegColorSpace.Grayscale, precision)
+            {
+            }
+
+            public override void ConvertToRgbInplace(in ComponentValues values) =>
+                ConvertCoreInplace(values.Component0, this.MaximumValue);
+
+            internal static void ConvertCoreInplace(Span<float> values, float maxValue)
+            {
+                ref float valuesRef = ref MemoryMarshal.GetReference(values);
+                float scale = 1 / maxValue;
+
+                for (nint i = 0; i < values.Length; i++)
+                {
+                    Unsafe.Add(ref valuesRef, i) *= scale;
+                }
+            }
+        }
+    }
+}

src/ImageSharp/Formats/Jpeg/Components/Decoder/ColorConverters/JpegColorConverter.FromGrayScaleVector.cs

@@ -0,0 +1,38 @@
+// Copyright (c) Six Labors.
+// Licensed under the Apache License, Version 2.0.
+
+using System.Numerics;
+using System.Runtime.CompilerServices;
+using System.Runtime.InteropServices;
+
+namespace SixLabors.ImageSharp.Formats.Jpeg.Components.Decoder.ColorConverters
+{
+    internal abstract partial class JpegColorConverterBase
+    {
+        internal sealed class FromGrayScaleVector : JpegColorConverterVector
+        {
+            public FromGrayScaleVector(int precision)
+                : base(JpegColorSpace.Grayscale, precision)
+            {
+            }
+
+            protected override void ConvertCoreVectorizedInplace(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);
+
+                nint n = values.Component0.Length / Vector<float>.Count;
+                for (nint i = 0; i < n; i++)
+                {
+                    ref Vector<float> c0 = ref Unsafe.Add(ref cBase, i);
+                    c0 *= scale;
+                }
+            }
+
+            protected override void ConvertCoreInplace(in ComponentValues values) =>
+                FromGrayscaleScalar.ConvertCoreInplace(values.Component0, this.MaximumValue);
+        }
+    }
+}

src/ImageSharp/Formats/Jpeg/Components/Decoder/ColorConverters/JpegColorConverter.FromRgbAvx2.cs → src/ImageSharp/Formats/Jpeg/Components/Decoder/ColorConverters/JpegColorConverter.FromRgbAvx.cs

@@ -1,40 +1,35 @@
-// Copyright (c) Six Labors.
+// Copyright (c) Six Labors.
 // Licensed under the Apache License, Version 2.0.
 
-using System;
-using System.Numerics;
+#if SUPPORTS_RUNTIME_INTRINSICS
 using System.Runtime.CompilerServices;
 using System.Runtime.InteropServices;
-#if SUPPORTS_RUNTIME_INTRINSICS
 using System.Runtime.Intrinsics;
 using System.Runtime.Intrinsics.X86;
-using static SixLabors.ImageSharp.SimdUtils;
-#endif
 
 namespace SixLabors.ImageSharp.Formats.Jpeg.Components.Decoder.ColorConverters
 {
-    internal abstract partial class JpegColorConverter
+    internal abstract partial class JpegColorConverterBase
     {
-        internal sealed class FromRgbAvx2 : Avx2JpegColorConverter
+        internal sealed class FromRgbAvx : JpegColorConverterAvx
         {
-            public FromRgbAvx2(int precision)
+            public FromRgbAvx(int precision)
                 : base(JpegColorSpace.RGB, precision)
             {
             }
 
-            protected override void ConvertCoreVectorizedInplace(in ComponentValues values)
+            public override void ConvertToRgbInplace(in ComponentValues values)
             {
-#if SUPPORTS_RUNTIME_INTRINSICS
                 ref Vector256<float> rBase =
-                                    ref Unsafe.As<float, Vector256<float>>(ref MemoryMarshal.GetReference(values.Component0));
+                    ref Unsafe.As<float, Vector256<float>>(ref MemoryMarshal.GetReference(values.Component0));
                 ref Vector256<float> gBase =
-                                    ref Unsafe.As<float, Vector256<float>>(ref MemoryMarshal.GetReference(values.Component1));
+                    ref Unsafe.As<float, Vector256<float>>(ref MemoryMarshal.GetReference(values.Component1));
                 ref Vector256<float> bBase =
-                                    ref Unsafe.As<float, Vector256<float>>(ref MemoryMarshal.GetReference(values.Component2));
+                    ref Unsafe.As<float, Vector256<float>>(ref MemoryMarshal.GetReference(values.Component2));
 
                 // Used for the color conversion
                 var scale = Vector256.Create(1 / this.MaximumValue);
-                nint n = values.Component0.Length / 8;
+                nint n = values.Component0.Length / Vector256<float>.Count;
                 for (nint i = 0; i < n; i++)
                 {
                     ref Vector256<float> r = ref Unsafe.Add(ref rBase, i);
@@ -44,11 +39,8 @@ namespace SixLabors.ImageSharp.Formats.Jpeg.Components.Decoder.ColorConverters
                     g = Avx.Multiply(g, scale);
                     b = Avx.Multiply(b, scale);
                 }
-#endif
             }
-
-            protected override void ConvertCoreInplace(in ComponentValues values) =>
-                FromRgbBasic.ConvertCoreInplace(values, this.MaximumValue);
         }
     }
 }
+#endif

src/ImageSharp/Formats/Jpeg/Components/Decoder/ColorConverters/JpegColorConverter.FromRgbBasic.cs

@@ -1,32 +0,0 @@
-// Copyright (c) Six Labors.
-// Licensed under the Apache License, Version 2.0.
-
-using System;
-using System.Numerics;
-using System.Runtime.InteropServices;
-
-namespace SixLabors.ImageSharp.Formats.Jpeg.Components.Decoder.ColorConverters
-{
-    internal abstract partial class JpegColorConverter
-    {
-        internal sealed class FromRgbBasic : BasicJpegColorConverter
-        {
-            public FromRgbBasic(int precision)
-                : base(JpegColorSpace.RGB, precision)
-            {
-            }
-
-            public override void ConvertToRgbInplace(in ComponentValues values)
-            {
-                ConvertCoreInplace(values, this.MaximumValue);
-            }
-
-            internal static void ConvertCoreInplace(ComponentValues values, float maxValue)
-            {
-                FromGrayscaleBasic.ScaleValues(values.Component0, maxValue);
-                FromGrayscaleBasic.ScaleValues(values.Component1, maxValue);
-                FromGrayscaleBasic.ScaleValues(values.Component2, maxValue);
-            }
-        }
-    }
-}

src/ImageSharp/Formats/Jpeg/Components/Decoder/ColorConverters/JpegColorConverter.FromRgbScalar.cs

@@ -0,0 +1,26 @@
+// Copyright (c) Six Labors.
+// Licensed under the Apache License, Version 2.0.
+
+namespace SixLabors.ImageSharp.Formats.Jpeg.Components.Decoder.ColorConverters
+{
+    internal abstract partial class JpegColorConverterBase
+    {
+        internal sealed class FromRgbScalar : JpegColorConverterScalar
+        {
+            public FromRgbScalar(int precision)
+                : base(JpegColorSpace.RGB, precision)
+            {
+            }
+
+            public override void ConvertToRgbInplace(in ComponentValues values) =>
+                ConvertCoreInplace(values, this.MaximumValue);
+
+            internal static void ConvertCoreInplace(ComponentValues values, float maxValue)
+            {
+                FromGrayscaleScalar.ConvertCoreInplace(values.Component0, maxValue);
+                FromGrayscaleScalar.ConvertCoreInplace(values.Component1, maxValue);
+                FromGrayscaleScalar.ConvertCoreInplace(values.Component2, maxValue);
+            }
+        }
+    }
+}

src/ImageSharp/Formats/Jpeg/Components/Decoder/ColorConverters/JpegColorConverter.FromRgbVector8.cs → src/ImageSharp/Formats/Jpeg/Components/Decoder/ColorConverters/JpegColorConverter.FromRgbVector.cs

@@ -1,19 +1,17 @@
-// Copyright (c) Six Labors.
+// Copyright (c) Six Labors.
 // Licensed under the Apache License, Version 2.0.
 
-using System;
 using System.Numerics;
 using System.Runtime.CompilerServices;
 using System.Runtime.InteropServices;
-using SixLabors.ImageSharp.Tuples;
 
 namespace SixLabors.ImageSharp.Formats.Jpeg.Components.Decoder.ColorConverters
 {
-    internal abstract partial class JpegColorConverter
+    internal abstract partial class JpegColorConverterBase
     {
-        internal sealed class FromRgbVector8 : Vector8JpegColorConverter
+        internal sealed class FromRgbVector : JpegColorConverterVector
         {
-            public FromRgbVector8(int precision)
+            public FromRgbVector(int precision)
                 : base(JpegColorSpace.RGB, precision)
             {
             }
@@ -29,8 +27,7 @@ namespace SixLabors.ImageSharp.Formats.Jpeg.Components.Decoder.ColorConverters
 
                 var scale = new Vector<float>(1 / this.MaximumValue);
 
-                // Walking 8 elements at one step:
-                nint n = values.Component0.Length / 8;
+                nint n = values.Component0.Length / Vector<float>.Count;
                 for (nint i = 0; i < n; i++)
                 {
                     ref Vector<float> r = ref Unsafe.Add(ref rBase, i);
@@ -43,7 +40,7 @@ namespace SixLabors.ImageSharp.Formats.Jpeg.Components.Decoder.ColorConverters
             }
 
             protected override void ConvertCoreInplace(in ComponentValues values) =>
-                FromRgbBasic.ConvertCoreInplace(values, this.MaximumValue);
+                FromRgbScalar.ConvertCoreInplace(values, this.MaximumValue);
         }
     }
 }

src/ImageSharp/Formats/Jpeg/Components/Decoder/ColorConverters/JpegColorConverter.FromYCbCrAvx2.cs → src/ImageSharp/Formats/Jpeg/Components/Decoder/ColorConverters/JpegColorConverter.FromYCbCrAvx.cs

@@ -1,31 +1,27 @@
 // Copyright (c) Six Labors.
 // Licensed under the Apache License, Version 2.0.
 
-using System;
-using System.Numerics;
+#if SUPPORTS_RUNTIME_INTRINSICS
 using System.Runtime.CompilerServices;
 using System.Runtime.InteropServices;
-#if SUPPORTS_RUNTIME_INTRINSICS
 using System.Runtime.Intrinsics;
 using System.Runtime.Intrinsics.X86;
 using static SixLabors.ImageSharp.SimdUtils;
-#endif
 
 // ReSharper disable ImpureMethodCallOnReadonlyValueField
 namespace SixLabors.ImageSharp.Formats.Jpeg.Components.Decoder.ColorConverters
 {
-    internal abstract partial class JpegColorConverter
+    internal abstract partial class JpegColorConverterBase
     {
-        internal sealed class FromYCbCrAvx2 : Avx2JpegColorConverter
+        internal sealed class FromYCbCrAvx : JpegColorConverterAvx
         {
-            public FromYCbCrAvx2(int precision)
+            public FromYCbCrAvx(int precision)
                 : base(JpegColorSpace.YCbCr, precision)
             {
             }
 
-            protected override void ConvertCoreVectorizedInplace(in ComponentValues values)
+            public override void ConvertToRgbInplace(in ComponentValues values)
             {
-#if SUPPORTS_RUNTIME_INTRINSICS
                 ref Vector256<float> c0Base =
                     ref Unsafe.As<float, Vector256<float>>(ref MemoryMarshal.GetReference(values.Component0));
                 ref Vector256<float> c1Base =
@@ -36,18 +32,13 @@ namespace SixLabors.ImageSharp.Formats.Jpeg.Components.Decoder.ColorConverters
                 // Used for the color conversion
                 var chromaOffset = Vector256.Create(-this.HalfValue);
                 var scale = Vector256.Create(1 / this.MaximumValue);
-                var rCrMult = Vector256.Create(1.402F);
-                var gCbMult = Vector256.Create(-0.344136F);
-                var gCrMult = Vector256.Create(-0.714136F);
-                var bCbMult = Vector256.Create(1.772F);
-
-                // Used for packing.
-                var va = Vector256.Create(1F);
-                ref byte control = ref MemoryMarshal.GetReference(HwIntrinsics.PermuteMaskEvenOdd8x32);
-                Vector256<int> vcontrol = Unsafe.As<byte, Vector256<int>>(ref control);
+                var rCrMult = Vector256.Create(FromYCbCrScalar.RCrMult);
+                var gCbMult = Vector256.Create(-FromYCbCrScalar.GCbMult);
+                var gCrMult = Vector256.Create(-FromYCbCrScalar.GCrMult);
+                var bCbMult = Vector256.Create(FromYCbCrScalar.BCbMult);
 
                 // Walking 8 elements at one step:
-                nint n = values.Component0.Length / 8;
+                nint n = values.Component0.Length / Vector256<float>.Count;
                 for (nint i = 0; i < n; i++)
                 {
                     // y = yVals[i];
@@ -64,7 +55,6 @@ namespace SixLabors.ImageSharp.Formats.Jpeg.Components.Decoder.ColorConverters
                     // r = y + (1.402F * cr);
                     // g = y - (0.344136F * cb) - (0.714136F * cr);
                     // b = y + (1.772F * cb);
-                    // Adding & multiplying 8 elements at one time:
                     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);
@@ -77,11 +67,8 @@ namespace SixLabors.ImageSharp.Formats.Jpeg.Components.Decoder.ColorConverters
                     c1 = g;
                     c2 = b;
                 }
-#endif
             }
-
-            protected override void ConvertCoreInplace(in ComponentValues values) =>
-                FromYCbCrBasic.ConvertCoreInplace(values, this.MaximumValue, this.HalfValue);
         }
     }
 }
+#endif

src/ImageSharp/Formats/Jpeg/Components/Decoder/ColorConverters/JpegColorConverter.FromYCbCrBasic.cs

@@ -1,42 +0,0 @@
-// Copyright (c) Six Labors.
-// Licensed under the Apache License, Version 2.0.
-
-using System;
-using System.Numerics;
-
-namespace SixLabors.ImageSharp.Formats.Jpeg.Components.Decoder.ColorConverters
-{
-    internal abstract partial class JpegColorConverter
-    {
-        internal sealed class FromYCbCrBasic : BasicJpegColorConverter
-        {
-            public FromYCbCrBasic(int precision)
-                : base(JpegColorSpace.YCbCr, precision)
-            {
-            }
-
-            public override void ConvertToRgbInplace(in ComponentValues values)
-                => ConvertCoreInplace(values, this.MaximumValue, this.HalfValue);
-
-            internal static void ConvertCoreInplace(in ComponentValues values, float maxValue, float halfValue)
-            {
-                Span<float> c0 = values.Component0;
-                Span<float> c1 = values.Component1;
-                Span<float> c2 = values.Component2;
-
-                var scale = 1 / maxValue;
-
-                for (int i = 0; i < c0.Length; i++)
-                {
-                    float y = c0[i];
-                    float cb = c1[i] - halfValue;
-                    float cr = c2[i] - halfValue;
-
-                    c0[i] = MathF.Round(y + (1.402F * cr), MidpointRounding.AwayFromZero) * scale;
-                    c1[i] = MathF.Round(y - (0.344136F * cb) - (0.714136F * cr), MidpointRounding.AwayFromZero) * scale;
-                    c2[i] = MathF.Round(y + (1.772F * cb), MidpointRounding.AwayFromZero) * scale;
-                }
-            }
-        }
-    }
-}

src/ImageSharp/Formats/Jpeg/Components/Decoder/ColorConverters/JpegColorConverter.FromYCbCrScalar.cs

@@ -0,0 +1,50 @@
+// Copyright (c) Six Labors.
+// Licensed under the Apache License, Version 2.0.
+
+using System;
+
+namespace SixLabors.ImageSharp.Formats.Jpeg.Components.Decoder.ColorConverters
+{
+    internal abstract partial class JpegColorConverterBase
+    {
+        internal sealed class FromYCbCrScalar : JpegColorConverterScalar
+        {
+            // TODO: comments, 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 FromYCbCrScalar(int precision)
+                : base(JpegColorSpace.YCbCr, precision)
+            {
+            }
+
+            public override void ConvertToRgbInplace(in ComponentValues values)
+                => ConvertCoreInplace(values, this.MaximumValue, this.HalfValue);
+
+            internal static void ConvertCoreInplace(in ComponentValues values, float maxValue, float halfValue)
+            {
+                Span<float> c0 = values.Component0;
+                Span<float> c1 = values.Component1;
+                Span<float> c2 = values.Component2;
+
+                float scale = 1 / maxValue;
+
+                for (int i = 0; i < c0.Length; i++)
+                {
+                    float y = c0[i];
+                    float cb = c1[i] - halfValue;
+                    float cr = c2[i] - halfValue;
+
+                    // r = y + (1.402F * cr);
+                    // g = y - (0.344136F * cb) - (0.714136F * cr);
+                    // b = y + (1.772F * cb);
+                    c0[i] = MathF.Round(y + (RCrMult * cr), MidpointRounding.AwayFromZero) * scale;
+                    c1[i] = MathF.Round(y - (GCbMult * cb) - (GCrMult * cr), MidpointRounding.AwayFromZero) * scale;
+                    c2[i] = MathF.Round(y + (BCbMult * cb), MidpointRounding.AwayFromZero) * scale;
+                }
+            }
+        }
+    }
+}

src/ImageSharp/Formats/Jpeg/Components/Decoder/ColorConverters/JpegColorConverter.FromYCbCrVector8.cs → src/ImageSharp/Formats/Jpeg/Components/Decoder/ColorConverters/JpegColorConverter.FromYCbCrVector.cs

@@ -1,20 +1,18 @@
 // Copyright (c) Six Labors.
 // Licensed under the Apache License, Version 2.0.
 
-using System;
 using System.Numerics;
 using System.Runtime.CompilerServices;
 using System.Runtime.InteropServices;
-using SixLabors.ImageSharp.Tuples;
 
 // ReSharper disable ImpureMethodCallOnReadonlyValueField
 namespace SixLabors.ImageSharp.Formats.Jpeg.Components.Decoder.ColorConverters
 {
-    internal abstract partial class JpegColorConverter
+    internal abstract partial class JpegColorConverterBase
     {
-        internal sealed class FromYCbCrVector8 : Vector8JpegColorConverter
+        internal sealed class FromYCbCrVector : JpegColorConverterVector
         {
-            public FromYCbCrVector8(int precision)
+            public FromYCbCrVector(int precision)
                 : base(JpegColorSpace.YCbCr, precision)
             {
             }
@@ -30,10 +28,13 @@ namespace SixLabors.ImageSharp.Formats.Jpeg.Components.Decoder.ColorConverters
 
                 var chromaOffset = new Vector<float>(-this.HalfValue);
 
-                // Walking 8 elements at one step:
-                nint n = values.Component0.Length / 8;
                 var scale = new Vector<float>(1 / this.MaximumValue);
+                var rCrMult = new Vector<float>(FromYCbCrScalar.RCrMult);
+                var gCbMult = new Vector<float>(-FromYCbCrScalar.GCbMult);
+                var gCrMult = new Vector<float>(-FromYCbCrScalar.GCrMult);
+                var bCbMult = new Vector<float>(FromYCbCrScalar.BCbMult);
 
+                nint n = values.Component0.Length / Vector<float>.Count;
                 for (nint i = 0; i < n; i++)
                 {
                     // y = yVals[i];
@@ -49,10 +50,9 @@ namespace SixLabors.ImageSharp.Formats.Jpeg.Components.Decoder.ColorConverters
                     // r = y + (1.402F * cr);
                     // g = y - (0.344136F * cb) - (0.714136F * cr);
                     // b = y + (1.772F * cb);
-                    // Adding & multiplying 8 elements at one time:
-                    Vector<float> r = y + (cr * new Vector<float>(1.402F));
-                    Vector<float> g = y - (cb * new Vector<float>(0.344136F)) - (cr * new Vector<float>(0.714136F));
-                    Vector<float> b = y + (cb * new Vector<float>(1.772F));
+                    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();
@@ -68,7 +68,7 @@ namespace SixLabors.ImageSharp.Formats.Jpeg.Components.Decoder.ColorConverters
             }
 
             protected override void ConvertCoreInplace(in ComponentValues values) =>
-                FromYCbCrBasic.ConvertCoreInplace(values, this.MaximumValue, this.HalfValue);
+                FromYCbCrScalar.ConvertCoreInplace(values, this.MaximumValue, this.HalfValue);
         }
     }
 }

src/ImageSharp/Formats/Jpeg/Components/Decoder/ColorConverters/JpegColorConverter.FromYCbCrVector4.cs

@@ -1,88 +0,0 @@
-// Copyright (c) Six Labors.
-// Licensed under the Apache License, Version 2.0.
-
-using System;
-using System.Numerics;
-using System.Runtime.CompilerServices;
-using System.Runtime.InteropServices;
-using SixLabors.ImageSharp.Tuples;
-
-namespace SixLabors.ImageSharp.Formats.Jpeg.Components.Decoder.ColorConverters
-{
-    internal abstract partial class JpegColorConverter
-    {
-        internal sealed class FromYCbCrVector4 : VectorizedJpegColorConverter
-        {
-            public FromYCbCrVector4(int precision)
-                : base(JpegColorSpace.YCbCr, precision, 8)
-            {
-            }
-
-            protected override bool IsAvailable => SimdUtils.HasVector4;
-
-            protected override void ConvertCoreVectorizedInplace(in ComponentValues values)
-            {
-                DebugGuard.IsTrue(values.Component0.Length % 8 == 0, nameof(values), "Length should be divisible by 8!");
-
-                ref Vector4Pair c0Base =
-                    ref Unsafe.As<float, Vector4Pair>(ref MemoryMarshal.GetReference(values.Component0));
-                ref Vector4Pair c1Base =
-                    ref Unsafe.As<float, Vector4Pair>(ref MemoryMarshal.GetReference(values.Component1));
-                ref Vector4Pair c2Base =
-                    ref Unsafe.As<float, Vector4Pair>(ref MemoryMarshal.GetReference(values.Component2));
-
-                var chromaOffset = new Vector4(-this.HalfValue);
-                var maxValue = this.MaximumValue;
-
-                // Walking 8 elements at one step:
-                nint n = values.Component0.Length / 8;
-
-                for (nint i = 0; i < n; i++)
-                {
-                    // y = yVals[i];
-                    ref Vector4Pair c0 = ref Unsafe.Add(ref c0Base, i);
-
-                    // cb = cbVals[i] - halfValue);
-                    ref Vector4Pair c1 = ref Unsafe.Add(ref c1Base, i);
-                    c1.AddInplace(chromaOffset);
-
-                    // cr = crVals[i] - halfValue;
-                    ref Vector4Pair c2 = ref Unsafe.Add(ref c2Base, i);
-                    c2.AddInplace(chromaOffset);
-
-                    // r = y + (1.402F * cr);
-                    Vector4Pair r = c0;
-                    Vector4Pair tmp = c2;
-                    tmp.MultiplyInplace(1.402F);
-                    r.AddInplace(ref tmp);
-
-                    // g = y - (0.344136F * cb) - (0.714136F * cr);
-                    Vector4Pair g = c0;
-                    tmp = c1;
-                    tmp.MultiplyInplace(-0.344136F);
-                    g.AddInplace(ref tmp);
-                    tmp = c2;
-                    tmp.MultiplyInplace(-0.714136F);
-                    g.AddInplace(ref tmp);
-
-                    // b = y + (1.772F * cb);
-                    Vector4Pair b = c0;
-                    tmp = c1;
-                    tmp.MultiplyInplace(1.772F);
-                    b.AddInplace(ref tmp);
-
-                    r.RoundAndDownscalePreVector8(maxValue);
-                    g.RoundAndDownscalePreVector8(maxValue);
-                    b.RoundAndDownscalePreVector8(maxValue);
-
-                    c0 = r;
-                    c1 = g;
-                    c2 = b;
-                }
-            }
-
-            protected override void ConvertCoreInplace(in ComponentValues values)
-                => FromYCbCrBasic.ConvertCoreInplace(values, this.MaximumValue, this.HalfValue);
-        }
-    }
-}

src/ImageSharp/Formats/Jpeg/Components/Decoder/ColorConverters/JpegColorConverter.FromYccKAvx2.cs → src/ImageSharp/Formats/Jpeg/Components/Decoder/ColorConverters/JpegColorConverter.FromYccKAvx.cs

@@ -1,30 +1,26 @@
-// Copyright (c) Six Labors.
+// Copyright (c) Six Labors.
 // Licensed under the Apache License, Version 2.0.
 
-using System;
-using System.Numerics;
+#if SUPPORTS_RUNTIME_INTRINSICS
 using System.Runtime.CompilerServices;
 using System.Runtime.InteropServices;
-#if SUPPORTS_RUNTIME_INTRINSICS
 using System.Runtime.Intrinsics;
 using System.Runtime.Intrinsics.X86;
 using static SixLabors.ImageSharp.SimdUtils;
-#endif
 
 namespace SixLabors.ImageSharp.Formats.Jpeg.Components.Decoder.ColorConverters
 {
-    internal abstract partial class JpegColorConverter
+    internal abstract partial class JpegColorConverterBase
     {
-        internal sealed class FromYccKAvx2 : Avx2JpegColorConverter
+        internal sealed class FromYccKAvx : JpegColorConverterAvx
         {
-            public FromYccKAvx2(int precision)
+            public FromYccKAvx(int precision)
                 : base(JpegColorSpace.Ycck, precision)
             {
             }
 
-            protected override void ConvertCoreVectorizedInplace(in ComponentValues values)
+            public override void ConvertToRgbInplace(in ComponentValues values)
             {
-#if SUPPORTS_RUNTIME_INTRINSICS
                 ref Vector256<float> c0Base =
                     ref Unsafe.As<float, Vector256<float>>(ref MemoryMarshal.GetReference(values.Component0));
                 ref Vector256<float> c1Base =
@@ -38,13 +34,13 @@ namespace SixLabors.ImageSharp.Formats.Jpeg.Components.Decoder.ColorConverters
                 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(1.402F);
-                var gCbMult = Vector256.Create(-0.344136F);
-                var gCrMult = Vector256.Create(-0.714136F);
-                var bCbMult = Vector256.Create(1.772F);
+                var rCrMult = Vector256.Create(FromYCbCrScalar.RCrMult);
+                var gCbMult = Vector256.Create(-FromYCbCrScalar.GCbMult);
+                var gCrMult = Vector256.Create(-FromYCbCrScalar.GCrMult);
+                var bCbMult = Vector256.Create(FromYCbCrScalar.BCbMult);
 
                 // Walking 8 elements at one step:
-                nint n = values.Component0.Length / 8;
+                nint n = values.Component0.Length / Vector256<float>.Count;
                 for (nint i = 0; i < n; i++)
                 {
                     // y = yVals[i];
@@ -62,7 +58,6 @@ namespace SixLabors.ImageSharp.Formats.Jpeg.Components.Decoder.ColorConverters
                     // r = y + (1.402F * cr);
                     // g = y - (0.344136F * cb) - (0.714136F * cr);
                     // b = y + (1.772F * cb);
-                    // Adding & multiplying 8 elements at one time:
                     Vector256<float> r = HwIntrinsics.MultiplyAdd(y, cr, rCrMult);
                     Vector256<float> g =
                         HwIntrinsics.MultiplyAdd(HwIntrinsics.MultiplyAdd(y, cb, gCbMult), cr, gCrMult);
@@ -80,11 +75,8 @@ namespace SixLabors.ImageSharp.Formats.Jpeg.Components.Decoder.ColorConverters
                     c1 = g;
                     c2 = b;
                 }
-#endif
             }
-
-            protected override void ConvertCoreInplace(in ComponentValues values) =>
-                FromYccKBasic.ConvertCoreInplace(values, this.MaximumValue, this.HalfValue);
         }
     }
 }
+#endif

src/ImageSharp/Formats/Jpeg/Components/Decoder/ColorConverters/JpegColorConverter.FromYccKBasic.cs → src/ImageSharp/Formats/Jpeg/Components/Decoder/ColorConverters/JpegColorConverter.FromYccKScalar.cs

@@ -1,16 +1,15 @@
-// Copyright (c) Six Labors.
+// Copyright (c) Six Labors.
 // Licensed under the Apache License, Version 2.0.
 
 using System;
-using System.Numerics;
 
 namespace SixLabors.ImageSharp.Formats.Jpeg.Components.Decoder.ColorConverters
 {
-    internal abstract partial class JpegColorConverter
+    internal abstract partial class JpegColorConverterBase
     {
-        internal sealed class FromYccKBasic : BasicJpegColorConverter
+        internal sealed class FromYccKScalar : JpegColorConverterScalar
         {
-            public FromYccKBasic(int precision)
+            public FromYccKScalar(int precision)
                 : base(JpegColorSpace.Ycck, precision)
             {
             }
@@ -25,9 +24,7 @@ namespace SixLabors.ImageSharp.Formats.Jpeg.Components.Decoder.ColorConverters
                 Span<float> c2 = values.Component2;
                 Span<float> c3 = values.Component3;
 
-                var v = new Vector4(0, 0, 0, 1F);
-
-                var scale = 1 / (maxValue * maxValue);
+                float scale = 1 / (maxValue * maxValue);
 
                 for (int i = 0; i < values.Component0.Length; i++)
                 {

src/ImageSharp/Formats/Jpeg/Components/Decoder/ColorConverters/JpegColorConverter.FromYccKVector8.cs → src/ImageSharp/Formats/Jpeg/Components/Decoder/ColorConverters/JpegColorConverter.FromYccKVector.cs

@@ -1,19 +1,17 @@
-// Copyright (c) Six Labors.
+// Copyright (c) Six Labors.
 // Licensed under the Apache License, Version 2.0.
 
-using System;
 using System.Numerics;
 using System.Runtime.CompilerServices;
 using System.Runtime.InteropServices;
-using SixLabors.ImageSharp.Tuples;
 
 namespace SixLabors.ImageSharp.Formats.Jpeg.Components.Decoder.ColorConverters
 {
-    internal abstract partial class JpegColorConverter
+    internal abstract partial class JpegColorConverterBase
     {
-        internal sealed class FromYccKVector8 : Vector8JpegColorConverter
+        internal sealed class FromYccKVector : JpegColorConverterVector
         {
-            public FromYccKVector8(int precision)
+            public FromYccKVector(int precision)
                 : base(JpegColorSpace.Ycck, precision)
             {
             }
@@ -30,13 +28,14 @@ namespace SixLabors.ImageSharp.Formats.Jpeg.Components.Decoder.ColorConverters
                     ref Unsafe.As<float, Vector<float>>(ref MemoryMarshal.GetReference(values.Component3));
 
                 var chromaOffset = new Vector<float>(-this.HalfValue);
-
-                // Walking 8 elements at one step:
-                nint n = values.Component0.Length / 8;
-
+                var scale = new Vector<float>(1 / (this.MaximumValue * this.MaximumValue));
                 var max = new Vector<float>(this.MaximumValue);
-                var scale = new Vector<float>(1f) / (max * max);
+                var rCrMult = new Vector<float>(FromYCbCrScalar.RCrMult);
+                var gCbMult = new Vector<float>(-FromYCbCrScalar.GCbMult);
+                var gCrMult = new Vector<float>(-FromYCbCrScalar.GCrMult);
+                var bCbMult = new Vector<float>(FromYCbCrScalar.BCbMult);
 
+                nint n = values.Component0.Length / Vector<float>.Count;
                 for (nint i = 0; i < n; i++)
                 {
                     // y = yVals[i];
@@ -55,10 +54,9 @@ namespace SixLabors.ImageSharp.Formats.Jpeg.Components.Decoder.ColorConverters
                     // r = y + (1.402F * cr);
                     // g = y - (0.344136F * cb) - (0.714136F * cr);
                     // b = y + (1.772F * cb);
-                    // Adding & multiplying 8 elements at one time:
-                    Vector<float> r = y + (cr * new Vector<float>(1.402F));
-                    Vector<float> g = y - (cb * new Vector<float>(0.344136F)) - (cr * new Vector<float>(0.714136F));
-                    Vector<float> b = y + (cb * new Vector<float>(1.772F));
+                    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;
@@ -71,7 +69,7 @@ namespace SixLabors.ImageSharp.Formats.Jpeg.Components.Decoder.ColorConverters
             }
 
             protected override void ConvertCoreInplace(in ComponentValues values) =>
-                FromYccKBasic.ConvertCoreInplace(values, this.MaximumValue, this.HalfValue);
+                FromYccKScalar.ConvertCoreInplace(values, this.MaximumValue, this.HalfValue);
         }
     }
 }

src/ImageSharp/Formats/Jpeg/Components/Decoder/ColorConverters/JpegColorConverter.Vector8JpegColorConverter.cs

@@ -1,18 +0,0 @@
-// Copyright (c) Six Labors.
-// Licensed under the Apache License, Version 2.0.
-
-namespace SixLabors.ImageSharp.Formats.Jpeg.Components.Decoder.ColorConverters
-{
-    internal abstract partial class JpegColorConverter
-    {
-        internal abstract class Vector8JpegColorConverter : VectorizedJpegColorConverter
-        {
-            protected Vector8JpegColorConverter(JpegColorSpace colorSpace, int precision)
-                : base(colorSpace, precision, 8)
-            {
-            }
-
-            protected sealed override bool IsAvailable => SimdUtils.HasVector8;
-        }
-    }
-}

src/ImageSharp/Formats/Jpeg/Components/Decoder/ColorConverters/JpegColorConverter.VectorizedJpegColorConverter.cs

@@ -1,47 +0,0 @@
-// Copyright (c) Six Labors.
-// Licensed under the Apache License, Version 2.0.
-
-using System;
-using System.Numerics;
-
-namespace SixLabors.ImageSharp.Formats.Jpeg.Components.Decoder.ColorConverters
-{
-    internal abstract partial class JpegColorConverter
-    {
-        internal abstract class VectorizedJpegColorConverter : JpegColorConverter
-        {
-            private readonly int vectorSize;
-
-            protected VectorizedJpegColorConverter(JpegColorSpace colorSpace, int precision, int vectorSize)
-                : base(colorSpace, precision)
-            {
-                this.vectorSize = vectorSize;
-            }
-
-            public override void ConvertToRgbInplace(in ComponentValues values)
-            {
-                int length = values.Component0.Length;
-                int remainder = values.Component0.Length % this.vectorSize;
-                int simdCount = length - remainder;
-                if (simdCount > 0)
-                {
-                    // This implementation is actually AVX specific.
-                    // An AVX register is capable of storing 8 float-s.
-                    if (!this.IsAvailable)
-                    {
-                        throw new InvalidOperationException(
-                            "This converter can be used only on architecture having 256 byte floating point SIMD registers!");
-                    }
-
-                    this.ConvertCoreVectorizedInplace(values.Slice(0, simdCount));
-                }
-
-                this.ConvertCoreInplace(values.Slice(simdCount, remainder));
-            }
-
-            protected virtual void ConvertCoreVectorizedInplace(in ComponentValues values) => throw new NotImplementedException();
-
-            protected virtual void ConvertCoreInplace(in ComponentValues values) => throw new NotImplementedException();
-        }
-    }
-}

src/ImageSharp/Formats/Jpeg/Components/Decoder/ColorConverters/JpegColorConverterAvx.cs

@@ -0,0 +1,32 @@
+// Copyright (c) Six Labors.
+// Licensed under the Apache License, Version 2.0.
+#if SUPPORTS_RUNTIME_INTRINSICS
+using System.Runtime.Intrinsics.X86;
+
+namespace SixLabors.ImageSharp.Formats.Jpeg.Components.Decoder.ColorConverters
+{
+    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 JpegColorConverterAvx : JpegColorConverterBase
+        {
+            protected JpegColorConverterAvx(JpegColorSpace colorSpace, int precision)
+                : base(colorSpace, precision)
+            {
+            }
+
+            public override bool IsAvailable => Avx.IsSupported;
+        }
+    }
+}
+#endif

src/ImageSharp/Formats/Jpeg/Components/Decoder/ColorConverters/JpegColorConverter.cs → src/ImageSharp/Formats/Jpeg/Components/Decoder/ColorConverters/JpegColorConverterBase.cs

@@ -4,26 +4,24 @@
 using System;
 using System.Collections.Generic;
 using System.Linq;
-using System.Numerics;
 using SixLabors.ImageSharp.Memory;
-using SixLabors.ImageSharp.Tuples;
 
 namespace SixLabors.ImageSharp.Formats.Jpeg.Components.Decoder.ColorConverters
 {
     /// <summary>
-    /// Encapsulates the conversion of Jpeg channels to RGBA values packed in <see cref="Vector4"/> buffer.
+    /// Encapsulates the conversion of color channels from jpeg image to RGB channels.
     /// </summary>
-    internal abstract partial class JpegColorConverter
+    internal abstract partial class JpegColorConverterBase
     {
         /// <summary>
         /// The available converters
         /// </summary>
-        private static readonly JpegColorConverter[] Converters = CreateConverters();
+        private static readonly JpegColorConverterBase[] Converters = CreateConverters();
 
         /// <summary>
-        /// Initializes a new instance of the <see cref="JpegColorConverter"/> class.
+        /// Initializes a new instance of the <see cref="JpegColorConverterBase"/> class.
         /// </summary>
-        protected JpegColorConverter(JpegColorSpace colorSpace, int precision)
+        protected JpegColorConverterBase(JpegColorSpace colorSpace, int precision)
         {
             this.ColorSpace = colorSpace;
             this.Precision = precision;
@@ -32,10 +30,10 @@ namespace SixLabors.ImageSharp.Formats.Jpeg.Components.Decoder.ColorConverters
         }
 
         /// <summary>
-        /// Gets a value indicating whether this <see cref="JpegColorConverter"/> is available
+        /// Gets a value indicating whether this <see cref="JpegColorConverterBase"/> is available
         /// on the current runtime and CPU architecture.
         /// </summary>
-        protected abstract bool IsAvailable { get; }
+        public abstract bool IsAvailable { get; }
 
         /// <summary>
         /// Gets the <see cref="JpegColorSpace"/> of this converter.
@@ -58,11 +56,11 @@ namespace SixLabors.ImageSharp.Formats.Jpeg.Components.Decoder.ColorConverters
         private float HalfValue { get; }
 
         /// <summary>
-        /// Returns the <see cref="JpegColorConverter"/> corresponding to the given <see cref="JpegColorSpace"/>
+        /// Returns the <see cref="JpegColorConverterBase"/> corresponding to the given <see cref="JpegColorSpace"/>
         /// </summary>
-        public static JpegColorConverter GetConverter(JpegColorSpace colorSpace, int precision)
+        public static JpegColorConverterBase GetConverter(JpegColorSpace colorSpace, int precision)
         {
-            JpegColorConverter converter = Array.Find(
+            JpegColorConverterBase converter = Array.Find(
                 Converters,
                 c => c.ColorSpace == colorSpace
                 && c.Precision == precision);
@@ -82,11 +80,11 @@ namespace SixLabors.ImageSharp.Formats.Jpeg.Components.Decoder.ColorConverters
         public abstract void ConvertToRgbInplace(in ComponentValues values);
 
         /// <summary>
-        /// Returns the <see cref="JpegColorConverter"/>s for all supported colorspaces and precisions.
+        /// Returns the <see cref="JpegColorConverterBase"/>s for all supported colorspaces and precisions.
         /// </summary>
-        private static JpegColorConverter[] CreateConverters()
+        private static JpegColorConverterBase[] CreateConverters()
         {
-            var converters = new List<JpegColorConverter>();
+            var converters = new List<JpegColorConverterBase>();
 
             // 8-bit converters
             converters.AddRange(GetYCbCrConverters(8));
@@ -106,63 +104,63 @@ namespace SixLabors.ImageSharp.Formats.Jpeg.Components.Decoder.ColorConverters
         }
 
         /// <summary>
-        /// Returns the <see cref="JpegColorConverter"/>s for the YCbCr colorspace.
+        /// Returns the <see cref="JpegColorConverterBase"/>s for the YCbCr colorspace.
         /// </summary>
-        private static IEnumerable<JpegColorConverter> GetYCbCrConverters(int precision)
+        private static IEnumerable<JpegColorConverterBase> GetYCbCrConverters(int precision)
         {
 #if SUPPORTS_RUNTIME_INTRINSICS
-            yield return new FromYCbCrAvx2(precision);
+            yield return new FromYCbCrAvx(precision);
 #endif
-            yield return new FromYCbCrVector8(precision);
-            yield return new FromYCbCrVector4(precision);
-            yield return new FromYCbCrBasic(precision);
+            yield return new FromYCbCrVector(precision);
+            yield return new FromYCbCrScalar(precision);
         }
 
         /// <summary>
-        /// Returns the <see cref="JpegColorConverter"/>s for the YccK colorspace.
+        /// Returns the <see cref="JpegColorConverterBase"/>s for the YccK colorspace.
         /// </summary>
-        private static IEnumerable<JpegColorConverter> GetYccKConverters(int precision)
+        private static IEnumerable<JpegColorConverterBase> GetYccKConverters(int precision)
         {
 #if SUPPORTS_RUNTIME_INTRINSICS
-            yield return new FromYccKAvx2(precision);
+            yield return new FromYccKAvx(precision);
 #endif
-            yield return new FromYccKVector8(precision);
-            yield return new FromYccKBasic(precision);
+            yield return new FromYccKVector(precision);
+            yield return new FromYccKScalar(precision);
         }
 
         /// <summary>
-        /// Returns the <see cref="JpegColorConverter"/>s for the CMYK colorspace.
+        /// Returns the <see cref="JpegColorConverterBase"/>s for the CMYK colorspace.
         /// </summary>
-        private static IEnumerable<JpegColorConverter> GetCmykConverters(int precision)
+        private static IEnumerable<JpegColorConverterBase> GetCmykConverters(int precision)
         {
 #if SUPPORTS_RUNTIME_INTRINSICS
-            yield return new FromCmykAvx2(precision);
+            yield return new FromCmykAvx(precision);
 #endif
-            yield return new FromCmykVector8(precision);
-            yield return new FromCmykBasic(precision);
+            yield return new FromCmykVector(precision);
+            yield return new FromCmykScalar(precision);
         }
 
         /// <summary>
-        /// Returns the <see cref="JpegColorConverter"/>s for the gray scale colorspace.
+        /// Returns the <see cref="JpegColorConverterBase"/>s for the gray scale colorspace.
         /// </summary>
-        private static IEnumerable<JpegColorConverter> GetGrayScaleConverters(int precision)
+        private static IEnumerable<JpegColorConverterBase> GetGrayScaleConverters(int precision)
         {
 #if SUPPORTS_RUNTIME_INTRINSICS
-            yield return new FromGrayscaleAvx2(precision);
+            yield return new FromGrayscaleAvx(precision);
 #endif
-            yield return new FromGrayscaleBasic(precision);
+            yield return new FromGrayScaleVector(precision);
+            yield return new FromGrayscaleScalar(precision);
         }
 
         /// <summary>
-        /// Returns the <see cref="JpegColorConverter"/>s for the RGB colorspace.
+        /// Returns the <see cref="JpegColorConverterBase"/>s for the RGB colorspace.
         /// </summary>
-        private static IEnumerable<JpegColorConverter> GetRgbConverters(int precision)
+        private static IEnumerable<JpegColorConverterBase> GetRgbConverters(int precision)
         {
 #if SUPPORTS_RUNTIME_INTRINSICS
-            yield return new FromRgbAvx2(precision);
+            yield return new FromRgbAvx(precision);
 #endif
-            yield return new FromRgbVector8(precision);
-            yield return new FromRgbBasic(precision);
+            yield return new FromRgbVector(precision);
+            yield return new FromRgbScalar(precision);
         }
 
         /// <summary>
@@ -200,18 +198,39 @@ namespace SixLabors.ImageSharp.Formats.Jpeg.Components.Decoder.ColorConverters
             /// <summary>
             /// Initializes a new instance of the <see cref="ComponentValues"/> struct.
             /// </summary>
-            /// <param name="componentBuffers">The 1-4 sized list of component buffers.</param>
-            /// <param name="row">The row to convert</param>
+            /// <param name="componentBuffers">List of component buffers.</param>
+            /// <param name="row">Row to convert</param>
             public ComponentValues(IReadOnlyList<Buffer2D<float>> componentBuffers, int row)
             {
+                DebugGuard.MustBeGreaterThan(componentBuffers.Count, 0, nameof(componentBuffers));
+
                 this.ComponentCount = componentBuffers.Count;
 
-                this.Component0 = componentBuffers[0].GetRowSpan(row);
+                this.Component0 = componentBuffers[0].DangerousGetRowSpan(row);
+
+                // 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;
+            }
+
+            /// <summary>
+            /// Initializes a new instance of the <see cref="ComponentValues"/> struct.
+            /// </summary>
+            /// <param name="processors">List of component color processors.</param>
+            /// <param name="row">Row to convert</param>
+            public ComponentValues(IReadOnlyList<JpegComponentPostProcessor> processors, int row)
+            {
+                DebugGuard.MustBeGreaterThan(processors.Count, 0, nameof(processors));
+
+                this.ComponentCount = processors.Count;
+
+                this.Component0 = processors[0].GetColorBufferRowSpan(row);
 
                 // In case of grayscale, Component1 and Component2 point to Component0 memory area
-                this.Component1 = this.ComponentCount > 1 ? componentBuffers[1].GetRowSpan(row) : this.Component0;
-                this.Component2 = this.ComponentCount > 2 ? componentBuffers[2].GetRowSpan(row) : this.Component0;
-                this.Component3 = this.ComponentCount > 3 ? componentBuffers[3].GetRowSpan(row) : Span<float>.Empty;
+                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;
             }
 
             internal ComponentValues(

src/ImageSharp/Formats/Jpeg/Components/Decoder/ColorConverters/JpegColorConverterScalar.cs

@@ -0,0 +1,22 @@
+// Copyright (c) Six Labors.
+// Licensed under the Apache License, Version 2.0.
+
+namespace SixLabors.ImageSharp.Formats.Jpeg.Components.Decoder.ColorConverters
+{
+    internal abstract partial class JpegColorConverterBase
+    {
+        /// <summary>
+        /// <see cref="JpegColorConverterBase"/> abstract base for implementations
+        /// based on scalar instructions.
+        /// </summary>
+        internal abstract class JpegColorConverterScalar : JpegColorConverterBase
+        {
+            protected JpegColorConverterScalar(JpegColorSpace colorSpace, int precision)
+                : base(colorSpace, precision)
+            {
+            }
+
+            public override bool IsAvailable => true;
+        }
+    }
+}

src/ImageSharp/Formats/Jpeg/Components/Decoder/ColorConverters/JpegColorConverterVector.cs

@@ -0,0 +1,59 @@
+// Copyright (c) Six Labors.
+// Licensed under the Apache License, Version 2.0.
+
+using System;
+using System.Numerics;
+
+namespace SixLabors.ImageSharp.Formats.Jpeg.Components.Decoder.ColorConverters
+{
+    internal abstract partial class JpegColorConverterBase
+    {
+        /// <summary>
+        /// <see cref="JpegColorConverterBase"/> abstract base for implementations
+        /// based on <see cref="Vector"/> API.
+        /// </summary>
+        /// <remarks>
+        /// Converters of this family can work with data of any size.
+        /// Even though real life data is guaranteed to be of size
+        /// divisible by 8 newer SIMD instructions like AVX512 won't work with
+        /// such data out of the box. These converters have fallback code
+        /// for 'remainder' data.
+        /// </remarks>
+        internal abstract class JpegColorConverterVector : JpegColorConverterBase
+        {
+            protected JpegColorConverterVector(JpegColorSpace colorSpace, int precision)
+                : base(colorSpace, precision)
+            {
+            }
+
+            public sealed override bool IsAvailable => Vector.IsHardwareAccelerated && Vector<float>.Count % 4 == 0;
+
+            public 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)Vector<float>.Count);
+
+                // Jpeg images are guaranteed to have pixel strides at least 8 pixels wide
+                // Thus there's no need to check whether simdCount is greater than zero
+                int simdCount = length - remainder;
+                this.ConvertCoreVectorizedInplace(values.Slice(0, simdCount));
+
+                // Jpeg images width is always divisible by 8 without a remainder
+                // so it's safe to say SSE/AVX implementations would never have
+                // 'remainder' pixels
+                // But some exotic simd implementations e.g. AVX-512 can have
+                // remainder pixels
+                if (remainder > 0)
+                {
+                    this.ConvertCoreInplace(values.Slice(simdCount, remainder));
+                }
+            }
+
+            protected virtual void ConvertCoreVectorizedInplace(in ComponentValues values) => throw new NotImplementedException();
+
+            protected virtual void ConvertCoreInplace(in ComponentValues values) => throw new NotImplementedException();
+        }
+    }
+}

src/ImageSharp/Formats/Jpeg/Components/Decoder/HuffmanScanDecoder.cs

@@ -151,6 +151,7 @@ namespace SixLabors.ImageSharp.Formats.Jpeg.Components.Decoder
             if (this.componentsCount == this.frame.ComponentCount)
             {
                 this.ParseBaselineDataInterleaved();
+                this.spectralConverter.CommitConversion();
             }
             else
             {
@@ -166,18 +167,6 @@ namespace SixLabors.ImageSharp.Formats.Jpeg.Components.Decoder
             int mcusPerLine = this.frame.McusPerLine;
             ref HuffmanScanBuffer buffer = ref this.scanBuffer;
 
-            // Pre-derive the huffman table to avoid in-loop checks.
-            for (int i = 0; i < this.componentsCount; i++)
-            {
-                int order = this.frame.ComponentOrder[i];
-                JpegComponent component = this.components[order];
-
-                ref HuffmanTable dcHuffmanTable = ref this.dcHuffmanTables[component.DCHuffmanTableId];
-                ref HuffmanTable acHuffmanTable = ref this.acHuffmanTables[component.ACHuffmanTableId];
-                dcHuffmanTable.Configure();
-                acHuffmanTable.Configure();
-            }
-
             for (int j = 0; j < mcusPerColumn; j++)
             {
                 this.cancellationToken.ThrowIfCancellationRequested();
@@ -202,7 +191,7 @@ namespace SixLabors.ImageSharp.Formats.Jpeg.Components.Decoder
                         // by the basic H and V specified for the component
                         for (int y = 0; y < v; y++)
                         {
-                            Span<Block8x8> blockSpan = component.SpectralBlocks.GetRowSpan(y);
+                            Span<Block8x8> blockSpan = component.SpectralBlocks.DangerousGetRowSpan(y);
                             ref Block8x8 blockRef = ref MemoryMarshal.GetReference(blockSpan);
 
                             for (int x = 0; x < h; x++)
@@ -247,13 +236,11 @@ namespace SixLabors.ImageSharp.Formats.Jpeg.Components.Decoder
 
             ref HuffmanTable dcHuffmanTable = ref this.dcHuffmanTables[component.DCHuffmanTableId];
             ref HuffmanTable acHuffmanTable = ref this.acHuffmanTables[component.ACHuffmanTableId];
-            dcHuffmanTable.Configure();
-            acHuffmanTable.Configure();
 
             for (int j = 0; j < h; j++)
             {
                 this.cancellationToken.ThrowIfCancellationRequested();
-                Span<Block8x8> blockSpan = component.SpectralBlocks.GetRowSpan(j);
+                Span<Block8x8> blockSpan = component.SpectralBlocks.DangerousGetRowSpan(j);
                 ref Block8x8 blockRef = ref MemoryMarshal.GetReference(blockSpan);
 
                 for (int i = 0; i < w; i++)
@@ -346,15 +333,6 @@ namespace SixLabors.ImageSharp.Formats.Jpeg.Components.Decoder
             int mcusPerLine = this.frame.McusPerLine;
             ref HuffmanScanBuffer buffer = ref this.scanBuffer;
 
-            // Pre-derive the huffman table to avoid in-loop checks.
-            for (int k = 0; k < this.componentsCount; k++)
-            {
-                int order = this.frame.ComponentOrder[k];
-                JpegComponent component = this.components[order];
-                ref HuffmanTable dcHuffmanTable = ref this.dcHuffmanTables[component.DCHuffmanTableId];
-                dcHuffmanTable.Configure();
-            }
-
             for (int j = 0; j < mcusPerColumn; j++)
             {
                 for (int i = 0; i < mcusPerLine; i++)
@@ -376,7 +354,7 @@ namespace SixLabors.ImageSharp.Formats.Jpeg.Components.Decoder
                         for (int y = 0; y < v; y++)
                         {
                             int blockRow = (mcuRow * v) + y;
-                            Span<Block8x8> blockSpan = component.SpectralBlocks.GetRowSpan(blockRow);
+                            Span<Block8x8> blockSpan = component.SpectralBlocks.DangerousGetRowSpan(blockRow);
                             ref Block8x8 blockRef = ref MemoryMarshal.GetReference(blockSpan);
 
                             for (int x = 0; x < h; x++)
@@ -415,13 +393,12 @@ namespace SixLabors.ImageSharp.Formats.Jpeg.Components.Decoder
             if (this.SpectralStart == 0)
             {
                 ref HuffmanTable dcHuffmanTable = ref this.dcHuffmanTables[component.DCHuffmanTableId];
-                dcHuffmanTable.Configure();
 
                 for (int j = 0; j < h; j++)
                 {
                     this.cancellationToken.ThrowIfCancellationRequested();
 
-                    Span<Block8x8> blockSpan = component.SpectralBlocks.GetRowSpan(j);
+                    Span<Block8x8> blockSpan = component.SpectralBlocks.DangerousGetRowSpan(j);
                     ref Block8x8 blockRef = ref MemoryMarshal.GetReference(blockSpan);
 
                     for (int i = 0; i < w; i++)
@@ -443,13 +420,12 @@ namespace SixLabors.ImageSharp.Formats.Jpeg.Components.Decoder
             else
             {
                 ref HuffmanTable acHuffmanTable = ref this.acHuffmanTables[component.ACHuffmanTableId];
-                acHuffmanTable.Configure();
 
                 for (int j = 0; j < h; j++)
                 {
                     this.cancellationToken.ThrowIfCancellationRequested();
 
-                    Span<Block8x8> blockSpan = component.SpectralBlocks.GetRowSpan(j);
+                    Span<Block8x8> blockSpan = component.SpectralBlocks.DangerousGetRowSpan(j);
                     ref Block8x8 blockRef = ref MemoryMarshal.GetReference(blockSpan);
 
                     for (int i = 0; i < w; i++)
@@ -501,7 +477,7 @@ namespace SixLabors.ImageSharp.Formats.Jpeg.Components.Decoder
                 {
                     i += r;
                     s = buffer.Receive(s);
-                    Unsafe.Add(ref blockDataRef, ZigZag.ZigZagOrder[i++]) = (short)s;
+                    Unsafe.Add(ref blockDataRef, ZigZag.TransposingOrder[i++]) = (short)s;
                 }
                 else
                 {
@@ -570,7 +546,7 @@ namespace SixLabors.ImageSharp.Formats.Jpeg.Components.Decoder
                     if (s != 0)
                     {
                         s = buffer.Receive(s);
-                        Unsafe.Add(ref blockDataRef, ZigZag.ZigZagOrder[i]) = (short)(s << low);
+                        Unsafe.Add(ref blockDataRef, ZigZag.TransposingOrder[i]) = (short)(s << low);
                     }
                     else
                     {
@@ -646,7 +622,7 @@ namespace SixLabors.ImageSharp.Formats.Jpeg.Components.Decoder
 
                     do
                     {
-                        ref short coef = ref Unsafe.Add(ref blockDataRef, ZigZag.ZigZagOrder[k]);
+                        ref short coef = ref Unsafe.Add(ref blockDataRef, ZigZag.TransposingOrder[k]);
                         if (coef != 0)
                         {
                             buffer.CheckBits();
@@ -672,7 +648,7 @@ namespace SixLabors.ImageSharp.Formats.Jpeg.Components.Decoder
 
                     if ((s != 0) && (k < 64))
                     {
-                        Unsafe.Add(ref blockDataRef, ZigZag.ZigZagOrder[k]) = (short)s;
+                        Unsafe.Add(ref blockDataRef, ZigZag.TransposingOrder[k]) = (short)s;
                     }
                 }
             }
@@ -681,7 +657,7 @@ namespace SixLabors.ImageSharp.Formats.Jpeg.Components.Decoder
             {
                 for (; k <= end; k++)
                 {
-                    ref short coef = ref Unsafe.Add(ref blockDataRef, ZigZag.ZigZagOrder[k]);
+                    ref short coef = ref Unsafe.Add(ref blockDataRef, ZigZag.TransposingOrder[k]);
 
                     if (coef != 0)
                     {
@@ -751,11 +727,12 @@ namespace SixLabors.ImageSharp.Formats.Jpeg.Components.Decoder
         /// <param name="index">Table index.</param>
         /// <param name="codeLengths">Code lengths.</param>
         /// <param name="values">Code values.</param>
+        /// <param name="workspace">The provided spare workspace memory, can be dirty.</param>
         [MethodImpl(InliningOptions.ShortMethod)]
-        public void BuildHuffmanTable(int type, int index, ReadOnlySpan<byte> codeLengths, ReadOnlySpan<byte> values)
+        public void BuildHuffmanTable(int type, int index, ReadOnlySpan<byte> codeLengths, ReadOnlySpan<byte> values, Span<uint> workspace)
         {
             HuffmanTable[] tables = type == 0 ? this.dcHuffmanTables : this.acHuffmanTables;
-            tables[index] = new HuffmanTable(codeLengths, values);
+            tables[index] = new HuffmanTable(codeLengths, values, workspace);
         }
     }
 }

src/ImageSharp/Formats/Jpeg/Components/Decoder/HuffmanTable.cs

@@ -13,12 +13,10 @@ namespace SixLabors.ImageSharp.Formats.Jpeg.Components.Decoder
     [StructLayout(LayoutKind.Sequential)]
     internal unsafe struct HuffmanTable
     {
-        private bool isConfigured;
-
         /// <summary>
-        /// Derived from the DHT marker. Sizes[k] = # of symbols with codes of length k bits; Sizes[0] is unused.
+        /// Memory workspace buffer size used in <see cref="HuffmanTable"/> ctor.
         /// </summary>
-        public fixed byte Sizes[17];
+        public const int WorkspaceByteSize = 256 * sizeof(uint);
 
         /// <summary>
         /// Derived from the DHT marker. Contains the symbols, in order of incremental code length.
@@ -58,51 +56,35 @@ namespace SixLabors.ImageSharp.Formats.Jpeg.Components.Decoder
         /// <summary>
         /// Initializes a new instance of the <see cref="HuffmanTable"/> struct.
         /// </summary>
-        /// <param name="codeLengths">The code lengths</param>
-        /// <param name="values">The huffman values</param>
-        public HuffmanTable(ReadOnlySpan<byte> codeLengths, ReadOnlySpan<byte> values)
+        /// <param name="codeLengths">The code lengths.</param>
+        /// <param name="values">The huffman values.</param>
+        /// <param name="workspace">The provided spare workspace memory, can be dirty.</param>
+        public HuffmanTable(ReadOnlySpan<byte> codeLengths, ReadOnlySpan<byte> values, Span<uint> workspace)
         {
-            this.isConfigured = false;
-            Unsafe.CopyBlockUnaligned(ref this.Sizes[0], ref MemoryMarshal.GetReference(codeLengths), (uint)codeLengths.Length);
             Unsafe.CopyBlockUnaligned(ref this.Values[0], ref MemoryMarshal.GetReference(values), (uint)values.Length);
-        }
-
-        /// <summary>
-        /// Expands the HuffmanTable into its readable form.
-        /// </summary>
-        public void Configure()
-        {
-            if (this.isConfigured)
-            {
-                return;
-            }
 
-            Span<char> huffSize = stackalloc char[257];
-            Span<uint> huffCode = stackalloc uint[257];
-
-            // Figure C.1: make table of Huffman code length for each symbol
+            // Generate codes
+            uint code = 0;
+            int si = 1;
             int p = 0;
-            for (int j = 1; j <= 16; j++)
+            for (int i = 1; i <= 16; i++)
             {
-                int i = this.Sizes[j];
-                while (i-- != 0)
+                int count = codeLengths[i];
+                for (int j = 0; j < count; j++)
                 {
-                    huffSize[p++] = (char)j;
+                    workspace[p++] = code;
+                    code++;
                 }
-            }
 
-            huffSize[p] = (char)0;
-
-            // Figure C.2: generate the codes themselves
-            uint code = 0;
-            int si = huffSize[0];
-            p = 0;
-            while (huffSize[p] != 0)
-            {
-                while (huffSize[p] == si)
+                // 'code' is now 1 more than the last code used for codelength 'si'
+                // in the valid worst possible case 'code' would have the least
+                // significant bit set to 1, e.g. 1111(0) +1 => 1111(1)
+                // but it must still fit in 'si' bits since no huffman code can be equal to all 1s
+                // if last code is all ones, e.g. 1111(1), then incrementing it by 1 would yield
+                // a new code which occupies one extra bit, e.g. 1111(1) +1 => (1)1111(0)
+                if (code >= (1 << si))
                 {
-                    huffCode[p++] = code;
-                    code++;
+                    JpegThrowHelper.ThrowInvalidImageContentException("Bad huffman table.");
                 }
 
                 code <<= 1;
@@ -113,11 +95,11 @@ namespace SixLabors.ImageSharp.Formats.Jpeg.Components.Decoder
             p = 0;
             for (int j = 1; j <= 16; j++)
             {
-                if (this.Sizes[j] != 0)
+                if (codeLengths[j] != 0)
                 {
-                    this.ValOffset[j] = p - (int)huffCode[p];
-                    p += this.Sizes[j];
-                    this.MaxCode[j] = huffCode[p - 1]; // Maximum code of length l
+                    this.ValOffset[j] = p - (int)workspace[p];
+                    p += codeLengths[j];
+                    this.MaxCode[j] = workspace[p - 1]; // Maximum code of length l
                     this.MaxCode[j] <<= JpegConstants.Huffman.RegisterSize - j; // Left justify
                     this.MaxCode[j] |= (1ul << (JpegConstants.Huffman.RegisterSize - j)) - 1;
                 }
@@ -142,11 +124,11 @@ namespace SixLabors.ImageSharp.Formats.Jpeg.Components.Decoder
             for (int length = 1; length <= JpegConstants.Huffman.LookupBits; length++)
             {
                 int jShift = JpegConstants.Huffman.LookupBits - length;
-                for (int i = 1; i <= this.Sizes[length]; i++, p++)
+                for (int i = 1; i <= codeLengths[length]; i++, p++)
                 {
                     // length = current code's length, p = its index in huffCode[] & Values[].
                     // Generate left-justified code followed by all possible bit sequences
-                    int lookBits = (int)(huffCode[p] << jShift);
+                    int lookBits = (int)(workspace[p] << jShift);
                     for (int ctr = 1 << (JpegConstants.Huffman.LookupBits - length); ctr > 0; ctr--)
                     {
                         this.LookaheadSize[lookBits] = (byte)length;
@@ -155,8 +137,6 @@ namespace SixLabors.ImageSharp.Formats.Jpeg.Components.Decoder
                     }
                 }
             }
-
-            this.isConfigured = true;
         }
     }
 }

src/ImageSharp/Formats/Jpeg/Components/Decoder/IRawJpegData.cs

@@ -5,7 +5,6 @@ using System;
 
 namespace SixLabors.ImageSharp.Formats.Jpeg.Components.Decoder
 {
-    /// <inheritdoc />
     /// <summary>
     /// Represents decompressed, unprocessed jpeg data with spectral space <see cref="IJpegComponent" />-s.
     /// </summary>

src/ImageSharp/Formats/Jpeg/Components/Decoder/JFifMarker.cs

@@ -1,4 +1,4 @@
-// Copyright (c) Six Labors.
+// Copyright (c) Six Labors.
 // Licensed under the Apache License, Version 2.0.
 
 using System;
@@ -103,26 +103,22 @@ namespace SixLabors.ImageSharp.Formats.Jpeg.Components.Decoder
 
         /// <inheritdoc/>
         public bool Equals(JFifMarker other)
-        {
-            return this.MajorVersion == other.MajorVersion
+            => this.MajorVersion == other.MajorVersion
                 && this.MinorVersion == other.MinorVersion
                 && this.DensityUnits == other.DensityUnits
                 && this.XDensity == other.XDensity
                 && this.YDensity == other.YDensity;
-        }
 
         /// <inheritdoc/>
         public override bool Equals(object obj) => obj is JFifMarker other && this.Equals(other);
 
         /// <inheritdoc/>
         public override int GetHashCode()
-        {
-            return HashCode.Combine(
+            => HashCode.Combine(
                 this.MajorVersion,
                 this.MinorVersion,
                 this.DensityUnits,
                 this.XDensity,
                 this.YDensity);
-        }
     }
 }

src/ImageSharp/Formats/Jpeg/Components/Decoder/JpegBlockPostProcessor.cs

@@ -1,88 +0,0 @@
-// Copyright (c) Six Labors.
-// Licensed under the Apache License, Version 2.0.
-
-using System;
-using System.Runtime.InteropServices;
-using SixLabors.ImageSharp.Memory;
-
-namespace SixLabors.ImageSharp.Formats.Jpeg.Components.Decoder
-{
-    /// <summary>
-    /// Encapsulates the implementation of processing "raw" jpeg buffers into Jpeg image channels.
-    /// </summary>
-    [StructLayout(LayoutKind.Sequential)]
-    internal struct JpegBlockPostProcessor
-    {
-        /// <summary>
-        /// Source block
-        /// </summary>
-        public Block8x8F SourceBlock;
-
-        /// <summary>
-        /// Temporal block to store intermediate computation results.
-        /// </summary>
-        public Block8x8F WorkspaceBlock;
-
-        /// <summary>
-        /// The quantization table as <see cref="Block8x8F"/>.
-        /// </summary>
-        public Block8x8F DequantiazationTable;
-
-        /// <summary>
-        /// Defines the horizontal and vertical scale we need to apply to the 8x8 sized block.
-        /// </summary>
-        private Size subSamplingDivisors;
-
-        /// <summary>
-        /// Initializes a new instance of the <see cref="JpegBlockPostProcessor"/> struct.
-        /// </summary>
-        /// <param name="decoder">The raw jpeg data.</param>
-        /// <param name="component">The raw component.</param>
-        public JpegBlockPostProcessor(IRawJpegData decoder, IJpegComponent component)
-        {
-            int qtIndex = component.QuantizationTableIndex;
-            this.DequantiazationTable = decoder.QuantizationTables[qtIndex];
-            this.subSamplingDivisors = component.SubSamplingDivisors;
-
-            this.SourceBlock = default;
-            this.WorkspaceBlock = default;
-        }
-
-        /// <summary>
-        /// Processes 'sourceBlock' producing Jpeg color channel values from spectral values:
-        /// - Dequantize
-        /// - Applying IDCT
-        /// - Level shift by +maximumValue/2, clip to [0, maximumValue]
-        /// - Copy the resulting color values into 'destArea' scaling up the block by amount defined in <see cref="subSamplingDivisors"/>.
-        /// </summary>
-        /// <param name="sourceBlock">The source block.</param>
-        /// <param name="destAreaOrigin">Reference to the origin of the destination pixel area.</param>
-        /// <param name="destAreaStride">The width of the destination pixel buffer.</param>
-        /// <param name="maximumValue">The maximum value derived from the bitdepth.</param>
-        public void ProcessBlockColorsInto(
-            ref Block8x8 sourceBlock,
-            ref float destAreaOrigin,
-            int destAreaStride,
-            float maximumValue)
-        {
-            ref Block8x8F block = ref this.SourceBlock;
-            block.LoadFrom(ref sourceBlock);
-
-            // Dequantize:
-            block.MultiplyInPlace(ref this.DequantiazationTable);
-
-            FastFloatingPointDCT.TransformIDCT(ref block, ref this.WorkspaceBlock);
-
-            // To conform better to libjpeg we actually NEED TO loose precision here.
-            // This is because they store blocks as Int16 between all the operations.
-            // To be "more accurate", we need to emulate this by rounding!
-            block.NormalizeColorsAndRoundInPlace(maximumValue);
-
-            block.ScaledCopyTo(
-                ref destAreaOrigin,
-                destAreaStride,
-                this.subSamplingDivisors.Width,
-                this.subSamplingDivisors.Height);
-        }
-    }
-}

src/ImageSharp/Formats/Jpeg/Components/Decoder/JpegColorSpace.cs

@@ -10,14 +10,29 @@ namespace SixLabors.ImageSharp.Formats.Jpeg.Components.Decoder
     {
         Undefined = 0,
 
+        /// <summary>
+        /// Color space with 1 component.
+        /// </summary>
         Grayscale,
 
+        /// <summary>
+        /// Color space with 4 components.
+        /// </summary>
         Ycck,
 
+        /// <summary>
+        /// Color space with 4 components.
+        /// </summary>
         Cmyk,
 
+        /// <summary>
+        /// Color space with 3 components.
+        /// </summary>
         RGB,
 
+        /// <summary>
+        /// Color space with 3 components.
+        /// </summary>
         YCbCr
     }
 }

src/ImageSharp/Formats/Jpeg/Components/Decoder/JpegComponent.cs

@@ -19,21 +19,10 @@ namespace SixLabors.ImageSharp.Formats.Jpeg.Components.Decoder
             this.Frame = frame;
             this.Id = id;
 
-            // Validate sampling factors.
-            if (horizontalFactor == 0 || verticalFactor == 0)
-            {
-                JpegThrowHelper.ThrowBadSampling();
-            }
-
             this.HorizontalSamplingFactor = horizontalFactor;
             this.VerticalSamplingFactor = verticalFactor;
             this.SamplingFactors = new Size(this.HorizontalSamplingFactor, this.VerticalSamplingFactor);
 
-            if (quantizationTableIndex > 3)
-            {
-                JpegThrowHelper.ThrowBadQuantizationTableIndex(quantizationTableIndex);
-            }
-
             this.QuantizationTableIndex = quantizationTableIndex;
             this.Index = index;
         }

src/ImageSharp/Formats/Jpeg/Components/Decoder/JpegComponentPostProcessor.cs

@@ -11,11 +11,6 @@ namespace SixLabors.ImageSharp.Formats.Jpeg.Components.Decoder
     /// </summary>
     internal class JpegComponentPostProcessor : IDisposable
     {
-        /// <summary>
-        /// Points to the current row in <see cref="Component"/>.
-        /// </summary>
-        private int currentComponentRowInBlocks;
-
         /// <summary>
         /// The size of the area in <see cref="ColorBuffer"/> corresponding to one 8x8 Jpeg block
         /// </summary>
@@ -26,6 +21,21 @@ namespace SixLabors.ImageSharp.Formats.Jpeg.Components.Decoder
         /// </summary>
         private readonly JpegFrame frame;
 
+        /// <summary>
+        /// Gets the maximal number of block rows being processed in one step.
+        /// </summary>
+        private readonly int blockRowsPerStep;
+
+        /// <summary>
+        /// Gets the <see cref="IJpegComponent"/> component containing decoding meta information.
+        /// </summary>
+        private readonly IJpegComponent component;
+
+        /// <summary>
+        /// Gets the <see cref="IRawJpegData"/> instance containing decoding meta information.
+        /// </summary>
+        private readonly IRawJpegData rawJpeg;
+
         /// <summary>
         /// Initializes a new instance of the <see cref="JpegComponentPostProcessor"/> class.
         /// </summary>
@@ -33,98 +43,87 @@ namespace SixLabors.ImageSharp.Formats.Jpeg.Components.Decoder
         {
             this.frame = frame;
 
-            this.Component = component;
-            this.RawJpeg = rawJpeg;
-            this.blockAreaSize = this.Component.SubSamplingDivisors * 8;
+            this.component = component;
+            this.rawJpeg = rawJpeg;
+            this.blockAreaSize = this.component.SubSamplingDivisors * 8;
             this.ColorBuffer = memoryAllocator.Allocate2DOveraligned<float>(
                 postProcessorBufferSize.Width,
                 postProcessorBufferSize.Height,
                 this.blockAreaSize.Height);
 
-            this.BlockRowsPerStep = postProcessorBufferSize.Height / 8 / this.Component.SubSamplingDivisors.Height;
+            this.blockRowsPerStep = postProcessorBufferSize.Height / 8 / this.component.SubSamplingDivisors.Height;
         }
 
-        public IRawJpegData RawJpeg { get; }
-
-        /// <summary>
-        /// Gets the <see cref="Component"/>
-        /// </summary>
-        public IJpegComponent Component { get; }
-
         /// <summary>
         /// Gets the temporary working buffer of color values.
         /// </summary>
         public Buffer2D<float> ColorBuffer { get; }
 
-        /// <summary>
-        /// Gets <see cref="IJpegComponent.SizeInBlocks"/>
-        /// </summary>
-        public Size SizeInBlocks => this.Component.SizeInBlocks;
-
-        /// <summary>
-        /// Gets the maximal number of block rows being processed in one step.
-        /// </summary>
-        public int BlockRowsPerStep { get; }
-
         /// <inheritdoc />
         public void Dispose() => this.ColorBuffer.Dispose();
 
         /// <summary>
-        /// Invoke <see cref="JpegBlockPostProcessor"/> for <see cref="BlockRowsPerStep"/> block rows, copy the result into <see cref="ColorBuffer"/>.
+        /// Convert raw spectral DCT data to color data and copy it to the color buffer <see cref="ColorBuffer"/>.
         /// </summary>
-        public void CopyBlocksToColorBuffer(int step)
+        public void CopyBlocksToColorBuffer(int spectralStep)
         {
-            Buffer2D<Block8x8> spectralBuffer = this.Component.SpectralBlocks;
-
-            var blockPp = new JpegBlockPostProcessor(this.RawJpeg, this.Component);
+            Buffer2D<Block8x8> spectralBuffer = this.component.SpectralBlocks;
 
             float maximumValue = this.frame.MaxColorChannelValue;
 
             int destAreaStride = this.ColorBuffer.Width;
 
-            int yBlockStart = step * this.BlockRowsPerStep;
+            int yBlockStart = spectralStep * this.blockRowsPerStep;
 
-            for (int y = 0; y < this.BlockRowsPerStep; y++)
-            {
-                int yBlock = yBlockStart + y;
+            Size subSamplingDivisors = this.component.SubSamplingDivisors;
 
-                if (yBlock >= spectralBuffer.Height)
-                {
-                    break;
-                }
+            Block8x8F dequantTable = this.rawJpeg.QuantizationTables[this.component.QuantizationTableIndex];
+            Block8x8F workspaceBlock = default;
 
+            for (int y = 0; y < this.blockRowsPerStep; y++)
+            {
                 int yBuffer = y * this.blockAreaSize.Height;
 
-                Span<float> colorBufferRow = this.ColorBuffer.GetRowSpan(yBuffer);
-                Span<Block8x8> blockRow = spectralBuffer.GetRowSpan(yBlock);
+                Span<float> colorBufferRow = this.ColorBuffer.DangerousGetRowSpan(yBuffer);
+                Span<Block8x8> blockRow = spectralBuffer.DangerousGetRowSpan(yBlockStart + y);
 
-                // see: https://github.com/SixLabors/ImageSharp/issues/824
-                int widthInBlocks = Math.Min(spectralBuffer.Width, this.SizeInBlocks.Width);
-
-                for (int xBlock = 0; xBlock < widthInBlocks; xBlock++)
+                for (int xBlock = 0; xBlock < spectralBuffer.Width; xBlock++)
                 {
-                    ref Block8x8 block = ref blockRow[xBlock];
-                    int xBuffer = xBlock * this.blockAreaSize.Width;
-                    ref float destAreaOrigin = ref colorBufferRow[xBuffer];
-
-                    blockPp.ProcessBlockColorsInto(ref block, ref destAreaOrigin, destAreaStride, maximumValue);
+                    // Integer to float
+                    workspaceBlock.LoadFrom(ref blockRow[xBlock]);
+
+                    // Dequantize
+                    workspaceBlock.MultiplyInPlace(ref dequantTable);
+
+                    // Convert from spectral to color
+                    FastFloatingPointDCT.TransformIDCT(ref workspaceBlock);
+
+                    // To conform better to libjpeg we actually NEED TO loose precision here.
+                    // This is because they store blocks as Int16 between all the operations.
+                    // To be "more accurate", we need to emulate this by rounding!
+                    workspaceBlock.NormalizeColorsAndRoundInPlace(maximumValue);
+
+                    // Write to color buffer acording to sampling factors
+                    int xColorBufferStart = xBlock * this.blockAreaSize.Width;
+                    workspaceBlock.ScaledCopyTo(
+                        ref colorBufferRow[xColorBufferStart],
+                        destAreaStride,
+                        subSamplingDivisors.Width,
+                        subSamplingDivisors.Height);
                 }
             }
         }
 
         public void ClearSpectralBuffers()
         {
-            Buffer2D<Block8x8> spectralBlocks = this.Component.SpectralBlocks;
+            Buffer2D<Block8x8> spectralBlocks = this.component.SpectralBlocks;
             for (int i = 0; i < spectralBlocks.Height; i++)
             {
-                spectralBlocks.GetRowSpan(i).Clear();
+                spectralBlocks.DangerousGetRowSpan(i).Clear();
             }
         }
 
-        public void CopyBlocksToColorBuffer()
-        {
-            this.CopyBlocksToColorBuffer(this.currentComponentRowInBlocks);
-            this.currentComponentRowInBlocks += this.BlockRowsPerStep;
-        }
+        public Span<float> GetColorBufferRowSpan(int row) =>
+            this.ColorBuffer.DangerousGetRowSpan(row);
     }
 }

src/ImageSharp/Formats/Jpeg/Components/Decoder/ProfileResolver.cs

@@ -60,6 +60,18 @@ namespace SixLabors.ImageSharp.Formats.Jpeg.Components.Decoder
             (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[]
+        {
+            (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>

src/ImageSharp/Formats/Jpeg/Components/Decoder/SpectralConverter.cs

@@ -6,13 +6,16 @@ using SixLabors.ImageSharp.Formats.Jpeg.Components.Decoder.ColorConverters;
 namespace SixLabors.ImageSharp.Formats.Jpeg.Components.Decoder
 {
     /// <summary>
-    /// Converter used to convert jpeg spectral data.
+    /// Converter used to convert jpeg spectral data to color pixels.
     /// </summary>
-    /// <remarks>
-    /// This is tightly coupled with <see cref="HuffmanScanDecoder"/> and <see cref="JpegDecoderCore"/>.
-    /// </remarks>
     internal abstract class SpectralConverter
     {
+        /// <summary>
+        /// Gets a value indicating whether this converter has converted spectral
+        /// data of the current image or not.
+        /// </summary>
+        protected bool Converted { get; private set; }
+
         /// <summary>
         /// Injects jpeg image decoding metadata.
         /// </summary>
@@ -24,21 +27,36 @@ namespace SixLabors.ImageSharp.Formats.Jpeg.Components.Decoder
         public abstract void InjectFrameData(JpegFrame frame, IRawJpegData jpegData);
 
         /// <summary>
-        /// Called once per spectral stride for each component in <see cref="HuffmanScanDecoder"/>.
-        /// This is called only for baseline interleaved jpegs.
+        /// Converts single spectral jpeg stride to color stride in baseline
+        /// decoding mode.
         /// </summary>
         /// <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 component.
+        /// Actual stride height depends on the subsampling factor of the given image.
         /// </remarks>
         public abstract void ConvertStrideBaseline();
 
+        /// <summary>
+        /// Marks current converter state as 'converted'.
+        /// </summary>
+        /// <remarks>
+        /// This must be called only for baseline interleaved jpeg's.
+        /// </remarks>
+        public void CommitConversion()
+        {
+            DebugGuard.IsFalse(this.Converted, nameof(this.Converted), $"{nameof(this.CommitConversion)} must be called only once");
+
+            this.Converted = true;
+        }
+
         /// <summary>
         /// Gets the color converter.
         /// </summary>
         /// <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 JpegColorConverter GetColorConverter(JpegFrame frame, IRawJpegData jpegData) => JpegColorConverter.GetConverter(jpegData.ColorSpace, frame.Precision);
+        protected virtual JpegColorConverterBase GetColorConverter(JpegFrame frame, IRawJpegData jpegData) => JpegColorConverterBase.GetConverter(jpegData.ColorSpace, frame.Precision);
     }
 }

src/ImageSharp/Formats/Jpeg/Components/Decoder/SpectralConverter{TPixel}.cs

@@ -3,7 +3,7 @@
 
 using System;
 using System.Buffers;
-using System.Numerics;
+using System.Linq;
 using System.Threading;
 using SixLabors.ImageSharp.Formats.Jpeg.Components.Decoder.ColorConverters;
 using SixLabors.ImageSharp.Memory;
@@ -11,39 +11,78 @@ using SixLabors.ImageSharp.PixelFormats;
 
 namespace SixLabors.ImageSharp.Formats.Jpeg.Components.Decoder
 {
+    /// <inheritdoc/>
+    /// <remarks>
+    /// Color decoding scheme:
+    /// <list type = "number" >
+    /// <listheader>
+    ///     <item>Decode spectral data to Jpeg color space</item>
+    ///     <item>Convert from Jpeg color space to RGB</item>
+    ///     <item>Convert from RGB to target pixel space</item>
+    /// </listheader>
+    /// </list>
+    /// </remarks>
     internal class SpectralConverter<TPixel> : SpectralConverter, IDisposable
         where TPixel : unmanaged, IPixel<TPixel>
     {
+        /// <summary>
+        /// <see cref="Configuration"/> instance associated with current
+        /// decoding routine.
+        /// </summary>
         private readonly Configuration configuration;
 
-        private readonly CancellationToken cancellationToken;
-
+        /// <summary>
+        /// Jpeg component converters from decompressed spectral to color data.
+        /// </summary>
         private JpegComponentPostProcessor[] componentProcessors;
 
-        private JpegColorConverter colorConverter;
+        /// <summary>
+        /// Color converter from jpeg color space to target pixel color space.
+        /// </summary>
+        private JpegColorConverterBase colorConverter;
 
-        // private IMemoryOwner<Vector4> rgbaBuffer;
+        /// <summary>
+        /// Intermediate buffer of RGB components used in color conversion.
+        /// </summary>
         private IMemoryOwner<byte> rgbBuffer;
 
+        /// <summary>
+        /// Proxy buffer used in packing from RGB to target TPixel pixels.
+        /// </summary>
         private IMemoryOwner<TPixel> paddedProxyPixelRow;
 
+        /// <summary>
+        /// Resulting 2D pixel buffer.
+        /// </summary>
         private Buffer2D<TPixel> pixelBuffer;
 
-        private int blockRowsPerStep;
-
+        /// <summary>
+        /// How many pixel rows are processed in one 'stride'.
+        /// </summary>
         private int pixelRowsPerStep;
 
+        /// <summary>
+        /// How many pixel rows were processed.
+        /// </summary>
         private int pixelRowCounter;
 
-        public SpectralConverter(Configuration configuration, CancellationToken cancellationToken)
-        {
+        /// <summary>
+        /// Initializes a new instance of the <see cref="SpectralConverter{TPixel}" /> class.
+        /// </summary>
+        /// <param name="configuration">The configuration.</param>
+        public SpectralConverter(Configuration configuration) =>
             this.configuration = configuration;
-            this.cancellationToken = cancellationToken;
-        }
-
-        private bool Converted => this.pixelRowCounter >= this.pixelBuffer.Height;
 
-        public Buffer2D<TPixel> GetPixelBuffer()
+        /// <summary>
+        /// Gets converted pixel buffer.
+        /// </summary>
+        /// <remarks>
+        /// For non-baseline interleaved jpeg this method does a 'lazy' spectral
+        /// conversion from spectral to color.
+        /// </remarks>
+        /// <param name="cancellationToken">Cancellation token.</param>
+        /// <returns>Pixel buffer.</returns>
+        public Buffer2D<TPixel> GetPixelBuffer(CancellationToken cancellationToken)
         {
             if (!this.Converted)
             {
@@ -51,8 +90,8 @@ namespace SixLabors.ImageSharp.Formats.Jpeg.Components.Decoder
 
                 for (int step = 0; step < steps; step++)
                 {
-                    this.cancellationToken.ThrowIfCancellationRequested();
-                    this.ConvertNextStride(step);
+                    cancellationToken.ThrowIfCancellationRequested();
+                    this.ConvertStride(step);
                 }
             }
 
@@ -65,18 +104,19 @@ namespace SixLabors.ImageSharp.Formats.Jpeg.Components.Decoder
             MemoryAllocator allocator = this.configuration.MemoryAllocator;
 
             // iteration data
-            IJpegComponent c0 = frame.Components[0];
+            int majorBlockWidth = frame.Components.Max((component) => component.SizeInBlocks.Width);
+            int majorVerticalSamplingFactor = frame.Components.Max((component) => component.SamplingFactors.Height);
 
             const int blockPixelHeight = 8;
-            this.blockRowsPerStep = c0.SamplingFactors.Height;
-            this.pixelRowsPerStep = this.blockRowsPerStep * blockPixelHeight;
+            this.pixelRowsPerStep = majorVerticalSamplingFactor * blockPixelHeight;
 
             // pixel buffer for resulting image
             this.pixelBuffer = allocator.Allocate2D<TPixel>(frame.PixelWidth, frame.PixelHeight);
             this.paddedProxyPixelRow = allocator.Allocate<TPixel>(frame.PixelWidth + 3);
 
             // component processors from spectral to Rgba32
-            var postProcessorBufferSize = new Size(c0.SizeInBlocks.Width * 8, this.pixelRowsPerStep);
+            const int blockPixelWidth = 8;
+            var postProcessorBufferSize = new Size(majorBlockWidth * blockPixelWidth, this.pixelRowsPerStep);
             this.componentProcessors = new JpegComponentPostProcessor[frame.Components.Length];
             for (int i = 0; i < this.componentProcessors.Length; i++)
             {
@@ -84,7 +124,6 @@ namespace SixLabors.ImageSharp.Formats.Jpeg.Components.Decoder
             }
 
             // single 'stride' rgba32 buffer for conversion between spectral and TPixel
-            // this.rgbaBuffer = allocator.Allocate<Vector4>(frame.PixelWidth);
             this.rgbBuffer = allocator.Allocate<byte>(frame.PixelWidth * 3);
 
             // color converter from Rgba32 to TPixel
@@ -95,41 +134,27 @@ namespace SixLabors.ImageSharp.Formats.Jpeg.Components.Decoder
         public override void ConvertStrideBaseline()
         {
             // Convert next pixel stride using single spectral `stride'
-            // Note that zero passing eliminates the need of virtual call from JpegComponentPostProcessor
-            this.ConvertNextStride(spectralStep: 0);
+            // Note that zero passing eliminates the need of virtual call
+            // from JpegComponentPostProcessor
+            this.ConvertStride(spectralStep: 0);
 
-            // Clear spectral stride - this is VERY important as jpeg possibly won't fill entire buffer each stride
-            // Which leads to decoding artifacts
-            // Note that this code clears all buffers of the post processors, it's their responsibility to allocate only single stride
             foreach (JpegComponentPostProcessor cpp in this.componentProcessors)
             {
                 cpp.ClearSpectralBuffers();
             }
         }
 
-        public void Dispose()
-        {
-            if (this.componentProcessors != null)
-            {
-                foreach (JpegComponentPostProcessor cpp in this.componentProcessors)
-                {
-                    cpp.Dispose();
-                }
-            }
-
-            this.rgbBuffer?.Dispose();
-            this.paddedProxyPixelRow?.Dispose();
-        }
-
-        private void ConvertNextStride(int spectralStep)
+        /// <summary>
+        /// Converts single spectral jpeg stride to color stride.
+        /// </summary>
+        /// <param name="spectralStep">Spectral stride index.</param>
+        private void ConvertStride(int spectralStep)
         {
             int maxY = Math.Min(this.pixelBuffer.Height, this.pixelRowCounter + this.pixelRowsPerStep);
 
-            var buffers = new Buffer2D<float>[this.componentProcessors.Length];
             for (int i = 0; i < this.componentProcessors.Length; i++)
             {
                 this.componentProcessors[i].CopyBlocksToColorBuffer(spectralStep);
-                buffers[i] = this.componentProcessors[i].ColorBuffer;
             }
 
             int width = this.pixelBuffer.Width;
@@ -138,7 +163,7 @@ namespace SixLabors.ImageSharp.Formats.Jpeg.Components.Decoder
             {
                 int y = yy - this.pixelRowCounter;
 
-                var values = new JpegColorConverter.ComponentValues(buffers, y);
+                var values = new JpegColorConverterBase.ComponentValues(this.componentProcessors, y);
 
                 this.colorConverter.ConvertToRgbInplace(values);
                 values = values.Slice(0, width); // slice away Jpeg padding
@@ -154,7 +179,7 @@ namespace SixLabors.ImageSharp.Formats.Jpeg.Components.Decoder
                 // PackFromRgbPlanes expects the destination to be padded, so try to get padded span containing extra elements from the next row.
                 // If we can't get such a padded row because we are on a MemoryGroup boundary or at the last row,
                 // pack pixels to a temporary, padded proxy buffer, then copy the relevant values to the destination row.
-                if (this.pixelBuffer.TryGetPaddedRowSpan(yy, 3, out Span<TPixel> destRow))
+                if (this.pixelBuffer.DangerousTryGetPaddedRowSpan(yy, 3, out Span<TPixel> destRow))
                 {
                     PixelOperations<TPixel>.Instance.PackFromRgbPlanes(this.configuration, r, g, b, destRow);
                 }
@@ -162,11 +187,26 @@ namespace SixLabors.ImageSharp.Formats.Jpeg.Components.Decoder
                 {
                     Span<TPixel> proxyRow = this.paddedProxyPixelRow.GetSpan();
                     PixelOperations<TPixel>.Instance.PackFromRgbPlanes(this.configuration, r, g, b, proxyRow);
-                    proxyRow.Slice(0, width).CopyTo(this.pixelBuffer.GetRowSpan(yy));
+                    proxyRow.Slice(0, width).CopyTo(this.pixelBuffer.DangerousGetRowSpan(yy));
                 }
             }
 
             this.pixelRowCounter += this.pixelRowsPerStep;
         }
+
+        /// <inheritdoc/>
+        public void Dispose()
+        {
+            if (this.componentProcessors != null)
+            {
+                foreach (JpegComponentPostProcessor cpp in this.componentProcessors)
+                {
+                    cpp.Dispose();
+                }
+            }
+
+            this.rgbBuffer?.Dispose();
+            this.paddedProxyPixelRow?.Dispose();
+        }
     }
 }

src/ImageSharp/Formats/Jpeg/Components/Encoder/HuffmanScanEncoder.cs

@@ -278,11 +278,12 @@ namespace SixLabors.ImageSharp.Formats.Jpeg.Components.Encoder
             // ReSharper disable once InconsistentNaming
             int prevDCY = 0;
 
-            var pixelConverter = LuminanceForwardConverter<TPixel>.Create();
             ImageFrame<TPixel> frame = pixels.Frames.RootFrame;
             Buffer2D<TPixel> pixelBuffer = frame.PixelBuffer;
             RowOctet<TPixel> currentRows = default;
 
+            var pixelConverter = new LuminanceForwardConverter<TPixel>(frame);
+
             for (int y = 0; y < pixels.Height; y += 8)
             {
                 cancellationToken.ThrowIfCancellationRequested();
@@ -290,7 +291,7 @@ namespace SixLabors.ImageSharp.Formats.Jpeg.Components.Encoder
 
                 for (int x = 0; x < pixels.Width; x += 8)
                 {
-                    pixelConverter.Convert(frame, x, y, ref currentRows);
+                    pixelConverter.Convert(x, y, ref currentRows);
 
                     prevDCY = this.WriteBlock(
                         QuantIndex.Luminance,
@@ -649,6 +650,7 @@ namespace SixLabors.ImageSharp.Formats.Jpeg.Components.Encoder
             }
 
             this.target.Write(this.streamWriteBuffer, 0, writeIdx);
+            this.emitWriteIndex = this.emitBuffer.Length;
         }
 
         /// <summary>
@@ -659,11 +661,8 @@ namespace SixLabors.ImageSharp.Formats.Jpeg.Components.Encoder
         /// This must be called only if <see cref="IsStreamFlushNeeded"/> is true
         /// only during the macroblocks encoding routine.
         /// </remarks>
-        private void FlushToStream()
-        {
+        private void FlushToStream() =>
             this.FlushToStream(this.emitWriteIndex * 4);
-            this.emitWriteIndex = this.emitBuffer.Length;
-        }
 
         /// <summary>
         /// Flushes final cached bits to the stream padding 1's to
@@ -680,10 +679,11 @@ namespace SixLabors.ImageSharp.Formats.Jpeg.Components.Encoder
             // And writing only valuable count of bytes count we want to write to the output stream
             int valuableBytesCount = (int)Numerics.DivideCeil((uint)this.bitCount, 8);
             uint packedBytes = this.accumulatedBits | (uint.MaxValue >> this.bitCount);
-            this.emitBuffer[--this.emitWriteIndex] = packedBytes;
+            this.emitBuffer[this.emitWriteIndex - 1] = packedBytes;
 
             // Flush cached bytes to the output stream with padding bits
-            this.FlushToStream((this.emitWriteIndex * 4) - 4 + valuableBytesCount);
+            int lastByteIndex = (this.emitWriteIndex * 4) - valuableBytesCount;
+            this.FlushToStream(lastByteIndex);
         }
     }
 }

src/ImageSharp/Formats/Jpeg/Components/Encoder/LuminanceForwardConverter{TPixel}.cs

@@ -3,6 +3,7 @@
 
 using System;
 using System.Runtime.CompilerServices;
+using System.Runtime.InteropServices;
 using SixLabors.ImageSharp.Advanced;
 using SixLabors.ImageSharp.PixelFormats;
 
@@ -15,39 +16,63 @@ namespace SixLabors.ImageSharp.Formats.Jpeg.Components.Encoder
     internal ref struct LuminanceForwardConverter<TPixel>
         where TPixel : unmanaged, IPixel<TPixel>
     {
+        /// <summary>
+        /// Number of pixels processed per single <see cref="Convert(int, int, ref RowOctet{TPixel})"/> call
+        /// </summary>
+        private const int PixelsPerSample = 8 * 8;
+
         /// <summary>
         /// The Y component
         /// </summary>
         public Block8x8F Y;
 
         /// <summary>
-        /// Temporal 8x8 block to hold TPixel data
+        /// Temporal 64-pixel span to hold unconverted TPixel data.
+        /// </summary>
+        private readonly Span<TPixel> pixelSpan;
+
+        /// <summary>
+        /// Temporal 64-byte span to hold converted <see cref="L8"/> data.
+        /// </summary>
+        private readonly Span<L8> l8Span;
+
+        /// <summary>
+        /// Sampled pixel buffer size.
         /// </summary>
-        private GenericBlock8x8<TPixel> pixelBlock;
+        private readonly Size samplingAreaSize;
 
         /// <summary>
-        /// Temporal RGB block
+        /// <see cref="Configuration"/> for internal operations.
         /// </summary>
-        private GenericBlock8x8<L8> l8Block;
+        private readonly Configuration config;
 
-        public static LuminanceForwardConverter<TPixel> Create()
+        public LuminanceForwardConverter(ImageFrame<TPixel> frame)
         {
-            var result = default(LuminanceForwardConverter<TPixel>);
-            return result;
+            this.Y = default;
+
+            this.pixelSpan = new TPixel[PixelsPerSample].AsSpan();
+            this.l8Span = new L8[PixelsPerSample].AsSpan();
+
+            this.samplingAreaSize = new Size(frame.Width, frame.Height);
+            this.config = frame.GetConfiguration();
         }
 
+        /// <summary>
+        /// Gets size of sampling area from given frame pixel buffer.
+        /// </summary>
+        private static Size SampleSize => new(8, 8);
+
         /// <summary>
         /// Converts a 8x8 image area inside 'pixels' at position (x,y) placing the result members of the structure (<see cref="Y"/>)
         /// </summary>
-        public void Convert(ImageFrame<TPixel> frame, int x, int y, ref RowOctet<TPixel> currentRows)
+        public void Convert(int x, int y, ref RowOctet<TPixel> currentRows)
         {
-            this.pixelBlock.LoadAndStretchEdges(frame.PixelBuffer, x, y, ref currentRows);
+            YCbCrForwardConverter<TPixel>.LoadAndStretchEdges(currentRows, this.pixelSpan, new Point(x, y), SampleSize, this.samplingAreaSize);
 
-            Span<L8> l8Span = this.l8Block.AsSpanUnsafe();
-            PixelOperations<TPixel>.Instance.ToL8(frame.GetConfiguration(), this.pixelBlock.AsSpanUnsafe(), l8Span);
+            PixelOperations<TPixel>.Instance.ToL8(this.config, this.pixelSpan, this.l8Span);
 
             ref Block8x8F yBlock = ref this.Y;
-            ref L8 l8Start = ref l8Span[0];
+            ref L8 l8Start = ref MemoryMarshal.GetReference(this.l8Span);
 
             for (int i = 0; i < Block8x8F.Size; i++)
             {

src/ImageSharp/Formats/Jpeg/Components/Encoder/RgbForwardConverter{TPixel}.cs

@@ -26,11 +26,6 @@ namespace SixLabors.ImageSharp.Formats.Jpeg.Components.Encoder
         /// </summary>
         private const int RgbSpanByteSize = PixelsPerSample * 3;
 
-        /// <summary>
-        /// <see cref="Size"/> of sampling area from given frame pixel buffer.
-        /// </summary>
-        private static readonly Size SampleSize = new Size(8, 8);
-
         /// <summary>
         /// The Red component.
         /// </summary>
@@ -81,6 +76,11 @@ namespace SixLabors.ImageSharp.Formats.Jpeg.Components.Encoder
             this.config = frame.GetConfiguration();
         }
 
+        /// <summary>
+        /// Gets size of sampling area from given frame pixel buffer.
+        /// </summary>
+        private static Size SampleSize => new(8, 8);
+
         /// <summary>
         /// Converts a 8x8 image area inside 'pixels' at position (x, y) to Rgb24.
         /// </summary>

src/ImageSharp/Formats/Jpeg/Components/Encoder/YCbCrForwardConverter420{TPixel}.cs

@@ -25,11 +25,6 @@ namespace SixLabors.ImageSharp.Formats.Jpeg.Components.Encoder
         /// </summary>
         private const int RgbSpanByteSize = PixelsPerSample * 3;
 
-        /// <summary>
-        /// <see cref="Size"/> of sampling area from given frame pixel buffer
-        /// </summary>
-        private static readonly Size SampleSize = new Size(16, 8);
-
         /// <summary>
         /// The left Y component
         /// </summary>
@@ -102,6 +97,11 @@ namespace SixLabors.ImageSharp.Formats.Jpeg.Components.Encoder
             }
         }
 
+        /// <summary>
+        /// Gets size of sampling area from given frame pixel buffer.
+        /// </summary>
+        private static Size SampleSize => new(16, 8);
+
         public void Convert(int x, int y, ref RowOctet<TPixel> currentRows, int idx)
         {
             YCbCrForwardConverter<TPixel>.LoadAndStretchEdges(currentRows, this.pixelSpan, new Point(x, y), SampleSize, this.samplingAreaSize);

src/ImageSharp/Formats/Jpeg/Components/Encoder/YCbCrForwardConverter444{TPixel}.cs

@@ -25,11 +25,6 @@ namespace SixLabors.ImageSharp.Formats.Jpeg.Components.Encoder
         /// </summary>
         private const int RgbSpanByteSize = PixelsPerSample * 3;
 
-        /// <summary>
-        /// <see cref="Size"/> of sampling area from given frame pixel buffer
-        /// </summary>
-        private static readonly Size SampleSize = new Size(8, 8);
-
         /// <summary>
         /// The Y component
         /// </summary>
@@ -96,6 +91,11 @@ namespace SixLabors.ImageSharp.Formats.Jpeg.Components.Encoder
             }
         }
 
+        /// <summary>
+        /// Gets size of sampling area from given frame pixel buffer.
+        /// </summary>
+        private static Size SampleSize => new(8, 8);
+
         /// <summary>
         /// Converts a 8x8 image area inside 'pixels' at position (x,y) placing the result members of the structure (<see cref="Y"/>, <see cref="Cb"/>, <see cref="Cr"/>)
         /// </summary>

src/ImageSharp/Formats/Jpeg/Components/FastFloatingPointDCT.Intrinsic.cs

@@ -2,9 +2,6 @@
 // Licensed under the Apache License, Version 2.0.
 
 #if SUPPORTS_RUNTIME_INTRINSICS
-using System.Diagnostics;
-using System.Numerics;
-using System.Runtime.CompilerServices;
 using System.Runtime.Intrinsics;
 using System.Runtime.Intrinsics.X86;
 
@@ -12,149 +9,147 @@ namespace SixLabors.ImageSharp.Formats.Jpeg.Components
 {
     internal static partial class FastFloatingPointDCT
     {
-#pragma warning disable SA1310, SA1311, IDE1006 // naming rules violation warnings
+#pragma warning disable SA1310, SA1311, IDE1006 // naming rule violation warnings
         private static readonly Vector256<float> mm256_F_0_7071 = Vector256.Create(0.707106781f);
         private static readonly Vector256<float> mm256_F_0_3826 = Vector256.Create(0.382683433f);
         private static readonly Vector256<float> mm256_F_0_5411 = Vector256.Create(0.541196100f);
         private static readonly Vector256<float> mm256_F_1_3065 = Vector256.Create(1.306562965f);
 
-        private static readonly Vector256<float> mm256_F_1_1758 = Vector256.Create(1.175876f);
-        private static readonly Vector256<float> mm256_F_n1_9615 = Vector256.Create(-1.961570560f);
-        private static readonly Vector256<float> mm256_F_n0_3901 = Vector256.Create(-0.390180644f);
-        private static readonly Vector256<float> mm256_F_n0_8999 = Vector256.Create(-0.899976223f);
-        private static readonly Vector256<float> mm256_F_n2_5629 = Vector256.Create(-2.562915447f);
-        private static readonly Vector256<float> mm256_F_0_2986 = Vector256.Create(0.298631336f);
-        private static readonly Vector256<float> mm256_F_2_0531 = Vector256.Create(2.053119869f);
-        private static readonly Vector256<float> mm256_F_3_0727 = Vector256.Create(3.072711026f);
-        private static readonly Vector256<float> mm256_F_1_5013 = Vector256.Create(1.501321110f);
-        private static readonly Vector256<float> mm256_F_n1_8477 = Vector256.Create(-1.847759065f);
-        private static readonly Vector256<float> mm256_F_0_7653 = Vector256.Create(0.765366865f);
+        private static readonly Vector256<float> mm256_F_1_4142 = Vector256.Create(1.414213562f);
+        private static readonly Vector256<float> mm256_F_1_8477 = Vector256.Create(1.847759065f);
+        private static readonly Vector256<float> mm256_F_n1_0823 = Vector256.Create(-1.082392200f);
+        private static readonly Vector256<float> mm256_F_n2_6131 = Vector256.Create(-2.613125930f);
 #pragma warning restore SA1310, SA1311, IDE1006
 
         /// <summary>
         /// Apply floating point FDCT inplace using simd operations.
         /// </summary>
-        /// <param name="block">Input matrix.</param>
-        private static void ForwardTransform_Avx(ref Block8x8F block)
+        /// <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 rows
             block.TransposeInplace();
-            FDCT8x8_Avx(ref block);
+            FDCT8x8_1D_Avx(ref block);
 
             // Second pass - process columns
             block.TransposeInplace();
-            FDCT8x8_Avx(ref block);
+            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);
+
+                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), mm256_F_0_3826);
+                Vector256<float> z2 = SimdUtils.HwIntrinsics.MultiplyAdd(z5, mm256_F_0_5411, tmp10);
+                Vector256<float> z4 = SimdUtils.HwIntrinsics.MultiplyAdd(z5, mm256_F_1_3065, tmp12);
+                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 1D floating point FDCT inplace using AVX operations on 8x8 matrix.
+        /// Apply floating point IDCT inplace using simd operations.
         /// </summary>
-        /// <remarks>
-        /// Requires Avx support.
-        /// </remarks>
-        /// <param name="block">Input matrix.</param>
-        public static void FDCT8x8_Avx(ref Block8x8F block)
+        /// <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.");
 
-            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);
-
-            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), mm256_F_0_3826);
-            Vector256<float> z2 = SimdUtils.HwIntrinsics.MultiplyAdd(z5, mm256_F_0_5411, tmp10);
-            Vector256<float> z4 = SimdUtils.HwIntrinsics.MultiplyAdd(z5, mm256_F_1_3065, tmp12);
-            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>
-        /// Combined operation of <see cref="IDCT8x4_LeftPart(ref Block8x8F, ref Block8x8F)"/> and <see cref="IDCT8x4_RightPart(ref Block8x8F, ref Block8x8F)"/>
-        /// using AVX commands.
-        /// </summary>
-        /// <param name="s">Source</param>
-        /// <param name="d">Destination</param>
-        public static void IDCT8x8_Avx(ref Block8x8F s, ref Block8x8F d)
-        {
-            Debug.Assert(Avx.IsSupported, "AVX is required to execute this method");
-
-            Vector256<float> my1 = s.V1;
-            Vector256<float> my7 = s.V7;
-            Vector256<float> mz0 = Avx.Add(my1, my7);
-
-            Vector256<float> my3 = s.V3;
-            Vector256<float> mz2 = Avx.Add(my3, my7);
-            Vector256<float> my5 = s.V5;
-            Vector256<float> mz1 = Avx.Add(my3, my5);
-            Vector256<float> mz3 = Avx.Add(my1, my5);
-
-            Vector256<float> mz4 = Avx.Multiply(Avx.Add(mz0, mz1), mm256_F_1_1758);
-
-            mz2 = SimdUtils.HwIntrinsics.MultiplyAdd(mz4, mz2, mm256_F_n1_9615);
-            mz3 = SimdUtils.HwIntrinsics.MultiplyAdd(mz4, mz3, mm256_F_n0_3901);
-            mz0 = Avx.Multiply(mz0, mm256_F_n0_8999);
-            mz1 = Avx.Multiply(mz1, mm256_F_n2_5629);
-
-            Vector256<float> mb3 = Avx.Add(SimdUtils.HwIntrinsics.MultiplyAdd(mz0, my7, mm256_F_0_2986), mz2);
-            Vector256<float> mb2 = Avx.Add(SimdUtils.HwIntrinsics.MultiplyAdd(mz1, my5, mm256_F_2_0531), mz3);
-            Vector256<float> mb1 = Avx.Add(SimdUtils.HwIntrinsics.MultiplyAdd(mz1, my3, mm256_F_3_0727), mz2);
-            Vector256<float> mb0 = Avx.Add(SimdUtils.HwIntrinsics.MultiplyAdd(mz0, my1, mm256_F_1_5013), mz3);
-
-            Vector256<float> my2 = s.V2;
-            Vector256<float> my6 = s.V6;
-            mz4 = Avx.Multiply(Avx.Add(my2, my6), mm256_F_0_5411);
-            Vector256<float> my0 = s.V0;
-            Vector256<float> my4 = s.V4;
-            mz0 = Avx.Add(my0, my4);
-            mz1 = Avx.Subtract(my0, my4);
-            mz2 = SimdUtils.HwIntrinsics.MultiplyAdd(mz4, my6, mm256_F_n1_8477);
-            mz3 = SimdUtils.HwIntrinsics.MultiplyAdd(mz4, my2, mm256_F_0_7653);
-
-            my0 = Avx.Add(mz0, mz3);
-            my3 = Avx.Subtract(mz0, mz3);
-            my1 = Avx.Add(mz1, mz2);
-            my2 = Avx.Subtract(mz1, mz2);
-
-            d.V0 = Avx.Add(my0, mb0);
-            d.V7 = Avx.Subtract(my0, mb0);
-            d.V1 = Avx.Add(my1, mb1);
-            d.V6 = Avx.Subtract(my1, mb1);
-            d.V2 = Avx.Add(my2, mb2);
-            d.V5 = Avx.Subtract(my2, mb2);
-            d.V3 = Avx.Add(my3, mb3);
-            d.V4 = Avx.Subtract(my3, mb3);
+            // 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);
+
+                Vector256<float> tmp13 = Avx.Add(tmp1, tmp3);
+                Vector256<float> tmp12 = SimdUtils.HwIntrinsics.MultiplySubstract(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), mm256_F_1_8477);
+
+                tmp10 = SimdUtils.HwIntrinsics.MultiplyAdd(z5, z12, mm256_F_n1_0823);
+                tmp12 = SimdUtils.HwIntrinsics.MultiplyAdd(z5, z10, 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);
+            }
         }
     }
 }

src/ImageSharp/Formats/Jpeg/Components/FastFloatingPointDCT.cs

@@ -3,6 +3,7 @@
 
 using System.Numerics;
 using System.Runtime.CompilerServices;
+using System.Runtime.InteropServices;
 #if SUPPORTS_RUNTIME_INTRINSICS
 using System.Runtime.Intrinsics.X86;
 #endif
@@ -15,102 +16,204 @@ namespace SixLabors.ImageSharp.Formats.Jpeg.Components
     /// </summary>
     internal static partial class FastFloatingPointDCT
     {
-#pragma warning disable SA1310 // FieldNamesMustNotContainUnderscore
-        private const float C_1_175876 = 1.175875602f;
-        private const float C_1_961571 = -1.961570560f;
-        private const float C_0_390181 = -0.390180644f;
-        private const float C_0_899976 = -0.899976223f;
-        private const float C_2_562915 = -2.562915447f;
-        private const float C_0_298631 = 0.298631336f;
-        private const float C_2_053120 = 2.053119869f;
-        private const float C_3_072711 = 3.072711026f;
-        private const float C_1_501321 = 1.501321110f;
-        private const float C_0_541196 = 0.541196100f;
-        private const float C_1_847759 = -1.847759065f;
-        private const float C_0_765367 = 0.765366865f;
-
-        private const float C_0_125 = 0.1250f;
-
-#pragma warning disable SA1311, IDE1006 // naming rules violation warnings
-        private static readonly Vector4 mm128_F_0_7071 = new Vector4(0.707106781f);
-        private static readonly Vector4 mm128_F_0_3826 = new Vector4(0.382683433f);
-        private static readonly Vector4 mm128_F_0_5411 = new Vector4(0.541196100f);
-        private static readonly Vector4 mm128_F_1_3065 = new Vector4(1.306562965f);
-#pragma warning restore SA1311, IDE1006
-
-#pragma warning restore SA1310 // FieldNamesMustNotContainUnderscore
+#pragma warning disable SA1310, SA1311, IDE1006 // naming rules violation warnings
+        private static readonly Vector4 mm128_F_0_7071 = new(0.707106781f);
+        private static readonly Vector4 mm128_F_0_3826 = new(0.382683433f);
+        private static readonly Vector4 mm128_F_0_5411 = new(0.541196100f);
+        private static readonly Vector4 mm128_F_1_3065 = new(1.306562965f);
+
+        private static readonly Vector4 mm128_F_1_4142 = new(1.414213562f);
+        private static readonly Vector4 mm128_F_1_8477 = new(1.847759065f);
+        private static readonly Vector4 mm128_F_n1_0823 = new(-1.082392200f);
+        private static readonly Vector4 mm128_F_n2_6131 = new(-2.613125930f);
+#pragma warning restore SA1310, SA1311, IDE1006
 
         /// <summary>
-        /// Gets reciprocal coefficients for jpeg quantization tables calculation.
+        /// Gets adjustment table for quantization tables.
         /// </summary>
         /// <remarks>
         /// <para>
-        /// Current FDCT implementation expects its results to be multiplied by
-        /// a reciprocal quantization table. To get 8x8 reciprocal block values in this
-        /// table must be divided by quantization table values scaled with quality settings.
+        /// Current IDCT and FDCT implementations are based on  Arai, Agui,
+        /// and Nakajima's algorithm. Both DCT methods does not
+        /// produce finished DCT output, final step is fused into the
+        /// quantization step. Quantization and de-quantization coefficients
+        /// must be multiplied by these values.
         /// </para>
         /// <para>
-        /// These values were calculates with this formula:
-        /// <code>
-        /// value[row * 8 + col] = scalefactor[row] * scalefactor[col] * 8;
-        /// </code>
-        /// Where:
+        /// Given values were generated by formula:
         /// <code>
+        /// scalefactor[row] * scalefactor[col], where
         /// scalefactor[0] = 1
-        /// </code>
-        /// <code>
         /// scalefactor[k] = cos(k*PI/16) * sqrt(2)    for k=1..7
         /// </code>
-        /// Values are also scaled by 8 so DCT code won't do extra division/multiplication.
         /// </para>
         /// </remarks>
-        internal static readonly float[] DctReciprocalAdjustmentCoefficients = new float[]
+        private static readonly float[] AdjustmentCoefficients = new float[]
         {
-            0.125f, 0.09011998f, 0.09567086f, 0.10630376f, 0.125f, 0.15909483f, 0.23096988f, 0.45306373f,
-            0.09011998f, 0.064972885f, 0.068974845f, 0.07664074f, 0.09011998f, 0.11470097f, 0.16652f, 0.32664075f,
-            0.09567086f, 0.068974845f, 0.07322331f, 0.081361376f, 0.09567086f, 0.121765904f, 0.17677669f, 0.34675997f,
-            0.10630376f, 0.07664074f, 0.081361376f, 0.09040392f, 0.10630376f, 0.13529903f, 0.19642374f, 0.38529903f,
-            0.125f, 0.09011998f, 0.09567086f, 0.10630376f, 0.125f, 0.15909483f, 0.23096988f, 0.45306373f,
-            0.15909483f, 0.11470097f, 0.121765904f, 0.13529903f, 0.15909483f, 0.2024893f, 0.2939689f, 0.5766407f,
-            0.23096988f, 0.16652f, 0.17677669f, 0.19642374f, 0.23096988f, 0.2939689f, 0.4267767f, 0.8371526f,
-            0.45306373f, 0.32664075f, 0.34675997f, 0.38529903f, 0.45306373f, 0.5766407f, 0.8371526f, 1.642134f,
+            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,
+            1.1758755f, 1.6309863f, 1.5363555f, 1.3826833f, 1.1758755f, 0.9238795f, 0.63637924f, 0.32442334f,
+            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,
         };
 
         /// <summary>
-        /// Adjusts given quantization table to be complient with FDCT implementation.
+        /// Adjusts given quantization table for usage with <see cref="TransformIDCT"/>.
+        /// </summary>
+        /// <param name="quantTable">Quantization table to adjust.</param>
+        public static void AdjustToIDCT(ref Block8x8F quantTable)
+        {
+            ref float tableRef = ref Unsafe.As<Block8x8F, float>(ref quantTable);
+            ref float multipliersRef = ref MemoryMarshal.GetReference<float>(AdjustmentCoefficients);
+            for (nint i = 0; i < Block8x8F.Size; i++)
+            {
+                tableRef = 0.125f * tableRef * Unsafe.Add(ref multipliersRef, i);
+                tableRef = ref Unsafe.Add(ref tableRef, 1);
+            }
+
+            // Spectral macroblocks are transposed before quantization
+            // so we must transpose quantization table
+            quantTable.TransposeInplace();
+        }
+
+        /// <summary>
+        /// Adjusts given quantization table for usage with <see cref="TransformFDCT"/>.
+        /// </summary>
+        /// <param name="quantTable">Quantization table to adjust.</param>
+        public static void AdjustToFDCT(ref Block8x8F quantTable)
+        {
+            ref float tableRef = ref Unsafe.As<Block8x8F, float>(ref quantTable);
+            ref float multipliersRef = ref MemoryMarshal.GetReference<float>(AdjustmentCoefficients);
+            for (nint i = 0; i < Block8x8F.Size; i++)
+            {
+                tableRef = 0.125f / (tableRef * Unsafe.Add(ref multipliersRef, i));
+                tableRef = ref Unsafe.Add(ref tableRef, 1);
+            }
+        }
+
+        /// <summary>
+        /// Apply 2D floating point IDCT inplace.
         /// </summary>
         /// <remarks>
-        /// See <see cref="DctReciprocalAdjustmentCoefficients"/> docs for explanation.
+        /// Input block must be dequantized before this method with table
+        /// adjusted by <see cref="AdjustToIDCT"/>.
         /// </remarks>
-        /// <param name="quantizationtable">Quantization table to adjust.</param>
-        public static void AdjustToFDCT(ref Block8x8F quantizationtable)
+        /// <param name="block">Input block.</param>
+        public static void TransformIDCT(ref Block8x8F block)
         {
-            for (int i = 0; i < Block8x8F.Size; i++)
+#if SUPPORTS_RUNTIME_INTRINSICS
+            if (Avx.IsSupported)
             {
-                quantizationtable[i] = DctReciprocalAdjustmentCoefficients[i] / quantizationtable[i];
+                IDCT8x8_Avx(ref block);
+            }
+            else
+#endif
+            {
+                IDCT_Vector4(ref block);
             }
         }
 
         /// <summary>
-        /// Apply 2D floating point FDCT inplace.
+        /// Apply 2D floating point IDCT inplace.
         /// </summary>
-        /// <param name="block">Input matrix.</param>
+        /// <remarks>
+        /// Input block must be quantized after this method with table adjusted
+        /// by <see cref="AdjustToFDCT"/>.
+        /// </remarks>
+        /// <param name="block">Input block.</param>
         public static void TransformFDCT(ref Block8x8F block)
         {
 #if SUPPORTS_RUNTIME_INTRINSICS
             if (Avx.IsSupported)
             {
-                ForwardTransform_Avx(ref block);
+                FDCT8x8_Avx(ref block);
             }
             else
 #endif
             if (Vector.IsHardwareAccelerated)
             {
-                ForwardTransform_Vector4(ref block);
+                FDCT_Vector4(ref block);
             }
             else
             {
-                ForwardTransform_Scalar(ref block);
+                FDCT_Scalar(ref block);
+            }
+        }
+
+        /// <summary>
+        /// Apply floating point IDCT inplace using <see cref="Vector4"/> API.
+        /// </summary>
+        /// <remarks>
+        /// This method can be used even if there's no SIMD intrinsics available
+        /// as <see cref="Vector4"/> can be compiled to scalar instructions.
+        /// </remarks>
+        /// <param name="transposedBlock">Input block.</param>
+        private static void IDCT_Vector4(ref Block8x8F transposedBlock)
+        {
+            // First pass - process columns
+            IDCT8x4_Vector4(ref transposedBlock.V0L);
+            IDCT8x4_Vector4(ref transposedBlock.V0R);
+
+            // Second pass - process rows
+            transposedBlock.TransposeInplace();
+            IDCT8x4_Vector4(ref transposedBlock.V0L);
+            IDCT8x4_Vector4(ref transposedBlock.V0R);
+
+            // Applies 1D floating point IDCT inplace on 8x4 part of 8x8 block
+            static void IDCT8x4_Vector4(ref Vector4 vecRef)
+            {
+                // Even part
+                Vector4 tmp0 = Unsafe.Add(ref vecRef, 0 * 2);
+                Vector4 tmp1 = Unsafe.Add(ref vecRef, 2 * 2);
+                Vector4 tmp2 = Unsafe.Add(ref vecRef, 4 * 2);
+                Vector4 tmp3 = Unsafe.Add(ref vecRef, 6 * 2);
+
+                Vector4 z5 = tmp0;
+                Vector4 tmp10 = z5 + tmp2;
+                Vector4 tmp11 = z5 - tmp2;
+
+                Vector4 tmp13 = tmp1 + tmp3;
+                Vector4 tmp12 = ((tmp1 - tmp3) * mm128_F_1_4142) - tmp13;
+
+                tmp0 = tmp10 + tmp13;
+                tmp3 = tmp10 - tmp13;
+                tmp1 = tmp11 + tmp12;
+                tmp2 = tmp11 - tmp12;
+
+                // Odd part
+                Vector4 tmp4 = Unsafe.Add(ref vecRef, 1 * 2);
+                Vector4 tmp5 = Unsafe.Add(ref vecRef, 3 * 2);
+                Vector4 tmp6 = Unsafe.Add(ref vecRef, 5 * 2);
+                Vector4 tmp7 = Unsafe.Add(ref vecRef, 7 * 2);
+
+                Vector4 z13 = tmp6 + tmp5;
+                Vector4 z10 = tmp6 - tmp5;
+                Vector4 z11 = tmp4 + tmp7;
+                Vector4 z12 = tmp4 - tmp7;
+
+                tmp7 = z11 + z13;
+                tmp11 = (z11 - z13) * mm128_F_1_4142;
+
+                z5 = (z10 + z12) * mm128_F_1_8477;
+
+                tmp10 = (z12 * mm128_F_n1_0823) + z5;
+                tmp12 = (z10 * mm128_F_n2_6131) + z5;
+
+                tmp6 = tmp12 - tmp7;
+                tmp5 = tmp11 - tmp6;
+                tmp4 = tmp10 - tmp5;
+
+                Unsafe.Add(ref vecRef, 0 * 2) = tmp0 + tmp7;
+                Unsafe.Add(ref vecRef, 7 * 2) = tmp0 - tmp7;
+                Unsafe.Add(ref vecRef, 1 * 2) = tmp1 + tmp6;
+                Unsafe.Add(ref vecRef, 6 * 2) = tmp1 - tmp6;
+                Unsafe.Add(ref vecRef, 2 * 2) = tmp2 + tmp5;
+                Unsafe.Add(ref vecRef, 5 * 2) = tmp2 - tmp5;
+                Unsafe.Add(ref vecRef, 3 * 2) = tmp3 + tmp4;
+                Unsafe.Add(ref vecRef, 4 * 2) = tmp3 - tmp4;
             }
         }
 
@@ -120,8 +223,8 @@ namespace SixLabors.ImageSharp.Formats.Jpeg.Components
         /// <remarks>
         /// Ported from libjpeg-turbo https://github.com/libjpeg-turbo/libjpeg-turbo/blob/main/jfdctflt.c.
         /// </remarks>
-        /// <param name="block">Input matrix.</param>
-        private static void ForwardTransform_Scalar(ref Block8x8F block)
+        /// <param name="block">Input block.</param>
+        private static void FDCT_Scalar(ref Block8x8F block)
         {
             const int dctSize = 8;
 
@@ -130,17 +233,17 @@ namespace SixLabors.ImageSharp.Formats.Jpeg.Components
             float z1, z2, z3, z4, z5, z11, z13;
 
             // First pass - process rows
-            ref float dataRef = ref Unsafe.As<Block8x8F, float>(ref block);
+            ref float blockRef = ref Unsafe.As<Block8x8F, float>(ref block);
             for (int ctr = 7; ctr >= 0; ctr--)
             {
-                tmp0 = Unsafe.Add(ref dataRef, 0) + Unsafe.Add(ref dataRef, 7);
-                tmp7 = Unsafe.Add(ref dataRef, 0) - Unsafe.Add(ref dataRef, 7);
-                tmp1 = Unsafe.Add(ref dataRef, 1) + Unsafe.Add(ref dataRef, 6);
-                tmp6 = Unsafe.Add(ref dataRef, 1) - Unsafe.Add(ref dataRef, 6);
-                tmp2 = Unsafe.Add(ref dataRef, 2) + Unsafe.Add(ref dataRef, 5);
-                tmp5 = Unsafe.Add(ref dataRef, 2) - Unsafe.Add(ref dataRef, 5);
-                tmp3 = Unsafe.Add(ref dataRef, 3) + Unsafe.Add(ref dataRef, 4);
-                tmp4 = Unsafe.Add(ref dataRef, 3) - Unsafe.Add(ref dataRef, 4);
+                tmp0 = Unsafe.Add(ref blockRef, 0) + Unsafe.Add(ref blockRef, 7);
+                tmp7 = Unsafe.Add(ref blockRef, 0) - Unsafe.Add(ref blockRef, 7);
+                tmp1 = Unsafe.Add(ref blockRef, 1) + Unsafe.Add(ref blockRef, 6);
+                tmp6 = Unsafe.Add(ref blockRef, 1) - Unsafe.Add(ref blockRef, 6);
+                tmp2 = Unsafe.Add(ref blockRef, 2) + Unsafe.Add(ref blockRef, 5);
+                tmp5 = Unsafe.Add(ref blockRef, 2) - Unsafe.Add(ref blockRef, 5);
+                tmp3 = Unsafe.Add(ref blockRef, 3) + Unsafe.Add(ref blockRef, 4);
+                tmp4 = Unsafe.Add(ref blockRef, 3) - Unsafe.Add(ref blockRef, 4);
 
                 // Even part
                 tmp10 = tmp0 + tmp3;
@@ -148,12 +251,12 @@ namespace SixLabors.ImageSharp.Formats.Jpeg.Components
                 tmp11 = tmp1 + tmp2;
                 tmp12 = tmp1 - tmp2;
 
-                Unsafe.Add(ref dataRef, 0) = tmp10 + tmp11;
-                Unsafe.Add(ref dataRef, 4) = tmp10 - tmp11;
+                Unsafe.Add(ref blockRef, 0) = tmp10 + tmp11;
+                Unsafe.Add(ref blockRef, 4) = tmp10 - tmp11;
 
                 z1 = (tmp12 + tmp13) * 0.707106781f;
-                Unsafe.Add(ref dataRef, 2) = tmp13 + z1;
-                Unsafe.Add(ref dataRef, 6) = tmp13 - z1;
+                Unsafe.Add(ref blockRef, 2) = tmp13 + z1;
+                Unsafe.Add(ref blockRef, 6) = tmp13 - z1;
 
                 // Odd part
                 tmp10 = tmp4 + tmp5;
@@ -168,26 +271,26 @@ namespace SixLabors.ImageSharp.Formats.Jpeg.Components
                 z11 = tmp7 + z3;
                 z13 = tmp7 - z3;
 
-                Unsafe.Add(ref dataRef, 5) = z13 + z2;
-                Unsafe.Add(ref dataRef, 3) = z13 - z2;
-                Unsafe.Add(ref dataRef, 1) = z11 + z4;
-                Unsafe.Add(ref dataRef, 7) = z11 - z4;
+                Unsafe.Add(ref blockRef, 5) = z13 + z2;
+                Unsafe.Add(ref blockRef, 3) = z13 - z2;
+                Unsafe.Add(ref blockRef, 1) = z11 + z4;
+                Unsafe.Add(ref blockRef, 7) = z11 - z4;
 
-                dataRef = ref Unsafe.Add(ref dataRef, dctSize);
+                blockRef = ref Unsafe.Add(ref blockRef, dctSize);
             }
 
             // Second pass - process columns
-            dataRef = ref Unsafe.As<Block8x8F, float>(ref block);
+            blockRef = ref Unsafe.As<Block8x8F, float>(ref block);
             for (int ctr = 7; ctr >= 0; ctr--)
             {
-                tmp0 = Unsafe.Add(ref dataRef, dctSize * 0) + Unsafe.Add(ref dataRef, dctSize * 7);
-                tmp7 = Unsafe.Add(ref dataRef, dctSize * 0) - Unsafe.Add(ref dataRef, dctSize * 7);
-                tmp1 = Unsafe.Add(ref dataRef, dctSize * 1) + Unsafe.Add(ref dataRef, dctSize * 6);
-                tmp6 = Unsafe.Add(ref dataRef, dctSize * 1) - Unsafe.Add(ref dataRef, dctSize * 6);
-                tmp2 = Unsafe.Add(ref dataRef, dctSize * 2) + Unsafe.Add(ref dataRef, dctSize * 5);
-                tmp5 = Unsafe.Add(ref dataRef, dctSize * 2) - Unsafe.Add(ref dataRef, dctSize * 5);
-                tmp3 = Unsafe.Add(ref dataRef, dctSize * 3) + Unsafe.Add(ref dataRef, dctSize * 4);
-                tmp4 = Unsafe.Add(ref dataRef, dctSize * 3) - Unsafe.Add(ref dataRef, dctSize * 4);
+                tmp0 = Unsafe.Add(ref blockRef, dctSize * 0) + Unsafe.Add(ref blockRef, dctSize * 7);
+                tmp7 = Unsafe.Add(ref blockRef, dctSize * 0) - Unsafe.Add(ref blockRef, dctSize * 7);
+                tmp1 = Unsafe.Add(ref blockRef, dctSize * 1) + Unsafe.Add(ref blockRef, dctSize * 6);
+                tmp6 = Unsafe.Add(ref blockRef, dctSize * 1) - Unsafe.Add(ref blockRef, dctSize * 6);
+                tmp2 = Unsafe.Add(ref blockRef, dctSize * 2) + Unsafe.Add(ref blockRef, dctSize * 5);
+                tmp5 = Unsafe.Add(ref blockRef, dctSize * 2) - Unsafe.Add(ref blockRef, dctSize * 5);
+                tmp3 = Unsafe.Add(ref blockRef, dctSize * 3) + Unsafe.Add(ref blockRef, dctSize * 4);
+                tmp4 = Unsafe.Add(ref blockRef, dctSize * 3) - Unsafe.Add(ref blockRef, dctSize * 4);
 
                 // Even part
                 tmp10 = tmp0 + tmp3;
@@ -195,12 +298,12 @@ namespace SixLabors.ImageSharp.Formats.Jpeg.Components
                 tmp11 = tmp1 + tmp2;
                 tmp12 = tmp1 - tmp2;
 
-                Unsafe.Add(ref dataRef, dctSize * 0) = tmp10 + tmp11;
-                Unsafe.Add(ref dataRef, dctSize * 4) = tmp10 - tmp11;
+                Unsafe.Add(ref blockRef, dctSize * 0) = tmp10 + tmp11;
+                Unsafe.Add(ref blockRef, dctSize * 4) = tmp10 - tmp11;
 
                 z1 = (tmp12 + tmp13) * 0.707106781f;
-                Unsafe.Add(ref dataRef, dctSize * 2) = tmp13 + z1;
-                Unsafe.Add(ref dataRef, dctSize * 6) = tmp13 - z1;
+                Unsafe.Add(ref blockRef, dctSize * 2) = tmp13 + z1;
+                Unsafe.Add(ref blockRef, dctSize * 6) = tmp13 - z1;
 
                 // Odd part
                 tmp10 = tmp4 + tmp5;
@@ -215,12 +318,12 @@ namespace SixLabors.ImageSharp.Formats.Jpeg.Components
                 z11 = tmp7 + z3;
                 z13 = tmp7 - z3;
 
-                Unsafe.Add(ref dataRef, dctSize * 5) = z13 + z2;
-                Unsafe.Add(ref dataRef, dctSize * 3) = z13 - z2;
-                Unsafe.Add(ref dataRef, dctSize * 1) = z11 + z4;
-                Unsafe.Add(ref dataRef, dctSize * 7) = z11 - z4;
+                Unsafe.Add(ref blockRef, dctSize * 5) = z13 + z2;
+                Unsafe.Add(ref blockRef, dctSize * 3) = z13 - z2;
+                Unsafe.Add(ref blockRef, dctSize * 1) = z11 + z4;
+                Unsafe.Add(ref blockRef, dctSize * 7) = z11 - z4;
 
-                dataRef = ref Unsafe.Add(ref dataRef, 1);
+                blockRef = ref Unsafe.Add(ref blockRef, 1);
             }
         }
 
@@ -230,11 +333,11 @@ namespace SixLabors.ImageSharp.Formats.Jpeg.Components
         /// <remarks>
         /// This implementation must be called only if hardware supports 4
         /// floating point numbers vector. Otherwise explicit scalar
-        /// implementation <see cref="ForwardTransform_Scalar"/> is faster
-        /// because it does not rely on matrix transposition.
+        /// implementation <see cref="FDCT_Scalar"/> is faster
+        /// because it does not rely on block transposition.
         /// </remarks>
-        /// <param name="block">Input matrix.</param>
-        private static void ForwardTransform_Vector4(ref Block8x8F block)
+        /// <param name="block">Input block.</param>
+        public static void FDCT_Vector4(ref Block8x8F block)
         {
             DebugGuard.IsTrue(Vector.IsHardwareAccelerated, "Scalar implementation should be called for non-accelerated hardware.");
 
@@ -247,209 +350,50 @@ namespace SixLabors.ImageSharp.Formats.Jpeg.Components
             block.TransposeInplace();
             FDCT8x4_Vector4(ref block.V0L);
             FDCT8x4_Vector4(ref block.V0R);
-        }
 
-        /// <summary>
-        /// Apply 1D floating point FDCT inplace on 8x4 part of 8x8 matrix.
-        /// </summary>
-        /// <remarks>
-        /// Implemented using Vector4 API operations for either scalar or sse hardware implementation.
-        /// Must be called on both 8x4 matrix parts for the full FDCT transform.
-        /// </remarks>
-        /// <param name="blockRef">Input reference to the first </param>
-        private static void FDCT8x4_Vector4(ref Vector4 blockRef)
-        {
-            Vector4 tmp0 = Unsafe.Add(ref blockRef, 0) + Unsafe.Add(ref blockRef, 14);
-            Vector4 tmp7 = Unsafe.Add(ref blockRef, 0) - Unsafe.Add(ref blockRef, 14);
-            Vector4 tmp1 = Unsafe.Add(ref blockRef, 2) + Unsafe.Add(ref blockRef, 12);
-            Vector4 tmp6 = Unsafe.Add(ref blockRef, 2) - Unsafe.Add(ref blockRef, 12);
-            Vector4 tmp2 = Unsafe.Add(ref blockRef, 4) + Unsafe.Add(ref blockRef, 10);
-            Vector4 tmp5 = Unsafe.Add(ref blockRef, 4) - Unsafe.Add(ref blockRef, 10);
-            Vector4 tmp3 = Unsafe.Add(ref blockRef, 6) + Unsafe.Add(ref blockRef, 8);
-            Vector4 tmp4 = Unsafe.Add(ref blockRef, 6) - Unsafe.Add(ref blockRef, 8);
-
-            // Even part
-            Vector4 tmp10 = tmp0 + tmp3;
-            Vector4 tmp13 = tmp0 - tmp3;
-            Vector4 tmp11 = tmp1 + tmp2;
-            Vector4 tmp12 = tmp1 - tmp2;
-
-            Unsafe.Add(ref blockRef, 0) = tmp10 + tmp11;
-            Unsafe.Add(ref blockRef, 8) = tmp10 - tmp11;
-
-            Vector4 z1 = (tmp12 + tmp13) * mm128_F_0_7071;
-            Unsafe.Add(ref blockRef, 4) = tmp13 + z1;
-            Unsafe.Add(ref blockRef, 12) = tmp13 - z1;
-
-            // Odd part
-            tmp10 = tmp4 + tmp5;
-            tmp11 = tmp5 + tmp6;
-            tmp12 = tmp6 + tmp7;
-
-            Vector4 z5 = (tmp10 - tmp12) * mm128_F_0_3826;
-            Vector4 z2 = (mm128_F_0_5411 * tmp10) + z5;
-            Vector4 z4 = (mm128_F_1_3065 * tmp12) + z5;
-            Vector4 z3 = tmp11 * mm128_F_0_7071;
-
-            Vector4 z11 = tmp7 + z3;
-            Vector4 z13 = tmp7 - z3;
-
-            Unsafe.Add(ref blockRef, 10) = z13 + z2;
-            Unsafe.Add(ref blockRef, 6) = z13 - z2;
-            Unsafe.Add(ref blockRef, 2) = z11 + z4;
-            Unsafe.Add(ref blockRef, 14) = z11 - z4;
-        }
+            // Applies 1D floating point FDCT inplace on 8x4 part of 8x8 block
+            static void FDCT8x4_Vector4(ref Vector4 vecRef)
+            {
+                Vector4 tmp0 = Unsafe.Add(ref vecRef, 0) + Unsafe.Add(ref vecRef, 14);
+                Vector4 tmp7 = Unsafe.Add(ref vecRef, 0) - Unsafe.Add(ref vecRef, 14);
+                Vector4 tmp1 = Unsafe.Add(ref vecRef, 2) + Unsafe.Add(ref vecRef, 12);
+                Vector4 tmp6 = Unsafe.Add(ref vecRef, 2) - Unsafe.Add(ref vecRef, 12);
+                Vector4 tmp2 = Unsafe.Add(ref vecRef, 4) + Unsafe.Add(ref vecRef, 10);
+                Vector4 tmp5 = Unsafe.Add(ref vecRef, 4) - Unsafe.Add(ref vecRef, 10);
+                Vector4 tmp3 = Unsafe.Add(ref vecRef, 6) + Unsafe.Add(ref vecRef, 8);
+                Vector4 tmp4 = Unsafe.Add(ref vecRef, 6) - Unsafe.Add(ref vecRef, 8);
 
-        /// <summary>
-        /// Apply floating point IDCT inplace.
-        /// Ported from https://github.com/norishigefukushima/dct_simd/blob/master/dct/dct8x8_simd.cpp#L239.
-        /// </summary>
-        /// <param name="block">Input matrix.</param>
-        /// <param name="temp">Matrix to store temporal results.</param>
-        public static void TransformIDCT(ref Block8x8F block, ref Block8x8F temp)
-        {
-            block.TransposeInplace();
-            IDCT8x8(ref block, ref temp);
-            temp.TransposeInplace();
-            IDCT8x8(ref temp, ref block);
+                // Even part
+                Vector4 tmp10 = tmp0 + tmp3;
+                Vector4 tmp13 = tmp0 - tmp3;
+                Vector4 tmp11 = tmp1 + tmp2;
+                Vector4 tmp12 = tmp1 - tmp2;
 
-            // TODO: This can be fused into quantization table step
-            block.MultiplyInPlace(C_0_125);
-        }
+                Unsafe.Add(ref vecRef, 0) = tmp10 + tmp11;
+                Unsafe.Add(ref vecRef, 8) = tmp10 - tmp11;
 
-        /// <summary>
-        /// Performs 8x8 matrix Inverse Discrete Cosine Transform
-        /// </summary>
-        /// <param name="s">Source</param>
-        /// <param name="d">Destination</param>
-        private static void IDCT8x8(ref Block8x8F s, ref Block8x8F d)
-        {
-#if SUPPORTS_RUNTIME_INTRINSICS
-            if (Avx.IsSupported)
-            {
-                IDCT8x8_Avx(ref s, ref d);
-            }
-            else
-#endif
-            {
-                IDCT8x4_LeftPart(ref s, ref d);
-                IDCT8x4_RightPart(ref s, ref d);
-            }
-        }
+                Vector4 z1 = (tmp12 + tmp13) * mm128_F_0_7071;
+                Unsafe.Add(ref vecRef, 4) = tmp13 + z1;
+                Unsafe.Add(ref vecRef, 12) = tmp13 - z1;
 
-        /// <summary>
-        /// Do IDCT internal operations on the left part of the block. Original src:
-        /// https://github.com/norishigefukushima/dct_simd/blob/master/dct/dct8x8_simd.cpp#L261
-        /// </summary>
-        /// <param name="s">The source block</param>
-        /// <param name="d">Destination block</param>
-        [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public static void IDCT8x4_LeftPart(ref Block8x8F s, ref Block8x8F d)
-        {
-            Vector4 my1 = s.V1L;
-            Vector4 my7 = s.V7L;
-            Vector4 mz0 = my1 + my7;
-
-            Vector4 my3 = s.V3L;
-            Vector4 mz2 = my3 + my7;
-            Vector4 my5 = s.V5L;
-            Vector4 mz1 = my3 + my5;
-            Vector4 mz3 = my1 + my5;
-
-            Vector4 mz4 = (mz0 + mz1) * C_1_175876;
-
-            mz2 = (mz2 * C_1_961571) + mz4;
-            mz3 = (mz3 * C_0_390181) + mz4;
-            mz0 = mz0 * C_0_899976;
-            mz1 = mz1 * C_2_562915;
-
-            Vector4 mb3 = (my7 * C_0_298631) + mz0 + mz2;
-            Vector4 mb2 = (my5 * C_2_053120) + mz1 + mz3;
-            Vector4 mb1 = (my3 * C_3_072711) + mz1 + mz2;
-            Vector4 mb0 = (my1 * C_1_501321) + mz0 + mz3;
-
-            Vector4 my2 = s.V2L;
-            Vector4 my6 = s.V6L;
-            mz4 = (my2 + my6) * C_0_541196;
-            Vector4 my0 = s.V0L;
-            Vector4 my4 = s.V4L;
-            mz0 = my0 + my4;
-            mz1 = my0 - my4;
-
-            mz2 = mz4 + (my6 * C_1_847759);
-            mz3 = mz4 + (my2 * C_0_765367);
-
-            my0 = mz0 + mz3;
-            my3 = mz0 - mz3;
-            my1 = mz1 + mz2;
-            my2 = mz1 - mz2;
-
-            d.V0L = my0 + mb0;
-            d.V7L = my0 - mb0;
-            d.V1L = my1 + mb1;
-            d.V6L = my1 - mb1;
-            d.V2L = my2 + mb2;
-            d.V5L = my2 - mb2;
-            d.V3L = my3 + mb3;
-            d.V4L = my3 - mb3;
-        }
+                // Odd part
+                tmp10 = tmp4 + tmp5;
+                tmp11 = tmp5 + tmp6;
+                tmp12 = tmp6 + tmp7;
 
-        /// <summary>
-        /// Do IDCT internal operations on the right part of the block.
-        /// Original src:
-        /// https://github.com/norishigefukushima/dct_simd/blob/master/dct/dct8x8_simd.cpp#L261
-        /// </summary>
-        /// <param name="s">The source block</param>
-        /// <param name="d">The destination block</param>
-        [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public static void IDCT8x4_RightPart(ref Block8x8F s, ref Block8x8F d)
-        {
-            Vector4 my1 = s.V1R;
-            Vector4 my7 = s.V7R;
-            Vector4 mz0 = my1 + my7;
-
-            Vector4 my3 = s.V3R;
-            Vector4 mz2 = my3 + my7;
-            Vector4 my5 = s.V5R;
-            Vector4 mz1 = my3 + my5;
-            Vector4 mz3 = my1 + my5;
-
-            Vector4 mz4 = (mz0 + mz1) * C_1_175876;
-
-            mz2 = (mz2 * C_1_961571) + mz4;
-            mz3 = (mz3 * C_0_390181) + mz4;
-            mz0 = mz0 * C_0_899976;
-            mz1 = mz1 * C_2_562915;
-
-            Vector4 mb3 = (my7 * C_0_298631) + mz0 + mz2;
-            Vector4 mb2 = (my5 * C_2_053120) + mz1 + mz3;
-            Vector4 mb1 = (my3 * C_3_072711) + mz1 + mz2;
-            Vector4 mb0 = (my1 * C_1_501321) + mz0 + mz3;
-
-            Vector4 my2 = s.V2R;
-            Vector4 my6 = s.V6R;
-            mz4 = (my2 + my6) * C_0_541196;
-            Vector4 my0 = s.V0R;
-            Vector4 my4 = s.V4R;
-            mz0 = my0 + my4;
-            mz1 = my0 - my4;
-
-            mz2 = mz4 + (my6 * C_1_847759);
-            mz3 = mz4 + (my2 * C_0_765367);
-
-            my0 = mz0 + mz3;
-            my3 = mz0 - mz3;
-            my1 = mz1 + mz2;
-            my2 = mz1 - mz2;
-
-            d.V0R = my0 + mb0;
-            d.V7R = my0 - mb0;
-            d.V1R = my1 + mb1;
-            d.V6R = my1 - mb1;
-            d.V2R = my2 + mb2;
-            d.V5R = my2 - mb2;
-            d.V3R = my3 + mb3;
-            d.V4R = my3 - mb3;
+                Vector4 z5 = (tmp10 - tmp12) * mm128_F_0_3826;
+                Vector4 z2 = (mm128_F_0_5411 * tmp10) + z5;
+                Vector4 z4 = (mm128_F_1_3065 * tmp12) + z5;
+                Vector4 z3 = tmp11 * mm128_F_0_7071;
+
+                Vector4 z11 = tmp7 + z3;
+                Vector4 z13 = tmp7 - z3;
+
+                Unsafe.Add(ref vecRef, 10) = z13 + z2;
+                Unsafe.Add(ref vecRef, 6) = z13 - z2;
+                Unsafe.Add(ref vecRef, 2) = z11 + z4;
+                Unsafe.Add(ref vecRef, 14) = z11 - z4;
+            }
         }
     }
 }

src/ImageSharp/Formats/Jpeg/Components/GenericBlock8x8.Generated.cs

@@ -1,23 +0,0 @@
-// Copyright (c) Six Labors.
-// Licensed under the Apache License, Version 2.0.
-
-// <auto-generated />
-namespace SixLabors.ImageSharp.Formats.Jpeg.Components
-{
-	internal unsafe partial struct GenericBlock8x8<T>
-    {
-        #pragma warning disable 169
-
-        // It's not allowed use fix-sized buffers with generics, need to place all the fields manually:
-        private T _y0_x0, _y0_x1, _y0_x2, _y0_x3, _y0_x4, _y0_x5, _y0_x6, _y0_x7;
-        private T _y1_x0, _y1_x1, _y1_x2, _y1_x3, _y1_x4, _y1_x5, _y1_x6, _y1_x7;
-        private T _y2_x0, _y2_x1, _y2_x2, _y2_x3, _y2_x4, _y2_x5, _y2_x6, _y2_x7;
-        private T _y3_x0, _y3_x1, _y3_x2, _y3_x3, _y3_x4, _y3_x5, _y3_x6, _y3_x7;
-        private T _y4_x0, _y4_x1, _y4_x2, _y4_x3, _y4_x4, _y4_x5, _y4_x6, _y4_x7;
-        private T _y5_x0, _y5_x1, _y5_x2, _y5_x3, _y5_x4, _y5_x5, _y5_x6, _y5_x7;
-        private T _y6_x0, _y6_x1, _y6_x2, _y6_x3, _y6_x4, _y6_x5, _y6_x6, _y6_x7;
-        private T _y7_x0, _y7_x1, _y7_x2, _y7_x3, _y7_x4, _y7_x5, _y7_x6, _y7_x7;
-
-        #pragma warning restore 169
-	}
-}

src/ImageSharp/Formats/Jpeg/Components/GenericBlock8x8.cs

@@ -1,122 +0,0 @@
-// Copyright (c) Six Labors.
-// Licensed under the Apache License, Version 2.0.
-
-using System;
-using System.Runtime.CompilerServices;
-using System.Runtime.InteropServices;
-using SixLabors.ImageSharp.Memory;
-using SixLabors.ImageSharp.PixelFormats;
-
-// ReSharper disable InconsistentNaming
-namespace SixLabors.ImageSharp.Formats.Jpeg.Components
-{
-    /// <summary>
-    /// A generic 8x8 block implementation, useful for manipulating custom 8x8 pixel data.
-    /// </summary>
-    [StructLayout(LayoutKind.Sequential)]
-    internal unsafe partial struct GenericBlock8x8<T>
-        where T : unmanaged
-    {
-        public const int Size = 64;
-
-        /// <summary>
-        /// FOR TESTING ONLY!
-        /// Gets or sets a <see cref="Rgb24"/> value at the given index
-        /// </summary>
-        /// <param name="idx">The index</param>
-        /// <returns>The value</returns>
-        public T this[int idx]
-        {
-            get
-            {
-                ref T selfRef = ref Unsafe.As<GenericBlock8x8<T>, T>(ref this);
-                return Unsafe.Add(ref selfRef, idx);
-            }
-
-            set
-            {
-                ref T selfRef = ref Unsafe.As<GenericBlock8x8<T>, T>(ref this);
-                Unsafe.Add(ref selfRef, idx) = value;
-            }
-        }
-
-        /// <summary>
-        /// FOR TESTING ONLY!
-        /// Gets or sets a value in a row+column of the 8x8 block
-        /// </summary>
-        /// <param name="x">The x position index in the row</param>
-        /// <param name="y">The column index</param>
-        /// <returns>The value</returns>
-        public T this[int x, int y]
-        {
-            get => this[(y * 8) + x];
-            set => this[(y * 8) + x] = value;
-        }
-
-        /// <summary>
-        /// Load a 8x8 region of an image into the block.
-        /// The "outlying" area of the block will be stretched out with pixels on the right and bottom edge of the image.
-        /// </summary>
-        public void LoadAndStretchEdges(Buffer2D<T> source, int sourceX, int sourceY, ref RowOctet<T> currentRows)
-        {
-            int width = Math.Min(8, source.Width - sourceX);
-            int height = Math.Min(8, source.Height - sourceY);
-
-            if (width <= 0 || height <= 0)
-            {
-                return;
-            }
-
-            uint byteWidth = (uint)width * (uint)Unsafe.SizeOf<T>();
-            int remainderXCount = 8 - width;
-
-            ref byte blockStart = ref Unsafe.As<GenericBlock8x8<T>, byte>(ref this);
-            int blockRowSizeInBytes = 8 * Unsafe.SizeOf<T>();
-
-            for (int y = 0; y < height; y++)
-            {
-                Span<T> row = currentRows[y];
-
-                ref byte s = ref Unsafe.As<T, byte>(ref row[sourceX]);
-                ref byte d = ref Unsafe.Add(ref blockStart, y * blockRowSizeInBytes);
-
-                Unsafe.CopyBlock(ref d, ref s, byteWidth);
-
-                ref T last = ref Unsafe.Add(ref Unsafe.As<byte, T>(ref d), width - 1);
-
-                for (int x = 1; x <= remainderXCount; x++)
-                {
-                    Unsafe.Add(ref last, x) = last;
-                }
-            }
-
-            int remainderYCount = 8 - height;
-
-            if (remainderYCount == 0)
-            {
-                return;
-            }
-
-            ref byte lastRowStart = ref Unsafe.Add(ref blockStart, (height - 1) * blockRowSizeInBytes);
-
-            for (int y = 1; y <= remainderYCount; y++)
-            {
-                ref byte remStart = ref Unsafe.Add(ref lastRowStart, blockRowSizeInBytes * y);
-                Unsafe.CopyBlock(ref remStart, ref lastRowStart, (uint)blockRowSizeInBytes);
-            }
-        }
-
-        /// <summary>
-        /// Only for on-stack instances!
-        /// </summary>
-        public Span<T> AsSpanUnsafe()
-        {
-#if SUPPORTS_CREATESPAN
-            Span<GenericBlock8x8<T>> s = MemoryMarshal.CreateSpan(ref this, 1);
-            return MemoryMarshal.Cast<GenericBlock8x8<T>, T>(s);
-#else
-            return new Span<T>(Unsafe.AsPointer(ref this), Size);
-#endif
-        }
-    }
-}

src/ImageSharp/Formats/Jpeg/Components/RowOctet.cs

@@ -86,7 +86,7 @@ namespace SixLabors.ImageSharp.Formats.Jpeg.Components
             int i = 0;
             while (y < yEnd)
             {
-                this[i++] = buffer.GetRowSpan(y++);
+                this[i++] = buffer.DangerousGetRowSpan(y++);
             }
         }
 

src/ImageSharp/Formats/Jpeg/Components/ZigZag.cs

@@ -35,5 +35,34 @@ namespace SixLabors.ImageSharp.Formats.Jpeg.Components
             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.
+        /// </summary>
+        /// <remarks>
+        /// When reading corrupted data, the Huffman decoders could attempt
+        /// to reference an entry beyond the end of this array (if the decoded
+        /// zero run length reaches past the end of the block).  To prevent
+        /// wild stores without adding an inner-loop test, we put some extra
+        /// "63"s after the real entries.  This will cause the extra coefficient
+        /// to be stored in location 63 of the block, not somewhere random.
+        /// 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[]
+        {
+            0,  8,  1,  2,  9,  16, 24, 17,
+            10, 3,  4,  11, 18, 25, 32, 40,
+            33, 26, 19, 12, 5,  6,  13, 20,
+            27, 34, 41, 48, 56, 49, 42, 35,
+            28, 21, 14, 7,  15, 22, 29, 36,
+            43, 50, 57, 58, 51, 44, 37, 30,
+            23, 31, 38, 45, 52, 59, 60, 53,
+            46, 39, 47, 54, 61, 62, 55, 63,
+
+            // Extra entries for safety in decoder
+            63, 63, 63, 63, 63, 63, 63, 63,
+            63, 63, 63, 63, 63, 63, 63, 63
+        };
     }
 }

src/ImageSharp/Formats/Jpeg/JpegDecoder.cs

@@ -42,7 +42,7 @@ namespace SixLabors.ImageSharp.Formats.Jpeg
 
         /// <inheritdoc />
         public async Task<Image> DecodeAsync(Configuration configuration, Stream stream, CancellationToken cancellationToken)
-            => await this.DecodeAsync<Rgba32>(configuration, stream, cancellationToken)
+            => await this.DecodeAsync<Rgb24>(configuration, stream, cancellationToken)
             .ConfigureAwait(false);
 
         /// <inheritdoc/>

src/ImageSharp/Formats/Jpeg/JpegDecoderCore.cs

@@ -17,6 +17,7 @@ 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;
 using SixLabors.ImageSharp.PixelFormats;
 
 namespace SixLabors.ImageSharp.Formats.Jpeg
@@ -46,7 +47,7 @@ namespace SixLabors.ImageSharp.Formats.Jpeg
         /// <summary>
         /// Whether the image has an EXIF marker.
         /// </summary>
-        private bool isExif;
+        private bool hasExif;
 
         /// <summary>
         /// Contains exif data.
@@ -56,7 +57,7 @@ namespace SixLabors.ImageSharp.Formats.Jpeg
         /// <summary>
         /// Whether the image has an ICC marker.
         /// </summary>
-        private bool isIcc;
+        private bool hasIcc;
 
         /// <summary>
         /// Contains ICC data.
@@ -66,13 +67,23 @@ namespace SixLabors.ImageSharp.Formats.Jpeg
         /// <summary>
         /// Whether the image has a IPTC data.
         /// </summary>
-        private bool isIptc;
+        private bool hasIptc;
 
         /// <summary>
         /// Contains IPTC data.
         /// </summary>
         private byte[] iptcData;
 
+        /// <summary>
+        /// Whether the image has a XMP data.
+        /// </summary>
+        private bool hasXmp;
+
+        /// <summary>
+        /// Contains XMP data.
+        /// </summary>
+        private byte[] xmpData;
+
         /// <summary>
         /// Contains information about the JFIF marker.
         /// </summary>
@@ -175,7 +186,7 @@ namespace SixLabors.ImageSharp.Formats.Jpeg
         public Image<TPixel> Decode<TPixel>(BufferedReadStream stream, CancellationToken cancellationToken)
             where TPixel : unmanaged, IPixel<TPixel>
         {
-            using var spectralConverter = new SpectralConverter<TPixel>(this.Configuration, cancellationToken);
+            using var spectralConverter = new SpectralConverter<TPixel>(this.Configuration);
 
             var scanDecoder = new HuffmanScanDecoder(stream, spectralConverter, cancellationToken);
 
@@ -183,9 +194,13 @@ namespace SixLabors.ImageSharp.Formats.Jpeg
             this.InitExifProfile();
             this.InitIccProfile();
             this.InitIptcProfile();
+            this.InitXmpProfile();
             this.InitDerivedMetadataProperties();
 
-            return new Image<TPixel>(this.Configuration, spectralConverter.GetPixelBuffer(), this.Metadata);
+            return new Image<TPixel>(
+                this.Configuration,
+                spectralConverter.GetPixelBuffer(cancellationToken),
+                this.Metadata);
         }
 
         /// <inheritdoc/>
@@ -195,6 +210,7 @@ namespace SixLabors.ImageSharp.Formats.Jpeg
             this.InitExifProfile();
             this.InitIccProfile();
             this.InitIptcProfile();
+            this.InitXmpProfile();
             this.InitDerivedMetadataProperties();
 
             Size pixelSize = this.Frame.PixelSize;
@@ -469,7 +485,7 @@ namespace SixLabors.ImageSharp.Formats.Jpeg
                     : JpegColorSpace.Cmyk;
             }
 
-            JpegThrowHelper.ThrowInvalidImageContentException($"Unsupported color mode. Supported component counts 1, 3, and 4; found {componentCount}");
+            JpegThrowHelper.ThrowNotSupportedComponentCount(componentCount);
             return default;
         }
 
@@ -536,7 +552,7 @@ namespace SixLabors.ImageSharp.Formats.Jpeg
         /// </summary>
         private void InitExifProfile()
         {
-            if (this.isExif)
+            if (this.hasExif)
             {
                 this.Metadata.ExifProfile = new ExifProfile(this.exifData);
             }
@@ -547,7 +563,7 @@ namespace SixLabors.ImageSharp.Formats.Jpeg
         /// </summary>
         private void InitIccProfile()
         {
-            if (this.isIcc)
+            if (this.hasIcc)
             {
                 var profile = new IccProfile(this.iccData);
                 if (profile.CheckIsValid())
@@ -562,13 +578,25 @@ namespace SixLabors.ImageSharp.Formats.Jpeg
         /// </summary>
         private void InitIptcProfile()
         {
-            if (this.isIptc)
+            if (this.hasIptc)
             {
                 var profile = new IptcProfile(this.iptcData);
                 this.Metadata.IptcProfile = profile;
             }
         }
 
+        /// <summary>
+        /// Initializes the XMP profile.
+        /// </summary>
+        private void InitXmpProfile()
+        {
+            if (this.hasXmp)
+            {
+                var profile = new XmpProfile(this.xmpData);
+                this.Metadata.XmpProfile = profile;
+            }
+        }
+
         /// <summary>
         /// Assigns derived metadata properties to <see cref="Metadata"/>, eg. horizontal and vertical resolution if it has a JFIF header.
         /// </summary>
@@ -580,7 +608,7 @@ namespace SixLabors.ImageSharp.Formats.Jpeg
                 this.Metadata.VerticalResolution = this.jFif.YDensity;
                 this.Metadata.ResolutionUnits = this.jFif.DensityUnits;
             }
-            else if (this.isExif)
+            else if (this.hasExif)
             {
                 double horizontalValue = this.GetExifResolutionValue(ExifTag.XResolution);
                 double verticalValue = this.GetExifResolutionValue(ExifTag.YResolution);
@@ -622,7 +650,9 @@ namespace SixLabors.ImageSharp.Formats.Jpeg
         private void ProcessApplicationHeaderMarker(BufferedReadStream stream, int remaining)
         {
             // We can only decode JFif identifiers.
-            if (remaining < JFifMarker.Length)
+            // Some images contain multiple JFIF markers (Issue 1932) so we check to see
+            // if it's already been read.
+            if (remaining < JFifMarker.Length || (!this.jFif.Equals(default)))
             {
                 // Skip the application header length
                 stream.Skip(remaining);
@@ -653,8 +683,9 @@ namespace SixLabors.ImageSharp.Formats.Jpeg
         /// <param name="remaining">The remaining bytes in the segment block.</param>
         private void ProcessApp1Marker(BufferedReadStream stream, int remaining)
         {
-            const int Exif00 = 6;
-            if (remaining < Exif00 || this.IgnoreMetadata)
+            const int ExifMarkerLength = 6;
+            const int XmpMarkerLength = 29;
+            if (remaining < ExifMarkerLength || this.IgnoreMetadata)
             {
                 // Skip the application header length
                 stream.Skip(remaining);
@@ -666,23 +697,55 @@ namespace SixLabors.ImageSharp.Formats.Jpeg
                 JpegThrowHelper.ThrowInvalidImageContentException("Bad App1 Marker length.");
             }
 
-            byte[] profile = new byte[remaining];
-            stream.Read(profile, 0, remaining);
+            // XMP marker is the longest, so read at least that many bytes into temp.
+            stream.Read(this.temp, 0, ExifMarkerLength);
 
-            if (ProfileResolver.IsProfile(profile, ProfileResolver.ExifMarker))
+            if (ProfileResolver.IsProfile(this.temp, ProfileResolver.ExifMarker))
             {
-                this.isExif = true;
+                remaining -= ExifMarkerLength;
+                this.hasExif = true;
+                byte[] profile = new byte[remaining];
+                stream.Read(profile, 0, remaining);
+
                 if (this.exifData is null)
                 {
-                    // The first 6 bytes (Exif00) will be skipped, because this is Jpeg specific
-                    this.exifData = profile.AsSpan(Exif00).ToArray();
+                    this.exifData = profile;
                 }
                 else
                 {
                     // If the EXIF information exceeds 64K, it will be split over multiple APP1 markers
-                    this.ExtendProfile(ref this.exifData, profile.AsSpan(Exif00).ToArray());
+                    this.ExtendProfile(ref this.exifData, profile);
+                }
+
+                remaining = 0;
+            }
+
+            if (ProfileResolver.IsProfile(this.temp, ProfileResolver.XmpMarker.Slice(0, ExifMarkerLength)))
+            {
+                stream.Read(this.temp, 0, XmpMarkerLength - ExifMarkerLength);
+                remaining -= XmpMarkerLength;
+                if (ProfileResolver.IsProfile(this.temp, ProfileResolver.XmpMarker.Slice(ExifMarkerLength)))
+                {
+                    this.hasXmp = true;
+                    byte[] profile = new byte[remaining];
+                    stream.Read(profile, 0, remaining);
+
+                    if (this.xmpData is null)
+                    {
+                        this.xmpData = profile;
+                    }
+                    else
+                    {
+                        // If the XMP information exceeds 64K, it will be split over multiple APP1 markers
+                        this.ExtendProfile(ref this.xmpData, profile);
+                    }
+
+                    remaining = 0;
                 }
             }
+
+            // Skip over any remaining bytes of this header.
+            stream.Skip(remaining);
         }
 
         /// <summary>
@@ -706,7 +769,7 @@ namespace SixLabors.ImageSharp.Formats.Jpeg
 
             if (ProfileResolver.IsProfile(identifier, ProfileResolver.IccMarker))
             {
-                this.isIcc = true;
+                this.hasIcc = true;
                 byte[] profile = new byte[remaining];
                 stream.Read(profile, 0, remaining);
 
@@ -765,7 +828,7 @@ namespace SixLabors.ImageSharp.Formats.Jpeg
                         int dataStartIdx = 2 + resourceBlockNameLength + 4;
                         if (resourceDataSize > 0 && blockDataSpan.Length >= dataStartIdx + resourceDataSize)
                         {
-                            this.isIptc = true;
+                            this.hasIptc = true;
                             this.iptcData = blockDataSpan.Slice(dataStartIdx, resourceDataSize).ToArray();
                             break;
                         }
@@ -785,6 +848,11 @@ namespace SixLabors.ImageSharp.Formats.Jpeg
                     }
                 }
             }
+            else
+            {
+                // If the profile is unknown skip over the rest of it.
+                stream.Skip(remaining);
+            }
         }
 
         /// <summary>
@@ -942,6 +1010,9 @@ namespace SixLabors.ImageSharp.Formats.Jpeg
                         break;
                     }
                 }
+
+                // Adjusting table for IDCT step during decompression
+                FastFloatingPointDCT.AdjustToIDCT(ref table);
             }
         }
 
@@ -992,6 +1063,14 @@ namespace SixLabors.ImageSharp.Formats.Jpeg
             // 1 byte: Number of components
             byte componentCount = this.temp[5];
 
+            // Validate: componentCount more than 4 can lead to a buffer overflow during stream
+            // reading so we must limit it to 4
+            // We do not support jpeg images with more than 4 components anyway
+            if (componentCount > 4)
+            {
+                JpegThrowHelper.ThrowNotSupportedComponentCount(componentCount);
+            }
+
             this.Frame = new JpegFrame(frameMarker, precision, frameWidth, frameHeight, componentCount);
 
             remaining -= length;
@@ -1016,10 +1095,26 @@ namespace SixLabors.ImageSharp.Formats.Jpeg
             int index = 0;
             for (int i = 0; i < componentCount; i++)
             {
+                // 1 byte: component identifier
+                byte componentId = this.temp[index];
+
+                // 1 byte: component sampling factors
                 byte hv = this.temp[index + 1];
                 int h = (hv >> 4) & 15;
                 int v = hv & 15;
 
+                // Validate: 1-4 range
+                if (Numerics.IsOutOfRange(h, 1, 4))
+                {
+                    JpegThrowHelper.ThrowBadSampling(h);
+                }
+
+                // Validate: 1-4 range
+                if (Numerics.IsOutOfRange(v, 1, 4))
+                {
+                    JpegThrowHelper.ThrowBadSampling(v);
+                }
+
                 if (maxH < h)
                 {
                     maxH = h;
@@ -1030,10 +1125,19 @@ namespace SixLabors.ImageSharp.Formats.Jpeg
                     maxV = v;
                 }
 
-                var component = new JpegComponent(this.Configuration.MemoryAllocator, this.Frame, this.temp[index], h, v, this.temp[index + 2], i);
+                // 1 byte: quantization table destination selector
+                byte quantTableIndex = this.temp[index + 2];
+
+                // Validate: 0-3 range
+                if (quantTableIndex > 3)
+                {
+                    JpegThrowHelper.ThrowBadQuantizationTableIndex(quantTableIndex);
+                }
+
+                var component = new JpegComponent(this.Configuration.MemoryAllocator, this.Frame, componentId, h, v, quantTableIndex, i);
 
                 this.Frame.Components[i] = component;
-                this.Frame.ComponentIds[i] = component.Id;
+                this.Frame.ComponentIds[i] = componentId;
 
                 index += componentBytes;
             }
@@ -1056,12 +1160,18 @@ namespace SixLabors.ImageSharp.Formats.Jpeg
         /// <param name="remaining">The remaining bytes in the segment block.</param>
         private void ProcessDefineHuffmanTablesMarker(BufferedReadStream stream, int remaining)
         {
-            int length = remaining;
+            const int codeLengthsByteSize = 17;
+            const int codeValuesMaxByteSize = 256;
+            const int totalBufferSize = codeLengthsByteSize + codeValuesMaxByteSize + HuffmanTable.WorkspaceByteSize;
 
-            using (IMemoryOwner<byte> huffmanData = this.Configuration.MemoryAllocator.Allocate<byte>(256, AllocationOptions.Clean))
+            int length = remaining;
+            using (IMemoryOwner<byte> buffer = this.Configuration.MemoryAllocator.Allocate<byte>(totalBufferSize))
             {
-                Span<byte> huffmanDataSpan = huffmanData.GetSpan();
-                ref byte huffmanDataRef = ref MemoryMarshal.GetReference(huffmanDataSpan);
+                Span<byte> bufferSpan = buffer.GetSpan();
+                Span<byte> huffmanLegthsSpan = bufferSpan.Slice(0, codeLengthsByteSize);
+                Span<byte> huffmanValuesSpan = bufferSpan.Slice(codeLengthsByteSize, codeValuesMaxByteSize);
+                Span<uint> tableWorkspace = MemoryMarshal.Cast<byte, uint>(bufferSpan.Slice(codeLengthsByteSize + codeValuesMaxByteSize));
+
                 for (int i = 2; i < remaining;)
                 {
                     byte huffmanTableSpec = (byte)stream.ReadByte();
@@ -1071,49 +1181,40 @@ namespace SixLabors.ImageSharp.Formats.Jpeg
                     // Types 0..1 DC..AC
                     if (tableType > 1)
                     {
-                        JpegThrowHelper.ThrowInvalidImageContentException($"Bad huffman table type: {tableType}");
+                        JpegThrowHelper.ThrowInvalidImageContentException($"Bad huffman table type: {tableType}.");
                     }
 
                     // Max tables of each type
                     if (tableIndex > 3)
                     {
-                        JpegThrowHelper.ThrowInvalidImageContentException($"Bad huffman table index: {tableIndex}");
+                        JpegThrowHelper.ThrowInvalidImageContentException($"Bad huffman table index: {tableIndex}.");
                     }
 
-                    stream.Read(huffmanDataSpan, 0, 16);
+                    stream.Read(huffmanLegthsSpan, 1, 16);
 
-                    using (IMemoryOwner<byte> codeLengths = this.Configuration.MemoryAllocator.Allocate<byte>(17, AllocationOptions.Clean))
+                    int codeLengthSum = 0;
+                    for (int j = 1; j < 17; j++)
                     {
-                        Span<byte> codeLengthsSpan = codeLengths.GetSpan();
-                        ref byte codeLengthsRef = ref MemoryMarshal.GetReference(codeLengthsSpan);
-                        int codeLengthSum = 0;
-
-                        for (int j = 1; j < 17; j++)
-                        {
-                            codeLengthSum += Unsafe.Add(ref codeLengthsRef, j) = Unsafe.Add(ref huffmanDataRef, j - 1);
-                        }
+                        codeLengthSum += huffmanLegthsSpan[j];
+                    }
 
-                        length -= 17;
+                    length -= 17;
 
-                        if (codeLengthSum > 256 || codeLengthSum > length)
-                        {
-                            JpegThrowHelper.ThrowInvalidImageContentException("Huffman table has excessive length.");
-                        }
+                    if (codeLengthSum > 256 || codeLengthSum > length)
+                    {
+                        JpegThrowHelper.ThrowInvalidImageContentException("Huffman table has excessive length.");
+                    }
 
-                        using (IMemoryOwner<byte> huffmanValues = this.Configuration.MemoryAllocator.Allocate<byte>(256, AllocationOptions.Clean))
-                        {
-                            Span<byte> huffmanValuesSpan = huffmanValues.GetSpan();
-                            stream.Read(huffmanValuesSpan, 0, codeLengthSum);
+                    stream.Read(huffmanValuesSpan, 0, codeLengthSum);
 
-                            i += 17 + codeLengthSum;
+                    i += 17 + codeLengthSum;
 
-                            this.scanDecoder.BuildHuffmanTable(
-                                tableType,
-                                tableIndex,
-                                codeLengthsSpan,
-                                huffmanValuesSpan);
-                        }
-                    }
+                    this.scanDecoder.BuildHuffmanTable(
+                        tableType,
+                        tableIndex,
+                        huffmanLegthsSpan,
+                        huffmanValuesSpan.Slice(0, codeLengthSum),
+                        tableWorkspace);
                 }
             }
         }

src/ImageSharp/Formats/Jpeg/JpegEncoderCore.cs

@@ -14,6 +14,7 @@ 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;
 using SixLabors.ImageSharp.PixelFormats;
 
 namespace SixLabors.ImageSharp.Formats.Jpeg
@@ -109,7 +110,7 @@ namespace SixLabors.ImageSharp.Formats.Jpeg
                 this.WriteJfifApplicationHeader(metadata);
             }
 
-            // Write Exif, ICC and IPTC profiles
+            // Write Exif, XMP, ICC and IPTC profiles
             this.WriteProfiles(metadata);
 
             if (this.colorType == JpegColorType.Rgb)
@@ -288,8 +289,10 @@ namespace SixLabors.ImageSharp.Formats.Jpeg
         /// <param name="componentCount">The number of components to write.</param>
         private void WriteDefineHuffmanTables(int componentCount)
         {
+            // This uses a C#'s compiler optimization that refers to the static data segment of the assembly,
+            // and doesn't incur any allocation at all.
             // Table identifiers.
-            ReadOnlySpan<byte> headers = stackalloc byte[]
+            ReadOnlySpan<byte> headers = new byte[]
             {
                 0x00,
                 0x10,
@@ -464,6 +467,54 @@ namespace SixLabors.ImageSharp.Formats.Jpeg
             this.outputStream.Write(data, 0, data.Length);
         }
 
+        /// <summary>
+        /// Writes the XMP metadata.
+        /// </summary>
+        /// <param name="xmpProfile">The XMP metadata to write.</param>
+        /// <exception cref="ImageFormatException">
+        /// Thrown if the XMP profile size exceeds the limit of 65533 bytes.
+        /// </exception>
+        private void WriteXmpProfile(XmpProfile xmpProfile)
+        {
+            if (xmpProfile is null)
+            {
+                return;
+            }
+
+            const int XmpOverheadLength = 29;
+            const int Max = 65533;
+            const int MaxData = Max - XmpOverheadLength;
+
+            byte[] data = xmpProfile.Data;
+
+            if (data is null || data.Length == 0)
+            {
+                return;
+            }
+
+            int dataLength = data.Length;
+            int offset = 0;
+
+            while (dataLength > 0)
+            {
+                int length = dataLength; // Number of bytes to write.
+
+                if (length > MaxData)
+                {
+                    length = MaxData;
+                }
+
+                dataLength -= length;
+
+                int app1Length = 2 + ProfileResolver.XmpMarker.Length + length;
+                this.WriteApp1Header(app1Length);
+                this.outputStream.Write(ProfileResolver.XmpMarker);
+                this.outputStream.Write(data, offset, length);
+
+                offset += length;
+            }
+        }
+
         /// <summary>
         /// Writes the App1 header.
         /// </summary>
@@ -577,8 +628,14 @@ namespace SixLabors.ImageSharp.Formats.Jpeg
                 return;
             }
 
+            // For compatibility, place the profiles in the following order:
+            // - APP1 EXIF
+            // - APP1 XMP
+            // - APP2 ICC
+            // - APP13 IPTC
             metadata.SyncProfiles();
             this.WriteExifProfile(metadata.ExifProfile);
+            this.WriteXmpProfile(metadata.XmpProfile);
             this.WriteIccProfile(metadata.IccProfile);
             this.WriteIptcProfile(metadata.IptcProfile);
         }

src/ImageSharp/Formats/Jpeg/JpegThrowHelper.cs

@@ -22,23 +22,6 @@ namespace SixLabors.ImageSharp.Formats.Jpeg
         [MethodImpl(InliningOptions.ColdPath)]
         public static void ThrowInvalidImageContentException(string errorMessage) => throw new InvalidImageContentException(errorMessage);
 
-        /// <summary>
-        /// Cold path optimization for throwing <see cref="InvalidImageContentException"/>'s.
-        /// </summary>
-        /// <param name="errorMessage">The error message for the exception.</param>
-        /// <param name="innerException">The exception that is the cause of the current exception, or a null reference
-        /// if no inner exception is specified.</param>
-        [MethodImpl(InliningOptions.ColdPath)]
-        public static void ThrowInvalidImageContentException(string errorMessage, Exception innerException) => throw new InvalidImageContentException(errorMessage, innerException);
-
-        /// <summary>
-        /// Cold path optimization for throwing <see cref="NotImplementedException"/>'s
-        /// </summary>
-        /// <param name="errorMessage">The error message for the exception.</param>
-        [MethodImpl(InliningOptions.ColdPath)]
-        public static void ThrowNotImplementedException(string errorMessage)
-            => throw new NotImplementedException(errorMessage);
-
         [MethodImpl(InliningOptions.ColdPath)]
         public static void ThrowBadMarker(string marker, int length) => throw new InvalidImageContentException($"Marker {marker} has bad length {length}.");
 
@@ -51,6 +34,9 @@ namespace SixLabors.ImageSharp.Formats.Jpeg
         [MethodImpl(InliningOptions.ColdPath)]
         public static void ThrowBadSampling() => throw new InvalidImageContentException("Bad sampling factor.");
 
+        [MethodImpl(InliningOptions.ColdPath)]
+        public static void ThrowBadSampling(int factor) => throw new InvalidImageContentException($"Bad sampling factor: {factor}");
+
         [MethodImpl(InliningOptions.ColdPath)]
         public static void ThrowBadProgressiveScan(int ss, int se, int ah, int al) => throw new InvalidImageContentException($"Invalid progressive parameters Ss={ss} Se={se} Ah={ah} Al={al}.");
 
@@ -59,5 +45,8 @@ namespace SixLabors.ImageSharp.Formats.Jpeg
 
         [MethodImpl(InliningOptions.ColdPath)]
         public static void ThrowDimensionsTooLarge(int width, int height) => throw new ImageFormatException($"Image is too large to encode at {width}x{height} for JPEG format.");
+
+        [MethodImpl(InliningOptions.ColdPath)]
+        public static void ThrowNotSupportedComponentCount(int componentCount) => throw new NotSupportedException($"Images with {componentCount} components are not supported.");
     }
 }

src/ImageSharp/Formats/Pbm/BinaryDecoder.cs

@@ -0,0 +1,194 @@
+// Copyright (c) Six Labors.
+// Licensed under the Apache License, Version 2.0.
+
+using System;
+using System.Buffers;
+using SixLabors.ImageSharp.IO;
+using SixLabors.ImageSharp.Memory;
+using SixLabors.ImageSharp.PixelFormats;
+
+namespace SixLabors.ImageSharp.Formats.Pbm
+{
+    /// <summary>
+    /// Pixel decoding methods for the PBM binary encoding.
+    /// </summary>
+    internal class BinaryDecoder
+    {
+        private static L8 white = new(255);
+        private static L8 black = new(0);
+
+        /// <summary>
+        /// Decode the specified pixels.
+        /// </summary>
+        /// <typeparam name="TPixel">The type of pixel to encode to.</typeparam>
+        /// <param name="configuration">The configuration.</param>
+        /// <param name="pixels">The pixel array to encode into.</param>
+        /// <param name="stream">The stream to read the data from.</param>
+        /// <param name="colorType">The ColorType to decode.</param>
+        /// <param name="componentType">Data type of the pixles components.</param>
+        /// <exception cref="InvalidImageContentException">
+        /// Thrown if an invalid combination of setting is requested.
+        /// </exception>
+        public static void Process<TPixel>(Configuration configuration, Buffer2D<TPixel> pixels, BufferedReadStream stream, PbmColorType colorType, PbmComponentType componentType)
+            where TPixel : unmanaged, IPixel<TPixel>
+        {
+            if (colorType == PbmColorType.Grayscale)
+            {
+                if (componentType == PbmComponentType.Byte)
+                {
+                    ProcessGrayscale(configuration, pixels, stream);
+                }
+                else
+                {
+                    ProcessWideGrayscale(configuration, pixels, stream);
+                }
+            }
+            else if (colorType == PbmColorType.Rgb)
+            {
+                if (componentType == PbmComponentType.Byte)
+                {
+                    ProcessRgb(configuration, pixels, stream);
+                }
+                else
+                {
+                    ProcessWideRgb(configuration, pixels, stream);
+                }
+            }
+            else
+            {
+                ProcessBlackAndWhite(configuration, pixels, stream);
+            }
+        }
+
+        private static void ProcessGrayscale<TPixel>(Configuration configuration, Buffer2D<TPixel> pixels, BufferedReadStream stream)
+            where TPixel : unmanaged, IPixel<TPixel>
+        {
+            const int bytesPerPixel = 1;
+            int width = pixels.Width;
+            int height = pixels.Height;
+            MemoryAllocator allocator = configuration.MemoryAllocator;
+            using IMemoryOwner<byte> row = allocator.Allocate<byte>(width * bytesPerPixel);
+            Span<byte> rowSpan = row.GetSpan();
+
+            for (int y = 0; y < height; y++)
+            {
+                stream.Read(rowSpan);
+                Span<TPixel> pixelSpan = pixels.DangerousGetRowSpan(y);
+                PixelOperations<TPixel>.Instance.FromL8Bytes(
+                    configuration,
+                    rowSpan,
+                    pixelSpan,
+                    width);
+            }
+        }
+
+        private static void ProcessWideGrayscale<TPixel>(Configuration configuration, Buffer2D<TPixel> pixels, BufferedReadStream stream)
+            where TPixel : unmanaged, IPixel<TPixel>
+        {
+            const int bytesPerPixel = 2;
+            int width = pixels.Width;
+            int height = pixels.Height;
+            MemoryAllocator allocator = configuration.MemoryAllocator;
+            using IMemoryOwner<byte> row = allocator.Allocate<byte>(width * bytesPerPixel);
+            Span<byte> rowSpan = row.GetSpan();
+
+            for (int y = 0; y < height; y++)
+            {
+                stream.Read(rowSpan);
+                Span<TPixel> pixelSpan = pixels.DangerousGetRowSpan(y);
+                PixelOperations<TPixel>.Instance.FromL16Bytes(
+                    configuration,
+                    rowSpan,
+                    pixelSpan,
+                    width);
+            }
+        }
+
+        private static void ProcessRgb<TPixel>(Configuration configuration, Buffer2D<TPixel> pixels, BufferedReadStream stream)
+            where TPixel : unmanaged, IPixel<TPixel>
+        {
+            const int bytesPerPixel = 3;
+            int width = pixels.Width;
+            int height = pixels.Height;
+            MemoryAllocator allocator = configuration.MemoryAllocator;
+            using IMemoryOwner<byte> row = allocator.Allocate<byte>(width * bytesPerPixel);
+            Span<byte> rowSpan = row.GetSpan();
+
+            for (int y = 0; y < height; y++)
+            {
+                stream.Read(rowSpan);
+                Span<TPixel> pixelSpan = pixels.DangerousGetRowSpan(y);
+                PixelOperations<TPixel>.Instance.FromRgb24Bytes(
+                    configuration,
+                    rowSpan,
+                    pixelSpan,
+                    width);
+            }
+        }
+
+        private static void ProcessWideRgb<TPixel>(Configuration configuration, Buffer2D<TPixel> pixels, BufferedReadStream stream)
+            where TPixel : unmanaged, IPixel<TPixel>
+        {
+            const int bytesPerPixel = 6;
+            int width = pixels.Width;
+            int height = pixels.Height;
+            MemoryAllocator allocator = configuration.MemoryAllocator;
+            using IMemoryOwner<byte> row = allocator.Allocate<byte>(width * bytesPerPixel);
+            Span<byte> rowSpan = row.GetSpan();
+
+            for (int y = 0; y < height; y++)
+            {
+                stream.Read(rowSpan);
+                Span<TPixel> pixelSpan = pixels.DangerousGetRowSpan(y);
+                PixelOperations<TPixel>.Instance.FromRgb48Bytes(
+                    configuration,
+                    rowSpan,
+                    pixelSpan,
+                    width);
+            }
+        }
+
+        private static void ProcessBlackAndWhite<TPixel>(Configuration configuration, Buffer2D<TPixel> pixels, BufferedReadStream stream)
+            where TPixel : unmanaged, IPixel<TPixel>
+        {
+            int width = pixels.Width;
+            int height = pixels.Height;
+            int startBit = 0;
+            MemoryAllocator allocator = configuration.MemoryAllocator;
+            using IMemoryOwner<L8> row = allocator.Allocate<L8>(width);
+            Span<L8> rowSpan = row.GetSpan();
+
+            for (int y = 0; y < height; y++)
+            {
+                for (int x = 0; x < width;)
+                {
+                    int raw = stream.ReadByte();
+                    int bit = startBit;
+                    startBit = 0;
+                    for (; bit < 8; bit++)
+                    {
+                        bool bitValue = (raw & (0x80 >> bit)) != 0;
+                        rowSpan[x] = bitValue ? black : white;
+                        x++;
+                        if (x == width)
+                        {
+                            startBit = (bit + 1) & 7; // Round off to below 8.
+                            if (startBit != 0)
+                            {
+                                stream.Seek(-1, System.IO.SeekOrigin.Current);
+                            }
+
+                            break;
+                        }
+                    }
+                }
+
+                Span<TPixel> pixelSpan = pixels.DangerousGetRowSpan(y);
+                PixelOperations<TPixel>.Instance.FromL8(
+                    configuration,
+                    rowSpan,
+                    pixelSpan);
+            }
+        }
+    }
+}

src/ImageSharp/Formats/Pbm/BinaryEncoder.cs

@@ -0,0 +1,208 @@
+// Copyright (c) Six Labors.
+// Licensed under the Apache License, Version 2.0.
+
+using System;
+using System.Buffers;
+using System.IO;
+using SixLabors.ImageSharp.Memory;
+using SixLabors.ImageSharp.PixelFormats;
+
+namespace SixLabors.ImageSharp.Formats.Pbm
+{
+    /// <summary>
+    /// Pixel encoding methods for the PBM binary encoding.
+    /// </summary>
+    internal class BinaryEncoder
+    {
+        /// <summary>
+        /// Decode pixels into the PBM binary encoding.
+        /// </summary>
+        /// <typeparam name="TPixel">The type of input pixel.</typeparam>
+        /// <param name="configuration">The configuration.</param>
+        /// <param name="stream">The bytestream to write to.</param>
+        /// <param name="image">The input image.</param>
+        /// <param name="colorType">The ColorType to use.</param>
+        /// <param name="componentType">Data type of the pixles components.</param>
+        /// <exception cref="InvalidImageContentException">
+        /// Thrown if an invalid combination of setting is requested.
+        /// </exception>
+        public static void WritePixels<TPixel>(Configuration configuration, Stream stream, ImageFrame<TPixel> image, PbmColorType colorType, PbmComponentType componentType)
+            where TPixel : unmanaged, IPixel<TPixel>
+        {
+            if (colorType == PbmColorType.Grayscale)
+            {
+                if (componentType == PbmComponentType.Byte)
+                {
+                    WriteGrayscale(configuration, stream, image);
+                }
+                else
+                {
+                    WriteWideGrayscale(configuration, stream, image);
+                }
+            }
+            else if (colorType == PbmColorType.Rgb)
+            {
+                if (componentType == PbmComponentType.Byte)
+                {
+                    WriteRgb(configuration, stream, image);
+                }
+                else
+                {
+                    WriteWideRgb(configuration, stream, image);
+                }
+            }
+            else
+            {
+                WriteBlackAndWhite(configuration, stream, image);
+            }
+        }
+
+        private static void WriteGrayscale<TPixel>(Configuration configuration, Stream stream, ImageFrame<TPixel> image)
+            where TPixel : unmanaged, IPixel<TPixel>
+        {
+            int width = image.Width;
+            int height = image.Height;
+            Buffer2D<TPixel> pixelBuffer = image.PixelBuffer;
+            MemoryAllocator allocator = configuration.MemoryAllocator;
+            using IMemoryOwner<byte> row = allocator.Allocate<byte>(width);
+            Span<byte> rowSpan = row.GetSpan();
+
+            for (int y = 0; y < height; y++)
+            {
+                Span<TPixel> pixelSpan = pixelBuffer.DangerousGetRowSpan(y);
+
+                PixelOperations<TPixel>.Instance.ToL8Bytes(
+                    configuration,
+                    pixelSpan,
+                    rowSpan,
+                    width);
+
+                stream.Write(rowSpan);
+            }
+        }
+
+        private static void WriteWideGrayscale<TPixel>(Configuration configuration, Stream stream, ImageFrame<TPixel> image)
+            where TPixel : unmanaged, IPixel<TPixel>
+        {
+            const int bytesPerPixel = 2;
+            int width = image.Width;
+            int height = image.Height;
+            Buffer2D<TPixel> pixelBuffer = image.PixelBuffer;
+            MemoryAllocator allocator = configuration.MemoryAllocator;
+            using IMemoryOwner<byte> row = allocator.Allocate<byte>(width * bytesPerPixel);
+            Span<byte> rowSpan = row.GetSpan();
+
+            for (int y = 0; y < height; y++)
+            {
+                Span<TPixel> pixelSpan = pixelBuffer.DangerousGetRowSpan(y);
+
+                PixelOperations<TPixel>.Instance.ToL16Bytes(
+                    configuration,
+                    pixelSpan,
+                    rowSpan,
+                    width);
+
+                stream.Write(rowSpan);
+            }
+        }
+
+        private static void WriteRgb<TPixel>(Configuration configuration, Stream stream, ImageFrame<TPixel> image)
+            where TPixel : unmanaged, IPixel<TPixel>
+        {
+            const int bytesPerPixel = 3;
+            int width = image.Width;
+            int height = image.Height;
+            Buffer2D<TPixel> pixelBuffer = image.PixelBuffer;
+            MemoryAllocator allocator = configuration.MemoryAllocator;
+            using IMemoryOwner<byte> row = allocator.Allocate<byte>(width * bytesPerPixel);
+            Span<byte> rowSpan = row.GetSpan();
+
+            for (int y = 0; y < height; y++)
+            {
+                Span<TPixel> pixelSpan = pixelBuffer.DangerousGetRowSpan(y);
+
+                PixelOperations<TPixel>.Instance.ToRgb24Bytes(
+                    configuration,
+                    pixelSpan,
+                    rowSpan,
+                    width);
+
+                stream.Write(rowSpan);
+            }
+        }
+
+        private static void WriteWideRgb<TPixel>(Configuration configuration, Stream stream, ImageFrame<TPixel> image)
+            where TPixel : unmanaged, IPixel<TPixel>
+        {
+            const int bytesPerPixel = 6;
+            int width = image.Width;
+            int height = image.Height;
+            Buffer2D<TPixel> pixelBuffer = image.PixelBuffer;
+            MemoryAllocator allocator = configuration.MemoryAllocator;
+            using IMemoryOwner<byte> row = allocator.Allocate<byte>(width * bytesPerPixel);
+            Span<byte> rowSpan = row.GetSpan();
+
+            for (int y = 0; y < height; y++)
+            {
+                Span<TPixel> pixelSpan = pixelBuffer.DangerousGetRowSpan(y);
+
+                PixelOperations<TPixel>.Instance.ToRgb48Bytes(
+                    configuration,
+                    pixelSpan,
+                    rowSpan,
+                    width);
+
+                stream.Write(rowSpan);
+            }
+        }
+
+        private static void WriteBlackAndWhite<TPixel>(Configuration configuration, Stream stream, ImageFrame<TPixel> image)
+            where TPixel : unmanaged, IPixel<TPixel>
+        {
+            int width = image.Width;
+            int height = image.Height;
+            Buffer2D<TPixel> pixelBuffer = image.PixelBuffer;
+            MemoryAllocator allocator = configuration.MemoryAllocator;
+            using IMemoryOwner<L8> row = allocator.Allocate<L8>(width);
+            Span<L8> rowSpan = row.GetSpan();
+
+            int previousValue = 0;
+            int startBit = 0;
+            for (int y = 0; y < height; y++)
+            {
+                Span<TPixel> pixelSpan = pixelBuffer.DangerousGetRowSpan(y);
+
+                PixelOperations<TPixel>.Instance.ToL8(
+                    configuration,
+                    pixelSpan,
+                    rowSpan);
+
+                for (int x = 0; x < width;)
+                {
+                    int value = previousValue;
+                    for (int i = startBit; i < 8; i++)
+                    {
+                        if (rowSpan[x].PackedValue < 128)
+                        {
+                            value |= 0x80 >> i;
+                        }
+
+                        x++;
+                        if (x == width)
+                        {
+                            previousValue = value;
+                            startBit = (i + 1) & 7; // Round off to below 8.
+                            break;
+                        }
+                    }
+
+                    if (startBit == 0)
+                    {
+                        stream.WriteByte((byte)value);
+                        previousValue = 0;
+                    }
+                }
+            }
+        }
+    }
+}

src/ImageSharp/Formats/Pbm/BufferedReadStreamExtensions.cs

@@ -0,0 +1,65 @@
+// Copyright (c) Six Labors.
+// Licensed under the Apache License, Version 2.0.
+
+using System.IO;
+using SixLabors.ImageSharp.IO;
+
+namespace SixLabors.ImageSharp.Formats.Pbm
+{
+    /// <summary>
+    /// Extensions methods for <see cref="BufferedReadStream"/>.
+    /// </summary>
+    internal static class BufferedReadStreamExtensions
+    {
+        /// <summary>
+        /// Skip over any whitespace or any comments.
+        /// </summary>
+        public static void SkipWhitespaceAndComments(this BufferedReadStream stream)
+        {
+            bool isWhitespace;
+            do
+            {
+                int val = stream.ReadByte();
+
+                // Comments start with '#' and end at the next new-line.
+                if (val == 0x23)
+                {
+                    int innerValue;
+                    do
+                    {
+                        innerValue = stream.ReadByte();
+                    }
+                    while (innerValue != 0x0a);
+
+                    // Continue searching for whitespace.
+                    val = innerValue;
+                }
+
+                isWhitespace = val is 0x09 or 0x0a or 0x0d or 0x20;
+            }
+            while (isWhitespace);
+            stream.Seek(-1, SeekOrigin.Current);
+        }
+
+        /// <summary>
+        /// Read a decimal text value.
+        /// </summary>
+        /// <returns>The integer value of the decimal.</returns>
+        public static int ReadDecimal(this BufferedReadStream stream)
+        {
+            int value = 0;
+            while (true)
+            {
+                int current = stream.ReadByte() - 0x30;
+                if ((uint)current > 9)
+                {
+                    break;
+                }
+
+                value = (value * 10) + current;
+            }
+
+            return value;
+        }
+    }
+}

src/ImageSharp/Formats/Pbm/IPbmEncoderOptions.cs

@@ -0,0 +1,26 @@
+// Copyright (c) Six Labors.
+// Licensed under the Apache License, Version 2.0.
+
+namespace SixLabors.ImageSharp.Formats.Pbm
+{
+    /// <summary>
+    /// Configuration options for use during PBM encoding.
+    /// </summary>
+    internal interface IPbmEncoderOptions
+    {
+        /// <summary>
+        /// Gets the encoding of the pixels.
+        /// </summary>
+        PbmEncoding? Encoding { get; }
+
+        /// <summary>
+        /// Gets the Color type of the resulting image.
+        /// </summary>
+        PbmColorType? ColorType { get; }
+
+        /// <summary>
+        /// Gets the Data Type of the pixel components.
+        /// </summary>
+        PbmComponentType? ComponentType { get; }
+    }
+}

src/ImageSharp/Formats/Pbm/MetadataExtensions.cs

@@ -0,0 +1,21 @@
+// Copyright (c) Six Labors.
+// Licensed under the Apache License, Version 2.0.
+
+using SixLabors.ImageSharp.Formats.Pbm;
+using SixLabors.ImageSharp.Metadata;
+
+namespace SixLabors.ImageSharp
+{
+    /// <summary>
+    /// Extension methods for the <see cref="ImageMetadata"/> type.
+    /// </summary>
+    public static partial class MetadataExtensions
+    {
+        /// <summary>
+        /// Gets the pbm format specific metadata for the image.
+        /// </summary>
+        /// <param name="metadata">The metadata this method extends.</param>
+        /// <returns>The <see cref="PbmMetadata"/>.</returns>
+        public static PbmMetadata GetPbmMetadata(this ImageMetadata metadata) => metadata.GetFormatMetadata(PbmFormat.Instance);
+    }
+}