manim 0.17.0__py3-none-any.whl → 0.19.1__py3-none-any.whl

manim/scene/scene_file_writer.py

@@ -5,12 +5,15 @@ from __future__ import annotations
 __all__ = ["SceneFileWriter"]
 
 import json
-import os
 import shutil
-import subprocess
+from fractions import Fraction
 from pathlib import Path
+from queue import Queue
+from tempfile import NamedTemporaryFile, _TemporaryFileWrapper
+from threading import Thread
 from typing import TYPE_CHECKING, Any
 
+import av
 import numpy as np
 import srt
 from PIL import Image
@@ -24,11 +27,9 @@ from ..constants import RendererType
 from ..utils.file_ops import (
     add_extension_if_not_present,
     add_version_before_extension,
-    ensure_executable,
     guarantee_existence,
     is_gif_format,
     is_png_format,
-    is_webm_format,
     modify_atime,
     write_to_movie,
 )
@@ -36,12 +37,50 @@ from ..utils.sounds import get_full_sound_file_path
 from .section import DefaultSectionType, Section
 
 if TYPE_CHECKING:
+    from av.container.output import OutputContainer
+    from av.stream import Stream
+
+    from manim.renderer.cairo_renderer import CairoRenderer
     from manim.renderer.opengl_renderer import OpenGLRenderer
+    from manim.typing import PixelArray, StrPath
+
+
+def to_av_frame_rate(fps: float) -> Fraction:
+    epsilon1 = 1e-4
+    epsilon2 = 0.02
+
+    if isinstance(fps, int):
+        (num, denom) = (fps, 1)
+    elif abs(fps - round(fps)) < epsilon1:
+        (num, denom) = (round(fps), 1)
+    else:
+        denom = 1001
+        num = round(fps * denom / 1000) * 1000
+        if abs(fps - num / denom) >= epsilon2:
+            raise ValueError("invalid frame rate")
+
+    return Fraction(num, denom)
+
+
+def convert_audio(
+    input_path: Path, output_path: Path | _TemporaryFileWrapper[bytes], codec_name: str
+) -> None:
+    with (
+        av.open(input_path) as input_audio,
+        av.open(output_path, "w") as output_audio,
+    ):
+        input_audio_stream = input_audio.streams.audio[0]
+        output_audio_stream = output_audio.add_stream(codec_name)
+        for frame in input_audio.decode(input_audio_stream):
+            for packet in output_audio_stream.encode(frame):
+                output_audio.mux(packet)
+
+        for packet in output_audio_stream.encode():
+            output_audio.mux(packet)
 
 
 class SceneFileWriter:
-    """
-    SceneFileWriter is the object that actually writes the animations
+    """SceneFileWriter is the object that actually writes the animations
     played, into video files, using FFMPEG.
     This is mostly for Manim's internal use. You will rarely, if ever,
     have to use the methods for this class, unless tinkering with the very
@@ -70,29 +109,26 @@ class SceneFileWriter:
 
     force_output_as_scene_name = False
 
-    def __init__(self, renderer, scene_name, **kwargs):
+    def __init__(
+        self,
+        renderer: CairoRenderer | OpenGLRenderer,
+        scene_name: str,
+        **kwargs: Any,
+    ) -> None:
         self.renderer = renderer
         self.init_output_directories(scene_name)
         self.init_audio()
         self.frame_count = 0
-        self.partial_movie_files: list[str] = []
+        self.partial_movie_files: list[str | None] = []
         self.subcaptions: list[srt.Subtitle] = []
         self.sections: list[Section] = []
         # first section gets automatically created for convenience
         # if you need the first section to be skipped, add a first section by hand, it will replace this one
         self.next_section(
-            name="autocreated", type=DefaultSectionType.NORMAL, skip_animations=False
+            name="autocreated", type_=DefaultSectionType.NORMAL, skip_animations=False
         )
