generalize fade function, add show fade out support

Author: brookgagnon

VERSION

@@ -1 +1 @@
-5.3.0-20250525
+5.3.0-20250531

obplayer/player/outputs.py

@@ -62,7 +62,8 @@ def add_inter_tap(self, name):
 class ObAudioMixerBin(ObOutputBin):
     def __init__(self):
 
-        self.main_fade_thread = None
+        self.fade_threads = {}
+        self.fade_threads_cancel = {}
 
         # silent input section
         silent_pipeline_str = """
@@ -164,17 +165,22 @@ def alert_off(self):
         )
         self.pipeline_main.get_state(Gst.CLOCK_TIME_NONE)
 
-    def main_fade(self, arguments):
-        # print("main_fade: " + str(arguments))
+    def fade(self, arguments):
 
-        volume_element = self.pipeline_main.get_by_name("channel-main-volume")
+        volume_element_name = arguments["element"]
+
+        if(volume_element_name not in self.fade_threads):
+            self.fade_threads[volume_element_name] = None
+            self.fade_threads_cancel[volume_element_name] = False
+
+        volume_element = self.pipeline_main.get_by_name(volume_element_name)
         current_volume = volume_element.get_property("volume")
         target_volume = arguments["volume"]
         fade_time = arguments["time"]
         fade_run_per_second = 20
 
         obplayer.Log.log(
-            "main fade from "
+            volume_element_name + " fade from "
             + str(round(current_volume * 100))
             + "% to "
             + str(round(target_volume * 100))
@@ -201,12 +207,12 @@ def main_fade(self, arguments):
             mode = "out"
 
         def run():
-            self.main_fade_cancel = False
+            self.fade_threads_cancel[volume_element] = False
             current_volume = volume_element.get_property("volume")
 
             while True:
                 if (
-                    self.main_fade_cancel
+                    self.fade_threads_cancel[volume_element]
                     or (mode == "in" and current_volume >= target_volume)
                     or (mode == "out" and current_volume <= target_volume)
                 ):
@@ -224,13 +230,13 @@ def run():
                 time.sleep(1 / fade_run_per_second)
 
         # cancel any existing run
-        if self.main_fade_thread is not None:
-            self.main_fade_cancel = True
-            self.main_fade_thread.join()
-            self.made_fade_thread = None
+        if self.fade_threads[volume_element_name] is not None:
+            self.fade_threads_cancel[volume_element] = True
+            self.fade_threads[volume_element_name].join()
+            self.fade_threads[volume_element_name] = None
 
-        self.main_fade_thread = threading.Thread(target=run)
-        self.main_fade_thread.start()
+        self.fade_threads[volume_element_name] = threading.Thread(target=run)
+        self.fade_threads[volume_element_name].start()
 
     def execute_instruction(self, instruction, arguments):
         obplayer.Log.log("mixer received instruction " + instruction, "debug")
@@ -246,11 +252,14 @@ def execute_instruction(self, instruction, arguments):
             )
             print(self.pipeline_main.get_by_name("mixer-prealert-volume").get_property("volume"))
         elif instruction == "voicetrack_on":
-            self.main_fade({"volume": arguments["volume"], "time": arguments["fade"]})
+            self.fade({"volume": arguments["volume"], "time": arguments["fade"], "element": "channel-main-volume"})
         elif instruction == "voicetrack_off":
-            self.main_fade({"volume": 1.0, "time": arguments["fade"]})
+            self.fade({"volume": 1.0, "time": arguments["fade"], "element": "channel-main-volume"})
         elif instruction == "main_fade":
-            self.main_fade(arguments)
+            arguments['element'] = "channel-main-volume"
+            self.fade(arguments)
+        elif instruction == "primary_on":
+            self.fade({"volume": 1.0, "time": 0.0, "element": "mixer-primary-volume"})
         else:
             print("unknown mixer instruction: " + instruction)
 

obplayer/scheduler/scheduler.py

@@ -146,6 +146,7 @@ def __init__(self):
         self.media_start_time = 0
         self.now_playing = None
         self.next_media_update = 0
+        self.fadeout = False
 
         self.show_data = None
         self.playlist = None
@@ -351,6 +352,7 @@ def play_media(self, media, offset, present_time):
                 self.end_time()
                 and self.media_start_time + media["duration"] > self.end_time()
             ):
+                self.fadeout = True
                 self.ctrl.add_request(
                     start_time=self.media_start_time,
                     end_time=self.end_time(),
@@ -362,8 +364,10 @@ def play_media(self, media, offset, present_time):
                     order_num=media["order_num"],
                     artist=media["artist"],
                     title=media["title"],
+                    mixerend=['primary_on', {}], # restore the mixer from fade-out when the track stops
                 )
             else:
+                self.fadeout = False
                 self.ctrl.add_request(
                     start_time=self.media_start_time,
                     media_type=media["media_type"],
@@ -566,6 +570,10 @@ def __init__(self, first_sync=False):
         self.lock = threading.Lock()
         self.first_sync = first_sync
 
+        self.showfade_ctrl = obplayer.Player.create_controller(
+            "showfade", priority=50, default_play_mode="overlap", allow_overlay=True
+        )
+
         self.voicetrack_ctrl = obplayer.Player.create_controller(
             "voicetrack", priority=50, default_play_mode="overlap", allow_overlay=True
         )
@@ -579,30 +587,42 @@ def __init__(self, first_sync=False):
 
         self.voicetrack_ctrl.set_request_callback(self.do_voicetrack_request)
         self.voicetrack_ctrl.set_update_callback(self.do_voicetrack_update)
+        
+        self.showfade_duration = float(obplayer.Config.setting("fade_duration", 5))
+        self.showfade_ctrl.set_request_callback(self.do_showfade_request)
+        self.showfade_ctrl.set_update_callback(self.do_showfade_update)
 
         self.present_show = None
         self.next_show_update = 0
 
-    # initial request?
+    def do_showfade_request(self, ctrl, present_time, media_class):
+        self.do_showfade_update(ctrl, present_time)
+
+    def do_showfade_update(self, ctrl, present_time):
+        self.showfade_ctrl.set_next_update(present_time + 0.25)
+        if self.present_show and type(self.present_show) is ObShow and self.present_show.fadeout:
+            ending_in = self.present_show.end_time() - present_time
+            fade_duration = self.showfade_duration # adding 0.25 to account for this only being called every 0.25, so we might be late
+
+            if(ending_in <= (fade_duration + 0.25)):
+                obplayer.Player.outputs["mixer"].fade(
+                    {
+                        "element": "mixer-primary-volume",
+                        "volume": 0.0,
+                        "time": self.showfade_duration
+                    }
+                )
+
+                self.present_show.fadeout = False
+
     def do_voicetrack_request(self, ctrl, present_time, media_class):
         self.do_voicetrack_update(ctrl, present_time)
 
-    # update request after initial?
     def do_voicetrack_update(self, ctrl, present_time):
         self.voicetrack_ctrl.set_next_update(present_time + 0.25)
         if self.present_show:
             self.present_show.play_current_voicetrack(present_time)
 
-        # self.check_show(present_time)
-
-        # if self.present_show is not None:
-        #     self.present_show.play_next_voicetrack(present_time)
-
-        # self.set_voicetrack_update(present_time)
-
-    def set_voicetrack_update(self, present_time):
-        self.voicetrack_ctrl.set_next_update(present_time + 0.25)
-
     def do_player_request(self, ctrl, present_time, media_class):
         self.check_show(present_time)