mirror of https://github.com/SixLabors/ImageSharp
James Jackson-South
2 months ago
6 changed files with 1043 additions and 11 deletions
@ -0,0 +1,438 @@ |
|||||
|
// Copyright (c) Six Labors.
|
||||
|
// Licensed under the Six Labors Split License.
|
||||
|
|
||||
|
using System.Buffers; |
||||
|
using System.Runtime.InteropServices; |
||||
|
using SixLabors.ImageSharp.Formats.Heif.Av1.OpenBitstreamUnit; |
||||
|
using SixLabors.ImageSharp.Formats.Heif.Av1.Pipeline.SuperResolution; |
||||
|
|
||||
|
namespace SixLabors.ImageSharp.Formats.Heif.Av1.Pipeline.LoopRestoration; |
||||
|
|
||||
|
/// <summary>
|
||||
|
/// Preserves the deblocked and frame-edge rows required by AV1 striped loop restoration.
|
||||
|
/// </summary>
|
||||
|
internal class Av1LoopRestorationBoundary : IDisposable |
||||
|
{ |
||||
|
/// <summary>
|
||||
|
/// The height of a complete restoration processing stripe in luma samples.
|
||||
|
/// </summary>
|
||||
|
public const int ProcessingStripeSize = 64; |
||||
|
|
||||
|
/// <summary>
|
||||
|
/// The upward offset of the restoration stripe grid from the restoration-unit grid.
|
||||
|
/// </summary>
|
||||
|
public const int ProcessingStripeOffset = 8; |
||||
|
|
||||
|
/// <summary>
|
||||
|
/// The number of distinct deblocked rows preserved above and below a stripe.
|
||||
|
/// </summary>
|
||||
|
private const int ContextRowCount = 2; |
||||
|
|
||||
|
/// <summary>
|
||||
|
/// The sequence-level bit-depth and plane-layout configuration.
|
||||
|
/// </summary>
|
||||
|
private readonly ObuSequenceHeader sequenceHeader; |
||||
|
|
||||
|
/// <summary>
|
||||
|
/// The coded, reconstructed, and upscaled frame dimensions.
|
||||
|
/// </summary>
|
||||
|
private readonly ObuFrameHeader frameHeader; |
||||
|
|
||||
|
/// <summary>
|
||||
|
/// The reconstructed sample planes read at each pipeline boundary.
|
||||
|
/// </summary>
|
||||
|
private readonly Av1FrameBuffer<byte> frameBuffer; |
||||
|
|
||||
|
/// <summary>
|
||||
|
/// The two preserved rows above every processing stripe, stored by plane.
|
||||
|
/// </summary>
|
||||
|
private readonly IMemoryOwner<ushort>?[] rowsAbove = new IMemoryOwner<ushort>?[Av1Constants.MaxPlanes]; |
||||
|
|
||||
|
/// <summary>
|
||||
|
/// The two preserved rows below every processing stripe, stored by plane.
|
||||
|
/// </summary>
|
||||
|
private readonly IMemoryOwner<ushort>?[] rowsBelow = new IMemoryOwner<ushort>?[Av1Constants.MaxPlanes]; |
||||
|
|
||||
|
/// <summary>
|
||||
|
/// The upscaled sample width stored for each plane boundary row.
|
||||
|
/// </summary>
|
||||
|
private readonly int[] planeWidths = new int[Av1Constants.MaxPlanes]; |
||||
|
|
||||
|
/// <summary>
|
||||
|
/// The number of processing stripes represented for each plane.
|
||||
|
/// </summary>
|
||||
|
private readonly int[] stripeCounts = new int[Av1Constants.MaxPlanes]; |
||||
|
|
||||
|
/// <summary>
|
||||
|
/// Initializes a new instance of the <see cref="Av1LoopRestorationBoundary"/> class.
|
||||
|
/// </summary>
|
||||
|
/// <param name="sequenceHeader">The sequence header defining bit depth and chroma subsampling.</param>
|
||||
|
/// <param name="frameHeader">The frame header defining coded and upscaled dimensions.</param>
|
||||
|
/// <param name="frameBuffer">The reconstructed frame sampled before and after CDEF.</param>
|
||||
|
public Av1LoopRestorationBoundary( |
||||
|
ObuSequenceHeader sequenceHeader, |
||||
|
ObuFrameHeader frameHeader, |
||||
|
Av1FrameBuffer<byte> frameBuffer) |
||||
|
{ |
||||
|
this.sequenceHeader = sequenceHeader; |
||||
|
this.frameHeader = frameHeader; |
||||
|
this.frameBuffer = frameBuffer; |
||||
|
|
||||
|
try |
||||
|
{ |
||||
|
ObuColorConfig colorConfig = sequenceHeader.ColorConfig; |
||||
|
for (int planeIndex = 0; planeIndex < colorConfig.PlaneCount; planeIndex++) |
||||
|
{ |
||||
|
if (frameHeader.LoopRestorationParameters.Items[planeIndex].Type == ObuRestorationType.None) |
||||
|
{ |
||||
|
continue; |
||||
|
} |
||||
|
|
||||
|
Av1Plane plane = (Av1Plane)planeIndex; |
||||
|
int subsamplingX = plane != Av1Plane.Y && colorConfig.SubSamplingX ? 1 : 0; |
||||
|
int subsamplingY = plane != Av1Plane.Y && colorConfig.SubSamplingY ? 1 : 0; |
||||
|
int planeWidth = Av1Math.DivideLog2Ceiling( |
||||
|
frameHeader.FrameSize.SuperResolutionUpscaledWidth, |
||||
|
subsamplingX); |
||||
|
|
||||
|
int planeHeight = Av1Math.DivideLog2Ceiling(frameHeader.FrameSize.FrameHeight, subsamplingY); |
||||
|
int stripeHeight = ProcessingStripeSize >> subsamplingY; |
||||
|
int stripeOffset = ProcessingStripeOffset >> subsamplingY; |
||||
|
|
||||
|
// The stripe grid begins eight luma rows above the restoration-unit grid. Including
|
||||
|
// that offset in the ceiling retains the short final stripe when one is present.
|
||||
|
int stripeCount = (planeHeight + stripeOffset + stripeHeight - 1) / stripeHeight; |
||||
|
int storageLength = stripeCount * ContextRowCount * planeWidth; |
||||
|
this.planeWidths[planeIndex] = planeWidth; |
||||
|
this.stripeCounts[planeIndex] = stripeCount; |
||||
|
this.rowsAbove[planeIndex] = frameBuffer.MemoryAllocator.Allocate<ushort>(storageLength); |
||||
|
this.rowsBelow[planeIndex] = frameBuffer.MemoryAllocator.Allocate<ushort>(storageLength); |
||||
|
} |
||||
|
} |
||||
|
catch |
||||
|
{ |
||||
|
// The object is not available to its caller when construction fails, so release any
|
||||
|
// plane owners acquired before the allocator reported the failure.
|
||||
|
this.Dispose(); |
||||
|
throw; |
||||
|
} |
||||
|
} |
||||
|
|
||||
|
/// <summary>
|
||||
|
/// Releases the preserved plane-boundary storage.
|
||||
|
/// </summary>
|
||||
|
public void Dispose() |
||||
|
{ |
||||
|
for (int plane = 0; plane < Av1Constants.MaxPlanes; plane++) |
||||
|
{ |
||||
|
this.rowsAbove[plane]?.Dispose(); |
||||
|
this.rowsAbove[plane] = null; |
||||
|
this.rowsBelow[plane]?.Dispose(); |
||||
|
this.rowsBelow[plane] = null; |
||||
|
} |
||||
|
} |
||||
|
|
||||
|
/// <summary>
|
||||
|
/// Preserves deblocked rows at every internal restoration-stripe boundary.
|
||||
|
/// </summary>
|
||||
|
public void SaveDeblockedRows() |
||||
|
{ |
||||
|
ObuColorConfig colorConfig = this.sequenceHeader.ColorConfig; |
||||
|
ObuFrameSize frameSize = this.frameHeader.FrameSize; |
||||
|
bool usesSuperResolution = frameSize.FrameWidth != frameSize.SuperResolutionUpscaledWidth; |
||||
|
for (int planeIndex = 0; planeIndex < colorConfig.PlaneCount; planeIndex++) |
||||
|
{ |
||||
|
if (this.stripeCounts[planeIndex] == 0) |
||||
|
{ |
||||
|
continue; |
||||
|
} |
||||
|
|
||||
|
Av1Plane plane = (Av1Plane)planeIndex; |
||||
|
int subsamplingX = plane != Av1Plane.Y && colorConfig.SubSamplingX ? 1 : 0; |
||||
|
int subsamplingY = plane != Av1Plane.Y && colorConfig.SubSamplingY ? 1 : 0; |
||||
|
int codedWidth = Av1Math.DivideLog2Ceiling(frameSize.FrameWidth, subsamplingX); |
||||
|
int upscaledWidth = this.planeWidths[planeIndex]; |
||||
|
int reconstructedWidth = this.frameHeader.ModeInfoColumnCount |
||||
|
<< (Av1Constants.ModeInfoSizeLog2 - subsamplingX); |
||||
|
|
||||
|
// Super-resolution phase uses the coded width, while its filter taps can consume the
|
||||
|
// complete mode-info-aligned reconstruction at the right edge.
|
||||
|
int planeHeight = Av1Math.DivideLog2Ceiling(frameSize.FrameHeight, subsamplingY); |
||||
|
int stripeHeight = ProcessingStripeSize >> subsamplingY; |
||||
|
int stripeOffset = ProcessingStripeOffset >> subsamplingY; |
||||
|
int upscaleSourceLength = usesSuperResolution |
||||
|
? reconstructedWidth + (Av1SuperResolutionKernels.SourceBorder * 2) |
||||
|
: 0; |
||||
|
|
||||
|
using IMemoryOwner<ushort>? upscaleSourceOwner = usesSuperResolution |
||||
|
? this.frameBuffer.MemoryAllocator.Allocate<ushort>(upscaleSourceLength) |
||||
|
: null; |
||||
|
|
||||
|
Span<ushort> upscaleSource = upscaleSourceOwner is not null |
||||
|
? upscaleSourceOwner.Memory.Span[..upscaleSourceLength] |
||||
|
: Span<ushort>.Empty; |
||||
|
|
||||
|
Span<byte> lowBitDepthPlane = default; |
||||
|
Span<ushort> highBitDepthPlane = default; |
||||
|
int sourceStride; |
||||
|
if (this.frameBuffer.BytesPerSample == 2) |
||||
|
{ |
||||
|
Span<short> signedPlane = this.frameBuffer.DeriveBlockPointer16( |
||||
|
plane, |
||||
|
Point.Empty, |
||||
|
subsamplingX, |
||||
|
subsamplingY, |
||||
|
out sourceStride); |
||||
|
|
||||
|
highBitDepthPlane = MemoryMarshal.Cast<short, ushort>(signedPlane); |
||||
|
} |
||||
|
else |
||||
|
{ |
||||
|
lowBitDepthPlane = this.frameBuffer.DeriveBlockPointer( |
||||
|
plane, |
||||
|
Point.Empty, |
||||
|
subsamplingX, |
||||
|
subsamplingY, |
||||
|
out sourceStride); |
||||
|
} |
||||
|
|
||||
|
int step = usesSuperResolution |
||||
|
? Av1SuperResolutionKernels.GetConvolveStep(codedWidth, upscaledWidth) |
||||
|
: 0; |
||||
|
|
||||
|
int initialSubpixel = usesSuperResolution |
||||
|
? Av1SuperResolutionKernels.GetInitialSubpixel(codedWidth, upscaledWidth, step) |
||||
|
: 0; |
||||
|
|
||||
|
for (int stripe = 0; stripe < this.stripeCounts[planeIndex]; stripe++) |
||||
|
{ |
||||
|
int stripeStart = Math.Max(0, (stripe * stripeHeight) - stripeOffset); |
||||
|
int stripeEnd = Math.Min(((stripe + 1) * stripeHeight) - stripeOffset, planeHeight); |
||||
|
if (stripe > 0) |
||||
|
{ |
||||
|
// Internal top context is the two deblocked rows immediately preceding the
|
||||
|
// stripe; restoration later expands the first row to fill its three-row border.
|
||||
|
this.SaveDeblockedRow( |
||||
|
lowBitDepthPlane, |
||||
|
highBitDepthPlane, |
||||
|
sourceStride, |
||||
|
stripeStart - ContextRowCount, |
||||
|
reconstructedWidth, |
||||
|
step, |
||||
|
initialSubpixel, |
||||
|
upscaleSource, |
||||
|
this.GetBoundaryRow(this.rowsAbove, planeIndex, stripe, 0)); |
||||
|
|
||||
|
this.SaveDeblockedRow( |
||||
|
lowBitDepthPlane, |
||||
|
highBitDepthPlane, |
||||
|
sourceStride, |
||||
|
stripeStart - 1, |
||||
|
reconstructedWidth, |
||||
|
step, |
||||
|
initialSubpixel, |
||||
|
upscaleSource, |
||||
|
this.GetBoundaryRow(this.rowsAbove, planeIndex, stripe, 1)); |
||||
|
} |
||||
|
|
||||
|
if (stripeEnd < planeHeight) |
||||
|
{ |
||||
|
// Internal bottom context begins at the exclusive stripe end. A one-row tail
|
||||
|
// duplicates its final sample row, matching AV1 crop-edge clamping.
|
||||
|
this.SaveDeblockedRow( |
||||
|
lowBitDepthPlane, |
||||
|
highBitDepthPlane, |
||||
|
sourceStride, |
||||
|
stripeEnd, |
||||
|
reconstructedWidth, |
||||
|
step, |
||||
|
initialSubpixel, |
||||
|
upscaleSource, |
||||
|
this.GetBoundaryRow(this.rowsBelow, planeIndex, stripe, 0)); |
||||
|
|
||||
|
this.SaveDeblockedRow( |
||||
|
lowBitDepthPlane, |
||||
|
highBitDepthPlane, |
||||
|
sourceStride, |
||||
|
Math.Min(stripeEnd + 1, planeHeight - 1), |
||||
|
reconstructedWidth, |
||||
|
step, |
||||
|
initialSubpixel, |
||||
|
upscaleSource, |
||||
|
this.GetBoundaryRow(this.rowsBelow, planeIndex, stripe, 1)); |
||||
|
} |
||||
|
} |
||||
|
} |
||||
|
} |
||||
|
|
||||
|
/// <summary>
|
||||
|
/// Preserves the post-CDEF and post-super-resolution rows at the top and bottom of each active plane.
|
||||
|
/// </summary>
|
||||
|
public void SaveFrameEdgeRows() |
||||
|
{ |
||||
|
ObuColorConfig colorConfig = this.sequenceHeader.ColorConfig; |
||||
|
ObuFrameSize frameSize = this.frameHeader.FrameSize; |
||||
|
for (int planeIndex = 0; planeIndex < colorConfig.PlaneCount; planeIndex++) |
||||
|
{ |
||||
|
int stripeCount = this.stripeCounts[planeIndex]; |
||||
|
if (stripeCount == 0) |
||||
|
{ |
||||
|
continue; |
||||
|
} |
||||
|
|
||||
|
Av1Plane plane = (Av1Plane)planeIndex; |
||||
|
int subsamplingX = plane != Av1Plane.Y && colorConfig.SubSamplingX ? 1 : 0; |
||||
|
int subsamplingY = plane != Av1Plane.Y && colorConfig.SubSamplingY ? 1 : 0; |
||||
|
int planeHeight = Av1Math.DivideLog2Ceiling(frameSize.FrameHeight, subsamplingY); |
||||
|
Span<byte> lowBitDepthPlane = default; |
||||
|
Span<ushort> highBitDepthPlane = default; |
||||
|
int sourceStride; |
||||
|
if (this.frameBuffer.BytesPerSample == 2) |
||||
|
{ |
||||
|
Span<short> signedPlane = this.frameBuffer.DeriveBlockPointer16( |
||||
|
plane, |
||||
|
Point.Empty, |
||||
|
subsamplingX, |
||||
|
subsamplingY, |
||||
|
out sourceStride); |
||||
|
|
||||
|
highBitDepthPlane = MemoryMarshal.Cast<short, ushort>(signedPlane); |
||||
|
} |
||||
|
else |
||||
|
{ |
||||
|
lowBitDepthPlane = this.frameBuffer.DeriveBlockPointer( |
||||
|
plane, |
||||
|
Point.Empty, |
||||
|
subsamplingX, |
||||
|
subsamplingY, |
||||
|
out sourceStride); |
||||
|
} |
||||
|
|
||||
|
Span<ushort> topRow0 = this.GetBoundaryRow(this.rowsAbove, planeIndex, 0, 0); |
||||
|
Span<ushort> topRow1 = this.GetBoundaryRow(this.rowsAbove, planeIndex, 0, 1); |
||||
|
CopyFrameRow(lowBitDepthPlane, highBitDepthPlane, sourceStride, 0, topRow0); |
||||
|
|
||||
|
// Frame boundaries use post-CDEF/post-super-resolution samples and replicate the outer row.
|
||||
|
topRow0.CopyTo(topRow1); |
||||
|
|
||||
|
int lastStripe = stripeCount - 1; |
||||
|
Span<ushort> bottomRow0 = this.GetBoundaryRow(this.rowsBelow, planeIndex, lastStripe, 0); |
||||
|
Span<ushort> bottomRow1 = this.GetBoundaryRow(this.rowsBelow, planeIndex, lastStripe, 1); |
||||
|
CopyFrameRow(lowBitDepthPlane, highBitDepthPlane, sourceStride, planeHeight - 1, bottomRow0); |
||||
|
bottomRow0.CopyTo(bottomRow1); |
||||
|
} |
||||
|
} |
||||
|
|
||||
|
/// <summary>
|
||||
|
/// Gets one preserved row above a restoration processing stripe.
|
||||
|
/// </summary>
|
||||
|
/// <param name="plane">The zero-based color-plane index.</param>
|
||||
|
/// <param name="stripe">The frame-relative processing-stripe index.</param>
|
||||
|
/// <param name="contextRow">The first or second preserved context row.</param>
|
||||
|
/// <returns>The preserved upscaled row.</returns>
|
||||
|
public ReadOnlySpan<ushort> GetRowAbove(int plane, int stripe, int contextRow) |
||||
|
=> this.GetBoundaryRow(this.rowsAbove, plane, stripe, contextRow); |
||||
|
|
||||
|
/// <summary>
|
||||
|
/// Gets one preserved row below a restoration processing stripe.
|
||||
|
/// </summary>
|
||||
|
/// <param name="plane">The zero-based color-plane index.</param>
|
||||
|
/// <param name="stripe">The frame-relative processing-stripe index.</param>
|
||||
|
/// <param name="contextRow">The first or second preserved context row.</param>
|
||||
|
/// <returns>The preserved upscaled row.</returns>
|
||||
|
public ReadOnlySpan<ushort> GetRowBelow(int plane, int stripe, int contextRow) |
||||
|
=> this.GetBoundaryRow(this.rowsBelow, plane, stripe, contextRow); |
||||
|
|
||||
|
/// <summary>
|
||||
|
/// Preserves one deblocked row, applying normative super-resolution when the frame is scaled.
|
||||
|
/// </summary>
|
||||
|
/// <param name="lowBitDepthPlane">The byte-backed plane when the frame uses eight-bit samples.</param>
|
||||
|
/// <param name="highBitDepthPlane">The native 16-bit plane when the frame uses high-bit-depth samples.</param>
|
||||
|
/// <param name="sourceStride">The number of samples between reconstructed rows.</param>
|
||||
|
/// <param name="row">The reconstructed row to preserve.</param>
|
||||
|
/// <param name="reconstructedWidth">The mode-info-aligned width supplying super-resolution taps.</param>
|
||||
|
/// <param name="step">The fixed-point super-resolution source-position increment, or zero when unscaled.</param>
|
||||
|
/// <param name="initialSubpixel">The first super-resolution source position, or zero when unscaled.</param>
|
||||
|
/// <param name="upscaleSource">The replicated-edge super-resolution work row.</param>
|
||||
|
/// <param name="destination">The preserved upscaled boundary row.</param>
|
||||
|
private void SaveDeblockedRow( |
||||
|
ReadOnlySpan<byte> lowBitDepthPlane, |
||||
|
ReadOnlySpan<ushort> highBitDepthPlane, |
||||
|
int sourceStride, |
||||
|
int row, |
||||
|
int reconstructedWidth, |
||||
|
int step, |
||||
|
int initialSubpixel, |
||||
|
Span<ushort> upscaleSource, |
||||
|
Span<ushort> destination) |
||||
|
{ |
||||
|
if (upscaleSource.IsEmpty) |
||||
|
{ |
||||
|
CopyFrameRow(lowBitDepthPlane, highBitDepthPlane, sourceStride, row, destination); |
||||
|
return; |
||||
|
} |
||||
|
|
||||
|
int sourceStart = Av1SuperResolutionKernels.SourceBorder; |
||||
|
Span<ushort> reconstructedSamples = upscaleSource.Slice(sourceStart, reconstructedWidth); |
||||
|
CopyFrameRow(lowBitDepthPlane, highBitDepthPlane, sourceStride, row, reconstructedSamples); |
||||
|
|
||||
|
// Boundary rows must follow the same continuous phase and aligned right-edge behavior as
|
||||
|
// the full-frame super-resolution stage or restoration would see different stripe context.
|
||||
|
upscaleSource[..sourceStart].Fill(reconstructedSamples[0]); |
||||
|
upscaleSource[(sourceStart + reconstructedWidth)..].Fill(reconstructedSamples[^1]); |
||||
|
Av1SuperResolutionKernels.UpscaleRow( |
||||
|
upscaleSource, |
||||
|
destination, |
||||
|
step, |
||||
|
initialSubpixel, |
||||
|
this.frameBuffer.BitDepth.GetBitCount()); |
||||
|
} |
||||
|
|
||||
|
/// <summary>
|
||||
|
/// Copies one reconstructed sample row into 16-bit working storage.
|
||||
|
/// </summary>
|
||||
|
/// <param name="lowBitDepthPlane">The byte-backed plane when the frame uses eight-bit samples.</param>
|
||||
|
/// <param name="highBitDepthPlane">The native 16-bit plane when the frame uses high-bit-depth samples.</param>
|
||||
|
/// <param name="sourceStride">The number of samples between reconstructed rows.</param>
|
||||
|
/// <param name="row">The zero-based visible row index.</param>
|
||||
|
/// <param name="destination">The destination row whose length determines the copied width.</param>
|
||||
|
private static void CopyFrameRow( |
||||
|
ReadOnlySpan<byte> lowBitDepthPlane, |
||||
|
ReadOnlySpan<ushort> highBitDepthPlane, |
||||
|
int sourceStride, |
||||
|
int row, |
||||
|
Span<ushort> destination) |
||||
|
{ |
||||
|
int sourceOffset = sourceStride + (row * sourceStride); |
||||
|
if (!highBitDepthPlane.IsEmpty) |
||||
|
{ |
||||
|
highBitDepthPlane.Slice(sourceOffset, destination.Length).CopyTo(destination); |
||||
|
return; |
||||
|
} |
||||
|
|
||||
|
ReadOnlySpan<byte> source = lowBitDepthPlane.Slice(sourceOffset, destination.Length); |
||||
|
for (int column = 0; column < destination.Length; column++) |
||||
|
{ |
||||
|
destination[column] = source[column]; |
||||
|
} |
||||
|
} |
||||
|
|
||||
|
/// <summary>
|
||||
|
/// Gets writable storage for one plane-relative boundary row.
|
||||
|
/// </summary>
|
||||
|
/// <param name="storage">The above- or below-stripe storage for every plane.</param>
|
||||
|
/// <param name="plane">The zero-based color-plane index.</param>
|
||||
|
/// <param name="stripe">The frame-relative processing-stripe index.</param>
|
||||
|
/// <param name="contextRow">The first or second preserved context row.</param>
|
||||
|
/// <returns>The selected boundary-row span.</returns>
|
||||
|
private Span<ushort> GetBoundaryRow( |
||||
|
IMemoryOwner<ushort>?[] storage, |
||||
|
int plane, |
||||
|
int stripe, |
||||
|
int contextRow) |
||||
|
{ |
||||
|
int width = this.planeWidths[plane]; |
||||
|
int offset = ((stripe * ContextRowCount) + contextRow) * width; |
||||
|
return storage[plane]!.Memory.Span.Slice(offset, width); |
||||
|
} |
||||
|
} |
||||
@ -0,0 +1,562 @@ |
|||||
|
// Copyright (c) Six Labors.
|
||||
|
// Licensed under the Six Labors Split License.
|
||||
|
|
||||
|
using System.Buffers; |
||||
|
using System.Runtime.InteropServices; |
||||
|
using SixLabors.ImageSharp.Formats.Heif.Av1.OpenBitstreamUnit; |
||||
|
using SixLabors.ImageSharp.Formats.Heif.Av1.Tiling; |
||||
|
using SixLabors.ImageSharp.Memory; |
||||
|
|
||||
|
namespace SixLabors.ImageSharp.Formats.Heif.Av1.Pipeline.LoopRestoration; |
||||
|
|
||||
|
/// <summary>
|
||||
|
/// Applies decoded AV1 loop-restoration units to a reconstructed still-image frame.
|
||||
|
/// </summary>
|
||||
|
internal class Av1LoopRestorationDecoder |
||||
|
{ |
||||
|
/// <summary>
|
||||
|
/// The number of source rows and columns required around each filtered processing stripe.
|
||||
|
/// </summary>
|
||||
|
private const int FilterBorder = 3; |
||||
|
|
||||
|
/// <summary>
|
||||
|
/// The additional zero-coefficient tap read by the padded Wiener convolution kernel.
|
||||
|
/// </summary>
|
||||
|
private const int WienerPadding = 1; |
||||
|
|
||||
|
/// <summary>
|
||||
|
/// The sequence-level bit-depth and plane-layout configuration.
|
||||
|
/// </summary>
|
||||
|
private readonly ObuSequenceHeader sequenceHeader; |
||||
|
|
||||
|
/// <summary>
|
||||
|
/// The frame-level restoration-unit and dimension configuration.
|
||||
|
/// </summary>
|
||||
|
private readonly ObuFrameHeader frameHeader; |
||||
|
|
||||
|
/// <summary>
|
||||
|
/// The decoded restoration filter and coefficient selections.
|
||||
|
/// </summary>
|
||||
|
private readonly Av1FrameInfo frameInfo; |
||||
|
|
||||
|
/// <summary>
|
||||
|
/// The reconstructed sample planes updated with restored output.
|
||||
|
/// </summary>
|
||||
|
private readonly Av1FrameBuffer<byte> frameBuffer; |
||||
|
|
||||
|
/// <summary>
|
||||
|
/// The preserved deblocked rows used at restoration-stripe boundaries.
|
||||
|
/// </summary>
|
||||
|
private readonly Av1LoopRestorationBoundary boundary; |
||||
|
|
||||
|
/// <summary>
|
||||
|
/// Initializes a new instance of the <see cref="Av1LoopRestorationDecoder"/> class.
|
||||
|
/// </summary>
|
||||
|
/// <param name="sequenceHeader">The sequence header defining bit depth and chroma subsampling.</param>
|
||||
|
/// <param name="frameHeader">The frame header defining restoration-unit sizes and frame dimensions.</param>
|
||||
|
/// <param name="frameInfo">The decoded restoration-unit selections and coefficients.</param>
|
||||
|
/// <param name="frameBuffer">The CDEF-filtered and upscaled frame samples.</param>
|
||||
|
/// <param name="boundary">The deblocked context preserved around restoration stripes.</param>
|
||||
|
public Av1LoopRestorationDecoder( |
||||
|
ObuSequenceHeader sequenceHeader, |
||||
|
ObuFrameHeader frameHeader, |
||||
|
Av1FrameInfo frameInfo, |
||||
|
Av1FrameBuffer<byte> frameBuffer, |
||||
|
Av1LoopRestorationBoundary boundary) |
||||
|
{ |
||||
|
this.sequenceHeader = sequenceHeader; |
||||
|
this.frameHeader = frameHeader; |
||||
|
this.frameInfo = frameInfo; |
||||
|
this.frameBuffer = frameBuffer; |
||||
|
this.boundary = boundary; |
||||
|
} |
||||
|
|
||||
|
/// <summary>
|
||||
|
/// Restores every active color plane from an immutable post-super-resolution source snapshot.
|
||||
|
/// </summary>
|
||||
|
public void DecodeFrame() |
||||
|
{ |
||||
|
ObuColorConfig colorConfig = this.sequenceHeader.ColorConfig; |
||||
|
for (int planeIndex = 0; planeIndex < colorConfig.PlaneCount; planeIndex++) |
||||
|
{ |
||||
|
ObuLoopRestorationItem item = this.frameHeader.LoopRestorationParameters.Items[planeIndex]; |
||||
|
if (item.Type == ObuRestorationType.None) |
||||
|
{ |
||||
|
continue; |
||||
|
} |
||||
|
|
||||
|
Av1Plane plane = (Av1Plane)planeIndex; |
||||
|
int subsamplingX = plane != Av1Plane.Y && colorConfig.SubSamplingX ? 1 : 0; |
||||
|
int subsamplingY = plane != Av1Plane.Y && colorConfig.SubSamplingY ? 1 : 0; |
||||
|
this.DecodePlane(plane, subsamplingX, subsamplingY, item.Size); |
||||
|
} |
||||
|
} |
||||
|
|
||||
|
/// <summary>
|
||||
|
/// Restores one color plane in raster-ordered restoration units.
|
||||
|
/// </summary>
|
||||
|
/// <param name="plane">The luma or chroma plane.</param>
|
||||
|
/// <param name="subsamplingX">The horizontal chroma subsampling shift.</param>
|
||||
|
/// <param name="subsamplingY">The vertical chroma subsampling shift.</param>
|
||||
|
/// <param name="unitSize">The nominal restoration-unit width and height in plane samples.</param>
|
||||
|
private void DecodePlane(Av1Plane plane, int subsamplingX, int subsamplingY, int unitSize) |
||||
|
{ |
||||
|
int planeIndex = (int)plane; |
||||
|
ObuFrameSize frameSize = this.frameHeader.FrameSize; |
||||
|
int planeWidth = Av1Math.DivideLog2Ceiling(frameSize.SuperResolutionUpscaledWidth, subsamplingX); |
||||
|
int planeHeight = Av1Math.DivideLog2Ceiling(frameSize.FrameHeight, subsamplingY); |
||||
|
int planeLength = planeWidth * planeHeight; |
||||
|
MemoryAllocator allocator = this.frameBuffer.MemoryAllocator; |
||||
|
using IMemoryOwner<ushort> sourceOwner = allocator.Allocate<ushort>(planeLength); |
||||
|
using IMemoryOwner<ushort> destinationOwner = allocator.Allocate<ushort>(planeLength); |
||||
|
Span<ushort> source = sourceOwner.Memory.Span[..planeLength]; |
||||
|
Span<ushort> destination = destinationOwner.Memory.Span[..planeLength]; |
||||
|
|
||||
|
// Restoration units overlap in their filter context but not in their output. A separate
|
||||
|
// destination prevents later units from observing already restored neighboring samples.
|
||||
|
this.CopyPlaneToWorkingBuffer(plane, subsamplingX, subsamplingY, planeWidth, planeHeight, source); |
||||
|
|
||||
|
// AV1 lets the last unit absorb a remainder smaller than 150 percent of the nominal size.
|
||||
|
// Size scratch storage for that largest legal unit rather than the nominal grid step.
|
||||
|
int extendedUnitSize = (unitSize * 3) / 2; |
||||
|
int maximumUnitWidth = Math.Min(extendedUnitSize, planeWidth); |
||||
|
int maximumStripeHeight = Av1LoopRestorationBoundary.ProcessingStripeSize >> subsamplingY; |
||||
|
int borderedStride = maximumUnitWidth + (FilterBorder * 2) + WienerPadding; |
||||
|
int borderedLength = borderedStride * (maximumStripeHeight + (FilterBorder * 2) + WienerPadding); |
||||
|
int wienerScratchLength = Av1WienerFilter.GetScratchLength(maximumUnitWidth, maximumStripeHeight); |
||||
|
using IMemoryOwner<ushort> borderedSourceOwner = allocator.Allocate<ushort>(borderedLength); |
||||
|
using IMemoryOwner<ushort> wienerScratchOwner = allocator.Allocate<ushort>(wienerScratchLength); |
||||
|
Span<ushort> borderedSource = borderedSourceOwner.Memory.Span[..borderedLength]; |
||||
|
Span<ushort> wienerScratch = wienerScratchOwner.Memory.Span[..wienerScratchLength]; |
||||
|
int processingUnitWidth = Av1LoopRestorationBoundary.ProcessingStripeSize >> subsamplingX; |
||||
|
int maximumSelfGuidedWidth = Math.Min(processingUnitWidth, maximumUnitWidth); |
||||
|
int selfGuidedScratchLength = Av1SelfGuidedFilter.GetScratchLength(maximumSelfGuidedWidth, maximumStripeHeight); |
||||
|
using IMemoryOwner<int> selfGuidedScratchOwner = allocator.Allocate<int>(selfGuidedScratchLength); |
||||
|
Span<int> selfGuidedScratch = selfGuidedScratchOwner.Memory.Span[..selfGuidedScratchLength]; |
||||
|
|
||||
|
int unitRowCount = this.frameInfo.GetLoopRestorationUnitRowCount(planeIndex); |
||||
|
int unitColumnCount = this.frameInfo.GetLoopRestorationUnitColumnCount(planeIndex); |
||||
|
int unitY = 0; |
||||
|
for (int unitRow = 0; unitRow < unitRowCount; unitRow++) |
||||
|
{ |
||||
|
int remainingHeight = planeHeight - unitY; |
||||
|
int unadjustedUnitHeight = remainingHeight < extendedUnitSize ? remainingHeight : unitSize; |
||||
|
int verticalStart = unitY; |
||||
|
int verticalEnd = unitY + unadjustedUnitHeight; |
||||
|
int verticalOffset = Av1LoopRestorationBoundary.ProcessingStripeOffset >> subsamplingY; |
||||
|
|
||||
|
// Unit ownership is signaled on the unshifted grid, but filtering rows follow the
|
||||
|
// processing-stripe grid positioned eight luma samples above it.
|
||||
|
verticalStart = Math.Max(0, verticalStart - verticalOffset); |
||||
|
if (verticalEnd < planeHeight) |
||||
|
{ |
||||
|
verticalEnd -= verticalOffset; |
||||
|
} |
||||
|
|
||||
|
int unitX = 0; |
||||
|
for (int unitColumn = 0; unitColumn < unitColumnCount; unitColumn++) |
||||
|
{ |
||||
|
int remainingWidth = planeWidth - unitX; |
||||
|
int unitWidth = remainingWidth < extendedUnitSize ? remainingWidth : unitSize; |
||||
|
Av1LoopRestorationUnit unit = this.frameInfo.GetLoopRestorationUnit( |
||||
|
planeIndex, |
||||
|
unitRow, |
||||
|
unitColumn); |
||||
|
|
||||
|
this.FilterUnit( |
||||
|
planeIndex, |
||||
|
subsamplingX, |
||||
|
source, |
||||
|
destination, |
||||
|
planeWidth, |
||||
|
planeHeight, |
||||
|
unitX, |
||||
|
unitX + unitWidth, |
||||
|
verticalStart, |
||||
|
verticalEnd, |
||||
|
unit, |
||||
|
borderedSource, |
||||
|
wienerScratch, |
||||
|
selfGuidedScratch); |
||||
|
|
||||
|
unitX += unitWidth; |
||||
|
} |
||||
|
|
||||
|
unitY += unadjustedUnitHeight; |
||||
|
} |
||||
|
|
||||
|
this.CopyWorkingBufferToPlane(plane, subsamplingX, subsamplingY, planeWidth, planeHeight, destination); |
||||
|
} |
||||
|
|
||||
|
/// <summary>
|
||||
|
/// Copies or filters one restoration unit without reading already restored destination samples.
|
||||
|
/// </summary>
|
||||
|
/// <param name="plane">The zero-based color-plane index.</param>
|
||||
|
/// <param name="subsamplingX">The horizontal chroma subsampling shift.</param>
|
||||
|
/// <param name="source">The immutable post-super-resolution plane samples.</param>
|
||||
|
/// <param name="destination">The restored destination plane samples.</param>
|
||||
|
/// <param name="planeWidth">The visible plane width.</param>
|
||||
|
/// <param name="planeHeight">The visible plane height.</param>
|
||||
|
/// <param name="horizontalStart">The unit's first plane column.</param>
|
||||
|
/// <param name="horizontalEnd">The exclusive unit column limit.</param>
|
||||
|
/// <param name="verticalStart">The unit's stripe-aligned first plane row.</param>
|
||||
|
/// <param name="verticalEnd">The exclusive unit row limit.</param>
|
||||
|
/// <param name="unit">The decoded unit filter and coefficients.</param>
|
||||
|
/// <param name="borderedSource">Reusable storage for one bordered processing stripe.</param>
|
||||
|
/// <param name="wienerScratch">Reusable Wiener intermediate storage.</param>
|
||||
|
/// <param name="selfGuidedScratch">Reusable self-guided intermediate storage.</param>
|
||||
|
private void FilterUnit( |
||||
|
int plane, |
||||
|
int subsamplingX, |
||||
|
ReadOnlySpan<ushort> source, |
||||
|
Span<ushort> destination, |
||||
|
int planeWidth, |
||||
|
int planeHeight, |
||||
|
int horizontalStart, |
||||
|
int horizontalEnd, |
||||
|
int verticalStart, |
||||
|
int verticalEnd, |
||||
|
Av1LoopRestorationUnit unit, |
||||
|
Span<ushort> borderedSource, |
||||
|
Span<ushort> wienerScratch, |
||||
|
Span<int> selfGuidedScratch) |
||||
|
{ |
||||
|
int unitWidth = horizontalEnd - horizontalStart; |
||||
|
if (unit.FilterType == Av1RestorationFilterType.None) |
||||
|
{ |
||||
|
// Every output sample still belongs to exactly one unit, including units that select
|
||||
|
// RESTORE_NONE, so copy the immutable source rectangle into the destination plane.
|
||||
|
CopyRectangle( |
||||
|
source, |
||||
|
destination, |
||||
|
planeWidth, |
||||
|
horizontalStart, |
||||
|
unitWidth, |
||||
|
verticalStart, |
||||
|
verticalEnd); |
||||
|
|
||||
|
return; |
||||
|
} |
||||
|
|
||||
|
int subsamplingY = plane == (int)Av1Plane.Y || !this.sequenceHeader.ColorConfig.SubSamplingY ? 0 : 1; |
||||
|
int fullStripeHeight = Av1LoopRestorationBoundary.ProcessingStripeSize >> subsamplingY; |
||||
|
int stripeOffset = Av1LoopRestorationBoundary.ProcessingStripeOffset >> subsamplingY; |
||||
|
int unitHeight = verticalEnd - verticalStart; |
||||
|
for (int unitRow = 0; unitRow < unitHeight;) |
||||
|
{ |
||||
|
int stripeStart = verticalStart + unitRow; |
||||
|
int frameStripe = (stripeStart + stripeOffset) / fullStripeHeight; |
||||
|
int nominalStripeHeight = fullStripeHeight - (frameStripe == 0 ? stripeOffset : 0); |
||||
|
int stripeHeight = Math.Min(nominalStripeHeight, verticalEnd - stripeStart); |
||||
|
|
||||
|
// The first frame stripe is shortened by the upward offset; subsequent stripes remain
|
||||
|
// 64 luma samples high, with the current unit limiting only the final iteration.
|
||||
|
if (unit.FilterType == Av1RestorationFilterType.Wiener) |
||||
|
{ |
||||
|
int sourceStride = unitWidth + (FilterBorder * 2) + WienerPadding; |
||||
|
int sourceLength = sourceStride * (stripeHeight + (FilterBorder * 2) + WienerPadding); |
||||
|
Span<ushort> filterSource = borderedSource[..sourceLength]; |
||||
|
this.PopulateBorderedSource( |
||||
|
plane, |
||||
|
frameStripe, |
||||
|
source, |
||||
|
planeWidth, |
||||
|
planeHeight, |
||||
|
horizontalStart, |
||||
|
unitWidth, |
||||
|
stripeStart, |
||||
|
stripeHeight, |
||||
|
sourceStride, |
||||
|
filterSource); |
||||
|
|
||||
|
int destinationOffset = (stripeStart * planeWidth) + horizontalStart; |
||||
|
int scratchLength = Av1WienerFilter.GetScratchLength(unitWidth, stripeHeight); |
||||
|
Av1WienerFilter.FilterStripe( |
||||
|
filterSource, |
||||
|
sourceStride, |
||||
|
destination[destinationOffset..], |
||||
|
planeWidth, |
||||
|
unitWidth, |
||||
|
stripeHeight, |
||||
|
this.frameBuffer.BitDepth.GetBitCount(), |
||||
|
unit.WienerHorizontal, |
||||
|
unit.WienerVertical, |
||||
|
wienerScratch[..scratchLength]); |
||||
|
} |
||||
|
else |
||||
|
{ |
||||
|
int processingUnitWidth = Av1LoopRestorationBoundary.ProcessingStripeSize >> subsamplingX; |
||||
|
|
||||
|
// Self-guided local statistics restart at each normative 64-luma processing unit.
|
||||
|
// Context still crosses the chunk boundary because the source is the full plane.
|
||||
|
for (int unitColumn = 0; unitColumn < unitWidth; unitColumn += processingUnitWidth) |
||||
|
{ |
||||
|
int blockWidth = Math.Min(processingUnitWidth, unitWidth - unitColumn); |
||||
|
int blockStart = horizontalStart + unitColumn; |
||||
|
int sourceStride = blockWidth + (FilterBorder * 2) + WienerPadding; |
||||
|
int sourceLength = sourceStride * (stripeHeight + (FilterBorder * 2) + WienerPadding); |
||||
|
Span<ushort> filterSource = borderedSource[..sourceLength]; |
||||
|
this.PopulateBorderedSource( |
||||
|
plane, |
||||
|
frameStripe, |
||||
|
source, |
||||
|
planeWidth, |
||||
|
planeHeight, |
||||
|
blockStart, |
||||
|
blockWidth, |
||||
|
stripeStart, |
||||
|
stripeHeight, |
||||
|
sourceStride, |
||||
|
filterSource); |
||||
|
|
||||
|
int destinationOffset = (stripeStart * planeWidth) + blockStart; |
||||
|
int scratchLength = Av1SelfGuidedFilter.GetScratchLength(blockWidth, stripeHeight); |
||||
|
Av1SelfGuidedFilter.FilterBlock( |
||||
|
filterSource, |
||||
|
sourceStride, |
||||
|
destination[destinationOffset..], |
||||
|
planeWidth, |
||||
|
blockWidth, |
||||
|
stripeHeight, |
||||
|
this.frameBuffer.BitDepth.GetBitCount(), |
||||
|
unit.SgrParameterSet, |
||||
|
unit.SgrProjectionCoefficients, |
||||
|
selfGuidedScratch[..scratchLength]); |
||||
|
} |
||||
|
} |
||||
|
|
||||
|
unitRow += stripeHeight; |
||||
|
} |
||||
|
} |
||||
|
|
||||
|
/// <summary>
|
||||
|
/// Builds one filter source rectangle with normative horizontal and stripe-boundary extension.
|
||||
|
/// </summary>
|
||||
|
/// <param name="plane">The zero-based color-plane index.</param>
|
||||
|
/// <param name="frameStripe">The frame-relative processing-stripe index.</param>
|
||||
|
/// <param name="source">The immutable post-super-resolution plane samples.</param>
|
||||
|
/// <param name="planeWidth">The visible plane width.</param>
|
||||
|
/// <param name="planeHeight">The visible plane height.</param>
|
||||
|
/// <param name="blockStart">The first filtered plane column.</param>
|
||||
|
/// <param name="blockWidth">The number of filtered columns.</param>
|
||||
|
/// <param name="stripeStart">The first filtered plane row.</param>
|
||||
|
/// <param name="stripeHeight">The number of filtered rows.</param>
|
||||
|
/// <param name="destinationStride">The number of samples between bordered destination rows.</param>
|
||||
|
/// <param name="destination">The bordered filter source rectangle.</param>
|
||||
|
private void PopulateBorderedSource( |
||||
|
int plane, |
||||
|
int frameStripe, |
||||
|
ReadOnlySpan<ushort> source, |
||||
|
int planeWidth, |
||||
|
int planeHeight, |
||||
|
int blockStart, |
||||
|
int blockWidth, |
||||
|
int stripeStart, |
||||
|
int stripeHeight, |
||||
|
int destinationStride, |
||||
|
Span<ushort> destination) |
||||
|
{ |
||||
|
int stripeEnd = stripeStart + stripeHeight; |
||||
|
int sourceRowCount = stripeHeight + (FilterBorder * 2) + WienerPadding; |
||||
|
for (int destinationRow = 0; destinationRow < sourceRowCount; destinationRow++) |
||||
|
{ |
||||
|
int sourceY = stripeStart + destinationRow - FilterBorder; |
||||
|
ReadOnlySpan<ushort> sourceRow; |
||||
|
if (sourceY < 0) |
||||
|
{ |
||||
|
sourceRow = this.boundary.GetRowAbove(plane, frameStripe, 0); |
||||
|
} |
||||
|
else if (sourceY < stripeStart) |
||||
|
{ |
||||
|
// Two preserved deblocked rows expand to three filter rows as [0, 0, 1].
|
||||
|
int contextRow = Math.Min(Math.Max(destinationRow - 1, 0), 1); |
||||
|
sourceRow = this.boundary.GetRowAbove(plane, frameStripe, contextRow); |
||||
|
} |
||||
|
else if (sourceY >= planeHeight) |
||||
|
{ |
||||
|
sourceRow = this.boundary.GetRowBelow(plane, frameStripe, 0); |
||||
|
} |
||||
|
else if (sourceY >= stripeEnd) |
||||
|
{ |
||||
|
// The bottom expansion is [0, 1, 1]; the padded Wiener zero tap also reads row 1.
|
||||
|
int contextRow = Math.Min(sourceY - stripeEnd, 1); |
||||
|
sourceRow = this.boundary.GetRowBelow(plane, frameStripe, contextRow); |
||||
|
} |
||||
|
else |
||||
|
{ |
||||
|
sourceRow = source.Slice(sourceY * planeWidth, planeWidth); |
||||
|
} |
||||
|
|
||||
|
Span<ushort> destinationRowSpan = destination.Slice(destinationRow * destinationStride, destinationStride); |
||||
|
int sourceX = blockStart - FilterBorder; |
||||
|
int leftExtension = Math.Max(-sourceX, 0); |
||||
|
|
||||
|
// Horizontal context crosses restoration-unit and self-guided processing-unit edges.
|
||||
|
// Replication occurs only at the visible frame boundary.
|
||||
|
if (leftExtension > 0) |
||||
|
{ |
||||
|
destinationRowSpan[..leftExtension].Fill(sourceRow[0]); |
||||
|
} |
||||
|
|
||||
|
int copiedStart = Math.Max(sourceX, 0); |
||||
|
int copiedEnd = Math.Min(sourceX + destinationStride, planeWidth); |
||||
|
int copiedLength = copiedEnd - copiedStart; |
||||
|
sourceRow.Slice(copiedStart, copiedLength).CopyTo(destinationRowSpan[leftExtension..]); |
||||
|
|
||||
|
int populatedLength = leftExtension + copiedLength; |
||||
|
if (populatedLength < destinationStride) |
||||
|
{ |
||||
|
destinationRowSpan[populatedLength..].Fill(sourceRow[^1]); |
||||
|
} |
||||
|
} |
||||
|
} |
||||
|
|
||||
|
/// <summary>
|
||||
|
/// Copies an unfiltered restoration-unit rectangle between plane working buffers.
|
||||
|
/// </summary>
|
||||
|
/// <param name="source">The immutable source plane.</param>
|
||||
|
/// <param name="destination">The destination plane.</param>
|
||||
|
/// <param name="planeWidth">The number of samples between plane rows.</param>
|
||||
|
/// <param name="horizontalStart">The first copied column.</param>
|
||||
|
/// <param name="width">The number of copied columns.</param>
|
||||
|
/// <param name="verticalStart">The first copied row.</param>
|
||||
|
/// <param name="verticalEnd">The exclusive copied row limit.</param>
|
||||
|
private static void CopyRectangle( |
||||
|
ReadOnlySpan<ushort> source, |
||||
|
Span<ushort> destination, |
||||
|
int planeWidth, |
||||
|
int horizontalStart, |
||||
|
int width, |
||||
|
int verticalStart, |
||||
|
int verticalEnd) |
||||
|
{ |
||||
|
for (int row = verticalStart; row < verticalEnd; row++) |
||||
|
{ |
||||
|
int offset = (row * planeWidth) + horizontalStart; |
||||
|
source.Slice(offset, width).CopyTo(destination[offset..]); |
||||
|
} |
||||
|
} |
||||
|
|
||||
|
/// <summary>
|
||||
|
/// Copies one reconstructed plane into an immutable 16-bit working buffer.
|
||||
|
/// </summary>
|
||||
|
/// <param name="plane">The luma or chroma plane.</param>
|
||||
|
/// <param name="subsamplingX">The horizontal chroma subsampling shift.</param>
|
||||
|
/// <param name="subsamplingY">The vertical chroma subsampling shift.</param>
|
||||
|
/// <param name="planeWidth">The visible plane width.</param>
|
||||
|
/// <param name="planeHeight">The visible plane height.</param>
|
||||
|
/// <param name="destination">The row-major working buffer.</param>
|
||||
|
private void CopyPlaneToWorkingBuffer( |
||||
|
Av1Plane plane, |
||||
|
int subsamplingX, |
||||
|
int subsamplingY, |
||||
|
int planeWidth, |
||||
|
int planeHeight, |
||||
|
Span<ushort> destination) |
||||
|
{ |
||||
|
Span<byte> lowBitDepthPlane = default; |
||||
|
Span<ushort> highBitDepthPlane = default; |
||||
|
int sourceStride; |
||||
|
if (this.frameBuffer.BytesPerSample == 2) |
||||
|
{ |
||||
|
Span<short> signedPlane = this.frameBuffer.DeriveBlockPointer16( |
||||
|
plane, |
||||
|
Point.Empty, |
||||
|
subsamplingX, |
||||
|
subsamplingY, |
||||
|
out sourceStride); |
||||
|
|
||||
|
highBitDepthPlane = MemoryMarshal.Cast<short, ushort>(signedPlane); |
||||
|
} |
||||
|
else |
||||
|
{ |
||||
|
lowBitDepthPlane = this.frameBuffer.DeriveBlockPointer( |
||||
|
plane, |
||||
|
Point.Empty, |
||||
|
subsamplingX, |
||||
|
subsamplingY, |
||||
|
out sourceStride); |
||||
|
} |
||||
|
|
||||
|
for (int row = 0; row < planeHeight; row++) |
||||
|
{ |
||||
|
// DeriveBlockPointer spans begin on the row above the visible origin for prediction,
|
||||
|
// hence the leading stride in every frame-relative row offset.
|
||||
|
int frameOffset = sourceStride + (row * sourceStride); |
||||
|
Span<ushort> destinationRow = destination.Slice(row * planeWidth, planeWidth); |
||||
|
if (!highBitDepthPlane.IsEmpty) |
||||
|
{ |
||||
|
highBitDepthPlane.Slice(frameOffset, planeWidth).CopyTo(destinationRow); |
||||
|
} |
||||
|
else |
||||
|
{ |
||||
|
ReadOnlySpan<byte> sourceRow = lowBitDepthPlane.Slice(frameOffset, planeWidth); |
||||
|
for (int column = 0; column < planeWidth; column++) |
||||
|
{ |
||||
|
destinationRow[column] = sourceRow[column]; |
||||
|
} |
||||
|
} |
||||
|
} |
||||
|
} |
||||
|
|
||||
|
/// <summary>
|
||||
|
/// Copies one restored 16-bit working buffer back to its reconstructed plane.
|
||||
|
/// </summary>
|
||||
|
/// <param name="plane">The luma or chroma plane.</param>
|
||||
|
/// <param name="subsamplingX">The horizontal chroma subsampling shift.</param>
|
||||
|
/// <param name="subsamplingY">The vertical chroma subsampling shift.</param>
|
||||
|
/// <param name="planeWidth">The visible plane width.</param>
|
||||
|
/// <param name="planeHeight">The visible plane height.</param>
|
||||
|
/// <param name="source">The row-major restored working buffer.</param>
|
||||
|
private void CopyWorkingBufferToPlane( |
||||
|
Av1Plane plane, |
||||
|
int subsamplingX, |
||||
|
int subsamplingY, |
||||
|
int planeWidth, |
||||
|
int planeHeight, |
||||
|
ReadOnlySpan<ushort> source) |
||||
|
{ |
||||
|
Span<byte> lowBitDepthPlane = default; |
||||
|
Span<ushort> highBitDepthPlane = default; |
||||
|
int destinationStride; |
||||
|
if (this.frameBuffer.BytesPerSample == 2) |
||||
|
{ |
||||
|
Span<short> signedPlane = this.frameBuffer.DeriveBlockPointer16( |
||||
|
plane, |
||||
|
Point.Empty, |
||||
|
subsamplingX, |
||||
|
subsamplingY, |
||||
|
out destinationStride); |
||||
|
|
||||
|
highBitDepthPlane = MemoryMarshal.Cast<short, ushort>(signedPlane); |
||||
|
} |
||||
|
else |
||||
|
{ |
||||
|
lowBitDepthPlane = this.frameBuffer.DeriveBlockPointer( |
||||
|
plane, |
||||
|
Point.Empty, |
||||
|
subsamplingX, |
||||
|
subsamplingY, |
||||
|
out destinationStride); |
||||
|
} |
||||
|
|
||||
|
for (int row = 0; row < planeHeight; row++) |
||||
|
{ |
||||
|
// The destination view has the same preceding prediction row as the source view.
|
||||
|
int frameOffset = destinationStride + (row * destinationStride); |
||||
|
ReadOnlySpan<ushort> sourceRow = source.Slice(row * planeWidth, planeWidth); |
||||
|
if (!highBitDepthPlane.IsEmpty) |
||||
|
{ |
||||
|
sourceRow.CopyTo(highBitDepthPlane[frameOffset..]); |
||||
|
} |
||||
|
else |
||||
|
{ |
||||
|
Span<byte> destinationRow = lowBitDepthPlane.Slice(frameOffset, planeWidth); |
||||
|
for (int column = 0; column < planeWidth; column++) |
||||
|
{ |
||||
|
destinationRow[column] = (byte)sourceRow[column]; |
||||
|
} |
||||
|
} |
||||
|
} |
||||
|
} |
||||
|
} |
||||
Loading…
Reference in new issue