@gjsify/webrtc 0.1.15

package/lib/esm/rtc-rtp-receiver.js

@@ -0,0 +1,91 @@
+import {
+  ReceiverBridge
+} from "@gjsify/webrtc-native";
+import { MediaStreamTrack } from "./media-stream-track.js";
+import { getRtpCapabilities } from "./rtp-capabilities.js";
+const MAX_JITTER_BUFFER_TARGET = 4e3;
+class RTCRtpReceiver {
+  _gstReceiver;
+  _track;
+  _jitterBufferTarget = null;
+  _pipeline = null;
+  _receiverBridge = null;
+  /** @internal — stats callback set by RTCPeerConnection */
+  _getStatsForTrack = null;
+  constructor(kind, gstReceiver, pipeline) {
+    this._gstReceiver = gstReceiver;
+    this._pipeline = pipeline ?? null;
+    this._track = new MediaStreamTrack({ kind, muted: true });
+  }
+  /** @internal — called from RTCPeerConnection._handlePadAdded */
+  _connectToPad(pad) {
+    if (!this._pipeline || this._receiverBridge) return;
+    this._receiverBridge = new ReceiverBridge({
+      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() {
+    try {
+      this._receiverBridge?.dispose_bridge();
+    } catch {
+    }
+    this._receiverBridge = null;
+  }
+  /** @internal — set by RTCPeerConnection */
+  _transport = null;
+  get track() {
+    return this._track;
+  }
+  get transport() {
+    return this._transport;
+  }
+  get jitterBufferTarget() {
+    return this._jitterBufferTarget;
+  }
+  set jitterBufferTarget(v) {
+    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() {
+    return {
+      codecs: [],
+      headerExtensions: [],
+      rtcp: {}
+    };
+  }
+  getContributingSources() {
+    return [];
+  }
+  getSynchronizationSources() {
+    return [];
+  }
+  async getStats() {
+    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) {
+    return getRtpCapabilities(kind);
+  }
+}
+export {
+  RTCRtpReceiver
+};

package/lib/esm/rtc-rtp-sender.js

@@ -0,0 +1,298 @@
+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";
+const OPUS_PAYLOAD_TYPE = 111;
+const VP8_PAYLOAD_TYPE = 96;
+let _txCounter = 0;
+class RTCRtpSender {
+  _gstSender;
+  _track = null;
+  _lastParams = null;
+  /** @internal GStreamer pipeline references (set by RTCPeerConnection) */
+  _pipeline = null;
+  _webrtcbin = null;
+  _mlineIndex = -1;
+  _elements = [];
+  _valve = null;
+  _linked = false;
+  /** @internal — tee src pad if this sender uses a shared source */
+  _teeSrcPad = null;
+  /** @internal — stats callback set by RTCPeerConnection */
+  _getStatsForTrack = null;
+  /** @internal — set by RTCPeerConnection */
+  _transport = null;
+  /** @internal — DTMF sender, created lazily for audio senders */
+  _dtmf = null;
+  /** @internal — the kind of media this sender handles */
+  _kind = null;
+  /** @internal — back-reference for DTMF stopped/direction checks */
+  _transceiver = null;
+  /** @internal — callback to notify RTCPeerConnection when pipeline changes (cross-pipeline fix) */
+  _onPipelineChanged = null;
+  constructor(gstSender, pipeline, webrtcbin) {
+    this._gstSender = gstSender;
+    this._pipeline = pipeline ?? null;
+    this._webrtcbin = webrtcbin ?? null;
+  }
+  get track() {
+    return this._track;
+  }
+  /** Returns the DTMF sender for audio senders, null for video. */
+  get dtmf() {
+    const kind = this._track?.kind ?? this._kind;
+    if (kind !== "audio") return null;
+    if (!this._dtmf) {
+      const dtmf = new RTCDTMFSender();
+      dtmf._isStopped = () => this._transceiver?.stopped ?? false;
+      dtmf._getCurrentDirection = () => this._transceiver?.currentDirection ?? null;
+      this._dtmf = dtmf;
+    }
+    return this._dtmf;
+  }
+  get transport() {
+    return this._transport;
+  }
+  /** @internal */
+  _setTrack(track) {
+    if (track === null && this._linked) {
+      this._teardownPipeline();
+    }
+    this._track = track;
+  }
+  /** @internal — called by RTCPeerConnection._createTransceiverWrapper */
+  _setMlineIndex(index) {
+    this._mlineIndex = index;
+  }
+  /** @internal — build the outgoing encoder chain and link to webrtcbin */
+  _wirePipeline(track) {
+    if (this._linked || !this._pipeline || !this._webrtcbin) return;
+    const source = track._gstSource;
+    if (!source) return;
+    const trackAny = track;
+    let sourceForChain;
+    if (trackAny._gstTee && trackAny._gstPipeline && trackAny._gstPipeline !== this._pipeline) {
+      const sourcePipeline = trackAny._gstPipeline;
+      const tee = trackAny._gstTee;
+      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();
+      this._pipeline = sourcePipeline;
+      this._onPipelineChanged?.(sourcePipeline);
+      const teeSrcPad = tee.request_pad_simple ? tee.request_pad_simple("src_%u") : tee.get_request_pad("src_%u");
+      this._teeSrcPad = teeSrcPad;
+      sourceForChain = null;
+    } else if (trackAny._teeMultiplexer) {
+      const tee = trackAny._teeMultiplexer;
+      const teeSrcPad = tee.requestSrcPad();
+      this._teeSrcPad = teeSrcPad;
+      sourceForChain = null;
+    } else if (trackAny._gstPipeline && trackAny._gstPipeline !== this._pipeline) {
+      const oldPipeline = trackAny._gstPipeline;
+      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;
+      const tee = new TeeMultiplexer(this._pipeline, source);
+      trackAny._teeMultiplexer = tee;
+      if (oldPeer) {
+        const firstBranch = tee.requestSrcPad();
+        if (firstBranch) firstBranch.link(oldPeer);
+      }
+      const teeSrcPad = tee.requestSrcPad();
+      this._teeSrcPad = teeSrcPad;
+      sourceForChain = null;
+    } else {
+      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;
+    }
+    const valve = Gst.ElementFactory.make("valve", null);
+    valve.drop = !track.enabled;
+    this._valve = valve;
+    this._pipeline.add(valve);
+    const elements = [valve];
+    let lastElement;
+    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.pt = OPUS_PAYLOAD_TYPE;
+      const capsfilter = Gst.ElementFactory.make("capsfilter", null);
+      capsfilter.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);
+      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 {
+      const convert = Gst.ElementFactory.make("videoconvert", null);
+      const scale = Gst.ElementFactory.make("videoscale", null);
+      const encoder = Gst.ElementFactory.make("vp8enc", null);
+      encoder.deadline = 1;
+      encoder.keyframe_max_dist = 60;
+      const payloader = Gst.ElementFactory.make("rtpvp8pay", null);
+      payloader.pt = VP8_PAYLOAD_TYPE;
+      const capsfilter = Gst.ElementFactory.make("capsfilter", null);
+      capsfilter.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);
+      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;
+    }
+    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);
+    }
+    const ownedElements = this._teeSrcPad ? elements : [source, ...elements];
+    for (const el of ownedElements) {
+      el.sync_state_with_parent();
+    }
+    this._elements = ownedElements;
+    this._linked = true;
+    track._setEnableCallback((enabled) => {
+      if (this._valve) this._valve.drop = !enabled;
+    });
+  }
+  /** @internal — tear down the encoder chain on close/removeTrack */
+  _teardownPipeline() {
+    if (!this._linked) return;
+    if (this._track) {
+      this._track._setEnableCallback(null);
+    }
+    if (this._teeSrcPad && this._track?._teeMultiplexer) {
+      try {
+        this._track._teeMultiplexer.releaseSrcPad(this._teeSrcPad);
+      } catch {
+      }
+      this._teeSrcPad = null;
+    }
+    for (const el of [...this._elements].reverse()) {
+      try {
+        el.set_state(Gst.State.NULL);
+        this._pipeline?.remove(el);
+      } catch {
+      }
+    }
+    this._elements = [];
+    this._valve = null;
+    this._linked = false;
+  }
+  getParameters() {
+    if (!this._lastParams) {
+      this._lastParams = {
+        transactionId: String(++_txCounter),
+        encodings: [],
+        codecs: [],
+        headerExtensions: [],
+        rtcp: {}
+      };
+    }
+    return { ...this._lastParams, encodings: [...this._lastParams.encodings] };
+  }
+  async setParameters(params) {
+    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) {
+    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._gstSource) {
+      const oldSource = this._elements[0];
+      const newSource = track._gstSource;
+      const oldPipeline = track._gstPipeline;
+      if (oldPipeline && oldPipeline !== this._pipeline) {
+        newSource.set_state(Gst.State.NULL);
+        oldPipeline.remove(newSource);
+        track._gstPipeline = this._pipeline;
+      }
+      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._gstSource) {
+      this._wirePipeline(track);
+    }
+    if (this._track) this._track._setEnableCallback(null);
+    this._track = track;
+    if (this._linked) {
+      track._setEnableCallback((enabled) => {
+        if (this._valve) this._valve.drop = !enabled;
+      });
+    }
+  }
+  async getStats() {
+    if (this._getStatsForTrack && this._track) {
+      return this._getStatsForTrack(this._track);
+    }
+    const { RTCStatsReport: Report } = await import("./rtc-stats-report.js");
+    return new Report();
+  }
+  setStreams(..._streams) {
+  }
+  static getCapabilities(kind) {
+    return getRtpCapabilities(kind);
+  }
+}
+export {
+  RTCRtpSender
+};

