Browse Source

Verify official ten-bit AV1 sequences

pull/2633/head
James Jackson-South 4 days ago
parent
commit
deefeba234
  1. 7
      HEIF_IMPLEMENTATION_PLAN.md
  2. 131
      tests/ImageSharp.Tests/Formats/Heif/Av1/Av1ReconstructionConformanceTests.cs
  3. 4
      tests/ImageSharp.Tests/TestImages.cs
  4. 16
      tests/Images/Input/Heif/Av1/Conformance/README.md
  5. 3
      tests/Images/Input/Heif/Av1/Conformance/libaom-av1-1-b10-23-film-grain-50-libaom.y4m
  6. 3
      tests/Images/Input/Heif/Av1/Conformance/libaom-av1-1-b10-23-film-grain-50.ivf
  7. 3
      tests/Images/Input/Heif/Av1/Conformance/libaom-av1-1-b10-24-monochrome-libaom.y4m
  8. 3
      tests/Images/Input/Heif/Av1/Conformance/libaom-av1-1-b10-24-monochrome.ivf

7
HEIF_IMPLEMENTATION_PLAN.md

@ -29,7 +29,7 @@ Checkboxes may be marked complete only when the implementation and the verificat
## Delivery dashboard
Last reconciled with the source tree on 2026-08-29 against production checkpoint `42384454eb45b6107608ed33379c7a69b101d533`. Committed checkpoints include the AV1 transform architecture, OBU framing, tile partitioning, mode information, segmentation, delta quantization, transform-size selection, coefficient decoding, inverse quantization, inverse transforms, complete intra prediction, intra-block copy, official extreme-displacement intra-block-copy conformance, the 12-profile reconstruction matrix, corrected twelve-bit inverse-transform SIMD arithmetic, layered-item properties, layered reference/header/CDF/motion-field state, inter-frame intra blocks, SIMD-first translational prediction, complete single-reference inter reconstruction, compound reference trees and modes, paired reference-MV derivation, reference-dependent bounded sequence decoding, allocation-free SIMD-first equal averaging, selected inter-intra prediction, selectable compound blending, OBMC, scaled-reference reconstruction, local warped prediction, non-translational global prediction, official motion-vector conformance, official spatial- and temporal-layer default-operating-point conformance, official active-film-grain and monochrome sequence conformance, selected spatial-layer presentation, and progressive color and auxiliary-alpha conformance. This dashboard is the authoritative delivery order. The detailed phase checklists below provide subsystem evidence; they do not override the current-stage marker or permit work to skip ahead.
Last reconciled with the source tree on 2026-08-29 against production checkpoint `6b3a5a5e1849de7881b929f46a5744fa3efe3fd6`. Committed checkpoints include the AV1 transform architecture, OBU framing, tile partitioning, mode information, segmentation, delta quantization, transform-size selection, coefficient decoding, inverse quantization, inverse transforms, complete intra prediction, intra-block copy, official extreme-displacement intra-block-copy conformance, the 12-profile reconstruction matrix, corrected twelve-bit inverse-transform SIMD arithmetic, layered-item properties, layered reference/header/CDF/motion-field state, inter-frame intra blocks, SIMD-first translational prediction, complete single-reference inter reconstruction, compound reference trees and modes, paired reference-MV derivation, reference-dependent bounded sequence decoding, allocation-free SIMD-first equal averaging, selected inter-intra prediction, selectable compound blending, OBMC, scaled-reference reconstruction, local warped prediction, non-translational global prediction, official motion-vector conformance, official spatial- and temporal-layer default-operating-point conformance, official active-film-grain and monochrome sequence conformance, selected spatial-layer presentation, and progressive color and auxiliary-alpha conformance. This dashboard is the authoritative delivery order. The detailed phase checklists below provide subsystem evidence; they do not override the current-stage marker or permit work to skip ahead.
Commit `1c58d855f70b024170ced9eb0a7005f0f9c955ad` records the complete official motion-vector conformance checkpoint. The official IVF has SHA-1 `F064290D7FCD3B3DE19020E8AEC6C43C88D3A505`, matching the pinned libaom test-data manifest, and SHA-256 `222A9050059B254DAB17CFB802FF829C778E3F93AF18961A622C8268576C1395`; its pinned-libaom Y4M has SHA-256 `D97AC78C81782CF1507549368047769DC677DBE205706458D1EE9C807DE6EC78`. Both source targets build with zero warnings and errors, the `net10.0` test-project analyzer build completes with zero errors and 1,014 pre-existing repository warnings, Roslynk reports zero compiler errors, 3,985 focused `net10.0` cases pass without failures or skips, and `git diff --check` is clean.
@ -59,6 +59,8 @@ Commit `fc9320262cc08dd5daf41f231998403b804b98da` closes the tile, mode, segment
Commit `42384454eb45b6107608ed33379c7a69b101d533` closes the AV1 intra-prediction checkpoint. Pinned-source review confirms conventional mode and angle syntax, palette and filter-intra eligibility and ordering, chroma-from-luma eligibility and alpha mapping, reference availability, edge preparation, and predictor dispatch. Every predictor family retains the JPEG-style static operator architecture. All 93 focused cases pass without failures or skips, including the exact 39-frame official all-intra native sequence, exact palette native and presentation fixtures, and the exact 12-profile matrix. The existing production implementation required no correction.
Commit `6b3a5a5e1849de7881b929f46a5744fa3efe3fd6` closes the AV1 inter-frame prediction parent. Every completed reference-state, syntax, motion-derivation, translational, compound, inter-intra, OBMC, scaled, local-warp, global-warp, layered-presentation, film-grain, and monochrome child remains connected to the production path. All 342 focused inter-frame cases pass without failures or skips, including exact independent native-plane and presentation comparisons, normal and scalar dispatch, constrained allocation, and exactly-once ownership evidence. The existing production implementation required no correction.
Status meanings:
- **Complete:** the implementation and its phase exit evidence are recorded.
@ -129,6 +131,7 @@ Immediate checkpoint: **remaining — close the Phase 3 AV1 still-image decode e
- [x] Correct the audited 12-bit inverse ADST4, Identity4, and Identity16 SIMD arithmetic by widening only the libaom-widened multiply/accumulate operations, with exact conformant-range vectors and `FeatureTestRunner` coverage. Both 128-bit and 256-bit operators match pinned outputs through every required hardware fallback; 510 focused inverse-transform cases, 44 production reconstruction cases, both zero-warning source builds, the zero-error analyzer build, zero Roslynk compiler errors, and clean `git diff --check` complete the verification.
- [x] Verify the official libaom all-intra, CDF-update, and temporal motion-field sequences through exact native output, selected syntax coverage, normal/scalar dispatch, constrained tracked allocation, and the family-owned JPEG-style predictor operator architecture.
- [ ] **Current:** continue inventorying and removing every remaining valid AV1 still-image unsupported branch, adding exact independent compression-tool fixtures to the profile-matrix regression gate.
- [x] Add the missing official ten-bit sequence evidence from libaom's pinned test-data manifest. All ten active-film-grain YUV420 frames and all ten monochrome frames match the pinned generic libaom native Y4M samples exactly under normal and scalar `FeatureTestRunner` dispatch, and both complete sequences pass through a 2 KiB constrained tracked allocator with balanced exactly-once returns. The existing production decoder required no correction.
- [ ] Complete the remaining HEVC still-image profile and Range Extensions matrix with exact independent native-plane and presentation evidence.
- [ ] Close shared decoded presentation, ICC, alpha, grid, transform, metadata, and animated AV1/HEVC decode gates.
- [ ] Implement and independently verify real AV1/AVIF still encoding.
@ -627,7 +630,7 @@ Implement and verify in dependency order:
- [x] Decode the official two-spatial-layer, two-temporal-layer L2T2 sequence at its default operating point. The 119,907-byte IVF has manifest-matching SHA-1 `32EF2F14EE9CB11A24A22934F4C065E926E5D236` and SHA-256 `14257D5FD3901581DBEB88133378CD79D50EA32506ADB729909AB56B4A52AF3C`; its pinned-libaom Y4M has SHA-256 `1ABB981CFF76BA9557DA437B258D8A95FCA755DED8E3949D857E8388AB1D6AE3`. All eight 1280x720 YUV420 frames match exactly under normal/scalar dispatch, and an 8 KiB constrained tracked allocator verifies balanced exactly-once returns. The existing decoder required no production correction. The scoped test-project analyzer build completes with zero errors and 1,011 repository warnings, Roslynk reports zero compiler errors, and both focused cases pass without failures or skips.
- [x] Decode the official ten-frame active-film-grain sequence. The 28,634-byte IVF has manifest-matching SHA-1 `11BB40026103182C23A88133EDAFCA369E5575E2` and SHA-256 `BA3EDD82A58414F009E1C821B947EC8DE4E0420F33803CA7BFEA39AF6AEEA155`; its pinned-libaom grained Y4M has SHA-256 `C71958DE496A949D12E819190F240BD56010E5AD57D8A0D55903BF380A9E0C26`, while pinned libaom's skip-grain output differs with SHA-256 `9E0762A82E582E854AFF2DC61EBA1E48C0F1D41BBC21E5C896573DA3BB2F1200`. All ten displayed 352x288 YUV420 frames match exactly under normal/scalar dispatch; active synthesis, dependent retained-reference reconstruction, and 2 KiB constrained tracked allocation with exactly-once returns pass. The fixture corrected the AV1 default loop-filter reference deltas from a swapped Golden/Backward pair to the normative `[1, 0, 0, 0, -1, 0, -1, -1]` order. Both Release source targets build with zero warnings and errors, the scoped test-project analyzer build completes with zero errors and 1,011 repository warnings, Roslynk reports zero compiler errors, 28 focused cases pass without failures or skips, documentation review is complete, and `git diff --check` is clean. Commit `15613b01c0bc098fd9926b886216558e0d26eff9` records the checkpoint.
- [x] Decode the official eight-bit monochrome sequence. The 10,000-byte IVF has manifest-matching SHA-1 `A17584012187CD886B64F8CB0F35BFD8D762F9DC` and SHA-256 `3DCC2A3C181F74788BD9575D94F0862D9E914415AC358A4DA4ED7D904F0535B7`; its ten-frame 576,000-byte pinned-libaom luma reference has SHA-256 `6A4F8A68366E801D60A14C00BE6EA88A861B1B631D86DEF8A8DB65EFB6B06FA8`. All ten displayed 320x180 native YUV400 frames match exactly under normal/scalar dispatch, the shared compact-sequence oracle keeps every prior YUV420 fixture exact, and a 2 KiB constrained tracked allocator verifies balanced exactly-once returns. The existing decoder required no production correction. Both Release source targets build with zero warnings and errors, the scoped test-project analyzer build completes with zero errors and 1,011 repository warnings, Roslynk reports zero compiler errors, all 17 official-sequence cases pass without failures or skips, documentation review is complete, and `git diff --check` is clean. Commit `da9a46b3d72fd682ea9293af3f88fde26defb222` records the checkpoint.
- [x] Reconcile every completed inter-frame child with the current production path and pinned libaom `03087864cf4bea6abb0d28f95cf7843511413d8f`. The connected syntax, reference-state, motion-derivation, translational, compound, inter-intra, OBMC, scaled, local-warp, global-warp, layered-presentation, film-grain, and monochrome paths contain no remaining explicit unsupported branch. Both Release source targets build with zero warnings and errors, the scoped test-project analyzer build completes with zero errors and 1,011 repository warnings, Roslynk reports zero compiler errors, and all 342 focused inter-frame cases pass without failures or skips. The existing production implementation required no correction.
- [x] Reconcile every completed inter-frame child with the current production path and pinned libaom `03087864cf4bea6abb0d28f95cf7843511413d8f`. The connected syntax, reference-state, motion-derivation, translational, compound, inter-intra, OBMC, scaled, local-warp, global-warp, layered-presentation, film-grain, and monochrome paths contain no remaining explicit unsupported branch. Both Release source targets build with zero warnings and errors, the scoped test-project analyzer build completes with zero errors and 1,011 repository warnings, Roslynk reports zero compiler errors, and all 342 focused inter-frame cases pass without failures or skips. The existing production implementation required no correction. Commit `6b3a5a5e1849de7881b929f46a5744fa3efe3fd6` records the checkpoint.
- [x] Lossless and high-bit-depth reconstruction with correct clipping and intermediate precision.
- [x] Route lossless 4x4 blocks through allocation-free reversible inverse Walsh-Hadamard reconstruction for 8/10/12-bit samples, including the DC-only specialization, `Vector128` production traversal, scalar fallback, exact clipping, and `FeatureTestRunner` parity.
- [x] Verify lossless syntax, inverse quantization, prediction, and presented reconstruction with independently encoded 8/10/12-bit AVIF fixtures. The tests require coded residuals with palette and intra-block copy disabled, compare every native YUV sample with the pinned generic libaom-backed decoder, and compare every presented RGBA byte with pinned generic libavif exactly under normal hardware dispatch and the scalar fallback.

