Merge branch 'dev'

Author: helgeerbe

src/picframe/interface_http.py

@@ -82,48 +82,6 @@ def heif_to_image(fname: str) -> Optional[Image.Image]:
         logger.warning("Failed attempt to convert %s due to %s \n** Have you installed pi_heif? **", fname, e)
         return None
 
-
-def frame_to_image(fname: str) -> Optional[Image.Image]:
-    """
-    Converts the first frame of a video file to an image.
-
-    This function attempts to extract the first frame of a video file
-    using the `VideoFrameExtractor` from the `picframe.video_streamer` module.
-    If the extraction is successful, it ensures the image is in RGB mode
-    before returning it. If the extraction fails or an error occurs, it logs
-    a warning and returns either an empty byte string or None.
-
-    Args:
-        fname (str): The file path to the video file.
-
-    Returns:
-        PIL.Image.Image or bytes or None: The extracted image in RGB mode if successful,
-        an empty byte string if the frame extraction fails, or None if an exception occurs.
-
-    Notes:
-        - Ensure that `ffmpeg` is installed and available in the system for
-          `VideoFrameExtractor` to work correctly.
-        - Logs warnings if the frame extraction or conversion fails.
-    """
-    logger = logging.getLogger("interface_http.frame_to_jpg")
-    try:
-        from picframe.video_streamer import VideoFrameExtractor
-        image = VideoFrameExtractor.get_first_frame_as_image(fname)
-        if image is None:
-            logger.warning("Failed to extract frames from %s \n** Have you installed ffmpeg? **", fname)
-            return None
-
-        if image.mode not in ("RGB", "RGBA"):
-            image = image.convert("RGB")
-        return image
-    except ImportError:
-        logger.warning("Failed to import required module for converting %s \n** Have you installed ffmpeg? **", fname)
-        return None
-    except (OSError, IOError) as e:
-        logger.warning("Failed attempt to convert %s due to %s \n** Have you installed ffmpeg? **", fname, e)
-        return None
-
-
 class RequestHandler(BaseHTTPRequestHandler):
 
     def do_AUTHHEAD(self):
@@ -182,16 +140,10 @@ def do_GET(self):  # noqa: C901
                             is_bytes = True
                         elif extension in VIDEO_EXTENSIONS:
                             # as current_image may be video
-                            image = frame_to_image(page)
-                            if image is not None:
-                                buf = io.BytesIO()
-                                image.save(buf, format="JPEG")
-                                buf.seek(0)
-                                page_bytes = buf.read()
-                            else:
-                                page_bytes = b""
+                            file = os.path.splitext(page)[0]
+                            page = file + ".1.frame"
                             content_type = EXTENSION_TO_MIMETYPE['.jpg']
-                            is_bytes = True
+                            is_bytes = False
                         else:
                             is_bytes = False
                     else:

src/picframe/model.py

@@ -167,7 +167,8 @@ def __init__(self, configfile=DEFAULT_CONFIGFILE):
             except yaml.YAMLError as exc:
                 self.__logger.error("Can't parse yaml config file: %s: %s", configfile, exc)
         root_logger = logging.getLogger()
-        root_logger.setLevel(self.get_model_config()['log_level'])  # set root logger
+        level = getattr(logging, self.get_model_config()['log_level'].upper(), logging.WARNING)
+        root_logger.setLevel(level)
         log_file = self.get_model_config()['log_file']
         if log_file != '':
             filehandler = logging.FileHandler(log_file)  # NB default appending so needs monitoring

src/picframe/video_player.py

@@ -47,6 +47,13 @@ def __init__(self, x: int, y: int, w: int, h: int, fit_display: bool = False) ->
         self.fit_display = fit_display
         self.cmd_queue: queue.Queue[str] = queue.Queue()
         self.stdin_thread = threading.Thread(target=self._stdin_reader, daemon=True)
+        self._vlc_event_manager: Optional[vlc.EventManager] = None
+        self._vlc_event_callbacks_registered: bool = False
+        self._show_window_request: bool = False
+        self._hide_window_request: bool = False
+        self._last_time: int = 0
+        self._last_progress_time: float = 0.0
+        self._startup: bool = True
 
     def setup(self) -> bool:
         """Initialize SDL2, create window, and set up VLC player."""
@@ -77,7 +84,7 @@ def setup(self) -> bool:
             return False
 
         # Initialize VLC
-        vlc_args = ['--no-audio']
+        vlc_args = ['--no-audio', '--quiet', '--verbose=0']
         try:
             self.instance = vlc.Instance(vlc_args)
             self.player = self.instance.media_player_new()
@@ -118,8 +125,63 @@ def setup(self) -> bool:
             aspect_ratio = f"{self.w}:{self.h}"
             self.player.video_set_aspect_ratio(aspect_ratio)
 
+        # Register VLC event callbacks
+        self._vlc_event_manager = self.player.event_manager()
+        self._register_vlc_events()
+
         return True
 
