@furious.luke/argus-js 0.5.1 → 0.5.2

package/README.md

@@ -181,6 +181,7 @@ the customer server owns a live control-token notify subscription.
 | `gatewayHandshakeTimeoutMs` | `number` | Overall deadline for the initial gateway race and `accepted` → `ready` handshake. Unaccepted sockets are replaced after 3 seconds so a blackholed TCP flow cannot consume the full deadline. Defaults to 20 seconds. |
 | `peerConnectionTimeoutMs` | `number` | Deadline after the initial offer for WebRTC to reach `connected`. Defaults to 30 seconds. |
 | `signalingReconnectTimeoutMs` | `number` | How long to retry a dropped signaling socket against the selected regional gateway. Defaults to 20 seconds. |
+| `preferredVideoCodecs` | `string[]` | Preferred video codecs, most-preferred first, as RTP MIME types (e.g. `"video/VP9"`, `"video/H264"`). Each published video track offers these ahead of the rest, so the browser sends the first one the media server also accepts. Defaults to `["video/VP9"]`. Pass `[]` to leave the browser's native order untouched. Codecs the browser lacks (or `setCodecPreferences` support, e.g. older Safari) are ignored — negotiation always falls back cleanly. |
 | `callbacks` | `PublisherCallbacks` | Optional lifecycle callbacks (see below). |
 
 ### Methods & properties

package/dist/index.cjs

@@ -370,6 +370,7 @@ var Publisher = class {
       };
       if (initialTrack) {
         const sender = initialTrack.type === "audio" ? this.addMicrophoneTrack(pc, initialTrack.track, initialTrack.stream) : pc.addTrack(initialTrack.track, initialTrack.stream);
+        if (initialTrack.type !== "audio") this.preferVideoCodecs(pc, sender);
         this.typeSenders.set(
           initialTrack.type,
           sender
@@ -1580,6 +1581,39 @@ var Publisher = class {
     this.microphoneTransceiver = transceiver;
     return transceiver.sender;
   }
+  /**
+   * Reorders the codecs a video sender offers so the browser prefers the
+   * configured codecs (VP9 by default). This is what actually controls the wire
+   * format: the browser is the offerer and sends its own top-of-offer codec, and
+   * the media server (Pion) answers by mirroring the offer's codec order — so the
+   * server's own registration order has no say. Floating VP9 to the front of the
+   * offer is therefore the lever. Codecs not in the preference keep their native
+   * order behind it, so anything VP9 can't satisfy still negotiates.
+   *
+   * Best-effort: browsers lacking `getCapabilities`/`setCodecPreferences` (older
+   * Safari) keep their default order, and any failure is swallowed — codec
+   * preference is an optimization, never a requirement for publishing.
+   */
+  preferVideoCodecs(pc, sender) {
+    const preferred = this.opts.preferredVideoCodecs ?? ["video/VP9"];
+    if (preferred.length === 0) return;
+    if (sender.track && sender.track.kind !== "video") return;
+    if (typeof RTCRtpSender === "undefined" || typeof RTCRtpSender.getCapabilities !== "function") return;
+    if (typeof pc.getTransceivers !== "function") return;
+    const caps = RTCRtpSender.getCapabilities("video");
+    if (!caps?.codecs) return;
+    const transceiver = pc.getTransceivers().find((t) => t.sender === sender);
+    if (!transceiver || typeof transceiver.setCodecPreferences !== "function") return;
+    const rank = (mimeType) => {
+      const idx = preferred.findIndex((p) => p.toLowerCase() === mimeType.toLowerCase());
+      return idx === -1 ? preferred.length : idx;
+    };
+    const ordered = caps.codecs.map((codec, index) => ({ codec, index })).sort((a, b) => rank(a.codec.mimeType) - rank(b.codec.mimeType) || a.index - b.index).map((entry) => entry.codec);
+    try {
+      transceiver.setCodecPreferences(ordered);
+    } catch {
+    }
+  }
   /** Registers one physical video track under its logical type and source stream. */
   registerTrack(track, stream, type) {
     this.published.set(track, type);
@@ -1653,6 +1687,7 @@ var Publisher = class {
         throw new SenderRestoreError(`inactive ${type} sender still has a track`);
       }
       addedSender = pc.addTrack(track, stream);
+      this.preferVideoCodecs(pc, addedSender);
       this.typeSenders.set(type, addedSender);
     }
     return {