MoviePy

https://zulko.github.io/moviepy
Admin
MoviePy is an open source, MIT-licensed Python library offering user-friendly tools for video...
Tokens:221,744
Snippets:2,107
Trust Score:8.3
Update:2 months ago
Show doc for...
Tokens:
Raw
### Build MoviePy Documentation

Source: https://zulko.github.io/moviepy/developer_guide/developers_install.html

After installing documentation libraries, run this command to build the MoviePy documentation locally. This is part of the developer setup process.

```bash
$ python setup.py build_docs

```

--------------------------------

### Install MoviePy Documentation Libraries

Source: https://zulko.github.io/moviepy/_sources/developer_guide/developers_install.rst.txt

Installs the necessary libraries to build the MoviePy documentation. Use this command when you need to generate or update the project's documentation.

```bash
$
(sudo) pip install moviepy[doc]
```

--------------------------------

### Install MoviePy

Source: https://zulko.github.io/moviepy/getting_started/moviepy_10_minutes.html

Install MoviePy using pip. This is the first step before using the library.

```bash
pip install moviepy

```

--------------------------------

### Install MoviePy Documentation Libraries

Source: https://zulko.github.io/moviepy/developer_guide/developers_install.html

Use this command to install the necessary libraries for building the MoviePy documentation. It's recommended for developers contributing to the project's documentation.

```bash
$ (sudo) pip install moviepy[doc]

```

--------------------------------

### Basic Video Editing Example

Source: https://zulko.github.io/moviepy/_sources/getting_started/quick_presentation.rst.txt

This example demonstrates loading a video, reducing its volume, adding a title overlay for the first ten seconds, and saving the result to a file. It requires the MoviePy library and a video file.

```python
from moviepy.editor import * 

# Load a video file
clip = VideoFileClip("my_video.mp4")

# Reduce the volume by half
clip = clip.volumex(0.5)

# Create a text clip for the title
txt_clip = TextClip("My Title", fontsize=50, color='white')

# Set the title to appear for the first 10 seconds and be centered
txt_clip = txt_clip.set_pos('center').set_duration(10)

# Overlay the title clip on the video clip
video = CompositeVideoClip([clip, txt_clip])

# Write the result to a new file
video.write_videofile("my_video_with_title.mp4")
```

--------------------------------

### Install Pre-commit Hooks

Source: https://zulko.github.io/moviepy/developer_guide/contribution_guidelines.html

Install the pre-commit framework to automatically run code checks before each commit. This helps maintain code quality and consistency.

```bash
$ pre-commit install
```

--------------------------------

### Install Pre-commit Hooks

Source: https://zulko.github.io/moviepy/_sources/developer_guide/contribution_guidelines.rst.txt

Installs pre-commit hooks to automatically check code quality before commits.

```bash
pre-commit install
```

--------------------------------

### CreditsClip Initialization Example

Source: https://zulko.github.io/moviepy/reference/reference/moviepy.video.tools.credits.CreditsClip.html

Demonstrates how to initialize a CreditsClip with a credit file, width, and various styling options. The credit file format is specified.

```python
# This is a comment # The next line says : leave 4 blank lines .blank 4
..Executive Story Editor MARCEL DURAND
..Associate Producers MARTIN MARCEL DIDIER MARTIN
..Music Supervisor JEAN DIDIER
```

--------------------------------

### Install MoviePy

Source: https://zulko.github.io/moviepy/_sources/getting_started/moviepy_10_minutes.rst.txt

Install MoviePy using pip. This is a prerequisite for using the library.

```shell
pip install moviepy
```

--------------------------------

### Install with Dependencies

Source: https://zulko.github.io/moviepy/developer_guide/contribution_guidelines.html

Install the MoviePy library in editable mode within a virtual environment, including optional, documentation, testing, and linting dependencies.

```bash
$ pip install -e ".[optional,doc,test,lint]"
```

--------------------------------

### MoviePy MultiplyVolume Examples

Source: https://zulko.github.io/moviepy/_modules/moviepy/audio/fx/MultiplyVolume.html

Demonstrates how to use the MultiplyVolume effect to adjust audio volume. Includes examples for doubling, halving, and silencing audio over a specific time range.

```python
from moviepy import AudioFileClip

music = AudioFileClip("music.ogg")
# doubles audio volume
doubled_audio_clip = music.with_effects([afx.MultiplyVolume(2)])
# halves audio volume
half_audio_clip = music.with_effects([afx.MultiplyVolume(0.5)])
# silences clip during one second at third
effect = afx.MultiplyVolume(0, start_time=2, end_time=3)
silenced_clip = clip.with_effects([effect])
```

--------------------------------

### Install MoviePy with Dependencies

Source: https://zulko.github.io/moviepy/_sources/developer_guide/contribution_guidelines.rst.txt

Installs MoviePy in editable mode with optional, documentation, testing, and linting dependencies.

```bash
pip install -e ".[optional,doc,test,lint]"
```

--------------------------------

### Notebook Display Example

Source: https://zulko.github.io/moviepy/reference/reference/moviepy.audio.AudioClip.AudioClip.html

Demonstrates how to display a clip's content within a Jupyter Notebook. Ensure MoviePy is imported.

```python
from moviepy import *

```

--------------------------------

### Install MoviePy Testing Libraries

Source: https://zulko.github.io/moviepy/developer_guide/developers_install.html

Install the libraries required for running MoviePy's test suite. Developers should use this to ensure code changes do not break existing functionality.

```bash
$ (sudo) pip install moviepy[test]

```

--------------------------------

### Install MoviePy Testing Libraries

Source: https://zulko.github.io/moviepy/_sources/developer_guide/developers_install.rst.txt

Installs the libraries required for running MoviePy tests. This command should be used by developers who want to contribute by fixing bugs or adding features.

```bash
$
(sudo) pip install moviepy[test]
```

--------------------------------

### Install MoviePy Linting Libraries

Source: https://zulko.github.io/moviepy/developer_guide/developers_install.html

Install the libraries needed for code linting. This helps maintain code quality and consistency across the MoviePy project.

```bash
$ (sudo) pip install moviepy[lint]

```

--------------------------------

