flac-tracksplit 0.1.0

Split FLAC+CUE (embedded) into multiple tracks
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

use std::path::PathBuf;

use anyhow::Context;
use bytesize::ByteSize;
use clap::Parser;
use flac_tracksplit::split_one_file;
use rayon::prelude::*;
use tracing::error;
use tracing_subscriber::prelude::*;
use tracing_subscriber::EnvFilter;

#[derive(Debug, Parser)]
#[command(author, version, about, long_about=None)]
struct Args {
    /// Pathnames of .flac files (with embedded CUE sheets) to split into tracks.
    paths: Vec<PathBuf>,

    /// Output directory into which to sort resulting per-track FLAC files.
    /// Tracks will be named according to this template:
    ///
    /// OUTPUT_DIR/<Album Artist>/<Release year> - <Album name>/<Trackno>.<Track title>.flac
    #[arg(long, default_value = "./")]
    output_dir: PathBuf,

    /// Number of 0-byte padding to add to the end of the metadata
    /// block. More padding allows larger additions to metadata
    /// without having to rewrite the whole file.
    #[arg(long, default_value = "2kB")]
    metadata_padding: ByteSize,
}

fn main() -> anyhow::Result<()> {
    // Setup logging:
    let indicatif_layer = tracing_indicatif::IndicatifLayer::new();
    let filter = EnvFilter::builder()
        .with_default_directive(tracing_subscriber::filter::LevelFilter::INFO.into())
        .from_env_lossy();
    let writer = indicatif_layer.get_stderr_writer();
    let app_log_layer = tracing_subscriber::fmt::layer()
        .with_target(false)
        .compact()
        .with_writer(writer);
    tracing_subscriber::registry()
        .with(filter)
        .with(app_log_layer)
        .with(indicatif_layer)
        .init();

    let args = Args::parse();
    let base_path = args.output_dir.as_path();
    let metadata_padding: u32 = args
        .metadata_padding
        .as_u64()
        .try_into()
        .context("--metadata-padding should fit into a 32-bit unsigned int")?;
    if let Err(err) = args
        .paths
        .into_par_iter()
        .panic_fuse()
        .try_for_each(|path| {
            split_one_file(&path, base_path, metadata_padding)
                .map(|_| ())
                .with_context(|| format!("splitting {:?}", path))
        })
    {
        error!(error = %err);
        Err(err)
    } else {
        Ok(())
    }
}