discord-sb.js 1.0.0

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

@@ -0,0 +1,120 @@
+'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('buffer');
+const VideoDispatcher = require('./VideoDispatcher');
+const Util = require('../../../util/Util');
+const { H264Helpers, H265Helpers } = require('../player/processing/AnnexBNalSplitter');
+
+class AnnexBDispatcher extends VideoDispatcher {
+  constructor(player, highWaterMark = 12, streams, fps, nalFunctions, payloadType) {
+    super(player, highWaterMark, streams, fps, payloadType);
+    this._nalFunctions = nalFunctions;
+  }
+
+  _codecCallback(frame) {
+    let accessUnit = frame;
+    let offset = 0;
+
+    // Extract NALUs from the access unit
+    while (offset < accessUnit.length) {
+      const naluSize = accessUnit.readUInt32BE(offset);
+      offset += 4;
+      const nalu = accessUnit.subarray(offset, offset + naluSize);
+      const isLastNal = offset + naluSize >= accessUnit.length;
+      if (nalu.length <= this.mtu) {
+        // Send as Single NAL Unit Packet.
+        this._playChunk(Buffer.concat([this.createPayloadExtension(), nalu]), isLastNal);
+      } else {
+        const [naluHeader, naluData] = this._nalFunctions.splitHeader(nalu);
+        const dataFragments = this.partitionMtu(naluData);
+        // Send as Fragmentation Unit A (FU-A):
+        for (let fragmentIndex = 0; fragmentIndex < dataFragments.length; fragmentIndex++) {
+          const data = dataFragments[fragmentIndex];
+          const isFirstPacket = fragmentIndex === 0;
+          const isFinalPacket = fragmentIndex === dataFragments.length - 1;
+
+          this._playChunk(
+            Buffer.concat([
+              this.createPayloadExtension(),
+              this.makeFragmentationUnitHeader(isFirstPacket, isFinalPacket, naluHeader),
+              data,
+            ]),
+            isLastNal && isFinalPacket,
+          );
+        }
+      }
+      offset += naluSize;
+    }
+  }
+}
+
+class H264Dispatcher extends AnnexBDispatcher {
+  constructor(player, highWaterMark = 12, streams, fps) {
+    super(player, highWaterMark, streams, fps, H264Helpers, Util.getPayloadType('H264'));
+  }
+
+  makeFragmentationUnitHeader(isFirstPacket, isLastPacket, naluHeader) {
+    const nal0 = naluHeader[0];
+    const fuPayloadHeader = Buffer.alloc(2);
+    const nalType = H264Helpers.getUnitType(naluHeader);
+    const fnri = nal0 & 0xe0;
+
+    fuPayloadHeader[0] = 0x1c | fnri;
+
+    if (isFirstPacket) {
+      fuPayloadHeader[1] = 0x80 | nalType;
+    } else if (isLastPacket) {
+      fuPayloadHeader[1] = 0x40 | nalType;
+    } else {
+      fuPayloadHeader[1] = nalType;
+    }
+
+    return fuPayloadHeader;
+  }
+}
+
+class H265Dispatcher extends AnnexBDispatcher {
+  constructor(player, highWaterMark = 12, streams, fps) {
+    super(player, highWaterMark, streams, fps, H265Helpers, Util.getPayloadType('H265'));
+  }
+
+  makeFragmentationUnitHeader(isFirstPacket, isLastPacket, naluHeader) {
+    const fuIndicatorHeader = Buffer.allocUnsafe(3);
+    naluHeader.copy(fuIndicatorHeader);
+    const nalType = H265Helpers.getUnitType(naluHeader);
+
+    fuIndicatorHeader[0] = (fuIndicatorHeader[0] & 0b10000001) | (49 << 1);
+
+    if (isFirstPacket) {
+      fuIndicatorHeader[2] = 0x80 | nalType;
+    } else if (isLastPacket) {
+      fuIndicatorHeader[2] = 0x40 | nalType;
+    } else {
+      fuIndicatorHeader[2] = nalType;
+    }
+
+    return fuIndicatorHeader;
+  }
+}
+
+module.exports = {
+  H264Dispatcher,
+  H265Dispatcher,
+};

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