### Install MoviePy Linting Libraries

Source: https://zulko.github.io/moviepy/_sources/developer_guide/developers_install.rst.txt

Installs the libraries needed for linting the MoviePy codebase. This helps maintain code quality and consistency across the project.

```bash
$
(sudo) pip install moviepy[lint]
```

--------------------------------

### Set Custom FFplay Path on Windows

Source: https://zulko.github.io/moviepy/getting_started/install.html

Example of setting a custom path for the FFplay binary on a Windows system using environment variables in Python.

```python
os.environ["FFPLAY_BINARY"] = r"C:\\Program Files\\ffmpeg\\ffplay.exe"

```

--------------------------------

### Start MoviePy Docker Container and Run Script

Source: https://zulko.github.io/moviepy/_sources/getting_started/docker.rst.txt

Starts a new MoviePy Docker container and immediately executes a Python script named 'myscript.py'. Mounts the current directory to /code inside the container.

```bash
docker run -it -v `pwd`:/code moviepy python myscript.py
```

--------------------------------

### Preview Video Clip

Source: https://zulko.github.io/moviepy/user_guide/rendering.html

Preview a video clip as a video. Requires ffplay to be installed. You can customize FPS and audio settings, or disable audio.

```python
from moviepy import *

myclip = VideoFileClip("./example.mp4").subclipped(0, 1)  # Keep only 0 to 1 sec

# We preview our clip as a video, inheriting FPS and audio of the original clip
myclip.preview()

# We preview our clip as video, but with a custom FPS for video and audio
# making it less consuming for our computer
myclip.preview(fps=5, audio_fps=11000)

# Now we preview without audio
myclip.preview(audio=False)
```

--------------------------------

### Preview Video Clips

Source: https://zulko.github.io/moviepy/getting_started/moviepy_10_minutes.html

Preview extracted video clips using the preview() method. Requires ffplay to be installed. Adjust fps for smoother playback if needed.

```python
#####################
# SCENES PREVIEWING #
#####################
# Now, lets have a first look at our clips
# Warning: you need ffplay installed for preview to work
# We set a low fps so our machine can render in real time without slowing down
intro_clip.preview(fps=20)
bird_clip.preview(fps=20)
bunny_clip.preview(fps=20)
rodents_clip.preview(fps=20)
rambo_clip.preview(fps=20)

```

--------------------------------

### Linear Gradient Example (Grayscale)

Source: https://zulko.github.io/moviepy/_modules/moviepy/video/tools/drawing.html

Generates a 10x1 grayscale gradient from white to black across the width.

```python
color_gradient((10, 1), (0, 0), p2=(10, 0))  # from white to black
#[[1.  0.9 0.8 0.7 0.6 0.5 0.4 0.3 0.2 0.1]]
```

--------------------------------

### Stereo Audio Clip Example

Source: https://zulko.github.io/moviepy/reference/reference/moviepy.audio.AudioClip.AudioClip.html

Creates and previews a stereo audio clip with two sine waves of different frequencies. Requires numpy for array manipulation.

```python
import numpy as np
frame_function = lambda t: np.array([
    np.sin(440 * 2 * np.pi * t),
    np.sin(880 * 2 * np.pi * t)
]).T.copy(order="C")
clip = AudioClip(frame_function, duration=3, fps=44100)
clip.preview()
```

--------------------------------

### Linear Gradient Example (RGB)

Source: https://zulko.github.io/moviepy/_modules/moviepy/video/tools/drawing.html

Generates a 10x1 RGB gradient from red to green across the width.

```python
color_gradient(
    (10, 1), (0, 0),
    p2=(10, 0),
    color_1=(255, 0, 0),
    color_2=(0, 255, 0)
)
# [[[  0.  255.    0. ]
#   [ 25.5 229.5   0. ]
#   [ 51.  204.    0. ]
#   [ 76.5 178.5   0. ]
#   [102.  153.    0. ]
#   [127.5 127.5   0. ]
#   [153.  102.    0. ]
#   [178.5  76.5   0. ]
#   [204.   51.    0. ]
#   [229.5  25.5   0. ]]]
```

--------------------------------

### Preview Video Clips

Source: https://zulko.github.io/moviepy/_sources/getting_started/moviepy_10_minutes.rst.txt

Preview individual video clips to check their content. Requires ffplay to be installed. Adjust fps for smoother playback if needed.

```python
# Preview the intro clip
intro_clip.preview()

# Preview the bird clip
bird_clip.preview()

# Preview the rabbit clip
rabbit_clip.preview()

# Preview the "Wow" clip
wow_clip.preview()

# Preview the final clip
final_clip.preview()
```

--------------------------------

### Get FFplay Version

Source: https://zulko.github.io/moviepy/_modules/moviepy/video/io/ffmpeg_tools.html

Retrieves the full and numeric version of the FFplay binary. Requires FFplay to be installed and accessible.

```python
def ffplay_version():
    """
    Retrieve the FFplay version.

    This function retrieves both the full and numeric version of FFplay
    by executing the `ffplay -version` command. The full version includes
    additional details like build information, while the numeric version
    contains only the version numbers (e.g., '6.0.1').

    Return
    ------
    tuple
        A tuple containing:
        - `full_version` (str): The complete version string (e.g., '6.0.1-static').
        - `numeric_version` (str): The numeric version string (e.g., '6.0.1').

    Example
    -------
    >>> ffplay_version()
    ('6.0.1-static', '6.0.1')

    Raises
    ------
    subprocess.CalledProcessError
        If the FFplay command fails to execute properly.
    """
    cmd = [
        FFPLAY_BINARY,
        "-version",
    ]

    result = subprocess.run(cmd, capture_output=True, text=True, check=True)
    # Extract the version number from the first line of output
    full_version = result.stdout.splitlines()[0].split()[2]
    numeric_version = re.match(r"^[0-9.]+", full_version).group(0)
    return (full_version, numeric_version)
```

--------------------------------

### initialize

Source: https://zulko.github.io/moviepy/reference/reference/moviepy.audio.io.readers.FFMPEG_AudioReader.html

Initializes the audio reader by opening the file and creating the necessary FFmpeg subprocess pipe.

