Sequencer: Fix missing sound from nested scene strips
[blender.git] / source / blender / makesrna / intern / rna_sequencer.c
1 /*
2  * This program is free software; you can redistribute it and/or
3  * modify it under the terms of the GNU General Public License
4  * as published by the Free Software Foundation; either version 2
5  * of the License, or (at your option) any later version.
6  *
7  * This program is distributed in the hope that it will be useful,
8  * but WITHOUT ANY WARRANTY; without even the implied warranty of
9  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
10  * GNU General Public License for more details.
11  *
12  * You should have received a copy of the GNU General Public License
13  * along with this program; if not, write to the Free Software Foundation,
14  * Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
15  */
16
17 /** \file
18  * \ingroup RNA
19  */
20
21 #include <stdlib.h>
22 #include <limits.h>
23
24 #include "DNA_anim_types.h"
25 #include "DNA_object_types.h"
26 #include "DNA_scene_types.h"
27 #include "DNA_sequence_types.h"
28 #include "DNA_movieclip_types.h"
29 #include "DNA_vfont_types.h"
30
31 #include "BLI_math.h"
32
33 #include "BLT_translation.h"
34
35 #include "BKE_animsys.h"
36 #include "BKE_sequencer.h"
37 #include "BKE_sound.h"
38
39 #include "IMB_metadata.h"
40
41 #include "MEM_guardedalloc.h"
42
43 #include "RNA_access.h"
44 #include "RNA_define.h"
45 #include "RNA_enum_types.h"
46
47 #include "rna_internal.h"
48
49 #include "WM_types.h"
50
51 typedef struct EffectInfo {
52   const char *struct_name;
53   const char *ui_name;
54   const char *ui_desc;
55   void (*func)(StructRNA *);
56   int inputs;
57 } EffectInfo;
58
59 const EnumPropertyItem rna_enum_sequence_modifier_type_items[] = {
60     {seqModifierType_ColorBalance, "COLOR_BALANCE", ICON_NONE, "Color Balance", ""},
61     {seqModifierType_Curves, "CURVES", ICON_NONE, "Curves", ""},
62     {seqModifierType_HueCorrect, "HUE_CORRECT", ICON_NONE, "Hue Correct", ""},
63     {seqModifierType_BrightContrast, "BRIGHT_CONTRAST", ICON_NONE, "Bright/Contrast", ""},
64     {seqModifierType_Mask, "MASK", ICON_NONE, "Mask", ""},
65     {seqModifierType_WhiteBalance, "WHITE_BALANCE", ICON_NONE, "White Balance", ""},
66     {seqModifierType_Tonemap, "TONEMAP", ICON_NONE, "Tone Map", ""},
67     {0, NULL, 0, NULL, NULL},
68 };
69
70 #ifdef RNA_RUNTIME
71
72 #  include "BKE_report.h"
73 #  include "BKE_idprop.h"
74 #  include "BKE_movieclip.h"
75
76 #  include "WM_api.h"
77
78 #  include "DEG_depsgraph.h"
79 #  include "DEG_depsgraph_build.h"
80
81 #  include "IMB_imbuf.h"
82
83 typedef struct SequenceSearchData {
84   Sequence *seq;
85   void *data;
86   SequenceModifierData *smd;
87 } SequenceSearchData;
88
89 /* build a temp reference to the parent */
90 static void meta_tmp_ref(Sequence *seq_par, Sequence *seq)
91 {
92   for (; seq; seq = seq->next) {
93     seq->tmp = seq_par;
94     if (seq->type == SEQ_TYPE_META) {
95       meta_tmp_ref(seq, seq->seqbase.first);
96     }
97   }
98 }
99
100 static void rna_SequenceElement_update(Main *UNUSED(bmain), Scene *UNUSED(scene), PointerRNA *ptr)
101 {
102   Scene *scene = (Scene *)ptr->id.data;
103   Editing *ed = BKE_sequencer_editing_get(scene, false);
104
105   if (ed) {
106     StripElem *se = (StripElem *)ptr->data;
107     Sequence *seq;
108
109     /* slow but we can't avoid! */
110     seq = BKE_sequencer_from_elem(&ed->seqbase, se);
111     if (seq) {
112       BKE_sequence_invalidate_cache_raw(scene, seq);
113     }
114   }
115 }
116
117 static void rna_Sequence_invalidate_raw_update(Main *UNUSED(bmain),
118                                                Scene *UNUSED(scene),
119                                                PointerRNA *ptr)
120 {
121   Scene *scene = (Scene *)ptr->id.data;
122   Editing *ed = BKE_sequencer_editing_get(scene, false);
123
124   if (ed) {
125     Sequence *seq = (Sequence *)ptr->data;
126
127     BKE_sequence_invalidate_cache_raw(scene, seq);
128   }
129 }
130
131 static void rna_Sequence_invalidate_preprocessed_update(Main *UNUSED(bmain),
132                                                         Scene *UNUSED(scene),
133                                                         PointerRNA *ptr)
134 {
135   Scene *scene = (Scene *)ptr->id.data;
136   Editing *ed = BKE_sequencer_editing_get(scene, false);
137
138   if (ed) {
139     Sequence *seq = (Sequence *)ptr->data;
140
141     BKE_sequence_invalidate_cache_preprocessed(scene, seq);
142   }
143 }
144
145 static void rna_Sequence_invalidate_composite_update(Main *UNUSED(bmain),
146                                                      Scene *UNUSED(scene),
147                                                      PointerRNA *ptr)
148 {
149   Scene *scene = (Scene *)ptr->id.data;
150   Editing *ed = BKE_sequencer_editing_get(scene, false);
151
152   if (ed) {
153     Sequence *seq = (Sequence *)ptr->data;
154
155     BKE_sequence_invalidate_cache_composite(scene, seq);
156   }
157 }
158
159 static void rna_Sequence_use_sequence(Main *bmain, Scene *scene, PointerRNA *ptr)
160 {
161   /* General update callback. */
162   rna_Sequence_invalidate_raw_update(bmain, scene, ptr);
163   /* Chaning recursion changes set of IDs which needs to be remapped by the copy-on-write.
164    * the only way for this currently is to tag the ID for ID_RECALC_COPY_ON_WRITE. */
165   Editing *ed = BKE_sequencer_editing_get(scene, false);
166   if (ed) {
167     Sequence *seq = (Sequence *)ptr->data;
168     if (seq->scene != NULL) {
169       DEG_id_tag_update(&seq->scene->id, ID_RECALC_COPY_ON_WRITE);
170     }
171   }
172   /* The sequencer scene is to be updated as well, including new relations from the nested
173    * sequencer. */
174   DEG_id_tag_update(&scene->id, ID_RECALC_SEQUENCER_STRIPS);
175   DEG_relations_tag_update(bmain);
176 }
177
178 static void rna_SequenceEditor_sequences_all_begin(CollectionPropertyIterator *iter,
179                                                    PointerRNA *ptr)
180 {
181   Scene *scene = (Scene *)ptr->id.data;
182   Editing *ed = BKE_sequencer_editing_get(scene, false);
183
184   meta_tmp_ref(NULL, ed->seqbase.first);
185
186   rna_iterator_listbase_begin(iter, &ed->seqbase, NULL);
187 }
188
189 static void rna_SequenceEditor_update_cache(Main *UNUSED(bmain),
190                                             Scene *scene,
191                                             PointerRNA *UNUSED(ptr))
192 {
193   Editing *ed = scene->ed;
194
195   BKE_sequencer_free_imbuf(scene, &ed->seqbase, false);
196   BKE_sequencer_cache_cleanup(scene);
197 }
198
199 static void rna_SequenceEditor_sequences_all_next(CollectionPropertyIterator *iter)
200 {
201   ListBaseIterator *internal = &iter->internal.listbase;
202   Sequence *seq = (Sequence *)internal->link;
203
204   if (seq->seqbase.first) {
205     internal->link = (Link *)seq->seqbase.first;
206   }
207   else if (seq->next) {
208     internal->link = (Link *)seq->next;
209   }
210   else {
211     internal->link = NULL;
212
213     do {
214       seq = seq->tmp; /* XXX - seq's don't reference their parents! */
215       if (seq && seq->next) {
216         internal->link = (Link *)seq->next;
217         break;
218       }
219     } while (seq);
220   }
221
222   iter->valid = (internal->link != NULL);
223 }
224
225 /* internal use */
226 static int rna_SequenceEditor_elements_length(PointerRNA *ptr)
227 {
228   Sequence *seq = (Sequence *)ptr->data;
229
230   /* Hack? copied from sequencer.c::reload_sequence_new_file() */
231   size_t olen = MEM_allocN_len(seq->strip->stripdata) / sizeof(struct StripElem);
232
233   /* The problem with seq->strip->len and seq->len is that it's discounted from the offset
234    * (hard cut trim). */
235   return (int)olen;
236 }
237
238 static void rna_SequenceEditor_elements_begin(CollectionPropertyIterator *iter, PointerRNA *ptr)
239 {
240   Sequence *seq = (Sequence *)ptr->data;
241   rna_iterator_array_begin(iter,
242                            (void *)seq->strip->stripdata,
243                            sizeof(StripElem),
244                            rna_SequenceEditor_elements_length(ptr),
245                            0,
246                            NULL);
247 }
248
249 static void rna_Sequence_views_format_update(Main *bmain, Scene *scene, PointerRNA *ptr)
250 {
251   rna_Sequence_invalidate_raw_update(bmain, scene, ptr);
252 }
253
254 static void do_sequence_frame_change_update(Scene *scene, Sequence *seq)
255 {
256   Editing *ed = BKE_sequencer_editing_get(scene, false);
257   ListBase *seqbase = BKE_sequence_seqbase(&ed->seqbase, seq);
258   Sequence *tseq;
259   BKE_sequence_calc_disp(scene, seq);
260
261   /* ensure effects are always fit in length to their input */
262
263   /* TODO(sergey): probably could be optimized.
264    *               in terms skipping update of non-changing strips
265    */
266   for (tseq = seqbase->first; tseq; tseq = tseq->next) {
267     if (tseq->seq1 || tseq->seq2 || tseq->seq3) {
268       BKE_sequence_calc(scene, tseq);
269     }
270   }
271
272   if (BKE_sequence_test_overlap(seqbase, seq)) {
273     BKE_sequence_base_shuffle(seqbase, seq, scene); /* XXX - BROKEN!, uses context seqbasep */
274   }
275   BKE_sequencer_sort(scene);
276 }
277
278 /* A simple wrapper around above func, directly usable as prop update func.
279  * Also invalidate cache if needed.
280  */
281 static void rna_Sequence_frame_change_update(Main *bmain, Scene *UNUSED(scene), PointerRNA *ptr)
282 {
283   Scene *scene = (Scene *)ptr->id.data;
284   do_sequence_frame_change_update(scene, (Sequence *)ptr->data);
285   rna_Sequence_invalidate_preprocessed_update(bmain, scene, ptr);
286 }
287
288 static void rna_Sequence_start_frame_set(PointerRNA *ptr, int value)
289 {
290   Sequence *seq = (Sequence *)ptr->data;
291   Scene *scene = (Scene *)ptr->id.data;
292
293   BKE_sequence_translate(scene, seq, value - seq->start);
294   do_sequence_frame_change_update(scene, seq);
295 }
296
297 static void rna_Sequence_start_frame_final_set(PointerRNA *ptr, int value)
298 {
299   Sequence *seq = (Sequence *)ptr->data;
300   Scene *scene = (Scene *)ptr->id.data;
301
302   BKE_sequence_tx_set_final_left(seq, value);
303   BKE_sequence_single_fix(seq);
304   do_sequence_frame_change_update(scene, seq);
305 }
306
307 static void rna_Sequence_end_frame_final_set(PointerRNA *ptr, int value)
308 {
309   Sequence *seq = (Sequence *)ptr->data;
310   Scene *scene = (Scene *)ptr->id.data;
311
312   BKE_sequence_tx_set_final_right(seq, value);
313   BKE_sequence_single_fix(seq);
314   do_sequence_frame_change_update(scene, seq);
315 }
316
317 static void rna_Sequence_anim_startofs_final_set(PointerRNA *ptr, int value)
318 {
319   Sequence *seq = (Sequence *)ptr->data;
320   Scene *scene = (Scene *)ptr->id.data;
321
322   seq->anim_startofs = MIN2(value, seq->len + seq->anim_startofs);
323
324   BKE_sequence_reload_new_file(scene, seq, false);
325   do_sequence_frame_change_update(scene, seq);
326 }
327
328 static void rna_Sequence_anim_endofs_final_set(PointerRNA *ptr, int value)
329 {
330   Sequence *seq = (Sequence *)ptr->data;
331   Scene *scene = (Scene *)ptr->id.data;
332
333   seq->anim_endofs = MIN2(value, seq->len + seq->anim_endofs);
334
335   BKE_sequence_reload_new_file(scene, seq, false);
336   do_sequence_frame_change_update(scene, seq);
337 }
338
339 static void rna_Sequence_frame_length_set(PointerRNA *ptr, int value)
340 {
341   Sequence *seq = (Sequence *)ptr->data;
342   Scene *scene = (Scene *)ptr->id.data;
343
344   BKE_sequence_tx_set_final_right(seq, BKE_sequence_tx_get_final_left(seq, false) + value);
345   do_sequence_frame_change_update(scene, seq);
346 }
347
348 static int rna_Sequence_frame_length_get(PointerRNA *ptr)
349 {
350   Sequence *seq = (Sequence *)ptr->data;
351   return BKE_sequence_tx_get_final_right(seq, false) - BKE_sequence_tx_get_final_left(seq, false);
352 }
353
354 static int rna_Sequence_frame_editable(PointerRNA *ptr, const char **UNUSED(r_info))
355 {
356   Sequence *seq = (Sequence *)ptr->data;
357   /* Effect sequences' start frame and length must be readonly! */
358   return (BKE_sequence_effect_get_num_inputs(seq->type)) ? 0 : PROP_EDITABLE;
359 }
360
361 static void rna_Sequence_channel_set(PointerRNA *ptr, int value)
362 {
363   Sequence *seq = (Sequence *)ptr->data;
364   Scene *scene = (Scene *)ptr->id.data;
365   Editing *ed = BKE_sequencer_editing_get(scene, false);
366   ListBase *seqbase = BKE_sequence_seqbase(&ed->seqbase, seq);
367
368   /* check channel increment or decrement */
369   const int channel_delta = (value >= seq->machine) ? 1 : -1;
370   seq->machine = value;
371
372   if (BKE_sequence_test_overlap(seqbase, seq)) {
373     /* XXX - BROKEN!, uses context seqbasep */
374     BKE_sequence_base_shuffle_ex(seqbase, seq, scene, channel_delta);
375   }
376   BKE_sequencer_sort(scene);
377 }
378
379 static void rna_Sequence_frame_offset_range(
380     PointerRNA *ptr, int *min, int *max, int *UNUSED(softmin), int *UNUSED(softmax))
381 {
382   Sequence *seq = (Sequence *)ptr->data;
383   *min = ELEM(seq->type, SEQ_TYPE_SOUND_RAM, SEQ_TYPE_SOUND_HD) ? 0 : INT_MIN;
384   *max = INT_MAX;
385 }
386
387 static void rna_Sequence_use_proxy_set(PointerRNA *ptr, bool value)
388 {
389   Sequence *seq = (Sequence *)ptr->data;
390   BKE_sequencer_proxy_set(seq, value != 0);
391 }
392
393 static void rna_Sequence_use_translation_set(PointerRNA *ptr, bool value)
394 {
395   Sequence *seq = (Sequence *)ptr->data;
396   if (value) {
397     seq->flag |= SEQ_USE_TRANSFORM;
398     if (seq->strip->transform == NULL) {
399       seq->strip->transform = MEM_callocN(sizeof(struct StripTransform), "StripTransform");
400     }
401   }
402   else {
403     seq->flag &= ~SEQ_USE_TRANSFORM;
404   }
405 }
406
407 static void rna_Sequence_use_crop_set(PointerRNA *ptr, bool value)
408 {
409   Sequence *seq = (Sequence *)ptr->data;
410   if (value) {
411     seq->flag |= SEQ_USE_CROP;
412     if (seq->strip->crop == NULL) {
413       seq->strip->crop = MEM_callocN(sizeof(struct StripCrop), "StripCrop");
414     }
415   }
416   else {
417     seq->flag &= ~SEQ_USE_CROP;
418   }
419 }
420
421 static int transform_seq_cmp_cb(Sequence *seq, void *arg_pt)
422 {
423   SequenceSearchData *data = arg_pt;
424
425   if (seq->strip && seq->strip->transform == data->data) {
426     data->seq = seq;
427     return -1; /* done so bail out */
428   }
429   return 1;
430 }
431
432 static Sequence *sequence_get_by_transform(Editing *ed, StripTransform *transform)
433 {
434   SequenceSearchData data;
435
436   data.seq = NULL;
437   data.data = transform;
438
439   /* irritating we need to search for our sequence! */
440   BKE_sequencer_base_recursive_apply(&ed->seqbase, transform_seq_cmp_cb, &data);
441
442   return data.seq;
443 }
444
445 static char *rna_SequenceTransform_path(PointerRNA *ptr)
446 {
447   Scene *scene = ptr->id.data;
448   Editing *ed = BKE_sequencer_editing_get(scene, false);
449   Sequence *seq = sequence_get_by_transform(ed, ptr->data);
450
451   if (seq && seq->name + 2) {
452     char name_esc[(sizeof(seq->name) - 2) * 2];
453
454     BLI_strescape(name_esc, seq->name + 2, sizeof(name_esc));
455     return BLI_sprintfN("sequence_editor.sequences_all[\"%s\"].transform", name_esc);
456   }
457   else {
458     return BLI_strdup("");
459   }
460 }
461
462 static void rna_SequenceTransform_update(Main *UNUSED(bmain),
463                                          Scene *UNUSED(scene),
464                                          PointerRNA *ptr)
465 {
466   Scene *scene = (Scene *)ptr->id.data;
467   Editing *ed = BKE_sequencer_editing_get(scene, false);
468   Sequence *seq = sequence_get_by_transform(ed, ptr->data);
469
470   BKE_sequence_invalidate_cache_preprocessed(scene, seq);
471 }
472
473 static int crop_seq_cmp_cb(Sequence *seq, void *arg_pt)
474 {
475   SequenceSearchData *data = arg_pt;
476
477   if (seq->strip && seq->strip->crop == data->data) {
478     data->seq = seq;
479     return -1; /* done so bail out */
480   }
481   return 1;
482 }
483
484 static Sequence *sequence_get_by_crop(Editing *ed, StripCrop *crop)
485 {
486   SequenceSearchData data;
487
488   data.seq = NULL;
489   data.data = crop;
490
491   /* irritating we need to search for our sequence! */
492   BKE_sequencer_base_recursive_apply(&ed->seqbase, crop_seq_cmp_cb, &data);
493
494   return data.seq;
495 }
496
497 static char *rna_SequenceCrop_path(PointerRNA *ptr)
498 {
499   Scene *scene = ptr->id.data;
500   Editing *ed = BKE_sequencer_editing_get(scene, false);
501   Sequence *seq = sequence_get_by_crop(ed, ptr->data);
502
503   if (seq && seq->name + 2) {
504     char name_esc[(sizeof(seq->name) - 2) * 2];
505
506     BLI_strescape(name_esc, seq->name + 2, sizeof(name_esc));
507     return BLI_sprintfN("sequence_editor.sequences_all[\"%s\"].crop", name_esc);
508   }
509   else {
510     return BLI_strdup("");
511   }
512 }
513
514 static void rna_SequenceCrop_update(Main *UNUSED(bmain), Scene *UNUSED(scene), PointerRNA *ptr)
515 {
516   Scene *scene = (Scene *)ptr->id.data;
517   Editing *ed = BKE_sequencer_editing_get(scene, false);
518   Sequence *seq = sequence_get_by_crop(ed, ptr->data);
519
520   BKE_sequence_invalidate_cache_preprocessed(scene, seq);
521 }
522
523 static void rna_Sequence_text_font_set(PointerRNA *ptr,
524                                        PointerRNA ptr_value,
525                                        struct ReportList *UNUSED(reports))
526 {
527   Sequence *seq = ptr->data;
528   TextVars *data = seq->effectdata;
529   VFont *value = ptr_value.data;
530
531   BKE_sequencer_text_font_unload(data, true);
532
533   id_us_plus(&value->id);
534   data->text_blf_id = SEQ_FONT_NOT_LOADED;
535   data->text_font = value;
536 }
537
538 /* name functions that ignore the first two characters */
539 static void rna_Sequence_name_get(PointerRNA *ptr, char *value)
540 {
541   Sequence *seq = (Sequence *)ptr->data;
542   BLI_strncpy(value, seq->name + 2, sizeof(seq->name) - 2);
543 }
544
545 static int rna_Sequence_name_length(PointerRNA *ptr)
546 {
547   Sequence *seq = (Sequence *)ptr->data;
548   return strlen(seq->name + 2);
549 }
550
551 static void rna_Sequence_name_set(PointerRNA *ptr, const char *value)
552 {
553   Scene *scene = (Scene *)ptr->id.data;
554   Sequence *seq = (Sequence *)ptr->data;
555   char oldname[sizeof(seq->name)];
556   AnimData *adt;
557
558   /* make a copy of the old name first */
559   BLI_strncpy(oldname, seq->name + 2, sizeof(seq->name) - 2);
560
561   /* copy the new name into the name slot */
562   BLI_strncpy_utf8(seq->name + 2, value, sizeof(seq->name) - 2);
563
564   /* make sure the name is unique */
565   BKE_sequence_base_unique_name_recursive(&scene->ed->seqbase, seq);
566
567   /* fix all the animation data which may link to this */
568
569   /* Don't rename everywhere because these are per scene. */
570 #  if 0
571   BKE_animdata_fix_paths_rename_all(NULL, "sequence_editor.sequences_all", oldname, seq->name + 2);
572 #  endif
573   adt = BKE_animdata_from_id(&scene->id);
574   if (adt) {
575     BKE_animdata_fix_paths_rename(
576         &scene->id, adt, NULL, "sequence_editor.sequences_all", oldname, seq->name + 2, 0, 0, 1);
577   }
578 }
579
580 static StructRNA *rna_Sequence_refine(struct PointerRNA *ptr)
581 {
582   Sequence *seq = (Sequence *)ptr->data;
583
584   switch (seq->type) {
585     case SEQ_TYPE_IMAGE:
586       return &RNA_ImageSequence;
587     case SEQ_TYPE_META:
588       return &RNA_MetaSequence;
589     case SEQ_TYPE_SCENE:
590       return &RNA_SceneSequence;
591     case SEQ_TYPE_MOVIE:
592       return &RNA_MovieSequence;
593     case SEQ_TYPE_MOVIECLIP:
594       return &RNA_MovieClipSequence;
595     case SEQ_TYPE_MASK:
596       return &RNA_MaskSequence;
597     case SEQ_TYPE_SOUND_RAM:
598       return &RNA_SoundSequence;
599     case SEQ_TYPE_CROSS:
600       return &RNA_CrossSequence;
601     case SEQ_TYPE_ADD:
602       return &RNA_AddSequence;
603     case SEQ_TYPE_SUB:
604       return &RNA_SubtractSequence;
605     case SEQ_TYPE_ALPHAOVER:
606       return &RNA_AlphaOverSequence;
607     case SEQ_TYPE_ALPHAUNDER:
608       return &RNA_AlphaUnderSequence;
609     case SEQ_TYPE_GAMCROSS:
610       return &RNA_GammaCrossSequence;
611     case SEQ_TYPE_MUL:
612       return &RNA_MultiplySequence;
613     case SEQ_TYPE_OVERDROP:
614       return &RNA_OverDropSequence;
615     case SEQ_TYPE_MULTICAM:
616       return &RNA_MulticamSequence;
617     case SEQ_TYPE_ADJUSTMENT:
618       return &RNA_AdjustmentSequence;
619     case SEQ_TYPE_WIPE:
620       return &RNA_WipeSequence;
621     case SEQ_TYPE_GLOW:
622       return &RNA_GlowSequence;
623     case SEQ_TYPE_TRANSFORM:
624       return &RNA_TransformSequence;
625     case SEQ_TYPE_COLOR:
626       return &RNA_ColorSequence;
627     case SEQ_TYPE_SPEED:
628       return &RNA_SpeedControlSequence;
629     case SEQ_TYPE_GAUSSIAN_BLUR:
630       return &RNA_GaussianBlurSequence;
631     case SEQ_TYPE_TEXT:
632       return &RNA_TextSequence;
633     case SEQ_TYPE_COLORMIX:
634       return &RNA_ColorMixSequence;
635     default:
636       return &RNA_Sequence;
637   }
638 }
639
640 static char *rna_Sequence_path(PointerRNA *ptr)
641 {
642   Sequence *seq = (Sequence *)ptr->data;
643
644   /* sequencer data comes from scene...
645    * TODO: would be nice to make SequenceEditor data a data-block of its own (for shorter paths)
646    */
647   if (seq->name + 2) {
648     char name_esc[(sizeof(seq->name) - 2) * 2];
649
650     BLI_strescape(name_esc, seq->name + 2, sizeof(name_esc));
651     return BLI_sprintfN("sequence_editor.sequences_all[\"%s\"]", name_esc);
652   }
653   else {
654     return BLI_strdup("");
655   }
656 }
657
658 static IDProperty *rna_Sequence_idprops(PointerRNA *ptr, bool create)
659 {
660   Sequence *seq = ptr->data;
661
662   if (create && !seq->prop) {
663     IDPropertyTemplate val = {0};
664     seq->prop = IDP_New(IDP_GROUP, &val, "Sequence ID properties");
665   }
666
667   return seq->prop;
668 }
669
670 static PointerRNA rna_MovieSequence_metadata_get(Sequence *seq)
671 {
672   if (seq == NULL || seq->anims.first == NULL) {
673     return PointerRNA_NULL;
674   }
675
676   StripAnim *sanim = seq->anims.first;
677   if (sanim->anim == NULL) {
678     return PointerRNA_NULL;
679   }
680
681   IDProperty *metadata = IMB_anim_load_metadata(sanim->anim);
682   if (metadata == NULL) {
683     return PointerRNA_NULL;
684   }
685
686   PointerRNA ptr;
687   RNA_pointer_create(NULL, &RNA_IDPropertyWrapPtr, metadata, &ptr);
688   return ptr;
689 }
690
691 static PointerRNA rna_SequenceEditor_meta_stack_get(CollectionPropertyIterator *iter)
692 {
693   ListBaseIterator *internal = &iter->internal.listbase;
694   MetaStack *ms = (MetaStack *)internal->link;
695
696   return rna_pointer_inherit_refine(&iter->parent, &RNA_Sequence, ms->parseq);
697 }
698
699 /* TODO, expose seq path setting as a higher level sequencer BKE function */
700 static void rna_Sequence_filepath_set(PointerRNA *ptr, const char *value)
701 {
702   Sequence *seq = (Sequence *)(ptr->data);
703   BLI_split_dirfile(value,
704                     seq->strip->dir,
705                     seq->strip->stripdata->name,
706                     sizeof(seq->strip->dir),
707                     sizeof(seq->strip->stripdata->name));
708 }
709
710 static void rna_Sequence_filepath_get(PointerRNA *ptr, char *value)
711 {
712   Sequence *seq = (Sequence *)(ptr->data);
713
714   BLI_join_dirfile(value, FILE_MAX, seq->strip->dir, seq->strip->stripdata->name);
715 }
716
717 static int rna_Sequence_filepath_length(PointerRNA *ptr)
718 {
719   Sequence *seq = (Sequence *)(ptr->data);
720   char path[FILE_MAX];
721
722   BLI_join_dirfile(path, sizeof(path), seq->strip->dir, seq->strip->stripdata->name);
723   return strlen(path);
724 }
725
726 static void rna_Sequence_proxy_filepath_set(PointerRNA *ptr, const char *value)
727 {
728   StripProxy *proxy = (StripProxy *)(ptr->data);
729   BLI_split_dirfile(value, proxy->dir, proxy->file, sizeof(proxy->dir), sizeof(proxy->file));
730   if (proxy->anim) {
731     IMB_free_anim(proxy->anim);
732     proxy->anim = NULL;
733   }
734 }
735
736 static void rna_Sequence_proxy_filepath_get(PointerRNA *ptr, char *value)
737 {
738   StripProxy *proxy = (StripProxy *)(ptr->data);
739
740   BLI_join_dirfile(value, FILE_MAX, proxy->dir, proxy->file);
741 }
742
743 static int rna_Sequence_proxy_filepath_length(PointerRNA *ptr)
744 {
745   StripProxy *proxy = (StripProxy *)(ptr->data);
746   char path[FILE_MAX];
747
748   BLI_join_dirfile(path, sizeof(path), proxy->dir, proxy->file);
749   return strlen(path);
750 }
751
752 static void rna_Sequence_audio_update(Main *UNUSED(bmain), Scene *scene, PointerRNA *UNUSED(ptr))
753 {
754   DEG_id_tag_update(&scene->id, ID_RECALC_SEQUENCER_STRIPS);
755 }
756
757 static int rna_Sequence_input_count_get(PointerRNA *ptr)
758 {
759   Sequence *seq = (Sequence *)(ptr->data);
760
761   return BKE_sequence_effect_get_num_inputs(seq->type);
762 }
763
764 #  if 0
765 static void rna_SoundSequence_filename_set(PointerRNA *ptr, const char *value)
766 {
767   Sequence *seq = (Sequence *)(ptr->data);
768   BLI_split_dirfile(value,
769                     seq->strip->dir,
770                     seq->strip->stripdata->name,
771                     sizeof(seq->strip->dir),
772                     sizeof(seq->strip->stripdata->name));
773 }
774
775 static void rna_SequenceElement_filename_set(PointerRNA *ptr, const char *value)
776 {
777   StripElem *elem = (StripElem *)(ptr->data);
778   BLI_split_file_part(value, elem->name, sizeof(elem->name));
779 }
780 #  endif
781
782 static void rna_Sequence_reopen_files_update(Main *bmain, Scene *UNUSED(scene), PointerRNA *ptr)
783 {
784   Scene *scene = (Scene *)ptr->id.data;
785   Editing *ed = BKE_sequencer_editing_get(scene, false);
786
787   BKE_sequencer_free_imbuf(scene, &ed->seqbase, false);
788   rna_Sequence_invalidate_raw_update(bmain, scene, ptr);
789
790   if (RNA_struct_is_a(ptr->type, &RNA_SoundSequence)) {
791     BKE_sequencer_update_sound_bounds(scene, ptr->data);
792   }
793 }
794
795 static void rna_Sequence_mute_update(Main *UNUSED(bmain), Scene *UNUSED(scene), PointerRNA *ptr)
796 {
797   Scene *scene = (Scene *)ptr->id.data;
798
799   DEG_id_tag_update(&scene->id, ID_RECALC_SEQUENCER_STRIPS);
800 }
801
802 static void rna_Sequence_filepath_update(Main *bmain, Scene *UNUSED(scene), PointerRNA *ptr)
803 {
804   Scene *scene = (Scene *)ptr->id.data;
805   Sequence *seq = (Sequence *)(ptr->data);
806   BKE_sequence_reload_new_file(scene, seq, true);
807   BKE_sequence_calc(scene, seq);
808   rna_Sequence_invalidate_raw_update(bmain, scene, ptr);
809 }
810
811 static void rna_Sequence_sound_update(Main *UNUSED(bmain), Scene *UNUSED(scene), PointerRNA *ptr)
812 {
813   Sequence *seq = (Sequence *)ptr->data;
814   if (seq->sound != NULL) {
815     BKE_sound_update_scene_sound(seq->scene_sound, seq->sound);
816   }
817 }
818
819 static int seqproxy_seq_cmp_cb(Sequence *seq, void *arg_pt)
820 {
821   SequenceSearchData *data = arg_pt;
822
823   if (seq->strip && seq->strip->proxy == data->data) {
824     data->seq = seq;
825     return -1; /* done so bail out */
826   }
827   return 1;
828 }
829
830 static Sequence *sequence_get_by_proxy(Editing *ed, StripProxy *proxy)
831 {
832   SequenceSearchData data;
833
834   data.seq = NULL;
835   data.data = proxy;
836
837   BKE_sequencer_base_recursive_apply(&ed->seqbase, seqproxy_seq_cmp_cb, &data);
838   return data.seq;
839 }
840
841 static void rna_Sequence_tcindex_update(Main *UNUSED(bmain), Scene *UNUSED(scene), PointerRNA *ptr)
842 {
843   Scene *scene = (Scene *)ptr->id.data;
844   Editing *ed = BKE_sequencer_editing_get(scene, false);
845   Sequence *seq = sequence_get_by_proxy(ed, ptr->data);
846
847   BKE_sequence_reload_new_file(scene, seq, false);
848   do_sequence_frame_change_update(scene, seq);
849 }
850
851 static void rna_SequenceProxy_update(Main *UNUSED(bmain), Scene *UNUSED(scene), PointerRNA *ptr)
852 {
853   Scene *scene = (Scene *)ptr->id.data;
854   Editing *ed = BKE_sequencer_editing_get(scene, false);
855   Sequence *seq = sequence_get_by_proxy(ed, ptr->data);
856
857   BKE_sequence_invalidate_cache_raw(scene, seq);
858 }
859
860 /* do_versions? */
861 static float rna_Sequence_opacity_get(PointerRNA *ptr)
862 {
863   Sequence *seq = (Sequence *)(ptr->data);
864   return seq->blend_opacity / 100.0f;
865 }
866 static void rna_Sequence_opacity_set(PointerRNA *ptr, float value)
867 {
868   Sequence *seq = (Sequence *)(ptr->data);
869   CLAMP(value, 0.0f, 1.0f);
870   seq->blend_opacity = value * 100.0f;
871 }
872
873 static int colbalance_seq_cmp_cb(Sequence *seq, void *arg_pt)
874 {
875   SequenceSearchData *data = arg_pt;
876
877   if (seq->modifiers.first) {
878     SequenceModifierData *smd = seq->modifiers.first;
879
880     for (smd = seq->modifiers.first; smd; smd = smd->next) {
881       if (smd->type == seqModifierType_ColorBalance) {
882         ColorBalanceModifierData *cbmd = (ColorBalanceModifierData *)smd;
883
884         if (&cbmd->color_balance == data->data) {
885           data->seq = seq;
886           data->smd = smd;
887           return -1; /* done so bail out */
888         }
889       }
890     }
891   }
892
893   return 1;
894 }
895
896 static Sequence *sequence_get_by_colorbalance(Editing *ed,
897                                               StripColorBalance *cb,
898                                               SequenceModifierData **r_smd)
899 {
900   SequenceSearchData data;
901
902   data.seq = NULL;
903   data.smd = NULL;
904   data.data = cb;
905
906   /* irritating we need to search for our sequence! */
907   BKE_sequencer_base_recursive_apply(&ed->seqbase, colbalance_seq_cmp_cb, &data);
908
909   *r_smd = data.smd;
910
911   return data.seq;
912 }
913
914 static char *rna_SequenceColorBalance_path(PointerRNA *ptr)
915 {
916   Scene *scene = ptr->id.data;
917   SequenceModifierData *smd;
918   Editing *ed = BKE_sequencer_editing_get(scene, false);
919   Sequence *seq = sequence_get_by_colorbalance(ed, ptr->data, &smd);
920
921   if (seq && seq->name + 2) {
922     char name_esc[(sizeof(seq->name) - 2) * 2];
923
924     BLI_strescape(name_esc, seq->name + 2, sizeof(name_esc));
925
926     if (!smd) {
927       /* path to old filter color balance */
928       return BLI_sprintfN("sequence_editor.sequences_all[\"%s\"].color_balance", name_esc);
929     }
930     else {
931       /* path to modifier */
932       char name_esc_smd[sizeof(smd->name) * 2];
933
934       BLI_strescape(name_esc_smd, smd->name, sizeof(name_esc_smd));
935       return BLI_sprintfN("sequence_editor.sequences_all[\"%s\"].modifiers[\"%s\"].color_balance",
936                           name_esc,
937                           name_esc_smd);
938     }
939   }
940   else {
941     return BLI_strdup("");
942   }
943 }
944
945 static void rna_SequenceColorBalance_update(Main *UNUSED(bmain),
946                                             Scene *UNUSED(scene),
947                                             PointerRNA *ptr)
948 {
949   Scene *scene = (Scene *)ptr->id.data;
950   Editing *ed = BKE_sequencer_editing_get(scene, false);
951   SequenceModifierData *smd;
952   Sequence *seq = sequence_get_by_colorbalance(ed, ptr->data, &smd);
953
954   BKE_sequence_invalidate_cache_preprocessed(scene, seq);
955 }
956
957 static void rna_SequenceEditor_overlay_lock_set(PointerRNA *ptr, bool value)
958 {
959   Scene *scene = ptr->id.data;
960   Editing *ed = BKE_sequencer_editing_get(scene, false);
961
962   if (ed == NULL) {
963     return;
964   }
965
966   /* convert from abs to relative and back */
967   if ((ed->over_flag & SEQ_EDIT_OVERLAY_ABS) == 0 && value) {
968     ed->over_cfra = scene->r.cfra + ed->over_ofs;
969     ed->over_flag |= SEQ_EDIT_OVERLAY_ABS;
970   }
971   else if ((ed->over_flag & SEQ_EDIT_OVERLAY_ABS) && !value) {
972     ed->over_ofs = ed->over_cfra - scene->r.cfra;
973     ed->over_flag &= ~SEQ_EDIT_OVERLAY_ABS;
974   }
975 }
976
977 static int rna_SequenceEditor_overlay_frame_get(PointerRNA *ptr)
978 {
979   Scene *scene = (Scene *)ptr->id.data;
980   Editing *ed = BKE_sequencer_editing_get(scene, false);
981
982   if (ed == NULL) {
983     return scene->r.cfra;
984   }
985
986   if (ed->over_flag & SEQ_EDIT_OVERLAY_ABS) {
987     return ed->over_cfra - scene->r.cfra;
988   }
989   else {
990     return ed->over_ofs;
991   }
992 }
993
994 static void rna_SequenceEditor_overlay_frame_set(PointerRNA *ptr, int value)
995 {
996   Scene *scene = (Scene *)ptr->id.data;
997   Editing *ed = BKE_sequencer_editing_get(scene, false);
998
999   if (ed == NULL) {
1000     return;
1001   }
1002
1003   if (ed->over_flag & SEQ_EDIT_OVERLAY_ABS) {
1004     ed->over_cfra = (scene->r.cfra + value);
1005   }
1006   else {
1007     ed->over_ofs = value;
1008   }
1009 }
1010
1011 static int modifier_seq_cmp_cb(Sequence *seq, void *arg_pt)
1012 {
1013   SequenceSearchData *data = arg_pt;
1014
1015   if (BLI_findindex(&seq->modifiers, data->data) != -1) {
1016     data->seq = seq;
1017     return -1; /* done so bail out */
1018   }
1019
1020   return 1;
1021 }
1022
1023 static Sequence *sequence_get_by_modifier(Editing *ed, SequenceModifierData *smd)
1024 {
1025   SequenceSearchData data;
1026
1027   data.seq = NULL;
1028   data.data = smd;
1029
1030   /* irritating we need to search for our sequence! */
1031   BKE_sequencer_base_recursive_apply(&ed->seqbase, modifier_seq_cmp_cb, &data);
1032
1033   return data.seq;
1034 }
1035
1036 static StructRNA *rna_SequenceModifier_refine(struct PointerRNA *ptr)
1037 {
1038   SequenceModifierData *smd = (SequenceModifierData *)ptr->data;
1039
1040   switch (smd->type) {
1041     case seqModifierType_ColorBalance:
1042       return &RNA_ColorBalanceModifier;
1043     case seqModifierType_Curves:
1044       return &RNA_CurvesModifier;
1045     case seqModifierType_HueCorrect:
1046       return &RNA_HueCorrectModifier;
1047     case seqModifierType_BrightContrast:
1048       return &RNA_BrightContrastModifier;
1049     case seqModifierType_WhiteBalance:
1050       return &RNA_WhiteBalanceModifier;
1051     case seqModifierType_Tonemap:
1052       return &RNA_SequencerTonemapModifierData;
1053     default:
1054       return &RNA_SequenceModifier;
1055   }
1056 }
1057
1058 static char *rna_SequenceModifier_path(PointerRNA *ptr)
1059 {
1060   Scene *scene = ptr->id.data;
1061   Editing *ed = BKE_sequencer_editing_get(scene, false);
1062   SequenceModifierData *smd = ptr->data;
1063   Sequence *seq = sequence_get_by_modifier(ed, smd);
1064
1065   if (seq && seq->name + 2) {
1066     char name_esc[(sizeof(seq->name) - 2) * 2];
1067     char name_esc_smd[sizeof(smd->name) * 2];
1068
1069     BLI_strescape(name_esc, seq->name + 2, sizeof(name_esc));
1070     BLI_strescape(name_esc_smd, smd->name, sizeof(name_esc_smd));
1071     return BLI_sprintfN(
1072         "sequence_editor.sequences_all[\"%s\"].modifiers[\"%s\"]", name_esc, name_esc_smd);
1073   }
1074   else {
1075     return BLI_strdup("");
1076   }
1077 }
1078
1079 static void rna_SequenceModifier_name_set(PointerRNA *ptr, const char *value)
1080 {
1081   SequenceModifierData *smd = ptr->data;
1082   Scene *scene = (Scene *)ptr->id.data;
1083   Editing *ed = BKE_sequencer_editing_get(scene, false);
1084   Sequence *seq = sequence_get_by_modifier(ed, smd);
1085   AnimData *adt;
1086   char oldname[sizeof(smd->name)];
1087
1088   /* make a copy of the old name first */
1089   BLI_strncpy(oldname, smd->name, sizeof(smd->name));
1090
1091   /* copy the new name into the name slot */
1092   BLI_strncpy_utf8(smd->name, value, sizeof(smd->name));
1093
1094   /* make sure the name is truly unique */
1095   BKE_sequence_modifier_unique_name(seq, smd);
1096
1097   /* fix all the animation data which may link to this */
1098   adt = BKE_animdata_from_id(&scene->id);
1099   if (adt) {
1100     char path[1024];
1101
1102     BLI_snprintf(
1103         path, sizeof(path), "sequence_editor.sequences_all[\"%s\"].modifiers", seq->name + 2);
1104     BKE_animdata_fix_paths_rename(&scene->id, adt, NULL, path, oldname, smd->name, 0, 0, 1);
1105   }
1106 }
1107
1108 static void rna_SequenceModifier_update(Main *UNUSED(bmain), Scene *UNUSED(scene), PointerRNA *ptr)
1109 {
1110   /* strip from other scenes could be modified, so using active scene is not reliable */
1111   Scene *scene = (Scene *)ptr->id.data;
1112   Editing *ed = BKE_sequencer_editing_get(scene, false);
1113   Sequence *seq = sequence_get_by_modifier(ed, ptr->data);
1114
1115   BKE_sequence_invalidate_cache_preprocessed(scene, seq);
1116 }
1117
1118 static bool rna_SequenceModifier_otherSequence_poll(PointerRNA *ptr, PointerRNA value)
1119 {
1120   Scene *scene = (Scene *)ptr->id.data;
1121   Editing *ed = BKE_sequencer_editing_get(scene, false);
1122   Sequence *seq = sequence_get_by_modifier(ed, ptr->data);
1123   Sequence *cur = (Sequence *)value.data;
1124
1125   if ((seq == cur) || (cur->type == SEQ_TYPE_SOUND_RAM)) {
1126     return false;
1127   }
1128
1129   return true;
1130 }
1131
1132 static SequenceModifierData *rna_Sequence_modifier_new(
1133     Sequence *seq, bContext *C, ReportList *reports, const char *name, int type)
1134 {
1135   if (!BKE_sequence_supports_modifiers(seq)) {
1136     BKE_report(reports, RPT_ERROR, "Sequence type does not support modifiers");
1137
1138     return NULL;
1139   }
1140   else {
1141     Scene *scene = CTX_data_scene(C);
1142     SequenceModifierData *smd;
1143
1144     smd = BKE_sequence_modifier_new(seq, name, type);
1145
1146     BKE_sequence_invalidate_cache_preprocessed(scene, seq);
1147
1148     WM_main_add_notifier(NC_SCENE | ND_SEQUENCER, NULL);
1149
1150     return smd;
1151   }
1152 }
1153
1154 static void rna_Sequence_modifier_remove(Sequence *seq,
1155                                          bContext *C,
1156                                          ReportList *reports,
1157                                          PointerRNA *smd_ptr)
1158 {
1159   SequenceModifierData *smd = smd_ptr->data;
1160   Scene *scene = CTX_data_scene(C);
1161
1162   if (BKE_sequence_modifier_remove(seq, smd) == false) {
1163     BKE_report(reports, RPT_ERROR, "Modifier was not found in the stack");
1164     return;
1165   }
1166
1167   RNA_POINTER_INVALIDATE(smd_ptr);
1168   BKE_sequence_invalidate_cache_preprocessed(scene, seq);
1169
1170   WM_main_add_notifier(NC_SCENE | ND_SEQUENCER, NULL);
1171 }
1172
1173 static void rna_Sequence_modifier_clear(Sequence *seq, bContext *C)
1174 {
1175   Scene *scene = CTX_data_scene(C);
1176
1177   BKE_sequence_modifier_clear(seq);
1178
1179   BKE_sequence_invalidate_cache_preprocessed(scene, seq);
1180
1181   WM_main_add_notifier(NC_SCENE | ND_SEQUENCER, NULL);
1182 }
1183
1184 static float rna_Sequence_fps_get(PointerRNA *ptr)
1185 {
1186   Scene *scene = (Scene *)ptr->id.data;
1187   Sequence *seq = (Sequence *)(ptr->data);
1188   return BKE_sequence_get_fps(scene, seq);
1189 }
1190
1191 #else
1192
1193 static void rna_def_strip_element(BlenderRNA *brna)
1194 {
1195   StructRNA *srna;
1196   PropertyRNA *prop;
1197
1198   srna = RNA_def_struct(brna, "SequenceElement", NULL);
1199   RNA_def_struct_ui_text(srna, "Sequence Element", "Sequence strip data for a single frame");
1200   RNA_def_struct_sdna(srna, "StripElem");
1201
1202   prop = RNA_def_property(srna, "filename", PROP_STRING, PROP_FILENAME);
1203   RNA_def_property_string_sdna(prop, NULL, "name");
1204   RNA_def_property_ui_text(prop, "Filename", "Name of the source file");
1205   RNA_def_property_update(prop, NC_SCENE | ND_SEQUENCER, "rna_SequenceElement_update");
1206
1207   prop = RNA_def_property(srna, "orig_width", PROP_INT, PROP_NONE);
1208   RNA_def_property_int_sdna(prop, NULL, "orig_width");
1209   RNA_def_property_clear_flag(prop, PROP_EDITABLE);
1210   RNA_def_property_ui_text(prop, "Orig Width", "Original image width");
1211
1212   prop = RNA_def_property(srna, "orig_height", PROP_INT, PROP_NONE);
1213   RNA_def_property_int_sdna(prop, NULL, "orig_height");
1214   RNA_def_property_clear_flag(prop, PROP_EDITABLE);
1215   RNA_def_property_ui_text(prop, "Orig Height", "Original image height");
1216 }
1217
1218 static void rna_def_strip_crop(BlenderRNA *brna)
1219 {
1220   StructRNA *srna;
1221   PropertyRNA *prop;
1222
1223   srna = RNA_def_struct(brna, "SequenceCrop", NULL);
1224   RNA_def_struct_ui_text(srna, "Sequence Crop", "Cropping parameters for a sequence strip");
1225   RNA_def_struct_sdna(srna, "StripCrop");
1226
1227   prop = RNA_def_property(srna, "max_y", PROP_INT, PROP_PIXEL);
1228   RNA_def_property_int_sdna(prop, NULL, "top");
1229   RNA_def_property_ui_text(prop, "Top", "Number of pixels to crop from the top");
1230   RNA_def_property_ui_range(prop, 0, 4096, 1, -1);
1231   RNA_def_property_update(prop, NC_SCENE | ND_SEQUENCER, "rna_SequenceCrop_update");
1232
1233   prop = RNA_def_property(srna, "min_y", PROP_INT, PROP_PIXEL);
1234   RNA_def_property_int_sdna(prop, NULL, "bottom");
1235   RNA_def_property_ui_text(prop, "Bottom", "Number of pixels to crop from the bottom");
1236   RNA_def_property_ui_range(prop, 0, 4096, 1, -1);
1237   RNA_def_property_update(prop, NC_SCENE | ND_SEQUENCER, "rna_SequenceCrop_update");
1238
1239   prop = RNA_def_property(srna, "min_x", PROP_INT, PROP_PIXEL);
1240   RNA_def_property_int_sdna(prop, NULL, "left");
1241   RNA_def_property_ui_text(prop, "Left", "Number of pixels to crop from the left side");
1242   RNA_def_property_ui_range(prop, 0, 4096, 1, -1);
1243   RNA_def_property_update(prop, NC_SCENE | ND_SEQUENCER, "rna_SequenceCrop_update");
1244
1245   prop = RNA_def_property(srna, "max_x", PROP_INT, PROP_PIXEL);
1246   RNA_def_property_int_sdna(prop, NULL, "right");
1247   RNA_def_property_ui_text(prop, "Right", "Number of pixels to crop from the right side");
1248   RNA_def_property_ui_range(prop, 0, 4096, 1, -1);
1249   RNA_def_property_update(prop, NC_SCENE | ND_SEQUENCER, "rna_SequenceCrop_update");
1250
1251   RNA_def_struct_path_func(srna, "rna_SequenceCrop_path");
1252 }
1253
1254 static void rna_def_strip_transform(BlenderRNA *brna)
1255 {
1256   StructRNA *srna;
1257   PropertyRNA *prop;
1258
1259   srna = RNA_def_struct(brna, "SequenceTransform", NULL);
1260   RNA_def_struct_ui_text(srna, "Sequence Transform", "Transform parameters for a sequence strip");
1261   RNA_def_struct_sdna(srna, "StripTransform");
1262
1263   prop = RNA_def_property(srna, "offset_x", PROP_INT, PROP_PIXEL);
1264   RNA_def_property_int_sdna(prop, NULL, "xofs");
1265   RNA_def_property_ui_text(
1266       prop, "Offset X", "Amount to move the input on the X axis within its boundaries");
1267   RNA_def_property_ui_range(prop, -4096, 4096, 1, -1);
1268   RNA_def_property_update(prop, NC_SCENE | ND_SEQUENCER, "rna_SequenceTransform_update");
1269
1270   prop = RNA_def_property(srna, "offset_y", PROP_INT, PROP_PIXEL);
1271   RNA_def_property_int_sdna(prop, NULL, "yofs");
1272   RNA_def_property_ui_text(
1273       prop, "Offset Y", "Amount to move the input on the Y axis within its boundaries");
1274   RNA_def_property_ui_range(prop, -4096, 4096, 1, -1);
1275   RNA_def_property_update(prop, NC_SCENE | ND_SEQUENCER, "rna_SequenceTransform_update");
1276
1277   RNA_def_struct_path_func(srna, "rna_SequenceTransform_path");
1278 }
1279
1280 static void rna_def_strip_proxy(BlenderRNA *brna)
1281 {
1282   StructRNA *srna;
1283   PropertyRNA *prop;
1284
1285   static const EnumPropertyItem seq_tc_items[] = {
1286       {SEQ_PROXY_TC_NONE, "NONE", 0, "No TC in use", ""},
1287       {SEQ_PROXY_TC_RECORD_RUN,
1288        "RECORD_RUN",
1289        0,
1290        "Record Run",
1291        "Use images in the order as they are recorded"},
1292       {SEQ_PROXY_TC_FREE_RUN,
1293        "FREE_RUN",
1294        0,
1295        "Free Run",
1296        "Use global timestamp written by recording device"},
1297       {SEQ_PROXY_TC_INTERP_REC_DATE_FREE_RUN,
1298        "FREE_RUN_REC_DATE",
1299        0,
1300        "Free Run (rec date)",
1301        "Interpolate a global timestamp using the "
1302        "record date and time written by recording device"},
1303       {SEQ_PROXY_TC_RECORD_RUN_NO_GAPS,
1304        "RECORD_RUN_NO_GAPS",
1305        0,
1306        "Record Run No Gaps",
1307        "Like record run, but ignore timecode, "
1308        "changes in framerate or dropouts"},
1309       {0, NULL, 0, NULL, NULL},
1310   };
1311
1312   srna = RNA_def_struct(brna, "SequenceProxy", NULL);
1313   RNA_def_struct_ui_text(srna, "Sequence Proxy", "Proxy parameters for a sequence strip");
1314   RNA_def_struct_sdna(srna, "StripProxy");
1315
1316   prop = RNA_def_property(srna, "directory", PROP_STRING, PROP_DIRPATH);
1317   RNA_def_property_string_sdna(prop, NULL, "dir");
1318   RNA_def_property_ui_text(prop, "Directory", "Location to store the proxy files");
1319   RNA_def_property_update(prop, NC_SCENE | ND_SEQUENCER, "rna_SequenceProxy_update");
1320
1321   prop = RNA_def_property(srna, "filepath", PROP_STRING, PROP_FILEPATH);
1322   RNA_def_property_ui_text(prop, "Path", "Location of custom proxy file");
1323   RNA_def_property_string_funcs(prop,
1324                                 "rna_Sequence_proxy_filepath_get",
1325                                 "rna_Sequence_proxy_filepath_length",
1326                                 "rna_Sequence_proxy_filepath_set");
1327
1328   RNA_def_property_update(prop, NC_SCENE | ND_SEQUENCER, "rna_SequenceProxy_update");
1329
1330   prop = RNA_def_property(srna, "use_overwrite", PROP_BOOLEAN, PROP_NONE);
1331   RNA_def_property_boolean_negative_sdna(prop, NULL, "build_flags", SEQ_PROXY_SKIP_EXISTING);
1332   RNA_def_property_ui_text(prop, "Overwrite", "Overwrite existing proxy files when building");
1333
1334   prop = RNA_def_property(srna, "build_25", PROP_BOOLEAN, PROP_NONE);
1335   RNA_def_property_boolean_sdna(prop, NULL, "build_size_flags", SEQ_PROXY_IMAGE_SIZE_25);
1336   RNA_def_property_ui_text(prop, "25%", "Build 25% proxy resolution");
1337
1338   prop = RNA_def_property(srna, "build_50", PROP_BOOLEAN, PROP_NONE);
1339   RNA_def_property_boolean_sdna(prop, NULL, "build_size_flags", SEQ_PROXY_IMAGE_SIZE_50);
1340   RNA_def_property_ui_text(prop, "50%", "Build 50% proxy resolution");
1341
1342   prop = RNA_def_property(srna, "build_75", PROP_BOOLEAN, PROP_NONE);
1343   RNA_def_property_boolean_sdna(prop, NULL, "build_size_flags", SEQ_PROXY_IMAGE_SIZE_75);
1344   RNA_def_property_ui_text(prop, "75%", "Build 75% proxy resolution");
1345
1346   prop = RNA_def_property(srna, "build_100", PROP_BOOLEAN, PROP_NONE);
1347   RNA_def_property_boolean_sdna(prop, NULL, "build_size_flags", SEQ_PROXY_IMAGE_SIZE_100);
1348   RNA_def_property_ui_text(prop, "100%", "Build 100% proxy resolution");
1349
1350   prop = RNA_def_property(srna, "build_record_run", PROP_BOOLEAN, PROP_NONE);
1351   RNA_def_property_boolean_sdna(prop, NULL, "build_tc_flags", SEQ_PROXY_TC_RECORD_RUN);
1352   RNA_def_property_ui_text(prop, "Rec Run", "Build record run time code index");
1353
1354   prop = RNA_def_property(srna, "build_free_run", PROP_BOOLEAN, PROP_NONE);
1355   RNA_def_property_boolean_sdna(prop, NULL, "build_tc_flags", SEQ_PROXY_TC_FREE_RUN);
1356   RNA_def_property_ui_text(prop, "Free Run", "Build free run time code index");
1357
1358   prop = RNA_def_property(srna, "build_free_run_rec_date", PROP_BOOLEAN, PROP_NONE);
1359   RNA_def_property_boolean_sdna(
1360       prop, NULL, "build_tc_flags", SEQ_PROXY_TC_INTERP_REC_DATE_FREE_RUN);
1361   RNA_def_property_ui_text(
1362       prop, "Free Run (Rec Date)", "Build free run time code index using Record Date/Time");
1363
1364   prop = RNA_def_property(srna, "quality", PROP_INT, PROP_UNSIGNED);
1365   RNA_def_property_int_sdna(prop, NULL, "quality");
1366   RNA_def_property_ui_text(prop, "Quality", "JPEG Quality of proxies to build");
1367   RNA_def_property_ui_range(prop, 1, 100, 1, -1);
1368
1369   prop = RNA_def_property(srna, "timecode", PROP_ENUM, PROP_NONE);
1370   RNA_def_property_enum_sdna(prop, NULL, "tc");
1371   RNA_def_property_enum_items(prop, seq_tc_items);
1372   RNA_def_property_ui_text(prop, "Timecode", "Method for reading the inputs timecode");
1373   RNA_def_property_update(prop, NC_SCENE | ND_SEQUENCER, "rna_Sequence_tcindex_update");
1374
1375   prop = RNA_def_property(srna, "use_proxy_custom_directory", PROP_BOOLEAN, PROP_NONE);
1376   RNA_def_property_boolean_sdna(prop, NULL, "storage", SEQ_STORAGE_PROXY_CUSTOM_DIR);
1377   RNA_def_property_ui_text(prop, "Proxy Custom Directory", "Use a custom directory to store data");
1378   RNA_def_property_update(prop, NC_SCENE | ND_SEQUENCER, "rna_Sequence_invalidate_raw_update");
1379
1380   prop = RNA_def_property(srna, "use_proxy_custom_file", PROP_BOOLEAN, PROP_NONE);
1381   RNA_def_property_boolean_sdna(prop, NULL, "storage", SEQ_STORAGE_PROXY_CUSTOM_FILE);
1382   RNA_def_property_ui_text(prop, "Proxy Custom File", "Use a custom file to read proxy data from");
1383   RNA_def_property_update(prop, NC_SCENE | ND_SEQUENCER, "rna_Sequence_invalidate_raw_update");
1384 }
1385
1386 static void rna_def_color_balance(BlenderRNA *brna)
1387 {
1388   StructRNA *srna;
1389   PropertyRNA *prop;
1390
1391   srna = RNA_def_struct(brna, "SequenceColorBalanceData", NULL);
1392   RNA_def_struct_ui_text(srna,
1393                          "Sequence Color Balance Data",
1394                          "Color balance parameters for a sequence strip and it's modifiers");
1395   RNA_def_struct_sdna(srna, "StripColorBalance");
1396
1397   prop = RNA_def_property(srna, "lift", PROP_FLOAT, PROP_COLOR_GAMMA);
1398   RNA_def_property_ui_text(prop, "Lift", "Color balance lift (shadows)");
1399   RNA_def_property_ui_range(prop, 0, 2, 0.1, 3);
1400   RNA_def_property_float_default(prop, 1.0f);
1401   RNA_def_property_update(prop, NC_SCENE | ND_SEQUENCER, "rna_SequenceColorBalance_update");
1402
1403   prop = RNA_def_property(srna, "gamma", PROP_FLOAT, PROP_COLOR_GAMMA);
1404   RNA_def_property_ui_text(prop, "Gamma", "Color balance gamma (midtones)");
1405   RNA_def_property_ui_range(prop, 0, 2, 0.1, 3);
1406   RNA_def_property_float_default(prop, 1.0f);
1407   RNA_def_property_update(prop, NC_SCENE | ND_SEQUENCER, "rna_SequenceColorBalance_update");
1408
1409   prop = RNA_def_property(srna, "gain", PROP_FLOAT, PROP_COLOR_GAMMA);
1410   RNA_def_property_ui_text(prop, "Gain", "Color balance gain (highlights)");
1411   RNA_def_property_ui_range(prop, 0, 2, 0.1, 3);
1412   RNA_def_property_float_default(prop, 1.0f);
1413   RNA_def_property_update(prop, NC_SCENE | ND_SEQUENCER, "rna_SequenceColorBalance_update");
1414
1415   prop = RNA_def_property(srna, "invert_gain", PROP_BOOLEAN, PROP_NONE);
1416   RNA_def_property_boolean_sdna(prop, NULL, "flag", SEQ_COLOR_BALANCE_INVERSE_GAIN);
1417   RNA_def_property_ui_text(prop, "Inverse Gain", "Invert the gain color`");
1418   RNA_def_property_update(prop, NC_SCENE | ND_SEQUENCER, "rna_SequenceColorBalance_update");
1419
1420   prop = RNA_def_property(srna, "invert_gamma", PROP_BOOLEAN, PROP_NONE);
1421   RNA_def_property_boolean_sdna(prop, NULL, "flag", SEQ_COLOR_BALANCE_INVERSE_GAMMA);
1422   RNA_def_property_ui_text(prop, "Inverse Gamma", "Invert the gamma color");
1423   RNA_def_property_update(prop, NC_SCENE | ND_SEQUENCER, "rna_SequenceColorBalance_update");
1424
1425   prop = RNA_def_property(srna, "invert_lift", PROP_BOOLEAN, PROP_NONE);
1426   RNA_def_property_boolean_sdna(prop, NULL, "flag", SEQ_COLOR_BALANCE_INVERSE_LIFT);
1427   RNA_def_property_ui_text(prop, "Inverse Lift", "Invert the lift color");
1428   RNA_def_property_update(prop, NC_SCENE | ND_SEQUENCER, "rna_SequenceColorBalance_update");
1429
1430   /* not yet used */
1431 #  if 0
1432   prop = RNA_def_property(srna, "exposure", PROP_FLOAT, PROP_NONE);
1433   RNA_def_property_range(prop, 0.0f, 1.0f);
1434   RNA_def_property_ui_text(prop, "Exposure", "");
1435   RNA_def_property_update(prop, NC_SCENE | ND_SEQUENCER, "rna_Sequence_ColorBabalnce_update");
1436
1437   prop = RNA_def_property(srna, "saturation", PROP_FLOAT, PROP_NONE);
1438   RNA_def_property_range(prop, 0.0f, 1.0f);
1439   RNA_def_property_ui_text(prop, "Saturation", "");
1440   RNA_def_property_update(prop, NC_SCENE | ND_SEQUENCER, "rna_Sequence_ColorBabalnce_update");
1441 #  endif
1442
1443   RNA_def_struct_path_func(srna, "rna_SequenceColorBalance_path");
1444 }
1445
1446 static void rna_def_strip_color_balance(BlenderRNA *brna)
1447 {
1448   StructRNA *srna;
1449
1450   srna = RNA_def_struct(brna, "SequenceColorBalance", "SequenceColorBalanceData");
1451   RNA_def_struct_ui_text(
1452       srna, "Sequence Color Balance", "Color balance parameters for a sequence strip");
1453   RNA_def_struct_sdna(srna, "StripColorBalance");
1454 }
1455
1456 static const EnumPropertyItem blend_mode_items[] = {
1457     {SEQ_BLEND_REPLACE, "REPLACE", 0, "Replace", ""},
1458     {SEQ_TYPE_CROSS, "CROSS", 0, "Cross", ""},
1459     {0, "", ICON_NONE, NULL, NULL},
1460     {SEQ_TYPE_DARKEN, "DARKEN", 0, "Darken", ""},
1461     {SEQ_TYPE_MUL, "MULTIPLY", 0, "Multiply", ""},
1462     {SEQ_TYPE_BURN, "BURN", 0, "Burn", ""},
1463     {SEQ_TYPE_LINEAR_BURN, "LINEAR_BURN", 0, "Linear Burn", ""},
1464     {0, "", ICON_NONE, NULL, NULL},
1465     {SEQ_TYPE_LIGHTEN, "LIGHTEN", 0, "Lighten", ""},
1466     {SEQ_TYPE_SCREEN, "SCREEN", 0, "Screen", ""},
1467     {SEQ_TYPE_DODGE, "DODGE", 0, "Dodge", ""},
1468     {SEQ_TYPE_ADD, "ADD", 0, "Add", ""},
1469     {0, "", ICON_NONE, NULL, NULL},
1470     {SEQ_TYPE_OVERLAY, "OVERLAY", 0, "Overlay", ""},
1471     {SEQ_TYPE_SOFT_LIGHT, "SOFT_LIGHT", 0, "Soft Light", ""},
1472     {SEQ_TYPE_HARD_LIGHT, "HARD_LIGHT", 0, "Hard Light", ""},
1473     {SEQ_TYPE_VIVID_LIGHT, "VIVID_LIGHT", 0, "Vivid Light", ""},
1474     {SEQ_TYPE_LIN_LIGHT, "LINEAR_LIGHT", 0, "Linear Light", ""},
1475     {SEQ_TYPE_PIN_LIGHT, "PIN_LIGHT", 0, "Pin Light", ""},
1476     {0, "", ICON_NONE, NULL, NULL},
1477     {SEQ_TYPE_DIFFERENCE, "DIFFERENCE", 0, "Difference", ""},
1478     {SEQ_TYPE_EXCLUSION, "EXCLUSION", 0, "Exclusion", ""},
1479     {SEQ_TYPE_SUB, "SUBTRACT", 0, "Subtract", ""},
1480     {0, "", ICON_NONE, NULL, NULL},
1481     {SEQ_TYPE_HUE, "HUE", 0, "Hue", ""},
1482     {SEQ_TYPE_SATURATION, "SATURATION", 0, "Saturation", ""},
1483     {SEQ_TYPE_BLEND_COLOR, "COLOR", 0, "Color", ""},
1484     {SEQ_TYPE_VALUE, "VALUE", 0, "Value", ""},
1485     {0, "", ICON_NONE, NULL, NULL},
1486     {SEQ_TYPE_ALPHAOVER, "ALPHA_OVER", 0, "Alpha Over", ""},
1487     {SEQ_TYPE_ALPHAUNDER, "ALPHA_UNDER", 0, "Alpha Under", ""},
1488     {SEQ_TYPE_GAMCROSS, "GAMMA_CROSS", 0, "Gamma Cross", ""},
1489     {SEQ_TYPE_OVERDROP, "OVER_DROP", 0, "Over Drop", ""},
1490     {0, NULL, 0, NULL, NULL},
1491 };
1492
1493 static void rna_def_sequence_modifiers(BlenderRNA *brna, PropertyRNA *cprop)
1494 {
1495   StructRNA *srna;
1496
1497   FunctionRNA *func;
1498   PropertyRNA *parm;
1499
1500   RNA_def_property_srna(cprop, "SequenceModifiers");
1501   srna = RNA_def_struct(brna, "SequenceModifiers", NULL);
1502   RNA_def_struct_sdna(srna, "Sequence");
1503   RNA_def_struct_ui_text(srna, "Strip Modifiers", "Collection of strip modifiers");
1504
1505   /* add modifier */
1506   func = RNA_def_function(srna, "new", "rna_Sequence_modifier_new");
1507   RNA_def_function_flag(func, FUNC_USE_CONTEXT | FUNC_USE_REPORTS);
1508   RNA_def_function_ui_description(func, "Add a new modifier");
1509   parm = RNA_def_string(func, "name", "Name", 0, "", "New name for the modifier");
1510   RNA_def_parameter_flags(parm, 0, PARM_REQUIRED);
1511   /* modifier to add */
1512   parm = RNA_def_enum(func,
1513                       "type",
1514                       rna_enum_sequence_modifier_type_items,
1515                       seqModifierType_ColorBalance,
1516                       "",
1517                       "Modifier type to add");
1518   RNA_def_parameter_flags(parm, 0, PARM_REQUIRED);
1519   /* return type */
1520   parm = RNA_def_pointer(func, "modifier", "SequenceModifier", "", "Newly created modifier");
1521   RNA_def_function_return(func, parm);
1522
1523   /* remove modifier */
1524   func = RNA_def_function(srna, "remove", "rna_Sequence_modifier_remove");
1525   RNA_def_function_flag(func, FUNC_USE_CONTEXT | FUNC_USE_REPORTS);
1526   RNA_def_function_ui_description(func, "Remove an existing modifier from the sequence");
1527   /* modifier to remove */
1528   parm = RNA_def_pointer(func, "modifier", "SequenceModifier", "", "Modifier to remove");
1529   RNA_def_parameter_flags(parm, PROP_NEVER_NULL, PARM_REQUIRED | PARM_RNAPTR);
1530   RNA_def_parameter_clear_flags(parm, PROP_THICK_WRAP, 0);
1531
1532   /* clear all modifiers */
1533   func = RNA_def_function(srna, "clear", "rna_Sequence_modifier_clear");
1534   RNA_def_function_flag(func, FUNC_USE_CONTEXT);
1535   RNA_def_function_ui_description(func, "Remove all modifiers from the sequence");
1536 }
1537
1538 static void rna_def_sequence(BlenderRNA *brna)
1539 {
1540   StructRNA *srna;
1541   PropertyRNA *prop;
1542
1543   static const EnumPropertyItem seq_type_items[] = {
1544       {SEQ_TYPE_IMAGE, "IMAGE", 0, "Image", ""},
1545       {SEQ_TYPE_META, "META", 0, "Meta", ""},
1546       {SEQ_TYPE_SCENE, "SCENE", 0, "Scene", ""},
1547       {SEQ_TYPE_MOVIE, "MOVIE", 0, "Movie", ""},
1548       {SEQ_TYPE_MOVIECLIP, "MOVIECLIP", 0, "Clip", ""},
1549       {SEQ_TYPE_MASK, "MASK", 0, "Mask", ""},
1550       {SEQ_TYPE_SOUND_RAM, "SOUND", 0, "Sound", ""},
1551       {SEQ_TYPE_CROSS, "CROSS", 0, "Cross", ""},
1552       {SEQ_TYPE_ADD, "ADD", 0, "Add", ""},
1553       {SEQ_TYPE_SUB, "SUBTRACT", 0, "Subtract", ""},
1554       {SEQ_TYPE_ALPHAOVER, "ALPHA_OVER", 0, "Alpha Over", ""},
1555       {SEQ_TYPE_ALPHAUNDER, "ALPHA_UNDER", 0, "Alpha Under", ""},
1556       {SEQ_TYPE_GAMCROSS, "GAMMA_CROSS", 0, "Gamma Cross", ""},
1557       {SEQ_TYPE_MUL, "MULTIPLY", 0, "Multiply", ""},
1558       {SEQ_TYPE_OVERDROP, "OVER_DROP", 0, "Over Drop", ""},
1559       {SEQ_TYPE_WIPE, "WIPE", 0, "Wipe", ""},
1560       {SEQ_TYPE_GLOW, "GLOW", 0, "Glow", ""},
1561       {SEQ_TYPE_TRANSFORM, "TRANSFORM", 0, "Transform", ""},
1562       {SEQ_TYPE_COLOR, "COLOR", 0, "Color", ""},
1563       {SEQ_TYPE_SPEED, "SPEED", 0, "Speed", ""},
1564       {SEQ_TYPE_MULTICAM, "MULTICAM", 0, "Multicam Selector", ""},
1565       {SEQ_TYPE_ADJUSTMENT, "ADJUSTMENT", 0, "Adjustment Layer", ""},
1566       {SEQ_TYPE_GAUSSIAN_BLUR, "GAUSSIAN_BLUR", 0, "Gaussian Blur", ""},
1567       {SEQ_TYPE_TEXT, "TEXT", 0, "Text", ""},
1568       {SEQ_TYPE_COLORMIX, "COLORMIX", 0, "Color Mix", ""},
1569       {0, NULL, 0, NULL, NULL},
1570   };
1571
1572   srna = RNA_def_struct(brna, "Sequence", NULL);
1573   RNA_def_struct_ui_text(srna, "Sequence", "Sequence strip in the sequence editor");
1574   RNA_def_struct_refine_func(srna, "rna_Sequence_refine");
1575   RNA_def_struct_path_func(srna, "rna_Sequence_path");
1576   RNA_def_struct_idprops_func(srna, "rna_Sequence_idprops");
1577
1578   prop = RNA_def_property(srna, "name", PROP_STRING, PROP_NONE);
1579   RNA_def_property_string_funcs(
1580       prop, "rna_Sequence_name_get", "rna_Sequence_name_length", "rna_Sequence_name_set");
1581   RNA_def_property_string_maxlength(prop, sizeof(((Sequence *)NULL)->name) - 2);
1582   RNA_def_property_ui_text(prop, "Name", "");
1583   RNA_def_struct_name_property(srna, prop);
1584   RNA_def_property_update(prop, NC_SCENE | ND_SEQUENCER, NULL);
1585
1586   prop = RNA_def_property(srna, "type", PROP_ENUM, PROP_NONE);
1587   RNA_def_property_clear_flag(prop, PROP_EDITABLE);
1588   RNA_def_property_enum_items(prop, seq_type_items);
1589   RNA_def_property_ui_text(prop, "Type", "");
1590   RNA_def_property_translation_context(prop, BLT_I18NCONTEXT_ID_SEQUENCE);
1591   RNA_def_property_update(prop, NC_SCENE | ND_SEQUENCER, "rna_Sequence_invalidate_raw_update");
1592
1593   /* flags */
1594   prop = RNA_def_property(srna, "select", PROP_BOOLEAN, PROP_NONE);
1595   RNA_def_property_boolean_sdna(prop, NULL, "flag", SELECT);
1596   RNA_def_property_ui_text(prop, "Select", "");
1597   RNA_def_property_update(prop, NC_SCENE | ND_SEQUENCER | NA_SELECTED, NULL);
1598
1599   prop = RNA_def_property(srna, "select_left_handle", PROP_BOOLEAN, PROP_NONE);
1600   RNA_def_property_boolean_sdna(prop, NULL, "flag", SEQ_LEFTSEL);
1601   RNA_def_property_ui_text(prop, "Left Handle Selected", "");
1602   RNA_def_property_update(prop, NC_SCENE | ND_SEQUENCER | NA_SELECTED, NULL);
1603
1604   prop = RNA_def_property(srna, "select_right_handle", PROP_BOOLEAN, PROP_NONE);
1605   RNA_def_property_boolean_sdna(prop, NULL, "flag", SEQ_RIGHTSEL);
1606   RNA_def_property_ui_text(prop, "Right Handle Selected", "");
1607   RNA_def_property_update(prop, NC_SCENE | ND_SEQUENCER | NA_SELECTED, NULL);
1608
1609   prop = RNA_def_property(srna, "mute", PROP_BOOLEAN, PROP_NONE);
1610   RNA_def_property_boolean_sdna(prop, NULL, "flag", SEQ_MUTE);
1611   RNA_def_property_ui_icon(prop, ICON_HIDE_OFF, -1);
1612   RNA_def_property_ui_text(
1613       prop, "Mute", "Disable strip so that it cannot be viewed in the output");
1614   RNA_def_property_update(prop, NC_SCENE | ND_SEQUENCER, "rna_Sequence_mute_update");
1615
1616   prop = RNA_def_property(srna, "lock", PROP_BOOLEAN, PROP_NONE);
1617   RNA_def_property_boolean_sdna(prop, NULL, "flag", SEQ_LOCK);
1618   RNA_def_property_clear_flag(prop, PROP_ANIMATABLE);
1619   RNA_def_property_ui_icon(prop, ICON_UNLOCKED, true);
1620   RNA_def_property_ui_text(prop, "Lock", "Lock strip so that it cannot be transformed");
1621   RNA_def_property_update(prop, NC_SCENE | ND_SEQUENCER, NULL);
1622
1623   /* strip positioning */
1624   prop = RNA_def_property(srna, "frame_final_duration", PROP_INT, PROP_TIME);
1625   RNA_def_property_range(prop, 1, MAXFRAME);
1626   RNA_def_property_clear_flag(prop, PROP_ANIMATABLE);
1627   RNA_def_property_ui_text(
1628       prop, "Length", "The length of the contents of this strip after the handles are applied");
1629   RNA_def_property_int_funcs(
1630       prop, "rna_Sequence_frame_length_get", "rna_Sequence_frame_length_set", NULL);
1631   RNA_def_property_editable_func(prop, "rna_Sequence_frame_editable");
1632   RNA_def_property_update(
1633       prop, NC_SCENE | ND_SEQUENCER, "rna_Sequence_invalidate_preprocessed_update");
1634
1635   prop = RNA_def_property(srna, "frame_duration", PROP_INT, PROP_TIME);
1636   RNA_def_property_int_sdna(prop, NULL, "len");
1637   RNA_def_property_clear_flag(prop, PROP_EDITABLE | PROP_ANIMATABLE);
1638   RNA_def_property_range(prop, 1, MAXFRAME);
1639   RNA_def_property_ui_text(
1640       prop, "Length", "The length of the contents of this strip before the handles are applied");
1641
1642   prop = RNA_def_property(srna, "frame_start", PROP_INT, PROP_TIME);
1643   RNA_def_property_int_sdna(prop, NULL, "start");
1644   RNA_def_property_clear_flag(prop, PROP_ANIMATABLE);
1645   RNA_def_property_ui_text(prop, "Start Frame", "X position where the strip begins");
1646   RNA_def_property_int_funcs(
1647       prop, NULL, "rna_Sequence_start_frame_set", NULL); /* overlap tests and calc_seq_disp */
1648   RNA_def_property_editable_func(prop, "rna_Sequence_frame_editable");
1649   RNA_def_property_update(
1650       prop, NC_SCENE | ND_SEQUENCER, "rna_Sequence_invalidate_preprocessed_update");
1651
1652   prop = RNA_def_property(srna, "frame_final_start", PROP_INT, PROP_TIME);
1653   RNA_def_property_int_sdna(prop, NULL, "startdisp");
1654   RNA_def_property_clear_flag(prop, PROP_ANIMATABLE);
1655   RNA_def_property_ui_text(
1656       prop,
1657       "Start Frame",
1658       "Start frame displayed in the sequence editor after offsets are applied, setting this is "
1659       "equivalent to moving the handle, not the actual start frame");
1660   /* overlap tests and calc_seq_disp */
1661   RNA_def_property_int_funcs(prop, NULL, "rna_Sequence_start_frame_final_set", NULL);
1662   RNA_def_property_editable_func(prop, "rna_Sequence_frame_editable");
1663   RNA_def_property_update(
1664       prop, NC_SCENE | ND_SEQUENCER, "rna_Sequence_invalidate_preprocessed_update");
1665
1666   prop = RNA_def_property(srna, "frame_final_end", PROP_INT, PROP_TIME);
1667   RNA_def_property_int_sdna(prop, NULL, "enddisp");
1668   RNA_def_property_clear_flag(prop, PROP_ANIMATABLE);
1669   RNA_def_property_ui_text(
1670       prop, "End Frame", "End frame displayed in the sequence editor after offsets are applied");
1671   /* overlap tests and calc_seq_disp */
1672   RNA_def_property_int_funcs(prop, NULL, "rna_Sequence_end_frame_final_set", NULL);
1673   RNA_def_property_editable_func(prop, "rna_Sequence_frame_editable");
1674   RNA_def_property_update(
1675       prop, NC_SCENE | ND_SEQUENCER, "rna_Sequence_invalidate_preprocessed_update");
1676
1677   prop = RNA_def_property(srna, "frame_offset_start", PROP_INT, PROP_TIME);
1678   RNA_def_property_int_sdna(prop, NULL, "startofs");
1679   //  RNA_def_property_clear_flag(prop, PROP_EDITABLE); /* overlap tests */
1680   RNA_def_property_ui_text(prop, "Start Offset", "");
1681   RNA_def_property_int_funcs(prop, NULL, NULL, "rna_Sequence_frame_offset_range");
1682   RNA_def_property_update(prop, NC_SCENE | ND_SEQUENCER, "rna_Sequence_frame_change_update");
1683
1684   prop = RNA_def_property(srna, "frame_offset_end", PROP_INT, PROP_TIME);
1685   RNA_def_property_int_sdna(prop, NULL, "endofs");
1686   //  RNA_def_property_clear_flag(prop, PROP_EDITABLE); /* overlap tests */
1687   RNA_def_property_ui_text(prop, "End Offset", "");
1688   RNA_def_property_int_funcs(prop, NULL, NULL, "rna_Sequence_frame_offset_range");
1689   RNA_def_property_update(prop, NC_SCENE | ND_SEQUENCER, "rna_Sequence_frame_change_update");
1690
1691   prop = RNA_def_property(srna, "frame_still_start", PROP_INT, PROP_TIME);
1692   RNA_def_property_int_sdna(prop, NULL, "startstill");
1693   //  RNA_def_property_clear_flag(prop, PROP_EDITABLE); /* overlap tests */
1694   RNA_def_property_range(prop, 0, MAXFRAME);
1695   RNA_def_property_ui_text(prop, "Start Still", "");
1696   RNA_def_property_update(prop, NC_SCENE | ND_SEQUENCER, "rna_Sequence_frame_change_update");
1697
1698   prop = RNA_def_property(srna, "frame_still_end", PROP_INT, PROP_TIME);
1699   RNA_def_property_int_sdna(prop, NULL, "endstill");
1700   //  RNA_def_property_clear_flag(prop, PROP_EDITABLE); /* overlap tests */
1701   RNA_def_property_range(prop, 0, MAXFRAME);
1702   RNA_def_property_ui_text(prop, "End Still", "");
1703   RNA_def_property_update(prop, NC_SCENE | ND_SEQUENCER, "rna_Sequence_frame_change_update");
1704
1705   prop = RNA_def_property(srna, "channel", PROP_INT, PROP_UNSIGNED);
1706   RNA_def_property_int_sdna(prop, NULL, "machine");
1707   RNA_def_property_clear_flag(prop, PROP_ANIMATABLE);
1708   RNA_def_property_range(prop, 1, MAXSEQ);
1709   RNA_def_property_ui_text(prop, "Channel", "Y position of the sequence strip");
1710   RNA_def_property_int_funcs(prop, NULL, "rna_Sequence_channel_set", NULL); /* overlap test */
1711   RNA_def_property_update(
1712       prop, NC_SCENE | ND_SEQUENCER, "rna_Sequence_invalidate_preprocessed_update");
1713
1714   prop = RNA_def_property(srna, "use_linear_modifiers", PROP_BOOLEAN, PROP_NONE);
1715   RNA_def_property_boolean_sdna(prop, NULL, "flag", SEQ_USE_LINEAR_MODIFIERS);
1716   RNA_def_property_ui_text(prop,
1717                            "Use Linear Modifiers",
1718                            "Calculate modifiers in linear space instead of sequencer's space");
1719   RNA_def_property_update(
1720       prop, NC_SCENE | ND_SEQUENCER, "rna_Sequence_invalidate_preprocessed_update");
1721
1722   /* blending */
1723
1724   prop = RNA_def_property(srna, "blend_type", PROP_ENUM, PROP_NONE);
1725   RNA_def_property_enum_sdna(prop, NULL, "blend_mode");
1726   RNA_def_property_enum_items(prop, blend_mode_items);
1727   RNA_def_property_ui_text(
1728       prop, "Blend Mode", "Method for controlling how the strip combines with other strips");
1729   RNA_def_property_update(
1730       prop, NC_SCENE | ND_SEQUENCER, "rna_Sequence_invalidate_preprocessed_update");
1731
1732   prop = RNA_def_property(srna, "blend_alpha", PROP_FLOAT, PROP_FACTOR);
1733   RNA_def_property_range(prop, 0.0f, 1.0f);
1734   RNA_def_property_ui_text(
1735       prop, "Blend Opacity", "Percentage of how much the strip's colors affect other strips");
1736   /* stupid 0-100 -> 0-1 */
1737   RNA_def_property_float_funcs(prop, "rna_Sequence_opacity_get", "rna_Sequence_opacity_set", NULL);
1738   RNA_def_property_update(
1739       prop, NC_SCENE | ND_SEQUENCER, "rna_Sequence_invalidate_composite_update");
1740
1741   prop = RNA_def_property(srna, "effect_fader", PROP_FLOAT, PROP_FACTOR);
1742   RNA_def_property_range(prop, 0.0f, 1.0f);
1743   RNA_def_property_ui_range(prop, 0.0f, 1.0f, 0.1, 3);
1744   RNA_def_property_float_sdna(prop, NULL, "effect_fader");
1745   RNA_def_property_ui_text(prop, "Effect fader position", "Custom fade value");
1746   RNA_def_property_update(
1747       prop, NC_SCENE | ND_SEQUENCER, "rna_Sequence_invalidate_preprocessed_update");
1748
1749   prop = RNA_def_property(srna, "use_default_fade", PROP_BOOLEAN, PROP_NONE);
1750   RNA_def_property_boolean_sdna(prop, NULL, "flag", SEQ_USE_EFFECT_DEFAULT_FADE);
1751   RNA_def_property_ui_text(
1752       prop,
1753       "Use Default Fade",
1754       "Fade effect using the built-in default (usually make transition as long as "
1755       "effect strip)");
1756   RNA_def_property_update(
1757       prop, NC_SCENE | ND_SEQUENCER, "rna_Sequence_invalidate_preprocessed_update");
1758
1759   prop = RNA_def_property(srna, "speed_factor", PROP_FLOAT, PROP_NONE);
1760   RNA_def_property_float_sdna(prop, NULL, "speed_fader");
1761   RNA_def_property_ui_text(
1762       prop,
1763       "Speed factor",
1764       "Multiply the current speed of the sequence with this number or remap current frame "
1765       "to this frame");
1766   RNA_def_property_update(
1767       prop, NC_SCENE | ND_SEQUENCER, "rna_Sequence_invalidate_preprocessed_update");
1768
1769   /* modifiers */
1770   prop = RNA_def_property(srna, "modifiers", PROP_COLLECTION, PROP_NONE);
1771   RNA_def_property_struct_type(prop, "SequenceModifier");
1772   RNA_def_property_ui_text(prop, "Modifiers", "Modifiers affecting this strip");
1773   rna_def_sequence_modifiers(brna, prop);
1774
1775   prop = RNA_def_property(srna, "use_cache_raw", PROP_BOOLEAN, PROP_NONE);
1776   RNA_def_property_boolean_sdna(prop, NULL, "cache_flag", SEQ_CACHE_STORE_RAW);
1777   RNA_def_property_ui_text(prop,
1778                            "Cache Raw",
1779                            "Cache raw images read from disk, for faster tweaking of strip "
1780                            "parameters at the cost of memory usage");
1781
1782   prop = RNA_def_property(srna, "use_cache_preprocessed", PROP_BOOLEAN, PROP_NONE);
1783   RNA_def_property_boolean_sdna(prop, NULL, "cache_flag", SEQ_CACHE_STORE_PREPROCESSED);
1784   RNA_def_property_ui_text(
1785       prop,
1786       "Cache Preprocessed",
1787       "Cache preprocessed images, for faster tweaking of effects at the cost of memory usage");
1788
1789   prop = RNA_def_property(srna, "use_cache_composite", PROP_BOOLEAN, PROP_NONE);
1790   RNA_def_property_boolean_sdna(prop, NULL, "cache_flag", SEQ_CACHE_STORE_COMPOSITE);
1791   RNA_def_property_ui_text(prop,
1792                            "Cache Composite",
1793                            "Cache intermediate composited images, for faster tweaking of stacked "
1794                            "strips at the cost of memory usage");
1795
1796   prop = RNA_def_property(srna, "override_cache_settings", PROP_BOOLEAN, PROP_NONE);
1797   RNA_def_property_boolean_sdna(prop, NULL, "cache_flag", SEQ_CACHE_OVERRIDE);
1798   RNA_def_property_ui_text(prop, "Override Cache Settings", "Override global cache settings");
1799
1800   RNA_api_sequence_strip(srna);
1801 }
1802
1803 static void rna_def_editor(BlenderRNA *brna)
1804 {
1805   StructRNA *srna;
1806   PropertyRNA *prop;
1807
1808   static const EnumPropertyItem editing_storage_items[] = {
1809       {0, "PER_STRIP", 0, "Per Strip", "Store proxies using per strip settings"},
1810       {SEQ_EDIT_PROXY_DIR_STORAGE,
1811        "PROJECT",
1812        0,
1813        "Project",
1814        "Store proxies using project directory"},
1815       {0, NULL, 0, NULL, NULL},
1816   };
1817   srna = RNA_def_struct(brna, "SequenceEditor", NULL);
1818   RNA_def_struct_ui_text(srna, "Sequence Editor", "Sequence editing data for a Scene data-block");
1819   RNA_def_struct_ui_icon(srna, ICON_SEQUENCE);
1820   RNA_def_struct_sdna(srna, "Editing");
1821
1822   prop = RNA_def_property(srna, "sequences", PROP_COLLECTION, PROP_NONE);
1823   RNA_def_property_collection_sdna(prop, NULL, "seqbase", NULL);
1824   RNA_def_property_struct_type(prop, "Sequence");
1825   RNA_def_property_ui_text(prop, "Sequences", "Top-level strips only");
1826   RNA_api_sequences(brna, prop);
1827
1828   prop = RNA_def_property(srna, "sequences_all", PROP_COLLECTION, PROP_NONE);
1829   RNA_def_property_collection_sdna(prop, NULL, "seqbase", NULL);
1830   RNA_def_property_struct_type(prop, "Sequence");
1831   RNA_def_property_ui_text(
1832       prop, "All Sequences", "All strips, recursively including those inside metastrips");
1833   RNA_def_property_collection_funcs(prop,
1834                                     "rna_SequenceEditor_sequences_all_begin",
1835                                     "rna_SequenceEditor_sequences_all_next",
1836                                     NULL,
1837                                     NULL,
1838                                     NULL,
1839                                     NULL,
1840                                     NULL,
1841                                     NULL);
1842
1843   prop = RNA_def_property(srna, "meta_stack", PROP_COLLECTION, PROP_NONE);
1844   RNA_def_property_collection_sdna(prop, NULL, "metastack", NULL);
1845   RNA_def_property_struct_type(prop, "Sequence");
1846   RNA_def_property_ui_text(
1847       prop, "Meta Stack", "Meta strip stack, last is currently edited meta strip");
1848   RNA_def_property_collection_funcs(
1849       prop, NULL, NULL, NULL, "rna_SequenceEditor_meta_stack_get", NULL, NULL, NULL, NULL);
1850
1851   prop = RNA_def_property(srna, "active_strip", PROP_POINTER, PROP_NONE);
1852   RNA_def_property_pointer_sdna(prop, NULL, "act_seq");
1853   RNA_def_property_flag(prop, PROP_EDITABLE);
1854   RNA_def_property_ui_text(prop, "Active Strip", "Sequencer's active strip");
1855
1856   prop = RNA_def_property(srna, "show_overlay", PROP_BOOLEAN, PROP_NONE);
1857   RNA_def_property_boolean_sdna(prop, NULL, "over_flag", SEQ_EDIT_OVERLAY_SHOW);
1858   RNA_def_property_ui_text(prop, "Draw Axes", "Partial overlay on top of the sequencer");
1859   RNA_def_property_update(prop, NC_SPACE | ND_SPACE_SEQUENCER, NULL);
1860
1861   prop = RNA_def_property(srna, "use_overlay_lock", PROP_BOOLEAN, PROP_NONE);
1862   RNA_def_property_boolean_sdna(prop, NULL, "over_flag", SEQ_EDIT_OVERLAY_ABS);
1863   RNA_def_property_ui_text(prop, "Overlay Lock", "");
1864   RNA_def_property_boolean_funcs(prop, NULL, "rna_SequenceEditor_overlay_lock_set");
1865   RNA_def_property_update(prop, NC_SPACE | ND_SPACE_SEQUENCER, NULL);
1866
1867   /* access to fixed and relative frame */
1868   prop = RNA_def_property(srna, "overlay_frame", PROP_INT, PROP_NONE);
1869   RNA_def_property_ui_text(prop, "Overlay Offset", "");
1870   RNA_def_property_int_funcs(
1871       prop, "rna_SequenceEditor_overlay_frame_get", "rna_SequenceEditor_overlay_frame_set", NULL);
1872   RNA_def_property_update(prop, NC_SPACE | ND_SPACE_SEQUENCER, NULL);
1873
1874   prop = RNA_def_property(srna, "proxy_storage", PROP_ENUM, PROP_NONE);
1875   RNA_def_property_enum_items(prop, editing_storage_items);
1876   RNA_def_property_ui_text(prop, "Proxy Storage", "How to store proxies for this project");
1877   RNA_def_property_update(prop, NC_SPACE | ND_SPACE_SEQUENCER, "rna_SequenceEditor_update_cache");
1878
1879   prop = RNA_def_property(srna, "proxy_dir", PROP_STRING, PROP_DIRPATH);
1880   RNA_def_property_string_sdna(prop, NULL, "proxy_dir");
1881   RNA_def_property_ui_text(prop, "Proxy Directory", "");
1882   RNA_def_property_update(prop, NC_SPACE | ND_SPACE_SEQUENCER, "rna_SequenceEditor_update_cache");
1883
1884   /* cache flags */
1885
1886   prop = RNA_def_property(srna, "show_cache", PROP_BOOLEAN, PROP_NONE);
1887   RNA_def_property_boolean_sdna(prop, NULL, "cache_flag", SEQ_CACHE_VIEW_ENABLE);
1888   RNA_def_property_ui_text(prop, "Show Cache", "Visualize cached images on the timeline");
1889   RNA_def_property_update(prop, NC_SCENE | ND_SEQUENCER, NULL);
1890
1891   prop = RNA_def_property(srna, "show_cache_final_out", PROP_BOOLEAN, PROP_NONE);
1892   RNA_def_property_boolean_sdna(prop, NULL, "cache_flag", SEQ_CACHE_VIEW_FINAL_OUT);
1893   RNA_def_property_ui_text(prop, "Final Images", "Visualize cached complete frames");
1894   RNA_def_property_update(prop, NC_SCENE | ND_SEQUENCER, NULL);
1895
1896   prop = RNA_def_property(srna, "show_cache_raw", PROP_BOOLEAN, PROP_NONE);
1897   RNA_def_property_boolean_sdna(prop, NULL, "cache_flag", SEQ_CACHE_VIEW_RAW);
1898   RNA_def_property_ui_text(prop, "Raw Images", "Visualize cached raw images");
1899   RNA_def_property_update(prop, NC_SCENE | ND_SEQUENCER, NULL);
1900
1901   prop = RNA_def_property(srna, "show_cache_preprocessed", PROP_BOOLEAN, PROP_NONE);
1902   RNA_def_property_boolean_sdna(prop, NULL, "cache_flag", SEQ_CACHE_VIEW_PREPROCESSED);
1903   RNA_def_property_ui_text(prop, "Preprocessed Images", "Visualize cached preprocessed images");
1904   RNA_def_property_update(prop, NC_SCENE | ND_SEQUENCER, NULL);
1905
1906   prop = RNA_def_property(srna, "show_cache_composite", PROP_BOOLEAN, PROP_NONE);
1907   RNA_def_property_boolean_sdna(prop, NULL, "cache_flag", SEQ_CACHE_VIEW_COMPOSITE);
1908   RNA_def_property_ui_text(prop, "Composite Images", "Visualize cached composite images");
1909   RNA_def_property_update(prop, NC_SCENE | ND_SEQUENCER, NULL);
1910
1911   prop = RNA_def_property(srna, "use_cache_raw", PROP_BOOLEAN, PROP_NONE);
1912   RNA_def_property_boolean_sdna(prop, NULL, "cache_flag", SEQ_CACHE_STORE_RAW);
1913   RNA_def_property_ui_text(prop,
1914                            "Cache Raw",
1915                            "Cache raw images read from disk, for faster tweaking of strip "
1916                            "parameters at the cost of memory usage");
1917
1918   prop = RNA_def_property(srna, "use_cache_preprocessed", PROP_BOOLEAN, PROP_NONE);
1919   RNA_def_property_boolean_sdna(prop, NULL, "cache_flag", SEQ_CACHE_STORE_PREPROCESSED);
1920   RNA_def_property_ui_text(
1921       prop,
1922       "Cache Preprocessed",
1923       "Cache preprocessed images, for faster tweaking of effects at the cost of memory usage");
1924
1925   prop = RNA_def_property(srna, "use_cache_composite", PROP_BOOLEAN, PROP_NONE);
1926   RNA_def_property_boolean_sdna(prop, NULL, "cache_flag", SEQ_CACHE_STORE_COMPOSITE);
1927   RNA_def_property_ui_text(prop,
1928                            "Cache Composite",
1929                            "Cache intermediate composited images, for faster tweaking of stacked "
1930                            "strips at the cost of memory usage");
1931
1932   prop = RNA_def_property(srna, "use_cache_final", PROP_BOOLEAN, PROP_NONE);
1933   RNA_def_property_boolean_sdna(prop, NULL, "cache_flag", SEQ_CACHE_STORE_FINAL_OUT);
1934   RNA_def_property_ui_text(prop, "Cache Final", "Cache final image for each frame");
1935
1936   prop = RNA_def_property(srna, "recycle_max_cost", PROP_FLOAT, PROP_NONE);
1937   RNA_def_property_range(prop, 0.0f, SEQ_CACHE_COST_MAX);
1938   RNA_def_property_ui_range(prop, 0.0f, SEQ_CACHE_COST_MAX, 0.1f, 1);
1939   RNA_def_property_float_sdna(prop, NULL, "recycle_max_cost");
1940   RNA_def_property_ui_text(
1941       prop, "Recycle Up To Cost", "Only frames with cost lower than this value will be recycled");
1942 }
1943
1944 static void rna_def_filter_video(StructRNA *srna)
1945 {
1946   PropertyRNA *prop;
1947
1948   static const EnumPropertyItem alpha_mode_items[] = {
1949       {SEQ_ALPHA_STRAIGHT,
1950        "STRAIGHT",
1951        0,
1952        "Straight",
1953        "RGB channels in transparent pixels are unaffected by the alpha channel"},
1954       {SEQ_ALPHA_PREMUL,
1955        "PREMUL",
1956        0,
1957        "Premultiplied",
1958        "RGB channels in transparent pixels are multiplied by the alpha channel"},
1959       {0, NULL, 0, NULL, NULL},
1960   };
1961
1962   prop = RNA_def_property(srna, "use_deinterlace", PROP_BOOLEAN, PROP_NONE);
1963   RNA_def_property_boolean_sdna(prop, NULL, "flag", SEQ_FILTERY);
1964   RNA_def_property_ui_text(prop, "Deinterlace", "Remove fields from video movies");
1965   RNA_def_property_update(prop, NC_SCENE | ND_SEQUENCER, "rna_Sequence_reopen_files_update");
1966
1967   prop = RNA_def_property(srna, "alpha_mode", PROP_ENUM, PROP_NONE);
1968   RNA_def_property_enum_items(prop, alpha_mode_items);
1969   RNA_def_property_ui_text(
1970       prop, "Alpha Mode", "Representation of alpha information in the RGBA pixels");
1971   RNA_def_property_update(prop, NC_SCENE | ND_SEQUENCER, "rna_Sequence_invalidate_raw_update");
1972
1973   prop = RNA_def_property(srna, "use_flip_x", PROP_BOOLEAN, PROP_NONE);
1974   RNA_def_property_boolean_sdna(prop, NULL, "flag", SEQ_FLIPX);
1975   RNA_def_property_ui_text(prop, "Flip X", "Flip on the X axis");
1976   RNA_def_property_update(prop, NC_SCENE | ND_SEQUENCER, "rna_Sequence_invalidate_raw_update");
1977
1978   prop = RNA_def_property(srna, "use_flip_y", PROP_BOOLEAN, PROP_NONE);
1979   RNA_def_property_boolean_sdna(prop, NULL, "flag", SEQ_FLIPY);
1980   RNA_def_property_ui_text(prop, "Flip Y", "Flip on the Y axis");
1981   RNA_def_property_update(prop, NC_SCENE | ND_SEQUENCER, "rna_Sequence_invalidate_raw_update");
1982
1983   prop = RNA_def_property(srna, "use_float", PROP_BOOLEAN, PROP_NONE);
1984   RNA_def_property_boolean_sdna(prop, NULL, "flag", SEQ_MAKE_FLOAT);
1985   RNA_def_property_ui_text(prop, "Convert Float", "Convert input to float data");
1986   RNA_def_property_update(prop, NC_SCENE | ND_SEQUENCER, "rna_Sequence_invalidate_raw_update");
1987
1988   prop = RNA_def_property(srna, "use_reverse_frames", PROP_BOOLEAN, PROP_NONE);
1989   RNA_def_property_boolean_sdna(prop, NULL, "flag", SEQ_REVERSE_FRAMES);
1990   RNA_def_property_ui_text(prop, "Flip Time", "Reverse frame order");
1991   RNA_def_property_update(prop, NC_SCENE | ND_SEQUENCER, "rna_Sequence_invalidate_raw_update");
1992
1993   prop = RNA_def_property(srna, "color_multiply", PROP_FLOAT, PROP_UNSIGNED);
1994   RNA_def_property_float_sdna(prop, NULL, "mul");
1995   RNA_def_property_range(prop, 0.0f, 20.0f);
1996   RNA_def_property_float_default(prop, 1.0f);
1997   RNA_def_property_ui_text(prop, "Multiply Colors", "");
1998   RNA_def_property_update(
1999       prop, NC_SCENE | ND_SEQUENCER, "rna_Sequence_invalidate_preprocessed_update");
2000
2001   prop = RNA_def_property(srna, "color_saturation", PROP_FLOAT, PROP_UNSIGNED);
2002   RNA_def_property_float_sdna(prop, NULL, "sat");
2003   RNA_def_property_range(prop, 0.0f, 20.0f);
2004   RNA_def_property_ui_range(prop, 0.0f, 2.0f, 3, 3);
2005   RNA_def_property_float_default(prop, 1.0f);
2006   RNA_def_property_ui_text(prop, "Saturation", "Adjust the intensity of the input's color");
2007   RNA_def_property_update(
2008       prop, NC_SCENE | ND_SEQUENCER, "rna_Sequence_invalidate_preprocessed_update");
2009
2010   prop = RNA_def_property(srna, "strobe", PROP_FLOAT, PROP_NONE);
2011   RNA_def_property_range(prop, 1.0f, 30.0f);
2012   RNA_def_property_ui_text(prop, "Strobe", "Only display every nth frame");
2013   RNA_def_property_update(prop, NC_SCENE | ND_SEQUENCER, "rna_Sequence_invalidate_raw_update");
2014
2015   prop = RNA_def_property(srna, "use_translation", PROP_BOOLEAN, PROP_NONE);
2016   RNA_def_property_boolean_sdna(prop, NULL, "flag", SEQ_USE_TRANSFORM);
2017   RNA_def_property_ui_text(prop, "Use Translation", "Translate image before processing");
2018   RNA_def_property_boolean_funcs(prop, NULL, "rna_Sequence_use_translation_set");
2019   RNA_def_property_update(prop, NC_SCENE | ND_SEQUENCER, "rna_Sequence_invalidate_raw_update");
2020
2021   prop = RNA_def_property(srna, "transform", PROP_POINTER, PROP_NONE);
2022   RNA_def_property_pointer_sdna(prop, NULL, "strip->transform");
2023   RNA_def_property_ui_text(prop, "Transform", "");
2024
2025   prop = RNA_def_property(srna, "use_crop", PROP_BOOLEAN, PROP_NONE);
2026   RNA_def_property_boolean_sdna(prop, NULL, "flag", SEQ_USE_CROP);
2027   RNA_def_property_ui_text(prop, "Use Crop", "Crop image before processing");
2028   RNA_def_property_boolean_funcs(prop, NULL, "rna_Sequence_use_crop_set");
2029   RNA_def_property_update(prop, NC_SCENE | ND_SEQUENCER, "rna_Sequence_invalidate_raw_update");
2030
2031   prop = RNA_def_property(srna, "crop", PROP_POINTER, PROP_NONE);
2032   RNA_def_property_pointer_sdna(prop, NULL, "strip->crop");
2033   RNA_def_property_ui_text(prop, "Crop", "");
2034 }
2035
2036 static void rna_def_proxy(StructRNA *srna)
2037 {
2038   PropertyRNA *prop;
2039
2040   prop = RNA_def_property(srna, "use_proxy", PROP_BOOLEAN, PROP_NONE);
2041   RNA_def_property_boolean_sdna(prop, NULL, "flag", SEQ_USE_PROXY);
2042   RNA_def_property_ui_text(
2043       prop, "Use Proxy / Timecode", "Use a preview proxy and/or timecode index for this strip");
2044   RNA_def_property_boolean_funcs(prop, NULL, "rna_Sequence_use_proxy_set");
2045   RNA_def_property_update(prop, NC_SCENE | ND_SEQUENCER, "rna_Sequence_invalidate_raw_update");
2046
2047   prop = RNA_def_property(srna, "proxy", PROP_POINTER, PROP_NONE);
2048   RNA_def_property_pointer_sdna(prop, NULL, "strip->proxy");
2049   RNA_def_property_ui_text(prop, "Proxy", "");
2050 }
2051
2052 static void rna_def_input(StructRNA *srna)
2053 {
2054   PropertyRNA *prop;
2055
2056   prop = RNA_def_property(srna, "animation_offset_start", PROP_INT, PROP_UNSIGNED);
2057   RNA_def_property_int_sdna(prop, NULL, "anim_startofs");
2058   RNA_def_property_clear_flag(prop, PROP_ANIMATABLE);
2059   RNA_def_property_int_funcs(
2060       prop, NULL, "rna_Sequence_anim_startofs_final_set", NULL); /* overlap tests */
2061   RNA_def_property_ui_text(prop, "Animation Start Offset", "Animation start offset (trim start)");
2062   RNA_def_property_update(
2063       prop, NC_SCENE | ND_SEQUENCER, "rna_Sequence_invalidate_preprocessed_update");
2064
2065   prop = RNA_def_property(srna, "animation_offset_end", PROP_INT, PROP_UNSIGNED);
2066   RNA_def_property_int_sdna(prop, NULL, "anim_endofs");
2067   RNA_def_property_clear_flag(prop, PROP_ANIMATABLE);
2068   RNA_def_property_int_funcs(
2069       prop, NULL, "rna_Sequence_anim_endofs_final_set", NULL); /* overlap tests */
2070   RNA_def_property_ui_text(prop, "Animation End Offset", "Animation end offset (trim end)");
2071   RNA_def_property_update(
2072       prop, NC_SCENE | ND_SEQUENCER, "rna_Sequence_invalidate_preprocessed_update");
2073 }
2074
2075 static void rna_def_effect_inputs(StructRNA *srna, int count)
2076 {
2077   PropertyRNA *prop;
2078
2079   prop = RNA_def_property(srna, "input_count", PROP_INT, PROP_UNSIGNED);
2080   RNA_def_property_clear_flag(prop, PROP_EDITABLE);
2081   RNA_def_property_int_funcs(prop, "rna_Sequence_input_count_get", NULL, NULL);
2082
2083   if (count >= 1) {
2084     prop = RNA_def_property(srna, "input_1", PROP_POINTER, PROP_NONE);
2085     RNA_def_property_pointer_sdna(prop, NULL, "seq1");
2086     RNA_def_property_flag(prop, PROP_EDITABLE | PROP_NEVER_NULL);
2087     RNA_def_property_ui_text(prop, "Input 1", "First input for the effect strip");
2088   }
2089
2090   if (count >= 2) {
2091     prop = RNA_def_property(srna, "input_2", PROP_POINTER, PROP_NONE);
2092     RNA_def_property_pointer_sdna(prop, NULL, "seq2");
2093     RNA_def_property_flag(prop, PROP_EDITABLE | PROP_NEVER_NULL);
2094     RNA_def_property_ui_text(prop, "Input 2", "Second input for the effect strip");
2095   }
2096
2097 #  if 0
2098   if (count == 3) {
2099     /* Not used by any effects (perhaps one day plugins?). */
2100     prop = RNA_def_property(srna, "input_3", PROP_POINTER, PROP_NONE);
2101     RNA_def_property_pointer_sdna(prop, NULL, "seq3");
2102     RNA_def_property_flag(prop, PROP_EDITABLE | PROP_NEVER_NULL);
2103     RNA_def_property_ui_text(prop, "Input 3", "Third input for the effect strip");
2104   }
2105 #  endif
2106 }
2107
2108 static void rna_def_color_management(StructRNA *srna)
2109 {
2110   PropertyRNA *prop;
2111
2112   prop = RNA_def_property(srna, "colorspace_settings", PROP_POINTER, PROP_NONE);
2113   RNA_def_property_pointer_sdna(prop, NULL, "strip->colorspace_settings");
2114   RNA_def_property_struct_type(prop, "ColorManagedInputColorspaceSettings");
2115   RNA_def_property_ui_text(prop, "Color Space Settings", "Input color space settings");
2116 }
2117
2118 static void rna_def_movie_types(StructRNA *srna)
2119 {
2120   PropertyRNA *prop;
2121
2122   prop = RNA_def_property(srna, "fps", PROP_FLOAT, PROP_NONE);
2123   RNA_def_property_ui_text(prop, "FPS", "Frames per second");
2124   RNA_def_property_clear_flag(prop, PROP_EDITABLE);
2125   RNA_def_property_float_funcs(prop, "rna_Sequence_fps_get", NULL, NULL);
2126 }
2127
2128 static void rna_def_image(BlenderRNA *brna)
2129 {
2130   StructRNA *srna;
2131   PropertyRNA *prop;
2132
2133   srna = RNA_def_struct(brna, "ImageSequence", "Sequence");
2134   RNA_def_struct_ui_text(srna, "Image Sequence", "Sequence strip to load one or more images");
2135   RNA_def_struct_sdna(srna, "Sequence");
2136
2137   prop = RNA_def_property(srna, "directory", PROP_STRING, PROP_DIRPATH);
2138   RNA_def_property_string_sdna(prop, NULL, "strip->dir");
2139   RNA_def_property_ui_text(prop, "Directory", "");
2140   RNA_def_property_update(prop, NC_SCENE | ND_SEQUENCER, "rna_Sequence_invalidate_raw_update");
2141
2142   prop = RNA_def_property(srna, "elements", PROP_COLLECTION, PROP_NONE);
2143   RNA_def_property_collection_sdna(prop, NULL, "strip->stripdata", NULL);
2144   RNA_def_property_struct_type(prop, "SequenceElement");
2145   RNA_def_property_ui_text(prop, "Elements", "");
2146   RNA_def_property_collection_funcs(prop,
2147                                     "rna_SequenceEditor_elements_begin",
2148                                     "rna_iterator_array_next",
2149                                     "rna_iterator_array_end",
2150                                     "rna_iterator_array_get",
2151                                     "rna_SequenceEditor_elements_length",
2152                                     NULL,
2153                                     NULL,
2154                                     NULL);
2155   RNA_api_sequence_elements(brna, prop);
2156
2157   /* multiview */
2158   prop = RNA_def_property(srna, "use_multiview", PROP_BOOLEAN, PROP_NONE);
2159   RNA_def_property_boolean_sdna(prop, NULL, "flag", SEQ_USE_VIEWS);
2160   RNA_def_property_ui_text(prop, "Use Multi-View", "Use Multiple Views (when available)");
2161   RNA_def_property_update(prop, NC_SCENE | ND_SEQUENCER, "rna_Sequence_views_format_update");
2162
2163   prop = RNA_def_property(srna, "views_format", PROP_ENUM, PROP_NONE);
2164   RNA_def_property_enum_sdna(prop, NULL, "views_format");
2165   RNA_def_property_enum_items(prop, rna_enum_views_format_items);
2166   RNA_def_property_ui_text(prop, "Views Format", "Mode to load image views");
2167   RNA_def_property_update(prop, NC_IMAGE | ND_DISPLAY, "rna_Sequence_views_format_update");
2168
2169   prop = RNA_def_property(srna, "stereo_3d_format", PROP_POINTER, PROP_NONE);
2170   RNA_def_property_pointer_sdna(prop, NULL, "stereo3d_format");
2171   RNA_def_property_flag(prop, PROP_NEVER_NULL);
2172   RNA_def_property_struct_type(prop, "Stereo3dFormat");
2173   RNA_def_property_ui_text(prop, "Stereo 3D Format", "Settings for stereo 3d");
2174
2175   rna_def_filter_video(srna);
2176   rna_def_proxy(srna);
2177   rna_def_input(srna);
2178   rna_def_color_management(srna);
2179 }
2180
2181 static void rna_def_meta(BlenderRNA *brna)
2182 {
2183   StructRNA *srna;
2184   PropertyRNA *prop;
2185
2186   srna = RNA_def_struct(brna, "MetaSequence", "Sequence");
2187   RNA_def_struct_ui_text(
2188       srna, "Meta Sequence", "Sequence strip to group other strips as a single sequence strip");
2189   RNA_def_struct_sdna(srna, "Sequence");
2190
2191   prop = RNA_def_property(srna, "sequences", PROP_COLLECTION, PROP_NONE);
2192   RNA_def_property_collection_sdna(prop, NULL, "seqbase", NULL);
2193   RNA_def_property_struct_type(prop, "Sequence");
2194   RNA_def_property_ui_text(prop, "Sequences", "");
2195
2196   rna_def_filter_video(srna);
2197   rna_def_proxy(srna);
2198   rna_def_input(srna);
2199 }
2200
2201 static void rna_def_scene(BlenderRNA *brna)
2202 {
2203   StructRNA *srna;
2204   PropertyRNA *prop;
2205
2206   srna = RNA_def_struct(brna, "SceneSequence", "Sequence");
2207   RNA_def_struct_ui_text(
2208       srna, "Scene Sequence", "Sequence strip to used the rendered image of a scene");
2209   RNA_def_struct_sdna(srna, "Sequence");
2210
2211   prop = RNA_def_property(srna, "scene", PROP_POINTER, PROP_NONE);
2212   RNA_def_property_flag(prop, PROP_EDITABLE);
2213   RNA_def_property_ui_text(prop, "Scene", "Scene that this sequence uses");
2214   RNA_def_property_update(prop, NC_SCENE | ND_SEQUENCER, "rna_Sequence_invalidate_raw_update");
2215
2216   prop = RNA_def_property(srna, "scene_camera", PROP_POINTER, PROP_NONE);
2217   RNA_def_property_flag(prop, PROP_EDITABLE);
2218   RNA_def_property_pointer_funcs(prop, NULL, NULL, NULL, "rna_Camera_object_poll");
2219   RNA_def_property_ui_text(prop, "Camera Override", "Override the scenes active camera");
2220   RNA_def_property_update(prop, NC_SCENE | ND_SEQUENCER, "rna_Sequence_invalidate_raw_update");
2221
2222   prop = RNA_def_property(srna, "use_sequence", PROP_BOOLEAN, PROP_NONE);
2223   RNA_def_property_boolean_sdna(prop, NULL, "flag", SEQ_SCENE_STRIPS);
2224   RNA_def_property_ui_text(
2225       prop, "Use Sequence", "Use scenes sequence strips directly, instead of rendering");
2226   RNA_def_property_update(prop, NC_SCENE | ND_SEQUENCER, "rna_Sequence_use_sequence");
2227
2228   prop = RNA_def_property(srna, "use_grease_pencil", PROP_BOOLEAN, PROP_NONE);
2229   RNA_def_property_boolean_negative_sdna(prop, NULL, "flag", SEQ_SCENE_NO_GPENCIL);
2230   RNA_def_property_ui_text(
2231       prop, "Use Grease Pencil", "Show Grease Pencil strokes in OpenGL previews");
2232   RNA_def_property_update(prop, NC_SCENE | ND_SEQUENCER, NULL);
2233
2234   rna_def_filter_video(srna);
2235   rna_def_proxy(srna);
2236   rna_def_input(srna);
2237   rna_def_movie_types(srna);
2238 }
2239
2240 static void rna_def_movie(BlenderRNA *brna)
2241 {
2242   StructRNA *srna;
2243   PropertyRNA *prop;
2244   FunctionRNA *func;
2245   PropertyRNA *parm;
2246
2247   srna = RNA_def_struct(brna, "MovieSequence", "Sequence");
2248   RNA_def_struct_ui_text(srna, "Movie Sequence", "Sequence strip to load a video");
2249   RNA_def_struct_sdna(srna, "Sequence");
2250
2251   prop = RNA_def_property(srna, "mpeg_preseek", PROP_INT, PROP_NONE);
2252   RNA_def_property_int_sdna(prop, NULL, "anim_preseek");
2253   RNA_def_property_range(prop, 0, 50);
2254   RNA_def_property_ui_text(prop, "MPEG Preseek", "For MPEG movies, preseek this many frames");
2255   RNA_def_property_update(prop, NC_SCENE | ND_SEQUENCER, NULL);
2256
2257   prop = RNA_def_property(srna, "stream_index", PROP_INT, PROP_NONE);
2258   RNA_def_property_int_sdna(prop, NULL, "streamindex");
2259   RNA_def_property_range(prop, 0, 20);
2260   RNA_def_property_ui_text(
2261       prop,
2262       "Stream Index",
2263       "For files with several movie streams, use the stream with the given index");
2264   RNA_def_property_update(prop, NC_SCENE | ND_SEQUENCER, "rna_Sequence_reopen_files_update");
2265
2266   prop = RNA_def_property(srna, "elements", PROP_COLLECTION, PROP_NONE);
2267   RNA_def_property_collection_sdna(prop, NULL, "strip->stripdata", NULL);
2268   RNA_def_property_struct_type(prop, "SequenceElement");
2269   RNA_def_property_ui_text(prop, "Elements", "");
2270   RNA_def_property_collection_funcs(prop,
2271                                     "rna_SequenceEditor_elements_begin",
2272                                     "rna_iterator_array_next",
2273                                     "rna_iterator_array_end",
2274                                     "rna_iterator_array_get",
2275                                     "rna_SequenceEditor_elements_length",
2276                                     NULL,
2277                                     NULL,
2278                                     NULL);
2279
2280   prop = RNA_def_property(srna, "filepath", PROP_STRING, PROP_FILEPATH);
2281   RNA_def_property_ui_text(prop, "File", "");
2282   RNA_def_property_string_funcs(prop,
2283                                 "rna_Sequence_filepath_get",
2284                                 "rna_Sequence_filepath_length",
2285                                 "rna_Sequence_filepath_set");
2286   RNA_def_property_update(prop, NC_SCENE | ND_SEQUENCER, "rna_Sequence_filepath_update");
2287
2288   /* metadata */
2289   func = RNA_def_function(srna, "metadata", "rna_MovieSequence_metadata_get");
2290   RNA_def_function_ui_description(func, "Retrieve metadata of the movie file");
2291   /* return type */
2292   parm = RNA_def_pointer(
2293       func, "metadata", "IDPropertyWrapPtr", "", "Dict-like object containing the metadata");
2294   RNA_def_parameter_flags(parm, 0, PARM_RNAPTR);
2295   RNA_def_function_return(func, parm);
2296
2297   /* multiview */
2298   prop = RNA_def_property(srna, "use_multiview", PROP_BOOLEAN, PROP_NONE);
2299   RNA_def_property_boolean_sdna(prop, NULL, "flag", SEQ_USE_VIEWS);
2300   RNA_def_property_ui_text(prop, "Use Multi-View", "Use Multiple Views (when available)");
2301   RNA_def_property_update(prop, NC_SCENE | ND_SEQUENCER, "rna_Sequence_views_format_update");
2302
2303   prop = RNA_def_property(srna, "views_format", PROP_ENUM, PROP_NONE);
2304   RNA_def_property_enum_sdna(prop, NULL, "views_format");
2305   RNA_def_property_enum_items(prop, rna_enum_views_format_items);
2306   RNA_def_property_ui_text(prop, "Views Format", "Mode to load movie views");
2307   RNA_def_property_update(prop, NC_IMAGE | ND_DISPLAY, "rna_Sequence_views_format_update");
2308
2309   prop = RNA_def_property(srna, "stereo_3d_format", PROP_POINTER, PROP_NONE);
2310   RNA_def_property_pointer_sdna(prop, NULL, "stereo3d_format");
2311   RNA_def_property_flag(prop, PROP_NEVER_NULL);
2312   RNA_def_property_struct_type(prop, "Stereo3dFormat");
2313   RNA_def_property_ui_text(prop, "Stereo 3D Format", "Settings for stereo 3d");
2314
2315   rna_def_filter_video(srna);
2316   rna_def_proxy(srna);
2317   rna_def_input(srna);
2318   rna_def_color_management(srna);
2319   rna_def_movie_types(srna);
2320 }
2321
2322 static void rna_def_movieclip(BlenderRNA *brna)
2323 {
2324   StructRNA *srna;
2325   PropertyRNA *prop;
2326
2327   srna = RNA_def_struct(brna, "MovieClipSequence", "Sequence");
2328   RNA_def_struct_ui_text(
2329       srna, "MovieClip Sequence", "Sequence strip to load a video from the clip editor");
2330   RNA_def_struct_sdna(srna, "Sequence");
2331
2332   /* TODO - add clip property? */
2333
2334   prop = RNA_def_property(srna, "undistort", PROP_BOOLEAN, PROP_NONE);
2335   RNA_def_property_boolean_sdna(prop, NULL, "clip_flag", SEQ_MOVIECLIP_RENDER_UNDISTORTED);
2336   RNA_def_property_ui_text(prop, "Undistort Clip", "Use the undistorted version of the clip");
2337   RNA_def_property_update(prop, NC_SCENE | ND_SEQUENCER, "rna_Sequence_invalidate_raw_update");
2338
2339   prop = RNA_def_property(srna, "stabilize2d", PROP_BOOLEAN, PROP_NONE);
2340   RNA_def_property_boolean_sdna(prop, NULL, "clip_flag", SEQ_MOVIECLIP_RENDER_STABILIZED);
2341   RNA_def_property_ui_text(prop, "Stabilize 2D Clip", "Use the 2D stabilized version of the clip");
2342   RNA_def_property_update(prop, NC_SCENE | ND_SEQUENCER, "rna_Sequence_invalidate_raw_update");
2343
2344   rna_def_filter_video(srna);
2345   rna_def_input(srna);
2346   rna_def_movie_types(srna);
2347 }
2348
2349 static void rna_def_mask(BlenderRNA *brna)
2350 {
2351   StructRNA *srna;
2352   PropertyRNA *prop;
2353
2354   srna = RNA_def_struct(brna, "MaskSequence", "Sequence");
2355   RNA_def_struct_ui_text(srna, "Mask Sequence", "Sequence strip to load a video from a mask");
2356   RNA_def_struct_sdna(srna, "Sequence");
2357
2358   prop = RNA_def_property(srna, "mask", PROP_POINTER, PROP_NONE);
2359   RNA_def_property_flag(prop, PROP_EDITABLE);
2360   RNA_def_property_ui_text(prop, "Mask", "Mask that this sequence uses");
2361   RNA_def_property_update(prop, NC_SCENE | ND_SEQUENCER, "rna_Sequence_invalidate_raw_update");
2362
2363   rna_def_filter_video(srna);
2364   rna_def_input(srna);
2365 }
2366
2367 static void rna_def_sound(BlenderRNA *brna)
2368 {
2369   StructRNA *srna;
2370   PropertyRNA *prop;
2371
2372   srna = RNA_def_struct(brna, "SoundSequence", "Sequence");
2373   RNA_def_struct_ui_text(srna,
2374                          "Sound Sequence",
2375                          "Sequence strip defining a sound to be played over a period of time");
2376   RNA_def_struct_sdna(srna, "Sequence");
2377
2378   prop = RNA_def_property(srna, "sound", PROP_POINTER, PROP_NONE);
2379   RNA_def_property_flag(prop, PROP_EDITABLE);
2380   RNA_def_property_struct_type(prop, "Sound");
2381   RNA_def_property_ui_text(prop, "Sound", "Sound data-block used by this sequence");
2382   RNA_def_property_update(prop, NC_SCENE | ND_SEQUENCER, "rna_Sequence_sound_update");
2383
2384   prop = RNA_def_property(srna, "volume", PROP_FLOAT, PROP_NONE);
2385   RNA_def_property_float_sdna(prop, NULL, "volume");
2386   RNA_def_property_range(prop, 0.0f, 100.0f);
2387   RNA_def_property_ui_text(prop, "Volume", "Playback volume of the sound");
2388   RNA_def_property_translation_context(prop, BLT_I18NCONTEXT_ID_SOUND);
2389   RNA_def_property_update(prop, NC_SCENE | ND_SEQUENCER, "rna_Sequence_audio_update");
2390
2391   prop = RNA_def_property(srna, "pitch", PROP_FLOAT, PROP_NONE);
2392   RNA_def_property_float_sdna(prop, NULL, "pitch");
2393   RNA_def_property_range(prop, 0.1f, 10.0f);
2394   RNA_def_property_ui_text(prop, "Pitch", "Playback pitch of the sound");
2395   RNA_def_property_translation_context(prop, BLT_I18NCONTEXT_ID_SOUND);
2396   RNA_def_property_update(prop, NC_SCENE | ND_SEQUENCER, "rna_Sequence_audio_update");
2397
2398   prop = RNA_def_property(srna, "pan", PROP_FLOAT, PROP_NONE);
2399   RNA_def_property_float_sdna(prop, NULL, "pan");
2400   RNA_def_property_range(prop, -2.0f, 2.0f);
2401   RNA_def_property_ui_text(prop, "Pan", "Playback panning of the sound (only for Mono sources)");
2402   RNA_def_property_update(prop, NC_SCENE | ND_SEQUENCER, "rna_Sequence_audio_update");
2403
2404   prop = RNA_def_property(srna, "show_waveform", PROP_BOOLEAN, PROP_NONE);
2405   RNA_def_property_boolean_sdna(prop, NULL, "flag", SEQ_AUDIO_DRAW_WAVEFORM);
2406   RNA_def_property_ui_text(prop, "Display Waveform", "Display the audio waveform inside the clip");
2407   RNA_def_property_update(prop, NC_SCENE | ND_SEQUENCER, NULL);
2408
2409   rna_def_input(srna);
2410 }
2411
2412 static void rna_def_effect(BlenderRNA *brna)
2413 {
2414   StructRNA *srna;
2415
2416   srna = RNA_def_struct(brna, "EffectSequence", "Sequence");
2417   RNA_def_struct_ui_text(
2418       srna,
2419       "Effect Sequence",
2420       "Sequence strip applying an effect on the images created by other strips");
2421   RNA_def_struct_sdna(srna, "Sequence");
2422
2423   rna_def_filter_video(srna);
2424   rna_def_proxy(srna);
2425 }
2426
2427 static void rna_def_multicam(StructRNA *srna)
2428 {
2429   PropertyRNA *prop;
2430
2431   prop = RNA_def_property(srna, "multicam_source", PROP_INT, PROP_UNSIGNED);
2432   RNA_def_property_int_sdna(prop, NULL, "multicam_source");
2433   RNA_def_property_range(prop, 0, MAXSEQ - 1);
2434   RNA_def_property_ui_text(prop, "Multicam Source Channel", "");
2435   RNA_def_property_update(prop, NC_SCENE | ND_SEQUENCER, "rna_Sequence_invalidate_raw_update");
2436
2437   rna_def_input(srna);
2438 }
2439
2440 static void rna_def_wipe(StructRNA *srna)
2441 {
2442   PropertyRNA *prop;
2443
2444   static const EnumPropertyItem wipe_type_items[] = {
2445       {0, "SINGLE", 0, "Single", ""},
2446       {1, "DOUBLE", 0, "Double", ""},
2447       /* not used yet {2, "BOX", 0, "Box", ""}, */
2448       /* not used yet {3, "CROSS", 0, "Cross", ""}, */
2449       {4, "IRIS", 0, "Iris", ""},
2450       {5, "CLOCK", 0, "Clock", ""},
2451       {0, NULL, 0, NULL, NULL},
2452   };
2453
2454   static const EnumPropertyItem wipe_direction_items[] = {
2455       {0, "OUT", 0, "Out", ""},
2456       {1, "IN", 0, "In", ""},
2457       {0, NULL, 0, NULL, NULL},
2458   };
2459
2460   RNA_def_struct_sdna_from(srna, "WipeVars", "effectdata");
2461
2462   prop = RNA_def_property(srna, "blur_width", PROP_FLOAT, PROP_FACTOR);
2463   RNA_def_property_float_sdna(prop, NULL, "edgeWidth");
2464   RNA_def_property_range(prop, 0.0f, 1.0f);
2465   RNA_def_property_ui_text(
2466       prop, "Blur Width", "Width of the blur edge, in percentage relative to the image size");
2467   RNA_def_property_update(
2468       prop, NC_SCENE | ND_SEQUENCER, "rna_Sequence_invalidate_preprocessed_update");
2469
2470   prop = RNA_def_property(srna, "angle", PROP_FLOAT, PROP_ANGLE);
2471   RNA_def_property_range(prop, DEG2RADF(-90.0f), DEG2RADF(90.0f));
2472   RNA_def_property_ui_text(prop, "Angle", "Edge angle");
2473   RNA_def_property_update(
2474       prop, NC_SCENE | ND_SEQUENCER, "rna_Sequence_invalidate_preprocessed_update");
2475
2476   prop = RNA_def_property(srna, "direction", PROP_ENUM, PROP_NONE);
2477   RNA_def_property_enum_sdna(prop, NULL, "forward");
2478   RNA_def_property_enum_items(prop, wipe_direction_items);
2479   RNA_def_property_ui_text(prop, "Direction", "Wipe direction");
2480   RNA_def_property_update(
2481       prop, NC_SCENE | ND_SEQUENCER, "rna_Sequence_invalidate_preprocessed_update");
2482
2483   prop = RNA_def_property(srna, "transition_type", PROP_ENUM, PROP_NONE);
2484   RNA_def_property_enum_sdna(prop, NULL, "wipetype");
2485   RNA_def_property_enum_items(prop, wipe_type_items);
2486   RNA_def_property_translation_context(prop, BLT_I18NCONTEXT_ID_SEQUENCE);
2487   RNA_def_property_ui_text(prop, "Transition Type", "");
2488   RNA_def_property_update(
2489       prop, NC_SCENE | ND_SEQUENCER, "rna_Sequence_invalidate_preprocessed_update");
2490 }
2491
2492 static void rna_def_glow(StructRNA *srna)
2493 {
2494   PropertyRNA *prop;
2495
2496   RNA_def_struct_sdna_from(srna, "GlowVars", "effectdata");
2497
2498   prop = RNA_def_property(srna, "threshold", PROP_FLOAT, PROP_FACTOR);
2499   RNA_def_property_float_sdna(prop, NULL, "fMini");
2500   RNA_def_property_range(prop, 0.0f, 1.0f);
2501   RNA_def_property_ui_text(prop, "Threshold", "Minimum intensity to trigger a glow");
2502   RNA_def_property_update(
2503       prop, NC_SCENE | ND_SEQUENCER, "rna_Sequence_invalidate_preprocessed_update");
2504
2505   prop = RNA_def_property(srna, "clamp", PROP_FLOAT, PROP_FACTOR);
2506   RNA_def_property_float_sdna(prop, NULL, "fClamp");
2507   RNA_def_property_range(prop, 0.0f, 1.0f);
2508   RNA_def_property_ui_text(prop, "Clamp", "Brightness limit of intensity");
2509   RNA_def_property_update(
2510       prop, NC_SCENE | ND_SEQUENCER, "rna_Sequence_invalidate_preprocessed_update");
2511
2512   prop = RNA_def_property(srna, "boost_factor", PROP_FLOAT, PROP_NONE);
2513   RNA_def_property_float_sdna(prop, NULL, "fBoost");
2514   RNA_def_property_range(prop, 0.0f, 10.0f);
2515   RNA_def_property_ui_text(prop, "Boost Factor", "Brightness multiplier");
2516   RNA_def_property_update(
2517       prop, NC_SCENE | ND_SEQUENCER, "rna_Sequence_invalidate_preprocessed_update");
2518
2519   prop = RNA_def_property(srna, "blur_radius", PROP_FLOAT, PROP_NONE);
2520   RNA_def_property_float_sdna(prop, NULL, "dDist");
2521   RNA_def_property_range(prop, 0.5f, 20.0f);
2522   RNA_def_property_ui_text(prop, "Blur Distance", "Radius of glow effect");
2523   RNA_def_property_update(
2524       prop, NC_SCENE | ND_SEQUENCER, "rna_Sequence_invalidate_preprocessed_update");
2525
2526   prop = RNA_def_property(srna, "quality", PROP_INT, PROP_NONE);
2527   RNA_def_property_int_sdna(prop, NULL, "dQuality");
2528   RNA_def_property_range(prop, 1, 5);
2529   RNA_def_property_ui_text(prop, "Quality", "Accuracy of the blur effect");
2530   RNA_def_property_update(
2531       prop, NC_SCENE | ND_SEQUENCER, "rna_Sequence_invalidate_preprocessed_update");
2532
2533   prop = RNA_def_property(srna, "use_only_boost", PROP_BOOLEAN, PROP_NONE);
2534   RNA_def_property_boolean_sdna(prop, NULL, "bNoComp", 0);
2535   RNA_def_property_ui_text(prop, "Only Boost", "Show the glow buffer only");
2536   RNA_def_property_update(
2537       prop, NC_SCENE | ND_SEQUENCER, "rna_Sequence_invalidate_preprocessed_update");
2538 }
2539
2540 static void rna_def_transform(StructRNA *srna)
2541 {
2542   PropertyRNA *prop;
2543
2544   static const EnumPropertyItem interpolation_items[] = {
2545       {0, "NONE", 0, "None", "No interpolation"},
2546       {1, "BILINEAR", 0, "Bilinear", "Bilinear interpolation"},
2547       {2, "BICUBIC", 0, "Bicubic", "Bicubic interpolation"},
2548       {0, NULL, 0, NULL, NULL},
2549   };
2550
2551   static const EnumPropertyItem translation_unit_items[] = {
2552       {0, "PIXELS", 0, "Pixels", ""},
2553       {1, "PERCENT", 0, "Percent", ""},
2554       {0, NULL, 0, NULL, NULL},
2555   };
2556
2557   RNA_def_struct_sdna_from(srna, "TransformVars", "effectdata");
2558
2559   prop = RNA_def_property(srna, "scale_start_x", PROP_FLOAT, PROP_UNSIGNED);
2560   RNA_def_property_float_sdna(prop, NULL, "ScalexIni");
2561   RNA_def_property_ui_text(prop, "Scale X", "Amount to scale the input in the X axis");
2562   RNA_def_property_ui_range(prop, 0, 10, 3, 6);
2563   RNA_def_property_update(
2564       prop, NC_SCENE | ND_SEQUENCER, "rna_Sequence_invalidate_preprocessed_update");
2565
2566   prop = RNA_def_property(srna, "scale_start_y", PROP_FLOAT, PROP_UNSIGNED);
2567   RNA_def_property_float_sdna(prop, NULL, "ScaleyIni");
2568   RNA_def_property_ui_text(prop, "Scale Y", "Amount to scale the input in the Y axis");
2569   RNA_def_property_ui_range(prop, 0, 10, 3, 6);
2570   RNA_def_property_update(
2571       prop, NC_SCENE | ND_SEQUENCER, "rna_Sequence_invalidate_preprocessed_update");
2572
2573   prop = RNA_def_property(srna, "use_uniform_scale", PROP_BOOLEAN, PROP_NONE);
2574   RNA_def_property_boolean_sdna(prop, NULL, "uniform_scale", 0);
2575   RNA_def_property_ui_text(prop, "Uniform Scale", "Scale uniformly, preserving aspect ratio");
2576   RNA_def_property_update(
2577       prop, NC_SCENE | ND_SEQUENCER, "rna_Sequence_invalidate_preprocessed_update");
2578
2579   prop = RNA_def_property(srna, "translate_start_x", PROP_FLOAT, PROP_NONE);
2580   RNA_def_property_float_sdna(prop, NULL, "xIni");
2581   RNA_def_property_ui_text(prop, "Translate X", "Amount to move the input on the X axis");
2582   RNA_def_property_ui_range(prop, -4000.0f, 4000.0f, 3, 6);
2583   RNA_def_property_update(
2584       prop, NC_SCENE | ND_SEQUENCER, "rna_Sequence_invalidate_preprocessed_update");
2585
2586   prop = RNA_def_property(srna, "translate_start_y", PROP_FLOAT, PROP_NONE);
2587   RNA_def_property_float_sdna(prop, NULL, "yIni");
2588   RNA_def_property_ui_text(prop, "Translate Y", "Amount to move the input on the Y axis");
2589   RNA_def_property_ui_range(prop, -4000.0f, 4000.0f, 3, 6);
2590   RNA_def_property_update(
2591       prop, NC_SCENE | ND_SEQUENCER, "rna_Sequence_invalidate_preprocessed_update");
2592
2593   prop = RNA_def_property(srna, "rotation_start", PROP_FLOAT, PROP_NONE);
2594   RNA_def_property_float_sdna(prop, NULL, "rotIni");
2595   RNA_def_property_ui_text(prop, "Rotation", "Degrees to rotate the input");
2596   RNA_def_property_update(
2597       prop, NC_SCENE | ND_SEQUENCER, "rna_Sequence_invalidate_preprocessed_update");
2598
2599   prop = RNA_def_property(srna, "translation_unit", PROP_ENUM, PROP_NONE);
2600   RNA_def_property_enum_sdna(prop, NULL, "percent");
2601   RNA_def_property_clear_flag(prop, PROP_ANIMATABLE); /* not meant to be animated */
2602   RNA_def_property_enum_items(prop, translation_unit_items);
2603   RNA_def_property_ui_text(prop, "Translation Unit", "Unit of measure to translate the input");
2604   RNA_def_property_update(
2605       prop, NC_SCENE | ND_SEQUENCER, "rna_Sequence_invalidate_preprocessed_update");
2606
2607   prop = RNA_def_property(srna, "interpolation", PROP_ENUM, PROP_NONE);
2608   RNA_def_property_enum_items(prop, interpolation_items);
2609   RNA_def_property_clear_flag(prop, PROP_ANIMATABLE); /* not meant to be animated */
2610   RNA_def_property_ui_text(
2611       prop, "Interpolation", "Method to determine how missing pixels are created");
2612   RNA_def_property_update(
2613       prop, NC_SCENE | ND_SEQUENCER, "rna_Sequence_invalidate_preprocessed_update");
2614 }
2615
2616 static void rna_def_solid_color(StructRNA *srna)
2617 {
2618   PropertyRNA *prop;
2619
2620   RNA_def_struct_sdna_from(srna, "SolidColorVars", "effectdata");
2621
2622   prop = RNA_def_property(srna, "color", PROP_FLOAT, PROP_COLOR_GAMMA);
2623   RNA_def_property_float_sdna(prop, NULL, "col");
2624   RNA_def_property_ui_text(prop, "Color", "Effect Strip color");
2625   RNA_def_property_update(
2626       prop, NC_SCENE | ND_SEQUENCER, "rna_Sequence_invalidate_preprocessed_update");
2627 }
2628
2629 static void rna_def_speed_control(StructRNA *srna)
2630 {
2631   PropertyRNA *prop;
2632
2633   RNA_def_struct_sdna_from(srna, "SpeedControlVars", "effectdata");
2634
2635   prop = RNA_def_property(srna, "multiply_speed", PROP_FLOAT, PROP_UNSIGNED);
2636   RNA_def_property_float_sdna(prop, NULL, "globalSpeed");
2637   RNA_def_property_clear_flag(prop, PROP_ANIMATABLE); /* seq->facf0 is used to animate this */
2638   RNA_def_property_ui_text(
2639       prop, "Multiply Speed", "Multiply the resulting speed after the speed factor");
2640   RNA_def_property_ui_range(prop, 0.0f, 100.0f, 1, -1);
2641   RNA_def_property_update(
2642       prop, NC_SCENE | ND_SEQUENCER, "rna_Sequence_invalidate_preprocessed_update");
2643
2644   prop = RNA_def_property(srna, "use_as_speed", PROP_BOOLEAN, PROP_NONE);
2645   RNA_def_property_boolean_sdna(prop, NULL, "flags", SEQ_SPEED_INTEGRATE);
2646   RNA_def_property_ui_text(
2647       prop, "Use as speed", "Interpret the value as speed instead of a frame number");
2648   RNA_def_property_update(
2649       prop, NC_SCENE | ND_SEQUENCER, "rna_Sequence_invalidate_preprocessed_update");
2650
2651   prop = RNA_def_property(srna, "use_scale_to_length", PROP_BOOLEAN, PROP_NONE);
2652   RNA_def_property_boolean_sdna(prop, NULL, "flags", SEQ_SPEED_COMPRESS_IPO_Y);
2653   RNA_def_property_ui_text(
2654       prop, "Scale to length", "Scale values from 0.0 to 1.0 to target sequence length");
2655   RNA_def_property_update(
2656       prop, NC_SCENE | ND_SEQUENCER, "rna_Sequence_invalidate_preprocessed_update");
2657 }
2658
2659 static void rna_def_gaussian_blur(StructRNA *srna)
2660 {
2661   PropertyRNA *prop;
2662
2663   RNA_def_struct_sdna_from(srna, "GaussianBlurVars", "effectdata");
2664   prop = RNA_def_property(srna, "size_x", PROP_FLOAT, PROP_UNSIGNED);
2665   RNA_def_property_ui_text(prop, "Size X", "Size of the blur along X axis");
2666   RNA_def_property_ui_range(prop, 0.0f, FLT_MAX, 1, -1);
2667   RNA_def_property_update(
2668       prop, NC_SCENE | ND_SEQUENCER, "rna_Sequence_invalidate_preprocessed_update");
2669
2670   prop = RNA_def_property(srna, "size_y", PROP_FLOAT, PROP_UNSIGNED);
2671   RNA_def_property_ui_text(prop, "Size Y", "Size of the blur along Y axis");
2672   RNA_def_property_ui_range(prop, 0.0f, FLT_MAX, 1, -1);
2673   RNA_def_property_update(
2674       prop, NC_SCENE | ND_SEQUENCER, "rna_Sequence_invalidate_preprocessed_update");
2675 }
2676
2677 static void rna_def_text(StructRNA *srna)
2678 {
2679   static const EnumPropertyItem text_align_x_items[] = {
2680       {SEQ_TEXT_ALIGN_X_LEFT, "LEFT", 0, "Left", ""},
2681       {SEQ_TEXT_ALIGN_X_CENTER, "CENTER", 0, "Center", ""},
2682       {SEQ_TEXT_ALIGN_X_RIGHT, "RIGHT", 0, "Right", ""},
2683       {0, NULL, 0, NULL, NULL},
2684   };
2685   static const EnumPropertyItem text_align_y_items[] = {
2686       {SEQ_TEXT_ALIGN_Y_TOP, "TOP", 0, "Top", ""},
2687       {SEQ_TEXT_ALIGN_Y_CENTER, "CENTER", 0, "Center", ""},
2688       {SEQ_TEXT_ALIGN_Y_BOTTOM, "BOTTOM", 0, "Bottom", ""},
2689       {0, NULL, 0, NULL, NULL},
2690   };
2691
2692   PropertyRNA *prop;
2693
2694   RNA_def_struct_sdna_from(srna, "TextVars", "effectdata");
2695
2696   prop = RNA_def_property(srna, "font", PROP_POINTER, PROP_NONE);
2697   RNA_def_property_pointer_sdna(prop, NULL, "text_font");
2698   RNA_def_property_ui_icon(prop, ICON_FILE_FONT, false);
2699   RNA_def_property_ui_text(prop, "Font", "Font of the text. Falls back to the UI font by default");
2700   RNA_def_property_flag(prop, PROP_EDITABLE);
2701   RNA_def_property_pointer_funcs(prop, NULL, "rna_Sequence_text_font_set", NULL, NULL);
2702   RNA_def_property_update(
2703       prop, NC_SCENE | ND_SEQUENCER, "rna_Sequence_invalidate_preprocessed_update");
2704
2705   prop = RNA_def_property(srna, "font_size", PROP_INT, PROP_UNSIGNED);
2706   RNA_def_property_int_sdna(prop, NULL, "text_size");
2707   RNA_def_property_ui_text(prop, "Size", "Size of the text");
2708   RNA_def_property_range(prop, 0.0, 2000);
2709   RNA_def_property_ui_range(prop, 0.0f, 1000, 1, -1);
2710   RNA_def_property_update(
2711       prop, NC_SCENE | ND_SEQUENCER, "rna_Sequence_invalidate_preprocessed_update");
2712
2713   prop = RNA_def_property(srna, "color", PROP_FLOAT, PROP_COLOR_GAMMA);
2714   RNA_def_property_float_sdna(prop, NULL, "color");
2715   RNA_def_property_ui_text(prop, "Color", "Text color");
2716   RNA_def_property_update(
2717       prop, NC_SCENE | ND_SEQUENCER, "rna_Sequence_invalidate_preprocessed_update");
2718
2719   prop = RNA_def_property(srna, "shadow_color", PROP_FLOAT, PROP_COLOR_GAMMA);
2720   RNA_def_property_float_sdna(prop, NULL, "shadow_color");
2721   RNA_def_property_ui_text(prop, "Shadow Color", "");
2722   RNA_def_property_update(
2723       prop, NC_SCENE | ND_SEQUENCER, "rna_Sequence_invalidate_preprocessed_update");
2724
2725   prop = RNA_def_property(srna, "location", PROP_FLOAT, PROP_XYZ);
2726   RNA_def_property_float_sdna(prop, NULL, "loc");
2727   RNA_def_property_ui_text(prop, "Location", "Location of the text");
2728   RNA_def_property_range(prop, -FLT_MAX, FLT_MAX);
2729   RNA_def_property_ui_range(prop, 0.0, 1.0, 1, -1);
2730   RNA_def_property_update(
2731       prop, NC_SCENE | ND_SEQUENCER, "rna_Sequence_invalidate_preprocessed_update");
2732
2733   prop = RNA_def_property(srna, "wrap_width", PROP_FLOAT, PROP_NONE);
2734   RNA_def_property_float_sdna(prop, NULL, "wrap_width");
2735   RNA_def_property_ui_text(prop, "Wrap Width", "Word wrap width as factor, zero disables");
2736   RNA_def_property_range(prop, 0, FLT_MAX);
2737   RNA_def_property_ui_range(prop, 0.0, 1.0, 1, -1);
2738   RNA_def_property_update(
2739       prop, NC_SCENE | ND_SEQUENCER, "rna_Sequence_invalidate_preprocessed_update");
2740
2741   prop = RNA_def_property(srna, "align_x", PROP_ENUM, PROP_NONE);
2742   RNA_def_property_enum_sdna(prop, NULL, "align");
2743   RNA_def_property_enum_items(prop, text_align_x_items);
2744   RNA_def_property_ui_text(prop, "Align X", "Align the text along the X axis");
2745   RNA_def_property_update(
2746       prop, NC_SCENE | ND_SEQUENCER, "rna_Sequence_invalidate_preprocessed_update");
2747
2748   prop = RNA_def_property(srna, "align_y", PROP_ENUM, PROP_NONE);
2749   RNA_def_property_enum_sdna(prop, NULL, "align_y");
2750   RNA_def_property_enum_items(prop, text_align_y_items);
2751   RNA_def_property_ui_text(prop, "Align Y", "Align the image along the Y axis");
2752   RNA_def_property_update(
2753       prop, NC_SCENE | ND_SEQUENCER, "rna_Sequence_invalidate_preprocessed_update");
2754
2755   prop = RNA_def_property(srna, "text", PROP_STRING, PROP_NONE);
2756   RNA_def_property_ui_text(prop, "Text", "Text that will be displayed");
2757   RNA_def_property_update(
2758       prop, NC_SCENE | ND_SEQUENCER, "rna_Sequence_invalidate_preprocessed_update");
2759
2760   prop = RNA_def_property(srna, "use_shadow", PROP_BOOLEAN, PROP_NONE);
2761   RNA_def_property_boolean_sdna(prop, NULL, "flag", SEQ_TEXT_SHADOW);
2762   RNA_def_property_ui_text(prop, "Shadow", "Draw text with shadow");
2763   RNA_def_property_update(
2764       prop, NC_SCENE | ND_SEQUENCER, "rna_Sequence_invalidate_preprocessed_update");
2765 }
2766
2767 static void rna_def_color_mix(StructRNA *srna)
2768 {
2769   static EnumPropertyItem blend_color_items[] = {
2770       {SEQ_TYPE_ADD, "ADD", 0, "Add", ""},
2771       {SEQ_TYPE_SUB, "SUBTRACT", 0, "Subtract", ""},
2772       {SEQ_TYPE_MUL, "MULTIPLY", 0, "Multiply", ""},
2773       {SEQ_TYPE_LIGHTEN, "LIGHTEN", 0, "Lighten", ""},
2774       {SEQ_TYPE_DARKEN, "DARKEN", 0, "Darken", ""},
2775       {SEQ_TYPE_SCREEN, "SCREEN", 0, "Screen", ""},
2776       {SEQ_TYPE_OVERLAY, "OVERLAY", 0, "Overlay", ""},
2777       {SEQ_TYPE_DODGE, "DODGE", 0, "Dodge", ""},
2778       {SEQ_TYPE_BURN, "BURN", 0, "Burn", ""},
2779       {SEQ_TYPE_LINEAR_BURN, "LINEAR_BURN", 0, "Linear Burn", ""},
2780       {SEQ_TYPE_SOFT_LIGHT, "SOFT_LIGHT", 0, "Soft Light", ""},
2781       {SEQ_TYPE_HARD_LIGHT, "HARD_LIGHT", 0, "Hard Light", ""},
2782       {SEQ_TYPE_PIN_LIGHT, "PIN_LIGHT", 0, "Pin Light", ""},
2783       {SEQ_TYPE_LIN_LIGHT, "LINEAR_LIGHT", 0, "Linear Light", ""},
2784       {SEQ_TYPE_VIVID_LIGHT, "VIVID_LIGHT", 0, "Vivid Light", ""},
2785       {SEQ_TYPE_BLEND_COLOR, "COLOR", 0, "Color", ""},
2786       {SEQ_TYPE_HUE, "HUE", 0, "Hue", ""},
2787       {SEQ_TYPE_SATURATION, "SATURATION", 0, "Saturation", ""},
2788       {SEQ_TYPE_VALUE, "VALUE", 0, "Value", ""},
2789       {SEQ_TYPE_DIFFERENCE, "DIFFERENCE", 0, "Difference", ""},
2790       {SEQ_TYPE_EXCLUSION, "EXCLUSION", 0, "Exclusion", ""},
2791       {0, NULL, 0, NULL, NULL},
2792   };
2793
2794   PropertyRNA *prop;
2795
2796   RNA_def_struct_sdna_from(srna, "ColorMixVars", "effectdata");
2797
2798   prop = RNA_def_property(srna, "blend_effect", PROP_ENUM, PROP_NONE);
2799   RNA_def_property_enum_sdna(prop, NULL, "blend_effect");
2800   RNA_def_property_enum_items(prop, blend_color_items);
2801   RNA_def_property_ui_text(
2802       prop, "Blend Effect", "Method for controlling how the strip combines with other strips");
2803   RNA_def_property_update(
2804       prop, NC_SCENE | ND_SEQUENCER, "rna_Sequence_invalidate_preprocessed_update");
2805
2806   prop = RNA_def_property(srna, "factor", PROP_FLOAT, PROP_FACTOR);
2807   RNA_def_property_range(prop, 0.0f, 1.0f);
2808   RNA_def_property_ui_text(
2809       prop, "Blend Factor", "Percentage of how much the strip's colors affect other strips");
2810   RNA_def_property_update(
2811       prop, NC_SCENE | ND_SEQUENCER, "rna_Sequence_invalidate_preprocessed_update");
2812 }
2813
2814 static EffectInfo def_effects[] = {
2815     {"AddSequence", "Add Sequence", "Add Sequence", NULL, 2},
2816     {"AdjustmentSequence",
2817      "Adjustment Layer Sequence",
2818      "Sequence strip to perform filter adjustments to layers below",
2819      rna_def_input,
2820      0},
2821     {"AlphaOverSequence", "Alpha Over Sequence", "Alpha Over Sequence", NULL, 2},
2822     {"AlphaUnderSequence", "Alpha Under Sequence", "Alpha Under Sequence", NULL, 2},
2823     {"ColorSequence",
2824      "Color Sequence",
2825      "Sequence strip creating an image filled with a single color",
2826      rna_def_solid_color,
2827      0},
2828     {"CrossSequence", "Cross Sequence", "Cross Sequence", NULL, 2},
2829     {"GammaCrossSequence", "Gamma Cross Sequence", "Gamma Cross Sequence", NULL, 2},
2830     {"GlowSequence", "Glow Sequence", "Sequence strip creating a glow effect", rna_def_glow, 1},
2831     {"MulticamSequence",
2832      "Multicam Select Sequence",
2833      "Sequence strip to perform multicam editing",
2834      rna_def_multicam,
2835      0},
2836     {"MultiplySequence", "Multiply Sequence", "Multiply Sequence", NULL, 2},
2837     {"OverDropSequence", "Over Drop Sequence", "Over Drop Sequence", NULL, 2},
2838     {"SpeedControlSequence",
2839      "SpeedControl Sequence",
2840      "Sequence strip to control the speed of other strips",
2841      rna_def_speed_control,
2842      1},
2843     {"SubtractSequence", "Subtract Sequence", "Subtract Sequence", NULL, 2},
2844     {"TransformSequence",
2845      "Transform Sequence",
2846      "Sequence strip applying affine transformations to other strips",
2847      rna_def_transform,
2848      1},
2849     {"WipeSequence",
2850      "Wipe Sequence",
2851      "Sequence strip creating a wipe transition",
2852      rna_def_wipe,
2853      2},
2854     {"GaussianBlurSequence",
2855      "Gaussian Blur Sequence",
2856      "Sequence strip creating a gaussian blur",
2857      rna_def_gaussian_blur,
2858      1},
2859     {"TextSequence", "Text Sequence", "Sequence strip creating text", rna_def_text, 0},
2860     {"ColorMixSequence", "Color Mix Sequence", "Color Mix Sequence", rna_def_color_mix, 2},
2861     {"", "", "", NULL, 0},
2862 };
2863
2864 static void rna_def_effects(BlenderRNA *brna)
2865 {
2866   StructRNA *srna;
2867   EffectInfo *effect;
2868
2869   for (effect = def_effects; effect->struct_name[0] != '\0'; effect++) {
2870     srna = RNA_def_struct(brna, effect->struct_name, "EffectSequence");
2871     RNA_def_struct_ui_text(srna, effect->ui_name, effect->ui_desc);
2872     RNA_def_struct_sdna(srna, "Sequence");
2873
2874     rna_def_effect_inputs(srna, effect->inputs);
2875
2876     if (effect->func) {
2877       effect->func(srna);
2878     }
2879   }
2880 }
2881
2882 static void rna_def_modifier(BlenderRNA *brna)
2883 {
2884   StructRNA *srna;
2885   PropertyRNA *prop;
2886
2887   static const EnumPropertyItem mask_input_type_items[] = {
2888       {SEQUENCE_MASK_INPUT_STRIP, "STRIP", 0, "Strip", "Use sequencer strip as mask input"},
2889       {SEQUENCE_MASK_INPUT_ID, "ID", 0, "Mask", "Use mask ID as mask input"},
2890       {0, NULL, 0, NULL, NULL},
2891   };
2892
2893   static const EnumPropertyItem mask_time_items[] = {
2894       {SEQUENCE_MASK_TIME_RELATIVE,
2895        "RELATIVE",
2896        0,
2897        "Relative",
2898        "Mask animation is offset to start of strip"},
2899       {SEQUENCE_MASK_TIME_ABSOLUTE,
2900        "ABSOLUTE",
2901        0,
2902        "Absolute",
2903        "Mask animation is in sync with scene frame"},
2904       {0, NULL, 0, NULL, NULL},
2905   };
2906
2907   srna = RNA_def_struct(brna, "SequenceModifier", NULL);
2908   RNA_def_struct_sdna(srna, "SequenceModifierData");
2909   RNA_def_struct_ui_text(srna, "SequenceModifier", "Modifier for sequence strip");
2910   RNA_def_struct_refine_func(srna, "rna_SequenceModifier_refine");
2911   RNA_def_struct_path_func(srna, "rna_SequenceModifier_path");
2912
2913   prop = RNA_def_property(srna, "name", PROP_STRING, PROP_NONE);
2914   RNA_def_property_string_funcs(prop, NULL, NULL, "rna_SequenceModifier_name_set");
2915   RNA_def_property_ui_text(prop, "Name", "");
2916   RNA_def_struct_name_property(srna, prop);
2917   RNA_def_property_update(prop, NC_SCENE | ND_SEQUENCER, NULL);
2918
2919   prop = RNA_def_property(srna, "type", PROP_ENUM, PROP_NONE);
2920   RNA_def_property_clear_flag(prop, PROP_EDITABLE);
2921   RNA_def_property_enum_items(prop, rna_enum_sequence_modifier_type_items);
2922   RNA_def_property_ui_text(prop, "Type", "");
2923   RNA_def_property_update(prop, NC_SCENE | ND_SEQUENCER, NULL);
2924
2925   prop = RNA_def_property(srna, "mute", PROP_BOOLEAN, PROP_NONE);
2926   RNA_def_property_boolean_sdna(prop, NULL, "flag", SEQUENCE_MODIFIER_MUTE);
2927   RNA_def_property_ui_text(prop, "Mute", "Mute this modifier");
2928   RNA_def_property_ui_icon(prop, ICON_HIDE_OFF, -1);
2929   RNA_def_property_update(prop, NC_SCENE | ND_SEQUENCER, "rna_SequenceModifier_update");
2930
2931   prop = RNA_def_property(srna, "show_expanded", PROP_BOOLEAN, PROP_NONE);
2932   RNA_def_property_flag(prop, PROP_NO_DEG_UPDATE);
2933   RNA_def_property_boolean_sdna(prop, NULL, "flag", SEQUENCE_MODIFIER_EXPANDED);
2934   RNA_def_property_ui_text(prop, "Expanded", "Mute expanded settings for the modifier");
2935   RNA_def_property_ui_icon(prop, ICON_TRIA_RIGHT, 1);
2936   RNA_def_property_update(prop, NC_SCENE | ND_SEQUENCER, NULL);
2937
2938   prop = RNA_def_property(srna, "input_mask_type", PROP_ENUM, PROP_NONE);
2939   RNA_def_property_enum_sdna(prop, NULL, "mask_input_type");
2940   RNA_def_property_enum_items(prop, mask_input_type_items);
2941   RNA_def_property_ui_text(prop, "Mask Input Type", "Type of input data used for mask");
2942   RNA_def_property_update(prop, NC_SCENE | ND_SEQUENCER, "rna_SequenceModifier_update");
2943
2944   prop = RNA_def_property(srna, "mask_time", PROP_ENUM, PROP_NONE);
2945   RNA_def_property_enum_sdna(prop, NULL, "mask_time");
2946   RNA_def_property_enum_items(prop, mask_time_items);
2947   RNA_def_property_ui_text(prop, "Mask Time", "Time to use for the Mask animation");
2948   RNA_def_property_update(prop, NC_SCENE | ND_SEQUENCER, "rna_SequenceModifier_update");
2949
2950   prop = RNA_def_property(srna, "input_mask_strip", PROP_POINTER, PROP_NONE);
2951   RNA_def_property_pointer_sdna(prop, NULL, "mask_sequence");
2952   RNA_def_property_pointer_funcs(
2953       prop, NULL, NULL, NULL, "rna_SequenceModifier_otherSequence_poll");
2954   RNA_def_property_flag(prop, PROP_EDITABLE);
2955   RNA_def_property_ui_text(prop, "Mask Strip", "Strip used as mask input for the modifier");
2956   RNA_def_property_update(prop, NC_SCENE | ND_SEQUENCER, "rna_SequenceModifier_update");
2957
2958   prop = RNA_def_property(srna, "input_mask_id", PROP_POINTER, PROP_NONE);
2959   RNA_def_property_pointer_sdna(prop, NULL, "mask_id");
2960   RNA_def_property_flag(prop, PROP_EDITABLE);
2961   RNA_def_property_ui_text(prop, "Mask", "Mask ID used as mask input for the modifier");
2962   RNA_def_property_update(prop, NC_SCENE | ND_SEQUENCER, "rna_SequenceModifier_update");
2963 }
2964
2965 static void rna_def_colorbalance_modifier(BlenderRNA *brna)
2966 {
2967   StructRNA *srna;
2968   PropertyRNA *prop;
2969
2970   srna = RNA_def_struct(brna, "ColorBalanceModifier", "SequenceModifier");
2971   RNA_def_struct_sdna(srna, "ColorBalanceModifierData");
2972   RNA_def_struct_ui_text(
2973       srna, "ColorBalanceModifier", "Color balance modifier for sequence strip");
2974
2975   prop = RNA_def_property(srna, "color_balance", PROP_POINTER, PROP_NONE);
2976   RNA_def_property_struct_type(prop, "SequenceColorBalanceData");
2977
2978   prop = RNA_def_property(srna, "color_multiply", PROP_FLOAT, PROP_UNSIGNED);
2979   RNA_def_property_float_sdna(prop, NULL, "color_multiply");
2980   RNA_def_property_range(prop, 0.0f, 20.0f);
2981   RNA_def_property_float_default(prop, 1.0f);
2982   RNA_def_property_ui_text(prop, "Multiply Colors", "Multiply the intensity of each pixel");
2983   RNA_def_property_update(prop, NC_SCENE | ND_SEQUENCER, "rna_SequenceModifier_update");
2984 }
2985
2986 static void rna_def_whitebalance_modifier(BlenderRNA *brna)
2987 {
2988   StructRNA *srna;
2989   PropertyRNA *prop;
2990
2991   srna = RNA_def_struct(brna, "WhiteBalanceModifier", "SequenceModifier");
2992   RNA_def_struct_sdna(srna, "WhiteBalanceModifierData");
2993   RNA_def_struct_ui_text(
2994       srna, "WhiteBalanceModifier", "White balance modifier for sequence strip");
2995
2996   prop = RNA_def_property(srna, "white_value", PROP_FLOAT, PROP_COLOR_GAMMA);
2997   RNA_def_property_range(prop, 0.0, 1.0);
2998   RNA_def_property_float_sdna(prop, NULL, "white_value");
2999   RNA_def_property_ui_text(prop, "White value", "This color defines white in the strip");
3000   RNA_def_property_update(prop, NC_SCENE | ND_SEQUENCER, "rna_SequenceModifier_update");
3001 }
3002
3003 static void rna_def_curves_modifier(BlenderRNA *brna)
3004 {
3005   StructRNA *srna;
3006   PropertyRNA *prop;
3007
3008   srna = RNA_def_struct(brna, "CurvesModifier", "SequenceModifier");
3009   RNA_def_struct_sdna(srna, "CurvesModifierData");
3010   RNA_def_struct_ui_text(srna, "CurvesModifier", "RGB curves modifier for sequence strip");
3011
3012   prop = RNA_def_property(srna, "curve_mapping", PROP_POINTER, PROP_NONE);
3013   RNA_def_property_pointer_sdna(prop, NULL, "curve_mapping");
3014   RNA_def_property_struct_type(prop, "CurveMapping");
3015   RNA_def_property_ui_text(prop, "Curve Mapping", "");
3016   RNA_def_property_update(prop, NC_SCENE | ND_SEQUENCER, "rna_SequenceModifier_update");
3017 }
3018
3019 static void rna_def_hue_modifier(BlenderRNA *brna)
3020 {
3021   StructRNA *srna;
3022   PropertyRNA *prop;
3023
3024   srna = RNA_def_struct(brna, "HueCorrectModifier", "SequenceModifier");
3025   RNA_def_struct_sdna(srna, "HueCorrectModifierData");
3026   RNA_def_struct_ui_text(srna, "HueCorrectModifier", "Hue correction modifier for sequence strip");
3027
3028   prop = RNA_def_property(srna, "curve_mapping", PROP_POINTER, PROP_NONE);
3029   RNA_def_property_pointer_sdna(prop, NULL, "curve_mapping");
3030   RNA_def_property_struct_type(prop, "CurveMapping");
3031   RNA_def_property_ui_text(prop, "Curve Mapping", "");
3032   RNA_def_property_update(prop, NC_SCENE | ND_SEQUENCER, "rna_SequenceModifier_update");
3033 }
3034
3035 static void rna_def_brightcontrast_modifier(BlenderRNA *brna)
3036 {
3037   StructRNA *srna;
3038   PropertyRNA *prop;
3039
3040   srna = RNA_def_struct(brna, "BrightContrastModifier", "SequenceModifier");
3041   RNA_def_struct_sdna(srna, "BrightContrastModifierData");
3042   RNA_def_struct_ui_text(
3043       srna, "BrightContrastModifier", "Bright/contrast modifier data for sequence strip");
3044
3045   prop = RNA_def_property(srna, "bright", PROP_FLOAT, PROP_UNSIGNED);
3046   RNA_def_property_float_sdna(prop, NULL, "bright");
3047   RNA_def_property_range(prop, -FLT_MAX, FLT_MAX);
3048   RNA_def_property_ui_text(prop, "Bright", "Adjust the luminosity of the colors");
3049   RNA_def_property_update(prop, NC_SCENE | ND_SEQUENCER, "rna_SequenceModifier_update");
3050
3051   prop = RNA_def_property(srna, "contrast", PROP_FLOAT, PROP_UNSIGNED);
3052   RNA_def_property_float_sdna(prop, NULL, "contrast");
3053   RNA_def_property_range(prop, -FLT_MAX, FLT_MAX);
3054   RNA_def_property_ui_text(prop, "Contrast", "Adjust the difference in luminosity between pixels");
3055   RNA_def_property_update(prop, NC_SCENE | ND_SEQUENCER, "rna_SequenceModifier_update");
3056 }
3057
3058 static void rna_def_tonemap_modifier(BlenderRNA *brna)
3059 {
3060   StructRNA *srna;
3061   PropertyRNA *prop;
3062
3063   static const EnumPropertyItem type_items[] = {
3064       {SEQ_TONEMAP_RD_PHOTORECEPTOR, "RD_PHOTORECEPTOR", 0, "R/D Photoreceptor", ""},
3065       {SEQ_TONEMAP_RH_SIMPLE, "RH_SIMPLE", 0, "Rh Simple", ""},
3066       {0, NULL, 0, NULL, NULL},
3067   };
3068
3069   srna = RNA_def_struct(brna, "SequencerTonemapModifierData", "SequenceModifier");
3070   RNA_def_struct_sdna(srna, "SequencerTonemapModifierData");
3071   RNA_def_struct_ui_text(srna, "SequencerTonemapModifierData", "Tone mapping modifier");
3072
3073   prop = RNA_def_property(srna, "tonemap_type", PROP_ENUM, PROP_NONE);
3074   RNA_def_property_enum_sdna(prop, NULL, "type");
3075   RNA_def_property_enum_items(prop, type_items);
3076   RNA_def_property_ui_text(prop, "Tonemap Type", "Tone mapping algorithm");
3077   RNA_def_property_update(prop, NC_SCENE | ND_SEQUENCER, "rna_SequenceModifier_update");
3078
3079   prop = RNA_def_property(srna, "key", PROP_FLOAT, PROP_FACTOR);
3080   RNA_def_property_range(prop, 0.0f, 1.0f);
3081   RNA_def_property_ui_text(prop, "Key", "The value the average luminance is mapped to");
3082   RNA_def_property_update(prop, NC_SCENE | ND_SEQUENCER, "rna_SequenceModifier_update");
3083
3084   prop = RNA_def_property(srna, "offset", PROP_FLOAT, PROP_NONE);
3085   RNA_def_property_range(prop, 0.001f, 10.0f);
3086   RNA_def_property_ui_text(
3087       prop,
3088       "Offset",
3089       "Normally always 1, but can be used as an extra control to alter the brightness curve");
3090   RNA_def_property_update(prop, NC_SCENE | ND_SEQUENCER, "rna_SequenceModifier_update");
3091
3092   prop = RNA_def_property(srna, "gamma", PROP_FLOAT, PROP_NONE);
3093   RNA_def_property_range(prop, 0.001f, 3.0f);
3094   RNA_def_property_ui_text(prop, "Gamma", "If not used, set to 1");
3095   RNA_def_property_update(prop, NC_SCENE | ND_SEQUENCER, "rna_SequenceModifier_update");
3096
3097   prop = RNA_def_property(srna, "intensity", PROP_FLOAT, PROP_NONE);
3098   RNA_def_property_range(prop, -8.0f, 8.0f);
3099   RNA_def_property_ui_text(
3100       prop, "Intensity", "If less than zero, darkens image; otherwise, makes it brighter");
3101   RNA_def_property_update(prop, NC_SCENE | ND_SEQUENCER, "rna_SequenceModifier_update");
3102
3103   prop = RNA_def_property(srna, "contrast", PROP_FLOAT, PROP_FACTOR);
3104   RNA_def_property_range(prop, 0.0f, 1.0f);
3105   RNA_def_property_ui_text(prop, "Contrast", "Set to 0 to use estimate from input image");
3106   RNA_def_property_update(prop, NC_SCENE | ND_SEQUENCER, "rna_SequenceModifier_update");
3107
3108   prop = RNA_def_property(srna, "adaptation", PROP_FLOAT, PROP_FACTOR);
3109   RNA_def_property_range(prop, 0.0f, 1.0f);
3110   RNA_def_property_ui_text(prop, "Adaptation", "If 0, global; if 1, based on pixel intensity");
3111   RNA_def_property_update(prop, NC_SCENE | ND_SEQUENCER, "rna_SequenceModifier_update");
3112
3113   prop = RNA_def_property(srna, "correction", PROP_FLOAT, PROP_FACTOR);
3114   RNA_def_property_range(prop, 0.0f, 1.0f);
3115   RNA_def_property_ui_text(
3116       prop, "Color Correction", "If 0, same for all channels; if 1, each independent");
3117   RNA_def_property_update(prop, NC_SCENE | ND_SEQUENCER, "rna_SequenceModifier_update");
3118 }
3119
3120 static void rna_def_modifiers(BlenderRNA *brna)
3121 {
3122   rna_def_modifier(brna);
3123
3124   rna_def_colorbalance_modifier(brna);
3125   rna_def_curves_modifier(brna);
3126   rna_def_hue_modifier(brna);
3127   rna_def_brightcontrast_modifier(brna);
3128   rna_def_whitebalance_modifier(brna);
3129   rna_def_tonemap_modifier(brna);
3130 }
3131
3132 void RNA_def_sequencer(BlenderRNA *brna)
3133 {
3134   rna_def_color_balance(brna);
3135
3136   rna_def_strip_element(brna);
3137   rna_def_strip_proxy(brna);
3138   rna_def_strip_color_balance(brna);
3139   rna_def_strip_crop(brna);
3140   rna_def_strip_transform(brna);
3141
3142   rna_def_sequence(brna);
3143   rna_def_editor(brna);
3144
3145   rna_def_image(brna);
3146   rna_def_meta(brna);
3147   rna_def_scene(brna);
3148   rna_def_movie(brna);
3149   rna_def_movieclip(brna);
3150   rna_def_mask(brna);
3151   rna_def_sound(brna);
3152   rna_def_effect(brna);
3153   rna_def_effects(brna);
3154   rna_def_modifiers(brna);
3155 }
3156
3157 #endif