Merge pull request #1706 from br3aker/jpeg-quantization-metadata

Jpeg quantization metadata

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

@@ -830,5 +830,46 @@ namespace SixLabors.ImageSharp.Formats.Jpeg.Components
                 d.V7R.W = this.V7R.W;
             }
         }
+
+        /// <summary>
+        /// Compares entire 8x8 block to a single scalar value.
+        /// </summary>
+        /// <param name="value">Value to compare to.</param>
+        public bool EqualsToScalar(int value)
+        {
+#if SUPPORTS_RUNTIME_INTRINSICS
+            if (Avx2.IsSupported)
+            {
+                const int equalityMask = unchecked((int)0b1111_1111_1111_1111_1111_1111_1111_1111);
+
+                var targetVector = Vector256.Create(value);
+                ref Vector256<float> blockStride = ref this.V0;
+
+                for (int i = 0; i < RowCount; i++)
+                {
+                    Vector256<int> areEqual = Avx2.CompareEqual(Avx.ConvertToVector256Int32WithTruncation(Unsafe.Add(ref this.V0, i)), targetVector);
+                    if (Avx2.MoveMask(areEqual.AsByte()) != equalityMask)
+                    {
+                        return false;
+                    }
+                }
+
+                return true;
+            }
+#endif
+            {
+                ref float scalars = ref Unsafe.As<Block8x8F, float>(ref this);
+
+                for (int i = 0; i < Size; i++)
+                {
+                    if ((int)Unsafe.Add(ref scalars, i) != value)
+                    {
+                        return false;
+                    }
+                }
+
+                return true;
+            }
+        }
     }
 }

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

@@ -32,7 +32,7 @@ namespace SixLabors.ImageSharp.Formats.Jpeg.Components.Decoder
 
             if (quantizationTableIndex > 3)
             {
-                JpegThrowHelper.ThrowBadQuantizationTable();
+                JpegThrowHelper.ThrowBadQuantizationTableIndex(quantizationTableIndex);
             }
 
             this.QuantizationTableIndex = quantizationTableIndex;

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

@@ -1,144 +0,0 @@
-// Copyright (c) Six Labors.
-// Licensed under the Apache License, Version 2.0.
-
-namespace SixLabors.ImageSharp.Formats.Jpeg.Components.Decoder
-{
-    /// <summary>
-    /// Provides methods to evaluate the quality of an image.
-    /// Ported from <see href="https://github.com/ImageMagick/ImageMagick/blob/f362c02083d27211b913c6e44794f0ac6edaf2bd/coders/jpeg.c#L855"/>
-    /// </summary>
-    internal static class QualityEvaluator
-    {
-        private static readonly int[] Hash = new int[101]
-        {
-            1020, 1015,  932,  848,  780,  735,  702,  679,  660,  645,
-            632,  623,  613,  607,  600,  594,  589,  585,  581,  571,
-            555,  542,  529,  514,  494,  474,  457,  439,  424,  410,
-            397,  386,  373,  364,  351,  341,  334,  324,  317,  309,
-            299,  294,  287,  279,  274,  267,  262,  257,  251,  247,
-            243,  237,  232,  227,  222,  217,  213,  207,  202,  198,
-            192,  188,  183,  177,  173,  168,  163,  157,  153,  148,
-            143,  139,  132,  128,  125,  119,  115,  108,  104,   99,
-            94,   90,   84,   79,   74,   70,   64,   59,   55,   49,
-            45,   40,   34,   30,   25,   20,   15,   11,    6,    4,
-            0
-        };
-
-        private static readonly int[] Sums = new int[101]
-        {
-            32640, 32635, 32266, 31495, 30665, 29804, 29146, 28599, 28104,
-            27670, 27225, 26725, 26210, 25716, 25240, 24789, 24373, 23946,
-            23572, 22846, 21801, 20842, 19949, 19121, 18386, 17651, 16998,
-            16349, 15800, 15247, 14783, 14321, 13859, 13535, 13081, 12702,
-            12423, 12056, 11779, 11513, 11135, 10955, 10676, 10392, 10208,
-            9928,  9747,  9564,  9369,  9193,  9017,  8822,  8639,  8458,
-            8270,  8084,  7896,  7710,  7527,  7347,  7156,  6977,  6788,
-            6607,  6422,  6236,  6054,  5867,  5684,  5495,  5305,  5128,
-            4945,  4751,  4638,  4442,  4248,  4065,  3888,  3698,  3509,
-            3326,  3139,  2957,  2775,  2586,  2405,  2216,  2037,  1846,
-            1666,  1483,  1297,  1109,   927,   735,   554,   375,   201,
-            128,     0
-        };
-
-        private static readonly int[] Hash1 = new int[101]
-        {
-            510,  505,  422,  380,  355,  338,  326,  318,  311,  305,
-            300,  297,  293,  291,  288,  286,  284,  283,  281,  280,
-            279,  278,  277,  273,  262,  251,  243,  233,  225,  218,
-            211,  205,  198,  193,  186,  181,  177,  172,  168,  164,
-            158,  156,  152,  148,  145,  142,  139,  136,  133,  131,
-            129,  126,  123,  120,  118,  115,  113,  110,  107,  105,
-            102,  100,   97,   94,   92,   89,   87,   83,   81,   79,
-            76,   74,   70,   68,   66,   63,   61,   57,   55,   52,
-            50,   48,   44,   42,   39,   37,   34,   31,   29,   26,
-            24,   21,   18,   16,   13,   11,    8,    6,    3,    2,
-            0
-        };
-
-        private static readonly int[] Sums1 = new int[101]
-        {
-            16320, 16315, 15946, 15277, 14655, 14073, 13623, 13230, 12859,
-            12560, 12240, 11861, 11456, 11081, 10714, 10360, 10027,  9679,
-            9368,  9056,  8680,  8331,  7995,  7668,  7376,  7084,  6823,
-            6562,  6345,  6125,  5939,  5756,  5571,  5421,  5240,  5086,
-            4976,  4829,  4719,  4616,  4463,  4393,  4280,  4166,  4092,
-            3980,  3909,  3835,  3755,  3688,  3621,  3541,  3467,  3396,
-            3323,  3247,  3170,  3096,  3021,  2952,  2874,  2804,  2727,
-            2657,  2583,  2509,  2437,  2362,  2290,  2211,  2136,  2068,
-            1996,  1915,  1858,  1773,  1692,  1620,  1552,  1477,  1398,
-            1326,  1251,  1179,  1109,  1031,   961,   884,   814,   736,
-            667,   592,   518,   441,   369,   292,   221,   151,    86,
-            64,     0
-        };
-
-        /// <summary>
-        /// Returns an estimated quality of the image based on the quantization tables.
-        /// </summary>
-        /// <param name="quantizationTables">The quantization tables.</param>
-        /// <returns>The <see cref="int"/>.</returns>
-        public static int EstimateQuality(Block8x8F[] quantizationTables)
-        {
-            int quality = 75;
-            float sum = 0;
-
-            for (int i = 0; i < quantizationTables.Length; i++)
-            {
-                ref Block8x8F qTable = ref quantizationTables[i];
-
-                if (!qTable.Equals(default))
-                {
-                    for (int j = 0; j < Block8x8F.Size; j++)
-                    {
-                        sum += qTable[j];
-                    }
-                }
-            }
-
-            ref Block8x8F qTable0 = ref quantizationTables[0];
-            ref Block8x8F qTable1 = ref quantizationTables[1];
-
-            if (!qTable0.Equals(default))
-            {
-                if (!qTable1.Equals(default))
-                {
-                    quality = (int)(qTable0[2]
-                            + qTable0[53]
-                            + qTable1[0]
-                            + qTable1[Block8x8F.Size - 1]);
-
-                    for (int i = 0; i < 100; i++)
-                    {
-                        if (quality < Hash[i] && sum < Sums[i])
-                        {
-                            continue;
-                        }
-
-                        if (((quality <= Hash[i]) && (sum <= Sums[i])) || (i >= 50))
-                        {
-                            return i + 1;
-                        }
-                    }
-                }
-                else
-                {
-                    quality = (int)(qTable0[2] + qTable0[53]);
-
-                    for (int i = 0; i < 100; i++)
-                    {
-                        if (quality < Hash1[i] && sum < Sums1[i])
-                        {
-                            continue;
-                        }
-
-                        if (((quality <= Hash1[i]) && (sum <= Sums1[i])) || (i >= 50))
-                        {
-                            return i + 1;
-                        }
-                    }
-                }
-            }
-
-            return quality;
-        }
-    }
-}

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

