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

Implement PickBestIntra16

pull/1552/head
Brian Popow 5 years ago
parent
54eb31d82d
commit
f120728730
9 changed files with 485 additions and 107 deletions
Whitespace
Show all changes Ignore whitespace when comparing lines Ignore changes in amount of whitespace Ignore changes in whitespace at EOL
Split View
Diff Options
Show Stats Download Patch File Download Diff File
  1. 2
      src/ImageSharp/Formats/WebP/Lossless/Vp8LHistogram.cs
  2. 156
      src/ImageSharp/Formats/WebP/Lossy/LossyUtils.cs
  3. 5
      src/ImageSharp/Formats/WebP/Lossy/Vp8EncIterator.cs
  4. 211
      src/ImageSharp/Formats/WebP/Lossy/Vp8Encoder.cs
  5. 7
      src/ImageSharp/Formats/WebP/Lossy/Vp8ModeScore.cs
  6. 54
      src/ImageSharp/Formats/WebP/Lossy/Vp8Residual.cs
  7. 28
      src/ImageSharp/Formats/WebP/Lossy/Vp8SegmentInfo.cs
  8. 2
      src/ImageSharp/Formats/WebP/WebpConstants.cs
  9. 127
      src/ImageSharp/Formats/WebP/WebpLookupTables.cs

2
src/ImageSharp/Formats/WebP/Lossless/Vp8LHistogram.cs
View File

