Complete AV1 local warped-motion decoding

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 committed production checkpoint `59a4fbad5ed3bc7c34331c4bdc65acc7acde3f04` plus the locally complete scaled-reference checkpoint awaiting commit. Committed checkpoints include the AV1 transform architecture, OBU framing, intra-block copy, 12-profile reconstruction matrix, 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, and OBMC. The local checkpoint adds exact Q14 reference scaling, variable-phase Q10 separable convolution, size-changing production reconstruction, scaled OBMC neighbors, the normative 288-sample retained border, and per-block inter deblocking decisions. Its pinned 40x40-to-80x80 bounded AVIF passes exact base and final native-plane comparison, exact final presentation comparison, normal and scalar `FeatureTestRunner` execution, constrained allocation, and collision-free exactly-once ownership tracking. Both source targets build with zero warnings and errors; the `net10.0` test project builds with zero errors and its 1,013 pre-existing warnings; 87 focused `net10.0` cases pass without failures or skips; and the documentation and diff checks are complete. 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 committed production checkpoint `8f57c29b250b4291f034b31c1ea3de3fa3345467` plus the locally complete local-warp checkpoint awaiting commit. Committed checkpoints include the AV1 transform architecture, OBU framing, intra-block copy, 12-profile reconstruction matrix, 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, and scaled-reference reconstruction. The local checkpoint adds pinned integer least-squares projection, reduced-shear validation, allocation-free 8x8-tiled affine filtering, and production local warped reconstruction across byte and high-bit-depth planes. Its genuine two-frame 256x256 bounded AVIF selects many traced `WARPED_CAUSAL` blocks, including multi-sample nonzero-shear models, and passes exact final pinned-libaom YUV444 planes, exact pinned-libavif RGBA presentation, normal and scalar `FeatureTestRunner` execution, constrained allocation, and balanced ownership tracking. Both source targets build with zero warnings and errors; the `net10.0` test project builds with zero errors and pre-existing warnings; 86 focused `net10.0` cases pass without failures or skips; and the documentation and diff checks are complete. 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.
 
 Status meanings:
 
@@ -39,15 +39,15 @@ Status meanings:
 - **Not started:** supporting primitives may exist, but the production format path is absent.
 - **Current:** the only work item that should be advanced before taking the next queued item.
 
-Current development stage: **Stage 3 — complete AV1 still-image decoding.** The decoder retains reference/header/CDF/motion-field state, derives frame-level skip-mode references, consumes temporal segment prediction, decodes intra-coded blocks inside inter frames, and reconstructs translational single-reference, compound, inter-intra, OBMC, and scaled-reference prediction before residual traversal. The scaled-reference implementation and independent evidence are complete locally; its checkpoint commit is the only remaining gate before warped motion becomes current. Warped motion and non-translational global prediction remain explicitly unsupported. Neither AV1 nor HEVC production encoding is implemented.
+Current development stage: **Stage 3 — complete AV1 still-image decoding.** The decoder retains reference/header/CDF/motion-field state, derives frame-level skip-mode references, consumes temporal segment prediction, decodes intra-coded blocks inside inter frames, and reconstructs translational single-reference, compound, inter-intra, OBMC, scaled-reference, and local warped prediction before residual traversal. The local-warp implementation and independent evidence are complete locally; its checkpoint commit is the only remaining gate before non-translational global prediction becomes current. Neither AV1 nor HEVC production encoding is implemented.
 
-Immediate checkpoint: **commit the complete scaled-reference implementation and its verified evidence before advancing to warped motion.** The production branch, independent native and presentation comparisons, constrained allocator coverage, Release builds, focused tests, documentation review, and diff validation are complete. This work remains inside the existing image-item and bounded image-sequence surfaces and does not expand into a general ISO BMFF/video model.
+Immediate checkpoint: **commit the complete local warped-motion implementation and its verified evidence before advancing to non-translational global motion.** The production branch, pinned multi-sample projection, independent native and presentation comparisons, constrained allocator coverage, Release builds, focused tests, documentation review, and diff validation are complete. This work remains inside the existing image-item and bounded image-sequence surfaces and does not expand into a general ISO BMFF/video model.
 
 | Order | Delivery stage | State | Delivered state | Gate that remains open |
 | --- | --- | --- | --- | --- |
 | 1 | Baseline, provenance, documentation, and public contract | In progress | Pinned codec references, a bounded image-only scope, encoder options, typed bit depth, decoder-option propagation, and extensive HEIF documentation exist. | Complete the all-file documentation audit, record a fresh Release baseline, finish distinct public HEIC/AVIF save boundaries, and close API review. |
 | 2 | Bounded HEIF item and image-sequence container | In progress | Still-item parsing, grids, auxiliary alpha, metadata properties, bounded image-sequence tracks, Identify, and all-sync AV1 sequence presentation are connected. | Complete adversarial boundary coverage, remaining item/property behavior, reference-dependent sequence reconstruction, and the bounded sequence writer. |
-| 3 | Still-image AV1 and HEVC decoding | **Current** | HEVC reconstruction reaches exact HM/libheif fixtures across the recorded 8/10/12-bit and chroma cases. AV1 work includes bounded OBU framing, reconstruction, filters, grain, color, transforms, intra-block copy, an exact independent 12-profile bit-depth/chroma matrix through every dispatch tier, retained layered reference/header/CDF/motion-field state, temporal segment prediction, inter-frame intra blocks, SIMD-first translational prediction, exact single-reference inter reconstruction, exact equal-average and selectable compound reconstruction, inter-intra prediction, committed OBMC, and a locally complete independently verified scaled-reference branch. | Commit scaled-reference, then implement warped and non-translational global prediction; remove every other valid AV1 still-image unsupported branch with independent vectors; then complete the remaining HEVC profile and Range Extensions matrix. |
+| 3 | Still-image AV1 and HEVC decoding | **Current** | HEVC reconstruction reaches exact HM/libheif fixtures across the recorded 8/10/12-bit and chroma cases. AV1 work includes bounded OBU framing, reconstruction, filters, grain, color, transforms, intra-block copy, an exact independent 12-profile bit-depth/chroma matrix through every dispatch tier, retained layered reference/header/CDF/motion-field state, temporal segment prediction, inter-frame intra blocks, SIMD-first translational prediction, exact single-reference inter reconstruction, exact equal-average and selectable compound reconstruction, inter-intra prediction, committed OBMC and scaled-reference reconstruction, and locally complete independently verified local warped prediction. | Commit local warped prediction, then implement non-translational global prediction; remove every other valid AV1 still-image unsupported branch with independent vectors; then complete the remaining HEVC profile and Range Extensions matrix. |
 | 4 | Complete decoded presentation and animation | In progress | Shared SIMD-first AV1/HEVC color conversion, ICC application, grids, transforms, direct planar alpha composition, frame metadata, repetition, and independently decodable AV1 sequence samples exist. | Close the full color/ICC cross-product, HEVC sequence decoding, AV1/HEVC reference-dependent samples, frame-local metadata/alpha behavior, and independent animated decode vectors. |
 | 5 | AV1/AVIF encoding | Not started | RGB-to-planar conversion, forward transforms, OBU writer foundations, options, and container-writing infrastructure exist. | `HeifEncoderCore` still rejects AV1. Implement a real independently decodable lossy/lossless AV1 payload and the complete AVIF item/metadata matrix. |
 | 6 | HEVC/HEIC encoding | Not started | Shared input color conversion, options, and HEIF writer infrastructure exist. | `HeifEncoderCore` still rejects HEVC. Implement a real independently decodable lossy/lossless HEVC payload and the complete HEIC item/metadata matrix. |
@@ -92,7 +92,8 @@ Immediate checkpoint: **commit the complete scaled-reference implementation and
     - [x] Decode selected inter-intra prediction and selectable distance-weighted, wedge, and difference-weighted compound blending. Normative-order syntax, direct 8/10/12-bit production reconstruction, SIMD/scalar arithmetic, four pinned bounded sequences, exact final native planes and presentation, constrained contiguous planes, and balanced allocator returns pass. Both source targets build with zero warnings and errors; the test project builds with zero errors and pre-existing repository warnings; 25 direct focused cases and six `FeatureTestRunner` cases pass without failures or skips; and `git diff --check` is clean.
     - [x] Decode and reconstruct above and left OBMC through allocator-owned prediction workspaces, exact pinned masks, and the existing SIMD-first masked blender. Commit `59a4fbad5ed3bc7c34331c4bdc65acc7acde3f04` records direct 8/10/12-bit production reconstruction, 4:2:0 and 4:2:2 overlap geometry, a real 19-frame YUV444 sequence containing more than one hundred traced OBMC blocks, exact final pinned-libaom native planes, exact pinned-libavif presentation through normal and scalar `FeatureTestRunner` configurations, constrained tracked allocation, zero-warning `net10.0` and `net11.0` source builds, a zero-error analyzer build with 1,013 pre-existing warnings, 14 direct focused cases plus the feature-isolated comparison, and clean staged `git diff --check`.
     - [x] Decode and independently verify scaled-reference prediction through exact Q14/Q10 arithmetic, allocation-free SIMD/scalar convolution, 8/10/12-bit production reconstruction, scaled OBMC, active inter deblocking, constrained allocation, and a genuine size-changing bounded AVIF.
-    - [ ] **Queued until the scaled-reference commit:** decode warped motion, then non-translational global-motion prediction.
+    - [x] Decode local warped motion through pinned integer projection and allocation-free SIMD-first affine filtering. A genuine two-frame bounded AVIF selects traced multi-sample warped blocks and passes exact final native-plane and presentation comparisons, constrained allocation, and normal/scalar dispatch. The checkpoint is complete locally and awaiting commit.
+    - [ ] **Queued until the local-warp commit:** decode non-translational global-motion prediction.
     - [ ] Verify every remaining connected mode and filter with independently encoded bounded AV1 content and exact native-plane comparisons.
   - [ ] Return the explicitly selected spatial layer or the final displayed layer, keeping reference reconstruction separate from display-only film grain.
   - [ ] Verify color and auxiliary-alpha output exactly against both pinned libavif progressive fixtures under normal SIMD dispatch and all required `FeatureTestRunner` fallbacks.
@@ -396,7 +397,8 @@ This assessment was reconciled with the source tree on 2026-08-29, including pro
 - Committed inter-frame support parses single-reference selection, builds the fixed-capacity spatial and temporal reference-MV stack, decodes NEAREST/NEAR/NEW/GLOBAL and DRL syntax, decodes or infers interpolation filters, checks inter-intra and motion-mode eligibility, and invokes simple translational prediction before residual reconstruction. Commit `8b9aa4b2cfe59ff0f8c348d9bb06678a5ff12f2a` records exact corrected dependent-frame native-plane and final-presentation comparisons plus the complete focused Release matrix and ownership/allocation evidence.
 - Commit `e1a764b8f2e8a8db98a003fb3b913213f40084db` owns every compound reference-selection and inter-mode distribution through the retained CDF lifecycle, derives primary and secondary candidate vectors as inseparable pairs, reconstructs both retained references through the existing translational predictor, and combines them through one SIMD-first byte/ushort averaging operator with scalar parity. The pinned 19-frame libavif sequence exercises the complete production block branch and matches pinned libaom native planes and pinned libavif presentation exactly after decoding all preceding reference samples.
 - Commit `59a4fbad5ed3bc7c34331c4bdc65acc7acde3f04` reconstructs eligible above and left OBMC neighbors through the retained primary reference, exact libaom masks, and the existing SIMD-first masked blender without per-block allocation. Direct production tests cover 8/10/12-bit storage plus 4:2:0 and 4:2:2 plane geometry. A pinned 19-frame sequence contains more than one hundred traced OBMC blocks and passes exact final native-plane, final-presentation, constrained-allocation, normal-dispatch, and scalar-dispatch comparison.
