Struct AudioExtractor 

pub struct AudioExtractor { /* private fields */ }

Demux an audio track from a media file and write it to a standalone audio file.

The audio bitstream is stream-copied (no decode/encode cycle). By default the first audio stream is selected; call stream_index to pick a specific one.

Returns RemuxError::OperationFailed when:

• no audio stream is found (or stream_index points to a non-audio stream), or
• the audio codec is incompatible with the output container.

Example

use ff_remux::AudioExtractor;

AudioExtractor::new("source.mp4", "audio.mp3").run()?;

Implementations

impl AudioExtractor

pub fn new(input: impl Into<PathBuf>, output: impl Into<PathBuf>) -> Self

Create a new AudioExtractor.

• input — source media file.
• output — destination audio file (format auto-detected from extension).

Examples found in repository

examples/audio_extraction.rs (line 70)

fn main() {
    let mut args = std::env::args().skip(1);
    let mut input = None::<String>;
    let mut output = None::<String>;
    let mut stream_index = None::<usize>;

    while let Some(flag) = args.next() {
        match flag.as_str() {
            "--input" | "-i" => input = Some(args.next().unwrap_or_default()),
            "--output" | "-o" => output = Some(args.next().unwrap_or_default()),
            "--stream" | "-s" => {
                let raw = args.next().unwrap_or_default();
                stream_index = Some(raw.parse().unwrap_or_else(|_| {
                    eprintln!("Invalid stream index: {raw}");
                    process::exit(1);
                }));
            }
            other => {
                eprintln!("Unknown flag: {other}");
                process::exit(1);
            }
        }
    }

    let input = input.unwrap_or_else(|| {
        eprintln!("Usage: audio_extraction --input <file> --output <audio> [--stream <index>]");
        process::exit(1);
    });
    let output = output.unwrap_or_else(|| {
        eprintln!("--output is required");
        process::exit(1);
    });

    println!("Input:  {input}");
    println!(
        "Stream: {}",
        stream_index.map_or_else(
            || "first audio stream (default)".to_string(),
            |i| i.to_string()
        )
    );
    println!("Output: {output}");
    println!();
    println!("Extracting audio track (stream-copy, no re-encode)…");

    let mut extractor = AudioExtractor::new(&input, &output);
    if let Some(idx) = stream_index {
        extractor = extractor.stream_index(idx);
    }

    extractor.run().unwrap_or_else(|e| {
        eprintln!("Error: {e}");
        process::exit(1);
    });

    let size = match std::fs::metadata(&output) {
        Ok(m) => {
            #[allow(clippy::cast_precision_loss)]
            let kb = m.len() as f64 / 1024.0;
            if kb < 1024.0 {
                format!("{kb:.0} KB")
            } else {
                format!("{:.1} MB", kb / 1024.0)
            }
        }
        Err(_) => "(unknown size)".to_string(),
    };

    println!("Done. {output}  {size}");
}

pub fn stream_index(self, idx: usize) -> Self

Select a specific audio stream by index (0-based over all streams in the container). Defaults to the first audio stream when not set.

Examples found in repository

examples/audio_extraction.rs (line 72)

fn main() {
    let mut args = std::env::args().skip(1);
    let mut input = None::<String>;
    let mut output = None::<String>;
    let mut stream_index = None::<usize>;

    while let Some(flag) = args.next() {
        match flag.as_str() {
            "--input" | "-i" => input = Some(args.next().unwrap_or_default()),
            "--output" | "-o" => output = Some(args.next().unwrap_or_default()),
            "--stream" | "-s" => {
                let raw = args.next().unwrap_or_default();
                stream_index = Some(raw.parse().unwrap_or_else(|_| {
                    eprintln!("Invalid stream index: {raw}");
                    process::exit(1);
                }));
            }
            other => {
                eprintln!("Unknown flag: {other}");
                process::exit(1);
            }
        }
    }

    let input = input.unwrap_or_else(|| {
        eprintln!("Usage: audio_extraction --input <file> --output <audio> [--stream <index>]");
        process::exit(1);
    });
    let output = output.unwrap_or_else(|| {
        eprintln!("--output is required");
        process::exit(1);
    });

    println!("Input:  {input}");
    println!(
        "Stream: {}",
        stream_index.map_or_else(
            || "first audio stream (default)".to_string(),
            |i| i.to_string()
        )
    );
    println!("Output: {output}");
    println!();
    println!("Extracting audio track (stream-copy, no re-encode)…");

    let mut extractor = AudioExtractor::new(&input, &output);
    if let Some(idx) = stream_index {
        extractor = extractor.stream_index(idx);
    }

    extractor.run().unwrap_or_else(|e| {
        eprintln!("Error: {e}");
        process::exit(1);
    });

    let size = match std::fs::metadata(&output) {
        Ok(m) => {
            #[allow(clippy::cast_precision_loss)]
            let kb = m.len() as f64 / 1024.0;
            if kb < 1024.0 {
                format!("{kb:.0} KB")
            } else {
                format!("{:.1} MB", kb / 1024.0)
            }
        }
        Err(_) => "(unknown size)".to_string(),
    };

    println!("Done. {output}  {size}");
}

pub fn run(self) -> Result<(), RemuxError>

Execute the audio extraction operation.

Errors

• RemuxError::OperationFailed if no audio stream is found, the requested stream index is invalid or not audio, or the codec is incompatible with the output container.
• RemuxError::Ffmpeg if any FFmpeg API call fails.

Examples found in repository

examples/audio_extraction.rs (line 75)

fn main() {
    let mut args = std::env::args().skip(1);
    let mut input = None::<String>;
    let mut output = None::<String>;
    let mut stream_index = None::<usize>;

    while let Some(flag) = args.next() {
        match flag.as_str() {
            "--input" | "-i" => input = Some(args.next().unwrap_or_default()),
            "--output" | "-o" => output = Some(args.next().unwrap_or_default()),
            "--stream" | "-s" => {
                let raw = args.next().unwrap_or_default();
                stream_index = Some(raw.parse().unwrap_or_else(|_| {
                    eprintln!("Invalid stream index: {raw}");
                    process::exit(1);
                }));
            }
            other => {
                eprintln!("Unknown flag: {other}");
                process::exit(1);
            }
        }
    }

    let input = input.unwrap_or_else(|| {
        eprintln!("Usage: audio_extraction --input <file> --output <audio> [--stream <index>]");
        process::exit(1);
    });
    let output = output.unwrap_or_else(|| {
        eprintln!("--output is required");
        process::exit(1);
    });

    println!("Input:  {input}");
    println!(
        "Stream: {}",
        stream_index.map_or_else(
            || "first audio stream (default)".to_string(),
            |i| i.to_string()
        )
    );
    println!("Output: {output}");
    println!();
    println!("Extracting audio track (stream-copy, no re-encode)…");

    let mut extractor = AudioExtractor::new(&input, &output);
    if let Some(idx) = stream_index {
        extractor = extractor.stream_index(idx);
    }

    extractor.run().unwrap_or_else(|e| {
        eprintln!("Error: {e}");
        process::exit(1);
    });

    let size = match std::fs::metadata(&output) {
        Ok(m) => {
            #[allow(clippy::cast_precision_loss)]
            let kb = m.len() as f64 / 1024.0;
            if kb < 1024.0 {
                format!("{kb:.0} KB")
            } else {
                format!("{:.1} MB", kb / 1024.0)
            }
        }
        Err(_) => "(unknown size)".to_string(),
    };

    println!("Done. {output}  {size}");
}