mp3rgain 3.6.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
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

pub mod apply;
pub mod info;
pub mod max_amplitude;
pub mod replaygain;
pub mod tags;
pub mod threading;
pub mod undo;
pub mod utils;

use anyhow::Result;
use colored::*;

use crate::cli::options::{Options, OutputFormat, StoredTagMode};
use crate::cli::parse_args::expand_files_recursive;

use apply::{cmd_apply, cmd_apply_channel};
use info::cmd_info;
use max_amplitude::cmd_max_amplitude;
use replaygain::{cmd_album_gain, cmd_album_gain_per_directory, cmd_track_gain};
use tags::{cmd_check_tags, cmd_delete_tags};
use undo::cmd_undo;

/// Validate options and dispatch to the appropriate `cmd_*` handler.
pub fn run(mut opts: Options) -> Result<()> {
    // Validate options
    if opts.files.is_empty() {
        eprintln!("{}: no files specified", "error".red().bold());
        std::process::exit(1);
    }

    // Expand files if recursive mode
    if opts.recursive {
        opts.files = expand_files_recursive(&opts.files)?;
        if opts.files.is_empty() {
            eprintln!("{}: no audio files found (MP3/M4A)", "error".red().bold());
            std::process::exit(1);
        }
    }

    // Configure the global rayon pool from -j / --threads / MP3RGAIN_THREADS.
    // Default is std::thread::available_parallelism(); -j 1 forces serial.
    threading::install_global_pool(threading::effective_threads(&opts));

    // -f option warning (assume MPEG2)
    if opts.assume_mpeg2 && !opts.quiet && opts.output_format == OutputFormat::Text {
        eprintln!(
            "{}: -f (assume MPEG2) is accepted for compatibility but has no effect",
            "note".cyan()
        );
    }

    // -s r warning: recalculation is mp3rgain's default, so the flag only
    // matters as an override of -s R (issues #253, #298)
    if opts.force_recalc
        && !opts.use_stored_tags
        && !opts.quiet
        && opts.output_format == OutputFormat::Text
    {
        eprintln!(
            "{}: -s r (force recalculation) is accepted for compatibility but has no effect (recalculation is the default; use -s R to reuse stored tags)",
            "note".cyan()
        );
    }

    // -s R warning: tell the user up front when stored tags will be ignored
    // (see Options::stored_tags_usable for the reasons)
    if opts.use_stored_tags
        && !opts.stored_tags_usable()
        && !opts.quiet
        && opts.output_format == OutputFormat::Text
    {
        eprintln!(
            "{}: -s R is ignored with -s r, -d/-m modifiers, or --rg2/--r128; files will be re-analyzed",
            "note".cyan()
        );
    }

    // Determine action based on options
    if opts.max_amplitude_only {
        // -x: only find max amplitude
        return cmd_max_amplitude(&opts.files, &opts);
    }

    if opts.stored_tag_mode == StoredTagMode::Delete {
        // -s d: delete stored tag info. With -u, cmd_delete_tags undoes the
        // frame-level gain first: deleting first would destroy MP3GAIN_UNDO
        // and make the applied gain permanently irreversible (issue #305).
        return cmd_delete_tags(&opts.files, &opts);
    }

    if opts.stored_tag_mode == StoredTagMode::Check {
        // -s c: check/show stored tag info
        return cmd_check_tags(&opts.files, &opts);
    }

    if opts.undo {
        // -u: undo from APEv2 tags
        return cmd_undo(&opts.files, &opts);
    }

    if opts.album_gain && !opts.skip_album {
        // -a: apply album gain (ReplayGain), per directory with --per-directory
        if opts.per_directory {
            return cmd_album_gain_per_directory(&opts.files, &opts);
        }
        return cmd_album_gain(&opts.files, &opts);
    }

    if opts.track_gain || opts.skip_album {
        // -r or -e: apply track gain (ReplayGain)
        return cmd_track_gain(&opts.files, &opts);
    }

    if let Some((channel, steps)) = opts.channel_gain {
        // -l: apply channel-specific gain
        return cmd_apply_channel(&opts.files, channel, steps, &opts);
    }

    if let Some(steps) = opts.gain_steps {
        // -g: apply fixed gain steps
        cmd_apply(&opts.files, steps, &opts)
    } else {
        // Default: analyze files (mp3gain compatible)
        // With -d modifier, perform ReplayGain analysis
        cmd_info(&opts.files, &opts)
    }
}