Cache video (#19)

Implements caching for videos which dramatically speeds up presentation
generation. The generation for the Google demo for example goes from 20
seconds to 2 seconds.

Unfortunately, `typst query` cannot extract the slides from the input
file. It can only get the speaker notes. Since the video cache key
requires the slide itself too, I therefore wrote some manual logic to
extract the slide content. That's didn't work because (as always)
parsing is hard. In this case, it also needs to handle slides such as

```typst
#slide[
    #set page(margin: 2em)
    #set text(size: 30pt)
    #align(left)[
      ```typ
      #import "@preview/polylux:0.4.0": *
      #set page(paper: "presentation-16-9")

      #slide[
        Hello

        #toolbox.pdfpc.speaker-note("
          This page contains Hello
        ")
      ]
      ```
    ]

    #toolbox.pdfpc.speaker-note("
      To create the presentation, we use Typst.
      Typst is a new typesetting system that is similar to LaTeX.

      Here for example is a simple Typst document with one slide.
      The slide contains the text Hello
      and a speaker note with the text This page contains Hello
    ")
]
```
without parsing the nested `#slide` as another slide. 

Instead, the tool now uses the slide images for the cache key. This
should work since

```sh
$ diff 1.png _out/image/1.png

$ diff 1.png _out/image/2.png
Binary files 1.png and _out/image/2.png differ
```

Also fixes #14.

Author: rikhuijzer

.github/workflows/release.yml

@@ -41,6 +41,11 @@ jobs:
         with:
           key: "release-${{ matrix.target }}"
 
+      - uses: actions/cache@v4
+        with:
+          path: ~/.cache/typst
+          key: typst
+
       - run: |
           if [[ ${{ matrix.os }} = "windows-latest" ]]; then
             EXT=".exe"

.github/workflows/test.yml

@@ -22,6 +22,11 @@ jobs:
         with:
           prefix-key: 'test'
 
+      - uses: actions/cache@v4
+        with:
+          path: ~/.cache/typst
+          key: typst
+
       - uses: FedericoCarboni/setup-ffmpeg@v3
 
       - uses: taiki-e/install-action@v2

Cargo.toml

@@ -17,6 +17,7 @@ tracing = "0.1"
 transformrs = "0.7"
 serde_json = "1.0.138"
 serde = { version = "1", features = ["derive"] }
+sha2 = "0.10.8"
 
 [dev-dependencies]
 assert_cmd = "2"

src/audio.rs

@@ -1,6 +1,6 @@
-use crate::image::NewSlide;
 use crate::path::audio_cache_key_path;
 use crate::path::audio_path;
+use crate::slide::Slide;
 use serde::Deserialize;
 use serde::Serialize;
 use std::fs::File;
@@ -11,16 +11,16 @@ use transformrs::Keys;
 use transformrs::Provider;
 
 #[derive(Debug, Serialize, Deserialize)]