-- The locally complete scaled-reference checkpoint maps current-frame Q4 positions into retained-frame Q10 coordinates with pinned-libaom Q14 scale factors and signed rounding, then applies allocation-free variable-phase two-pass convolution across byte and high-bit-depth storage. The production block path selects scaling from actual retained/current dimensions, covers both primary and secondary workspaces plus scaled OBMC neighbors, and retains libaom's 288-sample prediction border. The real layered fixture also exposed and now verifies per-block inter loop-filter reference/mode deltas and skipped-transform edge decisions that the earlier intra-only deblocking integration did not model.
+- Commit `8f57c29b250b4291f034b31c1ea3de3fa3345467` maps current-frame Q4 positions into retained-frame Q10 coordinates with pinned-libaom Q14 scale factors and signed rounding, then applies allocation-free variable-phase two-pass convolution across byte and high-bit-depth storage. The production block path selects scaling from actual retained/current dimensions, covers both primary and secondary workspaces plus scaled OBMC neighbors, and retains libaom's 288-sample prediction border. The real layered fixture also exposed and now verifies per-block inter loop-filter reference/mode deltas and skipped-transform edge decisions that the earlier intra-only deblocking integration did not model.
+- The locally complete local-warp checkpoint derives AV1's affine matrix from fixed-capacity spatial samples with pinned integer least squares, reciprocal lookup, coefficient clamping, and shear validation. Production reconstruction applies the pinned 193-phase Q7 warped filter in allocation-free 8x8 tiles through `Vector128` convolution with scalar fallback for 8/10/12-bit planes; an invalid selected model falls back to translational prediction as libaom does.
 - Source inspection against pinned libaom `03087864cf4bea6abb0d28f95cf7843511413d8f` resolves two disputed audit claims in favor of the current predicates. The interpolation call path uses `is_nontrans_global_motion()`, which returns false only for `TRANSLATION`, so an identity `GLOBALMV` block omits filter symbols. The single-reference spatial extension loops use `MAX_MV_REF_CANDIDATES`, which is two, while the full reference-MV stack capacity is eight. These loops are spatial extension, not temporal extension.
 - Every padded AV1 frame plane requests ImageSharp's contiguous allocation contract, and constrained-allocator reconstruction passes without copying. Motion fields use allocator-owned storage and counted leases; allocation tracking passes for initialization, retained aliases, failure unwinding, presentation ownership, decoder-result ownership, and exactly-once disposal. The corrected logical progressive color payload reaches the production inter branch and its final native planes match pinned libaom exactly.
 - 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.
@@ -427,7 +429,8 @@ This assessment was reconciled with the source tree on 2026-08-29, including pro
 ### Tests
 
 - HEVC coverage includes exact native-plane comparison with HM output, exact complete-image comparison with pinned libheif/libde265 references, and the 10 official Sony GENERAL Range Extensions first-picture fixtures across 8/10/12-bit monochrome, 4:2:0, 4:2:2, and 4:4:4 reconstruction. The remaining exposed profiles and individual Range Extensions tools still need exact independent vectors.
-- AV1 has focused bitstream, prediction, entropy, reconstruction, filter, film-grain, color, and transform coverage, plus real libavif inputs. A real two-layer libavif-derived OBU stream verifies the bounded frame lifecycle, retained-slot occupancy, resolved inter references, and `frame_size_with_refs` dimensions through a fake tile lifecycle. The corrected progressive color item then verifies its production single-reference inter branch against exact pinned-libaom native planes and pinned-libavif presentation. The pinned 19-frame YUV444 sequence separately reaches production equal-average compound reconstruction after every preceding reference sample and matches its final native and presented references exactly. A real palette stream truncated inside its tile entropy payload verifies libaom-equivalent overflow/trailing-bit rejection and decoder-session recovery. The committed equal-average checkpoint passes 119 direct focused cases plus three `FeatureTestRunner` cases, zero-warning `net10.0` and `net11.0` source builds, a zero-error test-project analyzer build with pre-existing repository warnings, allocator lifetime validation, and `git diff --check`. Four additional pinned sequences reach distance-weighted, both wedge signs, both difference-mask orientations, and smooth and wedge inter-intra reconstruction with exact final native and presented output. Commit `864b11ad9791d3254a38691246270c569001b5a1` records the selectable-compound checkpoint after both source targets, the test-project analyzer build, 25 direct focused cases, six `FeatureTestRunner` cases, constrained allocation, exactly-once tracked returns, and `git diff --check` passed. Commit `59a4fbad5ed3bc7c34331c4bdc65acc7acde3f04` adds exact traced OBMC sequence evidence, subsampled direct reconstruction, constrained allocation, both source builds, the analyzer build, 14 direct cases, the normal/scalar `FeatureTestRunner` comparison, and clean staged `git diff --check`. The local scaled-reference checkpoint adds a genuine size-changing layered AVIF, exact retained-base and final native planes, exact final presentation, active inter deblocking, constrained allocation, normal/scalar dispatch, direct 8/10/12-bit block reconstruction, and 87 passing focused cases. Valid still-image syntax paths still contain explicit unsupported branches, so the independent AV1 decode matrix is not complete.
+- AV1 has focused bitstream, prediction, entropy, reconstruction, filter, film-grain, color, and transform coverage, plus real libavif inputs. A real two-layer libavif-derived OBU stream verifies the bounded frame lifecycle, retained-slot occupancy, resolved inter references, and `frame_size_with_refs` dimensions through a fake tile lifecycle. The corrected progressive color item then verifies its production single-reference inter branch against exact pinned-libaom native planes and pinned-libavif presentation. The pinned 19-frame YUV444 sequence separately reaches production equal-average compound reconstruction after every preceding reference sample and matches its final native and presented references exactly. A real palette stream truncated inside its tile entropy payload verifies libaom-equivalent overflow/trailing-bit rejection and decoder-session recovery. The committed equal-average checkpoint passes 119 direct focused cases plus three `FeatureTestRunner` cases, zero-warning `net10.0` and `net11.0` source builds, a zero-error test-project analyzer build with pre-existing repository warnings, allocator lifetime validation, and `git diff --check`. Four additional pinned sequences reach distance-weighted, both wedge signs, both difference-mask orientations, and smooth and wedge inter-intra reconstruction with exact final native and presented output. Commit `864b11ad9791d3254a38691246270c569001b5a1` records the selectable-compound checkpoint after both source targets, the test-project analyzer build, 25 direct focused cases, six `FeatureTestRunner` cases, constrained allocation, exactly-once tracked returns, and `git diff --check` passed. Commit `59a4fbad5ed3bc7c34331c4bdc65acc7acde3f04` adds exact traced OBMC sequence evidence, subsampled direct reconstruction, constrained allocation, both source builds, the analyzer build, 14 direct cases, the normal/scalar `FeatureTestRunner` comparison, and clean staged `git diff --check`. Commit `8f57c29b250b4291f034b31c1ea3de3fa3345467` adds a genuine size-changing layered AVIF, exact retained-base and final native planes, exact final presentation, active inter deblocking, constrained allocation, normal/scalar dispatch, direct 8/10/12-bit block reconstruction, and 87 passing focused cases. The local-warp checkpoint adds a genuine two-frame 256x256 bounded AVIF with many traced `WARPED_CAUSAL` blocks, exact pinned multi-sample projection, exact final native and presentation comparisons, constrained allocation, normal/scalar `FeatureTestRunner` dispatch, direct 8/10/12-bit predictor parity, zero-warning source builds, and 86 passing focused cases. Valid still-image syntax paths still contain explicit unsupported branches, so the independent AV1 decode matrix is not complete.
+- Local-warp fixture provenance is pinned to libavif `062e582e8afda88e6baf988fdcf046a801efa0f5` and libaom `03087864cf4bea6abb0d28f95cf7843511413d8f`. A deterministic two-frame limited-range YUV444 grid sequence was encoded with `avifenc -j 1 -s 0 -q 60 -a color:enable-warped-motion=1 -a color:enable-global-motion=0 -a color:enable-obmc=0`. SHA-256 values are `990BAC4AD443005C217B0DA4FCCFA9ADFB3AA147AD06C85F9A655A4433E9E8A7` for the AVIF, `984B2815CEE0C05FDE26430F150A21B5C993141E25BA1ED4FDE09372DB64AC13` for the pinned-libaom frame-1 Y4M, and `4490D62FB6679378E92CACA48427359091AD2106BE49FC1A3848F78BE03BEEB1` for the pinned-libavif frame-1 PNG.
 - Scaled-reference fixture provenance is pinned to libavif `062e582e8afda88e6baf988fdcf046a801efa0f5` and libaom `03087864cf4bea6abb0d28f95cf7843511413d8f`. The source is libavif `tests/data/webp_logo_animated.y4m`, encoded as two layered YUV444 inputs with `avifenc -j 1 -q 90 --layered --scaling-mode:u 1/2 <input> --scaling-mode:u 1/1 <input> <output>`. The resulting item contains a 701-byte 40x40 base layer followed by a 1,494-byte 80x80 dependent layer. SHA-256 values are `EB239F31EC8DBF5E97AD6F52670FCA6497AE2A933822CFE724C75F66AAA2520B` for the AVIF, `B7E30E04A935414A517BAA2DF06AB756DA18BA7C291220D9D7C063297761AE82` for the 2,195-byte logical AV1 payload, `873DC1AB5623910FBF8053CBF684399F4F3BDDBA4110492E3E11DE86E01FEC1B` for the 4,800-byte pinned-libaom base YUV, `964F4D85A79FC10EEB3722E2C9DA3415083E1EB8C2611FE154946FA55E2171ED` for the pinned-libaom final Y4M, and `DC4C6DBE6BD92C5FCE1E3E23700AFA603EF04ED02EDD336213EBBA1E3BD84BA0` for the pinned-libavif final PNG.
 - The AV1 transform matrix verifies scalar, `Vector128`, `Vector256`, and `Vector512` forward representations plus the production inverse tiers across every valid size/type combination and supported bit depth. All 511 focused forward and inverse cases pass in Release; `FeatureTestRunner` isolates hardware tiers, every two-dimensional configuration exercises production dispatch, and the complete-block benchmark records zero managed allocation.
 - Independent libavif fixtures cover primary, grid, auxiliary-alpha, ICC, metadata-skipping, and all-sync image-sequence presentation. Reference-dependent AV1 and HEVC sequence reconstruction and independent HEVC ICC sequence coverage remain open.
@@ -578,7 +581,8 @@ Implement and verify in dependency order:
   - [x] Decode and reconstruct selected inter-intra prediction and selectable distance-weighted, wedge, and difference-weighted compound blending through reconstructed reference planes. Direct syntax and 8/10/12-bit production tests, SIMD/scalar mask and blend tests, exact four-sequence native/presentation comparisons, constrained contiguous allocation, and exactly-once tracked returns pass. Both source targets build with zero warnings and errors; the test project builds with zero errors and pre-existing repository warnings; 25 direct focused cases and six `FeatureTestRunner` cases pass without failures or skips; and `git diff --check` is clean. Commit `864b11ad9791d3254a38691246270c569001b5a1` records the checkpoint.
   - [x] Decode and reconstruct OBMC through above and left neighboring prediction, exact libaom masks, allocator-owned workspaces, and the existing SIMD-first masked blender. Commit `59a4fbad5ed3bc7c34331c4bdc65acc7acde3f04` records exact pinned native/presentation evidence, direct 8/10/12-bit and subsampled reconstruction, constrained allocation, both Release source builds, and normal/scalar dispatch.
   - [x] Decode scaled references through exact Q14 scale factors, signed Q4-to-Q10 coordinate rounding, variable per-output phases and steps, regular/smooth/sharp/bilinear reduced and full filters, bit-depth-dependent two-pass rounding, scaled OBMC neighbors, and the normative 288-sample retained border without per-block allocation. The independently generated 40x40-to-80x80 layered fixture proves the base reference before retention and in the production retained session, then matches the final pinned-libaom Y/U/V planes and pinned-libavif RGBA presentation exactly. Active inter deblocking additionally verifies per-block reference/mode deltas and skipped inter/intra boundary decisions. Normal and scalar `FeatureTestRunner` runs, constrained contiguous planes, unique allocation identities, 8/10/12-bit production-block coverage, zero-warning `net10.0` and `net11.0` source builds, the zero-error test-project build with 1,013 pre-existing warnings, 87 focused cases, documentation review, and `git diff --check` pass.
-  - [ ] **Queued until the scaled-reference commit:** decode warped motion and non-translational global motion through reconstructed reference planes.
+  - [x] Decode local warped motion through pinned integer projection and allocation-free 8x8-tiled affine filtering across byte and high-bit-depth planes. Exact traced native/presentation evidence, constrained allocation, and normal/scalar dispatch pass locally; the checkpoint awaits commit.
+  - [ ] **Queued until the local-warp commit:** decode non-translational global motion through reconstructed reference planes.
   - [ ] Verify every remaining connected inter mode and filter with independently encoded bounded AV1 content and exact native-plane comparisons.
 - [ ] 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.
