srtune/src/main.rs

#[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, 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")
                     .allow_hyphen_values(true)
                     .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 {}, -M{}={}", *idx, num, subtitle.start, dif, would_be_shifted_start, *vidt);
                                    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 - 0.1f64) { // margin
                                    let dif = *vidt - *subt;
                                    debug!("Move by time {} starts at #{} ({}), diff {}, -M{}={}", subt, num, subtitle.start, dif, subt, *vidt);
                                    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 Sub<f64> for SubInstant {
    type Output = SubInstant;

    fn sub(self, rhs: f64) -> Self::Output {
        SubInstant(self.0 - rhs)
    }
}

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");
}