@gjsify/webrtc 0.1.15

package/src/rtc-rtp-receiver.ts

@@ -0,0 +1,122 @@
+// W3C RTCRtpReceiver for GJS.
+//
+// Wraps GstWebRTC.WebRTCRTPReceiver. Phase 2.5: incoming media pipeline
+// is managed by ReceiverBridge (Vala) which handles decodebin's
+// streaming-thread signals natively and emits media-flowing on the
+// main thread when decoded media replaces the muted source.
+//
+// Reference: refs/node-gst-webrtc/src/webrtc/RTCRtpReceiver.ts (ISC)
+// Reference: W3C WebRTC spec § 5.3
+
+import type GstWebRTC from 'gi://GstWebRTC?version=1.0';
+import type Gst from 'gi://Gst?version=1.0';
+
+import {
+    ReceiverBridge,
+    type ReceiverBridge as ReceiverBridgeType,
+} from '@gjsify/webrtc-native';
+
+import { MediaStreamTrack } from './media-stream-track.js';
+import { getRtpCapabilities } from './rtp-capabilities.js';
+import type { RTCStatsReport } from './rtc-stats-report.js';
+import type { RTCDtlsTransport } from './rtc-dtls-transport.js';
+import type { RTCRtpCapabilities, RTCRtpCodecParameters, RTCRtpHeaderExtensionParameters, RTCRtcpParameters } from './rtc-rtp-sender.js';
+
+export interface RTCRtpReceiveParameters {
+    codecs: RTCRtpCodecParameters[];
+    headerExtensions: RTCRtpHeaderExtensionParameters[];
+    rtcp: RTCRtcpParameters;
+}
+
+export interface RTCRtpContributingSource {
+    timestamp: number;
+    source: number;
+    audioLevel?: number;
+    rtpTimestamp: number;
+}
+
+export interface RTCRtpSynchronizationSource extends RTCRtpContributingSource {
+    voiceActivityFlag?: boolean;
+}
+
+const MAX_JITTER_BUFFER_TARGET = 4000;
+
+export class RTCRtpReceiver {
+    private _gstReceiver: GstWebRTC.WebRTCRTPReceiver | null;
+    private _track: MediaStreamTrack;
+    private _jitterBufferTarget: number | null = null;
+    private _pipeline: any = null;
+    private _receiverBridge: ReceiverBridgeType | null = null;
+    /** @internal — stats callback set by RTCPeerConnection */
+    _getStatsForTrack: ((track: MediaStreamTrack) => Promise<RTCStatsReport>) | null = null;
+
+    constructor(kind: 'audio' | 'video', gstReceiver: GstWebRTC.WebRTCRTPReceiver | null, pipeline?: any) {
+        this._gstReceiver = gstReceiver;
+        this._pipeline = pipeline ?? null;
+        this._track = new MediaStreamTrack({ kind, muted: true });
+    }
+
+    /** @internal — called from RTCPeerConnection._handlePadAdded */
+    _connectToPad(pad: Gst.Pad): void {
+        if (!this._pipeline || this._receiverBridge) return;
+        this._receiverBridge = new (ReceiverBridge as any)({
+            pipeline: this._pipeline,
+            kind: this._track.kind,
+        });
+        this._receiverBridge!.connect_to_pad(pad);
+        this._receiverBridge!.connect('media-flowing', () => {
+            this._track._setMuted(false);
+        });
+    }
+
+    /** @internal — called from RTCPeerConnection.close() */
+    _dispose(): void {
+        try { this._receiverBridge?.dispose_bridge(); } catch { /* ignore */ }
+        this._receiverBridge = null;
+    }
+
+    /** @internal — set by RTCPeerConnection */
+    _transport: RTCDtlsTransport | null = null;
+
+    get track(): MediaStreamTrack { return this._track; }
+    get transport(): RTCDtlsTransport | null { return this._transport; }
+
+    get jitterBufferTarget(): number | null { return this._jitterBufferTarget; }
+    set jitterBufferTarget(v: number | null) {
+        if (v === null) {
+            this._jitterBufferTarget = null;
+            return;
+        }
+        const n = Number(v);
+        if (!Number.isFinite(n) || n < 0) {
+            throw new RangeError(`Failed to set jitterBufferTarget: ${v} is negative or not finite`);
+        }
+        if (n > MAX_JITTER_BUFFER_TARGET) {
+            throw new RangeError(`Failed to set jitterBufferTarget: ${v} exceeds maximum of ${MAX_JITTER_BUFFER_TARGET}`);
+        }
+        this._jitterBufferTarget = n;
+    }
+
+    getParameters(): RTCRtpReceiveParameters {
+        return {
+            codecs: [],
+            headerExtensions: [],
+            rtcp: {},
+        };
+    }
+
+    getContributingSources(): RTCRtpContributingSource[] { return []; }
+    getSynchronizationSources(): RTCRtpSynchronizationSource[] { return []; }
+
+    async getStats(): Promise<RTCStatsReport> {
+        if (this._getStatsForTrack && this._track) {
+            return this._getStatsForTrack(this._track);
+        }
+        const { RTCStatsReport: Report } = await import('./rtc-stats-report.js');
+        return new Report();
+    }
+
+    static getCapabilities(kind: string): RTCRtpCapabilities | null {
+        return getRtpCapabilities(kind);
+    }
+}