@@ -819,8 +823,9 @@ The dashboard and immediate execution queue define the remaining critical path.
 - [x] Implement compound reference selection and equal averaging with paired reference-MV derivation, allocation-free SIMD/scalar parity, and exact independent native/presentation evidence through a reference-dependent bounded AVIF sequence. Commit `e1a764b8f2e8a8db98a003fb3b913213f40084db` records the checkpoint.
 - [x] Implement and independently verify selected inter-intra prediction and selectable distance-weighted, wedge, and difference-weighted compound blending through exact pinned native-plane and presentation comparisons, direct 8/10/12-bit production coverage, constrained allocation, and SIMD/scalar parity.
 - [x] Implement and independently verify OBMC through exact traced native-plane and presentation evidence, direct 8/10/12-bit and subsampled production coverage, constrained allocation, and normal/scalar dispatch. Commit `59a4fbad5ed3bc7c34331c4bdc65acc7acde3f04` records the checkpoint.
-- [x] Implement and independently verify scaled references through pinned fixed-point oracles, direct 8/10/12-bit production reconstruction, a genuine 40x40-to-80x80 bounded AVIF, exact retained-base/final-native/final-presentation comparisons, active inter deblocking, constrained allocation, and normal/scalar dispatch. The checkpoint is complete locally and awaiting its commit.
-- [ ] **Queued until that commit:** implement warped motion, then non-translational global prediction. Each mode requires independent exact evidence before the next begins.
+- [x] Implement and independently verify scaled references through pinned fixed-point oracles, direct 8/10/12-bit production reconstruction, a genuine 40x40-to-80x80 bounded AVIF, exact retained-base/final-native/final-presentation comparisons, active inter deblocking, constrained allocation, and normal/scalar dispatch. Commit `8f57c29b250b4291f034b31c1ea3de3fa3345467` records the checkpoint.
+- [x] Implement and independently verify local warped motion through pinned projection, direct 8/10/12-bit predictor coverage, a genuine traced two-frame bounded AVIF, exact final native and presentation comparisons, constrained allocation, and normal/scalar dispatch. The checkpoint is complete locally and awaiting commit.
+- [ ] **Queued until that commit:** implement non-translational global prediction with its own independent exact evidence.
 - [ ] Remove every other unsupported valid AV1 still-image syntax path, correct the audited 12-bit inverse-transform arithmetic, and prove the complete AVIF decode matrix with independent inputs and scalar/SIMD parity.
 - [ ] Close Phase 4 by completing the remaining HEVC profile and Range Extensions matrix with exact native-plane and presented-image evidence.
 - [ ] Close Phase 5 and the decode portion of the bounded sequence ledger: color, ICC, alpha, grids, presentation transforms, reference-dependent samples, and complete animated AVIF/HEIC decode.

src/ImageSharp/Formats/Heif/Av1/Motion/Av1GlobalMotionParameters.cs

@@ -37,6 +37,21 @@ internal struct Av1GlobalMotionParameters
     /// </summary>
     private const int ReciprocalIndexBits = 8;
 
+    /// <summary>
+    /// The largest difference between a retained neighbor motion vector and the current block motion vector.
+    /// </summary>
+    private const int LocalProjectionMotionVectorLimit = 256;
+
+    /// <summary>
+    /// The maximum magnitude of a non-diagonal affine coefficient relative to the identity matrix.
+    /// </summary>
+    private const int NonDiagonalAffineClamp = 1 << (ModelPrecisionBits - 3);
+
+    /// <summary>
+    /// The exclusive upper magnitude of either translation coefficient.
+    /// </summary>
+    private const int TranslationClamp = 128 << ModelPrecisionBits;
+
     /// <summary>
     /// The six parameters ordered as horizontal translation, vertical translation, and the four affine coefficients.
     /// </summary>
@@ -186,6 +201,151 @@ internal struct Av1GlobalMotionParameters
             forceInteger: forceIntegerMotionVector);
     }
 
+    /// <summary>
+    /// Derives the local affine model for a warped inter block from its spatial neighbor samples.
+    /// </summary>
+    /// <param name="sourcePoints">The neighbor-center positions relative to the current block in one-eighth-sample units.</param>
+    /// <param name="referencePoints">The corresponding positions in the selected reference frame.</param>
+    /// <param name="blockSize">The current coding block size.</param>
+    /// <param name="motionVector">The current block motion vector in one-eighth-sample units.</param>
+    /// <param name="modeInfoPosition">The current block origin in 4x4 mode-information units.</param>
+    /// <returns>The derived affine model, marked invalid when AV1's projection or shear constraints cannot be satisfied.</returns>
+    public static Av1GlobalMotionParameters DeriveLocalProjection(
+        ReadOnlySpan<Point> sourcePoints,
+        ReadOnlySpan<Point> referencePoints,
+        Av1BlockSize blockSize,
+        Av1MotionVector motionVector,
+        Point modeInfoPosition)
+    {
+        Av1GlobalMotionParameters result = Identity;
+        result.Type = Av1GlobalMotionType.Affine;
+
+        int blockWidth = blockSize.GetWidth();
+        int blockHeight = blockSize.GetHeight();
+        int sampleThreshold = Math.Clamp(Math.Max(blockWidth, blockHeight), 16, 112);
+        bool hasSelectedSample = sourcePoints.Length == 1;
+        if (sourcePoints.Length > 1)
+        {
+            for (int index = 0; index < sourcePoints.Length; index++)
+            {
+                int difference = Math.Abs(referencePoints[index].X - sourcePoints[index].X - motionVector.Column) +
+                    Math.Abs(referencePoints[index].Y - sourcePoints[index].Y - motionVector.Row);
+
+                hasSelectedSample |= difference <= sampleThreshold;
+            }
+        }
+
+        int sourceCenterX = ((blockWidth >> 1) - 1) << 3;
+        int sourceCenterY = ((blockHeight >> 1) - 1) << 3;
+        int referenceCenterX = sourceCenterX + motionVector.Column;
+        int referenceCenterY = sourceCenterY + motionVector.Row;
+        int a00 = 0;
+        int a01 = 0;
+        int a11 = 0;
+        int bx0 = 0;
+        int bx1 = 0;
+        int by0 = 0;
+        int by1 = 0;
+
+        for (int index = 0; index < sourcePoints.Length; index++)
+        {
+            int motionVectorDifference = Math.Abs(referencePoints[index].X - sourcePoints[index].X - motionVector.Column) +
+                Math.Abs(referencePoints[index].Y - sourcePoints[index].Y - motionVector.Row);
+
+            // av1_selectSamples retains the original first sample when every candidate exceeds the threshold. Keeping
+            // that rule here is important because the selected Warped syntax still requires a deterministic model.
+            if (sourcePoints.Length > 1 && motionVectorDifference > sampleThreshold && (hasSelectedSample || index != 0))
+            {
+                continue;
+            }
+
+            int sourceX = sourcePoints[index].X - sourceCenterX;
+            int sourceY = sourcePoints[index].Y - sourceCenterY;
+            int referenceX = referencePoints[index].X - referenceCenterX;
+            int referenceY = referencePoints[index].Y - referenceCenterY;
+            if (Math.Abs(sourceX - referenceX) >= LocalProjectionMotionVectorLimit ||
+                Math.Abs(sourceY - referenceY) >= LocalProjectionMotionVectorLimit)
+            {
+                continue;
+            }
+
+            // These biased products are the normative reduced-precision P'P, P'q, and P'r matrices. Computing them
+            // directly preserves libaom's integer least-squares rounding instead of introducing floating-point drift.
+            a00 += LeastSquaresSquare(sourceX);
+            a01 += LeastSquaresProduct1(sourceX, sourceY);
+            a11 += LeastSquaresSquare(sourceY);
+            bx0 += LeastSquaresProduct2(sourceX, referenceX);
+            bx1 += LeastSquaresProduct1(sourceY, referenceX);
+            by0 += LeastSquaresProduct1(sourceX, referenceY);
+            by1 += LeastSquaresProduct2(sourceY, referenceY);
+        }
+
+        long determinant = ((long)a00 * a11) - ((long)a01 * a01);
+        if (determinant == 0)
+        {
+            result.IsInvalid = true;
+            return result;
+        }
+
+        int inverseDeterminant = ResolveDivisor((ulong)Math.Abs(determinant), out int determinantShift) *
+            (determinant < 0 ? -1 : 1);
+
+        determinantShift -= ModelPrecisionBits;
+        if (determinantShift < 0)
+        {
+            inverseDeterminant <<= -determinantShift;
+            determinantShift = 0;
+        }
+
+        long projectionX0 = ((long)a11 * bx0) - ((long)a01 * bx1);
+        long projectionX1 = -((long)a01 * bx0) + ((long)a00 * bx1);
+        long projectionY0 = ((long)a11 * by0) - ((long)a01 * by1);
+        long projectionY1 = -((long)a01 * by0) + ((long)a00 * by1);
+
+        result.matrix[2] = ResolveProjectionCoefficient(
+            projectionX0,
+            inverseDeterminant,
+            determinantShift,
+            ModelScale - NonDiagonalAffineClamp + 1,
+            ModelScale + NonDiagonalAffineClamp - 1);
+
+        result.matrix[3] = ResolveProjectionCoefficient(
+            projectionX1,
+            inverseDeterminant,
+            determinantShift,
+            -NonDiagonalAffineClamp + 1,
+            NonDiagonalAffineClamp - 1);
+
+        result.matrix[4] = ResolveProjectionCoefficient(
+            projectionY0,
+            inverseDeterminant,
+            determinantShift,
+            -NonDiagonalAffineClamp + 1,
+            NonDiagonalAffineClamp - 1);
+
+        result.matrix[5] = ResolveProjectionCoefficient(
+            projectionY1,
+            inverseDeterminant,
+            determinantShift,
+            ModelScale - NonDiagonalAffineClamp + 1,
+            ModelScale + NonDiagonalAffineClamp - 1);
+
+        int absoluteCenterX = (modeInfoPosition.X << Av1Constants.ModeInfoSizeLog2) + (blockWidth >> 1) - 1;
+        int absoluteCenterY = (modeInfoPosition.Y << Av1Constants.ModeInfoSizeLog2) + (blockHeight >> 1) - 1;
+        int horizontalTranslation = (motionVector.Column << (ModelPrecisionBits - 3)) -
+            (absoluteCenterX * (result.matrix[2] - ModelScale)) -
+            (absoluteCenterY * result.matrix[3]);
+
+        int verticalTranslation = (motionVector.Row << (ModelPrecisionBits - 3)) -
+            (absoluteCenterX * result.matrix[4]) -
+            (absoluteCenterY * (result.matrix[5] - ModelScale));
+
+        result.matrix[0] = Math.Clamp(horizontalTranslation, -TranslationClamp, TranslationClamp - 1);
+        result.matrix[1] = Math.Clamp(verticalTranslation, -TranslationClamp, TranslationClamp - 1);
+        result.UpdateShearParameters();
+        return result;
+    }
+
     /// <summary>
     /// Derives the reduced shear parameters and records whether the complete affine model is valid.
     /// </summary>
@@ -259,6 +419,52 @@ internal struct Av1GlobalMotionParameters
         return ReciprocalTable[reciprocalIndex];
     }
 
+    /// <summary>
+    /// Resolves a positive 64-bit divisor into AV1's fixed-point reciprocal representation.
+    /// </summary>
+    /// <param name="divisor">The positive divisor.</param>
+    /// <param name="shift">Receives the reciprocal's binary scale.</param>
+    /// <returns>The fixed-point reciprocal multiplier.</returns>
+    private static int ResolveDivisor(ulong divisor, out int shift)
+    {
+        shift = BitOperations.Log2(divisor);
+        ulong remainder = divisor - (1UL << shift);
+        int reciprocalIndex = shift > ReciprocalIndexBits
+            ? (int)((remainder + (1UL << (shift - ReciprocalIndexBits - 1))) >> (shift - ReciprocalIndexBits))
+            : (int)(remainder << (ReciprocalIndexBits - shift));
+
+        shift += ReciprocalPrecisionBits;
+        return ReciprocalTable[reciprocalIndex];
+    }
+
+    /// <summary>
+    /// Resolves one adjugate numerator into a clamped affine matrix coefficient.
+    /// </summary>
+    private static int ResolveProjectionCoefficient(long numerator, int inverseDeterminant, int shift, int minimum, int maximum)
+    {
+        long product = numerator * inverseDeterminant;
+        long value = shift > 0 ? RoundPowerOf2Signed(product, shift) : product << -shift;
+        return (int)Math.Clamp(value, minimum, maximum);
+    }
+
+    /// <summary>
+    /// Computes one reduced-precision diagonal element of the local projection matrix.
+    /// </summary>
+    private static int LeastSquaresSquare(int value)
+        => ((value * value * 4) + (value * 32) + 128) >> 4;
+
+    /// <summary>
+    /// Computes one reduced-precision off-diagonal product of the local projection matrix.
+    /// </summary>
+    private static int LeastSquaresProduct1(int first, int second)
+        => ((first * second * 4) + ((first + second) * 16) + 64) >> 4;
+
+    /// <summary>
+    /// Computes one reduced-precision source-to-reference product of the local projection matrix.
+    /// </summary>
+    private static int LeastSquaresProduct2(int first, int second)
+        => ((first * second * 4) + ((first + second) * 16) + 128) >> 4;
+
     /// <summary>
     /// Divides a nonnegative integer by a power of two with nearest-integer rounding.
     /// </summary>

