feat: add -i option for track index selection (issue #25)

- Add -i <n> option to specify which audio track to process in multi-track files
- Default to track index 0 (first audio track)
- Useful for MP4/M4V files with multiple audio tracks (e.g., different languages)
- Add aacgain to acknowledgements in README
- Bump version to 1.1.0

Author: m_igashi

Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "mp3rgain"
-version = "1.0.0"
+version = "1.1.0"
 edition = "2021"
 authors = ["Masanari Higashi <M-Igashi@users.noreply.github.com>"]
 description = "Lossless MP3 volume adjustment - a modern mp3gain replacement written in Rust"

README.md

@@ -123,6 +123,10 @@ mp3rgain -r *.mp3 *.m4a
 
 # Recursive directory processing includes M4A files
 mp3rgain -R /path/to/music
+
+# Process specific audio track in multi-track files (e.g., video files)
+mp3rgain -i 1 movie.m4v   # Process second audio track
+mp3rgain -i 0 song.m4a    # Process first track (default)
 ```
 
 Note: For M4A files, mp3rgain writes ReplayGain tags (iTunes freeform format) but does not modify the audio data, as AAC doesn't have a lossless gain adjustment mechanism like MP3's `global_gain` field.
@@ -255,6 +259,7 @@ Example JSON output:
 | `-r` | Apply Track gain (ReplayGain analysis) |
 | `-a` | Apply Album gain (ReplayGain analysis) |
 | `-e` | Skip album analysis (even with multiple files) |
+| `-i <n>` | Specify which audio track to process (default: 0) |
 | `-u` | Undo gain changes (restore from APEv2 tag) |
 | `-x` | Only find max amplitude of file |
 | `-s <mode>` | Stored tag handling: `c` (check), `d` (delete), `s` (skip), `r` (recalc), `i` (ID3v2), `a` (APEv2) |
@@ -364,6 +369,7 @@ println!("Headroom: {} steps", info.headroom_steps);
 
 - [symphonia](https://github.com/pdrat/symphonia) - Pure Rust audio decoding library (used for ReplayGain analysis)
 - [Original mp3gain](http://mp3gain.sourceforge.net/) - The original C implementation that inspired this project
+- [aacgain](https://aacgain.altosdesign.com/) - AAC/MP4 ReplayGain implementation that inspired the `-i` track index option
 
 ## Contributing
 

src/main.rs

@@ -69,6 +69,7 @@ struct Options {
     album_gain: bool,               // -a (apply album gain)
     skip_album: bool,               // -e: skip album analysis
     max_amplitude_only: bool,       // -x: only find max amplitude
+    track_index: Option<u32>,       // -i <index>: track index for multi-track files
 
     // Behavior options
     preserve_timestamp: bool,    // -p
@@ -323,6 +324,18 @@ fn parse_args(args: &[String]) -> Result<Options> {
                 "a" => opts.album_gain = true,
                 "e" => opts.skip_album = true,
                 "x" => opts.max_amplitude_only = true,
+                "i" => {
+                    i += 1;
+                    if i >= args.len() {
+                        eprintln!("{}: -i requires an argument", "error".red().bold());
+                        std::process::exit(1);
+                    }
+                    opts.track_index = Some(
+                        args[i]
+                            .parse()
+                            .map_err(|_| anyhow::anyhow!("invalid track index: {}", args[i]))?,
+                    );
+                }
                 "u" => opts.undo = true,
                 "p" => opts.preserve_timestamp = true,
                 "c" => opts.ignore_clipping = true,
@@ -386,6 +399,14 @@ fn parse_args(args: &[String]) -> Result<Options> {
                         .parse()
                         .map_err(|_| anyhow::anyhow!("invalid modifier value: {}", val))?;
                 }
+                // Handle -i with attached value (e.g., -i1)
+                _ if flag.starts_with('i') => {
+                    let val = &flag[1..];
+                    opts.track_index = Some(
+                        val.parse()
+                            .map_err(|_| anyhow::anyhow!("invalid track index: {}", val))?,
+                    );
+                }
                 _ => {
                     eprintln!("{}: unknown option: -{}", "warning".yellow().bold(), flag);
                 }
@@ -1308,7 +1329,7 @@ fn cmd_album_gain(files: &[PathBuf], opts: &Options) -> Result<()> {
 
     let file_refs: Vec<&std::path::Path> = files.iter().map(|p| p.as_path()).collect();
 
-    match replaygain::analyze_album(&file_refs) {
+    match replaygain::analyze_album_with_index(&file_refs, opts.track_index) {
         Ok(album_result) => {
             // Apply gain modifier
             let modified_gain_steps = album_result.album_gain_steps() + opts.gain_modifier;
@@ -1893,7 +1914,7 @@ fn process_track_gain(file: &PathBuf, opts: &Options) -> Result<JsonFileResult>
         );
     }
 
-    match replaygain::analyze_track(file) {
+    match replaygain::analyze_track_with_index(file, opts.track_index) {
         Ok(result) => {
             // Apply gain modifier
             let base_steps = result.gain_steps();
@@ -2229,6 +2250,7 @@ fn print_usage() {
     println!("    -r          Apply Track gain (ReplayGain analysis)");
     println!("    -a          Apply Album gain (ReplayGain analysis)");
     println!("    -e          Skip album analysis (even with multiple files)");
+    println!("    -i <n>      Specify which audio track to process (default: 0)");
     println!("    -u          Undo gain changes (restore from APEv2 tag)");
     println!("    -x          Only find max amplitude of file");
     println!("    -s <mode>   Stored tag handling:");

src/replaygain.rs

@@ -361,6 +361,15 @@ fn detect_file_type(file_path: &Path) -> AudioFileType {
 /// Analyze a single track and calculate ReplayGain
 #[cfg(feature = "replaygain")]
 pub fn analyze_track(file_path: &Path) -> Result<ReplayGainResult> {
+    analyze_track_with_index(file_path, None)
+}
+
+/// Analyze a single track with optional track index selection
+#[cfg(feature = "replaygain")]
+pub fn analyze_track_with_index(
+    file_path: &Path,
+    track_index: Option<u32>,
+) -> Result<ReplayGainResult> {
     // Detect file type
     let file_type = detect_file_type(file_path);
 
@@ -387,12 +396,32 @@ pub fn analyze_track(file_path: &Path) -> Result<ReplayGainResult> {
 
     let mut format = probed.format;
 
-    // Find the first audio track
-    let track = format
+    // Find audio tracks
+    let audio_tracks: Vec<_> = format
         .tracks()
         .iter()
-        .find(|t| t.codec_params.codec != CODEC_TYPE_NULL)
-        .ok_or_else(|| anyhow::anyhow!("No audio track found"))?;
+        .filter(|t| t.codec_params.codec != CODEC_TYPE_NULL)
+        .collect();
+
+    if audio_tracks.is_empty() {
+        anyhow::bail!("No audio track found");
+    }
+
+    // Select track by index or default to first
+    let track = match track_index {
+        Some(idx) => {
+            let idx = idx as usize;
+            if idx >= audio_tracks.len() {
+                anyhow::bail!(
+                    "Track index {} out of range (file has {} audio track(s))",
+                    idx,
+                    audio_tracks.len()
+                );
+            }
+            audio_tracks[idx]
+        }
+        None => audio_tracks[0],
+    };
 
     let track_id = track.id;
     let sample_rate = track
@@ -538,12 +567,21 @@ fn process_audio_buffer(
 /// Analyze multiple tracks for album gain
 #[cfg(feature = "replaygain")]
 pub fn analyze_album(files: &[&Path]) -> Result<AlbumGainResult> {
+    analyze_album_with_index(files, None)
+}
+
+/// Analyze multiple tracks for album gain with optional track index selection
+#[cfg(feature = "replaygain")]
+pub fn analyze_album_with_index(
+    files: &[&Path],
+    track_index: Option<u32>,
+) -> Result<AlbumGainResult> {
     let mut track_results = Vec::with_capacity(files.len());
     let mut album_peak: f64 = 0.0;
 
     for file in files {
         // Analyze each track
-        let result = analyze_track(file)?;
+        let result = analyze_track_with_index(file, track_index)?;
         album_peak = album_peak.max(result.peak);
 
         // We need to re-analyze to get raw RMS values for album calculation
@@ -582,6 +620,17 @@ pub fn analyze_track(_file_path: &Path) -> Result<ReplayGainResult> {
     )
 }
 
+#[cfg(not(feature = "replaygain"))]
+pub fn analyze_track_with_index(
+    _file_path: &Path,
+    _track_index: Option<u32>,
+) -> Result<ReplayGainResult> {
+    anyhow::bail!(
+        "ReplayGain analysis requires the 'replaygain' feature.\n\
+        Install with: cargo install mp3rgain --features replaygain"
+    )
+}
+
 #[cfg(not(feature = "replaygain"))]
 pub fn analyze_album(_files: &[&Path]) -> Result<AlbumGainResult> {
     anyhow::bail!(
@@ -590,6 +639,17 @@ pub fn analyze_album(_files: &[&Path]) -> Result<AlbumGainResult> {
     )
 }
 
+#[cfg(not(feature = "replaygain"))]
+pub fn analyze_album_with_index(
+    _files: &[&Path],
+    _track_index: Option<u32>,
+) -> Result<AlbumGainResult> {
+    anyhow::bail!(
+        "ReplayGain analysis requires the 'replaygain' feature.\n\
+        Install with: cargo install mp3rgain --features replaygain"
+    )
+}
+
 /// Check if ReplayGain feature is available
 pub fn is_available() -> bool {
     cfg!(feature = "replaygain")