VSE: Remove seq->tmp usage

Remove `seq->tmp` usage from transform code. It was used to tag strips
that need to be "shuffled". Pass these strips in `SeqCollection`
instead.

Reviewed By: sergey, mano-wii

Differential Revision: https://developer.blender.org/D11631

3 files changed, 116 insertions, 105 deletions

diff --git a/source/blender/editors/transform/transform_convert_sequencer.c b/source/blender/editors/transform/transform_convert_sequencer.c
index 4370e515680..eb8641f5070 100644
--- a/source/blender/editors/transform/transform_convert_sequencer.c
+++ b/source/blender/editors/transform/transform_convert_sequencer.c
@@ -318,16 +318,21 @@ static bool seq_transform_check_overlap(SeqCollection *transformed_strips)
   return false;
 }
 
-/* Offset all strips positioned after left edge of transformed strips boundbox by amount equal to
- * overlap of transformed strips. */
-static void seq_transform_handle_expand_to_fit(TransInfo *t, SeqCollection *transformed_strips)
+static SeqCollection *extract_standalone_strips(SeqCollection *transformed_strips)
 {
-  Editing *ed = SEQ_editing_get(t->scene, false);
-  ListBase *seqbasep = SEQ_active_seqbase_get(ed);
-  ListBase *markers = &t->scene->markers;
-  const bool use_sync_markers = (((SpaceSeq *)t->area->spacedata.first)->flag &
-                                 SEQ_MARKER_TRANS) != 0;
+  SeqCollection *collection = SEQ_collection_create();
+  Sequence *seq;
+  SEQ_ITERATOR_FOREACH (seq, transformed_strips) {
+    if ((seq->type & SEQ_TYPE_EFFECT) == 0 || seq->seq1 == NULL) {
+      SEQ_collection_append_strip(seq, collection);
+    }
+  }
+  return collection;
+}
 
