@gjsify/webrtc-native 0.3.21 → 0.4.3

package/package.json

@@ -1,56 +1,56 @@
 {
-  "name": "@gjsify/webrtc-native",
-  "version": "0.3.21",
-  "description": "Vala-based main-thread signal bridge for @gjsify/webrtc. Marshals webrtcbin signals and GstPromise callbacks from GStreamer's streaming thread onto the GLib main context so GJS can safely handle them.",
-  "type": "module",
-  "main": "lib/esm/index.js",
-  "module": "lib/esm/index.js",
-  "types": "lib/types/index.d.ts",
-  "exports": {
-    ".": {
-      "types": "./lib/types/index.d.ts",
-      "default": "./lib/esm/index.js"
+    "name": "@gjsify/webrtc-native",
+    "version": "0.4.3",
+    "description": "Vala-based main-thread signal bridge for @gjsify/webrtc. Marshals webrtcbin signals and GstPromise callbacks from GStreamer's streaming thread onto the GLib main context so GJS can safely handle them.",
+    "type": "module",
+    "main": "lib/esm/index.js",
+    "module": "lib/esm/index.js",
+    "types": "lib/types/index.d.ts",
+    "exports": {
+        ".": {
+            "types": "./lib/types/index.d.ts",
+            "default": "./lib/esm/index.js"
+        }
+    },
+    "files": [
+        "lib",
+        "prebuilds",
+        "meson.build",
+        "src/vala"
+    ],
+    "gjsify": {
+        "prebuilds": "prebuilds"
+    },
+    "scripts": {
+        "clear": "rm -rf lib build tsconfig.tsbuildinfo tsconfig.types.tsbuildinfo || exit 0",
+        "check": "tsc --noEmit",
+        "init:meson": "meson setup build .",
+        "init:meson:wipe": "gjsify run init:meson --wipe",
+        "build": "gjsify run build:gjsify && gjsify run build:types",
+        "build:gjsify": "gjsify build --library 'src/ts/**/*.{ts,js}'",
+        "build:meson": "gjsify run init:meson && meson compile -C build",
+        "build:types": "tsc -b --force",
+        "build:prebuilds": "gjsify run build:meson && mkdir -p prebuilds/linux-x86_64 && cp build/libgjsifywebrtc.so build/GjsifyWebrtc-0.1.typelib prebuilds/linux-x86_64/"
+    },
+    "keywords": [
+        "gjs",
+        "webrtc",
+        "gstreamer",
+        "webrtcbin",
+        "vala",
+        "native"
+    ],
+    "dependencies": {
+        "@girs/gjs": "4.0.0-rc.15",
+        "@girs/gjsifywebrtc-0.1": "0.1.0-4.0.0-rc.5",
+        "@girs/glib-2.0": "2.88.0-4.0.0-rc.15",
+        "@girs/gobject-2.0": "2.88.0-4.0.0-rc.15",
+        "@girs/gst-1.0": "1.28.1-4.0.0-rc.15",
+        "@girs/gstwebrtc-1.0": "1.0.0-4.0.0-rc.15"
+    },
+    "devDependencies": {
+        "@gjsify/cli": "workspace:^",
+        "@types/node": "^25.6.2",
+        "typescript": "^6.0.3"
     }
-  },
-  "files": [
-    "lib",
-    "prebuilds",
-    "meson.build",
-    "src/vala"
-  ],
-  "gjsify": {
-    "prebuilds": "prebuilds"
-  },
-  "scripts": {
-    "clear": "rm -rf lib build tsconfig.tsbuildinfo tsconfig.types.tsbuildinfo || exit 0",
-    "check": "tsc --noEmit",
-    "init:meson": "meson setup build .",
-    "init:meson:wipe": "yarn init:meson --wipe",
-    "build": "yarn build:gjsify && yarn build:types",
-    "build:gjsify": "gjsify build --library 'src/ts/**/*.{ts,js}'",
-    "build:meson": "yarn init:meson && meson compile -C build",
-    "build:types": "tsc -b --force",
-    "build:prebuilds": "yarn build:meson && mkdir -p prebuilds/linux-x86_64 && cp build/libgjsifywebrtc.so build/GjsifyWebrtc-0.1.typelib prebuilds/linux-x86_64/"
-  },
-  "keywords": [
-    "gjs",
-    "webrtc",
-    "gstreamer",
-    "webrtcbin",
-    "vala",
-    "native"
-  ],
-  "dependencies": {
-    "@girs/gjs": "4.0.0-rc.14",
-    "@girs/gjsifywebrtc-0.1": "0.1.0-4.0.0-rc.5",
-    "@girs/glib-2.0": "2.88.0-4.0.0-rc.14",
-    "@girs/gobject-2.0": "2.88.0-4.0.0-rc.14",
-    "@girs/gst-1.0": "1.28.1-4.0.0-rc.14",
-    "@girs/gstwebrtc-1.0": "1.0.0-4.0.0-rc.14"
-  },
-  "devDependencies": {
-    "@gjsify/cli": "^0.3.21",
-    "@types/node": "^25.6.2",
-    "typescript": "^6.0.3"
-  }
-}
+}

