mirror of https://github.com/SixLabors/ImageSharp
James Jackson-South
2 months ago
7 changed files with 1294 additions and 6 deletions
@ -0,0 +1,523 @@ |
|||||
|
// Copyright (c) Six Labors.
|
||||
|
// Licensed under the Six Labors Split License.
|
||||
|
|
||||
|
using System.Runtime.CompilerServices; |
||||
|
using System.Runtime.InteropServices; |
||||
|
using System.Runtime.Intrinsics; |
||||
|
using SixLabors.ImageSharp.Formats.Heif.Av1.Transform; |
||||
|
|
||||
|
namespace SixLabors.ImageSharp.Formats.Heif.Hevc; |
||||
|
|
||||
|
internal static partial class HevcInverseTransformer |
||||
|
{ |
||||
|
/// <summary>
|
||||
|
/// Calculates the disjoint odd-frequency groups that seed the HEVC partial-butterfly reconstruction.
|
||||
|
/// </summary>
|
||||
|
/// <typeparam name="TOperator">The selected inverse-DCT operator.</typeparam>
|
||||
|
/// <param name="source">The frequency rows followed by contiguous independent lines.</param>
|
||||
|
/// <param name="groups">The destination group rows.</param>
|
||||
|
/// <param name="lineCount">The number of independent lines transformed together.</param>
|
||||
|
private static void PopulateButterflyGroups<TOperator>(ReadOnlySpan<int> source, Span<int> groups, int lineCount) |
||||
|
where TOperator : struct, IHevcInverseTransformOperator<TOperator> |
||||
|
{ |
||||
|
int size = TOperator.Size; |
||||
|
int groupOffset = 0; |
||||
|
for (int frequencyStep = 2; frequencyStep < size; frequencyStep <<= 1) |
||||
|
{ |
||||
|
int outputCount = size / frequencyStep; |
||||
|
int firstFrequency = frequencyStep >> 1; |
||||
|
for (int position = 0; position < outputCount; position++) |
||||
|
{ |
||||
|
PopulateButterflyGroupRow<TOperator>( |
||||
|
source, |
||||
|
groups.Slice((groupOffset + position) * lineCount, lineCount), |
||||
|
lineCount, |
||||
|
firstFrequency, |
||||
|
frequencyStep, |
||||
|
position); |
||||
|
} |
||||
|
|
||||
|
groupOffset += outputCount; |
||||
|
} |
||||
|
|
||||
|
// The deepest even group contains the DC term and the transform's Nyquist-frequency term. It remains a
|
||||
|
// two-element group for every supported DCT size and closes the recursive butterfly hierarchy.
|
||||
|
for (int position = 0; position < 2; position++) |
||||
|
{ |
||||
|
PopulateButterflyGroupRow<TOperator>( |
||||
|
source, |
||||
|
groups.Slice((groupOffset + position) * lineCount, lineCount), |
||||
|
lineCount, |
||||
|
0, |
||||
|
size >> 1, |
||||
|
position); |
||||
|
} |
||||
|
} |
||||
|
|
||||
|
/// <summary>
|
||||
|
/// Calculates one partial-butterfly group row across all independent lines.
|
||||
|
/// </summary>
|
||||
|
/// <typeparam name="TOperator">The selected inverse-DCT operator.</typeparam>
|
||||
|
/// <param name="source">The complete frequency-row input.</param>
|
||||
|
/// <param name="destination">The destination group row.</param>
|
||||
|
/// <param name="lineCount">The number of independent lines.</param>
|
||||
|
/// <param name="firstFrequency">The first frequency included by the group.</param>
|
||||
|
/// <param name="frequencyStep">The distance between included frequencies.</param>
|
||||
|
/// <param name="position">The group-relative spatial coordinate.</param>
|
||||
|
private static void PopulateButterflyGroupRow<TOperator>( |
||||
|
ReadOnlySpan<int> source, |
||||
|
Span<int> destination, |
||||
|
int lineCount, |
||||
|
int firstFrequency, |
||||
|
int frequencyStep, |
||||
|
int position) |
||||
|
where TOperator : struct, IHevcInverseTransformOperator<TOperator> |
||||
|
{ |
||||
|
ref int sourceBase = ref MemoryMarshal.GetReference(source); |
||||
|
ref int destinationBase = ref MemoryMarshal.GetReference(destination); |
||||
|
int x = 0; |
||||
|
|
||||
|
if (Vector512.IsHardwareAccelerated) |
||||
|
{ |
||||
|
int oneVectorFromEnd = lineCount - Vector512<int>.Count; |
||||
|
for (; x <= oneVectorFromEnd; x += Vector512<int>.Count) |
||||
|
{ |
||||
|
Vector512<int> sum = Vector512<int>.Zero; |
||||
|
for (int frequency = firstFrequency; frequency < TOperator.Size; frequency += frequencyStep) |
||||
|
{ |
||||
|
Vector512<int> values = Vector512.LoadUnsafe(ref sourceBase, (nuint)((frequency * lineCount) + x)); |
||||
|
sum += values * Vector512.Create(TOperator.GetCoefficient(frequency, position)); |
||||
|
} |
||||
|
|
||||
|
sum.StoreUnsafe(ref destinationBase, (nuint)x); |
||||
|
} |
||||
|
} |
||||
|
|
||||
|
if (Vector256.IsHardwareAccelerated) |
||||
|
{ |
||||
|
int oneVectorFromEnd = lineCount - Vector256<int>.Count; |
||||
|
for (; x <= oneVectorFromEnd; x += Vector256<int>.Count) |
||||
|
{ |
||||
|
Vector256<int> sum = Vector256<int>.Zero; |
||||
|
for (int frequency = firstFrequency; frequency < TOperator.Size; frequency += frequencyStep) |
||||
|
{ |
||||
|
Vector256<int> values = Vector256.LoadUnsafe(ref sourceBase, (nuint)((frequency * lineCount) + x)); |
||||
|
sum += values * Vector256.Create(TOperator.GetCoefficient(frequency, position)); |
||||
|
} |
||||
|
|
||||
|
sum.StoreUnsafe(ref destinationBase, (nuint)x); |
||||
|
} |
||||
|
} |
||||
|
|
||||
|
if (Vector128.IsHardwareAccelerated) |
||||
|
{ |
||||
|
int oneVectorFromEnd = lineCount - Vector128<int>.Count; |
||||
|
for (; x <= oneVectorFromEnd; x += Vector128<int>.Count) |
||||
|
{ |
||||
|
Vector128<int> sum = Vector128<int>.Zero; |
||||
|
for (int frequency = firstFrequency; frequency < TOperator.Size; frequency += frequencyStep) |
||||
|
{ |
||||
|
Vector128<int> values = Vector128.LoadUnsafe(ref sourceBase, (nuint)((frequency * lineCount) + x)); |
||||
|
sum += values * Vector128.Create(TOperator.GetCoefficient(frequency, position)); |
||||
|
} |
||||
|
|
||||
|
sum.StoreUnsafe(ref destinationBase, (nuint)x); |
||||
|
} |
||||
|
} |
||||
|
|
||||
|
for (; x < lineCount; x++) |
||||
|
{ |
||||
|
int sum = 0; |
||||
|
for (int frequency = firstFrequency; frequency < TOperator.Size; frequency += frequencyStep) |
||||
|
{ |
||||
|
sum += source[(frequency * lineCount) + x] * TOperator.GetCoefficient(frequency, position); |
||||
|
} |
||||
|
|
||||
|
destination[x] = sum; |
||||
|
} |
||||
|
} |
||||
|
|
||||
|
/// <summary>
|
||||
|
/// Expands the disjoint partial-butterfly groups into spatial rows.
|
||||
|
/// </summary>
|
||||
|
/// <typeparam name="TOperator">The selected inverse-DCT operator.</typeparam>
|
||||
|
/// <param name="initial">The buffer containing every disjoint group.</param>
|
||||
|
/// <param name="alternate">The alternate expansion buffer.</param>
|
||||
|
/// <param name="lineCount">The number of independent lines transformed together.</param>
|
||||
|
/// <param name="shift">The rounded right shift applied at the final hierarchy level.</param>
|
||||
|
/// <param name="minimum">The inclusive output minimum.</param>
|
||||
|
/// <param name="maximum">The inclusive output maximum.</param>
|
||||
|
/// <returns>The buffer containing the completed spatial rows.</returns>
|
||||
|
private static Span<int> CombineButterflyGroups<TOperator>( |
||||
|
Span<int> initial, |
||||
|
Span<int> alternate, |
||||
|
int lineCount, |
||||
|
int shift, |
||||
|
int minimum, |
||||
|
int maximum) |
||||
|
where TOperator : struct, IHevcInverseTransformOperator<TOperator> |
||||
|
{ |
||||
|
int size = TOperator.Size; |
||||
|
int combinedSize = 2; |
||||
|
int combinedStart = size - combinedSize; |
||||
|
bool currentIsInitial = true; |
||||
|
while (combinedSize < size) |
||||
|
{ |
||||
|
int oddStart = combinedStart - combinedSize; |
||||
|
bool finalLevel = (combinedSize << 1) == size; |
||||
|
ReadOnlySpan<int> even = currentIsInitial ? initial : alternate; |
||||
|
Span<int> destination = currentIsInitial ? alternate : initial; |
||||
|
|
||||
|
for (int position = 0; position < combinedSize; position++) |
||||
|
{ |
||||
|
ReadOnlySpan<int> evenRow = even.Slice((combinedStart + position) * lineCount, lineCount); |
||||
|
ReadOnlySpan<int> oddRow = initial.Slice((oddStart + position) * lineCount, lineCount); |
||||
|
Span<int> positiveRow = destination.Slice((oddStart + position) * lineCount, lineCount); |
||||
|
Span<int> negativeRow = destination.Slice((oddStart + (2 * combinedSize) - 1 - position) * lineCount, lineCount); |
||||
|
CombineButterflyRows(evenRow, oddRow, positiveRow, negativeRow, finalLevel, shift, minimum, maximum); |
||||
|
} |
||||
|
|
||||
|
combinedStart = oddStart; |
||||
|
combinedSize <<= 1; |
||||
|
currentIsInitial = !currentIsInitial; |
||||
|
} |
||||
|
|
||||
|
return currentIsInitial ? initial : alternate; |
||||
|
} |
||||
|
|
||||
|
/// <summary>
|
||||
|
/// Combines one symmetric pair of partial-butterfly rows.
|
||||
|
/// </summary>
|
||||
|
/// <param name="even">The even-frequency contribution.</param>
|
||||
|
/// <param name="odd">The odd-frequency contribution.</param>
|
||||
|
/// <param name="positive">The destination receiving the added contribution.</param>
|
||||
|
/// <param name="negative">The destination receiving the subtracted contribution.</param>
|
||||
|
/// <param name="roundAndClip">Whether this is the final hierarchy level.</param>
|
||||
|
/// <param name="shift">The rounded right shift applied at the final hierarchy level.</param>
|
||||
|
/// <param name="minimum">The inclusive output minimum.</param>
|
||||
|
/// <param name="maximum">The inclusive output maximum.</param>
|
||||
|
private static void CombineButterflyRows( |
||||
|
ReadOnlySpan<int> even, |
||||
|
ReadOnlySpan<int> odd, |
||||
|
Span<int> positive, |
||||
|
Span<int> negative, |
||||
|
bool roundAndClip, |
||||
|
int shift, |
||||
|
int minimum, |
||||
|
int maximum) |
||||
|
{ |
||||
|
ref int evenBase = ref MemoryMarshal.GetReference(even); |
||||
|
ref int oddBase = ref MemoryMarshal.GetReference(odd); |
||||
|
ref int positiveBase = ref MemoryMarshal.GetReference(positive); |
||||
|
ref int negativeBase = ref MemoryMarshal.GetReference(negative); |
||||
|
int x = 0; |
||||
|
|
||||
|
if (Vector512.IsHardwareAccelerated) |
||||
|
{ |
||||
|
int oneVectorFromEnd = even.Length - Vector512<int>.Count; |
||||
|
for (; x <= oneVectorFromEnd; x += Vector512<int>.Count) |
||||
|
{ |
||||
|
Vector512<int> evenValues = Vector512.LoadUnsafe(ref evenBase, (nuint)x); |
||||
|
Vector512<int> oddValues = Vector512.LoadUnsafe(ref oddBase, (nuint)x); |
||||
|
Vector512<int> added = evenValues + oddValues; |
||||
|
Vector512<int> subtracted = evenValues - oddValues; |
||||
|
if (roundAndClip) |
||||
|
{ |
||||
|
added = RoundShiftAndClamp(added, shift, minimum, maximum); |
||||
|
subtracted = RoundShiftAndClamp(subtracted, shift, minimum, maximum); |
||||
|
} |
||||
|
|
||||
|
added.StoreUnsafe(ref positiveBase, (nuint)x); |
||||
|
subtracted.StoreUnsafe(ref negativeBase, (nuint)x); |
||||
|
} |
||||
|
} |
||||
|
|
||||
|
if (Vector256.IsHardwareAccelerated) |
||||
|
{ |
||||
|
int oneVectorFromEnd = even.Length - Vector256<int>.Count; |
||||
|
for (; x <= oneVectorFromEnd; x += Vector256<int>.Count) |
||||
|
{ |
||||
|
Vector256<int> evenValues = Vector256.LoadUnsafe(ref evenBase, (nuint)x); |
||||
|
Vector256<int> oddValues = Vector256.LoadUnsafe(ref oddBase, (nuint)x); |
||||
|
Vector256<int> added = evenValues + oddValues; |
||||
|
Vector256<int> subtracted = evenValues - oddValues; |
||||
|
if (roundAndClip) |
||||
|
{ |
||||
|
added = RoundShiftAndClamp(added, shift, minimum, maximum); |
||||
|
subtracted = RoundShiftAndClamp(subtracted, shift, minimum, maximum); |
||||
|
} |
||||
|
|
||||
|
added.StoreUnsafe(ref positiveBase, (nuint)x); |
||||
|
subtracted.StoreUnsafe(ref negativeBase, (nuint)x); |
||||
|
} |
||||
|
} |
||||
|
|
||||
|
if (Vector128.IsHardwareAccelerated) |
||||
|
{ |
||||
|
int oneVectorFromEnd = even.Length - Vector128<int>.Count; |
||||
|
for (; x <= oneVectorFromEnd; x += Vector128<int>.Count) |
||||
|
{ |
||||
|
Vector128<int> evenValues = Vector128.LoadUnsafe(ref evenBase, (nuint)x); |
||||
|
Vector128<int> oddValues = Vector128.LoadUnsafe(ref oddBase, (nuint)x); |
||||
|
Vector128<int> added = evenValues + oddValues; |
||||
|
Vector128<int> subtracted = evenValues - oddValues; |
||||
|
if (roundAndClip) |
||||
|
{ |
||||
|
added = RoundShiftAndClamp(added, shift, minimum, maximum); |
||||
|
subtracted = RoundShiftAndClamp(subtracted, shift, minimum, maximum); |
||||
|
} |
||||
|
|
||||
|
added.StoreUnsafe(ref positiveBase, (nuint)x); |
||||
|
subtracted.StoreUnsafe(ref negativeBase, (nuint)x); |
||||
|
} |
||||
|
} |
||||
|
|
||||
|
for (; x < even.Length; x++) |
||||
|
{ |
||||
|
int added = even[x] + odd[x]; |
||||
|
int subtracted = even[x] - odd[x]; |
||||
|
if (roundAndClip) |
||||
|
{ |
||||
|
added = RoundShiftAndClamp(added, shift, minimum, maximum); |
||||
|
subtracted = RoundShiftAndClamp(subtracted, shift, minimum, maximum); |
||||
|
} |
||||
|
|
||||
|
positive[x] = added; |
||||
|
negative[x] = subtracted; |
||||
|
} |
||||
|
} |
||||
|
|
||||
|
/// <summary>
|
||||
|
/// Applies the four-point inverse-DST matrix across all independent lines.
|
||||
|
/// </summary>
|
||||
|
/// <typeparam name="TOperator">The selected dense transform operator.</typeparam>
|
||||
|
/// <param name="source">The frequency rows followed by contiguous independent lines.</param>
|
||||
|
/// <param name="destination">The spatial rows followed by contiguous independent lines.</param>
|
||||
|
/// <param name="lineCount">The number of independent lines transformed together.</param>
|
||||
|
/// <param name="shift">The rounded right shift applied to each result.</param>
|
||||
|
/// <param name="minimum">The inclusive output minimum.</param>
|
||||
|
/// <param name="maximum">The inclusive output maximum.</param>
|
||||
|
private static void TransformDense<TOperator>( |
||||
|
ReadOnlySpan<int> source, |
||||
|
Span<int> destination, |
||||
|
int lineCount, |
||||
|
int shift, |
||||
|
int minimum, |
||||
|
int maximum) |
||||
|
where TOperator : struct, IHevcInverseTransformOperator<TOperator> |
||||
|
{ |
||||
|
ref int sourceBase = ref MemoryMarshal.GetReference(source); |
||||
|
ref int destinationBase = ref MemoryMarshal.GetReference(destination); |
||||
|
for (int position = 0; position < TOperator.Size; position++) |
||||
|
{ |
||||
|
int x = 0; |
||||
|
if (Vector512.IsHardwareAccelerated) |
||||
|
{ |
||||
|
int oneVectorFromEnd = lineCount - Vector512<int>.Count; |
||||
|
for (; x <= oneVectorFromEnd; x += Vector512<int>.Count) |
||||
|
{ |
||||
|
Vector512<int> sum = Vector512<int>.Zero; |
||||
|
for (int frequency = 0; frequency < TOperator.Size; frequency++) |
||||
|
{ |
||||
|
Vector512<int> values = Vector512.LoadUnsafe(ref sourceBase, (nuint)((frequency * lineCount) + x)); |
||||
|
sum += values * Vector512.Create(TOperator.GetCoefficient(frequency, position)); |
||||
|
} |
||||
|
|
||||
|
RoundShiftAndClamp(sum, shift, minimum, maximum).StoreUnsafe(ref destinationBase, (nuint)((position * lineCount) + x)); |
||||
|
} |
||||
|
} |
||||
|
|
||||
|
if (Vector256.IsHardwareAccelerated) |
||||
|
{ |
||||
|
int oneVectorFromEnd = lineCount - Vector256<int>.Count; |
||||
|
for (; x <= oneVectorFromEnd; x += Vector256<int>.Count) |
||||
|
{ |
||||
|
Vector256<int> sum = Vector256<int>.Zero; |
||||
|
for (int frequency = 0; frequency < TOperator.Size; frequency++) |
||||
|
{ |
||||
|
Vector256<int> values = Vector256.LoadUnsafe(ref sourceBase, (nuint)((frequency * lineCount) + x)); |
||||
|
sum += values * Vector256.Create(TOperator.GetCoefficient(frequency, position)); |
||||
|
} |
||||
|
|
||||
|
RoundShiftAndClamp(sum, shift, minimum, maximum).StoreUnsafe(ref destinationBase, (nuint)((position * lineCount) + x)); |
||||
|
} |
||||
|
} |
||||
|
|
||||
|
if (Vector128.IsHardwareAccelerated) |
||||
|
{ |
||||
|
int oneVectorFromEnd = lineCount - Vector128<int>.Count; |
||||
|
for (; x <= oneVectorFromEnd; x += Vector128<int>.Count) |
||||
|
{ |
||||
|
Vector128<int> sum = Vector128<int>.Zero; |
||||
|
for (int frequency = 0; frequency < TOperator.Size; frequency++) |
||||
|
{ |
||||
|
Vector128<int> values = Vector128.LoadUnsafe(ref sourceBase, (nuint)((frequency * lineCount) + x)); |
||||
|
sum += values * Vector128.Create(TOperator.GetCoefficient(frequency, position)); |
||||
|
} |
||||
|
|
||||
|
RoundShiftAndClamp(sum, shift, minimum, maximum).StoreUnsafe(ref destinationBase, (nuint)((position * lineCount) + x)); |
||||
|
} |
||||
|
} |
||||
|
|
||||
|
for (; x < lineCount; x++) |
||||
|
{ |
||||
|
int sum = 0; |
||||
|
for (int frequency = 0; frequency < TOperator.Size; frequency++) |
||||
|
{ |
||||
|
sum += source[(frequency * lineCount) + x] * TOperator.GetCoefficient(frequency, position); |
||||
|
} |
||||
|
|
||||
|
destination[(position * lineCount) + x] = RoundShiftAndClamp(sum, shift, minimum, maximum); |
||||
|
} |
||||
|
} |
||||
|
} |
||||
|
|
||||
|
/// <summary>
|
||||
|
/// Transposes one rectangular transform block into a separate full-block buffer.
|
||||
|
/// </summary>
|
||||
|
/// <param name="source">The source block in raster order.</param>
|
||||
|
/// <param name="destination">The transposed destination block.</param>
|
||||
|
/// <param name="sourceHeight">The source row count.</param>
|
||||
|
/// <param name="sourceWidth">The source column count.</param>
|
||||
|
private static void Transpose(ReadOnlySpan<int> source, Span<int> destination, int sourceHeight, int sourceWidth) |
||||
|
{ |
||||
|
if (Vector128.IsHardwareAccelerated) |
||||
|
{ |
||||
|
ref int sourceBase = ref MemoryMarshal.GetReference(source); |
||||
|
ref int destinationBase = ref MemoryMarshal.GetReference(destination); |
||||
|
for (int y = 0; y < sourceHeight; y += 4) |
||||
|
{ |
||||
|
for (int x = 0; x < sourceWidth; x += 4) |
||||
|
{ |
||||
|
Vector128<int> row0 = Vector128.LoadUnsafe(ref sourceBase, (nuint)((y * sourceWidth) + x)); |
||||
|
Vector128<int> row1 = Vector128.LoadUnsafe(ref sourceBase, (nuint)(((y + 1) * sourceWidth) + x)); |
||||
|
Vector128<int> row2 = Vector128.LoadUnsafe(ref sourceBase, (nuint)(((y + 2) * sourceWidth) + x)); |
||||
|
Vector128<int> row3 = Vector128.LoadUnsafe(ref sourceBase, (nuint)(((y + 3) * sourceWidth) + x)); |
||||
|
Av1Transform2dOperations.Transpose(ref row0, ref row1, ref row2, ref row3); |
||||
|
row0.StoreUnsafe(ref destinationBase, (nuint)((x * sourceHeight) + y)); |
||||
|
row1.StoreUnsafe(ref destinationBase, (nuint)(((x + 1) * sourceHeight) + y)); |
||||
|
row2.StoreUnsafe(ref destinationBase, (nuint)(((x + 2) * sourceHeight) + y)); |
||||
|
row3.StoreUnsafe(ref destinationBase, (nuint)(((x + 3) * sourceHeight) + y)); |
||||
|
} |
||||
|
} |
||||
|
|
||||
|
return; |
||||
|
} |
||||
|
|
||||
|
for (int y = 0; y < sourceHeight; y++) |
||||
|
{ |
||||
|
for (int x = 0; x < sourceWidth; x++) |
||||
|
{ |
||||
|
destination[(x * sourceHeight) + y] = source[(y * sourceWidth) + x]; |
||||
|
} |
||||
|
} |
||||
|
} |
||||
|
|
||||
|
/// <summary>
|
||||
|
/// Adds a complete signed residual block to the predicted samples and clips to the component precision.
|
||||
|
/// </summary>
|
||||
|
/// <param name="residual">The signed residual block in raster order.</param>
|
||||
|
/// <param name="destination">The predicted samples beginning at the block origin.</param>
|
||||
|
/// <param name="destinationStride">The destination row stride in samples.</param>
|
||||
|
/// <param name="width">The transform-block width.</param>
|
||||
|
/// <param name="height">The transform-block height.</param>
|
||||
|
/// <param name="bitDepth">The reconstructed component precision.</param>
|
||||
|
private static void AddResidual(ReadOnlySpan<int> residual, Span<ushort> destination, int destinationStride, int width, int height, int bitDepth) |
||||
|
{ |
||||
|
int maximum = (1 << bitDepth) - 1; |
||||
|
for (int y = 0; y < height; y++) |
||||
|
{ |
||||
|
ReadOnlySpan<int> residualRow = residual.Slice(y * width, width); |
||||
|
Span<ushort> destinationRow = destination.Slice(y * destinationStride, width); |
||||
|
ref int residualBase = ref MemoryMarshal.GetReference(residualRow); |
||||
|
ref ushort destinationBase = ref MemoryMarshal.GetReference(destinationRow); |
||||
|
int x = 0; |
||||
|
|
||||
|
if (Vector256.IsHardwareAccelerated) |
||||
|
{ |
||||
|
int oneVectorFromEnd = width - Vector256<int>.Count; |
||||
|
for (; x <= oneVectorFromEnd; x += Vector256<int>.Count) |
||||
|
{ |
||||
|
Vector128<ushort> predicted16 = Vector128.LoadUnsafe(ref destinationBase, (nuint)x); |
||||
|
Vector256<int> predicted = Vector256.Create(Vector128.WidenLower(predicted16), Vector128.WidenUpper(predicted16)).AsInt32(); |
||||
|
Vector256<int> reconstructed = Vector256.Clamp( |
||||
|
predicted + Vector256.LoadUnsafe(ref residualBase, (nuint)x), |
||||
|
Vector256<int>.Zero, |
||||
|
Vector256.Create(maximum)); |
||||
|
|
||||
|
Vector128.Narrow(reconstructed.GetLower().AsUInt32(), reconstructed.GetUpper().AsUInt32()).StoreUnsafe(ref destinationBase, (nuint)x); |
||||
|
} |
||||
|
} |
||||
|
|
||||
|
if (Vector128.IsHardwareAccelerated) |
||||
|
{ |
||||
|
int oneVectorFromEnd = width - Vector128<int>.Count; |
||||
|
for (; x <= oneVectorFromEnd; x += Vector128<int>.Count) |
||||
|
{ |
||||
|
ulong packed = Unsafe.ReadUnaligned<ulong>(ref Unsafe.As<ushort, byte>(ref Unsafe.Add(ref destinationBase, x))); |
||||
|
Vector128<int> predicted = Vector128.WidenLower(Vector128.CreateScalarUnsafe(packed).AsUInt16()).AsInt32(); |
||||
|
Vector128<int> reconstructed = Vector128.Clamp( |
||||
|
predicted + Vector128.LoadUnsafe(ref residualBase, (nuint)x), |
||||
|
Vector128<int>.Zero, |
||||
|
Vector128.Create(maximum)); |
||||
|
|
||||
|
Vector128<ushort> narrowed = Vector128.Narrow(reconstructed.AsUInt32(), Vector128<uint>.Zero); |
||||
|
Unsafe.WriteUnaligned(ref Unsafe.As<ushort, byte>(ref Unsafe.Add(ref destinationBase, x)), narrowed.AsUInt64().ToScalar()); |
||||
|
} |
||||
|
} |
||||
|
|
||||
|
for (; x < width; x++) |
||||
|
{ |
||||
|
destinationRow[x] = (ushort)Math.Clamp(destinationRow[x] + residualRow[x], 0, maximum); |
||||
|
} |
||||
|
} |
||||
|
} |
||||
|
|
||||
|
/// <summary>
|
||||
|
/// Applies HEVC's rounded right shift and inclusive clipping to a 512-bit vector.
|
||||
|
/// </summary>
|
||||
|
/// <param name="value">The unnormalized transform values.</param>
|
||||
|
/// <param name="shift">The right-shift count.</param>
|
||||
|
/// <param name="minimum">The inclusive result minimum.</param>
|
||||
|
/// <param name="maximum">The inclusive result maximum.</param>
|
||||
|
/// <returns>The normalized and clipped values.</returns>
|
||||
|
[MethodImpl(MethodImplOptions.AggressiveInlining)] |
||||
|
private static Vector512<int> RoundShiftAndClamp(Vector512<int> value, int shift, int minimum, int maximum) |
||||
|
=> Vector512.Clamp((value + Vector512.Create(1 << (shift - 1))) >> shift, Vector512.Create(minimum), Vector512.Create(maximum)); |
||||
|
|
||||
|
/// <summary>
|
||||
|
/// Applies HEVC's rounded right shift and inclusive clipping to a 256-bit vector.
|
||||
|
/// </summary>
|
||||
|
/// <param name="value">The unnormalized transform values.</param>
|
||||
|
/// <param name="shift">The right-shift count.</param>
|
||||
|
/// <param name="minimum">The inclusive result minimum.</param>
|
||||
|
/// <param name="maximum">The inclusive result maximum.</param>
|
||||
|
/// <returns>The normalized and clipped values.</returns>
|
||||
|
[MethodImpl(MethodImplOptions.AggressiveInlining)] |
||||
|
private static Vector256<int> RoundShiftAndClamp(Vector256<int> value, int shift, int minimum, int maximum) |
||||
|
=> Vector256.Clamp((value + Vector256.Create(1 << (shift - 1))) >> shift, Vector256.Create(minimum), Vector256.Create(maximum)); |
||||
|
|
||||
|
/// <summary>
|
||||
|
/// Applies HEVC's rounded right shift and inclusive clipping to a 128-bit vector.
|
||||
|
/// </summary>
|
||||
|
/// <param name="value">The unnormalized transform values.</param>
|
||||
|
/// <param name="shift">The right-shift count.</param>
|
||||
|
/// <param name="minimum">The inclusive result minimum.</param>
|
||||
|
/// <param name="maximum">The inclusive result maximum.</param>
|
||||
|
/// <returns>The normalized and clipped values.</returns>
|
||||
|
[MethodImpl(MethodImplOptions.AggressiveInlining)] |
||||
|
private static Vector128<int> RoundShiftAndClamp(Vector128<int> value, int shift, int minimum, int maximum) |
||||
|
=> Vector128.Clamp((value + Vector128.Create(1 << (shift - 1))) >> shift, Vector128.Create(minimum), Vector128.Create(maximum)); |
||||
|
|
||||
|
/// <summary>
|
||||
|
/// Applies HEVC's rounded right shift and inclusive clipping to one scalar value.
|
||||
|
/// </summary>
|
||||
|
/// <param name="value">The unnormalized transform value.</param>
|
||||
|
/// <param name="shift">The right-shift count.</param>
|
||||
|
/// <param name="minimum">The inclusive result minimum.</param>
|
||||
|
/// <param name="maximum">The inclusive result maximum.</param>
|
||||
|
/// <returns>The normalized and clipped value.</returns>
|
||||
|
[MethodImpl(MethodImplOptions.AggressiveInlining)] |
||||
|
private static int RoundShiftAndClamp(int value, int shift, int minimum, int maximum) |
||||
|
=> Math.Clamp((value + (1 << (shift - 1))) >> shift, minimum, maximum); |
||||
|
} |
||||
@ -0,0 +1,141 @@ |
|||||
|
// Copyright (c) Six Labors.
|
||||
|
// Licensed under the Six Labors Split License.
|
||||
|
|
||||
|
using System.Runtime.CompilerServices; |
||||
|
|
||||
|
namespace SixLabors.ImageSharp.Formats.Heif.Hevc; |
||||
|
|
||||
|
internal static partial class HevcInverseTransformer |
||||
|
{ |
||||
|
/// <summary>
|
||||
|
/// Gets the common HEVC inverse-DCT magnitudes ordered on the pi-over-sixty-four angle grid.
|
||||
|
/// </summary>
|
||||
|
private static ReadOnlySpan<sbyte> DiscreteCosineMagnitudes => |
||||
|
[ |
||||
|
90, 90, 90, 90, 89, 88, 87, 85, 83, 82, 80, 78, 75, 73, 70, 67, 64, |
||||
|
61, 57, 54, 50, 46, 43, 38, 36, 31, 25, 22, 18, 13, 9, 4, 0 |
||||
|
]; |
||||
|
|
||||
|
/// <summary>
|
||||
|
/// Gets the four-point HEVC inverse-DST matrix in frequency-major order.
|
||||
|
/// </summary>
|
||||
|
private static ReadOnlySpan<sbyte> DiscreteSine4Coefficients => |
||||
|
[ |
||||
|
29, 55, 74, 84, |
||||
|
74, 74, 0, -74, |
||||
|
84, -29, -74, 55, |
||||
|
55, -84, 74, -29 |
||||
|
]; |
||||
|
|
||||
|
/// <summary>
|
||||
|
/// Reconstructs one normative inverse-DCT coefficient from the common HEVC angle grid.
|
||||
|
/// </summary>
|
||||
|
/// <param name="size">The transform side.</param>
|
||||
|
/// <param name="frequency">The frequency-domain coordinate.</param>
|
||||
|
/// <param name="position">The spatial-domain coordinate.</param>
|
||||
|
/// <returns>The signed transform coefficient.</returns>
|
||||
|
[MethodImpl(MethodImplOptions.AggressiveInlining)] |
||||
|
private static int GetDiscreteCosineCoefficient(int size, int frequency, int position) |
||||
|
{ |
||||
|
if (frequency == 0) |
||||
|
{ |
||||
|
return 64; |
||||
|
} |
||||
|
|
||||
|
int angle = ((2 * position) + 1) * frequency * (32 / size); |
||||
|
angle &= 127; |
||||
|
if (angle > 64) |
||||
|
{ |
||||
|
angle = 128 - angle; |
||||
|
} |
||||
|
|
||||
|
// Angles in the second quadrant reuse the first-quadrant magnitude with a negative sign. Keeping the
|
||||
|
// normative integer magnitudes in one compile-time span avoids runtime trigonometry and duplicate matrices.
|
||||
|
if (angle > 32) |
||||
|
{ |
||||
|
return -DiscreteCosineMagnitudes[64 - angle]; |
||||
|
} |
||||
|
|
||||
|
return DiscreteCosineMagnitudes[angle]; |
||||
|
} |
||||
|
|
||||
|
/// <summary>
|
||||
|
/// Implements the four-point inverse discrete cosine transform.
|
||||
|
/// </summary>
|
||||
|
private readonly struct DiscreteCosine4Operator : IHevcInverseTransformOperator<DiscreteCosine4Operator> |
||||
|
{ |
||||
|
/// <inheritdoc/>
|
||||
|
public static int Size => 4; |
||||
|
|
||||
|
/// <inheritdoc/>
|
||||
|
public static bool UsesButterfly => true; |
||||
|
|
||||
|
/// <inheritdoc/>
|
||||
|
[MethodImpl(MethodImplOptions.AggressiveInlining)] |
||||
|
public static int GetCoefficient(int frequency, int position) => GetDiscreteCosineCoefficient(Size, frequency, position); |
||||
|
} |
||||
|
|
||||
|
/// <summary>
|
||||
|
/// Implements the four-point inverse discrete sine transform.
|
||||
|
/// </summary>
|
||||
|
private readonly struct DiscreteSine4Operator : IHevcInverseTransformOperator<DiscreteSine4Operator> |
||||
|
{ |
||||
|
/// <inheritdoc/>
|
||||
|
public static int Size => 4; |
||||
|
|
||||
|
/// <inheritdoc/>
|
||||
|
public static bool UsesButterfly => false; |
||||
|
|
||||
|
/// <inheritdoc/>
|
||||
|
[MethodImpl(MethodImplOptions.AggressiveInlining)] |
||||
|
public static int GetCoefficient(int frequency, int position) => DiscreteSine4Coefficients[(frequency * Size) + position]; |
||||
|
} |
||||
|
|
||||
|
/// <summary>
|
||||
|
/// Implements the eight-point inverse discrete cosine transform.
|
||||
|
/// </summary>
|
||||
|
private readonly struct DiscreteCosine8Operator : IHevcInverseTransformOperator<DiscreteCosine8Operator> |
||||
|
{ |
||||
|
/// <inheritdoc/>
|
||||
|
public static int Size => 8; |
||||
|
|
||||
|
/// <inheritdoc/>
|
||||
|
public static bool UsesButterfly => true; |
||||
|
|
||||
|
/// <inheritdoc/>
|
||||
|
[MethodImpl(MethodImplOptions.AggressiveInlining)] |
||||
|
public static int GetCoefficient(int frequency, int position) => GetDiscreteCosineCoefficient(Size, frequency, position); |
||||
|
} |
||||
|
|
||||
|
/// <summary>
|
||||
|
/// Implements the sixteen-point inverse discrete cosine transform.
|
||||
|
/// </summary>
|
||||
|
private readonly struct DiscreteCosine16Operator : IHevcInverseTransformOperator<DiscreteCosine16Operator> |
||||
|
{ |
||||
|
/// <inheritdoc/>
|
||||
|
public static int Size => 16; |
||||
|
|
||||
|
/// <inheritdoc/>
|
||||
|
public static bool UsesButterfly => true; |
||||
|
|
||||
|
/// <inheritdoc/>
|
||||
|
[MethodImpl(MethodImplOptions.AggressiveInlining)] |
||||
|
public static int GetCoefficient(int frequency, int position) => GetDiscreteCosineCoefficient(Size, frequency, position); |
||||
|
} |
||||
|
|
||||
|
/// <summary>
|
||||
|
/// Implements the thirty-two-point inverse discrete cosine transform.
|
||||
|
/// </summary>
|
||||
|
private readonly struct DiscreteCosine32Operator : IHevcInverseTransformOperator<DiscreteCosine32Operator> |
||||
|
{ |
||||
|
/// <inheritdoc/>
|
||||
|
public static int Size => 32; |
||||
|
|
||||
|
/// <inheritdoc/>
|
||||
|
public static bool UsesButterfly => true; |
||||
|
|
||||
|
/// <inheritdoc/>
|
||||
|
[MethodImpl(MethodImplOptions.AggressiveInlining)] |
||||
|
public static int GetCoefficient(int frequency, int position) => GetDiscreteCosineCoefficient(Size, frequency, position); |
||||
|
} |
||||
|
} |
||||
@ -0,0 +1,270 @@ |
|||||
|
// Copyright (c) Six Labors.
|
||||
|
// Licensed under the Six Labors Split License.
|
||||
|
|
||||
|
using System.Runtime.CompilerServices; |
||||
|
using SixLabors.ImageSharp.Common.Helpers; |
||||
|
|
||||
|
namespace SixLabors.ImageSharp.Formats.Heif.Hevc; |
||||
|
|
||||
|
/// <summary>
|
||||
|
/// Applies HEVC inverse transforms and reconstructs predicted samples.
|
||||
|
/// </summary>
|
||||
|
internal static partial class HevcInverseTransformer |
||||
|
{ |
||||
|
/// <summary>
|
||||
|
/// The signed residual precision used after the second inverse-transform pass.
|
||||
|
/// </summary>
|
||||
|
private const int ResidualPrecision = 16; |
||||
|
|
||||
|
/// <summary>
|
||||
|
/// Defines one closed inverse-transform operation selected by the transform-unit syntax.
|
||||
|
/// </summary>
|
||||
|
/// <typeparam name="TOperator">The implementing operator type.</typeparam>
|
||||
|
private interface IHevcInverseTransformOperator<TOperator> |
||||
|
where TOperator : struct, IHevcInverseTransformOperator<TOperator> |
||||
|
{ |
||||
|
/// <summary>
|
||||
|
/// Gets the transform side in samples.
|
||||
|
/// </summary>
|
||||
|
public static abstract int Size { get; } |
||||
|
|
||||
|
/// <summary>
|
||||
|
/// Gets a value indicating whether the transform uses the partial-butterfly factorization.
|
||||
|
/// </summary>
|
||||
|
public static abstract bool UsesButterfly { get; } |
||||
|
|
||||
|
/// <summary>
|
||||
|
/// Gets one inverse-transform matrix coefficient.
|
||||
|
/// </summary>
|
||||
|
/// <param name="frequency">The frequency-domain coordinate.</param>
|
||||
|
/// <param name="position">The spatial-domain coordinate.</param>
|
||||
|
/// <returns>The signed transform coefficient.</returns>
|
||||
|
public static abstract int GetCoefficient(int frequency, int position); |
||||
|
} |
||||
|
|
||||
|
/// <summary>
|
||||
|
/// Gets the scratch length required for the specified rectangular transform block.
|
||||
|
/// </summary>
|
||||
|
/// <param name="log2Width">The base-two logarithm of the transform-block width.</param>
|
||||
|
/// <param name="log2Height">The base-two logarithm of the transform-block height.</param>
|
||||
|
/// <returns>The required number of signed thirty-two-bit elements.</returns>
|
||||
|
public static int GetScratchLength(int log2Width, int log2Height) |
||||
|
{ |
||||
|
DebugGuard.MustBeBetweenOrEqualTo(log2Width, 2, 5, nameof(log2Width)); |
||||
|
DebugGuard.MustBeBetweenOrEqualTo(log2Height, 2, 5, nameof(log2Height)); |
||||
|
return 2 << (log2Width + log2Height); |
||||
|
} |
||||
|
|
||||
|
/// <summary>
|
||||
|
/// Reconstructs one transform block by adding its inverse-transformed residual to the predicted samples.
|
||||
|
/// </summary>
|
||||
|
/// <param name="coefficients">The dequantized transform coefficients in raster order.</param>
|
||||
|
/// <param name="destination">The predicted samples beginning at the transform-block origin.</param>
|
||||
|
/// <param name="destinationStride">The destination row stride in samples.</param>
|
||||
|
/// <param name="log2Width">The base-two logarithm of the transform-block width.</param>
|
||||
|
/// <param name="log2Height">The base-two logarithm of the transform-block height.</param>
|
||||
|
/// <param name="bitDepth">The reconstructed component precision.</param>
|
||||
|
/// <param name="maxTransformDynamicRange">The transform dynamic range excluding its sign bit.</param>
|
||||
|
/// <param name="useDiscreteSineTransform">Whether the four-by-four luma intra block uses the discrete sine transform.</param>
|
||||
|
/// <param name="scratch">The caller-owned scratch returned by <see cref="GetScratchLength(int, int)"/>.</param>
|
||||
|
public static void TransformAdd( |
||||
|
ReadOnlySpan<int> coefficients, |
||||
|
Span<ushort> destination, |
||||
|
int destinationStride, |
||||
|
int log2Width, |
||||
|
int log2Height, |
||||
|
int bitDepth, |
||||
|
int maxTransformDynamicRange, |
||||
|
bool useDiscreteSineTransform, |
||||
|
Span<int> scratch) |
||||
|
{ |
||||
|
DebugGuard.MustBeBetweenOrEqualTo(log2Width, 2, 5, nameof(log2Width)); |
||||
|
DebugGuard.MustBeBetweenOrEqualTo(log2Height, 2, 5, nameof(log2Height)); |
||||
|
DebugGuard.MustBeBetweenOrEqualTo(bitDepth, 8, 16, nameof(bitDepth)); |
||||
|
DebugGuard.IsTrue(!useDiscreteSineTransform || (log2Width == 2 && log2Height == 2), "The HEVC inverse DST is defined only for four-by-four blocks."); |
||||
|
|
||||
|
int width = 1 << log2Width; |
||||
|
int height = 1 << log2Height; |
||||
|
int sampleCount = width * height; |
||||
|
DebugGuard.IsTrue(coefficients.Length >= sampleCount, "The coefficient span is shorter than the transform block."); |
||||
|
DebugGuard.IsTrue(scratch.Length >= sampleCount * 2, "The scratch span is shorter than the inverse-transform requirement."); |
||||
|
|
||||
|
Span<int> first = scratch[..sampleCount]; |
||||
|
Span<int> second = scratch.Slice(sampleCount, sampleCount); |
||||
|
Span<int> residual = TransformCore( |
||||
|
coefficients[..sampleCount], |
||||
|
first, |
||||
|
second, |
||||
|
width, |
||||
|
height, |
||||
|
bitDepth, |
||||
|
maxTransformDynamicRange, |
||||
|
useDiscreteSineTransform); |
||||
|
|
||||
|
AddResidual(residual, destination, destinationStride, width, height, bitDepth); |
||||
|
} |
||||
|
|
||||
|
/// <summary>
|
||||
|
/// Applies one two-dimensional inverse transform and writes signed residual samples in raster order.
|
||||
|
/// </summary>
|
||||
|
/// <param name="coefficients">The dequantized transform coefficients in raster order.</param>
|
||||
|
/// <param name="residual">The destination residual samples in raster order.</param>
|
||||
|
/// <param name="log2Width">The base-two logarithm of the transform-block width.</param>
|
||||
|
/// <param name="log2Height">The base-two logarithm of the transform-block height.</param>
|
||||
|
/// <param name="bitDepth">The reconstructed component precision.</param>
|
||||
|
/// <param name="maxTransformDynamicRange">The transform dynamic range excluding its sign bit.</param>
|
||||
|
/// <param name="useDiscreteSineTransform">Whether the four-by-four luma intra block uses the discrete sine transform.</param>
|
||||
|
/// <param name="scratch">The caller-owned scratch returned by <see cref="GetScratchLength(int, int)"/>.</param>
|
||||
|
public static void Transform( |
||||
|
ReadOnlySpan<int> coefficients, |
||||
|
Span<int> residual, |
||||
|
int log2Width, |
||||
|
int log2Height, |
||||
|
int bitDepth, |
||||
|
int maxTransformDynamicRange, |
||||
|
bool useDiscreteSineTransform, |
||||
|
Span<int> scratch) |
||||
|
{ |
||||
|
int width = 1 << log2Width; |
||||
|
int height = 1 << log2Height; |
||||
|
int sampleCount = width * height; |
||||
|
DebugGuard.IsTrue(residual.Length >= sampleCount, "The residual span is shorter than the transform block."); |
||||
|
DebugGuard.IsTrue(scratch.Length >= sampleCount * 2, "The scratch span is shorter than the inverse-transform requirement."); |
||||
|
|
||||
|
Span<int> transformed = TransformCore( |
||||
|
coefficients[..sampleCount], |
||||
|
scratch[..sampleCount], |
||||
|
scratch.Slice(sampleCount, sampleCount), |
||||
|
width, |
||||
|
height, |
||||
|
bitDepth, |
||||
|
maxTransformDynamicRange, |
||||
|
useDiscreteSineTransform); |
||||
|
|
||||
|
transformed.CopyTo(residual); |
||||
|
} |
||||
|
|
||||
|
/// <summary>
|
||||
|
/// Dispatches both separable transform passes through closed operators selected from the block dimensions.
|
||||
|
/// </summary>
|
||||
|
/// <param name="coefficients">The complete dequantized coefficient block.</param>
|
||||
|
/// <param name="first">The first full-block scratch buffer.</param>
|
||||
|
/// <param name="second">The second full-block scratch buffer.</param>
|
||||
|
/// <param name="width">The transform-block width.</param>
|
||||
|
/// <param name="height">The transform-block height.</param>
|
||||
|
/// <param name="bitDepth">The reconstructed component precision.</param>
|
||||
|
/// <param name="maxTransformDynamicRange">The transform dynamic range excluding its sign bit.</param>
|
||||
|
/// <param name="useDiscreteSineTransform">Whether both four-point passes use the discrete sine transform.</param>
|
||||
|
/// <returns>The scratch buffer containing the raster-ordered residual.</returns>
|
||||
|
private static Span<int> TransformCore( |
||||
|
ReadOnlySpan<int> coefficients, |
||||
|
Span<int> first, |
||||
|
Span<int> second, |
||||
|
int width, |
||||
|
int height, |
||||
|
int bitDepth, |
||||
|
int maxTransformDynamicRange, |
||||
|
bool useDiscreteSineTransform) |
||||
|
{ |
||||
|
int dynamicMinimum = -(1 << maxTransformDynamicRange); |
||||
|
int dynamicMaximum = (1 << maxTransformDynamicRange) - 1; |
||||
|
|
||||
|
// HEVC moves one normalization bit from the second pass to the first. The intermediate clip therefore
|
||||
|
// belongs after the vertical pass and must not be combined with the final residual clipping operation.
|
||||
|
Span<int> vertical = TransformDimension( |
||||
|
coefficients, |
||||
|
first, |
||||
|
second, |
||||
|
height, |
||||
|
width, |
||||
|
7, |
||||
|
dynamicMinimum, |
||||
|
dynamicMaximum, |
||||
|
useDiscreteSineTransform); |
||||
|
|
||||
|
Span<int> horizontalInput = vertical.Overlaps(first) ? second : first; |
||||
|
Transpose(vertical, horizontalInput, height, width); |
||||
|
|
||||
|
Span<int> horizontalWorkspace = horizontalInput.Overlaps(first) ? second : first; |
||||
|
int secondShift = maxTransformDynamicRange + 5 - bitDepth; |
||||
|
Span<int> horizontal = TransformDimension( |
||||
|
horizontalInput, |
||||
|
horizontalWorkspace, |
||||
|
horizontalInput, |
||||
|
width, |
||||
|
height, |
||||
|
secondShift, |
||||
|
-(1 << (ResidualPrecision - 1)), |
||||
|
(1 << (ResidualPrecision - 1)) - 1, |
||||
|
useDiscreteSineTransform); |
||||
|
|
||||
|
Span<int> residual = horizontal.Overlaps(first) ? second : first; |
||||
|
Transpose(horizontal, residual, width, height); |
||||
|
return residual; |
||||
|
} |
||||
|
|
||||
|
/// <summary>
|
||||
|
/// Selects the statically specialized operator for one transform dimension.
|
||||
|
/// </summary>
|
||||
|
/// <param name="source">The frequency rows followed by contiguous independent lines.</param>
|
||||
|
/// <param name="initial">The initial operator output buffer.</param>
|
||||
|
/// <param name="alternate">The alternate combination buffer.</param>
|
||||
|
/// <param name="size">The transform dimension.</param>
|
||||
|
/// <param name="lineCount">The number of independent lines transformed together.</param>
|
||||
|
/// <param name="shift">The rounded right shift applied to the spatial results.</param>
|
||||
|
/// <param name="minimum">The inclusive output minimum.</param>
|
||||
|
/// <param name="maximum">The inclusive output maximum.</param>
|
||||
|
/// <param name="useDiscreteSineTransform">Whether the four-point pass uses the discrete sine transform.</param>
|
||||
|
/// <returns>The buffer containing spatial rows followed by contiguous independent lines.</returns>
|
||||
|
private static Span<int> TransformDimension( |
||||
|
ReadOnlySpan<int> source, |
||||
|
Span<int> initial, |
||||
|
Span<int> alternate, |
||||
|
int size, |
||||
|
int lineCount, |
||||
|
int shift, |
||||
|
int minimum, |
||||
|
int maximum, |
||||
|
bool useDiscreteSineTransform) |
||||
|
=> (size, useDiscreteSineTransform) switch |
||||
|
{ |
||||
|
(4, true) => TransformDimension<DiscreteSine4Operator>(source, initial, alternate, lineCount, shift, minimum, maximum), |
||||
|
(4, false) => TransformDimension<DiscreteCosine4Operator>(source, initial, alternate, lineCount, shift, minimum, maximum), |
||||
|
(8, _) => TransformDimension<DiscreteCosine8Operator>(source, initial, alternate, lineCount, shift, minimum, maximum), |
||||
|
(16, _) => TransformDimension<DiscreteCosine16Operator>(source, initial, alternate, lineCount, shift, minimum, maximum), |
||||
|
_ => TransformDimension<DiscreteCosine32Operator>(source, initial, alternate, lineCount, shift, minimum, maximum) |
||||
|
}; |
||||
|
|
||||
|
/// <summary>
|
||||
|
/// Invokes one statically selected inverse-transform operator.
|
||||
|
/// </summary>
|
||||
|
/// <typeparam name="TOperator">The selected inverse-transform operator.</typeparam>
|
||||
|
/// <param name="source">The frequency rows followed by contiguous independent lines.</param>
|
||||
|
/// <param name="initial">The initial operator output buffer.</param>
|
||||
|
/// <param name="alternate">The alternate combination buffer.</param>
|
||||
|
/// <param name="lineCount">The number of independent lines transformed together.</param>
|
||||
|
/// <param name="shift">The rounded right shift applied to the spatial results.</param>
|
||||
|
/// <param name="minimum">The inclusive output minimum.</param>
|
||||
|
/// <param name="maximum">The inclusive output maximum.</param>
|
||||
|
/// <returns>The buffer containing spatial rows followed by contiguous independent lines.</returns>
|
||||
|
[MethodImpl(MethodImplOptions.AggressiveInlining)] |
||||
|
private static Span<int> TransformDimension<TOperator>( |
||||
|
ReadOnlySpan<int> source, |
||||
|
Span<int> initial, |
||||
|
Span<int> alternate, |
||||
|
int lineCount, |
||||
|
int shift, |
||||
|
int minimum, |
||||
|
int maximum) |
||||
|
where TOperator : struct, IHevcInverseTransformOperator<TOperator> |
||||
|
{ |
||||
|
if (!TOperator.UsesButterfly) |
||||
|
{ |
||||
|
TransformDense<TOperator>(source, initial, lineCount, shift, minimum, maximum); |
||||
|
return initial; |
||||
|
} |
||||
|
|
||||
|
PopulateButterflyGroups<TOperator>(source, initial, lineCount); |
||||
|
return CombineButterflyGroups<TOperator>(initial, alternate, lineCount, shift, minimum, maximum); |
||||
|
} |
||||
|
} |
||||
@ -0,0 +1,90 @@ |
|||||
|
// 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 HEVC inverse-transform reconstruction.
|
||||
|
/// </summary>
|
||||
|
[MemoryDiagnoser(displayGenColumns: false)] |
||||
|
public class HevcInverseTransformBenchmarks |
||||
|
{ |
||||
|
/// <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 transform-block side.
|
||||
|
/// </summary>
|
||||
|
private const int BlockLog2 = 5; |
||||
|
|
||||
|
/// <summary>
|
||||
|
/// The transform-block side in samples.
|
||||
|
/// </summary>
|
||||
|
private const int BlockSize = 1 << BlockLog2; |
||||
|
|
||||
|
/// <summary>
|
||||
|
/// The deterministic dequantized coefficients reused by each benchmark block.
|
||||
|
/// </summary>
|
||||
|
private readonly int[] coefficients = new int[BlockSize * BlockSize]; |
||||
|
|
||||
|
/// <summary>
|
||||
|
/// The frame-wide predicted and reconstructed samples.
|
||||
|
/// </summary>
|
||||
|
private readonly ushort[] destination = new ushort[Width * Height]; |
||||
|
|
||||
|
/// <summary>
|
||||
|
/// The maximum-block inverse-transform scratch reused throughout each coded frame.
|
||||
|
/// </summary>
|
||||
|
private readonly int[] scratch = new int[HevcInverseTransformer.GetScratchLength(BlockLog2, BlockLog2)]; |
||||
|
|
||||
|
/// <summary>
|
||||
|
/// Populates a dense, deterministic twelve-bit transform workload outside the measured frame traversal.
|
||||
|
/// </summary>
|
||||
|
[GlobalSetup] |
||||
|
public void Setup() |
||||
|
{ |
||||
|
for (int i = 0; i < this.coefficients.Length; i++) |
||||
|
{ |
||||
|
this.coefficients[i] = (((i * 37) + 11) % 127) - 63; |
||||
|
} |
||||
|
|
||||
|
this.destination.AsSpan().Fill(2048); |
||||
|
} |
||||
|
|
||||
|
/// <summary>
|
||||
|
/// Measures factorized inverse DCT, both transpositions, and saturated prediction addition for a coded frame.
|
||||
|
/// </summary>
|
||||
|
/// <returns>The final reconstructed sample, keeping the frame output observable.</returns>
|
||||
|
[Benchmark] |
||||
|
public ushort TransformFrame() |
||||
|
{ |
||||
|
for (int y = 0; y < Height; y += BlockSize) |
||||
|
{ |
||||
|
for (int x = 0; x < Width; x += BlockSize) |
||||
|
{ |
||||
|
HevcInverseTransformer.TransformAdd( |
||||
|
this.coefficients, |
||||
|
this.destination.AsSpan((y * Width) + x), |
||||
|
Width, |
||||
|
BlockLog2, |
||||
|
BlockLog2, |
||||
|
12, |
||||
|
18, |
||||
|
false, |
||||
|
this.scratch); |
||||
|
} |
||||
|
} |
||||
|
|
||||
|
return this.destination[^1]; |
||||
|
} |
||||
|
} |
||||
@ -0,0 +1,248 @@ |
|||||
|
// Copyright (c) Six Labors.
|
||||
|
// Licensed under the Six Labors Split License.
|
||||
|
|
||||
|
using SixLabors.ImageSharp.Formats.Heif.Hevc; |
||||
|
|
||||
|
namespace SixLabors.ImageSharp.Tests.Formats.Heif.Hevc; |
||||
|
|
||||
|
/// <summary>
|
||||
|
/// Verifies HEVC inverse-DCT, inverse-DST, rectangular-block, dynamic-range, and reconstruction behavior.
|
||||
|
/// </summary>
|
||||
|
[Trait("Format", "Heic")] |
||||
|
public class HevcInverseTransformerTests |
||||
|
{ |
||||
|
/// <summary>
|
||||
|
/// Verifies the two normative normalization stages with a pure DC coefficient and a strided prediction block.
|
||||
|
/// </summary>
|
||||
|
[Fact] |
||||
|
public void DctDcCoefficientProducesUniformReconstruction() |
||||
|
{ |
||||
|
const int size = 4; |
||||
|
const int stride = 7; |
||||
|
int[] coefficients = new int[size * size]; |
||||
|
coefficients[0] = 1024; |
||||
|
ushort[] destination = new ushort[stride * size]; |
||||
|
destination.AsSpan().Fill(100); |
||||
|
int[] scratch = new int[HevcInverseTransformer.GetScratchLength(2, 2)]; |
||||
|
|
||||
|
HevcInverseTransformer.TransformAdd(coefficients, destination, stride, 2, 2, 8, 15, false, scratch); |
||||
|
|
||||
|
for (int y = 0; y < size; y++) |
||||
|
{ |
||||
|
for (int x = 0; x < size; x++) |
||||
|
{ |
||||
|
Assert.Equal((ushort)108, destination[(y * stride) + x]); |
||||
|
} |
||||
|
} |
||||
|
} |
||||
|
|
||||
|
/// <summary>
|
||||
|
/// Verifies a hand-derived four-by-four inverse-DST result from a pure lowest-frequency coefficient.
|
||||
|
/// </summary>
|
||||
|
[Fact] |
||||
|
public void DstLowestFrequencyMatchesFixedResult() |
||||
|
{ |
||||
|
int[] coefficients = new int[16]; |
||||
|
coefficients[0] = 1024; |
||||
|
int[] actual = new int[16]; |
||||
|
int[] scratch = new int[HevcInverseTransformer.GetScratchLength(2, 2)]; |
||||
|
int[] expected = |
||||
|
[ |
||||
|
2, 3, 4, 5, |
||||
|
3, 6, 8, 9, |
||||
|
4, 8, 11, 12, |
||||
|
5, 9, 12, 14 |
||||
|
]; |
||||
|
|
||||
|
HevcInverseTransformer.Transform(coefficients, actual, 2, 2, 8, 15, true, scratch); |
||||
|
|
||||
|
Assert.True(expected.AsSpan().SequenceEqual(actual)); |
||||
|
} |
||||
|
|
||||
|
/// <summary>
|
||||
|
/// Compares factorized SIMD transforms with a dense specification-shaped oracle across supported dimensions and precisions.
|
||||
|
/// </summary>
|
||||
|
/// <param name="log2Width">The base-two logarithm of the tested block width.</param>
|
||||
|
/// <param name="log2Height">The base-two logarithm of the tested block height.</param>
|
||||
|
/// <param name="bitDepth">The reconstructed component precision.</param>
|
||||
|
/// <param name="maxTransformDynamicRange">The transform dynamic range excluding its sign bit.</param>
|
||||
|
/// <param name="useDiscreteSineTransform">Whether the tested four-by-four block uses the inverse DST.</param>
|
||||
|
[Theory] |
||||
|
[InlineData(2, 2, 8, 15, false)] |
||||
|
[InlineData(2, 2, 8, 15, true)] |
||||
|
[InlineData(2, 3, 10, 15, false)] |
||||
|
[InlineData(3, 2, 10, 15, false)] |
||||
|
[InlineData(3, 3, 10, 15, false)] |
||||
|
[InlineData(4, 3, 12, 18, false)] |
||||
|
[InlineData(3, 4, 12, 18, false)] |
||||
|
[InlineData(5, 4, 12, 18, false)] |
||||
|
[InlineData(4, 5, 12, 18, false)] |
||||
|
[InlineData(5, 5, 12, 15, false)] |
||||
|
public void TransformMatchesDenseOracle( |
||||
|
int log2Width, |
||||
|
int log2Height, |
||||
|
int bitDepth, |
||||
|
int maxTransformDynamicRange, |
||||
|
bool useDiscreteSineTransform) |
||||
|
{ |
||||
|
int width = 1 << log2Width; |
||||
|
int height = 1 << log2Height; |
||||
|
int sampleCount = width * height; |
||||
|
int[] coefficients = new int[sampleCount]; |
||||
|
int coefficientMaximum = (1 << maxTransformDynamicRange) - 1; |
||||
|
for (int i = 0; i < coefficients.Length; i++) |
||||
|
{ |
||||
|
// Alternating values across the complete dequantized range exercise both intermediate clipping bounds
|
||||
|
// as well as every frequency group used by the factorized transform.
|
||||
|
int unit = (((i * 37) + (width * 11) + height) % 127) - 63; |
||||
|
coefficients[i] = (unit * coefficientMaximum) / 63; |
||||
|
} |
||||
|
|
||||
|
int[] expected = new int[sampleCount]; |
||||
|
int[] actual = new int[sampleCount]; |
||||
|
int[] oracleScratch = new int[sampleCount]; |
||||
|
int[] transformScratch = new int[HevcInverseTransformer.GetScratchLength(log2Width, log2Height)]; |
||||
|
TransformDenseOracle( |
||||
|
coefficients, |
||||
|
expected, |
||||
|
oracleScratch, |
||||
|
width, |
||||
|
height, |
||||
|
bitDepth, |
||||
|
maxTransformDynamicRange, |
||||
|
useDiscreteSineTransform); |
||||
|
|
||||
|
HevcInverseTransformer.Transform( |
||||
|
coefficients, |
||||
|
actual, |
||||
|
log2Width, |
||||
|
log2Height, |
||||
|
bitDepth, |
||||
|
maxTransformDynamicRange, |
||||
|
useDiscreteSineTransform, |
||||
|
transformScratch); |
||||
|
|
||||
|
Assert.True(expected.AsSpan().SequenceEqual(actual), $"The {width}x{height} transform at {bitDepth} bits did not match the dense HEVC oracle."); |
||||
|
} |
||||
|
|
||||
|
/// <summary>
|
||||
|
/// Verifies that residual addition clips both negative and positive reconstruction overflow at the component range.
|
||||
|
/// </summary>
|
||||
|
[Fact] |
||||
|
public void TransformAddClipsToComponentRange() |
||||
|
{ |
||||
|
const int size = 4; |
||||
|
int[] positiveCoefficients = new int[size * size]; |
||||
|
int[] negativeCoefficients = new int[size * size]; |
||||
|
positiveCoefficients[0] = 32767; |
||||
|
negativeCoefficients[0] = -32768; |
||||
|
ushort[] positive = new ushort[size * size]; |
||||
|
ushort[] negative = new ushort[size * size]; |
||||
|
positive.AsSpan().Fill(4090); |
||||
|
negative.AsSpan().Fill(5); |
||||
|
int[] scratch = new int[HevcInverseTransformer.GetScratchLength(2, 2)]; |
||||
|
|
||||
|
HevcInverseTransformer.TransformAdd(positiveCoefficients, positive, size, 2, 2, 12, 18, false, scratch); |
||||
|
HevcInverseTransformer.TransformAdd(negativeCoefficients, negative, size, 2, 2, 12, 18, false, scratch); |
||||
|
|
||||
|
Assert.All(positive, value => Assert.Equal((ushort)4095, value)); |
||||
|
Assert.All(negative, value => Assert.Equal((ushort)0, value)); |
||||
|
} |
||||
|
|
||||
|
/// <summary>
|
||||
|
/// Applies both inverse-transform dimensions using direct matrix products and normative rounding points.
|
||||
|
/// </summary>
|
||||
|
/// <param name="coefficients">The dequantized coefficient block.</param>
|
||||
|
/// <param name="residual">The destination signed residual block.</param>
|
||||
|
/// <param name="intermediate">The full-block intermediate buffer.</param>
|
||||
|
/// <param name="width">The transform-block width.</param>
|
||||
|
/// <param name="height">The transform-block height.</param>
|
||||
|
/// <param name="bitDepth">The reconstructed component precision.</param>
|
||||
|
/// <param name="maxTransformDynamicRange">The transform dynamic range excluding its sign bit.</param>
|
||||
|
/// <param name="useDiscreteSineTransform">Whether both dimensions use the four-point inverse DST.</param>
|
||||
|
private static void TransformDenseOracle( |
||||
|
ReadOnlySpan<int> coefficients, |
||||
|
Span<int> residual, |
||||
|
Span<int> intermediate, |
||||
|
int width, |
||||
|
int height, |
||||
|
int bitDepth, |
||||
|
int maxTransformDynamicRange, |
||||
|
bool useDiscreteSineTransform) |
||||
|
{ |
||||
|
int dynamicMinimum = -(1 << maxTransformDynamicRange); |
||||
|
int dynamicMaximum = (1 << maxTransformDynamicRange) - 1; |
||||
|
for (int y = 0; y < height; y++) |
||||
|
{ |
||||
|
for (int xFrequency = 0; xFrequency < width; xFrequency++) |
||||
|
{ |
||||
|
int sum = 0; |
||||
|
for (int yFrequency = 0; yFrequency < height; yFrequency++) |
||||
|
{ |
||||
|
sum += coefficients[(yFrequency * width) + xFrequency] * GetInverseCoefficient(height, yFrequency, y, useDiscreteSineTransform); |
||||
|
} |
||||
|
|
||||
|
intermediate[(y * width) + xFrequency] = Math.Clamp((sum + 64) >> 7, dynamicMinimum, dynamicMaximum); |
||||
|
} |
||||
|
} |
||||
|
|
||||
|
int secondShift = maxTransformDynamicRange + 5 - bitDepth; |
||||
|
int secondRounding = 1 << (secondShift - 1); |
||||
|
for (int y = 0; y < height; y++) |
||||
|
{ |
||||
|
for (int x = 0; x < width; x++) |
||||
|
{ |
||||
|
int sum = 0; |
||||
|
for (int xFrequency = 0; xFrequency < width; xFrequency++) |
||||
|
{ |
||||
|
sum += intermediate[(y * width) + xFrequency] * GetInverseCoefficient(width, xFrequency, x, useDiscreteSineTransform); |
||||
|
} |
||||
|
|
||||
|
residual[(y * width) + x] = Math.Clamp((sum + secondRounding) >> secondShift, short.MinValue, short.MaxValue); |
||||
|
} |
||||
|
} |
||||
|
} |
||||
|
|
||||
|
/// <summary>
|
||||
|
/// Gets one coefficient from the normative HEVC inverse-DCT or four-point inverse-DST matrix.
|
||||
|
/// </summary>
|
||||
|
/// <param name="size">The transform dimension.</param>
|
||||
|
/// <param name="frequency">The frequency-domain coordinate.</param>
|
||||
|
/// <param name="position">The spatial-domain coordinate.</param>
|
||||
|
/// <param name="useDiscreteSineTransform">Whether the four-point inverse DST is selected.</param>
|
||||
|
/// <returns>The signed matrix coefficient.</returns>
|
||||
|
private static int GetInverseCoefficient(int size, int frequency, int position, bool useDiscreteSineTransform) |
||||
|
{ |
||||
|
if (useDiscreteSineTransform) |
||||
|
{ |
||||
|
ReadOnlySpan<sbyte> sine = |
||||
|
[ |
||||
|
29, 55, 74, 84, |
||||
|
74, 74, 0, -74, |
||||
|
84, -29, -74, 55, |
||||
|
55, -84, 74, -29 |
||||
|
]; |
||||
|
|
||||
|
return sine[(frequency * 4) + position]; |
||||
|
} |
||||
|
|
||||
|
if (frequency == 0) |
||||
|
{ |
||||
|
return 64; |
||||
|
} |
||||
|
|
||||
|
ReadOnlySpan<sbyte> magnitudes = |
||||
|
[ |
||||
|
90, 90, 90, 90, 89, 88, 87, 85, 83, 82, 80, 78, 75, 73, 70, 67, 64, |
||||
|
61, 57, 54, 50, 46, 43, 38, 36, 31, 25, 22, 18, 13, 9, 4, 0 |
||||
|
]; |
||||
|
|
||||
|
int angle = (((2 * position) + 1) * frequency * (32 / size)) & 127; |
||||
|
if (angle > 64) |
||||
|
{ |
||||
|
angle = 128 - angle; |
||||
|
} |
||||
|
|
||||
|
return angle > 32 ? -magnitudes[64 - angle] : magnitudes[angle]; |
||||
|
} |
||||
|
} |
||||
Loading…
Reference in new issue