use std::path::{Path, PathBuf};
use std::sync::atomic::{AtomicU64, Ordering};
use std::sync::OnceLock;
use crate::error::Error;
pub fn resolve_helper(configured: &str) -> Option<String> {
let trimmed = configured.trim();
if !trimmed.is_empty() && Path::new(trimmed).is_file() {
return Some(trimmed.to_string());
}
let path = std::env::var_os("PATH")?;
std::env::split_paths(&path)
.map(|dir| dir.join("ffmpeg"))
.find(|candidate| candidate.is_file())
.map(|candidate| candidate.display().to_string())
}
fn describe_with_helper(
helper: &str,
input: &Path,
deadline: Option<std::time::Instant>,
) -> Result<String, Error> {
let mut cmd = std::process::Command::new(helper);
cmd.args(["-hide_banner", "-i", &input.display().to_string()])
.stdout(std::process::Stdio::null())
.stderr(std::process::Stdio::piped());
let (id, child) =
crate::signal::spawn_tracked(&mut cmd).map_err(|e| Error::HelperFailed(e.to_string()))?;
let mut captured = String::new();
{
let mut guard = child.lock().unwrap_or_else(|e| e.into_inner());
if let Some(mut err) = guard.stderr.take() {
use std::io::Read;
let _ = err.read_to_string(&mut captured);
}
}
let outcome = loop {
let polled = {
let mut guard = child.lock().unwrap_or_else(|e| e.into_inner());
guard
.try_wait()
.map_err(|e| Error::HelperFailed(e.to_string()))?
};
if polled.is_some() {
break Ok(());
}
let stop = if deadline
.map(|d| std::time::Instant::now() > d)
.unwrap_or(false)
{
Some(Error::Timeout)
} else if crate::signal::is_shutdown_requested() {
Some(crate::signal::shutdown_error().unwrap_or(Error::Interrupted))
} else {
None
};
if let Some(err) = stop {
let mut guard = child.lock().unwrap_or_else(|e| e.into_inner());
crate::signal::kill_child_tree(&mut guard);
break Err(err);
}
std::thread::sleep(helper_poll());
};
crate::signal::release_child(id);
outcome.map(|()| captured)
}
pub fn probe_video(
helper_hint: &str,
input: &Path,
deadline: Option<std::time::Instant>,
) -> Result<(f64, u32, usize), Error> {
let Some(helper) = resolve_helper(helper_hint) else {
return Err(Error::HelperMissing);
};
let description = describe_with_helper(&helper, input, deadline)?;
let Some(duration) = parse_duration(&description) else {
return Err(Error::VideoExtractionFailed {
path: input.display().to_string(),
});
};
let (rate, channels) = parse_audio_layout(&description);
Ok((duration, rate, channels))
}
fn parse_duration(description: &str) -> Option<f64> {
let tail = description.split("Duration:").nth(1)?;
let stamp = tail.split(',').next()?.trim();
if stamp.starts_with("N/A") {
return None;
}
let mut parts = stamp.split(':');
let hours: f64 = parts.next()?.trim().parse().ok()?;
let minutes: f64 = parts.next()?.trim().parse().ok()?;
let seconds: f64 = parts.next()?.trim().parse().ok()?;
Some(hours * 3600.0 + minutes * 60.0 + seconds)
}
fn parse_audio_layout(description: &str) -> (u32, usize) {
let Some(line) = description
.lines()
.find(|l| l.contains("Stream #") && l.contains("Audio:"))
else {
return (0, 0);
};
let mut rate = 0u32;
let mut channels = 0usize;
for field in line.split(',') {
let field = field.trim();
if let Some(hz) = field.strip_suffix(" Hz") {
if let Ok(parsed) = hz.trim().parse::<u32>() {
rate = parsed;
}
}
channels = match field {
"mono" => 1,
"stereo" => 2,
"5.1" | "5.1(side)" => 6,
"7.1" => 8,
_ => channels,
};
}
(rate, channels)
}
const DEFAULT_HELPER_POLL_MS: u64 = 25;
static HELPER_POLL_MS: AtomicU64 = AtomicU64::new(DEFAULT_HELPER_POLL_MS);
pub fn publish_helper_poll_ms(ms: u64) {
HELPER_POLL_MS.store(ms, Ordering::SeqCst);
}
fn helper_poll() -> std::time::Duration {
let ms = HELPER_POLL_MS.load(Ordering::SeqCst);
std::time::Duration::from_millis(if ms == 0 { DEFAULT_HELPER_POLL_MS } else { ms })
}
static HELPER_ARGS: OnceLock<Vec<String>> = OnceLock::new();
pub fn publish_helper_args(args: Vec<String>) {
let _ = HELPER_ARGS.set(args);
}
fn decode_args(input: &Path, out: &Path, extra: &[String]) -> Vec<String> {
let mut args = vec![
"-y".to_string(),
"-i".to_string(),
input.display().to_string(),
"-ac".to_string(),
"1".to_string(),
"-ar".to_string(),
"16000".to_string(),
"-f".to_string(),
"wav".to_string(),
];
args.extend(
extra
.iter()
.filter(|a| !a.trim().is_empty())
.map(|a| a.trim().to_string()),
);
args.push(out.display().to_string());
args
}
pub fn extract_with_helper(
helper: &str,
input: &Path,
work: &Path,
deadline: Option<std::time::Instant>,
) -> Result<PathBuf, Error> {
if helper.trim().is_empty() {
return Err(Error::HelperMissing);
}
let out = work.join("extract.wav");
let mut cmd = std::process::Command::new(helper);
cmd.args(decode_args(
input,
&out,
HELPER_ARGS.get().map(Vec::as_slice).unwrap_or_default(),
))
.stdout(std::process::Stdio::null())
.stderr(std::process::Stdio::null());
let (id, child) =
crate::signal::spawn_tracked(&mut cmd).map_err(|e| Error::HelperFailed(e.to_string()))?;
let result = await_helper(&child, input, deadline);
crate::signal::release_child(id);
result.map(|()| out)
}
fn await_helper(
child: &std::sync::Mutex<std::process::Child>,
input: &Path,
deadline: Option<std::time::Instant>,
) -> Result<(), Error> {
loop {
let polled = {
let mut guard = child.lock().unwrap_or_else(|e| e.into_inner());
guard
.try_wait()
.map_err(|e| Error::HelperFailed(e.to_string()))?
};
if let Some(status) = polled {
return if status.success() {
Ok(())
} else {
Err(Error::VideoExtractionFailed {
path: input.display().to_string(),
})
};
}
let stop = if deadline
.map(|d| std::time::Instant::now() > d)
.unwrap_or(false)
{
Some(Error::Timeout)
} else if crate::signal::is_shutdown_requested() {
Some(crate::signal::shutdown_error().unwrap_or(Error::Interrupted))
} else {
None
};
if let Some(err) = stop {
let mut guard = child.lock().unwrap_or_else(|e| e.into_inner());
crate::signal::kill_child_tree(&mut guard);
return Err(err);
}
std::thread::sleep(helper_poll());
}
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn extras_land_after_the_engine_contract_and_before_the_output() {
let args = decode_args(
Path::new("in.mkv"),
Path::new("out.wav"),
&["-threads".to_string(), "2".to_string(), " ".to_string()],
);
assert_eq!(
args,
vec![
"-y", "-i", "in.mkv", "-ac", "1", "-ar", "16000", "-f", "wav", "-threads", "2",
"out.wav",
]
);
}
#[test]
fn no_extras_keeps_the_argv_the_helper_always_got() {
let args = decode_args(Path::new("in.mkv"), Path::new("out.wav"), &[]);
assert_eq!(
args,
vec!["-y", "-i", "in.mkv", "-ac", "1", "-ar", "16000", "-f", "wav", "out.wav"]
);
}
}