Merge pull request #1702 from br3aker/jpeg-decoder-refactoring

Jpeg decoder refactoring, fixed 1693

Author: JimBobSquarePants

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

@@ -18,11 +18,24 @@ internal class HuffmanScanDecoder
     {
         private readonly BufferedReadStream stream;
 
-        // Frame related
+        /// <summary>
+        /// <see cref="JpegFrame"/> instance containing decoding-related information.
+        /// </summary>
         private JpegFrame frame;
+
+        /// <summary>
+        /// Shortcut for <see cref="frame"/>.Components.
+        /// </summary>
         private JpegComponent[] components;
 
-        // The restart interval.
+        /// <summary>
+        /// Number of component in the current scan.
+        /// </summary>
+        private int componentsCount;
+
+        /// <summary>
+        /// The reset interval determined by RST markers.
+        /// </summary>
         private int restartInterval;
 
         // How many mcu's are left to do.
@@ -31,6 +44,16 @@ internal class HuffmanScanDecoder
         // The End-Of-Block countdown for ending the sequence prematurely when the remaining coefficients are zero.
         private int eobrun;
 
+        /// <summary>
+        /// The DC Huffman tables.
+        /// </summary>
+        private readonly HuffmanTable[] dcHuffmanTables;
+
+        /// <summary>
+        /// The AC Huffman tables
+        /// </summary>
+        private readonly HuffmanTable[] acHuffmanTables;
+
         // The unzig data.
         private ZigZag dctZigZag;
 
@@ -55,14 +78,16 @@ public HuffmanScanDecoder(
             this.stream = stream;
             this.spectralConverter = converter;
             this.cancellationToken = cancellationToken;
-        }
 
-        // huffman tables
-        public HuffmanTable[] DcHuffmanTables { get; set; }
-
-        public HuffmanTable[] AcHuffmanTables { get; set; }
+            // TODO: this is actually a variable value depending on component count
+            const int maxTables = 4;
+            this.dcHuffmanTables = new HuffmanTable[maxTables];
+            this.acHuffmanTables = new HuffmanTable[maxTables];
+        }
 
-        // Reset interval
+        /// <summary>
+        /// Sets reset interval determined by RST markers.
+        /// </summary>
         public int ResetInterval
         {
             set
@@ -72,9 +97,6 @@ public int ResetInterval
             }
         }
 
-        // The number of interleaved components.
-        public int ComponentsLength { get; set; }
-
         // The spectral selection start.
         public int SpectralStart { get; set; }
 
@@ -90,10 +112,12 @@ public int ResetInterval
         /// <summary>
         /// Decodes the entropy coded data.
         /// </summary>
