reauktion/daedalus-v4l2
2
0
Fork 0
Code Issues 3 Pull Requests Actions Packages Projects Releases Wiki Activity

DAEMON-PPS: synthesise H.264 SPS/PPS NAL units from V4L2 controls

Browse Source 
libva-v4l2-request-fourier (and any V4L2-stateless-API consumer)
passes H.264 SPS/PPS as separate V4L2_CID_STATELESS_H264_{SPS,PPS}
controls; only the slice NAL goes into the OUTPUT buffer.  This is
correct per the V4L2 stateless contract.  But libavcodec — which
the daedalus daemon uses for actual decode (Option γ) — wants a
self-contained AnnexB stream including SPS+PPS before any slice.
Result on higgs: "non-existing PPS 0 referenced" + decode_slice_
header errors on every H.264 frame, even after LIBVA-1 and -2
routing correctly delivered the request to the daemon.

Fix splits across kernel + daemon, keeping the kernel module as a
thin transport and putting the actual NAL encoding in userspace:

  include/daedalus_v4l2_proto.h:
    Add struct daedalus_h264_meta (the four v4l2_ctrl_h264_*
    structs the kernel collects) and DAEDALUS_REQ_FLAG_H264_META
    (set in req.flags when the meta block is present between the
    daedalus_req_decode prefix and the slice bitstream).

  kernel/daedalus_v4l2_main.c:
    Add daedalus_collect_h264_meta() — reads the H.264 ctrl values
    from the bound media_request via v4l2_ctrl_find +
    ctrl->p_cur.p_h264_*.  device_run() calls it on H.264 codec_id,
    copies the structs into the REQ_DECODE payload between the
    prefix and bitstream, and sets the flag.  Payload size is
    bounds-checked against DAEDALUS_PROTO_MAX_PAYLOAD so an over-
    sized slice + meta fails loud instead of truncating.

  daemon/src/bitstream_writer.{c,h}:
    New module — MSB-first bit packer with H.264 Exp-Golomb ue(v)
    and se(v) coding + rbsp_trailing_bits alignment.  Sticky
    overflow flag so callers can verify the output buffer wasn't
    truncated.

  daemon/src/h264_nal_synth.{c,h}:
    New module — turns v4l2_ctrl_h264_sps / v4l2_ctrl_h264_pps
    into AnnexB-framed NAL units per ITU-T H.264 7.3.2.1 / 7.3.2.2.
    Emits emulation prevention bytes (0x03 after every 00 00 in the
    EBSP) and the 4-byte start code (0x00000001).  Coverage matches
    what V4L2 stateless surface gives us: VUI parameters and full
    scaling matrices are NOT emitted (V4L2 doesn't carry them — the
    seq_scaling_matrix_present_flag is set to 0 and libavcodec uses
    flat defaults, which matches the de-facto behaviour of most
    H.264 streams libva-v4l2-request drives).

  daemon/src/decoder.c:
    daedalus_decoder_run_request() now takes an optional
    h264_meta parameter.  For codec_id == H264 with meta != NULL,
    synthesises SPS+PPS NAL units, allocates a combined
    [SPS][PPS][slice] buffer (+ AV_INPUT_BUFFER_PADDING_SIZE), and
    feeds that to avcodec_send_packet instead of the raw slice.
    VP9/AV1 path unchanged (frames are self-contained).  Cleanup
    now goes through a unified `out:` label so the assembled
    buffer is always freed on every exit (including the existing
    decoder_open_codec / no-frame / receive_frame failure paths).

  daemon/src/chardev_client.c:
    handle_req_decode() peels off the optional meta block when the
    flag is set, passes it through to the decoder, and updates
    the payload-length consistency check (now allows for an extra
    sizeof(daedalus_h264_meta) when the flag is on).

Build (boltzmann aarch64): clean compile of all daemon sources,
including bitstream_writer + h264_nal_synth + the refactored
decoder.c.  Kernel module compile to be verified via DKMS rebuild
on higgs in the marfrit-packages bump that follows.