-        # fail fast if ffmpeg is not found
-        if not ensure_executable(Path(config.ffmpeg_executable)):
-            raise RuntimeError(
-                "Manim could not find ffmpeg, which is required for generating video output.\n"
-                "For installing ffmpeg please consult https://docs.manim.community/en/stable/installation.html\n"
-                "Make sure to either add ffmpeg to the PATH environment variable\n"
-                "or set path to the ffmpeg executable under the ffmpeg header in Manim's configuration."
-            )
 
-    def init_output_directories(self, scene_name):
+    def init_output_directories(self, scene_name: str) -> None:
         """Initialise output directories.
 
         Notes
@@ -105,10 +141,7 @@ class SceneFileWriter:
         if config["dry_run"]:  # in dry-run mode there is no output
             return
 
-        if config["input_file"]:
-            module_name = config.get_dir("input_file").stem
-        else:
-            module_name = ""
+        module_name = config.get_dir("input_file").stem if config["input_file"] else ""
 
         if SceneFileWriter.force_output_as_scene_name:
             self.output_name = Path(scene_name)
@@ -137,7 +170,7 @@ class SceneFileWriter:
                 self.output_name, config["movie_file_extension"]
             )
 
-            # TODO: /dev/null would be good in case sections_output_dir is used without bein set (doesn't work on Windows), everyone likes defensive programming, right?
+            # TODO: /dev/null would be good in case sections_output_dir is used without being set (doesn't work on Windows), everyone likes defensive programming, right?
             self.sections_output_dir = Path("")
             if config.save_sections:
                 self.sections_output_dir = guarantee_existence(
@@ -177,7 +210,7 @@ class SceneFileWriter:
         if len(self.sections) and self.sections[-1].is_empty():
             self.sections.pop()
 
-    def next_section(self, name: str, type: str, skip_animations: bool) -> None:
+    def next_section(self, name: str, type_: str, skip_animations: bool) -> None:
         """Create segmentation cut here."""
         self.finish_last_section()
 
@@ -191,20 +224,23 @@ class SceneFileWriter:
             and not skip_animations
         ):
             # relative to index file
-            section_video = f"{self.output_name}_{len(self.sections):04}{config.movie_file_extension}"
+            section_video = f"{self.output_name}_{len(self.sections):04}_{name}{config.movie_file_extension}"
 
         self.sections.append(
             Section(
-                type,
+                type_,
                 section_video,
                 name,
                 skip_animations,
             ),
         )
 
-    def add_partial_movie_file(self, hash_animation: str):
-        """Adds a new partial movie file path to `scene.partial_movie_files` and current section from a hash.
-        This method will compute the path from the hash. In addition to that it adds the new animation to the current section.
+    def add_partial_movie_file(self, hash_animation: str | None) -> None:
+        """Adds a new partial movie file path to ``scene.partial_movie_files``
+        and current section from a hash.
+
+        This method will compute the path from the hash. In addition to that it
+        adds the new animation to the current section.
 
         Parameters
         ----------
@@ -227,7 +263,7 @@ class SceneFileWriter:
             self.partial_movie_files.append(new_partial_movie_file)
             self.sections[-1].partial_movie_files.append(new_partial_movie_file)
 
-    def get_resolution_directory(self):
+    def get_resolution_directory(self) -> str:
         """Get the name of the resolution directory directly containing
         the video file.
 
@@ -243,9 +279,11 @@ class SceneFileWriter:
                 |--Tex
                 |--texts
                 |--videos
-                |--<name_of_file_containing_scene>
-                    |--<height_in_pixels_of_video>p<frame_rate>
-                        |--<scene_name>.mp4
+                    |--<name_of_file_containing_scene>
+                        |--<height_in_pixels_of_video>p<frame_rate>
+                            |--partial_movie_files
+                            |--<scene_name>.mp4
+                            |--<scene_name>.srt
 
         Returns
         -------
@@ -257,16 +295,12 @@ class SceneFileWriter:
         return f"{pixel_height}p{frame_rate}"
 
     # Sound
-    def init_audio(self):
-        """
-        Preps the writer for adding audio to the movie.
-        """
+    def init_audio(self) -> None:
+        """Preps the writer for adding audio to the movie."""
         self.includes_sound = False
 