@@ -0,0 +1,194 @@
+// Copyright (c) Six Labors.
+// Licensed under the Apache License, Version 2.0.
+
+using System;
+using System.Runtime.CompilerServices;
+
+namespace SixLabors.ImageSharp.Formats.Jpeg.Components
+{
+    /// <summary>
+    /// Provides methods and properties related to jpeg quantization.
+    /// </summary>
+    internal static class Quantization
+    {
+        /// <summary>
+        /// Upper bound (inclusive) for jpeg quality setting.
+        /// </summary>
+        public const int MaxQualityFactor = 100;
+
+        /// <summary>
+        /// Lower bound (inclusive) for jpeg quality setting.
+        /// </summary>
+        public const int MinQualityFactor = 1;
+
+        /// <summary>
+        /// Default JPEG quality for both luminance and chominance tables.
+        /// </summary>
+        public const int DefaultQualityFactor = 75;
+
+        /// <summary>
+        /// Represents lowest quality setting which can be estimated with enough confidence.
+        /// Any quality below it results in a highly compressed jpeg image
+        /// which shouldn't use standard itu quantization tables for re-encoding.
+        /// </summary>
+        public const int QualityEstimationConfidenceLowerThreshold = 25;
+
+        /// <summary>
+        /// Represents highest quality setting which can be estimated with enough confidence.
+        /// </summary>
+        public const int QualityEstimationConfidenceUpperThreshold = 98;
+
+        /// <summary>
+        /// Gets the unscaled luminance quantization table in zig-zag order. Each
+        /// encoder copies and scales the tables according to its quality parameter.
+        /// The values are derived from ITU section K.1 after converting from natural to
+        /// zig-zag order.
+        /// </summary>
+        // The C# compiler emits this as a compile-time constant embedded in the PE file.
+        // This is effectively compiled down to: return new ReadOnlySpan<byte>(&data, length)
+        // More details can be found: https://github.com/dotnet/roslyn/pull/24621
+        public static ReadOnlySpan<byte> UnscaledQuant_Luminance => new byte[]
+        {
+            16, 11, 12, 14, 12, 10, 16, 14, 13, 14, 18, 17, 16, 19, 24,
+            40, 26, 24, 22, 22, 24, 49, 35, 37, 29, 40, 58, 51, 61, 60,
+            57, 51, 56, 55, 64, 72, 92, 78, 64, 68, 87, 69, 55, 56, 80,
+            109, 81, 87, 95, 98, 103, 104, 103, 62, 77, 113, 121, 112,
+            100, 120, 92, 101, 103, 99,
+        };
+
+        /// <summary>
+        /// Gets the unscaled chrominance quantization table in zig-zag order. Each
+        /// encoder copies and scales the tables according to its quality parameter.
+        /// The values are derived from ITU section K.1 after converting from natural to
+        /// zig-zag order.
+        /// </summary>
+        // The C# compiler emits this as a compile-time constant embedded in the PE file.
+        // This is effectively compiled down to: return new ReadOnlySpan<byte>(&data, length)
+        // More details can be found: https://github.com/dotnet/roslyn/pull/24621
+        public static ReadOnlySpan<byte> UnscaledQuant_Chrominance => new byte[]
+        {
+            17, 18, 18, 24, 21, 24, 47, 26, 26, 47, 99, 66, 56, 66,
+            99, 99, 99, 99, 99, 99, 99, 99, 99, 99, 99, 99, 99, 99,
+            99, 99, 99, 99, 99, 99, 99, 99, 99, 99, 99, 99, 99, 99,
+            99, 99, 99, 99, 99, 99, 99, 99, 99, 99, 99, 99, 99, 99,
+            99, 99, 99, 99, 99, 99, 99, 99,
+        };
+
+        /// Ported from JPEGsnoop:
+        /// https://github.com/ImpulseAdventure/JPEGsnoop/blob/9732ee0961f100eb69bbff4a0c47438d5997abee/source/JfifDecode.cpp#L4570-L4694
+        /// <summary>
+        /// Estimates jpeg quality based on quantization table in zig-zag order.
+        /// </summary>
+        /// <remarks>
+        /// This technically can be used with any given table but internal decoder code uses ITU spec tables:
+        /// <see cref="UnscaledQuant_Luminance"/> and <see cref="UnscaledQuant_Chrominance"/>.
+        /// </remarks>
+        /// <param name="table">Input quantization table.</param>
+        /// <param name="target">Quantization to estimate against.</param>
+        /// <returns>Estimated quality</returns>
+        public static int EstimateQuality(ref Block8x8F table, ReadOnlySpan<byte> target)
+        {
+            // This method can be SIMD'ified if standard table is injected as Block8x8F.
+            // Or when we go to full-int16 spectral code implementation and inject both tables as Block8x8.
+            double comparePercent;
+            double sumPercent = 0;
+
+            // Corner case - all 1's => 100 quality
+            // It would fail to deduce using algorithm below without this check
+            if (table.EqualsToScalar(1))
+            {
+                // While this is a 100% to be 100 quality, any given table can be scaled to all 1's.
+                // According to jpeg creators, top of the line quality is 99, 100 is just a technical 'limit' which will affect result filesize drastically.
+                // Quality=100 shouldn't be used in usual use case.
+                return 100;
+            }
+
+            int quality;
+            for (int i = 0; i < Block8x8F.Size; i++)
+            {
+                float coeff = table[i];
+                int coeffInteger = (int)coeff;
+
+                // Coefficients are actually int16 casted to float numbers so there's no truncating error.
+                if (coeffInteger != 0)
+                {
+                    comparePercent = 100.0 * (table[i] / target[i]);
+                }
+                else
+                {
+                    // No 'valid' quantization table should contain zero at any position
+                    // while this is okay to decode with, it will throw DivideByZeroException at encoding proces stage.
+                    // Not sure what to do here, we can't throw as this technically correct
+                    // but this will screw up the encoder.
+                    comparePercent = 999.99;
+                }
+
+                sumPercent += comparePercent;
+            }
+
+            // Perform some statistical analysis of the quality factor
+            // to determine the likelihood of the current quantization
+            // table being a scaled version of the "standard" tables.
+            // If the variance is high, it is unlikely to be the case.
+            sumPercent /= 64.0;
+
+            // Generate the equivalent IJQ "quality" factor
+            if (sumPercent <= 100.0)
+            {
+                quality = (int)Math.Round((200 - sumPercent) / 2);
+            }
+            else
+            {
+                quality = (int)Math.Round(5000.0 / sumPercent);
+            }
+
+            return quality;
+        }
+
+        /// <summary>
+        /// Estimates jpeg quality based on quantization table in zig-zag order.
+        /// </summary>
+        /// <param name="luminanceTable">Luminance quantization table.</param>
+        /// <returns>Estimated quality</returns>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static int EstimateLuminanceQuality(ref Block8x8F luminanceTable)
+            => EstimateQuality(ref luminanceTable, UnscaledQuant_Luminance);
+
+        /// <summary>
+        /// Estimates jpeg quality based on quantization table in zig-zag order.
+        /// </summary>
+        /// <param name="chrominanceTable">Chrominance quantization table.</param>
+        /// <returns>Estimated quality</returns>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static int EstimateChrominanceQuality(ref Block8x8F chrominanceTable)
+            => EstimateQuality(ref chrominanceTable, UnscaledQuant_Chrominance);
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        private static int QualityToScale(int quality)
+        {
+            DebugGuard.MustBeBetweenOrEqualTo(quality, MinQualityFactor, MaxQualityFactor, nameof(quality));
+
+            return quality < 50 ? (5000 / quality) : (200 - (quality * 2));
+        }
+
+        private static Block8x8F ScaleQuantizationTable(int scale, ReadOnlySpan<byte> unscaledTable)
+        {
+            Block8x8F table = default;
+            for (int j = 0; j < Block8x8F.Size; j++)
+            {
+                int x = ((unscaledTable[j] * scale) + 50) / 100;
+                table[j] = Numerics.Clamp(x, 1, 255);
+            }
+
+            return table;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static Block8x8F ScaleLuminanceTable(int quality)
+            => ScaleQuantizationTable(scale: QualityToScale(quality), UnscaledQuant_Luminance);
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static Block8x8F ScaleChrominanceTable(int quality)
+            => ScaleQuantizationTable(scale: QualityToScale(quality), UnscaledQuant_Chrominance);
+    }
+}

src/ImageSharp/Formats/Jpeg/IJpegEncoderOptions.cs

@@ -9,11 +9,11 @@ namespace SixLabors.ImageSharp.Formats.Jpeg
     internal interface IJpegEncoderOptions
     {
         /// <summary>
-        /// Gets the quality, that will be used to encode the image. Quality
+        /// Gets or sets the quality, that will be used to encode the image. Quality
         /// index must be between 0 and 100 (compression from max to min).
+        /// Defaults to <value>75</value>.
         /// </summary>
-        /// <value>The quality of the jpg image from 0 to 100.</value>
-        int? Quality { get; }
+        public int? Quality { get; set; }
 
         /// <summary>
         /// Gets the subsample ration, that will be used to encode the image.

src/ImageSharp/Formats/Jpeg/JpegDecoder.cs

@@ -4,8 +4,6 @@
 using System.IO;
 using System.Threading;
 using System.Threading.Tasks;
-using SixLabors.ImageSharp.IO;
-using SixLabors.ImageSharp.Memory;
 using SixLabors.ImageSharp.PixelFormats;
 
 namespace SixLabors.ImageSharp.Formats.Jpeg

src/ImageSharp/Formats/Jpeg/JpegDecoderCore.cs

@@ -699,81 +699,95 @@ namespace SixLabors.ImageSharp.Formats.Jpeg
         /// </exception>
         private void ProcessDefineQuantizationTablesMarker(BufferedReadStream stream, int remaining)
         {
+            JpegMetadata jpegMetadata = this.Metadata.GetFormatMetadata(JpegFormat.Instance);
+
             while (remaining > 0)
             {
-                bool done = false;
-                remaining--;
+                // 1 byte: quantization table spec
+                // bit 0..3: table index (0..3)
+                // bit 4..7: table precision (0 = 8 bit, 1 = 16 bit)
                 int quantizationTableSpec = stream.ReadByte();
                 int tableIndex = quantizationTableSpec & 15;
+                int tablePrecision = quantizationTableSpec >> 4;
 
-                // Max index. 4 Tables max.
+                // Validate:
                 if (tableIndex > 3)
                 {
-                    JpegThrowHelper.ThrowBadQuantizationTable();
+                    JpegThrowHelper.ThrowBadQuantizationTableIndex(tableIndex);
                 }
 
-                switch (quantizationTableSpec >> 4)
+                remaining--;
+
+                // Decoding single 8x8 table
+                ref Block8x8F table = ref this.QuantizationTables[tableIndex];
+                switch (tablePrecision)
                 {
+                    // 8 bit values
                     case 0:
                     {
-                        // 8 bit values
+                        // Validate: 8 bit table needs exactly 64 bytes
                         if (remaining < 64)
                         {
-                            done = true;
-                            break;
+                            JpegThrowHelper.ThrowBadMarker(nameof(JpegConstants.Markers.DQT), remaining);
                         }
 
                         stream.Read(this.temp, 0, 64);
                         remaining -= 64;
 
-                        ref Block8x8F table = ref this.QuantizationTables[tableIndex];
                         for (int j = 0; j < 64; j++)
                         {
                             table[j] = this.temp[j];
                         }
+
+                        break;
                     }
 
-                    break;
+                    // 16 bit values
                     case 1:
                     {
-                        // 16 bit values
+                        // Validate: 16 bit table needs exactly 128 bytes
                         if (remaining < 128)
                         {
-                            done = true;
-                            break;
+                            JpegThrowHelper.ThrowBadMarker(nameof(JpegConstants.Markers.DQT), remaining);
                         }
 
                         stream.Read(this.temp, 0, 128);
                         remaining -= 128;
 
-                        ref Block8x8F table = ref this.QuantizationTables[tableIndex];
                         for (int j = 0; j < 64; j++)
                         {
                             table[j] = (this.temp[2 * j] << 8) | this.temp[(2 * j) + 1];
                         }
-                    }
 
-                    break;
+                        break;
+                    }
 
+                    // Unknown precision - error
                     default:
                     {
-                        JpegThrowHelper.ThrowBadQuantizationTable();
+                        JpegThrowHelper.ThrowBadQuantizationTablePrecision(tablePrecision);
                         break;
                     }
                 }
 
-                if (done)
+                // Estimating quality
+                switch (tableIndex)
                 {
-                    break;
-                }
-            }
+                    // luminance table
+                    case 0:
+                    {
+                        jpegMetadata.LuminanceQuality = Quantization.EstimateLuminanceQuality(ref table);
+                        break;
+                    }
 
-            if (remaining != 0)
-            {
-                JpegThrowHelper.ThrowBadMarker(nameof(JpegConstants.Markers.DQT), remaining);
+                    // chrominance table
+                    case 1:
+                    {
+                        jpegMetadata.ChrominanceQuality = Quantization.EstimateChrominanceQuality(ref table);
+                        break;
+                    }
+                }
             }
-
-            this.Metadata.GetFormatMetadata(JpegFormat.Instance).Quality = QualityEvaluator.EstimateQuality(this.QuantizationTables);
         }
 
         /// <summary>

