Make livestreaming a thing.

docs/source/tutorials/configuration.rst

@@ -353,12 +353,12 @@ A list of all config options
    'frame_y_radius', 'from_animation_number', 'images_dir', 'input_file',
    'leave_progress_bars', 'left_side', 'log_dir', 'log_to_file',
    'max_files_cached', 'media_dir', 'media_width', 'movie_file_extension', 'output_file',
-   'partial_movie_dir', 'pixel_height', 'pixel_width', 'plugins', 'png_mode',
+   'partial_movie_dir', 'pixel_height', 'pixel_width', 'plugins', 'png_mode', 
    'preview', 'progress_bar', 'quality', 'right_side', 'save_as_gif', 'save_last_frame',
-   'save_pngs', 'scene_names', 'show_in_file_browser', 'sound', 'tex_dir',
+   'save_pngs', 'scene_names', 'show_in_file_browser', 'sound', 'streaming_dir', 'tex_dir', 
    'tex_template', 'tex_template_file', 'text_dir', 'top', 'transparent',
-   'upto_animation_number', 'use_opengl_renderer', 'use_webgl_renderer', 'verbosity',
-   'video_dir', 'webgl_renderer_path', 'webgl_updater_fps', 'write_all',
+   'upto_animation_number', 'use_opengl_renderer', 'use_webgl_renderer', 'verbosity', 
+   'video_dir', 'webgl_renderer_path', 'webgl_updater_fps', 'write_all', 
    'write_to_movie']
 
 
@@ -441,6 +441,8 @@ A list of all CLI flags
      --config_file CONFIG_FILE
                            Specify the configuration file
      --custom_folders      Use the folders defined in the [custom_folders] section of the config file to define the output folder structure
+     --livestream          Run in streaming mode
+     --use-ipython         Use IPython for streaming
      -v {DEBUG,INFO,WARNING,ERROR,CRITICAL}, --verbosity {DEBUG,INFO,WARNING,ERROR,CRITICAL}
                            Verbosity level. Also changes the ffmpeg log level unless the latter is specified in the config
      --version             Print the current version of Manim you are using

manim/__init__.py

@@ -94,6 +94,7 @@
 from .utils.tex import *
 from .utils.tex_templates import *
 from .utils import unit
+from .stream_starter import *
 
 try:
     from IPython import get_ipython

manim/__main__.py

@@ -11,6 +11,7 @@
 )
 
 from manim._config.main_utils import parse_args
+from manim.stream_starter import livestream
 
 
 def main():
@@ -44,6 +45,11 @@ def main():
 
     else:
         config.digest_args(args)
+
+        if args.livestream:
+            livestream(use_ipython=args.use_ipython)
+            return
+
         input_file = config.get_dir("input_file")
 
         if config["use_opengl_renderer"]:

manim/_config/default.cfg

@@ -83,6 +83,7 @@ images_dir = {media_dir}/images/{module_name}
 tex_dir = {media_dir}/Tex
 text_dir = {media_dir}/texts
 partial_movie_dir = {video_dir}/partial_movie_files/{scene_name}
+streaming_dir = {media_dir}/streams
 
 # --use_webgl_renderer
 use_webgl_renderer = False
@@ -157,5 +158,15 @@ repr_number = green
 # ffmpeg manpage for accepted values
 loglevel = ERROR
 
+[streaming]
+# Streaming settings
+# Protocol defaults to rtp
+streaming_client = ffplay
+streaming_protocol = rtp
+streaming_ip = 127.0.0.1
+streaming_port = 2000
+streaming_url = {streaming_protocol}://{streaming_ip}:{streaming_port}
+sdp_name = stream_{streaming_protocol}.sdp
+
 [jupyter]
 media_width = 25vw

manim/_config/logger_utils.py

