### Basic mpv playback with python-mpv

Source: https://github.com/jaseg/python-mpv/blob/main/README.rst

This Python code snippet demonstrates how to initialize an mpv player instance, play a video from a URL (YouTube in this case, enabled by ytdl=True), and wait for playback to complete. It requires the mpv library to be installed.

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

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

### Install python-mpv using pip

Source: https://github.com/jaseg/python-mpv/blob/main/README.rst

This command installs the python-mpv library using pip, the Python package installer. It's the recommended way to get the library, although manual inclusion of the mpv.py file is also possible.

```bash
pip install mpv
```

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

### Control MPV Player Instance with Python Bindings

Source: https://github.com/jaseg/python-mpv/blob/main/README.rst

This snippet shows basic MPV player control using python-mpv. It demonstrates setting player properties like fullscreen, loop, and video output. It also includes examples of custom key press bindings and taking screenshots.

```python
import mpv

player = mpv.MPV()

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

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

### Enable MPV's Built-in GUI with python-mpv

Source: https://github.com/jaseg/python-mpv/blob/main/README.rst

This example illustrates how to enable MPV's graphical user interface features, such as the On-Screen Controller (OSC) and keyboard input, when embedding MPV using libmpv. It shows the necessary options to pass during MPV instance initialization.

```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',
```

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

### Load External Subtitles with MPV Player

Source: https://github.com/jaseg/python-mpv/blob/main/README.rst

This snippet shows two methods for loading external subtitle files with MPV. The first uses the `loadfile` function with the `sub_file` option. The second demonstrates adding subtitles at runtime using `sub_add` after the player has started playing.

```python
#!/usr/bin/env python3
import mpv

player = mpv.MPV()
player.loadfile('test.webm', sub_file='test.srt')
player.wait_for_playback()
```

```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()
```

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

### Embed mpv in PyGObject (GTK) Application

Source: https://github.com/jaseg/python-mpv/blob/main/README.rst

This example shows how to embed an mpv player within a PyGObject (GTK) application. It creates a GTK window and a frame widget, then initializes the mpv player using the window ID of the frame. Proper locale settings are crucial before mpv initialization.

```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__':
    # This is necessary since like Qt, Gtk stomps over the locale settings needed by libmpv.
    # Like with Qt, this needs to happen after importing Gtk but before creating the first mpv.MPV instance.
    import locale
    locale.setlocale(locale.LC_NUMERIC, 'C')
    
    application = MainClass()
    Gtk.main()

```

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

### Stream Media Data Directly to MPV Player

Source: https://github.com/jaseg/python-mpv/blob/main/README.rst

This example demonstrates feeding media data directly from a Python generator function to the MPV player. It uses the `@player.python_stream` decorator to define a stream named 'foo', reads data from a file in chunks, and plays it using the 'python://foo' URL.

```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()
```

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

### Skip Silence in Audio Files Using libav Filters

Source: https://github.com/jaseg/python-mpv/blob/main/README.rst

This example utilizes the libav 'silencedetect' filter to identify and skip silent parts at the beginning of an audio file. It configures the filter, parses its output from mpv's logs to determine silence duration, and adjusts playback accordingly.

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

p = mpv.MPV()
p.play(sys.argv[1])

def skip_silence():
    p.set_loglevel('debug')
    p.af = 'lavfi=[silencedetect=n=-20dB:d=1]'
    p.speed = 100
    def check(evt):
        toks = evt['event']['text'].split()
        if 'silence_end:' in toks:
            return float(toks[2])
    p.time_pos = p.wait_for_event('log_message', cond=check)
    p.speed = 1
    p.af = ''

skip_silence()
p.wait_for_playback()
```

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

### Advanced mpv configuration and logging with python-mpv

Source: https://github.com/jaseg/python-mpv/blob/main/README.rst

This Python script shows advanced configuration of the mpv player via python-mpv. It sets up a custom log handler, enables YouTube-dl support, and configures default and VO-specific keyboard bindings. It also demonstrates property observation for the 'time-pos' property.

```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
```

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

### Create Dynamic Video Overlays with PIL

Source: https://github.com/jaseg/python-mpv/blob/main/README.rst

This snippet demonstrates how to create and update video overlays dynamically using the Pillow (PIL) library. It continuously generates images with text, including timestamps, and displays them on the video at specified positions, updating them in real-time.

```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()
```

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

### Manage Playlists with python-mpv

Source: https://github.com/jaseg/python-mpv/blob/main/README.rst

This code illustrates how to manage media playlists using python-mpv. It shows how to append multiple video URLs to a playlist, set the current playback position, and continuously print the playlist contents. Modifications to the playlist are done via specific player methods.

```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()
```

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

### Embed mpv in PyQt5 Application

Source: https://github.com/jaseg/python-mpv/blob/main/README.rst

This snippet demonstrates how to embed an mpv player instance within a PyQt5 QMainWindow. It initializes the mpv player with the window ID of a QWidget container and plays a video file. Note the necessary locale setting adjustment for compatibility.

```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_())

```

=== COMPLETE CONTENT === This response contains all available snippets from this library. No additional content exists. Do not make further requests.