kithara-decode 0.0.1-alpha2

Pluggable audio decode (Symphonia / Apple / Android) to PCM.
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

use kithara_stream::AudioCodec;
use thiserror::Error;

use crate::DecodeError;

#[derive(Debug, Error)]
pub(crate) enum AndroidBackendError {
    #[error("android hardware backend is unavailable on API level {api_level}")]
    ApiLevelUnavailable { api_level: String },

    #[error("android hardware backend does not support codec {codec:?}")]
    UnsupportedCodec { codec: AudioCodec },

    #[error("android backend does not support pcm encoding {encoding}")]
    UnsupportedPcmEncoding { encoding: i32 },

    #[error("android backend failed during {operation}: {details}")]
    Operation {
        operation: &'static str,
        details: String,
    },
}

impl AndroidBackendError {
    pub(crate) fn api_level_unavailable(api_level: Option<u32>) -> Self {
        Self::ApiLevelUnavailable {
            api_level: api_level.map_or_else(|| "unknown".to_string(), |value| value.to_string()),
        }
    }

    pub(crate) fn operation(operation: &'static str, details: impl Into<String>) -> Self {
        Self::Operation {
            operation,
            details: details.into(),
        }
    }
}

impl From<AndroidBackendError> for DecodeError {
    fn from(err: AndroidBackendError) -> Self {
        match err {
            AndroidBackendError::UnsupportedCodec { codec } => DecodeError::UnsupportedCodec(codec),
            _ => DecodeError::backend(err),
        }
    }
}