src/ImageSharp/Formats/Jpeg/JpegEncoder.cs

@@ -13,11 +13,7 @@ namespace SixLabors.ImageSharp.Formats.Jpeg
     /// </summary>
     public sealed class JpegEncoder : IImageEncoder, IJpegEncoderOptions
     {
-        /// <summary>
-        /// Gets or sets the quality, that will be used to encode the image. Quality
-        /// index must be between 0 and 100 (compression from max to min).
-        /// Defaults to <value>75</value>.
-        /// </summary>
+        /// <inheritdoc/>
         public int? Quality { get; set; }
 
         /// <summary>

src/ImageSharp/Formats/Jpeg/JpegEncoderCore.cs

@@ -64,44 +64,6 @@ namespace SixLabors.ImageSharp.Formats.Jpeg
             this.colorType = options.ColorType;
         }
 
-        /// <summary>
-        /// Gets the unscaled quantization tables in zig-zag order. Each
-        /// encoder copies and scales the tables according to its quality parameter.
-        /// The values are derived from section K.1 after converting from natural to
-        /// zig-zag order.
-        /// </summary>
-        // The C# compiler emits this as a compile-time constant embedded in the PE file.
-        // This is effectively compiled down to: return new ReadOnlySpan<byte>(&data, length)
-        // More details can be found: https://github.com/dotnet/roslyn/pull/24621
-        private static ReadOnlySpan<byte> UnscaledQuant_Luminance => new byte[]
-        {
-            // Luminance.
-            16, 11, 12, 14, 12, 10, 16, 14, 13, 14, 18, 17, 16, 19, 24,
-            40, 26, 24, 22, 22, 24, 49, 35, 37, 29, 40, 58, 51, 61, 60,
-            57, 51, 56, 55, 64, 72, 92, 78, 64, 68, 87, 69, 55, 56, 80,
-            109, 81, 87, 95, 98, 103, 104, 103, 62, 77, 113, 121, 112,
-            100, 120, 92, 101, 103, 99,
-        };
-
-        /// <summary>
-        /// Gets the unscaled quantization tables in zig-zag order. Each
-        /// encoder copies and scales the tables according to its quality parameter.
-        /// The values are derived from section K.1 after converting from natural to
-        /// zig-zag order.
-        /// </summary>
-        // The C# compiler emits this as a compile-time constant embedded in the PE file.
-        // This is effectively compiled down to: return new ReadOnlySpan<byte>(&data, length)
-        // More details can be found: https://github.com/dotnet/roslyn/pull/24621
-        private static ReadOnlySpan<byte> UnscaledQuant_Chrominance => new byte[]
-        {
-            // Chrominance.
-            17, 18, 18, 24, 21, 24, 47, 26, 26, 47, 99, 66, 56, 66,
-            99, 99, 99, 99, 99, 99, 99, 99, 99, 99, 99, 99, 99, 99,
-            99, 99, 99, 99, 99, 99, 99, 99, 99, 99, 99, 99, 99, 99,
-            99, 99, 99, 99, 99, 99, 99, 99, 99, 99, 99, 99, 99, 99,
-            99, 99, 99, 99, 99, 99, 99, 99,
-        };
-
         /// <summary>
         /// Encode writes the image to the jpeg baseline format with the given options.
         /// </summary>
