djs-selfbot-v13 3.7.32 → 3.7.34

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,11 @@ 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. Close the official Discord app (desktop/mobile) on this account, leave any voice channel, then retry.',
+  VOICE_DAVE_REQUIRED: '%s',
+  VOICE_SESSION_EXPIRED:
+    'Voice session is no longer valid (4006). Quit any other Discord client on this account, leave voice channels, then retry.',
   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 +212,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,41 @@ 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;
+  width?: number;
+  bitrate?: number;
+  audioBitrate?: number;
+  videoCodec?: 'H264' | 'VP8';
+  preset?: string;
+  audio?: boolean;
+  /** Enable webcam. Default false (screenshare only). */
+  video?: boolean;
+  /** Download HTTP URLs locally before playback. Default true. */
+  downloadHttp?: boolean;
+  /** Max video bitrate in kbps. Default: bitrate * 1.5 */
+  bitrateMax?: number;
+  /** Low-latency encoding and playback. Default true. */
+  lowLatency?: 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;