$ (sudo) pip install moviepy

import os
os.environ["FFMPEG_BINARY"] = "/path/to/custom/ffmpeg"
os.environ["FFPLAY_BINARY"] = "/path/to/custom/ffplay"

FFMPEG_BINARY=/path/to/custom/ffmpeg
FFPLAY_BINARY=/path/to/custom/ffplay

from moviepy.config import check
check()

# Import everything needed to edit video clips
from moviepy import *
# Load file example.mp4 and extract only the subclip from 00:00:10 to 00:00:20
clip = VideoFileClip("long_examples/example2.mp4").subclipped(10, 20)
# Reduce the audio volume to 80% of his original volume
clip = clip.with_volume_scaled(0.8)
# Generate a text clip. You can customize the font, color, etc.
txt_clip = TextClip(


    font="example.ttf", text="Big Buck Bunny", font_size=70, color="white"
)
# Say that you want it to appear for 10s at the center of the screen
txt_clip = txt_clip.with_position("center").with_duration(10)
# Overlay the text clip on the first video clip
video = CompositeVideoClip([clip, txt_clip])
# Write the result to a file (many options available!)
video.write_videofile("result.mp4")

pip install moviepy

# Lets import moviepy, lets also import numpy we will use it a some point
import numpy as np
from moviepy import *
#################
# VIDEO LOADING #
#################
# We load our video

#####################
# SCENES EXTRACTION #
#####################
# We extract the scenes we want to use
# First the characters
intro_clip = video.subclipped(1, 11)
bird_clip = video.subclipped(16, 20)
bunny_clip = video.subclipped(37, 55)
rodents_clip = video.subclipped(


    "00:03:34.75", "00:03:56"
)  # we can also use string notation with format HH:MM:SS.uS

#####################
# 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)

##############################
# CLIPS MODIFICATION CUTTING #
##############################
# Well, looking at the rodent scene it is a bit long isn't?
# Let's see how we modify the clip with one of the many clip manipulation method starting by with_*
# in that case by removing of the clip the part between 00:06:00 to 00:10:00 of the clip, using with_section_cut_out
rodents_clip = rodents_clip.with_section_cut_out(start_time=4, end_time=10)
# Note: You may have noticed that we have reassign rodents_clip, this is because all with_* methods return a modified *copy* of the
# original clip instead of modifying it directly. In MoviePy any function starting by with_* is out-place instead of in-place
# meaning it does not modify the original data, but instead copy it and modify/return the copy
# Lets check the result

############################
# TEXT/LOGO CLIPS CREATION #
############################
# Lets create the texts to put between our clips
font = "./resources/font/font.ttf"
intro_text = TextClip(


    font=font,


    text="The Blender Foundation and\nPeach Project presents",


    font_size=50,


    color="#fff",


    text_align="center",
)
bird_text = TextClip(font=font, text="An unlucky bird", font_size=50, color="#fff")
bunny_text = TextClip(


    font=font, text="A (slightly overweight) bunny", font_size=50, color="#fff"
)
rodents_text = TextClip(


    font=font, text="And three rodent pests", font_size=50, color="#fff"
)
revenge_text = TextClip(


    font=font, text="Revenge is coming...", font_size=50, color="#fff"
)
made_with_text = TextClip(font=font, text="Made with", font_size=50, color="#fff")
# We will also need the big buck bunny logo, so lets load it and resize it
logo_clip = ImageClip("./resources/logo_bbb.png").resized(width=400)

################
# CLIPS TIMING #
################
# We have all the clips we need, but if we was to turn all the clips into a single one with composition (we will see that during next step)
# all our clips would start at the same time and play on top of each other, which is obviously not what we want.
# To fix that, we need to say when a clip should start and stop in the final clip.
# So, lets start by telling when each clip must start and end with appropriate with_* methods
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)

So in our case, we either use duration or end_time, depending on what is more practical for each specific case.

########################
# CLIPS TIMING PREVIEW #
########################
# Lets make a first compositing of the clips into one single clip and do a quick preview to see if everything is synchro
quick_compo = CompositeVideoClip(


    [


        intro_clip,


        intro_text,


        logo_clip,


        bird_clip,


        bird_text,


        bunny_clip,


        bunny_text,


        rodents_clip,


        rodents_text,


        rambo_clip,


        revenge_text,


        made_with_text,


        moviepy_clip,


    ]
)

######################
# CLIPS POSITIONNING #
######################
# Now that we have set the timing of our different clips, we need to make sure they are in the right position
# We will keep things simple, and almost always set center center for every texts
bird_text = bird_text.with_position(("center", "center"))
bunny_text = bunny_text.with_position(("center", "center"))
rodents_text = rodents_text.with_position(("center", "center"))
revenge_text = revenge_text.with_position(("center", "center"))
# For the logos and intro/end, we will use pixel position instead of center
top = intro_clip.h // 2
intro_text = intro_text.with_position(("center", 200))
logo_clip = logo_clip.with_position(("center", top))
made_with_text = made_with_text.with_position(("center", 300))
moviepy_clip = moviepy_clip.with_position(("center", 360))
# Lets take another look to check positions
quick_compo = CompositeVideoClip(


    [


        intro_clip,


        intro_text,


        logo_clip,


        bird_clip,


        bird_text,


        bunny_clip,


        bunny_text,


        rodents_clip,


        rodents_text,


        rambo_clip,


        revenge_text,


        made_with_text,


        moviepy_clip,


    ]
)

################################
# CLIPS TRANSITION AND EFFECTS #
################################
# Now that our clip are timed and positionned, lets add some transition to make it more natural
# To do so we use the with_effects method and the video effects in vfx
# We call with_effects on our clip and pass it an array of effect objects to apply
# We'll keep it simple, nothing fancy just cross fading
intro_text = intro_text.with_effects([vfx.CrossFadeIn(1), vfx.CrossFadeOut(1)])
logo_clip = logo_clip.with_effects([vfx.CrossFadeIn(1), vfx.CrossFadeOut(1)])
bird_text = bird_text.with_effects([vfx.CrossFadeIn(0.5), vfx.CrossFadeOut(0.5)])
bunny_text = bunny_text.with_effects([vfx.CrossFadeIn(0.5), vfx.CrossFadeOut(0.5)])
rodents_text = rodents_text.with_effects([vfx.CrossFadeIn(0.5), vfx.CrossFadeOut(0.5)])
# Also add cross fading on video clips and video clips audio
# See how video effects are under vfx and audio ones under afx
intro_clip = intro_clip.with_effects(


    [vfx.FadeIn(1), vfx.FadeOut(1), afx.AudioFadeIn(1), afx.AudioFadeOut(1)]
)
bird_clip = bird_clip.with_effects(


    [vfx.FadeIn(1), vfx.FadeOut(1), afx.AudioFadeIn(1), afx.AudioFadeOut(1)]
)
bunny_clip = bunny_clip.with_effects(


    [vfx.FadeIn(1), vfx.FadeOut(1), afx.AudioFadeIn(1), afx.AudioFadeOut(1)]
)
rodents_clip = rodents_clip.with_effects(


    [


        vfx.FadeIn(1),


        vfx.CrossFadeOut(1.5),


        afx.AudioFadeIn(1),


        afx.AudioFadeOut(1.5),


    ]
)  # Just fade in, rambo clip will do the cross fade
rambo_clip = rambo_clip.with_effects(


    [


        vfx.CrossFadeIn(1.5),


        vfx.FadeOut(1),


        afx.AudioFadeIn(1.5),


        afx.AudioFadeOut(1),


    ]
)
rambo_clip = rambo_clip.with_effects(


    [


        vfx.CrossFadeIn(1.5),


        vfx.FadeOut(1),


        afx.AudioFadeIn(1.5),


        afx.AudioFadeOut(1),


    ]
)
# Effects are not only for transition, they can also change a clip timing or appearance
# To show that, lets also modify the Rambo-like part of our clip to be in slow motion
# PS: We do it for effect, but this is one of the few effects that have a direct shortcut, with_speed_scaled
# the others are with_volume_scaled, resized, cropped and rotated
rambo_clip = rambo_clip.with_effects([vfx.MultiplySpeed(0.5)])
# Because we modified timing of rambo_clip with our MultiplySpeed effect, we must re-assign the following clips timing
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)
# Let's have a last look at the result to make sure everything is working as expected
quick_comp = CompositeVideoClip(


    [

We won't get into details, but know that in MoviePy, you can declare some sections of a video clip to be transparent by using masks. Masks are nothing more than special kinds of video clips that are made of values ranging from 0 for a transparent pixel to 1 for a fully opaque one.

For more info, see Mask Clips <#loading-masks>.

What you need to remember is just that we can apply filters on images. Here we do it mathematically, but you could very well use a library such as Pillow (provided it can understand numpy images) to do the maths for you!

        logo_clip,


        bird_clip,


        bird_text,


        bunny_clip,


        bunny_text,


        rodents_clip,


        rodents_text,


        rambo_clip,


        revenge_text,


        made_with_text,


        moviepy_clip,


    ]
)
quick_comp.preview(fps=10)
###############
# CLIP FILTER #
###############
# Lets finish by modifying our rambo clip to make it sepia
# We will start by defining a function that turn a numpy image into sepia
# It takes the image as numpy array in entry and return the modified image as output
def sepia_filter(frame: np.ndarray):


    # Sepia filter transformation matrix


    # Sepia transform works by applying to each pixel of the image the following rules


    # res_R = (R * .393) + (G *.769) + (B * .189)


    # res_G = (R * .349) + (G *.686) + (B * .168)


    # res_B = (R * .272) + (G *.534) + (B * .131)


    #


    # With numpy we can do that very efficiently by multiplying the image matrix by a transformation matrix


    sepia_matrix = np.array(


        [[0.393, 0.769, 0.189], [0.349, 0.686, 0.168], [0.272, 0.534, 0.131]]


    )


    # Convert the image to float32 format for matrix multiplication


    frame = frame.astype(np.float32)


    # Apply the sepia transformation


    # .T is needed because multiplying matrix of shape (n,m) * (m,k) result in a matrix of shape (n,k)


    # what we want is (n,m), so we must transpose matrix (m,k) to (k,m)

    # Because final result can be > 255, we limit the result to range [0, 255]


    sepia_image = np.clip(sepia_image, 0, 255)


    # Convert the image back to uint8 format, because we need integer not float


    sepia_image = sepia_image.astype(np.uint8)


    return sepia_image
