Only generate subtitle files when needed

Author: WyattBlue

auto_editor/edit.py

@@ -212,15 +212,6 @@ def edit_media(
     ensure = Ensure(ffmpeg, samplerate, temp, log)
 
     if tl is None:
-        # Extract subtitles in their native format.
-        if src is not None and len(src.subtitles) > 0 and not args.sn:
-            cmd = ["-i", f"{src.path}", "-hide_banner"]
-            for s, sub in enumerate(src.subtitles):
-                cmd.extend(["-map", f"0:s:{s}"])
-            for s, sub in enumerate(src.subtitles):
-                cmd.extend([os.path.join(temp, f"{s}s.{sub.ext}")])
-            ffmpeg.run(cmd)
-
         tl = make_timeline(sources, ensure, args, samplerate, bar, temp, log)
 
     if export["export"] == "timeline":
@@ -282,7 +273,7 @@ def make_media(tl: v3, output: str) -> None:
         apply_later = False
 
         if ctr.allow_subtitle and not args.sn:
-            sub_output = make_new_subtitles(tl, ffmpeg, temp, log)
+            sub_output = make_new_subtitles(tl, ffmpeg, ensure, temp, log)
 
         if ctr.allow_audio:
             audio_output = make_new_audio(tl, ensure, args, ffmpeg, bar, temp, log)

auto_editor/output.py

@@ -16,23 +16,23 @@ class Ensure:
     _sr: int
     temp: str
     log: Log
-    labels: list[tuple[FileInfo, int]] = field(default_factory=list)
-    sub_labels: list[tuple[FileInfo, int]] = field(default_factory=list)
+    _audios: list[tuple[FileInfo, int]] = field(default_factory=list)
+    _subtitles: list[tuple[FileInfo, int]] = field(default_factory=list)
 
     def audio(self, src: FileInfo, stream: int) -> str:
         try:
-            label = self.labels.index((src, stream))
+            label = self._audios.index((src, stream))
             first_time = False
         except ValueError:
-            self.labels.append((src, stream))
-            label = len(self.labels) - 1
+            self._audios.append((src, stream))
+            label = len(self._audios) - 1
             first_time = True
 
         out_path = os.path.join(self.temp, f"{label:x}.wav")
 
         if first_time:
+            self.log.debug(f"Making external audio: {out_path}")
             self.log.conwrite("Extracting audio")
-            self.log.debug(f"Making external audio for stream: {stream}")
 
             cmd = ["-i", f"{src.path}", "-map", f"0:a:{stream}"]
             cmd += ["-ac", "2", "-ar", f"{self._sr}", "-rf64", "always", out_path]
@@ -42,18 +42,18 @@ def audio(self, src: FileInfo, stream: int) -> str:
 
     def subtitle(self, src: FileInfo, stream: int) -> str:
         try:
-            label = self.sub_labels.index((src, stream))
+            self._subtitles.index((src, stream))
             first_time = False
         except ValueError:
-            self.sub_labels.append((src, stream))
-            label = len(self.sub_labels) - 1
+            self._subtitles.append((src, stream))
             first_time = True
 
-        out_path = os.path.join(self.temp, f"{label:x}.vtt")
+        sub = src.subtitles[stream]
+        out_path = os.path.join(self.temp, f"{stream}s.{sub.ext}")
 
         if first_time:
-            self.log.conwrite("Extracting subtitle")
             self.log.debug(f"Making external subtitle: {out_path}")
+            self.log.conwrite("Extracting subtitle")
             self._ffmpeg.run(["-i", f"{src.path}", "-map", f"0:s:{stream}", out_path])
 
         return out_path

auto_editor/render/subtitle.py

@@ -11,6 +11,7 @@
     from fractions import Fraction
 
     from auto_editor.ffwrapper import FFmpeg
+    from auto_editor.output import Ensure
     from auto_editor.timeline import v3
     from auto_editor.utils.chunks import Chunks
     from auto_editor.utils.log import Log
@@ -122,22 +123,24 @@ def write(self, file_path: str) -> None:
             file.write(self.footer)
 
 
-def make_new_subtitles(tl: v3, ffmpeg: FFmpeg, temp: str, log: Log) -> list[str]:
+def make_new_subtitles(
+    tl: v3, ffmpeg: FFmpeg, ensure: Ensure, temp: str, log: Log
+) -> list[str]:
     if tl.v1 is None:
         return []
 
     new_paths = []
 
     for s, sub in enumerate(tl.v1.source.subtitles):
-        file_path = os.path.join(temp, f"{s}s.{sub.ext}")
         new_path = os.path.join(temp, f"new{s}s.{sub.ext}")
-
         parser = SubtitleParser(tl.tb)
 
         if sub.codec in parser.supported_codecs:
+            file_path = ensure.subtitle(tl.v1.source, s)
             with open(file_path, encoding="utf-8") as file:
                 parser.parse(file.read(), sub.codec)
         else:
+            file_path = os.path.join(temp, f"{s}s.{sub.ext}")
             convert_path = os.path.join(temp, f"{s}s_convert.vtt")
             ffmpeg.run(["-i", file_path, convert_path])
             with open(convert_path, encoding="utf-8") as file: