rockcord 4.0.0-dev.4

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

@@ -0,0 +1,473 @@
+'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 MAX_UINT_16 = 2 ** 16 - 1;
+const MAX_UINT_32 = 2 ** 32 - 1;
+
+const nonceStates = new WeakMap();
+const packetStates = new WeakMap();
+
+/**
+ * @external WritableStream
+ * @see {@link https://nodejs.org/api/stream.html#stream_class_stream_writable}
+ */
+
+/**
+ * @extends {Writable}
+ */
+class BaseDispatcher extends Writable {
+  constructor(player, highWaterMark = 12, payloadType, extensionEnabled, streams = {}) {
+    super({
+      highWaterMark,
+    });
+    this.streams = streams;
+    /**
+     * The Player that controls this dispatcher
+     * @type {MediaPlayer}
+     */
+    this.player = player;
+    this.payloadType = payloadType;
+    this.extensionEnabled = extensionEnabled;
+
+    this._nonce = 0;
+    this._nonceBuffer = null;
+
+    /**
+     * The time that the stream was paused at (null if not paused)
+     * @type {?number}
+     */
+    this.pausedSince = null;
+    this._writeCallback = null;
+
+    this._pausedTime = 0;
+    this._silentPausedTime = 0;
+
+    this.count = 0;
+    this.sequence = 0;
+    this.timestamp = 0;
+    const connection = player.voiceConnection;
+    if (connection?.authentication?.secret_key) {
+      let states = packetStates.get(connection);
+      if (!states) packetStates.set(connection, (states = new Map()));
+      const type = this.getTypeDispatcher();
+      const { secret_key, ssrc } = connection.authentication;
+      let state = states.get(type);
+      if (!state || state.ssrc !== ssrc || !state.key.equals(Buffer.from(secret_key))) {
+        state = { ssrc, key: Buffer.from(secret_key), sequence: 0, timestamp: 0 };
+        states.set(type, state);
+      }
+      this._packetState = state;
+      this.sequence = state.sequence;
+      this.timestamp = state.timestamp;
+    }
+
+    const streamError = (type, err) => {
+      /**
+       * Emitted when the dispatcher encounters an error.
+       * @event BaseDispatcher#error
+       */
+      if (type && err) {
+        err.message = `${type} stream: ${err.message}`;
+        this.emit(this.player.dispatcher === this ? 'error' : 'debug', err);
+      }
+      this.destroy();
+    };
+
+    this.on('error', () => streamError());
+    if (this.streams.input) this.streams.input.on('error', err => streamError('input', err));
+    if (this.streams.ffmpeg) this.streams.ffmpeg.on('error', err => streamError('ffmpeg', err));
+    if (this.streams.opus) this.streams.opus.on('error', err => streamError('opus', err));
+    if (this.streams.volume) this.streams.volume.on('error', err => streamError('volume', err));
+
+    this.on('finish', () => {
+      this._cleanup();
+      this._setSpeaking(0);
+      this._setVideoStatus(false);
+      this._setStreamStatus(true);
+    });
+  }
+
+  getTypeDispatcher() {
+    return 'base';
+  }
+
+  resetNonceBuffer() {
+    this._nonceBuffer =
+      this.player.voiceConnection.authentication.mode === 'aead_aes256_gcm_rtpsize'
+        ? Buffer.alloc(12)
+        : Buffer.alloc(24);
+  }
+
+  getNewSequence() {
+    const currentSeq = this.sequence;
+    this.sequence++;
+    if (this.sequence > MAX_UINT_16) this.sequence = 0;
+    if (this._packetState) this._packetState.sequence = this.sequence;
+    return currentSeq;
+  }
+
+  _write(chunk, enc, done) {
+    if (!this.startTime) {
+      /**
+       * Emitted once the stream has started to play.
+       * @event BaseDispatcher#start
+       */
+      this.emit('start');
+      this.startTime = performance.now();
+    }
+    if (this._syncDispatcher && !this._syncDispatcher.startTime && !this._syncStartListener) {
+      this.pause();
+      const cb = () => {
+        this._syncDispatcher.removeListener('start', cb);
+        clearTimeout(this._syncStartTimer);
+        this._syncStartListener = null;
+        this.resume();
+      };
+      this._syncStartListener = cb;
+      this._syncDispatcher.once('start', cb);
+      this._syncStartTimer = setTimeout(cb, 10_000).unref();
+    }
+    try {
+      if (this.getTypeDispatcher() === 'video') {
+        this._codecCallback(chunk);
+      } else {
+        this._playChunk(chunk);
+      }
+    } catch (error) {
+      done(error);
+      return;
+    }
+    this._step(done);
+  }
+
+  _destroy(err, cb) {
+    this._cleanup();
+    super._destroy(err, cb);
+  }
+
+  _cleanup() {
+    clearTimeout(this._stepTimer);
+    clearTimeout(this._syncStartTimer);
+    if (this._syncStartListener) this._syncDispatcher?.removeListener('start', this._syncStartListener);
+    this._syncStartListener = null;
+    this._writeCallback = null;
+    if (this.player.dispatcher === this) {
+      this.player.dispatcher.destroy();
+      this.player.dispatcher = null;
+    }
+    if (this.player.videoDispatcher === this) {
+      this.player.videoDispatcher.destroy();
+      this.player.videoDispatcher = null;
+    }
+    const { streams } = this;
+    if (streams.opus) streams.opus.destroy();
+    streams.ffmpeg?.destroy();
+  }
+
+  /**
+   * Pauses playback
+   * @param {boolean} [silence=false] Whether to play silence while paused to prevent audio glitches
+   */
+  pause(silence = false) {
+    if (this.paused) return;
+    if (this.streams.opus) this.streams.opus.unpipe(this); // Audio
+    if (this.streams.video) {
+      this.streams.ffmpeg.pause();
+      this.streams.video.unpipe(this);
+    }
+    if (this.getTypeDispatcher() === 'audio') {
+      if (silence) {
+        this.streams.silence.pipe(this);
+        this._silence = true;
+      } else {
+        this._setSpeaking(0);
+      }
+    }
+    this.pausedSince = performance.now();
+  }
+
+  /**
+   * Whether or not playback is paused
+   * @type {boolean}
+   * @readonly
+   */
+  get paused() {
+    return Boolean(this.pausedSince);
+  }
+
+  /**
+   * Total time that this dispatcher has been paused in milliseconds
+   * @type {number}
+   * @readonly
+   */
+  get pausedTime() {
+    return this._silentPausedTime + this._pausedTime + (this.paused ? performance.now() - this.pausedSince : 0);
+  }
+
+  /**
+   * Resumes playback
+   */
+  resume() {
+    if (!this.pausedSince) return;
+    if (this.getTypeDispatcher() === 'audio') this.streams.silence.unpipe(this);
+    if (this.streams.opus) this.streams.opus.pipe(this);
+    if (this.streams.video) {
+      this.streams.ffmpeg.resume();
+      this.streams.video.pipe(this);
+    }
+    if (this._silence) {
+      this._silentPausedTime += performance.now() - this.pausedSince;
+      this._silence = false;
+    } else {
+      this._pausedTime += performance.now() - this.pausedSince;
+    }
+    this.pausedSince = null;
+    if (typeof this._writeCallback === 'function') this._writeCallback();
+  }
+
+  /**
+   * The time (in milliseconds) that the dispatcher has been playing audio for, taking into account skips and pauses
+   * @type {number}
+   * @readonly
+   */
+  get totalStreamTime() {
+    return performance.now() - this.startTime;
+  }
+
+  _step(done) {
+    this._writeCallback = () => {
+      this._writeCallback = null;
+      done();
+    };
+    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();
+    this.timestamp = (this.timestamp + this.TIMESTAMP_INC) % (MAX_UINT_32 + 1);
+    if (this._packetState) this._packetState.timestamp = this.timestamp;
+    this.count++;
+  }
+
+  _final(callback) {
+    this._writeCallback = null;
+    callback();
+  }
+
+  _playChunk(chunk, isLastPacket = false) {
+    if (
+      (this.player.dispatcher !== this && this.player.videoDispatcher !== this) ||
+      !this.player.voiceConnection.authentication.secret_key
+    ) {
+      return;
+    }
+    if (this.getTypeDispatcher() === 'audio' && this.player.voiceConnection.dave) {
+      chunk = this.player.voiceConnection.dave.encrypt(chunk);
+      if (!chunk) return;
+    }
+    const packet = this._createPacket(chunk, isLastPacket);
+    if (packet) this._sendPacket(packet);
+  }
+
+  /**
+   * Creates a one-byte extension header
+   * https://www.rfc-editor.org/rfc/rfc5285#section-4.2
+   * @returns {Buffer} <Buffer be de 00 01>
+   */
+  createHeaderExtension() {
+    /*
+      *  0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1
+      +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
+      |      defined by profile       |           length              |
+      +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
+      */
+    const profile = Buffer.alloc(4);
+    profile[0] = 0xbe;
+    profile[1] = 0xde;
+    profile.writeUInt16BE(this.createPayloadExtension().length / 4, 2);
+
+    return profile;
+  }
+
+  /*
+   * Creates padded native UDP extensions for playout delay, stream ID and transport sequence.
+   * @see https://docs.discord.food/topics/voice-connections#sending-and-receiving-voice
+   * Discord expects a playout delay RTP extension header on every video packet.
+   * @see https://webrtc.googlesource.com/src/+/refs/heads/main/docs/native-code/rtp-hdrext/playout-delay
+   * @returns {Buffer} Padded RTP extension elements
+   */
+  createPayloadExtension() {
+    // Native UDP uses ID 6 for playout delay, 11 for primary RID, and 5 for transport sequence.
+    const rid = Buffer.from(this.player.voiceConnection.authentication.streams?.[0]?.rid || '100');
+    if (!rid.length || rid.length > 16) throw new RangeError('Invalid video RID');
+    const data = Buffer.concat([
+      Buffer.from([0x62, 0, 0, 0, 0xb0 | (rid.length - 1)]),
+      rid,
+      Buffer.from([0x51, (this.sequence >> 8) & 255, this.sequence & 255]),
+    ]);
+    return Buffer.concat([data, Buffer.alloc((4 - (data.length % 4)) % 4)]);
+  }
+
+  _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;
+    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}`);
+      }
+    }
+  }
+
+  _createPacket(buffer, isLastPacket) {
+    /*
+    // Packet is raw rtp from ffmpeg
+    const rtp = webrtc.RtpPacket.deSerialize(buffer);
+    if (!rtp.payload) {
+      console.log('no payload', rtp);
+      return null;
+    }
+    // Header
+    // https://docs.discord.food/topics/voice-connections#rtp-packet-structure
+    let rtpHeader = buffer.slice(0, 12); // RTP_HEADER_SIZE
+    rtpHeader[0] = 0x80; // Version + Flags (1 byte)
+    rtpHeader[1] = this.payloadType; // Payload Type (1 byte)
+    if (this.extensionEnabled) {
+      rtpHeader = Buffer.concat([rtpHeader, this.createHeaderExtension()]);
+      rtpHeader[0] |= 1 << 4; // 0x90
+    }
+    rtpHeader.writeUIntBE(this.getNewSequence(), 2, 2);
+    rtpHeader.writeUIntBE(this.timestamp, 4, 4);
+    rtpHeader.writeUIntBE(
+      this.player.voiceConnection.authentication.ssrc + Number(this.getTypeDispatcher() === 'video'),
+      8,
+      4,
+    );
+    */
+    // Header
+    let rtpHeader = Buffer.alloc(12); // RTP_HEADER_SIZE
+    rtpHeader[0] = 0x80; // Version + Flags (1 byte)
+    rtpHeader[1] = this.payloadType; // Payload Type (1 byte)
+    if (this.extensionEnabled) {
+      rtpHeader = Buffer.concat([rtpHeader, this.createHeaderExtension()]);
+      rtpHeader[0] |= 1 << 4; // 0x90
+    }
+    if (this.getTypeDispatcher() === 'video' && isLastPacket) {
+      rtpHeader[1] |= 1 << 7; // Marker bit
+    }
+
+    rtpHeader.writeUIntBE(this.getNewSequence(), 2, 2);
+    rtpHeader.writeUIntBE(this.timestamp, 4, 4);
+    rtpHeader.writeUIntBE(
+      this.player.voiceConnection.authentication.ssrc + Number(this.getTypeDispatcher() === 'video'),
+      8,
+      4,
+    );
+    return Buffer.concat([rtpHeader, ...this._encrypt(buffer, rtpHeader)]);
+  }
+
+  _sendPacket(packet) {
+    /**
+     * Emitted whenever the dispatcher has debug information.
+     * @event BaseDispatcher#debug
+     * @param {string} info The debug info
+     */
+    if (this.getTypeDispatcher() === 'audio') {
+      this._setSpeaking(this.player.isScreenSharing ? 1 << 1 : 1 << 0); // 1 << 0 = SPEAKING, 1 << 1 = SOUND SHARE
+    } else if (this.getTypeDispatcher() === 'video') {
+      this._setVideoStatus(true);
+      this._setStreamStatus(false);
+    }
+    if (!this.player.voiceConnection.sockets.udp) {
+      this.emit('debug', 'Failed to send a packet - no UDP socket');
+      return;
+    }
+    this.player.voiceConnection.sockets.udp.send(packet).catch(e => {
+      if (this.getTypeDispatcher() === 'audio') {
+        this._setSpeaking(this._setSpeaking(0));
+      } else if (this.getTypeDispatcher() === 'video') {
+        this._setVideoStatus(false);
+        this._setStreamStatus(true);
+      }
+      this.emit('debug', `Failed to send a packet - ${e}`);
+    });
+  }
+
+  _setSpeaking(value) {
+    if (typeof this.player.voiceConnection !== 'undefined') {
+      this.player.voiceConnection.setSpeaking(value);
+    }
+    /**
+     * Emitted when the dispatcher starts/stops speaking.
+     * @event AudioDispatcher#speaking
+     * @param {boolean} value Whether or not the dispatcher is speaking
+     */
+    this.emit('speaking', value);
+  }
+
+  _setVideoStatus(value) {
+    if (typeof this.player.voiceConnection !== 'undefined') {
+      this.player.voiceConnection.setVideoStatus(value);
+    }
+    /**
+     * Emitted when the dispatcher starts/stops video.
+     * @event VideoDispatcher#videoStatus
+     * @param {boolean} value Whether or not the dispatcher is enable video
+     */
+    this.emit('videoStatus', value);
+  }
+
+  _setStreamStatus(value) {
+    if (typeof this.player.voiceConnection?.sendScreenshareState !== 'undefined') {
+      this.player.voiceConnection.sendScreenshareState(value);
+    }
+    /**
+     * Emitted when the dispatcher starts/stops video.
+     * @event VideoDispatcher#streamStatus
+     * @param {boolean} isPaused Whether or not the dispatcher is pause video
+     */
+    this.emit('streamStatus', value);
+  }
+}
+
+module.exports = BaseDispatcher;

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

@@ -0,0 +1,58 @@
+'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 { Buffer } = require('node:buffer');
+const VideoDispatcher = require('./VideoDispatcher');
+const Util = require('../../../util/Util');
+
+class VP8Dispatcher extends VideoDispatcher {
+  constructor(player, highWaterMark = 12, streams, fps) {
+    super(player, highWaterMark, streams, fps, Util.getPayloadType('VP8'));
+  }
+
+  makeChunk(buffer, isFirstPacket) {
+    // Vp8 payload descriptor
+    const payloadDescriptorBuf = Buffer.alloc(2);
+    payloadDescriptorBuf[0] = 0x80;
+    payloadDescriptorBuf[1] = 0x80;
+    if (isFirstPacket) {
+      payloadDescriptorBuf[0] |= 1 << 4; // Mark S bit, indicates start of frame
+    }
+    // Vp8 pictureid payload extension
+    const pictureIdBuf = Buffer.alloc(2);
+    pictureIdBuf.writeUintBE(this.count & 0x7fff, 0, 2);
+    pictureIdBuf[0] |= 0x80;
+    return Buffer.concat([this.createPayloadExtension(), payloadDescriptorBuf, pictureIdBuf, buffer]);
+  }
+
+  _codecCallback(chunk) {
+    if (this.player.voiceConnection.dave) {
+      chunk = this.player.voiceConnection.dave.encrypt(chunk, 'VP8');
+      if (!chunk) return;
+    }
+    const chunkSplit = this.partitionMtu(chunk).map((c, i) => this.makeChunk(c, i === 0));
+    for (let i = 0; i < chunkSplit.length; i++) {
+      this._playChunk(chunkSplit[i], i + 1 === chunkSplit.length);
+    }
+  }
+}
+
+module.exports = {
+  VP8Dispatcher,
+};

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

@@ -0,0 +1,68 @@
+'use strict';
+
+const BaseDispatcher = require('./BaseDispatcher');
+
+/**
+ * The class that sends video packet data to the voice connection.
+ * ```js
+ * // Obtained using:
+ * client.voice.joinChannel(channel).then(connection => {
+ *   // You can play a file or a stream here:
+ *   const dispatcher = connection.playVideo('/home/hydrabolt/video.mp4', { fps: 60, preset: 'ultrafast' });
+ * });
+ * ```
+ * @extends {BaseDispatcher}
+ */
+class VideoDispatcher extends BaseDispatcher {
+  constructor(player, highWaterMark = 12, streams, fps, payloadType) {
+    super(player, highWaterMark, payloadType, true, streams);
+    /**
+     * Video FPS
+     * @type {number}
+     */
+    this.fps = fps;
+
+    this.mtu = 1200;
+  }
+
+  get TIMESTAMP_INC() {
+    return 90000 / this.fps;
+  }
+
+  get FRAME_LENGTH() {
+    return 1000 / this.fps;
+  }
+
+  /**
+   * Get the type of the dispatcher
+   * @returns {'video'}
+   */
+  getTypeDispatcher() {
+    return 'video';
+  }
+
+  partitionMtu(data) {
+    const out = [];
+    const dataLength = data.length;
+
+    for (let i = 0; i < dataLength; i += this.mtu) {
+      out.push(data.slice(i, i + this.mtu));
+    }
+
+    return out;
+  }
+
+  /**
+   * Set FPS
+   * @param {number} value fps
+   */
+  setFPSSource(value) {
+    this.fps = value;
+  }
+
+  _codecCallback() {
+    throw new Error('The _codecCallback method must be implemented');
+  }
+}
+
+module.exports = VideoDispatcher;