# Now, we simply apply the filter to our clip by calling image_transform, which will call our filter on every frame
rambo_clip = rambo_clip.image_transform(sepia_filter)
# Let's see how our filter look
rambo_clip.preview(fps=10)
##################
# CLIP RENDERING #
##################
# Everything is good and ready, we can finally render our clip into a file
final_clip = CompositeVideoClip(


    [

docker run -w /moviepy -it moviepy python -m pytest

docker exec -it moviepy python myscript.py

docker run -it moviepy bash
python myscript.py

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

from moviepy import *  # Simple and clean; the __all__ is set in moviepy, so only useful things will be loaded
from moviepy import VideoFileClip  # You can also import only the things you really need

import numpy as np
from moviepy import (


    AudioClip,


    AudioFileClip,


    ColorClip,


    ImageClip,


    ImageSequenceClip,


    TextClip,


    VideoClip,


    VideoFileClip,
)
# Define some constants for later use
black = (255, 255, 255)  # RGB for black
def frame_function(t):


    """Random noise image of 200x100"""


    return np.random.randint(low=0, high=255, size=(100, 200, 3))
def frame_function_audio(t):


    """A note by producing a sinewave of 440 Hz"""


    return np.sin(440 * 2 * np.pi * t)
# Now lets see how to load different type of resources !
# VIDEO CLIPS
# 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)
# AUDIO CLIPS
# 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)

from moviepy import *
# clip.close() is implicitly called, so the lock on my_audiofile.mp3 file
# is immediately released.
try:


    with AudioFileClip("example.wav") as clip:


        raise Exception("Let's simulate an exception")
except Exception as e:


    print("{}".format(e))

import math
import numpy as np
from PIL import Image, ImageDraw
from moviepy import VideoClip
WIDTH, HEIGHT = (128, 128)
RED = (255, 0, 0)
def frame_function(t):


    frequency = 1  # One pulse per second


    coef = 0.5 * (1 + math.sin(2 * math.pi * frequency * t))  # radius varies over time


    radius = WIDTH * coef


    x1 = WIDTH / 2 - radius / 2


    y1 = HEIGHT / 2 - radius / 2


    x2 = WIDTH / 2 + radius / 2


    y2 = HEIGHT / 2 + radius / 2


    img = Image.new("RGB", (WIDTH, HEIGHT))


    draw = ImageDraw.Draw(img)


    draw.ellipse((x1, y1, x2, y2), fill=RED)


    return np.array(img)  # returns a 8-bit RGB array
# we define a 2s duration for the clip to be able to render it later
clip = VideoClip(frame_function, duration=2)
# we must set a framerate because VideoClip have no framerate by default
clip.write_gif("circle.gif", fps=15)

from moviepy import VideoFileClip
myclip = VideoFileClip("example.mp4")
# video file clips already have fps and duration
print("Clip duration: {}".format(myclip.duration))
print("Clip fps: {}".format(myclip.fps))
myclip = myclip.subclipped(0.5, 2)  # Cutting the clip between 0.5 and 2 secs.
print("Clip duration: {}".format(myclip.duration))  # Cuting will update duration
print("Clip fps: {}".format(myclip.fps))  # and keep fps
# the output video will be 1.5 sec long and use original fps
myclip.write_videofile("result.mp4")

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))
# This time we will load all images in the dir, and instead of showing theme
# for X seconds, we will define FPS
myclip2 = ImageSequenceClip("./example_img_dir", fps=30)
# fps = 30, so duration = nb images in dir / 30
print("Clip duration: {}".format(myclip2.duration))
print("Clip fps: {}".format(myclip2.fps))  # fps = 30
# the gif will be 30 fps, its duration will depend on the number of
# images in dir
myclip.write_gif("result.gif")  # the gif will be 3 sec and 1 fps
myclip2.write_gif("result2.gif")

"""Let's make a clip where frames depend on values in a list"""
from moviepy import DataVideoClip
import numpy as np
# Dataset will just be a list of colors as RGB
dataset = [


    (255, 0, 0),


    (0, 255, 0),


    (0, 0, 255),


    (0, 255, 255),


    (255, 0, 255),


    (255, 255, 0),
]
# The function make frame take data and create an image of 200x100 px
# filled with the color given in the dataset
def frame_function(data):


    frame = np.full((100, 200, 3), data, dtype=np.uint8)


    return frame
# We create the DataVideoClip, and we set FPS at 2, making a 3s clip
# (because len(dataset) = 6, so 6/2=3)
myclip = DataVideoClip(data=dataset, data_to_frame=frame_function, fps=2)
# Modifying fps here will change video FPS, not clip FPS
myclip.write_videofile("result.mp4", fps=30)

import random
import numpy as np
from moviepy import UpdatedVideoClip
class CoinFlipWorld:


    """A simulation of coin flipping.


    Imagine we want to make a video that become more and more red as we repeat same face


    on coinflip in a row because coinflip are done in real time, we need to wait


    until a winning row is done to be able to make the next frame.


    This is a world simulating that. Sorry, it's hard to come up with examples...


    """


    def __init__(self, fps):


        """


        FPS is usefull because we must increment clip_t by 1/FPS to have


        UpdatedVideoClip run with a certain FPS


        """


        self.clip_t = 0


        self.win_strike = 0


        self.reset = False


        self.fps = fps


    def update(self):


        if self.reset:


            self.win_strike = 0


            self.reset = False


        print("strike : {}, clip_t : {}".format(self.win_strike, self.clip_t))


        print(self.win_strike)


        # 0 tails, 1 heads, this is our simulation of coinflip


        choice = random.randint(0, 1)


        face = random.randint(0, 1)


        # We win, we increment our serie and retry


        if choice == face:


            self.win_strike += 1


            return


        # Different face, we increment clip_t and set reset so we will reset on next update.


        # We don't reset immediately because we will need current state to make frame


        self.reset = True


        self.clip_t += 1 / self.fps


    def to_frame(self):


        """Return a frame of a 200x100 image with red more or less intense based


        on number of victories in a row."""


        red_intensity = 255 * (self.win_strike / 10)


        red_intensity = min(red_intensity, 255)


        # A 200x100 image with red more or less intense based on number of victories in a row


        return np.full((100, 200, 3), (red_intensity, 0, 0), dtype=np.uint8)
world = CoinFlipWorld(fps=5)
myclip = UpdatedVideoClip(world=world, duration=10)
# We will set FPS to same as world, if we was to use a different FPS,
# the lowest from world.fps and our write_videofile fps param
# will be the real visible fps
myclip.write_videofile("result.mp4", fps=5)

"""Here's how you transform a VideoClip into an ImageClip from an image, from
arbitrary data, or by extracting a frame at a given time"""
from moviepy import ImageClip, VideoFileClip
import numpy as np
# Random RGB noise image of 200x100
noise_image = np.random.randint(low=0, high=255, size=(100, 200, 3))
myclip1 = ImageClip("example.png")  # You can create it from a path
myclip2 = ImageClip(noise_image)  # from a (height x width x 3) RGB numpy array
# Or load videoclip and extract frame at a given time
myclip3 = VideoFileClip("./example.mp4").to_ImageClip(t="00:00:01")

from moviepy import TextClip
font = "./example.ttf"
# First we use as string and let system autocalculate clip dimensions to fit the text
# we set clip duration to 2 secs, if we do not, it got an infinite duration
txt_clip1 = TextClip(


    font=font,


    text="Hello World !",


    font_size=30,


    color="#FF0000",  # Red


    bg_color="#FFFFFF",


    duration=2,
)
# This time we load text from a file, we set a fixed size for clip and let the system find best font size,
# allowing for line breaking
txt_clip2 = TextClip(


    font=font,


    filename="./example.txt",


    size=(500, 200),


    bg_color="#FFFFFF",


    method="caption",


    color=(0, 0, 255, 127),
)  # Blue with 50% transparency
# we set duration, because by default image clip are infinite, and we cannot render infinite
txt_clip2 = txt_clip2.with_duration(2)
# ImageClip have no FPS either, so we must defined it
txt_clip1.write_videofile("result1.mp4", fps=24)
txt_clip2.write_videofile("result2.mp4", fps=24)

from moviepy import ColorClip
# Color is passed as a RGB tuple
myclip = ColorClip(size=(200, 100), color=(255, 0, 0), duration=1)
# We really don't need more than 1 fps do we ?
myclip.write_videofile("result.mp4", fps=1)

import numpy as np
from moviepy import ImageClip, VideoClip, VideoFileClip
# Random RGB noise image of 200x100
frame_function = lambda t: np.random.rand(100, 200)
# To define the VideoClip as a mask, just pass parameter is_mask as True
maskclip1 = VideoClip(frame_function, duration=4, is_mask=True)  # A random noise mask
maskclip2 = ImageClip("example_mask.jpg", is_mask=True)  # A fixed mask as jpeg
maskclip3 = VideoFileClip("example_mask.mp4", is_mask=True)  # A video as a mask
# Load our basic clip, resize to 200x100 and apply each mask
clip = VideoFileClip("example.mp4")
clip_masked1 = clip.with_mask(maskclip1)
clip_masked2 = clip.with_mask(maskclip2)
clip_masked3 = clip.with_mask(maskclip3)

Also, when you load an image with an alpha layer, like a PNG, MoviePy will use this layer as a mask unless you pass transparent=False.

from moviepy import AudioClip
import numpy as np
def audio_frame(t):


    """Producing a sinewave of 440 Hz -> note A"""


    return np.sin(440 * 2 * np.pi * t)
audio_clip = AudioClip(frame_function=audio_frame, duration=3)

from moviepy import *
# Works for audio files, but also videos file where you only want the keep the audio track
clip = AudioFileClip("example.wav")
clip.write_audiofile("./result.wav")