+/* Query strips positioned after left edge of transformed strips boundbox. */
+static SeqCollection *query_right_side_strips(ListBase *seqbase, SeqCollection *transformed_strips)
+{
   int minframe = MAXFRAME;
   {
     Sequence *seq;
@@ -336,35 +341,40 @@ static void seq_transform_handle_expand_to_fit(TransInfo *t, SeqCollection *tran
     }
   }
 
-  /* Temporarily move strips to beyond timeline boundary */
-  LISTBASE_FOREACH (Sequence *, seq, seqbasep) {
-    if (!(seq->flag & SELECT)) {
-      if (seq->startdisp >= minframe) {
-        seq->machine += MAXSEQ * 2;
-      }
+  SeqCollection *collection = SEQ_collection_create();
+  LISTBASE_FOREACH (Sequence *, seq, seqbase) {
+    if ((seq->flag & SELECT) == 0 && seq->startdisp >= minframe) {
+      SEQ_collection_append_strip(seq, collection);
     }
   }
+  return collection;
+}
 
-  /* Shuffle transformed non-effects. This is because transformed strips can overlap with strips
-   * on left side. */
-  SEQ_transform_seqbase_shuffle_time(seqbasep, t->scene, markers, use_sync_markers);
-  /* Move temporarily moved strips back to their original place and tag for shuffling. */
-  LISTBASE_FOREACH (Sequence *, seq, seqbasep) {
-    if (seq->machine >= MAXSEQ * 2) {
-      seq->machine -= MAXSEQ * 2;
-      seq->tmp = (void *)1;
-    }
-    else {
-      seq->tmp = NULL;
+static void seq_transform_update_effects(TransInfo *t, SeqCollection *collection)
+{
+  Sequence *seq;
+  SEQ_ITERATOR_FOREACH (seq, collection) {
+    if ((seq->type & SEQ_TYPE_EFFECT) && (seq->seq1 || seq->seq2 || seq->seq3)) {
+        SEQ_time_update_sequence(t->scene, seq);
     }
   }
+}
 
-  /* Shuffle again to displace strips on right side. Final effect shuffling is done in
-   * seq_transform_handle_overlap. */
-  SEQ_transform_seqbase_shuffle_time(seqbasep, t->scene, markers, use_sync_markers);
+/* Check if effect strips with input are transformed. */
+static bool seq_transform_check_strip_effects(SeqCollection *transformed_strips)
+{
+  Sequence *seq;
+  SEQ_ITERATOR_FOREACH (seq, transformed_strips) {
+    if ((seq->type & SEQ_TYPE_EFFECT) && (seq->seq1 || seq->seq2 || seq->seq3)) {
+      return true;
+    }
+  }
+  return false;
 }
 
-static void seq_transform_handle_overlap(TransInfo *t, SeqCollection *transformed_strips)
+/* Offset all strips positioned after left edge of transformed strips boundbox by amount equal
+ * to overlap of transformed strips. */
+static void seq_transform_handle_expand_to_fit(TransInfo *t, SeqCollection *transformed_strips)
 {
   Editing *ed = SEQ_editing_get(t->scene, false);
   ListBase *seqbasep = SEQ_active_seqbase_get(ed);
@@ -372,38 +382,58 @@ static void seq_transform_handle_overlap(TransInfo *t, SeqCollection *transforme
   const bool use_sync_markers = (((SpaceSeq *)t->area->spacedata.first)->flag &
                                  SEQ_MARKER_TRANS) != 0;
 
-  LISTBASE_FOREACH (Sequence *, seq, seqbasep) {
-    seq->tmp = NULL;
-  }
+  SeqCollection *right_side_strips = query_right_side_strips(seqbasep, transformed_strips);
 
-  /* Check if effect strips are transformed and tag non effects. */
-  bool has_effect = false;
+  /* Temporarily move right side strips beyond timeline boundary. */
   Sequence *seq;
-  SEQ_ITERATOR_FOREACH (seq, transformed_strips) {
-    if ((seq->type & SEQ_TYPE_EFFECT) && seq->seq1) {
-      has_effect = true;
-    }
-    else {
-      seq->tmp = (void *)1;
-    }
+  SEQ_ITERATOR_FOREACH (seq, right_side_strips) {
+    seq->machine += MAXSEQ * 2;
+  }
+
+  /* Shuffle transformed standalone strips. This is because transformed strips can overlap with
+   * strips on left side. */
+  SeqCollection *standalone_strips = extract_standalone_strips(transformed_strips);
+  SEQ_transform_seqbase_shuffle_time(
+      standalone_strips, seqbasep, t->scene, markers, use_sync_markers);
+  SEQ_collection_free(standalone_strips);
+
+  /* Move temporarily moved strips back to their original place and tag for shuffling. */
+  SEQ_ITERATOR_FOREACH (seq, right_side_strips) {
+    seq->machine -= MAXSEQ * 2;
   }
+  /* Shuffle again to displace strips on right side. Final effect shuffling is done in
+   * seq_transform_handle_overlap. */
+  SEQ_transform_seqbase_shuffle_time(
+      right_side_strips, seqbasep, t->scene, markers, use_sync_markers);
+  seq_transform_update_effects(t, right_side_strips);
+  SEQ_collection_free(right_side_strips);
+}
+
+static void seq_transform_handle_overlap(TransInfo *t, SeqCollection *transformed_strips)
+{
+  Editing *ed = SEQ_editing_get(t->scene, false);
+  ListBase *seqbasep = SEQ_active_seqbase_get(ed);
 
   if (t->flag & T_ALT_TRANSFORM) {
     seq_transform_handle_expand_to_fit(t, transformed_strips);
   }
   else {
-    SEQ_transform_seqbase_shuffle_time(seqbasep, t->scene, markers, use_sync_markers);
+    ListBase *markers = &t->scene->markers;
+    const bool use_sync_markers = (((SpaceSeq *)t->area->spacedata.first)->flag &
+                                   SEQ_MARKER_TRANS) != 0;
+    /* Shuffle non strips with no effects attached. */
+    SeqCollection *standalone_strips = extract_standalone_strips(transformed_strips);
+    SEQ_transform_seqbase_shuffle_time(
+        standalone_strips, seqbasep, t->scene, markers, use_sync_markers);
+    SEQ_collection_free(standalone_strips);
   }
 
-  if (has_effect) {
+  if (seq_transform_check_strip_effects(transformed_strips)) {
     /* Update effect strips based on strips just moved in time. */
-    SEQ_ITERATOR_FOREACH (seq, transformed_strips) {
-      if ((seq->type & SEQ_TYPE_EFFECT) && seq->seq1) {
-        SEQ_time_update_sequence(t->scene, seq);
-      }
-    }
+    seq_transform_update_effects(t, transformed_strips);
 
     /* If any effects still overlap, we need to move them up. */
+    Sequence *seq;
     SEQ_ITERATOR_FOREACH (seq, transformed_strips) {
       if ((seq->type & SEQ_TYPE_EFFECT) && seq->seq1) {
         if (SEQ_transform_test_overlap(seqbasep, seq)) {
@@ -414,24 +444,6 @@ static void seq_transform_handle_overlap(TransInfo *t, SeqCollection *transforme
   }
 }
 
-static void seq_transform_update_effects(TransInfo *t, SeqCollection *transformed_strips)
-{
-  Sequence *seq;
-  SEQ_ITERATOR_FOREACH (seq, transformed_strips) {
-    if (seq->type & SEQ_TYPE_EFFECT) {
-      if (seq->seq1 && seq->seq1->flag & SELECT) {
-        SEQ_time_update_sequence(t->scene, seq);
-      }
-      else if (seq->seq2 && seq->seq2->flag & SELECT) {
-        SEQ_time_update_sequence(t->scene, seq);
-      }
-      else if (seq->seq3 && seq->seq3->flag & SELECT) {
-        SEQ_time_update_sequence(t->scene, seq);
-      }
-    }
-  }
-}
-
 static SeqCollection *seq_transform_collection_from_transdata(TransDataContainer *tc)
 {
   SeqCollection *collection = SEQ_collection_create();
diff --git a/source/blender/sequencer/SEQ_transform.h b/source/blender/sequencer/SEQ_transform.h
index d587bd0f1a1..837a2de5742 100644
--- a/source/blender/sequencer/SEQ_transform.h
+++ b/source/blender/sequencer/SEQ_transform.h
@@ -30,6 +30,7 @@ extern "C" {
 struct ListBase;
 struct Scene;
 struct Sequence;
+struct SeqCollection;
 
 int SEQ_transform_get_left_handle_frame(struct Sequence *seq);
 int SEQ_transform_get_right_handle_frame(struct Sequence *seq);
@@ -48,7 +49,8 @@ bool SEQ_transform_seqbase_shuffle_ex(struct ListBase *seqbasep,
 bool SEQ_transform_seqbase_shuffle(struct ListBase *seqbasep,
                                    struct Sequence *test,
                                    struct Scene *evil_scene);
-bool SEQ_transform_seqbase_shuffle_time(struct ListBase *seqbasep,
+bool SEQ_transform_seqbase_shuffle_time(struct SeqCollection *strips_to_shuffle,
+                                        struct ListBase *seqbasep,
                                         struct Scene *evil_scene,
                                         struct ListBase *markers,
                                         const bool use_sync_markers);
diff --git a/source/blender/sequencer/intern/strip_transform.c b/source/blender/sequencer/intern/strip_transform.c
index b969f531e68..095d3b2fa9d 100644
--- a/source/blender/sequencer/intern/strip_transform.c
+++ b/source/blender/sequencer/intern/strip_transform.c
@@ -34,6 +34,7 @@
 #include "BKE_sound.h"
 
 #include "SEQ_effects.h"
+#include "SEQ_iterator.h"
 #include "SEQ_relations.h"
 #include "SEQ_sequencer.h"
 #include "SEQ_time.h"
@@ -302,73 +303,69 @@ bool SEQ_transform_seqbase_shuffle(ListBase *seqbasep, Sequence *test, Scene *ev
   return SEQ_transform_seqbase_shuffle_ex(seqbasep, test, evil_scene, 1);
 }
 
-static int shuffle_seq_time_offset_test(ListBase *seqbasep, char dir)
+static int shuffle_seq_time_offset_test(SeqCollection *strips_to_shuffle,
+                                        ListBase *seqbasep,
+                                        char dir)
 {
   int offset = 0;
-  Sequence *seq, *seq_other;
-
-  for (seq = seqbasep->first; seq; seq = seq->next) {
-    if (seq->tmp) {
-      for (seq_other = seqbasep->first; seq_other; seq_other = seq_other->next) {
-        if (!seq_other->tmp && seq_overlap(seq, seq_other)) {
-          if (dir == 'L') {
-            offset = min_ii(offset, seq_other->startdisp - seq->enddisp);
-          }
-          else {
-            offset = max_ii(offset, seq_other->enddisp - seq->startdisp);
-          }
-        }
+  Sequence *seq;
+
+  SEQ_ITERATOR_FOREACH (seq, strips_to_shuffle) {
+    LISTBASE_FOREACH (Sequence *, seq_other, seqbasep) {
+      if (!seq_overlap(seq, seq_other)) {
+        continue;
+      }
+      if (dir == 'L') {
+        offset = min_ii(offset, seq_other->startdisp - seq->enddisp);
+      }
+      else {
+        offset = max_ii(offset, seq_other->enddisp - seq->startdisp);
       }
     }
   }
   return offset;
 }
 
-static int shuffle_seq_time_offset(Scene *scene, ListBase *seqbasep, char dir)
+static int shuffle_seq_time_offset(SeqCollection *strips_to_shuffle,
+                                   ListBase *seqbasep,
+                                   Scene *scene,
+                                   char dir)
 {
   int ofs = 0;
   int tot_ofs = 0;
   Sequence *seq;
-  while ((ofs = shuffle_seq_time_offset_test(seqbasep, dir))) {
-    for (seq = seqbasep->first; seq; seq = seq->next) {
-      if (seq->tmp) {
-        /* seq_test_overlap only tests display values */
-        seq->startdisp += ofs;
-        seq->enddisp += ofs;
-      }
+  while ((ofs = shuffle_seq_time_offset_test(strips_to_shuffle, seqbasep, dir))) {
+    SEQ_ITERATOR_FOREACH (seq, strips_to_shuffle) {
+      /* seq_test_overlap only tests display values */
+      seq->startdisp += ofs;
+      seq->enddisp += ofs;
     }
 
     tot_ofs += ofs;
   }
 
-  for (seq = seqbasep->first; seq; seq = seq->next) {
-    if (seq->tmp) {
-      SEQ_time_update_sequence_bounds(scene, seq); /* corrects dummy startdisp/enddisp values */
-    }
+  SEQ_ITERATOR_FOREACH (seq, strips_to_shuffle) {
+    SEQ_time_update_sequence_bounds(scene, seq); /* corrects dummy startdisp/enddisp values */
   }
 
   return tot_ofs;
 }
 
-bool SEQ_transform_seqbase_shuffle_time(ListBase *seqbasep,
+bool SEQ_transform_seqbase_shuffle_time(SeqCollection *strips_to_shuffle,
+                                        ListBase *seqbasep,
                                         Scene *evil_scene,
                                         ListBase *markers,
                                         const bool use_sync_markers)
 {
-  /* note: seq->tmp is used to tag strips to move */
-
-  Sequence *seq;
-
-  int offset_l = shuffle_seq_time_offset(evil_scene, seqbasep, 'L');
-  int offset_r = shuffle_seq_time_offset(evil_scene, seqbasep, 'R');
+  int offset_l = shuffle_seq_time_offset(strips_to_shuffle, seqbasep, evil_scene, 'L');
+  int offset_r = shuffle_seq_time_offset(strips_to_shuffle, seqbasep, evil_scene, 'R');
   int offset = (-offset_l < offset_r) ? offset_l : offset_r;
 
   if (offset) {
-    for (seq = seqbasep->first; seq; seq = seq->next) {
-      if (seq->tmp) {
-        SEQ_transform_translate_sequence(evil_scene, seq, offset);
-        seq->flag &= ~SEQ_OVERLAP;
-      }
+    Sequence *seq;
+    SEQ_ITERATOR_FOREACH (seq, strips_to_shuffle) {
+      SEQ_transform_translate_sequence(evil_scene, seq, offset);
+      seq->flag &= ~SEQ_OVERLAP;
     }
 
     if (use_sync_markers && !(evil_scene->toolsettings->lock_markers) && (markers != NULL)) {