discord-sb.js 1.0.0

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

@@ -0,0 +1,260 @@
+'use strict';
+
+const EventEmitter = require('events');
+const { Buffer } = require('node:buffer');
+const crypto = require('node:crypto');
+const { setTimeout } = require('node:timers');
+const { RtpPacket } = require('werift-rtp');
+const Recorder = require('./Recorder');
+const Speaking = require('../../../util/Speaking');
+const Util = require('../../../util/Util');
+const secretbox = require('../util/Secretbox');
+const { SILENCE_FRAME } = require('../util/Silence');
+
+// The delay between packets when a user is considered to have stopped speaking
+// https://github.com/discordjs/discord.js/issues/3524#issuecomment-540373200
+const DISCORD_SPEAKING_DELAY = 250;
+
+// Unused: const HEADER_EXTENSION_BYTE = Buffer.from([0xbe, 0xde]);
+const UNPADDED_NONCE_LENGTH = 4;
+const AUTH_TAG_LENGTH = 16;
+
+class Readable extends require('stream').Readable {
+  _read() {} // eslint-disable-line no-empty-function
+}
+
+class PacketHandler extends EventEmitter {
+  constructor(receiver) {
+    super();
+    this.receiver = receiver;
+    this.streams = new Map();
+    this.videoStreams = new Map();
+    this.speakingTimeouts = new Map();
+  }
+
+  getNonceBuffer() {
+    return this.receiver.connection.authentication.mode === 'aead_aes256_gcm_rtpsize'
+      ? Buffer.alloc(12)
+      : Buffer.alloc(24);
+  }
+
+  get connection() {
+    return this.receiver.connection;
+  }
+
+  _stoppedSpeaking(userId) {
+    const streamInfo = this.streams.get(userId);
+    if (streamInfo && streamInfo.end === 'silence') {
+      this.streams.delete(userId);
+      streamInfo.stream.push(null);
+    }
+  }
+
+  makeStream(user, end) {
+    if (this.streams.has(user)) return this.streams.get(user).stream;
+    const stream = new Readable();
+    stream.on('end', () => this.streams.delete(user));
+    this.streams.set(user, { stream, end });
+    return stream;
+  }
+
+  makeVideoStream(user, output) {
+    if (this.videoStreams.has(user)) return this.videoStreams.get(user);
+    const stream = new Recorder(this, {
+      userId: user,
+      output,
+      portUdpH264: 65506,
+      portUdpOpus: 65510,
+    });
+    stream.on('ready', () => {
+      this.videoStreams.set(user, stream);
+    });
+    return stream;
+  }
+
+  parseBuffer(buffer) {
+    const { secret_key, mode } = this.receiver.connection.authentication;
+    // Open packet
+    if (!secret_key) return new Error('secret_key cannot be null or undefined');
+    const nonce = this.getNonceBuffer();
+    // Copy the last 4 bytes of unpadded nonce to the padding of (12 - 4) or (24 - 4) bytes
+    buffer.copy(nonce, 0, buffer.length - UNPADDED_NONCE_LENGTH);
+
+    let headerSize = 12;
+    const first = buffer.readUint8();
+    if ((first >> 4) & 0x01) headerSize += 4;
+
+    // The unencrypted RTP header contains 12 bytes, HEADER_EXTENSION and the extension size
+    const header = buffer.slice(0, headerSize);
+
+    // Encrypted contains the extension, if any, the opus packet, and the auth tag
+    const encrypted = buffer.slice(headerSize, buffer.length - AUTH_TAG_LENGTH - UNPADDED_NONCE_LENGTH);
+    const authTag = buffer.slice(
+      buffer.length - AUTH_TAG_LENGTH - UNPADDED_NONCE_LENGTH,
+      buffer.length - UNPADDED_NONCE_LENGTH,
+    );
+
+    let packet;
+    switch (mode) {
+      case 'aead_aes256_gcm_rtpsize': {
+        const decipheriv = crypto.createDecipheriv('aes-256-gcm', secret_key, nonce);
+        decipheriv.setAAD(header);
+        decipheriv.setAuthTag(authTag);
+
+        packet = Buffer.concat([decipheriv.update(encrypted), decipheriv.final()]);
+        break;
+      }
+      case 'aead_xchacha20_poly1305_rtpsize': {
+        // Combined mode expects authtag in the encrypted message
+        packet = secretbox.methods.crypto_aead_xchacha20poly1305_ietf_decrypt(
+          Buffer.concat([encrypted, authTag]),
+          header,
+          nonce,
+          secret_key,
+        );
+
+        packet = Buffer.from(packet);
+        break;
+      }
+      default: {
+        return new RangeError(`Unsupported decryption method: ${mode}`);
+      }
+    }
+
+    /*
+    // Strip decrypted RTP Header Extension if present
+    if (buffer.slice(12, 14).compare(HEADER_EXTENSION_BYTE) === 0) {
+      const headerExtensionLength = buffer.slice(14).readUInt16BE();
+      packet = packet.subarray(4 * headerExtensionLength);
+    }
+    */
+
+    return RtpPacket.deSerialize(Buffer.concat([header, packet]));
+  }
+
+  audioReceiver(ssrc, userStat, opusPacket) {
+    const streamInfo = this.streams.get(userStat.userId);
+    // If the user is in video, we need to check if the packet is just silence
+    if (userStat.hasVideo) {
+      if (opusPacket instanceof Error) {
+        // Only emit an error if we were actively receiving packets from this user
+        if (streamInfo) {
+          this.emit('error', opusPacket);
+        }
+        return;
+      }
+      // Check payload type
+      if (opusPacket.header.payloadType !== Util.getPayloadType('opus')) {
+        return;
+      }
+      if (!opusPacket.payload) {
+        return;
+      }
+      if (SILENCE_FRAME.equals(opusPacket.payload)) {
+        // If this is a silence frame, pretend we never received it
+        return;
+      }
+    }
+
+    let speakingTimeout = this.speakingTimeouts.get(ssrc);
+    if (typeof speakingTimeout === 'undefined') {
+      // Ensure at least the speaking bit is set.
+      // As the object is by reference, it's only needed once per client re-connect.
+      if (userStat.speaking === 0) {
+        userStat.speaking = Speaking.FLAGS.SPEAKING;
+      }
+      this.connection.onSpeaking({ user_id: userStat.userId, ssrc: ssrc, speaking: userStat.speaking });
+      speakingTimeout = setTimeout(() => {
+        try {
+          this.connection.onSpeaking({ user_id: userStat.userId, ssrc: ssrc, speaking: 0 });
+          clearTimeout(speakingTimeout);
+          this.speakingTimeouts.delete(ssrc);
+        } catch {
+          // Connection already closed, ignore
+        }
+      }, DISCORD_SPEAKING_DELAY).unref();
+      this.speakingTimeouts.set(ssrc, speakingTimeout);
+    } else {
+      speakingTimeout.refresh();
+    }
+
+    if (streamInfo) {
+      const { stream } = streamInfo;
+      if (opusPacket instanceof Error) {
+        this.emit('error', opusPacket);
+        return;
+      }
+      if (opusPacket.header.payloadType !== Util.getPayloadType('opus')) {
+        return;
+      }
+      stream.push(opusPacket.payload);
+    }
+  }
+
+  audioReceiverForStream(ssrc, userStat, packet) {
+    const streamInfo = this.videoStreams.get(userStat.userId);
+    if (!streamInfo) return;
+    if (packet instanceof Error) {
+      return;
+    }
+    if (packet.header.payloadType !== Util.getPayloadType('opus')) {
+      return;
+    }
+    streamInfo.feed(packet);
+  }
+
+  /**
+   * Test
+   * @param {number} ssrc ssrc
+   * @param {Object} userStat { userId, hasVideo }
+   * @param {RtpPacket} packet RtpPacket
+   * @returns {void}
+   */
+  videoReceiver(ssrc, userStat, packet) {
+    const streamInfo = this.videoStreams.get(userStat.userId);
+    // If the user is in video, we need to check if the packet is just silence
+    if (userStat.hasVideo) {
+      if (packet instanceof Error) {
+        return;
+      }
+
+      if (packet.header.payloadType === Util.getPayloadType('opus')) {
+        return;
+      }
+
+      if (streamInfo) {
+        streamInfo.feed(packet);
+      }
+    }
+  }
+
+  push(buffer) {
+    const ssrc = buffer.readUInt32BE(8);
+    let userStat, packet;
+    if (this.connection.ssrcMap.has(ssrc)) {
+      userStat = this.connection.ssrcMap.get(ssrc); // Audio_ssrc
+      packet = this.parseBuffer(buffer);
+      this.audioReceiver(ssrc, userStat, packet);
+      this.audioReceiverForStream(ssrc, userStat, packet);
+    } else if (this.connection.ssrcMap.has(ssrc - 1)) {
+      userStat = this.connection.ssrcMap.get(ssrc - 1); // Video_ssrc
+      packet = this.parseBuffer(buffer);
+      this.videoReceiver(ssrc, userStat, packet);
+    }
+    if (userStat && !(packet instanceof Error)) this.receiver.emit('receiverData', userStat, packet);
+  }
+
+  // When udp connection is closed (STREAM_DELETE), destroy all streams (Memory leak)
+  destroyAllStream() {
+    for (const stream of this.streams.values()) {
+      stream.stream.destroy();
+    }
+    this.streams.clear();
+    for (const stream of this.videoStreams.values()) {
+      stream.destroy();
+    }
+    this.videoStreams.clear();
+  }
+}
+
+module.exports = PacketHandler;

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