package/src/vala/data-channel-bridge.vala

@@ -0,0 +1,114 @@
+/*
+ * DataChannelBridge — GstWebRTCDataChannel signals → main-thread signals.
+ *
+ * Same rationale as WebrtcbinBridge: GStreamer data-channel signals
+ * (on-open / on-close / on-error / on-message-string /
+ * on-message-data / on-buffered-amount-low) fire on the streaming
+ * thread, GJS blocks cross-thread JS callbacks, so we mirror them
+ * through a GLib.Idle.add() hop.
+ *
+ * Usage from JS:
+ *   const bridge = new GjsifyWebrtc.DataChannelBridge(gstDataChannel);
+ *   bridge.connect('message-string', (_b, str) => { ... });
+ *   bridge.connect('message-data', (_b, bytes) => { ... });
+ */
+namespace GjsifyWebrtc {
+
+    public class DataChannelBridge : GLib.Object {
+
+        public Gst.WebRTCDataChannel channel { get; construct; }
+
+        /** on-open */
+        public signal void opened();
+        /** on-close */
+        public signal void closed();
+        /** on-error(GLib.Error) — delivered as the message string */
+        public signal void error_occurred(string message);
+        /** on-message-string(string) */
+        public signal void message_string(string data);
+        /** on-message-data(GLib.Bytes) */
+        public signal void message_data(GLib.Bytes data);
+        /** on-buffered-amount-low */
+        public signal void buffered_amount_low();
+        /** notify::ready-state — fires on state transitions (connecting/open/closing/closed) */
+        public signal void ready_state_changed();
+
+        private ulong[] _handler_ids = {};
+
+        public DataChannelBridge(Gst.WebRTCDataChannel channel) {
+            Object(channel: channel);
+        }
+
+        construct {
+            _handler_ids += channel.on_open.connect(this.handle_open);
+            _handler_ids += channel.on_close.connect(this.handle_close);
+            _handler_ids += channel.on_error.connect(this.handle_error);
+            _handler_ids += channel.on_message_string.connect(this.handle_message_string);
+            _handler_ids += channel.on_message_data.connect(this.handle_message_data);
+            _handler_ids += channel.on_buffered_amount_low.connect(this.handle_buffered_amount_low);
+            _handler_ids += channel.notify["ready-state"].connect(this.handle_ready_state_changed);
+        }
+
+        private void handle_open() {
+            GLib.Idle.add(() => {
+                this.opened();
+                return false;
+            });
+        }
+
+        private void handle_close() {
+            GLib.Idle.add(() => {
+                this.closed();
+                return false;
+            });
+        }
+
+        private void handle_error(GLib.Error err) {
+            string msg = (err != null && err.message != null) ? err.message : "RTCDataChannel error";
+            GLib.Idle.add(() => {
+                this.error_occurred(msg);
+                return false;
+            });
+        }
+
+        private void handle_message_string(string? str) {
+            string payload = str ?? "";
+            GLib.Idle.add(() => {
+                this.message_string(payload);
+                return false;
+            });
+        }
+
+        private void handle_message_data(GLib.Bytes? data) {
+            GLib.Bytes payload = data ?? new GLib.Bytes(new uint8[0]);
+            GLib.Idle.add(() => {
+                this.message_data(payload);
+                return false;
+            });
+        }
+
+        private void handle_buffered_amount_low() {
+            GLib.Idle.add(() => {
+                this.buffered_amount_low();
+                return false;
+            });
+        }
+
+        private void handle_ready_state_changed(GLib.ParamSpec pspec) {
+            GLib.Idle.add(() => {
+                this.ready_state_changed();
+                return false;
+            });
+        }
+
+        /** Disconnect all handlers from the wrapped channel. */
+        public void dispose_bridge() {
+            foreach (ulong id in _handler_ids) {
+                if (GLib.SignalHandler.is_connected(channel, id)) {
+                    GLib.SignalHandler.disconnect(channel, id);
+                }
+            }
+            _handler_ids = {};
+        }
+    }
+}