+    def _register_vlc_events(self):
+        """Attach VLC event callbacks for playback state changes."""
+        if self._vlc_event_manager and not self._vlc_event_callbacks_registered:
+            self._vlc_event_manager.event_attach(vlc.EventType.MediaPlayerPlaying, self._on_vlc_playing)
+            self._vlc_event_manager.event_attach(vlc.EventType.MediaPlayerStopped, self._on_vlc_stopped)
+            self._vlc_event_manager.event_attach(vlc.EventType.MediaPlayerEndReached, self._on_vlc_ended)
+            self._vlc_event_manager.event_attach(vlc.EventType.MediaPlayerEncounteredError, self._on_vlc_error)
+            self._vlc_event_callbacks_registered = True
+
+    def _on_vlc_playing(self, event):
+        self.logger.debug("VLC event: MediaPlayerPlaying")
+        self._show_window_request = True
+        self._last_time = 0
+        self._last_progress_time = time.time()
+        self._startup = True
+
+    def _on_vlc_stopped(self, event: vlc.Event) -> None:
+        """
+        VLC event handler for MediaPlayerStopped.
+
+        Args:
+            event (vlc.Event): VLC event object.
+        """
+        self.logger.debug("VLC event: MediaPlayerStopped")
+        self._hide_window_request = True
+        self._send_state("ENDED")
+
+    def _on_vlc_ended(self, event: vlc.Event) -> None:
+        """
+        VLC event handler for MediaPlayerEndReached.
+
+        Args:
+            event (vlc.Event): VLC event object.
+        """
+        self.logger.debug("VLC event: MediaPlayerEndReached")
+        self._hide_window_request = True
+        self._send_state("ENDED")
+
+    def _on_vlc_error(self, event: vlc.Event) -> None:
+        """
+        VLC event handler for MediaPlayerEncounteredError.
+
+        Args:
+            event (vlc.Event): VLC event object.
+        """
+        self.logger.error("VLC event: MediaPlayerEncounteredError")
+        self._hide_window_request = True
+        if self.player:
+            self.player.stop()
+        self._send_state("ENDED")
+
     def _poll_events(self) -> bool:
         """Poll SDL2 events, return False if quit event is received."""
         while sdl2.SDL_PollEvent(ctypes.byref(self.event)):
@@ -148,62 +210,81 @@ def _stdin_reader(self):
                 break
             self.cmd_queue.put(line)
 
+    def check_video_progress(self) -> bool:
+        """
+        Checks the progress of the currently playing video and determines if the player is stuck.
+
+        This method monitors the playback time of the video player. If the playback time does not advance
+        for more than 3 seconds, or if the player reports that no media is loaded, it is considered stuck,
+        and playback is stopped.
+
+        Returns:
+            bool: True if the video is progressing normally, False if the player is stuck or not initialized.
+        """
+        if not self.player:
+            self.logger.error("Player not initialized, cannot check video progress.")
+            return False
+
+        current_time = self.player.get_time()
+        now = time.time()
+
+        if not self._startup and current_time == self._last_time:
+            # No progress, check if we've been stuck for more than 3 seconds
+            if now - self._last_progress_time > 3.0:
+                self.logger.error("vlc is stuck while playing for more than 3 seconds. Stopping it!")
+                self.logger.debug("vlc current time: %d, last time: %d", current_time, self._last_time)
+                self.player.stop()
+                return False
+        elif current_time == -1:  # VLC returns -1 if no media is loaded
+            self.logger.warning("No media loaded or media is invalid.")
+            self.player.stop()
+            return False
+        else:
+            # Progress detected, reset timer
+            self._last_progress_time = now
+            if self._startup and current_time > 0:
+                self.logger.debug("Video started playing.")
+                self.logger.debug("vlc current time: %d", current_time)
+                self._send_state("PLAYING")
+                self._startup = False
+
+        self._last_time = current_time
+        return True
+
     def run(self) -> None:
-        """Main event loop: handle commands and playback state."""
+        """Main event loop: handle SDL2 events and commands."""
         if not self.player:
             self.logger.error("Player not initialized, cannot run.")
             return
         self.stdin_thread.start()
         try:
-            while True:
-                self._poll_events()
-                # Check player state ignore opening and buffering
-                # to avoid flickering
-                state = self.player.get_state()
-                if state in [vlc.State.Ended, vlc.State.Stopped,
-                             vlc.State.Error]:
-                    if sdl2.SDL_GetWindowFlags(self.window) & sdl2.SDL_WINDOW_SHOWN:
-                        sdl2.SDL_HideWindow(self.window)
-                    self.player.stop()
-                    self.player.set_media(None)
-                    self._send_state("ENDED")
-                elif state in [vlc.State.Playing, vlc.State.Paused]:
-                    self._send_state("PLAYING")
-                    # Show window only if not already visible
+            running = True
+            while running:
+                running = self._poll_events()
+
+                # Handle window show/hide requests from VLC callbacks
+                if self._show_window_request:
                     if not sdl2.SDL_GetWindowFlags(self.window) & sdl2.SDL_WINDOW_SHOWN:
                         sdl2.SDL_ShowWindow(self.window)
