mp3rgain 3.1.1

Lossless MP3 volume adjustment - a modern mp3gain replacement written in Rust
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

use anyhow::Result;
use colored::*;
use mp3rgain::{find_max_amplitude, peak_to_headroom_db, peak_to_pcm_sample};
use std::fmt::Write as _;
use std::path::{Path, PathBuf};

use crate::cli::options::{Options, OutputFormat};
use crate::commands::utils::{finish_without_summary, for_each_file};
use crate::json_output::JsonFileResult;
use crate::util::get_filename;

pub fn cmd_max_amplitude(files: &[PathBuf], opts: &Options) -> Result<()> {
    if opts.output_format == OutputFormat::Text && !opts.quiet {
        println!(
            "{} Finding maximum amplitude for {} file(s)",
            "mp3rgain".green().bold(),
            files.len()
        );
        println!();
    }

    let (json_results, _, _) =
        for_each_file(files, opts, |file| Ok(process_max_amplitude(file, opts)))?;

    finish_without_summary(json_results, opts)
}

fn process_max_amplitude(file: &Path, opts: &Options) -> (Option<JsonFileResult>, String) {
    let filename = get_filename(file);
    let mut out = String::new();

    match find_max_amplitude(file) {
        Ok(amp_result) => {
            let max_amp = amp_result.max_amplitude();
            let max_gain = amp_result.max_global_gain();
            let min_gain = amp_result.min_global_gain();
            // Convert to PCM scale (like mp3gain: 0-32768+)
            let max_pcm_sample = peak_to_pcm_sample(max_amp);
            let headroom_db: Option<f64> = peak_to_headroom_db(max_amp);
            let headroom_text = match headroom_db {
                Some(d) => format!("{:+.2}", d),
                None => "(silent)".to_string(),
            };

            match opts.output_format {
                OutputFormat::Text => {
                    if !opts.quiet {
                        writeln!(out, "{}", filename.cyan().bold()).ok();
                        writeln!(out, "  Max PCM sample: {:.6}", max_pcm_sample).ok();
                        writeln!(out, "  Headroom:       {} dB", headroom_text).ok();
                        writeln!(out, "  Max global_gain: {}", max_gain).ok();
                        writeln!(out, "  Min global_gain: {}", min_gain).ok();
                        writeln!(out).ok();
                    } else {
                        writeln!(
                            out,
                            "{}\t{:.6}\t{}",
                            filename, max_pcm_sample, headroom_text
                        )
                        .ok();
                    }
                    (None, out)
                }
                OutputFormat::Tsv => {
                    writeln!(
                        out,
                        "{}\t{:.6}\t{}\t{}\t{}",
                        filename, max_pcm_sample, headroom_text, max_gain, min_gain
                    )
                    .ok();
                    (None, out)
                }
                OutputFormat::Json => (
                    Some(JsonFileResult {
                        file: file.display().to_string(),
                        max_amplitude: Some(max_pcm_sample),
                        headroom_db,
                        max_gain: Some(max_gain),
                        min_gain: Some(min_gain),
                        ..Default::default()
                    }),
                    out,
                ),
            }
        }
        Err(e) => {
            if opts.output_format == OutputFormat::Json {
                (Some(JsonFileResult::error(file, e)), out)
            } else {
                if !opts.quiet {
                    eprintln!("{} - {}", filename.red(), e);
                }
                (None, out)
            }
        }
    }
}