@gjsify/webrtc 0.1.15

package/src/rtc-sctp-transport.ts

@@ -0,0 +1,48 @@
+// W3C RTCSctpTransport for GJS.
+//
+// Created when a data channel is negotiated. Wraps the SCTP association
+// over the DTLS transport. State transitions from connecting → connected
+// when the first data channel opens.
+//
+// Reference: W3C WebRTC spec § 6.1
+// Reference: refs/wpt/webrtc/RTCSctpTransport-constructor.html
+
+import '@gjsify/dom-events/register/event-target';
+
+import { RTCDtlsTransport } from './rtc-dtls-transport.js';
+
+export type RTCSctpTransportState = 'connecting' | 'connected' | 'closed';
+
+type EventHandler = ((ev: Event) => void) | null;
+
+export class RTCSctpTransport extends EventTarget {
+    readonly transport: RTCDtlsTransport;
+    private _state: RTCSctpTransportState = 'connecting';
+    private _maxMessageSize: number = 262144; // 256 KB default per SCTP
+    private _maxChannels: number | null = 65535;
+
+    private _onstatechange: EventHandler = null;
+
+    constructor(dtlsTransport: RTCDtlsTransport) {
+        super();
+        this.transport = dtlsTransport;
+    }
+
+    get state(): RTCSctpTransportState { return this._state; }
+    get maxMessageSize(): number { return this._maxMessageSize; }
+    get maxChannels(): number | null { return this._maxChannels; }
+
+    get onstatechange(): EventHandler { return this._onstatechange; }
+    set onstatechange(v: EventHandler) { this._onstatechange = v; }
+
+    // ---- Internal setters (called by RTCPeerConnection) ---------------------
+
+    /** @internal */
+    _setState(state: RTCSctpTransportState): void {
+        if (this._state === state) return;
+        this._state = state;
+        const ev = new Event('statechange');
+        this._onstatechange?.call(this, ev);
+        this.dispatchEvent(ev);
+    }
+}

package/src/rtc-session-description.ts

@@ -0,0 +1,64 @@
+// RTCSessionDescription — W3C WebRTC session description (offer/answer/rollback).
+//
+// Reference: refs/node-gst-webrtc/src/webrtc/RTCSessionDescription.ts (ISC)
+// Adapted for GJS using GstSdp + GstWebRTC.
+
+import GstSdp from 'gi://GstSdp?version=1.0';
+import GstWebRTC from 'gi://GstWebRTC?version=1.0';
+
+export type RTCSdpType = 'offer' | 'pranswer' | 'answer' | 'rollback';
+
+export interface RTCSessionDescriptionInit {
+    type?: RTCSdpType;
+    sdp?: string;
+}
+
+function sdpTypeToGst(type: RTCSdpType): GstWebRTC.WebRTCSDPType {
+    switch (type) {
+        case 'offer':    return GstWebRTC.WebRTCSDPType.OFFER;
+        case 'pranswer': return GstWebRTC.WebRTCSDPType.PRANSWER;
+        case 'answer':   return GstWebRTC.WebRTCSDPType.ANSWER;
+        case 'rollback': return GstWebRTC.WebRTCSDPType.ROLLBACK;
+    }
+}
+
+function sdpTypeFromGst(type: GstWebRTC.WebRTCSDPType): RTCSdpType {
+    switch (type) {
+        case GstWebRTC.WebRTCSDPType.OFFER:    return 'offer';
+        case GstWebRTC.WebRTCSDPType.PRANSWER: return 'pranswer';
+        case GstWebRTC.WebRTCSDPType.ANSWER:   return 'answer';
+        case GstWebRTC.WebRTCSDPType.ROLLBACK: return 'rollback';
+        default: return 'offer';
+    }
+}
+
+export class RTCSessionDescription {
+    readonly type: RTCSdpType;
+    readonly sdp: string;
+
+    constructor(init?: RTCSessionDescriptionInit) {
+        this.type = (init?.type ?? 'offer') as RTCSdpType;
+        this.sdp = init?.sdp ?? '';
+    }
+
+    toJSON(): { type: RTCSdpType; sdp: string } {
+        return { type: this.type, sdp: this.sdp };
+    }
+
+    /** Build a GstWebRTC.WebRTCSessionDescription for use with webrtcbin signals. */
+    toGstDesc(): GstWebRTC.WebRTCSessionDescription {
+        const [ret, sdp] = GstSdp.SDPMessage.new_from_text(this.sdp);
+        if (ret !== GstSdp.SDPResult.OK) {
+            throw new Error(`Failed to parse SDP text (GstSDPResult=${ret})`);
+        }
+        return GstWebRTC.WebRTCSessionDescription.new(sdpTypeToGst(this.type), sdp);
+    }
+
+    static fromGstDesc(desc: GstWebRTC.WebRTCSessionDescription): RTCSessionDescription {
+        const sdpText = desc.sdp?.as_text?.() ?? '';
+        return new RTCSessionDescription({
+            type: sdpTypeFromGst(desc.type),
+            sdp: sdpText,
+        });
+    }
+}