"""Let's create an audioclip from values in a numpy array."""
import numpy as np
from moviepy import AudioArrayClip
# We want to play these notes
notes = {"A": 440, "B": 494, "C": 523, "D": 587, "E": 659, "F": 698}
note_duration = 0.5
total_duration = len(notes) * note_duration
sample_rate = 44100  # Number of samples per second
note_size = int(note_duration * sample_rate)
n_frames = note_size * len(notes)
def frame_function(t, note_frequency):


    return np.sin(note_frequency * 2 * np.pi * t)
# At this point one could use this audioclip which generates the audio on the fly
# clip = AudioFileClip(frame_function)
# We generate all frames timepoints
audio_frame_values = [


    2 * [frame_function(t, freq)]


    for freq in notes.values()


    for t in np.arange(0, note_duration, 1.0 / sample_rate)
]
# Create an AudioArrayClip from the audio samples
audio_clip = AudioArrayClip(np.array(audio_frame_values), fps=sample_rate)
# Write the audio clip to a WAV file
audio_clip.write_audiofile("result.wav", fps=44100)

• The built-in methods of VideoClip <#moviepy.video.VideoClip.VideoClip> or AudioClip <#moviepy.audio.AudioClip.AudioClip> modifying the properties of the object.
• The already-implemented effects of MoviePy you can apply on clips, usually affecting the clip by applying filters on each frame of the clip at rendering time.
• The transformation filters that you can apply using transform() <#moviepy.Clip.Clip.transform> and time_transform() <#moviepy.Clip.Clip.time_transform>.

# Import everything needed to edit video clips
from moviepy import VideoFileClip
# Load example.mp4
clip = VideoFileClip("example.mp4")
# This does nothing, as multiply_volume will return a copy of clip
# which you will loose immediatly as you don't store it
# If you was to render clip now, the audio would still be at full volume
clip.with_volume_scaled(0.1)
# This create a copy of clip in clip_whisper with a volume of only 10% the original,
# but does not modify the original clip
# If you was to render clip right now, the audio would still be at full volume
# If you was to render clip_whisper, the audio would be a 10% of the original volume
clip_whisper = clip.with_volume_scaled(0.1)
# This replace the original clip with a copy of it where volume is only 10% of
# the original. If you was to render clip now, the audio would be at 10%
# The original clip is now lost
clip = clip.with_volume_scaled(0.1)

from moviepy import VideoFileClip
myclip = VideoFileClip("example.mp4")
myclip = myclip.with_end(5)  # stop the clip after 5 sec
myclip = myclip.without_audio()  # remove the audio of the clip

from moviepy import VideoFileClip
from moviepy import vfx, afx
myclip = VideoFileClip("example.mp4")
# resize clip to be 460px in width, keeping aspect ratio
myclip = myclip.with_effects([vfx.Resize(width=460)])
# fx method return a copy of the clip, so we can easily chain them
# double the speed and half the audio volume
myclip = myclip.with_effects([vfx.MultiplySpeed(2), afx.MultiplyVolume(0.5)])
# because effects are added to Clip at runtime, you can also call
# them directly from your clip as methods
myclip = myclip.with_effects([vfx.MultiplyColor(0.5)])  # darken the clip

from moviepy import VideoFileClip
import math
my_clip = VideoFileClip("example.mp4")
# Let's accelerate the video by a factor of 3
modified_clip1 = my_clip.time_transform(lambda t: t * 3)
# Let's play the video back and forth with a "sine" time-warping effect
modified_clip2 = my_clip.time_transform(lambda t: 1 + math.sin(t))

If you wish to also modify audio and/or mask you can provide the parameter apply_to with either 'audio', 'mask', or ['audio', 'mask'].

"""Let's invert the green and blue channels of a video."""
from moviepy import VideoFileClip
import numpy
my_clip = VideoFileClip("example.mp4")
def invert_green_blue(image: numpy.ndarray) -> numpy.ndarray:


    return image[:, :, [0, 2, 1]]
modified_clip1 = my_clip.image_transform(invert_green_blue)

"""Let's create a scolling video effect from scratch."""
from moviepy import VideoFileClip
my_clip = VideoFileClip("example.mp4")
def scroll(get_frame, t):


    """


    This function returns a 'region' of the current frame.


    The position of this region depends on the time.


    """


    frame = get_frame(t)


    frame_region = frame[int(t) : int(t) + 360, :]


    return frame_region
modified_clip1 = my_clip.transform(scroll)

"""Let's write a custom effect that will add a basic progress bar
at the bottom of our clip."""
from moviepy import VideoClip
from moviepy.decorators import requires_duration
# Here you see a decorator that will verify if our clip have a duration
# MoviePy offer a few of them that may come handy when writing your own effects
@requires_duration
def progress_bar(clip: VideoClip, color: tuple, height: int = 10):


    """


    Add a progress bar at the bottom of our clip


     Parameters


    ----------


      color: Color of the bar as a RGB tuple


      height: The height of the bar in pixels. Default = 10


    """


    # Because we have define the filter func inside our global effect,


    # it have access to global effect scope and can use clip from inside filter


    def filter(get_frame, t):


        progression = t / clip.duration


        bar_width = int(progression * clip.w)


        # Showing a progress bar is just replacing bottom pixels


        # on some part of our frame


        frame = get_frame(t)


        frame[-height:, 0:bar_width] = color


        return frame


    return clip.transform(filter, apply_to="mask")

"""Let's concatenate (play one after the other) three video clips."""
from moviepy import VideoFileClip, concatenate_videoclips
# We load all the clips we want to concatenate
clip1 = VideoFileClip("example.mp4")
clip2 = VideoFileClip("example2.mp4").subclipped(0, 1)
clip3 = VideoFileClip("example3.mp4")
# We concatenate them and write the result
final_clip = concatenate_videoclips([clip1, clip2, clip3])
final_clip.write_videofile("final_clip.mp4")

"""Let's juxtapose four video clips in a 2x2 grid."""
from moviepy import VideoFileClip, clips_array, vfx
# We will use the same clip and transform it in 3 ways
clip1 = VideoFileClip("example.mp4").with_effects([vfx.Margin(10)])  # add 10px contour
clip2 = clip1.with_effects([vfx.MirrorX()])  # Flip horizontaly
clip3 = clip1.with_effects([vfx.MirrorY()])  # Flip verticaly
clip4 = clip1.resized(0.6)  # downsize to 60% of original
# The form of the final clip will depend of the shape of the array
# We want our clip to be our 4 videos, 2x2, so we make an array of 2x2
array = [


    [clip1, clip2],


    [clip3, clip4],
]
final_clip = clips_array(array)
# let's resize the final clip so it has 480px of width
final_clip = final_clip.resized(width=480)
final_clip.write_videofile("final_clip.mp4")

"""Let's stack three video clips on top of each other with
CompositeVideoClip."""
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("example.mp4")
# We concatenate them and write theme stacked on top of each other,
# with clip3 over clip2 over clip1
final_clip = CompositeVideoClip([clip1, clip2, clip3])
final_clip.write_videofile("final_clip.mp4")

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")

"""Let's position some text and images on a video."""
from moviepy import CompositeVideoClip, ImageClip, TextClip, VideoFileClip
# We load all the clips we want to compose
background = VideoFileClip("example2.mp4").subclipped(0, 2)
title = TextClip(


    "./example.ttf",


    text="Big Buck Bunny",


    font_size=80,


    color="#fff",


    text_align="center",


    duration=1,
)
author = TextClip(


    "./example.ttf",


    text="Blender Foundation",


    font_size=40,


    color="#fff",


    text_align="center",


    duration=1,
)
copyright = TextClip(


    "./example.ttf",


    text="© CC BY 3.0",


    font_size=20,


    color="#fff",


    text_align="center",


    duration=1,
)
logo = ImageClip("./example2.png", duration=1).resized(height=50)
# We want our title to be at the center horizontaly and start at 25%
# of the video verticaly. We can set as "center", "left", "right",
# "top" and "bottom", and % relative from the clip size
title = title.with_position(("center", 0.25), relative=True)
# We want the author to be in the center, 30px under the title
# We can set as pixels
top = background.h * 0.25 + title.h + 30
left = (background.w - author.w) / 2
author = author.with_position((left, top))
# We want the copyright to be 30px before bottom
copyright = copyright.with_position(("center", background.h - copyright.h - 30))
# Finally, we want the logo to be in the center, but to drop as time pass
# We can do so by setting position as a function that take time as argument,
# a lot like frame_function
top = (background.h - logo.h) / 2
logo = logo.with_position(lambda t: ("center", top + t * 30))
# We write the result
final_clip = CompositeVideoClip([background, title, author, copyright, logo])
final_clip.write_videofile("final_clip.mp4")

"""In this example, we will concatenate two clips with a 1-second
crossfadein of the second clip."""
from moviepy import VideoFileClip, CompositeVideoClip, vfx
# We load all the clips we want to compose
clip1 = VideoFileClip("example.mp4")
clip2 = VideoFileClip("example2.mp4")
clips = [


    clip1.with_end(2),


    clip2.with_start(1).with_effects([vfx.CrossFadeIn(1)]),
]
final_clip = CompositeVideoClip(clips)
final_clip.write_videofile("final_clip.mp4")

"""Let's first concatenate (one after the other) then composite
(on top of each other) three audio clips."""
from moviepy import AudioFileClip, CompositeAudioClip, concatenate_audioclips
# We load all the clips we want to compose
clip1 = AudioFileClip("example.wav")
clip2 = AudioFileClip("example2.wav")
clip3 = AudioFileClip("example3.wav")
# All clip will play one after the other
concat = concatenate_audioclips([clip1, clip2, clip3])
# We will play clip1, then on top of it clip2 starting at t=5s,
# and clip3 on top of both starting t=9s
compo = CompositeAudioClip(


    [


        clip1.with_volume_scaled(1.2),


        clip2.with_start(5),  # start at t=5s


        clip3.with_start(9),


    ]
)

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)

Don't hesitate to play with the options of preview: for instance, lower the fps of the sound (11000 Hz is still fine) and the video. Also, downsizing your video with resize() can help.

from moviepy import *
myclip = VideoFileClip("./example.mp4")
# We show the first frame of our clip
myclip.show()
# We show the frame at point 00:00:01.5 of our clip
myclip.show(1.5)
# We want to see our clip without applying his mask
myclip.show(1.5, with_mask=False)

