discord.js-selfv13 13.0.1

package/src/client/voice/VoiceWebSocket.js

@@ -0,0 +1,246 @@
+const Constants = require('../../util/Constants');
+const SecretKey = require('./util/SecretKey');
+const EventEmitter = require('events').EventEmitter;
+
+let WebSocket;
+try {
+  WebSocket = require('@discordjs/uws');
+} catch (err) {
+  WebSocket = require('ws');
+}
+
+/**
+ * Represents a Voice Connection's WebSocket.
+ * @extends {EventEmitter}
+ * @private
+ */
+class VoiceWebSocket extends EventEmitter {
+  constructor(voiceConnection) {
+    super();
+
+    /**
+     * The client of this voice WebSocket
+     * @type {Client}
+     */
+    this.client = voiceConnection.voiceManager.client;
+
+    /**
+     * The Voice Connection that this WebSocket serves
+     * @type {VoiceConnection}
+     */
+    this.voiceConnection = voiceConnection;
+
+    /**
+     * How many connection attempts have been made
+     * @type {number}
+     */
+    this.attempts = 0;
+
+    this.connect();
+    this.dead = false;
+    this.voiceConnection.on('closing', this.shutdown.bind(this));
+  }
+
+  shutdown() {
+    this.dead = true;
+    this.reset();
+  }
+
+  /**
+   * Resets the current WebSocket.
+   */
+  reset() {
+    if (this.ws) {
+      if (this.ws.readyState !== WebSocket.CLOSED) this.ws.close();
+      this.ws = null;
+    }
+    this.clearHeartbeat();
+  }
+
+  /**
+   * Starts connecting to the Voice WebSocket Server.
+   */
+  connect() {
+    if (this.dead) return;
+    if (this.ws) this.reset();
+    if (this.attempts >= 5) {
+      this.emit('debug', new Error(`Too many connection attempts (${this.attempts}).`));
+      return;
+    }
+
+    this.attempts++;
+
+    /**
+     * The actual WebSocket used to connect to the Voice WebSocket Server.
+     * @type {WebSocket}
+     */
+    this.ws = new WebSocket(`wss://${this.voiceConnection.authentication.endpoint}`);
+    this.ws.onopen = this.onOpen.bind(this);
+    this.ws.onmessage = this.onMessage.bind(this);
+    this.ws.onclose = this.onClose.bind(this);
+    this.ws.onerror = this.onError.bind(this);
+  }
+
+  /**
+   * Sends data to the WebSocket if it is open.
+   * @param {string} data The data to send to the WebSocket
+   * @returns {Promise<string>}
+   */
+  send(data) {
+    return new Promise((resolve, reject) => {
+      if (!this.ws || this.ws.readyState !== WebSocket.OPEN) {
+        throw new Error(`Voice websocket not open to send ${data}.`);
+      }
+      this.ws.send(data, null, error => {
+        if (error) reject(error); else resolve(data);
+      });
+    });
+  }
+
+  /**
+   * JSON.stringify's a packet and then sends it to the WebSocket Server.
+   * @param {Object} packet The packet to send
+   * @returns {Promise<string>}
+   */
+  sendPacket(packet) {
+    try {
+      packet = JSON.stringify(packet);
+    } catch (error) {
+      return Promise.reject(error);
+    }
+    return this.send(packet);
+  }
+
+  /**
+   * Called whenever the WebSocket opens.
+   */
+  onOpen() {
+    this.sendPacket({
+      op: Constants.OPCodes.DISPATCH,
+      d: {
+        server_id: this.voiceConnection.channel.guild.id,
+        user_id: this.client.user.id,
+        token: this.voiceConnection.authentication.token,
+        session_id: this.voiceConnection.authentication.sessionID,
+      },
+    }).catch(() => {
+      this.emit('error', new Error('Tried to send join packet, but the WebSocket is not open.'));
+    });
+  }
+
+  /**
+   * Called whenever a message is received from the WebSocket.
+   * @param {MessageEvent} event The message event that was received
+   * @returns {void}
+   */
+  onMessage(event) {
+    try {
+      return this.onPacket(JSON.parse(event.data));
+    } catch (error) {
+      return this.onError(error);
+    }
+  }
+
+  /**
+   * Called whenever the connection to the WebSocket server is lost.
+   */
+  onClose() {
+    if (!this.dead) this.client.setTimeout(this.connect.bind(this), this.attempts * 1000);
+  }
+
+  /**
+   * Called whenever an error occurs with the WebSocket.
+   * @param {Error} error The error that occurred
+   */
+  onError(error) {
+    this.emit('error', error);
+  }
+
+  /**
+   * Called whenever a valid packet is received from the WebSocket.
+   * @param {Object} packet The received packet
+   */
+  onPacket(packet) {
+    switch (packet.op) {
+      case Constants.VoiceOPCodes.READY:
+        this.setHeartbeat(packet.d.heartbeat_interval);
+        /**
+         * Emitted once the voice WebSocket receives the ready packet.
+         * @param {Object} packet The received packet
+         * @event VoiceWebSocket#ready
+         */
+        this.emit('ready', packet.d);
+        break;
+      case Constants.VoiceOPCodes.SESSION_DESCRIPTION:
+        /**
+         * Emitted once the Voice Websocket receives a description of this voice session.
+         * @param {string} encryptionMode The type of encryption being used
+         * @param {SecretKey} secretKey The secret key used for encryption
+         * @event VoiceWebSocket#sessionDescription
+         */
+        this.emit('sessionDescription', packet.d.mode, new SecretKey(packet.d.secret_key));
+        break;
+      case Constants.VoiceOPCodes.SPEAKING:
+        /**
+         * Emitted whenever a speaking packet is received.
+         * @param {Object} data
+         * @event VoiceWebSocket#speaking
+         */
+        this.emit('speaking', packet.d);
+        break;
+      default:
+        /**
+         * Emitted when an unhandled packet is received.
+         * @param {Object} packet
+         * @event VoiceWebSocket#unknownPacket
+         */
+        this.emit('unknownPacket', packet);
+        break;
+    }
+  }
+
+  /**
+   * Sets an interval at which to send a heartbeat packet to the WebSocket.
+   * @param {number} interval The interval at which to send a heartbeat packet
+   */
+  setHeartbeat(interval) {
+    if (!interval || isNaN(interval)) {
+      this.onError(new Error('Tried to set voice heartbeat but no valid interval was specified.'));
+      return;
+    }
+    if (this.heartbeatInterval) {
+      /**
+       * Emitted whenver the voice WebSocket encounters a non-fatal error.
+       * @param {string} warn The warning
+       * @event VoiceWebSocket#warn
+       */
+      this.emit('warn', 'A voice heartbeat interval is being overwritten');
+      clearInterval(this.heartbeatInterval);
+    }
+    this.heartbeatInterval = this.client.setInterval(this.sendHeartbeat.bind(this), interval);
+  }
+
+  /**
+   * Clears a heartbeat interval, if one exists.
+   */
+  clearHeartbeat() {
+    if (!this.heartbeatInterval) {
+      this.emit('warn', 'Tried to clear a heartbeat interval that does not exist');
+      return;
+    }
+    clearInterval(this.heartbeatInterval);
+    this.heartbeatInterval = null;
+  }
+
+  /**
+   * Sends a heartbeat packet.
+   */
+  sendHeartbeat() {
+    this.sendPacket({ op: Constants.VoiceOPCodes.HEARTBEAT, d: null }).catch(() => {
+      this.emit('warn', 'Tried to send heartbeat, but connection is not open');
+      this.clearHeartbeat();
+    });
+  }
+}
+
+module.exports = VoiceWebSocket;

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

