refactor(viewer): swap libmpv embed for QtMultimedia + GStreamer

The libmpv-embedded path engaged HW decode correctly on all 4 Qt6
boards but didn't move Pi 4 frame drops below the subprocess-mpv
baseline (562–2973 drops/60 s, same range as PR #2885). Real-device
verbose mpv logging confirmed the decoders engaged; the bottleneck
was V3D 6.0 fillrate through libmpv-render → QOpenGLWidget FBO →
Qt-compositor → eglfs swap. Skipping the FBO indirection by porting
to QOpenGLWindow crashed under eglfs's single-native-window-per-
process limit (reverted at f057198).

QtMultimedia + gstreamer is the next try:

- ``VideoView`` rewritten around QMediaPlayer + QVideoWidget +
  QAudioOutput. QVideoWidget paints inside MainWindow's existing
  eglfs native window, so we don't trip the single-window
  restriction. Stats logger keeps the same /data/.anthias/mpv-stats.log
  schema (INIT / LOADFILE / PLAYING / SAMPLE / END_FILE) with a
  drop estimate computed from container_fps × elapsed − frames-
  delivered (QVideoSink::videoFrameChanged counter).
- ``QT_MEDIA_BACKEND=gstreamer`` is set in the viewer Dockerfile so
  Qt picks the gstreamer backend over its ffmpeg one — the rpi
  ``v4l2slh264dec`` / ``v4l2slh265dec`` elements (in rpt3
  ``gstreamer1.0-plugins-bad``, confirmed via ``dpkg-deb -c`` on
  the .deb) route directly to QVideoSink.
- ``docker/_rpt1-ffmpeg-pin.j2`` extends the rpi-archive pin to
  ``gstreamer1.0-*`` + ``libgstreamer*`` so plugins-bad wins from
  rpt3 over stock Debian (priority bump 100 → 1001).
- ``viewer_extra_apt_dependencies`` swaps libmpv2 for the
  gstreamer1.0-{alsa,libav,plugins-{base,good,bad,ugly}} +
  libqt6multimedia6 + libqt6multimediawidgets6 + qt6-multimedia-dev
  set.
- ``MPVMediaPlayer`` Python options shrink to audio-device +
  video-rotate (Pi 4 only). Removed: hwdec, video-sync,
  vd-lavc-threads, the _PI_HWDEC_BY_CODEC table, _probe_video_codec,
  _pi_hwdec_for_uri. Codec dispatch is now gstreamer's job.
- Python tests drop the ~12 per-codec / ffprobe-dispatch tests;
  C++ tests drop the mpv_get_property_string round-trip in favour
  of QMediaPlayer construction + option-passthrough assertions.
  Codec-gate symmetry test replaced with "gate codecs ⊆
  {h264, hevc}" — broader, catches a relaxation of the upload
  gate at the same time.

Pi 4 perf gain is unverified — Pi 4 testbed went offline
mid-session (along with Pi 5 and Rock Pi 4). Real-device
validation pending.

Author: vpetersson

docker/Dockerfile.viewer.j2

@@ -17,15 +17,14 @@ RUN --mount=type=cache,target=/var/cache/apt,id=qt6-builder-apt-{{ artifact_boar
     apt-get update && \
     apt-get install -y --no-install-recommends \
         build-essential \
-        libmpv-dev \
-        pkg-config \
         qt6-base-dev \
+        qt6-multimedia-dev \
         qt6-webengine-dev
-# libmpv-dev + pkg-config: AnthiasWebview.pro pulls libmpv via
-# ``PKGCONFIG += mpv`` so the in-tree VideoView can call into
-# libmpv via mpv_render_context (issue #2904). Debian Trixie ships
-# libmpv2 in main; the dev package is builder-only, the runtime
-# .so is added to viewer_extra_apt_dependencies below.
+# qt6-multimedia-dev: AnthiasWebview's VideoView wraps QMediaPlayer +
+# QVideoWidget (issue #2904, see ``src/anthias_webview/AnthiasWebview.pro``).
+# Runtime backend is gstreamer (forced via ``QT_MEDIA_BACKEND`` env
+# below); plugin discovery happens at runtime against the
+# ``gstreamer1.0-*`` packages added to ``viewer_extra_apt_dependencies``.
 COPY src/anthias_webview/AnthiasWebview.pro /src/anthias_webview/AnthiasWebview.pro
 COPY src/anthias_webview/src /src/anthias_webview/src
 COPY src/anthias_webview/res /src/anthias_webview/res
@@ -120,6 +119,18 @@ ENV QT_QPA_PLATFORM=linuxfb
 ENV QT_LOGGING_RULES=*.debug=true
 ENV QT_QPA_DEBUG=1
 
+{% if is_qt6 %}
+# Force QtMultimedia's gstreamer backend (issue #2904). Qt 6.8's
+# default backend selection on Debian Trixie probes ffmpeg first,
+# but ffmpeg-backed playback would re-introduce the same offscreen-
+# decode-then-CPU-readback path that capped Pi 4 at 2973 vo
+# drops/60 s during the libmpv-render trial. Gstreamer routes the
+# v4l2 stateless decoders (``v4l2slh264dec`` / ``v4l2slh265dec``
+# from rpt3 ``gstreamer1.0-plugins-bad`` on Pi/arm64; ``vaapi`` on
+# x86) straight into ``QVideoSink``.
+ENV QT_MEDIA_BACKEND=gstreamer
+{% endif %}
+
 ENV GIT_HASH={{ git_hash }}
 ENV GIT_SHORT_HASH={{ git_short_hash }}
 ENV GIT_BRANCH={{ git_branch }}

docker/_rpt1-ffmpeg-pin.j2

@@ -48,7 +48,7 @@ RUN --mount=type=cache,target=/var/cache/apt,sharing=locked \
     echo "deb [signed-by=/etc/apt/keyrings/raspberrypi-archive.pgp] https://archive.raspberrypi.com/debian/ trixie main" \
         > /etc/apt/sources.list.d/raspberrypi.list && \
     printf '%s\n' \
-        'Package: mpv libavcodec* libavdevice* libavfilter* libavformat* libavutil* libpostproc* libswresample* libswscale* ffmpeg' \
+        'Package: mpv libavcodec* libavdevice* libavfilter* libavformat* libavutil* libpostproc* libswresample* libswscale* ffmpeg gstreamer1.0-* libgstreamer* libgstreamer-plugins-*' \
         'Pin: origin archive.raspberrypi.com' \
         'Pin-Priority: 1001' \
         '' \

src/anthias_viewer/media_player.py

@@ -1,9 +1,8 @@
 import logging
 import os
-import subprocess
 from typing import Any, ClassVar
 
-from anthias_common.board import ARM64_DEVICE_TYPES, resolve_device_key
+from anthias_common.board import ARM64_DEVICE_TYPES
 from anthias_common.device_helper import get_device_type
 from anthias_common.utils import clamp_screen_rotation
 from anthias_server.settings import settings
@@ -234,112 +233,6 @@ def is_playing(self) -> bool:
         raise NotImplementedError
 
 
-# Per-codec hwdec preference on Pi, per-board:
-#
-#   Pi 4: H.264 → v4l2m2m-copy  (V3D V4L2 M2M decoder via
-#                                bcm2835-codec, up to 1080p60)
-#         HEVC  → drm-copy      (FFmpeg v4l2_request_hevc, up to
-#                                4Kp60 via the dedicated HEVC block)
-#
-#   Pi 5: H.264 → auto-copy     (Hantro G1 silicon exists but mpv
-#                                has no v4l2-request H.264 hwdec
-#                                upstream; passing v4l2m2m-copy
-#                                here would just log "Could not
-#                                find a valid device" errors before
-#                                silently SW-falling-back. The
-#                                playback envelope (HEVC 4Kp60) means
-#                                every asset normalised post-rollout
-#                                lands as HEVC, so this branch only
-#                                fires for legacy variants the
-#                                re-render walker hasn't caught yet.)
-#         HEVC  → drm-copy      (Hantro G2, up to 4Kp60. Requires
-#                                `dtoverlay=vc4-kms-v3d,cma-512` in
-#                                /boot/firmware/config.txt — the
-#                                stock 64 MB CMA region can't fit
-#                                a 4K HEVC dst buffer pool, and the
-#                                kernel cmdline `cma=` route silently
-#                                orphans the rpi-hevc-dec driver.)
-#
-#   generic-arm64 (Armbian SBCs — Rock Pi 4, Orange Pi, etc.):
-#         H.264 → v4l2m2m-copy  (RK3399 Hantro via the v4l2m2m
-#         HEVC  → v4l2m2m-copy   driver. mpv's --hwdec=help on the
-#                                latest-generic-arm64 image lists
-#                                both h264_v4l2m2m and hevc_v4l2m2m;
-#                                on boards without a working driver
-#                                mpv logs a warning and SW-falls-
-#                                back at runtime.)
-#
-# `auto-copy` is the universal safe fallback when ffprobe can't
-# read the codec (missing file, network URI we don't probe, etc.).
-#
-# An earlier revision did this with a Lua on_load hook, but
-# video-codec-name is empty at every event mpv exposes to scripts
-# before hwdec init (on_load, on_preloaded). ffprobing from Python
-# at launch time is both simpler and the only thing that actually
-# works.
-_PI_HWDEC_BY_CODEC: dict[str, dict[str, str]] = {
-    'pi4-64': {'h264': 'v4l2m2m-copy', 'hevc': 'drm-copy'},
-    'pi5': {'hevc': 'drm-copy'},
-    # Rock Pi 4 (RK3399, Radxa). Both codecs go through
-    # ``drm-copy``: the arm64 viewer image now pulls the Raspberry
-    # Pi repo's ffmpeg (``+rpt1``, with ``--enable-v4l2-request``
-    # — same package family as Pi 4 / Pi 5), so mpv exposes the
-    # stateless v4l2_request decoders that the RK3399's ``rkvdec``
-    # (HEVC) and ``rockchip,rk3399-vpu-dec`` Hantro VPU (H.264)
-    # implement. The ``start_viewer.sh`` entrypoint creates the
-    # ``/dev/video-dec*`` symlinks the v4l2_request decoder
-    # discovery code expects (privileged docker mounts its own
-    # /dev tmpfs without udev's symlinks).
-    'rockpi4': {'h264': 'drm-copy', 'hevc': 'drm-copy'},
-}
-
-
-def _probe_video_codec(uri: str) -> str:
-    """Return the canonical lowercase video codec name for ``uri``.
-
-    Empty string on probe failure (missing file, unreadable codec,
-    ffprobe absent, etc.) — callers should then pick a safe
-    fallback like ``auto-copy``. Short timeout because this runs
-    synchronously before every mpv launch.
-    """
-    try:
-        result = subprocess.run(
-            [
-                'ffprobe',
-                '-v',
-                'error',
-                '-select_streams',
-                'v:0',
-                '-show_entries',
-                'stream=codec_name',
-                '-of',
-                'default=nw=1:nk=1',
-                uri,
-            ],
-            capture_output=True,
-            text=True,
-            timeout=5,
-        )
-        return result.stdout.strip().lower()
-    except (subprocess.SubprocessError, OSError):
-        return ''
-
-
-def _pi_hwdec_for_uri(uri: str) -> str:
-    """mpv ``--hwdec=`` value for ``uri`` on Pi 4 / Pi 5 / Rock Pi 4.
-
-    Reads the board key via ``resolve_device_key``, which upgrades a
-    catch-all ``arm64`` DEVICE_TYPE to the specific subtype the
-    host_agent publishes (Rock Pi 4 → ``rockpi4``). ``auto-copy`` is
-    the safe fallback when ffprobe can't read the codec; the upload
-    gate (`anthias_server.processing._hw_decoded_codecs`) prevents
-    any codec outside ``_PI_HWDEC_BY_CODEC`` reaching this branch in
-    the first place.
-    """
-    board_map = _PI_HWDEC_BY_CODEC.get(resolve_device_key(), {})
-    return board_map.get(_probe_video_codec(uri), 'auto-copy')
-
-
 def _marshal_dbus_options(options: dict[str, str]) -> dict:
     """Wrap each value as a ``GLib.Variant('s', ...)`` for pydbus.
 
@@ -357,49 +250,40 @@ def _marshal_dbus_options(options: dict[str, str]) -> dict:
 
 
 def _build_mpv_options(uri: str) -> dict[str, str]:
-    """Build the per-file mpv option dict sent over D-Bus to libmpv.
-
-    Mirrors what the old ``subprocess.Popen([mpv, ...])`` argv
-    composed, minus the bits that are now Qt's responsibility:
-
-    * ``--vo=...`` is gone — libmpv embedded via ``mpv_render_context``
-      paints into the QOpenGLWidget's FBO; there is no separate VO.
-    * ``--drm-mode=1920x1080@60`` on Pi 4 is gone — Qt's ``eglfs``
-      KMS config (``docker/eglfs-kms-pi4.json``) pins the framebuffer
-      to 1080p at QPA init.
-    * ``--no-terminal`` / stdout redirection is gone — libmpv's
-      logging is routed through ``mpv_request_log_messages`` to the
-      AnthiasWebview process's stderr in C++ (see
-      src/anthias_webview/src/videoview.cpp).
-
-    Kept: ``hwdec`` (per-board, per-codec via ffprobe),
-    ``audio-device`` (per-board ALSA), ``video-sync`` (display
-    resample — same rationale as before), ``vd-lavc-threads`` (Pi 4 /
-    Pi 5 decoder thread count), ``video-rotate`` (Pi 4 only — cage
-    boards rotate via wlr-randr).
+    """Build the per-file option dict sent over D-Bus to QtMultimedia.
+
+    QtMultimedia + GStreamer auto-picks the best decoder element
+    via ``decodebin3`` (``v4l2slh264dec`` / ``v4l2slh265dec`` on
+    Pi 4 / Pi 5 / Rock Pi 4 via the rpt3 ``gstreamer1.0-plugins-bad``
+    pin in docker/_rpt1-ffmpeg-pin.j2, ``vaapi`` on x86). The
+    application no longer dispatches per-codec hwdec; the
+    options dict shrinks to:
+
+    * ``audio-device`` — ALSA device name (the same string mpv
+      consumed; gstreamer's ALSA sink and Qt's ``QAudioDevice``
+      resolve it identically).
+    * ``video-rotate`` — Pi 4 only. Cage / wayland boards already
+      get the transform from wlr-randr at the compositor level;
+      sending ``video-rotate`` on top would double-rotate.
+
+    The ``uri`` argument is kept on the signature for symmetry
+    with the libmpv era (where it fed ffprobe). It's no longer
+    read because gstreamer handles codec probing internally —
+    but a future codec-specific tuning may re-introduce it.
     """
+    del uri  # see docstring; kept for signature compatibility.
     device_type = os.environ.get('DEVICE_TYPE', '')
 
-    if resolve_device_key() in _PI_HWDEC_BY_CODEC:
-        hwdec_value = _pi_hwdec_for_uri(uri)
-    else:
-        hwdec_value = 'auto-copy'
-
     options: dict[str, str] = {
-        'hwdec': hwdec_value,
-        'video-sync': 'display-resample',
         'audio-device': f'alsa/{get_alsa_audio_device()}',
     }
 
-    if device_type in ('pi4-64', 'pi5'):
-        options['vd-lavc-threads'] = '4'
-
     # Rotation: cage/wlroots boards rotate via wlr-randr (issue
     # #2856, wired in src/anthias_viewer/__init__.py) and Qt's
-    # wayland QPA inherits the transform — passing video-rotate to
-    # libmpv on top of that would double-rotate. On Pi 4 (eglfs,
-    # no compositor) Qt has no transform plumbing, so libmpv has
-    # to apply the rotation itself.
+    # wayland QPA inherits the transform — passing video-rotate
+    # on top would double-rotate. On Pi 4 (eglfs, no compositor)
+    # Qt has no transform plumbing, so the video pipeline has to
+    # apply the rotation itself.
     rotation = _screen_rotation()
     if rotation and device_type == 'pi4-64':
         options['video-rotate'] = str(rotation)

src/anthias_webview/AnthiasWebview.pro

@@ -1,17 +1,19 @@
 TEMPLATE = app
 
-QT += webenginecore webenginewidgets dbus openglwidgets
-CONFIG += c++17 link_pkgconfig
+QT += webenginecore webenginewidgets dbus multimedia multimediawidgets
+CONFIG += c++17
 
-# libmpv embedded inside AnthiasWebview (issue #2904). Replaces the
-# external mpv subprocess MPVMediaPlayer used to launch — one Qt
-# process now owns the framebuffer / Wayland surface for video too,
-# eliminating the two-process DRM-master contention that cost
-# 600-2800 vo drops per 60 s clip on Pi 4 under linuxfb. The Debian
-# Trixie ``libmpv-dev`` package supplies pkg-config metadata; the
-# runtime link is to ``libmpv.so`` (provided by ``libmpv2`` at
-# runtime, see docker/Dockerfile.viewer.j2).
-PKGCONFIG += mpv
+# QtMultimedia is the in-process video pipeline (issue #2904). An
+# earlier revision linked libmpv via ``mpv_render_context`` into a
+# ``QOpenGLWidget``; that engaged HW decode correctly but Pi 4 V3D
+# 6.0 couldn't sustain 60 fps through libmpv-render's GL upload +
+# FBO + Qt compositor pipeline. QtMultimedia with the gstreamer
+# backend (forced via ``QT_MEDIA_BACKEND=gstreamer`` in the runtime
+# env) routes the rpi v4l2 stateless decoders (``v4l2slh264dec`` /
+# ``v4l2slh265dec`` from rpt3 ``gstreamer1.0-plugins-bad``) directly
+# to ``QVideoSink`` — fewer copies, no FBO indirection, and
+# ``QVideoWidget`` paints inside MainWindow's single eglfs native
+# window so we don't trip eglfs's single-window-per-process limit.
 
 SOURCES += src/main.cpp \
     src/mainwindow.cpp \