Test plan: with this commit + a marfrit-packages daedalus pin
bump, higgs's ffmpeg -hwaccel vaapi -i h264_test.mp4 should
produce a successful decode (vs. the previous "non-existing PPS 0
referenced" failure).  The daemon log should show:
  decoder: opened h264 context
  decoder: h264 prepended SPS=NB PPS=MB slice=KB
  decoder: OK 320x240 fmt=0 (yuv420p) fnv1a=0x...

VP9 / AV1 behaviour unchanged — they don't carry meta and the
existing per-frame self-describing path still applies.

Co-Authored-By: Claude Opus 4.7 <noreply@anthropic.com>
This commit is contained in:
Markus Fritsche
2026-05-20 17:35:24 +02:00
parent 481279c9bf
commit 8c1d9960c4
10 changed files with 720 additions and 56 deletions
Download Patch File Download Diff File Expand all files Collapse all files
daemon/src/decoder.c
+63 -15
View File
@@ -4,6 +4,7 @@
*/
#include "decoder.h"
#include "ffmpeg_loader.h"
#include "h264_nal_synth.h"
#include "log.h"
#include <errno.h>
@@ -350,11 +351,14 @@ static int pack_nv12_to_planes(struct AVFrame *fr,
int daedalus_decoder_run_request(struct daedalus_decoder *dec,
const struct daedalus_req_decode *req,
const uint8_t *bitstream,
const struct daedalus_h264_meta *h264_meta,
struct daedalus_resp_frame *resp,
const struct daedalus_capture_planes *planes)
{
struct ffmpeg_loader *fm = dec->loader;
struct AVCodecContext *ctx = NULL;
uint8_t *assembled = NULL;
size_t assembled_len = 0;
int rc;
memset(resp, 0, sizeof(*resp));
@@ -363,32 +367,72 @@ int daedalus_decoder_run_request(struct daedalus_decoder *dec,
rc = decoder_open_codec(dec, req->codec_id, &ctx);
if (rc == -ENOSYS) {
resp->status = DAEDALUS_DECODE_ERR_CODEC;
return 0;
goto out;
}
if (rc < 0) {
resp->status = DAEDALUS_DECODE_ERR_OPEN;
return 0;
goto out;
}
fm->av_packet_unref(dec->pkt);
/*
* The kernel's REQ_DECODE payload is borrowed memory we'll
* free as soon as this function returns. Pointing the
* AVPacket at it directly is safe because avcodec_send_packet
* either fully consumes the input or copies it internally —
* by the time we return we no longer reference @bitstream.
*
* We cast away const because AVPacket->data is non-const in
* the FFmpeg API; we promise not to mutate the buffer.
* H.264 path: libavcodec needs SPS+PPS NAL units BEFORE the
* slice can be decoded. libva-v4l2-request passes those as
* separate V4L2 controls (per the stateless API), so the
* daedalus kernel module forwards them to us as struct
* daedalus_h264_meta. Synthesise AnnexB SPS+PPS NALs from
* the structs and prepend them to @bitstream before feeding
* libavcodec.
*/
dec->pkt->data = (uint8_t *) (uintptr_t) bitstream;
dec->pkt->size = (int) req->bitstream_len;
if (req->codec_id == DAEDALUS_CODEC_H264 && h264_meta) {
uint8_t sps_nal[256];
uint8_t pps_nal[128];
size_t sps_len, pps_len;
sps_len = h264_synth_sps(&h264_meta->sps,
sps_nal, sizeof(sps_nal));
pps_len = h264_synth_pps(&h264_meta->pps,
pps_nal, sizeof(pps_nal));
if (sps_len == 0 || pps_len == 0) {
log_err("decoder: SPS/PPS NAL synth failed (sps=%zu pps=%zu)",
sps_len, pps_len);
resp->status = DAEDALUS_DECODE_ERR_SEND;
goto out;
}
assembled_len = sps_len + pps_len + req->bitstream_len;
assembled = malloc(assembled_len + AV_INPUT_BUFFER_PADDING_SIZE);
if (!assembled) {
resp->status = DAEDALUS_DECODE_ERR_SEND;
goto out;
}
memcpy(assembled, sps_nal, sps_len);
memcpy(assembled + sps_len, pps_nal, pps_len);
memcpy(assembled + sps_len + pps_len,
bitstream, req->bitstream_len);
memset(assembled + assembled_len, 0,
AV_INPUT_BUFFER_PADDING_SIZE);
dec->pkt->data = assembled;
dec->pkt->size = (int) assembled_len;
log_debug("decoder: h264 prepended SPS=%zuB PPS=%zuB slice=%uB",
sps_len, pps_len, req->bitstream_len);
} else {
/*
* VP9/AV1: bitstream is self-contained per frame, point the
* AVPacket at it directly. Cast away const — AVPacket->data
* is non-const but avcodec_send_packet doesn't mutate it.
*/
dec->pkt->data = (uint8_t *) (uintptr_t) bitstream;
dec->pkt->size = (int) req->bitstream_len;
}
rc = fm->avcodec_send_packet(ctx, dec->pkt);
if (rc < 0) {
log_err("decoder: avcodec_send_packet failed: %d", rc);
resp->status = DAEDALUS_DECODE_ERR_SEND;
return 0;
goto out;
}
fm->av_frame_unref(dec->frame);
@@ -396,12 +440,12 @@ int daedalus_decoder_run_request(struct daedalus_decoder *dec,
if (rc == AVERROR(EAGAIN) || rc == AVERROR_EOF) {
log_debug("decoder: no frame ready yet (rc=%d)", rc);
resp->status = DAEDALUS_DECODE_NO_FRAME;
return 0;
goto out;
}
if (rc < 0) {
log_err("decoder: avcodec_receive_frame failed: %d", rc);
resp->status = DAEDALUS_DECODE_ERR_RECV;
return 0;
goto out;
}
{
@@ -508,5 +552,9 @@ int daedalus_decoder_run_request(struct daedalus_decoder *dec,
}
fm->av_frame_unref(dec->frame);
out:
free(assembled);
(void) assembled_len;
return 0;
}