Make livestreaming a thing.

docs/source/tutorials/configuration.rst

@@ -355,8 +355,8 @@ A list of all config options
    'max_files_cached', 'media_dir', 'movie_file_extension', 'output_file',
    'partial_movie_dir', 'pixel_height', 'pixel_width', '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',
-   'tex_template', 'tex_template_file', 'text_dir', 'top', 'transparent',
+   '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_js_renderer', 'verbosity', 'video_dir', 'write_all',
    'write_to_movie']
 
@@ -435,6 +435,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
      --progress_bar True/False

manim/__init__.py

@@ -90,3 +90,4 @@
 from .utils import unit
 
 from .plugins import *
+from .stream_starter import *

manim/__main__.py

@@ -11,6 +11,7 @@
 )
 from manim.utils.file_ops import open_file as open_media_file
 from manim._config.main_utils import parse_args
+from manim.stream_starter import livestream
 
 try:
     from manim.grpc.impl import frame_server_impl
@@ -76,6 +77,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_js_renderer"]:
             try:

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_js_renderer
 use_js_renderer = False
@@ -146,3 +147,14 @@ log_timestamps = True
 # Uncomment the following line to manually set the loglevel for ffmpeg. See
 # ffmpeg manpage for accepted values
 loglevel = ERROR
+
+
+# Streaming settings
+# Protocol defaults to rtp
+[streaming]
+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

manim/_config/main_utils.py

@@ -187,6 +187,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(
@@ -433,6 +435,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

@@ -280,6 +280,7 @@ class MyScene(Scene):
         "save_pngs",
         "scene_names",
         "show_in_file_browser",
+        "streaming_dir",
         "sound",
         "tex_dir",
         "tex_template_file",
@@ -539,6 +540,7 @@ def digest_parser(self, parser: configparser.ConfigParser) -> "ManimConfig":
             "movie_file_extension",
             "background_color",
             "js_renderer_path",
+            "streaming_dir",
         ]:
             setattr(self, key, parser["CLI"].get(key, fallback="", raw=True))
 
@@ -560,6 +562,23 @@ def digest_parser(self, parser: configparser.ConfigParser) -> "ManimConfig":
         if val:
             setattr(self, "ffmpeg_loglevel", 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":
@@ -679,7 +698,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
 
@@ -1161,6 +1180,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(
@@ -1236,6 +1256,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,11 @@
+from .cairo_renderer import CairoRenderer
+from .. import config
+from ..scene.stream_file_writer import StreamFileWriter
+
+
+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)

manim/scene/stream_file_writer.py

@@ -0,0 +1,103 @@
+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):
+    def __init__(self, renderer):
+        super().__init__(renderer, "")
+        vars(self).update(config.streaming_config)
+        path = os.path.join(config.get_dir("streaming_dir"), "clips")
+        self.FOLDER_PATH = os.path.relpath(guarantee_existence(path))
+        # To prevent extensive overwriting
+        self.partial_movie_directory = self.FOLDER_PATH
+
+    def init_output_directories(self, scene_name):
+        """The original :class:`SceneFileWriter` uses this method while initializing.
+        The method is overwritten carefully so as to correspond arguments in the
+        original and still avoid the folder creation effects of this method.
+        """
+        pass
+
+    @property
+    def file_path(self):
+        return self.partial_movie_files[-1]
+
+    def end_animation(self, allow_write=False):
+        """The point in the animation where the file exists."""
+        super().end_animation(allow_write=allow_write)
+        self.stream()
+
+    def combine_movie_files(self):
+        """Also to reduce overriding code."""
+        pass
+
+    def stream(self):
+        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 open_movie_pipe(self):
+        fps = config["frame_rate"]
+        height = config["pixel_height"]
+        width = config["pixel_width"]
+
+        command = [
+            FFMPEG_BIN,
+            "-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 imput comes from a pipe
+            "-an",  # Tells FFMPEG not to expect any audio
+            "-loglevel",
+            "error",
+        ]
+        if config["transparent"]:
+            command += ["-vcodec", "qtrle"]
+        else:
+            command += ["-vcodec", "libx264", "-pix_fmt", "yuv420p"]
+        command += [self.file_path]
+        self.writing_process = subprocess.Popen(command, stdin=subprocess.PIPE)
+
+    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}},
+        )

