djs-selfbot-v13 3.7.32 → 3.7.33

package/src/client/voice/player/processing/AnnexBBitstreamReaderWriter.js

@@ -0,0 +1,137 @@
+'use strict';
+
+class AnnexBBitstreamReader {
+  constructor(buffer) {
+    this._buffer = buffer;
+    this._byteOffset = 0;
+    this._bitOffset = 0;
+  }
+
+  readBits(count) {
+    if (count === 0) return 0;
+    let result = 0;
+    while (count > 0) {
+      if (this._byteOffset >= this._buffer.length) throw new Error('Bad byte offset');
+      if (
+        this._bitOffset === 0 &&
+        this._byteOffset >= 2 &&
+        this._buffer[this._byteOffset - 2] === 0 &&
+        this._buffer[this._byteOffset - 1] === 0 &&
+        this._buffer[this._byteOffset] === 3
+      ) {
+        this._byteOffset++;
+      }
+      if (this._bitOffset === 0 && count >= 8) {
+        result = (result << 8) | this._buffer[this._byteOffset++];
+        count -= 8;
+      } else {
+        const numBitsToRead = Math.min(count, 8 - this._bitOffset);
+        const mask = (1 << numBitsToRead) - 1;
+        const newBits = (this._buffer[this._byteOffset] >> (8 - this._bitOffset - numBitsToRead)) & mask;
+        result = (result << numBitsToRead) | newBits;
+        count -= numBitsToRead;
+        this._bitOffset += numBitsToRead;
+        if (this._bitOffset === 8) {
+          this._bitOffset = 0;
+          this._byteOffset++;
+        }
+      }
+    }
+    return result;
+  }
+
+  readUnsigned(bits) {
+    return this.readBits(bits);
+  }
+
+  readSigned(bits) {
+    const unsigned = this.readUnsigned(bits);
+    if (unsigned & (1 << (bits - 1))) return unsigned - (1 << bits);
+    return unsigned;
+  }
+
+  readUnsignedExpGolomb() {
+    let leading0 = 0;
+    while (this.readBits(1) === 0) leading0++;
+    return (1 << leading0) + this.readBits(leading0) - 1;
+  }
+
+  readSignedExpGolomb() {
+    const unsigned = this.readUnsignedExpGolomb();
+    if (unsigned % 2 === 0) return unsigned / -2;
+    return (unsigned + 1) / 2;
+  }
+}
+
+class AnnexBBitstreamWriter {
+  constructor() {
+    this._arr = [];
+    this._pendingByte = 0;
+    this._bitOffset = 0;
+  }
+
+  toBuffer() {
+    return Buffer.from(this._arr);
+  }
+
+  flush() {
+    if (this._pendingByte <= 3 && this._arr.at(-1) === 0 && this._arr.at(-2) === 0) this._arr.push(3);
+    this._arr.push(this._pendingByte);
+    this._pendingByte = 0;
+    this._bitOffset = 0;
+  }
+
+  writeBits(bits, count) {
+    while (count > 0) {
+      if (this._bitOffset === 0) {
+        if (count >= 8) {
+          this._pendingByte = (bits >> (count - 8)) & 0xff;
+          count -= 8;
+          this.flush();
+        } else {
+          const mask = (1 << count) - 1;
+          this._pendingByte |= (bits & mask) << (8 - count);
+          this._bitOffset = count;
+          count = 0;
+        }
+      } else {
+        const numBitsToWrite = Math.min(8 - this._bitOffset, count);
+        const bitsToWrite = (bits >> (count - numBitsToWrite)) & ((1 << numBitsToWrite) - 1);
+        this._pendingByte |= bitsToWrite << (8 - this._bitOffset - numBitsToWrite);
+        count -= numBitsToWrite;
+        this._bitOffset += numBitsToWrite;
+        if (this._bitOffset === 8) {
+          this._bitOffset = 0;
+          this.flush();
+        }
+      }
+    }
+  }
+
+  writeUnsigned(num, count) {
+    if (num < 0) throw new Error('Expected a non-negative number');
+    this.writeBits(num, count);
+  }
+
+  writeSigned(num, count) {
+    if (count <= 0) return;
+    if (count > 32) throw new Error('writeSigned supports up to 32 bits');
+    const mask = count === 32 ? 0xffffffff >>> 0 : (((1 << count) >>> 0) - 1) >>> 0;
+    this.writeBits((num & mask) >>> 0, count);
+  }
+
+  writeUnsignedExpGolomb(num) {
+    if (num < 0) throw new Error('Expected a non-negative number');
+    num++;
+    const bitCount = 32 - Math.clz32(num >>> 0);
+    this.writeBits(0, bitCount - 1);
+    this.writeBits(num, bitCount);
+  }
+
+  writeSignedExpGolomb(num) {
+    if (num < 0) this.writeUnsignedExpGolomb(-2 * num);
+    else this.writeUnsignedExpGolomb(2 * num - 1);
+  }
+}
+
+module.exports = { AnnexBBitstreamReader, AnnexBBitstreamWriter };