@@ -0,0 +1,331 @@
+const VolumeInterface = require('../util/VolumeInterface');
+const VoiceBroadcast = require('../VoiceBroadcast');
+const Constants = require('../../../util/Constants');
+
+const secretbox = require('../util/Secretbox');
+
+const nonce = Buffer.alloc(24);
+nonce.fill(0);
+
+/**
+ * The class that sends voice packet data to the voice connection.
+ * ```js
+ * // Obtained using:
+ * voiceChannel.join().then(connection => {
+ *   // You can play a file or a stream here:
+ *   const dispatcher = connection.playFile('./file.mp3');
+ * });
+ * ```
+ * @implements {VolumeInterface}
+ */
+class StreamDispatcher extends VolumeInterface {
+  constructor(player, stream, streamOptions) {
+    super(streamOptions);
+    /**
+     * The Audio Player that controls this dispatcher
+     * @type {AudioPlayer}
+     */
+    this.player = player;
+    /**
+     * The stream that the dispatcher plays
+     * @type {ReadableStream|VoiceBroadcast}
+     */
+    this.stream = stream;
+    if (!(this.stream instanceof VoiceBroadcast)) this.startStreaming();
+    this.streamOptions = streamOptions;
+
+    const data = this.streamingData;
+    data.length = 20;
+    data.missed = 0;
+
+    /**
+     * Whether playing is paused
+     * @type {boolean}
+     */
+    this.paused = false;
+    /**
+     * Whether this dispatcher has been destroyed
+     * @type {boolean}
+     */
+    this.destroyed = false;
+
+    this._opus = streamOptions.opus;
+  }
+
+  /**
+   * How many passes the dispatcher should take when sending packets to reduce packet loss. Values over 5
+   * aren't recommended, as it means you are using 5x more bandwidth. You _can_ edit this at runtime
+   * @type {number}
+   * @readonly
+   */
+  get passes() {
+    return this.streamOptions.passes || 1;
+  }
+
+  set passes(n) {
+    this.streamOptions.passes = n;
+  }
+
+  get streamingData() {
+    return this.player.streamingData;
+  }
+
+  /**
+   * How long the stream dispatcher has been "speaking" for
+   * @type {number}
+   * @readonly
+   */
+  get time() {
+    return this.streamingData.count * (this.streamingData.length || 0);
+  }
+
+  /**
+   * The total time, taking into account pauses and skips, that the dispatcher has been streaming for
+   * @type {number}
+   * @readonly
+   */
+  get totalStreamTime() {
+    return this.time + this.streamingData.pausedTime;
+  }
+
+  /**
+   * Stops sending voice packets to the voice connection (stream may still progress however).
+   */
+  pause() { this.setPaused(true); }
+
+  /**
+   * Resumes sending voice packets to the voice connection (may be further on in the stream than when paused).
+   */
+  resume() { this.setPaused(false); }
+
+
+  /**
+   * Stops the current stream permanently and emits an `end` event.
+   * @param {string} [reason='user'] An optional reason for stopping the dispatcher
+   */
+  end(reason = 'user') {
+    this.destroy('end', reason);
+  }
+
+  setSpeaking(value) {
+    if (this.speaking === value) return;
+    if (this.player.voiceConnection.status !== Constants.VoiceStatus.CONNECTED) return;
+    this.speaking = value;
+    /**
+     * Emitted when the dispatcher starts/stops speaking.
+     * @event StreamDispatcher#speaking
+     * @param {boolean} value Whether or not the dispatcher is speaking
+     */
+    this.emit('speaking', value);
+  }
+
+
+  /**
+   * Set the bitrate of the current Opus encoder.
+   * @param {number} bitrate New bitrate, in kbps
+   * If set to 'auto', the voice channel's bitrate will be used
+   */
+  setBitrate(bitrate) {
+    this.player.setBitrate(bitrate);
+  }
+
+  sendBuffer(buffer, sequence, timestamp, opusPacket) {
+    opusPacket = opusPacket || this.player.opusEncoder.encode(buffer);
+    const packet = this.createPacket(sequence, timestamp, opusPacket);
+    this.sendPacket(packet);
+  }
+
+  sendPacket(packet) {
+    let repeats = this.passes;
+    /**
+     * Emitted whenever the dispatcher has debug information.
+     * @event StreamDispatcher#debug
+     * @param {string} info The debug info
+     */
+    this.setSpeaking(true);
+    while (repeats-- && this.player.voiceConnection.sockets.udp) {
+      this.player.voiceConnection.sockets.udp.send(packet)
+        .catch(e => {
+          this.setSpeaking(false);
+          this.emit('debug', `Failed to send a packet ${e}`);
+        });
+    }
+  }
+
+  createPacket(sequence, timestamp, buffer) {
+    const packetBuffer = Buffer.alloc(buffer.length + 28);
+    packetBuffer.fill(0);
+    packetBuffer[0] = 0x80;
+    packetBuffer[1] = 0x78;
+
+    packetBuffer.writeUIntBE(sequence, 2, 2);
+    packetBuffer.writeUIntBE(timestamp, 4, 4);
+    packetBuffer.writeUIntBE(this.player.voiceConnection.authentication.ssrc, 8, 4);
+
+    packetBuffer.copy(nonce, 0, 0, 12);
+    buffer = secretbox.methods.close(buffer, nonce, this.player.voiceConnection.authentication.secretKey.key);
+    for (let i = 0; i < buffer.length; i++) packetBuffer[i + 12] = buffer[i];
+
+    return packetBuffer;
+  }
+
+  processPacket(packet) {
+    try {
+      if (this.destroyed || !this.player.voiceConnection.authentication.secretKey) {
+        this.setSpeaking(false);
+        return;
+      }
+
+      const data = this.streamingData;
+
+      if (this.paused) {
+        this.setSpeaking(false);
+        data.pausedTime = data.length * 10;
+        return;
+      }
+
+      if (!packet) {
+        data.missed++;
+        data.pausedTime += data.length * 10;
+        return;
+      }
+
+      this.started();
+      this.missed = 0;
+
+      this.stepStreamingData();
+      this.sendBuffer(null, data.sequence, data.timestamp, packet);
+    } catch (e) {
+      this.destroy('error', e);
+    }
+  }
+
+  process() {
+    try {
+      if (this.destroyed) {
+        this.setSpeaking(false);
+        return;
+      }
+
+      const data = this.streamingData;
+
+      if (data.missed >= 5) {
+        this.destroy('end', 'Stream is not generating quickly enough.');
+        return;
+      }
+
+      if (this.paused) {
+        this.setSpeaking(false);
+        // Old code?
+        // data.timestamp = data.timestamp + 4294967295 ? data.timestamp + 960 : 0;
+        data.pausedTime += data.length * 10;
+        this.player.voiceConnection.voiceManager.client.setTimeout(() => this.process(), data.length * 10);
+        return;
+      }
+
+      this.started();
+
+      const buffer = this.readStreamBuffer();
+      if (!buffer) {
+        data.missed++;
+        data.pausedTime += data.length * 10;
+        this.player.voiceConnection.voiceManager.client.setTimeout(() => this.process(), data.length * 10);
+        return;
+      }
+
+      data.missed = 0;
+
+      this.stepStreamingData();
+
+      if (this._opus) {
+        this.sendBuffer(null, data.sequence, data.timestamp, buffer);
+      } else {
+        this.sendBuffer(buffer, data.sequence, data.timestamp);
+      }
+
+      const nextTime = data.length + (data.startTime + data.pausedTime + (data.count * data.length) - Date.now());
+      this.player.voiceConnection.voiceManager.client.setTimeout(() => this.process(), nextTime);
+    } catch (e) {
+      this.destroy('error', e);
+    }
+  }
+
+  readStreamBuffer() {
+    const data = this.streamingData;
+    const bufferLength = (this._opus ? 80 : 1920) * data.channels;
+    let buffer = this.stream.read(bufferLength);
+    if (this._opus) return buffer;
+    if (!buffer) return null;
+
+    if (buffer.length !== bufferLength) {
+      const newBuffer = Buffer.alloc(bufferLength).fill(0);
+      buffer.copy(newBuffer);
+      buffer = newBuffer;
+    }
+
+    buffer = this.applyVolume(buffer);
+    return buffer;
+  }
+
+  started() {
+    const data = this.streamingData;
+
+    if (!data.startTime) {
+      /**
+       * Emitted once the dispatcher starts streaming.
+       * @event StreamDispatcher#start
+       */
+      this.emit('start');
+      data.startTime = Date.now();
+    }
+  }
+
+  stepStreamingData() {
+    const data = this.streamingData;
+    data.count++;
+    data.sequence = data.sequence < 65535 ? data.sequence + 1 : 0;
+    data.timestamp = (data.timestamp + 960) < 4294967295 ? data.timestamp + 960 : 0;
+  }
+
+  destroy(type, reason) {
+    if (this.destroyed) return;
+    this.destroyed = true;
+    this.setSpeaking(false);
+    this.emit(type, reason);
+    /**
+     * Emitted once the dispatcher ends.
+     * @param {string} [reason] The reason the dispatcher ended
+     * @event StreamDispatcher#end
+     */
+    if (type !== 'end') this.emit('end', `destroyed due to ${type} - ${reason}`);
+  }
+
+  startStreaming() {
+    if (!this.stream) {
+      /**
+       * Emitted if the dispatcher encounters an error.
+       * @event StreamDispatcher#error
+       * @param {string} error The error message
+       */
+      this.emit('error', 'No stream');
+      return;
+    }
+
+    this.stream.on('end', err => this.destroy('end', err || 'stream'));
+    this.stream.on('error', err => this.destroy('error', err));
+
+    const data = this.streamingData;
+    data.length = 20;
+    data.missed = 0;
+
+    this.stream.once('readable', () => {
+      data.startTime = null;
+      data.count = 0;
+      this.process();
+    });
+  }
+
+  setPaused(paused) { this.setSpeaking(!(this.paused = paused)); }
+}
+
+module.exports = StreamDispatcher;