@@ -11,11 +11,12 @@
 """
 import configparser
 import copy
+from functools import wraps
 import json
 import logging
 import os
 import typing
-from typing import TYPE_CHECKING
+from typing import TYPE_CHECKING, Callable, Any
 
 from rich import color, errors
 from rich import print as printf
@@ -178,6 +179,19 @@ def set_file_logger(config: "ManimConfig", verbosity: str) -> None:
     logger.setLevel(verbosity)
 
 
+def disable_logging(func: Callable[[Any], Any]) -> Callable[[Any], Any]:
+    """Decorator for disabling logging output of a function."""
+
+    wraps(func)
+
+    def action(*args, **kwargs):
+        logging.disable(50)
+        func(*args, **kwargs)
+        logging.disable(0)
+
+    return action
+
+
 class JSONFormatter(logging.Formatter):
     """A formatter that outputs logs in a custom JSON format.
 

manim/_config/main_utils.py

@@ -190,6 +190,8 @@ def _parse_args_no_subcmd(args: list) -> argparse.Namespace:
 
     parser.add_argument(
         "file",
+        nargs="?",
+        default="",
         help="Path to file holding the python code for the scene",
     )
     parser.add_argument(
@@ -449,6 +451,20 @@ def _parse_args_no_subcmd(args: list) -> argparse.Namespace:
         "section of the config file to define the output folder structure",
     )
 
+    # Overrides default false streaming so streaming can happen
+    parser.add_argument(
+        "--livestream",
+        action="store_true",
+        help="Run in streaming mode",
+    )
+
+    # Optional use of IPython for streaming
+    parser.add_argument(
+        "--use-ipython",
+        action="store_true",
+        help="Use IPython for streaming",
+    )
+
     # Specify the verbosity
     parser.add_argument(
         "-v",

manim/_config/utils.py

@@ -283,6 +283,7 @@ class MyScene(Scene):
         "save_pngs",
         "scene_names",
         "show_in_file_browser",
+        "streaming_dir",
         "sound",
         "tex_dir",
         "tex_template_file",
@@ -547,6 +548,7 @@ def digest_parser(self, parser: configparser.ConfigParser) -> "ManimConfig":
             "movie_file_extension",
             "background_color",
             "webgl_renderer_path",
+            "streaming_dir",
         ]:
             setattr(self, key, parser["CLI"].get(key, fallback="", raw=True))
 
@@ -581,6 +583,23 @@ def digest_parser(self, parser: configparser.ConfigParser) -> "ManimConfig":
         if val:
             setattr(self, "media_width", val)
 
+        streaming_config = {
+            opt: parser["streaming"].get(opt, fallback="", raw=True)
+            for opt in [
+                "streaming_client",
+                "streaming_protocol",
+                "streaming_ip",
+                "streaming_port",
+            ]
+        }
+        url = parser["streaming"].get("streaming_url", fallback="", raw=True)
+        sdp_name = parser["streaming"].get("sdp_name", fallback="", raw=True)
+        streaming_config["streaming_url"] = url.format(**streaming_config)
+        streaming_config["sdp_path"] = os.path.join(
+            self.get_dir("streaming_dir"), sdp_name.format(**streaming_config)
+        )
+        self.streaming_config = streaming_config
+
         return self
 
     def digest_args(self, args: argparse.Namespace) -> "ManimConfig":
@@ -705,7 +724,7 @@ def digest_args(self, args: argparse.Namespace) -> "ManimConfig":
                 "partial_movie_dir",
             ]:
                 self[opt] = self._parser["custom_folders"].get(opt, raw=True)
-            # --media_dir overrides the deaful.cfg file
+            # --media_dir overrides the default.cfg file
             if hasattr(args, "media_dir") and args.media_dir:
                 self.media_dir = args.media_dir
 
@@ -1224,6 +1243,7 @@ def get_dir(self, key: str, **kwargs: str) -> Path:
             "input_file",
             "output_file",
             "partial_movie_dir",
+            "streaming_dir",
         ]
         if key not in dirs:
             raise KeyError(
@@ -1299,6 +1319,12 @@ def _set_dir(self, key: str, val: typing.Union[str, Path]):
         doc="Directory to place partial movie files (no flag).  See :meth:`ManimConfig.get_dir`.",
     )
 