package/src/vala/promise-bridge.vala

@@ -0,0 +1,73 @@
+/*
+ * PromiseBridge — GstPromise → main-thread signal.
+ *
+ * Gst.Promise.new_with_change_func() invokes its callback on the
+ * GStreamer streaming thread. GJS blocks cross-thread JS callbacks to
+ * prevent SpiderMonkey VM corruption, so the bridge catches the reply
+ * on the C side, hops to the GLib main context via GLib.Idle.add(),
+ * and only then emits the `replied` / `rejected` signals — which JS
+ * can safely handle.
+ *
+ * Usage from JS:
+ *   const pb = new GjsifyWebrtc.PromiseBridge();
+ *   pb.connect('replied', (_self, reply) => resolve(reply));
+ *   pb.connect('rejected', (_self, msg) => reject(new Error(msg)));
+ *   webrtcbin.emit('create-offer', opts, pb.promise);
+ */
+namespace GjsifyWebrtc {
+
+    public class PromiseBridge : GLib.Object {
+
+        /** Emitted on the main thread when the GstPromise replied successfully. */
+        public signal void replied(Gst.Structure? reply);
+
+        /** Emitted on the main thread when the GstPromise failed or expired. */
+        public signal void rejected(string message);
+
+        private Gst.Promise _promise;
+
+        /** Consumer passes this to webrtcbin.emit('create-offer', opts, promise). */
+        public Gst.Promise promise { get { return _promise; } }
+
+        construct {
+            // Keep a strong ref to `this` across the async hop.
+            var self = this;
+            _promise = new Gst.Promise.with_change_func((p) => {
+                var result = p.wait();
+
+                // Copy the reply off the promise so we can reach it from
+                // the main-thread handler without holding the streaming-thread's
+                // ownership model.
+                Gst.Structure? reply_copy = null;
+                string? error_message = null;
+
+                if (result == Gst.PromiseResult.REPLIED) {
+                    unowned Gst.Structure? reply = p.get_reply();
+                    if (reply != null) {
+                        reply_copy = reply.copy();
+                        if (reply_copy.has_field("error")) {
+                            unowned GLib.Value? err_val = reply_copy.get_value("error");
+                            if (err_val != null) {
+                                GLib.Error err = (GLib.Error) err_val.get_boxed();
+                                error_message = err != null ? err.message : "GstPromise error";
+                            }
+                        }
+                    }
+                } else if (result == Gst.PromiseResult.EXPIRED) {
+                    error_message = "GstPromise expired";
+                } else if (result == Gst.PromiseResult.INTERRUPTED) {
+                    error_message = "GstPromise interrupted";
+                }
+
+                GLib.Idle.add(() => {
+                    if (error_message != null) {
+                        self.rejected(error_message);
+                    } else {
+                        self.replied(reply_copy);
+                    }
+                    return false;
+                });
+            });
+        }
+    }
+}

package/src/vala/receiver-bridge.vala

