app/classes.py

@@ -2,13 +2,20 @@
 from dataclasses import dataclass, field
 from enum import auto, Enum
 from typing import Any, Optional
+import datetime as dt
 
 # PyQt imports
-from PyQt6.QtCore import pyqtSignal, QObject
+from PyQt6.QtCore import pyqtSignal, QObject, QThread
 
 # Third party imports
+import numpy as np
+import pyqtgraph as pg  # type: ignore
+from sqlalchemy.orm import scoped_session
 
 # App imports
+from config import Config
+from log import log
+from models import PlaylistRows
 import helpers
 
 
@@ -25,6 +32,62 @@ class Col(Enum):
     NOTE = auto()
 
 
+class FadeCurve:
+    GraphWidget = None
+
+    def __init__(
+        self, track_path: str, track_fade_at: int, track_silence_at: int
+    ) -> None:
+        """
+        Set up fade graph array
+        """
+
+        audio = helpers.get_audio_segment(track_path)
+        if not audio:
+            log.error(f"FadeCurve: could not get audio for {track_path=}")
+            return None
+
+        # Start point of curve is Config.FADE_CURVE_MS_BEFORE_FADE
+        # milliseconds before fade starts to silence
+        self.start_ms = max(0, track_fade_at - Config.FADE_CURVE_MS_BEFORE_FADE - 1)
+        self.end_ms = track_silence_at
+        self.audio_segment = audio[self.start_ms : self.end_ms]
+        self.graph_array = np.array(self.audio_segment.get_array_of_samples())
+
+        # Calculate the factor to map milliseconds of track to array
+        self.ms_to_array_factor = len(self.graph_array) / (self.end_ms - self.start_ms)
+
+        self.region = None
+
+    def clear(self) -> None:
+        """Clear the current graph"""
+
+        if self.GraphWidget:
+            self.GraphWidget.clear()
+
+    def plot(self):
+        self.curve = self.GraphWidget.plot(self.graph_array)
+        self.curve.setPen(Config.FADE_CURVE_FOREGROUND)
+
+    def tick(self, play_time) -> None:
+        """Update volume fade curve"""
+
+        if not self.GraphWidget:
+            return
+
+        ms_of_graph = play_time - self.start_ms
+        if ms_of_graph < 0:
+            return
+
+        if self.region is None:
+            # Create the region now that we're into fade
+            self.region = pg.LinearRegionItem([0, 0], bounds=[0, len(self.graph_array)])
+            self.GraphWidget.addItem(self.region)
+
+        # Update region position
+        self.region.setRegion([0, ms_of_graph * self.ms_to_array_factor])
+
+
 @helpers.singleton
 @dataclass
 class MusicMusterSignals(QObject):
@@ -53,6 +116,112 @@ class MusicMusterSignals(QObject):
         super().__init__()
 
 
+class PlaylistTrack:
+    """
+    Used to provide a single reference point for specific playlist tracks,
+    typically the previous, current and next track.
+    """
+
+    def __init__(self) -> None:
+        """
+        Only initialises data structure. Call set_plr to populate.
+        """
+
+        self.artist: Optional[str] = None
+        self.duration: Optional[int] = None
+        self.end_time: Optional[dt.datetime] = None
+        self.fade_at: Optional[int] = None
+        self.fade_graph: Optional[FadeCurve] = None
+        self.fade_graph_start_updates: Optional[dt.datetime] = None
+        self.fade_length: Optional[int] = None
+        self.path: Optional[str] = None
+        self.playlist_id: Optional[int] = None
+        self.plr_id: Optional[int] = None
+        self.plr_rownum: Optional[int] = None
+        self.resume_marker: Optional[float] = None
+        self.silence_at: Optional[int] = None
+        self.start_gap: Optional[int] = None
+        self.start_time: Optional[dt.datetime] = None
+        self.title: Optional[str] = None
+        self.track_id: Optional[int] = None
+
+    def __repr__(self) -> str:
+        return (
+            f"<PlaylistTrack(title={self.title}, artist={self.artist}, "
+            f"plr_rownum={self.plr_rownum}, playlist_id={self.playlist_id}>"
+        )
+
+    def set_plr(self, session: scoped_session, plr: PlaylistRows) -> None:
+        """
+        Update with new plr information
+        """
+
+        session.add(plr)
+        self.plr_rownum = plr.plr_rownum
+        if not plr.track:
+            return
+        track = plr.track
+
+        self.artist = track.artist
+        self.duration = track.duration
+        self.end_time = None
+        self.fade_at = track.fade_at
+        self.intro = track.intro
+        self.path = track.path
+        self.playlist_id = plr.playlist_id
+        self.plr_id = plr.id
+        self.silence_at = track.silence_at
+        self.start_gap = track.start_gap
+        self.start_time = None
+        self.title = track.title
+        self.track_id = track.id
+
+        if track.silence_at and track.fade_at:
+            self.fade_length = track.silence_at - track.fade_at
+
+        # Initialise and add FadeCurve in a thread as it's slow
+        self.fadecurve_thread = QThread()
+        self.worker = AddFadeCurve(
+            self,
+            track_path=track.path,
+            track_fade_at=track.fade_at,
+            track_silence_at=track.silence_at,
+        )
+        self.worker.moveToThread(self.fadecurve_thread)
+        self.fadecurve_thread.started.connect(self.worker.run)
+        self.worker.finished.connect(self.fadecurve_thread.quit)
+        self.worker.finished.connect(self.worker.deleteLater)
+        self.fadecurve_thread.finished.connect(self.fadecurve_thread.deleteLater)
+        self.fadecurve_thread.start()
+
+    def start(self) -> None:
+        """
+        Called when track starts playing
+        """
+
+        now = dt.datetime.now()
+        self.start_time = now
+        if self.duration:
+            self.end_time = self.start_time + dt.timedelta(milliseconds=self.duration)
+
+        # Calculate time fade_graph should start updating
+        if self.fade_at:
+            update_graph_at_ms = max(
+                0, self.fade_at - Config.FADE_CURVE_MS_BEFORE_FADE - 1
+            )
+            self.fade_graph_start_updates = now + dt.timedelta(
+                milliseconds=update_graph_at_ms
+            )
+
+            # Calculate time fade_graph should start updating
+            update_graph_at_ms = max(
+                0, self.fade_at - Config.FADE_CURVE_MS_BEFORE_FADE - 1
+            )
+            self.fade_graph_start_updates = now + dt.timedelta(
+                milliseconds=update_graph_at_ms
+            )
+
+
 @dataclass
 class TrackFileData:
     """
@@ -65,3 +234,46 @@ class TrackFileData:
     obsolete_path: Optional[str] = None
     tags: dict[str, Any] = field(default_factory=dict)
     audio_metadata: dict[str, str | int | float] = field(default_factory=dict)
+
+
+class AddFadeCurve(QObject):
+    """
+    Initialising a fade curve introduces a noticeable delay so carry out in
+    a thread.
+    """
+
+    finished = pyqtSignal()
+
+    def __init__(
+        self,
+        playlist_track: PlaylistTrack,
+        track_path: str,
+        track_fade_at: int,
+        track_silence_at: int,
+    ):
+        super().__init__()
+        self.playlist_track = playlist_track
+        self.track_path = track_path
+        self.track_fade_at = track_fade_at
+        self.track_silence_at = track_silence_at
+
+    def run(self):
+        """
+        Create fade curve and add to PlaylistTrack object
+        """
+
+        fc = FadeCurve(self.track_path, self.track_fade_at, self.track_silence_at)
+        if not fc:
+            log.error(f"Failed to create FadeCurve for {self.track_path=}")
+        else:
+            self.playlist_track.fade_graph = fc
+        self.finished.emit()
+
+
+class TrackSequence:
+    next = PlaylistTrack()
+    now = PlaylistTrack()
+    previous = PlaylistTrack()
+
+
+track_sequence = TrackSequence()

app/music.py

@@ -0,0 +1,260 @@
+# Standard library imports
+import datetime as dt
+import threading
+from time import sleep
+from typing import Optional
+
+# Third party imports
+import vlc  # type: ignore
+
+# PyQt imports
+from PyQt6.QtCore import (
+    QRunnable,
+    QThreadPool,
+)
+
+# App imports
+from config import Config
+from helpers import file_is_unreadable
+from log import log
+
+lock = threading.Lock()
+
+
+class FadeTrack(QRunnable):
+    def __init__(self, player: vlc.MediaPlayer, fade_seconds) -> None:
+        super().__init__()
+        self.player = player
+        self.fade_seconds = fade_seconds
+
+    def run(self) -> None:
+        """
+        Implementation of fading the player
+        """
+
+        if not self.player:
+            return
+
+        # Reduce volume logarithmically
+        total_steps = self.fade_seconds * Config.FADEOUT_STEPS_PER_SECOND
+        db_reduction_per_step = Config.FADEOUT_DB / total_steps
+        reduction_factor_per_step = pow(10, (db_reduction_per_step / 20))
+
+        volume = self.player.audio_get_volume()
+
+        for i in range(1, total_steps + 1):
+            self.player.audio_set_volume(
+                int(volume * pow(reduction_factor_per_step, i))
+            )
+            sleep(1 / Config.FADEOUT_STEPS_PER_SECOND)
+
+        self.player.stop()
+        log.debug(f"Releasing player {self.player=}")
+        self.player.release()
+
+
+class Music:
+    """
+    Manage the playing of music tracks
+    """
+
+    def __init__(self, name) -> None:
+        self.VLC = vlc.Instance()
+        self.VLC.set_user_agent(name, name)
+        self.player = None
+        self.name = name
+        self.max_volume = Config.VLC_VOLUME_DEFAULT
+        self.start_dt: Optional[dt.datetime] = None
+
+    def _adjust_by_ms(self, ms: int) -> None:
+        """Move player position by ms milliseconds"""
+
+        if not self.player:
+            return
+
+        elapsed_ms = self.get_playtime()
+        position = self.get_position()
+        if not position:
+            position = 0
+        new_position = max(0, position + ((position * ms) / elapsed_ms))
+        self.set_position(new_position)
+        # Adjus start time so elapsed time calculations are correct
+        if new_position == 0:
+            self.start_dt = dt.datetime.now()
+        else:
+            self.start_dt -= dt.timedelta(milliseconds=ms)
+
+    def fade(self, fade_seconds: int = Config.FADEOUT_SECONDS) -> None:
+        """
+        Fade the currently playing track.
+
+        The actual management of fading runs in its own thread so as not
+        to hold up the UI during the fade.
+        """
+
+        log.info(f"Music[{self.name}].stop()")
+
+        if not self.player:
+            return
+
+        if not self.player.get_position() > 0 and self.player.is_playing():
+            return
+
+        # Take a copy of current player to allow another track to be
+        # started without interfering here
+        with lock:
+            p = self.player
+            self.player = None
+
+        pool = QThreadPool.globalInstance()
+        fader = FadeTrack(p, fade_seconds=fade_seconds)
+        pool.start(fader)
+        self.start_dt = None
+
+    def get_playtime(self) -> int:
+        """
+        Return number of milliseconds current track has been playing or
+        zero if not playing. The vlc function get_time() only updates 3-4
+        times a second; this function has much better resolution.
+        """
+
+        if self.start_dt is None:
+            return 0
+
+        now = dt.datetime.now()
+        elapsed_seconds = (now - self.start_dt).total_seconds()
+        return int(elapsed_seconds * 1000)
+
+    def get_position(self) -> Optional[float]:
+        """Return current position"""
+
+        if not self.player:
+            return None
+        return self.player.get_position()
+
+    def is_playing(self) -> bool:
+        """
+        Return True if we're playing
+        """
+
+        if not self.player:
+            return False
+
+        # There is a discrete time between starting playing a track and
+        # player.is_playing() returning True, so assume playing if less
+        # than Config.PLAY_SETTLE microseconds have passed since
+        # starting play.
+        return (
+            self.player is not None
+            and self.start_dt is not None
+            and (
+                self.player.is_playing()
+                or (dt.datetime.now() - self.start_dt)
+                < dt.timedelta(microseconds=Config.PLAY_SETTLE)
+            )
+        )
+
+    def move_back(self, ms: int) -> None:
+        """
+        Rewind player by ms milliseconds
+        """
+
+        self._adjust_by_ms(ms * -1)
+
+    def move_forward(self, ms: int) -> None:
+        """
+        Rewind player by ms milliseconds
+        """
+
+        self._adjust_by_ms(ms)
+
+    def play(self, path: str, position: Optional[float] = None) -> None:
+        """
+        Start playing the track at path.
+
+        Log and return if path not found.
+        """
+
+        log.info(f"Music[{self.name}].play({path=}, {position=}")
+
+        if file_is_unreadable(path):
+            log.error(f"play({path}): path not readable")
+            return None
+
+        media = self.VLC.media_new_path(path)
+        self.player = media.player_new_from_media()
+        if self.player:
+            _ = self.player.play()
+            self.set_volume(self.max_volume)
+
+            if position:
+                self.player.set_position(position)
+            self.start_dt = dt.datetime.now()
+
+            # For as-yet unknown reasons. sometimes the volume gets
+            # reset to zero within 200mS or so of starting play. This
+            # only happened since moving to Debian 12, which uses
+            # Pipewire for sound (which may be irrelevant).
+            # It has been known for the volume to need correcting more
+            # than once in the first 200mS.
+            for _ in range(3):
+                if self.player:
+                    volume = self.player.audio_get_volume()
+                    if volume < Config.VLC_VOLUME_DEFAULT:
+                        self.set_volume(Config.VLC_VOLUME_DEFAULT)
+                        log.error(f"Reset from {volume=}")
+                sleep(0.1)
+
+    def set_position(self, position: int) -> None:
+        """
+        Set player position
+        """
+
+        if self.player:
+            self.player.set_position(position)
+
+    def set_volume(self, volume=None, set_default=True) -> None:
+        """Set maximum volume used for player"""
+
+        if not self.player:
+            return
+
+        if set_default:
+            self.max_volume = volume
+
+        if volume is None:
+            volume = Config.VLC_VOLUME_DEFAULT
+
+        self.player.audio_set_volume(volume)
+        # Ensure volume correct
+        # For as-yet unknown reasons. sometimes the volume gets
+        # reset to zero within 200mS or so of starting play. This
+        # only happened since moving to Debian 12, which uses
+        # Pipewire for sound (which may be irrelevant).
+        for _ in range(3):
+            current_volume = self.player.audio_get_volume()
+            if current_volume < volume:
+                self.player.audio_set_volume(volume)
+                log.debug(f"Reset from {volume=}")
+            sleep(0.1)
+
+    def stop(self) -> float:
+        """Immediately stop playing"""
+
+        log.info(f"Music[{self.name}].stop()")
+
+        self.start_dt = None
+
+        if not self.player:
+            return 0.0
+
+        p = self.player
+        self.player = None
+        self.start_dt = None
+
+        with lock:
+            position = p.get_position()
+            p.stop()
+            p.release()
+            p = None
+            return position

app/musicmuster.py

@@ -59,7 +59,6 @@ from classes import (
     FadeCurve,
     MusicMusterSignals,
     PlaylistTrack,
-    PreviewTrackPlayer,
     TrackFileData,
 )
 from config import Config
@@ -232,8 +231,9 @@ class Window(QMainWindow, Ui_MainWindow):
         self.timer1000: QTimer = QTimer()
 
         self.music: music.Music = music.Music(name=Config.VLC_MAIN_PLAYER_NAME)
-        self.preview_track_player: Optional[PreviewTrackPlayer] = None
-
+        self.preview_player: music.Music = music.Music(
+            name=Config.VLC_PREVIEW_PLAYER_NAME
+        )
         self.playing: bool = False
 
         self.set_main_window_size()
@@ -430,7 +430,7 @@ class Window(QMainWindow, Ui_MainWindow):
         Clear next track
         """
 
-        track_sequence.next = None
+        track_sequence.next = PlaylistTrack()
         self.update_headers()
 
     def clear_selection(self) -> None:
@@ -521,10 +521,7 @@ class Window(QMainWindow, Ui_MainWindow):
         """
 
         # Don't close current track playlist
-        if track_sequence.current is None:
-            return True
-
-        current_track_playlist_id = track_sequence.current.playlist_id
+        current_track_playlist_id = track_sequence.now.playlist_id
         closing_tab_playlist_id = self.tabPlaylist.widget(tab_index).playlist_id
         if current_track_playlist_id:
             if closing_tab_playlist_id == current_track_playlist_id:
@@ -1148,12 +1145,11 @@ class Window(QMainWindow, Ui_MainWindow):
         """
 
         # Check for inadvertent press of 'return'
