platypush/platypush/plugins/media/mpv.py

import os
import re
import threading

from platypush.context import get_bus, get_plugin
from platypush.plugins.media import PlayerState, MediaPlugin
from platypush.message.event.media import MediaPlayEvent, MediaPlayRequestEvent, \
    MediaPauseEvent, MediaStopEvent, NewPlayingMediaEvent, MediaSeekEvent

from platypush.plugins import action


class MediaMpvPlugin(MediaPlugin):
    """
    Plugin to control MPV instances

    Requires:

        * **python-mpv** (``pip install python-mpv``)
        * **mpv** executable on your system
    """

    _default_mpv_args = {
        'ytdl': True,
        'start_event_thread': True,
    }

    def __init__(self, args=None, *argv, **kwargs):
        """
        Create the MPV wrapper.

        :param args: Default arguments that will be passed to the mpv executable
            as a key-value dict (names without the `--` prefix). See `man mpv`
            for available options.
        :type args: dict[str, str]
        """

        super().__init__(*argv, **kwargs)

        self.args = self._default_mpv_args
        if args:
            self.args.update(args)

        self._player = None
        self._is_playing_torrent = False
        self._playback_rebounce_event = threading.Event()
        self._on_stop_callbacks = []

    def _init_mpv(self, args=None):
        import mpv

        mpv_args = self.args.copy()
        if args:
            mpv_args.update(args)

        for k,v in self._env.items():
            os.environ[k] = v

        self._player = mpv.MPV(**mpv_args)
        self._player.register_event_callback(self._event_callback())

    def _event_callback(self):
        def callback(event):
            from mpv import MpvEventID as Event
            from mpv import MpvEventEndFile as EndFile

            self.logger.info('Received mpv event: {}'.format(event))

            evt = event.get('event_id')
            if not evt:
                return

            bus = get_bus()
            if (evt == Event.FILE_LOADED or evt == Event.START_FILE) and self._get_current_resource():
                self._playback_rebounce_event.set()
                bus.post(NewPlayingMediaEvent(resource=self._get_current_resource(), title=self._player.filename))
                bus.post(MediaPlayEvent(resource=self._get_current_resource(), title=self._player.filename))
            elif evt == Event.PLAYBACK_RESTART:
                self._playback_rebounce_event.set()
            elif evt == Event.PAUSE:
                bus.post(MediaPauseEvent(resource=self._get_current_resource(), title=self._player.filename))
            elif evt == Event.UNPAUSE:
                bus.post(MediaPlayEvent(resource=self._get_current_resource(), title=self._player.filename))
            elif evt == Event.SHUTDOWN or (
                evt == Event.END_FILE and event.get('event', {}).get('reason')
                in [EndFile.EOF_OR_INIT_FAILURE, EndFile.ABORTED, EndFile.QUIT]):
                playback_rebounced = self._playback_rebounce_event.wait(timeout=0.5)
                if playback_rebounced:
                    self._playback_rebounce_event.clear()
                    return

                self._player = None
                bus.post(MediaStopEvent())

                for callback in self._on_stop_callbacks:
                    callback()
            elif evt == Event.SEEK:
                bus.post(MediaSeekEvent(position=self._player.playback_time))

        return callback

    @staticmethod
    def _get_youtube_link(resource):
        base_url = 'https://youtu.be/'
        regexes = ['^https://(www\.)?youtube.com/watch\?v=([^?&#]+)',
                   '^https://(www\.)?youtu.be.com/([^?&#]+)',
                   '^(youtube:video):([^?&#]+)']

        for regex in regexes:
            m = re.search(regex, resource)
            if m: return base_url + m.group(2)
        return None

    @action
    def execute(self, cmd, **args):
        """
        Execute a raw mpv command.
        """
        if not self._player:
            return None, 'No mpv instance is running'
        return self._player.command(cmd, *args)

    @action
    def play(self, resource, subtitles=None, **args):
        """
        Play a resource.

        :param resource: Resource to play - can be a local file or a remote URL
        :type resource: str

        :param subtitles: Path to optional subtitle file
        :type subtitles: str

        :param args: Extra runtime arguments that will be passed to the
            mpv executable as a key-value dict (keys without `--` prefix)
        :type args: dict[str,str]
        """

        get_bus().post(MediaPlayRequestEvent(resource=resource))
        self._init_mpv(args)

        if subtitles:
            args['sub_file'] = self.get_subtitles_file(subtitles)

        resource = self._get_resource(resource)

        if resource.startswith('file://'):
            resource = resource[7:]
        elif resource.startswith('magnet:?'):
            self._is_playing_torrent = True
            return get_plugin('media.webtorrent').play(resource)
        else:
            yt_resource = self._get_youtube_link(resource)
            if yt_resource: resource = yt_resource

        self._is_playing_torrent = False
        self._player.play(resource)
        return self.status()

    @action
    def pause(self):
        """ Toggle the paused state """
        if not self._player:
            return None, 'No mpv instance is running'

        self._player.pause = not self._player.pause
        return self.status()

    @action
    def quit(self):
        """ Stop and quit the player """
        self._stop_torrent()
        if not self._player:
            return None, 'No mpv instance is running'

        self._player.quit()
        self._player.terminate()
        self._player = None
        return {'state': PlayerState.STOP.value}

    @action
    def stop(self):
        """ Stop and quit the player """
        return self.quit()

    @action
    def voldown(self, step=10.0):
        """ Volume down by (default: 10)% """
        if not self._player:
            return None, 'No mpv instance is running'
        return self.set_volume(self._player.volume-step)

    @action
    def volup(self, step=10.0):
        """ Volume up by (default: 10)% """
        if not self._player:
            return None, 'No mpv instance is running'
        return self.set_volume(self._player.volume+step)

    @action
    def set_volume(self, volume):
        """
        Set the volume

        :param volume: Volume value between 0 and 100
        :type volume: float
        """
        if not self._player:
            return None, 'No mpv instance is running'

        volume = max(0, min([self._player.volume_max, volume]))
        self._player.volume = volume
        return {'volume': volume}

    @action
    def seek(self, position):
        """
        Seek backward/forward by the specified number of seconds

        :param position: Number of seconds relative to the current cursor
        :type position: int
        """
        if not self._player:
            return None, 'No mpv instance is running'
        if not self._player.seekable:
            return None, 'The resource is not seekable'
        pos = min(self._player.time_pos+self._player.time_remaining,
                  max(0, position))
        self._player.time_pos = pos
        return {'position': pos}

    @action
    def back(self, offset=60.0):
        """ Back by (default: 60) seconds """
        if not self._player:
            return None, 'No mpv instance is running'
        if not self._player.seekable:
            return None, 'The resource is not seekable'
        pos = max(0, self._player.time_pos-offset)
        return self.seek(pos)

    @action
    def forward(self, offset=60.0):
        """ Forward by (default: 60) seconds """
        if not self._player:
            return None, 'No mpv instance is running'
        if not self._player.seekable:
            return None, 'The resource is not seekable'
        pos = min(self._player.time_pos+self._player.time_remaining,
                  self._player.time_pos+offset)
        return self.seek(pos)

    @action
    def next(self):
        """ Play the next item in the queue """
        if not self._player:
            return None, 'No mpv instance is running'
        self._player.playlist_next()

    @action
    def prev(self):
        """ Play the previous item in the queue """
        if not self._player:
            return None, 'No mpv instance is running'
        self._player.playlist_prev()

    @action
    def toggle_subtitles(self, visible=None):
        """ Toggle the subtitles visibility """
        return self.toggle_property('sub_visibility')

    @action
    def toggle_fullscreen(self, fullscreen=None):
        """ Toggle the fullscreen mode """
        return self.toggle_property('fullscreen')

    @action
    def toggle_property(self, property):
        """
        Toggle or sets the value of an mpv property (e.g. fullscreen,
        sub_visibility etc.). See ``man mpv`` for a full list of properties

        :param property: Property to toggle
        """
        if not self._player:
            return (None, 'No mpv instance is running')

        if not hasattr(self._player, property):
            self.logger.warning('No such mpv property: {}'.format(property))

        value = not getattr(self._player, property)
        setattr(self._player, property, value)
        return { property: value }

    @action
    def get_property(self, property):
        """
        Get a player property (e.g. pause, fullscreen etc.). See
        ``man mpv`` for a full list of the available properties
        """
        if not self._player:
            return (None, 'No mpv instance is running')
        return getattr(self._player, property)

    @action
    def set_property(self, **props):
        """
        Set the value of an mpv property (e.g. fullscreen, sub_visibility
        etc.). See ``man mpv`` for a full list of properties

        :param props: Key-value args for the properties to set
        :type props: dict
        """
        if not self._player:
            return (None, 'No mpv instance is running')

        for k,v in props.items():
            setattr(self._player, k, v)
        return props

    @action
    def set_subtitles(self, filename, *args, **kwargs):
        """ Sets media subtitles from filename """
        return self.set_property(subfile=filename, sub_visibility=True)

    @action
    def remove_subtitles(self):
        """ Removes (hides) the subtitles """
        if not self._player:
            return (None, 'No mpv instance is running')
        self._player.sub_visibility = False

    @action
    def is_playing(self):
        """
        :returns: True if it's playing, False otherwise
        """
        if not self._player:
            return False
        return not self._player.pause

    @action
    def load(self, resource, **args):
        """
        Load/queue a resource/video to the player
        """
        if not self._player:
            return self.play(resource, **args)
        return self._player.loadfile(resource, mode='append-play', **args)

    @action
    def mute(self):
        """ Toggle mute state """
        if not self._player:
            return (None, 'No mpv instance is running')
        mute = not self._player.mute
        self._player.mute = mute
        return { 'muted': mute }

    @action
    def set_position(self, position):
        """
        Seek backward/forward to the specified absolute position (same as ``seek``)
        """
        return self.seek(position)

    @action
    def status(self):
        """
        Get the current player state.

        :returns: A dictionary containing the current state.

        Example::

            output = {
                "filename": "filename or stream URL",
                "state": "play"  # or "stop" or "pause"
            }
        """
        if not self._player or not hasattr(self._player, 'pause'):
            return {'state': PlayerState.STOP.value}

        return {
            'alang': getattr(self._player, 'alang'),
            'aspect': getattr(self._player, 'aspect'),
            'audio': getattr(self._player, 'audio'),
            'audio_bitrate': getattr(self._player, 'audio_bitrate'),
            'audio_buffer': getattr(self._player, 'audio_buffer'),
            'audio_channels': getattr(self._player, 'audio_channels'),
            'audio_client_name': getattr(self._player, 'audio_client_name'),
            'audio_codec': getattr(self._player, 'audio_codec'),
            'audio_codec_name': getattr(self._player, 'audio_codec_name'),
            'audio_delay': getattr(self._player, 'audio_delay'),
            'audio_device': getattr(self._player, 'audio_device'),
            'audio_device_list': getattr(self._player, 'audio_device_list'),
            'audio_exclusive': getattr(self._player, 'audio_exclusive'),
            'audio_file_paths': getattr(self._player, 'audio_file_paths'),
            'audio_files': getattr(self._player, 'audio_files'),
            'audio_format': getattr(self._player, 'audio_format'),
            'audio_out_params': getattr(self._player, 'audio_out_params'),
            'audio_params': getattr(self._player, 'audio_params'),
            'audio_mixer_device': getattr(self._player, 'alsa_mixer_device'),
            'audio_mixer_index': getattr(self._player, 'alsa_mixer_index'),
            'audio_mixer_name': getattr(self._player, 'alsa_mixer_name'),
            'autosub': getattr(self._player, 'autosub'),
            'autosync': getattr(self._player, 'autosync'),
            'background': getattr(self._player, 'background'),
            'border': getattr(self._player, 'border'),
            'brightness': getattr(self._player, 'brightness'),
            'chapter': getattr(self._player, 'chapter'),
            'chapter_list': getattr(self._player, 'chapter_list'),
            'chapter_metadata': getattr(self._player, 'chapter_metadata'),
            'chapters': getattr(self._player, 'chapters'),
            'chapters_file': getattr(self._player, 'chapters_file'),
            'clock': getattr(self._player, 'clock'),
            'cookies': getattr(self._player, 'cookies'),
            'cookies_file': getattr(self._player, 'cookies_file'),
            'current_ao': getattr(self._player, 'current_ao'),
            'current_vo': getattr(self._player, 'current_vo'),
            'delay': getattr(self._player, 'delay'),
            'display_names': getattr(self._player, 'display_names'),
            'end': getattr(self._player, 'end'),
            'endpos': getattr(self._player, 'endpos'),
            'eof_reached': getattr(self._player, 'eof_reached'),
            'file_format': getattr(self._player, 'file_format'),
            'filename': getattr(self._player, 'filename'),
            'file_size': getattr(self._player, 'file_size'),
            'font': getattr(self._player, 'font'),
            'fps': getattr(self._player, 'fps'),
            'fullscreen': getattr(self._player, 'fs'),
            'height': getattr(self._player, 'height'),
            'idle': getattr(self._player, 'idle'),
            'idle_active': getattr(self._player, 'idle_active'),
            'length': getattr(self._player, 'playback_time', 0) + getattr(self._player, 'playtime_remaining', 0)
                      if getattr(self._player, 'playtime_remaining') else None,
            'loop': getattr(self._player, 'loop'),
            'media_title': getattr(self._player, 'loop'),
            'mpv_configuration': getattr(self._player, 'mpv_configuration'),
            'mpv_version': getattr(self._player, 'mpv_version'),
            'mute': getattr(self._player, 'mute'),
            'name': getattr(self._player, 'name'),
            'pause': getattr(self._player, 'pause'),
            'percent_pos': getattr(self._player, 'percent_pos'),
            'playlist': getattr(self._player, 'playlist'),
            'playlist_pos': getattr(self._player, 'playlist_pos'),
            'position': getattr(self._player, 'playback_time'),
            'quiet': getattr(self._player, 'quiet'),
            'really_quiet': getattr(self._player, 'really_quiet'),
            'saturation': getattr(self._player, 'saturation'),
            'screen': getattr(self._player, 'screen'),
            'screenshot_directory': getattr(self._player, 'screenshot_directory'),
            'screenshot_format': getattr(self._player, 'screenshot_format'),
            'screenshot_template': getattr(self._player, 'screenshot_template'),
            'seekable': getattr(self._player, 'seekable'),
            'seeking': getattr(self._player, 'seeking'),
            'shuffle': getattr(self._player, 'shuffle'),
            'speed': getattr(self._player, 'speed'),
            'state': (PlayerState.PAUSE.value if self._player.pause else PlayerState.PLAY.value),
            'stream_pos': getattr(self._player, 'stream_pos'),
            'sub': getattr(self._player, 'sub'),
            'sub_file_paths': getattr(self._player, 'sub_file_paths'),
            'sub_files': getattr(self._player, 'sub_files'),
            'sub_paths': getattr(self._player, 'sub_paths'),
            'sub_text': getattr(self._player, 'sub_text'),
            'subdelay': getattr(self._player, 'subdelay'),
            'terminal': getattr(self._player, 'terminal'),
            'time_start': getattr(self._player, 'time_start'),
            'title': getattr(self._player, 'filename'),
            'tv_alsa': getattr(self._player, 'tv_alsa'),
            'tv_audio': getattr(self._player, 'tv_audio'),
            'tv_audiorate': getattr(self._player, 'tv_audiorate'),
            'tv_channels': getattr(self._player, 'tv_channels'),
            'tv_device': getattr(self._player, 'tv_device'),
            'tv_height': getattr(self._player, 'tv_height'),
            'tv_volume': getattr(self._player, 'tv_volume'),
            'tv_width': getattr(self._player, 'tv_width'),
            'url': self._get_current_resource(),
            'user_agent': getattr(self._player, 'user_agent'),
            'video': getattr(self._player, 'video'),
            'video_align_x': getattr(self._player, 'video_align_x'),
            'video_align_y': getattr(self._player, 'video_align_y'),
            'video_aspect': getattr(self._player, 'video_aspect'),
            'video_bitrate': getattr(self._player, 'video_bitrate'),
            'video_codec': getattr(self._player, 'video_codec'),
            'video_format': getattr(self._player, 'video_format'),
            'video_params': getattr(self._player, 'video_params'),
            'video_sync': getattr(self._player, 'video_sync'),
            'video_zoom': getattr(self._player, 'video_zoom'),
            'vlang': getattr(self._player, 'vlang'),
            'volume': getattr(self._player, 'volume'),
            'volume_max': getattr(self._player, 'volume_max'),
            'width': getattr(self._player, 'width'),
            'window_minimized': getattr(self._player, 'window_minimized'),
            'window_scale': getattr(self._player, 'window_scale'),
            'working_directory': getattr(self._player, 'working_directory'),
            'ytdl': getattr(self._player, 'ytdl'),
        }

    def on_stop(self, callback):
        self._on_stop_callbacks.append(callback)

    def _get_current_resource(self):
        if not self._player or not self._player.stream_path:
            return

        return ('file://' if os.path.isfile(self._player.stream_path)
                else '') + self._player.stream_path


# vim:sw=4:ts=4:et: