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.

.gitea/workflows/build.yml

@@ -1556,3 +1556,179 @@ jobs:
         if: always()
         run: rm -f /root/repo_pass /root/.ssh/id_ed25519
 
+  # -------------------------------------------------------------------------
+  # aish (arch=any) — pure LuaJIT, one .pkg.tar valid on every pacman target.
+  # Same dual-arch publish pattern as lmcp / claude-his.
+  # -------------------------------------------------------------------------
+  aish-any:
+    needs: lmcp-debian   # parallel with claude-his-any (pure-Lua sibling),
+                         # serialized via the shared arch-aarch64 runner.
+                         # Avoids needless wait through the fourier stack.
+    runs-on: arch-aarch64
+    steps:
+      - uses: actions/checkout@v4
+
+      - name: skip if already published
+        id: skip-check
+        run: |
+          set -e
+          result=$(./.gitea/scripts/check-already-published.sh arch/aish)
+          echo "$result" >> "$GITHUB_OUTPUT"
+          echo "decision: $result"
+
+      - name: bootstrap runner (idempotent)
+        if: steps.skip-check.outputs.skip != '1'
+        run: |
+          set -e
+          retry() { for i in 1 2 3; do "$@" && return 0; rc=$?; echo "retry $i (exit=$rc)" >&2; sleep $((i*5)); done; return 1; }
+          retry pacman -Syu --noconfirm --needed base-devel git rsync gnupg openssh sudo luajit readline curl
+
+      - name: import signing key
+        if: steps.skip-check.outputs.skip != '1'
+        env:
+          PRIV: ${{ secrets.MARFRIT_REPO_PRIVATE_KEY }}
+          PASS: ${{ secrets.MARFRIT_REPO_PASSPHRASE }}
+        run: |
+          set -e
+          gpgconf --homedir /root/.gnupg --kill all 2>/dev/null || true
+          rm -rf /root/.gnupg /root/repo_pass
+          mkdir -m700 -p /root/.gnupg
+          printf '%s' "$PASS" > /root/repo_pass
+          chmod 600 /root/repo_pass
+          printf '%s\n' "$PRIV" | gpg --batch --import
+          echo "92D5E96D8F63C75E4116AA1FF5C8C4603D0D250C:6:" | gpg --import-ownertrust
+
+      - name: install deploy ssh key
+        if: steps.skip-check.outputs.skip != '1'
+        env:
+          KEY: ${{ secrets.MARFRIT_REPO_DEPLOY_KEY }}
+        run: |
+          mkdir -m700 -p /root/.ssh
+          printf '%s\n' "$KEY" > /root/.ssh/id_ed25519
+          chmod 600 /root/.ssh/id_ed25519
+          ssh-keyscan -t ed25519 nc.reauktion.de > /root/.ssh/known_hosts 2>/dev/null
+
+      - name: makepkg aish
+        if: steps.skip-check.outputs.skip != '1'
+        run: |
+          set -e
+          rm -rf /tmp/build-aish
+          cp -r arch/aish /tmp/build-aish
+          chown -R builder:builder /tmp/build-aish
+          cd /tmp/build-aish
+          sudo -u builder -H makepkg --nocheck --noconfirm --syncdeps --cleanbuild
+          ls -la *.pkg.tar.* | grep -v "\.sig$"
+
+      - name: sign aish
+        if: steps.skip-check.outputs.skip != '1'
+        run: |
+          set -e
+          cd /tmp/build-aish
+          for f in *.pkg.tar.xz *.pkg.tar.zst *.pkg.tar.gz; do
+            [ -f "$f" ] || continue
+            gpg --batch --pinentry-mode loopback --passphrase-file /root/repo_pass \
+                --detach-sign --yes -u 92D5E96D8F63C75E4116AA1FF5C8C4603D0D250C "$f"
+          done
+
+      - name: publish aish to both arches
+        if: steps.skip-check.outputs.skip != '1'
+        run: |
+          set -e
+          retry() { for i in 1 2 3; do "$@" && return 0; rc=$?; echo "retry $i (exit=$rc)" >&2; sleep $((i*5)); done; return 1; }
+          export GNUPGHOME=/root/.gnupg
+          printf 'pinentry-mode loopback\npassphrase-file /root/repo_pass\n' > /root/.gnupg/gpg.conf
+          printf 'allow-loopback-pinentry\n' > /root/.gnupg/gpg-agent.conf
+          gpg-connect-agent reloadagent /bye
+
+          for target in aarch64 x86_64; do
+              stage="/tmp/arch-stage-$target"
+              rm -rf "$stage"; mkdir -p "$stage"; cd "$stage"
+              for f in marfrit.db.tar.gz marfrit.db.tar.gz.sig marfrit.files.tar.gz marfrit.files.tar.gz.sig; do
+                curl -sSLf "https://packages.reauktion.de/arch/$target/$f" -o "$f" || rm -f "$f"
+              done
+              cp /tmp/build-aish/*.pkg.tar.* .
+              pkgs=()
+              for ext in xz zst gz; do
+                for f in *.pkg.tar.$ext; do [ -f "$f" ] && pkgs+=("$f"); done
+              done
+              if [ -f marfrit.db.tar.gz ]; then
+                for f in "${pkgs[@]}"; do
+                  name=$(echo "$f" | sed -E 's/-[0-9].*//')
+                  repo-remove --sign --key 92D5E96D8F63C75E4116AA1FF5C8C4603D0D250C \
+                    marfrit.db.tar.gz "$name" 2>/dev/null || true
+                done
+              fi
+              repo-add --new --sign --key 92D5E96D8F63C75E4116AA1FF5C8C4603D0D250C \
+                --verify marfrit.db.tar.gz "${pkgs[@]}"
+              ln -sf marfrit.db.tar.gz        marfrit.db
+              ln -sf marfrit.files.tar.gz     marfrit.files
+              ln -sf marfrit.db.tar.gz.sig    marfrit.db.sig
+              ln -sf marfrit.files.tar.gz.sig marfrit.files.sig
+              retry rsync -avL --copy-unsafe-links \
+                -e 'ssh -i /root/.ssh/id_ed25519' \
+                ./ "mfritsche@nc.reauktion.de:arch/$target/"
+          done
+
+      - name: wipe secrets
+        if: always()
+        run: rm -f /root/repo_pass /root/.ssh/id_ed25519
+
+  aish-debian:
+    needs: aish-any   # serialize after the Arch build to share the runner
+    runs-on: arch-aarch64
+    steps:
+      - uses: actions/checkout@v4
+
+      - name: skip if already published
+        id: skip-check
+        run: |
+          set -e
+          result=$(./.gitea/scripts/check-already-published.sh debian/aish)
+          echo "$result" >> "$GITHUB_OUTPUT"
+          echo "decision: $result"
+
+      - name: install dpkg
+        if: steps.skip-check.outputs.skip != '1'
+        run: |
+          set -e
+          retry() { for i in 1 2 3; do "$@" && return 0; rc=$?; echo "retry $i (exit=$rc)" >&2; sleep $((i*5)); done; return 1; }
+          retry pacman -Syu --noconfirm --needed dpkg openssh rsync curl
+
+      - name: install hertz deploy ssh key
+        if: steps.skip-check.outputs.skip != '1'
+        env:
+          KEY: ${{ secrets.MARFRIT_REPO_HERTZ_KEY }}
+        run: |
+          mkdir -m700 -p /root/.ssh
+          printf '%s\n' "$KEY" > /root/.ssh/id_ed25519_hertz
+          chmod 600 /root/.ssh/id_ed25519_hertz
+          ssh-keyscan -t ed25519 hertz.fritz.box >> /root/.ssh/known_hosts 2>/dev/null
+
+      - name: build aish .deb
+        if: steps.skip-check.outputs.skip != '1'
+        run: |
+          set -e
+          cd debian/aish
+          ./build-deb.sh
+          ls -la *.deb
+
+      - name: upload + publish to suites
+        if: steps.skip-check.outputs.skip != '1'
+        run: |
+          set -e
+          retry() { for i in 1 2 3; do "$@" && return 0; rc=$?; echo "retry $i (exit=$rc)" >&2; sleep $((i*5)); done; return 1; }
+          cd debian/aish
+          DEB=$(ls aish_*.deb | head -1)
+          # Push the .deb into hertz's incoming dir via rrsync.
+          retry rsync -av -e 'ssh -i /root/.ssh/id_ed25519_hertz' "$DEB" \
+              marfritrepo@hertz.fritz.box:
+          # Trigger reprepro for each suite.
+          for suite in bookworm trixie; do
+              retry ssh -i /root/.ssh/id_ed25519_hertz marfritrepo@hertz.fritz.box \
+                  "publish-deb $suite $DEB"
+          done
+
+      - name: wipe secrets
+        if: always()
+        run: rm -f /root/.ssh/id_ed25519_hertz
+