```APIDOC
## initialize

### Description
Opens the file, creates the pipe.

### Parameters
* **start_time** (float) - The starting time for initialization. Defaults to 0.
```

--------------------------------

### Get FFmpeg Version

Source: https://zulko.github.io/moviepy/_modules/moviepy/video/io/ffmpeg_tools.html

Retrieves the full and numeric version of the FFmpeg binary. Requires FFmpeg to be installed and accessible.

```python
def ffmpeg_version():
    """
    Retrieve the FFmpeg version.

    This function retrieves both the full and numeric version of FFmpeg
    by executing the `ffmpeg -version` command. The full version includes
    additional details like build information, while the numeric version
    contains only the version numbers (e.g., '7.0.2').

    Return
    ------
    tuple
        A tuple containing:
        - `full_version` (str): The complete version string (e.g., '7.0.2-static').
        - `numeric_version` (str): The numeric version string (e.g., '7.0.2').

    Example
    -------
    >>> ffmpeg_version()
    ('7.0.2-static', '7.0.2')

    Raises
    ------
    subprocess.CalledProcessError
        If the FFmpeg command fails to execute properly.
    """
    cmd = [
        FFMPEG_BINARY,
        "-version",
        "-v",
        "quiet",
    ]

    result = subprocess.run(cmd, capture_output=True, text=True, check=True)

    # Extract the version number from the first line of output
    full_version = result.stdout.splitlines()[0].split()[2]
    numeric_version = re.match(r"^[0-9.]+", full_version).group(0)
    return (full_version, numeric_version)
```

--------------------------------

### Build MoviePy Documentation

Source: https://zulko.github.io/moviepy/_sources/developer_guide/developers_install.rst.txt

Builds the MoviePy documentation after installing the required libraries. This command is used by developers to generate the documentation locally.

```bash
$ python setup.py build_docs
```

--------------------------------

### Time Transformation Example

Source: https://zulko.github.io/moviepy/reference/reference/moviepy.Clip.Clip.html

Plays the clip starting at a specific time and backwards. This is achieved using the time_transform method with a lambda function.

```python
new_clip = clip.time_transform(lambda t: 3-t)
```

--------------------------------

### Subclipping a Video Clip

Source: https://zulko.github.io/moviepy/reference/reference/moviepy.Clip.Clip.html

This example shows how to create a subclip from an existing clip, cutting out the last two seconds. The subclipped method allows specifying start and end times, which can be negative to indicate offsets from the end of the clip.

```python
new_clip = clip.subclipped(0, -2)

```

--------------------------------

### Setting Clip Start Time

Source: https://zulko.github.io/moviepy/reference/reference/moviepy.Clip.Clip.html

Returns a copy of the clip with a new start attribute. This affects when the clip starts playing in a composite video, not the clip's internal start time. The end time is adjusted accordingly if change_end is True.

```python
new_clip = clip.with_start(t=10.0, change_end=True)
```

--------------------------------

### Initializing a TextClip with Font and Text

Source: https://zulko.github.io/moviepy/_modules/moviepy/video/VideoClip.html

Demonstrates the basic initialization of a TextClip using font and text arguments. It includes error handling for invalid fonts.

```python
from moviepy.editor import TextClip

# Example 1: Basic text clip
clip = TextClip(txt='Hello World', fontsize=50, color='white')

# Example 2: Text clip with a specific font file
# clip = TextClip(txt='MoviePy', font='Arial', fontsize=70, color='blue')

# Example 3: Text clip loaded from a file
# with open('my_text.txt', 'w') as f:
#     f.write('This is text from a file.')
# clip = TextClip(filename='my_text.txt', size=(640, 480), method='caption', color='black')

```

--------------------------------

### Install MoviePy with Pip

Source: https://zulko.github.io/moviepy/getting_started/install.html

Use this command to install MoviePy using pip. The 'sudo' prefix is optional and depends on your system's Python installation.

```bash
$ (sudo) pip install moviepy

```

--------------------------------

### Create Clip from Image Sequence with Durations

Source: https://zulko.github.io/moviepy/user_guide/loading.html

This example demonstrates creating a video clip from a list of image file paths, where each image is displayed for a specified duration. The total duration and FPS are calculated based on the number of images and their individual display times.

```Python
from moviepy import ImageSequenceClip

# A clip with a list of images showed for 1 second each
myclip = ImageSequenceClip(
    [
        "example_img_dir/image_0001.jpg",
        "example_img_dir/image_0002.jpg",
        "example_img_dir/image_0003.jpg",
    ],
    durations=[1, 1, 1],
)
# 3 images, 1 seconds each, duration = 3
print("Clip duration: {}".format(myclip.duration))
# 3 seconds, 3 images, fps is 3/3 = 1
print("Clip fps: {}".format(myclip.fps))

```

--------------------------------

### Install MoviePy with Pip

Source: https://zulko.github.io/moviepy/_sources/getting_started/install.rst.txt

Use this command to install MoviePy using pip. The 'sudo' prefix is optional and may be required depending on your system's Python installation.

```bash
$ (sudo) pip install moviepy
```

--------------------------------

### TextClip Initialization with Size and Method

Source: https://zulko.github.io/moviepy/_modules/moviepy/video/VideoClip.html

Illustrates creating a TextClip using the 'caption' method, which requires a fixed size. Text will wrap automatically within this size.

```python
caption_clip = TextClip(txt='A long sentence that needs to wrap within the specified size.', size=(300, 100), method='caption', fontsize=20, color='black')
```

--------------------------------

### FFMPEG_VideoReader Initialize Method

Source: https://zulko.github.io/moviepy/_modules/moviepy/video/io/ffmpeg_reader.html

Opens the video file and creates the FFmpeg subprocess pipe. It sets the starting time and configures FFmpeg options like pixel format and scaling.