from moviepy import *
# ...
# ... some jupyter specifics stuff
# ...
my_video_clip = VideoFileClip("./example.mp4")
my_image_clip = ImageClip("./example.png")
my_audio_clip = AudioFileClip("./example.wav")
# We can show any type of clip
my_video_clip.display_in_notebook()  # embeds a video
my_image_clip.display_in_notebook()  # embeds an image
my_audio_clip.display_in_notebook()  # embeds a sound
# We can display only a snaphot of a video
my_video_clip.display_in_notebook(t=1)
# We can provide any valid HTML5 option as keyword argument
# For instance, if the clip is too big, we can set width
my_video_clip.display_in_notebook(width=400)
# We can also make it loop, for example to check if a GIF is
# looping as expected
my_video_clip.display_in_notebook(autoplay=1, loop=1)

Also, note that display_in_notebook() <#moviepy.video.io.display_in_notebook.display_in_notebook> actually embeds the clips physically in your notebook. The advantage is that you can move the notebook or put it online and the videos will work. However, the drawback is that the file size of the notebook can become very large. Depending on your browser, re-computing and displaying the video multiple times can take up space in the cache and the RAM (this will only be a problem for intensive uses). Restarting your browser solves the problem.

from moviepy import *
# We load all the clips we want to compose
background = VideoFileClip("long_examples/example2.mp4").subclipped(0, 10)
title = TextClip(


    "./example.ttf",


    text="Big Buck Bunny",


    font_size=80,


    color="#fff",


    text_align="center",


    duration=3,
).with_position(("center", "center"))
# We make our final clip through composition
final_clip = CompositeVideoClip([background, title])
# And finally we can write the result into a file
# Here we just save as MP4, inheriting FPS, etc. from final_clip
final_clip.write_videofile("result.mp4")
# Here we save as MP4, but we set the FPS of the clip to our own, here 24 fps, like cinema
final_clip.write_videofile("result24fps.mp4", fps=24)
# Now we save as WEBM instead, and we want tu use codec libvpx-vp9 (usefull when mp4 + transparency).
# We also want ffmpeg compression optimisation as minimal as possible. This will not change
# the video quality and it will decrease time for encoding, but increase final file size a lot.
# Finally, we want ffmpeg to use 4 threads for video encoding. You should probably leave that
# to default, as ffmpeg is already quite good at using the best setting on his own.
final_clip.write_videofile(


    "result.webm", codec="libvpx-vp9", fps=24, preset="ultrafast", threads=4
)

Also, know that it is possible to pass additional parameters to the ffmpeg command line invoked by MoviePy by using the ffmpeg_params argument.

from moviepy import *
# By default an ImageClip has no duration
my_clip = ImageClip("example.png")
try:


    # This will fail! We cannot write a clip with no duration!


    my_clip.write_videofile("result.mp4")
except:


    print("Cannot write a video without duration")
# By calling with_duration on our clip, we fix the problem! We also need to set fps
my_clip.with_duration(2).write_videofile("result.mp4", fps=1)

from moviepy import *
# We load all the clips we want to compose
myclip = VideoFileClip("example.mp4")
myclip.save_frame("result.png", t=1)  # Save frame at 1 sec

from moviepy import *
myclip = VideoFileClip("example.mp4").subclipped(0, 2)
# Here we just save as GIF
myclip.write_gif("result.gif")
# Here we save as GIF, but we set the FPS of our GIF at 10
myclip.write_gif("result.gif", fps=10)

from moviepy import *
import os
myclip = VideoFileClip("example.mp4")
# Here we just save in dir output with filename being his index (start at 0, then +1 for each frame)
os.mkdir("./output")
myclip.write_images_sequence("./output/%d.jpg")
# We set the FPS of our GIF at 10, and we leftpad name with 0 up to 4 digits
myclip.write_images_sequence("./output/%04d.jpg")

start

When the clip is included in a composition, time of the composition at which the clip starts playing (in seconds).

end

When the clip is included in a composition, time of the composition at which the clip stops playing (in seconds).

duration

Duration of the clip (in seconds). Some clips are infinite, in this case their duration will be None.

close()

Release any resources that are in use.

copy()

Allows the usage of .copy() in clips as chained methods invocation.

get_frame(t) -> ndarray

Gets a numpy array representing the RGB picture of the clip, or (mono or stereo) value for a sound clip, at time t.

is_playing(t)

If t is a time, returns true if t is between the start and the end of the clip. t can be expressed in seconds (15.35), in (min, sec), in (hour, min, sec), or as a string: '01:03:05.35'. If t is a numpy array, returns False if none of the t is in the clip, else returns a vector [b_1, b_2, b_3...] where b_i is true if tti is in the clip.

iter_frames(fps=None, with_times=False, logger=None, dtype=None)

Iterates over all the frames of the clip.

Returns each frame of the clip as a HxWxN Numpy array, where N=1 for mask clips and N=3 for RGB clips.

This function is not really meant for video editing. It provides an easy way to do frame-by-frame treatment of a video, for fields like science, computer vision...

Examples

# prints the maximum of red that is contained
# on the first line of each frame of the clip.
from moviepy import VideoFileClip
myclip = VideoFileClip('myvideo.mp4')
print([frame[0,:,0].max()


      for frame in myclip.iter_frames()])

subclipped(start_time=0, end_time=None)

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].

time_transform(time_func, apply_to=None, keep_duration=False)

Returns a Clip instance playing the content of the current clip but with a modified timeline, time t being replaced by the return of time_func(t).

Examples

# plays the clip (and its mask and sound) twice faster
new_clip = clip.time_transform(lambda t: 2*t, apply_to=['mask', 'audio'])
# plays the clip starting at t=3, and backwards:
new_clip = clip.time_transform(lambda t: 3-t)

transform(func, apply_to=None, keep_duration=True)

General processing of a clip.

Returns a new Clip whose frames are a transformation (through function func) of the frames of the current clip.

Examples

In the following new_clip a 100 pixels-high clip whose video content scrolls from the top to the bottom of the frames of clip at 50 pixels per second.

>>> filter = lambda get_frame,t : get_frame(t)[int(t):int(t)+50, :]
>>> new_clip = clip.transform(filter, apply_to='mask')

with_duration(duration, change_end=True)

Returns a copy of the clip, with the duration attribute set to t, which can be expressed in seconds (15.35), in (min, sec), in (hour, min, sec), or as a string: '01:03:05.35'. Also sets the duration of the mask and audio, if any, of the returned clip.

If change_end is False, the start attribute of the clip will be modified in function of the duration and the preset end of the clip.

