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

package/src/client/voice/player/MediaPlayer.js

@@ -22,7 +22,7 @@ const { Readable: ReadableStream } = require('stream');
 const prism = require('prism-media');
 const { H264NalSplitter, H265NalSplitter } = require('./processing/AnnexBNalSplitter');
 const { IvfTransformer } = require('./processing/IvfSplitter');
-const { H264Dispatcher } = require('../dispatcher/AnnexBDispatcher');
+const { H264Dispatcher, H265Dispatcher } = require('../dispatcher/AnnexBDispatcher');
 const AudioDispatcher = require('../dispatcher/AudioDispatcher');
 const { VP8Dispatcher } = require('../dispatcher/VPxDispatcher');
 
@@ -52,10 +52,8 @@ const FFMPEG_H264_ARGUMENTS = options => [
   options?.presetH26x || 'faster',
   '-profile:v',
   'baseline',
-  // '-g',
-  // `${options?.fps}`,
-  // '-x264-params',
-  // `keyint=${options?.fps}:min-keyint=${options?.fps}`,
+  '-g',
+  String(Math.max(1, Math.round(options?.fps || 30))),
   '-bf',
   '0',
   '-bsf:v',
@@ -68,9 +66,15 @@ const FFMPEG_H265_ARGUMENTS = options => [
   '-f',
   'hevc',
   '-preset',
-  options?.presetH265 || 'faster',
+  options?.presetH26x || 'faster',
+  '-tune',
+  'zerolatency',
   '-profile:v',
   'main',
+  '-g',
+  String(Math.max(1, Math.round(options?.fps || 30))),
+  '-x265-params',
+  'repeat-headers=1:aud=1',
   '-bf',
   '0',
 ];
@@ -173,7 +177,10 @@ class MediaPlayer extends EventEmitter {
   playUnknownVideo(input, options = {}) {
     this.destroyVideoDispatcher();
     const isStream = input instanceof ReadableStream;
-    if (!options?.fps) options.fps = 30;
+    if (options.fps == null) options.fps = 30;
+    if (!Number.isFinite(options.fps) || options.fps <= 0) {
+      throw new RangeError('Video FPS must be a positive finite number');
+    }
 
     const args = [
       '-i',
@@ -245,8 +252,11 @@ class MediaPlayer extends EventEmitter {
       case 'H264': {
         return this.playAnnexBVideo(ffmpeg, options, streams, 'H264');
       }
+      case 'H265': {
+        return this.playAnnexBVideo(ffmpeg, options, streams, 'H265');
+      }
       default: {
-        throw new Error('Invalid codec (Supported: VP8, H264)');
+        throw new Error('Invalid codec (Supported: VP8, H264, H265)');
       }
     }
   }
@@ -311,6 +321,15 @@ class MediaPlayer extends EventEmitter {
         ));
         return dispatcher;
       }
+      case 'H265': {
+        const dispatcher = (this.videoDispatcher = new H265Dispatcher(
+          this,
+          options?.highWaterMark,
+          streams,
+          options?.fps,
+        ));
+        return dispatcher;
+      }
       default: {
         throw new Error('Invalid codec');
       }

package/src/client/voice/receiver/AudioJitter.js

@@ -0,0 +1,98 @@
+'use strict';
+
+const { Buffer } = require('node:buffer');
+const { setTimeout } = require('node:timers');
+const { RtpHeader, RtpPacket } = require('werift-rtp');
+const { SILENCE_FRAME } = require('../util/Silence');
+
+// Opus TOC frame durations from RFC 6716, section 3.1.
+function duration(payload) {
+  if (!payload.length) return 20;
+  const config = payload[0] >> 3;
+  const frame =
+    config >= 16 ? 2.5 * 2 ** (config & 3) : config >= 12 ? 10 * 2 ** (config & 1) : [10, 20, 40, 60][config & 3];
+  const code = payload[0] & 3;
+  const frames = code === 0 ? 1 : code === 3 ? (payload[1] || 0) & 63 : 2;
+  const milliseconds = frame * frames;
+  return milliseconds > 0 && milliseconds <= 120 ? milliseconds : 20;
+}
+
+/** Forty-millisecond playout window with bounded reordering and loss padding. @private */
+class AudioJitter {
+  constructor(deliver) {
+    this.deliver = deliver;
+    this.packets = new Map();
+    this.expected = null;
+    this.lastArrival = -Infinity;
+  }
+
+  push(packet) {
+    const now = performance.now();
+    const seq = packet.header.sequenceNumber;
+    if (packet.payload.length > 4096) return;
+    if (
+      this.expected === null ||
+      now - this.lastArrival > 500 ||
+      (((seq - this.expected) & 65535) > 1024 && ((seq - this.expected) & 65535) < 32768)
+    ) {
+      this.reset();
+      this.expected = seq;
+      this.next = now + 40;
+    }
+    const ahead = (seq - this.expected) & 65535;
+    if (ahead >= 32768 || this.packets.has(seq)) return;
+    if (this.packets.size >= 64) return;
+    this.lastArrival = now;
+    this.packets.set(seq, packet);
+    this._schedule();
+  }
+
+  _schedule() {
+    if (this.timer || !this.packets.size) return;
+    this.timer = setTimeout(() => {
+      this.timer = null;
+      this._play();
+    }, Math.max(0, this.next - performance.now())).unref();
+  }
+
+  _play() {
+    let packet = this.packets.get(this.expected);
+    if (!packet) {
+      const sequence = [...this.packets.keys()].sort(
+        (a, b) => ((a - this.expected) & 65535) - ((b - this.expected) & 65535),
+      )[0];
+      if (sequence === undefined) return;
+      const gap = (sequence - this.expected) & 65535;
+      if (gap > 10 || !this.last) {
+        this.expected = sequence;
+        packet = this.packets.get(sequence);
+      } else {
+        packet = new RtpPacket(
+          new RtpHeader({
+            ...this.last.header,
+            sequenceNumber: this.expected,
+            timestamp: (this.last.header.timestamp + duration(this.last.payload) * 48) >>> 0,
+          }),
+          Buffer.from(SILENCE_FRAME),
+        );
+        packet.concealed = true;
+      }
+    }
+    this.packets.delete(this.expected);
+    this.expected = (this.expected + 1) & 65535;
+    this.last = packet;
+    this.next += duration(packet.payload);
+    this.deliver(packet);
+    this._schedule();
+  }
+
+  reset() {
+    clearTimeout(this.timer);
+    this.timer = null;
+    this.packets.clear();
+    this.expected = null;
+    this.last = null;
+  }
+}
+
+module.exports = { AudioJitter, duration };

package/src/client/voice/receiver/PacketHandler.js

@@ -5,9 +5,11 @@ const { Buffer } = require('node:buffer');
 const crypto = require('node:crypto');
 const { setTimeout } = require('node:timers');
 const { RtpPacket, RtpHeader } = require('werift-rtp');
+const { AudioJitter } = require('./AudioJitter');
 const Recorder = require('./Recorder');
 const Speaking = require('../../../util/Speaking');
 const Util = require('../../../util/Util');
+const MediaRecovery = require('../networking/MediaRecovery');
 const secretbox = require('../util/Secretbox');
 const { SILENCE_FRAME } = require('../util/Silence');
 const { VideoFrames, packetize } = require('../util/VideoFrames');
@@ -38,6 +40,8 @@ class PacketHandler extends EventEmitter {
     this.speakingTimeouts = new Map();
     this.videoFrames = new VideoFrames();
     this.videoSequences = new Map();
+    this.audioJitters = new Map();
+    this.recovery = this.connection._mediaRecovery = new MediaRecovery(this.connection);
   }
 
   getNonceBuffer() {
@@ -164,7 +168,7 @@ class PacketHandler extends EventEmitter {
       if (!opusPacket.payload) {
         return;
       }
-      if (SILENCE_FRAME.equals(opusPacket.payload)) {
+      if (SILENCE_FRAME.equals(opusPacket.payload) && !opusPacket.concealed) {
         // If this is a silence frame, pretend we never received it
         return;
       }
@@ -239,10 +243,12 @@ class PacketHandler extends EventEmitter {
       if (this.connection.dave) {
         const codec = ['H264', 'H265', 'VP8'].find(name => Util.getPayloadType(name) === packet.header.payloadType);
         if (!codec) return;
-        const frame = this.videoFrames.push(packet, codec);
+        let plain;
+        const frame = this.videoFrames.push(packet, codec, assembled => {
+          plain = this.connection.dave.decrypt(assembled, userStat.userId, true);
+          return Boolean(plain);
+        });
         if (!frame) return;
-        const plain = this.connection.dave.decrypt(frame, userStat.userId, true);
-        if (!plain) return;
         this.receiver.emit('videoFrame', userStat, plain, codec);
         if (streamInfo) {
           const payloads = packetize(plain, codec);
@@ -270,6 +276,16 @@ class PacketHandler extends EventEmitter {
   }
 
   push(buffer) {
+    if (
+      Buffer.isBuffer(buffer) &&
+      buffer.length >= 28 &&
+      buffer[0] >> 6 === 2 &&
+      buffer[1] >= 192 &&
+      buffer[1] <= 223
+    ) {
+      this.recovery.handle(buffer);
+      return;
+    }
     if (!Buffer.isBuffer(buffer) || buffer.length < 32 || buffer[0] >> 6 !== 2) return;
     const ssrc = buffer.readUInt32BE(8);
     let userStat, packet;
@@ -280,6 +296,8 @@ class PacketHandler extends EventEmitter {
       return;
     }
     if (packet instanceof Error) return;
+    const type = packet.header.payloadType;
+    if (!Util.getAllPayloadType().some(codec => codec.payload_type === type || codec.rtx_payload_type === type)) return;
     if (this.connection.ssrcMap.has(ssrc)) {
       userStat = this.connection.ssrcMap.get(ssrc); // Audio_ssrc
       if (userStat.kind === 'video-rtx') {
@@ -289,17 +307,35 @@ class PacketHandler extends EventEmitter {
         packet.header.sequenceNumber = packet.payload.readUInt16BE();
         packet.header.payloadType = codec.payload_type;
         packet.payload = packet.payload.subarray(2);
+        this.recovery.receive(packet);
         this.videoReceiver(userStat.primarySsrc, userStat, packet);
       } else if (userStat.kind === 'video') {
+        this.recovery.receive(packet);
         this.videoReceiver(ssrc, userStat, packet);
       } else {
+        if (type !== Util.getPayloadType('opus')) return;
         if (this.connection.dave) {
           const plain = this.connection.dave.decrypt(packet.payload, userStat.userId);
           if (!plain) return;
           packet.payload = plain;
         }
-        this.audioReceiver(ssrc, userStat, packet);
-        this.audioReceiverForStream(ssrc, userStat, packet);
+        let jitter = this.audioJitters.get(ssrc);
+        if (jitter && jitter.userId !== userStat.userId) {
+          jitter.reset();
+          this.audioJitters.delete(ssrc);
+          jitter = null;
+        }
+        if (!jitter) {
+          if (this.audioJitters.size >= 32) return;
+          jitter = new AudioJitter(ordered => {
+            this.audioReceiver(ssrc, jitter.userStat, ordered);
+            this.audioReceiverForStream(ssrc, jitter.userStat, ordered);
+          });
+          jitter.userId = userStat.userId;
+          this.audioJitters.set(ssrc, jitter);
+        }
+        jitter.userStat = userStat;
+        jitter.push(packet);
       }
     } else if (this.connection.ssrcMap.has(ssrc - 1)) {
       userStat = this.connection.ssrcMap.get(ssrc - 1); // Video_ssrc
@@ -309,7 +345,22 @@ class PacketHandler extends EventEmitter {
   }
 
   // When udp connection is closed (STREAM_DELETE), destroy all streams (Memory leak)
+  forgetSource(ssrc) {
+    this.audioJitters.get(ssrc)?.reset();
+    this.audioJitters.delete(ssrc);
+    this.recovery.sources.delete(ssrc);
+    this.videoSequences.delete(ssrc);
+    clearTimeout(this.speakingTimeouts.get(ssrc));
+    this.speakingTimeouts.delete(ssrc);
+    for (const key of this.videoFrames.frames.keys()) {
+      if (key.startsWith(`${ssrc}:`)) this.videoFrames.frames.delete(key);
+    }
+  }
+
   destroyAllStream() {
+    this.recovery.reset();
+    for (const jitter of this.audioJitters.values()) jitter.reset();
+    this.audioJitters.clear();
     for (const timeout of this.speakingTimeouts.values()) clearTimeout(timeout);
     this.speakingTimeouts.clear();
     this.videoFrames.frames.clear();

package/src/client/voice/receiver/Receiver.js

@@ -34,7 +34,9 @@ class VoiceReceiver extends EventEmitter {
   }
 
   _updateVideoSubscriptions(frames = this.listenerCount('videoFrame') > 0) {
-    const wants = { any: 0 };
+    // Keep default media delivery enabled: any: 0 also suppresses audio when
+    // switching on explicit video subscriptions.
+    const wants = { any: 100 };
     for (const [ssrc, info] of this.connection.ssrcMap) {
       if (info.kind === 'video') wants[ssrc] = frames || this.packets.videoStreams.has(info.userId) ? 100 : 0;
     }
@@ -90,7 +92,8 @@ class VoiceReceiver extends EventEmitter {
   /**
    * Creates a new video receiving stream. If a stream already exists for a user, then that stream will be returned
    * rather than generating a new one.
-   * <info>Proof of concept - Requires a very good internet connection</info>
+   * Records received H264 video and Opus audio using FFmpeg.
+   * Wait for `ready` before sending media and await `stop()` to finalize the output.
    * @param {UserResolvable} user The user to start listening to.
    * @param {WritableStream|string} output Output stream or file path to write the video stream to.
    * @returns {Recorder} The video stream for the specified user.

package/src/client/voice/receiver/Recorder.js

@@ -4,6 +4,11 @@ const { spawn } = require('child_process');
 const { createSocket } = require('dgram');
 const { EventEmitter } = require('events');
 const { Buffer } = require('node:buffer');
+const fs = require('node:fs');
+const os = require('node:os');
+const path = require('node:path');
+const process = require('node:process');
+const { setTimeout } = require('node:timers');
 const { Writable } = require('stream');
 const kill = require('tree-kill');
 const { RtpPacket } = require('werift-rtp');
@@ -63,6 +68,8 @@ class Recorder extends EventEmitter {
      */
     this.ready = false;
     this.destroyed = false;
+    this.closed = false;
+    this.completion = new Promise(resolve => (this._resolveCompletion = resolve));
 
     this.socket = createSocket('udp4');
 
@@ -71,6 +78,7 @@ class Recorder extends EventEmitter {
   }
 
   fail(error) {
+    this._error = error;
     if (this.listenerCount('error')) this.emit('error', error);
     else this.emit('debug', error.message);
     this.destroy();
@@ -78,47 +86,60 @@ class Recorder extends EventEmitter {
   async init(output) {
     await this.promise;
     if (this.destroyed) return;
-    const sdpData = Util.getSDPCodecName(this.portUdpH264, this.portUdpH265, this.portUdpOpus);
+    // Keep stdin available for FFmpeg's graceful quit command. Reading SDP from
+    // stdin and closing it leaves no way to write the Matroska trailer on Windows.
+    const sdpData = Util.getSDPCodecName(this.portUdpH264, this.portUdpH265, this.portUdpOpus).replace(
+      /;sprop-parameter-sets=[^;\r\n]+/,
+      '',
+    );
+    this._directory = fs.mkdtempSync(path.join(os.tmpdir(), 'rockcord-recorder-'));
+    this._sdpPath = path.join(this._directory, 'input.sdp');
+    fs.writeFileSync(this._sdpPath, sdpData);
     const isStream = output instanceof Writable;
     if (isStream) {
       this.outputStream = StreamOutput(output);
     }
-    const stream = spawn('ffmpeg', [
-      '-reorder_queue_size',
-      '500',
-      '-thread_queue_size',
-      '500',
-      '-err_detect',
-      'ignore_err',
-      '-flags2',
-      '+export_mvs',
-      '-fflags',
-      '+genpts+discardcorrupt',
-      '-use_wallclock_as_timestamps',
-      '1',
-      '-f',
-      'sdp',
-      '-analyzeduration',
-      '1M',
-      '-probesize',
-      '1M',
-      '-protocol_whitelist',
-      'file,udp,rtp,pipe,fd',
-      '-i',
-      '-', // Read from stdin
-      '-buffer_size',
-      '4M',
-      '-max_delay',
-      '500000', // 500ms
-      '-rtbufsize',
-      '4M',
-      '-c',
-      'copy',
-      '-y',
-      '-f',
-      'matroska',
-      isStream ? this.outputStream.url : output,
-    ]);
+    const stream = spawn(
+      process.env.FFMPEG_PATH || 'ffmpeg',
+      [
+        '-hide_banner',
+        '-reorder_queue_size',
+        '0',
+        '-thread_queue_size',
+        '500',
+        '-err_detect',
+        'ignore_err',
+        '-flags2',
+        '+export_mvs',
+        '-fflags',
+        '+genpts+discardcorrupt',
+        '-f',
+        'sdp',
+        '-analyzeduration',
+        '5000000',
+        '-probesize',
+        '1M',
+        '-listen_timeout',
+        '0',
+        '-protocol_whitelist',
+        'file,udp,rtp,pipe,fd',
+        '-i',
+        this._sdpPath,
+        '-buffer_size',
+        '4M',
+        '-max_delay',
+        '0',
+        '-rtbufsize',
+        '4M',
+        '-c',
+        'copy',
+        '-y',
+        '-f',
+        'matroska',
+        isStream ? this.outputStream.url : output,
+      ],
+      { windowsHide: true },
+    );
 
     /**
      * The FFmpeg process
@@ -127,15 +148,44 @@ class Recorder extends EventEmitter {
     this.stream = stream;
     stream.on('error', error => this.fail(error));
     stream.stdin.on('error', error => this.fail(error));
-    stream.once('exit', () => this.destroy());
-    this.stream.stdin.write(sdpData);
-    this.stream.stdin.end();
-    this.stream.stderr.once('data', data => {
+    stream.once('close', code => {
+      this.exitCode = code;
+      if (code && !this._error) this._error = new Error(`FFmpeg recording exited with code ${code}`);
+      this.destroy();
+      this._finalize();
+    });
+    this.stream.stdout?.resume();
+    stream.once('spawn', () => this._waitForPorts().catch(error => this.fail(error)));
+    this.stream.stderr.on('data', data => {
       this.emit('debug', `stderr: ${data}`);
-      this.ready = true;
-      this.emit('ready');
     });
   }
+
+  async _waitForPorts() {
+    const bound = port =>
+      new Promise(resolve => {
+        const probe = createSocket('udp4');
+        probe.once('error', error => {
+          try {
+            probe.close();
+          } catch {
+            /* An unsuccessful bind may close the probe. */
+          }
+          resolve(error.code === 'EADDRINUSE');
+        });
+        probe.bind(port, '127.0.0.1', () => probe.close(() => resolve(false)));
+      });
+    for (let attempt = 0; attempt < 120 && !this.destroyed; attempt++) {
+      const ports = await Promise.all([bound(this.portUdpH264), bound(this.portUdpOpus)]);
+      if (ports.every(Boolean)) {
+        this.ready = true;
+        this.emit('ready', this);
+        return;
+      }
+      await new Promise(resolve => setTimeout(resolve, 25));
+    }
+    if (!this.destroyed) throw new Error('FFmpeg did not open the recording RTP ports');
+  }
   /**
    * Send a payload to FFmpeg via UDP
    * @param {RtpPacket|string|Buffer} payload The payload
@@ -158,10 +208,10 @@ class Recorder extends EventEmitter {
     let port;
     if (payload.header.payloadType === Util.getPayloadType('opus')) {
       port = this.portUdpOpus;
+      this._lastAudioHeader = payload.header;
     } else if (payload.header.payloadType === Util.getPayloadType('H264')) {
       port = this.portUdpH264;
-    } else if (payload.header.payloadType === Util.getPayloadType('H265')) {
-      port = this.portUdpH265;
+      this._lastVideoHeader = payload.header;
     } else {
       return;
     }
@@ -172,15 +222,64 @@ class Recorder extends EventEmitter {
     if (this.destroyed) return;
     this.destroyed = true;
     this.ready = false;
+    if (this.receiver?.videoStreams?.get(this.userId) === this) this.receiver.videoStreams.delete(this.userId);
+    if (this.stream?.pid && this.stream.exitCode === null && !this._error) {
+      // RTCP BYE ends both local RTP inputs. Unlike an immediate quit, EOF lets
+      // FFmpeg drain its parser and muxer, preserving the final buffered frame.
+      for (const [port, ssrc] of [
+        [this.portUdpH264, this._lastVideoHeader?.ssrc ?? 1],
+        [this.portUdpOpus, this._lastAudioHeader?.ssrc ?? 2],
+      ]) {
+        // Include an empty, padded reason: FFmpeg's RTP demuxer requires at
+        // least 12 bytes even though a reason-less BYE may be eight bytes.
+        const bye = Buffer.from([0x81, 203, 0, 2, 0, 0, 0, 0, 0, 0, 0, 0]);
+        bye.writeUInt32BE(ssrc, 4);
+        this.socket.send(bye, port + 1, '127.0.0.1', () => {});
+      }
+      this._quitTimer = setTimeout(() => this.stream.stdin.end('q\n'), 2000).unref();
+      this._killTimer = setTimeout(() => {
+        this._error = new Error('FFmpeg recording did not stop within 5 seconds');
+        kill(this.stream.pid, () => {});
+      }, 5000).unref();
+    } else if (this.stream?.pid && this.stream.exitCode === null) {
+      // Wait for close before removing the SDP: Windows keeps the input file
+      // locked until the failed child has actually exited.
+      kill(this.stream.pid, () => {});
+    } else {
+      this._finalize();
+    }
+  }
+
+  /**
+   * Stop receiving and wait for FFmpeg to finalize the recording.
+   * @returns {Promise<void>}
+   */
+  async stop() {
+    this.destroy();
+    await this.completion;
+    if (this._error) throw this._error;
+  }
+
+  _finalize() {
+    if (this.closed) return;
+    this.closed = true;
+    clearTimeout(this._killTimer);
+    clearTimeout(this._quitTimer);
     try {
       this.socket.close();
     } catch {
       /* Socket may not have bound yet. */
     }
     this.outputStream?.destroy();
-    if (this.stream?.pid) kill(this.stream.pid, () => {});
-    if (this.receiver?.videoStreams?.get(this.userId) === this) this.receiver.videoStreams.delete(this.userId);
-    this.emit('closed');
+    try {
+      if (this._sdpPath) fs.rmSync(this._sdpPath, { force: true });
+      if (this._directory) fs.rmdirSync(this._directory);
+    } catch (error) {
+      this._error ??= error;
+      this.emit('debug', `Recorder temporary-file cleanup failed: ${error.message}`);
+    }
+    this._resolveCompletion();
+    this.emit('closed', this);
   }
 
   /**

package/src/client/voice/util/TransportCrypto.js

@@ -0,0 +1,54 @@
+'use strict';
+
+const { Buffer } = require('node:buffer');
+const crypto = require('node:crypto');
+const secretbox = require('./Secretbox');
+
+const states = new WeakMap();
+
+// RTP, RTX and RTCP all share a nonce space for a negotiated session key.
+function encrypt(connection, payload, header) {
+  const { secret_key: key, mode } = connection.authentication;
+  let state = states.get(connection);
+  if (!state || !state.key.equals(Buffer.from(key))) {
+    state = { key: Buffer.from(key), value: 0 };
+    states.set(connection, state);
+  }
+  if (state.value >= 0xffffffff) throw new RangeError('Voice encryption nonce exhausted; establish a new session key');
+  const nonce = Buffer.alloc(mode === 'aead_aes256_gcm_rtpsize' ? 12 : 24);
+  nonce.writeUInt32BE(++state.value);
+  let ciphertext;
+  if (mode === 'aead_aes256_gcm_rtpsize') {
+    const cipher = crypto.createCipheriv('aes-256-gcm', key, nonce);
+    cipher.setAAD(header);
+    ciphertext = Buffer.concat([cipher.update(payload), cipher.final(), cipher.getAuthTag()]);
+  } else if (mode === 'aead_xchacha20_poly1305_rtpsize') {
+    ciphertext = Buffer.from(secretbox.methods.crypto_aead_xchacha20poly1305_ietf_encrypt(payload, header, nonce, key));
+  } else {
+    throw new RangeError(`Unsupported encryption method: ${mode}`);
+  }
+  return [ciphertext, nonce.subarray(0, 4)];
+}
+
+function decrypt(connection, packet, headerSize) {
+  const { secret_key: key, mode } = connection.authentication;
+  if (!key || packet.length < headerSize + 20) throw new RangeError('Truncated encrypted media packet');
+  const header = packet.subarray(0, headerSize);
+  const nonce = Buffer.alloc(mode === 'aead_aes256_gcm_rtpsize' ? 12 : 24);
+  packet.copy(nonce, 0, packet.length - 4);
+  const ciphertext = packet.subarray(headerSize, packet.length - 4);
+  let plain;
+  if (mode === 'aead_aes256_gcm_rtpsize') {
+    const cipher = crypto.createDecipheriv('aes-256-gcm', key, nonce);
+    cipher.setAAD(header);
+    cipher.setAuthTag(ciphertext.subarray(-16));
+    plain = Buffer.concat([cipher.update(ciphertext.subarray(0, -16)), cipher.final()]);
+  } else if (mode === 'aead_xchacha20_poly1305_rtpsize') {
+    plain = Buffer.from(secretbox.methods.crypto_aead_xchacha20poly1305_ietf_decrypt(ciphertext, header, nonce, key));
+  } else {
+    throw new RangeError(`Unsupported decryption method: ${mode}`);
+  }
+  return Buffer.concat([header, plain]);
+}
+
+module.exports = { encrypt, decrypt };

package/src/client/voice/util/VideoFrames.js

@@ -132,7 +132,7 @@ class VideoFrames {
     this.completed = new Map();
   }
 
-  push(packet, codec) {
+  push(packet, codec, validate) {
     const { ssrc, timestamp, sequenceNumber: seq, marker } = packet.header;
     const now = Date.now();
     const key = `${ssrc}:${timestamp}:${codec}`;
@@ -169,6 +169,9 @@ class VideoFrames {
     }
     try {
       const complete = depacketize(payloads, codec);
+      // A marker and contiguous tail do not prove the beginning arrived. DAVE
+      // authentication must succeed before suppressing subsequent RTX fragments.
+      if (validate && !validate(complete)) return null;
       this.frames.delete(key);
       if (this.completed.size >= 128) this.completed.delete(this.completed.keys().next().value);
       this.completed.set(key, now);

package/typings/index.d.ts

@@ -1255,6 +1255,7 @@ export class Recorder<Ready extends boolean = boolean, T = any> extends EventEmi
   public output: Writable | string;
   public userId: Snowflake;
   public feed(payload: RtpPacket | BufferResolvable): void;
+  public stop(): Promise<void>;
   public on(event: 'ready' | 'closed', listener: (recorder: Recorder<true, T>) => void): this;
   public once(event: 'ready' | 'closed', listener: (recorder: Recorder<true, T>) => void): this;
   public destroy(): void;