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++; } } }
/// <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 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; } }