tsai
/
ImageSharp
mirror of https://github.com/SixLabors/ImageSharp
1
0
Fork 0
Code Issues Projects Releases Wiki Activity
Browse Source

Initial new quality estimator

pull/1706/head
Dmitry Pentin 5 years ago
parent
15d77ddf26
commit
664d7f366f
5 changed files with 199 additions and 196 deletions
Whitespace
Show all changes Ignore whitespace when comparing lines Ignore changes in amount of whitespace Ignore changes in whitespace at EOL
Split View
Diff Options
Show Stats Download Patch File Download Diff File
  1. 152
      src/ImageSharp/Formats/Jpeg/Components/Decoder/QualityEvaluator.cs
  2. 128
      src/ImageSharp/Formats/Jpeg/Components/Quantization.cs
  3. 39
      src/ImageSharp/Formats/Jpeg/JpegDecoderCore.cs
  4. 40
      src/ImageSharp/Formats/Jpeg/JpegEncoderCore.cs
  5. 36
      src/ImageSharp/Formats/Jpeg/JpegMetadata.cs

152
src/ImageSharp/Formats/Jpeg/Components/Decoder/QualityEvaluator.cs
View File

@ -1,152 +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 a jpeg quality parameter based on the quantization tables.
/// </summary>
/// <param name="quantizationTables">The quantization tables.</param>
/// <param name="quality">Jpeg quality parameter</param>
/// <returns><see cref="bool"/> indicating if given quantization tables are equal to standard ITU spec.</returns>
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;
}
}
}

128
src/ImageSharp/Formats/Jpeg/Components/Quantization.cs
View File

@ -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
{
/// <summary>
/// Provides methods and properties related to jpeg quantization.
/// </summary>
internal static class Quantization
{
/// <summary>
/// Threshold at which given luminance quantization table should not be considered 'standard'.
/// </summary>
/// <remarks>
/// Jpeg does not define either 'quality' nor 'standard quantization table' properties
/// so this is purely a practical value derived from tests.
/// </remarks>
public const double StandardLuminanceTableVarianceThreshold = 10.0;
/// <summary>
/// Threshold at which given luminance quantization table should not be considered 'standard'.
/// </summary>
/// <remarks>
/// Jpeg does not define either 'quality' nor 'standard quantization table' properties
/// so this is purely a practical value derived from tests.
/// </remarks>
public const double StandardChrominanceTableVarianceThreshold = 10.0;
/// <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,
};
// https://github.com/ImpulseAdventure/JPEGsnoop/blob/9732ee0961f100eb69bbff4a0c47438d5997abee/source/JfifDecode.cpp#L4570-L4694
public static void EstimateQuality(ref Block8x8F table, ReadOnlySpan<byte> 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;
}
}
}
}

39
src/ImageSharp/Formats/Jpeg/JpegDecoderCore.cs
View File

@ -753,6 +753,8 @@ namespace SixLabors.ImageSharp.Formats.Jpeg
/// </exception>
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;
}
}
}
}
/// <summary>

40
src/ImageSharp/Formats/Jpeg/JpegEncoderCore.cs
View File

@ -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>
@ -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<byte> unscaledQuant = (i == 0) ? UnscaledQuant_Luminance : UnscaledQuant_Chrominance;
ReadOnlySpan<byte> unscaledQuant = (i == 0) ? Quantization.UnscaledQuant_Luminance : Quantization.UnscaledQuant_Chrominance;
for (int j = 0; j < Block8x8F.Size; j++)
{

36
src/ImageSharp/Formats/Jpeg/JpegMetadata.cs
View File

@ -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,26 @@ namespace SixLabors.ImageSharp.Formats.Jpeg
/// </summary>
public class JpegMetadata : IDeepCloneable
{
/// <summary>
/// Luminance qunatization table derived from jpeg image.
/// </summary>
/// <remarks>
/// Would be null if jpeg was encoded using table from ITU spec
/// </remarks>
internal Block8x8? lumaQuantizationTable;
/// <summary>
/// Luminance qunatization table derived from jpeg image.
/// </summary>
/// <remarks>
/// Would be null if jpeg was encoded using table from ITU spec
/// </remarks>
internal Block8x8? chromaQuantizationTable;
internal double LumaQuality;
internal double ChromaQuality;
/// <summary>
/// Initializes a new instance of the <see cref="JpegMetadata"/> class.
/// </summary>
@ -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;
}
/// <summary>
/// Gets or sets the encoded quality.
/// </summary>
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;
}
}
/// <summary>
/// Gets or sets the encoded quality.

Write Preview
Loading…
Cancel
Save