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

mod file;
mod hls;
mod http;
mod ytdl;

pub use self::{file::*, hls::*, http::*, ytdl::*};

use std::{
    io::{ErrorKind as IoErrorKind, Result as IoResult, SeekFrom},
    pin::Pin,
    task::{Context, Poll},
};

use async_trait::async_trait;
use pin_project::pin_project;
use tokio::io::{AsyncRead, AsyncSeek, ReadBuf};

use crate::input::{AsyncMediaSource, AudioStreamError};

/// `AsyncReadOnlySource` wraps any source implementing [`tokio::io::AsyncRead`] in an unseekable
/// [`symphonia_core::io::MediaSource`], similar to [`symphonia_core::io::ReadOnlySource`]
#[pin_project]
pub struct AsyncReadOnlySource {
    #[pin]
    stream: Box<dyn AsyncRead + Send + Sync + Unpin>,
}

impl AsyncReadOnlySource {
    /// Instantiates a new `AsyncReadOnlySource` by taking ownership and wrapping the provided
    /// `Read`er.
    pub fn new<R>(inner: R) -> Self
    where
        R: AsyncRead + Send + Sync + Unpin + 'static,
    {
        AsyncReadOnlySource {
            stream: Box::new(inner),
        }
    }

    /// Gets a reference to the underlying reader.
    #[allow(clippy::borrowed_box)] // FIXME: Changing this may break compatibility. remedy in v0.5
    #[must_use]
    pub fn get_ref(&self) -> &Box<dyn AsyncRead + Send + Sync + Unpin> {
        &self.stream
    }

    /// Unwraps this `AsyncReadOnlySource`, returning the underlying reader.
    #[must_use]
    pub fn into_inner<R>(self) -> Box<dyn AsyncRead + Send + Sync + Unpin> {
        self.stream
    }
}

impl AsyncRead for AsyncReadOnlySource {
    fn poll_read(
        self: Pin<&mut Self>,
        cx: &mut Context<'_>,
        buf: &mut ReadBuf<'_>,
    ) -> Poll<IoResult<()>> {
        AsyncRead::poll_read(self.project().stream, cx, buf)
    }
}

impl AsyncSeek for AsyncReadOnlySource {
    fn start_seek(self: Pin<&mut Self>, _position: SeekFrom) -> IoResult<()> {
        Err(IoErrorKind::Unsupported.into())
    }

    fn poll_complete(self: Pin<&mut Self>, _cx: &mut Context<'_>) -> Poll<IoResult<u64>> {
        unreachable!()
    }
}

#[async_trait]
impl AsyncMediaSource for AsyncReadOnlySource {
    fn is_seekable(&self) -> bool {
        false
    }

    async fn byte_len(&self) -> Option<u64> {
        None
    }

    async fn try_resume(
        &mut self,
        _offset: u64,
    ) -> Result<Box<dyn AsyncMediaSource>, AudioStreamError> {
        Err(AudioStreamError::Unsupported)
    }
}