-        public void ParseEntropyCodedData()
+        public void ParseEntropyCodedData(int componentCount)
         {
             this.cancellationToken.ThrowIfCancellationRequested();
 
+            this.componentsCount = componentCount;
+
             this.scanBuffer = new HuffmanScanBuffer(this.stream);
 
             bool fullScan = this.frame.Progressive || this.frame.MultiScan;
@@ -124,7 +148,7 @@ public void InjectFrameData(JpegFrame frame, IRawJpegData jpegData)
 
         private void ParseBaselineData()
         {
-            if (this.ComponentsLength == this.frame.ComponentCount)
+            if (this.componentsCount == this.frame.ComponentCount)
             {
                 this.ParseBaselineDataInterleaved();
             }
@@ -143,13 +167,13 @@ private void ParseBaselineDataInterleaved()
             ref HuffmanScanBuffer buffer = ref this.scanBuffer;
 
             // Pre-derive the huffman table to avoid in-loop checks.
-            for (int i = 0; i < this.ComponentsLength; i++)
+            for (int i = 0; i < this.componentsCount; i++)
             {
                 int order = this.frame.ComponentOrder[i];
                 JpegComponent component = this.components[order];
 
-                ref HuffmanTable dcHuffmanTable = ref this.DcHuffmanTables[component.DCHuffmanTableId];
-                ref HuffmanTable acHuffmanTable = ref this.AcHuffmanTables[component.ACHuffmanTableId];
+                ref HuffmanTable dcHuffmanTable = ref this.dcHuffmanTables[component.DCHuffmanTableId];
+                ref HuffmanTable acHuffmanTable = ref this.acHuffmanTables[component.ACHuffmanTableId];
                 dcHuffmanTable.Configure();
                 acHuffmanTable.Configure();
             }
@@ -163,13 +187,13 @@ private void ParseBaselineDataInterleaved()
                 {
                     // Scan an interleaved mcu... process components in order
                     int mcuCol = mcu % mcusPerLine;
-                    for (int k = 0; k < this.ComponentsLength; k++)
+                    for (int k = 0; k < this.componentsCount; k++)
                     {
                         int order = this.frame.ComponentOrder[k];
                         JpegComponent component = this.components[order];
 
-                        ref HuffmanTable dcHuffmanTable = ref this.DcHuffmanTables[component.DCHuffmanTableId];
-                        ref HuffmanTable acHuffmanTable = ref this.AcHuffmanTables[component.ACHuffmanTableId];
+                        ref HuffmanTable dcHuffmanTable = ref this.dcHuffmanTables[component.DCHuffmanTableId];
+                        ref HuffmanTable acHuffmanTable = ref this.acHuffmanTables[component.ACHuffmanTableId];
 
                         int h = component.HorizontalSamplingFactor;
                         int v = component.VerticalSamplingFactor;
@@ -221,8 +245,8 @@ private void ParseBaselineDataNonInterleaved()
             int w = component.WidthInBlocks;
             int h = component.HeightInBlocks;
 
-            ref HuffmanTable dcHuffmanTable = ref this.DcHuffmanTables[component.DCHuffmanTableId];
-            ref HuffmanTable acHuffmanTable = ref this.AcHuffmanTables[component.ACHuffmanTableId];
+            ref HuffmanTable dcHuffmanTable = ref this.dcHuffmanTables[component.DCHuffmanTableId];
+            ref HuffmanTable acHuffmanTable = ref this.acHuffmanTables[component.ACHuffmanTableId];
             dcHuffmanTable.Configure();
             acHuffmanTable.Configure();
 
@@ -272,7 +296,7 @@ private void CheckProgressiveData()
                 }
 
                 // AC scans may have only one component.
-                if (this.ComponentsLength != 1)
+                if (this.componentsCount != 1)
                 {
                     invalid = true;
                 }
@@ -304,7 +328,7 @@ private void ParseProgressiveData()
         {
             this.CheckProgressiveData();
 
-            if (this.ComponentsLength == 1)
+            if (this.componentsCount == 1)
             {
                 this.ParseProgressiveDataNonInterleaved();
             }
@@ -323,11 +347,11 @@ private void ParseProgressiveDataInterleaved()
             ref HuffmanScanBuffer buffer = ref this.scanBuffer;
 
             // Pre-derive the huffman table to avoid in-loop checks.
-            for (int k = 0; k < this.ComponentsLength; k++)
+            for (int k = 0; k < this.componentsCount; k++)
             {
                 int order = this.frame.ComponentOrder[k];
                 JpegComponent component = this.components[order];
-                ref HuffmanTable dcHuffmanTable = ref this.DcHuffmanTables[component.DCHuffmanTableId];
+                ref HuffmanTable dcHuffmanTable = ref this.dcHuffmanTables[component.DCHuffmanTableId];
                 dcHuffmanTable.Configure();
             }
 
@@ -338,11 +362,11 @@ private void ParseProgressiveDataInterleaved()
                     // Scan an interleaved mcu... process components in order
                     int mcuRow = mcu / mcusPerLine;
                     int mcuCol = mcu % mcusPerLine;
-                    for (int k = 0; k < this.ComponentsLength; k++)
+                    for (int k = 0; k < this.componentsCount; k++)
                     {
                         int order = this.frame.ComponentOrder[k];
                         JpegComponent component = this.components[order];
-                        ref HuffmanTable dcHuffmanTable = ref this.DcHuffmanTables[component.DCHuffmanTableId];
+                        ref HuffmanTable dcHuffmanTable = ref this.dcHuffmanTables[component.DCHuffmanTableId];
 
                         int h = component.HorizontalSamplingFactor;
                         int v = component.VerticalSamplingFactor;
@@ -390,7 +414,7 @@ private void ParseProgressiveDataNonInterleaved()
 
             if (this.SpectralStart == 0)
             {
-                ref HuffmanTable dcHuffmanTable = ref this.DcHuffmanTables[component.DCHuffmanTableId];
+                ref HuffmanTable dcHuffmanTable = ref this.dcHuffmanTables[component.DCHuffmanTableId];
                 dcHuffmanTable.Configure();
 
                 for (int j = 0; j < h; j++)
@@ -418,7 +442,7 @@ ref Unsafe.Add(ref blockRef, i),
             }
             else
             {
-                ref HuffmanTable acHuffmanTable = ref this.AcHuffmanTables[component.ACHuffmanTableId];
+                ref HuffmanTable acHuffmanTable = ref this.acHuffmanTables[component.ACHuffmanTableId];
                 acHuffmanTable.Configure();
 
                 for (int j = 0; j < h; j++)
@@ -722,5 +746,19 @@ private bool HandleRestart()
 
             return false;
         }
+
+        /// <summary>
+        /// Build the huffman table using code lengths and code values.
+        /// </summary>
+        /// <param name="type">Table type.</param>
+        /// <param name="index">Table index.</param>
+        /// <param name="codeLengths">Code lengths.</param>
+        /// <param name="values">Code values.</param>
+        [MethodImpl(InliningOptions.ShortMethod)]
+        public void BuildHuffmanTable(int type, int index, ReadOnlySpan<byte> codeLengths, ReadOnlySpan<byte> values)
+        {
+            HuffmanTable[] tables = type == 0 ? this.dcHuffmanTables : this.acHuffmanTables;
+            tables[index] = new HuffmanTable(codeLengths, values);
+        }
     }
 }

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

@@ -11,26 +11,11 @@ namespace SixLabors.ImageSharp.Formats.Jpeg.Components.Decoder
     /// </summary>
     internal interface IRawJpegData : IDisposable
     {
-        /// <summary>
-        /// Gets the image size in pixels.
-        /// </summary>
-        Size ImageSizeInPixels { get; }
-
-        /// <summary>
-        /// Gets the number of components.
-        /// </summary>
-        int ComponentCount { get; }
-
         /// <summary>
         /// Gets the color space
         /// </summary>
         JpegColorSpace ColorSpace { get; }
 
-        /// <summary>
-        /// Gets the number of bits used for precision.
-        /// </summary>
-        int Precision { get; }
-
         /// <summary>
         /// Gets the components.
         /// </summary>
@@ -41,4 +26,4 @@ internal interface IRawJpegData : IDisposable
         /// </summary>
         Block8x8F[] QuantizationTables { get; }
     }
-}
+}

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

@@ -38,11 +38,6 @@ internal struct JpegBlockPostProcessor
         /// </summary>
         private Size subSamplingDivisors;
 
-        /// <summary>
-        /// Defines the maximum value derived from the bitdepth.
-        /// </summary>
-        private readonly int maximumValue;
-
         /// <summary>
         /// Initializes a new instance of the <see cref="JpegBlockPostProcessor"/> struct.
         /// </summary>
@@ -53,7 +48,6 @@ public JpegBlockPostProcessor(IRawJpegData decoder, IJpegComponent component)
             int qtIndex = component.QuantizationTableIndex;
             this.DequantiazationTable = ZigZag.CreateDequantizationTable(ref decoder.QuantizationTables[qtIndex]);
             this.subSamplingDivisors = component.SubSamplingDivisors;
-            this.maximumValue = (int)MathF.Pow(2, decoder.Precision) - 1;
 
             this.SourceBlock = default;
             this.WorkspaceBlock1 = default;

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

@@ -106,20 +106,24 @@ public void Dispose()
             this.SpectralBlocks = null;
         }
 
