diff --git a/HEIF_IMPLEMENTATION_PLAN.md b/HEIF_IMPLEMENTATION_PLAN.md index 66b6bef81e..08f150746f 100644 --- a/HEIF_IMPLEMENTATION_PLAN.md +++ b/HEIF_IMPLEMENTATION_PLAN.md @@ -351,7 +351,7 @@ This assessment was reconciled with the source tree on 2026-08-26. Unless a resu - The single-still `Av1Decoder` path now parses tile state before allocating and reconstructing one independently decodable frame, and it disposes the reconstruction planes after pixel conversion. It deliberately does not retain animation/video reference frames or implement `show_existing_frame` playback state. - Transform coefficient entropy derivation and updates now address the above contexts relative to the tile column and the left contexts relative to the current superblock row, preserve luma coordinates independently of chroma subsampling, and test every packed context entry for the libaom any-nonzero rule. Extended vertical partition updates advance the mode-information column rather than the row. The existing multi-superblock 4:4:4 AVIF fixture now completes tile parsing; independent coefficient-context vectors across tile boundaries, chroma layouts, bit depths, and edge-clipped transforms remain required. -- The reconstruction pipeline now records plane-relative transform geometry, preserves tile-local delta-Q and delta-LF predictors, derives segmentation and reference-adjusted filter levels, and runs the exact AV1 4-, 6-, 8-, and 14-tap deblocking kernels in normative vertical-then-horizontal order. Deblocking uses the same closed edge-operator architecture as the HEVC filter, with operators specialized by sample storage and orientation, `Vector128` lanes representing the four rows or columns along an edge, and an allocation-free scalar fallback for disabled intrinsics. It then applies scalar CDEF direction search, luma variance adjustment, primary and secondary constrained taps, chroma direction conversion, high-bit-depth scaling, skipped-block selection, and frame-edge sentinel handling from immutable per-plane snapshots. Active super-resolution derives the Appendix A bounded coded width and applies the exact 64-phase, 8-tap horizontal filter with aligned reconstruction-edge input, 8/10/12-bit clipping, and the existing cross-platform `Vector128_.MultiplyAddAdjacent` helper. Loop restoration follows super-resolution, preserves the required pre-CDEF deblocked context at internal stripes, and applies decoded Wiener or self-guided units from immutable plane snapshots. The visible still-image path then applies the complete self-contained film-grain parameter set after all in-loop filters. Independent 8-, 10-, and 12-bit AVIF vectors exercising every active filter and grain stage remain required before these paths have external pixel-level verification. +- The reconstruction pipeline now records plane-relative transform geometry, preserves tile-local delta-Q and delta-LF predictors, derives segmentation and reference-adjusted filter levels, and runs the exact AV1 4-, 6-, 8-, and 14-tap deblocking kernels in normative vertical-then-horizontal order. Deblocking uses the same closed edge-operator architecture as the HEVC filter, with operators specialized by sample storage and orientation, `Vector128` lanes representing the four rows or columns along an edge, and an allocation-free scalar fallback for disabled intrinsics. Exact native-plane comparison with pinned scalar libaom output now verifies active deblocking and complete reconstruction for real 8-bit 4:2:0, 10-bit 4:4:4, and 12-bit 4:4:4 content; genuine AVIF containers separately verify presentation and public bit-depth metadata. The pipeline then applies scalar CDEF direction search, luma variance adjustment, primary and secondary constrained taps, chroma direction conversion, high-bit-depth scaling, skipped-block selection, and frame-edge sentinel handling from immutable per-plane snapshots. Active super-resolution derives the Appendix A bounded coded width and applies the exact 64-phase, 8-tap horizontal filter with aligned reconstruction-edge input, 8/10/12-bit clipping, and the existing cross-platform `Vector128_.MultiplyAddAdjacent` helper. Loop restoration follows super-resolution, preserves the required pre-CDEF deblocked context at internal stripes, and applies decoded Wiener or self-guided units from immutable plane snapshots. The visible still-image path then applies the complete self-contained film-grain parameter set after all in-loop filters. Independent 8-, 10-, and 12-bit vectors exercising CDEF, super-resolution, restoration, and grain remain required before those stages have external pixel-level verification. - Palette mode now reads the normative luma/chroma mode and size CDFs, neighbor color caches, high-bit-depth color syntax, diagonal color-index maps, and clipped-edge padding. Reconstruction retains libaom's exact indexed-palette contract while using repeated eight-entry tables and native lane-local shuffles across runtime-selected `Vector512`, `Vector256`, and `Vector128` paths before an exact scalar fallback. `FeatureTestRunner` verifies palette sizes 2-8, transform widths 4-64, padded rows, and 8/10/12-bit samples. This path is not production-complete until its syntax and reconstruction are verified with an independently encoded palette AVIF fixture. - Non-reduced still-image sequence parsing now consumes decoder-model operating parameters, temporal presentation fields, and OBU-layer-applicable buffer-removal fields only to preserve AV1 bit alignment. The scheduling values are not retained, and no movie, track, timing, playback, or generic ISO BMFF surface has been introduced. Existing focused sequence-header coverage exercises only reduced-still syntax, so an independent non-reduced still AVIF vector remains required. - Loop-restoration unit parsing records tile-local switchable/Wiener/self-guided filter selections and coefficients in frame-owned plane grids, including super-resolution-adjusted unit corners and the corrected conditional 64x64-superblock unit-size bit. The active restoration stage implements the normative unit geometry, striped deblocked boundaries, Wiener filtering, self-guided projection, and 8/10/12-bit clipping, while reusing the existing SIMD-backed super-resolution and adjacent multiply/add primitives. Independently encoded fixtures covering every parameter set, plane layout, bit depth, and frame-edge geometry are still required. Other normative independently decodable still-image syntax paths still contain `NotImplementedException` or equivalent unsupported branches. Tile-local palette CDF adaptation is present; the remaining still-image frame-context behavior requires a separate source audit without introducing sequence playback state. @@ -501,9 +501,9 @@ Implement and verify in dependency order: - [ ] 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. - [ ] Verify lossless syntax, inverse quantization, prediction, and presented reconstruction with independently encoded 8/10/12-bit AVIF fixtures. -- [ ] Deblocking loop filter. +- [x] Deblocking loop filter. - [x] Implement allocation-free SIMD-first 4-, 6-, 8-, and 14-tap filtering for vertical and horizontal edges in 8/10/12-bit storage through closed edge operators, with exact scalar fallback and `FeatureTestRunner` parity against an independent definition. - - [ ] Verify deblocking syntax, filter-level derivation, boundary traversal, and presented reconstruction with independently encoded 8/10/12-bit AVIF fixtures. + - [x] Verify deblocking syntax, filter-level derivation, and boundary traversal with independently encoded 8/10/12-bit AV1 samples and exact scalar-libaom planes; verify presented reconstruction and public precision with genuine AVIF containers at every supported bit depth. - [ ] CDEF. - [ ] Super-resolution scaling. - [ ] Loop restoration. diff --git a/src/ImageSharp/Formats/Heif/Av1/Av1Decoder.cs b/src/ImageSharp/Formats/Heif/Av1/Av1Decoder.cs index bf75d19cd0..aeb74c07cc 100644 --- a/src/ImageSharp/Formats/Heif/Av1/Av1Decoder.cs +++ b/src/ImageSharp/Formats/Heif/Av1/Av1Decoder.cs @@ -195,7 +195,7 @@ internal sealed class Av1Decoder : IAv1TileReader, IDisposable /// The AV1 codec configuration validated against the coded sequence header. /// Receives the effective CICP description associated with the native planes. /// The reconstructed native frame buffer. Ownership transfers to the caller. - private Av1FrameBuffer DecodeFrameBuffer( + public Av1FrameBuffer DecodeFrameBuffer( Span buffer, CicpProfile? containerColorProfile, Av1CodecConfiguration? codecConfiguration, diff --git a/tests/ImageSharp.Tests/Formats/Heif/Av1/Av1DeblockingConformanceTests.cs b/tests/ImageSharp.Tests/Formats/Heif/Av1/Av1DeblockingConformanceTests.cs new file mode 100644 index 0000000000..f1e251c4b2 --- /dev/null +++ b/tests/ImageSharp.Tests/Formats/Heif/Av1/Av1DeblockingConformanceTests.cs @@ -0,0 +1,221 @@ +// Copyright (c) Six Labors. +// Licensed under the Six Labors Split License. + +using System.Buffers.Binary; +using SixLabors.ImageSharp.Formats; +using SixLabors.ImageSharp.Formats.Heif; +using SixLabors.ImageSharp.Formats.Heif.Av1; +using SixLabors.ImageSharp.Formats.Heif.Av1.OpenBitstreamUnit; +using SixLabors.ImageSharp.Memory; +using SixLabors.ImageSharp.PixelFormats; + +namespace SixLabors.ImageSharp.Tests.Formats.Heif.Av1; + +/// +/// Validates complete AV1 reconstruction against independently decoded native component planes. +/// +[Trait("Format", "Avif")] +public class Av1DeblockingConformanceTests +{ + /// + /// Verifies deblocking syntax, filter activation, component traversal, and presentation for real eight-, ten-, + /// and twelve-bit AV1 and AVIF content. + /// + [Fact] + public void DecodeMatchesPinnedLibaomReference() + { + ValidateFixture( + TestImages.Heif.Av1Deblocking8BitAvif, + TestImages.Heif.Av1Deblocking8BitPayload, + TestImages.Heif.Av1Deblocking8BitReference, + 768, + 512, + Av1BitDepth.EightBit, + Av1ColorFormat.Yuv420, + HeifBitDepth.Bit8); + + ValidateFixture( + TestImages.Heif.Av1Deblocking10BitAvif, + TestImages.Heif.Av1Deblocking10BitPayload, + TestImages.Heif.Av1Deblocking10BitReference, + 1024, + 428, + Av1BitDepth.TenBit, + Av1ColorFormat.Yuv444, + HeifBitDepth.Bit10); + + ValidateNativeFixture( + TestImages.Heif.Av1Deblocking12BitPayload, + TestImages.Heif.Av1Deblocking12BitReference, + 1024, + 428, + Av1BitDepth.TwelveBit, + Av1ColorFormat.Yuv444); + + ValidatePresentedImage(TestImages.Heif.Av1Deblocking12BitAvif, 64, 64, HeifBitDepth.Bit12); + } + + /// + /// Validates one elementary-stream sample and its containing AVIF image. + /// + /// The complete AVIF container. + /// The AV1 elementary-stream sample extracted from the container. + /// The native planar output produced by the pinned libaom decoder. + /// The expected displayed width. + /// The expected displayed height. + /// The expected AV1 sample precision. + /// The expected native chroma-sampling layout. + /// The expected public HEIF sample precision. + private static void ValidateFixture( + string imagePath, + string payloadPath, + string referencePath, + int width, + int height, + Av1BitDepth bitDepth, + Av1ColorFormat colorFormat, + HeifBitDepth metadataBitDepth) + { + ValidateNativeFixture(payloadPath, referencePath, width, height, bitDepth, colorFormat); + ValidatePresentedImage(imagePath, width, height, metadataBitDepth); + } + + /// + /// Validates complete native-plane reconstruction for one AV1 elementary-stream sample. + /// + /// The AV1 elementary-stream sample. + /// The native planar output produced by the pinned libaom decoder. + /// The expected reconstructed width. + /// The expected reconstructed height. + /// The expected AV1 sample precision. + /// The expected native chroma-sampling layout. + private static void ValidateNativeFixture( + string payloadPath, + string referencePath, + int width, + int height, + Av1BitDepth bitDepth, + Av1ColorFormat colorFormat) + { + byte[] payload = TestFile.Create(payloadPath).Bytes; + byte[] reference = TestFile.Create(referencePath).Bytes; + using Av1Decoder decoder = new(Configuration.Default); + using Av1FrameBuffer frameBuffer = decoder.DecodeFrameBuffer(payload, null, null, out _); + + Assert.Equal(width, frameBuffer.Width); + Assert.Equal(height, frameBuffer.Height); + Assert.Equal(bitDepth, frameBuffer.BitDepth); + Assert.Equal(colorFormat, frameBuffer.ColorFormat); + Assert.NotNull(decoder.FrameHeader); + ObuLoopFilterParameters filterParameters = decoder.FrameHeader.LoopFilterParameters; + Assert.True( + filterParameters.FilterLevel[0] != 0 + || filterParameters.FilterLevel[1] != 0 + || filterParameters.FilterLevelU != 0 + || filterParameters.FilterLevelV != 0); + + AssertNativePlanesEqual(frameBuffer, reference); + } + + /// + /// Validates the public presentation and metadata produced from one complete AVIF container. + /// + /// The complete AVIF container. + /// The expected displayed width. + /// The expected displayed height. + /// The expected public HEIF sample precision. + private static void ValidatePresentedImage(string imagePath, int width, int height, HeifBitDepth metadataBitDepth) + { + DecoderOptions options = new() { MaxFrames = 1 }; + byte[] imageBytes = TestFile.Create(imagePath).Bytes; + using Image image = Image.Load(options, imageBytes); + + Assert.Equal(width, image.Width); + Assert.Equal(height, image.Height); + Assert.Single(image.Frames); + HeifMetadata metadata = image.Metadata.GetHeifMetadata(); + Assert.Equal(HeifCompressionMethod.Av1, metadata.CompressionMethod); + Assert.Equal(metadataBitDepth, metadata.BitDepth); + } + + /// + /// Compares every visible native component sample with the independent planar reference. + /// + /// The reconstructed AV1 component planes. + /// The planar Y, U, and V samples produced by the pinned libaom decoder. + private static void AssertNativePlanesEqual(Av1FrameBuffer frameBuffer, ReadOnlySpan reference) + { + (int chromaSubsamplingX, int chromaSubsamplingY) = frameBuffer.ColorFormat switch + { + Av1ColorFormat.Yuv420 => (1, 1), + Av1ColorFormat.Yuv422 => (1, 0), + _ => (0, 0) + }; + + int referenceOffset = 0; + foreach (Av1Plane plane in new[] { Av1Plane.Y, Av1Plane.U, Av1Plane.V }) + { + int subsamplingX = plane == Av1Plane.Y ? 0 : chromaSubsamplingX; + int subsamplingY = plane == Av1Plane.Y ? 0 : chromaSubsamplingY; + int planeWidth = GetSubsampledSize(frameBuffer.Width, subsamplingX); + int planeHeight = GetSubsampledSize(frameBuffer.Height, subsamplingY); + + if (frameBuffer.BitDepth == Av1BitDepth.EightBit) + { + Buffer2DRegion actualPlane = frameBuffer.DeriveBlockPointer(plane, subsamplingX, subsamplingY); + for (int y = 0; y < planeHeight; y++) + { + Span actualRow = actualPlane.DangerousGetRowSpan(y)[..planeWidth]; + ReadOnlySpan expectedRow = reference.Slice(referenceOffset, planeWidth); + for (int x = 0; x < planeWidth; x++) + { + AssertSampleEqual(plane, x, y, expectedRow[x], actualRow[x]); + } + + referenceOffset += planeWidth; + } + } + else + { + // aomdec writes high-bit-depth YUV as little-endian 16-bit values, independently of host endianness. + for (int y = 0; y < planeHeight; y++) + { + Span actualRow = frameBuffer.GetHighBitDepthRowSpan(plane, y, subsamplingX, subsamplingY); + for (int x = 0; x < planeWidth; x++) + { + ushort expected = BinaryPrimitives.ReadUInt16LittleEndian(reference.Slice(referenceOffset, sizeof(ushort))); + AssertSampleEqual(plane, x, y, expected, actualRow[x]); + referenceOffset += sizeof(ushort); + } + } + } + } + + Assert.Equal(reference.Length, referenceOffset); + } + + /// + /// Calculates a component dimension after chroma subsampling with the AV1 rounding rule. + /// + /// The luma dimension. + /// The component subsampling shift. + /// The subsampled component dimension. + private static int GetSubsampledSize(int size, int subsampling) + => (size + (1 << subsampling) - 1) >> subsampling; + + /// + /// Reports the exact component coordinate when independently decoded samples differ. + /// + /// The compared component plane. + /// The sample X coordinate. + /// The sample Y coordinate. + /// The reference sample. + /// The reconstructed sample. + private static void AssertSampleEqual(Av1Plane plane, int x, int y, ushort expected, ushort actual) + { + if (expected != actual) + { + Assert.Fail($"Plane {plane} differs at ({x}, {y}): expected {expected}, actual {actual}."); + } + } +} diff --git a/tests/ImageSharp.Tests/TestImages.cs b/tests/ImageSharp.Tests/TestImages.cs index f472000386..97982dce8b 100644 --- a/tests/ImageSharp.Tests/TestImages.cs +++ b/tests/ImageSharp.Tests/TestImages.cs @@ -1341,6 +1341,18 @@ public static class TestImages public const string Animated8BitWithAudio = "Heif/colors-animated-8bpc-audio.avif"; public const string Animated8BitWithAlphaExifXmp = "Heif/colors-animated-8bpc-alpha-exif-xmp.avif"; public const string Animated12BitWithKeyframes = "Heif/colors-animated-12bpc-keyframes-0-2-3.avif"; + + // Genuine libavif AVIF inputs, independently encoded AV1 samples, and exact native-plane output from the + // pinned scalar libaom reference decoder. See the fixture README for source and encoding details. + public const string Av1Deblocking8BitAvif = "Heif/Av1/Conformance/libavif-kodim23-8b.avif"; + public const string Av1Deblocking8BitPayload = "Heif/Av1/Conformance/libavif-kodim23-8b.bit"; + public const string Av1Deblocking8BitReference = "Heif/Av1/Conformance/libavif-kodim23-8b-libaom.yuv"; + public const string Av1Deblocking10BitAvif = "Heif/Av1/Conformance/libavif-cosmos1650-10b.avif"; + public const string Av1Deblocking10BitPayload = "Heif/Av1/Conformance/libavif-cosmos1650-10b.bit"; + public const string Av1Deblocking10BitReference = "Heif/Av1/Conformance/libavif-cosmos1650-10b-libaom.yuv"; + public const string Av1Deblocking12BitAvif = "Heif/Av1/Conformance/libavif-colors-12b.avif"; + public const string Av1Deblocking12BitPayload = "Heif/Av1/Conformance/libaom-cosmos1650-12b.bit"; + public const string Av1Deblocking12BitReference = "Heif/Av1/Conformance/libaom-cosmos1650-12b-libaom.yuv"; } public static class Ico diff --git a/tests/Images/Input/Heif/Av1/Conformance/README.md b/tests/Images/Input/Heif/Av1/Conformance/README.md new file mode 100644 index 0000000000..925bbec0b8 --- /dev/null +++ b/tests/Images/Input/Heif/Av1/Conformance/README.md @@ -0,0 +1,17 @@ +# AV1 deblocking conformance fixtures + +The AVIF files come from `libavif/tests/data` at commit `062e582e8afda88e6baf988fdcf046a801efa0f5`. They retain the licenses recorded in libavif's `tests/data/README.md`: the Kodak image is released for unrestricted use, the Cosmos Laundromat frame uses CC BY 3.0, and the libavif color animation is distributed with the libavif test corpus under its BSD-2-Clause license. + +The 8- and 10-bit `.bit` files contain the exact AV1 item payloads from the corresponding AVIF files. Each still file has one item occupying the complete `mdat` payload. The genuine 12-bit libavif sequence is retained for container, presentation, alpha, and metadata coverage, but its first color frame disables deblocking and therefore cannot prove the 12-bit filter path. + +`libaom-cosmos1650-12b.bit` was encoded from libavif's real 10-bit 4:4:4 Cosmos Laundromat Y4M source with the pinned libaom encoder. libaom promotes the input samples to a 12-bit AV1 profile-2 still-picture stream. The constant-quality level is deliberately lossy so the frame signals nonzero loop-filter levels. The material command options were `--usage=2 --passes=1 --limit=1 --obu --bit-depth=12 --input-bit-depth=10 --profile=2 --end-usage=q --cq-level=30 --cpu-used=6 --threads=1 --lag-in-frames=0 --full-still-picture-hdr`. + +The `_libaom.yuv` files were decoded from those exact payloads with `aomdec` built from libaom commit `03087864cf4bea6abb0d28f95cf7843511413d8f`. The reference build used `AOM_TARGET_CPU=generic`, so these files come from libaom's scalar decoder rather than ImageSharp or an architecture-specific implementation. + +The native reference layouts are: + +- `libavif-kodim23-8b-libaom.yuv`: 768x512, 8-bit YUV 4:2:0, planar Y/U/V. +- `libavif-cosmos1650-10b-libaom.yuv`: 1024x428, 10-bit YUV 4:4:4, planar Y/U/V with little-endian 16-bit samples. +- `libaom-cosmos1650-12b-libaom.yuv`: 1024x428, 12-bit YUV 4:4:4, planar Y/U/V with little-endian 16-bit samples. + +The conformance test compares every visible reconstructed sample with these files. It also verifies that the parsed frame enables deblocking, so a disabled or bypassed loop-filter stage cannot satisfy the test accidentally. diff --git a/tests/Images/Input/Heif/Av1/Conformance/libaom-cosmos1650-12b-libaom.yuv b/tests/Images/Input/Heif/Av1/Conformance/libaom-cosmos1650-12b-libaom.yuv new file mode 100644 index 0000000000..d3f0731df5 --- /dev/null +++ b/tests/Images/Input/Heif/Av1/Conformance/libaom-cosmos1650-12b-libaom.yuv @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:ef712be32af7cf0a95c5c41bdcc51afc05a4ab7c047383f5f65edad2bb986712 +size 2629632 diff --git a/tests/Images/Input/Heif/Av1/Conformance/libaom-cosmos1650-12b.bit b/tests/Images/Input/Heif/Av1/Conformance/libaom-cosmos1650-12b.bit new file mode 100644 index 0000000000..546c68d06f --- /dev/null +++ b/tests/Images/Input/Heif/Av1/Conformance/libaom-cosmos1650-12b.bit @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:a45f9653255c1a660906554bafcc13fdee04f88cc6d0e08e1efa169cf0c6ddd2 +size 23769 diff --git a/tests/Images/Input/Heif/Av1/Conformance/libavif-colors-12b.avif b/tests/Images/Input/Heif/Av1/Conformance/libavif-colors-12b.avif new file mode 100644 index 0000000000..1550d842f4 --- /dev/null +++ b/tests/Images/Input/Heif/Av1/Conformance/libavif-colors-12b.avif @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:3bf9f91da471749e7df639ba7945d4d94c1c3e3968c26f3619fbbcfc92790576 +size 2267 diff --git a/tests/Images/Input/Heif/Av1/Conformance/libavif-cosmos1650-10b-libaom.yuv b/tests/Images/Input/Heif/Av1/Conformance/libavif-cosmos1650-10b-libaom.yuv new file mode 100644 index 0000000000..b15f31bf19 --- /dev/null +++ b/tests/Images/Input/Heif/Av1/Conformance/libavif-cosmos1650-10b-libaom.yuv @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:9a59dd92a0c579f942acca8281ebd0465dc848be200a4d2ff57eaff589445f6c +size 2629632 diff --git a/tests/Images/Input/Heif/Av1/Conformance/libavif-cosmos1650-10b.avif b/tests/Images/Input/Heif/Av1/Conformance/libavif-cosmos1650-10b.avif new file mode 100644 index 0000000000..dc79231cb7 --- /dev/null +++ b/tests/Images/Input/Heif/Av1/Conformance/libavif-cosmos1650-10b.avif @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:1c3db1867051ae23ba61ed217f6b7372a4248e6322d76a239feab14bc4c55ab5 +size 37451 diff --git a/tests/Images/Input/Heif/Av1/Conformance/libavif-cosmos1650-10b.bit b/tests/Images/Input/Heif/Av1/Conformance/libavif-cosmos1650-10b.bit new file mode 100644 index 0000000000..980c072965 --- /dev/null +++ b/tests/Images/Input/Heif/Av1/Conformance/libavif-cosmos1650-10b.bit @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:f930bf11eb2f61bf4ee0fe61853cd387a4c3dbe53503707db7b2c59d9d273ff3 +size 37169 diff --git a/tests/Images/Input/Heif/Av1/Conformance/libavif-kodim23-8b-libaom.yuv b/tests/Images/Input/Heif/Av1/Conformance/libavif-kodim23-8b-libaom.yuv new file mode 100644 index 0000000000..c858043687 --- /dev/null +++ b/tests/Images/Input/Heif/Av1/Conformance/libavif-kodim23-8b-libaom.yuv @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:8dde2eec742c39f0579c29ae84cba0fe01522a9008adcb2cffccec0295d18141 +size 589824 diff --git a/tests/Images/Input/Heif/Av1/Conformance/libavif-kodim23-8b.avif b/tests/Images/Input/Heif/Av1/Conformance/libavif-kodim23-8b.avif new file mode 100644 index 0000000000..b3570628be --- /dev/null +++ b/tests/Images/Input/Heif/Av1/Conformance/libavif-kodim23-8b.avif @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:fa97744b1bad2137cac0f81fb653175362e16c6d8d20613d0769a847f2769bd1 +size 21032 diff --git a/tests/Images/Input/Heif/Av1/Conformance/libavif-kodim23-8b.bit b/tests/Images/Input/Heif/Av1/Conformance/libavif-kodim23-8b.bit new file mode 100644 index 0000000000..d2e35fb7a9 --- /dev/null +++ b/tests/Images/Input/Heif/Av1/Conformance/libavif-kodim23-8b.bit @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:b7b1d3f85a870475acf579fbb7a0b59ff94c30f84b3f3a066411a50f9ba1bd20 +size 20750