selene-core 0.4.2

selene-core is the backend for Selene, a local-first music player
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

use std::process::Command;

use serde::{Deserialize, Serialize};

use crate::media_container::{Codec, ContainerFormat};

pub const BITRATE_128K: u32 = 128_000;
pub const BITRATE_192K: u32 = 192_000;
pub const BITRATE_256K: u32 = 256_000;
pub const BITRATE_320K: u32 = 320_000;

#[derive(Debug, Clone, Copy, Serialize, Deserialize, PartialEq, Eq)]
pub struct TranscodeSettings {
    pub from_format: Option<ContainerFormat>,
    pub from_codec: Option<Codec>,
    pub target: TranscodeTarget,
}

impl TranscodeSettings {
    #[must_use] 
    pub fn to_flac(from_format: Option<ContainerFormat>, from_codec: Option<Codec>) -> Self {
        Self {
            from_format,
            from_codec,
            target: TranscodeTarget::Flac(FlacEncoderSettings::default()),
        }
    }

    #[must_use] 
    pub fn is_lossless(&self) -> bool {
        matches!(self.target, TranscodeTarget::Flac(_))
    }

    pub fn add_ffmpeg_args(&self, command: &mut Command) {
        match self.target {
            TranscodeTarget::Flac(flac_encoder_settings) => {
                flac_encoder_settings.add_ffmpeg_args(command);
            }
        }
    }

    #[must_use] 
    pub fn container_codec(&self) -> (ContainerFormat, Codec) {
        match self.target {
            TranscodeTarget::Flac(_) => (ContainerFormat::Flac, Codec::Flac),
        }
    }
}

#[derive(Debug, Clone, Copy, Serialize, Deserialize, PartialEq, Eq)]
pub enum TranscodeTarget {
    Flac(FlacEncoderSettings),
}

#[derive(Debug, Clone, Copy, Serialize, Deserialize, PartialEq, Eq)]
pub struct FlacEncoderSettings {
    pub compression_level: u8,
}

impl FlacEncoderSettings {
    pub fn add_ffmpeg_args(&self, command: &mut Command) {
        command
            .args(["-f", "flac", "-c:a", "flac", "-compression_level"])
            .arg(self.compression_level.to_string());
    }
}

impl Default for FlacEncoderSettings {
    fn default() -> Self {
        Self {
            compression_level: 5,
        }
    }
}