mirror of https://github.com/SixLabors/ImageSharp
James Jackson-South
2 months ago
6 changed files with 1634 additions and 1 deletions
@ -0,0 +1,423 @@ |
|||||
|
// Copyright (c) Six Labors.
|
||||
|
// Licensed under the Six Labors Split License.
|
||||
|
|
||||
|
using System.Numerics; |
||||
|
using System.Runtime.CompilerServices; |
||||
|
using System.Runtime.InteropServices; |
||||
|
using System.Runtime.Intrinsics; |
||||
|
using SixLabors.ImageSharp.Common.Helpers; |
||||
|
|
||||
|
namespace SixLabors.ImageSharp.Formats.Heif.Hevc; |
||||
|
|
||||
|
/// <content>
|
||||
|
/// Provides shared SIMD operations used by the closed prediction operators.
|
||||
|
/// </content>
|
||||
|
internal static partial class HevcIntraPredictor |
||||
|
{ |
||||
|
/// <summary>
|
||||
|
/// Calculates one 512-bit half of a planar prediction row.
|
||||
|
/// </summary>
|
||||
|
/// <param name="top">The top reference samples.</param>
|
||||
|
/// <param name="indices">The zero-based X coordinates.</param>
|
||||
|
/// <param name="left">The left reference sample for the row.</param>
|
||||
|
/// <param name="topRight">The top-right reference sample.</param>
|
||||
|
/// <param name="bottomLeft">The bottom-left reference sample.</param>
|
||||
|
/// <param name="topWeight">The top-reference weight.</param>
|
||||
|
/// <param name="bottomWeight">The bottom-left-reference weight.</param>
|
||||
|
/// <param name="size">The square block side.</param>
|
||||
|
/// <param name="rounding">The division rounding constant.</param>
|
||||
|
/// <param name="shift">The division shift.</param>
|
||||
|
/// <returns>The predicted samples as widened lanes.</returns>
|
||||
|
[MethodImpl(MethodImplOptions.AggressiveInlining)] |
||||
|
private static Vector512<uint> CalculatePlanarVector( |
||||
|
Vector512<uint> top, |
||||
|
Vector512<uint> indices, |
||||
|
uint left, |
||||
|
uint topRight, |
||||
|
uint bottomLeft, |
||||
|
uint topWeight, |
||||
|
uint bottomWeight, |
||||
|
uint size, |
||||
|
uint rounding, |
||||
|
int shift) |
||||
|
{ |
||||
|
Vector512<uint> horizontal = ((Vector512.Create(size - 1) - indices) * left) + ((indices + Vector512<uint>.One) * topRight); |
||||
|
Vector512<uint> vertical = (top * topWeight) + Vector512.Create(bottomLeft * bottomWeight); |
||||
|
return (horizontal + vertical + Vector512.Create(rounding)) >> shift; |
||||
|
} |
||||
|
|
||||
|
/// <summary>
|
||||
|
/// Calculates one 256-bit half of a planar prediction row.
|
||||
|
/// </summary>
|
||||
|
/// <param name="top">The top reference samples.</param>
|
||||
|
/// <param name="indices">The zero-based X coordinates.</param>
|
||||
|
/// <param name="left">The left reference sample for the row.</param>
|
||||
|
/// <param name="topRight">The top-right reference sample.</param>
|
||||
|
/// <param name="bottomLeft">The bottom-left reference sample.</param>
|
||||
|
/// <param name="topWeight">The top-reference weight.</param>
|
||||
|
/// <param name="bottomWeight">The bottom-left-reference weight.</param>
|
||||
|
/// <param name="size">The square block side.</param>
|
||||
|
/// <param name="rounding">The division rounding constant.</param>
|
||||
|
/// <param name="shift">The division shift.</param>
|
||||
|
/// <returns>The predicted samples as widened lanes.</returns>
|
||||
|
[MethodImpl(MethodImplOptions.AggressiveInlining)] |
||||
|
private static Vector256<uint> CalculatePlanarVector( |
||||
|
Vector256<uint> top, |
||||
|
Vector256<uint> indices, |
||||
|
uint left, |
||||
|
uint topRight, |
||||
|
uint bottomLeft, |
||||
|
uint topWeight, |
||||
|
uint bottomWeight, |
||||
|
uint size, |
||||
|
uint rounding, |
||||
|
int shift) |
||||
|
{ |
||||
|
Vector256<uint> horizontal = ((Vector256.Create(size - 1) - indices) * left) + ((indices + Vector256<uint>.One) * topRight); |
||||
|
Vector256<uint> vertical = (top * topWeight) + Vector256.Create(bottomLeft * bottomWeight); |
||||
|
return (horizontal + vertical + Vector256.Create(rounding)) >> shift; |
||||
|
} |
||||
|
|
||||
|
/// <summary>
|
||||
|
/// Calculates one 128-bit half of a planar prediction row.
|
||||
|
/// </summary>
|
||||
|
/// <param name="top">The top reference samples.</param>
|
||||
|
/// <param name="indices">The zero-based X coordinates.</param>
|
||||
|
/// <param name="left">The left reference sample for the row.</param>
|
||||
|
/// <param name="topRight">The top-right reference sample.</param>
|
||||
|
/// <param name="bottomLeft">The bottom-left reference sample.</param>
|
||||
|
/// <param name="topWeight">The top-reference weight.</param>
|
||||
|
/// <param name="bottomWeight">The bottom-left-reference weight.</param>
|
||||
|
/// <param name="size">The square block side.</param>
|
||||
|
/// <param name="rounding">The division rounding constant.</param>
|
||||
|
/// <param name="shift">The division shift.</param>
|
||||
|
/// <returns>The predicted samples as widened lanes.</returns>
|
||||
|
[MethodImpl(MethodImplOptions.AggressiveInlining)] |
||||
|
private static Vector128<uint> CalculatePlanarVector( |
||||
|
Vector128<uint> top, |
||||
|
Vector128<uint> indices, |
||||
|
uint left, |
||||
|
uint topRight, |
||||
|
uint bottomLeft, |
||||
|
uint topWeight, |
||||
|
uint bottomWeight, |
||||
|
uint size, |
||||
|
uint rounding, |
||||
|
int shift) |
||||
|
{ |
||||
|
Vector128<uint> horizontal = ((Vector128.Create(size - 1) - indices) * left) + ((indices + Vector128<uint>.One) * topRight); |
||||
|
Vector128<uint> vertical = (top * topWeight) + Vector128.Create(bottomLeft * bottomWeight); |
||||
|
return (horizontal + vertical + Vector128.Create(rounding)) >> shift; |
||||
|
} |
||||
|
|
||||
|
/// <summary>
|
||||
|
/// Sums reconstructed reference samples without overflowing their 16-bit storage.
|
||||
|
/// </summary>
|
||||
|
/// <param name="samples">The samples to sum.</param>
|
||||
|
/// <returns>The exact unsigned sum.</returns>
|
||||
|
private static uint SumSamples(ReadOnlySpan<ushort> samples) |
||||
|
{ |
||||
|
ref ushort samplesBase = ref MemoryMarshal.GetReference(samples); |
||||
|
uint sum = 0; |
||||
|
int i = 0; |
||||
|
if (Vector512.IsHardwareAccelerated) |
||||
|
{ |
||||
|
int oneVectorFromEnd = samples.Length - Vector512<ushort>.Count; |
||||
|
for (; i <= oneVectorFromEnd; i += Vector512<ushort>.Count) |
||||
|
{ |
||||
|
(Vector512<uint> low, Vector512<uint> high) = Vector512.Widen(Vector512.LoadUnsafe(ref samplesBase, (nuint)i)); |
||||
|
sum += Vector512.Sum(low) + Vector512.Sum(high); |
||||
|
} |
||||
|
} |
||||
|
|
||||
|
if (Vector256.IsHardwareAccelerated) |
||||
|
{ |
||||
|
int oneVectorFromEnd = samples.Length - Vector256<ushort>.Count; |
||||
|
for (; i <= oneVectorFromEnd; i += Vector256<ushort>.Count) |
||||
|
{ |
||||
|
(Vector256<uint> low, Vector256<uint> high) = Vector256.Widen(Vector256.LoadUnsafe(ref samplesBase, (nuint)i)); |
||||
|
sum += Vector256.Sum(low) + Vector256.Sum(high); |
||||
|
} |
||||
|
} |
||||
|
|
||||
|
if (Vector128.IsHardwareAccelerated) |
||||
|
{ |
||||
|
int oneVectorFromEnd = samples.Length - Vector128<ushort>.Count; |
||||
|
for (; i <= oneVectorFromEnd; i += Vector128<ushort>.Count) |
||||
|
{ |
||||
|
(Vector128<uint> low, Vector128<uint> high) = Vector128.Widen(Vector128.LoadUnsafe(ref samplesBase, (nuint)i)); |
||||
|
sum += Vector128.Sum(low) + Vector128.Sum(high); |
||||
|
} |
||||
|
} |
||||
|
|
||||
|
for (; i < samples.Length; i++) |
||||
|
{ |
||||
|
sum += Unsafe.Add(ref samplesBase, i); |
||||
|
} |
||||
|
|
||||
|
return sum; |
||||
|
} |
||||
|
|
||||
|
/// <summary>
|
||||
|
/// Copies the top reference into every row and optionally filters the first column.
|
||||
|
/// </summary>
|
||||
|
/// <param name="top">The top reference samples.</param>
|
||||
|
/// <param name="left">The left reference samples.</param>
|
||||
|
/// <param name="destination">The destination block origin.</param>
|
||||
|
/// <param name="destinationStride">The destination row stride.</param>
|
||||
|
/// <param name="size">The square block side.</param>
|
||||
|
/// <param name="bitDepth">The reconstructed component precision.</param>
|
||||
|
/// <param name="filterPredictionEdges">Whether the vertical luma edge filter applies.</param>
|
||||
|
private static void PredictVertical( |
||||
|
ReadOnlySpan<ushort> top, |
||||
|
ReadOnlySpan<ushort> left, |
||||
|
Span<ushort> destination, |
||||
|
int destinationStride, |
||||
|
int size, |
||||
|
int bitDepth, |
||||
|
bool filterPredictionEdges) |
||||
|
{ |
||||
|
ReadOnlySpan<ushort> row = top.Slice(1, size); |
||||
|
int maximum = (1 << bitDepth) - 1; |
||||
|
for (int y = 0; y < size; y++) |
||||
|
{ |
||||
|
row.CopyTo(destination.Slice(y * destinationStride, size)); |
||||
|
if (filterPredictionEdges) |
||||
|
{ |
||||
|
int sample = destination[y * destinationStride] + ((left[y + 1] - left[0]) >> 1); |
||||
|
destination[y * destinationStride] = (ushort)Math.Clamp(sample, 0, maximum); |
||||
|
} |
||||
|
} |
||||
|
} |
||||
|
|
||||
|
/// <summary>
|
||||
|
/// Fills each row from its left reference and optionally filters the first row.
|
||||
|
/// </summary>
|
||||
|
/// <param name="top">The top reference samples.</param>
|
||||
|
/// <param name="left">The left reference samples.</param>
|
||||
|
/// <param name="destination">The destination block origin.</param>
|
||||
|
/// <param name="destinationStride">The destination row stride.</param>
|
||||
|
/// <param name="size">The square block side.</param>
|
||||
|
/// <param name="bitDepth">The reconstructed component precision.</param>
|
||||
|
/// <param name="filterPredictionEdges">Whether the horizontal luma edge filter applies.</param>
|
||||
|
private static void PredictHorizontal( |
||||
|
ReadOnlySpan<ushort> top, |
||||
|
ReadOnlySpan<ushort> left, |
||||
|
Span<ushort> destination, |
||||
|
int destinationStride, |
||||
|
int size, |
||||
|
int bitDepth, |
||||
|
bool filterPredictionEdges) |
||||
|
{ |
||||
|
for (int y = 0; y < size; y++) |
||||
|
{ |
||||
|
destination.Slice(y * destinationStride, size).Fill(left[y + 1]); |
||||
|
} |
||||
|
|
||||
|
if (!filterPredictionEdges) |
||||
|
{ |
||||
|
return; |
||||
|
} |
||||
|
|
||||
|
int maximum = (1 << bitDepth) - 1; |
||||
|
for (int x = 0; x < size; x++) |
||||
|
{ |
||||
|
int sample = destination[x] + ((top[x + 1] - top[0]) >> 1); |
||||
|
destination[x] = (ushort)Math.Clamp(sample, 0, maximum); |
||||
|
} |
||||
|
} |
||||
|
|
||||
|
/// <summary>
|
||||
|
/// Generates a vertical-oriented angular block using contiguous SIMD interpolation within each row.
|
||||
|
/// </summary>
|
||||
|
/// <param name="main">The main reference beginning at logical index zero.</param>
|
||||
|
/// <param name="mainOrigin">The span index corresponding to logical reference index zero.</param>
|
||||
|
/// <param name="destination">The contiguous destination or transposition scratch block.</param>
|
||||
|
/// <param name="destinationStride">The destination row stride.</param>
|
||||
|
/// <param name="size">The square block side.</param>
|
||||
|
/// <param name="angle">The signed prediction displacement in thirty-second-sample units.</param>
|
||||
|
private static void PredictAngularRows( |
||||
|
ReadOnlySpan<ushort> main, |
||||
|
int mainOrigin, |
||||
|
Span<ushort> destination, |
||||
|
int destinationStride, |
||||
|
int size, |
||||
|
int angle) |
||||
|
{ |
||||
|
for (int y = 0, deltaPosition = angle; y < size; y++, deltaPosition += angle) |
||||
|
{ |
||||
|
int deltaInteger = deltaPosition >> 5; |
||||
|
int deltaFraction = deltaPosition & 31; |
||||
|
int sourceOffset = mainOrigin + deltaInteger + 1; |
||||
|
Span<ushort> row = destination.Slice(y * destinationStride, size); |
||||
|
if (deltaFraction == 0) |
||||
|
{ |
||||
|
main.Slice(sourceOffset, size).CopyTo(row); |
||||
|
} |
||||
|
else |
||||
|
{ |
||||
|
InterpolateAngularRow(main[sourceOffset..], row, deltaFraction); |
||||
|
} |
||||
|
} |
||||
|
} |
||||
|
|
||||
|
/// <summary>
|
||||
|
/// Interpolates one angular prediction row between consecutive main-reference samples.
|
||||
|
/// </summary>
|
||||
|
/// <param name="source">The first main-reference sample for the row.</param>
|
||||
|
/// <param name="destination">The destination prediction row.</param>
|
||||
|
/// <param name="fraction">The right-hand weight with a denominator of thirty-two.</param>
|
||||
|
private static void InterpolateAngularRow(ReadOnlySpan<ushort> source, Span<ushort> destination, int fraction) |
||||
|
{ |
||||
|
ref ushort sourceBase = ref MemoryMarshal.GetReference(source); |
||||
|
ref ushort destinationBase = ref MemoryMarshal.GetReference(destination); |
||||
|
uint leftWeight = (uint)(32 - fraction); |
||||
|
uint rightWeight = (uint)fraction; |
||||
|
int i = 0; |
||||
|
|
||||
|
if (Vector512.IsHardwareAccelerated) |
||||
|
{ |
||||
|
int oneVectorFromEnd = destination.Length - Vector512<ushort>.Count; |
||||
|
for (; i <= oneVectorFromEnd; i += Vector512<ushort>.Count) |
||||
|
{ |
||||
|
Vector512<ushort> left = Vector512.LoadUnsafe(ref sourceBase, (nuint)i); |
||||
|
Vector512<ushort> right = Vector512.LoadUnsafe(ref sourceBase, (nuint)(i + 1)); |
||||
|
(Vector512<uint> leftLow, Vector512<uint> leftHigh) = Vector512.Widen(left); |
||||
|
(Vector512<uint> rightLow, Vector512<uint> rightHigh) = Vector512.Widen(right); |
||||
|
Vector512<uint> low = ((leftLow * leftWeight) + (rightLow * rightWeight) + Vector512.Create(16U)) >> 5; |
||||
|
Vector512<uint> high = ((leftHigh * leftWeight) + (rightHigh * rightWeight) + Vector512.Create(16U)) >> 5; |
||||
|
Vector512.Narrow(low, high).StoreUnsafe(ref Unsafe.Add(ref destinationBase, i)); |
||||
|
} |
||||
|
} |
||||
|
|
||||
|
if (Vector256.IsHardwareAccelerated) |
||||
|
{ |
||||
|
int oneVectorFromEnd = destination.Length - Vector256<ushort>.Count; |
||||
|
for (; i <= oneVectorFromEnd; i += Vector256<ushort>.Count) |
||||
|
{ |
||||
|
Vector256<ushort> left = Vector256.LoadUnsafe(ref sourceBase, (nuint)i); |
||||
|
Vector256<ushort> right = Vector256.LoadUnsafe(ref sourceBase, (nuint)(i + 1)); |
||||
|
(Vector256<uint> leftLow, Vector256<uint> leftHigh) = Vector256.Widen(left); |
||||
|
(Vector256<uint> rightLow, Vector256<uint> rightHigh) = Vector256.Widen(right); |
||||
|
Vector256<uint> low = ((leftLow * leftWeight) + (rightLow * rightWeight) + Vector256.Create(16U)) >> 5; |
||||
|
Vector256<uint> high = ((leftHigh * leftWeight) + (rightHigh * rightWeight) + Vector256.Create(16U)) >> 5; |
||||
|
Vector256.Narrow(low, high).StoreUnsafe(ref Unsafe.Add(ref destinationBase, i)); |
||||
|
} |
||||
|
} |
||||
|
|
||||
|
if (Vector128.IsHardwareAccelerated) |
||||
|
{ |
||||
|
int oneVectorFromEnd = destination.Length - Vector128<ushort>.Count; |
||||
|
for (; i <= oneVectorFromEnd; i += Vector128<ushort>.Count) |
||||
|
{ |
||||
|
Vector128<ushort> left = Vector128.LoadUnsafe(ref sourceBase, (nuint)i); |
||||
|
Vector128<ushort> right = Vector128.LoadUnsafe(ref sourceBase, (nuint)(i + 1)); |
||||
|
(Vector128<uint> leftLow, Vector128<uint> leftHigh) = Vector128.Widen(left); |
||||
|
(Vector128<uint> rightLow, Vector128<uint> rightHigh) = Vector128.Widen(right); |
||||
|
Vector128<uint> low = ((leftLow * leftWeight) + (rightLow * rightWeight) + Vector128.Create(16U)) >> 5; |
||||
|
Vector128<uint> high = ((leftHigh * leftWeight) + (rightHigh * rightWeight) + Vector128.Create(16U)) >> 5; |
||||
|
Vector128.Narrow(low, high).StoreUnsafe(ref Unsafe.Add(ref destinationBase, i)); |
||||
|
} |
||||
|
} |
||||
|
|
||||
|
for (; i < destination.Length; i++) |
||||
|
{ |
||||
|
Unsafe.Add(ref destinationBase, i) = (ushort)(((source[i] * leftWeight) + (source[i + 1] * rightWeight) + 16) >> 5); |
||||
|
} |
||||
|
} |
||||
|
|
||||
|
/// <summary>
|
||||
|
/// Transposes a square horizontal prediction block into the reconstructed destination.
|
||||
|
/// </summary>
|
||||
|
/// <param name="source">The contiguous transposed prediction block.</param>
|
||||
|
/// <param name="destination">The destination block origin.</param>
|
||||
|
/// <param name="destinationStride">The destination row stride.</param>
|
||||
|
/// <param name="size">The square block side.</param>
|
||||
|
private static void TransposeBlock(ReadOnlySpan<ushort> source, Span<ushort> destination, int destinationStride, int size) |
||||
|
{ |
||||
|
if (Vector128.IsHardwareAccelerated && size >= Vector128<ushort>.Count) |
||||
|
{ |
||||
|
for (int y = 0; y < size; y += Vector128<ushort>.Count) |
||||
|
{ |
||||
|
for (int x = 0; x < size; x += Vector128<ushort>.Count) |
||||
|
{ |
||||
|
Transpose8x8(source, destination, destinationStride, size, x, y); |
||||
|
} |
||||
|
} |
||||
|
|
||||
|
return; |
||||
|
} |
||||
|
|
||||
|
for (int y = 0; y < size; y++) |
||||
|
{ |
||||
|
for (int x = 0; x < size; x++) |
||||
|
{ |
||||
|
destination[(x * destinationStride) + y] = source[(y * size) + x]; |
||||
|
} |
||||
|
} |
||||
|
} |
||||
|
|
||||
|
/// <summary>
|
||||
|
/// Transposes one eight-by-eight tile of 16-bit prediction samples.
|
||||
|
/// </summary>
|
||||
|
/// <param name="source">The contiguous source block.</param>
|
||||
|
/// <param name="destination">The destination block origin.</param>
|
||||
|
/// <param name="destinationStride">The destination row stride.</param>
|
||||
|
/// <param name="sourceStride">The contiguous source row stride.</param>
|
||||
|
/// <param name="x">The tile X coordinate in the source block.</param>
|
||||
|
/// <param name="y">The tile Y coordinate in the source block.</param>
|
||||
|
private static void Transpose8x8( |
||||
|
ReadOnlySpan<ushort> source, |
||||
|
Span<ushort> destination, |
||||
|
int destinationStride, |
||||
|
int sourceStride, |
||||
|
int x, |
||||
|
int y) |
||||
|
{ |
||||
|
ref ushort sourceBase = ref MemoryMarshal.GetReference(source); |
||||
|
ref ushort destinationBase = ref MemoryMarshal.GetReference(destination); |
||||
|
Vector128<short> row0 = Vector128.LoadUnsafe(ref sourceBase, (nuint)(((y + 0) * sourceStride) + x)).AsInt16(); |
||||
|
Vector128<short> row1 = Vector128.LoadUnsafe(ref sourceBase, (nuint)(((y + 1) * sourceStride) + x)).AsInt16(); |
||||
|
Vector128<short> row2 = Vector128.LoadUnsafe(ref sourceBase, (nuint)(((y + 2) * sourceStride) + x)).AsInt16(); |
||||
|
Vector128<short> row3 = Vector128.LoadUnsafe(ref sourceBase, (nuint)(((y + 3) * sourceStride) + x)).AsInt16(); |
||||
|
Vector128<short> row4 = Vector128.LoadUnsafe(ref sourceBase, (nuint)(((y + 4) * sourceStride) + x)).AsInt16(); |
||||
|
Vector128<short> row5 = Vector128.LoadUnsafe(ref sourceBase, (nuint)(((y + 5) * sourceStride) + x)).AsInt16(); |
||||
|
Vector128<short> row6 = Vector128.LoadUnsafe(ref sourceBase, (nuint)(((y + 6) * sourceStride) + x)).AsInt16(); |
||||
|
Vector128<short> row7 = Vector128.LoadUnsafe(ref sourceBase, (nuint)(((y + 7) * sourceStride) + x)).AsInt16(); |
||||
|
|
||||
|
// Three zip stages exchange one, two, then four 16-bit coordinates. The resulting vectors are the eight
|
||||
|
// source columns in row order, so each can be stored contiguously into one destination row.
|
||||
|
Vector128<short> pair0 = Vector128_.UnpackLow(row0, row1); |
||||
|
Vector128<short> pair1 = Vector128_.UnpackHigh(row0, row1); |
||||
|
Vector128<short> pair2 = Vector128_.UnpackLow(row2, row3); |
||||
|
Vector128<short> pair3 = Vector128_.UnpackHigh(row2, row3); |
||||
|
Vector128<short> pair4 = Vector128_.UnpackLow(row4, row5); |
||||
|
Vector128<short> pair5 = Vector128_.UnpackHigh(row4, row5); |
||||
|
Vector128<short> pair6 = Vector128_.UnpackLow(row6, row7); |
||||
|
Vector128<short> pair7 = Vector128_.UnpackHigh(row6, row7); |
||||
|
Vector128<int> quad0 = Vector128_.UnpackLow(pair0.AsInt32(), pair2.AsInt32()); |
||||
|
Vector128<int> quad1 = Vector128_.UnpackHigh(pair0.AsInt32(), pair2.AsInt32()); |
||||
|
Vector128<int> quad2 = Vector128_.UnpackLow(pair1.AsInt32(), pair3.AsInt32()); |
||||
|
Vector128<int> quad3 = Vector128_.UnpackHigh(pair1.AsInt32(), pair3.AsInt32()); |
||||
|
Vector128<int> quad4 = Vector128_.UnpackLow(pair4.AsInt32(), pair6.AsInt32()); |
||||
|
Vector128<int> quad5 = Vector128_.UnpackHigh(pair4.AsInt32(), pair6.AsInt32()); |
||||
|
Vector128<int> quad6 = Vector128_.UnpackLow(pair5.AsInt32(), pair7.AsInt32()); |
||||
|
Vector128<int> quad7 = Vector128_.UnpackHigh(pair5.AsInt32(), pair7.AsInt32()); |
||||
|
Vector128<ushort> column0 = Vector128_.UnpackLow(quad0.AsInt64(), quad4.AsInt64()).AsUInt16(); |
||||
|
Vector128<ushort> column1 = Vector128_.UnpackHigh(quad0.AsInt64(), quad4.AsInt64()).AsUInt16(); |
||||
|
Vector128<ushort> column2 = Vector128_.UnpackLow(quad1.AsInt64(), quad5.AsInt64()).AsUInt16(); |
||||
|
Vector128<ushort> column3 = Vector128_.UnpackHigh(quad1.AsInt64(), quad5.AsInt64()).AsUInt16(); |
||||
|
Vector128<ushort> column4 = Vector128_.UnpackLow(quad2.AsInt64(), quad6.AsInt64()).AsUInt16(); |
||||
|
Vector128<ushort> column5 = Vector128_.UnpackHigh(quad2.AsInt64(), quad6.AsInt64()).AsUInt16(); |
||||
|
Vector128<ushort> column6 = Vector128_.UnpackLow(quad3.AsInt64(), quad7.AsInt64()).AsUInt16(); |
||||
|
Vector128<ushort> column7 = Vector128_.UnpackHigh(quad3.AsInt64(), quad7.AsInt64()).AsUInt16(); |
||||
|
column0.StoreUnsafe(ref destinationBase, (nuint)(((x + 0) * destinationStride) + y)); |
||||
|
column1.StoreUnsafe(ref destinationBase, (nuint)(((x + 1) * destinationStride) + y)); |
||||
|
column2.StoreUnsafe(ref destinationBase, (nuint)(((x + 2) * destinationStride) + y)); |
||||
|
column3.StoreUnsafe(ref destinationBase, (nuint)(((x + 3) * destinationStride) + y)); |
||||
|
column4.StoreUnsafe(ref destinationBase, (nuint)(((x + 4) * destinationStride) + y)); |
||||
|
column5.StoreUnsafe(ref destinationBase, (nuint)(((x + 5) * destinationStride) + y)); |
||||
|
column6.StoreUnsafe(ref destinationBase, (nuint)(((x + 6) * destinationStride) + y)); |
||||
|
column7.StoreUnsafe(ref destinationBase, (nuint)(((x + 7) * destinationStride) + y)); |
||||
|
} |
||||
|
} |
||||
@ -0,0 +1,280 @@ |
|||||
|
// Copyright (c) Six Labors.
|
||||
|
// Licensed under the Six Labors Split License.
|
||||
|
|
||||
|
using System.Numerics; |
||||
|
using System.Runtime.CompilerServices; |
||||
|
using System.Runtime.InteropServices; |
||||
|
using System.Runtime.Intrinsics; |
||||
|
|
||||
|
namespace SixLabors.ImageSharp.Formats.Heif.Hevc; |
||||
|
|
||||
|
/// <content>
|
||||
|
/// Provides the closed planar, DC, and angular prediction operators.
|
||||
|
/// </content>
|
||||
|
internal static partial class HevcIntraPredictor |
||||
|
{ |
||||
|
/// <summary>
|
||||
|
/// Implements planar interpolation between the top, left, bottom-left, and top-right references.
|
||||
|
/// </summary>
|
||||
|
private readonly struct PlanarPredictionOperator : IHevcIntraPredictionOperator<PlanarPredictionOperator> |
||||
|
{ |
||||
|
/// <inheritdoc/>
|
||||
|
public static void Predict( |
||||
|
ReadOnlySpan<ushort> top, |
||||
|
ReadOnlySpan<ushort> left, |
||||
|
Span<ushort> destination, |
||||
|
int destinationStride, |
||||
|
int size, |
||||
|
int mode, |
||||
|
int bitDepth, |
||||
|
bool filterPredictionEdges, |
||||
|
Span<ushort> scratch) |
||||
|
{ |
||||
|
ref ushort topBase = ref MemoryMarshal.GetReference(top); |
||||
|
ref ushort destinationBase = ref MemoryMarshal.GetReference(destination); |
||||
|
uint bottomLeft = left[size]; |
||||
|
uint topRight = top[size]; |
||||
|
int shift = BitOperations.Log2((uint)size) + 1; |
||||
|
uint rounding = (uint)size; |
||||
|
|
||||
|
for (int y = 0; y < size; y++) |
||||
|
{ |
||||
|
uint leftSample = left[y + 1]; |
||||
|
uint topWeight = (uint)(size - y - 1); |
||||
|
uint bottomWeight = (uint)(y + 1); |
||||
|
ref ushort rowBase = ref Unsafe.Add(ref destinationBase, y * destinationStride); |
||||
|
int x = 0; |
||||
|
|
||||
|
// The two widened halves carry consecutive X coordinates. Each lane evaluates the normative
|
||||
|
// horizontal and vertical ramps, then narrows after the common rounded power-of-two division.
|
||||
|
if (Vector512.IsHardwareAccelerated) |
||||
|
{ |
||||
|
Vector512<uint> indices = CreateIndicesVector512(); |
||||
|
int oneVectorFromEnd = size - Vector512<ushort>.Count; |
||||
|
for (; x <= oneVectorFromEnd; x += Vector512<ushort>.Count) |
||||
|
{ |
||||
|
Vector512<ushort> topSamples = Vector512.LoadUnsafe(ref topBase, (nuint)(x + 1)); |
||||
|
(Vector512<uint> topLow, Vector512<uint> topHigh) = Vector512.Widen(topSamples); |
||||
|
Vector512<uint> lowIndices = indices + Vector512.Create((uint)x); |
||||
|
Vector512<uint> highIndices = lowIndices + Vector512.Create((uint)Vector512<uint>.Count); |
||||
|
Vector512<uint> low = CalculatePlanarVector( |
||||
|
topLow, |
||||
|
lowIndices, |
||||
|
leftSample, |
||||
|
topRight, |
||||
|
bottomLeft, |
||||
|
topWeight, |
||||
|
bottomWeight, |
||||
|
(uint)size, |
||||
|
rounding, |
||||
|
shift); |
||||
|
|
||||
|
Vector512<uint> high = CalculatePlanarVector( |
||||
|
topHigh, |
||||
|
highIndices, |
||||
|
leftSample, |
||||
|
topRight, |
||||
|
bottomLeft, |
||||
|
topWeight, |
||||
|
bottomWeight, |
||||
|
(uint)size, |
||||
|
rounding, |
||||
|
shift); |
||||
|
|
||||
|
Vector512.Narrow(low, high).StoreUnsafe(ref Unsafe.Add(ref rowBase, x)); |
||||
|
} |
||||
|
} |
||||
|
|
||||
|
if (Vector256.IsHardwareAccelerated) |
||||
|
{ |
||||
|
Vector256<uint> indices = CreateIndicesVector256(); |
||||
|
int oneVectorFromEnd = size - Vector256<ushort>.Count; |
||||
|
for (; x <= oneVectorFromEnd; x += Vector256<ushort>.Count) |
||||
|
{ |
||||
|
Vector256<ushort> topSamples = Vector256.LoadUnsafe(ref topBase, (nuint)(x + 1)); |
||||
|
(Vector256<uint> topLow, Vector256<uint> topHigh) = Vector256.Widen(topSamples); |
||||
|
Vector256<uint> lowIndices = indices + Vector256.Create((uint)x); |
||||
|
Vector256<uint> highIndices = lowIndices + Vector256.Create((uint)Vector256<uint>.Count); |
||||
|
Vector256<uint> low = CalculatePlanarVector( |
||||
|
topLow, |
||||
|
lowIndices, |
||||
|
leftSample, |
||||
|
topRight, |
||||
|
bottomLeft, |
||||
|
topWeight, |
||||
|
bottomWeight, |
||||
|
(uint)size, |
||||
|
rounding, |
||||
|
shift); |
||||
|
|
||||
|
Vector256<uint> high = CalculatePlanarVector( |
||||
|
topHigh, |
||||
|
highIndices, |
||||
|
leftSample, |
||||
|
topRight, |
||||
|
bottomLeft, |
||||
|
topWeight, |
||||
|
bottomWeight, |
||||
|
(uint)size, |
||||
|
rounding, |
||||
|
shift); |
||||
|
|
||||
|
Vector256.Narrow(low, high).StoreUnsafe(ref Unsafe.Add(ref rowBase, x)); |
||||
|
} |
||||
|
} |
||||
|
|
||||
|
if (Vector128.IsHardwareAccelerated) |
||||
|
{ |
||||
|
Vector128<uint> indices = CreateIndicesVector128(); |
||||
|
int oneVectorFromEnd = size - Vector128<ushort>.Count; |
||||
|
for (; x <= oneVectorFromEnd; x += Vector128<ushort>.Count) |
||||
|
{ |
||||
|
Vector128<ushort> topSamples = Vector128.LoadUnsafe(ref topBase, (nuint)(x + 1)); |
||||
|
(Vector128<uint> topLow, Vector128<uint> topHigh) = Vector128.Widen(topSamples); |
||||
|
Vector128<uint> lowIndices = indices + Vector128.Create((uint)x); |
||||
|
Vector128<uint> highIndices = lowIndices + Vector128.Create((uint)Vector128<uint>.Count); |
||||
|
Vector128<uint> low = CalculatePlanarVector( |
||||
|
topLow, |
||||
|
lowIndices, |
||||
|
leftSample, |
||||
|
topRight, |
||||
|
bottomLeft, |
||||
|
topWeight, |
||||
|
bottomWeight, |
||||
|
(uint)size, |
||||
|
rounding, |
||||
|
shift); |
||||
|
|
||||
|
Vector128<uint> high = CalculatePlanarVector( |
||||
|
topHigh, |
||||
|
highIndices, |
||||
|
leftSample, |
||||
|
topRight, |
||||
|
bottomLeft, |
||||
|
topWeight, |
||||
|
bottomWeight, |
||||
|
(uint)size, |
||||
|
rounding, |
||||
|
shift); |
||||
|
|
||||
|
Vector128.Narrow(low, high).StoreUnsafe(ref Unsafe.Add(ref rowBase, x)); |
||||
|
} |
||||
|
} |
||||
|
|
||||
|
for (; x < size; x++) |
||||
|
{ |
||||
|
uint horizontal = ((uint)(size - x - 1) * leftSample) + ((uint)(x + 1) * topRight); |
||||
|
uint vertical = ((uint)(size - y - 1) * top[x + 1]) + ((uint)(y + 1) * bottomLeft); |
||||
|
Unsafe.Add(ref rowBase, x) = (ushort)((horizontal + vertical + (uint)size) >> shift); |
||||
|
} |
||||
|
} |
||||
|
} |
||||
|
} |
||||
|
|
||||
|
/// <summary>
|
||||
|
/// Implements DC prediction and its optional luma boundary filter.
|
||||
|
/// </summary>
|
||||
|
private readonly struct DcPredictionOperator : IHevcIntraPredictionOperator<DcPredictionOperator> |
||||
|
{ |
||||
|
/// <inheritdoc/>
|
||||
|
public static void Predict( |
||||
|
ReadOnlySpan<ushort> top, |
||||
|
ReadOnlySpan<ushort> left, |
||||
|
Span<ushort> destination, |
||||
|
int destinationStride, |
||||
|
int size, |
||||
|
int mode, |
||||
|
int bitDepth, |
||||
|
bool filterPredictionEdges, |
||||
|
Span<ushort> scratch) |
||||
|
{ |
||||
|
uint sum = SumSamples(top.Slice(1, size)) + SumSamples(left.Slice(1, size)); |
||||
|
ushort dc = (ushort)((sum + (uint)size) >> (BitOperations.Log2((uint)size) + 1)); |
||||
|
for (int y = 0; y < size; y++) |
||||
|
{ |
||||
|
destination.Slice(y * destinationStride, size).Fill(dc); |
||||
|
} |
||||
|
|
||||
|
if (!filterPredictionEdges) |
||||
|
{ |
||||
|
return; |
||||
|
} |
||||
|
|
||||
|
destination[0] = (ushort)((top[1] + left[1] + (2 * dc) + 2) >> 2); |
||||
|
for (int x = 1; x < size; x++) |
||||
|
{ |
||||
|
destination[x] = (ushort)((top[x + 1] + (3 * dc) + 2) >> 2); |
||||
|
} |
||||
|
|
||||
|
for (int y = 1; y < size; y++) |
||||
|
{ |
||||
|
destination[y * destinationStride] = (ushort)((left[y + 1] + (3 * dc) + 2) >> 2); |
||||
|
} |
||||
|
} |
||||
|
} |
||||
|
|
||||
|
/// <summary>
|
||||
|
/// Implements the thirty-three directional intra-prediction modes.
|
||||
|
/// </summary>
|
||||
|
private readonly struct AngularPredictionOperator : IHevcIntraPredictionOperator<AngularPredictionOperator> |
||||
|
{ |
||||
|
/// <inheritdoc/>
|
||||
|
public static void Predict( |
||||
|
ReadOnlySpan<ushort> top, |
||||
|
ReadOnlySpan<ushort> left, |
||||
|
Span<ushort> destination, |
||||
|
int destinationStride, |
||||
|
int size, |
||||
|
int mode, |
||||
|
int bitDepth, |
||||
|
bool filterPredictionEdges, |
||||
|
Span<ushort> scratch) |
||||
|
{ |
||||
|
if (mode == VerticalMode) |
||||
|
{ |
||||
|
PredictVertical(top, left, destination, destinationStride, size, bitDepth, filterPredictionEdges); |
||||
|
return; |
||||
|
} |
||||
|
|
||||
|
if (mode == HorizontalMode) |
||||
|
{ |
||||
|
PredictHorizontal(top, left, destination, destinationStride, size, bitDepth, filterPredictionEdges); |
||||
|
return; |
||||
|
} |
||||
|
|
||||
|
bool vertical = mode >= FirstVerticalMode; |
||||
|
int angleMode = vertical ? mode - VerticalMode : HorizontalMode - mode; |
||||
|
int absoluteAngleMode = Math.Abs(angleMode); |
||||
|
int angle = PredictionAngles[absoluteAngleMode] * Math.Sign(angleMode); |
||||
|
ReadOnlySpan<ushort> main = vertical ? top : left; |
||||
|
ReadOnlySpan<ushort> side = vertical ? left : top; |
||||
|
Span<ushort> temporaryBlock = scratch[..(size * size)]; |
||||
|
Span<ushort> extendedReference = scratch.Slice(size * size, (4 * size) + 1); |
||||
|
int mainOrigin = 0; |
||||
|
|
||||
|
if (angle < 0) |
||||
|
{ |
||||
|
mainOrigin = size * 2; |
||||
|
main[..(size + 1)].CopyTo(extendedReference[mainOrigin..]); |
||||
|
int inverseAngle = InversePredictionAngles[absoluteAngleMode]; |
||||
|
int inverseAngleSum = 128; |
||||
|
int minimumIndex = (size * angle) >> 5; |
||||
|
for (int index = -1; index > minimumIndex; index--) |
||||
|
{ |
||||
|
inverseAngleSum += inverseAngle; |
||||
|
extendedReference[mainOrigin + index] = side[inverseAngleSum >> 8]; |
||||
|
} |
||||
|
|
||||
|
main = extendedReference; |
||||
|
} |
||||
|
|
||||
|
Span<ushort> prediction = vertical ? destination : temporaryBlock; |
||||
|
int predictionStride = vertical ? destinationStride : size; |
||||
|
PredictAngularRows(main, mainOrigin, prediction, predictionStride, size, angle); |
||||
|
if (!vertical) |
||||
|
{ |
||||
|
TransposeBlock(temporaryBlock, destination, destinationStride, size); |
||||
|
} |
||||
|
} |
||||
|
} |
||||
|
} |
||||
@ -0,0 +1,412 @@ |
|||||
|
// Copyright (c) Six Labors.
|
||||
|
// Licensed under the Six Labors Split License.
|
||||
|
|
||||
|
using System.Numerics; |
||||
|
using System.Runtime.CompilerServices; |
||||
|
using System.Runtime.InteropServices; |
||||
|
using System.Runtime.Intrinsics; |
||||
|
using SixLabors.ImageSharp.Common.Helpers; |
||||
|
|
||||
|
namespace SixLabors.ImageSharp.Formats.Heif.Hevc; |
||||
|
|
||||
|
/// <summary>
|
||||
|
/// Reconstructs HEVC intra-prediction blocks from prepared neighboring samples.
|
||||
|
/// </summary>
|
||||
|
internal static partial class HevcIntraPredictor |
||||
|
{ |
||||
|
/// <summary>
|
||||
|
/// The HEVC planar prediction mode.
|
||||
|
/// </summary>
|
||||
|
private const int PlanarMode = 0; |
||||
|
|
||||
|
/// <summary>
|
||||
|
/// The HEVC DC prediction mode.
|
||||
|
/// </summary>
|
||||
|
private const int DcMode = 1; |
||||
|
|
||||
|
/// <summary>
|
||||
|
/// The HEVC horizontal prediction mode.
|
||||
|
/// </summary>
|
||||
|
private const int HorizontalMode = 10; |
||||
|
|
||||
|
/// <summary>
|
||||
|
/// The first prediction mode whose main reference is the top row.
|
||||
|
/// </summary>
|
||||
|
private const int FirstVerticalMode = 18; |
||||
|
|
||||
|
/// <summary>
|
||||
|
/// The HEVC vertical prediction mode.
|
||||
|
/// </summary>
|
||||
|
private const int VerticalMode = 26; |
||||
|
|
||||
|
/// <summary>
|
||||
|
/// The largest transform-block side supported by HEVC intra prediction.
|
||||
|
/// </summary>
|
||||
|
private const int MaximumBlockSize = 32; |
||||
|
|
||||
|
/// <summary>
|
||||
|
/// Defines one closed intra-prediction operation selected by the decoded mode.
|
||||
|
/// </summary>
|
||||
|
/// <typeparam name="TOperator">The implementing operator type.</typeparam>
|
||||
|
private interface IHevcIntraPredictionOperator<TOperator> |
||||
|
where TOperator : struct, IHevcIntraPredictionOperator<TOperator> |
||||
|
{ |
||||
|
/// <summary>
|
||||
|
/// Reconstructs one square prediction block.
|
||||
|
/// </summary>
|
||||
|
/// <param name="top">The top-left, top, and top-right reference samples.</param>
|
||||
|
/// <param name="left">The top-left, left, and below-left reference samples.</param>
|
||||
|
/// <param name="destination">The destination buffer beginning at the block origin.</param>
|
||||
|
/// <param name="destinationStride">The destination row stride in samples.</param>
|
||||
|
/// <param name="size">The square block side in samples.</param>
|
||||
|
/// <param name="mode">The decoded prediction mode.</param>
|
||||
|
/// <param name="bitDepth">The reconstructed component precision.</param>
|
||||
|
/// <param name="filterPredictionEdges">Whether the luma edge filter applies to the selected block.</param>
|
||||
|
/// <param name="scratch">The caller-owned block and extended-reference scratch space.</param>
|
||||
|
public static abstract void Predict( |
||||
|
ReadOnlySpan<ushort> top, |
||||
|
ReadOnlySpan<ushort> left, |
||||
|
Span<ushort> destination, |
||||
|
int destinationStride, |
||||
|
int size, |
||||
|
int mode, |
||||
|
int bitDepth, |
||||
|
bool filterPredictionEdges, |
||||
|
Span<ushort> scratch); |
||||
|
} |
||||
|
|
||||
|
/// <summary>
|
||||
|
/// Gets the angle selected by each absolute angular-mode displacement.
|
||||
|
/// </summary>
|
||||
|
private static ReadOnlySpan<int> PredictionAngles => [0, 2, 5, 9, 13, 17, 21, 26, 32]; |
||||
|
|
||||
|
/// <summary>
|
||||
|
/// Gets the reciprocal angle used to extend the main reference for negative directions.
|
||||
|
/// </summary>
|
||||
|
private static ReadOnlySpan<int> InversePredictionAngles => [0, 4096, 1638, 910, 630, 482, 390, 315, 256]; |
||||
|
|
||||
|
/// <summary>
|
||||
|
/// Gets the scratch length required to predict a block of the specified size.
|
||||
|
/// </summary>
|
||||
|
/// <param name="log2Size">The base-two logarithm of the square block side.</param>
|
||||
|
/// <returns>The required number of <see cref="ushort"/> elements.</returns>
|
||||
|
public static int GetScratchLength(int log2Size) |
||||
|
{ |
||||
|
DebugGuard.MustBeBetweenOrEqualTo(log2Size, 2, 5, nameof(log2Size)); |
||||
|
int size = 1 << log2Size; |
||||
|
return (size * size) + (4 * size) + 1; |
||||
|
} |
||||
|
|
||||
|
/// <summary>
|
||||
|
/// Reconstructs one square intra-prediction block using a closed operator selected by the decoded mode.
|
||||
|
/// </summary>
|
||||
|
/// <param name="top">The top-left, top, and top-right reference samples.</param>
|
||||
|
/// <param name="left">The top-left, left, and below-left reference samples.</param>
|
||||
|
/// <param name="destination">The destination buffer beginning at the block origin.</param>
|
||||
|
/// <param name="destinationStride">The destination row stride in samples.</param>
|
||||
|
/// <param name="log2Size">The base-two logarithm of the square block side.</param>
|
||||
|
/// <param name="mode">The decoded prediction mode in the inclusive range zero through thirty-four.</param>
|
||||
|
/// <param name="bitDepth">The reconstructed component precision.</param>
|
||||
|
/// <param name="filterPredictionEdges">Whether the luma edge filter applies to the selected block.</param>
|
||||
|
/// <param name="scratch">The caller-owned scratch returned by <see cref="GetScratchLength(int)"/>.</param>
|
||||
|
public static void Predict( |
||||
|
ReadOnlySpan<ushort> top, |
||||
|
ReadOnlySpan<ushort> left, |
||||
|
Span<ushort> destination, |
||||
|
int destinationStride, |
||||
|
int log2Size, |
||||
|
int mode, |
||||
|
int bitDepth, |
||||
|
bool filterPredictionEdges, |
||||
|
Span<ushort> scratch) |
||||
|
{ |
||||
|
DebugGuard.MustBeBetweenOrEqualTo(log2Size, 2, 5, nameof(log2Size)); |
||||
|
DebugGuard.MustBeBetweenOrEqualTo(mode, PlanarMode, 34, nameof(mode)); |
||||
|
int size = 1 << log2Size; |
||||
|
|
||||
|
switch (mode) |
||||
|
{ |
||||
|
case PlanarMode: |
||||
|
Predict<PlanarPredictionOperator>( |
||||
|
top, |
||||
|
left, |
||||
|
destination, |
||||
|
destinationStride, |
||||
|
size, |
||||
|
mode, |
||||
|
bitDepth, |
||||
|
filterPredictionEdges, |
||||
|
scratch); |
||||
|
break; |
||||
|
case DcMode: |
||||
|
Predict<DcPredictionOperator>( |
||||
|
top, |
||||
|
left, |
||||
|
destination, |
||||
|
destinationStride, |
||||
|
size, |
||||
|
mode, |
||||
|
bitDepth, |
||||
|
filterPredictionEdges, |
||||
|
scratch); |
||||
|
break; |
||||
|
default: |
||||
|
Predict<AngularPredictionOperator>( |
||||
|
top, |
||||
|
left, |
||||
|
destination, |
||||
|
destinationStride, |
||||
|
size, |
||||
|
mode, |
||||
|
bitDepth, |
||||
|
filterPredictionEdges, |
||||
|
scratch); |
||||
|
break; |
||||
|
} |
||||
|
} |
||||
|
|
||||
|
/// <summary>
|
||||
|
/// Filters prepared reference samples using the normative three-tap or strong bilinear filter.
|
||||
|
/// </summary>
|
||||
|
/// <param name="top">The unfiltered top-left, top, and top-right samples.</param>
|
||||
|
/// <param name="left">The unfiltered top-left, left, and below-left samples.</param>
|
||||
|
/// <param name="filteredTop">The destination top reference.</param>
|
||||
|
/// <param name="filteredLeft">The destination left reference.</param>
|
||||
|
/// <param name="log2Size">The base-two logarithm of the square prediction-block side.</param>
|
||||
|
/// <param name="bitDepth">The reconstructed luma precision.</param>
|
||||
|
/// <param name="strongIntraSmoothingEnabled">Whether the sequence permits strong intra smoothing.</param>
|
||||
|
public static void FilterReferenceSamples( |
||||
|
ReadOnlySpan<ushort> top, |
||||
|
ReadOnlySpan<ushort> left, |
||||
|
Span<ushort> filteredTop, |
||||
|
Span<ushort> filteredLeft, |
||||
|
int log2Size, |
||||
|
int bitDepth, |
||||
|
bool strongIntraSmoothingEnabled) |
||||
|
{ |
||||
|
DebugGuard.MustBeBetweenOrEqualTo(log2Size, 2, 5, nameof(log2Size)); |
||||
|
int size = 1 << log2Size; |
||||
|
int referenceLength = (size * 2) + 1; |
||||
|
bool useStrongSmoothing = strongIntraSmoothingEnabled && size == MaximumBlockSize; |
||||
|
if (useStrongSmoothing) |
||||
|
{ |
||||
|
int threshold = 1 << (bitDepth - 5); |
||||
|
int last = referenceLength - 1; |
||||
|
bool leftIsBilinear = Math.Abs((left[last] + left[0]) - (2 * left[size])) < threshold; |
||||
|
bool topIsBilinear = Math.Abs((top[0] + top[last]) - (2 * top[size])) < threshold; |
||||
|
useStrongSmoothing = leftIsBilinear && topIsBilinear; |
||||
|
} |
||||
|
|
||||
|
if (useStrongSmoothing) |
||||
|
{ |
||||
|
FilterReferenceBilinear(top[..referenceLength], filteredTop, size); |
||||
|
FilterReferenceBilinear(left[..referenceLength], filteredLeft, size); |
||||
|
return; |
||||
|
} |
||||
|
|
||||
|
// The corner belongs to both references. Filtering it once from the first samples on both sides keeps the
|
||||
|
// two logical arrays identical at index zero before their independent one-dimensional filters continue.
|
||||
|
ushort filteredCorner = (ushort)((left[1] + (2 * top[0]) + top[1] + 2) >> 2); |
||||
|
filteredTop[0] = filteredCorner; |
||||
|
filteredLeft[0] = filteredCorner; |
||||
|
FilterReferenceThreeTap(top[..referenceLength], filteredTop); |
||||
|
FilterReferenceThreeTap(left[..referenceLength], filteredLeft); |
||||
|
} |
||||
|
|
||||
|
/// <summary>
|
||||
|
/// Invokes one statically selected prediction operator without interface dispatch in the block loop.
|
||||
|
/// </summary>
|
||||
|
/// <typeparam name="TOperator">The selected prediction operator.</typeparam>
|
||||
|
/// <param name="top">The prepared top reference.</param>
|
||||
|
/// <param name="left">The prepared left reference.</param>
|
||||
|
/// <param name="destination">The destination block origin.</param>
|
||||
|
/// <param name="destinationStride">The destination row stride in samples.</param>
|
||||
|
/// <param name="size">The square block side in samples.</param>
|
||||
|
/// <param name="mode">The decoded prediction mode.</param>
|
||||
|
/// <param name="bitDepth">The reconstructed component precision.</param>
|
||||
|
/// <param name="filterPredictionEdges">Whether the luma edge filter applies.</param>
|
||||
|
/// <param name="scratch">The caller-owned prediction scratch.</param>
|
||||
|
[MethodImpl(MethodImplOptions.AggressiveInlining)] |
||||
|
private static void Predict<TOperator>( |
||||
|
ReadOnlySpan<ushort> top, |
||||
|
ReadOnlySpan<ushort> left, |
||||
|
Span<ushort> destination, |
||||
|
int destinationStride, |
||||
|
int size, |
||||
|
int mode, |
||||
|
int bitDepth, |
||||
|
bool filterPredictionEdges, |
||||
|
Span<ushort> scratch) |
||||
|
where TOperator : struct, IHevcIntraPredictionOperator<TOperator> |
||||
|
=> TOperator.Predict( |
||||
|
top, |
||||
|
left, |
||||
|
destination, |
||||
|
destinationStride, |
||||
|
size, |
||||
|
mode, |
||||
|
bitDepth, |
||||
|
filterPredictionEdges, |
||||
|
scratch); |
||||
|
|
||||
|
/// <summary>
|
||||
|
/// Applies the strong bilinear filter between the reference endpoints.
|
||||
|
/// </summary>
|
||||
|
/// <param name="source">The complete unfiltered reference.</param>
|
||||
|
/// <param name="destination">The complete filtered reference.</param>
|
||||
|
/// <param name="size">The prediction-block side in samples.</param>
|
||||
|
private static void FilterReferenceBilinear(ReadOnlySpan<ushort> source, Span<ushort> destination, int size) |
||||
|
{ |
||||
|
int last = source.Length - 1; |
||||
|
destination[0] = source[0]; |
||||
|
destination[last] = source[last]; |
||||
|
ref ushort sourceBase = ref MemoryMarshal.GetReference(source); |
||||
|
ref ushort destinationBase = ref MemoryMarshal.GetReference(destination); |
||||
|
uint first = source[0]; |
||||
|
uint final = source[last]; |
||||
|
int shift = BitOperations.Log2((uint)(size * 2)); |
||||
|
uint rounding = (uint)size; |
||||
|
int i = 1; |
||||
|
|
||||
|
// Each widened lane represents one reference coordinate. The weights sum to 2N, so narrowing is exact
|
||||
|
// after the rounded shift for every supported 8, 10, and 12-bit sample.
|
||||
|
if (Vector512.IsHardwareAccelerated) |
||||
|
{ |
||||
|
Vector512<uint> indices = CreateIndicesVector512(); |
||||
|
int oneVectorFromEnd = last - Vector512<ushort>.Count; |
||||
|
for (; i <= oneVectorFromEnd; i += Vector512<ushort>.Count) |
||||
|
{ |
||||
|
Vector512<uint> lowerIndices = indices + Vector512.Create((uint)i); |
||||
|
Vector512<uint> upperIndices = lowerIndices + Vector512.Create((uint)Vector512<uint>.Count); |
||||
|
Vector512<uint> lower = (((Vector512.Create((uint)last) - lowerIndices) * first) + (lowerIndices * final) + Vector512.Create(rounding)) >> shift; |
||||
|
Vector512<uint> upper = (((Vector512.Create((uint)last) - upperIndices) * first) + (upperIndices * final) + Vector512.Create(rounding)) >> shift; |
||||
|
Vector512.Narrow(lower, upper).StoreUnsafe(ref Unsafe.Add(ref destinationBase, i)); |
||||
|
} |
||||
|
} |
||||
|
|
||||
|
if (Vector256.IsHardwareAccelerated) |
||||
|
{ |
||||
|
Vector256<uint> indices = CreateIndicesVector256(); |
||||
|
int oneVectorFromEnd = last - Vector256<ushort>.Count; |
||||
|
for (; i <= oneVectorFromEnd; i += Vector256<ushort>.Count) |
||||
|
{ |
||||
|
Vector256<uint> lowerIndices = indices + Vector256.Create((uint)i); |
||||
|
Vector256<uint> upperIndices = lowerIndices + Vector256.Create((uint)Vector256<uint>.Count); |
||||
|
Vector256<uint> lower = (((Vector256.Create((uint)last) - lowerIndices) * first) + (lowerIndices * final) + Vector256.Create(rounding)) >> shift; |
||||
|
Vector256<uint> upper = (((Vector256.Create((uint)last) - upperIndices) * first) + (upperIndices * final) + Vector256.Create(rounding)) >> shift; |
||||
|
Vector256.Narrow(lower, upper).StoreUnsafe(ref Unsafe.Add(ref destinationBase, i)); |
||||
|
} |
||||
|
} |
||||
|
|
||||
|
if (Vector128.IsHardwareAccelerated) |
||||
|
{ |
||||
|
Vector128<uint> indices = CreateIndicesVector128(); |
||||
|
int oneVectorFromEnd = last - Vector128<ushort>.Count; |
||||
|
for (; i <= oneVectorFromEnd; i += Vector128<ushort>.Count) |
||||
|
{ |
||||
|
Vector128<uint> lowerIndices = indices + Vector128.Create((uint)i); |
||||
|
Vector128<uint> upperIndices = lowerIndices + Vector128.Create((uint)Vector128<uint>.Count); |
||||
|
Vector128<uint> lower = (((Vector128.Create((uint)last) - lowerIndices) * first) + (lowerIndices * final) + Vector128.Create(rounding)) >> shift; |
||||
|
Vector128<uint> upper = (((Vector128.Create((uint)last) - upperIndices) * first) + (upperIndices * final) + Vector128.Create(rounding)) >> shift; |
||||
|
Vector128.Narrow(lower, upper).StoreUnsafe(ref Unsafe.Add(ref destinationBase, i)); |
||||
|
} |
||||
|
} |
||||
|
|
||||
|
for (; i < last; i++) |
||||
|
{ |
||||
|
Unsafe.Add(ref destinationBase, i) = (ushort)((((last - i) * first) + (i * final) + rounding) >> shift); |
||||
|
} |
||||
|
} |
||||
|
|
||||
|
/// <summary>
|
||||
|
/// Applies the normal three-tap reference filter to every non-endpoint sample.
|
||||
|
/// </summary>
|
||||
|
/// <param name="source">The complete unfiltered reference.</param>
|
||||
|
/// <param name="destination">The complete filtered reference with its corner already initialized.</param>
|
||||
|
private static void FilterReferenceThreeTap(ReadOnlySpan<ushort> source, Span<ushort> destination) |
||||
|
{ |
||||
|
int last = source.Length - 1; |
||||
|
destination[last] = source[last]; |
||||
|
ref ushort sourceBase = ref MemoryMarshal.GetReference(source); |
||||
|
ref ushort destinationBase = ref MemoryMarshal.GetReference(destination); |
||||
|
int i = 1; |
||||
|
|
||||
|
if (Vector512.IsHardwareAccelerated) |
||||
|
{ |
||||
|
int oneVectorFromEnd = last - Vector512<ushort>.Count; |
||||
|
for (; i <= oneVectorFromEnd; i += Vector512<ushort>.Count) |
||||
|
{ |
||||
|
Vector512<ushort> previous = Vector512.LoadUnsafe(ref sourceBase, (nuint)(i - 1)); |
||||
|
Vector512<ushort> current = Vector512.LoadUnsafe(ref sourceBase, (nuint)i); |
||||
|
Vector512<ushort> next = Vector512.LoadUnsafe(ref sourceBase, (nuint)(i + 1)); |
||||
|
(Vector512<uint> previousLow, Vector512<uint> previousHigh) = Vector512.Widen(previous); |
||||
|
(Vector512<uint> currentLow, Vector512<uint> currentHigh) = Vector512.Widen(current); |
||||
|
(Vector512<uint> nextLow, Vector512<uint> nextHigh) = Vector512.Widen(next); |
||||
|
Vector512<uint> low = (previousLow + (currentLow << 1) + nextLow + Vector512.Create(2U)) >> 2; |
||||
|
Vector512<uint> high = (previousHigh + (currentHigh << 1) + nextHigh + Vector512.Create(2U)) >> 2; |
||||
|
Vector512.Narrow(low, high).StoreUnsafe(ref Unsafe.Add(ref destinationBase, i)); |
||||
|
} |
||||
|
} |
||||
|
|
||||
|
if (Vector256.IsHardwareAccelerated) |
||||
|
{ |
||||
|
int oneVectorFromEnd = last - Vector256<ushort>.Count; |
||||
|
for (; i <= oneVectorFromEnd; i += Vector256<ushort>.Count) |
||||
|
{ |
||||
|
Vector256<ushort> previous = Vector256.LoadUnsafe(ref sourceBase, (nuint)(i - 1)); |
||||
|
Vector256<ushort> current = Vector256.LoadUnsafe(ref sourceBase, (nuint)i); |
||||
|
Vector256<ushort> next = Vector256.LoadUnsafe(ref sourceBase, (nuint)(i + 1)); |
||||
|
(Vector256<uint> previousLow, Vector256<uint> previousHigh) = Vector256.Widen(previous); |
||||
|
(Vector256<uint> currentLow, Vector256<uint> currentHigh) = Vector256.Widen(current); |
||||
|
(Vector256<uint> nextLow, Vector256<uint> nextHigh) = Vector256.Widen(next); |
||||
|
Vector256<uint> low = (previousLow + (currentLow << 1) + nextLow + Vector256.Create(2U)) >> 2; |
||||
|
Vector256<uint> high = (previousHigh + (currentHigh << 1) + nextHigh + Vector256.Create(2U)) >> 2; |
||||
|
Vector256.Narrow(low, high).StoreUnsafe(ref Unsafe.Add(ref destinationBase, i)); |
||||
|
} |
||||
|
} |
||||
|
|
||||
|
if (Vector128.IsHardwareAccelerated) |
||||
|
{ |
||||
|
int oneVectorFromEnd = last - Vector128<ushort>.Count; |
||||
|
for (; i <= oneVectorFromEnd; i += Vector128<ushort>.Count) |
||||
|
{ |
||||
|
Vector128<ushort> previous = Vector128.LoadUnsafe(ref sourceBase, (nuint)(i - 1)); |
||||
|
Vector128<ushort> current = Vector128.LoadUnsafe(ref sourceBase, (nuint)i); |
||||
|
Vector128<ushort> next = Vector128.LoadUnsafe(ref sourceBase, (nuint)(i + 1)); |
||||
|
(Vector128<uint> previousLow, Vector128<uint> previousHigh) = Vector128.Widen(previous); |
||||
|
(Vector128<uint> currentLow, Vector128<uint> currentHigh) = Vector128.Widen(current); |
||||
|
(Vector128<uint> nextLow, Vector128<uint> nextHigh) = Vector128.Widen(next); |
||||
|
Vector128<uint> low = (previousLow + (currentLow << 1) + nextLow + Vector128.Create(2U)) >> 2; |
||||
|
Vector128<uint> high = (previousHigh + (currentHigh << 1) + nextHigh + Vector128.Create(2U)) >> 2; |
||||
|
Vector128.Narrow(low, high).StoreUnsafe(ref Unsafe.Add(ref destinationBase, i)); |
||||
|
} |
||||
|
} |
||||
|
|
||||
|
for (; i < last; i++) |
||||
|
{ |
||||
|
Unsafe.Add(ref destinationBase, i) = (ushort)((source[i - 1] + (2 * source[i]) + source[i + 1] + 2) >> 2); |
||||
|
} |
||||
|
} |
||||
|
|
||||
|
/// <summary>
|
||||
|
/// Creates the zero-through-fifteen lane indices used by 512-bit weighted interpolation.
|
||||
|
/// </summary>
|
||||
|
/// <returns>The ordered lane indices.</returns>
|
||||
|
[MethodImpl(MethodImplOptions.AggressiveInlining)] |
||||
|
private static Vector512<uint> CreateIndicesVector512() |
||||
|
=> Vector512.Create(0U, 1U, 2U, 3U, 4U, 5U, 6U, 7U, 8U, 9U, 10U, 11U, 12U, 13U, 14U, 15U); |
||||
|
|
||||
|
/// <summary>
|
||||
|
/// Creates the zero-through-seven lane indices used by 256-bit weighted interpolation.
|
||||
|
/// </summary>
|
||||
|
/// <returns>The ordered lane indices.</returns>
|
||||
|
[MethodImpl(MethodImplOptions.AggressiveInlining)] |
||||
|
private static Vector256<uint> CreateIndicesVector256() => Vector256.Create(0U, 1U, 2U, 3U, 4U, 5U, 6U, 7U); |
||||
|
|
||||
|
/// <summary>
|
||||
|
/// Creates the zero-through-three lane indices used by 128-bit weighted interpolation.
|
||||
|
/// </summary>
|
||||
|
/// <returns>The ordered lane indices.</returns>
|
||||
|
[MethodImpl(MethodImplOptions.AggressiveInlining)] |
||||
|
private static Vector128<uint> CreateIndicesVector128() => Vector128.Create(0U, 1U, 2U, 3U); |
||||
|
} |
||||
@ -0,0 +1,116 @@ |
|||||
|
// Copyright (c) Six Labors.
|
||||
|
// Licensed under the Six Labors Split License.
|
||||
|
|
||||
|
using BenchmarkDotNet.Attributes; |
||||
|
using SixLabors.ImageSharp.Formats.Heif.Hevc; |
||||
|
|
||||
|
namespace SixLabors.ImageSharp.Benchmarks.Codecs.Heif; |
||||
|
|
||||
|
/// <summary>
|
||||
|
/// Measures complete coded-frame traversal through representative HEVC intra-prediction modes.
|
||||
|
/// </summary>
|
||||
|
[MemoryDiagnoser(displayGenColumns: false)] |
||||
|
public class HevcIntraPredictionBenchmarks |
||||
|
{ |
||||
|
/// <summary>
|
||||
|
/// The coded frame width, which is an exact multiple of the maximum transform-block side.
|
||||
|
/// </summary>
|
||||
|
private const int Width = 1920; |
||||
|
|
||||
|
/// <summary>
|
||||
|
/// The coded frame height including the final padded coding-tree row for a 1080-line presentation.
|
||||
|
/// </summary>
|
||||
|
private const int Height = 1088; |
||||
|
|
||||
|
/// <summary>
|
||||
|
/// The base-two logarithm of the benchmark prediction-block side.
|
||||
|
/// </summary>
|
||||
|
private const int BlockLog2 = 5; |
||||
|
|
||||
|
/// <summary>
|
||||
|
/// The prediction-block side in samples.
|
||||
|
/// </summary>
|
||||
|
private const int BlockSize = 1 << BlockLog2; |
||||
|
|
||||
|
/// <summary>
|
||||
|
/// The prepared top reference shared by deterministic benchmark blocks.
|
||||
|
/// </summary>
|
||||
|
private readonly ushort[] top = new ushort[(BlockSize * 2) + 1]; |
||||
|
|
||||
|
/// <summary>
|
||||
|
/// The prepared left reference shared by deterministic benchmark blocks.
|
||||
|
/// </summary>
|
||||
|
private readonly ushort[] left = new ushort[(BlockSize * 2) + 1]; |
||||
|
|
||||
|
/// <summary>
|
||||
|
/// The frame-wide reconstructed prediction samples.
|
||||
|
/// </summary>
|
||||
|
private readonly ushort[] destination = new ushort[Width * Height]; |
||||
|
|
||||
|
/// <summary>
|
||||
|
/// The maximum-block scratch reused throughout each coded frame.
|
||||
|
/// </summary>
|
||||
|
private readonly ushort[] scratch = new ushort[HevcIntraPredictor.GetScratchLength(BlockLog2)]; |
||||
|
|
||||
|
/// <summary>
|
||||
|
/// Populates deterministic twelve-bit reference samples outside the measured frame traversal.
|
||||
|
/// </summary>
|
||||
|
[GlobalSetup] |
||||
|
public void Setup() |
||||
|
{ |
||||
|
this.top[0] = this.left[0] = 1365; |
||||
|
for (int i = 1; i < this.top.Length; i++) |
||||
|
{ |
||||
|
this.top[i] = (ushort)((1365 + (37 * i)) & 4095); |
||||
|
this.left[i] = (ushort)((1365 + (53 * i)) & 4095); |
||||
|
} |
||||
|
} |
||||
|
|
||||
|
/// <summary>
|
||||
|
/// Measures frame-wide planar prediction with 512-, 256-, and 128-bit row dispatch where available.
|
||||
|
/// </summary>
|
||||
|
/// <returns>The final reconstructed sample, keeping the frame output observable.</returns>
|
||||
|
[Benchmark(Baseline = true)] |
||||
|
public ushort PredictPlanarFrame() => this.PredictFrame(0); |
||||
|
|
||||
|
/// <summary>
|
||||
|
/// Measures frame-wide fractional vertical prediction using contiguous SIMD interpolation.
|
||||
|
/// </summary>
|
||||
|
/// <returns>The final reconstructed sample, keeping the frame output observable.</returns>
|
||||
|
[Benchmark] |
||||
|
public ushort PredictVerticalAngularFrame() => this.PredictFrame(30); |
||||
|
|
||||
|
/// <summary>
|
||||
|
/// Measures frame-wide horizontal prediction including the SIMD block transposition stage.
|
||||
|
/// </summary>
|
||||
|
/// <returns>The final reconstructed sample, keeping the frame output observable.</returns>
|
||||
|
[Benchmark] |
||||
|
public ushort PredictHorizontalAngularFrame() => this.PredictFrame(2); |
||||
|
|
||||
|
/// <summary>
|
||||
|
/// Reconstructs every maximum-size prediction block in the coded benchmark frame.
|
||||
|
/// </summary>
|
||||
|
/// <param name="mode">The HEVC intra-prediction mode.</param>
|
||||
|
/// <returns>The final reconstructed sample.</returns>
|
||||
|
private ushort PredictFrame(int mode) |
||||
|
{ |
||||
|
for (int y = 0; y < Height; y += BlockSize) |
||||
|
{ |
||||
|
for (int x = 0; x < Width; x += BlockSize) |
||||
|
{ |
||||
|
HevcIntraPredictor.Predict( |
||||
|
this.top, |
||||
|
this.left, |
||||
|
this.destination.AsSpan((y * Width) + x), |
||||
|
Width, |
||||
|
BlockLog2, |
||||
|
mode, |
||||
|
12, |
||||
|
true, |
||||
|
this.scratch); |
||||
|
} |
||||
|
} |
||||
|
|
||||
|
return this.destination[^1]; |
||||
|
} |
||||
|
} |
||||
@ -0,0 +1,396 @@ |
|||||
|
// Copyright (c) Six Labors.
|
||||
|
// Licensed under the Six Labors Split License.
|
||||
|
|
||||
|
using System.Numerics; |
||||
|
using SixLabors.ImageSharp.Formats.Heif.Hevc; |
||||
|
|
||||
|
namespace SixLabors.ImageSharp.Tests.Formats.Heif.Hevc; |
||||
|
|
||||
|
/// <summary>
|
||||
|
/// Verifies HEVC planar, DC, angular, reference-filter, and SIMD prediction behavior.
|
||||
|
/// </summary>
|
||||
|
[Trait("Format", "Heic")] |
||||
|
public class HevcIntraPredictorTests |
||||
|
{ |
||||
|
/// <summary>
|
||||
|
/// Verifies fixed four-by-four prediction results derived from the HEVC intra-prediction equations.
|
||||
|
/// </summary>
|
||||
|
[Fact] |
||||
|
public void PredictsKnownFourByFourBlocks() |
||||
|
{ |
||||
|
ushort[] top = [64, 80, 96, 112, 128, 144, 160, 176, 192]; |
||||
|
ushort[] left = [64, 70, 76, 82, 88, 94, 100, 106, 112]; |
||||
|
int[] modes = [0, 1, 2, 9, 18, 30, 34]; |
||||
|
ushort[][] expected = |
||||
|
[ |
||||
|
[83, 97, 110, 123, 87, 97, 108, 118, 90, 98, 105, 113, 93, 98, 103, 108], |
||||
|
[84, 93, 97, 101, 88, 92, 92, 92, 90, 92, 92, 92, 91, 92, 92, 92], |
||||
|
[76, 82, 88, 94, 82, 88, 94, 100, 88, 94, 100, 106, 94, 100, 106, 112], |
||||
|
[70, 71, 71, 72, 76, 77, 77, 78, 82, 83, 83, 84, 88, 89, 89, 90], |
||||
|
[64, 80, 96, 112, 70, 64, 80, 96, 76, 70, 64, 80, 82, 76, 70, 64], |
||||
|
[87, 103, 119, 135, 93, 109, 125, 141, 100, 116, 132, 148, 106, 122, 138, 154], |
||||
|
[96, 112, 128, 144, 112, 128, 144, 160, 128, 144, 160, 176, 144, 160, 176, 192] |
||||
|
]; |
||||
|
|
||||
|
const int size = 4; |
||||
|
const int stride = 7; |
||||
|
ushort[] destination = new ushort[stride * size]; |
||||
|
ushort[] scratch = new ushort[HevcIntraPredictor.GetScratchLength(2)]; |
||||
|
for (int caseIndex = 0; caseIndex < modes.Length; caseIndex++) |
||||
|
{ |
||||
|
destination.AsSpan().Fill(ushort.MaxValue); |
||||
|
int mode = modes[caseIndex]; |
||||
|
HevcIntraPredictor.Predict(top, left, destination, stride, 2, mode, 8, mode == 1, scratch); |
||||
|
|
||||
|
for (int y = 0; y < size; y++) |
||||
|
{ |
||||
|
ReadOnlySpan<ushort> expectedRow = expected[caseIndex].AsSpan(y * size, size); |
||||
|
ReadOnlySpan<ushort> actualRow = destination.AsSpan(y * stride, size); |
||||
|
Assert.True(expectedRow.SequenceEqual(actualRow), $"Mode {mode}, row {y} did not match the fixed HEVC result."); |
||||
|
} |
||||
|
} |
||||
|
} |
||||
|
|
||||
|
/// <summary>
|
||||
|
/// Verifies the optional luma boundary filter for the pure horizontal and vertical modes.
|
||||
|
/// </summary>
|
||||
|
[Fact] |
||||
|
public void FiltersPureDirectionPredictionEdges() |
||||
|
{ |
||||
|
ushort[] top = [64, 80, 96, 112, 128, 144, 160, 176, 192]; |
||||
|
ushort[] left = [64, 70, 76, 82, 88, 94, 100, 106, 112]; |
||||
|
ushort[] scratch = new ushort[HevcIntraPredictor.GetScratchLength(2)]; |
||||
|
ushort[] horizontal = new ushort[16]; |
||||
|
ushort[] vertical = new ushort[16]; |
||||
|
|
||||
|
HevcIntraPredictor.Predict(top, left, horizontal, 4, 2, 10, 8, true, scratch); |
||||
|
HevcIntraPredictor.Predict(top, left, vertical, 4, 2, 26, 8, true, scratch); |
||||
|
|
||||
|
ushort[] expectedHorizontal = [78, 86, 94, 102, 76, 76, 76, 76, 82, 82, 82, 82, 88, 88, 88, 88]; |
||||
|
ushort[] expectedVertical = [83, 96, 112, 128, 86, 96, 112, 128, 89, 96, 112, 128, 92, 96, 112, 128]; |
||||
|
Assert.True(expectedHorizontal.AsSpan().SequenceEqual(horizontal)); |
||||
|
Assert.True(expectedVertical.AsSpan().SequenceEqual(vertical)); |
||||
|
} |
||||
|
|
||||
|
/// <summary>
|
||||
|
/// Verifies exact three-tap filtering, including the shared top-left sample.
|
||||
|
/// </summary>
|
||||
|
[Fact] |
||||
|
public void FiltersReferenceSamplesWithThreeTapKernel() |
||||
|
{ |
||||
|
ushort[] top = [64, 80, 96, 112, 128, 144, 160, 176, 192]; |
||||
|
ushort[] left = [64, 70, 76, 82, 88, 94, 100, 106, 112]; |
||||
|
ushort[] filteredTop = new ushort[top.Length]; |
||||
|
ushort[] filteredLeft = new ushort[left.Length]; |
||||
|
|
||||
|
HevcIntraPredictor.FilterReferenceSamples(top, left, filteredTop, filteredLeft, 2, 8, true); |
||||
|
|
||||
|
ushort[] expectedTop = [70, 80, 96, 112, 128, 144, 160, 176, 192]; |
||||
|
ushort[] expectedLeft = [70, 70, 76, 82, 88, 94, 100, 106, 112]; |
||||
|
Assert.True(expectedTop.AsSpan().SequenceEqual(filteredTop)); |
||||
|
Assert.True(expectedLeft.AsSpan().SequenceEqual(filteredLeft)); |
||||
|
} |
||||
|
|
||||
|
/// <summary>
|
||||
|
/// Verifies that eligible thirty-two-sample references use strong bilinear smoothing rather than local three-tap filtering.
|
||||
|
/// </summary>
|
||||
|
[Fact] |
||||
|
public void StrongSmoothingReplacesEligibleNonlinearReferences() |
||||
|
{ |
||||
|
const int size = 32; |
||||
|
ushort[] top = new ushort[(size * 2) + 1]; |
||||
|
ushort[] left = new ushort[top.Length]; |
||||
|
ushort[] filteredTop = new ushort[top.Length]; |
||||
|
ushort[] filteredLeft = new ushort[left.Length]; |
||||
|
for (int i = 0; i < top.Length; i++) |
||||
|
{ |
||||
|
top[i] = (ushort)(100 + i + (i % 3)); |
||||
|
left[i] = (ushort)(100 + (2 * i) + (i % 5)); |
||||
|
} |
||||
|
|
||||
|
// Strong smoothing is selected from the endpoint/midpoint test, so keep those six values exactly bilinear
|
||||
|
// while the remaining samples deliberately differ from the expected straight lines.
|
||||
|
top[0] = left[0] = 100; |
||||
|
top[size] = 132; |
||||
|
top[size * 2] = 164; |
||||
|
left[size] = 164; |
||||
|
left[size * 2] = 228; |
||||
|
|
||||
|
HevcIntraPredictor.FilterReferenceSamples(top, left, filteredTop, filteredLeft, 5, 10, true); |
||||
|
|
||||
|
for (int i = 0; i < top.Length; i++) |
||||
|
{ |
||||
|
Assert.Equal((ushort)(100 + i), filteredTop[i]); |
||||
|
Assert.Equal((ushort)(100 + (2 * i)), filteredLeft[i]); |
||||
|
} |
||||
|
} |
||||
|
|
||||
|
/// <summary>
|
||||
|
/// Compares every prediction mode and block width with a specification-shaped scalar oracle.
|
||||
|
/// </summary>
|
||||
|
/// <param name="log2Size">The base-two logarithm of the tested block side.</param>
|
||||
|
/// <param name="bitDepth">The reconstructed component precision.</param>
|
||||
|
[Theory] |
||||
|
[InlineData(2, 8)] |
||||
|
[InlineData(3, 10)] |
||||
|
[InlineData(4, 12)] |
||||
|
[InlineData(5, 12)] |
||||
|
public void EveryModeMatchesScalarOracle(int log2Size, int bitDepth) |
||||
|
{ |
||||
|
int size = 1 << log2Size; |
||||
|
int maximum = (1 << bitDepth) - 1; |
||||
|
int referenceLength = (size * 2) + 1; |
||||
|
ushort[] top = new ushort[referenceLength]; |
||||
|
ushort[] left = new ushort[referenceLength]; |
||||
|
top[0] = left[0] = (ushort)(maximum / 3); |
||||
|
for (int i = 1; i < referenceLength; i++) |
||||
|
{ |
||||
|
top[i] = (ushort)((top[0] + (37 * i) + (3 * size)) & maximum); |
||||
|
left[i] = (ushort)((left[0] + (53 * i) + (5 * size)) & maximum); |
||||
|
} |
||||
|
|
||||
|
int stride = size + 3; |
||||
|
ushort[] expected = new ushort[stride * size]; |
||||
|
ushort[] actual = new ushort[stride * size]; |
||||
|
ushort[] scratch = new ushort[HevcIntraPredictor.GetScratchLength(log2Size)]; |
||||
|
for (int mode = 0; mode <= 34; mode++) |
||||
|
{ |
||||
|
expected.AsSpan().Clear(); |
||||
|
actual.AsSpan().Clear(); |
||||
|
PredictScalar(top, left, expected, stride, size, mode, bitDepth, true); |
||||
|
HevcIntraPredictor.Predict(top, left, actual, stride, log2Size, mode, bitDepth, true, scratch); |
||||
|
Assert.True(expected.AsSpan().SequenceEqual(actual), $"Mode {mode}, size {size}, and bit depth {bitDepth} did not match the scalar oracle."); |
||||
|
} |
||||
|
} |
||||
|
|
||||
|
/// <summary>
|
||||
|
/// Reconstructs one block directly from the HEVC planar, DC, and angular prediction equations.
|
||||
|
/// </summary>
|
||||
|
/// <param name="top">The top reference samples.</param>
|
||||
|
/// <param name="left">The left reference samples.</param>
|
||||
|
/// <param name="destination">The destination block origin.</param>
|
||||
|
/// <param name="destinationStride">The destination row stride.</param>
|
||||
|
/// <param name="size">The square block side.</param>
|
||||
|
/// <param name="mode">The prediction mode.</param>
|
||||
|
/// <param name="bitDepth">The reconstructed component precision.</param>
|
||||
|
/// <param name="filterPredictionEdges">Whether the luma edge filter applies.</param>
|
||||
|
private static void PredictScalar( |
||||
|
ReadOnlySpan<ushort> top, |
||||
|
ReadOnlySpan<ushort> left, |
||||
|
Span<ushort> destination, |
||||
|
int destinationStride, |
||||
|
int size, |
||||
|
int mode, |
||||
|
int bitDepth, |
||||
|
bool filterPredictionEdges) |
||||
|
{ |
||||
|
if (mode == 0) |
||||
|
{ |
||||
|
int shift = BitOperations.Log2((uint)size) + 1; |
||||
|
for (int y = 0; y < size; y++) |
||||
|
{ |
||||
|
for (int x = 0; x < size; x++) |
||||
|
{ |
||||
|
int horizontal = ((size - x - 1) * left[y + 1]) + ((x + 1) * top[size]); |
||||
|
int vertical = ((size - y - 1) * top[x + 1]) + ((y + 1) * left[size]); |
||||
|
destination[(y * destinationStride) + x] = (ushort)((horizontal + vertical + size) >> shift); |
||||
|
} |
||||
|
} |
||||
|
|
||||
|
return; |
||||
|
} |
||||
|
|
||||
|
if (mode == 1) |
||||
|
{ |
||||
|
PredictDcScalar(top, left, destination, destinationStride, size, filterPredictionEdges); |
||||
|
return; |
||||
|
} |
||||
|
|
||||
|
if (mode == 10) |
||||
|
{ |
||||
|
PredictHorizontalScalar(top, left, destination, destinationStride, size, bitDepth, filterPredictionEdges); |
||||
|
return; |
||||
|
} |
||||
|
|
||||
|
if (mode == 26) |
||||
|
{ |
||||
|
PredictVerticalScalar(top, left, destination, destinationStride, size, bitDepth, filterPredictionEdges); |
||||
|
return; |
||||
|
} |
||||
|
|
||||
|
PredictAngularScalar(top, left, destination, destinationStride, size, mode); |
||||
|
} |
||||
|
|
||||
|
/// <summary>
|
||||
|
/// Reconstructs a scalar DC block and its optional boundary filter.
|
||||
|
/// </summary>
|
||||
|
/// <param name="top">The top reference samples.</param>
|
||||
|
/// <param name="left">The left reference samples.</param>
|
||||
|
/// <param name="destination">The destination block origin.</param>
|
||||
|
/// <param name="destinationStride">The destination row stride.</param>
|
||||
|
/// <param name="size">The square block side.</param>
|
||||
|
/// <param name="filterPredictionEdges">Whether the luma edge filter applies.</param>
|
||||
|
private static void PredictDcScalar( |
||||
|
ReadOnlySpan<ushort> top, |
||||
|
ReadOnlySpan<ushort> left, |
||||
|
Span<ushort> destination, |
||||
|
int destinationStride, |
||||
|
int size, |
||||
|
bool filterPredictionEdges) |
||||
|
{ |
||||
|
int sum = 0; |
||||
|
for (int i = 1; i <= size; i++) |
||||
|
{ |
||||
|
sum += top[i] + left[i]; |
||||
|
} |
||||
|
|
||||
|
ushort dc = (ushort)((sum + size) >> (BitOperations.Log2((uint)size) + 1)); |
||||
|
for (int y = 0; y < size; y++) |
||||
|
{ |
||||
|
destination.Slice(y * destinationStride, size).Fill(dc); |
||||
|
} |
||||
|
|
||||
|
if (!filterPredictionEdges) |
||||
|
{ |
||||
|
return; |
||||
|
} |
||||
|
|
||||
|
destination[0] = (ushort)((top[1] + left[1] + (2 * dc) + 2) >> 2); |
||||
|
for (int i = 1; i < size; i++) |
||||
|
{ |
||||
|
destination[i] = (ushort)((top[i + 1] + (3 * dc) + 2) >> 2); |
||||
|
destination[i * destinationStride] = (ushort)((left[i + 1] + (3 * dc) + 2) >> 2); |
||||
|
} |
||||
|
} |
||||
|
|
||||
|
/// <summary>
|
||||
|
/// Reconstructs scalar horizontal prediction and its optional boundary filter.
|
||||
|
/// </summary>
|
||||
|
/// <param name="top">The top reference samples.</param>
|
||||
|
/// <param name="left">The left reference samples.</param>
|
||||
|
/// <param name="destination">The destination block origin.</param>
|
||||
|
/// <param name="destinationStride">The destination row stride.</param>
|
||||
|
/// <param name="size">The square block side.</param>
|
||||
|
/// <param name="bitDepth">The reconstructed component precision.</param>
|
||||
|
/// <param name="filterPredictionEdges">Whether the luma edge filter applies.</param>
|
||||
|
private static void PredictHorizontalScalar( |
||||
|
ReadOnlySpan<ushort> top, |
||||
|
ReadOnlySpan<ushort> left, |
||||
|
Span<ushort> destination, |
||||
|
int destinationStride, |
||||
|
int size, |
||||
|
int bitDepth, |
||||
|
bool filterPredictionEdges) |
||||
|
{ |
||||
|
for (int y = 0; y < size; y++) |
||||
|
{ |
||||
|
destination.Slice(y * destinationStride, size).Fill(left[y + 1]); |
||||
|
} |
||||
|
|
||||
|
if (filterPredictionEdges) |
||||
|
{ |
||||
|
int maximum = (1 << bitDepth) - 1; |
||||
|
for (int x = 0; x < size; x++) |
||||
|
{ |
||||
|
destination[x] = (ushort)Math.Clamp(destination[x] + ((top[x + 1] - top[0]) >> 1), 0, maximum); |
||||
|
} |
||||
|
} |
||||
|
} |
||||
|
|
||||
|
/// <summary>
|
||||
|
/// Reconstructs scalar vertical prediction and its optional boundary filter.
|
||||
|
/// </summary>
|
||||
|
/// <param name="top">The top reference samples.</param>
|
||||
|
/// <param name="left">The left reference samples.</param>
|
||||
|
/// <param name="destination">The destination block origin.</param>
|
||||
|
/// <param name="destinationStride">The destination row stride.</param>
|
||||
|
/// <param name="size">The square block side.</param>
|
||||
|
/// <param name="bitDepth">The reconstructed component precision.</param>
|
||||
|
/// <param name="filterPredictionEdges">Whether the luma edge filter applies.</param>
|
||||
|
private static void PredictVerticalScalar( |
||||
|
ReadOnlySpan<ushort> top, |
||||
|
ReadOnlySpan<ushort> left, |
||||
|
Span<ushort> destination, |
||||
|
int destinationStride, |
||||
|
int size, |
||||
|
int bitDepth, |
||||
|
bool filterPredictionEdges) |
||||
|
{ |
||||
|
int maximum = (1 << bitDepth) - 1; |
||||
|
for (int y = 0; y < size; y++) |
||||
|
{ |
||||
|
top.Slice(1, size).CopyTo(destination[(y * destinationStride)..]); |
||||
|
if (filterPredictionEdges) |
||||
|
{ |
||||
|
int offset = y * destinationStride; |
||||
|
destination[offset] = (ushort)Math.Clamp(destination[offset] + ((left[y + 1] - left[0]) >> 1), 0, maximum); |
||||
|
} |
||||
|
} |
||||
|
} |
||||
|
|
||||
|
/// <summary>
|
||||
|
/// Reconstructs a scalar angular block, including negative-reference extension and horizontal transposition.
|
||||
|
/// </summary>
|
||||
|
/// <param name="top">The top reference samples.</param>
|
||||
|
/// <param name="left">The left reference samples.</param>
|
||||
|
/// <param name="destination">The destination block origin.</param>
|
||||
|
/// <param name="destinationStride">The destination row stride.</param>
|
||||
|
/// <param name="size">The square block side.</param>
|
||||
|
/// <param name="mode">The angular prediction mode.</param>
|
||||
|
private static void PredictAngularScalar( |
||||
|
ReadOnlySpan<ushort> top, |
||||
|
ReadOnlySpan<ushort> left, |
||||
|
Span<ushort> destination, |
||||
|
int destinationStride, |
||||
|
int size, |
||||
|
int mode) |
||||
|
{ |
||||
|
ReadOnlySpan<int> angles = [0, 2, 5, 9, 13, 17, 21, 26, 32]; |
||||
|
ReadOnlySpan<int> inverseAngles = [0, 4096, 1638, 910, 630, 482, 390, 315, 256]; |
||||
|
bool vertical = mode >= 18; |
||||
|
int angleMode = vertical ? mode - 26 : 10 - mode; |
||||
|
int absoluteAngleMode = Math.Abs(angleMode); |
||||
|
int angle = angles[absoluteAngleMode] * Math.Sign(angleMode); |
||||
|
ReadOnlySpan<ushort> main = vertical ? top : left; |
||||
|
ReadOnlySpan<ushort> side = vertical ? left : top; |
||||
|
int mainOrigin = size * 2; |
||||
|
int[] extendedMain = new int[(4 * size) + 1]; |
||||
|
for (int i = 0; i < main.Length; i++) |
||||
|
{ |
||||
|
extendedMain[mainOrigin + i] = main[i]; |
||||
|
} |
||||
|
|
||||
|
if (angle < 0) |
||||
|
{ |
||||
|
int inverseAngleSum = 128; |
||||
|
for (int index = -1; index > ((size * angle) >> 5); index--) |
||||
|
{ |
||||
|
inverseAngleSum += inverseAngles[absoluteAngleMode]; |
||||
|
extendedMain[mainOrigin + index] = side[inverseAngleSum >> 8]; |
||||
|
} |
||||
|
} |
||||
|
|
||||
|
ushort[] temporary = new ushort[size * size]; |
||||
|
for (int y = 0, deltaPosition = angle; y < size; y++, deltaPosition += angle) |
||||
|
{ |
||||
|
int deltaInteger = deltaPosition >> 5; |
||||
|
int deltaFraction = deltaPosition & 31; |
||||
|
for (int x = 0; x < size; x++) |
||||
|
{ |
||||
|
int index = mainOrigin + x + deltaInteger + 1; |
||||
|
temporary[(y * size) + x] = deltaFraction == 0 |
||||
|
? (ushort)extendedMain[index] |
||||
|
: (ushort)(((extendedMain[index] * (32 - deltaFraction)) + (extendedMain[index + 1] * deltaFraction) + 16) >> 5); |
||||
|
} |
||||
|
} |
||||
|
|
||||
|
for (int y = 0; y < size; y++) |
||||
|
{ |
||||
|
for (int x = 0; x < size; x++) |
||||
|
{ |
||||
|
int sourceIndex = vertical ? (y * size) + x : (x * size) + y; |
||||
|
destination[(y * destinationStride) + x] = temporary[sourceIndex]; |
||||
|
} |
||||
|
} |
||||
|
} |
||||
|
} |
||||
Loading…
Reference in new issue