-                        # Wait until the window is actually shown
-                        shown = False
-                        start_time = time.time()
-                        timeout = 4  # seconds
-                        window_id = sdl2.SDL_GetWindowID(self.window)  # Get window ID once
-                        while not shown and (time.time() - start_time) < timeout:
-                            while sdl2.SDL_PollEvent(ctypes.byref(self.event)) != 0:
-                                if (self.event.type == sdl2.SDL_WINDOWEVENT and
-                                        self.event.window.event == sdl2.SDL_WINDOWEVENT_SHOWN and
-                                        self.event.window.windowID == window_id):
-                                    shown = True
-                                    break
-                            if shown:  # If event found, break outer loop
-                                break
-                            time.sleep(0.01)
-
-                        if not shown:  # If timeout occurred
-                            self.logger.warning(
-                                "Player window not shown within %d seconds.", timeout
-                                )
-                        else:
-                            # Wait a bit longer to ensure compositor has mapped the window
-                            time.sleep(0.3)
-                            sdl2.SDL_ShowCursor(sdl2.SDL_DISABLE)
-                            sdl2.SDL_WarpMouseInWindow(self.window, self.w - 1, self.h - 1)
-                elif state in [vlc.State.Opening,
-                               vlc.State.Buffering,
-                               vlc.State.NothingSpecial]:
+                        self._wait_for_window_shown(timeout=4.0)
+                        sdl2.SDL_ShowCursor(sdl2.SDL_DISABLE)
+                        sdl2.SDL_WarpMouseInWindow(self.window, self.w - 1, self.h - 1)
+                    self._show_window_request = False
+                
+                if sdl2.SDL_ShowCursor(sdl2.SDL_QUERY) == 1:
+                    self.logger.debug("Mouse pointer is visible, hiding it.")
+                    sdl2.SDL_ShowCursor(sdl2.SDL_DISABLE)
+
+                if self._hide_window_request:
                     if sdl2.SDL_GetWindowFlags(self.window) & sdl2.SDL_WINDOW_SHOWN:
                         sdl2.SDL_HideWindow(self.window)
-                    self._send_state("ENDED")
-                # check for commands in the queue
+                    self._hide_window_request = False
+
+                state = self.player.get_state() if self.player else None
+                if state == vlc.State.Playing:
+                    self.check_video_progress()
+
+                # Only handle commands
                 try:
                     line = self.cmd_queue.get_nowait()
                 except queue.Empty:
@@ -214,6 +295,8 @@ def run(self) -> None:
                         continue
                     self._handle_command(cmd)
         finally:
+            if self.player:
+                self.player.stop()
             sdl2.SDL_DestroyWindow(self.window)
             sdl2.SDL_Quit()
 
@@ -226,7 +309,6 @@ def _handle_command(self, cmd: list[str]) -> None:
             media_path = " ".join(cmd[1:])
             if os.path.exists(media_path):
                 self.player.stop()
-                self.player.set_media(None)
                 media = self.instance.media_new_path(media_path)
                 self.player.set_media(media)
                 self.player.play()
@@ -240,7 +322,29 @@ def _handle_command(self, cmd: list[str]) -> None:
             if sdl2.SDL_GetWindowFlags(self.window) & sdl2.SDL_WINDOW_SHOWN:
                 sdl2.SDL_HideWindow(self.window)
             self.player.stop()
-            self.player.set_media(None)
+
+    def _wait_for_window_shown(self, timeout: float = 4.0) -> bool:
+        """Wait for the SDL_WINDOWEVENT_SHOWN event for this window."""
+        start_time = time.time()
+        window_id = sdl2.SDL_GetWindowID(self.window)
+        shown = False
+        while not shown and (time.time() - start_time) < timeout:
+            while sdl2.SDL_PollEvent(ctypes.byref(self.event)) != 0:
+                if (
+                    self.event.type == sdl2.SDL_WINDOWEVENT and
+                    self.event.window.event == sdl2.SDL_WINDOWEVENT_SHOWN and
+                    self.event.window.windowID == window_id
+                ):
+                    shown = True
+                    break
+            if shown:
+                break
+            time.sleep(0.01)
+        if not shown:  # If timeout occurred
+            self.logger.warning(
+                "Player window not shown within %d seconds.", timeout
+                )
+        return shown
 
 
 def parse_args() -> argparse.Namespace:
@@ -257,6 +361,8 @@ def parse_args() -> argparse.Namespace:
     parser.add_argument("--w", type=int, default=640)
     parser.add_argument("--h", type=int, default=480)
     parser.add_argument("--fit_display", action="store_true")
+    parser.add_argument("--log_level", type=str, default="info", choices=["debug", "info", "warning", "error", "critical"],
+                        help="Set the logging level (default: info)")
     return parser.parse_args()
 
 
@@ -265,8 +371,9 @@ def main() -> None:
     Entry point for the video player application.
     Initializes logging, parses arguments, sets up the video player, and starts the event loop.
     """
-    logging.basicConfig(level=logging.DEBUG)
     args = parse_args()
+    log_level = getattr(logging, args.log_level.upper(), logging.INFO)
+    logging.basicConfig(level=log_level)
     player = VideoPlayer(args.x, args.y, args.w, args.h, args.fit_display)
     if player.setup():
         player.run()