mirror of https://github.com/SixLabors/ImageSharp
Brian Popow
6 years ago
13 changed files with 1136 additions and 135 deletions
@ -0,0 +1,92 @@ |
|||||
|
// Copyright (c) Six Labors and contributors.
|
||||
|
// Licensed under the GNU Affero General Public License, Version 3.
|
||||
|
|
||||
|
namespace SixLabors.ImageSharp.Formats.WebP.Lossless |
||||
|
{ |
||||
|
/// <summary>
|
||||
|
/// Data container to keep track of cost range for the three dominant entropy symbols.
|
||||
|
/// </summary>
|
||||
|
internal class DominantCostRange |
||||
|
{ |
||||
|
/// <summary>
|
||||
|
/// Initializes a new instance of the <see cref="DominantCostRange"/> class.
|
||||
|
/// </summary>
|
||||
|
public DominantCostRange() |
||||
|
{ |
||||
|
this.LiteralMax = 0.0d; |
||||
|
this.LiteralMin = double.MaxValue; |
||||
|
this.RedMax = 0.0d; |
||||
|
this.RedMin = double.MaxValue; |
||||
|
this.BlueMax = 0.0d; |
||||
|
this.BlueMin = double.MaxValue; |
||||
|
} |
||||
|
|
||||
|
public double LiteralMax { get; set; } |
||||
|
|
||||
|
public double LiteralMin { get; set; } |
||||
|
|
||||
|
public double RedMax { get; set; } |
||||
|
|
||||
|
public double RedMin { get; set; } |
||||
|
|
||||
|
public double BlueMax { get; set; } |
||||
|
|
||||
|
public double BlueMin { get; set; } |
||||
|
|
||||
|
public void UpdateDominantCostRange(Vp8LHistogram h) |
||||
|
{ |
||||
|
if (this.LiteralMax < h.LiteralCost) |
||||
|
{ |
||||
|
this.LiteralMax = h.LiteralCost; |
||||
|
} |
||||
|
|
||||
|
if (this.LiteralMin > h.LiteralCost) |
||||
|
{ |
||||
|
this.LiteralMin = h.LiteralCost; |
||||
|
} |
||||
|
|
||||
|
if (this.RedMax < h.RedCost) |
||||
|
{ |
||||
|
this.RedMax = h.RedCost; |
||||
|
} |
||||
|
|
||||
|
if (this.RedMin > h.RedCost) |
||||
|
{ |
||||
|
this.RedMin = h.RedCost; |
||||
|
} |
||||
|
|
||||
|
if (this.BlueMax < h.BlueCost) |
||||
|
{ |
||||
|
this.BlueMax = h.BlueCost; |
||||
|
} |
||||
|
|
||||
|
if (this.BlueMin > h.BlueCost) |
||||
|
{ |
||||
|
this.BlueMin = h.BlueCost; |
||||
|
} |
||||
|
} |
||||
|
|
||||
|
public int GetHistoBinIndex(Vp8LHistogram h, int numPartitions) |
||||
|
{ |
||||
|
int binId = GetBinIdForEntropy(this.LiteralMin, this.LiteralMax, h.LiteralCost, numPartitions); |
||||
|
binId = (binId * numPartitions) + GetBinIdForEntropy(this.RedMin, this.RedMax, h.RedCost, numPartitions); |
||||
|
binId = (binId * numPartitions) + GetBinIdForEntropy(this.BlueMin, this.BlueMax, h.BlueCost, numPartitions); |
||||
|
|
||||
|
return binId; |
||||
|
} |
||||
|
|
||||
|
private static int GetBinIdForEntropy(double min, double max, double val, int numPartitions) |
||||
|
{ |
||||
|
double range = max - min; |
||||
|
if (range > 0.0d) |
||||
|
{ |
||||
|
double delta = val - min; |
||||
|
return (int)((numPartitions - 1e-6) * delta / range); |
||||
|
} |
||||
|
else |
||||
|
{ |
||||
|
return 0; |
||||
|
} |
||||
|
} |
||||
|
} |
||||
|
} |
||||
@ -0,0 +1,627 @@ |
|||||
|
// Copyright (c) Six Labors and contributors.
|
||||
|
// Licensed under the GNU Affero General Public License, Version 3.
|
||||
|
|
||||
|
using System; |
||||
|
using System.Collections.Generic; |
||||
|
using System.Linq; |
||||
|
|
||||
|
namespace SixLabors.ImageSharp.Formats.WebP.Lossless |
||||
|
{ |
||||
|
internal class HistogramEncoder |
||||
|
{ |
||||
|
/// <summary>
|
||||
|
/// Number of partitions for the three dominant (literal, red and blue) symbol costs.
|
||||
|
/// </summary>
|
||||
|
private const int NumPartitions = 4; |
||||
|
|
||||
|
/// <summary>
|
||||
|
/// The size of the bin-hash corresponding to the three dominant costs.
|
||||
|
/// </summary>
|
||||
|
private const int BinSize = NumPartitions * NumPartitions * NumPartitions; |
||||
|
|
||||
|
/// <summary>
|
||||
|
/// Maximum number of histograms allowed in greedy combining algorithm.
|
||||
|
/// </summary>
|
||||
|
private const int MaxHistoGreedy = 100; |
||||
|
|
||||
|
private const uint NonTrivialSym = 0xffffffff; |
||||
|
|
||||
|
public static void GetHistoImageSymbols(int xSize, int ySize, Vp8LBackwardRefs refs, int quality, int histoBits, int cacheBits, List<Vp8LHistogram> imageHisto, Vp8LHistogram tmpHisto, short[] histogramSymbols) |
||||
|
{ |
||||
|
int histoXSize = histoBits > 0 ? LosslessUtils.SubSampleSize(xSize, histoBits) : 1; |
||||
|
int histoYSize = histoBits > 0 ? LosslessUtils.SubSampleSize(ySize, histoBits) : 1; |
||||
|
int imageHistoRawSize = histoXSize * histoYSize; |
||||
|
int entropyCombineNumBins = BinSize; |
||||
|
short[] mapTmp = new short[imageHistoRawSize]; |
||||
|
short[] clusterMappings = new short[imageHistoRawSize]; |
||||
|
int numUsed = imageHistoRawSize; |
||||
|
var origHisto = new List<Vp8LHistogram>(imageHistoRawSize); |
||||
|
for (int i = 0; i < imageHistoRawSize; i++) |
||||
|
{ |
||||
|
origHisto.Add(new Vp8LHistogram(cacheBits)); |
||||
|
} |
||||
|
|
||||
|
// Construct the histograms from backward references.
|
||||
|
HistogramBuild(xSize, histoBits, refs, origHisto); |
||||
|
|
||||
|
// Copies the histograms and computes its bit_cost. histogramSymbols is optimized.
|
||||
|
HistogramCopyAndAnalyze(origHisto, imageHisto, ref numUsed, histogramSymbols); |
||||
|
|
||||
|
var entropyCombine = (numUsed > entropyCombineNumBins * 2) && (quality < 100); |
||||
|
if (entropyCombine) |
||||
|
{ |
||||
|
var binMap = mapTmp; |
||||
|
var numClusters = numUsed; |
||||
|
double combineCostFactor = GetCombineCostFactor(imageHistoRawSize, quality); |
||||
|
HistogramAnalyzeEntropyBin(imageHisto, binMap); |
||||
|
|
||||
|
// Collapse histograms with similar entropy.
|
||||
|
HistogramCombineEntropyBin(imageHisto, ref numUsed, histogramSymbols, clusterMappings, tmpHisto, binMap, entropyCombineNumBins, combineCostFactor); |
||||
|
|
||||
|
OptimizeHistogramSymbols(imageHisto, clusterMappings, numClusters, mapTmp, histogramSymbols); |
||||
|
} |
||||
|
|
||||
|
if (!entropyCombine) |
||||
|
{ |
||||
|
float x = quality / 100.0f; |
||||
|
|
||||
|
// Cubic ramp between 1 and MaxHistoGreedy:
|
||||
|
int thresholdSize = (int)(1 + (x * x * x * (MaxHistoGreedy - 1))); |
||||
|
bool doGreedy = HistogramCombineStochastic(imageHisto, ref numUsed, thresholdSize); |
||||
|
if (doGreedy) |
||||
|
{ |
||||
|
HistogramCombineGreedy(imageHisto, ref numUsed); |
||||
|
} |
||||
|
} |
||||
|
} |
||||
|
|
||||
|
/// <summary>
|
||||
|
/// Construct the histograms from backward references.
|
||||
|
/// </summary>
|
||||
|
private static void HistogramBuild(int xSize, int histoBits, Vp8LBackwardRefs backwardRefs, List<Vp8LHistogram> histograms) |
||||
|
{ |
||||
|
int x = 0, y = 0; |
||||
|
int histoXSize = LosslessUtils.SubSampleSize(xSize, histoBits); |
||||
|
using List<PixOrCopy>.Enumerator backwardRefsEnumerator = backwardRefs.Refs.GetEnumerator(); |
||||
|
while (backwardRefsEnumerator.MoveNext()) |
||||
|
{ |
||||
|
PixOrCopy v = backwardRefsEnumerator.Current; |
||||
|
int ix = ((y >> histoBits) * histoXSize) + (x >> histoBits); |
||||
|
histograms[ix].AddSinglePixOrCopy(v, false); |
||||
|
x += v.Len; |
||||
|
while (x >= xSize) |
||||
|
{ |
||||
|
x -= xSize; |
||||
|
y++; |
||||
|
} |
||||
|
} |
||||
|
} |
||||
|
|
||||
|
/// <summary>
|
||||
|
/// Partition histograms to different entropy bins for three dominant (literal,
|
||||
|
/// red and blue) symbol costs and compute the histogram aggregate bitCost.
|
||||
|
/// </summary>
|
||||
|
private static void HistogramAnalyzeEntropyBin(List<Vp8LHistogram> histograms, short[] binMap) |
||||
|
{ |
||||
|
int histoSize = histograms.Count; |
||||
|
var costRange = new DominantCostRange(); |
||||
|
|
||||
|
// Analyze the dominant (literal, red and blue) entropy costs.
|
||||
|
for (int i = 0; i < histoSize; i++) |
||||
|
{ |
||||
|
costRange.UpdateDominantCostRange(histograms[i]); |
||||
|
} |
||||
|
|
||||
|
// bin-hash histograms on three of the dominant (literal, red and blue)
|
||||
|
// symbol costs and store the resulting bin_id for each histogram.
|
||||
|
for (int i = 0; i < histoSize; i++) |
||||
|
{ |
||||
|
binMap[i] = (short)costRange.GetHistoBinIndex(histograms[i], NumPartitions); |
||||
|
} |
||||
|
} |
||||
|
|
||||
|
private static void HistogramCopyAndAnalyze(List<Vp8LHistogram> origHistograms, List<Vp8LHistogram> histograms, ref int numUsed, short[] histogramSymbols) |
||||
|
{ |
||||
|
int numUsedOrig = numUsed; |
||||
|
var indicesToRemove = new List<int>(); |
||||
|
for (int clusterId = 0, i = 0; i < origHistograms.Count; i++) |
||||
|
{ |
||||
|
Vp8LHistogram histo = origHistograms[i]; |
||||
|
histo.UpdateHistogramCost(); |
||||
|
|
||||
|
// Skip the histogram if it is completely empty, which can happen for tiles
|
||||
|
// with no information (when they are skipped because of LZ77).
|
||||
|
if (!histo.IsUsed[0] && !histo.IsUsed[1] && !histo.IsUsed[2] && !histo.IsUsed[3] && !histo.IsUsed[4]) |
||||
|
{ |
||||
|
indicesToRemove.Add(i); |
||||
|
} |
||||
|
else |
||||
|
{ |
||||
|
// TODO: HistogramCopy(histo, histograms[i]);
|
||||
|
histogramSymbols[i] = (short)clusterId++; |
||||
|
} |
||||
|
} |
||||
|
|
||||
|
foreach (int indice in indicesToRemove.OrderByDescending(v => v)) |
||||
|
{ |
||||
|
origHistograms.RemoveAt(indice); |
||||
|
histograms.RemoveAt(indice); |
||||
|
} |
||||
|
} |
||||
|
|
||||
|
private static void HistogramCombineEntropyBin(List<Vp8LHistogram> histograms, ref int numUsed, short[] clusters, short[] clusterMappings, Vp8LHistogram curCombo, short[] binMap, int numBins, double combineCostFactor) |
||||
|
{ |
||||
|
for (int idx = 0; idx < histograms.Count; idx++) |
||||
|
{ |
||||
|
clusterMappings[idx] = (short)idx; |
||||
|
} |
||||
|
} |
||||
|
|
||||
|
/// <summary>
|
||||
|
/// Given a Histogram set, the mapping of clusters 'clusterMapping' and the
|
||||
|
/// current assignment of the cells in 'symbols', merge the clusters and
|
||||
|
/// assign the smallest possible clusters values.
|
||||
|
/// </summary>
|
||||
|
private static void OptimizeHistogramSymbols(List<Vp8LHistogram> histograms, short[] clusterMappings, int numClusters, short[] clusterMappingsTmp, short[] symbols) |
||||
|
{ |
||||
|
int clusterMax; |
||||
|
bool doContinue = true; |
||||
|
|
||||
|
// First, assign the lowest cluster to each pixel.
|
||||
|
while (doContinue) |
||||
|
{ |
||||
|
doContinue = false; |
||||
|
for (int i = 0; i < numClusters; i++) |
||||
|
{ |
||||
|
int k; |
||||
|
k = clusterMappings[i]; |
||||
|
while (k != clusterMappings[k]) |
||||
|
{ |
||||
|
clusterMappings[k] = clusterMappings[clusterMappings[k]]; |
||||
|
k = clusterMappings[k]; |
||||
|
} |
||||
|
|
||||
|
if (k != clusterMappings[i]) |
||||
|
{ |
||||
|
doContinue = true; |
||||
|
clusterMappings[i] = (short)k; |
||||
|
} |
||||
|
} |
||||
|
} |
||||
|
|
||||
|
// Create a mapping from a cluster id to its minimal version.
|
||||
|
clusterMax = 0; |
||||
|
clusterMappingsTmp.AsSpan().Fill(0); |
||||
|
|
||||
|
// Re-map the ids.
|
||||
|
for (int i = 0; i < histograms.Count; i++) |
||||
|
{ |
||||
|
int cluster; |
||||
|
cluster = clusterMappings[symbols[i]]; |
||||
|
if (cluster > 0 && clusterMappingsTmp[cluster] == 0) |
||||
|
{ |
||||
|
clusterMax++; |
||||
|
clusterMappingsTmp[cluster] = (short)clusterMax; |
||||
|
} |
||||
|
|
||||
|
symbols[i] = clusterMappingsTmp[cluster]; |
||||
|
} |
||||
|
|
||||
|
// Make sure all cluster values are used.
|
||||
|
clusterMax = 0; |
||||
|
for (int i = 0; i < histograms.Count; i++) |
||||
|
{ |
||||
|
if (symbols[i] <= clusterMax) |
||||
|
{ |
||||
|
continue; |
||||
|
} |
||||
|
|
||||
|
clusterMax++; |
||||
|
} |
||||
|
} |
||||
|
|
||||
|
/// <summary>
|
||||
|
/// Perform histogram aggregation using a stochastic approach.
|
||||
|
/// </summary>
|
||||
|
/// <returns>true if a greedy approach needs to be performed afterwards, false otherwise.</returns>
|
||||
|
private static bool HistogramCombineStochastic(List<Vp8LHistogram> histograms, ref int numUsed, int minClusterSize) |
||||
|
{ |
||||
|
var rand = new Random(); |
||||
|
int triesWithNoSuccess = 0; |
||||
|
int outerIters = numUsed; |
||||
|
int numTriesNoSuccess = outerIters / 2; |
||||
|
|
||||
|
// Priority queue of histogram pairs. Its size impacts the quality of the compression and the speed:
|
||||
|
// the smaller the faster but the worse for the compression.
|
||||
|
var histoPriorityList = new List<HistogramPair>(); |
||||
|
int histoQueueMaxSize = histograms.Count * histograms.Count; |
||||
|
|
||||
|
// Fill the initial mapping.
|
||||
|
int[] mappings = new int[histograms.Count]; |
||||
|
for (int j = 0, iter = 0; iter < histograms.Count; iter++) |
||||
|
{ |
||||
|
mappings[j++] = iter; |
||||
|
} |
||||
|
|
||||
|
// Collapse similar histograms
|
||||
|
for (int iter = 0; iter < outerIters && numUsed >= minClusterSize && ++triesWithNoSuccess < numTriesNoSuccess; iter++) |
||||
|
{ |
||||
|
double bestCost = (histoPriorityList.Count == 0) ? 0.0d : histoPriorityList[0].CostDiff; |
||||
|
int bestIdx1 = -1; |
||||
|
int bestIdx2 = 1; |
||||
|
int numTries = numUsed / 2; // TODO: should that be histogram.Count/2?
|
||||
|
uint randRange = (uint)((numUsed - 1) * numUsed); |
||||
|
|
||||
|
// Pick random samples.
|
||||
|
for (int j = 0; numUsed >= 2 && j < numTries; j++) |
||||
|
{ |
||||
|
// Choose two different histograms at random and try to combine them.
|
||||
|
uint tmp = (uint)(rand.Next() % randRange); |
||||
|
double currCost; |
||||
|
int idx1 = (int)(tmp / (numUsed - 1)); |
||||
|
int idx2 = (int)(tmp % (numUsed - 1)); |
||||
|
if (idx2 >= idx1) |
||||
|
{ |
||||
|
idx2++; |
||||
|
} |
||||
|
|
||||
|
idx1 = mappings[idx1]; |
||||
|
idx2 = mappings[idx2]; |
||||
|
|
||||
|
// Calculate cost reduction on combination.
|
||||
|
currCost = HistoQueuePush(histoPriorityList, histoQueueMaxSize, histograms, idx1, idx2, bestCost); |
||||
|
|
||||
|
// Found a better pair?
|
||||
|
if (currCost < 0) |
||||
|
{ |
||||
|
bestCost = currCost; |
||||
|
|
||||
|
// Empty the queue if we reached full capacity.
|
||||
|
if (histoPriorityList.Count == histoQueueMaxSize) |
||||
|
{ |
||||
|
break; |
||||
|
} |
||||
|
} |
||||
|
} |
||||
|
|
||||
|
if (histoPriorityList.Count == 0) |
||||
|
{ |
||||
|
continue; |
||||
|
} |
||||
|
|
||||
|
// Get the best histograms.
|
||||
|
bestIdx1 = histoPriorityList[0].Idx1; |
||||
|
bestIdx2 = histoPriorityList[0].Idx2; |
||||
|
|
||||
|
// Pop bestIdx2 from mappings.
|
||||
|
var mappingIndex = Array.BinarySearch(mappings, bestIdx2); |
||||
|
// TODO: memmove(mapping_index, mapping_index + 1, sizeof(*mapping_index) *((*num_used) - (mapping_index - mappings) - 1));
|
||||
|
|
||||
|
// Merge the histograms and remove bestIdx2 from the queue.
|
||||
|
HistogramAdd(histograms[bestIdx2], histograms[bestIdx1], histograms[bestIdx1]); |
||||
|
histograms.ElementAt(bestIdx1).BitCost = histoPriorityList[0].CostCombo; |
||||
|
histograms.RemoveAt(bestIdx2); |
||||
|
numUsed--; |
||||
|
|
||||
|
var indicesToRemove = new List<int>(); |
||||
|
int lastIndex = histoPriorityList.Count - 1; |
||||
|
for (int j = 0; j < histoPriorityList.Count;) |
||||
|
{ |
||||
|
HistogramPair p = histoPriorityList.ElementAt(j); |
||||
|
bool isIdx1Best = p.Idx1 == bestIdx1 || p.Idx1 == bestIdx2; |
||||
|
bool isIdx2Best = p.Idx2 == bestIdx1 || p.Idx2 == bestIdx2; |
||||
|
bool doEval = false; |
||||
|
|
||||
|
// The front pair could have been duplicated by a random pick so
|
||||
|
// check for it all the time nevertheless.
|
||||
|
if (isIdx1Best && isIdx2Best) |
||||
|
{ |
||||
|
indicesToRemove.Add(lastIndex); |
||||
|
numUsed--; |
||||
|
lastIndex--; |
||||
|
continue; |
||||
|
} |
||||
|
|
||||
|
// Any pair containing one of the two best indices should only refer to
|
||||
|
// best_idx1. Its cost should also be updated.
|
||||
|
if (isIdx1Best) |
||||
|
{ |
||||
|
p.Idx1 = bestIdx1; |
||||
|
doEval = true; |
||||
|
} |
||||
|
else if (isIdx2Best) |
||||
|
{ |
||||
|
p.Idx2 = bestIdx1; |
||||
|
doEval = true; |
||||
|
} |
||||
|
|
||||
|
// Make sure the index order is respected.
|
||||
|
if (p.Idx1 > p.Idx2) |
||||
|
{ |
||||
|
int tmp = p.Idx2; |
||||
|
p.Idx2 = p.Idx1; |
||||
|
p.Idx1 = tmp; |
||||
|
} |
||||
|
|
||||
|
if (doEval) |
||||
|
{ |
||||
|
// Re-evaluate the cost of an updated pair.
|
||||
|
HistoQueueUpdatePair(histograms[p.Idx1], histograms[p.Idx2], 0.0d, p); |
||||
|
if (p.CostDiff >= 0.0d) |
||||
|
{ |
||||
|
indicesToRemove.Add(lastIndex); |
||||
|
lastIndex--; |
||||
|
numUsed--; |
||||
|
continue; |
||||
|
} |
||||
|
} |
||||
|
|
||||
|
HistoQueueUpdateHead(histoPriorityList, p); |
||||
|
j++; |
||||
|
} |
||||
|
|
||||
|
triesWithNoSuccess = 0; |
||||
|
} |
||||
|
|
||||
|
bool doGreedy = numUsed <= minClusterSize; |
||||
|
|
||||
|
return doGreedy; |
||||
|
} |
||||
|
|
||||
|
private static void HistogramCombineGreedy(List<Vp8LHistogram> histograms, ref int numUsed) |
||||
|
{ |
||||
|
int histoSize = histograms.Count; |
||||
|
|
||||
|
// Priority list of histogram pairs.
|
||||
|
var histoPriorityList = new List<HistogramPair>(); |
||||
|
int maxHistoQueueSize = histoSize * histoSize; |
||||
|
|
||||
|
for (int i = 0; i < histograms.Count; i++) |
||||
|
{ |
||||
|
for (int j = i + 1; j < histograms.Count; j++) |
||||
|
{ |
||||
|
// Initialize queue.
|
||||
|
HistoQueuePush(histoPriorityList, maxHistoQueueSize, histograms, i, j, 0.0d); |
||||
|
} |
||||
|
} |
||||
|
|
||||
|
while (histoPriorityList.Count > 0) |
||||
|
{ |
||||
|
int idx1 = histoPriorityList[0].Idx1; |
||||
|
int idx2 = histoPriorityList[0].Idx2; |
||||
|
HistogramAdd(histograms[idx2], histograms[idx1], histograms[idx1]); |
||||
|
histograms[idx1].BitCost = histoPriorityList[0].CostCombo; |
||||
|
|
||||
|
// Remove merged histogram.
|
||||
|
histograms.RemoveAt(idx2); |
||||
|
numUsed--; |
||||
|
|
||||
|
// Remove pairs intersecting the just combined best pair.
|
||||
|
for (int i = 0; i < histoPriorityList.Count;) |
||||
|
{ |
||||
|
HistogramPair p = histoPriorityList.ElementAt(i); |
||||
|
if (p.Idx1 == idx1 || p.Idx2 == idx1 || p.Idx1 == idx2 || p.Idx2 == idx2) |
||||
|
{ |
||||
|
// Remove last entry from the queue.
|
||||
|
p = histoPriorityList.ElementAt(histoPriorityList.Count - 1); |
||||
|
histoPriorityList.RemoveAt(histoPriorityList.Count - 1); // TODO: use list instead Queue?
|
||||
|
} |
||||
|
else |
||||
|
{ |
||||
|
HistoQueueUpdateHead(histoPriorityList, p); |
||||
|
i++; |
||||
|
} |
||||
|
} |
||||
|
|
||||
|
// Push new pairs formed with combined histogram to the queue.
|
||||
|
for (int i = 0; i < histograms.Count; i++) |
||||
|
{ |
||||
|
if (i == idx1) |
||||
|
{ |
||||
|
continue; |
||||
|
} |
||||
|
|
||||
|
HistoQueuePush(histoPriorityList, maxHistoQueueSize, histograms, idx1, i, 0.0d); |
||||
|
} |
||||
|
} |
||||
|
} |
||||
|
|
||||
|
/// <summary>
|
||||
|
/// // Create a pair from indices "idx1" and "idx2" provided its cost
|
||||
|
/// is inferior to "threshold", a negative entropy.
|
||||
|
/// </summary>
|
||||
|
/// <returns>The cost of the pair, or 0. if it superior to threshold.</returns>
|
||||
|
private static double HistoQueuePush(List<HistogramPair> histoQueue, int queueMaxSize, List<Vp8LHistogram> histograms, int idx1, int idx2, double threshold) |
||||
|
{ |
||||
|
var pair = new HistogramPair(); |
||||
|
|
||||
|
// Stop here if the queue is full.
|
||||
|
if (histoQueue.Count == queueMaxSize) |
||||
|
{ |
||||
|
return 0.0d; |
||||
|
} |
||||
|
|
||||
|
if (idx1 > idx2) |
||||
|
{ |
||||
|
int tmp = idx2; |
||||
|
idx2 = idx1; |
||||
|
idx1 = tmp; |
||||
|
} |
||||
|
|
||||
|
pair.Idx1 = idx1; |
||||
|
pair.Idx2 = idx2; |
||||
|
Vp8LHistogram h1 = histograms[idx1]; |
||||
|
Vp8LHistogram h2 = histograms[idx2]; |
||||
|
|
||||
|
HistoQueueUpdatePair(h1, h2, threshold, pair); |
||||
|
|
||||
|
// Do not even consider the pair if it does not improve the entropy.
|
||||
|
if (pair.CostDiff >= threshold) |
||||
|
{ |
||||
|
return 0.0d; |
||||
|
} |
||||
|
|
||||
|
histoQueue.Add(pair); |
||||
|
|
||||
|
HistoQueueUpdateHead(histoQueue, pair); |
||||
|
|
||||
|
return pair.CostDiff; |
||||
|
} |
||||
|
|
||||
|
/// <summary>
|
||||
|
/// Update the cost diff and combo of a pair of histograms. This needs to be
|
||||
|
/// called when the the histograms have been merged with a third one.
|
||||
|
/// </summary>
|
||||
|
private static void HistoQueueUpdatePair(Vp8LHistogram h1, Vp8LHistogram h2, double threshold, HistogramPair pair) |
||||
|
{ |
||||
|
double sumCost = h1.BitCost + h2.BitCost; |
||||
|
pair.CostCombo = GetCombinedHistogramEntropy(h1, h2, sumCost + threshold); |
||||
|
pair.CostDiff = pair.CostCombo - sumCost; |
||||
|
} |
||||
|
|
||||
|
private static double GetCombinedHistogramEntropy(Vp8LHistogram a, Vp8LHistogram b, double costThreshold) |
||||
|
{ |
||||
|
double cost = 0.0d; |
||||
|
int paletteCodeBits = a.PaletteCodeBits; |
||||
|
bool trivialAtEnd = false; |
||||
|
|
||||
|
cost += GetCombinedEntropy(a.Literal, b.Literal, Vp8LHistogram.HistogramNumCodes(paletteCodeBits), a.IsUsed[0], b.IsUsed[0], false); |
||||
|
|
||||
|
cost += ExtraCostCombined(a.Literal.AsSpan(WebPConstants.NumLiteralCodes), b.Literal.AsSpan(WebPConstants.NumLiteralCodes), WebPConstants.NumLengthCodes); |
||||
|
|
||||
|
if (cost > costThreshold) |
||||
|
{ |
||||
|
return 0; |
||||
|
} |
||||
|
|
||||
|
if (a.TrivialSymbol != NonTrivialSym && a.TrivialSymbol == b.TrivialSymbol) |
||||
|
{ |
||||
|
// A, R and B are all 0 or 0xff.
|
||||
|
uint color_a = (a.TrivialSymbol >> 24) & 0xff; |
||||
|
uint color_r = (a.TrivialSymbol >> 16) & 0xff; |
||||
|
uint color_b = (a.TrivialSymbol >> 0) & 0xff; |
||||
|
if ((color_a == 0 || color_a == 0xff) && |
||||
|
(color_r == 0 || color_r == 0xff) && |
||||
|
(color_b == 0 || color_b == 0xff)) |
||||
|
{ |
||||
|
trivialAtEnd = true; |
||||
|
} |
||||
|
} |
||||
|
|
||||
|
cost += GetCombinedEntropy(a.Red, b.Red, WebPConstants.NumLiteralCodes, a.IsUsed[1], b.IsUsed[1], trivialAtEnd); |
||||
|
|
||||
|
return cost; |
||||
|
} |
||||
|
|
||||
|
private static double GetCombinedEntropy(uint[] x, uint[] y, int length, bool isXUsed, bool isYUsed, bool trivialAtEnd) |
||||
|
{ |
||||
|
var stats = new Vp8LStreaks(); |
||||
|
if (trivialAtEnd) |
||||
|
{ |
||||
|
// This configuration is due to palettization that transforms an indexed
|
||||
|
// pixel into 0xff000000 | (pixel << 8) in BundleColorMap.
|
||||
|
// BitsEntropyRefine is 0 for histograms with only one non-zero value.
|
||||
|
// Only FinalHuffmanCost needs to be evaluated.
|
||||
|
|
||||
|
// Deal with the non-zero value at index 0 or length-1.
|
||||
|
stats.Streaks[1][0] = 1; |
||||
|
|
||||
|
// Deal with the following/previous zero streak.
|
||||
|
stats.Counts[0] = 1; |
||||
|
stats.Streaks[0][1] = length - 1; |
||||
|
|
||||
|
return stats.FinalHuffmanCost(); |
||||
|
} |
||||
|
|
||||
|
var bitEntropy = new Vp8LBitEntropy(); |
||||
|
if (isXUsed) |
||||
|
{ |
||||
|
if (isYUsed) |
||||
|
{ |
||||
|
bitEntropy.GetCombinedEntropyUnrefined(x, y, length, stats); |
||||
|
} |
||||
|
else |
||||
|
{ |
||||
|
bitEntropy.GetEntropyUnrefined(x, length, stats); |
||||
|
} |
||||
|
} |
||||
|
else |
||||
|
{ |
||||
|
if (isYUsed) |
||||
|
{ |
||||
|
bitEntropy.GetEntropyUnrefined(y, length, stats); |
||||
|
} |
||||
|
else |
||||
|
{ |
||||
|
stats.Counts[0] = 1; |
||||
|
stats.Streaks[0][length > 3 ? 1 : 0] = length; |
||||
|
bitEntropy.Init(); |
||||
|
} |
||||
|
} |
||||
|
|
||||
|
return bitEntropy.BitsEntropyRefine() + stats.FinalHuffmanCost(); |
||||
|
} |
||||
|
|
||||
|
private static double ExtraCostCombined(Span<uint> x, Span<uint> y, int length) |
||||
|
{ |
||||
|
double cost = 0.0d; |
||||
|
for (int i = 2; i < length - 2; i++) |
||||
|
{ |
||||
|
int xy = (int)(x[i + 2] + y[i + 2]); |
||||
|
cost += (i >> 1) * xy; |
||||
|
} |
||||
|
|
||||
|
return cost; |
||||
|
} |
||||
|
|
||||
|
private static void HistogramAdd(Vp8LHistogram a, Vp8LHistogram b, Vp8LHistogram output) |
||||
|
{ |
||||
|
// TODO: VP8LHistogramAdd(a, b, out);
|
||||
|
output.TrivialSymbol = (a.TrivialSymbol == b.TrivialSymbol) |
||||
|
? a.TrivialSymbol |
||||
|
: NonTrivialSym; |
||||
|
} |
||||
|
|
||||
|
/// <summary>
|
||||
|
/// Check whether a pair in the list should be updated as head or not.
|
||||
|
/// </summary>
|
||||
|
private static void HistoQueueUpdateHead(List<HistogramPair> histoQueue, HistogramPair pair) |
||||
|
{ |
||||
|
if (pair.CostDiff < histoQueue[0].CostDiff) |
||||
|
{ |
||||
|
// Replace the best pair.
|
||||
|
histoQueue.RemoveAt(0); |
||||
|
histoQueue.Insert(0, pair); |
||||
|
} |
||||
|
} |
||||
|
|
||||
|
private static double GetCombineCostFactor(int histoSize, int quality) |
||||
|
{ |
||||
|
double combineCostFactor = 0.16d; |
||||
|
if (quality < 90) |
||||
|
{ |
||||
|
if (histoSize > 256) |
||||
|
{ |
||||
|
combineCostFactor /= 2.0d; |
||||
|
} |
||||
|
|
||||
|
if (histoSize > 512) |
||||
|
{ |
||||
|
combineCostFactor /= 2.0d; |
||||
|
} |
||||
|
|
||||
|
if (histoSize > 1024) |
||||
|
{ |
||||
|
combineCostFactor /= 2.0d; |
||||
|
} |
||||
|
|
||||
|
if (quality <= 50) |
||||
|
{ |
||||
|
combineCostFactor /= 2.0d; |
||||
|
} |
||||
|
} |
||||
|
|
||||
|
return combineCostFactor; |
||||
|
} |
||||
|
} |
||||
|
} |
||||
@ -0,0 +1,19 @@ |
|||||
|
// Copyright (c) Six Labors and contributors.
|
||||
|
// Licensed under the GNU Affero General Public License, Version 3.
|
||||
|
|
||||
|
namespace SixLabors.ImageSharp.Formats.WebP.Lossless |
||||
|
{ |
||||
|
/// <summary>
|
||||
|
/// Pair of histograms. Negative Idx1 value means that pair is out-of-date.
|
||||
|
/// </summary>
|
||||
|
internal class HistogramPair |
||||
|
{ |
||||
|
public int Idx1 { get; set; } |
||||
|
|
||||
|
public int Idx2 { get; set; } |
||||
|
|
||||
|
public double CostDiff { get; set; } |
||||
|
|
||||
|
public double CostCombo { get; set; } |
||||
|
} |
||||
|
} |
||||
Loading…
Reference in new issue