package/src/client/voice/opus/BaseOpusEngine.js

@@ -0,0 +1,60 @@
+/**
+ * The base opus encoding engine.
+ * @private
+ */
+class BaseOpus {
+  /**
+   * @param {Object} [options] The options to apply to the Opus engine
+   * @param {number} [options.bitrate=48] The desired bitrate (kbps)
+   * @param {boolean} [options.fec=false] Whether to enable forward error correction
+   * @param {number} [options.plp=0] The expected packet loss percentage
+   */
+  constructor({ bitrate = 48, fec = false, plp = 0 } = {}) {
+    this.ctl = {
+      BITRATE: 4002,
+      FEC: 4012,
+      PLP: 4014,
+    };
+
+    this.samplingRate = 48000;
+    this.channels = 2;
+
+    /**
+     * The desired bitrate (kbps)
+     * @type {number}
+     */
+    this.bitrate = bitrate;
+
+    /**
+     * Miscellaneous Opus options
+     * @type {Object}
+     */
+    this.options = { fec, plp };
+  }
+
+  init() {
+    try {
+      this.setBitrate(this.bitrate);
+
+      // Set FEC (forward error correction)
+      if (this.options.fec) this.setFEC(this.options.fec);
+
+      // Set PLP (expected packet loss percentage)
+      if (this.options.plp) this.setPLP(this.options.plp);
+    } catch (err) {
+      // Opus engine likely has no support for libopus CTL
+    }
+  }
+
+  encode(buffer) {
+    return buffer;
+  }
+
+  decode(buffer) {
+    return buffer;
+  }
+
+  destroy() {} // eslint-disable-line no-empty-function
+}
+
+module.exports = BaseOpus;