@@ -0,0 +1,162 @@
+/*
+ * ReceiverBridge — per-receiver incoming media pipeline.
+ *
+ * Manages the GStreamer elements for one RTCRtpReceiver's incoming
+ * media path: muted source → tee (initial), then on connect_to_pad()
+ * wires webrtcbin output → decodebin → tee (replacing the muted source).
+ *
+ * All GStreamer signal handling (especially decodebin's pad-added which
+ * fires on the streaming thread) happens in C/Vala. JS only receives
+ * the main-thread-safe `media_flowing` signal when decoded media is
+ * actively flowing through the tee.
+ *
+ * Usage from JS:
+ *   const bridge = new GjsifyWebrtc.ReceiverBridge({ pipeline, kind: 'audio' });
+ *   bridge.connect_to_pad(webrtcbinSrcPad);
+ *   bridge.connect('media-flowing', () => { track._setMuted(false); });
+ */
+namespace GjsifyWebrtc {
+
+    public class ReceiverBridge : GLib.Object {
+
+        public Gst.Pipeline pipeline { get; construct; }
+        public string kind { get; construct; }
+
+        /** Emitted on main thread when decoded media replaces the muted source. */
+        public signal void media_flowing();
+
+        private Gst.Element? _muted = null;
+        private Gst.Element _tee;
+        private Gst.Element? _decodebin = null;
+        private bool _switched = false;
+        private static int _counter = 0;
+
+        public ReceiverBridge(Gst.Pipeline pipeline, string kind) {
+            Object(pipeline: pipeline, kind: kind);
+        }
+
+        construct {
+            int id = _counter++;
+
+            // Create muted source (silence for audio, black for video)
+            if (kind == "audio") {
+                _muted = Gst.ElementFactory.make("audiotestsrc", "recv-muted-audio-%d".printf(id));
+                _muted.set_property("wave", 4);       // silence
+                _muted.set_property("is-live", true);
+            } else {
+                _muted = Gst.ElementFactory.make("videotestsrc", "recv-muted-video-%d".printf(id));
+                _muted.set_property("pattern", 2);     // black
+                _muted.set_property("is-live", true);
+            }
+
+            // Create tee for fan-out to track consumers
+            _tee = Gst.ElementFactory.make("tee", "recv-tee-%d".printf(id));
+            _tee.set_property("allow-not-linked", true);
+
+            // Add to pipeline and link: muted → tee
+            pipeline.add(_muted);
+            pipeline.add(_tee);
+
+            var muted_src = _muted.get_static_pad("src");
+            var tee_sink = _tee.get_static_pad("sink");
+            muted_src.link(tee_sink);
+
+            _muted.sync_state_with_parent();
+            _tee.sync_state_with_parent();
+        }
+
+        /**
+         * Wire the webrtcbin output pad through decodebin into the tee.
+         * Must be called from the main thread (JS calls this from
+         * _handlePadAdded via the WebrtcbinBridge signal).
+         */
+        public void connect_to_pad(Gst.Pad src_pad) {
+            if (_decodebin != null) return; // already connected
+
+            int id = _counter++;
+            _decodebin = Gst.ElementFactory.make("decodebin", "recv-decodebin-%d".printf(id));
+            pipeline.add(_decodebin);
+
+            // Link webrtcbin src pad → decodebin sink
+            var dec_sink = _decodebin.get_static_pad("sink");
+            src_pad.link(dec_sink);
+
+            // Connect decodebin's pad-added signal — this fires on the
+            // streaming thread, which is why this entire class exists
+            _decodebin.pad_added.connect(this.on_decode_pad_added);
+
+            _decodebin.sync_state_with_parent();
+        }
+
+        /**
+         * Called on the STREAMING THREAD when decodebin has decoded the
+         * incoming RTP stream and created a src pad with raw media.
+         */
+        private void on_decode_pad_added(Gst.Element element, Gst.Pad new_pad) {
+            // Only process src pads (decoded output)
+            if (new_pad.direction != Gst.PadDirection.SRC) return;
+
+            // Guard: only switch once (decodebin may fire multiple pad-added)
+            if (_switched) return;
+            _switched = true;
+
+            // Switch tee input from muted source to decoded pad
+            var tee_sink = _tee.get_static_pad("sink");
+            var old_peer = tee_sink.get_peer();
+
+            if (old_peer != null) {
+                // Add DROP probe on old pad to prevent errors during unlink
+                old_peer.add_probe(
+                    Gst.PadProbeType.BLOCK | Gst.PadProbeType.DATA_DOWNSTREAM,
+                    () => { return Gst.PadProbeReturn.DROP; }
+                );
+                old_peer.unlink(tee_sink);
+            }
+
+            // Link decoded pad to tee
+            new_pad.link(tee_sink);
+
+            // Stop and remove muted element
+            if (_muted != null) {
+                _muted.set_state(Gst.State.NULL);
+                pipeline.remove(_muted);
+                _muted = null;
+            }
+
+            // Disconnect from decodebin pad-added (no longer needed)
+            _decodebin.pad_added.disconnect(this.on_decode_pad_added);
+
+            // Notify JS on main thread
+            GLib.Idle.add(() => {
+                this.media_flowing();
+                return false;
+            });
+        }
+
+        /** Request a src pad from the tee for a track consumer. */
+        public Gst.Pad request_src_pad() {
+            return _tee.request_pad_simple("src_%u");
+        }
+
+        /** Release a previously requested src pad. */
+        public void release_src_pad(Gst.Pad pad) {
+            _tee.release_request_pad(pad);
+        }
+
+        /** Clean up all GStreamer elements. Call from RTCRtpReceiver._dispose(). */
+        public void dispose_bridge() {
+            if (_decodebin != null) {
+                _decodebin.set_state(Gst.State.NULL);
+                pipeline.remove(_decodebin);
+                _decodebin = null;
+            }
+            if (_muted != null) {
+                _muted.set_state(Gst.State.NULL);
+                pipeline.remove(_muted);
+                _muted = null;
+            }
+            _tee.set_state(Gst.State.NULL);
+            pipeline.remove(_tee);
+        }
+    }
+}