package/src/rtc-stats-report.ts

@@ -0,0 +1,39 @@
+// W3C RTCStatsReport — read-only Map<string, object> of WebRTC statistics.
+//
+// Reference: W3C WebRTC spec § 8.5
+// The report is a frozen snapshot; .set()/.delete()/.clear() are no-ops.
+
+export interface RTCStats {
+    timestamp: number;
+    type: string;
+    id: string;
+    [key: string]: unknown;
+}
+
+/**
+ * Read-only Map-like collection of stats entries keyed by id.
+ * W3C requires iteration support but not mutation.
+ */
+export class RTCStatsReport {
+    private readonly _map: Map<string, RTCStats>;
+
+    constructor(entries?: Iterable<[string, RTCStats]>) {
+        this._map = new Map(entries);
+    }
+
+    get size(): number { return this._map.size; }
+
+    get(key: string): RTCStats | undefined { return this._map.get(key); }
+    has(key: string): boolean { return this._map.has(key); }
+
+    forEach(callbackfn: (value: RTCStats, key: string, map: RTCStatsReport) => void, thisArg?: unknown): void {
+        this._map.forEach((value, key) => {
+            callbackfn.call(thisArg, value, key, this);
+        });
+    }
+
+    entries(): IterableIterator<[string, RTCStats]> { return this._map.entries(); }
+    keys(): IterableIterator<string> { return this._map.keys(); }
+    values(): IterableIterator<RTCStats> { return this._map.values(); }
+    [Symbol.iterator](): IterableIterator<[string, RTCStats]> { return this._map.entries(); }
+}

package/src/rtc-track-event.ts

@@ -0,0 +1,45 @@
+// W3C RTCTrackEvent for GJS.
+//
+// Ported from refs/wpt/webrtc/RTCTrackEvent-constructor.html (W3C, BSD-3-Clause)
+// Reference: W3C WebRTC spec § 5.7
+
+import '@gjsify/dom-events/register/event-target';
+
+import type { RTCRtpReceiver } from './rtc-rtp-receiver.js';
+import type { RTCRtpTransceiver } from './rtc-rtp-transceiver.js';
+import type { MediaStreamTrack } from './media-stream-track.js';
+import type { MediaStream } from './media-stream.js';
+
+export interface RTCTrackEventInit extends EventInit {
+    receiver: RTCRtpReceiver;
+    track: MediaStreamTrack;
+    streams?: MediaStream[];
+    transceiver: RTCRtpTransceiver;
+}
+
+export class RTCTrackEvent extends Event {
+    readonly receiver: RTCRtpReceiver;
+    readonly track: MediaStreamTrack;
+    readonly streams: ReadonlyArray<MediaStream>;
+    readonly transceiver: RTCRtpTransceiver;
+
+    constructor(type: string, init: RTCTrackEventInit) {
+        super(type, init);
+        if (!init || typeof init !== 'object') {
+            throw new TypeError('RTCTrackEventInit is required');
+        }
+        if (!('receiver' in init)) {
+            throw new TypeError("Failed to construct 'RTCTrackEvent': required member receiver is not provided.");
+        }
+        if (!('track' in init)) {
+            throw new TypeError("Failed to construct 'RTCTrackEvent': required member track is not provided.");
+        }
+        if (!('transceiver' in init)) {
+            throw new TypeError("Failed to construct 'RTCTrackEvent': required member transceiver is not provided.");
+        }
+        this.receiver = init.receiver;
+        this.track = init.track;
+        this.streams = Object.freeze(init.streams ? [...init.streams] : []);
+        this.transceiver = init.transceiver;
+    }
+}

package/src/rtp-capabilities.ts