@@ -124,35 +86,14 @@ namespace SixLabors.ImageSharp.Formats.Jpeg
 
             this.outputStream = stream;
             ImageMetadata metadata = image.Metadata;
+            JpegMetadata jpegMetadata = metadata.GetJpegMetadata();
 
             // Compute number of components based on color type in options.
             int componentCount = (this.colorType == JpegColorType.Luminance) ? 1 : 3;
 
-            // System.Drawing produces identical output for jpegs with a quality parameter of 0 and 1.
-            int qlty = Numerics.Clamp(this.quality ?? metadata.GetJpegMetadata().Quality, 1, 100);
-            this.subsample ??= qlty >= 91 ? JpegSubsample.Ratio444 : JpegSubsample.Ratio420;
-
-            // Convert from a quality rating to a scaling factor.
-            int scale;
-            if (qlty < 50)
-            {
-                scale = 5000 / qlty;
-            }
-            else
-            {
-                scale = 200 - (qlty * 2);
-            }
-
+            // TODO: Right now encoder writes both quantization tables for grayscale images - we shouldn't do that
             // Initialize the quantization tables.
-            // TODO: This looks ugly, should we write chrominance table for luminance-only images?
-            // If not - this can code can be simplified
-            Block8x8F luminanceQuantTable = default;
-            Block8x8F chrominanceQuantTable = default;
-            InitQuantizationTable(0, scale, ref luminanceQuantTable);
-            if (componentCount > 1)
-            {
-                InitQuantizationTable(1, scale, ref chrominanceQuantTable);
-            }
+            this.InitQuantizationTables(componentCount, jpegMetadata, out Block8x8F luminanceQuantTable, out Block8x8F chrominanceQuantTable);
 
             // Write the Start Of Image marker.
             this.WriteApplicationHeader(metadata);