manim/scene/streaming_scene.py

@@ -0,0 +1,111 @@
+from .. import config
+from ..mobject.frame import FullScreenRectangle as Frame
+from ..renderer.stream_renderer import StreamCairoRenderer
+from ..utils.simple_functions import get_parameters
+from .scene import Scene
+
+
+class Stream:
+    """This class is really intended for inheritance of the style:
+
+    >>> class Streamer(Stream, Scene): # doctest: +SKIP
+    ...     pass
+    ...
+    >>>
+
+    This order is paramount. This :class:`Stream` class does the switch to
+    the specialized renderer, which uses the :class:`StreamFileWriter` to
+    handle specialized streaming services. That explains the calls to super,
+    which dig through the MRO of a class instead of using just a single
+    implementation contained in Scene. Okay, the references in super probably
+    point to things in the :class:`Scene` class only, but it's already happened so...
+
+    PS: You can probably already tell using this class on its own will bring you
+    errors.
+
+    """
+
+    def __init__(self, **kwargs):
+        camera_class = self.mint_camera_class()
+        renderer = StreamCairoRenderer(camera_class=camera_class)
+        super().__init__(renderer=renderer, **kwargs)
+        # To identify the frame in a black background
+        self.add(Frame())
+        self.setup()
+
+    @classmethod
+    def mint_camera_class(cls):
+        """Only __init__ arguments have the camera class now. In order for the
+        specialized renderer to be used, the scene's camera class must be found.
+
+        Returns:
+            A camera class from the scene's inheritance hierachy
+
+        Raises:
+            AttributeError: If this lookup fails
+        """
+        for obj in cls.mro():
+            try:
+                parameter = get_parameters(obj.__init__)["camera_class"]
+            except KeyError:
+                continue
+            else:
+                return parameter.default
+        raise AttributeError("Object does not contain scene protocol")
+
+    def show_frame(self):
+        """
+        Opens the current frame in the Default Image Viewer
+        of your system.
+        """
+        self.renderer.update_frame(self, ignore_skipping=True)
+        self.renderer.camera.get_image().show()
+
+
+def get_streamer(*scene):
+    """Creates an instance of a class that has streaming services.
+
+    Optional arguments:
+        scene: The scene whose methods can be used in the resulting
+        instance, such as zooming in and arbitrary method constructions.
+        Defaults to just Scene
+
+    Returns:
+        StreamingScene: It's a Scene that Streams. Name deconstruction.
+    """
+    bases = (Stream,) + (scene or (Scene,))
+    cls = type("StreamingScene", bases, {})
+    # This class doesn't really need a name, but we can go
+    # generic for this one
+    return cls()
+
+
+def play_scene(scene, start=None, end=None):
+    """Every scene has a render method that runs its setup and construct methods.
+    Using a streamer from classes with detailed implementation of this may call for
+    use of this.
+
+    >>> from example_scenes.basic import OpeningManimExample  # doctest: +SKIP
+    >>> manim = get_streamer(OpeningManimExample)             # doctest: +SKIP
+    >>> manim.render()                                        # doctest: +SKIP
+
+    This should stream a complete rendering of the Scene to the URL specified.
+    Hence the function clears everything after it's finished for more use. Or
+    something like that.
+
+    Arguments:
+        scene: The scene to be played.
+        start: The animation to start with. Default original start point.
+        end: The animation to end with. Default original endpoint
+             Note: The animations use endpoint-inclusive indexing, meaning (0, 5) would
+             play 0 upto 5 inclusive of both.
+    """
+    manim = get_streamer(scene)
+    original = (config.from_animation_number, config.upto_animation_number)
+    config.from_animation_number = start or config.from_animation_number
+    config.upto_animation_number = end or config.upto_animation_number
+    manim.render()
+    # Need to put it back because an end point less than the number of animations
+    # in a streamer makes any others ignored. That's a bug
+    config.from_animation_number, config.upto_animation_number = original
+    manim.clear()