-    def create_audio_segment(self):
-        """
-        Creates an empty, silent, Audio Segment.
-        """
+    def create_audio_segment(self) -> None:
+        """Creates an empty, silent, Audio Segment."""
         self.audio_segment = AudioSegment.silent()
 
     def add_audio_segment(
@@ -274,10 +308,9 @@ class SceneFileWriter:
         new_segment: AudioSegment,
         time: float | None = None,
         gain_to_background: float | None = None,
-    ):
-        """
-        This method adds an audio segment from an
-        AudioSegment type object and suitable parameters.
+    ) -> None:
+        """This method adds an audio segment from an AudioSegment type object
+        and suitable parameters.
 
         Parameters
         ----------
@@ -285,8 +318,7 @@ class SceneFileWriter:
             The audio segment to add
 
         time
-            the timestamp at which the
-            sound should be added.
+            the timestamp at which the sound should be added.
 
         gain_to_background
             The gain of the segment from the background.
@@ -316,13 +348,12 @@ class SceneFileWriter:
 
     def add_sound(
         self,
-        sound_file: str,
+        sound_file: StrPath,
         time: float | None = None,
         gain: float | None = None,
-        **kwargs,
-    ):
-        """
-        This method adds an audio segment from a sound file.
+        **kwargs: Any,
+    ) -> None:
+        """This method adds an audio segment from a sound file.
 
         Parameters
         ----------
@@ -341,15 +372,28 @@ class SceneFileWriter:
 
         """
         file_path = get_full_sound_file_path(sound_file)
-        new_segment = AudioSegment.from_file(file_path)
+        # we assume files with .wav / .raw suffix are actually
+        # .wav and .raw files, respectively.
+        if file_path.suffix not in (".wav", ".raw"):
+            # we need to pass delete=False to work on Windows
+            # TODO: figure out a way to cache the wav file generated (benchmark needed)
+            with NamedTemporaryFile(suffix=".wav", delete=False) as wav_file_path:
+                convert_audio(file_path, wav_file_path, "pcm_s16le")
+                new_segment = AudioSegment.from_file(wav_file_path.name)
+                logger.info(f"Automatically converted {file_path} to .wav")
+            Path(wav_file_path.name).unlink()
+        else:
+            new_segment = AudioSegment.from_file(file_path)
+
         if gain:
             new_segment = new_segment.apply_gain(gain)
         self.add_audio_segment(new_segment, time, **kwargs)
 
     # Writers
-    def begin_animation(self, allow_write: bool = False, file_path=None):
-        """
-        Used internally by manim to stream the animation to FFMPEG for
+    def begin_animation(
+        self, allow_write: bool = False, file_path: StrPath | None = None
+    ) -> None:
+        """Used internally by manim to stream the animation to FFMPEG for
         displaying or writing to a file.
 
         Parameters
@@ -358,12 +402,10 @@ class SceneFileWriter:
             Whether or not to write to a video file.
         """
         if write_to_movie() and allow_write:
-            self.open_movie_pipe(file_path=file_path)
+            self.open_partial_movie_stream(file_path=file_path)
 
-    def end_animation(self, allow_write: bool = False):
-        """
-        Internally used by Manim to stop streaming to
-        FFMPEG gracefully.
+    def end_animation(self, allow_write: bool = False) -> None:
+        """Internally used by Manim to stop streaming to FFMPEG gracefully.
 
         Parameters
         ----------
