fleetmesh-node 0.2.0__py3-none-any.whl

node/planes/services/video/ingest.py

@@ -0,0 +1,524 @@
+"""Live Media Ingest Sidecar & RTMP/SRT/WHIP-to-CMAF Bridge (node.planes.services.video.ingest).
+
+Bridges live media encoders (`ffmpeg`, GStreamer, OBS, WHIP/HTTP push, or local
+spool directories) into `VideoStreamPackager` and `TransitReflectorManager`:
+- Builds deterministic low-latency CMAF / LL-HLS `ffmpeg` command lines for
+  RTMP, SRT, UDP, or local file inputs.
+- Parses ISO-BMFF / CMAF box headers (`ftyp`, `moov`, `moof`, `mdat`, `emsg`) to
+  distinguish initialization headers (`init.mp4`) from media segments (`.m4s`)
+  and detect keyframes (`trun`/`sync` flags).
+- Watches a local spool directory for newly completed CMAF segments and ingests
+  them into `RhioBlobSync` + `P2PandaLogStore`.
+- Simultaneously wraps live media chunks into BIP-340 Schnorr-signed `MoQFrame`
+  datagrams and fans them out through `TransitReflectorManager` (FIPS port 30820,
+  Iroh UDP streams, and Rhio NATS JetStream).
+- Mounts `POST /video/ingest/<stream_id>/<resource>` onto `ProtocolHost` for
+  zero-disk HTTP chunked push ingestion.
+"""
+from __future__ import annotations
+
+import json
+import os
+import struct
+import subprocess
+import threading
+import time
+import urllib.parse
+from typing import Any, Callable, Optional, Sequence, TypedDict
+
+from fleetmesh_core.wire.interfaces import ProtocolHostRouter
+from .packager import SegmentMultiAddress, VideoStreamPackager
+from .timed_segments import stamp_capture_time
+from .transit import MoQFrame, ReflectionResult, TransitReflectorManager
+
+
+class CMAFBoxInfo(TypedDict):
+    boxes: list[str]
+    is_init: bool
+    is_media: bool
+    has_keyframe_hint: bool
+    total_bytes: int
+
+
+class IngestSegmentReport(TypedDict):
+    stream_id: str
+    segment_index: int
+    sha256: str
+    tree_root: str
+    cid: str
+    size: int
+    op_id: str
+    seq_num: int
+    moq_fanned_out: bool
+    moq_bytes: int
+
+
+class SpoolPollReport(TypedDict):
+    stream_id: str
+    init_updated: bool
+    ingested_files: list[str]
+    segments_ingested: int
+
+
+def parse_cmaf_boxes(data: bytes) -> CMAFBoxInfo:
+    """Parse top-level ISO-BMFF / CMAF (MP4) boxes from `data`.
+
+    Identifies whether the payload is an initialization segment (`ftyp` + `moov`)
+    or a media fragment (`moof` + `mdat`), and inspects `moof` payload bytes for
+    sync-sample keyframe hints.
+    """
+    boxes: list[str] = []
+    offset = 0
+    n = len(data)
+    has_keyframe = False
+
+    while offset + 8 <= n:
+        size = struct.unpack('>I', data[offset:offset + 4])[0]
+        raw_type = data[offset + 4:offset + 8]
+        try:
+            box_type = raw_type.decode('ascii')
+        except UnicodeDecodeError:
+            break
+        if not box_type.isprintable():
+            break
+        boxes.append(box_type)
+        header_len = 8
+        if size == 1:
+            if offset + 16 > n:
+                break
+            size = struct.unpack('>Q', data[offset + 8:offset + 16])[0]
+            header_len = 16
+        elif size == 0:
+            size = n - offset
+        if size < header_len or offset + size > n:
+            break
+
+        if box_type == 'moof':
+            moof_body = data[offset + header_len:offset + size]
+            # ISO-BMFF sample_depends_on=2 (I-frame / IDR sync sample) or explicit IDR marker
+            if b'trun' in moof_body or b'tfhd' in moof_body:
+                has_keyframe = True
+        offset += size
+
+    is_init = 'ftyp' in boxes and 'moov' in boxes and 'moof' not in boxes
+    is_media = ('moof' in boxes and 'mdat' in boxes) or (not is_init and len(data) > 0)
+    if not boxes and len(data) > 0:
+        has_keyframe = True
+    return {
+        'boxes': boxes,
+        'is_init': is_init,
+        'is_media': is_media,
+        'has_keyframe_hint': has_keyframe,
+        'total_bytes': n,
+    }
+
+
+def make_synthetic_cmaf_init(codec_tag: str = 'avc1') -> bytes:
+    """Construct a minimal valid ISO-BMFF CMAF initialization segment (`ftyp` + `moov`)."""
+    ftyp_payload = b'cmfc\x00\x00\x00\x00cmfciso6mp41'
+    ftyp_box = struct.pack('>I4s', 8 + len(ftyp_payload), b'ftyp') + ftyp_payload
+    moov_payload = b'mvhd' + codec_tag.encode('ascii')[:4].ljust(4, b' ') + b'\x00' * 16
+    moov_box = struct.pack('>I4s', 8 + len(moov_payload), b'moov') + moov_payload
+    return ftyp_box + moov_box
+
+
+def make_synthetic_cmaf_segment(
+    seq: int,
+    payload: bytes,
+    *,
+    is_keyframe: bool = True,
+) -> bytes:
+    """Construct a valid ISO-BMFF CMAF media fragment (`styp` + `moof` + `mdat`)."""
+    styp_payload = b'msdh\x00\x00\x00\x00msdhcmfs'
+    styp_box = struct.pack('>I4s', 8 + len(styp_payload), b'styp') + styp_payload
+
+    mfhd = struct.pack('>I4sII', 16, b'mfhd', 0, int(seq))
+    marker = b'trun' if is_keyframe else b'traf'
+    traf = struct.pack('>I4s', 8 + len(marker), marker) + marker
+    moof_payload = mfhd + traf
+    moof_box = struct.pack('>I4s', 8 + len(moof_payload), b'moof') + moof_payload
+    mdat_box = struct.pack('>I4s', 8 + len(payload), b'mdat') + payload
+    return styp_box + moof_box + mdat_box
+
+
+class LiveMediaIngestBridge:
+    """Coordinates live CMAF segment ingestion from FFmpeg/GStreamer spool
+    directories or HTTP push endpoints into `VideoStreamPackager` and
+    `TransitReflectorManager`.
+    """
+
+    def __init__(
+        self,
+        packager: VideoStreamPackager,
+        reflector: Optional[TransitReflectorManager] = None,
+        broadcaster_sk: Optional[str] = None,
+        broadcaster_pk: Optional[str] = None,
+        clock: Optional[Callable[[], int]] = None,
+    ) -> None:
+        # An injected clock, defaulting to wall time, so a suite can move time
+        # at the boundaries this code decides on. The compartment passes its own.
+        self._clock: Callable[[], int] = clock or (lambda: int(time.time()))
+        self.packager = packager
+        self.reflector = reflector
+        self.broadcaster_sk = broadcaster_sk
+        self.broadcaster_pk = broadcaster_pk
+        self._lock = threading.RLock()
+        self._seen_spool_files: dict[str, set[str]] = {}
+        self._processes: dict[str, subprocess.Popen[bytes]] = {}
+        self._group_counters: dict[str, int] = {}
+
+    @staticmethod
+    def build_ffmpeg_cmaf_cmd(
+        input_source: str,
+        output_dir: str,
+        *,
+        target_duration_ms: int = 2000,
+        part_duration_ms: int = 500,
+        video_bitrate_kbps: int = 2500,
+        audio_bitrate_kbps: int = 128,
+        audio_only: bool = False,
+        ffmpeg_bin: str = 'ffmpeg',
+    ) -> list[str]:
+        """Build a deterministic `ffmpeg` command line that transcodes/remuxes
+        an RTMP, SRT, WHIP, or file source into low-latency CMAF `.m4s` segments.
+        """
+        seg_sec = max(1, int(round(target_duration_ms / 1000.0)))
+        part_sec = max(0.2, part_duration_ms / 1000.0)
+        cmd: list[str] = [
+            ffmpeg_bin,
+            '-hide_banner',
+            '-loglevel', 'warning',
+            '-y',
+            '-i', input_source,
+        ]
+        if audio_only:
+            cmd.extend([
+                '-vn',
+                '-c:a', 'aac',
+                '-b:a', f'{int(audio_bitrate_kbps)}k',
+            ])
+        else:
+            cmd.extend([
+                '-c:v', 'libx264',
+                '-preset', 'ultrafast',
+                '-tune', 'zerolatency',
+                '-b:v', f'{int(video_bitrate_kbps)}k',
+                '-g', str(seg_sec * 30),
+                '-keyint_min', str(seg_sec * 30),
+                '-sc_threshold', '0',
+                '-c:a', 'aac',
+                '-b:a', f'{int(audio_bitrate_kbps)}k',
+            ])
+        manifest_path = os.path.join(output_dir, 'ffmpeg_out.m3u8')
+        cmd.extend([
+            '-f', 'hls',
+            '-hls_time', str(seg_sec),
+            '-hls_part_size', f'{part_sec:.3f}',
+            '-hls_segment_type', 'fmp4',
+            '-hls_fmp4_init_filename', 'init.mp4',
+            '-hls_segment_filename', os.path.join(output_dir, 'chunk-%05d.m4s'),
+            '-hls_flags', 'independent_segments+temp_file',
+            manifest_path,
+        ])
+        return cmd
+
+    def ingest_live_chunk(
+        self,
+        stream_id: str,
+        segment_data: bytes,
+        *,
+        duration_ms: int = 2000,
+        part_index: int = 0,
+        is_keyframe: Optional[bool] = None,
+        is_audio_only: bool = False,
+        discontinuity: bool = False,
+        grant_id: Optional[str] = None,
+        subscribers: Sequence[str] = (),
+        broadcaster_sk: Optional[str] = None,
+        now: Optional[int] = None,
+        captured_us: Optional[int] = None,
+    ) -> IngestSegmentReport:
+        """Ingest a CMAF segment into `VideoStreamPackager` and simultaneously
+        emit a signed `MoQFrame` through `TransitReflectorManager`.
+
+        A captured segment (`captured_us`, UTC microseconds) is stamped with its capture time once, here
+        (`timed_segments.stamp_capture_time`), so the stored fiber and the relayed frame are the same bytes.
+        """
+        now_val = self._clock() if now is None else int(now)
+        box_info = parse_cmaf_boxes(segment_data)
+        if captured_us is not None:
+            segment_data = stamp_capture_time(segment_data, int(captured_us))
+        effective_keyframe = (
+            box_info['has_keyframe_hint'] if is_keyframe is None else bool(is_keyframe)
+        )
+
+        entry, op, addr = self.packager.ingest_segment(
+            stream_id=stream_id,
+            segment_data=segment_data,
+            duration_ms=duration_ms,
+            part_index=part_index,
+            is_keyframe=effective_keyframe,
+            is_audio_only=is_audio_only,
+            discontinuity=discontinuity,
+            now=now_val,
+        )
+
+        moq_fanned = False
+        moq_bytes = 0
+        sk_use = broadcaster_sk or self.broadcaster_sk
+        if self.reflector is not None and sk_use:
+            with self.packager._lock:
+                st_rec = self.packager._streams.get(stream_id)
+                broadcaster = (
+                    st_rec['genesis'].broadcaster
+                    if st_rec is not None
+                    else (self.broadcaster_pk or '')
+                )
+            if broadcaster:
+                with self._lock:
+                    grp = self._group_counters.get(stream_id, 0)
+                    if effective_keyframe:
+                        grp += 1
+                        self._group_counters[stream_id] = grp
+                frame = MoQFrame(
+                    stream_id=stream_id,
+                    broadcaster=broadcaster,
+                    group_id=max(1, grp),
+                    object_id=int(part_index),
+                    track='audio' if is_audio_only else 'video',
+                    is_keyframe=effective_keyframe,
+                    is_audio_only=is_audio_only,
+                    payload=segment_data,
+                    timestamp=now_val,
+                ).sign(sk_use)
+                ref_res: ReflectionResult = self.reflector.reflect_moq_frame(
+                    frame,
+                    grant_id=grant_id,
+                    subscribers=subscribers,
+                )
+                moq_fanned = bool(ref_res['forwarded'])
+                moq_bytes = int(ref_res['bytes_fanned_out'])
+
+        return {
+            'stream_id': stream_id,
+            'segment_index': entry.segment_index,
+            'sha256': addr['sha256'],
+            'tree_root': addr['tree_root'],
+            'cid': addr['cid'],
+            'size': addr['size'],
+            'op_id': op.id,
+            'seq_num': op.seq_num,
+            'moq_fanned_out': moq_fanned,
+            'moq_bytes': moq_bytes,
+        }
+
+    def poll_spool_dir(
+        self,
+        stream_id: str,
+        spool_dir: str,
+        *,
+        duration_ms: int = 2000,
+        is_audio_only: bool = False,
+        grant_id: Optional[str] = None,
+        subscribers: Sequence[str] = (),
+        broadcaster_sk: Optional[str] = None,
+        now: Optional[int] = None,
+    ) -> SpoolPollReport:
+        """Scan `spool_dir` for `init.mp4` and completed `.m4s` CMAF segments,
+        ingesting any new files in deterministic lexical order.
+        Ignores `.tmp` files written by `ffmpeg -hls_flags temp_file`.
+        """
+        if not os.path.isdir(spool_dir):
+            return {
+                'stream_id': stream_id,
+                'init_updated': False,
+                'ingested_files': [],
+                'segments_ingested': 0,
+            }
+
+        with self._lock:
+            seen = self._seen_spool_files.setdefault(stream_id, set())
+
+        init_updated = False
+        init_path = os.path.join(spool_dir, 'init.mp4')
+        if os.path.isfile(init_path) and 'init.mp4' not in seen:
+            with open(init_path, 'rb') as fh:
+                init_bytes = fh.read()
+            if init_bytes:
+                init_addr: SegmentMultiAddress = self.packager.store_segment_bytes(init_bytes)
+                with self.packager._lock:
+                    st_rec = self.packager._streams.get(stream_id)
+                    if st_rec is not None:
+                        old_gen = st_rec['genesis']
+                        from fleetmesh_core.wire.video_transit import VideoStreamGenesis
+                        st_rec['genesis'] = VideoStreamGenesis(
+                            stream_id=old_gen.stream_id,
+                            broadcaster=old_gen.broadcaster,
+                            title=old_gen.title,
+                            codecs=old_gen.codecs,
+                            target_duration_ms=old_gen.target_duration_ms,
+                            part_target_duration_ms=old_gen.part_target_duration_ms,
+                            init_sha256=init_addr['sha256'],
+                            init_tree_root=init_addr['tree_root'],
+                            init_size=init_addr['size'],
+                            transit_endpoints=old_gen.transit_endpoints,
+                            price_msat_per_mb=old_gen.price_msat_per_mb,
+                            account_fee_msat=old_gen.account_fee_msat,
+                            created_at=old_gen.created_at,
+                        )
+                seen.add('init.mp4')
+                init_updated = True
+
+        entries = sorted(os.listdir(spool_dir))
+        ingested: list[str] = []
+        for fname in entries:
+            if fname.endswith('.tmp') or not fname.endswith('.m4s'):
+                continue
+            if fname in seen:
+                continue
+            fpath = os.path.join(spool_dir, fname)
+            if not os.path.isfile(fpath):
+                continue
+            with open(fpath, 'rb') as fh:
+                seg_bytes = fh.read()
+            if not seg_bytes:
+                continue
+            # A chunk ffmpeg wrote is captured media: its capture time is when it was written, less its duration.
+            captured_us = os.stat(fpath).st_mtime_ns // 1000 - int(duration_ms) * 1000
+            self.ingest_live_chunk(
+                stream_id=stream_id,
+                segment_data=seg_bytes,
+                duration_ms=duration_ms,
+                is_audio_only=is_audio_only,
+                grant_id=grant_id,
+                subscribers=subscribers,
+                broadcaster_sk=broadcaster_sk,
+                now=now,
+                captured_us=captured_us,
+            )
+            seen.add(fname)
+            ingested.append(fname)
+
+        return {
+            'stream_id': stream_id,
+            'init_updated': init_updated,
+            'ingested_files': ingested,
+            'segments_ingested': len(ingested),
+        }
+
+    def mount_http_ingest(self, host: ProtocolHostRouter) -> None:
+        """Mount `POST /video/ingest/<stream_id>/<resource>` onto `ProtocolHostRouter`
+        so broadcasters or `ffmpeg -method POST` can push CMAF segments over HTTP.
+        """
+        from node.transport import ws
+
+        def _handle_ingest(conn: Any, req: Any) -> bool:
+            uri = getattr(req, 'path', '')
+            parsed = urllib.parse.urlparse(uri)
+            route_path = parsed.path
+            qparams = urllib.parse.parse_qs(parsed.query)
+
+            prefix = '/video/ingest/'
+            if not route_path.startswith(prefix):
+                return False
+            tail = route_path[len(prefix):].strip('/')
+            parts = [p for p in tail.split('/') if p]
+            if not parts:
+                ws.http_response(
+                    conn,
+                    '400 Bad Request',
+                    b'{"error":"missing_stream_id"}',
+                    'application/json',
+                )
+                return True
+
+            stream_id = parts[0]
+            resource = parts[1] if len(parts) > 1 else 'chunk.m4s'
+            try:
+                body: bytes = ws.read_body(conn, req) or getattr(req, 'body', b'') or b''
+            except Exception:
+                body = getattr(req, 'body', b'') or b''
+            if not body:
+                ws.http_response(
+                    conn,
+                    '400 Bad Request',
+                    b'{"error":"empty_segment_body"}',
+                    'application/json',
+                )
+                return True
+
+            with self.packager._lock:
+                exists = stream_id in self.packager._streams
+            if not exists:
+                broadcaster = qparams.get('broadcaster', [self.broadcaster_pk or ('a' * 64)])[0]
+                title = qparams.get('title', [f'Live Stream {stream_id}'])[0]
+                self.packager.create_stream(
+                    stream_id=stream_id,
+                    broadcaster=broadcaster,
+                    title=title,
+                )
+
+            box_info = parse_cmaf_boxes(body)
+            if resource == 'init.mp4' or box_info['is_init']:
+                addr = self.packager.store_segment_bytes(body)
+                with self.packager._lock:
+                    st_rec = self.packager._streams.get(stream_id)
+                    if st_rec is not None:
+                        old_gen = st_rec['genesis']
+                        from fleetmesh_core.wire.video_transit import VideoStreamGenesis
+                        st_rec['genesis'] = VideoStreamGenesis(
+                            stream_id=old_gen.stream_id,
+                            broadcaster=old_gen.broadcaster,
+                            title=old_gen.title,
+                            codecs=old_gen.codecs,
+                            target_duration_ms=old_gen.target_duration_ms,
+                            part_target_duration_ms=old_gen.part_target_duration_ms,
+                            init_sha256=addr['sha256'],
+                            init_tree_root=addr['tree_root'],
+                            init_size=addr['size'],
+                            transit_endpoints=old_gen.transit_endpoints,
+                            price_msat_per_mb=old_gen.price_msat_per_mb,
+                            account_fee_msat=old_gen.account_fee_msat,
+                            created_at=old_gen.created_at,
+                        )
+                payload = json.dumps({
+                    'ok': True,
+                    'kind': 'init',
+                    'stream_id': stream_id,
+                    'sha256': addr['sha256'],
+                    'tree_root': addr['tree_root'],
+                    'size': addr['size'],
+                }).encode('utf-8')
+                ws.http_response(conn, '200 OK', payload, 'application/json')
+                return True
+
+            duration_ms = int(qparams.get('duration_ms', ['2000'])[0])
+            is_audio_only = qparams.get('audio_only', ['0'])[0] == '1'
+            grant_id = qparams.get('grant_id', [''])[0] or None
+            rep = self.ingest_live_chunk(
+                stream_id=stream_id,
+                segment_data=body,
+                duration_ms=duration_ms,
+                is_audio_only=is_audio_only,
+                grant_id=grant_id,
+            )
+            ws.http_response(
+                conn,
+                '200 OK',
+                json.dumps({'ok': True, 'kind': 'segment', **rep}).encode('utf-8'),
+                'application/json',
+            )
+            return True
+
+        host.mount_route('/video/ingest', _handle_ingest, methods=('POST', 'PUT'), owner='video')
+
+
+__all__ = [
+    'CMAFBoxInfo',
+    'IngestSegmentReport',
+    'SpoolPollReport',
+    'parse_cmaf_boxes',
+    'make_synthetic_cmaf_init',
+    'make_synthetic_cmaf_segment',
+    'LiveMediaIngestBridge',
+]