@@ -0,0 +1,96 @@
+'use strict';
+
+const EventEmitter = require('events');
+const prism = require('prism-media');
+const PacketHandler = require('./PacketHandler');
+const { Error } = require('../../../errors');
+const { PCMInsertSilence } = require('../player/processing/PCMInsertSilence');
+
+/**
+ * Receives audio packets from a voice connection.
+ * @example
+ * const receiver = connection.createReceiver();
+ * // opusStream is a ReadableStream - that means you could play it back to a voice channel if you wanted to!
+ * const opusStream = receiver.createStream(user);
+ */
+class VoiceReceiver extends EventEmitter {
+  constructor(connection) {
+    super();
+    this.connection = connection;
+    this.packets = new PacketHandler(this);
+    /**
+     * Emitted whenever there is a warning
+     * @event VoiceReceiver#debug
+     * @param {Error|string} error The error or message to debug
+     */
+    this.packets.on('error', err => this.emit('debug', err));
+  }
+
+  /**
+   * Options passed to `VoiceReceiver#createStream`.
+   * @typedef {Object} ReceiveStreamOptions
+   * @property {string} [mode='opus'] The mode for audio output. This defaults to opus, meaning discord.js won't decode
+   * the packets for you. You can set this to 'pcm' so that the stream's output will be 16-bit little-endian stereo
+   * audio
+   * @property {string} [end='silence'] When the stream should be destroyed. If `silence`, this will be when the user
+   * stops talking. Otherwise, if `manual`, this should be handled by you.
+   * @property {boolean} [paddingSilence=false] Whether to add silence padding
+   * If 'end' is set to 'silence', this property automatically defaults to `false`
+   */
+
+  /**
+   * Creates a new audio receiving stream. If a stream already exists for a user, then that stream will be returned
+   * rather than generating a new one.
+   * @param {UserResolvable} user The user to start listening to.
+   * @param {ReceiveStreamOptions} options Options.
+   * @returns {ReadableStream}
+   */
+  createStream(user, { mode = 'opus', end = 'silence', paddingSilence = false } = {}) {
+    user = this.connection.client.users.resolve(user);
+    if (end === 'silence') paddingSilence = false;
+    if (!user) throw new Error('VOICE_USER_MISSING');
+    const stream = this.packets.makeStream(user.id, end); // Opus stream
+    if (paddingSilence) {
+      const decoder = new prism.opus.Decoder({ channels: 2, rate: 48000, frameSize: 960 });
+      const pcmTransformer = new PCMInsertSilence();
+      stream.pipe(decoder).pipe(pcmTransformer);
+      if (mode === 'opus') {
+        const encoder = new prism.opus.Encoder({ channels: 2, rate: 48000, frameSize: 960 });
+        pcmTransformer.pipe(encoder);
+        return encoder;
+      }
+      return pcmTransformer;
+    } else {
+      if (mode === 'pcm') {
+        const decoder = new prism.opus.Decoder({ channels: 2, rate: 48000, frameSize: 960 });
+        stream.pipe(decoder);
+        return decoder;
+      }
+      return stream;
+    }
+  }
+
+  /**
+   * 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>
+   * @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.
+   */
+  createVideoStream(user, output) {
+    user = this.connection.client.users.resolve(user);
+    if (!user) throw new Error('VOICE_USER_MISSING');
+    const stream = this.packets.makeVideoStream(user.id, output);
+    return stream;
+  }
+
+  /**
+   * Emitted whenever there is a data packet received.
+   * @event VoiceReceiver#receiverData
+   * @param {{ userId: Snowflake, hasVideo: boolean }} ssrcData SSRC Data
+   * @param {RtpPacket} header RTP Packet
+   */
+}
+
+module.exports = VoiceReceiver;

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

