rockcord 4.0.0-dev.4

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

@@ -0,0 +1,366 @@
+'use strict';
+
+const EventEmitter = require('events');
+const { Buffer } = require('node:buffer');
+const { setTimeout, setInterval } = require('node:timers');
+const DAVE = require('./DAVE');
+const WebSocket = require('../../../WebSocket');
+const { Error } = require('../../../errors');
+const { VoiceOpcodes } = require('../../../util/Constants');
+
+/**
+ * Represents a Voice Connection's WebSocket.
+ * @extends {EventEmitter}
+ * @private
+ */
+class VoiceWebSocket extends EventEmitter {
+  constructor(connection) {
+    super();
+    /**
+     * The Voice Connection that this WebSocket serves
+     * @type {VoiceConnection}
+     */
+    this.connection = connection;
+    this.dave = connection.dave = new DAVE(
+      connection.client.user.id,
+      connection.serverId ? (BigInt(connection.serverId) - 1n).toString() : connection.channel.id,
+      packet => this.sendPacket(packet).catch(error => this.onError(error)),
+      (op, payload) => this.send(Buffer.concat([Buffer.from([op]), payload])).catch(error => this.onError(error)),
+    );
+
+    /**
+     * How many connection attempts have been made
+     * @type {number}
+     */
+    this.attempts = 0;
+
+    this._sequenceNumber = -1;
+
+    this.dead = false;
+    this.heartbeatAcked = true;
+    this.closingHandler = this.shutdown.bind(this);
+    this.connection.on('closing', this.closingHandler);
+  }
+
+  /**
+   * The client of this voice WebSocket
+   * @type {Client}
+   * @readonly
+   */
+  get client() {
+    return this.connection.client;
+  }
+
+  shutdown() {
+    this.emit('debug', `[WS] shutdown requested`);
+    this.dead = true;
+    this.dave.destroy();
+    this.connection.removeListener('closing', this.closingHandler);
+    this.reset();
+  }
+
+  /**
+   * Resets the current WebSocket.
+   */
+  reset() {
+    this.emit('debug', `[WS] reset requested`);
+    clearTimeout(this.reconnectTimer);
+    if (this.ws) {
+      const ws = this.ws;
+      this.ws = null;
+      if (ws.readyState !== WebSocket.CLOSED) ws.close();
+    }
+    this.clearHeartbeat();
+  }
+
+  /**
+   * Starts connecting to the Voice WebSocket Server.
+   */
+  connect() {
+    this.emit('debug', `[WS] connect requested`);
+    if (this.dead) return;
+    if (this.ws) this.reset();
+    if (this.attempts >= 5) {
+      this.emit('debug', new Error('VOICE_CONNECTION_ATTEMPTS_EXCEEDED', this.attempts));
+      return;
+    }
+
+    this.attempts++;
+    if (this.attempts > 1) {
+      this.dave.session?.reset();
+      this.dave.negotiated = false;
+      this.dave.blocked = true;
+      this.dave.pending.clear();
+      this.dave.clients = new Set([this.client.user.id]);
+    }
+
+    /**
+     * The actual WebSocket used to connect to the Voice WebSocket Server.
+     * @type {WebSocket}
+     */
+    this.ws = WebSocket.create(`wss://${this.connection.authentication.endpoint}/`, { v: 8 });
+    const ws = this.ws;
+    this.emit('debug', `[WS] connecting, ${this.attempts} attempts, ${this.ws.url}`);
+    this.ws.onopen = () => {
+      if (this.ws === ws) this.onOpen();
+    };
+    this.ws.on('message', (data, isBinary) => {
+      if (this.ws === ws) this.onMessage({ data, isBinary });
+    });
+    this.ws.onclose = event => {
+      if (this.ws === ws) this.onClose(event);
+    };
+    this.ws.onerror = error => {
+      if (this.ws === ws) this.onError(error);
+    };
+  }
+
+  /**
+   * Sends data to the WebSocket if it is open.
+   * @param {string} data The data to send to the WebSocket
+   * @returns {Promise<string>}
+   */
+  send(data) {
+    this.emit('debug', '[WS] >> sending packet');
+    return new Promise((resolve, reject) => {
+      if (!this.ws || this.ws.readyState !== WebSocket.OPEN) throw new Error('WS_NOT_OPEN', '[REDACTED]');
+      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>}
+   */
+  async sendPacket(packet) {
+    packet = JSON.stringify(packet);
+    return this.send(packet);
+  }
+
+  /**
+   * Called whenever the WebSocket opens.
+   */
+  onOpen() {
+    this.emit('debug', `[WS] opened at gateway ${this.connection.authentication.endpoint}`);
+  }
+
+  identify() {
+    this.sendPacket({
+      op: VoiceOpcodes.IDENTIFY,
+      d: {
+        server_id: this.connection.serverId || this.connection.channel.guild?.id || this.connection.channel.id,
+        user_id: this.client.user.id,
+        token: this.connection.authentication.token,
+        session_id: this.connection.authentication.sessionId,
+        streams: [{ type: 'screen', rid: '100', quality: 100 }],
+        video: true,
+        max_dave_protocol_version: DAVE.maxVersion,
+      },
+    }).catch(() => {
+      this.emit('error', new Error('VOICE_JOIN_SOCKET_CLOSED'));
+    });
+  }
+
+  /**
+   * Called whenever a message is received from the WebSocket.
+   * @param {MessageEvent} event The message event that was received
+   * @returns {void}
+   */
+  onMessage(event) {
+    try {
+      if (event.isBinary ?? typeof event.data !== 'string') {
+        const data = Buffer.isBuffer(event.data) ? event.data : Buffer.from(event.data);
+        if (data.length < 3) throw new RangeError('Truncated voice gateway binary packet');
+        this._sequenceNumber = data.readUInt16BE(0);
+        this.dave.binary(data[2], data.subarray(3));
+        return;
+      }
+      this.onPacket(WebSocket.unpack(event.data, 'json'));
+    } catch (error) {
+      this.onError(error);
+    }
+  }
+
+  /**
+   * Called whenever the connection to the WebSocket server is lost.
+   * @param {CloseEvent} event The WebSocket close event
+   */
+  onClose(event) {
+    this.emit('debug', `[WS] closed with code ${event.code} and reason: ${event.reason}`);
+    if (event.code === 4017) {
+      this.shutdown();
+      this.onError(new Error('VOICE_DAVE_UNSUPPORTED'));
+      return;
+    }
+    if (!this.dead) this.reconnectTimer = setTimeout(this.connect.bind(this), this.attempts * 1000).unref();
+  }
+
+  /**
+   * Called whenever an error occurs with the WebSocket.
+   * @param {Error} error The error that occurred
+   */
+  onError(error) {
+    this.emit('debug', `[WS] Error: ${error}`);
+    this.emit('error', error);
+  }
+
+  /**
+   * Called whenever a valid packet is received from the WebSocket.
+   * @param {Object} packet The received packet
+   */
+  onPacket(packet) {
+    this.emit('debug', `[WS] << opcode ${packet.op}`);
+    if (packet.seq !== undefined) this._sequenceNumber = packet.seq;
+    switch (packet.op) {
+      case VoiceOpcodes.HELLO:
+        this.heartbeatAcked = true;
+        this.setHeartbeat(packet.d.heartbeat_interval);
+        this.identify();
+        break;
+      case VoiceOpcodes.READY:
+        /**
+         * Emitted once the voice WebSocket receives the ready packet.
+         * @param {Object} packet The received packet
+         * @event VoiceWebSocket#ready
+         */
+        this.emit('ready', packet.d);
+        this.connection.setVideoStatus(false);
+        break;
+      /* eslint-disable no-case-declarations */
+      case VoiceOpcodes.SESSION_DESCRIPTION:
+        try {
+          this.dave.initialize(packet.d.dave_protocol_version ?? 0);
+        } catch (error) {
+          this.shutdown();
+          this.onError(error);
+          return;
+        }
+        packet.d.secret_key = new Uint8Array(packet.d.secret_key);
+        /**
+         * Emitted once the Voice Websocket receives a description of this voice session.
+         * @param {Object} packet The received packet
+         * @event VoiceWebSocket#sessionDescription
+         */
+        this.emit('sessionDescription', packet.d);
+        break;
+      case VoiceOpcodes.HEARTBEAT_ACK:
+        this.heartbeatAcked = true;
+        break;
+      case VoiceOpcodes.CLIENT_CONNECT:
+        for (const id of packet.d.user_ids || [packet.d.user_id].filter(Boolean)) this.dave.clients.add(id);
+        if (packet.d.audio_ssrc) {
+          this.connection.ssrcMap.set(+packet.d.audio_ssrc, {
+            userId: packet.d.user_id,
+            speaking: 0,
+            hasVideo: Boolean(packet.d.video_ssrc),
+          });
+        }
+        break;
+      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);
+        }
+        const streamInfo = this.connection.receiver && this.connection.receiver.packets.streams.get(packet.d.user_id);
+        if (streamInfo) {
+          this.connection.receiver.packets.streams.delete(packet.d.user_id);
+          streamInfo.stream.push(null);
+        }
+        break;
+      case VoiceOpcodes.DAVE_PREPARE_TRANSITION:
+        this.dave.prepare(packet.d);
+        break;
+      case VoiceOpcodes.DAVE_EXECUTE_TRANSITION:
+        this.dave.execute(packet.d.transition_id);
+        break;
+      case VoiceOpcodes.DAVE_PREPARE_EPOCH:
+        this.dave.epoch(packet.d);
+        break;
+      case VoiceOpcodes.SPEAKING:
+        /**
+         * Emitted whenever a speaking packet is received.
+         * @param {Object} data
+         * @event VoiceWebSocket#startSpeaking
+         */
+        this.emit('startSpeaking', packet.d);
+        break;
+      case VoiceOpcodes.SOURCES:
+        /**
+         * Emitted whenever a streaming packet is received.
+         * @param {Object} data
+         * @event VoiceWebSocket#startStreaming
+         */
+        this.emit('startStreaming', 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('VOICE_INVALID_HEARTBEAT'));
+      return;
+    }
+    if (this.heartbeatInterval) {
+      /**
+       * Emitted whenever 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 = setInterval(this.sendHeartbeat.bind(this), interval).unref();
+  }
+
+  /**
+   * 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() {
+    if (!this.heartbeatAcked) {
+      this.ws?.close(4000);
+      this.clearHeartbeat();
+      return;
+    }
+    this.heartbeatAcked = false;
+    this.sendPacket({
+      op: VoiceOpcodes.HEARTBEAT,
+      d: {
+        t: Date.now(),
+        seq_ack: this._sequenceNumber,
+      },
+    }).catch(() => {
+      this.emit('warn', 'Tried to send heartbeat, but connection is not open');
+      this.clearHeartbeat();
+    });
+  }
+}
+
+module.exports = VoiceWebSocket;

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

@@ -0,0 +1,321 @@
+'use strict';
+
+/*
+Credit: https://github.com/dank074/Discord-video-stream
+The use of video streaming in this library is an incomplete implementation with many bugs, primarily aimed at lazy users.
+The video streaming features in this library are sourced from https://github.com/dank074/Discord-video-stream.
+
+Please use the @dank074/discord-video-stream library to access all advanced and professional features,
+along with comprehensive support. I will not actively fix bugs related to streaming and encourage everyone to
+use https://github.com/dank074/Discord-video-stream for stable and smooth streaming.
+
+To reiterate: This is an incomplete implementation of the library https://github.com/dank074/Discord-video-stream.
+
+Thanks to dank074 and longnguyen2004 for implementing new codecs (H264, H265).
+Thanks to mrjvs for discovering how Discord transmits data and the VP8 codec.
+
+Please use the @dank074/discord-video-stream library for the best support.
+*/
+
+const EventEmitter = require('events');
+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 AudioDispatcher = require('../dispatcher/AudioDispatcher');
+const { VP8Dispatcher } = require('../dispatcher/VPxDispatcher');
+
+const FFMPEG_OUTPUT_PREFIX = ['-use_wallclock_as_timestamps', '1', '-copyts', '-analyzeduration', '0'];
+const FFMPEG_INPUT_PREFIX = [
+  '-reconnect',
+  '1',
+  '-reconnect_at_eof',
+  '1',
+  '-reconnect_streamed',
+  '1',
+  '-reconnect_delay_max',
+  '4294',
+];
+const FFMPEG_PCM_ARGUMENTS = ['-f', 's16le', '-ar', '48000', '-ac', '2'];
+const FFMPEG_VP8_ARGUMENTS = ['-f', 'ivf', '-deadline', 'realtime', '-c:v', 'libvpx'];
+const FFMPEG_H264_ARGUMENTS = options => [
+  '-c:v',
+  'libx264',
+  '-f',
+  'h264',
+  '-tune',
+  'zerolatency',
+  // '-pix_fmt',
+  // 'yuv420p',
+  '-preset',
+  options?.presetH26x || 'faster',
+  '-profile:v',
+  'baseline',
+  // '-g',
+  // `${options?.fps}`,
+  // '-x264-params',
+  // `keyint=${options?.fps}:min-keyint=${options?.fps}`,
+  '-bf',
+  '0',
+  '-bsf:v',
+  'h264_metadata=aud=insert',
+];
+
+const FFMPEG_H265_ARGUMENTS = options => [
+  '-c:v',
+  'libx265',
+  '-f',
+  'hevc',
+  '-preset',
+  options?.presetH265 || 'faster',
+  '-profile:v',
+  'main',
+  '-bf',
+  '0',
+];
+
+/**
+ * Player for a Voice Connection.
+ * @private
+ * @extends {EventEmitter}
+ */
+class MediaPlayer extends EventEmitter {
+  constructor(voiceConnection, isScreenSharing) {
+    super();
+
+    this.dispatcher = null;
+
+    this.videoDispatcher = null;
+    /**
+     * The voice connection that the player serves
+     * @type {VoiceConnection}
+     */
+    this.voiceConnection = voiceConnection;
+
+    this.isScreenSharing = isScreenSharing;
+  }
+
+  destroy() {
+    this.destroyDispatcher();
+    this.destroyVideoDispatcher();
+  }
+
+  destroyDispatcher() {
+    if (this.dispatcher) {
+      this.dispatcher.destroy();
+      this.dispatcher = null;
+    }
+  }
+
+  destroyVideoDispatcher() {
+    if (this.videoDispatcher) {
+      this.videoDispatcher.destroy();
+      this.videoDispatcher = null;
+    }
+  }
+
+  playUnknown(input, options, streams = {}) {
+    this.destroyDispatcher();
+    const isStream = input instanceof ReadableStream;
+    const args = [...FFMPEG_OUTPUT_PREFIX, ...FFMPEG_PCM_ARGUMENTS];
+    if (!isStream) args.unshift('-i', input);
+    if (options.seek) args.unshift('-ss', String(options.seek));
+    // Check input
+    if (typeof input == 'string' && input.startsWith('http')) {
+      args.unshift(...FFMPEG_INPUT_PREFIX);
+    }
+
+    const ffmpeg = new prism.FFmpeg({ args });
+    this.emit('debug', `[ffmpeg-audio_process] Spawn process with args:\n${args.join(' ')}`);
+
+    ffmpeg.process.stderr.on('data', data => {
+      this.emit('debug', `[ffmpeg-audio_process]: ${data.toString()}`);
+    });
+
+    streams.ffmpeg = ffmpeg;
+    if (isStream) {
+      streams.input = input;
+      input.pipe(ffmpeg);
+    }
+    return this.playPCMStream(ffmpeg, options, streams);
+  }
+
+  playPCMStream(stream, options, streams = {}) {
+    this.destroyDispatcher();
+    const opus = (streams.opus = new prism.opus.Encoder({ channels: 2, rate: 48000, frameSize: 960 }));
+    if (options && options.volume === false) {
+      stream.pipe(opus);
+      return this.playOpusStream(opus, options, streams);
+    }
+    streams.volume = new prism.VolumeTransformer({ type: 's16le', volume: options ? options.volume : 1 });
+    stream.pipe(streams.volume).pipe(opus);
+    return this.playOpusStream(opus, options, streams);
+  }
+
+  playOpusStream(stream, options, streams = {}) {
+    this.destroyDispatcher();
+    streams.opus = stream;
+    if (options.volume !== false && !streams.input) {
+      streams.input = stream;
+      const decoder = new prism.opus.Decoder({ channels: 2, rate: 48000, frameSize: 960 });
+      streams.volume = new prism.VolumeTransformer({ type: 's16le', volume: options ? options.volume : 1 });
+      streams.opus = stream
+        .pipe(decoder)
+        .pipe(streams.volume)
+        .pipe(new prism.opus.Encoder({ channels: 2, rate: 48000, frameSize: 960 }));
+    }
+    const dispatcher = this.createDispatcher(options, streams);
+    streams.opus.pipe(dispatcher);
+    return dispatcher;
+  }
+
+  playUnknownVideo(input, options = {}) {
+    this.destroyVideoDispatcher();
+    const isStream = input instanceof ReadableStream;
+    if (!options?.fps) options.fps = 30;
+
+    const args = [
+      '-i',
+      isStream ? '-' : input,
+      ...FFMPEG_OUTPUT_PREFIX,
+      '-flags',
+      'low_delay',
+      '-r',
+      `${options?.fps}`,
+    ];
+
+    if (options?.bitrate && typeof options?.bitrate === 'number') {
+      args.push('-b:v', `${options?.bitrate}K`);
+    }
+
+    if (options?.hwAccel === true) {
+      args.unshift('-hwaccel', 'auto');
+    }
+
+    if (options.seek) args.unshift('-ss', String(options.seek));
+
+    // Check input
+    if (typeof input == 'string' && input.startsWith('http')) {
+      args.unshift(...FFMPEG_INPUT_PREFIX);
+    }
+
+    // Get stream type
+    if (this.voiceConnection.videoCodec === 'VP8') {
+      args.push(...FFMPEG_VP8_ARGUMENTS);
+      // Remove  '-speed', '5' bc bad quality
+    }
+
+    if (this.voiceConnection.videoCodec === 'H264') {
+      args.push(...FFMPEG_H264_ARGUMENTS(options));
+    }
+
+    if (this.voiceConnection.videoCodec === 'H265') {
+      args.push(...FFMPEG_H265_ARGUMENTS(options));
+    }
+
+    args.push('-force_key_frames', '00:02');
+
+    if (options?.inputFFmpegArgs) {
+      args.unshift(...options.inputFFmpegArgs);
+    }
+
+    if (options?.outputFFmpegArgs) {
+      args.push(...options.outputFFmpegArgs);
+    }
+
+    const ffmpeg = new prism.FFmpeg({ args });
+    const streams = { ffmpeg };
+
+    if (isStream) {
+      streams.input = input;
+      input.pipe(ffmpeg);
+    }
+
+    this.emit('debug', `[ffmpeg-video_process] Spawn process with args:\n${args.join(' ')}`);
+
+    ffmpeg.process.stderr.on('data', data => {
+      this.emit('debug', `[ffmpeg-video_process]: ${data.toString()}`);
+    });
+
+    switch (this.voiceConnection.videoCodec) {
+      case 'VP8': {
+        return this.playIvfVideo(ffmpeg, options, streams);
+      }
+      case 'H264': {
+        return this.playAnnexBVideo(ffmpeg, options, streams, 'H264');
+      }
+      default: {
+        throw new Error('Invalid codec (Supported: VP8, H264)');
+      }
+    }
+  }
+
+  playIvfVideo(stream, options, streams) {
+    this.destroyVideoDispatcher();
+    const videoStream = new IvfTransformer();
+    stream.pipe(videoStream);
+    streams.video = videoStream;
+    const dispatcher = this.createVideoDispatcher(options, streams);
+    videoStream.pipe(dispatcher);
+    return dispatcher;
+  }
+
+  // eslint-disable-next-line no-unused-vars
+  playAnnexBVideo(stream, options, streams, type) {
+    this.destroyVideoDispatcher();
+    let videoStream;
+    if (type === 'H264') {
+      videoStream = new H264NalSplitter();
+    } else if (type === 'H265') {
+      videoStream = new H265NalSplitter();
+    }
+    stream.pipe(videoStream);
+    streams.video = videoStream;
+    const dispatcher = this.createVideoDispatcher(options, streams);
+    videoStream.pipe(dispatcher);
+    return dispatcher;
+  }
+
+  createDispatcher(options, streams) {
+    this.destroyDispatcher();
+    const dispatcher = (this.dispatcher = new AudioDispatcher(this, options, streams));
+    return dispatcher;
+  }
+
+  /**
+   * Create
+   * @private
+   * @param {Object} options any
+   * @param {Object} streams any
+   * @returns {VideoDispatcher}
+   */
+  createVideoDispatcher(options, streams) {
+    this.destroyVideoDispatcher();
+    switch (this.voiceConnection.videoCodec) {
+      case 'VP8': {
+        const dispatcher = (this.videoDispatcher = new VP8Dispatcher(
+          this,
+          options?.highWaterMark,
+          streams,
+          options?.fps,
+        ));
+        return dispatcher;
+      }
+      case 'H264': {
+        const dispatcher = (this.videoDispatcher = new H264Dispatcher(
+          this,
+          options?.highWaterMark,
+          streams,
+          options?.fps,
+        ));
+        return dispatcher;
+      }
+      default: {
+        throw new Error('Invalid codec');
+      }
+    }
+  }
+}
+
+module.exports = MediaPlayer;