use crate::{
cli::BatchArgs,
commands::batch::{run_batch, BatchFuture, BatchTask, FileOutcome},
ffmpeg::{args, Ffmpeg, ProcessRunner},
util::files,
workflow::{Workflow, WorkflowOptions},
};
use anyhow::Result;
use clap::Args;
use std::{
fs,
path::{Path, PathBuf},
};
use tokio_util::sync::CancellationToken;
const DEFAULT_BITRATE: u32 = 320;
const DEFAULT_COVER_SIZE: u32 = 600;
const TEMP_COVER_PREFIX: &str = "toolkitrs-cover-";
const TEMP_COVER_SUFFIX: &str = ".jpg";
const WARNING_PREFIX: &str = "WARNING";
const COVER_EXTRACTION_WARNING: &str = "cover extraction failed; continuing without cover";
#[derive(Debug, Args)]
#[command(after_help = "Examples:
toolkitrs mkv2mp3 Scan and process all .mkv files in the current directory
toolkitrs mkv2mp3 movie.mkv Process one file; prompt if sibling .mkv files exist
toolkitrs mkv2mp3 --batch --input-dir /dir Process all .mkv files in /dir
toolkitrs mkv2mp3 --batch --on-error skip Continue past errors and report at the end
toolkitrs mkv2mp3 --cover-size 800 Extract larger cover art")]
pub struct Mkv2mp3Args {
#[command(flatten)]
pub batch: BatchArgs,
#[arg(long, default_value_t = DEFAULT_COVER_SIZE)]
pub cover_size: u32,
#[arg(long, default_value_t = DEFAULT_BITRATE)]
pub bitrate: u32,
#[arg(value_name = "FILE")]
pub files: Vec<PathBuf>,
}
#[derive(Debug, Clone, Copy)]
struct MkvToMp3Task {
cover_size: u32,
bitrate: u32,
force: bool,
}
impl MkvToMp3Task {
fn workflow_options(self) -> WorkflowOptions {
WorkflowOptions {
force: self.force,
bitrate: self.bitrate,
cover_size: self.cover_size,
..WorkflowOptions::default()
}
}
}
impl BatchTask for MkvToMp3Task {
fn input_extension(&self) -> &str {
Workflow::Mkv2Mp3.input_extension()
}
fn output_extension(&self) -> &str {
Workflow::Mkv2Mp3.output_extension()
}
fn file_type_name(&self) -> &str {
Workflow::Mkv2Mp3.file_type_name()
}
fn process_file<R: ProcessRunner>(
&self,
input: &Path,
output: &Path,
ffmpeg: &Ffmpeg<R>,
) -> Result<FileOutcome> {
let cover = files::temp_path(TEMP_COVER_PREFIX, TEMP_COVER_SUFFIX)?;
let has_cover = ffmpeg
.run(args::extract_frame(input, &cover, self.cover_size))
.is_ok()
&& has_file_content(&cover);
if !has_cover {
eprintln!(
"{WARNING_PREFIX}: {COVER_EXTRACTION_WARNING}: {}",
input.display()
);
}
let result = ffmpeg.run(args::encode_mp3(
input,
has_cover.then_some(cover.as_path()),
output,
self.bitrate,
self.force,
));
cleanup_temp_file(&cover);
result?;
Ok(FileOutcome::Success)
}
fn process_file_async(
&self,
input: PathBuf,
output: PathBuf,
ffmpeg_binary: PathBuf,
cancel: CancellationToken,
) -> BatchFuture {
let options = self.workflow_options();
Box::pin(async move {
Workflow::Mkv2Mp3
.run_async(input, output, &options, &ffmpeg_binary, cancel, None)
.await
})
}
}
pub fn run<R: ProcessRunner>(args_cli: Mkv2mp3Args, ffmpeg: &Ffmpeg<R>) -> Result<()> {
let task = MkvToMp3Task {
cover_size: args_cli.cover_size,
bitrate: args_cli.bitrate,
force: args_cli.batch.force,
};
run_batch(&task, &args_cli.batch, args_cli.files, ffmpeg)
}
fn has_file_content(path: &Path) -> bool {
path.metadata().map(|meta| meta.len() > 0).unwrap_or(false)
}
fn cleanup_temp_file(path: &Path) {
let _ = fs::remove_file(path);
}