+    streaming_dir = property(
+        lambda self: self._d["streaming_dir"],
+        lambda self, val: self._set_dir("streaming_dir", val),
+        doc="Directory to have streamed files.  See :meth:`ManimConfig.get_dir`.",
+    )
+
     custom_folders = property(
         lambda self: self._d["custom_folders"],
         lambda self, val: self._set_boolean("custom_folders", val),

manim/renderer/stream_renderer.py

@@ -0,0 +1,29 @@
+from manim.renderer.cairo_renderer import CairoRenderer
+from manim._config import config, logger
+from manim.scene.stream_file_writer import StreamFileWriter
+
+from manim.utils.hashing import get_hash_from_play_call
+
+
+class StreamCairoRenderer(CairoRenderer):
+    def init_scene(self, scene):
+        """For compatibility with the __init__ from scene that's not being
+        directly overridden
+        """
+        self.file_writer = StreamFileWriter(self)
+
+    def play(self, scene, *args, **kwargs):
+        """Meant to attach some things
+
+        Args:
+            scene ([type]): [description]
+        """
+        scene.compile_animation_data(*args, **kwargs)
+        if not config["disable_caching"] and not self.skip_animations:
+            hash_current_animation = get_hash_from_play_call(
+                scene, self.camera, scene.animations, scene.mobjects
+            )
+        else:
+            hash_current_animation = f"uncached_{self.num_plays:05}"
+        self.file_writer.add_partial_movie_file(hash_current_animation)
+        super().play(scene, *args, **kwargs)

manim/scene/stream_file_writer.py

@@ -0,0 +1,98 @@
+from abc import ABCMeta
+
+import os
+import subprocess
+
+from .. import config, logger
+from ..constants import FFMPEG_BIN
+from .scene import Scene
+from .scene_file_writer import SceneFileWriter
+from ..utils.file_ops import guarantee_existence
+
+
+class StreamFileWriter(SceneFileWriter):
+    """Specialized file writer for streaming.
+
+    Takes a good portion of its implementation from `:class:~.SceneFileWriter`
+    but changes enough of it to redirect output directories and the final
+    request to the streaming protocol.
+
+    .. seealso::
+
+        :func:`~.stream_starter.livestream`
+        :class:`~.SceneFileWriter`
+
+    """
+
+    def __init__(self, renderer):
+        super().__init__(renderer, "")
+        vars(self).update(config.streaming_config)
+        path = os.path.join(config.get_dir("streaming_dir"), "clips")
+        self.partial_movie_directory = os.path.relpath(guarantee_existence(path))
+
+    def init_output_directories(self, scene_name):
+        """Overridden to avoid creation of unnecessary output directories."""
+        pass
+
+    @property
+    def file_path(self):
+        """Returns the path of the most recent animation generated by the
+        class. This is insignificant to the base class which has its own ways
+        of acquiring this path.
+        """
+        self.partial_movie_files = list(filter(lambda item: item is not None, self.partial_movie_files))
+        return self.partial_movie_files[self.renderer.num_plays]
+
+    def end_animation(self, allow_write=False):
+        """Closes the input buffer and streams the rendered partial movie file.
+
+        Called at the end of the life cycle of an :class:`~.Animation`.
+
+        """
+        super().end_animation(allow_write=allow_write)
+        self.stream()
+
+    def combine_movie_files(self):
+        """Overridden: not required for live streaming.
+
+        .. seealso::
+
+            :class:`~.SceneFileWriter`
+
+        """
+        pass
+
+    def stream(self):
+        """Stream the (partial) video file via the configured streaming protocol."""
+        logger.info(
+            "Houston, we are ready to launch. Sending over to %(url)s",
+            {"url": {self.streaming_url}},
+        )
+        command = [
+            FFMPEG_BIN,
+            "-re",
+            "-i",
+            self.file_path,
+            "-vcodec",
+            "copy",
+            "-an",
+            "-loglevel",
+            "quiet",
+        ]
+
+        if self.streaming_protocol == "rtp":
+            command += ["-sdp_file", self.sdp_path]
+        command += [
+            "-f",
+            self.streaming_protocol,  # Take a look here for other streaming protocols
+            self.streaming_url,
+        ]
+        os.system(" ".join(command))
+
+    def close_movie_pipe(self):
+        self.writing_process.stdin.close()
+        self.writing_process.wait()
+        logger.info(
+            f"Animation {self.renderer.num_plays}: File at %(path)s",
+            {"path": {self.file_path}},
+        )