All Projects → jaseg → Python Mpv

jaseg / Python Mpv

Licence: agpl-3.0
Python interface to the awesome mpv media player

Programming Languages

python
139335 projects - #7 most used programming language

Projects that are alternatives of or similar to Python Mpv

Libvlc Go
Go bindings for libVLC and high-level media player interface
Stars: ✭ 188 (-23.27%)
Mutual labels:  bindings, audio, media, media-player
Glow
mpv Config File Generator for Windows
Stars: ✭ 167 (-31.84%)
Mutual labels:  audio, media-player, mpv, gui
React Native Jw Media Player
React-Native Android/iOS bridge for JWPlayer SDK (https://www.jwplayer.com/)
Stars: ✭ 76 (-68.98%)
Mutual labels:  audio, media, media-player
Mpv Easy Player
MPV-EASY Player - A movie player based on mpv
Stars: ✭ 324 (+32.24%)
Mutual labels:  multimedia, media-player, mpv
playercast
Cast to media player and control playback remotely.
Stars: ✭ 46 (-81.22%)
Mutual labels:  mpv, media, media-player
Mystiq
Qt5/C++ FFmpeg Media Converter
Stars: ✭ 393 (+60.41%)
Mutual labels:  audio, multimedia, gui
Kawaii Player
Multimedia player, media library manager and portable media server with PC-To-PC casting feature.
Stars: ✭ 397 (+62.04%)
Mutual labels:  multimedia, media-player, mpv
Monstercat Visualizer
A real time audio visualizer for Rainmeter similar to the ones used in the Monstercat videos.
Stars: ✭ 571 (+133.06%)
Mutual labels:  audio, media, media-player
Mpv
🎥 Command line video player
Stars: ✭ 17,018 (+6846.12%)
Mutual labels:  audio, multimedia, mpv
Swiftffmpeg
A Swift wrapper for the FFmpeg API
Stars: ✭ 243 (-0.82%)
Mutual labels:  audio, multimedia
Awesome Python Applications
💿 Free software that works great, and also happens to be open-source Python.
Stars: ✭ 13,275 (+5318.37%)
Mutual labels:  audio, gui
Fltk Rs
Rust bindings for the FLTK GUI library.
Stars: ✭ 241 (-1.63%)
Mutual labels:  bindings, gui
Xbmc
Kodi is an award-winning free and open source home theater/media center software and entertainment hub for digital media. With its beautiful interface and powerful skinning engine, it's available for Android, BSD, Linux, macOS, iOS and Windows.
Stars: ✭ 13,175 (+5277.55%)
Mutual labels:  multimedia, media-player
Ktvhttpcache
A powerful media cache framework.
Stars: ✭ 2,113 (+762.45%)
Mutual labels:  audio, media
Cassette
📼 A flexible media player component library for React that requires no up-front config
Stars: ✭ 171 (-30.2%)
Mutual labels:  audio, media-player
Shaden
🎧 A modular audio synthesizer.
Stars: ✭ 175 (-28.57%)
Mutual labels:  audio, media
Rust Bindgen
Automatically generates Rust FFI bindings to C (and some C++) libraries.
Stars: ✭ 2,453 (+901.22%)
Mutual labels:  bindings, ffi
Docker Kodi
Dockerized Kodi with audio and video
Stars: ✭ 157 (-35.92%)
Mutual labels:  audio, media
Goluwa
a game framework written in luajit
Stars: ✭ 173 (-29.39%)
Mutual labels:  ffi, gui
Render Media
Intelligently render media files in the browser
Stars: ✭ 181 (-26.12%)
Mutual labels:  audio, media

.. vim: tw=120 sw=4 et

python-mpv

python-mpv is a ctypes-based python interface to the mpv media player. It gives you more or less full control of all features of the player, just as the lua interface does.

Installation

.. code:: bash

pip install python-mpv

...though you can also realistically just copy mpv.py_ into your project as it's all nicely contained in one file.

Requirements


libmpv
......
``libmpv.so`` either locally (in your current working directory) or somewhere in your system library search path. This
module is somewhat lenient as far as ``libmpv`` versions are concerned but since ``libmpv`` is changing quite frequently
you'll only get all the newest features when using an up-to-date version of this module. The unit tests for this module
do some basic automatic version compatibility checks. If you discover anything missing here, please open an `issue`_ or
submit a `pull request`_ on github.

On Windows you can place libmpv anywhere in your ``%PATH%`` (e.g. next to ``python.exe``) or next to this module's
``mpv.py``.  Before falling back to looking in the mpv module's directory, python-mpv uses the DLL search order built
into ctypes, which is different to the one Windows uses internally. Consult `this stackoverflow post
<https://stackoverflow.com/a/23805306>`__ for details.

Python >= 3.5 (officially)
..........................
The ``master`` branch officially only supports recent python releases (3.5 onwards), but there is the somewhat outdated
but functional `py2compat branch`_ providing Python 2 compatibility.

.. _`py2compat branch`: https://github.com/jaseg/python-mpv/tree/py2compat
.. _`issue`: https://github.com/jaseg/python-mpv/issues
.. _`pull request`: https://github.com/jaseg/python-mpv/pulls

Supported Platforms
...................

**Linux**, **Windows** and **OSX** all seem to work mostly fine. For some notes on the installation on Windows see
`this comment`__. Shared library handling is quite bad on windows, so expect some pain there. On OSX there seems to be
some bug int the event logic. See `issue 36`_ and `issue 61`_ for details. Creating a pyQT window and having mpv draw
into it seems to be a workaround (about 10loc), but in case you want this fixed please weigh in on the issue tracker
since right now there is not many OSX users.

.. __: https://github.com/jaseg/python-mpv/issues/60#issuecomment-352719773
.. _`issue 61`: https://github.com/jaseg/python-mpv/issues/61
.. _`issue 36`: https://github.com/jaseg/python-mpv/issues/36

Usage
-----

.. code:: python

    import mpv
    player = mpv.MPV(ytdl=True)
    player.play('https://youtu.be/DOmdB7D-pUU')
    player.wait_for_playback()

python-mpv mostly exposes mpv's built-in API to python, adding only some porcelain on top. Most "`input commands <https://mpv.io/manual/master/#list-of-input-commands>`_" are mapped to methods of the MPV class. Check out these methods and their docstrings in `the source <https://github.com/jaseg/python-mpv/blob/master/mpv.py>`__ for things you can do. Additional controls and status information are exposed through `MPV properties <https://mpv.io/manual/master/#properties>`_. These can be accessed like ``player.metadata``, ``player.fullscreen`` and ``player.loop_playlist``.

Threading
~~~~~~~~~

The ``mpv`` module starts one thread for event handling, since MPV sends events that must be processed quickly. The
event queue has a fixed maxmimum size and some operations can cause a large number of events to be sent.

If you want to handle threading yourself, you can pass ``start_event_thread=False`` to the ``MPV`` constructor and
manually call the ``MPV`` object's ``_loop`` function. If you have some strong need to not use threads and use some
external event loop (such as asyncio) instead you can do that, too with some work. The API of the backend C ``libmpv``
has a function for producing a sort of event file descriptor for a handle. You can use that to produce a file descriptor
that can be passed to an event loop to tell it to wake up the python-mpv event handler on every incoming event.

All API functions are thread-safe. If one is not, please file an issue on github.

Advanced Usage

Logging, Properties, Python Key Bindings, Screenshots and youtube-dl ....................................................................

.. code:: python

#!/usr/bin/env python3
import mpv

def my_log(loglevel, component, message):
    print('[{}] {}: {}'.format(loglevel, component, message))

player = mpv.MPV(log_handler=my_log, ytdl=True, input_default_bindings=True, input_vo_keyboard=True)

# Property access, these can be changed at runtime
@player.property_observer('time-pos')
def time_observer(_name, value):
    # Here, _value is either None if nothing is playing or a float containing
    # fractional seconds since the beginning of the file.
    print('Now playing at {:.2f}s'.format(value))

player.fullscreen = True
player.loop_playlist = 'inf'
# Option access, in general these require the core to reinitialize
player['vo'] = 'gpu'

@player.on_key_press('q')
def my_q_binding():
    print('THERE IS NO ESCAPE')

@player.on_key_press('s')
def my_s_binding():
    pillow_img = player.screenshot_raw()
    pillow_img.save('screenshot.png')

player.play('https://youtu.be/DLzxrzFCyOs')
player.wait_for_playback()

del player

Video overlays ..............

.. code:: python

#!/usr/bin/env python3
import time
from PIL import Image, ImageDraw, ImageFont
import mpv

player = mpv.MPV()

player.loop = True
player.play('test.webm')
player.wait_until_playing()

font = ImageFont.truetype('DejaVuSans.ttf', 40)

while not player.core_idle:

    time.sleep(0.5)
    overlay = player.create_image_overlay()

    for pos in range(0, 500, 5):
        ts = player.time_pos
        if ts is None:
            break

        img = Image.new('RGBA', (400, 150),  (255, 255, 255, 0))
        d = ImageDraw.Draw(img)
        d.text((10, 10), 'Hello World', font=font, fill=(0, 255, 255, 128))
        d.text((10, 60), f't={ts:.3f}', font=font, fill=(255, 0, 255, 255))

        overlay.update(img, pos=(2*pos, pos))
        time.sleep(0.05)

    overlay.remove()

Playlist handling .................

.. code:: python

#!/usr/bin/env python3
import mpv

player = mpv.MPV(ytdl=True, input_default_bindings=True, input_vo_keyboard=True)

player.playlist_append('https://youtu.be/PHIGke6Yzh8')
player.playlist_append('https://youtu.be/Ji9qSuQapFY')
player.playlist_append('https://youtu.be/6f78_Tf4Tdk')

player.playlist_pos = 0

while True:
    # To modify the playlist, use player.playlist_{append,clear,move,remove}. player.playlist is read-only
    print(player.playlist)
    player.wait_for_playback()

Directly feeding mpv data from python .....................................

.. code:: python

#!/usr/bin/env python3
import mpv

player = mpv.MPV()
@player.python_stream('foo')
def reader():
    with open('test.webm', 'rb') as f:
        while True:
            yield f.read(1024*1024)

player.play('python://foo')
player.wait_for_playback()

Using external subtitles ........................

The easiest way to load custom subtitles from a file is to pass the --sub-file option to the loadfile call:

.. code:: python

#!/usr/bin/env python3
import mpv

player = mpv.MPV()
player.play('test.webm', sub_file='test.srt')

Note that you can also pass many other options to loadfile. See the mpv docs for details.

If you want to add subtitle files or streams at runtime, you can use the sub-add command. sub-add can only be called once the player is done loading the file and starts playing. An easy way to wait for this is to wait for the core-idle property.

.. code:: python

#!/usr/bin/env python3
import mpv

player = mpv.MPV()
player.play('test.webm')
player.wait_until_playing()
player.sub_add('test.srt')
player.wait_for_playback()

Using MPV's built-in GUI ........................

python-mpv is using mpv via libmpv. libmpv is meant for embedding into other applications and by default disables most GUI features such as the OSD or keyboard input. To enable the built-in GUI, use the following options when initializing the MPV instance. See Issue 102_ for more details

.. _issue 102: https://github.com/jaseg/python-mpv/issues/61

.. code:: python

# Enable the on-screen controller and keyboard shortcuts
player = mpv.MPV(input_default_bindings=True, input_vo_keyboard=True, osc=True)

# Alternative version using the old "floating box" style on-screen controller
player = mpv.MPV(player_operation_mode='pseudo-gui',
                 script_opts='osc-layout=box,osc-seekbarstyle=bar,osc-deadzonesize=0,osc-minmousemove=3',
                 input_default_bindings=True,
                 input_vo_keyboard=True,
                 osc=True)

PyQT embedding ..............

.. code:: python

#!/usr/bin/env python3
import mpv
import sys

from PyQt5.QtWidgets import *
from PyQt5.QtCore import *

class Test(QMainWindow):
    def __init__(self, parent=None):
        super().__init__(parent)
        self.container = QWidget(self)
        self.setCentralWidget(self.container)
        self.container.setAttribute(Qt.WA_DontCreateNativeAncestors)
        self.container.setAttribute(Qt.WA_NativeWindow)
        player = mpv.MPV(wid=str(int(self.container.winId())),
                vo='x11', # You may not need this
                log_handler=print,
                loglevel='debug')
        player.play('test.webm')

app = QApplication(sys.argv)

# This is necessary since PyQT stomps over the locale settings needed by libmpv.
# This needs to happen after importing PyQT before creating the first mpv.MPV instance.
import locale
locale.setlocale(locale.LC_NUMERIC, 'C')
win = Test()
win.show()
sys.exit(app.exec_())

PyGObject embedding ...................

.. code:: python

#!/usr/bin/env python3
import gi

import mpv

gi.require_version('Gtk', '3.0')
from gi.repository import Gtk


class MainClass(Gtk.Window):

    def __init__(self):
        super(MainClass, self).__init__()
        self.set_default_size(600, 400)
        self.connect("destroy", self.on_destroy)

        widget = Gtk.Frame()
        self.add(widget)
        self.show_all()

        # Must be created >after< the widget is shown, else property 'window' will be None
        self.mpv = mpv.MPV(wid=str(widget.get_property("window").get_xid()))
        self.mpv.play("test.webm")

    def on_destroy(self, widget, data=None):
        self.mpv.terminate()
        Gtk.main_quit()


if __name__ == '__main__':
    application = MainClass()
    Gtk.main()

Using OpenGL from PyGObject via new render context API ......................................................

Just like it is possible to render into a GTK widget through X11 windows, it also is possible to render into a GTK widget using OpenGL <https://gist.github.com/jaseg/657e8ecca3267c0d82ec85d40f423caa>__ through this python API.

Using OpenGL via legacy opengl_cb backend from PyQT ...................................................

Github user cosven_ has managed to make mpv render into a Qt widget using OpenGL <https://gist.github.com/cosven/b313de2acce1b7e15afda263779c0afc>__ through this python API.

Using OpenGL via legacy opengl_cb backend from PyGObject ........................................................

Just like it is possible to render into a Qt widget, it also is possible to render into a GTK widget <https://gist.github.com/trin94/a930f2a13cee1c9fd21cab0393bf4663>__ through this python API.

Using OpenGL from PyQt5/QML via new render context API ......................................................

Robozman_ has mangaed to make mpv render into a PyQt5/QML widget using OpenGL <https://gitlab.com/robozman/python-mpv-qml-example>__ through this python API.

Using mpv inside imgui inside OpenGL via GLFW .............................................

dfaker_ has written a demo (link <https://github.com/dfaker/imgui_glfw_pythonmpv_demo/blob/main/main.py>) that uses mpv to render video into an imgui <https://github.com/ocornut/imgui> UI running on an OpenGL context inside GLFW <https://www.glfw.org/>__. Check out their demo to see how to integrate with imgui/OpenGL and how to access properties and manage the lifecycle of an MPV instance.

Coding Conventions

The general aim is PEP 8_, with liberal application of the "consistency" section. 120 cells line width. Four spaces. No tabs. Probably don't bother making pure-formatting PRs except if you think it really helps readability or it really irks you if you don't.

.. _PEP 8: https://www.python.org/dev/peps/pep-0008/ .. _mpv.py: https://raw.githubusercontent.com/jaseg/python-mpv/master/mpv.py .. _cosven: https://github.com/cosven .. _Robozman: https://gitlab.com/robozman .. _dfaker: https://github.com/dfaker

Note that the project description data, including the texts, logos, images, and/or trademarks, for each open source project belongs to its rightful owner. If you wish to add or remove any projects, please contact us at [email protected].