Verify AV1 deblocking conformance

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<int>` 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<int>` 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.

src/ImageSharp/Formats/Heif/Av1/Av1Decoder.cs

@@ -195,7 +195,7 @@ internal sealed class Av1Decoder : IAv1TileReader, IDisposable
     /// <param name="codecConfiguration">The AV1 codec configuration validated against the coded sequence header.</param>
     /// <param name="effectiveColorProfile">Receives the effective CICP description associated with the native planes.</param>
     /// <returns>The reconstructed native frame buffer. Ownership transfers to the caller.</returns>
-    private Av1FrameBuffer<byte> DecodeFrameBuffer(
+    public Av1FrameBuffer<byte> DecodeFrameBuffer(
         Span<byte> buffer,
         CicpProfile? containerColorProfile,
         Av1CodecConfiguration? codecConfiguration,

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;
+
+/// <summary>
+/// Validates complete AV1 reconstruction against independently decoded native component planes.
+/// </summary>
+[Trait("Format", "Avif")]
+public class Av1DeblockingConformanceTests
+{
+    /// <summary>
+    /// Verifies deblocking syntax, filter activation, component traversal, and presentation for real eight-, ten-,
+    /// and twelve-bit AV1 and AVIF content.
+    /// </summary>
+    [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);
+    }
+
+    /// <summary>
+    /// Validates one elementary-stream sample and its containing AVIF image.
+    /// </summary>
+    /// <param name="imagePath">The complete AVIF container.</param>
+    /// <param name="payloadPath">The AV1 elementary-stream sample extracted from the container.</param>
+    /// <param name="referencePath">The native planar output produced by the pinned libaom decoder.</param>
+    /// <param name="width">The expected displayed width.</param>
+    /// <param name="height">The expected displayed height.</param>
+    /// <param name="bitDepth">The expected AV1 sample precision.</param>
+    /// <param name="colorFormat">The expected native chroma-sampling layout.</param>
+    /// <param name="metadataBitDepth">The expected public HEIF sample precision.</param>
+    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);
+    }
+
+    /// <summary>
+    /// Validates complete native-plane reconstruction for one AV1 elementary-stream sample.
+    /// </summary>
+    /// <param name="payloadPath">The AV1 elementary-stream sample.</param>
+    /// <param name="referencePath">The native planar output produced by the pinned libaom decoder.</param>
+    /// <param name="width">The expected reconstructed width.</param>
+    /// <param name="height">The expected reconstructed height.</param>
+    /// <param name="bitDepth">The expected AV1 sample precision.</param>
+    /// <param name="colorFormat">The expected native chroma-sampling layout.</param>
+    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<byte> 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);
+    }
+
+    /// <summary>
+    /// Validates the public presentation and metadata produced from one complete AVIF container.
+    /// </summary>
+    /// <param name="imagePath">The complete AVIF container.</param>
+    /// <param name="width">The expected displayed width.</param>
+    /// <param name="height">The expected displayed height.</param>
+    /// <param name="metadataBitDepth">The expected public HEIF sample precision.</param>
+    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<Rgba64> image = Image.Load<Rgba64>(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);
+    }
+
+    /// <summary>
+    /// Compares every visible native component sample with the independent planar reference.
+    /// </summary>
+    /// <param name="frameBuffer">The reconstructed AV1 component planes.</param>
+    /// <param name="reference">The planar Y, U, and V samples produced by the pinned libaom decoder.</param>
+    private static void AssertNativePlanesEqual(Av1FrameBuffer<byte> frameBuffer, ReadOnlySpan<byte> 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<byte> actualPlane = frameBuffer.DeriveBlockPointer(plane, subsamplingX, subsamplingY);
+                for (int y = 0; y < planeHeight; y++)
+                {
+                    Span<byte> actualRow = actualPlane.DangerousGetRowSpan(y)[..planeWidth];
+                    ReadOnlySpan<byte> 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<ushort> 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);
+    }
+
+    /// <summary>
+    /// Calculates a component dimension after chroma subsampling with the AV1 rounding rule.
+    /// </summary>
+    /// <param name="size">The luma dimension.</param>
+    /// <param name="subsampling">The component subsampling shift.</param>
+    /// <returns>The subsampled component dimension.</returns>
+    private static int GetSubsampledSize(int size, int subsampling)
+        => (size + (1 << subsampling) - 1) >> subsampling;
+
+    /// <summary>
+    /// Reports the exact component coordinate when independently decoded samples differ.
+    /// </summary>
+    /// <param name="plane">The compared component plane.</param>
+    /// <param name="x">The sample X coordinate.</param>
+    /// <param name="y">The sample Y coordinate.</param>
+    /// <param name="expected">The reference sample.</param>
+    /// <param name="actual">The reconstructed sample.</param>
+    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}.");
+        }
+    }
+}

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

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.

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

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

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

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

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

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

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

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

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