From cf314f261595a6fb1f043634dd1436228b711aa5 Mon Sep 17 00:00:00 2001 From: Fabio Manganiello Date: Sat, 13 Jan 2024 22:36:42 +0100 Subject: [PATCH] [mpv] Refactored plugin. I hadn't paid attention to this plugin in a while and the newest mpv API has diverged so much that it was entirely incompatible with recent mpv versions. --- platypush/plugins/media/mpv/__init__.py | 413 +++++++++++++----------- 1 file changed, 232 insertions(+), 181 deletions(-) diff --git a/platypush/plugins/media/mpv/__init__.py b/platypush/plugins/media/mpv/__init__.py index a83504a978..97bf3b5efc 100644 --- a/platypush/plugins/media/mpv/__init__.py +++ b/platypush/plugins/media/mpv/__init__.py @@ -1,10 +1,12 @@ -from dataclasses import asdict import os -import threading +from dataclasses import asdict +from typing import Any, Dict, Optional, Type +from urllib.parse import quote -from platypush.context import get_bus +from platypush.plugins import action from platypush.plugins.media import PlayerState, MediaPlugin from platypush.message.event.media import ( + MediaEvent, MediaPlayEvent, MediaPlayRequestEvent, MediaPauseEvent, @@ -14,8 +16,6 @@ from platypush.message.event.media import ( MediaResumeEvent, ) -from platypush.plugins import action - class MediaMpvPlugin(MediaPlugin): """ @@ -27,26 +27,29 @@ class MediaMpvPlugin(MediaPlugin): 'start_event_thread': True, } - def __init__(self, args=None, *argv, **kwargs): + def __init__( + self, args: Optional[Dict[str, Any]] = None, fullscreen: bool = False, **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] + :param fullscreen: Set to True if you want media files to be opened in + fullscreen by default (can be overridden by `.play()`) (default: False) """ - super().__init__(*argv, **kwargs) + super().__init__(**kwargs) - self.args = self._default_mpv_args + self.args = {**self._default_mpv_args} if args: - # noinspection PyTypeChecker self.args.update(args) + if fullscreen: + self.args['fs'] = True self._player = None - self._playback_rebounce_event = threading.Event() - self._on_stop_callbacks = [] + self._latest_state = PlayerState.STOP def _init_mpv(self, args=None): import mpv @@ -59,80 +62,85 @@ class MediaMpvPlugin(MediaPlugin): os.environ[k] = v self._player = mpv.MPV(**mpv_args) - # noinspection PyProtectedMember self._player._event_callbacks += [self._event_callback()] - @staticmethod - def _post_event(evt_type, **evt): - bus = get_bus() - bus.post(evt_type(player='local', plugin='media.mpv', **evt)) + def _post_event(self, evt_type: Type[MediaEvent], **evt): + self._bus.post( + evt_type( + player='local', + plugin='media.mpv', + resource=evt.pop('resource', self._resource), + title=self._filename, + **evt, + ) + ) + + @property + def _cur_player(self): + if self._player and not self._player.core_shutdown: + return self._player + + return None + + @property + def _state(self): + player = self._cur_player + if not player: + return PlayerState.STOP + + return PlayerState.PAUSE if player.pause else PlayerState.PLAY + + @property + def _resource(self): + if not self._cur_player: + return None + + cur_resource = self._cur_player.stream_path + if not cur_resource: + return None + + return quote( + ('file://' if os.path.isfile(cur_resource) else '') + str(cur_resource) + ) + + @property + def _filename(self): + if not self._cur_player: + return None + + return self._cur_player.filename def _event_callback(self): def callback(event): - from mpv import ( - MpvEvent, - MpvEventID as Event, - MpvEventEndFile as EndFile, - ) + from mpv import MpvEvent - self.logger.info('Received mpv event: {}'.format(event)) + self.logger.info('Received mpv event: %s', event) if isinstance(event, MpvEvent): event = event.as_dict() - - evt = event.get('event_id') - if not evt: + if not isinstance(event, dict): return - if ( - evt == Event.FILE_LOADED or evt == Event.START_FILE - ) and self._get_current_resource(): - self._playback_rebounce_event.set() - self._post_event( - NewPlayingMediaEvent, - resource=self._get_current_resource(), - title=self._player.filename, - ) - elif evt == Event.PLAYBACK_RESTART: - self._playback_rebounce_event.set() - self._post_event( - MediaPlayEvent, - resource=self._get_current_resource(), - title=self._player.filename, - ) - elif evt == Event.PAUSE: - self._post_event( - MediaPauseEvent, - resource=self._get_current_resource(), - title=self._player.filename, - ) - elif evt == Event.UNPAUSE: - self._post_event( - MediaResumeEvent, - resource=self._get_current_resource(), - title=self._player.filename, - ) - elif ( - evt == Event.SHUTDOWN - or evt == Event.IDLE - or ( - evt == Event.END_FILE - and event.get('event', {}).get('reason') - in [EndFile.EOF, EndFile.ABORTED, EndFile.QUIT] - ) - ): - playback_rebounced = self._playback_rebounce_event.wait(timeout=0.5) - if playback_rebounced: - self._playback_rebounce_event.clear() - return + evt_type = event.get('event', b'').decode() + if not evt_type: + return - self._player = None - self._post_event(MediaStopEvent) + if evt_type == 'start-file': + self._post_event(NewPlayingMediaEvent) + elif evt_type == 'playback-restart': + self._post_event(MediaPlayEvent) + elif evt_type in ('shutdown', 'idle', 'end-file'): + if self._state != PlayerState.PLAY: + self._post_event(MediaStopEvent) - for cbk in self._on_stop_callbacks: - cbk() - elif evt == Event.SEEK: - self._post_event(MediaSeekEvent, position=self._player.playback_time) + if evt_type == 'shutdown' and self._player: + self._player = None + elif evt_type == 'seek' and self._cur_player: + self._post_event( + MediaSeekEvent, position=self._cur_player.playback_time + ) + + self._latest_state = self._state return callback @@ -141,35 +149,41 @@ class MediaMpvPlugin(MediaPlugin): """ Execute a raw mpv command. """ - if not self._player: - return None, 'No mpv instance is running' - return self._player.command(cmd, *args) + if not self._cur_player: + return None + + return self._cur_player.command(cmd, *args) @action - def play(self, resource, subtitles=None, **args): + def play( + self, + resource: str, + *_, + subtitles: Optional[str] = None, + fullscreen: Optional[bool] = 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] """ self._post_event(MediaPlayRequestEvent, resource=resource) + if fullscreen is not None: + args['fs'] = fullscreen + self._init_mpv(args) resource = self._get_resource(resource) if resource.startswith('file://'): resource = resource[7:] - assert self._player, 'The player is not ready' - self._player.play(resource) + assert self._cur_player, 'The player is not ready' + self._cur_player.play(resource) if self.volume: self.set_volume(volume=self.volume) if subtitles: @@ -178,43 +192,54 @@ class MediaMpvPlugin(MediaPlugin): return self.status() @action - def pause(self): + def pause(self, *_, **__): """Toggle the paused state""" - if not self._player: - return None, 'No mpv instance is running' + if not self._cur_player: + return None - self._player.pause = not self._player.pause + self._cur_player.pause = not self._cur_player.pause return self.status() @action - def quit(self): + def quit(self, *_, **__): """Stop and quit the player""" - if not self._player: - return None, 'No mpv instance is running' + player = self._cur_player + if not player: + return None - self._player.quit() - self._player.terminate() + player.stop() + player.quit(code=0) + player.wait_for_shutdown(timeout=10) + player.terminate() self._player = None - return {'state': PlayerState.STOP.value} + return self.status() @action - def stop(self): + 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) + def _set_vol(self, *_, step=10.0, **__): + if not self._cur_player: + return None + + return self.set_volume(float(self._cur_player.volume or 0) - step) @action - def volup(self, step=10.0): + def voldown(self, *_, step: float = 10.0, **__): + """Volume down by (default: 10)%""" + if not self._cur_player: + return None + + return self.set_volume(float(self._cur_player.volume or 0) - step) + + @action + def volup(self, step: float = 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) + if not self._cur_player: + return None + + return self.set_volume(float(self._cur_player.volume or 0) + step) @action def set_volume(self, volume): @@ -224,82 +249,92 @@ class MediaMpvPlugin(MediaPlugin): :param volume: Volume value between 0 and 100 :type volume: float """ - if not self._player: - return None, 'No mpv instance is running' + if not self._cur_player: + return None - volume = max(0, min([self._player.volume_max, volume])) - self._player.volume = volume + max_vol = ( + self._cur_player.volume_max + if self._cur_player.volume_max is not None + else 100 + ) + volume = max(0, min([max_vol, volume])) + self._cur_player.volume = volume return self.status() @action - def seek(self, position): + def seek(self, position: float, **_): """ 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 + if not self._cur_player: + return None + + assert self._cur_player.seekable, 'The resource is not seekable' + self._cur_player.time_pos = min( + float(self._cur_player.time_pos or 0) + + float(self._cur_player.time_remaining or 0), + max(0, position), + ) return self.status() @action - def back(self, offset=30.0): + def back(self, offset=30.0, **_): """Back by (default: 30) 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) + if not self._cur_player: + return None + + assert self._cur_player.seekable, 'The resource is not seekable' + cur_pos = float(self._cur_player.time_pos or 0) + return self.seek(cur_pos - offset) @action - def forward(self, offset=30.0): + def forward(self, offset=30.0, **_): """Forward by (default: 30) 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) + if not self._cur_player: + return None + + assert self._cur_player.seekable, 'The resource is not seekable' + cur_pos = float(self._cur_player.time_pos or 0) + return self.seek(cur_pos + offset) @action - def next(self): + 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() + if not self._cur_player: + return None + + self._cur_player.playlist_next() + return self.status() @action - def prev(self): + 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() + if not self._cur_player: + return None + + self._cur_player.playlist_prev() + return self.status() @action - def toggle_subtitles(self, visible=None): + def toggle_subtitles(self, *_, **__): """Toggle the subtitles visibility""" return self.toggle_property('sub_visibility') @action def add_subtitles(self, filename): """Add a subtitles file""" - return self._player.sub_add(filename) + if not self._cur_player: + return None + + return self._cur_player.sub_add(filename) @action def toggle_fullscreen(self): """Toggle the fullscreen mode""" return self.toggle_property('fullscreen') - # noinspection PyShadowingBuiltins @action def toggle_property(self, property): """ @@ -309,7 +344,7 @@ class MediaMpvPlugin(MediaPlugin): :param property: Property to toggle """ if not self._player: - return None, 'No mpv instance is running' + return None if not hasattr(self._player, property): self.logger.warning('No such mpv property: {}'.format(property)) @@ -318,7 +353,6 @@ class MediaMpvPlugin(MediaPlugin): setattr(self._player, property, value) return {property: value} - # noinspection PyShadowingBuiltins @action def get_property(self, property): """ @@ -326,7 +360,7 @@ class MediaMpvPlugin(MediaPlugin): ``man mpv`` for a full list of the available properties """ if not self._player: - return None, 'No mpv instance is running' + return None return getattr(self._player, property) @action @@ -339,29 +373,28 @@ class MediaMpvPlugin(MediaPlugin): :type props: dict """ if not self._player: - return None, 'No mpv instance is running' + return None for k, v in props.items(): setattr(self._player, k, v) return props @action - def set_subtitles(self, filename, *args, **kwargs): + def set_subtitles(self, filename, *_, **__): """Sets media subtitles from filename""" - # noinspection PyTypeChecker return self.set_property(subfile=filename, sub_visibility=True) @action - def remove_subtitles(self, sub_id=None): + def remove_subtitles(self, sub_id=None, **_): """Removes (hides) the subtitles""" if not self._player: - return None, 'No mpv instance is running' + return None if sub_id: return self._player.sub_remove(sub_id) self._player.sub_visibility = False @action - def is_playing(self): + def is_playing(self, **_): """ :returns: True if it's playing, False otherwise """ @@ -379,36 +412,58 @@ class MediaMpvPlugin(MediaPlugin): return self._player.loadfile(resource, mode='append-play') @action - def mute(self): + def mute(self, **_): """Toggle mute state""" if not self._player: - return None, 'No mpv instance is running' + return None mute = not self._player.mute self._player.mute = mute return {'muted': mute} @action - def set_position(self, position): + def set_position(self, position: float, **_): """ Seek backward/forward to the specified absolute position (same as ``seek``) """ return self.seek(position) @action - def status(self): + def status(self, **_): """ Get the current player state. :returns: A dictionary containing the current state. - Example:: + Example: + + .. code-block:: javascript + + { + "audio_channels": 2, + "audio_codec": "mp3", + "delay": 0, + "duration": 300.0, + "file_size": 123456, + "filename": "filename or stream URL", + "fullscreen": false, + "mute": false, + "name": "mpv", + "pause": false, + "percent_pos": 10.0, + "position": 30.0, + "seekable": true, + "state": "play", // or "stop" or "pause" + "title": "filename or stream URL", + "url": "file:///path/to/file.mp3", + "video_codec": "h264", + "video_format": "avc1", + "volume": 50.0, + "volume_max": 100.0, + "width": 1280 + } - output = { - "filename": "filename or stream URL", - "state": "play" # or "stop" or "pause" - } """ - if not self._player or not hasattr(self._player, 'pause'): + if not self._cur_player: return {'state': PlayerState.STOP.value} status = { @@ -428,14 +483,10 @@ class MediaMpvPlugin(MediaPlugin): 'percent_pos': getattr(self._player, 'percent_pos', None), 'position': getattr(self._player, 'playback_time', None), 'seekable': getattr(self._player, 'seekable', None), - 'state': ( - PlayerState.PAUSE.value - if self._player.pause - else PlayerState.PLAY.value - ), + 'state': self._state.value, 'title': getattr(self._player, 'media_title', None) or getattr(self._player, 'filename', None), - 'url': self._get_current_resource(), + 'url': self._resource, 'video_codec': getattr(self._player, 'video_codec', None), 'video_format': getattr(self._player, 'video_format', None), 'volume': getattr(self._player, 'volume', None), @@ -452,19 +503,19 @@ class MediaMpvPlugin(MediaPlugin): } ) + if self._state != self._latest_state: + if not self._cur_player: + self._post_event(MediaStopEvent) + else: + self._post_event( + MediaPauseEvent + if self._state == PlayerState.PAUSE + else MediaResumeEvent + ) + + self._latest_state = self._state return status - 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 - def _get_resource(self, resource): if self._is_youtube_resource(resource): return resource # mpv can handle YouTube streaming natively