-        public void Init()
+        /// <summary>
+        /// Initializes component for future buffers initialization.
+        /// </summary>
+        /// <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(int maxSubFactorH, int maxSubFactorV)
         {
             this.WidthInBlocks = (int)MathF.Ceiling(
-                MathF.Ceiling(this.Frame.PixelWidth / 8F) * this.HorizontalSamplingFactor / this.Frame.MaxHorizontalFactor);
+                MathF.Ceiling(this.Frame.PixelWidth / 8F) * this.HorizontalSamplingFactor / maxSubFactorH);
 
             this.HeightInBlocks = (int)MathF.Ceiling(
-                MathF.Ceiling(this.Frame.PixelHeight / 8F) * this.VerticalSamplingFactor / this.Frame.MaxVerticalFactor);
+                MathF.Ceiling(this.Frame.PixelHeight / 8F) * this.VerticalSamplingFactor / maxSubFactorV);
 
             int blocksPerLineForMcu = this.Frame.McusPerLine * this.HorizontalSamplingFactor;
             int blocksPerColumnForMcu = this.Frame.McusPerColumn * this.VerticalSamplingFactor;
             this.SizeInBlocks = new Size(blocksPerLineForMcu, blocksPerColumnForMcu);
 
-            JpegComponent c0 = this.Frame.Components[0];
-            this.SubSamplingDivisors = c0.SamplingFactors.DivideBy(this.SamplingFactors);
+            this.SubSamplingDivisors = new Size(maxSubFactorH, maxSubFactorV).DivideBy(this.SamplingFactors);
 
             if (this.SubSamplingDivisors.Width == 0 || this.SubSamplingDivisors.Height == 0)
             {

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

@@ -21,11 +21,18 @@ internal class JpegComponentPostProcessor : IDisposable
         /// </summary>
         private readonly Size blockAreaSize;
 
+        /// <summary>
+        /// Jpeg frame instance containing required decoding metadata.
+        /// </summary>
+        private readonly JpegFrame frame;
+
         /// <summary>
         /// Initializes a new instance of the <see cref="JpegComponentPostProcessor"/> class.
         /// </summary>
-        public JpegComponentPostProcessor(MemoryAllocator memoryAllocator, IRawJpegData rawJpeg, Size postProcessorBufferSize, IJpegComponent component)
+        public JpegComponentPostProcessor(MemoryAllocator memoryAllocator, JpegFrame frame, IRawJpegData rawJpeg, Size postProcessorBufferSize, IJpegComponent component)
         {
+            this.frame = frame;
+
             this.Component = component;
             this.RawJpeg = rawJpeg;
             this.blockAreaSize = this.Component.SubSamplingDivisors * 8;
@@ -70,7 +77,8 @@ public void CopyBlocksToColorBuffer(int step)
             Buffer2D<Block8x8> spectralBuffer = this.Component.SpectralBlocks;
 
             var blockPp = new JpegBlockPostProcessor(this.RawJpeg, this.Component);
-            float maximumValue = MathF.Pow(2, this.RawJpeg.Precision) - 1;
+
+            float maximumValue = this.frame.MaxColorChannelValue;
 
             int destAreaStride = this.ColorBuffer.Width;