src/ImageSharp/Formats/Heif/Av1/Prediction/Inter/Av1InterPredictor.Warped.cs

@@ -0,0 +1,560 @@
+// Copyright (c) Six Labors.
+// Licensed under the Six Labors Split License.
+
+using System.Runtime.CompilerServices;
+using System.Runtime.InteropServices;
+using System.Runtime.Intrinsics;
+using SixLabors.ImageSharp.Formats.Heif.Av1.Motion;
+
+namespace SixLabors.ImageSharp.Formats.Heif.Av1.Prediction.Inter;
+
+/// <content>
+/// Reconstructs local and global affine warped-motion prediction blocks.
+/// </content>
+internal static partial class Av1InterPredictor
+{
+    /// <summary>
+    /// The number of rows in one warped filter's horizontal intermediate tile.
+    /// </summary>
+    private const int WarpedIntermediateRows = 15;
+
+    /// <summary>
+    /// The number of columns in one warped filter tile.
+    /// </summary>
+    private const int WarpedTileSize = 8;
+
+    /// <summary>
+    /// The number of low model bits removed when addressing the warped filter table.
+    /// </summary>
+    private const int WarpedDifferencePrecisionBits = 10;
+
+    /// <summary>
+    /// The number of fractional positions in one warped pixel.
+    /// </summary>
+    private const int WarpedPixelPrecisionShifts = 64;
+
+    /// <summary>
+    /// Gets the number of signed 16-bit elements required by warped prediction.
+    /// </summary>
+    public const int WarpedScratchLength = WarpedIntermediateRows * WarpedTileSize;
+
+    /// <summary>
+    /// Supplies the horizontal and vertical eight-tap dot products for one execution width.
+    /// </summary>
+    private interface IWarpedConvolution
+    {
+        /// <summary>
+        /// Convolves eight adjacent unsigned byte samples.
+        /// </summary>
+        /// <param name="source">The first source sample.</param>
+        /// <param name="coefficients">The first signed Q7 coefficient.</param>
+        /// <returns>The sum of the eight sample-coefficient products.</returns>
+        public static abstract int Convolve(ref byte source, ref short coefficients);
+
+        /// <summary>
+        /// Convolves eight adjacent unsigned high-bit-depth samples.
+        /// </summary>
+        /// <param name="source">The first source sample.</param>
+        /// <param name="coefficients">The first signed Q7 coefficient.</param>
+        /// <returns>The sum of the eight sample-coefficient products.</returns>
+        public static abstract int Convolve(ref ushort source, ref short coefficients);
+
+        /// <summary>
+        /// Convolves eight vertically strided unsigned intermediate samples.
+        /// </summary>
+        /// <param name="source">The first intermediate sample.</param>
+        /// <param name="stride">The distance between intermediate rows.</param>
+        /// <param name="coefficients">The first signed Q7 coefficient.</param>
+        /// <returns>The sum of the eight sample-coefficient products.</returns>
+        public static abstract int ConvolveVertical(ref ushort source, int stride, ref short coefficients);
+    }
+
+    /// <summary>
+    /// Reconstructs an 8-bit affine warped prediction using the widest supported convolution operator.
+    /// </summary>
+    public static void PredictWarped(
+        ReadOnlySpan<byte> source,
+        int sourceStride,
+        Point sourceOrigin,
+        int sourceWidth,
+        int sourceHeight,
+        Span<byte> destination,
+        int destinationStride,
+        Point destinationPosition,
+        int width,
+        int height,
+        int subsamplingX,
+        int subsamplingY,
+        Av1GlobalMotionParameters parameters,
+        Span<short> scratch)
+    {
+        if (Vector128.IsHardwareAccelerated)
+        {
+            PredictWarped<WarpedVector128Convolution>(
+                source,
+                sourceStride,
+                sourceOrigin,
+                sourceWidth,
+                sourceHeight,
+                destination,
+                destinationStride,
+                destinationPosition,
+                width,
+                height,
+                subsamplingX,
+                subsamplingY,
+                parameters,
+                scratch);
+
+            return;
+        }
+
+        PredictWarped<WarpedScalarConvolution>(
+            source,
+            sourceStride,
+            sourceOrigin,
+            sourceWidth,
+            sourceHeight,
+            destination,
+            destinationStride,
+            destinationPosition,
+            width,
+            height,
+            subsamplingX,
+            subsamplingY,
+            parameters,
+            scratch);
+    }
+
+    /// <summary>
+    /// Reconstructs a high-bit-depth affine warped prediction using the widest supported convolution operator.
+    /// </summary>
+    public static void PredictWarped(
+        ReadOnlySpan<ushort> source,
+        int sourceStride,
+        Point sourceOrigin,
+        int sourceWidth,
+        int sourceHeight,
+        Span<ushort> destination,
+        int destinationStride,
+        Point destinationPosition,
+        int width,
+        int height,
+        int subsamplingX,
+        int subsamplingY,
+        int bitDepth,
+        Av1GlobalMotionParameters parameters,
+        Span<short> scratch)
+    {
+        if (Vector128.IsHardwareAccelerated)
+        {
+            PredictWarped<WarpedVector128Convolution>(
+                source,
+                sourceStride,
+                sourceOrigin,
+                sourceWidth,
+                sourceHeight,
+                destination,
+                destinationStride,
+                destinationPosition,
+                width,
+                height,
+                subsamplingX,
+                subsamplingY,
+                bitDepth,
+                parameters,
+                scratch);
+
+            return;
+        }
+
+        PredictWarped<WarpedScalarConvolution>(
+            source,
+            sourceStride,
+            sourceOrigin,
+            sourceWidth,
+            sourceHeight,
+            destination,
+            destinationStride,
+            destinationPosition,
+            width,
+            height,
+            subsamplingX,
+            subsamplingY,
+            bitDepth,
+            parameters,
+            scratch);
+    }
+
+    /// <summary>
+    /// Reconstructs an 8-bit affine warped prediction without explicit hardware intrinsics.
+    /// </summary>
+    public static void PredictWarpedScalar(
+        ReadOnlySpan<byte> source,
+        int sourceStride,
+        Point sourceOrigin,
+        int sourceWidth,
+        int sourceHeight,
+        Span<byte> destination,
+        int destinationStride,
+        Point destinationPosition,
+        int width,
+        int height,
+        int subsamplingX,
+        int subsamplingY,
+        Av1GlobalMotionParameters parameters,
+        Span<short> scratch)
+        => PredictWarped<WarpedScalarConvolution>(
+            source,
+            sourceStride,
+            sourceOrigin,
+            sourceWidth,
+            sourceHeight,
+            destination,
+            destinationStride,
+            destinationPosition,
+            width,
+            height,
+            subsamplingX,
+            subsamplingY,
+            parameters,
+            scratch);
+
+    /// <summary>
+    /// Reconstructs a high-bit-depth affine warped prediction without explicit hardware intrinsics.
+    /// </summary>
+    public static void PredictWarpedScalar(
+        ReadOnlySpan<ushort> source,
+        int sourceStride,
+        Point sourceOrigin,
+        int sourceWidth,
+        int sourceHeight,
+        Span<ushort> destination,
+        int destinationStride,
+        Point destinationPosition,
+        int width,
+        int height,
+        int subsamplingX,
+        int subsamplingY,
+        int bitDepth,
+        Av1GlobalMotionParameters parameters,
+        Span<short> scratch)
+        => PredictWarped<WarpedScalarConvolution>(
+            source,
+            sourceStride,
+            sourceOrigin,
+            sourceWidth,
+            sourceHeight,
+            destination,
+            destinationStride,
+            destinationPosition,
+            width,
+            height,
+            subsamplingX,
+            subsamplingY,
+            bitDepth,
+            parameters,
+            scratch);
+
+    /// <summary>
+    /// Reconstructs one 8-bit warped block through a closed convolution operator.
+    /// </summary>
+    private static void PredictWarped<TConvolution>(
+        ReadOnlySpan<byte> source,
+        int sourceStride,
+        Point sourceOrigin,
+        int sourceWidth,
+        int sourceHeight,
+        Span<byte> destination,
+        int destinationStride,
+        Point destinationPosition,
+        int width,
+        int height,
+        int subsamplingX,
+        int subsamplingY,
+        Av1GlobalMotionParameters parameters,
+        Span<short> scratch)
+        where TConvolution : struct, IWarpedConvolution
+    {
+        ref byte sourceBase = ref MemoryMarshal.GetReference(source);
+        ref byte destinationBase = ref MemoryMarshal.GetReference(destination);
+        Span<ushort> intermediate = MemoryMarshal.Cast<short, ushort>(scratch)[..WarpedScratchLength];
+        int horizontalBias = 1 << (8 + FilterBits - 1);
+        int verticalBias = 1 << (8 + (2 * FilterBits) - Round0Bits);
+        int verticalRound = (2 * FilterBits) - Round0Bits;
+
+        for (int tileRow = destinationPosition.Y; tileRow < destinationPosition.Y + height; tileRow += WarpedTileSize)
+        {
+            for (int tileColumn = destinationPosition.X; tileColumn < destinationPosition.X + width; tileColumn += WarpedTileSize)
+            {
+                DeriveWarpedTilePosition(
+                    parameters,
+                    tileColumn,
+                    tileRow,
+                    subsamplingX,
+                    subsamplingY,
+                    out int integerX,
+                    out int integerY,
+                    out int phaseX,
+                    out int phaseY);
+
+                for (int row = -7; row < 8; row++)
+                {
+                    int sourceY = Math.Clamp(integerY + row, 0, sourceHeight - 1);
+                    int phase = phaseX + (parameters.Beta * (row + 4));
+                    for (int column = -4; column < 4; column++)
+                    {
+                        int sourceX = integerX + column - 3;
+                        int sourceIndex = ((sourceOrigin.Y + sourceY) * sourceStride) + sourceOrigin.X + sourceX;
+                        ref short coefficients = ref GetWarpedFilterReference(phase);
+                        int sum = horizontalBias + TConvolution.Convolve(ref Unsafe.Add(ref sourceBase, sourceIndex), ref coefficients);
+                        intermediate[((row + 7) * WarpedTileSize) + column + 4] = (ushort)RoundPowerOfTwoScalar(sum, Round0Bits);
+                        phase += parameters.Alpha;
+                    }
+                }
+
+                int tileHeight = Math.Min(WarpedTileSize, destinationPosition.Y + height - tileRow);
+                int tileWidth = Math.Min(WarpedTileSize, destinationPosition.X + width - tileColumn);
+                for (int row = 0; row < tileHeight; row++)
+                {
+                    int phase = phaseY + (parameters.Delta * row);
+                    int destinationRowOffset = (tileRow - destinationPosition.Y + row) * destinationStride;
+                    for (int column = 0; column < tileWidth; column++)
+                    {
+                        ref ushort intermediateSource = ref intermediate[(row * WarpedTileSize) + column];
+                        ref short coefficients = ref GetWarpedFilterReference(phase);
+                        int sum = verticalBias + TConvolution.ConvolveVertical(ref intermediateSource, WarpedTileSize, ref coefficients);
+                        int value = RoundPowerOfTwoScalar(sum, verticalRound) - (1 << 7) - (1 << 8);
+                        Unsafe.Add(ref destinationBase, destinationRowOffset + tileColumn - destinationPosition.X + column) =
+                            (byte)Math.Clamp(value, byte.MinValue, byte.MaxValue);
+
+                        phase += parameters.Gamma;
+                    }
+                }
+            }
+        }
+    }
+
+    /// <summary>
+    /// Reconstructs one high-bit-depth warped block through a closed convolution operator.
+    /// </summary>
+    private static void PredictWarped<TConvolution>(
+        ReadOnlySpan<ushort> source,
+        int sourceStride,
+        Point sourceOrigin,
+        int sourceWidth,
+        int sourceHeight,
+        Span<ushort> destination,
+        int destinationStride,
+        Point destinationPosition,
+        int width,
+        int height,
+        int subsamplingX,
+        int subsamplingY,
+        int bitDepth,
+        Av1GlobalMotionParameters parameters,
+        Span<short> scratch)
+        where TConvolution : struct, IWarpedConvolution
+    {
+        ref ushort sourceBase = ref MemoryMarshal.GetReference(source);
+        ref ushort destinationBase = ref MemoryMarshal.GetReference(destination);
+        Span<ushort> intermediate = MemoryMarshal.Cast<short, ushort>(scratch)[..WarpedScratchLength];
+
+        // Twelve-bit prediction increases round0 by two so the biased horizontal intermediate remains representable
+        // in sixteen bits. Reducing round1 by the same amount preserves the complete normative Q14 shift.
+        int intermediateRange = bitDepth + FilterBits - Round0Bits + 2;
+        int round0 = Round0Bits + Math.Max(intermediateRange - 16, 0);
+        int verticalRound = (2 * FilterBits) - round0;
+        int horizontalBias = 1 << (bitDepth + FilterBits - 1);
+        int verticalBias = 1 << (bitDepth + (2 * FilterBits) - round0);
+        int maximum = (1 << bitDepth) - 1;
+
+        for (int tileRow = destinationPosition.Y; tileRow < destinationPosition.Y + height; tileRow += WarpedTileSize)
+        {
+            for (int tileColumn = destinationPosition.X; tileColumn < destinationPosition.X + width; tileColumn += WarpedTileSize)
+            {
+                DeriveWarpedTilePosition(
+                    parameters,
+                    tileColumn,
+                    tileRow,
+                    subsamplingX,
+                    subsamplingY,
+                    out int integerX,
+                    out int integerY,
+                    out int phaseX,
+                    out int phaseY);
+
+                for (int row = -7; row < 8; row++)
+                {
+                    int sourceY = Math.Clamp(integerY + row, 0, sourceHeight - 1);
+                    int phase = phaseX + (parameters.Beta * (row + 4));
+                    for (int column = -4; column < 4; column++)
+                    {
+                        int sourceX = integerX + column - 3;
+                        int sourceIndex = ((sourceOrigin.Y + sourceY) * sourceStride) + sourceOrigin.X + sourceX;
+                        ref short coefficients = ref GetWarpedFilterReference(phase);
+                        int sum = horizontalBias + TConvolution.Convolve(ref Unsafe.Add(ref sourceBase, sourceIndex), ref coefficients);
+                        intermediate[((row + 7) * WarpedTileSize) + column + 4] = (ushort)RoundPowerOfTwoScalar(sum, round0);
+                        phase += parameters.Alpha;
+                    }
+                }
+
+                int tileHeight = Math.Min(WarpedTileSize, destinationPosition.Y + height - tileRow);
+                int tileWidth = Math.Min(WarpedTileSize, destinationPosition.X + width - tileColumn);
+                for (int row = 0; row < tileHeight; row++)
+                {
+                    int phase = phaseY + (parameters.Delta * row);
+                    int destinationRowOffset = (tileRow - destinationPosition.Y + row) * destinationStride;
+                    for (int column = 0; column < tileWidth; column++)
+                    {
+                        ref ushort intermediateSource = ref intermediate[(row * WarpedTileSize) + column];
+                        ref short coefficients = ref GetWarpedFilterReference(phase);
+                        int sum = verticalBias + TConvolution.ConvolveVertical(ref intermediateSource, WarpedTileSize, ref coefficients);
+                        int value = RoundPowerOfTwoScalar(sum, verticalRound) - (1 << (bitDepth - 1)) - (1 << bitDepth);
+                        Unsafe.Add(ref destinationBase, destinationRowOffset + tileColumn - destinationPosition.X + column) =
+                            (ushort)Math.Clamp(value, 0, maximum);
+
+                        phase += parameters.Gamma;
+                    }
+                }
+            }
+        }
+    }
+
+    /// <summary>
+    /// Projects the center of one 8x8 output tile and derives its integer source position and reduced phases.
+    /// </summary>
+    private static void DeriveWarpedTilePosition(
+        Av1GlobalMotionParameters parameters,
+        int tileColumn,
+        int tileRow,
+        int subsamplingX,
+        int subsamplingY,
+        out int integerX,
+        out int integerY,
+        out int phaseX,
+        out int phaseY)
+    {
+        int sourceX = (tileColumn + 4) << subsamplingX;
+        int sourceY = (tileRow + 4) << subsamplingY;
+        long projectedX = ((long)parameters[2] * sourceX) + ((long)parameters[3] * sourceY) + parameters[0];
+        long projectedY = ((long)parameters[4] * sourceX) + ((long)parameters[5] * sourceY) + parameters[1];
+        long planeX = projectedX >> subsamplingX;
+        long planeY = projectedY >> subsamplingY;
+        integerX = (int)(planeX >> Av1GlobalMotionParameters.ModelPrecisionBits);
+        integerY = (int)(planeY >> Av1GlobalMotionParameters.ModelPrecisionBits);
+        phaseX = (int)planeX & (Av1GlobalMotionParameters.ModelScale - 1);
+        phaseY = (int)planeY & (Av1GlobalMotionParameters.ModelScale - 1);
+        phaseX += (-4 * parameters.Alpha) + (-4 * parameters.Beta);
+        phaseY += (-4 * parameters.Gamma) + (-4 * parameters.Delta);
+
+        // Shear parameters are quantized to 64-model-unit steps. Clearing the same low bits after the tile-center
+        // projection keeps negative and positive phases on the exact filter-table grid used by the bitstream model.
+        phaseX &= -1 << 6;
+        phaseY &= -1 << 6;
+    }
+
+    /// <summary>
+    /// Gets a reference to the first coefficient for one reduced warped-filter phase.
+    /// </summary>
+    private static ref short GetWarpedFilterReference(int phase)
+    {
+        int filterIndex = ((phase + (1 << (WarpedDifferencePrecisionBits - 1))) >> WarpedDifferencePrecisionBits) +
+            WarpedPixelPrecisionShifts;
+
+        return ref Unsafe.Add(ref MemoryMarshal.GetReference(WarpedFilter), filterIndex * FilterCoefficientCount);
+    }
+
+    /// <summary>
+    /// Divides a nonnegative value by a power of two with nearest-integer rounding.
+    /// </summary>
+    private static int RoundPowerOfTwoScalar(int value, int bitCount)
+        => (value + (1 << (bitCount - 1))) >> bitCount;
+
+    /// <summary>
+    /// Executes warped dot products with portable 128-bit SIMD.
+    /// </summary>
+    private readonly struct WarpedVector128Convolution : IWarpedConvolution
+    {
+        /// <inheritdoc/>
+        public static int Convolve(ref byte source, ref short coefficients)
+        {
+            Vector128<byte> packed = Vector128.LoadUnsafe(ref source);
+            (Vector128<ushort> samples, _) = Vector128.Widen(packed);
+            return MultiplyAndSum(samples, Vector128.LoadUnsafe(ref coefficients));
+        }
+
+        /// <inheritdoc/>
+        public static int Convolve(ref ushort source, ref short coefficients)
+            => MultiplyAndSum(Vector128.LoadUnsafe(ref source), Vector128.LoadUnsafe(ref coefficients));
+
+        /// <inheritdoc/>
+        public static int ConvolveVertical(ref ushort source, int stride, ref short coefficients)
+        {
+            Vector128<ushort> samples = Vector128.Create(
+                source,
+                Unsafe.Add(ref source, stride),
+                Unsafe.Add(ref source, stride * 2),
+                Unsafe.Add(ref source, stride * 3),
+                Unsafe.Add(ref source, stride * 4),
+                Unsafe.Add(ref source, stride * 5),
+                Unsafe.Add(ref source, stride * 6),
+                Unsafe.Add(ref source, stride * 7));
+
+            return MultiplyAndSum(samples, Vector128.LoadUnsafe(ref coefficients));
+        }
+
+        /// <summary>
+        /// Widens unsigned samples and signed coefficients before accumulating their exact 32-bit products.
+        /// </summary>
+        private static int MultiplyAndSum(Vector128<ushort> samples, Vector128<short> coefficients)
+        {
+            (Vector128<uint> sampleLower, Vector128<uint> sampleUpper) = Vector128.Widen(samples);
+            (Vector128<int> coefficientLower, Vector128<int> coefficientUpper) = Vector128.Widen(coefficients);
+            return Vector128.Sum(sampleLower.AsInt32() * coefficientLower) +
+                Vector128.Sum(sampleUpper.AsInt32() * coefficientUpper);
+        }
+    }
+
+    /// <summary>
+    /// Executes warped dot products without explicit hardware intrinsics.
+    /// </summary>
+    private readonly struct WarpedScalarConvolution : IWarpedConvolution
+    {
+        /// <inheritdoc/>
+        public static int Convolve(ref byte source, ref short coefficients)
+        {
+            int sum = 0;
+            for (nuint index = 0; index < FilterCoefficientCount; index++)
+            {
+                sum += Unsafe.Add(ref source, index) * Unsafe.Add(ref coefficients, index);
+            }
+
+            return sum;
+        }
+
+        /// <inheritdoc/>
+        public static int Convolve(ref ushort source, ref short coefficients)
+        {
+            int sum = 0;
+            for (nuint index = 0; index < FilterCoefficientCount; index++)
+            {
+                sum += Unsafe.Add(ref source, index) * Unsafe.Add(ref coefficients, index);
+            }
+
+            return sum;
+        }
+
+        /// <inheritdoc/>
+        public static int ConvolveVertical(ref ushort source, int stride, ref short coefficients)
+        {
+            int sum = 0;
+            for (int index = 0; index < FilterCoefficientCount; index++)
+            {
+                sum += Unsafe.Add(ref source, index * stride) * Unsafe.Add(ref coefficients, index);
+            }
+
+            return sum;
+        }
+    }
+}