131
tests/ImageSharp.Tests/Formats/Heif/Av1/Av1ReconstructionConformanceTests.cs

@ -1490,6 +1490,33 @@ public class Av1ReconstructionConformanceTests
Assert.NotEqual(0, coverage & FilmGrainCoverage);
}
/// <summary>
/// Verifies the official ten-bit film-grain sequence against exact pinned-libaom native output.
/// </summary>
[Fact]
public void DecodeOfficialTenBitFilmGrainSequenceMatchesPinnedLibaomReference()
=> FeatureTestRunner.RunWithHwIntrinsicsFeature(
ValidateOfficialTenBitFilmGrainFixture,
ReconstructionConfigurations);
/// <summary>
/// Decodes the official ten-bit film-grain sequence and verifies that synthesis is active.
/// </summary>
private static void ValidateOfficialTenBitFilmGrainFixture()
{
int coverage = ValidateOfficialCompactSequence(
Configuration.Default,
TestImages.Heif.Av1OfficialTenBitFilmGrainSequence,
TestImages.Heif.Av1OfficialTenBitFilmGrainSequenceNativeReference,
OfficialFilmGrainFixtureFrameCount,
OfficialMotionVectorFixtureWidth,
OfficialMotionVectorFixtureHeight,
Av1ColorFormat.Yuv420,
Av1BitDepth.TenBit);
Assert.NotEqual(0, coverage & FilmGrainCoverage);
}
/// <summary>
/// Verifies the official eight-bit monochrome sequence against exact pinned-libaom native output under normal and
/// scalar dispatch.
@ -1542,6 +1569,70 @@ public class Av1ReconstructionConformanceTests
OfficialMonochromeFixtureHeight,
Av1ColorFormat.Yuv400);
/// <summary>
/// Verifies the official ten-bit monochrome sequence against exact pinned-libaom native output.
/// </summary>
[Fact]
public void DecodeOfficialTenBitMonochromeSequenceMatchesPinnedLibaomReference()
=> FeatureTestRunner.RunWithHwIntrinsicsFeature(
ValidateOfficialTenBitMonochromeFixture,
ReconstructionConfigurations);
/// <summary>
/// Decodes the official ten-bit monochrome sequence.
/// </summary>
private static void ValidateOfficialTenBitMonochromeFixture()
=> ValidateOfficialCompactSequence(
Configuration.Default,
TestImages.Heif.Av1OfficialTenBitMonochromeSequence,
TestImages.Heif.Av1OfficialTenBitMonochromeSequenceNativeReference,
OfficialMonochromeFixtureFrameCount,
OfficialMonochromeFixtureWidth,
OfficialMonochromeFixtureHeight,
Av1ColorFormat.Yuv400,
Av1BitDepth.TenBit);
/// <summary>
/// Verifies both official ten-bit sequences through constrained tracked allocation.
/// </summary>
[Fact]
[ValidateDisposedMemoryAllocations]
public void DecodeOfficialTenBitSequencesWithConstrainedAllocator()
{
TestMemoryAllocator allocator = new() { BufferCapacityInBytes = 2_048 };
allocator.EnableNonThreadSafeLogging();
Configuration configuration = Configuration.Default.Clone();
configuration.MemoryAllocator = allocator;
int filmGrainCoverage = ValidateOfficialCompactSequence(
configuration,
TestImages.Heif.Av1OfficialTenBitFilmGrainSequence,
TestImages.Heif.Av1OfficialTenBitFilmGrainSequenceNativeReference,
OfficialFilmGrainFixtureFrameCount,
OfficialMotionVectorFixtureWidth,
OfficialMotionVectorFixtureHeight,
Av1ColorFormat.Yuv420,
Av1BitDepth.TenBit);
ValidateOfficialCompactSequence(
configuration,
TestImages.Heif.Av1OfficialTenBitMonochromeSequence,
TestImages.Heif.Av1OfficialTenBitMonochromeSequenceNativeReference,
OfficialMonochromeFixtureFrameCount,
OfficialMonochromeFixtureWidth,
OfficialMonochromeFixtureHeight,
Av1ColorFormat.Yuv400,
Av1BitDepth.TenBit);
Assert.NotEqual(0, filmGrainCoverage & FilmGrainCoverage);
Assert.Equal(allocator.AllocationLog.Count, allocator.ReturnLog.Count);
Assert.All(
allocator.AllocationLog,
allocation => Assert.Single(
allocator.ReturnLog,
returned => returned.AllocationId == allocation.AllocationId));
}
/// <summary>
/// Decodes one compact official IVF sequence, compares every native sample, and returns its active frame-state
/// coverage mask.
@ -1553,13 +1644,34 @@ public class Av1ReconstructionConformanceTests
int expectedFrameCount,
int expectedWidth = OfficialMotionVectorFixtureWidth,
int expectedHeight = OfficialMotionVectorFixtureHeight,
Av1ColorFormat expectedColorFormat = Av1ColorFormat.Yuv420)
Av1ColorFormat expectedColorFormat = Av1ColorFormat.Yuv420,
Av1BitDepth expectedBitDepth = Av1BitDepth.EightBit)
{
byte[] ivf = TestFile.Create(fixturePath).Bytes;
byte[] nativeReference = TestFile.Create(nativeReferencePath).Bytes;
bool hasY4mHeaders = expectedColorFormat != Av1ColorFormat.Yuv400;
bool hasY4mHeaders = nativeReference.AsSpan().StartsWith("YUV4MPEG2 "u8);
int bitDepth = expectedBitDepth switch
{
Av1BitDepth.EightBit => 8,
Av1BitDepth.TenBit => 10,
Av1BitDepth.TwelveBit => 12,
_ => throw new InvalidOperationException("The compact official sequence oracle requires a valid AV1 bit depth.")
};
string y4mColorSpace = expectedColorFormat switch
{
Av1ColorFormat.Yuv400 => expectedBitDepth == Av1BitDepth.EightBit
? "Cmono"
: $"Cmono{bitDepth}",
Av1ColorFormat.Yuv420 => expectedBitDepth == Av1BitDepth.EightBit
? "C420jpeg"
: $"C420p{bitDepth} XYSCSS=420P{bitDepth}",
_ => throw new InvalidOperationException("The compact official sequence oracle supports YUV400 and YUV420 references.")
};
ReadOnlySpan<byte> y4mFileHeader = hasY4mHeaders
? Encoding.ASCII.GetBytes($"YUV4MPEG2 W{expectedWidth} H{expectedHeight} F30:1 Ip C420jpeg\n")
? Encoding.ASCII.GetBytes(
$"YUV4MPEG2 W{expectedWidth} H{expectedHeight} F30:1 Ip {y4mColorSpace}\n")
: [];
ReadOnlySpan<byte> y4mFrameHeader = "FRAME\n"u8;
@ -1574,16 +1686,16 @@ public class Av1ReconstructionConformanceTests
expectedFrameCount,
checked((int)BinaryPrimitives.ReadUInt32LittleEndian(ivf.AsSpan(24, 4))));
if (hasY4mHeaders)
{
Assert.True(nativeReference.AsSpan().StartsWith(y4mFileHeader));
}
Assert.True(nativeReference.AsSpan().StartsWith(y4mFileHeader));
int ivfOffset = 32;
int nativeOffset = y4mFileHeader.Length;
int nativeFrameLength = expectedColorFormat == Av1ColorFormat.Yuv400
int nativeSampleCount = expectedColorFormat == Av1ColorFormat.Yuv400
? expectedWidth * expectedHeight
: (expectedWidth * expectedHeight) + (2 * (expectedWidth >> 1) * (expectedHeight >> 1));
: (expectedWidth * expectedHeight) +
(2 * GetSubsampledSize(expectedWidth, 1) * GetSubsampledSize(expectedHeight, 1));
int nativeFrameLength = nativeSampleCount * (expectedBitDepth == Av1BitDepth.EightBit ? 1 : sizeof(ushort));
int coverage = 0;
using Av1Decoder decoder = new(configuration);
@ -1606,6 +1718,7 @@ public class Av1ReconstructionConformanceTests
}
Av1FrameBuffer<byte> frameBuffer = Assert.IsType<Av1FrameBuffer<byte>>(decoder.FrameBuffer);
Assert.Equal(expectedBitDepth, frameBuffer.BitDepth);
Assert.Equal(expectedColorFormat, frameBuffer.ColorFormat);
AssertNativePlanesEqual(
decoder,

4
tests/ImageSharp.Tests/TestImages.cs

@ -1406,8 +1406,12 @@ public static class TestImages
public const string Av1OfficialSpatialTemporalLayerSequenceNativeReference = "Heif/Av1/Conformance/libaom-av1-1-b8-22-svc-L2T2-libaom.y4m";
public const string Av1OfficialFilmGrainSequence = "Heif/Av1/Conformance/libaom-av1-1-b8-23-film-grain-50.ivf";
public const string Av1OfficialFilmGrainSequenceNativeReference = "Heif/Av1/Conformance/libaom-av1-1-b8-23-film-grain-50-libaom.y4m";
public const string Av1OfficialTenBitFilmGrainSequence = "Heif/Av1/Conformance/libaom-av1-1-b10-23-film-grain-50.ivf";
public const string Av1OfficialTenBitFilmGrainSequenceNativeReference = "Heif/Av1/Conformance/libaom-av1-1-b10-23-film-grain-50-libaom.y4m";
public const string Av1OfficialMonochromeSequence = "Heif/Av1/Conformance/libaom-av1-1-b8-24-monochrome.ivf";
public const string Av1OfficialMonochromeSequenceNativeReference = "Heif/Av1/Conformance/libaom-av1-1-b8-24-monochrome-libaom.yuv";
public const string Av1OfficialTenBitMonochromeSequence = "Heif/Av1/Conformance/libaom-av1-1-b10-24-monochrome.ivf";
public const string Av1OfficialTenBitMonochromeSequenceNativeReference = "Heif/Av1/Conformance/libaom-av1-1-b10-24-monochrome-libaom.y4m";
public const string Av1Cdef8BitPayload = "Heif/Av1/Conformance/libaom-cdef-kodim23-8b.bit";
public const string Av1Cdef8BitReference = "Heif/Av1/Conformance/libaom-cdef-kodim23-8b-libaom.yuv";
public const string Av1Cdef8BitAvif = "Heif/Av1/Conformance/libavif-cdef-kodim23-8b.avif";

16
tests/Images/Input/Heif/Av1/Conformance/README.md

@ -19,7 +19,7 @@ The reference builds use `AOM_TARGET_CPU=generic` and disable libyuv. Native rec
- `.bit` files contain the exact AV1 elementary-stream payload used by reconstruction tests.
- `-libaom.yuv` files contain headerless planar Y, U, and V reference samples. Samples above eight bits are stored as little-endian 16-bit values.
- `-libaom-y4m.yuv` files retain the Y4M header together with the native planar frame.
- `-libaom.y4m` files retain the Y4M header together with the selected native sequence frame.
- `-libaom.y4m` files retain the Y4M header together with the native sequence frames selected for comparison.
- `.png` files contain the eight-bit RGBA presentation reference produced by the pinned scalar libavif build.
## Coverage
@ -36,6 +36,7 @@ The reference builds use `AOM_TARGET_CPU=generic` and disable libyuv. Native rec
| `*-intrabc-*` | Intra-block copy at every supported bit depth |
| `*-lossless-*` | Lossless quantization, reversible transforms, and exact presentation |
| `*-film-grain-*` | Full and restricted range, monochrome, identity matrix, 8/10/12-bit synthesis, overlap, and odd frame dimensions |
| `libaom-av1-1-b10-23`, `libaom-av1-1-b10-24` | Official ten-bit dependent-frame film grain and monochrome sequence reconstruction |
| `libavif-progressive-draw-points-8b` | A real two-layer color item whose final frame uses single-reference inter reconstruction, plus its progressive auxiliary alpha item |
| `libavif-webp-logo-average-compound` | A 19-frame YUV444 image sequence whose retained references reach equal-weight compound inter reconstruction |
| `libavif-webp-logo-distance-weighted-compound` | Selectable distance-weighted compound prediction |
@ -48,6 +49,19 @@ The reference builds use `AOM_TARGET_CPU=generic` and disable libyuv. Native rec
The corresponding tests also assert the syntax required by each family before comparing output. This prevents an inactive tool or an incorrectly substituted stream from passing solely because its final pixels happen to match.
## Official ten-bit sequence fixtures
The `libaom-av1-1-b10-23-film-grain-50.ivf` and `libaom-av1-1-b10-24-monochrome.ivf` streams are the official files from libaom's test-data bucket. Their SHA-1 values are `2F883C7E11C21A31F79BD9C809541BE90B0C7C4A` and `03A8D002594CCC51932332002BB6F9837EF46D0F`, exactly matching `test/test-data.sha1` at pinned libaom commit `03087864cf4bea6abb0d28f95cf7843511413d8f`. Their SHA-256 values are `C36CF5AB6A2E9E27C212C06863759B60791E3FA681A0800B5D57FD4192EF29CB` and `6A1B0729305A167F10737A5375F0570139F055BCD7916DF260B653AB2210ADC1`.
The retained native references were generated from the pinned generic libaom build with:
```text
aomdec --threads=1 --output=libaom-av1-1-b10-23-film-grain-50-libaom.y4m libaom-av1-1-b10-23-film-grain-50.ivf
aomdec --threads=1 --output=libaom-av1-1-b10-24-monochrome-libaom.y4m libaom-av1-1-b10-24-monochrome.ivf
```
The film-grain Y4M SHA-256 is `A1B553BE140F48ABDDB2A6D39917AB714BA03AC7FFD6359EAA1CB0D89C985A3B`, and the monochrome Y4M SHA-256 is `7394BC8146485D200BFDEC62E170482F8B1A85A64D21FAC62D10116FB1BB140D`. The tests decode and compare all ten frames from each sequence exactly under normal and scalar dispatch. The film-grain stream retains dependent ungrained references while applying ten-bit grain to each displayed 352x288 YUV420 frame; the monochrome stream verifies every 320x180 ten-bit luma sample without manufacturing chroma in ImageSharp. Both sequences also run through a constrained tracked allocator.
## Progressive dependent-frame fixture
The `libavif-progressive-draw-points-8b.avif` fixture is the unmodified `tests/data/draw_points_idat_progressive.avif` file from the pinned libavif tree. Its SHA-256 is `077AB2AD1E46DD912A973E4F024CB1EB242A08298BE2DBF1A52A058E88C48A4A`. It was generated with:

3
tests/Images/Input/Heif/Av1/Conformance/libaom-av1-1-b10-23-film-grain-50-libaom.y4m

@ -0,0 +1,3 @@
version https://git-lfs.github.com/spec/v1
oid sha256:a1b553be140f48abddb2a6d39917ab714ba03ac7ffd6359eaa1cb0d89c985a3b
size 3041391

3
tests/Images/Input/Heif/Av1/Conformance/libaom-av1-1-b10-23-film-grain-50.ivf

@ -0,0 +1,3 @@
version https://git-lfs.github.com/spec/v1
oid sha256:c36cf5ab6a2e9e27c212c06863759b60791e3fa681a0800b5d57fd4192ef29cb
size 28906

3
tests/Images/Input/Heif/Av1/Conformance/libaom-av1-1-b10-24-monochrome-libaom.y4m

@ -0,0 +1,3 @@
version https://git-lfs.github.com/spec/v1
oid sha256:7394bc8146485d200bfdec62e170482f8b1a85a64d21fac62d10116fb1bb140d
size 1152097

3
tests/Images/Input/Heif/Av1/Conformance/libaom-av1-1-b10-24-monochrome.ivf

@ -0,0 +1,3 @@
version https://git-lfs.github.com/spec/v1
oid sha256:6a1b0729305a167f10737a5375f0570139f055bcd7916df260b653ab2210adc1
size 16044
Loading…
Cancel
Save