|
|
|
#[macro_use]
|
|
|
|
extern crate log;
|
|
|
|
#[macro_use]
|
|
|
|
extern crate lazy_static;
|
|
|
|
|
|
|
|
use regex::Regex;
|
|
|
|
use std::fs::{File, OpenOptions};
|
|
|
|
use std::io::{BufReader, Write as ioWrite, StdoutLock, StdinLock};
|
|
|
|
use std::io;
|
|
|
|
use std::str::FromStr;
|
|
|
|
use std::convert::TryFrom;
|
|
|
|
use std::io::BufRead;
|
|
|
|
use std::ops::{Add, Mul, MulAssign, AddAssign, SubAssign, Sub};
|
|
|
|
use std::fmt::{self, Display};
|
|
|
|
use serde::export::fmt::Debug;
|
|
|
|
use core::fmt::Write as fmtWrite;
|
|
|
|
|
|
|
|
const LOG_LEVELS: [&str; 5] = ["error", "warn", "info", "debug", "trace"];
|
|
|
|
const SPAMMY_LIBS: [&str; 5] = ["tokio_reactor", "hyper", "reqwest", "mio", "want"];
|
|
|
|
|
|
|
|
fn main() {
|
|
|
|
let argv =
|
|
|
|
clap::App::new("srtune")
|
|
|
|
.version(env!("CARGO_PKG_VERSION"))
|
|
|
|
.about("\
|
|
|
|
'srtune' helps you edit a .srt file to match a video. Input and output can be either a file, or a stream, \
|
|
|
|
so you can pipe multiple invocations to create more complex operations. However, a single \
|
|
|
|
invocation should suffice in most cases.\n\
|
|
|
|
\n\
|
|
|
|
Times are specified with colons (required) and always include seconds (HH:MM:SS, MM:SS, 0:SS, :SS). \
|
|
|
|
Decimal point in the seconds part, if needed, can be either a period or a comma; times can be copied from the \
|
|
|
|
.srt file. Numbers without colons are assumed to be subtitle indices.\n\
|
|
|
|
\n\
|
|
|
|
The tool can be used iteratively, adjusting the invocation until the generated \
|
|
|
|
subtitle file matches the audio track. You can reload the file in VLC by dragging it \
|
|
|
|
onto the player window. To make this work, subtitle times specified in arguments are the \
|
|
|
|
ones seen in the output file (after shifts and moving), while entry indices are those from the input file.\n\
|
|
|
|
\n\
|
|
|
|
Using indices makes it easier to specify a subtitle to alter, but it is tied to the one .srt file. \
|
|
|
|
Times are harder to write, but the one configuration will work for any locatization or variant of the file,\
|
|
|
|
so long as it is intended for the same version of the movie. Enable debug logging with '-v' to see times \
|
|
|
|
you can use in place of indices.
|
|
|
|
\n\
|
|
|
|
Indices are normally not renumbered, so the output file can be used as a reference \
|
|
|
|
for both times and indices when you work out the right set of arguments. The flag '--renumber' \
|
|
|
|
will give each output entry a new sequential number. Please note that, once renumbered, \
|
|
|
|
the indices in the output file should no longer be used in the command invocation, \
|
|
|
|
as there can be (and often will be) differences from the original file.\
|
|
|
|
")
|
|
|
|
.arg(clap::Arg::with_name("input")
|
|
|
|
.value_name("INFILE")
|
|
|
|
.help("Input file, leave out for stdin"),
|
|
|
|
)
|
|
|
|
.arg(clap::Arg::with_name("output")
|
|
|
|
.short("o")
|
|
|
|
.long("output")
|
|
|
|
.value_name("OUTFILE")
|
|
|
|
.help("Output file, defaults to stdout"),
|
|
|
|
)
|
|
|
|
// .arg(clap::Arg::with_name("drop")
|
|
|
|
// .short("d")
|
|
|
|
// .long("drop")
|
|
|
|
// .value_name("ITEMS")
|
|
|
|
// .help("Drop one or multiple entries (separated by comma). Entries can be TIME \
|
|
|
|
// or INDEX. Two entries can be joined by '..' to specify a range. Use '..ENTRY'\
|
|
|
|
// or 'ENTRY..' to drop all in one direction. Ranges are inclusive."),
|
|
|
|
// )
|
|
|
|
.arg(clap::Arg::with_name("move")
|
|
|
|
.short("m")
|
|
|
|
.long("move")
|
|
|
|
.value_name("OFFSET")
|
|
|
|
.help("Move all subtitles in time (e.g 12:00.15 or -0:44)"),
|
|
|
|
)
|
|
|
|
.arg(clap::Arg::with_name("automove")
|
|
|
|
.short("M")
|
|
|
|
.long("automove")
|
|
|
|
.value_name("ENTRY=VIDEOTIME")
|
|
|
|
.multiple(true)
|
|
|
|
.help("Move subtitles starting at a given time or index to align with \
|
|
|
|
a matching audio track time. This argument can be given multiple times. \
|
|
|
|
Some subtitles may be dropped if they fall outside the timeline after \
|
|
|
|
the move."),
|
|
|
|
)
|
|
|
|
.arg(clap::Arg::with_name("scale")
|
|
|
|
.short("s")
|
|
|
|
.long("scale")
|
|
|
|
.value_name("RATIO")
|
|
|
|
.help("Scale all subtitle times and durations to compensate for bitrate \
|
|
|
|
differences. 1 means identity, 1.1 makes all times 10% longer. Scaling is \
|
|
|
|
relative to the first emitted subtitle; align it with '--move'. This option \
|
|
|
|
has no effect if '--autoscale' is used."),
|
|
|
|
)
|
|
|
|
.arg(clap::Arg::with_name("autoscale")
|
|
|
|
.short("S")
|
|
|
|
.long("autoscale")
|
|
|
|
.value_name("SUBTIME=VIDEOTIME")
|
|
|
|
.help("Calculate scaling based on a perceived difference. The scaling is \
|
|
|
|
related to the first emitted subtitle; align it with '--move'. \
|
|
|
|
This overrides '--scale'."),
|
|
|
|
)
|
|
|
|
.arg(clap::Arg::with_name("durscale")
|
|
|
|
.short("d")
|
|
|
|
.long("durscale")
|
|
|
|
.value_name("RATIO")
|
|
|
|
.help("Scale durations, can be combined with '--scale' or '--autoscale'. The \
|
|
|
|
given value will always be multiplied by the absolute time scale. 1 means \
|
|
|
|
identity, 1.1 makes all times 10% longer."),
|
|
|
|
)
|
|
|
|
.arg(clap::Arg::with_name("renumber")
|
|
|
|
.short("r")
|
|
|
|
.long("renumber")
|
|
|
|
.help("Renumber all emitted entries with sequential 1-based numbers."),
|
|
|
|
)
|
|
|
|
.arg(clap::Arg::with_name("v").short("v").multiple(true).help(
|
|
|
|
"Increase the logging verbosity; can be used multiple times",
|
|
|
|
))
|
|
|
|
.get_matches();
|
|
|
|
|
|
|
|
let mut log_level = "info".to_owned();
|
|
|
|
|
|
|
|
if argv.is_present("v") {
|
|
|
|
// bump verbosity if -v's are present
|
|
|
|
let pos = LOG_LEVELS
|
|
|
|
.iter()
|
|
|
|
.position(|x| x == &log_level)
|
|
|
|
.unwrap();
|
|
|
|
|
|
|
|
log_level = match LOG_LEVELS
|
|
|
|
.iter()
|
|
|
|
.nth(pos + argv.occurrences_of("v") as usize)
|
|
|
|
{
|
|
|
|
Some(new_level) => new_level.to_string(),
|
|
|
|
None => "trace".to_owned(),
|
|
|
|
};
|
|
|
|
}
|
|
|
|
|
|
|
|
//println!("LEVEL={}", log_level);
|
|
|
|
|
|
|
|
// init logging
|
|
|
|
let env = env_logger::Env::default().default_filter_or(log_level);
|
|
|
|
let mut builder = env_logger::Builder::from_env(env);
|
|
|
|
let lib_level = log::LevelFilter::Info;
|
|
|
|
for lib in &SPAMMY_LIBS {
|
|
|
|
builder.filter_module(lib, lib_level);
|
|
|
|
}
|
|
|
|
builder.init();
|
|
|
|
|
|
|
|
let shift = match argv.value_of("move") {
|
|
|
|
Some(s) => {
|
|
|
|
SubDuration::try_from(s).expect("Bad --move format")
|
|
|
|
}
|
|
|
|
None => SubDuration(0f64)
|
|
|
|
};
|
|
|
|
|
|
|
|
let scale = match argv.value_of("scale") {
|
|
|
|
Some(s) => {
|
|
|
|
s.parse().expect("Bad --scale format")
|
|
|
|
}
|
|
|
|
None => 1f64
|
|
|
|
};
|
|
|
|
|
|
|
|
let durscale = match argv.value_of("durscale") {
|
|
|
|
Some(s) => {
|
|
|
|
s.parse().expect("Bad --durscale format")
|
|
|
|
}
|
|
|
|
None => 1f64
|
|
|
|
}; // always also shrink durations
|
|
|
|
|
|
|
|
let autoscale = match argv.value_of("autoscale") {
|
|
|
|
Some(s) => {
|
|
|
|
let halves : Vec<&str> = s.split("=").collect();
|
|
|
|
if halves.len() != 2 {
|
|
|
|
panic!("Bad --autoscale format, should be SUBTIME=VIDEOTIME")
|
|
|
|
}
|
|
|
|
let (first, second) = (halves[0], halves[1]);
|
|
|
|
if !first.contains(':') || !second.contains(':') {
|
|
|
|
panic!("'--autoscale' requires two times");
|
|
|
|
}
|
|
|
|
let subtime = SubDuration::try_from(first).expect("Bad --autoscale time format").as_instant();
|
|
|
|
let vidtime = SubDuration::try_from(second).expect("Bad --autoscale time format").as_instant();
|
|
|
|
|
|
|
|
Some((subtime, vidtime))
|
|
|
|
}
|
|
|
|
None => None
|
|
|
|
};
|
|
|
|
|
|
|
|
let mut automove = Vec::<AutoMoveTag>::new();
|
|
|
|
let mut automove_indices = vec![];
|
|
|
|
match argv.values_of("automove") {
|
|
|
|
Some(ss) => {
|
|
|
|
for s in ss {
|
|
|
|
let halves: Vec<&str> = s.split("=").collect();
|
|
|
|
if halves.len() != 2 {
|
|
|
|
panic!("Bad --automove format, should be ENTRY=VIDEOTIME")
|
|
|
|
}
|
|
|
|
let (first, second) = (halves[0], halves[1]);
|
|
|
|
if !second.contains(':') {
|
|
|
|
panic!("'--automove' requires time after '='");
|
|
|
|
}
|
|
|
|
let vidtime = SubDuration::try_from(second).expect("Bad --automove format").as_instant();
|
|
|
|
|
|
|
|
if first.contains(':') {
|
|
|
|
let subtime = SubDuration::try_from(first).expect("Bad --automove format").as_instant();
|
|
|
|
automove.push(AutoMoveTag::ByTime(subtime, vidtime));
|
|
|
|
} else {
|
|
|
|
let index : u32 = first.parse().expect("Bad --automove format");
|
|
|
|
|
|
|
|
if automove_indices.contains(&index) {
|
|
|
|
panic!("Index {} already used in automove.", index);
|
|
|
|
}
|
|
|
|
automove_indices.push(index);
|
|
|
|
|
|
|
|
automove.push(AutoMoveTag::ByIndex(index, vidtime));
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
None => (/* no automoves */)
|
|
|
|
}
|
|
|
|
|
|
|
|
let inf = argv.value_of("input");
|
|
|
|
let outf = argv.value_of("output");
|
|
|
|
let stdin = io::stdin();
|
|
|
|
let stdout = io::stdout();
|
|
|
|
|
|
|
|
let renumber = argv.is_present("renumber");
|
|
|
|
|
|
|
|
let opts = TransformOpts {
|
|
|
|
renumber,
|
|
|
|
autoscale,
|
|
|
|
durscale,
|
|
|
|
scale,
|
|
|
|
shift,
|
|
|
|
automove,
|
|
|
|
};
|
|
|
|
|
|
|
|
let lines_iterator: Box<dyn SubsInput> = match inf {
|
|
|
|
None => {
|
|
|
|
Box::new(StdinSubsInput::new(stdin.lock()))
|
|
|
|
}
|
|
|
|
Some(f) => {
|
|
|
|
let file = File::open(f).expect(&format!("Could not open file: {:?}", f));
|
|
|
|
Box::new(FileSubsInput::new(file))
|
|
|
|
}
|
|
|
|
};
|
|
|
|
|
|
|
|
let outfile: Box<dyn SubsOutput> = match outf {
|
|
|
|
None => {
|
|
|
|
Box::new(StdoutSubsOutput::new(stdout.lock()))
|
|
|
|
}
|
|
|
|
Some(f) => {
|
|
|
|
let file = OpenOptions::new()
|
|
|
|
.create(true)
|
|
|
|
.truncate(true)
|
|
|
|
.write(true)
|
|
|
|
.open(f)
|
|
|
|
.expect(&format!("Could not open file: {:?}", f));
|
|
|
|
Box::new(FileSubsOutput::new(file))
|
|
|
|
}
|
|
|
|
};
|
|
|
|
|
|
|
|
transform_subtitles(lines_iterator, outfile, opts);
|
|
|
|
}
|
|
|
|
|
|
|
|
//region SubInput
|
|
|
|
trait SubsInput : Iterator<Item=String> {}
|
|
|
|
|
|
|
|
struct StdinSubsInput<'a> {
|
|
|
|
inner : io::Lines<StdinLock<'a>>
|
|
|
|
}
|
|
|
|
|
|
|
|
impl<'a> Iterator for StdinSubsInput<'a> {
|
|
|
|
type Item = String;
|
|
|
|
|
|
|
|
fn next(&mut self) -> Option<Self::Item> {
|
|
|
|
self.inner.next().map_or(None, Result::ok)
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
impl<'a> StdinSubsInput<'a> {
|
|
|
|
pub fn new(lock : StdinLock<'a>) -> Self {
|
|
|
|
Self {
|
|
|
|
inner : lock.lines()
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
impl<'a> SubsInput for StdinSubsInput<'a> {}
|
|
|
|
|
|
|
|
|
|
|
|
struct FileSubsInput {
|
|
|
|
inner : io::Lines<BufReader<File>>
|
|
|
|
}
|
|
|
|
|
|
|
|
impl FileSubsInput {
|
|
|
|
pub fn new(file : File) -> Self {
|
|
|
|
Self {
|
|
|
|
inner : BufReader::new(file).lines()
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
impl Iterator for FileSubsInput {
|
|
|
|
type Item = String;
|
|
|
|
|
|
|
|
fn next(&mut self) -> Option<Self::Item> {
|
|
|
|
self.inner.next().map_or(None, Result::ok)
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
impl SubsInput for FileSubsInput {}
|
|
|
|
//endregion
|
|
|
|
|
|
|
|
//region SubOutput
|
|
|
|
trait SubsOutput {
|
|
|
|
fn emit(&mut self, subtitle : Subtitle);
|
|
|
|
}
|
|
|
|
|
|
|
|
struct StdoutSubsOutput<'a> {
|
|
|
|
inner : StdoutLock<'a>
|
|
|
|
}
|
|
|
|
|
|
|
|
impl<'a> StdoutSubsOutput<'a> {
|
|
|
|
pub fn new(inner : StdoutLock<'a>) -> Self {
|
|
|
|
Self { inner }
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
impl<'a> SubsOutput for StdoutSubsOutput<'a> {
|
|
|
|
fn emit(&mut self, subtitle: Subtitle) {
|
|
|
|
self.inner.write(subtitle.to_string().as_bytes()).expect("failed to write");
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
struct FileSubsOutput {
|
|
|
|
inner : File
|
|
|
|
}
|
|
|
|
|
|
|
|
impl FileSubsOutput {
|
|
|
|
pub fn new(inner : File) -> Self {
|
|
|
|
Self { inner }
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
impl SubsOutput for FileSubsOutput {
|
|
|
|
fn emit(&mut self, subtitle: Subtitle) {
|
|
|
|
self.inner.write(subtitle.to_string().as_bytes()).expect("failed to write");
|
|
|
|
}
|
|
|
|
}
|
|
|
|
//endregion
|
|
|
|
|
|
|
|
#[derive(Debug)]
|
|
|
|
struct TransformOpts {
|
|
|
|
renumber: bool,
|
|
|
|
autoscale: Option<(SubInstant, SubInstant)>,
|
|
|
|
durscale: f64,
|
|
|
|
scale: f64,
|
|
|
|
shift: SubDuration,
|
|
|
|
automove: Vec<AutoMoveTag>,
|
|
|
|
}
|
|
|
|
|
|
|
|
#[derive(Debug)]
|
|
|
|
enum AutoMoveTag {
|
|
|
|
ByTime(SubInstant, SubInstant),
|
|
|
|
ByIndex(u32, SubInstant)
|
|
|
|
}
|
|
|
|
|
|
|
|
#[derive(Debug,Default,Clone)]
|
|
|
|
struct IterState {
|
|
|
|
start_time : Option<SubInstant>,
|
|
|
|
renumber_i : u32,
|
|
|
|
timeline_head : SubInstant,
|
|
|
|
/// Queue last item for duration clipping
|
|
|
|
queued : Option<Subtitle>,
|
|
|
|
}
|
|
|
|
|
|
|
|
fn transform_subtitles<'a>(mut lines : Box<dyn SubsInput + 'a>, mut outfile : Box<dyn SubsOutput + 'a>, mut opts : TransformOpts) {
|
|
|
|
debug!("Opts: {:#?}", opts);
|
|
|
|
|
|
|
|
let mut istate = IterState::default();
|
|
|
|
|
|
|
|
let mut linebuf : Vec<String> = vec![];
|
|
|
|
'lines: while let Some(x) = lines.next() {
|
|
|
|
let mut x = x.trim();
|
|
|
|
if x.starts_with('\u{feff}') {
|
|
|
|
debug!("Stripping BOM mark");
|
|
|
|
x = &x[3..];
|
|
|
|
}
|
|
|
|
let x = x.trim();
|
|
|
|
if x.is_empty() {
|
|
|
|
continue;
|
|
|
|
}
|
|
|
|
|
|
|
|
// 236
|
|
|
|
// 00:18:01,755 --> 00:18:03,774
|
|
|
|
// (掃除機の音)
|
|
|
|
// う~ん…。
|
|
|
|
match u32::from_str(x) {
|
|
|
|
Ok(num) => {
|
|
|
|
// println!("Entry {}", num);
|
|
|
|
let datesrow = lines.next().unwrap();
|
|
|
|
if datesrow.contains(" --> ") {
|
|
|
|
let mut halves = datesrow.split(" --> ");
|
|
|
|
let (first, second) = (halves.next().unwrap(), halves.next().unwrap());
|
|
|
|
let sub_start = SubInstant::try_from(first).unwrap();
|
|
|
|
let sub_end = SubInstant::try_from(second).unwrap();
|
|
|
|
|
|
|
|
linebuf.clear();
|
|
|
|
'text: while let Some(x) = lines.next() {
|
|
|
|
if x.is_empty() {
|
|
|
|
break 'text; // space between the entries
|
|
|
|
}
|
|
|
|
linebuf.push(x);
|
|
|
|
}
|
|
|
|
|
|
|
|
let mut subtitle = Subtitle {
|
|
|
|
num,
|
|
|
|
start: sub_start,
|
|
|
|
dur: sub_end - sub_start,
|
|
|
|
text: linebuf.join("\n"),
|
|
|
|
};
|
|
|
|
|
|
|
|
if istate.start_time.is_none() {
|
|
|
|
debug!("Scaling anchored at {} (#{})", sub_start, num);
|
|
|
|
istate.start_time = Some(sub_start);
|
|
|
|
|
|
|
|
if let Some((mut subt, mut vidt)) = opts.autoscale {
|
|
|
|
debug!("Autoscale: VT {} -> ST {}", vidt, subt);
|
|
|
|
subt -= sub_start;
|
|
|
|
vidt -= sub_start + opts.shift;
|
|
|
|
if subt.0 <= 0f64 {
|
|
|
|
panic!("Error in autoscale, start time is negative or zero.");
|
|
|
|
}
|
|
|
|
if vidt.0 <= 0f64 {
|
|
|
|
panic!("Error in autoscale, end time is negative or zero.");
|
|
|
|
}
|
|
|
|
debug!(" relative to #{}, after \"move\": VT {} -> ST {}", num, vidt, subt);
|
|
|
|
opts.scale = vidt.0 / subt.0;
|
|
|
|
debug!("Resolved scale as {}", opts.scale);
|
|
|
|
}
|
|
|
|
|
|
|
|
opts.durscale *= opts.scale;
|
|
|
|
debug!("Duration scaling is {}", opts.durscale);
|
|
|
|
}
|
|
|
|
|
|
|
|
if opts.scale != 1f64 {
|
|
|
|
let scaled = subtitle.start.scale(istate.start_time.unwrap(), opts.scale);
|
|
|
|
trace!("Scale #{} ({}) -> {}", num, subtitle.start, scaled);
|
|
|
|
subtitle.start = scaled;
|
|
|
|
}
|
|
|
|
|
|
|
|
subtitle.dur *= opts.durscale;
|
|
|
|
|
|
|
|
let would_be_shifted_start = subtitle.start + opts.shift;
|
|
|
|
|
|
|
|
let mut to_drop = vec![];
|
|
|
|
for (i, amove) in opts.automove.iter().enumerate() {
|
|
|
|
match amove {
|
|
|
|
AutoMoveTag::ByIndex(idx, ref vidt) => {
|
|
|
|
if num >= *idx {
|
|
|
|
let dif = *vidt - would_be_shifted_start;
|
|
|
|
debug!("Move by index #{} starts at #{} ({}) -> {}, diff {}", *idx, num, subtitle.start, *vidt, dif);
|
|
|
|
opts.shift += dif;
|
|
|
|
to_drop.push(i);
|
|
|
|
} else if would_be_shifted_start > *vidt {
|
|
|
|
warn!("Discarding out-of-order entry #{} @ {} (timeline head is {})", num, subtitle.start, istate.timeline_head);
|
|
|
|
continue 'lines;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
AutoMoveTag::ByTime(ref subt, ref vidt) => {
|
|
|
|
if would_be_shifted_start >= *subt {
|
|
|
|
let dif = *vidt - *subt;
|
|
|
|
debug!("Move by time {} starts at #{} ({}) -> {}, diff {}", subt, num, subtitle.start, *vidt, dif);
|
|
|
|
opts.shift += dif;
|
|
|
|
to_drop.push(i);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
for i in &to_drop {
|
|
|
|
let x = opts.automove.swap_remove(*i);
|
|
|
|
trace!("Clean up: {:?}", x);
|
|
|
|
}
|
|
|
|
if !to_drop.is_empty() {
|
|
|
|
debug!("New shift: {}, Timeline head: {}", opts.shift, istate.timeline_head);
|
|
|
|
}
|
|
|
|
|
|
|
|
if opts.shift.0 != 0f64 {
|
|
|
|
let shifted = subtitle.start + opts.shift;
|
|
|
|
trace!("Shift #{} ({}) by {} -> {}", num, subtitle.start, opts.shift, shifted);
|
|
|
|
subtitle.start = shifted;
|
|
|
|
}
|
|
|
|
|
|
|
|
if subtitle.start <= istate.timeline_head {
|
|
|
|
warn!("Discarding out-of-order entry #{} @ {} (timeline head is {})", num, subtitle.start, istate.timeline_head);
|
|
|
|
continue 'lines;
|
|
|
|
}
|
|
|
|
|
|
|
|
if subtitle.start.is_negative() {
|
|
|
|
warn!("Discarding negative time entry #{} @ {:.3}s", num, sub_start);
|
|
|
|
continue 'lines;
|
|
|
|
}
|
|
|
|
|
|
|
|
istate.timeline_head = subtitle.start;
|
|
|
|
|
|
|
|
if opts.renumber {
|
|
|
|
istate.renumber_i += 1;
|
|
|
|
subtitle.num = istate.renumber_i;
|
|
|
|
}
|
|
|
|
|
|
|
|
if let Some(mut q) = istate.queued.take() {
|
|
|
|
if q.start + q.dur > subtitle.start {
|
|
|
|
let clipped = subtitle.start - q.start;
|
|
|
|
debug!("Clipping duration of #{} ({}) to avoid overlap: {} -> {}", q.num, q.start, q.dur, clipped);
|
|
|
|
q.dur = clipped;
|
|
|
|
}
|
|
|
|
outfile.emit(q);
|
|
|
|
}
|
|
|
|
|
|
|
|
istate.queued = Some(subtitle);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
Err(e) => {
|
|
|
|
error!("couldnt parse >{}<: {}", x, e);
|
|
|
|
for b in x.as_bytes() {
|
|
|
|
error!("{:#02x} - {}", b, b);
|
|
|
|
}
|
|
|
|
error!("\n");
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
// emit the last entry
|
|
|
|
if let Some(q) = istate.queued.take() {
|
|
|
|
outfile.emit(q);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
//region Time types
|
|
|
|
#[derive(Default, Copy, Clone, PartialEq, PartialOrd)]
|
|
|
|
struct SubInstant(f64);
|
|
|
|
|
|
|
|
impl Debug for SubInstant {
|
|
|
|
fn fmt(&self, f: &mut fmt::Formatter) -> Result<(), fmt::Error> {
|
|
|
|
write!(f, "Time({})", self)
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
impl SubInstant {
|
|
|
|
fn is_negative(&self) -> bool {
|
|
|
|
self.0 < 0f64
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
#[derive(Default, Copy, Clone, PartialEq, PartialOrd)]
|
|
|
|
struct SubDuration(f64);
|
|
|
|
|
|
|
|
impl Debug for SubDuration {
|
|
|
|
fn fmt(&self, f: &mut fmt::Formatter) -> Result<(), fmt::Error> {
|
|
|
|
write!(f, "Duration({})", self)
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
impl Display for SubDuration {
|
|
|
|
fn fmt(&self, f: &mut fmt::Formatter) -> Result<(), fmt::Error> {
|
|
|
|
let sign = self.0.signum();
|
|
|
|
let mut secs = self.0.abs();
|
|
|
|
let hours = (secs / 3600f64).floor();
|
|
|
|
secs -= hours * 3600f64;
|
|
|
|
let mins = (secs / 60f64).floor();
|
|
|
|
secs -= mins * 60f64;
|
|
|
|
let msecs = ((secs % 1f64) * 1000f64).round();
|
|
|
|
secs = secs.floor();
|
|
|
|
|
|
|
|
if sign.is_sign_negative() {
|
|
|
|
f.write_char('-')?;
|
|
|
|
}
|
|
|
|
|
|
|
|
if hours > 0f64 {
|
|
|
|
write!(f, "{:02}:", hours)?;
|
|
|
|
}
|
|
|
|
|
|
|
|
if hours > 0f64 || mins > 0f64 {
|
|
|
|
write!(f, "{:02}:{:02},{:03}", mins, secs, msecs)
|
|
|
|
} else {
|
|
|
|
write!(f, "{},{:03}", secs, msecs)
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
impl Add<SubDuration> for SubInstant {
|
|
|
|
type Output = SubInstant;
|
|
|
|
|
|
|
|
fn add(self, rhs: SubDuration) -> Self::Output {
|
|
|
|
SubInstant(self.0 + rhs.0)
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
impl Sub<SubDuration> for SubInstant {
|
|
|
|
type Output = SubInstant;
|
|
|
|
|
|
|
|
fn sub(self, rhs: SubDuration) -> Self::Output {
|
|
|
|
SubInstant(self.0 - rhs.0)
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
impl Sub<SubInstant> for SubInstant {
|
|
|
|
type Output = SubDuration;
|
|
|
|
|
|
|
|
fn sub(self, rhs: SubInstant) -> Self::Output {
|
|
|
|
SubDuration(self.0 - rhs.0)
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
impl Mul<f64> for SubDuration {
|
|
|
|
type Output = SubDuration;
|
|
|
|
|
|
|
|
fn mul(self, rhs: f64) -> Self::Output {
|
|
|
|
SubDuration(self.0 * rhs)
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
impl MulAssign<f64> for SubDuration {
|
|
|
|
fn mul_assign(&mut self, rhs: f64) {
|
|
|
|
self.0 *= rhs;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
impl AddAssign<f64> for SubDuration {
|
|
|
|
fn add_assign(&mut self, rhs: f64) {
|
|
|
|
self.0 += rhs;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
impl SubInstant {
|
|
|
|
/// Scale by a factor with a custom start time
|
|
|
|
pub fn scale(&self, start: SubInstant, factor: f64) -> SubInstant {
|
|
|
|
SubInstant(start.0 + (self.0 - start.0) * factor)
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
impl AddAssign<f64> for SubInstant {
|
|
|
|
fn add_assign(&mut self, rhs: f64) {
|
|
|
|
self.0 += rhs;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
impl AddAssign<SubInstant> for SubInstant {
|
|
|
|
fn add_assign(&mut self, rhs: SubInstant) {
|
|
|
|
self.0 += rhs.0;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
impl SubAssign<SubInstant> for SubInstant {
|
|
|
|
fn sub_assign(&mut self, rhs: SubInstant) {
|
|
|
|
self.0 -= rhs.0;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
impl SubAssign<SubDuration> for SubInstant {
|
|
|
|
fn sub_assign(&mut self, rhs: SubDuration) {
|
|
|
|
self.0 -= rhs.0;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
impl SubAssign<SubDuration> for SubDuration {
|
|
|
|
fn sub_assign(&mut self, rhs: SubDuration) {
|
|
|
|
self.0 -= rhs.0;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
impl AddAssign<SubDuration> for SubDuration {
|
|
|
|
fn add_assign(&mut self, rhs: SubDuration) {
|
|
|
|
self.0 += rhs.0;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
impl AddAssign<SubDuration> for SubInstant {
|
|
|
|
fn add_assign(&mut self, rhs: SubDuration) {
|
|
|
|
self.0 += rhs.0;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
impl Display for SubInstant {
|
|
|
|
fn fmt(&self, f: &mut fmt::Formatter) -> Result<(), fmt::Error> {
|
|
|
|
let sign = self.0.signum();
|
|
|
|
let mut secs = self.0.abs();
|
|
|
|
let hours = (secs / 3600f64).floor();
|
|
|
|
secs -= hours * 3600f64;
|
|
|
|
let minutes = (secs / 60f64).floor();
|
|
|
|
secs -= minutes * 60f64;
|
|
|
|
let msecs = ((secs % 1f64) * 1000f64).round();
|
|
|
|
write!(f, "{}{:02}:{:02}:{:02},{:03}",
|
|
|
|
if sign.is_sign_negative() { "-" } else { "" },
|
|
|
|
hours, minutes, secs.floor(), msecs)
|
|
|
|
}
|
|
|
|
}
|
|
|
|
//endregion
|
|
|
|
|
|
|
|
#[derive(Clone, Debug)]
|
|
|
|
struct Subtitle {
|
|
|
|
num: u32,
|
|
|
|
start: SubInstant,
|
|
|
|
dur: SubDuration,
|
|
|
|
text: String,
|
|
|
|
}
|
|
|
|
|
|
|
|
impl Display for Subtitle {
|
|
|
|
fn fmt(&self, f: &mut fmt::Formatter) -> Result<(), fmt::Error> {
|
|
|
|
write!(f, "{}\n{} --> {}\n{}\n\n",
|
|
|
|
self.num,
|
|
|
|
self.start, self.start + self.dur,
|
|
|
|
self.text
|
|
|
|
)
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
impl TryFrom<&str> for SubInstant {
|
|
|
|
type Error = failure::Error;
|
|
|
|
|
|
|
|
fn try_from(value: &str) -> Result<Self, Self::Error> {
|
|
|
|
lazy_static! {
|
|
|
|
static ref DATE_RE: Regex = Regex::new(r"^(-)?(?P<h>\d+):(?P<m>\d+):(?P<s>\d+(:?[,.]\d+)?)$").unwrap();
|
|
|
|
}
|
|
|
|
|
|
|
|
match DATE_RE.captures(value) {
|
|
|
|
Some(caps) => {
|
|
|
|
let minus = if caps.get(1).is_some() { -1f64 } else { 1f64 };
|
|
|
|
|
|
|
|
let h = &caps["h"];
|
|
|
|
let m = &caps["m"];
|
|
|
|
let s = caps["s"].replace(",", ".");
|
|
|
|
|
|
|
|
Ok(SubInstant(minus * (f64::from_str(h).unwrap() * 3600f64 +
|
|
|
|
f64::from_str(m).unwrap() * 60f64 +
|
|
|
|
f64::from_str(&s).unwrap())))
|
|
|
|
}
|
|
|
|
None => Err(failure::format_err!("Error parsing time: {}", value))
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
impl SubDuration {
|
|
|
|
pub fn as_instant(&self) -> SubInstant {
|
|
|
|
SubInstant(self.0)
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
impl TryFrom<&str> for SubDuration {
|
|
|
|
type Error = failure::Error;
|
|
|
|
|
|
|
|
fn try_from(mut value: &str) -> Result<Self, Self::Error> {
|
|
|
|
lazy_static! {
|
|
|
|
static ref TIME_RE: Regex = Regex::new(r"^(?U)(?:(?P<h>\d+):)?(?:(?P<m>\d+):)?(?P<s>\d+(?:[.,]\d+)?)$").unwrap();
|
|
|
|
}
|
|
|
|
|
|
|
|
let negative = value.starts_with('-');
|
|
|
|
if negative {
|
|
|
|
value = &value[1..];
|
|
|
|
}
|
|
|
|
|
|
|
|
if value.starts_with(':') {
|
|
|
|
// prefixed colon when someone is lazy to type 0:
|
|
|
|
value = &value[1..];
|
|
|
|
}
|
|
|
|
|
|
|
|
match TIME_RE.captures(value) {
|
|
|
|
Some(caps) => {
|
|
|
|
let minus = if negative { -1f64 } else { 1f64 };
|
|
|
|
let h = caps.name("h").map_or(0f64, |m| f64::from_str(m.as_str()).unwrap());
|
|
|
|
let m = caps.name("m").map_or(0f64, |m| f64::from_str(m.as_str()).unwrap());
|
|
|
|
let s = caps.name("s").map_or(0f64, |m| f64::from_str(&m.as_str().replace(",", ".")).unwrap());
|
|
|
|
|
|
|
|
Ok(SubDuration(minus * (h * 3600f64 + m * 60f64 + s)))
|
|
|
|
}
|
|
|
|
None => {
|
|
|
|
Err(failure::format_err!("Error parsing time: {}", value))
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
#[test]
|
|
|
|
fn test_parse_duration() {
|
|
|
|
// this is used for user input on the command line
|
|
|
|
let bad = SubDuration(-1f64);
|
|
|
|
assert_eq!(SubDuration::try_from(":45678").unwrap_or(bad), SubDuration(45678f64), "integer secs with colon prefix");
|
|
|
|
assert_eq!(SubDuration::try_from("-:45678").unwrap_or(bad), SubDuration(-45678f64), "neg integer secs with colon prefix");
|
|
|
|
assert_eq!(SubDuration::try_from("45678").unwrap_or(bad), SubDuration(45678f64), "integer secs");
|
|
|
|
assert_eq!(SubDuration::try_from("1.23").unwrap_or(bad), SubDuration(1.23f64), "float secs with period");
|
|
|
|
assert_eq!(SubDuration::try_from("-1.23").unwrap_or(bad), SubDuration(-1.23f64), "MINUS float secs with period");
|
|
|
|
assert_eq!(SubDuration::try_from("1,23").unwrap_or(bad), SubDuration(1.23f64), "float secs with comma");
|
|
|
|
assert_eq!(SubDuration::try_from("2:1.15").unwrap_or(bad), SubDuration(121.15f64), "m:s.frac");
|
|
|
|
assert_eq!(SubDuration::try_from("2:01.15").unwrap_or(bad), SubDuration(121.15f64), "m:0s.frac");
|
|
|
|
assert_eq!(SubDuration::try_from("02:01.15").unwrap_or(bad), SubDuration(121.15f64), "0m:0s.frac");
|
|
|
|
assert_eq!(SubDuration::try_from("02:01,15").unwrap_or(bad), SubDuration(121.15f64), "0m:0s,frac");
|
|
|
|
|
|
|
|
assert_eq!(SubDuration::try_from("1:02:01,15").unwrap_or(bad), SubDuration(3721.15f64), "h:0m:0s,frac");
|
|
|
|
assert_eq!(SubDuration::try_from("1:02:01,15").unwrap_or(bad), SubDuration(3721.15f64), "h:0m:0s.frac");
|
|
|
|
assert_eq!(SubDuration::try_from("01:02:01,15").unwrap_or(bad), SubDuration(3721.15f64), "0h:0m:0s,frac");
|
|
|
|
assert_eq!(SubDuration::try_from("-01:02:01,15").unwrap_or(bad), SubDuration(-3721.15f64), "-0h:0m:0s,frac");
|
|
|
|
|
|
|
|
assert_eq!(SubDuration::try_from("18:01,755").unwrap_or(bad), SubDuration(1081.755f64));
|
|
|
|
assert_eq!(SubDuration::try_from("-18:01,755").unwrap_or(bad), SubDuration(-1081.755f64));
|
|
|
|
assert_eq!(SubDuration::try_from("-18:01.7").unwrap_or(bad), SubDuration(-1081.7f64));
|
|
|
|
assert_eq!(SubDuration::try_from("-12:18:01.7").unwrap_or(bad), SubDuration(-44281.7f64));
|
|
|
|
assert_eq!(SubDuration::try_from("0,000").unwrap_or(bad), SubDuration(0f64));
|
|
|
|
assert_eq!(SubDuration::try_from("-0,000").unwrap_or(bad), SubDuration(-0f64));
|
|
|
|
}
|
|
|
|
|
|
|
|
#[test]
|
|
|
|
fn test_parse_instant() {
|
|
|
|
let bad = SubInstant(-1f64);
|
|
|
|
assert_eq!(SubInstant::try_from("00:18:01,755").unwrap_or(bad), SubInstant(1081.755f64));
|
|
|
|
assert_eq!(SubInstant::try_from("00:18:01.755").unwrap_or(bad), SubInstant(1081.755f64));
|
|
|
|
assert_eq!(SubInstant::try_from("00:18:01.7").unwrap_or(bad), SubInstant(1081.7f64));
|
|
|
|
assert_eq!(SubInstant::try_from("0:18:1.7").unwrap_or(bad), SubInstant(1081.7f64));
|
|
|
|
assert_eq!(SubInstant::try_from("00:00:00,000").unwrap_or(bad), SubInstant(0f64));
|
|
|
|
assert_eq!(SubInstant::try_from("-01:00:00,000").unwrap_or(bad), SubInstant(-3600f64));
|
|
|
|
}
|
|
|
|
|
|
|
|
#[test]
|
|
|
|
fn test_stringify_instant() {
|
|
|
|
assert_eq!(SubInstant::try_from("00:18:01,755").unwrap().to_string(), "00:18:01,755");
|
|
|
|
assert_eq!(SubInstant::try_from("-00:18:01,755").unwrap().to_string(), "-00:18:01,755");
|
|
|
|
assert_eq!(SubInstant::try_from("-00:18:01.7").unwrap().to_string(), "-00:18:01,700");
|
|
|
|
assert_eq!(SubInstant::try_from("00:00:00,000").unwrap().to_string(), "00:00:00,000");
|
|
|
|
assert_eq!(SubInstant::try_from("-00:00:00,000").unwrap().to_string(), "-00:00:00,000");
|
|
|
|
}
|
|
|
|
|
|
|
|
#[test]
|
|
|
|
fn test_stringify_duration() {
|
|
|
|
assert_eq!(SubDuration::try_from("18:01,755").unwrap().to_string(), "18:01,755");
|
|
|
|
assert_eq!(SubDuration::try_from("-18:01,755").unwrap().to_string(), "-18:01,755");
|
|
|
|
assert_eq!(SubDuration::try_from("-18:01.7").unwrap().to_string(), "-18:01,700");
|
|
|
|
assert_eq!(SubDuration::try_from("-12:18:01.7").unwrap().to_string(), "-12:18:01,700");
|
|
|
|
assert_eq!(SubDuration::try_from("0,000").unwrap().to_string(), "0,000");
|
|
|
|
assert_eq!(SubDuration::try_from("-0,000").unwrap().to_string(), "-0,000");
|
|
|
|
}
|