package/src/client/voice/player/processing/SPSVUIRewriter.js

@@ -0,0 +1,203 @@
+'use strict';
+
+const { AnnexBBitstreamReader, AnnexBBitstreamWriter } = require('./AnnexBBitstreamReaderWriter');
+
+function rewriteSPSVUI(buffer) {
+  const reader = new AnnexBBitstreamReader(buffer.subarray(1));
+  const writer = new AnnexBBitstreamWriter();
+
+  const readBit = (n = 1) => reader.readBits(n);
+  const writeBit = (v, n = 1) => writer.writeBits(v, n);
+  const readU = n => reader.readUnsigned(n);
+  const writeU = (v, n) => writer.writeUnsigned(v, n);
+  const readUE = () => reader.readUnsignedExpGolomb();
+  const writeUE = v => writer.writeUnsignedExpGolomb(v);
+  const readSE = () => reader.readSignedExpGolomb();
+  const writeSE = v => writer.writeSignedExpGolomb(v);
+
+  writeU(buffer[0], 8);
+
+  const profile_idc = readU(8);
+  writeU(profile_idc, 8);
+  const constraint_flags = readU(8);
+  writeU(constraint_flags, 8);
+  const level_idc = readU(8);
+  writeU(level_idc, 8);
+  const seq_parameter_set_id = readUE();
+  writeUE(seq_parameter_set_id);
+
+  const highProfiles = new Set([100, 110, 122, 244, 44, 83, 86, 118, 128, 138, 144]);
+  if (highProfiles.has(profile_idc)) {
+    const chroma_format_idc = readUE();
+    writeUE(chroma_format_idc);
+    if (chroma_format_idc === 3) writeBit(readBit(1), 1);
+    writeUE(readUE());
+    writeUE(readUE());
+    writeBit(readBit(1), 1);
+    const seq_scaling_matrix_present_flag = readBit(1);
+    writeBit(seq_scaling_matrix_present_flag, 1);
+    if (seq_scaling_matrix_present_flag) {
+      const scalingCount = chroma_format_idc !== 3 ? 8 : 12;
+      for (let i = 0; i < scalingCount; i++) {
+        const seq_scaling_list_present_flag = readBit(1);
+        writeBit(seq_scaling_list_present_flag, 1);
+        if (seq_scaling_list_present_flag) {
+          const size = i < 6 ? 16 : 64;
+          let lastScale = 8;
+          for (let j = 0; j < size; j++) {
+            const delta = readSE();
+            writeSE(delta);
+            const nextScale = (lastScale + delta + 256) % 256;
+            if (nextScale !== 0) lastScale = nextScale;
+          }
+        }
+      }
+    }
+  }
+
+  writeUE(readUE());
+  const pic_order_cnt_type = readUE();
+  writeUE(pic_order_cnt_type);
+  if (pic_order_cnt_type === 0) writeUE(readUE());
+  else if (pic_order_cnt_type === 1) {
+    writeBit(readBit(1), 1);
+    writeSE(readSE());
+    writeSE(readSE());
+    const num_ref_frames_in_pic_order_cnt_cycle = readUE();
+    writeUE(num_ref_frames_in_pic_order_cnt_cycle);
+    for (let i = 0; i < num_ref_frames_in_pic_order_cnt_cycle; i++) writeSE(readSE());
+  }
+
+  const max_num_ref_frames = readUE();
+  writeUE(max_num_ref_frames);
+  writeBit(readBit(1), 1);
+  writeUE(readUE());
+  writeUE(readUE());
+  const frame_mbs_only_flag = readBit(1);
+  writeBit(frame_mbs_only_flag, 1);
+  if (frame_mbs_only_flag === 0) writeBit(readBit(1), 1);
+  writeBit(readBit(1), 1);
+  const frame_cropping_flag = readBit(1);
+  writeBit(frame_cropping_flag, 1);
+  if (frame_cropping_flag) {
+    writeUE(readUE());
+    writeUE(readUE());
+    writeUE(readUE());
+    writeUE(readUE());
+  }
+
+  function addBitstreamRestriction() {
+    writeBit(1, 1);
+    writeUE(2);
+    writeUE(1);
+    writeUE(16);
+    writeUE(16);
+    writeUE(0);
+    writeUE(max_num_ref_frames);
+  }
+
+  const vui_parameters_present_flag = readBit(1);
+  writeBit(1, 1);
+  if (!vui_parameters_present_flag) {
+    writeBit(0, 2);
+    writeBit(0, 1);
+    writeBit(0, 5);
+    writeBit(1, 1);
+    addBitstreamRestriction();
+  } else {
+    const aspect_ratio_info_present_flag = readBit(1);
+    writeBit(aspect_ratio_info_present_flag, 1);
+    if (aspect_ratio_info_present_flag) {
+      const aspect_ratio_idc = readU(8);
+      writeU(aspect_ratio_idc, 8);
+      if (aspect_ratio_idc === 255) {
+        writeU(readU(16), 16);
+        writeU(readU(16), 16);
+      }
+    }
+    const overscan_info_present_flag = readBit(1);
+    writeBit(overscan_info_present_flag, 1);
+    if (overscan_info_present_flag) writeBit(readBit(1), 1);
+    const video_signal_type_present_flag = readBit(1);
+    writeBit(0, 1);
+    if (video_signal_type_present_flag) {
+      readBit(3);
+      readBit(1);
+      const colour_description_present_flag = readBit(1);
+      if (colour_description_present_flag) {
+        readU(8);
+        readU(8);
+        readU(8);
+      }
+    }
+    const chroma_loc_info_present_flag = readBit(1);
+    writeBit(chroma_loc_info_present_flag, 1);
+    if (chroma_loc_info_present_flag) {
+      writeUE(readUE());
+      writeUE(readUE());
+    }
+    const timing_info_present_flag = readBit(1);
+    writeBit(timing_info_present_flag, 1);
+    if (timing_info_present_flag) {
+      writeU(readU(32), 32);
+      writeU(readU(32), 32);
+      writeBit(readBit(1), 1);
+    }
+    const nal_hrd_parameters_present_flag = readBit(1);
+    writeBit(nal_hrd_parameters_present_flag, 1);
+    if (nal_hrd_parameters_present_flag) {
+      const cpb_cnt_minus1 = readUE();
+      writeUE(cpb_cnt_minus1);
+      writeBit(readBit(4), 4);
+      writeBit(readBit(4), 4);
+      for (let i = 0; i <= cpb_cnt_minus1; i++) {
+        writeUE(readUE());
+        writeUE(readUE());
+        writeBit(readBit(1), 1);
+      }
+      writeBit(readBit(5), 5);
+      writeBit(readBit(5), 5);
+      writeBit(readBit(5), 5);
+      writeBit(readBit(5), 5);
+    }
+    const vcl_hrd_parameters_present_flag = readBit(1);
+    writeBit(vcl_hrd_parameters_present_flag, 1);
+    if (vcl_hrd_parameters_present_flag) {
+      const cpb_cnt_minus1 = readUE();
+      writeUE(cpb_cnt_minus1);
+      writeBit(readBit(4), 4);
+      writeBit(readBit(4), 4);
+      for (let i = 0; i <= cpb_cnt_minus1; i++) {
+        writeUE(readUE());
+        writeUE(readUE());
+        writeBit(readBit(1), 1);
+      }
+      writeBit(readBit(5), 5);
+      writeBit(readBit(5), 5);
+      writeBit(readBit(5), 5);
+      writeBit(readBit(5), 5);
+    }
+    if (nal_hrd_parameters_present_flag || vcl_hrd_parameters_present_flag) writeBit(readBit(1), 1);
+    writeBit(readBit(1), 1);
+    const bitstream_restriction_flag = readBit(1);
+    writeBit(1, 1);
+    if (!bitstream_restriction_flag) addBitstreamRestriction();
+    else {
+      writeBit(readBit(1), 1);
+      writeUE(readUE());
+      writeUE(readUE());
+      writeUE(readUE());
+      writeUE(readUE());
+      readUE();
+      writeUE(0);
+      readUE();
+      writeUE(max_num_ref_frames);
+    }
+  }
+
+  writeBit(1, 1);
+  writer.flush();
+  return writer.toBuffer();
+}
+
+module.exports = { rewriteSPSVUI };

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

