1 files changed, 104 insertions, 146 deletions

diff --git a/source/blender/sequencer/intern/strip_time.c b/source/blender/sequencer/intern/strip_time.c
index a5341dbc528..4d6efb1639b 100644
--- a/source/blender/sequencer/intern/strip_time.c
+++ b/source/blender/sequencer/intern/strip_time.c
@@ -27,6 +27,7 @@
 #include "SEQ_time.h"
 #include "SEQ_transform.h"
 
+#include "sequencer.h"
 #include "strip_time.h"
 #include "utils.h"
 
@@ -37,7 +38,7 @@ float seq_give_frame_index(Sequence *seq, float timeline_frame)
   int end = seq->start + seq->len - 1;
 
   if (seq->type & SEQ_TYPE_EFFECT) {
-    end = seq->enddisp;
+    end = SEQ_time_right_handle_frame_get(seq);
   }
 
   if (end < sta) {
@@ -89,7 +90,7 @@ static int metaseq_end(Sequence *metaseq)
   return metaseq->start + metaseq->len - metaseq->endofs;
 }
 
-static void seq_update_sound_bounds_recursive_impl(Scene *scene,
+static void seq_update_sound_bounds_recursive_impl(const Scene *scene,
                                                    Sequence *metaseq,
                                                    int start,
                                                    int end)
@@ -131,40 +132,31 @@ static void seq_update_sound_bounds_recursive_impl(Scene *scene,
   }
 }
 
-void seq_update_sound_bounds_recursive(Scene *scene, Sequence *metaseq)
+void seq_update_sound_bounds_recursive(const Scene *scene, Sequence *metaseq)
 {
   seq_update_sound_bounds_recursive_impl(
       scene, metaseq, metaseq_start(metaseq), metaseq_end(metaseq));
 }
 