package/src/client/voice/opus/NodeOpusEngine.js

@@ -0,0 +1,40 @@
+const OpusEngine = require('./BaseOpusEngine');
+
+let opus;
+
+class NodeOpusEngine extends OpusEngine {
+  constructor(player) {
+    super(player);
+    try {
+      opus = require('node-opus');
+    } catch (err) {
+      throw err;
+    }
+    this.encoder = new opus.OpusEncoder(this.samplingRate, this.channels);
+    super.init();
+  }
+
+  setBitrate(bitrate) {
+    this.encoder.applyEncoderCTL(this.ctl.BITRATE, Math.min(128, Math.max(16, bitrate)) * 1000);
+  }
+
+  setFEC(enabled) {
+    this.encoder.applyEncoderCTL(this.ctl.FEC, enabled ? 1 : 0);
+  }
+
+  setPLP(percent) {
+    this.encoder.applyEncoderCTL(this.ctl.PLP, Math.min(100, Math.max(0, percent * 100)));
+  }
+
+  encode(buffer) {
+    super.encode(buffer);
+    return this.encoder.encode(buffer, 1920);
+  }
+
+  decode(buffer) {
+    super.decode(buffer);
+    return this.encoder.decode(buffer, 1920);
+  }
+}
+
+module.exports = NodeOpusEngine;

package/src/client/voice/opus/OpusEngineList.js

@@ -0,0 +1,28 @@
+const list = [
+  require('./NodeOpusEngine'),
+  require('./OpusScriptEngine'),
+];
+
+function fetch(Encoder, engineOptions) {
+  try {
+    return new Encoder(engineOptions);
+  } catch (err) {
+    if (err.message.includes('Cannot find module')) return null;
+
+    // The Opus engine exists, but another error occurred.
+    throw err;
+  }
+}
+
+exports.add = encoder => {
+  list.push(encoder);
+};
+
+exports.fetch = engineOptions => {
+  for (const encoder of list) {
+    const fetched = fetch(encoder, engineOptions);
+    if (fetched) return fetched;
+  }
+
+  throw new Error('Couldn\'t find an Opus engine.');
+};