src/ImageSharp/Formats/Heif/Av1/Prediction/Inter/Av1InterPredictor.WarpedFilters.cs

@@ -0,0 +1,210 @@
+// Copyright (c) Six Labors.
+// Licensed under the Six Labors Split License.
+
+namespace SixLabors.ImageSharp.Formats.Heif.Av1.Prediction.Inter;
+
+/// <content>
+/// Provides the normative Q7 filter kernels for affine warped-motion prediction.
+/// </content>
+internal static partial class Av1InterPredictor
+{
+    /// <summary>
+    /// Gets the 193 consecutive eight-tap warped-filter phases spanning fractional positions [-1, 2].
+    /// </summary>
+    private static ReadOnlySpan<short> WarpedFilter =>
+    [
+        0, 0, 127, 1, 0, 0, 0, 0,
+        0, -1, 127, 2, 0, 0, 0, 0,
+        1, -3, 127, 4, -1, 0, 0, 0,
+        1, -4, 126, 6, -2, 1, 0, 0,
+        1, -5, 126, 8, -3, 1, 0, 0,
+        1, -6, 125, 11, -4, 1, 0, 0,
+        1, -7, 124, 13, -4, 1, 0, 0,
+        2, -8, 123, 15, -5, 1, 0, 0,
+        2, -9, 122, 18, -6, 1, 0, 0,
+        2, -10, 121, 20, -6, 1, 0, 0,
+        2, -11, 120, 22, -7, 2, 0, 0,
+        2, -12, 119, 25, -8, 2, 0, 0,
+        3, -13, 117, 27, -8, 2, 0, 0,
+        3, -13, 116, 29, -9, 2, 0, 0,
+        3, -14, 114, 32, -10, 3, 0, 0,
+        3, -15, 113, 35, -10, 2, 0, 0,
+        3, -15, 111, 37, -11, 3, 0, 0,
+        3, -16, 109, 40, -11, 3, 0, 0,
+        3, -16, 108, 42, -12, 3, 0, 0,
+        4, -17, 106, 45, -13, 3, 0, 0,
+        4, -17, 104, 47, -13, 3, 0, 0,
+        4, -17, 102, 50, -14, 3, 0, 0,
+        4, -17, 100, 52, -14, 3, 0, 0,
+        4, -18, 98, 55, -15, 4, 0, 0,
+        4, -18, 96, 58, -15, 3, 0, 0,
+        4, -18, 94, 60, -16, 4, 0, 0,
+        4, -18, 91, 63, -16, 4, 0, 0,
+        4, -18, 89, 65, -16, 4, 0, 0,
+        4, -18, 87, 68, -17, 4, 0, 0,
+        4, -18, 85, 70, -17, 4, 0, 0,
+        4, -18, 82, 73, -17, 4, 0, 0,
+        4, -18, 80, 75, -17, 4, 0, 0,
+        4, -18, 78, 78, -18, 4, 0, 0,
+        4, -17, 75, 80, -18, 4, 0, 0,
+        4, -17, 73, 82, -18, 4, 0, 0,
+        4, -17, 70, 85, -18, 4, 0, 0,
+        4, -17, 68, 87, -18, 4, 0, 0,
+        4, -16, 65, 89, -18, 4, 0, 0,
+        4, -16, 63, 91, -18, 4, 0, 0,
+        4, -16, 60, 94, -18, 4, 0, 0,
+        3, -15, 58, 96, -18, 4, 0, 0,
+        4, -15, 55, 98, -18, 4, 0, 0,
+        3, -14, 52, 100, -17, 4, 0, 0,
+        3, -14, 50, 102, -17, 4, 0, 0,
+        3, -13, 47, 104, -17, 4, 0, 0,
+        3, -13, 45, 106, -17, 4, 0, 0,
+        3, -12, 42, 108, -16, 3, 0, 0,
+        3, -11, 40, 109, -16, 3, 0, 0,
+        3, -11, 37, 111, -15, 3, 0, 0,
+        2, -10, 35, 113, -15, 3, 0, 0,
+        3, -10, 32, 114, -14, 3, 0, 0,
+        2, -9, 29, 116, -13, 3, 0, 0,
+        2, -8, 27, 117, -13, 3, 0, 0,
+        2, -8, 25, 119, -12, 2, 0, 0,
+        2, -7, 22, 120, -11, 2, 0, 0,
+        1, -6, 20, 121, -10, 2, 0, 0,
+        1, -6, 18, 122, -9, 2, 0, 0,
+        1, -5, 15, 123, -8, 2, 0, 0,
+        1, -4, 13, 124, -7, 1, 0, 0,
+        1, -4, 11, 125, -6, 1, 0, 0,
+        1, -3, 8, 126, -5, 1, 0, 0,
+        1, -2, 6, 126, -4, 1, 0, 0,
+        0, -1, 4, 127, -3, 1, 0, 0,
+        0, 0, 2, 127, -1, 0, 0, 0,
+        0, 0, 0, 127, 1, 0, 0, 0,
+        0, 0, -1, 127, 2, 0, 0, 0,
+        0, 1, -3, 127, 4, -2, 1, 0,
+        0, 1, -5, 127, 6, -2, 1, 0,
+        0, 2, -6, 126, 8, -3, 1, 0,
+        -1, 2, -7, 126, 11, -4, 2, -1,
+        -1, 3, -8, 125, 13, -5, 2, -1,
+        -1, 3, -10, 124, 16, -6, 3, -1,
+        -1, 4, -11, 123, 18, -7, 3, -1,
+        -1, 4, -12, 122, 20, -7, 3, -1,
+        -1, 4, -13, 121, 23, -8, 3, -1,
+        -2, 5, -14, 120, 25, -9, 4, -1,
+        -1, 5, -15, 119, 27, -10, 4, -1,
+        -1, 5, -16, 118, 30, -11, 4, -1,
+        -2, 6, -17, 116, 33, -12, 5, -1,
+        -2, 6, -17, 114, 35, -12, 5, -1,
+        -2, 6, -18, 113, 38, -13, 5, -1,
+        -2, 7, -19, 111, 41, -14, 6, -2,
+        -2, 7, -19, 110, 43, -15, 6, -2,
+        -2, 7, -20, 108, 46, -15, 6, -2,
+        -2, 7, -20, 106, 49, -16, 6, -2,
+        -2, 7, -21, 104, 51, -16, 7, -2,
+        -2, 7, -21, 102, 54, -17, 7, -2,
+        -2, 8, -21, 100, 56, -18, 7, -2,
+        -2, 8, -22, 98, 59, -18, 7, -2,
+        -2, 8, -22, 96, 62, -19, 7, -2,
+        -2, 8, -22, 94, 64, -19, 7, -2,
+        -2, 8, -22, 91, 67, -20, 8, -2,
+        -2, 8, -22, 89, 69, -20, 8, -2,
+        -2, 8, -22, 87, 72, -21, 8, -2,
+        -2, 8, -21, 84, 74, -21, 8, -2,
+        -2, 8, -22, 82, 77, -21, 8, -2,
+        -2, 8, -21, 79, 79, -21, 8, -2,
+        -2, 8, -21, 77, 82, -22, 8, -2,
+        -2, 8, -21, 74, 84, -21, 8, -2,
+        -2, 8, -21, 72, 87, -22, 8, -2,
+        -2, 8, -20, 69, 89, -22, 8, -2,
+        -2, 8, -20, 67, 91, -22, 8, -2,
+        -2, 7, -19, 64, 94, -22, 8, -2,
+        -2, 7, -19, 62, 96, -22, 8, -2,
+        -2, 7, -18, 59, 98, -22, 8, -2,
+        -2, 7, -18, 56, 100, -21, 8, -2,
+        -2, 7, -17, 54, 102, -21, 7, -2,
+        -2, 7, -16, 51, 104, -21, 7, -2,
+        -2, 6, -16, 49, 106, -20, 7, -2,
+        -2, 6, -15, 46, 108, -20, 7, -2,
+        -2, 6, -15, 43, 110, -19, 7, -2,
+        -2, 6, -14, 41, 111, -19, 7, -2,
+        -1, 5, -13, 38, 113, -18, 6, -2,
+        -1, 5, -12, 35, 114, -17, 6, -2,
+        -1, 5, -12, 33, 116, -17, 6, -2,
+        -1, 4, -11, 30, 118, -16, 5, -1,
+        -1, 4, -10, 27, 119, -15, 5, -1,
+        -1, 4, -9, 25, 120, -14, 5, -2,
+        -1, 3, -8, 23, 121, -13, 4, -1,
+        -1, 3, -7, 20, 122, -12, 4, -1,
+        -1, 3, -7, 18, 123, -11, 4, -1,
+        -1, 3, -6, 16, 124, -10, 3, -1,
+        -1, 2, -5, 13, 125, -8, 3, -1,
+        -1, 2, -4, 11, 126, -7, 2, -1,
+        0, 1, -3, 8, 126, -6, 2, 0,
+        0, 1, -2, 6, 127, -5, 1, 0,
+        0, 1, -2, 4, 127, -3, 1, 0,
+        0, 0, 0, 2, 127, -1, 0, 0,
+        0, 0, 0, 1, 127, 0, 0, 0,
+        0, 0, 0, -1, 127, 2, 0, 0,
+        0, 0, 1, -3, 127, 4, -1, 0,
+        0, 0, 1, -4, 126, 6, -2, 1,
+        0, 0, 1, -5, 126, 8, -3, 1,
+        0, 0, 1, -6, 125, 11, -4, 1,
+        0, 0, 1, -7, 124, 13, -4, 1,
+        0, 0, 2, -8, 123, 15, -5, 1,
+        0, 0, 2, -9, 122, 18, -6, 1,
+        0, 0, 2, -10, 121, 20, -6, 1,
+        0, 0, 2, -11, 120, 22, -7, 2,
+        0, 0, 2, -12, 119, 25, -8, 2,
+        0, 0, 3, -13, 117, 27, -8, 2,
+        0, 0, 3, -13, 116, 29, -9, 2,
+        0, 0, 3, -14, 114, 32, -10, 3,
+        0, 0, 3, -15, 113, 35, -10, 2,
+        0, 0, 3, -15, 111, 37, -11, 3,
+        0, 0, 3, -16, 109, 40, -11, 3,
+        0, 0, 3, -16, 108, 42, -12, 3,
+        0, 0, 4, -17, 106, 45, -13, 3,
+        0, 0, 4, -17, 104, 47, -13, 3,
+        0, 0, 4, -17, 102, 50, -14, 3,
+        0, 0, 4, -17, 100, 52, -14, 3,
+        0, 0, 4, -18, 98, 55, -15, 4,
+        0, 0, 4, -18, 96, 58, -15, 3,
+        0, 0, 4, -18, 94, 60, -16, 4,
+        0, 0, 4, -18, 91, 63, -16, 4,
+        0, 0, 4, -18, 89, 65, -16, 4,
+        0, 0, 4, -18, 87, 68, -17, 4,
+        0, 0, 4, -18, 85, 70, -17, 4,
+        0, 0, 4, -18, 82, 73, -17, 4,
+        0, 0, 4, -18, 80, 75, -17, 4,
+        0, 0, 4, -18, 78, 78, -18, 4,
+        0, 0, 4, -17, 75, 80, -18, 4,
+        0, 0, 4, -17, 73, 82, -18, 4,
+        0, 0, 4, -17, 70, 85, -18, 4,
+        0, 0, 4, -17, 68, 87, -18, 4,
+        0, 0, 4, -16, 65, 89, -18, 4,
+        0, 0, 4, -16, 63, 91, -18, 4,
+        0, 0, 4, -16, 60, 94, -18, 4,
+        0, 0, 3, -15, 58, 96, -18, 4,
+        0, 0, 4, -15, 55, 98, -18, 4,
+        0, 0, 3, -14, 52, 100, -17, 4,
+        0, 0, 3, -14, 50, 102, -17, 4,
+        0, 0, 3, -13, 47, 104, -17, 4,
+        0, 0, 3, -13, 45, 106, -17, 4,
+        0, 0, 3, -12, 42, 108, -16, 3,
+        0, 0, 3, -11, 40, 109, -16, 3,
+        0, 0, 3, -11, 37, 111, -15, 3,
+        0, 0, 2, -10, 35, 113, -15, 3,
+        0, 0, 3, -10, 32, 114, -14, 3,
+        0, 0, 2, -9, 29, 116, -13, 3,
+        0, 0, 2, -8, 27, 117, -13, 3,
+        0, 0, 2, -8, 25, 119, -12, 2,
+        0, 0, 2, -7, 22, 120, -11, 2,
+        0, 0, 1, -6, 20, 121, -10, 2,
+        0, 0, 1, -6, 18, 122, -9, 2,
+        0, 0, 1, -5, 15, 123, -8, 2,
+        0, 0, 1, -4, 13, 124, -7, 1,
+        0, 0, 1, -4, 11, 125, -6, 1,
+        0, 0, 1, -3, 8, 126, -5, 1,
+        0, 0, 1, -2, 6, 126, -4, 1,
+        0, 0, 0, -1, 4, 127, -3, 1,
+        0, 0, 0, 0, 2, 127, -1, 0,
+        0, 0, 0, 0, 2, 127, -1, 0,
+    ];
+}