@@ -176,10 +117,12 @@ namespace SixLabors.ImageSharp.Formats.Jpeg
             var scanEncoder = new HuffmanScanEncoder(stream);
             if (this.colorType == JpegColorType.Luminance)
             {
+                // luminance quantization table only
                 scanEncoder.EncodeGrayscale(image, ref luminanceQuantTable, cancellationToken);
             }
             else
             {
+                // luminance and chrominance quantization tables
                 switch (this.subsample)
                 {
                     case JpegSubsample.Ratio444:
@@ -690,31 +633,49 @@ namespace SixLabors.ImageSharp.Formats.Jpeg
         }
 
         /// <summary>
-        /// Initializes quantization table.
+        /// Initializes quntization tables.
         /// </summary>
-        /// <param name="i">The quantization index.</param>
-        /// <param name="scale">The scaling factor.</param>
-        /// <param name="quant">The quantization table.</param>
-        private static void InitQuantizationTable(int i, int scale, ref Block8x8F quant)
+        /// <remarks>
+        /// We take quality values in a hierarchical order:
+        /// 1. Check if encoder has set quality
+        /// 2. Check if metadata has special table for encoding
+        /// 3. Check if metadata has set quality
+        /// 4. Take default quality value - 75
+        /// </remarks>
+        /// <param name="componentCount">Color components count.</param>
+        /// <param name="metadata">Jpeg metadata instance.</param>
+        /// <param name="luminanceQuantTable">Output luminance quantization table.</param>
+        /// <param name="chrominanceQuantTable">Output chrominance quantization table.</param>
+        private void InitQuantizationTables(int componentCount, JpegMetadata metadata, out Block8x8F luminanceQuantTable, out Block8x8F chrominanceQuantTable)
         {
-            DebugGuard.MustBeBetweenOrEqualTo(i, 0, 1, nameof(i));
-            ReadOnlySpan<byte> unscaledQuant = (i == 0) ? UnscaledQuant_Luminance : UnscaledQuant_Chrominance;
+            int lumaQuality;
+            int chromaQuality;
+            if (this.quality.HasValue)
+            {
+                lumaQuality = this.quality.Value;
+                chromaQuality = this.quality.Value;
+            }
+            else
+            {
+                lumaQuality = metadata.LuminanceQuality;
+                chromaQuality = metadata.ChrominanceQuality;
+            }
 
-            for (int j = 0; j < Block8x8F.Size; j++)
+            // Luminance
+            lumaQuality = Numerics.Clamp(lumaQuality, 1, 100);
+            luminanceQuantTable = Quantization.ScaleLuminanceTable(lumaQuality);
+
+            // Chrominance
+            chrominanceQuantTable = default;
+            if (componentCount > 1)
             {
-                int x = unscaledQuant[j];
-                x = ((x * scale) + 50) / 100;
-                if (x < 1)
-                {
-                    x = 1;
-                }
+                chromaQuality = Numerics.Clamp(chromaQuality, 1, 100);
+                chrominanceQuantTable = Quantization.ScaleChrominanceTable(chromaQuality);
 
-                if (x > 255)
+                if (!this.subsample.HasValue)
                 {
-                    x = 255;
+                    this.subsample = chromaQuality >= 91 ? JpegSubsample.Ratio444 : JpegSubsample.Ratio420;
                 }
-
-                quant[j] = x;
             }
         }
     }

