archive/blender-archive
Archived
1
1
Fork 0
Code Pull Requests Packages Activity

VSE: Remove seq->tmp usage

Browse Source 
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
This commit is contained in:
Richard Antalik
2021-06-19 05:04:16 +02:00
parent f9aea19d98
commit 033641aa74
3 changed files with 119 additions and 108 deletions
Download Patch File Download Diff File Expand all files Collapse all files

152
source/blender/editors/transform/transform_convert_sequencer.c
View File

@@ -318,16 +318,21 @@ static bool seq_transform_check_overlap(SeqCollection *transformed_strips)
return false; return false;
} }
/* Offset all strips positioned after left edge of transformed strips boundbox by amount equal to static SeqCollection *extract_standalone_strips(SeqCollection *transformed_strips)
* 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); SeqCollection *collection = SEQ_collection_create();
ListBase *seqbasep = SEQ_active_seqbase_get(ed); Sequence *seq;
ListBase *markers = &t->scene->markers; SEQ_ITERATOR_FOREACH (seq, transformed_strips) {
const bool use_sync_markers = (((SpaceSeq *)t->area->spacedata.first)->flag & if ((seq->type & SEQ_TYPE_EFFECT) == 0 || seq->seq1 == NULL) {
SEQ_MARKER_TRANS) != 0; 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; int minframe = MAXFRAME;
{ {
Sequence *seq; 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 */ SeqCollection *collection = SEQ_collection_create();
LISTBASE_FOREACH (Sequence *, seq, seqbasep) { LISTBASE_FOREACH (Sequence *, seq, seqbase) {
if (!(seq->flag & SELECT)) { if ((seq->flag & SELECT) == 0 && seq->startdisp >= minframe) {
if (seq->startdisp >= minframe) { SEQ_collection_append_strip(seq, collection);
seq->machine += MAXSEQ * 2;
}
} }
} }
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;
}
}
/* 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);
} }
static void seq_transform_handle_overlap(TransInfo *t, SeqCollection *transformed_strips) 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);
}
}
}
/* 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;
}
/* 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); Editing *ed = SEQ_editing_get(t->scene, false);
ListBase *seqbasep = SEQ_active_seqbase_get(ed); 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 & const bool use_sync_markers = (((SpaceSeq *)t->area->spacedata.first)->flag &
SEQ_MARKER_TRANS) != 0; SEQ_MARKER_TRANS) != 0;
LISTBASE_FOREACH (Sequence *, seq, seqbasep) { SeqCollection *right_side_strips = query_right_side_strips(seqbasep, transformed_strips);
seq->tmp = NULL;
/* Temporarily move right side strips beyond timeline boundary. */
Sequence *seq;
SEQ_ITERATOR_FOREACH (seq, right_side_strips) {
seq->machine += MAXSEQ * 2;
} }
/* Check if effect strips are transformed and tag non effects. */ /* Shuffle transformed standalone strips. This is because transformed strips can overlap with
bool has_effect = false; * strips on left side. */
Sequence *seq; SeqCollection *standalone_strips = extract_standalone_strips(transformed_strips);
SEQ_ITERATOR_FOREACH (seq, transformed_strips) { SEQ_transform_seqbase_shuffle_time(
if ((seq->type & SEQ_TYPE_EFFECT) && seq->seq1) { standalone_strips, seqbasep, t->scene, markers, use_sync_markers);
has_effect = true; SEQ_collection_free(standalone_strips);
}
else { /* Move temporarily moved strips back to their original place and tag for shuffling. */
seq->tmp = (void *)1; 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) { if (t->flag & T_ALT_TRANSFORM) {
seq_transform_handle_expand_to_fit(t, transformed_strips); seq_transform_handle_expand_to_fit(t, transformed_strips);
} }
else { 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. */ /* Update effect strips based on strips just moved in time. */
SEQ_ITERATOR_FOREACH (seq, transformed_strips) { seq_transform_update_effects(t, transformed_strips);
if ((seq->type & SEQ_TYPE_EFFECT) && seq->seq1) {
SEQ_time_update_sequence(t->scene, seq);
}
}
/* If any effects still overlap, we need to move them up. */ /* If any effects still overlap, we need to move them up. */
Sequence *seq;
SEQ_ITERATOR_FOREACH (seq, transformed_strips) { SEQ_ITERATOR_FOREACH (seq, transformed_strips) {
if ((seq->type & SEQ_TYPE_EFFECT) && seq->seq1) { if ((seq->type & SEQ_TYPE_EFFECT) && seq->seq1) {
if (SEQ_transform_test_overlap(seqbasep, seq)) { 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) static SeqCollection *seq_transform_collection_from_transdata(TransDataContainer *tc)
{ {
SeqCollection *collection = SEQ_collection_create(); SeqCollection *collection = SEQ_collection_create();

4
source/blender/sequencer/SEQ_transform.h
View File

@@ -30,6 +30,7 @@ extern "C" {
struct ListBase; struct ListBase;
struct Scene; struct Scene;
struct Sequence; struct Sequence;
struct SeqCollection;
int SEQ_transform_get_left_handle_frame(struct Sequence *seq); int SEQ_transform_get_left_handle_frame(struct Sequence *seq);
int SEQ_transform_get_right_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, bool SEQ_transform_seqbase_shuffle(struct ListBase *seqbasep,
struct Sequence *test, struct Sequence *test,
struct Scene *evil_scene); 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 Scene *evil_scene,
struct ListBase *markers, struct ListBase *markers,
const bool use_sync_markers); const bool use_sync_markers);

71
source/blender/sequencer/intern/strip_transform.c
View File

@@ -34,6 +34,7 @@
#include "BKE_sound.h" #include "BKE_sound.h"
#include "SEQ_effects.h" #include "SEQ_effects.h"
#include "SEQ_iterator.h"
#include "SEQ_relations.h" #include "SEQ_relations.h"
#include "SEQ_sequencer.h" #include "SEQ_sequencer.h"
#include "SEQ_time.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); 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; int offset = 0;
Sequence *seq, *seq_other; Sequence *seq;
for (seq = seqbasep->first; seq; seq = seq->next) { SEQ_ITERATOR_FOREACH (seq, strips_to_shuffle) {
if (seq->tmp) { LISTBASE_FOREACH (Sequence *, seq_other, seqbasep) {
for (seq_other = seqbasep->first; seq_other; seq_other = seq_other->next) { if (!seq_overlap(seq, seq_other)) {
if (!seq_other->tmp && seq_overlap(seq, seq_other)) { continue;
if (dir == 'L') { }
offset = min_ii(offset, seq_other->startdisp - seq->enddisp); if (dir == 'L') {
} offset = min_ii(offset, seq_other->startdisp - seq->enddisp);
else { }
offset = max_ii(offset, seq_other->enddisp - seq->startdisp); else {
} offset = max_ii(offset, seq_other->enddisp - seq->startdisp);
}
} }
} }
} }
return offset; 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 ofs = 0;
int tot_ofs = 0; int tot_ofs = 0;
Sequence *seq; Sequence *seq;
while ((ofs = shuffle_seq_time_offset_test(seqbasep, dir))) { while ((ofs = shuffle_seq_time_offset_test(strips_to_shuffle, seqbasep, dir))) {
for (seq = seqbasep->first; seq; seq = seq->next) { SEQ_ITERATOR_FOREACH (seq, strips_to_shuffle) {
if (seq->tmp) { /* seq_test_overlap only tests display values */
/* seq_test_overlap only tests display values */ seq->startdisp += ofs;
seq->startdisp += ofs; seq->enddisp += ofs;
seq->enddisp += ofs;
}
} }
tot_ofs += ofs; tot_ofs += ofs;
} }
for (seq = seqbasep->first; seq; seq = seq->next) { SEQ_ITERATOR_FOREACH (seq, strips_to_shuffle) {
if (seq->tmp) { SEQ_time_update_sequence_bounds(scene, seq); /* corrects dummy startdisp/enddisp values */
SEQ_time_update_sequence_bounds(scene, seq); /* corrects dummy startdisp/enddisp values */
}
} }
return tot_ofs; 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, Scene *evil_scene,
ListBase *markers, ListBase *markers,
const bool use_sync_markers) const bool use_sync_markers)
{ {
/* note: seq->tmp is used to tag strips to move */ 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');
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 = (-offset_l < offset_r) ? offset_l : offset_r; int offset = (-offset_l < offset_r) ? offset_l : offset_r;
if (offset) { if (offset) {
for (seq = seqbasep->first; seq; seq = seq->next) { Sequence *seq;
if (seq->tmp) { SEQ_ITERATOR_FOREACH (seq, strips_to_shuffle) {
SEQ_transform_translate_sequence(evil_scene, seq, offset); SEQ_transform_translate_sequence(evil_scene, seq, offset);
seq->flag &= ~SEQ_OVERLAP; seq->flag &= ~SEQ_OVERLAP;
}
} }
if (use_sync_markers && !(evil_scene->toolsettings->lock_markers) && (markers != NULL)) { if (use_sync_markers && !(evil_scene->toolsettings->lock_markers) && (markers != NULL)) {