-struct CacheKey {
+struct AudioCacheKey {
     text: String,
     config: TTSConfig,
 }
 
-fn write_cache_key(dir: &str, slide: &NewSlide, config: &TTSConfig) {
+fn write_cache_key(dir: &str, slide: &Slide, config: &TTSConfig) {
     let txt_path = audio_cache_key_path(dir, slide);
     let mut file = File::create(txt_path).unwrap();
-    let text = slide.note.clone();
-    let cache_key = CacheKey {
+    let text = slide.speaker_note.clone();
+    let cache_key = AudioCacheKey {
         text,
         config: config.clone(),
     };
@@ -29,28 +29,28 @@ fn write_cache_key(dir: &str, slide: &NewSlide, config: &TTSConfig) {
 }
 
 /// Whether the audio file for the given slide exists and is for the same slide.
-fn is_cached(dir: &str, slide: &NewSlide, config: &TTSConfig, audio_ext: &str) -> bool {
+fn is_cached(dir: &str, slide: &Slide, config: &TTSConfig, audio_ext: &str) -> bool {
     let txt_path = audio_cache_key_path(dir, slide);
     let audio_path = audio_path(dir, slide, audio_ext);
     if !txt_path.exists() || !audio_path.exists() {
         return false;
     }
-    let contents = std::fs::read_to_string(txt_path).unwrap();
-    let text = slide.note.clone();
-    let cache_key = CacheKey {
+    let stored_key = std::fs::read_to_string(txt_path).unwrap();
+    let text = slide.speaker_note.clone();
+    let cache_key = AudioCacheKey {
         text,
         config: config.clone(),
     };
-    let serialized = serde_json::to_string(&cache_key).unwrap();
-    contents == serialized
+    let current_info = serde_json::to_string(&cache_key).unwrap();
+    stored_key == current_info
 }
 
 #[allow(clippy::too_many_arguments)]
 async fn generate_audio_file(
     provider: &Provider,
     keys: &Keys,
     dir: &str,
-    slide: &NewSlide,
+    slide: &Slide,
     cache: bool,
     config: &TTSConfig,
     model: &Option<String>,
@@ -78,10 +78,11 @@ async fn generate_audio_file(
         }
         _ => get_key(keys, provider),
     };
-    let msg = &slide.note;
-    if cache && is_cached(dir, slide, config, audio_ext) {
+    let msg = &slide.speaker_note;
+    let is_cached = cache && is_cached(dir, slide, config, audio_ext);
+    if is_cached {
         tracing::info!(
-            "Skipping audio generation for slide {} due to cache",
+            "Slide {}: Skipping audio generation due to cache",
             slide.idx
         );
         return;
@@ -101,15 +102,15 @@ async fn generate_audio_file(
     }
     let mut file = File::create(path).unwrap();
     file.write_all(&bytes).unwrap();
-    if cache {
+    if cache && !is_cached {
         write_cache_key(dir, slide, config);
     }
 }
 
 pub async fn generate_audio_files(
     provider: &Provider,
     dir: &str,
-    slides: &Vec<NewSlide>,
+    slides: &Vec<Slide>,
     cache: bool,
     config: &TTSConfig,
     model: &Option<String>,
@@ -119,8 +120,8 @@ pub async fn generate_audio_files(
     // keys from environment variables).
     let keys = transformrs::load_keys("not_used.env");
     for slide in slides {
-        let idx = crate::path::idx(slide);
-        tracing::info!("Generating audio file for slide {idx}");
+        let idx = slide.idx;
+        tracing::info!("Slide {idx}: Generating audio file...");
         generate_audio_file(provider, &keys, dir, slide, cache, config, model, audio_ext).await;
     }
 }

src/image.rs

@@ -1,81 +1,7 @@
 use crate::path::PathStr;
-use serde::Deserialize;
-use serde::Serialize;
-use serde_json::Value;
 use std::path::Path;
 use std::path::PathBuf;
 
-#[derive(Clone, Debug, Serialize, Deserialize)]
-pub struct NewSlide {
-    pub idx: u64,
-    #[allow(dead_code)]
-    pub overlay: u64,
-    #[allow(dead_code)]
-    pub logical_slide: u64,
-    pub note: String,
-}
-
-impl NewSlide {
-    fn new(idx: &Value, overlay: &Value, logical_slide: &Value, note: &Value) -> Self {
-        let idx = idx.get("v").and_then(|v| v.as_u64()).unwrap();
-        let overlay = overlay.get("v").and_then(|v| v.as_u64()).unwrap();
-        let logical_slide = logical_slide.get("v").and_then(|v| v.as_u64()).unwrap();
-        let note = note.get("v").and_then(|v| v.as_str()).unwrap();
-        Self {
-            idx,
-            overlay,
-            logical_slide,
-            note: note.to_string(),
-        }
-    }
-}
-
-fn query_presenter_notes(input: &str) -> Value {
-    let output = std::process::Command::new("typst")
-        .arg("query")
-        .arg(input)
-        .arg("<pdfpc>")
-        .arg("--field=value")
-        .output()
-        .expect("Failed to run typst presenter-notes command");
-
-    let text = String::from_utf8_lossy(&output.stdout);
-    match serde_json::from_str::<Value>(&text) {
-        Ok(json) => json,
-        Err(e) => {
-            tracing::error!("Error parsing JSON: {}", e);
-            tracing::error!("Stderr: {}", String::from_utf8_lossy(&output.stderr));
-            std::process::exit(1);
-        }
-    }
-}
-
-pub fn presenter_notes(input: &str) -> Vec<NewSlide> {
-    let json = query_presenter_notes(input);
-
-    let values = json.as_array().expect("Expected JSON array");
-
-    let mut slides = Vec::new();
-
-    for i in 0..values.len() {
-        let note = &values[i];
-        if let Some(obj) = note.as_object() {
-            if let Some(t) = obj.get("t") {
-                if t == "NewSlide" {
-                    let idx = &values[i + 1];
-                    let overlay = &values[i + 2];
-                    let logical_slide = &values[i + 3];
-                    let note = &values[i + 4];
-                    let slide = NewSlide::new(idx, overlay, logical_slide, note);
-                    slides.push(slide);
-                }
-            }
-        }
-    }
-
-    slides
-}
-
 pub fn generate_images(input: &PathBuf, dir: &str) {
     let image_dir = Path::new(dir).join("image");
     if !image_dir.exists() {

src/main.rs

@@ -1,6 +1,7 @@
 mod audio;
 mod image;
 mod path;
+mod slide;
 mod video;
 
 use clap::Parser;
@@ -126,13 +127,38 @@ fn init_subscriber(level: tracing::Level) -> Result<(), SetGlobalDefaultError> {
     tracing::subscriber::set_global_default(subscriber)
 }
 
-/// Copy the input file to the output directory.
+fn include_includes(input_dir: &Path, content: &str) -> String {
+    let mut output = String::new();
+    for line in content.lines() {
+        if line.starts_with("#include") {
+            let include = line.split_whitespace().nth(1).unwrap().trim_matches('"');
+            let include_path = input_dir.join(include);
+            tracing::info!("Including file: {}", include_path.display());
+            let content = std::fs::read_to_string(include_path).unwrap();
+            for line in content.lines() {
+                output.push_str(line);
+                output.push('\n');
+            }
+        } else {
+            output.push_str(line);
+            output.push('\n');
+        }
+    }
+    output
+}
+
+/// Copy the Typst input file to the output directory.
 ///
-/// Typst requires the input to be present in the project directory.
-fn copy_input(input: &str, dir: &str) -> PathBuf {
-    let path = Path::new(dir).join("input.typ");
-    std::fs::copy(input, &path).unwrap();
-    path
+/// This is necessary because Typst requires the input to be present in the
+/// project directory.
+fn copy_input_with_includes(dir: &str, input: &str) -> PathBuf {
+    let output_path = Path::new(dir).join("input.typ");
+    let content = std::fs::read_to_string(input).unwrap();
+    let input_dir = Path::new(input).parent().unwrap();
+    let content = include_includes(input_dir, &content);
+    std::fs::write(&output_path, content).unwrap();
+
+    output_path
 }
 
 #[tokio::main]
@@ -149,7 +175,7 @@ async fn main() {
     if !path.exists() {
         std::fs::create_dir_all(path).unwrap();
     }
-    let input = copy_input(&args.input, dir);
+    let input = copy_input_with_includes(dir, &args.input);
 
     let provider = args.provider.map(|p| provider_from_str(&p));
     let provider = provider.unwrap_or(Provider::DeepInfra);
@@ -165,7 +191,10 @@ async fn main() {
         language_code: args.language_code.clone(),
     };
 
-    let slides = image::presenter_notes(&args.input);
+    let slides = slide::slides(input.to_str().unwrap());
+    if slides.is_empty() {
+        panic!("No slides found in input file: {}", args.input);
+    }
     image::generate_images(&input, dir);
     let audio_ext = config.output_format.clone().unwrap_or("mp3".to_string());
     audio::generate_audio_files(
@@ -180,7 +209,7 @@ async fn main() {
     .await;
     // Using mkv by default because it supports more audio formats.
     let output = "out.mkv";
-    video::generate_video(dir, &slides, output, &audio_ext);
+    video::generate_video(dir, &slides, args.cache, &config, output, &audio_ext);
     if args.release {
         video::generate_release_video(dir, output, "release.mp4", &args.audio_codec);
     }

src/path.rs

@@ -1,4 +1,4 @@
-use crate::image::NewSlide;
+use crate::slide::Slide;
 use std::path::Path;
 use std::path::PathBuf;
 
@@ -12,35 +12,36 @@ impl PathStr for PathBuf {
     }
 }
 
-pub fn idx(slide: &NewSlide) -> u64 {
-    // Typst png files start at one, while slide.idx at zero.
-    slide.idx + 1
-}
-
-pub fn audio_path(dir: &str, slide: &NewSlide, audio_ext: &str) -> PathBuf {
-    let idx = idx(slide);
+pub fn audio_path(dir: &str, slide: &Slide, audio_ext: &str) -> PathBuf {
+    let idx = slide.idx;
     let filename = format!("{idx}.{audio_ext}");
     Path::new(dir).join("audio").join(filename)
 }
 
-pub fn image_path(dir: &str, slide: &NewSlide) -> PathBuf {
-    let idx = idx(slide);
+pub fn image_path(dir: &str, slide: &Slide) -> PathBuf {
+    let idx = slide.idx;
     let filename = format!("{idx}.png");
     Path::new(dir).join("image").join(filename)
 }
 
-pub fn audio_cache_key_path(dir: &str, slide: &NewSlide) -> PathBuf {
-    let idx = idx(slide);
+pub fn audio_cache_key_path(dir: &str, slide: &Slide) -> PathBuf {
+    let idx = slide.idx;
     let filename = format!("{idx}.audio.cache_key");
     Path::new(dir).join("audio").join(filename)
 }
 
+pub fn video_cache_key_path(dir: &str, slide: &Slide) -> PathBuf {
+    let idx = slide.idx;
+    let filename = format!("{idx}.video.cache_key");
+    Path::new(dir).join("video").join(filename)
+}
+
 pub fn video_dir_name() -> &'static str {
     "video"
 }
 
-pub fn video_path(dir: &str, slide: &NewSlide) -> PathBuf {
-    let idx = idx(slide);
+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");
     Path::new(dir).join(video_dir_name()).join(filename)