blender
/
blender
136
406
Fork 590
Code Issues 6.2k Pull Requests 764 Projects 19 Wiki Activity

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
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
Show Stats 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;
}
/* 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);
}
}
/* 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);
return collection;
}
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);
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);
/* 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. */
bool has_effect = false;
Sequence *seq;
SEQ_ITERATOR_FOREACH (seq, transformed_strips) {
if ((seq->type & SEQ_TYPE_EFFECT) && seq->seq1) {
has_effect = true;
}
else {
seq->tmp = (void *)1;
}
/* 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();

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

@ -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);

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

@ -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;
Sequence *seq;
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);
}
}
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)) {