Bring back crossfade computation over overlap. (#3716)

Author: toots

src/core/operators/cross.ml

@@ -265,6 +265,7 @@ 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_after buffered_before in
       let after =
         Clock.collect_after (fun () ->
             let metadata = function
@@ -273,20 +274,55 @@ 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);
             before#set_id (self#id ^ "_before");
+            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
             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 duration over overlapping %.2fs buffered \
+               data at start and end."
+              (Frame.seconds_of_main buffered);
             let compound =
               let params =
                 [
@@ -317,7 +353,19 @@ class cross val_source ~duration_getter ~override_duration ~persist_override
               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/libs/fades.liq

@@ -526,9 +526,18 @@ def fade.in(
     curve_log =
       if null.defined(curve()) then string(null.get(curve())) else "default" end
 
+    duration =
+      if
+        source.remaining(s) < duration()
+      then
+        source.remaining(s)
+      else
+        duration()
+      end
+
     log(
       "Fading in with type: #{type()}, curve: #{curve_log}, delay: #{delay()}s \
-       and duration: #{duration()}s."
+       and duration: #{duration}s."
     )
     fn :=
       mkfade(
@@ -537,7 +546,7 @@ def fade.in(
         type=type(),
         curve=curve(),
         delay=delay(),
-        duration=duration(),
+        duration=duration,
         s
       )
   end