Phase 8.4: daemon ↔ kernel decode round-trip (VP9 end-to-end)
Wires the Phase 8.3 FFmpeg loader through the Phase 8.2 chardev
bridge: kernel injects REQ_DECODE carrying a raw VP9 access unit,
daemon hands the bitstream to libavcodec via dlopen, sends
RESP_FRAME back with a content-dependent FNV-1a digest of the
decoded YUV planes. Pure CPU decode for now — Phase 8.5 swaps in
dmabuf + QPU dispatch.
Protocol (include/daedalus_v4l2_proto.h):
- New REQ_DECODE (kernel→daemon) and RESP_FRAME (daemon→kernel)
message types, with fixed-size payload structs.
- New DAEDALUS_CODEC_VP9/AV1/H264 enum (wire-stable so 8.6's
AV1+H.264 work doesn't move existing values).
- New DAEDALUS_DECODE_* status enum (OK / NO_FRAME / ERR_OPEN /
ERR_SEND / ERR_RECV / ERR_CODEC).
- Converted the prior `enum daedalus_msg_type` to #defines —
high-bit values exceed INT_MAX and tripped -Wpedantic on
userspace; kernel uABI headers use the same idiom.
Kernel (kernel/daedalus_v4l2_chardev.c):
- New debugfs entry /sys/kernel/debug/daedalus_v4l2/test_decode:
writing raw bitstream bytes wraps them in a REQ_DECODE
(codec=VP9 for Phase 8.4) and enqueues with an
auto-incrementing cookie.
- daedalus_chardev_write learned RESP_FRAME: parses the payload
and emits a single pr_info line with decode metadata. Keeps
existing PONG handling on the default arm.
Daemon (daemon/src/...):
- chardev_client.{c,h} — opens /dev/daedalus-v4l2, blocking read
loop, single-buffer write() responses (kernel chardev has only
.write, not .write_iter, so writev lands as -EINVAL —
discovered the hard way during first run).
- decoder.{c,h} — lazily-opened AVCodecContext per codec, shared
AVPacket/AVFrame pair, descriptor-driven plane walker
(av_pix_fmt_desc_get) so the same hash path covers YUV420P,
YUV422P, YUV444P, GBRP and other 8-bit planar layouts.
Generalised after first run decoded testsrc as GBRP (71)
rather than the assumed YUV420P.
- `daemon` command in main.c opens the chardev and runs the loop
until SIGINT/SIGTERM. Cookie correlation handled end-to-end.
- ffmpeg_loader gained av_pix_fmt_desc_get (23 symbols total).
Build:
- CMakeLists adds chardev_client.c + decoder.c; explicit
-I../include for the shared protocol header.
- Still -Wall -Wextra -Wpedantic clean.
Verification on hertz (Pi 5, 6.12.75+rpt-rpi-2712):
$ ffmpeg ... -pix_fmt yuv420p -c:v libvpx-vp9 -frames:v 1 \
-y /tmp/vp9_test.ivf
$ python3 ... strip IVF framing → vp9_keyframe.bin (3268 B)
$ sudo insmod kernel/daedalus_v4l2.ko
$ daedalus_v4l2_daemon -v daemon &
$ sudo dd if=vp9_keyframe.bin \
of=/sys/kernel/debug/daedalus_v4l2/test_decode
daemon: REQ_DECODE cookie=2 → decoded yuv420p 320x240
fnv1a=0x6ef10d71 luma=76800 chroma=38400
kernel: RESP_FRAME cookie=2 status=0 320x240 pixfmt=0
fnv1a=0x6ef10d71 ← matches daemon ✓
Hash properties verified:
cookie=2 testsrc 3268 B → 0x6ef10d71 (first decode)
cookie=3 red 44 B → 0x7f6e5dc5 (content-dependent ✓)
cookie=4 testsrc 3268 B → 0x6ef10d71 (deterministic ✓)
cookie=5 64 B random → status=101 (ERR_SEND, daemon alive)
Daemon survives bad input (FFmpeg "Invalid sync code" wrapped
into structured ERR_SEND response). Clean SIGTERM shutdown,
clean rmmod.
Phase 8.4 acceptance criteria met:
- ✓ end-to-end kernel→daemon→FFmpeg→kernel round-trip
- ✓ cookie correlation per request/response pair
- ✓ content-dependent + deterministic digest
- ✓ structured error responses (no daemon crash on bad input)
- ✓ clean teardown (SIGTERM + rmmod)
- ✓ builds clean on both kernel kbuild and daemon CMake
Per correctness-before-speed:
- Real chardev I/O (no shortcuts, no select-loop hacks)
- Real FFmpeg AVCodecContext lifecycle (lazily opened, properly
freed on cleanup)
- Descriptor-driven plane walk (generalises across pix_fmts)
- Structured error path (not just log-and-continue)
- All resource paths cleaned up on every error branch
- Documented why FNV-1a digest, why write() not writev(), why
pix_desc walk in docs/phase_8_4_closure.md
Phase 8.5 next: V4L2 m2m queue submits REQ_DECODE from
vidioc_qbuf; dmabuf carries actual pixel data so the chardev's
64 KiB cap doesn't gate frame size; begin substituting
daedalus_dispatch_* into the daemon's decode path.
Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com>
This commit is contained in:
+101
-17
@@ -18,9 +18,8 @@
|
||||
* Each message is a `struct daedalus_msg_hdr` followed by an
|
||||
* optional variable-length payload of `hdr.payload_len` bytes.
|
||||
*
|
||||
* Phase 8.2 (chardev bridge): only PING/PONG implemented.
|
||||
* Phase 8.4 (VP9 end-to-end): adds DECODE_FRAME request,
|
||||
* FRAME_READY response.
|
||||
* Phase 8.2 (chardev bridge): PING / PONG.
|
||||
* Phase 8.4 (decode end-to-end): REQ_DECODE / RESP_FRAME.
|
||||
*/
|
||||
#ifndef DAEDALUS_V4L2_PROTO_H
|
||||
#define DAEDALUS_V4L2_PROTO_H
|
||||
@@ -30,23 +29,25 @@
|
||||
#define DAEDALUS_PROTO_MAGIC 0x44303456u /* 'D04V' */
|
||||
#define DAEDALUS_PROTO_VERSION 0u /* pre-1.0 */
|
||||
|
||||
/**
|
||||
* enum daedalus_msg_type - wire-protocol message types
|
||||
* @DAEDALUS_MSG_PING: request: payload is opaque echo data
|
||||
* @DAEDALUS_MSG_PONG: response: payload echoes the matching ping
|
||||
* @DAEDALUS_MSG_HELLO: response: daemon announces itself on connect
|
||||
*
|
||||
* Phase 8.2 implements PING / PONG / HELLO. Later phases add
|
||||
* REQ_DECODE / RESP_FRAME / etc.
|
||||
/*
|
||||
* Wire-protocol message types.
|
||||
*
|
||||
* Request types (kernel → daemon) live in 0x0000_0000..0x7fff_ffff.
|
||||
* Response types (daemon → kernel) live in 0x8000_0000..0xffff_ffff.
|
||||
* The high bit is what distinguishes "kernel produced this" from
|
||||
* "daemon produced this" on the wire.
|
||||
*
|
||||
* These are #defines rather than an enum because the high-bit
|
||||
* values (>= 0x80000000) exceed INT_MAX, and pre-C23 enums can't
|
||||
* portably hold them — kernel uABI headers follow the same
|
||||
* convention.
|
||||
*/
|
||||
enum daedalus_msg_type {
|
||||
DAEDALUS_MSG_PING = 0x00000001u,
|
||||
DAEDALUS_MSG_HELLO = 0x80000001u,
|
||||
DAEDALUS_MSG_PONG = 0x80000002u,
|
||||
};
|
||||
#define DAEDALUS_MSG_PING 0x00000001u
|
||||
#define DAEDALUS_MSG_REQ_DECODE 0x00000002u
|
||||
|
||||
#define DAEDALUS_MSG_HELLO 0x80000001u
|
||||
#define DAEDALUS_MSG_PONG 0x80000002u
|
||||
#define DAEDALUS_MSG_RESP_FRAME 0x80000003u
|
||||
|
||||
/**
|
||||
* struct daedalus_msg_hdr - on-the-wire message header
|
||||
@@ -54,7 +55,7 @@ enum daedalus_msg_type {
|
||||
* @version: protocol version (DAEDALUS_PROTO_VERSION)
|
||||
* @type: one of enum daedalus_msg_type
|
||||
* @cookie: caller-supplied identifier; copied verbatim into
|
||||
* the matching response so the daemon can pair
|
||||
* the matching response so the kernel can pair
|
||||
* response with request
|
||||
* @payload_len: number of bytes immediately following this
|
||||
* struct (max DAEDALUS_PROTO_MAX_PAYLOAD)
|
||||
@@ -71,4 +72,87 @@ struct daedalus_msg_hdr {
|
||||
|
||||
#define DAEDALUS_PROTO_MAX_PAYLOAD (64u * 1024u) /* 64 KiB */
|
||||
|
||||
/* -- REQ_DECODE / RESP_FRAME payload structures ---------------------- */
|
||||
|
||||
/**
|
||||
* enum daedalus_codec_id - codec selector for REQ_DECODE
|
||||
* @DAEDALUS_CODEC_VP9: libavcodec AV_CODEC_ID_VP9
|
||||
* @DAEDALUS_CODEC_AV1: libavcodec AV_CODEC_ID_AV1 (Phase 8.6)
|
||||
* @DAEDALUS_CODEC_H264: libavcodec AV_CODEC_ID_H264 (Phase 8.6)
|
||||
*
|
||||
* Wire-stable across phases. The daemon maps these to the
|
||||
* libavcodec AV_CODEC_ID_* values internally so we don't leak
|
||||
* FFmpeg's enum into the kernel ABI.
|
||||
*/
|
||||
enum daedalus_codec_id {
|
||||
DAEDALUS_CODEC_VP9 = 1,
|
||||
DAEDALUS_CODEC_AV1 = 2,
|
||||
DAEDALUS_CODEC_H264 = 3,
|
||||
};
|
||||
|
||||
/**
|
||||
* struct daedalus_req_decode - REQ_DECODE payload prefix
|
||||
* @codec_id: enum daedalus_codec_id
|
||||
* @bitstream_len: bytes of bitstream following this struct
|
||||
* @flags: reserved, must be zero
|
||||
*
|
||||
* Total payload_len for a REQ_DECODE = sizeof(struct
|
||||
* daedalus_req_decode) + bitstream_len.
|
||||
*/
|
||||
struct daedalus_req_decode {
|
||||
__u32 codec_id;
|
||||
__u32 bitstream_len;
|
||||
__u32 flags;
|
||||
};
|
||||
|
||||
/**
|
||||
* enum daedalus_decode_status - RESP_FRAME outcome codes
|
||||
* @DAEDALUS_DECODE_OK: frame produced; fields below populated
|
||||
* @DAEDALUS_DECODE_NO_FRAME: codec consumed input but no frame
|
||||
* ready yet (e.g. lacks reference)
|
||||
* @DAEDALUS_DECODE_ERR_OPEN: avcodec_open2 failed
|
||||
* @DAEDALUS_DECODE_ERR_SEND: avcodec_send_packet failed
|
||||
* @DAEDALUS_DECODE_ERR_RECV: avcodec_receive_frame failed
|
||||
* @DAEDALUS_DECODE_ERR_CODEC: unknown codec_id
|
||||
*/
|
||||
enum daedalus_decode_status {
|
||||
DAEDALUS_DECODE_OK = 0,
|
||||
DAEDALUS_DECODE_NO_FRAME = 1,
|
||||
DAEDALUS_DECODE_ERR_OPEN = 100,
|
||||
DAEDALUS_DECODE_ERR_SEND = 101,
|
||||
DAEDALUS_DECODE_ERR_RECV = 102,
|
||||
DAEDALUS_DECODE_ERR_CODEC = 103,
|
||||
};
|
||||
|
||||
/**
|
||||
* struct daedalus_resp_frame - RESP_FRAME payload
|
||||
* @status: enum daedalus_decode_status
|
||||
* @codec_id: echoes the request's codec_id
|
||||
* @width: decoded frame width in pixels (0 if !OK)
|
||||
* @height: decoded frame height in pixels (0 if !OK)
|
||||
* @pix_fmt: libavcodec AVPixelFormat as int (informational)
|
||||
* @luma_len: Y-plane byte count actually hashed
|
||||
* @chroma_len: U+V byte count actually hashed (planar combined)
|
||||
* @fnv1a_yuv: FNV-1a 32-bit hash of Y,U,V planes concatenated
|
||||
* (line-by-line, stripping any libav alignment
|
||||
* stride padding). Lets the kernel side compare
|
||||
* against an offline reference without shipping
|
||||
* full pixel data through the chardev.
|
||||
* @reserved: must be zero
|
||||
*
|
||||
* Fixed size — keeps wire parsing simple. No variable-length
|
||||
* pixel data in Phase 8.4; dmabuf in Phase 8.5 carries that.
|
||||
*/
|
||||
struct daedalus_resp_frame {
|
||||
__u32 status;
|
||||
__u32 codec_id;
|
||||
__u32 width;
|
||||
__u32 height;
|
||||
__s32 pix_fmt;
|
||||
__u32 luma_len;
|
||||
__u32 chroma_len;
|
||||
__u32 fnv1a_yuv;
|
||||
__u32 reserved;
|
||||
};
|
||||
|
||||
#endif /* DAEDALUS_V4L2_PROTO_H */
|
||||
|
||||
Reference in New Issue
Block a user