songbird 0.6.0

An async Rust library for the Discord voice API.
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

use crate::{error::JsonError, input::AudioStreamError};
use opus2::Error as OpusError;
use std::{
    error::Error as StdError,
    fmt::{Display, Formatter, Result as FmtResult},
};
use streamcatcher::CatcherError;
use symphonia_core::errors::Error as SymphError;
use tokio::task::JoinError;

/// Errors encountered using a [`Memory`] cached source.
///
/// [`Memory`]: super::Memory
#[derive(Debug)]
pub enum Error {
    /// The audio stream could not be created.
    Create(AudioStreamError),
    /// The audio stream failed to be created due to a panic in `spawn_blocking`.
    CreatePanicked,
    /// Streamcatcher's configuration was illegal, and the cache could not be created.
    Streamcatcher(CatcherError),
    /// The input stream had already been read (i.e., `Parsed`) and so the whole stream
    /// could not be used.
    StreamNotAtStart,
}

impl Display for Error {
    fn fmt(&self, f: &mut Formatter<'_>) -> FmtResult {
        match self {
            Self::Create(c) => f.write_fmt(format_args!("failed to create audio stream: {c}")),
            Self::CreatePanicked => f.write_str("sync thread panicked while creating stream"),
            Self::Streamcatcher(s) =>
                f.write_fmt(format_args!("illegal streamcatcher config: {s}")),
            Self::StreamNotAtStart =>
                f.write_str("stream cannot have been pre-read/parsed, missing headers"),
        }
    }
}

impl StdError for Error {}

impl From<AudioStreamError> for Error {
    fn from(val: AudioStreamError) -> Self {
        Self::Create(val)
    }
}

impl From<CatcherError> for Error {
    fn from(val: CatcherError) -> Self {
        Self::Streamcatcher(val)
    }
}

impl From<JoinError> for Error {
    fn from(_val: JoinError) -> Self {
        Self::CreatePanicked
    }
}

/// Errors encountered using a [`Compressed`] or [`Decompressed`] cached source.
///
/// [`Compressed`]: super::Compressed
/// [`Decompressed`]: super::Decompressed
#[derive(Debug)]
pub enum CodecCacheError {
    /// The audio stream could not be created.
    Create(AudioStreamError),
    /// Symphonia failed to parse the container or decode the default stream.
    Parse(SymphError),
    /// The Opus encoder could not be created.
    Opus(OpusError),
    /// The file's metadata could not be converted to JSON.
    MetadataEncoding(JsonError),
    /// The input's metadata was too large after conversion to JSON to fit in a DCA file.
    MetadataTooLarge,
    /// The audio stream failed to be created due to a panic in `spawn_blocking`.
    CreatePanicked,
    /// The audio stream's channel count could not be determined.
    UnknownChannelCount,
    /// Streamcatcher's configuration was illegal, and the cache could not be created.
    Streamcatcher(CatcherError),
    /// The input stream had already been read (i.e., `Parsed`) and so the whole stream
    /// could not be used.
    StreamNotAtStart,
}

impl Display for CodecCacheError {
    fn fmt(&self, f: &mut Formatter<'_>) -> FmtResult {
        match self {
            Self::Create(c) => f.write_fmt(format_args!("failed to create audio stream: {c}")),
            Self::Parse(p) => f.write_fmt(format_args!("failed to parse audio format: {p}")),
            Self::Opus(o) => f.write_fmt(format_args!("failed to create Opus encoder: {o}")),
            Self::MetadataEncoding(m) => f.write_fmt(format_args!(
                "failed to convert track metadata to JSON: {m}"
            )),
            Self::MetadataTooLarge => f.write_str("track metadata was too large, >= 32kiB"),
            Self::CreatePanicked => f.write_str("sync thread panicked while creating stream"),
            Self::UnknownChannelCount =>
                f.write_str("audio stream's channel count could not be determined"),
            Self::Streamcatcher(s) =>
                f.write_fmt(format_args!("illegal streamcatcher config: {s}")),
            Self::StreamNotAtStart =>
                f.write_str("stream cannot have been pre-read/parsed, missing headers"),
        }
    }
}

impl StdError for CodecCacheError {}

impl From<AudioStreamError> for CodecCacheError {
    fn from(val: AudioStreamError) -> Self {
        Self::Create(val)
    }
}

impl From<CatcherError> for CodecCacheError {
    fn from(val: CatcherError) -> Self {
        Self::Streamcatcher(val)
    }
}

impl From<JoinError> for CodecCacheError {
    fn from(_val: JoinError) -> Self {
        Self::CreatePanicked
    }
}

impl From<JsonError> for CodecCacheError {
    fn from(val: JsonError) -> Self {
        Self::MetadataEncoding(val)
    }
}

impl From<OpusError> for CodecCacheError {
    fn from(val: OpusError) -> Self {
        Self::Opus(val)
    }
}

impl From<SymphError> for CodecCacheError {
    fn from(val: SymphError) -> Self {
        Self::Parse(val)
    }
}