livekit-client 2.19.2 → 2.20.1

package/src/room/PCTransport.test.ts

@@ -0,0 +1,150 @@
+import { type MediaDescription, parse } from 'sdp-transform';
+import { describe, expect, it } from 'vitest';
+import { conformBundledCodecFmtp, placeholderMidsFromTransceivers } from './PCTransport';
+
+/** Parse the `key[=value]` pairs of an fmtp config into a comparable set. */
+const paramSet = (config: string) => new Set(config.split(';').filter(Boolean));
+
+const fmtpOf = (media: MediaDescription[], mid: string, payload: number) => {
+  const m = media.find((section) => `${section.mid}` === mid)!;
+  return m.fmtp.find((f) => f.payload === payload)?.config;
+};
+
+/** Predicate for conformBundledCodecFmtp based on an explicit set of mids. */
+const placeholders = (mids: string[]) => {
+  const set = new Set(mids);
+  return (m: MediaDescription) => set.has(`${m.mid}`);
+};
+
+// One publisher bundle: a published mic + camera (real sends, with msid/ssrc)
+// and their pre-populated recvonly placeholders.
+const PUBLISHER_SDP = `v=0
+o=- 0 0 IN IP4 127.0.0.1
+s=-
+t=0 0
+a=group:BUNDLE 0 1 2 3
+m=audio 9 UDP/TLS/RTP/SAVPF 111
+c=IN IP4 0.0.0.0
+a=mid:0
+a=sendonly
+a=msid:s mic
+a=ssrc:1111 cname:a
+a=rtpmap:111 opus/48000/2
+a=fmtp:111 minptime=10;useinbandfec=1;usedtx=1
+m=audio 9 UDP/TLS/RTP/SAVPF 111
+c=IN IP4 0.0.0.0
+a=mid:1
+a=recvonly
+a=rtpmap:111 opus/48000/2
+a=fmtp:111 minptime=10;useinbandfec=1
+m=video 9 UDP/TLS/RTP/SAVPF 49
+c=IN IP4 0.0.0.0
+a=mid:2
+a=sendonly
+a=msid:s cam
+a=ssrc:2222 cname:b
+a=rtpmap:49 H265/90000
+a=fmtp:49 level-id=186;profile-id=1;tier-flag=0;tx-mode=SRST
+m=video 9 UDP/TLS/RTP/SAVPF 49
+c=IN IP4 0.0.0.0
+a=mid:3
+a=recvonly
+a=rtpmap:49 H265/90000
+a=fmtp:49 level-id=180;profile-id=1;tier-flag=0;tx-mode=SRST`;
+
+describe('placeholderMidsFromTransceivers', () => {
+  const tr = (mid: string | null, track: unknown) =>
+    ({ mid, sender: { track } }) as unknown as RTCRtpTransceiver;
+
+  it('includes transceivers with a mid and no outgoing track', () => {
+    const mids = placeholderMidsFromTransceivers([
+      tr('0', {}), // real send
+      tr('1', null), // pre-populated placeholder
+      tr('2', null), // reverted after unpublish (msid may linger in SDP, but no track)
+      tr(null, null), // not yet negotiated — no mid, excluded
+    ]);
+    expect(mids).toEqual(new Set(['1', '2']));
+  });
+});
+
+describe('conformBundledCodecFmtp', () => {
+  it('copies opus and H.265 fmtp from real sections onto placeholders', () => {
+    const { media } = parse(PUBLISHER_SDP);
+
+    conformBundledCodecFmtp(media, placeholders(['1', '3']));
+
+    expect(fmtpOf(media, '1', 111)).toBe(fmtpOf(media, '0', 111));
+    expect(paramSet(fmtpOf(media, '1', 111)!)).toContain('usedtx=1');
+    expect(fmtpOf(media, '3', 49)).toBe(fmtpOf(media, '2', 49));
+    expect(paramSet(fmtpOf(media, '3', 49)!)).toContain('level-id=186');
+  });
+
+  it('never rewrites the real (non-placeholder) sections', () => {
+    const { media } = parse(PUBLISHER_SDP);
+
+    conformBundledCodecFmtp(media, placeholders(['1', '3']));
+
+    expect(fmtpOf(media, '0', 111)).toBe('minptime=10;useinbandfec=1;usedtx=1');
+    expect(paramSet(fmtpOf(media, '2', 49)!)).toContain('level-id=186');
+  });
+
+  it('converges divergent placeholders even when no real section declares the payload', () => {
+    // Two placeholders that disagree (a reverted one kept level 186, a fresh one
+    // has 180) with no active send present.
+    const { media } = parse(`v=0
+o=- 0 0 IN IP4 127.0.0.1
+s=-
+t=0 0
+a=group:BUNDLE 10 11
+m=video 9 UDP/TLS/RTP/SAVPF 49
+a=mid:10
+a=rtpmap:49 H265/90000
+a=fmtp:49 level-id=186;profile-id=1;tier-flag=0;tx-mode=SRST
+m=video 9 UDP/TLS/RTP/SAVPF 49
+a=mid:11
+a=rtpmap:49 H265/90000
+a=fmtp:49 level-id=180;profile-id=1;tier-flag=0;tx-mode=SRST`);
+
+    conformBundledCodecFmtp(media, placeholders(['10', '11']));
+
+    expect(fmtpOf(media, '10', 49)).toBe(fmtpOf(media, '11', 49));
+  });
+
+  it('conforms a reverted section that kept its msid (second-publish case)', () => {
+    // The real second publish: a live camera send (level 186), plus the section
+    // left over from the first (unpublished) track. Chrome keeps that section's
+    // `a=msid`/`a=ssrc` even though it no longer sends, so it must be identified
+    // as a placeholder by its transceiver (no track), not by SDP.
+    const { media } = parse(`v=0
+o=- 0 0 IN IP4 127.0.0.1
+s=-
+t=0 0
+a=group:BUNDLE 3 4 5
+m=video 9 UDP/TLS/RTP/SAVPF 49
+a=mid:3
+a=sendonly
+a=msid:s cam
+a=ssrc:9 cname:c
+a=rtpmap:49 H265/90000
+a=fmtp:49 level-id=186;profile-id=1;tier-flag=0;tx-mode=SRST
+m=video 9 UDP/TLS/RTP/SAVPF 49
+a=mid:4
+a=sendonly
+a=msid:s stale
+a=ssrc:8 cname:d
+a=rtpmap:49 H265/90000
+a=fmtp:49 level-id=180;profile-id=1;tier-flag=0;tx-mode=SRST
+m=video 9 UDP/TLS/RTP/SAVPF 49
+a=mid:5
+a=recvonly
+a=rtpmap:49 H265/90000
+a=fmtp:49 level-id=180;profile-id=1;tier-flag=0;tx-mode=SRST`);
+
+    // mid 4 still has msid/ssrc in the SDP, but its transceiver has no track.
+    conformBundledCodecFmtp(media, placeholders(['4', '5']));
+
+    expect(paramSet(fmtpOf(media, '3', 49)!)).toContain('level-id=186'); // real send untouched
+    expect(fmtpOf(media, '4', 49)).toBe(fmtpOf(media, '3', 49)); // stale conformed
+    expect(fmtpOf(media, '5', 49)).toBe(fmtpOf(media, '3', 49)); // placeholder conformed
+  });
+});