@@ -72,7 +72,7 @@ class PacketHandler extends EventEmitter {
     return stream;
   }
 
-  parseBuffer(buffer) {
+  parseBuffer(buffer, userId) {
     const { secret_key, mode } = this.receiver.connection.authentication;
     // Open packet
     if (!secret_key) return new Error('secret_key cannot be null or undefined');
@@ -129,7 +129,14 @@ class PacketHandler extends EventEmitter {
     }
     */
 
-    return RtpPacket.deSerialize(Buffer.concat([header, packet]));
+    const rtp = RtpPacket.deSerialize(Buffer.concat([header, packet]));
+    const dave = this.connection.dave;
+    if (dave && userId && rtp.payload) {
+      const decrypted = dave.decrypt(rtp.payload, userId);
+      if (decrypted === null) return new Error('DAVE_DECRYPT_FAILED');
+      rtp.payload = decrypted;
+    }
+    return rtp;
   }
 
   audioReceiver(ssrc, userStat, opusPacket) {
@@ -233,12 +240,12 @@ class PacketHandler extends EventEmitter {
     let userStat, packet;
     if (this.connection.ssrcMap.has(ssrc)) {
       userStat = this.connection.ssrcMap.get(ssrc); // Audio_ssrc
-      packet = this.parseBuffer(buffer);
+      packet = this.parseBuffer(buffer, userStat.userId);
       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);
+      packet = this.parseBuffer(buffer, userStat.userId);
       this.videoReceiver(ssrc, userStat, packet);
     }
     if (userStat && !(packet instanceof Error)) this.receiver.emit('receiverData', userStat, packet);

package/src/errors/Messages.js

@@ -186,7 +186,9 @@ const Messages = {
   VOICE_USER_MISSING: "Couldn't resolve the user to create stream.",
   VOICE_JOIN_CHANNEL: (full = false) =>
     `You do not have permission to join this voice channel${full ? '; it is full.' : '.'}`,
-  VOICE_CONNECTION_TIMEOUT: 'Connection not established within 15 seconds.',
+  VOICE_CONNECTION_TIMEOUT: 'Connection not established within 30 seconds.',
+  VOICE_DAVE_REQUIRED: '%s',
+  VOICE_SESSION_EXPIRED: 'Voice session is no longer valid.',
   VOICE_TOKEN_ABSENT: 'Token not provided from voice server packet.',
   VOICE_SESSION_ABSENT: 'Session ID not supplied.',
   VOICE_INVALID_ENDPOINT: 'Invalid endpoint received.',
@@ -208,6 +210,9 @@ const Messages = {
 
   STREAM_CONNECTION_READONLY: 'Cannot send data to a read-only stream',
   STREAM_CANNOT_JOIN: 'Cannot join a stream to itself',
+  STREAM_URL_REQUIRED: 'A url is required to start a stream.',
+  STREAM_CHANNEL_REQUIRED: 'guildId and channelId are required to start a stream.',
+  STREAM_CHANNEL_NOT_FOUND: 'The specified voice channel could not be found.',
   VOICE_USER_NOT_STREAMING: 'User is not streaming',
   POLL_ALREADY_EXPIRED: 'This poll has already expired.',
   METHOD_WARNING:

package/src/util/Constants.js

@@ -284,6 +284,18 @@ exports.VoiceOpcodes = {
   MEDIA_SINK_WANTS: 15,
   VOICE_BACKEND_VERSION: 16,
   CHANNEL_OPTIONS_UPDATE: 17,
+  CLIENTS_CONNECT: 11,
+  DAVE_PREPARE_TRANSITION: 21,
+  DAVE_EXECUTE_TRANSITION: 22,
+  DAVE_TRANSITION_READY: 23,
+  DAVE_PREPARE_EPOCH: 24,
+  DAVE_MLS_EXTERNAL_SENDER: 25,
+  DAVE_MLS_KEY_PACKAGE: 26,
+  DAVE_MLS_PROPOSALS: 27,
+  DAVE_MLS_COMMIT_WELCOME: 28,
+  DAVE_MLS_ANNOUNCE_COMMIT_TRANSITION: 29,
+  DAVE_MLS_WELCOME: 30,
+  DAVE_MLS_INVALID_COMMIT_WELCOME: 31,
 };
 
 /**

package/typings/index.d.ts

@@ -918,6 +918,7 @@ export class Client<Ready extends boolean = boolean> extends BaseClient {
       }
     >
   >;
+  public startStream(options: StartStreamOptions): Promise<StreamSession>;
 
   public on<K extends keyof ClientEvents>(event: K, listener: (...args: ClientEvents[K]) => Awaitable<void>): this;
   public on<S extends string | symbol>(
@@ -1189,6 +1190,34 @@ export class BaseDispatcher extends Writable {
   public once(event: string, listener: (...args: any[]) => void): this;
 }
 
+export interface StartStreamOptions {
+  guildId: Snowflake;
+  channelId: Snowflake;
+  url: string;
+  fps?: number;
+  height?: number;
+  bitrate?: number;
+  audioBitrate?: number;
+  videoCodec?: 'H264' | 'VP8';
+  preset?: string;
+  audio?: boolean;
+  /** Enable webcam. Default false (screenshare only). */
+  video?: boolean;
+}
+
+export class StreamSession extends EventEmitter {
+  public readonly client: Client;
+  public readonly voiceConnection: VoiceConnection;
+  public readonly streamConnection: StreamConnection;
+  public pause(): void;
+  public resume(): void;
+  public stop(): void;
+  public replay(): VideoDispatcher;
+  public disconnect(): void;
+  public on(event: 'finish', listener: () => void): this;
+  public once(event: 'finish', listener: () => void): this;
+}
+
 export class AudioDispatcher extends VolumeMixin(BaseDispatcher) {
   constructor(player: object, options?: StreamOptions, streams?: object);
   public readonly bitrateEditable: boolean;