Add trv watch command (#21)

Will spawn a server with live reloading that shows the slides and allows
playing the sub-videos.

Author: rikhuijzer

Cargo.toml

@@ -19,6 +19,9 @@ serde_json = "1.0.138"
 serde = { version = "1", features = ["derive"] }
 sha2 = "0.10.8"
 toml = "0.8"
+live-server = "0.10.0"
+notify = "8.0"
+indoc = "2.0.6"
 
 [dev-dependencies]
 assert_cmd = "2"

examples/first.typ

@@ -38,4 +38,4 @@
       That would be pretty cool.
       Here is a plan to make it happen.
     ")
-]
+]

src/main.rs

@@ -3,7 +3,9 @@ mod image;
 mod path;
 mod slide;
 mod video;
+mod watch;
 
+use crate::slide::Slide;
 use clap::Parser;
 use serde::Deserialize;
 use serde_json::json;
@@ -12,6 +14,7 @@ use std::path::Path;
 use std::path::PathBuf;
 use tracing::subscriber::SetGlobalDefaultError;
 use transformrs::Provider;
+use watch::watch;
 
 #[derive(Clone, Debug, Default, Deserialize)]
 struct Config {
@@ -110,7 +113,7 @@ enum Task {
 
 #[derive(Parser)]
 #[command(author, version, about = "Text and image to video")]
-struct Arguments {
+pub(crate) struct Arguments {
     #[command(subcommand)]
     task: Task,
 
@@ -124,7 +127,7 @@ struct Arguments {
 
     /// Enable caching.
     #[arg(long, default_value = "true")]
-    cache: bool,
+    cache: Option<bool>,
 
     /// Release.
     ///
@@ -215,25 +218,9 @@ fn copy_input_with_includes(dir: &str, input: &PathBuf) -> PathBuf {
     output_path
 }
 
-#[tokio::main]
-async fn main() {
-    let args = Arguments::parse();
-    if args.verbose {
-        init_subscriber(tracing::Level::DEBUG).unwrap();
-    } else {
-        init_subscriber(tracing::Level::INFO).unwrap();
-    }
-
-    let dir = &args.out_dir;
-    let path = Path::new(dir);
-    if !path.exists() {
-        std::fs::create_dir_all(path).unwrap();
-    }
-    let input = match args.task {
-        Task::Build(args) => args.input,
-        Task::Watch(args) => args.input,
-    };
-    let copied_input = copy_input_with_includes(dir, &input);
+pub(crate) async fn build(input: PathBuf, args: &Arguments) -> Vec<Slide> {
+    let out_dir = &args.out_dir;
+    let copied_input = copy_input_with_includes(out_dir, &input);
     let config = parse_config(&copied_input);
 
     let provider = config.provider.map(|p| provider_from_str(&p));
@@ -254,25 +241,49 @@ async fn main() {
     if slides.is_empty() {
         panic!("No slides found in input file: {}", input.display());
     }
-    image::generate_images(&copied_input, dir);
+    image::generate_images(&copied_input, out_dir);
     let audio_ext = tts_config
         .output_format
         .clone()
         .unwrap_or("mp3".to_string());
+    let cache = args.cache.unwrap();
     audio::generate_audio_files(
         &provider,
-        dir,
+        out_dir,
         &slides,
-        args.cache,
+        cache,
         &tts_config,
         &config.model,
         &audio_ext,
     )
     .await;
-    // Using mkv by default because it supports more audio formats.
-    let output = "out.mkv";
-    video::generate_video(dir, &slides, args.cache, &tts_config, output, &audio_ext);
+    let output = "out.mp4";
+    video::generate_video(out_dir, &slides, cache, &tts_config, output, &audio_ext);
     if args.release {
-        video::generate_release_video(dir, output, "release.mp4", &args.audio_codec);
+        video::generate_release_video(out_dir, output, "release.mp4", &args.audio_codec);
+    }
+    slides
+}
+
+#[tokio::main]
+async fn main() {
+    let args = Arguments::parse();
+    if args.verbose {
+        init_subscriber(tracing::Level::DEBUG).unwrap();
+    } else {
+        init_subscriber(tracing::Level::INFO).unwrap();
     }
+
+    let dir = &args.out_dir;
+    let path = Path::new(dir);
+    if !path.exists() {
+        std::fs::create_dir_all(path).unwrap();
+    }
+
+    match args.task {
+        Task::Build(ref build_args) => {
+            let _ = build(build_args.input.clone(), &args).await;
+        }
+        Task::Watch(ref watch_args) => watch(watch_args.input.clone(), &args).await,
+    };
 }

src/path.rs

@@ -42,7 +42,7 @@ pub fn video_dir_name() -> &'static str {
 
 pub fn video_path(dir: &str, slide: &Slide) -> PathBuf {
     let idx = slide.idx;
-    // Using mkv by default because it supports more audio formats.
-    let filename = format!("{idx}.mkv");
+    // Using mp4 by default because it is widely supported in browsers.
+    let filename = format!("{idx}.mp4");
     Path::new(dir).join(video_dir_name()).join(filename)
 }

src/video.rs

@@ -83,6 +83,11 @@ fn write_concat_list(dir: &str, path: &str, slides: &Vec<Slide>) {
     std::fs::write(path, concat_list).expect("couldn't write concat list");
 }
 
+// 1920 is the height of a HD YouTube Short.
+// It should be a good height for landscape videos too.
+// Since the video consists of images, data-wise it should be not a problem to go for a higher resolution.
+const HEIGHT: i32 = 1920;
+
 fn create_video_clip(dir: &str, slide: &Slide, cache: bool, config: &TTSConfig, ext: &str) {
     tracing::info!("Slide {}: Generating video file...", slide.idx);
     let input_audio = crate::path::audio_path(dir, slide, ext);
@@ -106,8 +111,18 @@ fn create_video_clip(dir: &str, slide: &Slide, cache: bool, config: &TTSConfig,
         .arg(input_audio)
         .arg("-c:v")
         .arg("libx264")
+        .arg("-crf")
+        .arg("23")
+        .arg("-preset")
+        .arg("fast")
+        .arg("-vf")
+        .arg(format!("scale=-1:{HEIGHT},format=yuv420p"))
+        .arg("-pix_fmt")
+        .arg("yuv420p")
         .arg("-c:a")
-        .arg("copy")
+        .arg("opus")
+        .arg("-strict")
+        .arg("experimental")
         .arg("-shortest")
         .arg("-tune")
         .arg("stillimage")
@@ -187,10 +202,6 @@ pub fn generate_release_video(dir: &str, input: &str, output: &str, audio_codec:
     let output_path = Path::new(dir).join(output);
     let output_path = output_path.to_str().unwrap();
     let mut cmd = std::process::Command::new("ffmpeg");
-    // 1920 is the height of a HD YouTube Short.
-    // It should be a good height for landscape videos too.
-    // Since the video consists of images, data-wise it should be not a problem to go for a higher resolution.
-    let height = 1920;
     let output = cmd
         .arg("-y")
         .arg("-i")
@@ -202,7 +213,7 @@ pub fn generate_release_video(dir: &str, input: &str, output: &str, audio_codec:
         .arg("-preset")
         .arg("fast")
         .arg("-vf")
-        .arg(format!("scale=-1:{height},format=yuv420p"))
+        .arg(format!("scale=-1:{HEIGHT},format=yuv420p"))
         .arg("-c:a")
         .arg(audio_codec)
         .arg("-strict")