with_effects(effects: List[Effect <#moviepy.Effect.Effect>])

Return a copy of the current clip with the effects applied

>>> new_clip = clip.with_effects([vfx.Resize(0.2, method="bilinear")])
    

You can also pass multiple effect as a list

>>> clip.with_effects([afx.VolumeX(0.5), vfx.Resize(0.3), vfx.Mirrorx()])
    

with_end(t)

Returns a copy of the clip, with the end attribute set to t, which can be expressed in seconds (15.35), in (min, sec), in (hour, min, sec), or as a string: '01:03:05.35'. Also sets the duration of the mask and audio, if any, of the returned clip.

with_fps(fps, change_duration=False)

Returns a copy of the clip with a new default fps for functions like write_videofile, iterframe, etc.

with_is_mask(is_mask)

Says whether the clip is a mask or not.

with_memoize(memoize)

Sets whether the clip should keep the last frame read in memory.

with_section_cut_out(start_time, end_time)

Returns a clip playing the content of the current clip but skips the extract between 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'.

If the original clip has a duration attribute set, the duration of the returned clip is automatically computed as `` duration - (end_time - start_time)``.

The resulting clip's audio and mask will also be cutout if they exist.

with_speed_scaled(factor: float = None, final_duration: float = None)

Returns a clip playing the current clip but at a speed multiplied by factor. For info on the parameters, please see vfx.MultiplySpeed.

with_start(t, change_end=True)

Returns a copy of the clip, with the start attribute set to t, which can be expressed in seconds (15.35), in (min, sec), in (hour, min, sec), or as a string: '01:03:05.35'.

These changes are also applied to the audio and mask clips of the current clip, if they exist.

with_updated_frame_function(frame_function)

Sets a frame_function attribute for the clip. Useful for setting arbitrary/complicated videoclips.

with_volume_scaled(factor: float, start_time=None, end_time=None)

Returns a new clip with audio volume multiplied by the value factor. For info on the parameters, please see afx.MultiplyVolume

abstractmethod apply(clip: Clip <#moviepy.Clip.Clip>) -> Clip <#moviepy.Clip.Clip>

Apply the current effect on a clip

copy()

Return a shallow copy of an Effect.

You must always copy an Effect before applying, because some of them will modify their own attributes when applied. For example, setting a previously unset property by using target clip property.

If we was to use the original effect, calling the same effect multiple times could lead to different properties, and different results for equivalent clips.

By using copy, we ensure we can use the same effect object multiple times while maintaining the same behavior/result.

In a way, copy makes the effect himself being kind of idempotent.

Parameters

Parameters

audiopreview(fps=None, buffersize=2000, nbytes=2, audio_flag=None, video_flag=None)

Preview an AudioClip using ffplay

display_in_notebook(filetype=None, maxduration=60, t=None, fps=None, rd_kwargs=None, center=True, **html_kwargs)

Displays clip content in an Jupyter Notebook.

Remarks: If your browser doesn't support HTML5, this should warn you. If nothing is displayed, maybe your file or filename is wrong. Important: The media will be physically embedded in the notebook.

Examples

from moviepy import *
# later ...
clip.display_in_notebook(width=360)
clip.audio.display_in_notebook()
clip.write_gif("test.gif")
display_in_notebook('test.gif')
clip.save_frame("first_frame.jpeg")
display_in_notebook("first_frame.jpeg")

iter_chunks(chunksize=None, chunk_duration=None, fps=None, quantize=False, nbytes=2, logger=None)

Iterator that returns the whole sound array of the clip by chunks

max_volume(stereo=False, chunksize=50000, logger=None)

Returns the maximum volume level of the clip.

to_soundarray(tt=None, fps=None, quantize=False, nbytes=2, buffersize=50000)

Transforms the sound into an array that can be played by pygame or written in a wav file. See AudioClip.preview.

write_audiofile(filename, fps=None, nbytes=2, buffersize=2000, codec=None, bitrate=None, ffmpeg_params=None, write_logfile=False, logger='bar')

Writes an audio file from the AudioClip.

Parameters

clips -- List of audio clips, which may start playing at different times or together, depends on their start attributes. If all have their duration attribute set, the duration of the composite clip is computed automatically.

property ends

Returns ending times for all clips in the composition.

frame_function(t)

Renders a frame for the composition for the time t.

property starts

Returns starting times for all clips in the composition.

Parameters

clips -- List of audio clips, which will be played one after other.

Parameters

apply(clip: Clip <#moviepy.Clip.Clip>) -> Clip <#moviepy.Clip.Clip>

Apply the effect to the clip.

copy()

Return a shallow copy of an Effect.

You must always copy an Effect before applying, because some of them will modify their own attributes when applied. For example, setting a previously unset property by using target clip property.

If we was to use the original effect, calling the same effect multiple times could lead to different properties, and different results for equivalent clips.

By using copy, we ensure we can use the same effect object multiple times while maintaining the same behavior/result.

In a way, copy makes the effect himself being kind of idempotent.

Parameters

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

apply(clip: Clip <#moviepy.Clip.Clip>) -> Clip <#moviepy.Clip.Clip>

Apply the effect to the clip.

copy()

Return a shallow copy of an Effect.

You must always copy an Effect before applying, because some of them will modify their own attributes when applied. For example, setting a previously unset property by using target clip property.

If we was to use the original effect, calling the same effect multiple times could lead to different properties, and different results for equivalent clips.

By using copy, we ensure we can use the same effect object multiple times while maintaining the same behavior/result.

In a way, copy makes the effect himself being kind of idempotent.

Parameters

duration (float) -- How long does it take for the sound to reach the zero level at the end of the clip.

apply(clip: Clip <#moviepy.Clip.Clip>) -> Clip <#moviepy.Clip.Clip>

Apply the effect to the clip.

copy()

Return a shallow copy of an Effect.

You must always copy an Effect before applying, because some of them will modify their own attributes when applied. For example, setting a previously unset property by using target clip property.

If we was to use the original effect, calling the same effect multiple times could lead to different properties, and different results for equivalent clips.

By using copy, we ensure we can use the same effect object multiple times while maintaining the same behavior/result.

In a way, copy makes the effect himself being kind of idempotent.

apply(clip: Clip <#moviepy.Clip.Clip>) -> Clip <#moviepy.Clip.Clip>

Apply the effect to the clip.

copy()

Return a shallow copy of an Effect.

You must always copy an Effect before applying, because some of them will modify their own attributes when applied. For example, setting a previously unset property by using target clip property.

If we was to use the original effect, calling the same effect multiple times could lead to different properties, and different results for equivalent clips.

By using copy, we ensure we can use the same effect object multiple times while maintaining the same behavior/result.

In a way, copy makes the effect himself being kind of idempotent.

apply(clip: Clip <#moviepy.Clip.Clip>) -> Clip <#moviepy.Clip.Clip>

Apply the effect to the clip.

copy()

Return a shallow copy of an Effect.

You must always copy an Effect before applying, because some of them will modify their own attributes when applied. For example, setting a previously unset property by using target clip property.

If we was to use the original effect, calling the same effect multiple times could lead to different properties, and different results for equivalent clips.

By using copy, we ensure we can use the same effect object multiple times while maintaining the same behavior/result.

In a way, copy makes the effect himself being kind of idempotent.

apply(clip: Clip <#moviepy.Clip.Clip>) -> Clip <#moviepy.Clip.Clip>

Apply the effect to the clip.

copy()

Return a shallow copy of an Effect.

You must always copy an Effect before applying, because some of them will modify their own attributes when applied. For example, setting a previously unset property by using target clip property.

If we was to use the original effect, calling the same effect multiple times could lead to different properties, and different results for equivalent clips.

By using copy, we ensure we can use the same effect object multiple times while maintaining the same behavior/result.

In a way, copy makes the effect himself being kind of idempotent.

Parameters

apply(clip: Clip <#moviepy.Clip.Clip>) -> Clip <#moviepy.Clip.Clip>

Apply the effect to the clip.

copy()

Return a shallow copy of an Effect.

You must always copy an Effect before applying, because some of them will modify their own attributes when applied. For example, setting a previously unset property by using target clip property.

If we was to use the original effect, calling the same effect multiple times could lead to different properties, and different results for equivalent clips.

By using copy, we ensure we can use the same effect object multiple times while maintaining the same behavior/result.

In a way, copy makes the effect himself being kind of idempotent.

Parameters

nbytes

Number of bits per frame of the original audio file.

fps

Number of frames per second in the audio file

buffersize

See Parameters.

audio_stream_index

The index of the audio stream to read from the file.

Lifetime

--------

Note that this creates subprocesses and locks files. If you construct one

of these instances, you must call close() afterwards, or the subresources

will not be cleaned up until the process ends.

close()

Close the internal reader.

Parameters

close()

Closes the writer, terminating the subprocess if is still alive.

write_frames(frames_array)

Send the audio frame (a chunck of AudioClip) to ffmpeg for writting

Parameters

close()

Closes the writer, terminating the subprocess if is still alive.

write_frames(frames_array)

Send a raw audio frame (a chunck of audio) to ffplay to be played

Parameters

Parameters

buffer_around(frame_number)

Fill the buffer with frames, centered on frame_number if possible.

close()

Closes the reader, terminating the subprocess if is still alive.

get_frame(tt)

Retrieve the audio frame(s) corresponding to the given timestamp(s).

initialize(start_time=0)

Opens the file, creates the pipe.

read_chunk(chunksize)

Read a chunk of audio data from the audio stream.

This method reads a chunk of audio data from the audio stream. The specified number of frames, given by chunksize, is read from the proc stdout. The audio data is returned as a NumPy array, where each row corresponds to a frame and each column corresponds to a channel. If there is not enough audio left to read, the remaining portion is padded with zeros, ensuring that the returned array has the desired length. The pos attribute is updated accordingly.

seek(pos)

Read a frame at time t. Note for coders: getting an arbitrary frame in the video with ffmpeg can be painfully slow if some decoding has to be done. This function tries to avoid fectching arbitrary frames whenever possible, by moving between adjacent frames.

skip_chunk(chunksize)

Skip a chunk of audio data by reading and discarding the specified number of frames from the audio stream. The audio stream is read from the proc stdout. After skipping the chunk, the pos attribute is updated accordingly.

Parameters

Parameters

•

types (Iterable, optional) -- Set of types of clips to close, being "audio", "video" or "image" the supported values.

Parameters

Returns

A tuple (x, y) representing the top-left corner of clip1 relative to clip2.

Return type

tuple[int, int]

•

creationflags=0x08000000: no extra unwanted window opens on Windows when the child process is created. Only added on Windows.

Returns

A function that does the same thing as func, but with a docstring and a printed message on call which say that the function is deprecated and that you should use func instead.

Return type

deprecated_func

Parameters

codec (str) -- Video or audio codec name.

..info::

Currently this only works for Linux/BSD systems with X11 or wayland. It probably works for SunOS, AIX and CYGWIN

to_bitmap(color_dict=None)

Returns a valid bitmap list that represents each frame of the clip. If color_dict is not specified, then it will use the same color_dict that was used to create the clip.

Parameters

Parameters

Parameters

img

Array representing the image of the clip.

image_transform(image_func, apply_to=None)

Image-transformation filter.

Does the same as VideoClip.image_transform, but for ImageClip the transformed clip is computed once and for all at the beginning, and not for each 'frame'.

time_transform(time_func, apply_to=None, keep_duration=False)

Time-transformation filter.

Applies a transformation to the clip's timeline (see Clip.time_transform).

This method does nothing for ImageClips (but it may affect their masks or their audios). The result is still an ImageClip.

transform(func, apply_to=None, keep_duration=True)

General transformation filter.

Equivalent to VideoClip.transform. The result is no more an ImageClip, it has the class VideoClip (since it may be animated)

Parameters

• text_align -- center | left | right. Text align similar to css. Default to left.
• horizontal_align -- center | left | right. Define horizontal align of text bloc in image. Default to center.
• vertical_align -- center | top | bottom. Define vertical align of text bloc in image. Default to center.
• interline -- Interline spacing. Default to 4.
• transparent -- True (default) if you want to take into account the transparency in the image.
• duration -- Duration of the clip
• note:: (..) --

  ** About final TextClip size **

  The final TextClip size will be of the absolute maximum height possible for the font and the number of line. It specifically mean that the final height might be a bit bigger than the real text height, i.e, absolute bottom pixel of text - absolute top pixel of text. This is because in a font, some letter go above standard top line (e.g letters with accents), and bellow standard baseline (e.g letters such as p, y, g).

  This notion is known under the name "ascent" and "descent" meaning the highest and lowest pixel above and below the baseline.

  If your first line doesn't have an "accent character" and your last line doesn't have a "descent character", you'll have some "fat" around.

Parameters

Parameters

size

The size of the clip, (width,height), in pixels.

w, h

The width and height of the clip, in pixels.

is_mask

Boolean set to True if the clip is a mask.

frame_function

A function t-> frame at time t where frame is a w*h*3 RGB array.

mask(default None)

audio(default None)

An AudioClip instance containing the audio of the video clip.

pos

A function t->(x,y) where x,y is the position of the clip when it is composed with other clips. See VideoClip.set_pos for more details

relative_pos

See variable pos.

layer

Indicates which clip is rendered on top when two clips overlap in a CompositeVideoClip. The highest number is rendered on top. Default is 0.

property aspect_ratio

Returns the aspect ratio of the video.

compose_mask(background_mask: ndarray, t: float) -> ndarray

Returns the result of the clip's mask at time t composited on the given background_mask, the position of the clip being given by the clip's pos attribute. Meant for compositing.

(warning: only use this function to blit two masks together, never images)

compose_on(background: ndarray, t, background_mask: ndarray | None = None) -> Tuple[ndarray, ndarray | None]

Returns the result of the clip's frame at time t on top on the given picture, the position of the clip being given by the clip's pos attribute. Meant for compositing.

If the clip/backgrounds have transparency the transparency will be accounted for.

The return is either a numpy array for image with no transparency or a tuple (image, mask) for image with transparency

copy()

Mixed copy of the clip.

Returns a shallow copy of the clip whose mask and audio will be shallow copies of the clip's mask and audio if they exist.

This method is intensively used to produce new clips every time there is an outplace transformation of the clip (clip.resize, clip.subclipped, etc.)

Acts like a deepcopy except for the fact that readers and other possible unpickleables objects are not copied.

cropped(x1: int = None, y1: int = None, x2: int = None, y2: int = None, width: int = None, height: int = None, x_center: int = None, y_center: int = None)

Returns a new clip in which just a rectangular subregion of the original clip is conserved. x1,y1 indicates the top left corner and x2,y2 is the lower right corner of the cropped region. All coordinates are in pixels. Float numbers are accepted. For info on the parameters, please see vfx.Crop

display_in_notebook(filetype=None, maxduration=60, t=None, fps=None, rd_kwargs=None, center=True, **html_kwargs)

Displays clip content in an Jupyter Notebook.

Remarks: If your browser doesn't support HTML5, this should warn you. If nothing is displayed, maybe your file or filename is wrong. Important: The media will be physically embedded in the notebook.

Examples

from moviepy import *
# later ...
clip.display_in_notebook(width=360)
clip.audio.display_in_notebook()
clip.write_gif("test.gif")
display_in_notebook('test.gif')
clip.save_frame("first_frame.jpeg")
display_in_notebook("first_frame.jpeg")

fill_array(pre_array, shape=(0, 0))

Fills an array to match the specified shape.

If the pre_array is smaller than the desired shape, the missing rows or columns are added with ones to the bottom or right, respectively, until the shape matches. If the pre_array is larger than the desired shape, the excess rows or columns are cropped from the bottom or right, respectively, until the shape matches.

The resulting array with the filled shape is returned.

property h

Returns the height of the video.

image_transform(image_func, apply_to=None)

Modifies the images of a clip by replacing the frame get_frame(t) by another frame, image_func(get_frame(t)).

property n_frames

Returns the number of frames of the video.

preview(fps=15, audio=True, audio_fps=22050, audio_buffersize=3000, audio_nbytes=2)

Displays the clip in a window, at the given frames per second.

It will avoid that the clip be played faster than normal, but it cannot avoid the clip to be played slower than normal if the computations are complex. In this case, try reducing the fps.

Examples

from moviepy import *
clip = VideoFileClip("media/chaplin.mp4")
clip.preview(fps=10, audio=False)

resized(new_size=None, height=None, width=None, apply_to_mask=True)

Returns a video clip that is a resized version of the clip. For info on the parameters, please see vfx.Resize

rotated(angle: float, unit: str = 'deg', resample: str = 'bicubic', expand: bool = False, center: tuple = None, translate: tuple = None, bg_color: tuple = None)

Rotates the specified clip by angle degrees (or radians) anticlockwise If the angle is not a multiple of 90 (degrees) or center, translate, and bg_color are not None. For info on the parameters, please see vfx.Rotate

save_frame(filename, t=0, with_mask=True)

Save a clip's frame to an image file.

Saves the frame of clip corresponding to time t in filename. t can be expressed in seconds (15.35), in (min, sec), in (hour, min, sec), or as a string: '01:03:05.35'.

show(t=0, with_mask=True)

Splashes the frame of clip corresponding to time t.

Examples

from moviepy import *
clip = VideoFileClip("media/chaplin.mp4")
clip.show(t=4)

to_ImageClip(t=0, with_mask=True, duration=None)

Returns an ImageClip made out of the clip's frame at time t, which can be expressed in seconds (15.35), in (min, sec), in (hour, min, sec), or as a string: '01:03:05.35'.

to_RGB()

Return a non-mask video clip made from the mask video clip.

to_mask(canal=0)

Return a mask a video clip made from the clip.

property w

Returns the width of the video.

with_audio(audioclip)

Attach an AudioClip to the VideoClip.

Returns a copy of the VideoClip instance, with the audio attribute set to audio, which must be an AudioClip instance.

with_background_color(size=None, color=(0, 0, 0), pos=None, opacity=None)

Place the clip on a colored background.

Returns a clip made of the current clip overlaid on a color clip of a possibly bigger size. Can serve to flatten transparent clips.

with_effects_on_subclip(effects: List[Effect <#moviepy.Effect.Effect>], start_time=0, end_time=None, **kwargs)

Apply a transformation to a part of the clip.

Returns a new clip in which the function fun (clip->clip) has been applied to the subclip between times start_time and end_time (in seconds).

Examples

# The scene between times t=3s and t=6s in ``clip`` will be
# be played twice slower in ``new_clip``
new_clip = clip.with_sub_effect(MultiplySpeed(0.5), 3, 6)

with_layer_index(index)

Set the clip's layer in compositions. Clips with a greater layer attribute will be displayed on top of others.

Note: Only has effect when the clip is used in a CompositeVideoClip.

with_mask(mask: VideoClip <#moviepy.video.VideoClip.VideoClip> | str = 'auto')

Set the clip's mask.

Returns a copy of the VideoClip with the mask attribute set to mask, which must be a greyscale (values in 0-1) VideoClip.

with_opacity(opacity)

Set the opacity/transparency level of the clip.

Returns a semi-transparent copy of the clip where the mask is multiplied by op (any float, normally between 0 and 1).

with_position(pos, relative=False)

Set the clip's position in compositions.

Sets the position that the clip will have when included in compositions. The argument pos can be either a couple (x,y) or a function t-> (x,y). x and y mark the location of the top left corner of the clip, and can be of several types.

Examples

clip.with_position((45,150)) # x=45, y=150
# clip horizontally centered, at the top of the picture
clip.with_position(("center","top"))
# clip is at 40% of the width, 70% of the height:
clip.with_position((0.4,0.7), relative=True)
# clip's position is horizontally centered, and moving up !
clip.with_position(lambda t: ('center', 50+t))

with_updated_frame_function(frame_function: Callable[[float], ndarray])

Change the clip's get_frame.

Returns a copy of the VideoClip instance, with the frame_function attribute set to mf.

without_audio()

Remove the clip's audio.

Return a copy of the clip with audio set to None.

without_mask()

Remove the clip's mask.

write_gif(filename, fps=None, loop=0, logger='bar')

Write the VideoClip to a GIF file.

Converts a VideoClip into an animated GIF using imageio

Notes

The gif will be playing the clip in real time (you can only change the frame rate). If you want the gif to be played slower than the clip you will use

# slow down clip 50% and make it a gif
myClip.multiply_speed(0.5).to_gif('myClip.gif')

write_images_sequence(name_format, fps=None, with_mask=True, logger='bar')

Writes the videoclip to a sequence of image files.

Notes

The resulting image sequence can be read using e.g. the class ImageSequenceClip.

write_videofile(filename, fps=None, codec=None, bitrate=None, audio=True, audio_fps=44100, preset='medium', audio_nbytes=4, audio_codec=None, audio_bitrate=None, audio_bufsize=2000, temp_audiofile=None, temp_audiofile_path='', remove_temp=True, write_logfile=False, threads=None, ffmpeg_params=None, logger='bar', pixel_format=None)

Write the clip to a videofile.

Examples

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

Parameters

close()

Closes the instance, releasing all the resources.

frame_function(t)

The clips playing at time t are blitted over one another.

playing_clips(t=0)

Returns a list of the clips in the composite clips that are actually playing at the given time t.

array

Matrix of clips included in the returned composited video clip.

rows_widths

Widths of the different rows in pixels. If None, is set automatically.

cols_heights

Heights of the different columns in pixels. If None, is set automatically.

bg_color

Fill color for the masked and unfilled regions. Set to None for these regions to be transparent (processing will be slower).

• method="chain": will produce a clip that simply outputs the frames of the successive clips, without any correction if they are not of the same size of anything. If none of the clips have masks the resulting clip has no mask, else the mask is a concatenation of masks (using completely opaque for clips that don't have masks, obviously). If you have clips of different size and you want to write directly the result of the concatenation to a file, use the method "compose" instead.
• method="compose", if the clips do not have the same resolution, the final resolution will be such that no clip has to be resized. As a consequence the final clip has the height of the highest clip and the width of the widest clip of the list. All the clips with smaller dimensions will appear centered. The border will be transparent if mask=True, else it will be of the color specified by bg_color.

Parameters

Parameters

Raises

ValueError -- When sooness argument is lower than 0.

apply(clip)

Apply the effect to the clip.

copy()

Return a shallow copy of an Effect.

You must always copy an Effect before applying, because some of them will modify their own attributes when applied. For example, setting a previously unset property by using target clip property.

If we was to use the original effect, calling the same effect multiple times could lead to different properties, and different results for equivalent clips.

By using copy, we ensure we can use the same effect object multiple times while maintaining the same behavior/result.

In a way, copy makes the effect himself being kind of idempotent.

apply(clip)

Apply the effect to the clip.

copy()

Return a shallow copy of an Effect.

You must always copy an Effect before applying, because some of them will modify their own attributes when applied. For example, setting a previously unset property by using target clip property.

If we was to use the original effect, calling the same effect multiple times could lead to different properties, and different results for equivalent clips.

By using copy, we ensure we can use the same effect object multiple times while maintaining the same behavior/result.

In a way, copy makes the effect himself being kind of idempotent.

apply(clip)

Apply the effect to the clip.

copy()

Return a shallow copy of an Effect.

You must always copy an Effect before applying, because some of them will modify their own attributes when applied. For example, setting a previously unset property by using target clip property.

If we was to use the original effect, calling the same effect multiple times could lead to different properties, and different results for equivalent clips.

By using copy, we ensure we can use the same effect object multiple times while maintaining the same behavior/result.

In a way, copy makes the effect himself being kind of idempotent.

apply(clip: Clip <#moviepy.Clip.Clip>) -> Clip <#moviepy.Clip.Clip>

Apply the effect to the clip.

copy()

Return a shallow copy of an Effect.

You must always copy an Effect before applying, because some of them will modify their own attributes when applied. For example, setting a previously unset property by using target clip property.

If we was to use the original effect, calling the same effect multiple times could lead to different properties, and different results for equivalent clips.

By using copy, we ensure we can use the same effect object multiple times while maintaining the same behavior/result.

In a way, copy makes the effect himself being kind of idempotent.

apply(clip: Clip <#moviepy.Clip.Clip>) -> Clip <#moviepy.Clip.Clip>

Apply the effect to the clip.

copy()

Return a shallow copy of an Effect.

You must always copy an Effect before applying, because some of them will modify their own attributes when applied. For example, setting a previously unset property by using target clip property.

If we was to use the original effect, calling the same effect multiple times could lead to different properties, and different results for equivalent clips.

By using copy, we ensure we can use the same effect object multiple times while maintaining the same behavior/result.

In a way, copy makes the effect himself being kind of idempotent.

apply(clip: Clip <#moviepy.Clip.Clip>) -> Clip <#moviepy.Clip.Clip>

Apply the effect to the clip.

copy()

Return a shallow copy of an Effect.

You must always copy an Effect before applying, because some of them will modify their own attributes when applied. For example, setting a previously unset property by using target clip property.

If we was to use the original effect, calling the same effect multiple times could lead to different properties, and different results for equivalent clips.

By using copy, we ensure we can use the same effect object multiple times while maintaining the same behavior/result.

In a way, copy makes the effect himself being kind of idempotent.

apply(clip: Clip <#moviepy.Clip.Clip>) -> Clip <#moviepy.Clip.Clip>

Apply the effect to the clip.

copy()

Return a shallow copy of an Effect.

You must always copy an Effect before applying, because some of them will modify their own attributes when applied. For example, setting a previously unset property by using target clip property.

If we was to use the original effect, calling the same effect multiple times could lead to different properties, and different results for equivalent clips.

By using copy, we ensure we can use the same effect object multiple times while maintaining the same behavior/result.

In a way, copy makes the effect himself being kind of idempotent.

apply(clip: Clip <#moviepy.Clip.Clip>) -> Clip <#moviepy.Clip.Clip>

Apply the effect to the clip.

copy()

Return a shallow copy of an Effect.

You must always copy an Effect before applying, because some of them will modify their own attributes when applied. For example, setting a previously unset property by using target clip property.

If we was to use the original effect, calling the same effect multiple times could lead to different properties, and different results for equivalent clips.

By using copy, we ensure we can use the same effect object multiple times while maintaining the same behavior/result.

In a way, copy makes the effect himself being kind of idempotent.

apply(clip: Clip <#moviepy.Clip.Clip>) -> Clip <#moviepy.Clip.Clip>

Apply the effect to the clip.

copy()

Return a shallow copy of an Effect.

You must always copy an Effect before applying, because some of them will modify their own attributes when applied. For example, setting a previously unset property by using target clip property.

If we was to use the original effect, calling the same effect multiple times could lead to different properties, and different results for equivalent clips.

By using copy, we ensure we can use the same effect object multiple times while maintaining the same behavior/result.

In a way, copy makes the effect himself being kind of idempotent.

apply(clip: Clip <#moviepy.Clip.Clip>) -> Clip <#moviepy.Clip.Clip>

Apply the effect to the clip.

copy()

Return a shallow copy of an Effect.

You must always copy an Effect before applying, because some of them will modify their own attributes when applied. For example, setting a previously unset property by using target clip property.

If we was to use the original effect, calling the same effect multiple times could lead to different properties, and different results for equivalent clips.

By using copy, we ensure we can use the same effect object multiple times while maintaining the same behavior/result.

In a way, copy makes the effect himself being kind of idempotent.

Parameters

apply(clip: Clip <#moviepy.Clip.Clip>) -> Clip <#moviepy.Clip.Clip>

Apply the effect to the clip.

copy()

Return a shallow copy of an Effect.

You must always copy an Effect before applying, because some of them will modify their own attributes when applied. For example, setting a previously unset property by using target clip property.

If we was to use the original effect, calling the same effect multiple times could lead to different properties, and different results for equivalent clips.

By using copy, we ensure we can use the same effect object multiple times while maintaining the same behavior/result.

In a way, copy makes the effect himself being kind of idempotent.

apply(clip: Clip <#moviepy.Clip.Clip>) -> Clip <#moviepy.Clip.Clip>

Apply the effect to the clip.

copy()

Return a shallow copy of an Effect.

You must always copy an Effect before applying, because some of them will modify their own attributes when applied. For example, setting a previously unset property by using target clip property.

If we was to use the original effect, calling the same effect multiple times could lead to different properties, and different results for equivalent clips.

By using copy, we ensure we can use the same effect object multiple times while maintaining the same behavior/result.

In a way, copy makes the effect himself being kind of idempotent.

apply(clip: Clip <#moviepy.Clip.Clip>) -> Clip <#moviepy.Clip.Clip>

Apply the effect to the clip.

copy()

Return a shallow copy of an Effect.

You must always copy an Effect before applying, because some of them will modify their own attributes when applied. For example, setting a previously unset property by using target clip property.

If we was to use the original effect, calling the same effect multiple times could lead to different properties, and different results for equivalent clips.

By using copy, we ensure we can use the same effect object multiple times while maintaining the same behavior/result.

In a way, copy makes the effect himself being kind of idempotent.

apply(clip: Clip <#moviepy.Clip.Clip>) -> Clip <#moviepy.Clip.Clip>

Apply the effect to the clip.

copy()

Return a shallow copy of an Effect.

You must always copy an Effect before applying, because some of them will modify their own attributes when applied. For example, setting a previously unset property by using target clip property.

If we was to use the original effect, calling the same effect multiple times could lead to different properties, and different results for equivalent clips.

By using copy, we ensure we can use the same effect object multiple times while maintaining the same behavior/result.

In a way, copy makes the effect himself being kind of idempotent.

Parameters

apply(clip: Clip <#moviepy.Clip.Clip>) -> Clip <#moviepy.Clip.Clip>

Apply the effect to the clip.

copy()

Return a shallow copy of an Effect.

You must always copy an Effect before applying, because some of them will modify their own attributes when applied. For example, setting a previously unset property by using target clip property.

If we was to use the original effect, calling the same effect multiple times could lead to different properties, and different results for equivalent clips.

By using copy, we ensure we can use the same effect object multiple times while maintaining the same behavior/result.

In a way, copy makes the effect himself being kind of idempotent.

apply(clip: Clip <#moviepy.Clip.Clip>) -> Clip <#moviepy.Clip.Clip>

Apply the effect to the clip.

copy()

Return a shallow copy of an Effect.

You must always copy an Effect before applying, because some of them will modify their own attributes when applied. For example, setting a previously unset property by using target clip property.

If we was to use the original effect, calling the same effect multiple times could lead to different properties, and different results for equivalent clips.

By using copy, we ensure we can use the same effect object multiple times while maintaining the same behavior/result.

In a way, copy makes the effect himself being kind of idempotent.

Parameters

overlap_duration (float) -- Duration of the fade-in (in seconds).

apply(clip: Clip <#moviepy.Clip.Clip>) -> Clip <#moviepy.Clip.Clip>

Apply the effect to the clip.

copy()

Return a shallow copy of an Effect.

You must always copy an Effect before applying, because some of them will modify their own attributes when applied. For example, setting a previously unset property by using target clip property.

If we was to use the original effect, calling the same effect multiple times could lead to different properties, and different results for equivalent clips.

By using copy, we ensure we can use the same effect object multiple times while maintaining the same behavior/result.

In a way, copy makes the effect himself being kind of idempotent.

Parameters

add_margin(clip: Clip <#moviepy.Clip.Clip>)

Add margins to the clip.

apply(clip: Clip <#moviepy.Clip.Clip>) -> Clip <#moviepy.Clip.Clip>

Apply the effect to the clip.

copy()

Return a shallow copy of an Effect.

You must always copy an Effect before applying, because some of them will modify their own attributes when applied. For example, setting a previously unset property by using target clip property.

If we was to use the original effect, calling the same effect multiple times could lead to different properties, and different results for equivalent clips.

By using copy, we ensure we can use the same effect object multiple times while maintaining the same behavior/result.

In a way, copy makes the effect himself being kind of idempotent.

apply(clip: Clip <#moviepy.Clip.Clip>) -> Clip <#moviepy.Clip.Clip>

Apply the effect to the clip.

copy()

Return a shallow copy of an Effect.

You must always copy an Effect before applying, because some of them will modify their own attributes when applied. For example, setting a previously unset property by using target clip property.

If we was to use the original effect, calling the same effect multiple times could lead to different properties, and different results for equivalent clips.

By using copy, we ensure we can use the same effect object multiple times while maintaining the same behavior/result.

In a way, copy makes the effect himself being kind of idempotent.

Parameters

np.ndarray (other_clip ImageClip or) -- Clip used to mask the original clip.

apply(clip: Clip <#moviepy.Clip.Clip>) -> Clip <#moviepy.Clip.Clip>

Apply the effect to the clip.

copy()

Return a shallow copy of an Effect.

You must always copy an Effect before applying, because some of them will modify their own attributes when applied. For example, setting a previously unset property by using target clip property.

If we was to use the original effect, calling the same effect multiple times could lead to different properties, and different results for equivalent clips.

By using copy, we ensure we can use the same effect object multiple times while maintaining the same behavior/result.

In a way, copy makes the effect himself being kind of idempotent.

Parameters

np.ndarray (other_clip ImageClip or) -- Clip used to mask the original clip.

apply(clip: Clip <#moviepy.Clip.Clip>) -> Clip <#moviepy.Clip.Clip>

Apply the effect to the clip.

copy()

Return a shallow copy of an Effect.

You must always copy an Effect before applying, because some of them will modify their own attributes when applied. For example, setting a previously unset property by using target clip property.

If we was to use the original effect, calling the same effect multiple times could lead to different properties, and different results for equivalent clips.

By using copy, we ensure we can use the same effect object multiple times while maintaining the same behavior/result.

In a way, copy makes the effect himself being kind of idempotent.

apply(clip: Clip <#moviepy.Clip.Clip>) -> Clip <#moviepy.Clip.Clip>

Apply the effect to the clip.

copy()

Return a shallow copy of an Effect.

You must always copy an Effect before applying, because some of them will modify their own attributes when applied. For example, setting a previously unset property by using target clip property.

If we was to use the original effect, calling the same effect multiple times could lead to different properties, and different results for equivalent clips.

By using copy, we ensure we can use the same effect object multiple times while maintaining the same behavior/result.

In a way, copy makes the effect himself being kind of idempotent.

apply(clip: Clip <#moviepy.Clip.Clip>) -> Clip <#moviepy.Clip.Clip>

Apply the effect to the clip.

copy()

Return a shallow copy of an Effect.

You must always copy an Effect before applying, because some of them will modify their own attributes when applied. For example, setting a previously unset property by using target clip property.

If we was to use the original effect, calling the same effect multiple times could lead to different properties, and different results for equivalent clips.

By using copy, we ensure we can use the same effect object multiple times while maintaining the same behavior/result.

In a way, copy makes the effect himself being kind of idempotent.

apply(clip: Clip <#moviepy.Clip.Clip>) -> Clip <#moviepy.Clip.Clip>

Apply the effect to the clip.

copy()

Return a shallow copy of an Effect.

You must always copy an Effect before applying, because some of them will modify their own attributes when applied. For example, setting a previously unset property by using target clip property.

If we was to use the original effect, calling the same effect multiple times could lead to different properties, and different results for equivalent clips.

By using copy, we ensure we can use the same effect object multiple times while maintaining the same behavior/result.

In a way, copy makes the effect himself being kind of idempotent.

apply(clip: Clip <#moviepy.Clip.Clip>) -> Clip <#moviepy.Clip.Clip>

Apply the effect to the clip.

copy()

Return a shallow copy of an Effect.

You must always copy an Effect before applying, because some of them will modify their own attributes when applied. For example, setting a previously unset property by using target clip property.

If we was to use the original effect, calling the same effect multiple times could lead to different properties, and different results for equivalent clips.

By using copy, we ensure we can use the same effect object multiple times while maintaining the same behavior/result.

In a way, copy makes the effect himself being kind of idempotent.

apply(clip: Clip <#moviepy.Clip.Clip>) -> Clip <#moviepy.Clip.Clip>

Apply the effect to the clip.

copy()

Return a shallow copy of an Effect.

You must always copy an Effect before applying, because some of them will modify their own attributes when applied. For example, setting a previously unset property by using target clip property.

If we was to use the original effect, calling the same effect multiple times could lead to different properties, and different results for equivalent clips.

By using copy, we ensure we can use the same effect object multiple times while maintaining the same behavior/result.

In a way, copy makes the effect himself being kind of idempotent.

to_painting(np_image, saturation=1.4, black=0.006)

Transforms any photo into some kind of painting.

Transforms any photo into some kind of painting. Saturation tells at which point the colors of the result should be flashy. black gives the amount of black lines wanted.

np_image : a numpy image

Parameters

apply(clip)

Apply the effect to the clip.

copy()

Return a shallow copy of an Effect.

You must always copy an Effect before applying, because some of them will modify their own attributes when applied. For example, setting a previously unset property by using target clip property.

If we was to use the original effect, calling the same effect multiple times could lead to different properties, and different results for equivalent clips.

By using copy, we ensure we can use the same effect object multiple times while maintaining the same behavior/result.

In a way, copy makes the effect himself being kind of idempotent.

resizer(pic, new_size)

Resize the image using openCV.

Parameters

apply(clip: Clip <#moviepy.Clip.Clip>) -> Clip <#moviepy.Clip.Clip>

Apply the effect to the clip.

copy()

Return a shallow copy of an Effect.

You must always copy an Effect before applying, because some of them will modify their own attributes when applied. For example, setting a previously unset property by using target clip property.

If we was to use the original effect, calling the same effect multiple times could lead to different properties, and different results for equivalent clips.

By using copy, we ensure we can use the same effect object multiple times while maintaining the same behavior/result.

In a way, copy makes the effect himself being kind of idempotent.

rotate_frame(frame: ndarray, angle: float, resample: int, expand: bool, center: tuple | None, translate: tuple | None, bg_color: tuple | None) -> ndarray

Rotate a single image or mask using OpenCV.

Parameters

apply_to

Whether to apply the effect to the mask too.

apply(clip)

Apply the effect to the clip.

copy()

Return a shallow copy of an Effect.

You must always copy an Effect before applying, because some of them will modify their own attributes when applied. For example, setting a previously unset property by using target clip property.

If we was to use the original effect, calling the same effect multiple times could lead to different properties, and different results for equivalent clips.

By using copy, we ensure we can use the same effect object multiple times while maintaining the same behavior/result.

In a way, copy makes the effect himself being kind of idempotent.

Parameters

apply(clip: Clip <#moviepy.Clip.Clip>) -> Clip <#moviepy.Clip.Clip>

Apply the effect to the clip.

copy()

Return a shallow copy of an Effect.

You must always copy an Effect before applying, because some of them will modify their own attributes when applied. For example, setting a previously unset property by using target clip property.

If we was to use the original effect, calling the same effect multiple times could lead to different properties, and different results for equivalent clips.

By using copy, we ensure we can use the same effect object multiple times while maintaining the same behavior/result.

In a way, copy makes the effect himself being kind of idempotent.

Parameters

apply(clip: Clip <#moviepy.Clip.Clip>) -> Clip <#moviepy.Clip.Clip>

Apply the effect to the clip.

copy()

Return a shallow copy of an Effect.

You must always copy an Effect before applying, because some of them will modify their own attributes when applied. For example, setting a previously unset property by using target clip property.

If we was to use the original effect, calling the same effect multiple times could lead to different properties, and different results for equivalent clips.

By using copy, we ensure we can use the same effect object multiple times while maintaining the same behavior/result.

In a way, copy makes the effect himself being kind of idempotent.

apply(clip: Clip <#moviepy.Clip.Clip>) -> Clip <#moviepy.Clip.Clip>

Apply the effect to the clip.

copy()

Return a shallow copy of an Effect.

You must always copy an Effect before applying, because some of them will modify their own attributes when applied. For example, setting a previously unset property by using target clip property.

If we was to use the original effect, calling the same effect multiple times could lead to different properties, and different results for equivalent clips.

By using copy, we ensure we can use the same effect object multiple times while maintaining the same behavior/result.

In a way, copy makes the effect himself being kind of idempotent.

apply(clip: Clip <#moviepy.Clip.Clip>) -> Clip <#moviepy.Clip.Clip>

Apply the effect to the clip.

copy()

Return a shallow copy of an Effect.

You must always copy an Effect before applying, because some of them will modify their own attributes when applied. For example, setting a previously unset property by using target clip property.

If we was to use the original effect, calling the same effect multiple times could lead to different properties, and different results for equivalent clips.

By using copy, we ensure we can use the same effect object multiple times while maintaining the same behavior/result.

In a way, copy makes the effect himself being kind of idempotent.

apply(clip: Clip <#moviepy.Clip.Clip>) -> Clip <#moviepy.Clip.Clip>

Apply the effect to the clip.

copy()

Return a shallow copy of an Effect.

You must always copy an Effect before applying, because some of them will modify their own attributes when applied. For example, setting a previously unset property by using target clip property.

If we was to use the original effect, calling the same effect multiple times could lead to different properties, and different results for equivalent clips.

By using copy, we ensure we can use the same effect object multiple times while maintaining the same behavior/result.

In a way, copy makes the effect himself being kind of idempotent.

Parameters

frame_function(t)

Retrieves the frame corresponding to the given time t.

Depending on whether the frames are loaded from files or provided as an in-memory sequence, this function either reads the frame from disk or accesses it directly from the sequence.

Parameters

filename

Name of the original video file.

fps

Frames per second in the original file.

Parameters

Parameters

close(delete_lastread=True)

Closes the reader terminating the process, if is still open.

get_frame(t)

Read a file video frame at time t.

Note for coders: getting an arbitrary frame in the video with ffmpeg can be painfully slow if some decoding has to be done. This function tries to avoid fetching arbitrary frames whenever possible, by moving between adjacent frames.

get_frame_number(t)

Helper method to return the frame number at time t

initialize(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).

property lastread

Alias of self.last_read for backwards compatibility with MoviePy 1.x.

read_frame()

Reads the next frame from the file. Note that upon (re)initialization, the first frame will already have been read and stored in self.last_read.

skip_frames(n=1)

Reads and throws away n frames

Parameters

class InfoBlock(block_line, indent_level=0)

Represents a block of output from ffmpeg, which can be an input file, stream, chapter or metadata.

exception ParseDimensionError

Error raised when we cannot find dimensions in a video stream

exception ParseDurationError

Error raised when we cannot find duration in a video stream

parse()

Parses the information returned by FFmpeg in stderr executing their binary for a file with -i option and returns a dictionary with all data needed by MoviePy.

• "audio_bitrate"
• "audio_found"
• "audio_fps"
• "bitrate"
• "duration"
• "inputs"
• "metadata"
• "start"
• "video_bitrate"
• "video_codec_name"
• "video_duration"
• "video_fps"
• "video_found"
• "video_n_frames"
• "video_profile"
• "video_rotation"
• "video_size"

Parameters

Parameters

Parameters

Return type

None

Parameters

Parameters

Parameters

Parameters

Parameters

Returns

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').

Return type

tuple

Raises

subprocess.CalledProcessError -- If the FFmpeg command fails to execute properly.

Returns

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').

Return type

tuple

Raises

subprocess.CalledProcessError -- If the FFplay command fails to execute properly.

Parameters

close()

Closes the writer, terminating the subprocess if is still alive.

write_frame(img_array)

Writes one frame in the file.

Parameters

Parameters

close()

Closes the writer, terminating the subprocess if is still alive.

show_frame(img_array)

Writes one frame in the file.

Parameters