@@ -0,0 +1,145 @@
+'use strict';
+
+const BaseDispatcher = require('./BaseDispatcher');
+const Util = require('../../../util/Util');
+const Silence = require('../util/Silence');
+const VolumeInterface = require('../util/VolumeInterface');
+
+const CHANNELS = 2;
+
+/**
+ * @external WritableStream
+ * @see {@link https://nodejs.org/api/stream.html#stream_class_stream_writable}
+ */
+
+/**
+ * The class that sends voice 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.playAudio('/home/hydrabolt/audio.mp3');
+ * });
+ * ```
+ * @implements {VolumeInterface}
+ * @extends {BaseDispatcher}
+ */
+class AudioDispatcher extends BaseDispatcher {
+  constructor(player, { seek = 0, volume = 1, fec, plp, bitrate = 96, highWaterMark = 12 } = {}, streams) {
+    const streamOptions = { seek, volume, fec, plp, bitrate, highWaterMark };
+    super(player, highWaterMark, Util.getPayloadType('opus'), false, streams);
+
+    this.streamOptions = streamOptions;
+
+    this.streams.silence = new Silence();
+
+    this.setVolume(volume);
+    this.setBitrate(bitrate);
+    if (typeof fec !== 'undefined') this.setFEC(fec);
+    if (typeof plp !== 'undefined') this.setPLP(plp);
+  }
+
+  get TIMESTAMP_INC() {
+    return 480 * CHANNELS;
+  }
+
+  get FRAME_LENGTH() {
+    return 20;
+  }
+
+  /**
+   * Get the type of the dispatcher
+   * @returns {'audio'}
+   */
+  getTypeDispatcher() {
+    return 'audio';
+  }
+
+  /**
+   * Set the bitrate of the current Opus encoder if using a compatible Opus stream.
+   * @param {number} value New bitrate, in kbps
+   * If set to 'auto', the voice channel's bitrate will be used
+   * @returns {boolean} true if the bitrate has been successfully changed.
+   */
+  setBitrate(value) {
+    if (!value || !this.bitrateEditable) return false;
+    const bitrate = value === 'auto' ? this.player.voiceConnection.channel.bitrate : value;
+    this.streams.opus.setBitrate(bitrate * 1000);
+    return true;
+  }
+
+  /**
+   * Sets the expected packet loss percentage if using a compatible Opus stream.
+   * @param {number} value between 0 and 1
+   * @returns {boolean} Returns true if it was successfully set.
+   */
+  setPLP(value) {
+    if (!this.bitrateEditable) return false;
+    this.streams.opus.setPLP(value);
+    return true;
+  }
+
+  /**
+   * Enables or disables forward error correction if using a compatible Opus stream.
+   * @param {boolean} enabled true to enable
+   * @returns {boolean} Returns true if it was successfully set.
+   */
+  setFEC(enabled) {
+    if (!this.bitrateEditable) return false;
+    this.streams.opus.setFEC(enabled);
+    return true;
+  }
+
+  get volumeEditable() {
+    return Boolean(this.streams.volume);
+  }
+
+  /**
+   * Whether or not the Opus bitrate of this stream is editable
+   * @type {boolean}
+   * @readonly
+   */
+  get bitrateEditable() {
+    return this.streams.opus && this.streams.opus.setBitrate;
+  }
+
+  // Volume
+  get volume() {
+    return this.streams.volume ? this.streams.volume.volume : 1;
+  }
+
+  setVolume(value) {
+    if (!this.streams.volume) return false;
+    /**
+     * Emitted when the volume of this dispatcher changes.
+     * @event AudioDispatcher#volumeChange
+     * @param {number} oldVolume The old volume of this dispatcher
+     * @param {number} newVolume The new volume of this dispatcher
+     */
+    this.emit('volumeChange', this.volume, value);
+    this.streams.volume.setVolume(value);
+    return true;
+  }
+
+  /**
+   * Sync with another video dispatcher to ensure that the audio and video are played at the same time.
+   * @param {VideoDispatcher} otherDispatcher The video dispatcher to sync with
+   */
+  setSyncVideoDispatcher(otherDispatcher) {
+    if (otherDispatcher.getTypeDispatcher() !== 'video') {
+      throw new Error('Dispatcher must be a video dispatcher');
+    }
+    this._syncDispatcher = otherDispatcher;
+  }
+
+  // Volume stubs for docs
+  /* eslint-disable no-empty-function*/
+  get volumeDecibels() {}
+  get volumeLogarithmic() {}
+  setVolumeDecibels() {}
+  setVolumeLogarithmic() {}
+}
+
+VolumeInterface.applyToClass(AudioDispatcher);
+
+module.exports = AudioDispatcher;