src/ImageSharp/Formats/Heif/Av1/Tiling/Av1BlockModeInfo.cs

@@ -156,6 +156,11 @@ internal class Av1BlockModeInfo
     /// </summary>
     public Av1MotionMode MotionMode { get; set; }
 
+    /// <summary>
+    /// Gets or sets the affine model derived for local warped prediction.
+    /// </summary>
+    public Av1GlobalMotionParameters WarpedMotionParameters { get; set; }
+
     /// <summary>
     /// Gets or sets the intra predictor blended with a single-reference inter predictor.
     /// </summary>

src/ImageSharp/Formats/Heif/Av1/Tiling/Av1TileReader.cs

@@ -2076,7 +2076,12 @@ internal sealed class Av1TileReader : IAv1TileReader, IDisposable
                     modeInfo.MotionMode = reader.ReadMotionMode(modeInfo.BlockSize, allowWarpedMotion);
                     if (modeInfo.MotionMode == Av1MotionMode.Warped)
                     {
-                        throw new NotSupportedException($"AV1 {modeInfo.MotionMode} block prediction is not implemented.");
+                        modeInfo.WarpedMotionParameters = Av1GlobalMotionParameters.DeriveLocalProjection(
+                            candidates.SourcePoints,
+                            candidates.ReferencePoints,
+                            modeInfo.BlockSize,
+                            motionVectors[0],
+                            new Point(partitionInfo.ColumnIndex, partitionInfo.RowIndex));
                     }
                 }
             }