src/ImageSharp/Formats/Jpeg/JpegMetadata.cs

@@ -1,6 +1,9 @@
 // Copyright (c) Six Labors.
 // Licensed under the Apache License, Version 2.0.
 
+using System;
+using SixLabors.ImageSharp.Formats.Jpeg.Components;
+
 namespace SixLabors.ImageSharp.Formats.Jpeg
 {
     /// <summary>
@@ -8,6 +11,16 @@ 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>
@@ -21,18 +34,80 @@ namespace SixLabors.ImageSharp.Formats.Jpeg
         /// <param name="other">The metadata to create an instance from.</param>
         private JpegMetadata(JpegMetadata other)
         {
-            this.Quality = other.Quality;
             this.ColorType = other.ColorType;
+
+            this.luminanceQuality = other.luminanceQuality;
+            this.chrominanceQuality = other.chrominanceQuality;
         }
 
         /// <summary>
-        /// Gets or sets the encoded quality.
+        /// Gets or sets the jpeg luminance quality.
+        /// </summary>
+        /// <remarks>
+        /// This value might not be accurate if it was calculated during jpeg decoding
+        /// with non-complient ITU quantization tables.
+        /// </remarks>
+        internal int LuminanceQuality
+        {
+            get => this.luminanceQuality ?? Quantization.DefaultQualityFactor;
+            set => this.luminanceQuality = value;
+        }
+
+        /// <summary>
+        /// Gets or sets the jpeg chrominance quality.
         /// </summary>
-        public int Quality { get; set; } = 75;
+        /// <remarks>
+        /// This value might not be accurate if it was calculated during jpeg decoding
+        /// with non-complient ITU quantization tables.
+        /// </remarks>
+        internal int ChrominanceQuality
+        {
+            get => this.chrominanceQuality ?? Quantization.DefaultQualityFactor;
+            set => this.chrominanceQuality = value;
+        }
 
         /// <summary>
         /// Gets or sets 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.
+        /// </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)
+                {
+                    return Quantization.DefaultQualityFactor;
+                }
+
+                int lumaQuality = this.luminanceQuality.Value;
+
+                // Jpeg might not have a chrominance table - return luminance quality (grayscale images)
+                if (!this.chrominanceQuality.HasValue)
+                {
+                    return lumaQuality;
+                }
+
+                int chromaQuality = this.chrominanceQuality.Value;
+
+                // 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.
+        /// </summary>
         public JpegColorType? ColorType { get; set; }
 
         /// <inheritdoc/>

src/ImageSharp/Formats/Jpeg/JpegThrowHelper.cs

@@ -36,7 +36,10 @@ namespace SixLabors.ImageSharp.Formats.Jpeg
         public static void ThrowBadMarker(string marker, int length) => throw new InvalidImageContentException($"Marker {marker} has bad length {length}.");
 
         [MethodImpl(InliningOptions.ColdPath)]
-        public static void ThrowBadQuantizationTable() => throw new InvalidImageContentException("Bad Quantization Table index.");
+        public static void ThrowBadQuantizationTableIndex(int index) => throw new InvalidImageContentException($"Bad Quantization Table index {index}.");
+
+        [MethodImpl(InliningOptions.ColdPath)]
+        public static void ThrowBadQuantizationTablePrecision(int precision) => throw new InvalidImageContentException($"Unknown Quantization Table precision {precision}.");
 
         [MethodImpl(InliningOptions.ColdPath)]
         public static void ThrowBadSampling() => throw new InvalidImageContentException("Bad sampling factor.");

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

@@ -493,5 +493,96 @@ namespace SixLabors.ImageSharp.Tests.Formats.Jpg
                 Assert.Equal(data[i], dest[i]);
             }
         }