@@ -0,0 +1,173 @@
+'use strict';
+
+const { spawn } = require('child_process');
+const { createSocket } = require('dgram');
+const { EventEmitter } = require('events');
+const { Buffer } = require('node:buffer');
+const { Writable } = require('stream');
+const find = require('find-process');
+const kill = require('tree-kill');
+const { RtpPacket } = require('werift-rtp');
+const Util = require('../../../util/Util');
+const { randomPorts } = require('../util/Function');
+const { StreamOutput } = require('../util/Socket');
+
+/**
+ * Represents a FFmpeg handler
+ * @extends {EventEmitter}
+ */
+class Recorder extends EventEmitter {
+  constructor(receiver, { userId, portUdpH264, portUdpOpus, output } = {}) {
+    super();
+
+    Object.defineProperty(this, 'receiver', { value: receiver });
+
+    /**
+     * The user ID
+     * @type {Snowflake}
+     */
+    this.userId = userId;
+
+    this.portUdpH264 = portUdpH264;
+    this.portUdpH265 = null;
+    this.portUdpOpus = portUdpOpus;
+
+    this.promise = null;
+
+    if (!portUdpH264 || !portUdpOpus) {
+      this.promise = randomPorts(6, 'udp4').then(ports => {
+        ports = ports.filter(port => port % 2 === 0);
+        this.portUdpH264 ??= ports[0];
+        this.portUdpOpus ??= ports[1];
+      });
+    }
+
+    /**
+     * The output of the stream
+     * @type {string|Readable}
+     */
+    this.output = output;
+
+    /**
+     * The FFmpeg process is ready or not
+     * @type {boolean}
+     */
+    this.ready = false;
+
+    this.socket = createSocket('udp4');
+
+    this.init(output);
+  }
+  async init(output) {
+    await this.promise;
+    const sdpData = Util.getSDPCodecName(this.portUdpH264, this.portUdpH265, this.portUdpOpus);
+    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,
+    ]);
+
+    /**
+     * The FFmpeg process
+     * @type {ChildProcessWithoutNullStreams}
+     */
+    this.stream = stream;
+    this.stream.stdin.write(sdpData);
+    this.stream.stdin.end();
+    this.stream.stderr.once('data', data => {
+      this.emit('debug', `stderr: ${data}`);
+      this.ready = true;
+      this.emit('ready');
+    });
+  }
+  /**
+   * Send a payload to FFmpeg via UDP
+   * @param {RtpPacket|string|Buffer} payload The payload
+   * @param {*} callback Callback
+   */
+  feed(
+    payload,
+    callback = e => {
+      if (e) {
+        console.error('Error sending packet:', e);
+      }
+    },
+  ) {
+    if (!(payload instanceof RtpPacket)) {
+      payload = RtpPacket.deSerialize(Buffer.isBuffer(payload) ? payload : Buffer.from(payload));
+    }
+    const message = payload.serialize();
+    // Get port from payloadType
+    let port;
+    if (payload.header.payloadType === Util.getPayloadType('opus')) {
+      port = this.portUdpOpus;
+    } else if (payload.header.payloadType === Util.getPayloadType('H264')) {
+      port = this.portUdpH264;
+    } else if (payload.header.payloadType === Util.getPayloadType('H265')) {
+      port = this.portUdpH265;
+    } else {
+      return;
+    }
+    this.socket.send(message, 0, message.length, port, '127.0.0.1', callback);
+  }
+
+  destroy() {
+    const ffmpegPid = this.stream.pid; // But it is ppid ;-;
+    const args = this.stream.spawnargs.slice(1).join(' '); // Skip ffmpeg
+    find('name', 'ffmpeg', true).then(list => {
+      let process = list.find(o => o.pid === ffmpegPid || o.ppid === ffmpegPid || o.cmd.includes(args));
+      if (process) {
+        kill(process.pid);
+        this.receiver?.videoStreams?.delete(this.userId);
+        this.emit('closed');
+      }
+    });
+  }
+
+  /**
+   * Emitted when the Recorder becomes ready to start working.
+   * @event Recorder#ready
+   */
+
+  /**
+   * Emitted when the Recorder is closed.
+   * @event Recorder#closed
+   */
+}
+
+module.exports = Recorder;

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

