Show only image and audio during watch (#32)

This speeds up the workflow since it avoids having to combine the image
and audio into a video file.

Author: rikhuijzer

README.md

@@ -201,3 +201,24 @@ $ whisper _out/out.mp4 -f srt --model small --language=en
 ```
 
 This will create a `out.srt` file with the subtitles.
+
+## Static Videos
+
+The videos created by `trv` consist only of static images.
+This might seem limiting, but as long as the content of the video is high, static images should be fine.
+Here are some YouTubers that have hundreds of thousands to millions of views with only static images:
+
+- [Perun](https://www.youtube.com/@PerunAU)
+- [The Histocrat](https://www.youtube.com/@TheHistocrat)
+- [Christopher Manning](https://youtu.be/5Aer7MUSuSU)
+- [Richard McElreath](https://www.youtube.com/@rmcelreath)
+
+Static images with a talking-head:
+
+- [Tony Seba](https://www.youtube.com/@tonyseba)
+- [The Wild West Extravaganza](https://www.youtube.com/@WildWestExtravaganza)
+- [Andrej Karpathy](https://youtu.be/zjkBMFhNj_g)
+
+Static images with a computer-generated moving hand:
+
+- [Simplilearn](https://www.youtube.com/@SimplilearnOfficial)

src/main.rs

@@ -13,11 +13,12 @@ use std::collections::HashMap;
 use std::path::Path;
 use std::path::PathBuf;
 use tracing::subscriber::SetGlobalDefaultError;
+use transformrs::text_to_speech::TTSConfig;
 use transformrs::Provider;
 use watch::watch;
 
 #[derive(Clone, Debug, Default, Deserialize)]
-struct Config {
+pub(crate) struct Config {
     /// Provider.
     ///
     /// Can be used to pass for example
@@ -185,28 +186,32 @@ fn init_subscriber(level: tracing::Level) -> Result<(), SetGlobalDefaultError> {
     tracing::subscriber::set_global_default(subscriber)
 }
 
+fn tts_config(config: &Config, provider: &Provider) -> TTSConfig {
+    let mut other = HashMap::new();
+    if provider != &Provider::Google {
+        other.insert("seed".to_string(), json!(42));
+    }
+    TTSConfig {
+        voice: Some(config.voice.clone()),
+        output_format: config.audio_format.clone(),
+        speed: config.speed,
+        other: Some(other),
+        language_code: config.language_code.clone(),
+    }
+}
+
 pub(crate) async fn build(
     input: PathBuf,
+    config: &Config,
     args: &Arguments,
     release: bool,
     audio_codec: Option<String>,
 ) -> Vec<Slide> {
     let out_dir = &args.out_dir;
-    let config = parse_config(&input);
 
-    let provider = config.provider.map(|p| provider_from_str(&p));
+    let provider = config.provider.as_ref().map(|p| provider_from_str(p));
     let provider = provider.unwrap_or(Provider::DeepInfra);
-    let mut other = HashMap::new();
-    if provider != Provider::Google {
-        other.insert("seed".to_string(), json!(42));
-    }
-    let tts_config = transformrs::text_to_speech::TTSConfig {
-        voice: Some(config.voice.clone()),
-        output_format: config.audio_format.clone(),
-        speed: config.speed,
-        other: Some(other),
-        language_code: config.language_code.clone(),
-    };
+    let tts_config = tts_config(config, &provider);
 
     let slides = slide::slides(input.to_str().unwrap());
     if slides.is_empty() {
@@ -229,8 +234,8 @@ pub(crate) async fn build(
     )
     .await;
     let output = "out.mp4";
-    video::create_video_clips(out_dir, &slides, cache, &tts_config, &audio_ext);
     if release {
+        video::create_video_clips(out_dir, &slides, cache, &tts_config, &audio_ext);
         let audio_codec = audio_codec.unwrap();
         video::combine_video(out_dir, &slides, output, &audio_codec);
     }
@@ -256,8 +261,19 @@ async fn main() {
         Task::Build(ref build_args) => {
             let release = true;
             let audio_codec = Some(build_args.audio_codec.clone());
-            let _ = build(build_args.input.clone(), &args, release, audio_codec).await;
+            let config = parse_config(&build_args.input);
+            let _ = build(
+                build_args.input.clone(),
+                &config,
+                &args,
+                release,
+                audio_codec,
+            )
+            .await;
+        }
+        Task::Watch(ref watch_args) => {
+            let config = parse_config(&watch_args.input);
+            watch(watch_args, &config, &args).await
         }
-        Task::Watch(ref watch_args) => watch(watch_args, &args).await,
     };
 }

src/watch.rs

@@ -1,6 +1,7 @@
 use crate::build;
 use crate::slide::Slide;
 use crate::Arguments;
+use crate::Config;
 use crate::WatchArgs;
 use ignore::Walk;
 use live_server::listen;
@@ -13,35 +14,50 @@ use std::path::Path;
 use std::path::PathBuf;
 use std::sync::mpsc;
 
+/// Add a timestamp to the filename.
+///
+/// This is used to bust the browser cache (force update).
 fn add_timestamp(filename: &OsStr, timestamp: u64) -> String {
     let path = Path::new(filename);
     let stem = path.file_stem().unwrap().to_str().unwrap();
     let extension = path.extension().unwrap_or_default().to_str().unwrap_or("");
     format!("{}_{}.{}", stem, timestamp, extension)
 }
 
-fn core_html(out_dir: &str, slide: &Slide, timestamp: u64) -> String {
-    let video_path = crate::path::video_path(out_dir, slide);
-    let filename = video_path.file_name().unwrap();
-    let filename = add_timestamp(filename, timestamp);
+fn core_html(out_dir: &str, slide: &Slide, timestamp: u64, config: &Config) -> String {
+    let image_path = crate::path::image_path(out_dir, slide);
+    let image_file = image_path.file_name().unwrap();
+    let image_file = add_timestamp(image_file, timestamp);
+    let audio_ext = config.audio_format.as_ref().unwrap();
+    let audio_path = crate::path::audio_path(out_dir, slide, audio_ext);
+    let audio_file = audio_path.file_name().unwrap();
+    let audio_file = add_timestamp(audio_file, timestamp);
     format!(
         indoc::indoc! {"
-        <h2>Slide {}</h2>
+        <div class='slide'>
+            <h2>Slide {}</h2>
 
-        <video controls>
-          <source src='{}' type='video/mp4'>
-          Your browser does not support the video tag.
-        </video>
+            <a href='{}'>
+                <img src='{}' alt='Slide {}'/><br/>
+            </a>
+            <audio controls src='{}'/></audio>
+        </div>
         "},
-        slide.idx, filename
+        slide.idx, image_file, image_file, slide.idx, audio_file
     )
 }
 
-fn index(args: &Arguments, slides: &[Slide], timestamp: u64, init: bool) -> String {
+fn index(
+    args: &Arguments,
+    config: &Config,
+    slides: &[Slide],
+    timestamp: u64,
+    init: bool,
+) -> String {
     let out_dir = &args.out_dir;
     let core = slides
         .iter()
-        .map(|slide| core_html(out_dir, slide, timestamp))
+        .map(|slide| core_html(out_dir, slide, timestamp, config))
         .collect::<Vec<_>>()
         .join("\n");
     let waiting_text = if init {
@@ -65,8 +81,19 @@ fn index(args: &Arguments, slides: &[Slide], timestamp: u64, init: bool) -> Stri
                 body {{
                     text-align: center;
                 }}
-                video {{
+                img {{
                     max-width: 800px;
+                    max-height: 80vh;
+                    border: 1px solid black;
+                }}
+                audio {{
+                    width: 800px;
+                }}
+                .slide {{
+                    margin-bottom: 60px;
+                }}
+                .slide h2 {{
+                    margin-bottom: 10px;
                 }}
             </style>
         </head>
@@ -88,8 +115,8 @@ fn public_dir(args: &Arguments) -> PathBuf {
     public_path
 }
 
-fn build_index(args: &Arguments, slides: &[Slide], timestamp: u64, init: bool) {
-    let index = index(args, slides, timestamp, init);
+fn build_index(args: &Arguments, config: &Config, slides: &[Slide], timestamp: u64, init: bool) {
+    let index = index(args, config, slides, timestamp, init);
     let path = public_dir(args).join("index.html");
     tracing::info!("Writing index.html");
     std::fs::write(path, index).unwrap();
@@ -105,18 +132,24 @@ fn timestamp() -> u64 {
         .as_secs()
 }
 
-fn move_files_into_public(args: &Arguments, slides: &[Slide]) -> u64 {
+fn move_files_into_public(args: &Arguments, config: &Config, slides: &[Slide]) -> u64 {
     let public_path = public_dir(args);
     let out_dir = &args.out_dir;
 
     let timestamp = timestamp();
 
     for slide in slides {
-        let video_path = crate::path::video_path(out_dir, slide);
-        let filename = video_path.file_name().unwrap();
+        let image_path = crate::path::image_path(out_dir, slide);
+        let filename = image_path.file_name().unwrap();
         let filename = add_timestamp(filename, timestamp);
 
-        std::fs::copy(video_path, public_path.join(filename)).unwrap();
+        std::fs::copy(image_path, public_path.join(filename)).unwrap();
+
+        let audio_ext = config.audio_format.clone().unwrap();
+        let audio_path = crate::path::audio_path(out_dir, slide, &audio_ext);
+        let filename = audio_path.file_name().unwrap();
+        let filename = add_timestamp(filename, timestamp);
+        std::fs::copy(audio_path, public_path.join(filename)).unwrap();
     }
     timestamp
 }
@@ -130,7 +163,7 @@ fn remove_old_files(args: &Arguments, timestamp: u64) {
             continue;
         }
         if let Some(extension) = path.extension() {
-            if extension == "mp4" {
+            if extension != "html" {
                 let filename = path.file_name().unwrap().to_str().unwrap();
                 if !filename.contains(&format!("_{}", timestamp)) {
                     std::fs::remove_file(path).unwrap();
@@ -169,16 +202,16 @@ fn run_pre_typst(watch_args: &WatchArgs) -> Status {
     Status::Success
 }
 
-async fn watch_build(watch_args: &WatchArgs, args: &Arguments) {
+async fn watch_build(watch_args: &WatchArgs, config: &Config, args: &Arguments) {
     let release = false;
     let input = watch_args.input.clone();
     let audio_codec = None;
 
     let status = run_pre_typst(watch_args);
     if status == Status::Success {
-        let slides = build(input.clone(), args, release, audio_codec).await;
-        let timestamp = move_files_into_public(args, &slides);
-        build_index(args, &slides, timestamp, false);
+        let slides = build(input.clone(), config, args, release, audio_codec).await;
+        let timestamp = move_files_into_public(args, config, &slides);
+        build_index(args, config, &slides, timestamp, false);
         remove_old_files(args, timestamp);
     }
 }
@@ -203,7 +236,7 @@ fn spawn_server(watch_args: &WatchArgs, args: &Arguments) {
     });
 }
 
-pub async fn watch(watch_args: &WatchArgs, args: &Arguments) {
+pub async fn watch(watch_args: &WatchArgs, config: &Config, args: &Arguments) {
     let (tx, rx) = mpsc::channel::<Result<Event>>();
     let mut watcher = recommended_watcher(tx).unwrap();
     let mode = notify::RecursiveMode::NonRecursive;
@@ -228,14 +261,14 @@ pub async fn watch(watch_args: &WatchArgs, args: &Arguments) {
 
     let slides = [];
     let timestamp = timestamp();
-    build_index(args, &slides, timestamp, true);
+    build_index(args, config, &slides, timestamp, true);
     spawn_server(watch_args, args);
-    watch_build(watch_args, args).await;
+    watch_build(watch_args, config, args).await;
 
     for result in &rx {
         match result {
             Ok(_event) => {
-                watch_build(watch_args, args).await;
+                watch_build(watch_args, config, args).await;
                 // Drain the channel to avoid processing old events.
                 while rx.try_recv().is_ok() {}
             }