From 6d1f8d49f67aabbc9b1cf577fce38c3209993371 Mon Sep 17 00:00:00 2001
From: ByteDream <bytedream@protonmail.com>
Date: Fri, 13 Jan 2023 15:21:23 +0100
Subject: [PATCH 1/6] Add hardsubs manually to download videos (#81)

---
 crunchy-cli-core/src/cli/archive.rs    | 151 +------------------------
 crunchy-cli-core/src/cli/download.rs   | 134 +++++++++++++---------
 crunchy-cli-core/src/cli/utils.rs      |  20 ++--
 crunchy-cli-core/src/utils/format.rs   |   6 +-
 crunchy-cli-core/src/utils/mod.rs      |   1 +
 crunchy-cli-core/src/utils/subtitle.rs | 108 ++++++++++++++++++
 crunchy-cli-core/src/utils/video.rs    |  25 ++++
 7 files changed, 233 insertions(+), 212 deletions(-)
 create mode 100644 crunchy-cli-core/src/utils/video.rs

diff --git a/crunchy-cli-core/src/cli/archive.rs b/crunchy-cli-core/src/cli/archive.rs
index 768c629..c7030b4 100644
--- a/crunchy-cli-core/src/cli/archive.rs
+++ b/crunchy-cli-core/src/cli/archive.rs
@@ -9,16 +9,14 @@ use crate::utils::log::progress;
 use crate::utils::os::{free_file, has_ffmpeg, is_special_file, tempfile};
 use crate::utils::parse::{parse_url, UrlFilter};
 use crate::utils::sort::{sort_formats_after_seasons, sort_seasons_after_number};
-use crate::utils::subtitle::Subtitle;
+use crate::utils::subtitle::{download_subtitle, Subtitle};
+use crate::utils::video::get_video_length;
 use crate::Execute;
 use anyhow::{bail, Result};
-use chrono::NaiveTime;
-use crunchyroll_rs::media::{Resolution, StreamSubtitle};
+use crunchyroll_rs::media::Resolution;
 use crunchyroll_rs::{Locale, Media, MediaCollection, Series};
 use log::{debug, error, info, warn};
-use regex::Regex;
 use std::collections::BTreeMap;
-use std::io::Write;
 use std::path::PathBuf;
 use std::process::{Command, Stdio};
 use tempfile::TempPath;
@@ -113,14 +111,6 @@ pub struct Archive {
     )]
     #[arg(long)]
     default_subtitle: Option<Locale>,
-    #[arg(help = "Disable subtitle optimizations")]
-    #[arg(
-        long_help = "By default, Crunchyroll delivers subtitles in a format which may cause issues in some video players. \
-    These issues are fixed internally by setting a flag which is not part of the official specification of the subtitle format. \
-    If you do not want this fixes or they cause more trouble than they solve (for you), it can be disabled with this flag"
-    )]
-    #[arg(long)]
-    no_subtitle_optimizations: bool,
 
     #[arg(help = "Ignore interactive input")]
     #[arg(short, long, default_value_t = false)]
@@ -326,12 +316,8 @@ impl Execute for Archive {
                 let primary_video_length = get_video_length(primary_video.to_path_buf()).unwrap();
                 for subtitle in subtitles {
                     subtitle_paths.push((
-                        download_subtitle(
-                            &self,
-                            subtitle.stream_subtitle.clone(),
-                            primary_video_length,
-                        )
-                        .await?,
+                        download_subtitle(subtitle.stream_subtitle.clone(), primary_video_length)
+                            .await?,
                         subtitle,
                     ))
                 }
@@ -436,7 +422,7 @@ async fn formats_from_series(
                 };
                 Some(subtitle)
             }));
-            formats.push(Format::new_from_episode(episode, &episodes, stream));
+            formats.push(Format::new_from_episode(episode, &episodes, stream, vec![]));
         }
 
         primary_season = false;
@@ -476,111 +462,6 @@ async fn download_video(ctx: &Context, format: &Format, only_audio: bool) -> Res
     Ok(path)
 }
 
