161 lines
4.5 KiB
Python
161 lines
4.5 KiB
Python
"""
|
|
MPV wrapper using python-mpv (libmpv bindings) with OpenGL render API.
|
|
|
|
Renders video frames to an OpenGL context provided by GTK4's GLArea.
|
|
No subprocess calls, no X11 wid hacks.
|
|
"""
|
|
|
|
import ctypes
|
|
import logging
|
|
|
|
import mpv as libmpv
|
|
|
|
log = logging.getLogger(__name__)
|
|
|
|
|
|
def _make_get_proc_address():
|
|
"""Create a ctypes callback for OpenGL function loading."""
|
|
libgl = ctypes.cdll.LoadLibrary("libGL.so.1")
|
|
libgl.glXGetProcAddressARB.restype = ctypes.c_void_p
|
|
libgl.glXGetProcAddressARB.argtypes = [ctypes.c_char_p]
|
|
|
|
@ctypes.CFUNCTYPE(ctypes.c_void_p, ctypes.c_void_p, ctypes.c_char_p)
|
|
def get_proc_address(_, name):
|
|
return libgl.glXGetProcAddressARB(name)
|
|
|
|
return get_proc_address
|
|
|
|
|
|
_get_proc_address = _make_get_proc_address()
|
|
|
|
|
|
class Player:
|
|
"""Wraps a libmpv player with OpenGL render context for GTK4 embedding."""
|
|
|
|
def __init__(self, record_path=None):
|
|
opts = {
|
|
"input_default_bindings": False,
|
|
"input_vo_keyboard": False,
|
|
"osc": False,
|
|
"profile": "low-latency",
|
|
"cache": "no",
|
|
"untimed": True,
|
|
"demuxer_thread": "no",
|
|
"demuxer_lavf_o": "fflags=+nobuffer",
|
|
"video_sync": "display-desync",
|
|
"vo": "libmpv",
|
|
"hwdec": "auto",
|
|
}
|
|
if record_path:
|
|
opts["stream_record"] = str(record_path)
|
|
log.info("mpv will record stream to: %s", record_path)
|
|
|
|
log.info("Creating mpv player (OpenGL render mode)")
|
|
self._player = libmpv.MPV(**opts)
|
|
self._ctx = None
|
|
self._update_callback = None
|
|
log.info("mpv player created")
|
|
|
|
def init_gl(self, update_callback):
|
|
"""Initialize the OpenGL render context.
|
|
|
|
Must be called from a thread with an active GL context (e.g. GLArea realize).
|
|
|
|
Args:
|
|
update_callback: called by mpv when a new frame is ready to render.
|
|
Should trigger a GLArea queue_render().
|
|
"""
|
|
self._update_callback = update_callback
|
|
self._ctx = libmpv.MpvRenderContext(
|
|
self._player,
|
|
"opengl",
|
|
opengl_init_params={
|
|
"get_proc_address": _get_proc_address,
|
|
},
|
|
)
|
|
# Keep reference to prevent GC of the ctypes callback
|
|
self._get_proc_address_ref = _get_proc_address
|
|
self._ctx.update_cb = self._on_mpv_update
|
|
log.info("mpv OpenGL render context initialized")
|
|
|
|
def _on_mpv_update(self):
|
|
"""Called by mpv from any thread when a new frame is available."""
|
|
if self._update_callback:
|
|
self._update_callback()
|
|
|
|
def render(self, fbo, width, height):
|
|
"""Render the current frame to the given OpenGL FBO.
|
|
|
|
Call from the GLArea render signal handler.
|
|
"""
|
|
if self._ctx:
|
|
self._ctx.render(
|
|
flip_y=True,
|
|
opengl_fbo={
|
|
"fbo": fbo,
|
|
"w": width,
|
|
"h": height,
|
|
},
|
|
)
|
|
|
|
def play(self, source):
|
|
"""Play from a file path or URL."""
|
|
log.info("mpv play: %s", source)
|
|
self._player.play(str(source))
|
|
|
|
def play_fd(self, fd):
|
|
"""Play from a raw file descriptor."""
|
|
source = f"fd://{fd}"
|
|
log.info("mpv play from fd: %s", source)
|
|
self._player.play(source)
|
|
|
|
def pause(self):
|
|
self._player.pause = True
|
|
|
|
def resume(self):
|
|
self._player.pause = False
|
|
|
|
@property
|
|
def paused(self):
|
|
return self._player.pause
|
|
|
|
def seek(self, seconds):
|
|
"""Seek to absolute position in seconds."""
|
|
self._player.seek(seconds, reference="absolute")
|
|
|
|
def seek_relative(self, seconds):
|
|
"""Seek relative to current position."""
|
|
self._player.seek(seconds, reference="relative")
|
|
|
|
def stop(self):
|
|
log.info("mpv stop")
|
|
self._player.stop()
|
|
|
|
def terminate(self):
|
|
log.info("mpv terminate")
|
|
try:
|
|
if self._ctx:
|
|
self._ctx.free()
|
|
self._ctx = None
|
|
self._player.terminate()
|
|
except Exception as e:
|
|
log.warning("mpv terminate error: %s", e)
|
|
|
|
@property
|
|
def idle(self):
|
|
return self._player.core_idle
|
|
|
|
@property
|
|
def duration(self):
|
|
try:
|
|
return self._player.duration
|
|
except Exception:
|
|
return None
|
|
|
|
@property
|
|
def time_pos(self):
|
|
try:
|
|
return self._player.time_pos
|
|
except Exception:
|
|
return None
|