# Movie

Ren'Py is capable of using FFmpeg (included) to play movies using the video codecs:

- VP9
- VP8
- Theora
- MPEG-4 part 2 (including Xvid and DivX)
- MPEG-2
- MPEG-1

and the following audio codecs:

- Opus
- Vorbis
- MP3
- MP2
- PCM

inside the following container formats:

- WebM
- Matroska
- Ogg
- AVI
- Various kinds of MPEG stream.

(Note that using some of these formats may require patent licenses. When in doubt, and especially for commercial games, we recommend using VP9, VP8, or Theora; Opus or Vorbis; and WebM, Matroska, or Ogg.)

Movies can be displayed fullscreen or in a displayable. Fullscreen movies are more efficient.

Ren'Py's movie decoder does not support movies with alpha channels, but the side_mask parameter of the `Movie()` displayable can be used for that purpose. Here is an example of hhow to use ffmpeg to create a webm file with a side-by-side mask from a mov file with an alpha channel.

    ffmpeg -i original.mov -filter:v alphaextract mask.mov
    ffmpeg -i original.mov -i mask.mov -filter_complex "hstack" -codec:v vp8 -crf 10 output.webm

Movies are not supported on the Web platform.

## Fullscreen Movies

The easiest and most efficient way to display a movie fullscreen is to use the `renpy.movie_cutscene()` function. This function displays the movie fullscreen until it either ends, or the player clicks to dismiss it.

    $ renpy.movie_cutscene("On_Your_Mark.webm")

On mobile platforms, such as Android and iOS, hardware video decoding is used when `config.hw_video` is changed to True. This can be faster, but the list of supported movie formats depends on the platform. See for instance Android's supported media formats. A quick way to test if your videos are supported is to copy them to your target device and play them with its default video player.

## Movie Displayables and Movie Sprites

The Movie displayable can be used to display a movie anywhere Ren'Py can show a displayable. For example, a movie can be displayed as the background of a menu screen, or as a background.

The Movie displayable can also be used to define a movie sprite, which is a sprite that is backed by two movies. The primary movie provides the color of the sprite. A second movie, the mask movie, provides the alpha channel, with white being full opacity and black being full transparency.

Movies played by the Movie displayable loop automatically.

Here's an example of defining a movie sprite:

    image eileen movie = Movie(play="eileen_movie.webm", side_mask=True)

The movie sprite can be shown using the show statement, which automatically starts the movie playing. It will be automatically stopped when the displayable is hidden.

    show eileen movie

    e "I'm feeling quite animated today."

    hide eileen

    e "But there's no point on wasting energy when I'm not around."

A Movie displayable can also be used as part of a screen, provided it is created during the init phase (for example, as part of an image statement.)

    image main_menu = Movie(play="main_menu.ogv")

    screen main_menu:
        add "main_menu"
        textbutton "Start" action Start() xalign 0.5 yalign 0.5

Multiple movie displayables or sprites can be displayed on the screen at once, subject to system performance, and provided all share the same framerate. The behavior of Ren'Py when displaying movies with different framerates is undefined, but will likely include a significant amount of frame drop.

## Python Functions

`renpy.``movie_cutscene`(filename, delay=None, loops=0, stop_music=True)

  This displays a movie cutscene for the specified number of seconds. The user can click to interrupt the cutscene. Overlays and Underlays are disabled for the duration of the cutscene.

  filename
    The name of a file containing any movie playable by Ren'Py.
  delay
    The number of seconds to wait before ending the cutscene. Normally the length of the movie, in seconds. If None, then the delay is computed from the number of loops (that is, loops + 1) * the length of the movie. If -1, we wait until the user clicks.
  loops
    The number of extra loops to show, -1 to loop forever.

  Returns True if the movie was terminated by the user, or False if the given delay elapsed uninterrupted.

`Movie`(fps=24, size=None, channel=u'movie', play=None, mask=None, mask_channel=None, image=None, play_callback=None, side_mask=False, loop=True, start_image=None, **properties)

  This is a displayable that shows the current movie.

  fps
    The framerate that the movie should be shown at. (This is currently ignored, but the parameter is kept for backwards compatibility. The framerate is auto-detected.)
  size
    This should be specified as either a tuple giving the width and height of the movie, or None to automatically adjust to the size of the playing movie. (If None, the displayable will be (0, 0) when the movie is not playing.)
  channel
    The audio channel associated with this movie. When a movie file is played on that channel, it will be displayed in this Movie displayable. If this is left at the default of "movie", and play is provided, a channel name is automatically selected, using `config.single_movie_channel` and `config.auto_movie_channel`.
  play
    If given, this should be the path to a movie file, or a list of paths to movie files. These movie files will be automatically played on channel when the Movie is shown, and automatically stopped when the movie is hidden.
  side_mask

    If true, this tells Ren'Py to use the side-by-side mask mode for the Movie. In this case, the movie is divided in half. The left half is used for color information, while the right half is used for alpha information. The width of the displayable is half the width of the movie file.

    Where possible, side_mask should be used over mask as it has no chance of frames going out of sync.

  mask
    If given, this should be the path to a movie file, or a list of paths to movie files, that are used as the alpha channel of this displayable. The movie file will be automatically played on movie_channel when the Movie is shown, and automatically stopped when the movie is hidden.
  mask_channel
    The channel the alpha mask video is played on. If not given, defaults to channel_mask. (For example, if channel is "sprite", mask_channel defaults to "sprite_mask".)
  start_image
    An image that is displayed when playback has started, but the first frame has not yet been decoded.
  image
    An image that is displayed when play has been given, but the file it refers to does not exist. (For example, this can be used to create a slimmed-down mobile version that does not use movie sprites.) Users can also choose to fall back to this image as a preference if video is too taxing for their system. The image will also be used if the video plays, and then the movie ends.
  play_callback

    If not None, a function that's used to start the movies playing. (This may do things like queue a transition between sprites, if desired.) It's called with the following arguments:

    old
      The old Movie object, or None if the movie is not playing.
    new
      The new Movie object.

    A movie object has the play parameter available as `_play`, while the `channel`, `loop`, `mask`, and `mask_channel` fields correspond to the given parameters.

    Generally, this will want to use `renpy.music.play()` to start the movie playing on the given channel, with synchro_start=True. A minimal implementation is:

        def play_callback(old, new):

            renpy.music.play(new._play, channel=new.channel, loop=new.loop, synchro_start=True)

            if new.mask:
                renpy.music.play(new.mask, channel=new.mask_channel, loop=new.loop, synchro_start=True)

  loop
    If False, the movie will not loop. If image is defined, the image will be displayed when the movie ends. Otherwise, the displayable will become transparent.