mirror of https://github.com/SixLabors/ImageSharp
James Jackson-South
2 months ago
9 changed files with 670 additions and 55 deletions
@ -0,0 +1,123 @@ |
|||||
|
// Copyright (c) Six Labors.
|
||||
|
// Licensed under the Six Labors Split License.
|
||||
|
|
||||
|
namespace SixLabors.ImageSharp.Formats.Heif.Hevc; |
||||
|
|
||||
|
/// <summary>
|
||||
|
/// Contains the length-delimited NAL units and IDR slice segments carried by one HEVC still-image item.
|
||||
|
/// </summary>
|
||||
|
internal sealed class HevcImageItemBitstream |
||||
|
{ |
||||
|
/// <summary>
|
||||
|
/// Initializes a new instance of the <see cref="HevcImageItemBitstream"/> class.
|
||||
|
/// </summary>
|
||||
|
/// <param name="data">The complete bounded payload of one <c>hvc1</c> image item.</param>
|
||||
|
/// <param name="configuration">The codec configuration associated with the same image item.</param>
|
||||
|
/// <exception cref="InvalidImageContentException">
|
||||
|
/// NAL-unit framing is malformed, the payload contains sequence or layered coding, or the item does not contain
|
||||
|
/// exactly one independently decodable IDR picture.
|
||||
|
/// </exception>
|
||||
|
public HevcImageItemBitstream(ReadOnlySpan<byte> data, HevcCodecConfiguration configuration) |
||||
|
{ |
||||
|
List<HevcNalUnit> nalUnits = []; |
||||
|
List<HevcSliceSegmentHeader> sliceSegments = []; |
||||
|
int offset = 0; |
||||
|
while (offset < data.Length) |
||||
|
{ |
||||
|
if (data.Length - offset < configuration.NalUnitLengthSize) |
||||
|
{ |
||||
|
throw new InvalidImageContentException("The HEVC image item has a truncated NAL-unit length."); |
||||
|
} |
||||
|
|
||||
|
int nalUnitLength = ReadNalUnitLength(data[offset..], configuration.NalUnitLengthSize); |
||||
|
offset += configuration.NalUnitLengthSize; |
||||
|
if (nalUnitLength < 2 || nalUnitLength > data.Length - offset) |
||||
|
{ |
||||
|
throw new InvalidImageContentException("The HEVC image item has an invalid NAL-unit length."); |
||||
|
} |
||||
|
|
||||
|
HevcNalUnit nalUnit = new(data.Slice(offset, nalUnitLength)); |
||||
|
offset += nalUnitLength; |
||||
|
if (nalUnit.Header.LayerId != 0 || nalUnit.Header.TemporalId != 0) |
||||
|
{ |
||||
|
throw new InvalidImageContentException("The HEVC image item contains layered or temporal-substream NAL units."); |
||||
|
} |
||||
|
|
||||
|
nalUnits.Add(nalUnit); |
||||
|
if (nalUnit.Header.IsVideoCodingLayer) |
||||
|
{ |
||||
|
if (!nalUnit.Header.IsInstantaneousDecoderRefresh) |
||||
|
{ |
||||
|
throw new InvalidImageContentException("The HEVC image item contains a coded picture that is not independently decodable."); |
||||
|
} |
||||
|
|
||||
|
HevcSliceSegmentHeader sliceSegment = new(nalUnit, configuration.PictureParameterSets); |
||||
|
if (sliceSegments.Count == 0 && !sliceSegment.FirstSliceSegmentInPicture) |
||||
|
{ |
||||
|
throw new InvalidImageContentException("The first HEVC image-item slice is not marked as the first picture segment."); |
||||
|
} |
||||
|
|
||||
|
if (sliceSegments.Count != 0 && sliceSegment.FirstSliceSegmentInPicture) |
||||
|
{ |
||||
|
throw new InvalidImageContentException("The HEVC image item contains more than one coded picture."); |
||||
|
} |
||||
|
|
||||
|
sliceSegments.Add(sliceSegment); |
||||
|
continue; |
||||
|
} |
||||
|
|
||||
|
if (nalUnit.Header.NalUnitType is 32 or 33 or 34) |
||||
|
{ |
||||
|
// hvc1 image items obtain all parameter sets from the associated hvcC property. Accepting in-band
|
||||
|
// replacements would silently apply the more permissive hev1 sample contract to this still image.
|
||||
|
throw new InvalidImageContentException("The HEVC hvc1 image item contains an in-band parameter set."); |
||||
|
} |
||||
|
|
||||
|
if (nalUnit.Header.NalUnitType is 36 or 37) |
||||
|
{ |
||||
|
throw new InvalidImageContentException("The HEVC image item contains an end-of-sequence NAL unit."); |
||||
|
} |
||||
|
} |
||||
|
|
||||
|
if (sliceSegments.Count == 0) |
||||
|
{ |
||||
|
throw new InvalidImageContentException("The HEVC image item contains no independently decodable picture."); |
||||
|
} |
||||
|
|
||||
|
this.NalUnits = nalUnits; |
||||
|
this.SliceSegments = sliceSegments; |
||||
|
} |
||||
|
|
||||
|
/// <summary>
|
||||
|
/// Gets every decoded NAL unit in item order, including permitted delimiter, filler, and supplemental units.
|
||||
|
/// </summary>
|
||||
|
public IReadOnlyList<HevcNalUnit> NalUnits { get; } |
||||
|
|
||||
|
/// <summary>
|
||||
|
/// Gets the ordered slice segments that reconstruct the item's single IDR picture.
|
||||
|
/// </summary>
|
||||
|
public IReadOnlyList<HevcSliceSegmentHeader> SliceSegments { get; } |
||||
|
|
||||
|
/// <summary>
|
||||
|
/// Reads an unsigned one-through-four-byte NAL-unit length without assuming four-byte item framing.
|
||||
|
/// </summary>
|
||||
|
/// <param name="data">The item bytes beginning at the length field.</param>
|
||||
|
/// <param name="lengthSize">The codec-configuration-selected length-field width.</param>
|
||||
|
/// <returns>The bounded signed integer NAL-unit length.</returns>
|
||||
|
/// <exception cref="InvalidImageContentException">The unsigned length exceeds the supported item-buffer range.</exception>
|
||||
|
private static int ReadNalUnitLength(ReadOnlySpan<byte> data, int lengthSize) |
||||
|
{ |
||||
|
uint value = 0; |
||||
|
for (int byteIndex = 0; byteIndex < lengthSize; byteIndex++) |
||||
|
{ |
||||
|
value = (value << 8) | data[byteIndex]; |
||||
|
} |
||||
|
|
||||
|
if (value > int.MaxValue) |
||||
|
{ |
||||
|
throw new InvalidImageContentException("The HEVC image-item NAL-unit length is too large."); |
||||
|
} |
||||
|
|
||||
|
return (int)value; |
||||
|
} |
||||
|
} |
||||
@ -0,0 +1,389 @@ |
|||||
|
// Copyright (c) Six Labors.
|
||||
|
// Licensed under the Six Labors Split License.
|
||||
|
|
||||
|
namespace SixLabors.ImageSharp.Formats.Heif.Hevc; |
||||
|
|
||||
|
/// <summary>
|
||||
|
/// Contains the decoded header and entropy-coded payload of one HEVC still-picture slice segment.
|
||||
|
/// </summary>
|
||||
|
internal sealed class HevcSliceSegmentHeader |
||||
|
{ |
||||
|
/// <summary>
|
||||
|
/// Initializes a new instance of the <see cref="HevcSliceSegmentHeader"/> class.
|
||||
|
/// </summary>
|
||||
|
/// <param name="nalUnit">The item-local instantaneous-decoder-refresh NAL unit.</param>
|
||||
|
/// <param name="pictureParameterSets">The picture parameter sets available to the coded image item.</param>
|
||||
|
/// <exception cref="InvalidImageContentException">
|
||||
|
/// The NAL unit is not a base-layer IDR slice, references unavailable parameters, or contains malformed
|
||||
|
/// still-picture slice-header syntax.
|
||||
|
/// </exception>
|
||||
|
public HevcSliceSegmentHeader( |
||||
|
HevcNalUnit nalUnit, |
||||
|
IReadOnlyList<HevcPictureParameterSet> pictureParameterSets) |
||||
|
{ |
||||
|
if (!nalUnit.Header.IsInstantaneousDecoderRefresh |
||||
|
|| nalUnit.Header.LayerId != 0 |
||||
|
|| nalUnit.Header.TemporalId != 0) |
||||
|
{ |
||||
|
throw new InvalidImageContentException("The HEVC image item contains a non-IDR or layered coded slice."); |
||||
|
} |
||||
|
|
||||
|
this.NalUnit = nalUnit; |
||||
|
HevcBitReader reader = new(nalUnit.Rbsp.Span); |
||||
|
this.FirstSliceSegmentInPicture = reader.ReadFlag(); |
||||
|
|
||||
|
// An IDR item has no earlier picture whose output can affect the returned still image. Consume the required
|
||||
|
// random-access flag without retaining sequence-output state in the image decoder.
|
||||
|
reader.ReadFlag(); |
||||
|
|
||||
|
uint pictureParameterSetId = reader.ReadUnsignedExpGolomb(); |
||||
|
if (pictureParameterSetId > 63) |
||||
|
{ |
||||
|
throw new InvalidImageContentException("The HEVC slice segment has an invalid picture-parameter-set identifier."); |
||||
|
} |
||||
|
|
||||
|
HevcPictureParameterSet? pictureParameterSet = null; |
||||
|
foreach (HevcPictureParameterSet candidate in pictureParameterSets) |
||||
|
{ |
||||
|
if (candidate.Id == pictureParameterSetId) |
||||
|
{ |
||||
|
pictureParameterSet = candidate; |
||||
|
break; |
||||
|
} |
||||
|
} |
||||
|
|
||||
|
if (pictureParameterSet is null) |
||||
|
{ |
||||
|
throw new InvalidImageContentException("The HEVC slice segment references an unavailable picture parameter set."); |
||||
|
} |
||||
|
|
||||
|
this.PictureParameterSet = pictureParameterSet; |
||||
|
HevcSequenceParameterSet sequenceParameterSet = pictureParameterSet.SequenceParameterSet; |
||||
|
if (pictureParameterSet.DependentSliceSegmentsEnabled && !this.FirstSliceSegmentInPicture) |
||||
|
{ |
||||
|
this.DependentSliceSegment = reader.ReadFlag(); |
||||
|
} |
||||
|
|
||||
|
int codingTreeBlockColumns = HevcParameterSetSyntax.GetCodingTreeBlockCount( |
||||
|
sequenceParameterSet.Width, |
||||
|
sequenceParameterSet.CodingTreeBlockLog2); |
||||
|
|
||||
|
int codingTreeBlockRows = HevcParameterSetSyntax.GetCodingTreeBlockCount( |
||||
|
sequenceParameterSet.Height, |
||||
|
sequenceParameterSet.CodingTreeBlockLog2); |
||||
|
|
||||
|
int codingTreeBlockCount = codingTreeBlockColumns * codingTreeBlockRows; |
||||
|
if (!this.FirstSliceSegmentInPicture) |
||||
|
{ |
||||
|
int addressBitCount = HevcParameterSetSyntax.GetCeilingLog2(codingTreeBlockCount); |
||||
|
uint address = reader.ReadBits(addressBitCount); |
||||
|
if (address >= codingTreeBlockCount) |
||||
|
{ |
||||
|
throw new InvalidImageContentException("The HEVC slice segment address is outside the coded picture."); |
||||
|
} |
||||
|
|
||||
|
this.SliceSegmentAddress = (int)address; |
||||
|
} |
||||
|
|
||||
|
if (!this.DependentSliceSegment) |
||||
|
{ |
||||
|
this.ReadIndependentHeader(ref reader); |
||||
|
} |
||||
|
|
||||
|
this.ReadEntryPoints(ref reader, codingTreeBlockCount); |
||||
|
if (pictureParameterSet.SliceSegmentHeaderExtensionPresent) |
||||
|
{ |
||||
|
uint extensionLength = reader.ReadUnsignedExpGolomb(); |
||||
|
if (extensionLength > int.MaxValue || extensionLength > reader.BitsRemaining / 8) |
||||
|
{ |
||||
|
throw new InvalidImageContentException("The HEVC slice-segment header extension is truncated."); |
||||
|
} |
||||
|
|
||||
|
for (int byteIndex = 0; byteIndex < extensionLength; byteIndex++) |
||||
|
{ |
||||
|
reader.ReadBits(8); |
||||
|
} |
||||
|
} |
||||
|
|
||||
|
reader.ReadByteAlignment(); |
||||
|
this.HeaderLength = reader.BitPosition / 8; |
||||
|
this.SliceData = nalUnit.Rbsp[this.HeaderLength..]; |
||||
|
if (this.SliceData.IsEmpty) |
||||
|
{ |
||||
|
throw new InvalidImageContentException("The HEVC slice segment contains no entropy-coded data."); |
||||
|
} |
||||
|
|
||||
|
int encodedHeaderLength = GetEncodedPayloadOffset( |
||||
|
this.HeaderLength, |
||||
|
nalUnit.EmulationPreventionBytePositions); |
||||
|
|
||||
|
int availableEncodedData = nalUnit.EncodedPayloadLength - encodedHeaderLength; |
||||
|
int cumulativeEntryPointOffset = 0; |
||||
|
foreach (int entryPointOffset in this.EntryPointOffsets) |
||||
|
{ |
||||
|
if (cumulativeEntryPointOffset > availableEncodedData - entryPointOffset) |
||||
|
{ |
||||
|
throw new InvalidImageContentException("The HEVC slice entry point extends beyond its NAL unit."); |
||||
|
} |
||||
|
|
||||
|
cumulativeEntryPointOffset += entryPointOffset; |
||||
|
} |
||||
|
} |
||||
|
|
||||
|
/// <summary>Gets the complete decoded NAL unit containing this slice segment.</summary>
|
||||
|
public HevcNalUnit NalUnit { get; } |
||||
|
|
||||
|
/// <summary>Gets a value indicating whether this is the first slice segment of the coded picture.</summary>
|
||||
|
public bool FirstSliceSegmentInPicture { get; } |
||||
|
|
||||
|
/// <summary>Gets a value indicating whether this segment inherits syntax from an earlier independent slice.</summary>
|
||||
|
public bool DependentSliceSegment { get; } |
||||
|
|
||||
|
/// <summary>Gets the picture parameters selected by this slice segment.</summary>
|
||||
|
public HevcPictureParameterSet PictureParameterSet { get; } |
||||
|
|
||||
|
/// <summary>Gets the raster-scan address of the first coding-tree block in this slice segment.</summary>
|
||||
|
public int SliceSegmentAddress { get; } |
||||
|
|
||||
|
/// <summary>Gets the independent slice prediction type, or <see langword="null"/> for a dependent segment.</summary>
|
||||
|
public HevcSliceType? SliceType { get; private set; } |
||||
|
|
||||
|
/// <summary>Gets the selected color-plane identifier for separate-plane 4:4:4 coding.</summary>
|
||||
|
public byte ColorPlaneId { get; private set; } |
||||
|
|
||||
|
/// <summary>Gets a value indicating whether luma sample-adaptive offset filtering is enabled.</summary>
|
||||
|
public bool? SampleAdaptiveOffsetLumaEnabled { get; private set; } |
||||
|
|
||||
|
/// <summary>Gets a value indicating whether chroma sample-adaptive offset filtering is enabled.</summary>
|
||||
|
public bool? SampleAdaptiveOffsetChromaEnabled { get; private set; } |
||||
|
|
||||
|
/// <summary>Gets the effective luma quantization parameter, or <see langword="null"/> for a dependent segment.</summary>
|
||||
|
public int? QuantizationParameter { get; private set; } |
||||
|
|
||||
|
/// <summary>Gets the slice-level Cb quantization-parameter offset.</summary>
|
||||
|
public int ChromaCbQuantizationParameterOffset { get; private set; } |
||||
|
|
||||
|
/// <summary>Gets the slice-level Cr quantization-parameter offset.</summary>
|
||||
|
public int ChromaCrQuantizationParameterOffset { get; private set; } |
||||
|
|
||||
|
/// <summary>Gets a value indicating whether coding units can select the PPS chroma-offset list.</summary>
|
||||
|
public bool? ChromaQuantizationParameterOffsetListEnabled { get; private set; } |
||||
|
|
||||
|
/// <summary>Gets a value indicating whether deblocking is disabled for this independent slice.</summary>
|
||||
|
public bool? DeblockingFilterDisabled { get; private set; } |
||||
|
|
||||
|
/// <summary>Gets half the effective deblocking beta-threshold offset.</summary>
|
||||
|
public int DeblockingFilterBetaOffsetDiv2 { get; private set; } |
||||
|
|
||||
|
/// <summary>Gets half the effective deblocking clipping-threshold offset.</summary>
|
||||
|
public int DeblockingFilterTcOffsetDiv2 { get; private set; } |
||||
|
|
||||
|
/// <summary>Gets a value indicating whether in-loop filtering crosses slice boundaries.</summary>
|
||||
|
public bool? LoopFilterAcrossSlicesEnabled { get; private set; } |
||||
|
|
||||
|
/// <summary>
|
||||
|
/// Gets the encoded-byte lengths that separate tile or wavefront entropy substreams after the first substream.
|
||||
|
/// </summary>
|
||||
|
public IReadOnlyList<int> EntryPointOffsets { get; private set; } = Array.Empty<int>(); |
||||
|
|
||||
|
/// <summary>Gets the slice-header length in decoded raw-byte-sequence payload bytes.</summary>
|
||||
|
public int HeaderLength { get; } |
||||
|
|
||||
|
/// <summary>Gets the entropy-coded slice data following byte alignment.</summary>
|
||||
|
public ReadOnlyMemory<byte> SliceData { get; } |
||||
|
|
||||
|
/// <summary>
|
||||
|
/// Reads fields carried only by an independent slice-segment header.
|
||||
|
/// </summary>
|
||||
|
/// <param name="reader">The slice-segment raw byte sequence payload reader.</param>
|
||||
|
/// <exception cref="InvalidImageContentException">
|
||||
|
/// The slice is not intra-coded or its quantization and filter fields are outside the governing parameter bounds.
|
||||
|
/// </exception>
|
||||
|
private void ReadIndependentHeader(ref HevcBitReader reader) |
||||
|
{ |
||||
|
HevcPictureParameterSet pictureParameterSet = this.PictureParameterSet; |
||||
|
HevcSequenceParameterSet sequenceParameterSet = pictureParameterSet.SequenceParameterSet; |
||||
|
for (int extraBit = 0; extraBit < pictureParameterSet.ExtraSliceHeaderBitCount; extraBit++) |
||||
|
{ |
||||
|
reader.ReadFlag(); |
||||
|
} |
||||
|
|
||||
|
uint sliceType = reader.ReadUnsignedExpGolomb(); |
||||
|
if (sliceType != (uint)HevcSliceType.Intra) |
||||
|
{ |
||||
|
throw new InvalidImageContentException("An independently coded HEVC image item must contain intra IDR slices."); |
||||
|
} |
||||
|
|
||||
|
this.SliceType = HevcSliceType.Intra; |
||||
|
if (pictureParameterSet.OutputFlagPresent && !reader.ReadFlag()) |
||||
|
{ |
||||
|
throw new InvalidImageContentException("The HEVC image-item slice is marked as unavailable for output."); |
||||
|
} |
||||
|
|
||||
|
if (sequenceParameterSet.SeparateColorPlaneFlag) |
||||
|
{ |
||||
|
this.ColorPlaneId = (byte)reader.ReadBits(2); |
||||
|
if (this.ColorPlaneId > 2) |
||||
|
{ |
||||
|
throw new InvalidImageContentException("The HEVC slice segment has an invalid separate color-plane identifier."); |
||||
|
} |
||||
|
} |
||||
|
|
||||
|
bool hasCombinedChromaPlanes = sequenceParameterSet.ChromaFormat != 0 |
||||
|
&& !sequenceParameterSet.SeparateColorPlaneFlag; |
||||
|
|
||||
|
if (sequenceParameterSet.SampleAdaptiveOffsetEnabled) |
||||
|
{ |
||||
|
this.SampleAdaptiveOffsetLumaEnabled = reader.ReadFlag(); |
||||
|
this.SampleAdaptiveOffsetChromaEnabled = hasCombinedChromaPlanes && reader.ReadFlag(); |
||||
|
} |
||||
|
|
||||
|
int sliceQuantizationParameterDelta = reader.ReadSignedExpGolomb(); |
||||
|
long quantizationParameter = 26L |
||||
|
+ pictureParameterSet.InitialQuantizationParameterMinus26 |
||||
|
+ sliceQuantizationParameterDelta; |
||||
|
|
||||
|
int minimumQuantizationParameter = -6 * (sequenceParameterSet.BitDepthLuma - 8); |
||||
|
if (quantizationParameter < minimumQuantizationParameter || quantizationParameter > 51) |
||||
|
{ |
||||
|
throw new InvalidImageContentException("The HEVC slice segment has an invalid luma quantization parameter."); |
||||
|
} |
||||
|
|
||||
|
this.QuantizationParameter = (int)quantizationParameter; |
||||
|
if (pictureParameterSet.SliceChromaQuantizationParameterOffsetsPresent && hasCombinedChromaPlanes) |
||||
|
{ |
||||
|
this.ChromaCbQuantizationParameterOffset = HevcParameterSetSyntax.ReadQuantizationParameterOffset(ref reader); |
||||
|
this.ChromaCrQuantizationParameterOffset = HevcParameterSetSyntax.ReadQuantizationParameterOffset(ref reader); |
||||
|
if (pictureParameterSet.ChromaCbQuantizationParameterOffset + this.ChromaCbQuantizationParameterOffset is < -12 or > 12 |
||||
|
|| pictureParameterSet.ChromaCrQuantizationParameterOffset + this.ChromaCrQuantizationParameterOffset is < -12 or > 12) |
||||
|
{ |
||||
|
throw new InvalidImageContentException("The HEVC slice and picture chroma quantization offsets have an invalid sum."); |
||||
|
} |
||||
|
} |
||||
|
|
||||
|
if (pictureParameterSet.ChromaQuantizationParameterOffsetsCb.Count != 0) |
||||
|
{ |
||||
|
this.ChromaQuantizationParameterOffsetListEnabled = reader.ReadFlag(); |
||||
|
} |
||||
|
|
||||
|
this.ReadDeblockingFilterFields(ref reader); |
||||
|
bool sampleAdaptiveOffsetEnabled = this.SampleAdaptiveOffsetLumaEnabled == true |
||||
|
|| this.SampleAdaptiveOffsetChromaEnabled == true; |
||||
|
|
||||
|
if (pictureParameterSet.LoopFilterAcrossSlicesEnabled |
||||
|
&& (sampleAdaptiveOffsetEnabled || this.DeblockingFilterDisabled == false)) |
||||
|
{ |
||||
|
this.LoopFilterAcrossSlicesEnabled = reader.ReadFlag(); |
||||
|
} |
||||
|
else |
||||
|
{ |
||||
|
this.LoopFilterAcrossSlicesEnabled = pictureParameterSet.LoopFilterAcrossSlicesEnabled; |
||||
|
} |
||||
|
} |
||||
|
|
||||
|
/// <summary>
|
||||
|
/// Resolves the independent slice's effective deblocking mode and threshold offsets.
|
||||
|
/// </summary>
|
||||
|
/// <param name="reader">The slice-segment raw byte sequence payload reader.</param>
|
||||
|
private void ReadDeblockingFilterFields(ref HevcBitReader reader) |
||||
|
{ |
||||
|
HevcPictureParameterSet pictureParameterSet = this.PictureParameterSet; |
||||
|
bool overrideFilter = false; |
||||
|
if (pictureParameterSet.DeblockingFilterControlPresent |
||||
|
&& pictureParameterSet.DeblockingFilterOverrideEnabled) |
||||
|
{ |
||||
|
overrideFilter = reader.ReadFlag(); |
||||
|
} |
||||
|
|
||||
|
if (overrideFilter) |
||||
|
{ |
||||
|
this.DeblockingFilterDisabled = reader.ReadFlag(); |
||||
|
if (this.DeblockingFilterDisabled == false) |
||||
|
{ |
||||
|
this.DeblockingFilterBetaOffsetDiv2 = HevcParameterSetSyntax.ReadDeblockingFilterOffset(ref reader); |
||||
|
this.DeblockingFilterTcOffsetDiv2 = HevcParameterSetSyntax.ReadDeblockingFilterOffset(ref reader); |
||||
|
} |
||||
|
|
||||
|
return; |
||||
|
} |
||||
|
|
||||
|
this.DeblockingFilterDisabled = pictureParameterSet.DeblockingFilterControlPresent |
||||
|
&& pictureParameterSet.DeblockingFilterDisabled; |
||||
|
|
||||
|
this.DeblockingFilterBetaOffsetDiv2 = pictureParameterSet.DeblockingFilterBetaOffsetDiv2; |
||||
|
this.DeblockingFilterTcOffsetDiv2 = pictureParameterSet.DeblockingFilterTcOffsetDiv2; |
||||
|
} |
||||
|
|
||||
|
/// <summary>
|
||||
|
/// Reads tile or wavefront substream entry-point byte lengths.
|
||||
|
/// </summary>
|
||||
|
/// <param name="reader">The slice-segment raw byte sequence payload reader.</param>
|
||||
|
/// <param name="codingTreeBlockCount">The number of coding-tree blocks in the coded picture.</param>
|
||||
|
/// <exception cref="InvalidImageContentException">
|
||||
|
/// The entry-point count, field width, or byte length exceeds the bounded picture or integer range.
|
||||
|
/// </exception>
|
||||
|
private void ReadEntryPoints(ref HevcBitReader reader, int codingTreeBlockCount) |
||||
|
{ |
||||
|
HevcPictureParameterSet pictureParameterSet = this.PictureParameterSet; |
||||
|
if (!pictureParameterSet.TilesEnabled && !pictureParameterSet.EntropyCodingSynchronizationEnabled) |
||||
|
{ |
||||
|
return; |
||||
|
} |
||||
|
|
||||
|
uint entryPointCount = reader.ReadUnsignedExpGolomb(); |
||||
|
if (entryPointCount >= codingTreeBlockCount) |
||||
|
{ |
||||
|
throw new InvalidImageContentException("The HEVC slice segment declares too many entropy entry points."); |
||||
|
} |
||||
|
|
||||
|
if (entryPointCount == 0) |
||||
|
{ |
||||
|
return; |
||||
|
} |
||||
|
|
||||
|
uint offsetLengthMinusOne = reader.ReadUnsignedExpGolomb(); |
||||
|
if (offsetLengthMinusOne > 31) |
||||
|
{ |
||||
|
throw new InvalidImageContentException("The HEVC slice entry-point offset width is invalid."); |
||||
|
} |
||||
|
|
||||
|
int offsetBitCount = (int)offsetLengthMinusOne + 1; |
||||
|
int[] entryPointOffsets = new int[entryPointCount]; |
||||
|
for (int entryPoint = 0; entryPoint < entryPointOffsets.Length; entryPoint++) |
||||
|
{ |
||||
|
uint entryPointOffsetMinusOne = reader.ReadBits(offsetBitCount); |
||||
|
if (entryPointOffsetMinusOne >= int.MaxValue) |
||||
|
{ |
||||
|
throw new InvalidImageContentException("The HEVC slice entry-point byte length is too large."); |
||||
|
} |
||||
|
|
||||
|
entryPointOffsets[entryPoint] = (int)entryPointOffsetMinusOne + 1; |
||||
|
} |
||||
|
|
||||
|
this.EntryPointOffsets = entryPointOffsets; |
||||
|
} |
||||
|
|
||||
|
/// <summary>
|
||||
|
/// Converts an RBSP byte boundary to its corresponding encoded-payload boundary.
|
||||
|
/// </summary>
|
||||
|
/// <param name="rbspOffset">The decoded raw-byte-sequence payload offset.</param>
|
||||
|
/// <param name="emulationPreventionBytePositions">The removed encoded-payload byte positions.</param>
|
||||
|
/// <returns>The encoded byte-sequence payload offset at the same syntax boundary.</returns>
|
||||
|
private static int GetEncodedPayloadOffset( |
||||
|
int rbspOffset, |
||||
|
IReadOnlyList<int> emulationPreventionBytePositions) |
||||
|
{ |
||||
|
int encodedOffset = rbspOffset; |
||||
|
foreach (int preventionBytePosition in emulationPreventionBytePositions) |
||||
|
{ |
||||
|
if (preventionBytePosition >= encodedOffset) |
||||
|
{ |
||||
|
break; |
||||
|
} |
||||
|
|
||||
|
encodedOffset++; |
||||
|
} |
||||
|
|
||||
|
return encodedOffset; |
||||
|
} |
||||
|
} |
||||
@ -0,0 +1,25 @@ |
|||||
|
// Copyright (c) Six Labors.
|
||||
|
// Licensed under the Six Labors Split License.
|
||||
|
|
||||
|
namespace SixLabors.ImageSharp.Formats.Heif.Hevc; |
||||
|
|
||||
|
/// <summary>
|
||||
|
/// Identifies the prediction structure signaled for an HEVC slice segment.
|
||||
|
/// </summary>
|
||||
|
internal enum HevcSliceType |
||||
|
{ |
||||
|
/// <summary>
|
||||
|
/// The slice can use intra and bidirectional inter prediction.
|
||||
|
/// </summary>
|
||||
|
Bidirectional = 0, |
||||
|
|
||||
|
/// <summary>
|
||||
|
/// The slice can use intra and forward inter prediction.
|
||||
|
/// </summary>
|
||||
|
Predictive = 1, |
||||
|
|
||||
|
/// <summary>
|
||||
|
/// The slice uses only intra-picture prediction.
|
||||
|
/// </summary>
|
||||
|
Intra = 2 |
||||
|
} |
||||
Loading…
Reference in new issue