@ -219,7 +219,7 @@ namespace SixLabors.ImageSharp.Formats.Webp.Lossless
{
double sumCost = this.BitCost + b.BitCost;
costThreshold += sumCost;
if (this.GetCombinedHistogramEntropy(b, costThreshold, costInitial: 0, out var cost))
if (this.GetCombinedHistogramEntropy(b, costThreshold, costInitial: 0, out double cost))
{
this.Add(b, output);
output.BitCost = cost;

156
src/ImageSharp/Formats/WebP/Lossy/LossyUtils.cs
View File

@ -25,10 +25,7 @@ namespace SixLabors.ImageSharp.Formats.Webp.Lossy
}
[MethodImpl(InliningOptions.ShortMethod)]
public static void TM16(Span<byte> dst, Span<byte> yuv, int offset)
{
TrueMotion(dst, yuv, offset, 16);
}
public static void TM16(Span<byte> dst, Span<byte> yuv, int offset) => TrueMotion(dst, yuv, offset, 16);
public static void VE16(Span<byte> dst, Span<byte> yuv, int offset)
{
@ -82,11 +79,8 @@ namespace SixLabors.ImageSharp.Formats.Webp.Lossy
}
[MethodImpl(InliningOptions.ShortMethod)]
public static void DC16NoTopLeft(Span<byte> dst)
{
// DC with no top and left samples.
Put16(0x80, dst);
}
public static void DC16NoTopLeft(Span<byte> dst) =>
Put16(0x80, dst); // DC with no top and left samples.
public static void DC8uv(Span<byte> dst, Span<byte> yuv, int offset)
{
@ -103,11 +97,8 @@ namespace SixLabors.ImageSharp.Formats.Webp.Lossy
}
[MethodImpl(InliningOptions.ShortMethod)]
public static void TM8uv(Span<byte> dst, Span<byte> yuv, int offset)
{
// TrueMotion
TrueMotion(dst, yuv, offset, 8);
}
public static void TM8uv(Span<byte> dst, Span<byte> yuv, int offset) =>
TrueMotion(dst, yuv, offset, 8); // TrueMotion
public static void VE8uv(Span<byte> dst, Span<byte> yuv, int offset)
{
@ -167,11 +158,8 @@ namespace SixLabors.ImageSharp.Formats.Webp.Lossy
}
[MethodImpl(InliningOptions.ShortMethod)]
public static void DC8uvNoTopLeft(Span<byte> dst)
{
// DC with nothing.
Put8x8uv(0x80, dst);
}
public static void DC8uvNoTopLeft(Span<byte> dst) =>
Put8x8uv(0x80, dst); // DC with nothing.
public static void DC4(Span<byte> dst, Span<byte> yuv, int offset)
{
@ -192,10 +180,7 @@ namespace SixLabors.ImageSharp.Formats.Webp.Lossy
}
[MethodImpl(InliningOptions.ShortMethod)]
public static void TM4(Span<byte> dst, Span<byte> yuv, int offset)
{
TrueMotion(dst, yuv, offset, 4);
}
public static void TM4(Span<byte> dst, Span<byte> yuv, int offset) => TrueMotion(dst, yuv, offset, 4);
public static void VE4(Span<byte> dst, Span<byte> yuv, int offset)
{
@ -484,6 +469,54 @@ namespace SixLabors.ImageSharp.Formats.Webp.Lossy
}
}
/// <summary>
/// Hadamard transform
/// Returns the weighted sum of the absolute value of transformed coefficients.
/// w[] contains a row-major 4 by 4 symmetric matrix.
/// </summary>
public static int TTransform(Span<byte> input, Span<ushort> w)
{
int sum = 0;
int[] tmp = new int[16];
// horizontal pass.
for (int i = 0; i < 4; ++i)
{
int a0 = input[0] + input[2];
int a1 = input[1] + input[3];
int a2 = input[1] - input[3];
int a3 = input[0] - input[2];
tmp[0 + (i * 4)] = a0 + a1;
tmp[1 + (i * 4)] = a3 + a2;
tmp[2 + (i * 4)] = a3 - a2;
tmp[3 + (i * 4)] = a0 - a1;
input = input.Slice(WebpConstants.Bps);
}
// vertical pass
for (int i = 0; i < 4; ++i)
{
int a0 = tmp[0 + i] + tmp[8 + i];
int a1 = tmp[4 + i] + tmp[12 + i];
int a2 = tmp[4 + i] - tmp[12 + i];
int a3 = tmp[0 + i] - tmp[8 + i];
int b0 = a0 + a1;
int b1 = a3 + a2;
int b2 = a3 - a2;
int b3 = a0 - a1;
sum += w[0] * Math.Abs(b0);
sum += w[4] * Math.Abs(b1);
sum += w[8] * Math.Abs(b2);
sum += w[12] * Math.Abs(b3);
w = w.Slice(1);
}
return sum;
}
public static void TransformTwo(Span<short> src, Span<byte> dst)
{
TransformOne(src, dst);
@ -638,15 +671,11 @@ namespace SixLabors.ImageSharp.Formats.Webp.Lossy
[MethodImpl(InliningOptions.ShortMethod)]
public static void VFilter16(Span<byte> p, int offset, int stride, int thresh, int ithresh, int hevThresh)
{
FilterLoop26(p, offset, stride, 1, 16, thresh, ithresh, hevThresh);
}
=> FilterLoop26(p, offset, stride, 1, 16, thresh, ithresh, hevThresh);
[MethodImpl(InliningOptions.ShortMethod)]
public static void HFilter16(Span<byte> p, int offset, int stride, int thresh, int ithresh, int hevThresh)
{
FilterLoop26(p, offset, 1, stride, 16, thresh, ithresh, hevThresh);
}
=> FilterLoop26(p, offset, 1, stride, 16, thresh, ithresh, hevThresh);
public static void VFilter16i(Span<byte> p, int offset, int stride, int thresh, int ithresh, int hevThresh)
{
@ -698,11 +727,8 @@ namespace SixLabors.ImageSharp.Formats.Webp.Lossy
}
[MethodImpl(InliningOptions.ShortMethod)]
public static uint LoadUv(byte u, byte v)
{
// We process u and v together stashed into 32bit(16bit each).
return (uint)(u | (v << 16));
}
public static uint LoadUv(byte u, byte v) =>
(uint)(u | (v << 16)); // We process u and v together stashed into 32bit(16bit each).
[MethodImpl(InliningOptions.ShortMethod)]
public static void YuvToBgr(int y, int u, int v, Span<byte> bgr)
@ -713,52 +739,28 @@ namespace SixLabors.ImageSharp.Formats.Webp.Lossy
}
[MethodImpl(InliningOptions.ShortMethod)]
public static int YuvToB(int y, int u)
{
return Clip8(MultHi(y, 19077) + MultHi(u, 33050) - 17685);
}
public static int YuvToB(int y, int u) => Clip8(MultHi(y, 19077) + MultHi(u, 33050) - 17685);
[MethodImpl(InliningOptions.ShortMethod)]
public static int YuvToG(int y, int u, int v)
{
return Clip8(MultHi(y, 19077) - MultHi(u, 6419) - MultHi(v, 13320) + 8708);
}
public static int YuvToG(int y, int u, int v) => Clip8(MultHi(y, 19077) - MultHi(u, 6419) - MultHi(v, 13320) + 8708);
[MethodImpl(InliningOptions.ShortMethod)]
public static int YuvToR(int y, int v)
{
return Clip8(MultHi(y, 19077) + MultHi(v, 26149) - 14234);
}
public static int YuvToR(int y, int v) => Clip8(MultHi(y, 19077) + MultHi(v, 26149) - 14234);
[MethodImpl(InliningOptions.ShortMethod)]
public static byte Avg2(byte a, byte b)
{
return (byte)((a + b + 1) >> 1);
}
public static byte Avg2(byte a, byte b) => (byte)((a + b + 1) >> 1);
[MethodImpl(InliningOptions.ShortMethod)]
public static byte Avg3(byte a, byte b, byte c)
{
return (byte)((a + (2 * b) + c + 2) >> 2);
}
public static byte Avg3(byte a, byte b, byte c) => (byte)((a + (2 * b) + c + 2) >> 2);
[MethodImpl(InliningOptions.ShortMethod)]
public static void Dst(Span<byte> dst, int x, int y, byte v)
{
dst[x + (y * WebpConstants.Bps)] = v;
}
public static void Dst(Span<byte> dst, int x, int y, byte v) => dst[x + (y * WebpConstants.Bps)] = v;
[MethodImpl(InliningOptions.ShortMethod)]
public static byte Clip8B(int v)
{
return (byte)((v & ~0xff) == 0 ? v : (v < 0) ? 0 : 255);
}
public static byte Clip8B(int v) => (byte)((v & ~0xff) == 0 ? v : (v < 0) ? 0 : 255);
// Cost of coding one event with probability 'proba'.
public static int Vp8BitCost(int bit, byte proba)
{
return bit == 0 ? WebpLookupTables.Vp8EntropyCost[proba] : WebpLookupTables.Vp8EntropyCost[255 - proba];
}
public static int Vp8BitCost(int bit, byte proba) => bit == 0 ? WebpLookupTables.Vp8EntropyCost[proba] : WebpLookupTables.Vp8EntropyCost[255 - proba];
[MethodImpl(InliningOptions.ShortMethod)]
private static void Put16(int v, Span<byte> dst)
@ -950,15 +952,12 @@ namespace SixLabors.ImageSharp.Formats.Webp.Lossy
}
[MethodImpl(InliningOptions.ShortMethod)]
private static int MultHi(int v, int coeff)
{
return (v * coeff) >> 8;
}
private static int MultHi(int v, int coeff) => (v * coeff) >> 8;
[MethodImpl(InliningOptions.ShortMethod)]
private static void Store(Span<byte> dst, int x, int y, int v)
{
var index = x + (y * WebpConstants.Bps);
int index = x + (y * WebpConstants.Bps);
dst[index] = Clip8B(dst[index] + (v >> 3));
}
@ -972,16 +971,10 @@ namespace SixLabors.ImageSharp.Formats.Webp.Lossy
}
[MethodImpl(InliningOptions.ShortMethod)]
private static int Mul1(int a)
{
return ((a * 20091) >> 16) + a;
}
private static int Mul1(int a) => ((a * 20091) >> 16) + a;
[MethodImpl(InliningOptions.ShortMethod)]
private static int Mul2(int a)
{
return (a * 35468) >> 16;
}
private static int Mul2(int a) => (a * 35468) >> 16;
[MethodImpl(InliningOptions.ShortMethod)]
private static byte Clip8(int v)
@ -1012,9 +1005,6 @@ namespace SixLabors.ImageSharp.Formats.Webp.Lossy
}
[MethodImpl(InliningOptions.ShortMethod)]
private static int Clamp255(int x)
{
return x < 0 ? 0 : (x > 255 ? 255 : x);
}
private static int Clamp255(int x) => x < 0 ? 0 : (x > 255 ? 255 : x);
}
}

5
src/ImageSharp/Formats/WebP/Lossy/Vp8EncIterator.cs
View File

