raplay 0.4.3

Library for playing audio
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

use thiserror::Error;

use crate::source::symph;

use cpal::{
    BuildStreamError, DefaultStreamConfigError, DevicesError,
    PauseStreamError, PlayStreamError, StreamError,
    SupportedStreamConfigsError,
};

/// Result with this crate error type [`enum@Error`]
pub type Result<T> = std::result::Result<T, Error>;

/// Error type of this crate
#[derive(Error, Debug)]
pub enum Error {
    #[error("Failed to convert to timestamp")]
    CannotDetermineTimestamp,
    /// Error that is returned when something fails to lock some resource
    #[error("Failed to aquire lock")]
    PoisonError,
    /// Returned when the device uses an unsupported sample format
    #[error("Format supported by the device is not supported by the library")]
    UnsupportedSampleFormat,
    /// Returned when the sink fails to select output device
    #[error("No available output device was found")]
    NoOutDevice,
    /// Returned when some feature is not supported
    #[error("{component} doesn't support {feature}")]
    Unsupported {
        component: &'static str,
        feature: &'static str,
    },
    /// Returned when Sink tries to do action on Source, but there is no source
    #[error("Cannot operate on a source because there is no source playing")]
    NoSourceIsPlaying,
    #[error("Cannot load prefetched source. There is no prefetched source.")]
    NoPrefetchedSource,
    /// Cpal errors
    #[error(transparent)]
    Cpal(#[from] CpalError),
    /// Errors from the [`crate::source::Symph`] source
    #[error(transparent)]
    Symph(#[from] symph::Error),
    /// Any other error, usually from a custom source
    #[error(transparent)]
    Other(anyhow::Error),
}

impl From<anyhow::Error> for Error {
    fn from(value: anyhow::Error) -> Self {
        if value.is::<Self>() {
            value.downcast().unwrap()
        } else {
            Self::Other(value)
        }
    }
}

impl<T> From<std::sync::PoisonError<T>> for Error {
    fn from(_value: std::sync::PoisonError<T>) -> Self {
        Self::PoisonError
    }
}

macro_rules! impl_cpal {
    ($($i:ident -> $t:ty),+ $(,)?) => {
        $(
            impl From<$t> for Error {
                fn from(value: $t) -> Self {
                    Self::Cpal(value.into())
                }
            }
        )+

        #[derive(Error, Debug)]
        pub enum CpalError {
            $(
                #[error(transparent)]
                $i(#[from] $t),
            )+
        }
    };
}

impl_cpal!(
    DefaultStreamConfig -> DefaultStreamConfigError,
    Stream -> StreamError,
    BuildStream -> BuildStreamError,
    PlayStream -> PlayStreamError,
    SupportedConfigs -> SupportedStreamConfigsError,
    PauseStreamError -> PauseStreamError,
    DevicesError -> DevicesError,
);