```python
    def initialize(self, start_time=0):
        """
        Opens the file, creates the pipe.

        Sets self.pos to the appropriate value (1 if start_time == 0 because
        it pre-reads the first frame).
        """
        self.close(delete_lastread=False)  # if any

        if start_time != 0:
            offset = min(1, start_time)
            i_arg = [
                "-ss",
                "%.06f" % (start_time - offset),
                "-i",
                ffmpeg_escape_filename(self.filename),
                "-ss",
                "%.06f" % offset,
            ]
        else:
            i_arg = ["-i", ffmpeg_escape_filename(self.filename)]

        # For webm video (vp8 and vp9) with transparent layer, force libvpx/libvpx-vp9
        # as ffmpeg native webm decoder dont decode alpha layer
        # (see
        # https://www.reddit.com/r/ffmpeg/comments/fgpyfb/help_with_webm_with_alpha_channel/
        # )
        if self.depth == 4:
            codec_name = self.infos.get("video_codec_name")
            if codec_name == "vp9":
                i_arg = ["-c:v", "libvpx-vp9"] + i_arg
            elif codec_name == "vp8":
                i_arg = ["-c:v", "libvpx"] + i_arg

        cmd = (
            [FFMPEG_BINARY]
            + i_arg
            + [
                "-loglevel",
                "error",
                "-f",
                "image2pipe",
                "-vf",
                "scale=%d:%d" % tuple(self.size),
                "-sws_flags",
                self.resize_algo,
                "-pix_fmt",
                self.pixel_format,
                "-vcodec",
                "rawvideo",
                "-",
            ]
        )

        popen_params = cross_platform_popen_params(
            {
                "bufsize": self.bufsize,
                "stdout": sp.PIPE,
                "stderr": sp.PIPE,
                "stdin": sp.DEVNULL,
            }
        )
        self.proc = sp.Popen(cmd, **popen_params)

        # self.pos represents the (0-indexed) index of the frame that is next in line
        # to be read by self.read_frame().
        # Eg when self.pos is 1, the 2nd frame will be read next.
        self.pos = self.get_frame_number(start_time)
        self.last_read = self.read_frame()

```

--------------------------------

### Writing Matching Frames as GIFs

Source: https://zulko.github.io/moviepy/reference/reference/moviepy.video.tools.cuts.FramesMatches.html

This example demonstrates how to use `FramesMatches.from_clip` to find matching scenes in a video and then export these identified matching frames as individual GIF files using `write_gifs`. It requires creating a directory to store the output GIFs.

```python
import os
from pprint import pprint
from moviepy import *
from moviepy.video.tools.cuts import FramesMatches

ch_clip = VideoFileClip("media/chaplin.mp4").subclipped(1, 4)
clip = concatenate_videoclips([ch_clip.time_mirror(), ch_clip])

result = FramesMatches.from_clip(clip, 10, 3).select_scenes(
    1, 2, nomatch_threshold=0,
)

os.mkdir("foo")
result.write_gifs(clip, "foo")
# MoviePy - Building file foo/00000100_00000400.gif with imageio.
# MoviePy - Building file foo/00000115_00000384.gif with imageio.
# MoviePy - Building file foo/00000128_00000372.gif with imageio.
# MoviePy - Building file foo/00000140_00000360.gif with imageio.
```

--------------------------------

### Setting Start and End Times for Clips

Source: https://zulko.github.io/moviepy/user_guide/compositing.html

Demonstrates how to precisely control when clips start and end within a composite video. Use `with_end()` to set the clip's stop time and `with_start()` to define its start time.

```python
from moviepy import VideoFileClip, CompositeVideoClip

# We load all the clips we want to compose
clip1 = VideoFileClip("example.mp4")
clip2 = VideoFileClip("example2.mp4").subclipped(0, 1)
clip3 = VideoFileClip("example3.mp4")

# We want to stop clip1 after 1s
clip1 = clip1.with_end(1)

# We want to play clip2 after 1.5s
clip2 = clip2.with_start(1.5)

# We want to play clip3 at the end of clip2, and so for 3 seconds only
# Some times its more practical to modify the duration of a clip instead
# of his end
clip3 = clip3.with_start(clip2.end).with_duration(1)

# We write the result
final_clip = CompositeVideoClip([clip1, clip2, clip3])
final_clip.write_videofile("final_clip.mp4")

```

--------------------------------

### Create and Close VideoFileClip

Source: https://zulko.github.io/moviepy/_modules/moviepy/video/io/VideoFileClip.html

Demonstrates basic instantiation of VideoFileClip and the importance of calling close() to release resources. It also shows the usage of a context manager for implicit closing.

```python
clip = VideoFileClip("myHolidays.mp4")
clip.close()
with VideoFileClip("myMaskVideo.avi") as clip2:
    pass  # Implicit close called by context manager.
```

--------------------------------

### Creating Audio Clips

Source: https://zulko.github.io/moviepy/user_guide/loading.html

Shows how to create audio clips from audio files or by generating custom audio waveforms using a function.

```python
# for audio files, but also videos where you only want the keep the audio track
clip = AudioFileClip("example.wav")
# for custom audio, where frame_function is a function returning a
# float (or tuple for stereo) for a given time
clip = AudioClip(frame_function_audio, duration=3)
```

--------------------------------

### TextClip Initialization with Filename

Source: https://zulko.github.io/moviepy/_modules/moviepy/video/VideoClip.html

Shows how to create a TextClip by reading text content directly from a file. The text is read and trailing newlines are removed.

```python
text_clip = TextClip(filename='path/to/your/textfile.txt', font='Arial', fontsize=24, color='black')
```

--------------------------------

### Creating Video Clips

Source: https://zulko.github.io/moviepy/user_guide/loading.html

Demonstrates creating video clips from custom frame functions, existing video files, sequences of images, static images, text, and solid colors.

```python
# for custom animations, where frame_function is a function returning an image
# as numpy array for a given time
clip = VideoClip(frame_function, duration=5)
clip = VideoFileClip("example.mp4")  # for videos
# for a list or directory of images to be used as a video sequence
clip = ImageSequenceClip("example_img_dir", fps=24)
clip = ImageClip("example.png")  # For a picture
# To create the image of a text
clip = TextClip(font="./example.ttf", text="Hello!", font_size=70, color="black")
# a clip of a single unified color, where color is a RGB tuple/array/list
clip = ColorClip(size=(460, 380), color=black)
```

--------------------------------

### Setting Clip Start and End Times

Source: https://zulko.github.io/moviepy/getting_started/moviepy_10_minutes.html

