diff --git a/src/ImageSharp/Formats/Jpeg/Components/Decoder/QualityEvaluator.cs b/src/ImageSharp/Formats/Jpeg/Components/Decoder/QualityEvaluator.cs
deleted file mode 100644
index e9d67d1ba9..0000000000
--- a/src/ImageSharp/Formats/Jpeg/Components/Decoder/QualityEvaluator.cs
+++ /dev/null
@@ -1,152 +0,0 @@
-// Copyright (c) Six Labors.
-// Licensed under the Apache License, Version 2.0.
-
-namespace SixLabors.ImageSharp.Formats.Jpeg.Components.Decoder
-{
- ///
- /// Provides methods to evaluate the quality of an image.
- /// Ported from
- ///
- 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
- };
-
- ///
- /// Returns a jpeg quality parameter based on the quantization tables.
- ///
- /// The quantization tables.
- /// Jpeg quality parameter
- /// indicating if given quantization tables are equal to standard ITU spec.
- public static bool EstimateQuality(Block8x8F[] quantizationTables, out int quality)
- {
- DebugGuard.MustBeGreaterThan(quantizationTables.Length, 2, nameof(quantizationTables));
-
- 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;
- }
-
- bool sumHashCondition = (quality <= Hash[i]) && (sum <= Sums[i]);
- if (sumHashCondition || (i >= 50))
- {
- quality = i + 1;
- return sumHashCondition;
- }
- }
- }
- else
- {
- quality = (int)(qTable0[2] + qTable0[53]);
-
- for (int i = 0; i < 100; i++)
- {
- if (quality < Hash1[i] && sum < Sums1[i])
- {
- continue;
- }
-
- bool sumHashCondition = (quality <= Hash1[i]) && (sum <= Sums1[i]);
- if (sumHashCondition || (i >= 50))
- {
- quality = i + 1;
- return sumHashCondition;
- }
- }
- }
- }
-
- return false;
- }
- }
-}
diff --git a/src/ImageSharp/Formats/Jpeg/Components/Quantization.cs b/src/ImageSharp/Formats/Jpeg/Components/Quantization.cs
new file mode 100644
index 0000000000..3471558054
--- /dev/null
+++ b/src/ImageSharp/Formats/Jpeg/Components/Quantization.cs
@@ -0,0 +1,128 @@
+// Copyright (c) Six Labors.
+// Licensed under the Apache License, Version 2.0.
+
+using System;
+using System.Collections.Generic;
+using System.Text;
+
+namespace SixLabors.ImageSharp.Formats.Jpeg.Components
+{
+ ///
+ /// Provides methods and properties related to jpeg quantization.
+ ///
+ internal static class Quantization
+ {
+ ///
+ /// Threshold at which given luminance quantization table should not be considered 'standard'.
+ ///
+ ///
+ /// Jpeg does not define either 'quality' nor 'standard quantization table' properties
+ /// so this is purely a practical value derived from tests.
+ ///
+ public const double StandardLuminanceTableVarianceThreshold = 10.0;
+
+ ///
+ /// Threshold at which given luminance quantization table should not be considered 'standard'.
+ ///
+ ///
+ /// Jpeg does not define either 'quality' nor 'standard quantization table' properties
+ /// so this is purely a practical value derived from tests.
+ ///
+ public const double StandardChrominanceTableVarianceThreshold = 10.0;
+
+ ///
+ /// 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.
+ ///
+ // The C# compiler emits this as a compile-time constant embedded in the PE file.
+ // This is effectively compiled down to: return new ReadOnlySpan(&data, length)
+ // More details can be found: https://github.com/dotnet/roslyn/pull/24621
+ public static ReadOnlySpan 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,
+ };
+
+ ///
+ /// 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.
+ ///
+ // The C# compiler emits this as a compile-time constant embedded in the PE file.
+ // This is effectively compiled down to: return new ReadOnlySpan(&data, length)
+ // More details can be found: https://github.com/dotnet/roslyn/pull/24621
+ public static ReadOnlySpan 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,
+ };
+
+ // https://github.com/ImpulseAdventure/JPEGsnoop/blob/9732ee0961f100eb69bbff4a0c47438d5997abee/source/JfifDecode.cpp#L4570-L4694
+ public static void EstimateQuality(ref Block8x8F table, ReadOnlySpan target, out double quality, out double variance)
+ {
+ // 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;
+ double sumPercentSqr = 0;
+
+ bool allOnes = true;
+
+ 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
+ {
+ comparePercent = 999.99;
+ }
+
+ sumPercent += comparePercent;
+ sumPercentSqr += comparePercent * comparePercent;
+
+ // Check just in case entire table are ones (Quality 100)
+ if (coeffInteger != 1)
+ {
+ allOnes = false;
+ }
+ }
+
+ // 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;
+ sumPercentSqr /= 64.0;
+ variance = sumPercentSqr - (sumPercent * sumPercent);
+
+ // Generate the equivalent IJQ "quality" factor
+ if (allOnes)
+ {
+ quality = 100;
+ }
+ else if (sumPercent <= 100.0)
+ {
+ quality = (200 - sumPercent) / 2;
+ }
+ else
+ {
+ quality = 5000.0 / sumPercent;
+ }
+ }
+ }
+}
diff --git a/src/ImageSharp/Formats/Jpeg/JpegDecoderCore.cs b/src/ImageSharp/Formats/Jpeg/JpegDecoderCore.cs
index 3896aa2930..b86772d81c 100644
--- a/src/ImageSharp/Formats/Jpeg/JpegDecoderCore.cs
+++ b/src/ImageSharp/Formats/Jpeg/JpegDecoderCore.cs
@@ -753,6 +753,8 @@ namespace SixLabors.ImageSharp.Formats.Jpeg
///
private void ProcessDefineQuantizationTablesMarker(BufferedReadStream stream, int remaining)
{
+ JpegMetadata jpegMetadata = this.Metadata.GetFormatMetadata(JpegFormat.Instance);
+
while (remaining > 0)
{
// 1 byte: quantization table spec
@@ -769,6 +771,9 @@ namespace SixLabors.ImageSharp.Formats.Jpeg
}
remaining--;
+
+ // Decoding single 8x8 table
+ ref Block8x8F table = ref this.QuantizationTables[tableIndex];
switch (tablePrecision)
{
// 8 bit values
@@ -783,7 +788,6 @@ namespace SixLabors.ImageSharp.Formats.Jpeg
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];
@@ -804,7 +808,6 @@ namespace SixLabors.ImageSharp.Formats.Jpeg
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];
@@ -820,9 +823,37 @@ namespace SixLabors.ImageSharp.Formats.Jpeg
break;
}
}
- }
- this.Metadata.GetFormatMetadata(JpegFormat.Instance).Quality = QualityEvaluator.EstimateQuality(this.QuantizationTables);
+ // Estimating quality
+ switch (tableIndex)
+ {
+ // luminance table
+ case 0:
+ {
+ Quantization.EstimateQuality(ref table, Quantization.UnscaledQuant_Luminance, out double quality, out double variance);
+ jpegMetadata.LumaQuality = quality;
+ if (variance <= Quantization.StandardLuminanceTableVarianceThreshold)
+ {
+ jpegMetadata.lumaQuantizationTable = table.RoundAsInt16Block();
+ }
+
+ break;
+ }
+
+ // chrominance table
+ case 1:
+ {
+ Quantization.EstimateQuality(ref table, Quantization.UnscaledQuant_Chrominance, out double quality, out double variance);
+ jpegMetadata.ChromaQuality = quality;
+ if (variance <= Quantization.StandardChrominanceTableVarianceThreshold)
+ {
+ jpegMetadata.chromaQuantizationTable = table.RoundAsInt16Block();
+ }
+
+ break;
+ }
+ }
+ }
}
///
diff --git a/src/ImageSharp/Formats/Jpeg/JpegEncoderCore.cs b/src/ImageSharp/Formats/Jpeg/JpegEncoderCore.cs
index 60c209c524..f3fddd9e0d 100644
--- a/src/ImageSharp/Formats/Jpeg/JpegEncoderCore.cs
+++ b/src/ImageSharp/Formats/Jpeg/JpegEncoderCore.cs
@@ -64,44 +64,6 @@ namespace SixLabors.ImageSharp.Formats.Jpeg
this.colorType = options.ColorType;
}
- ///
- /// 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.
- ///
- // The C# compiler emits this as a compile-time constant embedded in the PE file.
- // This is effectively compiled down to: return new ReadOnlySpan(&data, length)
- // More details can be found: https://github.com/dotnet/roslyn/pull/24621
- private static ReadOnlySpan 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,
- };
-
- ///
- /// 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.
- ///
- // The C# compiler emits this as a compile-time constant embedded in the PE file.
- // This is effectively compiled down to: return new ReadOnlySpan(&data, length)
- // More details can be found: https://github.com/dotnet/roslyn/pull/24621
- private static ReadOnlySpan 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,
- };
-
///
/// Encode writes the image to the jpeg baseline format with the given options.
///
@@ -698,7 +660,7 @@ namespace SixLabors.ImageSharp.Formats.Jpeg
private static void InitQuantizationTable(int i, int scale, ref Block8x8F quant)
{
DebugGuard.MustBeBetweenOrEqualTo(i, 0, 1, nameof(i));
- ReadOnlySpan unscaledQuant = (i == 0) ? UnscaledQuant_Luminance : UnscaledQuant_Chrominance;
+ ReadOnlySpan unscaledQuant = (i == 0) ? Quantization.UnscaledQuant_Luminance : Quantization.UnscaledQuant_Chrominance;
for (int j = 0; j < Block8x8F.Size; j++)
{
diff --git a/src/ImageSharp/Formats/Jpeg/JpegMetadata.cs b/src/ImageSharp/Formats/Jpeg/JpegMetadata.cs
index 9670d167e0..0a05aac170 100644
--- a/src/ImageSharp/Formats/Jpeg/JpegMetadata.cs
+++ b/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
{
///
@@ -8,6 +11,26 @@ namespace SixLabors.ImageSharp.Formats.Jpeg
///
public class JpegMetadata : IDeepCloneable
{
+ ///
+ /// Luminance qunatization table derived from jpeg image.
+ ///
+ ///
+ /// Would be null if jpeg was encoded using table from ITU spec
+ ///
+ internal Block8x8? lumaQuantizationTable;
+
+ ///
+ /// Luminance qunatization table derived from jpeg image.
+ ///
+ ///
+ /// Would be null if jpeg was encoded using table from ITU spec
+ ///
+ internal Block8x8? chromaQuantizationTable;
+
+ internal double LumaQuality;
+
+ internal double ChromaQuality;
+
///
/// Initializes a new instance of the class.
///
@@ -23,12 +46,23 @@ namespace SixLabors.ImageSharp.Formats.Jpeg
{
this.Quality = other.Quality;
this.ColorType = other.ColorType;
+ this.lumaQuantizationTable = other.lumaQuantizationTable;
+ this.chromaQuantizationTable = other.chromaQuantizationTable;
}
///
/// Gets or sets the encoded quality.
///
- public int Quality { get; set; } = 75;
+ public int Quality
+ {
+ get => (int)Math.Round((this.LumaQuality + this.ChromaQuality) / 2f);
+ set
+ {
+ double halfValue = value / 2.0;
+ this.LumaQuality = halfValue;
+ this.ChromaQuality = halfValue;
+ }
+ }
///
/// Gets or sets the encoded quality.