@@ -0,0 +1,48 @@
+// Shared RTP codec capabilities for RTCRtpSender and RTCRtpReceiver.
+//
+// Both classes expose identical getCapabilities(kind) static methods per
+// W3C WebRTC spec §§ 5.2 and 5.3. This module deduplicates the data.
+
+import type { RTCRtpCapabilities } from './rtc-rtp-sender.js';
+
+const AUDIO_CAPABILITIES: RTCRtpCapabilities = {
+    codecs: [
+        { mimeType: 'audio/opus', clockRate: 48000, channels: 2, sdpFmtpLine: 'minptime=10;useinbandfec=1' },
+        { mimeType: 'audio/G722', clockRate: 8000, channels: 1 },
+        { mimeType: 'audio/PCMU', clockRate: 8000, channels: 1 },
+        { mimeType: 'audio/PCMA', clockRate: 8000, channels: 1 },
+        { mimeType: 'audio/telephone-event', clockRate: 8000, channels: 1 },
+        { mimeType: 'audio/red', clockRate: 48000, channels: 2 },
+    ],
+    headerExtensions: [
+        { uri: 'urn:ietf:params:rtp-hdrext:ssrc-audio-level' },
+        { uri: 'http://www.webrtc.org/experiments/rtp-hdrext/abs-send-time' },
+        { uri: 'urn:ietf:params:rtp-hdrext:sdes:mid' },
+    ],
+};
+
+const VIDEO_CAPABILITIES: RTCRtpCapabilities = {
+    codecs: [
+        { mimeType: 'video/VP8', clockRate: 90000 },
+        { mimeType: 'video/rtx', clockRate: 90000 },
+        { mimeType: 'video/H264', clockRate: 90000, sdpFmtpLine: 'level-asymmetry-allowed=1;packetization-mode=1;profile-level-id=42001f' },
+        { mimeType: 'video/VP9', clockRate: 90000 },
+        { mimeType: 'video/red', clockRate: 90000 },
+        { mimeType: 'video/ulpfec', clockRate: 90000 },
+    ],
+    headerExtensions: [
+        { uri: 'urn:ietf:params:rtp-hdrext:toffset' },
+        { uri: 'http://www.webrtc.org/experiments/rtp-hdrext/abs-send-time' },
+        { uri: 'urn:3gpp:video-orientation' },
+        { uri: 'urn:ietf:params:rtp-hdrext:sdes:mid' },
+        { uri: 'urn:ietf:params:rtp-hdrext:sdes:rtp-stream-id' },
+        { uri: 'urn:ietf:params:rtp-hdrext:sdes:repaired-rtp-stream-id' },
+    ],
+};
+
+/** Shared implementation for RTCRtpSender.getCapabilities / RTCRtpReceiver.getCapabilities. */
+export function getRtpCapabilities(kind: string): RTCRtpCapabilities | null {
+    if (kind === 'audio') return AUDIO_CAPABILITIES;
+    if (kind === 'video') return VIDEO_CAPABILITIES;
+    return null;
+}

package/src/tee-multiplexer.ts

@@ -0,0 +1,75 @@
+// GStreamer tee element manager for multi-PC fan-out.
+//
+// When a single MediaStreamTrack (backed by a GStreamer source) needs to
+// feed multiple RTCPeerConnections, a tee element is inserted after the
+// source. Each PC gets its own branch (encoder chain → webrtcbin sink).
+//
+// Reference: refs/node-gst-webrtc/src/media/TeeMultiplexer.ts (ISC)
+// Reference: packages/web/webrtc-native/src/vala/receiver-bridge.vala (tee pattern)
+
+import { Gst } from './gst-init.js';
+
+/**
+ * Manages a GStreamer `tee` element that fans out one source to multiple
+ * consumer branches. Each branch gets its own src pad from the tee.
+ */
+export class TeeMultiplexer {
+    private _tee: any; // Gst.Element
+    private _pipeline: any; // Gst.Pipeline
+    private _branchCount = 0;
+
+    /**
+     * Create a tee in the given pipeline and link it to the source's output.
+     * The source must already be in the pipeline.
+     */
+    constructor(pipeline: any, source: any) {
+        this._pipeline = pipeline;
+        this._tee = Gst.ElementFactory.make('tee', null)!;
+        (this._tee as any).allow_not_linked = true;
+
+        pipeline.add(this._tee);
+        this._tee.sync_state_with_parent();
+
+        // Link source → tee
+        source.link(this._tee);
+    }
+
+    /** Request a new src pad from the tee for a consumer branch. */
+    requestSrcPad(): any /* Gst.Pad */ {
+        const padName = 'src_%u';
+        const srcPad = this._tee.request_pad_simple
+            ? this._tee.request_pad_simple(padName)
+            : this._tee.get_request_pad(padName);
+        if (srcPad) this._branchCount++;
+        return srcPad;
+    }
+
+    /**
+     * Release a branch's src pad from the tee.
+     * Adds a DROP probe before unlinking to prevent errors.
+     */
+    releaseSrcPad(srcPad: any): void {
+        if (!srcPad) return;
+        try {
+            // Block data on the pad before unlinking
+            srcPad.add_probe(
+                Gst.PadProbeType.BLOCK_DOWNSTREAM,
+                () => Gst.PadProbeReturn.DROP,
+            );
+        } catch { /* ignore if probe fails */ }
+        try {
+            const peer = srcPad.get_peer();
+            if (peer) srcPad.unlink(peer);
+        } catch { /* ignore */ }
+        try {
+            this._tee.release_request_pad(srcPad);
+        } catch { /* ignore */ }
+        this._branchCount--;
+    }
+
+    /** Number of active branches. */
+    get branchCount(): number { return this._branchCount; }
+
+    /** The tee element (for pipeline queries). */
+    get element(): any { return this._tee; }
+}

package/src/test.mts

@@ -0,0 +1,11 @@
+import webrtcSpec from './webrtc.spec.js';
+import wptSpec from './wpt.spec.js';
+import wptMediaSpec from './wpt-media.spec.js';
+import registerSpec from './register.spec.js';
+
+const results = {
+    webrtc: await webrtcSpec(),
+    wpt: await wptSpec(),
+    wptMedia: await wptMediaSpec(),
+    register: await registerSpec(),
+};