package/src/room/PCTransport.ts

@@ -234,6 +234,17 @@ export default class PCTransport extends (EventEmitter as new () => TypedEmitter
           });
         }
       });
+      // The server's answer sets per-track codec params (e.g. opus `usedtx`) on
+      // the sections mapped to a published track, but leaves the pre-populated
+      // recvonly placeholder sections with defaults. Conform the placeholders so
+      // each shared payload type is consistent across the bundle, otherwise
+      // libwebrtc flags a "bundled payload type collision".
+      const placeholderMids = this.getPlaceholderMids();
+      if (placeholderMids.size > 0) {
+        conformBundledCodecFmtp(sdpParsed.media, (media) =>
+          placeholderMids.has(getMidString(media.mid!)),
+        );
+      }
       mungedSDP = write(sdpParsed);
     }
     await this.setMungedSDP(sd, mungedSDP, true);
@@ -400,6 +411,17 @@ export default class PCTransport extends (EventEmitter as new () => TypedEmitter
           });
         }
       });
+      // Conform the placeholder sections (pre-populated, or reverted after an
+      // unpublish) so every shared payload type carries identical fmtp across the
+      // bundle, otherwise libwebrtc flags a "bundled payload type collision".
+      // Detection is by transceiver (mids are stable across renegotiations) since
+      // an unpublished section keeps its `a=msid`.
+      const placeholderMids = this.getPlaceholderMids();
+      if (placeholderMids.size > 0) {
+        conformBundledCodecFmtp(sdpParsed.media, (media) =>
+          placeholderMids.has(getMidString(media.mid!)),
+        );
+      }
       if (this.latestOfferId > offerId) {
         this.log.warn('latestOfferId mismatch', {
           ...this.logContext,
@@ -428,6 +450,17 @@ export default class PCTransport extends (EventEmitter as new () => TypedEmitter
     return answer;
   }
 
+  /**
+   * Returns the mids of transceivers that carry no outgoing track on this
+   * (publisher) connection: the pre-populated placeholders added by
+   * `RTCEngine.applyInitialPublisherLayout`, plus any transceiver that was used
+   * for a track and reverted on unpublish. Their codec fmtp is conformed to the
+   * published tracks so a shared payload type stays consistent across the bundle.
+   */
+  private getPlaceholderMids(): Set<string> {
+    return placeholderMidsFromTransceivers(this._pc?.getTransceivers() ?? []);
+  }
+
   createDataChannel(label: string, dataChannelDict: RTCDataChannelInit) {
     return this.pc.createDataChannel(label, dataChannelDict);
   }
@@ -498,6 +531,10 @@ export default class PCTransport extends (EventEmitter as new () => TypedEmitter
     return this.pc.getStats();
   }
 
+  getMaxMessageSize() {
+    return this._pc?.sctp?.maxMessageSize;
+  }
+
   async getConnectedAddress(): Promise<string | undefined> {
     if (!this._pc) {
       return;
@@ -699,6 +736,86 @@ function ensureAudioNackAndStereo(
   }
 }
 
+/**
+ * Returns the mids of transceivers that carry no outgoing track: the
+ * pre-populated placeholders added by `RTCEngine.applyInitialPublisherLayout`,
+ * plus any transceiver that was used for a track and reverted on unpublish. The
+ * `sender.track` check is the reliable signal — an unpublished section keeps its
+ * `a=msid` (and its stale send-derived fmtp), so it can't be told apart from a
+ * real send by SDP alone. Transceiver mids are stable across renegotiations, so
+ * this works for every offer/answer after the first.
+ * @internal
+ */
+export function placeholderMidsFromTransceivers(
+  transceivers: readonly RTCRtpTransceiver[],
+): Set<string> {
+  const mids = new Set<string>();
+  for (const transceiver of transceivers) {
+    if (transceiver.mid && !transceiver.sender.track) {
+      mids.add(transceiver.mid);
+    }
+  }
+  return mids;
+}
+
+/**
+ * Within a BUNDLE group a payload type must map to identical codec parameters
+ * across every m-line. When the same payload type carries different fmtp between
+ * sections — e.g. opus `usedtx=1` on the published microphone but not on the
+ * pre-populated recvonly placeholders, or H.265 with different `level-id` between
+ * a published video track and a placeholder — libwebrtc flags a "bundled payload
+ * type collision".
+ *
+ * Rewrite the placeholder sections so every shared payload type carries the
+ * same fmtp. Real (non-placeholder) sections always win the canonical value, so
+ * a published track's encoder parameters are never altered. When no real
+ * section declares a payload type — e.g. a placeholder that was reused for a
+ * track and then reverted to recvonly keeps its send-derived `level-id` while
+ * fresh placeholders use the default — the placeholders still converge on the
+ * first value seen, so two placeholders can't disagree either. Only placeholder
+ * sections are ever rewritten, and it is codec-agnostic (opus, H.265, ...).
+ * `isPlaceholder` identifies the sections to conform.
+ * @internal
+ */
+export function conformBundledCodecFmtp(
+  media: MediaDescription[],
+  isPlaceholder: (media: MediaDescription) => boolean,
+) {
+  // Canonical fmtp per payload type. Payload types are unique within a BUNDLE
+  // group, so keying by payload alone (across audio and video) is safe. A real
+  // section's value always takes precedence; otherwise the first placeholder
+  // value seen is used so divergent placeholders still converge.
+  const canonicalByPayload = new Map<number, string>();
+  const fromRealSection = new Set<number>();
+  for (const m of media) {
+    const placeholder = isPlaceholder(m);
+    for (const fmtp of m.fmtp ?? []) {
+      if (!placeholder) {
+        canonicalByPayload.set(fmtp.payload, fmtp.config);
+        fromRealSection.add(fmtp.payload);
+      } else if (!canonicalByPayload.has(fmtp.payload)) {
+        canonicalByPayload.set(fmtp.payload, fmtp.config);
+      }
+    }
+  }
+  if (canonicalByPayload.size === 0) {
+    return;
+  }
+
+  // Conform placeholder sections to the canonical fmtp for each shared payload.
+  for (const m of media) {
+    if (!isPlaceholder(m)) {
+      continue;
+    }
+    for (const fmtp of m.fmtp ?? []) {
+      const config = canonicalByPayload.get(fmtp.payload);
+      if (config !== undefined && fmtp.config !== config) {
+        fmtp.config = config;
+      }
+    }
+  }
+}
+
 function extractStereoAndNackAudioFromOffer(offer: RTCSessionDescriptionInit): {
   stereoMids: string[];
   nackMids: string[];

package/src/room/PCTransportManager.ts

@@ -310,6 +310,10 @@ export class PCTransportManager {
     return matchingTransceiver?.mid;
   }
 
+  getMaxPublisherMessageSize() {
+    return this.publisher.getMaxMessageSize();
+  }
+
   addPublisherTrack(track: MediaStreamTrack) {
     return this.publisher.addTrack(track);
   }

package/src/room/RTCEngine.test.ts

@@ -1,6 +1,8 @@
+import { DataPacket, DataPacket_Kind, UserPacket } from '@livekit/protocol';
 import { afterEach, describe, expect, it, vi } from 'vitest';
-import RTCEngine from './RTCEngine';
+import RTCEngine, { DataChannelKind } from './RTCEngine';
 import { roomOptionDefaults } from './defaults';
+import { PublishDataError } from './errors';
 
 describe('RTCEngine', () => {
   const originalRTCRtpSender = window.RTCRtpSender;
@@ -56,12 +58,12 @@ describe('RTCEngine', () => {
     ).makeRTCConfiguration();
   }
 
-  function setupPacketTrailerSender(engine: RTCEngine, sender: RTCRtpSender, opts = {}) {
+  function setupFrameMetadataSender(engine: RTCEngine, sender: RTCRtpSender, opts = {}) {
     (
       engine as unknown as {
-        setupPacketTrailerSender: (sender: RTCRtpSender, opts?: unknown) => void;
+        setupFrameMetadataSender: (sender: RTCRtpSender, opts?: unknown) => void;
       }
-    ).setupPacketTrailerSender(sender, opts);
+    ).setupFrameMetadataSender(sender, opts);
   }
 
   it('does not enable encoded insertable streams without E2EE or a packet trailer worker', () => {
@@ -128,7 +130,7 @@ describe('RTCEngine', () => {
       createEncodedStreams,
     } as unknown as RTCRtpSender;
 
-    setupPacketTrailerSender(engine, sender);
+    setupFrameMetadataSender(engine, sender);
 
     expect(createEncodedStreams).not.toHaveBeenCalled();
   });
@@ -145,7 +147,7 @@ describe('RTCEngine', () => {
       createEncodedStreams,
     } as unknown as RTCRtpSender;
 
-    setupPacketTrailerSender(engine, sender);
+    setupFrameMetadataSender(engine, sender);
 
     expect(createEncodedStreams).not.toHaveBeenCalled();
   });
@@ -165,7 +167,7 @@ describe('RTCEngine', () => {
       createEncodedStreams,
     } as unknown as RTCRtpSender;
 
-    setupPacketTrailerSender(engine, sender, { packetTrailer: { timestamp: true, frameId: true } });
+    setupFrameMetadataSender(engine, sender, { packetTrailer: { timestamp: true, frameId: true } });
 
     expect(createEncodedStreams).toHaveBeenCalledTimes(1);
     expect(worker.postMessage).toHaveBeenCalledWith(
@@ -185,7 +187,9 @@ describe('RTCEngine', () => {
     stubScriptTransformSupport();
 
     const transform = {};
-    const RTCRtpScriptTransform = vi.fn(() => transform);
+    const RTCRtpScriptTransform = vi.fn(function () {
+      return transform;
+    });
     Object.defineProperty(window, 'RTCRtpScriptTransform', {
       configurable: true,
       value: RTCRtpScriptTransform,
@@ -207,7 +211,7 @@ describe('RTCEngine', () => {
       createEncodedStreams,
     } as unknown as RTCRtpSender;
 
-    setupPacketTrailerSender(engine, sender, { packetTrailer: { timestamp: true } });
+    setupFrameMetadataSender(engine, sender, { packetTrailer: { timestamp: true } });
 
     expect(RTCRtpScriptTransform).toHaveBeenCalledWith(worker, {
       kind: 'encode',
@@ -216,4 +220,134 @@ describe('RTCEngine', () => {
     expect((sender as unknown as { transform: unknown }).transform).toBe(transform);
     expect(createEncodedStreams).not.toHaveBeenCalled();
   });
+
+  describe('sendDataPacket', () => {
+    const MAX_DATA_PACKET_SIZE = 64 * 1024 - 1; // 65535 bytes (64 KB - 1)
+    function stubConnectedEngine(
+      engine: RTCEngine,
+      maxDataPacketSize: number = MAX_DATA_PACKET_SIZE,
+    ) {
+      const send = vi.fn();
+      Object.assign(engine as unknown as Record<string, unknown>, {
+        ensurePublisherConnected: vi.fn().mockResolvedValue(undefined),
+        waitForBufferStatusLow: vi.fn().mockResolvedValue(undefined),
+        updateAndEmitDCBufferStatus: vi.fn(),
+        dataChannelForKind: vi.fn(() => ({ send })),
+        pcManager: {
+          getMaxPublisherMessageSize: vi.fn(() => maxDataPacketSize),
+        },
+      });
+      return send;
+    }
+
+    it('rejects packets larger than the max data packet size', async () => {
+      const engine = new RTCEngine(roomOptionDefaults);
+      const send = stubConnectedEngine(engine);
+
+      // The serialized packet includes protobuf framing on top of the payload, so a payload at the
+      // limit is already guaranteed to exceed it once serialized.
+      const packet = new DataPacket({
+        kind: DataPacket_Kind.RELIABLE,
+        value: {
+          case: 'user',
+          value: new UserPacket({ payload: new Uint8Array(MAX_DATA_PACKET_SIZE) }),
+        },
+      });
+
+      await expect(engine.sendDataPacket(packet, DataChannelKind.RELIABLE)).rejects.toBeInstanceOf(
+        PublishDataError,
+      );
+      expect(send).not.toHaveBeenCalled();
+    });
+
+    it('does not reject packets if the max data packet size is 0', async () => {
+      const engine = new RTCEngine(roomOptionDefaults);
+      const send = stubConnectedEngine(engine, 0);
+
+      const packet = new DataPacket({
+        kind: DataPacket_Kind.RELIABLE,
+        value: {
+          case: 'user',
+          value: new UserPacket({ payload: new Uint8Array(100) }),
+        },
+      });
+
+      // Sending the packet should succeed, there isn't a size limit
+      await expect(
+        engine.sendDataPacket(packet, DataChannelKind.RELIABLE),
+      ).resolves.toBeUndefined();
+      expect(send).toHaveBeenCalledTimes(1);
+    });
+
+    it('sends packets within the max data packet size', async () => {
+      const engine = new RTCEngine(roomOptionDefaults);
+      const send = stubConnectedEngine(engine);
+
+      const packet = new DataPacket({
+        kind: DataPacket_Kind.RELIABLE,
+        value: {
+          case: 'user',
+          value: new UserPacket({ payload: new Uint8Array(1024) }),
+        },
+      });
+
+      await expect(
+        engine.sendDataPacket(packet, DataChannelKind.RELIABLE),
+      ).resolves.toBeUndefined();
+      expect(send).toHaveBeenCalledTimes(1);
+    });
+  });
+
+  describe('handleDataChannelClose', () => {
+    function stubCloseEnv(
+      engine: RTCEngine,
+      { closed, publisherState }: { closed: boolean; publisherState: RTCPeerConnectionState },
+    ) {
+      const error = vi.fn();
+      Object.assign(engine as unknown as Record<string, unknown>, {
+        _isClosed: closed,
+        log: { error },
+        pcManager: {
+          publisher: { getConnectionState: () => publisherState },
+        },
+      });
+      return error;
+    }
+
+    function fireClose(engine: RTCEngine, kind: DataChannelKind) {
+      (
+        engine as unknown as {
+          handleDataChannelClose: (kind: DataChannelKind) => () => void;
+        }
+      ).handleDataChannelClose(kind)();
+    }
+
+    it('logs an error when a publisher channel closes while connected', () => {
+      const engine = new RTCEngine(roomOptionDefaults);
+      const error = stubCloseEnv(engine, { closed: false, publisherState: 'connected' });
+
+      fireClose(engine, DataChannelKind.RELIABLE);
+
+      expect(error).toHaveBeenCalledOnce();
+      expect(error.mock.calls[0][0]).toContain('RELIABLE');
+    });
+
+    it('stays quiet when the engine is already closed', () => {
+      const engine = new RTCEngine(roomOptionDefaults);
+      const error = stubCloseEnv(engine, { closed: true, publisherState: 'connected' });
+
+      fireClose(engine, DataChannelKind.RELIABLE);
+
+      expect(error).not.toHaveBeenCalled();
+    });
+
+    it('stays quiet when the publisher PC is no longer connected', () => {
+      const engine = new RTCEngine(roomOptionDefaults);
+      const error = stubCloseEnv(engine, { closed: false, publisherState: 'closed' });
+
+      fireClose(engine, DataChannelKind.RELIABLE);
+
+      expect(error).not.toHaveBeenCalled();
+    });
+  });
 });