discord-stream-rs 0.1.3

Discord voice/video streaming library for selfbots, ported from @dank074/discord-video-stream
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158

/// Ported from `utils.ts`.

use thiserror::Error;

#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub enum StreamType {
    Guild,
    Call,
}

impl std::fmt::Display for StreamType {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        match self {
            StreamType::Guild => write!(f, "guild"),
            StreamType::Call => write!(f, "call"),
        }
    }
}

#[derive(Debug, Clone)]
pub struct StreamKey {
    pub kind: StreamType,
    pub guild_id: Option<String>,
    pub channel_id: String,
    pub user_id: String,
}

#[derive(Debug, Error)]
pub enum StreamKeyError {
    #[error("invalid stream key type: {0}")]
    InvalidType(String),
    #[error("stream key too short: {0}")]
    TooShort(String),
}

/// Parse a Discord stream key.  
/// Format: `guild:<guild_id>:<channel_id>:<user_id>` or `call:<channel_id>:<user_id>`
pub fn parse_stream_key(key: &str) -> Result<StreamKey, StreamKeyError> {
    let mut parts: Vec<&str> = key.splitn(5, ':').collect();
    let kind_str = parts.remove(0);
    let kind = match kind_str {
        "guild" => StreamType::Guild,
        "call" => StreamType::Call,
        other => return Err(StreamKeyError::InvalidType(other.to_owned())),
    };

    match kind {
        StreamType::Guild => {
            if parts.len() < 3 {
                return Err(StreamKeyError::TooShort(key.to_owned()));
            }
            Ok(StreamKey {
                kind,
                guild_id: Some(parts[0].to_owned()),
                channel_id: parts[1].to_owned(),
                user_id: parts[2].to_owned(),
            })
        }
        StreamType::Call => {
            if parts.len() < 2 {
                return Err(StreamKeyError::TooShort(key.to_owned()));
            }
            Ok(StreamKey {
                kind,
                guild_id: None,
                channel_id: parts[0].to_owned(),
                user_id: parts[1].to_owned(),
            })
        }
    }
}

/// Generate a Discord stream key.
pub fn generate_stream_key(
    kind: StreamType,
    guild_id: Option<&str>,
    channel_id: &str,
    user_id: &str,
) -> String {
    match kind {
        StreamType::Guild => {
            format!(
                "guild:{}:{}:{}",
                guild_id.unwrap_or(""),
                channel_id,
                user_id
            )
        }
        StreamType::Call => {
            format!("call:{}:{}", channel_id, user_id)
        }
    }
}

// ---------------------------------------------------------------------------
// Video codec helpers
// ---------------------------------------------------------------------------

#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub enum VideoCodec {
    H264,
    H265,
    Vp8,
    Vp9,
    Av1,
}

impl std::fmt::Display for VideoCodec {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        match self {
            VideoCodec::H264 => write!(f, "H264"),
            VideoCodec::H265 => write!(f, "H265"),
            VideoCodec::Vp8 => write!(f, "VP8"),
            VideoCodec::Vp9 => write!(f, "VP9"),
            VideoCodec::Av1 => write!(f, "AV1"),
        }
    }
}

#[derive(Debug, Error)]
#[error("unknown codec: {0}")]
pub struct UnknownCodecError(pub String);

/// Normalize a codec string to a [`VideoCodec`].
/// Mirrors `normalizeVideoCodec()` in `utils.ts`.
pub fn normalize_video_codec(s: &str) -> Result<VideoCodec, UnknownCodecError> {
    let upper = s.to_uppercase();
    if upper.contains("264") || upper.contains("AVC") {
        return Ok(VideoCodec::H264);
    }
    if upper.contains("265") || upper.contains("HEVC") {
        return Ok(VideoCodec::H265);
    }
    if upper.contains("VP8") {
        return Ok(VideoCodec::Vp8);
    }
    if upper.contains("VP9") {
        return Ok(VideoCodec::Vp9);
    }
    if upper.contains("AV1") {
        return Ok(VideoCodec::Av1);
    }
    Err(UnknownCodecError(s.to_owned()))
}

// ---------------------------------------------------------------------------
// Encryption mode constants  (SupportedEncryptionModes in utils.ts)
// ---------------------------------------------------------------------------

pub const ENCRYPTION_AES256: &str = "aead_aes256_gcm_rtpsize";
pub const ENCRYPTION_XCHACHA20: &str = "aead_xchacha20_poly1305_rtpsize";

// Hardcoded simulcast descriptor sent in IDENTIFY (STREAMS_SIMULCAST in utils.ts)
pub const STREAMS_SIMULCAST_RID: &str = "100";
pub const STREAMS_SIMULCAST_QUALITY: u8 = 100;

pub const MAX_INT16: u32 = 1 << 16;
pub const MAX_INT32: u64 = 1 << 32;