caesura 0.29.0

An all-in-one command line tool to transcode FLAC audio files and upload to gazelle based indexers/trackers
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

use crate::prelude::*;
use tokio::fs::{copy, create_dir_all, hard_link};

/// File extensions recognized as cover-art images when collecting additional files.
pub const IMAGE_EXTENSIONS: [&str; 3] = ["jpg", "jpeg", "png"];
/// File extensions recognized as text metadata when collecting additional files.
pub const TEXT_EXTENSIONS: [&str; 5] = ["cue", "log", "nfo", "rtf", "txt"];

/// Factory for creating [`AdditionalJob`] instances.
#[injectable]
pub(crate) struct AdditionalJobFactory {
    copy_options: Ref<CopyOptions>,
    file_options: Ref<FileOptions>,
    paths: Ref<PathManager>,
}

impl AdditionalJobFactory {
    /// Create an [`AdditionalJob`] for each [`AdditionalFile`].
    pub(crate) async fn create(
        &self,
        files: &[AdditionalFile],
        source: &Source,
        target: TargetFormat,
    ) -> Result<Vec<Job>, Failure<TranscodeAction>> {
        let mut jobs = Vec::new();
        for (index, file) in files.iter().enumerate() {
            if let Some(job) = self.create_single(index, file, source, target).await? {
                jobs.push(job);
            }
        }
        Ok(jobs)
    }

    /// Create a single [`AdditionalJob`] from a `flac_file`.
    #[allow(clippy::integer_division)]
    async fn create_single(
        &self,
        index: usize,
        file: &AdditionalFile,
        source: &Source,
        target: TargetFormat,
    ) -> Result<Option<Job>, Failure<TranscodeAction>> {
        let source_path = file.path.clone();
        let output_dir = self
            .paths
            .get_transcode_target_dir(source, target)
            .join(&file.sub_dir);
        let mut output_path = output_dir.join(&file.file_name);
        let size = file
            .get_size()
            .await
            .map_err(Failure::wrap(TranscodeAction::ReadFlac))?;
        let max_file_size = self.file_options.max_file_size;
        let extension = source_path
            .extension()
            .expect("Source has extension")
            .to_string_lossy()
            .to_string()
            .to_lowercase();
        let is_image = IMAGE_EXTENSIONS.contains(&extension.as_str());
        let is_large = size > max_file_size;
        let no_image_compression = self.file_options.no_image_compression;
        create_dir_all(&output_dir)
            .await
            .map_err(Failure::wrap_with_path(
                TranscodeAction::CreateOutputDirectory,
                &output_dir,
            ))?;
        if !is_image || no_image_compression || !is_large {
            if is_large {
                warn!(
                    "Including large {} ({} KB): {}",
                    extension,
                    size / 1_000,
                    source_path.display()
                );
            }
            let verb =
                if self.copy_options.hard_link {
                    hard_link(&source_path, &output_path).await.map_err(
                        Failure::wrap_with_path(TranscodeAction::HardLinkAdditional, &output_path),
                    )?;
                    "Hard Linked"
                } else {
                    copy(&source_path, &output_path)
                        .await
                        .map_err(Failure::wrap_with_path(
                            TranscodeAction::CopyAdditional,
                            &output_path,
                        ))?;
                    "Copied"
                };
            trace!(
                "{} {} to {}",
                verb.bold(),
                &source_path.display(),
                &output_path.display()
            );
            return Ok(None);
        }
        let no_png_to_jpg = self.file_options.no_png_to_jpg;
        if !no_png_to_jpg && extension == "png" {
            let mut temp_source = source_path.clone();
            temp_source.set_extension("jpg");
            if temp_source.exists() {
                output_path.set_extension("png.jpg");
            } else {
                output_path.set_extension("jpg");
            }
        }
        let id = format!("Additional {target:<7?}{index:>3}");
        let max_pixel_size = self.file_options.max_pixel_size;
        let quality = self.file_options.jpg_quality;
        let job = Job::Additional(AdditionalJob {
            id,
            resize: Resize {
                input: source_path,
                output: output_path,
                max_pixel_size,
                quality,
            },
        });
        Ok(Some(job))
    }
}