package/src/rtc-rtp-sender.ts

@@ -0,0 +1,444 @@
+// W3C RTCRtpSender for GJS.
+//
+// Phase 2: API surface wrapping GstWebRTC.WebRTCRTPSender.
+// Phase 3: outgoing media pipeline — builds explicit encoder chains
+// (source → valve → convert → encode → payloader → webrtcbin sink pad)
+// entirely on the main thread. No Vala bridge needed.
+//
+// Reference: refs/node-gst-webrtc/src/webrtc/RTCRtpSender.ts (ISC)
+// Reference: W3C WebRTC spec § 5.2
+
+import type GstWebRTC from 'gi://GstWebRTC?version=1.0';
+
+import { Gst } from './gst-init.js';
+import { getRtpCapabilities } from './rtp-capabilities.js';
+import { RTCDTMFSender } from './rtc-dtmf-sender.js';
+import { TeeMultiplexer } from './tee-multiplexer.js';
+import type { RTCStatsReport } from './rtc-stats-report.js';
+import type { RTCDtlsTransport } from './rtc-dtls-transport.js';
+import type { MediaStreamTrack } from './media-stream-track.js';
+import type { MediaStream } from './media-stream.js';
+
+// Standard RTP payload types used in WebRTC SDP
+const OPUS_PAYLOAD_TYPE = 111;
+const VP8_PAYLOAD_TYPE = 96;
+
+export type RTCRtpTransceiverDirection = 'sendrecv' | 'sendonly' | 'recvonly' | 'inactive' | 'stopped';
+
+export interface RTCRtpCodecCapability {
+    mimeType: string;
+    clockRate: number;
+    channels?: number;
+    sdpFmtpLine?: string;
+}
+
+export interface RTCRtpHeaderExtensionCapability {
+    uri: string;
+}
+
+export interface RTCRtpCapabilities {
+    codecs: RTCRtpCodecCapability[];
+    headerExtensions: RTCRtpHeaderExtensionCapability[];
+}
+
+export interface RTCRtpEncodingParameters {
+    rid?: string;
+    active?: boolean;
+    maxBitrate?: number;
+    maxFramerate?: number;
+    scaleResolutionDownBy?: number;
+}
+
+export interface RTCRtpCodecParameters {
+    payloadType: number;
+    mimeType: string;
+    clockRate: number;
+    channels?: number;
+    sdpFmtpLine?: string;
+}
+
+export interface RTCRtpHeaderExtensionParameters {
+    uri: string;
+    id: number;
+    encrypted?: boolean;
+}
+
+export interface RTCRtcpParameters {
+    cname?: string;
+    reducedSize?: boolean;
+}
+
+export interface RTCRtpSendParameters {
+    transactionId: string;
+    encodings: RTCRtpEncodingParameters[];
+    codecs: RTCRtpCodecParameters[];
+    headerExtensions: RTCRtpHeaderExtensionParameters[];
+    rtcp: RTCRtcpParameters;
+}
+
+let _txCounter = 0;
+
+export class RTCRtpSender {
+    private _gstSender: GstWebRTC.WebRTCRTPSender | null;
+    private _track: MediaStreamTrack | null = null;
+    private _lastParams: RTCRtpSendParameters | null = null;
+
+    /** @internal GStreamer pipeline references (set by RTCPeerConnection) */
+    private _pipeline: any = null;
+    private _webrtcbin: any = null;
+    private _mlineIndex: number = -1;
+    private _elements: any[] = [];
+    private _valve: any = null;
+    _linked = false;
+    /** @internal — tee src pad if this sender uses a shared source */
+    private _teeSrcPad: any = null;
+    /** @internal — stats callback set by RTCPeerConnection */
+    _getStatsForTrack: ((track: MediaStreamTrack) => Promise<RTCStatsReport>) | null = null;
+    /** @internal — set by RTCPeerConnection */
+    _transport: RTCDtlsTransport | null = null;
+    /** @internal — DTMF sender, created lazily for audio senders */
+    private _dtmf: RTCDTMFSender | null = null;
+    /** @internal — the kind of media this sender handles */
+    _kind: 'audio' | 'video' | null = null;
+    /** @internal — back-reference for DTMF stopped/direction checks */
+    _transceiver: { stopped: boolean; currentDirection: string | null } | null = null;
+    /** @internal — callback to notify RTCPeerConnection when pipeline changes (cross-pipeline fix) */
+    _onPipelineChanged: ((newPipeline: any) => void) | null = null;
+
+    constructor(gstSender: GstWebRTC.WebRTCRTPSender | null, pipeline?: any, webrtcbin?: any) {
+        this._gstSender = gstSender;
+        this._pipeline = pipeline ?? null;
+        this._webrtcbin = webrtcbin ?? null;
+    }
+
+    get track(): MediaStreamTrack | null { return this._track; }
+
+    /** Returns the DTMF sender for audio senders, null for video. */
+    get dtmf(): RTCDTMFSender | null {
+        // Determine kind from track or from what was set by PC
+        const kind = this._track?.kind ?? this._kind;
+        if (kind !== 'audio') return null;
+        if (!this._dtmf) {
+            const dtmf = new RTCDTMFSender();
+            // Wire transceiver state checks for insertDTMF validation
+            dtmf._isStopped = () => this._transceiver?.stopped ?? false;
+            dtmf._getCurrentDirection = () => this._transceiver?.currentDirection ?? null;
+            this._dtmf = dtmf;
+        }
+        return this._dtmf;
+    }
+    get transport(): RTCDtlsTransport | null { return this._transport; }
+
+    /** @internal */
+    _setTrack(track: MediaStreamTrack | null): void {
+        if (track === null && this._linked) {
+            this._teardownPipeline();
+        }
+        this._track = track;
+    }
+
+    /** @internal — called by RTCPeerConnection._createTransceiverWrapper */
+    _setMlineIndex(index: number): void { this._mlineIndex = index; }
+
+    /** @internal — build the outgoing encoder chain and link to webrtcbin */
+    _wirePipeline(track: MediaStreamTrack): void {
+        if (this._linked || !this._pipeline || !this._webrtcbin) return;
+        const source = (track as any)._gstSource;
+        if (!source) return; // No GStreamer backing — nothing to wire
+
+        const trackAny = track as any;
+        let sourceForChain: any; // What to link to the valve (source directly or tee branch)
+
+        if (trackAny._gstTee && trackAny._gstPipeline && trackAny._gstPipeline !== this._pipeline) {
+            // Source has a tee from VideoBridge (preview) in a different pipeline.
+            // Instead of moving the source, we add our encoder chain elements to
+            // the SOURCE's pipeline and request a new branch from its tee.
+            // The webrtcbin must also move to the source pipeline.
+            const sourcePipeline = trackAny._gstPipeline;
+            const tee = trackAny._gstTee;
+
+            // Move webrtcbin to the source pipeline so everything is in one pipeline
+            if (this._webrtcbin.get_parent() === this._pipeline) {
+                this._pipeline.set_state(Gst.State.NULL);
+                this._pipeline.remove(this._webrtcbin);
+            }
+            sourcePipeline.add(this._webrtcbin);
+            this._webrtcbin.sync_state_with_parent();
+
+            // Switch our pipeline reference to the source's pipeline
+            this._pipeline = sourcePipeline;
+            // Notify the owning RTCPeerConnection to update its pipeline reference
+            this._onPipelineChanged?.(sourcePipeline);
+
+            // Request a new branch from the existing tee
+            const teeSrcPad = tee.request_pad_simple
+                ? tee.request_pad_simple('src_%u')
+                : tee.get_request_pad('src_%u');
+            this._teeSrcPad = teeSrcPad;
+            sourceForChain = null; // We'll link via pad below
+        } else if (trackAny._teeMultiplexer) {
+            // Track already has a TeeMultiplexer (shared with another PC) — request a new branch
+            const tee = trackAny._teeMultiplexer as TeeMultiplexer;
+            const teeSrcPad = tee.requestSrcPad();
+            this._teeSrcPad = teeSrcPad;
+            sourceForChain = null; // We'll link via pad below
+        } else if (trackAny._gstPipeline && trackAny._gstPipeline !== this._pipeline) {
+            // Source is in another pipeline (no tee from VideoBridge) — this is the
+            // second PC using this track. Insert a tee between source and the
+            // existing consumer. Move source to this pipeline and create a tee.
+            const oldPipeline = trackAny._gstPipeline;
+
+            // First, unlink source from its current peer (the first sender's valve)
+            const sourceSrcPad = source.get_static_pad('src');
+            const oldPeer = sourceSrcPad?.get_peer?.();
+            if (oldPeer) sourceSrcPad.unlink(oldPeer);
+
+            source.set_state(Gst.State.NULL);
+            oldPipeline.remove(source);
+            this._pipeline.add(source);
+            trackAny._gstPipeline = this._pipeline;
+
+            // Create tee in this pipeline
+            const tee = new TeeMultiplexer(this._pipeline, source);
+            trackAny._teeMultiplexer = tee;
+
+            // Reconnect the old consumer (first sender) via a tee branch
+            if (oldPeer) {
+                const firstBranch = tee.requestSrcPad();
+                if (firstBranch) firstBranch.link(oldPeer);
+            }
+
+            // Request a branch for this sender
+            const teeSrcPad = tee.requestSrcPad();
+            this._teeSrcPad = teeSrcPad;
+            sourceForChain = null;
+        } else {
+            // First PC to use this track — move source directly
+            const oldPipeline = trackAny._gstPipeline;
+            if (oldPipeline && oldPipeline !== this._pipeline) {
+                source.set_state(Gst.State.NULL);
+                oldPipeline.remove(source);
+                trackAny._gstPipeline = this._pipeline;
+            }
+            if (source.get_parent() !== this._pipeline) {
+                this._pipeline.add(source);
+            }
+            sourceForChain = source;
+        }
+
+        // Valve element for Track.enabled control
+        const valve = Gst.ElementFactory.make('valve', null)!;
+        (valve as any).drop = !track.enabled;
+        this._valve = valve;
+        this._pipeline.add(valve);
+
+        const elements: any[] = [valve];
+        let lastElement: any;
+
+        if (track.kind === 'audio') {
+            const convert = Gst.ElementFactory.make('audioconvert', null)!;
+            const resample = Gst.ElementFactory.make('audioresample', null)!;
+            const encoder = Gst.ElementFactory.make('opusenc', null)!;
+            const payloader = Gst.ElementFactory.make('rtpopuspay', null)!;
+            (payloader as any).pt = OPUS_PAYLOAD_TYPE;
+
+            // capsfilter tells webrtcbin the RTP caps immediately so createOffer
+            // can generate the m=audio line without waiting for data to flow.
+            const capsfilter = Gst.ElementFactory.make('capsfilter', null)!;
+            (capsfilter as any).caps = Gst.Caps.from_string(
+                `application/x-rtp,media=audio,encoding-name=OPUS,clock-rate=48000,payload=${OPUS_PAYLOAD_TYPE}`,
+            );
+
+            elements.push(convert, resample, encoder, payloader, capsfilter);
+            for (const el of elements) this._pipeline.add(el);
+
+            // Link source/tee → valve
+            if (this._teeSrcPad) {
+                const valveSinkPad = valve.get_static_pad('sink');
+                this._teeSrcPad.link(valveSinkPad);
+            } else if (sourceForChain) {
+                sourceForChain.link(valve);
+            }
+            valve.link(convert);
+            convert.link(resample);
+            resample.link(encoder);
+            encoder.link(payloader);
+            payloader.link(capsfilter);
+            lastElement = capsfilter;
+        } else {
+            // Video
+            const convert = Gst.ElementFactory.make('videoconvert', null)!;
+            const scale = Gst.ElementFactory.make('videoscale', null)!;
+            const encoder = Gst.ElementFactory.make('vp8enc', null)!;
+            (encoder as any).deadline = 1; // Realtime encoding
+            (encoder as any).keyframe_max_dist = 60;
+            const payloader = Gst.ElementFactory.make('rtpvp8pay', null)!;
+            (payloader as any).pt = VP8_PAYLOAD_TYPE;
+
+            const capsfilter = Gst.ElementFactory.make('capsfilter', null)!;
+            (capsfilter as any).caps = Gst.Caps.from_string(
+                `application/x-rtp,media=video,encoding-name=VP8,clock-rate=90000,payload=${VP8_PAYLOAD_TYPE}`,
+            );
+
+            elements.push(convert, scale, encoder, payloader, capsfilter);
+            for (const el of elements) this._pipeline.add(el);
+
+            // Link source/tee → valve
+            if (this._teeSrcPad) {
+                const valveSinkPad = valve.get_static_pad('sink');
+                this._teeSrcPad.link(valveSinkPad);
+            } else if (sourceForChain) {
+                sourceForChain.link(valve);
+            }
+            valve.link(convert);
+            convert.link(scale);
+            scale.link(encoder);
+            encoder.link(payloader);
+            payloader.link(capsfilter);
+            lastElement = capsfilter;
+        }
+
+        // Link payloader output to webrtcbin sink pad.
+        // Use the mline index if assigned (>= 0), otherwise request next available.
+        const padName = this._mlineIndex >= 0 ? `sink_${this._mlineIndex}` : 'sink_%u';
+        const sinkPad = this._webrtcbin.request_pad_simple
+            ? this._webrtcbin.request_pad_simple(padName)
+            : this._webrtcbin.get_request_pad(padName);
+        if (sinkPad) {
+            const srcPad = lastElement.get_static_pad('src');
+            srcPad.link(sinkPad);
+        }
+
+        // Sync states — elements added to a PLAYING pipeline
+        // If using a tee branch, don't include the shared source in our element list
+        const ownedElements = this._teeSrcPad ? elements : [source, ...elements];
+        for (const el of ownedElements) {
+            el.sync_state_with_parent();
+        }
+
+        this._elements = ownedElements;
+        this._linked = true;
+
+        // Wire Track.enabled → valve.drop
+        track._setEnableCallback((enabled: boolean) => {
+            if (this._valve) (this._valve as any).drop = !enabled;
+        });
+    }
+
+    /** @internal — tear down the encoder chain on close/removeTrack */
+    _teardownPipeline(): void {
+        if (!this._linked) return;
+        // Disconnect enable callback from the track
+        if (this._track) {
+            this._track._setEnableCallback(null);
+        }
+        // Release tee branch if using shared source
+        if (this._teeSrcPad && this._track?._teeMultiplexer) {
+            try {
+                (this._track._teeMultiplexer as TeeMultiplexer).releaseSrcPad(this._teeSrcPad);
+            } catch { /* ignore */ }
+            this._teeSrcPad = null;
+        }
+        for (const el of [...this._elements].reverse()) {
+            try {
+                el.set_state(Gst.State.NULL);
+                this._pipeline?.remove(el);
+            } catch { /* ignore cleanup errors */ }
+        }
+        this._elements = [];
+        this._valve = null;
+        this._linked = false;
+    }
+
+    getParameters(): RTCRtpSendParameters {
+        if (!this._lastParams) {
+            this._lastParams = {
+                transactionId: String(++_txCounter),
+                encodings: [],
+                codecs: [],
+                headerExtensions: [],
+                rtcp: {},
+            };
+        }
+        return { ...this._lastParams, encodings: [...this._lastParams.encodings] };
+    }
+
+    async setParameters(params: RTCRtpSendParameters): Promise<void> {
+        if (!this._lastParams) {
+            throw new DOMException(
+                'getParameters must be called before setParameters',
+                'InvalidStateError',
+            );
+        }
+        if (params.transactionId !== this._lastParams.transactionId) {
+            throw new DOMException(
+                'transactionId mismatch',
+                'InvalidModificationError',
+            );
+        }
+        this._lastParams = null;
+    }
+
+    async replaceTrack(track: MediaStreamTrack | null): Promise<void> {
+        if (track === null) {
+            this._teardownPipeline();
+            this._track = null;
+            return;
+        }
+        if (this._track !== null && track.kind !== this._track.kind) {
+            throw new TypeError('Cannot replace track with different kind');
+        }
+        if (this._linked && (track as any)._gstSource) {
+            // Atomic source swap: old source → new source, keep rest of chain
+            const oldSource = this._elements[0];
+            const newSource = (track as any)._gstSource;
+
+            // Move new source from its pipeline
+            const oldPipeline = (track as any)._gstPipeline;
+            if (oldPipeline && oldPipeline !== this._pipeline) {
+                newSource.set_state(Gst.State.NULL);
+                oldPipeline.remove(newSource);
+                (track as any)._gstPipeline = this._pipeline;
+            }
+
+            // Swap: unlink old, link new
+            oldSource.set_state(Gst.State.NULL);
+            oldSource.unlink(this._valve);
+            this._pipeline.remove(oldSource);
+
+            this._pipeline.add(newSource);
+            newSource.link(this._valve);
+            newSource.sync_state_with_parent();
+
+            this._elements[0] = newSource;
+        } else if ((track as any)._gstSource) {
+            this._wirePipeline(track);
+        }
+
+        // Disconnect old track's enable callback, wire new one
+        if (this._track) this._track._setEnableCallback(null);
+        this._track = track;
+        if (this._linked) {
+            track._setEnableCallback((enabled: boolean) => {
+                if (this._valve) (this._valve as any).drop = !enabled;
+            });
+        }
+    }
+
+    async getStats(): Promise<RTCStatsReport> {
+        if (this._getStatsForTrack && this._track) {
+            return this._getStatsForTrack(this._track);
+        }
+        // Fallback: return empty report if no PC or no track
+        const { RTCStatsReport: Report } = await import('./rtc-stats-report.js');
+        return new Report();
+    }
+
+    setStreams(..._streams: MediaStream[]): void {
+        // Phase 3: no-op — webrtcbin manages msid in SDP automatically
+    }
+
+    static getCapabilities(kind: string): RTCRtpCapabilities | null {
+        return getRtpCapabilities(kind);
+    }
+}