@@ -371,63 +413,86 @@ class SceneFileWriter:
             Whether or not to write to a video file.
         """
         if write_to_movie() and allow_write:
-            self.close_movie_pipe()
+            self.close_partial_movie_stream()
 
-    def write_frame(self, frame_or_renderer: np.ndarray | OpenGLRenderer):
+    def listen_and_write(self) -> None:
+        """For internal use only: blocks until new frame is available on the queue."""
+        while True:
+            num_frames, frame_data = self.queue.get()
+            if frame_data is None:
+                break
+
+            self.encode_and_write_frame(frame_data, num_frames)
+
+    def encode_and_write_frame(self, frame: PixelArray, num_frames: int) -> None:
+        """For internal use only: takes a given frame in ``np.ndarray`` format and
+        writes it to the stream
         """
-        Used internally by Manim to write a frame to
-        the FFMPEG input buffer.
+        for _ in range(num_frames):
+            # Notes: precomputing reusing packets does not work!
+            # I.e., you cannot do `packets = encode(...)`
+            # and reuse it, as it seems that `mux(...)`
+            # consumes the packet.
+            # The same issue applies for `av_frame`,
+            # reusing it renders weird-looking frames.
+            av_frame = av.VideoFrame.from_ndarray(frame, format="rgba")
+            for packet in self.video_stream.encode(av_frame):
+                self.video_container.mux(packet)
+
+    def write_frame(
+        self, frame_or_renderer: PixelArray | OpenGLRenderer, num_frames: int = 1
+    ) -> None:
+        """Used internally by Manim to write a frame to the FFMPEG input buffer.
 
         Parameters
         ----------
         frame_or_renderer
             Pixel array of the frame.
+        num_frames
+            The number of times to write frame.
         """
-        if config.renderer == RendererType.OPENGL:
-            self.write_opengl_frame(frame_or_renderer)
-        elif config.renderer == RendererType.CAIRO:
-            frame = frame_or_renderer
-            if write_to_movie():
-                self.writing_process.stdin.write(frame.tobytes())
-            if is_png_format() and not config["dry_run"]:
-                self.output_image_from_array(frame)
-
-    def write_opengl_frame(self, renderer: OpenGLRenderer):
         if write_to_movie():
-            self.writing_process.stdin.write(
-                renderer.get_raw_frame_buffer_object_data(),
-            )
-        elif is_png_format() and not config["dry_run"]:
+            if isinstance(frame_or_renderer, np.ndarray):
+                frame = frame_or_renderer
+            else:
+                frame = (
+                    frame_or_renderer.get_frame()
+                    if config.renderer == RendererType.OPENGL
+                    else frame_or_renderer
+                )
+
+            msg = (num_frames, frame)
+            self.queue.put(msg)
+
+        if is_png_format() and not config["dry_run"]:
+            if isinstance(frame_or_renderer, np.ndarray):
+                image = Image.fromarray(frame_or_renderer)
+            else:
+                image = (
+                    frame_or_renderer.get_image()
+                    if config.renderer == RendererType.OPENGL
+                    else Image.fromarray(frame_or_renderer)
+                )
             target_dir = self.image_file_path.parent / self.image_file_path.stem
             extension = self.image_file_path.suffix
             self.output_image(
-                renderer.get_image(),
+                image,
                 target_dir,
                 extension,
                 config["zero_pad"],
             )
 
-    def output_image_from_array(self, frame_data):
-        target_dir = self.image_file_path.parent / self.image_file_path.stem
-        extension = self.image_file_path.suffix
-        self.output_image(
-            Image.fromarray(frame_data),
-            target_dir,
-            extension,
-            config["zero_pad"],
-        )
-
-    def output_image(self, image: Image.Image, target_dir, ext, zero_pad: bool):
+    def output_image(
+        self, image: Image.Image, target_dir: StrPath, ext: str, zero_pad: int
+    ) -> None:
         if zero_pad:
             image.save(f"{target_dir}{str(self.frame_count).zfill(zero_pad)}{ext}")
         else:
             image.save(f"{target_dir}{self.frame_count}{ext}")
         self.frame_count += 1
 
-    def save_final_image(self, image: np.ndarray):
-        """
-        The name is a misnomer. This method saves the image
-        passed to it as an in the default image directory.
+    def save_image(self, image: Image.Image) -> None:
+        """This method saves the image passed to it in the default image directory.
 
         Parameters
         ----------
@@ -442,18 +507,12 @@ class SceneFileWriter:
         image.save(self.image_file_path)
         self.print_file_ready_message(self.image_file_path)
 
-    def finish(self):
-        """
-        Finishes writing to the FFMPEG buffer or writing images
-        to output directory.
-        Combines the partial movie files into the
-        whole scene.
-        If save_last_frame is True, saves the last
-        frame in the default image directory.
+    def finish(self) -> None:
+        """Finishes writing to the FFMPEG buffer or writing images to output directory.
+        Combines the partial movie files into the whole scene.
+        If save_last_frame is True, saves the last frame in the default image directory.
         """
         if write_to_movie():