+
+        [Fact]
+        public void EqualsToScalar_AllOne()
+        {
+            static void RunTest()
+            {
+                // Fill matrix with valid value
+                Block8x8F block = default;
+                for (int i = 0; i < Block8x8F.Size; i++)
+                {
+                    block[i] = 1;
+                }
+
+                bool isEqual = block.EqualsToScalar(1);
+                Assert.True(isEqual);
+            }
+
+            // 2 paths:
+            // 1. DisableFMA - call avx implementation
+            // 3. DisableAvx2 - call fallback code of float implementation
+            FeatureTestRunner.RunWithHwIntrinsicsFeature(
+                RunTest,
+                HwIntrinsics.AllowAll | HwIntrinsics.DisableAVX2);
+        }
+
+        [Theory]
+        [InlineData(10)]
+        public void EqualsToScalar_OneOffEachPosition(int equalsTo)
+        {
+            static void RunTest(string serializedEqualsTo)
+            {
+                int equalsTo = FeatureTestRunner.Deserialize<int>(serializedEqualsTo);
+                int offValue = 0;
+
+                // Fill matrix with valid value
+                Block8x8F block = default;
+                for (int i = 0; i < Block8x8F.Size; i++)
+                {
+                    block[i] = equalsTo;
+                }
+
+                // Assert with invalid values at different positions
+                for (int i = 0; i < Block8x8F.Size; i++)
+                {
+                    block[i] = offValue;
+
+                    bool isEqual = block.EqualsToScalar(equalsTo);
+                    Assert.False(isEqual, $"False equality:\n{block}");
+
+                    // restore valid value for next iteration assertion
+                    block[i] = equalsTo;
+                }
+            }
+
+            // 2 paths:
+            // 1. DisableFMA - call avx implementation
+            // 3. DisableAvx2 - call fallback code of float implementation
+            FeatureTestRunner.RunWithHwIntrinsicsFeature(
+                RunTest,
+                equalsTo,
+                HwIntrinsics.AllowAll | HwIntrinsics.DisableAVX2);
+        }
+
+        [Theory]
+        [InlineData(39)]
+        public void EqualsToScalar_Valid(int equalsTo)
+        {
+            static void RunTest(string serializedEqualsTo)
+            {
+                int equalsTo = FeatureTestRunner.Deserialize<int>(serializedEqualsTo);
+
+                // Fill matrix with valid value
+                Block8x8F block = default;
+                for (int i = 0; i < Block8x8F.Size; i++)
+                {
+                    block[i] = equalsTo;
+                }
+
+                // Assert
+                bool isEqual = block.EqualsToScalar(equalsTo);
+                Assert.True(isEqual);
+            }
+
+            // 2 paths:
+            // 1. DisableFMA - call avx implementation
+            // 3. DisableAvx2 - call fallback code of float implementation
+            FeatureTestRunner.RunWithHwIntrinsicsFeature(
+                RunTest,
+                equalsTo,
+                HwIntrinsics.AllowAll | HwIntrinsics.DisableAVX2);
+        }
     }
 }

tests/ImageSharp.Tests/Formats/Jpg/JpegDecoderTests.Metadata.cs

@@ -55,7 +55,9 @@ namespace SixLabors.ImageSharp.Tests.Formats.Jpg
         {
             { TestImages.Jpeg.Baseline.Calliphora, 80 },
             { TestImages.Jpeg.Progressive.Fb, 75 },
-            { TestImages.Jpeg.Issues.IncorrectQuality845, 99 }
+            { TestImages.Jpeg.Issues.IncorrectQuality845, 98 },
+            { TestImages.Jpeg.Baseline.ForestBridgeDifferentComponentsQuality, 89 },
+            { TestImages.Jpeg.Progressive.Winter, 80 }
         };
 
         [Theory]

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