Define when each clip should start and end within the final video. This ensures clips play in the correct sequence and for the desired duration.

```python
intro_text = intro_text.with_duration(6).with_start(3)  # Intro for 6 seconds, start after 3 seconds
logo_clip = logo_clip.with_start(intro_text.start + 2).with_end(intro_text.end)  # Logo start 2 second after intro text and stop with it
bird_clip = bird_clip.with_start(intro_clip.end)  # Make bird clip start after intro, duration already known
bird_text = bird_text.with_start(bird_clip.start).with_end(bird_clip.end)  # Make text synchro with clip
bunny_clip = bunny_clip.with_start(bird_clip.end)  # Make bunny clip follow bird clip
bunny_text = bunny_text.with_start(bunny_clip.start + 2).with_duration(7)
rodents_clip = rodents_clip.with_start(bunny_clip.end)
rodents_text = rodents_text.with_start(rodents_clip.start).with_duration(4)
rambo_clip = rambo_clip.with_start(rodents_clip.end - 1.5)
revenge_text = revenge_text.with_start(rambo_clip.start + 1.5).with_duration(4)
made_with_text = made_with_text.with_start(rambo_clip.end).with_duration(3)
moviepy_clip = moviepy_clip.with_start(made_with_text.start).with_duration(3)
```

--------------------------------

### Set Clip Start Time in MoviePy

Source: https://zulko.github.io/moviepy/_modules/moviepy/Clip.html

Modifies the 'start' attribute of a clip, affecting when it plays in a composite video. Optionally updates the 'end' attribute based on duration.

```python
self.start = t
if (self.duration is not None) and change_end:
    self.end = t + self.duration
elif self.end is not None:
    self.duration = self.end - self.start
```

--------------------------------

### FFMPEG_VideoReader.initialize()

Source: https://zulko.github.io/moviepy/reference/reference/moviepy.video.io.ffmpeg_reader.FFMPEG_VideoReader.html

Opens the video file and initializes the FFmpeg reading process.

```APIDOC
## initialize(start_time=0)

### Description
Opens the file, creates the pipe.
Sets self.pos to the appropriate value (1 if start_time == 0 because it pre-reads the first frame).

### Parameters
- **start_time** (float) - Optional - The time in seconds to start reading from (default is 0).
```

--------------------------------

### TextClip Initialization with Alignment and Interline

Source: https://zulko.github.io/moviepy/_modules/moviepy/video/VideoClip.html

Demonstrates controlling the alignment of the text block within the clip and the spacing between lines.

```python
aligned_clip = TextClip(txt='Line 1\nLine 2', size=(400, 200), method='caption', 
                        text_align='center', horizontal_align='center', 
                        vertical_align='center', interline=10)
```

--------------------------------

### Set FFplay Binary Path on Windows

Source: https://zulko.github.io/moviepy/_sources/getting_started/install.rst.txt

Example of setting the FFPLAY_BINARY environment variable to a specific executable path on a Windows system. Note the use of a raw string literal for the path.

```python
os.environ["FFPLAY_BINARY"] = r"C:\\Program Files\\ffmpeg\\ffplay.exe"
```

--------------------------------

### ImageSequenceClip Initialization with Folder

Source: https://zulko.github.io/moviepy/_modules/moviepy/video/io/ImageSequenceClip.html

Initializes an ImageSequenceClip using the path to a folder containing image files. Images are sorted alphanumerically. Ensures all images are the same size. Loads images on demand.

```python
from moviepy.video.io.ImageSequenceClip import ImageSequenceClip

# Example usage:
# clip = ImageSequenceClip('path/to/image_folder', fps=24)
```

--------------------------------

### Set start and end times for clips

Source: https://zulko.github.io/moviepy/_sources/getting_started/moviepy_10_minutes.rst.txt

Specify the start and end times for each clip to control their playback sequence. If a clip lacks a duration, setting `end_time` will automatically calculate it.

```python
clip1 = clip1.set_start(0).set_end(5)
clip2 = clip2.set_start(5).set_end(10)
clip3 = clip3.set_start(10).set_end(15)
```

--------------------------------

### Applying AudioDelay to an AudioFileClip

Source: https://zulko.github.io/moviepy/_modules/moviepy/audio/fx/AudioDelay.html

Demonstrates how to apply the AudioDelay effect to an existing audio file. This example sets an offset of 0.2 seconds, 10 repetitions, and a decay factor of 0.2.

```python
from moviepy import *
videoclip = AudioFileClip('myaudio.wav').with_effects([
    afx.AudioDelay(offset=.2, n_repeats=10, decayment=.2)
])
```

--------------------------------

### Parse Global Bitrate and Start Time

Source: https://zulko.github.io/moviepy/_modules/moviepy/video/io/ffmpeg_reader.html

Extracts global bitrate (in kb/s) and start time (in seconds) from FFmpeg output lines. Handles cases where these values might not be present.

```python
                # parse global bitrate (in kb/s)
                bitrate_match = re.search(r"bitrate: (\d+) k(i?)b/s", line)
                self.result["bitrate"] = (
                    int(bitrate_match.group(1)) if bitrate_match else None
                )

                # parse start time (in seconds)
                start_match = re.search(r"start: (\d+\.?\d+)", line)
                self.result["start"] = (
                    float(start_match.group(1)) if start_match else None
                )
```

--------------------------------

### ImageSequenceClip Initialization with Durations

Source: https://zulko.github.io/moviepy/_modules/moviepy/video/io/ImageSequenceClip.html

Initializes an ImageSequenceClip using a list of image file paths and a list of durations for each image. Ensures all images are the same size. Loads images on demand.

```python
from moviepy.video.io.ImageSequenceClip import ImageSequenceClip

# Example usage:
# clip = ImageSequenceClip(['img1.png', 'img2.png', 'img3.png'], durations=[0.5, 0.5, 1.0])
```

--------------------------------

### Control Clip Start and End Times in Composition

Source: https://zulko.github.io/moviepy/_sources/user_guide/compositing.rst.txt

Manage when clips begin and end within a composition by setting their 'start' and 'end' attributes. This allows for precise timing and sequencing of video elements.

