Infrastructure

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

@@ -233,6 +233,21 @@ namespace SixLabors.ImageSharp.Formats.Jpeg.Components.Decoder.ColorConverters
                 this.Component3 = this.ComponentCount > 3 ? processors[3].GetColorBufferRowSpan(row) : Span<float>.Empty;
             }
 
+            // TODO: experimental
+            public ComponentValues(IReadOnlyList<JpegComponentPostProcessor8> 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;
+            }
+
             internal ComponentValues(
                 int componentCount,
                 Span<float> c0,

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

@@ -22,7 +22,7 @@ namespace SixLabors.ImageSharp.Formats.Jpeg.Components.Decoder
     /// </listheader>
     /// </list>
     /// </remarks>
-    internal class SpectralConverter<TPixel> : SpectralConverter, IDisposable
+    internal class DirectSpectralConverter<TPixel> : SpectralConverter<TPixel>, IDisposable
         where TPixel : unmanaged, IPixel<TPixel>
     {
         /// <summary>
@@ -67,22 +67,18 @@ namespace SixLabors.ImageSharp.Formats.Jpeg.Components.Decoder
         private int pixelRowCounter;
 
         /// <summary>
-        /// Initializes a new instance of the <see cref="SpectralConverter{TPixel}" /> class.
+        /// Initializes a new instance of the <see cref="DirectSpectralConverter{TPixel}" /> class.
         /// </summary>
         /// <param name="configuration">The configuration.</param>
-        public SpectralConverter(Configuration configuration) =>
+        public DirectSpectralConverter(Configuration configuration) =>
             this.configuration = configuration;
 
-        /// <summary>
+        /// <inheritdoc/>
-        /// Gets converted pixel buffer.
-        /// </summary>
         /// <remarks>
         /// For non-baseline interleaved jpeg this method does a 'lazy' spectral
         /// conversion from spectral to color.
         /// </remarks>
-        /// <param name="cancellationToken">Cancellation token.</param>
+        public override Buffer2D<TPixel> GetPixelBuffer(CancellationToken cancellationToken)
-        /// <returns>Pixel buffer.</returns>
-        public Buffer2D<TPixel> GetPixelBuffer(CancellationToken cancellationToken)
         {
             if (!this.Converted)
             {

src/ImageSharp/Formats/Jpeg/Components/Decoder/SpectralConversion/JpegComponentPostProcessor8.cs

@@ -0,0 +1,129 @@
+// Copyright (c) Six Labors.
+// Licensed under the Apache License, Version 2.0.
+
+using System;
+using SixLabors.ImageSharp.Memory;
+
+namespace SixLabors.ImageSharp.Formats.Jpeg.Components.Decoder
+{
+    /// <summary>
+    /// Encapsulates spectral data to rgba32 processing for one component.
+    /// </summary>
+    internal class JpegComponentPostProcessor8 : IDisposable
+    {
+        /// <summary>
+        /// The size of the area in <see cref="ColorBuffer"/> corresponding to one 8x8 Jpeg block
+        /// </summary>
+        private readonly Size blockAreaSize;
+
+        /// <summary>
+        /// Jpeg frame instance containing required decoding metadata.
+        /// </summary>
+        private readonly JpegFrame frame;
+
+        /// <summary>
+        /// Gets the <see cref="IJpegComponent"/> component containing decoding meta information.
+        /// </summary>
+        private readonly IJpegComponent component;
+
+        /// <summary>
+        /// Gets the <see cref="IRawJpegData"/> instance containing decoding meta information.
+        /// </summary>
+        private readonly IRawJpegData rawJpeg;
+
+        /// <summary>
+        /// Initializes a new instance of the <see cref="JpegComponentPostProcessor8"/> class.
+        /// </summary>
+        public JpegComponentPostProcessor8(MemoryAllocator memoryAllocator, JpegFrame frame, IRawJpegData rawJpeg, Size postProcessorBufferSize, IJpegComponent component)
+        {
+            // TODO: this must be a variable depending on dct scale factor
+            const int blockSize = 1;
+
+            this.frame = frame;
+
+            this.component = component;
+            this.rawJpeg = rawJpeg;
+            this.blockAreaSize = this.component.SubSamplingDivisors * blockSize;
+            this.ColorBuffer = memoryAllocator.Allocate2DOveraligned<float>(
+                postProcessorBufferSize.Width,
+                postProcessorBufferSize.Height,
+                this.blockAreaSize.Height);
+        }
+
+        /// <summary>
+        /// Gets the temporary working buffer of color values.
+        /// </summary>
+        public Buffer2D<float> ColorBuffer { get; }
+
+        /// <inheritdoc />
+        public void Dispose() => this.ColorBuffer.Dispose();
+
+        /// <summary>
+        /// Convert raw spectral DCT data to color data and copy it to the color buffer <see cref="ColorBuffer"/>.
+        /// </summary>
+        public void CopyBlocksToColorBuffer(int spectralStep)
+        {
+            Buffer2D<Block8x8> spectralBuffer = this.component.SpectralBlocks;
+
+            float maximumValue = this.frame.MaxColorChannelValue;
+
+            int destAreaStride = this.ColorBuffer.Width;
+
+            int blocksRowsPerStep = this.component.SamplingFactors.Height;
+
+            int yBlockStart = spectralStep * blocksRowsPerStep;
+
+            Size subSamplingDivisors = this.component.SubSamplingDivisors;
+
+            Block8x8F dequantTable = this.rawJpeg.QuantizationTables[this.component.QuantizationTableIndex];
+            Block8x8F workspaceBlock = default;
+
+            return;
+
+            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++)
+                {
+                    // Integer to float
+                    workspaceBlock.LoadFrom(ref blockRow[xBlock]);
+
+                    // Dequantize
+                    workspaceBlock.MultiplyInPlace(ref dequantTable);
+
+                    // Convert from spectral to color
+                    FastFloatingPointDCT.TransformIDCT(ref workspaceBlock);
+
+                    // To conform better to libjpeg we actually NEED TO loose precision here.
+                    // This is because they store blocks as Int16 between all the operations.
+                    // To be "more accurate", we need to emulate this by rounding!
+                    workspaceBlock.NormalizeColorsAndRoundInPlace(maximumValue);
+
+                    // Write to color buffer acording to sampling factors
+                    int xColorBufferStart = xBlock * this.blockAreaSize.Width;
+                    workspaceBlock.ScaledCopyTo(
+                        ref colorBufferRow[xColorBufferStart],
+                        destAreaStride,
+                        subSamplingDivisors.Width,
+                        subSamplingDivisors.Height);
+                }
+            }
+        }
+
+        public void ClearSpectralBuffers()
+        {
+            Buffer2D<Block8x8> spectralBlocks = this.component.SpectralBlocks;
+            for (int i = 0; i < spectralBlocks.Height; i++)
+            {
+                spectralBlocks.DangerousGetRowSpan(i).Clear();
+            }
+        }
+
+        public Span<float> GetColorBufferRowSpan(int row) =>
+            this.ColorBuffer.DangerousGetRowSpan(row);
+    }
+}

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

@@ -0,0 +1,258 @@
+// Copyright (c) Six Labors.
+// Licensed under the Apache License, Version 2.0.
+
+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;
+
+namespace SixLabors.ImageSharp.Formats.Jpeg.Components.Decoder
+{
+    // TODO: docs
+    internal class ResizingSpectralConverter<TPixel> : SpectralConverter<TPixel>, IDisposable
+        where TPixel : unmanaged, IPixel<TPixel>
+    {
+        /// <summary>
+        /// <see cref="Configuration"/> instance associated with current
+        /// decoding routine.
+        /// </summary>
+        private readonly Configuration configuration;
+
+        /// <summary>
+        /// Target image size after scaled decoding.
+        /// </summary>
+        private readonly Size targetSize;
+
+        /// <summary>
+        /// Jpeg component converters from decompressed spectral to color data.
+        /// </summary>
+        private JpegComponentPostProcessor8[] componentProcessors;
+
+        /// <summary>
+        /// Resulting 2D pixel buffer.
+        /// </summary>
+        private Buffer2D<TPixel> pixelBuffer;
+
+        /// <summary>
+        /// How many pixel rows are processed in one 'stride'.
+        /// </summary>
+        private int pixelRowsPerStep;
+
+        /// <summary>
+        /// How many pixel rows were processed.
+        /// </summary>
+        private int pixelRowCounter;
+
+        /// <summary>
+        /// Intermediate buffer of RGB components used in color conversion.
+        /// </summary>
+        private IMemoryOwner<byte> rgbBuffer;
+
+        /// <summary>
+        /// Proxy buffer used in packing from RGB to target TPixel pixels.
+        /// </summary>
+        private IMemoryOwner<TPixel> paddedProxyPixelRow;
+
+        /// <summary>
+        /// Color converter from jpeg color space to target pixel color space.
+        /// </summary>
+        private JpegColorConverterBase colorConverter;
+
+        public ResizingSpectralConverter(Configuration configuration, Size targetSize)
+        {
+            this.configuration = configuration;
+            this.targetSize = targetSize;
+        }
+
+        public override void InjectFrameData(JpegFrame frame, IRawJpegData jpegData)
+        {
+            MemoryAllocator allocator = this.configuration.MemoryAllocator;
+
+            (int width, int height, int scaleDenominator) = GetScaledImageDimensions(frame.PixelWidth, frame.PixelHeight, this.targetSize.Width, this.targetSize.Height);
+
+            // iteration data
+            int majorBlockWidth = frame.Components.Max((component) => component.SizeInBlocks.Width);
+            int majorVerticalSamplingFactor = frame.Components.Max((component) => component.SamplingFactors.Height);
+
+            this.pixelBuffer = allocator.Allocate2D<TPixel>(
+                width,
+                height,
+                this.configuration.PreferContiguousImageBuffers);
+
+            this.paddedProxyPixelRow = allocator.Allocate<TPixel>(width + 3);
+
+            // single 'stride' rgba32 buffer for conversion between spectral and TPixel
+            this.rgbBuffer = allocator.Allocate<byte>(width * 3);
+
+            // component processors from spectral to Rgba32
+            int blockPixelSize = 8 / scaleDenominator;
+            this.pixelRowsPerStep = majorVerticalSamplingFactor * blockPixelSize;
+
+            // BUFFER SIZE MUST BE DIVISIBLE BY 8 ATM
+            // TODO: fix this mess
+            int bufferWidth = majorBlockWidth * blockPixelSize;
+            int correctedBufferWidth = bufferWidth + (8 - (bufferWidth % 8));
+            var postProcessorBufferSize = new Size(correctedBufferWidth, this.pixelRowsPerStep);
+
+            this.componentProcessors = new JpegComponentPostProcessor8[frame.Components.Length];
+            for (int i = 0; i < this.componentProcessors.Length; i++)
+            {
+                this.componentProcessors[i] = new JpegComponentPostProcessor8(allocator, frame, jpegData, postProcessorBufferSize, frame.Components[i]);
+            }
+
+            // color converter
+            this.colorConverter = this.GetColorConverter(frame, jpegData);
+        }
+
+        public override void ConvertStrideBaseline()
+        {
+            // Convert next pixel stride using single spectral `stride'
+            // Note that zero passing eliminates the need of virtual call
+            // from JpegComponentPostProcessor
+            this.ConvertStride(spectralStep: 0);
+
+            foreach (JpegComponentPostProcessor8 cpp in this.componentProcessors)
+            {
+                cpp.ClearSpectralBuffers();
+            }
+        }
+
+        /// <summary>
+        /// Converts single spectral jpeg stride to color stride.
+        /// </summary>
+        /// <param name="spectralStep">Spectral stride index.</param>
+        private void ConvertStride(int spectralStep)
+        {
+            int maxY = Math.Min(this.pixelBuffer.Height, this.pixelRowCounter + this.pixelRowsPerStep);
+
+            for (int i = 0; i < this.componentProcessors.Length; i++)
+            {
+                this.componentProcessors[i].CopyBlocksToColorBuffer(spectralStep);
+            }
+
+            int width = this.pixelBuffer.Width;
+
+            for (int yy = this.pixelRowCounter; yy < maxY; yy++)
+            {
+                int y = yy - this.pixelRowCounter;
+
+                var values = new JpegColorConverterBase.ComponentValues(this.componentProcessors, y);
+
+                this.colorConverter.ConvertToRgbInplace(values);
+                values = values.Slice(0, width); // slice away Jpeg padding
+
+                Span<byte> r = this.rgbBuffer.Slice(0, width);
+                Span<byte> g = this.rgbBuffer.Slice(width, width);
+                Span<byte> b = this.rgbBuffer.Slice(width * 2, width);
+
+                SimdUtils.NormalizedFloatToByteSaturate(values.Component0.Slice(0, width), r);
+                SimdUtils.NormalizedFloatToByteSaturate(values.Component1.Slice(0, width), g);
+                SimdUtils.NormalizedFloatToByteSaturate(values.Component2.Slice(0, width), b);
+
+                // PackFromRgbPlanes expects the destination to be padded, so try to get padded span containing extra elements from the next row.
+                // If we can't get such a padded row because we are on a MemoryGroup boundary or at the last row,
+                // pack pixels to a temporary, padded proxy buffer, then copy the relevant values to the destination row.
+                if (this.pixelBuffer.DangerousTryGetPaddedRowSpan(yy, 3, out Span<TPixel> destRow))
+                {
+                    PixelOperations<TPixel>.Instance.PackFromRgbPlanes(this.configuration, r, g, b, destRow);
+                }
+                else
+                {
+                    Span<TPixel> proxyRow = this.paddedProxyPixelRow.GetSpan();
+                    PixelOperations<TPixel>.Instance.PackFromRgbPlanes(this.configuration, r, g, b, proxyRow);
+                    proxyRow.Slice(0, width).CopyTo(this.pixelBuffer.DangerousGetRowSpan(yy));
+                }
+            }
+
+            this.pixelRowCounter += this.pixelRowsPerStep;
+        }
+
+        public override Buffer2D<TPixel> GetPixelBuffer(CancellationToken cancellationToken)
+        {
+            if (!this.Converted)
+            {
+                int steps = (int)Math.Ceiling(this.pixelBuffer.Height / (float)this.pixelRowsPerStep);
+
+                for (int step = 0; step < steps; step++)
+                {
+                    cancellationToken.ThrowIfCancellationRequested();
+                    this.ConvertStride(step);
+                }
+            }
+
+            return this.pixelBuffer;
+        }
+
+        public void Dispose()
+        {
+            if (this.componentProcessors != null)
+            {
+                foreach (JpegComponentPostProcessor8 cpp in this.componentProcessors)
+                {
+                    cpp.Dispose();
+                }
+            }
+        }
+
+        // TODO: docs, code formatting
+        private static readonly (int Num, int Denom)[] ScalingFactors = new (int, int)[]
+        {
+            /* upscaling factors */
+            // (16, 8),
+            // (15, 8),
+            // (14, 8),
+            // (13, 8),
+            // (12, 8),
+            // (11, 8),
+            // (10, 8),
+            // (9,  8),
+
+            /* no scaling */
+            (8,  8),
+
+            /* downscaling factors */
+            // (7,  8),     // 8 => 7
+            // (6,  8),     // 8 => 6
+            // (5,  8),     // 8 => 5
+            // (4,  8),     // 1/2 dct scaling - currently not supported
+            // (3,  8),     // 8 => 3
+            // (2,  8),     // 1/4 dct scaling - currently not supported
+            (1,  8),        // 1/8 dct scaling
+        };
+
+        /// <summary>
+        /// TODO: docs, code formatting
+        /// </summary>
+        /// <param name="iWidth">Initial image width.</param>
+        /// <param name="iHeight">Initial image height.</param>
+        /// <param name="tWidth">Target image width.</param>
+        /// <param name="tHeight">Target image height.</param>
+        private static (int Width, int Height, int ScaleDenominator) GetScaledImageDimensions(int iWidth, int iHeight, int tWidth, int tHeight)
+        {
+            int output_width = iWidth;
+            int output_height = iHeight;
+            int dct_scale = 8;
+
+            for (int i = 1; i < ScalingFactors.Length; i++)
+            {
+                (int num, int denom) = ScalingFactors[i];
+                int scaledw = (int)Numerics.DivideCeil((uint)(iWidth * num), (uint)denom);
+                int scaledh = (int)Numerics.DivideCeil((uint)(iHeight * num), (uint)denom);
+
+                if (scaledw < tWidth || scaledh < tHeight)
+                {
+                    dct_scale = 8 / ScalingFactors[i - 1].Num;
+                    break;
+                }
+
+                output_width = scaledw;
+                output_height = scaledh;
+            }
+
+            return (output_width, output_height, dct_scale);
+        }
+    }
+}

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

@@ -0,0 +1,21 @@
+// Copyright (c) Six Labors.
+// Licensed under the Apache License, Version 2.0.
+
+using System.Threading;
+using SixLabors.ImageSharp.Memory;
+using SixLabors.ImageSharp.PixelFormats;
+
+namespace SixLabors.ImageSharp.Formats.Jpeg.Components.Decoder
+{
+    // TODO: docs
+    internal abstract class SpectralConverter<TPixel> : SpectralConverter
+        where TPixel : unmanaged, IPixel<TPixel>
+    {
+        /// <summary>
+        /// Gets converted pixel buffer.
+        /// </summary>
+        /// <param name="cancellationToken">Cancellation token.</param>
+        /// <returns>Pixel buffer.</returns>
+        public abstract Buffer2D<TPixel> GetPixelBuffer(CancellationToken cancellationToken);
+    }
+}

src/ImageSharp/Formats/Jpeg/JpegDecoder.cs

@@ -3,6 +3,9 @@
 
 using System.IO;
 using System.Threading;
+using SixLabors.ImageSharp.Formats.Jpeg.Components.Decoder;
+using SixLabors.ImageSharp.IO;
+using SixLabors.ImageSharp.Memory;
 using SixLabors.ImageSharp.PixelFormats;
 
 namespace SixLabors.ImageSharp.Formats.Jpeg
@@ -29,6 +32,27 @@ namespace SixLabors.ImageSharp.Formats.Jpeg
         public Image Decode(Configuration configuration, Stream stream, CancellationToken cancellationToken)
             => this.Decode<Rgb24>(configuration, stream, cancellationToken);
 
+        // TODO: this implementation is experimental
+        public Image<TPixel> experimental__DecodeInto<TPixel>(Configuration configuration, Stream stream, Size targetSize, CancellationToken cancellationToken)
+            where TPixel : unmanaged, IPixel<TPixel>
+        {
+            Guard.NotNull(stream, nameof(stream));
+
+            using var decoder = new JpegDecoderCore(configuration, this);
+
+            // Copied from ImageDecoderUtilities.cs
+            // TODO: interface cast druing exception handling and code duplication is not okay
+            using var bufferedReadStream = new BufferedReadStream(configuration, stream);
+            try
+            {
+                return decoder.experimental__DecodeInto<TPixel>(bufferedReadStream, targetSize, cancellationToken);
+            }
+            catch (InvalidMemoryOperationException ex)
+            {
+                throw new InvalidImageContentException(((IImageDecoderInternals)decoder).Dimensions, ex);
+            }
+        }
+
         /// <inheritdoc/>
         public IImageInfo Identify(Configuration configuration, Stream stream, CancellationToken cancellationToken)
         {

src/ImageSharp/Formats/Jpeg/JpegDecoderCore.cs

@@ -182,13 +182,11 @@ namespace SixLabors.ImageSharp.Formats.Jpeg
             return new JpegFileMarker(marker[1], stream.Position - 2, true);
         }
 
-        /// <inheritdoc/>
+        // TODO: docs
-        public Image<TPixel> Decode<TPixel>(BufferedReadStream stream, CancellationToken cancellationToken)
+        private Image<TPixel> Decode<TPixel>(BufferedReadStream stream, SpectralConverter<TPixel> converter, CancellationToken cancellationToken)
             where TPixel : unmanaged, IPixel<TPixel>
         {
-            using var spectralConverter = new SpectralConverter<TPixel>(this.Configuration);
+            var scanDecoder = new HuffmanScanDecoder(stream, converter, cancellationToken);
-
-            var scanDecoder = new HuffmanScanDecoder(stream, spectralConverter, cancellationToken);
 
             this.ParseStream(stream, scanDecoder, cancellationToken);
             this.InitExifProfile();
@@ -199,10 +197,26 @@ namespace SixLabors.ImageSharp.Formats.Jpeg
 
             return new Image<TPixel>(
                 this.Configuration,
-                spectralConverter.GetPixelBuffer(cancellationToken),
+                converter.GetPixelBuffer(cancellationToken),
                 this.Metadata);
         }
 
+        // TODO: docs
+        public Image<TPixel> experimental__DecodeInto<TPixel>(BufferedReadStream stream, Size targetSize, CancellationToken cancellationToken)
+            where TPixel : unmanaged, IPixel<TPixel>
+        {
+            using var converter = new ResizingSpectralConverter<TPixel>(this.Configuration, targetSize);
+            return this.Decode(stream, converter, cancellationToken);
+        }
+
+        /// <inheritdoc/>
+        public Image<TPixel> Decode<TPixel>(BufferedReadStream stream, CancellationToken cancellationToken)
+            where TPixel : unmanaged, IPixel<TPixel>
+        {
+            using var converter = new DirectSpectralConverter<TPixel>(this.Configuration);
+            return this.Decode(stream, converter, cancellationToken);
+        }
+
         /// <inheritdoc/>
         public IImageInfo Identify(BufferedReadStream stream, CancellationToken cancellationToken)
         {

src/ImageSharp/Formats/Tiff/Compression/Decompressors/GrayJpegSpectralConverter.cs

@@ -11,7 +11,7 @@ namespace SixLabors.ImageSharp.Formats.Tiff.Compression.Decompressors
     /// Spectral converter for gray TIFF's which use the JPEG compression.
     /// </summary>
     /// <typeparam name="TPixel">The type of the pixel.</typeparam>
-    internal sealed class GrayJpegSpectralConverter<TPixel> : SpectralConverter<TPixel>
+    internal sealed class GrayJpegSpectralConverter<TPixel> : DirectSpectralConverter<TPixel>
         where TPixel : unmanaged, IPixel<TPixel>
     {
         /// <summary>

src/ImageSharp/Formats/Tiff/Compression/Decompressors/JpegTiffCompression.cs

@@ -59,7 +59,7 @@ namespace SixLabors.ImageSharp.Formats.Tiff.Compression.Decompressors
                     case TiffPhotometricInterpretation.BlackIsZero:
                     case TiffPhotometricInterpretation.WhiteIsZero:
                     {
-                        using SpectralConverter<L8> spectralConverterGray = new GrayJpegSpectralConverter<L8>(this.configuration);
+                        using DirectSpectralConverter<L8> spectralConverterGray = new GrayJpegSpectralConverter<L8>(this.configuration);
                         var scanDecoderGray = new HuffmanScanDecoder(stream, spectralConverterGray, CancellationToken.None);
                         jpegDecoder.LoadTables(this.jpegTables, scanDecoderGray);
                         jpegDecoder.ParseStream(stream, scanDecoderGray, CancellationToken.None);
@@ -74,8 +74,8 @@ namespace SixLabors.ImageSharp.Formats.Tiff.Compression.Decompressors
                     case TiffPhotometricInterpretation.YCbCr:
                     case TiffPhotometricInterpretation.Rgb:
                     {
-                        using SpectralConverter<Rgb24> spectralConverter = this.photometricInterpretation == TiffPhotometricInterpretation.YCbCr ?
+                        using DirectSpectralConverter<Rgb24> spectralConverter = this.photometricInterpretation == TiffPhotometricInterpretation.YCbCr ?
-                            new RgbJpegSpectralConverter<Rgb24>(this.configuration) : new SpectralConverter<Rgb24>(this.configuration);
+                            new RgbJpegSpectralConverter<Rgb24>(this.configuration) : new DirectSpectralConverter<Rgb24>(this.configuration);
                         var scanDecoder = new HuffmanScanDecoder(stream, spectralConverter, CancellationToken.None);
                         jpegDecoder.LoadTables(this.jpegTables, scanDecoder);
                         jpegDecoder.ParseStream(stream, scanDecoder, CancellationToken.None);

src/ImageSharp/Formats/Tiff/Compression/Decompressors/RgbJpegSpectralConverter.cs

@@ -12,7 +12,7 @@ namespace SixLabors.ImageSharp.Formats.Tiff.Compression.Decompressors
     /// The jpeg data should be always treated as RGB color space.
     /// </summary>
     /// <typeparam name="TPixel">The type of the pixel.</typeparam>
-    internal sealed class RgbJpegSpectralConverter<TPixel> : SpectralConverter<TPixel>
+    internal sealed class RgbJpegSpectralConverter<TPixel> : DirectSpectralConverter<TPixel>
         where TPixel : unmanaged, IPixel<TPixel>
     {
         /// <summary>

tests/ImageSharp.Tests/Formats/Jpg/SpectralToPixelConversionTests.cs

@@ -44,7 +44,7 @@ namespace SixLabors.ImageSharp.Tests.Formats.Jpg
             using var bufferedStream = new BufferedReadStream(Configuration.Default, ms);
 
             // Decoding
-            using var converter = new SpectralConverter<TPixel>(Configuration.Default);
+            using var converter = new DirectSpectralConverter<TPixel>(Configuration.Default);
             using var decoder = new JpegDecoderCore(Configuration.Default, new JpegDecoder());
             var scanDecoder = new HuffmanScanDecoder(bufferedStream, converter, cancellationToken: default);
             decoder.ParseStream(bufferedStream, scanDecoder, cancellationToken: default);