arch/aish/PKGBUILD

@@ -0,0 +1,53 @@
+# Maintainer: Markus Fritsche <mfritsche@reauktion.de>
+# aish — AI-augmented conversational shell in LuaJIT.
+# Source of truth: git.reauktion.de/marfrit/aish
+
+pkgname=aish
+pkgver=0.1.0
+pkgrel=1
+pkgdesc="AI-augmented conversational shell (LuaJIT, FFI-only)"
+arch=('any')
+url="https://git.reauktion.de/marfrit/aish"
+license=('MIT')
+depends=('luajit' 'readline' 'curl')
+# The _tag back-translation handles both clean releases (no '_') and
+# pre-release pkgvers (e.g. 0.1.0_rc1 → v0.1.0-rc1).
+_tag="v${pkgver//_/-}"
+source=("${pkgname}-${pkgver}.tar.gz::https://git.reauktion.de/marfrit/aish/archive/${_tag}.tar.gz")
+sha256sums=('9ebc3939e028832e39391ae33efacb5ec9bcd99d123cbc8ca1cd6ca9a640b5b5')
+
+package() {
+    cd "${pkgname}"
+    local libdir="${pkgdir}/usr/share/lua/5.1/aish"
+
+    # Top-level modules
+    install -Dm644 main.lua     "${libdir}/main.lua"
+    install -Dm644 broker.lua   "${libdir}/broker.lua"
+    install -Dm644 context.lua  "${libdir}/context.lua"
+    install -Dm644 executor.lua "${libdir}/executor.lua"
+    install -Dm644 history.lua  "${libdir}/history.lua"
+    install -Dm644 mcp.lua      "${libdir}/mcp.lua"
+    install -Dm644 renderer.lua "${libdir}/renderer.lua"
+    install -Dm644 repl.lua     "${libdir}/repl.lua"
+    install -Dm644 router.lua   "${libdir}/router.lua"
+    install -Dm644 safety.lua   "${libdir}/safety.lua"
+    install -Dm644 secrets.lua  "${libdir}/secrets.lua"
+
+    # FFI bindings
+    install -Dm644 ffi/curl.lua     "${libdir}/ffi/curl.lua"
+    install -Dm644 ffi/libc.lua     "${libdir}/ffi/libc.lua"
+    install -Dm644 ffi/pty.lua      "${libdir}/ffi/pty.lua"
+    install -Dm644 ffi/readline.lua "${libdir}/ffi/readline.lua"
+
+    # Vendored dependencies
+    install -Dm644 vendor/dkjson.lua "${libdir}/vendor/dkjson.lua"
+
+    # Launch wrapper
+    install -Dm755 bin/aish "${pkgdir}/usr/bin/aish"
+
+    # Documentation + example config
+    install -Dm644 README.md  "${pkgdir}/usr/share/doc/${pkgname}/README.md"
+    install -Dm644 LICENSE    "${pkgdir}/usr/share/doc/${pkgname}/LICENSE"
+    install -Dm644 examples/config.lua \
+        "${pkgdir}/usr/share/doc/${pkgname}/examples/config.lua"
+}

