private static void BackwardReferencesHashChainFollowChosenPath(ReadOnlySpan <uint> bgra, int cacheBits, Span <ushort> chosenPath, int chosenPathSize, Vp8LHashChain hashChain, Vp8LBackwardRefs backwardRefs)
{
bool useColorCache = cacheBits > 0;
var colorCache = new ColorCache();
int i = 0;
if (useColorCache)
{
colorCache.Init(cacheBits);
}
backwardRefs.Refs.Clear();
for (int ix = 0; ix < chosenPathSize; ix++)
{
int len = chosenPath[ix];
if (len != 1)
{
int offset = hashChain.FindOffset(i);
backwardRefs.Add(PixOrCopy.CreateCopy((uint)offset, (ushort)len));
if (useColorCache)
{
for (int k = 0; k < len; k++)
{
colorCache.Insert(bgra[i + k]);
}
}
i += len;
}
else
{
PixOrCopy v;
int idx = useColorCache ? colorCache.Contains(bgra[i]) : -1;
if (idx >= 0)
{
// useColorCache is true and color cache contains bgra[i]
// Push pixel as a color cache index.
v = PixOrCopy.CreateCacheIdx(idx);
}
else
{
if (useColorCache)
{
colorCache.Insert(bgra[i]);
}
v = PixOrCopy.CreateLiteral(bgra[i]);
}
backwardRefs.Add(v);
i++;
}
}
}
private static void BackwardReferencesRle(int xSize, int ySize, ReadOnlySpan <uint> bgra, int cacheBits, Vp8LBackwardRefs refs)
{
int pixelCount = xSize * ySize;
bool useColorCache = cacheBits > 0;
var colorCache = new ColorCache();
if (useColorCache)
{
colorCache.Init(cacheBits);
}
refs.Refs.Clear();
// Add first pixel as literal.
AddSingleLiteral(bgra[0], useColorCache, colorCache, refs);
int i = 1;
while (i < pixelCount)
{
int maxLen = LosslessUtils.MaxFindCopyLength(pixelCount - i);
int rleLen = LosslessUtils.FindMatchLength(bgra.Slice(i), bgra.Slice(i - 1), 0, maxLen);
int prevRowLen = i < xSize ? 0 : LosslessUtils.FindMatchLength(bgra.Slice(i), bgra.Slice(i - xSize), 0, maxLen);
if (rleLen >= prevRowLen && rleLen >= MinLength)
{
refs.Add(PixOrCopy.CreateCopy(1, (ushort)rleLen));
// We don't need to update the color cache here since it is always the
// same pixel being copied, and that does not change the color cache state.
i += rleLen;
}
else if (prevRowLen >= MinLength)
{
refs.Add(PixOrCopy.CreateCopy((uint)xSize, (ushort)prevRowLen));
if (useColorCache)
{
for (int k = 0; k < prevRowLen; ++k)
{
colorCache.Insert(bgra[i + k]);
}
}
i += prevRowLen;
}
else
{
AddSingleLiteral(bgra[i], useColorCache, colorCache, refs);
i++;
}
}
}
private void AdvanceByOne(ref int col, ref int row, int width, ColorCache colorCache, ref int decodedPixels, Span <uint> pixelData, ref int lastCached)
{
col++;
decodedPixels++;
if (col >= width)
{
col = 0;
row++;
if (colorCache != null)
{
while (lastCached < decodedPixels)
{
colorCache.Insert(pixelData[lastCached]);
lastCached++;
}
}
}
}
/// <summary>
/// Update (in-place) backward references for the specified cacheBits.
/// </summary>
private static void BackwardRefsWithLocalCache(ReadOnlySpan <uint> bgra, int cacheBits, Vp8LBackwardRefs refs)
{
int pixelIndex = 0;
var colorCache = new ColorCache();
colorCache.Init(cacheBits);
for (int idx = 0; idx < refs.Refs.Count; idx++)
{
PixOrCopy v = refs.Refs[idx];
if (v.IsLiteral())
{
uint bgraLiteral = v.BgraOrDistance;
int ix = colorCache.Contains(bgraLiteral);
if (ix >= 0)
{
// Color cache contains bgraLiteral
v.Mode = PixOrCopyMode.CacheIdx;
v.BgraOrDistance = (uint)ix;
v.Len = 1;
}
else
{
colorCache.Insert(bgraLiteral);
}
pixelIndex++;
}
else
{
// refs was created without local cache, so it can not have cache indexes.
for (int k = 0; k < v.Len; ++k)
{
colorCache.Insert(bgra[pixelIndex++]);
}
}
}
}
private static void AddSingleLiteral(uint pixel, bool useColorCache, ColorCache colorCache, Vp8LBackwardRefs refs)
{
PixOrCopy v;
if (useColorCache)
{
int key = colorCache.GetIndex(pixel);
if (colorCache.Lookup(key) == pixel)
{
v = PixOrCopy.CreateCacheIdx(key);
}
else
{
v = PixOrCopy.CreateLiteral(pixel);
colorCache.Set((uint)key, pixel);
}
}
else
{
v = PixOrCopy.CreateLiteral(pixel);
}
refs.Add(v);
}
private static void AddSingleLiteralWithCostModel(
ReadOnlySpan <uint> bgra,
ColorCache colorCache,
CostModel costModel,
int idx,
bool useColorCache,
float prevCost,
Span <float> cost,
Span <ushort> distArray)
{
double costVal = prevCost;
uint color = bgra[idx];
int ix = useColorCache ? colorCache.Contains(color) : -1;
if (ix >= 0)
{
double mul0 = 0.68;
costVal += costModel.GetCacheCost((uint)ix) * mul0;
}
else
{
double mul1 = 0.82;
if (useColorCache)
{
colorCache.Insert(color);
}
costVal += costModel.GetLiteralCost(color) * mul1;
}
if (cost[idx] > costVal)
{
cost[idx] = (float)costVal;
distArray[idx] = 1; // only one is inserted.
}
}
private static void BackwardReferencesLz77(int xSize, int ySize, ReadOnlySpan <uint> bgra, int cacheBits, Vp8LHashChain hashChain, Vp8LBackwardRefs refs)
{
int iLastCheck = -1;
bool useColorCache = cacheBits > 0;
int pixCount = xSize * ySize;
var colorCache = new ColorCache();
if (useColorCache)
{
colorCache.Init(cacheBits);
}
refs.Refs.Clear();
for (int i = 0; i < pixCount;)
{
// Alternative #1: Code the pixels starting at 'i' using backward reference.
int j;
int offset = hashChain.FindOffset(i);
int len = hashChain.FindLength(i);
if (len >= MinLength)
{
int lenIni = len;
int maxReach = 0;
int jMax = i + lenIni >= pixCount ? pixCount - 1 : i + lenIni;
// Only start from what we have not checked already.
iLastCheck = i > iLastCheck ? i : iLastCheck;
// We know the best match for the current pixel but we try to find the
// best matches for the current pixel AND the next one combined.
// The naive method would use the intervals:
// [i,i+len) + [i+len, length of best match at i+len)
// while we check if we can use:
// [i,j) (where j<=i+len) + [j, length of best match at j)
for (j = iLastCheck + 1; j <= jMax; j++)
{
int lenJ = hashChain.FindLength(j);
int reach = j + (lenJ >= MinLength ? lenJ : 1); // 1 for single literal.
if (reach > maxReach)
{
len = j - i;
maxReach = reach;
if (maxReach >= pixCount)
{
break;
}
}
}
}
else
{
len = 1;
}
// Go with literal or backward reference.
if (len == 1)
{
AddSingleLiteral(bgra[i], useColorCache, colorCache, refs);
}
else
{
refs.Add(PixOrCopy.CreateCopy((uint)offset, (ushort)len));
if (useColorCache)
{
for (j = i; j < i + len; j++)
{
colorCache.Insert(bgra[j]);
}
}
}
i += len;
}
}
private static void BackwardReferencesHashChainDistanceOnly(
int xSize,
int ySize,
MemoryAllocator memoryAllocator,
ReadOnlySpan <uint> bgra,
int cacheBits,
Vp8LHashChain hashChain,
Vp8LBackwardRefs refs,
IMemoryOwner <ushort> distArrayBuffer)
{
int pixCount = xSize * ySize;
bool useColorCache = cacheBits > 0;
int literalArraySize = WebpConstants.NumLiteralCodes + WebpConstants.NumLengthCodes + (cacheBits > 0 ? 1 << cacheBits : 0);
var costModel = new CostModel(literalArraySize);
int offsetPrev = -1;
int lenPrev = -1;
double offsetCost = -1;
int firstOffsetIsConstant = -1; // initialized with 'impossible' value.
int reach = 0;
var colorCache = new ColorCache();
if (useColorCache)
{
colorCache.Init(cacheBits);
}
costModel.Build(xSize, cacheBits, refs);
using var costManager = new CostManager(memoryAllocator, distArrayBuffer, pixCount, costModel);
Span <float> costManagerCosts = costManager.Costs.GetSpan();
Span <ushort> distArray = distArrayBuffer.GetSpan();
// We loop one pixel at a time, but store all currently best points to non-processed locations from this point.
distArray[0] = 0;
// Add first pixel as literal.
AddSingleLiteralWithCostModel(bgra, colorCache, costModel, 0, useColorCache, 0.0f, costManagerCosts, distArray);
for (int i = 1; i < pixCount; i++)
{
float prevCost = costManagerCosts[i - 1];
int offset = hashChain.FindOffset(i);
int len = hashChain.FindLength(i);
// Try adding the pixel as a literal.
AddSingleLiteralWithCostModel(bgra, colorCache, costModel, i, useColorCache, prevCost, costManagerCosts, distArray);
// If we are dealing with a non-literal.
if (len >= 2)
{
if (offset != offsetPrev)
{
int code = DistanceToPlaneCode(xSize, offset);
offsetCost = costModel.GetDistanceCost(code);
firstOffsetIsConstant = 1;
costManager.PushInterval(prevCost + offsetCost, i, len);
}
else
{
// Instead of considering all contributions from a pixel i by calling:
// costManager.PushInterval(prevCost + offsetCost, i, len);
// we optimize these contributions in case offsetCost stays the same
// for consecutive pixels. This describes a set of pixels similar to a
// previous set (e.g. constant color regions).
if (firstOffsetIsConstant != 0)
{
reach = i - 1 + lenPrev - 1;
firstOffsetIsConstant = 0;
}
if (i + len - 1 > reach)
{
int lenJ = 0;
int j;
for (j = i; j <= reach; j++)
{
int offsetJ = hashChain.FindOffset(j + 1);
lenJ = hashChain.FindLength(j + 1);
if (offsetJ != offset)
{
lenJ = hashChain.FindLength(j);
break;
}
}
// Update the cost at j - 1 and j.
costManager.UpdateCostAtIndex(j - 1, false);
costManager.UpdateCostAtIndex(j, false);
costManager.PushInterval(costManagerCosts[j - 1] + offsetCost, j, lenJ);
reach = j + lenJ - 1;
}
}
}
costManager.UpdateCostAtIndex(i, true);
offsetPrev = offset;
lenPrev = len;
}
}
/// <summary>
/// Evaluate optimal cache bits for the local color cache.
/// The input bestCacheBits sets the maximum cache bits to use (passing 0 implies disabling the local color cache).
/// The local color cache is also disabled for the lower (smaller then 25) quality.
/// </summary>
/// <returns>Best cache size.</returns>
private static int CalculateBestCacheSize(ReadOnlySpan <uint> bgra, int quality, Vp8LBackwardRefs refs, int bestCacheBits)
{
int cacheBitsMax = quality <= 25 ? 0 : bestCacheBits;
if (cacheBitsMax == 0)
{
// Local color cache is disabled.
return(0);
}
double entropyMin = MaxEntropy;
int pos = 0;
var colorCache = new ColorCache[WebpConstants.MaxColorCacheBits + 1];
var histos = new Vp8LHistogram[WebpConstants.MaxColorCacheBits + 1];
for (int i = 0; i <= WebpConstants.MaxColorCacheBits; i++)
{
histos[i] = new Vp8LHistogram(paletteCodeBits: i);
colorCache[i] = new ColorCache();
colorCache[i].Init(i);
}
// Find the cacheBits giving the lowest entropy.
for (int idx = 0; idx < refs.Refs.Count; idx++)
{
PixOrCopy v = refs.Refs[idx];
if (v.IsLiteral())
{
uint pix = bgra[pos++];
uint a = (pix >> 24) & 0xff;
uint r = (pix >> 16) & 0xff;
uint g = (pix >> 8) & 0xff;
uint b = (pix >> 0) & 0xff;
// The keys of the caches can be derived from the longest one.
int key = ColorCache.HashPix(pix, 32 - cacheBitsMax);
// Do not use the color cache for cacheBits = 0.
++histos[0].Blue[b];
++histos[0].Literal[g];
++histos[0].Red[r];
++histos[0].Alpha[a];
// Deal with cacheBits > 0.
for (int i = cacheBitsMax; i >= 1; --i, key >>= 1)
{
if (colorCache[i].Lookup(key) == pix)
{
++histos[i].Literal[WebpConstants.NumLiteralCodes + WebpConstants.NumLengthCodes + key];
}
else
{
colorCache[i].Set((uint)key, pix);
++histos[i].Blue[b];
++histos[i].Literal[g];
++histos[i].Red[r];
++histos[i].Alpha[a];
}
}
}
else
{
// We should compute the contribution of the (distance, length)
// histograms but those are the same independently from the cache size.
// As those constant contributions are in the end added to the other
// histogram contributions, we can ignore them, except for the length
// prefix that is part of the literal_ histogram.
int len = v.Len;
uint bgraPrev = bgra[pos] ^ 0xffffffffu;
int extraBits = 0, extraBitsValue = 0;
int code = LosslessUtils.PrefixEncode(len, ref extraBits, ref extraBitsValue);
for (int i = 0; i <= cacheBitsMax; i++)
{
++histos[i].Literal[WebpConstants.NumLiteralCodes + code];
}
// Update the color caches.
do
{
if (bgra[pos] != bgraPrev)
{
// Efficiency: insert only if the color changes.
int key = ColorCache.HashPix(bgra[pos], 32 - cacheBitsMax);
for (int i = cacheBitsMax; i >= 1; --i, key >>= 1)
{
colorCache[i].Colors[key] = bgra[pos];
}
bgraPrev = bgra[pos];
}
pos++;
}while (--len != 0);
}
}
var stats = new Vp8LStreaks();
var bitsEntropy = new Vp8LBitEntropy();
for (int i = 0; i <= cacheBitsMax; i++)
{
double entropy = histos[i].EstimateBits(stats, bitsEntropy);
if (i == 0 || entropy < entropyMin)
{
entropyMin = entropy;
bestCacheBits = i;
}
}
return(bestCacheBits);
}
public void DecodeImageData(Vp8LDecoder decoder, Span <uint> pixelData)
{
int lastPixel = 0;
int width = decoder.Width;
int height = decoder.Height;
int row = lastPixel / width;
int col = lastPixel % width;
const int lenCodeLimit = WebpConstants.NumLiteralCodes + WebpConstants.NumLengthCodes;
int colorCacheSize = decoder.Metadata.ColorCacheSize;
ColorCache colorCache = decoder.Metadata.ColorCache;
int colorCacheLimit = lenCodeLimit + colorCacheSize;
int mask = decoder.Metadata.HuffmanMask;
Span <HTreeGroup> hTreeGroup = GetHTreeGroupForPos(decoder.Metadata, col, row);
int totalPixels = width * height;
int decodedPixels = 0;
int lastCached = decodedPixels;
while (decodedPixels < totalPixels)
{
int code;
if ((col & mask) == 0)
{
hTreeGroup = GetHTreeGroupForPos(decoder.Metadata, col, row);
}
if (hTreeGroup[0].IsTrivialCode)
{
pixelData[decodedPixels] = hTreeGroup[0].LiteralArb;
this.AdvanceByOne(ref col, ref row, width, colorCache, ref decodedPixels, pixelData, ref lastCached);
continue;
}
this.bitReader.FillBitWindow();
if (hTreeGroup[0].UsePackedTable)
{
code = (int)this.ReadPackedSymbols(hTreeGroup, pixelData, decodedPixels);
if (this.bitReader.IsEndOfStream())
{
break;
}
if (code == PackedNonLiteralCode)
{
this.AdvanceByOne(ref col, ref row, width, colorCache, ref decodedPixels, pixelData, ref lastCached);
continue;
}
}
else
{
code = (int)this.ReadSymbol(hTreeGroup[0].HTrees[HuffIndex.Green]);
}
if (this.bitReader.IsEndOfStream())
{
break;
}
// Literal
if (code < WebpConstants.NumLiteralCodes)
{
if (hTreeGroup[0].IsTrivialLiteral)
{
pixelData[decodedPixels] = hTreeGroup[0].LiteralArb | ((uint)code << 8);
}
else
{
uint red = this.ReadSymbol(hTreeGroup[0].HTrees[HuffIndex.Red]);
this.bitReader.FillBitWindow();
uint blue = this.ReadSymbol(hTreeGroup[0].HTrees[HuffIndex.Blue]);
uint alpha = this.ReadSymbol(hTreeGroup[0].HTrees[HuffIndex.Alpha]);
if (this.bitReader.IsEndOfStream())
{
break;
}
pixelData[decodedPixels] = (uint)(((byte)alpha << 24) | ((byte)red << 16) | ((byte)code << 8) | (byte)blue);
}
this.AdvanceByOne(ref col, ref row, width, colorCache, ref decodedPixels, pixelData, ref lastCached);
}
else if (code < lenCodeLimit)
{
// Backward reference is used.
int lengthSym = code - WebpConstants.NumLiteralCodes;
int length = this.GetCopyLength(lengthSym);
uint distSymbol = this.ReadSymbol(hTreeGroup[0].HTrees[HuffIndex.Dist]);
this.bitReader.FillBitWindow();
int distCode = this.GetCopyDistance((int)distSymbol);
int dist = PlaneCodeToDistance(width, distCode);
if (this.bitReader.IsEndOfStream())
{
break;
}
CopyBlock(pixelData, decodedPixels, dist, length);
decodedPixels += length;
col += length;
while (col >= width)
{
col -= width;
row++;
}
if ((col & mask) != 0)
{
hTreeGroup = GetHTreeGroupForPos(decoder.Metadata, col, row);
}
if (colorCache != null)
{
while (lastCached < decodedPixels)
{
colorCache.Insert(pixelData[lastCached]);
lastCached++;
}
}
}
else if (code < colorCacheLimit)
{
// Color cache should be used.
int key = code - lenCodeLimit;
while (lastCached < decodedPixels)
{
colorCache.Insert(pixelData[lastCached]);
lastCached++;
}
pixelData[decodedPixels] = colorCache.Lookup(key);
this.AdvanceByOne(ref col, ref row, width, colorCache, ref decodedPixels, pixelData, ref lastCached);
}
else
{
WebpThrowHelper.ThrowImageFormatException("Webp parsing error");
}
}
}