-            if hasattr(self, "writing_process"):
-                self.writing_process.terminate()
             self.combine_to_movie()
             if config.save_sections:
                 self.combine_to_section_videos()
@@ -467,69 +526,73 @@ class SceneFileWriter:
         if self.subcaptions:
             self.write_subcaption_file()
 
-    def open_movie_pipe(self, file_path=None):
-        """
-        Used internally by Manim to initialise
-        FFMPEG and begin writing to FFMPEG's input
-        buffer.
+    def open_partial_movie_stream(self, file_path: StrPath | None = None) -> None:
+        """Open a container holding a video stream.
+
+        This is used internally by Manim initialize the container holding
+        the video stream of a partial movie file.
         """
         if file_path is None:
             file_path = self.partial_movie_files[self.renderer.num_plays]
         self.partial_movie_file_path = file_path
 
-        fps = config["frame_rate"]
-        if fps == int(fps):  # fps is integer
-            fps = int(fps)
-        if config.renderer == RendererType.OPENGL:
-            width, height = self.renderer.get_pixel_shape()
-        else:
-            height = config["pixel_height"]
-            width = config["pixel_width"]
-
-        command = [
-            config.ffmpeg_executable,
-            "-y",  # overwrite output file if it exists
-            "-f",
-            "rawvideo",
-            "-s",
-            "%dx%d" % (width, height),  # size of one frame
-            "-pix_fmt",
-            "rgba",
-            "-r",
-            str(fps),  # frames per second
-            "-i",
-            "-",  # The input comes from a pipe
-            "-an",  # Tells FFMPEG not to expect any audio
-            "-loglevel",
-            config["ffmpeg_loglevel"].lower(),
-            "-metadata",
-            f"comment=Rendered with Manim Community v{__version__}",
-        ]
-        if config.renderer == RendererType.OPENGL:
-            command += ["-vf", "vflip"]
-        if is_webm_format():
-            command += ["-vcodec", "libvpx-vp9", "-auto-alt-ref", "0"]
-        # .mov format
-        elif config["transparent"]:
-            command += ["-vcodec", "qtrle"]
-        else:
-            command += ["-vcodec", "libx264", "-pix_fmt", "yuv420p"]
-        command += [file_path]
-        self.writing_process = subprocess.Popen(command, stdin=subprocess.PIPE)
+        fps = to_av_frame_rate(config.frame_rate)
+
+        partial_movie_file_codec = "libx264"
+        partial_movie_file_pix_fmt = "yuv420p"
+        av_options = {
+            "an": "1",  # ffmpeg: -an, no audio
+            "crf": "23",  # ffmpeg: -crf, constant rate factor (improved bitrate)
+        }
+
+        if config.movie_file_extension == ".webm":
+            partial_movie_file_codec = "libvpx-vp9"
+            av_options["-auto-alt-ref"] = "1"
+            if config.transparent:
+                partial_movie_file_pix_fmt = "yuva420p"
+
+        elif config.transparent:
+            partial_movie_file_codec = "qtrle"
+            partial_movie_file_pix_fmt = "argb"
+
+        with av.open(file_path, mode="w") as video_container:
+            stream = video_container.add_stream(
+                partial_movie_file_codec,
+                rate=fps,
+                options=av_options,
+            )
+            stream.pix_fmt = partial_movie_file_pix_fmt
+            stream.width = config.pixel_width
+            stream.height = config.pixel_height
 
-    def close_movie_pipe(self):
-        """
-        Used internally by Manim to gracefully stop writing to FFMPEG's input buffer
+            self.video_container: OutputContainer = video_container
+            self.video_stream: Stream = stream
+
+            self.queue: Queue[tuple[int, PixelArray | None]] = Queue()
+            self.writer_thread = Thread(target=self.listen_and_write, args=())
+            self.writer_thread.start()
+
+    def close_partial_movie_stream(self) -> None:
+        """Close the currently opened video container.
+
+        Used internally by Manim to first flush the remaining packages
+        in the video stream holding a partial file, and then close
+        the corresponding container.
         """
