Blender  V3.3
sequencer.c
Go to the documentation of this file.
1 /* SPDX-License-Identifier: GPL-2.0-or-later
2  * Copyright 2001-2002 NaN Holding BV. All rights reserved.
3  * 2003-2009 Blender Foundation.
4  * 2005-2006 Peter Schlaile <peter [at] schlaile [dot] de> */
5 
10 #define DNA_DEPRECATED_ALLOW
11 
12 #include "MEM_guardedalloc.h"
13 
14 #include "DNA_anim_types.h"
15 #include "DNA_scene_types.h"
16 #include "DNA_sequence_types.h"
17 #include "DNA_sound_types.h"
18 
19 #include "BLI_listbase.h"
20 
21 #include "BKE_idprop.h"
22 #include "BKE_lib_id.h"
23 #include "BKE_sound.h"
24 
25 #include "DEG_depsgraph.h"
26 
27 #include "IMB_colormanagement.h"
28 #include "IMB_imbuf.h"
29 
30 #include "SEQ_channels.h"
31 #include "SEQ_edit.h"
32 #include "SEQ_effects.h"
33 #include "SEQ_iterator.h"
34 #include "SEQ_modifier.h"
35 #include "SEQ_proxy.h"
36 #include "SEQ_relations.h"
37 #include "SEQ_select.h"
38 #include "SEQ_sequencer.h"
39 #include "SEQ_sound.h"
40 #include "SEQ_time.h"
41 #include "SEQ_utils.h"
42 
43 #include "BLO_read_write.h"
44 
45 #include "image_cache.h"
46 #include "prefetch.h"
47 #include "sequencer.h"
48 #include "utils.h"
49 
50 /* -------------------------------------------------------------------- */
55 {
56  StripProxy *strip_proxy = MEM_callocN(sizeof(struct StripProxy), "StripProxy");
57  strip_proxy->quality = 50;
58  strip_proxy->build_tc_flags = SEQ_PROXY_TC_ALL;
59  strip_proxy->tc = SEQ_PROXY_TC_RECORD_RUN;
60  return strip_proxy;
61 }
62 
64 {
65  Strip *strip = MEM_callocN(sizeof(Strip), "strip");
66 
68  strip->transform = MEM_callocN(sizeof(struct StripTransform), "StripTransform");
69  strip->transform->scale_x = 1;
70  strip->transform->scale_y = 1;
71  strip->transform->origin[0] = 0.5f;
72  strip->transform->origin[1] = 0.5f;
74  strip->crop = MEM_callocN(sizeof(struct StripCrop), "StripCrop");
75  }
76 
77  strip->us = 1;
78  return strip;
79 }
80 
81 static void seq_free_strip(Strip *strip)
82 {
83  strip->us--;
84  if (strip->us > 0) {
85  return;
86  }
87  if (strip->us < 0) {
88  printf("error: negative users in strip\n");
89  return;
90  }
91 
92  if (strip->stripdata) {
93  MEM_freeN(strip->stripdata);
94  }
95 
96  if (strip->proxy) {
97  if (strip->proxy->anim) {
98  IMB_free_anim(strip->proxy->anim);
99  }
100 
101  MEM_freeN(strip->proxy);
102  }
103  if (strip->crop) {
104  MEM_freeN(strip->crop);
105  }
106  if (strip->transform) {
107  MEM_freeN(strip->transform);
108  }
109 
110  MEM_freeN(strip);
111 }
112 
113 Sequence *SEQ_sequence_alloc(ListBase *lb, int timeline_frame, int machine, int type)
114 {
115  Sequence *seq;
116 
117  seq = MEM_callocN(sizeof(Sequence), "addseq");
118  BLI_addtail(lb, seq);
119 
120  *((short *)seq->name) = ID_SEQ;
121  seq->name[2] = 0;
122 
123  seq->flag = SELECT;
124  seq->start = timeline_frame;
125  seq->machine = machine;
126  seq->sat = 1.0;
127  seq->mul = 1.0;
128  seq->blend_opacity = 100.0;
129  seq->volume = 1.0f;
130  seq->scene_sound = NULL;
131  seq->type = type;
132  seq->media_playback_rate = 0.0f;
133  seq->speed_factor = 1.0f;
134 
135  if (seq->type == SEQ_TYPE_ADJUSTMENT) {
136  seq->blend_mode = SEQ_TYPE_CROSS;
137  }
138  else {
140  }
141 
142  seq->strip = seq_strip_alloc(type);
143  seq->stereo3d_format = MEM_callocN(sizeof(Stereo3dFormat), "Sequence Stereo Format");
144 
146 
147  if (seq->type == SEQ_TYPE_META) {
149  }
150 
152 
153  return seq;
154 }
155 
156 /* only give option to skip cache locally (static func) */
158  Sequence *seq,
159  const bool do_cache,
160  const bool do_id_user)
161 {
162  if (seq->strip) {
163  seq_free_strip(seq->strip);
164  }
165 
167 
168  if (seq->type & SEQ_TYPE_EFFECT) {
170  sh.free(seq, do_id_user);
171  }
172 
173  if (seq->sound && do_id_user) {
174  id_us_min(((ID *)seq->sound));
175  }
176 
177  if (seq->stereo3d_format) {
179  }
180 
181  /* clipboard has no scene and will never have a sound handle or be active
182  * same goes to sequences copy for proxy rebuild job
183  */
184  if (scene) {
185  Editing *ed = scene->ed;
186 
187  if (ed->act_seq == seq) {
188  ed->act_seq = NULL;
189  }
190 
191  if (seq->scene_sound && ELEM(seq->type, SEQ_TYPE_SOUND_RAM, SEQ_TYPE_SCENE)) {
193  }
194  }
195 
196  if (seq->prop) {
197  IDP_FreePropertyContent_ex(seq->prop, do_id_user);
198  MEM_freeN(seq->prop);
199  }
200 
201  /* free modifiers */
202  SEQ_modifier_clear(seq);
203 
204  /* free cached data used by this strip,
205  * also invalidate cache for all dependent sequences
206  *
207  * be _very_ careful here, invalidating cache loops over the scene sequences and
208  * assumes the listbase is valid for all strips,
209  * this may not be the case if lists are being freed.
210  * this is optional SEQ_relations_invalidate_cache
211  */
212  if (do_cache) {
213  if (scene) {
215  }
216  }
217  if (seq->type == SEQ_TYPE_META) {
219  }
220 
221  MEM_freeN(seq);
222 }
223 
225 {
226  seq_sequence_free_ex(scene, seq, true, true);
227 }
228 
229 void seq_free_sequence_recurse(Scene *scene, Sequence *seq, const bool do_id_user)
230 {
231  Sequence *iseq, *iseq_next;
232 
233  for (iseq = seq->seqbase.first; iseq; iseq = iseq_next) {
234  iseq_next = iseq->next;
235  seq_free_sequence_recurse(scene, iseq, do_id_user);
236  }
237 
238  seq_sequence_free_ex(scene, seq, false, do_id_user);
239 }
240 
242 {
243  return scene->ed;
244 }
245 
247 {
248  if (scene->ed == NULL) {
249  Editing *ed;
250 
251  ed = scene->ed = MEM_callocN(sizeof(Editing), "addseq");
252  ed->seqbasep = &ed->seqbase;
253  ed->cache = NULL;
256  ed->displayed_channels = &ed->channels;
258  }
259 
260  return scene->ed;
261 }
262 
263 void SEQ_editing_free(Scene *scene, const bool do_id_user)
264 {
265  Editing *ed = scene->ed;
266 
267  if (ed == NULL) {
268  return;
269  }
270 
273 
274  /* handle cache freeing above */
275  LISTBASE_FOREACH_MUTABLE (Sequence *, seq, &ed->seqbase) {
276  seq_free_sequence_recurse(scene, seq, do_id_user);
277  }
278 
279  BLI_freelistN(&ed->metastack);
282  MEM_freeN(ed);
283 
284  scene->ed = NULL;
285 }
286 
288 {
290 
291  if (seq->type & SEQ_TYPE_EFFECT) {
292  if (seq->seq1 && seq->seq1->tmp) {
293  seq->seq1 = seq->seq1->tmp;
294  }
295  if (seq->seq2 && seq->seq2->tmp) {
296  seq->seq2 = seq->seq2->tmp;
297  }
298  if (seq->seq3 && seq->seq3->tmp) {
299  seq->seq3 = seq->seq3->tmp;
300  }
301  }
302  else if (seq->type == SEQ_TYPE_META) {
303  Sequence *seqn;
304  for (seqn = seq->seqbase.first; seqn; seqn = seqn->next) {
306  }
307  }
308 
309  for (smd = seq->modifiers.first; smd; smd = smd->next) {
310  if (smd->mask_sequence && smd->mask_sequence->tmp) {
311  smd->mask_sequence = smd->mask_sequence->tmp;
312  }
313  }
314 }
315 
317 {
319  "Sequencer tool settings");
320  tool_settings->fit_method = SEQ_SCALE_TO_FIT;
323  tool_settings->snap_distance = 15;
324  tool_settings->overlap_mode = SEQ_OVERLAP_SHUFFLE;
325  tool_settings->pivot_point = V3D_AROUND_LOCAL_ORIGINS;
326 
327  return tool_settings;
328 }
329 
331 {
333  if (tool_settings == NULL) {
335  tool_settings = scene->toolsettings->sequencer_tool_settings;
336  }
337 
338  return tool_settings;
339 }
340 
342 {
343  MEM_freeN(tool_settings);
344 }
345 
347 {
348  const SequencerToolSettings *tool_settings = SEQ_tool_settings_ensure(scene);
349  return tool_settings->fit_method;
350 }
351 
353 {
354  const SequencerToolSettings *tool_settings = SEQ_tool_settings_ensure(scene);
355  return tool_settings->snap_mode;
356 }
357 
359 {
360  const SequencerToolSettings *tool_settings = SEQ_tool_settings_ensure(scene);
361  return tool_settings->snap_flag;
362 }
363 
365 {
366  const SequencerToolSettings *tool_settings = SEQ_tool_settings_ensure(scene);
367  return tool_settings->snap_distance;
368 }
369 
371 {
373  tool_settings->fit_method = fit_method;
374 }
375 
377 {
378  const SequencerToolSettings *tool_settings = SEQ_tool_settings_ensure(scene);
379  return tool_settings->overlap_mode;
380 }
381 
383 {
384  const SequencerToolSettings *tool_settings = SEQ_tool_settings_ensure(scene);
385  return tool_settings->pivot_point;
386 }
387 
389 {
390  if (ed == NULL) {
391  return NULL;
392  }
393 
394  return ed->seqbasep;
395 }
396 
398 {
399  ed->seqbasep = seqbase;
400 }
401 
403 {
405 
406  MetaStack *ms = MEM_mallocN(sizeof(MetaStack), "metastack");
407  BLI_addhead(&ed->metastack, ms);
408  ms->parseq = seq_meta;
409 
410  /* Reference to previously displayed timeline data. */
411  Sequence *higher_level_meta = seq_sequence_lookup_meta_by_seq(scene, seq_meta);
412  ms->oldbasep = higher_level_meta ? &higher_level_meta->seqbase : &ed->seqbase;
413  ms->old_channels = higher_level_meta ? &higher_level_meta->channels : &ed->channels;
414 
417  return ms;
418 }
419 
421 {
422  if (ed == NULL) {
423  return NULL;
424  }
425 
426  return ed->metastack.last;
427 }
428 
430 {
432  /* Clear metastack */
433  BLI_freelistN(&ed->metastack);
434 
435  if (seqm != NULL) {
436  /* Allocate meta stack in a way, that represents meta hierarchy in timeline. */
438  Sequence *meta_parent = seqm;
439  while ((meta_parent = seq_sequence_lookup_meta_by_seq(scene, meta_parent))) {
440  seq_meta_stack_alloc(scene, meta_parent);
441  }
442 
443  SEQ_seqbase_active_set(ed, &seqm->seqbase);
445  }
446  else {
447  /* Go to top level, exiting meta strip. */
450  }
451 }
452 
454 {
456  Sequence *meta_parent = ms->parseq;
459  BLI_remlink(&ed->metastack, ms);
460  MEM_freeN(ms);
461  return meta_parent;
462 }
463 
466 /* -------------------------------------------------------------------- */
470 static Sequence *seq_dupli(const Scene *scene_src,
471  Scene *scene_dst,
472  ListBase *new_seq_list,
473  Sequence *seq,
474  int dupe_flag,
475  const int flag)
476 {
477  Sequence *seqn = MEM_dupallocN(seq);
478 
479  if ((flag & LIB_ID_CREATE_NO_MAIN) == 0) {
481  }
482 
483  seq->tmp = seqn;
484  seqn->strip = MEM_dupallocN(seq->strip);
485 
487 
488  /* XXX: add F-Curve duplication stuff? */
489 
490  if (seq->strip->crop) {
491  seqn->strip->crop = MEM_dupallocN(seq->strip->crop);
492  }
493 
494  if (seq->strip->transform) {
495  seqn->strip->transform = MEM_dupallocN(seq->strip->transform);
496  }
497 
498  if (seq->strip->proxy) {
499  seqn->strip->proxy = MEM_dupallocN(seq->strip->proxy);
500  seqn->strip->proxy->anim = NULL;
501  }
502 
503  if (seq->prop) {
504  seqn->prop = IDP_CopyProperty_ex(seq->prop, flag);
505  }
506 
507  if (seqn->modifiers.first) {
509 
510  SEQ_modifier_list_copy(seqn, seq);
511  }
512 
513  if (seq->type == SEQ_TYPE_META) {
514  seqn->strip->stripdata = NULL;
515 
516  BLI_listbase_clear(&seqn->seqbase);
517  /* WARNING: This meta-strip is not recursively duplicated here - do this after! */
518  // seq_dupli_recursive(&seq->seqbase, &seqn->seqbase);
519 
522  }
523  else if (seq->type == SEQ_TYPE_SCENE) {
524  seqn->strip->stripdata = NULL;
525  if (seq->scene_sound) {
526  seqn->scene_sound = BKE_sound_scene_add_scene_sound_defaults(scene_dst, seqn);
527  }
528  }
529  else if (seq->type == SEQ_TYPE_MOVIECLIP) {
530  /* avoid assert */
531  }
532  else if (seq->type == SEQ_TYPE_MASK) {
533  /* avoid assert */
534  }
535  else if (seq->type == SEQ_TYPE_MOVIE) {
536  seqn->strip->stripdata = MEM_dupallocN(seq->strip->stripdata);
537  BLI_listbase_clear(&seqn->anims);
538  }
539  else if (seq->type == SEQ_TYPE_SOUND_RAM) {
540  seqn->strip->stripdata = MEM_dupallocN(seq->strip->stripdata);
541  seqn->scene_sound = NULL;
542  if ((flag & LIB_ID_CREATE_NO_USER_REFCOUNT) == 0) {
543  id_us_plus((ID *)seqn->sound);
544  }
545  }
546  else if (seq->type == SEQ_TYPE_IMAGE) {
547  seqn->strip->stripdata = MEM_dupallocN(seq->strip->stripdata);
548  }
549  else if (seq->type & SEQ_TYPE_EFFECT) {
550  struct SeqEffectHandle sh;
551  sh = SEQ_effect_handle_get(seq);
552  if (sh.copy) {
553  sh.copy(seqn, seq, flag);
554  }
555 
556  seqn->strip->stripdata = NULL;
557  }
558  else {
559  /* sequence type not handled in duplicate! Expect a crash now... */
561  }
562 
563  /* When using SEQ_DUPE_UNIQUE_NAME, it is mandatory to add new sequences in relevant container
564  * (scene or meta's one), *before* checking for unique names. Otherwise the meta's list is empty
565  * and hence we miss all seqs in that meta that have already been duplicated (see T55668).
566  * Note that unique name check itself could be done at a later step in calling code, once all
567  * seqs have bee duplicated (that was first, simpler solution), but then handling of animation
568  * data will be broken (see T60194). */
569  if (new_seq_list != NULL) {
570  BLI_addtail(new_seq_list, seqn);
571  }
572 
573  if (scene_src == scene_dst) {
574  if (dupe_flag & SEQ_DUPE_UNIQUE_NAME) {
575  SEQ_sequence_base_unique_name_recursive(scene_dst, &scene_dst->ed->seqbase, seqn);
576  }
577  }
578 
579  return seqn;
580 }
581 
582 static Sequence *sequence_dupli_recursive_do(const Scene *scene_src,
583  Scene *scene_dst,
584  ListBase *new_seq_list,
585  Sequence *seq,
586  const int dupe_flag)
587 {
588  Sequence *seqn;
589 
590  seq->tmp = NULL;
591  seqn = seq_dupli(scene_src, scene_dst, new_seq_list, seq, dupe_flag, 0);
592  if (seq->type == SEQ_TYPE_META) {
593  Sequence *s;
594  for (s = seq->seqbase.first; s; s = s->next) {
595  sequence_dupli_recursive_do(scene_src, scene_dst, &seqn->seqbase, s, dupe_flag);
596  }
597  }
598 
599  return seqn;
600 }
601 
603  const Scene *scene_src, Scene *scene_dst, ListBase *new_seq_list, Sequence *seq, int dupe_flag)
604 {
605  Sequence *seqn = sequence_dupli_recursive_do(scene_src, scene_dst, new_seq_list, seq, dupe_flag);
606 
607  /* This does not need to be in recursive call itself, since it is already recursive... */
609 
610  return seqn;
611 }
612 
614  Scene *scene_dst,
615  ListBase *nseqbase,
616  const ListBase *seqbase,
617  int dupe_flag,
618  const int flag)
619 {
620  Sequence *seq;
621  Sequence *seqn = NULL;
622 
623  for (seq = seqbase->first; seq; seq = seq->next) {
624  seq->tmp = NULL;
625  if ((seq->flag & SELECT) || (dupe_flag & SEQ_DUPE_ALL)) {
626  seqn = seq_dupli(scene_src, scene_dst, nseqbase, seq, dupe_flag, flag);
627 
628  if (seqn == NULL) {
629  continue; /* Should never fail. */
630  }
631 
632  if (seq->type == SEQ_TYPE_META) {
633  /* Always include meta all strip children. */
634  int dupe_flag_recursive = dupe_flag | SEQ_DUPE_ALL | SEQ_DUPE_IS_RECURSIVE_CALL;
636  scene_src, scene_dst, &seqn->seqbase, &seq->seqbase, dupe_flag_recursive, flag);
637  }
638  }
639  }
640 
641  /* Fix modifier links recursively from the top level only, when all sequences have been
642  * copied. */
643  if (dupe_flag & SEQ_DUPE_IS_RECURSIVE_CALL) {
644  return;
645  }
646 
647  /* fix modifier linking */
648  for (seq = nseqbase->first; seq; seq = seq->next) {
650  }
651 }
652 
654 {
655  if (seq->machine < 1) {
656  return false;
657  }
658  if (seq->machine > MAXSEQ) {
659  return false;
660  }
661  return true;
662 }
663 
665 {
666  SequencerToolSettings *tool_settings_copy = MEM_dupallocN(tool_settings);
667  return tool_settings_copy;
668 }
669 
672 static bool seq_set_strip_done_cb(Sequence *seq, void *UNUSED(userdata))
673 {
674  if (seq->strip) {
675  seq->strip->done = false;
676  }
677  return true;
678 }
679 
680 static bool seq_write_data_cb(Sequence *seq, void *userdata)
681 {
682  BlendWriter *writer = (BlendWriter *)userdata;
683  BLO_write_struct(writer, Sequence, seq);
684  if (seq->strip && seq->strip->done == 0) {
685  /* Write strip with 'done' at 0 because read-file. */
686 
687  /* TODO this doesn't depend on the `Strip` data to be present? */
688  if (seq->effectdata) {
689  switch (seq->type) {
690  case SEQ_TYPE_COLOR:
692  break;
693  case SEQ_TYPE_SPEED:
695  break;
696  case SEQ_TYPE_WIPE:
697  BLO_write_struct(writer, WipeVars, seq->effectdata);
698  break;
699  case SEQ_TYPE_GLOW:
700  BLO_write_struct(writer, GlowVars, seq->effectdata);
701  break;
702  case SEQ_TYPE_TRANSFORM:
704  break;
707  break;
708  case SEQ_TYPE_TEXT:
709  BLO_write_struct(writer, TextVars, seq->effectdata);
710  break;
711  case SEQ_TYPE_COLORMIX:
713  break;
714  }
715  }
716 
718 
719  Strip *strip = seq->strip;
720  BLO_write_struct(writer, Strip, strip);
721  if (strip->crop) {
722  BLO_write_struct(writer, StripCrop, strip->crop);
723  }
724  if (strip->transform) {
725  BLO_write_struct(writer, StripTransform, strip->transform);
726  }
727  if (strip->proxy) {
728  BLO_write_struct(writer, StripProxy, strip->proxy);
729  }
730  if (seq->type == SEQ_TYPE_IMAGE) {
731  BLO_write_struct_array(writer,
732  StripElem,
733  MEM_allocN_len(strip->stripdata) / sizeof(struct StripElem),
734  strip->stripdata);
735  }
737  BLO_write_struct(writer, StripElem, strip->stripdata);
738  }
739 
740  strip->done = true;
741  }
742 
743  if (seq->prop) {
744  IDP_BlendWrite(writer, seq->prop);
745  }
746 
747  SEQ_modifier_blend_write(writer, &seq->modifiers);
748 
749  LISTBASE_FOREACH (SeqTimelineChannel *, channel, &seq->channels) {
750  BLO_write_struct(writer, SeqTimelineChannel, channel);
751  }
752  return true;
753 }
754 
755 void SEQ_blend_write(BlendWriter *writer, ListBase *seqbase)
756 {
757  /* reset write flags */
759 
760  SEQ_for_each_callback(seqbase, seq_write_data_cb, writer);
761 }
762 
763 static bool seq_read_data_cb(Sequence *seq, void *user_data)
764 {
766 
767  /* Do as early as possible, so that other parts of reading can rely on valid session UUID. */
769 
770  BLO_read_data_address(reader, &seq->seq1);
771  BLO_read_data_address(reader, &seq->seq2);
772  BLO_read_data_address(reader, &seq->seq3);
773 
774  /* a patch: after introduction of effects with 3 input strips */
775  if (seq->seq3 == NULL) {
776  seq->seq3 = seq->seq2;
777  }
778 
779  BLO_read_data_address(reader, &seq->effectdata);
780  BLO_read_data_address(reader, &seq->stereo3d_format);
781 
782  if (seq->type & SEQ_TYPE_EFFECT) {
783  seq->flag |= SEQ_EFFECT_NOT_LOADED;
784  }
785 
786  if (seq->type == SEQ_TYPE_TEXT) {
787  TextVars *t = seq->effectdata;
788  t->text_blf_id = SEQ_FONT_NOT_LOADED;
789  }
790 
791  BLO_read_data_address(reader, &seq->prop);
792  IDP_BlendDataRead(reader, &seq->prop);
793 
794  BLO_read_data_address(reader, &seq->strip);
795  if (seq->strip && seq->strip->done == 0) {
796  seq->strip->done = true;
797 
799  BLO_read_data_address(reader, &seq->strip->stripdata);
800  }
801  else {
802  seq->strip->stripdata = NULL;
803  }
804  BLO_read_data_address(reader, &seq->strip->crop);
805  BLO_read_data_address(reader, &seq->strip->transform);
806  BLO_read_data_address(reader, &seq->strip->proxy);
807  if (seq->strip->proxy) {
808  seq->strip->proxy->anim = NULL;
809  }
810  else if (seq->flag & SEQ_USE_PROXY) {
811  SEQ_proxy_set(seq, true);
812  }
813 
814  /* need to load color balance to it could be converted to modifier */
815  BLO_read_data_address(reader, &seq->strip->color_balance);
816  }
817 
819 
820  BLO_read_list(reader, &seq->channels);
821  return true;
822 }
823 void SEQ_blend_read(BlendDataReader *reader, ListBase *seqbase)
824 {
825  SEQ_for_each_callback(seqbase, seq_read_data_cb, reader);
826 }
827 
828 typedef struct Read_lib_data {
832 
833 static bool seq_read_lib_cb(Sequence *seq, void *user_data)
834 {
836  BlendLibReader *reader = data->reader;
837  Scene *sce = data->scene;
838 
839  IDP_BlendReadLib(reader, sce->id.lib, seq->prop);
840 
841  if (seq->ipo) {
842  /* XXX: deprecated - old animation system. */
843  BLO_read_id_address(reader, sce->id.lib, &seq->ipo);
844  }
845  seq->scene_sound = NULL;
846  if (seq->scene) {
847  BLO_read_id_address(reader, sce->id.lib, &seq->scene);
848  seq->scene_sound = NULL;
849  }
850  if (seq->clip) {
851  BLO_read_id_address(reader, sce->id.lib, &seq->clip);
852  }
853  if (seq->mask) {
854  BLO_read_id_address(reader, sce->id.lib, &seq->mask);
855  }
856  if (seq->scene_camera) {
857  BLO_read_id_address(reader, sce->id.lib, &seq->scene_camera);
858  }
859  if (seq->sound) {
860  seq->scene_sound = NULL;
861  if (seq->type == SEQ_TYPE_SOUND_HD) {
862  seq->type = SEQ_TYPE_SOUND_RAM;
863  }
864  else {
865  BLO_read_id_address(reader, sce->id.lib, &seq->sound);
866  }
867  if (seq->sound) {
868  id_us_plus_no_lib((ID *)seq->sound);
869  seq->scene_sound = NULL;
870  }
871  }
872  if (seq->type == SEQ_TYPE_TEXT) {
873  TextVars *t = seq->effectdata;
874  BLO_read_id_address(reader, sce->id.lib, &t->text_font);
875  }
876  BLI_listbase_clear(&seq->anims);
877 
878  SEQ_modifier_blend_read_lib(reader, sce, &seq->modifiers);
879 
881  return true;
882 }
883 
885 {
886  Read_lib_data data = {reader, scene};
888 }
889 
890 static bool seq_blend_read_expand(Sequence *seq, void *user_data)
891 {
892  BlendExpander *expander = (BlendExpander *)user_data;
893 
894  IDP_BlendReadExpand(expander, seq->prop);
895 
896  if (seq->scene) {
897  BLO_expand(expander, seq->scene);
898  }
899  if (seq->scene_camera) {
900  BLO_expand(expander, seq->scene_camera);
901  }
902  if (seq->clip) {
903  BLO_expand(expander, seq->clip);
904  }
905  if (seq->mask) {
906  BLO_expand(expander, seq->mask);
907  }
908  if (seq->sound) {
909  BLO_expand(expander, seq->sound);
910  }
911 
912  if (seq->type == SEQ_TYPE_TEXT && seq->effectdata) {
913  TextVars *data = seq->effectdata;
914  BLO_expand(expander, data->text_font);
915  }
916  return true;
917 }
918 
920 {
921  SEQ_for_each_callback(seqbase, seq_blend_read_expand, expander);
922 }
923 
924 /* Depsgraph update functions. */
925 
927 {
928  Scene *scene = (Scene *)user_data;
929  if (seq->scene_sound != NULL) {
931  seq->scene_sound = NULL;
932  }
933  return true;
934 }
935 
936 static bool seq_update_seq_cb(Sequence *seq, void *user_data)
937 {
938  Scene *scene = (Scene *)user_data;
939  if (seq->scene_sound == NULL) {
940  if (seq->sound != NULL) {
942  }
943  else if (seq->type == SEQ_TYPE_SCENE) {
944  if (seq->scene != NULL) {
947  }
948  }
949  }
950  if (seq->scene_sound != NULL) {
951  /* Make sure changing volume via sequence's properties panel works correct.
952  *
953  * Ideally, the entire BKE_scene_update_sound() will happen from a dependency graph, so
954  * then it is no longer needed to do such manual forced updates. */
955  if (seq->type == SEQ_TYPE_SCENE && seq->scene != NULL) {
957  if ((seq->flag & SEQ_SCENE_STRIPS) == 0 && seq->scene->sound_scene != NULL &&
958  seq->scene->ed != NULL) {
960  }
961  }
962  if (seq->sound != NULL) {
965  }
966  }
968  seq->scene_sound, seq->volume, (seq->flag & SEQ_AUDIO_VOLUME_ANIMATED) != 0);
971  (seq->flag & SEQ_AUDIO_PITCH_ANIMATED) != 0);
973  seq->scene_sound, seq->pan, (seq->flag & SEQ_AUDIO_PAN_ANIMATED) != 0);
974  }
975  return true;
976 }
977 
979 {
982 
984 
987 }
void IDP_BlendReadExpand(struct BlendExpander *expander, struct IDProperty *prop)
Definition: idprop.c:1471
struct IDProperty * IDP_CopyProperty_ex(const struct IDProperty *prop, int flag) ATTR_WARN_UNUSED_RESULT ATTR_NONNULL()
void IDP_BlendWrite(struct BlendWriter *writer, const struct IDProperty *prop)
#define IDP_BlendDataRead(reader, prop)
Definition: BKE_idprop.h:321
void IDP_FreePropertyContent_ex(struct IDProperty *prop, bool do_id_user)
Definition: idprop.c:1055
void IDP_BlendReadLib(struct BlendLibReader *reader, struct Library *lib, struct IDProperty *prop)
Definition: idprop.c:1435
@ LIB_ID_CREATE_NO_USER_REFCOUNT
Definition: BKE_lib_id.h:126
@ LIB_ID_CREATE_NO_MAIN
Definition: BKE_lib_id.h:122
void id_us_min(struct ID *id)
Definition: lib_id.c:313
void id_us_plus(struct ID *id)
Definition: lib_id.c:305
void id_us_plus_no_lib(struct ID *id)
Definition: lib_id.c:289
void BKE_sound_set_scene_sound_pitch(void *handle, float pitch, char animated)
void BKE_sound_set_scene_sound_volume(void *handle, float volume, char animated)
void BKE_sound_set_scene_volume(struct Scene *scene, float volume)
void BKE_sound_ensure_scene(struct Scene *scene)
void BKE_sound_update_scene_sound(void *handle, struct bSound *sound)
void * BKE_sound_add_scene_sound_defaults(struct Scene *scene, struct Sequence *sequence)
void BKE_sound_set_scene_sound_pan(void *handle, float pan, char animated)
void BKE_sound_remove_scene_sound(struct Scene *scene, void *handle)
void * BKE_sound_scene_add_scene_sound_defaults(struct Scene *scene, struct Sequence *sequence)
#define BLI_assert_unreachable()
Definition: BLI_assert.h:93
void BLI_addhead(struct ListBase *listbase, void *vlink) ATTR_NONNULL(1)
Definition: listbase.c:60
#define LISTBASE_FOREACH(type, var, list)
Definition: BLI_listbase.h:336
#define LISTBASE_FOREACH_MUTABLE(type, var, list)
Definition: BLI_listbase.h:354
BLI_INLINE void BLI_listbase_clear(struct ListBase *lb)
Definition: BLI_listbase.h:273
void void BLI_freelistN(struct ListBase *listbase) ATTR_NONNULL(1)
Definition: listbase.c:466
void BLI_addtail(struct ListBase *listbase, void *vlink) ATTR_NONNULL(1)
Definition: listbase.c:80
void BLI_remlink(struct ListBase *listbase, void *vlink) ATTR_NONNULL(1)
Definition: listbase.c:100
#define UNUSED(x)
#define ELEM(...)
#define BLO_read_data_address(reader, ptr_p)
#define BLO_write_struct(writer, struct_name, data_ptr)
void BLO_read_list(BlendDataReader *reader, struct ListBase *list)
Definition: readfile.c:5172
#define BLO_read_id_address(reader, lib, id_ptr_p)
#define BLO_write_struct_array(writer, struct_name, array_size, data_ptr)
#define BLO_expand(expander, id)
struct Depsgraph Depsgraph
Definition: DEG_depsgraph.h:35
void DEG_debug_print_eval(struct Depsgraph *depsgraph, const char *function_name, const char *object_name, const void *object_address)
@ ID_RECALC_AUDIO
Definition: DNA_ID.h:848
#define ID_SEQ
Definition: DNA_ID_enums.h:94
#define SEQ_SNAP_TO_STRIPS
#define SEQ_SNAP_TO_STRIP_HOLD
eSeqOverlapMode
@ SEQ_OVERLAP_SHUFFLE
#define SEQ_SNAP_TO_CURRENT_FRAME
eSeqImageFitMethod
@ SEQ_SCALE_TO_FIT
@ SEQ_TYPE_TRANSFORM
@ SEQ_TYPE_SOUND_RAM
@ SEQ_TYPE_CROSS
@ SEQ_TYPE_SOUND_HD
@ SEQ_TYPE_GLOW
@ SEQ_TYPE_COLORMIX
@ SEQ_TYPE_WIPE
@ SEQ_TYPE_META
@ SEQ_TYPE_SCENE
@ SEQ_TYPE_MOVIECLIP
@ SEQ_TYPE_GAUSSIAN_BLUR
@ SEQ_TYPE_ALPHAOVER
@ SEQ_TYPE_TEXT
@ SEQ_TYPE_IMAGE
@ SEQ_TYPE_SPEED
@ SEQ_TYPE_COLOR
@ SEQ_TYPE_EFFECT
@ SEQ_TYPE_MOVIE
@ SEQ_TYPE_MASK
@ SEQ_TYPE_ADJUSTMENT
#define SEQ_FONT_NOT_LOADED
@ SEQUENCE_COLOR_NONE
@ SEQ_CACHE_STORE_RAW
@ SEQ_CACHE_STORE_FINAL_OUT
#define SEQ_PROXY_TC_ALL
@ SEQ_FLAG_SKIP_THUMBNAILS
@ SEQ_EFFECT_NOT_LOADED
@ SEQ_SCENE_STRIPS
@ SEQ_AUDIO_PITCH_ANIMATED
@ SEQ_USE_PROXY
@ SEQ_AUDIO_VOLUME_ANIMATED
@ SEQ_AUDIO_PAN_ANIMATED
#define MAXSEQ
@ SEQ_TRANSFORM_FILTER_BILINEAR
#define SEQ_PROXY_TC_RECORD_RUN
@ V3D_AROUND_LOCAL_ORIGINS
_GL_VOID GLfloat value _GL_VOID_RET _GL_VOID const GLuint GLboolean *residences _GL_BOOL_RET _GL_VOID GLsizei GLfloat GLfloat GLfloat GLfloat const GLubyte *bitmap _GL_VOID_RET _GL_VOID GLenum type
_GL_VOID GLfloat value _GL_VOID_RET _GL_VOID const GLuint GLboolean *residences _GL_BOOL_RET _GL_VOID GLsizei GLfloat GLfloat GLfloat GLfloat const GLubyte *bitmap _GL_VOID_RET _GL_VOID GLenum const void *lists _GL_VOID_RET _GL_VOID const GLdouble *equation _GL_VOID_RET _GL_VOID GLdouble GLdouble blue _GL_VOID_RET _GL_VOID GLfloat GLfloat blue _GL_VOID_RET _GL_VOID GLint GLint blue _GL_VOID_RET _GL_VOID GLshort GLshort blue _GL_VOID_RET _GL_VOID GLubyte GLubyte blue _GL_VOID_RET _GL_VOID GLuint GLuint blue _GL_VOID_RET _GL_VOID GLushort GLushort blue _GL_VOID_RET _GL_VOID GLbyte GLbyte GLbyte alpha _GL_VOID_RET _GL_VOID GLdouble GLdouble GLdouble alpha _GL_VOID_RET _GL_VOID GLfloat GLfloat GLfloat alpha _GL_VOID_RET _GL_VOID GLint GLint GLint alpha _GL_VOID_RET _GL_VOID GLshort GLshort GLshort alpha _GL_VOID_RET _GL_VOID GLubyte GLubyte GLubyte alpha _GL_VOID_RET _GL_VOID GLuint GLuint GLuint alpha _GL_VOID_RET _GL_VOID GLushort GLushort GLushort alpha _GL_VOID_RET _GL_VOID GLenum mode _GL_VOID_RET _GL_VOID GLint GLsizei GLsizei GLenum type _GL_VOID_RET _GL_VOID GLsizei GLenum GLenum const void *pixels _GL_VOID_RET _GL_VOID const void *pointer _GL_VOID_RET _GL_VOID GLdouble v _GL_VOID_RET _GL_VOID GLfloat v _GL_VOID_RET _GL_VOID GLint GLint i2 _GL_VOID_RET _GL_VOID GLint j _GL_VOID_RET _GL_VOID GLfloat param _GL_VOID_RET _GL_VOID GLint param _GL_VOID_RET _GL_VOID GLdouble GLdouble GLdouble GLdouble GLdouble zFar _GL_VOID_RET _GL_UINT GLdouble *equation _GL_VOID_RET _GL_VOID GLenum GLint *params _GL_VOID_RET _GL_VOID GLenum GLfloat *v _GL_VOID_RET _GL_VOID GLenum GLfloat *params _GL_VOID_RET _GL_VOID GLfloat *values _GL_VOID_RET _GL_VOID GLushort *values _GL_VOID_RET _GL_VOID GLenum GLfloat *params _GL_VOID_RET _GL_VOID GLenum GLdouble *params _GL_VOID_RET _GL_VOID GLenum GLint *params _GL_VOID_RET _GL_VOID GLsizei const void *pointer _GL_VOID_RET _GL_VOID GLsizei const void *pointer _GL_VOID_RET _GL_BOOL GLfloat param _GL_VOID_RET _GL_VOID GLint param _GL_VOID_RET _GL_VOID GLenum GLfloat param _GL_VOID_RET _GL_VOID GLenum GLint param _GL_VOID_RET _GL_VOID GLushort pattern _GL_VOID_RET _GL_VOID GLdouble GLdouble GLint GLint const GLdouble *points _GL_VOID_RET _GL_VOID GLdouble GLdouble GLint GLint GLdouble GLdouble GLint GLint const GLdouble *points _GL_VOID_RET _GL_VOID GLdouble GLdouble u2 _GL_VOID_RET _GL_VOID GLdouble GLdouble GLint GLdouble GLdouble v2 _GL_VOID_RET _GL_VOID GLenum GLfloat param _GL_VOID_RET _GL_VOID GLenum GLint param _GL_VOID_RET _GL_VOID GLenum mode _GL_VOID_RET _GL_VOID GLdouble GLdouble nz _GL_VOID_RET _GL_VOID GLfloat GLfloat nz _GL_VOID_RET _GL_VOID GLint GLint nz _GL_VOID_RET _GL_VOID GLshort GLshort nz _GL_VOID_RET _GL_VOID GLsizei const void *pointer _GL_VOID_RET _GL_VOID GLsizei const GLfloat *values _GL_VOID_RET _GL_VOID GLsizei const GLushort *values _GL_VOID_RET _GL_VOID GLint param _GL_VOID_RET _GL_VOID const GLuint const GLclampf *priorities _GL_VOID_RET _GL_VOID GLdouble y _GL_VOID_RET _GL_VOID GLfloat y _GL_VOID_RET _GL_VOID GLint y _GL_VOID_RET _GL_VOID GLshort y _GL_VOID_RET _GL_VOID GLdouble GLdouble z _GL_VOID_RET _GL_VOID GLfloat GLfloat z _GL_VOID_RET _GL_VOID GLint GLint z _GL_VOID_RET _GL_VOID GLshort GLshort z _GL_VOID_RET _GL_VOID GLdouble GLdouble GLdouble w _GL_VOID_RET _GL_VOID GLfloat GLfloat GLfloat w _GL_VOID_RET _GL_VOID GLint GLint GLint w _GL_VOID_RET _GL_VOID GLshort GLshort GLshort w _GL_VOID_RET _GL_VOID GLdouble GLdouble GLdouble y2 _GL_VOID_RET _GL_VOID GLfloat GLfloat GLfloat y2 _GL_VOID_RET _GL_VOID GLint GLint GLint y2 _GL_VOID_RET _GL_VOID GLshort GLshort GLshort y2 _GL_VOID_RET _GL_VOID GLdouble GLdouble GLdouble z _GL_VOID_RET _GL_VOID GLdouble GLdouble z _GL_VOID_RET _GL_VOID GLuint *buffer _GL_VOID_RET _GL_VOID GLdouble t _GL_VOID_RET _GL_VOID GLfloat t _GL_VOID_RET _GL_VOID GLint t _GL_VOID_RET _GL_VOID GLshort t _GL_VOID_RET _GL_VOID GLdouble t
void IMB_free_anim(struct anim *anim)
Definition: anim_movie.c:193
Read Guarded memory(de)allocation.
#define SEQ_DUPE_UNIQUE_NAME
Definition: SEQ_sequencer.h:38
#define SEQ_DUPE_ALL
Definition: SEQ_sequencer.h:39
#define SEQ_DUPE_IS_RECURSIVE_CALL
Definition: SEQ_sequencer.h:40
void SEQ_channels_duplicate(ListBase *channels_dst, ListBase *channels_src)
Definition: channels.c:44
void SEQ_channels_free(ListBase *channels)
Definition: channels.c:52
void SEQ_channels_ensure(ListBase *channels)
Definition: channels.c:33
void SEQ_channels_displayed_set(Editing *ed, ListBase *channels)
Definition: channels.c:28
#define SELECT
Scene scene
const Depsgraph * depsgraph
void * user_data
struct SeqEffectHandle SEQ_effect_handle_get(Sequence *seq)
Definition: effects.c:3704
void seq_cache_destruct(Scene *scene)
Definition: image_cache.c:576
void SEQ_for_each_callback(ListBase *seqbase, SeqForEachFunc callback, void *user_data)
Definition: iterator.c:76
ccl_gpu_kernel_postfix ccl_global float int int int int sh
void(* MEM_freeN)(void *vmemh)
Definition: mallocn.c:27
void *(* MEM_dupallocN)(const void *vmemh)
Definition: mallocn.c:28
size_t(* MEM_allocN_len)(const void *vmemh)
Definition: mallocn.c:26
void *(* MEM_callocN)(size_t len, const char *str)
Definition: mallocn.c:31
void *(* MEM_mallocN)(size_t len, const char *str)
Definition: mallocn.c:33
void seq_prefetch_free(Scene *scene)
Definition: prefetch.c:339
void SEQ_proxy_set(struct Sequence *seq, bool value)
Definition: proxy.c:571
void SEQ_sequence_lookup_free(const Scene *scene)
Sequence * seq_sequence_lookup_meta_by_seq(const Scene *scene, const Sequence *key)
void SEQ_modifier_blend_write(BlendWriter *writer, ListBase *modbase)
void SEQ_modifier_blend_read_lib(BlendLibReader *reader, Scene *scene, ListBase *lb)
void SEQ_modifier_clear(Sequence *seq)
void SEQ_modifier_blend_read_data(BlendDataReader *reader, ListBase *lb)
void SEQ_modifier_list_copy(Sequence *seqn, Sequence *seq)
void SEQ_sound_update_bounds_all(Scene *scene)
float SEQ_sound_pitch_get(const Scene *scene, const Sequence *seq)
void SEQ_tool_settings_free(SequencerToolSettings *tool_settings)
Definition: sequencer.c:341
void SEQ_sequence_base_dupli_recursive(const Scene *scene_src, Scene *scene_dst, ListBase *nseqbase, const ListBase *seqbase, int dupe_flag, const int flag)
Definition: sequencer.c:613
static void seq_new_fix_links_recursive(Sequence *seq)
Definition: sequencer.c:287
static bool seq_update_seq_cb(Sequence *seq, void *user_data)
Definition: sequencer.c:936
void SEQ_sequence_free(Scene *scene, Sequence *seq)
Definition: sequencer.c:224
ListBase * SEQ_active_seqbase_get(const Editing *ed)
Definition: sequencer.c:388
static bool seq_set_strip_done_cb(Sequence *seq, void *UNUSED(userdata))
Definition: sequencer.c:672
static bool seq_read_data_cb(Sequence *seq, void *user_data)
Definition: sequencer.c:763
StripProxy * seq_strip_proxy_alloc(void)
Definition: sequencer.c:54
void SEQ_blend_read_expand(BlendExpander *expander, ListBase *seqbase)
Definition: sequencer.c:919
struct Read_lib_data Read_lib_data
SequencerToolSettings * SEQ_tool_settings_init(void)
Definition: sequencer.c:316
short SEQ_tool_settings_snap_mode_get(Scene *scene)
Definition: sequencer.c:352
Sequence * SEQ_sequence_dupli_recursive(const Scene *scene_src, Scene *scene_dst, ListBase *new_seq_list, Sequence *seq, int dupe_flag)
Definition: sequencer.c:602
int SEQ_tool_settings_snap_distance_get(Scene *scene)
Definition: sequencer.c:364
MetaStack * SEQ_meta_stack_active_get(const Editing *ed)
Definition: sequencer.c:420
static void seq_sequence_free_ex(Scene *scene, Sequence *seq, const bool do_cache, const bool do_id_user)
Definition: sequencer.c:157
void SEQ_blend_read_lib(BlendLibReader *reader, Scene *scene, ListBase *seqbase)
Definition: sequencer.c:884
void SEQ_editing_free(Scene *scene, const bool do_id_user)
Definition: sequencer.c:263
static Strip * seq_strip_alloc(int type)
Definition: sequencer.c:63
SequencerToolSettings * SEQ_tool_settings_copy(SequencerToolSettings *tool_settings)
Definition: sequencer.c:664
short SEQ_tool_settings_snap_flag_get(Scene *scene)
Definition: sequencer.c:358
Editing * SEQ_editing_ensure(Scene *scene)
Definition: sequencer.c:246
void SEQ_eval_sequences(Depsgraph *depsgraph, Scene *scene, ListBase *seqbase)
Definition: sequencer.c:978
void SEQ_seqbase_active_set(Editing *ed, ListBase *seqbase)
Definition: sequencer.c:397
void seq_free_sequence_recurse(Scene *scene, Sequence *seq, const bool do_id_user)
Definition: sequencer.c:229
void SEQ_blend_read(BlendDataReader *reader, ListBase *seqbase)
Definition: sequencer.c:823
static MetaStack * seq_meta_stack_alloc(const Scene *scene, Sequence *seq_meta)
Definition: sequencer.c:402
eSeqOverlapMode SEQ_tool_settings_overlap_mode_get(Scene *scene)
Definition: sequencer.c:376
static bool seq_blend_read_expand(Sequence *seq, void *user_data)
Definition: sequencer.c:890
void SEQ_meta_stack_set(const Scene *scene, Sequence *seqm)
Definition: sequencer.c:429
int SEQ_tool_settings_pivot_point_get(Scene *scene)
Definition: sequencer.c:382
static bool seq_write_data_cb(Sequence *seq, void *userdata)
Definition: sequencer.c:680
static void seq_free_strip(Strip *strip)
Definition: sequencer.c:81
Sequence * SEQ_sequence_alloc(ListBase *lb, int timeline_frame, int machine, int type)
Definition: sequencer.c:113
Editing * SEQ_editing_get(const Scene *scene)
Definition: sequencer.c:241
eSeqImageFitMethod SEQ_tool_settings_fit_method_get(Scene *scene)
Definition: sequencer.c:346
static bool seq_read_lib_cb(Sequence *seq, void *user_data)
Definition: sequencer.c:833
static Sequence * seq_dupli(const Scene *scene_src, Scene *scene_dst, ListBase *new_seq_list, Sequence *seq, int dupe_flag, const int flag)
Definition: sequencer.c:470
static bool seq_disable_sound_strips_cb(Sequence *seq, void *user_data)
Definition: sequencer.c:926
Sequence * SEQ_meta_stack_pop(Editing *ed)
Definition: sequencer.c:453
void SEQ_tool_settings_fit_method_set(Scene *scene, eSeqImageFitMethod fit_method)
Definition: sequencer.c:370
SequencerToolSettings * SEQ_tool_settings_ensure(Scene *scene)
Definition: sequencer.c:330
bool SEQ_valid_strip_channel(Sequence *seq)
Definition: sequencer.c:653
static Sequence * sequence_dupli_recursive_do(const Scene *scene_src, Scene *scene_dst, ListBase *new_seq_list, Sequence *seq, const int dupe_flag)
Definition: sequencer.c:582
void SEQ_blend_write(BlendWriter *writer, ListBase *seqbase)
Definition: sequencer.c:755
void SEQ_edit_update_muting(Editing *ed)
Definition: strip_edit.c:123
void SEQ_relations_invalidate_cache_raw(Scene *scene, Sequence *seq)
void SEQ_relations_sequence_free_anim(Sequence *seq)
void SEQ_relations_session_uuid_generate(struct Sequence *sequence)
int SEQ_time_left_handle_frame_get(const Scene *UNUSED(scene), const Sequence *seq)
Definition: strip_time.c:506
int SEQ_time_right_handle_frame_get(const Scene *scene, const Sequence *seq)
Definition: strip_time.c:515
ListBase seqbase
ListBase * seqbasep
Sequence * act_seq
ListBase channels
ListBase * displayed_channels
ListBase metastack
struct SeqCache * cache
Definition: DNA_ID.h:368
struct Library * lib
Definition: DNA_ID.h:372
int recalc
Definition: DNA_ID.h:390
char name[66]
Definition: DNA_ID.h:378
void * last
Definition: DNA_listBase.h:31
void * first
Definition: DNA_listBase.h:31
Sequence * parseq
ListBase * old_channels
ListBase * oldbasep
Scene * scene
Definition: sequencer.c:830
BlendLibReader * reader
Definition: sequencer.c:829
void * sound_scene
struct ToolSettings * toolsettings
struct Editing * ed
struct AudioData audio
struct SequenceModifierData * next
struct Sequence * mask_sequence
float media_playback_rate
struct MovieClip * clip
struct Scene * scene
ListBase anims
struct Object * scene_camera
struct Sequence * seq3
void * scene_sound
struct Mask * mask
ListBase channels
ListBase modifiers
ListBase seqbase
struct bSound * sound
struct Sequence * seq1
struct Sequence * seq2
struct Sequence * next
float pitch pan
struct IDProperty * prop
struct Stereo3dFormat * stereo3d_format
struct anim * anim
StripProxy * proxy
StripTransform * transform
StripElem * stripdata
StripCrop * crop
struct SequencerToolSettings * sequencer_tool_settings
void SEQ_sequence_base_unique_name_recursive(struct Scene *scene, ListBase *seqbasep, Sequence *seq)
Definition: utils.c:78