mirror of https://github.com/SixLabors/ImageSharp
James Jackson-South
1 week ago
5 changed files with 2340 additions and 328 deletions
File diff suppressed because it is too large
@ -1,321 +0,0 @@ |
|||||
// Copyright (c) Six Labors.
|
|
||||
// Licensed under the Six Labors Split License.
|
|
||||
|
|
||||
namespace SixLabors.ImageSharp.Formats.Heif.Av1.Pipeline.Cdef; |
|
||||
|
|
||||
/// <summary>
|
|
||||
/// Provides the scalar constrained directional enhancement filter operations defined by AV1.
|
|
||||
/// </summary>
|
|
||||
internal static class Av1CdefKernels |
|
||||
{ |
|
||||
/// <summary>
|
|
||||
/// The sample value used for neighbors outside the coded frame.
|
|
||||
/// </summary>
|
|
||||
public const ushort VeryLarge = 0x4000; |
|
||||
|
|
||||
/// <summary>
|
|
||||
/// The horizontal offsets for the nearest primary or secondary taps in each direction.
|
|
||||
/// </summary>
|
|
||||
private static readonly int[] DirectionX1 = [1, 1, 1, 1, 1, 0, 0, 0]; |
|
||||
|
|
||||
/// <summary>
|
|
||||
/// The vertical offsets for the nearest primary or secondary taps in each direction.
|
|
||||
/// </summary>
|
|
||||
private static readonly int[] DirectionY1 = [-1, 0, 0, 0, 1, 1, 1, 1]; |
|
||||
|
|
||||
/// <summary>
|
|
||||
/// The horizontal offsets for the furthest primary or secondary taps in each direction.
|
|
||||
/// </summary>
|
|
||||
private static readonly int[] DirectionX2 = [2, 2, 2, 2, 2, 1, 0, -1]; |
|
||||
|
|
||||
/// <summary>
|
|
||||
/// The vertical offsets for the furthest primary or secondary taps in each direction.
|
|
||||
/// </summary>
|
|
||||
private static readonly int[] DirectionY2 = [-2, -1, 0, 1, 2, 2, 2, 2]; |
|
||||
|
|
||||
/// <summary>
|
|
||||
/// The primary-tap weights selected by the parity of the unscaled primary strength.
|
|
||||
/// </summary>
|
|
||||
private static readonly int[,] PrimaryTaps = |
|
||||
{ |
|
||||
{ 4, 2 }, |
|
||||
{ 3, 3 } |
|
||||
}; |
|
||||
|
|
||||
/// <summary>
|
|
||||
/// The secondary-tap weights for the nearest and furthest samples.
|
|
||||
/// </summary>
|
|
||||
private static readonly int[] SecondaryTaps = [2, 1]; |
|
||||
|
|
||||
/// <summary>
|
|
||||
/// The common multiples used to compare line variance without division.
|
|
||||
/// </summary>
|
|
||||
private static readonly int[] DivisionTable = [0, 840, 420, 280, 210, 168, 140, 120, 105]; |
|
||||
|
|
||||
/// <summary>
|
|
||||
/// The direction mapping for horizontally subsampled, vertically full-resolution chroma.
|
|
||||
/// </summary>
|
|
||||
private static readonly int[] DirectionMap422 = [7, 0, 2, 4, 5, 6, 6, 6]; |
|
||||
|
|
||||
/// <summary>
|
|
||||
/// The direction mapping for horizontally full-resolution, vertically subsampled chroma.
|
|
||||
/// </summary>
|
|
||||
private static readonly int[] DirectionMap440 = [1, 2, 2, 2, 3, 4, 6, 0]; |
|
||||
|
|
||||
/// <summary>
|
|
||||
/// Finds the dominant direction of an 8x8 luma block and its directional variance.
|
|
||||
/// </summary>
|
|
||||
/// <param name="source">The bordered, deblocked source plane.</param>
|
|
||||
/// <param name="sourceOffset">The offset of the block's top-left sample.</param>
|
|
||||
/// <param name="sourceStride">The number of samples between adjacent source rows.</param>
|
|
||||
/// <param name="coefficientShift">The number of bits above the eight-bit analysis precision.</param>
|
|
||||
/// <param name="variance">Receives the variance difference between the selected and orthogonal directions.</param>
|
|
||||
/// <returns>The zero-based AV1 direction index.</returns>
|
|
||||
public static int FindDirection( |
|
||||
ReadOnlySpan<ushort> source, |
|
||||
int sourceOffset, |
|
||||
int sourceStride, |
|
||||
int coefficientShift, |
|
||||
out int variance) |
|
||||
{ |
|
||||
Span<int> partial = stackalloc int[8 * 15]; |
|
||||
Span<int> cost = stackalloc int[8]; |
|
||||
partial.Clear(); |
|
||||
cost.Clear(); |
|
||||
|
|
||||
for (int row = 0; row < 8; row++) |
|
||||
{ |
|
||||
for (int column = 0; column < 8; column++) |
|
||||
{ |
|
||||
// Direction analysis deliberately reduces every source to eight-bit precision so its
|
|
||||
// strength selection is identical for 8-, 10-, and 12-bit coded images.
|
|
||||
int value = (source[sourceOffset + (row * sourceStride) + column] >> coefficientShift) - 128; |
|
||||
partial[(0 * 15) + row + column] += value; |
|
||||
partial[(1 * 15) + row + (column / 2)] += value; |
|
||||
partial[(2 * 15) + row] += value; |
|
||||
partial[(3 * 15) + 3 + row - (column / 2)] += value; |
|
||||
partial[(4 * 15) + 7 + row - column] += value; |
|
||||
partial[(5 * 15) + 3 - (row / 2) + column] += value; |
|
||||
partial[(6 * 15) + column] += value; |
|
||||
partial[(7 * 15) + (row / 2) + column] += value; |
|
||||
} |
|
||||
} |
|
||||
|
|
||||
for (int i = 0; i < 8; i++) |
|
||||
{ |
|
||||
cost[2] += partial[(2 * 15) + i] * partial[(2 * 15) + i]; |
|
||||
cost[6] += partial[(6 * 15) + i] * partial[(6 * 15) + i]; |
|
||||
} |
|
||||
|
|
||||
cost[2] *= DivisionTable[8]; |
|
||||
cost[6] *= DivisionTable[8]; |
|
||||
for (int i = 0; i < 7; i++) |
|
||||
{ |
|
||||
cost[0] += ((partial[(0 * 15) + i] * partial[(0 * 15) + i]) + |
|
||||
(partial[(0 * 15) + 14 - i] * partial[(0 * 15) + 14 - i])) * DivisionTable[i + 1]; |
|
||||
cost[4] += ((partial[(4 * 15) + i] * partial[(4 * 15) + i]) + |
|
||||
(partial[(4 * 15) + 14 - i] * partial[(4 * 15) + 14 - i])) * DivisionTable[i + 1]; |
|
||||
} |
|
||||
|
|
||||
cost[0] += partial[(0 * 15) + 7] * partial[(0 * 15) + 7] * DivisionTable[8]; |
|
||||
cost[4] += partial[(4 * 15) + 7] * partial[(4 * 15) + 7] * DivisionTable[8]; |
|
||||
for (int direction = 1; direction < 8; direction += 2) |
|
||||
{ |
|
||||
for (int i = 0; i < 5; i++) |
|
||||
{ |
|
||||
cost[direction] += partial[(direction * 15) + 3 + i] * partial[(direction * 15) + 3 + i]; |
|
||||
} |
|
||||
|
|
||||
cost[direction] *= DivisionTable[8]; |
|
||||
for (int i = 0; i < 3; i++) |
|
||||
{ |
|
||||
cost[direction] += ((partial[(direction * 15) + i] * partial[(direction * 15) + i]) + |
|
||||
(partial[(direction * 15) + 10 - i] * partial[(direction * 15) + 10 - i])) * DivisionTable[(2 * i) + 2]; |
|
||||
} |
|
||||
} |
|
||||
|
|
||||
int bestCost = 0; |
|
||||
int bestDirection = 0; |
|
||||
for (int direction = 0; direction < 8; direction++) |
|
||||
{ |
|
||||
if (cost[direction] > bestCost) |
|
||||
{ |
|
||||
bestCost = cost[direction]; |
|
||||
bestDirection = direction; |
|
||||
} |
|
||||
} |
|
||||
|
|
||||
// Both costs omit the same sum-of-squares term. Their scaled difference is the
|
|
||||
// directional variance consumed by AV1's luma strength adjustment.
|
|
||||
variance = (bestCost - cost[(bestDirection + 4) & 7]) >> 10; |
|
||||
return bestDirection; |
|
||||
} |
|
||||
|
|
||||
/// <summary>
|
|
||||
/// Adjusts a luma primary strength according to the directional variance of its 8x8 block.
|
|
||||
/// </summary>
|
|
||||
/// <param name="strength">The bit-depth-scaled primary strength.</param>
|
|
||||
/// <param name="variance">The directional variance returned by <see cref="FindDirection"/>.</param>
|
|
||||
/// <returns>The variance-adjusted primary strength.</returns>
|
|
||||
public static int AdjustStrength(int strength, int variance) |
|
||||
{ |
|
||||
int varianceClass = variance >> 6; |
|
||||
int adjustment = varianceClass != 0 ? Math.Min(Av1Math.MostSignificantBit((uint)varianceClass), 12) : 0; |
|
||||
return variance != 0 ? ((strength * (4 + adjustment)) + 8) >> 4 : 0; |
|
||||
} |
|
||||
|
|
||||
/// <summary>
|
|
||||
/// Converts a luma direction to the matching chroma direction for asymmetric subsampling.
|
|
||||
/// </summary>
|
|
||||
/// <param name="direction">The zero-based luma direction index.</param>
|
|
||||
/// <param name="subsamplingX">The horizontal chroma subsampling shift.</param>
|
|
||||
/// <param name="subsamplingY">The vertical chroma subsampling shift.</param>
|
|
||||
/// <returns>The direction index in the chroma sample grid.</returns>
|
|
||||
public static int ConvertDirection(int direction, int subsamplingX, int subsamplingY) |
|
||||
{ |
|
||||
if (subsamplingX == subsamplingY) |
|
||||
{ |
|
||||
return direction; |
|
||||
} |
|
||||
|
|
||||
return subsamplingX != 0 ? DirectionMap422[direction] : DirectionMap440[direction]; |
|
||||
} |
|
||||
|
|
||||
/// <summary>
|
|
||||
/// Filters one luma or chroma block from an immutable bordered source plane.
|
|
||||
/// </summary>
|
|
||||
/// <param name="source">The bordered, deblocked source plane.</param>
|
|
||||
/// <param name="sourceOffset">The offset of the block's top-left source sample.</param>
|
|
||||
/// <param name="sourceStride">The number of samples between adjacent source rows.</param>
|
|
||||
/// <param name="destination">The unbordered filtered destination plane.</param>
|
|
||||
/// <param name="destinationOffset">The offset of the block's top-left destination sample.</param>
|
|
||||
/// <param name="destinationStride">The number of samples between adjacent destination rows.</param>
|
|
||||
/// <param name="primaryStrength">The bit-depth-scaled primary strength.</param>
|
|
||||
/// <param name="secondaryStrength">The bit-depth-scaled secondary strength.</param>
|
|
||||
/// <param name="direction">The zero-based AV1 direction index.</param>
|
|
||||
/// <param name="primaryDamping">The damping value applied to primary taps.</param>
|
|
||||
/// <param name="secondaryDamping">The damping value applied to secondary taps.</param>
|
|
||||
/// <param name="coefficientShift">The number of bits above eight-bit sample precision.</param>
|
|
||||
/// <param name="blockWidth">The block width in plane samples.</param>
|
|
||||
/// <param name="blockHeight">The block height in plane samples.</param>
|
|
||||
public static void FilterBlock( |
|
||||
ReadOnlySpan<ushort> source, |
|
||||
int sourceOffset, |
|
||||
int sourceStride, |
|
||||
Span<ushort> destination, |
|
||||
int destinationOffset, |
|
||||
int destinationStride, |
|
||||
int primaryStrength, |
|
||||
int secondaryStrength, |
|
||||
int direction, |
|
||||
int primaryDamping, |
|
||||
int secondaryDamping, |
|
||||
int coefficientShift, |
|
||||
int blockWidth, |
|
||||
int blockHeight) |
|
||||
{ |
|
||||
bool enablePrimary = primaryStrength != 0; |
|
||||
bool enableSecondary = secondaryStrength != 0; |
|
||||
bool clippingRequired = enablePrimary && enableSecondary; |
|
||||
int primaryTapSet = (primaryStrength >> coefficientShift) & 1; |
|
||||
|
|
||||
for (int row = 0; row < blockHeight; row++) |
|
||||
{ |
|
||||
for (int column = 0; column < blockWidth; column++) |
|
||||
{ |
|
||||
int sourceIndex = sourceOffset + (row * sourceStride) + column; |
|
||||
int sample = source[sourceIndex]; |
|
||||
int sum = 0; |
|
||||
int minimum = sample; |
|
||||
int maximum = sample; |
|
||||
|
|
||||
for (int tap = 0; tap < 2; tap++) |
|
||||
{ |
|
||||
if (enablePrimary) |
|
||||
{ |
|
||||
int primaryDirectionOffset = GetDirectionOffset(direction, tap, sourceStride); |
|
||||
int neighbor0 = source[sourceIndex + primaryDirectionOffset]; |
|
||||
int neighbor1 = source[sourceIndex - primaryDirectionOffset]; |
|
||||
int weight = PrimaryTaps[primaryTapSet, tap]; |
|
||||
sum += weight * Constrain(neighbor0 - sample, primaryStrength, primaryDamping); |
|
||||
sum += weight * Constrain(neighbor1 - sample, primaryStrength, primaryDamping); |
|
||||
|
|
||||
if (clippingRequired) |
|
||||
{ |
|
||||
maximum = neighbor0 != VeryLarge ? Math.Max(maximum, neighbor0) : maximum; |
|
||||
maximum = neighbor1 != VeryLarge ? Math.Max(maximum, neighbor1) : maximum; |
|
||||
minimum = Math.Min(minimum, neighbor0); |
|
||||
minimum = Math.Min(minimum, neighbor1); |
|
||||
} |
|
||||
} |
|
||||
|
|
||||
if (enableSecondary) |
|
||||
{ |
|
||||
int secondaryDirection0 = GetDirectionOffset((direction + 2) & 7, tap, sourceStride); |
|
||||
int secondaryDirection1 = GetDirectionOffset((direction + 6) & 7, tap, sourceStride); |
|
||||
int neighbor0 = source[sourceIndex + secondaryDirection0]; |
|
||||
int neighbor1 = source[sourceIndex - secondaryDirection0]; |
|
||||
int neighbor2 = source[sourceIndex + secondaryDirection1]; |
|
||||
int neighbor3 = source[sourceIndex - secondaryDirection1]; |
|
||||
int weight = SecondaryTaps[tap]; |
|
||||
|
|
||||
if (clippingRequired) |
|
||||
{ |
|
||||
maximum = neighbor0 != VeryLarge ? Math.Max(maximum, neighbor0) : maximum; |
|
||||
maximum = neighbor1 != VeryLarge ? Math.Max(maximum, neighbor1) : maximum; |
|
||||
maximum = neighbor2 != VeryLarge ? Math.Max(maximum, neighbor2) : maximum; |
|
||||
maximum = neighbor3 != VeryLarge ? Math.Max(maximum, neighbor3) : maximum; |
|
||||
minimum = Math.Min(minimum, neighbor0); |
|
||||
minimum = Math.Min(minimum, neighbor1); |
|
||||
minimum = Math.Min(minimum, neighbor2); |
|
||||
minimum = Math.Min(minimum, neighbor3); |
|
||||
} |
|
||||
|
|
||||
sum += weight * Constrain(neighbor0 - sample, secondaryStrength, secondaryDamping); |
|
||||
sum += weight * Constrain(neighbor1 - sample, secondaryStrength, secondaryDamping); |
|
||||
sum += weight * Constrain(neighbor2 - sample, secondaryStrength, secondaryDamping); |
|
||||
sum += weight * Constrain(neighbor3 - sample, secondaryStrength, secondaryDamping); |
|
||||
} |
|
||||
} |
|
||||
|
|
||||
// The negative-sum correction preserves AV1's asymmetric signed rounding exactly.
|
|
||||
int filtered = sample + ((8 + sum - (sum < 0 ? 1 : 0)) >> 4); |
|
||||
destination[destinationOffset + (row * destinationStride) + column] = |
|
||||
(ushort)(clippingRequired ? Av1Math.Clip3(minimum, maximum, filtered) : filtered); |
|
||||
} |
|
||||
} |
|
||||
} |
|
||||
|
|
||||
/// <summary>
|
|
||||
/// Converts a direction and tap number to a signed plane-buffer offset.
|
|
||||
/// </summary>
|
|
||||
/// <param name="direction">The zero-based AV1 direction index.</param>
|
|
||||
/// <param name="tap">The zero-based distance index.</param>
|
|
||||
/// <param name="stride">The number of samples between adjacent rows.</param>
|
|
||||
/// <returns>The signed sample offset.</returns>
|
|
||||
private static int GetDirectionOffset(int direction, int tap, int stride) |
|
||||
=> tap == 0 |
|
||||
? (DirectionY1[direction] * stride) + DirectionX1[direction] |
|
||||
: (DirectionY2[direction] * stride) + DirectionX2[direction]; |
|
||||
|
|
||||
/// <summary>
|
|
||||
/// Limits a neighbor difference according to a filter strength and damping value.
|
|
||||
/// </summary>
|
|
||||
/// <param name="difference">The signed difference from the current sample.</param>
|
|
||||
/// <param name="threshold">The bit-depth-scaled filter strength.</param>
|
|
||||
/// <param name="damping">The damping value.</param>
|
|
||||
/// <returns>The signed constrained difference.</returns>
|
|
||||
private static int Constrain(int difference, int threshold, int damping) |
|
||||
{ |
|
||||
if (threshold == 0) |
|
||||
{ |
|
||||
return 0; |
|
||||
} |
|
||||
|
|
||||
// Stronger thresholds reduce the effective damping shift, matching the AV1 constrain function.
|
|
||||
int shift = Math.Max(0, damping - Av1Math.MostSignificantBit((uint)threshold)); |
|
||||
int magnitude = Math.Abs(difference); |
|
||||
int constrained = Av1Math.Clip3(0, magnitude, threshold - (magnitude >> shift)); |
|
||||
return difference < 0 ? -constrained : constrained; |
|
||||
} |
|
||||
} |
|
||||
@ -0,0 +1,627 @@ |
|||||
|
// Copyright (c) Six Labors.
|
||||
|
// Licensed under the Six Labors Split License.
|
||||
|
|
||||
|
using System.Numerics; |
||||
|
using SixLabors.ImageSharp.Formats.Heif.Av1.Pipeline.Cdef; |
||||
|
using SixLabors.ImageSharp.Tests.TestUtilities; |
||||
|
|
||||
|
namespace SixLabors.ImageSharp.Tests.Formats.Heif.Av1; |
||||
|
|
||||
|
/// <summary>
|
||||
|
/// Verifies AV1 constrained directional enhancement filtering across sample precision, block geometry, and intrinsic tiers.
|
||||
|
/// </summary>
|
||||
|
[Trait("Format", "Avif")] |
||||
|
public class Av1CdefFilterTests |
||||
|
{ |
||||
|
/// <summary>
|
||||
|
/// The hardware configurations required to exercise packed filtering and the scalar fallback.
|
||||
|
/// </summary>
|
||||
|
private const HwIntrinsics Configurations = HwIntrinsics.AllowAll | HwIntrinsics.DisableHWIntrinsic; |
||||
|
|
||||
|
/// <summary>
|
||||
|
/// The row stride of the bordered source plane used by the filter tests.
|
||||
|
/// </summary>
|
||||
|
private const int SourceStride = 16; |
||||
|
|
||||
|
/// <summary>
|
||||
|
/// The number of unavailable samples surrounding the test image.
|
||||
|
/// </summary>
|
||||
|
private const int SourceBorder = 2; |
||||
|
|
||||
|
/// <summary>
|
||||
|
/// Verifies direction selection and variance against an independent scalar definition.
|
||||
|
/// </summary>
|
||||
|
[Fact] |
||||
|
public void FindDirectionMatchesIndependentDefinitionAcrossIntrinsicTiers() |
||||
|
=> FeatureTestRunner.RunWithHwIntrinsicsFeature(ValidateDirections, Configurations); |
||||
|
|
||||
|
/// <summary>
|
||||
|
/// Verifies every CDEF block geometry and strength mode against an independent scalar definition.
|
||||
|
/// </summary>
|
||||
|
[Fact] |
||||
|
public void FilterBlockMatchesIndependentDefinitionAcrossIntrinsicTiers() |
||||
|
=> FeatureTestRunner.RunWithHwIntrinsicsFeature(ValidateFilters, Configurations); |
||||
|
|
||||
|
/// <summary>
|
||||
|
/// Verifies the complete asymmetric chroma direction mappings and the unchanged symmetric mappings.
|
||||
|
/// </summary>
|
||||
|
[Fact] |
||||
|
public void ConvertDirectionMatchesSubsamplingGeometry() |
||||
|
{ |
||||
|
int[] horizontalSubsampling = [7, 0, 2, 4, 5, 6, 6, 6]; |
||||
|
int[] verticalSubsampling = [1, 2, 2, 2, 3, 4, 6, 0]; |
||||
|
for (int direction = 0; direction < 8; direction++) |
||||
|
{ |
||||
|
Assert.Equal(horizontalSubsampling[direction], Av1CdefFilter.ConvertDirection(direction, 1, 0)); |
||||
|
Assert.Equal(verticalSubsampling[direction], Av1CdefFilter.ConvertDirection(direction, 0, 1)); |
||||
|
Assert.Equal(direction, Av1CdefFilter.ConvertDirection(direction, 0, 0)); |
||||
|
Assert.Equal(direction, Av1CdefFilter.ConvertDirection(direction, 1, 1)); |
||||
|
} |
||||
|
} |
||||
|
|
||||
|
/// <summary>
|
||||
|
/// Verifies luma strength adjustment at zero, logarithmic-class boundaries, and the capped variance class.
|
||||
|
/// </summary>
|
||||
|
[Fact] |
||||
|
public void AdjustStrengthMatchesIndependentDefinition() |
||||
|
{ |
||||
|
foreach (int strength in new[] { 0, 4, 15, 60 }) |
||||
|
{ |
||||
|
foreach (int variance in new[] { 0, 1, 63, 64, 255, 4096, 1 << 20 }) |
||||
|
{ |
||||
|
int varianceClass = variance >> 6; |
||||
|
int adjustment = varianceClass == 0 ? 0 : Math.Min(BitOperations.Log2((uint)varianceClass), 12); |
||||
|
int expected = variance == 0 ? 0 : ((strength * (4 + adjustment)) + 8) >> 4; |
||||
|
Assert.Equal(expected, Av1CdefFilter.AdjustStrength(strength, variance)); |
||||
|
} |
||||
|
} |
||||
|
} |
||||
|
|
||||
|
/// <summary>
|
||||
|
/// Verifies that the deterministic direction corpus exercises every selected-direction branch.
|
||||
|
/// </summary>
|
||||
|
[Fact] |
||||
|
public void DirectionCorpusCoversEveryDirection() |
||||
|
{ |
||||
|
const int stride = 32; |
||||
|
const int sourceOffset = (4 * stride) + 5; |
||||
|
int secondSourceOffset = sourceOffset + 8; |
||||
|
HashSet<int> observedDirections = []; |
||||
|
for (int pattern = 0; pattern < 8; pattern++) |
||||
|
{ |
||||
|
ushort[] source = new ushort[stride * 16]; |
||||
|
PopulateDirectionSource(source, sourceOffset, stride, pattern, 8); |
||||
|
observedDirections.Add(FindDirectionReference(source, sourceOffset, stride, 0, out _)); |
||||
|
observedDirections.Add(FindDirectionReference(source, secondSourceOffset, stride, 0, out _)); |
||||
|
} |
||||
|
|
||||
|
Assert.Equal(Enumerable.Range(0, 8), observedDirections.Order()); |
||||
|
} |
||||
|
|
||||
|
/// <summary>
|
||||
|
/// Exercises direction search with multiple source patterns at every supported sample precision.
|
||||
|
/// </summary>
|
||||
|
private static void ValidateDirections() |
||||
|
{ |
||||
|
const int stride = 32; |
||||
|
const int sourceOffset = (4 * stride) + 5; |
||||
|
|
||||
|
foreach (int bitDepth in new[] { 8, 10, 12 }) |
||||
|
{ |
||||
|
int coefficientShift = bitDepth - 8; |
||||
|
for (int pattern = 0; pattern < 8; pattern++) |
||||
|
{ |
||||
|
ushort[] source = new ushort[stride * 16]; |
||||
|
int secondSourceOffset = sourceOffset + 8; |
||||
|
PopulateDirectionSource(source, sourceOffset, stride, pattern, bitDepth); |
||||
|
|
||||
|
int expectedDirection = FindDirectionReference(source, sourceOffset, stride, coefficientShift, out int expectedVariance); |
||||
|
int actualDirection = Av1CdefFilter.FindDirection(source, sourceOffset, stride, coefficientShift, out int actualVariance); |
||||
|
Assert.Equal(expectedDirection, actualDirection); |
||||
|
Assert.Equal(expectedVariance, actualVariance); |
||||
|
|
||||
|
int secondExpectedDirection = FindDirectionReference(source, secondSourceOffset, stride, coefficientShift, out int secondExpectedVariance); |
||||
|
Av1CdefFilter.FindDirections( |
||||
|
source, |
||||
|
sourceOffset, |
||||
|
secondSourceOffset, |
||||
|
stride, |
||||
|
coefficientShift, |
||||
|
out int firstActualDirection, |
||||
|
out int firstActualVariance, |
||||
|
out int secondActualDirection, |
||||
|
out int secondActualVariance); |
||||
|
|
||||
|
Assert.Equal(expectedDirection, firstActualDirection); |
||||
|
Assert.Equal(expectedVariance, firstActualVariance); |
||||
|
Assert.Equal(secondExpectedDirection, secondActualDirection); |
||||
|
Assert.Equal(secondExpectedVariance, secondActualVariance); |
||||
|
} |
||||
|
} |
||||
|
} |
||||
|
|
||||
|
/// <summary>
|
||||
|
/// Populates two adjacent 8x8 blocks with deterministic directional samples.
|
||||
|
/// </summary>
|
||||
|
/// <param name="source">The destination source plane.</param>
|
||||
|
/// <param name="sourceOffset">The first populated sample.</param>
|
||||
|
/// <param name="sourceStride">The source row stride.</param>
|
||||
|
/// <param name="pattern">The deterministic pattern index.</param>
|
||||
|
/// <param name="bitDepth">The sample precision.</param>
|
||||
|
private static void PopulateDirectionSource(Span<ushort> source, int sourceOffset, int sourceStride, int pattern, int bitDepth) |
||||
|
{ |
||||
|
int coefficientShift = bitDepth - 8; |
||||
|
int maximum = (1 << bitDepth) - 1; |
||||
|
for (int row = 0; row < 8; row++) |
||||
|
{ |
||||
|
for (int column = 0; column < 16; column++) |
||||
|
{ |
||||
|
int localColumn = column & 7; |
||||
|
int direction = column < 8 ? pattern : (pattern + 4) & 7; |
||||
|
int line = GetDirectionLineReference(direction, row, localColumn); |
||||
|
|
||||
|
// Samples are constant along the requested geometric line and vary between lines. Direction search
|
||||
|
// therefore minimizes reconstruction error in that direction while still exercising nonuniform values.
|
||||
|
int value = (24 + (line * 14)) << coefficientShift; |
||||
|
source[sourceOffset + (row * sourceStride) + column] = (ushort)(value & maximum); |
||||
|
} |
||||
|
} |
||||
|
} |
||||
|
|
||||
|
/// <summary>
|
||||
|
/// Maps one source coordinate to its line in an AV1 direction independently of the production implementation.
|
||||
|
/// </summary>
|
||||
|
/// <param name="direction">The zero-based AV1 direction index.</param>
|
||||
|
/// <param name="row">The source row.</param>
|
||||
|
/// <param name="column">The source column.</param>
|
||||
|
/// <returns>The zero-based line index.</returns>
|
||||
|
private static int GetDirectionLineReference(int direction, int row, int column) => direction switch |
||||
|
{ |
||||
|
0 => row + column, |
||||
|
1 => row + (column / 2), |
||||
|
2 => row, |
||||
|
3 => 3 + row - (column / 2), |
||||
|
4 => 7 + row - column, |
||||
|
5 => 3 - (row / 2) + column, |
||||
|
6 => column, |
||||
|
_ => (row / 2) + column |
||||
|
}; |
||||
|
|
||||
|
/// <summary>
|
||||
|
/// Exercises all normative block dimensions, directions, strength combinations, output types, and coded precisions.
|
||||
|
/// </summary>
|
||||
|
private static void ValidateFilters() |
||||
|
{ |
||||
|
(int Width, int Height)[] dimensions = [(4, 4), (4, 8), (8, 4), (8, 8)]; |
||||
|
foreach (int bitDepth in new[] { 8, 10, 12 }) |
||||
|
{ |
||||
|
int coefficientShift = bitDepth - 8; |
||||
|
int scale = 1 << coefficientShift; |
||||
|
ushort[] source = CreateBorderedSource(bitDepth); |
||||
|
int sourceOffset = (SourceBorder * SourceStride) + SourceBorder; |
||||
|
(int Primary, int Secondary)[] strengths = [(0, 0), (4 * scale, 0), (0, 2 * scale), (5 * scale, 2 * scale)]; |
||||
|
|
||||
|
foreach ((int blockWidth, int blockHeight) in dimensions) |
||||
|
{ |
||||
|
foreach (int direction in Enumerable.Range(0, 8)) |
||||
|
{ |
||||
|
foreach ((int primaryStrength, int secondaryStrength) in strengths) |
||||
|
{ |
||||
|
if (bitDepth == 8) |
||||
|
{ |
||||
|
AssertByteFilter( |
||||
|
source, |
||||
|
sourceOffset, |
||||
|
blockWidth, |
||||
|
blockHeight, |
||||
|
primaryStrength, |
||||
|
secondaryStrength, |
||||
|
direction, |
||||
|
coefficientShift); |
||||
|
} |
||||
|
|
||||
|
AssertUInt16Filter( |
||||
|
source, |
||||
|
sourceOffset, |
||||
|
blockWidth, |
||||
|
blockHeight, |
||||
|
primaryStrength, |
||||
|
secondaryStrength, |
||||
|
direction, |
||||
|
coefficientShift); |
||||
|
} |
||||
|
} |
||||
|
} |
||||
|
} |
||||
|
} |
||||
|
|
||||
|
/// <summary>
|
||||
|
/// Creates a deterministic image whose top-left output block touches the unavailable-neighbor border.
|
||||
|
/// </summary>
|
||||
|
/// <param name="bitDepth">The source sample precision.</param>
|
||||
|
/// <returns>The bordered 16-bit source plane.</returns>
|
||||
|
private static ushort[] CreateBorderedSource(int bitDepth) |
||||
|
{ |
||||
|
ushort[] source = Enumerable.Repeat(Av1CdefFilter.VeryLarge, SourceStride * SourceStride).ToArray(); |
||||
|
int maximum = (1 << bitDepth) - 1; |
||||
|
int scale = 1 << (bitDepth - 8); |
||||
|
for (int row = SourceBorder; row < SourceStride - SourceBorder; row++) |
||||
|
{ |
||||
|
for (int column = SourceBorder; column < SourceStride - SourceBorder; column++) |
||||
|
{ |
||||
|
int localRow = row - SourceBorder; |
||||
|
int localColumn = column - SourceBorder; |
||||
|
int value = (72 + (localRow * 9) + (localColumn * 5) + ((localRow * localColumn) & 15)) * scale; |
||||
|
source[(row * SourceStride) + column] = (ushort)Math.Min(value, maximum); |
||||
|
} |
||||
|
} |
||||
|
|
||||
|
return source; |
||||
|
} |
||||
|
|
||||
|
/// <summary>
|
||||
|
/// Verifies one eight-bit output block while retaining untouched destination padding in the comparison.
|
||||
|
/// </summary>
|
||||
|
/// <param name="source">The bordered source plane.</param>
|
||||
|
/// <param name="sourceOffset">The first source sample in the block.</param>
|
||||
|
/// <param name="blockWidth">The output block width.</param>
|
||||
|
/// <param name="blockHeight">The output block height.</param>
|
||||
|
/// <param name="primaryStrength">The primary filter strength.</param>
|
||||
|
/// <param name="secondaryStrength">The secondary filter strength.</param>
|
||||
|
/// <param name="direction">The primary filter direction.</param>
|
||||
|
/// <param name="coefficientShift">The source precision shift.</param>
|
||||
|
private static void AssertByteFilter( |
||||
|
ushort[] source, |
||||
|
int sourceOffset, |
||||
|
int blockWidth, |
||||
|
int blockHeight, |
||||
|
int primaryStrength, |
||||
|
int secondaryStrength, |
||||
|
int direction, |
||||
|
int coefficientShift) |
||||
|
{ |
||||
|
const int destinationStride = 12; |
||||
|
const int destinationOffset = destinationStride + 1; |
||||
|
byte[] expected = Enumerable.Repeat((byte)231, destinationStride * 10).ToArray(); |
||||
|
byte[] actual = (byte[])expected.Clone(); |
||||
|
int damping = 5 + coefficientShift; |
||||
|
|
||||
|
FilterReference( |
||||
|
source, |
||||
|
sourceOffset, |
||||
|
SourceStride, |
||||
|
expected, |
||||
|
destinationOffset, |
||||
|
destinationStride, |
||||
|
primaryStrength, |
||||
|
secondaryStrength, |
||||
|
direction, |
||||
|
damping, |
||||
|
coefficientShift, |
||||
|
blockWidth, |
||||
|
blockHeight); |
||||
|
|
||||
|
Av1CdefFilter.FilterBlock( |
||||
|
source, |
||||
|
sourceOffset, |
||||
|
SourceStride, |
||||
|
actual, |
||||
|
destinationOffset, |
||||
|
destinationStride, |
||||
|
primaryStrength, |
||||
|
secondaryStrength, |
||||
|
direction, |
||||
|
damping, |
||||
|
damping, |
||||
|
coefficientShift, |
||||
|
blockWidth, |
||||
|
blockHeight); |
||||
|
|
||||
|
Assert.Equal(expected, actual); |
||||
|
} |
||||
|
|
||||
|
/// <summary>
|
||||
|
/// Verifies one 16-bit output block while retaining untouched destination padding in the comparison.
|
||||
|
/// </summary>
|
||||
|
/// <param name="source">The bordered source plane.</param>
|
||||
|
/// <param name="sourceOffset">The first source sample in the block.</param>
|
||||
|
/// <param name="blockWidth">The output block width.</param>
|
||||
|
/// <param name="blockHeight">The output block height.</param>
|
||||
|
/// <param name="primaryStrength">The primary filter strength.</param>
|
||||
|
/// <param name="secondaryStrength">The secondary filter strength.</param>
|
||||
|
/// <param name="direction">The primary filter direction.</param>
|
||||
|
/// <param name="coefficientShift">The source precision shift.</param>
|
||||
|
private static void AssertUInt16Filter( |
||||
|
ushort[] source, |
||||
|
int sourceOffset, |
||||
|
int blockWidth, |
||||
|
int blockHeight, |
||||
|
int primaryStrength, |
||||
|
int secondaryStrength, |
||||
|
int direction, |
||||
|
int coefficientShift) |
||||
|
{ |
||||
|
const int destinationStride = 12; |
||||
|
const int destinationOffset = destinationStride + 1; |
||||
|
ushort[] expected = Enumerable.Repeat((ushort)60000, destinationStride * 10).ToArray(); |
||||
|
ushort[] actual = (ushort[])expected.Clone(); |
||||
|
int damping = 5 + coefficientShift; |
||||
|
|
||||
|
FilterReference( |
||||
|
source, |
||||
|
sourceOffset, |
||||
|
SourceStride, |
||||
|
expected, |
||||
|
destinationOffset, |
||||
|
destinationStride, |
||||
|
primaryStrength, |
||||
|
secondaryStrength, |
||||
|
direction, |
||||
|
damping, |
||||
|
coefficientShift, |
||||
|
blockWidth, |
||||
|
blockHeight); |
||||
|
|
||||
|
Av1CdefFilter.FilterBlock( |
||||
|
source, |
||||
|
sourceOffset, |
||||
|
SourceStride, |
||||
|
actual, |
||||
|
destinationOffset, |
||||
|
destinationStride, |
||||
|
primaryStrength, |
||||
|
secondaryStrength, |
||||
|
direction, |
||||
|
damping, |
||||
|
damping, |
||||
|
coefficientShift, |
||||
|
blockWidth, |
||||
|
blockHeight); |
||||
|
|
||||
|
Assert.Equal(expected, actual); |
||||
|
} |
||||
|
|
||||
|
/// <summary>
|
||||
|
/// Finds one direction and variance using the scalar AV1 definition independently of the production layouts.
|
||||
|
/// </summary>
|
||||
|
/// <param name="source">The source plane.</param>
|
||||
|
/// <param name="sourceOffset">The first sample in the 8x8 block.</param>
|
||||
|
/// <param name="sourceStride">The source row stride.</param>
|
||||
|
/// <param name="coefficientShift">The source precision shift.</param>
|
||||
|
/// <param name="variance">Receives the directional variance.</param>
|
||||
|
/// <returns>The selected direction.</returns>
|
||||
|
private static int FindDirectionReference( |
||||
|
ReadOnlySpan<ushort> source, |
||||
|
int sourceOffset, |
||||
|
int sourceStride, |
||||
|
int coefficientShift, |
||||
|
out int variance) |
||||
|
{ |
||||
|
int[,] partials = new int[8, 15]; |
||||
|
int[] costs = new int[8]; |
||||
|
int[] divisions = [0, 840, 420, 280, 210, 168, 140, 120, 105]; |
||||
|
for (int row = 0; row < 8; row++) |
||||
|
{ |
||||
|
for (int column = 0; column < 8; column++) |
||||
|
{ |
||||
|
int value = (source[sourceOffset + (row * sourceStride) + column] >> coefficientShift) - 128; |
||||
|
partials[0, row + column] += value; |
||||
|
partials[1, row + (column / 2)] += value; |
||||
|
partials[2, row] += value; |
||||
|
partials[3, 3 + row - (column / 2)] += value; |
||||
|
partials[4, 7 + row - column] += value; |
||||
|
partials[5, 3 - (row / 2) + column] += value; |
||||
|
partials[6, column] += value; |
||||
|
partials[7, (row / 2) + column] += value; |
||||
|
} |
||||
|
} |
||||
|
|
||||
|
for (int line = 0; line < 8; line++) |
||||
|
{ |
||||
|
costs[2] += partials[2, line] * partials[2, line]; |
||||
|
costs[6] += partials[6, line] * partials[6, line]; |
||||
|
} |
||||
|
|
||||
|
costs[2] *= divisions[8]; |
||||
|
costs[6] *= divisions[8]; |
||||
|
for (int line = 0; line < 7; line++) |
||||
|
{ |
||||
|
costs[0] += ((partials[0, line] * partials[0, line]) + (partials[0, 14 - line] * partials[0, 14 - line])) * divisions[line + 1]; |
||||
|
costs[4] += ((partials[4, line] * partials[4, line]) + (partials[4, 14 - line] * partials[4, 14 - line])) * divisions[line + 1]; |
||||
|
} |
||||
|
|
||||
|
costs[0] += partials[0, 7] * partials[0, 7] * divisions[8]; |
||||
|
costs[4] += partials[4, 7] * partials[4, 7] * divisions[8]; |
||||
|
for (int direction = 1; direction < 8; direction += 2) |
||||
|
{ |
||||
|
for (int line = 0; line < 5; line++) |
||||
|
{ |
||||
|
costs[direction] += partials[direction, 3 + line] * partials[direction, 3 + line]; |
||||
|
} |
||||
|
|
||||
|
costs[direction] *= divisions[8]; |
||||
|
for (int line = 0; line < 3; line++) |
||||
|
{ |
||||
|
costs[direction] += ((partials[direction, line] * partials[direction, line]) |
||||
|
+ (partials[direction, 10 - line] * partials[direction, 10 - line])) * divisions[(2 * line) + 2]; |
||||
|
} |
||||
|
} |
||||
|
|
||||
|
int bestCost = 0; |
||||
|
int bestDirection = 0; |
||||
|
for (int direction = 0; direction < 8; direction++) |
||||
|
{ |
||||
|
if (costs[direction] > bestCost) |
||||
|
{ |
||||
|
bestCost = costs[direction]; |
||||
|
bestDirection = direction; |
||||
|
} |
||||
|
} |
||||
|
|
||||
|
variance = (bestCost - costs[(bestDirection + 4) & 7]) >> 10; |
||||
|
return bestDirection; |
||||
|
} |
||||
|
|
||||
|
/// <summary>
|
||||
|
/// Applies the independent scalar filter definition to eight-bit output storage.
|
||||
|
/// </summary>
|
||||
|
private static void FilterReference( |
||||
|
ReadOnlySpan<ushort> source, |
||||
|
int sourceOffset, |
||||
|
int sourceStride, |
||||
|
Span<byte> destination, |
||||
|
int destinationOffset, |
||||
|
int destinationStride, |
||||
|
int primaryStrength, |
||||
|
int secondaryStrength, |
||||
|
int direction, |
||||
|
int damping, |
||||
|
int coefficientShift, |
||||
|
int blockWidth, |
||||
|
int blockHeight) |
||||
|
{ |
||||
|
for (int row = 0; row < blockHeight; row++) |
||||
|
{ |
||||
|
for (int column = 0; column < blockWidth; column++) |
||||
|
{ |
||||
|
destination[destinationOffset + (row * destinationStride) + column] = (byte)FilterSampleReference( |
||||
|
source, |
||||
|
sourceOffset + (row * sourceStride) + column, |
||||
|
sourceStride, |
||||
|
primaryStrength, |
||||
|
secondaryStrength, |
||||
|
direction, |
||||
|
damping, |
||||
|
coefficientShift); |
||||
|
} |
||||
|
} |
||||
|
} |
||||
|
|
||||
|
/// <summary>
|
||||
|
/// Applies the independent scalar filter definition to 16-bit output storage.
|
||||
|
/// </summary>
|
||||
|
private static void FilterReference( |
||||
|
ReadOnlySpan<ushort> source, |
||||
|
int sourceOffset, |
||||
|
int sourceStride, |
||||
|
Span<ushort> destination, |
||||
|
int destinationOffset, |
||||
|
int destinationStride, |
||||
|
int primaryStrength, |
||||
|
int secondaryStrength, |
||||
|
int direction, |
||||
|
int damping, |
||||
|
int coefficientShift, |
||||
|
int blockWidth, |
||||
|
int blockHeight) |
||||
|
{ |
||||
|
for (int row = 0; row < blockHeight; row++) |
||||
|
{ |
||||
|
for (int column = 0; column < blockWidth; column++) |
||||
|
{ |
||||
|
destination[destinationOffset + (row * destinationStride) + column] = (ushort)FilterSampleReference( |
||||
|
source, |
||||
|
sourceOffset + (row * sourceStride) + column, |
||||
|
sourceStride, |
||||
|
primaryStrength, |
||||
|
secondaryStrength, |
||||
|
direction, |
||||
|
damping, |
||||
|
coefficientShift); |
||||
|
} |
||||
|
} |
||||
|
} |
||||
|
|
||||
|
/// <summary>
|
||||
|
/// Computes one independently filtered sample from its primary and secondary neighbors.
|
||||
|
/// </summary>
|
||||
|
private static int FilterSampleReference( |
||||
|
ReadOnlySpan<ushort> source, |
||||
|
int sourceIndex, |
||||
|
int sourceStride, |
||||
|
int primaryStrength, |
||||
|
int secondaryStrength, |
||||
|
int direction, |
||||
|
int damping, |
||||
|
int coefficientShift) |
||||
|
{ |
||||
|
bool enablePrimary = primaryStrength != 0; |
||||
|
bool enableSecondary = secondaryStrength != 0; |
||||
|
bool clippingRequired = enablePrimary && enableSecondary; |
||||
|
int primaryTapSet = (primaryStrength >> coefficientShift) & 1; |
||||
|
int sample = source[sourceIndex]; |
||||
|
int sum = 0; |
||||
|
int minimum = sample; |
||||
|
int maximum = sample; |
||||
|
|
||||
|
for (int tap = 0; tap < 2; tap++) |
||||
|
{ |
||||
|
if (enablePrimary) |
||||
|
{ |
||||
|
int offset = GetDirectionOffsetReference(direction, tap, sourceStride); |
||||
|
int neighbor0 = source[sourceIndex + offset]; |
||||
|
int neighbor1 = source[sourceIndex - offset]; |
||||
|
int weight = primaryTapSet == 0 ? (tap == 0 ? 4 : 2) : 3; |
||||
|
sum += weight * ConstrainReference(neighbor0 - sample, primaryStrength, damping); |
||||
|
sum += weight * ConstrainReference(neighbor1 - sample, primaryStrength, damping); |
||||
|
|
||||
|
if (clippingRequired) |
||||
|
{ |
||||
|
maximum = neighbor0 != Av1CdefFilter.VeryLarge ? Math.Max(maximum, neighbor0) : maximum; |
||||
|
maximum = neighbor1 != Av1CdefFilter.VeryLarge ? Math.Max(maximum, neighbor1) : maximum; |
||||
|
minimum = Math.Min(minimum, Math.Min(neighbor0, neighbor1)); |
||||
|
} |
||||
|
} |
||||
|
|
||||
|
if (enableSecondary) |
||||
|
{ |
||||
|
int offset0 = GetDirectionOffsetReference((direction + 2) & 7, tap, sourceStride); |
||||
|
int offset1 = GetDirectionOffsetReference((direction + 6) & 7, tap, sourceStride); |
||||
|
int neighbor0 = source[sourceIndex + offset0]; |
||||
|
int neighbor1 = source[sourceIndex - offset0]; |
||||
|
int neighbor2 = source[sourceIndex + offset1]; |
||||
|
int neighbor3 = source[sourceIndex - offset1]; |
||||
|
int weight = tap == 0 ? 2 : 1; |
||||
|
sum += weight * ConstrainReference(neighbor0 - sample, secondaryStrength, damping); |
||||
|
sum += weight * ConstrainReference(neighbor1 - sample, secondaryStrength, damping); |
||||
|
sum += weight * ConstrainReference(neighbor2 - sample, secondaryStrength, damping); |
||||
|
sum += weight * ConstrainReference(neighbor3 - sample, secondaryStrength, damping); |
||||
|
|
||||
|
if (clippingRequired) |
||||
|
{ |
||||
|
maximum = neighbor0 != Av1CdefFilter.VeryLarge ? Math.Max(maximum, neighbor0) : maximum; |
||||
|
maximum = neighbor1 != Av1CdefFilter.VeryLarge ? Math.Max(maximum, neighbor1) : maximum; |
||||
|
maximum = neighbor2 != Av1CdefFilter.VeryLarge ? Math.Max(maximum, neighbor2) : maximum; |
||||
|
maximum = neighbor3 != Av1CdefFilter.VeryLarge ? Math.Max(maximum, neighbor3) : maximum; |
||||
|
minimum = Math.Min(minimum, Math.Min(Math.Min(neighbor0, neighbor1), Math.Min(neighbor2, neighbor3))); |
||||
|
} |
||||
|
} |
||||
|
} |
||||
|
|
||||
|
int filtered = sample + ((8 + sum - (sum < 0 ? 1 : 0)) >> 4); |
||||
|
return clippingRequired ? Math.Clamp(filtered, minimum, maximum) : filtered; |
||||
|
} |
||||
|
|
||||
|
/// <summary>
|
||||
|
/// Applies the scalar AV1 constrain equation independently of the production implementation.
|
||||
|
/// </summary>
|
||||
|
private static int ConstrainReference(int difference, int threshold, int damping) |
||||
|
{ |
||||
|
int shift = Math.Max(0, damping - BitOperations.Log2((uint)threshold)); |
||||
|
int magnitude = Math.Abs(difference); |
||||
|
int constrained = Math.Clamp(threshold - (magnitude >> shift), 0, magnitude); |
||||
|
return difference < 0 ? -constrained : constrained; |
||||
|
} |
||||
|
|
||||
|
/// <summary>
|
||||
|
/// Converts a direction and tap to a signed source offset independently of the production implementation.
|
||||
|
/// </summary>
|
||||
|
private static int GetDirectionOffsetReference(int direction, int tap, int stride) |
||||
|
{ |
||||
|
int[] x0 = [1, 1, 1, 1, 1, 0, 0, 0]; |
||||
|
int[] y0 = [-1, 0, 0, 0, 1, 1, 1, 1]; |
||||
|
int[] x1 = [2, 2, 2, 2, 2, 1, 0, -1]; |
||||
|
int[] y1 = [-2, -1, 0, 1, 2, 2, 2, 2]; |
||||
|
return tap == 0 ? (y0[direction] * stride) + x0[direction] : (y1[direction] * stride) + x1[direction]; |
||||
|
} |
||||
|
} |
||||
Loading…
Reference in new issue