-        self.writing_process.stdin.close()
-        self.writing_process.wait()
+        self.queue.put((-1, None))
+        self.writer_thread.join()
+
+        for packet in self.video_stream.encode():
+            self.video_container.mux(packet)
+
+        self.video_container.close()
 
         logger.info(
             f"Animation {self.renderer.num_plays} : Partial movie file written in %(path)s",
             {"path": f"'{self.partial_movie_file_path}'"},
         )
 
-    def is_already_cached(self, hash_invocation: str):
+    def is_already_cached(self, hash_invocation: str) -> bool:
         """Will check if a file named with `hash_invocation` exists.
 
         Parameters
@@ -554,9 +617,9 @@ class SceneFileWriter:
         self,
         input_files: list[str],
         output_file: Path,
-        create_gif=False,
-        includes_sound=False,
-    ):
+        create_gif: bool = False,
+        includes_sound: bool = False,
+    ) -> None:
         file_list = self.partial_movie_directory / "partial_movie_file_list.txt"
         logger.debug(
             f"Partial movie files to combine ({len(input_files)} files): %(p)s",
@@ -567,39 +630,94 @@ class SceneFileWriter:
             for pf_path in input_files:
                 pf_path = Path(pf_path).as_posix()
                 fp.write(f"file 'file:{pf_path}'\n")
-        commands = [
-            config.ffmpeg_executable,
-            "-y",  # overwrite output file if it exists
-            "-f",
-            "concat",
-            "-safe",
-            "0",
-            "-i",
-            str(file_list),
-            "-loglevel",
-            config.ffmpeg_loglevel.lower(),
-            "-metadata",
-            f"comment=Rendered with Manim Community v{__version__}",
-            "-nostdin",
-        ]
 
+        av_options = {
+            "safe": "0",  # needed to read files
+        }
+
+        if not includes_sound:
+            av_options["an"] = "1"
+
+        partial_movies_input = av.open(
+            str(file_list), options=av_options, format="concat"
+        )
+        partial_movies_stream = partial_movies_input.streams.video[0]
+        output_container = av.open(str(output_file), mode="w")
+        output_container.metadata["comment"] = (
+            f"Rendered with Manim Community v{__version__}"
+        )
+        output_stream = output_container.add_stream(
+            codec_name="gif" if create_gif else None,
+            template=partial_movies_stream if not create_gif else None,
+        )
+        if config.transparent and config.movie_file_extension == ".webm":
+            output_stream.pix_fmt = "yuva420p"
         if create_gif:
-            commands += [
-                "-vf",
-                f"fps={np.clip(config['frame_rate'], 1, 50)},split[s0][s1];[s0]palettegen=stats_mode=diff[p];[s1][p]paletteuse=dither=bayer:bayer_scale=5:diff_mode=rectangle",
-            ]
+            """The following solution was largely inspired from this comment
+            https://github.com/imageio/imageio/issues/995#issuecomment-1580533018,
+            and the following code
+            https://github.com/imageio/imageio/blob/65d79140018bb7c64c0692ea72cb4093e8d632a0/imageio/plugins/pyav.py#L927-L996.
+            """
+            output_stream.pix_fmt = "rgb8"
+            if config.transparent:
+                output_stream.pix_fmt = "pal8"
+            output_stream.width = config.pixel_width
+            output_stream.height = config.pixel_height
+            output_stream.rate = to_av_frame_rate(config.frame_rate)
+            graph = av.filter.Graph()
+            input_buffer = graph.add_buffer(template=partial_movies_stream)
+            split = graph.add("split")
+            palettegen = graph.add("palettegen", "stats_mode=diff")
+            paletteuse = graph.add(
+                "paletteuse", "dither=bayer:bayer_scale=5:diff_mode=rectangle"
+            )
+            output_sink = graph.add("buffersink")
+
+            input_buffer.link_to(split)
+            split.link_to(palettegen, 0, 0)  # 1st input of split -> input of palettegen
+            split.link_to(paletteuse, 1, 0)  # 2nd output of split -> 1st input
+            palettegen.link_to(paletteuse, 0, 1)  # output of palettegen -> 2nd input
+            paletteuse.link_to(output_sink)
+
+            graph.configure()
+
+            for frame in partial_movies_input.decode(video=0):
+                graph.push(frame)
+
+            graph.push(None)  # EOF: https://github.com/PyAV-Org/PyAV/issues/886.
+
+            frames_written = 0
+            while True:
+                try:
+                    frame = graph.pull()
+                    if output_stream.codec_context.time_base is not None:
+                        frame.time_base = output_stream.codec_context.time_base
+                    frame.pts = frames_written
+                    frames_written += 1
+                    output_container.mux(output_stream.encode(frame))
+                except av.error.EOFError:
+                    break
+
+            for packet in output_stream.encode():
+                output_container.mux(packet)
+
         else:
-            commands += ["-c", "copy"]
+            for packet in partial_movies_input.demux(partial_movies_stream):
+                # We need to skip the "flushing" packets that `demux` generates.
+                if packet.dts is None:
+                    continue
 
-        if not includes_sound:
-            commands += ["-an"]
+                packet.dts = None  # This seems to be needed, as dts from consecutive
+                # files may not be monotically increasing, so we let libav compute it.
 
-        commands += [str(output_file)]
+                # We need to assign the packet to the new stream.
+                packet.stream = output_stream
+                output_container.mux(packet)
 
-        combine_process = subprocess.Popen(commands)
-        combine_process.wait()
+        partial_movies_input.close()
+        output_container.close()
 
-    def combine_to_movie(self):
+    def combine_to_movie(self) -> None:
         """Used internally by Manim to combine the separate
         partial movie files that make up a Scene into a single
         video file for that Scene.