package/src/rtc-rtp-transceiver.ts

@@ -0,0 +1,127 @@
+// W3C RTCRtpTransceiver for GJS.
+//
+// Wraps GstWebRTC.WebRTCRTPTransceiver. Reads mid, direction, currentDirection
+// from the native object. direction setter maps back to GStreamer enum.
+//
+// Reference: refs/node-gst-webrtc/src/webrtc/RTCRtpTransceiver.ts (ISC)
+// Reference: W3C WebRTC spec § 5.4
+
+import type GstWebRTC from 'gi://GstWebRTC?version=1.0';
+
+import { gstDirectionToW3C, w3cDirectionToGst } from './gst-enum-maps.js';
+import { RTCRtpSender, type RTCRtpTransceiverDirection, type RTCRtpCodecCapability } from './rtc-rtp-sender.js';
+import { RTCRtpReceiver } from './rtc-rtp-receiver.js';
+
+export class RTCRtpTransceiver {
+    private _gstTrans: GstWebRTC.WebRTCRTPTransceiver;
+    readonly sender: RTCRtpSender;
+    readonly receiver: RTCRtpReceiver;
+    private _stopped = false;
+    private _codecPreferences: RTCRtpCodecCapability[] = [];
+
+    constructor(
+        gstTrans: GstWebRTC.WebRTCRTPTransceiver,
+        sender: RTCRtpSender,
+        receiver: RTCRtpReceiver,
+    ) {
+        this._gstTrans = gstTrans;
+        this.sender = sender;
+        this.receiver = receiver;
+    }
+
+    get mid(): string | null {
+        if (this._stopped) return null;
+        const m = (this._gstTrans as any).mid;
+        return (m === '' || m == null) ? null : String(m);
+    }
+
+    get direction(): RTCRtpTransceiverDirection {
+        if (this._stopped) return 'stopped';
+        return gstDirectionToW3C((this._gstTrans as any).direction);
+    }
+
+    set direction(d: RTCRtpTransceiverDirection) {
+        if (this._stopped) {
+            throw new DOMException(
+                "Cannot set direction on a stopped transceiver",
+                'InvalidStateError',
+            );
+        }
+        if (d === 'stopped') {
+            throw new TypeError("The provided value 'stopped' is not a valid enum value of type RTCRtpTransceiverDirection.");
+        }
+        const valid: RTCRtpTransceiverDirection[] = ['sendrecv', 'sendonly', 'recvonly', 'inactive'];
+        if (!valid.includes(d)) {
+            throw new TypeError(`The provided value '${d}' is not a valid enum value of type RTCRtpTransceiverDirection.`);
+        }
+        (this._gstTrans as any).direction = w3cDirectionToGst(d);
+    }
+
+    get currentDirection(): RTCRtpTransceiverDirection | null {
+        if (this._stopped) return null;
+        const cd = (this._gstTrans as any).current_direction ?? (this._gstTrans as any).currentDirection;
+        if (cd == null) return null;
+        const w3c = gstDirectionToW3C(cd);
+        return w3c === 'inactive' ? null : w3c;
+    }
+
+    get stopped(): boolean {
+        return this._stopped;
+    }
+
+    stop(): void {
+        if (this._stopped) return;
+        this._stopped = true;
+    }
+
+    setCodecPreferences(codecs: RTCRtpCodecCapability[]): void {
+        if (!Array.isArray(codecs)) {
+            throw new TypeError('codecs must be an array');
+        }
+        if (codecs.length === 0) {
+            this._codecPreferences = [];
+            return;
+        }
+
+        const kind = this.receiver.track.kind;
+        const recvCaps = RTCRtpReceiver.getCapabilities(kind);
+        const sendCaps = RTCRtpSender.getCapabilities(kind);
+        if (!recvCaps || !sendCaps) {
+            throw new DOMException('No capabilities available', 'InvalidModificationError');
+        }
+
+        const allCaps = [...recvCaps.codecs, ...sendCaps.codecs];
+
+        for (const codec of codecs) {
+            if (!codec || typeof codec !== 'object') {
+                throw new TypeError('Each codec must be an object');
+            }
+            if (typeof codec.mimeType !== 'string' || typeof codec.clockRate !== 'number') {
+                throw new TypeError('codec must have mimeType (string) and clockRate (number)');
+            }
+
+            const isResiliency = /\/(rtx|red|ulpfec)$/i.test(codec.mimeType);
+            if (isResiliency) continue;
+
+            const match = allCaps.find((c) =>
+                c.mimeType.toLowerCase() === codec.mimeType.toLowerCase() &&
+                c.clockRate === codec.clockRate &&
+                (codec.channels === undefined || c.channels === codec.channels) &&
+                (codec.sdpFmtpLine === undefined || c.sdpFmtpLine === codec.sdpFmtpLine)
+            );
+            if (!match) {
+                throw new DOMException(
+                    `Codec ${codec.mimeType} ${codec.clockRate} is not in capabilities`,
+                    'InvalidModificationError',
+                );
+            }
+        }
+
+        this._codecPreferences = [...codecs];
+    }
+
+    /** @internal */
+    get _nativeTransceiver(): GstWebRTC.WebRTCRTPTransceiver {
+        return this._gstTrans;
+    }
+}