arch/ffmpeg-v4l2-request-fourier/0008-h264-deblock-luma-h-daedalus-fourier.patch

@@ -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
+

arch/ffmpeg-v4l2-request-fourier/0009-h264-deblock-chroma-daedalus-fourier.patch

@@ -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
+

arch/ffmpeg-v4l2-request-fourier/0010-h264-deblock-luma-intra-daedalus-fourier.patch

@@ -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
+

arch/ffmpeg-v4l2-request-fourier/0011-h264-chroma-dc-hadamard-daedalus-fourier.patch

@@ -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
+

arch/ffmpeg-v4l2-request-fourier/PKGBUILD

@@ -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,12 @@ 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')
+sha256sums=('SKIP' 'SKIP' 'SKIP' 'SKIP' 'SKIP' 'SKIP' 'SKIP' 'SKIP' 'SKIP' 'SKIP' 'SKIP' 'SKIP' 'SKIP')
 
 pkgver() {
   cd "${_srcname}"
@@ -113,6 +117,10 @@ 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"
 }
 
 build() {

arch/mesa-panvk-bifrost/0007-panvk-bifrost-xfb-component-base-fix.patch

@@ -0,0 +1,103 @@
+From: marfrit-packages noether <claude-noether@reauktion.de>
+Subject: [PATCH] panvk-bifrost: fix XFB store channel-extract for packed varyings
+
+iter19 — fixes a reliable SIGSEGV during vkCreateGraphicsPipeline on any
+shader that uses XFB-bound varyings declared with non-zero `layout
+(component=N)` qualifiers. Surfaced by
+dEQP-VK.transform_feedback.simple.holes_vert; backtrace lands 11 frames
+into libvulkan_panfrost.so called from `vkt::TransformFeedback::
+TransformFeedbackHolesInstance::iterate`.
+
+Root cause: `lower_xfb_output_iter17` (and upstream `lower_xfb_output`,
+which carries a `// TODO` on the same assertion) computes the source-
+channel mask as `mask << channel_idx`, where `channel_idx` is the
+varying-location component (0..3) but `src` only contains channels for
+the source-side range starting at `nir_intrinsic_component(intr)`. For
+`flat out float vegeta` declared with `component=2`, NIR emits
+`store_output src=<vec1>, component=2`, and the lowering computes
+`mask << 2` against a single-component src — out-of-range; the
+resulting malformed nir_def then segfaults inside downstream NIR
+constant-folding (`nir_constant_expressions.c::evaluate_*`).
+
+The assertion `assert(nir_intrinsic_component(intr) == 0)` was inherited
+from upstream `pan_nir_lower_xfb.c` as a documented `// TODO`; release
+builds (-DNDEBUG) elide it. The fix translates `channel_idx` to the
+source-channel space by subtracting `nir_intrinsic_component(intr)`
+before shifting the mask, and replaces the elided asserts with explicit
+release-mode guards (the patch closes the same release-mode-elision
+class as the original bug).
+
+Verified on PineTab2 (Mali-G52 r1 MC1, PAN_ARCH 7) against vulkan-cts
+1.3.10.0:
+  - holes_vert / holes_extra_draw_vert no longer SIGSEGV (now Fail on
+    color-check; that is a separate iter20 finding — the rasterized
+    varying gets removed alongside the XFB-bound one).
+  - basic_*: 36/36 Pass. depth_clip_*: 1 Pass + 4 NotSupported.
+    lines_or_triangles*: 16 NotSupported. 0 Fail across the full set.
+  - holes_geom / holes_extra_draw_geom remain NotSupported
+    (geometryShader not on G52) — unchanged.
+
+Caveat: max_output_components_64/_128/_256 were never reached on the
+r5 sweep (watchdog killed transform_feedback after the holes_vert
+crash). With this fix in place, those tests now run and surface
+*their own pre-existing* coredumps — confirmed on shipped r6 baseline
+too. They are NOT regressions from this patch; they are latent crashes
+unmasked by it. iter20+ territory.
+
+Phase 5 (2nd-model) review: APPROVE WITH CHANGES (non-blocking).
+Changes applied: release-mode defensive guards on both preconditions
+plus a dispatcher-side comment clarifying the i*2+j semantics.
+
+Cross-refs:
+  - iter19/phase{0,1,2,3}_holes_vert*.md in panvk-bifrost repo
+
+---
+ src/panfrost/vulkan/panvk_vX_xfb_lower.c | 24 +++++++++++++++++++++---
+ 1 file changed, 21 insertions(+), 3 deletions(-)
+
+diff --git a/src/panfrost/vulkan/panvk_vX_xfb_lower.c b/src/panfrost/vulkan/panvk_vX_xfb_lower.c
+@@ -339,7 +339,20 @@
+                         unsigned buffer, unsigned offset_words)
+ {
+    assert(buffer < MAX_XFB_BUFFERS);
+-   assert(nir_intrinsic_component(intr) == 0);
++
++   /* iter19: nir_intrinsic_component(intr) is the source-channel base —
++    * for a packed varying like `layout (location=0, component=2) flat out
++    * float vegeta`, NIR emits store_output with component=2 and a single-
++    * component src. The XFB iteration index `channel_idx` (0..3) is the
++    * varying-location component, not the source channel. Translate by
++    * subtracting the base before shifting the mask. Fixes the long-
++    * standing `assert(nir_intrinsic_component(intr) == 0) // TODO` in
++    * upstream pan_nir_lower_xfb that surfaces on holes_vert. */
++   const unsigned base_comp = nir_intrinsic_component(intr);
++   /* Defensive against release-build elision: this is precisely the
++    * bug class the patch is fixing, so don't re-introduce it. */
++   if (channel_idx < base_comp)
++      return;
+ 
+    uint16_t stride = b->shader->info.xfb_stride[buffer] * 4;
+    assert(stride != 0);
+@@ -357,7 +370,11 @@
+ 
+    nir_def *src = intr->src[0].ssa;
+    nir_component_mask_t mask = nir_component_mask(num_components);
+-   nir_def *value = nir_channels(b, src, mask << channel_idx);
++   const unsigned src_channel = channel_idx - base_comp;
++   /* Same defensive class as the channel_idx >= base_comp guard above. */
++   if (src_channel + num_components > src->num_components)
++      return;
++   nir_def *value = nir_channels(b, src, mask << src_channel);
+ 
+    /* Topology dispatch ladder. LIST first (fast path). */
+    nir_push_if(b, nir_ieq_imm(b, topology, PANVK_XFB_TOPO_LIST));
+@@ -465,6 +482,9 @@
+       for (unsigned j = 0; j < 2; ++j) {
+          if (!xfb.out[j].num_components)
+             continue;
++         /* `i*2+j` is the varying-location component (0..3) — io_xfb covers
++          * slots 0..1, io_xfb2 covers 2..3. The leaf translates this into
++          * a source-channel index by subtracting nir_intrinsic_component(intr). */
+          lower_xfb_output_iter17(b, intr, i * 2 + j, xfb.out[j].num_components,
+                                  xfb.out[j].buffer, xfb.out[j].offset);
+          progress = true;

arch/mesa-panvk-bifrost/PKGBUILD

@@ -30,7 +30,7 @@
 
 pkgname=mesa-panvk-bifrost
 _mesaver=26.0.6
-pkgver=26.0.6.r6
+pkgver=26.0.6.r7
 pkgrel=1
 pkgdesc="Patched Mesa libvulkan_panfrost.so exposing Bifrost-gen Mali to Vulkan apps (panvk-bifrost campaign)"
 arch=('aarch64')
@@ -83,6 +83,7 @@ source=(
     "0004-panvk-bifrost-xfb-primitive-decomposition.patch"
     "0005-panvk-bifrost-fragment-stores-atomics.patch"
     "0006-panvk-bifrost-legacy-dithering.patch"
+    "0007-panvk-bifrost-xfb-component-base-fix.patch"
     "brave-vulkan"
     "icd.json"
 )
@@ -96,6 +97,7 @@ sha256sums=(
     'SKIP'
     'SKIP'
     'SKIP'
+    'SKIP'
 )
 
 prepare() {
@@ -152,6 +154,16 @@ prepare() {
     # extension as Mali-G52-architecture supported.
     patch -p1 < "${srcdir}/0006-panvk-bifrost-legacy-dithering.patch"
 
+    # r7 (2026-05-25): XFB store channel-extract fix for packed varyings.
+    # Eliminates a reliable SIGSEGV in vkCreateGraphicsPipeline whenever
+    # an XFB-bound vertex output is declared with non-zero
+    # `layout (component=N)`. Surfaced by dEQP-VK.transform_feedback.
+    # simple.holes_vert (now Fails on color-check rather than crashing;
+    # the color-check residual is a separate iter20 finding).
+    # Phase-doc context: ~/src/panvk-bifrost/iter19/phase{0,1,2,3}_*.md.
+    # Phase 5 reviewed; release-mode-elision defensive guards applied.
+    patch -p1 < "${srcdir}/0007-panvk-bifrost-xfb-component-base-fix.patch"
+
     # Sanity-check the patches landed.
     grep -q "KHR_robustness2 = true," src/panfrost/vulkan/panvk_vX_physical_device.c
     grep -q "EXT_robustness2 = true," src/panfrost/vulkan/panvk_vX_physical_device.c
@@ -171,6 +183,9 @@ prepare() {
     grep -q "xfb_topology" src/panfrost/vulkan/panvk_shader.h
     grep -q "panvk_xfb_topology" src/panfrost/vulkan/panvk_shader.h
     test -f src/panfrost/vulkan/panvk_vX_xfb_lower.c
+    # r7 sanity: XFB channel-base correction landed
+    grep -q "iter19: nir_intrinsic_component(intr) is the source-channel base" src/panfrost/vulkan/panvk_vX_xfb_lower.c
+    grep -q "mask << src_channel" src/panfrost/vulkan/panvk_vX_xfb_lower.c
 }
 
 build() {

debian/aish/build-deb.sh

@@ -0,0 +1,85 @@
+#!/bin/bash
+# Build aish_<ver>_all.deb from this directory using dpkg-deb directly.
+# Run from inside the runner container, which has dpkg installed.
+#
+# Matches the lmcp build-deb.sh pattern: no dh/debhelper, no Build-Depends
+# beyond `dpkg`, structurally a normal apt package (Architecture: all).
+set -euo pipefail
+
+PKGVER=0.1.0
+UPSTREAM_TAG=v0.1.0
+PKGREL=1
+AISH_TARBALL_SHA256=9ebc3939e028832e39391ae33efacb5ec9bcd99d123cbc8ca1cd6ca9a640b5b5
+HERE=$(dirname "$(readlink -f "$0")")
+
+# Reproducible build: pin all file mtimes + ar member timestamps to a fixed
+# epoch tied to this packaging release (aish v0.1.0 — 2026-05-25 00:00 UTC).
+# Without this, repeat builds produce different byte streams and reprepro
+# refuses re-includes with "size expected: X, got: Y".
+export SOURCE_DATE_EPOCH=1779667200
+
+work=$(mktemp -d)
+trap "rm -rf $work" EXIT
+
+cd "$work"
+curl --connect-timeout 10 --max-time 600 --retry 3 --retry-delay 5 -sSLfo aish.tar.gz \
+    "https://git.reauktion.de/marfrit/aish/archive/${UPSTREAM_TAG}.tar.gz"
+echo "$AISH_TARBALL_SHA256  aish.tar.gz" | sha256sum -c
+tar xzf aish.tar.gz
+
+ROOT="$work/pkgroot"
+LIBDIR="$ROOT/usr/share/lua/5.1/aish"
+mkdir -p "$ROOT/DEBIAN" \
+         "$LIBDIR/ffi" \
+         "$LIBDIR/vendor" \
+         "$ROOT/usr/bin" \
+         "$ROOT/usr/share/doc/aish/examples"
+
+# Top-level modules
+for m in main broker context executor history mcp renderer repl router safety secrets; do
+    cp "aish/${m}.lua" "$LIBDIR/${m}.lua"
+done
+
+# FFI bindings
+for m in curl libc pty readline; do
+    cp "aish/ffi/${m}.lua" "$LIBDIR/ffi/${m}.lua"
+done
+
+# Vendored dependencies
+cp aish/vendor/dkjson.lua "$LIBDIR/vendor/dkjson.lua"
+
+# Launch wrapper
+install -m 755 aish/bin/aish "$ROOT/usr/bin/aish"
+
+# Documentation + example config
+cp aish/README.md          "$ROOT/usr/share/doc/aish/"
+cp aish/LICENSE            "$ROOT/usr/share/doc/aish/"
+cp aish/examples/config.lua "$ROOT/usr/share/doc/aish/examples/"
+cp "$HERE/debian/copyright" "$ROOT/usr/share/doc/aish/copyright"
+cp "$HERE/debian/changelog" "$ROOT/usr/share/doc/aish/changelog.Debian"
+gzip -9 -n "$ROOT/usr/share/doc/aish/changelog.Debian"
+
+cat > "$ROOT/DEBIAN/control" <<EOF
+Package: aish
+Version: ${PKGVER}-${PKGREL}
+Section: shells
+Priority: optional
+Architecture: all
+Depends: luajit, libreadline8t64 | libreadline8, libcurl4t64 | libcurl4
+Maintainer: Markus Fritsche <mfritsche@reauktion.de>
+Homepage: https://git.reauktion.de/marfrit/aish
+Description: AI-augmented conversational shell (LuaJIT, FFI-only)
+ aish is an interactive REPL that interleaves shell execution and
+ language-model conversation against llama.cpp HTTP brokers. Pure
+ LuaJIT 2.x with FFI bindings to libcurl, GNU readline, and libc.
+ .
+ Modules install under /usr/share/lua/5.1/aish/. The launcher is
+ /usr/bin/aish. Example configuration is at
+ /usr/share/doc/aish/examples/config.lua (copy to
+ ~/.config/aish/config.lua and adapt).
+EOF
+
+# Build the .deb. Output to current dir of the caller.
+DEB_OUT=aish_${PKGVER}-${PKGREL}_all.deb
+dpkg-deb --root-owner-group --build "$ROOT" "$HERE/$DEB_OUT"
+echo "built: $HERE/$DEB_OUT"

debian/aish/debian/changelog

@@ -0,0 +1,14 @@
+aish (0.1.0-1) bookworm trixie; urgency=medium
+
+  * Initial release packaged for marfrit overlay repo. Phases 0-10
+    complete (102 closed issues): local llama.cpp + cloud broker
+    routing via hossenfelder, MCP tool calls with confirm-gate and
+    per-tool auto_approve, Chuck Norris autonomous mode with
+    destructive-op heuristic, cross-session memory.jsonl, multi-model
+    routing + GBNF grammar passthrough, project file-tree context,
+    cost/usage observability, /tokenize endpoint integration, project
+    overlay (.aish.lua + sha256-pinned trust ledger), cloud preplanner
+    → local executor split.
+  * Source-of-truth: git.reauktion.de/marfrit/aish, tagged v0.1.0.
+
+ -- Markus Fritsche <mfritsche@reauktion.de>  Mon, 25 May 2026 00:00:00 +0000

debian/aish/debian/control

@@ -0,0 +1,20 @@
+Source: aish
+Section: shells
+Priority: optional
+Maintainer: Markus Fritsche <mfritsche@reauktion.de>
+Standards-Version: 4.6.2
+Homepage: https://git.reauktion.de/marfrit/aish
+
+Package: aish
+Architecture: all
+Depends: ${misc:Depends}, luajit, libreadline8t64 | libreadline8, libcurl4t64 | libcurl4
+Description: AI-augmented conversational shell (LuaJIT, FFI-only)
+ aish is an interactive REPL that interleaves shell execution and language-
+ model conversation against llama.cpp HTTP brokers. Implementation is pure
+ LuaJIT 2.x with FFI bindings to libcurl, GNU readline, and libc — no C
+ extensions, no build step.
+ .
+ Modules install under /usr/share/lua/5.1/aish/. The launcher is
+ /usr/bin/aish. Example configuration is at
+ /usr/share/doc/aish/examples/config.lua (copy to ~/.config/aish/config.lua
+ and adapt).

debian/aish/debian/copyright

@@ -0,0 +1,30 @@
+Format: https://www.debian.org/doc/packaging-manuals/copyright-format/1.0/
+Upstream-Name: aish
+Source: https://git.reauktion.de/marfrit/aish
+
+Files: *
+Copyright: 2026 Markus Fritsche <mfritsche@reauktion.de>
+License: MIT
+ Permission is hereby granted, free of charge, to any person obtaining a copy
+ of this software and associated documentation files (the "Software"), to deal
+ in the Software without restriction, including without limitation the rights
+ to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ copies of the Software, and to permit persons to whom the Software is
+ furnished to do so, subject to the following conditions:
+ .
+ The above copyright notice and this permission notice shall be included in
+ all copies or substantial portions of the Software.
+ .
+ THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND.
+
+Files: vendor/dkjson.lua
+Copyright: 2010-2014 David Heiko Kolf
+License: MIT
+ Permission is hereby granted, free of charge, to any person obtaining a copy
+ of this software and associated documentation files (the "Software"), to deal
+ in the Software without restriction, including the rights to use, copy,
+ modify, merge, publish, distribute, sublicense, and/or sell copies of the
+ Software, and to permit persons to whom the Software is furnished to do so,
+ subject to the following conditions: the above copyright notice and this
+ permission notice shall be included in all copies or substantial portions of
+ the Software. THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND.

debian/ffmpeg-v4l2-request-fourier/0008-h264-deblock-luma-h-daedalus-fourier.patch

@@ -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
+

debian/ffmpeg-v4l2-request-fourier/0009-h264-deblock-chroma-daedalus-fourier.patch

@@ -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
+

debian/ffmpeg-v4l2-request-fourier/0010-h264-deblock-luma-intra-daedalus-fourier.patch

@@ -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
+

debian/ffmpeg-v4l2-request-fourier/0011-h264-chroma-dc-hadamard-daedalus-fourier.patch

@@ -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
+

debian/ffmpeg-v4l2-request-fourier/build-deb.sh

@@ -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,10 @@ 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"
 
 # --- daedalus-fourier: fetch + build static .a with PIC, install to a
 # per-build prefix; libavcodec.so links it into the shared object so