src/ImageSharp/Formats/Heif/Av1/Transform/Av1BlockDecoder.cs

@@ -370,6 +370,70 @@ internal sealed class Av1BlockDecoder : IDisposable
                     bool isScaledReference = activeReferenceFrameBuffer.Width != this.frameHeader.FrameSize.FrameWidth ||
                         activeReferenceFrameBuffer.Height != this.frameHeader.FrameSize.FrameHeight;
 
+                    if (referenceIndex == 0 &&
+                        modeInfo.MotionMode == Av1MotionMode.Warped &&
+                        !modeInfo.WarpedMotionParameters.IsInvalid)
+                    {
+                        int referencePlaneWidth = Av1Math.DivideLog2Ceiling(activeReferenceFrameBuffer.Width, subX);
+                        int referencePlaneHeight = Av1Math.DivideLog2Ceiling(activeReferenceFrameBuffer.Height, subY);
+                        if (highBitDepth)
+                        {
+                            Span<ushort> source = activeReferenceFrameBuffer.GetPaddedPlaneSpan16(
+                                (Av1Plane)plane,
+                                subX,
+                                subY,
+                                out int sourceStride,
+                                out Point sourceOrigin);
+
+                            Span<ushort> destination = MemoryMarshal.Cast<short, ushort>(
+                                highBitDepthBlockReconstructionBuffer[reconstructionStride..]);
+
+                            Av1InterPredictor.PredictWarped(
+                                source,
+                                sourceStride,
+                                sourceOrigin,
+                                referencePlaneWidth,
+                                referencePlaneHeight,
+                                destination,
+                                reconstructionStride,
+                                pixelPosition,
+                                predictionWidth,
+                                predictionHeight,
+                                subX,
+                                subY,
+                                this.frameBuffer.BitDepth.GetBitCount(),
+                                modeInfo.WarpedMotionParameters,
+                                predictionScratch);
+                        }
+                        else
+                        {
+                            Span<byte> source = activeReferenceFrameBuffer.GetPaddedPlaneSpan(
+                                (Av1Plane)plane,
+                                subX,
+                                subY,
+                                out int sourceStride,
+                                out Point sourceOrigin);
+
+                            Av1InterPredictor.PredictWarped(
+                                source,
+                                sourceStride,
+                                sourceOrigin,
+                                referencePlaneWidth,
+                                referencePlaneHeight,
+                                blockReconstructionBuffer[reconstructionStride..],
+                                reconstructionStride,
+                                pixelPosition,
+                                predictionWidth,
+                                predictionHeight,
+                                subX,
+                                subY,
+                                modeInfo.WarpedMotionParameters,
+                                predictionScratch);
+                        }
+
+                        continue;
+                    }
+
                     if (isScaledReference)
                     {
                         Span<byte> scaledDestination = default;

tests/ImageSharp.Tests/Formats/Heif/Av1/Av1GlobalMotionParametersTests.cs

@@ -82,4 +82,34 @@ public class Av1GlobalMotionParametersTests
 
         Assert.Equal(new Av1MotionVector(expectedRow, expectedColumn), actual);
     }
+
+    /// <summary>
+    /// Verifies local least-squares projection against a multi-sample model traced from pinned libaom.
+    /// </summary>
+    [Fact]
+    public void LocalProjectionMatchesPinnedLibaomMultiSampleModel()
+    {
+        Point[] sourcePoints = [new(24, -40), new(-40, 24), new(-24, -24), new(72, -24)];
+        Point[] referencePoints = [new(-16, -8), new(-72, 64), new(-64, 16), new(32, 8)];
+
+        Av1GlobalMotionParameters parameters = Av1GlobalMotionParameters.DeriveLocalProjection(
+            sourcePoints,
+            referencePoints,
+            Av1BlockSize.Block8x8,
+            new Av1MotionVector(32, -40),
+            new Point(8, 6));
+
+        Assert.Equal(Av1GlobalMotionType.Affine, parameters.Type);
+        Assert.False(parameters.IsInvalid);
+        Assert.Equal(-191565, parameters[0]);
+        Assert.Equal(599107, parameters[1]);
+        Assert.Equal(61755, parameters[2]);
+        Assert.Equal(-140, parameters[3]);
+        Assert.Equal(-6909, parameters[4]);
+        Assert.Equal(62012, parameters[5]);
+        Assert.Equal(-3776, parameters.Alpha);
+        Assert.Equal(-128, parameters.Beta);
+        Assert.Equal(-7360, parameters.Gamma);
+        Assert.Equal(-3520, parameters.Delta);
+    }
 }

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

@@ -193,6 +193,11 @@ public class Av1ReconstructionConformanceTests
     /// </summary>
     private const int ObmcCoverage = 1 << 7;
 
+    /// <summary>
+    /// The coverage bit representing local warped-motion prediction.
+    /// </summary>
+    private const int LocalWarpCoverage = 1 << 8;
+
     /// <summary>
     /// The hardware configurations covering the available vector widths and the scalar color-conversion fallback.
     /// </summary>
@@ -750,6 +755,47 @@ public class Av1ReconstructionConformanceTests
             TestImages.Heif.Av1ObmcSequencePresentationReference,
             ObmcCoverage);
 
+    /// <summary>
+    /// Verifies production local warped-motion reconstruction against pinned native and presentation references.
+    /// </summary>
+    [Fact]
+    public void DecodeRealLibavifLocalWarpSequenceMatchesPinnedReferences()
+        => FeatureTestRunner.RunWithHwIntrinsicsFeature(
+            ValidateLocalWarpSequenceWithDefaultConfiguration,
+            ReconstructionConfigurations);
+
+    /// <summary>
+    /// Verifies production local warped-motion reconstruction through a constrained allocator.
+    /// </summary>
+    [Fact]
+    [ValidateDisposedMemoryAllocations]
+    public void DecodeRealLibavifLocalWarpSequenceUsesContiguousPlanes()
+    {
+        TestMemoryAllocator allocator = new() { BufferCapacityInBytes = 1_024 };
+        allocator.EnableNonThreadSafeLogging();
+        Configuration configuration = Configuration.Default.Clone();
+        configuration.MemoryAllocator = allocator;
+
+        ValidateInterPredictionSequence(
+            configuration,
+            TestImages.Heif.Av1LocalWarpSequenceAvif,
+            TestImages.Heif.Av1LocalWarpSequenceNativeReference,
+            TestImages.Heif.Av1LocalWarpSequencePresentationReference,
+            LocalWarpCoverage,
+            comparePresentation: false,
+            fixtureSize: 256,
+            visibleFrameCount: 2);
+
+        Assert.Contains(allocator.AllocationLog, request => request.ElementType.Name == "RetainedMotionFieldEntry");
+        Assert.Contains(allocator.AllocationLog, request => request.ElementType.Name == "TemporalMotionFieldEntry");
+        Assert.Equal(allocator.AllocationLog.Count, allocator.ReturnLog.Count);
+        Assert.All(
+            allocator.AllocationLog,
+            allocation => Assert.Single(
+                allocator.ReturnLog,
+                returned => returned.AllocationId == allocation.AllocationId));
+    }
+
     /// <summary>
     /// Verifies one complete inter-prediction sequence with a separately tracked constrained allocator.
     /// </summary>
@@ -800,6 +846,20 @@ public class Av1ReconstructionConformanceTests
             ObmcCoverage,
             comparePresentation: true);
 
+    /// <summary>
+    /// Runs the local warped-motion sequence with exact final presentation comparison.
+    /// </summary>
+    private static void ValidateLocalWarpSequenceWithDefaultConfiguration()
+        => ValidateInterPredictionSequence(
+            Configuration.Default,
+            TestImages.Heif.Av1LocalWarpSequenceAvif,
+            TestImages.Heif.Av1LocalWarpSequenceNativeReference,
+            TestImages.Heif.Av1LocalWarpSequencePresentationReference,
+            LocalWarpCoverage,
+            comparePresentation: true,
+            fixtureSize: 256,
+            visibleFrameCount: 2);
+
     /// <summary>
     /// Validates every selectable compound fixture with the requested decoder configuration.
     /// </summary>
@@ -849,12 +909,16 @@ public class Av1ReconstructionConformanceTests
         string nativeReferencePath,
         string presentationReferencePath,
         int requiredCoverage,
-        bool comparePresentation)
+        bool comparePresentation,
+        int fixtureSize = AverageCompoundFixtureSize,
+        int visibleFrameCount = AverageCompoundFixtureFrameCount)
     {
         byte[] fileBytes = TestFile.Create(imagePath).Bytes;
         byte[] referenceBytes = TestFile.Create(nativeReferencePath).Bytes;
-        ReadOnlySpan<byte> fileHeader =
-            "YUV4MPEG2 W80 H80 F25:1 Ip A0:0 C444 XYSCSS=444 XCOLORRANGE=LIMITED\n"u8;
+        string fileHeaderText =
+            $"YUV4MPEG2 W{fixtureSize} H{fixtureSize} F25:1 Ip A0:0 C444 XYSCSS=444 XCOLORRANGE=LIMITED\n";
+
+        ReadOnlySpan<byte> fileHeader = Encoding.ASCII.GetBytes(fileHeaderText);
 
         ReadOnlySpan<byte> frameHeader = "FRAME\n"u8;
 
@@ -863,7 +927,7 @@ public class Av1ReconstructionConformanceTests
         nativeReference = nativeReference[fileHeader.Length..];
         Assert.True(nativeReference.StartsWith(frameHeader));
         nativeReference = nativeReference[frameHeader.Length..];
-        Assert.Equal(AverageCompoundFixtureSize * AverageCompoundFixtureSize * 3, nativeReference.Length);
+        Assert.Equal(fixtureSize * fixtureSize * 3, nativeReference.Length);
 
         using Image<Rgba32> presentationReference =
             Image.Load<Rgba32>(TestFile.Create(presentationReferencePath).Bytes);
@@ -871,7 +935,7 @@ public class Av1ReconstructionConformanceTests
         HeifSequence sequence = ParseImageSequence(fileBytes);
         HeifSequenceTrack track = sequence.ColorTrack;
         int coverage = 0;
-        int visibleFrameCount = 0;
+        int decodedVisibleFrameCount = 0;
         bool nativeCompared = false;
         bool presentationCompared = false;
 
@@ -904,7 +968,7 @@ public class Av1ReconstructionConformanceTests
             Assert.Equal(1, frameBuffer.BufferCb!.FastMemoryGroup.Count);
             Assert.Equal(1, frameBuffer.BufferCr!.FastMemoryGroup.Count);
 
-            if (visibleFrameCount == AverageCompoundFixtureFrameCount - 1)
+            if (decodedVisibleFrameCount == visibleFrameCount - 1)
             {
                 AssertNativePlanesEqual(decoder, frameBuffer, nativeReference);
                 nativeCompared = true;
@@ -913,7 +977,7 @@ public class Av1ReconstructionConformanceTests
                 {
                     ImageSimilarityReport<Rgba32, Rgba32> report =
                         ImageComparer.Exact.CompareImagesOrFrames(
-                            visibleFrameCount,
+                            decodedVisibleFrameCount,
                             presentationReference.Frames.RootFrame,
                             frame);
 
@@ -922,10 +986,10 @@ public class Av1ReconstructionConformanceTests
                 }
             }
 
-            visibleFrameCount++;
+            decodedVisibleFrameCount++;
         }
 
-        Assert.Equal(AverageCompoundFixtureFrameCount, visibleFrameCount);
+        Assert.Equal(visibleFrameCount, decodedVisibleFrameCount);
         Assert.Equal(requiredCoverage, coverage & requiredCoverage);
         Assert.True(nativeCompared);
         Assert.Equal(comparePresentation, presentationCompared);
@@ -954,6 +1018,11 @@ public class Av1ReconstructionConformanceTests
                         coverage |= ObmcCoverage;
                     }
 