@@ -614,6 +732,11 @@ class SceneFileWriter:
         movie_file_path = self.movie_file_path
         if is_gif_format():
             movie_file_path = self.gif_file_path
+
+        if len(partial_movie_files) == 0:  # Prevent calling concat on empty list
+            logger.info("No animations are contained in this scene.")
+            return
+
         logger.info("Combining to Movie file.")
         self.combine_files(
             partial_movie_files,
@@ -623,44 +746,72 @@ class SceneFileWriter:
         )
 
         # handle sound
-        if self.includes_sound:
+        if self.includes_sound and config.format != "gif":
             sound_file_path = movie_file_path.with_suffix(".wav")
             # Makes sure sound file length will match video file
             self.add_audio_segment(AudioSegment.silent(0))
             self.audio_segment.export(
                 sound_file_path,
+                format="wav",
                 bitrate="312k",
             )
+            # Audio added to a VP9 encoded (webm) video file needs
+            # to be encoded as vorbis or opus. Directly exporting
+            # self.audio_segment with such a codec works in principle,
+            # but tries to call ffmpeg via its CLI -- which we want
+            # to avoid. This is why we need to do the conversion
+            # manually.
+            if config.movie_file_extension == ".webm":
+                ogg_sound_file_path = sound_file_path.with_suffix(".ogg")
+                convert_audio(sound_file_path, ogg_sound_file_path, "libvorbis")
+                sound_file_path = ogg_sound_file_path
+            elif config.movie_file_extension == ".mp4":
+                # Similarly, pyav may reject wav audio in an .mp4 file;
+                # convert to AAC.
+                aac_sound_file_path = sound_file_path.with_suffix(".aac")
+                convert_audio(sound_file_path, aac_sound_file_path, "aac")
+                sound_file_path = aac_sound_file_path
+
             temp_file_path = movie_file_path.with_name(
                 f"{movie_file_path.stem}_temp{movie_file_path.suffix}"
             )