-        if track_sequence.current and self.catch_return_key:
+        if self.catch_return_key:
             # Suppress inadvertent double press
             if (
-                track_sequence.current
-                and track_sequence.current.track_player.start_time
-                and track_sequence.current.track_player.start_time
+                track_sequence.now.start_time
+                and track_sequence.now.start_time
                 + dt.timedelta(milliseconds=Config.RETURN_KEY_DEBOUNCE_MS)
                 > dt.datetime.now()
             ):
@@ -1161,16 +1157,10 @@ class Window(QMainWindow, Ui_MainWindow):
             # If return is pressed during first PLAY_NEXT_GUARD_MS then
             # default to NOT playing the next track, else default to
             # playing it.
-            default_yes: bool = (
-                track_sequence.current.track_player.start_time is not None
-                and (
-                    (
-                        dt.datetime.now()
-                        - track_sequence.current.track_player.start_time
-                    ).total_seconds()
-                    * 1000
-                    > Config.PLAY_NEXT_GUARD_MS
-                )
+            default_yes: bool = track_sequence.now.start_time is not None and (
+                (dt.datetime.now() - track_sequence.now.start_time).total_seconds()
+                * 1000
+                > Config.PLAY_NEXT_GUARD_MS
             )
             if not helpers.ask_yes_no(
                 "Track playing",
@@ -1183,9 +1173,12 @@ class Window(QMainWindow, Ui_MainWindow):
         log.info(f"play_next({position=})")
 
         # If there is no next track set, return.
-        if track_sequence.next is None:
+        if not track_sequence.next.track_id:
             log.error("musicmuster.play_next(): no next track selected")
             return
+        if not track_sequence.next.path:
+            log.error("musicmuster.play_next(): no path for next track")
+            return
 
         # Issue #223 concerns a very short pause (maybe 0.1s) sometimes
         # when starting to play at track.
@@ -1202,7 +1195,7 @@ class Window(QMainWindow, Ui_MainWindow):
         # Move next track to current track.
         # stop_playing() above has called end_of_track_actions()
         # which will have populated self.previous_track
-        track_sequence.current = track_sequence.next
+        track_sequence.now = track_sequence.next
 
         # Clear next track
         self.clear_next()
@@ -1213,7 +1206,21 @@ class Window(QMainWindow, Ui_MainWindow):
             self.btnDrop3db.setChecked(False)
 
         # Play (new) current track
-        track_sequence.current.track_player.play(position)
+        if not track_sequence.now.path:
+            log.error("No path for next track")
+            return
+        self.music.play(track_sequence.now.path, position)
+
+        # Show closing volume graph
+        if track_sequence.now.fade_graph:
+            track_sequence.now.fade_graph.plot()
+        else:
+            log.error("No fade_graph")
+
+        # Note that track is playing
+        log.debug("set track_sequence")
+        track_sequence.now.start()
+        self.playing = True
 
         # Disable play next controls
         self.catch_return_key = True
@@ -1241,22 +1248,18 @@ class Window(QMainWindow, Ui_MainWindow):
         """
 
         if self.btnPreview.isChecked():
-            # Get track_id for first selected track if there is one
-            track_id = self.active_tab().get_selected_row_track_id()
-            if not track_id:
+            # Get track path for first selected track if there is one
+            track_path = self.active_tab().get_selected_row_track_path()
+            if not track_path:
                 # Otherwise get path to next track to play
-                if track_sequence.next:
-                    track_id = track_sequence.next.track_id
-                if not track_id:
+                track_path = track_sequence.next.path
+                if not track_path:
                     self.btnPreview.setChecked(False)
                     return
-            with db.Session() as session:
-                self.preview_track_player = PreviewTrackPlayer(session, track_id)
-                self.preview_track_player.play()
+            self.preview_player.play(path=track_path)
 
         else:
-            if self.preview_track_player:
-                self.preview_track_player.stop_playing()
+            self.preview_player.stop()
             self.label_intro_timer.setText("0.0")
             self.btnPreviewMark.setEnabled(False)
             self.btnPreviewArm.setChecked(False)
@@ -1269,7 +1272,7 @@ class Window(QMainWindow, Ui_MainWindow):
     def preview_back(self) -> None:
         """Wind back preview file"""
 
-        self.preview_track_player.move_back(Config.PREVIEW_BACK_MS)
+        self.preview_player.move_back(Config.PREVIEW_BACK_MS)
 
     def preview_end(self) -> None:
         """Advance preview file to just before end of intro"""
@@ -1313,7 +1316,7 @@ class Window(QMainWindow, Ui_MainWindow):
     def preview_start(self) -> None:
         """Advance preview file"""
 
-        self.preview_track_player.set_position(0)
+        self.preview_player.set_position(0)
 
     def rename_playlist(self) -> None:
         """
@@ -1429,14 +1432,12 @@ class Window(QMainWindow, Ui_MainWindow):
         # We need to fake the start time to reflect where we resumed the
         # track
         if (
-            track_sequence.current.start_time
-            and track_sequence.current.duration
-            and track_sequence.current.resume_marker
+            track_sequence.now.start_time
+            and track_sequence.now.duration
+            and track_sequence.now.resume_marker
         ):
-            elapsed_ms = (
-                track_sequence.current.duration * track_sequence.current.resume_marker
-            )
-            track_sequence.current.start_time -= dt.timedelta(milliseconds=elapsed_ms)
+            elapsed_ms = track_sequence.now.duration * track_sequence.now.resume_marker
+            track_sequence.now.start_time -= dt.timedelta(milliseconds=elapsed_ms)
 
     def save_as_template(self) -> None:
         """Save current playlist as template"""
@@ -1562,8 +1563,7 @@ class Window(QMainWindow, Ui_MainWindow):
     def show_current(self) -> None:
         """Scroll to show current track"""
 
-        if track_sequence.current:
-            self.show_track(track_sequence.current)
+        self.show_track(track_sequence.now)
 
     def show_warning(self, title: str, body: str) -> None:
         """
@@ -1576,8 +1576,7 @@ class Window(QMainWindow, Ui_MainWindow):
     def show_next(self) -> None:
         """Scroll to show next track"""
 
-        if track_sequence.next:
-            self.show_track(track_sequence.next)
+        self.show_track(track_sequence.next)
 
     def show_status_message(self, message: str, timing: int) -> None:
         """
@@ -1586,25 +1585,25 @@ class Window(QMainWindow, Ui_MainWindow):
 
         self.statusbar.showMessage(message, timing)
 
-    def show_track(self, playlist_track: PlaylistTrack) -> None:
+    def show_track(self, plt: PlaylistTrack) -> None:
         """Scroll to show track in plt"""
 
         # Switch to the correct tab
-        playlist_id = playlist_track.playlist_id
-        if not playlist_id:
+        plt_playlist_id = plt.playlist_id
+        if not plt_playlist_id:
             # No playlist
             return
 
-        if playlist_id != self.active_tab().playlist_id:
+        if plt_playlist_id != self.active_tab().playlist_id:
             for idx in range(self.tabPlaylist.count()):
-                if self.tabPlaylist.widget(idx).playlist_id == playlist_id:
+                if self.tabPlaylist.widget(idx).playlist_id == plt_playlist_id:
                     self.tabPlaylist.setCurrentIndex(idx)
                     break
 
         display_row = (
             self.active_proxy_model()
             .mapFromSource(
-                self.active_proxy_model().source_model.index(playlist_track.row_number, 0)
+                self.active_proxy_model().source_model.index(plt.plr_rownum, 0)
             )
             .row()
         )
@@ -1711,23 +1710,22 @@ class Window(QMainWindow, Ui_MainWindow):
         Called every 10ms
         """
 
-        return
         # Update volume fade curve
         if (
-            track_sequence.current.fade_graph_start_updates is None
-            or track_sequence.current.fade_graph_start_updates > dt.datetime.now()
+            track_sequence.now.fade_graph_start_updates is None
+            or track_sequence.now.fade_graph_start_updates > dt.datetime.now()
         ):
             return
 
         if (
-            track_sequence.current.track_id
-            and track_sequence.current.fade_graph
-            and track_sequence.current.start_time
+            track_sequence.now.track_id
+            and track_sequence.now.fade_graph
+            and track_sequence.now.start_time
         ):
             play_time = (
-                dt.datetime.now() - track_sequence.current.start_time
+                dt.datetime.now() - track_sequence.now.start_time
             ).total_seconds() * 1000
-            track_sequence.current.fade_graph.tick(play_time)
+            track_sequence.now.fade_graph.tick(play_time)
 
     def tick_500ms(self) -> None:
         """
@@ -1847,26 +1845,25 @@ class Window(QMainWindow, Ui_MainWindow):
         Update last / current / next track headers
         """
 
-        if track_sequence.previous:
-            player = track_sequence.previous.track_player
-            self.hdrPreviousTrack.setText(f"{player.title} - {player.artist}")
+        if track_sequence.previous.title and track_sequence.previous.artist:
+            self.hdrPreviousTrack.setText(
+                f"{track_sequence.previous.title} - {track_sequence.previous.artist}"
+            )
         else:
             self.hdrPreviousTrack.setText("")
 
-        if track_sequence.current:
-            player = track_sequence.current.track_player
+        if track_sequence.now.title and track_sequence.now.artist:
             self.hdrCurrentTrack.setText(
-                f"{player.title.replace('&', '&&')} - "
-                f"{player.artist.replace('&', '&&')}"
+                f"{track_sequence.now.title.replace('&', '&&')} - "
+                f"{track_sequence.now.artist.replace('&', '&&')}"
             )
         else:
             self.hdrCurrentTrack.setText("")
 
-        if track_sequence.next:
-            player = track_sequence.next.track_player
+        if track_sequence.next.title and track_sequence.next.artist:
             self.hdrNextTrack.setText(
-                f"{player.title.replace('&', '&&')} - "
-                f"{player.artist.replace('&', '&&')}"
+                f"{track_sequence.next.title.replace('&', '&&')} - "
+                f"{track_sequence.next.artist.replace('&', '&&')}"
             )
         else:
             self.hdrNextTrack.setText("")

app/playlistmodel.py

@@ -47,7 +47,7 @@ HEADER_NOTES_COLUMN = 1
 scene_change_re = re.compile(r"SetScene=\[([^[\]]*)\]")
 
 
-class _PlaylistRowData:
+class PlaylistRowData:
     def __init__(self, plr: PlaylistRows) -> None:
         """
         Populate PlaylistRowData from database PlaylistRows record
@@ -117,7 +117,7 @@ class PlaylistModel(QAbstractTableModel):
         self.playlist_id = playlist_id
         super().__init__(*args, **kwargs)
 
-        self.playlist_rows: dict[int, _PlaylistRowData] = {}
+        self.playlist_rows: dict[int, PlaylistRowData] = {}
         self.signals = MusicMusterSignals()
         self.played_tracks_hidden = False
 
@@ -178,7 +178,7 @@ class PlaylistModel(QAbstractTableModel):
 
         self.signals.resize_rows_signal.emit(self.playlist_id)
 
-    def background_role(self, row: int, column: int, prd: _PlaylistRowData) -> QBrush:
+    def background_role(self, row: int, column: int, prd: PlaylistRowData) -> QBrush:
         """Return background setting"""
 
         # Handle entire row colouring
@@ -195,10 +195,10 @@ class PlaylistModel(QAbstractTableModel):
         if file_is_unreadable(prd.path):
             return QBrush(QColor(Config.COLOUR_UNREADABLE))
         # Current track
-        if track_sequence.current and track_sequence.current.track_id == prd.track_id:
+        if prd.plrid == track_sequence.now.plr_id:
             return QBrush(QColor(Config.COLOUR_CURRENT_PLAYLIST))
         # Next track
-        if track_sequence.next and track_sequence.next.track_id == prd.track_id:
+        if prd.plrid == track_sequence.next.plr_id:
             return QBrush(QColor(Config.COLOUR_NEXT_PLAYLIST))
 
         # Individual cell colouring
@@ -250,10 +250,24 @@ class PlaylistModel(QAbstractTableModel):
         - find next track
         """
 
-        if not track_sequence.current:
-            return
+        row_number = track_sequence.now.plr_rownum
+        if row_number is not None:
+            prd = self.playlist_rows[row_number]
+        else:
+            prd = None
 
-        row_number = track_sequence.current.row_number
+        # Sanity check
+        if not track_sequence.now.track_id:
+            log.error(
+                "playlistmodel:current_track_started called with no current track"
+            )
+            return
+        if row_number is None:
+            log.error(
+                "playlistmodel:current_track_started called with no row number "
+                f"({track_sequence.now=})"
+            )
+            return
 
         # Check for OBS scene change
         log.debug("Call OBS scene change")
@@ -262,23 +276,29 @@ class PlaylistModel(QAbstractTableModel):
         with db.Session() as session:
             # Update Playdates in database
             log.debug("update playdates")
-            Playdates(session, track_sequence.current.track_id)
+            Playdates(session, track_sequence.now.track_id)
 
             # Mark track as played in playlist
             log.debug("Mark track as played")
-            plr = session.get(PlaylistRows, track_sequence.current.plr_id)
+            plr = session.get(PlaylistRows, track_sequence.now.plr_id)
             if plr:
                 plr.played = True
                 self.refresh_row(session, plr.plr_rownum)
             else:
-                log.error(f"Can't retrieve plr, {track_sequence.current.plr_id=}")
+                log.error(f"Can't retrieve plr, {track_sequence.now.plr_id=}")
+
+            # Update track times
+            log.debug("Update track times")
+            if prd:
+                prd.start_time = track_sequence.now.start_time
+                prd.end_time = track_sequence.now.end_time
 
             # Update colour and times for current row
             self.invalidate_row(row_number)
 
             # Update previous row in case we're hiding played rows
-            if track_sequence.previous and track_sequence.previous.row_number:
-                self.invalidate_row(track_sequence.previous.row_number)
+            if track_sequence.previous.plr_rownum:
+                self.invalidate_row(track_sequence.previous.plr_rownum)
 
             # Update all other track times
             self.update_track_times()
@@ -373,7 +393,7 @@ class PlaylistModel(QAbstractTableModel):
 
         self.reset_track_sequence_row_numbers()
 
-    def display_role(self, row: int, column: int, prd: _PlaylistRowData) -> QVariant:
+    def display_role(self, row: int, column: int, prd: PlaylistRowData) -> QVariant:
         """
         Return text for display
         """
@@ -446,7 +466,7 @@ class PlaylistModel(QAbstractTableModel):
         super().endResetModel()
         self.reset_track_sequence_row_numbers()
 
-    def edit_role(self, row: int, column: int, prd: _PlaylistRowData) -> QVariant:
+    def edit_role(self, row: int, column: int, prd: PlaylistRowData) -> QVariant:
         """
         Return text for editing
         """
@@ -490,7 +510,7 @@ class PlaylistModel(QAbstractTableModel):
 
         return default
 
-    def font_role(self, row: int, column: int, prd: _PlaylistRowData) -> QVariant:
+    def font_role(self, row: int, column: int, prd: PlaylistRowData) -> QVariant:
         """
         Return font
         """
@@ -549,7 +569,7 @@ class PlaylistModel(QAbstractTableModel):
         log.debug(f"get_new_row_number() return: {new_row_number=}")
         return new_row_number
 
-    def get_row_info(self, row_number: int) -> _PlaylistRowData:
+    def get_row_info(self, row_number: int) -> PlaylistRowData:
         """
         Return info about passed row
         """
@@ -639,7 +659,7 @@ class PlaylistModel(QAbstractTableModel):
 
         return QVariant()
 
-    def header_text(self, prd: _PlaylistRowData) -> str:
+    def header_text(self, prd: PlaylistRowData) -> str:
         """
         Process possible section timing directives embeded in header
         """
@@ -683,16 +703,16 @@ class PlaylistModel(QAbstractTableModel):
                         # calculate end time if all tracks are played.
                         end_time_str = ""
                         if (
-                            track_sequence.current
-                            and track_sequence.current.track_player.end_time
+                            track_sequence.now.plr_rownum
+                            and track_sequence.now.end_time
                             and (
                                 row_number
-                                < track_sequence.current.row_number
+                                < track_sequence.now.plr_rownum
                                 < prd.plr_rownum
                             )
                         ):
                             section_end_time = (
-                                track_sequence.current.track_player.end_time
+                                track_sequence.now.end_time
                                 + dt.timedelta(milliseconds=duration)
                             )
                             end_time_str = (
@@ -810,7 +830,7 @@ class PlaylistModel(QAbstractTableModel):
 
         return self.playlist_rows[row_number].played
 
-    def is_track_in_playlist(self, track_id: int) -> Optional[_PlaylistRowData]:
+    def is_track_in_playlist(self, track_id: int) -> Optional[PlaylistRowData]:
         """
         If this track_id is in the playlist, return the PlaylistRowData object
         else return None
@@ -886,16 +906,14 @@ class PlaylistModel(QAbstractTableModel):
                 row_map[old_row] = new_row
 
         # Check to see whether any rows in track_sequence have moved
-        if track_sequence.previous and track_sequence.previous.row_number in row_map:
-            track_sequence.previous.row_number = row_map[
-                track_sequence.previous.row_number
+        if track_sequence.previous.plr_rownum in row_map:
+            track_sequence.previous.plr_rownum = row_map[
+                track_sequence.previous.plr_rownum
             ]
-        if track_sequence.current and track_sequence.current.row_number in row_map:
-            track_sequence.current.row_number = row_map[
-                track_sequence.current.row_number
-            ]
-        if track_sequence.next and track_sequence.next.row_number in row_map:
-            track_sequence.next.row_number = row_map[track_sequence.next.row_number]
+        if track_sequence.now.plr_rownum in row_map:
+            track_sequence.now.plr_rownum = row_map[track_sequence.now.plr_rownum]
+        if track_sequence.next.plr_rownum in row_map:
+            track_sequence.next.plr_rownum = row_map[track_sequence.next.plr_rownum]
 
         # For SQLAlchemy, build a list of dictionaries that map plrid to
         # new row number:
@@ -955,10 +973,7 @@ class PlaylistModel(QAbstractTableModel):
                     self.playlist_id,
                     [self.playlist_rows[a].plrid for a in row_group],
                 ):
-                    if (
-                        track_sequence.current
-                        and plr.id == track_sequence.current.plr_id
-                    ):
+                    if plr.id == track_sequence.now.plr_id:
                         # Don't move current track
                         continue
                     plr.playlist_id = to_playlist_id
@@ -979,7 +994,7 @@ class PlaylistModel(QAbstractTableModel):
         self.update_track_times()
 
     def move_track_add_note(
-        self, new_row_number: int, existing_prd: _PlaylistRowData, note: str
+        self, new_row_number: int, existing_prd: PlaylistRowData, note: str
     ) -> None:
         """
         Move existing_prd track to new_row_number and append note to any existing note
@@ -1003,10 +1018,7 @@ class PlaylistModel(QAbstractTableModel):
         self.signals.resize_rows_signal.emit(self.playlist_id)
 
     def move_track_to_header(
-        self,
-        header_row_number: int,
-        existing_prd: _PlaylistRowData,
-        note: Optional[str],
+        self, header_row_number: int, existing_prd: PlaylistRowData, note: Optional[str]
     ) -> None:
         """
         Add the existing_prd track details to the existing header at  header_row_number
@@ -1068,10 +1080,10 @@ class PlaylistModel(QAbstractTableModel):
         log.info("previous_track_ended()")
 
         # Sanity check
-        if not track_sequence.previous:
+        if not track_sequence.previous.track_id:
             log.error("playlistmodel:previous_track_ended called with no current track")
             return
-        if track_sequence.previous.row_number is None:
+        if track_sequence.previous.plr_rownum is None:
             log.error(
                 "playlistmodel:previous_track_ended called with no row number "
                 f"({track_sequence.previous=})"
@@ -1079,7 +1091,7 @@ class PlaylistModel(QAbstractTableModel):
             return
 
         # Update display
-        self.invalidate_row(track_sequence.previous.row_number)
+        self.invalidate_row(track_sequence.previous.plr_rownum)
 
     def refresh_data(self, session: db.session):
         """Populate dicts for data calls"""
@@ -1087,13 +1099,13 @@ class PlaylistModel(QAbstractTableModel):
         # Populate self.playlist_rows with playlist data
         self.playlist_rows.clear()
         for p in PlaylistRows.deep_rows(session, self.playlist_id):
-            self.playlist_rows[p.plr_rownum] = _PlaylistRowData(p)
+            self.playlist_rows[p.plr_rownum] = PlaylistRowData(p)
 
     def refresh_row(self, session, row_number):
         """Populate dict for one row from database"""
 
         p = PlaylistRows.deep_row(session, self.playlist_id, row_number)
-        self.playlist_rows[row_number] = _PlaylistRowData(p)
+        self.playlist_rows[row_number] = PlaylistRowData(p)
 
     def remove_track(self, row_number: int) -> None:
         """
@@ -1133,23 +1145,21 @@ class PlaylistModel(QAbstractTableModel):
 
         log.debug("reset_track_sequence_row_numbers()")
 
-        # Check the track_sequence next, current and previous plrs and
+        # Check the track_sequence next, now and previous plrs and
         # update the row number
         with db.Session() as session:
-            if track_sequence.next and track_sequence.next.row_number:
-                next_plr = session.get(PlaylistRows, track_sequence.next.row_number)
+            if track_sequence.next.plr_rownum:
+                next_plr = session.get(PlaylistRows, track_sequence.next.plr_id)
                 if next_plr:
-                    track_sequence.next.row_number = next_plr.plr_rownum
-            if track_sequence.current and track_sequence.current.row_number:
-                now_plr = session.get(PlaylistRows, track_sequence.current.row_number)
+                    track_sequence.next.plr_rownum = next_plr.plr_rownum
+            if track_sequence.now.plr_rownum:
+                now_plr = session.get(PlaylistRows, track_sequence.now.plr_id)
                 if now_plr:
-                    track_sequence.current.row_number = now_plr.plr_rownum
-            if track_sequence.previous and track_sequence.previous.row_number:
-                previous_plr = session.get(
-                    PlaylistRows, track_sequence.previous.row_number
-                )
+                    track_sequence.now.plr_rownum = now_plr.plr_rownum
+            if track_sequence.previous.plr_rownum:
+                previous_plr = session.get(PlaylistRows, track_sequence.previous.plr_id)
                 if previous_plr:
-                    track_sequence.previous.row_number = previous_plr.plr_rownum
+                    track_sequence.previous.plr_rownum = previous_plr.plr_rownum
 
         self.update_track_times()
 
@@ -1230,53 +1240,59 @@ class PlaylistModel(QAbstractTableModel):
         Set row_number as next track. If row_number is None, clear next track.
         """
 
-        log.debug(f"set_next_row({row_number=})")
+        log.info(f"set_next_row({row_number=})")
+
+        next_row_was = track_sequence.next.plr_rownum
 
         if row_number is None:
-            # Clear next track
-            if track_sequence.next:
-                track_sequence.next = None
-            else:
+            if next_row_was is None:
                 return
-        else:
-            # Get plrid of row
+            track_sequence.next = PlaylistTrack()
+            self.signals.next_track_changed_signal.emit()
+            return
+
+        # Update track_sequence
+        with db.Session() as session:
+            track_sequence.next = PlaylistTrack()
             try:
-                prd = self.playlist_rows[row_number]
+                plrid = self.playlist_rows[row_number].plrid
             except IndexError:
                 log.error(
                     f"playlistmodel.set_next_track({row_number=}, "
                     f"{self.playlist_id=}"
-                    "IndexError"
                 )
                 return
-            if prd.track_id is None or prd.plr_rownum is None:
-                log.error(
-                    f"playlistmodel.set_next_track({row_number=}, "
-                    "No track / row number "
-                    f"{self.playlist_id=}, {prd.track_id=}, {prd.plr_rownum=}"
+            plr = session.get(PlaylistRows, plrid)
+            if plr:
+                # Check this isn't a header row
+                if self.is_header_row(row_number):
+                    log.error(
+                        "Tried to set next row on header row: "
+                        f"playlistmodel.set_next_track({row_number=}, "
+                        f"{self.playlist_id=}"
+                    )
+                    return
+                # Check track is readable
+                if file_is_unreadable(plr.track.path):
+                    log.error(
+                        "Tried to set next row on unreadable row: "
+                        f"playlistmodel.set_next_track({row_number=}, "
+                        f"{self.playlist_id=}"
+                    )
+                    return
+                track_sequence.next.set_plr(session, plr)
+                self.signals.next_track_changed_signal.emit()
+                self.signals.search_wikipedia_signal.emit(
+                    self.playlist_rows[row_number].title
                 )
-                return
-
-            try:
-                track_sequence.next = PlaylistTrack(prd.plrid)
                 self.invalidate_row(row_number)
-            except ValueError as e:
-                log.error(f"Error creating PlaylistTrack({prd=}): ({str(e)})")
-                return
 
-            self.signals.search_wikipedia_signal.emit(
-                self.playlist_rows[row_number].title
-            )
-            self.invalidate_row(row_number)
-
-        self.signals.next_track_changed_signal.emit()
+        if next_row_was is not None:
+            self.invalidate_row(next_row_was)
         self.update_track_times()
 
     def setData(
-        self,
-        index: QModelIndex,
-        value: str | float,
-        role: int = Qt.ItemDataRole.EditRole,
+        self, index: QModelIndex, value: str | float, role: int = Qt.ItemDataRole.EditRole
     ) -> bool:
         """
         Update model with edited data
@@ -1380,7 +1396,7 @@ class PlaylistModel(QAbstractTableModel):
     def supportedDropActions(self) -> Qt.DropAction:
         return Qt.DropAction.MoveAction | Qt.DropAction.CopyAction
 
-    def tooltip_role(self, row: int, column: int, prd: _PlaylistRowData) -> QVariant:
+    def tooltip_role(self, row: int, column: int, prd: PlaylistRowData) -> QVariant:
         """
         Return tooltip. Currently only used for last_played column.
         """
@@ -1418,9 +1434,9 @@ class PlaylistModel(QAbstractTableModel):
             prd = self.playlist_rows[row_number]
 
             # Reset start_time if this is the current row
-            if row_number == track_sequence.current.plr_rownum:
-                prd.start_time = track_sequence.current.start_time
-                prd.end_time = track_sequence.current.end_time
+            if row_number == track_sequence.now.plr_rownum:
+                prd.start_time = track_sequence.now.start_time
+                prd.end_time = track_sequence.now.end_time
                 update_rows.append(row_number)
                 if not next_start_time:
                     next_start_time = prd.end_time
@@ -1429,9 +1445,9 @@ class PlaylistModel(QAbstractTableModel):
             # Set start time for next row if we have a current track
             if (
                 row_number == track_sequence.next.plr_rownum
-                and track_sequence.current.end_time
+                and track_sequence.now.end_time
             ):
-                prd.start_time = track_sequence.current.end_time
+                prd.start_time = track_sequence.now.end_time
                 prd.end_time = prd.start_time + dt.timedelta(milliseconds=prd.duration)
                 next_start_time = prd.end_time
                 update_rows.append(row_number)
@@ -1444,9 +1460,9 @@ class PlaylistModel(QAbstractTableModel):
             # If we're between the current and next row, zero out
             # times
             if (
-                track_sequence.current.plr_rownum is not None
+                track_sequence.now.plr_rownum is not None
                 and track_sequence.next.plr_rownum is not None
-                and track_sequence.current.plr_rownum
+                and track_sequence.now.plr_rownum
                 < row_number
                 < track_sequence.next.plr_rownum
             ):
@@ -1523,7 +1539,7 @@ class PlaylistProxyModel(QSortFilterProxyModel):
             if self.source_model.is_played_row(source_row):
                 # Don't hide current or next track
                 with db.Session() as session:
-                    if track_sequence.next:
+                    if track_sequence.next.plr_id:
                         next_plr = session.get(PlaylistRows, track_sequence.next.plr_id)
                         if (
                             next_plr
@@ -1531,10 +1547,8 @@ class PlaylistProxyModel(QSortFilterProxyModel):
                             and next_plr.playlist_id == self.source_model.playlist_id
                         ):
                             return True
-                    if track_sequence.current:
-                        now_plr = session.get(
-                            PlaylistRows, track_sequence.current.plr_id
-                        )
+                    if track_sequence.now.plr_id:
+                        now_plr = session.get(PlaylistRows, track_sequence.now.plr_id)
                         if (
                             now_plr
                             and now_plr.plr_rownum == source_row
@@ -1544,20 +1558,19 @@ class PlaylistProxyModel(QSortFilterProxyModel):
                     # Don't hide previous track until
                     # HIDE_AFTER_PLAYING_OFFSET milliseconds after
                     # current track has started
-                    if track_sequence.previous:
+                    if track_sequence.previous.plr_id:
                         previous_plr = session.get(
                             PlaylistRows, track_sequence.previous.plr_id
                         )
                         if (
-                            track_sequence.current
-                            and previous_plr
+                            previous_plr
                             and previous_plr.plr_rownum == source_row
                             and previous_plr.playlist_id
                             == self.source_model.playlist_id
                         ):
-                            if track_sequence.current.track_player.start_time:
+                            if track_sequence.now.start_time:
                                 if dt.datetime.now() > (
-                                    track_sequence.current.track_player.start_time
+                                    track_sequence.now.start_time
                                     + dt.timedelta(
                                         milliseconds=Config.HIDE_AFTER_PLAYING_OFFSET
                                     )
@@ -1610,7 +1623,7 @@ class PlaylistProxyModel(QSortFilterProxyModel):
     def get_rows_duration(self, row_numbers: List[int]) -> int:
         return self.source_model.get_rows_duration(row_numbers)
 
-    def get_row_info(self, row_number: int) -> _PlaylistRowData:
+    def get_row_info(self, row_number: int) -> PlaylistRowData:
         return self.source_model.get_row_info(row_number)
 
     def get_row_track_path(self, row_number: int) -> str:
@@ -1636,7 +1649,7 @@ class PlaylistProxyModel(QSortFilterProxyModel):
     def is_played_row(self, row_number: int) -> bool:
         return self.source_model.is_played_row(row_number)
 
-    def is_track_in_playlist(self, track_id: int) -> Optional[_PlaylistRowData]:
+    def is_track_in_playlist(self, track_id: int) -> Optional[PlaylistRowData]:
         return self.source_model.is_track_in_playlist(track_id)
 
     def mark_unplayed(self, row_numbers: List[int]) -> None:
@@ -1653,15 +1666,12 @@ class PlaylistProxyModel(QSortFilterProxyModel):
         )
 
     def move_track_add_note(
-        self, new_row_number: int, existing_prd: _PlaylistRowData, note: str
+        self, new_row_number: int, existing_prd: PlaylistRowData, note: str
     ) -> None:
         return self.source_model.move_track_add_note(new_row_number, existing_prd, note)
 
     def move_track_to_header(
-        self,
-        header_row_number: int,
-        existing_prd: _PlaylistRowData,
-        note: Optional[str],
+        self, header_row_number: int, existing_prd: PlaylistRowData, note: Optional[str]
     ) -> None:
         return self.source_model.move_track_to_header(
             header_row_number, existing_prd, note

app/playlists.py

@@ -118,13 +118,9 @@ class EscapeDelegate(QStyledItemDelegate):
                 # Close editor if no changes have been made
                 data_modified = False
                 if isinstance(self.editor, QPlainTextEdit):
-                    data_modified = (
-                        self.original_model_data == self.editor.toPlainText()
-                    )
+                    data_modified = self.original_model_data == self.editor.toPlainText()
                 elif isinstance(self.editor, QDoubleSpinBox):
-                    data_modified = (
-                        self.original_model_data == int(self.editor.value()) * 1000
-                    )
+                    data_modified = self.original_model_data == int(self.editor.value()) * 1000
                 if data_modified:
                     self.closeEditor.emit(editor)
                     return True
@@ -429,18 +425,12 @@ class PlaylistTab(QTableView):
 
         header_row = proxy_model.is_header_row(model_row_number)
         track_row = not header_row
-        if track_sequence.current:
-            this_is_current_row = model_row_number == track_sequence.current.row_number
-        else:
-            this_is_current_row = False
-        if track_sequence.next:
-            this_is_next_row = model_row_number == track_sequence.next.row_number
-        else:
-            this_is_next_row = False
+        current_row = model_row_number == track_sequence.now.plr_rownum
+        next_row = model_row_number == track_sequence.next.plr_rownum
         track_path = self.source_model.get_row_info(model_row_number).path
 
         # Open/import in/from Audacity
-        if track_row and not this_is_current_row:
+        if track_row and not current_row:
             if track_path == self.musicmuster.audacity_file_path:
                 # This track was opened in Audacity
                 self._add_context_menu(
@@ -457,7 +447,7 @@ class PlaylistTab(QTableView):
                 )
 
         # Rescan
-        if track_row and not this_is_current_row:
+        if track_row and not current_row:
             self._add_context_menu(
                 "Rescan track", lambda: self._rescan(model_row_number)
             )
@@ -466,11 +456,11 @@ class PlaylistTab(QTableView):
         self.menu.addSeparator()
 
         # Delete row
-        if not this_is_current_row and not this_is_next_row:
+        if not current_row and not next_row:
             self._add_context_menu("Delete row", lambda: self._delete_rows())
 
         # Remove track from row
-        if track_row and not this_is_current_row and not this_is_next_row:
+        if track_row and not current_row and not next_row:
             self._add_context_menu(
                 "Remove track from row",
                 lambda: proxy_model.remove_track(model_row_number),
@@ -491,7 +481,7 @@ class PlaylistTab(QTableView):
             )
 
         # Unmark as next
-        if this_is_next_row:
+        if next_row:
             self._add_context_menu(
                 "Unmark as next track", lambda: self._unmark_as_next()
             )

app/trackmanager.py

@@ -1,523 +0,0 @@
-# Standard library imports
-from __future__ import annotations
-
-import datetime as dt
-import threading
-from time import sleep
-from typing import Optional
-
-# Third party imports
-import numpy as np
-import pyqtgraph as pg  # type: ignore
-import vlc  # type: ignore
-
-# PyQt imports
-from PyQt6.QtCore import (
-    pyqtSignal,
-    QObject,
-    QRunnable,
-    QThread,
-    QThreadPool,
-)
-
-# App imports
-from config import Config
-from log import log
-from models import db, PlaylistRows, Tracks
-from helpers import (
-    file_is_unreadable,
-    get_audio_segment,
-)
-
-lock = threading.Lock()
-
-
-class _AddFadeCurve(QObject):
-    """
-    Initialising a fade curve introduces a noticeable delay so carry out in
-    a thread.
-    """
-
-    finished = pyqtSignal()
-
-    def __init__(
-        self,
-        track_player: _TrackManager,
-        track_path: str,
-        track_fade_at: int,
-        track_silence_at: int,
-    ):
-        super().__init__()
-        self.track_player = track_player
-        self.track_path = track_path
-        self.track_fade_at = track_fade_at
-        self.track_silence_at = track_silence_at
-
-    def run(self):
-        """
-        Create fade curve and add to PlaylistTrack object
-        """
-
-        fc = _FadeCurve(self.track_path, self.track_fade_at, self.track_silence_at)
-        if not fc:
-            log.error(f"Failed to create FadeCurve for {self.track_path=}")
-        else:
-            self.track_player.fade_graph = fc
-        self.finished.emit()
-
-
-class _FadeCurve:
-    GraphWidget = None
-
-    def __init__(
-        self, track_path: str, track_fade_at: int, track_silence_at: int
-    ) -> None:
-        """
-        Set up fade graph array
-        """
-
-        audio = get_audio_segment(track_path)
-        if not audio:
-            log.error(f"FadeCurve: could not get audio for {track_path=}")
-            return None
-
-        # Start point of curve is Config.FADE_CURVE_MS_BEFORE_FADE
-        # milliseconds before fade starts to silence
-        self.start_ms = max(0, track_fade_at - Config.FADE_CURVE_MS_BEFORE_FADE - 1)
-        self.end_ms = track_silence_at
-        self.audio_segment = audio[self.start_ms : self.end_ms]
-        self.graph_array = np.array(self.audio_segment.get_array_of_samples())
-
-        # Calculate the factor to map milliseconds of track to array
-        self.ms_to_array_factor = len(self.graph_array) / (self.end_ms - self.start_ms)
-
-        self.region = None
-
-    def clear(self) -> None:
-        """Clear the current graph"""
-
-        if self.GraphWidget:
-            self.GraphWidget.clear()
-
-    def plot(self):
-        self.curve = self.GraphWidget.plot(self.graph_array)
-        self.curve.setPen(Config.FADE_CURVE_FOREGROUND)
-
-    def tick(self, play_time) -> None:
-        """Update volume fade curve"""
-
-        if not self.GraphWidget:
-            return
-
-        ms_of_graph = play_time - self.start_ms
-        if ms_of_graph < 0:
-            return
-
-        if self.region is None:
-            # Create the region now that we're into fade
-            self.region = pg.LinearRegionItem([0, 0], bounds=[0, len(self.graph_array)])
-            self.GraphWidget.addItem(self.region)
-
-        # Update region position
-        self.region.setRegion([0, ms_of_graph * self.ms_to_array_factor])
-
-
-class _FadeTrack(QRunnable):
-    def __init__(self, player: vlc.MediaPlayer, fade_seconds) -> None:
-        super().__init__()
-        self.player = player
-        self.fade_seconds = fade_seconds
-
-    def run(self) -> None:
-        """
-        Implementation of fading the player
-        """
-
-        if not self.player:
-            return
-
-        # Reduce volume logarithmically
-        total_steps = self.fade_seconds * Config.FADEOUT_STEPS_PER_SECOND
-        db_reduction_per_step = Config.FADEOUT_DB / total_steps
-        reduction_factor_per_step = pow(10, (db_reduction_per_step / 20))
-
-        volume = self.player.audio_get_volume()
-
-        for i in range(1, total_steps + 1):
-            self.player.audio_set_volume(
-                int(volume * pow(reduction_factor_per_step, i))
-            )
-            sleep(1 / Config.FADEOUT_STEPS_PER_SECOND)
-
-        self.player.stop()
-        log.debug(f"Releasing player {self.player=}")
-        self.player.release()
-
-
-class _Music:
-    """
-    Manage the playing of music tracks
-    """
-
-    def __init__(self, name) -> None:
-        self.VLC = vlc.Instance()
-        self.VLC.set_user_agent(name, name)
-        self.player = None
-        self.name = name
-        self.max_volume = Config.VLC_VOLUME_DEFAULT
-        self.start_dt: Optional[dt.datetime] = None
-
-    def _adjust_by_ms(self, ms: int) -> None:
-        """Move player position by ms milliseconds"""
-
-        if not self.player:
-            return
-
-        elapsed_ms = self.get_playtime()
-        position = self.get_position()
-        if not position:
-            position = 0
-        new_position = max(0, position + ((position * ms) / elapsed_ms))
-        self.set_position(new_position)
-        # Adjus start time so elapsed time calculations are correct
-        if new_position == 0:
-            self.start_dt = dt.datetime.now()
-        else:
-            self.start_dt -= dt.timedelta(milliseconds=ms)
-
-    def fade(self, fade_seconds: int) -> None:
-        """
-        Fade the currently playing track.
-
-        The actual management of fading runs in its own thread so as not
-        to hold up the UI during the fade.
-        """
-
-        log.info(f"Music[{self.name}].stop()")
-
-        if not self.player:
-            return
-
-        if not self.player.get_position() > 0 and self.player.is_playing():
-            return
-
-        if fade_seconds <= 0:
-            self._stop()
-            return
-
-        # Take a copy of current player to allow another track to be
-        # started without interfering here
-        with lock:
-            p = self.player
-            self.player = None
-
-        pool = QThreadPool.globalInstance()
-        fader = _FadeTrack(p, fade_seconds=fade_seconds)
-        pool.start(fader)
-        self.start_dt = None
-
-    def get_playtime(self) -> int:
-        """
-        Return number of milliseconds current track has been playing or
-        zero if not playing. The vlc function get_time() only updates 3-4
-        times a second; this function has much better resolution.
-        """
-
-        if self.start_dt is None:
-            return 0
-
-        now = dt.datetime.now()
-        elapsed_seconds = (now - self.start_dt).total_seconds()
-        return int(elapsed_seconds * 1000)
-
-    def get_position(self) -> Optional[float]:
-        """Return current position"""
-
-        if not self.player:
-            return None
-        return self.player.get_position()
-
-    def is_playing(self) -> bool:
-        """
-        Return True if we're playing
-        """
-
-        if not self.player:
-            return False
-
-        # There is a discrete time between starting playing a track and
-        # player.is_playing() returning True, so assume playing if less
-        # than Config.PLAY_SETTLE microseconds have passed since
-        # starting play.
-        return (
-            self.start_dt is not None
-            and (
-                self.player.is_playing()
-                or (dt.datetime.now() - self.start_dt)
-                < dt.timedelta(microseconds=Config.PLAY_SETTLE)
-            )
-        )
-
-    def move_back(self, ms: int) -> None:
-        """
-        Rewind player by ms milliseconds
-        """
-
-        self._adjust_by_ms(ms * -1)
-
-    def move_forward(self, ms: int) -> None:
-        """
-        Rewind player by ms milliseconds
-        """
-
-        self._adjust_by_ms(ms)
-
-    def play(self, path: str, position: Optional[float]) -> None:
-        """
-        Start playing the track at path.
-
-        Log and return if path not found.
-        """
-
-        log.info(f"Music[{self.name}].play({path=}, {position=}")
-
-        if file_is_unreadable(path):
-            log.error(f"play({path}): path not readable")
-            return None
-
-        media = self.VLC.media_new_path(path)
-        self.player = media.player_new_from_media()
-        if self.player:
-            _ = self.player.play()
-            self.set_volume(self.max_volume)
-
-            if position:
-                self.player.set_position(position)
-            self.start_dt = dt.datetime.now()
-
-            # For as-yet unknown reasons. sometimes the volume gets
-            # reset to zero within 200mS or so of starting play. This
-            # only happened since moving to Debian 12, which uses
-            # Pipewire for sound (which may be irrelevant).
-            # It has been known for the volume to need correcting more
-            # than once in the first 200mS.
-            for _ in range(3):
-                if self.player:
-                    volume = self.player.audio_get_volume()
-                    if volume < Config.VLC_VOLUME_DEFAULT:
-                        self.set_volume(Config.VLC_VOLUME_DEFAULT)
-                        log.error(f"Reset from {volume=}")
-                sleep(0.1)
-
-    def set_position(self, position: int) -> None:
-        """
-        Set player position
-        """
-
-        if self.player:
-            self.player.set_position(position)
-
-    def set_volume(self, volume=None, set_default=True) -> None:
-        """Set maximum volume used for player"""
-
-        if not self.player:
-            return
-
-        if set_default:
-            self.max_volume = volume
-
-        if volume is None:
-            volume = Config.VLC_VOLUME_DEFAULT
-
-        self.player.audio_set_volume(volume)
-        # Ensure volume correct
-        # For as-yet unknown reasons. sometimes the volume gets
-        # reset to zero within 200mS or so of starting play. This
-        # only happened since moving to Debian 12, which uses
-        # Pipewire for sound (which may be irrelevant).
-        for _ in range(3):
-            current_volume = self.player.audio_get_volume()
-            if current_volume < volume:
-                self.player.audio_set_volume(volume)
-                log.debug(f"Reset from {volume=}")
-            sleep(0.1)
-
-    def _stop(self) -> None:
-        """Immediately stop playing"""
-
-        log.info(f"Music[{self.name}].stop()")
-
-        self.start_dt = None
-
-        if not self.player:
-            return
-
-        p = self.player
-        self.player = None
-        self.start_dt = None
-
-        with lock:
-            p.stop()
-            p.release()
-            p = None
-
-
-class _TrackManager:
-    """
-    Object to manage active playlist tracks,
-    typically the previous, current and next track.
-    """
-
-    def __init__(self, session: db.Session, player_name: str, track_id: int) -> None:
-        """
-        Initialises data structure.
-        Define a player.
-        Raise ValueError if no track in passed plr.
-        """
-
-        track = session.get(Tracks, track_id)
-        if not track:
-            raise ValueError(f"_TrackPlayer: unable to retreived {track_id=}")
-        self.player_name = player_name
-
-        self.artist = track.artist
-        self.bitrate = track.bitrate
-        self.duration = track.duration
-        self.fade_at = track.fade_at
-        self.intro = track.intro
-        self.path = track.path
-        self.silence_at = track.silence_at
-        self.start_gap = track.start_gap
-        self.title = track.title
-        self.track_id = track.id
-
-        self.end_time: Optional[dt.datetime] = None
-        self.fade_graph: Optional[_FadeCurve] = None
-        self.fade_graph_start_updates: Optional[dt.datetime] = None
-        self.resume_marker: Optional[float]
-        self.start_time: Optional[dt.datetime] = None
-
-        self.player = _Music(name=player_name)
-        # Initialise player
-        self.track_player = MainTrackManager(session=session, track_id=self.track_id)
-
-        # Initialise and add FadeCurve in a thread as it's slow
-        self.fadecurve_thread = QThread()
-        self.worker = _AddFadeCurve(
-            self,
-            track_path=track.path,
-            track_fade_at=track.fade_at,
-            track_silence_at=track.silence_at,
-        )
-        self.worker.moveToThread(self.fadecurve_thread)
-        self.fadecurve_thread.started.connect(self.worker.run)
-        self.worker.finished.connect(self.fadecurve_thread.quit)
-        self.worker.finished.connect(self.worker.deleteLater)
-        self.fadecurve_thread.finished.connect(self.fadecurve_thread.deleteLater)
-        self.fadecurve_thread.start()
-
-
-    def fade(self, fade_seconds: int = Config.FADEOUT_SECONDS) -> None:
-        """Fade music"""
-
-        self.player.fade(fade_seconds)
-
-    @property
-    def is_playing(self) -> bool:
-        return self.track_player.is_playing()
-
-    def play(self, position: Optional[float] = None) -> None:
-        """Play track"""
-
-        now = dt.datetime.now()
-        self.start_time = now
-        self.player.play(self.path, position)
-
-        self.end_time = self.start_time + dt.timedelta(milliseconds=self.duration)
-
-        # Calculate time fade_graph should start updating
-        if self.fade_at:
-            update_graph_at_ms = max(
-                0, self.fade_at - Config.FADE_CURVE_MS_BEFORE_FADE - 1
-            )
-            self.fade_graph_start_updates = now + dt.timedelta(
-                milliseconds=update_graph_at_ms
-            )
-
-    def stop_playing(self, fade_seconds: int = 0) -> None:
-        """
-        Stop this track playing
-        """
-
-        self.resume_marker = self.player.get_position()
-        self.player.fade(fade_seconds)
-
-        # Reset fade graph
-        if self.fade_graph:
-            self.fade_graph.clear()
-
-    def time_to_fade(self) -> int:
-        """
-        Return milliseconds until fade time. Return zero if we're not playing.
-        """
-
-        if not self.player.is_playing:
-            return 0
-
-
-class MainTrackManager(_TrackManager):
-    """
-    Manage playing tracks from the playlist with associated data
-    """
-
-    def __init__(self, plr_id: int) -> None:
-        """
-        Set up manager for playlist tracks
-        """
-
-        with db.Session() as session:
-            # Ensure we have a track
-            plr = session.get(PlaylistRows, plr_id)
-            if not plr:
-                raise ValueError(f"PlaylistTrack: unable to retreive plr {plr_id=}")
-
-            self.track_id: int = plr.track_id
-
-            super().__init__(
-                session=session, player_name=Config.VLC_MAIN_PLAYER_NAME, track_id=self.track_id
-            )
-
-            # Save non-track plr info
-            self.plr_id: int = plr.id
-            self.playlist_id: int = plr.playlist_id
-            self.row_number: int = plr.plr_rownum
-
-    def __repr__(self) -> str:
-        return (
-            f"<MainTrackManager(plr_id={self.plr_id}, playlist_id={self.playlist_id}, "
-            f"row_number={self.row_number}>"
-        )
-
-
-class PreviewTrackManager(_TrackManager):
-    """
-    Manage previewing tracks
-    """
-
-    def __init__(self, track_id: int) -> None:
-        super().__init__(
-            player_name=Config.VLC_PREVIEW_PLAYER_NAME,
-            track_id=track_id,
-        )
-
-    def __repr__(self) -> str:
-        return f"<PreviewTrackManager(track_id={self.track_id}>"
-
-
-class TrackSequence:
-    next: Optional[MainTrackManager] = None
-    current: Optional[MainTrackManager] = None
-    previous: Optional[MainTrackManager] = None
-
-
-track_sequence = TrackSequence()