mirror of https://github.com/SixLabors/ImageSharp
winscripter
4 weeks ago
10 changed files with 1895 additions and 5 deletions
@ -1,13 +1,13 @@ |
|||
// Copyright (c) Six Labors.
|
|||
// Licensed under the Six Labors Split License.
|
|||
|
|||
using SixLabors.ImageSharp.Formats.Jxl.Processing.Splines; |
|||
using SixLabors.ImageSharp.Formats.Jxl.Processing.Modular.Encoding; |
|||
|
|||
namespace SixLabors.ImageSharp.Formats.Jxl.Processing.Encoder.Ans; |
|||
|
|||
internal struct JxlToken(JxlSplineEntropyContext c, uint value) |
|||
internal struct JxlToken(JxlMaTreeContext c, uint value) |
|||
{ |
|||
public bool IsLz77Length; |
|||
public JxlSplineEntropyContext Context = c; |
|||
public JxlMaTreeContext Context = c; |
|||
public uint Value = value; |
|||
} |
|||
|
|||
@ -0,0 +1,865 @@ |
|||
// Copyright (c) Six Labors.
|
|||
// Licensed under the Six Labors Split License.
|
|||
|
|||
using System.Buffers; |
|||
using System.Numerics; |
|||
using System.Numerics.Tensors; |
|||
using System.Runtime.CompilerServices; |
|||
using System.Runtime.InteropServices; |
|||
using SixLabors.ImageSharp.Formats.Jxl.IO.Entropy; |
|||
using SixLabors.ImageSharp.Formats.Jxl.Processing.Encoder.Ans; |
|||
using SixLabors.ImageSharp.Formats.Jxl.Processing.Modular.Encoding.ContextPrediction; |
|||
using SixLabors.ImageSharp.Formats.Jxl.Processing.Primitives; |
|||
using StaticPropertyRange = System.Runtime.CompilerServices.InlineArray2<System.Runtime.CompilerServices.InlineArray2<int>>; |
|||
using Tree = System.Collections.Generic.List<SixLabors.ImageSharp.Formats.Jxl.Processing.Modular.Encoding.JxlPropertyDecisionNode>; |
|||
|
|||
namespace SixLabors.ImageSharp.Formats.Jxl.Processing.Modular.Encoding; |
|||
|
|||
internal static class JxlMaEncoder |
|||
{ |
|||
internal enum IntersectionType |
|||
{ |
|||
None, |
|||
Partial, |
|||
Inside |
|||
} |
|||
|
|||
private static int Padded(int x) => JxlMath.RoundUpTo(x, Vector<float>.Count); |
|||
|
|||
public static float EstimateBits(Span<int> counts, int numSymbols) |
|||
{ |
|||
int total = TensorPrimitives.Sum((ReadOnlySpan<int>)counts.Slice(0, numSymbols)); |
|||
|
|||
Vector<float> minprob = Vector.Create(1.0f / JxlAnsConstants.AnsTableSize); |
|||
Vector<float> inverseTotal = Vector.Create(1.0f / total); |
|||
Vector<float> bitsLanes = Vector<float>.Zero; |
|||
|
|||
for (int i = 0; i < numSymbols; i += Vector<float>.Count) |
|||
{ |
|||
Vector<int> countsIv = new(counts[i..]); |
|||
Vector<float> countsFv = Vector.ConvertToSingle(countsIv); |
|||
Vector<float> probs = countsFv * inverseTotal; |
|||
Vector<float> mprobs = probs * minprob; |
|||
|
|||
Vector<float> nbps = Vector.ConditionalSelect( |
|||
Vector.Equals(countsIv, Vector.Create(total)), |
|||
Vector<float>.Zero, |
|||
Vector.Log2(mprobs)); |
|||
|
|||
bitsLanes -= countsFv * nbps; |
|||
} |
|||
|
|||
return Vector.Sum(bitsLanes); |
|||
} |
|||
|
|||
public static void MakeSplitNode(int pos, int property, int splitValue, JxlPredictor leftPredictor, int leftOffset, JxlPredictor rightPredictor, int rightOffset, Tree tree) |
|||
{ |
|||
ref JxlPropertyDecisionNode treePos = ref CollectionsMarshal.AsSpan(tree)[pos]; |
|||
|
|||
treePos.LeftChild = tree.Count; |
|||
treePos.RightChild = tree.Count + 1; |
|||
treePos.SplitValue = splitValue; |
|||
treePos.Property = property; |
|||
|
|||
JxlPropertyDecisionNode newRightNode = new() |
|||
{ |
|||
Property = -1, |
|||
Predictor = rightPredictor, |
|||
PredictorOffset = rightOffset, |
|||
Multiplier = 1 |
|||
}; |
|||
|
|||
JxlPropertyDecisionNode newLeftNode = new() |
|||
{ |
|||
Property = -1, |
|||
Predictor = leftPredictor, |
|||
PredictorOffset = leftOffset, |
|||
Multiplier = 1 |
|||
}; |
|||
|
|||
tree.Add(newRightNode); |
|||
tree.Add(newLeftNode); |
|||
} |
|||
|
|||
public static IntersectionType BoxIntersects(StaticPropertyRange needle, StaticPropertyRange haystack, ref int partialAxis, ref int partialValue) |
|||
{ |
|||
bool partial = false; |
|||
|
|||
for (int i = 0; i < JxlPredictorFacts.StaticProperties; i++) |
|||
{ |
|||
if (haystack[i][0] >= needle[i][1]) |
|||
{ |
|||
return IntersectionType.None; |
|||
} |
|||
|
|||
if (haystack[i][1] <= needle[i][0]) |
|||
{ |
|||
return IntersectionType.None; |
|||
} |
|||
|
|||
if (haystack[i][0] <= needle[i][0] && haystack[i][1] >= needle[i][1]) |
|||
{ |
|||
continue; |
|||
} |
|||
|
|||
partial = true; |
|||
partialAxis = i; |
|||
|
|||
int innerOffset = haystack[i][0] > needle[i][0] && haystack[i][0] < needle[i][1] ? 0 : 1; // yes, if true then 0 not 1
|
|||
partialValue = haystack[i][innerOffset] - 1; |
|||
} |
|||
|
|||
return partial ? IntersectionType.Partial : IntersectionType.Inside; |
|||
} |
|||
|
|||
public static void SplitTreeSamples(bool s, JxlTreeSamples samples, int begin, int pos, int end, int prop, int value) |
|||
{ |
|||
int beginPos = begin; |
|||
int endPos = pos; |
|||
|
|||
do |
|||
{ |
|||
while (beginPos < pos && samples.GetProperty(s, prop, beginPos) <= value) |
|||
{ |
|||
beginPos++; |
|||
} |
|||
|
|||
while (endPos < end && samples.GetProperty(s, prop, endPos) > value) |
|||
{ |
|||
endPos++; |
|||
} |
|||
|
|||
if (beginPos < pos && endPos < end) |
|||
{ |
|||
samples.Swap(beginPos, endPos); |
|||
} |
|||
|
|||
beginPos++; |
|||
endPos++; |
|||
} |
|||
while (beginPos < pos && endPos < end); |
|||
} |
|||
|
|||
// Simple overload so we don't have to type out CollectionsMarshal.AsSpan all the time.
|
|||
public static void CollectExtraBitsIncrease(bool s, JxlTreeSamples treeSamples, List<JxlResidualToken> residualTokens, List<int> countIncrease, List<int> extraBitsIncrease, int begin, int end, int propertyIndex, int maxSymbols) |
|||
=> CollectExtraBitsIncrease( |
|||
s, |
|||
treeSamples, |
|||
residualTokens, |
|||
CollectionsMarshal.AsSpan(countIncrease), |
|||
CollectionsMarshal.AsSpan(extraBitsIncrease), |
|||
begin, |
|||
end, |
|||
propertyIndex, |
|||
maxSymbols); |
|||
|
|||
public static void CollectExtraBitsIncrease(bool s, JxlTreeSamples treeSamples, List<JxlResidualToken> residualTokens, Span<int> countIncrease, Span<int> extraBitsIncrease, int begin, int end, int propertyIndex, int maxSymbols) |
|||
{ |
|||
for (int i2 = begin; i2 < end; i2++) |
|||
{ |
|||
JxlResidualToken rt = residualTokens[i2]; |
|||
|
|||
int cnt = treeSamples.GetCount(i2); |
|||
int p = treeSamples.GetProperty(s, propertyIndex, i2); |
|||
int sym = rt.Token; |
|||
int ebi = rt.NumberOfBits * cnt; |
|||
|
|||
countIncrease[(p * maxSymbols) + sym] += cnt; |
|||
extraBitsIncrease[p] += ebi; |
|||
} |
|||
} |
|||
|
|||
public static unsafe void FindBestSplit(JxlTreeSamples treeSamples, float threshold, List<JxlModularMultiplierInfo> mulInfo, StaticPropertyRange initialStaticPropertyRange, float fastDecodeMultiplier, Tree tree) |
|||
{ |
|||
Stack<NodeInfo> nodes = []; |
|||
nodes.Push(new(0, 0, treeSamples.NumberOfDistinctSamples, initialStaticPropertyRange)); |
|||
|
|||
int numPred = treeSamples.NumberOfPredictors; |
|||
int numProp = treeSamples.NumberOfProperties; |
|||
|
|||
Span<int> totalExtraBits = stackalloc int[numPred]; |
|||
|
|||
while (nodes.Count > 0) |
|||
{ |
|||
NodeInfo last = nodes.Peek(); |
|||
|
|||
int pos = last.Pos; |
|||
int begin = last.Begin; |
|||
int end = last.End; |
|||
StaticPropertyRange staticPropertyRange = last.StaticPropertyRange; |
|||
|
|||
_ = nodes.Pop(); |
|||
|
|||
if (begin == end) |
|||
{ |
|||
continue; |
|||
} |
|||
|
|||
SplitInfo bestSplitStaticConstant = default; |
|||
SplitInfo bestSplitStatic = default; |
|||
SplitInfo bestSplitNonStatic = default; |
|||
SplitInfo bestSplitNoWeightedPrediction = default; |
|||
|
|||
if (begin > end) |
|||
{ |
|||
throw new InvalidOperationException("Begin should be <= end"); |
|||
} |
|||
|
|||
if (end > treeSamples.NumberOfDistinctSamples) |
|||
{ |
|||
throw new InvalidOperationException("End index out of range"); |
|||
} |
|||
|
|||
int maxSymbols = 0; |
|||
|
|||
for (int pred = 0; pred < numPred; pred++) |
|||
{ |
|||
for (int i = begin; i < end; i++) |
|||
{ |
|||
int token = treeSamples.GetToken(pred, i); |
|||
maxSymbols = maxSymbols > token + 1 ? maxSymbols : token + 1; |
|||
} |
|||
} |
|||
|
|||
maxSymbols = Padded(maxSymbols); |
|||
|
|||
int[] counts = ArrayPool<int>.Shared.Rent(maxSymbols * numPred); |
|||
|
|||
for (int pred = 0; pred < numPred; pred++) |
|||
{ |
|||
int extraBits = 0; |
|||
List<JxlResidualToken> rtokens = treeSamples.GetResidualTokensForPrediction(pred); |
|||
|
|||
for (int i = begin; i < end; i++) |
|||
{ |
|||
JxlResidualToken rt = rtokens[i]; |
|||
|
|||
int count = treeSamples.GetCount(i); |
|||
int eb = rt.NumberOfBits * count; |
|||
|
|||
counts[(pred * maxSymbols) + rt.Token] += count; |
|||
extraBits += eb; |
|||
} |
|||
|
|||
totalExtraBits[pred] = extraBits; |
|||
} |
|||
|
|||
float baseBits = 0; |
|||
{ |
|||
int pred = treeSamples.FindPredictorIndex(tree[pos].Predictor); |
|||
baseBits = EstimateBits(counts.AsSpan(pred * maxSymbols), maxSymbols) + totalExtraBits[pred]; |
|||
} |
|||
|
|||
ref SplitInfo best = ref bestSplitNonStatic; |
|||
|
|||
SplitInfo forcedSplit = default; |
|||
|
|||
foreach (JxlModularMultiplierInfo mmi in mulInfo) |
|||
{ |
|||
int axis = 0; |
|||
int val = 0; |
|||
IntersectionType t = BoxIntersects(staticPropertyRange, mmi.Range, ref axis, ref val); |
|||
|
|||
if (t == IntersectionType.None) |
|||
{ |
|||
continue; |
|||
} |
|||
|
|||
if (t == IntersectionType.Inside) |
|||
{ |
|||
CollectionsMarshal.AsSpan(tree)[pos].Multiplier = (int)mmi.Multiplier; |
|||
break; |
|||
} |
|||
|
|||
if (t == IntersectionType.Partial) |
|||
{ |
|||
forcedSplit.Value = treeSamples.QuantizeStaticProperty(axis, val); |
|||
forcedSplit.Property = axis; |
|||
forcedSplit.LeftCost = forcedSplit.RightCost = (baseBits / 2) - threshold; |
|||
forcedSplit.LeftPredictor = forcedSplit.RightPredictor = CollectionsMarshal.AsSpan(tree)[pos].Predictor; |
|||
best = ref forcedSplit; |
|||
best.Position = begin; |
|||
|
|||
if (best.Property != treeSamples.PropertyFromIndex(best.Property)) |
|||
{ |
|||
throw new InvalidOperationException("Invalid property"); |
|||
} |
|||
|
|||
if (best.Property < treeSamples.NumberOfStaticProperties) |
|||
{ |
|||
for (int x = begin; x < end; x++) |
|||
{ |
|||
if (treeSamples.GetProperty(true, best.Property, x) <= best.Value) |
|||
{ |
|||
best.Position++; |
|||
} |
|||
} |
|||
} |
|||
else |
|||
{ |
|||
int prop = best.Property - treeSamples.NumberOfStaticProperties; |
|||
|
|||
for (int x = begin; x < end; x++) |
|||
{ |
|||
if (treeSamples.GetProperty(false, prop, x) <= best.Value) |
|||
{ |
|||
best.Position++; |
|||
} |
|||
} |
|||
} |
|||
|
|||
break; |
|||
} |
|||
} |
|||
|
|||
if (!Unsafe.AreSame(ref best, ref forcedSplit)) |
|||
{ |
|||
List<int> countsIncrease = []; |
|||
List<int> extraBitsIncrease = []; |
|||
|
|||
List<CostInfo> leftCosts = []; |
|||
List<CostInfo> rightCosts = []; |
|||
|
|||
int[] aboveCounts = ArrayPool<int>.Shared.Rent(maxSymbols); |
|||
int[] belowCounts = ArrayPool<int>.Shared.Rent(maxSymbols); |
|||
|
|||
float changePredictionPenalty = 800.0f / (100.0f + threshold); |
|||
|
|||
for (int prop = 0; prop < numProp && baseBits > threshold; prop++) |
|||
{ |
|||
leftCosts.Clear(); |
|||
rightCosts.Clear(); |
|||
|
|||
int propertySize = treeSamples.CountPropertyValues(prop); |
|||
|
|||
if (extraBitsIncrease.Count < propertySize) |
|||
{ |
|||
countsIncrease.Grow(0, propertySize * maxSymbols); |
|||
extraBitsIncrease.Grow(0, propertySize); |
|||
} |
|||
|
|||
int[] propertyValueUsedCount = ArrayPool<int>.Shared.Rent(propertySize); |
|||
propertyValueUsedCount.AsSpan().Clear(); |
|||
|
|||
int firstUsed = propertySize; |
|||
int lastUsed = 0; |
|||
|
|||
if (prop < treeSamples.NumberOfStaticProperties) |
|||
{ |
|||
for (int i = begin; i < end; i++) |
|||
{ |
|||
int p = treeSamples.GetProperty(true, prop, i); |
|||
propertyValueUsedCount[p]++; |
|||
lastUsed = Math.Max(lastUsed, p); |
|||
firstUsed = Math.Max(firstUsed, p); |
|||
} |
|||
} |
|||
else |
|||
{ |
|||
int prop_idx = prop - treeSamples.NumberOfStaticProperties; |
|||
|
|||
for (int i = begin; i < end; i++) |
|||
{ |
|||
int p = treeSamples.GetProperty(false, prop_idx, i); |
|||
propertyValueUsedCount[p]++; |
|||
lastUsed = Math.Max(lastUsed, p); |
|||
firstUsed = Math.Max(firstUsed, p); |
|||
} |
|||
} |
|||
|
|||
leftCosts.Grow(default, lastUsed - firstUsed); |
|||
rightCosts.Grow(default, lastUsed - firstUsed); |
|||
|
|||
for (int pred = 0; pred < numPred; pred++) |
|||
{ |
|||
List<JxlResidualToken> rtokens = treeSamples.GetResidualTokensForPrediction(pred); |
|||
|
|||
if (prop < treeSamples.NumberOfStaticProperties) |
|||
{ |
|||
CollectExtraBitsIncrease(true, treeSamples, rtokens, countsIncrease, extraBitsIncrease, begin, end, prop, maxSymbols); |
|||
} |
|||
else |
|||
{ |
|||
CollectExtraBitsIncrease(false, treeSamples, rtokens, countsIncrease, extraBitsIncrease, begin, end, prop - treeSamples.NumberOfStaticProperties, maxSymbols); |
|||
} |
|||
|
|||
counts.AsSpan().Slice(pred * maxSymbols, maxSymbols).CopyTo(aboveCounts); |
|||
belowCounts.AsSpan().Slice(0, maxSymbols).Clear(); |
|||
|
|||
int extraBitsBelow = 0; |
|||
|
|||
for (int i = firstUsed; i < lastUsed; i++) |
|||
{ |
|||
if (propertyValueUsedCount[i] == 0) |
|||
{ |
|||
continue; |
|||
} |
|||
|
|||
extraBitsBelow += extraBitsIncrease[i]; |
|||
extraBitsIncrease[i] = 0; |
|||
|
|||
for (int sym = 0; sym < maxSymbols; sym++) |
|||
{ |
|||
aboveCounts[sym] -= countsIncrease[(i * maxSymbols) + sym]; |
|||
belowCounts[sym] += countsIncrease[(i * maxSymbols) + sym]; |
|||
countsIncrease[(i * maxSymbols) + sym] = 0; |
|||
} |
|||
|
|||
float rightCost = EstimateBits(aboveCounts.AsSpan(), maxSymbols) + totalExtraBits[pred] - extraBitsBelow; |
|||
float leftCost = EstimateBits(belowCounts.AsSpan(), maxSymbols) + extraBitsBelow; |
|||
|
|||
if (extraBitsBelow > totalExtraBits[pred]) |
|||
{ |
|||
throw new InvalidOperationException("Too many extra bits"); |
|||
} |
|||
|
|||
float penalty = 0; |
|||
|
|||
if (treeSamples.PredictorFromIndex(pred) != tree[pos].Predictor && |
|||
tree[pos].Predictor != JxlPredictor.Weighted) |
|||
{ |
|||
penalty = changePredictionPenalty; |
|||
} |
|||
|
|||
if (treeSamples.PredictorFromIndex(pred) == JxlPredictor.Weighted) |
|||
{ |
|||
penalty += 1e-8f; |
|||
} |
|||
|
|||
if (treeSamples.PredictorFromIndex(pred) == JxlPredictor.Zero) |
|||
{ |
|||
penalty -= 1e-8f; |
|||
} |
|||
|
|||
if (rightCost + penalty < rightCosts[i - firstUsed].TotalCost) |
|||
{ |
|||
CostInfo cost = rightCosts[i - firstUsed]; |
|||
cost.Cost = rightCost; |
|||
cost.ExtraCost = penalty; |
|||
cost.Predictor = treeSamples.PredictorFromIndex(pred); |
|||
rightCosts[i - firstUsed] = cost; |
|||
} |
|||
|
|||
if (leftCost + penalty < leftCosts[i - firstUsed].TotalCost) |
|||
{ |
|||
CostInfo cost = leftCosts[i - firstUsed]; |
|||
cost.Cost = leftCost; |
|||
cost.ExtraCost = penalty; |
|||
cost.Predictor = treeSamples.PredictorFromIndex(pred); |
|||
leftCosts[i - firstUsed] = cost; |
|||
} |
|||
} |
|||
} |
|||
|
|||
int split = begin; |
|||
|
|||
for (int i = firstUsed; i < lastUsed; i++) |
|||
{ |
|||
if (propertyValueUsedCount[i] == 0) |
|||
{ |
|||
continue; |
|||
} |
|||
|
|||
split += propertyValueUsedCount[i]; |
|||
|
|||
float rightCost = rightCosts[i - firstUsed].Cost; |
|||
float leftCost = leftCosts[i - firstUsed].Cost; |
|||
|
|||
bool usesWeightedPrediction = treeSamples.PropertyFromIndex(prop) == JxlMaConstants.WpProp || |
|||
leftCosts[i - firstUsed].Predictor == JxlPredictor.Weighted || |
|||
rightCosts[i - firstUsed].Predictor == JxlPredictor.Weighted; |
|||
|
|||
bool zeroEntropySide = rightCost == 0 || leftCost == 0; |
|||
|
|||
// Using pointer specifically for this variable instead of
|
|||
// ref, as we can't assign a ref variable conditionally.
|
|||
SplitInfo* referenceToBest = |
|||
treeSamples.PropertyFromIndex(prop) < JxlPredictorFacts.StaticProperties |
|||
? (zeroEntropySide ? &bestSplitStaticConstant : &bestSplitStatic) |
|||
: (usesWeightedPrediction ? &bestSplitNonStatic : &bestSplitNoWeightedPrediction); |
|||
|
|||
if (leftCost + rightCost < referenceToBest->Cost) |
|||
{ |
|||
referenceToBest->Property = prop; |
|||
referenceToBest->Value = i; |
|||
referenceToBest->Position = split; |
|||
referenceToBest->LeftCost = leftCost; |
|||
referenceToBest->LeftPredictor = leftCosts[i - firstUsed].Predictor; |
|||
referenceToBest->RightCost = rightCost; |
|||
referenceToBest->RightPredictor = rightCosts[i - firstUsed].Predictor; |
|||
} |
|||
} |
|||
|
|||
extraBitsIncrease[lastUsed] = 0; |
|||
|
|||
for (int sym = 0; sym < maxSymbols; sym++) |
|||
{ |
|||
countsIncrease[(lastUsed * maxSymbols) + sym] = 0; |
|||
} |
|||
} |
|||
|
|||
if (bestSplitNoWeightedPrediction.Cost + threshold < baseBits && |
|||
bestSplitNoWeightedPrediction.Cost <= fastDecodeMultiplier * best.Cost) |
|||
{ |
|||
best = ref bestSplitNoWeightedPrediction; |
|||
} |
|||
|
|||
if (bestSplitStatic.Cost + threshold < baseBits && |
|||
bestSplitStatic.Cost <= fastDecodeMultiplier * best.Cost) |
|||
{ |
|||
best = ref bestSplitStatic; |
|||
} |
|||
|
|||
if (bestSplitStaticConstant.Cost + threshold < baseBits) |
|||
{ |
|||
best = ref bestSplitStaticConstant; |
|||
} |
|||
|
|||
ArrayPool<int>.Shared.Return(aboveCounts); |
|||
ArrayPool<int>.Shared.Return(belowCounts); |
|||
} |
|||
|
|||
if (best.Cost + threshold < baseBits) |
|||
{ |
|||
int p = treeSamples.PropertyFromIndex(best.Property); |
|||
int dequant = treeSamples.UnquantizeProperty(best.Property, best.Value); |
|||
|
|||
MakeSplitNode(pos, p, dequant, best.LeftPredictor, 0, best.RightPredictor, 0, tree); |
|||
|
|||
if (best.Property < treeSamples.NumberOfStaticProperties) |
|||
{ |
|||
SplitTreeSamples(true, treeSamples, begin, best.Position, end, best.Property, best.Value); |
|||
} |
|||
else |
|||
{ |
|||
SplitTreeSamples(false, treeSamples, begin, best.Position, end, best.Property - treeSamples.NumberOfStaticProperties, best.Value); |
|||
} |
|||
|
|||
StaticPropertyRange newStaticPropertyRange = staticPropertyRange; |
|||
|
|||
if (p < JxlPredictorFacts.StaticProperties) |
|||
{ |
|||
if (dequant + 1 > newStaticPropertyRange[p][1]) |
|||
{ |
|||
throw new InvalidOperationException("Dequantized coefficient is out of range"); |
|||
} |
|||
|
|||
newStaticPropertyRange[p][1] = dequant + 1; |
|||
|
|||
if (newStaticPropertyRange[p][0] >= newStaticPropertyRange[p][1]) |
|||
{ |
|||
throw new InvalidOperationException("Static property is out of range"); |
|||
} |
|||
} |
|||
|
|||
nodes.Push(new(tree[pos].RightChild, begin, best.Position, newStaticPropertyRange)); |
|||
newStaticPropertyRange = staticPropertyRange; |
|||
|
|||
if (p < JxlPredictorFacts.StaticProperties) |
|||
{ |
|||
if (newStaticPropertyRange[p][0] > dequant + 1) |
|||
{ |
|||
throw new InvalidOperationException("Static property must be <= dequantized coefficient"); |
|||
} |
|||
|
|||
newStaticPropertyRange[p][0] = dequant + 1; |
|||
|
|||
if (newStaticPropertyRange[p][0] >= newStaticPropertyRange[p][1]) |
|||
{ |
|||
throw new InvalidOperationException("Static property is out of range"); |
|||
} |
|||
} |
|||
|
|||
nodes.Push(new NodeInfo(tree[pos].LeftChild, best.Position, end, newStaticPropertyRange)); |
|||
} |
|||
|
|||
ArrayPool<int>.Shared.Return(counts); |
|||
} |
|||
} |
|||
|
|||
public static void ComputeBestTree(JxlTreeSamples treeSamples, float threshold, List<JxlModularMultiplierInfo> mulInfo, StaticPropertyRange staticPropertyRange, float fastDecodeMultiplier, Tree tree) |
|||
{ |
|||
JxlPropertyDecisionNode node = new() |
|||
{ |
|||
Property = -1, |
|||
Predictor = treeSamples.PredictorFromIndex(0), |
|||
PredictorOffset = 0, |
|||
Multiplier = 1 |
|||
}; |
|||
|
|||
tree.Add(node); |
|||
|
|||
if (treeSamples.NumberOfProperties >= 64) |
|||
{ |
|||
throw new InvalidOperationException($"Too many properties: {treeSamples.NumberOfPredictors}"); |
|||
} |
|||
|
|||
FindBestSplit(treeSamples, threshold, mulInfo, staticPropertyRange, fastDecodeMultiplier, tree); |
|||
} |
|||
|
|||
public static List<int> QuantizeHistogram(ReadOnlySpan<int> histogram, int numChunks) |
|||
{ |
|||
if (histogram.Length == 0 || numChunks == 0) |
|||
{ |
|||
return []; |
|||
} |
|||
|
|||
int sum = TensorPrimitives.Sum(histogram); |
|||
|
|||
if (sum == 0) |
|||
{ |
|||
return []; |
|||
} |
|||
|
|||
List<int> thresholds = []; |
|||
|
|||
long cumulativeSum = 0; |
|||
long threshold = 1; |
|||
|
|||
for (int i = 0; i < histogram.Length; i++) |
|||
{ |
|||
cumulativeSum += histogram[i]; |
|||
|
|||
if (cumulativeSum * numChunks >= threshold * sum) |
|||
{ |
|||
thresholds.Add(i); |
|||
|
|||
while (cumulativeSum * numChunks >= threshold * sum) |
|||
{ |
|||
threshold++; |
|||
} |
|||
} |
|||
} |
|||
|
|||
if (thresholds.Count > numChunks) |
|||
{ |
|||
throw new InvalidOperationException("Too many thresholds"); |
|||
} |
|||
|
|||
thresholds.RemoveAt(thresholds.Count - 1); |
|||
|
|||
return thresholds; |
|||
} |
|||
|
|||
public static List<int> QuantizeSamples(ReadOnlySpan<int> samples, int numChunks) |
|||
{ |
|||
const int range = 512; |
|||
|
|||
if (samples.Length == 0) |
|||
{ |
|||
return []; |
|||
} |
|||
|
|||
int min = Math.Clamp(TensorPrimitives.Min(samples), -range, range); |
|||
|
|||
Span<int> counts = stackalloc int[2048].Slice(0, (2 * range) + 1); |
|||
|
|||
for (int i = 0; i < samples.Length; i++) |
|||
{ |
|||
int s = samples[i]; |
|||
int sampleOffset = Math.Clamp(s, -range, range) - min; |
|||
counts[sampleOffset]++; |
|||
} |
|||
|
|||
List<int> thresholds = QuantizeHistogram(counts, numChunks); |
|||
|
|||
// For fast processing via TensorPrimitives
|
|||
Span<int> thresholdsSpan = CollectionsMarshal.AsSpan(thresholds); |
|||
TensorPrimitives.Add(thresholdsSpan, min, thresholdsSpan); |
|||
|
|||
return thresholds; |
|||
} |
|||
|
|||
public static void QuantMap(Span<int> from, Span<int> to, int numPegs, int bias) |
|||
{ |
|||
int mapped = 0; |
|||
|
|||
for (int i = 0; i < numPegs; i++) |
|||
{ |
|||
while (mapped < from.Length && i - bias > from[mapped]) |
|||
{ |
|||
mapped++; |
|||
} |
|||
|
|||
to[i] = mapped; |
|||
} |
|||
} |
|||
|
|||
public static void CollectPixelSamples(Configuration configuration, JxlModularImage image, JxlModularOptions options, int groupId, Span<int> groupPixelCount, Span<int> channelPixelCount, List<int> pixelSamples, List<int> diffSamples) |
|||
{ |
|||
if (options.NumberOfRepeats == 0) |
|||
{ |
|||
throw new InvalidOperationException("No repeats"); |
|||
} |
|||
|
|||
// Power of 2 size is unknown.
|
|||
Span<int> alignedGroupPixelCount = stackalloc int[groupPixelCount.Length <= groupId ? groupId + 1 : groupPixelCount.Length]; |
|||
groupPixelCount.CopyTo(alignedGroupPixelCount); |
|||
|
|||
Span<int> alignedChannelPixelCount = stackalloc int[channelPixelCount.Length < image.Channels.Count ? image.Channels.Count : channelPixelCount.Length]; |
|||
channelPixelCount.CopyTo(alignedGroupPixelCount); |
|||
|
|||
Rng rng = new((ulong)groupId); |
|||
|
|||
float fraction = MathF.Min(options.NumberOfRepeats * 0.1f, 0.99f); |
|||
Rng.GeometricDistribution dist = new(fraction); |
|||
|
|||
int totalPixels = 0; |
|||
List<int> channelIds = []; |
|||
|
|||
int i; |
|||
for (i = 0; i < image.Channels.Count; i++) |
|||
{ |
|||
JxlModularChannel channel = image.Channels[i]; |
|||
|
|||
if (i >= image.MetaChannels && (channel.Width > options.MaxChannelSize || channel.Height > options.MaxChannelSize)) |
|||
{ |
|||
break; |
|||
} |
|||
|
|||
if (channel.Width <= 1 || channel.Height == 0) |
|||
{ |
|||
continue; |
|||
} |
|||
|
|||
channelIds.Add(i); |
|||
|
|||
groupPixelCount[groupId] += channel.Width * channel.Height; |
|||
channelPixelCount[i] += channel.Width * channel.Height; |
|||
totalPixels += channel.Width * channel.Height; |
|||
} |
|||
|
|||
if (channelIds.Count == 0) |
|||
{ |
|||
throw new InvalidOperationException("No channel IDs"); |
|||
} |
|||
|
|||
pixelSamples.Grow(0, (int)(pixelSamples.Count + (fraction * totalPixels))); |
|||
diffSamples.Grow(0, (int)(diffSamples.Count + (fraction * totalPixels))); |
|||
|
|||
i = 0; |
|||
int y = 0; |
|||
int x = 0; |
|||
|
|||
void Advance(uint amount) |
|||
{ |
|||
x += (int)amount; |
|||
|
|||
while (x >= image.Channels[channelIds[i]].Width) |
|||
{ |
|||
x -= image.Channels[channelIds[i]].Width; |
|||
y++; |
|||
|
|||
if (y == image.Channels[channelIds[i]].Height) |
|||
{ |
|||
i++; |
|||
y = 0; |
|||
|
|||
if (i >= channelIds.Count) |
|||
{ |
|||
return; |
|||
} |
|||
} |
|||
} |
|||
} |
|||
|
|||
Advance(rng.Geometric(in dist)); |
|||
|
|||
for (; i < channelIds.Count; Advance(rng.Geometric(in dist) + 1)) |
|||
{ |
|||
Span<int> row = image.Channels[channelIds[i]].GetRow(y); |
|||
pixelSamples.Add(row[x]); |
|||
|
|||
int xp = x == 0 ? 1 : x - 1; |
|||
diffSamples.Add(row[x] - row[xp]); |
|||
} |
|||
} |
|||
|
|||
public static void TokenizeTree(Tree tree, List<JxlToken> tokens, Tree decoderTree) |
|||
{ |
|||
if (tree.Count > JxlMaConstants.MaxTreeSize) |
|||
{ |
|||
throw new InvalidOperationException("Too many tree nodes"); |
|||
} |
|||
|
|||
Queue<int> q = []; |
|||
q.Enqueue(0); |
|||
|
|||
int leafId = 0; |
|||
decoderTree.Clear(); |
|||
|
|||
while (q.Count > 0) |
|||
{ |
|||
int cur = q.Peek(); |
|||
_ = q.Dequeue(); |
|||
|
|||
if (tree[cur].Property < -1) |
|||
{ |
|||
throw new InvalidOperationException("Property value is too small"); |
|||
} |
|||
|
|||
tokens.Add(new JxlToken(JxlMaTreeContext.Property, (uint)tree[cur].Property + 1)); |
|||
|
|||
if (tree[cur].Property == -1) |
|||
{ |
|||
tokens.Add(new JxlToken(JxlMaTreeContext.Predictor, (uint)tree[cur].Predictor)); |
|||
tokens.Add(new JxlToken(JxlMaTreeContext.Offset, JxlPackSigned.PackUnsigned((int)tree[cur].PredictorOffset))); |
|||
|
|||
uint mulLog = JxlMath.Num0BitsBelowLS1Bit_Nonzero(tree[cur].Multiplier); |
|||
int mulBits = (tree[cur].Multiplier >> (int)mulLog) - 1; |
|||
|
|||
tokens.Add(new JxlToken(JxlMaTreeContext.MultiplierLog, mulLog)); |
|||
tokens.Add(new JxlToken(JxlMaTreeContext.MultiplierBits, (uint)mulBits)); |
|||
|
|||
if (tree[cur].Predictor >= JxlPredictor.Best) |
|||
{ |
|||
throw new InvalidOperationException("Invalid predictor"); |
|||
} |
|||
|
|||
decoderTree.Add(new JxlPropertyDecisionNode(-1, 0, leafId, 0, tree[cur].Predictor, tree[cur].PredictorOffset, tree[cur].Multiplier)); |
|||
leafId++; |
|||
|
|||
continue; |
|||
} |
|||
|
|||
decoderTree.Add(new JxlPropertyDecisionNode(tree[cur].Property, tree[cur].SplitValue, decoderTree.Count + q.Count + 1, decoderTree.Count + q.Count + 2, JxlPredictor.Zero, 0, 1)); |
|||
|
|||
q.Enqueue(tree[cur].LeftChild); |
|||
q.Enqueue(tree[cur].RightChild); |
|||
|
|||
tokens.Add(new JxlToken(JxlMaTreeContext.SplitValue, JxlPackSigned.PackUnsigned(tree[cur].SplitValue))); |
|||
} |
|||
} |
|||
|
|||
private readonly record struct NodeInfo(int Pos, int Begin, int End, StaticPropertyRange StaticPropertyRange); |
|||
|
|||
private struct SplitInfo() |
|||
{ |
|||
public int Property { get; set; } |
|||
|
|||
public int Value { get; set; } |
|||
|
|||
public int Position { get; set; } |
|||
|
|||
public float LeftCost { get; set; } = float.MaxValue; |
|||
|
|||
public float RightCost { get; set; } = float.MaxValue; |
|||
|
|||
public JxlPredictor LeftPredictor { get; set; } = JxlPredictor.Zero; |
|||
|
|||
public JxlPredictor RightPredictor { get; set; } = JxlPredictor.Zero; |
|||
|
|||
public readonly float Cost => this.LeftCost + this.RightCost; |
|||
} |
|||
|
|||
private struct CostInfo() |
|||
{ |
|||
public float Cost { get; set; } = float.MaxValue; |
|||
|
|||
public float ExtraCost { get; set; } |
|||
|
|||
public JxlPredictor Predictor { get; set; } |
|||
|
|||
public readonly float TotalCost => this.Cost + this.ExtraCost; |
|||
} |
|||
} |
|||
@ -0,0 +1,16 @@ |
|||
// Copyright (c) Six Labors.
|
|||
// Licensed under the Six Labors Split License.
|
|||
|
|||
namespace SixLabors.ImageSharp.Formats.Jxl.Processing.Modular.Encoding; |
|||
|
|||
internal struct JxlResidualToken |
|||
{ |
|||
public int Token; |
|||
public int NumberOfBits; |
|||
|
|||
public JxlResidualToken(int token, int numberOfBits) |
|||
{ |
|||
this.Token = token; |
|||
this.NumberOfBits = numberOfBits; |
|||
} |
|||
} |
|||
@ -0,0 +1,884 @@ |
|||
// Copyright (c) Six Labors.
|
|||
// Licensed under the Six Labors Split License.
|
|||
|
|||
using System.Numerics.Tensors; |
|||
using System.Runtime.CompilerServices; |
|||
using System.Runtime.InteropServices; |
|||
using SixLabors.ImageSharp.Common.Helpers; |
|||
using SixLabors.ImageSharp.Formats.Jxl.IO.Entropy; |
|||
using SixLabors.ImageSharp.Formats.Jxl.Processing.Modular.Encoding.ContextPrediction; |
|||
using SixLabors.ImageSharp.Formats.Jxl.Processing.Primitives; |
|||
using StaticPropertyRange = System.Runtime.CompilerServices.InlineArray2<System.Runtime.CompilerServices.InlineArray2<int>>; |
|||
|
|||
namespace SixLabors.ImageSharp.Formats.Jxl.Processing.Modular.Encoding; |
|||
|
|||
/// <summary>
|
|||
/// Contains all the necessary data needed to build a tree.
|
|||
/// </summary>
|
|||
internal sealed class JxlTreeSamples |
|||
{ |
|||
/// <summary>
|
|||
/// This deduplication table entry marks an unused entry.
|
|||
/// </summary>
|
|||
private const int DeduplicationEntryUnused = -1; |
|||
|
|||
private const int PropertyRange = 511; |
|||
|
|||
/// <summary>
|
|||
/// Residual information: token and number of extra bits per predictor.
|
|||
/// </summary>
|
|||
private List<List<JxlResidualToken>> residuals = []; |
|||
|
|||
/// <summary>
|
|||
/// Number of occurrences of each sample.
|
|||
/// </summary>
|
|||
private readonly List<int> sampleCounts = []; |
|||
|
|||
/// <summary>
|
|||
/// Quantized static property values.
|
|||
/// </summary>
|
|||
private InlineArray2<List<int>> staticProperties; |
|||
|
|||
/// <summary>
|
|||
/// Property values, quantized to at most 256 distinct values.
|
|||
/// </summary>
|
|||
private readonly List<List<byte>> properties = []; |
|||
|
|||
/// <summary>
|
|||
/// Decompactification info for <see cref="properties"/>.
|
|||
/// </summary>
|
|||
private readonly List<List<int>> compactProperties = []; |
|||
|
|||
/// <summary>
|
|||
/// List of properties to use.
|
|||
/// </summary>
|
|||
private List<int> propertiesToUse = []; |
|||
|
|||
/// <summary>
|
|||
/// List of predictors to use.
|
|||
/// </summary>
|
|||
private List<JxlPredictor> predictors = []; |
|||
|
|||
/// <summary>
|
|||
/// Mapping property value -> quantized property value.
|
|||
/// </summary>
|
|||
private InlineArray2<List<int>> staticPropertyMapping; |
|||
|
|||
private readonly List<List<int>> propertyMapping = []; |
|||
|
|||
/// <summary>
|
|||
/// Table for deduplication.
|
|||
/// </summary>
|
|||
private List<int> deduplicationTable = []; |
|||
|
|||
/// <summary>
|
|||
/// Gets a value indicating whether there are any residual samples.
|
|||
/// </summary>
|
|||
public bool HasSamples => this.residuals.Count > 0 && this.residuals[0].Count > 0; |
|||
|
|||
/// <summary>
|
|||
/// Gets the total number of distinct samples.
|
|||
/// </summary>
|
|||
public int NumberOfDistinctSamples => this.sampleCounts.Count; |
|||
|
|||
/// <summary>
|
|||
/// Gets the total number of samples.
|
|||
/// </summary>
|
|||
public int NumberOfSamples { get; private set; } |
|||
|
|||
/// <summary>
|
|||
/// Gets the number of quantized static property values.
|
|||
/// </summary>
|
|||
public int NumberOfStaticProperties { get; private set; } |
|||
|
|||
/// <summary>
|
|||
/// Gets the total number of predictors.
|
|||
/// </summary>
|
|||
public int NumberOfPredictors => this.predictors.Count; |
|||
|
|||
/// <summary>
|
|||
/// Gets the total number of properties.
|
|||
/// </summary>
|
|||
public int NumberOfProperties => this.propertiesToUse.Count; |
|||
|
|||
/// <summary>
|
|||
/// Returns a List of residual tokens for the specified kind of prediction.
|
|||
/// </summary>
|
|||
/// <param name="prediction">The type of prediction.</param>
|
|||
/// <returns>Residual tokens corresponding to the prediction specified by the parameter <paramref name="prediction"/>.</returns>
|
|||
public List<JxlResidualToken> GetResidualTokensForPrediction(int prediction) => this.residuals[prediction]; |
|||
|
|||
/// <summary>
|
|||
/// Returns a reference to the residual token.
|
|||
/// </summary>
|
|||
/// <param name="pred">Kind of prediction.</param>
|
|||
/// <param name="i">Index of the residual token within that prediction.</param>
|
|||
/// <returns>The residual token for prediction <paramref name="pred"/> indexed <paramref name="i"/>.</returns>
|
|||
public ref JxlResidualToken GetResidualToken(int pred, int i) => ref CollectionsMarshal.AsSpan(this.residuals[pred])[i]; |
|||
|
|||
/// <summary>
|
|||
/// Returns a token of the residual for prediction <paramref name="prediction"/> index <paramref name="index"/>.
|
|||
/// </summary>
|
|||
/// <param name="prediction">The kind of prediction.</param>
|
|||
/// <param name="index">Index of the residual token within that prediction.</param>
|
|||
/// <returns>For residual token whose prediction is <paramref name="prediction"/> and index is <paramref name="index"/>, returns its token coefficient.</returns>
|
|||
public int GetToken(int prediction, int index) => this.residuals[prediction][index].Token; |
|||
|
|||
/// <summary>
|
|||
/// Returns the number of occurrences for sample <paramref name="i"/>.
|
|||
/// </summary>
|
|||
/// <param name="i">The index of the sample.</param>
|
|||
/// <returns>Number of times <paramref name="i"/> appears.</returns>
|
|||
public int GetCount(int i) => this.sampleCounts[i]; |
|||
|
|||
/// <summary>
|
|||
/// Finds the index of the predictor <paramref name="predictor"/>.
|
|||
/// </summary>
|
|||
/// <param name="predictor">The predictor to find the index for.</param>
|
|||
/// <returns>Index of the predictor in the predictors storage.</returns>
|
|||
/// <exception cref="InvalidOperationException">Thrown when the predictor can't be found.</exception>
|
|||
public int FindPredictorIndex(JxlPredictor predictor) |
|||
{ |
|||
ReadOnlySpan<JxlPredictor> span = CollectionsMarshal.AsSpan(this.predictors); |
|||
|
|||
int index = span.IndexOf(predictor); |
|||
|
|||
if (index < 0) |
|||
{ |
|||
// Should not happen.
|
|||
throw new InvalidOperationException("Cannot find the index of the predictor"); |
|||
} |
|||
|
|||
return index; |
|||
} |
|||
|
|||
/// <summary>
|
|||
/// Finds the index of the property <paramref name="property"/>.
|
|||
/// </summary>
|
|||
/// <param name="property">The property to find the index for.</param>
|
|||
/// <returns>Index of the property in the properties storage.</returns>
|
|||
/// <exception cref="InvalidOperationException">Thrown when the property isn't valid.</exception>
|
|||
public int FindPropertyIndex(int property) |
|||
{ |
|||
ReadOnlySpan<int> span = CollectionsMarshal.AsSpan(this.propertiesToUse); |
|||
|
|||
int index = span.IndexOf(property); |
|||
|
|||
if (index != this.propertiesToUse[^1]) |
|||
{ |
|||
// Should not happen.
|
|||
throw new InvalidOperationException("Invalid property"); |
|||
} |
|||
|
|||
return index; |
|||
} |
|||
|
|||
/// <summary>
|
|||
/// Returns the number of properties for a <paramref name="propertyIndex"/>.
|
|||
/// </summary>
|
|||
/// <param name="propertyIndex">Index of the property.</param>
|
|||
/// <returns>Number of property values for property with index <paramref name="propertyIndex"/>.</returns>
|
|||
public int CountPropertyValues(int propertyIndex) => this.compactProperties[propertyIndex].Count + 1; |
|||
|
|||
/// <summary>
|
|||
/// Returns the value of a property.
|
|||
/// </summary>
|
|||
/// <param name="useStaticProperty">Prefer a static property?</param>
|
|||
/// <param name="propertyIndex">The index of the properties table.</param>
|
|||
/// <param name="i">The index of the property.</param>
|
|||
/// <returns>
|
|||
/// Property for index <paramref name="i" /> within table <paramref name="propertyIndex"/>.
|
|||
/// </returns>
|
|||
[MethodImpl(MethodImplOptions.AggressiveInlining)] |
|||
public int GetProperty(bool useStaticProperty, int propertyIndex, int i) |
|||
{ |
|||
if (useStaticProperty) |
|||
{ |
|||
return this.staticProperties[propertyIndex][i]; |
|||
} |
|||
else |
|||
{ |
|||
return this.properties[propertyIndex][i]; |
|||
} |
|||
} |
|||
|
|||
/// <summary>
|
|||
/// Returns the dequantized property.
|
|||
/// </summary>
|
|||
/// <param name="propertyIndex">Index of the target property.</param>
|
|||
/// <param name="quant">Property quantizer.</param>
|
|||
/// <returns>The dequantized property.</returns>
|
|||
/// <exception cref="InvalidOperationException">Thrown when the quant is out of range.</exception>
|
|||
public int UnquantizeProperty(int propertyIndex, int quant) |
|||
{ |
|||
List<int> compactProperties = this.compactProperties[propertyIndex]; |
|||
|
|||
if (quant >= compactProperties.Count) |
|||
{ |
|||
throw new InvalidOperationException("Quant is out of range"); |
|||
} |
|||
|
|||
return compactProperties[quant]; |
|||
} |
|||
|
|||
/// <summary>
|
|||
/// Returns a predictor for index <paramref name="index"/>.
|
|||
/// </summary>
|
|||
/// <param name="index">The index of the predictor.</param>
|
|||
/// <returns>Predictor at index <paramref name="index"/>.</returns>
|
|||
public JxlPredictor PredictorFromIndex(int index) |
|||
{ |
|||
DebugGuard.MustBeLessThan(index, this.predictors.Count, nameof(index)); |
|||
|
|||
return this.predictors[index]; |
|||
} |
|||
|
|||
/// <summary>
|
|||
/// Returns a property for index <paramref name="index"/>.
|
|||
/// </summary>
|
|||
/// <param name="index">The index of the property.</param>
|
|||
/// <returns>Property at index <paramref name="index"/>.</returns>
|
|||
public int PropertyFromIndex(int index) |
|||
{ |
|||
DebugGuard.MustBeLessThan(index, this.propertiesToUse.Count, nameof(index)); |
|||
|
|||
return this.propertiesToUse[index]; |
|||
} |
|||
|
|||
/// <summary>
|
|||
/// Invoked after processing samples completed.
|
|||
/// </summary>
|
|||
public void AllSamplesDone() => this.deduplicationTable = []; |
|||
|
|||
/// <summary>
|
|||
/// Returns the quantized property value of <paramref name="v"/>.
|
|||
/// </summary>
|
|||
/// <param name="property">Index of the property.</param>
|
|||
/// <param name="v">Value to quantize.</param>
|
|||
/// <returns>Quantized value.</returns>
|
|||
public int QuantizeProperty(int property, int v) |
|||
{ |
|||
DebugGuard.MustBeGreaterThanOrEqualTo(property, this.NumberOfStaticProperties, nameof(property)); |
|||
|
|||
v = Math.Clamp(v, -PropertyRange, PropertyRange) + PropertyRange; |
|||
|
|||
return this.propertyMapping[property][v]; |
|||
} |
|||
|
|||
/// <summary>
|
|||
/// Returns the quantized static property value of <paramref name="v"/>.
|
|||
/// </summary>
|
|||
/// <param name="property">Index of the static property.</param>
|
|||
/// <param name="v">Value to quantize.</param>
|
|||
/// <returns>Quantized value.</returns>
|
|||
public int QuantizeStaticProperty(int property, int v) |
|||
{ |
|||
DebugGuard.MustBeGreaterThanOrEqualTo(property, this.NumberOfStaticProperties, nameof(property)); |
|||
|
|||
v = Math.Clamp(v, -PropertyRange, PropertyRange) + PropertyRange; |
|||
|
|||
return this.staticPropertyMapping[property][v]; |
|||
} |
|||
|
|||
public void SetPredictor(JxlPredictor predictor, JxlTreeMode wpTreeMode) |
|||
{ |
|||
if (wpTreeMode == JxlTreeMode.WpOnly) |
|||
{ |
|||
this.predictors = [JxlPredictor.Weighted]; |
|||
|
|||
// equivalent of residuals.resize(1)
|
|||
if (this.residuals.Count > 1) |
|||
{ |
|||
this.residuals = [this.residuals[0]]; |
|||
} |
|||
else if (this.residuals.Count < 1) |
|||
{ |
|||
this.residuals = [[]]; |
|||
} |
|||
|
|||
return; |
|||
} |
|||
|
|||
if (wpTreeMode == JxlTreeMode.NoWp && predictor == JxlPredictor.Weighted) |
|||
{ |
|||
throw new InvalidOperationException("Invalid predictor settings"); |
|||
} |
|||
|
|||
if (predictor == JxlPredictor.Variable) |
|||
{ |
|||
for (int i = 0; i < JxlPredictorFacts.ModularPredictors; i++) |
|||
{ |
|||
this.predictors.Add((JxlPredictor)i); |
|||
} |
|||
|
|||
Span<JxlPredictor> predictorsSpan = CollectionsMarshal.AsSpan(this.predictors); |
|||
RuntimeUtility.Swap(ref predictorsSpan[0], ref predictorsSpan[(int)JxlPredictor.Weighted]); |
|||
RuntimeUtility.Swap(ref predictorsSpan[1], ref predictorsSpan[(int)JxlPredictor.Gradient]); |
|||
} |
|||
else if (predictor == JxlPredictor.Best) |
|||
{ |
|||
this.predictors = [JxlPredictor.Weighted, JxlPredictor.Gradient]; |
|||
} |
|||
else |
|||
{ |
|||
this.predictors = [predictor]; |
|||
} |
|||
|
|||
if (wpTreeMode == JxlTreeMode.NoWp) |
|||
{ |
|||
// delete all weighted predictors
|
|||
_ = this.predictors.RemoveAll(p => p == JxlPredictor.Weighted); |
|||
} |
|||
|
|||
this.residuals.Grow([], this.predictors.Count); |
|||
} |
|||
|
|||
public void SetProperties(List<int> properties, JxlTreeMode wpTreeMode) |
|||
{ |
|||
this.propertiesToUse = properties; |
|||
|
|||
if (wpTreeMode == JxlTreeMode.WpOnly) |
|||
{ |
|||
this.propertiesToUse = [JxlMaConstants.WpProp]; |
|||
} |
|||
else if (wpTreeMode == JxlTreeMode.GradientOnly) |
|||
{ |
|||
this.propertiesToUse = [JxlMaConstants.GradientProp]; |
|||
} |
|||
else if (wpTreeMode == JxlTreeMode.NoWp) |
|||
{ |
|||
// delete all weighted properties, tree mode
|
|||
// says "no weighted predictors"
|
|||
_ = this.propertiesToUse.RemoveAll(x => x == JxlMaConstants.WpProp); |
|||
} |
|||
|
|||
if (this.propertiesToUse.Count == 0) |
|||
{ |
|||
// could happen in default tree mode or when properties parameter
|
|||
// is empty
|
|||
throw new InvalidOperationException("Invalid property set configuration"); |
|||
} |
|||
|
|||
this.NumberOfStaticProperties = 0; |
|||
|
|||
for (int i = 0; i < this.propertiesToUse.Count; ++i) |
|||
{ |
|||
int prop = this.propertiesToUse[i]; |
|||
|
|||
if (prop < JxlPredictorFacts.StaticProperties) |
|||
{ |
|||
if (i != prop) |
|||
{ |
|||
throw new InvalidOperationException("Index is not equal to the property"); |
|||
} |
|||
|
|||
this.NumberOfStaticProperties++; |
|||
} |
|||
} |
|||
|
|||
this.properties.Resize(this.propertiesToUse.Count - this.NumberOfStaticProperties); |
|||
} |
|||
|
|||
public void InitializeTable(int logSize) |
|||
{ |
|||
int size = 1 << logSize; |
|||
|
|||
if (this.deduplicationTable.Count == size) |
|||
{ |
|||
return; |
|||
} |
|||
|
|||
this.deduplicationTable.Resize(size, DeduplicationEntryUnused); |
|||
|
|||
for (int i = 0; i < this.NumberOfDistinctSamples; i++) |
|||
{ |
|||
if (this.sampleCounts[i] != ushort.MaxValue) |
|||
{ |
|||
this.AddToTable(i); |
|||
} |
|||
} |
|||
} |
|||
|
|||
public void AddToTableAndMerge(int a) |
|||
{ |
|||
int pos1 = Hash1(a); |
|||
int pos2 = Hash2(a); |
|||
|
|||
if (this.deduplicationTable[pos1] != DeduplicationEntryUnused && this.IsSameSample(a, this.deduplicationTable[pos1])) |
|||
{ |
|||
if (this.sampleCounts[a] != 1) |
|||
{ |
|||
throw new InvalidOperationException("Sample count must be 1"); |
|||
} |
|||
|
|||
this.sampleCounts[this.deduplicationTable[pos1]]++; |
|||
|
|||
if (this.sampleCounts[this.deduplicationTable[pos1]] == ushort.MaxValue) |
|||
{ |
|||
this.deduplicationTable[pos1] = DeduplicationEntryUnused; |
|||
} |
|||
|
|||
return; |
|||
} |
|||
|
|||
if (this.deduplicationTable[pos2] != DeduplicationEntryUnused && this.IsSameSample(a, this.deduplicationTable[pos2])) |
|||
{ |
|||
if (this.sampleCounts[a] != 1) |
|||
{ |
|||
throw new InvalidOperationException("Sample count must be 1"); |
|||
} |
|||
|
|||
this.sampleCounts[this.deduplicationTable[pos2]]++; |
|||
|
|||
if (this.sampleCounts[this.deduplicationTable[pos2]] == ushort.MaxValue) |
|||
{ |
|||
this.deduplicationTable[pos2] = DeduplicationEntryUnused; |
|||
} |
|||
|
|||
return; |
|||
} |
|||
|
|||
this.AddToTable(a); |
|||
} |
|||
|
|||
public void AddToTable(int a) |
|||
{ |
|||
int pos1 = Hash1(a); |
|||
int pos2 = Hash2(a); |
|||
|
|||
if (this.deduplicationTable[pos1] == DeduplicationEntryUnused) |
|||
{ |
|||
this.deduplicationTable[pos1] = a; |
|||
} |
|||
else if (this.deduplicationTable[pos2] == DeduplicationEntryUnused) |
|||
{ |
|||
this.deduplicationTable[pos2] = a; |
|||
} |
|||
} |
|||
|
|||
public void PrepareForSamples(int extraNumSamples) |
|||
{ |
|||
foreach (List<JxlResidualToken> residual in this.residuals) |
|||
{ |
|||
residual.Grow(default, residual.Count + extraNumSamples); |
|||
} |
|||
|
|||
for (int i = 0; i < this.NumberOfStaticProperties; i++) |
|||
{ |
|||
this.staticProperties[i].Grow(0, this.staticProperties[i].Count + extraNumSamples); |
|||
} |
|||
|
|||
foreach (List<byte> prop in this.properties) |
|||
{ |
|||
prop.Grow((byte)0, prop.Count + extraNumSamples); |
|||
} |
|||
|
|||
int totalNumSamples = extraNumSamples + this.sampleCounts.Count; |
|||
int nextSize = JxlMath.CeilLog2Nonzero(totalNumSamples * 3 / 2); |
|||
|
|||
this.InitializeTable(nextSize); |
|||
} |
|||
|
|||
public int Hash1(int a) |
|||
{ |
|||
const ulong constant = 0x1e35a7bd; |
|||
|
|||
ulong h = constant; |
|||
|
|||
foreach (List<JxlResidualToken> r in this.residuals) |
|||
{ |
|||
h = (h * constant) + (ulong)r[a].Token; |
|||
h = (h * constant) + (ulong)r[a].NumberOfBits; |
|||
} |
|||
|
|||
for (int i = 0; i < this.NumberOfStaticProperties; i++) |
|||
{ |
|||
h = (h * constant) + (ulong)this.staticProperties[i][a]; |
|||
} |
|||
|
|||
foreach (List<byte> property in this.properties) |
|||
{ |
|||
h = (h * constant) + property[a]; |
|||
} |
|||
|
|||
return (int)((h >> 16) & (ulong)(this.deduplicationTable.Count - 1)); |
|||
} |
|||
|
|||
public int Hash2(int a) |
|||
{ |
|||
const ulong constant = 0x1e35a7bd1e35a7bd; |
|||
|
|||
ulong h = constant; |
|||
|
|||
for (int i = 0; i < this.NumberOfStaticProperties; i++) |
|||
{ |
|||
h = (h * constant) ^ (ulong)this.staticProperties[i][a]; |
|||
} |
|||
|
|||
foreach (List<byte> property in this.properties) |
|||
{ |
|||
h = (h * constant) ^ property[a]; |
|||
} |
|||
|
|||
foreach (List<JxlResidualToken> r in this.residuals) |
|||
{ |
|||
h = (h * constant) ^ (ulong)r[a].Token; |
|||
h = (h * constant) ^ (ulong)r[a].NumberOfBits; |
|||
} |
|||
|
|||
return (int)((h >> 16) & (ulong)(this.deduplicationTable.Count - 1)); |
|||
} |
|||
|
|||
public bool IsSameSample(int a, int b) |
|||
{ |
|||
foreach (List<JxlResidualToken> r in this.residuals) |
|||
{ |
|||
if (r[a].Token != r[b].Token) |
|||
{ |
|||
return false; |
|||
} |
|||
|
|||
if (r[a].NumberOfBits != r[b].NumberOfBits) |
|||
{ |
|||
return false; |
|||
} |
|||
} |
|||
|
|||
for (int i = 0; i < this.NumberOfStaticProperties; ++i) |
|||
{ |
|||
if (this.staticProperties[i][a] != this.staticProperties[i][b]) |
|||
{ |
|||
return false; |
|||
} |
|||
} |
|||
|
|||
foreach (List<byte> p in this.properties) |
|||
{ |
|||
if (p[a] != p[b]) |
|||
{ |
|||
return false; |
|||
} |
|||
} |
|||
|
|||
return false; |
|||
} |
|||
|
|||
public void AddSample(int pixel, Span<int> properties, Span<int> predictions) |
|||
{ |
|||
for (int i = 0; i < this.predictors.Count; i++) |
|||
{ |
|||
int v = pixel - predictions[(int)this.predictors[i]]; |
|||
new JxlAnsHybridUIntConfiguration(4, 1, 2).Encode(JxlPackSigned.PackUnsigned(v), out uint tok, out uint nbits, out uint bits); |
|||
|
|||
if (tok >= 256) |
|||
{ |
|||
throw new InvalidOperationException("Token is too large"); |
|||
} |
|||
|
|||
if (nbits >= 256) |
|||
{ |
|||
throw new InvalidOperationException("Number of bits is too large"); |
|||
} |
|||
|
|||
JxlResidualToken token = new((int)tok, (int)nbits); |
|||
this.residuals[i].Add(token); |
|||
} |
|||
|
|||
for (int i = 0; i < this.NumberOfStaticProperties; ++i) |
|||
{ |
|||
this.staticProperties[i].Add(this.QuantizeStaticProperty(i, properties[i])); |
|||
} |
|||
|
|||
for (int i = this.NumberOfStaticProperties; i < this.propertiesToUse.Count; i++) |
|||
{ |
|||
this.properties[i - this.NumberOfStaticProperties].Add(unchecked((byte)this.QuantizeProperty(i, properties[this.propertiesToUse[i]]))); |
|||
} |
|||
|
|||
this.sampleCounts.Add(1); |
|||
this.NumberOfSamples++; |
|||
|
|||
this.AddToTableAndMerge(this.sampleCounts.Count - 1); |
|||
|
|||
foreach (List<JxlResidualToken> residual in this.residuals) |
|||
{ |
|||
// remove last item from List<T>
|
|||
residual.RemoveAt(residual.Count - 1); |
|||
} |
|||
|
|||
for (int i = 0; i < this.NumberOfStaticProperties; i++) |
|||
{ |
|||
// ditto
|
|||
this.staticProperties[i].RemoveAt(this.staticProperties[i].Count - 1); |
|||
} |
|||
|
|||
foreach (List<byte> property in this.properties) |
|||
{ |
|||
// ditto
|
|||
property.RemoveAt(property.Count - 1); |
|||
} |
|||
|
|||
// ditto
|
|||
this.sampleCounts.RemoveAt(this.sampleCounts.Count - 1); |
|||
} |
|||
|
|||
public void Swap(int a, int b) |
|||
{ |
|||
if (a == b) |
|||
{ |
|||
return; |
|||
} |
|||
|
|||
foreach (List<JxlResidualToken> r in this.residuals) |
|||
{ |
|||
// Get a Span for this List so we can get a ref to its items
|
|||
// for use in RuntimeUtility.Swap (tuple-swap is slightly slower)
|
|||
Span<JxlResidualToken> sp = CollectionsMarshal.AsSpan(r); |
|||
|
|||
RuntimeUtility.Swap(ref sp[a], ref sp[b]); |
|||
} |
|||
|
|||
for (int i = 0; i < this.NumberOfStaticProperties; i++) |
|||
{ |
|||
// Ditto
|
|||
Span<int> sp = CollectionsMarshal.AsSpan(this.staticProperties[i]); |
|||
|
|||
RuntimeUtility.Swap(ref sp[a], ref sp[b]); |
|||
} |
|||
|
|||
foreach (List<byte> p in this.properties) |
|||
{ |
|||
// Ditto
|
|||
Span<byte> sp = CollectionsMarshal.AsSpan(p); |
|||
|
|||
RuntimeUtility.Swap(ref sp[a], ref sp[b]); |
|||
} |
|||
|
|||
// Ditto
|
|||
Span<int> sampleCounts = CollectionsMarshal.AsSpan(this.sampleCounts); |
|||
|
|||
RuntimeUtility.Swap(ref sampleCounts[a], ref sampleCounts[b]); |
|||
} |
|||
|
|||
public void PreQuantizeProperties( |
|||
Configuration configuration, |
|||
StaticPropertyRange range, |
|||
List<JxlModularMultiplierInfo> multiplierInfo, |
|||
List<int> groupPixelCount, |
|||
List<int> channelPixelCount, |
|||
List<int> pixelSamples, |
|||
List<int> diffSamples, |
|||
int maxPropertyValues) |
|||
{ |
|||
List<int> groupMultiplierThresholds = []; |
|||
List<int> channelMultiplierThresholds = []; |
|||
|
|||
foreach (JxlModularMultiplierInfo v in multiplierInfo) |
|||
{ |
|||
if (v.Range[0][0] != range[0][0]) |
|||
{ |
|||
channelMultiplierThresholds.Add(v.Range[0][0] - 1); |
|||
} |
|||
|
|||
if (v.Range[0][1] != range[0][1]) |
|||
{ |
|||
channelMultiplierThresholds.Add(v.Range[0][1] - 1); |
|||
} |
|||
|
|||
if (v.Range[1][0] != range[1][0]) |
|||
{ |
|||
groupMultiplierThresholds.Add(v.Range[1][0] - 1); |
|||
} |
|||
|
|||
if (v.Range[1][1] != range[1][1]) |
|||
{ |
|||
groupMultiplierThresholds.Add(v.Range[1][1] - 1); |
|||
} |
|||
} |
|||
|
|||
channelMultiplierThresholds.Sort(); |
|||
channelMultiplierThresholds.Resize(0, channelMultiplierThresholds.Distinct().Count()); |
|||
groupMultiplierThresholds.Sort(); |
|||
groupMultiplierThresholds.Resize(0, groupMultiplierThresholds.Distinct().Count()); |
|||
|
|||
this.compactProperties.Resize([], this.propertiesToUse.Count); |
|||
|
|||
List<int> QuantizeChannel() |
|||
{ |
|||
if (channelMultiplierThresholds.Count > 0) |
|||
{ |
|||
return channelMultiplierThresholds; |
|||
} |
|||
|
|||
return JxlMaEncoder.QuantizeHistogram( |
|||
CollectionsMarshal.AsSpan(groupPixelCount), |
|||
maxPropertyValues); |
|||
} |
|||
|
|||
List<int> QuantizeGroupId() |
|||
{ |
|||
if (groupMultiplierThresholds.Count > 0) |
|||
{ |
|||
return groupMultiplierThresholds; |
|||
} |
|||
|
|||
return JxlMaEncoder.QuantizeHistogram( |
|||
CollectionsMarshal.AsSpan(groupPixelCount), |
|||
maxPropertyValues); |
|||
} |
|||
|
|||
List<int> QuantizeCoordinate() |
|||
{ |
|||
List<int> quantized = new(maxPropertyValues - 1); |
|||
|
|||
for (int i = 0; i + 1 < maxPropertyValues; i++) |
|||
{ |
|||
quantized[i] = ((i + 1) * 256 / maxPropertyValues) - 1; |
|||
} |
|||
|
|||
return quantized; |
|||
} |
|||
|
|||
List<int> absPixelThresholds = []; |
|||
List<int> pixelThresholds = []; |
|||
|
|||
List<int> QuantizePixelProperty() |
|||
{ |
|||
if (pixelThresholds.Count == 0) |
|||
{ |
|||
pixelThresholds = JxlMaEncoder.QuantizeSamples( |
|||
CollectionsMarshal.AsSpan(pixelSamples), |
|||
maxPropertyValues); |
|||
} |
|||
|
|||
return pixelThresholds; |
|||
} |
|||
|
|||
List<int> QuantizeAbsolutePixelProperty() |
|||
{ |
|||
if (absPixelThresholds.Count == 0) |
|||
{ |
|||
_ = QuantizePixelProperty(); // compute the non-abs thresholds
|
|||
|
|||
Span<int> pixelSamplesSpan = CollectionsMarshal.AsSpan(pixelSamples); |
|||
TensorPrimitives.Abs(pixelSamplesSpan, pixelSamplesSpan); |
|||
|
|||
absPixelThresholds = JxlMaEncoder.QuantizeSamples(pixelSamplesSpan, maxPropertyValues); |
|||
} |
|||
|
|||
return absPixelThresholds; |
|||
} |
|||
|
|||
List<int> absoluteDiffThresholds = []; |
|||
List<int> diffThresholds = []; |
|||
|
|||
List<int> QuantizeDiffProperty() |
|||
{ |
|||
if (diffThresholds.Count == 0) |
|||
{ |
|||
diffThresholds = JxlMaEncoder.QuantizeSamples( |
|||
CollectionsMarshal.AsSpan(diffSamples), |
|||
maxPropertyValues); |
|||
} |
|||
|
|||
return diffThresholds; |
|||
} |
|||
|
|||
List<int> QuantizeAbsoluteDiffProperty() |
|||
{ |
|||
if (absoluteDiffThresholds.Count == 0) |
|||
{ |
|||
_ = QuantizeDiffProperty(); |
|||
|
|||
Span<int> diffSamplesSpan = CollectionsMarshal.AsSpan(diffSamples); |
|||
TensorPrimitives.Abs(diffSamplesSpan, diffSamplesSpan); |
|||
|
|||
absoluteDiffThresholds = JxlMaEncoder.QuantizeSamples(diffSamplesSpan, maxPropertyValues); |
|||
} |
|||
|
|||
return absoluteDiffThresholds; |
|||
} |
|||
|
|||
List<int> QuantizeWeightedPrediction() |
|||
{ |
|||
// TODO: static ReadOnlySpan<int> ... => [...]?
|
|||
if (maxPropertyValues < 32) |
|||
{ |
|||
return [-127, -63, -31, -15, -7, -3, -1, 0, 1, |
|||
3, 7, 15, 31, 63, 127]; |
|||
} |
|||
else if (maxPropertyValues < 64) |
|||
{ |
|||
return [-255, -191, -127, -95, -63, -47, -31, -23, |
|||
-15, -11, -7, -5, -3, -1, 0, 1, |
|||
3, 5, 7, 11, 15, 23, 31, 47, |
|||
63, 95, 127, 191, 255]; |
|||
} |
|||
else |
|||
{ |
|||
return [-255, -223, -191, -159, -127, -111, -95, -79, -63, -55, -47, |
|||
-39, -31, -27, -23, -19, -15, -13, -11, -9, -7, -6, |
|||
-5, -4, -3, -2, -1, 0, 1, 2, 3, 4, 5, |
|||
6, 7, 9, 11, 13, 15, 19, 23, 27, 31, 39, |
|||
47, 55, 63, 79, 95, 111, 127, 159, 191, 223, 255]; |
|||
} |
|||
} |
|||
|
|||
this.propertyMapping.Resize(0, this.propertiesToUse.Count - this.NumberOfStaticProperties); |
|||
|
|||
for (int i = 0; i < this.propertiesToUse.Count; i++) |
|||
{ |
|||
if (this.propertiesToUse[i] == 0) |
|||
{ |
|||
this.compactProperties[i] = QuantizeChannel(); |
|||
} |
|||
else if (this.propertiesToUse[i] == 1) |
|||
{ |
|||
this.compactProperties[i] = QuantizeGroupId(); |
|||
} |
|||
else if (this.propertiesToUse[i] is 2 or 3) |
|||
{ |
|||
this.compactProperties[i] = QuantizeCoordinate(); |
|||
} |
|||
else if (this.propertiesToUse[i] == 6 || this.propertiesToUse[i] == 7 || |
|||
this.propertiesToUse[i] == 8 || |
|||
(this.propertiesToUse[i] >= JxlMaConstants.NumNonrefProperties && (this.propertiesToUse[i] - JxlMaConstants.NumNonrefProperties) % 4 == 1)) |
|||
{ |
|||
this.compactProperties[i] = QuantizePixelProperty(); |
|||
} |
|||
else if (this.propertiesToUse[i] == 4 || this.propertiesToUse[i] == 5 || |
|||
(this.propertiesToUse[i] >= JxlMaConstants.NumNonrefProperties && (this.propertiesToUse[i] - JxlMaConstants.NumNonrefProperties) % 4 == 0)) |
|||
{ |
|||
this.compactProperties[i] = QuantizeAbsolutePixelProperty(); |
|||
} |
|||
else if (this.propertiesToUse[i] >= JxlMaConstants.NumNonrefProperties && (this.propertiesToUse[i] - JxlMaConstants.NumNonrefProperties) % 4 == 2) |
|||
{ |
|||
this.compactProperties[i] = QuantizeAbsoluteDiffProperty(); |
|||
} |
|||
else if (this.propertiesToUse[i] == JxlMaConstants.WpProp) |
|||
{ |
|||
this.compactProperties[i] = QuantizeWeightedPrediction(); |
|||
} |
|||
else |
|||
{ |
|||
this.compactProperties[i] = QuantizeDiffProperty(); |
|||
} |
|||
|
|||
if (i < this.NumberOfStaticProperties) |
|||
{ |
|||
JxlMaEncoder.QuantMap( |
|||
CollectionsMarshal.AsSpan(this.compactProperties[i]), |
|||
CollectionsMarshal.AsSpan(this.staticPropertyMapping[i]), |
|||
(PropertyRange * 2) + 1, |
|||
PropertyRange); |
|||
} |
|||
else |
|||
{ |
|||
JxlMaEncoder.QuantMap( |
|||
CollectionsMarshal.AsSpan(this.compactProperties[i]), |
|||
CollectionsMarshal.AsSpan(this.propertyMapping[i - this.NumberOfStaticProperties]), |
|||
(PropertyRange * 2) + 1, |
|||
PropertyRange); |
|||
} |
|||
} |
|||
} |
|||
} |
|||
@ -0,0 +1,15 @@ |
|||
// Copyright (c) Six Labors.
|
|||
// Licensed under the Six Labors Split License.
|
|||
|
|||
namespace SixLabors.ImageSharp.Formats.Jxl.Processing.Modular.Encoding; |
|||
|
|||
internal static class ListUtils |
|||
{ |
|||
public static void Grow<T>(this List<T> list, T item, int desiredSize) |
|||
{ |
|||
while (list.Count < desiredSize) |
|||
{ |
|||
list.Add(item); |
|||
} |
|||
} |
|||
} |
|||
@ -0,0 +1,15 @@ |
|||
# Implementation of Modular coding mode for JPEG XL |
|||
JPEG XL files typically consist of two distinct coding modes: VarDCT |
|||
and Modular. VarDCT is lossy and transform-based, while Modular uses |
|||
the predictive coding approach and can achieve lossless or near-lossless |
|||
compression. |
|||
|
|||
This folder has the implementation of the Modular encoder/decoder. |
|||
|
|||
### Folder structure |
|||
In the Transforms folder, there are implementations for the Reversible |
|||
Color Transform (RCT), Squeeze Transform and Palette, both inverse |
|||
and forward. |
|||
|
|||
In the Encoding folder there are predictors using neighbors, averages, |
|||
weighted prediction and tree-based prediction. |
|||
@ -0,0 +1,87 @@ |
|||
// Copyright (c) Six Labors.
|
|||
// Licensed under the Six Labors Split License.
|
|||
|
|||
using System.Runtime.CompilerServices; |
|||
using SixLabors.ImageSharp.Common.Helpers; |
|||
|
|||
namespace SixLabors.ImageSharp.Formats.Jxl.Processing.Primitives; |
|||
|
|||
/// <summary>
|
|||
/// Deterministic random number generator used for compatibility
|
|||
/// with JPEG XL.
|
|||
/// </summary>
|
|||
internal struct Rng |
|||
{ |
|||
private ulong s0; |
|||
private ulong s1; |
|||
|
|||
public Rng(ulong seed) |
|||
{ |
|||
this.s0 = 0x94D049BB133111EBUL; |
|||
this.s1 = 0xBF58476D1CE4E5B9UL + seed; |
|||
} |
|||
|
|||
[MethodImpl(MethodImplOptions.AggressiveInlining)] |
|||
public ulong Next() |
|||
{ |
|||
ulong s1 = this.s0; |
|||
ulong s0 = this.s1; |
|||
ulong bits = s1 + s0; |
|||
this.s0 = s0; |
|||
|
|||
s1 ^= s1 << 23; |
|||
s1 ^= s0 ^ (s1 >> 18) ^ (s0 >> 5); |
|||
|
|||
this.s1 = s1; |
|||
|
|||
return bits; |
|||
} |
|||
|
|||
[MethodImpl(MethodImplOptions.AggressiveInlining)] |
|||
public long UniformI(long begin, long end) => (long)(this.Next() % (ulong)(end - begin)) + begin; |
|||
|
|||
[MethodImpl(MethodImplOptions.AggressiveInlining)] |
|||
public ulong UniformU(ulong begin, ulong end) => (this.Next() % (end - begin)) + begin; |
|||
|
|||
[MethodImpl(MethodImplOptions.AggressiveInlining)] |
|||
public float UniformF(float begin, float end) |
|||
{ |
|||
uint u = (uint)(this.Next() >> (64 - 23)) | 0x3F800000u; |
|||
float f = BitConverter.UInt32BitsToSingle(u); |
|||
|
|||
return ((end - begin) * (f - 1.0f)) + begin; |
|||
} |
|||
|
|||
[MethodImpl(MethodImplOptions.AggressiveInlining)] |
|||
public bool Bernoulli(float p) => this.UniformF(0, 1) < p; |
|||
|
|||
internal readonly struct GeometricDistribution |
|||
{ |
|||
public readonly float Value { get; } |
|||
|
|||
public GeometricDistribution(float value) => this.Value = value; |
|||
|
|||
[MethodImpl(MethodImplOptions.AggressiveInlining)] |
|||
public static GeometricDistribution Make(float p) => new(1.0f / MathF.Log(1.0f - p)); |
|||
} |
|||
|
|||
[MethodImpl(MethodImplOptions.AggressiveInlining)] |
|||
public uint Geometric(in GeometricDistribution dist) |
|||
{ |
|||
float f = this.UniformF(0, 1); |
|||
float invLog1mp = dist.Value; |
|||
|
|||
float log = MathF.Log(1.0f - f) * invLog1mp; |
|||
|
|||
return (uint)log; |
|||
} |
|||
|
|||
public void Shuffle<T>(Span<T> span) |
|||
{ |
|||
for (nuint i = 0; i + 1 < (nuint)span.Length; i++) |
|||
{ |
|||
nuint a = (nuint)this.UniformU(i, (nuint)span.Length); |
|||
RuntimeUtility.Swap(ref span[(int)a], ref span[(int)i]); |
|||
} |
|||
} |
|||
} |
|||
Loading…
Reference in new issue