djs-selfbot-v13 3.7.30 → 3.7.33

package/src/client/voice/VoiceConnection.js

@@ -16,6 +16,14 @@ const { Opcodes, VoiceOpcodes, VoiceStatus, Events } = require('../../util/Const
 const Speaking = require('../../util/Speaking');
 const Util = require('../../util/Util');
 
+function normalizeVoiceEndpoint(endpoint, { preservePort = false } = {}) {
+  const match = endpoint?.match(/^([^:]+)(?::(\d+))?/);
+  if (!match) return endpoint;
+  const [, host, port] = match;
+  if (!preservePort || !port || port === '443' || port === '80') return host;
+  return `${host}:${port}`;
+}
+
 // Workaround for Discord now requiring silence to be sent before being able to receive audio
 class SingleSilence extends Silence {
   _read() {
@@ -166,6 +174,18 @@ class VoiceConnection extends EventEmitter {
      * @type {Collection<Snowflake, StreamConnectionReadonly>}
      */
     this.streamWatchConnection = new Collection();
+
+    /**
+     * DAVE end-to-end encryption session
+     * @type {?DAVESession}
+     */
+    this.dave = null;
+
+    /**
+     * Connected client user IDs for DAVE MLS
+     * @type {Set<Snowflake>}
+     */
+    this.connectedClients = new Set();
   }
 
   /**
@@ -228,6 +248,20 @@ class VoiceConnection extends EventEmitter {
     return this;
   }
 
+  /**
+   * SSRC values assigned by the voice server.
+   * @returns {{ audioSsrc: number, videoSsrc: number, rtxSsrc: number }}
+   */
+  getStreamSsrcs() {
+    const stream = this.authentication.streams?.[0];
+    const audioSsrc = this.authentication.ssrc;
+    return {
+      audioSsrc,
+      videoSsrc: stream?.ssrc ?? audioSsrc + 1,
+      rtxSsrc: stream?.rtx_ssrc ?? audioSsrc + 2,
+    };
+  }
+
   /**
    * Sets video status
    * @param {boolean} value Video on or off
@@ -236,6 +270,10 @@ class VoiceConnection extends EventEmitter {
     if (value === this.videoStatus) return;
     if (this.status !== VoiceStatus.CONNECTED) return;
     this.videoStatus = value;
+    const attrs = this.videoAttributes ?? {};
+    const fps = attrs.fps ?? 30;
+    const height = attrs.height ?? 720;
+    const width = attrs.width ?? Math.round((height * 16) / 9);
     if (!value) {
       this.sockets.ws
         .sendPacket({
@@ -251,27 +289,28 @@ class VoiceConnection extends EventEmitter {
           this.emit('debug', e);
         });
     } else {
+      const { audioSsrc, videoSsrc, rtxSsrc } = this.getStreamSsrcs();
       this.sockets.ws
         .sendPacket({
           op: VoiceOpcodes.SOURCES,
           d: {
-            audio_ssrc: this.authentication.ssrc,
-            video_ssrc: this.authentication.ssrc + 1,
-            rtx_ssrc: this.authentication.ssrc + 2,
+            audio_ssrc: audioSsrc,
+            video_ssrc: videoSsrc,
+            rtx_ssrc: rtxSsrc,
             streams: [
               {
                 type: 'video',
                 rid: '100',
-                ssrc: this.authentication.ssrc + 1,
+                ssrc: videoSsrc,
                 active: true,
                 quality: 100,
-                rtx_ssrc: this.authentication.ssrc + 2,
-                max_bitrate: 8000000,
-                max_framerate: 60,
+                rtx_ssrc: rtxSsrc,
+                max_bitrate: 10_000_000,
+                max_framerate: fps,
                 max_resolution: {
-                  type: 'source',
-                  width: 0,
-                  height: 0,
+                  type: 'fixed',
+                  width,
+                  height,
                 },
               },
             ],
@@ -305,11 +344,14 @@ class VoiceConnection extends EventEmitter {
         self_mute: this.voice ? this.voice.selfMute : false,
         self_deaf: this.voice ? this.voice.selfDeaf : false,
         self_video: this.voice ? this.voice.selfVideo : false,
-        flags: 2,
       },
       options,
     );
 
+    if (options.self_video) {
+      options.flags = 2;
+    }
+
     this.emit('debug', `Sending voice state update: ${JSON.stringify(options)}`);
 
     return this.channel.client.ws.broadcast({
@@ -371,6 +413,21 @@ class VoiceConnection extends EventEmitter {
       this.checkAuthenticated();
     } else if (sessionId !== this.authentication.sessionId) {
       this.authentication.sessionId = sessionId;
+      if (
+        this.constructor.name !== 'StreamConnection' &&
+        [VoiceStatus.CONNECTED, VoiceStatus.CONNECTING].includes(this.status)
+      ) {
+        this.status = VoiceStatus.RECONNECTING;
+        if (this.sockets.ws) {
+          this.sockets.ws.shutdown();
+          this.sockets.ws = null;
+        }
+        if (this.sockets.udp) {
+          this.sockets.udp.shutdown();
+          this.sockets.udp = null;
+        }
+        this.checkAuthenticated();
+      }
       /**
        * Emitted when a new session ID is received.
        * @event VoiceConnection#newSession
@@ -386,8 +443,9 @@ class VoiceConnection extends EventEmitter {
    */
   checkAuthenticated() {
     const { token, endpoint, sessionId } = this.authentication;
+    const needsServerId = this.constructor.name === 'StreamConnection';
     this.emit('debug', `Authenticated with sessionId ${sessionId}`);
-    if (token && endpoint && sessionId) {
+    if (token && endpoint && sessionId && (!needsServerId || this.serverId)) {
       this.status = VoiceStatus.CONNECTING;
       /**
        * Emitted when we successfully initiate a voice connection.
@@ -441,7 +499,7 @@ class VoiceConnection extends EventEmitter {
    */
   authenticate(options = {}) {
     this.sendVoiceStateUpdate(options);
-    this.connectTimeout = setTimeout(() => this.authenticateFailed('VOICE_CONNECTION_TIMEOUT'), 15_000).unref();
+    this.connectTimeout = setTimeout(() => this.authenticateFailed('VOICE_CONNECTION_TIMEOUT'), 30_000).unref();
   }
 
   /**
@@ -500,6 +558,16 @@ class VoiceConnection extends EventEmitter {
   cleanup() {
     this.player.destroy();
     this.speaking = new Speaking().freeze();
+    if (this.dave) {
+      const isSharedDave =
+        this.constructor.name === 'StreamConnection' && this.voiceConnection?.dave === this.dave;
+      if (!isSharedDave) {
+        this.dave.destroy();
+        this.dave.removeAllListeners();
+      }
+      this.dave = null;
+    }
+    this.connectedClients.clear();
     const { ws, udp } = this.sockets;
 
     this.emit('debug', 'Connection clean up');
@@ -571,11 +639,21 @@ class VoiceConnection extends EventEmitter {
    * @param {Object} data The received data
    * @private
    */
+  isDaveReady() {
+    return (
+      !this.authentication.dave_protocol_version ||
+      (this.dave?.lastTransitionId === 0 && Boolean(this.dave?.session?.ready))
+    );
+  }
+
   onSessionDescription(data) {
     Object.assign(this.authentication, data);
     this.status = VoiceStatus.CONNECTED;
+    clearTimeout(this.connectTimeout);
+    let daveFallback;
     const ready = () => {
       clearTimeout(this.connectTimeout);
+      clearTimeout(daveFallback);
       this.emit('debug', `Ready with authentication details: ${JSON.stringify(this.authentication)}`);
       /**
        * Emitted once the connection is ready, when a promise to join a voice channel resolves,
@@ -584,10 +662,32 @@ class VoiceConnection extends EventEmitter {
        */
       this.emit('ready');
     };
-    if (this.dispatcher || this.videoDispatcher) {
+    const waitForDave = () => {
+      if (this.isDaveReady()) {
+        ready();
+        return;
+      }
+      const onTransitioned = () => {
+        if (this.isDaveReady()) {
+          this.sockets.ws?.removeListener('transitioned', onTransitioned);
+          ready();
+        }
+      };
+      this.sockets.ws?.on('transitioned', onTransitioned);
+      daveFallback = setTimeout(() => {
+        this.sockets.ws?.removeListener('transitioned', onTransitioned);
+        this.emit('debug', 'DAVE handshake incomplete, continuing with transport encryption only');
+        ready();
+      }, 15_000).unref();
+    };
+    if (data.dave_protocol_version) {
+      if (!this.dispatcher && !this.videoDispatcher) {
+        this.playAudio(new SingleSilence(), { type: 'opus', volume: false });
+      }
+      waitForDave();
+    } else if (this.dispatcher || this.videoDispatcher) {
       ready();
     } else {
-      // This serves to provide support for voice receive, sending audio is required to receive it.
       const dispatcher = this.playAudio(new SingleSilence(), { type: 'opus', volume: false });
       dispatcher.once('finish', ready);
     }
@@ -672,12 +772,97 @@ class VoiceConnection extends EventEmitter {
    * Create new connection to screenshare stream
    * @returns {Promise<StreamConnection>}
    */
+  waitForDaveReady() {
+    if (this.isDaveReady() || this.status === VoiceStatus.CONNECTED) return Promise.resolve();
+    return new Promise((resolve, reject) => {
+      const timeout = setTimeout(() => reject(new Error('VOICE_CONNECTION_TIMEOUT')), 30_000).unref();
+      const onReady = () => {
+        if (!this.isDaveReady()) return;
+        clearTimeout(timeout);
+        this.sockets.ws?.removeListener('transitioned', onReady);
+        resolve();
+      };
+      this.sockets.ws?.on('transitioned', onReady);
+      onReady();
+    });
+  }
+
+  stopExistingStream() {
+    return new Promise(resolve => {
+      const hadStreamConnection = Boolean(this.streamConnection);
+      if (this.streamConnection) {
+        this.streamConnection.disconnect();
+        this.streamConnection = null;
+      }
+
+      const streamKey = `${['DM', 'GROUP_DM'].includes(this.channel.type) ? 'call' : `guild:${this.channel.guild.id}`}:${
+        this.channel.id
+      }:${this.client.user.id}`;
+
+      const voiceState = this.channel.guild?.voiceStates.cache.get(this.client.user.id);
+      const wasStreaming = this.client.user?.voice?.streaming || voiceState?.streaming;
+
+      if (!wasStreaming && !hadStreamConnection) {
+        setTimeout(resolve, 200).unref();
+        return;
+      }
+
+      const sendDelete = () => {
+        this.channel.client.ws.broadcast({
+          op: Opcodes.STREAM_DELETE,
+          d: { stream_key: streamKey },
+        });
+      };
+
+      sendDelete();
+      if (wasStreaming) setTimeout(sendDelete, 400).unref();
+
+      let settled = false;
+      const cleanup = () => {
+        this.client.off(Events.VOICE_STATE_UPDATE, onState);
+        this.off('ready', onVoiceReady);
+      };
+      const finish = () => {
+        if (settled) return;
+        if (this.status !== VoiceStatus.CONNECTED) return;
+        settled = true;
+        cleanup();
+        setTimeout(resolve, 500).unref();
+      };
+
+      const onState = (_oldState, newState) => {
+        if (newState.id !== this.client.user.id || newState.streaming) return;
+        finish();
+      };
+      const onVoiceReady = () => finish();
+
+      this.client.on(Events.VOICE_STATE_UPDATE, onState);
+      this.on('ready', onVoiceReady);
+
+      if (!wasStreaming) {
+        setTimeout(resolve, 1500).unref();
+        return;
+      }
+
+      setTimeout(() => finish(), 2000).unref();
+      setTimeout(() => {
+        if (settled) return;
+        settled = true;
+        cleanup();
+        resolve();
+      }, 12_000).unref();
+    });
+  }
+
   createStreamConnection() {
     // eslint-disable-next-line consistent-return
     return new Promise((resolve, reject) => {
       if (this.streamConnection) {
         return resolve(this.streamConnection);
       } else {
+        this.waitForDaveReady()
+          .then(() => this.stopExistingStream())
+          .then(() => {
         const connection = (this.streamConnection = new StreamConnection(this.voiceManager, this.channel, this));
         connection.setVideoCodec(this.videoCodec); // Sync :?
         // Setup event...
@@ -697,7 +882,7 @@ class VoiceConnection extends EventEmitter {
               // Current user stream
               switch (event) {
                 case 'STREAM_CREATE': {
-                  this.streamConnection.setSessionId(this.authentication.sessionId);
+                  this.streamConnection.setSessionId(data.session_id || this.authentication.sessionId);
                   this.streamConnection.serverId = data.rtc_server_id;
                   break;
                 }
@@ -706,6 +891,13 @@ class VoiceConnection extends EventEmitter {
                   break;
                 }
                 case 'STREAM_DELETE': {
+                  if (
+                    [VoiceStatus.CONNECTING, VoiceStatus.AUTHENTICATING, VoiceStatus.RECONNECTING].includes(
+                      this.streamConnection.status,
+                    )
+                  ) {
+                    break;
+                  }
                   this.streamConnection.disconnect();
                   break;
                 }
@@ -743,7 +935,7 @@ class VoiceConnection extends EventEmitter {
         }
 
         connection.sendSignalScreenshare();
-        connection.sendScreenshareState(true);
+        connection.connectTimeout = setTimeout(() => connection.authenticateFailed('VOICE_CONNECTION_TIMEOUT'), 30_000).unref();
 
         connection.on('debug', msg =>
           this.channel.client.emit(
@@ -760,6 +952,7 @@ class VoiceConnection extends EventEmitter {
 
         connection.once('authenticated', () => {
           connection.once('ready', () => {
+            connection.sendScreenshareState(false);
             resolve(connection);
             connection.removeListener('error', reject);
           });
@@ -767,6 +960,8 @@ class VoiceConnection extends EventEmitter {
             this.streamConnection = null;
           });
         });
+        })
+          .catch(reject);
       }
     });
   }
@@ -811,7 +1006,7 @@ class VoiceConnection extends EventEmitter {
               // Current user stream
               switch (event) {
                 case 'STREAM_CREATE': {
-                  this.streamConnection.setSessionId(this.authentication.sessionId);
+                  this.streamConnection.setSessionId(data.session_id || this.authentication.sessionId);
                   this.streamConnection.serverId = data.rtc_server_id;
                   break;
                 }
@@ -820,6 +1015,13 @@ class VoiceConnection extends EventEmitter {
                   break;
                 }
                 case 'STREAM_DELETE': {
+                  if (
+                    [VoiceStatus.CONNECTING, VoiceStatus.AUTHENTICATING, VoiceStatus.RECONNECTING].includes(
+                      this.streamConnection.status,
+                    )
+                  ) {
+                    break;
+                  }
                   this.streamConnection.disconnect();
                   break;
                 }
@@ -963,6 +1165,49 @@ class StreamConnection extends VoiceConnection {
     return Promise.resolve(this);
   }
 
+  setTokenAndEndpoint(token, endpoint) {
+    this.emit('debug', `Token "${token}" and endpoint "${endpoint}"`);
+    if (!endpoint) return;
+
+    if (!token) {
+      this.authenticateFailed('VOICE_TOKEN_ABSENT');
+      return;
+    }
+
+    endpoint = normalizeVoiceEndpoint(endpoint, { preservePort: true });
+    this.emit('debug', `Endpoint resolved as ${endpoint}`);
+
+    if (!endpoint) {
+      this.authenticateFailed('VOICE_INVALID_ENDPOINT');
+      return;
+    }
+
+    const connect = () => {
+      if (this.status === VoiceStatus.AUTHENTICATING) {
+        this.authentication.token = token;
+        this.authentication.endpoint = endpoint;
+        this.checkAuthenticated();
+      } else if (token !== this.authentication.token || endpoint !== this.authentication.endpoint) {
+        this.reconnect(token, endpoint);
+      }
+    };
+
+    if (this.status === VoiceStatus.AUTHENTICATING) {
+      setTimeout(connect, 750).unref();
+    } else {
+      connect();
+    }
+  }
+
+  onSessionDescription(data) {
+    Object.assign(this.authentication, data);
+    this.status = VoiceStatus.CONNECTED;
+    this._sessionRetries = 0;
+    clearTimeout(this.connectTimeout);
+    this.emit('debug', `Ready with authentication details: ${JSON.stringify(this.authentication)}`);
+    this.emit('ready');
+  }
+
   joinStreamConnection() {
     throw new Error('STREAM_CANNOT_JOIN');
   }
@@ -1005,10 +1250,11 @@ class StreamConnection extends VoiceConnection {
       preferred_region: null,
     };
     this.emit('debug', `Signal Stream: ${JSON.stringify(data)}`);
-    return this.channel.client.ws.broadcast({
+    this.channel.client.ws.broadcast({
       op: Opcodes.STREAM_CREATE,
       d: data,
     });
+    this.sendScreenshareState(false);
   }
 
   /**

package/src/client/voice/dispatcher/AnnexBDispatcher.js

@@ -20,7 +20,8 @@ Please use the @dank074/discord-video-stream library for the best support.
 const { Buffer } = require('buffer');
 const VideoDispatcher = require('./VideoDispatcher');
 const Util = require('../../../util/Util');
-const { H264Helpers, H265Helpers } = require('../player/processing/AnnexBNalSplitter');
+const { H264Helpers, H265Helpers, H264NalUnitTypes, H265NalUnitTypes } = require('../player/processing/AnnexBNalSplitter');
+const { rewriteSPSVUI } = require('../player/processing/SPSVUIRewriter');
 
 class AnnexBDispatcher extends VideoDispatcher {
   constructor(player, highWaterMark = 12, streams, fps, nalFunctions, payloadType) {
@@ -28,8 +29,65 @@ class AnnexBDispatcher extends VideoDispatcher {
     this._nalFunctions = nalFunctions;
   }
 
+  _rewriteH264SPS(accessUnit) {
+    const parts = [];
+    let offset = 0;
+    while (offset < accessUnit.length) {
+      const naluSize = accessUnit.readUInt32BE(offset);
+      offset += 4;
+      let nalu = accessUnit.subarray(offset, offset + naluSize);
+      if (this._nalFunctions === H264Helpers && H264Helpers.getUnitType(nalu) === 7) {
+        try {
+          nalu = rewriteSPSVUI(nalu);
+        } catch {
+          // keep original SPS on rewrite failure
+        }
+      }
+      const header = Buffer.alloc(4);
+      header.writeUInt32BE(nalu.length);
+      parts.push(header, nalu);
+      offset += naluSize;
+    }
+    return Buffer.concat(parts);
+  }
+
+  _accessUnitIsKeyframe(accessUnit) {
+    let offset = 0;
+    while (offset < accessUnit.length) {
+      const naluSize = accessUnit.readUInt32BE(offset);
+      offset += 4;
+      const nalu = accessUnit.subarray(offset, offset + naluSize);
+      const unitType = this._nalFunctions.getUnitType(nalu);
+      if (this._nalFunctions === H264Helpers) {
+        if (unitType === H264NalUnitTypes.CodedSliceIdr) return true;
+      } else if (
+        unitType === H265NalUnitTypes.IDR_W_RADL ||
+        unitType === H265NalUnitTypes.IDR_N_LP ||
+        unitType === H265NalUnitTypes.CRA_NUT
+      ) {
+        return true;
+      }
+      offset += naluSize;
+    }
+    return false;
+  }
+
+  _sendVideoPacket(naluPayload, isLastPacket, isKeyframe) {
+    const includeContentType = isKeyframe && isLastPacket && this.player.isScreenSharing;
+    this._playChunk(
+      Buffer.concat([this.createPayloadExtension(includeContentType), naluPayload]),
+      isLastPacket,
+      { isKeyframe },
+    );
+  }
+
   _codecCallback(frame) {
-    let accessUnit = frame;
+    let accessUnit = this._nalFunctions === H264Helpers ? this._rewriteH264SPS(frame) : frame;
+    const isKeyframe = this._accessUnitIsKeyframe(accessUnit);
+    const dave = this.player.voiceConnection.dave;
+    if (dave?.session?.ready) {
+      accessUnit = dave.encryptVideo(accessUnit, this.player.voiceConnection.videoCodec);
+    }
     let offset = 0;
 
     // Extract NALUs from the access unit
@@ -39,24 +97,19 @@ class AnnexBDispatcher extends VideoDispatcher {
       const nalu = accessUnit.subarray(offset, offset + naluSize);
       const isLastNal = offset + naluSize >= accessUnit.length;
       if (nalu.length <= this.mtu) {
-        // Send as Single NAL Unit Packet.
-        this._playChunk(Buffer.concat([this.createPayloadExtension(), nalu]), isLastNal);
+        this._sendVideoPacket(nalu, isLastNal, isKeyframe);
       } else {
         const [naluHeader, naluData] = this._nalFunctions.splitHeader(nalu);
         const dataFragments = this.partitionMtu(naluData);
-        // Send as Fragmentation Unit A (FU-A):
         for (let fragmentIndex = 0; fragmentIndex < dataFragments.length; fragmentIndex++) {
           const data = dataFragments[fragmentIndex];
           const isFirstPacket = fragmentIndex === 0;
           const isFinalPacket = fragmentIndex === dataFragments.length - 1;
 
-          this._playChunk(
-            Buffer.concat([
-              this.createPayloadExtension(),
-              this.makeFragmentationUnitHeader(isFirstPacket, isFinalPacket, naluHeader),
-              data,
-            ]),
+          this._sendVideoPacket(
+            Buffer.concat([this.makeFragmentationUnitHeader(isFirstPacket, isFinalPacket, naluHeader), data]),
             isLastNal && isFinalPacket,
+            isKeyframe,
           );
         }
       }

package/src/client/voice/dispatcher/BaseDispatcher.js

@@ -5,6 +5,7 @@ const crypto = require('node:crypto');
 const { Writable } = require('node:stream');
 const { setTimeout } = require('node:timers');
 const secretbox = require('../util/Secretbox');
+const Speaking = require('../../../util/Speaking');
 
 const MAX_UINT_16 = 2 ** 16 - 1;
 const MAX_UINT_32 = 2 ** 32 - 1;
@@ -232,14 +233,16 @@ class BaseDispatcher extends Writable {
     callback();
   }
 
-  _playChunk(chunk, isLastPacket = false) {
+  _playChunk(chunk, isLastPacket = false, packetOpts = {}) {
     if (
       (this.player.dispatcher !== this && this.player.videoDispatcher !== this) ||
       !this.player.voiceConnection.authentication.secret_key
     ) {
       return;
     }
+    this._packetOpts = packetOpts;
     const packet = this._createPacket(chunk, isLastPacket);
+    this._packetOpts = null;
     if (packet) this._sendPacket(packet);
   }
 
@@ -375,7 +378,9 @@ class BaseDispatcher extends Writable {
     rtpHeader[0] = 0x80; // Version + Flags (1 byte)
     rtpHeader[1] = this.payloadType; // Payload Type (1 byte)
     if (this.extensionEnabled) {
-      rtpHeader = Buffer.concat([rtpHeader, this.createHeaderExtension()]);
+      const extensionWordCount =
+        typeof this.getExtensionWordCount === 'function' ? this.getExtensionWordCount(isLastPacket) : 1;
+      rtpHeader = Buffer.concat([rtpHeader, this.createHeaderExtension(extensionWordCount)]);
       rtpHeader[0] |= 1 << 4; // 0x90
     }
     if (this.getTypeDispatcher() === 'video' && isLastPacket) {
@@ -384,12 +389,11 @@ class BaseDispatcher extends Writable {
 
     rtpHeader.writeUIntBE(this.getNewSequence(), 2, 2);
     rtpHeader.writeUIntBE(this.timestamp, 4, 4);
-    rtpHeader.writeUIntBE(
-      this.player.voiceConnection.authentication.ssrc + Number(this.getTypeDispatcher() === 'video'),
-      8,
-      4,
-    );
-    return Buffer.concat([rtpHeader, ...this._encrypt(buffer, rtpHeader)]);
+    const { audioSsrc, videoSsrc } = this.player.voiceConnection.getStreamSsrcs();
+    rtpHeader.writeUIntBE(this.getTypeDispatcher() === 'video' ? videoSsrc : audioSsrc, 8, 4);
+    const dave = this.player.voiceConnection.dave;
+    const payload = this.getTypeDispatcher() === 'audio' && dave?.session?.ready ? dave.encrypt(buffer) : buffer;
+    return Buffer.concat([rtpHeader, ...this._encrypt(payload, rtpHeader)]);
   }
 
   _sendPacket(packet) {
@@ -399,7 +403,7 @@ class BaseDispatcher extends Writable {
      * @param {string} info The debug info
      */
     if (this.getTypeDispatcher() === 'audio') {
-      this._setSpeaking(this.player.isScreenSharing ? 1 << 1 : 1 << 0); // 1 << 0 = SPEAKING, 1 << 1 = SOUND SHARE
+      this._setSpeaking(this.player.isScreenSharing ? Speaking.FLAGS.SOUNDSHARE : Speaking.FLAGS.SPEAKING);
     } else if (this.getTypeDispatcher() === 'video') {
       this._setVideoStatus(true);
       this._setStreamStatus(false);

package/src/client/voice/dispatcher/VideoDispatcher.js

@@ -60,6 +60,39 @@ class VideoDispatcher extends BaseDispatcher {
     this.fps = value;
   }
 
+  shouldIncludeContentType(isLastPacket) {
+    return Boolean(
+      this.player.isScreenSharing && this._packetOpts?.isKeyframe && isLastPacket,
+    );
+  }
+
+  getExtensionWordCount(isLastPacket) {
+    return this.shouldIncludeContentType(isLastPacket) ? 2 : 1;
+  }
+
+  createHeaderExtension(extensionWordCount = 1) {
+    const profile = Buffer.alloc(4);
+    profile[0] = 0xbe;
+    profile[1] = 0xde;
+    profile.writeInt16BE(extensionWordCount, 2);
+    return profile;
+  }
+
+  createPayloadExtension(includeContentType = false) {
+    if (includeContentType) {
+      const data = Buffer.alloc(8);
+      data[0] = (5 << 4) | 1;
+      data.writeUIntBE(10, 1, 2);
+      data[3] = 6 << 4;
+      data[4] = 0x01;
+      return data;
+    }
+    const data = Buffer.alloc(4);
+    data[0] = (5 << 4) | 1;
+    data.writeUIntBE(10, 1, 2);
+    return data;
+  }
+
   _codecCallback() {
     throw new Error('The _codecCallback method must be implemented');
   }