use media_loaded_v2 signal

feeluown/gui/uimain/nowplaying_overlay.py

@@ -53,10 +53,13 @@ def __init__(self, app: 'GuiApp', parent=None):
         self.setup_ui()
 
         self.artwork_view.mv_btn.clicked.connect(self.play_mv)
-        self.ctl_btns.media_btns.toggle_video_btn.clicked.connect(self.enter_video_mode)
-        self._app.player.video_channel_changed.connect(
-            self.on_video_channel_changed, aioqueue=True
+        self.ctl_btns.media_btns.toggle_video_btn.clicked.connect(
+            self.keep_and_enter_video_mode
         )
+        self._app.player.media_loaded_v2.connect(
+            self.on_media_loaded, aioqueue=True
+        )
+        self._keep_video_mode = False
 
     def setup_ui(self):
         self._layout.setContentsMargins(0, 0, 11, 0)
@@ -76,20 +79,31 @@ def play_mv(self):
         self._app.playlist.set_current_model(self._app.playlist.current_song_mv)
         self.enter_video_mode()
 
+    def keep_and_enter_video_mode(self):
+        self._keep_video_mode = True
+        self.enter_video_mode()
+
+    def unkeep_and_enter_cover_mode(self):
+        self._keep_video_mode = False
+        self.enter_cover_mode()
+
     def enter_video_mode(self):
         # FIXME: should call watch_mgr.set_mode
         self._app.watch_mgr.exit_pip_mode()
         self._app.watch_mgr.exit_fullwindow_mode()
         video_widget = self._app.ui.mpv_widget
         video_widget.overlay_auto_visible = True
-        with video_widget.change_parent():
+        if video_widget.parent() == self.artwork_view:
             self.artwork_view.set_body(video_widget)
+        else:
+            with video_widget.change_parent():
+                self.artwork_view.set_body(video_widget)
         self.ctl_btns.hide()
         self.progress.hide()
         video_widget.ctl_bar.clear_adhoc_btns()
         exit_btn = video_widget.ctl_bar.add_adhoc_btn('退出视频模式')
         fullwindow_btn = video_widget.ctl_bar.add_adhoc_btn('窗口全屏')
-        exit_btn.clicked.connect(self.enter_cover_mode)
+        exit_btn.clicked.connect(self.unkeep_and_enter_cover_mode)
         fullwindow_btn.clicked.connect(
             lambda: self._app.watch_mgr.
             enter_fullwindow_mode(go_back=self.enter_video_mode)
@@ -115,11 +129,11 @@ def showEvent(self, a0) -> None:
     def sizeHint(self):
         return QSize(500, 400)
 
-    def on_video_channel_changed(self, _):
-        if (
-            bool(self._app.player.video_channel) is False
-            and not self._app.ui.mpv_widget.is_changing_parent
-        ):
+    def on_media_loaded(self, properties):
+        if bool(properties['video_format']) is True:
+            if self._keep_video_mode:
+                self.enter_video_mode()
+        else:
             self.enter_cover_mode()
 
 

feeluown/gui/watch.py

@@ -57,22 +57,30 @@ def __init__(self, app: 'GuiApp'):
         self._pip_container = ResizableFramelessContainer()
         self._fullwindow_container = FullWindowContainer(app, parent=app)
 
-        #: Is the video widget visible before.
-        self._is_visible_before_auto_set_to_none = False
+        self._keep_fullwindow_mode = False
+        self._keep_pip_mode = False
 
     def initialize(self):
         self._initialize_mpv_video_renderring()
 
         self._ui = self._app.ui
         self._ui.pc_panel.media_btns.toggle_video_btn.clicked.connect(
-            lambda: self.set_mode(Mode.fullwindow))
+            lambda: self.keep_and_set_mode(Mode.fullwindow))
         self._app.player.media_changed.connect(self.on_media_changed, aioqueue=True)
-        self._app.player.video_channel_changed.connect(self.on_video_channel_changed, aioqueue=True)  # noqa
+        self._app.player.media_loaded_v2.connect(self.on_media_loaded, aioqueue=True)
 
         self._pip_container.setMinimumSize(200, 130)
         self._pip_container.hide()
         self._fullwindow_container.hide()
 
+    def keep_and_set_mode(self, mode):
+        mode = Mode(mode)
+        if mode is Mode.fullwindow:
+            self._keep_fullwindow_mode = True
+        elif mode is Mode.pip:
+            self._keep_pip_mode = True
+        self.set_mode(mode)
+
     def set_mode(self, mode):
         mode = Mode(mode)  # So that user can call set_mode(0/1/2) in REPL.
         if mode is Mode.none:
@@ -86,14 +94,14 @@ def set_mode(self, mode):
             # current mode and enter mode
             if mode is Mode.fullwindow:
                 self.exit_pip_mode()
-                self.enter_fullwindow_mode(go_back=self.exit_fullwindow_mode)
+                self.enter_fullwindow_mode(go_back=self.unkeep_and_exit_fullwindow_mode)
             else:
                 self.exit_fullwindow_mode()
                 self.enter_pip_mode()
 
     def enter_fullwindow_mode(self, go_back=None):
-        video_widget = self._app.ui.mpv_widget
         logger.debug("enter video-show fullwindow mode")
+        video_widget = self._app.ui.mpv_widget
         if video_widget.parent() != self._fullwindow_container:
             with video_widget.change_parent():
                 self._fullwindow_container.set_body(video_widget)
@@ -104,26 +112,23 @@ def enter_fullwindow_mode(self, go_back=None):
         video_widget.overlay_auto_visible = True
         video_widget.ctl_bar.clear_adhoc_btns()
         pip_btn = video_widget.ctl_bar.add_adhoc_btn('画中画')
-        pip_btn.clicked.connect(lambda: self.set_mode(Mode.pip))
+        pip_btn.clicked.connect(lambda: self.keep_and_set_mode(Mode.pip))
         if go_back is not None:
             hide_btn = video_widget.ctl_bar.add_adhoc_btn('最小化')
             hide_btn.clicked.connect(go_back)
 
+    def unkeep_pip_and_enter_fullwindow_mode(self):
+        self._keep_pip_mode = False
+        self.set_mode(Mode.fullwindow)
+
+    def unkeep_and_exit_fullwindow_mode(self):
+        self._keep_fullwindow_mode = False
+        self.exit_fullwindow_mode()
+
     def exit_fullwindow_mode(self):
-        self._app.ui.mpv_widget.hide()
         self._fullwindow_container.hide()
         logger.debug("exit video-show fullwindow mode")
 
-    def _is_pip_mode(self):
-        return self._app.ui.mpv_widget.parent() == self._pip_container
-
-    def _is_fullwindow_mode(self):
-        return (self._app.ui.mpv_widget.parent() == self._app and
-                self._app.ui.mpv_widget.isVisible())
-
-    def _is_none_mode(self):
-        return not (self._is_pip_mode() or self._is_fullwindow_mode())
-
     def enter_pip_mode(self):
         """enter picture in picture mode"""
         logger.debug("enter video-show picture in picture mode")
@@ -138,13 +143,13 @@ def enter_pip_mode(self):
         fullscreen_btn = video_widget.ctl_bar.add_adhoc_btn('全屏')
         hide_btn = video_widget.ctl_bar.add_adhoc_btn('退出画中画')
         fullscreen_btn.clicked.connect(self.toggle_pip_fullscreen)
-        hide_btn.clicked.connect(lambda: self.set_mode(Mode.fullwindow))
+        hide_btn.clicked.connect(self.unkeep_pip_and_enter_fullwindow_mode)
         self._pip_container.show()
         self._app.ui.mpv_widget.show()
         try:
             width = int(self._app.player._mpv.width)  # type: ignore
             height = int(self._app.player._mpv.height)  # type: ignore
-        except ValueError:
+        except TypeError:
             logger.exception('mpv video width/height is not a valid int')
         else:
             proper_width = max(min(width, 640), 320)
@@ -169,24 +174,14 @@ def on_media_changed(self, media):
             logger.debug('media is changed to none, hide video-show')
             self.set_mode(Mode.none)
 
-    def on_video_channel_changed(self, _):
-        if bool(self._app.player.video_channel) is False:
-            # When the mpv widget is changing it's parent, the video_channel may be
-            # changed to empty manully (see mpv_widget.change_parent).
-            if not self._app.ui.mpv_widget.is_changing_parent:
-                return
-
-            # HELP(cosven): Even if player play a valid video, the video_format
-            # is changed to none first, and then it is changed to the real value.
-            # So check if the video widget is visible before hide it.
-            self._is_visible_before_auto_set_to_none = self._app.ui.mpv_widget.isVisible()  # noqa
-            self.set_mode(Mode.none)
+    def on_media_loaded(self, properties):
+        if bool(properties['video_format']) is True:
+            if self._keep_fullwindow_mode:
+                self.set_mode(Mode.fullwindow)
+            elif self._keep_pip_mode:
+                self.set_mode(Mode.pip)
         else:
-            if self._is_visible_before_auto_set_to_none is True:
-                if self._is_fullwindow_mode():
-                    self.set_mode(Mode.fullwindow)
-                elif self._is_pip_mode():
-                    self.set_mode(Mode.pip)
+            self.set_mode(Mode.none)
 
     #
     # private methods

feeluown/gui/widgets/mpv_.py

@@ -37,7 +37,6 @@ def __init__(self, app, parent=None):
         self.mpv = self._app.player._mpv  # noqa
         self.ctx = None
         self.get_proc_addr_c = OpenGlCbGetProcAddrFn(get_proc_addr)
-        self._is_changing_parent = False
 
     def initializeGL(self):
         params = {'get_proc_address': self.get_proc_addr_c}
@@ -99,26 +98,18 @@ def sizeHint(self):
             return QSize(self.mpv.width, self.mpv.height)
         return super().sizeHint()
 
-    @property
-    def is_changing_parent(self):
-        return self._is_changing_parent
-
     @contextmanager
     def change_parent(self):
-        assert self._is_changing_parent is False, 'implementation bug'
-
         # on macOS, changing mpv widget parent cause no side effects.
         # on Linux (wayland), it seems changing mpv widget parent may cause segfault,
         # so do some hack to avoid crash.
         if not IS_MACOS:
-            self._is_changing_parent = True
             self._before_change_mpv_widget_parent()
         try:
             yield
         finally:
             if not IS_MACOS:
                 self._after_change_mpv_widget_parent()
-                self._is_changing_parent = False
 
     def _before_change_mpv_widget_parent(self):
         """

feeluown/player/base_player.py

@@ -47,7 +47,6 @@ def __init__(self, _=None, **kwargs):
         self._current_media = None
         self._current_metadata = Metadata()
         self._video_format = None
-        self._video_channel = False  # False, True, 1, int
 
         #: player position changed signal
         self.position_changed = Signal()
@@ -62,7 +61,10 @@ def __init__(self, _=None, **kwargs):
         #: media about to change: (old_media, media)
         self.media_about_to_changed = Signal()
         self.media_changed = Signal()  # Media source is changed (not loaded yet).
+        # The difference between media_loaded and media_loaded_v2 is that
+        # media_loaded_v2 carries some media properties.
         self.media_loaded = Signal()  # Start to play the media.
+        self.media_loaded_v2 = Signal()  # emit(properties)
         # Metadata is changed, and it may be changed during playing.
         self.metadata_changed = Signal()
         self.media_finished = Signal()  # Finish to play the media.

feeluown/player/mpvplayer.py

@@ -68,7 +68,6 @@ def __init__(self, _=None, audio_device=b'auto', winid=None,
 
         #: if video_format changes to None, there is no video available
         self.video_format_changed = Signal()
-        self.video_channel_changed = Signal()
 
         self._mpv.observe_property(
             'time-pos',
@@ -272,20 +271,6 @@ def video_format(self, vformat):
         # firstly changed to None, and then changed to the real format.
         self.video_format_changed.emit(vformat)
 
-    @property
-    def video_channel(self):
-        return self._video_channel
-
-    @video_channel.setter
-    def video_channel(self, value):
-        """
-        According to practice:
-        - when playing a audio, the video channel is changed to False.
-        - when playing a video, the video channel is changed to 1.
-        """
-        self._video_channel = value
-        self.video_channel_changed.emit(value)
-
     def _stop_mpv(self):
         # Remove current media.
         self._mpv.play("")
@@ -304,9 +289,6 @@ def _on_duration_changed(self, duration):
     def _on_video_format_changed(self, vformat):
         self.video_format = vformat
 
-    def _on_video_changed(self, video):
-        self.video_channel = video
-
     def _on_event(self, event):
         event_id = event['event_id']
         if event_id == MpvEventID.END_FILE:
@@ -321,6 +303,7 @@ def _on_event(self, event):
         elif event_id == MpvEventID.FILE_LOADED:
             # If the media is a live streaming, this event may not be received.
             self.media_loaded.emit()
+            self.media_loaded_v2.emit({'video_format': self._mpv.video_format})
         elif event_id == MpvEventID.METADATA_UPDATE:
             metadata = dict(self._mpv.metadata or {})  # type: ignore
             logger.debug('metadata updated to %s', metadata)