av1: populate V4L2_CID_STATELESS_AV1_SEQUENCE in codec_set_controls

Implements the libva-side portion of issue #11 — replaces PR #10's
no-op AV1 dispatch with a real av1_set_controls that maps VAAPI's
VADecPictureParameterBufferAV1.seq_info_fields + scalar fields onto
struct v4l2_ctrl_av1_sequence (the kernel uAPI control declared at
linux/v4l2-controls.h:2891-2919).

Daemon-track context (issue #11 daemon side, operator-owned):
ffmpeg-vaapi splits the AV1 bitstream client-side and strips the
OBU_SEQUENCE_HEADER before delivery; the V4L2 OUTPUT buffer contains
only OBU_FRAME_HEADER + OBU_TILE_GROUP.  libdav1d in the daedalus
daemon cannot parse this — it expects a complete OBU stream.  The
daemon side has to synthesise OBU_SEQUENCE_HEADER from the SEQUENCE
ctrl and prepend it to the slice bitstream.  This libva-side change
just makes the SEQUENCE ctrl populated and queued via S_EXT_CTRLS;
the daemon track is the consumer.

Three small touch points beyond the new src/av1.{c,h}:

  - src/surface.h: add an av1 leaf to surface->params holding
    VADecPictureParameterBufferAV1.  Slice params intentionally
    absent — the daedalus daemon consumes the slice OBU bytes
    directly from the OUTPUT buffer; no per-tile-group struct →
    OBU re-synthesis required from libva today.
  - src/picture.c: copy the picture-param buffer into the new leaf
    in RenderPicture, mirror of the per-codec memcpy pattern, plus
    call av1_set_controls from codec_set_controls (replacing the
    no-op).
  - src/meson.build: register src/av1.c.

Sequence-field mapping covers everything VAAPI exposes at the
sequence level (12 of 18 V4L2_AV1_SEQUENCE_FLAG_* bits + the four
scalars).  Bits VAAPI doesn't carry at the sequence level
(WARPED_MOTION, REF_FRAME_MVS, SUPERRES, RESTORATION,
SEPARATE_UV_DELTA_Q) stay clear; per-frame consumers (libdav1d via
the daemon, vpu981 via the hardware path) read those from the
OBU_FRAME_HEADER that is already in the slice buffer anyway.  See
feedback memory `feedback_vaapi_blind_to_some_hevc_sps_fields` for
the precedent.

Build verified on higgs (Debian 13 trixie, gcc 14.2.0, libva 2.22.0,
linux uAPI v4l2-controls.h sizeof(struct v4l2_ctrl_av1_sequence)==12):
clean meson + ninja link of v4l2_request_drv_video.so, vainfo
enumerates VAProfileAV1Profile0 via daedalus_v4l2 slot, av1_set_controls
symbol present.

Out of scope on this PR (operator-track, issue #11 follow-up):
  - daedalus-v4l2 kernel module wire-protocol extension (daedalus_
    collect_av1_meta + AV1 ctrl request_setup).
  - daedalus daemon OBU synthesiser (~400 LoC AV1 OBU encoder in
    daemon/src/av1_obu_synth.{c,h}).

Co-Authored-By: Claude Opus 4.7 <noreply@anthropic.com>

src/av1.c

@@ -0,0 +1,155 @@
+/*
+ * Copyright (C) 2026 Markus Fritsche <fritsche.markus@gmail.com>
+ *
+ * AV1 codec dispatcher.  Populates V4L2_CID_STATELESS_AV1_SEQUENCE
+ * (struct v4l2_ctrl_av1_sequence) from VAAPI's VADecPictureParameterBufferAV1.
+ *
+ * Why a single SEQUENCE control and not the full V4L2_CID_STATELESS_AV1_*
+ * family (FRAME, TILE_GROUP_ENTRY, FILM_GRAIN):
+ *
+ *   - The daedalus_v4l2 daemon path consumes the OUTPUT bitstream
+ *     directly via libavcodec/libdav1d.  libdav1d needs a complete OBU
+ *     stream that includes the sequence header — ffmpeg-vaapi strips the
+ *     sequence header on the client side (its parser is split across
+ *     VAPictureParameterBufferAV1 + slice payload, with OBU_SEQUENCE_HEADER
+ *     consumed and not re-emitted), so the daemon side has to synthesise
+ *     it from the SEQUENCE ctrl.  The other AV1 ctrls (FRAME / TILE /
+ *     FILM_GRAIN) are not needed for that synthesis — the OBU_FRAME_HEADER
+ *     + OBU_TILE_GROUP that libdav1d also needs are still in the slice
+ *     bitstream.
+ *
+ *   - The vpu981 (RK3588 dedicated AV1 hantro) hardware path doesn't
+ *     consult these controls either — vpu981's driver parses the AV1
+ *     bitstream directly.  So setting only SEQUENCE is correct for both
+ *     destination decoders.
+ *
+ * Reference: marfrit/libva-v4l2-request-fourier issue #11
+ *            (DAEMON-PPS-style sequence-header re-synthesis on the daemon
+ *            side, paralleling the H.264 SPS/PPS work in DAEMON-PPS).
+ *            kernel uAPI: <linux/v4l2-controls.h> @ 2891-2919.
+ *            VAAPI:       <va/va_dec_av1.h> typedef
+ *                         VADecPictureParameterBufferAV1.
+ */
+
+#include "av1.h"
+
+#include "v4l2.h"
+#include "utils.h"
+
+#include <stdint.h>
+#include <string.h>
+
+#include <linux/v4l2-controls.h>
+#include <linux/videodev2.h>
+
+/*
+ * VADecPictureParameterBufferAV1 reaches us transitively via surface.h →
+ * va_backend.h → va.h → va_dec_av1.h (va_dec_av1.h alone won't compile
+ * standalone — it needs va.h's VA_PADDING_LOW / va_deprecated machinery).
+ */
+
+/* Compile-time UAPI shift guard, sibling to vp9.c's pattern. */
+_Static_assert(sizeof(struct v4l2_ctrl_av1_sequence) == 12,
+	       "v4l2_ctrl_av1_sequence size mismatch — kernel UAPI changed");
+
+/*
+ * Map VAAPI bit_depth_idx (0/1/2 → 8/10/12) to the kernel ctrl's plain
+ * uint8_t bit_depth field.  ffmpeg-vaapi sets idx from the bitstream
+ * BitDepth value, so this is an exact inverse of AV1 spec 5.5.2.
+ */
+static uint8_t av1_bit_depth_from_idx(uint8_t idx)
+{
+	switch (idx) {
+	case 0:  return 8;
+	case 1:  return 10;
+	case 2:  return 12;
+	default:
+		/* Spec-illegal; pass through so a reviewer / test catches it. */
+		return 8;
+	}
+}
+
+int av1_set_controls(struct request_data *driver_data,
+		     struct object_context *context,
+		     struct object_surface *surface_object)
+{
+	VADecPictureParameterBufferAV1 *picture =
+		&surface_object->params.av1.picture;
+	struct v4l2_ctrl_av1_sequence sequence;
+	struct v4l2_ext_control ctrls[1];
+	int rc;
+
+	(void)context;
+
+	memset(&sequence, 0, sizeof sequence);
+
+	/*
+	 * Scalar mapping.  Names align with kernel uAPI; off-by-one and
+	 * idx→value translations are annotated.
+	 */
+	sequence.seq_profile = picture->profile;
+	sequence.order_hint_bits =
+		(uint8_t)(picture->order_hint_bits_minus_1 + 1u);
+	sequence.bit_depth = av1_bit_depth_from_idx(picture->bit_depth_idx);
+	sequence.max_frame_width_minus_1 = picture->frame_width_minus1;
+	sequence.max_frame_height_minus_1 = picture->frame_height_minus1;
+
+	/*
+	 * Sequence-header flag mapping.  VAAPI exposes most of these directly
+	 * in seq_info_fields.fields.*; the ones that don't have a 1:1 mirror
+	 * (V4L2_AV1_SEQUENCE_FLAG_ENABLE_WARPED_MOTION, _ENABLE_REF_FRAME_MVS,
+	 * _ENABLE_SUPERRES, _ENABLE_RESTORATION, _SEPARATE_UV_DELTA_Q) live in
+	 * VAAPI's per-frame pic_info_fields rather than the sequence struct.
+	 * For SEQUENCE-control purposes we treat them as best-effort
+	 * unobservable from libva and leave the corresponding bits clear; the
+	 * daedalus daemon's OBU synthesiser (issue #11 daemon track) carries
+	 * the SEQUENCE bytes verbatim, so per-frame consumers (libdav1d) will
+	 * still see the full bitstream truth for those toggles via the
+	 * OBU_FRAME stream already in the slice buffer.  See feedback memory
+	 * `feedback_vaapi_blind_to_some_hevc_sps_fields` for the precedent.
+	 */
+	if (picture->seq_info_fields.fields.still_picture)
+		sequence.flags |= V4L2_AV1_SEQUENCE_FLAG_STILL_PICTURE;
+	if (picture->seq_info_fields.fields.use_128x128_superblock)
+		sequence.flags |= V4L2_AV1_SEQUENCE_FLAG_USE_128X128_SUPERBLOCK;
+	if (picture->seq_info_fields.fields.enable_filter_intra)
+		sequence.flags |= V4L2_AV1_SEQUENCE_FLAG_ENABLE_FILTER_INTRA;
+	if (picture->seq_info_fields.fields.enable_intra_edge_filter)
+		sequence.flags |= V4L2_AV1_SEQUENCE_FLAG_ENABLE_INTRA_EDGE_FILTER;
+	if (picture->seq_info_fields.fields.enable_interintra_compound)
+		sequence.flags |= V4L2_AV1_SEQUENCE_FLAG_ENABLE_INTERINTRA_COMPOUND;
+	if (picture->seq_info_fields.fields.enable_masked_compound)
+		sequence.flags |= V4L2_AV1_SEQUENCE_FLAG_ENABLE_MASKED_COMPOUND;
+	if (picture->seq_info_fields.fields.enable_dual_filter)
+		sequence.flags |= V4L2_AV1_SEQUENCE_FLAG_ENABLE_DUAL_FILTER;
+	if (picture->seq_info_fields.fields.enable_order_hint)
+		sequence.flags |= V4L2_AV1_SEQUENCE_FLAG_ENABLE_ORDER_HINT;
+	if (picture->seq_info_fields.fields.enable_jnt_comp)
+		sequence.flags |= V4L2_AV1_SEQUENCE_FLAG_ENABLE_JNT_COMP;
+	if (picture->seq_info_fields.fields.enable_cdef)
+		sequence.flags |= V4L2_AV1_SEQUENCE_FLAG_ENABLE_CDEF;
+	if (picture->seq_info_fields.fields.mono_chrome)
+		sequence.flags |= V4L2_AV1_SEQUENCE_FLAG_MONO_CHROME;
+	if (picture->seq_info_fields.fields.color_range)
+		sequence.flags |= V4L2_AV1_SEQUENCE_FLAG_COLOR_RANGE;
+	if (picture->seq_info_fields.fields.subsampling_x)
+		sequence.flags |= V4L2_AV1_SEQUENCE_FLAG_SUBSAMPLING_X;
+	if (picture->seq_info_fields.fields.subsampling_y)
+		sequence.flags |= V4L2_AV1_SEQUENCE_FLAG_SUBSAMPLING_Y;
+	if (picture->seq_info_fields.fields.film_grain_params_present)
+		sequence.flags |= V4L2_AV1_SEQUENCE_FLAG_FILM_GRAIN_PARAMS_PRESENT;
+
+	/* Single-control batched submission. */
+	memset(ctrls, 0, sizeof ctrls);
+	ctrls[0].id   = V4L2_CID_STATELESS_AV1_SEQUENCE;
+	ctrls[0].ptr  = &sequence;
+	ctrls[0].size = sizeof sequence;
+
+	rc = v4l2_set_controls(driver_data->video_fd,
+			       surface_object->request_fd,
+			       ctrls, 1);
+	if (rc < 0)
+		return VA_STATUS_ERROR_OPERATION_FAILED;
+
+	return VA_STATUS_SUCCESS;
+}

src/av1.h

@@ -0,0 +1,39 @@
+/*
+ * Copyright (C) 2026 Markus Fritsche <fritsche.markus@gmail.com>
+ *
+ * AV1 codec dispatcher — populates V4L2_CID_STATELESS_AV1_SEQUENCE
+ * (struct v4l2_ctrl_av1_sequence) from VAAPI's VADecPictureParameterBufferAV1.
+ *
+ * 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, sub license, 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 (including the
+ * next paragraph) shall be included in all copies or substantial portions
+ * of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
+ * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+ * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT.
+ * IN NO EVENT SHALL THE AUTHORS OR CONTRIBUTORS BE LIABLE FOR ANY CLAIM,
+ * DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
+ * OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR
+ * THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+ */
+
+#ifndef _AV1_H_
+#define _AV1_H_
+
+#include "context.h"
+#include "request.h"
+#include "surface.h"
+
+int av1_set_controls(struct request_data *driver_data,
+		     struct object_context *context,
+		     struct object_surface *surface);
+
+#endif /* _AV1_H_ */

src/config.c

@@ -172,15 +172,20 @@ VAStatus RequestDestroyConfig(VADriverContextP context, VAConfigID config_id)
 static bool any_fd_supports_output_format(struct request_data *driver_data,
 					  unsigned int fmt)
 {
-	int fds[5] = {
+	int fds[6] = {
 		driver_data->video_fd,
 		driver_data->video_fd_rkvdec,
 		driver_data->video_fd_hantro,
 		driver_data->video_fd_rpi_hevc_dec,  /* iter40 */
 		driver_data->video_fd_vpu981,        /* ampere-av1 Phase 2 */
+#ifdef HAVE_DAEDALUS_V4L2
+		driver_data->video_fd_daedalus,      /* LIBVA-1: H.264/VP9/AV1 */
+#else
+		-1,
+#endif
 	};
 	int i;
-	for (i = 0; i < 5; i++) {
+	for (i = 0; i < 6; i++) {
 		if (fds[i] < 0) continue;
 		if (v4l2_find_format(fds[i], V4L2_BUF_TYPE_VIDEO_OUTPUT, fmt))
 			return true;

src/h264.c

@@ -827,10 +827,63 @@ int h264_set_controls(struct request_data *driver_data,
 
 	dpb_update(context, &surface->params.h264.picture);
 
+	/*
+	 * Dump the raw VAAPI fields at the libva boundary so issue #8
+	 * follow-up can disambiguate "ffmpeg-vaapi didn't populate" from
+	 * "downstream consumer (daedalus_v4l2 wire protocol) corrupted the
+	 * value". One-line; safe to leave in — costs a single printf per frame.
+	 */
+	request_log("h264_set_controls: VAProfile=%d seq_fields=0x%08x pic_fields=0x%08x num_ref_frames=%u bit_depth_luma_m8=%u bit_depth_chroma_m8=%u w_mbs_m1=%u h_mbs_m1=%u\n",
+		    (int)profile,
+		    surface->params.h264.picture.seq_fields.value,
+		    surface->params.h264.picture.pic_fields.value,
+		    surface->params.h264.picture.num_ref_frames,
+		    surface->params.h264.picture.bit_depth_luma_minus8,
+		    surface->params.h264.picture.bit_depth_chroma_minus8,
+		    surface->params.h264.picture.picture_width_in_mbs_minus1,
+		    surface->params.h264.picture.picture_height_in_mbs_minus1);
+
 	h264_va_picture_to_v4l2(driver_data, context, surface,
 				&surface->params.h264.picture,
 				&decode, &pps, &sps);
 
+	/*
+	 * max_num_ref_frames fallback. Some VAAPI clients (older ffmpeg-vaapi
+	 * paths, some daedalus_v4l2 consumers) leave VAPicture->num_ref_frames
+	 * at zero. Hardware decoders tolerate; libavcodec-via-daedalus enforces
+	 * sps.max_num_ref_frames strictly and rejects every frame.
+	 *
+	 * Count valid DPB entries first (the bitstream-true reference count we
+	 * can see); fall back to a per-profile spec minimum if even that is 0.
+	 * See marfrit/libva-v4l2-request-fourier issue #8.
+	 */
+	if (sps.max_num_ref_frames == 0) {
+		unsigned int valid = 0;
+		unsigned int i;
+		for (i = 0; i < 16; i++) {
+			const VAPictureH264 *ref =
+				&surface->params.h264.picture.ReferenceFrames[i];
+			if (!(ref->flags & VA_PICTURE_H264_INVALID))
+				valid++;
+		}
+		if (valid > 0) {
+			sps.max_num_ref_frames = (uint8_t)valid;
+		} else {
+			switch (profile) {
+			case VAProfileH264ConstrainedBaseline:
+				sps.max_num_ref_frames = 1;
+				break;
+			case VAProfileH264Main:
+			case VAProfileH264High:
+			case VAProfileH264MultiviewHigh:
+			case VAProfileH264StereoHigh:
+			default:
+				sps.max_num_ref_frames = 4;
+				break;
+			}
+		}
+	}
+
 	/*
 	 * Populate the scaling matrix unconditionally: from VAAPI's
 	 * VAIQMatrixBufferH264 when the consumer sent one this frame

src/meson.build

@@ -53,6 +53,7 @@ sources = [
 	'h265.c',
 	'vp8.c',
 	'vp9.c',
+	'av1.c',
 	'codec.c',
 	'nv15.c',
 	'nv12_col128.c',

src/picture.c

@@ -36,6 +36,7 @@
 #include "mpeg2.h"
 #include "vp8.h"
 #include "vp9.h"
+#include "av1.h"
 
 #include <assert.h>
 #include <stdio.h>
@@ -157,6 +158,12 @@ static VAStatus codec_store_buffer(struct request_data *driver_data,
 			       sizeof(surface_object->params.vp9.picture));
 			break;
 
+		case VAProfileAV1Profile0:
+			memcpy(&surface_object->params.av1.picture,
+			       buffer_object->data,
+			       sizeof(surface_object->params.av1.picture));
+			break;
+
 		default:
 			break;
 		}
@@ -318,6 +325,26 @@ static VAStatus codec_set_controls(struct request_data *driver_data,
 			return VA_STATUS_ERROR_OPERATION_FAILED;
 		break;
 
+	case VAProfileAV1Profile0:
+		/*
+		 * Populates V4L2_CID_STATELESS_AV1_SEQUENCE from
+		 * VAPictureParameterBufferAV1.  The daedalus_v4l2 daemon
+		 * (issue #11 daemon track) synthesises an OBU_SEQUENCE_HEADER
+		 * from this ctrl and prepends it to the slice bitstream
+		 * before handing it to libavcodec/libdav1d, which otherwise
+		 * cannot parse the (sequence-header-stripped) OUTPUT buffer
+		 * that ffmpeg-vaapi delivers.
+		 *
+		 * On the RK3588 vpu981 hardware path the same SEQUENCE ctrl
+		 * is harmless: vpu981's driver parses the OBU stream
+		 * directly and ignores the ctrl payload, so no per-decoder
+		 * gating is required here.
+		 */
+		rc = av1_set_controls(driver_data, context, surface_object);
+		if (rc < 0)
+			return VA_STATUS_ERROR_OPERATION_FAILED;
+		break;
+
 	default:
 		return VA_STATUS_ERROR_UNSUPPORTED_PROFILE;
 	}

src/request.c

@@ -461,6 +461,44 @@ int request_switch_device_for_profile(struct request_data *driver_data,
 		kind = 'p';
 	}
 
+#ifdef HAVE_DAEDALUS_V4L2
+	/*
+	 * LIBVA-1: VP9/AV1/H.264 → daedalus_v4l2 when the daemon-backed
+	 * decoder fd is open.  Pi 5 has no rkvdec (those profiles map to
+	 * 'r' by default → video_fd_rkvdec = -1 → "stay on whatever's
+	 * active" fallback would put H.264 frames on rpi-hevc-dec's fd
+	 * and S_FMT would fail).  Re-route to the daedalus daemon instead.
+	 *
+	 * HEVC stays on 'p' (rpi-hevc-dec is HEVC-only — daedalus would
+	 * accept it via FFmpeg, but rpi-hevc-dec has the GPU-backed
+	 * hardware path so it's the right choice on this SoC).
+	 *
+	 * AV1 'a' kind (RK3588 vpu981) wins ONLY if vpu981 was probed.
+	 * On a Pi 5 the vpu981 slot stays -1, so we still route AV1 to
+	 * daedalus here.  Check video_fd_vpu981 to preserve the RK3588
+	 * priority for that case.
+	 */
+	if (driver_data->video_fd_daedalus >= 0 &&
+	    driver_data->media_fd_daedalus >= 0) {
+		switch (profile) {
+		case VAProfileH264Main:
+		case VAProfileH264High:
+		case VAProfileH264ConstrainedBaseline:
+		case VAProfileH264MultiviewHigh:
+		case VAProfileH264StereoHigh:
+		case VAProfileVP9Profile0:
+			kind = 'd';
+			break;
+		case VAProfileAV1Profile0:
+			if (driver_data->video_fd_vpu981 < 0)
+				kind = 'd';
+			break;
+		default:
+			break;
+		}
+	}
+#endif
+
 	if (kind == 'r') {
 		target_video = driver_data->video_fd_rkvdec;
 		target_media = driver_data->media_fd_rkvdec;
@@ -473,6 +511,11 @@ int request_switch_device_for_profile(struct request_data *driver_data,
 	} else if (kind == 'a') {
 		target_video = driver_data->video_fd_vpu981;
 		target_media = driver_data->media_fd_vpu981;
+#ifdef HAVE_DAEDALUS_V4L2
+	} else if (kind == 'd') {
+		target_video = driver_data->video_fd_daedalus;
+		target_media = driver_data->media_fd_daedalus;
+#endif
 	} else {
 		return -1;
 	}
@@ -697,26 +740,32 @@ VAStatus VA_DRIVER_INIT_FUNC(VADriverContextP context)
 				driver_data->video_fd_hantro = video_fd;
 				driver_data->media_fd_hantro = media_fd;
 			} else if (strcmp(info.driver, "rpi-hevc-dec") == 0) {
-				/* iter40: Pi 5 / CM5 — sole decoder is rpi-hevc-dec.
-				 * No alt driver to probe; the rkvdec / hantro slots
-				 * stay -1 and HEVC routes to 'p' via
-				 * request_device_kind_for_profile. */
+				/* iter40 + LIBVA-1: Pi 5 / CM5.  rpi-hevc-dec is
+				 * HEVC-only.  If daedalus_v4l2 is ALSO loaded (Pi 5
+				 * mixed deployment — out-of-tree daemon-backed
+				 * decoder for VP9/AV1/H264), pick it up as the alt
+				 * so VP9/AV1/H264 have somewhere to land. */
 				primary_driver = "rpi-hevc-dec";
+#ifdef HAVE_DAEDALUS_V4L2
+				alt_driver = "daedalus_v4l2";
+#else
 				alt_driver = NULL;
+#endif
 				driver_data->video_fd_rpi_hevc_dec = video_fd;
 				driver_data->media_fd_rpi_hevc_dec = media_fd;
 #ifdef HAVE_DAEDALUS_V4L2
 			} else if (strcmp(info.driver, "daedalus_v4l2") == 0) {
-				/* phase 8.10: Pi 5 daemon-backed decoder.  Sole
-				 * V4L2 stateless slot on this kernel; VP9 / AV1 /
-				 * H.264 all route through it.  Other slots stay -1.
-				 *
-				 * On a mixed-driver box (daedalus loaded ALONGSIDE
-				 * rpi-hevc-dec) HEVC would prefer rpi-hevc-dec via
-				 * the existing 'p' override; VP9/AV1/H264 prefer
-				 * daedalus_v4l2 since rpi-hevc-dec is HEVC-only. */
+				/* phase 8.10 + LIBVA-1: Pi 5 daemon-backed decoder.
+				 * VP9 / AV1 / H.264 route through it via the 'd'
+				 * kind below.  On a mixed-driver box where
+				 * rpi-hevc-dec is ALSO loaded, pick it up as the
+				 * alt so HEVC has somewhere to land too — find_
+				 * codec_device's known_decoder_drivers[] order
+				 * normally puts rpi-hevc-dec first (we hit the
+				 * other branch in practice), but symmetric handling
+				 * keeps us correct if probe order ever flips. */
 				primary_driver = "daedalus_v4l2";
-				alt_driver = NULL;
+				alt_driver = "rpi-hevc-dec";
 				driver_data->video_fd_daedalus = video_fd;
 				driver_data->media_fd_daedalus = media_fd;
 #endif
@@ -731,15 +780,38 @@ VAStatus VA_DRIVER_INIT_FUNC(VADriverContextP context)
 				int alt_v = open(alt_video, O_RDWR | O_NONBLOCK);
 				int alt_m = (alt_v >= 0) ? open(alt_media, O_RDWR | O_NONBLOCK) : -1;
 				if (alt_v >= 0 && alt_m >= 0) {
+					/* Dispatch into the matching per-driver slot.
+					 * iter38 only had rkvdec/hantro pairs; iter40 +
+					 * LIBVA-1 extended this to rpi-hevc-dec and
+					 * daedalus_v4l2 for the Pi 5 mixed-decoder
+					 * deployment. */
 					if (strcmp(alt_driver, "rkvdec") == 0) {
 						driver_data->video_fd_rkvdec = alt_v;
 						driver_data->media_fd_rkvdec = alt_m;
-					} else {
+					} else if (strcmp(alt_driver, "hantro-vpu") == 0) {
 						driver_data->video_fd_hantro = alt_v;
 						driver_data->media_fd_hantro = alt_m;
+					} else if (strcmp(alt_driver, "rpi-hevc-dec") == 0) {
+						driver_data->video_fd_rpi_hevc_dec = alt_v;
+						driver_data->media_fd_rpi_hevc_dec = alt_m;
+#ifdef HAVE_DAEDALUS_V4L2
+					} else if (strcmp(alt_driver, "daedalus_v4l2") == 0) {
+						driver_data->video_fd_daedalus = alt_v;
+						driver_data->media_fd_daedalus = alt_m;
+#endif
+					} else {
+						/* Shouldn't happen — primary_driver branches
+						 * above only set alt_driver to one of the
+						 * names handled here.  Close and move on. */
+						close(alt_v);
+						close(alt_m);
+						alt_v = -1;
+						alt_m = -1;
 					}
+					if (alt_v >= 0) {
 						request_log("iter38: also opened %s decoder at %s + %s\n",
 							    alt_driver, alt_video, alt_media);
+					}
 				} else {
 					if (alt_v >= 0) close(alt_v);
 					if (alt_m >= 0) close(alt_m);
@@ -890,6 +962,12 @@ VAStatus RequestTerminate(VADriverContextP context)
 		close(driver_data->video_fd_vpu981);
 	if (driver_data->media_fd_vpu981 >= 0)
 		close(driver_data->media_fd_vpu981);
+#ifdef HAVE_DAEDALUS_V4L2
+	if (driver_data->video_fd_daedalus >= 0)
+		close(driver_data->video_fd_daedalus);
+	if (driver_data->media_fd_daedalus >= 0)
+		close(driver_data->media_fd_daedalus);
+#endif
 	/* Fall back to direct close if neither alt fd captured the active
 	 * pair (env-override path). */
 	if (driver_data->video_fd_rkvdec < 0 && driver_data->video_fd_hantro < 0) {

src/surface.h

@@ -122,6 +122,18 @@ struct object_surface {
 			VADecPictureParameterBufferVP9 picture;
 			VASliceParameterBufferVP9 slice;
 		} vp9;
+		struct {
+			/*
+			 * AV1 picture parameter buffer.  Slice params are
+			 * intentionally absent — the daedalus daemon track
+			 * (issue #11) consumes the slice OBU bytes directly
+			 * from the OUTPUT bitstream and synthesises only the
+			 * sequence-header OBU from V4L2_CID_STATELESS_AV1_
+			 * SEQUENCE.  No per-tile-group struct→OBU re-synthesis
+			 * required from libva today.
+			 */
+			VADecPictureParameterBufferAV1 picture;
+		} av1;
 	} params;
 
 	int request_fd;