Add crossfade delay (#3704)

Author: toots

doc/content/migrating.md

@@ -17,6 +17,27 @@ so, always best to first to a trial run before putting things to production!
 
 ## From 2.2.x to 2.3.x
 
+### Crossfade transitions and track marks
+
+Track marks can now be properly passed through crossfade transitions. This means that you also have to make sure
+that your transition function is fallible! For instance, this silly transition function:
+
+```liquidsoap
+def transition(_, _) =
+  blank(duration=2.)
+end
+```
+
+Will never terminate!
+
+Typically, to insert a jingle you would do:
+
+```liquidsoap
+def transition(old, new) =
+  sequence([old.source, single("/path/to/jingle.mp3"), new.source])
+end
+```
+
 ### Replaygain
 
 - There is a new `metadata.replaygain` function that extracts the replay gain value in _dB_ from the metadata.

src/core/operators/cross.ml

@@ -203,10 +203,7 @@ class cross val_source ~duration_getter ~override_duration ~persist_override
               | `After after_source -> Some after_source)
         | `After after_source
           when self#can_reselect
-                 ~reselect:
-                   (match reselect with
-                     | `After_position _ -> reselect
-                     | _ -> `Ok)
+                 ~reselect:(match reselect with `Force -> `Ok | _ -> reselect)
                  after_source ->
             Some after_source
         | `After _ -> Some self#prepare_before
@@ -268,7 +265,6 @@ class cross val_source ~duration_getter ~override_duration ~persist_override
       in
       let buffered_before = Generator.length gen_before in
       let buffered_after = Generator.length gen_after in
-      let buffered = min buffered_before buffered_after in
       let after =
         Clock.collect_after (fun () ->
             let metadata = function
@@ -277,52 +273,20 @@ class cross val_source ~duration_getter ~override_duration ~persist_override
             in
             let before_metadata = metadata before_metadata in
             let after_metadata = metadata after_metadata in
-            let before_head =
-              if buffered < buffered_before then (
-                let head =
-                  Generator.slice gen_before (buffered_before - buffered)
-                in
-                let head_gen =
-                  Generator.create ~content:head
-                    (Generator.content_type gen_before)
-                in
-                let s = new consumer head_gen in
-                s#set_id (self#id ^ "_before_head");
-                Typing.(s#frame_type <: self#frame_type);
-                Some s)
-              else None
-            in
             let before = new consumer gen_before in
             Typing.(before#frame_type <: self#frame_type);
             let before = new Insert_metadata.replay before_metadata before in
             Typing.(before#frame_type <: self#frame_type);
-            let after_tail =
-              if buffered < buffered_after then (
-                let head = Generator.slice gen_after buffered in
-                let head_gen =
-                  Generator.create ~content:head
-                    (Generator.content_type gen_after)
-                in
-                let tail_gen = gen_after in
-                gen_after <- head_gen;
-                let s = new consumer tail_gen in
-                Typing.(s#frame_type <: self#frame_type);
-                s#set_id (self#id ^ "_after_tail");
-                Some s)
-              else None
-            in
+            before#set_id (self#id ^ "_before");
             let after = new consumer gen_after in
             Typing.(after#frame_type <: self#frame_type);
             let after = new Insert_metadata.replay after_metadata after in
             Typing.(after#frame_type <: self#frame_type);
-            before#set_id (self#id ^ "_before");
             after#set_id (self#id ^ "_after");
             self#log#important "Analysis: %fdB / %fdB (%.2fs / %.2fs)" db_before
               db_after
               (Frame.seconds_of_main buffered_before)
               (Frame.seconds_of_main buffered_after);
-            self#log#important "Computing crossfade over first and last %.2fs"
-              (Frame.seconds_of_main buffered);
             let compound =
               let params =
                 [
@@ -334,9 +298,7 @@ class cross val_source ~duration_getter ~override_duration ~persist_override
                         ( "expected_duration",
                           Lang.float (Frame.seconds_of_main cross_length) );
                         ( "buffered",
-                          Lang.float
-                            (Frame.seconds_of_main
-                               (Generator.length gen_before)) );
+                          Lang.float (Frame.seconds_of_main buffered_before) );
                         ("metadata", Lang.metadata before_metadata);
                       ] );
                   ( "",
@@ -347,29 +309,15 @@ class cross val_source ~duration_getter ~override_duration ~persist_override
                         ( "expected_duration",
                           Lang.float (Frame.seconds_of_main cross_length) );
                         ( "buffered",
-                          Lang.float
-                            (Frame.seconds_of_main (Generator.length gen_after))
-                        );
+                          Lang.float (Frame.seconds_of_main buffered_after) );
                         ("metadata", Lang.metadata after_metadata);
                       ] );
                 ]
               in
               Lang.to_source (Lang.apply transition params)
             in
             Typing.(compound#frame_type <: self#frame_type);
-            let compound =
-              match (before_head, after_tail) with
-                | None, None -> compound
-                | Some s, None ->
-                    (new Sequence.sequence ~merge:true [s; compound]
-                      :> Source.source)
-                | None, Some s ->
-                    (new Sequence.sequence ~merge:true [compound; s]
-                      :> Source.source)
-                | Some _, Some _ -> assert false
-            in
             Clock.unify ~pos:self#pos compound#clock s#clock;
-            Typing.(compound#frame_type <: self#frame_type);
             compound)
       in
       self#prepare_source after;

src/core/sources/blank.ml

@@ -24,20 +24,30 @@ open Mm
 open Source
 
 class blank duration =
-  let ticks = if duration < 0. then -1 else Frame.main_of_seconds duration in
+  let ticks () =
+    let d = duration () in
+    if d < 0. then -1 else Frame.main_of_seconds d
+  in
   object (self)
     inherit source ~name:"blank" ()
 
     (** Remaining time, -1 for infinity. *)
-    val mutable remaining = ticks
+    val mutable remaining = None
+
+    method remaining =
+      match remaining with
+        | Some r -> r
+        | None ->
+            let r = ticks () in
+            remaining <- Some r;
+            r
 
-    method remaining = remaining
     method stype = `Infallible
     method private can_generate_frame = true
     method self_sync = (`Static, false)
     method! seek x = x
     method seek_source = (self :> Source.source)
-    method abort_track = remaining <- 0
+    method abort_track = remaining <- Some 0
     val mutable is_first = true
 
     method generate_frame =
@@ -84,15 +94,15 @@ class blank duration =
           self#content_type
           (Frame.create ~length Frame.Fields.empty)
       in
-      match (was_first, remaining) with
+      match (was_first, self#remaining) with
         | true, _ -> Frame.add_track_mark frame 0
         | _, -1 -> frame
         | _, r ->
             if r < length then (
-              remaining <- ticks - r;
+              remaining <- Some (ticks () - r);
               Frame.add_track_mark frame r)
             else (
-              remaining <- r - length;
+              remaining <- Some (r - length);
               frame)
   end
 
@@ -102,12 +112,12 @@ let blank =
     ~descr:"Produce silence and blank images." ~return_t
     [
       ( "duration",
-        Lang.float_t,
+        Lang.getter_t Lang.float_t,
         Some (Lang.float (-1.)),
         Some
           "Duration of blank tracks in seconds, Negative value means forever."
       );
     ]
     (fun p ->
-      let d = Lang.to_float (List.assoc "duration" p) in
+      let d = Lang.to_float_getter (List.assoc "duration" p) in
       (new blank d :> source))

src/libs/extra/fades.liq

@@ -0,0 +1,78 @@
+# Plot the first crossfade transition. Used for visualizing and testing
+# crossfade transitions.
+# @flag extra
+def cross.plot(~png=null(), ~dir=null(), s) =
+  dir =
+    if
+      null.defined(dir)
+    then
+      null.get(dir)
+    else
+      dir = file.temp_dir("plot")
+      on_cleanup({file.rmdir(dir)})
+      dir
+    end
+
+  old_txt = path.concat(dir, "old.txt")
+  new_txt = path.concat(dir, "new.txt")
+
+  def gnuplot_cmd(filename) =
+    'set term png; set output "#{filename}"; plot "#{new_txt}" using 1:2 with \
+     lines title "new track", "#{old_txt}" using 1:2 with lines title "old \
+     track"'
+  end
+
+  def store_rms(~id, s) =
+    s = rms(duration=settings.frame.duration(), s)
+    t0 = ref(null())
+
+    source.on_frame(
+      before=false,
+      s,
+      {
+        let t0 =
+          if
+            null.defined(t0())
+          then
+            null.get(t0())
+          else
+            t0 := source.time(s)
+            null.get(t0())
+          end
+        let v = s.rms()
+        let p = source.time(s) - t0
+        fname = id == "old" ? old_txt : new_txt
+        file.write(append=true, data="#{p}\t#{v}\n", fname)
+      }
+    )
+  end
+
+  plotted = ref(false)
+
+  def transition(old, new) =
+    old = store_rms(id="old", fade.out(old.source))
+    new = store_rms(id="new", fade.in(new.source))
+
+    s = blank(duration=0.1)
+    s =
+      source.on_frame(
+        s,
+        {
+          if
+            null.defined(png) and not plotted()
+          then
+            ignore(
+              process.run(
+                "gnuplot -e #{process.quote(gnuplot_cmd(null.get(png)))}"
+              )
+            )
+          end
+          plotted := true
+        }
+      )
+
+    sequence(merge=true, [add(normalize=false, [new, old]), once(s)])
+  end
+
+  cross(transition, s)
+end