-async fn download_subtitle(
-    archive: &Archive,
-    subtitle: StreamSubtitle,
-    max_length: NaiveTime,
-) -> Result<TempPath> {
-    let tempfile = tempfile(".ass")?;
-    let (mut file, path) = tempfile.into_parts();
-
-    let mut buf = vec![];
-    subtitle.write_to(&mut buf).await?;
-    if !archive.no_subtitle_optimizations {
-        buf = fix_subtitle_look_and_feel(buf)
-    }
-    buf = fix_subtitle_length(buf, max_length);
-
-    file.write_all(buf.as_slice())?;
-
-    Ok(path)
-}
-
-/// Add `ScaledBorderAndShadows: yes` to subtitles; without it they look very messy on some video
-/// players. See [crunchy-labs/crunchy-cli#66](https://github.com/crunchy-labs/crunchy-cli/issues/66)
-/// for more information.
-fn fix_subtitle_look_and_feel(raw: Vec<u8>) -> Vec<u8> {
-    let mut script_info = false;
-    let mut new = String::new();
-
-    for line in String::from_utf8_lossy(raw.as_slice()).split('\n') {
-        if line.trim().starts_with('[') && script_info {
-            new.push_str("ScaledBorderAndShadow: yes\n");
-            script_info = false
-        } else if line.trim() == "[Script Info]" {
-            script_info = true
-        }
-        new.push_str(line);
-        new.push('\n')
-    }
-
-    new.into_bytes()
-}
-
-/// Fix the length of subtitles to a specified maximum amount. This is required because sometimes
-/// subtitles have an unnecessary entry long after the actual video ends with artificially extends
-/// the video length on some video players. To prevent this, the video length must be hard set. See
-/// [crunchy-labs/crunchy-cli#32](https://github.com/crunchy-labs/crunchy-cli/issues/32) for more
-/// information.
-fn fix_subtitle_length(raw: Vec<u8>, max_length: NaiveTime) -> Vec<u8> {
-    let re =
-        Regex::new(r#"^Dialogue:\s\d+,(?P<start>\d+:\d+:\d+\.\d+),(?P<end>\d+:\d+:\d+\.\d+),"#)
-            .unwrap();
-
-    // chrono panics if we try to format NaiveTime with `%2f` and the nano seconds has more than 2
-    // digits so them have to be reduced manually to avoid the panic
-    fn format_naive_time(native_time: NaiveTime) -> String {
-        let formatted_time = native_time.format("%f").to_string();
-        format!(
-            "{}.{}",
-            native_time.format("%T"),
-            if formatted_time.len() <= 2 {
-                native_time.format("%2f").to_string()
-            } else {
-                formatted_time.split_at(2).0.parse().unwrap()
-            }
-        )
-    }
-
-    let length_as_string = format_naive_time(max_length);
-    let mut new = String::new();
-
-    for line in String::from_utf8_lossy(raw.as_slice()).split('\n') {
-        if let Some(capture) = re.captures(line) {
-            let start = capture.name("start").map_or(NaiveTime::default(), |s| {
-                NaiveTime::parse_from_str(s.as_str(), "%H:%M:%S.%f").unwrap()
-            });
-            let end = capture.name("end").map_or(NaiveTime::default(), |s| {
-                NaiveTime::parse_from_str(s.as_str(), "%H:%M:%S.%f").unwrap()
-            });
-
-            if start > max_length {
-                continue;
-            } else if end > max_length {
-                new.push_str(
-                    re.replace(
-                        line,
-                        format!(
-                            "Dialogue: {},{},",
-                            format_naive_time(start),
-                            &length_as_string
-                        ),
-                    )
-                    .to_string()
-                    .as_str(),
-                )
-            } else {
-                new.push_str(line)
-            }
-        } else {
-            new.push_str(line)
-        }
-        new.push('\n')
-    }
-
-    new.into_bytes()
-}
-
 fn generate_mkv(
     archive: &Archive,
     target: PathBuf,
@@ -721,23 +602,3 @@ fn generate_mkv(
 
     Ok(())
 }
-
-/// Get the length of a video. This is required because sometimes subtitles have an unnecessary entry
-/// long after the actual video ends with artificially extends the video length on some video players.
-/// To prevent this, the video length must be hard set. See
-/// [crunchy-labs/crunchy-cli#32](https://github.com/crunchy-labs/crunchy-cli/issues/32) for more
-/// information.
-fn get_video_length(path: PathBuf) -> Result<NaiveTime> {
-    let video_length = Regex::new(r"Duration:\s(?P<time>\d+:\d+:\d+\.\d+),")?;
-
-    let ffmpeg = Command::new("ffmpeg")
-        .stdout(Stdio::null())
-        .stderr(Stdio::piped())
-        .arg("-y")
-        .args(["-i", path.to_str().unwrap()])
-        .output()?;
-    let ffmpeg_output = String::from_utf8(ffmpeg.stderr)?;
-    let caps = video_length.captures(ffmpeg_output.as_str()).unwrap();
-
-    Ok(NaiveTime::parse_from_str(caps.name("time").unwrap().as_str(), "%H:%M:%S%.f").unwrap())
-}
diff --git a/crunchy-cli-core/src/cli/download.rs b/crunchy-cli-core/src/cli/download.rs
index 7a49a4c..223162f 100644
--- a/crunchy-cli-core/src/cli/download.rs
+++ b/crunchy-cli-core/src/cli/download.rs
@@ -6,19 +6,21 @@ use crate::cli::utils::{
 use crate::utils::context::Context;
 use crate::utils::format::Format;
 use crate::utils::log::progress;
-use crate::utils::os::{free_file, has_ffmpeg, is_special_file};
+use crate::utils::os::{free_file, has_ffmpeg, is_special_file, tempfile};
 use crate::utils::parse::{parse_url, UrlFilter};
 use crate::utils::sort::{sort_formats_after_seasons, sort_seasons_after_number};
+use crate::utils::subtitle::download_subtitle;
+use crate::utils::video::get_video_length;
 use crate::Execute;
 use anyhow::{bail, Result};
-use crunchyroll_rs::media::{Resolution, VariantData};
+use crunchyroll_rs::media::{Resolution, StreamSubtitle, VariantData};
 use crunchyroll_rs::{
     Episode, Locale, Media, MediaCollection, Movie, MovieListing, Season, Series,
 };
 use log::{debug, error, info, warn};
 use std::borrow::Cow;
-use std::fs::File;
-use std::path::{Path, PathBuf};
+use std::io::Read;
+use std::path::Path;
 use std::process::{Command, Stdio};
 
 #[derive(Debug, clap::Parser)]
@@ -51,7 +53,7 @@ pub struct Download {
       {series_id}               → ID of the series\n  \
       {season_id}               → ID of the season\n  \
       {episode_id}              → ID of the episode")]
-    #[arg(short, long, default_value = "{title}.ts")]
+    #[arg(short, long, default_value = "{title}.mp4")]
     output: String,
 
     #[arg(help = "Video resolution")]
@@ -85,17 +87,14 @@ pub struct Download {
 #[async_trait::async_trait(?Send)]
 impl Execute for Download {
     fn pre_check(&self) -> Result<()> {
-        if has_ffmpeg() {
-            debug!("FFmpeg detected")
-        } else if PathBuf::from(&self.output)
+        if !has_ffmpeg() {
+            bail!("FFmpeg is needed to run this command")
+        } else if Path::new(&self.output)
             .extension()
             .unwrap_or_default()
-            .to_string_lossy()
-            != "ts"
+            .is_empty()
         {
-            bail!("File extension is not '.ts'. If you want to use a custom file format, please install ffmpeg")
-        } else if !self.ffmpeg_preset.is_empty() {
-            bail!("FFmpeg is required to use (ffmpeg) presets")
+            bail!("No file extension found. Please specify a file extension (via `-o`) for the output file")
         }
 
         let _ = FFmpegPreset::ffmpeg_presets(self.ffmpeg_preset.clone())?;
@@ -245,23 +244,14 @@ impl Execute for Download {
                 tab_info!("Resolution: {}", format.stream.resolution);
                 tab_info!("FPS: {:.2}", format.stream.fps);
 
-                let extension = path.extension().unwrap_or_default().to_string_lossy();
-
-                if (!extension.is_empty() && extension != "ts") || !self.ffmpeg_preset.is_empty() {
-                    download_ffmpeg(&ctx, &self, format.stream, path.as_path()).await?;
-                } else if path.to_str().unwrap() == "-" {
-                    let mut stdout = std::io::stdout().lock();
-                    download_segments(&ctx, &mut stdout, None, format.stream).await?;
-                } else {
-                    // create parent directory if it does not exist
-                    if let Some(parent) = path.parent() {
-                        if !parent.exists() {
-                            std::fs::create_dir_all(parent)?
-                        }
-                    }
-                    let mut file = File::options().create(true).write(true).open(&path)?;
-                    download_segments(&ctx, &mut file, None, format.stream).await?
-                }
+                download_ffmpeg(
+                    &ctx,
+                    &self,
+                    format.stream,
+                    format.subtitles.get(0).cloned(),
+                    path.as_path(),
+                )
+                .await?;
             }
         }
 
@@ -273,9 +263,10 @@ async fn download_ffmpeg(
     ctx: &Context,
     download: &Download,
     variant_data: VariantData,
+    subtitle: Option<StreamSubtitle>,
     target: &Path,
 ) -> Result<()> {
-    let (input_presets, output_presets) =
+    let (input_presets, mut output_presets) =
         FFmpegPreset::ffmpeg_presets(download.ffmpeg_preset.clone())?;
 
     // create parent directory if it does not exist
@@ -285,32 +276,66 @@ async fn download_ffmpeg(
         }
     }
 
+    if let Some(ext) = target.extension() {
+        if ext.to_string_lossy() != "mp4" && subtitle.is_some() {
+            warn!("Detected a non mp4 output container. Adding subtitles may take a while")
+        }
+    }
+
+    let mut video_file = tempfile(".ts")?;
+    download_segments(ctx, &mut video_file, None, variant_data).await?;
+    let subtitle_file = if let Some(ref sub) = subtitle {
+        let video_len = get_video_length(video_file.path().to_path_buf())?;
+        Some(download_subtitle(sub.clone(), video_len).await?)
+    } else {
+        None
+    };
+
+    let subtitle_preset = if let Some(sub_file) = &subtitle_file {
+        if target.extension().unwrap_or_default().to_string_lossy() == "mp4" {
+            vec![
+                "-i".to_string(),
+                sub_file.to_string_lossy().to_string(),
+                "-c:s".to_string(),
+                "mov_text".to_string(),
+                "-disposition:s:s:0".to_string(),
+                "forced".to_string(),
+            ]
+        } else {
+            // remove '-c:v copy' and '-c:a copy' from output presets as its causes issues with
+            // burning subs into the video
+            let mut last = String::new();
+            let mut remove_count = 0;
+            for (i, s) in output_presets.clone().iter().enumerate() {
+                if (last == "-c:v" || last == "-c:a") && s == "copy" {
+                    // remove last
+                    output_presets.remove(i - remove_count - 1);
+                    remove_count += 1;
+                    output_presets.remove(i - remove_count);
+                    remove_count += 1;
+                }
+                last = s.clone();
+            }
+
+            vec![
+                "-vf".to_string(),
+                format!("subtitles={}", sub_file.to_string_lossy()),
+            ]
+        }
+    } else {
+        vec![]
+    };
+
     let mut ffmpeg = Command::new("ffmpeg")
-        .stdin(Stdio::piped())
-        .stdout(Stdio::null())
         .stderr(Stdio::piped())
         .arg("-y")
         .args(input_presets)
-        .args(["-f", "mpegts", "-i", "pipe:"])
-        .args(
-            if target
-                .extension()
-                .unwrap_or_default()
-                .to_string_lossy()
-                .is_empty()
-            {
-                vec!["-f", "mpegts"]
-            } else {
-                vec![]
-            }
-            .as_slice(),
-        )
+        .args(["-i", video_file.path().to_string_lossy().as_ref()])
+        .args(subtitle_preset)
         .args(output_presets)
         .arg(target.to_str().unwrap())
         .spawn()?;
 
-    download_segments(ctx, &mut ffmpeg.stdin.take().unwrap(), None, variant_data).await?;
-
     let _progress_handler = progress!("Generating output file");
     ffmpeg.wait()?;
     info!("Output file generated");
@@ -431,8 +456,11 @@ async fn format_from_episode(
     }
 
     let streams = episode.streams().await?;
-    let streaming_data = if let Some(subtitle) = &download.subtitle {
-        if !streams.subtitles.keys().cloned().any(|x| &x == subtitle) {
+    let streaming_data = streams.hls_streaming_data(None).await?;
+    let subtitle = if let Some(subtitle) = &download.subtitle {
+        if let Some(sub) = streams.subtitles.get(subtitle) {
+            Some(sub.clone())
+        } else {
             error!(
                 "Episode {} ({}) of season {} ({}) of {} has no {} subtitles",
                 episode.metadata.episode_number,
@@ -444,9 +472,8 @@ async fn format_from_episode(
             );
             return Ok(None);
         }
-        streams.hls_streaming_data(Some(subtitle.clone())).await?
     } else {
-        streams.hls_streaming_data(None).await?
+        None
     };
 
     let Some(stream) = find_resolution(streaming_data, &download.resolution) else {
@@ -476,6 +503,7 @@ async fn format_from_episode(
         episode,
         &season_eps.to_vec(),
         stream,
+        subtitle.map_or_else(|| vec![], |s| vec![s]),
     )))
 }
 
diff --git a/crunchy-cli-core/src/cli/utils.rs b/crunchy-cli-core/src/cli/utils.rs
index da56f5e..8a7a79a 100644
--- a/crunchy-cli-core/src/cli/utils.rs
+++ b/crunchy-cli-core/src/cli/utils.rs
@@ -290,38 +290,32 @@ impl FFmpegPreset {
                     FFmpegPreset::Av1 => bail!("'nvidia' hardware acceleration preset is not available in combination with the 'av1' codec preset"),
                     FFmpegPreset::H265 => {
                         input.extend(["-hwaccel", "cuvid", "-c:v", "h264_cuvid"]);
-                        output.extend(["-c:v", "hevc_nvenc"]);
+                        output.extend(["-c:v", "hevc_nvenc", "-c:a", "copy"]);
                     }
                     FFmpegPreset::H264 => {
                         input.extend(["-hwaccel", "cuvid", "-c:v", "h264_cuvid"]);
-                        output.extend(["-c:v", "h264_nvenc"]);
+                        output.extend(["-c:v", "h264_nvenc", "-c:a", "copy"]);
                     }
                     _ => ()
                 }
             } else {
                 match preset {
                     FFmpegPreset::Av1 => {
-                        output.extend(["-c:v", "libaom-av1"]);
+                        output.extend(["-c:v", "libaom-av1", "-c:a", "copy"]);
                     }
                     FFmpegPreset::H265 => {
-                        output.extend(["-c:v", "libx265"]);
+                        output.extend(["-c:v", "libx265", "-c:a", "copy"]);
                     }
                     FFmpegPreset::H264 => {
-                        output.extend(["-c:v", "libx264"]);
+                        output.extend(["-c:v", "libx264", "-c:a", "copy"]);
                     }
                     _ => (),
                 }
             }
         }
 
-        if input.is_empty() && output.is_empty() {
-            output.extend(["-c", "copy"])
-        } else {
-            if output.is_empty() {
-                output.extend(["-c", "copy"])
-            } else {
-                output.extend(["-c:a", "copy", "-c:s", "copy"])
-            }
+        if output.is_empty() {
+            output.extend(["-c:v", "copy", "-c:a", "copy"])
         }
 
         Ok((
diff --git a/crunchy-cli-core/src/utils/format.rs b/crunchy-cli-core/src/utils/format.rs
index 60596ad..93ee773 100644
--- a/crunchy-cli-core/src/utils/format.rs
+++ b/crunchy-cli-core/src/utils/format.rs
@@ -1,4 +1,4 @@
-use crunchyroll_rs::media::VariantData;
+use crunchyroll_rs::media::{StreamSubtitle, VariantData};
 use crunchyroll_rs::{Episode, Locale, Media, Movie};
 use log::warn;
 use std::path::PathBuf;
@@ -10,6 +10,7 @@ pub struct Format {
     pub description: String,
 
     pub audio: Locale,
+    pub subtitles: Vec<StreamSubtitle>,
 
     pub duration: Duration,
     pub stream: VariantData,
@@ -31,12 +32,14 @@ impl Format {
         episode: &Media<Episode>,
         season_episodes: &Vec<Media<Episode>>,
         stream: VariantData,
+        subtitles: Vec<StreamSubtitle>,
     ) -> Self {
         Self {
             title: episode.title.clone(),
             description: episode.description.clone(),
 
             audio: episode.metadata.audio_locale.clone(),
+            subtitles,
 
             duration: episode.metadata.duration.to_std().unwrap(),
             stream,
@@ -78,6 +81,7 @@ impl Format {
 
             duration: movie.metadata.duration.to_std().unwrap(),
             stream,
+            subtitles: vec![],
 
             series_id: movie.metadata.movie_listing_id.clone(),
             series_name: movie.metadata.movie_listing_title.clone(),
diff --git a/crunchy-cli-core/src/utils/mod.rs b/crunchy-cli-core/src/utils/mod.rs
index 3b15a89..552c198 100644
--- a/crunchy-cli-core/src/utils/mod.rs
+++ b/crunchy-cli-core/src/utils/mod.rs
@@ -7,3 +7,4 @@ pub mod os;
 pub mod parse;
 pub mod sort;
 pub mod subtitle;
+pub mod video;
diff --git a/crunchy-cli-core/src/utils/subtitle.rs b/crunchy-cli-core/src/utils/subtitle.rs
index 86b9359..f638b1b 100644
--- a/crunchy-cli-core/src/utils/subtitle.rs
+++ b/crunchy-cli-core/src/utils/subtitle.rs
@@ -1,5 +1,11 @@
+use crate::utils::os::tempfile;
+use anyhow::Result;
+use chrono::NaiveTime;
 use crunchyroll_rs::media::StreamSubtitle;
 use crunchyroll_rs::Locale;
+use regex::Regex;
+use std::io::Write;
+use tempfile::TempPath;
 
 #[derive(Clone)]
 pub struct Subtitle {
@@ -9,3 +15,105 @@ pub struct Subtitle {
     pub forced: bool,
     pub primary: bool,
 }
+
+pub async fn download_subtitle(
+    subtitle: StreamSubtitle,
+    max_length: NaiveTime,
+) -> Result<TempPath> {
+    let tempfile = tempfile(".ass")?;
+    let (mut file, path) = tempfile.into_parts();
+
+    let mut buf = vec![];
+    subtitle.write_to(&mut buf).await?;
+    buf = fix_subtitle_look_and_feel(buf);
+    buf = fix_subtitle_length(buf, max_length);
+
+    file.write_all(buf.as_slice())?;
+
+    Ok(path)
+}
+
+/// Add `ScaledBorderAndShadows: yes` to subtitles; without it they look very messy on some video
+/// players. See [crunchy-labs/crunchy-cli#66](https://github.com/crunchy-labs/crunchy-cli/issues/66)
+/// for more information.
+fn fix_subtitle_look_and_feel(raw: Vec<u8>) -> Vec<u8> {
+    let mut script_info = false;
+    let mut new = String::new();
+
+    for line in String::from_utf8_lossy(raw.as_slice()).split('\n') {
+        if line.trim().starts_with('[') && script_info {
+            new.push_str("ScaledBorderAndShadow: yes\n");
+            script_info = false
+        } else if line.trim() == "[Script Info]" {
+            script_info = true
+        }
+        new.push_str(line);
+        new.push('\n')
+    }
+
+    new.into_bytes()
+}
+
+/// Fix the length of subtitles to a specified maximum amount. This is required because sometimes
+/// subtitles have an unnecessary entry long after the actual video ends with artificially extends
+/// the video length on some video players. To prevent this, the video length must be hard set. See
+/// [crunchy-labs/crunchy-cli#32](https://github.com/crunchy-labs/crunchy-cli/issues/32) for more
+/// information.
+fn fix_subtitle_length(raw: Vec<u8>, max_length: NaiveTime) -> Vec<u8> {
+    let re =
+        Regex::new(r#"^Dialogue:\s\d+,(?P<start>\d+:\d+:\d+\.\d+),(?P<end>\d+:\d+:\d+\.\d+),"#)
+            .unwrap();
+
+    // chrono panics if we try to format NaiveTime with `%2f` and the nano seconds has more than 2
+    // digits so them have to be reduced manually to avoid the panic
+    fn format_naive_time(native_time: NaiveTime) -> String {
+        let formatted_time = native_time.format("%f").to_string();
+        format!(
+            "{}.{}",
+            native_time.format("%T"),
+            if formatted_time.len() <= 2 {
+                native_time.format("%2f").to_string()
+            } else {
+                formatted_time.split_at(2).0.parse().unwrap()
+            }
+        )
+    }
+
+    let length_as_string = format_naive_time(max_length);
+    let mut new = String::new();
+
+    for line in String::from_utf8_lossy(raw.as_slice()).split('\n') {
+        if let Some(capture) = re.captures(line) {
+            let start = capture.name("start").map_or(NaiveTime::default(), |s| {
+                NaiveTime::parse_from_str(s.as_str(), "%H:%M:%S.%f").unwrap()
+            });
+            let end = capture.name("end").map_or(NaiveTime::default(), |s| {
+                NaiveTime::parse_from_str(s.as_str(), "%H:%M:%S.%f").unwrap()
+            });
+
+            if start > max_length {
+                continue;
+            } else if end > max_length {
+                new.push_str(
+                    re.replace(
+                        line,
+                        format!(
+                            "Dialogue: {},{},",
+                            format_naive_time(start),
+                            &length_as_string
+                        ),
+                    )
+                    .to_string()
+                    .as_str(),
+                )
+            } else {
+                new.push_str(line)
+            }
+        } else {
+            new.push_str(line)
+        }
+        new.push('\n')
+    }
+
+    new.into_bytes()
+}
diff --git a/crunchy-cli-core/src/utils/video.rs b/crunchy-cli-core/src/utils/video.rs
new file mode 100644
index 0000000..2d12bfc
--- /dev/null
+++ b/crunchy-cli-core/src/utils/video.rs
@@ -0,0 +1,25 @@
+use anyhow::Result;
+use chrono::NaiveTime;
+use regex::Regex;
+use std::path::PathBuf;
+use std::process::{Command, Stdio};
+
+/// Get the length of a video. This is required because sometimes subtitles have an unnecessary entry
+/// long after the actual video ends with artificially extends the video length on some video players.
+/// To prevent this, the video length must be hard set. See
+/// [crunchy-labs/crunchy-cli#32](https://github.com/crunchy-labs/crunchy-cli/issues/32) for more
+/// information.
+pub fn get_video_length(path: PathBuf) -> Result<NaiveTime> {
+    let video_length = Regex::new(r"Duration:\s(?P<time>\d+:\d+:\d+\.\d+),")?;
+
+    let ffmpeg = Command::new("ffmpeg")
+        .stdout(Stdio::null())
+        .stderr(Stdio::piped())
+        .arg("-y")
+        .args(["-i", path.to_str().unwrap()])
+        .output()?;
+    let ffmpeg_output = String::from_utf8(ffmpeg.stderr)?;
+    let caps = video_length.captures(ffmpeg_output.as_str()).unwrap();
+
+    Ok(NaiveTime::parse_from_str(caps.name("time").unwrap().as_str(), "%H:%M:%S%.f").unwrap())
+}

From 08c4e30a06d13703d948ccc431a4f459e8c53fa5 Mon Sep 17 00:00:00 2001
From: ByteDream <bytedream@protonmail.com>
Date: Fri, 13 Jan 2023 16:03:19 +0100
Subject: [PATCH 2/6] (Re-)add download pipe to stdout

---
 crunchy-cli-core/src/cli/download.rs | 43 ++++++++++++++++++++--------
 1 file changed, 31 insertions(+), 12 deletions(-)

diff --git a/crunchy-cli-core/src/cli/download.rs b/crunchy-cli-core/src/cli/download.rs
index 223162f..9885b3c 100644
--- a/crunchy-cli-core/src/cli/download.rs
+++ b/crunchy-cli-core/src/cli/download.rs
@@ -19,8 +19,7 @@ use crunchyroll_rs::{
 };
 use log::{debug, error, info, warn};
 use std::borrow::Cow;
-use std::io::Read;
-use std::path::Path;
+use std::path::{Path, PathBuf};
 use std::process::{Command, Stdio};
 
 #[derive(Debug, clap::Parser)]
@@ -93,10 +92,19 @@ impl Execute for Download {
             .extension()
             .unwrap_or_default()
             .is_empty()
+            && self.output != "-"
         {
             bail!("No file extension found. Please specify a file extension (via `-o`) for the output file")
         }
 
+        if self.subtitle.is_some() {
+            if let Some(ext) = Path::new(&self.output).extension() {
+                if ext.to_string_lossy() != "mp4" {
+                    warn!("Detected a non mp4 output container. Adding subtitles may take a while")
+                }
+            }
+        }
+
         let _ = FFmpegPreset::ffmpeg_presets(self.ffmpeg_preset.clone())?;
         if self.ffmpeg_preset.len() == 1
             && self.ffmpeg_preset.get(0).unwrap() == &FFmpegPreset::Nvidia
@@ -249,7 +257,7 @@ impl Execute for Download {
                     &self,
                     format.stream,
                     format.subtitles.get(0).cloned(),
-                    path.as_path(),
+                    path.to_path_buf(),
                 )
                 .await?;
             }
@@ -264,7 +272,7 @@ async fn download_ffmpeg(
     download: &Download,
     variant_data: VariantData,
     subtitle: Option<StreamSubtitle>,
-    target: &Path,
+    mut target: PathBuf,
 ) -> Result<()> {
     let (input_presets, mut output_presets) =
         FFmpegPreset::ffmpeg_presets(download.ffmpeg_preset.clone())?;
@@ -276,12 +284,6 @@ async fn download_ffmpeg(
         }
     }
 
-    if let Some(ext) = target.extension() {
-        if ext.to_string_lossy() != "mp4" && subtitle.is_some() {
-            warn!("Detected a non mp4 output container. Adding subtitles may take a while")
-        }
-    }
-
     let mut video_file = tempfile(".ts")?;
     download_segments(ctx, &mut video_file, None, variant_data).await?;
     let subtitle_file = if let Some(ref sub) = subtitle {
@@ -291,11 +293,22 @@ async fn download_ffmpeg(
         None
     };
 
-    let subtitle_preset = if let Some(sub_file) = &subtitle_file {
+    let stdout_tempfile = if target.to_string_lossy() == "-" {
+        let file = tempfile(".mp4")?;
+        target = file.path().to_path_buf();
+
+        Some(file)
+    } else {
+        None
+    };
+
+    let subtitle_presets = if let Some(sub_file) = &subtitle_file {
         if target.extension().unwrap_or_default().to_string_lossy() == "mp4" {
             vec![
                 "-i".to_string(),
                 sub_file.to_string_lossy().to_string(),
+                "-movflags".to_string(),
+                "faststart".to_string(),
                 "-c:s".to_string(),
                 "mov_text".to_string(),
                 "-disposition:s:s:0".to_string(),
@@ -331,7 +344,7 @@ async fn download_ffmpeg(
         .arg("-y")
         .args(input_presets)
         .args(["-i", video_file.path().to_string_lossy().as_ref()])
-        .args(subtitle_preset)
+        .args(subtitle_presets)
         .args(output_presets)
         .arg(target.to_str().unwrap())
         .spawn()?;
@@ -340,6 +353,12 @@ async fn download_ffmpeg(
     ffmpeg.wait()?;
     info!("Output file generated");
 
+    if let Some(mut stdout_file) = stdout_tempfile {
+        let mut stdout = std::io::stdout();
+
+        std::io::copy(&mut stdout_file, &mut stdout)?;
+    }
+
     Ok(())
 }
 

From 3d145b021baa207016b9ca419c33cfbd4bf8aa46 Mon Sep 17 00:00:00 2001
From: ByteDream <bytedream@protonmail.com>
Date: Fri, 13 Jan 2023 16:04:53 +0100
Subject: [PATCH 3/6] Add download ffmpeg error output

---
 crunchy-cli-core/src/cli/download.rs | 5 ++++-
 1 file changed, 4 insertions(+), 1 deletion(-)

diff --git a/crunchy-cli-core/src/cli/download.rs b/crunchy-cli-core/src/cli/download.rs
index 9885b3c..66027a2 100644
--- a/crunchy-cli-core/src/cli/download.rs
+++ b/crunchy-cli-core/src/cli/download.rs
@@ -340,6 +340,7 @@ async fn download_ffmpeg(
     };
 
     let mut ffmpeg = Command::new("ffmpeg")
+        .stdout(Stdio::null())
         .stderr(Stdio::piped())
         .arg("-y")
         .args(input_presets)
@@ -350,7 +351,9 @@ async fn download_ffmpeg(
         .spawn()?;
 
     let _progress_handler = progress!("Generating output file");
-    ffmpeg.wait()?;
+    if !ffmpeg.wait()?.success() {
+        bail!("{}", std::io::read_to_string(ffmpeg.stderr.unwrap())?)
+    }
     info!("Output file generated");
 
     if let Some(mut stdout_file) = stdout_tempfile {

From 497f22ee49e0476203e75abef56413e891a584cb Mon Sep 17 00:00:00 2001
From: ByteDream <bytedream@protonmail.com>
Date: Fri, 13 Jan 2023 22:38:29 +0100
Subject: [PATCH 4/6] Fix double download progress output message

---
 crunchy-cli-core/src/cli/download.rs | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/crunchy-cli-core/src/cli/download.rs b/crunchy-cli-core/src/cli/download.rs
index 66027a2..05372a4 100644
--- a/crunchy-cli-core/src/cli/download.rs
+++ b/crunchy-cli-core/src/cli/download.rs
@@ -350,11 +350,11 @@ async fn download_ffmpeg(
         .arg(target.to_str().unwrap())
         .spawn()?;
 
-    let _progress_handler = progress!("Generating output file");
+    let progress_handler = progress!("Generating output file");
     if !ffmpeg.wait()?.success() {
         bail!("{}", std::io::read_to_string(ffmpeg.stderr.unwrap())?)
     }
-    info!("Output file generated");
+    progress_handler.stop("Output file generated");
 
     if let Some(mut stdout_file) = stdout_tempfile {
         let mut stdout = std::io::stdout();

From 685ac85857c37b7d6abd53c3171faeda4b1a8fd5 Mon Sep 17 00:00:00 2001
From: ByteDream <bytedream@protonmail.com>
Date: Sun, 15 Jan 2023 21:38:35 +0100
Subject: [PATCH 5/6] Add flag to skip existing files (#67, #109)

---
 crunchy-cli-core/src/cli/archive.rs  | 31 +++++++++++++++++++---------
 crunchy-cli-core/src/cli/download.rs | 31 +++++++++++++++++++---------
 crunchy-cli-core/src/utils/os.rs     |  6 +++---
 3 files changed, 45 insertions(+), 23 deletions(-)

diff --git a/crunchy-cli-core/src/cli/archive.rs b/crunchy-cli-core/src/cli/archive.rs
index 768c629..a8b79b6 100644
--- a/crunchy-cli-core/src/cli/archive.rs
+++ b/crunchy-cli-core/src/cli/archive.rs
@@ -122,6 +122,10 @@ pub struct Archive {
     #[arg(long)]
     no_subtitle_optimizations: bool,
 
+    #[arg(help = "Skip files which are already existing")]
+    #[arg(long, default_value_t = false)]
+    skip_existing: bool,
+
     #[arg(help = "Ignore interactive input")]
     #[arg(short, long, default_value_t = false)]
     yes: bool,
@@ -242,17 +246,24 @@ impl Execute for Archive {
             for (formats, mut subtitles) in archive_formats {
                 let (primary, additionally) = formats.split_first().unwrap();
 
-                let path = free_file(
-                    primary.format_path(
-                        if self.output.is_empty() {
-                            "{title}.mkv"
-                        } else {
-                            &self.output
-                        }
-                        .into(),
-                        true,
-                    ),
+                let formatted_path = primary.format_path(
+                    if self.output.is_empty() {
+                        "{title}.mkv"
+                    } else {
+                        &self.output
+                    }
+                    .into(),
+                    true,
                 );
+                let (path, changed) = free_file(formatted_path.clone());
+
+                if changed && self.skip_existing {
+                    debug!(
+                        "Skipping already existing file '{}'",
+                        formatted_path.to_string_lossy()
+                    );
+                    continue;
+                }
 
                 info!(
                     "Downloading {} to '{}'",
diff --git a/crunchy-cli-core/src/cli/download.rs b/crunchy-cli-core/src/cli/download.rs
index 7a49a4c..fddbfd3 100644
--- a/crunchy-cli-core/src/cli/download.rs
+++ b/crunchy-cli-core/src/cli/download.rs
@@ -74,6 +74,10 @@ pub struct Download {
     #[arg(value_parser = FFmpegPreset::parse)]
     ffmpeg_preset: Vec<FFmpegPreset>,
 
+    #[arg(help = "Skip files which are already existing")]
+    #[arg(long, default_value_t = false)]
+    skip_existing: bool,
+
     #[arg(help = "Ignore interactive input")]
     #[arg(short, long, default_value_t = false)]
     yes: bool,
@@ -209,17 +213,24 @@ impl Execute for Download {
             }
 
             for format in formats {
-                let path = free_file(
-                    format.format_path(
-                        if self.output.is_empty() {
-                            "{title}.mkv"
-                        } else {
-                            &self.output
-                        }
-                        .into(),
-                        true,
-                    ),
+                let formatted_path = format.format_path(
+                    if self.output.is_empty() {
+                        "{title}.mkv"
+                    } else {
+                        &self.output
+                    }
+                    .into(),
+                    true,
                 );
+                let (path, changed) = free_file(formatted_path.clone());
+
+                if changed && self.skip_existing {
+                    debug!(
+                        "Skipping already existing file '{}'",
+                        formatted_path.to_string_lossy()
+                    );
+                    continue;
+                }
 
                 info!(
                     "Downloading {} to '{}'",
diff --git a/crunchy-cli-core/src/utils/os.rs b/crunchy-cli-core/src/utils/os.rs
index a7b3fbf..94e9d02 100644
--- a/crunchy-cli-core/src/utils/os.rs
+++ b/crunchy-cli-core/src/utils/os.rs
@@ -36,10 +36,10 @@ pub fn tempfile<S: AsRef<str>>(suffix: S) -> io::Result<NamedTempFile> {
 }
 
 /// Check if the given path exists and rename it until the new (renamed) file does not exist.
-pub fn free_file(mut path: PathBuf) -> PathBuf {
+pub fn free_file(mut path: PathBuf) -> (PathBuf, bool) {
     // if it's a special file does not rename it
     if is_special_file(&path) {
-        return path;
+        return (path, false);
     }
 
     let mut i = 0;
@@ -55,7 +55,7 @@ pub fn free_file(mut path: PathBuf) -> PathBuf {
 
         path.set_file_name(format!("{} ({}).{}", filename, i, ext))
     }
-    path
+    (path, i != 0)
 }
 
 /// Check if the given path is a special file. On Linux this is probably a pipe and on Windows

From 577c0679adee027dc52801a8745968a830d35120 Mon Sep 17 00:00:00 2001
From: ByteDream <bytedream@protonmail.com>
Date: Sun, 15 Jan 2023 21:43:31 +0100
Subject: [PATCH 6/6] Remove automatically set filename if output is empty

---
 crunchy-cli-core/src/cli/archive.rs  | 10 +---------
 crunchy-cli-core/src/cli/download.rs | 10 +---------
 2 files changed, 2 insertions(+), 18 deletions(-)

diff --git a/crunchy-cli-core/src/cli/archive.rs b/crunchy-cli-core/src/cli/archive.rs
index a8b79b6..31d39c6 100644
--- a/crunchy-cli-core/src/cli/archive.rs
+++ b/crunchy-cli-core/src/cli/archive.rs
@@ -246,15 +246,7 @@ impl Execute for Archive {
             for (formats, mut subtitles) in archive_formats {
                 let (primary, additionally) = formats.split_first().unwrap();
 
-                let formatted_path = primary.format_path(
-                    if self.output.is_empty() {
-                        "{title}.mkv"
-                    } else {
-                        &self.output
-                    }
-                    .into(),
-                    true,
-                );
+                let formatted_path = primary.format_path((&self.output).into(), true);
                 let (path, changed) = free_file(formatted_path.clone());
 
                 if changed && self.skip_existing {
diff --git a/crunchy-cli-core/src/cli/download.rs b/crunchy-cli-core/src/cli/download.rs
index fddbfd3..d8fb003 100644
--- a/crunchy-cli-core/src/cli/download.rs
+++ b/crunchy-cli-core/src/cli/download.rs
@@ -213,15 +213,7 @@ impl Execute for Download {
             }
 
             for format in formats {
-                let formatted_path = format.format_path(
-                    if self.output.is_empty() {
-                        "{title}.mkv"
-                    } else {
-                        &self.output
-                    }
-                    .into(),
-                    true,
-                );
+                let formatted_path = format.format_path((&self.output).into(), true);
                 let (path, changed) = free_file(formatted_path.clone());
 
                 if changed && self.skip_existing {