Merge branch 'main' into js/remove-obsolete-code

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

@@ -21,18 +21,19 @@ jobs:
             runtime: -x64
             codecov: false
           # Temp disabled due to runtime preview issues.
+          # https://github.com/SixLabors/ImageSharp/issues/2117
           #- os: macos-latest
           #  framework: net7.0
           #  sdk: 7.0.x
           #  sdk-preview: true
           #  runtime: -x64
           #  codecov: false
-          - os: windows-latest
+          #- os: windows-latest
-            framework: net7.0
+          #  framework: net7.0
-            sdk: 7.0.x
+          #  sdk: 7.0.x
-            sdk-preview: true
+          #  sdk-preview: true
-            runtime: -x64
+          #  runtime: -x64
-            codecov: false
+          #  codecov: false
           - os: ubuntu-latest
             framework: net6.0
             sdk: 6.0.x

src/ImageSharp/Advanced/AotCompilerTools.cs

@@ -178,7 +178,7 @@ namespace SixLabors.ImageSharp.Advanced
             img.CloneAs<Short2>(default);
             img.CloneAs<Short4>(default);
 
-            ImageFrame.LoadPixelData<TPixel>(default, default(ReadOnlySpan<TPixel>), default, default);
+            ImageFrame.LoadPixelData(default, default(ReadOnlySpan<TPixel>), default, default);
             ImageFrame.LoadPixelData<TPixel>(default, default(ReadOnlySpan<byte>), default, default);
         }
 
@@ -217,14 +217,14 @@ namespace SixLabors.ImageSharp.Advanced
         private static void AotCompileImageDecoderInternals<TPixel>()
             where TPixel : unmanaged, IPixel<TPixel>
         {
-            default(WebpDecoderCore).Decode<TPixel>(default, default, default);
+            default(WebpDecoderCore).Decode<TPixel>(default, default);
-            default(BmpDecoderCore).Decode<TPixel>(default, default, default);
+            default(BmpDecoderCore).Decode<TPixel>(default, default);
-            default(GifDecoderCore).Decode<TPixel>(default, default, default);
+            default(GifDecoderCore).Decode<TPixel>(default, default);
-            default(JpegDecoderCore).Decode<TPixel>(default, default, default);
+            default(JpegDecoderCore).Decode<TPixel>(default, default);
-            default(PbmDecoderCore).Decode<TPixel>(default, default, default);
+            default(PbmDecoderCore).Decode<TPixel>(default, default);
-            default(PngDecoderCore).Decode<TPixel>(default, default, default);
+            default(PngDecoderCore).Decode<TPixel>(default, default);
-            default(TgaDecoderCore).Decode<TPixel>(default, default, default);
+            default(TgaDecoderCore).Decode<TPixel>(default, default);
-            default(TiffDecoderCore).Decode<TPixel>(default, default, default);
+            default(TiffDecoderCore).Decode<TPixel>(default, default);
         }
 
         /// <summary>
@@ -286,9 +286,7 @@ namespace SixLabors.ImageSharp.Advanced
         private static void AotCompileImageDecoder<TPixel, TDecoder>()
            where TPixel : unmanaged, IPixel<TPixel>
            where TDecoder : class, IImageDecoder
-        {
+            => default(TDecoder).Decode<TPixel>(default, default, default);
-            default(TDecoder).Decode<TPixel>(default, default, default);
-        }
 
         /// <summary>
         /// This method pre-seeds the all <see cref="IImageProcessor" /> in the AoT compiler.

src/ImageSharp/Common/Helpers/EnumUtils.cs

@@ -19,15 +19,14 @@ namespace SixLabors.ImageSharp
         /// <param name="defaultValue">The default value to return.</param>
         /// <returns>The <typeparamref name="TEnum"/>.</returns>
         public static TEnum Parse<TEnum>(int value, TEnum defaultValue)
-            where TEnum : Enum
+            where TEnum : struct, Enum
         {
-            foreach (TEnum enumValue in Enum.GetValues(typeof(TEnum)))
+            DebugGuard.IsTrue(Unsafe.SizeOf<TEnum>() == sizeof(int), "Only int-sized enums are supported.");
+
+            TEnum valueEnum = Unsafe.As<int, TEnum>(ref value);
+            if (Enum.IsDefined(valueEnum))
             {
-                TEnum current = enumValue;
+                return valueEnum;
-                if (value == Unsafe.As<TEnum, int>(ref current))
-                {
-                    return enumValue;
-                }
             }
 
             return defaultValue;
@@ -41,8 +40,10 @@ namespace SixLabors.ImageSharp
         /// <param name="flag">The flag.</param>
         /// <returns>The <see cref="bool"/>.</returns>
         public static bool HasFlag<TEnum>(TEnum value, TEnum flag)
-          where TEnum : Enum
+          where TEnum : struct, Enum
         {
+            DebugGuard.IsTrue(Unsafe.SizeOf<TEnum>() == sizeof(int), "Only int-sized enums are supported.");
+
             uint flagValue = Unsafe.As<TEnum, uint>(ref flag);
             return (Unsafe.As<TEnum, uint>(ref value) & flagValue) == flagValue;
         }

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

@@ -20,6 +20,10 @@ namespace SixLabors.ImageSharp
 
             public static ReadOnlySpan<byte> PermuteMaskSwitchInnerDWords8x32 => new byte[] { 0, 0, 0, 0, 1, 0, 0, 0, 4, 0, 0, 0, 5, 0, 0, 0, 2, 0, 0, 0, 3, 0, 0, 0, 6, 0, 0, 0, 7, 0, 0, 0 };
 
+            private static ReadOnlySpan<byte> MoveFirst24BytesToSeparateLanes => new byte[] { 0, 0, 0, 0, 1, 0, 0, 0, 2, 0, 0, 0, 6, 0, 0, 0, 3, 0, 0, 0, 4, 0, 0, 0, 5, 0, 0, 0, 7, 0, 0, 0 };
+
+            internal static ReadOnlySpan<byte> ExtractRgb => new byte[] { 0, 3, 6, 9, 1, 4, 7, 10, 2, 5, 8, 11, 0xFF, 0xFF, 0xFF, 0xFF, 0, 3, 6, 9, 1, 4, 7, 10, 2, 5, 8, 11, 0xFF, 0xFF, 0xFF, 0xFF };
+
             private static ReadOnlySpan<byte> ShuffleMaskPad4Nx16 => new byte[] { 0, 1, 2, 0x80, 3, 4, 5, 0x80, 6, 7, 8, 0x80, 9, 10, 11, 0x80 };
 
             private static ReadOnlySpan<byte> ShuffleMaskSlice4Nx16 => new byte[] { 0, 1, 2, 4, 5, 6, 8, 9, 10, 12, 13, 14, 0x80, 0x80, 0x80, 0x80 };
@@ -953,6 +957,49 @@ namespace SixLabors.ImageSharp
                 blueChannel = blueChannel[slice..];
                 destination = destination[slice..];
             }
+
+            internal static void UnpackToRgbPlanesAvx2Reduce(
+                ref Span<float> redChannel,
+                ref Span<float> greenChannel,
+                ref Span<float> blueChannel,
+                ref ReadOnlySpan<Rgb24> source)
+            {
+                ref Vector256<byte> rgbByteSpan = ref Unsafe.As<Rgb24, Vector256<byte>>(ref MemoryMarshal.GetReference(source));
+                ref Vector256<float> destRRef = ref Unsafe.As<float, Vector256<float>>(ref MemoryMarshal.GetReference(redChannel));
+                ref Vector256<float> destGRef = ref Unsafe.As<float, Vector256<float>>(ref MemoryMarshal.GetReference(greenChannel));
+                ref Vector256<float> destBRef = ref Unsafe.As<float, Vector256<float>>(ref MemoryMarshal.GetReference(blueChannel));
+
+                Vector256<uint> extractToLanesMask = Unsafe.As<byte, Vector256<uint>>(ref MemoryMarshal.GetReference(MoveFirst24BytesToSeparateLanes));
+                Vector256<byte> extractRgbMask = Unsafe.As<byte, Vector256<byte>>(ref MemoryMarshal.GetReference(ExtractRgb));
+                Vector256<byte> rgb, rg, bx;
+                Vector256<float> r, g, b;
+
+                const int bytesPerRgbStride = 24;
+                int count = (int)((uint)source.Length / 8);
+                for (int i = 0; i < count; i++)
+                {
+                    rgb = Avx2.PermuteVar8x32(Unsafe.AddByteOffset(ref rgbByteSpan, (IntPtr)(bytesPerRgbStride * i)).AsUInt32(), extractToLanesMask).AsByte();
+
+                    rgb = Avx2.Shuffle(rgb, extractRgbMask);
+
+                    rg = Avx2.UnpackLow(rgb, Vector256<byte>.Zero);
+                    bx = Avx2.UnpackHigh(rgb, Vector256<byte>.Zero);
+
+                    r = Avx.ConvertToVector256Single(Avx2.UnpackLow(rg, Vector256<byte>.Zero).AsInt32());
+                    g = Avx.ConvertToVector256Single(Avx2.UnpackHigh(rg, Vector256<byte>.Zero).AsInt32());
+                    b = Avx.ConvertToVector256Single(Avx2.UnpackLow(bx, Vector256<byte>.Zero).AsInt32());
+
+                    Unsafe.Add(ref destRRef, i) = r;
+                    Unsafe.Add(ref destGRef, i) = g;
+                    Unsafe.Add(ref destBRef, i) = b;
+                }
+
+                int sliceCount = count * 8;
+                redChannel = redChannel.Slice(sliceCount);
+                greenChannel = greenChannel.Slice(sliceCount);
+                blueChannel = blueChannel.Slice(sliceCount);
+                source = source.Slice(sliceCount);
+            }
         }
     }
 }

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

@@ -57,6 +57,25 @@ namespace SixLabors.ImageSharp
             PackFromRgbPlanesRemainder(redChannel, greenChannel, blueChannel, destination);
         }
 
+        [MethodImpl(InliningOptions.ShortMethod)]
+        internal static void UnpackToRgbPlanes(
+            Span<float> redChannel,
+            Span<float> greenChannel,
+            Span<float> blueChannel,
+            ReadOnlySpan<Rgb24> source)
+        {
+            DebugGuard.IsTrue(greenChannel.Length == redChannel.Length, nameof(greenChannel), "Channels must be of same size!");
+            DebugGuard.IsTrue(blueChannel.Length == redChannel.Length, nameof(blueChannel), "Channels must be of same size!");
+            DebugGuard.IsTrue(source.Length <= redChannel.Length, nameof(source), "'source' span should not be bigger than the destination channels!");
+
+            if (Avx2.IsSupported)
+            {
+                HwIntrinsics.UnpackToRgbPlanesAvx2Reduce(ref redChannel, ref greenChannel, ref blueChannel, ref source);
+            }
+
+            UnpackToRgbPlanesScalar(redChannel, greenChannel, blueChannel, source);
+        }
+
         private static void PackFromRgbPlanesScalarBatchedReduce(
             ref ReadOnlySpan<byte> redChannel,
             ref ReadOnlySpan<byte> greenChannel,
@@ -192,5 +211,29 @@ namespace SixLabors.ImageSharp
                 d.A = 255;
             }
         }
+
+        private static void UnpackToRgbPlanesScalar(
+            Span<float> redChannel,
+            Span<float> greenChannel,
+            Span<float> blueChannel,
+            ReadOnlySpan<Rgb24> source)
+        {
+            DebugGuard.IsTrue(greenChannel.Length == redChannel.Length, nameof(greenChannel), "Channels must be of same size!");
+            DebugGuard.IsTrue(blueChannel.Length == redChannel.Length, nameof(blueChannel), "Channels must be of same size!");
+            DebugGuard.IsTrue(source.Length <= redChannel.Length, nameof(source), "'source' span should not be bigger than the destination channels!");
+
+            ref float r = ref MemoryMarshal.GetReference(redChannel);
+            ref float g = ref MemoryMarshal.GetReference(greenChannel);
+            ref float b = ref MemoryMarshal.GetReference(blueChannel);
+            ref Rgb24 rgb = ref MemoryMarshal.GetReference(source);
+
+            for (int i = 0; i < source.Length; i++)
+            {
+                ref Rgb24 src = ref Unsafe.Add(ref rgb, i);
+                Unsafe.Add(ref r, i) = src.R;
+                Unsafe.Add(ref g, i) = src.G;
+                Unsafe.Add(ref b, i) = src.B;
+            }
+        }
     }
 }

src/ImageSharp/Formats/Bmp/BmpBitsPerPixel.cs

@@ -13,6 +13,11 @@ namespace SixLabors.ImageSharp.Formats.Bmp
         /// </summary>
         Pixel1 = 1,
 
+        /// <summary>
+        /// 2 bits per pixel.
+        /// </summary>
+        Pixel2 = 2,
+
         /// <summary>
         /// 4 bits per pixel.
         /// </summary>

src/ImageSharp/Formats/Bmp/BmpDecoder.cs

@@ -10,43 +10,40 @@ namespace SixLabors.ImageSharp.Formats.Bmp
     /// <summary>
     /// Image decoder for generating an image out of a Windows bitmap stream.
     /// </summary>
-    /// <remarks>
+    public class BmpDecoder : IImageDecoderSpecialized<BmpDecoderOptions>
-    /// Does not support the following formats at the moment:
-    /// <list type="bullet">
-    ///    <item>JPG</item>
-    ///    <item>PNG</item>
-    ///    <item>Some OS/2 specific subtypes like: Bitmap Array, Color Icon, Color Pointer, Icon, Pointer.</item>
-    /// </list>
-    /// Formats will be supported in a later releases. We advise always
-    /// to use only 24 Bit Windows bitmaps.
-    /// </remarks>
-    public sealed class BmpDecoder : IImageDecoder, IBmpDecoderOptions, IImageInfoDetector
     {
-        /// <summary>
-        /// Gets or sets a value indicating how to deal with skipped pixels, which can occur during decoding run length encoded bitmaps.
-        /// </summary>
-        public RleSkippedPixelHandling RleSkippedPixelHandling { get; set; } = RleSkippedPixelHandling.Black;
-
         /// <inheritdoc/>
-        public Image<TPixel> Decode<TPixel>(Configuration configuration, Stream stream, CancellationToken cancellationToken)
+        IImageInfo IImageInfoDetector.Identify(DecoderOptions options, Stream stream, CancellationToken cancellationToken)
-            where TPixel : unmanaged, IPixel<TPixel>
         {
+            Guard.NotNull(options, nameof(options));
             Guard.NotNull(stream, nameof(stream));
 
-            var decoder = new BmpDecoderCore(configuration, this);
+            return new BmpDecoderCore(new() { GeneralOptions = options }).Identify(options.Configuration, stream, cancellationToken);
-            return decoder.Decode<TPixel>(configuration, stream, cancellationToken);
         }
 
-        /// <inheritdoc />
+        /// <inheritdoc/>
-        public Image Decode(Configuration configuration, Stream stream, CancellationToken cancellationToken)
+        Image<TPixel> IImageDecoder.Decode<TPixel>(DecoderOptions options, Stream stream, CancellationToken cancellationToken)
-            => this.Decode<Rgba32>(configuration, stream, cancellationToken);
+            => ((IImageDecoderSpecialized<BmpDecoderOptions>)this).Decode<TPixel>(new() { GeneralOptions = options }, stream, cancellationToken);
+
+        /// <inheritdoc/>
+        Image IImageDecoder.Decode(DecoderOptions options, Stream stream, CancellationToken cancellationToken)
+          => ((IImageDecoderSpecialized<BmpDecoderOptions>)this).Decode(new() { GeneralOptions = options }, stream, cancellationToken);
 
         /// <inheritdoc/>
-        public IImageInfo Identify(Configuration configuration, Stream stream, CancellationToken cancellationToken)
+        Image<TPixel> IImageDecoderSpecialized<BmpDecoderOptions>.Decode<TPixel>(BmpDecoderOptions options, Stream stream, CancellationToken cancellationToken)
         {
+            Guard.NotNull(options, nameof(options));
             Guard.NotNull(stream, nameof(stream));
 
-            return new BmpDecoderCore(configuration, this).Identify(configuration, stream, cancellationToken);
+            Image<TPixel> image = new BmpDecoderCore(options).Decode<TPixel>(options.GeneralOptions.Configuration, stream, cancellationToken);
+
+            ImageDecoderUtilities.Resize(options.GeneralOptions, image);
+
+            return image;
         }
+
+        /// <inheritdoc/>
+        Image IImageDecoderSpecialized<BmpDecoderOptions>.Decode(BmpDecoderOptions options, Stream stream, CancellationToken cancellationToken)
+            => ((IImageDecoderSpecialized<BmpDecoderOptions>)this).Decode<Rgba32>(options, stream, cancellationToken);
     }
 }

src/ImageSharp/Formats/Bmp/BmpDecoderCore.cs

@@ -89,34 +89,38 @@ namespace SixLabors.ImageSharp.Formats.Bmp
         /// </summary>
         private BmpInfoHeader infoHeader;
 
+        /// <summary>
+        /// The global configuration.
+        /// </summary>
+        private readonly Configuration configuration;
+
         /// <summary>
         /// Used for allocating memory during processing operations.
         /// </summary>
         private readonly MemoryAllocator memoryAllocator;
 
         /// <summary>
-        /// The bitmap decoder options.
+        /// How to deal with skipped pixels,
+        /// which can occur during decoding run length encoded bitmaps.
         /// </summary>
-        private readonly IBmpDecoderOptions options;
+        private readonly RleSkippedPixelHandling rleSkippedPixelHandling;
 
         /// <summary>
         /// Initializes a new instance of the <see cref="BmpDecoderCore"/> class.
         /// </summary>
-        /// <param name="configuration">The configuration.</param>
         /// <param name="options">The options.</param>
-        public BmpDecoderCore(Configuration configuration, IBmpDecoderOptions options)
+        public BmpDecoderCore(BmpDecoderOptions options)
         {
-            this.Configuration = configuration;
+            this.Options = options.GeneralOptions;
-            this.memoryAllocator = configuration.MemoryAllocator;
+            this.rleSkippedPixelHandling = options.RleSkippedPixelHandling;
-            this.options = options;
+            this.configuration = options.GeneralOptions.Configuration;
+            this.memoryAllocator = this.configuration.MemoryAllocator;
         }
 
         /// <inheritdoc />
-        public Configuration Configuration { get; }
+        public DecoderOptions Options { get; }
 
-        /// <summary>
+        /// <inheritdoc />
-        /// Gets the dimensions of the image.
-        /// </summary>
         public Size Dimensions => new(this.infoHeader.Width, this.infoHeader.Height);
 
         /// <inheritdoc />
@@ -128,7 +132,7 @@ namespace SixLabors.ImageSharp.Formats.Bmp
             {
                 int bytesPerColorMapEntry = this.ReadImageHeaders(stream, out bool inverted, out byte[] palette);
 
-                image = new Image<TPixel>(this.Configuration, this.infoHeader.Width, this.infoHeader.Height, this.metadata);
+                image = new Image<TPixel>(this.configuration, this.infoHeader.Width, this.infoHeader.Height, this.metadata);
 
                 Buffer2D<TPixel> pixels = image.GetRootFramePixelBuffer();
 
@@ -325,7 +329,7 @@ namespace SixLabors.ImageSharp.Formats.Bmp
                             byte colorIdx = bufferRow[x];
                             if (undefinedPixelsSpan[rowStartIdx + x])
                             {
-                                switch (this.options.RleSkippedPixelHandling)
+                                switch (this.rleSkippedPixelHandling)
                                 {
                                     case RleSkippedPixelHandling.FirstColorOfPalette:
                                         color.FromBgr24(Unsafe.As<byte, Bgr24>(ref colors[colorIdx * 4]));
@@ -397,7 +401,7 @@ namespace SixLabors.ImageSharp.Formats.Bmp
                             int idx = rowStartIdx + (x * 3);
                             if (undefinedPixelsSpan[yMulWidth + x])
                             {
-                                switch (this.options.RleSkippedPixelHandling)
+                                switch (this.rleSkippedPixelHandling)
                                 {
                                     case RleSkippedPixelHandling.FirstColorOfPalette:
                                         color.FromBgr24(Unsafe.As<byte, Bgr24>(ref bufferSpan[idx]));
@@ -832,7 +836,11 @@ namespace SixLabors.ImageSharp.Formats.Bmp
             for (int y = 0; y < height; y++)
             {
                 int newY = Invert(y, height, inverted);
-                this.stream.Read(rowSpan);
+                if (this.stream.Read(rowSpan) == 0)
+                {
+                    BmpThrowHelper.ThrowInvalidImageContentException("Could not read enough data for a pixel row!");
+                }
+
                 int offset = 0;
                 Span<TPixel> pixelRow = pixels.DangerousGetRowSpan(newY);
 
@@ -884,7 +892,11 @@ namespace SixLabors.ImageSharp.Formats.Bmp
 
             for (int y = 0; y < height; y++)
             {
-                this.stream.Read(bufferSpan);
+                if (this.stream.Read(bufferSpan) == 0)
+                {
+                    BmpThrowHelper.ThrowInvalidImageContentException("Could not read enough data for a pixel row!");
+                }
+
                 int newY = Invert(y, height, inverted);
                 Span<TPixel> pixelRow = pixels.DangerousGetRowSpan(newY);
 
@@ -939,11 +951,15 @@ namespace SixLabors.ImageSharp.Formats.Bmp
 
             for (int y = 0; y < height; y++)
             {
-                this.stream.Read(rowSpan);
+                if (this.stream.Read(rowSpan) == 0)
+                {
+                    BmpThrowHelper.ThrowInvalidImageContentException("Could not read enough data for a pixel row!");
+                }
+
                 int newY = Invert(y, height, inverted);
                 Span<TPixel> pixelSpan = pixels.DangerousGetRowSpan(newY);
                 PixelOperations<TPixel>.Instance.FromBgr24Bytes(
-                    this.Configuration,
+                    this.configuration,
                     rowSpan,
                     pixelSpan,
                     width);
@@ -967,11 +983,15 @@ namespace SixLabors.ImageSharp.Formats.Bmp
 
             for (int y = 0; y < height; y++)
             {
-                this.stream.Read(rowSpan);
+                if (this.stream.Read(rowSpan) == 0)
+                {
+                    BmpThrowHelper.ThrowInvalidImageContentException("Could not read enough data for a pixel row!");
+                }
+
                 int newY = Invert(y, height, inverted);
                 Span<TPixel> pixelSpan = pixels.DangerousGetRowSpan(newY);
                 PixelOperations<TPixel>.Instance.FromBgra32Bytes(
-                    this.Configuration,
+                    this.configuration,
                     rowSpan,
                     pixelSpan,
                     width);
@@ -1003,10 +1023,13 @@ namespace SixLabors.ImageSharp.Formats.Bmp
             // actually a BGRA image, and change tactics accordingly.
             for (int y = 0; y < height; y++)
             {
-                this.stream.Read(rowSpan);
+                if (this.stream.Read(rowSpan) == 0)
+                {
+                    BmpThrowHelper.ThrowInvalidImageContentException("Could not read enough data for a pixel row!");
+                }
 
                 PixelOperations<Bgra32>.Instance.FromBgra32Bytes(
-                    this.Configuration,
+                    this.configuration,
                     rowSpan,
                     bgraRowSpan,
                     width);
@@ -1036,13 +1059,16 @@ namespace SixLabors.ImageSharp.Formats.Bmp
             {
                 for (int y = 0; y < height; y++)
                 {
-                    this.stream.Read(rowSpan);
+                    if (this.stream.Read(rowSpan) == 0)
+                    {
+                        BmpThrowHelper.ThrowInvalidImageContentException("Could not read enough data for a pixel row!");
+                    }
 
                     int newY = Invert(y, height, inverted);
                     Span<TPixel> pixelSpan = pixels.DangerousGetRowSpan(newY);
 
                     PixelOperations<TPixel>.Instance.FromBgra32Bytes(
-                        this.Configuration,
+                        this.configuration,
                         rowSpan,
                         pixelSpan,
                         width);
@@ -1054,9 +1080,13 @@ namespace SixLabors.ImageSharp.Formats.Bmp
             // Slow path. We need to set each alpha component value to fully opaque.
             for (int y = 0; y < height; y++)
             {
-                this.stream.Read(rowSpan);
+                if (this.stream.Read(rowSpan) == 0)
+                {
+                    BmpThrowHelper.ThrowInvalidImageContentException("Could not read enough data for a pixel row!");
+                }
+
                 PixelOperations<Bgra32>.Instance.FromBgra32Bytes(
-                    this.Configuration,
+                    this.configuration,
                     rowSpan,
                     bgraRowSpan,
                     width);
@@ -1115,7 +1145,11 @@ namespace SixLabors.ImageSharp.Formats.Bmp
 
             for (int y = 0; y < height; y++)
             {
-                this.stream.Read(bufferSpan);
+                if (this.stream.Read(bufferSpan) == 0)
+                {
+                    BmpThrowHelper.ThrowInvalidImageContentException("Could not read enough data for a pixel row!");
+                }
+
                 int newY = Invert(y, height, inverted);
                 Span<TPixel> pixelRow = pixels.DangerousGetRowSpan(newY);
 
@@ -1387,7 +1421,7 @@ namespace SixLabors.ImageSharp.Formats.Bmp
             int colorMapSizeBytes = -1;
             if (this.infoHeader.ClrUsed == 0)
             {
-                if (this.infoHeader.BitsPerPixel is 1 or 4 or 8)
+                if (this.infoHeader.BitsPerPixel is 1 or 2 or 4 or 8)
                 {
                     switch (this.fileMarkerType)
                     {
@@ -1431,7 +1465,10 @@ namespace SixLabors.ImageSharp.Formats.Bmp
 
                 palette = new byte[colorMapSizeBytes];
 
-                this.stream.Read(palette, 0, colorMapSizeBytes);
+                if (this.stream.Read(palette, 0, colorMapSizeBytes) == 0)
+                {
+                    BmpThrowHelper.ThrowInvalidImageContentException("Could not read enough data for the palette!");
+                }
             }
 
             this.infoHeader.VerifyDimensions();

src/ImageSharp/Formats/Bmp/BmpDecoderOptions.cs

@@ -0,0 +1,20 @@
+// Copyright (c) Six Labors.
+// Licensed under the Six Labors Split License.
+
+namespace SixLabors.ImageSharp.Formats.Bmp
+{
+    /// <summary>
+    /// Configuration options for decoding Windows Bitmap images.
+    /// </summary>
+    public sealed class BmpDecoderOptions : ISpecializedDecoderOptions
+    {
+        /// <inheritdoc/>
+        public DecoderOptions GeneralOptions { get; set; } = new();
+
+        /// <summary>
+        /// Gets or sets the value indicating how to deal with skipped pixels,
+        /// which can occur during decoding run length encoded bitmaps.
+        /// </summary>
+        public RleSkippedPixelHandling RleSkippedPixelHandling { get; set; }
+    }
+}

src/ImageSharp/Formats/Bmp/BmpEncoderCore.cs

@@ -57,6 +57,11 @@ namespace SixLabors.ImageSharp.Formats.Bmp
         /// </summary>
         private const int ColorPaletteSize4Bit = 64;
 
+        /// <summary>
+        /// The color palette for an 2 bit image will have 4 entry's with 4 bytes for each entry.
+        /// </summary>
+        private const int ColorPaletteSize2Bit = 16;
+
         /// <summary>
         /// The color palette for an 1 bit image will have 2 entry's with 4 bytes for each entry.
         /// </summary>
@@ -125,19 +130,14 @@ namespace SixLabors.ImageSharp.Formats.Bmp
             int bytesPerLine = 4 * (((image.Width * bpp) + 31) / 32);
             this.padding = bytesPerLine - (int)(image.Width * (bpp / 8F));
 
-            int colorPaletteSize = 0;
+            int colorPaletteSize = this.bitsPerPixel switch
-            if (this.bitsPerPixel == BmpBitsPerPixel.Pixel8)
-            {
-                colorPaletteSize = ColorPaletteSize8Bit;
-            }
-            else if (this.bitsPerPixel == BmpBitsPerPixel.Pixel4)
-            {
-                colorPaletteSize = ColorPaletteSize4Bit;
-            }
-            else if (this.bitsPerPixel == BmpBitsPerPixel.Pixel1)
             {
-                colorPaletteSize = ColorPaletteSize1Bit;
+                BmpBitsPerPixel.Pixel8 => ColorPaletteSize8Bit,
-            }
+                BmpBitsPerPixel.Pixel4 => ColorPaletteSize4Bit,
+                BmpBitsPerPixel.Pixel2 => ColorPaletteSize2Bit,
+                BmpBitsPerPixel.Pixel1 => ColorPaletteSize1Bit,
+                _ => 0
+            };
 
             byte[] iccProfileData = null;
             int iccProfileSize = 0;
@@ -322,27 +322,31 @@ namespace SixLabors.ImageSharp.Formats.Bmp
             switch (this.bitsPerPixel)
             {
                 case BmpBitsPerPixel.Pixel32:
-                    this.Write32Bit(stream, pixels);
+                    this.Write32BitPixelData(stream, pixels);
                     break;
 
                 case BmpBitsPerPixel.Pixel24:
-                    this.Write24Bit(stream, pixels);
+                    this.Write24BitPixelData(stream, pixels);
                     break;
 
                 case BmpBitsPerPixel.Pixel16:
-                    this.Write16Bit(stream, pixels);
+                    this.Write16BitPixelData(stream, pixels);
                     break;
 
                 case BmpBitsPerPixel.Pixel8:
-                    this.Write8Bit(stream, image);
+                    this.Write8BitPixelData(stream, image);
                     break;
 
                 case BmpBitsPerPixel.Pixel4:
-                    this.Write4BitColor(stream, image);
+                    this.Write4BitPixelData(stream, image);
+                    break;
+
+                case BmpBitsPerPixel.Pixel2:
+                    this.Write2BitPixelData(stream, image);
                     break;
 
                 case BmpBitsPerPixel.Pixel1:
-                    this.Write1BitColor(stream, image);
+                    this.Write1BitPixelData(stream, image);
                     break;
             }
         }
@@ -351,12 +355,12 @@ namespace SixLabors.ImageSharp.Formats.Bmp
             => this.memoryAllocator.AllocatePaddedPixelRowBuffer(width, bytesPerPixel, this.padding);
 
         /// <summary>
-        /// Writes the 32bit color palette to the stream.
+        /// Writes 32-bit data with a color palette to the stream.
         /// </summary>
         /// <typeparam name="TPixel">The pixel format.</typeparam>
         /// <param name="stream">The <see cref="Stream"/> to write to.</param>
         /// <param name="pixels">The <see cref="Buffer2D{TPixel}"/> containing pixel data.</param>
-        private void Write32Bit<TPixel>(Stream stream, Buffer2D<TPixel> pixels)
+        private void Write32BitPixelData<TPixel>(Stream stream, Buffer2D<TPixel> pixels)
             where TPixel : unmanaged, IPixel<TPixel>
         {
             using IMemoryOwner<byte> row = this.AllocateRow(pixels.Width, 4);
@@ -375,12 +379,12 @@ namespace SixLabors.ImageSharp.Formats.Bmp
         }
 
         /// <summary>
-        /// Writes the 24bit color palette to the stream.
+        /// Writes 24-bit pixel data with a color palette to the stream.
         /// </summary>
         /// <typeparam name="TPixel">The pixel format.</typeparam>
         /// <param name="stream">The <see cref="Stream"/> to write to.</param>
         /// <param name="pixels">The <see cref="Buffer2D{TPixel}"/> containing pixel data.</param>
-        private void Write24Bit<TPixel>(Stream stream, Buffer2D<TPixel> pixels)
+        private void Write24BitPixelData<TPixel>(Stream stream, Buffer2D<TPixel> pixels)
             where TPixel : unmanaged, IPixel<TPixel>
         {
             int width = pixels.Width;
@@ -401,12 +405,12 @@ namespace SixLabors.ImageSharp.Formats.Bmp
         }
 
         /// <summary>
-        /// Writes the 16bit color palette to the stream.
+        /// Writes 16-bit pixel data with a color palette to the stream.
         /// </summary>
         /// <typeparam name="TPixel">The type of the pixel.</typeparam>
         /// <param name="stream">The <see cref="Stream"/> to write to.</param>
         /// <param name="pixels">The <see cref="Buffer2D{TPixel}"/> containing pixel data.</param>
-        private void Write16Bit<TPixel>(Stream stream, Buffer2D<TPixel> pixels)
+        private void Write16BitPixelData<TPixel>(Stream stream, Buffer2D<TPixel> pixels)
             where TPixel : unmanaged, IPixel<TPixel>
         {
             int width = pixels.Width;
@@ -429,12 +433,12 @@ namespace SixLabors.ImageSharp.Formats.Bmp
         }
 
         /// <summary>
-        /// Writes an 8 bit image with a color palette. The color palette has 256 entry's with 4 bytes for each entry.
+        /// Writes 8 bit pixel data with a color palette. The color palette has 256 entry's with 4 bytes for each entry.
         /// </summary>
         /// <typeparam name="TPixel">The type of the pixel.</typeparam>
         /// <param name="stream">The <see cref="Stream"/> to write to.</param>
         /// <param name="image"> The <see cref="ImageFrame{TPixel}"/> containing pixel data.</param>
-        private void Write8Bit<TPixel>(Stream stream, ImageFrame<TPixel> image)
+        private void Write8BitPixelData<TPixel>(Stream stream, ImageFrame<TPixel> image)
             where TPixel : unmanaged, IPixel<TPixel>
         {
             bool isL8 = typeof(TPixel) == typeof(L8);
@@ -443,7 +447,7 @@ namespace SixLabors.ImageSharp.Formats.Bmp
 
             if (isL8)
             {
-                this.Write8BitGray(stream, image, colorPalette);
+                this.Write8BitPixelData(stream, image, colorPalette);
             }
             else
             {
@@ -480,13 +484,13 @@ namespace SixLabors.ImageSharp.Formats.Bmp
         }
 
         /// <summary>
-        /// Writes an 8 bit gray image with a color palette. The color palette has 256 entry's with 4 bytes for each entry.
+        /// Writes 8 bit gray pixel data with a color palette. The color palette has 256 entry's with 4 bytes for each entry.
         /// </summary>
         /// <typeparam name="TPixel">The type of the pixel.</typeparam>
         /// <param name="stream">The <see cref="Stream"/> to write to.</param>
         /// <param name="image"> The <see cref="ImageFrame{TPixel}"/> containing pixel data.</param>
         /// <param name="colorPalette">A byte span of size 1024 for the color palette.</param>
-        private void Write8BitGray<TPixel>(Stream stream, ImageFrame<TPixel> image, Span<byte> colorPalette)
+        private void Write8BitPixelData<TPixel>(Stream stream, ImageFrame<TPixel> image, Span<byte> colorPalette)
             where TPixel : unmanaged, IPixel<TPixel>
         {
             // Create a color palette with 256 different gray values.
@@ -518,12 +522,12 @@ namespace SixLabors.ImageSharp.Formats.Bmp
         }
 
         /// <summary>
-        /// Writes an 4 bit color image with a color palette. The color palette has 16 entry's with 4 bytes for each entry.
+        /// Writes 4 bit pixel data with a color palette. The color palette has 16 entry's with 4 bytes for each entry.
         /// </summary>
         /// <typeparam name="TPixel">The type of the pixel.</typeparam>
         /// <param name="stream">The <see cref="Stream"/> to write to.</param>
         /// <param name="image"> The <see cref="ImageFrame{TPixel}"/> containing pixel data.</param>
-        private void Write4BitColor<TPixel>(Stream stream, ImageFrame<TPixel> image)
+        private void Write4BitPixelData<TPixel>(Stream stream, ImageFrame<TPixel> image)
             where TPixel : unmanaged, IPixel<TPixel>
         {
             using IQuantizer<TPixel> frameQuantizer = this.quantizer.CreatePixelSpecificQuantizer<TPixel>(this.configuration, new QuantizerOptions()
@@ -562,12 +566,65 @@ namespace SixLabors.ImageSharp.Formats.Bmp
         }
 
         /// <summary>
-        /// Writes a 1 bit image with a color palette. The color palette has 2 entry's with 4 bytes for each entry.
+        /// Writes 2 bit pixel data with a color palette. The color palette has 4 entry's with 4 bytes for each entry.
+        /// </summary>
+        /// <typeparam name="TPixel">The type of the pixel.</typeparam>
+        /// <param name="stream">The <see cref="Stream"/> to write to.</param>
+        /// <param name="image"> The <see cref="ImageFrame{TPixel}"/> containing pixel data.</param>
+        private void Write2BitPixelData<TPixel>(Stream stream, ImageFrame<TPixel> image)
+            where TPixel : unmanaged, IPixel<TPixel>
+        {
+            using IQuantizer<TPixel> frameQuantizer = this.quantizer.CreatePixelSpecificQuantizer<TPixel>(this.configuration, new QuantizerOptions()
+            {
+                MaxColors = 4
+            });
+            using IndexedImageFrame<TPixel> quantized = frameQuantizer.BuildPaletteAndQuantizeFrame(image, image.Bounds());
+            using IMemoryOwner<byte> colorPaletteBuffer = this.memoryAllocator.Allocate<byte>(ColorPaletteSize2Bit, AllocationOptions.Clean);
+
+            Span<byte> colorPalette = colorPaletteBuffer.GetSpan();
+            ReadOnlySpan<TPixel> quantizedColorPalette = quantized.Palette.Span;
+            this.WriteColorPalette(stream, quantizedColorPalette, colorPalette);
+
+            ReadOnlySpan<byte> pixelRowSpan = quantized.DangerousGetRowSpan(0);
+            int rowPadding = pixelRowSpan.Length % 4 != 0 ? this.padding - 1 : this.padding;
+            for (int y = image.Height - 1; y >= 0; y--)
+            {
+                pixelRowSpan = quantized.DangerousGetRowSpan(y);
+
+                int endIdx = pixelRowSpan.Length % 4 == 0 ? pixelRowSpan.Length : pixelRowSpan.Length - 4;
+                int i = 0;
+                for (i = 0; i < endIdx; i += 4)
+                {
+                    stream.WriteByte((byte)((pixelRowSpan[i] << 6) | (pixelRowSpan[i + 1] << 4) | (pixelRowSpan[i + 2] << 2) | pixelRowSpan[i + 3]));
+                }
+
+                if (pixelRowSpan.Length % 4 != 0)
+                {
+                    int shift = 6;
+                    byte pixelData = 0;
+                    for (; i < pixelRowSpan.Length; i++)
+                    {
+                        pixelData = (byte)(pixelData | (pixelRowSpan[i] << shift));
+                        shift -= 2;
+                    }
+
+                    stream.WriteByte(pixelData);
+                }
+
+                for (i = 0; i < rowPadding; i++)
+                {
+                    stream.WriteByte(0);
+                }
+            }
+        }
+
+        /// <summary>
+        /// Writes 1 bit pixel data with a color palette. The color palette has 2 entry's with 4 bytes for each entry.
         /// </summary>
         /// <typeparam name="TPixel">The type of the pixel.</typeparam>
         /// <param name="stream">The <see cref="Stream"/> to write to.</param>
         /// <param name="image"> The <see cref="ImageFrame{TPixel}"/> containing pixel data.</param>
-        private void Write1BitColor<TPixel>(Stream stream, ImageFrame<TPixel> image)
+        private void Write1BitPixelData<TPixel>(Stream stream, ImageFrame<TPixel> image)
             where TPixel : unmanaged, IPixel<TPixel>
         {
             using IQuantizer<TPixel> frameQuantizer = this.quantizer.CreatePixelSpecificQuantizer<TPixel>(this.configuration, new QuantizerOptions()
@@ -622,7 +679,7 @@ namespace SixLabors.ImageSharp.Formats.Bmp
             Span<uint> colorPaletteAsUInt = MemoryMarshal.Cast<byte, uint>(colorPalette);
             for (int i = 0; i < colorPaletteAsUInt.Length; i++)
             {
-                colorPaletteAsUInt[i] = colorPaletteAsUInt[i] & 0x00FFFFFF; // Padding byte, always 0.
+                colorPaletteAsUInt[i] &= 0x00FFFFFF; // Padding byte, always 0.
             }
 
             stream.Write(colorPalette);

src/ImageSharp/Formats/Bmp/IBmpDecoderOptions.cs

@@ -1,16 +0,0 @@
-// Copyright (c) Six Labors.
-// Licensed under the Six Labors Split License.
-
-namespace SixLabors.ImageSharp.Formats.Bmp
-{
-    /// <summary>
-    /// Image decoder options for decoding Windows bitmap streams.
-    /// </summary>
-    internal interface IBmpDecoderOptions
-    {
-        /// <summary>
-        /// Gets the value indicating how to deal with skipped pixels, which can occur during decoding run length encoded bitmaps.
-        /// </summary>
-        RleSkippedPixelHandling RleSkippedPixelHandling { get; }
-    }
-}

src/ImageSharp/Formats/DecoderOptions.cs

@@ -0,0 +1,49 @@
+// Copyright (c) Six Labors.
+// Licensed under the Six Labors Split License.
+
+using System;
+using SixLabors.ImageSharp.Processing;
+using SixLabors.ImageSharp.Processing.Processors.Transforms;
+
+namespace SixLabors.ImageSharp.Formats
+{
+    /// <summary>
+    /// Provides general configuration options for decoding image formats.
+    /// </summary>
+    public sealed class DecoderOptions
+    {
+        private static readonly Lazy<DecoderOptions> LazyOptions = new(() => new());
+
+        private uint maxFrames = int.MaxValue;
+
+        /// <summary>
+        /// Gets the shared default general decoder options instance.
+        /// </summary>
+        internal static DecoderOptions Default { get; } = LazyOptions.Value;
+
+        /// <summary>
+        /// Gets or sets a custom Configuration instance to be used by the image processing pipeline.
+        /// </summary>
+        public Configuration Configuration { get; set; } = Configuration.Default;
+
+        /// <summary>
+        /// Gets or sets the target size to decode the image into.
+        /// </summary>
+        public Size? TargetSize { get; set; } = null;
+
+        /// <summary>
+        /// Gets or sets the sampler to use when resizing during decoding.
+        /// </summary>
+        public IResampler Sampler { get; set; } = KnownResamplers.Box;
+
+        /// <summary>
+        /// Gets or sets a value indicating whether to ignore encoded metadata when decoding.
+        /// </summary>
+        public bool SkipMetadata { get; set; } = false;
+
+        /// <summary>
+        /// Gets or sets the maximum number of image frames to decode, inclusive.
+        /// </summary>
+        public uint MaxFrames { get => this.maxFrames; set => this.maxFrames = Math.Clamp(value, 1, int.MaxValue); }
+    }
+}

src/ImageSharp/Formats/Gif/GifDecoder.cs

@@ -3,7 +3,6 @@
 
 using System.IO;
 using System.Threading;
-using SixLabors.ImageSharp.Metadata;
 using SixLabors.ImageSharp.PixelFormats;
 
 namespace SixLabors.ImageSharp.Formats.Gif
@@ -11,37 +10,33 @@ namespace SixLabors.ImageSharp.Formats.Gif
     /// <summary>
     /// Decoder for generating an image out of a gif encoded stream.
     /// </summary>
-    public sealed class GifDecoder : IImageDecoder, IGifDecoderOptions, IImageInfoDetector
+    public sealed class GifDecoder : IImageDecoder
     {
-        /// <summary>
-        /// Gets or sets a value indicating whether the metadata should be ignored when the image is being decoded.
-        /// </summary>
-        public bool IgnoreMetadata { get; set; } = false;
-
-        /// <summary>
-        /// Gets or sets the decoding mode for multi-frame images
-        /// </summary>
-        public FrameDecodingMode DecodingMode { get; set; } = FrameDecodingMode.All;
-
         /// <inheritdoc/>
-        public Image<TPixel> Decode<TPixel>(Configuration configuration, Stream stream, CancellationToken cancellationToken)
+        IImageInfo IImageInfoDetector.Identify(DecoderOptions options, Stream stream, CancellationToken cancellationToken)
-            where TPixel : unmanaged, IPixel<TPixel>
         {
-            var decoder = new GifDecoderCore(configuration, this);
+            Guard.NotNull(options, nameof(options));
-            return decoder.Decode<TPixel>(configuration, stream, cancellationToken);
+            Guard.NotNull(stream, nameof(stream));
-        }
 
-        /// <inheritdoc />
+            return new GifDecoderCore(options).Identify(options.Configuration, stream, cancellationToken);
-        public Image Decode(Configuration configuration, Stream stream, CancellationToken cancellationToken)
+        }
-            => this.Decode<Rgba32>(configuration, stream, cancellationToken);
 
         /// <inheritdoc/>
-        public IImageInfo Identify(Configuration configuration, Stream stream, CancellationToken cancellationToken)
+        Image<TPixel> IImageDecoder.Decode<TPixel>(DecoderOptions options, Stream stream, CancellationToken cancellationToken)
         {
+            Guard.NotNull(options, nameof(options));
             Guard.NotNull(stream, nameof(stream));
 
-            var decoder = new GifDecoderCore(configuration, this);
+            GifDecoderCore decoder = new(options);
-            return decoder.Identify(configuration, stream, cancellationToken);
+            Image<TPixel> image = decoder.Decode<TPixel>(options.Configuration, stream, cancellationToken);
+
+            ImageDecoderUtilities.Resize(options, image);
+
+            return image;
         }
+
+        /// <inheritdoc/>
+        Image IImageDecoder.Decode(DecoderOptions options, Stream stream, CancellationToken cancellationToken)
+            => ((IImageDecoder)this).Decode<Rgba32>(options, stream, cancellationToken);
     }
 }

src/ImageSharp/Formats/Gif/GifDecoderCore.cs

@@ -56,6 +56,26 @@ namespace SixLabors.ImageSharp.Formats.Gif
         /// </summary>
         private GifImageDescriptor imageDescriptor;
 
+        /// <summary>
+        /// The global configuration.
+        /// </summary>
+        private readonly Configuration configuration;
+
+        /// <summary>
+        /// Used for allocating memory during processing operations.
+        /// </summary>
+        private readonly MemoryAllocator memoryAllocator;
+
+        /// <summary>
+        /// The maximum number of frames to decode. Inclusive.
+        /// </summary>
+        private readonly uint maxFrames;
+
+        /// <summary>
+        /// Whether to skip metadata during decode.
+        /// </summary>
+        private readonly bool skipMetadata;
+
         /// <summary>
         /// The abstract metadata.
         /// </summary>
@@ -69,39 +89,27 @@ namespace SixLabors.ImageSharp.Formats.Gif
         /// <summary>
         /// Initializes a new instance of the <see cref="GifDecoderCore"/> class.
         /// </summary>
-        /// <param name="configuration">The configuration.</param>
         /// <param name="options">The decoder options.</param>
-        public GifDecoderCore(Configuration configuration, IGifDecoderOptions options)
+        public GifDecoderCore(DecoderOptions options)
         {
-            this.IgnoreMetadata = options.IgnoreMetadata;
+            this.Options = options;
-            this.DecodingMode = options.DecodingMode;
+            this.configuration = options.Configuration;
-            this.Configuration = configuration ?? Configuration.Default;
+            this.skipMetadata = options.SkipMetadata;
+            this.maxFrames = options.MaxFrames;
+            this.memoryAllocator = this.configuration.MemoryAllocator;
         }
 
         /// <inheritdoc />
-        public Configuration Configuration { get; }
+        public DecoderOptions Options { get; }
-
-        /// <summary>
-        /// Gets or sets a value indicating whether the metadata should be ignored when the image is being decoded.
-        /// </summary>
-        public bool IgnoreMetadata { get; internal set; }
 
-        /// <summary>
+        /// <inheritdoc />
-        /// Gets the decoding mode for multi-frame images.
-        /// </summary>
-        public FrameDecodingMode DecodingMode { get; }
-
-        /// <summary>
-        /// Gets the dimensions of the image.
-        /// </summary>
         public Size Dimensions => new(this.imageDescriptor.Width, this.imageDescriptor.Height);
 
-        private MemoryAllocator MemoryAllocator => this.Configuration.MemoryAllocator;
-
         /// <inheritdoc />
         public Image<TPixel> Decode<TPixel>(BufferedReadStream stream, CancellationToken cancellationToken)
             where TPixel : unmanaged, IPixel<TPixel>
         {
+            uint frameCount = 0;
             Image<TPixel> image = null;
             ImageFrame<TPixel> previousFrame = null;
             try
@@ -114,7 +122,7 @@ namespace SixLabors.ImageSharp.Formats.Gif
                 {
                     if (nextFlag == GifConstants.ImageLabel)
                     {
-                        if (previousFrame != null && this.DecodingMode == FrameDecodingMode.First)
+                        if (previousFrame != null && ++frameCount == this.maxFrames)
                         {
                             break;
                         }
@@ -277,9 +285,9 @@ namespace SixLabors.ImageSharp.Formats.Gif
                 this.stream.Read(this.buffer, 0, GifConstants.ApplicationBlockSize);
                 bool isXmp = this.buffer.AsSpan().StartsWith(GifConstants.XmpApplicationIdentificationBytes);
 
-                if (isXmp && !this.IgnoreMetadata)
+                if (isXmp && !this.skipMetadata)
                 {
-                    var extension = GifXmpApplicationExtension.Read(this.stream, this.MemoryAllocator);
+                    var extension = GifXmpApplicationExtension.Read(this.stream, this.memoryAllocator);
                     if (extension.Data.Length > 0)
                     {
                         this.metadata.XmpProfile = new XmpProfile(extension.Data);
@@ -346,13 +354,13 @@ namespace SixLabors.ImageSharp.Formats.Gif
                     GifThrowHelper.ThrowInvalidImageContentException($"Gif comment length '{length}' exceeds max '{GifConstants.MaxCommentSubBlockLength}' of a comment data block");
                 }
 
-                if (this.IgnoreMetadata)
+                if (this.skipMetadata)
                 {
                     this.stream.Seek(length, SeekOrigin.Current);
                     continue;
                 }
 
-                using IMemoryOwner<byte> commentsBuffer = this.MemoryAllocator.Allocate<byte>(length);
+                using IMemoryOwner<byte> commentsBuffer = this.memoryAllocator.Allocate<byte>(length);
                 Span<byte> commentsSpan = commentsBuffer.GetSpan();
 
                 this.stream.Read(commentsSpan);
@@ -385,11 +393,11 @@ namespace SixLabors.ImageSharp.Formats.Gif
                 if (this.imageDescriptor.LocalColorTableFlag)
                 {
                     int length = this.imageDescriptor.LocalColorTableSize * 3;
-                    localColorTable = this.Configuration.MemoryAllocator.Allocate<byte>(length, AllocationOptions.Clean);
+                    localColorTable = this.configuration.MemoryAllocator.Allocate<byte>(length, AllocationOptions.Clean);
                     this.stream.Read(localColorTable.GetSpan());
                 }
 
-                indices = this.Configuration.MemoryAllocator.Allocate2D<byte>(this.imageDescriptor.Width, this.imageDescriptor.Height, AllocationOptions.Clean);
+                indices = this.configuration.MemoryAllocator.Allocate2D<byte>(this.imageDescriptor.Width, this.imageDescriptor.Height, AllocationOptions.Clean);
                 this.ReadFrameIndices(indices);
 
                 Span<byte> rawColorTable = default;
@@ -423,7 +431,7 @@ namespace SixLabors.ImageSharp.Formats.Gif
         private void ReadFrameIndices(Buffer2D<byte> indices)
         {
             int minCodeSize = this.stream.ReadByte();
-            using var lzwDecoder = new LzwDecoder(this.Configuration.MemoryAllocator, this.stream);
+            using var lzwDecoder = new LzwDecoder(this.configuration.MemoryAllocator, this.stream);
             lzwDecoder.DecodePixels(minCodeSize, indices);
         }
 
@@ -451,12 +459,12 @@ namespace SixLabors.ImageSharp.Formats.Gif
             {
                 if (!transFlag)
                 {
-                    image = new Image<TPixel>(this.Configuration, imageWidth, imageHeight, Color.Black.ToPixel<TPixel>(), this.metadata);
+                    image = new Image<TPixel>(this.configuration, imageWidth, imageHeight, Color.Black.ToPixel<TPixel>(), this.metadata);
                 }
                 else
                 {
                     // This initializes the image to become fully transparent because the alpha channel is zero.
-                    image = new Image<TPixel>(this.Configuration, imageWidth, imageHeight, this.metadata);
+                    image = new Image<TPixel>(this.configuration, imageWidth, imageHeight, this.metadata);
                 }
 
                 this.SetFrameMetadata(image.Frames.RootFrame.Metadata);
@@ -675,7 +683,7 @@ namespace SixLabors.ImageSharp.Formats.Gif
 
                 if (globalColorTableLength > 0)
                 {
-                    this.globalColorTable = this.MemoryAllocator.Allocate<byte>(globalColorTableLength, AllocationOptions.Clean);
+                    this.globalColorTable = this.memoryAllocator.Allocate<byte>(globalColorTableLength, AllocationOptions.Clean);
 
                     // Read the global color table data from the stream
                     stream.Read(this.globalColorTable.GetSpan());

src/ImageSharp/Formats/Gif/IGifDecoderOptions.cs

@@ -1,23 +0,0 @@
-// Copyright (c) Six Labors.
-// Licensed under the Six Labors Split License.
-
-using SixLabors.ImageSharp.Metadata;
-
-namespace SixLabors.ImageSharp.Formats.Gif
-{
-    /// <summary>
-    /// Decoder for generating an image out of a gif encoded stream.
-    /// </summary>
-    internal interface IGifDecoderOptions
-    {
-        /// <summary>
-        /// Gets a value indicating whether the metadata should be ignored when the image is being decoded.
-        /// </summary>
-        bool IgnoreMetadata { get; }
-
-        /// <summary>
-        /// Gets the decoding mode for multi-frame images.
-        /// </summary>
-        FrameDecodingMode DecodingMode { get; }
-    }
-}

src/ImageSharp/Formats/IImageDecoder.cs

@@ -10,28 +10,34 @@ namespace SixLabors.ImageSharp.Formats
     /// <summary>
     /// Encapsulates properties and methods required for decoding an image from a stream.
     /// </summary>
-    public interface IImageDecoder
+    public interface IImageDecoder : IImageInfoDetector
     {
         /// <summary>
         /// Decodes the image from the specified stream to an <see cref="Image{TPixel}"/> of a specific pixel type.
         /// </summary>
+        /// <remarks>
+        /// This method is designed to support the ImageSharp internal infrastructure and is not recommended for direct use.
+        /// </remarks>
         /// <typeparam name="TPixel">The pixel format.</typeparam>
-        /// <param name="configuration">The configuration for the image.</param>
+        /// <param name="options">The general decoder options.</param>
         /// <param name="stream">The <see cref="Stream"/> containing image data.</param>
         /// <param name="cancellationToken">The token to monitor for cancellation requests.</param>
         /// <returns>The <see cref="Image{TPixel}"/>.</returns>
-        // TODO: Document ImageFormatExceptions (https://github.com/SixLabors/ImageSharp/issues/1110)
+        /// <exception cref="ImageFormatException">Thrown if the encoded image contains errors.</exception>
-        Image<TPixel> Decode<TPixel>(Configuration configuration, Stream stream, CancellationToken cancellationToken)
+        Image<TPixel> Decode<TPixel>(DecoderOptions options, Stream stream, CancellationToken cancellationToken)
             where TPixel : unmanaged, IPixel<TPixel>;
 
         /// <summary>
         /// Decodes the image from the specified stream to an <see cref="Image"/>.
         /// </summary>
-        /// <param name="configuration">The configuration for the image.</param>
+        /// <remarks>
+        /// This method is designed to support the ImageSharp internal infrastructure and is not recommended for direct use.
+        /// </remarks>
+        /// <param name="options">The general decoder options.</param>
         /// <param name="stream">The <see cref="Stream"/> containing image data.</param>
         /// <param name="cancellationToken">The token to monitor for cancellation requests.</param>
         /// <returns>The <see cref="Image"/>.</returns>
-        // TODO: Document ImageFormatExceptions (https://github.com/SixLabors/ImageSharp/issues/1110)
+        /// <exception cref="ImageFormatException">Thrown if the encoded image contains errors.</exception>
-        Image Decode(Configuration configuration, Stream stream, CancellationToken cancellationToken);
+        Image Decode(DecoderOptions options, Stream stream, CancellationToken cancellationToken);
     }
 }

src/ImageSharp/Formats/IImageDecoderInternals.cs

@@ -1,4 +1,4 @@
-// Copyright (c) Six Labors.
+// Copyright (c) Six Labors.
 // Licensed under the Six Labors Split License.
 
 using System;
@@ -9,14 +9,14 @@ using SixLabors.ImageSharp.PixelFormats;
 namespace SixLabors.ImageSharp.Formats
 {
     /// <summary>
-    /// Abstraction for shared internals for ***DecoderCore implementations to be used with <see cref="ImageDecoderUtilities"/>.
+    /// Abstraction for shared internals for XXXDecoderCore implementations to be used with <see cref="ImageDecoderUtilities"/>.
     /// </summary>
     internal interface IImageDecoderInternals
     {
         /// <summary>
-        /// Gets the associated configuration.
+        /// Gets the general decoder options.
         /// </summary>
-        Configuration Configuration { get; }
+        DecoderOptions Options { get; }
 
         /// <summary>
         /// Gets the dimensions of the image being decoded.

src/ImageSharp/Formats/IImageDecoderSpecialized{T}.cs

@@ -0,0 +1,45 @@
+// Copyright (c) Six Labors.
+// Licensed under the Six Labors Split License.
+
+using System.IO;
+using System.Threading;
+using SixLabors.ImageSharp.PixelFormats;
+
+namespace SixLabors.ImageSharp.Formats
+{
+    /// <summary>
+    /// The base class for all specialized image decoders.
+    /// </summary>
+    /// <typeparam name="T">The type of specialized options.</typeparam>
+    public interface IImageDecoderSpecialized<T> : IImageDecoder
+        where T : ISpecializedDecoderOptions
+    {
+        /// <summary>
+        /// Decodes the image from the specified stream to an <see cref="Image{TPixel}"/> of a specific pixel type.
+        /// </summary>
+        /// <remarks>
+        /// This method is designed to support the ImageSharp internal infrastructure and is not recommended for direct use.
+        /// </remarks>
+        /// <typeparam name="TPixel">The pixel format.</typeparam>
+        /// <param name="options">The specialized decoder options.</param>
+        /// <param name="stream">The <see cref="Stream"/> containing image data.</param>
+        /// <param name="cancellationToken">The token to monitor for cancellation requests.</param>
+        /// <returns>The <see cref="Image{TPixel}"/>.</returns>
+        /// <exception cref="ImageFormatException">Thrown if the encoded image contains errors.</exception>
+        public Image<TPixel> Decode<TPixel>(T options, Stream stream, CancellationToken cancellationToken)
+            where TPixel : unmanaged, IPixel<TPixel>;
+
+        /// <summary>
+        /// Decodes the image from the specified stream to an <see cref="Image"/> of a specific pixel type.
+        /// </summary>
+        /// <remarks>
+        /// This method is designed to support the ImageSharp internal infrastructure and is not recommended for direct use.
+        /// </remarks>
+        /// <param name="options">The specialized decoder options.</param>
+        /// <param name="stream">The <see cref="Stream"/> containing image data.</param>
+        /// <param name="cancellationToken">The token to monitor for cancellation requests.</param>
+        /// <returns>The <see cref="Image{TPixel}"/>.</returns>
+        /// <exception cref="ImageFormatException">Thrown if the encoded image contains errors.</exception>
+        public Image Decode(T options, Stream stream, CancellationToken cancellationToken);
+    }
+}

src/ImageSharp/Formats/IImageInfoDetector.cs

@@ -14,10 +14,14 @@ namespace SixLabors.ImageSharp.Formats
         /// <summary>
         /// Reads the raw image information from the specified stream.
         /// </summary>
-        /// <param name="configuration">The configuration for the image.</param>
+        /// <remarks>
+        /// This method is designed to support the ImageSharp internal infrastructure and is not recommended for direct use.
+        /// </remarks>
+        /// <param name="options">The general decoder options.</param>
         /// <param name="stream">The <see cref="Stream"/> containing image data.</param>
         /// <param name="cancellationToken">The token to monitor for cancellation requests.</param>
-        /// <returns>The <see cref="PixelTypeInfo"/> object</returns>
+        /// <returns>The <see cref="IImageInfo"/> object.</returns>
-        IImageInfo Identify(Configuration configuration, Stream stream, CancellationToken cancellationToken);
+        /// <exception cref="ImageFormatException">Thrown if the encoded image contains errors.</exception>
+        IImageInfo Identify(DecoderOptions options, Stream stream, CancellationToken cancellationToken);
     }
 }

src/ImageSharp/Formats/ISpecializedDecoderOptions.cs

@@ -0,0 +1,16 @@
+// Copyright (c) Six Labors.
+// Licensed under the Six Labors Split License.
+
+namespace SixLabors.ImageSharp.Formats
+{
+    /// <summary>
+    /// Provides specialized configuration options for decoding image formats.
+    /// </summary>
+    public interface ISpecializedDecoderOptions
+    {
+        /// <summary>
+        /// Gets or sets the general decoder options.
+        /// </summary>
+        DecoderOptions GeneralOptions { get; set; }
+    }
+}

src/ImageSharp/Formats/ImageDecoderExtensions.cs

@@ -0,0 +1,182 @@
+// Copyright (c) Six Labors.
+// Licensed under the Six Labors Split License.
+
+using System.IO;
+using System.Threading;
+using System.Threading.Tasks;
+using SixLabors.ImageSharp.PixelFormats;
+
+namespace SixLabors.ImageSharp.Formats
+{
+    /// <summary>
+    /// Extensions methods for <see cref="IImageDecoder"/> and <see cref="IImageDecoderSpecialized{T}"/>.
+    /// </summary>
+    public static class ImageDecoderExtensions
+    {
+        /// <summary>
+        /// Reads the raw image information from the specified stream.
+        /// </summary>
+        /// <param name="decoder">The decoder.</param>
+        /// <param name="options">The general decoder options.</param>
+        /// <param name="stream">The <see cref="Stream"/> containing image data.</param>
+        /// <returns>The <see cref="IImageInfo"/> object.</returns>
+        /// <exception cref="ImageFormatException">Thrown if the encoded image contains errors.</exception>
+        public static IImageInfo Identify(this IImageDecoder decoder, DecoderOptions options, Stream stream)
+            => Image.WithSeekableStream(
+                options,
+                stream,
+                s => decoder.Identify(options, s, default));
+
+        /// <summary>
+        /// Reads the raw image information from the specified stream.
+        /// </summary>
+        /// <param name="decoder">The decoder.</param>
+        /// <param name="options">The general decoder options.</param>
+        /// <param name="stream">The <see cref="Stream"/> containing image data.</param>
+        /// <param name="cancellationToken">The token to monitor for cancellation requests.</param>
+        /// <returns>The <see cref="Task{IImageInfo}"/> object.</returns>
+        /// <exception cref="ImageFormatException">Thrown if the encoded image contains errors.</exception>
+        public static Task<IImageInfo> IdentifyAsync(this IImageDecoder decoder, DecoderOptions options, Stream stream, CancellationToken cancellationToken = default)
+            => Image.WithSeekableStreamAsync(
+                options,
+                stream,
+                (s, ct) => decoder.Identify(options, s, ct),
+                cancellationToken);
+
+        /// <summary>
+        /// Decodes the image from the specified stream to an <see cref="Image{TPixel}"/> of a specific pixel type.
+        /// </summary>
+        /// <typeparam name="TPixel">The pixel format.</typeparam>
+        /// <param name="decoder">The decoder.</param>
+        /// <param name="options">The general decoder options.</param>
+        /// <param name="stream">The <see cref="Stream"/> containing image data.</param>
+        /// <returns>The <see cref="Image{TPixel}"/>.</returns>
+        /// <exception cref="ImageFormatException">Thrown if the encoded image contains errors.</exception>
+        public static Image<TPixel> Decode<TPixel>(this IImageDecoder decoder, DecoderOptions options, Stream stream)
+            where TPixel : unmanaged, IPixel<TPixel>
+            => Image.WithSeekableStream(
+                options,
+                stream,
+                s => decoder.Decode<TPixel>(options, s, default));
+
+        /// <summary>
+        /// Decodes the image from the specified stream to an <see cref="Image"/> of a specific pixel type.
+        /// </summary>
+        /// <param name="decoder">The decoder.</param>
+        /// <param name="options">The general decoder options.</param>
+        /// <param name="stream">The <see cref="Stream"/> containing image data.</param>
+        /// <returns>The <see cref="Image{TPixel}"/>.</returns>
+        /// <exception cref="ImageFormatException">Thrown if the encoded image contains errors.</exception>
+        public static Image Decode(this IImageDecoder decoder, DecoderOptions options, Stream stream)
+            => Image.WithSeekableStream(
+                options,
+                stream,
+                s => decoder.Decode(options, s, default));
+
+        /// <summary>
+        /// Decodes the image from the specified stream to an <see cref="Image{TPixel}"/> of a specific pixel type.
+        /// </summary>
+        /// <typeparam name="TPixel">The pixel format.</typeparam>
+        /// <param name="decoder">The decoder.</param>
+        /// <param name="options">The general decoder options.</param>
+        /// <param name="stream">The <see cref="Stream"/> containing image data.</param>
+        /// <param name="cancellationToken">The token to monitor for cancellation requests.</param>
+        /// <returns>A <see cref="Task{Image}"/> representing the asynchronous operation.</returns>
+        /// <exception cref="ImageFormatException">Thrown if the encoded image contains errors.</exception>
+        public static Task<Image<TPixel>> DecodeAsync<TPixel>(this IImageDecoder decoder, DecoderOptions options, Stream stream, CancellationToken cancellationToken = default)
+            where TPixel : unmanaged, IPixel<TPixel>
+            => Image.WithSeekableStreamAsync(
+                options,
+                stream,
+                (s, ct) => decoder.Decode<TPixel>(options, s, ct),
+                cancellationToken);
+
+        /// <summary>
+        /// Decodes the image from the specified stream to an <see cref="Image"/> of a specific pixel type.
+        /// </summary>
+        /// <param name="decoder">The decoder.</param>
+        /// <param name="options">The general decoder options.</param>
+        /// <param name="stream">The <see cref="Stream"/> containing image data.</param>
+        /// <param name="cancellationToken">The token to monitor for cancellation requests.</param>
+        /// <returns>A <see cref="Task{Image}"/> representing the asynchronous operation.</returns>
+        /// <exception cref="ImageFormatException">Thrown if the encoded image contains errors.</exception>
+        public static Task<Image> DecodeAsync(this IImageDecoder decoder, DecoderOptions options, Stream stream, CancellationToken cancellationToken = default)
+            => Image.WithSeekableStreamAsync(
+                options,
+                stream,
+                (s, ct) => decoder.Decode(options, s, ct),
+                cancellationToken);
+
+        /// <summary>
+        /// Decodes the image from the specified stream to an <see cref="Image{TPixel}"/> of a specific pixel type.
+        /// </summary>
+        /// <typeparam name="T">The type of specialized options.</typeparam>
+        /// <typeparam name="TPixel">The pixel format.</typeparam>
+        /// <param name="decoder">The decoder.</param>
+        /// <param name="options">The specialized decoder options.</param>
+        /// <param name="stream">The <see cref="Stream"/> containing image data.</param>
+        /// <returns>The <see cref="Image{TPixel}"/>.</returns>
+        /// <exception cref="ImageFormatException">Thrown if the encoded image contains errors.</exception>
+        public static Image<TPixel> Decode<T, TPixel>(this IImageDecoderSpecialized<T> decoder, T options, Stream stream)
+            where T : ISpecializedDecoderOptions
+            where TPixel : unmanaged, IPixel<TPixel>
+            => Image.WithSeekableStream(
+                options.GeneralOptions,
+                stream,
+                s => decoder.Decode<TPixel>(options, s, default));
+
+        /// <summary>
+        /// Decodes the image from the specified stream to an <see cref="Image"/> of a specific pixel type.
+        /// </summary>
+        /// <typeparam name="T">The type of specialized options.</typeparam>
+        /// <param name="decoder">The decoder.</param>
+        /// <param name="options">The specialized decoder options.</param>
+        /// <param name="stream">The <see cref="Stream"/> containing image data.</param>
+        /// <returns>The <see cref="Image{TPixel}"/>.</returns>
+        /// <exception cref="ImageFormatException">Thrown if the encoded image contains errors.</exception>
+        public static Image Decode<T>(this IImageDecoderSpecialized<T> decoder, T options, Stream stream)
+            where T : ISpecializedDecoderOptions
+            => Image.WithSeekableStream(
+                options.GeneralOptions,
+                stream,
+                s => decoder.Decode(options, s, default));
+
+        /// <summary>
+        /// Decodes the image from the specified stream to an <see cref="Image{TPixel}"/> of a specific pixel type.
+        /// </summary>
+        /// <typeparam name="T">The type of specialized options.</typeparam>
+        /// <typeparam name="TPixel">The pixel format.</typeparam>
+        /// <param name="decoder">The decoder.</param>
+        /// <param name="options">The specialized decoder options.</param>
+        /// <param name="stream">The <see cref="Stream"/> containing image data.</param>
+        /// <param name="cancellationToken">The token to monitor for cancellation requests.</param>
+        /// <returns>A <see cref="Task{Image}"/> representing the asynchronous operation.</returns>
+        /// <exception cref="ImageFormatException">Thrown if the encoded image contains errors.</exception>
+        public static Task<Image<TPixel>> DecodeAsync<T, TPixel>(this IImageDecoderSpecialized<T> decoder, T options, Stream stream, CancellationToken cancellationToken = default)
+            where T : ISpecializedDecoderOptions
+            where TPixel : unmanaged, IPixel<TPixel>
+            => Image.WithSeekableStreamAsync(
+                options.GeneralOptions,
+                stream,
+                (s, ct) => decoder.Decode<TPixel>(options, s, ct),
+                cancellationToken);
+
+        /// <summary>
+        /// Decodes the image from the specified stream to an <see cref="Image"/> of a specific pixel type.
+        /// </summary>
+        /// <typeparam name="T">The type of specialized options.</typeparam>
+        /// <param name="decoder">The decoder.</param>
+        /// <param name="options">The specialized decoder options.</param>
+        /// <param name="stream">The <see cref="Stream"/> containing image data.</param>
+        /// <param name="cancellationToken">The token to monitor for cancellation requests.</param>
+        /// <returns>A <see cref="Task{Image}"/> representing the asynchronous operation.</returns>
+        /// <exception cref="ImageFormatException">Thrown if the encoded image contains errors.</exception>
+        public static Task<Image> DecodeAsync<T>(this IImageDecoderSpecialized<T> decoder, T options, Stream stream, CancellationToken cancellationToken = default)
+            where T : ISpecializedDecoderOptions
+            => Image.WithSeekableStreamAsync(
+                options.GeneralOptions,
+                stream,
+                (s, ct) => decoder.Decode(options, s, ct),
+                cancellationToken);
+    }
+}

src/ImageSharp/Formats/ImageDecoderUtilities.cs

@@ -7,12 +7,55 @@ using System.Threading;
 using SixLabors.ImageSharp.IO;
 using SixLabors.ImageSharp.Memory;
 using SixLabors.ImageSharp.PixelFormats;
+using SixLabors.ImageSharp.Processing;
 
 namespace SixLabors.ImageSharp.Formats
 {
+    /// <summary>
+    /// Utility methods for <see cref="IImageDecoder"/>.
+    /// </summary>
     internal static class ImageDecoderUtilities
     {
-        public static IImageInfo Identify(
+        /// <summary>
+        /// Performs a resize operation against the decoded image. If the target size is not set, or the image size
+        /// already matches the target size, the image is untouched.
+        /// </summary>
+        /// <param name="options">The decoder options.</param>
+        /// <param name="image">The decoded image.</param>
+        public static void Resize(DecoderOptions options, Image image)
+        {
+            if (ShouldResize(options, image))
+            {
+                ResizeOptions resizeOptions = new()
+                {
+                    Size = options.TargetSize.Value,
+                    Sampler = options.Sampler,
+                    Mode = ResizeMode.Max
+                };
+
+                image.Mutate(x => x.Resize(resizeOptions));
+            }
+        }
+
+        /// <summary>
+        /// Determines whether the decoded image should be resized.
+        /// </summary>
+        /// <param name="options">The decoder options.</param>
+        /// <param name="image">The decoded image.</param>
+        /// <returns><see langword="true"/> if the image should be resized, otherwise; <see langword="false"/>.</returns>
+        private static bool ShouldResize(DecoderOptions options, Image image)
+        {
+            if (options.TargetSize is null)
+            {
+                return false;
+            }
+
+            Size targetSize = options.TargetSize.Value;
+            Size currentSize = image.Size();
+            return currentSize.Width != targetSize.Width && currentSize.Height != targetSize.Height;
+        }
+
+        internal static IImageInfo Identify(
             this IImageDecoderInternals decoder,
             Configuration configuration,
             Stream stream,
@@ -30,7 +73,7 @@ namespace SixLabors.ImageSharp.Formats
             }
         }
 
-        public static Image<TPixel> Decode<TPixel>(
+        internal static Image<TPixel> Decode<TPixel>(
             this IImageDecoderInternals decoder,
             Configuration configuration,
             Stream stream,
@@ -38,7 +81,7 @@ namespace SixLabors.ImageSharp.Formats
             where TPixel : unmanaged, IPixel<TPixel>
             => decoder.Decode<TPixel>(configuration, stream, DefaultLargeImageExceptionFactory, cancellationToken);
 
-        public static Image<TPixel> Decode<TPixel>(
+        internal static Image<TPixel> Decode<TPixel>(
             this IImageDecoderInternals decoder,
             Configuration configuration,
             Stream stream,

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

@@ -121,6 +121,21 @@ namespace SixLabors.ImageSharp.Formats.Jpeg.Components
             }
         }
 
+        public static Block8x8 Load(ReadOnlySpan<byte> data)
+        {
+            Unsafe.SkipInit(out Block8x8 result);
+            result.LoadFrom(data);
+            return result;
+        }
+
+        public void LoadFrom(ReadOnlySpan<byte> source)
+        {
+            for (int i = 0; i < Size; i++)
+            {
+                this[i] = source[i];
+            }
+        }
+
         /// <summary>
         /// Load raw 16bit integers from source.
         /// </summary>

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

@@ -8,7 +8,7 @@ using System.Runtime.CompilerServices;
 // <auto-generated />
 namespace SixLabors.ImageSharp.Formats.Jpeg.Components
 {
-	internal partial struct Block8x8F
+    internal partial struct Block8x8F
     {
 		/// <summary>
         /// Level shift by +maximum/2, clip to [0, maximum]

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

@@ -0,0 +1,159 @@
+// Copyright (c) Six Labors.
+// Licensed under the Six Labors Split License.
+
+using System.Numerics;
+using System.Runtime.CompilerServices;
+
+// ReSharper disable UseObjectOrCollectionInitializer
+// ReSharper disable InconsistentNaming
+namespace SixLabors.ImageSharp.Formats.Jpeg.Components
+{
+    internal partial struct Block8x8F
+    {
+        [MethodImpl(InliningOptions.ShortMethod)]
+        public void ScaledCopyFrom(ref float areaOrigin, int areaStride) =>
+            CopyFrom1x1Scale(ref Unsafe.As<float, byte>(ref areaOrigin), ref Unsafe.As<Block8x8F, byte>(ref this), areaStride);
+
+        [MethodImpl(InliningOptions.ShortMethod)]
+        public void ScaledCopyTo(ref float areaOrigin, int areaStride, int horizontalScale, int verticalScale)
+        {
+            if (horizontalScale == 1 && verticalScale == 1)
+            {
+                CopyTo1x1Scale(ref Unsafe.As<Block8x8F, byte>(ref this), ref Unsafe.As<float, byte>(ref areaOrigin), areaStride);
+                return;
+            }
+
+            if (horizontalScale == 2 && verticalScale == 2)
+            {
+                this.CopyTo2x2Scale(ref areaOrigin, areaStride);
+                return;
+            }
+
+            // TODO: Optimize: implement all cases with scale-specific, loopless code!
+            this.CopyArbitraryScale(ref areaOrigin, areaStride, horizontalScale, verticalScale);
+        }
+
+        private void CopyTo2x2Scale(ref float areaOrigin, int areaStride)
+        {
+            ref Vector2 destBase = ref Unsafe.As<float, Vector2>(ref areaOrigin);
+            int destStride = (int)((uint)areaStride / 2);
+
+            WidenCopyRowImpl2x2(ref this.V0L, ref destBase, 0, destStride);
+            WidenCopyRowImpl2x2(ref this.V0L, ref destBase, 1, destStride);
+            WidenCopyRowImpl2x2(ref this.V0L, ref destBase, 2, destStride);
+            WidenCopyRowImpl2x2(ref this.V0L, ref destBase, 3, destStride);
+            WidenCopyRowImpl2x2(ref this.V0L, ref destBase, 4, destStride);
+            WidenCopyRowImpl2x2(ref this.V0L, ref destBase, 5, destStride);
+            WidenCopyRowImpl2x2(ref this.V0L, ref destBase, 6, destStride);
+            WidenCopyRowImpl2x2(ref this.V0L, ref destBase, 7, destStride);
+
+            [MethodImpl(MethodImplOptions.AggressiveInlining)]
+            static void WidenCopyRowImpl2x2(ref Vector4 selfBase, ref Vector2 destBase, nint row, nint destStride)
+            {
+                ref Vector4 sLeft = ref Unsafe.Add(ref selfBase, 2 * row);
+                ref Vector4 sRight = ref Unsafe.Add(ref sLeft, 1);
+
+                nint offset = 2 * row * destStride;
+                ref Vector4 dTopLeft = ref Unsafe.As<Vector2, Vector4>(ref Unsafe.Add(ref destBase, offset));
+                ref Vector4 dBottomLeft = ref Unsafe.As<Vector2, Vector4>(ref Unsafe.Add(ref destBase, offset + destStride));
+
+                var xyLeft = new Vector4(sLeft.X);
+                xyLeft.Z = sLeft.Y;
+                xyLeft.W = sLeft.Y;
+
+                var zwLeft = new Vector4(sLeft.Z);
+                zwLeft.Z = sLeft.W;
+                zwLeft.W = sLeft.W;
+
+                var xyRight = new Vector4(sRight.X);
+                xyRight.Z = sRight.Y;
+                xyRight.W = sRight.Y;
+
+                var zwRight = new Vector4(sRight.Z);
+                zwRight.Z = sRight.W;
+                zwRight.W = sRight.W;
+
+                dTopLeft = xyLeft;
+                Unsafe.Add(ref dTopLeft, 1) = zwLeft;
+                Unsafe.Add(ref dTopLeft, 2) = xyRight;
+                Unsafe.Add(ref dTopLeft, 3) = zwRight;
+
+                dBottomLeft = xyLeft;
+                Unsafe.Add(ref dBottomLeft, 1) = zwLeft;
+                Unsafe.Add(ref dBottomLeft, 2) = xyRight;
+                Unsafe.Add(ref dBottomLeft, 3) = zwRight;
+            }
+        }
+
+        [MethodImpl(InliningOptions.ColdPath)]
+        private void CopyArbitraryScale(ref float areaOrigin, int areaStride, int horizontalScale, int verticalScale)
+        {
+            for (int y = 0; y < 8; y++)
+            {
+                int yy = y * verticalScale;
+                int y8 = y * 8;
+
+                for (int x = 0; x < 8; x++)
+                {
+                    int xx = x * horizontalScale;
+
+                    float value = this[y8 + x];
+                    nint baseIdx = (yy * areaStride) + xx;
+
+                    for (nint i = 0; i < verticalScale; i++, baseIdx += areaStride)
+                    {
+                        for (nint j = 0; j < horizontalScale; j++)
+                        {
+                            // area[xx + j, yy + i] = value;
+                            Unsafe.Add(ref areaOrigin, baseIdx + j) = value;
+                        }
+                    }
+                }
+            }
+        }
+
+        private static void CopyTo1x1Scale(ref byte origin, ref byte dest, int areaStride)
+        {
+            int destStride = areaStride * sizeof(float);
+
+            CopyRowImpl(ref origin, ref dest, destStride, 0);
+            CopyRowImpl(ref origin, ref dest, destStride, 1);
+            CopyRowImpl(ref origin, ref dest, destStride, 2);
+            CopyRowImpl(ref origin, ref dest, destStride, 3);
+            CopyRowImpl(ref origin, ref dest, destStride, 4);
+            CopyRowImpl(ref origin, ref dest, destStride, 5);
+            CopyRowImpl(ref origin, ref dest, destStride, 6);
+            CopyRowImpl(ref origin, ref dest, destStride, 7);
+
+            [MethodImpl(MethodImplOptions.AggressiveInlining)]
+            static void CopyRowImpl(ref byte origin, ref byte dest, int destStride, int row)
+            {
+                origin = ref Unsafe.Add(ref origin, row * 8 * sizeof(float));
+                dest = ref Unsafe.Add(ref dest, row * destStride);
+                Unsafe.CopyBlock(ref dest, ref origin, 8 * sizeof(float));
+            }
+        }
+
+        private static void CopyFrom1x1Scale(ref byte origin, ref byte dest, int areaStride)
+        {
+            int destStride = areaStride * sizeof(float);
+
+            CopyRowImpl(ref origin, ref dest, destStride, 0);
+            CopyRowImpl(ref origin, ref dest, destStride, 1);
+            CopyRowImpl(ref origin, ref dest, destStride, 2);
+            CopyRowImpl(ref origin, ref dest, destStride, 3);
+            CopyRowImpl(ref origin, ref dest, destStride, 4);
+            CopyRowImpl(ref origin, ref dest, destStride, 5);
+            CopyRowImpl(ref origin, ref dest, destStride, 6);
+            CopyRowImpl(ref origin, ref dest, destStride, 7);
+
+            [MethodImpl(MethodImplOptions.AggressiveInlining)]
+            static void CopyRowImpl(ref byte origin, ref byte dest, int sourceStride, int row)
+            {
+                origin = ref Unsafe.Add(ref origin, row * sourceStride);
+                dest = ref Unsafe.Add(ref dest, row * 8 * sizeof(float));
+                Unsafe.CopyBlock(ref dest, ref origin, 8 * sizeof(float));
+            }
+        }
+    }
+}

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

@@ -1,147 +0,0 @@
-// Copyright (c) Six Labors.
-// Licensed under the Six Labors Split License.
-
-using System.Numerics;
-using System.Runtime.CompilerServices;
-using SixLabors.ImageSharp.Memory;
-
-// ReSharper disable UseObjectOrCollectionInitializer
-// ReSharper disable InconsistentNaming
-namespace SixLabors.ImageSharp.Formats.Jpeg.Components
-{
-    internal partial struct Block8x8F
-    {
-        /// <summary>
-        /// Copy block data into the destination color buffer pixel area with the provided horizontal and vertical scale factors.
-        /// </summary>
-        [MethodImpl(InliningOptions.ShortMethod)]
-        public void ScaledCopyTo(in Buffer2DRegion<float> region, int horizontalScale, int verticalScale)
-        {
-            ref float areaOrigin = ref region.GetReferenceToOrigin();
-            this.ScaledCopyTo(ref areaOrigin, region.Stride, horizontalScale, verticalScale);
-        }
-
-        [MethodImpl(InliningOptions.ShortMethod)]
-        public void ScaledCopyTo(ref float areaOrigin, int areaStride, int horizontalScale, int verticalScale)
-        {
-            if (horizontalScale == 1 && verticalScale == 1)
-            {
-                this.Copy1x1Scale(ref areaOrigin, areaStride);
-                return;
-            }
-
-            if (horizontalScale == 2 && verticalScale == 2)
-            {
-                this.Copy2x2Scale(ref areaOrigin, areaStride);
-                return;
-            }
-
-            // TODO: Optimize: implement all cases with scale-specific, loopless code!
-            this.CopyArbitraryScale(ref areaOrigin, areaStride, horizontalScale, verticalScale);
-        }
-
-        public void Copy1x1Scale(ref float areaOrigin, int areaStride)
-        {
-            ref byte selfBase = ref Unsafe.As<Block8x8F, byte>(ref this);
-            ref byte destBase = ref Unsafe.As<float, byte>(ref areaOrigin);
-            int destStride = areaStride * sizeof(float);
-
-            CopyRowImpl(ref selfBase, ref destBase, destStride, 0);
-            CopyRowImpl(ref selfBase, ref destBase, destStride, 1);
-            CopyRowImpl(ref selfBase, ref destBase, destStride, 2);
-            CopyRowImpl(ref selfBase, ref destBase, destStride, 3);
-            CopyRowImpl(ref selfBase, ref destBase, destStride, 4);
-            CopyRowImpl(ref selfBase, ref destBase, destStride, 5);
-            CopyRowImpl(ref selfBase, ref destBase, destStride, 6);
-            CopyRowImpl(ref selfBase, ref destBase, destStride, 7);
-        }
-
-        [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        private static void CopyRowImpl(ref byte selfBase, ref byte destBase, int destStride, int row)
-        {
-            ref byte s = ref Unsafe.Add(ref selfBase, row * 8 * sizeof(float));
-            ref byte d = ref Unsafe.Add(ref destBase, row * destStride);
-            Unsafe.CopyBlock(ref d, ref s, 8 * sizeof(float));
-        }
-
-        private void Copy2x2Scale(ref float areaOrigin, int areaStride)
-        {
-            ref Vector2 destBase = ref Unsafe.As<float, Vector2>(ref areaOrigin);
-            int destStride = areaStride / 2;
-
-            this.WidenCopyRowImpl2x2(ref destBase, 0, destStride);
-            this.WidenCopyRowImpl2x2(ref destBase, 1, destStride);
-            this.WidenCopyRowImpl2x2(ref destBase, 2, destStride);
-            this.WidenCopyRowImpl2x2(ref destBase, 3, destStride);
-            this.WidenCopyRowImpl2x2(ref destBase, 4, destStride);
-            this.WidenCopyRowImpl2x2(ref destBase, 5, destStride);
-            this.WidenCopyRowImpl2x2(ref destBase, 6, destStride);
-            this.WidenCopyRowImpl2x2(ref destBase, 7, destStride);
-        }
-
-        [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        private void WidenCopyRowImpl2x2(ref Vector2 destBase, int row, int destStride)
-        {
-            ref Vector4 sLeft = ref Unsafe.Add(ref this.V0L, 2 * row);
-            ref Vector4 sRight = ref Unsafe.Add(ref sLeft, 1);
-
-            int offset = 2 * row * destStride;
-            ref Vector4 dTopLeft = ref Unsafe.As<Vector2, Vector4>(ref Unsafe.Add(ref destBase, offset));
-            ref Vector4 dBottomLeft = ref Unsafe.As<Vector2, Vector4>(ref Unsafe.Add(ref destBase, offset + destStride));
-
-            var xyLeft = new Vector4(sLeft.X);
-            xyLeft.Z = sLeft.Y;
-            xyLeft.W = sLeft.Y;
-
-            var zwLeft = new Vector4(sLeft.Z);
-            zwLeft.Z = sLeft.W;
-            zwLeft.W = sLeft.W;
-
-            var xyRight = new Vector4(sRight.X);
-            xyRight.Z = sRight.Y;
-            xyRight.W = sRight.Y;
-
-            var zwRight = new Vector4(sRight.Z);
-            zwRight.Z = sRight.W;
-            zwRight.W = sRight.W;
-
-            dTopLeft = xyLeft;
-            Unsafe.Add(ref dTopLeft, 1) = zwLeft;
-            Unsafe.Add(ref dTopLeft, 2) = xyRight;
-            Unsafe.Add(ref dTopLeft, 3) = zwRight;
-
-            dBottomLeft = xyLeft;
-            Unsafe.Add(ref dBottomLeft, 1) = zwLeft;
-            Unsafe.Add(ref dBottomLeft, 2) = xyRight;
-            Unsafe.Add(ref dBottomLeft, 3) = zwRight;
-        }
-
-        [MethodImpl(InliningOptions.ColdPath)]
-        private void CopyArbitraryScale(ref float areaOrigin, int areaStride, int horizontalScale, int verticalScale)
-        {
-            for (int y = 0; y < 8; y++)
-            {
-                int yy = y * verticalScale;
-                int y8 = y * 8;
-
-                for (int x = 0; x < 8; x++)
-                {
-                    int xx = x * horizontalScale;
-
-                    float value = this[y8 + x];
-
-                    for (int i = 0; i < verticalScale; i++)
-                    {
-                        int baseIdx = ((yy + i) * areaStride) + xx;
-
-                        for (int j = 0; j < horizontalScale; j++)
-                        {
-                            // area[xx + j, yy + i] = value;
-                            Unsafe.Add(ref areaOrigin, baseIdx + j) = value;
-                        }
-                    }
-                }
-            }
-        }
-    }
-}

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

@@ -343,6 +343,19 @@ namespace SixLabors.ImageSharp.Formats.Jpeg.Components
             }
         }
 
+        public void DE_NormalizeColors(float maximum)
+        {
+            if (SimdUtils.HasVector8)
+            {
+                this.NormalizeColorsAndRoundInPlaceVector8(maximum);
+            }
+            else
+            {
+                this.NormalizeColorsInPlace(maximum);
+                this.RoundInPlace();
+            }
+        }
+
         /// <summary>
         /// Rounds all values in the block.
         /// </summary>

src/ImageSharp/Formats/Jpeg/Components/ColorConverters/JpegColorConverter.CmykAvx.cs

@@ -0,0 +1,99 @@
+// Copyright (c) Six Labors.
+// Licensed under the Six Labors Split License.
+
+#if SUPPORTS_RUNTIME_INTRINSICS
+using System;
+using System.Runtime.CompilerServices;
+using System.Runtime.InteropServices;
+using System.Runtime.Intrinsics;
+using System.Runtime.Intrinsics.X86;
+
+namespace SixLabors.ImageSharp.Formats.Jpeg.Components
+{
+    internal abstract partial class JpegColorConverterBase
+    {
+        internal sealed class CmykAvx : JpegColorConverterAvx
+        {
+            public CmykAvx(int precision)
+                : base(JpegColorSpace.Cmyk, precision)
+            {
+            }
+
+            /// <inheritdoc/>
+            public override void ConvertToRgbInplace(in ComponentValues values)
+            {
+                ref Vector256<float> c0Base =
+                    ref Unsafe.As<float, Vector256<float>>(ref MemoryMarshal.GetReference(values.Component0));
+                ref Vector256<float> c1Base =
+                    ref Unsafe.As<float, Vector256<float>>(ref MemoryMarshal.GetReference(values.Component1));
+                ref Vector256<float> c2Base =
+                    ref Unsafe.As<float, Vector256<float>>(ref MemoryMarshal.GetReference(values.Component2));
+                ref Vector256<float> c3Base =
+                    ref Unsafe.As<float, Vector256<float>>(ref MemoryMarshal.GetReference(values.Component3));
+
+                // 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);
+                }
+            }
+
+            /// <inheritdoc/>
+            public override void ConvertFromRgb(in ComponentValues values, Span<float> rLane, Span<float> gLane, Span<float> bLane)
+                => ConvertFromRgb(in values, this.MaximumValue, rLane, gLane, bLane);
+
+            public static void ConvertFromRgb(in ComponentValues values, float maxValue, Span<float> rLane, Span<float> gLane, Span<float> bLane)
+            {
+                ref Vector256<float> destC =
+                    ref Unsafe.As<float, Vector256<float>>(ref MemoryMarshal.GetReference(values.Component0));
+                ref Vector256<float> destM =
+                    ref Unsafe.As<float, Vector256<float>>(ref MemoryMarshal.GetReference(values.Component1));
+                ref Vector256<float> destY =
+                    ref Unsafe.As<float, Vector256<float>>(ref MemoryMarshal.GetReference(values.Component2));
+                ref Vector256<float> destK =
+                    ref Unsafe.As<float, Vector256<float>>(ref MemoryMarshal.GetReference(values.Component3));
+
+                ref Vector256<float> srcR =
+                    ref Unsafe.As<float, Vector256<float>>(ref MemoryMarshal.GetReference(rLane));
+                ref Vector256<float> srcG =
+                    ref Unsafe.As<float, Vector256<float>>(ref MemoryMarshal.GetReference(gLane));
+                ref Vector256<float> srcB =
+                    ref Unsafe.As<float, Vector256<float>>(ref MemoryMarshal.GetReference(bLane));
+
+                var scale = Vector256.Create(maxValue);
+
+                nint n = values.Component0.Length / Vector256<float>.Count;
+                for (nint i = 0; i < n; i++)
+                {
+                    Vector256<float> ctmp = Avx.Subtract(scale, Unsafe.Add(ref srcR, i));
+                    Vector256<float> mtmp = Avx.Subtract(scale, Unsafe.Add(ref srcG, i));
+                    Vector256<float> ytmp = Avx.Subtract(scale, Unsafe.Add(ref srcB, i));
+                    Vector256<float> ktmp = Avx.Min(ctmp, Avx.Min(mtmp, ytmp));
+
+                    Vector256<float> kMask = Avx.CompareNotEqual(ktmp, scale);
+
+                    ctmp = Avx.And(Avx.Divide(Avx.Subtract(ctmp, ktmp), Avx.Subtract(scale, ktmp)), kMask);
+                    mtmp = Avx.And(Avx.Divide(Avx.Subtract(mtmp, ktmp), Avx.Subtract(scale, ktmp)), kMask);
+                    ytmp = Avx.And(Avx.Divide(Avx.Subtract(ytmp, ktmp), Avx.Subtract(scale, ktmp)), kMask);
+
+                    Unsafe.Add(ref destC, i) = Avx.Subtract(scale, Avx.Multiply(ctmp, scale));
+                    Unsafe.Add(ref destM, i) = Avx.Subtract(scale, Avx.Multiply(mtmp, scale));
+                    Unsafe.Add(ref destY, i) = Avx.Subtract(scale, Avx.Multiply(ytmp, scale));
+                    Unsafe.Add(ref destK, i) = Avx.Subtract(scale, ktmp);
+                }
+            }
+        }
+    }
+}
+#endif

src/ImageSharp/Formats/Jpeg/Components/ColorConverters/JpegColorConverter.CmykScalar.cs

@@ -0,0 +1,82 @@
+// Copyright (c) Six Labors.
+// Licensed under the Six Labors Split License.
+
+using System;
+
+namespace SixLabors.ImageSharp.Formats.Jpeg.Components
+{
+    internal abstract partial class JpegColorConverterBase
+    {
+        internal sealed class CmykScalar : JpegColorConverterScalar
+        {
+            public CmykScalar(int precision)
+                : base(JpegColorSpace.Cmyk, precision)
+            {
+            }
+
+            /// <inheritdoc/>
+            public override void ConvertToRgbInplace(in ComponentValues values) =>
+                ConvertToRgbInplace(values, this.MaximumValue);
+
+            /// <inheritdoc/>
+            public override void ConvertFromRgb(in ComponentValues values, Span<float> r, Span<float> g, Span<float> b)
+                => ConvertFromRgb(values, this.MaximumValue, r, g, b);
+
+            public static void ConvertToRgbInplace(in ComponentValues values, float maxValue)
+            {
+                Span<float> c0 = values.Component0;
+                Span<float> c1 = values.Component1;
+                Span<float> c2 = values.Component2;
+                Span<float> c3 = values.Component3;
+
+                float scale = 1 / (maxValue * 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];
+
+                    k *= scale;
+                    c0[i] = c * k;
+                    c1[i] = m * k;
+                    c2[i] = y * k;
+                }
+            }
+
+            public static void ConvertFromRgb(in ComponentValues values, float maxValue, Span<float> r, Span<float> g, Span<float> b)
+            {
+                Span<float> c = values.Component0;
+                Span<float> m = values.Component1;
+                Span<float> y = values.Component2;
+                Span<float> k = values.Component3;
+
+                for (int i = 0; i < c.Length; i++)
+                {
+                    float ctmp = 255f - r[i];
+                    float mtmp = 255f - g[i];
+                    float ytmp = 255f - b[i];
+                    float ktmp = MathF.Min(MathF.Min(ctmp, mtmp), ytmp);
+
+                    if (ktmp >= 255f)
+                    {
+                        ctmp = 0f;
+                        mtmp = 0f;
+                        ytmp = 0f;
+                    }
+                    else
+                    {
+                        ctmp = (ctmp - ktmp) / (255f - ktmp);
+                        mtmp = (mtmp - ktmp) / (255f - ktmp);
+                        ytmp = (ytmp - ktmp) / (255f - ktmp);
+                    }
+
+                    c[i] = maxValue - (ctmp * maxValue);
+                    m[i] = maxValue - (mtmp * maxValue);
+                    y[i] = maxValue - (ytmp * maxValue);
+                    k[i] = maxValue - ktmp;
+                }
+            }
+        }
+    }
+}

src/ImageSharp/Formats/Jpeg/Components/ColorConverters/JpegColorConverter.CmykVector.cs

@@ -0,0 +1,106 @@
+// Copyright (c) Six Labors.
+// Licensed under the Six Labors Split License.
+
+using System;
+using System.Numerics;
+using System.Runtime.CompilerServices;
+using System.Runtime.InteropServices;
+
+namespace SixLabors.ImageSharp.Formats.Jpeg.Components
+{
+    internal abstract partial class JpegColorConverterBase
+    {
+        internal sealed class CmykVector : JpegColorConverterVector
+        {
+            public CmykVector(int precision)
+                : base(JpegColorSpace.Cmyk, precision)
+            {
+            }
+
+            /// <inheritdoc/>
+            protected override void ConvertToRgbInplaceVectorized(in ComponentValues values)
+            {
+                ref Vector<float> cBase =
+                    ref Unsafe.As<float, Vector<float>>(ref MemoryMarshal.GetReference(values.Component0));
+                ref Vector<float> mBase =
+                    ref Unsafe.As<float, Vector<float>>(ref MemoryMarshal.GetReference(values.Component1));
+                ref Vector<float> yBase =
+                    ref Unsafe.As<float, Vector<float>>(ref MemoryMarshal.GetReference(values.Component2));
+                ref Vector<float> kBase =
+                    ref Unsafe.As<float, Vector<float>>(ref MemoryMarshal.GetReference(values.Component3));
+
+                var scale = new Vector<float>(1 / (this.MaximumValue * this.MaximumValue));
+
+                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;
+                }
+            }
+
+            /// <inheritdoc/>
+            protected override void ConvertToRgbInplaceScalarRemainder(in ComponentValues values)
+                 => CmykScalar.ConvertToRgbInplace(values, this.MaximumValue);
+
+            /// <inheritdoc/>
+            protected override void ConvertFromRgbVectorized(in ComponentValues values, Span<float> r, Span<float> g, Span<float> b)
+                => ConvertFromRgbInplaceVectorized(in values, this.MaximumValue, r, g, b);
+
+            /// <inheritdoc/>
+            protected override void ConvertFromRgbScalarRemainder(in ComponentValues values, Span<float> r, Span<float> g, Span<float> b)
+                => ConvertFromRgbInplaceRemainder(values, this.MaximumValue, r, g, b);
+
+            public static void ConvertFromRgbInplaceVectorized(in ComponentValues values, float maxValue, Span<float> r, Span<float> g, Span<float> b)
+            {
+                ref Vector<float> destC =
+                    ref Unsafe.As<float, Vector<float>>(ref MemoryMarshal.GetReference(values.Component0));
+                ref Vector<float> destM =
+                    ref Unsafe.As<float, Vector<float>>(ref MemoryMarshal.GetReference(values.Component1));
+                ref Vector<float> destY =
+                    ref Unsafe.As<float, Vector<float>>(ref MemoryMarshal.GetReference(values.Component2));
+                ref Vector<float> destK =
+                    ref Unsafe.As<float, Vector<float>>(ref MemoryMarshal.GetReference(values.Component3));
+
+                ref Vector<float> srcR =
+                    ref Unsafe.As<float, Vector<float>>(ref MemoryMarshal.GetReference(r));
+                ref Vector<float> srcG =
+                    ref Unsafe.As<float, Vector<float>>(ref MemoryMarshal.GetReference(g));
+                ref Vector<float> srcB =
+                    ref Unsafe.As<float, Vector<float>>(ref MemoryMarshal.GetReference(b));
+
+                // Used for the color conversion
+                var scale = new Vector<float>(maxValue);
+
+                nint n = values.Component0.Length / Vector<float>.Count;
+                for (nint i = 0; i < n; i++)
+                {
+                    Vector<float> ctmp = scale - Unsafe.Add(ref srcR, i);
+                    Vector<float> mtmp = scale - Unsafe.Add(ref srcG, i);
+                    Vector<float> ytmp = scale - Unsafe.Add(ref srcB, i);
+                    Vector<float> ktmp = Vector.Min(ctmp, Vector.Min(mtmp, ytmp));
+
+                    var kMask = Vector.Equals(ktmp, scale);
+                    ctmp = Vector.AndNot((ctmp - ktmp) / (scale - ktmp), kMask.As<int, float>());
+                    mtmp = Vector.AndNot((mtmp - ktmp) / (scale - ktmp), kMask.As<int, float>());
+                    ytmp = Vector.AndNot((ytmp - ktmp) / (scale - ktmp), kMask.As<int, float>());
+
+                    Unsafe.Add(ref destC, i) = scale - (ctmp * scale);
+                    Unsafe.Add(ref destM, i) = scale - (mtmp * scale);
+                    Unsafe.Add(ref destY, i) = scale - (ytmp * scale);
+                    Unsafe.Add(ref destK, i) = scale - ktmp;
+                }
+            }
+
+            public static void ConvertFromRgbInplaceRemainder(in ComponentValues values, float maxValue, Span<float> r, Span<float> g, Span<float> b)
+                => CmykScalar.ConvertFromRgb(values, maxValue, r, g, b);
+        }
+    }
+}

src/ImageSharp/Formats/Jpeg/Components/ColorConverters/JpegColorConverter.GrayScaleAvx.cs

@@ -0,0 +1,72 @@
+// Copyright (c) Six Labors.
+// Licensed under the Six Labors Split License.
+
+#if SUPPORTS_RUNTIME_INTRINSICS
+using System;
+using System.Runtime.CompilerServices;
+using System.Runtime.InteropServices;
+using System.Runtime.Intrinsics;
+using System.Runtime.Intrinsics.X86;
+using static SixLabors.ImageSharp.SimdUtils;
+
+namespace SixLabors.ImageSharp.Formats.Jpeg.Components
+{
+    internal abstract partial class JpegColorConverterBase
+    {
+        internal sealed class GrayscaleAvx : JpegColorConverterAvx
+        {
+            public GrayscaleAvx(int precision)
+                : base(JpegColorSpace.Grayscale, precision)
+            {
+            }
+
+            /// <inheritdoc/>
+            public override void ConvertToRgbInplace(in ComponentValues values)
+            {
+                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 / 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);
+                }
+            }
+
+            /// <inheritdoc/>
+            public override void ConvertFromRgb(in ComponentValues values, Span<float> rLane, Span<float> gLane, Span<float> bLane)
+            {
+                ref Vector256<float> destLuminance =
+                    ref Unsafe.As<float, Vector256<float>>(ref MemoryMarshal.GetReference(values.Component0));
+
+                ref Vector256<float> srcRed =
+                    ref Unsafe.As<float, Vector256<float>>(ref MemoryMarshal.GetReference(rLane));
+                ref Vector256<float> srcGreen =
+                    ref Unsafe.As<float, Vector256<float>>(ref MemoryMarshal.GetReference(gLane));
+                ref Vector256<float> srcBlue =
+                    ref Unsafe.As<float, Vector256<float>>(ref MemoryMarshal.GetReference(bLane));
+
+                // Used for the color conversion
+                var f0299 = Vector256.Create(0.299f);
+                var f0587 = Vector256.Create(0.587f);
+                var f0114 = Vector256.Create(0.114f);
+
+                nint n = values.Component0.Length / Vector256<float>.Count;
+                for (nint i = 0; i < n; i++)
+                {
+                    ref Vector256<float> r = ref Unsafe.Add(ref srcRed, i);
+                    ref Vector256<float> g = ref Unsafe.Add(ref srcGreen, i);
+                    ref Vector256<float> b = ref Unsafe.Add(ref srcBlue, i);
+
+                    // luminocity = (0.299 * r) + (0.587 * g) + (0.114 * b)
+                    Unsafe.Add(ref destLuminance, i) = HwIntrinsics.MultiplyAdd(HwIntrinsics.MultiplyAdd(Avx.Multiply(f0114, b), f0587, g), f0299, r);
+                }
+            }
+        }
+    }
+}
+#endif

src/ImageSharp/Formats/Jpeg/Components/ColorConverters/JpegColorConverter.GrayScaleScalar.cs

@@ -0,0 +1,51 @@
+// Copyright (c) Six Labors.
+// Licensed under the Six Labors Split License.
+
+using System;
+using System.Runtime.CompilerServices;
+using System.Runtime.InteropServices;
+
+namespace SixLabors.ImageSharp.Formats.Jpeg.Components
+{
+    internal abstract partial class JpegColorConverterBase
+    {
+        internal sealed class GrayscaleScalar : JpegColorConverterScalar
+        {
+            public GrayscaleScalar(int precision)
+                : base(JpegColorSpace.Grayscale, precision)
+            {
+            }
+
+            /// <inheritdoc/>
+            public override void ConvertToRgbInplace(in ComponentValues values)
+                => ConvertToRgbInplace(values.Component0, this.MaximumValue);
+
+            /// <inheritdoc/>
+            public override void ConvertFromRgb(in ComponentValues values, Span<float> r, Span<float> g, Span<float> b)
+                => ConvertCoreInplaceFromRgb(values, r, g, b);
+
+            internal static void ConvertToRgbInplace(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;
+                }
+            }
+
+            internal static void ConvertCoreInplaceFromRgb(in ComponentValues values, Span<float> rLane, Span<float> gLane, Span<float> bLane)
+            {
+                Span<float> c0 = values.Component0;
+
+                for (int i = 0; i < c0.Length; i++)
+                {
+                    // luminocity = (0.299 * r) + (0.587 * g) + (0.114 * b)
+                    float luma = (0.299f * rLane[i]) + (0.587f * gLane[i]) + (0.114f * bLane[i]);
+                    c0[i] = luma;
+                }
+            }
+        }
+    }
+}

src/ImageSharp/Formats/Jpeg/Components/ColorConverters/JpegColorConverter.GrayScaleVector.cs

@@ -0,0 +1,74 @@
+// Copyright (c) Six Labors.
+// Licensed under the Six Labors Split License.
+
+using System;
+using System.Numerics;
+using System.Runtime.CompilerServices;
+using System.Runtime.InteropServices;
+
+namespace SixLabors.ImageSharp.Formats.Jpeg.Components
+{
+    internal abstract partial class JpegColorConverterBase
+    {
+        internal sealed class GrayScaleVector : JpegColorConverterVector
+        {
+            public GrayScaleVector(int precision)
+                : base(JpegColorSpace.Grayscale, precision)
+            {
+            }
+
+            /// <inheritdoc/>
+            protected override void ConvertToRgbInplaceVectorized(in ComponentValues values)
+            {
+                ref Vector<float> cBase =
+                    ref Unsafe.As<float, Vector<float>>(ref MemoryMarshal.GetReference(values.Component0));
+
+                var scale = new Vector<float>(1 / this.MaximumValue);
+
+                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;
+                }
+            }
+
+            /// <inheritdoc/>
+            protected override void ConvertToRgbInplaceScalarRemainder(in ComponentValues values)
+                => GrayscaleScalar.ConvertToRgbInplace(values.Component0, this.MaximumValue);
+
+            /// <inheritdoc/>
+            protected override void ConvertFromRgbVectorized(in ComponentValues values, Span<float> rLane, Span<float> gLane, Span<float> bLane)
+            {
+                ref Vector<float> destLuma =
+                    ref Unsafe.As<float, Vector<float>>(ref MemoryMarshal.GetReference(values.Component0));
+
+                ref Vector<float> srcR =
+                    ref Unsafe.As<float, Vector<float>>(ref MemoryMarshal.GetReference(rLane));
+                ref Vector<float> srcG =
+                    ref Unsafe.As<float, Vector<float>>(ref MemoryMarshal.GetReference(gLane));
+                ref Vector<float> srcB =
+                    ref Unsafe.As<float, Vector<float>>(ref MemoryMarshal.GetReference(bLane));
+
+                var rMult = new Vector<float>(0.299f);
+                var gMult = new Vector<float>(0.587f);
+                var bMult = new Vector<float>(0.114f);
+
+                nint n = values.Component0.Length / Vector<float>.Count;
+                for (nint i = 0; i < n; i++)
+                {
+                    Vector<float> r = Unsafe.Add(ref srcR, i);
+                    Vector<float> g = Unsafe.Add(ref srcR, i);
+                    Vector<float> b = Unsafe.Add(ref srcR, i);
+
+                    // luminocity = (0.299 * r) + (0.587 * g) + (0.114 * b)
+                    Unsafe.Add(ref destLuma, i) = (rMult * r) + (gMult * g) + (bMult * b);
+                }
+            }
+
+            /// <inheritdoc/>
+            protected override void ConvertFromRgbScalarRemainder(in ComponentValues values, Span<float> r, Span<float> g, Span<float> b)
+                => GrayscaleScalar.ConvertCoreInplaceFromRgb(values, r, g, b);
+        }
+    }
+}

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

@@ -1,22 +1,24 @@
 // Copyright (c) Six Labors.
 // Licensed under the Six Labors Split License.
 
+using System;
 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
+namespace SixLabors.ImageSharp.Formats.Jpeg.Components
 {
     internal abstract partial class JpegColorConverterBase
     {
-        internal sealed class FromRgbAvx : JpegColorConverterAvx
+        internal sealed class RgbAvx : JpegColorConverterAvx
         {
-            public FromRgbAvx(int precision)
+            public RgbAvx(int precision)
                 : base(JpegColorSpace.RGB, precision)
             {
             }
 
+            /// <inheritdoc/>
             public override void ConvertToRgbInplace(in ComponentValues values)
             {
                 ref Vector256<float> rBase =
@@ -39,6 +41,14 @@ namespace SixLabors.ImageSharp.Formats.Jpeg.Components.Decoder.ColorConverters
                     b = Avx.Multiply(b, scale);
                 }
             }
+
+            /// <inheritdoc/>
+            public override void ConvertFromRgb(in ComponentValues values, Span<float> rLane, Span<float> gLane, Span<float> bLane)
+            {
+                rLane.CopyTo(values.Component0);
+                gLane.CopyTo(values.Component1);
+                bLane.CopyTo(values.Component2);
+            }
         }
     }
 }

src/ImageSharp/Formats/Jpeg/Components/ColorConverters/JpegColorConverter.RgbScalar.cs

@@ -0,0 +1,40 @@
+// Copyright (c) Six Labors.
+// Licensed under the Six Labors Split License.
+
+using System;
+
+namespace SixLabors.ImageSharp.Formats.Jpeg.Components
+{
+    internal abstract partial class JpegColorConverterBase
+    {
+        internal sealed class RgbScalar : JpegColorConverterScalar
+        {
+            public RgbScalar(int precision)
+                : base(JpegColorSpace.RGB, precision)
+            {
+            }
+
+            /// <inheritdoc/>
+            public override void ConvertToRgbInplace(in ComponentValues values)
+                => ConvertToRgbInplace(values, this.MaximumValue);
+
+            /// <inheritdoc/>
+            public override void ConvertFromRgb(in ComponentValues values, Span<float> r, Span<float> g, Span<float> b)
+                => ConvertFromRgb(values, r, g, b);
+
+            internal static void ConvertToRgbInplace(ComponentValues values, float maxValue)
+            {
+                GrayscaleScalar.ConvertToRgbInplace(values.Component0, maxValue);
+                GrayscaleScalar.ConvertToRgbInplace(values.Component1, maxValue);
+                GrayscaleScalar.ConvertToRgbInplace(values.Component2, maxValue);
+            }
+
+            internal static void ConvertFromRgb(ComponentValues values, Span<float> r, Span<float> g, Span<float> b)
+            {
+                r.CopyTo(values.Component0);
+                g.CopyTo(values.Component1);
+                b.CopyTo(values.Component2);
+            }
+        }
+    }
+}

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

@@ -1,22 +1,24 @@
 // Copyright (c) Six Labors.
 // Licensed under the Six Labors Split License.
 
+using System;
 using System.Numerics;
 using System.Runtime.CompilerServices;
 using System.Runtime.InteropServices;
 
-namespace SixLabors.ImageSharp.Formats.Jpeg.Components.Decoder.ColorConverters
+namespace SixLabors.ImageSharp.Formats.Jpeg.Components
 {
     internal abstract partial class JpegColorConverterBase
     {
-        internal sealed class FromRgbVector : JpegColorConverterVector
+        internal sealed class RgbVector : JpegColorConverterVector
         {
-            public FromRgbVector(int precision)
+            public RgbVector(int precision)
                 : base(JpegColorSpace.RGB, precision)
             {
             }
 
-            protected override void ConvertCoreVectorizedInplace(in ComponentValues values)
+            /// <inheritdoc/>
+            protected override void ConvertToRgbInplaceVectorized(in ComponentValues values)
             {
                 ref Vector<float> rBase =
                     ref Unsafe.As<float, Vector<float>>(ref MemoryMarshal.GetReference(values.Component0));
@@ -39,8 +41,21 @@ namespace SixLabors.ImageSharp.Formats.Jpeg.Components.Decoder.ColorConverters
                 }
             }
 
-            protected override void ConvertCoreInplace(in ComponentValues values) =>
+            /// <inheritdoc/>
-                FromRgbScalar.ConvertCoreInplace(values, this.MaximumValue);
+            protected override void ConvertToRgbInplaceScalarRemainder(in ComponentValues values)
+                => RgbScalar.ConvertToRgbInplace(values, this.MaximumValue);
+
+            /// <inheritdoc/>
+            protected override void ConvertFromRgbVectorized(in ComponentValues values, Span<float> r, Span<float> g, Span<float> b)
+            {
+                r.CopyTo(values.Component0);
+                g.CopyTo(values.Component1);
+                b.CopyTo(values.Component2);
+            }
+
+            /// <inheritdoc/>
+            protected override void ConvertFromRgbScalarRemainder(in ComponentValues values, Span<float> r, Span<float> g, Span<float> b)
+                => RgbScalar.ConvertFromRgb(values, r, g, b);
         }
     }
 }

src/ImageSharp/Formats/Jpeg/Components/ColorConverters/JpegColorConverter.YCbCrAvx.cs

@@ -0,0 +1,125 @@
+// Copyright (c) Six Labors.
+// Licensed under the Six Labors Split License.
+
+#if SUPPORTS_RUNTIME_INTRINSICS
+using System;
+using System.Runtime.CompilerServices;
+using System.Runtime.InteropServices;
+using System.Runtime.Intrinsics;
+using System.Runtime.Intrinsics.X86;
+using static SixLabors.ImageSharp.SimdUtils;
+
+// ReSharper disable ImpureMethodCallOnReadonlyValueField
+namespace SixLabors.ImageSharp.Formats.Jpeg.Components
+{
+    internal abstract partial class JpegColorConverterBase
+    {
+        internal sealed class YCbCrAvx : JpegColorConverterAvx
+        {
+            public YCbCrAvx(int precision)
+                : base(JpegColorSpace.YCbCr, precision)
+            {
+            }
+
+            /// <inheritdoc/>
+            public override void ConvertToRgbInplace(in ComponentValues values)
+            {
+                ref Vector256<float> c0Base =
+                    ref Unsafe.As<float, Vector256<float>>(ref MemoryMarshal.GetReference(values.Component0));
+                ref Vector256<float> c1Base =
+                    ref Unsafe.As<float, Vector256<float>>(ref MemoryMarshal.GetReference(values.Component1));
+                ref Vector256<float> c2Base =
+                    ref Unsafe.As<float, Vector256<float>>(ref MemoryMarshal.GetReference(values.Component2));
+
+                // Used for the color conversion
+                var chromaOffset = Vector256.Create(-this.HalfValue);
+                var scale = Vector256.Create(1 / this.MaximumValue);
+                var rCrMult = Vector256.Create(YCbCrScalar.RCrMult);
+                var gCbMult = Vector256.Create(-YCbCrScalar.GCbMult);
+                var gCrMult = Vector256.Create(-YCbCrScalar.GCrMult);
+                var bCbMult = Vector256.Create(YCbCrScalar.BCbMult);
+
+                // Walking 8 elements at one step:
+                nint n = values.Component0.Length / Vector256<float>.Count;
+                for (nint i = 0; i < n; i++)
+                {
+                    // y = yVals[i];
+                    // cb = cbVals[i] - 128F;
+                    // cr = crVals[i] - 128F;
+                    ref Vector256<float> c0 = ref Unsafe.Add(ref c0Base, i);
+                    ref Vector256<float> c1 = ref Unsafe.Add(ref c1Base, i);
+                    ref Vector256<float> c2 = ref Unsafe.Add(ref c2Base, i);
+
+                    Vector256<float> y = c0;
+                    Vector256<float> cb = Avx.Add(c1, chromaOffset);
+                    Vector256<float> cr = Avx.Add(c2, chromaOffset);
+
+                    // r = y + (1.402F * cr);
+                    // g = y - (0.344136F * cb) - (0.714136F * cr);
+                    // b = y + (1.772F * cb);
+                    Vector256<float> r = HwIntrinsics.MultiplyAdd(y, cr, rCrMult);
+                    Vector256<float> g = HwIntrinsics.MultiplyAdd(HwIntrinsics.MultiplyAdd(y, cb, gCbMult), cr, gCrMult);
+                    Vector256<float> b = HwIntrinsics.MultiplyAdd(y, cb, bCbMult);
+
+                    r = Avx.Multiply(Avx.RoundToNearestInteger(r), scale);
+                    g = Avx.Multiply(Avx.RoundToNearestInteger(g), scale);
+                    b = Avx.Multiply(Avx.RoundToNearestInteger(b), scale);
+
+                    c0 = r;
+                    c1 = g;
+                    c2 = b;
+                }
+            }
+
+            /// <inheritdoc/>
+            public override void ConvertFromRgb(in ComponentValues values, Span<float> rLane, Span<float> gLane, Span<float> bLane)
+            {
+                ref Vector256<float> destY =
+                    ref Unsafe.As<float, Vector256<float>>(ref MemoryMarshal.GetReference(values.Component0));
+                ref Vector256<float> destCb =
+                    ref Unsafe.As<float, Vector256<float>>(ref MemoryMarshal.GetReference(values.Component1));
+                ref Vector256<float> destCr =
+                    ref Unsafe.As<float, Vector256<float>>(ref MemoryMarshal.GetReference(values.Component2));
+
+                ref Vector256<float> srcR =
+                    ref Unsafe.As<float, Vector256<float>>(ref MemoryMarshal.GetReference(rLane));
+                ref Vector256<float> srcG =
+                    ref Unsafe.As<float, Vector256<float>>(ref MemoryMarshal.GetReference(gLane));
+                ref Vector256<float> srcB =
+                    ref Unsafe.As<float, Vector256<float>>(ref MemoryMarshal.GetReference(bLane));
+
+                // Used for the color conversion
+                var chromaOffset = Vector256.Create(this.HalfValue);
+
+                var f0299 = Vector256.Create(0.299f);
+                var f0587 = Vector256.Create(0.587f);
+                var f0114 = Vector256.Create(0.114f);
+                var fn0168736 = Vector256.Create(-0.168736f);
+                var fn0331264 = Vector256.Create(-0.331264f);
+                var fn0418688 = Vector256.Create(-0.418688f);
+                var fn0081312F = Vector256.Create(-0.081312F);
+                var f05 = Vector256.Create(0.5f);
+
+                nint n = values.Component0.Length / Vector256<float>.Count;
+                for (nint i = 0; i < n; i++)
+                {
+                    Vector256<float> r = Unsafe.Add(ref srcR, i);
+                    Vector256<float> g = Unsafe.Add(ref srcG, i);
+                    Vector256<float> b = Unsafe.Add(ref srcB, i);
+
+                    // y  =   0 + (0.299 * r) + (0.587 * g) + (0.114 * b)
+                    // cb = 128 - (0.168736 * r) - (0.331264 * g) + (0.5 * b)
+                    // cr = 128 + (0.5 * r) - (0.418688 * g) - (0.081312 * b)
+                    Vector256<float> y = HwIntrinsics.MultiplyAdd(HwIntrinsics.MultiplyAdd(Avx.Multiply(f0114, b), f0587, g), f0299, r);
+                    Vector256<float> cb = Avx.Add(chromaOffset, HwIntrinsics.MultiplyAdd(HwIntrinsics.MultiplyAdd(Avx.Multiply(f05, b), fn0331264, g), fn0168736, r));
+                    Vector256<float> cr = Avx.Add(chromaOffset, HwIntrinsics.MultiplyAdd(HwIntrinsics.MultiplyAdd(Avx.Multiply(fn0081312F, b), fn0418688, g), f05, r));
+
+                    Unsafe.Add(ref destY, i) = y;
+                    Unsafe.Add(ref destCb, i) = cb;
+                    Unsafe.Add(ref destCr, i) = cr;
+                }
+            }
+        }
+    }
+}
+#endif

src/ImageSharp/Formats/Jpeg/Components/ColorConverters/JpegColorConverter.YCbCrScalar.cs

@@ -0,0 +1,76 @@
+// Copyright (c) Six Labors.
+// Licensed under the Six Labors Split License.
+
+using System;
+
+namespace SixLabors.ImageSharp.Formats.Jpeg.Components
+{
+    internal abstract partial class JpegColorConverterBase
+    {
+        internal sealed class YCbCrScalar : JpegColorConverterScalar
+        {
+            // derived from ITU-T Rec. T.871
+            internal const float RCrMult = 1.402f;
+            internal const float GCbMult = (float)(0.114 * 1.772 / 0.587);
+            internal const float GCrMult = (float)(0.299 * 1.402 / 0.587);
+            internal const float BCbMult = 1.772f;
+
+            public YCbCrScalar(int precision)
+                : base(JpegColorSpace.YCbCr, precision)
+            {
+            }
+
+            /// <inheritdoc/>
+            public override void ConvertToRgbInplace(in ComponentValues values)
+                => ConvertToRgbInplace(values, this.MaximumValue, this.HalfValue);
+
+            /// <inheritdoc/>
+            public override void ConvertFromRgb(in ComponentValues values, Span<float> r, Span<float> g, Span<float> b)
+                => ConvertFromRgb(values, this.HalfValue, r, g, b);
+
+            public static void ConvertToRgbInplace(in ComponentValues values, float maxValue, float halfValue)
+            {
+                Span<float> c0 = values.Component0;
+                Span<float> c1 = values.Component1;
+                Span<float> c2 = values.Component2;
+
+                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;
+                }
+            }
+
+            public static void ConvertFromRgb(in ComponentValues values, float halfValue, Span<float> rLane, Span<float> gLane, Span<float> bLane)
+            {
+                Span<float> y = values.Component0;
+                Span<float> cb = values.Component1;
+                Span<float> cr = values.Component2;
+
+                for (int i = 0; i < y.Length; i++)
+                {
+                    float r = rLane[i];
+                    float g = gLane[i];
+                    float b = bLane[i];
+
+                    // y  =   0 + (0.299 * r) + (0.587 * g) + (0.114 * b)
+                    // cb = 128 - (0.168736 * r) - (0.331264 * g) + (0.5 * b)
+                    // cr = 128 + (0.5 * r) - (0.418688 * g) - (0.081312 * b)
+                    y[i] = (0.299f * r) + (0.587f * g) + (0.114f * b);
+                    cb[i] = halfValue - (0.168736f * r) - (0.331264f * g) + (0.5f * b);
+                    cr[i] = halfValue + (0.5f * r) - (0.418688f * g) - (0.081312f * b);
+                }
+            }
+        }
+    }
+}

src/ImageSharp/Formats/Jpeg/Components/ColorConverters/JpegColorConverter.YCbCrVector.cs

@@ -0,0 +1,128 @@
+// Copyright (c) Six Labors.
+// Licensed under the Six Labors Split License.
+
+using System;
+using System.Numerics;
+using System.Runtime.CompilerServices;
+using System.Runtime.InteropServices;
+
+// ReSharper disable ImpureMethodCallOnReadonlyValueField
+namespace SixLabors.ImageSharp.Formats.Jpeg.Components
+{
+    internal abstract partial class JpegColorConverterBase
+    {
+        internal sealed class YCbCrVector : JpegColorConverterVector
+        {
+            public YCbCrVector(int precision)
+                : base(JpegColorSpace.YCbCr, precision)
+            {
+            }
+
+            /// <inheritdoc/>
+            protected override void ConvertToRgbInplaceVectorized(in ComponentValues values)
+            {
+                ref Vector<float> c0Base =
+                    ref Unsafe.As<float, Vector<float>>(ref MemoryMarshal.GetReference(values.Component0));
+                ref Vector<float> c1Base =
+                    ref Unsafe.As<float, Vector<float>>(ref MemoryMarshal.GetReference(values.Component1));
+                ref Vector<float> c2Base =
+                    ref Unsafe.As<float, Vector<float>>(ref MemoryMarshal.GetReference(values.Component2));
+
+                var chromaOffset = new Vector<float>(-this.HalfValue);
+
+                var scale = new Vector<float>(1 / this.MaximumValue);
+                var rCrMult = new Vector<float>(YCbCrScalar.RCrMult);
+                var gCbMult = new Vector<float>(-YCbCrScalar.GCbMult);
+                var gCrMult = new Vector<float>(-YCbCrScalar.GCrMult);
+                var bCbMult = new Vector<float>(YCbCrScalar.BCbMult);
+
+                nint n = values.Component0.Length / Vector<float>.Count;
+                for (nint i = 0; i < n; i++)
+                {
+                    // y = yVals[i];
+                    // cb = cbVals[i] - 128F;
+                    // cr = crVals[i] - 128F;
+                    ref Vector<float> c0 = ref Unsafe.Add(ref c0Base, i);
+                    ref Vector<float> c1 = ref Unsafe.Add(ref c1Base, i);
+                    ref Vector<float> c2 = ref Unsafe.Add(ref c2Base, i);
+                    Vector<float> y = Unsafe.Add(ref c0Base, i);
+                    Vector<float> cb = Unsafe.Add(ref c1Base, i) + chromaOffset;
+                    Vector<float> cr = Unsafe.Add(ref c2Base, i) + chromaOffset;
+
+                    // r = y + (1.402F * cr);
+                    // g = y - (0.344136F * cb) - (0.714136F * cr);
+                    // b = y + (1.772F * cb);
+                    Vector<float> r = y + (cr * rCrMult);
+                    Vector<float> g = y + (cb * gCbMult) + (cr * gCrMult);
+                    Vector<float> b = y + (cb * bCbMult);
+
+                    r = r.FastRound();
+                    g = g.FastRound();
+                    b = b.FastRound();
+                    r *= scale;
+                    g *= scale;
+                    b *= scale;
+
+                    c0 = r;
+                    c1 = g;
+                    c2 = b;
+                }
+            }
+
+            /// <inheritdoc/>
+            protected override void ConvertToRgbInplaceScalarRemainder(in ComponentValues values)
+                => YCbCrScalar.ConvertToRgbInplace(values, this.MaximumValue, this.HalfValue);
+
+            /// <inheritdoc/>
+            protected override void ConvertFromRgbVectorized(in ComponentValues values, Span<float> rLane, Span<float> gLane, Span<float> bLane)
+            {
+                ref Vector<float> destY =
+                    ref Unsafe.As<float, Vector<float>>(ref MemoryMarshal.GetReference(values.Component0));
+                ref Vector<float> destCb =
+                    ref Unsafe.As<float, Vector<float>>(ref MemoryMarshal.GetReference(values.Component1));
+                ref Vector<float> destCr =
+                    ref Unsafe.As<float, Vector<float>>(ref MemoryMarshal.GetReference(values.Component2));
+
+                ref Vector<float> srcR =
+                    ref Unsafe.As<float, Vector<float>>(ref MemoryMarshal.GetReference(rLane));
+                ref Vector<float> srcG =
+                    ref Unsafe.As<float, Vector<float>>(ref MemoryMarshal.GetReference(gLane));
+                ref Vector<float> srcB =
+                    ref Unsafe.As<float, Vector<float>>(ref MemoryMarshal.GetReference(bLane));
+
+                var chromaOffset = new Vector<float>(this.HalfValue);
+
+                var rYMult = new Vector<float>(0.299f);
+                var gYMult = new Vector<float>(0.587f);
+                var bYMult = new Vector<float>(0.114f);
+
+                var rCbMult = new Vector<float>(0.168736f);
+                var gCbMult = new Vector<float>(0.331264f);
+                var bCbMult = new Vector<float>(0.5f);
+
+                var rCrMult = new Vector<float>(0.5f);
+                var gCrMult = new Vector<float>(0.418688f);
+                var bCrMult = new Vector<float>(0.081312f);
+
+                nint n = values.Component0.Length / Vector<float>.Count;
+                for (nint i = 0; i < n; i++)
+                {
+                    Vector<float> r = Unsafe.Add(ref srcR, i);
+                    Vector<float> g = Unsafe.Add(ref srcG, i);
+                    Vector<float> b = Unsafe.Add(ref srcB, i);
+
+                    // y  =   0 + (0.299 * r) + (0.587 * g) + (0.114 * b)
+                    // cb = 128 - (0.168736 * r) - (0.331264 * g) + (0.5 * b)
+                    // cr = 128 + (0.5 * r) - (0.418688 * g) - (0.081312 * b)
+                    Unsafe.Add(ref destY, i) = (rYMult * r) + (gYMult * g) + (bYMult * b);
+                    Unsafe.Add(ref destCb, i) = chromaOffset - (rCbMult * r) - (gCbMult * g) + (bCbMult * b);
+                    Unsafe.Add(ref destCr, i) = chromaOffset + (rCrMult * r) - (gCrMult * g) - (bCrMult * b);
+                }
+            }
+
+            /// <inheritdoc/>
+            protected override void ConvertFromRgbScalarRemainder(in ComponentValues values, Span<float> r, Span<float> g, Span<float> b)
+                => YCbCrScalar.ConvertFromRgb(values, this.HalfValue, r, g, b);
+        }
+    }
+}

src/ImageSharp/Formats/Jpeg/Components/ColorConverters/JpegColorConverter.YccKAvx.cs

@@ -0,0 +1,136 @@
+// Copyright (c) Six Labors.
+// Licensed under the Six Labors Split License.
+
+#if SUPPORTS_RUNTIME_INTRINSICS
+using System;
+using System.Runtime.CompilerServices;
+using System.Runtime.InteropServices;
+using System.Runtime.Intrinsics;
+using System.Runtime.Intrinsics.X86;
+using static SixLabors.ImageSharp.SimdUtils;
+
+namespace SixLabors.ImageSharp.Formats.Jpeg.Components
+{
+    internal abstract partial class JpegColorConverterBase
+    {
+        internal sealed class YccKAvx : JpegColorConverterAvx
+        {
+            public YccKAvx(int precision)
+                : base(JpegColorSpace.Ycck, precision)
+            {
+            }
+
+            /// <inheritdoc/>
+            public override void ConvertToRgbInplace(in ComponentValues values)
+            {
+                ref Vector256<float> c0Base =
+                    ref Unsafe.As<float, Vector256<float>>(ref MemoryMarshal.GetReference(values.Component0));
+                ref Vector256<float> c1Base =
+                    ref Unsafe.As<float, Vector256<float>>(ref MemoryMarshal.GetReference(values.Component1));
+                ref Vector256<float> c2Base =
+                    ref Unsafe.As<float, Vector256<float>>(ref MemoryMarshal.GetReference(values.Component2));
+                ref Vector256<float> kBase =
+                    ref Unsafe.As<float, Vector256<float>>(ref MemoryMarshal.GetReference(values.Component3));
+
+                // Used for the color conversion
+                var chromaOffset = Vector256.Create(-this.HalfValue);
+                var scale = Vector256.Create(1 / (this.MaximumValue * this.MaximumValue));
+                var max = Vector256.Create(this.MaximumValue);
+                var rCrMult = Vector256.Create(YCbCrScalar.RCrMult);
+                var gCbMult = Vector256.Create(-YCbCrScalar.GCbMult);
+                var gCrMult = Vector256.Create(-YCbCrScalar.GCrMult);
+                var bCbMult = Vector256.Create(YCbCrScalar.BCbMult);
+
+                // Walking 8 elements at one step:
+                nint n = values.Component0.Length / Vector256<float>.Count;
+                for (nint i = 0; i < n; i++)
+                {
+                    // y = yVals[i];
+                    // cb = cbVals[i] - 128F;
+                    // cr = crVals[i] - 128F;
+                    // k = kVals[i] / 256F;
+                    ref Vector256<float> c0 = ref Unsafe.Add(ref c0Base, i);
+                    ref Vector256<float> c1 = ref Unsafe.Add(ref c1Base, i);
+                    ref Vector256<float> c2 = ref Unsafe.Add(ref c2Base, i);
+                    Vector256<float> y = c0;
+                    Vector256<float> cb = Avx.Add(c1, chromaOffset);
+                    Vector256<float> cr = Avx.Add(c2, chromaOffset);
+                    Vector256<float> scaledK = Avx.Multiply(Unsafe.Add(ref kBase, i), scale);
+
+                    // r = y + (1.402F * cr);
+                    // g = y - (0.344136F * cb) - (0.714136F * cr);
+                    // b = y + (1.772F * cb);
+                    Vector256<float> r = HwIntrinsics.MultiplyAdd(y, cr, rCrMult);
+                    Vector256<float> g =
+                        HwIntrinsics.MultiplyAdd(HwIntrinsics.MultiplyAdd(y, cb, gCbMult), cr, gCrMult);
+                    Vector256<float> b = HwIntrinsics.MultiplyAdd(y, cb, bCbMult);
+
+                    r = Avx.Subtract(max, Avx.RoundToNearestInteger(r));
+                    g = Avx.Subtract(max, Avx.RoundToNearestInteger(g));
+                    b = Avx.Subtract(max, Avx.RoundToNearestInteger(b));
+
+                    r = Avx.Multiply(r, scaledK);
+                    g = Avx.Multiply(g, scaledK);
+                    b = Avx.Multiply(b, scaledK);
+
+                    c0 = r;
+                    c1 = g;
+                    c2 = b;
+                }
+            }
+
+            /// <inheritdoc/>
+            public override void ConvertFromRgb(in ComponentValues values, Span<float> rLane, Span<float> gLane, Span<float> bLane)
+            {
+                // rgb -> cmyk
+                CmykAvx.ConvertFromRgb(in values, this.MaximumValue, rLane, gLane, bLane);
+
+                // cmyk -> ycck
+                ref Vector256<float> destY =
+                    ref Unsafe.As<float, Vector256<float>>(ref MemoryMarshal.GetReference(values.Component0));
+                ref Vector256<float> destCb =
+                    ref Unsafe.As<float, Vector256<float>>(ref MemoryMarshal.GetReference(values.Component1));
+                ref Vector256<float> destCr =
+                    ref Unsafe.As<float, Vector256<float>>(ref MemoryMarshal.GetReference(values.Component2));
+
+                ref Vector256<float> srcR = ref destY;
+                ref Vector256<float> srcG = ref destCb;
+                ref Vector256<float> srcB = ref destCr;
+
+                // Used for the color conversion
+                var maxSampleValue = Vector256.Create(this.MaximumValue);
+
+                var chromaOffset = Vector256.Create(this.HalfValue);
+
+                var f0299 = Vector256.Create(0.299f);
+                var f0587 = Vector256.Create(0.587f);
+                var f0114 = Vector256.Create(0.114f);
+                var fn0168736 = Vector256.Create(-0.168736f);
+                var fn0331264 = Vector256.Create(-0.331264f);
+                var fn0418688 = Vector256.Create(-0.418688f);
+                var fn0081312F = Vector256.Create(-0.081312F);
+                var f05 = Vector256.Create(0.5f);
+
+                nint n = values.Component0.Length / Vector256<float>.Count;
+                for (nint i = 0; i < n; i++)
+                {
+                    Vector256<float> r = Avx.Subtract(maxSampleValue, Unsafe.Add(ref srcR, i));
+                    Vector256<float> g = Avx.Subtract(maxSampleValue, Unsafe.Add(ref srcG, i));
+                    Vector256<float> b = Avx.Subtract(maxSampleValue, Unsafe.Add(ref srcB, i));
+
+                    // y  =   0 + (0.299 * r) + (0.587 * g) + (0.114 * b)
+                    // cb = 128 - (0.168736 * r) - (0.331264 * g) + (0.5 * b)
+                    // cr = 128 + (0.5 * r) - (0.418688 * g) - (0.081312 * b)
+                    Vector256<float> y = HwIntrinsics.MultiplyAdd(HwIntrinsics.MultiplyAdd(Avx.Multiply(f0114, b), f0587, g), f0299, r);
+                    Vector256<float> cb = Avx.Add(chromaOffset, HwIntrinsics.MultiplyAdd(HwIntrinsics.MultiplyAdd(Avx.Multiply(f05, b), fn0331264, g), fn0168736, r));
+                    Vector256<float> cr = Avx.Add(chromaOffset, HwIntrinsics.MultiplyAdd(HwIntrinsics.MultiplyAdd(Avx.Multiply(fn0081312F, b), fn0418688, g), f05, r));
+
+                    Unsafe.Add(ref destY, i) = y;
+                    Unsafe.Add(ref destCb, i) = cb;
+                    Unsafe.Add(ref destCr, i) = cr;
+                }
+            }
+        }
+    }
+}
+#endif

src/ImageSharp/Formats/Jpeg/Components/ColorConverters/JpegColorConverter.YccKScalar.cs

@@ -0,0 +1,80 @@
+// Copyright (c) Six Labors.
+// Licensed under the Six Labors Split License.
+
+using System;
+
+namespace SixLabors.ImageSharp.Formats.Jpeg.Components
+{
+    internal abstract partial class JpegColorConverterBase
+    {
+        internal sealed class YccKScalar : JpegColorConverterScalar
+        {
+            // derived from ITU-T Rec. T.871
+            internal const float RCrMult = 1.402f;
+            internal const float GCbMult = (float)(0.114 * 1.772 / 0.587);
+            internal const float GCrMult = (float)(0.299 * 1.402 / 0.587);
+            internal const float BCbMult = 1.772f;
+
+            public YccKScalar(int precision)
+                : base(JpegColorSpace.Ycck, precision)
+            {
+            }
+
+            /// <inheritdoc/>
+            public override void ConvertToRgbInplace(in ComponentValues values)
+                => ConvertToRgpInplace(values, this.MaximumValue, this.HalfValue);
+
+            /// <inheritdoc/>
+            public override void ConvertFromRgb(in ComponentValues values, Span<float> r, Span<float> g, Span<float> b)
+                => ConvertFromRgb(values, this.HalfValue, this.MaximumValue, r, g, b);
+
+            public static void ConvertToRgpInplace(in ComponentValues values, float maxValue, float halfValue)
+            {
+                Span<float> c0 = values.Component0;
+                Span<float> c1 = values.Component1;
+                Span<float> c2 = values.Component2;
+                Span<float> c3 = values.Component3;
+
+                float scale = 1 / (maxValue * maxValue);
+
+                for (int i = 0; i < values.Component0.Length; i++)
+                {
+                    float y = c0[i];
+                    float cb = c1[i] - halfValue;
+                    float cr = c2[i] - halfValue;
+                    float scaledK = c3[i] * scale;
+
+                    // r = y + (1.402F * cr);
+                    // g = y - (0.344136F * cb) - (0.714136F * cr);
+                    // b = y + (1.772F * cb);
+                    c0[i] = (maxValue - MathF.Round(y + (RCrMult * cr), MidpointRounding.AwayFromZero)) * scaledK;
+                    c1[i] = (maxValue - MathF.Round(y - (GCbMult * cb) - (GCrMult * cr), MidpointRounding.AwayFromZero)) * scaledK;
+                    c2[i] = (maxValue - MathF.Round(y + (BCbMult * cb), MidpointRounding.AwayFromZero)) * scaledK;
+                }
+            }
+
+            public static void ConvertFromRgb(in ComponentValues values, float halfValue, float maxValue, Span<float> rLane, Span<float> gLane, Span<float> bLane)
+            {
+                // rgb -> cmyk
+                CmykScalar.ConvertFromRgb(in values, maxValue, rLane, gLane, bLane);
+
+                // cmyk -> ycck
+                Span<float> c = values.Component0;
+                Span<float> m = values.Component1;
+                Span<float> y = values.Component2;
+
+                for (int i = 0; i < y.Length; i++)
+                {
+                    float r = maxValue - c[i];
+                    float g = maxValue - m[i];
+                    float b = maxValue - y[i];
+
+                    // k value is passed untouched from rgb -> cmyk conversion
+                    c[i] = (0.299f * r) + (0.587f * g) + (0.114f * b);
+                    m[i] = halfValue - (0.168736f * r) - (0.331264f * g) + (0.5f * b);
+                    y[i] = halfValue + (0.5f * r) - (0.418688f * g) - (0.081312f * b);
+                }
+            }
+        }
+    }
+}

src/ImageSharp/Formats/Jpeg/Components/ColorConverters/JpegColorConverter.YccKVector.cs

@@ -0,0 +1,138 @@
+// Copyright (c) Six Labors.
+// Licensed under the Six Labors Split License.
+
+using System;
+using System.Numerics;
+using System.Runtime.CompilerServices;
+using System.Runtime.InteropServices;
+
+namespace SixLabors.ImageSharp.Formats.Jpeg.Components
+{
+    internal abstract partial class JpegColorConverterBase
+    {
+        internal sealed class YccKVector : JpegColorConverterVector
+        {
+            public YccKVector(int precision)
+                : base(JpegColorSpace.Ycck, precision)
+            {
+            }
+
+            /// <inheritdoc/>
+            protected override void ConvertToRgbInplaceVectorized(in ComponentValues values)
+            {
+                ref Vector<float> c0Base =
+                    ref Unsafe.As<float, Vector<float>>(ref MemoryMarshal.GetReference(values.Component0));
+                ref Vector<float> c1Base =
+                    ref Unsafe.As<float, Vector<float>>(ref MemoryMarshal.GetReference(values.Component1));
+                ref Vector<float> c2Base =
+                    ref Unsafe.As<float, Vector<float>>(ref MemoryMarshal.GetReference(values.Component2));
+                ref Vector<float> kBase =
+                    ref Unsafe.As<float, Vector<float>>(ref MemoryMarshal.GetReference(values.Component3));
+
+                var chromaOffset = new Vector<float>(-this.HalfValue);
+                var scale = new Vector<float>(1 / (this.MaximumValue * this.MaximumValue));
+                var max = new Vector<float>(this.MaximumValue);
+                var rCrMult = new Vector<float>(YCbCrScalar.RCrMult);
+                var gCbMult = new Vector<float>(-YCbCrScalar.GCbMult);
+                var gCrMult = new Vector<float>(-YCbCrScalar.GCrMult);
+                var bCbMult = new Vector<float>(YCbCrScalar.BCbMult);
+
+                nint n = values.Component0.Length / Vector<float>.Count;
+                for (nint i = 0; i < n; i++)
+                {
+                    // y = yVals[i];
+                    // cb = cbVals[i] - 128F;
+                    // cr = crVals[i] - 128F;
+                    // k = kVals[i] / 256F;
+                    ref Vector<float> c0 = ref Unsafe.Add(ref c0Base, i);
+                    ref Vector<float> c1 = ref Unsafe.Add(ref c1Base, i);
+                    ref Vector<float> c2 = ref Unsafe.Add(ref c2Base, i);
+
+                    Vector<float> y = c0;
+                    Vector<float> cb = c1 + chromaOffset;
+                    Vector<float> cr = c2 + chromaOffset;
+                    Vector<float> scaledK = Unsafe.Add(ref kBase, i) * scale;
+
+                    // r = y + (1.402F * cr);
+                    // g = y - (0.344136F * cb) - (0.714136F * cr);
+                    // b = y + (1.772F * cb);
+                    Vector<float> r = y + (cr * rCrMult);
+                    Vector<float> g = y + (cb * gCbMult) + (cr * gCrMult);
+                    Vector<float> b = y + (cb * bCbMult);
+
+                    r = (max - r.FastRound()) * scaledK;
+                    g = (max - g.FastRound()) * scaledK;
+                    b = (max - b.FastRound()) * scaledK;
+
+                    c0 = r;
+                    c1 = g;
+                    c2 = b;
+                }
+            }
+
+            /// <inheritdoc/>
+            protected override void ConvertToRgbInplaceScalarRemainder(in ComponentValues values)
+                => YccKScalar.ConvertToRgpInplace(values, this.MaximumValue, this.HalfValue);
+
+            /// <inheritdoc/>
+            protected override void ConvertFromRgbVectorized(in ComponentValues values, Span<float> rLane, Span<float> gLane, Span<float> bLane)
+            {
+                // rgb -> cmyk
+                CmykVector.ConvertFromRgbInplaceVectorized(in values, this.MaximumValue, rLane, gLane, bLane);
+
+                // cmyk -> ycck
+                ref Vector<float> destY =
+                    ref Unsafe.As<float, Vector<float>>(ref MemoryMarshal.GetReference(values.Component0));
+                ref Vector<float> destCb =
+                    ref Unsafe.As<float, Vector<float>>(ref MemoryMarshal.GetReference(values.Component1));
+                ref Vector<float> destCr =
+                    ref Unsafe.As<float, Vector<float>>(ref MemoryMarshal.GetReference(values.Component2));
+
+                ref Vector<float> srcR = ref destY;
+                ref Vector<float> srcG = ref destCb;
+                ref Vector<float> srcB = ref destCr;
+
+                var maxSampleValue = new Vector<float>(this.MaximumValue);
+
+                var chromaOffset = new Vector<float>(this.HalfValue);
+
+                var rYMult = new Vector<float>(0.299f);
+                var gYMult = new Vector<float>(0.587f);
+                var bYMult = new Vector<float>(0.114f);
+
+                var rCbMult = new Vector<float>(0.168736f);
+                var gCbMult = new Vector<float>(0.331264f);
+                var bCbMult = new Vector<float>(0.5f);
+
+                var rCrMult = new Vector<float>(0.5f);
+                var gCrMult = new Vector<float>(0.418688f);
+                var bCrMult = new Vector<float>(0.081312f);
+
+                nint n = values.Component0.Length / Vector<float>.Count;
+                for (nint i = 0; i < n; i++)
+                {
+                    Vector<float> r = maxSampleValue - Unsafe.Add(ref srcR, i);
+                    Vector<float> g = maxSampleValue - Unsafe.Add(ref srcG, i);
+                    Vector<float> b = maxSampleValue - Unsafe.Add(ref srcB, i);
+
+                    // y  =   0 + (0.299 * r) + (0.587 * g) + (0.114 * b)
+                    // cb = 128 - (0.168736 * r) - (0.331264 * g) + (0.5 * b)
+                    // cr = 128 + (0.5 * r) - (0.418688 * g) - (0.081312 * b)
+                    Unsafe.Add(ref destY, i) = (rYMult * r) + (gYMult * g) + (bYMult * b);
+                    Unsafe.Add(ref destCb, i) = chromaOffset - (rCbMult * r) - (gCbMult * g) + (bCbMult * b);
+                    Unsafe.Add(ref destCr, i) = chromaOffset + (rCrMult * r) - (gCrMult * g) - (bCrMult * b);
+                }
+            }
+
+            /// <inheritdoc/>
+            protected override void ConvertFromRgbScalarRemainder(in ComponentValues values, Span<float> r, Span<float> g, Span<float> b)
+            {
+                // rgb -> cmyk
+                CmykScalar.ConvertFromRgb(in values, this.MaximumValue, r, g, b);
+
+                // cmyk -> ycck
+                YccKScalar.ConvertFromRgb(in values, this.HalfValue, this.MaximumValue, r, g, b);
+            }
+        }
+    }
+}

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

@@ -3,7 +3,7 @@
 using System.Runtime.Intrinsics;
 using System.Runtime.Intrinsics.X86;
 
-namespace SixLabors.ImageSharp.Formats.Jpeg.Components.Decoder.ColorConverters
+namespace SixLabors.ImageSharp.Formats.Jpeg.Components
 {
     internal abstract partial class JpegColorConverterBase
     {
@@ -25,7 +25,9 @@ namespace SixLabors.ImageSharp.Formats.Jpeg.Components.Decoder.ColorConverters
             {
             }
 
-            public sealed override bool IsAvailable => Avx.IsSupported;
+            public static bool IsSupported => Avx.IsSupported;
+
+            public sealed override bool IsAvailable => IsSupported;
 
             public sealed override int ElementsPerBatch => Vector256<float>.Count;
         }

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

@@ -3,10 +3,9 @@
 
 using System;
 using System.Collections.Generic;
-using System.Linq;
 using SixLabors.ImageSharp.Memory;
 
-namespace SixLabors.ImageSharp.Formats.Jpeg.Components.Decoder.ColorConverters
+namespace SixLabors.ImageSharp.Formats.Jpeg.Components
 {
     /// <summary>
     /// Encapsulates the conversion of color channels from jpeg image to RGB channels.
@@ -88,78 +87,130 @@ namespace SixLabors.ImageSharp.Formats.Jpeg.Components.Decoder.ColorConverters
         /// <param name="values">The input/ouptut as a stack-only <see cref="ComponentValues"/> struct</param>
         public abstract void ConvertToRgbInplace(in ComponentValues values);
 
+        /// <summary>
+        /// Converts RGB lanes to jpeg component values.
+        /// </summary>
+        /// <param name="values">Jpeg component values.</param>
+        /// <param name="rLane">Red colors lane.</param>
+        /// <param name="gLane">Green colors lane.</param>
+        /// <param name="bLane">Blue colors lane.</param>
+        public abstract void ConvertFromRgb(in ComponentValues values, Span<float> rLane, Span<float> gLane, Span<float> bLane);
+
         /// <summary>
         /// Returns the <see cref="JpegColorConverterBase"/>s for all supported colorspaces and precisions.
         /// </summary>
         private static JpegColorConverterBase[] CreateConverters()
         {
-            var converters = new List<JpegColorConverterBase>();
+            // 5 color types with 2 supported precisions: 8 bit & 12 bit
+            const int colorConvertersCount = 5 * 2;
+
+            var converters = new JpegColorConverterBase[colorConvertersCount];
 
             // 8-bit converters
-            converters.AddRange(GetYCbCrConverters(8));
+            converters[0] = GetYCbCrConverter(8);
-            converters.AddRange(GetYccKConverters(8));
+            converters[1] = GetYccKConverter(8);
-            converters.AddRange(GetCmykConverters(8));
+            converters[2] = GetCmykConverter(8);
-            converters.AddRange(GetGrayScaleConverters(8));
+            converters[3] = GetGrayScaleConverter(8);
-            converters.AddRange(GetRgbConverters(8));
+            converters[4] = GetRgbConverter(8);
 
             // 12-bit converters
-            converters.AddRange(GetYCbCrConverters(12));
+            converters[5] = GetYCbCrConverter(12);
-            converters.AddRange(GetYccKConverters(12));
+            converters[6] = GetYccKConverter(12);
-            converters.AddRange(GetCmykConverters(12));
+            converters[7] = GetCmykConverter(12);
-            converters.AddRange(GetGrayScaleConverters(12));
+            converters[8] = GetGrayScaleConverter(12);
-            converters.AddRange(GetRgbConverters(12));
+            converters[9] = GetRgbConverter(12);
 
-            return converters.Where(x => x.IsAvailable).ToArray();
+            return converters;
         }
 
         /// <summary>
         /// Returns the <see cref="JpegColorConverterBase"/>s for the YCbCr colorspace.
         /// </summary>
-        private static IEnumerable<JpegColorConverterBase> GetYCbCrConverters(int precision)
+        private static JpegColorConverterBase GetYCbCrConverter(int precision)
         {
-            yield return new FromYCbCrAvx(precision);
+            if (JpegColorConverterAvx.IsSupported)
-            yield return new FromYCbCrVector(precision);
+            {
-            yield return new FromYCbCrScalar(precision);
+                return new YCbCrAvx(precision);
+            }
+
+            if (JpegColorConverterVector.IsSupported)
+            {
+                return new YCbCrVector(precision);
+            }
+
+            return new YCbCrScalar(precision);
         }
 
         /// <summary>
         /// Returns the <see cref="JpegColorConverterBase"/>s for the YccK colorspace.
         /// </summary>
-        private static IEnumerable<JpegColorConverterBase> GetYccKConverters(int precision)
+        private static JpegColorConverterBase GetYccKConverter(int precision)
         {
-            yield return new FromYccKAvx(precision);
+            if (JpegColorConverterAvx.IsSupported)
-            yield return new FromYccKVector(precision);
+            {
-            yield return new FromYccKScalar(precision);
+                return new YccKAvx(precision);
+            }
+
+            if (JpegColorConverterVector.IsSupported)
+            {
+                return new YccKVector(precision);
+            }
+
+            return new YccKScalar(precision);
         }
 
         /// <summary>
         /// Returns the <see cref="JpegColorConverterBase"/>s for the CMYK colorspace.
         /// </summary>
-        private static IEnumerable<JpegColorConverterBase> GetCmykConverters(int precision)
+        private static JpegColorConverterBase GetCmykConverter(int precision)
         {
-            yield return new FromCmykAvx(precision);
+            if (JpegColorConverterAvx.IsSupported)
-            yield return new FromCmykVector(precision);
+            {
-            yield return new FromCmykScalar(precision);
+                return new CmykAvx(precision);
+            }
+
+            if (JpegColorConverterVector.IsSupported)
+            {
+                return new CmykVector(precision);
+            }
+
+            return new CmykScalar(precision);
         }
 
         /// <summary>
         /// Returns the <see cref="JpegColorConverterBase"/>s for the gray scale colorspace.
         /// </summary>
-        private static IEnumerable<JpegColorConverterBase> GetGrayScaleConverters(int precision)
+        private static JpegColorConverterBase GetGrayScaleConverter(int precision)
         {
-            yield return new FromGrayscaleAvx(precision);
+            if (JpegColorConverterAvx.IsSupported)
-            yield return new FromGrayScaleVector(precision);
+            {
-            yield return new FromGrayscaleScalar(precision);
+                return new GrayscaleAvx(precision);
+            }
+
+            if (JpegColorConverterVector.IsSupported)
+            {
+                return new GrayScaleVector(precision);
+            }
+
+            return new GrayscaleScalar(precision);
         }
 
         /// <summary>
         /// Returns the <see cref="JpegColorConverterBase"/>s for the RGB colorspace.
         /// </summary>
-        private static IEnumerable<JpegColorConverterBase> GetRgbConverters(int precision)
+        private static JpegColorConverterBase GetRgbConverter(int precision)
         {
-            yield return new FromRgbAvx(precision);
+            if (JpegColorConverterAvx.IsSupported)
-            yield return new FromRgbVector(precision);
+            {
-            yield return new FromRgbScalar(precision);
+                return new RgbAvx(precision);
+            }
+
+            if (JpegColorConverterVector.IsSupported)
+            {
+                return new RgbScalar(precision);
+            }
+
+            return new GrayscaleScalar(precision);
         }
 
         /// <summary>
@@ -218,7 +269,26 @@ namespace SixLabors.ImageSharp.Formats.Jpeg.Components.Decoder.ColorConverters
             /// </summary>
             /// <param name="processors">List of component color processors.</param>
             /// <param name="row">Row to convert</param>
-            public ComponentValues(IReadOnlyList<ComponentProcessor> processors, int row)
+            public ComponentValues(IReadOnlyList<Decoder.ComponentProcessor> 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 ? 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;
+            }
+
+            /// <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<Encoder.ComponentProcessor> processors, int row)
             {
                 DebugGuard.MustBeGreaterThan(processors.Count, 0, nameof(processors));
 

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

@@ -1,7 +1,7 @@
 // Copyright (c) Six Labors.
 // Licensed under the Six Labors Split License.
 
-namespace SixLabors.ImageSharp.Formats.Jpeg.Components.Decoder.ColorConverters
+namespace SixLabors.ImageSharp.Formats.Jpeg.Components
 {
     internal abstract partial class JpegColorConverterBase
     {

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

@@ -0,0 +1,131 @@
+// Copyright (c) Six Labors.
+// Licensed under the Six Labors Split License.
+
+using System;
+using System.Numerics;
+
+namespace SixLabors.ImageSharp.Formats.Jpeg.Components
+{
+    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)
+            {
+            }
+
+            /// <summary>
+            /// Gets a value indicating whether this converter is supported on current hardware.
+            /// </summary>
+            public static bool IsSupported => Vector.IsHardwareAccelerated && Vector<float>.Count % 4 == 0;
+
+            /// <inheritdoc/>
+            public sealed override bool IsAvailable => IsSupported;
+
+            public override int ElementsPerBatch => Vector<float>.Count;
+
+            /// <inheritdoc/>
+            public sealed override void ConvertToRgbInplace(in ComponentValues values)
+            {
+                DebugGuard.IsTrue(this.IsAvailable, $"{this.GetType().Name} converter is not supported on current hardware.");
+
+                int length = values.Component0.Length;
+                int remainder = (int)((uint)length % (uint)Vector<float>.Count);
+
+                int simdCount = length - remainder;
+                if (simdCount > 0)
+                {
+                    this.ConvertToRgbInplaceVectorized(values.Slice(0, simdCount));
+                }
+
+                // Jpeg images width is always divisible by 8 without a remainder
+                // so it's safe to say SSE/AVX1/AVX2 implementations would never have
+                // 'remainder' pixels
+                // But some exotic simd implementations e.g. AVX-512 can have
+                // remainder pixels
+                if (remainder > 0)
+                {
+                    this.ConvertToRgbInplaceScalarRemainder(values.Slice(simdCount, remainder));
+                }
+            }
+
+            /// <inheritdoc/>
+            public sealed override void ConvertFromRgb(in ComponentValues values, Span<float> r, Span<float> g, Span<float> b)
+            {
+                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);
+
+                int simdCount = length - remainder;
+                if (simdCount > 0)
+                {
+                    this.ConvertFromRgbVectorized(
+                        values.Slice(0, simdCount),
+                        r.Slice(0, simdCount),
+                        g.Slice(0, simdCount),
+                        b.Slice(0, simdCount));
+                }
+
+                // Jpeg images width is always divisible by 8 without a remainder
+                // so it's safe to say SSE/AVX1/AVX2 implementations would never have
+                // 'remainder' pixels
+                // But some exotic simd implementations e.g. AVX-512 can have
+                // remainder pixels
+                if (remainder > 0)
+                {
+                    this.ConvertFromRgbScalarRemainder(
+                        values.Slice(simdCount, remainder),
+                        r.Slice(simdCount, remainder),
+                        g.Slice(simdCount, remainder),
+                        b.Slice(simdCount, remainder));
+                }
+            }
+
+            /// <summary>
+            /// Converts planar jpeg component values in <paramref name="values"/>
+            /// to RGB color space inplace using <see cref="Vector"/> API.
+            /// </summary>
+            /// <param name="values">The input/ouptut as a stack-only <see cref="ComponentValues"/> struct</param>
+            protected abstract void ConvertToRgbInplaceVectorized(in ComponentValues values);
+
+            /// <summary>
+            /// Converts remainder of the planar jpeg component values after
+            /// conversion in <see cref="ConvertToRgbInplaceVectorized(in ComponentValues)"/>.
+            /// </summary>
+            /// <param name="values">The input/ouptut as a stack-only <see cref="ComponentValues"/> struct</param>
+            protected abstract void ConvertToRgbInplaceScalarRemainder(in ComponentValues values);
+
+            /// <summary>
+            /// Converts RGB lanes to jpeg component values using <see cref="Vector"/> API.
+            /// </summary>
+            /// <param name="values">Jpeg component values.</param>
+            /// <param name="rLane">Red colors lane.</param>
+            /// <param name="gLane">Green colors lane.</param>
+            /// <param name="bLane">Blue colors lane.</param>
+            protected abstract void ConvertFromRgbVectorized(in ComponentValues values, Span<float> rLane, Span<float> gLane, Span<float> bLane);
+
+            /// <summary>
+            /// Converts remainder of RGB lanes to jpeg component values after
+            ///  conversion in <see cref="ConvertFromRgbVectorized(in ComponentValues, Span{float}, Span{float}, Span{float})"/>.
+            /// </summary>
+            /// <param name="values">Jpeg component values.</param>
+            /// <param name="rLane">Red colors lane.</param>
+            /// <param name="gLane">Green colors lane.</param>
+            /// <param name="bLane">Blue colors lane.</param>
+            protected abstract void ConvertFromRgbScalarRemainder(in ComponentValues values, Span<float> rLane, Span<float> gLane, Span<float> bLane);
+        }
+    }
+}

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

@@ -1,50 +0,0 @@
-// Copyright (c) Six Labors.
-// Licensed under the Six Labors Split License.
-
-using System.Runtime.CompilerServices;
-using System.Runtime.InteropServices;
-using System.Runtime.Intrinsics;
-using System.Runtime.Intrinsics.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);
-                }
-            }
-        }
-    }
-}

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

@@ -1,43 +0,0 @@
-// Copyright (c) Six Labors.
-// Licensed under the Six Labors Split License.
-
-using System;
-
-namespace SixLabors.ImageSharp.Formats.Jpeg.Components.Decoder.ColorConverters
-{
-    internal abstract partial class JpegColorConverterBase
-    {
-        internal sealed class FromCmykScalar : JpegColorConverterScalar
-        {
-            public FromCmykScalar(int precision)
-                : base(JpegColorSpace.Cmyk, precision)
-            {
-            }
-
-            public override void ConvertToRgbInplace(in ComponentValues values) =>
-                ConvertCoreInplace(values, this.MaximumValue);
-
-            internal static void ConvertCoreInplace(in ComponentValues values, float maxValue)
-            {
-                Span<float> c0 = values.Component0;
-                Span<float> c1 = values.Component1;
-                Span<float> c2 = values.Component2;
-                Span<float> c3 = values.Component3;
-
-                float scale = 1 / (maxValue * 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];
-
-                    k *= scale;
-                    c0[i] = c * k;
-                    c1[i] = m * k;
-                    c2[i] = y * k;
-                }
-            }
-        }
-    }
-}

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

@@ -1,51 +0,0 @@
-// Copyright (c) Six Labors.
-// Licensed under the Six Labors Split License.
-
-using System.Numerics;
-using System.Runtime.CompilerServices;
-using System.Runtime.InteropServices;
-
-namespace SixLabors.ImageSharp.Formats.Jpeg.Components.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.FromGrayScaleAvx.cs

@@ -1,37 +0,0 @@
-// Copyright (c) Six Labors.
-// Licensed under the Six Labors Split License.
-
-using System.Runtime.CompilerServices;
-using System.Runtime.InteropServices;
-using System.Runtime.Intrinsics;
-using System.Runtime.Intrinsics.X86;
-
-namespace SixLabors.ImageSharp.Formats.Jpeg.Components.Decoder.ColorConverters
-{
-    internal abstract partial class JpegColorConverterBase
-    {
-        internal sealed class FromGrayscaleAvx : JpegColorConverterAvx
-        {
-            public FromGrayscaleAvx(int precision)
-                : base(JpegColorSpace.Grayscale, precision)
-            {
-            }
-
-            public override void ConvertToRgbInplace(in ComponentValues values)
-            {
-                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 / 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);
-                }
-            }
-        }
-    }
-}

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

@@ -1,34 +0,0 @@
-// Copyright (c) Six Labors.
-// Licensed under the Six Labors Split License.
-
-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

@@ -1,38 +0,0 @@
-// Copyright (c) Six Labors.
-// Licensed under the Six Labors Split License.
-
-using System.Numerics;
-using System.Runtime.CompilerServices;
-using System.Runtime.InteropServices;
-
-namespace SixLabors.ImageSharp.Formats.Jpeg.Components.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.FromRgbScalar.cs

@@ -1,26 +0,0 @@
-// Copyright (c) Six Labors.
-// Licensed under the Six Labors Split License.
-
-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.FromYCbCrAvx.cs

@@ -1,72 +0,0 @@
-// Copyright (c) Six Labors.
-// Licensed under the Six Labors Split License.
-
-using System.Runtime.CompilerServices;
-using System.Runtime.InteropServices;
-using System.Runtime.Intrinsics;
-using System.Runtime.Intrinsics.X86;
-using static SixLabors.ImageSharp.SimdUtils;
-
-// ReSharper disable ImpureMethodCallOnReadonlyValueField
-namespace SixLabors.ImageSharp.Formats.Jpeg.Components.Decoder.ColorConverters
-{
-    internal abstract partial class JpegColorConverterBase
-    {
-        internal sealed class FromYCbCrAvx : JpegColorConverterAvx
-        {
-            public FromYCbCrAvx(int precision)
-                : base(JpegColorSpace.YCbCr, 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));
-
-                // Used for the color conversion
-                var chromaOffset = Vector256.Create(-this.HalfValue);
-                var scale = Vector256.Create(1 / this.MaximumValue);
-                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 / Vector256<float>.Count;
-                for (nint i = 0; i < n; i++)
-                {
-                    // y = yVals[i];
-                    // cb = cbVals[i] - 128F;
-                    // cr = crVals[i] - 128F;
-                    ref Vector256<float> c0 = ref Unsafe.Add(ref c0Base, i);
-                    ref Vector256<float> c1 = ref Unsafe.Add(ref c1Base, i);
-                    ref Vector256<float> c2 = ref Unsafe.Add(ref c2Base, i);
-
-                    Vector256<float> y = c0;
-                    Vector256<float> cb = Avx.Add(c1, chromaOffset);
-                    Vector256<float> cr = Avx.Add(c2, chromaOffset);
-
-                    // r = y + (1.402F * cr);
-                    // g = y - (0.344136F * cb) - (0.714136F * cr);
-                    // b = y + (1.772F * cb);
-                    Vector256<float> r = HwIntrinsics.MultiplyAdd(y, cr, rCrMult);
-                    Vector256<float> g = HwIntrinsics.MultiplyAdd(HwIntrinsics.MultiplyAdd(y, cb, gCbMult), cr, gCrMult);
-                    Vector256<float> b = HwIntrinsics.MultiplyAdd(y, cb, bCbMult);
-
-                    r = Avx.Multiply(Avx.RoundToNearestInteger(r), scale);
-                    g = Avx.Multiply(Avx.RoundToNearestInteger(g), scale);
-                    b = Avx.Multiply(Avx.RoundToNearestInteger(b), scale);
-
-                    c0 = r;
-                    c1 = g;
-                    c2 = b;
-                }
-            }
-        }
-    }
-}

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

@@ -1,50 +0,0 @@
-// Copyright (c) Six Labors.
-// Licensed under the Six Labors Split License.
-
-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.FromYCbCrVector.cs

@@ -1,74 +0,0 @@
-// Copyright (c) Six Labors.
-// Licensed under the Six Labors Split License.
-
-using System.Numerics;
-using System.Runtime.CompilerServices;
-using System.Runtime.InteropServices;
-
-// ReSharper disable ImpureMethodCallOnReadonlyValueField
-namespace SixLabors.ImageSharp.Formats.Jpeg.Components.Decoder.ColorConverters
-{
-    internal abstract partial class JpegColorConverterBase
-    {
-        internal sealed class FromYCbCrVector : JpegColorConverterVector
-        {
-            public FromYCbCrVector(int precision)
-                : base(JpegColorSpace.YCbCr, precision)
-            {
-            }
-
-            protected override void ConvertCoreVectorizedInplace(in ComponentValues values)
-            {
-                ref Vector<float> c0Base =
-                    ref Unsafe.As<float, Vector<float>>(ref MemoryMarshal.GetReference(values.Component0));
-                ref Vector<float> c1Base =
-                    ref Unsafe.As<float, Vector<float>>(ref MemoryMarshal.GetReference(values.Component1));
-                ref Vector<float> c2Base =
-                    ref Unsafe.As<float, Vector<float>>(ref MemoryMarshal.GetReference(values.Component2));
-
-                var chromaOffset = new Vector<float>(-this.HalfValue);
-
-                var scale = new Vector<float>(1 / this.MaximumValue);
-                var rCrMult = new Vector<float>(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];
-                    // cb = cbVals[i] - 128F;
-                    // cr = crVals[i] - 128F;
-                    ref Vector<float> c0 = ref Unsafe.Add(ref c0Base, i);
-                    ref Vector<float> c1 = ref Unsafe.Add(ref c1Base, i);
-                    ref Vector<float> c2 = ref Unsafe.Add(ref c2Base, i);
-                    Vector<float> y = Unsafe.Add(ref c0Base, i);
-                    Vector<float> cb = Unsafe.Add(ref c1Base, i) + chromaOffset;
-                    Vector<float> cr = Unsafe.Add(ref c2Base, i) + chromaOffset;
-
-                    // r = y + (1.402F * cr);
-                    // g = y - (0.344136F * cb) - (0.714136F * cr);
-                    // b = y + (1.772F * cb);
-                    Vector<float> r = y + (cr * rCrMult);
-                    Vector<float> g = y + (cb * gCbMult) + (cr * gCrMult);
-                    Vector<float> b = y + (cb * bCbMult);
-
-                    r = r.FastRound();
-                    g = g.FastRound();
-                    b = b.FastRound();
-                    r *= scale;
-                    g *= scale;
-                    b *= scale;
-
-                    c0 = r;
-                    c1 = g;
-                    c2 = b;
-                }
-            }
-
-            protected override void ConvertCoreInplace(in ComponentValues values) =>
-                FromYCbCrScalar.ConvertCoreInplace(values, this.MaximumValue, this.HalfValue);
-        }
-    }
-}

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

@@ -1,80 +0,0 @@
-// Copyright (c) Six Labors.
-// Licensed under the Six Labors Split License.
-
-using System.Runtime.CompilerServices;
-using System.Runtime.InteropServices;
-using System.Runtime.Intrinsics;
-using System.Runtime.Intrinsics.X86;
-using static SixLabors.ImageSharp.SimdUtils;
-
-namespace SixLabors.ImageSharp.Formats.Jpeg.Components.Decoder.ColorConverters
-{
-    internal abstract partial class JpegColorConverterBase
-    {
-        internal sealed class FromYccKAvx : JpegColorConverterAvx
-        {
-            public FromYccKAvx(int precision)
-                : base(JpegColorSpace.Ycck, 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> kBase =
-                    ref Unsafe.As<float, Vector256<float>>(ref MemoryMarshal.GetReference(values.Component3));
-
-                // Used for the color conversion
-                var chromaOffset = Vector256.Create(-this.HalfValue);
-                var scale = Vector256.Create(1 / (this.MaximumValue * this.MaximumValue));
-                var max = Vector256.Create(this.MaximumValue);
-                var rCrMult = Vector256.Create(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 / Vector256<float>.Count;
-                for (nint i = 0; i < n; i++)
-                {
-                    // y = yVals[i];
-                    // cb = cbVals[i] - 128F;
-                    // cr = crVals[i] - 128F;
-                    // k = kVals[i] / 256F;
-                    ref Vector256<float> c0 = ref Unsafe.Add(ref c0Base, i);
-                    ref Vector256<float> c1 = ref Unsafe.Add(ref c1Base, i);
-                    ref Vector256<float> c2 = ref Unsafe.Add(ref c2Base, i);
-                    Vector256<float> y = c0;
-                    Vector256<float> cb = Avx.Add(c1, chromaOffset);
-                    Vector256<float> cr = Avx.Add(c2, chromaOffset);
-                    Vector256<float> scaledK = Avx.Multiply(Unsafe.Add(ref kBase, i), scale);
-
-                    // r = y + (1.402F * cr);
-                    // g = y - (0.344136F * cb) - (0.714136F * cr);
-                    // b = y + (1.772F * cb);
-                    Vector256<float> r = HwIntrinsics.MultiplyAdd(y, cr, rCrMult);
-                    Vector256<float> g =
-                        HwIntrinsics.MultiplyAdd(HwIntrinsics.MultiplyAdd(y, cb, gCbMult), cr, gCrMult);
-                    Vector256<float> b = HwIntrinsics.MultiplyAdd(y, cb, bCbMult);
-
-                    r = Avx.Subtract(max, Avx.RoundToNearestInteger(r));
-                    g = Avx.Subtract(max, Avx.RoundToNearestInteger(g));
-                    b = Avx.Subtract(max, Avx.RoundToNearestInteger(b));
-
-                    r = Avx.Multiply(r, scaledK);
-                    g = Avx.Multiply(g, scaledK);
-                    b = Avx.Multiply(b, scaledK);
-
-                    c0 = r;
-                    c1 = g;
-                    c2 = b;
-                }
-            }
-        }
-    }
-}

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

@@ -1,43 +0,0 @@
-// Copyright (c) Six Labors.
-// Licensed under the Six Labors Split License.
-
-using System;
-
-namespace SixLabors.ImageSharp.Formats.Jpeg.Components.Decoder.ColorConverters
-{
-    internal abstract partial class JpegColorConverterBase
-    {
-        internal sealed class FromYccKScalar : JpegColorConverterScalar
-        {
-            public FromYccKScalar(int precision)
-                : base(JpegColorSpace.Ycck, 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;
-                Span<float> c3 = values.Component3;
-
-                float scale = 1 / (maxValue * maxValue);
-
-                for (int i = 0; i < values.Component0.Length; i++)
-                {
-                    float y = c0[i];
-                    float cb = c1[i] - halfValue;
-                    float cr = c2[i] - halfValue;
-                    float scaledK = c3[i] * scale;
-
-                    c0[i] = (maxValue - MathF.Round(y + (1.402F * cr), MidpointRounding.AwayFromZero)) * scaledK;
-                    c1[i] = (maxValue - MathF.Round(y - (0.344136F * cb) - (0.714136F * cr), MidpointRounding.AwayFromZero)) * scaledK;
-                    c2[i] = (maxValue - MathF.Round(y + (1.772F * cb), MidpointRounding.AwayFromZero)) * scaledK;
-                }
-            }
-        }
-    }
-}

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

@@ -1,75 +0,0 @@
-// Copyright (c) Six Labors.
-// Licensed under the Six Labors Split License.
-
-using System.Numerics;
-using System.Runtime.CompilerServices;
-using System.Runtime.InteropServices;
-
-namespace SixLabors.ImageSharp.Formats.Jpeg.Components.Decoder.ColorConverters
-{
-    internal abstract partial class JpegColorConverterBase
-    {
-        internal sealed class FromYccKVector : JpegColorConverterVector
-        {
-            public FromYccKVector(int precision)
-                : base(JpegColorSpace.Ycck, precision)
-            {
-            }
-
-            protected override void ConvertCoreVectorizedInplace(in ComponentValues values)
-            {
-                ref Vector<float> c0Base =
-                    ref Unsafe.As<float, Vector<float>>(ref MemoryMarshal.GetReference(values.Component0));
-                ref Vector<float> c1Base =
-                    ref Unsafe.As<float, Vector<float>>(ref MemoryMarshal.GetReference(values.Component1));
-                ref Vector<float> c2Base =
-                    ref Unsafe.As<float, Vector<float>>(ref MemoryMarshal.GetReference(values.Component2));
-                ref Vector<float> kBase =
-                    ref Unsafe.As<float, Vector<float>>(ref MemoryMarshal.GetReference(values.Component3));
-
-                var chromaOffset = new Vector<float>(-this.HalfValue);
-                var scale = new Vector<float>(1 / (this.MaximumValue * this.MaximumValue));
-                var max = new Vector<float>(this.MaximumValue);
-                var rCrMult = new Vector<float>(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];
-                    // cb = cbVals[i] - 128F;
-                    // cr = crVals[i] - 128F;
-                    // k = kVals[i] / 256F;
-                    ref Vector<float> c0 = ref Unsafe.Add(ref c0Base, i);
-                    ref Vector<float> c1 = ref Unsafe.Add(ref c1Base, i);
-                    ref Vector<float> c2 = ref Unsafe.Add(ref c2Base, i);
-
-                    Vector<float> y = c0;
-                    Vector<float> cb = c1 + chromaOffset;
-                    Vector<float> cr = c2 + chromaOffset;
-                    Vector<float> scaledK = Unsafe.Add(ref kBase, i) * scale;
-
-                    // r = y + (1.402F * cr);
-                    // g = y - (0.344136F * cb) - (0.714136F * cr);
-                    // b = y + (1.772F * cb);
-                    Vector<float> r = y + (cr * rCrMult);
-                    Vector<float> g = y + (cb * gCbMult) + (cr * gCrMult);
-                    Vector<float> b = y + (cb * bCbMult);
-
-                    r = (max - r.FastRound()) * scaledK;
-                    g = (max - g.FastRound()) * scaledK;
-                    b = (max - b.FastRound()) * scaledK;
-
-                    c0 = r;
-                    c1 = g;
-                    c2 = b;
-                }
-            }
-
-            protected override void ConvertCoreInplace(in ComponentValues values) =>
-                FromYccKScalar.ConvertCoreInplace(values, this.MaximumValue, this.HalfValue);
-        }
-    }
-}

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

@@ -1,61 +0,0 @@
-// Copyright (c) Six Labors.
-// Licensed under the Six Labors Split License.
-
-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 sealed override int ElementsPerBatch => Vector<float>.Count;
-
-            public sealed override void ConvertToRgbInplace(in ComponentValues values)
-            {
-                DebugGuard.IsTrue(this.IsAvailable, $"{this.GetType().Name} converter is not supported on current hardware.");
-
-                int length = values.Component0.Length;
-                int remainder = (int)((uint)length % (uint)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/JpegFrame.cs

@@ -12,7 +12,7 @@ namespace SixLabors.ImageSharp.Formats.Jpeg.Components.Decoder
     {
         public JpegFrame(JpegFileMarker sofMarker, byte precision, int width, int height, byte componentCount)
         {
-            this.Extended = sofMarker.Marker is JpegConstants.Markers.SOF1 or JpegConstants.Markers.SOF9;
+            this.IsExtended = sofMarker.Marker is JpegConstants.Markers.SOF1 or JpegConstants.Markers.SOF9;
             this.Progressive = sofMarker.Marker is JpegConstants.Markers.SOF2 or JpegConstants.Markers.SOF10;
 
             this.Precision = precision;
@@ -27,7 +27,7 @@ namespace SixLabors.ImageSharp.Formats.Jpeg.Components.Decoder
         /// <summary>
         /// Gets a value indicating whether the frame uses the extended specification.
         /// </summary>
-        public bool Extended { get; private set; }
+        public bool IsExtended { get; private set; }
 
         /// <summary>
         /// Gets a value indicating whether the frame uses the progressive specification.
@@ -40,7 +40,7 @@ namespace SixLabors.ImageSharp.Formats.Jpeg.Components.Decoder
         /// <remarks>
         /// This is true for progressive and baseline non-interleaved images.
         /// </remarks>
-        public bool MultiScan { get; set; }
+        public bool Interleaved { get; set; }
 
         /// <summary>
         /// Gets the precision.
@@ -141,7 +141,7 @@ namespace SixLabors.ImageSharp.Formats.Jpeg.Components.Decoder
 
         public void AllocateComponents()
         {
-            bool fullScan = this.Progressive || this.MultiScan;
+            bool fullScan = this.Progressive || !this.Interleaved;
             for (int i = 0; i < this.ComponentCount; i++)
             {
                 IJpegComponent component = this.Components[i];

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

@@ -1,12 +1,10 @@
 // Copyright (c) Six Labors.
 // Licensed under the Six Labors Split License.
 
-using SixLabors.ImageSharp.Formats.Jpeg.Components.Decoder.ColorConverters;
-
 namespace SixLabors.ImageSharp.Formats.Jpeg.Components.Decoder
 {
     /// <summary>
-    /// Converter used to convert jpeg spectral data to color pixels.
+    /// Converter used to convert jpeg spectral data to pixels.
     /// </summary>
     internal abstract class SpectralConverter
     {

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

@@ -5,7 +5,6 @@ using System;
 using System.Buffers;
 using System.Linq;
 using System.Threading;
-using SixLabors.ImageSharp.Formats.Jpeg.Components.Decoder.ColorConverters;
 using SixLabors.ImageSharp.Memory;
 using SixLabors.ImageSharp.PixelFormats;
 

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

@@ -0,0 +1,116 @@
+// Copyright (c) Six Labors.
+// Licensed under the Six Labors Split License.
+
+using System;
+using SixLabors.ImageSharp.Memory;
+
+namespace SixLabors.ImageSharp.Formats.Jpeg.Components.Encoder
+{
+    /// <summary>
+    /// Represents a single frame component.
+    /// </summary>
+    internal class Component : IDisposable
+    {
+        private readonly MemoryAllocator memoryAllocator;
+
+        public Component(MemoryAllocator memoryAllocator, int horizontalFactor, int verticalFactor, int quantizationTableIndex)
+        {
+            this.memoryAllocator = memoryAllocator;
+
+            this.HorizontalSamplingFactor = horizontalFactor;
+            this.VerticalSamplingFactor = verticalFactor;
+            this.SamplingFactors = new Size(horizontalFactor, verticalFactor);
+
+            this.QuantizationTableIndex = quantizationTableIndex;
+        }
+
+        /// <summary>
+        /// Gets or sets DC coefficient predictor.
+        /// </summary>
+        public int DcPredictor { get; set; }
+
+        /// <summary>
+        /// Gets the horizontal sampling factor.
+        /// </summary>
+        public int HorizontalSamplingFactor { get; }
+
+        /// <summary>
+        /// Gets the vertical sampling factor.
+        /// </summary>
+        public int VerticalSamplingFactor { get; }
+
+        public Buffer2D<Block8x8> SpectralBlocks { get; private set; }
+
+        public Size SubSamplingDivisors { get; private set; }
+
+        public int QuantizationTableIndex { get; }
+
+        public Size SizeInBlocks { get; private set; }
+
+        public Size SamplingFactors { get; set; }
+
+        /// <summary>
+        /// Gets the number of blocks per line.
+        /// </summary>
+        public int WidthInBlocks { get; private set; }
+
+        /// <summary>
+        /// Gets the number of blocks per column.
+        /// </summary>
+        public int HeightInBlocks { get; private set; }
+
+        /// <summary>
+        /// Gets or sets the index for the DC Huffman table.
+        /// </summary>
+        public int DcTableId { get; set; }
+
+        /// <summary>
+        /// Gets or sets the index for the AC Huffman table.
+        /// </summary>
+        public int AcTableId { get; set; }
+
+        /// <inheritdoc/>
+        public void Dispose()
+        {
+            this.SpectralBlocks?.Dispose();
+            this.SpectralBlocks = null;
+        }
+
+        /// <summary>
+        /// Initializes component for future buffers initialization.
+        /// </summary>
+        /// <param name="frame">asdfasdf.</param>
+        /// <param name="maxSubFactorH">Maximal horizontal subsampling factor among all the components.</param>
+        /// <param name="maxSubFactorV">Maximal vertical subsampling factor among all the components.</param>
+        public void Init(JpegFrame frame, int maxSubFactorH, int maxSubFactorV)
+        {
+            uint widthInBlocks = ((uint)frame.PixelWidth + 7) / 8;
+            uint heightInBlocks = ((uint)frame.PixelHeight + 7) / 8;
+
+            this.WidthInBlocks = (int)MathF.Ceiling(
+                (float)widthInBlocks * this.HorizontalSamplingFactor / maxSubFactorH);
+
+            this.HeightInBlocks = (int)MathF.Ceiling(
+                (float)heightInBlocks * this.VerticalSamplingFactor / maxSubFactorV);
+
+            int blocksPerLineForMcu = frame.McusPerLine * this.HorizontalSamplingFactor;
+            int blocksPerColumnForMcu = frame.McusPerColumn * this.VerticalSamplingFactor;
+            this.SizeInBlocks = new Size(blocksPerLineForMcu, blocksPerColumnForMcu);
+
+            this.SubSamplingDivisors = new Size(maxSubFactorH, maxSubFactorV).DivideBy(this.SamplingFactors);
+
+            if (this.SubSamplingDivisors.Width == 0 || this.SubSamplingDivisors.Height == 0)
+            {
+                JpegThrowHelper.ThrowBadSampling();
+            }
+        }
+
+        public void AllocateSpectral(bool fullScan)
+        {
+            int spectralAllocWidth = this.SizeInBlocks.Width;
+            int spectralAllocHeight = fullScan ? this.SizeInBlocks.Height : this.VerticalSamplingFactor;
+
+            this.SpectralBlocks = this.memoryAllocator.Allocate2D<Block8x8>(spectralAllocWidth, spectralAllocHeight);
+        }
+    }
+}

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

@@ -0,0 +1,231 @@
+// Copyright (c) Six Labors.
+// Licensed under the Six Labors Split License.
+
+using System;
+using System.Numerics;
+using System.Runtime.CompilerServices;
+using System.Runtime.InteropServices;
+using System.Runtime.Intrinsics;
+using System.Runtime.Intrinsics.X86;
+using SixLabors.ImageSharp.Memory;
+
+namespace SixLabors.ImageSharp.Formats.Jpeg.Components.Encoder
+{
+    internal class ComponentProcessor : IDisposable
+    {
+        private readonly Size blockAreaSize;
+
+        private readonly Component component;
+
+        private Block8x8F quantTable;
+
+        public ComponentProcessor(MemoryAllocator memoryAllocator, Component component, Size postProcessorBufferSize, Block8x8F quantTable)
+        {
+            this.component = component;
+            this.quantTable = quantTable;
+
+            this.component = component;
+            this.blockAreaSize = component.SubSamplingDivisors * 8;
+
+            // alignment of 8 so each block stride can be sampled from a single 'ref pointer'
+            this.ColorBuffer = memoryAllocator.Allocate2DOveraligned<float>(
+                postProcessorBufferSize.Width,
+                postProcessorBufferSize.Height,
+                8,
+                AllocationOptions.Clean);
+        }
+
+        /// <summary>
+        /// Gets the temporary working buffer of color values.
+        /// </summary>
+        public Buffer2D<float> ColorBuffer { get; }
+
+        public void CopyColorBufferToBlocks(int spectralStep)
+        {
+            Buffer2D<Block8x8> spectralBuffer = this.component.SpectralBlocks;
+            int destAreaStride = this.ColorBuffer.Width;
+            int yBlockStart = spectralStep * this.component.SamplingFactors.Height;
+
+            Block8x8F workspaceBlock = default;
+
+            // handle subsampling
+            Size subsamplingFactors = this.component.SubSamplingDivisors;
+            if (subsamplingFactors.Width != 1 || subsamplingFactors.Height != 1)
+            {
+                this.PackColorBuffer();
+            }
+
+            int blocksRowsPerStep = this.component.SamplingFactors.Height;
+
+            for (int y = 0; y < blocksRowsPerStep; y++)
+            {
+                int yBuffer = y * this.blockAreaSize.Height;
+                Span<float> colorBufferRow = this.ColorBuffer.DangerousGetRowSpan(yBuffer);
+                Span<Block8x8> blockRow = spectralBuffer.DangerousGetRowSpan(yBlockStart + y);
+                for (int xBlock = 0; xBlock < spectralBuffer.Width; xBlock++)
+                {
+                    // load 8x8 block from 8 pixel strides
+                    int xColorBufferStart = xBlock * 8;
+                    workspaceBlock.ScaledCopyFrom(
+                        ref colorBufferRow[xColorBufferStart],
+                        destAreaStride);
+
+                    // level shift via -128f
+                    workspaceBlock.AddInPlace(-128f);
+
+                    // FDCT
+                    FloatingPointDCT.TransformFDCT(ref workspaceBlock);
+
+                    // Quantize and save to spectral blocks
+                    Block8x8F.Quantize(ref workspaceBlock, ref blockRow[xBlock], ref this.quantTable);
+                }
+            }
+        }
+
+        public Span<float> GetColorBufferRowSpan(int row)
+            => this.ColorBuffer.DangerousGetRowSpan(row);
+
+        public void Dispose()
+            => this.ColorBuffer.Dispose();
+
+        private void PackColorBuffer()
+        {
+            Size factors = this.component.SubSamplingDivisors;
+
+            int packedWidth = this.ColorBuffer.Width / factors.Width;
+
+            float averageMultiplier = 1f / (factors.Width * factors.Height);
+            for (int i = 0; i < this.ColorBuffer.Height; i += factors.Height)
+            {
+                Span<float> sourceRow = this.ColorBuffer.DangerousGetRowSpan(i);
+
+                // vertical sum
+                for (int j = 1; j < factors.Height; j++)
+                {
+                    SumVertical(sourceRow, this.ColorBuffer.DangerousGetRowSpan(i + j));
+                }
+
+                // horizontal sum
+                SumHorizontal(sourceRow, factors.Width);
+
+                // calculate average
+                MultiplyToAverage(sourceRow, averageMultiplier);
+
+                // copy to the first 8 slots
+                sourceRow.Slice(0, packedWidth).CopyTo(this.ColorBuffer.DangerousGetRowSpan(i / factors.Height));
+            }
+
+            static void SumVertical(Span<float> target, Span<float> source)
+            {
+                if (Avx.IsSupported)
+                {
+                    ref Vector256<float> targetVectorRef = ref Unsafe.As<float, Vector256<float>>(ref MemoryMarshal.GetReference(target));
+                    ref Vector256<float> sourceVectorRef = ref Unsafe.As<float, Vector256<float>>(ref MemoryMarshal.GetReference(source));
+
+                    // Spans are guaranteed to be multiple of 8 so no extra 'remainder' steps are needed
+                    nint count = source.Length / Vector256<float>.Count;
+                    for (nint i = 0; i < count; i++)
+                    {
+                        Unsafe.Add(ref targetVectorRef, i) = Avx.Add(Unsafe.Add(ref targetVectorRef, i), Unsafe.Add(ref sourceVectorRef, i));
+                    }
+                }
+                else
+                {
+                    ref Vector<float> targetVectorRef = ref Unsafe.As<float, Vector<float>>(ref MemoryMarshal.GetReference(target));
+                    ref Vector<float> sourceVectorRef = ref Unsafe.As<float, Vector<float>>(ref MemoryMarshal.GetReference(source));
+
+                    nint count = source.Length / Vector<float>.Count;
+                    for (nint i = 0; i < count; i++)
+                    {
+                        Unsafe.Add(ref targetVectorRef, i) += Unsafe.Add(ref sourceVectorRef, i);
+                    }
+
+                    ref float targetRef = ref MemoryMarshal.GetReference(target);
+                    ref float sourceRef = ref MemoryMarshal.GetReference(source);
+                    for (nint i = count * Vector<float>.Count; i < source.Length; i++)
+                    {
+                        Unsafe.Add(ref targetRef, i) += Unsafe.Add(ref sourceRef, i);
+                    }
+                }
+            }
+
+            static void SumHorizontal(Span<float> target, int factor)
+            {
+                Span<float> source = target;
+                if (Avx2.IsSupported)
+                {
+                    ref Vector256<float> targetRef = ref Unsafe.As<float, Vector256<float>>(ref MemoryMarshal.GetReference(target));
+
+                    // Ideally we need to use log2: Numerics.Log2((uint)factor)
+                    // but division by 2 works just fine in this case
+                    int haddIterationsCount = (int)((uint)factor / 2);
+
+                    // Transform spans so that it only contains 'remainder'
+                    // values for the scalar fallback code
+                    int scalarRemainder = target.Length % (Vector<float>.Count * factor);
+                    int touchedCount = target.Length - scalarRemainder;
+                    source = source.Slice(touchedCount);
+                    target = target.Slice(touchedCount / factor);
+
+                    uint length = (uint)touchedCount / (uint)Vector256<float>.Count;
+
+                    for (int i = 0; i < haddIterationsCount; i++)
+                    {
+                        length /= 2;
+
+                        for (nuint j = 0; j < length; j++)
+                        {
+                            nuint indexLeft = j * 2;
+                            nuint indexRight = indexLeft + 1;
+                            Vector256<float> sum = Avx.HorizontalAdd(Unsafe.Add(ref targetRef, indexLeft), Unsafe.Add(ref targetRef, indexRight));
+                            Unsafe.Add(ref targetRef, j) = Avx2.Permute4x64(sum.AsDouble(), 0b11_01_10_00).AsSingle();
+                        }
+                    }
+                }
+
+                // scalar remainder
+                for (int i = 0; i < source.Length / factor; i++)
+                {
+                    target[i] = source[i * factor];
+                    for (int j = 1; j < factor; j++)
+                    {
+                        target[i] += source[(i * factor) + j];
+                    }
+                }
+            }
+
+            static void MultiplyToAverage(Span<float> target, float multiplier)
+            {
+                if (Avx.IsSupported)
+                {
+                    ref Vector256<float> targetVectorRef = ref Unsafe.As<float, Vector256<float>>(ref MemoryMarshal.GetReference(target));
+
+                    // Spans are guaranteed to be multiple of 8 so no extra 'remainder' steps are needed
+                    nint count = target.Length / Vector256<float>.Count;
+                    var multiplierVector = Vector256.Create(multiplier);
+                    for (nint i = 0; i < count; i++)
+                    {
+                        Unsafe.Add(ref targetVectorRef, i) = Avx.Multiply(Unsafe.Add(ref targetVectorRef, i), multiplierVector);
+                    }
+                }
+                else
+                {
+                    ref Vector<float> targetVectorRef = ref Unsafe.As<float, Vector<float>>(ref MemoryMarshal.GetReference(target));
+
+                    nint count = target.Length / Vector<float>.Count;
+                    var multiplierVector = new Vector<float>(multiplier);
+                    for (nint i = 0; i < count; i++)
+                    {
+                        Unsafe.Add(ref targetVectorRef, i) *= multiplierVector;
+                    }
+
+                    ref float targetRef = ref MemoryMarshal.GetReference(target);
+                    for (nint i = count * Vector<float>.Count; i < target.Length; i++)
+                    {
+                        Unsafe.Add(ref targetRef, i) *= multiplier;
+                    }
+                }
+            }
+        }
+    }
+}

src/ImageSharp/Formats/Jpeg/Components/Encoder/EncodingConfigs/JpegComponentConfig.cs

@@ -0,0 +1,30 @@
+// Copyright (c) Six Labors.
+// Licensed under the Six Labors Split License.
+
+namespace SixLabors.ImageSharp.Formats.Jpeg.Components.Encoder
+{
+    internal class JpegComponentConfig
+    {
+        public JpegComponentConfig(byte id, int hsf, int vsf, int quantIndex, int dcIndex, int acIndex)
+        {
+            this.Id = id;
+            this.HorizontalSampleFactor = hsf;
+            this.VerticalSampleFactor = vsf;
+            this.QuantizatioTableIndex = quantIndex;
+            this.DcTableSelector = dcIndex;
+            this.AcTableSelector = acIndex;
+        }
+
+        public byte Id { get; }
+
+        public int HorizontalSampleFactor { get; }
+
+        public int VerticalSampleFactor { get; }
+
+        public int QuantizatioTableIndex { get; }
+
+        public int DcTableSelector { get; }
+
+        public int AcTableSelector { get; }
+    }
+}

src/ImageSharp/Formats/Jpeg/Components/Encoder/EncodingConfigs/JpegFrameConfig.cs

@@ -0,0 +1,44 @@
+// Copyright (c) Six Labors.
+// Licensed under the Six Labors Split License.
+
+using System;
+
+namespace SixLabors.ImageSharp.Formats.Jpeg.Components.Encoder
+{
+    internal class JpegFrameConfig
+    {
+        public JpegFrameConfig(JpegColorSpace colorType, JpegEncodingColor encodingColor, JpegComponentConfig[] components, JpegHuffmanTableConfig[] huffmanTables, JpegQuantizationTableConfig[] quantTables)
+        {
+            this.ColorType = colorType;
+            this.EncodingColor = encodingColor;
+            this.Components = components;
+            this.HuffmanTables = huffmanTables;
+            this.QuantizationTables = quantTables;
+
+            this.MaxHorizontalSamplingFactor = components[0].HorizontalSampleFactor;
+            this.MaxVerticalSamplingFactor = components[0].VerticalSampleFactor;
+            for (int i = 1; i < components.Length; i++)
+            {
+                JpegComponentConfig component = components[i];
+                this.MaxHorizontalSamplingFactor = Math.Max(this.MaxHorizontalSamplingFactor, component.HorizontalSampleFactor);
+                this.MaxVerticalSamplingFactor = Math.Max(this.MaxVerticalSamplingFactor, component.VerticalSampleFactor);
+            }
+        }
+
+        public JpegColorSpace ColorType { get; }
+
+        public JpegEncodingColor EncodingColor { get; }
+
+        public JpegComponentConfig[] Components { get; }
+
+        public JpegHuffmanTableConfig[] HuffmanTables { get; }
+
+        public JpegQuantizationTableConfig[] QuantizationTables { get; }
+
+        public int MaxHorizontalSamplingFactor { get; }
+
+        public int MaxVerticalSamplingFactor { get; }
+
+        public byte? AdobeColorTransformMarkerFlag { get; set; } = null;
+    }
+}

src/ImageSharp/Formats/Jpeg/Components/Encoder/EncodingConfigs/JpegHuffmanTableConfig.cs

@@ -0,0 +1,21 @@
+// Copyright (c) Six Labors.
+// Licensed under the Six Labors Split License.
+
+namespace SixLabors.ImageSharp.Formats.Jpeg.Components.Encoder
+{
+    internal class JpegHuffmanTableConfig
+    {
+        public JpegHuffmanTableConfig(int @class, int destIndex, HuffmanSpec table)
+        {
+            this.Class = @class;
+            this.DestinationIndex = destIndex;
+            this.Table = table;
+        }
+
+        public int Class { get; }
+
+        public int DestinationIndex { get; }
+
+        public HuffmanSpec Table { get; }
+    }
+}

src/ImageSharp/Formats/Jpeg/Components/Encoder/EncodingConfigs/JpegQuantizationTableConfig.cs

@@ -0,0 +1,20 @@
+// Copyright (c) Six Labors.
+// Licensed under the Six Labors Split License.
+
+using System;
+
+namespace SixLabors.ImageSharp.Formats.Jpeg.Components.Encoder
+{
+    internal class JpegQuantizationTableConfig
+    {
+        public JpegQuantizationTableConfig(int destIndex, ReadOnlySpan<byte> quantizationTable)
+        {
+            this.DestinationIndex = destIndex;
+            this.Table = Block8x8.Load(quantizationTable);
+        }
+
+        public int DestinationIndex { get; }
+
+        public Block8x8 Table { get; }
+    }
+}

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

@@ -1,35 +0,0 @@
-// Copyright (c) Six Labors.
-// Licensed under the Six Labors Split License.
-
-namespace SixLabors.ImageSharp.Formats.Jpeg.Components.Encoder
-{
-    /// <summary>
-    /// Enumerates the Huffman tables
-    /// </summary>
-    internal enum HuffIndex
-    {
-        /// <summary>
-        /// The DC luminance huffman table index
-        /// </summary>
-        LuminanceDC = 0,
-
-        // ReSharper disable UnusedMember.Local
-
-        /// <summary>
-        /// The AC luminance huffman table index
-        /// </summary>
-        LuminanceAC = 1,
-
-        /// <summary>
-        /// The DC chrominance huffman table index
-        /// </summary>
-        ChrominanceDC = 2,
-
-        /// <summary>
-        /// The AC chrominance huffman table index
-        /// </summary>
-        ChrominanceAC = 3,
-
-        // ReSharper restore UnusedMember.Local
-    }
-}

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

@@ -26,23 +26,6 @@ namespace SixLabors.ImageSharp.Formats.Jpeg.Components.Encoder
     /// </remarks>
     internal readonly struct HuffmanLut
     {
-        /// <summary>
-        /// The compiled representations of theHuffmanSpec.
-        /// </summary>
-        public static readonly HuffmanLut[] TheHuffmanLut = new HuffmanLut[4];
-
-        /// <summary>
-        /// Initializes static members of the <see cref="HuffmanLut"/> struct.
-        /// </summary>
-        static HuffmanLut()
-        {
-            // Initialize the Huffman tables
-            for (int i = 0; i < HuffmanSpec.TheHuffmanSpecs.Length; i++)
-            {
-                TheHuffmanLut[i] = new HuffmanLut(HuffmanSpec.TheHuffmanSpecs[i]);
-            }
-        }
-
         /// <summary>
         /// Initializes a new instance of the <see cref="HuffmanLut"/> struct.
         /// </summary>

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

@@ -7,7 +7,6 @@ using System.Numerics;
 using System.Runtime.CompilerServices;
 using System.Runtime.InteropServices;
 using System.Threading;
-using SixLabors.ImageSharp.Memory;
 using SixLabors.ImageSharp.PixelFormats;
 
 namespace SixLabors.ImageSharp.Formats.Jpeg.Components.Encoder
@@ -60,10 +59,14 @@ namespace SixLabors.ImageSharp.Formats.Jpeg.Components.Encoder
         private const int OutputBufferLengthMultiplier = 2;
 
         /// <summary>
-        /// Compiled huffman tree to encode given values.
+        /// The DC Huffman tables.
         /// </summary>
-        /// <remarks>Yields codewords by index consisting of [run length | bitsize].</remarks>
+        private readonly HuffmanLut[] dcHuffmanTables = new HuffmanLut[4];
-        private HuffmanLut[] huffmanTables;
+
+        /// <summary>
+        /// The AC Huffman tables.
+        /// </summary>
+        private readonly HuffmanLut[] acHuffmanTables = new HuffmanLut[4];
 
         /// <summary>
         /// Emitted bits 'micro buffer' before being transferred to the <see cref="emitBuffer"/>.
@@ -94,8 +97,6 @@ namespace SixLabors.ImageSharp.Formats.Jpeg.Components.Encoder
 
         private int emitWriteIndex;
 
-        private Block8x8 tempBlock;
-
         /// <summary>
         /// The output stream. All attempted writes after the first error become no-ops.
         /// </summary>
@@ -128,57 +129,67 @@ namespace SixLabors.ImageSharp.Formats.Jpeg.Components.Encoder
             get => this.emitWriteIndex < (uint)this.emitBuffer.Length / 2;
         }
 
+        public void BuildHuffmanTable(JpegHuffmanTableConfig tableConfig)
+        {
+            HuffmanLut[] tables = tableConfig.Class == 0 ? this.dcHuffmanTables : this.acHuffmanTables;
+            tables[tableConfig.DestinationIndex] = new HuffmanLut(tableConfig.Table);
+        }
+
         /// <summary>
-        /// Encodes the image with no subsampling.
+        /// Encodes scan in baseline interleaved mode.
         /// </summary>
-        /// <typeparam name="TPixel">The pixel format.</typeparam>
+        /// <param name="color">Output color space.</param>
-        /// <param name="pixels">The pixel accessor providing access to the image pixels.</param>
+        /// <param name="frame">Frame to encode.</param>
-        /// <param name="luminanceQuantTable">Luminance quantization table provided by the callee.</param>
+        /// <param name="converter">Converter from color to spectral.</param>
-        /// <param name="chrominanceQuantTable">Chrominance quantization table provided by the callee.</param>
+        /// <param name="cancellationToken">The token to request cancellation.</param>
-        /// <param name="cancellationToken">The token to monitor for cancellation.</param>
+        public void EncodeScanBaselineInterleaved<TPixel>(JpegEncodingColor color, JpegFrame frame, SpectralConverter<TPixel> converter, CancellationToken cancellationToken)
-        public void Encode444<TPixel>(Image<TPixel> pixels, ref Block8x8F luminanceQuantTable, ref Block8x8F chrominanceQuantTable, CancellationToken cancellationToken)
             where TPixel : unmanaged, IPixel<TPixel>
         {
-            FloatingPointDCT.AdjustToFDCT(ref luminanceQuantTable);
+            switch (color)
-            FloatingPointDCT.AdjustToFDCT(ref chrominanceQuantTable);
+            {
-
+                case JpegEncodingColor.YCbCrRatio444:
-            this.huffmanTables = HuffmanLut.TheHuffmanLut;
+                case JpegEncodingColor.Rgb:
-
+                    this.EncodeThreeComponentBaselineInterleavedScanNoSubsampling(frame, converter, cancellationToken);
-            // ReSharper disable once InconsistentNaming
+                    break;
-            int prevDCY = 0, prevDCCb = 0, prevDCCr = 0;
+                default:
+                    this.EncodeScanBaselineInterleaved(frame, converter, cancellationToken);
+                    break;
+            }
+        }
 
-            ImageFrame<TPixel> frame = pixels.Frames.RootFrame;
+        /// <summary>
-            Buffer2D<TPixel> pixelBuffer = frame.PixelBuffer;
+        /// Encodes grayscale scan in baseline interleaved mode.
-            RowOctet<TPixel> currentRows = default;
+        /// </summary>
+        /// <param name="component">Component with grayscale data.</param>
+        /// <param name="converter">Converter from color to spectral.</param>
+        /// <param name="cancellationToken">The token to request cancellation.</param>
+        public void EncodeScanBaselineSingleComponent<TPixel>(Component component, SpectralConverter<TPixel> converter, CancellationToken cancellationToken)
+            where TPixel : unmanaged, IPixel<TPixel>
+        {
+            int h = component.HeightInBlocks;
+            int w = component.WidthInBlocks;
 
-            var pixelConverter = new YCbCrForwardConverter444<TPixel>(frame);
+            ref HuffmanLut dcHuffmanTable = ref this.dcHuffmanTables[component.DcTableId];
+            ref HuffmanLut acHuffmanTable = ref this.acHuffmanTables[component.AcTableId];
 
-            for (int y = 0; y < pixels.Height; y += 8)
+            for (int i = 0; i < h; i++)
             {
                 cancellationToken.ThrowIfCancellationRequested();
-                currentRows.Update(pixelBuffer, y);
 
-                for (int x = 0; x < pixels.Width; x += 8)
+                // Convert from pixels to spectral via given converter
+                converter.ConvertStrideBaseline();
+
+                // Encode spectral to binary
+                Span<Block8x8> blockSpan = component.SpectralBlocks.DangerousGetRowSpan(y: 0);
+                ref Block8x8 blockRef = ref MemoryMarshal.GetReference(blockSpan);
+
+                for (nint k = 0; k < w; k++)
                 {
-                    pixelConverter.Convert(x, y, ref currentRows);
+                    this.WriteBlock(
-
+                        component,
-                    prevDCY = this.WriteBlock(
+                        ref Unsafe.Add(ref blockRef, k),
-                        QuantIndex.Luminance,
+                        ref dcHuffmanTable,
-                        prevDCY,
+                        ref acHuffmanTable);
-                        ref pixelConverter.Y,
-                        ref luminanceQuantTable);
-
-                    prevDCCb = this.WriteBlock(
-                        QuantIndex.Chrominance,
-                        prevDCCb,
-                        ref pixelConverter.Cb,
-                        ref chrominanceQuantTable);
-
-                    prevDCCr = this.WriteBlock(
-                        QuantIndex.Chrominance,
-                        prevDCCr,
-                        ref pixelConverter.Cr,
-                        ref chrominanceQuantTable);
 
                     if (this.IsStreamFlushNeeded)
                     {
@@ -191,65 +202,33 @@ namespace SixLabors.ImageSharp.Formats.Jpeg.Components.Encoder
         }
 
         /// <summary>
-        /// Encodes the image with subsampling. The Cb and Cr components are each subsampled
+        /// Encodes scan with a single component in baseline non-interleaved mode.
-        /// at a factor of 2 both horizontally and vertically.
         /// </summary>
-        /// <typeparam name="TPixel">The pixel format.</typeparam>
+        /// <param name="component">Component with grayscale data.</param>
-        /// <param name="pixels">The pixel accessor providing access to the image pixels.</param>
+        /// <param name="cancellationToken">The token to request cancellation.</param>
-        /// <param name="luminanceQuantTable">Luminance quantization table provided by the callee.</param>
+        public void EncodeScanBaseline(Component component, CancellationToken cancellationToken)
-        /// <param name="chrominanceQuantTable">Chrominance quantization table provided by the callee.</param>
-        /// <param name="cancellationToken">The token to monitor for cancellation.</param>
-        public void Encode420<TPixel>(Image<TPixel> pixels, ref Block8x8F luminanceQuantTable, ref Block8x8F chrominanceQuantTable, CancellationToken cancellationToken)
-            where TPixel : unmanaged, IPixel<TPixel>
         {
-            FloatingPointDCT.AdjustToFDCT(ref luminanceQuantTable);
+            int h = component.HeightInBlocks;
-            FloatingPointDCT.AdjustToFDCT(ref chrominanceQuantTable);
+            int w = component.WidthInBlocks;
-
-            this.huffmanTables = HuffmanLut.TheHuffmanLut;
-
-            // ReSharper disable once InconsistentNaming
-            int prevDCY = 0, prevDCCb = 0, prevDCCr = 0;
-            ImageFrame<TPixel> frame = pixels.Frames.RootFrame;
-            Buffer2D<TPixel> pixelBuffer = frame.PixelBuffer;
-            RowOctet<TPixel> currentRows = default;
 
-            var pixelConverter = new YCbCrForwardConverter420<TPixel>(frame);
+            ref HuffmanLut dcHuffmanTable = ref this.dcHuffmanTables[component.DcTableId];
+            ref HuffmanLut acHuffmanTable = ref this.acHuffmanTables[component.AcTableId];
 
-            for (int y = 0; y < pixels.Height; y += 16)
+            for (int i = 0; i < h; i++)
             {
                 cancellationToken.ThrowIfCancellationRequested();
-                for (int x = 0; x < pixels.Width; x += 16)
-                {
-                    for (int i = 0; i < 2; i++)
-                    {
-                        int yOff = i * 8;
-                        currentRows.Update(pixelBuffer, y + yOff);
-                        pixelConverter.Convert(x, y, ref currentRows, i);
-
-                        prevDCY = this.WriteBlock(
-                            QuantIndex.Luminance,
-                            prevDCY,
-                            ref pixelConverter.YLeft,
-                            ref luminanceQuantTable);
-
-                        prevDCY = this.WriteBlock(
-                            QuantIndex.Luminance,
-                            prevDCY,
-                            ref pixelConverter.YRight,
-                            ref luminanceQuantTable);
-                    }
 
-                    prevDCCb = this.WriteBlock(
+                // Encode spectral to binary
-                        QuantIndex.Chrominance,
+                Span<Block8x8> blockSpan = component.SpectralBlocks.DangerousGetRowSpan(y: i);
-                        prevDCCb,
+                ref Block8x8 blockRef = ref MemoryMarshal.GetReference(blockSpan);
-                        ref pixelConverter.Cb,
-                        ref chrominanceQuantTable);
 
-                    prevDCCr = this.WriteBlock(
+                for (nint k = 0; k < w; k++)
-                        QuantIndex.Chrominance,
+                {
-                        prevDCCr,
+                    this.WriteBlock(
-                        ref pixelConverter.Cr,
+                        component,
-                        ref chrominanceQuantTable);
+                        ref Unsafe.Add(ref blockRef, k),
+                        ref dcHuffmanTable,
+                        ref acHuffmanTable);
 
                     if (this.IsStreamFlushNeeded)
                     {
@@ -262,43 +241,64 @@ namespace SixLabors.ImageSharp.Formats.Jpeg.Components.Encoder
         }
 
         /// <summary>
-        /// Encodes the image with no chroma, just luminance.
+        /// Encodes scan in baseline interleaved mode for any amount of component with arbitrary sampling factors.
         /// </summary>
-        /// <typeparam name="TPixel">The pixel format.</typeparam>
+        /// <param name="frame">Frame to encode.</param>
-        /// <param name="pixels">The pixel accessor providing access to the image pixels.</param>
+        /// <param name="converter">Converter from color to spectral.</param>
-        /// <param name="luminanceQuantTable">Luminance quantization table provided by the callee.</param>
+        /// <param name="cancellationToken">The token to request cancellation.</param>
-        /// <param name="cancellationToken">The token to monitor for cancellation.</param>
+        private void EncodeScanBaselineInterleaved<TPixel>(JpegFrame frame, SpectralConverter<TPixel> converter, CancellationToken cancellationToken)
-        public void EncodeGrayscale<TPixel>(Image<TPixel> pixels, ref Block8x8F luminanceQuantTable, CancellationToken cancellationToken)
             where TPixel : unmanaged, IPixel<TPixel>
         {
-            FloatingPointDCT.AdjustToFDCT(ref luminanceQuantTable);
+            nint mcu = 0;
+            nint mcusPerColumn = frame.McusPerColumn;
+            nint mcusPerLine = frame.McusPerLine;
 
-            this.huffmanTables = HuffmanLut.TheHuffmanLut;
+            for (int j = 0; j < mcusPerColumn; j++)
+            {
+                cancellationToken.ThrowIfCancellationRequested();
 
-            // ReSharper disable once InconsistentNaming
+                // Convert from pixels to spectral via given converter
-            int prevDCY = 0;
+                converter.ConvertStrideBaseline();
 
-            ImageFrame<TPixel> frame = pixels.Frames.RootFrame;
+                // Encode spectral to binary
-            Buffer2D<TPixel> pixelBuffer = frame.PixelBuffer;
+                for (nint i = 0; i < mcusPerLine; i++)
-            RowOctet<TPixel> currentRows = default;
+                {
+                    // Scan an interleaved mcu... process components in order
+                    nint mcuCol = mcu % mcusPerLine;
+                    for (nint k = 0; k < frame.Components.Length; k++)
+                    {
+                        Component component = frame.Components[k];
 
-            var pixelConverter = new LuminanceForwardConverter<TPixel>(frame);
+                        ref HuffmanLut dcHuffmanTable = ref this.dcHuffmanTables[component.DcTableId];
+                        ref HuffmanLut acHuffmanTable = ref this.acHuffmanTables[component.AcTableId];
 
-            for (int y = 0; y < pixels.Height; y += 8)
+                        nint h = component.HorizontalSamplingFactor;
-            {
+                        int v = component.VerticalSamplingFactor;
-                cancellationToken.ThrowIfCancellationRequested();
-                currentRows.Update(pixelBuffer, y);
 
-                for (int x = 0; x < pixels.Width; x += 8)
+                        nint blockColBase = mcuCol * h;
-                {
-                    pixelConverter.Convert(x, y, ref currentRows);
 
-                    prevDCY = this.WriteBlock(
+                        // Scan out an mcu's worth of this component; that's just determined
-                        QuantIndex.Luminance,
+                        // by the basic H and V specified for the component
-                        prevDCY,
+                        for (int y = 0; y < v; y++)
-                        ref pixelConverter.Y,
+                        {
-                        ref luminanceQuantTable);
+                            Span<Block8x8> blockSpan = component.SpectralBlocks.DangerousGetRowSpan(y);
+                            ref Block8x8 blockRef = ref MemoryMarshal.GetReference(blockSpan);
+
+                            for (nint x = 0; x < h; x++)
+                            {
+                                nint blockCol = blockColBase + x;
+
+                                this.WriteBlock(
+                                    component,
+                                    ref Unsafe.Add(ref blockRef, blockCol),
+                                    ref dcHuffmanTable,
+                                    ref acHuffmanTable);
+                            }
+                        }
+                    }
 
+                    // After all interleaved components, that's an interleaved MCU
+                    mcu++;
                     if (this.IsStreamFlushNeeded)
                     {
                         this.FlushToStream();
@@ -310,54 +310,59 @@ namespace SixLabors.ImageSharp.Formats.Jpeg.Components.Encoder
         }
 
         /// <summary>
-        /// Encodes the image with no subsampling and keeps the pixel data as Rgb24.
+        /// Encodes scan in baseline interleaved mode with exactly 3 components with no subsampling.
         /// </summary>
-        /// <typeparam name="TPixel">The pixel format.</typeparam>
+        /// <param name="frame">Frame to encode.</param>
-        /// <param name="pixels">The pixel accessor providing access to the image pixels.</param>
+        /// <param name="converter">Converter from color to spectral.</param>
-        /// <param name="quantTable">Quantization table provided by the callee.</param>
+        /// <param name="cancellationToken">The token to request cancellation.</param>
-        /// <param name="cancellationToken">The token to monitor for cancellation.</param>
+        private void EncodeThreeComponentBaselineInterleavedScanNoSubsampling<TPixel>(JpegFrame frame, SpectralConverter<TPixel> converter, CancellationToken cancellationToken)
-        public void EncodeRgb<TPixel>(Image<TPixel> pixels, ref Block8x8F quantTable, CancellationToken cancellationToken)
             where TPixel : unmanaged, IPixel<TPixel>
         {
-            FloatingPointDCT.AdjustToFDCT(ref quantTable);
+            nint mcusPerColumn = frame.McusPerColumn;
-
+            nint mcusPerLine = frame.McusPerLine;
-            this.huffmanTables = HuffmanLut.TheHuffmanLut;
 
-            // ReSharper disable once InconsistentNaming
+            Component c2 = frame.Components[2];
-            int prevDCR = 0, prevDCG = 0, prevDCB = 0;
+            Component c1 = frame.Components[1];
+            Component c0 = frame.Components[0];
 
-            ImageFrame<TPixel> frame = pixels.Frames.RootFrame;
+            ref HuffmanLut c0dcHuffmanTable = ref this.dcHuffmanTables[c0.DcTableId];
-            Buffer2D<TPixel> pixelBuffer = frame.PixelBuffer;
+            ref HuffmanLut c0acHuffmanTable = ref this.acHuffmanTables[c0.AcTableId];
-            RowOctet<TPixel> currentRows = default;
+            ref HuffmanLut c1dcHuffmanTable = ref this.dcHuffmanTables[c1.DcTableId];
+            ref HuffmanLut c1acHuffmanTable = ref this.acHuffmanTables[c1.AcTableId];
+            ref HuffmanLut c2dcHuffmanTable = ref this.dcHuffmanTables[c2.DcTableId];
+            ref HuffmanLut c2acHuffmanTable = ref this.acHuffmanTables[c2.AcTableId];
 
-            var pixelConverter = new RgbForwardConverter<TPixel>(frame);
+            ref Block8x8 c0BlockRef = ref MemoryMarshal.GetReference(c0.SpectralBlocks.DangerousGetRowSpan(y: 0));
+            ref Block8x8 c1BlockRef = ref MemoryMarshal.GetReference(c1.SpectralBlocks.DangerousGetRowSpan(y: 0));
+            ref Block8x8 c2BlockRef = ref MemoryMarshal.GetReference(c2.SpectralBlocks.DangerousGetRowSpan(y: 0));
 
-            for (int y = 0; y < pixels.Height; y += 8)
+            for (nint j = 0; j < mcusPerColumn; j++)
             {
                 cancellationToken.ThrowIfCancellationRequested();
-                currentRows.Update(pixelBuffer, y);
 
-                for (int x = 0; x < pixels.Width; x += 8)
+                // Convert from pixels to spectral via given converter
+                converter.ConvertStrideBaseline();
+
+                // Encode spectral to binary
+                for (nint i = 0; i < mcusPerLine; i++)
                 {
-                    pixelConverter.Convert(x, y, ref currentRows);
+                    this.WriteBlock(
-
+                        c0,
-                    prevDCR = this.WriteBlock(
+                        ref Unsafe.Add(ref c0BlockRef, i),
-                        QuantIndex.Luminance,
+                        ref c0dcHuffmanTable,
-                        prevDCR,
+                        ref c0acHuffmanTable);
-                        ref pixelConverter.R,
+
-                        ref quantTable);
+                    this.WriteBlock(
-
+                        c1,
-                    prevDCG = this.WriteBlock(
+                        ref Unsafe.Add(ref c1BlockRef, i),
-                        QuantIndex.Luminance,
+                        ref c1dcHuffmanTable,
-                        prevDCG,
+                        ref c1acHuffmanTable);
-                        ref pixelConverter.G,
+
-                        ref quantTable);
+                    this.WriteBlock(
-
+                        c2,
-                    prevDCB = this.WriteBlock(
+                        ref Unsafe.Add(ref c2BlockRef, i),
-                        QuantIndex.Luminance,
+                        ref c2dcHuffmanTable,
-                        prevDCB,
+                        ref c2acHuffmanTable);
-                        ref pixelConverter.B,
-                        ref quantTable);
 
                     if (this.IsStreamFlushNeeded)
                     {
@@ -369,44 +374,24 @@ namespace SixLabors.ImageSharp.Formats.Jpeg.Components.Encoder
             this.FlushRemainingBytes();
         }
 
-        /// <summary>
+        private void WriteBlock(
-        /// Writes a block of pixel data using the given quantization table,
+            Component component,
-        /// returning the post-quantized DC value of the DCT-transformed block.
+            ref Block8x8 block,
-        /// The block is in natural (not zig-zag) order.
+            ref HuffmanLut dcTable,
-        /// </summary>
+            ref HuffmanLut acTable)
-        /// <param name="index">The quantization table index.</param>
-        /// <param name="prevDC">The previous DC value.</param>
-        /// <param name="block">Source block.</param>
-        /// <param name="quant">Quantization table.</param>
-        /// <returns>The <see cref="int"/>.</returns>
-        private int WriteBlock(
-            QuantIndex index,
-            int prevDC,
-            ref Block8x8F block,
-            ref Block8x8F quant)
         {
-            ref Block8x8 spectralBlock = ref this.tempBlock;
-
-            // Shifting level from 0..255 to -128..127
-            block.AddInPlace(-128f);
-
-            // Discrete cosine transform
-            FloatingPointDCT.TransformFDCT(ref block);
-
-            // Quantization
-            Block8x8F.Quantize(ref block, ref spectralBlock, ref quant);
-
             // Emit the DC delta.
-            int dc = spectralBlock[0];
+            int dc = block[0];
-            this.EmitHuffRLE(this.huffmanTables[2 * (int)index].Values, 0, dc - prevDC);
+            this.EmitHuffRLE(dcTable.Values, 0, dc - component.DcPredictor);
+            component.DcPredictor = dc;
 
             // Emit the AC components.
-            int[] acHuffTable = this.huffmanTables[(2 * (int)index) + 1].Values;
+            int[] acHuffTable = acTable.Values;
 
-            nint lastValuableIndex = spectralBlock.GetLastNonZeroIndex();
+            nint lastValuableIndex = block.GetLastNonZeroIndex();
 
             int runLength = 0;
-            ref short blockRef = ref Unsafe.As<Block8x8, short>(ref spectralBlock);
+            ref short blockRef = ref Unsafe.As<Block8x8, short>(ref block);
             for (nint zig = 1; zig <= lastValuableIndex; zig++)
             {
                 const int zeroRun1 = 1 << 4;
@@ -437,8 +422,6 @@ namespace SixLabors.ImageSharp.Formats.Jpeg.Components.Encoder
             {
                 this.EmitHuff(acHuffTable, 0x00);
             }
-
-            return dc;
         }
 
         /// <summary>
@@ -642,7 +625,7 @@ namespace SixLabors.ImageSharp.Formats.Jpeg.Components.Encoder
 
         /// <summary>
         /// Flushes spectral data bytes after encoding all channel blocks
-        /// in a single jpeg macroblock using <see cref="WriteBlock"/>.
+        /// in a single jpeg macroblock using <see cref="WriteBlock(Component, ref Block8x8, ref HuffmanLut, ref HuffmanLut)"/>.
         /// </summary>
         /// <remarks>
         /// This must be called only if <see cref="IsStreamFlushNeeded"/> is true
@@ -671,6 +654,11 @@ namespace SixLabors.ImageSharp.Formats.Jpeg.Components.Encoder
             // Flush cached bytes to the output stream with padding bits
             int lastByteIndex = (this.emitWriteIndex * 4) - valuableBytesCount;
             this.FlushToStream(lastByteIndex);
+
+            // Clear huffman register
+            // This is needed for for images with multiples scans
+            this.bitCount = 0;
+            this.accumulatedBits = 0;
         }
     }
 }

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

@@ -6,111 +6,122 @@ namespace SixLabors.ImageSharp.Formats.Jpeg.Components.Encoder
     /// <summary>
     ///     The Huffman encoding specifications.
     /// </summary>
-    internal readonly struct HuffmanSpec
+    public readonly struct HuffmanSpec
     {
-#pragma warning disable SA1118 // ParameterMustNotSpanMultipleLines
+        /// <summary>
+        /// Huffman talbe specification for luminance DC.
+        /// </summary>
+        /// <remarks>
+        /// This is an example specification taken from the jpeg specification paper.
+        /// </remarks>
+        public static readonly HuffmanSpec LuminanceDC = new(
+            new byte[]
+            {
+                0, 1, 5, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0,
+                0, 0, 0
+            },
+            new byte[]
+            {
+                0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11
+            });
 
         /// <summary>
-        ///     The Huffman encoding specifications.
+        /// Huffman talbe specification for luminance AC.
-        ///     This encoder uses the same Huffman encoding for all images.
         /// </summary>
-        public static readonly HuffmanSpec[] TheHuffmanSpecs =
+        /// <remarks>
+        /// This is an example specification taken from the jpeg specification paper.
+        /// </remarks>
+        public static readonly HuffmanSpec LuminanceAC = new(
+            new byte[]
             {
-                // Luminance DC.
+                0, 2, 1, 3, 3, 2, 4, 3, 5, 5, 4, 4, 0,
-                new HuffmanSpec(
+                0, 1, 125
-                    new byte[]
+            },
-                        {
+            new byte[]
-                            0, 1, 5, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0,
+            {
-                            0, 0, 0
+                0x01, 0x02, 0x03, 0x00, 0x04, 0x11,
-                        },
+                0x05, 0x12, 0x21, 0x31, 0x41, 0x06, 0x13,
-                    new byte[]
+                0x51, 0x61, 0x07, 0x22, 0x71, 0x14, 0x32,
-                        {
+                0x81, 0x91, 0xa1, 0x08, 0x23, 0x42, 0xb1,
-                            0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11
+                0xc1, 0x15, 0x52, 0xd1, 0xf0, 0x24, 0x33,
-                        }),
+                0x62, 0x72, 0x82, 0x09, 0x0a, 0x16, 0x17,
+                0x18, 0x19, 0x1a, 0x25, 0x26, 0x27, 0x28,
+                0x29, 0x2a, 0x34, 0x35, 0x36, 0x37, 0x38,
+                0x39, 0x3a, 0x43, 0x44, 0x45, 0x46, 0x47,
+                0x48, 0x49, 0x4a, 0x53, 0x54, 0x55, 0x56,
+                0x57, 0x58, 0x59, 0x5a, 0x63, 0x64, 0x65,
+                0x66, 0x67, 0x68, 0x69, 0x6a, 0x73, 0x74,
+                0x75, 0x76, 0x77, 0x78, 0x79, 0x7a, 0x83,
+                0x84, 0x85, 0x86, 0x87, 0x88, 0x89, 0x8a,
+                0x92, 0x93, 0x94, 0x95, 0x96, 0x97, 0x98,
+                0x99, 0x9a, 0xa2, 0xa3, 0xa4, 0xa5, 0xa6,
+                0xa7, 0xa8, 0xa9, 0xaa, 0xb2, 0xb3, 0xb4,
+                0xb5, 0xb6, 0xb7, 0xb8, 0xb9, 0xba, 0xc2,
+                0xc3, 0xc4, 0xc5, 0xc6, 0xc7, 0xc8, 0xc9,
+                0xca, 0xd2, 0xd3, 0xd4, 0xd5, 0xd6, 0xd7,
+                0xd8, 0xd9, 0xda, 0xe1, 0xe2, 0xe3, 0xe4,
+                0xe5, 0xe6, 0xe7, 0xe8, 0xe9, 0xea, 0xf1,
+                0xf2, 0xf3, 0xf4, 0xf5, 0xf6, 0xf7, 0xf8,
+                0xf9, 0xfa
+            });
 
-                // Luminance AC.
+        /// <summary>
-                new HuffmanSpec(
+        /// Huffman talbe specification for chrominance DC.
-                    new byte[]
+        /// </summary>
-                        {
+        /// <remarks>
-                            0, 2, 1, 3, 3, 2, 4, 3, 5, 5, 4, 4, 0,
+        /// This is an example specification taken from the jpeg specification paper.
-                            0, 1, 125
+        /// </remarks>
-                        },
+        public static readonly HuffmanSpec ChrominanceDC = new(
-                    new byte[]
+            new byte[]
-                        {
+            {
-                            0x01, 0x02, 0x03, 0x00, 0x04, 0x11,
+                0, 3, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0,
-                            0x05, 0x12, 0x21, 0x31, 0x41, 0x06, 0x13,
+                0, 0, 0
-                            0x51, 0x61, 0x07, 0x22, 0x71, 0x14, 0x32,
+            },
-                            0x81, 0x91, 0xa1, 0x08, 0x23, 0x42, 0xb1,
+            new byte[]
-                            0xc1, 0x15, 0x52, 0xd1, 0xf0, 0x24, 0x33,
+            {
-                            0x62, 0x72, 0x82, 0x09, 0x0a, 0x16, 0x17,
+                0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11
-                            0x18, 0x19, 0x1a, 0x25, 0x26, 0x27, 0x28,
+            });
-                            0x29, 0x2a, 0x34, 0x35, 0x36, 0x37, 0x38,
-                            0x39, 0x3a, 0x43, 0x44, 0x45, 0x46, 0x47,
-                            0x48, 0x49, 0x4a, 0x53, 0x54, 0x55, 0x56,
-                            0x57, 0x58, 0x59, 0x5a, 0x63, 0x64, 0x65,
-                            0x66, 0x67, 0x68, 0x69, 0x6a, 0x73, 0x74,
-                            0x75, 0x76, 0x77, 0x78, 0x79, 0x7a, 0x83,
-                            0x84, 0x85, 0x86, 0x87, 0x88, 0x89, 0x8a,
-                            0x92, 0x93, 0x94, 0x95, 0x96, 0x97, 0x98,
-                            0x99, 0x9a, 0xa2, 0xa3, 0xa4, 0xa5, 0xa6,
-                            0xa7, 0xa8, 0xa9, 0xaa, 0xb2, 0xb3, 0xb4,
-                            0xb5, 0xb6, 0xb7, 0xb8, 0xb9, 0xba, 0xc2,
-                            0xc3, 0xc4, 0xc5, 0xc6, 0xc7, 0xc8, 0xc9,
-                            0xca, 0xd2, 0xd3, 0xd4, 0xd5, 0xd6, 0xd7,
-                            0xd8, 0xd9, 0xda, 0xe1, 0xe2, 0xe3, 0xe4,
-                            0xe5, 0xe6, 0xe7, 0xe8, 0xe9, 0xea, 0xf1,
-                            0xf2, 0xf3, 0xf4, 0xf5, 0xf6, 0xf7, 0xf8,
-                            0xf9, 0xfa
-                        }),
 
-                // Chrominance DC.
+        /// <summary>
-                new HuffmanSpec(
+        /// Huffman talbe specification for chrominance DC.
-                    new byte[]
+        /// </summary>
-                        {
+        /// <remarks>
-                            0, 3, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0,
+        /// This is an example specification taken from the jpeg specification paper.
-                            0, 0, 0
+        /// </remarks>
-                        },
+        public static readonly HuffmanSpec ChrominanceAC = new(
-                    new byte[]
+            new byte[]
-                            {
+            {
-                               0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11
+                0, 2, 1, 2, 4, 4, 3, 4, 7, 5, 4, 4, 0,
-                            }),
+                1, 2, 119
+            },
+            new byte[]
+            {
+                0x00, 0x01, 0x02, 0x03, 0x11, 0x04,
+                0x05, 0x21, 0x31, 0x06, 0x12, 0x41, 0x51,
+                0x07, 0x61, 0x71, 0x13, 0x22, 0x32, 0x81,
+                0x08, 0x14, 0x42, 0x91, 0xa1, 0xb1, 0xc1,
+                0x09, 0x23, 0x33, 0x52, 0xf0, 0x15, 0x62,
+                0x72, 0xd1, 0x0a, 0x16, 0x24, 0x34, 0xe1,
+                0x25, 0xf1, 0x17, 0x18, 0x19, 0x1a, 0x26,
+                0x27, 0x28, 0x29, 0x2a, 0x35, 0x36, 0x37,
+                0x38, 0x39, 0x3a, 0x43, 0x44, 0x45, 0x46,
+                0x47, 0x48, 0x49, 0x4a, 0x53, 0x54, 0x55,
+                0x56, 0x57, 0x58, 0x59, 0x5a, 0x63, 0x64,
+                0x65, 0x66, 0x67, 0x68, 0x69, 0x6a, 0x73,
+                0x74, 0x75, 0x76, 0x77, 0x78, 0x79, 0x7a,
+                0x82, 0x83, 0x84, 0x85, 0x86, 0x87, 0x88,
+                0x89, 0x8a, 0x92, 0x93, 0x94, 0x95, 0x96,
+                0x97, 0x98, 0x99, 0x9a, 0xa2, 0xa3, 0xa4,
+                0xa5, 0xa6, 0xa7, 0xa8, 0xa9, 0xaa, 0xb2,
+                0xb3, 0xb4, 0xb5, 0xb6, 0xb7, 0xb8, 0xb9,
+                0xba, 0xc2, 0xc3, 0xc4, 0xc5, 0xc6, 0xc7,
+                0xc8, 0xc9, 0xca, 0xd2, 0xd3, 0xd4, 0xd5,
+                0xd6, 0xd7, 0xd8, 0xd9, 0xda, 0xe2, 0xe3,
+                0xe4, 0xe5, 0xe6, 0xe7, 0xe8, 0xe9, 0xea,
+                0xf2, 0xf3, 0xf4, 0xf5, 0xf6, 0xf7, 0xf8,
+                0xf9, 0xfa
+            });
 
-                // Chrominance AC.
-                new HuffmanSpec(
-                    new byte[]
-                        {
-                            0, 2, 1, 2, 4, 4, 3, 4, 7, 5, 4, 4, 0,
-                            1, 2, 119
-                        },
-                    new byte[]
-                        {
-                            0x00, 0x01, 0x02, 0x03, 0x11, 0x04,
-                            0x05, 0x21, 0x31, 0x06, 0x12, 0x41, 0x51,
-                            0x07, 0x61, 0x71, 0x13, 0x22, 0x32, 0x81,
-                            0x08, 0x14, 0x42, 0x91, 0xa1, 0xb1, 0xc1,
-                            0x09, 0x23, 0x33, 0x52, 0xf0, 0x15, 0x62,
-                            0x72, 0xd1, 0x0a, 0x16, 0x24, 0x34, 0xe1,
-                            0x25, 0xf1, 0x17, 0x18, 0x19, 0x1a, 0x26,
-                            0x27, 0x28, 0x29, 0x2a, 0x35, 0x36, 0x37,
-                            0x38, 0x39, 0x3a, 0x43, 0x44, 0x45, 0x46,
-                            0x47, 0x48, 0x49, 0x4a, 0x53, 0x54, 0x55,
-                            0x56, 0x57, 0x58, 0x59, 0x5a, 0x63, 0x64,
-                            0x65, 0x66, 0x67, 0x68, 0x69, 0x6a, 0x73,
-                            0x74, 0x75, 0x76, 0x77, 0x78, 0x79, 0x7a,
-                            0x82, 0x83, 0x84, 0x85, 0x86, 0x87, 0x88,
-                            0x89, 0x8a, 0x92, 0x93, 0x94, 0x95, 0x96,
-                            0x97, 0x98, 0x99, 0x9a, 0xa2, 0xa3, 0xa4,
-                            0xa5, 0xa6, 0xa7, 0xa8, 0xa9, 0xaa, 0xb2,
-                            0xb3, 0xb4, 0xb5, 0xb6, 0xb7, 0xb8, 0xb9,
-                            0xba, 0xc2, 0xc3, 0xc4, 0xc5, 0xc6, 0xc7,
-                            0xc8, 0xc9, 0xca, 0xd2, 0xd3, 0xd4, 0xd5,
-                            0xd6, 0xd7, 0xd8, 0xd9, 0xda, 0xe2, 0xe3,
-                            0xe4, 0xe5, 0xe6, 0xe7, 0xe8, 0xe9, 0xea,
-                            0xf2, 0xf3, 0xf4, 0xf5, 0xf6, 0xf7, 0xf8,
-                            0xf9, 0xfa
-                        })
-            };
-#pragma warning restore SA1118 // ParameterMustNotSpanMultipleLines
         /// <summary>
         ///     Gets count[i] - The number of codes of length i bits.
         /// </summary>

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

@@ -0,0 +1,85 @@
+// Copyright (c) Six Labors.
+// Licensed under the Six Labors Split License.
+
+using System;
+using SixLabors.ImageSharp.Advanced;
+using SixLabors.ImageSharp.Memory;
+
+namespace SixLabors.ImageSharp.Formats.Jpeg.Components.Encoder
+{
+    /// <summary>
+    /// Represent a single jpeg frame.
+    /// </summary>
+    internal sealed class JpegFrame : IDisposable
+    {
+        public JpegFrame(Image image, JpegFrameConfig frameConfig, bool interleaved)
+        {
+            this.ColorSpace = frameConfig.ColorType;
+
+            this.Interleaved = interleaved;
+
+            this.PixelWidth = image.Width;
+            this.PixelHeight = image.Height;
+
+            MemoryAllocator allocator = image.GetConfiguration().MemoryAllocator;
+
+            JpegComponentConfig[] componentConfigs = frameConfig.Components;
+            this.Components = new Component[componentConfigs.Length];
+            for (int i = 0; i < this.Components.Length; i++)
+            {
+                JpegComponentConfig componentConfig = componentConfigs[i];
+                this.Components[i] = new Component(allocator, componentConfig.HorizontalSampleFactor, componentConfig.VerticalSampleFactor, componentConfig.QuantizatioTableIndex)
+                {
+                    DcTableId = componentConfig.DcTableSelector,
+                    AcTableId = componentConfig.AcTableSelector,
+                };
+
+                this.BlocksPerMcu += componentConfig.HorizontalSampleFactor * componentConfig.VerticalSampleFactor;
+            }
+
+            int maxSubFactorH = frameConfig.MaxHorizontalSamplingFactor;
+            int maxSubFactorV = frameConfig.MaxVerticalSamplingFactor;
+            this.McusPerLine = (int)Numerics.DivideCeil((uint)image.Width, (uint)maxSubFactorH * 8);
+            this.McusPerColumn = (int)Numerics.DivideCeil((uint)image.Height, (uint)maxSubFactorV * 8);
+
+            for (int i = 0; i < this.Components.Length; i++)
+            {
+                Component component = this.Components[i];
+                component.Init(this, maxSubFactorH, maxSubFactorV);
+            }
+        }
+
+        public JpegColorSpace ColorSpace { get; }
+
+        public bool Interleaved { get; }
+
+        public int PixelHeight { get; }
+
+        public int PixelWidth { get; }
+
+        public Component[] Components { get; }
+
+        public int McusPerLine { get; }
+
+        public int McusPerColumn { get; }
+
+        public int BlocksPerMcu { get; }
+
+        public void Dispose()
+        {
+            for (int i = 0; i < this.Components.Length; i++)
+            {
+                this.Components[i].Dispose();
+            }
+        }
+
+        public void AllocateComponents(bool fullScan)
+        {
+            for (int i = 0; i < this.Components.Length; i++)
+            {
+                Component component = this.Components[i];
+                component.AllocateSpectral(fullScan);
+            }
+        }
+    }
+}

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

@@ -1,123 +0,0 @@
-// Copyright (c) Six Labors.
-// Licensed under the Six Labors Split License.
-
-using System;
-using System.Diagnostics;
-using System.Runtime.CompilerServices;
-using System.Runtime.InteropServices;
-using System.Runtime.Intrinsics;
-using System.Runtime.Intrinsics.X86;
-using SixLabors.ImageSharp.Advanced;
-using SixLabors.ImageSharp.PixelFormats;
-
-namespace SixLabors.ImageSharp.Formats.Jpeg.Components.Encoder
-{
-    /// <summary>
-    /// On-stack worker struct to efficiently encapsulate the TPixel -> L8 -> Y conversion chain of 8x8 pixel blocks.
-    /// </summary>
-    /// <typeparam name="TPixel">The pixel type to work on</typeparam>
-    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 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 readonly Size samplingAreaSize;
-
-        /// <summary>
-        /// <see cref="Configuration"/> for internal operations.
-        /// </summary>
-        private readonly Configuration config;
-
-        public LuminanceForwardConverter(ImageFrame<TPixel> frame)
-        {
-            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(int x, int y, ref RowOctet<TPixel> currentRows)
-        {
-            YCbCrForwardConverter<TPixel>.LoadAndStretchEdges(currentRows, this.pixelSpan, new Point(x, y), SampleSize, this.samplingAreaSize);
-
-            PixelOperations<TPixel>.Instance.ToL8(this.config, this.pixelSpan, this.l8Span);
-
-            ref Block8x8F yBlock = ref this.Y;
-            ref L8 l8Start = ref MemoryMarshal.GetReference(this.l8Span);
-
-            if (RgbToYCbCrConverterVectorized.IsSupported)
-            {
-                ConvertAvx(ref l8Start, ref yBlock);
-            }
-            else
-            {
-                ConvertScalar(ref l8Start, ref yBlock);
-            }
-        }
-
-        /// <summary>
-        /// Converts 8x8 L8 pixel matrix to 8x8 Block of floats using Avx2 Intrinsics.
-        /// </summary>
-        /// <param name="l8Start">Start of span of L8 pixels with size of 64</param>
-        /// <param name="yBlock">8x8 destination matrix of Luminance(Y) converted data</param>
-        private static void ConvertAvx(ref L8 l8Start, ref Block8x8F yBlock)
-        {
-            Debug.Assert(RgbToYCbCrConverterVectorized.IsSupported, "AVX2 is required to run this converter");
-
-            ref Vector128<byte> l8ByteSpan = ref Unsafe.As<L8, Vector128<byte>>(ref l8Start);
-            ref Vector256<float> destRef = ref yBlock.V0;
-
-            const int bytesPerL8Stride = 8;
-            for (nint i = 0; i < 8; i++)
-            {
-                Unsafe.Add(ref destRef, i) = Avx.ConvertToVector256Single(Avx2.ConvertToVector256Int32(Unsafe.AddByteOffset(ref l8ByteSpan, bytesPerL8Stride * i)));
-            }
-        }
-
-        /// <summary>
-        /// Converts 8x8 L8 pixel matrix to 8x8 Block of floats.
-        /// </summary>
-        /// <param name="l8Start">Start of span of L8 pixels with size of 64</param>
-        /// <param name="yBlock">8x8 destination matrix of Luminance(Y) converted data</param>
-        private static void ConvertScalar(ref L8 l8Start, ref Block8x8F yBlock)
-        {
-            for (int i = 0; i < Block8x8F.Size; i++)
-            {
-                ref L8 c = ref Unsafe.Add(ref l8Start, i);
-                yBlock[i] = c.PackedValue;
-            }
-        }
-    }
-}

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

@@ -1,21 +0,0 @@
-// Copyright (c) Six Labors.
-// Licensed under the Six Labors Split License.
-
-namespace SixLabors.ImageSharp.Formats.Jpeg.Components.Encoder
-{
-    /// <summary>
-    /// Enumerates the quantization tables.
-    /// </summary>
-    internal enum QuantIndex
-    {
-        /// <summary>
-        /// The luminance quantization table index.
-        /// </summary>
-        Luminance = 0,
-
-        /// <summary>
-        /// The chrominance quantization table index.
-        /// </summary>
-        Chrominance = 1,
-    }
-}

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

@@ -1,161 +0,0 @@
-// Copyright (c) Six Labors.
-// Licensed under the Six Labors Split License.
-
-using System;
-using System.Diagnostics;
-using System.Runtime.CompilerServices;
-using System.Runtime.InteropServices;
-using System.Runtime.Intrinsics;
-using System.Runtime.Intrinsics.X86;
-using SixLabors.ImageSharp.Advanced;
-using SixLabors.ImageSharp.PixelFormats;
-
-namespace SixLabors.ImageSharp.Formats.Jpeg.Components.Encoder
-{
-    /// <summary>
-    /// On-stack worker struct to convert TPixel -> Rgb24 of 8x8 pixel blocks.
-    /// </summary>
-    /// <typeparam name="TPixel">The pixel type to work on.</typeparam>
-    internal ref struct RgbForwardConverter<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>
-        /// Total byte size of processed pixels converted from TPixel to <see cref="Rgb24"/>
-        /// </summary>
-        private const int RgbSpanByteSize = PixelsPerSample * 3;
-
-        /// <summary>
-        /// The Red component.
-        /// </summary>
-        public Block8x8F R;
-
-        /// <summary>
-        /// The Green component.
-        /// </summary>
-        public Block8x8F G;
-
-        /// <summary>
-        /// The Blue component.
-        /// </summary>
-        public Block8x8F B;
-
-        /// <summary>
-        /// Temporal 64-byte span to hold unconverted TPixel data.
-        /// </summary>
-        private readonly Span<TPixel> pixelSpan;
-
-        /// <summary>
-        /// Temporal 64-byte span to hold converted Rgb24 data.
-        /// </summary>
-        private readonly Span<Rgb24> rgbSpan;
-
-        /// <summary>
-        /// Sampled pixel buffer size.
-        /// </summary>
-        private readonly Size samplingAreaSize;
-
-        /// <summary>
-        /// <see cref="Configuration"/> for internal operations.
-        /// </summary>
-        private readonly Configuration config;
-
-        public RgbForwardConverter(ImageFrame<TPixel> frame)
-        {
-            this.R = default;
-            this.G = default;
-            this.B = default;
-
-            // temporal pixel buffers
-            this.pixelSpan = new TPixel[PixelsPerSample].AsSpan();
-            this.rgbSpan = MemoryMarshal.Cast<byte, Rgb24>(new byte[RgbSpanByteSize + RgbToYCbCrConverterVectorized.AvxCompatibilityPadding].AsSpan());
-
-            // frame data
-            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) to Rgb24.
-        /// </summary>
-        public void Convert(int x, int y, ref RowOctet<TPixel> currentRows)
-        {
-            YCbCrForwardConverter<TPixel>.LoadAndStretchEdges(currentRows, this.pixelSpan, new Point(x, y), SampleSize, this.samplingAreaSize);
-
-            PixelOperations<TPixel>.Instance.ToRgb24(this.config, this.pixelSpan, this.rgbSpan);
-
-            ref Block8x8F redBlock = ref this.R;
-            ref Block8x8F greenBlock = ref this.G;
-            ref Block8x8F blueBlock = ref this.B;
-
-            if (RgbToYCbCrConverterVectorized.IsSupported)
-            {
-                ConvertAvx(this.rgbSpan, ref redBlock, ref greenBlock, ref blueBlock);
-            }
-            else
-            {
-                ConvertScalar(this.rgbSpan, ref redBlock, ref greenBlock, ref blueBlock);
-            }
-        }
-
-        /// <summary>
-        /// Converts 8x8 RGB24 pixel matrix to 8x8 Block of floats using Avx2 Intrinsics.
-        /// </summary>
-        /// <param name="rgbSpan">Span of Rgb24 pixels with size of 64</param>
-        /// <param name="rBlock">8x8 destination matrix of Red converted data</param>
-        /// <param name="gBlock">8x8 destination matrix of Blue converted data</param>
-        /// <param name="bBlock">8x8 destination matrix of Green converted data</param>
-        private static void ConvertAvx(Span<Rgb24> rgbSpan, ref Block8x8F rBlock, ref Block8x8F gBlock, ref Block8x8F bBlock)
-        {
-            Debug.Assert(RgbToYCbCrConverterVectorized.IsSupported, "AVX2 is required to run this converter");
-
-            ref Vector256<byte> rgbByteSpan = ref Unsafe.As<Rgb24, Vector256<byte>>(ref MemoryMarshal.GetReference(rgbSpan));
-            ref Vector256<float> redRef = ref rBlock.V0;
-            ref Vector256<float> greenRef = ref gBlock.V0;
-            ref Vector256<float> blueRef = ref bBlock.V0;
-            Vector256<byte> zero = Vector256.Create(0).AsByte();
-
-            Vector256<uint> extractToLanesMask = Unsafe.As<byte, Vector256<uint>>(ref MemoryMarshal.GetReference(RgbToYCbCrConverterVectorized.MoveFirst24BytesToSeparateLanes));
-            Vector256<byte> extractRgbMask = Unsafe.As<byte, Vector256<byte>>(ref MemoryMarshal.GetReference(RgbToYCbCrConverterVectorized.ExtractRgb));
-            Vector256<byte> rgb, rg, bx;
-
-            const int bytesPerRgbStride = 24;
-            for (nint i = 0; i < 8; i++)
-            {
-                rgb = Avx2.PermuteVar8x32(Unsafe.AddByteOffset(ref rgbByteSpan, bytesPerRgbStride * i).AsUInt32(), extractToLanesMask).AsByte();
-
-                rgb = Avx2.Shuffle(rgb, extractRgbMask);
-
-                rg = Avx2.UnpackLow(rgb, zero);
-                bx = Avx2.UnpackHigh(rgb, zero);
-
-                Unsafe.Add(ref redRef, i) = Avx.ConvertToVector256Single(Avx2.UnpackLow(rg, zero).AsInt32());
-                Unsafe.Add(ref greenRef, i) = Avx.ConvertToVector256Single(Avx2.UnpackHigh(rg, zero).AsInt32());
-                Unsafe.Add(ref blueRef, i) = Avx.ConvertToVector256Single(Avx2.UnpackLow(bx, zero).AsInt32());
-            }
-        }
-
-        private static void ConvertScalar(Span<Rgb24> rgbSpan, ref Block8x8F redBlock, ref Block8x8F greenBlock, ref Block8x8F blueBlock)
-        {
-            ref Rgb24 rgbStart = ref MemoryMarshal.GetReference(rgbSpan);
-
-            for (int i = 0; i < Block8x8F.Size; i++)
-            {
-                Rgb24 c = Unsafe.Add(ref rgbStart, (nint)(uint)i);
-
-                redBlock[i] = c.R;
-                greenBlock[i] = c.G;
-                blueBlock[i] = c.B;
-            }
-        }
-    }
-}

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

@@ -1,237 +0,0 @@
-// Copyright (c) Six Labors.
-// Licensed under the Six Labors Split License.
-
-using System;
-using System.Runtime.CompilerServices;
-using SixLabors.ImageSharp.PixelFormats;
-
-namespace SixLabors.ImageSharp.Formats.Jpeg.Components.Encoder
-{
-    /// <summary>
-    /// Provides 8-bit lookup tables for converting from Rgb to YCbCr colorspace.
-    /// Methods to build the tables are based on libjpeg implementation.
-    /// </summary>
-    internal unsafe struct RgbToYCbCrConverterLut
-    {
-        /// <summary>
-        /// The red luminance table
-        /// </summary>
-        public fixed int YRTable[256];
-
-        /// <summary>
-        /// The green luminance table
-        /// </summary>
-        public fixed int YGTable[256];
-
-        /// <summary>
-        /// The blue luminance table
-        /// </summary>
-        public fixed int YBTable[256];
-
-        /// <summary>
-        /// The red blue-chrominance table
-        /// </summary>
-        public fixed int CbRTable[256];
-
-        /// <summary>
-        /// The green blue-chrominance table
-        /// </summary>
-        public fixed int CbGTable[256];
-
-        /// <summary>
-        /// The blue blue-chrominance table
-        /// B=>Cb and R=>Cr are the same
-        /// </summary>
-        public fixed int CbBTable[256];
-
-        /// <summary>
-        /// The green red-chrominance table
-        /// </summary>
-        public fixed int CrGTable[256];
-
-        /// <summary>
-        /// The blue red-chrominance table
-        /// </summary>
-        public fixed int CrBTable[256];
-
-        // Speediest right-shift on some machines and gives us enough accuracy at 4 decimal places.
-        private const int ScaleBits = 16;
-
-        private const int CBCrOffset = 128 << ScaleBits;
-
-        private const int Half = 1 << (ScaleBits - 1);
-
-        /// <summary>
-        /// Initializes the YCbCr tables
-        /// </summary>
-        /// <returns>The initialized <see cref="RgbToYCbCrConverterLut"/></returns>
-        public static RgbToYCbCrConverterLut Create()
-        {
-            RgbToYCbCrConverterLut tables = default;
-
-            for (int i = 0; i <= 255; i++)
-            {
-                // The values for the calculations are left scaled up since we must add them together before rounding.
-                tables.YRTable[i] = Fix(0.299F) * i;
-                tables.YGTable[i] = Fix(0.587F) * i;
-                tables.YBTable[i] = (Fix(0.114F) * i) + Half;
-                tables.CbRTable[i] = (-Fix(0.168735892F)) * i;
-                tables.CbGTable[i] = (-Fix(0.331264108F)) * i;
-
-                // We use a rounding fudge - factor of 0.5 - epsilon for Cb and Cr.
-                // This ensures that the maximum output will round to 255
-                // not 256, and thus that we don't have to range-limit.
-                //
-                // B=>Cb and R=>Cr tables are the same
-                tables.CbBTable[i] = (Fix(0.5F) * i) + CBCrOffset + Half - 1;
-
-                tables.CrGTable[i] = (-Fix(0.418687589F)) * i;
-                tables.CrBTable[i] = (-Fix(0.081312411F)) * i;
-            }
-
-            return tables;
-        }
-
-        [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        private float CalculateY(byte r, byte g, byte b)
-        {
-            // float y = (0.299F * r) + (0.587F * g) + (0.114F * b);
-            return (this.YRTable[r] + this.YGTable[g] + this.YBTable[b]) >> ScaleBits;
-        }
-
-        [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        private float CalculateCb(byte r, byte g, byte b)
-        {
-            // float cb = 128F + ((-0.168736F * r) - (0.331264F * g) + (0.5F * b));
-            return (this.CbRTable[r] + this.CbGTable[g] + this.CbBTable[b]) >> ScaleBits;
-        }
-
-        [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        private float CalculateCr(byte r, byte g, byte b)
-        {
-            // float cr = 128F + ((0.5F * r) - (0.418688F * g) - (0.081312F * b));
-            return (this.CbBTable[r] + this.CrGTable[g] + this.CrBTable[b]) >> ScaleBits;
-        }
-
-        /// <summary>
-        /// Converts Rgb24 pixels into YCbCr color space with 4:4:4 subsampling sampling of luminance and chroma.
-        /// </summary>
-        /// <param name="rgbSpan">Span of Rgb24 pixel data</param>
-        /// <param name="yBlock">Resulting Y values block</param>
-        /// <param name="cbBlock">Resulting Cb values block</param>
-        /// <param name="crBlock">Resulting Cr values block</param>
-        public void Convert444(Span<Rgb24> rgbSpan, ref Block8x8F yBlock, ref Block8x8F cbBlock, ref Block8x8F crBlock)
-        {
-            ref Rgb24 rgbStart = ref rgbSpan[0];
-
-            for (int i = 0; i < Block8x8F.Size; i++)
-            {
-                Rgb24 c = Unsafe.Add(ref rgbStart, i);
-
-                yBlock[i] = this.CalculateY(c.R, c.G, c.B);
-                cbBlock[i] = this.CalculateCb(c.R, c.G, c.B);
-                crBlock[i] = this.CalculateCr(c.R, c.G, c.B);
-            }
-        }
-
-        /// <summary>
-        /// Converts Rgb24 pixels into YCbCr color space with 4:2:0 subsampling of luminance and chroma.
-        /// </summary>
-        /// <remarks>Calculates 2 out of 4 luminance blocks and half of chroma blocks. This method must be called twice per 4x 8x8 DCT blocks with different row param.</remarks>
-        /// <param name="rgbSpan">Span of Rgb24 pixel data</param>
-        /// <param name="yBlockLeft">First or "left" resulting Y block</param>
-        /// <param name="yBlockRight">Second or "right" resulting Y block</param>
-        /// <param name="cbBlock">Resulting Cb values block</param>
-        /// <param name="crBlock">Resulting Cr values block</param>
-        /// <param name="row">Row index of the 16x16 block, 0 or 1</param>
-        public void Convert420(Span<Rgb24> rgbSpan, ref Block8x8F yBlockLeft, ref Block8x8F yBlockRight, ref Block8x8F cbBlock, ref Block8x8F crBlock, int row)
-        {
-            DebugGuard.MustBeBetweenOrEqualTo(row, 0, 1, nameof(row));
-
-            ref float yBlockLeftRef = ref Unsafe.As<Block8x8F, float>(ref yBlockLeft);
-            ref float yBlockRightRef = ref Unsafe.As<Block8x8F, float>(ref yBlockRight);
-
-            // 0-31 or 32-63
-            // upper or lower part
-            int chromaWriteOffset = row * (Block8x8F.Size / 2);
-            ref float cbBlockRef = ref Unsafe.Add(ref Unsafe.As<Block8x8F, float>(ref cbBlock), chromaWriteOffset);
-            ref float crBlockRef = ref Unsafe.Add(ref Unsafe.As<Block8x8F, float>(ref crBlock), chromaWriteOffset);
-
-            ref Rgb24 rgbStart = ref rgbSpan[0];
-
-            for (int i = 0; i < 8; i += 2)
-            {
-                int yBlockWriteOffset = i * 8;
-                ref Rgb24 stride = ref Unsafe.Add(ref rgbStart, i * 16);
-
-                int chromaOffset = 8 * (i / 2);
-
-                // left
-                this.ConvertChunk420(
-                    ref stride,
-                    ref Unsafe.Add(ref yBlockLeftRef, yBlockWriteOffset),
-                    ref Unsafe.Add(ref cbBlockRef, chromaOffset),
-                    ref Unsafe.Add(ref crBlockRef, chromaOffset));
-
-                // right
-                this.ConvertChunk420(
-                    ref Unsafe.Add(ref stride, 8),
-                    ref Unsafe.Add(ref yBlockRightRef, yBlockWriteOffset),
-                    ref Unsafe.Add(ref cbBlockRef, chromaOffset + 4),
-                    ref Unsafe.Add(ref crBlockRef, chromaOffset + 4));
-            }
-        }
-
-        [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        private void ConvertChunk420(ref Rgb24 stride, ref float yBlock, ref float cbBlock, ref float crBlock)
-        {
-            // jpeg 8x8 blocks are processed as 16x16 blocks with 16x8 subpasses (this is done for performance reasons)
-            // each row is 16 pixels wide thus +16 stride reference offset
-            // resulting luminance (Y`) are sampled at original resolution thus +8 reference offset
-            for (int k = 0; k < 8; k += 2)
-            {
-                ref float yBlockRef = ref Unsafe.Add(ref yBlock, k);
-
-                // top row
-                Rgb24 px0 = Unsafe.Add(ref stride, k);
-                Rgb24 px1 = Unsafe.Add(ref stride, k + 1);
-                yBlockRef = this.CalculateY(px0.R, px0.G, px0.B);
-                Unsafe.Add(ref yBlockRef, 1) = this.CalculateY(px1.R, px1.G, px1.B);
-
-                // bottom row
-                Rgb24 px2 = Unsafe.Add(ref stride, k + 16);
-                Rgb24 px3 = Unsafe.Add(ref stride, k + 17);
-                Unsafe.Add(ref yBlockRef, 8) = this.CalculateY(px2.R, px2.G, px2.B);
-                Unsafe.Add(ref yBlockRef, 9) = this.CalculateY(px3.R, px3.G, px3.B);
-
-                // chroma average for 2x2 pixel block
-                Unsafe.Add(ref cbBlock, k / 2) = this.CalculateAverageCb(px0, px1, px2, px3);
-                Unsafe.Add(ref crBlock, k / 2) = this.CalculateAverageCr(px0, px1, px2, px3);
-            }
-        }
-
-        [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        private float CalculateAverageCb(Rgb24 px0, Rgb24 px1, Rgb24 px2, Rgb24 px3)
-        {
-            return 0.25f
-                * (this.CalculateCb(px0.R, px0.G, px0.B)
-                + this.CalculateCb(px1.R, px1.G, px1.B)
-                + this.CalculateCb(px2.R, px2.G, px2.B)
-                + this.CalculateCb(px3.R, px3.G, px3.B));
-        }
-
-        [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        private float CalculateAverageCr(Rgb24 px0, Rgb24 px1, Rgb24 px2, Rgb24 px3)
-        {
-            return 0.25f
-                * (this.CalculateCr(px0.R, px0.G, px0.B)
-                + this.CalculateCr(px1.R, px1.G, px1.B)
-                + this.CalculateCr(px2.R, px2.G, px2.B)
-                + this.CalculateCr(px3.R, px3.G, px3.B));
-        }
-
-        [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        private static int Fix(float x)
-            => (int)((x * (1L << ScaleBits)) + 0.5F);
-    }
-}

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

@@ -1,237 +0,0 @@
-// Copyright (c) Six Labors.
-// Licensed under the Six Labors Split License.
-
-using System;
-using System.Diagnostics;
-using System.Runtime.CompilerServices;
-using System.Runtime.InteropServices;
-using System.Runtime.Intrinsics;
-using System.Runtime.Intrinsics.X86;
-using SixLabors.ImageSharp.PixelFormats;
-
-namespace SixLabors.ImageSharp.Formats.Jpeg.Components.Encoder
-{
-    internal static class RgbToYCbCrConverterVectorized
-    {
-        public static bool IsSupported => Avx2.IsSupported;
-
-        public static int AvxCompatibilityPadding
-        {
-            // rgb byte matrices contain 8 strides by 8 pixels each, thus 64 pixels total
-            // Strides are stored sequentially - one big span of 64 * 3 = 192 bytes
-            // Each stride has exactly 3 * 8 = 24 bytes or 3 * 8 * 8 = 192 bits
-            // Avx registers are 256 bits so rgb span will be loaded with extra 64 bits from the next stride:
-            // stride 0    0    - 192  -(+64bits)-> 256
-            // stride 1    192  - 384  -(+64bits)-> 448
-            // stride 2    384  - 576  -(+64bits)-> 640
-            // stride 3    576  - 768  -(+64bits)-> 832
-            // stride 4    768  - 960  -(+64bits)-> 1024
-            // stride 5    960  - 1152 -(+64bits)-> 1216
-            // stride 6    1152 - 1344 -(+64bits)-> 1408
-            // stride 7    1344 - 1536 -(+64bits)-> 1600 <-- READ ACCESS VIOLATION
-            //
-            // Total size of the 64 pixel rgb span: 64 * 3 * 8 = 1536 bits, avx operations require 1600 bits
-            // This is not permitted - we are reading foreign memory
-            //
-            // 8 byte padding to rgb byte span will solve this problem without extra code in converters
-            get
-            {
-                if (IsSupported)
-                {
-                    return 8;
-                }
-
-                return 0;
-            }
-        }
-
-        internal static ReadOnlySpan<byte> MoveFirst24BytesToSeparateLanes => new byte[]
-        {
-            0, 0, 0, 0, 1, 0, 0, 0, 2, 0, 0, 0, 6, 0, 0, 0,
-            3, 0, 0, 0, 4, 0, 0, 0, 5, 0, 0, 0, 7, 0, 0, 0
-        };
-
-        internal static ReadOnlySpan<byte> ExtractRgb => new byte[]
-        {
-            0, 3, 6, 9, 1, 4, 7, 10, 2, 5, 8, 11, 0xFF, 0xFF, 0xFF, 0xFF,
-            0, 3, 6, 9, 1, 4, 7, 10, 2, 5, 8, 11, 0xFF, 0xFF, 0xFF, 0xFF
-        };
-
-        /// <summary>
-        /// Converts 8x8 Rgb24 pixel matrix to YCbCr pixel matrices with 4:4:4 subsampling
-        /// </summary>
-        /// <remarks>Total size of rgb span must be 200 bytes</remarks>
-        /// <param name="rgbSpan">Span of rgb pixels with size of 64</param>
-        /// <param name="yBlock">8x8 destination matrix of Luminance(Y) converted data</param>
-        /// <param name="cbBlock">8x8 destination matrix of Chrominance(Cb) converted data</param>
-        /// <param name="crBlock">8x8 destination matrix of Chrominance(Cr) converted data</param>
-        public static void Convert444(ReadOnlySpan<Rgb24> rgbSpan, ref Block8x8F yBlock, ref Block8x8F cbBlock, ref Block8x8F crBlock)
-        {
-            Debug.Assert(IsSupported, "AVX2 is required to run this converter");
-
-            var f0299 = Vector256.Create(0.299f);
-            var f0587 = Vector256.Create(0.587f);
-            var f0114 = Vector256.Create(0.114f);
-            var fn0168736 = Vector256.Create(-0.168736f);
-            var fn0331264 = Vector256.Create(-0.331264f);
-            var f128 = Vector256.Create(128f);
-            var fn0418688 = Vector256.Create(-0.418688f);
-            var fn0081312F = Vector256.Create(-0.081312F);
-            var f05 = Vector256.Create(0.5f);
-            Vector256<byte> zero = Vector256.Create(0).AsByte();
-
-            ref Vector256<byte> rgbByteSpan = ref Unsafe.As<Rgb24, Vector256<byte>>(ref MemoryMarshal.GetReference(rgbSpan));
-            ref Vector256<float> destYRef = ref yBlock.V0;
-            ref Vector256<float> destCbRef = ref cbBlock.V0;
-            ref Vector256<float> destCrRef = ref crBlock.V0;
-
-            Vector256<uint> extractToLanesMask = Unsafe.As<byte, Vector256<uint>>(ref MemoryMarshal.GetReference(MoveFirst24BytesToSeparateLanes));
-            Vector256<byte> extractRgbMask = Unsafe.As<byte, Vector256<byte>>(ref MemoryMarshal.GetReference(ExtractRgb));
-            Vector256<byte> rgb, rg, bx;
-            Vector256<float> r, g, b;
-
-            const int bytesPerRgbStride = 24;
-            for (int i = 0; i < 8; i++)
-            {
-                rgb = Avx2.PermuteVar8x32(Unsafe.AddByteOffset(ref rgbByteSpan, (IntPtr)(bytesPerRgbStride * i)).AsUInt32(), extractToLanesMask).AsByte();
-
-                rgb = Avx2.Shuffle(rgb, extractRgbMask);
-
-                rg = Avx2.UnpackLow(rgb, zero);
-                bx = Avx2.UnpackHigh(rgb, zero);
-
-                r = Avx.ConvertToVector256Single(Avx2.UnpackLow(rg, zero).AsInt32());
-                g = Avx.ConvertToVector256Single(Avx2.UnpackHigh(rg, zero).AsInt32());
-                b = Avx.ConvertToVector256Single(Avx2.UnpackLow(bx, zero).AsInt32());
-
-                // (0.299F * r) + (0.587F * g) + (0.114F * b);
-                Unsafe.Add(ref destYRef, i) = SimdUtils.HwIntrinsics.MultiplyAdd(SimdUtils.HwIntrinsics.MultiplyAdd(Avx.Multiply(f0114, b), f0587, g), f0299, r);
-
-                // 128F + ((-0.168736F * r) - (0.331264F * g) + (0.5F * b))
-                Unsafe.Add(ref destCbRef, i) = Avx.Add(f128, SimdUtils.HwIntrinsics.MultiplyAdd(SimdUtils.HwIntrinsics.MultiplyAdd(Avx.Multiply(f05, b), fn0331264, g), fn0168736, r));
-
-                // 128F + ((0.5F * r) - (0.418688F * g) - (0.081312F * b))
-                Unsafe.Add(ref destCrRef, i) = Avx.Add(f128, SimdUtils.HwIntrinsics.MultiplyAdd(SimdUtils.HwIntrinsics.MultiplyAdd(Avx.Multiply(fn0081312F, b), fn0418688, g), f05, r));
-            }
-        }
-
-        /// <summary>
-        /// Converts 16x8 Rgb24 pixels matrix to 2 Y 8x8 matrices with 4:2:0 subsampling
-        /// </summary>
-        public static void Convert420(ReadOnlySpan<Rgb24> rgbSpan, ref Block8x8F yBlockLeft, ref Block8x8F yBlockRight, ref Block8x8F cbBlock, ref Block8x8F crBlock, int row)
-        {
-            Debug.Assert(IsSupported, "AVX2 is required to run this converter");
-
-            var f0299 = Vector256.Create(0.299f);
-            var f0587 = Vector256.Create(0.587f);
-            var f0114 = Vector256.Create(0.114f);
-            var fn0168736 = Vector256.Create(-0.168736f);
-            var fn0331264 = Vector256.Create(-0.331264f);
-            var f128 = Vector256.Create(128f);
-            var fn0418688 = Vector256.Create(-0.418688f);
-            var fn0081312F = Vector256.Create(-0.081312F);
-            var f05 = Vector256.Create(0.5f);
-            Vector256<byte> zero = Vector256.Create(0).AsByte();
-
-            ref Vector256<byte> rgbByteSpan = ref Unsafe.As<Rgb24, Vector256<byte>>(ref MemoryMarshal.GetReference(rgbSpan));
-
-            int destOffset = row * 4;
-
-            ref Vector256<float> destCbRef = ref Unsafe.Add(ref Unsafe.As<Block8x8F, Vector256<float>>(ref cbBlock), destOffset);
-            ref Vector256<float> destCrRef = ref Unsafe.Add(ref Unsafe.As<Block8x8F, Vector256<float>>(ref crBlock), destOffset);
-
-            Vector256<uint> extractToLanesMask = Unsafe.As<byte, Vector256<uint>>(ref MemoryMarshal.GetReference(MoveFirst24BytesToSeparateLanes));
-            Vector256<byte> extractRgbMask = Unsafe.As<byte, Vector256<byte>>(ref MemoryMarshal.GetReference(ExtractRgb));
-            Vector256<byte> rgb, rg, bx;
-            Vector256<float> r, g, b;
-
-            Span<Vector256<float>> rDataLanes = stackalloc Vector256<float>[4];
-            Span<Vector256<float>> gDataLanes = stackalloc Vector256<float>[4];
-            Span<Vector256<float>> bDataLanes = stackalloc Vector256<float>[4];
-
-            const int bytesPerRgbStride = 24;
-            for (int i = 0; i < 4; i++)
-            {
-                // 16x2 => 8x1
-                // left 8x8 column conversions
-                for (int j = 0; j < 4; j += 2)
-                {
-                    rgb = Avx2.PermuteVar8x32(Unsafe.AddByteOffset(ref rgbByteSpan, (IntPtr)(bytesPerRgbStride * ((i * 4) + j))).AsUInt32(), extractToLanesMask).AsByte();
-
-                    rgb = Avx2.Shuffle(rgb, extractRgbMask);
-
-                    rg = Avx2.UnpackLow(rgb, zero);
-                    bx = Avx2.UnpackHigh(rgb, zero);
-
-                    r = Avx.ConvertToVector256Single(Avx2.UnpackLow(rg, zero).AsInt32());
-                    g = Avx.ConvertToVector256Single(Avx2.UnpackHigh(rg, zero).AsInt32());
-                    b = Avx.ConvertToVector256Single(Avx2.UnpackLow(bx, zero).AsInt32());
-
-                    int yBlockVerticalOffset = (i * 2) + ((j & 2) >> 1);
-
-                    // (0.299F * r) + (0.587F * g) + (0.114F * b);
-                    Unsafe.Add(ref yBlockLeft.V0, yBlockVerticalOffset) = SimdUtils.HwIntrinsics.MultiplyAdd(SimdUtils.HwIntrinsics.MultiplyAdd(Avx.Multiply(f0114, b), f0587, g), f0299, r);
-
-                    rDataLanes[j] = r;
-                    gDataLanes[j] = g;
-                    bDataLanes[j] = b;
-                }
-
-                // 16x2 => 8x1
-                // right 8x8 column conversions
-                for (int j = 1; j < 4; j += 2)
-                {
-                    rgb = Avx2.PermuteVar8x32(Unsafe.AddByteOffset(ref rgbByteSpan, (IntPtr)(bytesPerRgbStride * ((i * 4) + j))).AsUInt32(), extractToLanesMask).AsByte();
-
-                    rgb = Avx2.Shuffle(rgb, extractRgbMask);
-
-                    rg = Avx2.UnpackLow(rgb, zero);
-                    bx = Avx2.UnpackHigh(rgb, zero);
-
-                    r = Avx.ConvertToVector256Single(Avx2.UnpackLow(rg, zero).AsInt32());
-                    g = Avx.ConvertToVector256Single(Avx2.UnpackHigh(rg, zero).AsInt32());
-                    b = Avx.ConvertToVector256Single(Avx2.UnpackLow(bx, zero).AsInt32());
-
-                    int yBlockVerticalOffset = (i * 2) + ((j & 2) >> 1);
-
-                    // (0.299F * r) + (0.587F * g) + (0.114F * b);
-                    Unsafe.Add(ref yBlockRight.V0, yBlockVerticalOffset) = SimdUtils.HwIntrinsics.MultiplyAdd(SimdUtils.HwIntrinsics.MultiplyAdd(Avx.Multiply(f0114, b), f0587, g), f0299, r);
-
-                    rDataLanes[j] = r;
-                    gDataLanes[j] = g;
-                    bDataLanes[j] = b;
-                }
-
-                r = Scale16x2_8x1(rDataLanes);
-                g = Scale16x2_8x1(gDataLanes);
-                b = Scale16x2_8x1(bDataLanes);
-
-                // 128F + ((-0.168736F * r) - (0.331264F * g) + (0.5F * b))
-                Unsafe.Add(ref destCbRef, i) = Avx.Add(f128, SimdUtils.HwIntrinsics.MultiplyAdd(SimdUtils.HwIntrinsics.MultiplyAdd(Avx.Multiply(f05, b), fn0331264, g), fn0168736, r));
-
-                // 128F + ((0.5F * r) - (0.418688F * g) - (0.081312F * b))
-                Unsafe.Add(ref destCrRef, i) = Avx.Add(f128, SimdUtils.HwIntrinsics.MultiplyAdd(SimdUtils.HwIntrinsics.MultiplyAdd(Avx.Multiply(fn0081312F, b), fn0418688, g), f05, r));
-            }
-        }
-
-        /// <summary>
-        /// Scales 16x2 matrix to 8x1 using 2x2 average
-        /// </summary>
-        /// <param name="v">Input matrix consisting of 4 256bit vectors</param>
-        /// <returns>256bit vector containing upper and lower scaled parts of the input matrix</returns>
-        [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        internal static Vector256<float> Scale16x2_8x1(ReadOnlySpan<Vector256<float>> v)
-        {
-            Debug.Assert(Avx2.IsSupported, "AVX2 is required to run this converter");
-            DebugGuard.IsTrue(v.Length == 4, "Input span must consist of 4 elements");
-
-            var f025 = Vector256.Create(0.25f);
-
-            Vector256<float> left = Avx.Add(v[0], v[2]);
-            Vector256<float> right = Avx.Add(v[1], v[3]);
-            Vector256<float> avg2x2 = Avx.Multiply(Avx.HorizontalAdd(left, right), f025);
-
-            return Avx2.Permute4x64(avg2x2.AsDouble(), 0b11_01_10_00).AsSingle();
-        }
-    }
-}

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

@@ -0,0 +1,12 @@
+// Copyright (c) Six Labors.
+// Licensed under the Six Labors Split License.
+
+namespace SixLabors.ImageSharp.Formats.Jpeg.Components.Encoder
+{
+    /// <summary>
+    /// Converter used to convert pixel data to jpeg spectral data.
+    /// </summary>
+    internal abstract class SpectralConverter
+    {
+    }
+}

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

@@ -0,0 +1,149 @@
+// Copyright (c) Six Labors.
+// Licensed under the Six Labors Split License.
+
+using System;
+using System.Buffers;
+using System.Linq;
+using SixLabors.ImageSharp.Advanced;
+using SixLabors.ImageSharp.Memory;
+using SixLabors.ImageSharp.PixelFormats;
+
+namespace SixLabors.ImageSharp.Formats.Jpeg.Components.Encoder
+{
+    /// <inheritdoc/>
+    internal class SpectralConverter<TPixel> : SpectralConverter, IDisposable
+        where TPixel : unmanaged, IPixel<TPixel>
+    {
+        private readonly ComponentProcessor[] componentProcessors;
+
+        private readonly int pixelRowsPerStep;
+
+        private int pixelRowCounter;
+
+        private readonly Buffer2D<TPixel> pixelBuffer;
+
+        private readonly IMemoryOwner<float> redLane;
+
+        private readonly IMemoryOwner<float> greenLane;
+
+        private readonly IMemoryOwner<float> blueLane;
+
+        private readonly int alignedPixelWidth;
+
+        private readonly JpegColorConverterBase colorConverter;
+
+        public SpectralConverter(JpegFrame frame, Image<TPixel> image, Block8x8F[] dequantTables)
+        {
+            MemoryAllocator allocator = image.GetConfiguration().MemoryAllocator;
+
+            // iteration data
+            int majorBlockWidth = frame.Components.Max((component) => component.SizeInBlocks.Width);
+            int majorVerticalSamplingFactor = frame.Components.Max((component) => component.SamplingFactors.Height);
+
+            const int blockPixelHeight = 8;
+            this.pixelRowsPerStep = majorVerticalSamplingFactor * blockPixelHeight;
+
+            // pixel buffer of the image
+            this.pixelBuffer = image.GetRootFramePixelBuffer();
+
+            // component processors from spectral to Rgb24
+            const int blockPixelWidth = 8;
+            this.alignedPixelWidth = majorBlockWidth * blockPixelWidth;
+            var postProcessorBufferSize = new Size(this.alignedPixelWidth, this.pixelRowsPerStep);
+            this.componentProcessors = new ComponentProcessor[frame.Components.Length];
+            for (int i = 0; i < this.componentProcessors.Length; i++)
+            {
+                Component component = frame.Components[i];
+                this.componentProcessors[i] = new ComponentProcessor(
+                    allocator,
+                    component,
+                    postProcessorBufferSize,
+                    dequantTables[component.QuantizationTableIndex]);
+            }
+
+            this.redLane = allocator.Allocate<float>(this.alignedPixelWidth, AllocationOptions.Clean);
+            this.greenLane = allocator.Allocate<float>(this.alignedPixelWidth, AllocationOptions.Clean);
+            this.blueLane = allocator.Allocate<float>(this.alignedPixelWidth, AllocationOptions.Clean);
+
+            // color converter from Rgb24 to YCbCr
+            this.colorConverter = JpegColorConverterBase.GetConverter(colorSpace: frame.ColorSpace, precision: 8);
+        }
+
+        public void ConvertStrideBaseline()
+        {
+            // Codestyle suggests expression body but it
+            // also requires empty line before comments
+            // which looks ugly with expression bodies thus this warning disable
+#pragma warning disable IDE0022
+            // Convert next pixel stride using single spectral `stride'
+            // Note that zero passing eliminates the need of virtual call
+            // from JpegComponentPostProcessor
+            this.ConvertStride(spectralStep: 0);
+#pragma warning restore IDE0022
+        }
+
+        public void ConvertFull()
+        {
+            int steps = (int)Numerics.DivideCeil((uint)this.pixelBuffer.Height, (uint)this.pixelRowsPerStep);
+            for (int i = 0; i < steps; i++)
+            {
+                this.ConvertStride(i);
+            }
+        }
+
+        private void ConvertStride(int spectralStep)
+        {
+            int start = this.pixelRowCounter;
+            int end = start + this.pixelRowsPerStep;
+
+            int pixelBufferLastVerticalIndex = this.pixelBuffer.Height - 1;
+
+            // Pixel strides must be padded with the last pixel of the stride
+            int paddingStartIndex = this.pixelBuffer.Width;
+            int paddedPixelsCount = this.alignedPixelWidth - this.pixelBuffer.Width;
+
+            Span<float> rLane = this.redLane.GetSpan();
+            Span<float> gLane = this.greenLane.GetSpan();
+            Span<float> bLane = this.blueLane.GetSpan();
+
+            for (int yy = start; yy < end; yy++)
+            {
+                int y = yy - this.pixelRowCounter;
+
+                // Unpack TPixel to r/g/b planes
+                int srcIndex = Math.Min(yy, pixelBufferLastVerticalIndex);
+                Span<TPixel> sourceRow = this.pixelBuffer.DangerousGetRowSpan(srcIndex);
+                PixelOperations<TPixel>.Instance.UnpackIntoRgbPlanes(rLane, gLane, bLane, sourceRow);
+
+                rLane.Slice(paddingStartIndex).Fill(rLane[paddingStartIndex - 1]);
+                gLane.Slice(paddingStartIndex).Fill(gLane[paddingStartIndex - 1]);
+                bLane.Slice(paddingStartIndex).Fill(bLane[paddingStartIndex - 1]);
+
+                // Convert from rgb24 to target pixel type
+                var values = new JpegColorConverterBase.ComponentValues(this.componentProcessors, y);
+                this.colorConverter.ConvertFromRgb(values, rLane, gLane, bLane);
+            }
+
+            // Convert pixels to spectral
+            for (int i = 0; i < this.componentProcessors.Length; i++)
+            {
+                this.componentProcessors[i].CopyColorBufferToBlocks(spectralStep);
+            }
+
+            this.pixelRowCounter = end;
+        }
+
+        /// <inheritdoc/>
+        public void Dispose()
+        {
+            foreach (ComponentProcessor cpp in this.componentProcessors)
+            {
+                cpp.Dispose();
+            }
+
+            this.redLane.Dispose();
+            this.greenLane.Dispose();
+            this.blueLane.Dispose();
+        }
+    }
+}

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

@@ -1,121 +0,0 @@
-// Copyright (c) Six Labors.
-// Licensed under the Six Labors Split License.
-
-using System;
-using System.Runtime.InteropServices;
-using SixLabors.ImageSharp.Advanced;
-using SixLabors.ImageSharp.PixelFormats;
-
-namespace SixLabors.ImageSharp.Formats.Jpeg.Components.Encoder
-{
-    /// <summary>
-    /// On-stack worker struct to efficiently encapsulate the TPixel -> Rgb24 -> YCbCr conversion chain of 8x8 pixel blocks.
-    /// </summary>
-    /// <typeparam name="TPixel">The pixel type to work on</typeparam>
-    internal ref struct YCbCrForwardConverter420<TPixel>
-        where TPixel : unmanaged, IPixel<TPixel>
-    {
-        /// <summary>
-        /// Number of pixels processed per single <see cref="Convert(int, int, ref RowOctet{TPixel}, int)"/> call
-        /// </summary>
-        private const int PixelsPerSample = 16 * 8;
-
-        /// <summary>
-        /// Total byte size of processed pixels converted from TPixel to <see cref="Rgb24"/>
-        /// </summary>
-        private const int RgbSpanByteSize = PixelsPerSample * 3;
-
-        /// <summary>
-        /// The left Y component
-        /// </summary>
-        public Block8x8F YLeft;
-
-        /// <summary>
-        /// The left Y component
-        /// </summary>
-        public Block8x8F YRight;
-
-        /// <summary>
-        /// The Cb component
-        /// </summary>
-        public Block8x8F Cb;
-
-        /// <summary>
-        /// The Cr component
-        /// </summary>
-        public Block8x8F Cr;
-
-        /// <summary>
-        /// The color conversion tables
-        /// </summary>
-        private RgbToYCbCrConverterLut colorTables;
-
-        /// <summary>
-        /// Temporal 16x8 block to hold TPixel data
-        /// </summary>
-        private readonly Span<TPixel> pixelSpan;
-
-        /// <summary>
-        /// Temporal RGB block
-        /// </summary>
-        private readonly Span<Rgb24> rgbSpan;
-
-        /// <summary>
-        /// Sampled pixel buffer size
-        /// </summary>
-        private readonly Size samplingAreaSize;
-
-        /// <summary>
-        /// <see cref="Configuration"/> for internal operations
-        /// </summary>
-        private readonly Configuration config;
-
-        public YCbCrForwardConverter420(ImageFrame<TPixel> frame)
-        {
-            // matrices would be filled during convert calls
-            this.YLeft = default;
-            this.YRight = default;
-            this.Cb = default;
-            this.Cr = default;
-
-            // temporal pixel buffers
-            this.pixelSpan = new TPixel[PixelsPerSample].AsSpan();
-            this.rgbSpan = MemoryMarshal.Cast<byte, Rgb24>(new byte[RgbSpanByteSize + RgbToYCbCrConverterVectorized.AvxCompatibilityPadding].AsSpan());
-
-            // frame data
-            this.samplingAreaSize = new Size(frame.Width, frame.Height);
-            this.config = frame.GetConfiguration();
-
-            // conversion vector fallback data
-            if (!RgbToYCbCrConverterVectorized.IsSupported)
-            {
-                this.colorTables = RgbToYCbCrConverterLut.Create();
-            }
-            else
-            {
-                this.colorTables = default;
-            }
-        }
-
-        /// <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);
-
-            PixelOperations<TPixel>.Instance.ToRgb24(this.config, this.pixelSpan, this.rgbSpan);
-
-            if (RgbToYCbCrConverterVectorized.IsSupported)
-            {
-                RgbToYCbCrConverterVectorized.Convert420(this.rgbSpan, ref this.YLeft, ref this.YRight, ref this.Cb, ref this.Cr, idx);
-            }
-            else
-            {
-                this.colorTables.Convert420(this.rgbSpan, ref this.YLeft, ref this.YRight, ref this.Cb, ref this.Cr, idx);
-            }
-        }
-    }
-}

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

@@ -1,122 +0,0 @@
-// Copyright (c) Six Labors.
-// Licensed under the Six Labors Split License.
-
-using System;
-using System.Runtime.InteropServices;
-using SixLabors.ImageSharp.Advanced;
-using SixLabors.ImageSharp.PixelFormats;
-
-namespace SixLabors.ImageSharp.Formats.Jpeg.Components.Encoder
-{
-    /// <summary>
-    /// On-stack worker struct to efficiently encapsulate the TPixel -> Rgb24 -> YCbCr conversion chain of 8x8 pixel blocks.
-    /// </summary>
-    /// <typeparam name="TPixel">The pixel type to work on</typeparam>
-    internal ref struct YCbCrForwardConverter444<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>
-        /// Total byte size of processed pixels converted from TPixel to <see cref="Rgb24"/>
-        /// </summary>
-        private const int RgbSpanByteSize = PixelsPerSample * 3;
-
-        /// <summary>
-        /// The Y component
-        /// </summary>
-        public Block8x8F Y;
-
-        /// <summary>
-        /// The Cb component
-        /// </summary>
-        public Block8x8F Cb;
-
-        /// <summary>
-        /// The Cr component
-        /// </summary>
-        public Block8x8F Cr;
-
-        /// <summary>
-        /// The color conversion tables
-        /// </summary>
-        private RgbToYCbCrConverterLut colorTables;
-
-        /// <summary>
-        /// Temporal 64-byte span to hold unconverted TPixel data
-        /// </summary>
-        private readonly Span<TPixel> pixelSpan;
-
-        /// <summary>
-        /// Temporal 64-byte span to hold converted Rgb24 data
-        /// </summary>
-        private readonly Span<Rgb24> rgbSpan;
-
-        /// <summary>
-        /// Sampled pixel buffer size
-        /// </summary>
-        private readonly Size samplingAreaSize;
-
-        /// <summary>
-        /// <see cref="Configuration"/> for internal operations
-        /// </summary>
-        private readonly Configuration config;
-
-        public YCbCrForwardConverter444(ImageFrame<TPixel> frame)
-        {
-            // matrices would be filled during convert calls
-            this.Y = default;
-            this.Cb = default;
-            this.Cr = default;
-
-            // temporal pixel buffers
-            this.pixelSpan = new TPixel[PixelsPerSample].AsSpan();
-            this.rgbSpan = MemoryMarshal.Cast<byte, Rgb24>(new byte[RgbSpanByteSize + RgbToYCbCrConverterVectorized.AvxCompatibilityPadding].AsSpan());
-
-            // frame data
-            this.samplingAreaSize = new Size(frame.Width, frame.Height);
-            this.config = frame.GetConfiguration();
-
-            // conversion vector fallback data
-            if (!RgbToYCbCrConverterVectorized.IsSupported)
-            {
-                this.colorTables = RgbToYCbCrConverterLut.Create();
-            }
-            else
-            {
-                this.colorTables = default;
-            }
-        }
-
-        /// <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>
-        public void Convert(int x, int y, ref RowOctet<TPixel> currentRows)
-        {
-            YCbCrForwardConverter<TPixel>.LoadAndStretchEdges(currentRows, this.pixelSpan, new Point(x, y), SampleSize, this.samplingAreaSize);
-
-            PixelOperations<TPixel>.Instance.ToRgb24(this.config, this.pixelSpan, this.rgbSpan);
-
-            ref Block8x8F yBlock = ref this.Y;
-            ref Block8x8F cbBlock = ref this.Cb;
-            ref Block8x8F crBlock = ref this.Cr;
-
-            if (RgbToYCbCrConverterVectorized.IsSupported)
-            {
-                RgbToYCbCrConverterVectorized.Convert444(this.rgbSpan, ref yBlock, ref cbBlock, ref crBlock);
-            }
-            else
-            {
-                this.colorTables.Convert444(this.rgbSpan, ref yBlock, ref cbBlock, ref crBlock);
-            }
-        }
-    }
-}

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

@@ -1,61 +0,0 @@
-// Copyright (c) Six Labors.
-// Licensed under the Six Labors Split License.
-
-using System;
-using System.Runtime.CompilerServices;
-using System.Runtime.InteropServices;
-using SixLabors.ImageSharp.PixelFormats;
-
-namespace SixLabors.ImageSharp.Formats.Jpeg.Components.Encoder
-{
-    internal static class YCbCrForwardConverter<TPixel>
-        where TPixel : unmanaged, IPixel<TPixel>
-    {
-        public static void LoadAndStretchEdges(RowOctet<TPixel> source, Span<TPixel> dest, Point start, Size sampleSize, Size totalSize)
-        {
-            DebugGuard.MustBeBetweenOrEqualTo(start.X, 0, totalSize.Width - 1, nameof(start.X));
-            DebugGuard.MustBeBetweenOrEqualTo(start.Y, 0, totalSize.Height - 1, nameof(start.Y));
-
-            int width = Math.Min(sampleSize.Width, totalSize.Width - start.X);
-            int height = Math.Min(sampleSize.Height, totalSize.Height - start.Y);
-
-            uint byteWidth = (uint)(width * Unsafe.SizeOf<TPixel>());
-            int remainderXCount = sampleSize.Width - width;
-
-            ref byte blockStart = ref MemoryMarshal.GetReference(MemoryMarshal.Cast<TPixel, byte>(dest));
-            int rowSizeInBytes = sampleSize.Width * Unsafe.SizeOf<TPixel>();
-
-            for (int y = 0; y < height; y++)
-            {
-                Span<TPixel> row = source[y];
-
-                ref byte s = ref Unsafe.As<TPixel, byte>(ref row[start.X]);
-                ref byte d = ref Unsafe.Add(ref blockStart, y * rowSizeInBytes);
-
-                Unsafe.CopyBlock(ref d, ref s, byteWidth);
-
-                ref TPixel last = ref Unsafe.Add(ref Unsafe.As<byte, TPixel>(ref d), width - 1);
-
-                for (int x = 1; x <= remainderXCount; x++)
-                {
-                    Unsafe.Add(ref last, x) = last;
-                }
-            }
-
-            int remainderYCount = sampleSize.Height - height;
-
-            if (remainderYCount == 0)
-            {
-                return;
-            }
-
-            ref byte lastRowStart = ref Unsafe.Add(ref blockStart, (height - 1) * rowSizeInBytes);
-
-            for (int y = 1; y <= remainderYCount; y++)
-            {
-                ref byte remStart = ref Unsafe.Add(ref lastRowStart, rowSizeInBytes * y);
-                Unsafe.CopyBlock(ref remStart, ref lastRowStart, (uint)rowSizeInBytes);
-            }
-        }
-    }
-}

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

@@ -1,15 +1,13 @@
 // Copyright (c) Six Labors.
 // Licensed under the Six Labors Split License.
 
-namespace SixLabors.ImageSharp.Formats.Jpeg.Components.Decoder
+namespace SixLabors.ImageSharp.Formats.Jpeg.Components
 {
     /// <summary>
     /// Identifies the colorspace of a Jpeg image.
     /// </summary>
     internal enum JpegColorSpace
     {
-        Undefined = 0,
-
         /// <summary>
         /// Color space with 1 component.
         /// </summary>

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

@@ -176,7 +176,7 @@ namespace SixLabors.ImageSharp.Formats.Jpeg.Components
             return quality < 50 ? (5000 / quality) : (200 - (quality * 2));
         }
 
-        private static Block8x8F ScaleQuantizationTable(int scale, ReadOnlySpan<byte> unscaledTable)
+        public static Block8x8F ScaleQuantizationTable(int scale, ReadOnlySpan<byte> unscaledTable)
         {
             Block8x8F table = default;
             for (int j = 0; j < Block8x8F.Size; j++)
@@ -188,6 +188,19 @@ namespace SixLabors.ImageSharp.Formats.Jpeg.Components
             return table;
         }
 
+        public static Block8x8 ScaleQuantizationTable(int quality, Block8x8 unscaledTable)
+        {
+            int scale = QualityToScale(quality);
+            Block8x8 table = default;
+            for (int j = 0; j < Block8x8.Size; j++)
+            {
+                int x = ((unscaledTable[j] * scale) + 50) / 100;
+                table[j] = (short)(uint)Numerics.Clamp(x, 1, 255);
+            }
+
+            return table;
+        }
+
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
         public static Block8x8F ScaleLuminanceTable(int quality)
             => ScaleQuantizationTable(scale: QualityToScale(quality), LuminanceTable);

src/ImageSharp/Formats/Jpeg/IJpegDecoderOptions.cs

@@ -1,16 +0,0 @@
-// Copyright (c) Six Labors.
-// Licensed under the Six Labors Split License.
-
-namespace SixLabors.ImageSharp.Formats.Jpeg
-{
-    /// <summary>
-    /// Image decoder for generating an image out of a jpg stream.
-    /// </summary>
-    internal interface IJpegDecoderOptions
-    {
-        /// <summary>
-        /// Gets a value indicating whether the metadata should be ignored when the image is being decoded.
-        /// </summary>
-        bool IgnoreMetadata { get; }
-    }
-}

src/ImageSharp/Formats/Jpeg/IJpegEncoderOptions.cs

@@ -16,8 +16,17 @@ namespace SixLabors.ImageSharp.Formats.Jpeg
         public int? Quality { get; set; }
 
         /// <summary>
-        /// Gets the color type, that will be used to encode the image.
+        /// Gets or sets the component encoding mode.
         /// </summary>
-        JpegColorType? ColorType { get; }
+        /// <remarks>
+        /// Interleaved encoding mode encodes all color components in a single scan.
+        /// Non-interleaved encoding mode encodes each color component in a separate scan.
+        /// </remarks>
+        public bool? Interleaved { get; set; }
+
+        /// <summary>
+        /// Gets or sets jpeg color for encoding.
+        /// </summary>
+        public JpegEncodingColor? ColorType { get; set; }
     }
 }

src/ImageSharp/Formats/Jpeg/JpegDecoder.cs

@@ -3,77 +3,52 @@
 
 using System.IO;
 using System.Threading;
-using SixLabors.ImageSharp.IO;
-using SixLabors.ImageSharp.Memory;
 using SixLabors.ImageSharp.PixelFormats;
 
 namespace SixLabors.ImageSharp.Formats.Jpeg
 {
     /// <summary>
-    /// Image decoder for generating an image out of a jpg stream.
+    /// Decoder for generating an image out of a jpeg encoded stream.
     /// </summary>
-    public sealed class JpegDecoder : IImageDecoder, IJpegDecoderOptions, IImageInfoDetector
+    public sealed class JpegDecoder : IImageDecoderSpecialized<JpegDecoderOptions>
     {
         /// <inheritdoc/>
-        public bool IgnoreMetadata { get; set; }
+        IImageInfo IImageInfoDetector.Identify(DecoderOptions options, Stream stream, CancellationToken cancellationToken)
-
-        /// <inheritdoc/>
-        public Image<TPixel> Decode<TPixel>(Configuration configuration, Stream stream, CancellationToken cancellationToken)
-            where TPixel : unmanaged, IPixel<TPixel>
         {
+            Guard.NotNull(options, nameof(options));
             Guard.NotNull(stream, nameof(stream));
 
-            using var decoder = new JpegDecoderCore(configuration, this);
+            using JpegDecoderCore decoder = new(new() { GeneralOptions = options });
-            return decoder.Decode<TPixel>(configuration, stream, cancellationToken);
+            return decoder.Identify(options.Configuration, stream, cancellationToken);
         }
 
-        /// <inheritdoc />
+        /// <inheritdoc/>
-        public Image Decode(Configuration configuration, Stream stream, CancellationToken cancellationToken)
+        Image<TPixel> IImageDecoder.Decode<TPixel>(DecoderOptions options, Stream stream, CancellationToken cancellationToken)
-            => this.Decode<Rgb24>(configuration, stream, cancellationToken);
+             => ((IImageDecoderSpecialized<JpegDecoderOptions>)this).Decode<TPixel>(new() { GeneralOptions = options }, stream, cancellationToken);
 
-        /// <summary>
+        /// <inheritdoc/>
-        /// Placeholder summary.
+        Image IImageDecoder.Decode(DecoderOptions options, Stream stream, CancellationToken cancellationToken)
-        /// </summary>
+            => ((IImageDecoderSpecialized<JpegDecoderOptions>)this).Decode(new() { GeneralOptions = options }, stream, cancellationToken);
-        /// <param name="configuration">Placeholder2</param>
-        /// <param name="stream">Placeholder3</param>
-        /// <param name="targetSize">Placeholder4</param>
-        /// <param name="cancellationToken">Placeholder5</param>
-        /// <returns>Placeholder6</returns>
-        internal Image DecodeInto(Configuration configuration, Stream stream, Size targetSize, CancellationToken cancellationToken)
-            => this.DecodeInto<Rgb24>(configuration, stream, targetSize, cancellationToken);
 
-        /// <summary>
+        /// <inheritdoc/>
-        /// Decodes and downscales the image from the specified stream if possible.
+        Image<TPixel> IImageDecoderSpecialized<JpegDecoderOptions>.Decode<TPixel>(JpegDecoderOptions options, Stream stream, CancellationToken cancellationToken)
-        /// </summary>
-        /// <typeparam name="TPixel">The pixel format.</typeparam>
-        /// <param name="configuration">Configuration.</param>
-        /// <param name="stream">Stream.</param>
-        /// <param name="targetSize">Target size.</param>
-        /// <param name="cancellationToken">Cancellation token.</param>
-        internal Image<TPixel> DecodeInto<TPixel>(Configuration configuration, Stream stream, Size targetSize, CancellationToken cancellationToken)
-            where TPixel : unmanaged, IPixel<TPixel>
         {
+            Guard.NotNull(options, nameof(options));
             Guard.NotNull(stream, nameof(stream));
 
-            using var decoder = new JpegDecoderCore(configuration, this);
+            using JpegDecoderCore decoder = new(options);
-            using var bufferedReadStream = new BufferedReadStream(configuration, stream);
+            Image<TPixel> image = decoder.Decode<TPixel>(options.GeneralOptions.Configuration, stream, cancellationToken);
-            try
+
-            {
+            if (options.ResizeMode != JpegDecoderResizeMode.IdctOnly)
-                return decoder.DecodeInto<TPixel>(bufferedReadStream, targetSize, cancellationToken);
-            }
-            catch (InvalidMemoryOperationException ex)
             {
-                throw new InvalidImageContentException(((IImageDecoderInternals)decoder).Dimensions, ex);
+                ImageDecoderUtilities.Resize(options.GeneralOptions, image);
             }
+
+            return image;
         }
 
         /// <inheritdoc/>
-        public IImageInfo Identify(Configuration configuration, Stream stream, CancellationToken cancellationToken)
+        Image IImageDecoderSpecialized<JpegDecoderOptions>.Decode(JpegDecoderOptions options, Stream stream, CancellationToken cancellationToken)
-        {
+            => ((IImageDecoderSpecialized<JpegDecoderOptions>)this).Decode<Rgb24>(options, stream, cancellationToken);
-            Guard.NotNull(stream, nameof(stream));
-
-            using var decoder = new JpegDecoderCore(configuration, this);
-            return decoder.Identify(configuration, stream, cancellationToken);
-        }
     }
 }

src/ImageSharp/Formats/Jpeg/JpegDecoderCore.cs

@@ -116,31 +116,42 @@ namespace SixLabors.ImageSharp.Formats.Jpeg
         private int? resetInterval;
 
         /// <summary>
-        /// Initializes a new instance of the <see cref="JpegDecoderCore" /> class.
+        /// The global configuration.
         /// </summary>
-        /// <param name="configuration">The configuration.</param>
+        private readonly Configuration configuration;
-        /// <param name="options">The options.</param>
-        public JpegDecoderCore(Configuration configuration, IJpegDecoderOptions options)
-        {
-            this.Configuration = configuration ?? Configuration.Default;
-            this.IgnoreMetadata = options.IgnoreMetadata;
-        }
 
-        /// <inheritdoc />
+        /// <summary>
-        public Configuration Configuration { get; }
+        /// Whether to skip metadata during decode.
+        /// </summary>
+        private readonly bool skipMetadata;
 
         /// <summary>
-        /// Gets the frame
+        /// The jpeg specific resize options.
         /// </summary>
-        public JpegFrame Frame { get; private set; }
+        private readonly JpegDecoderResizeMode resizeMode;
+
+        /// <summary>
+        /// Initializes a new instance of the <see cref="JpegDecoderCore"/> class.
+        /// </summary>
+        /// <param name="options">The decoder options.</param>
+        public JpegDecoderCore(JpegDecoderOptions options)
+        {
+            this.Options = options.GeneralOptions;
+            this.resizeMode = options.ResizeMode;
+            this.configuration = options.GeneralOptions.Configuration;
+            this.skipMetadata = options.GeneralOptions.SkipMetadata;
+        }
+
+        /// <inheritdoc />
+        public DecoderOptions Options { get; }
 
         /// <inheritdoc/>
-        Size IImageDecoderInternals.Dimensions => this.Frame.PixelSize;
+        public Size Dimensions => this.Frame.PixelSize;
 
         /// <summary>
-        /// Gets a value indicating whether the metadata should be ignored when the image is being decoded.
+        /// Gets the frame
         /// </summary>
-        public bool IgnoreMetadata { get; }
+        public JpegFrame Frame { get; private set; }
 
         /// <summary>
         /// Gets the <see cref="ImageMetadata"/> decoded by this decoder instance.
@@ -201,48 +212,33 @@ namespace SixLabors.ImageSharp.Formats.Jpeg
         /// <inheritdoc/>
         public Image<TPixel> Decode<TPixel>(BufferedReadStream stream, CancellationToken cancellationToken)
             where TPixel : unmanaged, IPixel<TPixel>
-            => this.Decode<TPixel>(stream, targetSize: null, cancellationToken);
-
-        /// <inheritdoc/>
-        public IImageInfo Identify(BufferedReadStream stream, CancellationToken cancellationToken)
         {
-            this.ParseStream(stream, spectralConverter: null, cancellationToken);
+            using var spectralConverter = new SpectralConverter<TPixel>(this.configuration, this.resizeMode == JpegDecoderResizeMode.ScaleOnly ? null : this.Options.TargetSize);
+            this.ParseStream(stream, spectralConverter, cancellationToken);
             this.InitExifProfile();
             this.InitIccProfile();
             this.InitIptcProfile();
             this.InitXmpProfile();
             this.InitDerivedMetadataProperties();
 
-            Size pixelSize = this.Frame.PixelSize;
+            return new Image<TPixel>(
-            return new ImageInfo(new PixelTypeInfo(this.Frame.BitsPerPixel), pixelSize.Width, pixelSize.Height, this.Metadata);
+                this.configuration,
+                spectralConverter.GetPixelBuffer(cancellationToken),
+                this.Metadata);
         }
 
-        /// <summary>
+        /// <inheritdoc/>
-        /// Decodes and downscales the image from the specified stream if possible.
+        public IImageInfo Identify(BufferedReadStream stream, CancellationToken cancellationToken)
-        /// </summary>
-        /// <typeparam name="TPixel">The pixel format.</typeparam>
-        /// <param name="stream">Stream.</param>
-        /// <param name="targetSize">Target size.</param>
-        /// <param name="cancellationToken">Cancellation token.</param>
-        internal Image<TPixel> DecodeInto<TPixel>(BufferedReadStream stream, Size targetSize, CancellationToken cancellationToken)
-            where TPixel : unmanaged, IPixel<TPixel>
-            => this.Decode<TPixel>(stream, targetSize, cancellationToken);
-
-        private Image<TPixel> Decode<TPixel>(BufferedReadStream stream, Size? targetSize, CancellationToken cancellationToken)
-            where TPixel : unmanaged, IPixel<TPixel>
         {
-            using var spectralConverter = new SpectralConverter<TPixel>(this.Configuration, targetSize);
+            this.ParseStream(stream, spectralConverter: null, cancellationToken);
-            this.ParseStream(stream, spectralConverter, cancellationToken);
             this.InitExifProfile();
             this.InitIccProfile();
             this.InitIptcProfile();
             this.InitXmpProfile();
             this.InitDerivedMetadataProperties();
 
-            return new Image<TPixel>(
+            Size pixelSize = this.Frame.PixelSize;
-                this.Configuration,
+            return new ImageInfo(new PixelTypeInfo(this.Frame.BitsPerPixel), pixelSize.Width, pixelSize.Height, this.Metadata);
-                spectralConverter.GetPixelBuffer(cancellationToken),
-                this.Metadata);
         }
 
         /// <summary>
@@ -262,7 +258,7 @@ namespace SixLabors.ImageSharp.Formats.Jpeg
             }
 
             using var ms = new MemoryStream(tableBytes);
-            using var stream = new BufferedReadStream(this.Configuration, ms);
+            using var stream = new BufferedReadStream(this.configuration, ms);
 
             // Check for the Start Of Image marker.
             int bytesRead = stream.Read(this.markerBuffer, 0, 2);
@@ -504,6 +500,8 @@ namespace SixLabors.ImageSharp.Formats.Jpeg
                 // Read on.
                 fileMarker = FindNextFileMarker(stream);
             }
+
+            this.Metadata.GetJpegMetadata().Interleaved = this.Frame.Interleaved;
         }
 
         /// <inheritdoc/>
@@ -583,57 +581,58 @@ namespace SixLabors.ImageSharp.Formats.Jpeg
         /// Returns the jpeg color type based on the colorspace and subsampling used.
         /// </summary>
         /// <returns>Jpeg color type.</returns>
-        private JpegColorType DeduceJpegColorType()
+        private JpegEncodingColor DeduceJpegColorType()
         {
             switch (this.ColorSpace)
             {
                 case JpegColorSpace.Grayscale:
-                    return JpegColorType.Luminance;
+                    return JpegEncodingColor.Luminance;
 
                 case JpegColorSpace.RGB:
-                    return JpegColorType.Rgb;
+                    return JpegEncodingColor.Rgb;
 
                 case JpegColorSpace.YCbCr:
                     if (this.Frame.Components[0].HorizontalSamplingFactor == 1 && this.Frame.Components[0].VerticalSamplingFactor == 1 &&
                         this.Frame.Components[1].HorizontalSamplingFactor == 1 && this.Frame.Components[1].VerticalSamplingFactor == 1 &&
                         this.Frame.Components[2].HorizontalSamplingFactor == 1 && this.Frame.Components[2].VerticalSamplingFactor == 1)
                     {
-                        return JpegColorType.YCbCrRatio444;
+                        return JpegEncodingColor.YCbCrRatio444;
                     }
-                    else if (this.Frame.Components[0].HorizontalSamplingFactor == 2 && this.Frame.Components[0].VerticalSamplingFactor == 2 &&
+                    else if (this.Frame.Components[0].HorizontalSamplingFactor == 2 && this.Frame.Components[0].VerticalSamplingFactor == 1 &&
                         this.Frame.Components[1].HorizontalSamplingFactor == 1 && this.Frame.Components[1].VerticalSamplingFactor == 1 &&
                         this.Frame.Components[2].HorizontalSamplingFactor == 1 && this.Frame.Components[2].VerticalSamplingFactor == 1)
                     {
-                        return JpegColorType.YCbCrRatio420;
+                        return JpegEncodingColor.YCbCrRatio422;
                     }
-                    else if (this.Frame.Components[0].HorizontalSamplingFactor == 1 && this.Frame.Components[0].VerticalSamplingFactor == 1 &&
+                    else if (this.Frame.Components[0].HorizontalSamplingFactor == 2 && this.Frame.Components[0].VerticalSamplingFactor == 2 &&
-                        this.Frame.Components[1].HorizontalSamplingFactor == 1 && this.Frame.Components[1].VerticalSamplingFactor == 2 &&
+                        this.Frame.Components[1].HorizontalSamplingFactor == 1 && this.Frame.Components[1].VerticalSamplingFactor == 1 &&
-                        this.Frame.Components[2].HorizontalSamplingFactor == 1 && this.Frame.Components[2].VerticalSamplingFactor == 2)
+                        this.Frame.Components[2].HorizontalSamplingFactor == 1 && this.Frame.Components[2].VerticalSamplingFactor == 1)
                     {
-                        return JpegColorType.YCbCrRatio422;
+                        return JpegEncodingColor.YCbCrRatio420;
                     }
                     else if (this.Frame.Components[0].HorizontalSamplingFactor == 4 && this.Frame.Components[0].VerticalSamplingFactor == 1 &&
                              this.Frame.Components[1].HorizontalSamplingFactor == 1 && this.Frame.Components[1].VerticalSamplingFactor == 1 &&
                              this.Frame.Components[2].HorizontalSamplingFactor == 1 && this.Frame.Components[2].VerticalSamplingFactor == 1)
                     {
-                        return JpegColorType.YCbCrRatio411;
+                        return JpegEncodingColor.YCbCrRatio411;
                     }
                     else if (this.Frame.Components[0].HorizontalSamplingFactor == 4 && this.Frame.Components[0].VerticalSamplingFactor == 2 &&
                              this.Frame.Components[1].HorizontalSamplingFactor == 1 && this.Frame.Components[1].VerticalSamplingFactor == 1 &&
                              this.Frame.Components[2].HorizontalSamplingFactor == 1 && this.Frame.Components[2].VerticalSamplingFactor == 1)
                     {
-                        return JpegColorType.YCbCrRatio410;
+                        return JpegEncodingColor.YCbCrRatio410;
                     }
                     else
                     {
-                        return JpegColorType.YCbCrRatio420;
+                        return JpegEncodingColor.YCbCrRatio420;
                     }
 
                 case JpegColorSpace.Cmyk:
-                    return JpegColorType.Cmyk;
+                    return JpegEncodingColor.Cmyk;
-
+                case JpegColorSpace.Ycck:
+                    return JpegEncodingColor.Ycck;
                 default:
-                    return JpegColorType.YCbCrRatio420;
+                    return JpegEncodingColor.YCbCrRatio420;
             }
         }
 
@@ -775,7 +774,7 @@ namespace SixLabors.ImageSharp.Formats.Jpeg
         {
             const int ExifMarkerLength = 6;
             const int XmpMarkerLength = 29;
-            if (remaining < ExifMarkerLength || this.IgnoreMetadata)
+            if (remaining < ExifMarkerLength || this.skipMetadata)
             {
                 // Skip the application header length.
                 stream.Skip(remaining);
@@ -813,7 +812,7 @@ namespace SixLabors.ImageSharp.Formats.Jpeg
             if (ProfileResolver.IsProfile(this.temp, ProfileResolver.XmpMarker[..ExifMarkerLength]))
             {
                 const int remainingXmpMarkerBytes = XmpMarkerLength - ExifMarkerLength;
-                if (remaining < remainingXmpMarkerBytes || this.IgnoreMetadata)
+                if (remaining < remainingXmpMarkerBytes || this.skipMetadata)
                 {
                     // Skip the application header length.
                     stream.Skip(remaining);
@@ -855,7 +854,7 @@ namespace SixLabors.ImageSharp.Formats.Jpeg
         {
             // Length is 14 though we only need to check 12.
             const int Icclength = 14;
-            if (remaining < Icclength || this.IgnoreMetadata)
+            if (remaining < Icclength || this.skipMetadata)
             {
                 stream.Skip(remaining);
                 return;
@@ -896,7 +895,7 @@ namespace SixLabors.ImageSharp.Formats.Jpeg
         /// <param name="remaining">The remaining bytes in the segment block.</param>
         private void ProcessApp13Marker(BufferedReadStream stream, int remaining)
         {
-            if (remaining < ProfileResolver.AdobePhotoshopApp13Marker.Length || this.IgnoreMetadata)
+            if (remaining < ProfileResolver.AdobePhotoshopApp13Marker.Length || this.skipMetadata)
             {
                 stream.Skip(remaining);
                 return;
@@ -1216,6 +1215,7 @@ namespace SixLabors.ImageSharp.Formats.Jpeg
             }
 
             this.Frame = new JpegFrame(frameMarker, precision, frameWidth, frameHeight, componentCount);
+            this.Metadata.GetJpegMetadata().Progressive = this.Frame.Progressive;
 
             remaining -= length;
 
@@ -1279,8 +1279,8 @@ namespace SixLabors.ImageSharp.Formats.Jpeg
                 }
 
                 IJpegComponent component = decodingComponentType is ComponentType.Huffman ?
-                            new JpegComponent(this.Configuration.MemoryAllocator, this.Frame, componentId, h, v, quantTableIndex, i) :
+                            new JpegComponent(this.configuration.MemoryAllocator, this.Frame, componentId, h, v, quantTableIndex, i) :
-                            new ArithmeticDecodingComponent(this.Configuration.MemoryAllocator, this.Frame, componentId, h, v, quantTableIndex, i);
+                            new ArithmeticDecodingComponent(this.configuration.MemoryAllocator, this.Frame, componentId, h, v, quantTableIndex, i);
 
                 this.Frame.Components[i] = (JpegComponent)component;
                 this.Frame.ComponentIds[i] = componentId;
@@ -1319,7 +1319,7 @@ namespace SixLabors.ImageSharp.Formats.Jpeg
             }
 
             int length = remaining;
-            using (IMemoryOwner<byte> buffer = this.Configuration.MemoryAllocator.Allocate<byte>(totalBufferSize))
+            using (IMemoryOwner<byte> buffer = this.configuration.MemoryAllocator.Allocate<byte>(totalBufferSize))
             {
                 Span<byte> bufferSpan = buffer.GetSpan();
                 Span<byte> huffmanLengthsSpan = bufferSpan[..codeLengthsByteSize];
@@ -1426,7 +1426,7 @@ namespace SixLabors.ImageSharp.Formats.Jpeg
             // selectorsCount*2 bytes: component index + huffman tables indices
             stream.Read(this.temp, 0, selectorsBytes);
 
-            this.Frame.MultiScan = this.Frame.ComponentCount != selectorsCount;
+            this.Frame.Interleaved = this.Frame.ComponentCount == selectorsCount;
             for (int i = 0; i < selectorsBytes; i += 2)
             {
                 // 1 byte: Component id

src/ImageSharp/Formats/Jpeg/JpegDecoderOptions.cs

@@ -0,0 +1,19 @@
+// Copyright (c) Six Labors.
+// Licensed under the Six Labors Split License.
+
+namespace SixLabors.ImageSharp.Formats.Jpeg
+{
+    /// <summary>
+    /// Configuration options for decoding Jpeg images.
+    /// </summary>
+    public sealed class JpegDecoderOptions : ISpecializedDecoderOptions
+    {
+        /// <summary>
+        /// Gets or sets the resize mode.
+        /// </summary>
+        public JpegDecoderResizeMode ResizeMode { get; set; }
+
+        /// <inheritdoc/>
+        public DecoderOptions GeneralOptions { get; set; } = new();
+    }
+}

src/ImageSharp/Formats/Jpeg/JpegDecoderResizeMode.cs

@@ -0,0 +1,29 @@
+// Copyright (c) Six Labors.
+// Licensed under the Six Labors Split License.
+
+using SixLabors.ImageSharp.Processing;
+
+namespace SixLabors.ImageSharp.Formats.Jpeg
+{
+    /// <summary>
+    /// Provides enumeration for resize modes taken during decoding.
+    /// Applicable only when <see cref="DecoderOptions.TargetSize"/> has a value.
+    /// </summary>
+    public enum JpegDecoderResizeMode
+    {
+        /// <summary>
+        /// Both <see cref="IdctOnly"/> and <see cref="ScaleOnly"/>.
+        /// </summary>
+        Combined,
+
+        /// <summary>
+        /// IDCT-only to nearest block scale. Similar in output to <see cref="KnownResamplers.Box"/>.
+        /// </summary>
+        IdctOnly,
+
+        /// <summary>
+        /// Opt-out the IDCT part and only Resize. Can be useful in case of quality concerns.
+        /// </summary>
+        ScaleOnly
+    }
+}

src/ImageSharp/Formats/Jpeg/JpegEncoder.cs

@@ -1,6 +1,7 @@
 // Copyright (c) Six Labors.
 // Licensed under the Six Labors Split License.
 
+using System;
 using System.IO;
 using System.Threading;
 using System.Threading.Tasks;
@@ -13,11 +14,31 @@ namespace SixLabors.ImageSharp.Formats.Jpeg
     /// </summary>
     public sealed class JpegEncoder : IImageEncoder, IJpegEncoderOptions
     {
+        /// <summary>
+        /// Backing field for <see cref="Quality"/>.
+        /// </summary>
+        private int? quality;
+
+        /// <inheritdoc/>
+        public int? Quality
+        {
+            get => this.quality;
+            set
+            {
+                if (value is < 1 or > 100)
+                {
+                    throw new ArgumentException("Quality factor must be in [1..100] range.");
+                }
+
+                this.quality = value;
+            }
+        }
+
         /// <inheritdoc/>
-        public int? Quality { get; set; }
+        public bool? Interleaved { get; set; }
 
         /// <inheritdoc/>
-        public JpegColorType? ColorType { get; set; }
+        public JpegEncodingColor? ColorType { get; set; }
 
         /// <summary>
         /// Encodes the image to the specified stream from the <see cref="Image{TPixel}"/>.

src/ImageSharp/Formats/Jpeg/JpegEncoderCore.FrameConfig.cs

@@ -0,0 +1,196 @@
+// Copyright (c) Six Labors.
+// Licensed under the Six Labors Split License.
+
+using SixLabors.ImageSharp.Formats.Jpeg.Components;
+using SixLabors.ImageSharp.Formats.Jpeg.Components.Encoder;
+
+namespace SixLabors.ImageSharp.Formats.Jpeg
+{
+    /// <summary>
+    /// Image encoder for writing an image to a stream as a jpeg.
+    /// </summary>
+    internal sealed unsafe partial class JpegEncoderCore
+    {
+        private static JpegFrameConfig[] CreateFrameConfigs()
+        {
+            var defaultLuminanceHuffmanDC = new JpegHuffmanTableConfig(@class: 0, destIndex: 0, HuffmanSpec.LuminanceDC);
+            var defaultLuminanceHuffmanAC = new JpegHuffmanTableConfig(@class: 1, destIndex: 0, HuffmanSpec.LuminanceAC);
+            var defaultChrominanceHuffmanDC = new JpegHuffmanTableConfig(@class: 0, destIndex: 1, HuffmanSpec.ChrominanceDC);
+            var defaultChrominanceHuffmanAC = new JpegHuffmanTableConfig(@class: 1, destIndex: 1, HuffmanSpec.ChrominanceAC);
+
+            var defaultLuminanceQuantTable = new JpegQuantizationTableConfig(0, Quantization.LuminanceTable);
+            var defaultChrominanceQuantTable = new JpegQuantizationTableConfig(1, Quantization.ChrominanceTable);
+
+            var yCbCrHuffmanConfigs = new JpegHuffmanTableConfig[]
+            {
+                defaultLuminanceHuffmanDC,
+                defaultLuminanceHuffmanAC,
+                defaultChrominanceHuffmanDC,
+                defaultChrominanceHuffmanAC,
+            };
+
+            var yCbCrQuantTableConfigs = new JpegQuantizationTableConfig[]
+            {
+                defaultLuminanceQuantTable,
+                defaultChrominanceQuantTable,
+            };
+
+            return new JpegFrameConfig[]
+            {
+                // YCbCr 4:4:4
+                new JpegFrameConfig(
+                    JpegColorSpace.YCbCr,
+                    JpegEncodingColor.YCbCrRatio444,
+                    new JpegComponentConfig[]
+                    {
+                        new JpegComponentConfig(id: 1, hsf: 1, vsf: 1, quantIndex: 0, dcIndex: 0, acIndex: 0),
+                        new JpegComponentConfig(id: 2, hsf: 1, vsf: 1, quantIndex: 1, dcIndex: 1, acIndex: 1),
+                        new JpegComponentConfig(id: 3, hsf: 1, vsf: 1, quantIndex: 1, dcIndex: 1, acIndex: 1),
+                    },
+                    yCbCrHuffmanConfigs,
+                    yCbCrQuantTableConfigs),
+
+                // YCbCr 4:2:2
+                new JpegFrameConfig(
+                    JpegColorSpace.YCbCr,
+                    JpegEncodingColor.YCbCrRatio422,
+                    new JpegComponentConfig[]
+                    {
+                        new JpegComponentConfig(id: 1, hsf: 2, vsf: 1, quantIndex: 0, dcIndex: 0, acIndex: 0),
+                        new JpegComponentConfig(id: 2, hsf: 1, vsf: 1, quantIndex: 1, dcIndex: 1, acIndex: 1),
+                        new JpegComponentConfig(id: 3, hsf: 1, vsf: 1, quantIndex: 1, dcIndex: 1, acIndex: 1),
+                    },
+                    yCbCrHuffmanConfigs,
+                    yCbCrQuantTableConfigs),
+
+                // YCbCr 4:2:0
+                new JpegFrameConfig(
+                    JpegColorSpace.YCbCr,
+                    JpegEncodingColor.YCbCrRatio420,
+                    new JpegComponentConfig[]
+                    {
+                        new JpegComponentConfig(id: 1, hsf: 2, vsf: 2, quantIndex: 0, dcIndex: 0, acIndex: 0),
+                        new JpegComponentConfig(id: 2, hsf: 1, vsf: 1, quantIndex: 1, dcIndex: 1, acIndex: 1),
+                        new JpegComponentConfig(id: 3, hsf: 1, vsf: 1, quantIndex: 1, dcIndex: 1, acIndex: 1),
+                    },
+                    yCbCrHuffmanConfigs,
+                    yCbCrQuantTableConfigs),
+
+                // YCbCr 4:1:1
+                new JpegFrameConfig(
+                    JpegColorSpace.YCbCr,
+                    JpegEncodingColor.YCbCrRatio411,
+                    new JpegComponentConfig[]
+                    {
+                        new JpegComponentConfig(id: 1, hsf: 4, vsf: 1, quantIndex: 0, dcIndex: 0, acIndex: 0),
+                        new JpegComponentConfig(id: 2, hsf: 1, vsf: 1, quantIndex: 1, dcIndex: 1, acIndex: 1),
+                        new JpegComponentConfig(id: 3, hsf: 1, vsf: 1, quantIndex: 1, dcIndex: 1, acIndex: 1),
+                    },
+                    yCbCrHuffmanConfigs,
+                    yCbCrQuantTableConfigs),
+
+                // YCbCr 4:1:0
+                new JpegFrameConfig(
+                    JpegColorSpace.YCbCr,
+                    JpegEncodingColor.YCbCrRatio410,
+                    new JpegComponentConfig[]
+                    {
+                        new JpegComponentConfig(id: 1, hsf: 4, vsf: 2, quantIndex: 0, dcIndex: 0, acIndex: 0),
+                        new JpegComponentConfig(id: 2, hsf: 1, vsf: 1, quantIndex: 1, dcIndex: 1, acIndex: 1),
+                        new JpegComponentConfig(id: 3, hsf: 1, vsf: 1, quantIndex: 1, dcIndex: 1, acIndex: 1),
+                    },
+                    yCbCrHuffmanConfigs,
+                    yCbCrQuantTableConfigs),
+
+                // Luminance
+                new JpegFrameConfig(
+                    JpegColorSpace.Grayscale,
+                    JpegEncodingColor.Luminance,
+                    new JpegComponentConfig[]
+                    {
+                        new JpegComponentConfig(id: 0, hsf: 1, vsf: 1, quantIndex: 0, dcIndex: 0, acIndex: 0),
+                    },
+                    new JpegHuffmanTableConfig[]
+                    {
+                        defaultLuminanceHuffmanDC,
+                        defaultLuminanceHuffmanAC
+                    },
+                    new JpegQuantizationTableConfig[]
+                    {
+                        defaultLuminanceQuantTable
+                    }),
+
+                // Rgb
+                new JpegFrameConfig(
+                    JpegColorSpace.RGB,
+                    JpegEncodingColor.Rgb,
+                    new JpegComponentConfig[]
+                    {
+                        new JpegComponentConfig(id: 82, hsf: 1, vsf: 1, quantIndex: 0, dcIndex: 0, acIndex: 0),
+                        new JpegComponentConfig(id: 71, hsf: 1, vsf: 1, quantIndex: 0, dcIndex: 0, acIndex: 0),
+                        new JpegComponentConfig(id: 66, hsf: 1, vsf: 1, quantIndex: 0, dcIndex: 0, acIndex: 0),
+                    },
+                    new JpegHuffmanTableConfig[]
+                    {
+                        defaultLuminanceHuffmanDC,
+                        defaultLuminanceHuffmanAC
+                    },
+                    new JpegQuantizationTableConfig[]
+                    {
+                        defaultLuminanceQuantTable
+                    })
+                {
+                    AdobeColorTransformMarkerFlag = JpegConstants.Adobe.ColorTransformUnknown
+                },
+
+                // Cmyk
+                new JpegFrameConfig(
+                    JpegColorSpace.Cmyk,
+                    JpegEncodingColor.Cmyk,
+                    new JpegComponentConfig[]
+                    {
+                        new JpegComponentConfig(id: 1, hsf: 1, vsf: 1, quantIndex: 0, dcIndex: 0, acIndex: 0),
+                        new JpegComponentConfig(id: 2, hsf: 1, vsf: 1, quantIndex: 0, dcIndex: 0, acIndex: 0),
+                        new JpegComponentConfig(id: 3, hsf: 1, vsf: 1, quantIndex: 0, dcIndex: 0, acIndex: 0),
+                        new JpegComponentConfig(id: 4, hsf: 1, vsf: 1, quantIndex: 0, dcIndex: 0, acIndex: 0),
+                    },
+                    new JpegHuffmanTableConfig[]
+                    {
+                        defaultLuminanceHuffmanDC,
+                        defaultLuminanceHuffmanAC
+                    },
+                    new JpegQuantizationTableConfig[]
+                    {
+                        defaultLuminanceQuantTable
+                    })
+                {
+                    AdobeColorTransformMarkerFlag = JpegConstants.Adobe.ColorTransformUnknown,
+                },
+
+                // YccK
+                new JpegFrameConfig(
+                    JpegColorSpace.Ycck,
+                    JpegEncodingColor.Ycck,
+                    new JpegComponentConfig[]
+                    {
+                        new JpegComponentConfig(id: 1, hsf: 1, vsf: 1, quantIndex: 0, dcIndex: 0, acIndex: 0),
+                        new JpegComponentConfig(id: 2, hsf: 1, vsf: 1, quantIndex: 0, dcIndex: 0, acIndex: 0),
+                        new JpegComponentConfig(id: 3, hsf: 1, vsf: 1, quantIndex: 0, dcIndex: 0, acIndex: 0),
+                        new JpegComponentConfig(id: 4, hsf: 1, vsf: 1, quantIndex: 0, dcIndex: 0, acIndex: 0),
+                    },
+                    new JpegHuffmanTableConfig[]
+                    {
+                        defaultLuminanceHuffmanDC,
+                        defaultLuminanceHuffmanAC
+                    },
+                    new JpegQuantizationTableConfig[]
+                    {
+                        defaultLuminanceQuantTable
+                    })
+                {
+                    AdobeColorTransformMarkerFlag = JpegConstants.Adobe.ColorTransformYcck,
+                },
+            };
+        }
+    }
+}

src/ImageSharp/Formats/Jpeg/JpegEncoderCore.cs

@@ -8,7 +8,6 @@ using System.Linq;
 using System.Threading;
 using SixLabors.ImageSharp.Common.Helpers;
 using SixLabors.ImageSharp.Formats.Jpeg.Components;
-using SixLabors.ImageSharp.Formats.Jpeg.Components.Decoder;
 using SixLabors.ImageSharp.Formats.Jpeg.Components.Encoder;
 using SixLabors.ImageSharp.Metadata;
 using SixLabors.ImageSharp.Metadata.Profiles.Exif;
@@ -22,27 +21,19 @@ namespace SixLabors.ImageSharp.Formats.Jpeg
     /// <summary>
     /// Image encoder for writing an image to a stream as a jpeg.
     /// </summary>
-    internal sealed unsafe class JpegEncoderCore : IImageEncoderInternals
+    internal sealed unsafe partial class JpegEncoderCore : IImageEncoderInternals
     {
         /// <summary>
-        /// The number of quantization tables.
+        /// The available encodable frame configs.
         /// </summary>
-        private const int QuantizationTableCount = 2;
+        private static readonly JpegFrameConfig[] FrameConfigs = CreateFrameConfigs();
 
         /// <summary>
         /// A scratch buffer to reduce allocations.
         /// </summary>
         private readonly byte[] buffer = new byte[20];
 
-        /// <summary>
+        private readonly IJpegEncoderOptions options;
-        /// The quality, that will be used to encode the image.
-        /// </summary>
-        private readonly int? quality;
-
-        /// <summary>
-        /// Gets or sets the colorspace to use.
-        /// </summary>
-        private JpegColorType? colorType;
 
         /// <summary>
         /// The output stream. All attempted writes after the first error become no-ops.
@@ -54,14 +45,9 @@ namespace SixLabors.ImageSharp.Formats.Jpeg
         /// </summary>
         /// <param name="options">The options.</param>
         public JpegEncoderCore(IJpegEncoderOptions options)
-        {
+            => this.options = options;
-            this.quality = options.Quality;
 
-            if (IsSupportedColorType(options.ColorType))
+        public Block8x8F[] QuantizationTables { get; } = new Block8x8F[4];
-            {
-                this.colorType = options.ColorType;
-            }
-        }
 
         /// <summary>
         /// Encode writes the image to the jpeg baseline format with the given options.
@@ -84,72 +70,45 @@ namespace SixLabors.ImageSharp.Formats.Jpeg
             cancellationToken.ThrowIfCancellationRequested();
 
             this.outputStream = stream;
+
             ImageMetadata metadata = image.Metadata;
             JpegMetadata jpegMetadata = metadata.GetJpegMetadata();
+            JpegFrameConfig frameConfig = this.GetFrameConfig(jpegMetadata);
 
-            // If the color type was not specified by the user, preserve the color type of the input image.
+            bool interleaved = this.options.Interleaved ?? jpegMetadata.Interleaved ?? true;
-            if (!this.colorType.HasValue)
+            using var frame = new JpegFrame(image, frameConfig, interleaved);
-            {
-                this.colorType = GetFallbackColorType(image);
-            }
-
-            // Compute number of components based on color type in options.
-            int componentCount = (this.colorType == JpegColorType.Luminance) ? 1 : 3;
-            ReadOnlySpan<byte> componentIds = this.GetComponentIds();
-
-            // TODO: Right now encoder writes both quantization tables for grayscale images - we shouldn't do that
-            // Initialize the quantization tables.
-            this.InitQuantizationTables(componentCount, jpegMetadata, out Block8x8F luminanceQuantTable, out Block8x8F chrominanceQuantTable);
 
             // Write the Start Of Image marker.
             this.WriteStartOfImage();
 
-            // Do not write APP0 marker for RGB colorspace.
+            // Write APP0 marker
-            if (this.colorType != JpegColorType.Rgb)
+            if (frameConfig.AdobeColorTransformMarkerFlag is null)
             {
                 this.WriteJfifApplicationHeader(metadata);
             }
 
-            // Write Exif, XMP, ICC and IPTC profiles
+            // Write APP14 marker with adobe color extension
-            this.WriteProfiles(metadata);
+            else
-
-            if (this.colorType == JpegColorType.Rgb)
             {
-                // Write App14 marker to indicate RGB color space.
+                this.WriteApp14Marker(frameConfig.AdobeColorTransformMarkerFlag.Value);
-                this.WriteApp14Marker();
             }
 
-            // Write the quantization tables.
+            // Write Exif, XMP, ICC and IPTC profiles
-            this.WriteDefineQuantizationTables(ref luminanceQuantTable, ref chrominanceQuantTable);
+            this.WriteProfiles(metadata);
 
             // Write the image dimensions.
-            this.WriteStartOfFrame(image.Width, image.Height, componentCount, componentIds);
+            this.WriteStartOfFrame(image.Width, image.Height, frameConfig);
 
             // Write the Huffman tables.
-            this.WriteDefineHuffmanTables(componentCount);
+            var scanEncoder = new HuffmanScanEncoder(frame.BlocksPerMcu, stream);
+            this.WriteDefineHuffmanTables(frameConfig.HuffmanTables, scanEncoder);
 
-            // Write the scan header.
+            // Write the quantization tables.
-            this.WriteStartOfScan(componentCount, componentIds);
+            this.WriteDefineQuantizationTables(frameConfig.QuantizationTables, this.options.Quality, jpegMetadata);
 
-            // Write the scan compressed data.
+            // Write scans with actual pixel data
-            switch (this.colorType)
+            using var spectralConverter = new SpectralConverter<TPixel>(frame, image, this.QuantizationTables);
-            {
+            this.WriteHuffmanScans(frame, frameConfig, spectralConverter, scanEncoder, cancellationToken);
-                case JpegColorType.YCbCrRatio444:
-                    new HuffmanScanEncoder(3, stream).Encode444(image, ref luminanceQuantTable, ref chrominanceQuantTable, cancellationToken);
-                    break;
-                case JpegColorType.YCbCrRatio420:
-                    new HuffmanScanEncoder(6, stream).Encode420(image, ref luminanceQuantTable, ref chrominanceQuantTable, cancellationToken);
-                    break;
-                case JpegColorType.Luminance:
-                    new HuffmanScanEncoder(1, stream).EncodeGrayscale(image, ref luminanceQuantTable, cancellationToken);
-                    break;
-                case JpegColorType.Rgb:
-                    new HuffmanScanEncoder(3, stream).EncodeRgb(image, ref luminanceQuantTable, cancellationToken);
-                    break;
-                default:
-                    // all other non-supported color types are checked at the start of this method
-                    break;
-            }
 
             // Write the End Of Image marker.
             this.WriteEndOfImageMarker();
@@ -157,75 +116,6 @@ namespace SixLabors.ImageSharp.Formats.Jpeg
             stream.Flush();
         }
 
-        /// <summary>
-        /// If color type was not set, set it based on the given image.
-        /// Note, if there is no metadata and the image has multiple components this method
-        /// returns <see langword="null"/> defering the field assignment
-        /// to <see cref="InitQuantizationTables(int, JpegMetadata, out Block8x8F, out Block8x8F)"/>.
-        /// </summary>
-        private static JpegColorType? GetFallbackColorType<TPixel>(Image<TPixel> image)
-            where TPixel : unmanaged, IPixel<TPixel>
-        {
-            // First inspect the image metadata.
-            JpegColorType? colorType = null;
-            JpegMetadata metadata = image.Metadata.GetJpegMetadata();
-            if (IsSupportedColorType(metadata.ColorType))
-            {
-                return metadata.ColorType;
-            }
-
-            // Secondly, inspect the pixel type.
-            // TODO: PixelTypeInfo should contain a component count!
-            bool isGrayscale =
-                typeof(TPixel) == typeof(L8) || typeof(TPixel) == typeof(L16) ||
-                typeof(TPixel) == typeof(La16) || typeof(TPixel) == typeof(La32);
-
-            // We don't set multi-component color types here since we can set it based upon
-            // the quality in InitQuantizationTables.
-            if (isGrayscale)
-            {
-                colorType = JpegColorType.Luminance;
-            }
-
-            return colorType;
-        }
-
-        /// <summary>
-        /// Returns true, if the color type is supported by the encoder.
-        /// </summary>
-        /// <param name="colorType">The color type.</param>
-        /// <returns>true, if color type is supported.</returns>
-        private static bool IsSupportedColorType(JpegColorType? colorType)
-            => colorType == JpegColorType.YCbCrRatio444
-            || colorType == JpegColorType.YCbCrRatio420
-            || colorType == JpegColorType.Luminance
-            || colorType == JpegColorType.Rgb;
-
-        /// <summary>
-        /// Gets the component ids.
-        /// For color space RGB this will be RGB as ASCII, otherwise 1, 2, 3.
-        /// </summary>
-        /// <returns>The component Ids.</returns>
-        private ReadOnlySpan<byte> GetComponentIds() => this.colorType == JpegColorType.Rgb
-                ? new ReadOnlySpan<byte>(new byte[] { 82, 71, 66 })
-                : new ReadOnlySpan<byte>(new byte[] { 1, 2, 3 });
-
-        /// <summary>
-        /// Writes data to "Define Quantization Tables" block for QuantIndex.
-        /// </summary>
-        /// <param name="dqt">The "Define Quantization Tables" block.</param>
-        /// <param name="offset">Offset in "Define Quantization Tables" block.</param>
-        /// <param name="i">The quantization index.</param>
-        /// <param name="quant">The quantization table to copy data from.</param>
-        private static void WriteDataToDqt(byte[] dqt, ref int offset, QuantIndex i, ref Block8x8F quant)
-        {
-            dqt[offset++] = (byte)i;
-            for (int j = 0; j < Block8x8F.Size; j++)
-            {
-                dqt[offset++] = (byte)quant[ZigZag.ZigZagOrder[j]];
-            }
-        }
-
         /// <summary>
         /// Write the start of image marker.
         /// </summary>
@@ -286,71 +176,40 @@ namespace SixLabors.ImageSharp.Formats.Jpeg
         /// <summary>
         /// Writes the Define Huffman Table marker and tables.
         /// </summary>
-        /// <param name="componentCount">The number of components to write.</param>
+        private void WriteDefineHuffmanTables(JpegHuffmanTableConfig[] tableConfigs, HuffmanScanEncoder scanEncoder)
-        private void WriteDefineHuffmanTables(int componentCount)
         {
-            // This uses a C#'s compiler optimization that refers to the static data segment of the assembly,
+            if (tableConfigs is null)
-            // and doesn't incur any allocation at all.
-            // Table identifiers.
-            ReadOnlySpan<byte> headers = new byte[]
             {
-                0x00,
+                throw new ArgumentNullException(nameof(tableConfigs));
-                0x10,
+            }
-                0x01,
-                0x11
-            };
 
             int markerlen = 2;
-            HuffmanSpec[] specs = HuffmanSpec.TheHuffmanSpecs;
 
-            if (componentCount == 1)
+            for (int i = 0; i < tableConfigs.Length; i++)
             {
-                // Drop the Chrominance tables.
+                markerlen += 1 + 16 + tableConfigs[i].Table.Values.Length;
-                specs = new[] { HuffmanSpec.TheHuffmanSpecs[0], HuffmanSpec.TheHuffmanSpecs[1] };
-            }
-
-            for (int i = 0; i < specs.Length; i++)
-            {
-                ref HuffmanSpec s = ref specs[i];
-                markerlen += 1 + 16 + s.Values.Length;
             }
 
             this.WriteMarkerHeader(JpegConstants.Markers.DHT, markerlen);
-            for (int i = 0; i < specs.Length; i++)
+            for (int i = 0; i < tableConfigs.Length; i++)
             {
-                this.outputStream.WriteByte(headers[i]);
+                JpegHuffmanTableConfig tableConfig = tableConfigs[i];
-                this.outputStream.Write(specs[i].Count);
-                this.outputStream.Write(specs[i].Values);
-            }
-        }
 
-        /// <summary>
+                int header = (tableConfig.Class << 4) | tableConfig.DestinationIndex;
-        /// Writes the Define Quantization Marker and tables.
+                this.outputStream.WriteByte((byte)header);
-        /// </summary>
+                this.outputStream.Write(tableConfig.Table.Count);
-        private void WriteDefineQuantizationTables(ref Block8x8F luminanceQuantTable, ref Block8x8F chrominanceQuantTable)
+                this.outputStream.Write(tableConfig.Table.Values);
-        {
-            // Marker + quantization table lengths.
-            int markerlen = 2 + (QuantizationTableCount * (1 + Block8x8F.Size));
-            this.WriteMarkerHeader(JpegConstants.Markers.DQT, markerlen);
-
-            // Loop through and collect the tables as one array.
-            // This allows us to reduce the number of writes to the stream.
-            int dqtCount = (QuantizationTableCount * Block8x8F.Size) + QuantizationTableCount;
-            byte[] dqt = new byte[dqtCount];
-            int offset = 0;
-
-            WriteDataToDqt(dqt, ref offset, QuantIndex.Luminance, ref luminanceQuantTable);
-            WriteDataToDqt(dqt, ref offset, QuantIndex.Chrominance, ref chrominanceQuantTable);
 
-            this.outputStream.Write(dqt, 0, dqtCount);
+                scanEncoder.BuildHuffmanTable(tableConfig);
+            }
         }
 
         /// <summary>
         /// Writes the APP14 marker to indicate the image is in RGB color space.
         /// </summary>
-        private void WriteApp14Marker()
+        private void WriteApp14Marker(byte colorTransform)
         {
-            this.WriteMarkerHeader(JpegConstants.Markers.APP14, 2 + AdobeMarker.Length);
+            this.WriteMarkerHeader(JpegConstants.Markers.APP14, 2 + Components.Decoder.AdobeMarker.Length);
 
             // Identifier: ASCII "Adobe".
             this.buffer[0] = 0x41;
@@ -368,8 +227,8 @@ namespace SixLabors.ImageSharp.Formats.Jpeg
             // Flags1
             BinaryPrimitives.WriteInt16BigEndian(this.buffer.AsSpan(9, 2), 0);
 
-            // Transform byte, 0 in combination with three components means the image is in RGB colorspace.
+            // Color transform byte
-            this.buffer[11] = 0;
+            this.buffer[11] = colorTransform;
 
             this.outputStream.Write(this.buffer.AsSpan(0, 12));
         }
@@ -385,8 +244,8 @@ namespace SixLabors.ImageSharp.Formats.Jpeg
                 return;
             }
 
-            const int MaxBytesApp1 = 65533; // 64k - 2 padding bytes
+            const int maxBytesApp1 = 65533; // 64k - 2 padding bytes
-            const int MaxBytesWithExifId = 65527; // Max - 6 bytes for EXIF header.
+            const int maxBytesWithExifId = 65527; // Max - 6 bytes for EXIF header.
 
             byte[] data = exifProfile.ToByteArray();
 
@@ -396,27 +255,27 @@ namespace SixLabors.ImageSharp.Formats.Jpeg
             }
 
             // We can write up to a maximum of 64 data to the initial marker so calculate boundaries.
-            int exifMarkerLength = ProfileResolver.ExifMarker.Length;
+            int exifMarkerLength = Components.Decoder.ProfileResolver.ExifMarker.Length;
             int remaining = exifMarkerLength + data.Length;
-            int bytesToWrite = remaining > MaxBytesApp1 ? MaxBytesApp1 : remaining;
+            int bytesToWrite = remaining > maxBytesApp1 ? maxBytesApp1 : remaining;
             int app1Length = bytesToWrite + 2;
 
             // Write the app marker, EXIF marker, and data
             this.WriteApp1Header(app1Length);
-            this.outputStream.Write(ProfileResolver.ExifMarker);
+            this.outputStream.Write(Components.Decoder.ProfileResolver.ExifMarker);
             this.outputStream.Write(data, 0, bytesToWrite - exifMarkerLength);
             remaining -= bytesToWrite;
 
             // If the exif data exceeds 64K, write it in multiple APP1 Markers
-            for (int idx = MaxBytesWithExifId; idx < data.Length; idx += MaxBytesWithExifId)
+            for (int idx = maxBytesWithExifId; idx < data.Length; idx += maxBytesWithExifId)
             {
-                bytesToWrite = remaining > MaxBytesWithExifId ? MaxBytesWithExifId : remaining;
+                bytesToWrite = remaining > maxBytesWithExifId ? maxBytesWithExifId : remaining;
                 app1Length = bytesToWrite + 2 + exifMarkerLength;
 
                 this.WriteApp1Header(app1Length);
 
                 // Write Exif00 marker
-                this.outputStream.Write(ProfileResolver.ExifMarker);
+                this.outputStream.Write(Components.Decoder.ProfileResolver.ExifMarker);
 
                 // Write the exif data
                 this.outputStream.Write(data, idx, bytesToWrite);
@@ -434,7 +293,7 @@ namespace SixLabors.ImageSharp.Formats.Jpeg
         /// </exception>
         private void WriteIptcProfile(IptcProfile iptcProfile)
         {
-            const int Max = 65533;
+            const int maxBytes = 65533;
             if (iptcProfile is null || !iptcProfile.Values.Any())
             {
                 return;
@@ -447,19 +306,19 @@ namespace SixLabors.ImageSharp.Formats.Jpeg
                 return;
             }
 
-            if (data.Length > Max)
+            if (data.Length > maxBytes)
             {
-                throw new ImageFormatException($"Iptc profile size exceeds limit of {Max} bytes");
+                throw new ImageFormatException($"Iptc profile size exceeds limit of {maxBytes} bytes");
             }
 
-            int app13Length = 2 + ProfileResolver.AdobePhotoshopApp13Marker.Length +
+            int app13Length = 2 + Components.Decoder.ProfileResolver.AdobePhotoshopApp13Marker.Length +
-                              ProfileResolver.AdobeImageResourceBlockMarker.Length +
+                              Components.Decoder.ProfileResolver.AdobeImageResourceBlockMarker.Length +
-                              ProfileResolver.AdobeIptcMarker.Length +
+                              Components.Decoder.ProfileResolver.AdobeIptcMarker.Length +
                               2 + 4 + data.Length;
             this.WriteAppHeader(app13Length, JpegConstants.Markers.APP13);
-            this.outputStream.Write(ProfileResolver.AdobePhotoshopApp13Marker);
+            this.outputStream.Write(Components.Decoder.ProfileResolver.AdobePhotoshopApp13Marker);
-            this.outputStream.Write(ProfileResolver.AdobeImageResourceBlockMarker);
+            this.outputStream.Write(Components.Decoder.ProfileResolver.AdobeImageResourceBlockMarker);
-            this.outputStream.Write(ProfileResolver.AdobeIptcMarker);
+            this.outputStream.Write(Components.Decoder.ProfileResolver.AdobeIptcMarker);
             this.outputStream.WriteByte(0); // a empty pascal string (padded to make size even)
             this.outputStream.WriteByte(0);
             BinaryPrimitives.WriteInt32BigEndian(this.buffer, data.Length);
@@ -481,9 +340,9 @@ namespace SixLabors.ImageSharp.Formats.Jpeg
                 return;
             }
 
-            const int XmpOverheadLength = 29;
+            const int xmpOverheadLength = 29;
-            const int Max = 65533;
+            const int maxBytes = 65533;
-            const int MaxData = Max - XmpOverheadLength;
+            const int maxData = maxBytes - xmpOverheadLength;
 
             byte[] data = xmpProfile.Data;
 
@@ -499,16 +358,16 @@ namespace SixLabors.ImageSharp.Formats.Jpeg
             {
                 int length = dataLength; // Number of bytes to write.
 
-                if (length > MaxData)
+                if (length > maxData)
                 {
-                    length = MaxData;
+                    length = maxData;
                 }
 
                 dataLength -= length;
 
-                int app1Length = 2 + ProfileResolver.XmpMarker.Length + length;
+                int app1Length = 2 + Components.Decoder.ProfileResolver.XmpMarker.Length + length;
                 this.WriteApp1Header(app1Length);
-                this.outputStream.Write(ProfileResolver.XmpMarker);
+                this.outputStream.Write(Components.Decoder.ProfileResolver.XmpMarker);
                 this.outputStream.Write(data, offset, length);
 
                 offset += length;
@@ -551,9 +410,9 @@ namespace SixLabors.ImageSharp.Formats.Jpeg
                 return;
             }
 
-            const int IccOverheadLength = 14;
+            const int iccOverheadLength = 14;
-            const int Max = 65533;
+            const int maxBytes = 65533;
-            const int MaxData = Max - IccOverheadLength;
+            const int maxData = maxBytes - iccOverheadLength;
 
             byte[] data = iccProfile.ToByteArray();
 
@@ -564,9 +423,9 @@ namespace SixLabors.ImageSharp.Formats.Jpeg
 
             // Calculate the number of markers we'll need, rounding up of course.
             int dataLength = data.Length;
-            int count = dataLength / MaxData;
+            int count = dataLength / maxData;
 
-            if (count * MaxData != dataLength)
+            if (count * maxData != dataLength)
             {
                 count++;
             }
@@ -579,9 +438,9 @@ namespace SixLabors.ImageSharp.Formats.Jpeg
             {
                 int length = dataLength; // Number of bytes to write.
 
-                if (length > MaxData)
+                if (length > maxData)
                 {
-                    length = MaxData;
+                    length = maxData;
                 }
 
                 dataLength -= length;
@@ -609,7 +468,7 @@ namespace SixLabors.ImageSharp.Formats.Jpeg
                 this.buffer[12] = (byte)current; // The position within the collection.
                 this.buffer[13] = (byte)count; // The total number of profiles.
 
-                this.outputStream.Write(this.buffer, 0, IccOverheadLength);
+                this.outputStream.Write(this.buffer, 0, iccOverheadLength);
                 this.outputStream.Write(data, offset, length);
 
                 current++;
@@ -643,124 +502,46 @@ namespace SixLabors.ImageSharp.Formats.Jpeg
         /// <summary>
         /// Writes the Start Of Frame (Baseline) marker.
         /// </summary>
-        /// <param name="width">The width of the image.</param>
+        private void WriteStartOfFrame(int width, int height, JpegFrameConfig frame)
-        /// <param name="height">The height of the image.</param>
-        /// <param name="componentCount">The number of components in a pixel.</param>
-        /// <param name="componentIds">The component Id's.</param>
-        private void WriteStartOfFrame(int width, int height, int componentCount, ReadOnlySpan<byte> componentIds)
         {
-            // This uses a C#'s compiler optimization that refers to the static data segment of the assembly,
+            JpegComponentConfig[] components = frame.Components;
-            // and doesn't incur any allocation at all.
-            // "default" to 4:2:0
-            ReadOnlySpan<byte> subsamples = new byte[]
-            {
-                0x22,
-                0x11,
-                0x11
-            };
-
-            ReadOnlySpan<byte> chroma = new byte[]
-            {
-                0x00,
-                0x01,
-                0x01
-            };
-
-            if (this.colorType == JpegColorType.Luminance)
-            {
-                subsamples = new byte[]
-                {
-                    0x11,
-                    0x00,
-                    0x00
-                };
-            }
-            else
-            {
-                switch (this.colorType)
-                {
-                    case JpegColorType.YCbCrRatio444:
-                    case JpegColorType.Rgb:
-                        subsamples = new byte[]
-                        {
-                            0x11,
-                            0x11,
-                            0x11
-                        };
-
-                        if (this.colorType == JpegColorType.Rgb)
-                        {
-                            chroma = new byte[]
-                            {
-                                0x00,
-                                0x00,
-                                0x00
-                            };
-                        }
-
-                        break;
-                    case JpegColorType.YCbCrRatio420:
-                        subsamples = new byte[]
-                        {
-                            0x22,
-                            0x11,
-                            0x11
-                        };
-                        break;
-                }
-            }
 
             // Length (high byte, low byte), 8 + components * 3.
-            int markerlen = 8 + (3 * componentCount);
+            int markerlen = 8 + (3 * components.Length);
             this.WriteMarkerHeader(JpegConstants.Markers.SOF0, markerlen);
             this.buffer[0] = 8; // Data Precision. 8 for now, 12 and 16 bit jpegs not supported
             this.buffer[1] = (byte)(height >> 8);
             this.buffer[2] = (byte)(height & 0xff); // (2 bytes, Hi-Lo), must be > 0 if DNL not supported
             this.buffer[3] = (byte)(width >> 8);
             this.buffer[4] = (byte)(width & 0xff); // (2 bytes, Hi-Lo), must be > 0 if DNL not supported
-            this.buffer[5] = (byte)componentCount;
+            this.buffer[5] = (byte)components.Length;
 
-            for (int i = 0; i < componentCount; i++)
+            // Components data
+            for (int i = 0; i < components.Length; i++)
             {
                 int i3 = 3 * i;
-
-                // Component ID.
                 Span<byte> bufferSpan = this.buffer.AsSpan(i3 + 6, 3);
-                bufferSpan[2] = chroma[i];
+
-                bufferSpan[1] = subsamples[i];
+                // Quantization table selector
-                bufferSpan[0] = componentIds[i];
+                bufferSpan[2] = (byte)components[i].QuantizatioTableIndex;
+
+                // Sampling factors
+                // 4 bits
+                int samplingFactors = (components[i].HorizontalSampleFactor << 4) | components[i].VerticalSampleFactor;
+                bufferSpan[1] = (byte)samplingFactors;
+
+                // Id
+                bufferSpan[0] = components[i].Id;
             }
 
-            this.outputStream.Write(this.buffer, 0, (3 * (componentCount - 1)) + 9);
+            this.outputStream.Write(this.buffer, 0, (3 * (components.Length - 1)) + 9);
         }
 
         /// <summary>
         /// Writes the StartOfScan marker.
         /// </summary>
-        /// <param name="componentCount">The number of components in a pixel.</param>
+        private void WriteStartOfScan(Span<JpegComponentConfig> components)
-        /// <param name="componentIds">The componentId's.</param>
-        private void WriteStartOfScan(int componentCount, ReadOnlySpan<byte> componentIds)
         {
-            // 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.
-            ReadOnlySpan<byte> huffmanId = new byte[]
-            {
-                0x00,
-                0x11,
-                0x11
-            };
-
-            // Use the same DC/AC tables for all channels for RGB.
-            if (this.colorType == JpegColorType.Rgb)
-            {
-                huffmanId = new byte[]
-                {
-                    0x00,
-                    0x00,
-                    0x00
-                };
-            }
-
             // Write the SOS (Start Of Scan) marker "\xff\xda" followed by 12 bytes:
             // - the marker length "\x00\x0c",
             // - the number of components "\x03",
@@ -774,15 +555,22 @@ namespace SixLabors.ImageSharp.Formats.Jpeg
             this.buffer[1] = JpegConstants.Markers.SOS;
 
             // Length (high byte, low byte), must be 6 + 2 * (number of components in scan)
-            int sosSize = 6 + (2 * componentCount);
+            int sosSize = 6 + (2 * components.Length);
             this.buffer[2] = 0x00;
             this.buffer[3] = (byte)sosSize;
-            this.buffer[4] = (byte)componentCount; // Number of components in a scan
+            this.buffer[4] = (byte)components.Length; // Number of components in a scan
-            for (int i = 0; i < componentCount; i++)
+
+            // Components data
+            for (int i = 0; i < components.Length; i++)
             {
                 int i2 = 2 * i;
-                this.buffer[i2 + 5] = componentIds[i]; // Component Id
+
-                this.buffer[i2 + 6] = huffmanId[i]; // DC/AC Huffman table
+                // Id
+                this.buffer[i2 + 5] = components[i].Id;
+
+                // Table selectors
+                int tableSelectors = (components[i].DcTableSelector << 4) | components[i].AcTableSelector;
+                this.buffer[i2 + 6] = (byte)tableSelectors;
             }
 
             this.buffer[sosSize - 1] = 0x00; // Ss - Start of spectral selection.
@@ -801,6 +589,40 @@ namespace SixLabors.ImageSharp.Formats.Jpeg
             this.outputStream.Write(this.buffer, 0, 2);
         }
 
+        /// <summary>
+        /// Writes scans for given config.
+        /// </summary>
+        private void WriteHuffmanScans<TPixel>(JpegFrame frame, JpegFrameConfig frameConfig, SpectralConverter<TPixel> spectralConverter, HuffmanScanEncoder encoder, CancellationToken cancellationToken)
+            where TPixel : unmanaged, IPixel<TPixel>
+        {
+            if (frame.Components.Length == 1)
+            {
+                frame.AllocateComponents(fullScan: false);
+
+                this.WriteStartOfScan(frameConfig.Components);
+                encoder.EncodeScanBaselineSingleComponent(frame.Components[0], spectralConverter, cancellationToken);
+            }
+            else if (frame.Interleaved)
+            {
+                frame.AllocateComponents(fullScan: false);
+
+                this.WriteStartOfScan(frameConfig.Components);
+                encoder.EncodeScanBaselineInterleaved(frameConfig.EncodingColor, frame, spectralConverter, cancellationToken);
+            }
+            else
+            {
+                frame.AllocateComponents(fullScan: true);
+                spectralConverter.ConvertFull();
+
+                Span<JpegComponentConfig> components = frameConfig.Components;
+                for (int i = 0; i < frame.Components.Length; i++)
+                {
+                    this.WriteStartOfScan(components.Slice(i, 1));
+                    encoder.EncodeScanBaseline(frame.Components[i], cancellationToken);
+                }
+            }
+        }
+
         /// <summary>
         /// Writes the header for a marker with the given length.
         /// </summary>
@@ -817,54 +639,78 @@ namespace SixLabors.ImageSharp.Formats.Jpeg
         }
 
         /// <summary>
-        /// Initializes quantization tables.
+        /// Writes the Define Quantization Marker and prepares tables for encoding.
         /// </summary>
         /// <remarks>
-        /// <para>
-        /// Zig-zag ordering is NOT applied to the resulting tables.
-        /// </para>
-        /// <para>
         /// We take quality values in a hierarchical order:
-        /// 1. Check if encoder has set quality
+        /// <list type = "number" >
-        /// 2. Check if metadata has set quality
+        ///     <item>Check if encoder has set quality.</item>
-        /// 3. Take default quality value - 75
+        ///     <item>Check if metadata has set quality.</item>
-        /// </para>
+        ///     <item>Take default quality value from <see cref="Quantization.DefaultQualityFactor"/></item>
+        /// </list>
         /// </remarks>
-        /// <param name="componentCount">Color components count.</param>
+        /// <param name="configs">Quantization tables configs.</param>
+        /// <param name="optionsQuality">Optional quality value from the options.</param>
         /// <param name="metadata">Jpeg metadata instance.</param>
-        /// <param name="luminanceQuantTable">Output luminance quantization table.</param>
+        private void WriteDefineQuantizationTables(JpegQuantizationTableConfig[] configs, int? optionsQuality, JpegMetadata metadata)
-        /// <param name="chrominanceQuantTable">Output chrominance quantization table.</param>
-        private void InitQuantizationTables(int componentCount, JpegMetadata metadata, out Block8x8F luminanceQuantTable, out Block8x8F chrominanceQuantTable)
         {
-            int lumaQuality;
+            int dataLen = configs.Length * (1 + Block8x8.Size);
-            int chromaQuality;
+
-            if (this.quality.HasValue)
+            // Marker + quantization table lengths.
-            {
+            int markerlen = 2 + dataLen;
-                lumaQuality = this.quality.Value;
+            this.WriteMarkerHeader(JpegConstants.Markers.DQT, markerlen);
-                chromaQuality = this.quality.Value;
-            }
-            else
-            {
-                lumaQuality = metadata.LuminanceQuality;
-                chromaQuality = metadata.ChrominanceQuality;
-            }
 
-            // Luminance
+            byte[] buffer = new byte[dataLen];
-            lumaQuality = Numerics.Clamp(lumaQuality, 1, 100);
+            int offset = 0;
-            luminanceQuantTable = Quantization.ScaleLuminanceTable(lumaQuality);
+
+            Block8x8F workspaceBlock = default;
 
-            // Chrominance
+            for (int i = 0; i < configs.Length; i++)
-            chrominanceQuantTable = default;
-            if (componentCount > 1)
             {
-                chromaQuality = Numerics.Clamp(chromaQuality, 1, 100);
+                JpegQuantizationTableConfig config = configs[i];
-                chrominanceQuantTable = Quantization.ScaleChrominanceTable(chromaQuality);
+
+                int quality = GetQualityForTable(config.DestinationIndex, optionsQuality, metadata);
+                Block8x8 scaledTable = Quantization.ScaleQuantizationTable(quality, config.Table);
 
-                if (!this.colorType.HasValue)
+                // write to the output stream
+                buffer[offset++] = (byte)config.DestinationIndex;
+
+                for (int j = 0; j < Block8x8.Size; j++)
                 {
-                    this.colorType = chromaQuality >= 91 ? JpegColorType.YCbCrRatio444 : JpegColorType.YCbCrRatio420;
+                    buffer[offset++] = (byte)(uint)scaledTable[ZigZag.ZigZagOrder[j]];
                 }
+
+                // apply FDCT multipliers and inject to the destination index
+                workspaceBlock.LoadFrom(ref scaledTable);
+                FloatingPointDCT.AdjustToFDCT(ref workspaceBlock);
+
+                this.QuantizationTables[config.DestinationIndex] = workspaceBlock;
             }
+
+            // write filled buffer to the stream
+            this.outputStream.Write(buffer);
+
+            static int GetQualityForTable(int destIndex, int? encoderQuality, JpegMetadata metadata) => destIndex switch
+            {
+                0 => encoderQuality ?? metadata.LuminanceQuality ?? Quantization.DefaultQualityFactor,
+                1 => encoderQuality ?? metadata.ChrominanceQuality ?? Quantization.DefaultQualityFactor,
+                _ => encoderQuality ?? metadata.Quality,
+            };
+        }
+
+        private JpegFrameConfig GetFrameConfig(JpegMetadata metadata)
+        {
+            JpegEncodingColor color = this.options.ColorType ?? metadata.ColorType ?? JpegEncodingColor.YCbCrRatio420;
+            JpegFrameConfig frameConfig = Array.Find(
+                FrameConfigs,
+                cfg => cfg.EncodingColor == color);
+
+            if (frameConfig == null)
+            {
+                throw new ArgumentException(nameof(color));
+            }
+
+            return frameConfig;
         }
     }
 }

src/ImageSharp/Formats/Jpeg/JpegColorType.cs → src/ImageSharp/Formats/Jpeg/JpegEncodingColor.cs

@@ -6,7 +6,7 @@ namespace SixLabors.ImageSharp.Formats.Jpeg
     /// <summary>
     /// Provides enumeration of available JPEG color types.
     /// </summary>
-    public enum JpegColorType : byte
+    public enum JpegEncodingColor : byte
     {
         /// <summary>
         /// YCbCr (luminance, blue chroma, red chroma) color as defined in the ITU-T T.871 specification.
@@ -25,24 +25,18 @@ namespace SixLabors.ImageSharp.Formats.Jpeg
         /// <summary>
         /// YCbCr (luminance, blue chroma, red chroma) color as defined in the ITU-T T.871 specification.
         /// The two chroma components are sampled at half the horizontal sample rate of luma while vertically it has full resolution.
-        ///
-        /// Note: Not supported by the encoder.
         /// </summary>
         YCbCrRatio422 = 2,
 
         /// <summary>
         /// YCbCr (luminance, blue chroma, red chroma) color as defined in the ITU-T T.871 specification.
         /// In 4:1:1 chroma subsampling, the horizontal color resolution is quartered.
-        ///
-        /// Note: Not supported by the encoder.
         /// </summary>
         YCbCrRatio411 = 3,
 
         /// <summary>
         /// YCbCr (luminance, blue chroma, red chroma) color as defined in the ITU-T T.871 specification.
         /// This ratio uses half of the vertical and one-fourth the horizontal color resolutions.
-        ///
-        /// Note: Not supported by the encoder.
         /// </summary>
         YCbCrRatio410 = 4,
 
@@ -58,9 +52,12 @@ namespace SixLabors.ImageSharp.Formats.Jpeg
 
         /// <summary>
         /// CMYK colorspace (cyan, magenta, yellow, and key black) intended for printing.
-        ///
-        /// Note: Not supported by the encoder.
         /// </summary>
         Cmyk = 7,
+
+        /// <summary>
+        /// YCCK colorspace (Y, Cb, Cr, and key black).
+        /// </summary>
+        Ycck = 8,
     }
 }

src/ImageSharp/Formats/Jpeg/JpegMetadata.cs

@@ -11,16 +11,6 @@ namespace SixLabors.ImageSharp.Formats.Jpeg
     /// </summary>
     public class JpegMetadata : IDeepCloneable
     {
-        /// <summary>
-        /// Backing field for <see cref="LuminanceQuality"/>
-        /// </summary>
-        private int? luminanceQuality;
-
-        /// <summary>
-        /// Backing field for <see cref="ChrominanceQuality"/>
-        /// </summary>
-        private int? chrominanceQuality;
-
         /// <summary>
         /// Initializes a new instance of the <see cref="JpegMetadata"/> class.
         /// </summary>
@@ -36,8 +26,8 @@ namespace SixLabors.ImageSharp.Formats.Jpeg
         {
             this.ColorType = other.ColorType;
 
-            this.luminanceQuality = other.luminanceQuality;
+            this.LuminanceQuality = other.LuminanceQuality;
-            this.chrominanceQuality = other.chrominanceQuality;
+            this.ChrominanceQuality = other.ChrominanceQuality;
         }
 
         /// <summary>
@@ -47,11 +37,7 @@ namespace SixLabors.ImageSharp.Formats.Jpeg
         /// This value might not be accurate if it was calculated during jpeg decoding
         /// with non-complient ITU quantization tables.
         /// </remarks>
-        internal int LuminanceQuality
+        internal int? LuminanceQuality { get; set; }
-        {
-            get => this.luminanceQuality ?? Quantization.DefaultQualityFactor;
-            set => this.luminanceQuality = value;
-        }
 
         /// <summary>
         /// Gets or sets the jpeg chrominance quality.
@@ -60,55 +46,61 @@ namespace SixLabors.ImageSharp.Formats.Jpeg
         /// This value might not be accurate if it was calculated during jpeg decoding
         /// with non-complient ITU quantization tables.
         /// </remarks>
-        internal int ChrominanceQuality
+        internal int? ChrominanceQuality { get; set; }
-        {
-            get => this.chrominanceQuality ?? Quantization.DefaultQualityFactor;
-            set => this.chrominanceQuality = value;
-        }
 
         /// <summary>
-        /// Gets or sets the encoded quality.
+        /// Gets the encoded quality.
         /// </summary>
         /// <remarks>
         /// Note that jpeg image can have different quality for luminance and chrominance components.
-        /// This property returns maximum value of luma/chroma qualities.
+        /// This property returns maximum value of luma/chroma qualities if both are present.
         /// </remarks>
         public int Quality
         {
             get
             {
-                // Jpeg always has a luminance table thus it must have a luminance quality derived from it
+                if (this.LuminanceQuality.HasValue)
-                if (!this.luminanceQuality.HasValue)
                 {
-                    return Quantization.DefaultQualityFactor;
+                    if (this.ChrominanceQuality.HasValue)
-                }
+                    {
+                        return Math.Max(this.LuminanceQuality.Value, this.ChrominanceQuality.Value);
+                    }
 
-                int lumaQuality = this.luminanceQuality.Value;
+                    return this.LuminanceQuality.Value;
-
-                // Jpeg might not have a chrominance table - return luminance quality (grayscale images)
-                if (!this.chrominanceQuality.HasValue)
-                {
-                    return lumaQuality;
                 }
+                else
+                {
+                    if (this.ChrominanceQuality.HasValue)
+                    {
+                        return this.ChrominanceQuality.Value;
+                    }
 
-                int chromaQuality = this.chrominanceQuality.Value;
+                    return Quantization.DefaultQualityFactor;
-
+                }
-                // Theoretically, luma quality would always be greater or equal to chroma quality
-                // But we've already encountered images which can have higher quality of chroma components
-                return Math.Max(lumaQuality, chromaQuality);
-            }
-
-            set
-            {
-                this.LuminanceQuality = value;
-                this.ChrominanceQuality = value;
             }
         }
 
         /// <summary>
-        /// Gets or sets the color type.
+        /// Gets the color type.
+        /// </summary>
+        public JpegEncodingColor? ColorType { get; internal set; }
+
+        /// <summary>
+        /// Gets the component encoding mode.
         /// </summary>
-        public JpegColorType? ColorType { get; set; }
+        /// <remarks>
+        /// Interleaved encoding mode encodes all color components in a single scan.
+        /// Non-interleaved encoding mode encodes each color component in a separate scan.
+        /// </remarks>
+        public bool? Interleaved { get; internal set; }
+
+        /// <summary>
+        /// Gets the scan encoding mode.
+        /// </summary>
+        /// <remarks>
+        /// Progressive jpeg images encode component data across multiple scans.
+        /// </remarks>
+        public bool? Progressive { get; internal set; }
 
         /// <inheritdoc/>
         public IDeepCloneable DeepClone() => new JpegMetadata(this);

src/ImageSharp/Formats/Pbm/PbmDecoder.cs

@@ -26,29 +26,33 @@ namespace SixLabors.ImageSharp.Formats.Pbm
     /// </list>
     /// The specification of these images is found at <seealso href="http://netpbm.sourceforge.net/doc/pnm.html"/>.
     /// </summary>
-    public sealed class PbmDecoder : IImageDecoder, IImageInfoDetector
+    public sealed class PbmDecoder : IImageDecoder
     {
         /// <inheritdoc/>
-        public Image<TPixel> Decode<TPixel>(Configuration configuration, Stream stream, CancellationToken cancellationToken)
+        IImageInfo IImageInfoDetector.Identify(DecoderOptions options, Stream stream, CancellationToken cancellationToken)
-            where TPixel : unmanaged, IPixel<TPixel>
         {
+            Guard.NotNull(options, nameof(options));
             Guard.NotNull(stream, nameof(stream));
 
-            var decoder = new PbmDecoderCore(configuration);
+            return new PbmDecoderCore(options).Identify(options.Configuration, stream, cancellationToken);
-            return decoder.Decode<TPixel>(configuration, stream, cancellationToken);
         }
 
         /// <inheritdoc />
-        public Image Decode(Configuration configuration, Stream stream, CancellationToken cancellationToken)
+        Image<TPixel> IImageDecoder.Decode<TPixel>(DecoderOptions options, Stream stream, CancellationToken cancellationToken)
-            => this.Decode<Rgb24>(configuration, stream, cancellationToken);
-
-        /// <inheritdoc/>
-        public IImageInfo Identify(Configuration configuration, Stream stream, CancellationToken cancellationToken)
         {
+            Guard.NotNull(options, nameof(options));
             Guard.NotNull(stream, nameof(stream));
 
-            var decoder = new PbmDecoderCore(configuration);
+            PbmDecoderCore decoder = new(options);
-            return decoder.Identify(configuration, stream, cancellationToken);
+            Image<TPixel> image = decoder.Decode<TPixel>(options.Configuration, stream, cancellationToken);
+
+            ImageDecoderUtilities.Resize(options, image);
+
+            return image;
         }
+
+        /// <inheritdoc />
+        Image IImageDecoder.Decode(DecoderOptions options, Stream stream, CancellationToken cancellationToken)
+            => ((IImageDecoder)this).Decode<Rgb24>(options, stream, cancellationToken);
     }
 }

src/ImageSharp/Formats/Pbm/PbmDecoderCore.cs

@@ -19,43 +19,50 @@ namespace SixLabors.ImageSharp.Formats.Pbm
         private int maxPixelValue;
 
         /// <summary>
-        /// Initializes a new instance of the <see cref="PbmDecoderCore" /> class.
+        /// The general configuration.
         /// </summary>
-        /// <param name="configuration">The configuration.</param>
+        private readonly Configuration configuration;
-        public PbmDecoderCore(Configuration configuration) => this.Configuration = configuration ?? Configuration.Default;
 
-        /// <inheritdoc />
+        /// <summary>
-        public Configuration Configuration { get; }
+        /// The colortype to use
+        /// </summary>
+        private PbmColorType colorType;
 
         /// <summary>
-        /// Gets the colortype to use
+        /// The size of the pixel array
         /// </summary>
-        public PbmColorType ColorType { get; private set; }
+        private Size pixelSize;
 
         /// <summary>
-        /// Gets the size of the pixel array
+        /// The component data type
         /// </summary>
-        public Size PixelSize { get; private set; }
+        private PbmComponentType componentType;
 
         /// <summary>
-        /// Gets the component data type
+        /// The Encoding of pixels
         /// </summary>
-        public PbmComponentType ComponentType { get; private set; }
+        private PbmEncoding encoding;
 
         /// <summary>
-        /// Gets the Encoding of pixels
+        /// The <see cref="ImageMetadata"/> decoded by this decoder instance.
         /// </summary>
-        public PbmEncoding Encoding { get; private set; }
+        private ImageMetadata metadata;
 
         /// <summary>
-        /// Gets the <see cref="ImageMetadata"/> decoded by this decoder instance.
+        /// Initializes a new instance of the <see cref="PbmDecoderCore" /> class.
         /// </summary>
-        public ImageMetadata Metadata { get; private set; }
+        /// <param name="options">The decoder options.</param>
+        public PbmDecoderCore(DecoderOptions options)
+        {
+            this.Options = options;
+            this.configuration = options.Configuration;
+        }
 
         /// <inheritdoc/>
-        Size IImageDecoderInternals.Dimensions => this.PixelSize;
+        public DecoderOptions Options { get; }
 
-        private bool NeedsUpscaling => this.ColorType != PbmColorType.BlackAndWhite && this.maxPixelValue is not 255 and not 65535;
+        /// <inheritdoc/>
+        public Size Dimensions => this.pixelSize;
 
         /// <inheritdoc/>
         public Image<TPixel> Decode<TPixel>(BufferedReadStream stream, CancellationToken cancellationToken)
@@ -63,12 +70,12 @@ namespace SixLabors.ImageSharp.Formats.Pbm
         {
             this.ProcessHeader(stream);
 
-            var image = new Image<TPixel>(this.Configuration, this.PixelSize.Width, this.PixelSize.Height, this.Metadata);
+            var image = new Image<TPixel>(this.configuration, this.pixelSize.Width, this.pixelSize.Height, this.metadata);
 
             Buffer2D<TPixel> pixels = image.GetRootFramePixelBuffer();
 
             this.ProcessPixels(stream, pixels);
-            if (this.NeedsUpscaling)
+            if (this.NeedsUpscaling())
             {
                 this.ProcessUpscaling(image);
             }
@@ -82,8 +89,8 @@ namespace SixLabors.ImageSharp.Formats.Pbm
             this.ProcessHeader(stream);
 
             // BlackAndWhite pixels are encoded into a byte.
-            int bitsPerPixel = this.ComponentType == PbmComponentType.Short ? 16 : 8;
+            int bitsPerPixel = this.componentType == PbmComponentType.Short ? 16 : 8;
-            return new ImageInfo(new PixelTypeInfo(bitsPerPixel), this.PixelSize.Width, this.PixelSize.Height, this.Metadata);
+            return new ImageInfo(new PixelTypeInfo(bitsPerPixel), this.pixelSize.Width, this.pixelSize.Height, this.metadata);
         }
 
         /// <summary>
@@ -104,33 +111,33 @@ namespace SixLabors.ImageSharp.Formats.Pbm
             {
                 case '1':
                     // Plain PBM format: 1 component per pixel, boolean value ('0' or '1').
-                    this.ColorType = PbmColorType.BlackAndWhite;
+                    this.colorType = PbmColorType.BlackAndWhite;
-                    this.Encoding = PbmEncoding.Plain;
+                    this.encoding = PbmEncoding.Plain;
                     break;
                 case '2':
                     // Plain PGM format: 1 component per pixel, in decimal text.
-                    this.ColorType = PbmColorType.Grayscale;
+                    this.colorType = PbmColorType.Grayscale;
-                    this.Encoding = PbmEncoding.Plain;
+                    this.encoding = PbmEncoding.Plain;
                     break;
                 case '3':
                     // Plain PPM format: 3 components per pixel, in decimal text.
-                    this.ColorType = PbmColorType.Rgb;
+                    this.colorType = PbmColorType.Rgb;
-                    this.Encoding = PbmEncoding.Plain;
+                    this.encoding = PbmEncoding.Plain;
                     break;
                 case '4':
                     // Binary PBM format: 1 component per pixel, 8 pixels per byte.
-                    this.ColorType = PbmColorType.BlackAndWhite;
+                    this.colorType = PbmColorType.BlackAndWhite;
-                    this.Encoding = PbmEncoding.Binary;
+                    this.encoding = PbmEncoding.Binary;
                     break;
                 case '5':
                     // Binary PGM format: 1 components per pixel, in binary integers.
-                    this.ColorType = PbmColorType.Grayscale;
+                    this.colorType = PbmColorType.Grayscale;
-                    this.Encoding = PbmEncoding.Binary;
+                    this.encoding = PbmEncoding.Binary;
                     break;
                 case '6':
                     // Binary PPM format: 3 components per pixel, in binary integers.
-                    this.ColorType = PbmColorType.Rgb;
+                    this.colorType = PbmColorType.Rgb;
-                    this.Encoding = PbmEncoding.Binary;
+                    this.encoding = PbmEncoding.Binary;
                     break;
                 case '7':
                 // PAM image: sequence of images.
@@ -144,52 +151,54 @@ namespace SixLabors.ImageSharp.Formats.Pbm
             stream.SkipWhitespaceAndComments();
             int height = stream.ReadDecimal();
             stream.SkipWhitespaceAndComments();
-            if (this.ColorType != PbmColorType.BlackAndWhite)
+            if (this.colorType != PbmColorType.BlackAndWhite)
             {
                 this.maxPixelValue = stream.ReadDecimal();
                 if (this.maxPixelValue > 255)
                 {
-                    this.ComponentType = PbmComponentType.Short;
+                    this.componentType = PbmComponentType.Short;
                 }
                 else
                 {
-                    this.ComponentType = PbmComponentType.Byte;
+                    this.componentType = PbmComponentType.Byte;
                 }
 
                 stream.SkipWhitespaceAndComments();
             }
             else
             {
-                this.ComponentType = PbmComponentType.Bit;
+                this.componentType = PbmComponentType.Bit;
             }
 
-            this.PixelSize = new Size(width, height);
+            this.pixelSize = new Size(width, height);
-            this.Metadata = new ImageMetadata();
+            this.metadata = new ImageMetadata();
-            PbmMetadata meta = this.Metadata.GetPbmMetadata();
+            PbmMetadata meta = this.metadata.GetPbmMetadata();
-            meta.Encoding = this.Encoding;
+            meta.Encoding = this.encoding;
-            meta.ColorType = this.ColorType;
+            meta.ColorType = this.colorType;
-            meta.ComponentType = this.ComponentType;
+            meta.ComponentType = this.componentType;
         }
 
         private void ProcessPixels<TPixel>(BufferedReadStream stream, Buffer2D<TPixel> pixels)
             where TPixel : unmanaged, IPixel<TPixel>
         {
-            if (this.Encoding == PbmEncoding.Binary)
+            if (this.encoding == PbmEncoding.Binary)
             {
-                BinaryDecoder.Process(this.Configuration, pixels, stream, this.ColorType, this.ComponentType);
+                BinaryDecoder.Process(this.configuration, pixels, stream, this.colorType, this.componentType);
             }
             else
             {
-                PlainDecoder.Process(this.Configuration, pixels, stream, this.ColorType, this.ComponentType);
+                PlainDecoder.Process(this.configuration, pixels, stream, this.colorType, this.componentType);
             }
         }
 
         private void ProcessUpscaling<TPixel>(Image<TPixel> image)
             where TPixel : unmanaged, IPixel<TPixel>
         {
-            int maxAllocationValue = this.ComponentType == PbmComponentType.Short ? 65535 : 255;
+            int maxAllocationValue = this.componentType == PbmComponentType.Short ? 65535 : 255;
             float factor = maxAllocationValue / this.maxPixelValue;
             image.Mutate(x => x.Brightness(factor));
         }
+
+        private bool NeedsUpscaling() => this.colorType != PbmColorType.BlackAndWhite && this.maxPixelValue is not 255 and not 65535;
     }
 }

src/ImageSharp/Formats/Png/IPngDecoderOptions.cs

@@ -1,16 +0,0 @@
-// Copyright (c) Six Labors.
-// Licensed under the Six Labors Split License.
-
-namespace SixLabors.ImageSharp.Formats.Png
-{
-    /// <summary>
-    /// The options for decoding png images
-    /// </summary>
-    internal interface IPngDecoderOptions
-    {
-        /// <summary>
-        /// Gets a value indicating whether the metadata should be ignored when the image is being decoded.
-        /// </summary>
-        bool IgnoreMetadata { get; }
-    }
-}