GitHub - Powercoder64/ffmpeg-python at f3b32d6d41d65701aa65bae951518e1ec387b483

Powercoder64 / ffmpeg-python Public

forked from kkroening/ffmpeg-python

Notifications You must be signed in to change notification settings
Fork 0
Star 0

Python bindings for FFmpeg - with complex filtering support

Apache-2.0 license

0 stars 919 forks Branches Tags Activity

Star

Notifications

Branches Tags

Name		Name	Last commit message	Last commit date
Latest commit History 16 Commits
doc		doc
ffmpeg		ffmpeg
.gitignore		.gitignore
LICENSE		LICENSE
MANIFEST		MANIFEST
README		README
pytest.ini		pytest.ini
requirements.txt		requirements.txt
setup.py		setup.py

Repository files navigation

# ffmpeg-python: Python bindings for FFmpeg with complex filtering support

## Overview

There are tons of Python FFmpeg wrappers out there but they seem to lack complex filter support.  `ffmpeg-python` works well for simple as well as complex signal graphs.

## Quickstart

```
import ffmpeg
ffmpeg \
    .file_input('input.mp4') \
    .file_output('output.mp4') \
    .run()
```

Or if you prefer a non-fluent interface:
```
import ffmpeg
in = ffmpeg.file_input('input.mp4')
out = ffmpeg.file_output(in)
ffmpeg.run(out)
```

## Complex filter graphs
FFmpeg is extremely powerful, but it's command-line interface gets really complicated really quickly - especially when working with signal graphs and doing anything more than trivial.

Take for example a signal graph that looks like this:

<img src="https://raw.githubusercontent.com/kkroening/ffmpeg-python/master/doc/graph1.png" alt="Signal graph" align="middle" width="50%" />

The corresponding command-line arguments are pretty gnarly:
```
ffmpeg -i input.mp4 \
    -filter_complex "\
        [0]trim=start_frame=10:end_frame=20,setpts=PTS-STARTPTS[v0];\
        [0]trim=start_frame=30:end_frame=40,setpts=PTS-STARTPTS[v1];\
        [v0][v1]concat=n=2[v2];\
        [1]hflip[v3];\
        [v2][v3]overlay=eof_action=repeat[v4];\
        [v4]drawbox=50:50:120:120:red:t=5[v5]"\
     -map [v5] output.mp4
```

Maybe this looks great to you, but if you haven't worked with FFmpeg before, it probably looks pretty alien.

If you're like me and find Python to be powerful and readable, it's easy with `ffmpeg-python`:
```
import ffmpeg

in_file = ffmpeg.file_input(TEST_INPUT_FILE)
overlay_file = ffmpeg.file_input(TEST_OVERLAY_FILE)
ffmpeg \
    .concat(
        in_file.trim(10, 20),
        in_file.trim(30, 40),
    ) \
    .overlay(overlay_file.hflip()) \
    .drawbox(50, 50, 120, 120, color='red', thickness=5) \
    .file_output(TEST_OUTPUT_FILE) \
    .run()
```

`ffmpeg-python` takes care of running `ffmpeg` with the command-line arguments that correspond to the above filter diagram, and it's easy to what's going on and make changes as needed.

Real-world signal graphs can get a heck of a lot more complex, but `ffmpeg-python` handles them with ease.