Add locking to music.py

Ensure nothing interrupts the stop - release - nullify sequence. Also
don't limit how many concurrent fades there can be.

app/music.py

@@ -8,6 +8,8 @@ from time import sleep
 
 from log import DEBUG, ERROR
 
+lock = threading.Lock()
+
 
 class Music:
     """
@@ -16,7 +18,7 @@ class Music:
 
     def __init__(self):
         self.current_track_start_time = None
-        self.fading = False
+        self.fading = 0
         self.VLC = vlc.Instance()
         self.player = None
         self.track_path = None
@@ -30,15 +32,16 @@ class Music:
         to hold up the UI during the fade.
         """
 
+        with lock:
             DEBUG("music.fade()", True)
 
-        if not self.playing():
-            return None
-
-        # Only allow one track to fade at a time
-        if self.fading:
+            if not self.player:
                 return
-        self.fading = True
+
+            if not self.player.get_position() > 0 and self.player.is_playing():
+                return
+
+            self.fading += 1
 
             thread = threading.Thread(target=self._fade)
             thread.start()
@@ -69,16 +72,18 @@ class Music:
         measures_to_reduce_by = 0
         for i in range(1, steps + 1):
             measures_to_reduce_by += i
-            volume_factor = 1 - (measures_to_reduce_by / total_measures_count)
+            volume_factor = 1 - (
+                measures_to_reduce_by / total_measures_count)
             p.audio_set_volume(int(self.max_volume * volume_factor))
             sleep(sleep_time)
 
         self.stop(p)
-        self.fading = False
+        self.fading -= 1
 
     def get_playtime(self):
         "Return elapsed play time"
 
+        with lock:
             if not self.player:
                 return None
 
@@ -87,6 +92,7 @@ class Music:
     def get_position(self):
         "Return current position"
 
+        with lock:
             DEBUG("music.get_position", True)
 
             return self.player.get_position()
@@ -118,22 +124,25 @@ class Music:
         get_position seems more reliable.
         """
 
+        with lock:
             if self.player:
                 if self.player.get_position() > 0 and self.player.is_playing():
                     return True
 
             # We take a copy of the player when fading, so we could be
             # playing in a fade nowFalse
-        return self.fading
+            return self.fading > 0
 
     def set_position(self, ms):
         "Set current play time in milliseconds from start"
 
+        with lock:
             return self.player.set_time(ms)
 
     def set_volume(self, volume):
         "Set maximum volume used for player"
 
+        with lock:
             if not self.player:
                 return
 
@@ -143,6 +152,7 @@ class Music:
     def stop(self, player=None):
         "Immediately stop playing"
 
+        with lock:
             DEBUG(f"music.stop(), {player=}", True)
 
             if not player:
@@ -154,10 +164,9 @@ class Music:
 
             position = player.get_position()
             player.stop()
-        p = player
+            DEBUG(f"Releasing player {player=}", True)
+            player.release()
             # Ensure we don't reference player after release
             player = None
-        DEBUG(f"Releasing player {p=}", True)
-        p.release()
 
             return position