+                    if (modeInfo.MotionMode == Av1MotionMode.Warped)
+                    {
+                        coverage |= LocalWarpCoverage;
+                    }
+
                     if (modeInfo.ReferenceFrames[1] == Av1ReferenceFrameType.Intra)
                     {
                         coverage |= modeInfo.UseInterIntraWedge ? WedgeInterIntraCoverage : SmoothInterIntraCoverage;

tests/ImageSharp.Tests/Formats/Heif/Av1/Av1WarpedInterPredictorTests.cs

@@ -0,0 +1,198 @@
+// Copyright (c) Six Labors.
+// Licensed under the Six Labors Split License.
+
+using SixLabors.ImageSharp.Formats.Heif.Av1.Motion;
+using SixLabors.ImageSharp.Formats.Heif.Av1.Prediction.Inter;
+using SixLabors.ImageSharp.Tests.TestUtilities;
+
+namespace SixLabors.ImageSharp.Tests.Formats.Heif.Av1;
+
+/// <summary>
+/// Verifies affine warped-motion prediction through native SIMD and scalar execution.
+/// </summary>
+[Trait("Format", "Avif")]
+public class Av1WarpedInterPredictorTests
+{
+    /// <summary>
+    /// The hardware configurations covering the portable vector operator and scalar fallback.
+    /// </summary>
+    private const HwIntrinsics PredictorConfigurations = HwIntrinsics.AllowAll | HwIntrinsics.DisableHWIntrinsic;
+
+    /// <summary>
+    /// Verifies exact 8-bit vector/scalar parity for luma and subsampled chroma coordinates.
+    /// </summary>
+    [Fact]
+    public void BytePredictionMatchesScalarAcrossIntrinsicConfigurations()
+        => FeatureTestRunner.RunWithHwIntrinsicsFeature(ValidateBytePrediction, PredictorConfigurations);
+
+    /// <summary>
+    /// Verifies exact 8-, 10-, and 12-bit vector/scalar parity for luma and subsampled chroma coordinates.
+    /// </summary>
+    [Fact]
+    public void HighBitDepthPredictionMatchesScalarAcrossIntrinsicConfigurations()
+        => FeatureTestRunner.RunWithHwIntrinsicsFeature(ValidateHighBitDepthPrediction, PredictorConfigurations);
+
+    /// <summary>
+    /// Applies the pinned multi-sample affine model to deterministic byte storage.
+    /// </summary>
+    private static void ValidateBytePrediction()
+    {
+        const int activeSize = 96;
+        const int padding = 24;
+        const int sourceStride = activeSize + (2 * padding);
+        const int width = 13;
+        const int height = 11;
+        const int destinationStride = width + 7;
+        byte[] source = new byte[sourceStride * sourceStride];
+        for (int row = 0; row < sourceStride; row++)
+        {
+            for (int column = 0; column < sourceStride; column++)
+            {
+                source[(row * sourceStride) + column] = (byte)(((row * 29) + (column * 47) + (row * column * 3)) & byte.MaxValue);
+            }
+        }
+
+        Av1GlobalMotionParameters parameters = CreatePinnedParameters();
+        for (int subsampling = 0; subsampling <= 1; subsampling++)
+        {
+            byte[] expected = new byte[destinationStride * height];
+            byte[] actual = new byte[destinationStride * height];
+            Array.Fill(expected, (byte)0xD3);
+            Array.Fill(actual, (byte)0xD3);
+            short[] expectedScratch = new short[Av1InterPredictor.WarpedScratchLength];
+            short[] actualScratch = new short[Av1InterPredictor.WarpedScratchLength];
+            Point destinationPosition = subsampling == 0 ? new Point(32, 24) : new Point(16, 12);
+
+            Av1InterPredictor.PredictWarpedScalar(
+                source,
+                sourceStride,
+                new Point(padding, padding),
+                activeSize,
+                activeSize,
+                expected,
+                destinationStride,
+                destinationPosition,
+                width,
+                height,
+                subsampling,
+                subsampling,
+                parameters,
+                expectedScratch);
+
+            Av1InterPredictor.PredictWarped(
+                source,
+                sourceStride,
+                new Point(padding, padding),
+                activeSize,
+                activeSize,
+                actual,
+                destinationStride,
+                destinationPosition,
+                width,
+                height,
+                subsampling,
+                subsampling,
+                parameters,
+                actualScratch);
+
+            Assert.Equal(expected, actual);
+        }
+    }
+
+    /// <summary>
+    /// Applies the pinned multi-sample affine model to every supported high-bit-depth precision.
+    /// </summary>
+    private static void ValidateHighBitDepthPrediction()
+    {
+        const int activeSize = 96;
+        const int padding = 24;
+        const int sourceStride = activeSize + (2 * padding);
+        const int width = 13;
+        const int height = 11;
+        const int destinationStride = width + 7;
+        Av1GlobalMotionParameters parameters = CreatePinnedParameters();
+        foreach (int bitDepth in new[] { 8, 10, 12 })
+        {
+            int maximum = (1 << bitDepth) - 1;
+            ushort[] source = new ushort[sourceStride * sourceStride];
+            for (int row = 0; row < sourceStride; row++)
+            {
+                for (int column = 0; column < sourceStride; column++)
+                {
+                    source[(row * sourceStride) + column] =
+                        (ushort)(((row * 269) + (column * 443) + (row * column * 31)) & maximum);
+
+                }
+            }
+
+            for (int subsampling = 0; subsampling <= 1; subsampling++)
+            {
+                ushort[] expected = new ushort[destinationStride * height];
+                ushort[] actual = new ushort[destinationStride * height];
+                Array.Fill(expected, (ushort)0xDEAD);
+                Array.Fill(actual, (ushort)0xDEAD);
+                short[] expectedScratch = new short[Av1InterPredictor.WarpedScratchLength];
+                short[] actualScratch = new short[Av1InterPredictor.WarpedScratchLength];
+                Point destinationPosition = subsampling == 0 ? new Point(32, 24) : new Point(16, 12);
+
+                Av1InterPredictor.PredictWarpedScalar(
+                    source,
+                    sourceStride,
+                    new Point(padding, padding),
+                    activeSize,
+                    activeSize,
+                    expected,
+                    destinationStride,
+                    destinationPosition,
+                    width,
+                    height,
+                    subsampling,
+                    subsampling,
+                    bitDepth,
+                    parameters,
+                    expectedScratch);
+
+                Av1InterPredictor.PredictWarped(
+                    source,
+                    sourceStride,
+                    new Point(padding, padding),
+                    activeSize,
+                    activeSize,
+                    actual,
+                    destinationStride,
+                    destinationPosition,
+                    width,
+                    height,
+                    subsampling,
+                    subsampling,
+                    bitDepth,
+                    parameters,
+                    actualScratch);
+
+                Assert.Equal(expected, actual);
+            }
+        }
+    }
+
+    /// <summary>
+    /// Creates one nontrivial affine model traced from the pinned two-frame local-warp fixture.
+    /// </summary>
+    private static Av1GlobalMotionParameters CreatePinnedParameters()
+    {
+        Av1GlobalMotionParameters parameters = Av1GlobalMotionParameters.Identity;
+        parameters.Type = Av1GlobalMotionType.Affine;
+        parameters[0] = -191565;
+        parameters[1] = 599107;
+        parameters[2] = 61755;
+        parameters[3] = -140;
+        parameters[4] = -6909;
+        parameters[5] = 62012;
+        parameters.UpdateShearParameters();
+        Assert.False(parameters.IsInvalid);
+        Assert.Equal(-3776, parameters.Alpha);
+        Assert.Equal(-128, parameters.Beta);
+        Assert.Equal(-7360, parameters.Gamma);
+        Assert.Equal(-3520, parameters.Delta);
+        return parameters;
+    }
+}

tests/ImageSharp.Tests/TestImages.cs

@@ -1380,6 +1380,9 @@ public static class TestImages
         public const string Av1ObmcSequenceAvif = "Heif/Av1/Conformance/libavif-webp-logo-obmc.avif";
         public const string Av1ObmcSequenceNativeReference = "Heif/Av1/Conformance/libavif-webp-logo-obmc-libaom.y4m";
         public const string Av1ObmcSequencePresentationReference = "Heif/Av1/Conformance/libavif-webp-logo-obmc-libavif.png";
+        public const string Av1LocalWarpSequenceAvif = "Heif/Av1/Conformance/libavif-rotating-grid-local-warp.avif";
+        public const string Av1LocalWarpSequenceNativeReference = "Heif/Av1/Conformance/libavif-rotating-grid-local-warp-libaom.y4m";
+        public const string Av1LocalWarpSequencePresentationReference = "Heif/Av1/Conformance/libavif-rotating-grid-local-warp-libavif.png";
         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";

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

@@ -43,6 +43,7 @@ The reference builds use `AOM_TARGET_CPU=generic` and disable libyuv. Native rec
 | `libavif-webp-logo-difference-weighted-compound` | Difference-weighted compound prediction with both mask orientations |
 | `libavif-webp-logo-inter-intra` | Smooth and wedge inter-intra prediction |
 | `libavif-webp-logo-obmc` | Above and left overlapping motion compensation through a 19-frame dependent sequence |
+| `libavif-rotating-grid-local-warp` | Multi-sample local affine projection and warped prediction through a two-frame dependent sequence |
 
 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.
 
@@ -119,6 +120,18 @@ Pinned scalar libavif generated the final native and presentation references wit
 
 The AVIF SHA-256 is `765245F71BD398F7AD87BD83FD5C5C11172981B37A4FABF4F10F65D4E8AEA537`. The retained frame-18 Y4M SHA-256 is `904D1B5B3E7F334CE8D44040F9A7BDCAC1F7773122FF1C5F06A5B4DD31A62A97`, and the frame-18 PNG SHA-256 is `D2CB388C9092EF17C4F0382C0150DD30D6F9D0EE247FF45AB5D7D4D312CEB23C`. Pinned libaom block tracing records more than one hundred actual OBMC blocks across the decoded sequence, including blocks with nonzero horizontal and vertical motion vectors. The production test requires decoded OBMC mode state, decodes every retained-reference dependency, compares the final native Y, U, and V planes exactly, compares the final RGBA presentation exactly through `FeatureTestRunner`, and repeats reconstruction with constrained tracked allocation. Direct production-branch tests separately cover 8/10/12-bit storage and 4:2:0 and 4:2:2 overlap geometry.
 
+## Local warped-motion fixture
+
+The `libavif-rotating-grid-local-warp.avif` fixture was encoded from a deterministic two-frame 256x256 limited-range YUV444 source. The source combines checkerboard, ring, and chroma-gradient detail; its second frame rotates the first by 2.5 degrees with nearest-neighbor sampling and edge clamping. The two-frame source Y4M SHA-256 is `82C1468C95C996B05165590417184F59373D67896F8C7B0EB398582C29C9C7A7`. Pinned scalar libavif and libaom generated the fixture and references with:
+
+```text
+./avifenc -j 1 -s 0 -q 60 -a color:enable-warped-motion=1 -a color:enable-global-motion=0 -a color:enable-obmc=0 rotating-grid-256-two-frame.y4m libavif-rotating-grid-local-warp.avif
+./avifdec -j 1 --index 1 libavif-rotating-grid-local-warp.avif libavif-rotating-grid-local-warp-libaom.y4m
+./avifdec -j 1 --index 1 libavif-rotating-grid-local-warp.avif libavif-rotating-grid-local-warp-libavif.png
+```
+
+The AVIF SHA-256 is `990BAC4AD443005C217B0DA4FCCFA9ADFB3AA147AD06C85F9A655A4433E9E8A7`. The retained frame-1 Y4M SHA-256 is `984B2815CEE0C05FDE26430F150A21B5C993141E25BA1ED4FDE09372DB64AC13`, and the frame-1 PNG SHA-256 is `4490D62FB6679378E92CACA48427359091AD2106BE49FC1A3848F78BE03BEEB1`. Pinned libaom tracing records many actual `WARPED_CAUSAL` blocks. The multi-sample model at mode-information row 6, column 8 derives matrix `[-191565, 599107, 61755, -140, -6909, 62012]` and reduced shear `[-3776, -128, -7360, -3520]` from four retained neighbor samples. The production test requires decoded warped mode state, compares every final native Y, U, and V sample and the final RGBA presentation exactly, runs normal and scalar dispatch through `FeatureTestRunner`, and repeats reconstruction with constrained tracked allocation.
+
 ## Updating fixtures
 
 Do not create conformance references with ImageSharp. Generate both the native-plane and presentation references with an independent decoder, record the exact upstream revisions and source license, and preserve exact comparisons. A new tool-specific fixture should demonstrate that the relevant syntax is active and should be no larger than required to cover that behavior.

tests/Images/Input/Heif/Av1/Conformance/libavif-rotating-grid-local-warp-libavif.png

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

tests/Images/Input/Heif/Av1/Conformance/libavif-rotating-grid-local-warp.avif

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