ffmpeg-v4l2-request-fourier: route H.264 chroma intra deblock (4:2:0) through daedalus-fourier (0013)

Substitutes c->v_loop_filter_chroma_intra and c->h_loop_filter_chroma_intra with daedalus wrappers in the bit_depth=8 / chroma_format_idc<=1 (4:2:0) branch. 4:2:2 stays on the in-tree NEON path (the daedalus chroma intra dispatch is 4:2:0-only). The fourier dispatches were exposed in PR #11 (DEFINE_INTRA_DISPATCH macro generates the public daedalus_dispatch_h264_deblock_chroma_*_intra symbols + recipe wrappers). Re-architects the chroma init: v_loop_filter_chroma_intra was previously assigned unconditionally to the NEON variant (which works for both 4:2:0 and 4:2:2). We now assign it INSIDE both branches of the chroma_format_idc conditional — 4:2:0 picks daedalus, 4:2:2 keeps NEON. No regression for 4:2:2 streams. Same NEON-to-NEON via recipe shape as 0010 luma intra. Closes the deblock substitution layer for the 4:2:0 / 8-bit hot path: - 0005 luma_v non-intra ✓ - 0008 luma_h non-intra ✓ - 0009 chroma_v / chroma_h non-intra ✓ - 0010 luma_v / luma_h intra ✓ - 0013 chroma_v / chroma_h intra ✓ All 8 deblock variants for the common 4:2:0 path now route through daedalus. 4:2:2 chroma + the chroma422 mbaff variants stay on in-tree NEON. Verified the patch applies cleanly on top of 0001-0012 against the pinned upstream commit b57fbbe5 on hertz.
Merge pull request 'ffmpeg-v4l2-request-fourier: route remaining H.264 qpel 8x8 positions through daedalus-fourier (0012)' (#101 ) from claude-noether/marfrit-packages:noether/h264-substitute-qpel-rest into main
2026-05-25 14:22:02 +02:00 · 2026-05-25 12:19:55 +00:00 · 2026-05-25 14:05:56 +02:00 · 2026-05-25 12:03:08 +00:00 · 2026-05-25 13:39:54 +02:00 · 2026-05-25 11:28:33 +00:00
14 changed files with 1644 additions and 4 deletions
@@ -0,0 +1,92 @@
+From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
+From: claude-noether <claude-noether@noreply.localhost>
+Date: Sun, 25 May 2026 12:00:00 +0200
+Subject: [PATCH] avcodec/aarch64/h264dsp: route H.264 luma-h deblock through daedalus-fourier
+
+Sibling of 0005 (which substituted v_loop_filter_luma).  Same
+NEON-to-NEON substitution: H264DSPContext.h_loop_filter_luma →
+daedalus_recipe_dispatch_h264_deblock_luma_h.  The H kernel landed
+in daedalus-fourier PR #9 (CPU NEON only — no QPU shader yet).
+
+libavcodec.so ctx is no-QPU per the existing 0003-0005 / 0007
+pattern; we cannot assume Vulkan in arbitrary host processes
+(firefox-fourier RDD, mpv-fourier, etc.).
+
+Intra (bS=4) h_loop_filter_luma_intra stays on the in-tree NEON .S
+code; daedalus_h264_deblock_meta only covers the non-intra path.
+An intra-h substitution can land once daedalus-fourier exposes a
+dispatch helper (the kernel already exists internally per PR #11).
+
+Refs reauktion/daedalus-v4l2#11 — substitution arc step 2 cycle 8 H.
+---
+diff --git a/libavcodec/aarch64/h264_idct_daedalus.c b/libavcodec/aarch64/h264_idct_daedalus.c
+--- a/libavcodec/aarch64/h264_idct_daedalus.c	2026-05-25 13:09:33.694760715 +0200
+++ libavcodec/aarch64/h264_idct_daedalus.c	2026-05-25 13:09:33.715603719 +0200
+@@ -1,9 +1,10 @@
+ /*
+- * H.264 4x4 / 8x8 IDCT + luma-v deblock — daedalus-fourier substitution shims.
+ * H.264 4x4 / 8x8 IDCT + luma v/h deblock — daedalus-fourier substitution shims.
+  *
+  * Routes H264DSPContext.idct_add           → daedalus_recipe_dispatch_h264_idct4
+  *        H264DSPContext.idct8_add          → daedalus_recipe_dispatch_h264_idct8
+  *        H264DSPContext.v_loop_filter_luma → daedalus_recipe_dispatch_h264_deblock_luma_v
+ *        H264DSPContext.h_loop_filter_luma → daedalus_recipe_dispatch_h264_deblock_luma_h
+  * instead of the in-tree ff_h264_*_neon assembly.  The recipe layer
+  * picks the substrate (CPU NEON for cycles 6 + 7 by default; cycle 8
+  * is CPU primary with QPU opportunistic — the ctx below is no-QPU,
+@@ -45,6 +46,8 @@
+ void ff_h264_idct8_add_daedalus(uint8_t *dst, int16_t *block, int stride);
+ void ff_h264_v_loop_filter_luma_daedalus(uint8_t *pix, ptrdiff_t stride,
+                                          int alpha, int beta, int8_t *tc0);
+void ff_h264_h_loop_filter_luma_daedalus(uint8_t *pix, ptrdiff_t stride,
+                                         int alpha, int beta, int8_t *tc0);
+ 
+ void ff_h264_idct_add_daedalus(uint8_t *dst, int16_t *block, int stride)
+ {
+@@ -84,3 +87,22 @@
+     daedalus_recipe_dispatch_h264_deblock_luma_v(g_dctx, pix, (size_t)stride,
+                                                  1, &meta);
+ }
+
+void ff_h264_h_loop_filter_luma_daedalus(uint8_t *pix, ptrdiff_t stride,
+                                         int alpha, int beta, int8_t *tc0)
+{
+    daedalus_h264_deblock_meta meta = {
+        .dst_off = 0,
+        .alpha   = alpha,
+        .beta    = beta,
+    };
+    meta.tc0[0] = tc0[0];
+    meta.tc0[1] = tc0[1];
+    meta.tc0[2] = tc0[2];
+    meta.tc0[3] = tc0[3];
+
+    pthread_once(&g_dctx_once, daedalus_ctx_init_once);
+
+    daedalus_recipe_dispatch_h264_deblock_luma_h(g_dctx, pix, (size_t)stride,
+                                                 1, &meta);
+}
+diff --git a/libavcodec/aarch64/h264dsp_init_aarch64.c b/libavcodec/aarch64/h264dsp_init_aarch64.c
+--- a/libavcodec/aarch64/h264dsp_init_aarch64.c	2026-05-25 13:09:33.695937103 +0200
+++ libavcodec/aarch64/h264dsp_init_aarch64.c	2026-05-25 13:09:33.715541700 +0200
+@@ -31,6 +31,8 @@
+                                          int alpha, int beta, int8_t *tc0);
+ void ff_h264_h_loop_filter_luma_neon(uint8_t *pix, ptrdiff_t stride, int alpha,
+                                      int beta, int8_t *tc0);
+void ff_h264_h_loop_filter_luma_daedalus(uint8_t *pix, ptrdiff_t stride,
+                                         int alpha, int beta, int8_t *tc0);
+ void ff_h264_v_loop_filter_luma_intra_neon(uint8_t *pix, ptrdiff_t stride, int alpha,
+                                            int beta);
+ void ff_h264_h_loop_filter_luma_intra_neon(uint8_t *pix, ptrdiff_t stride, int alpha,
+@@ -117,7 +119,7 @@
+ 
+     if (have_neon(cpu_flags) && bit_depth == 8) {
+         c->v_loop_filter_luma   = ff_h264_v_loop_filter_luma_daedalus;
+-        c->h_loop_filter_luma   = ff_h264_h_loop_filter_luma_neon;
+        c->h_loop_filter_luma   = ff_h264_h_loop_filter_luma_daedalus;
+         c->v_loop_filter_luma_intra= ff_h264_v_loop_filter_luma_intra_neon;
+         c->h_loop_filter_luma_intra= ff_h264_h_loop_filter_luma_intra_neon;
+ 
+--
+2.47.3
+
@@ -0,0 +1,127 @@
+From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
+From: claude-noether <claude-noether@noreply.localhost>
+Date: Sun, 25 May 2026 12:00:00 +0200
+Subject: [PATCH] avcodec/aarch64/h264dsp: route H.264 chroma v/h deblock through daedalus-fourier
+
+Chroma siblings of 0005 (luma_v) and 0008 (luma_h).  Same
+NEON-to-NEON pattern via the daedalus recipe layer:
+
+  H264DSPContext.v_loop_filter_chroma →
+    daedalus_recipe_dispatch_h264_deblock_chroma_v
+  H264DSPContext.h_loop_filter_chroma →
+    daedalus_recipe_dispatch_h264_deblock_chroma_h
+
+Both kernels landed in daedalus-fourier PR #10.  Recipe table
+routes AUTO to CPU NEON (no chroma QPU shaders yet), so this
+is plumbing-only and stays bit-exact against the in-tree NEON.
+
+Intra chroma (bS=4) loop filters remain on in-tree NEON;
+daedalus_h264_deblock_meta covers the non-intra (bS<4) path.
+
+Refs reauktion/daedalus-v4l2#11 — substitution arc step 2 cycle 8 chroma.
+---
+diff --git a/libavcodec/aarch64/h264_idct_daedalus.c b/libavcodec/aarch64/h264_idct_daedalus.c
+--- a/libavcodec/aarch64/h264_idct_daedalus.c	2026-05-25 13:15:45.995368233 +0200
+++ libavcodec/aarch64/h264_idct_daedalus.c	2026-05-25 13:15:46.015839177 +0200
+@@ -1,10 +1,12 @@
+ /*
+- * H.264 4x4 / 8x8 IDCT + luma v/h deblock — daedalus-fourier substitution shims.
+ * H.264 4x4 / 8x8 IDCT + luma v/h + chroma v/h deblock — daedalus-fourier substitution shims.
+  *
+  * Routes H264DSPContext.idct_add           → daedalus_recipe_dispatch_h264_idct4
+  *        H264DSPContext.idct8_add          → daedalus_recipe_dispatch_h264_idct8
+- *        H264DSPContext.v_loop_filter_luma → daedalus_recipe_dispatch_h264_deblock_luma_v
+- *        H264DSPContext.h_loop_filter_luma → daedalus_recipe_dispatch_h264_deblock_luma_h
+ *        H264DSPContext.v_loop_filter_luma   → daedalus_recipe_dispatch_h264_deblock_luma_v
+ *        H264DSPContext.h_loop_filter_luma   → daedalus_recipe_dispatch_h264_deblock_luma_h
+ *        H264DSPContext.v_loop_filter_chroma → daedalus_recipe_dispatch_h264_deblock_chroma_v
+ *        H264DSPContext.h_loop_filter_chroma → daedalus_recipe_dispatch_h264_deblock_chroma_h
+  * instead of the in-tree ff_h264_*_neon assembly.  The recipe layer
+  * picks the substrate (CPU NEON for cycles 6 + 7 by default; cycle 8
+  * is CPU primary with QPU opportunistic — the ctx below is no-QPU,
+@@ -48,6 +50,10 @@
+                                          int alpha, int beta, int8_t *tc0);
+ void ff_h264_h_loop_filter_luma_daedalus(uint8_t *pix, ptrdiff_t stride,
+                                          int alpha, int beta, int8_t *tc0);
+void ff_h264_v_loop_filter_chroma_daedalus(uint8_t *pix, ptrdiff_t stride,
+                                           int alpha, int beta, int8_t *tc0);
+void ff_h264_h_loop_filter_chroma_daedalus(uint8_t *pix, ptrdiff_t stride,
+                                           int alpha, int beta, int8_t *tc0);
+ 
+ void ff_h264_idct_add_daedalus(uint8_t *dst, int16_t *block, int stride)
+ {
+@@ -106,3 +112,41 @@
+     daedalus_recipe_dispatch_h264_deblock_luma_h(g_dctx, pix, (size_t)stride,
+                                                  1, &meta);
+ }
+
+void ff_h264_v_loop_filter_chroma_daedalus(uint8_t *pix, ptrdiff_t stride,
+                                           int alpha, int beta, int8_t *tc0)
+{
+    daedalus_h264_deblock_meta meta = {
+        .dst_off = 0,
+        .alpha   = alpha,
+        .beta    = beta,
+    };
+    meta.tc0[0] = tc0[0];
+    meta.tc0[1] = tc0[1];
+    meta.tc0[2] = tc0[2];
+    meta.tc0[3] = tc0[3];
+
+    pthread_once(&g_dctx_once, daedalus_ctx_init_once);
+
+    daedalus_recipe_dispatch_h264_deblock_chroma_v(g_dctx, pix, (size_t)stride,
+                                                   1, &meta);
+}
+
+void ff_h264_h_loop_filter_chroma_daedalus(uint8_t *pix, ptrdiff_t stride,
+                                           int alpha, int beta, int8_t *tc0)
+{
+    daedalus_h264_deblock_meta meta = {
+        .dst_off = 0,
+        .alpha   = alpha,
+        .beta    = beta,
+    };
+    meta.tc0[0] = tc0[0];
+    meta.tc0[1] = tc0[1];
+    meta.tc0[2] = tc0[2];
+    meta.tc0[3] = tc0[3];
+
+    pthread_once(&g_dctx_once, daedalus_ctx_init_once);
+
+    daedalus_recipe_dispatch_h264_deblock_chroma_h(g_dctx, pix, (size_t)stride,
+                                                   1, &meta);
+}
+diff --git a/libavcodec/aarch64/h264dsp_init_aarch64.c b/libavcodec/aarch64/h264dsp_init_aarch64.c
+--- a/libavcodec/aarch64/h264dsp_init_aarch64.c	2026-05-25 13:15:45.996482360 +0200
+++ libavcodec/aarch64/h264dsp_init_aarch64.c	2026-05-25 13:15:46.025604910 +0200
+@@ -39,8 +39,12 @@
+                                            int beta);
+ void ff_h264_v_loop_filter_chroma_neon(uint8_t *pix, ptrdiff_t stride, int alpha,
+                                        int beta, int8_t *tc0);
+void ff_h264_v_loop_filter_chroma_daedalus(uint8_t *pix, ptrdiff_t stride,
+                                           int alpha, int beta, int8_t *tc0);
+ void ff_h264_h_loop_filter_chroma_neon(uint8_t *pix, ptrdiff_t stride, int alpha,
+                                        int beta, int8_t *tc0);
+void ff_h264_h_loop_filter_chroma_daedalus(uint8_t *pix, ptrdiff_t stride,
+                                           int alpha, int beta, int8_t *tc0);
+ void ff_h264_h_loop_filter_chroma422_neon(uint8_t *pix, ptrdiff_t stride, int alpha,
+                                           int beta, int8_t *tc0);
+ void ff_h264_v_loop_filter_chroma_intra_neon(uint8_t *pix, ptrdiff_t stride,
+@@ -123,11 +127,11 @@
+         c->v_loop_filter_luma_intra= ff_h264_v_loop_filter_luma_intra_neon;
+         c->h_loop_filter_luma_intra= ff_h264_h_loop_filter_luma_intra_neon;
+ 
+-        c->v_loop_filter_chroma = ff_h264_v_loop_filter_chroma_neon;
+        c->v_loop_filter_chroma = ff_h264_v_loop_filter_chroma_daedalus;
+         c->v_loop_filter_chroma_intra = ff_h264_v_loop_filter_chroma_intra_neon;
+ 
+         if (chroma_format_idc <= 1) {
+-            c->h_loop_filter_chroma = ff_h264_h_loop_filter_chroma_neon;
+            c->h_loop_filter_chroma = ff_h264_h_loop_filter_chroma_daedalus;
+             c->h_loop_filter_chroma_intra = ff_h264_h_loop_filter_chroma_intra_neon;
+             c->h_loop_filter_chroma_mbaff_intra = ff_h264_h_loop_filter_chroma_mbaff_intra_neon;
+         } else {
+--
+2.47.3
+
@@ -0,0 +1,126 @@
+From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
+From: claude-noether <claude-noether@noreply.localhost>
+Date: Sun, 25 May 2026 12:30:00 +0200
+Subject: [PATCH] avcodec/aarch64/h264dsp: route H.264 luma intra deblock through daedalus-fourier
+
+Adds the bS=4 intra-strength variants of the already-substituted
+luma_v / luma_h deblock (0005, 0008).  Intra MBs and certain
+inter-MB edges (4x4 transform boundaries inside an Intra_NxN
+neighbour) force boundary strength to 4 per H.264 §8.7.2.1.
+
+  H264DSPContext.v_loop_filter_luma_intra →
+    daedalus_recipe_dispatch_h264_deblock_luma_v_intra
+  H264DSPContext.h_loop_filter_luma_intra →
+    daedalus_recipe_dispatch_h264_deblock_luma_h_intra
+
+Both kernels landed in daedalus-fourier PR #11.  Recipe table
+routes AUTO to CPU NEON (no intra QPU shaders yet) — plumbing-
+only NEON-to-NEON via daedalus, bit-exact against the in-tree
+FFmpeg NEON path.
+
+Signature differs from bS<4: no tc0 argument.  The wrapper
+passes daedalus_h264_deblock_meta with alpha/beta set; tc0[] is
+ignored by the intra dispatch (bS=4 hardcodes the strength).
+
+Chroma intra variants are deferred to a follow-up PR because the
+chroma path has a 4:2:0 / 4:2:2 split (chroma_format_idc gating)
+that needs explicit conditional substitution to avoid running
+the 4:2:0-only daedalus dispatch on 4:2:2 chroma.
+
+Refs reauktion/daedalus-v4l2#11 — substitution arc step 2 cycle 8 intra.
+---
+diff --git a/libavcodec/aarch64/h264_idct_daedalus.c b/libavcodec/aarch64/h264_idct_daedalus.c
+--- a/libavcodec/aarch64/h264_idct_daedalus.c	2026-05-25 13:18:54.992244965 +0200
+++ libavcodec/aarch64/h264_idct_daedalus.c	2026-05-25 13:20:12.338122217 +0200
+@@ -1,5 +1,5 @@
+ /*
+- * H.264 4x4 / 8x8 IDCT + luma v/h + chroma v/h deblock — daedalus-fourier substitution shims.
+ * H.264 4x4 / 8x8 IDCT + luma v/h (inter + intra) + chroma v/h deblock — daedalus-fourier substitution shims.
+  *
+  * Routes H264DSPContext.idct_add           → daedalus_recipe_dispatch_h264_idct4
+  *        H264DSPContext.idct8_add          → daedalus_recipe_dispatch_h264_idct8
+@@ -7,6 +7,8 @@
+  *        H264DSPContext.h_loop_filter_luma   → daedalus_recipe_dispatch_h264_deblock_luma_h
+  *        H264DSPContext.v_loop_filter_chroma → daedalus_recipe_dispatch_h264_deblock_chroma_v
+  *        H264DSPContext.h_loop_filter_chroma → daedalus_recipe_dispatch_h264_deblock_chroma_h
+ *        H264DSPContext.v_loop_filter_luma_intra → daedalus_recipe_dispatch_h264_deblock_luma_v_intra
+ *        H264DSPContext.h_loop_filter_luma_intra → daedalus_recipe_dispatch_h264_deblock_luma_h_intra
+  * instead of the in-tree ff_h264_*_neon assembly.  The recipe layer
+  * picks the substrate (CPU NEON for cycles 6 + 7 by default; cycle 8
+  * is CPU primary with QPU opportunistic — the ctx below is no-QPU,
+@@ -54,6 +56,10 @@
+                                            int alpha, int beta, int8_t *tc0);
+ void ff_h264_h_loop_filter_chroma_daedalus(uint8_t *pix, ptrdiff_t stride,
+                                            int alpha, int beta, int8_t *tc0);
+void ff_h264_v_loop_filter_luma_intra_daedalus(uint8_t *pix, ptrdiff_t stride,
+                                                int alpha, int beta);
+void ff_h264_h_loop_filter_luma_intra_daedalus(uint8_t *pix, ptrdiff_t stride,
+                                                int alpha, int beta);
+ 
+ void ff_h264_idct_add_daedalus(uint8_t *dst, int16_t *block, int stride)
+ {
+@@ -150,3 +156,34 @@
+     daedalus_recipe_dispatch_h264_deblock_chroma_h(g_dctx, pix, (size_t)stride,
+                                                    1, &meta);
+ }
+
+void ff_h264_v_loop_filter_luma_intra_daedalus(uint8_t *pix, ptrdiff_t stride,
+                                                int alpha, int beta)
+{
+    daedalus_h264_deblock_meta meta = {
+        .dst_off = 0,
+        .alpha   = alpha,
+        .beta    = beta,
+    };
+    /* tc0[] is ignored by the intra-strength dispatch (bS=4 hardcodes the strength). */
+
+    pthread_once(&g_dctx_once, daedalus_ctx_init_once);
+
+    daedalus_recipe_dispatch_h264_deblock_luma_v_intra(g_dctx, pix, (size_t)stride,
+                                                        1, &meta);
+}
+
+void ff_h264_h_loop_filter_luma_intra_daedalus(uint8_t *pix, ptrdiff_t stride,
+                                                int alpha, int beta)
+{
+    daedalus_h264_deblock_meta meta = {
+        .dst_off = 0,
+        .alpha   = alpha,
+        .beta    = beta,
+    };
+
+    pthread_once(&g_dctx_once, daedalus_ctx_init_once);
+
+    daedalus_recipe_dispatch_h264_deblock_luma_h_intra(g_dctx, pix, (size_t)stride,
+                                                        1, &meta);
+}
+diff --git a/libavcodec/aarch64/h264dsp_init_aarch64.c b/libavcodec/aarch64/h264dsp_init_aarch64.c
+--- a/libavcodec/aarch64/h264dsp_init_aarch64.c	2026-05-25 13:18:54.993349573 +0200
+++ libavcodec/aarch64/h264dsp_init_aarch64.c	2026-05-25 13:20:12.338265830 +0200
+@@ -35,8 +35,12 @@
+                                          int alpha, int beta, int8_t *tc0);
+ void ff_h264_v_loop_filter_luma_intra_neon(uint8_t *pix, ptrdiff_t stride, int alpha,
+                                            int beta);
+void ff_h264_v_loop_filter_luma_intra_daedalus(uint8_t *pix, ptrdiff_t stride,
+                                                int alpha, int beta);
+ void ff_h264_h_loop_filter_luma_intra_neon(uint8_t *pix, ptrdiff_t stride, int alpha,
+                                            int beta);
+void ff_h264_h_loop_filter_luma_intra_daedalus(uint8_t *pix, ptrdiff_t stride,
+                                                int alpha, int beta);
+ void ff_h264_v_loop_filter_chroma_neon(uint8_t *pix, ptrdiff_t stride, int alpha,
+                                        int beta, int8_t *tc0);
+ void ff_h264_v_loop_filter_chroma_daedalus(uint8_t *pix, ptrdiff_t stride,
+@@ -124,8 +128,8 @@
+     if (have_neon(cpu_flags) && bit_depth == 8) {
+         c->v_loop_filter_luma   = ff_h264_v_loop_filter_luma_daedalus;
+         c->h_loop_filter_luma   = ff_h264_h_loop_filter_luma_daedalus;
+-        c->v_loop_filter_luma_intra= ff_h264_v_loop_filter_luma_intra_neon;
+-        c->h_loop_filter_luma_intra= ff_h264_h_loop_filter_luma_intra_neon;
+        c->v_loop_filter_luma_intra= ff_h264_v_loop_filter_luma_intra_daedalus;
+        c->h_loop_filter_luma_intra= ff_h264_h_loop_filter_luma_intra_daedalus;
+ 
+         c->v_loop_filter_chroma = ff_h264_v_loop_filter_chroma_daedalus;
+         c->v_loop_filter_chroma_intra = ff_h264_v_loop_filter_chroma_intra_neon;
+--
+2.47.3
+
@@ -0,0 +1,101 @@
+From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
+From: claude-noether <claude-noether@noreply.localhost>
+Date: Sun, 25 May 2026 13:00:00 +0200
+Subject: [PATCH] avcodec/aarch64/h264dsp: route H.264 chroma DC Hadamard through daedalus-fourier
+
+Substitutes H264DSPContext.chroma_dc_dequant_idct in the
+4:2:0 / bit_depth=8 init path with a wrapper that composes
+the daedalus chroma DC Hadamard primitive (fourier PR #25)
+with qmul scaling FFmpeg does in one fused function.
+
+Bit-exact against ff_h264_chroma_dc_dequant_idct_8_c.
+Hadamard correctness gated by fourier PR #23 test suite.
+
+4:2:2 chroma stays on the in-tree 422 variant (same
+gating shape as 0009 chroma deblock substitution).
+
+Requires daedalus-fourier commit b9f9ff2 or later (PR #25
+exposing the public Hadamard symbol).  Pin bumps in PKGBUILD
+and build-deb.sh come in the same commit.
+---
+diff --git a/libavcodec/aarch64/h264_idct_daedalus.c b/libavcodec/aarch64/h264_idct_daedalus.c
+--- a/libavcodec/aarch64/h264_idct_daedalus.c	2026-05-25 13:38:32.019491484 +0200
+++ libavcodec/aarch64/h264_idct_daedalus.c	2026-05-25 13:38:32.033821507 +0200
+@@ -1,5 +1,5 @@
+ /*
+- * H.264 4x4 / 8x8 IDCT + luma v/h (inter + intra) + chroma v/h deblock — daedalus-fourier substitution shims.
+ * H.264 4x4 / 8x8 IDCT + luma v/h (inter+intra) + chroma v/h deblock + chroma DC Hadamard — daedalus-fourier substitution shims.
+  *
+  * Routes H264DSPContext.idct_add           → daedalus_recipe_dispatch_h264_idct4
+  *        H264DSPContext.idct8_add          → daedalus_recipe_dispatch_h264_idct8
+@@ -9,6 +9,7 @@
+  *        H264DSPContext.h_loop_filter_chroma → daedalus_recipe_dispatch_h264_deblock_chroma_h
+  *        H264DSPContext.v_loop_filter_luma_intra → daedalus_recipe_dispatch_h264_deblock_luma_v_intra
+  *        H264DSPContext.h_loop_filter_luma_intra → daedalus_recipe_dispatch_h264_deblock_luma_h_intra
+ *        H264DSPContext.chroma_dc_dequant_idct   → daedalus_h264_chroma_dc_hadamard_2x2 + caller-side qmul
+  * instead of the in-tree ff_h264_*_neon assembly.  The recipe layer
+  * picks the substrate (CPU NEON for cycles 6 + 7 by default; cycle 8
+  * is CPU primary with QPU opportunistic — the ctx below is no-QPU,
+@@ -60,6 +61,7 @@
+                                                 int alpha, int beta);
+ void ff_h264_h_loop_filter_luma_intra_daedalus(uint8_t *pix, ptrdiff_t stride,
+                                                 int alpha, int beta);
+void ff_h264_chroma_dc_dequant_idct_daedalus(int16_t *block, int qmul);
+ 
+ void ff_h264_idct_add_daedalus(uint8_t *dst, int16_t *block, int stride)
+ {
+@@ -187,3 +189,32 @@
+     daedalus_recipe_dispatch_h264_deblock_luma_h_intra(g_dctx, pix, (size_t)stride,
+                                                         1, &meta);
+ }
+
+/* Composes daedalus_h264_chroma_dc_hadamard_2x2 with the qmul scaling
+ * that FFmpeg's reference does in one fused function (h264idct_template.c
+ * ff_h264_chroma_dc_dequant_idct).
+ *
+ * The 4 DC coefficients are scattered across the per-MB coefficient
+ * buffer at offsets [r*stride + c*xStride] (stride=32, xStride=16).
+ * Extract into a contiguous int16[4], run the Hadamard, then apply
+ * the qmul scale and write back to the original positions.
+ *
+ * No daedalus ctx needed; the Hadamard is a pure stateless primitive.
+ */
+void ff_h264_chroma_dc_dequant_idct_daedalus(int16_t *block, int qmul)
+{
+    enum { stride = 32, xStride = 16 };
+    int16_t dc[4];
+
+    dc[0] = block[stride*0 + xStride*0];
+    dc[1] = block[stride*0 + xStride*1];
+    dc[2] = block[stride*1 + xStride*0];
+    dc[3] = block[stride*1 + xStride*1];
+
+    daedalus_h264_chroma_dc_hadamard_2x2(dc);
+
+    block[stride*0 + xStride*0] = (int16_t)((int)dc[0] * qmul >> 7);
+    block[stride*0 + xStride*1] = (int16_t)((int)dc[1] * qmul >> 7);
+    block[stride*1 + xStride*0] = (int16_t)((int)dc[2] * qmul >> 7);
+    block[stride*1 + xStride*1] = (int16_t)((int)dc[3] * qmul >> 7);
+}
+diff --git a/libavcodec/aarch64/h264dsp_init_aarch64.c b/libavcodec/aarch64/h264dsp_init_aarch64.c
+--- a/libavcodec/aarch64/h264dsp_init_aarch64.c	2026-05-25 13:38:32.020346459 +0200
+++ libavcodec/aarch64/h264dsp_init_aarch64.c	2026-05-25 13:38:32.033909804 +0200
+@@ -41,6 +41,7 @@
+                                            int beta);
+ void ff_h264_h_loop_filter_luma_intra_daedalus(uint8_t *pix, ptrdiff_t stride,
+                                                 int alpha, int beta);
+void ff_h264_chroma_dc_dequant_idct_daedalus(int16_t *block, int qmul);
+ void ff_h264_v_loop_filter_chroma_neon(uint8_t *pix, ptrdiff_t stride, int alpha,
+                                        int beta, int8_t *tc0);
+ void ff_h264_v_loop_filter_chroma_daedalus(uint8_t *pix, ptrdiff_t stride,
+@@ -135,6 +136,7 @@
+         c->v_loop_filter_chroma_intra = ff_h264_v_loop_filter_chroma_intra_neon;
+ 
+         if (chroma_format_idc <= 1) {
+            c->chroma_dc_dequant_idct = ff_h264_chroma_dc_dequant_idct_daedalus;
+             c->h_loop_filter_chroma = ff_h264_h_loop_filter_chroma_daedalus;
+             c->h_loop_filter_chroma_intra = ff_h264_h_loop_filter_chroma_intra_neon;
+             c->h_loop_filter_chroma_mbaff_intra = ff_h264_h_loop_filter_chroma_mbaff_intra_neon;
+--
+2.47.3
+
@@ -0,0 +1,245 @@
+From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
+From: claude-noether <claude-noether@noreply.localhost>
+Date: Sun, 25 May 2026 14:00:00 +0200
+Subject: [PATCH] avcodec/aarch64/h264qpel: route remaining qpel 8x8 positions through daedalus-fourier
+
+Closes the H.264 qpel substitution.  Extends 0007 (which routed only
+mc20 put_) to ALL 15 useful positions in BOTH the put_ and avg_
+tables, skipping mc00 (integer copy / pointer-only fast path).
+
+29 substitutions total: 14 new put_ + 15 avg_.  Each is a uniform
+wrapper around daedalus_recipe_dispatch_h264_qpel_{avg_,}mcXY exposed
+by daedalus-fourier PRs #15-#20.
+
+All recipe-table entries route AUTO to CPU NEON (no QPU shaders
+for any qpel position other than mc20 yet), so this is plumbing-only
+NEON-to-NEON — bit-exact against the in-tree ff_*_h264_qpel8_*_neon
+path.
+
+16x16 qpel tables ([0][...]) stay on the in-tree NEON.  daedalus
+only exposes 8x8 today; 16x16 substitution can land once fourier
+provides those variants (likely just dispatching the 8x8 path four
+times with shifted dst/src offsets).
+
+Refs reauktion/daedalus-v4l2#11 — substitution arc qpel buildout.
+---
+diff --git a/libavcodec/aarch64/h264_qpel_daedalus.c b/libavcodec/aarch64/h264_qpel_daedalus.c
+--- a/libavcodec/aarch64/h264_qpel_daedalus.c	2026-05-25 14:05:05.789298250 +0200
+++ libavcodec/aarch64/h264_qpel_daedalus.c	2026-05-25 14:05:05.818358374 +0200
+@@ -1,10 +1,13 @@
+ /*
+- * H.264 luma qpel mc20 (8x8, horizontal half-pel, 6-tap "put")
+- * — daedalus-fourier substitution shim.
+ * H.264 luma qpel 8x8 — daedalus-fourier substitution shims (put_ + avg_).
+  *
+- * Routes H264QpelContext.put_h264_qpel_pixels_tab[1][2] through
+- * daedalus_recipe_dispatch_h264_qpel_mc20 instead of
+- * ff_put_h264_qpel8_mc20_neon.  The recipe layer picks the substrate
+ * Routes ALL 15 useful positions in H264QpelContext's 8x8 put_ and
+ * avg_ tables through daedalus_recipe_dispatch_h264_qpel_mc{XY}
+ * (skipping mc00 which is integer copy / FFmpeg's pointer-only fast
+ * path).  Plumbing-only NEON-by-recipe — daedalus-fourier PRs #15-#20
+ * exposed each variant via the same dispatch signature, so the
+ * substitution is a uniform macro across put_/avg_ and across all
+ * 15 mc positions.  The recipe layer picks the substrate
+  * (CPU NEON for cycle 9; QPU not viable — per-block 7.6 ns vs
+  * ~250 ns QPU dispatch floor, see docs/k9_h264qpel_mc20.md).
+  *
+@@ -48,3 +51,53 @@
+     daedalus_recipe_dispatch_h264_qpel_mc20(g_dctx, dst, src, (size_t)stride,
+                                             1, &meta);
+ }
+
+
+/* All other 8x8 qpel positions follow the same dispatch shape as mc20
+ * above.  The macro collapses ~600 LOC of one-wrapper-per-variant
+ * boilerplate (29 variants total: 14 put_ + 15 avg_). */
+#define DEFINE_QPEL_WRAPPER(type, suffix, dispatch_fn)                          \
+void ff_ ## type ## _h264_qpel8_ ## suffix ## _daedalus(uint8_t *dst,           \
+    const uint8_t *src, ptrdiff_t stride);                                      \
+void ff_ ## type ## _h264_qpel8_ ## suffix ## _daedalus(uint8_t *dst,           \
+    const uint8_t *src, ptrdiff_t stride)                                       \
+{                                                                               \
+    static const daedalus_h264_qpel_meta meta = { .dst_off = 0, .src_off = 0 }; \
+    pthread_once(&g_dctx_once, daedalus_ctx_init_once);                         \
+    dispatch_fn(g_dctx, dst, src, (size_t)stride, 1, &meta);                    \
+}
+
+/* put_ variants (mc20 stays on the explicit definition above). */
+DEFINE_QPEL_WRAPPER(put, mc10, daedalus_recipe_dispatch_h264_qpel_mc10)
+DEFINE_QPEL_WRAPPER(put, mc30, daedalus_recipe_dispatch_h264_qpel_mc30)
+DEFINE_QPEL_WRAPPER(put, mc01, daedalus_recipe_dispatch_h264_qpel_mc01)
+DEFINE_QPEL_WRAPPER(put, mc11, daedalus_recipe_dispatch_h264_qpel_mc11)
+DEFINE_QPEL_WRAPPER(put, mc21, daedalus_recipe_dispatch_h264_qpel_mc21)
+DEFINE_QPEL_WRAPPER(put, mc31, daedalus_recipe_dispatch_h264_qpel_mc31)
+DEFINE_QPEL_WRAPPER(put, mc02, daedalus_recipe_dispatch_h264_qpel_mc02)
+DEFINE_QPEL_WRAPPER(put, mc12, daedalus_recipe_dispatch_h264_qpel_mc12)
+DEFINE_QPEL_WRAPPER(put, mc22, daedalus_recipe_dispatch_h264_qpel_mc22)
+DEFINE_QPEL_WRAPPER(put, mc32, daedalus_recipe_dispatch_h264_qpel_mc32)
+DEFINE_QPEL_WRAPPER(put, mc03, daedalus_recipe_dispatch_h264_qpel_mc03)
+DEFINE_QPEL_WRAPPER(put, mc13, daedalus_recipe_dispatch_h264_qpel_mc13)
+DEFINE_QPEL_WRAPPER(put, mc23, daedalus_recipe_dispatch_h264_qpel_mc23)
+DEFINE_QPEL_WRAPPER(put, mc33, daedalus_recipe_dispatch_h264_qpel_mc33)
+
+/* avg_ variants — all 15 useful positions. */
+DEFINE_QPEL_WRAPPER(avg, mc10, daedalus_recipe_dispatch_h264_qpel_avg_mc10)
+DEFINE_QPEL_WRAPPER(avg, mc20, daedalus_recipe_dispatch_h264_qpel_avg_mc20)
+DEFINE_QPEL_WRAPPER(avg, mc30, daedalus_recipe_dispatch_h264_qpel_avg_mc30)
+DEFINE_QPEL_WRAPPER(avg, mc01, daedalus_recipe_dispatch_h264_qpel_avg_mc01)
+DEFINE_QPEL_WRAPPER(avg, mc11, daedalus_recipe_dispatch_h264_qpel_avg_mc11)
+DEFINE_QPEL_WRAPPER(avg, mc21, daedalus_recipe_dispatch_h264_qpel_avg_mc21)
+DEFINE_QPEL_WRAPPER(avg, mc31, daedalus_recipe_dispatch_h264_qpel_avg_mc31)
+DEFINE_QPEL_WRAPPER(avg, mc02, daedalus_recipe_dispatch_h264_qpel_avg_mc02)
+DEFINE_QPEL_WRAPPER(avg, mc12, daedalus_recipe_dispatch_h264_qpel_avg_mc12)
+DEFINE_QPEL_WRAPPER(avg, mc22, daedalus_recipe_dispatch_h264_qpel_avg_mc22)
+DEFINE_QPEL_WRAPPER(avg, mc32, daedalus_recipe_dispatch_h264_qpel_avg_mc32)
+DEFINE_QPEL_WRAPPER(avg, mc03, daedalus_recipe_dispatch_h264_qpel_avg_mc03)
+DEFINE_QPEL_WRAPPER(avg, mc13, daedalus_recipe_dispatch_h264_qpel_avg_mc13)
+DEFINE_QPEL_WRAPPER(avg, mc23, daedalus_recipe_dispatch_h264_qpel_avg_mc23)
+DEFINE_QPEL_WRAPPER(avg, mc33, daedalus_recipe_dispatch_h264_qpel_avg_mc33)
+
+#undef DEFINE_QPEL_WRAPPER
+diff --git a/libavcodec/aarch64/h264qpel_init_aarch64.c b/libavcodec/aarch64/h264qpel_init_aarch64.c
+--- a/libavcodec/aarch64/h264qpel_init_aarch64.c	2026-05-25 14:05:05.790403989 +0200
+++ libavcodec/aarch64/h264qpel_init_aarch64.c	2026-05-25 14:05:05.819136071 +0200
+@@ -50,6 +50,64 @@
+ void ff_put_h264_qpel8_mc30_neon(uint8_t *dst, const uint8_t *src, ptrdiff_t stride);
+ void ff_put_h264_qpel8_mc20_daedalus(uint8_t *dst, const uint8_t *src,
+                                      ptrdiff_t stride);
+void ff_put_h264_qpel8_mc10_daedalus(uint8_t *dst, const uint8_t *src,
+                                  ptrdiff_t stride);
+void ff_put_h264_qpel8_mc30_daedalus(uint8_t *dst, const uint8_t *src,
+                                  ptrdiff_t stride);
+void ff_put_h264_qpel8_mc01_daedalus(uint8_t *dst, const uint8_t *src,
+                                  ptrdiff_t stride);
+void ff_put_h264_qpel8_mc11_daedalus(uint8_t *dst, const uint8_t *src,
+                                  ptrdiff_t stride);
+void ff_put_h264_qpel8_mc21_daedalus(uint8_t *dst, const uint8_t *src,
+                                  ptrdiff_t stride);
+void ff_put_h264_qpel8_mc31_daedalus(uint8_t *dst, const uint8_t *src,
+                                  ptrdiff_t stride);
+void ff_put_h264_qpel8_mc02_daedalus(uint8_t *dst, const uint8_t *src,
+                                  ptrdiff_t stride);
+void ff_put_h264_qpel8_mc12_daedalus(uint8_t *dst, const uint8_t *src,
+                                  ptrdiff_t stride);
+void ff_put_h264_qpel8_mc22_daedalus(uint8_t *dst, const uint8_t *src,
+                                  ptrdiff_t stride);
+void ff_put_h264_qpel8_mc32_daedalus(uint8_t *dst, const uint8_t *src,
+                                  ptrdiff_t stride);
+void ff_put_h264_qpel8_mc03_daedalus(uint8_t *dst, const uint8_t *src,
+                                  ptrdiff_t stride);
+void ff_put_h264_qpel8_mc13_daedalus(uint8_t *dst, const uint8_t *src,
+                                  ptrdiff_t stride);
+void ff_put_h264_qpel8_mc23_daedalus(uint8_t *dst, const uint8_t *src,
+                                  ptrdiff_t stride);
+void ff_put_h264_qpel8_mc33_daedalus(uint8_t *dst, const uint8_t *src,
+                                  ptrdiff_t stride);
+void ff_avg_h264_qpel8_mc10_daedalus(uint8_t *dst, const uint8_t *src,
+                                  ptrdiff_t stride);
+void ff_avg_h264_qpel8_mc20_daedalus(uint8_t *dst, const uint8_t *src,
+                                  ptrdiff_t stride);
+void ff_avg_h264_qpel8_mc30_daedalus(uint8_t *dst, const uint8_t *src,
+                                  ptrdiff_t stride);
+void ff_avg_h264_qpel8_mc01_daedalus(uint8_t *dst, const uint8_t *src,
+                                  ptrdiff_t stride);
+void ff_avg_h264_qpel8_mc11_daedalus(uint8_t *dst, const uint8_t *src,
+                                  ptrdiff_t stride);
+void ff_avg_h264_qpel8_mc21_daedalus(uint8_t *dst, const uint8_t *src,
+                                  ptrdiff_t stride);
+void ff_avg_h264_qpel8_mc31_daedalus(uint8_t *dst, const uint8_t *src,
+                                  ptrdiff_t stride);
+void ff_avg_h264_qpel8_mc02_daedalus(uint8_t *dst, const uint8_t *src,
+                                  ptrdiff_t stride);
+void ff_avg_h264_qpel8_mc12_daedalus(uint8_t *dst, const uint8_t *src,
+                                  ptrdiff_t stride);
+void ff_avg_h264_qpel8_mc22_daedalus(uint8_t *dst, const uint8_t *src,
+                                  ptrdiff_t stride);
+void ff_avg_h264_qpel8_mc32_daedalus(uint8_t *dst, const uint8_t *src,
+                                  ptrdiff_t stride);
+void ff_avg_h264_qpel8_mc03_daedalus(uint8_t *dst, const uint8_t *src,
+                                  ptrdiff_t stride);
+void ff_avg_h264_qpel8_mc13_daedalus(uint8_t *dst, const uint8_t *src,
+                                  ptrdiff_t stride);
+void ff_avg_h264_qpel8_mc23_daedalus(uint8_t *dst, const uint8_t *src,
+                                  ptrdiff_t stride);
+void ff_avg_h264_qpel8_mc33_daedalus(uint8_t *dst, const uint8_t *src,
+                                  ptrdiff_t stride);
+ void ff_put_h264_qpel8_mc01_neon(uint8_t *dst, const uint8_t *src, ptrdiff_t stride);
+ void ff_put_h264_qpel8_mc11_neon(uint8_t *dst, const uint8_t *src, ptrdiff_t stride);
+ void ff_put_h264_qpel8_mc21_neon(uint8_t *dst, const uint8_t *src, ptrdiff_t stride);
+@@ -164,21 +222,21 @@
+         c->put_h264_qpel_pixels_tab[0][15] = ff_put_h264_qpel16_mc33_neon;
+ 
+         c->put_h264_qpel_pixels_tab[1][ 0] = ff_put_h264_qpel8_mc00_neon;
+-        c->put_h264_qpel_pixels_tab[1][ 1] = ff_put_h264_qpel8_mc10_neon;
+        c->put_h264_qpel_pixels_tab[1][ 1] = ff_put_h264_qpel8_mc10_daedalus;
+         c->put_h264_qpel_pixels_tab[1][ 2] = ff_put_h264_qpel8_mc20_daedalus;
+-        c->put_h264_qpel_pixels_tab[1][ 3] = ff_put_h264_qpel8_mc30_neon;
+-        c->put_h264_qpel_pixels_tab[1][ 4] = ff_put_h264_qpel8_mc01_neon;
+-        c->put_h264_qpel_pixels_tab[1][ 5] = ff_put_h264_qpel8_mc11_neon;
+-        c->put_h264_qpel_pixels_tab[1][ 6] = ff_put_h264_qpel8_mc21_neon;
+-        c->put_h264_qpel_pixels_tab[1][ 7] = ff_put_h264_qpel8_mc31_neon;
+-        c->put_h264_qpel_pixels_tab[1][ 8] = ff_put_h264_qpel8_mc02_neon;
+-        c->put_h264_qpel_pixels_tab[1][ 9] = ff_put_h264_qpel8_mc12_neon;
+-        c->put_h264_qpel_pixels_tab[1][10] = ff_put_h264_qpel8_mc22_neon;
+-        c->put_h264_qpel_pixels_tab[1][11] = ff_put_h264_qpel8_mc32_neon;
+-        c->put_h264_qpel_pixels_tab[1][12] = ff_put_h264_qpel8_mc03_neon;
+-        c->put_h264_qpel_pixels_tab[1][13] = ff_put_h264_qpel8_mc13_neon;
+-        c->put_h264_qpel_pixels_tab[1][14] = ff_put_h264_qpel8_mc23_neon;
+-        c->put_h264_qpel_pixels_tab[1][15] = ff_put_h264_qpel8_mc33_neon;
+        c->put_h264_qpel_pixels_tab[1][ 3] = ff_put_h264_qpel8_mc30_daedalus;
+        c->put_h264_qpel_pixels_tab[1][ 4] = ff_put_h264_qpel8_mc01_daedalus;
+        c->put_h264_qpel_pixels_tab[1][ 5] = ff_put_h264_qpel8_mc11_daedalus;
+        c->put_h264_qpel_pixels_tab[1][ 6] = ff_put_h264_qpel8_mc21_daedalus;
+        c->put_h264_qpel_pixels_tab[1][ 7] = ff_put_h264_qpel8_mc31_daedalus;
+        c->put_h264_qpel_pixels_tab[1][ 8] = ff_put_h264_qpel8_mc02_daedalus;
+        c->put_h264_qpel_pixels_tab[1][ 9] = ff_put_h264_qpel8_mc12_daedalus;
+        c->put_h264_qpel_pixels_tab[1][10] = ff_put_h264_qpel8_mc22_daedalus;
+        c->put_h264_qpel_pixels_tab[1][11] = ff_put_h264_qpel8_mc32_daedalus;
+        c->put_h264_qpel_pixels_tab[1][12] = ff_put_h264_qpel8_mc03_daedalus;
+        c->put_h264_qpel_pixels_tab[1][13] = ff_put_h264_qpel8_mc13_daedalus;
+        c->put_h264_qpel_pixels_tab[1][14] = ff_put_h264_qpel8_mc23_daedalus;
+        c->put_h264_qpel_pixels_tab[1][15] = ff_put_h264_qpel8_mc33_daedalus;
+ 
+         c->avg_h264_qpel_pixels_tab[0][ 0] = ff_avg_h264_qpel16_mc00_neon;
+         c->avg_h264_qpel_pixels_tab[0][ 1] = ff_avg_h264_qpel16_mc10_neon;
+@@ -198,21 +256,21 @@
+         c->avg_h264_qpel_pixels_tab[0][15] = ff_avg_h264_qpel16_mc33_neon;
+ 
+         c->avg_h264_qpel_pixels_tab[1][ 0] = ff_avg_h264_qpel8_mc00_neon;
+-        c->avg_h264_qpel_pixels_tab[1][ 1] = ff_avg_h264_qpel8_mc10_neon;
+-        c->avg_h264_qpel_pixels_tab[1][ 2] = ff_avg_h264_qpel8_mc20_neon;
+-        c->avg_h264_qpel_pixels_tab[1][ 3] = ff_avg_h264_qpel8_mc30_neon;
+-        c->avg_h264_qpel_pixels_tab[1][ 4] = ff_avg_h264_qpel8_mc01_neon;
+-        c->avg_h264_qpel_pixels_tab[1][ 5] = ff_avg_h264_qpel8_mc11_neon;
+-        c->avg_h264_qpel_pixels_tab[1][ 6] = ff_avg_h264_qpel8_mc21_neon;
+-        c->avg_h264_qpel_pixels_tab[1][ 7] = ff_avg_h264_qpel8_mc31_neon;
+-        c->avg_h264_qpel_pixels_tab[1][ 8] = ff_avg_h264_qpel8_mc02_neon;
+-        c->avg_h264_qpel_pixels_tab[1][ 9] = ff_avg_h264_qpel8_mc12_neon;
+-        c->avg_h264_qpel_pixels_tab[1][10] = ff_avg_h264_qpel8_mc22_neon;
+-        c->avg_h264_qpel_pixels_tab[1][11] = ff_avg_h264_qpel8_mc32_neon;
+-        c->avg_h264_qpel_pixels_tab[1][12] = ff_avg_h264_qpel8_mc03_neon;
+-        c->avg_h264_qpel_pixels_tab[1][13] = ff_avg_h264_qpel8_mc13_neon;
+-        c->avg_h264_qpel_pixels_tab[1][14] = ff_avg_h264_qpel8_mc23_neon;
+-        c->avg_h264_qpel_pixels_tab[1][15] = ff_avg_h264_qpel8_mc33_neon;
+        c->avg_h264_qpel_pixels_tab[1][ 1] = ff_avg_h264_qpel8_mc10_daedalus;
+        c->avg_h264_qpel_pixels_tab[1][ 2] = ff_avg_h264_qpel8_mc20_daedalus;
+        c->avg_h264_qpel_pixels_tab[1][ 3] = ff_avg_h264_qpel8_mc30_daedalus;
+        c->avg_h264_qpel_pixels_tab[1][ 4] = ff_avg_h264_qpel8_mc01_daedalus;
+        c->avg_h264_qpel_pixels_tab[1][ 5] = ff_avg_h264_qpel8_mc11_daedalus;
+        c->avg_h264_qpel_pixels_tab[1][ 6] = ff_avg_h264_qpel8_mc21_daedalus;
+        c->avg_h264_qpel_pixels_tab[1][ 7] = ff_avg_h264_qpel8_mc31_daedalus;
+        c->avg_h264_qpel_pixels_tab[1][ 8] = ff_avg_h264_qpel8_mc02_daedalus;
+        c->avg_h264_qpel_pixels_tab[1][ 9] = ff_avg_h264_qpel8_mc12_daedalus;
+        c->avg_h264_qpel_pixels_tab[1][10] = ff_avg_h264_qpel8_mc22_daedalus;
+        c->avg_h264_qpel_pixels_tab[1][11] = ff_avg_h264_qpel8_mc32_daedalus;
+        c->avg_h264_qpel_pixels_tab[1][12] = ff_avg_h264_qpel8_mc03_daedalus;
+        c->avg_h264_qpel_pixels_tab[1][13] = ff_avg_h264_qpel8_mc13_daedalus;
+        c->avg_h264_qpel_pixels_tab[1][14] = ff_avg_h264_qpel8_mc23_daedalus;
+        c->avg_h264_qpel_pixels_tab[1][15] = ff_avg_h264_qpel8_mc33_daedalus;
+     } else if (have_neon(cpu_flags) && bit_depth == 10) {
+         c->put_h264_qpel_pixels_tab[0][ 1] = ff_put_h264_qpel16_mc10_neon_10;
+         c->put_h264_qpel_pixels_tab[0][ 2] = ff_put_h264_qpel16_mc20_neon_10;
+--
+2.47.3
+
@@ -0,0 +1,120 @@
+From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
+From: claude-noether <claude-noether@noreply.localhost>
+Date: Sun, 25 May 2026 14:30:00 +0200
+Subject: [PATCH] avcodec/aarch64/h264dsp: route H.264 chroma intra deblock (4:2:0) through daedalus-fourier
+
+Substitutes c->v_loop_filter_chroma_intra and c->h_loop_filter_chroma_intra
+with daedalus wrappers in the bit_depth=8 / chroma_format_idc<=1 (4:2:0)
+branch.  4:2:2 stays on the in-tree NEON path (the daedalus chroma intra
+dispatch is 4:2:0-only).
+
+The fourier dispatches were exposed in PR #11 (DEFINE_INTRA_DISPATCH
+macro generates the public daedalus_dispatch_h264_deblock_chroma_*_intra
+symbols + recipe wrappers).
+
+Re-architects the chroma init: v_loop_filter_chroma_intra was previously
+assigned unconditionally to the NEON variant (which works for both 4:2:0
+and 4:2:2).  We now assign it INSIDE both branches of the chroma_format_idc
+conditional, with the 4:2:0 branch picking daedalus and the 4:2:2 branch
+keeping NEON.  No regression for 4:2:2 streams.
+
+Same NEON-to-NEON via recipe shape as 0010 luma intra.
+
+Refs reauktion/daedalus-v4l2#11 — substitution arc chroma intra.
+---
+diff --git a/libavcodec/aarch64/h264_idct_daedalus.c b/libavcodec/aarch64/h264_idct_daedalus.c
+--- a/libavcodec/aarch64/h264_idct_daedalus.c	2026-05-25 14:21:08.267156263 +0200
+++ libavcodec/aarch64/h264_idct_daedalus.c	2026-05-25 14:21:08.287745931 +0200
+@@ -1,5 +1,5 @@
+ /*
+- * H.264 4x4 / 8x8 IDCT + luma v/h (inter+intra) + chroma v/h deblock + chroma DC Hadamard — daedalus-fourier substitution shims.
+ * H.264 4x4 / 8x8 IDCT + luma v/h (inter+intra) + chroma v/h (inter+intra) deblock + chroma DC Hadamard — daedalus-fourier substitution shims.
+  *
+  * Routes H264DSPContext.idct_add           → daedalus_recipe_dispatch_h264_idct4
+  *        H264DSPContext.idct8_add          → daedalus_recipe_dispatch_h264_idct8
+@@ -9,6 +9,8 @@
+  *        H264DSPContext.h_loop_filter_chroma → daedalus_recipe_dispatch_h264_deblock_chroma_h
+  *        H264DSPContext.v_loop_filter_luma_intra → daedalus_recipe_dispatch_h264_deblock_luma_v_intra
+  *        H264DSPContext.h_loop_filter_luma_intra → daedalus_recipe_dispatch_h264_deblock_luma_h_intra
+ *        H264DSPContext.v_loop_filter_chroma_intra → daedalus_recipe_dispatch_h264_deblock_chroma_v_intra
+ *        H264DSPContext.h_loop_filter_chroma_intra → daedalus_recipe_dispatch_h264_deblock_chroma_h_intra
+  *        H264DSPContext.chroma_dc_dequant_idct   → daedalus_h264_chroma_dc_hadamard_2x2 + caller-side qmul
+  * instead of the in-tree ff_h264_*_neon assembly.  The recipe layer
+  * picks the substrate (CPU NEON for cycles 6 + 7 by default; cycle 8
+@@ -61,6 +63,10 @@
+                                                 int alpha, int beta);
+ void ff_h264_h_loop_filter_luma_intra_daedalus(uint8_t *pix, ptrdiff_t stride,
+                                                 int alpha, int beta);
+void ff_h264_v_loop_filter_chroma_intra_daedalus(uint8_t *pix, ptrdiff_t stride,
+                                                 int alpha, int beta);
+void ff_h264_h_loop_filter_chroma_intra_daedalus(uint8_t *pix, ptrdiff_t stride,
+                                                 int alpha, int beta);
+ void ff_h264_chroma_dc_dequant_idct_daedalus(int16_t *block, int qmul);
+ 
+ void ff_h264_idct_add_daedalus(uint8_t *dst, int16_t *block, int stride)
+@@ -218,3 +224,30 @@
+     block[stride*1 + xStride*0] = (int16_t)((int)dc[2] * qmul >> 7);
+     block[stride*1 + xStride*1] = (int16_t)((int)dc[3] * qmul >> 7);
+ }
+
+void ff_h264_v_loop_filter_chroma_intra_daedalus(uint8_t *pix, ptrdiff_t stride,
+                                                 int alpha, int beta)
+{
+    daedalus_h264_deblock_meta meta = {
+        .dst_off = 0,
+        .alpha   = alpha,
+        .beta    = beta,
+    };
+    /* tc0[] unused for intra (bS=4 hardcodes the strength). */
+    pthread_once(&g_dctx_once, daedalus_ctx_init_once);
+    daedalus_recipe_dispatch_h264_deblock_chroma_v_intra(g_dctx, pix, (size_t)stride,
+                                                          1, &meta);
+}
+
+void ff_h264_h_loop_filter_chroma_intra_daedalus(uint8_t *pix, ptrdiff_t stride,
+                                                 int alpha, int beta)
+{
+    daedalus_h264_deblock_meta meta = {
+        .dst_off = 0,
+        .alpha   = alpha,
+        .beta    = beta,
+    };
+    pthread_once(&g_dctx_once, daedalus_ctx_init_once);
+    daedalus_recipe_dispatch_h264_deblock_chroma_h_intra(g_dctx, pix, (size_t)stride,
+                                                          1, &meta);
+}
+diff --git a/libavcodec/aarch64/h264dsp_init_aarch64.c b/libavcodec/aarch64/h264dsp_init_aarch64.c
+--- a/libavcodec/aarch64/h264dsp_init_aarch64.c	2026-05-25 14:21:08.268311057 +0200
+++ libavcodec/aarch64/h264dsp_init_aarch64.c	2026-05-25 14:21:08.287886563 +0200
+@@ -42,6 +42,10 @@
+ void ff_h264_h_loop_filter_luma_intra_daedalus(uint8_t *pix, ptrdiff_t stride,
+                                                 int alpha, int beta);
+ void ff_h264_chroma_dc_dequant_idct_daedalus(int16_t *block, int qmul);
+void ff_h264_v_loop_filter_chroma_intra_daedalus(uint8_t *pix, ptrdiff_t stride,
+                                                 int alpha, int beta);
+void ff_h264_h_loop_filter_chroma_intra_daedalus(uint8_t *pix, ptrdiff_t stride,
+                                                 int alpha, int beta);
+ void ff_h264_v_loop_filter_chroma_neon(uint8_t *pix, ptrdiff_t stride, int alpha,
+                                        int beta, int8_t *tc0);
+ void ff_h264_v_loop_filter_chroma_daedalus(uint8_t *pix, ptrdiff_t stride,
+@@ -133,14 +137,15 @@
+         c->h_loop_filter_luma_intra= ff_h264_h_loop_filter_luma_intra_daedalus;
+ 
+         c->v_loop_filter_chroma = ff_h264_v_loop_filter_chroma_daedalus;
+-        c->v_loop_filter_chroma_intra = ff_h264_v_loop_filter_chroma_intra_neon;
+ 
+         if (chroma_format_idc <= 1) {
+             c->chroma_dc_dequant_idct = ff_h264_chroma_dc_dequant_idct_daedalus;
+            c->v_loop_filter_chroma_intra = ff_h264_v_loop_filter_chroma_intra_daedalus;
+             c->h_loop_filter_chroma = ff_h264_h_loop_filter_chroma_daedalus;
+-            c->h_loop_filter_chroma_intra = ff_h264_h_loop_filter_chroma_intra_neon;
+            c->h_loop_filter_chroma_intra = ff_h264_h_loop_filter_chroma_intra_daedalus;
+             c->h_loop_filter_chroma_mbaff_intra = ff_h264_h_loop_filter_chroma_mbaff_intra_neon;
+         } else {
+            c->v_loop_filter_chroma_intra = ff_h264_v_loop_filter_chroma_intra_neon;
+             c->h_loop_filter_chroma = ff_h264_h_loop_filter_chroma422_neon;
+             c->h_loop_filter_chroma_mbaff = ff_h264_h_loop_filter_chroma_neon;
+             c->h_loop_filter_chroma_intra = ff_h264_h_loop_filter_chroma422_intra_neon;
+--
+2.47.3
+
@@ -30,7 +30,7 @@ epoch=2
 # daedalus-fourier pin.  209a421 = PR #2 merge (Phase 8c — public API
 # gains daedalus_recipe_dispatch_h264_qpel_mc20 + DAEDALUS_KERNEL_H264_QPEL_MC20).
 # Cycle 9 closes the libavcodec.so substitution arc started at cycle 6.
-_daedalus_fourier_commit='209a4218bcb98b91c04f07ad61513bb04adb13ad'
+_daedalus_fourier_commit='b9f9ff2a89c068aea54dcb52b543afddad28311e'  # PR #25 — public chroma DC Hadamard symbol
 pkgdesc='FFmpeg with V4L2 Request API hwaccel (Rockchip / Allwinner stateless decode)'
 arch=('aarch64')
 url='https://github.com/Kwiboo/FFmpeg'
@@ -94,8 +94,14 @@ source=("git+https://github.com/Kwiboo/FFmpeg.git#commit=${_commit}"
        '0004-h264-idct8-daedalus-fourier.patch'
        '0005-h264-deblock-luma-v-daedalus-fourier.patch'
        '0006-h264-restore-low-delay.patch'
-        '0007-h264-qpel-mc20-daedalus-fourier.patch')
-sha256sums=('SKIP' 'SKIP' 'SKIP' 'SKIP' 'SKIP' 'SKIP' 'SKIP' 'SKIP' 'SKIP')
+        '0007-h264-qpel-mc20-daedalus-fourier.patch'
+        '0008-h264-deblock-luma-h-daedalus-fourier.patch'
+        '0009-h264-deblock-chroma-daedalus-fourier.patch'
+        '0010-h264-deblock-luma-intra-daedalus-fourier.patch'
+        '0011-h264-chroma-dc-hadamard-daedalus-fourier.patch'
+        '0012-h264-qpel-rest-daedalus-fourier.patch'
+        '0013-h264-deblock-chroma-intra-daedalus-fourier.patch')
+sha256sums=('SKIP' 'SKIP' 'SKIP' 'SKIP' 'SKIP' 'SKIP' 'SKIP' 'SKIP' 'SKIP' 'SKIP' 'SKIP' 'SKIP' 'SKIP' 'SKIP' 'SKIP')

 pkgver() {
  cd "${_srcname}"
@@ -113,6 +119,12 @@ prepare() {
  patch -Np1 -i "${srcdir}/0005-h264-deblock-luma-v-daedalus-fourier.patch"
  patch -Np1 -i "${srcdir}/0006-h264-restore-low-delay.patch"
  patch -Np1 -i "${srcdir}/0007-h264-qpel-mc20-daedalus-fourier.patch"
+  patch -Np1 -i "${srcdir}/0008-h264-deblock-luma-h-daedalus-fourier.patch"
+  patch -Np1 -i "${srcdir}/0009-h264-deblock-chroma-daedalus-fourier.patch"
+  patch -Np1 -i "${srcdir}/0010-h264-deblock-luma-intra-daedalus-fourier.patch"
+  patch -Np1 -i "${srcdir}/0011-h264-chroma-dc-hadamard-daedalus-fourier.patch"
+  patch -Np1 -i "${srcdir}/0012-h264-qpel-rest-daedalus-fourier.patch"
+  patch -Np1 -i "${srcdir}/0013-h264-deblock-chroma-intra-daedalus-fourier.patch"
 }

 build() {
@@ -0,0 +1,92 @@
+From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
+From: claude-noether <claude-noether@noreply.localhost>
+Date: Sun, 25 May 2026 12:00:00 +0200
+Subject: [PATCH] avcodec/aarch64/h264dsp: route H.264 luma-h deblock through daedalus-fourier
+
+Sibling of 0005 (which substituted v_loop_filter_luma).  Same
+NEON-to-NEON substitution: H264DSPContext.h_loop_filter_luma →
+daedalus_recipe_dispatch_h264_deblock_luma_h.  The H kernel landed
+in daedalus-fourier PR #9 (CPU NEON only — no QPU shader yet).
+
+libavcodec.so ctx is no-QPU per the existing 0003-0005 / 0007
+pattern; we cannot assume Vulkan in arbitrary host processes
+(firefox-fourier RDD, mpv-fourier, etc.).
+
+Intra (bS=4) h_loop_filter_luma_intra stays on the in-tree NEON .S
+code; daedalus_h264_deblock_meta only covers the non-intra path.
+An intra-h substitution can land once daedalus-fourier exposes a
+dispatch helper (the kernel already exists internally per PR #11).
+
+Refs reauktion/daedalus-v4l2#11 — substitution arc step 2 cycle 8 H.
+---
+diff --git a/libavcodec/aarch64/h264_idct_daedalus.c b/libavcodec/aarch64/h264_idct_daedalus.c
+--- a/libavcodec/aarch64/h264_idct_daedalus.c	2026-05-25 13:09:33.694760715 +0200
+++ libavcodec/aarch64/h264_idct_daedalus.c	2026-05-25 13:09:33.715603719 +0200
+@@ -1,9 +1,10 @@
+ /*
+- * H.264 4x4 / 8x8 IDCT + luma-v deblock — daedalus-fourier substitution shims.
+ * H.264 4x4 / 8x8 IDCT + luma v/h deblock — daedalus-fourier substitution shims.
+  *
+  * Routes H264DSPContext.idct_add           → daedalus_recipe_dispatch_h264_idct4
+  *        H264DSPContext.idct8_add          → daedalus_recipe_dispatch_h264_idct8
+  *        H264DSPContext.v_loop_filter_luma → daedalus_recipe_dispatch_h264_deblock_luma_v
+ *        H264DSPContext.h_loop_filter_luma → daedalus_recipe_dispatch_h264_deblock_luma_h
+  * instead of the in-tree ff_h264_*_neon assembly.  The recipe layer
+  * picks the substrate (CPU NEON for cycles 6 + 7 by default; cycle 8
+  * is CPU primary with QPU opportunistic — the ctx below is no-QPU,
+@@ -45,6 +46,8 @@
+ void ff_h264_idct8_add_daedalus(uint8_t *dst, int16_t *block, int stride);
+ void ff_h264_v_loop_filter_luma_daedalus(uint8_t *pix, ptrdiff_t stride,
+                                          int alpha, int beta, int8_t *tc0);
+void ff_h264_h_loop_filter_luma_daedalus(uint8_t *pix, ptrdiff_t stride,
+                                         int alpha, int beta, int8_t *tc0);
+ 
+ void ff_h264_idct_add_daedalus(uint8_t *dst, int16_t *block, int stride)
+ {
+@@ -84,3 +87,22 @@
+     daedalus_recipe_dispatch_h264_deblock_luma_v(g_dctx, pix, (size_t)stride,
+                                                  1, &meta);
+ }
+
+void ff_h264_h_loop_filter_luma_daedalus(uint8_t *pix, ptrdiff_t stride,
+                                         int alpha, int beta, int8_t *tc0)
+{
+    daedalus_h264_deblock_meta meta = {
+        .dst_off = 0,
+        .alpha   = alpha,
+        .beta    = beta,
+    };
+    meta.tc0[0] = tc0[0];
+    meta.tc0[1] = tc0[1];
+    meta.tc0[2] = tc0[2];
+    meta.tc0[3] = tc0[3];
+
+    pthread_once(&g_dctx_once, daedalus_ctx_init_once);
+
+    daedalus_recipe_dispatch_h264_deblock_luma_h(g_dctx, pix, (size_t)stride,
+                                                 1, &meta);
+}
+diff --git a/libavcodec/aarch64/h264dsp_init_aarch64.c b/libavcodec/aarch64/h264dsp_init_aarch64.c
+--- a/libavcodec/aarch64/h264dsp_init_aarch64.c	2026-05-25 13:09:33.695937103 +0200
+++ libavcodec/aarch64/h264dsp_init_aarch64.c	2026-05-25 13:09:33.715541700 +0200
+@@ -31,6 +31,8 @@
+                                          int alpha, int beta, int8_t *tc0);
+ void ff_h264_h_loop_filter_luma_neon(uint8_t *pix, ptrdiff_t stride, int alpha,
+                                      int beta, int8_t *tc0);
+void ff_h264_h_loop_filter_luma_daedalus(uint8_t *pix, ptrdiff_t stride,
+                                         int alpha, int beta, int8_t *tc0);
+ void ff_h264_v_loop_filter_luma_intra_neon(uint8_t *pix, ptrdiff_t stride, int alpha,
+                                            int beta);
+ void ff_h264_h_loop_filter_luma_intra_neon(uint8_t *pix, ptrdiff_t stride, int alpha,
+@@ -117,7 +119,7 @@
+ 
+     if (have_neon(cpu_flags) && bit_depth == 8) {
+         c->v_loop_filter_luma   = ff_h264_v_loop_filter_luma_daedalus;
+-        c->h_loop_filter_luma   = ff_h264_h_loop_filter_luma_neon;
+        c->h_loop_filter_luma   = ff_h264_h_loop_filter_luma_daedalus;
+         c->v_loop_filter_luma_intra= ff_h264_v_loop_filter_luma_intra_neon;
+         c->h_loop_filter_luma_intra= ff_h264_h_loop_filter_luma_intra_neon;
+ 
+--
+2.47.3
+
@@ -0,0 +1,127 @@
+From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
+From: claude-noether <claude-noether@noreply.localhost>
+Date: Sun, 25 May 2026 12:00:00 +0200
+Subject: [PATCH] avcodec/aarch64/h264dsp: route H.264 chroma v/h deblock through daedalus-fourier
+
+Chroma siblings of 0005 (luma_v) and 0008 (luma_h).  Same
+NEON-to-NEON pattern via the daedalus recipe layer:
+
+  H264DSPContext.v_loop_filter_chroma →
+    daedalus_recipe_dispatch_h264_deblock_chroma_v
+  H264DSPContext.h_loop_filter_chroma →
+    daedalus_recipe_dispatch_h264_deblock_chroma_h
+
+Both kernels landed in daedalus-fourier PR #10.  Recipe table
+routes AUTO to CPU NEON (no chroma QPU shaders yet), so this
+is plumbing-only and stays bit-exact against the in-tree NEON.
+
+Intra chroma (bS=4) loop filters remain on in-tree NEON;
+daedalus_h264_deblock_meta covers the non-intra (bS<4) path.
+
+Refs reauktion/daedalus-v4l2#11 — substitution arc step 2 cycle 8 chroma.
+---
+diff --git a/libavcodec/aarch64/h264_idct_daedalus.c b/libavcodec/aarch64/h264_idct_daedalus.c
+--- a/libavcodec/aarch64/h264_idct_daedalus.c	2026-05-25 13:15:45.995368233 +0200
+++ libavcodec/aarch64/h264_idct_daedalus.c	2026-05-25 13:15:46.015839177 +0200
+@@ -1,10 +1,12 @@
+ /*
+- * H.264 4x4 / 8x8 IDCT + luma v/h deblock — daedalus-fourier substitution shims.
+ * H.264 4x4 / 8x8 IDCT + luma v/h + chroma v/h deblock — daedalus-fourier substitution shims.
+  *
+  * Routes H264DSPContext.idct_add           → daedalus_recipe_dispatch_h264_idct4
+  *        H264DSPContext.idct8_add          → daedalus_recipe_dispatch_h264_idct8
+- *        H264DSPContext.v_loop_filter_luma → daedalus_recipe_dispatch_h264_deblock_luma_v
+- *        H264DSPContext.h_loop_filter_luma → daedalus_recipe_dispatch_h264_deblock_luma_h
+ *        H264DSPContext.v_loop_filter_luma   → daedalus_recipe_dispatch_h264_deblock_luma_v
+ *        H264DSPContext.h_loop_filter_luma   → daedalus_recipe_dispatch_h264_deblock_luma_h
+ *        H264DSPContext.v_loop_filter_chroma → daedalus_recipe_dispatch_h264_deblock_chroma_v
+ *        H264DSPContext.h_loop_filter_chroma → daedalus_recipe_dispatch_h264_deblock_chroma_h
+  * instead of the in-tree ff_h264_*_neon assembly.  The recipe layer
+  * picks the substrate (CPU NEON for cycles 6 + 7 by default; cycle 8
+  * is CPU primary with QPU opportunistic — the ctx below is no-QPU,
+@@ -48,6 +50,10 @@
+                                          int alpha, int beta, int8_t *tc0);
+ void ff_h264_h_loop_filter_luma_daedalus(uint8_t *pix, ptrdiff_t stride,
+                                          int alpha, int beta, int8_t *tc0);
+void ff_h264_v_loop_filter_chroma_daedalus(uint8_t *pix, ptrdiff_t stride,
+                                           int alpha, int beta, int8_t *tc0);
+void ff_h264_h_loop_filter_chroma_daedalus(uint8_t *pix, ptrdiff_t stride,
+                                           int alpha, int beta, int8_t *tc0);
+ 
+ void ff_h264_idct_add_daedalus(uint8_t *dst, int16_t *block, int stride)
+ {
+@@ -106,3 +112,41 @@
+     daedalus_recipe_dispatch_h264_deblock_luma_h(g_dctx, pix, (size_t)stride,
+                                                  1, &meta);
+ }
+
+void ff_h264_v_loop_filter_chroma_daedalus(uint8_t *pix, ptrdiff_t stride,
+                                           int alpha, int beta, int8_t *tc0)
+{
+    daedalus_h264_deblock_meta meta = {
+        .dst_off = 0,
+        .alpha   = alpha,
+        .beta    = beta,
+    };
+    meta.tc0[0] = tc0[0];
+    meta.tc0[1] = tc0[1];
+    meta.tc0[2] = tc0[2];
+    meta.tc0[3] = tc0[3];
+
+    pthread_once(&g_dctx_once, daedalus_ctx_init_once);
+
+    daedalus_recipe_dispatch_h264_deblock_chroma_v(g_dctx, pix, (size_t)stride,
+                                                   1, &meta);
+}
+
+void ff_h264_h_loop_filter_chroma_daedalus(uint8_t *pix, ptrdiff_t stride,
+                                           int alpha, int beta, int8_t *tc0)
+{
+    daedalus_h264_deblock_meta meta = {
+        .dst_off = 0,
+        .alpha   = alpha,
+        .beta    = beta,
+    };
+    meta.tc0[0] = tc0[0];
+    meta.tc0[1] = tc0[1];
+    meta.tc0[2] = tc0[2];
+    meta.tc0[3] = tc0[3];
+
+    pthread_once(&g_dctx_once, daedalus_ctx_init_once);
+
+    daedalus_recipe_dispatch_h264_deblock_chroma_h(g_dctx, pix, (size_t)stride,
+                                                   1, &meta);
+}
+diff --git a/libavcodec/aarch64/h264dsp_init_aarch64.c b/libavcodec/aarch64/h264dsp_init_aarch64.c
+--- a/libavcodec/aarch64/h264dsp_init_aarch64.c	2026-05-25 13:15:45.996482360 +0200
+++ libavcodec/aarch64/h264dsp_init_aarch64.c	2026-05-25 13:15:46.025604910 +0200
+@@ -39,8 +39,12 @@
+                                            int beta);
+ void ff_h264_v_loop_filter_chroma_neon(uint8_t *pix, ptrdiff_t stride, int alpha,
+                                        int beta, int8_t *tc0);
+void ff_h264_v_loop_filter_chroma_daedalus(uint8_t *pix, ptrdiff_t stride,
+                                           int alpha, int beta, int8_t *tc0);
+ void ff_h264_h_loop_filter_chroma_neon(uint8_t *pix, ptrdiff_t stride, int alpha,
+                                        int beta, int8_t *tc0);
+void ff_h264_h_loop_filter_chroma_daedalus(uint8_t *pix, ptrdiff_t stride,
+                                           int alpha, int beta, int8_t *tc0);
+ void ff_h264_h_loop_filter_chroma422_neon(uint8_t *pix, ptrdiff_t stride, int alpha,
+                                           int beta, int8_t *tc0);
+ void ff_h264_v_loop_filter_chroma_intra_neon(uint8_t *pix, ptrdiff_t stride,
+@@ -123,11 +127,11 @@
+         c->v_loop_filter_luma_intra= ff_h264_v_loop_filter_luma_intra_neon;
+         c->h_loop_filter_luma_intra= ff_h264_h_loop_filter_luma_intra_neon;
+ 
+-        c->v_loop_filter_chroma = ff_h264_v_loop_filter_chroma_neon;
+        c->v_loop_filter_chroma = ff_h264_v_loop_filter_chroma_daedalus;
+         c->v_loop_filter_chroma_intra = ff_h264_v_loop_filter_chroma_intra_neon;
+ 
+         if (chroma_format_idc <= 1) {
+-            c->h_loop_filter_chroma = ff_h264_h_loop_filter_chroma_neon;
+            c->h_loop_filter_chroma = ff_h264_h_loop_filter_chroma_daedalus;
+             c->h_loop_filter_chroma_intra = ff_h264_h_loop_filter_chroma_intra_neon;
+             c->h_loop_filter_chroma_mbaff_intra = ff_h264_h_loop_filter_chroma_mbaff_intra_neon;
+         } else {
+--
+2.47.3
+
@@ -0,0 +1,126 @@
+From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
+From: claude-noether <claude-noether@noreply.localhost>
+Date: Sun, 25 May 2026 12:30:00 +0200
+Subject: [PATCH] avcodec/aarch64/h264dsp: route H.264 luma intra deblock through daedalus-fourier
+
+Adds the bS=4 intra-strength variants of the already-substituted
+luma_v / luma_h deblock (0005, 0008).  Intra MBs and certain
+inter-MB edges (4x4 transform boundaries inside an Intra_NxN
+neighbour) force boundary strength to 4 per H.264 §8.7.2.1.
+
+  H264DSPContext.v_loop_filter_luma_intra →
+    daedalus_recipe_dispatch_h264_deblock_luma_v_intra
+  H264DSPContext.h_loop_filter_luma_intra →
+    daedalus_recipe_dispatch_h264_deblock_luma_h_intra
+
+Both kernels landed in daedalus-fourier PR #11.  Recipe table
+routes AUTO to CPU NEON (no intra QPU shaders yet) — plumbing-
+only NEON-to-NEON via daedalus, bit-exact against the in-tree
+FFmpeg NEON path.
+
+Signature differs from bS<4: no tc0 argument.  The wrapper
+passes daedalus_h264_deblock_meta with alpha/beta set; tc0[] is
+ignored by the intra dispatch (bS=4 hardcodes the strength).
+
+Chroma intra variants are deferred to a follow-up PR because the
+chroma path has a 4:2:0 / 4:2:2 split (chroma_format_idc gating)
+that needs explicit conditional substitution to avoid running
+the 4:2:0-only daedalus dispatch on 4:2:2 chroma.
+
+Refs reauktion/daedalus-v4l2#11 — substitution arc step 2 cycle 8 intra.
+---
+diff --git a/libavcodec/aarch64/h264_idct_daedalus.c b/libavcodec/aarch64/h264_idct_daedalus.c
+--- a/libavcodec/aarch64/h264_idct_daedalus.c	2026-05-25 13:18:54.992244965 +0200
+++ libavcodec/aarch64/h264_idct_daedalus.c	2026-05-25 13:20:12.338122217 +0200
+@@ -1,5 +1,5 @@
+ /*
+- * H.264 4x4 / 8x8 IDCT + luma v/h + chroma v/h deblock — daedalus-fourier substitution shims.
+ * H.264 4x4 / 8x8 IDCT + luma v/h (inter + intra) + chroma v/h deblock — daedalus-fourier substitution shims.
+  *
+  * Routes H264DSPContext.idct_add           → daedalus_recipe_dispatch_h264_idct4
+  *        H264DSPContext.idct8_add          → daedalus_recipe_dispatch_h264_idct8
+@@ -7,6 +7,8 @@
+  *        H264DSPContext.h_loop_filter_luma   → daedalus_recipe_dispatch_h264_deblock_luma_h
+  *        H264DSPContext.v_loop_filter_chroma → daedalus_recipe_dispatch_h264_deblock_chroma_v
+  *        H264DSPContext.h_loop_filter_chroma → daedalus_recipe_dispatch_h264_deblock_chroma_h
+ *        H264DSPContext.v_loop_filter_luma_intra → daedalus_recipe_dispatch_h264_deblock_luma_v_intra
+ *        H264DSPContext.h_loop_filter_luma_intra → daedalus_recipe_dispatch_h264_deblock_luma_h_intra
+  * instead of the in-tree ff_h264_*_neon assembly.  The recipe layer
+  * picks the substrate (CPU NEON for cycles 6 + 7 by default; cycle 8
+  * is CPU primary with QPU opportunistic — the ctx below is no-QPU,
+@@ -54,6 +56,10 @@
+                                            int alpha, int beta, int8_t *tc0);
+ void ff_h264_h_loop_filter_chroma_daedalus(uint8_t *pix, ptrdiff_t stride,
+                                            int alpha, int beta, int8_t *tc0);
+void ff_h264_v_loop_filter_luma_intra_daedalus(uint8_t *pix, ptrdiff_t stride,
+                                                int alpha, int beta);
+void ff_h264_h_loop_filter_luma_intra_daedalus(uint8_t *pix, ptrdiff_t stride,
+                                                int alpha, int beta);
+ 
+ void ff_h264_idct_add_daedalus(uint8_t *dst, int16_t *block, int stride)
+ {
+@@ -150,3 +156,34 @@
+     daedalus_recipe_dispatch_h264_deblock_chroma_h(g_dctx, pix, (size_t)stride,
+                                                    1, &meta);
+ }
+
+void ff_h264_v_loop_filter_luma_intra_daedalus(uint8_t *pix, ptrdiff_t stride,
+                                                int alpha, int beta)
+{
+    daedalus_h264_deblock_meta meta = {
+        .dst_off = 0,
+        .alpha   = alpha,
+        .beta    = beta,
+    };
+    /* tc0[] is ignored by the intra-strength dispatch (bS=4 hardcodes the strength). */
+
+    pthread_once(&g_dctx_once, daedalus_ctx_init_once);
+
+    daedalus_recipe_dispatch_h264_deblock_luma_v_intra(g_dctx, pix, (size_t)stride,
+                                                        1, &meta);
+}
+
+void ff_h264_h_loop_filter_luma_intra_daedalus(uint8_t *pix, ptrdiff_t stride,
+                                                int alpha, int beta)
+{
+    daedalus_h264_deblock_meta meta = {
+        .dst_off = 0,
+        .alpha   = alpha,
+        .beta    = beta,
+    };
+
+    pthread_once(&g_dctx_once, daedalus_ctx_init_once);
+
+    daedalus_recipe_dispatch_h264_deblock_luma_h_intra(g_dctx, pix, (size_t)stride,
+                                                        1, &meta);
+}
+diff --git a/libavcodec/aarch64/h264dsp_init_aarch64.c b/libavcodec/aarch64/h264dsp_init_aarch64.c
+--- a/libavcodec/aarch64/h264dsp_init_aarch64.c	2026-05-25 13:18:54.993349573 +0200
+++ libavcodec/aarch64/h264dsp_init_aarch64.c	2026-05-25 13:20:12.338265830 +0200
+@@ -35,8 +35,12 @@
+                                          int alpha, int beta, int8_t *tc0);
+ void ff_h264_v_loop_filter_luma_intra_neon(uint8_t *pix, ptrdiff_t stride, int alpha,
+                                            int beta);
+void ff_h264_v_loop_filter_luma_intra_daedalus(uint8_t *pix, ptrdiff_t stride,
+                                                int alpha, int beta);
+ void ff_h264_h_loop_filter_luma_intra_neon(uint8_t *pix, ptrdiff_t stride, int alpha,
+                                            int beta);
+void ff_h264_h_loop_filter_luma_intra_daedalus(uint8_t *pix, ptrdiff_t stride,
+                                                int alpha, int beta);
+ void ff_h264_v_loop_filter_chroma_neon(uint8_t *pix, ptrdiff_t stride, int alpha,
+                                        int beta, int8_t *tc0);
+ void ff_h264_v_loop_filter_chroma_daedalus(uint8_t *pix, ptrdiff_t stride,
+@@ -124,8 +128,8 @@
+     if (have_neon(cpu_flags) && bit_depth == 8) {
+         c->v_loop_filter_luma   = ff_h264_v_loop_filter_luma_daedalus;
+         c->h_loop_filter_luma   = ff_h264_h_loop_filter_luma_daedalus;
+-        c->v_loop_filter_luma_intra= ff_h264_v_loop_filter_luma_intra_neon;
+-        c->h_loop_filter_luma_intra= ff_h264_h_loop_filter_luma_intra_neon;
+        c->v_loop_filter_luma_intra= ff_h264_v_loop_filter_luma_intra_daedalus;
+        c->h_loop_filter_luma_intra= ff_h264_h_loop_filter_luma_intra_daedalus;
+ 
+         c->v_loop_filter_chroma = ff_h264_v_loop_filter_chroma_daedalus;
+         c->v_loop_filter_chroma_intra = ff_h264_v_loop_filter_chroma_intra_neon;
+--
+2.47.3
+
@@ -0,0 +1,101 @@
+From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
+From: claude-noether <claude-noether@noreply.localhost>
+Date: Sun, 25 May 2026 13:00:00 +0200
+Subject: [PATCH] avcodec/aarch64/h264dsp: route H.264 chroma DC Hadamard through daedalus-fourier
+
+Substitutes H264DSPContext.chroma_dc_dequant_idct in the
+4:2:0 / bit_depth=8 init path with a wrapper that composes
+the daedalus chroma DC Hadamard primitive (fourier PR #25)
+with qmul scaling FFmpeg does in one fused function.
+
+Bit-exact against ff_h264_chroma_dc_dequant_idct_8_c.
+Hadamard correctness gated by fourier PR #23 test suite.
+
+4:2:2 chroma stays on the in-tree 422 variant (same
+gating shape as 0009 chroma deblock substitution).
+
+Requires daedalus-fourier commit b9f9ff2 or later (PR #25
+exposing the public Hadamard symbol).  Pin bumps in PKGBUILD
+and build-deb.sh come in the same commit.
+---
+diff --git a/libavcodec/aarch64/h264_idct_daedalus.c b/libavcodec/aarch64/h264_idct_daedalus.c
+--- a/libavcodec/aarch64/h264_idct_daedalus.c	2026-05-25 13:38:32.019491484 +0200
+++ libavcodec/aarch64/h264_idct_daedalus.c	2026-05-25 13:38:32.033821507 +0200
+@@ -1,5 +1,5 @@
+ /*
+- * H.264 4x4 / 8x8 IDCT + luma v/h (inter + intra) + chroma v/h deblock — daedalus-fourier substitution shims.
+ * H.264 4x4 / 8x8 IDCT + luma v/h (inter+intra) + chroma v/h deblock + chroma DC Hadamard — daedalus-fourier substitution shims.
+  *
+  * Routes H264DSPContext.idct_add           → daedalus_recipe_dispatch_h264_idct4
+  *        H264DSPContext.idct8_add          → daedalus_recipe_dispatch_h264_idct8
+@@ -9,6 +9,7 @@
+  *        H264DSPContext.h_loop_filter_chroma → daedalus_recipe_dispatch_h264_deblock_chroma_h
+  *        H264DSPContext.v_loop_filter_luma_intra → daedalus_recipe_dispatch_h264_deblock_luma_v_intra
+  *        H264DSPContext.h_loop_filter_luma_intra → daedalus_recipe_dispatch_h264_deblock_luma_h_intra
+ *        H264DSPContext.chroma_dc_dequant_idct   → daedalus_h264_chroma_dc_hadamard_2x2 + caller-side qmul
+  * instead of the in-tree ff_h264_*_neon assembly.  The recipe layer
+  * picks the substrate (CPU NEON for cycles 6 + 7 by default; cycle 8
+  * is CPU primary with QPU opportunistic — the ctx below is no-QPU,
+@@ -60,6 +61,7 @@
+                                                 int alpha, int beta);
+ void ff_h264_h_loop_filter_luma_intra_daedalus(uint8_t *pix, ptrdiff_t stride,
+                                                 int alpha, int beta);
+void ff_h264_chroma_dc_dequant_idct_daedalus(int16_t *block, int qmul);
+ 
+ void ff_h264_idct_add_daedalus(uint8_t *dst, int16_t *block, int stride)
+ {
+@@ -187,3 +189,32 @@
+     daedalus_recipe_dispatch_h264_deblock_luma_h_intra(g_dctx, pix, (size_t)stride,
+                                                         1, &meta);
+ }
+
+/* Composes daedalus_h264_chroma_dc_hadamard_2x2 with the qmul scaling
+ * that FFmpeg's reference does in one fused function (h264idct_template.c
+ * ff_h264_chroma_dc_dequant_idct).
+ *
+ * The 4 DC coefficients are scattered across the per-MB coefficient
+ * buffer at offsets [r*stride + c*xStride] (stride=32, xStride=16).
+ * Extract into a contiguous int16[4], run the Hadamard, then apply
+ * the qmul scale and write back to the original positions.
+ *
+ * No daedalus ctx needed; the Hadamard is a pure stateless primitive.
+ */
+void ff_h264_chroma_dc_dequant_idct_daedalus(int16_t *block, int qmul)
+{
+    enum { stride = 32, xStride = 16 };
+    int16_t dc[4];
+
+    dc[0] = block[stride*0 + xStride*0];
+    dc[1] = block[stride*0 + xStride*1];
+    dc[2] = block[stride*1 + xStride*0];
+    dc[3] = block[stride*1 + xStride*1];
+
+    daedalus_h264_chroma_dc_hadamard_2x2(dc);
+
+    block[stride*0 + xStride*0] = (int16_t)((int)dc[0] * qmul >> 7);
+    block[stride*0 + xStride*1] = (int16_t)((int)dc[1] * qmul >> 7);
+    block[stride*1 + xStride*0] = (int16_t)((int)dc[2] * qmul >> 7);
+    block[stride*1 + xStride*1] = (int16_t)((int)dc[3] * qmul >> 7);
+}
+diff --git a/libavcodec/aarch64/h264dsp_init_aarch64.c b/libavcodec/aarch64/h264dsp_init_aarch64.c
+--- a/libavcodec/aarch64/h264dsp_init_aarch64.c	2026-05-25 13:38:32.020346459 +0200
+++ libavcodec/aarch64/h264dsp_init_aarch64.c	2026-05-25 13:38:32.033909804 +0200
+@@ -41,6 +41,7 @@
+                                            int beta);
+ void ff_h264_h_loop_filter_luma_intra_daedalus(uint8_t *pix, ptrdiff_t stride,
+                                                 int alpha, int beta);
+void ff_h264_chroma_dc_dequant_idct_daedalus(int16_t *block, int qmul);
+ void ff_h264_v_loop_filter_chroma_neon(uint8_t *pix, ptrdiff_t stride, int alpha,
+                                        int beta, int8_t *tc0);
+ void ff_h264_v_loop_filter_chroma_daedalus(uint8_t *pix, ptrdiff_t stride,
+@@ -135,6 +136,7 @@
+         c->v_loop_filter_chroma_intra = ff_h264_v_loop_filter_chroma_intra_neon;
+ 
+         if (chroma_format_idc <= 1) {
+            c->chroma_dc_dequant_idct = ff_h264_chroma_dc_dequant_idct_daedalus;
+             c->h_loop_filter_chroma = ff_h264_h_loop_filter_chroma_daedalus;
+             c->h_loop_filter_chroma_intra = ff_h264_h_loop_filter_chroma_intra_neon;
+             c->h_loop_filter_chroma_mbaff_intra = ff_h264_h_loop_filter_chroma_mbaff_intra_neon;
+--
+2.47.3
+
@@ -0,0 +1,245 @@
+From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
+From: claude-noether <claude-noether@noreply.localhost>
+Date: Sun, 25 May 2026 14:00:00 +0200
+Subject: [PATCH] avcodec/aarch64/h264qpel: route remaining qpel 8x8 positions through daedalus-fourier
+
+Closes the H.264 qpel substitution.  Extends 0007 (which routed only
+mc20 put_) to ALL 15 useful positions in BOTH the put_ and avg_
+tables, skipping mc00 (integer copy / pointer-only fast path).
+
+29 substitutions total: 14 new put_ + 15 avg_.  Each is a uniform
+wrapper around daedalus_recipe_dispatch_h264_qpel_{avg_,}mcXY exposed
+by daedalus-fourier PRs #15-#20.
+
+All recipe-table entries route AUTO to CPU NEON (no QPU shaders
+for any qpel position other than mc20 yet), so this is plumbing-only
+NEON-to-NEON — bit-exact against the in-tree ff_*_h264_qpel8_*_neon
+path.
+
+16x16 qpel tables ([0][...]) stay on the in-tree NEON.  daedalus
+only exposes 8x8 today; 16x16 substitution can land once fourier
+provides those variants (likely just dispatching the 8x8 path four
+times with shifted dst/src offsets).
+
+Refs reauktion/daedalus-v4l2#11 — substitution arc qpel buildout.
+---
+diff --git a/libavcodec/aarch64/h264_qpel_daedalus.c b/libavcodec/aarch64/h264_qpel_daedalus.c
+--- a/libavcodec/aarch64/h264_qpel_daedalus.c	2026-05-25 14:05:05.789298250 +0200
+++ libavcodec/aarch64/h264_qpel_daedalus.c	2026-05-25 14:05:05.818358374 +0200
+@@ -1,10 +1,13 @@
+ /*
+- * H.264 luma qpel mc20 (8x8, horizontal half-pel, 6-tap "put")
+- * — daedalus-fourier substitution shim.
+ * H.264 luma qpel 8x8 — daedalus-fourier substitution shims (put_ + avg_).
+  *
+- * Routes H264QpelContext.put_h264_qpel_pixels_tab[1][2] through
+- * daedalus_recipe_dispatch_h264_qpel_mc20 instead of
+- * ff_put_h264_qpel8_mc20_neon.  The recipe layer picks the substrate
+ * Routes ALL 15 useful positions in H264QpelContext's 8x8 put_ and
+ * avg_ tables through daedalus_recipe_dispatch_h264_qpel_mc{XY}
+ * (skipping mc00 which is integer copy / FFmpeg's pointer-only fast
+ * path).  Plumbing-only NEON-by-recipe — daedalus-fourier PRs #15-#20
+ * exposed each variant via the same dispatch signature, so the
+ * substitution is a uniform macro across put_/avg_ and across all
+ * 15 mc positions.  The recipe layer picks the substrate
+  * (CPU NEON for cycle 9; QPU not viable — per-block 7.6 ns vs
+  * ~250 ns QPU dispatch floor, see docs/k9_h264qpel_mc20.md).
+  *
+@@ -48,3 +51,53 @@
+     daedalus_recipe_dispatch_h264_qpel_mc20(g_dctx, dst, src, (size_t)stride,
+                                             1, &meta);
+ }
+
+
+/* All other 8x8 qpel positions follow the same dispatch shape as mc20
+ * above.  The macro collapses ~600 LOC of one-wrapper-per-variant
+ * boilerplate (29 variants total: 14 put_ + 15 avg_). */
+#define DEFINE_QPEL_WRAPPER(type, suffix, dispatch_fn)                          \
+void ff_ ## type ## _h264_qpel8_ ## suffix ## _daedalus(uint8_t *dst,           \
+    const uint8_t *src, ptrdiff_t stride);                                      \
+void ff_ ## type ## _h264_qpel8_ ## suffix ## _daedalus(uint8_t *dst,           \
+    const uint8_t *src, ptrdiff_t stride)                                       \
+{                                                                               \
+    static const daedalus_h264_qpel_meta meta = { .dst_off = 0, .src_off = 0 }; \
+    pthread_once(&g_dctx_once, daedalus_ctx_init_once);                         \
+    dispatch_fn(g_dctx, dst, src, (size_t)stride, 1, &meta);                    \
+}
+
+/* put_ variants (mc20 stays on the explicit definition above). */
+DEFINE_QPEL_WRAPPER(put, mc10, daedalus_recipe_dispatch_h264_qpel_mc10)
+DEFINE_QPEL_WRAPPER(put, mc30, daedalus_recipe_dispatch_h264_qpel_mc30)
+DEFINE_QPEL_WRAPPER(put, mc01, daedalus_recipe_dispatch_h264_qpel_mc01)
+DEFINE_QPEL_WRAPPER(put, mc11, daedalus_recipe_dispatch_h264_qpel_mc11)
+DEFINE_QPEL_WRAPPER(put, mc21, daedalus_recipe_dispatch_h264_qpel_mc21)
+DEFINE_QPEL_WRAPPER(put, mc31, daedalus_recipe_dispatch_h264_qpel_mc31)
+DEFINE_QPEL_WRAPPER(put, mc02, daedalus_recipe_dispatch_h264_qpel_mc02)
+DEFINE_QPEL_WRAPPER(put, mc12, daedalus_recipe_dispatch_h264_qpel_mc12)
+DEFINE_QPEL_WRAPPER(put, mc22, daedalus_recipe_dispatch_h264_qpel_mc22)
+DEFINE_QPEL_WRAPPER(put, mc32, daedalus_recipe_dispatch_h264_qpel_mc32)
+DEFINE_QPEL_WRAPPER(put, mc03, daedalus_recipe_dispatch_h264_qpel_mc03)
+DEFINE_QPEL_WRAPPER(put, mc13, daedalus_recipe_dispatch_h264_qpel_mc13)
+DEFINE_QPEL_WRAPPER(put, mc23, daedalus_recipe_dispatch_h264_qpel_mc23)
+DEFINE_QPEL_WRAPPER(put, mc33, daedalus_recipe_dispatch_h264_qpel_mc33)
+
+/* avg_ variants — all 15 useful positions. */
+DEFINE_QPEL_WRAPPER(avg, mc10, daedalus_recipe_dispatch_h264_qpel_avg_mc10)
+DEFINE_QPEL_WRAPPER(avg, mc20, daedalus_recipe_dispatch_h264_qpel_avg_mc20)
+DEFINE_QPEL_WRAPPER(avg, mc30, daedalus_recipe_dispatch_h264_qpel_avg_mc30)
+DEFINE_QPEL_WRAPPER(avg, mc01, daedalus_recipe_dispatch_h264_qpel_avg_mc01)
+DEFINE_QPEL_WRAPPER(avg, mc11, daedalus_recipe_dispatch_h264_qpel_avg_mc11)
+DEFINE_QPEL_WRAPPER(avg, mc21, daedalus_recipe_dispatch_h264_qpel_avg_mc21)
+DEFINE_QPEL_WRAPPER(avg, mc31, daedalus_recipe_dispatch_h264_qpel_avg_mc31)
+DEFINE_QPEL_WRAPPER(avg, mc02, daedalus_recipe_dispatch_h264_qpel_avg_mc02)
+DEFINE_QPEL_WRAPPER(avg, mc12, daedalus_recipe_dispatch_h264_qpel_avg_mc12)
+DEFINE_QPEL_WRAPPER(avg, mc22, daedalus_recipe_dispatch_h264_qpel_avg_mc22)
+DEFINE_QPEL_WRAPPER(avg, mc32, daedalus_recipe_dispatch_h264_qpel_avg_mc32)
+DEFINE_QPEL_WRAPPER(avg, mc03, daedalus_recipe_dispatch_h264_qpel_avg_mc03)
+DEFINE_QPEL_WRAPPER(avg, mc13, daedalus_recipe_dispatch_h264_qpel_avg_mc13)
+DEFINE_QPEL_WRAPPER(avg, mc23, daedalus_recipe_dispatch_h264_qpel_avg_mc23)
+DEFINE_QPEL_WRAPPER(avg, mc33, daedalus_recipe_dispatch_h264_qpel_avg_mc33)
+
+#undef DEFINE_QPEL_WRAPPER
+diff --git a/libavcodec/aarch64/h264qpel_init_aarch64.c b/libavcodec/aarch64/h264qpel_init_aarch64.c
+--- a/libavcodec/aarch64/h264qpel_init_aarch64.c	2026-05-25 14:05:05.790403989 +0200
+++ libavcodec/aarch64/h264qpel_init_aarch64.c	2026-05-25 14:05:05.819136071 +0200
+@@ -50,6 +50,64 @@
+ void ff_put_h264_qpel8_mc30_neon(uint8_t *dst, const uint8_t *src, ptrdiff_t stride);
+ void ff_put_h264_qpel8_mc20_daedalus(uint8_t *dst, const uint8_t *src,
+                                      ptrdiff_t stride);
+void ff_put_h264_qpel8_mc10_daedalus(uint8_t *dst, const uint8_t *src,
+                                  ptrdiff_t stride);
+void ff_put_h264_qpel8_mc30_daedalus(uint8_t *dst, const uint8_t *src,
+                                  ptrdiff_t stride);
+void ff_put_h264_qpel8_mc01_daedalus(uint8_t *dst, const uint8_t *src,
+                                  ptrdiff_t stride);
+void ff_put_h264_qpel8_mc11_daedalus(uint8_t *dst, const uint8_t *src,
+                                  ptrdiff_t stride);
+void ff_put_h264_qpel8_mc21_daedalus(uint8_t *dst, const uint8_t *src,
+                                  ptrdiff_t stride);
+void ff_put_h264_qpel8_mc31_daedalus(uint8_t *dst, const uint8_t *src,
+                                  ptrdiff_t stride);
+void ff_put_h264_qpel8_mc02_daedalus(uint8_t *dst, const uint8_t *src,
+                                  ptrdiff_t stride);
+void ff_put_h264_qpel8_mc12_daedalus(uint8_t *dst, const uint8_t *src,
+                                  ptrdiff_t stride);
+void ff_put_h264_qpel8_mc22_daedalus(uint8_t *dst, const uint8_t *src,
+                                  ptrdiff_t stride);
+void ff_put_h264_qpel8_mc32_daedalus(uint8_t *dst, const uint8_t *src,
+                                  ptrdiff_t stride);
+void ff_put_h264_qpel8_mc03_daedalus(uint8_t *dst, const uint8_t *src,
+                                  ptrdiff_t stride);
+void ff_put_h264_qpel8_mc13_daedalus(uint8_t *dst, const uint8_t *src,
+                                  ptrdiff_t stride);
+void ff_put_h264_qpel8_mc23_daedalus(uint8_t *dst, const uint8_t *src,
+                                  ptrdiff_t stride);
+void ff_put_h264_qpel8_mc33_daedalus(uint8_t *dst, const uint8_t *src,
+                                  ptrdiff_t stride);
+void ff_avg_h264_qpel8_mc10_daedalus(uint8_t *dst, const uint8_t *src,
+                                  ptrdiff_t stride);
+void ff_avg_h264_qpel8_mc20_daedalus(uint8_t *dst, const uint8_t *src,
+                                  ptrdiff_t stride);
+void ff_avg_h264_qpel8_mc30_daedalus(uint8_t *dst, const uint8_t *src,
+                                  ptrdiff_t stride);
+void ff_avg_h264_qpel8_mc01_daedalus(uint8_t *dst, const uint8_t *src,
+                                  ptrdiff_t stride);
+void ff_avg_h264_qpel8_mc11_daedalus(uint8_t *dst, const uint8_t *src,
+                                  ptrdiff_t stride);
+void ff_avg_h264_qpel8_mc21_daedalus(uint8_t *dst, const uint8_t *src,
+                                  ptrdiff_t stride);
+void ff_avg_h264_qpel8_mc31_daedalus(uint8_t *dst, const uint8_t *src,
+                                  ptrdiff_t stride);
+void ff_avg_h264_qpel8_mc02_daedalus(uint8_t *dst, const uint8_t *src,
+                                  ptrdiff_t stride);
+void ff_avg_h264_qpel8_mc12_daedalus(uint8_t *dst, const uint8_t *src,
+                                  ptrdiff_t stride);
+void ff_avg_h264_qpel8_mc22_daedalus(uint8_t *dst, const uint8_t *src,
+                                  ptrdiff_t stride);
+void ff_avg_h264_qpel8_mc32_daedalus(uint8_t *dst, const uint8_t *src,
+                                  ptrdiff_t stride);
+void ff_avg_h264_qpel8_mc03_daedalus(uint8_t *dst, const uint8_t *src,
+                                  ptrdiff_t stride);
+void ff_avg_h264_qpel8_mc13_daedalus(uint8_t *dst, const uint8_t *src,
+                                  ptrdiff_t stride);
+void ff_avg_h264_qpel8_mc23_daedalus(uint8_t *dst, const uint8_t *src,
+                                  ptrdiff_t stride);
+void ff_avg_h264_qpel8_mc33_daedalus(uint8_t *dst, const uint8_t *src,
+                                  ptrdiff_t stride);
+ void ff_put_h264_qpel8_mc01_neon(uint8_t *dst, const uint8_t *src, ptrdiff_t stride);
+ void ff_put_h264_qpel8_mc11_neon(uint8_t *dst, const uint8_t *src, ptrdiff_t stride);
+ void ff_put_h264_qpel8_mc21_neon(uint8_t *dst, const uint8_t *src, ptrdiff_t stride);
+@@ -164,21 +222,21 @@
+         c->put_h264_qpel_pixels_tab[0][15] = ff_put_h264_qpel16_mc33_neon;
+ 
+         c->put_h264_qpel_pixels_tab[1][ 0] = ff_put_h264_qpel8_mc00_neon;
+-        c->put_h264_qpel_pixels_tab[1][ 1] = ff_put_h264_qpel8_mc10_neon;
+        c->put_h264_qpel_pixels_tab[1][ 1] = ff_put_h264_qpel8_mc10_daedalus;
+         c->put_h264_qpel_pixels_tab[1][ 2] = ff_put_h264_qpel8_mc20_daedalus;
+-        c->put_h264_qpel_pixels_tab[1][ 3] = ff_put_h264_qpel8_mc30_neon;
+-        c->put_h264_qpel_pixels_tab[1][ 4] = ff_put_h264_qpel8_mc01_neon;
+-        c->put_h264_qpel_pixels_tab[1][ 5] = ff_put_h264_qpel8_mc11_neon;
+-        c->put_h264_qpel_pixels_tab[1][ 6] = ff_put_h264_qpel8_mc21_neon;
+-        c->put_h264_qpel_pixels_tab[1][ 7] = ff_put_h264_qpel8_mc31_neon;
+-        c->put_h264_qpel_pixels_tab[1][ 8] = ff_put_h264_qpel8_mc02_neon;
+-        c->put_h264_qpel_pixels_tab[1][ 9] = ff_put_h264_qpel8_mc12_neon;
+-        c->put_h264_qpel_pixels_tab[1][10] = ff_put_h264_qpel8_mc22_neon;
+-        c->put_h264_qpel_pixels_tab[1][11] = ff_put_h264_qpel8_mc32_neon;
+-        c->put_h264_qpel_pixels_tab[1][12] = ff_put_h264_qpel8_mc03_neon;
+-        c->put_h264_qpel_pixels_tab[1][13] = ff_put_h264_qpel8_mc13_neon;
+-        c->put_h264_qpel_pixels_tab[1][14] = ff_put_h264_qpel8_mc23_neon;
+-        c->put_h264_qpel_pixels_tab[1][15] = ff_put_h264_qpel8_mc33_neon;
+        c->put_h264_qpel_pixels_tab[1][ 3] = ff_put_h264_qpel8_mc30_daedalus;
+        c->put_h264_qpel_pixels_tab[1][ 4] = ff_put_h264_qpel8_mc01_daedalus;
+        c->put_h264_qpel_pixels_tab[1][ 5] = ff_put_h264_qpel8_mc11_daedalus;
+        c->put_h264_qpel_pixels_tab[1][ 6] = ff_put_h264_qpel8_mc21_daedalus;
+        c->put_h264_qpel_pixels_tab[1][ 7] = ff_put_h264_qpel8_mc31_daedalus;
+        c->put_h264_qpel_pixels_tab[1][ 8] = ff_put_h264_qpel8_mc02_daedalus;
+        c->put_h264_qpel_pixels_tab[1][ 9] = ff_put_h264_qpel8_mc12_daedalus;
+        c->put_h264_qpel_pixels_tab[1][10] = ff_put_h264_qpel8_mc22_daedalus;
+        c->put_h264_qpel_pixels_tab[1][11] = ff_put_h264_qpel8_mc32_daedalus;
+        c->put_h264_qpel_pixels_tab[1][12] = ff_put_h264_qpel8_mc03_daedalus;
+        c->put_h264_qpel_pixels_tab[1][13] = ff_put_h264_qpel8_mc13_daedalus;
+        c->put_h264_qpel_pixels_tab[1][14] = ff_put_h264_qpel8_mc23_daedalus;
+        c->put_h264_qpel_pixels_tab[1][15] = ff_put_h264_qpel8_mc33_daedalus;
+ 
+         c->avg_h264_qpel_pixels_tab[0][ 0] = ff_avg_h264_qpel16_mc00_neon;
+         c->avg_h264_qpel_pixels_tab[0][ 1] = ff_avg_h264_qpel16_mc10_neon;
+@@ -198,21 +256,21 @@
+         c->avg_h264_qpel_pixels_tab[0][15] = ff_avg_h264_qpel16_mc33_neon;
+ 
+         c->avg_h264_qpel_pixels_tab[1][ 0] = ff_avg_h264_qpel8_mc00_neon;
+-        c->avg_h264_qpel_pixels_tab[1][ 1] = ff_avg_h264_qpel8_mc10_neon;
+-        c->avg_h264_qpel_pixels_tab[1][ 2] = ff_avg_h264_qpel8_mc20_neon;
+-        c->avg_h264_qpel_pixels_tab[1][ 3] = ff_avg_h264_qpel8_mc30_neon;
+-        c->avg_h264_qpel_pixels_tab[1][ 4] = ff_avg_h264_qpel8_mc01_neon;
+-        c->avg_h264_qpel_pixels_tab[1][ 5] = ff_avg_h264_qpel8_mc11_neon;
+-        c->avg_h264_qpel_pixels_tab[1][ 6] = ff_avg_h264_qpel8_mc21_neon;
+-        c->avg_h264_qpel_pixels_tab[1][ 7] = ff_avg_h264_qpel8_mc31_neon;
+-        c->avg_h264_qpel_pixels_tab[1][ 8] = ff_avg_h264_qpel8_mc02_neon;
+-        c->avg_h264_qpel_pixels_tab[1][ 9] = ff_avg_h264_qpel8_mc12_neon;
+-        c->avg_h264_qpel_pixels_tab[1][10] = ff_avg_h264_qpel8_mc22_neon;
+-        c->avg_h264_qpel_pixels_tab[1][11] = ff_avg_h264_qpel8_mc32_neon;
+-        c->avg_h264_qpel_pixels_tab[1][12] = ff_avg_h264_qpel8_mc03_neon;
+-        c->avg_h264_qpel_pixels_tab[1][13] = ff_avg_h264_qpel8_mc13_neon;
+-        c->avg_h264_qpel_pixels_tab[1][14] = ff_avg_h264_qpel8_mc23_neon;
+-        c->avg_h264_qpel_pixels_tab[1][15] = ff_avg_h264_qpel8_mc33_neon;
+        c->avg_h264_qpel_pixels_tab[1][ 1] = ff_avg_h264_qpel8_mc10_daedalus;
+        c->avg_h264_qpel_pixels_tab[1][ 2] = ff_avg_h264_qpel8_mc20_daedalus;
+        c->avg_h264_qpel_pixels_tab[1][ 3] = ff_avg_h264_qpel8_mc30_daedalus;
+        c->avg_h264_qpel_pixels_tab[1][ 4] = ff_avg_h264_qpel8_mc01_daedalus;
+        c->avg_h264_qpel_pixels_tab[1][ 5] = ff_avg_h264_qpel8_mc11_daedalus;
+        c->avg_h264_qpel_pixels_tab[1][ 6] = ff_avg_h264_qpel8_mc21_daedalus;
+        c->avg_h264_qpel_pixels_tab[1][ 7] = ff_avg_h264_qpel8_mc31_daedalus;
+        c->avg_h264_qpel_pixels_tab[1][ 8] = ff_avg_h264_qpel8_mc02_daedalus;
+        c->avg_h264_qpel_pixels_tab[1][ 9] = ff_avg_h264_qpel8_mc12_daedalus;
+        c->avg_h264_qpel_pixels_tab[1][10] = ff_avg_h264_qpel8_mc22_daedalus;
+        c->avg_h264_qpel_pixels_tab[1][11] = ff_avg_h264_qpel8_mc32_daedalus;
+        c->avg_h264_qpel_pixels_tab[1][12] = ff_avg_h264_qpel8_mc03_daedalus;
+        c->avg_h264_qpel_pixels_tab[1][13] = ff_avg_h264_qpel8_mc13_daedalus;
+        c->avg_h264_qpel_pixels_tab[1][14] = ff_avg_h264_qpel8_mc23_daedalus;
+        c->avg_h264_qpel_pixels_tab[1][15] = ff_avg_h264_qpel8_mc33_daedalus;
+     } else if (have_neon(cpu_flags) && bit_depth == 10) {
+         c->put_h264_qpel_pixels_tab[0][ 1] = ff_put_h264_qpel16_mc10_neon_10;
+         c->put_h264_qpel_pixels_tab[0][ 2] = ff_put_h264_qpel16_mc20_neon_10;
+--
+2.47.3
+
@@ -0,0 +1,120 @@
+From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
+From: claude-noether <claude-noether@noreply.localhost>
+Date: Sun, 25 May 2026 14:30:00 +0200
+Subject: [PATCH] avcodec/aarch64/h264dsp: route H.264 chroma intra deblock (4:2:0) through daedalus-fourier
+
+Substitutes c->v_loop_filter_chroma_intra and c->h_loop_filter_chroma_intra
+with daedalus wrappers in the bit_depth=8 / chroma_format_idc<=1 (4:2:0)
+branch.  4:2:2 stays on the in-tree NEON path (the daedalus chroma intra
+dispatch is 4:2:0-only).
+
+The fourier dispatches were exposed in PR #11 (DEFINE_INTRA_DISPATCH
+macro generates the public daedalus_dispatch_h264_deblock_chroma_*_intra
+symbols + recipe wrappers).
+
+Re-architects the chroma init: v_loop_filter_chroma_intra was previously
+assigned unconditionally to the NEON variant (which works for both 4:2:0
+and 4:2:2).  We now assign it INSIDE both branches of the chroma_format_idc
+conditional, with the 4:2:0 branch picking daedalus and the 4:2:2 branch
+keeping NEON.  No regression for 4:2:2 streams.
+
+Same NEON-to-NEON via recipe shape as 0010 luma intra.
+
+Refs reauktion/daedalus-v4l2#11 — substitution arc chroma intra.
+---
+diff --git a/libavcodec/aarch64/h264_idct_daedalus.c b/libavcodec/aarch64/h264_idct_daedalus.c
+--- a/libavcodec/aarch64/h264_idct_daedalus.c	2026-05-25 14:21:08.267156263 +0200
+++ libavcodec/aarch64/h264_idct_daedalus.c	2026-05-25 14:21:08.287745931 +0200
+@@ -1,5 +1,5 @@
+ /*
+- * H.264 4x4 / 8x8 IDCT + luma v/h (inter+intra) + chroma v/h deblock + chroma DC Hadamard — daedalus-fourier substitution shims.
+ * H.264 4x4 / 8x8 IDCT + luma v/h (inter+intra) + chroma v/h (inter+intra) deblock + chroma DC Hadamard — daedalus-fourier substitution shims.
+  *
+  * Routes H264DSPContext.idct_add           → daedalus_recipe_dispatch_h264_idct4
+  *        H264DSPContext.idct8_add          → daedalus_recipe_dispatch_h264_idct8
+@@ -9,6 +9,8 @@
+  *        H264DSPContext.h_loop_filter_chroma → daedalus_recipe_dispatch_h264_deblock_chroma_h
+  *        H264DSPContext.v_loop_filter_luma_intra → daedalus_recipe_dispatch_h264_deblock_luma_v_intra
+  *        H264DSPContext.h_loop_filter_luma_intra → daedalus_recipe_dispatch_h264_deblock_luma_h_intra
+ *        H264DSPContext.v_loop_filter_chroma_intra → daedalus_recipe_dispatch_h264_deblock_chroma_v_intra
+ *        H264DSPContext.h_loop_filter_chroma_intra → daedalus_recipe_dispatch_h264_deblock_chroma_h_intra
+  *        H264DSPContext.chroma_dc_dequant_idct   → daedalus_h264_chroma_dc_hadamard_2x2 + caller-side qmul
+  * instead of the in-tree ff_h264_*_neon assembly.  The recipe layer
+  * picks the substrate (CPU NEON for cycles 6 + 7 by default; cycle 8
+@@ -61,6 +63,10 @@
+                                                 int alpha, int beta);
+ void ff_h264_h_loop_filter_luma_intra_daedalus(uint8_t *pix, ptrdiff_t stride,
+                                                 int alpha, int beta);
+void ff_h264_v_loop_filter_chroma_intra_daedalus(uint8_t *pix, ptrdiff_t stride,
+                                                 int alpha, int beta);
+void ff_h264_h_loop_filter_chroma_intra_daedalus(uint8_t *pix, ptrdiff_t stride,
+                                                 int alpha, int beta);
+ void ff_h264_chroma_dc_dequant_idct_daedalus(int16_t *block, int qmul);
+ 
+ void ff_h264_idct_add_daedalus(uint8_t *dst, int16_t *block, int stride)
+@@ -218,3 +224,30 @@
+     block[stride*1 + xStride*0] = (int16_t)((int)dc[2] * qmul >> 7);
+     block[stride*1 + xStride*1] = (int16_t)((int)dc[3] * qmul >> 7);
+ }
+
+void ff_h264_v_loop_filter_chroma_intra_daedalus(uint8_t *pix, ptrdiff_t stride,
+                                                 int alpha, int beta)
+{
+    daedalus_h264_deblock_meta meta = {
+        .dst_off = 0,
+        .alpha   = alpha,
+        .beta    = beta,
+    };
+    /* tc0[] unused for intra (bS=4 hardcodes the strength). */
+    pthread_once(&g_dctx_once, daedalus_ctx_init_once);
+    daedalus_recipe_dispatch_h264_deblock_chroma_v_intra(g_dctx, pix, (size_t)stride,
+                                                          1, &meta);
+}
+
+void ff_h264_h_loop_filter_chroma_intra_daedalus(uint8_t *pix, ptrdiff_t stride,
+                                                 int alpha, int beta)
+{
+    daedalus_h264_deblock_meta meta = {
+        .dst_off = 0,
+        .alpha   = alpha,
+        .beta    = beta,
+    };
+    pthread_once(&g_dctx_once, daedalus_ctx_init_once);
+    daedalus_recipe_dispatch_h264_deblock_chroma_h_intra(g_dctx, pix, (size_t)stride,
+                                                          1, &meta);
+}
+diff --git a/libavcodec/aarch64/h264dsp_init_aarch64.c b/libavcodec/aarch64/h264dsp_init_aarch64.c
+--- a/libavcodec/aarch64/h264dsp_init_aarch64.c	2026-05-25 14:21:08.268311057 +0200
+++ libavcodec/aarch64/h264dsp_init_aarch64.c	2026-05-25 14:21:08.287886563 +0200
+@@ -42,6 +42,10 @@
+ void ff_h264_h_loop_filter_luma_intra_daedalus(uint8_t *pix, ptrdiff_t stride,
+                                                 int alpha, int beta);
+ void ff_h264_chroma_dc_dequant_idct_daedalus(int16_t *block, int qmul);
+void ff_h264_v_loop_filter_chroma_intra_daedalus(uint8_t *pix, ptrdiff_t stride,
+                                                 int alpha, int beta);
+void ff_h264_h_loop_filter_chroma_intra_daedalus(uint8_t *pix, ptrdiff_t stride,
+                                                 int alpha, int beta);
+ void ff_h264_v_loop_filter_chroma_neon(uint8_t *pix, ptrdiff_t stride, int alpha,
+                                        int beta, int8_t *tc0);
+ void ff_h264_v_loop_filter_chroma_daedalus(uint8_t *pix, ptrdiff_t stride,
+@@ -133,14 +137,15 @@
+         c->h_loop_filter_luma_intra= ff_h264_h_loop_filter_luma_intra_daedalus;
+ 
+         c->v_loop_filter_chroma = ff_h264_v_loop_filter_chroma_daedalus;
+-        c->v_loop_filter_chroma_intra = ff_h264_v_loop_filter_chroma_intra_neon;
+ 
+         if (chroma_format_idc <= 1) {
+             c->chroma_dc_dequant_idct = ff_h264_chroma_dc_dequant_idct_daedalus;
+            c->v_loop_filter_chroma_intra = ff_h264_v_loop_filter_chroma_intra_daedalus;
+             c->h_loop_filter_chroma = ff_h264_h_loop_filter_chroma_daedalus;
+-            c->h_loop_filter_chroma_intra = ff_h264_h_loop_filter_chroma_intra_neon;
+            c->h_loop_filter_chroma_intra = ff_h264_h_loop_filter_chroma_intra_daedalus;
+             c->h_loop_filter_chroma_mbaff_intra = ff_h264_h_loop_filter_chroma_mbaff_intra_neon;
+         } else {
+            c->v_loop_filter_chroma_intra = ff_h264_v_loop_filter_chroma_intra_neon;
+             c->h_loop_filter_chroma = ff_h264_h_loop_filter_chroma422_neon;
+             c->h_loop_filter_chroma_mbaff = ff_h264_h_loop_filter_chroma_neon;
+             c->h_loop_filter_chroma_intra = ff_h264_h_loop_filter_chroma422_intra_neon;
+--
+2.47.3
+
@@ -45,7 +45,7 @@ PKGREL=10  # pkgrel=10 — H.264 luma qpel mc20 daedalus-fourier substitution
 # DAEDALUS_KERNEL_H264_QPEL_MC20.  Cycle 9 plumbs the last H.264 NEON
 # kernel through the recipe layer.  Daemon-side build (debian/daedalus-v4l2)
 # can bump in a follow-up; this PR only changes the libavcodec.so consumer.
-DAEDALUS_FOURIER_COMMIT=209a4218bcb98b91c04f07ad61513bb04adb13ad
+DAEDALUS_FOURIER_COMMIT=b9f9ff2a89c068aea54dcb52b543afddad28311e  # PR #25 — public chroma DC Hadamard

 HERE=$(dirname "$(readlink -f "$0")")

@@ -74,6 +74,12 @@ patch -Np1 -i "$HERE/0004-h264-idct8-daedalus-fourier.patch"
 patch -Np1 -i "$HERE/0005-h264-deblock-luma-v-daedalus-fourier.patch"
 patch -Np1 -i "$HERE/0006-h264-restore-low-delay.patch"
 patch -Np1 -i "$HERE/0007-h264-qpel-mc20-daedalus-fourier.patch"
+patch -Np1 -i "$HERE/0008-h264-deblock-luma-h-daedalus-fourier.patch"
+patch -Np1 -i "$HERE/0009-h264-deblock-chroma-daedalus-fourier.patch"
+patch -Np1 -i "$HERE/0010-h264-deblock-luma-intra-daedalus-fourier.patch"
+patch -Np1 -i "$HERE/0011-h264-chroma-dc-hadamard-daedalus-fourier.patch"
+patch -Np1 -i "$HERE/0012-h264-qpel-rest-daedalus-fourier.patch"
+patch -Np1 -i "$HERE/0013-h264-deblock-chroma-intra-daedalus-fourier.patch"

 # --- daedalus-fourier: fetch + build static .a with PIC, install to a
 # per-build prefix; libavcodec.so links it into the shared object so
Author	SHA1	Message	Date
claude-noether	8f9487d355	ffmpeg-v4l2-request-fourier: route H.264 chroma intra deblock (4:2:0) through daedalus-fourier (0013) Substitutes c->v_loop_filter_chroma_intra and c->h_loop_filter_chroma_intra with daedalus wrappers in the bit_depth=8 / chroma_format_idc<=1 (4:2:0) branch. 4:2:2 stays on the in-tree NEON path (the daedalus chroma intra dispatch is 4:2:0-only). The fourier dispatches were exposed in PR #11 (DEFINE_INTRA_DISPATCH macro generates the public daedalus_dispatch_h264_deblock_chroma_*_intra symbols + recipe wrappers). Re-architects the chroma init: v_loop_filter_chroma_intra was previously assigned unconditionally to the NEON variant (which works for both 4:2:0 and 4:2:2). We now assign it INSIDE both branches of the chroma_format_idc conditional — 4:2:0 picks daedalus, 4:2:2 keeps NEON. No regression for 4:2:2 streams. Same NEON-to-NEON via recipe shape as 0010 luma intra. Closes the deblock substitution layer for the 4:2:0 / 8-bit hot path: - 0005 luma_v non-intra ✓ - 0008 luma_h non-intra ✓ - 0009 chroma_v / chroma_h non-intra ✓ - 0010 luma_v / luma_h intra ✓ - 0013 chroma_v / chroma_h intra ✓ All 8 deblock variants for the common 4:2:0 path now route through daedalus. 4:2:2 chroma + the chroma422 mbaff variants stay on in-tree NEON. Verified the patch applies cleanly on top of 0001-0012 against the pinned upstream commit b57fbbe5 on hertz.	2026-05-25 14:22:02 +02:00
marfrit	f07824adb7	Merge pull request 'ffmpeg-v4l2-request-fourier: route remaining H.264 qpel 8x8 positions through daedalus-fourier (0012)' (#101 ) from claude-noether/marfrit-packages:noether/h264-substitute-qpel-rest into main Reviewed-on: marfrit/marfrit-packages#101	2026-05-25 12:19:55 +00:00
claude-noether	2732a022f8	ffmpeg-v4l2-request-fourier: route remaining H.264 qpel 8x8 positions through daedalus-fourier (0012) Closes the H.264 qpel substitution. Extends 0007 (which routed only mc20 put_) to ALL 15 useful positions in BOTH the put_ and avg_ tables, skipping mc00 (integer copy / pointer-only fast path). 29 substitutions total: 14 new put_ + 15 avg_. Each wraps a single daedalus_recipe_dispatch_h264_qpel_{avg_,}mcXY call (the dispatches landed in daedalus-fourier PRs #15-#20). Collapsed via a single DEFINE_QPEL_WRAPPER macro on the libavcodec shim side so the diff is uniform. All recipe-table entries route AUTO to CPU NEON — no QPU shaders for any qpel position other than mc20 yet. Plumbing-only NEON-to-NEON via the daedalus recipe layer; bit-exact against the in-tree ff__h264_qpel8__neon path (each daedalus dispatch is already bit-exact-gated by the corresponding fourier PR's test). 16x16 qpel tables ([0][...]) stay on the in-tree NEON. daedalus only exposes 8x8 today; 16x16 substitution can land once fourier provides those variants. Verified the patch applies cleanly on top of 0001-0011 against the pinned upstream commit b57fbbe5 on hertz.	2026-05-25 14:05:56 +02:00
marfrit	57f73f1afb	Merge pull request 'ffmpeg-v4l2-request-fourier: route H.264 chroma DC Hadamard through daedalus-fourier (0011)' (#100 ) from claude-noether/marfrit-packages:noether/h264-substitute-chroma-dc into main Reviewed-on: marfrit/marfrit-packages#100	2026-05-25 12:03:08 +00:00
claude-noether	d8aa3aae8d	ffmpeg-v4l2-request-fourier: route H.264 chroma DC Hadamard through daedalus-fourier (0011) Substitutes H264DSPContext.chroma_dc_dequant_idct in the 4:2:0 / bit_depth=8 init path with a wrapper that composes the daedalus chroma DC Hadamard primitive (daedalus-fourier PR #25) with the qmul scaling FFmpeg's reference does in one fused function (h264idct_template.c::ff_h264_chroma_dc_dequant_idct). Algorithm per H.264 §8.5.11.1 / §8.5.11.2: 1. Extract 4 DCs from the scattered positions in the per-MB coefficient buffer (stride=32, xStride=16) 2. 2x2 Hadamard transform (daedalus primitive) 3. qmul scale + >> 7, write back to original positions Bit-exact against ff_h264_chroma_dc_dequant_idct_8_c. The Hadamard itself is gated by the fourier PR #23 7-case test suite (including the H·H = 4·I algebraic invariant), and the public-API parity test added in PR #25 confirms the src/ symbol matches the test ref. 4:2:2 chroma stays on the in-tree ff_h264_chroma422_dc_dequant_idct_c path — same chroma_format_idc<=1 gating shape as 0009 chroma deblock. Pin bump: _daedalus_fourier_commit / DAEDALUS_FOURIER_COMMIT bumped to b9f9ff2a (post-PR #25) so the build picks up the public daedalus_h264_chroma_dc_hadamard_2x2 symbol. Verified the patch applies cleanly on top of 0001-0010 against the pinned upstream commit b57fbbe5 on hertz.	2026-05-25 13:39:54 +02:00
marfrit	1f58ff2b6b	Merge pull request 'ffmpeg-v4l2-request-fourier: route H.264 luma intra deblock through daedalus-fourier (0010)' (#99 ) from claude-noether/marfrit-packages:noether/h264-substitute-deblock-intra into main Reviewed-on: marfrit/marfrit-packages#99	2026-05-25 11:28:33 +00:00
claude-noether	45be17fbdf	ffmpeg-v4l2-request-fourier: route H.264 luma intra deblock through daedalus-fourier (0010) Adds the bS=4 intra-strength variants of the already-substituted luma_v / luma_h deblock (0005, 0008). Intra MBs and certain inter-MB edges (4x4 transform boundaries inside an Intra_NxN neighbour) force boundary strength to 4 per H.264 §8.7.2.1. H264DSPContext.v_loop_filter_luma_intra → daedalus_recipe_dispatch_h264_deblock_luma_v_intra H264DSPContext.h_loop_filter_luma_intra → daedalus_recipe_dispatch_h264_deblock_luma_h_intra Both kernels landed in daedalus-fourier PR #11. Recipe → CPU NEON (no intra QPU shaders yet); plumbing-only NEON-to-NEON via daedalus. Signature differs from bS<4: no tc0 argument. Wrapper passes daedalus_h264_deblock_meta with alpha/beta set; tc0[] is ignored by the intra dispatch (bS=4 hardcodes the strength). Chroma intra variants are deferred to a follow-up because the chroma init has a 4:2:0 / 4:2:2 split (chroma_format_idc gating) — the daedalus dispatch is 4:2:0-only and needs explicit conditional substitution to avoid running on 4:2:2 chroma. Verified the patch applies cleanly on top of 0001-0009 against the pinned upstream commit b57fbbe5 on hertz.	2026-05-25 13:21:00 +02:00
marfrit	7b9bb9b2d0	Merge pull request 'ffmpeg-v4l2-request-fourier: route H.264 chroma v/h deblock through daedalus-fourier (0009)' (#98 ) from claude-noether/marfrit-packages:noether/h264-substitute-deblock-chroma into main Reviewed-on: marfrit/marfrit-packages#98	2026-05-25 11:18:15 +00:00
claude-noether	babb280410	ffmpeg-v4l2-request-fourier: route H.264 chroma v/h deblock through daedalus-fourier (0009) Chroma siblings of 0005 (luma_v) and 0008 (luma_h). Same NEON-to-NEON pattern via the daedalus recipe layer: H264DSPContext.v_loop_filter_chroma → daedalus_recipe_dispatch_h264_deblock_chroma_v H264DSPContext.h_loop_filter_chroma → daedalus_recipe_dispatch_h264_deblock_chroma_h Both kernels landed in daedalus-fourier PR #10. Recipe table routes AUTO to CPU NEON (no chroma QPU shaders yet), so this is plumbing- only and stays bit-exact against the in-tree NEON. Intra chroma (bS=4) loop filters remain on in-tree NEON; daedalus_h264_deblock_meta covers the non-intra (bS<4) path. Verified the patch applies cleanly on top of 0001-0008 against the pinned upstream commit b57fbbe5 on hertz. Wires the new patch into both arch/PKGBUILD and debian/build-deb.sh.	2026-05-25 13:16:45 +02:00
marfrit	5b48d1c743	Merge pull request 'ffmpeg-v4l2-request-fourier: route H.264 luma-h deblock through daedalus-fourier (0008)' (#97 ) from claude-noether/marfrit-packages:noether/h264-substitute-deblock-luma-h into main Reviewed-on: marfrit/marfrit-packages#97	2026-05-25 11:14:26 +00:00
claude-noether	624f83e877	ffmpeg-v4l2-request-fourier: route H.264 luma-h deblock through daedalus-fourier (0008) Adds patch 0008 to the substitution arc, mirroring 0005's V variant for H.264 non-intra bS<4 horizontal luma deblock. H264DSPContext.h_loop_filter_luma → daedalus_recipe_dispatch_h264_deblock_luma_h The H kernel was added to daedalus-fourier in PR #9 (vendored ff_h264_h_loop_filter_luma_neon, wired through the same CPU-dispatch pattern as V). Recipe table routes AUTO to CPU NEON (no QPU shader for H yet), so this is a NEON-to-NEON substitution via the daedalus recipe layer — same shape as 0005. The libavcodec.so ctx remains no-QPU (daedalus_ctx_create_no_qpu), matching the existing 0003/0004/0005/0007 patches. Higher-cycle QPU init waits for a feature-flag gating change in a separate PR. Intra (bS=4) h_loop_filter_luma_intra stays on the in-tree NEON .S code; daedalus_h264_deblock_meta covers the non-intra path only. A follow-up can route intra once daedalus-fourier exposes the intra-h dispatch (the kernel already exists internally per fourier PR #11). Wires the new patch into both arch/PKGBUILD and debian/build-deb.sh sequences. Verified the patch applies cleanly on top of 0001-0007 against the pinned upstream commit b57fbbe5 on hertz.	2026-05-25 13:10:05 +02:00