package/src/vala/webrtcbin-bridge.vala

@@ -0,0 +1,178 @@
+/*
+ * WebrtcbinBridge — webrtcbin signals → main-thread signals.
+ *
+ * webrtcbin emits on-negotiation-needed / on-ice-candidate /
+ * on-data-channel plus notify::*-state from GStreamer's internal
+ * streaming thread. GJS blocks JS callbacks on non-main threads, so
+ * the bridge connects on the C (Vala) side, captures arguments, hops
+ * to the GLib main context via GLib.Idle.add(), and only then emits
+ * its own signals which JS can safely consume.
+ *
+ * Usage from JS:
+ *   const bridge = new GjsifyWebrtc.WebrtcbinBridge(webrtcbin);
+ *   bridge.connect('icecandidate', (_b, mline, cand) => { ... });
+ *   bridge.connect('datachannel', (_b, channel) => { ... });
+ */
+namespace GjsifyWebrtc {
+
+    public class WebrtcbinBridge : GLib.Object {
+
+        public Gst.Element bin { get; construct; }
+
+        /** on-negotiation-needed */
+        public signal void negotiation_needed();
+        /** on-ice-candidate(uint sdp_mline_index, string candidate) */
+        public signal void icecandidate(uint sdp_mline_index, string candidate);
+        /**
+         * on-data-channel — fired with a pre-wrapped DataChannelBridge so
+         * the wrapper is installed (and thus its signal handlers are active)
+         * *before* any on-message-* callbacks can fire on the streaming
+         * thread. Without this eager wrap, the first few messages from the
+         * remote peer would race the JS-side setup and get dropped.
+         */
+        public signal void datachannel(DataChannelBridge channel_bridge);
+        /** on-new-transceiver(GstWebRTCRTPTransceiver) */
+        public signal void new_transceiver(Gst.WebRTCRTPTransceiver transceiver);
+        /** pad-added(Gst.Pad) — incoming RTP src pads from webrtcbin */
+        public signal void pad_added(Gst.Pad pad);
+        /** notify::connection-state */
+        public signal void connection_state_changed();
+        /** notify::signaling-state */
+        public signal void signaling_state_changed();
+        /** notify::ice-connection-state */
+        public signal void ice_connection_state_changed();
+        /** notify::ice-gathering-state */
+        public signal void ice_gathering_state_changed();
+
+        private ulong[] _handler_ids = {};
+
+        public WebrtcbinBridge(Gst.Element bin) {
+            Object(bin: bin);
+        }
+
+        construct {
+            _handler_ids += GLib.Signal.connect(bin, "on-negotiation-needed",
+                (GLib.Callback) on_negotiation_needed_cb, this);
+            _handler_ids += GLib.Signal.connect(bin, "on-ice-candidate",
+                (GLib.Callback) on_ice_candidate_cb, this);
+            _handler_ids += GLib.Signal.connect(bin, "on-data-channel",
+                (GLib.Callback) on_data_channel_cb, this);
+            _handler_ids += GLib.Signal.connect(bin, "on-new-transceiver",
+                (GLib.Callback) on_new_transceiver_cb, this);
+            _handler_ids += GLib.Signal.connect(bin, "pad-added",
+                (GLib.Callback) on_pad_added_cb, this);
+            _handler_ids += bin.notify["connection-state"].connect(this.handle_connection_state);
+            _handler_ids += bin.notify["signaling-state"].connect(this.handle_signaling_state);
+            _handler_ids += bin.notify["ice-connection-state"].connect(this.handle_ice_connection_state);
+            _handler_ids += bin.notify["ice-gathering-state"].connect(this.handle_ice_gathering_state);
+        }
+
+        // ---- C-ABI callbacks for dynamic (non-VAPI) webrtcbin signals ----
+        // Signatures must match the GObject signal marshallers exactly
+        // (element as first arg, signal args next, user_data last).
+
+        [CCode (instance_pos = -1)]
+        private static void on_negotiation_needed_cb(Gst.Element element,
+                                                     WebrtcbinBridge self) {
+            GLib.Idle.add(() => {
+                self.negotiation_needed();
+                return false;
+            });
+        }
+
+        [CCode (instance_pos = -1)]
+        private static void on_ice_candidate_cb(Gst.Element element,
+                                                uint mline_index,
+                                                string candidate,
+                                                WebrtcbinBridge self) {
+            uint idx = mline_index;
+            string cand = candidate;
+            GLib.Idle.add(() => {
+                self.icecandidate(idx, cand);
+                return false;
+            });
+        }
+
+        [CCode (instance_pos = -1)]
+        private static void on_data_channel_cb(Gst.Element element,
+                                               Gst.WebRTCDataChannel channel,
+                                               WebrtcbinBridge self) {
+            // Eagerly wrap the incoming channel in a DataChannelBridge *on
+            // the streaming thread* so its signal handlers are installed
+            // before any on-message-* callbacks can fire. This avoids a
+            // race where early messages would arrive before the JS-side
+            // RTCDataChannel (and thus the DataChannelBridge) is created.
+            var bridge = new DataChannelBridge(channel);
+            GLib.Idle.add(() => {
+                self.datachannel(bridge);
+                return false;
+            });
+        }
+
+        [CCode (instance_pos = -1)]
+        private static void on_new_transceiver_cb(Gst.Element element,
+                                                   Gst.WebRTCRTPTransceiver trans,
+                                                   WebrtcbinBridge self) {
+            var t = trans;
+            GLib.Idle.add(() => {
+                self.new_transceiver(t);
+                return false;
+            });
+        }
+
+        [CCode (instance_pos = -1)]
+        private static void on_pad_added_cb(Gst.Element element,
+                                             Gst.Pad pad,
+                                             WebrtcbinBridge self) {
+            var p = pad;
+            GLib.Idle.add(() => {
+                self.pad_added(p);
+                return false;
+            });
+        }
+
+        // ---- notify:: handlers for state-change properties ----
+
+        private void handle_connection_state(GLib.ParamSpec pspec) {
+            GLib.Idle.add(() => {
+                this.connection_state_changed();
+                return false;
+            });
+        }
+
+        private void handle_signaling_state(GLib.ParamSpec pspec) {
+            GLib.Idle.add(() => {
+                this.signaling_state_changed();
+                return false;
+            });
+        }
+
+        private void handle_ice_connection_state(GLib.ParamSpec pspec) {
+            GLib.Idle.add(() => {
+                this.ice_connection_state_changed();
+                return false;
+            });
+        }
+
+        private void handle_ice_gathering_state(GLib.ParamSpec pspec) {
+            GLib.Idle.add(() => {
+                this.ice_gathering_state_changed();
+                return false;
+            });
+        }
+
+        /**
+         * Disconnect all handlers from the wrapped webrtcbin. Call this
+         * from RTCPeerConnection.close() to break the reference cycle
+         * before the pipeline is torn down.
+         */
+        public void dispose_bridge() {
+            foreach (ulong id in _handler_ids) {
+                if (GLib.SignalHandler.is_connected(bin, id)) {
+                    GLib.SignalHandler.disconnect(bin, id);
+                }
+            }
+            _handler_ids = {};
+        }
+    }
+}