Let SceneFileWriter access ffmpeg via av instead of via external process

manim/_config/utils.py

@@ -24,6 +24,7 @@
 from pathlib import Path
 from typing import Any, ClassVar, Iterable, Iterator, NoReturn
 
+import av
 import numpy as np
 from typing_extensions import Self
 
@@ -1053,6 +1054,7 @@ def ffmpeg_loglevel(self, val: str) -> None:
             val,
             ["DEBUG", "INFO", "WARNING", "ERROR", "CRITICAL"],
         )
+        logging.getLogger("libav").setLevel(self.ffmpeg_loglevel)
 
     @property
     def ffmpeg_executable(self) -> str:

manim/mobject/geometry/polygram.py

@@ -472,7 +472,6 @@ class Star(Polygon):
     Examples
     --------
     .. manim:: StarExample
-        :save_as_gif:
 
         class StarExample(Scene):
             def construct(self):

manim/scene/scene_file_writer.py

@@ -5,12 +5,14 @@
 __all__ = ["SceneFileWriter"]
 
 import json
+import logging
 import os
 import shutil
 import subprocess
 from pathlib import Path
 from typing import TYPE_CHECKING, Any
 
+import av
 import numpy as np
 import srt
 from PIL import Image
@@ -24,7 +26,6 @@
 from ..utils.file_ops import (
     add_extension_if_not_present,
     add_version_before_extension,
-    ensure_executable,
     guarantee_existence,
     is_gif_format,
     is_png_format,
@@ -83,14 +84,6 @@ def __init__(self, renderer, scene_name, **kwargs):
         self.next_section(
             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):
         """Initialise output directories.
@@ -358,7 +351,7 @@ def begin_animation(self, allow_write: bool = False, file_path=None):
             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):
         """
@@ -371,7 +364,7 @@ def end_animation(self, allow_write: bool = False):
             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):
         """
@@ -388,15 +381,17 @@ def write_frame(self, frame_or_renderer: np.ndarray | OpenGLRenderer):
         elif config.renderer == RendererType.CAIRO:
             frame = frame_or_renderer
             if write_to_movie():
-                self.writing_process.stdin.write(frame.tobytes())
+                av_frame = av.VideoFrame.from_ndarray(frame, format="rgba")
+                for packet in self.video_stream.encode(av_frame):
+                    self.video_container.mux(packet)
             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(),
-            )
+            av_frame = av.VideoFrame.from_ndarray(renderer.get_frame(), format="rgba")
+            for packet in self.video_stream.encode(av_frame):
+                self.video_container.mux(packet)
         elif is_png_format() and not config["dry_run"]:
             target_dir = self.image_file_path.parent / self.image_file_path.stem
             extension = self.image_file_path.suffix
@@ -467,11 +462,11 @@ def finish(self):
         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=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]
@@ -480,49 +475,45 @@ def open_movie_pipe(self, file_path=None):
         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"]
+
+        video_container = av.open(file_path, mode="w")
+
+        partial_movie_file_codec = "libx264"
+        partial_movie_file_pix_fmt = "yuv420p"
+        av_options = {
+            "an": "1",  # ffmpeg: -an, no audio
+        }
         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)
+            partial_movie_file_codec = "libvpx-vp9"
+            partial_movie_file_pix_fmt = "rgba"
+            av_options["-auto-alt-ref"] = "1"
+        elif config.transparent:
+            partial_movie_file_codec = "qtrle"
+            partial_movie_file_pix_fmt = "rgba"
+
+        stream = video_container.add_stream(
+            partial_movie_file_codec,
+            rate=config.frame_rate,
+            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 = video_container
+        self.video_stream = stream
+
+    def close_partial_movie_stream(self):
+        """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()
+        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",
@@ -567,37 +558,41 @@ def combine_files(
             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",
+            "metadata": f"comment=Rendered with Manim Community v{__version__}",
+        }
         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",
-            ]
-        else:
-            commands += ["-c", "copy"]
+            av_options["vf"] = (  # add video filter (is there a better way to do this?)
+                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"
+            )
+        else:  # copy codec of combined files
+            av_options["c"] = "copy"
 
         if not includes_sound:
-            commands += ["-an"]
+            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_stream = output_container.add_stream(template=partial_movies_stream)
+
+        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
 
-        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):
         """Used internally by Manim to combine the separate