```python
from moviepy.editor import *

clip1 = VideoFileClip("my_video.mp4").subclip(0, 6)
clip2 = VideoFileClip("my_video.mp4").subclip(0, 5)
clip3 = VideoFileClip("my_video.mp4").subclip(0, 7)

clip1 = clip1.set_start(0).set_end(6) # Plays from 0 to 6 seconds
clip2 = clip2.set_start(5).set_end(10) # Plays from 5 to 10 seconds
clip3 = clip3.set_start(10).set_end(17) # Plays from 10 to 17 seconds

final_clip = CompositeVideoClip([clip1, clip2, clip3])
final_clip.write_videofile("timed_composition.mp4")
```

--------------------------------

### FFMPEG_AudioReader Initialization

Source: https://zulko.github.io/moviepy/_modules/moviepy/audio/io/readers.html

Method to open the audio file and create the FFmpeg subprocess pipe.

```python
def initialize(self, start_time=0):
        """Opens the file, creates the pipe."""
        self.close()  # if any

        if start_time != 0:
            offset = min(1, start_time)
            i_arg = [
                "-ss",
                "%.05f" % (start_time - offset),
                "-i",
                ffmpeg_escape_filename(self.filename),
                "-vn",
                "-ss",
                "%.05f" % offset,
            ]
        else:
            i_arg = ["-i", ffmpeg_escape_filename(self.filename), "-vn"]

        cmd = (
            [FFMPEG_BINARY]
            + i_arg
            + [
                "-loglevel",
                "error",
                "-f",
                self.format,
                "-acodec",
                self.codec,
                "-ar",
                "%d" % self.fps,
                "-ac",
                "%d" % self.nchannels,
                "-",
            ]
        )

        popen_params = cross_platform_popen_params(
            {
                "bufsize": self.buffersize,
                "stdout": sp.PIPE,
                "stderr": sp.PIPE,
                "stdin": sp.DEVNULL,
            }
        )

        self.proc = sp.Popen(cmd, **popen_params)

        self.pos = np.round(self.fps * start_time)
```

--------------------------------

### Basic Video Clip Usage

Source: https://zulko.github.io/moviepy/reference/reference/moviepy.video.VideoClip.VideoClip.html

Demonstrates how to load a video file, subclip a portion, and write it to a new file. Remember to close the clip after use.

```python
from moviepy import VideoFileClip
clip = VideoFileClip("myvideo.mp4").subclipped(100,120)
clip.write_videofile("my_new_video.mp4")
clip.close()

```

--------------------------------

### Start MoviePy Docker Container in Interactive Mode

Source: https://zulko.github.io/moviepy/_sources/getting_started/docker.rst.txt

Starts a new MoviePy Docker container and opens an interactive bash shell. Useful for manual exploration or running commands within the container.

```bash
docker run -it moviepy bash
```

--------------------------------

### FFPLAY_VideoPreviewer Constructor

Source: https://zulko.github.io/moviepy/reference/reference/moviepy.video.io.ffplay_previewer.FFPLAY_VideoPreviewer.html

Initializes the FFPLAY_VideoPreviewer with video properties.

```APIDOC
## FFPLAY_VideoPreviewer(size, fps, pixel_format)

### Description
Initializes the FFPLAY_VideoPreviewer with video properties.

### Parameters
* **size** (tuple or list) - Required - Size of the output video in pixels (width, height).
* **fps** (int) - Required - Frames per second in the output video file.
* **pixel_format** (str) - Required - Pixel format for the output video file, `rgb24` for normal video, `rgba` if video with mask.
```

--------------------------------

### CompositeAudioClip

Source: https://zulko.github.io/moviepy/reference/reference/moviepy.audio.AudioClip.CompositeAudioClip.html

Initializes a CompositeAudioClip by composing several AudioClips. The clips can start at different times or together, based on their 'start' attributes. If all clips have their 'duration' attribute set, the duration of the composite clip is computed automatically.

```APIDOC
## CompositeAudioClip

### Description
Creates an audio clip by composing several AudioClips. This allows for layering or sequencing multiple audio sources.

### Parameters
* **clips** (list) - A list of AudioClip objects. These clips can have different start times and durations. The total duration is automatically calculated if all individual clips have their durations defined.

### Properties
* **starts**: Returns the starting times for all clips in the composition.
* **ends**: Returns the ending times for all clips in the composition.

### Methods
* **frame_function(t)**: Renders a frame for the composition at a given time `t`.
```

--------------------------------

### Initialize FFPLAY_AudioPreviewer

Source: https://zulko.github.io/moviepy/_modules/moviepy/audio/io/ffplay_audiopreviewer.html

Initializes the FFPLAY_AudioPreviewer with specified audio parameters. It configures ffplay command-line arguments based on the ffplay version to handle audio channels correctly.

```python
cmd = [
            FFPLAY_BINARY,
            "-autoexit",  # If you don't precise, ffplay won't stop at end
            "-nodisp",  # If you don't precise a window is
            "-f",
            "s%dle" % (8 * nbytes),
            "-ar",
            "%d" % fps_input,
        ]

        # Adapt number of channels argument to ffplay version
        ffplay_version = ffmpeg_tools.ffplay_version()[1]
        if int(ffplay_version.split(".")[0]) >= 7:
            cmd += [
                "-ch_layout",
                "stereo" if nchannels == 2 else "mono",
            ]
        else:
            cmd += [
                "-ac",
                "%d" % nchannels,
            ]

        cmd += [
            "-i",
            "-",
        ]

        popen_params = cross_platform_popen_params(
            {"stdout": sp.DEVNULL, "stderr": sp.STDOUT, "stdin": sp.PIPE}
        )

        self.proc = sp.Popen(cmd, **popen_params)
```

--------------------------------

### FFMPEG_AudioReader.__init__

Source: https://zulko.github.io/moviepy/_modules/moviepy/audio/io/readers.html

Initializes the audio reader for a specific file, setting up the ffmpeg process and buffer parameters.

