rockcord 4.0.0-dev.4 → 4.0.0-dev.5

package/README.md

@@ -30,8 +30,9 @@ Media playback also requires FFmpeg and a supported Opus binding. Keep optional
 - Components V2 support and checked runtime exports with TypeScript declarations.
 - Bounded REST retries, request deadlines, credential redaction, and connection cleanup.
 - Native DAVE/MLS encryption for audio and video, complete received video frames, and voice privacy verification codes.
+- Screen-share connections, H264/VP8/H265 playback, H264/Opus recording, video retransmission, and buffered audio reception.
 
-This is a **development release**. Live audio, H264 camera video, rejoining, and reconnect checks passed. Separate screen-share startup currently fails; recorder output and live VP8/H265 remain unverified. See the [implementation report](https://github.com/rock-forge/rockcord/blob/main/docs/audit/IMPLEMENTATION.md) for coverage and limitations.
+This is a **development release**. Live audio, all three video codecs, screen sharing, H264 recording, and packet-loss recovery have passed targeted checks. See the [implementation report](https://github.com/rock-forge/rockcord/blob/main/docs/audit/IMPLEMENTATION.md) for coverage and limitations.
 
 ## Project links
 
@@ -43,6 +44,6 @@ This is a **development release**. Live audio, H264 camera video, rejoining, and
 
 ## Credits and license
 
-Rockcord is maintained independently by [Rock Forge](https://github.com/rock-forge) and [devrock07](https://github.com/devrock07). It builds on [discord.js-selfbot-v13](https://github.com/aiko-chan-ai/discord.js-selfbot-v13) and [discord.js](https://github.com/discordjs/discord.js), with original Git history and contributor attribution retained.
+Rockcord is maintained independently by [Rock Forge](https://github.com/rock-forge) and [devrock07](https://github.com/devrock07). It builds on [discord.js-selfbot-v13](https://github.com/aiko-chan-ai/discord.js-selfbot-v13) and [discord.js](https://github.com/discordjs/discord.js). Original source attribution and licensing are preserved; this repository starts with fresh Rock Forge commit history.
 
 Licensed under [GPL v3](https://github.com/rock-forge/rockcord/blob/main/LICENSE). Dependencies retain their own licenses.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "rockcord",
-  "version": "4.0.0-dev.4",
+  "version": "4.0.0-dev.5",
   "description": "Rockcord: a maintained Discord client library with tested v13 APIs and DAVE media encryption",
   "main": "./src/index.js",
   "types": "./typings/index.d.ts",
@@ -8,7 +8,7 @@
     "all": "npm run build",
     "test": "npm run test:unit && npm run lint:all && npm run docs:test && npm run test:typescript",
     "test:unit": "node --test test/*.test.cjs",
-    "test:media": "node scripts/media-integration.cjs",
+    "test:media": "node scripts/media-integration.cjs && node scripts/recording-integration.cjs",
     "test:live": "node --env-file=.env scripts/live-voice-check.cjs",
     "bench": "node --expose-gc scripts/bench.cjs",
     "fix:all": "npm run lint:fix && npm run lint:typings:fix && npm run format",
@@ -49,7 +49,7 @@
     "client",
     "discordapp"
   ],
-  "author": "aiko-chan-ai",
+  "author": "Rock Forge (https://github.com/rock-forge)",
   "license": "GNU General Public License v3.0",
   "bugs": {
     "url": "https://github.com/rock-forge/rockcord/issues"

package/src/client/voice/VoiceConnection.js

@@ -31,7 +31,7 @@ if (getCiphers().includes('aes-256-gcm')) {
   SUPPORTED_MODES.unshift('aead_aes256_gcm_rtpsize');
 }
 
-const SUPPORTED_CODECS = ['VP8', 'H264'];
+const SUPPORTED_CODECS = ['VP8', 'H264', 'H265'];
 
 /**
  * Represents a connection to a guild's voice server.
@@ -144,7 +144,7 @@ class VoiceConnection extends EventEmitter {
      * * `VP8`
      * * `VP9` (Not supported for encoding & decoding)
      * * `H264`
-     * * `H265` (Not supported for encoding & decoding)
+     * * `H265`
      * * `AV1` (Not supported for encoding & decoding)
      * @typedef {string} VideoCodec
      */
@@ -312,10 +312,36 @@ class VoiceConnection extends EventEmitter {
 
     this.emit('debug', `Sending voice state update: ${JSON.stringify(options)}`);
 
-    return this.channel.client.ws.broadcast({
-      op: Opcodes.VOICE_STATE_UPDATE,
-      d: options,
-    });
+    this._pendingVoiceState?.cancel();
+    let settle;
+    const pending = { promise: new Promise(resolve => (settle = resolve)) };
+    const finish = acknowledged => {
+      clearTimeout(pending.timer);
+      this.client.removeListener('raw', onState);
+      if (this._pendingVoiceState === pending) this._pendingVoiceState = null;
+      settle(acknowledged);
+    };
+    const onState = packet => {
+      if (packet?.t !== 'VOICE_STATE_UPDATE' || packet.d?.user_id !== this.client.user?.id) return;
+      if (!['channel_id', 'self_mute', 'self_deaf', 'self_video'].every(key => packet.d[key] === options[key])) return;
+      finish(true);
+    };
+    pending.cancel = () => finish(false);
+    pending.timer = setTimeout(pending.cancel, 15_000).unref();
+    this._pendingVoiceState = pending;
+    this.client.on('raw', onState);
+
+    try {
+      return Promise.resolve(this.channel.client.ws.broadcast({ op: Opcodes.VOICE_STATE_UPDATE, d: options })).catch(
+        error => {
+          pending.cancel();
+          throw error;
+        },
+      );
+    } catch (error) {
+      pending.cancel();
+      throw error;
+    }
   }
 
   /**
@@ -498,6 +524,11 @@ class VoiceConnection extends EventEmitter {
    * @private
    */
   cleanup() {
+    this._pendingVoiceState?.cancel();
+    if (!this.voiceConnection) {
+      this.streamConnection?.disconnect();
+      for (const stream of this.streamWatchConnection.values()) stream.disconnect();
+    }
     this.player.destroy();
     this.speaking = new Speaking().freeze();
     const { ws, udp } = this.sockets;
@@ -576,6 +607,9 @@ class VoiceConnection extends EventEmitter {
    * @private
    */
   onSessionDescription(data) {
+    this._mediaRecovery?.reset();
+    for (const jitter of this.receiver.packets.audioJitters.values()) jitter.reset();
+    this.receiver.packets.audioJitters.clear();
     Object.assign(this.authentication, data);
     this.status = VoiceStatus.CONNECTED;
     const ready = () => {
@@ -606,17 +640,21 @@ class VoiceConnection extends EventEmitter {
   }
 
   onStartStreaming({ video_ssrc, user_id, audio_ssrc, rtx_ssrc, streams = [] }) {
+    const layers = streams.length
+      ? streams.filter(stream => stream.active !== false)
+      : [{ ssrc: video_ssrc, rtx_ssrc }];
+    const retained = new Set(layers.flatMap(layer => [+layer.ssrc, +layer.rtx_ssrc]).filter(Boolean));
     for (const [ssrc, info] of this.ssrcMap) {
-      if (info.userId === user_id && ['video', 'video-rtx'].includes(info.kind)) this.ssrcMap.delete(ssrc);
+      if (info.userId === user_id && ['video', 'video-rtx'].includes(info.kind) && !retained.has(ssrc)) {
+        this.ssrcMap.delete(ssrc);
+        this.receiver.packets.forgetSource(ssrc);
+      }
     }
     this.ssrcMap.set(+audio_ssrc, {
       ...(this.ssrcMap.get(+audio_ssrc) || {}),
       userId: user_id,
       hasVideo: Boolean(video_ssrc), // Maybe ?
     });
-    const layers = streams.length
-      ? streams.filter(stream => stream.active !== false)
-      : [{ ssrc: video_ssrc, rtx_ssrc }];
     for (const layer of layers) {
       if (!layer.ssrc) continue;
       this.ssrcMap.set(+layer.ssrc, { userId: user_id, hasVideo: true, kind: 'video' });
@@ -696,12 +734,15 @@ class VoiceConnection extends EventEmitter {
    * @returns {Promise<StreamConnection>}
    */
   createStreamConnection() {
+    if (this.streamConnection?._readyPromise) return this.streamConnection._readyPromise;
+    let created;
     // eslint-disable-next-line consistent-return
-    return new Promise((resolve, reject) => {
+    const pending = new Promise((resolve, reject) => {
       if (this.streamConnection) {
         return resolve(this.streamConnection);
       } else {
         const connection = (this.streamConnection = new StreamConnection(this.voiceManager, this.channel, this));
+        created = connection;
         connection.setVideoCodec(this.videoCodec); // Sync :?
         // Setup event...
         if (!this.eventHook) {
@@ -720,8 +761,8 @@ class VoiceConnection extends EventEmitter {
               // Current user stream
               switch (event) {
                 case 'STREAM_CREATE': {
-                  this.streamConnection.setSessionId(this.authentication.sessionId);
                   this.streamConnection.serverId = data.rtc_server_id;
+                  this.streamConnection.setSessionId(this.authentication.sessionId);
                   break;
                 }
                 case 'STREAM_SERVER_UPDATE': {
@@ -743,8 +784,8 @@ class VoiceConnection extends EventEmitter {
               // Watch user stream
               switch (event) {
                 case 'STREAM_CREATE': {
-                  streamConnection.setSessionId(this.authentication.sessionId);
                   streamConnection.serverId = data.rtc_server_id;
+                  streamConnection.setSessionId(this.authentication.sessionId);
                   break;
                 }
                 case 'STREAM_SERVER_UPDATE': {
@@ -782,12 +823,16 @@ class VoiceConnection extends EventEmitter {
           connection.disconnect();
         });
 
-        connection.on('error', reject);
+        const onError = error => {
+          reject(error);
+          connection.disconnect();
+        };
+        connection.on('error', onError);
 
         connection.once('ready', () => {
           clearTimeout(connection.connectTimeout);
           resolve(connection);
-          connection.removeListener('error', reject);
+          connection.removeListener('error', onError);
         });
         connection.once('disconnect', () => {
           clearTimeout(connection.connectTimeout);
@@ -798,10 +843,28 @@ class VoiceConnection extends EventEmitter {
           () => connection.authenticateFailed('VOICE_CONNECTION_TIMEOUT'),
           15_000,
         ).unref();
-        connection.sendSignalScreenshare();
-        connection.sendScreenshareState(false);
+        const start = () => {
+          if (connection.status === VoiceStatus.DISCONNECTED) return;
+          connection.sendSignalScreenshare();
+          connection.sendScreenshareState(false);
+        };
+        // Wait for an in-flight camera/voice change before creating a stream: a late
+        // camera-off update can otherwise cancel the newly created stream server-side.
+        if (this._pendingVoiceState) {
+          this._pendingVoiceState.promise.then(acknowledged => {
+            if (acknowledged) {
+              start();
+            } else if (connection.status !== VoiceStatus.DISCONNECTED) {
+              connection.authenticateFailed('VOICE_CONNECTION_TIMEOUT');
+            }
+          });
+        } else {
+          start();
+        }
       }
     });
+    if (created) created._readyPromise = pending;
+    return pending;
   }
 
   /**
@@ -819,12 +882,17 @@ class VoiceConnection extends EventEmitter {
     if (!voiceState || !voiceState.streaming) {
       throw new Error('VOICE_USER_NOT_STREAMING');
     }
+    if (this.streamWatchConnection.get(userId)?._readyPromise) {
+      return this.streamWatchConnection.get(userId)._readyPromise;
+    }
+    let created;
     // eslint-disable-next-line consistent-return
-    return new Promise((resolve, reject) => {
+    const pending = new Promise((resolve, reject) => {
       if (this.streamWatchConnection.has(userId)) {
         return resolve(this.streamWatchConnection.get(userId));
       } else {
         const connection = new StreamConnectionReadonly(this.voiceManager, this.channel, this, userId);
+        created = connection;
         this.streamWatchConnection.set(userId, connection);
         connection.setVideoCodec(this.videoCodec);
         // Setup event...
@@ -844,8 +912,8 @@ class VoiceConnection extends EventEmitter {
               // Current user stream
               switch (event) {
                 case 'STREAM_CREATE': {
-                  this.streamConnection.setSessionId(this.authentication.sessionId);
                   this.streamConnection.serverId = data.rtc_server_id;
+                  this.streamConnection.setSessionId(this.authentication.sessionId);
                   break;
                 }
                 case 'STREAM_SERVER_UPDATE': {
@@ -867,8 +935,8 @@ class VoiceConnection extends EventEmitter {
               // Watch user stream
               switch (event) {
                 case 'STREAM_CREATE': {
-                  streamConnection.setSessionId(this.authentication.sessionId);
                   streamConnection.serverId = data.rtc_server_id;
+                  streamConnection.setSessionId(this.authentication.sessionId);
                   break;
                 }
                 case 'STREAM_SERVER_UPDATE': {
@@ -908,12 +976,16 @@ class VoiceConnection extends EventEmitter {
           connection.disconnect();
         });
 
-        connection.on('error', reject);
+        const onError = error => {
+          reject(error);
+          connection.disconnect();
+        };
+        connection.on('error', onError);
 
         connection.once('ready', () => {
           clearTimeout(connection.connectTimeout);
           resolve(connection);
-          connection.removeListener('error', reject);
+          connection.removeListener('error', onError);
         });
         connection.once('disconnect', () => {
           clearTimeout(connection.connectTimeout);
@@ -927,6 +999,8 @@ class VoiceConnection extends EventEmitter {
         connection.sendSignalScreenshare();
       }
     });
+    if (created) created._readyPromise = pending;
+    return pending;
   }
 
   /**

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

@@ -1,15 +1,13 @@
 'use strict';
 
 const { Buffer } = require('node:buffer');
-const crypto = require('node:crypto');
 const { Writable } = require('node:stream');
 const { setTimeout } = require('node:timers');
-const secretbox = require('../util/Secretbox');
+const { encrypt } = require('../util/TransportCrypto');
 
 const MAX_UINT_16 = 2 ** 16 - 1;
 const MAX_UINT_32 = 2 ** 32 - 1;
 
-const nonceStates = new WeakMap();
 const packetStates = new WeakMap();
 
 /**
@@ -86,9 +84,12 @@ class BaseDispatcher extends Writable {
 
     this.on('finish', () => {
       this._cleanup();
-      this._setSpeaking(0);
-      this._setVideoStatus(false);
-      this._setStreamStatus(true);
+      if (this.getTypeDispatcher() === 'audio') {
+        this._setSpeaking(0);
+      } else if (this.getTypeDispatcher() === 'video') {
+        this._setVideoStatus(false);
+        this._setStreamStatus(true);
+      }
     });
   }
 
@@ -247,7 +248,7 @@ class BaseDispatcher extends Writable {
     const next = (this.count + 1) * this.FRAME_LENGTH - (performance.now() - this.startTime - this._pausedTime);
     this._stepTimer = setTimeout(() => {
       if ((!this.pausedSince || this._silence) && this._writeCallback) this._writeCallback();
-    }, next).unref();
+    }, Math.max(0, next)).unref();
     this.timestamp = (this.timestamp + this.TIMESTAMP_INC) % (MAX_UINT_32 + 1);
     if (this._packetState) this._packetState.timestamp = this.timestamp;
     this.count++;
@@ -313,50 +314,11 @@ class BaseDispatcher extends Writable {
   }
 
   _encrypt(buffer, additionalData) {
-    const { secret_key, mode } = this.player.voiceConnection.authentication;
-    // A key must never reuse a nonce, including across audio/video dispatchers and playback restarts.
-    const connection = this.player.voiceConnection;
-    let state = nonceStates.get(connection);
-    if (!state || !state.key.equals(Buffer.from(secret_key))) {
-      state = { key: Buffer.from(secret_key), value: 0 };
-      nonceStates.set(connection, state);
-    }
-    if (state.value >= MAX_UINT_32) {
-      throw new RangeError('Voice encryption nonce exhausted; establish a new session key');
-    }
-    this._nonce = ++state.value;
+    const parts = encrypt(this.player.voiceConnection, buffer, additionalData);
+    this._nonce = parts[1].readUInt32BE();
     this.resetNonceBuffer();
-    this._nonceBuffer.writeUInt32BE(this._nonce, 0);
-
-    // 4 extra bytes of padding on the end of the encrypted packet
-    const noncePadding = this._nonceBuffer.slice(0, 4);
-
-    let encrypted;
-
-    switch (mode) {
-      case 'aead_aes256_gcm_rtpsize': {
-        const cipher = crypto.createCipheriv('aes-256-gcm', secret_key, this._nonceBuffer);
-        cipher.setAAD(additionalData);
-
-        encrypted = Buffer.concat([cipher.update(buffer), cipher.final(), cipher.getAuthTag()]);
-
-        return [encrypted, noncePadding];
-      }
-      case 'aead_xchacha20_poly1305_rtpsize': {
-        encrypted = secretbox.methods.crypto_aead_xchacha20poly1305_ietf_encrypt(
-          buffer,
-          additionalData,
-          this._nonceBuffer,
-          secret_key,
-        );
-
-        return [encrypted, noncePadding];
-      }
-      default: {
-        // This should never happen. Our encryption mode is chosen from a list given to us by the gateway and checked with the ones we support.
-        throw new RangeError(`Unsupported encryption method: ${mode}`);
-      }
-    }
+    parts[1].copy(this._nonceBuffer);
+    return parts;
   }
 
   _createPacket(buffer, isLastPacket) {
@@ -403,6 +365,7 @@ class BaseDispatcher extends Writable {
       8,
       4,
     );
+    this.player.voiceConnection._mediaRecovery?.remember(rtpHeader, buffer);
     return Buffer.concat([rtpHeader, ...this._encrypt(buffer, rtpHeader)]);
   }
 
@@ -424,7 +387,7 @@ class BaseDispatcher extends Writable {
     }
     this.player.voiceConnection.sockets.udp.send(packet).catch(e => {
       if (this.getTypeDispatcher() === 'audio') {
-        this._setSpeaking(this._setSpeaking(0));
+        this._setSpeaking(0);
       } else if (this.getTypeDispatcher() === 'video') {
         this._setVideoStatus(false);
         this._setStreamStatus(true);

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

@@ -14,13 +14,13 @@ const BaseDispatcher = require('./BaseDispatcher');
  * @extends {BaseDispatcher}
  */
 class VideoDispatcher extends BaseDispatcher {
-  constructor(player, highWaterMark = 12, streams, fps, payloadType) {
+  constructor(player, highWaterMark = 12, streams, fps = 30, payloadType) {
     super(player, highWaterMark, payloadType, true, streams);
     /**
      * Video FPS
      * @type {number}
      */
-    this.fps = fps;
+    this.setFPSSource(fps);
 
     this.mtu = 1200;
   }
@@ -57,6 +57,7 @@ class VideoDispatcher extends BaseDispatcher {
    * @param {number} value fps
    */
   setFPSSource(value) {
+    if (!Number.isFinite(value) || value <= 0) throw new RangeError('Video FPS must be a positive finite number');
     this.fps = value;
   }
 

package/src/client/voice/networking/MediaRecovery.js

@@ -0,0 +1,197 @@
+'use strict';
+
+const { Buffer } = require('node:buffer');
+const { setInterval } = require('node:timers');
+const Util = require('../../../util/Util');
+const { encrypt, decrypt } = require('../util/TransportCrypto');
+
+/** Bounded RFC 4585 NACK feedback and RFC 4588 video RTX handling. @private */
+class MediaRecovery {
+  constructor(connection) {
+    this.connection = connection;
+    this.cache = new Map();
+    this.sources = new Map();
+    this.rtxSequence = 0;
+    this.stats = { requested: 0, retransmitted: 0, recovered: 0, expired: 0 };
+  }
+
+  remember(header, payload) {
+    const type = Util.getAllPayloadType().find(
+      codec => codec.rtx_payload_type && codec.payload_type === (header[1] & 127),
+    );
+    if (!type || payload.length > 4096) return;
+    const key = Buffer.from(this.connection.authentication.secret_key);
+    if (!this.key?.equals(key)) {
+      this.reset();
+      this.key = key;
+    }
+    const now = performance.now();
+    for (const [id, item] of this.cache) if (now - item.time > 2000) this.cache.delete(id);
+    if (this.cache.size >= 512) this.cache.delete(this.cache.keys().next().value);
+    const extension = header[0] & 0x10 ? header.readUInt16BE(header.length - 2) * 4 : 0;
+    this.cache.set(`${header.readUInt32BE(8)}:${header.readUInt16BE(2)}`, {
+      header: Buffer.from(header.subarray(0, 12)),
+      payload: Buffer.from(payload.subarray(extension)),
+      type: type.rtx_payload_type,
+      time: now,
+      retries: 0,
+      last: -Infinity,
+    });
+  }
+
+  receive(packet) {
+    const { ssrc, sequenceNumber: seq } = packet.header;
+    let source = this.sources.get(ssrc);
+    if (!source) {
+      if (this.sources.size >= 32) return;
+      this.sources.set(ssrc, (source = { highest: seq, missing: new Map() }));
+      return;
+    }
+    if (source.missing.delete(seq)) this.stats.recovered++;
+    const distance = (seq - source.highest) & 65535;
+    if (!distance || distance >= 32768) return;
+    if (distance > 128) {
+      this.stats.expired += source.missing.size;
+      source.missing.clear();
+    } else {
+      const time = performance.now();
+      for (let i = 1; i < distance; i++) {
+        if (source.missing.size >= 128) break;
+        source.missing.set((source.highest + i) & 65535, { time, last: -Infinity, retries: 0 });
+      }
+    }
+    source.highest = seq;
+    if (source.missing.size && !this.timer) this.timer = setInterval(() => this._tick(), 20).unref();
+  }
+
+  _tick() {
+    const now = performance.now();
+    let pending = false;
+    for (const [ssrc, source] of this.sources) {
+      const sequences = [];
+      for (const [seq, item] of source.missing) {
+        if (now - item.time >= 500) {
+          source.missing.delete(seq);
+          this.stats.expired++;
+        } else if (now - item.time >= 20 && now - item.last >= 60 && item.retries < 3) {
+          item.last = now;
+          item.retries++;
+          sequences.push(seq);
+        }
+      }
+      if (sequences.length) this._nack(ssrc, sequences);
+      pending ||= source.missing.size > 0;
+    }
+    if (!pending) {
+      clearInterval(this.timer);
+      this.timer = null;
+    }
+  }
+
+  _nack(ssrc, sequences) {
+    const entries = [];
+    for (const seq of sequences) {
+      const entry = entries.at(-1);
+      const delta = entry ? (seq - entry.seq) & 65535 : 0;
+      if (entry && delta > 0 && delta <= 16) entry.mask |= 1 << (delta - 1);
+      else entries.push({ seq, mask: 0 });
+    }
+    const packet = Buffer.alloc(12 + entries.length * 4);
+    packet[0] = 0x81;
+    packet[1] = 205;
+    packet.writeUInt16BE(packet.length / 4 - 1, 2);
+    packet.writeUInt32BE(this.connection.authentication.ssrc, 4);
+    packet.writeUInt32BE(ssrc, 8);
+    entries.forEach((entry, index) => {
+      packet.writeUInt16BE(entry.seq, 12 + index * 4);
+      packet.writeUInt16BE(entry.mask, 14 + index * 4);
+    });
+    this.stats.requested += sequences.length;
+    try {
+      const header = packet.subarray(0, 8);
+      this._send(Buffer.concat([header, ...encrypt(this.connection, packet.subarray(8), header)]));
+    } catch (error) {
+      this.connection.receiver?.emit('debug', error);
+    }
+  }
+
+  handle(buffer) {
+    let packet;
+    try {
+      packet = decrypt(this.connection, buffer, 8);
+    } catch {
+      return;
+    }
+    const messages = [];
+    let offset = 0;
+    while (offset + 8 <= packet.length) {
+      const size = (packet.readUInt16BE(offset + 2) + 1) * 4;
+      if (packet[offset] >> 6 !== 2 || size < 8 || offset + size > packet.length) return;
+      if (packet[offset + 1] === 205 && (packet[offset] & 31) === 1 && size >= 16 && size % 4 === 0) {
+        messages.push(packet.subarray(offset, offset + size));
+      }
+      offset += size;
+    }
+    if (offset !== packet.length) return;
+    for (const message of messages) this._handleNack(message);
+  }
+
+  _handleNack(packet) {
+    const now = performance.now();
+    const ssrc = packet.readUInt32BE(8);
+    for (let offset = 12; offset < packet.length; offset += 4) {
+      const seq = packet.readUInt16BE(offset),
+        mask = packet.readUInt16BE(offset + 2);
+      this._retransmit(ssrc, seq, now);
+      for (let bit = 0; bit < 16; bit++) {
+        if (mask & (1 << bit)) this._retransmit(ssrc, (seq + bit + 1) & 65535, now);
+      }
+    }
+  }
+
+  _retransmit(ssrc, sequence, now) {
+    const item = this.cache.get(`${ssrc}:${sequence}`);
+    const auth = this.connection.authentication;
+    if (
+      !item ||
+      !this.key?.equals(Buffer.from(auth.secret_key)) ||
+      now - item.time > 2000 ||
+      item.retries >= 3 ||
+      now - item.last < 20
+    ) {
+      return;
+    }
+    const stream = auth.streams?.find(value => value.ssrc === ssrc);
+    const rtx = stream?.rtx_ssrc ?? (ssrc === auth.ssrc + 1 ? auth.ssrc + 2 : null);
+    if (!rtx) return;
+    item.retries++;
+    item.last = now;
+    const header = Buffer.from(item.header);
+    header[0] = 0x80;
+    header[1] = (header[1] & 0x80) | item.type;
+    header.writeUInt16BE(this.rtxSequence++ & 65535, 2);
+    header.writeUInt32BE(rtx, 8);
+    const original = Buffer.alloc(2);
+    original.writeUInt16BE(sequence);
+    try {
+      this._send(Buffer.concat([header, ...encrypt(this.connection, Buffer.concat([original, item.payload]), header)]));
+      this.stats.retransmitted++;
+    } catch (error) {
+      this.connection.receiver?.emit('debug', error);
+    }
+  }
+
+  _send(packet) {
+    this.connection.sockets?.udp?.send(packet).catch(error => this.connection.receiver?.emit('debug', error));
+  }
+
+  reset() {
+    clearInterval(this.timer);
+    this.timer = null;
+    this.cache.clear();
+    this.sources.clear();
+    this.rtxSequence = 0;
+  }
+}
+
+module.exports = MediaRecovery;

package/src/client/voice/networking/VoiceUDPClient.js

@@ -137,7 +137,16 @@ class VoiceConnectionUDPClient extends EventEmitter {
           op: VoiceOpcodes.SELECT_PROTOCOL,
           d: {
             protocol: 'udp',
-            codecs: Util.getAllPayloadType(),
+            codecs: Util.getAllPayloadType().map(codec =>
+              codec.type === 'video'
+                ? {
+                    ...codec,
+                    priority: codec.name === this.voiceConnection.videoCodec ? 1 : codec.priority,
+                    encode: codec.name === this.voiceConnection.videoCodec,
+                    decode: ['H264', 'H265', 'VP8'].includes(codec.name),
+                  }
+                : codec,
+            ),
             data: {
               address: packet.address,
               port: packet.port,

package/src/client/voice/networking/VoiceWebSocket.js

@@ -263,7 +263,10 @@ class VoiceWebSocket extends EventEmitter {
       case VoiceOpcodes.CLIENT_DISCONNECT:
         this.dave.clients.delete(packet.d.user_id);
         for (const [ssrc, info] of this.connection.ssrcMap) {
-          if (info.userId === packet.d.user_id) this.connection.ssrcMap.delete(ssrc);
+          if (info.userId === packet.d.user_id) {
+            this.connection.ssrcMap.delete(ssrc);
+            this.connection.receiver?.packets.forgetSource(ssrc);
+          }
         }
         const streamInfo = this.connection.receiver && this.connection.receiver.packets.streams.get(packet.d.user_id);
         if (streamInfo) {