@ -214,10 +214,7 @@ namespace SixLabors.ImageSharp.Formats.Webp.Lossy
private Vp8MacroBlockInfo[] Mb { get; }
public void Init()
{
this.Reset();
}
public void Init() => this.Reset();
public void InitFilter()
{

211
src/ImageSharp/Formats/WebP/Lossy/Vp8Encoder.cs
View File

@ -25,7 +25,7 @@ namespace SixLabors.ImageSharp.Formats.Webp.Lossy
/// <summary>
/// The global configuration.
/// </summary>
private Configuration configuration;
private readonly Configuration configuration;
/// <summary>
/// The quality, that will be used to encode the image.
@ -81,6 +81,11 @@ namespace SixLabors.ImageSharp.Formats.Webp.Lossy
// TODO: filterStrength is hardcoded, should be configurable.
private const int FilterStrength = 60;
/// <summary>
/// I16 mode (special case).
/// </summary>
private const int FlatenessLimitI16 = 0;
/// <summary>
/// Initializes a new instance of the <see cref="Vp8Encoder"/> class.
/// </summary>
@ -261,6 +266,13 @@ namespace SixLabors.ImageSharp.Formats.Webp.Lossy
/// </summary>
private int MbHeaderLimit { get; }
/// <summary>
/// The number of prediction modes.
/// </summary>
private const int NumPredModes = 4;
private readonly ushort[] WeightY = { 38, 32, 20, 9, 32, 28, 17, 7, 20, 17, 10, 4, 9, 7, 4, 2 };
/// <summary>
/// Encodes the image to the specified stream from the <see cref="Image{TPixel}"/>.
/// </summary>
@ -850,15 +862,29 @@ namespace SixLabors.ImageSharp.Formats.Webp.Lossy
{
rd.InitScore();
// We can perform predictions for Luma16x16 and Chroma8x8 already.
// Luma4x4 predictions needs to be done as-we-go.
it.MakeLuma16Preds();
it.MakeChroma8Preds();
// TODO: add support for Rate-distortion optimization levels
// At this point we have heuristically decided intra16 / intra4.
// For method >= 2, pick the best intra4/intra16 based on SSE (~tad slower).
// For method <= 1, we don't re-examine the decision but just go ahead with
// quantization/reconstruction.
this.RefineUsingDistortion(it, rd, this.method >= 2, this.method >= 1);
if (rdOpt > Vp8RdLevel.RdOptNone)
{
this.PickBestIntra16(it, rd);
if (this.method >= 2)
{
this.PickBestIntra4(it, rd);
}
this.PickBestUv(it, rd);
}
else
{
// At this point we have heuristically decided intra16 / intra4.
// For method >= 2, pick the best intra4/intra16 based on SSE (~tad slower).
// For method <= 1, we don't re-examine the decision but just go ahead with
// quantization/reconstruction.
this.RefineUsingDistortion(it, rd, this.method >= 2, this.method >= 1);
}
bool isSkipped = rd.Nz == 0;
it.SetSkip(isSkipped);
@ -866,6 +892,115 @@ namespace SixLabors.ImageSharp.Formats.Webp.Lossy
return isSkipped;
}
private void PickBestIntra16(Vp8EncIterator it, Vp8ModeScore rd)
{
const int numBlocks = 16;
Vp8SegmentInfo dqm = this.SegmentInfos[it.CurrentMacroBlockInfo.Segment];
int lambda = dqm.LambdaI16;
int tlambda = dqm.TLambda;
Span<byte> src = it.YuvIn.AsSpan(Vp8EncIterator.YOffEnc);
var rdTmp = new Vp8ModeScore();
Vp8ModeScore rdCur = rdTmp;
Vp8ModeScore rdBest = rd;
int mode;
bool isFlat = IsFlatSource16(src);
rd.ModeI16 = -1;
for (mode = 0; mode < NumPredModes; ++mode)
{
// scratch buffer.
Span<byte> tmpDst = it.YuvOut2.AsSpan(Vp8EncIterator.YOffEnc);
rdCur.ModeI16 = mode;
// Reconstruct.
rdCur.Nz = (uint)this.ReconstructIntra16(it, dqm, rdCur, tmpDst, mode);
// Measure RD-score.
rdCur.D = Vp8Sse16X16(src, tmpDst);
rdCur.SD = tlambda != 0 ? Mult8B(tlambda, Vp8Disto16x16(src, tmpDst, this.WeightY)) : 0;
rdCur.H = WebpConstants.Vp8FixedCostsI16[mode];
rdCur.R = this.GetCostLuma16(it, rdCur);
if (isFlat)
{
// Refine the first impression (which was in pixel space).
isFlat = IsFlat(rdCur.YAcLevels, numBlocks, FlatenessLimitI16);
if (isFlat)
{
// Block is very flat. We put emphasis on the distortion being very low!
rdCur.D *= 2;
rdCur.SD *= 2;
}
}
// Since we always examine Intra16 first, we can overwrite *rd directly.
rdCur.SetRdScore(lambda);
if (mode == 0 || rdCur.Score < rdBest.Score)
{
Vp8ModeScore tmp = rdCur;
rdCur = rdBest;
rdBest = tmp;
it.SwapOut();
}
}
if (rdBest != rd)
{
rd = rdBest;
}
// Finalize score for mode decision.
rd.SetRdScore(dqm.LambdaMode);
it.SetIntra16Mode(rd.ModeI16);
// We have a blocky macroblock (only DCs are non-zero) with fairly high
// distortion, record max delta so we can later adjust the minimal filtering
// strength needed to smooth these blocks out.
if ((rd.Nz & 0x100ffff) == 0x1000000 && rd.D > dqm.MinDisto)
{
dqm.StoreMaxDelta(rd.YDcLevels);
}
}
private void PickBestIntra4(Vp8EncIterator it, Vp8ModeScore rd)
{
}
private void PickBestUv(Vp8EncIterator it, Vp8ModeScore rd)
{
}
private int GetCostLuma16(Vp8EncIterator it, Vp8ModeScore rd)
{
var res = new Vp8Residual();
int r = 0;
// re-import the non-zero context.
it.NzToBytes();
// DC
res.Init(0, 1, this.Proba);
res.SetCoeffs(rd.YDcLevels);
r += res.GetResidualCost(it.TopNz[8] + it.LeftNz[8]);
// AC
res.Init(1, 0, this.Proba);
for (int y = 0; y < 4; ++y)
{
for (int x = 0; x < 4; ++x)
{
int ctx = it.TopNz[x] + it.LeftNz[y];
res.SetCoeffs(rd.YAcLevels.AsSpan(x + (y * 4)));
r += res.GetResidualCost(ctx);
it.TopNz[x] = it.LeftNz[y] = (res.Last >= 0) ? 1 : 0;
}
}
return r;
}
// Refine intra16/intra4 sub-modes based on distortion only (not rate).
private void RefineUsingDistortion(Vp8EncIterator it, Vp8ModeScore rd, bool tryBothModes, bool refineUvMode)
{
@ -876,22 +1011,21 @@ namespace SixLabors.ImageSharp.Formats.Webp.Lossy
Vp8SegmentInfo dqm = this.SegmentInfos[it.CurrentMacroBlockInfo.Segment];
// Some empiric constants, of approximate order of magnitude.
int lambdaDi16 = 106;
int lambdaDi4 = 11;
int lambdaDuv = 120;
const int lambdaDi16 = 106;
const int lambdaDi4 = 11;
const int lambdaDuv = 120;
long scoreI4 = dqm.I4Penalty;
long i4BitSum = 0;
long bitLimit = tryBothModes
? this.MbHeaderLimit
: Vp8ModeScore.MaxCost; // no early-out allowed.
int numPredModes = 4;
int numBModes = 10;
const int numBModes = 10;
if (isI16)
{
int bestMode = -1;
Span<byte> src = it.YuvIn.AsSpan(Vp8EncIterator.YOffEnc);
for (mode = 0; mode < numPredModes; ++mode)
for (mode = 0; mode < NumPredModes; ++mode)
{
Span<byte> reference = it.YuvP.AsSpan(Vp8Encoding.Vp8I16ModeOffsets[mode]);
long score = (Vp8Sse16X16(src, reference) * WebpConstants.RdDistoMult) + (WebpConstants.Vp8FixedCostsI16[mode] * lambdaDi16);
@ -987,7 +1121,7 @@ namespace SixLabors.ImageSharp.Formats.Webp.Lossy
int bestMode = -1;
long bestUvScore = Vp8ModeScore.MaxCost;
Span<byte> src = it.YuvIn.AsSpan(Vp8EncIterator.UOffEnc);
for (mode = 0; mode < numPredModes; ++mode)
for (mode = 0; mode < NumPredModes; ++mode)
{
Span<byte> reference = it.YuvP.AsSpan(Vp8Encoding.Vp8UvModeOffsets[mode]);
long score = (Vp8Sse16X8(src, reference) * WebpConstants.RdDistoMult) + (WebpConstants.Vp8FixedCostsUv[mode] * lambdaDuv);
@ -1313,6 +1447,52 @@ namespace SixLabors.ImageSharp.Formats.Webp.Lossy
return count;
}
[MethodImpl(InliningOptions.ShortMethod)]
private static int Vp8Disto16x16(Span<byte> a, Span<byte> b, Span<ushort> w)
{
int D = 0;
int x, y;
for (y = 0; y < 16 * WebpConstants.Bps; y += 4 * WebpConstants.Bps)
{
for (x = 0; x < 16; x += 4)
{
D += Disto4x4(a.Slice(x + y), b.Slice(x + y), w);
}
}
return D;
}
[MethodImpl(InliningOptions.ShortMethod)]
private static int Disto4x4(Span<byte> a, Span<byte> b, Span<ushort> w)
{
int sum1 = LossyUtils.TTransform(a, w);
int sum2 = LossyUtils.TTransform(b, w);
return Math.Abs(sum2 - sum1) >> 5;
}
[MethodImpl(InliningOptions.ShortMethod)]
private static bool IsFlat(Span<short> levels, int numBlocks, int thresh)
{
int score = 0;
while (numBlocks-- > 0)
{
for (int i = 1; i < 16; ++i)
{
// omit DC, we're only interested in AC
score += (levels[i] != 0) ? 1 : 0;
if (score > thresh)
{
return false;
}
}
levels = levels.Slice(16, 16);
}
return true;
}
[MethodImpl(InliningOptions.ShortMethod)]
private static bool IsFlatSource16(Span<byte> src)
{
@ -1360,6 +1540,9 @@ namespace SixLabors.ImageSharp.Formats.Webp.Lossy
return WebpLookupTables.LevelsFromDelta[sharpness, pos];
}
[MethodImpl(InliningOptions.ShortMethod)]
private static int Mult8B(int a, int b) => ((a * b) + 128) >> 8;
[MethodImpl(InliningOptions.ShortMethod)]
private static double GetPsnr(long mse, long size) => (mse > 0 && size > 0) ? 10.0f * Math.Log10(255.0f * 255.0f * size / mse) : 99;

7
src/ImageSharp/Formats/WebP/Lossy/Vp8ModeScore.cs
View File

@ -10,6 +10,11 @@ namespace SixLabors.ImageSharp.Formats.Webp.Lossy
{
public const long MaxCost = 0x7fffffffffffffL;
/// <summary>
/// Distortion multiplier (equivalent of lambda).
/// </summary>
private const int RdDistoMult = 256;
/// <summary>
/// Initializes a new instance of the <see cref="Vp8ModeScore"/> class.
/// </summary>
@ -91,5 +96,7 @@ namespace SixLabors.ImageSharp.Formats.Webp.Lossy
this.Nz = 0;
this.Score = MaxCost;
}
public void SetRdScore(int lambda) => this.Score = ((this.R + this.H) * lambda) + (RdDistoMult * (this.D + this.SD));
}
}

54
src/ImageSharp/Formats/WebP/Lossy/Vp8Residual.cs
View File

@ -10,8 +10,6 @@ namespace SixLabors.ImageSharp.Formats.Webp.Lossy
/// </summary>
internal class Vp8Residual
{
private const int MaxVariableLevel = 67;
public int First { get; set; }
public int Last { get; set; }
@ -24,12 +22,15 @@ namespace SixLabors.ImageSharp.Formats.Webp.Lossy
public Vp8Stats[] Stats { get; set; }
public ushort[] Costs { get; set; }
public void Init(int first, int coeffType, Vp8EncProba prob)
{
this.First = first;
this.CoeffType = coeffType;
this.Prob = prob.Coeffs[this.CoeffType];
this.Stats = prob.Stats[this.CoeffType];
this.Costs = new ushort[WebpConstants.NumCtx * (WebpConstants.MaxVariableLevel + 1)];
// TODO:
// res->costs = enc->proba_.remapped_costs_[coeff_type];
@ -83,9 +84,9 @@ namespace SixLabors.ImageSharp.Formats.Webp.Lossy
else
{
v = Math.Abs(v);
if (v > MaxVariableLevel)
if (v > WebpConstants.MaxVariableLevel)
{
v = MaxVariableLevel;
v = WebpConstants.MaxVariableLevel;
}
int bits = WebpLookupTables.Vp8LevelCodes[v - 1][1];
@ -106,12 +107,55 @@ namespace SixLabors.ImageSharp.Formats.Webp.Lossy
if (n < 16)
{
this.RecordStats(0, s, 0);
this.RecordStats(0, s, 0);
}
return 1;
}
public int GetResidualCost(int ctx0)
{
int n = this.First;
int p0 = this.Prob[n].Probabilities[ctx0].Probabilities[0];
ushort[] costs = this.Costs;
Span<ushort> t = costs.AsSpan(n * ctx0);
// bitCost(1, p0) is already incorporated in t[] tables, but only if ctx != 0
// (as required by the syntax). For ctx0 == 0, we need to add it here or it'll
// be missing during the loop.
int cost = (ctx0 == 0) ? LossyUtils.Vp8BitCost(1, (byte)p0) : 0;
if (this.Last < 0)
{
return LossyUtils.Vp8BitCost(0, (byte)p0);
}
int v;
for (; n < this.Last; ++n)
{
v = Math.Abs(this.Coeffs[n]);
int ctx = (v >= 2) ? 2 : v;
cost += LevelCost(t, v);
t[0] = costs[(n + 1) * ctx];
}
// Last coefficient is always non-zero
v = Math.Abs(this.Coeffs[n]);
cost += LevelCost(t, v);
if (n < 15)
{
int b = WebpConstants.Vp8EncBands[n + 1];
int ctx = (v == 1) ? 1 : 2;
int last_p0 = this.Prob[b].Probabilities[ctx].Probabilities[0];
cost += LossyUtils.Vp8BitCost(0, (byte)last_p0);
}
return cost;
}
private static int LevelCost(Span<ushort> table, int level)
=> WebpLookupTables.Vp8LevelFixedCosts[level] + table[(level > WebpConstants.MaxVariableLevel) ? WebpConstants.MaxVariableLevel : level];
private int RecordStats(int bit, Vp8StatsArray statsArr, int idx)
{
// An overflow is inbound. Note we handle this at 0xfffe0000u instead of

28
src/ImageSharp/Formats/WebP/Lossy/Vp8SegmentInfo.cs
View File

@ -1,6 +1,8 @@
// Copyright (c) Six Labors.
// Licensed under the Apache License, Version 2.0.
using System;
namespace SixLabors.ImageSharp.Formats.Webp.Lossy
{
internal class Vp8SegmentInfo
@ -49,5 +51,31 @@ namespace SixLabors.ImageSharp.Formats.Webp.Lossy
/// Gets or sets the penalty for using Intra4.
/// </summary>
public long I4Penalty { get; set; }
/// <summary>
/// Gets or sets the minimum distortion required to trigger filtering record.
/// </summary>
public int MinDisto { get; set; }
public int LambdaI16 { get; set; }
public int TLambda { get; set; }
public int LambdaMode { get; set; }
public void StoreMaxDelta(Span<short> dcs)
{
// We look at the first three AC coefficients to determine what is the average
// delta between each sub-4x4 block.
int v0 = Math.Abs(dcs[1]);
int v1 = Math.Abs(dcs[2]);
int v2 = Math.Abs(dcs[4]);
int maxV = (v1 > v0) ? v1 : v0;
maxV = (v2 > maxV) ? v2 : maxV;
if (maxV > this.MaxEdge)
{
this.MaxEdge = maxV;
}
}
}
}

2
src/ImageSharp/Formats/WebP/WebpConstants.cs
View File

@ -222,6 +222,8 @@ namespace SixLabors.ImageSharp.Formats.Webp
public const int NumCtx = 3;
public const int MaxVariableLevel = 67;
// This is the common stride for enc/dec.
public const int Bps = 32;

127
src/ImageSharp/Formats/WebP/WebpLookupTables.cs
View File

@ -54,6 +54,133 @@ namespace SixLabors.ImageSharp.Formats.Webp
8 + (0 * WebpConstants.Bps), 12 + (0 * WebpConstants.Bps), 8 + (4 * WebpConstants.Bps), 12 + (4 * WebpConstants.Bps) // V
};
// fixed costs for coding levels, deduce from the coding tree.
// This is only the part that doesn't depend on the probability state.
public static readonly short[] Vp8LevelFixedCosts =
{
0, 256, 256, 256, 256, 432, 618, 630, 731, 640, 640, 828, 901, 948, 1021, 1101, 1174, 1221, 1294, 1042,
1085, 1115, 1158, 1202, 1245, 1275, 1318, 1337, 1380, 1410, 1453, 1497, 1540, 1570, 1613, 1280, 1295,
1317, 1332, 1358, 1373, 1395, 1410, 1454, 1469, 1491, 1506, 1532, 1547, 1569, 1584, 1601, 1616, 1638,
1653, 1679, 1694, 1716, 1731, 1775, 1790, 1812, 1827, 1853, 1868, 1890, 1905, 1727, 1733, 1742, 1748,
1759, 1765, 1774, 1780, 1800, 1806, 1815, 1821, 1832, 1838, 1847, 1853, 1878, 1884, 1893, 1899, 1910,
1916, 1925, 1931, 1951, 1957, 1966, 1972, 1983, 1989, 1998, 2004, 2027, 2033, 2042, 2048, 2059, 2065,
2074, 2080, 2100, 2106, 2115, 2121, 2132, 2138, 2147, 2153, 2178, 2184, 2193, 2199, 2210, 2216, 2225,
2231, 2251, 2257, 2266, 2272, 2283, 2289, 2298, 2304, 2168, 2174, 2183, 2189, 2200, 2206, 2215, 2221,
2241, 2247, 2256, 2262, 2273, 2279, 2288, 2294, 2319, 2325, 2334, 2340, 2351, 2357, 2366, 2372, 2392,
2398, 2407, 2413, 2424, 2430, 2439, 2445, 2468, 2474, 2483, 2489, 2500, 2506, 2515, 2521, 2541, 2547,
2556, 2562, 2573, 2579, 2588, 2594, 2619, 2625, 2634, 2640, 2651, 2657, 2666, 2672, 2692, 2698, 2707,
2713, 2724, 2730, 2739, 2745, 2540, 2546, 2555, 2561, 2572, 2578, 2587, 2593, 2613, 2619, 2628, 2634,
2645, 2651, 2660, 2666, 2691, 2697, 2706, 2712, 2723, 2729, 2738, 2744, 2764, 2770, 2779, 2785, 2796,
2802, 2811, 2817, 2840, 2846, 2855, 2861, 2872, 2878, 2887, 2893, 2913, 2919, 2928, 2934, 2945, 2951,
2960, 2966, 2991, 2997, 3006, 3012, 3023, 3029, 3038, 3044, 3064, 3070, 3079, 3085, 3096, 3102, 3111,
3117, 2981, 2987, 2996, 3002, 3013, 3019, 3028, 3034, 3054, 3060, 3069, 3075, 3086, 3092, 3101, 3107,
3132, 3138, 3147, 3153, 3164, 3170, 3179, 3185, 3205, 3211, 3220, 3226, 3237, 3243, 3252, 3258, 3281,
3287, 3296, 3302, 3313, 3319, 3328, 3334, 3354, 3360, 3369, 3375, 3386, 3392, 3401, 3407, 3432, 3438,
3447, 3453, 3464, 3470, 3479, 3485, 3505, 3511, 3520, 3526, 3537, 3543, 3552, 3558, 2816, 2822, 2831,
2837, 2848, 2854, 2863, 2869, 2889, 2895, 2904, 2910, 2921, 2927, 2936, 2942, 2967, 2973, 2982, 2988,
2999, 3005, 3014, 3020, 3040, 3046, 3055, 3061, 3072, 3078, 3087, 3093, 3116, 3122, 3131, 3137, 3148,
3154, 3163, 3169, 3189, 3195, 3204, 3210, 3221, 3227, 3236, 3242, 3267, 3273, 3282, 3288, 3299, 3305,
3314, 3320, 3340, 3346, 3355, 3361, 3372, 3378, 3387, 3393, 3257, 3263, 3272, 3278, 3289, 3295, 3304,
3310, 3330, 3336, 3345, 3351, 3362, 3368, 3377, 3383, 3408, 3414, 3423, 3429, 3440, 3446, 3455, 3461,
3481, 3487, 3496, 3502, 3513, 3519, 3528, 3534, 3557, 3563, 3572, 3578, 3589, 3595, 3604, 3610, 3630,
3636, 3645, 3651, 3662, 3668, 3677, 3683, 3708, 3714, 3723, 3729, 3740, 3746, 3755, 3761, 3781, 3787,
3796, 3802, 3813, 3819, 3828, 3834, 3629, 3635, 3644, 3650, 3661, 3667, 3676, 3682, 3702, 3708, 3717,
3723, 3734, 3740, 3749, 3755, 3780, 3786, 3795, 3801, 3812, 3818, 3827, 3833, 3853, 3859, 3868, 3874,
3885, 3891, 3900, 3906, 3929, 3935, 3944, 3950, 3961, 3967, 3976, 3982, 4002, 4008, 4017, 4023, 4034,
4040, 4049, 4055, 4080, 4086, 4095, 4101, 4112, 4118, 4127, 4133, 4153, 4159, 4168, 4174, 4185, 4191,
4200, 4206, 4070, 4076, 4085, 4091, 4102, 4108, 4117, 4123, 4143, 4149, 4158, 4164, 4175, 4181, 4190,
4196, 4221, 4227, 4236, 4242, 4253, 4259, 4268, 4274, 4294, 4300, 4309, 4315, 4326, 4332, 4341, 4347,
4370, 4376, 4385, 4391, 4402, 4408, 4417, 4423, 4443, 4449, 4458, 4464, 4475, 4481, 4490, 4496, 4521,
4527, 4536, 4542, 4553, 4559, 4568, 4574, 4594, 4600, 4609, 4615, 4626, 4632, 4641, 4647, 3515, 3521,
3530, 3536, 3547, 3553, 3562, 3568, 3588, 3594, 3603, 3609, 3620, 3626, 3635, 3641, 3666, 3672, 3681,
3687, 3698, 3704, 3713, 3719, 3739, 3745, 3754, 3760, 3771, 3777, 3786, 3792, 3815, 3821, 3830, 3836,
3847, 3853, 3862, 3868, 3888, 3894, 3903, 3909, 3920, 3926, 3935, 3941, 3966, 3972, 3981, 3987, 3998,
4004, 4013, 4019, 4039, 4045, 4054, 4060, 4071, 4077, 4086, 4092, 3956, 3962, 3971, 3977, 3988, 3994,
4003, 4009, 4029, 4035, 4044, 4050, 4061, 4067, 4076, 4082, 4107, 4113, 4122, 4128, 4139, 4145, 4154,
4160, 4180, 4186, 4195, 4201, 4212, 4218, 4227, 4233, 4256, 4262, 4271, 4277, 4288, 4294, 4303, 4309,
4329, 4335, 4344, 4350, 4361, 4367, 4376, 4382, 4407, 4413, 4422, 4428, 4439, 4445, 4454, 4460, 4480,
4486, 4495, 4501, 4512, 4518, 4527, 4533, 4328, 4334, 4343, 4349, 4360, 4366, 4375, 4381, 4401, 4407,
4416, 4422, 4433, 4439, 4448, 4454, 4479, 4485, 4494, 4500, 4511, 4517, 4526, 4532, 4552, 4558, 4567,
4573, 4584, 4590, 4599, 4605, 4628, 4634, 4643, 4649, 4660, 4666, 4675, 4681, 4701, 4707, 4716, 4722,
4733, 4739, 4748, 4754, 4779, 4785, 4794, 4800, 4811, 4817, 4826, 4832, 4852, 4858, 4867, 4873, 4884,
4890, 4899, 4905, 4769, 4775, 4784, 4790, 4801, 4807, 4816, 4822, 4842, 4848, 4857, 4863, 4874, 4880,
4889, 4895, 4920, 4926, 4935, 4941, 4952, 4958, 4967, 4973, 4993, 4999, 5008, 5014, 5025, 5031, 5040,
5046, 5069, 5075, 5084, 5090, 5101, 5107, 5116, 5122, 5142, 5148, 5157, 5163, 5174, 5180, 5189, 5195,
5220, 5226, 5235, 5241, 5252, 5258, 5267, 5273, 5293, 5299, 5308, 5314, 5325, 5331, 5340, 5346, 4604,
4610, 4619, 4625, 4636, 4642, 4651, 4657, 4677, 4683, 4692, 4698, 4709, 4715, 4724, 4730, 4755, 4761,
4770, 4776, 4787, 4793, 4802, 4808, 4828, 4834, 4843, 4849, 4860, 4866, 4875, 4881, 4904, 4910, 4919,
4925, 4936, 4942, 4951, 4957, 4977, 4983, 4992, 4998, 5009, 5015, 5024, 5030, 5055, 5061, 5070, 5076,
5087, 5093, 5102, 5108, 5128, 5134, 5143, 5149, 5160, 5166, 5175, 5181, 5045, 5051, 5060, 5066, 5077,
5083, 5092, 5098, 5118, 5124, 5133, 5139, 5150, 5156, 5165, 5171, 5196, 5202, 5211, 5217, 5228, 5234,
5243, 5249, 5269, 5275, 5284, 5290, 5301, 5307, 5316, 5322, 5345, 5351, 5360, 5366, 5377, 5383, 5392,
5398, 5418, 5424, 5433, 5439, 5450, 5456, 5465, 5471, 5496, 5502, 5511, 5517, 5528, 5534, 5543, 5549,
5569, 5575, 5584, 5590, 5601, 5607, 5616, 5622, 5417, 5423, 5432, 5438, 5449, 5455, 5464, 5470, 5490,
5496, 5505, 5511, 5522, 5528, 5537, 5543, 5568, 5574, 5583, 5589, 5600, 5606, 5615, 5621, 5641, 5647,
5656, 5662, 5673, 5679, 5688, 5694, 5717, 5723, 5732, 5738, 5749, 5755, 5764, 5770, 5790, 5796, 5805,
5811, 5822, 5828, 5837, 5843, 5868, 5874, 5883, 5889, 5900, 5906, 5915, 5921, 5941, 5947, 5956, 5962,
5973, 5979, 5988, 5994, 5858, 5864, 5873, 5879, 5890, 5896, 5905, 5911, 5931, 5937, 5946, 5952, 5963,
5969, 5978, 5984, 6009, 6015, 6024, 6030, 6041, 6047, 6056, 6062, 6082, 6088, 6097, 6103, 6114, 6120,
6129, 6135, 6158, 6164, 6173, 6179, 6190, 6196, 6205, 6211, 6231, 6237, 6246, 6252, 6263, 6269, 6278,
6284, 6309, 6315, 6324, 6330, 6341, 6347, 6356, 6362, 6382, 6388, 6397, 6403, 6414, 6420, 6429, 6435,
3515, 3521, 3530, 3536, 3547, 3553, 3562, 3568, 3588, 3594, 3603, 3609, 3620, 3626, 3635, 3641, 3666,
3672, 3681, 3687, 3698, 3704, 3713, 3719, 3739, 3745, 3754, 3760, 3771, 3777, 3786, 3792, 3815, 3821,
3830, 3836, 3847, 3853, 3862, 3868, 3888, 3894, 3903, 3909, 3920, 3926, 3935, 3941, 3966, 3972, 3981,
3987, 3998, 4004, 4013, 4019, 4039, 4045, 4054, 4060, 4071, 4077, 4086, 4092, 3956, 3962, 3971, 3977,
3988, 3994, 4003, 4009, 4029, 4035, 4044, 4050, 4061, 4067, 4076, 4082, 4107, 4113, 4122, 4128, 4139,
4145, 4154, 4160, 4180, 4186, 4195, 4201, 4212, 4218, 4227, 4233, 4256, 4262, 4271, 4277, 4288, 4294,
4303, 4309, 4329, 4335, 4344, 4350, 4361, 4367, 4376, 4382, 4407, 4413, 4422, 4428, 4439, 4445, 4454,
4460, 4480, 4486, 4495, 4501, 4512, 4518, 4527, 4533, 4328, 4334, 4343, 4349, 4360, 4366, 4375, 4381,
4401, 4407, 4416, 4422, 4433, 4439, 4448, 4454, 4479, 4485, 4494, 4500, 4511, 4517, 4526, 4532, 4552,
4558, 4567, 4573, 4584, 4590, 4599, 4605, 4628, 4634, 4643, 4649, 4660, 4666, 4675, 4681, 4701, 4707,
4716, 4722, 4733, 4739, 4748, 4754, 4779, 4785, 4794, 4800, 4811, 4817, 4826, 4832, 4852, 4858, 4867,
4873, 4884, 4890, 4899, 4905, 4769, 4775, 4784, 4790, 4801, 4807, 4816, 4822, 4842, 4848, 4857, 4863,
4874, 4880, 4889, 4895, 4920, 4926, 4935, 4941, 4952, 4958, 4967, 4973, 4993, 4999, 5008, 5014, 5025,
5031, 5040, 5046, 5069, 5075, 5084, 5090, 5101, 5107, 5116, 5122, 5142, 5148, 5157, 5163, 5174, 5180,
5189, 5195, 5220, 5226, 5235, 5241, 5252, 5258, 5267, 5273, 5293, 5299, 5308, 5314, 5325, 5331, 5340,
5346, 4604, 4610, 4619, 4625, 4636, 4642, 4651, 4657, 4677, 4683, 4692, 4698, 4709, 4715, 4724, 4730,
4755, 4761, 4770, 4776, 4787, 4793, 4802, 4808, 4828, 4834, 4843, 4849, 4860, 4866, 4875, 4881, 4904,
4910, 4919, 4925, 4936, 4942, 4951, 4957, 4977, 4983, 4992, 4998, 5009, 5015, 5024, 5030, 5055, 5061,
5070, 5076, 5087, 5093, 5102, 5108, 5128, 5134, 5143, 5149, 5160, 5166, 5175, 5181, 5045, 5051, 5060,
5066, 5077, 5083, 5092, 5098, 5118, 5124, 5133, 5139, 5150, 5156, 5165, 5171, 5196, 5202, 5211, 5217,
5228, 5234, 5243, 5249, 5269, 5275, 5284, 5290, 5301, 5307, 5316, 5322, 5345, 5351, 5360, 5366, 5377,
5383, 5392, 5398, 5418, 5424, 5433, 5439, 5450, 5456, 5465, 5471, 5496, 5502, 5511, 5517, 5528, 5534,
5543, 5549, 5569, 5575, 5584, 5590, 5601, 5607, 5616, 5622, 5417, 5423, 5432, 5438, 5449, 5455, 5464,
5470, 5490, 5496, 5505, 5511, 5522, 5528, 5537, 5543, 5568, 5574, 5583, 5589, 5600, 5606, 5615, 5621,
5641, 5647, 5656, 5662, 5673, 5679, 5688, 5694, 5717, 5723, 5732, 5738, 5749, 5755, 5764, 5770, 5790,
5796, 5805, 5811, 5822, 5828, 5837, 5843, 5868, 5874, 5883, 5889, 5900, 5906, 5915, 5921, 5941, 5947,
5956, 5962, 5973, 5979, 5988, 5994, 5858, 5864, 5873, 5879, 5890, 5896, 5905, 5911, 5931, 5937, 5946,
5952, 5963, 5969, 5978, 5984, 6009, 6015, 6024, 6030, 6041, 6047, 6056, 6062, 6082, 6088, 6097, 6103,
6114, 6120, 6129, 6135, 6158, 6164, 6173, 6179, 6190, 6196, 6205, 6211, 6231, 6237, 6246, 6252, 6263,
6269, 6278, 6284, 6309, 6315, 6324, 6330, 6341, 6347, 6356, 6362, 6382, 6388, 6397, 6403, 6414, 6420,
6429, 6435, 5303, 5309, 5318, 5324, 5335, 5341, 5350, 5356, 5376, 5382, 5391, 5397, 5408, 5414, 5423,
5429, 5454, 5460, 5469, 5475, 5486, 5492, 5501, 5507, 5527, 5533, 5542, 5548, 5559, 5565, 5574, 5580,
5603, 5609, 5618, 5624, 5635, 5641, 5650, 5656, 5676, 5682, 5691, 5697, 5708, 5714, 5723, 5729, 5754,
5760, 5769, 5775, 5786, 5792, 5801, 5807, 5827, 5833, 5842, 5848, 5859, 5865, 5874, 5880, 5744, 5750,
5759, 5765, 5776, 5782, 5791, 5797, 5817, 5823, 5832, 5838, 5849, 5855, 5864, 5870, 5895, 5901, 5910,
5916, 5927, 5933, 5942, 5948, 5968, 5974, 5983, 5989, 6000, 6006, 6015, 6021, 6044, 6050, 6059, 6065,
6076, 6082, 6091, 6097, 6117, 6123, 6132, 6138, 6149, 6155, 6164, 6170, 6195, 6201, 6210, 6216, 6227,
6233, 6242, 6248, 6268, 6274, 6283, 6289, 6300, 6306, 6315, 6321, 6116, 6122, 6131, 6137, 6148, 6154,
6163, 6169, 6189, 6195, 6204, 6210, 6221, 6227, 6236, 6242, 6267, 6273, 6282, 6288, 6299, 6305, 6314,
6320, 6340, 6346, 6355, 6361, 6372, 6378, 6387, 6393, 6416, 6422, 6431, 6437, 6448, 6454, 6463, 6469,
6489, 6495, 6504, 6510, 6521, 6527, 6536, 6542, 6567, 6573, 6582, 6588, 6599, 6605, 6614, 6620, 6640,
6646, 6655, 6661, 6672, 6678, 6687, 6693, 6557, 6563, 6572, 6578, 6589, 6595, 6604, 6610, 6630, 6636,
6645, 6651, 6662, 6668, 6677, 6683, 6708, 6714, 6723, 6729, 6740, 6746, 6755, 6761, 6781, 6787, 6796,
6802, 6813, 6819, 6828, 6834, 6857, 6863, 6872, 6878, 6889, 6895, 6904, 6910, 6930, 6936, 6945, 6951,
6962, 6968, 6977, 6983, 7008, 7014, 7023, 7029, 7040, 7046, 7055, 7061, 7081, 7087, 7096, 7102, 7113,
7119, 7128, 7134, 6392, 6398, 6407, 6413, 6424, 6430, 6439, 6445, 6465, 6471, 6480, 6486, 6497, 6503,
6512, 6518, 6543, 6549, 6558, 6564, 6575, 6581, 6590, 6596, 6616, 6622, 6631, 6637, 6648, 6654, 6663,
6669, 6692, 6698, 6707, 6713, 6724, 6730, 6739, 6745, 6765, 6771, 6780, 6786, 6797, 6803, 6812, 6818,
6843, 6849, 6858, 6864, 6875, 6881, 6890, 6896, 6916, 6922, 6931, 6937, 6948, 6954, 6963, 6969, 6833,
6839, 6848, 6854, 6865, 6871, 6880, 6886, 6906, 6912, 6921, 6927, 6938, 6944, 6953, 6959, 6984, 6990,
6999, 7005, 7016, 7022, 7031, 7037, 7057, 7063, 7072, 7078, 7089, 7095, 7104, 7110, 7133, 7139, 7148,
7154, 7165, 7171, 7180, 7186, 7206, 7212, 7221, 7227, 7238, 7244, 7253, 7259, 7284, 7290, 7299, 7305,
7316, 7322, 7331, 7337, 7357, 7363, 7372, 7378, 7389, 7395, 7404, 7410, 7205, 7211, 7220, 7226, 7237,
7243, 7252, 7258, 7278, 7284, 7293, 7299, 7310, 7316, 7325, 7331, 7356, 7362, 7371, 7377, 7388, 7394,
7403, 7409, 7429, 7435, 7444, 7450, 7461, 7467, 7476, 7482, 7505, 7511, 7520, 7526, 7537, 7543, 7552,
7558, 7578, 7584, 7593, 7599, 7610, 7616, 7625, 7631, 7656, 7662, 7671, 7677, 7688, 7694, 7703, 7709,
7729, 7735, 7744, 7750, 7761
};
// This table gives, for a given sharpness, the filtering strength to be
// used (at least) in order to filter a given edge step delta.
public static readonly byte[,] LevelsFromDelta =

Write Preview
Loading…
Cancel
Save