reactor-runtime 2.9.2__tar.gz → 2.9.4__tar.gz

{reactor_runtime-2.9.2 → reactor_runtime-2.9.4}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: reactor_runtime
-Version: 2.9.2
+Version: 2.9.4
 Summary: Reactor runtime with public model API
 Author-email: Reactor <team@reactor.inc>
 Requires-Python: >=3.9

{reactor_runtime-2.9.2 → reactor_runtime-2.9.4}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "reactor_runtime"
-version = "2.9.2"
+version = "2.9.4"
 description = "Reactor runtime with public model API"
 authors = [
 	{ name = "Reactor", email = "team@reactor.inc" }

reactor_runtime-2.9.4/src/reactor_runtime/realtime/pipeline.py

@@ -0,0 +1,426 @@
+# Copyright (c) 2026 Reactor Technologies, Inc. All rights reserved.
+"""
+:class:`RealtimePipeline` — the thin runtime bridge to a standalone engine.
+
+The engine (the ``realtime_engine`` package) owns the scheduling loop and all
+ML. It is driven only through inbox/outbox queues and has **zero**
+``reactor_runtime`` dependency. This bridge is the runtime-side caller: it
+inherits everything from :class:`ReactorPipeline` — typed :class:`InputState`,
+auto ``set_<field>`` events, :class:`Output` wrapping, ``emit`` / FPS pacing,
+and the connection lifecycle — and adds only the queue plumbing::
+
+    connect      ->  Attach(session_id, attach_context)
+    per tick     ->  Action(session_id, conditioning)   (state_to_conditioning, on change)
+    @event reset ->  Reset(session_id, attach_context)  (edge-triggered)
+    Chunk        ->  on_output  (default: emit media; override to send a message)
+
+**One conditioning path.** A single loop runs at the engine's ``rate_hz``,
+snapshots :meth:`state_to_conditioning` under ``_gen_lock``, and enqueues an
+``Action`` only when the conditioning changed. Everything the engine conditions
+on flows through this one path — control fields (``self.state``) *and* any input
+media a model pulls from its input tracks inside ``state_to_conditioning``.
+``default_serve`` keeps the last conditioning between ticks and applies the
+newest at the next chunk boundary, so tick-cadence sampling costs no more latency
+than event-driven pushes (the engine only applies at boundaries either way) while
+keeping a single, un-branched code path — matching the design doc (the runtime
+snapshots state → inbox at chunk boundaries) and how vLLM-Omni / sglang drain
+conditioning at chunk boundaries and generate from the last value otherwise.
+
+The bridge owns **no** scheduling, **no** ML, and **no** state machine; if it
+grows logic, that logic belongs in the engine (its ``serve`` loop) or in a
+hook, not here.
+
+Subclasses declare a typed ``state: MyState`` and an :class:`Output` subclass,
+then override the small hooks: :meth:`build_engine`, :meth:`_attach_context`,
+:meth:`state_to_conditioning`, :meth:`on_output`. A media-in model (v2v, a VLA
+policy) reads its input tracks (``self._input_buffers``) inside
+``state_to_conditioning`` and returns the frames as ordinary conditioning keys —
+no special flag or reserved field; the loop above carries them like any other
+conditioning.
+"""
+
+from __future__ import annotations
+
+import asyncio
+import copy
+import itertools
+from collections.abc import Mapping
+from typing import Any, Optional
+
+import numpy as np
+
+from reactor_runtime.interface import BufferClosed
+from reactor_runtime.interface.pipeline.reactor_pipeline import ReactorPipeline
+from reactor_runtime.utils.log import get_logger
+
+# Optional dependency: the runtime does NOT depend on the engine/contract. This
+# guarded import lets a plain ``reactor_runtime`` install (and non-engine models)
+# work without it — importing this module never fails. Only engine-backed models
+# need the contract, and ``RealtimePipeline.__init__`` fails clearly (below) if
+# it's absent, instead of a bare ``ModuleNotFoundError``.
+try:
+    from realtime_engine import (
+        Action,
+        Attach,
+        Detach,
+        Inbox,
+        Outbox,
+        RealtimeInterface,
+        Reset,
+        run_engine,
+    )
+
+    HAS_REALTIME_ENGINE = True
+except ImportError:
+    HAS_REALTIME_ENGINE = False
+
+logger = get_logger(__name__)
+
+
+class RealtimePipeline(ReactorPipeline):
+    """Drive a queue/``serve`` :class:`RealtimeInterface` engine from the runtime.
+
+    Override :meth:`run` is **not** needed — this class provides the queue
+    loop. Subclasses provide the model surface (state + output track) and the
+    hooks. ``inference()`` is intentionally unused: the engine, not a
+    generator, produces frames.
+    """
+
+    # Session-liveness poll interval. This only governs how quickly the bridge
+    # notices connect/disconnect transitions to issue Attach/Detach — it is NOT
+    # on the frame path (chunks flow through an independent drain task + the
+    # engine's own loop), so a coarse interval is fine.
+    _lifecycle_poll_s: float = 0.02
+
+    def __init__(self) -> None:
+        if not HAS_REALTIME_ENGINE:
+            raise ImportError(
+                "RealtimePipeline (engine-backed models) requires the realtime "
+                "contract package. Install it with "
+                "`pip install reactor-realtime-engine`."
+            )
+        super().__init__()
+        self._engine: Optional[RealtimeInterface] = None
+        self._inbox: Optional[Inbox] = None
+        self._sid: Optional[str] = None
+        self._last_cond: Optional[dict] = None
+        self._sid_counter = itertools.count(1)
+        # Conditioning-loop cadence; set from the manifest in run(). Initialized
+        # here so the attr always has a value (and tests can set it directly).
+        self._rate_hz: float = 1.0
+
+    # ------------------------------------------------------------------
+    # load() — build the engine (no event-loop primitives here)
+    # ------------------------------------------------------------------
+
+    def load(self, config: dict[str, Any]) -> None:
+        """Build the engine once, before any client connects.
+
+        Queues / events are created in :meth:`run` instead — ``load()`` runs
+        before the event loop exists.
+        """
+        self._engine = self.build_engine(config)
+
+    # ------------------------------------------------------------------
+    # run() — the queue-plumbing loop (replaces the generator loop)
+    # ------------------------------------------------------------------
+
+    async def run(self) -> None:
+        engine = self._engine
+        if engine is None:
+            raise RuntimeError(
+                f"{type(self).__name__}.load() must build an engine before run()"
+            )
+
+        inbox, outbox, stop = Inbox(), Outbox(), asyncio.Event()
+        self._inbox = inbox
+
+        # Pace emission to the engine's declared chunk cadence — NOT to its
+        # per-step compute time. The engine's serve loop already ticks at
+        # rate_hz; deriving fps from step_ms (tiny on a fast engine) would tell
+        # the output buffer to drain far faster than chunks actually arrive.
+        # frames_per_chunk is declared by the manifest (not inferred from
+        # chunk_shape, which is an opaque output shape).
+        manifest = engine.manifest()
+        self.output_buffer.set_fps(
+            max(1.0, manifest.rate_hz * manifest.frames_per_chunk)
+        )
+        # The conditioning loop samples state at the engine's tick cadence.
+        self._rate_hz = max(1.0, manifest.rate_hz)
+
+        lock = self._gen_lock
+        if lock is None:
+            raise RuntimeError(
+                f"{type(self).__name__}.run() called before _init_async()"
+            )
+
+        engine_task = asyncio.create_task(run_engine(engine, inbox, outbox, stop=stop))
+        try:
+            while True:
+                # Fresh state per connection (mirrors ReactorPipeline.run()).
+                self.state = self._state_cls()
+                self._sid = None
+                self._last_cond = None
+                await self.connected.wait()
+
+                # Attach only after the @connected handler has initialized state.
+                # That handler runs under _gen_lock (ReactorPipeline._invoke), and
+                # the dispatcher acquires the lock before it yields, so taking the
+                # lock here orders us strictly after it — otherwise a model that
+                # sets seed/prompt/image in @connected would attach with defaults.
+                async with lock:
+                    sid = f"s{next(self._sid_counter)}"
+                    self._sid = sid
+                    # deepcopy: the inbox payload must be a self-contained
+                    # snapshot — a nested ndarray/list in the context stays a
+                    # live alias of self.state under a shallow dict() copy, so a
+                    # later in-place mutation could change an already-enqueued msg.
+                    inbox.put_nowait(
+                        Attach(sid, copy.deepcopy(dict(self._attach_context())))
+                    )
+                    self._push_action_if_changed()  # seed initial conditioning
+
+                # The single conditioning path: sample state_to_conditioning() at
+                # the engine's cadence and push on change. Started after Attach so
+                # the engine has a session to condition.
+                #
+                # Why this is a separate task from the drain loop below (they are
+                # NOT two competing rates): the two directions have different
+                # natural triggers. INBOUND (client->engine) is time-driven — we
+                # sample conditioning at the engine's step cadence (rate_hz), so
+                # it's a fixed-rate loop. OUTBOUND (engine->client) is
+                # event-driven — we emit each chunk the instant it lands on the
+                # outbox, so that loop blocks on outbox.get(). Keeping them
+                # separate lets output emit with no added latency while
+                # conditioning samples on its own clock; folding both into one
+                # loop would gate one direction on the other's timing.
+                cond_task = asyncio.create_task(self._conditioning_loop(sid))
+
+                # Drain chunks -> emit, and notice disconnect. This loop is paced
+                # by chunk ARRIVAL (i.e. rate_hz), not by _lifecycle_poll_s:
+                # wait_for only bounds a single get() so a paused engine (no
+                # chunks) still re-checks liveness and detaches promptly instead
+                # of blocking forever — it's a liveness timeout, not the emit
+                # rate. A timed-out get() leaves any in-flight chunk on the queue
+                # (get is cancellation-safe), so the next iteration picks it up.
+                try:
+                    while self.connected.is_set():
+                        try:
+                            chunk = await asyncio.wait_for(
+                                outbox.get(), self._lifecycle_poll_s
+                            )
+                        except asyncio.TimeoutError:
+                            continue  # no chunk this interval — re-check liveness
+                        if chunk.session_id != sid:
+                            continue  # a chunk for a previous/other session — drop it
+                        try:
+                            await self.on_output(chunk.output)
+                        except Exception:
+                            # A model bug in on_output (e.g. a translation raising
+                            # on one malformed chunk) must not kill the session —
+                            # log, drop this chunk, keep draining. Parity with
+                            # _conditioning_loop; a real disconnect is still caught
+                            # by the connected/wait_for liveness check above.
+                            logger.exception(
+                                "on_output failed for a chunk; dropping it "
+                                "(session survives)"
+                            )
+                finally:
+                    # Stop the conditioning loop before clearing identity so it
+                    # can't enqueue an Action after the Detach below.
+                    cond_task.cancel()
+                    # Clear identity BEFORE enqueuing Detach: a racing tick then
+                    # sees no session and won't enqueue an Action after the Detach
+                    # (the local sid stays valid here).
+                    self._sid = None
+                    self.state = None
+                    inbox.put_nowait(Detach(sid))
+                    for buf in self._input_buffers.values():
+                        buf.reset()
+                    self.output_buffer.flush()
+                    await _await_quietly(cond_task)
+        finally:
+            stop.set()
+            self._inbox = None
+            await _await_quietly(engine_task)
+
+    # ------------------------------------------------------------------
+    # Conditioning — one tick-cadence loop, push on change
+    # ------------------------------------------------------------------
+
+    async def _conditioning_loop(self, sid: str) -> None:
+        """Snapshot conditioning at the engine's cadence; enqueue on change.
+
+        The sole runtime→engine conditioning path. Each tick, under ``_gen_lock``
+        (so we never snapshot state torn mid-mutation by an async ``@event`` /
+        ``@connected`` handler), recompute :meth:`state_to_conditioning` and push
+        one ``Action`` only if it changed vs the last. Control fields and any
+        input media a model reads inside ``state_to_conditioning`` flow through
+        here identically. ``default_serve`` reuses the last conditioning when no
+        new ``Action`` arrives, so unchanged state needs no message. A
+        :class:`BufferClosed` (a model reading a closed input track after the
+        client left) or cancellation ends the loop; teardown issues the Detach.
+        """
+        interval = 1.0 / self._rate_hz
+        while self._inbox is not None and self._sid == sid and self.state is not None:
+            try:
+                async with self._gen_lock:
+                    self._push_action_if_changed()
+            except BufferClosed:
+                return  # a model read a closed input track; teardown does Detach
+            except Exception:
+                # A model bug in state_to_conditioning must not silently freeze
+                # conditioning for the rest of the session — log and keep ticking
+                # (mirrors default_serve's "skip the tick, the loop survives").
+                logger.exception(
+                    "conditioning snapshot failed; skipping tick (loop survives)"
+                )
+            await asyncio.sleep(interval)
+
+    def _push_action_if_changed(self) -> None:
+        """Recompute conditioning; enqueue an ``Action`` only when it changed.
+
+        Called under ``_gen_lock`` (from :meth:`_conditioning_loop`, and once at
+        Attach to seed). Kept side-effect-cheap so holding the lock is brief.
+        """
+        if self._inbox is None or self._sid is None or self.state is None:
+            return
+        # deepcopy so the enqueued Action is a self-contained snapshot: a nested
+        # ndarray/list (e.g. an input frame a model pulled into conditioning)
+        # would otherwise alias live storage and could be mutated in place after
+        # enqueue (also keeps _last_cond a stable comparison base).
+        cond = copy.deepcopy(dict(self.state_to_conditioning()))
+        if _conds_equal(cond, self._last_cond):
+            return
+        self._last_cond = cond
+        self._inbox.put_nowait(Action(self._sid, cond))
+
+    def reset_session(self) -> None:
+        """Reset the live session's episode (edge-triggered — deliver once).
+
+        Call from an ``@event`` handler for a discrete command (e.g. episode
+        reset), NOT via conditioning: conditioning is sampled every tick, so a
+        reset carried there would drop (two within a tick) or repeat (a lingering
+        flag fires every step). ``default_serve`` turns this ``Reset`` into
+        detach + re-attach, so the engine rebuilds the session fresh (clears any
+        per-session state — frame buffers, step count) and re-seeds from a fresh
+        attach context. No-op if there's no live session.
+
+        Also clears the runtime-side carry-over so the new episode starts clean:
+        the input-track buffers (else a media-in model's next
+        ``state_to_conditioning`` replays stale pre-reset frames) and
+        ``_last_cond`` — so the next conditioning tick re-seeds the rebuilt
+        session (which ``default_serve`` re-attaches with empty conditioning).
+        """
+        if self._inbox is None or self._sid is None or self.state is None:
+            return
+        for buf in self._input_buffers.values():
+            buf.reset()
+        self._last_cond = None  # force the next tick to re-seed the rebuilt session
+        self._inbox.put_nowait(
+            Reset(self._sid, copy.deepcopy(dict(self._attach_context())))
+        )
+
+    # ------------------------------------------------------------------
+    # Hooks — subclasses override these
+    # ------------------------------------------------------------------
+
+    def build_engine(self, config: dict[str, Any]) -> RealtimeInterface:
+        """Construct the engine. Required override."""
+        raise NotImplementedError(
+            f"{type(self).__name__} must implement build_engine()"
+        )
+
+    def _state_snapshot(self) -> dict[str, Any]:
+        """Public state fields as a plain dict (the default hook payload)."""
+        if self.state is None:
+            return {}
+        return {
+            name: getattr(self.state, name) for name in type(self.state)._public_fields
+        }
+
+    def _attach_context(self) -> Mapping[str, Any]:
+        """Seed context for :class:`Attach` (image / scene / prompt / seed).
+
+        Defaults to a snapshot of public state at connect time; override to
+        narrow it (e.g. only the seed).
+        """
+        return self._state_snapshot()
+
+    def state_to_conditioning(self) -> Mapping[str, Any]:
+        """Adapter from ``self.state`` (+ input tracks) to engine conditioning.
+
+        The single State/input -> ``dict[str, Any]`` seam for :class:`Action`,
+        sampled once per tick by :meth:`_conditioning_loop`. Override it to
+        decouple your state shape from the engine's conditioning vocabulary —
+        rename fields, drop internal-only fields, or derive values the engine
+        wants but you don't expose in state. Defaults to a snapshot of public
+        state.
+
+        **Media-in models** (v2v, VLA policies) read their input tracks here and
+        return the frames as ordinary conditioning keys. **Retain the last frame
+        across gap ticks** — a ``LATEST`` read returns ``None`` when no fresh
+        frame arrived, and dropping the key would push a key-less ``Action`` that
+        flaps the track out of the engine's conditioning until frames resume
+        (``default_serve`` replaces conditioning wholesale). Keep the key on the
+        last value instead::
+
+            def state_to_conditioning(self):
+                frames = self.input.camera.try_read(1, mode=ReadMode.LATEST)
+                if frames:
+                    self._last_camera = frames[0].data
+                cond = {"prompt": self.state.prompt}
+                if self._last_camera is not None:
+                    cond["camera"] = self._last_camera
+                return cond
+
+        (If the engine keeps its own per-track history and tolerates a missing
+        key on a gap tick — e.g. GR00T's step appends only when the key is
+        present — you can drop the key instead; retain-last is the safe default.)
+
+        The loop deep-copies the result into the ``Action`` (snapshot safety), so
+        returned frame arrays are safe. Change-detection then suppresses
+        byte-identical snapshots — fine for content-conditioning (``default_serve``
+        reuses the last, identical value); a model that must forward *every* frame
+        object regardless of content can include a monotonic counter/timestamp key
+        to defeat suppression.
+
+        Note: change-detection between ticks compares the returned dict; array
+        values are handled with :func:`numpy.array_equal`.
+        """
+        return self._state_snapshot()
+
+    async def on_output(self, output: Any) -> None:
+        """Put one engine chunk on the wire — the single emission seam.
+
+        Default: the opaque engine ndarray is wrapped into the model's
+        single-track :class:`Output` (:meth:`_resolve_output`) and emitted
+        (FPS-paced). Override to send a data-channel message, emit multiple
+        tracks, or translate however the model needs — e.g. a VLA policy's action
+        chunk goes to ``send`` instead of ``emit``.
+        """
+        await self.emit(self._resolve_output(output))
+
+
+def _conds_equal(a: Optional[dict], b: Optional[dict]) -> bool:
+    """Dict equality that tolerates ndarray values (plain ``==`` on arrays
+    yields an array, and ``bool()`` of that raises ``ValueError``)."""
+    if a is None or b is None:
+        return a is b
+    if a.keys() != b.keys():
+        return False
+    for key in a:
+        av, bv = a[key], b[key]
+        if isinstance(av, np.ndarray) or isinstance(bv, np.ndarray):
+            if not np.array_equal(av, bv):
+                return False
+        elif av != bv:
+            return False
+    return True
+
+
+async def _await_quietly(task: asyncio.Task) -> None:
+    try:
+        await task
+    except asyncio.CancelledError:
+        pass

{reactor_runtime-2.9.2 → reactor_runtime-2.9.4}/src/reactor_runtime/transports/gstreamer/client.py

@@ -59,7 +59,13 @@ from reactor_runtime.transports.types import (
 )
 
 from reactor_runtime.utils.log import get_logger
-from reactor_runtime.transports.gstreamer.gst import Gst, GstSdp, GLib, GstWebRTC
+from reactor_runtime.transports.gstreamer.gst import (
+    Gst,
+    GstSdp,
+    GLib,
+    GstVideo,
+    GstWebRTC,
+)
 from reactor_runtime.transports.gstreamer.gst_helpers import (
     add_many,
     link_pads,
@@ -143,6 +149,32 @@ def _gst_buffer_pts_seconds(buf: object) -> Optional[float]:
         return None
 
 
+def _rgb_frame_from_mapped_buffer(
+    data: bytes | bytearray | memoryview, width: int, height: int, stride: int
+) -> np.ndarray:
+    """Copy a mapped RGB buffer into a tightly packed ``(H, W, 3)`` array.
+
+    GStreamer pads each row up to a 4-byte boundary, so ``stride`` (the bytes
+    the negotiated caps reserve per row) can exceed ``width * 3``. Reading at
+    the true stride and dropping the trailing padding keeps the rows from
+    shearing and the channels from rotating into grayscale.
+
+    Args:
+        data: The mapped buffer memory (anything exposing the buffer protocol).
+        width: Frame width in pixels.
+        height: Frame height in pixels.
+        stride: Bytes per row including padding, from the negotiated caps.
+
+    Returns:
+        An owned ``(height, width, 3)`` uint8 array with padding removed.
+    """
+    row_bytes = width * 3
+    if stride == row_bytes:
+        return np.ndarray((height, width, 3), dtype=np.uint8, buffer=data).copy()
+    padded = np.ndarray((height, stride), dtype=np.uint8, buffer=data)
+    return np.ascontiguousarray(padded[:, :row_bytes]).reshape(height, width, 3)
+
+
 # =============================================================================
 # GStreamerTransport
 # =============================================================================
@@ -1201,10 +1233,11 @@ class GStreamerTransport(WebRTCTransport):
             return Gst.FlowReturn.OK
 
         try:
-            # Create numpy array from buffer (RGB format)
-            frame: np.ndarray = np.ndarray(
-                shape=(height, width, 3), dtype=np.uint8, buffer=map_info.data
-            ).copy()  # Copy to own the data
+            # Read at the true row stride from the negotiated caps so padded
+            # rows (width * 3 not 4-aligned) don't shear into grayscale.
+            video_info = GstVideo.VideoInfo.new_from_caps(caps)
+            stride = video_info.stride[0] if video_info is not None else width * 3
+            frame = _rgb_frame_from_mapped_buffer(map_info.data, width, height, stride)
 
             self._gst_emit_event(
                 VideoFrameEvent(

{reactor_runtime-2.9.2 → reactor_runtime-2.9.4}/src/reactor_runtime/transports/gstreamer/encoders/av1.py

@@ -4,6 +4,7 @@ from reactor_runtime.transports.gstreamer.gst_helpers import (
     make_element,
     try_set_property,
 )
+from reactor_runtime.transports.gstreamer.settings import RTP_PAYLOAD_MTU
 from .base import BaseEncoderBin
 
 
@@ -71,6 +72,7 @@ class AV1EncoderBin(BaseEncoderBin):
 
         # Set RTP payload type to match negotiated PT
         self._pay.set_property("pt", self._pt)
+        try_set_property(self._pay, "mtu", RTP_PAYLOAD_MTU)
         if ssrc is not None:
             try_set_property(self._pay, "ssrc", ssrc)
 

{reactor_runtime-2.9.2 → reactor_runtime-2.9.4}/src/reactor_runtime/transports/gstreamer/encoders/h264.py

@@ -1,7 +1,10 @@
 from typing import Optional
 
 from reactor_runtime.transports.gstreamer.gst import Gst
-from reactor_runtime.transports.gstreamer.settings import HW_CODECS_ENABLED
+from reactor_runtime.transports.gstreamer.settings import (
+    HW_CODECS_ENABLED,
+    RTP_PAYLOAD_MTU,
+)
 from reactor_runtime.transports.gstreamer.gst_helpers import (
     link_many,
     make_element,
@@ -156,6 +159,7 @@ class H264EncoderBin(BaseEncoderBin):
 
         # Set RTP payload type
         self._pay.set_property("pt", self._pt)
+        try_set_property(self._pay, "mtu", RTP_PAYLOAD_MTU)
 
         # config-interval=1 forces SPS/PPS to be sent periodically.
         # Important for WebRTC because:
@@ -166,13 +170,21 @@ class H264EncoderBin(BaseEncoderBin):
             try_set_property(self._pay, "ssrc", ssrc)
 
         # ---------------------------------------------------------
-        # Enforce negotiated profile/level
+        # Enforce negotiated profile only — NOT level.
         # ---------------------------------------------------------
-        profile, level = h264_plid_to_gst_profile_level(profile_level_id)
-
-        caps = Gst.Caps.from_string(
-            f"video/x-h264,profile=(string){profile},level=(string){level}"
-        )
+        # The SDP profile-level-id encodes a level (e.g. 42e01f -> 3.1) that is
+        # only valid up to ~720p. Pinning that level in the capsfilter caps the
+        # encoder below the actual resolution: at 2K the encoded stream is
+        # ~level 5.x, the level-3.1 capsfilter fails to negotiate, and the whole
+        # send branch stalls with `not-negotiated` — zero RTP ever leaves. VP8
+        # (no level) is unaffected, which is why it works over the same path.
+        #
+        # Pin the profile only. x264/NVENC pick a level valid for the resolution,
+        # and receivers (incl. Safari) match on the profile, not the exact level.
+        # (`h264_plid_to_gst_profile_level` still validates the negotiated id.)
+        profile, _level = h264_plid_to_gst_profile_level(profile_level_id)
+
+        caps = Gst.Caps.from_string(f"video/x-h264,profile=(string){profile}")
 
         try_set_property(self._capsfilter, "caps", caps)
 

{reactor_runtime-2.9.2 → reactor_runtime-2.9.4}/src/reactor_runtime/transports/gstreamer/encoders/h265.py

@@ -1,7 +1,10 @@
 from typing import Dict, Optional
 
 from reactor_runtime.transports.gstreamer.gst import Gst
-from reactor_runtime.transports.gstreamer.settings import HW_CODECS_ENABLED
+from reactor_runtime.transports.gstreamer.settings import (
+    HW_CODECS_ENABLED,
+    RTP_PAYLOAD_MTU,
+)
 from reactor_runtime.transports.gstreamer.gst_helpers import (
     make_element,
     try_set_property,
@@ -13,11 +16,19 @@ def h265_fmtp_to_x265_option_string(fmtp: Dict[str, Optional[str]]) -> str:
     """
     Map HEVC SDP fmtp (RFC 7798) keys to ``x265enc`` ``option-string`` tokens.
 
-    SDP ``tier-flag`` and ``level-id`` are mapped to ``high-tier`` and
-    ``level-idc`` respectively.  ``profile-id`` is intentionally omitted:
-    GStreamer's x265enc enforces profile through caps negotiation (calling
-    x265_param_apply_profile internally), not via x265_param_parse — passing
-    ``profile=...`` in option-string causes an encoder init failure.
+    SDP ``tier-flag`` is mapped to ``high-tier``.  ``profile-id`` is
+    intentionally omitted: GStreamer's x265enc enforces profile through caps
+    negotiation (calling x265_param_apply_profile internally), not via
+    x265_param_parse — passing ``profile=...`` in option-string causes an
+    encoder init failure.
+
+    ``level-id`` is intentionally NOT mapped to ``level-idc``. The offered
+    level-id advertises the receiver's decode ceiling, and forcing it onto
+    the encoder makes x265 refuse to initialize for any frame above that
+    level's budget (Safari offers level-id=93 = level 3.1, ~720p), silently
+    stalling the sender branch. x265 derives a resolution-valid level and
+    writes it into the bitstream; receivers decode based on that, and in
+    practice tolerate streams above their advertised ceiling.
 
     Unrecognized or missing values are omitted so the encoder can use defaults.
     """
@@ -36,19 +47,6 @@ def h265_fmtp_to_x265_option_string(fmtp: Dict[str, Optional[str]]) -> str:
     elif tier == "0":
         parts.append("high-tier=0")
 
-    level = _get("level-id")
-    if level is not None:
-        try:
-            lid = int(level)
-        except ValueError:
-            lid = -1
-        if 0 <= lid <= 255:
-            level_idc = lid / 30
-            if level_idc == int(level_idc):
-                parts.append(f"level-idc={int(level_idc)}")
-            else:
-                parts.append(f"level-idc={level_idc:.1f}")
-
     return ":".join(parts)
 
 
@@ -122,6 +120,7 @@ class H265EncoderBin(BaseEncoderBin):
 
         # Set RTP payload type to match SDP negotiation
         self._pay.set_property("pt", self._pt)
+        try_set_property(self._pay, "mtu", RTP_PAYLOAD_MTU)
 
         # config-interval=1 ensures VPS/SPS/PPS are periodically sent.
         # Important for:

{reactor_runtime-2.9.2 → reactor_runtime-2.9.4}/src/reactor_runtime/transports/gstreamer/encoders/opus.py

@@ -17,6 +17,7 @@ from reactor_runtime.transports.gstreamer.gst_helpers import (
     make_element,
     try_set_property,
 )
+from reactor_runtime.transports.gstreamer.settings import RTP_PAYLOAD_MTU
 from .base import BaseEncoderBin
 
 # opusenc frame-size enum values (ms); must be >= SDP minptime
@@ -131,6 +132,7 @@ class OpusEncoderBin(BaseEncoderBin):
         try_set_property(self._enc, "dtx", dtx)
 
         self._pay.set_property("pt", self._pt)
+        try_set_property(self._pay, "mtu", RTP_PAYLOAD_MTU)
         if ssrc is not None:
             try_set_property(self._pay, "ssrc", ssrc)
 

{reactor_runtime-2.9.2 → reactor_runtime-2.9.4}/src/reactor_runtime/transports/gstreamer/encoders/vp8.py

@@ -4,6 +4,7 @@ from reactor_runtime.transports.gstreamer.gst_helpers import (
     make_element,
     try_set_property,
 )
+from reactor_runtime.transports.gstreamer.settings import RTP_PAYLOAD_MTU
 from .base import BaseEncoderBin
 
 
@@ -86,6 +87,7 @@ class VP8EncoderBin(BaseEncoderBin):
 
         # RTP payload type must match SDP negotiation
         self._pay.set_property("pt", self._pt)
+        try_set_property(self._pay, "mtu", RTP_PAYLOAD_MTU)
         if ssrc is not None:
             try_set_property(self._pay, "ssrc", ssrc)