selene-core 0.9.0-rc.1

Backend for selene-server
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

use std::{
    fs,
    io::{Read, Seek},
    path::{Path, PathBuf},
};

use serde::{Deserialize, Serialize};
use symphonia::core::{
    formats::{FormatOptions, TrackType, probe::Hint},
    io::MediaSourceStream,
    meta::MetadataOptions,
};
use thiserror::Error;

mod codec;
pub use codec::*;

mod format;
pub use format::*;

mod sample_format;
pub use sample_format::*;

mod stream;
pub use stream::*;

#[derive(Debug, Error)]
pub enum ContainerError {
    #[error("IoError: {0}")]
    Io(#[from] std::io::Error),

    #[error("Codec Error: {0}")]
    Codec(#[from] CodecError),

    #[error("Symphonia Error: {0}")]
    Symphonia(#[from] symphonia::core::errors::Error),

    #[error("File '{0}' has no tracks/streams")]
    NoStream(PathBuf),

    #[error("File '{0}' has an unsupported container")]
    InvalidSource(PathBuf),

    #[error("'{0:?}' is an unsupported container")]
    UnsupportedContainer(Format),

    #[error("Couldn't find sample rate")]
    NoSampleRate,

    #[error("Couldn't find channel count'")]
    NoChannelCount,

    #[error("Couldn't find an audio stream")]
    NoAudioStream,

    #[error("The track is unplayable")]
    Unplayable,
}

#[derive(Debug, Clone, PartialEq, Deserialize, Serialize)]
pub struct MediaContainer {
    pub(crate) format: Format,
    pub(crate) stream: Stream,
}

impl MediaContainer {
    #[must_use]
    pub fn format(&self) -> Format {
        self.format
    }

    /// Returns the file extension this [`MediaContainer`] uses.
    #[must_use]
    pub fn extension(&self) -> &'static str {
        let format = self.format;
        let codec = self.stream.codec_params.codec;
        match format {
            Format::Flac if codec.is_flac() => "flac",
            Format::Mp3 if codec.is_mp3() => "mp3",
            Format::Ogg if codec.is_vorbis() => "ogg",
            Format::Ogg if codec.is_opus() => "opus",
            Format::Ogg if codec.is_flac() => "oga",
            Format::Wav if codec.is_pcm() => "wav",
            Format::Aiff if codec.is_pcm() => "aiff",
            Format::Ape if codec.is_ape() => "ape",
            _ => panic!("Invalid format/codec pairing: {format:?} + {codec:?}"),
        }
    }

    /// Returns the mime type of this [`MediaContainer`] uses.
    #[must_use]
    pub fn mime_type(&self) -> &'static str {
        let format = self.format;
        let codec = self.stream.codec_params.codec;
        match format {
            Format::Flac if codec.is_flac() => "audio/flac",
            Format::Mp3 if codec.is_mp3() => "audio/mpeg",
            Format::Ogg if codec.is_vorbis() => "audio/ogg",
            Format::Ogg if codec.is_opus() => "audio/opus",
            Format::Ogg if codec.is_flac() => "audio/oga",
            Format::Wav if codec.is_pcm() => "audio/wav",
            Format::Aiff if codec.is_pcm() => "audio/aiff",
            Format::Ape if codec.is_ape() => "audio/x-ape",
            _ => panic!("Invalid format/codec pairing: {format:?} + {codec:?}"),
        }
    }

    #[must_use]
    pub fn stream(&self) -> &Stream {
        &self.stream
    }
}

pub fn extract_from_file(path: impl AsRef<Path>) -> Result<MediaContainer, ContainerError> {
    let path = path.as_ref();
    let mut file = fs::File::open(path)?;

    let mut buf = [0_u8; 16];
    file.read_exact(&mut buf)?;
    file.seek(std::io::SeekFrom::Start(0))?;

    let container_format =
        Format::from_buf(&buf).ok_or_else(|| ContainerError::InvalidSource(path.to_path_buf()))?;

    let mss = MediaSourceStream::new(Box::new(file), Default::default());
    let fmt_opts = FormatOptions::default();
    let metadata_opts = MetadataOptions::default();
    let probe =
        symphonia::default::get_probe().probe(&Hint::new(), mss, fmt_opts, metadata_opts)?;

    let track = probe
        .default_track(TrackType::Audio)
        .or_else(|| probe.first_track(TrackType::Audio))
        .ok_or(ContainerError::NoAudioStream)?;
    let stream = Stream::try_from(track)?;

    let container = MediaContainer {
        format: container_format,
        stream,
    };

    Ok(container)
}