use std::path::PathBuf;
use std::sync::Mutex;
#[cfg(feature = "logs")]
use std::fs;
#[cfg(feature = "logs")]
use std::io::{BufWriter, Write};
#[cfg(feature = "logs")]
use std::path::Path;
use indicatif::{HumanDuration, ProgressBar, ProgressStyle};
use crate::pipeline::Outcome;
#[derive(Clone, Debug, serde::Serialize)]
pub enum JobEvent {
Started {
total_files: u64,
},
FileStarted {
index: u64,
path: PathBuf,
},
FileFinished {
index: u64,
path: PathBuf,
outcome: Outcome,
},
Notice {
path: Option<PathBuf>,
message: String,
},
ProgressStats {
input_bytes: u64,
output_bytes: u64,
ok: u64,
skipped: u64,
errors: u64,
},
Finished,
}
pub trait Reporter: Send + Sync {
fn on_event(&self, ev: JobEvent);
}
#[derive(Debug, Default)]
pub struct NullReporter {
captured: Mutex<Vec<u8>>,
}
impl NullReporter {
#[must_use]
pub fn new() -> Self {
Self::default()
}
pub fn captured(&self) -> std::sync::MutexGuard<'_, Vec<u8>> {
self.captured.lock().expect("null reporter mutex poisoned")
}
}
impl Reporter for NullReporter {
fn on_event(&self, _ev: JobEvent) {
}
}
#[derive(Default)]
pub struct TeeReporter {
reporters: Vec<Box<dyn Reporter>>,
}
impl TeeReporter {
#[must_use]
pub fn new() -> Self {
Self::default()
}
pub fn push(&mut self, reporter: Box<dyn Reporter>) {
self.reporters.push(reporter);
}
pub fn with_reporters(reporters: impl IntoIterator<Item = Box<dyn Reporter>>) -> Self {
Self {
reporters: reporters.into_iter().collect(),
}
}
}
impl Reporter for TeeReporter {
fn on_event(&self, ev: JobEvent) {
for reporter in &self.reporters {
reporter.on_event(ev.clone());
}
}
}
pub struct StdoutReporter {
state: Mutex<StdoutState>,
}
struct StdoutState {
bar: Option<ProgressBar>,
input_bytes: u64,
output_bytes: u64,
preexisting_input: u64,
preexisting_output: u64,
ok: u64,
skipped: u64,
errors: u64,
collisions: u64,
discarded: u64,
discarded_input: u64,
discarded_output: u64,
aborted: u64,
metadata_dropped: u64,
total_files: u64,
}
impl StdoutState {
fn new() -> Self {
StdoutState {
bar: None,
input_bytes: 0,
output_bytes: 0,
preexisting_input: 0,
preexisting_output: 0,
ok: 0,
skipped: 0,
errors: 0,
collisions: 0,
discarded: 0,
discarded_input: 0,
discarded_output: 0,
aborted: 0,
metadata_dropped: 0,
total_files: 0,
}
}
}
fn size_format() -> humansize::FormatSizeOptions {
humansize::FormatSizeOptions::from(humansize::BINARY)
.decimal_places(2)
.decimal_zeroes(2)
.space_after_value(false)
}
impl StdoutReporter {
#[must_use]
pub fn new() -> Self {
StdoutReporter {
state: Mutex::new(StdoutState::new()),
}
}
fn print_notice(message: &str, bar_active: bool) {
if bar_active {
println!("\r\x1b[2K{message}");
} else {
println!("{message}");
}
}
fn bar_message(state: &StdoutState) -> String {
let fmt = size_format();
if state.preexisting_input > 0 {
format!(
"{} ➜ {} ({} ➜ {} preexisting) | ✔ {} — {} ✖ {}",
humansize::format_size(state.input_bytes, fmt),
humansize::format_size(state.output_bytes, fmt),
humansize::format_size(state.preexisting_input, fmt),
humansize::format_size(state.preexisting_output, fmt),
state.ok,
state.skipped,
state.errors
)
} else {
format!(
"{} ➜ {} | ✔ {} — {} ✖ {}",
humansize::format_size(state.input_bytes, fmt),
humansize::format_size(state.output_bytes, fmt),
state.ok,
state.skipped,
state.errors
)
}
}
fn tally(state: &mut StdoutState, outcome: &Outcome) {
match outcome {
Outcome::Encoded {
input_size,
output_size,
metadata_dropped,
..
} => {
state.ok += 1;
state.input_bytes += input_size;
state.output_bytes += output_size;
state.metadata_dropped += u64::from(*metadata_dropped);
}
Outcome::SkippedExisting {
input_size,
existing_size,
..
}
| Outcome::DiscardedLargerThanExisting {
input_size,
existing_size,
} => {
state.skipped += 1;
state.input_bytes += input_size;
state.output_bytes += existing_size;
state.preexisting_input += input_size;
state.preexisting_output += existing_size;
}
Outcome::SkippedCollision { .. } => state.collisions += 1,
Outcome::DiscardedLargerThanInput {
input_size,
encoded_size,
} => {
state.discarded += 1;
state.discarded_input += input_size;
state.discarded_output += encoded_size;
}
Outcome::Error(_) => state.errors += 1,
Outcome::Aborted => state.aborted += 1,
}
}
fn print_statistics(state: &StdoutState, elapsed: std::time::Duration) {
let fmt = size_format();
println!("Encode statistics:");
println!("Time taken: {}", HumanDuration(elapsed));
println!("Input files: {}", state.total_files);
println!("Successful: {}", state.ok);
println!("Skipped: {}", state.skipped);
if state.collisions > 0 {
println!(
"Collisions: {} (skipped, the output path was already produced by another input)",
state.collisions
);
}
println!("Errors: {}", state.errors);
if state.metadata_dropped > 0 {
println!(
"Metadata: {} outputs could not carry EXIF metadata (target format has no support)",
state.metadata_dropped
);
}
if state.discarded > 0 {
println!(
"Discarded: {} (due to the encode being larger than the input; {} ➜ {})",
state.discarded,
humansize::format_size(state.discarded_input, fmt),
humansize::format_size(state.discarded_output, fmt)
);
println!(
"Please note that discarded in- and outputs do not count into the total in-/output statistics below."
);
}
if state.input_bytes > 0 && state.output_bytes > 0 {
println!(
"Total input size: {}",
humansize::format_size(state.input_bytes, fmt)
);
println!(
"Total output size: {}",
humansize::format_size(state.output_bytes, fmt)
);
println!(
"Total comp. ratio: {:.02}%",
state.output_bytes as f64 / state.input_bytes as f64 * 100.0
);
if state.preexisting_input > 0 && state.preexisting_output > 0 {
if state.input_bytes - state.preexisting_input > 0 {
println!(
"New encodes input size: {}",
humansize::format_size(state.input_bytes - state.preexisting_input, fmt)
);
println!(
"New encodes output size: {}",
humansize::format_size(state.output_bytes - state.preexisting_output, fmt)
);
println!(
"New encodes comp. ratio: {:.02}%",
state.preexisting_output as f64 / state.preexisting_input as f64 * 100.0
);
}
println!(
"Preexisting input size: {}",
humansize::format_size(state.preexisting_input, fmt)
);
println!(
"Preexisting output size: {}",
humansize::format_size(state.preexisting_output, fmt)
);
println!(
"Preexisting comp. ratio: {:.02}%",
state.preexisting_output as f64 / state.preexisting_input as f64 * 100.0
);
}
} else if (state.ok + state.skipped + state.errors) > 1 {
println!(
"Input and output size could not be determined, please try using OS-native binaries."
);
}
}
}
impl Default for StdoutReporter {
fn default() -> Self {
Self::new()
}
}
impl Reporter for StdoutReporter {
fn on_event(&self, ev: JobEvent) {
let mut state = self.state.lock().expect("stdout reporter mutex poisoned");
match ev {
JobEvent::Notice { message, .. } => {
Self::print_notice(&message, state.bar.is_some());
}
JobEvent::Started { total_files } => {
state.total_files = total_files;
let pb = ProgressBar::new(total_files);
let style = ProgressStyle::with_template(
"[{elapsed_precise}/~{duration_precise} ({eta_precise} rem.)] {wide_bar:.cyan/blue} {pos:>7}/{len:7} | {msg}",
)
.unwrap();
pb.set_style(style);
state.bar = Some(pb);
}
JobEvent::FileFinished { outcome, .. } => {
Self::tally(&mut state, &outcome);
if let Some(pb) = &state.bar {
pb.inc(1);
pb.set_message(Self::bar_message(&state));
}
}
JobEvent::Finished => {
if let Some(pb) = state.bar.take() {
let elapsed = pb.elapsed();
pb.finish_with_message("finished!");
Self::print_statistics(&state, elapsed);
}
}
JobEvent::FileStarted { .. } | JobEvent::ProgressStats { .. } => {}
}
}
}
#[cfg(feature = "logs")]
pub struct JsonlReporter {
writer: Mutex<BufWriter<fs::File>>,
}
#[cfg(feature = "logs")]
impl JsonlReporter {
pub fn new(path: &Path) -> std::io::Result<Self> {
let file = fs::File::create(path)?;
Ok(JsonlReporter {
writer: Mutex::new(BufWriter::new(file)),
})
}
}
#[cfg(feature = "logs")]
impl Reporter for JsonlReporter {
fn on_event(&self, ev: JobEvent) {
let mut writer = self.writer.lock().expect("jsonl reporter mutex poisoned");
if let Ok(line) = serde_json::to_string(&ev) {
let _ = writeln!(writer, "{line}");
let _ = writer.flush();
}
}
}