```APIDOC
## Constructor: FFMPEG_AudioReader(filename, buffersize, decode_file=False, print_infos=False, fps=44100, nbytes=2, nchannels=2)

### Description
Initializes the audio reader instance. It parses file information and prepares the ffmpeg pipe for reading.

### Parameters
- **filename** (str) - Required - Path to the video or audio file.
- **buffersize** (int) - Required - Size of the buffer for reading.
- **decode_file** (bool) - Optional - Whether to decode the file.
- **print_infos** (bool) - Optional - Whether to print ffmpeg info.
- **fps** (int) - Optional - Desired frames per second (default: 44100).
- **nbytes** (int) - Optional - Number of bytes per sample (default: 2).
- **nchannels** (int) - Optional - Number of audio channels (default: 2).
```

--------------------------------

### ffplay_version

Source: https://zulko.github.io/moviepy/reference/reference/moviepy.video.io.ffmpeg_tools.html

Retrieves the installed FFplay version.

```APIDOC
## ffplay_version

### Description
Retrieve the FFplay version.

### Method
`ffplay_version()`

### Returns
- (string) - The version string of FFplay.
```

--------------------------------

### Creating and Using a SubtitlesClip

Source: https://zulko.github.io/moviepy/reference/reference/moviepy.video.tools.subtitles.SubtitlesClip.html

Demonstrates how to create a SubtitlesClip with a custom text generator, composite it with a video, and write the final video file. Ensure you have a 'subtitles.srt' file and 'myvideo.avi' in the same directory.

```python
from moviepy.video.tools.subtitles import SubtitlesClip
from moviepy.video.io.VideoFileClip import VideoFileClip
generator = lambda text: TextClip(text, font='./path/to/font.ttf',
                                font_size=24, color='white')
sub = SubtitlesClip("subtitles.srt", make_textclip=generator, encoding='utf-8')
myvideo = VideoFileClip("myvideo.avi")
final = CompositeVideoClip([clip, subtitles])
final.write_videofile("final.mp4", fps=myvideo.fps)
```

--------------------------------

### ImageSequenceClip Initialization with FPS

Source: https://zulko.github.io/moviepy/_modules/moviepy/video/io/ImageSequenceClip.html

Initializes an ImageSequenceClip using a list of image file paths and a specified frames per second (fps). Ensures all images are the same size. Loads images on demand.

```python
from moviepy.video.io.ImageSequenceClip import ImageSequenceClip

# Example usage:
# clip = ImageSequenceClip(['img1.png', 'img2.png', 'img3.png'], fps=24)
```

--------------------------------

### ffmpeg_version

Source: https://zulko.github.io/moviepy/reference/reference/moviepy.video.io.ffmpeg_tools.html

Retrieves the installed FFmpeg version.

```APIDOC
## ffmpeg_version

### Description
Retrieve the FFmpeg version.

### Method
`ffmpeg_version()`

### Returns
- (string) - The version string of FFmpeg.
```

--------------------------------

### ffplay_version

Source: https://zulko.github.io/moviepy/_sources/reference/reference/moviepy.video.io.ffmpeg_tools.ffplay_version.rst.txt

Returns the version of ffplay installed on the system.

```APIDOC
## ffplay_version()

### Description
Returns the version of ffplay installed on the system. This function is useful for checking compatibility or debugging issues related to ffplay.

### Method
`function`

### Parameters
None

### Returns
- `str`: The version string of ffplay.
```

--------------------------------

### TextClip Initialization with Background Color

Source: https://zulko.github.io/moviepy/_modules/moviepy/video/VideoClip.html

Shows how to set a background color for the TextClip. The background color can be specified as a tuple, name, or hex code.

```python
clip_with_bg = TextClip(txt='Text with background', bg_color=(255, 0, 0), color='white')
```

--------------------------------

### ffmpeg_extract_subclip

Source: https://zulko.github.io/moviepy/_modules/moviepy/video/io/ffmpeg_tools.html

Extracts a subclip from a video file between specified start and end times.

```APIDOC
## ffmpeg_extract_subclip

### Description
Makes a new video file playing video file between two times.

### Parameters

#### inputfile
- **inputfile** (str) - Path to the file from which the subclip will be extracted.

#### start_time
- **start_time** (float) - Moment of the input clip that marks the start of the produced subclip.

#### end_time
- **end_time** (float) - Moment of the input clip that marks the end of the produced subclip.

#### outputfile
- **outputfile** (str) - Optional. Path to the output file. Defaults to ``<inputfile_name>SUB<start_time>_<end_time><ext>``.
```

--------------------------------

### Crop with explicit width

Source: https://zulko.github.io/moviepy/reference/reference/moviepy.video.fx.Crop.html

Use this to crop a rectangle that starts at a specific x-coordinate and has a defined width.

```python
>>> Crop(x1=10, width=200)
```

--------------------------------

### subclipped(start_time=0, end_time=None)

Source: https://zulko.github.io/moviepy/reference/reference/moviepy.Clip.Clip.html

Creates a subclip from the current clip, specifying start and end times.

```APIDOC
## subclipped(start_time=0, end_time=None)

### Description

Returns a clip playing the content of the current clip between times `start_time` and `end_time`, which can be expressed in seconds (15.35), in (min, sec), in (hour, min, sec), or as a string: ‘01:03:05.35’. The `mask` and `audio` of the resulting subclip will be subclips of `mask` and `audio` the original clip, if they exist. It’s equivalent to slice the clip as a sequence, like `clip[t_start:t_end]`.

### Method

`subclipped(start_time=0, end_time=None)`

### Parameters

#### Path Parameters

*   **start_time** (float or tuple or str, optional) – Moment that will be chosen as the beginning of the produced clip. If is negative, it is reset to `clip.duration + start_time`.
*   **end_time** (float or tuple or str, optional) – Moment that will be chosen as the end of the produced clip. If not provided, it is assumed to be the duration of the clip (potentially infinite). If is negative, it is reset to `clip.duration + end_time`. For instance:
    ```python
    >>> # cut the last two seconds of the clip:
    >>> new_clip = clip.subclipped(0, -2)
    ```
    If `end_time` is provided or if the clip has a duration attribute, the duration of the returned clip is set automatically.
```

--------------------------------

### Preview a Video Clip

Source: https://zulko.github.io/moviepy/_sources/user_guide/rendering.rst.txt