@@ -0,0 +1,116 @@
+'use strict';
+
+const dgram = require('dgram');
+const { setImmediate } = require('node:timers');
+
+/**
+ * @typedef {Object} InterfaceAddresses
+ * @property {string} [udp4] - IPv4 address
+ * @property {string} [udp6] - IPv6 address
+ */
+
+/**
+ * Get the interface address for a given socket type.
+ * @param {"udp4"|"udp6"} type - The socket type.
+ * @param {InterfaceAddresses} [interfaceAddresses] - The interface addresses mapping.
+ * @returns {string|undefined} The interface address if available.
+ */
+function interfaceAddress(type, interfaceAddresses) {
+  return interfaceAddresses ? interfaceAddresses[type] : undefined;
+}
+
+/**
+ * Get a random available port.
+ * @param {"udp4"|"udp6"} [protocol="udp4"] - The socket type.
+ * @param {InterfaceAddresses} [interfaceAddresses] - The interface addresses mapping.
+ * @returns {Promise<number>} The assigned random port.
+ */
+async function randomPort(protocol = 'udp4', interfaceAddresses) {
+  const socket = dgram.createSocket(protocol);
+
+  setImmediate(() =>
+    socket.bind({
+      port: 0,
+      address: interfaceAddress(protocol, interfaceAddresses),
+    }),
+  );
+
+  await new Promise((resolve, reject) => {
+    socket.once('error', reject);
+    socket.once('listening', resolve);
+  });
+
+  const port = socket.address()?.port;
+  await new Promise(resolve => socket.close(resolve));
+  return port;
+}
+
+/**
+ * Get multiple random available ports.
+ * @param {number} num - Number of ports to find.
+ * @param {"udp4"|"udp6"} [protocol="udp4"] - The socket type.
+ * @param {InterfaceAddresses} [interfaceAddresses] - The interface addresses mapping.
+ * @returns {Promise<number[]>} An array of assigned random ports.
+ */
+async function randomPorts(num, protocol = 'udp4', interfaceAddresses) {
+  return Promise.all(Array.from({ length: num }).map(() => randomPort(protocol, interfaceAddresses)));
+}
+
+/**
+ * Find an available port within a given range.
+ * @param {number} min - The minimum port number.
+ * @param {number} max - The maximum port number.
+ * @param {"udp4"|"udp6"} [protocol="udp4"] - The socket type.
+ * @param {InterfaceAddresses} [interfaceAddresses] - The interface addresses mapping.
+ * @returns {Promise<number>} The available port within range.
+ * @throws {Error} If no port is found within the range.
+ */
+async function findPort(min, max, protocol = 'udp4', interfaceAddresses) {
+  let port;
+
+  for (let i = min; i <= max; i++) {
+    const socket = dgram.createSocket(protocol);
+
+    setImmediate(() =>
+      socket.bind({
+        port: i,
+        address: interfaceAddress(protocol, interfaceAddresses),
+      }),
+    );
+
+    const error = await new Promise(resolve => {
+      socket.once('error', resolve);
+      socket.once('listening', () => resolve(null));
+    });
+
+    await new Promise(resolve => socket.close(resolve));
+
+    if (error) continue;
+
+    const addressInfo = socket.address();
+    if (addressInfo && addressInfo.port >= min && addressInfo.port <= max) {
+      port = addressInfo.port;
+      break;
+    }
+  }
+
+  if (!port) throw new Error('port not found');
+  return port;
+}
+
+function parseStreamKey(key) {
+  const Arr = key.split(':');
+  const type = Arr[0];
+  const guildId = type == 'guild' ? Arr[1] : null;
+  const channelId = type == 'guild' ? Arr[2] : Arr[1];
+  const userId = type == 'guild' ? Arr[3] : Arr[2];
+  return { type, guildId, channelId, userId };
+}
+
+module.exports = {
+  randomPort,
+  randomPorts,
+  findPort,
+  interfaceAddress,
+  parseStreamKey,
+};