-static void seq_time_update_sequence_bounds(Scene *scene, Sequence *seq)
+/* Update meta strip content start and end, update sound playback range. */
+void SEQ_time_update_meta_strip_range(const Scene *scene, Sequence *seq_meta)
 {
-  if (seq->startofs && seq->startstill) {
-    seq->startstill = 0;
-  }
-  if (seq->endofs && seq->endstill) {
-    seq->endstill = 0;
+  if (seq_meta == NULL) {
+    return;
   }
 
-  seq->startdisp = seq->start + seq->startofs - seq->startstill;
-  seq->enddisp = seq->start + seq->len - seq->endofs + seq->endstill;
-
-  if (seq->type == SEQ_TYPE_META) {
-    seq_update_sound_bounds_recursive(scene, seq);
-  }
-}
-
-static void seq_time_update_meta_strip(Scene *scene, Sequence *seq_meta)
-{
   if (BLI_listbase_is_empty(&seq_meta->seqbase)) {
     return;
   }
 
+  const int strip_start = SEQ_time_left_handle_frame_get(seq_meta);
+  const int strip_end = SEQ_time_right_handle_frame_get(seq_meta);
+
   int min = MAXFRAME * 2;
   int max = -MAXFRAME * 2;
   LISTBASE_FOREACH (Sequence *, seq, &seq_meta->seqbase) {
-    min = min_ii(seq->startdisp, min);
-    max = max_ii(seq->enddisp, max);
+    min = min_ii(SEQ_time_left_handle_frame_get(seq), min);
+    max = max_ii(SEQ_time_right_handle_frame_get(seq), max);
   }
 
   seq_meta->start = min + seq_meta->anim_startofs;
@@ -173,144 +165,58 @@ static void seq_time_update_meta_strip(Scene *scene, Sequence *seq_meta)
   seq_meta->len -= seq_meta->anim_endofs;
 
   seq_update_sound_bounds_recursive(scene, seq_meta);
-}
-
-void SEQ_time_update_meta_strip_range(Scene *scene, Sequence *seq_meta)
-{
-  if (seq_meta == NULL) {
-    return;
-  }
-
-  seq_time_update_meta_strip(scene, seq_meta);
 
   /* Prevent meta-strip to move in timeline. */
-  SEQ_transform_set_left_handle_frame(seq_meta, seq_meta->startdisp);
-  SEQ_transform_set_right_handle_frame(seq_meta, seq_meta->enddisp);
+  SEQ_time_left_handle_frame_set(scene, seq_meta, strip_start);
+  SEQ_time_right_handle_frame_set(scene, seq_meta, strip_end);
 }
 
-void SEQ_time_update_sequence(Scene *scene, ListBase *seqbase, Sequence *seq)
+void seq_time_effect_range_set(Sequence *seq)
 {
-  Sequence *seqm;
-
-  /* Check all meta-strips recursively. */
-  seqm = seq->seqbase.first;
-  while (seqm) {
-    if (seqm->seqbase.first) {
-      SEQ_time_update_sequence(scene, &seqm->seqbase, seqm);
-    }
-    seqm = seqm->next;
+  if (seq->seq1 == NULL && seq->seq2 == NULL) {
+    return;
   }
 
-  /* effects and meta: automatic start and end */
-  if (seq->type & SEQ_TYPE_EFFECT) {
-    if (seq->seq1) {
-      seq->startofs = seq->endofs = seq->startstill = seq->endstill = 0;
-      if (seq->seq3) {
-        seq->start = seq->startdisp = max_iii(
-            seq->seq1->startdisp, seq->seq2->startdisp, seq->seq3->startdisp);
-        seq->enddisp = min_iii(seq->seq1->enddisp, seq->seq2->enddisp, seq->seq3->enddisp);
-      }
-      else if (seq->seq2) {
-        seq->start = seq->startdisp = max_ii(seq->seq1->startdisp, seq->seq2->startdisp);
-        seq->enddisp = min_ii(seq->seq1->enddisp, seq->seq2->enddisp);
-      }
-      else {
-        seq->start = seq->startdisp = seq->seq1->startdisp;
-        seq->enddisp = seq->seq1->enddisp;
-      }
-      /* we can't help if strips don't overlap, it won't give useful results.
-       * but at least ensure 'len' is never negative which causes bad bugs elsewhere. */
-      if (seq->enddisp < seq->startdisp) {
-        /* simple start/end swap */
-        seq->start = seq->enddisp;
-        seq->enddisp = seq->startdisp;
-        seq->startdisp = seq->start;
-        seq->flag |= SEQ_INVALID_EFFECT;
-      }
-      else {
-        seq->flag &= ~SEQ_INVALID_EFFECT;
-      }
-
-      seq->len = seq->enddisp - seq->startdisp;
-    }
-    else {
-      seq_time_update_sequence_bounds(scene, seq);
-    }
+  if (seq->seq1 && seq->seq2) { /* 2 - input effect. */
+    seq->startdisp = max_ii(SEQ_time_left_handle_frame_get(seq->seq1),
+                            SEQ_time_left_handle_frame_get(seq->seq2));
+    seq->enddisp = min_ii(SEQ_time_right_handle_frame_get(seq->seq1),
+                          SEQ_time_right_handle_frame_get(seq->seq2));
   }
-  else if (seq->type == SEQ_TYPE_META) {
-    seq_time_update_meta_strip(scene, seq);
+  else if (seq->seq1) { /* Single input effect. */
+    seq->startdisp = SEQ_time_right_handle_frame_get(seq->seq1);
+    seq->enddisp = SEQ_time_left_handle_frame_get(seq->seq1);
   }
-  else {
-    seq_time_update_sequence_bounds(scene, seq);
+  else if (seq->seq2) { /* Strip may be missing one of inputs. */
+    seq->startdisp = SEQ_time_right_handle_frame_get(seq->seq2);
+    seq->enddisp = SEQ_time_left_handle_frame_get(seq->seq2);
   }
 
-  Editing *ed = SEQ_editing_get(scene);
-
-  /* Strip is inside meta strip */
-  if (seqbase != &ed->seqbase) {
-    Sequence *meta = SEQ_get_meta_by_seqbase(&ed->seqbase, seqbase);
-    SEQ_time_update_meta_strip_range(scene, meta);
+  if (seq->startdisp > seq->enddisp) {
+    SWAP(int, seq->startdisp, seq->enddisp);
   }
 
-  seq_time_update_sequence_bounds(scene, seq);
+  /* Values unusable for effects, these should be always 0. */
+  seq->startofs = seq->endofs = seq->anim_startofs = seq->anim_endofs = 0;
 }
 
-static bool update_changed_seq_recurs(Scene *scene, Sequence *seq, Sequence *changed_seq)
+/* Update strip startdisp and enddisp (n-input effects have no len to calculate these). */
+void seq_time_update_effects_strip_range(const Scene *scene, SeqCollection *effects)
 {
-  Sequence *subseq;
-  bool do_update = false;
-
-  /* recurse downwards to see if this seq depends on the changed seq */
-
-  if (seq == NULL) {
-    return false;
-  }
-
-  if (seq == changed_seq) {
-    do_update = true;
-  }
-
-  for (subseq = seq->seqbase.first; subseq; subseq = subseq->next) {
-    if (update_changed_seq_recurs(scene, subseq, changed_seq)) {
-      do_update = true;
-    }
-  }
-
-  if (seq->seq1) {
-    if (update_changed_seq_recurs(scene, seq->seq1, changed_seq)) {
-      do_update = true;
-    }
-  }
-  if (seq->seq2 && (seq->seq2 != seq->seq1)) {
-    if (update_changed_seq_recurs(scene, seq->seq2, changed_seq)) {
-      do_update = true;
-    }
-  }
-  if (seq->seq3 && (seq->seq3 != seq->seq1) && (seq->seq3 != seq->seq2)) {
-    if (update_changed_seq_recurs(scene, seq->seq3, changed_seq)) {
-      do_update = true;
-    }
-  }
-
-  if (do_update) {
-    ListBase *seqbase = SEQ_active_seqbase_get(SEQ_editing_get(scene));
-    SEQ_time_update_sequence(scene, seqbase, seq);
+  if (effects == NULL) {
+    return;
   }
 
-  return do_update;
-}
-
-void SEQ_time_update_recursive(Scene *scene, Sequence *changed_seq)
-{
-  Editing *ed = SEQ_editing_get(scene);
   Sequence *seq;
-
-  if (ed == NULL) {
-    return;
+  /* First pass: Update length of immediate effects. */
+  SEQ_ITERATOR_FOREACH (seq, effects) {
+    seq_time_effect_range_set(seq);
   }
 
-  for (seq = ed->seqbase.first; seq; seq = seq->next) {
-    update_changed_seq_recurs(scene, seq, changed_seq);
+  /* Second pass: Recursive call to update effects in chain and in order, so they inherit length
+   * correctly. */
+  SEQ_ITERATOR_FOREACH (seq, effects) {
+    seq_time_update_effects_strip_range(scene, seq_sequence_lookup_effects_by_seq(scene, seq));
   }
 }
 
@@ -349,12 +255,14 @@ int SEQ_time_find_next_prev_edit(Scene *scene,
     }
 
     if (do_center) {
-      seq_frames[0] = (seq->startdisp + seq->enddisp) / 2;
+      seq_frames[0] = (SEQ_time_left_handle_frame_get(seq) +
+                       SEQ_time_right_handle_frame_get(seq)) /
+                      2;
       seq_frames_tot = 1;
     }
     else {
-      seq_frames[0] = seq->startdisp;
-      seq_frames[1] = seq->enddisp;
+      seq_frames[0] = SEQ_time_left_handle_frame_get(seq);
+      seq_frames[1] = SEQ_time_right_handle_frame_get(seq);
 
       seq_frames_tot = 2;
     }
@@ -438,11 +346,11 @@ void SEQ_timeline_expand_boundbox(const ListBase *seqbase, rctf *rect)
   }
 
   LISTBASE_FOREACH (Sequence *, seq, seqbase) {
-    if (rect->xmin > seq->startdisp - 1) {
-      rect->xmin = seq->startdisp - 1;
+    if (rect->xmin > SEQ_time_left_handle_frame_get(seq) - 1) {
+      rect->xmin = SEQ_time_left_handle_frame_get(seq) - 1;
     }
-    if (rect->xmax < seq->enddisp + 1) {
-      rect->xmax = seq->enddisp + 1;
+    if (rect->xmax < SEQ_time_right_handle_frame_get(seq) + 1) {
+      rect->xmax = SEQ_time_right_handle_frame_get(seq) + 1;
     }
     if (rect->ymax < seq->machine) {
       rect->ymax = seq->machine;
@@ -514,5 +422,55 @@ void seq_time_gap_info_get(const Scene *scene,
 
 bool SEQ_time_strip_intersects_frame(const Sequence *seq, const int timeline_frame)
 {
-  return (seq->startdisp <= timeline_frame) && (seq->enddisp > timeline_frame);
+  return (SEQ_time_left_handle_frame_get(seq) <= timeline_frame) &&
+         (SEQ_time_right_handle_frame_get(seq) > timeline_frame);
+}
+
+bool SEQ_time_has_left_still_frames(const Sequence *seq)
+{
+  return seq->startofs < 0;
+}
+
+bool SEQ_time_has_right_still_frames(const Sequence *seq)
+{
+  return seq->endofs < 0;
+}
+
+bool SEQ_time_has_still_frames(const Sequence *seq)
+{
+  return SEQ_time_has_right_still_frames(seq) || SEQ_time_has_left_still_frames(seq);
+}
+
+int SEQ_time_left_handle_frame_get(const Sequence *seq)
+{
+  if (seq->seq1 || seq->seq2) {
+    return seq->startdisp;
+  }
+
+  return seq->start + seq->startofs;
+}
+
+int SEQ_time_right_handle_frame_get(const Sequence *seq)
+{
+  if (seq->seq1 || seq->seq2) {
+    return seq->enddisp;
+  }
+
+  return seq->start + seq->len - seq->endofs;
+}
+
+void SEQ_time_left_handle_frame_set(const Scene *scene, Sequence *seq, int val)
+{
+  seq->startofs = val - seq->start;
+  seq->startdisp = val; /* Only to make files usable in older versions. */
+  SEQ_time_update_meta_strip_range(scene, seq_sequence_lookup_meta_by_seq(scene, seq));
+  seq_time_update_effects_strip_range(scene, seq_sequence_lookup_effects_by_seq(scene, seq));
+}
+
+void SEQ_time_right_handle_frame_set(const Scene *scene, Sequence *seq, int val)
+{
+  seq->endofs = seq->start + seq->len - val;
+  seq->enddisp = val; /* Only to make files usable in older versions. */
+  SEQ_time_update_meta_strip_range(scene, seq_sequence_lookup_meta_by_seq(scene, seq));
+  seq_time_update_effects_strip_range(scene, seq_sequence_lookup_effects_by_seq(scene, seq));
 }