package/lib/esm/rtc-rtp-transceiver.js

@@ -0,0 +1,97 @@
+import { gstDirectionToW3C, w3cDirectionToGst } from "./gst-enum-maps.js";
+import { RTCRtpSender } from "./rtc-rtp-sender.js";
+import { RTCRtpReceiver } from "./rtc-rtp-receiver.js";
+class RTCRtpTransceiver {
+  _gstTrans;
+  sender;
+  receiver;
+  _stopped = false;
+  _codecPreferences = [];
+  constructor(gstTrans, sender, receiver) {
+    this._gstTrans = gstTrans;
+    this.sender = sender;
+    this.receiver = receiver;
+  }
+  get mid() {
+    if (this._stopped) return null;
+    const m = this._gstTrans.mid;
+    return m === "" || m == null ? null : String(m);
+  }
+  get direction() {
+    if (this._stopped) return "stopped";
+    return gstDirectionToW3C(this._gstTrans.direction);
+  }
+  set direction(d) {
+    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 = ["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.direction = w3cDirectionToGst(d);
+  }
+  get currentDirection() {
+    if (this._stopped) return null;
+    const cd = this._gstTrans.current_direction ?? this._gstTrans.currentDirection;
+    if (cd == null) return null;
+    const w3c = gstDirectionToW3C(cd);
+    return w3c === "inactive" ? null : w3c;
+  }
+  get stopped() {
+    return this._stopped;
+  }
+  stop() {
+    if (this._stopped) return;
+    this._stopped = true;
+  }
+  setCodecPreferences(codecs) {
+    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 === void 0 || c.channels === codec.channels) && (codec.sdpFmtpLine === void 0 || 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() {
+    return this._gstTrans;
+  }
+}
+export {
+  RTCRtpTransceiver
+};

package/lib/esm/rtc-sctp-transport.js

@@ -0,0 +1,40 @@
+import "@gjsify/dom-events/register/event-target";
+class RTCSctpTransport extends EventTarget {
+  transport;
+  _state = "connecting";
+  _maxMessageSize = 262144;
+  // 256 KB default per SCTP
+  _maxChannels = 65535;
+  _onstatechange = null;
+  constructor(dtlsTransport) {
+    super();
+    this.transport = dtlsTransport;
+  }
+  get state() {
+    return this._state;
+  }
+  get maxMessageSize() {
+    return this._maxMessageSize;
+  }
+  get maxChannels() {
+    return this._maxChannels;
+  }
+  get onstatechange() {
+    return this._onstatechange;
+  }
+  set onstatechange(v) {
+    this._onstatechange = v;
+  }
+  // ---- Internal setters (called by RTCPeerConnection) ---------------------
+  /** @internal */
+  _setState(state) {
+    if (this._state === state) return;
+    this._state = state;
+    const ev = new Event("statechange");
+    this._onstatechange?.call(this, ev);
+    this.dispatchEvent(ev);
+  }
+}
+export {
+  RTCSctpTransport
+};

package/lib/esm/rtc-session-description.js

@@ -0,0 +1,57 @@
+import GstSdp from "gi://GstSdp?version=1.0";
+import GstWebRTC from "gi://GstWebRTC?version=1.0";
+function sdpTypeToGst(type) {
+  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) {
+  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";
+  }
+}
+class RTCSessionDescription {
+  type;
+  sdp;
+  constructor(init) {
+    this.type = init?.type ?? "offer";
+    this.sdp = init?.sdp ?? "";
+  }
+  toJSON() {
+    return { type: this.type, sdp: this.sdp };
+  }
+  /** Build a GstWebRTC.WebRTCSessionDescription for use with webrtcbin signals. */
+  toGstDesc() {
+    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) {
+    const sdpText = desc.sdp?.as_text?.() ?? "";
+    return new RTCSessionDescription({
+      type: sdpTypeFromGst(desc.type),
+      sdp: sdpText
+    });
+  }
+}
+export {
+  RTCSessionDescription
+};

package/lib/esm/rtc-stats-report.js

@@ -0,0 +1,35 @@
+class RTCStatsReport {
+  _map;
+  constructor(entries) {
+    this._map = new Map(entries);
+  }
+  get size() {
+    return this._map.size;
+  }
+  get(key) {
+    return this._map.get(key);
+  }
+  has(key) {
+    return this._map.has(key);
+  }
+  forEach(callbackfn, thisArg) {
+    this._map.forEach((value, key) => {
+      callbackfn.call(thisArg, value, key, this);
+    });
+  }
+  entries() {
+    return this._map.entries();
+  }
+  keys() {
+    return this._map.keys();
+  }
+  values() {
+    return this._map.values();
+  }
+  [Symbol.iterator]() {
+    return this._map.entries();
+  }
+}
+export {
+  RTCStatsReport
+};

package/lib/esm/rtc-track-event.js

@@ -0,0 +1,29 @@
+import "@gjsify/dom-events/register/event-target";
+class RTCTrackEvent extends Event {
+  receiver;
+  track;
+  streams;
+  transceiver;
+  constructor(type, init) {
+    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;
+  }
+}
+export {
+  RTCTrackEvent
+};

package/lib/esm/rtp-capabilities.js

@@ -0,0 +1,41 @@
+const AUDIO_CAPABILITIES = {
+  codecs: [
+    { mimeType: "audio/opus", clockRate: 48e3, channels: 2, sdpFmtpLine: "minptime=10;useinbandfec=1" },
+    { mimeType: "audio/G722", clockRate: 8e3, channels: 1 },
+    { mimeType: "audio/PCMU", clockRate: 8e3, channels: 1 },
+    { mimeType: "audio/PCMA", clockRate: 8e3, channels: 1 },
+    { mimeType: "audio/telephone-event", clockRate: 8e3, channels: 1 },
+    { mimeType: "audio/red", clockRate: 48e3, 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 = {
+  codecs: [
+    { mimeType: "video/VP8", clockRate: 9e4 },
+    { mimeType: "video/rtx", clockRate: 9e4 },
+    { mimeType: "video/H264", clockRate: 9e4, sdpFmtpLine: "level-asymmetry-allowed=1;packetization-mode=1;profile-level-id=42001f" },
+    { mimeType: "video/VP9", clockRate: 9e4 },
+    { mimeType: "video/red", clockRate: 9e4 },
+    { mimeType: "video/ulpfec", clockRate: 9e4 }
+  ],
+  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" }
+  ]
+};
+function getRtpCapabilities(kind) {
+  if (kind === "audio") return AUDIO_CAPABILITIES;
+  if (kind === "video") return VIDEO_CAPABILITIES;
+  return null;
+}
+export {
+  getRtpCapabilities
+};