mirror of https://github.com/SixLabors/ImageSharp
James Jackson-South
2 months ago
16 changed files with 1224 additions and 1282 deletions
@ -1,455 +0,0 @@ |
|||||
// Copyright (c) Six Labors.
|
|
||||
// Licensed under the Six Labors Split License.
|
|
||||
|
|
||||
using System.Runtime.InteropServices; |
|
||||
using SixLabors.ImageSharp.Advanced; |
|
||||
using SixLabors.ImageSharp.Common.Helpers; |
|
||||
using SixLabors.ImageSharp.Formats.Heif.Av1.OpenBitstreamUnit; |
|
||||
using SixLabors.ImageSharp.Formats.Heif.Color; |
|
||||
using SixLabors.ImageSharp.Memory; |
|
||||
using SixLabors.ImageSharp.PixelFormats; |
|
||||
using static SixLabors.ImageSharp.Formats.Heif.Color.HeifColorConverterBase; |
|
||||
|
|
||||
namespace SixLabors.ImageSharp.Formats.Heif.Av1; |
|
||||
|
|
||||
/// <content>
|
|
||||
/// Provides the pooled row converters used by AV1 color conversion.
|
|
||||
/// </content>
|
|
||||
internal static partial class Av1YuvConverter |
|
||||
{ |
|
||||
/// <summary>
|
|
||||
/// Converts one reconstructed AV1 row using frame-scoped pooled component, chroma, and packed-pixel storage.
|
|
||||
/// </summary>
|
|
||||
/// <typeparam name="TPixel">The destination pixel type.</typeparam>
|
|
||||
/// <typeparam name="TSample">The reconstructed sample type.</typeparam>
|
|
||||
/// <typeparam name="TLoader">The SIMD widening operations for the sample type.</typeparam>
|
|
||||
private readonly struct YuvToRgbRowConverter<TPixel, TSample, TLoader> |
|
||||
where TPixel : unmanaged, IPixel<TPixel> |
|
||||
where TSample : unmanaged |
|
||||
where TLoader : struct, IHeifSampleLoader<TSample> |
|
||||
{ |
|
||||
/// <summary>
|
|
||||
/// The configuration used by bulk pixel conversion.
|
|
||||
/// </summary>
|
|
||||
private readonly Configuration configuration; |
|
||||
|
|
||||
/// <summary>
|
|
||||
/// The reconstructed AV1 frame containing the source planes.
|
|
||||
/// </summary>
|
|
||||
private readonly Av1FrameBuffer<byte> frameBuffer; |
|
||||
|
|
||||
/// <summary>
|
|
||||
/// The destination image frame.
|
|
||||
/// </summary>
|
|
||||
private readonly ImageFrame<TPixel> image; |
|
||||
|
|
||||
/// <summary>
|
|
||||
/// The full-resolution luma plane.
|
|
||||
/// </summary>
|
|
||||
private readonly Buffer2DRegion<byte> yPlane; |
|
||||
|
|
||||
/// <summary>
|
|
||||
/// The blue-difference plane when the frame contains chroma.
|
|
||||
/// </summary>
|
|
||||
private readonly Buffer2DRegion<byte> uPlane; |
|
||||
|
|
||||
/// <summary>
|
|
||||
/// The red-difference plane when the frame contains chroma.
|
|
||||
/// </summary>
|
|
||||
private readonly Buffer2DRegion<byte> vPlane; |
|
||||
|
|
||||
/// <summary>
|
|
||||
/// The frame-scoped color-model converter.
|
|
||||
/// </summary>
|
|
||||
private readonly HeifColorConverterBase colorConverter; |
|
||||
|
|
||||
/// <summary>
|
|
||||
/// The signaled chroma sample position used for reconstruction.
|
|
||||
/// </summary>
|
|
||||
private readonly ObuChromoSamplePosition chromaSamplePosition; |
|
||||
|
|
||||
/// <summary>
|
|
||||
/// Whether the source contains only a luma plane.
|
|
||||
/// </summary>
|
|
||||
private readonly bool isMonochrome; |
|
||||
|
|
||||
/// <summary>
|
|
||||
/// The horizontal chroma subsampling shift.
|
|
||||
/// </summary>
|
|
||||
private readonly int subX; |
|
||||
|
|
||||
/// <summary>
|
|
||||
/// The vertical chroma subsampling shift.
|
|
||||
/// </summary>
|
|
||||
private readonly int subY; |
|
||||
|
|
||||
/// <summary>
|
|
||||
/// Initializes a new instance of the <see cref="YuvToRgbRowConverter{TPixel, TSample, TLoader}"/> struct.
|
|
||||
/// </summary>
|
|
||||
/// <param name="configuration">The configuration used for packed-pixel conversion.</param>
|
|
||||
/// <param name="frameBuffer">The reconstructed AV1 frame.</param>
|
|
||||
/// <param name="image">The destination image frame.</param>
|
|
||||
/// <param name="colorConverter">The selected H.273 color converter.</param>
|
|
||||
public YuvToRgbRowConverter( |
|
||||
Configuration configuration, |
|
||||
Av1FrameBuffer<byte> frameBuffer, |
|
||||
ImageFrame<TPixel> image, |
|
||||
HeifColorConverterBase colorConverter) |
|
||||
{ |
|
||||
this.configuration = configuration; |
|
||||
this.frameBuffer = frameBuffer; |
|
||||
this.image = image; |
|
||||
this.colorConverter = colorConverter; |
|
||||
this.isMonochrome = frameBuffer.ColorFormat == Av1ColorFormat.Yuv400; |
|
||||
this.subX = frameBuffer.ColorConfig.SubSamplingX ? 1 : 0; |
|
||||
this.subY = frameBuffer.ColorConfig.SubSamplingY ? 1 : 0; |
|
||||
this.chromaSamplePosition = frameBuffer.ColorConfig.ChromaSamplePosition; |
|
||||
this.yPlane = frameBuffer.DeriveBlockPointer(Av1Plane.Y, 0, 0); |
|
||||
this.uPlane = this.isMonochrome ? default : frameBuffer.DeriveBlockPointer(Av1Plane.U, this.subX, this.subY); |
|
||||
this.vPlane = this.isMonochrome ? default : frameBuffer.DeriveBlockPointer(Av1Plane.V, this.subX, this.subY); |
|
||||
} |
|
||||
|
|
||||
/// <summary>
|
|
||||
/// Gets the number of float elements required by the reusable conversion buffer.
|
|
||||
/// </summary>
|
|
||||
public int BufferLength |
|
||||
{ |
|
||||
get |
|
||||
{ |
|
||||
// Three float component rows are converted in place. Color input adds two reusable chroma scratch
|
|
||||
// rows, and the final one or two float-sized slots per pixel back RGB byte planes or an Rgba64 row.
|
|
||||
int rowCount = this.isMonochrome ? 3 : 5; |
|
||||
int packedRowCount = typeof(TSample) == typeof(byte) ? 1 : 2; |
|
||||
return this.image.Width * (rowCount + packedRowCount); |
|
||||
} |
|
||||
} |
|
||||
|
|
||||
/// <summary>
|
|
||||
/// Converts one reconstructed AV1 row to packed pixels.
|
|
||||
/// </summary>
|
|
||||
/// <param name="y">The row index.</param>
|
|
||||
/// <param name="span">The reusable conversion buffer.</param>
|
|
||||
public void Convert(int y, Span<float> span) |
|
||||
{ |
|
||||
int width = this.image.Width; |
|
||||
Span<float> red = span[..width]; |
|
||||
Span<float> green = span.Slice(width, width); |
|
||||
Span<float> blue = span.Slice(width * 2, width); |
|
||||
|
|
||||
ReadOnlySpan<TSample> ySource; |
|
||||
if (typeof(TSample) == typeof(byte)) |
|
||||
{ |
|
||||
ySource = MemoryMarshal.Cast<byte, TSample>(this.yPlane.DangerousGetRowSpan(y)); |
|
||||
} |
|
||||
else |
|
||||
{ |
|
||||
ySource = MemoryMarshal.Cast<ushort, TSample>(this.frameBuffer.GetHighBitDepthRowSpan(Av1Plane.Y, y, 0, 0)); |
|
||||
} |
|
||||
|
|
||||
ConvertSamplesToFloat<TSample, TLoader>(ySource, red); |
|
||||
|
|
||||
int packedOffset = width * 3; |
|
||||
if (!this.isMonochrome) |
|
||||
{ |
|
||||
GetChromaCoordinates( |
|
||||
y, |
|
||||
this.subY, |
|
||||
this.subY != 0 && this.chromaSamplePosition != ObuChromoSamplePosition.Colocated, |
|
||||
this.uPlane.Height - 1, |
|
||||
out int y0, |
|
||||
out int y1, |
|
||||
out int y1Weight); |
|
||||
|
|
||||
ReadOnlySpan<TSample> uRow0; |
|
||||
ReadOnlySpan<TSample> uRow1; |
|
||||
ReadOnlySpan<TSample> vRow0; |
|
||||
ReadOnlySpan<TSample> vRow1; |
|
||||
if (typeof(TSample) == typeof(byte)) |
|
||||
{ |
|
||||
uRow0 = MemoryMarshal.Cast<byte, TSample>(this.uPlane.DangerousGetRowSpan(y0)); |
|
||||
uRow1 = MemoryMarshal.Cast<byte, TSample>(this.uPlane.DangerousGetRowSpan(y1)); |
|
||||
vRow0 = MemoryMarshal.Cast<byte, TSample>(this.vPlane.DangerousGetRowSpan(y0)); |
|
||||
vRow1 = MemoryMarshal.Cast<byte, TSample>(this.vPlane.DangerousGetRowSpan(y1)); |
|
||||
} |
|
||||
else |
|
||||
{ |
|
||||
uRow0 = MemoryMarshal.Cast<ushort, TSample>(this.frameBuffer.GetHighBitDepthRowSpan(Av1Plane.U, y0, this.subX, this.subY)); |
|
||||
uRow1 = MemoryMarshal.Cast<ushort, TSample>(this.frameBuffer.GetHighBitDepthRowSpan(Av1Plane.U, y1, this.subX, this.subY)); |
|
||||
vRow0 = MemoryMarshal.Cast<ushort, TSample>(this.frameBuffer.GetHighBitDepthRowSpan(Av1Plane.V, y0, this.subX, this.subY)); |
|
||||
vRow1 = MemoryMarshal.Cast<ushort, TSample>(this.frameBuffer.GetHighBitDepthRowSpan(Av1Plane.V, y1, this.subX, this.subY)); |
|
||||
} |
|
||||
|
|
||||
Span<float> scratch0 = span.Slice(width * 3, width); |
|
||||
Span<float> scratch1 = span.Slice(width * 4, width); |
|
||||
bool isCenteredX = this.subX != 0 && (this.subY == 0 || this.chromaSamplePosition == ObuChromoSamplePosition.Unknown); |
|
||||
ReconstructChromaRow<TSample, TLoader>(uRow0, uRow1, y1Weight, this.subX, isCenteredX, green, scratch0, scratch1); |
|
||||
ReconstructChromaRow<TSample, TLoader>(vRow0, vRow1, y1Weight, this.subX, isCenteredX, blue, scratch0, scratch1); |
|
||||
packedOffset = width * 5; |
|
||||
} |
|
||||
|
|
||||
this.colorConverter.ConvertToRgbInPlace(red, green, blue); |
|
||||
Span<float> packedStorage = span[packedOffset..]; |
|
||||
Span<TPixel> destination = this.image.PixelBuffer.DangerousGetRowSpan(y); |
|
||||
if (typeof(TSample) == typeof(byte)) |
|
||||
{ |
|
||||
// Match JPEG's byte-plane packing contract so optimized pixel types use the existing RGB packer.
|
|
||||
// The final float row provides enough byte storage for three tightly packed component planes.
|
|
||||
Span<byte> byteStorage = MemoryMarshal.AsBytes(packedStorage)[..(width * 3)]; |
|
||||
Span<byte> redBytes = byteStorage[..width]; |
|
||||
Span<byte> greenBytes = byteStorage.Slice(width, width); |
|
||||
Span<byte> blueBytes = byteStorage.Slice(width * 2, width); |
|
||||
SimdUtils.NormalizedFloatToByteSaturate(red, redBytes); |
|
||||
SimdUtils.NormalizedFloatToByteSaturate(green, greenBytes); |
|
||||
SimdUtils.NormalizedFloatToByteSaturate(blue, blueBytes); |
|
||||
|
|
||||
PixelOperations<TPixel>.Instance.PackFromRgbPlanes(redBytes, greenBytes, blueBytes, destination); |
|
||||
} |
|
||||
else |
|
||||
{ |
|
||||
Span<Rgba64> packed = MemoryMarshal.Cast<float, Rgba64>(packedStorage)[..width]; |
|
||||
PackRgba64(red, green, blue, packed); |
|
||||
PixelOperations<TPixel>.Instance.FromRgba64(this.configuration, packed, destination); |
|
||||
} |
|
||||
} |
|
||||
} |
|
||||
|
|
||||
/// <summary>
|
|
||||
/// Converts one source row, or one vertically subsampled row pair, using reusable pooled component storage.
|
|
||||
/// </summary>
|
|
||||
/// <typeparam name="TPixel">The source pixel type.</typeparam>
|
|
||||
/// <typeparam name="TSample">The encoded sample type.</typeparam>
|
|
||||
/// <typeparam name="TStorer">The SIMD narrowing and storage operations for the sample type.</typeparam>
|
|
||||
private readonly struct RgbToYuvRowConverter<TPixel, TSample, TStorer> |
|
||||
where TPixel : unmanaged, IPixel<TPixel> |
|
||||
where TSample : unmanaged |
|
||||
where TStorer : struct, IHeifSampleStorer<TSample> |
|
||||
{ |
|
||||
/// <summary>
|
|
||||
/// The configuration used by bulk pixel conversion.
|
|
||||
/// </summary>
|
|
||||
private readonly Configuration configuration; |
|
||||
|
|
||||
/// <summary>
|
|
||||
/// The destination AV1 frame.
|
|
||||
/// </summary>
|
|
||||
private readonly Av1FrameBuffer<byte> frameBuffer; |
|
||||
|
|
||||
/// <summary>
|
|
||||
/// The source image frame.
|
|
||||
/// </summary>
|
|
||||
private readonly ImageFrame<TPixel> image; |
|
||||
|
|
||||
/// <summary>
|
|
||||
/// The full-resolution luma plane.
|
|
||||
/// </summary>
|
|
||||
private readonly Buffer2DRegion<byte> yPlane; |
|
||||
|
|
||||
/// <summary>
|
|
||||
/// The blue-difference plane when the frame contains chroma.
|
|
||||
/// </summary>
|
|
||||
private readonly Buffer2DRegion<byte> uPlane; |
|
||||
|
|
||||
/// <summary>
|
|
||||
/// The red-difference plane when the frame contains chroma.
|
|
||||
/// </summary>
|
|
||||
private readonly Buffer2DRegion<byte> vPlane; |
|
||||
|
|
||||
/// <summary>
|
|
||||
/// The frame-scoped color-model converter.
|
|
||||
/// </summary>
|
|
||||
private readonly HeifColorConverterBase colorConverter; |
|
||||
|
|
||||
/// <summary>
|
|
||||
/// The largest value represented by the encoded AV1 bit depth.
|
|
||||
/// </summary>
|
|
||||
private readonly float sampleMaximum; |
|
||||
|
|
||||
/// <summary>
|
|
||||
/// Whether the destination contains only a luma plane.
|
|
||||
/// </summary>
|
|
||||
private readonly bool isMonochrome; |
|
||||
|
|
||||
/// <summary>
|
|
||||
/// The horizontal chroma subsampling shift.
|
|
||||
/// </summary>
|
|
||||
private readonly int subX; |
|
||||
|
|
||||
/// <summary>
|
|
||||
/// The vertical chroma subsampling shift.
|
|
||||
/// </summary>
|
|
||||
private readonly int rowShift; |
|
||||
|
|
||||
/// <summary>
|
|
||||
/// Initializes a new instance of the <see cref="RgbToYuvRowConverter{TPixel, TSample, TStorer}"/> struct.
|
|
||||
/// </summary>
|
|
||||
/// <param name="configuration">The configuration used for packed-pixel conversion.</param>
|
|
||||
/// <param name="frameBuffer">The destination AV1 frame.</param>
|
|
||||
/// <param name="image">The source image frame.</param>
|
|
||||
/// <param name="colorConverter">The selected H.273 color converter.</param>
|
|
||||
/// <param name="sampleMaximum">The largest encoded sample value.</param>
|
|
||||
public RgbToYuvRowConverter( |
|
||||
Configuration configuration, |
|
||||
Av1FrameBuffer<byte> frameBuffer, |
|
||||
ImageFrame<TPixel> image, |
|
||||
HeifColorConverterBase colorConverter, |
|
||||
float sampleMaximum) |
|
||||
{ |
|
||||
this.configuration = configuration; |
|
||||
this.frameBuffer = frameBuffer; |
|
||||
this.image = image; |
|
||||
this.colorConverter = colorConverter; |
|
||||
this.sampleMaximum = sampleMaximum; |
|
||||
this.isMonochrome = frameBuffer.ColorFormat == Av1ColorFormat.Yuv400; |
|
||||
this.subX = frameBuffer.ColorConfig.SubSamplingX ? 1 : 0; |
|
||||
this.rowShift = !this.isMonochrome && frameBuffer.ColorConfig.SubSamplingY ? 1 : 0; |
|
||||
this.yPlane = frameBuffer.DeriveBlockPointer(Av1Plane.Y, 0, 0); |
|
||||
this.uPlane = this.isMonochrome ? default : frameBuffer.DeriveBlockPointer(Av1Plane.U, this.subX, this.rowShift); |
|
||||
this.vPlane = this.isMonochrome ? default : frameBuffer.DeriveBlockPointer(Av1Plane.V, this.subX, this.rowShift); |
|
||||
} |
|
||||
|
|
||||
/// <summary>
|
|
||||
/// Gets the number of float elements required by the reusable conversion buffer.
|
|
||||
/// </summary>
|
|
||||
public int ComponentBufferLength |
|
||||
{ |
|
||||
get |
|
||||
{ |
|
||||
// Three planar rows hold the converted YUV values, and 4:2:0 keeps a second set until its
|
|
||||
// chroma has been averaged with the first.
|
|
||||
int componentRowCount = this.rowShift == 0 ? 3 : 6; |
|
||||
return this.image.Width * componentRowCount; |
|
||||
} |
|
||||
} |
|
||||
|
|
||||
/// <summary>
|
|
||||
/// Converts one source row, or one vertically subsampled row pair, to AV1 planes.
|
|
||||
/// </summary>
|
|
||||
/// <param name="y">The conversion iteration index.</param>
|
|
||||
/// <param name="packed">The reusable high-bit-depth RGB staging row.</param>
|
|
||||
/// <param name="components">The reusable planar component buffer.</param>
|
|
||||
public void Convert(int y, Span<Rgb48> packed, Span<float> components) |
|
||||
{ |
|
||||
int width = this.image.Width; |
|
||||
int sourceY = y << this.rowShift; |
|
||||
Span<float> yRow0 = components[..width]; |
|
||||
Span<float> cbRow0 = components.Slice(width, width); |
|
||||
Span<float> crRow0 = components.Slice(width * 2, width); |
|
||||
this.ConvertSourceRow(sourceY, packed, yRow0, cbRow0, crRow0); |
|
||||
WriteSamples<TSample, TStorer>( |
|
||||
yRow0, |
|
||||
this.GetPlaneRow(Av1Plane.Y, sourceY), |
|
||||
this.colorConverter.LumaScale, |
|
||||
this.colorConverter.LumaBias, |
|
||||
this.sampleMaximum); |
|
||||
|
|
||||
bool hasSecondSourceRow = this.rowShift != 0 && sourceY + 1 < this.image.Height; |
|
||||
Span<float> yRow1 = Span<float>.Empty; |
|
||||
Span<float> cbRow1 = Span<float>.Empty; |
|
||||
Span<float> crRow1 = Span<float>.Empty; |
|
||||
if (hasSecondSourceRow) |
|
||||
{ |
|
||||
yRow1 = components.Slice(width * 3, width); |
|
||||
cbRow1 = components.Slice(width * 4, width); |
|
||||
crRow1 = components.Slice(width * 5, width); |
|
||||
this.ConvertSourceRow(sourceY + 1, packed, yRow1, cbRow1, crRow1); |
|
||||
WriteSamples<TSample, TStorer>( |
|
||||
yRow1, |
|
||||
this.GetPlaneRow(Av1Plane.Y, sourceY + 1), |
|
||||
this.colorConverter.LumaScale, |
|
||||
this.colorConverter.LumaBias, |
|
||||
this.sampleMaximum); |
|
||||
} |
|
||||
|
|
||||
if (this.isMonochrome) |
|
||||
{ |
|
||||
return; |
|
||||
} |
|
||||
|
|
||||
Span<TSample> uDestination = this.GetPlaneRow(Av1Plane.U, y); |
|
||||
Span<TSample> vDestination = this.GetPlaneRow(Av1Plane.V, y); |
|
||||
float chromaScale = this.colorConverter.ChromaScale; |
|
||||
float chromaBias = this.colorConverter.ChromaBias; |
|
||||
if (this.subX == 0) |
|
||||
{ |
|
||||
WriteSamples<TSample, TStorer>(cbRow0, uDestination, chromaScale, chromaBias, this.sampleMaximum); |
|
||||
WriteSamples<TSample, TStorer>(crRow0, vDestination, chromaScale, chromaBias, this.sampleMaximum); |
|
||||
} |
|
||||
else |
|
||||
{ |
|
||||
float secondRowWeight = hasSecondSourceRow ? 0.5F : 0F; |
|
||||
WriteSubsampledSamples<TSample, TStorer>( |
|
||||
cbRow0, |
|
||||
cbRow1, |
|
||||
uDestination, |
|
||||
true, |
|
||||
secondRowWeight, |
|
||||
chromaScale, |
|
||||
chromaBias, |
|
||||
this.sampleMaximum); |
|
||||
|
|
||||
WriteSubsampledSamples<TSample, TStorer>( |
|
||||
crRow0, |
|
||||
crRow1, |
|
||||
vDestination, |
|
||||
true, |
|
||||
secondRowWeight, |
|
||||
chromaScale, |
|
||||
chromaBias, |
|
||||
this.sampleMaximum); |
|
||||
} |
|
||||
} |
|
||||
|
|
||||
/// <summary>
|
|
||||
/// Converts one source row into normalized planar AV1 components.
|
|
||||
/// </summary>
|
|
||||
/// <param name="y">The source row index.</param>
|
|
||||
/// <param name="packed">The high-bit-depth RGB staging row.</param>
|
|
||||
/// <param name="luma">The destination luma values.</param>
|
|
||||
/// <param name="chromaBlue">The destination blue-difference values.</param>
|
|
||||
/// <param name="chromaRed">The destination red-difference values.</param>
|
|
||||
private void ConvertSourceRow(int y, Span<Rgb48> packed, Span<float> luma, Span<float> chromaBlue, Span<float> chromaRed) |
|
||||
{ |
|
||||
ReadOnlySpan<TPixel> source = this.image.PixelBuffer.DangerousGetRowSpan(y); |
|
||||
if (typeof(TSample) == typeof(byte)) |
|
||||
{ |
|
||||
// This is the same planar input contract used by JPEG encoding. Pixel types with optimized
|
|
||||
// unpackers reach their existing SIMD path before the AV1 operator consumes the planes.
|
|
||||
PixelOperations<TPixel>.Instance.UnpackIntoRgbPlanes(luma, chromaBlue, chromaRed, source); |
|
||||
this.colorConverter.ConvertFromRgbInPlace(luma, chromaBlue, chromaRed, ByteMaximum); |
|
||||
} |
|
||||
else |
|
||||
{ |
|
||||
// JPEG's planar unpack contract is eight-bit. AV1 10/12-bit encoding stages Rgb48 instead
|
|
||||
// so high-precision source pixels are not truncated before the color transform.
|
|
||||
PixelOperations<TPixel>.Instance.ToRgb48(this.configuration, source, packed); |
|
||||
DeinterleaveRgb48(packed, luma, chromaBlue, chromaRed); |
|
||||
this.colorConverter.ConvertFromRgbInPlace(luma, chromaBlue, chromaRed, UShortMaximum); |
|
||||
} |
|
||||
} |
|
||||
|
|
||||
/// <summary>
|
|
||||
/// Gets a writable row from an eight-bit or high-bit-depth AV1 plane.
|
|
||||
/// </summary>
|
|
||||
/// <param name="plane">The requested plane.</param>
|
|
||||
/// <param name="y">The row index in the requested plane.</param>
|
|
||||
/// <returns>The writable sample row.</returns>
|
|
||||
private Span<TSample> GetPlaneRow(Av1Plane plane, int y) |
|
||||
{ |
|
||||
if (typeof(TSample) == typeof(byte)) |
|
||||
{ |
|
||||
Buffer2DRegion<byte> region = plane switch |
|
||||
{ |
|
||||
Av1Plane.Y => this.yPlane, |
|
||||
Av1Plane.U => this.uPlane, |
|
||||
_ => this.vPlane, |
|
||||
}; |
|
||||
|
|
||||
return MemoryMarshal.Cast<byte, TSample>(region.DangerousGetRowSpan(y)); |
|
||||
} |
|
||||
|
|
||||
int subX = plane == Av1Plane.Y ? 0 : this.subX; |
|
||||
int subY = plane == Av1Plane.Y ? 0 : this.rowShift; |
|
||||
return MemoryMarshal.Cast<ushort, TSample>(this.frameBuffer.GetHighBitDepthRowSpan(plane, y, subX, subY)); |
|
||||
} |
|
||||
} |
|
||||
} |
|
||||
@ -1,174 +0,0 @@ |
|||||
// Copyright (c) Six Labors.
|
|
||||
// Licensed under the Six Labors Split License.
|
|
||||
|
|
||||
using System.Buffers; |
|
||||
using SixLabors.ImageSharp.Advanced; |
|
||||
using SixLabors.ImageSharp.Formats.Heif.Av1.OpenBitstreamUnit; |
|
||||
using SixLabors.ImageSharp.Formats.Heif.Color; |
|
||||
using SixLabors.ImageSharp.Memory; |
|
||||
using SixLabors.ImageSharp.Metadata.Profiles.Cicp; |
|
||||
using SixLabors.ImageSharp.PixelFormats; |
|
||||
using static SixLabors.ImageSharp.Formats.Heif.Color.HeifColorConverterBase; |
|
||||
|
|
||||
namespace SixLabors.ImageSharp.Formats.Heif.Av1; |
|
||||
|
|
||||
/// <summary>
|
|
||||
/// Converts between reconstructed AV1 YUV planes and packed ImageSharp pixels.
|
|
||||
/// </summary>
|
|
||||
internal static partial class Av1YuvConverter |
|
||||
{ |
|
||||
/// <summary>
|
|
||||
/// The largest value represented by an eight-bit packed RGB component.
|
|
||||
/// </summary>
|
|
||||
private const float ByteMaximum = byte.MaxValue; |
|
||||
|
|
||||
/// <summary>
|
|
||||
/// The largest value represented by a 16-bit packed RGB component.
|
|
||||
/// </summary>
|
|
||||
private const float UShortMaximum = ushort.MaxValue; |
|
||||
|
|
||||
/// <summary>
|
|
||||
/// Converts the reconstructed YUV planes to packed pixels.
|
|
||||
/// </summary>
|
|
||||
/// <typeparam name="TPixel">The destination pixel type.</typeparam>
|
|
||||
/// <param name="configuration">The configuration used for allocation and pixel conversion.</param>
|
|
||||
/// <param name="frameBuffer">The reconstructed AV1 frame.</param>
|
|
||||
/// <param name="image">The destination image frame.</param>
|
|
||||
public static void ConvertToRgb<TPixel>(Configuration configuration, Av1FrameBuffer<byte> frameBuffer, ImageFrame<TPixel> image) |
|
||||
where TPixel : unmanaged, IPixel<TPixel> |
|
||||
{ |
|
||||
HeifColorConversionParameters parameters = GetConversionParameters(frameBuffer, out HeifColorConversionMode mode); |
|
||||
|
|
||||
HeifColorConverterBase colorConverter = HeifColorConverterBase.Create(mode, in parameters, frameBuffer.ColorFormat == Av1ColorFormat.Yuv400); |
|
||||
if (frameBuffer.BitDepth == Av1BitDepth.EightBit) |
|
||||
{ |
|
||||
YuvToRgbRowConverter<TPixel, byte, HeifByteSampleLoader> converter = new(configuration, frameBuffer, image, colorConverter); |
|
||||
using IMemoryOwner<float> scratchOwner = configuration.MemoryAllocator.Allocate<float>(converter.BufferLength); |
|
||||
Span<float> scratch = scratchOwner.GetSpan(); |
|
||||
for (int y = 0; y < image.Height; y++) |
|
||||
{ |
|
||||
converter.Convert(y, scratch); |
|
||||
} |
|
||||
} |
|
||||
else |
|
||||
{ |
|
||||
YuvToRgbRowConverter<TPixel, ushort, HeifUShortSampleLoader> converter = new(configuration, frameBuffer, image, colorConverter); |
|
||||
using IMemoryOwner<float> owner = configuration.MemoryAllocator.Allocate<float>(converter.BufferLength); |
|
||||
Span<float> scratch = owner.GetSpan(); |
|
||||
for (int y = 0; y < image.Height; y++) |
|
||||
{ |
|
||||
converter.Convert(y, scratch); |
|
||||
} |
|
||||
} |
|
||||
} |
|
||||
|
|
||||
/// <summary>
|
|
||||
/// Converts packed pixels to the configured monochrome or YUV planes used by the AV1 encoder.
|
|
||||
/// </summary>
|
|
||||
/// <typeparam name="TPixel">The source pixel type.</typeparam>
|
|
||||
/// <param name="configuration">The configuration used for allocation and pixel conversion.</param>
|
|
||||
/// <param name="image">The source image frame.</param>
|
|
||||
/// <param name="frameBuffer">The destination AV1 frame.</param>
|
|
||||
public static void ConvertFromRgb<TPixel>(Configuration configuration, ImageFrame<TPixel> image, Av1FrameBuffer<byte> frameBuffer) |
|
||||
where TPixel : unmanaged, IPixel<TPixel> |
|
||||
{ |
|
||||
HeifColorConversionParameters parameters = GetConversionParameters(frameBuffer, out HeifColorConversionMode mode); |
|
||||
float sampleMaximum = parameters.LumaSampleMaximum; |
|
||||
|
|
||||
bool isMonochrome = frameBuffer.ColorFormat == Av1ColorFormat.Yuv400; |
|
||||
HeifColorConverterBase colorConverter = HeifColorConverterBase.Create(mode, in parameters, isMonochrome); |
|
||||
int rowShift = !isMonochrome && frameBuffer.ColorConfig.SubSamplingY ? 1 : 0; |
|
||||
int iterationCount = (image.Height + rowShift) >> rowShift; |
|
||||
if (frameBuffer.BitDepth == Av1BitDepth.EightBit) |
|
||||
{ |
|
||||
RgbToYuvRowConverter<TPixel, byte, HeifByteSampleStorer> converter = new(configuration, frameBuffer, image, colorConverter, sampleMaximum); |
|
||||
using IMemoryOwner<float> componentOwner = configuration.MemoryAllocator.Allocate<float>(converter.ComponentBufferLength); |
|
||||
Span<float> components = componentOwner.GetSpan(); |
|
||||
for (int y = 0; y < iterationCount; y++) |
|
||||
{ |
|
||||
converter.Convert(y, Span<Rgb48>.Empty, components); |
|
||||
} |
|
||||
} |
|
||||
else |
|
||||
{ |
|
||||
RgbToYuvRowConverter<TPixel, ushort, HeifUShortSampleStorer> converter = new(configuration, frameBuffer, image, colorConverter, sampleMaximum); |
|
||||
using IMemoryOwner<Rgb48> packedOwner = configuration.MemoryAllocator.Allocate<Rgb48>(image.Width); |
|
||||
using IMemoryOwner<float> componentOwner = configuration.MemoryAllocator.Allocate<float>(converter.ComponentBufferLength); |
|
||||
Span<Rgb48> packed = packedOwner.GetSpan()[..image.Width]; |
|
||||
Span<float> components = componentOwner.GetSpan(); |
|
||||
for (int y = 0; y < iterationCount; y++) |
|
||||
{ |
|
||||
converter.Convert(y, packed, components); |
|
||||
} |
|
||||
} |
|
||||
} |
|
||||
|
|
||||
/// <summary>
|
|
||||
/// Resolves the H.273 conversion mode, matrix coefficients, and sample range for a frame.
|
|
||||
/// </summary>
|
|
||||
/// <param name="frameBuffer">The AV1 frame containing the signaled color configuration.</param>
|
|
||||
/// <param name="mode">The resolved conversion mode.</param>
|
|
||||
/// <returns>The resolved conversion parameters.</returns>
|
|
||||
private static HeifColorConversionParameters GetConversionParameters(Av1FrameBuffer<byte> frameBuffer, out HeifColorConversionMode mode) |
|
||||
{ |
|
||||
if (frameBuffer.ColorConfig.ChromaSamplePosition == ObuChromoSamplePosition.Reserved) |
|
||||
{ |
|
||||
throw new InvalidImageContentException("The reserved AV1 chroma sample position is invalid."); |
|
||||
} |
|
||||
|
|
||||
bool isMonochrome = frameBuffer.ColorFormat == Av1ColorFormat.Yuv400; |
|
||||
|
|
||||
return HeifColorConversionParameters.Create( |
|
||||
(CicpColorPrimaries)(byte)frameBuffer.ColorConfig.ColorPrimaries, |
|
||||
(CicpTransferCharacteristics)(byte)frameBuffer.ColorConfig.TransferCharacteristics, |
|
||||
(CicpMatrixCoefficients)(byte)frameBuffer.ColorConfig.MatrixCoefficients, |
|
||||
frameBuffer.ColorConfig.ColorRange, |
|
||||
frameBuffer.BitDepth.GetBitCount(), |
|
||||
frameBuffer.BitDepth.GetBitCount(), |
|
||||
isMonochrome, |
|
||||
frameBuffer.ColorFormat == Av1ColorFormat.Yuv444, |
|
||||
out mode); |
|
||||
} |
|
||||
|
|
||||
/// <summary>
|
|
||||
/// Resolves the two chroma samples and quarter-sample weight surrounding a luma coordinate.
|
|
||||
/// </summary>
|
|
||||
/// <param name="coordinate">The luma coordinate.</param>
|
|
||||
/// <param name="subsampling">The chroma subsampling shift.</param>
|
|
||||
/// <param name="isCentered">Whether chroma lies between neighboring luma samples.</param>
|
|
||||
/// <param name="maximum">The last available chroma coordinate.</param>
|
|
||||
/// <param name="lower">The lower chroma coordinate.</param>
|
|
||||
/// <param name="upper">The upper chroma coordinate.</param>
|
|
||||
/// <param name="upperWeight">The upper-coordinate weight with a denominator of four.</param>
|
|
||||
private static void GetChromaCoordinates( |
|
||||
int coordinate, |
|
||||
int subsampling, |
|
||||
bool isCentered, |
|
||||
int maximum, |
|
||||
out int lower, |
|
||||
out int upper, |
|
||||
out int upperWeight) |
|
||||
{ |
|
||||
if (subsampling == 0) |
|
||||
{ |
|
||||
lower = coordinate; |
|
||||
upper = coordinate; |
|
||||
upperWeight = 0; |
|
||||
return; |
|
||||
} |
|
||||
|
|
||||
int sample = coordinate >> 1; |
|
||||
bool isOdd = (coordinate & 1) != 0; |
|
||||
if (isCentered) |
|
||||
{ |
|
||||
lower = isOdd ? sample : Math.Max(sample - 1, 0); |
|
||||
upper = isOdd ? Math.Min(sample + 1, maximum) : sample; |
|
||||
upperWeight = isOdd ? 1 : 3; |
|
||||
return; |
|
||||
} |
|
||||
|
|
||||
lower = sample; |
|
||||
upper = isOdd ? Math.Min(sample + 1, maximum) : sample; |
|
||||
upperWeight = isOdd ? 2 : 0; |
|
||||
} |
|
||||
} |
|
||||
@ -0,0 +1,133 @@ |
|||||
|
// Copyright (c) Six Labors.
|
||||
|
// Licensed under the Six Labors Split License.
|
||||
|
|
||||
|
using System.Runtime.InteropServices; |
||||
|
using SixLabors.ImageSharp.Formats.Heif.Av1.OpenBitstreamUnit; |
||||
|
using SixLabors.ImageSharp.Formats.Heif.Color; |
||||
|
using SixLabors.ImageSharp.Memory; |
||||
|
|
||||
|
namespace SixLabors.ImageSharp.Formats.Heif.Av1.Color; |
||||
|
|
||||
|
/// <summary>
|
||||
|
/// Adapts reconstructed AV1 planes to the shared HEIF planar color pipeline.
|
||||
|
/// </summary>
|
||||
|
/// <typeparam name="TSample">The native unsigned sample storage type.</typeparam>
|
||||
|
internal struct Av1PlanarSampleBuffer<TSample> : IHeifPlanarSampleBuffer<TSample> |
||||
|
where TSample : unmanaged |
||||
|
{ |
||||
|
/// <summary>
|
||||
|
/// The reconstructed AV1 frame containing the component planes.
|
||||
|
/// </summary>
|
||||
|
private readonly Av1FrameBuffer<byte> frameBuffer; |
||||
|
|
||||
|
/// <summary>
|
||||
|
/// The visible luma plane in byte-backed storage.
|
||||
|
/// </summary>
|
||||
|
private readonly Buffer2DRegion<byte> luma; |
||||
|
|
||||
|
/// <summary>
|
||||
|
/// The visible blue-difference plane in byte-backed storage.
|
||||
|
/// </summary>
|
||||
|
private readonly Buffer2DRegion<byte> chromaBlue; |
||||
|
|
||||
|
/// <summary>
|
||||
|
/// The visible red-difference plane in byte-backed storage.
|
||||
|
/// </summary>
|
||||
|
private readonly Buffer2DRegion<byte> chromaRed; |
||||
|
|
||||
|
/// <summary>
|
||||
|
/// Initializes a new instance of the <see cref="Av1PlanarSampleBuffer{TSample}"/> struct.
|
||||
|
/// </summary>
|
||||
|
/// <param name="frameBuffer">The reconstructed AV1 frame.</param>
|
||||
|
public Av1PlanarSampleBuffer(Av1FrameBuffer<byte> frameBuffer) |
||||
|
{ |
||||
|
this.frameBuffer = frameBuffer; |
||||
|
this.luma = frameBuffer.DeriveBlockPointer(Av1Plane.Y, 0, 0); |
||||
|
this.chromaBlue = this.IsMonochrome |
||||
|
? default |
||||
|
: frameBuffer.DeriveBlockPointer(Av1Plane.U, this.ChromaSubsamplingX, this.ChromaSubsamplingY); |
||||
|
|
||||
|
this.chromaRed = this.IsMonochrome |
||||
|
? default |
||||
|
: frameBuffer.DeriveBlockPointer(Av1Plane.V, this.ChromaSubsamplingX, this.ChromaSubsamplingY); |
||||
|
} |
||||
|
|
||||
|
/// <inheritdoc/>
|
||||
|
public readonly int Width => this.frameBuffer.Width; |
||||
|
|
||||
|
/// <inheritdoc/>
|
||||
|
public readonly int Height => this.frameBuffer.Height; |
||||
|
|
||||
|
/// <inheritdoc/>
|
||||
|
public readonly int LumaBitDepth => this.frameBuffer.BitDepth.GetBitCount(); |
||||
|
|
||||
|
/// <inheritdoc/>
|
||||
|
public readonly int ChromaBitDepth => this.frameBuffer.BitDepth.GetBitCount(); |
||||
|
|
||||
|
/// <inheritdoc/>
|
||||
|
public readonly bool IsMonochrome => this.frameBuffer.ColorFormat == Av1ColorFormat.Yuv400; |
||||
|
|
||||
|
/// <inheritdoc/>
|
||||
|
public readonly int ChromaSubsamplingX => this.frameBuffer.ColorConfig.SubSamplingX ? 1 : 0; |
||||
|
|
||||
|
/// <inheritdoc/>
|
||||
|
public readonly int ChromaSubsamplingY => this.frameBuffer.ColorConfig.SubSamplingY ? 1 : 0; |
||||
|
|
||||
|
/// <inheritdoc/>
|
||||
|
public readonly int ChromaPositionX |
||||
|
{ |
||||
|
get |
||||
|
{ |
||||
|
if (this.ChromaSubsamplingX == 0) |
||||
|
{ |
||||
|
return 0; |
||||
|
} |
||||
|
|
||||
|
// AV1 4:2:2 chroma is centered horizontally. For 4:2:0, CSP_UNKNOWN is centered while the two
|
||||
|
// explicitly positioned layouts are co-sited with the left luma sample.
|
||||
|
bool isCentered = this.ChromaSubsamplingY == 0 |
||||
|
|| this.frameBuffer.ColorConfig.ChromaSamplePosition == ObuChromoSamplePosition.Unknown; |
||||
|
|
||||
|
return isCentered ? 1 : 0; |
||||
|
} |
||||
|
} |
||||
|
|
||||
|
/// <inheritdoc/>
|
||||
|
public readonly int ChromaPositionY |
||||
|
=> this.ChromaSubsamplingY != 0 && this.frameBuffer.ColorConfig.ChromaSamplePosition != ObuChromoSamplePosition.Colocated ? 1 : 0; |
||||
|
|
||||
|
/// <inheritdoc/>
|
||||
|
public Span<TSample> GetLumaRowSpan(int row) |
||||
|
{ |
||||
|
if (typeof(TSample) == typeof(byte)) |
||||
|
{ |
||||
|
return MemoryMarshal.Cast<byte, TSample>(this.luma.DangerousGetRowSpan(row)); |
||||
|
} |
||||
|
|
||||
|
return MemoryMarshal.Cast<ushort, TSample>(this.frameBuffer.GetHighBitDepthRowSpan(Av1Plane.Y, row, 0, 0)); |
||||
|
} |
||||
|
|
||||
|
/// <inheritdoc/>
|
||||
|
public Span<TSample> GetChromaBlueRowSpan(int row) |
||||
|
{ |
||||
|
if (typeof(TSample) == typeof(byte)) |
||||
|
{ |
||||
|
return MemoryMarshal.Cast<byte, TSample>(this.chromaBlue.DangerousGetRowSpan(row)); |
||||
|
} |
||||
|
|
||||
|
return MemoryMarshal.Cast<ushort, TSample>( |
||||
|
this.frameBuffer.GetHighBitDepthRowSpan(Av1Plane.U, row, this.ChromaSubsamplingX, this.ChromaSubsamplingY)); |
||||
|
} |
||||
|
|
||||
|
/// <inheritdoc/>
|
||||
|
public Span<TSample> GetChromaRedRowSpan(int row) |
||||
|
{ |
||||
|
if (typeof(TSample) == typeof(byte)) |
||||
|
{ |
||||
|
return MemoryMarshal.Cast<byte, TSample>(this.chromaRed.DangerousGetRowSpan(row)); |
||||
|
} |
||||
|
|
||||
|
return MemoryMarshal.Cast<ushort, TSample>( |
||||
|
this.frameBuffer.GetHighBitDepthRowSpan(Av1Plane.V, row, this.ChromaSubsamplingX, this.ChromaSubsamplingY)); |
||||
|
} |
||||
|
} |
||||
@ -0,0 +1,109 @@ |
|||||
|
// Copyright (c) Six Labors.
|
||||
|
// Licensed under the Six Labors Split License.
|
||||
|
|
||||
|
using SixLabors.ImageSharp.Formats.Heif.Av1.OpenBitstreamUnit; |
||||
|
using SixLabors.ImageSharp.Formats.Heif.Color; |
||||
|
using SixLabors.ImageSharp.Metadata.Profiles.Cicp; |
||||
|
using SixLabors.ImageSharp.PixelFormats; |
||||
|
using static SixLabors.ImageSharp.Formats.Heif.Color.HeifColorConverterBase; |
||||
|
|
||||
|
namespace SixLabors.ImageSharp.Formats.Heif.Av1.Color; |
||||
|
|
||||
|
/// <summary>
|
||||
|
/// Adapts AV1 color signaling and reconstructed planes to the shared HEIF color pipeline.
|
||||
|
/// </summary>
|
||||
|
internal static class Av1YuvConverter |
||||
|
{ |
||||
|
/// <summary>
|
||||
|
/// Converts the reconstructed component planes to packed pixels.
|
||||
|
/// </summary>
|
||||
|
/// <typeparam name="TPixel">The destination pixel type.</typeparam>
|
||||
|
/// <param name="configuration">The configuration used for allocation and pixel conversion.</param>
|
||||
|
/// <param name="frameBuffer">The reconstructed AV1 frame.</param>
|
||||
|
/// <param name="image">The destination image frame.</param>
|
||||
|
public static void ConvertToRgb<TPixel>(Configuration configuration, Av1FrameBuffer<byte> frameBuffer, ImageFrame<TPixel> image) |
||||
|
where TPixel : unmanaged, IPixel<TPixel> |
||||
|
{ |
||||
|
HeifColorConversionParameters parameters = GetConversionParameters(frameBuffer, out HeifColorConversionMode mode); |
||||
|
if (frameBuffer.BitDepth == Av1BitDepth.EightBit) |
||||
|
{ |
||||
|
Av1PlanarSampleBuffer<byte> buffer = new(frameBuffer); |
||||
|
HeifPlanarColorConverter.ConvertToRgb<TPixel, Av1PlanarSampleBuffer<byte>, byte, HeifByteSampleLoader>( |
||||
|
configuration, |
||||
|
buffer, |
||||
|
image, |
||||
|
in parameters, |
||||
|
mode); |
||||
|
|
||||
|
return; |
||||
|
} |
||||
|
|
||||
|
Av1PlanarSampleBuffer<ushort> highBitDepthBuffer = new(frameBuffer); |
||||
|
HeifPlanarColorConverter.ConvertToRgb<TPixel, Av1PlanarSampleBuffer<ushort>>( |
||||
|
configuration, |
||||
|
highBitDepthBuffer, |
||||
|
image, |
||||
|
in parameters, |
||||
|
mode); |
||||
|
} |
||||
|
|
||||
|
/// <summary>
|
||||
|
/// Converts packed pixels to the configured monochrome or component planes used by the AV1 encoder.
|
||||
|
/// </summary>
|
||||
|
/// <typeparam name="TPixel">The source pixel type.</typeparam>
|
||||
|
/// <param name="configuration">The configuration used for allocation and pixel conversion.</param>
|
||||
|
/// <param name="image">The source image frame.</param>
|
||||
|
/// <param name="frameBuffer">The destination AV1 frame.</param>
|
||||
|
public static void ConvertFromRgb<TPixel>(Configuration configuration, ImageFrame<TPixel> image, Av1FrameBuffer<byte> frameBuffer) |
||||
|
where TPixel : unmanaged, IPixel<TPixel> |
||||
|
{ |
||||
|
HeifColorConversionParameters parameters = GetConversionParameters(frameBuffer, out HeifColorConversionMode mode); |
||||
|
if (frameBuffer.BitDepth == Av1BitDepth.EightBit) |
||||
|
{ |
||||
|
Av1PlanarSampleBuffer<byte> buffer = new(frameBuffer); |
||||
|
HeifPlanarColorConverter.ConvertFromRgb<TPixel, Av1PlanarSampleBuffer<byte>, byte, HeifByteSampleStorer>( |
||||
|
configuration, |
||||
|
image, |
||||
|
buffer, |
||||
|
in parameters, |
||||
|
mode); |
||||
|
|
||||
|
return; |
||||
|
} |
||||
|
|
||||
|
Av1PlanarSampleBuffer<ushort> highBitDepthBuffer = new(frameBuffer); |
||||
|
HeifPlanarColorConverter.ConvertFromRgb<TPixel, Av1PlanarSampleBuffer<ushort>, ushort, HeifUShortSampleStorer>( |
||||
|
configuration, |
||||
|
image, |
||||
|
highBitDepthBuffer, |
||||
|
in parameters, |
||||
|
mode); |
||||
|
} |
||||
|
|
||||
|
/// <summary>
|
||||
|
/// Resolves the H.273 conversion mode, matrix coefficients, and sample range for a frame.
|
||||
|
/// </summary>
|
||||
|
/// <param name="frameBuffer">The AV1 frame containing the signaled color configuration.</param>
|
||||
|
/// <param name="mode">The resolved conversion mode.</param>
|
||||
|
/// <returns>The resolved conversion parameters.</returns>
|
||||
|
private static HeifColorConversionParameters GetConversionParameters(Av1FrameBuffer<byte> frameBuffer, out HeifColorConversionMode mode) |
||||
|
{ |
||||
|
if (frameBuffer.ColorConfig.ChromaSamplePosition == ObuChromoSamplePosition.Reserved) |
||||
|
{ |
||||
|
throw new InvalidImageContentException("The reserved AV1 chroma sample position is invalid."); |
||||
|
} |
||||
|
|
||||
|
bool isMonochrome = frameBuffer.ColorFormat == Av1ColorFormat.Yuv400; |
||||
|
|
||||
|
return HeifColorConversionParameters.Create( |
||||
|
(CicpColorPrimaries)(byte)frameBuffer.ColorConfig.ColorPrimaries, |
||||
|
(CicpTransferCharacteristics)(byte)frameBuffer.ColorConfig.TransferCharacteristics, |
||||
|
(CicpMatrixCoefficients)(byte)frameBuffer.ColorConfig.MatrixCoefficients, |
||||
|
frameBuffer.ColorConfig.ColorRange, |
||||
|
frameBuffer.BitDepth.GetBitCount(), |
||||
|
frameBuffer.BitDepth.GetBitCount(), |
||||
|
isMonochrome, |
||||
|
frameBuffer.ColorFormat == Av1ColorFormat.Yuv444, |
||||
|
out mode); |
||||
|
} |
||||
|
} |
||||
@ -0,0 +1,738 @@ |
|||||
|
// Copyright (c) Six Labors.
|
||||
|
// Licensed under the Six Labors Split License.
|
||||
|
|
||||
|
using System.Buffers; |
||||
|
using System.Runtime.InteropServices; |
||||
|
using SixLabors.ImageSharp.Advanced; |
||||
|
using SixLabors.ImageSharp.Common.Helpers; |
||||
|
using SixLabors.ImageSharp.Memory; |
||||
|
using SixLabors.ImageSharp.PixelFormats; |
||||
|
using static SixLabors.ImageSharp.Formats.Heif.Color.HeifColorConverterBase; |
||||
|
|
||||
|
namespace SixLabors.ImageSharp.Formats.Heif.Color; |
||||
|
|
||||
|
/// <summary>
|
||||
|
/// Converts between native HEIF component planes and packed ImageSharp pixels.
|
||||
|
/// </summary>
|
||||
|
internal static class HeifPlanarColorConverter |
||||
|
{ |
||||
|
/// <summary>
|
||||
|
/// The largest value represented by an eight-bit packed RGB component.
|
||||
|
/// </summary>
|
||||
|
private const float ByteMaximum = byte.MaxValue; |
||||
|
|
||||
|
/// <summary>
|
||||
|
/// The largest value represented by a 16-bit packed RGB component.
|
||||
|
/// </summary>
|
||||
|
private const float UShortMaximum = ushort.MaxValue; |
||||
|
|
||||
|
/// <summary>
|
||||
|
/// Converts native unsigned 16-bit component storage to packed pixels and selects eligible exact integer kernels.
|
||||
|
/// </summary>
|
||||
|
/// <typeparam name="TPixel">The destination pixel type.</typeparam>
|
||||
|
/// <typeparam name="TBuffer">The codec adapter exposing the native component planes.</typeparam>
|
||||
|
/// <param name="configuration">The configuration used for allocation and pixel conversion.</param>
|
||||
|
/// <param name="buffer">The native component-plane buffer.</param>
|
||||
|
/// <param name="image">The destination image frame.</param>
|
||||
|
/// <param name="parameters">The resolved H.273 conversion parameters.</param>
|
||||
|
/// <param name="mode">The resolved H.273 conversion mode.</param>
|
||||
|
/// <param name="sourceX">The horizontal luma-sample offset of the first converted pixel.</param>
|
||||
|
/// <param name="sourceY">The vertical luma-sample offset of the first converted pixel.</param>
|
||||
|
public static void ConvertToRgb<TPixel, TBuffer>( |
||||
|
Configuration configuration, |
||||
|
TBuffer buffer, |
||||
|
ImageFrame<TPixel> image, |
||||
|
in HeifColorConversionParameters parameters, |
||||
|
HeifColorConversionMode mode, |
||||
|
int sourceX = 0, |
||||
|
int sourceY = 0) |
||||
|
where TPixel : unmanaged, IPixel<TPixel> |
||||
|
where TBuffer : struct, IHeifPlanarSampleBuffer<ushort> |
||||
|
{ |
||||
|
if (HeifYuv420ToRgb8Converter.IsSupported( |
||||
|
buffer.ChromaSubsamplingX, |
||||
|
buffer.ChromaSubsamplingY, |
||||
|
buffer.LumaBitDepth, |
||||
|
buffer.ChromaBitDepth, |
||||
|
parameters.IsFullRange, |
||||
|
parameters.MatrixCoefficients, |
||||
|
mode)) |
||||
|
{ |
||||
|
// The fixed-point operator preserves the exact code-value rounding used by the verified eight-bit
|
||||
|
// presentation path. Selection belongs here so no codec can acquire a private color-conversion route.
|
||||
|
HeifYuv420ToRgb8Converter.Convert(configuration, buffer, image, in parameters, sourceX, sourceY); |
||||
|
return; |
||||
|
} |
||||
|
|
||||
|
ConvertToRgb<TPixel, TBuffer, ushort, HeifUShortSampleLoader>( |
||||
|
configuration, |
||||
|
buffer, |
||||
|
image, |
||||
|
in parameters, |
||||
|
mode, |
||||
|
sourceX, |
||||
|
sourceY); |
||||
|
} |
||||
|
|
||||
|
/// <summary>
|
||||
|
/// Converts native component planes to packed pixels.
|
||||
|
/// </summary>
|
||||
|
/// <typeparam name="TPixel">The destination pixel type.</typeparam>
|
||||
|
/// <typeparam name="TBuffer">The codec adapter exposing the native component planes.</typeparam>
|
||||
|
/// <typeparam name="TSample">The native unsigned sample storage type.</typeparam>
|
||||
|
/// <typeparam name="TLoader">The SIMD widening operations for the sample type.</typeparam>
|
||||
|
/// <param name="configuration">The configuration used for allocation and pixel conversion.</param>
|
||||
|
/// <param name="buffer">The native component-plane buffer.</param>
|
||||
|
/// <param name="image">The destination image frame.</param>
|
||||
|
/// <param name="parameters">The resolved H.273 conversion parameters.</param>
|
||||
|
/// <param name="mode">The resolved H.273 conversion mode.</param>
|
||||
|
/// <param name="sourceX">The horizontal luma-sample offset of the first converted pixel.</param>
|
||||
|
/// <param name="sourceY">The vertical luma-sample offset of the first converted pixel.</param>
|
||||
|
public static void ConvertToRgb<TPixel, TBuffer, TSample, TLoader>( |
||||
|
Configuration configuration, |
||||
|
TBuffer buffer, |
||||
|
ImageFrame<TPixel> image, |
||||
|
in HeifColorConversionParameters parameters, |
||||
|
HeifColorConversionMode mode, |
||||
|
int sourceX = 0, |
||||
|
int sourceY = 0) |
||||
|
where TPixel : unmanaged, IPixel<TPixel> |
||||
|
where TBuffer : struct, IHeifPlanarSampleBuffer<TSample> |
||||
|
where TSample : unmanaged |
||||
|
where TLoader : struct, IHeifSampleLoader<TSample> |
||||
|
{ |
||||
|
HeifColorConverterBase colorConverter = HeifColorConverterBase.Create(mode, in parameters, buffer.IsMonochrome); |
||||
|
YuvToRgbRowConverter<TPixel, TBuffer, TSample, TLoader> converter = new( |
||||
|
configuration, |
||||
|
buffer, |
||||
|
image, |
||||
|
colorConverter, |
||||
|
sourceX, |
||||
|
sourceY); |
||||
|
|
||||
|
using IMemoryOwner<float> scratchOwner = configuration.MemoryAllocator.Allocate<float>(converter.BufferLength); |
||||
|
Span<float> scratch = scratchOwner.GetSpan(); |
||||
|
for (int y = 0; y < image.Height; y++) |
||||
|
{ |
||||
|
converter.Convert(y, scratch); |
||||
|
} |
||||
|
} |
||||
|
|
||||
|
/// <summary>
|
||||
|
/// Converts packed pixels to native component planes.
|
||||
|
/// </summary>
|
||||
|
/// <typeparam name="TPixel">The source pixel type.</typeparam>
|
||||
|
/// <typeparam name="TBuffer">The codec adapter exposing the native component planes.</typeparam>
|
||||
|
/// <typeparam name="TSample">The native unsigned sample storage type.</typeparam>
|
||||
|
/// <typeparam name="TStorer">The SIMD narrowing and storage operations for the sample type.</typeparam>
|
||||
|
/// <param name="configuration">The configuration used for allocation and pixel conversion.</param>
|
||||
|
/// <param name="image">The source image frame.</param>
|
||||
|
/// <param name="buffer">The destination component-plane buffer.</param>
|
||||
|
/// <param name="parameters">The resolved H.273 conversion parameters.</param>
|
||||
|
/// <param name="mode">The resolved H.273 conversion mode.</param>
|
||||
|
public static void ConvertFromRgb<TPixel, TBuffer, TSample, TStorer>( |
||||
|
Configuration configuration, |
||||
|
ImageFrame<TPixel> image, |
||||
|
TBuffer buffer, |
||||
|
in HeifColorConversionParameters parameters, |
||||
|
HeifColorConversionMode mode) |
||||
|
where TPixel : unmanaged, IPixel<TPixel> |
||||
|
where TBuffer : struct, IHeifPlanarSampleBuffer<TSample> |
||||
|
where TSample : unmanaged |
||||
|
where TStorer : struct, IHeifSampleStorer<TSample> |
||||
|
{ |
||||
|
HeifColorConverterBase colorConverter = HeifColorConverterBase.Create(mode, in parameters, buffer.IsMonochrome); |
||||
|
RgbToYuvRowConverter<TPixel, TBuffer, TSample, TStorer> converter = new( |
||||
|
configuration, |
||||
|
buffer, |
||||
|
image, |
||||
|
colorConverter, |
||||
|
in parameters); |
||||
|
|
||||
|
using IMemoryOwner<float> componentOwner = configuration.MemoryAllocator.Allocate<float>(converter.ComponentBufferLength); |
||||
|
Span<float> components = componentOwner.GetSpan(); |
||||
|
if (converter.UsesByteInput) |
||||
|
{ |
||||
|
converter.Convert(Span<Rgb48>.Empty, components); |
||||
|
return; |
||||
|
} |
||||
|
|
||||
|
using IMemoryOwner<Rgb48> packedOwner = configuration.MemoryAllocator.Allocate<Rgb48>(image.Width); |
||||
|
converter.Convert(packedOwner.GetSpan()[..image.Width], components); |
||||
|
} |
||||
|
|
||||
|
/// <summary>
|
||||
|
/// Resolves the two chroma rows and quarter-sample weight surrounding a luma row.
|
||||
|
/// </summary>
|
||||
|
/// <param name="coordinate">The luma row coordinate.</param>
|
||||
|
/// <param name="subsampling">The vertical chroma subsampling shift.</param>
|
||||
|
/// <param name="position">The chroma offset in half-luma-sample units.</param>
|
||||
|
/// <param name="maximum">The last available chroma row.</param>
|
||||
|
/// <param name="lower">The lower chroma row.</param>
|
||||
|
/// <param name="upper">The upper chroma row.</param>
|
||||
|
/// <param name="upperWeight">The upper-row weight with a denominator of four.</param>
|
||||
|
private static void GetChromaCoordinates( |
||||
|
int coordinate, |
||||
|
int subsampling, |
||||
|
int position, |
||||
|
int maximum, |
||||
|
out int lower, |
||||
|
out int upper, |
||||
|
out int upperWeight) |
||||
|
{ |
||||
|
if (subsampling == 0) |
||||
|
{ |
||||
|
lower = coordinate; |
||||
|
upper = coordinate; |
||||
|
upperWeight = 0; |
||||
|
return; |
||||
|
} |
||||
|
|
||||
|
// Multiplication by two expresses the luma coordinate in half-sample units, while division by four
|
||||
|
// addresses the subsampled plane. Floor division is required before the first centered chroma sample.
|
||||
|
int quarterCoordinate = (coordinate * 2) - position; |
||||
|
int unclampedLower = quarterCoordinate >= 0 ? quarterCoordinate >> 2 : -((-quarterCoordinate + 3) >> 2); |
||||
|
int fraction = quarterCoordinate - (unclampedLower * 4); |
||||
|
lower = Numerics.Clamp(unclampedLower, 0, maximum); |
||||
|
upper = Numerics.Clamp(unclampedLower + 1, 0, maximum); |
||||
|
upperWeight = lower == upper ? 0 : fraction; |
||||
|
} |
||||
|
|
||||
|
/// <summary>
|
||||
|
/// Converts one native component row using pooled planar and packed-pixel storage.
|
||||
|
/// </summary>
|
||||
|
/// <typeparam name="TPixel">The destination pixel type.</typeparam>
|
||||
|
/// <typeparam name="TBuffer">The codec adapter exposing the native component planes.</typeparam>
|
||||
|
/// <typeparam name="TSample">The native unsigned sample storage type.</typeparam>
|
||||
|
/// <typeparam name="TLoader">The SIMD widening operations for the sample type.</typeparam>
|
||||
|
private struct YuvToRgbRowConverter<TPixel, TBuffer, TSample, TLoader> |
||||
|
where TPixel : unmanaged, IPixel<TPixel> |
||||
|
where TBuffer : struct, IHeifPlanarSampleBuffer<TSample> |
||||
|
where TSample : unmanaged |
||||
|
where TLoader : struct, IHeifSampleLoader<TSample> |
||||
|
{ |
||||
|
/// <summary>
|
||||
|
/// The configuration used for packed-pixel conversion.
|
||||
|
/// </summary>
|
||||
|
private readonly Configuration configuration; |
||||
|
|
||||
|
/// <summary>
|
||||
|
/// The codec adapter exposing the reconstructed component planes.
|
||||
|
/// </summary>
|
||||
|
private TBuffer buffer; |
||||
|
|
||||
|
/// <summary>
|
||||
|
/// The destination image frame.
|
||||
|
/// </summary>
|
||||
|
private readonly ImageFrame<TPixel> image; |
||||
|
|
||||
|
/// <summary>
|
||||
|
/// The selected H.273 color converter.
|
||||
|
/// </summary>
|
||||
|
private readonly HeifColorConverterBase colorConverter; |
||||
|
|
||||
|
/// <summary>
|
||||
|
/// The horizontal luma-sample offset of the output window.
|
||||
|
/// </summary>
|
||||
|
private readonly int sourceX; |
||||
|
|
||||
|
/// <summary>
|
||||
|
/// The vertical luma-sample offset of the output window.
|
||||
|
/// </summary>
|
||||
|
private readonly int sourceY; |
||||
|
|
||||
|
/// <summary>
|
||||
|
/// The full coded luma-plane width.
|
||||
|
/// </summary>
|
||||
|
private readonly int bufferWidth; |
||||
|
|
||||
|
/// <summary>
|
||||
|
/// The chroma-plane width in samples.
|
||||
|
/// </summary>
|
||||
|
private readonly int chromaWidth; |
||||
|
|
||||
|
/// <summary>
|
||||
|
/// The chroma-plane height in samples.
|
||||
|
/// </summary>
|
||||
|
private readonly int chromaHeight; |
||||
|
|
||||
|
/// <summary>
|
||||
|
/// The horizontal chroma subsampling shift.
|
||||
|
/// </summary>
|
||||
|
private readonly int subsamplingX; |
||||
|
|
||||
|
/// <summary>
|
||||
|
/// The vertical chroma subsampling shift.
|
||||
|
/// </summary>
|
||||
|
private readonly int subsamplingY; |
||||
|
|
||||
|
/// <summary>
|
||||
|
/// The horizontal chroma position in half-luma-sample units.
|
||||
|
/// </summary>
|
||||
|
private readonly int chromaPositionX; |
||||
|
|
||||
|
/// <summary>
|
||||
|
/// The vertical chroma position in half-luma-sample units.
|
||||
|
/// </summary>
|
||||
|
private readonly int chromaPositionY; |
||||
|
|
||||
|
/// <summary>
|
||||
|
/// Whether the buffer contains only the luma plane.
|
||||
|
/// </summary>
|
||||
|
private readonly bool isMonochrome; |
||||
|
|
||||
|
/// <summary>
|
||||
|
/// Whether the destination uses JPEG-compatible eight-bit RGB plane packing.
|
||||
|
/// </summary>
|
||||
|
private readonly bool usesBytePacking; |
||||
|
|
||||
|
/// <summary>
|
||||
|
/// Whether chroma reconstruction must retain the complete coded row before selecting the output window.
|
||||
|
/// </summary>
|
||||
|
private readonly bool reconstructCompleteRow; |
||||
|
|
||||
|
/// <summary>
|
||||
|
/// Initializes a new instance of the <see cref="YuvToRgbRowConverter{TPixel, TBuffer, TSample, TLoader}"/> struct.
|
||||
|
/// </summary>
|
||||
|
/// <param name="configuration">The configuration used for pixel conversion.</param>
|
||||
|
/// <param name="buffer">The codec adapter exposing the reconstructed component planes.</param>
|
||||
|
/// <param name="image">The destination image frame.</param>
|
||||
|
/// <param name="colorConverter">The selected H.273 color converter.</param>
|
||||
|
/// <param name="sourceX">The horizontal luma-sample offset of the output window.</param>
|
||||
|
/// <param name="sourceY">The vertical luma-sample offset of the output window.</param>
|
||||
|
public YuvToRgbRowConverter( |
||||
|
Configuration configuration, |
||||
|
TBuffer buffer, |
||||
|
ImageFrame<TPixel> image, |
||||
|
HeifColorConverterBase colorConverter, |
||||
|
int sourceX, |
||||
|
int sourceY) |
||||
|
{ |
||||
|
this.configuration = configuration; |
||||
|
this.buffer = buffer; |
||||
|
this.image = image; |
||||
|
this.colorConverter = colorConverter; |
||||
|
this.sourceX = sourceX; |
||||
|
this.sourceY = sourceY; |
||||
|
this.bufferWidth = buffer.Width; |
||||
|
this.subsamplingX = buffer.ChromaSubsamplingX; |
||||
|
this.subsamplingY = buffer.ChromaSubsamplingY; |
||||
|
this.chromaPositionX = buffer.ChromaPositionX; |
||||
|
this.chromaPositionY = buffer.ChromaPositionY; |
||||
|
this.isMonochrome = buffer.IsMonochrome; |
||||
|
this.usesBytePacking = buffer.LumaBitDepth == 8 && (buffer.IsMonochrome || buffer.ChromaBitDepth == 8); |
||||
|
this.chromaWidth = (buffer.Width + (1 << this.subsamplingX) - 1) >> this.subsamplingX; |
||||
|
this.chromaHeight = (buffer.Height + (1 << this.subsamplingY) - 1) >> this.subsamplingY; |
||||
|
this.reconstructCompleteRow = sourceX != 0 || image.Width != buffer.Width; |
||||
|
} |
||||
|
|
||||
|
/// <summary>
|
||||
|
/// Gets a value indicating whether the destination uses JPEG-compatible eight-bit RGB plane packing.
|
||||
|
/// </summary>
|
||||
|
public readonly bool UsesBytePacking => this.usesBytePacking; |
||||
|
|
||||
|
/// <summary>
|
||||
|
/// Gets the number of float elements required by the reusable row buffer.
|
||||
|
/// </summary>
|
||||
|
public readonly int BufferLength |
||||
|
{ |
||||
|
get |
||||
|
{ |
||||
|
int componentLength = this.image.Width * 3; |
||||
|
if (!this.isMonochrome && this.subsamplingX != 0) |
||||
|
{ |
||||
|
// Full-image conversion reconstructs directly into the component rows. Cropped conversion
|
||||
|
// retains the complete coded row so interpolation phase is preserved at the window boundary.
|
||||
|
componentLength += (this.chromaWidth * 2) + (this.reconstructCompleteRow ? this.bufferWidth : 0); |
||||
|
} |
||||
|
|
||||
|
int packedRowCount = this.UsesBytePacking ? 1 : 2; |
||||
|
return componentLength + (this.image.Width * packedRowCount); |
||||
|
} |
||||
|
} |
||||
|
|
||||
|
/// <summary>
|
||||
|
/// Converts one reconstructed row to packed pixels.
|
||||
|
/// </summary>
|
||||
|
/// <param name="y">The zero-based output row.</param>
|
||||
|
/// <param name="scratch">The reusable pooled row buffer.</param>
|
||||
|
public void Convert(int y, Span<float> scratch) |
||||
|
{ |
||||
|
int width = this.image.Width; |
||||
|
Span<float> red = scratch[..width]; |
||||
|
Span<float> green = scratch.Slice(width, width); |
||||
|
Span<float> blue = scratch.Slice(width * 2, width); |
||||
|
int sourceY = y + this.sourceY; |
||||
|
ReadOnlySpan<TSample> luma = this.buffer.GetLumaRowSpan(sourceY).Slice(this.sourceX, width); |
||||
|
ConvertSamplesToFloat<TSample, TLoader>(luma, red); |
||||
|
|
||||
|
int packedOffset = width * 3; |
||||
|
if (!this.isMonochrome) |
||||
|
{ |
||||
|
GetChromaCoordinates( |
||||
|
sourceY, |
||||
|
this.subsamplingY, |
||||
|
this.chromaPositionY, |
||||
|
this.chromaHeight - 1, |
||||
|
out int y0, |
||||
|
out int y1, |
||||
|
out int y1Weight); |
||||
|
|
||||
|
ReadOnlySpan<TSample> cb0 = this.buffer.GetChromaBlueRowSpan(y0); |
||||
|
ReadOnlySpan<TSample> cb1 = this.buffer.GetChromaBlueRowSpan(y1); |
||||
|
ReadOnlySpan<TSample> cr0 = this.buffer.GetChromaRedRowSpan(y0); |
||||
|
ReadOnlySpan<TSample> cr1 = this.buffer.GetChromaRedRowSpan(y1); |
||||
|
if (this.subsamplingX == 0) |
||||
|
{ |
||||
|
ConvertSamplesToFloat<TSample, TLoader>(cb0.Slice(this.sourceX, width), green); |
||||
|
ConvertSamplesToFloat<TSample, TLoader>(cr0.Slice(this.sourceX, width), blue); |
||||
|
} |
||||
|
else |
||||
|
{ |
||||
|
Span<float> chroma0 = scratch.Slice(packedOffset, this.chromaWidth); |
||||
|
Span<float> chroma1 = scratch.Slice(packedOffset + this.chromaWidth, this.chromaWidth); |
||||
|
Span<float> reconstructed = this.reconstructCompleteRow |
||||
|
? scratch.Slice(packedOffset + (this.chromaWidth * 2), this.bufferWidth) |
||||
|
: green; |
||||
|
|
||||
|
bool isCenteredX = this.chromaPositionX == 1; |
||||
|
|
||||
|
ReconstructChromaRow<TSample, TLoader>( |
||||
|
cb0, |
||||
|
cb1, |
||||
|
y1Weight, |
||||
|
this.subsamplingX, |
||||
|
isCenteredX, |
||||
|
reconstructed, |
||||
|
chroma0, |
||||
|
chroma1); |
||||
|
|
||||
|
if (this.reconstructCompleteRow) |
||||
|
{ |
||||
|
reconstructed.Slice(this.sourceX, width).CopyTo(green); |
||||
|
} |
||||
|
|
||||
|
reconstructed = this.reconstructCompleteRow ? reconstructed : blue; |
||||
|
ReconstructChromaRow<TSample, TLoader>( |
||||
|
cr0, |
||||
|
cr1, |
||||
|
y1Weight, |
||||
|
this.subsamplingX, |
||||
|
isCenteredX, |
||||
|
reconstructed, |
||||
|
chroma0, |
||||
|
chroma1); |
||||
|
|
||||
|
if (this.reconstructCompleteRow) |
||||
|
{ |
||||
|
reconstructed.Slice(this.sourceX, width).CopyTo(blue); |
||||
|
} |
||||
|
|
||||
|
packedOffset += (this.chromaWidth * 2) + (this.reconstructCompleteRow ? this.bufferWidth : 0); |
||||
|
} |
||||
|
} |
||||
|
|
||||
|
this.colorConverter.ConvertToRgbInPlace(red, green, blue); |
||||
|
Span<TPixel> destination = this.image.PixelBuffer.DangerousGetRowSpan(y); |
||||
|
Span<float> packedStorage = scratch[packedOffset..]; |
||||
|
if (this.UsesBytePacking) |
||||
|
{ |
||||
|
// This is JPEG's planar packing contract. Existing pixel-specific SIMD packers therefore own the
|
||||
|
// final RGB-to-TPixel conversion rather than a HEIF-codec-specific per-pixel implementation.
|
||||
|
Span<byte> byteStorage = MemoryMarshal.AsBytes(packedStorage)[..(width * 3)]; |
||||
|
Span<byte> redBytes = byteStorage[..width]; |
||||
|
Span<byte> greenBytes = byteStorage.Slice(width, width); |
||||
|
Span<byte> blueBytes = byteStorage.Slice(width * 2, width); |
||||
|
SimdUtils.NormalizedFloatToByteSaturate(red, redBytes); |
||||
|
SimdUtils.NormalizedFloatToByteSaturate(green, greenBytes); |
||||
|
SimdUtils.NormalizedFloatToByteSaturate(blue, blueBytes); |
||||
|
|
||||
|
PixelOperations<TPixel>.Instance.PackFromRgbPlanes(redBytes, greenBytes, blueBytes, destination); |
||||
|
return; |
||||
|
} |
||||
|
|
||||
|
Span<Rgba64> packed = MemoryMarshal.Cast<float, Rgba64>(packedStorage)[..width]; |
||||
|
PackRgba64(red, green, blue, packed); |
||||
|
PixelOperations<TPixel>.Instance.FromRgba64(this.configuration, packed, destination); |
||||
|
} |
||||
|
} |
||||
|
|
||||
|
/// <summary>
|
||||
|
/// Converts packed image rows to native component planes using pooled planar storage.
|
||||
|
/// </summary>
|
||||
|
/// <typeparam name="TPixel">The source pixel type.</typeparam>
|
||||
|
/// <typeparam name="TBuffer">The codec adapter exposing the native component planes.</typeparam>
|
||||
|
/// <typeparam name="TSample">The native unsigned sample storage type.</typeparam>
|
||||
|
/// <typeparam name="TStorer">The SIMD narrowing and storage operations for the sample type.</typeparam>
|
||||
|
private struct RgbToYuvRowConverter<TPixel, TBuffer, TSample, TStorer> |
||||
|
where TPixel : unmanaged, IPixel<TPixel> |
||||
|
where TBuffer : struct, IHeifPlanarSampleBuffer<TSample> |
||||
|
where TSample : unmanaged |
||||
|
where TStorer : struct, IHeifSampleStorer<TSample> |
||||
|
{ |
||||
|
/// <summary>
|
||||
|
/// The configuration used for packed-pixel conversion.
|
||||
|
/// </summary>
|
||||
|
private readonly Configuration configuration; |
||||
|
|
||||
|
/// <summary>
|
||||
|
/// The codec adapter exposing the destination component planes.
|
||||
|
/// </summary>
|
||||
|
private TBuffer buffer; |
||||
|
|
||||
|
/// <summary>
|
||||
|
/// The source image frame.
|
||||
|
/// </summary>
|
||||
|
private readonly ImageFrame<TPixel> image; |
||||
|
|
||||
|
/// <summary>
|
||||
|
/// The selected H.273 color converter.
|
||||
|
/// </summary>
|
||||
|
private readonly HeifColorConverterBase colorConverter; |
||||
|
|
||||
|
/// <summary>
|
||||
|
/// The largest encoded luma sample value.
|
||||
|
/// </summary>
|
||||
|
private readonly float lumaMaximum; |
||||
|
|
||||
|
/// <summary>
|
||||
|
/// The largest encoded chroma sample value.
|
||||
|
/// </summary>
|
||||
|
private readonly float chromaMaximum; |
||||
|
|
||||
|
/// <summary>
|
||||
|
/// The horizontal chroma subsampling shift.
|
||||
|
/// </summary>
|
||||
|
private readonly int subsamplingX; |
||||
|
|
||||
|
/// <summary>
|
||||
|
/// The vertical chroma subsampling shift.
|
||||
|
/// </summary>
|
||||
|
private readonly int subsamplingY; |
||||
|
|
||||
|
/// <summary>
|
||||
|
/// The horizontal chroma position in half-luma-sample units.
|
||||
|
/// </summary>
|
||||
|
private readonly int chromaPositionX; |
||||
|
|
||||
|
/// <summary>
|
||||
|
/// The vertical chroma position in half-luma-sample units.
|
||||
|
/// </summary>
|
||||
|
private readonly int chromaPositionY; |
||||
|
|
||||
|
/// <summary>
|
||||
|
/// Whether the destination buffer contains only the luma plane.
|
||||
|
/// </summary>
|
||||
|
private readonly bool isMonochrome; |
||||
|
|
||||
|
/// <summary>
|
||||
|
/// Whether source pixels use JPEG-compatible eight-bit RGB plane unpacking.
|
||||
|
/// </summary>
|
||||
|
private readonly bool usesByteInput; |
||||
|
|
||||
|
/// <summary>
|
||||
|
/// Initializes a new instance of the <see cref="RgbToYuvRowConverter{TPixel, TBuffer, TSample, TStorer}"/> struct.
|
||||
|
/// </summary>
|
||||
|
/// <param name="configuration">The configuration used for pixel conversion.</param>
|
||||
|
/// <param name="buffer">The codec adapter exposing the destination component planes.</param>
|
||||
|
/// <param name="image">The source image frame.</param>
|
||||
|
/// <param name="colorConverter">The selected H.273 color converter.</param>
|
||||
|
/// <param name="parameters">The resolved H.273 component ranges.</param>
|
||||
|
public RgbToYuvRowConverter( |
||||
|
Configuration configuration, |
||||
|
TBuffer buffer, |
||||
|
ImageFrame<TPixel> image, |
||||
|
HeifColorConverterBase colorConverter, |
||||
|
in HeifColorConversionParameters parameters) |
||||
|
{ |
||||
|
this.configuration = configuration; |
||||
|
this.buffer = buffer; |
||||
|
this.image = image; |
||||
|
this.colorConverter = colorConverter; |
||||
|
this.lumaMaximum = parameters.LumaSampleMaximum; |
||||
|
this.chromaMaximum = parameters.ChromaSampleMaximum; |
||||
|
this.subsamplingX = buffer.ChromaSubsamplingX; |
||||
|
this.subsamplingY = buffer.ChromaSubsamplingY; |
||||
|
this.chromaPositionX = buffer.ChromaPositionX; |
||||
|
this.chromaPositionY = buffer.ChromaPositionY; |
||||
|
this.isMonochrome = buffer.IsMonochrome; |
||||
|
this.usesByteInput = buffer.LumaBitDepth == 8 && (buffer.IsMonochrome || buffer.ChromaBitDepth == 8); |
||||
|
} |
||||
|
|
||||
|
/// <summary>
|
||||
|
/// Gets a value indicating whether source pixels use JPEG-compatible eight-bit RGB plane unpacking.
|
||||
|
/// </summary>
|
||||
|
public readonly bool UsesByteInput => this.usesByteInput; |
||||
|
|
||||
|
/// <summary>
|
||||
|
/// Gets the number of float elements required by the reusable component buffer.
|
||||
|
/// </summary>
|
||||
|
public readonly int ComponentBufferLength => this.image.Width * (this.subsamplingY == 0 || this.isMonochrome ? 3 : 6); |
||||
|
|
||||
|
/// <summary>
|
||||
|
/// Converts every packed source row to the destination component planes.
|
||||
|
/// </summary>
|
||||
|
/// <param name="packed">The reusable high-bit-depth RGB staging row.</param>
|
||||
|
/// <param name="components">The reusable planar component buffer.</param>
|
||||
|
public void Convert(Span<Rgb48> packed, Span<float> components) |
||||
|
{ |
||||
|
int width = this.image.Width; |
||||
|
Span<float> luma0 = components[..width]; |
||||
|
Span<float> blue0 = components.Slice(width, width); |
||||
|
Span<float> red0 = components.Slice(width * 2, width); |
||||
|
if (this.subsamplingY == 0) |
||||
|
{ |
||||
|
for (int y = 0; y < this.image.Height; y++) |
||||
|
{ |
||||
|
this.ConvertSourceRow(y, packed, luma0, blue0, red0); |
||||
|
WriteSamples<TSample, TStorer>( |
||||
|
luma0, |
||||
|
this.buffer.GetLumaRowSpan(y), |
||||
|
this.colorConverter.LumaScale, |
||||
|
this.colorConverter.LumaBias, |
||||
|
this.lumaMaximum); |
||||
|
|
||||
|
if (!this.isMonochrome) |
||||
|
{ |
||||
|
this.WriteChromaRows(y, blue0, red0, Span<float>.Empty, Span<float>.Empty, 0F); |
||||
|
} |
||||
|
} |
||||
|
|
||||
|
return; |
||||
|
} |
||||
|
|
||||
|
Span<float> luma1 = this.isMonochrome ? luma0 : components.Slice(width * 3, width); |
||||
|
Span<float> blue1 = this.isMonochrome ? blue0 : components.Slice(width * 4, width); |
||||
|
Span<float> red1 = this.isMonochrome ? red0 : components.Slice(width * 5, width); |
||||
|
int chromaHeight = (this.image.Height + 1) >> 1; |
||||
|
for (int destinationY = 0; destinationY < chromaHeight; destinationY++) |
||||
|
{ |
||||
|
// A vertically subsampled chroma row is owned by one two-row luma cell. Processing that cell as a
|
||||
|
// unit removes per-row state and lets the selected chroma position choose or average the two rows.
|
||||
|
int sourceY = destinationY << 1; |
||||
|
this.ConvertSourceRow(sourceY, packed, luma0, blue0, red0); |
||||
|
WriteSamples<TSample, TStorer>( |
||||
|
luma0, |
||||
|
this.buffer.GetLumaRowSpan(sourceY), |
||||
|
this.colorConverter.LumaScale, |
||||
|
this.colorConverter.LumaBias, |
||||
|
this.lumaMaximum); |
||||
|
|
||||
|
bool hasSecondRow = sourceY + 1 < this.image.Height; |
||||
|
if (hasSecondRow) |
||||
|
{ |
||||
|
this.ConvertSourceRow(sourceY + 1, packed, luma1, blue1, red1); |
||||
|
WriteSamples<TSample, TStorer>( |
||||
|
luma1, |
||||
|
this.buffer.GetLumaRowSpan(sourceY + 1), |
||||
|
this.colorConverter.LumaScale, |
||||
|
this.colorConverter.LumaBias, |
||||
|
this.lumaMaximum); |
||||
|
} |
||||
|
|
||||
|
if (this.isMonochrome) |
||||
|
{ |
||||
|
continue; |
||||
|
} |
||||
|
|
||||
|
if (this.chromaPositionY == 0 || !hasSecondRow) |
||||
|
{ |
||||
|
this.WriteChromaRows(destinationY, blue0, red0, Span<float>.Empty, Span<float>.Empty, 0F); |
||||
|
} |
||||
|
else if (this.chromaPositionY == 1) |
||||
|
{ |
||||
|
this.WriteChromaRows(destinationY, blue0, red0, blue1, red1, 0.5F); |
||||
|
} |
||||
|
else |
||||
|
{ |
||||
|
this.WriteChromaRows(destinationY, blue1, red1, Span<float>.Empty, Span<float>.Empty, 0F); |
||||
|
} |
||||
|
} |
||||
|
} |
||||
|
|
||||
|
/// <summary>
|
||||
|
/// Converts one packed source row into normalized planar components.
|
||||
|
/// </summary>
|
||||
|
/// <param name="y">The source row index.</param>
|
||||
|
/// <param name="packed">The high-bit-depth RGB staging row.</param>
|
||||
|
/// <param name="luma">The destination luma or first component values.</param>
|
||||
|
/// <param name="chromaBlue">The destination blue-difference or second component values.</param>
|
||||
|
/// <param name="chromaRed">The destination red-difference or third component values.</param>
|
||||
|
private void ConvertSourceRow(int y, Span<Rgb48> packed, Span<float> luma, Span<float> chromaBlue, Span<float> chromaRed) |
||||
|
{ |
||||
|
ReadOnlySpan<TPixel> source = this.image.PixelBuffer.DangerousGetRowSpan(y); |
||||
|
if (this.UsesByteInput) |
||||
|
{ |
||||
|
// JPEG's planar unpack contract reaches the existing pixel-specific SIMD implementation before
|
||||
|
// the closed H.273 operator transforms the component rows in place.
|
||||
|
PixelOperations<TPixel>.Instance.UnpackIntoRgbPlanes(luma, chromaBlue, chromaRed, source); |
||||
|
this.colorConverter.ConvertFromRgbInPlace(luma, chromaBlue, chromaRed, ByteMaximum); |
||||
|
return; |
||||
|
} |
||||
|
|
||||
|
PixelOperations<TPixel>.Instance.ToRgb48(this.configuration, source, packed); |
||||
|
DeinterleaveRgb48(packed, luma, chromaBlue, chromaRed); |
||||
|
this.colorConverter.ConvertFromRgbInPlace(luma, chromaBlue, chromaRed, UShortMaximum); |
||||
|
} |
||||
|
|
||||
|
/// <summary>
|
||||
|
/// Filters and writes one pair of chroma component rows.
|
||||
|
/// </summary>
|
||||
|
/// <param name="destinationY">The destination chroma row.</param>
|
||||
|
/// <param name="blue0">The first blue-difference source row.</param>
|
||||
|
/// <param name="red0">The first red-difference source row.</param>
|
||||
|
/// <param name="blue1">The optional second blue-difference source row.</param>
|
||||
|
/// <param name="red1">The optional second red-difference source row.</param>
|
||||
|
/// <param name="row1Weight">The second-row contribution.</param>
|
||||
|
private void WriteChromaRows( |
||||
|
int destinationY, |
||||
|
ReadOnlySpan<float> blue0, |
||||
|
ReadOnlySpan<float> red0, |
||||
|
ReadOnlySpan<float> blue1, |
||||
|
ReadOnlySpan<float> red1, |
||||
|
float row1Weight) |
||||
|
{ |
||||
|
Span<TSample> blueDestination = this.buffer.GetChromaBlueRowSpan(destinationY); |
||||
|
Span<TSample> redDestination = this.buffer.GetChromaRedRowSpan(destinationY); |
||||
|
if (this.subsamplingX == 0) |
||||
|
{ |
||||
|
WriteSamples<TSample, TStorer>( |
||||
|
blue0, |
||||
|
blueDestination, |
||||
|
this.colorConverter.ChromaScale, |
||||
|
this.colorConverter.ChromaBias, |
||||
|
this.chromaMaximum); |
||||
|
|
||||
|
WriteSamples<TSample, TStorer>( |
||||
|
red0, |
||||
|
redDestination, |
||||
|
this.colorConverter.ChromaScale, |
||||
|
this.colorConverter.ChromaBias, |
||||
|
this.chromaMaximum); |
||||
|
|
||||
|
return; |
||||
|
} |
||||
|
|
||||
|
bool isCenteredX = this.chromaPositionX == 1; |
||||
|
WriteSubsampledSamples<TSample, TStorer>( |
||||
|
blue0, |
||||
|
blue1, |
||||
|
blueDestination, |
||||
|
isCenteredX, |
||||
|
row1Weight, |
||||
|
this.colorConverter.ChromaScale, |
||||
|
this.colorConverter.ChromaBias, |
||||
|
this.chromaMaximum); |
||||
|
|
||||
|
WriteSubsampledSamples<TSample, TStorer>( |
||||
|
red0, |
||||
|
red1, |
||||
|
redDestination, |
||||
|
isCenteredX, |
||||
|
row1Weight, |
||||
|
this.colorConverter.ChromaScale, |
||||
|
this.colorConverter.ChromaBias, |
||||
|
this.chromaMaximum); |
||||
|
} |
||||
|
} |
||||
|
} |
||||
@ -0,0 +1,78 @@ |
|||||
|
// Copyright (c) Six Labors.
|
||||
|
// Licensed under the Six Labors Split License.
|
||||
|
|
||||
|
namespace SixLabors.ImageSharp.Formats.Heif.Color; |
||||
|
|
||||
|
/// <summary>
|
||||
|
/// Exposes the native planar sample layout shared by HEIF image codecs.
|
||||
|
/// </summary>
|
||||
|
/// <typeparam name="TSample">The native unsigned sample storage type.</typeparam>
|
||||
|
internal interface IHeifPlanarSampleBuffer<TSample> |
||||
|
where TSample : unmanaged |
||||
|
{ |
||||
|
/// <summary>
|
||||
|
/// Gets the full luma-plane width in samples.
|
||||
|
/// </summary>
|
||||
|
public int Width { get; } |
||||
|
|
||||
|
/// <summary>
|
||||
|
/// Gets the full luma-plane height in samples.
|
||||
|
/// </summary>
|
||||
|
public int Height { get; } |
||||
|
|
||||
|
/// <summary>
|
||||
|
/// Gets the luma sample precision in bits.
|
||||
|
/// </summary>
|
||||
|
public int LumaBitDepth { get; } |
||||
|
|
||||
|
/// <summary>
|
||||
|
/// Gets the chroma sample precision in bits.
|
||||
|
/// </summary>
|
||||
|
public int ChromaBitDepth { get; } |
||||
|
|
||||
|
/// <summary>
|
||||
|
/// Gets a value indicating whether the buffer contains only the luma plane.
|
||||
|
/// </summary>
|
||||
|
public bool IsMonochrome { get; } |
||||
|
|
||||
|
/// <summary>
|
||||
|
/// Gets the horizontal chroma subsampling shift.
|
||||
|
/// </summary>
|
||||
|
public int ChromaSubsamplingX { get; } |
||||
|
|
||||
|
/// <summary>
|
||||
|
/// Gets the vertical chroma subsampling shift.
|
||||
|
/// </summary>
|
||||
|
public int ChromaSubsamplingY { get; } |
||||
|
|
||||
|
/// <summary>
|
||||
|
/// Gets the horizontal chroma position in half-luma-sample units.
|
||||
|
/// </summary>
|
||||
|
public int ChromaPositionX { get; } |
||||
|
|
||||
|
/// <summary>
|
||||
|
/// Gets the vertical chroma position in half-luma-sample units.
|
||||
|
/// </summary>
|
||||
|
public int ChromaPositionY { get; } |
||||
|
|
||||
|
/// <summary>
|
||||
|
/// Gets one complete writable row from the luma, green, or intensity plane.
|
||||
|
/// </summary>
|
||||
|
/// <param name="row">The zero-based row index in plane samples.</param>
|
||||
|
/// <returns>The native luma, green, or intensity samples.</returns>
|
||||
|
public Span<TSample> GetLumaRowSpan(int row); |
||||
|
|
||||
|
/// <summary>
|
||||
|
/// Gets one complete writable row from the blue-difference, blue, or first opponent-color plane.
|
||||
|
/// </summary>
|
||||
|
/// <param name="row">The zero-based row index in plane samples.</param>
|
||||
|
/// <returns>The native blue-difference, blue, or first opponent-color samples.</returns>
|
||||
|
public Span<TSample> GetChromaBlueRowSpan(int row); |
||||
|
|
||||
|
/// <summary>
|
||||
|
/// Gets one complete writable row from the red-difference, red, or second opponent-color plane.
|
||||
|
/// </summary>
|
||||
|
/// <param name="row">The zero-based row index in plane samples.</param>
|
||||
|
/// <returns>The native red-difference, red, or second opponent-color samples.</returns>
|
||||
|
public Span<TSample> GetChromaRedRowSpan(int row); |
||||
|
} |
||||
@ -1,31 +0,0 @@ |
|||||
// Copyright (c) Six Labors.
|
|
||||
// Licensed under the Six Labors Split License.
|
|
||||
|
|
||||
namespace SixLabors.ImageSharp.Formats.Heif.Color; |
|
||||
|
|
||||
/// <summary>
|
|
||||
/// Exposes reconstructed eight-bit 4:2:0 component rows to the shared fixed-point HEIF converter.
|
|
||||
/// </summary>
|
|
||||
internal interface IHeifYuv420ToRgb8Source |
|
||||
{ |
|
||||
/// <summary>
|
|
||||
/// Gets one complete luma row in native sample storage.
|
|
||||
/// </summary>
|
|
||||
/// <param name="row">The zero-based luma row.</param>
|
|
||||
/// <returns>The reconstructed luma samples.</returns>
|
|
||||
public ReadOnlySpan<ushort> GetLumaRow(int row); |
|
||||
|
|
||||
/// <summary>
|
|
||||
/// Gets one complete blue-difference chroma row in native sample storage.
|
|
||||
/// </summary>
|
|
||||
/// <param name="row">The zero-based chroma row.</param>
|
|
||||
/// <returns>The reconstructed blue-difference samples.</returns>
|
|
||||
public ReadOnlySpan<ushort> GetChromaBlueRow(int row); |
|
||||
|
|
||||
/// <summary>
|
|
||||
/// Gets one complete red-difference chroma row in native sample storage.
|
|
||||
/// </summary>
|
|
||||
/// <param name="row">The zero-based chroma row.</param>
|
|
||||
/// <returns>The reconstructed red-difference samples.</returns>
|
|
||||
public ReadOnlySpan<ushort> GetChromaRedRow(int row); |
|
||||
} |
|
||||
@ -0,0 +1,81 @@ |
|||||
|
// Copyright (c) Six Labors.
|
||||
|
// Licensed under the Six Labors Split License.
|
||||
|
|
||||
|
using SixLabors.ImageSharp.Formats.Heif.Color; |
||||
|
|
||||
|
namespace SixLabors.ImageSharp.Formats.Heif.Hevc.Color; |
||||
|
|
||||
|
/// <summary>
|
||||
|
/// Adapts reconstructed HEVC planes to the shared HEIF planar color pipeline.
|
||||
|
/// </summary>
|
||||
|
internal struct HevcPlanarSampleBuffer : IHeifPlanarSampleBuffer<ushort> |
||||
|
{ |
||||
|
/// <summary>
|
||||
|
/// The reconstructed HEVC picture containing the component planes.
|
||||
|
/// </summary>
|
||||
|
private readonly HevcPictureBuffer picture; |
||||
|
|
||||
|
/// <summary>
|
||||
|
/// The progressive-frame 4:2:0 chroma sample location.
|
||||
|
/// </summary>
|
||||
|
private readonly HevcChromaSampleLocation chromaSampleLocation; |
||||
|
|
||||
|
/// <summary>
|
||||
|
/// Initializes a new instance of the <see cref="HevcPlanarSampleBuffer"/> struct.
|
||||
|
/// </summary>
|
||||
|
/// <param name="picture">The reconstructed HEVC picture.</param>
|
||||
|
/// <param name="chromaSampleLocation">The progressive-frame 4:2:0 chroma sample location.</param>
|
||||
|
public HevcPlanarSampleBuffer(HevcPictureBuffer picture, HevcChromaSampleLocation chromaSampleLocation) |
||||
|
{ |
||||
|
this.picture = picture; |
||||
|
this.chromaSampleLocation = chromaSampleLocation; |
||||
|
} |
||||
|
|
||||
|
/// <summary>
|
||||
|
/// Gets the horizontal offset in half-luma-sample units for each HEVC 4:2:0 chroma-location code.
|
||||
|
/// </summary>
|
||||
|
private static ReadOnlySpan<byte> ChromaLocationX => [0, 1, 0, 1, 0, 1]; |
||||
|
|
||||
|
/// <summary>
|
||||
|
/// Gets the vertical offset in half-luma-sample units for each HEVC 4:2:0 chroma-location code.
|
||||
|
/// </summary>
|
||||
|
private static ReadOnlySpan<byte> ChromaLocationY => [1, 1, 0, 0, 2, 2]; |
||||
|
|
||||
|
/// <inheritdoc/>
|
||||
|
public readonly int Width => this.picture.Width; |
||||
|
|
||||
|
/// <inheritdoc/>
|
||||
|
public readonly int Height => this.picture.Height; |
||||
|
|
||||
|
/// <inheritdoc/>
|
||||
|
public readonly int LumaBitDepth => this.picture.BitDepthLuma; |
||||
|
|
||||
|
/// <inheritdoc/>
|
||||
|
public readonly int ChromaBitDepth => this.picture.BitDepthChroma; |
||||
|
|
||||
|
/// <inheritdoc/>
|
||||
|
public readonly bool IsMonochrome => this.picture.ChromaFormat == 0; |
||||
|
|
||||
|
/// <inheritdoc/>
|
||||
|
public readonly int ChromaSubsamplingX => this.picture.GetSubsamplingX(HevcPlane.Cb); |
||||
|
|
||||
|
/// <inheritdoc/>
|
||||
|
public readonly int ChromaSubsamplingY => this.picture.GetSubsamplingY(HevcPlane.Cb); |
||||
|
|
||||
|
/// <inheritdoc/>
|
||||
|
public readonly int ChromaPositionX |
||||
|
=> this.picture.ChromaFormat == 1 && !this.picture.SeparateColorPlane ? ChromaLocationX[(int)this.chromaSampleLocation] : 0; |
||||
|
|
||||
|
/// <inheritdoc/>
|
||||
|
public readonly int ChromaPositionY |
||||
|
=> this.picture.ChromaFormat == 1 && !this.picture.SeparateColorPlane ? ChromaLocationY[(int)this.chromaSampleLocation] : 0; |
||||
|
|
||||
|
/// <inheritdoc/>
|
||||
|
public Span<ushort> GetLumaRowSpan(int row) => this.picture.GetRowSpan(HevcPlane.Y, row); |
||||
|
|
||||
|
/// <inheritdoc/>
|
||||
|
public Span<ushort> GetChromaBlueRowSpan(int row) => this.picture.GetRowSpan(HevcPlane.Cb, row); |
||||
|
|
||||
|
/// <inheritdoc/>
|
||||
|
public Span<ushort> GetChromaRedRowSpan(int row) => this.picture.GetRowSpan(HevcPlane.Cr, row); |
||||
|
} |
||||
@ -1,32 +0,0 @@ |
|||||
// Copyright (c) Six Labors.
|
|
||||
// Licensed under the Six Labors Split License.
|
|
||||
|
|
||||
using SixLabors.ImageSharp.Formats.Heif.Color; |
|
||||
|
|
||||
namespace SixLabors.ImageSharp.Formats.Heif.Hevc.Color; |
|
||||
|
|
||||
/// <summary>
|
|
||||
/// Adapts reconstructed HEVC planes to the shared fixed-point HEIF color converter.
|
|
||||
/// </summary>
|
|
||||
internal readonly struct HevcYuv420ToRgb8Source : IHeifYuv420ToRgb8Source |
|
||||
{ |
|
||||
/// <summary>
|
|
||||
/// The reconstructed HEVC picture containing the component planes.
|
|
||||
/// </summary>
|
|
||||
private readonly HevcPictureBuffer picture; |
|
||||
|
|
||||
/// <summary>
|
|
||||
/// Initializes a new instance of the <see cref="HevcYuv420ToRgb8Source"/> struct.
|
|
||||
/// </summary>
|
|
||||
/// <param name="picture">The reconstructed HEVC picture.</param>
|
|
||||
public HevcYuv420ToRgb8Source(HevcPictureBuffer picture) => this.picture = picture; |
|
||||
|
|
||||
/// <inheritdoc/>
|
|
||||
public ReadOnlySpan<ushort> GetLumaRow(int row) => this.picture.GetRowSpan(HevcPlane.Y, row); |
|
||||
|
|
||||
/// <inheritdoc/>
|
|
||||
public ReadOnlySpan<ushort> GetChromaBlueRow(int row) => this.picture.GetRowSpan(HevcPlane.Cb, row); |
|
||||
|
|
||||
/// <inheritdoc/>
|
|
||||
public ReadOnlySpan<ushort> GetChromaRedRow(int row) => this.picture.GetRowSpan(HevcPlane.Cr, row); |
|
||||
} |
|
||||
Loading…
Reference in new issue