-            commands = [
-                config.ffmpeg_executable,
-                "-i",
-                str(movie_file_path),
-                "-i",
-                str(sound_file_path),
-                "-y",  # overwrite output file if it exists
-                "-c:v",
-                "copy",
-                "-c:a",
-                "aac",
-                "-b:a",
-                "320k",
-                # select video stream from first file
-                "-map",
-                "0:v:0",
-                # select audio stream from second file
-                "-map",
-                "1:a:0",
-                "-loglevel",
-                config.ffmpeg_loglevel.lower(),
-                "-metadata",
-                f"comment=Rendered with Manim Community v{__version__}",
-                # "-shortest",
-                str(temp_file_path),
-            ]
-            subprocess.call(commands)
+            av_options = {
+                "shortest": "1",
+                "metadata": f"comment=Rendered with Manim Community v{__version__}",
+            }
+
+            with (
+                av.open(movie_file_path) as video_input,
+                av.open(sound_file_path) as audio_input,
+            ):
+                video_stream = video_input.streams.video[0]
+                audio_stream = audio_input.streams.audio[0]
+                output_container = av.open(
+                    str(temp_file_path), mode="w", options=av_options
+                )
+                output_video_stream = output_container.add_stream(template=video_stream)
+                output_audio_stream = output_container.add_stream(template=audio_stream)
+
+                for packet in video_input.demux(video_stream):
+                    # We need to skip the "flushing" packets that `demux` generates.
+                    if packet.dts is None:
+                        continue
+
+                    # We need to assign the packet to the new stream.
+                    packet.stream = output_video_stream
+                    output_container.mux(packet)
+
+                for packet in audio_input.demux(audio_stream):
+                    # We need to skip the "flushing" packets that `demux` generates.
+                    if packet.dts is None:
+                        continue
+
+                    # We need to assign the packet to the new stream.
+                    packet.stream = output_audio_stream
+                    output_container.mux(packet)
+
+                output_container.close()
+
             shutil.move(str(temp_file_path), str(movie_file_path))
             sound_file_path.unlink()
 
@@ -672,7 +823,6 @@ class SceneFileWriter:
 
     def combine_to_section_videos(self) -> None:
         """Concatenate partial movie files for each section."""
-
         self.finish_last_section()
         sections_index: list[dict[str, Any]] = []
         for section in self.sections:
@@ -687,7 +837,7 @@ class SceneFileWriter:
         with (self.sections_output_dir / f"{self.output_name}.json").open("w") as file:
             json.dump(sections_index, file, indent=4)
 
-    def clean_cache(self):
+    def clean_cache(self) -> None:
         """Will clean the cache by removing the oldest partial_movie_files."""
         cached_partial_movies = [
             (self.partial_movie_directory / file_name)
@@ -700,9 +850,8 @@ class SceneFileWriter:
             )
             oldest_files_to_delete = sorted(
                 cached_partial_movies,
-                key=os.path.getatime,
+                key=lambda path: path.stat().st_atime,
             )[:number_files_to_delete]
-            # oldest_file_path = min(cached_partial_movies, key=os.path.getatime)
             for file_to_delete in oldest_files_to_delete:
                 file_to_delete.unlink()
             logger.info(
@@ -710,7 +859,7 @@ class SceneFileWriter:
                 " You can change this behaviour by changing max_files_cached in config.",
             )
 
-    def flush_cache_directory(self):
+    def flush_cache_directory(self) -> None:
         """Delete all the cached partial movie files"""
         cached_partial_movies = [
             self.partial_movie_directory / file_name
@@ -724,13 +873,15 @@ class SceneFileWriter:
             {"par_dir": self.partial_movie_directory},
         )
 
-    def write_subcaption_file(self):
+    def write_subcaption_file(self) -> None:
         """Writes the subcaption file."""
+        if config.output_file is None:
+            return
         subcaption_file = Path(config.output_file).with_suffix(".srt")
-        subcaption_file.write_text(srt.compose(self.subcaptions))
+        subcaption_file.write_text(srt.compose(self.subcaptions), encoding="utf-8")
         logger.info(f"Subcaption file has been written as {subcaption_file}")
 
-    def print_file_ready_message(self, file_path):
+    def print_file_ready_message(self, file_path: StrPath) -> None:
         """Prints the "File Ready" message to STDOUT."""
         config["output_file"] = file_path
         logger.info("\nFile ready at %(file_path)s\n", {"file_path": f"'{file_path}'"})