@@ -21,5 +21,44 @@ namespace SixLabors.ImageSharp.Tests.Formats.Jpg
             Assert.False(meta.Quality.Equals(clone.Quality));
             Assert.False(meta.ColorType.Equals(clone.ColorType));
         }
+
+        [Fact]
+        public void Quality_DefaultQuality()
+        {
+            var meta = new JpegMetadata();
+
+            Assert.Equal(meta.Quality, ImageSharp.Formats.Jpeg.Components.Quantization.DefaultQualityFactor);
+        }
+
+        [Fact]
+        public void Quality_LuminanceOnlyQuality()
+        {
+            int quality = 50;
+
+            var meta = new JpegMetadata { LuminanceQuality = quality };
+
+            Assert.Equal(meta.Quality, quality);
+        }
+
+        [Fact]
+        public void Quality_BothComponentsQuality()
+        {
+            int quality = 50;
+
+            var meta = new JpegMetadata { LuminanceQuality = quality, ChrominanceQuality = quality };
+
+            Assert.Equal(meta.Quality, quality);
+        }
+
+        [Fact]
+        public void Quality_ReturnsMaxQuality()
+        {
+            int qualityLuma = 50;
+            int qualityChroma = 30;
+
+            var meta = new JpegMetadata { LuminanceQuality = qualityLuma, ChrominanceQuality = qualityChroma };
+
+            Assert.Equal(meta.Quality, qualityLuma);
+        }
     }
 }

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

@@ -0,0 +1,42 @@
+// Copyright (c) Six Labors.
+// Licensed under the Apache License, Version 2.0.
+
+using SixLabors.ImageSharp.Formats.Jpeg.Components;
+using Xunit;
+
+using JpegQuantization = SixLabors.ImageSharp.Formats.Jpeg.Components.Quantization;
+
+namespace SixLabors.ImageSharp.Tests.Formats.Jpg
+{
+    [Trait("Format", "Jpg")]
+    public class QuantizationTests
+    {
+        [Fact]
+        public void QualityEstimationFromStandardEncoderTables_Luminance()
+        {
+            int firstIndex = JpegQuantization.QualityEstimationConfidenceLowerThreshold;
+            int lastIndex = JpegQuantization.QualityEstimationConfidenceUpperThreshold;
+            for (int quality = firstIndex; quality <= lastIndex; quality++)
+            {
+                Block8x8F table = JpegQuantization.ScaleLuminanceTable(quality);
+                int estimatedQuality = JpegQuantization.EstimateLuminanceQuality(ref table);
+
+                Assert.True(quality.Equals(estimatedQuality), $"Failed to estimate luminance quality for standard table at quality level {quality}");
+            }
+        }
+
+        [Fact]
+        public void QualityEstimationFromStandardEncoderTables_Chrominance()
+        {
+            int firstIndex = JpegQuantization.QualityEstimationConfidenceLowerThreshold;
+            int lastIndex = JpegQuantization.QualityEstimationConfidenceUpperThreshold;
+            for (int quality = firstIndex; quality <= lastIndex; quality++)
+            {
+                Block8x8F table = JpegQuantization.ScaleChrominanceTable(quality);
+                int estimatedQuality = JpegQuantization.EstimateChrominanceQuality(ref table);
+
+                Assert.True(quality.Equals(estimatedQuality), $"Failed to estimate chrominance quality for standard table at quality level {quality}");
+            }
+        }
+    }
+}

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

@@ -4,7 +4,6 @@
 using System;
 using System.IO;
 using System.Linq;
-using System.Threading;
 using SixLabors.ImageSharp.Formats.Jpeg;
 using SixLabors.ImageSharp.Formats.Jpeg.Components;
 using SixLabors.ImageSharp.Formats.Jpeg.Components.Decoder;

tests/ImageSharp.Tests/TestImages.cs

@@ -157,6 +157,7 @@ namespace SixLabors.ImageSharp.Tests
                 public const string Fb = "Jpg/progressive/fb.jpg";
                 public const string Progress = "Jpg/progressive/progress.jpg";
                 public const string Festzug = "Jpg/progressive/Festzug.jpg";
+                public const string Winter = "Jpg/progressive/winter.jpg";
 
                 public static class Bad
                 {
@@ -198,6 +199,7 @@ namespace SixLabors.ImageSharp.Tests
                 public const string Iptc = "Jpg/baseline/iptc.jpg";
                 public const string App13WithEmptyIptc = "Jpg/baseline/iptc-psAPP13-wIPTCempty.jpg";
                 public const string HistogramEqImage = "Jpg/baseline/640px-Unequalized_Hawkes_Bay_NZ.jpg";
+                public const string ForestBridgeDifferentComponentsQuality = "Jpg/baseline/forest_bridge.jpg";
 
                 public static readonly string[] All =
                 {

tests/Images/Input/Jpg/baseline/forest_bridge.jpg

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:56b3db3d0e146ee7fe27f8fbda4bccc1483e18104bfc747cac75a2ec03d65647
+size 1936782

tests/Images/Input/Jpg/progressive/winter.jpg

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:d377b70cedfb9d25f1ae0244dcf2edb000540aa4a8925cce57f810f7efd0dc84
+size 234976