Use the `preview` function to display a video clip in real-time. Ensure `ffplay` is installed and accessible. This method is useful for quick checks during the editing process.

```python
from moviepy.editor import *

clip = VideoFileClip("my_video.mp4").subclip(10, 20)
clip.preview()
# or clip.subclip(10, 20).preview()
```

--------------------------------

### Adjust Clip Duration

Source: https://zulko.github.io/moviepy/_modules/moviepy/Clip.html

Modifies the duration of a clip. The start attribute is adjusted if change_end is False.

```python
def set_duration(self, duration, change_end=False):
        """Sets a new duration for the clip.

        Parameters
        ----------

        duration : float
          New duration attribute value for the clip.

        change_end : bool, optional
          If ``True``, the ``end`` attribute value of the clip will be adjusted
          accordingly to the new duration using ``clip.start + duration``.
        """
        self.duration = duration

        if change_end:
            self.end = None if (duration is None) else (self.start + duration)
        else:
            if self.duration is None:
                raise ValueError("Cannot change clip start when new duration is None")
            self.start = self.end - duration
```

--------------------------------

### Creating and Applying AudioDelay to a Generated AudioClip

Source: https://zulko.github.io/moviepy/_modules/moviepy/audio/fx/AudioDelay.html

Shows how to create a synthetic stereo audio clip and then apply the AudioDelay effect to it. This example uses 11 repetitions with a decay of 0, effectively muting the delayed copies.

```python
# stereo A note
frame_function = lambda t: np.array(
    [np.sin(440 * 2 * np.pi * t), np.sin(880 * 2 * np.pi * t)]
).T
clip = AudioClip(frame_function=frame_function, duration=0.1, fps=44100)
clip = clip.with_effects([afx.AudioDelay(offset=.2, n_repeats=11, decay=0)])
```

--------------------------------

### TextClip Initialization

Source: https://zulko.github.io/moviepy/_modules/moviepy/video/VideoClip.html

Initializes a TextClip, which creates a video clip from text. It supports specifying font, text content, or a filename containing the text.

```python
def __init__(
        self,
        font=None,
        text=None,
        filename=None,
        size=None,
        color='black',
        bg_color='transparent',
        stroke_color='transparent',
        stroke_width=0,
        fontsize=None,
        method='caption',
        align='center',
        kerning1=None,
        kerning2=None,
        interline=None,
        line_spacing=None,
        transparent=True,
        is_mask=False,
        duration=None,
        # The following parameters are only used if method='label'
        # and are ignored otherwise:
        imaginary_size=None,
        # The following parameters are only used if method='caption'
        # and are ignored otherwise:
        caption_text=None,
        caption_fontsize=None,
        caption_pad=0,
        caption_align='South',
        caption_margin=0,
        caption_background='transparent',
        caption_stroke_color='transparent',
        caption_stroke_width=0,
        caption_font_color='black',
        caption_font=None,
        caption_method='caption',
        caption_kerning1=None,
        caption_kerning2=None,
        caption_interline=None,
        caption_line_spacing=None,
        caption_imaginary_size=None,
    ):
        # ... (implementation details omitted for brevity) ...
        pass
```

--------------------------------

### Crop from the top

Source: https://zulko.github.io/moviepy/_modules/moviepy/video/fx/Crop.html

This snippet demonstrates how to remove the top portion of a clip by specifying only the starting y-coordinate (y1).

```python
from moviepy.video.fx.Crop import Crop

clip = clip.fx(Crop, y1=30)
```

--------------------------------

### ImageSequenceClip Loading All Images into Memory

Source: https://zulko.github.io/moviepy/_modules/moviepy/video/io/ImageSequenceClip.html

Initializes an ImageSequenceClip by loading all images into RAM at once. This is beneficial for smaller image sets that are accessed frequently. Use the 'load_images' parameter.

```python
from moviepy.video.io.ImageSequenceClip import ImageSequenceClip

# Example usage:
# clip = ImageSequenceClip(['img1.png', 'img2.png'], fps=24, load_images=True)
```

--------------------------------

### Loading an AudioFileClip

Source: https://zulko.github.io/moviepy/_sources/user_guide/loading.rst.txt

Use AudioFileClip to load an audio file directly. This is the most common way to work with existing audio files.

```python
from moviepy.editor import *

# Load an audio file (e.g., 'my_sound.mp3')
audio_file = AudioFileClip("my_sound.mp3")

# You can then manipulate it or write it to a file
# audio_file.write_audiofile("my_sound_copy.wav")
```

--------------------------------

### Crop

Source: https://zulko.github.io/moviepy/reference/reference/moviepy.video.fx.html

Effect to crop a clip to get a new clip in which just a rectangular subregion of the original clip is conserved.

```APIDOC
## Crop

### Description
Effect to crop a clip to get a new clip in which just a rectangular subregion of the original clip is conserved.

### Method
`moviepy.video.fx.Crop([x1, y1, x2, y2, ...])`

### Parameters
* `x1` (int, float) - Optional - The x-coordinate of the top-left corner of the cropping rectangle.
* `y1` (int, float) - Optional - The y-coordinate of the top-left corner of the cropping rectangle.
* `x2` (int, float) - Optional - The x-coordinate of the bottom-right corner of the cropping rectangle.
* `y2` (int, float) - Optional - The y-coordinate of the bottom-right corner of the cropping rectangle.

### Returns
* A new VideoClip that is a cropped version of the original.
```

--------------------------------

### AudioFadeIn

Source: https://zulko.github.io/moviepy/reference/reference/moviepy.audio.fx.AudioFadeIn.html

Creates an audio or video clip that starts muted and progressively increases its sound level over a specified duration.

```APIDOC
## class moviepy.audio.fx.AudioFadeIn.AudioFadeIn

### Description
Returns an audio (or video) clip that is first mute, then the sound arrives progressively over `duration` seconds.

### Parameters
#### Parameters
- **duration** (float) - How long does it take for the sound to return to its normal level.

### Examples
```python
clip = VideoFileClip("media/chaplin.mp4")
clip.with_effects([afx.AudioFadeIn("00:00:06")])
```
```
Tokens:
Raw