VSE: Cache rewrite
[blender.git] / source / blender / blenkernel / intern / 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  * The Original Code is Copyright (C) 2001-2002 by NaN Holding BV.
17  * All rights reserved.
18  *
19  * - Blender Foundation, 2003-2009
20  * - Peter Schlaile <peter [at] schlaile [dot] de> 2005/2006
21  */
22
23 /** \file
24  * \ingroup bke
25  */
26
27 #include <stddef.h>
28 #include <stdlib.h>
29 #include <string.h>
30 #include <time.h>
31
32 #include "MEM_guardedalloc.h"
33
34 #include "DNA_sequence_types.h"
35 #include "DNA_movieclip_types.h"
36 #include "DNA_mask_types.h"
37 #include "DNA_scene_types.h"
38 #include "DNA_anim_types.h"
39 #include "DNA_object_types.h"
40 #include "DNA_sound_types.h"
41
42 #include "BLI_math.h"
43 #include "BLI_fileops.h"
44 #include "BLI_listbase.h"
45 #include "BLI_linklist.h"
46 #include "BLI_path_util.h"
47 #include "BLI_string.h"
48 #include "BLI_string_utf8.h"
49 #include "BLI_threads.h"
50 #include "BLI_utildefines.h"
51
52 #ifdef WIN32
53 #  include "BLI_winstuff.h"
54 #else
55 #  include <unistd.h>
56 #endif
57
58 #include "BLT_translation.h"
59
60 #include "BKE_animsys.h"
61 #include "BKE_global.h"
62 #include "BKE_image.h"
63 #include "BKE_layer.h"
64 #include "BKE_main.h"
65 #include "BKE_sequencer.h"
66 #include "BKE_movieclip.h"
67 #include "BKE_fcurve.h"
68 #include "BKE_scene.h"
69 #include "BKE_mask.h"
70 #include "BKE_library.h"
71 #include "BKE_idprop.h"
72
73 #include "DEG_depsgraph.h"
74 #include "DEG_depsgraph_query.h"
75
76 #include "RNA_access.h"
77
78 #include "RE_pipeline.h"
79
80 #include <pthread.h>
81
82 #include "IMB_imbuf.h"
83 #include "IMB_imbuf_types.h"
84 #include "IMB_colormanagement.h"
85 #include "IMB_metadata.h"
86
87 #include "BKE_context.h"
88 #include "BKE_sound.h"
89
90 #include "RE_engine.h"
91
92 #ifdef WITH_AUDASPACE
93 #  include <AUD_Special.h>
94 #endif
95
96 /* mutable state for sequencer */
97 typedef struct SeqRenderState {
98   LinkNode *scene_parents;
99 } SeqRenderState;
100
101 static ImBuf *seq_render_strip_stack(const SeqRenderData *context,
102                                      SeqRenderState *state,
103                                      ListBase *seqbasep,
104                                      float cfra,
105                                      int chanshown);
106 static ImBuf *seq_render_strip(const SeqRenderData *context,
107                                SeqRenderState *state,
108                                Sequence *seq,
109                                float cfra);
110 static void seq_free_animdata(Scene *scene, Sequence *seq);
111 static ImBuf *seq_render_mask(const SeqRenderData *context, Mask *mask, float nr, bool make_float);
112 static int seq_num_files(Scene *scene, char views_format, const bool is_multiview);
113 static void seq_anim_add_suffix(Scene *scene, struct anim *anim, const int view_id);
114
115 /* **** XXX ******** */
116 #define SELECT 1
117 ListBase seqbase_clipboard;
118 int seqbase_clipboard_frame;
119 SequencerDrawView sequencer_view3d_cb = NULL; /* NULL in background mode */
120
121 #if 0 /* unused function */
122 static void printf_strip(Sequence *seq)
123 {
124   fprintf(stderr,
125           "name: '%s', len:%d, start:%d, (startofs:%d, endofs:%d), "
126           "(startstill:%d, endstill:%d), machine:%d, (startdisp:%d, enddisp:%d)\n",
127           seq->name,
128           seq->len,
129           seq->start,
130           seq->startofs,
131           seq->endofs,
132           seq->startstill,
133           seq->endstill,
134           seq->machine,
135           seq->startdisp,
136           seq->enddisp);
137
138   fprintf(stderr,
139           "\tseq_tx_set_final_left: %d %d\n\n",
140           seq_tx_get_final_left(seq, 0),
141           seq_tx_get_final_right(seq, 0));
142 }
143 #endif
144
145 static void sequencer_state_init(SeqRenderState *state)
146 {
147   state->scene_parents = NULL;
148 }
149
150 int BKE_sequencer_base_recursive_apply(ListBase *seqbase,
151                                        int (*apply_func)(Sequence *seq, void *),
152                                        void *arg)
153 {
154   Sequence *iseq;
155   for (iseq = seqbase->first; iseq; iseq = iseq->next) {
156     if (BKE_sequencer_recursive_apply(iseq, apply_func, arg) == -1) {
157       return -1; /* bail out */
158     }
159   }
160   return 1;
161 }
162
163 int BKE_sequencer_recursive_apply(Sequence *seq, int (*apply_func)(Sequence *, void *), void *arg)
164 {
165   int ret = apply_func(seq, arg);
166
167   if (ret == -1) {
168     return -1; /* bail out */
169   }
170
171   if (ret && seq->seqbase.first) {
172     ret = BKE_sequencer_base_recursive_apply(&seq->seqbase, apply_func, arg);
173   }
174
175   return ret;
176 }
177
178 /*********************** alloc / free functions *************************/
179
180 /* free */
181
182 static void free_proxy_seq(Sequence *seq)
183 {
184   if (seq->strip && seq->strip->proxy && seq->strip->proxy->anim) {
185     IMB_free_anim(seq->strip->proxy->anim);
186     seq->strip->proxy->anim = NULL;
187   }
188 }
189
190 static void seq_free_strip(Strip *strip)
191 {
192   strip->us--;
193   if (strip->us > 0) {
194     return;
195   }
196   if (strip->us < 0) {
197     printf("error: negative users in strip\n");
198     return;
199   }
200
201   if (strip->stripdata) {
202     MEM_freeN(strip->stripdata);
203   }
204
205   if (strip->proxy) {
206     if (strip->proxy->anim) {
207       IMB_free_anim(strip->proxy->anim);
208     }
209
210     MEM_freeN(strip->proxy);
211   }
212   if (strip->crop) {
213     MEM_freeN(strip->crop);
214   }
215   if (strip->transform) {
216     MEM_freeN(strip->transform);
217   }
218
219   MEM_freeN(strip);
220 }
221
222 /* only give option to skip cache locally (static func) */
223 static void BKE_sequence_free_ex(Scene *scene,
224                                  Sequence *seq,
225                                  const bool do_cache,
226                                  const bool do_id_user)
227 {
228   if (seq->strip) {
229     seq_free_strip(seq->strip);
230   }
231
232   BKE_sequence_free_anim(seq);
233
234   if (seq->type & SEQ_TYPE_EFFECT) {
235     struct SeqEffectHandle sh = BKE_sequence_get_effect(seq);
236     sh.free(seq, do_id_user);
237   }
238
239   if (seq->sound && do_id_user) {
240     id_us_min(((ID *)seq->sound));
241   }
242
243   if (seq->stereo3d_format) {
244     MEM_freeN(seq->stereo3d_format);
245   }
246
247   /* clipboard has no scene and will never have a sound handle or be active
248    * same goes to sequences copy for proxy rebuild job
249    */
250   if (scene) {
251     Editing *ed = scene->ed;
252
253     if (ed->act_seq == seq) {
254       ed->act_seq = NULL;
255     }
256
257     if (seq->scene_sound && ELEM(seq->type, SEQ_TYPE_SOUND_RAM, SEQ_TYPE_SCENE)) {
258       BKE_sound_remove_scene_sound(scene, seq->scene_sound);
259     }
260
261     seq_free_animdata(scene, seq);
262   }
263
264   if (seq->prop) {
265     IDP_FreeProperty_ex(seq->prop, do_id_user);
266     MEM_freeN(seq->prop);
267   }
268
269   /* free modifiers */
270   BKE_sequence_modifier_clear(seq);
271
272   /* free cached data used by this strip,
273    * also invalidate cache for all dependent sequences
274    *
275    * be _very_ careful here, invalidating cache loops over the scene sequences and
276    * assumes the listbase is valid for all strips,
277    * this may not be the case if lists are being freed.
278    * this is optional BKE_sequence_invalidate_cache
279    */
280   if (do_cache) {
281     if (scene) {
282       BKE_sequence_invalidate_cache(scene, seq);
283     }
284   }
285
286   MEM_freeN(seq);
287 }
288
289 void BKE_sequence_free(Scene *scene, Sequence *seq)
290 {
291   BKE_sequence_free_ex(scene, seq, true, true);
292 }
293
294 /* Function to free imbuf and anim data on changes */
295 void BKE_sequence_free_anim(Sequence *seq)
296 {
297   while (seq->anims.last) {
298     StripAnim *sanim = seq->anims.last;
299
300     if (sanim->anim) {
301       IMB_free_anim(sanim->anim);
302       sanim->anim = NULL;
303     }
304
305     BLI_freelinkN(&seq->anims, sanim);
306   }
307   BLI_listbase_clear(&seq->anims);
308 }
309
310 /* cache must be freed before calling this function
311  * since it leaves the seqbase in an invalid state */
312 static void seq_free_sequence_recurse(Scene *scene, Sequence *seq, const bool do_id_user)
313 {
314   Sequence *iseq, *iseq_next;
315
316   for (iseq = seq->seqbase.first; iseq; iseq = iseq_next) {
317     iseq_next = iseq->next;
318     seq_free_sequence_recurse(scene, iseq, do_id_user);
319   }
320
321   BKE_sequence_free_ex(scene, seq, false, do_id_user);
322 }
323
324 Editing *BKE_sequencer_editing_get(Scene *scene, bool alloc)
325 {
326   if (alloc) {
327     BKE_sequencer_editing_ensure(scene);
328   }
329   return scene->ed;
330 }
331
332 void BKE_sequencer_free_clipboard(void)
333 {
334   Sequence *seq, *nseq;
335
336   BKE_sequencer_base_clipboard_pointers_free(&seqbase_clipboard);
337
338   for (seq = seqbase_clipboard.first; seq; seq = nseq) {
339     nseq = seq->next;
340     seq_free_sequence_recurse(NULL, seq, false);
341   }
342   BLI_listbase_clear(&seqbase_clipboard);
343 }
344
345 /* -------------------------------------------------------------------- */
346 /* Manage pointers in the clipboard.
347  * note that these pointers should _never_ be access in the sequencer,
348  * they are only for storage while in the clipboard
349  * notice 'newid' is used for temp pointer storage here, validate on access (this is safe usage,
350  * since those datablocks are fully out of Main lists).
351  */
352 #define ID_PT (*id_pt)
353 static void seqclipboard_ptr_free(Main *UNUSED(bmain), ID **id_pt)
354 {
355   if (ID_PT) {
356     BLI_assert(ID_PT->newid != NULL);
357     MEM_freeN(ID_PT);
358     ID_PT = NULL;
359   }
360 }
361 static void seqclipboard_ptr_store(Main *UNUSED(bmain), ID **id_pt)
362 {
363   if (ID_PT) {
364     ID *id_prev = ID_PT;
365     ID_PT = MEM_dupallocN(ID_PT);
366     ID_PT->newid = id_prev;
367   }
368 }
369 static void seqclipboard_ptr_restore(Main *bmain, ID **id_pt)
370 {
371   if (ID_PT) {
372     const ListBase *lb = which_libbase(bmain, GS(ID_PT->name));
373     void *id_restore;
374
375     BLI_assert(ID_PT->newid != NULL);
376     if (BLI_findindex(lb, (ID_PT)->newid) != -1) {
377       /* the pointer is still valid */
378       id_restore = (ID_PT)->newid;
379     }
380     else {
381       /* the pointer of the same name still exists  */
382       id_restore = BLI_findstring(lb, (ID_PT)->name + 2, offsetof(ID, name) + 2);
383     }
384
385     if (id_restore == NULL) {
386       /* check for a data with the same filename */
387       switch (GS(ID_PT->name)) {
388         case ID_SO: {
389           id_restore = BLI_findstring(lb, ((bSound *)ID_PT)->name, offsetof(bSound, name));
390           if (id_restore == NULL) {
391             id_restore = BKE_sound_new_file(bmain, ((bSound *)ID_PT)->name);
392             (ID_PT)->newid = id_restore; /* reuse next time */
393           }
394           break;
395         }
396         case ID_MC: {
397           id_restore = BLI_findstring(lb, ((MovieClip *)ID_PT)->name, offsetof(MovieClip, name));
398           if (id_restore == NULL) {
399             id_restore = BKE_movieclip_file_add(bmain, ((MovieClip *)ID_PT)->name);
400             (ID_PT)->newid = id_restore; /* reuse next time */
401           }
402           break;
403         }
404         default:
405           break;
406       }
407     }
408
409     /* Replace with pointer to actual datablock. */
410     seqclipboard_ptr_free(bmain, id_pt);
411     ID_PT = id_restore;
412   }
413 }
414 #undef ID_PT
415
416 static void sequence_clipboard_pointers(Main *bmain,
417                                         Sequence *seq,
418                                         void (*callback)(Main *, ID **))
419 {
420   callback(bmain, (ID **)&seq->scene);
421   callback(bmain, (ID **)&seq->scene_camera);
422   callback(bmain, (ID **)&seq->clip);
423   callback(bmain, (ID **)&seq->mask);
424   callback(bmain, (ID **)&seq->sound);
425
426   if (seq->type == SEQ_TYPE_TEXT && seq->effectdata) {
427     TextVars *text_data = seq->effectdata;
428     callback(bmain, (ID **)&text_data->text_font);
429   }
430 }
431
432 /* recursive versions of functions above */
433 void BKE_sequencer_base_clipboard_pointers_free(ListBase *seqbase)
434 {
435   Sequence *seq;
436   for (seq = seqbase->first; seq; seq = seq->next) {
437     sequence_clipboard_pointers(NULL, seq, seqclipboard_ptr_free);
438     BKE_sequencer_base_clipboard_pointers_free(&seq->seqbase);
439   }
440 }
441 void BKE_sequencer_base_clipboard_pointers_store(Main *bmain, ListBase *seqbase)
442 {
443   Sequence *seq;
444   for (seq = seqbase->first; seq; seq = seq->next) {
445     sequence_clipboard_pointers(bmain, seq, seqclipboard_ptr_store);
446     BKE_sequencer_base_clipboard_pointers_store(bmain, &seq->seqbase);
447   }
448 }
449 void BKE_sequencer_base_clipboard_pointers_restore(ListBase *seqbase, Main *bmain)
450 {
451   Sequence *seq;
452   for (seq = seqbase->first; seq; seq = seq->next) {
453     sequence_clipboard_pointers(bmain, seq, seqclipboard_ptr_restore);
454     BKE_sequencer_base_clipboard_pointers_restore(&seq->seqbase, bmain);
455   }
456 }
457
458 /* end clipboard pointer mess */
459
460 Editing *BKE_sequencer_editing_ensure(Scene *scene)
461 {
462   if (scene->ed == NULL) {
463     Editing *ed;
464
465     ed = scene->ed = MEM_callocN(sizeof(Editing), "addseq");
466     ed->seqbasep = &ed->seqbase;
467     ed->cache = NULL;
468     ed->cache_flag = SEQ_CACHE_STORE_FINAL_OUT;
469     ed->cache_flag |= SEQ_CACHE_VIEW_FINAL_OUT;
470     ed->cache_flag |= SEQ_CACHE_VIEW_ENABLE;
471     ed->recycle_max_cost = 10.0f;
472   }
473
474   return scene->ed;
475 }
476
477 void BKE_sequencer_editing_free(Scene *scene, const bool do_id_user)
478 {
479   Editing *ed = scene->ed;
480   Sequence *seq;
481
482   if (ed == NULL) {
483     return;
484   }
485
486   BKE_sequencer_cache_destruct(scene);
487
488   SEQ_BEGIN (ed, seq) {
489     /* handle cache freeing above */
490     BKE_sequence_free_ex(scene, seq, false, do_id_user);
491   }
492   SEQ_END;
493
494   BLI_freelistN(&ed->metastack);
495
496   MEM_freeN(ed);
497
498   scene->ed = NULL;
499 }
500
501 /*********************** Sequencer color space functions  *************************/
502
503 static void sequencer_imbuf_assign_spaces(Scene *scene, ImBuf *ibuf)
504 {
505 #if 0
506   /* Bute buffer is supposed to be in sequencer working space already. */
507   if (ibuf->rect != NULL) {
508     IMB_colormanagement_assign_rect_colorspace(ibuf, scene->sequencer_colorspace_settings.name);
509   }
510 #endif
511   if (ibuf->rect_float != NULL) {
512     IMB_colormanagement_assign_float_colorspace(ibuf, scene->sequencer_colorspace_settings.name);
513   }
514 }
515
516 void BKE_sequencer_imbuf_to_sequencer_space(Scene *scene, ImBuf *ibuf, bool make_float)
517 {
518   /* Early output check: if both buffers are NULL we have nothing to convert. */
519   if (ibuf->rect_float == NULL && ibuf->rect == NULL) {
520     return;
521   }
522   /* Get common conversion settings. */
523   const char *to_colorspace = scene->sequencer_colorspace_settings.name;
524   /* Perform actual conversion logic. */
525   if (ibuf->rect_float == NULL) {
526     /* We are not requested to give float buffer and byte buffer is already
527      * in thee required colorspace. Can skip doing anything here.
528      */
529     const char *from_colorspace = IMB_colormanagement_get_rect_colorspace(ibuf);
530     if (!make_float && STREQ(from_colorspace, to_colorspace)) {
531       return;
532     }
533     if (false) {
534       /* The idea here is to provide as fast playback as possible and
535        * enforcing float buffer here (a) uses more cache memory (b) might
536        * make some other effects slower to apply.
537        *
538        * However, this might also have negative effect by adding weird
539        * artifacts which will then not happen in final render.
540        */
541       IMB_colormanagement_transform_byte_threaded((unsigned char *)ibuf->rect,
542                                                   ibuf->x,
543                                                   ibuf->y,
544                                                   ibuf->channels,
545                                                   from_colorspace,
546                                                   to_colorspace);
547     }
548     else {
549       /* We perform conversion to a float buffer so we don't worry about
550        * precision loss.
551        */
552       imb_addrectfloatImBuf(ibuf);
553       IMB_colormanagement_transform_from_byte_threaded(ibuf->rect_float,
554                                                        (unsigned char *)ibuf->rect,
555                                                        ibuf->x,
556                                                        ibuf->y,
557                                                        ibuf->channels,
558                                                        from_colorspace,
559                                                        to_colorspace);
560       /* We don't need byte buffer anymore. */
561       imb_freerectImBuf(ibuf);
562     }
563   }
564   else {
565     const char *from_colorspace = IMB_colormanagement_get_float_colorspace(ibuf);
566     /* Unknown input color space, can't perform conversion. */
567     if (from_colorspace == NULL || from_colorspace[0] == '\0') {
568       return;
569     }
570     /* We don't want both byte and float buffers around: they'll either run
571      * out of sync or conversion of byte buffer will loose precision in there.
572      */
573     if (ibuf->rect != NULL) {
574       imb_freerectImBuf(ibuf);
575     }
576     IMB_colormanagement_transform_threaded(
577         ibuf->rect_float, ibuf->x, ibuf->y, ibuf->channels, from_colorspace, to_colorspace, true);
578   }
579   sequencer_imbuf_assign_spaces(scene, ibuf);
580 }
581
582 void BKE_sequencer_imbuf_from_sequencer_space(Scene *scene, ImBuf *ibuf)
583 {
584   const char *from_colorspace = scene->sequencer_colorspace_settings.name;
585   const char *to_colorspace = IMB_colormanagement_role_colorspace_name_get(
586       COLOR_ROLE_SCENE_LINEAR);
587
588   if (!ibuf->rect_float) {
589     return;
590   }
591
592   if (to_colorspace && to_colorspace[0] != '\0') {
593     IMB_colormanagement_transform_threaded(
594         ibuf->rect_float, ibuf->x, ibuf->y, ibuf->channels, from_colorspace, to_colorspace, true);
595     IMB_colormanagement_assign_float_colorspace(ibuf, to_colorspace);
596   }
597 }
598
599 void BKE_sequencer_pixel_from_sequencer_space_v4(struct Scene *scene, float pixel[4])
600 {
601   const char *from_colorspace = scene->sequencer_colorspace_settings.name;
602   const char *to_colorspace = IMB_colormanagement_role_colorspace_name_get(
603       COLOR_ROLE_SCENE_LINEAR);
604
605   if (to_colorspace && to_colorspace[0] != '\0') {
606     IMB_colormanagement_transform_v4(pixel, from_colorspace, to_colorspace);
607   }
608   else {
609     /* if no color management enables fallback to legacy conversion */
610     srgb_to_linearrgb_v4(pixel, pixel);
611   }
612 }
613
614 /*********************** sequencer pipeline functions *************************/
615
616 void BKE_sequencer_new_render_data(Main *bmain,
617                                    struct Depsgraph *depsgraph,
618                                    Scene *scene,
619                                    int rectx,
620                                    int recty,
621                                    int preview_render_size,
622                                    int for_render,
623                                    SeqRenderData *r_context)
624 {
625   r_context->bmain = bmain;
626   r_context->depsgraph = depsgraph;
627   r_context->scene = scene;
628   r_context->rectx = rectx;
629   r_context->recty = recty;
630   r_context->preview_render_size = preview_render_size;
631   r_context->for_render = for_render;
632   r_context->motion_blur_samples = 0;
633   r_context->motion_blur_shutter = 0;
634   r_context->skip_cache = false;
635   r_context->is_proxy_render = false;
636   r_context->view_id = 0;
637   r_context->gpu_offscreen = NULL;
638   r_context->gpu_samples = (scene->r.mode & R_OSA) ? scene->r.osa : 0;
639   r_context->gpu_full_samples = (r_context->gpu_samples) && (scene->r.scemode & R_FULL_SAMPLE);
640 }
641
642 /* ************************* iterator ************************** */
643 /* *************** (replaces old WHILE_SEQ) ********************* */
644 /* **************** use now SEQ_BEGIN () SEQ_END ***************** */
645
646 /* sequence strip iterator:
647  * - builds a full array, recursively into meta strips
648  */
649
650 static void seq_count(ListBase *seqbase, int *tot)
651 {
652   Sequence *seq;
653
654   for (seq = seqbase->first; seq; seq = seq->next) {
655     (*tot)++;
656
657     if (seq->seqbase.first) {
658       seq_count(&seq->seqbase, tot);
659     }
660   }
661 }
662
663 static void seq_build_array(ListBase *seqbase, Sequence ***array, int depth)
664 {
665   Sequence *seq;
666
667   for (seq = seqbase->first; seq; seq = seq->next) {
668     seq->depth = depth;
669
670     if (seq->seqbase.first) {
671       seq_build_array(&seq->seqbase, array, depth + 1);
672     }
673
674     **array = seq;
675     (*array)++;
676   }
677 }
678
679 static void seq_array(Editing *ed, Sequence ***seqarray, int *tot, bool use_pointer)
680 {
681   Sequence **array;
682
683   *seqarray = NULL;
684   *tot = 0;
685
686   if (ed == NULL) {
687     return;
688   }
689
690   if (use_pointer) {
691     seq_count(ed->seqbasep, tot);
692   }
693   else {
694     seq_count(&ed->seqbase, tot);
695   }
696
697   if (*tot == 0) {
698     return;
699   }
700
701   *seqarray = array = MEM_mallocN(sizeof(Sequence *) * (*tot), "SeqArray");
702   if (use_pointer) {
703     seq_build_array(ed->seqbasep, &array, 0);
704   }
705   else {
706     seq_build_array(&ed->seqbase, &array, 0);
707   }
708 }
709
710 void BKE_sequence_iterator_begin(Editing *ed, SeqIterator *iter, bool use_pointer)
711 {
712   memset(iter, 0, sizeof(*iter));
713   seq_array(ed, &iter->array, &iter->tot, use_pointer);
714
715   if (iter->tot) {
716     iter->cur = 0;
717     iter->seq = iter->array[iter->cur];
718     iter->valid = 1;
719   }
720 }
721
722 void BKE_sequence_iterator_next(SeqIterator *iter)
723 {
724   if (++iter->cur < iter->tot) {
725     iter->seq = iter->array[iter->cur];
726   }
727   else {
728     iter->valid = 0;
729   }
730 }
731
732 void BKE_sequence_iterator_end(SeqIterator *iter)
733 {
734   if (iter->array) {
735     MEM_freeN(iter->array);
736   }
737
738   iter->valid = 0;
739 }
740
741 static int metaseq_start(Sequence *metaseq)
742 {
743   return metaseq->start + metaseq->startofs;
744 }
745
746 static int metaseq_end(Sequence *metaseq)
747 {
748   return metaseq->start + metaseq->len - metaseq->endofs;
749 }
750
751 static void seq_update_sound_bounds_recursive_rec(Scene *scene,
752                                                   Sequence *metaseq,
753                                                   int start,
754                                                   int end)
755 {
756   Sequence *seq;
757
758   /* for sound we go over full meta tree to update bounds of the sound strips,
759    * since sound is played outside of evaluating the imbufs, */
760   for (seq = metaseq->seqbase.first; seq; seq = seq->next) {
761     if (seq->type == SEQ_TYPE_META) {
762       seq_update_sound_bounds_recursive_rec(
763           scene, seq, max_ii(start, metaseq_start(seq)), min_ii(end, metaseq_end(seq)));
764     }
765     else if (ELEM(seq->type, SEQ_TYPE_SOUND_RAM, SEQ_TYPE_SCENE)) {
766       if (seq->scene_sound) {
767         int startofs = seq->startofs;
768         int endofs = seq->endofs;
769         if (seq->startofs + seq->start < start) {
770           startofs = start - seq->start;
771         }
772
773         if (seq->start + seq->len - seq->endofs > end) {
774           endofs = seq->start + seq->len - end;
775         }
776
777         BKE_sound_move_scene_sound(scene,
778                                    seq->scene_sound,
779                                    seq->start + startofs,
780                                    seq->start + seq->len - endofs,
781                                    startofs + seq->anim_startofs);
782       }
783     }
784   }
785 }
786
787 static void seq_update_sound_bounds_recursive(Scene *scene, Sequence *metaseq)
788 {
789   seq_update_sound_bounds_recursive_rec(
790       scene, metaseq, metaseq_start(metaseq), metaseq_end(metaseq));
791 }
792
793 void BKE_sequence_calc_disp(Scene *scene, Sequence *seq)
794 {
795   if (seq->startofs && seq->startstill) {
796     seq->startstill = 0;
797   }
798   if (seq->endofs && seq->endstill) {
799     seq->endstill = 0;
800   }
801
802   seq->startdisp = seq->start + seq->startofs - seq->startstill;
803   seq->enddisp = seq->start + seq->len - seq->endofs + seq->endstill;
804
805   seq->handsize = 10.0; /* 10 frames */
806   if (seq->enddisp - seq->startdisp < 10) {
807     seq->handsize = (float)(0.5 * (seq->enddisp - seq->startdisp));
808   }
809   else if (seq->enddisp - seq->startdisp > 250) {
810     seq->handsize = (float)((seq->enddisp - seq->startdisp) / 25);
811   }
812
813   if (ELEM(seq->type, SEQ_TYPE_SOUND_RAM, SEQ_TYPE_SCENE)) {
814     BKE_sequencer_update_sound_bounds(scene, seq);
815   }
816   else if (seq->type == SEQ_TYPE_META) {
817     seq_update_sound_bounds_recursive(scene, seq);
818   }
819 }
820
821 void BKE_sequence_calc(Scene *scene, Sequence *seq)
822 {
823   Sequence *seqm;
824   int min, max;
825
826   /* check all metas recursively */
827   seqm = seq->seqbase.first;
828   while (seqm) {
829     if (seqm->seqbase.first) {
830       BKE_sequence_calc(scene, seqm);
831     }
832     seqm = seqm->next;
833   }
834
835   /* effects and meta: automatic start and end */
836
837   if (seq->type & SEQ_TYPE_EFFECT) {
838     /* pointers */
839     if (seq->seq2 == NULL) {
840       seq->seq2 = seq->seq1;
841     }
842     if (seq->seq3 == NULL) {
843       seq->seq3 = seq->seq1;
844     }
845
846     /* effecten go from seq1 -> seq2: test */
847
848     /* we take the largest start and smallest end */
849
850     // seq->start = seq->startdisp = MAX2(seq->seq1->startdisp, seq->seq2->startdisp);
851     // seq->enddisp = MIN2(seq->seq1->enddisp, seq->seq2->enddisp);
852
853     if (seq->seq1) {
854       /* XXX These resets should not be necessary, but users used to be able to
855        *     edit effect's length, leading to strange results. See [#29190] */
856       seq->startofs = seq->endofs = seq->startstill = seq->endstill = 0;
857       seq->start = seq->startdisp = max_iii(
858           seq->seq1->startdisp, seq->seq2->startdisp, seq->seq3->startdisp);
859       seq->enddisp = min_iii(seq->seq1->enddisp, seq->seq2->enddisp, seq->seq3->enddisp);
860       /* we cant help if strips don't overlap, it wont give useful results.
861        * but at least ensure 'len' is never negative which causes bad bugs elsewhere. */
862       if (seq->enddisp < seq->startdisp) {
863         /* simple start/end swap */
864         seq->start = seq->enddisp;
865         seq->enddisp = seq->startdisp;
866         seq->startdisp = seq->start;
867         seq->flag |= SEQ_INVALID_EFFECT;
868       }
869       else {
870         seq->flag &= ~SEQ_INVALID_EFFECT;
871       }
872
873       seq->len = seq->enddisp - seq->startdisp;
874     }
875     else {
876       BKE_sequence_calc_disp(scene, seq);
877     }
878   }
879   else {
880     if (seq->type == SEQ_TYPE_META) {
881       seqm = seq->seqbase.first;
882       if (seqm) {
883         min = MAXFRAME * 2;
884         max = -MAXFRAME * 2;
885         while (seqm) {
886           if (seqm->startdisp < min) {
887             min = seqm->startdisp;
888           }
889           if (seqm->enddisp > max) {
890             max = seqm->enddisp;
891           }
892           seqm = seqm->next;
893         }
894         seq->start = min + seq->anim_startofs;
895         seq->len = max - min;
896         seq->len -= seq->anim_startofs;
897         seq->len -= seq->anim_endofs;
898       }
899       seq_update_sound_bounds_recursive(scene, seq);
900     }
901     BKE_sequence_calc_disp(scene, seq);
902   }
903 }
904
905 static void seq_multiview_name(Scene *scene,
906                                const int view_id,
907                                const char *prefix,
908                                const char *ext,
909                                char *r_path,
910                                size_t r_size)
911 {
912   const char *suffix = BKE_scene_multiview_view_id_suffix_get(&scene->r, view_id);
913   BLI_snprintf(r_path, r_size, "%s%s%s", prefix, suffix, ext);
914 }
915
916 /* note: caller should run BKE_sequence_calc(scene, seq) after */
917 void BKE_sequence_reload_new_file(Scene *scene, Sequence *seq, const bool lock_range)
918 {
919   char path[FILE_MAX];
920   int prev_startdisp = 0, prev_enddisp = 0;
921   /* note: don't rename the strip, will break animation curves */
922
923   if (ELEM(seq->type,
924            SEQ_TYPE_MOVIE,
925            SEQ_TYPE_IMAGE,
926            SEQ_TYPE_SOUND_RAM,
927            SEQ_TYPE_SCENE,
928            SEQ_TYPE_META,
929            SEQ_TYPE_MOVIECLIP,
930            SEQ_TYPE_MASK) == 0) {
931     return;
932   }
933
934   if (lock_range) {
935     /* keep so we don't have to move the actual start and end points (only the data) */
936     BKE_sequence_calc_disp(scene, seq);
937     prev_startdisp = seq->startdisp;
938     prev_enddisp = seq->enddisp;
939   }
940
941   switch (seq->type) {
942     case SEQ_TYPE_IMAGE: {
943       /* Hack? */
944       size_t olen = MEM_allocN_len(seq->strip->stripdata) / sizeof(StripElem);
945
946       seq->len = olen;
947       seq->len -= seq->anim_startofs;
948       seq->len -= seq->anim_endofs;
949       if (seq->len < 0) {
950         seq->len = 0;
951       }
952       break;
953     }
954     case SEQ_TYPE_MOVIE: {
955       StripAnim *sanim;
956       bool is_multiview_loaded = false;
957       const bool is_multiview = (seq->flag & SEQ_USE_VIEWS) != 0 &&
958                                 (scene->r.scemode & R_MULTIVIEW) != 0;
959
960       BLI_join_dirfile(path, sizeof(path), seq->strip->dir, seq->strip->stripdata->name);
961       BLI_path_abs(path, BKE_main_blendfile_path_from_global());
962
963       BKE_sequence_free_anim(seq);
964
965       if (is_multiview && (seq->views_format == R_IMF_VIEWS_INDIVIDUAL)) {
966         char prefix[FILE_MAX];
967         const char *ext = NULL;
968         const int totfiles = seq_num_files(scene, seq->views_format, true);
969         int i = 0;
970
971         BKE_scene_multiview_view_prefix_get(scene, path, prefix, &ext);
972
973         if (prefix[0] != '\0') {
974           for (i = 0; i < totfiles; i++) {
975             struct anim *anim;
976             char str[FILE_MAX];
977
978             seq_multiview_name(scene, i, prefix, ext, str, FILE_MAX);
979             anim = openanim(str,
980                             IB_rect | ((seq->flag & SEQ_FILTERY) ? IB_animdeinterlace : 0),
981                             seq->streamindex,
982                             seq->strip->colorspace_settings.name);
983
984             if (anim) {
985               seq_anim_add_suffix(scene, anim, i);
986               sanim = MEM_mallocN(sizeof(StripAnim), "Strip Anim");
987               BLI_addtail(&seq->anims, sanim);
988               sanim->anim = anim;
989             }
990           }
991           is_multiview_loaded = true;
992         }
993       }
994
995       if (is_multiview_loaded == false) {
996         struct anim *anim;
997         anim = openanim(path,
998                         IB_rect | ((seq->flag & SEQ_FILTERY) ? IB_animdeinterlace : 0),
999                         seq->streamindex,
1000                         seq->strip->colorspace_settings.name);
1001         if (anim) {
1002           sanim = MEM_mallocN(sizeof(StripAnim), "Strip Anim");
1003           BLI_addtail(&seq->anims, sanim);
1004           sanim->anim = anim;
1005         }
1006       }
1007
1008       /* use the first video as reference for everything */
1009       sanim = seq->anims.first;
1010
1011       if ((!sanim) || (!sanim->anim)) {
1012         return;
1013       }
1014
1015       IMB_anim_load_metadata(sanim->anim);
1016
1017       seq->len = IMB_anim_get_duration(
1018           sanim->anim, seq->strip->proxy ? seq->strip->proxy->tc : IMB_TC_RECORD_RUN);
1019
1020       seq->anim_preseek = IMB_anim_get_preseek(sanim->anim);
1021
1022       seq->len -= seq->anim_startofs;
1023       seq->len -= seq->anim_endofs;
1024       if (seq->len < 0) {
1025         seq->len = 0;
1026       }
1027       break;
1028     }
1029     case SEQ_TYPE_MOVIECLIP:
1030       if (seq->clip == NULL) {
1031         return;
1032       }
1033
1034       seq->len = BKE_movieclip_get_duration(seq->clip);
1035
1036       seq->len -= seq->anim_startofs;
1037       seq->len -= seq->anim_endofs;
1038       if (seq->len < 0) {
1039         seq->len = 0;
1040       }
1041       break;
1042     case SEQ_TYPE_MASK:
1043       if (seq->mask == NULL) {
1044         return;
1045       }
1046       seq->len = BKE_mask_get_duration(seq->mask);
1047       seq->len -= seq->anim_startofs;
1048       seq->len -= seq->anim_endofs;
1049       if (seq->len < 0) {
1050         seq->len = 0;
1051       }
1052       break;
1053     case SEQ_TYPE_SOUND_RAM:
1054 #ifdef WITH_AUDASPACE
1055       if (!seq->sound) {
1056         return;
1057       }
1058       seq->len = ceil((double)AUD_getInfo(seq->sound->playback_handle).length * FPS);
1059       seq->len -= seq->anim_startofs;
1060       seq->len -= seq->anim_endofs;
1061       if (seq->len < 0) {
1062         seq->len = 0;
1063       }
1064 #else
1065       return;
1066 #endif
1067       break;
1068     case SEQ_TYPE_SCENE: {
1069       seq->len = (seq->scene) ? seq->scene->r.efra - seq->scene->r.sfra + 1 : 0;
1070       seq->len -= seq->anim_startofs;
1071       seq->len -= seq->anim_endofs;
1072       if (seq->len < 0) {
1073         seq->len = 0;
1074       }
1075       break;
1076     }
1077   }
1078
1079   free_proxy_seq(seq);
1080
1081   if (lock_range) {
1082     BKE_sequence_tx_set_final_left(seq, prev_startdisp);
1083     BKE_sequence_tx_set_final_right(seq, prev_enddisp);
1084     BKE_sequence_single_fix(seq);
1085   }
1086
1087   BKE_sequence_calc(scene, seq);
1088 }
1089
1090 void BKE_sequencer_sort(Scene *scene)
1091 {
1092   /* all strips together per kind, and in order of y location ("machine") */
1093   ListBase seqbase, effbase;
1094   Editing *ed = BKE_sequencer_editing_get(scene, false);
1095   Sequence *seq, *seqt;
1096
1097   if (ed == NULL) {
1098     return;
1099   }
1100
1101   BLI_listbase_clear(&seqbase);
1102   BLI_listbase_clear(&effbase);
1103
1104   while ((seq = BLI_pophead(ed->seqbasep))) {
1105
1106     if (seq->type & SEQ_TYPE_EFFECT) {
1107       seqt = effbase.first;
1108       while (seqt) {
1109         if (seqt->machine >= seq->machine) {
1110           BLI_insertlinkbefore(&effbase, seqt, seq);
1111           break;
1112         }
1113         seqt = seqt->next;
1114       }
1115       if (seqt == NULL) {
1116         BLI_addtail(&effbase, seq);
1117       }
1118     }
1119     else {
1120       seqt = seqbase.first;
1121       while (seqt) {
1122         if (seqt->machine >= seq->machine) {
1123           BLI_insertlinkbefore(&seqbase, seqt, seq);
1124           break;
1125         }
1126         seqt = seqt->next;
1127       }
1128       if (seqt == NULL) {
1129         BLI_addtail(&seqbase, seq);
1130       }
1131     }
1132   }
1133
1134   BLI_movelisttolist(&seqbase, &effbase);
1135   *(ed->seqbasep) = seqbase;
1136 }
1137
1138 /** Comparison function suitable to be used with BLI_listbase_sort()... */
1139 int BKE_sequencer_cmp_time_startdisp(const void *a, const void *b)
1140 {
1141   const Sequence *seq_a = a;
1142   const Sequence *seq_b = b;
1143
1144   return (seq_a->startdisp > seq_b->startdisp);
1145 }
1146
1147 static int clear_scene_in_allseqs_cb(Sequence *seq, void *arg_pt)
1148 {
1149   if (seq->scene == (Scene *)arg_pt) {
1150     seq->scene = NULL;
1151   }
1152   return 1;
1153 }
1154
1155 void BKE_sequencer_clear_scene_in_allseqs(Main *bmain, Scene *scene)
1156 {
1157   Scene *scene_iter;
1158
1159   /* when a scene is deleted: test all seqs */
1160   for (scene_iter = bmain->scenes.first; scene_iter; scene_iter = scene_iter->id.next) {
1161     if (scene_iter != scene && scene_iter->ed) {
1162       BKE_sequencer_base_recursive_apply(
1163           &scene_iter->ed->seqbase, clear_scene_in_allseqs_cb, scene);
1164     }
1165   }
1166 }
1167
1168 typedef struct SeqUniqueInfo {
1169   Sequence *seq;
1170   char name_src[SEQ_NAME_MAXSTR];
1171   char name_dest[SEQ_NAME_MAXSTR];
1172   int count;
1173   int match;
1174 } SeqUniqueInfo;
1175
1176 static void seqbase_unique_name(ListBase *seqbasep, SeqUniqueInfo *sui)
1177 {
1178   Sequence *seq;
1179   for (seq = seqbasep->first; seq; seq = seq->next) {
1180     if ((sui->seq != seq) && STREQ(sui->name_dest, seq->name + 2)) {
1181       /* SEQ_NAME_MAXSTR -4 for the number, -1 for \0, - 2 for prefix */
1182       BLI_snprintf(sui->name_dest,
1183                    sizeof(sui->name_dest),
1184                    "%.*s.%03d",
1185                    SEQ_NAME_MAXSTR - 4 - 1 - 2,
1186                    sui->name_src,
1187                    sui->count++);
1188       sui->match = 1; /* be sure to re-scan */
1189     }
1190   }
1191 }
1192
1193 static int seqbase_unique_name_recursive_cb(Sequence *seq, void *arg_pt)
1194 {
1195   if (seq->seqbase.first) {
1196     seqbase_unique_name(&seq->seqbase, (SeqUniqueInfo *)arg_pt);
1197   }
1198   return 1;
1199 }
1200
1201 void BKE_sequence_base_unique_name_recursive(ListBase *seqbasep, Sequence *seq)
1202 {
1203   SeqUniqueInfo sui;
1204   char *dot;
1205   sui.seq = seq;
1206   BLI_strncpy(sui.name_src, seq->name + 2, sizeof(sui.name_src));
1207   BLI_strncpy(sui.name_dest, seq->name + 2, sizeof(sui.name_dest));
1208
1209   sui.count = 1;
1210   sui.match = 1; /* assume the worst to start the loop */
1211
1212   /* Strip off the suffix */
1213   if ((dot = strrchr(sui.name_src, '.'))) {
1214     *dot = '\0';
1215     dot++;
1216
1217     if (*dot) {
1218       sui.count = atoi(dot) + 1;
1219     }
1220   }
1221
1222   while (sui.match) {
1223     sui.match = 0;
1224     seqbase_unique_name(seqbasep, &sui);
1225     BKE_sequencer_base_recursive_apply(seqbasep, seqbase_unique_name_recursive_cb, &sui);
1226   }
1227
1228   BLI_strncpy(seq->name + 2, sui.name_dest, sizeof(seq->name) - 2);
1229 }
1230
1231 static const char *give_seqname_by_type(int type)
1232 {
1233   switch (type) {
1234     case SEQ_TYPE_META:
1235       return "Meta";
1236     case SEQ_TYPE_IMAGE:
1237       return "Image";
1238     case SEQ_TYPE_SCENE:
1239       return "Scene";
1240     case SEQ_TYPE_MOVIE:
1241       return "Movie";
1242     case SEQ_TYPE_MOVIECLIP:
1243       return "Clip";
1244     case SEQ_TYPE_MASK:
1245       return "Mask";
1246     case SEQ_TYPE_SOUND_RAM:
1247       return "Audio";
1248     case SEQ_TYPE_CROSS:
1249       return "Cross";
1250     case SEQ_TYPE_GAMCROSS:
1251       return "Gamma Cross";
1252     case SEQ_TYPE_ADD:
1253       return "Add";
1254     case SEQ_TYPE_SUB:
1255       return "Sub";
1256     case SEQ_TYPE_MUL:
1257       return "Mul";
1258     case SEQ_TYPE_ALPHAOVER:
1259       return "Alpha Over";
1260     case SEQ_TYPE_ALPHAUNDER:
1261       return "Alpha Under";
1262     case SEQ_TYPE_OVERDROP:
1263       return "Over Drop";
1264     case SEQ_TYPE_COLORMIX:
1265       return "Color Mix";
1266     case SEQ_TYPE_WIPE:
1267       return "Wipe";
1268     case SEQ_TYPE_GLOW:
1269       return "Glow";
1270     case SEQ_TYPE_TRANSFORM:
1271       return "Transform";
1272     case SEQ_TYPE_COLOR:
1273       return "Color";
1274     case SEQ_TYPE_MULTICAM:
1275       return "Multicam";
1276     case SEQ_TYPE_ADJUSTMENT:
1277       return "Adjustment";
1278     case SEQ_TYPE_SPEED:
1279       return "Speed";
1280     case SEQ_TYPE_GAUSSIAN_BLUR:
1281       return "Gaussian Blur";
1282     case SEQ_TYPE_TEXT:
1283       return "Text";
1284     default:
1285       return NULL;
1286   }
1287 }
1288
1289 const char *BKE_sequence_give_name(Sequence *seq)
1290 {
1291   const char *name = give_seqname_by_type(seq->type);
1292
1293   if (!name) {
1294     if (!(seq->type & SEQ_TYPE_EFFECT)) {
1295       return seq->strip->dir;
1296     }
1297     else {
1298       return "Effect";
1299     }
1300   }
1301   return name;
1302 }
1303
1304 ListBase *BKE_sequence_seqbase_get(Sequence *seq, int *r_offset)
1305 {
1306   ListBase *seqbase = NULL;
1307
1308   switch (seq->type) {
1309     case SEQ_TYPE_META: {
1310       seqbase = &seq->seqbase;
1311       *r_offset = seq->start;
1312       break;
1313     }
1314     case SEQ_TYPE_SCENE: {
1315       if (seq->flag & SEQ_SCENE_STRIPS) {
1316         Editing *ed = BKE_sequencer_editing_get(seq->scene, false);
1317         if (ed) {
1318           seqbase = &ed->seqbase;
1319           *r_offset = seq->scene->r.sfra;
1320         }
1321       }
1322       break;
1323     }
1324   }
1325
1326   return seqbase;
1327 }
1328
1329 /*********************** DO THE SEQUENCE *************************/
1330
1331 static void make_black_ibuf(ImBuf *ibuf)
1332 {
1333   unsigned int *rect;
1334   float *rect_float;
1335   int tot;
1336
1337   if (ibuf == NULL || (ibuf->rect == NULL && ibuf->rect_float == NULL)) {
1338     return;
1339   }
1340
1341   tot = ibuf->x * ibuf->y;
1342
1343   rect = ibuf->rect;
1344   rect_float = ibuf->rect_float;
1345
1346   if (rect) {
1347     memset(rect, 0, tot * sizeof(char) * 4);
1348   }
1349
1350   if (rect_float) {
1351     memset(rect_float, 0, tot * sizeof(float) * 4);
1352   }
1353 }
1354
1355 static void multibuf(ImBuf *ibuf, const float fmul)
1356 {
1357   char *rt;
1358   float *rt_float;
1359
1360   int a;
1361
1362   rt = (char *)ibuf->rect;
1363   rt_float = ibuf->rect_float;
1364
1365   if (rt) {
1366     const int imul = (int)(256.0f * fmul);
1367     a = ibuf->x * ibuf->y;
1368     while (a--) {
1369       rt[0] = min_ii((imul * rt[0]) >> 8, 255);
1370       rt[1] = min_ii((imul * rt[1]) >> 8, 255);
1371       rt[2] = min_ii((imul * rt[2]) >> 8, 255);
1372       rt[3] = min_ii((imul * rt[3]) >> 8, 255);
1373
1374       rt += 4;
1375     }
1376   }
1377   if (rt_float) {
1378     a = ibuf->x * ibuf->y;
1379     while (a--) {
1380       rt_float[0] *= fmul;
1381       rt_float[1] *= fmul;
1382       rt_float[2] *= fmul;
1383       rt_float[3] *= fmul;
1384
1385       rt_float += 4;
1386     }
1387   }
1388 }
1389
1390 static float give_stripelem_index(Sequence *seq, float cfra)
1391 {
1392   float nr;
1393   int sta = seq->start;
1394   int end = seq->start + seq->len - 1;
1395
1396   if (seq->type & SEQ_TYPE_EFFECT) {
1397     end = seq->enddisp;
1398   }
1399
1400   if (end < sta) {
1401     return -1;
1402   }
1403
1404   if (seq->flag & SEQ_REVERSE_FRAMES) {
1405     /*reverse frame in this sequence */
1406     if (cfra <= sta) {
1407       nr = end - sta;
1408     }
1409     else if (cfra >= end) {
1410       nr = 0;
1411     }
1412     else {
1413       nr = end - cfra;
1414     }
1415   }
1416   else {
1417     if (cfra <= sta) {
1418       nr = 0;
1419     }
1420     else if (cfra >= end) {
1421       nr = end - sta;
1422     }
1423     else {
1424       nr = cfra - sta;
1425     }
1426   }
1427
1428   if (seq->strobe < 1.0f) {
1429     seq->strobe = 1.0f;
1430   }
1431
1432   if (seq->strobe > 1.0f) {
1433     nr -= fmodf((double)nr, (double)seq->strobe);
1434   }
1435
1436   return nr;
1437 }
1438
1439 StripElem *BKE_sequencer_give_stripelem(Sequence *seq, int cfra)
1440 {
1441   StripElem *se = seq->strip->stripdata;
1442
1443   if (seq->type == SEQ_TYPE_IMAGE) {
1444     /* only IMAGE strips use the whole array, MOVIE strips use only the first element,
1445      * all other strips don't use this...
1446      */
1447
1448     int nr = (int)give_stripelem_index(seq, cfra);
1449
1450     if (nr == -1 || se == NULL) {
1451       return NULL;
1452     }
1453
1454     se += nr + seq->anim_startofs;
1455   }
1456   return se;
1457 }
1458
1459 static int evaluate_seq_frame_gen(Sequence **seq_arr, ListBase *seqbase, int cfra, int chanshown)
1460 {
1461   /* Use arbitrary sized linked list, the size could be over MAXSEQ. */
1462   LinkNodePair effect_inputs = {NULL, NULL};
1463   int totseq = 0;
1464
1465   memset(seq_arr, 0, sizeof(Sequence *) * (MAXSEQ + 1));
1466
1467   for (Sequence *seq = seqbase->first; seq; seq = seq->next) {
1468     if ((seq->startdisp <= cfra) && (seq->enddisp > cfra)) {
1469       if ((seq->type & SEQ_TYPE_EFFECT) && !(seq->flag & SEQ_MUTE)) {
1470
1471         if (seq->seq1) {
1472           BLI_linklist_append_alloca(&effect_inputs, seq->seq1);
1473         }
1474
1475         if (seq->seq2) {
1476           BLI_linklist_append_alloca(&effect_inputs, seq->seq2);
1477         }
1478
1479         if (seq->seq3) {
1480           BLI_linklist_append_alloca(&effect_inputs, seq->seq3);
1481         }
1482       }
1483
1484       seq_arr[seq->machine] = seq;
1485       totseq++;
1486     }
1487   }
1488
1489   /* Drop strips which are used for effect inputs, we don't want
1490    * them to blend into render stack in any other way than effect
1491    * string rendering.
1492    */
1493   for (LinkNode *seq_item = effect_inputs.list; seq_item; seq_item = seq_item->next) {
1494     Sequence *seq = seq_item->link;
1495     /* It's possible that effetc strip would be placed to the same
1496      * 'machine' as it's inputs. We don't want to clear such strips
1497      * from the stack.
1498      */
1499     if (seq_arr[seq->machine] && seq_arr[seq->machine]->type & SEQ_TYPE_EFFECT) {
1500       continue;
1501     }
1502     /* If we're shown a specified channel, then we want to see the stirps
1503      * which belongs to this machine.
1504      */
1505     if (chanshown != 0 && chanshown <= seq->machine) {
1506       continue;
1507     }
1508     seq_arr[seq->machine] = NULL;
1509   }
1510
1511   return totseq;
1512 }
1513
1514 int BKE_sequencer_evaluate_frame(Scene *scene, int cfra)
1515 {
1516   Editing *ed = BKE_sequencer_editing_get(scene, false);
1517   Sequence *seq_arr[MAXSEQ + 1];
1518
1519   if (ed == NULL) {
1520     return 0;
1521   }
1522
1523   return evaluate_seq_frame_gen(seq_arr, ed->seqbasep, cfra, 0);
1524 }
1525
1526 static bool video_seq_is_rendered(Sequence *seq)
1527 {
1528   return (seq && !(seq->flag & SEQ_MUTE) && seq->type != SEQ_TYPE_SOUND_RAM);
1529 }
1530
1531 static int get_shown_sequences(ListBase *seqbasep, int cfra, int chanshown, Sequence **seq_arr_out)
1532 {
1533   Sequence *seq_arr[MAXSEQ + 1];
1534   int b = chanshown;
1535   int cnt = 0;
1536
1537   if (b > MAXSEQ) {
1538     return 0;
1539   }
1540
1541   if (evaluate_seq_frame_gen(seq_arr, seqbasep, cfra, chanshown)) {
1542     if (b == 0) {
1543       b = MAXSEQ;
1544     }
1545     for (; b > 0; b--) {
1546       if (video_seq_is_rendered(seq_arr[b])) {
1547         break;
1548       }
1549     }
1550   }
1551
1552   chanshown = b;
1553
1554   for (; b > 0; b--) {
1555     if (video_seq_is_rendered(seq_arr[b])) {
1556       if (seq_arr[b]->blend_mode == SEQ_BLEND_REPLACE) {
1557         break;
1558       }
1559     }
1560   }
1561
1562   for (; b <= chanshown && b >= 0; b++) {
1563     if (video_seq_is_rendered(seq_arr[b])) {
1564       seq_arr_out[cnt++] = seq_arr[b];
1565     }
1566   }
1567
1568   return cnt;
1569 }
1570
1571 /*********************** proxy management *************************/
1572
1573 typedef struct SeqIndexBuildContext {
1574   struct IndexBuildContext *index_context;
1575
1576   int tc_flags;
1577   int size_flags;
1578   int quality;
1579   bool overwrite;
1580   int view_id;
1581
1582   Main *bmain;
1583   Depsgraph *depsgraph;
1584   Scene *scene;
1585   Sequence *seq, *orig_seq;
1586 } SeqIndexBuildContext;
1587
1588 #define PROXY_MAXFILE (2 * FILE_MAXDIR + FILE_MAXFILE)
1589
1590 static IMB_Proxy_Size seq_rendersize_to_proxysize(int size)
1591 {
1592   if (size >= 100) {
1593     return IMB_PROXY_NONE;
1594   }
1595   if (size >= 99) {
1596     return IMB_PROXY_100;
1597   }
1598   if (size >= 75) {
1599     return IMB_PROXY_75;
1600   }
1601   if (size >= 50) {
1602     return IMB_PROXY_50;
1603   }
1604   return IMB_PROXY_25;
1605 }
1606
1607 static double seq_rendersize_to_scale_factor(int size)
1608 {
1609   if (size >= 99) {
1610     return 1.0;
1611   }
1612   if (size >= 75) {
1613     return 0.75;
1614   }
1615   if (size >= 50) {
1616     return 0.50;
1617   }
1618   return 0.25;
1619 }
1620
1621 /* the number of files will vary according to the stereo format */
1622 static int seq_num_files(Scene *scene, char views_format, const bool is_multiview)
1623 {
1624   if (!is_multiview) {
1625     return 1;
1626   }
1627   else if (views_format == R_IMF_VIEWS_STEREO_3D) {
1628     return 1;
1629   }
1630   /* R_IMF_VIEWS_INDIVIDUAL */
1631   else {
1632     return BKE_scene_multiview_num_views_get(&scene->r);
1633   }
1634 }
1635
1636 static void seq_proxy_index_dir_set(struct anim *anim, const char *base_dir)
1637 {
1638   char dir[FILE_MAX];
1639   char fname[FILE_MAXFILE];
1640
1641   IMB_anim_get_fname(anim, fname, FILE_MAXFILE);
1642   BLI_strncpy(dir, base_dir, sizeof(dir));
1643   BLI_path_append(dir, sizeof(dir), fname);
1644   IMB_anim_set_index_dir(anim, dir);
1645 }
1646
1647 static void seq_open_anim_file(Scene *scene, Sequence *seq, bool openfile)
1648 {
1649   char dir[FILE_MAX];
1650   char name[FILE_MAX];
1651   StripProxy *proxy;
1652   bool use_proxy;
1653   bool is_multiview_loaded = false;
1654   Editing *ed = scene->ed;
1655   const bool is_multiview = (seq->flag & SEQ_USE_VIEWS) != 0 &&
1656                             (scene->r.scemode & R_MULTIVIEW) != 0;
1657
1658   if ((seq->anims.first != NULL) && (((StripAnim *)seq->anims.first)->anim != NULL)) {
1659     return;
1660   }
1661
1662   /* reset all the previously created anims */
1663   BKE_sequence_free_anim(seq);
1664
1665   BLI_join_dirfile(name, sizeof(name), seq->strip->dir, seq->strip->stripdata->name);
1666   BLI_path_abs(name, BKE_main_blendfile_path_from_global());
1667
1668   proxy = seq->strip->proxy;
1669
1670   use_proxy = proxy && ((proxy->storage & SEQ_STORAGE_PROXY_CUSTOM_DIR) != 0 ||
1671                         (ed->proxy_storage == SEQ_EDIT_PROXY_DIR_STORAGE));
1672
1673   if (use_proxy) {
1674     if (ed->proxy_storage == SEQ_EDIT_PROXY_DIR_STORAGE) {
1675       if (ed->proxy_dir[0] == 0) {
1676         BLI_strncpy(dir, "//BL_proxy", sizeof(dir));
1677       }
1678       else {
1679         BLI_strncpy(dir, ed->proxy_dir, sizeof(dir));
1680       }
1681     }
1682     else {
1683       BLI_strncpy(dir, seq->strip->proxy->dir, sizeof(dir));
1684     }
1685     BLI_path_abs(dir, BKE_main_blendfile_path_from_global());
1686   }
1687
1688   if (is_multiview && seq->views_format == R_IMF_VIEWS_INDIVIDUAL) {
1689     int totfiles = seq_num_files(scene, seq->views_format, true);
1690     char prefix[FILE_MAX];
1691     const char *ext = NULL;
1692     int i;
1693
1694     BKE_scene_multiview_view_prefix_get(scene, name, prefix, &ext);
1695
1696     if (prefix[0] != '\0') {
1697       for (i = 0; i < totfiles; i++) {
1698         const char *suffix = BKE_scene_multiview_view_id_suffix_get(&scene->r, i);
1699         char str[FILE_MAX];
1700         StripAnim *sanim = MEM_mallocN(sizeof(StripAnim), "Strip Anim");
1701
1702         BLI_addtail(&seq->anims, sanim);
1703
1704         BLI_snprintf(str, sizeof(str), "%s%s%s", prefix, suffix, ext);
1705
1706         if (openfile) {
1707           sanim->anim = openanim(str,
1708                                  IB_rect | ((seq->flag & SEQ_FILTERY) ? IB_animdeinterlace : 0),
1709                                  seq->streamindex,
1710                                  seq->strip->colorspace_settings.name);
1711         }
1712         else {
1713           sanim->anim = openanim_noload(str,
1714                                         IB_rect |
1715                                             ((seq->flag & SEQ_FILTERY) ? IB_animdeinterlace : 0),
1716                                         seq->streamindex,
1717                                         seq->strip->colorspace_settings.name);
1718         }
1719
1720         if (sanim->anim) {
1721           /* we already have the suffix */
1722           IMB_suffix_anim(sanim->anim, suffix);
1723         }
1724         else {
1725           if (openfile) {
1726             sanim->anim = openanim(name,
1727                                    IB_rect | ((seq->flag & SEQ_FILTERY) ? IB_animdeinterlace : 0),
1728                                    seq->streamindex,
1729                                    seq->strip->colorspace_settings.name);
1730           }
1731           else {
1732             sanim->anim = openanim_noload(name,
1733                                           IB_rect |
1734                                               ((seq->flag & SEQ_FILTERY) ? IB_animdeinterlace : 0),
1735                                           seq->streamindex,
1736                                           seq->strip->colorspace_settings.name);
1737           }
1738
1739           /* no individual view files - monoscopic, stereo 3d or exr multiview */
1740           totfiles = 1;
1741         }
1742
1743         if (sanim->anim && use_proxy) {
1744           seq_proxy_index_dir_set(sanim->anim, dir);
1745         }
1746       }
1747       is_multiview_loaded = true;
1748     }
1749   }
1750
1751   if (is_multiview_loaded == false) {
1752     StripAnim *sanim;
1753
1754     sanim = MEM_mallocN(sizeof(StripAnim), "Strip Anim");
1755     BLI_addtail(&seq->anims, sanim);
1756
1757     if (openfile) {
1758       sanim->anim = openanim(name,
1759                              IB_rect | ((seq->flag & SEQ_FILTERY) ? IB_animdeinterlace : 0),
1760                              seq->streamindex,
1761                              seq->strip->colorspace_settings.name);
1762     }
1763     else {
1764       sanim->anim = openanim_noload(name,
1765                                     IB_rect | ((seq->flag & SEQ_FILTERY) ? IB_animdeinterlace : 0),
1766                                     seq->streamindex,
1767                                     seq->strip->colorspace_settings.name);
1768     }
1769
1770     if (sanim->anim && use_proxy) {
1771       seq_proxy_index_dir_set(sanim->anim, dir);
1772     }
1773   }
1774 }
1775
1776 static bool seq_proxy_get_fname(
1777     Editing *ed, Sequence *seq, int cfra, int render_size, char *name, const int view_id)
1778 {
1779   int frameno;
1780   char dir[PROXY_MAXFILE];
1781   StripAnim *sanim;
1782   char suffix[24] = {'\0'};
1783
1784   StripProxy *proxy = seq->strip->proxy;
1785   if (!proxy) {
1786     return false;
1787   }
1788
1789   /* MOVIE tracks (only exception: custom files) are now handled
1790    * internally by ImBuf module for various reasons: proper time code
1791    * support, quicker index build, using one file instead
1792    * of a full directory of jpeg files, etc. Trying to support old
1793    * and new method at once could lead to funny effects, if people
1794    * have both, a directory full of jpeg files and proxy avis, so
1795    * sorry folks, please rebuild your proxies... */
1796
1797   sanim = BLI_findlink(&seq->anims, view_id);
1798
1799   if (ed->proxy_storage == SEQ_EDIT_PROXY_DIR_STORAGE) {
1800     char fname[FILE_MAXFILE];
1801     if (ed->proxy_dir[0] == 0) {
1802       BLI_strncpy(dir, "//BL_proxy", sizeof(dir));
1803     }
1804     else {
1805       BLI_strncpy(dir, ed->proxy_dir, sizeof(dir));
1806     }
1807
1808     if (sanim && sanim->anim) {
1809       IMB_anim_get_fname(sanim->anim, fname, FILE_MAXFILE);
1810     }
1811     else if (seq->type == SEQ_TYPE_IMAGE) {
1812       fname[0] = 0;
1813     }
1814     else {
1815       /* We could make a name here, except non-movie's don't generate proxies,
1816        * cancel until other types of sequence strips are supported. */
1817       return false;
1818     }
1819     BLI_path_append(dir, sizeof(dir), fname);
1820     BLI_path_abs(name, BKE_main_blendfile_path_from_global());
1821   }
1822   else if ((proxy->storage & SEQ_STORAGE_PROXY_CUSTOM_DIR) &&
1823            (proxy->storage & SEQ_STORAGE_PROXY_CUSTOM_FILE)) {
1824     BLI_strncpy(dir, seq->strip->proxy->dir, sizeof(dir));
1825   }
1826   else if (proxy->storage & SEQ_STORAGE_PROXY_CUSTOM_FILE) {
1827     BLI_strncpy(dir, seq->strip->proxy->dir, sizeof(dir));
1828   }
1829   else if (sanim && sanim->anim && (proxy->storage & SEQ_STORAGE_PROXY_CUSTOM_DIR)) {
1830     char fname[FILE_MAXFILE];
1831     BLI_strncpy(dir, seq->strip->proxy->dir, sizeof(dir));
1832     IMB_anim_get_fname(sanim->anim, fname, FILE_MAXFILE);
1833     BLI_path_append(dir, sizeof(dir), fname);
1834   }
1835   else if (seq->type == SEQ_TYPE_IMAGE) {
1836     if (proxy->storage & SEQ_STORAGE_PROXY_CUSTOM_DIR) {
1837       BLI_strncpy(dir, seq->strip->proxy->dir, sizeof(dir));
1838     }
1839     else {
1840       BLI_snprintf(dir, PROXY_MAXFILE, "%s/BL_proxy", seq->strip->dir);
1841     }
1842   }
1843   else {
1844     return false;
1845   }
1846
1847   if (view_id > 0) {
1848     BLI_snprintf(suffix, sizeof(suffix), "_%d", view_id);
1849   }
1850
1851   if (proxy->storage & SEQ_STORAGE_PROXY_CUSTOM_FILE &&
1852       ed->proxy_storage != SEQ_EDIT_PROXY_DIR_STORAGE) {
1853     char fname[FILE_MAXFILE];
1854     BLI_join_dirfile(fname, PROXY_MAXFILE, dir, proxy->file);
1855     BLI_path_abs(fname, BKE_main_blendfile_path_from_global());
1856     if (suffix[0] != '\0') {
1857       /* TODO(sergey): This will actually append suffix after extension
1858        * which is weird but how was originally coded in multiview branch.
1859        */
1860       BLI_snprintf(name, PROXY_MAXFILE, "%s_%s", fname, suffix);
1861     }
1862     else {
1863       BLI_strncpy(name, fname, PROXY_MAXFILE);
1864     }
1865
1866     return true;
1867   }
1868
1869   /* generate a separate proxy directory for each preview size */
1870
1871   if (seq->type == SEQ_TYPE_IMAGE) {
1872     BLI_snprintf(name,
1873                  PROXY_MAXFILE,
1874                  "%s/images/%d/%s_proxy%s",
1875                  dir,
1876                  render_size,
1877                  BKE_sequencer_give_stripelem(seq, cfra)->name,
1878                  suffix);
1879     frameno = 1;
1880   }
1881   else {
1882     frameno = (int)give_stripelem_index(seq, cfra) + seq->anim_startofs;
1883     BLI_snprintf(name, PROXY_MAXFILE, "%s/proxy_misc/%d/####%s", dir, render_size, suffix);
1884   }
1885
1886   BLI_path_abs(name, BKE_main_blendfile_path_from_global());
1887   BLI_path_frame(name, frameno, 0);
1888
1889   strcat(name, ".jpg");
1890
1891   return true;
1892 }
1893
1894 static ImBuf *seq_proxy_fetch(const SeqRenderData *context, Sequence *seq, int cfra)
1895 {
1896   char name[PROXY_MAXFILE];
1897   IMB_Proxy_Size psize = seq_rendersize_to_proxysize(context->preview_render_size);
1898   int size_flags;
1899   int render_size = context->preview_render_size;
1900   StripProxy *proxy = seq->strip->proxy;
1901   Editing *ed = context->scene->ed;
1902   StripAnim *sanim;
1903
1904   if (!(seq->flag & SEQ_USE_PROXY)) {
1905     return NULL;
1906   }
1907
1908   /* dirty hack to distinguish 100% render size from PROXY_100 */
1909   if (render_size == 99) {
1910     render_size = 100;
1911   }
1912
1913   size_flags = proxy->build_size_flags;
1914
1915   /* only use proxies, if they are enabled (even if present!) */
1916   if (psize == IMB_PROXY_NONE || ((size_flags & psize) != psize)) {
1917     return NULL;
1918   }
1919
1920   if (proxy->storage & SEQ_STORAGE_PROXY_CUSTOM_FILE) {
1921     int frameno = (int)give_stripelem_index(seq, cfra) + seq->anim_startofs;
1922     if (proxy->anim == NULL) {
1923       if (seq_proxy_get_fname(ed, seq, cfra, render_size, name, context->view_id) == 0) {
1924         return NULL;
1925       }
1926
1927       proxy->anim = openanim(name, IB_rect, 0, seq->strip->colorspace_settings.name);
1928     }
1929     if (proxy->anim == NULL) {
1930       return NULL;
1931     }
1932
1933     seq_open_anim_file(context->scene, seq, true);
1934     sanim = seq->anims.first;
1935
1936     frameno = IMB_anim_index_get_frame_index(
1937         sanim ? sanim->anim : NULL, seq->strip->proxy->tc, frameno);
1938
1939     return IMB_anim_absolute(proxy->anim, frameno, IMB_TC_NONE, IMB_PROXY_NONE);
1940   }
1941
1942   if (seq_proxy_get_fname(ed, seq, cfra, render_size, name, context->view_id) == 0) {
1943     return NULL;
1944   }
1945
1946   if (BLI_exists(name)) {
1947     ImBuf *ibuf = IMB_loadiffname(name, IB_rect, NULL);
1948
1949     if (ibuf) {
1950       sequencer_imbuf_assign_spaces(context->scene, ibuf);
1951     }
1952
1953     return ibuf;
1954   }
1955   else {
1956     return NULL;
1957   }
1958 }
1959
1960 static void seq_proxy_build_frame(const SeqRenderData *context,
1961                                   SeqRenderState *state,
1962                                   Sequence *seq,
1963                                   int cfra,
1964                                   int proxy_render_size,
1965                                   const bool overwrite)
1966 {
1967   char name[PROXY_MAXFILE];
1968   int quality;
1969   int rectx, recty;
1970   int ok;
1971   ImBuf *ibuf_tmp, *ibuf;
1972   Editing *ed = context->scene->ed;
1973
1974   if (!seq_proxy_get_fname(ed, seq, cfra, proxy_render_size, name, context->view_id)) {
1975     return;
1976   }
1977
1978   if (!overwrite && BLI_exists(name)) {
1979     return;
1980   }
1981
1982   ibuf_tmp = seq_render_strip(context, state, seq, cfra);
1983
1984   rectx = (proxy_render_size * ibuf_tmp->x) / 100;
1985   recty = (proxy_render_size * ibuf_tmp->y) / 100;
1986
1987   if (ibuf_tmp->x != rectx || ibuf_tmp->y != recty) {
1988     ibuf = IMB_dupImBuf(ibuf_tmp);
1989     IMB_metadata_copy(ibuf, ibuf_tmp);
1990     IMB_freeImBuf(ibuf_tmp);
1991     IMB_scalefastImBuf(ibuf, (short)rectx, (short)recty);
1992   }
1993   else {
1994     ibuf = ibuf_tmp;
1995   }
1996
1997   /* depth = 32 is intentionally left in, otherwise ALPHA channels
1998    * won't work... */
1999   quality = seq->strip->proxy->quality;
2000   ibuf->ftype = IMB_FTYPE_JPG;
2001   ibuf->foptions.quality = quality;
2002
2003   /* unsupported feature only confuses other s/w */
2004   if (ibuf->planes == 32) {
2005     ibuf->planes = 24;
2006   }
2007
2008   BLI_make_existing_file(name);
2009
2010   ok = IMB_saveiff(ibuf, name, IB_rect | IB_zbuf | IB_zbuffloat);
2011   if (ok == 0) {
2012     perror(name);
2013   }
2014
2015   IMB_freeImBuf(ibuf);
2016 }
2017
2018 /**
2019  * Returns whether the file this context would read from even exist,
2020  * if not, don't create the context
2021  */
2022 static bool seq_proxy_multiview_context_invalid(Sequence *seq, Scene *scene, const int view_id)
2023 {
2024   if ((scene->r.scemode & R_MULTIVIEW) == 0) {
2025     return false;
2026   }
2027
2028   if ((seq->type == SEQ_TYPE_IMAGE) && (seq->views_format == R_IMF_VIEWS_INDIVIDUAL)) {
2029     static char prefix[FILE_MAX];
2030     static const char *ext = NULL;
2031     char str[FILE_MAX];
2032
2033     if (view_id == 0) {
2034       char path[FILE_MAX];
2035       BLI_join_dirfile(path, sizeof(path), seq->strip->dir, seq->strip->stripdata->name);
2036       BLI_path_abs(path, BKE_main_blendfile_path_from_global());
2037       BKE_scene_multiview_view_prefix_get(scene, path, prefix, &ext);
2038     }
2039     else {
2040       prefix[0] = '\0';
2041     }
2042
2043     if (prefix[0] == '\0') {
2044       return view_id != 0;
2045     }
2046
2047     seq_multiview_name(scene, view_id, prefix, ext, str, FILE_MAX);
2048
2049     if (BLI_access(str, R_OK) == 0) {
2050       return false;
2051     }
2052     else {
2053       return view_id != 0;
2054     }
2055   }
2056   return false;
2057 }
2058
2059 /**
2060  * This returns the maximum possible number of required contexts
2061  */
2062 static int seq_proxy_context_count(Sequence *seq, Scene *scene)
2063 {
2064   int num_views = 1;
2065
2066   if ((scene->r.scemode & R_MULTIVIEW) == 0) {
2067     return 1;
2068   }
2069
2070   switch (seq->type) {
2071     case SEQ_TYPE_MOVIE: {
2072       num_views = BLI_listbase_count(&seq->anims);
2073       break;
2074     }
2075     case SEQ_TYPE_IMAGE: {
2076       switch (seq->views_format) {
2077         case R_IMF_VIEWS_INDIVIDUAL:
2078           num_views = BKE_scene_multiview_num_views_get(&scene->r);
2079           break;
2080         case R_IMF_VIEWS_STEREO_3D:
2081           num_views = 2;
2082           break;
2083         case R_IMF_VIEWS_MULTIVIEW:
2084           /* not supported at the moment */
2085           /* pass through */
2086         default:
2087           num_views = 1;
2088       }
2089       break;
2090     }
2091   }
2092
2093   return num_views;
2094 }
2095
2096 void BKE_sequencer_proxy_rebuild_context(Main *bmain,
2097                                          Depsgraph *depsgraph,
2098                                          Scene *scene,
2099                                          Sequence *seq,
2100                                          struct GSet *file_list,
2101                                          ListBase *queue)
2102 {
2103   SeqIndexBuildContext *context;
2104   Sequence *nseq;
2105   LinkData *link;
2106   int num_files;
2107   int i;
2108
2109   if (!seq->strip || !seq->strip->proxy) {
2110     return;
2111   }
2112
2113   if (!(seq->flag & SEQ_USE_PROXY)) {
2114     return;
2115   }
2116
2117   num_files = seq_proxy_context_count(seq, scene);
2118
2119   for (i = 0; i < num_files; i++) {
2120     if (seq_proxy_multiview_context_invalid(seq, scene, i)) {
2121       continue;
2122     }
2123
2124     context = MEM_callocN(sizeof(SeqIndexBuildContext), "seq proxy rebuild context");
2125
2126     nseq = BKE_sequence_dupli_recursive(scene, scene, NULL, seq, 0);
2127
2128     context->tc_flags = nseq->strip->proxy->build_tc_flags;
2129     context->size_flags = nseq->strip->proxy->build_size_flags;
2130     context->quality = nseq->strip->proxy->quality;
2131     context->overwrite = (nseq->strip->proxy->build_flags & SEQ_PROXY_SKIP_EXISTING) == 0;
2132
2133     context->bmain = bmain;
2134     context->depsgraph = depsgraph;
2135     context->scene = scene;
2136     context->orig_seq = seq;
2137     context->seq = nseq;
2138
2139     context->view_id = i; /* only for images */
2140
2141     link = BLI_genericNodeN(context);
2142     BLI_addtail(queue, link);
2143
2144     if (nseq->type == SEQ_TYPE_MOVIE) {
2145       StripAnim *sanim;
2146
2147       seq_open_anim_file(scene, nseq, true);
2148       sanim = BLI_findlink(&nseq->anims, i);
2149
2150       if (sanim->anim) {
2151         context->index_context = IMB_anim_index_rebuild_context(sanim->anim,
2152                                                                 context->tc_flags,
2153                                                                 context->size_flags,
2154                                                                 context->quality,
2155                                                                 context->overwrite,
2156                                                                 file_list);
2157       }
2158     }
2159   }
2160 }
2161
2162 void BKE_sequencer_proxy_rebuild(SeqIndexBuildContext *context,
2163                                  short *stop,
2164                                  short *do_update,
2165                                  float *progress)
2166 {
2167   const bool overwrite = context->overwrite;
2168   SeqRenderData render_context;
2169   Sequence *seq = context->seq;
2170   Scene *scene = context->scene;
2171   Main *bmain = context->bmain;
2172   int cfra;
2173
2174   if (seq->type == SEQ_TYPE_MOVIE) {
2175     if (context->index_context) {
2176       IMB_anim_index_rebuild(context->index_context, stop, do_update, progress);
2177     }
2178
2179     return;
2180   }
2181
2182   if (!(seq->flag & SEQ_USE_PROXY)) {
2183     return;
2184   }
2185
2186   /* that's why it is called custom... */
2187   if (seq->strip->proxy && seq->strip->proxy->storage & SEQ_STORAGE_PROXY_CUSTOM_FILE) {
2188     return;
2189   }
2190
2191   /* fail safe code */
2192
2193   BKE_sequencer_new_render_data(bmain,
2194                                 context->depsgraph,
2195                                 context->scene,
2196                                 (scene->r.size * (float)scene->r.xsch) / 100.0f + 0.5f,
2197                                 (scene->r.size * (float)scene->r.ysch) / 100.0f + 0.5f,
2198                                 100,
2199                                 false,
2200                                 &render_context);
2201
2202   render_context.skip_cache = true;
2203   render_context.is_proxy_render = true;
2204   render_context.view_id = context->view_id;
2205
2206   SeqRenderState state;
2207   sequencer_state_init(&state);
2208
2209   for (cfra = seq->startdisp + seq->startstill; cfra < seq->enddisp - seq->endstill; cfra++) {
2210     if (context->size_flags & IMB_PROXY_25) {
2211       seq_proxy_build_frame(&render_context, &state, seq, cfra, 25, overwrite);
2212     }
2213     if (context->size_flags & IMB_PROXY_50) {
2214       seq_proxy_build_frame(&render_context, &state, seq, cfra, 50, overwrite);
2215     }
2216     if (context->size_flags & IMB_PROXY_75) {
2217       seq_proxy_build_frame(&render_context, &state, seq, cfra, 75, overwrite);
2218     }
2219     if (context->size_flags & IMB_PROXY_100) {
2220       seq_proxy_build_frame(&render_context, &state, seq, cfra, 100, overwrite);
2221     }
2222
2223     *progress = (float)(cfra - seq->startdisp - seq->startstill) /
2224                 (seq->enddisp - seq->endstill - seq->startdisp - seq->startstill);
2225     *do_update = true;
2226
2227     if (*stop || G.is_break) {
2228       break;
2229     }
2230   }
2231 }
2232
2233 void BKE_sequencer_proxy_rebuild_finish(SeqIndexBuildContext *context, bool stop)
2234 {
2235   if (context->index_context) {
2236     StripAnim *sanim;
2237
2238     for (sanim = context->seq->anims.first; sanim; sanim = sanim->next) {
2239       IMB_close_anim_proxies(sanim->anim);
2240     }
2241
2242     for (sanim = context->orig_seq->anims.first; sanim; sanim = sanim->next) {
2243       IMB_close_anim_proxies(sanim->anim);
2244     }
2245
2246     IMB_anim_index_rebuild_finish(context->index_context, stop);
2247   }
2248
2249   seq_free_sequence_recurse(NULL, context->seq, true);
2250
2251   MEM_freeN(context);
2252 }
2253
2254 void BKE_sequencer_proxy_set(struct Sequence *seq, bool value)
2255 {
2256   if (value) {
2257     seq->flag |= SEQ_USE_PROXY;
2258     if (seq->strip->proxy == NULL) {
2259       seq->strip->proxy = MEM_callocN(sizeof(struct StripProxy), "StripProxy");
2260       seq->strip->proxy->quality = 90;
2261       seq->strip->proxy->build_tc_flags = SEQ_PROXY_TC_ALL;
2262       seq->strip->proxy->build_size_flags = SEQ_PROXY_IMAGE_SIZE_25;
2263     }
2264   }
2265   else {
2266     seq->flag &= ~SEQ_USE_PROXY;
2267   }
2268 }
2269
2270 /*********************** color balance *************************/
2271
2272 static StripColorBalance calc_cb(StripColorBalance *cb_)
2273 {
2274   StripColorBalance cb = *cb_;
2275   int c;
2276
2277   for (c = 0; c < 3; c++) {
2278     cb.lift[c] = 2.0f - cb.lift[c];
2279   }
2280
2281   if (cb.flag & SEQ_COLOR_BALANCE_INVERSE_LIFT) {
2282     for (c = 0; c < 3; c++) {
2283       /* tweak to give more subtle results
2284        * values above 1.0 are scaled */
2285       if (cb.lift[c] > 1.0f) {
2286         cb.lift[c] = pow(cb.lift[c] - 1.0f, 2.0) + 1.0;
2287       }
2288
2289       cb.lift[c] = 2.0f - cb.lift[c];
2290     }
2291   }
2292
2293   if (cb.flag & SEQ_COLOR_BALANCE_INVERSE_GAIN) {
2294     for (c = 0; c < 3; c++) {
2295       if (cb.gain[c] != 0.0f) {
2296         cb.gain[c] = 1.0f / cb.gain[c];
2297       }
2298       else {
2299         cb.gain[c] = 1000000; /* should be enough :) */
2300       }
2301     }
2302   }
2303
2304   if (!(cb.flag & SEQ_COLOR_BALANCE_INVERSE_GAMMA)) {
2305     for (c = 0; c < 3; c++) {
2306       if (cb.gamma[c] != 0.0f) {
2307         cb.gamma[c] = 1.0f / cb.gamma[c];
2308       }
2309       else {
2310         cb.gamma[c] = 1000000; /* should be enough :) */
2311       }
2312     }
2313   }
2314
2315   return cb;
2316 }
2317
2318 /* note: lift is actually 2-lift */
2319 MINLINE float color_balance_fl(
2320     float in, const float lift, const float gain, const float gamma, const float mul)
2321 {
2322   float x = (((in - 1.0f) * lift) + 1.0f) * gain;
2323
2324   /* prevent NaN */
2325   if (x < 0.f) {
2326     x = 0.f;
2327   }
2328
2329   return powf(x, gamma) * mul;
2330 }
2331
2332 static void make_cb_table_float(float lift, float gain, float gamma, float *table, float mul)
2333 {
2334   int y;
2335
2336   for (y = 0; y < 256; y++) {
2337     float v = color_balance_fl((float)y * (1.0f / 255.0f), lift, gain, gamma, mul);
2338
2339     table[y] = v;
2340   }
2341 }
2342
2343 static void color_balance_byte_byte(StripColorBalance *cb_,
2344                                     unsigned char *rect,
2345                                     unsigned char *mask_rect,
2346                                     int width,
2347                                     int height,
2348                                     float mul)
2349 {
2350   //unsigned char cb_tab[3][256];
2351   unsigned char *cp = rect;
2352   unsigned char *e = cp + width * 4 * height;
2353   unsigned char *m = mask_rect;
2354
2355   StripColorBalance cb = calc_cb(cb_);
2356
2357   while (cp < e) {
2358     float p[4];
2359     int c;
2360
2361     straight_uchar_to_premul_float(p, cp);
2362
2363     for (c = 0; c < 3; c++) {
2364       float t = color_balance_fl(p[c], cb.lift[c], cb.gain[c], cb.gamma[c], mul);
2365
2366       if (m) {
2367         float m_normal = (float)m[c] / 255.0f;
2368
2369         p[c] = p[c] * (1.0f - m_normal) + t * m_normal;
2370       }
2371       else {
2372         p[c] = t;
2373       }
2374     }
2375
2376     premul_float_to_straight_uchar(cp, p);
2377
2378     cp += 4;
2379     if (m) {
2380       m += 4;
2381     }
2382   }
2383 }
2384
2385 static void color_balance_byte_float(StripColorBalance *cb_,
2386                                      unsigned char *rect,
2387                                      float *rect_float,
2388                                      unsigned char *mask_rect,
2389                                      int width,
2390                                      int height,
2391                                      float mul)
2392 {
2393   float cb_tab[4][256];
2394   int c, i;
2395   unsigned char *p = rect;
2396   unsigned char *e = p + width * 4 * height;
2397   unsigned char *m = mask_rect;
2398   float *o;
2399   StripColorBalance cb;
2400
2401   o = rect_float;
2402
2403   cb = calc_cb(cb_);
2404
2405   for (c = 0; c < 3; c++) {
2406     make_cb_table_float(cb.lift[c], cb.gain[c], cb.gamma[c], cb_tab[c], mul);
2407   }
2408
2409   for (i = 0; i < 256; i++) {
2410     cb_tab[3][i] = ((float)i) * (1.0f / 255.0f);
2411   }
2412
2413   while (p < e) {
2414     if (m) {
2415       float t[3] = {m[0] / 255.0f, m[1] / 255.0f, m[2] / 255.0f};
2416
2417       p[0] = p[0] * (1.0f - t[0]) + t[0] * cb_tab[0][p[0]];
2418       p[1] = p[1] * (1.0f - t[1]) + t[1] * cb_tab[1][p[1]];
2419       p[2] = p[2] * (1.0f - t[2]) + t[2] * cb_tab[2][p[2]];
2420
2421       m += 4;
2422     }
2423     else {
2424       o[0] = cb_tab[0][p[0]];
2425       o[1] = cb_tab[1][p[1]];
2426       o[2] = cb_tab[2][p[2]];
2427     }
2428
2429     o[3] = cb_tab[3][p[3]];
2430
2431     p += 4;
2432     o += 4;
2433   }
2434 }
2435
2436 static void color_balance_float_float(StripColorBalance *cb_,
2437                                       float *rect_float,
2438                                       float *mask_rect_float,
2439                                       int width,
2440                                       int height,
2441                                       float mul)
2442 {
2443   float *p = rect_float;
2444   const float *e = rect_float + width * 4 * height;
2445   const float *m = mask_rect_float;
2446   StripColorBalance cb = calc_cb(cb_);
2447
2448   while (p < e) {
2449     int c;
2450     for (c = 0; c < 3; c++) {
2451       float t = color_balance_fl(p[c], cb.lift[c], cb.gain[c], cb.gamma[c], mul);
2452
2453       if (m) {
2454         p[c] = p[c] * (1.0f - m[c]) + t * m[c];
2455       }
2456       else {
2457         p[c] = t;
2458       }
2459     }
2460
2461     p += 4;
2462     if (m) {
2463       m += 4;
2464     }
2465   }
2466 }
2467
2468 typedef struct ColorBalanceInitData {
2469   StripColorBalance *cb;
2470   ImBuf *ibuf;
2471   float mul;
2472   ImBuf *mask;
2473   bool make_float;
2474 } ColorBalanceInitData;
2475
2476 typedef struct ColorBalanceThread {
2477   StripColorBalance *cb;
2478   float mul;
2479
2480   int width, height;
2481
2482   unsigned char *rect, *mask_rect;
2483   float *rect_float, *mask_rect_float;
2484
2485   bool make_float;
2486 } ColorBalanceThread;
2487
2488 static void color_balance_init_handle(void *handle_v,
2489                                       int start_line,
2490                                       int tot_line,
2491                                       void *init_data_v)
2492 {
2493   ColorBalanceThread *handle = (ColorBalanceThread *)handle_v;
2494   ColorBalanceInitData *init_data = (ColorBalanceInitData *)init_data_v;
2495   ImBuf *ibuf = init_data->ibuf;
2496   ImBuf *mask = init_data->mask;
2497
2498   int offset = 4 * start_line * ibuf->x;
2499
2500   memset(handle, 0, sizeof(ColorBalanceThread));
2501
2502   handle->cb = init_data->cb;
2503   handle->mul = init_data->mul;
2504   handle->width = ibuf->x;
2505   handle->height = tot_line;
2506   handle->make_float = init_data->make_float;
2507
2508   if (ibuf->rect) {
2509     handle->rect = (unsigned char *)ibuf->rect + offset;
2510   }
2511
2512   if (ibuf->rect_float) {
2513     handle->rect_float = ibuf->rect_float + offset;
2514   }
2515
2516   if (mask) {
2517     if (mask->rect) {
2518       handle->mask_rect = (unsigned char *)mask->rect + offset;
2519     }
2520
2521     if (mask->rect_float) {
2522       handle->mask_rect_float = mask->rect_float + offset;
2523     }
2524   }
2525   else {
2526     handle->mask_rect = NULL;
2527     handle->mask_rect_float = NULL;
2528   }
2529 }
2530
2531 static void *color_balance_do_thread(void *thread_data_v)
2532 {
2533   ColorBalanceThread *thread_data = (ColorBalanceThread *)thread_data_v;
2534   StripColorBalance *cb = thread_data->cb;
2535   int width = thread_data->width, height = thread_data->height;
2536   unsigned char *rect = thread_data->rect;
2537   unsigned char *mask_rect = thread_data->mask_rect;
2538   float *rect_float = thread_data->rect_float;
2539   float *mask_rect_float = thread_data->mask_rect_float;
2540   float mul = thread_data->mul;
2541
2542   if (rect_float) {
2543     color_balance_float_float(cb, rect_float, mask_rect_float, width, height, mul);
2544   }
2545   else if (thread_data->make_float) {
2546     color_balance_byte_float(cb, rect, rect_float, mask_rect, width, height, mul);
2547   }
2548   else {
2549     color_balance_byte_byte(cb, rect, mask_rect, width, height, mul);
2550   }
2551
2552   return NULL;
2553 }
2554
2555 /* cfra is offset by fra_offset only in case we are using a real mask. */
2556 ImBuf *BKE_sequencer_render_mask_input(const SeqRenderData *context,
2557                                        int mask_input_type,
2558                                        Sequence *mask_sequence,
2559                                        Mask *mask_id,
2560                                        int cfra,
2561                                        int fra_offset,
2562                                        bool make_float)
2563 {
2564   ImBuf *mask_input = NULL;
2565
2566   if (mask_input_type == SEQUENCE_MASK_INPUT_STRIP) {
2567     if (mask_sequence) {
2568       SeqRenderState state;
2569       sequencer_state_init(&state);
2570
2571       mask_input = seq_render_strip(context, &state, mask_sequence, cfra);
2572
2573       if (make_float) {
2574         if (!mask_input->rect_float) {
2575           IMB_float_from_rect(mask_input);
2576         }
2577       }
2578       else {
2579         if (!mask_input->rect) {
2580           IMB_rect_from_float(mask_input);
2581         }
2582       }
2583     }
2584   }
2585   else if (mask_input_type == SEQUENCE_MASK_INPUT_ID) {
2586     mask_input = seq_render_mask(context, mask_id, cfra - fra_offset, make_float);
2587   }
2588
2589   return mask_input;
2590 }
2591
2592 void BKE_sequencer_color_balance_apply(
2593     StripColorBalance *cb, ImBuf *ibuf, float mul, bool make_float, ImBuf *mask_input)
2594 {
2595   ColorBalanceInitData init_data;
2596
2597   if (!ibuf->rect_float && make_float) {
2598     imb_addrectfloatImBuf(ibuf);
2599   }
2600
2601   init_data.cb = cb;
2602   init_data.ibuf = ibuf;
2603   init_data.mul = mul;
2604   init_data.make_float = make_float;
2605   init_data.mask = mask_input;
2606
2607   IMB_processor_apply_threaded(ibuf->y,
2608                                sizeof(ColorBalanceThread),
2609                                &init_data,
2610                                color_balance_init_handle,
2611                                color_balance_do_thread);
2612
2613   /* color balance either happens on float buffer or byte buffer, but never on both,
2614    * free byte buffer if there's float buffer since float buffer would be used for
2615    * color balance in favor of byte buffer
2616    */
2617   if (ibuf->rect_float && ibuf->rect) {
2618     imb_freerectImBuf(ibuf);
2619   }
2620 }
2621
2622 /*
2623  * input preprocessing for SEQ_TYPE_IMAGE, SEQ_TYPE_MOVIE, SEQ_TYPE_MOVIECLIP and SEQ_TYPE_SCENE
2624  *
2625  * Do all the things you can't really do afterwards using sequence effects
2626  * (read: before rescaling to render resolution has been done)
2627  *
2628  * Order is important!
2629  *
2630  * - Deinterlace
2631  * - Crop and transform in image source coordinate space
2632  * - Flip X + Flip Y (could be done afterwards, backward compatibility)
2633  * - Promote image to float data (affects pipeline operations afterwards)
2634  * - Color balance (is most efficient in the byte -> float
2635  *   (future: half -> float should also work fine!)
2636  *   case, if done on load, since we can use lookup tables)
2637  * - Premultiply
2638  */
2639
2640 bool BKE_sequencer_input_have_to_preprocess(const SeqRenderData *context,
2641                                             Sequence *seq,
2642                                             float UNUSED(cfra))
2643 {
2644   float mul;
2645
2646   if (context && context->is_proxy_render) {
2647     return false;
2648   }
2649
2650   if (seq->flag &
2651       (SEQ_FILTERY | SEQ_USE_CROP | SEQ_USE_TRANSFORM | SEQ_FLIPX | SEQ_FLIPY | SEQ_MAKE_FLOAT)) {
2652     return true;
2653   }
2654
2655   mul = seq->mul;
2656
2657   if (seq->blend_mode == SEQ_BLEND_REPLACE) {
2658     mul *= seq->blend_opacity / 100.0f;
2659   }
2660
2661   if (mul != 1.0f) {
2662     return true;
2663   }
2664
2665   if (seq->sat != 1.0f) {
2666     return true;
2667   }
2668
2669   if (seq->modifiers.first) {
2670     return true;
2671   }
2672
2673   return false;
2674 }
2675
2676 static ImBuf *input_preprocess(const SeqRenderData *context,
2677                                Sequence *seq,
2678                                float cfra,
2679                                ImBuf *ibuf,
2680                                const bool is_proxy_image,
2681                                const bool is_preprocessed)
2682 {
2683   Scene *scene = context->scene;
2684   float mul;
2685
2686   ibuf = IMB_makeSingleUser(ibuf);
2687
2688   if ((seq->flag & SEQ_FILTERY) && !ELEM(seq->type, SEQ_TYPE_MOVIE, SEQ_TYPE_MOVIECLIP)) {
2689     IMB_filtery(ibuf);
2690   }
2691
2692   if (seq->flag & (SEQ_USE_CROP | SEQ_USE_TRANSFORM)) {
2693     StripCrop c = {0};
2694     StripTransform t = {0};
2695     int sx, sy, dx, dy;
2696
2697     if (is_proxy_image) {
2698       double f = seq_rendersize_to_scale_factor(context->preview_render_size);
2699
2700       if (f != 1.0) {
2701         IMB_scalefastImBuf(ibuf, ibuf->x / f, ibuf->y / f);
2702       }
2703     }
2704
2705     if (seq->flag & SEQ_USE_CROP && seq->strip->crop) {
2706       c = *seq->strip->crop;
2707     }
2708     if (seq->flag & SEQ_USE_TRANSFORM && seq->strip->transform) {
2709       t = *seq->strip->transform;
2710     }
2711
2712     if (is_preprocessed) {
2713       double xscale = scene->r.xsch ? ((double)context->rectx / (double)scene->r.xsch) : 1.0;
2714       double yscale = scene->r.ysch ? ((double)context->recty / (double)scene->r.ysch) : 1.0;
2715       if (seq->flag & SEQ_USE_TRANSFORM) {
2716         t.xofs *= xscale;
2717         t.yofs *= yscale;
2718       }
2719       if (seq->flag & SEQ_USE_CROP) {
2720         c.left *= xscale;
2721         c.right *= xscale;
2722         c.top *= yscale;
2723         c.bottom *= yscale;
2724       }
2725     }
2726
2727     sx = ibuf->x - c.left - c.right;
2728     sy = ibuf->y - c.top - c.bottom;
2729
2730     if (seq->flag & SEQ_USE_TRANSFORM) {
2731       if (is_preprocessed) {
2732         dx = context->rectx;
2733         dy = context->recty;
2734       }
2735       else {
2736         dx = scene->r.xsch;
2737         dy = scene->r.ysch;
2738       }
2739     }
2740     else {
2741       dx = sx;
2742       dy = sy;
2743     }
2744
2745     if (c.top + c.bottom >= ibuf->y || c.left + c.right >= ibuf->x || t.xofs >= dx ||
2746         t.yofs >= dy) {
2747       make_black_ibuf(ibuf);
2748     }
2749     else {
2750       ImBuf *i = IMB_allocImBuf(dx, dy, 32, ibuf->rect_float ? IB_rectfloat : IB_rect);
2751
2752       IMB_rectcpy(i, ibuf, t.xofs, t.yofs, c.left, c.bottom, sx, sy);
2753       sequencer_imbuf_assign_spaces(scene, i);
2754
2755       IMB_metadata_copy(i, ibuf);
2756       IMB_freeImBuf(ibuf);
2757
2758       ibuf = i;
2759     }
2760   }
2761
2762   if (seq->flag & SEQ_FLIPX) {
2763     IMB_flipx(ibuf);
2764   }
2765
2766   if (seq->flag & SEQ_FLIPY) {
2767     IMB_flipy(ibuf);
2768   }
2769
2770   if (seq->sat != 1.0f) {
2771     IMB_saturation(ibuf, seq->sat);
2772   }
2773
2774   mul = seq->mul;
2775
2776   if (seq->blend_mode == SEQ_BLEND_REPLACE) {
2777     mul *= seq->blend_opacity / 100.0f;
2778   }
2779
2780   if (seq->flag & SEQ_MAKE_FLOAT) {
2781     if (!ibuf->rect_float) {
2782       BKE_sequencer_imbuf_to_sequencer_space(scene, ibuf, true);
2783     }
2784
2785     if (ibuf->rect) {
2786       imb_freerectImBuf(ibuf);
2787     }
2788   }
2789
2790   if (mul != 1.0f) {
2791     multibuf(ibuf, mul);
2792   }
2793
2794   if (ibuf->x != context->rectx || ibuf->y != context->recty) {
2795     if (scene->r.mode & R_OSA) {
2796       IMB_scaleImBuf(ibuf, (short)context->rectx, (short)context->recty);
2797     }
2798     else {
2799       IMB_scalefastImBuf(ibuf, (short)context->rectx, (short)context->recty);
2800     }
2801   }
2802
2803   if (seq->modifiers.first) {
2804     ImBuf *ibuf_new = BKE_sequence_modifier_apply_stack(context, seq, ibuf, cfra);
2805
2806     if (ibuf_new != ibuf) {
2807       IMB_metadata_copy(ibuf_new, ibuf);
2808       IMB_freeImBuf(ibuf);
2809       ibuf = ibuf_new;
2810     }
2811   }
2812
2813   return ibuf;
2814 }
2815
2816 /*********************** strip rendering functions  *************************/
2817
2818 typedef struct RenderEffectInitData {
2819   struct SeqEffectHandle *sh;
2820   const SeqRenderData *context;
2821   Sequence *seq;
2822   float cfra, facf0, facf1;
2823   ImBuf *ibuf1, *ibuf2, *ibuf3;
2824
2825   ImBuf *out;
2826 } RenderEffectInitData;
2827
2828 typedef struct RenderEffectThread {
2829   struct SeqEffectHandle *sh;
2830   const SeqRenderData *context;
2831   Sequence *seq;
2832   float cfra, facf0, facf1;
2833   ImBuf *ibuf1, *ibuf2, *ibuf3;
2834
2835   ImBuf *out;
2836   int start_line, tot_line;
2837 } RenderEffectThread;
2838
2839 static void render_effect_execute_init_handle(void *handle_v,
2840                                               int start_line,
2841                                               int tot_line,
2842                                               void *init_data_v)
2843 {
2844   RenderEffectThread *handle = (RenderEffectThread *)handle_v;
2845   RenderEffectInitData *init_data = (RenderEffectInitData *)init_data_v;
2846
2847   handle->sh = init_data->sh;
2848   handle->context = init_data->context;
2849   handle->seq = init_data->seq;
2850   handle->cfra = init_data->cfra;
2851   handle->facf0 = init_data->facf0;
2852   handle->facf1 = init_data->facf1;
2853   handle->ibuf1 = init_data->ibuf1;
2854   handle->ibuf2 = init_data->ibuf2;
2855   handle->ibuf3 = init_data->ibuf3;
2856   handle->out = init_data->out;
2857
2858   handle->start_line = start_line;
2859   handle->tot_line = tot_line;
2860 }
2861
2862 static void *render_effect_execute_do_thread(void *thread_data_v)
2863 {
2864   RenderEffectThread *thread_data = (RenderEffectThread *)thread_data_v;
2865
2866   thread_data->sh->execute_slice(thread_data->context,
2867                                  thread_data->seq,
2868                                  thread_data->cfra,
2869                                  thread_data->facf0,
2870                                  thread_data->facf1,
2871                                  thread_data->ibuf1,
2872                                  thread_data->ibuf2,
2873                                  thread_data->ibuf3,
2874                                  thread_data->start_line,
2875                                  thread_data->tot_line,
2876                                  thread_data->out);
2877
2878   return NULL;
2879 }
2880
2881 static ImBuf *seq_render_effect_execute_threaded(struct SeqEffectHandle *sh,
2882                                                  const SeqRenderData *context,
2883                                                  Sequence *seq,
2884                                                  float cfra,
2885                                                  float facf0,
2886                                                  float facf1,
2887                                                  ImBuf *ibuf1,
2888                                                  ImBuf *ibuf2,
2889                                                  ImBuf *ibuf3)
2890 {
2891   RenderEffectInitData init_data;
2892   ImBuf *out = sh->init_execution(context, ibuf1, ibuf2, ibuf3);
2893
2894   init_data.sh = sh;
2895   init_data.context = context;
2896   init_data.seq = seq;
2897   init_data.cfra = cfra;
2898   init_data.facf0 = facf0;
2899   init_data.facf1 = facf1;
2900   init_data.ibuf1 = ibuf1;
2901   init_data.ibuf2 = ibuf2;
2902   init_data.ibuf3 = ibuf3;
2903   init_data.out = out;
2904
2905   IMB_processor_apply_threaded(out->y,
2906                                sizeof(RenderEffectThread),
2907                                &init_data,
2908                                render_effect_execute_init_handle,
2909                                render_effect_execute_do_thread);
2910
2911   return out;
2912 }
2913
2914 static ImBuf *seq_render_effect_strip_impl(const SeqRenderData *context,
2915                                            SeqRenderState *state,
2916                                            Sequence *seq,
2917                                            float cfra)
2918 {
2919   Scene *scene = context->scene;
2920   float fac, facf;
2921   int early_out;
2922   int i;
2923   struct SeqEffectHandle sh = BKE_sequence_get_effect(seq);
2924   FCurve *fcu = NULL;
2925   ImBuf *ibuf[3];
2926   Sequence *input[3];
2927   ImBuf *out = NULL;
2928
2929   ibuf[0] = ibuf[1] = ibuf[2] = NULL;
2930
2931   input[0] = seq->seq1;
2932   input[1] = seq->seq2;
2933   input[2] = seq->seq3;
2934
2935   if (!sh.execute && !(sh.execute_slice && sh.init_execution)) {
2936     /* effect not supported in this version... */
2937     out = IMB_allocImBuf(context->rectx, context->recty, 32, IB_rect);
2938     return out;
2939   }
2940
2941   if (seq->flag & SEQ_USE_EFFECT_DEFAULT_FADE) {
2942     sh.get_default_fac(seq, cfra, &fac, &facf);
2943     facf = fac;
2944   }
2945   else {
2946     fcu = id_data_find_fcurve(&scene->id, seq, &RNA_Sequence, "effect_fader", 0, NULL);
2947     if (fcu) {
2948       fac = facf = evaluate_fcurve(fcu, cfra);
2949     }
2950     else {
2951       fac = facf = seq->effect_fader;
2952     }
2953   }
2954
2955   early_out = sh.early_out(seq, fac, facf);
2956
2957   switch (early_out) {
2958     case EARLY_NO_INPUT:
2959       out = sh.execute(context, seq, cfra, fac, facf, NULL, NULL, NULL);
2960       break;
2961     case EARLY_DO_EFFECT:
2962       for (i = 0; i < 3; i++) {
2963         if (input[i]) {
2964           ibuf[i] = seq_render_strip(context, state, input[i], cfra);
2965         }
2966       }
2967
2968       if (ibuf[0] && ibuf[1]) {
2969         if (sh.multithreaded) {
2970           out = seq_render_effect_execute_threaded(
2971               &sh, context, seq, cfra, fac, facf, ibuf[0], ibuf[1], ibuf[2]);
2972         }
2973         else {
2974           out = sh.execute(context, seq, cfra, fac, facf, ibuf[0], ibuf[1], ibuf[2]);
2975         }
2976       }
2977       break;
2978     case EARLY_USE_INPUT_1:
2979       if (input[0]) {
2980         ibuf[0] = seq_render_strip(context, state, input[0], cfra);
2981       }
2982       if (ibuf[0]) {
2983         if (BKE_sequencer_input_have_to_preprocess(context, seq, cfra)) {
2984           out = IMB_dupImBuf(ibuf[0]);
2985         }
2986         else {
2987           out = ibuf[0];
2988           IMB_refImBuf(out);
2989         }
2990       }
2991       break;
2992     case EARLY_USE_INPUT_2:
2993       if (input[1]) {
2994         ibuf[1] = seq_render_strip(context, state, input[1], cfra);
2995       }
2996       if (ibuf[1]) {
2997         if (BKE_sequencer_input_have_to_preprocess(context, seq, cfra)) {
2998           out = IMB_dupImBuf(ibuf[1]);
2999         }
3000         else {
3001           out = ibuf[1];
3002           IMB_refImBuf(out);
3003         }
3004       }
3005       break;
3006   }
3007
3008   for (i = 0; i < 3; i++) {
3009     IMB_freeImBuf(ibuf[i]);
3010   }
3011
3012   if (out == NULL) {
3013     out = IMB_allocImBuf(context->rectx, context->recty, 32, IB_rect);
3014   }
3015
3016   return out;
3017 }
3018
3019 static ImBuf *seq_render_image_strip(const SeqRenderData *context,
3020                                      Sequence *seq,
3021                                      float UNUSED(nr),
3022                                      float cfra)
3023 {
3024   ImBuf *ibuf = NULL;
3025   char name[FILE_MAX];
3026   bool is_multiview = (seq->flag & SEQ_USE_VIEWS) != 0 &&
3027                       (context->scene->r.scemode & R_MULTIVIEW) != 0;
3028   StripElem *s_elem = BKE_sequencer_give_stripelem(seq, cfra);
3029   int flag;
3030
3031   if (s_elem) {
3032     BLI_join_dirfile(name, sizeof(name), seq->strip->dir, s_elem->name);
3033     BLI_path_abs(name, BKE_main_blendfile_path_from_global());
3034   }
3035
3036   flag = IB_rect | IB_metadata;
3037   if (seq->alpha_mode == SEQ_ALPHA_PREMUL) {
3038     flag |= IB_alphamode_premul;
3039   }
3040
3041   if (!s_elem) {
3042     /* don't do anything */
3043   }
3044   else if (is_multiview) {
3045     const int totfiles = seq_num_files(context->scene, seq->views_format, true);
3046     int totviews;
3047     struct ImBuf **ibufs_arr;
3048     char prefix[FILE_MAX];
3049     const char *ext = NULL;
3050     int i;
3051
3052     if (totfiles > 1) {
3053       BKE_scene_multiview_view_prefix_get(context->scene, name, prefix, &ext);
3054       if (prefix[0] == '\0') {
3055         goto monoview_image;
3056       }
3057     }
3058     else {
3059       prefix[0] = '\0';
3060     }
3061
3062     totviews = BKE_scene_multiview_num_views_get(&context->scene->r);
3063     ibufs_arr = MEM_callocN(sizeof(ImBuf *) * totviews, "Sequence Image Views Imbufs");
3064
3065     for (i = 0; i < totfiles; i++) {
3066
3067       if (prefix[0] == '\0') {
3068         ibufs_arr[i] = IMB_loadiffname(name, flag, seq->strip->colorspace_settings.name);
3069       }
3070       else {
3071         char str[FILE_MAX];
3072         seq_multiview_name(context->scene, i, prefix, ext, str, FILE_MAX);
3073         ibufs_arr[i] = IMB_loadiffname(str, flag, seq->strip->colorspace_settings.name);
3074       }
3075
3076       if (ibufs_arr[i]) {
3077         /* we don't need both (speed reasons)! */
3078         if (ibufs_arr[i]->rect_float && ibufs_arr[i]->rect) {
3079           imb_freerectImBuf(ibufs_arr[i]);
3080         }
3081       }
3082     }
3083
3084     if (seq->views_format == R_IMF_VIEWS_STEREO_3D && ibufs_arr[0]) {
3085       IMB_ImBufFromStereo3d(seq->stereo3d_format, ibufs_arr[0], &ibufs_arr[0], &ibufs_arr[1]);
3086     }
3087
3088     for (i = 0; i < totviews; i++) {
3089       if (ibufs_arr[i]) {
3090         SeqRenderData localcontext = *context;
3091         localcontext.view_id = i;
3092
3093         /* all sequencer color is done in SRGB space, linear gives odd crossfades */
3094         BKE_sequencer_imbuf_to_sequencer_space(context->scene, ibufs_arr[i], false);
3095
3096         if (i != context->view_id) {
3097           BKE_sequencer_cache_put(
3098               &localcontext, seq, cfra, SEQ_CACHE_STORE_PREPROCESSED, ibufs_arr[i], 0);
3099         }
3100       }
3101     }
3102
3103     /* return the original requested ImBuf */
3104     ibuf = ibufs_arr[context->view_id];
3105     if (ibuf) {
3106       s_elem->orig_width = ibufs_arr[0]->x;
3107       s_elem->orig_height = ibufs_arr[0]->y;
3108     }
3109
3110     /* "remove" the others (decrease their refcount) */
3111     for (i = 0; i < totviews; i++) {
3112       if (ibufs_arr[i] != ibuf) {
3113         IMB_freeImBuf(ibufs_arr[i]);
3114       }
3115     }
3116
3117     MEM_freeN(ibufs_arr);
3118   }
3119   else {
3120   monoview_image:
3121     if ((ibuf = IMB_loadiffname(name, flag, seq->strip->colorspace_settings.name))) {
3122       /* we don't need both (speed reasons)! */
3123       if (ibuf->rect_float && ibuf->rect) {
3124         imb_freerectImBuf(ibuf);
3125       }
3126
3127       /* all sequencer color is done in SRGB space, linear gives odd crossfades */
3128       BKE_sequencer_imbuf_to_sequencer_space(context->scene, ibuf, false);
3129
3130       s_elem->orig_width = ibuf->x;
3131       s_elem->orig_height = ibuf->y;
3132     }
3133   }
3134
3135   return ibuf;
3136 }
3137
3138 static ImBuf *seq_render_movie_strip(const SeqRenderData *context,
3139                                      Sequence *seq,
3140                                      float nr,
3141                                      float cfra)
3142 {
3143   ImBuf *ibuf = NULL;
3144   StripAnim *sanim;
3145   bool is_multiview = (seq->flag & SEQ_USE_VIEWS) != 0 &&
3146                       (context->scene->r.scemode & R_MULTIVIEW) != 0;
3147
3148   /* load all the videos */
3149   seq_open_anim_file(context->scene, seq, false);
3150
3151   if (is_multiview) {
3152     ImBuf **ibuf_arr;
3153     const int totfiles = seq_num_files(context->scene, seq->views_format, true);
3154     int totviews;
3155     int i;
3156
3157     if (totfiles != BLI_listbase_count_at_most(&seq->anims, totfiles + 1)) {
3158       goto monoview_movie;
3159     }
3160
3161     totviews = BKE_scene_multiview_num_views_get(&context->scene->r);
3162     ibuf_arr = MEM_callocN(sizeof(ImBuf *) * totviews, "Sequence Image Views Imbufs");
3163
3164     for (i = 0, sanim = seq->anims.first; sanim; sanim = sanim->next, i++) {
3165       if (sanim->anim) {
3166         IMB_Proxy_Size proxy_size = seq_rendersize_to_proxysize(context->preview_render_size);
3167         IMB_anim_set_preseek(sanim->anim, seq->anim_preseek);
3168
3169         ibuf_arr[i] = IMB_anim_absolute(sanim->anim,
3170                                         nr + seq->anim_startofs,
3171                                         seq->strip->proxy ? seq->strip->proxy->tc :
3172                                                             IMB_TC_RECORD_RUN,
3173                                         proxy_size);
3174
3175         /* fetching for requested proxy size failed, try fetching the original instead */
3176         if (!ibuf_arr[i] && proxy_size != IMB_PROXY_NONE) {
3177           ibuf_arr[i] = IMB_anim_absolute(sanim->anim,
3178                                           nr + seq->anim_startofs,
3179                                           seq->strip->proxy ? seq->strip->proxy->tc :
3180                                                               IMB_TC_RECORD_RUN,
3181                                           IMB_PROXY_NONE);
3182         }
3183         if (ibuf_arr[i]) {
3184           /* we don't need both (speed reasons)! */
3185           if (ibuf_arr[i]->rect_float && ibuf_arr[i]->rect) {
3186             imb_freerectImBuf(ibuf_arr[i]);
3187           }
3188         }
3189       }
3190     }
3191
3192     if (seq->views_format == R_IMF_VIEWS_STEREO_3D) {
3193       if (ibuf_arr[0]) {
3194         IMB_ImBufFromStereo3d(seq->stereo3d_format, ibuf_arr[0], &ibuf_arr[0], &ibuf_arr[1]);
3195       }
3196       else {
3197         /* probably proxy hasn't been created yet */
3198         MEM_freeN(ibuf_arr);
3199         return NULL;
3200       }
3201     }
3202
3203     for (i = 0; i < totviews; i++) {
3204       SeqRenderData localcontext = *context;
3205       localcontext.view_id = i;
3206
3207       if (ibuf_arr[i]) {
3208         /* all sequencer color is done in SRGB space, linear gives odd crossfades */
3209         BKE_sequencer_imbuf_to_sequencer_space(context->scene, ibuf_arr[i], false);
3210       }
3211       if (i != context->view_id) {
3212         BKE_sequencer_cache_put(
3213             &localcontext, seq, cfra, SEQ_CACHE_STORE_PREPROCESSED, ibuf_arr[i], 0);
3214       }
3215     }
3216
3217     /* return the original requested ImBuf */
3218     ibuf = ibuf_arr[context->view_id];
3219     if (ibuf) {
3220       seq->strip->stripdata->orig_width = ibuf->x;
3221       seq->strip->stripdata->orig_height = ibuf->y;
3222     }
3223
3224     /* "remove" the others (decrease their refcount) */
3225     for (i = 0; i < totviews; i++) {
3226       if (ibuf_arr[i] != ibuf) {
3227         IMB_freeImBuf(ibuf_arr[i]);
3228       }
3229     }
3230
3231     MEM_freeN(ibuf_arr);
3232   }
3233   else {
3234   monoview_movie:
3235     sanim = seq->anims.first;
3236     if (sanim && sanim->anim) {
3237       IMB_Proxy_Size proxy_size = seq_rendersize_to_proxysize(context->preview_render_size);
3238       IMB_anim_set_preseek(sanim->anim, seq->anim_preseek);
3239
3240       ibuf = IMB_anim_absolute(sanim->anim,
3241                                nr + seq->anim_startofs,
3242                                seq->strip->proxy ? seq->strip->proxy->tc : IMB_TC_RECORD_RUN,
3243                                proxy_size);
3244
3245       /* fetching for requested proxy size failed, try fetching the original instead */
3246       if (!ibuf && proxy_size != IMB_PROXY_NONE) {
3247         ibuf = IMB_anim_absolute(sanim->anim,
3248                                  nr + seq->anim_startofs,
3249                                  seq->strip->proxy ? seq->strip->proxy->tc : IMB_TC_RECORD_RUN,
3250                                  IMB_PROXY_NONE);
3251       }
3252       if (ibuf) {
3253         BKE_sequencer_imbuf_to_sequencer_space(context->scene, ibuf, false);
3254
3255         /* we don't need both (speed reasons)! */
3256         if (ibuf->rect_float && ibuf->rect) {
3257           imb_freerectImBuf(ibuf);
3258         }
3259
3260         seq->strip->stripdata->orig_width = ibuf->x;
3261         seq->strip->stripdata->orig_height = ibuf->y;
3262       }
3263     }
3264   }
3265   return ibuf;
3266 }
3267
3268 static ImBuf *seq_render_movieclip_strip(const SeqRenderData *context, Sequence *seq, float nr)
3269 {
3270   ImBuf *ibuf = NULL;
3271   MovieClipUser user;
3272   float tloc[2], tscale, tangle;
3273
3274   if (!seq->clip) {
3275     return NULL;
3276   }
3277
3278   memset(&user, 0, sizeof(MovieClipUser));
3279
3280   BKE_movieclip_user_set_frame(&user, nr + seq->anim_startofs + seq->clip->start_frame);
3281
3282   user.render_flag |= MCLIP_PROXY_RENDER_USE_FALLBACK_RENDER;
3283
3284   user.render_size = MCLIP_PROXY_RENDER_SIZE_FULL;
3285   switch (seq_rendersize_to_proxysize(context->preview_render_size)) {
3286     case IMB_PROXY_NONE:
3287       user.render_size = MCLIP_PROXY_RENDER_SIZE_FULL;
3288       break;
3289     case IMB_PROXY_100:
3290       user.render_size = MCLIP_PROXY_RENDER_SIZE_100;
3291       break;
3292     case IMB_PROXY_75:
3293       user.render_size = MCLIP_PROXY_RENDER_SIZE_75;
3294       break;
3295     case IMB_PROXY_50:
3296       user.render_size = MCLIP_PROXY_RENDER_SIZE_50;
3297       break;
3298     case IMB_PROXY_25:
3299       user.render_size = MCLIP_PROXY_RENDER_SIZE_25;
3300       break;
3301   }
3302
3303   if (seq->clip_flag & SEQ_MOVIECLIP_RENDER_UNDISTORTED) {
3304     user.render_flag |= MCLIP_PROXY_RENDER_UNDISTORT;
3305   }
3306
3307   if (seq->clip_flag & SEQ_MOVIECLIP_RENDER_STABILIZED) {
3308     ibuf = BKE_movieclip_get_stable_ibuf(seq->clip, &user, tloc, &tscale, &tangle, 0);
3309   }
3310   else {
3311     ibuf = BKE_movieclip_get_ibuf_flag(seq->clip, &user, seq->clip->flag, MOVIECLIP_CACHE_SKIP);
3312   }
3313
3314   return ibuf;
3315 }
3316
3317 static ImBuf *seq_render_mask(const SeqRenderData *context, Mask *mask, float nr, bool make_float)
3318 {
3319   /* TODO - add option to rasterize to alpha imbuf? */
3320   ImBuf *ibuf = NULL;
3321   float *maskbuf;
3322   int i;
3323
3324   if (!mask) {
3325     return NULL;
3326   }
3327   else {
3328     AnimData *adt;
3329     Mask *mask_temp;
3330     MaskRasterHandle *mr_handle;
3331
3332     mask_temp = BKE_mask_copy_nolib(mask);
3333
3334     BKE_mask_evaluate(mask_temp, mask->sfra + nr, true);
3335
3336     /* anim-data */
3337     adt = BKE_animdata_from_id(&mask->id);
3338     BKE_animsys_evaluate_animdata(
3339         context->depsgraph, context->scene, &mask_temp->id, adt, nr, ADT_RECALC_ANIM);
3340
3341     maskbuf = MEM_mallocN(sizeof(float) * context->rectx * context->recty, __func__);
3342
3343     mr_handle = BKE_maskrasterize_handle_new();
3344
3345     BKE_maskrasterize_handle_init(
3346         mr_handle, mask_temp, context->rectx, context->recty, true, true, true);
3347
3348     BKE_mask_free(mask_temp);
3349     MEM_freeN(mask_temp);
3350
3351     BKE_maskrasterize_buffer(mr_handle, context->rectx, context->recty, maskbuf);
3352
3353     BKE_maskrasterize_handle_free(mr_handle);
3354   }
3355
3356   if (make_float) {
3357     /* pixels */
3358     const float *fp_src;
3359     float *fp_dst;
3360
3361     ibuf = IMB_allocImBuf(context->rectx, context->recty, 32, IB_rectfloat);
3362
3363     fp_src = maskbuf;
3364     fp_dst = ibuf->rect_float;
3365     i = context->rectx * context->recty;
3366     while (--i) {
3367       fp_dst[0] = fp_dst[1] = fp_dst[2] = *fp_src;
3368       fp_dst[3] = 1.0f;
3369
3370       fp_src += 1;
3371       fp_dst += 4;
3372     }
3373   }
3374   else {
3375     /* pixels */
3376     const float *fp_src;
3377     unsigned char *ub_dst;
3378
3379     ibuf = IMB_allocImBuf(context->rectx, context->recty, 32, IB_rect);
3380
3381     fp_src = maskbuf;
3382     ub_dst = (unsigned char *)ibuf->rect;
3383     i = context->rectx * context->recty;
3384     while (--i) {
3385       ub_dst[0] = ub_dst[1] = ub_dst[2] = (unsigned char)(*fp_src * 255.0f); /* already clamped */
3386       ub_dst[3] = 255;
3387
3388       fp_src += 1;
3389       ub_dst += 4;
3390     }
3391   }
3392
3393   MEM_freeN(maskbuf);
3394
3395   return ibuf;
3396 }
3397
3398 static ImBuf *seq_render_mask_strip(const SeqRenderData *context, Sequence *seq, float nr)
3399 {
3400   bool make_float = (seq->flag & SEQ_MAKE_FLOAT) != 0;
3401
3402   return seq_render_mask(context, seq->mask, nr, make_float);
3403 }
3404
3405 static ImBuf *seq_render_scene_strip(const SeqRenderData *context,
3406                                      Sequence *seq,
3407                                      float nr,
3408                                      float cfra)
3409 {
3410   ImBuf *ibuf = NULL;
3411   double frame;
3412   Object *camera;
3413
3414   struct {
3415     int scemode;
3416     int cfra;
3417     float subframe;
3418
3419 #ifdef DURIAN_CAMERA_SWITCH
3420     int mode;
3421 #endif
3422   } orig_data;
3423
3424   /* Old info:
3425    * Hack! This function can be called from do_render_seq(), in that case
3426    * the seq->scene can already have a Render initialized with same name,
3427    * so we have to use a default name. (compositor uses scene name to
3428    * find render).
3429    * However, when called from within the UI (image preview in sequencer)
3430    * we do want to use scene Render, that way the render result is defined
3431    * for display in render/imagewindow
3432    *
3433    * Hmm, don't see, why we can't do that all the time,
3434    * and since G.is_rendering is uhm, gone... (Peter)
3435    */
3436
3437   /* New info:
3438    * Using the same name for the renders works just fine as the do_render_seq()
3439    * render is not used while the scene strips are rendered.
3440    *
3441    * However rendering from UI (through sequencer_preview_area_draw) can crash in
3442    * very many cases since other renders (material preview, an actual render etc.)
3443    * can be started while this sequence preview render is running. The only proper
3444    * solution is to make the sequencer preview render a proper job, which can be
3445    * stopped when needed. This would also give a nice progress bar for the preview
3446    * space so that users know there's something happening.
3447    *
3448    * As a result the active scene now only uses OpenGL rendering for the sequencer
3449    * preview. This is far from nice, but is the only way to prevent crashes at this
3450    * time.
3451    *
3452    * -jahka
3453    */
3454
3455   const bool is_rendering = G.is_rendering;
3456   const bool is_background = G.background;
3457   const bool do_seq_gl = is_rendering ? 0 /* (context->scene->r.seq_flag & R_SEQ_GL_REND) */ :
3458                                         (context->scene->r.seq_prev_type) != OB_RENDER;
3459   // bool have_seq = false;  /* UNUSED */
3460   bool have_comp = false;
3461   bool use_gpencil = true;
3462   /* do we need to re-evaluate the frame after rendering? */
3463   bool is_frame_update = false;
3464   Scene *scene;
3465   int is_thread_main = BLI_thread_is_main();
3466
3467   /* don't refer to seq->scene above this point!, it can be NULL */
3468   if (seq->scene == NULL) {
3469     return NULL;
3470   }
3471
3472   scene = seq->scene;
3473   frame = (double)scene->r.sfra + (double)nr + (double)seq->anim_startofs;
3474
3475 #if 0 /* UNUSED */
3476   have_seq = (scene->r.scemode & R_DOSEQ) && scene->ed && scene->ed->seqbase.first);
3477 #endif
3478   have_comp = (scene->r.scemode & R_DOCOMP) && scene->use_nodes && scene->nodetree;
3479
3480   /* Get view layer for the strip. */
3481   ViewLayer *view_layer = BKE_view_layer_default_render(scene);
3482   /* Depsgraph will be NULL when doing rendering. */
3483   Depsgraph *depsgraph = NULL;
3484
3485   orig_data.scemode = scene->r.scemode;
3486   orig_data.cfra = scene->r.cfra;
3487   orig_data.subframe = scene->r.subframe;
3488 #ifdef DURIAN_CAMERA_SWITCH
3489   orig_data.mode = scene->r.mode;
3490 #endif
3491
3492   BKE_scene_frame_set(scene, frame);
3493
3494   if (seq->scene_camera) {
3495     camera = seq->scene_camera;
3496   }
3497   else {
3498     BKE_scene_camera_switch_update(scene);
3499     camera = scene->camera;
3500   }
3501
3502   if (have_comp == false && camera == NULL) {
3503     goto finally;
3504   }
3505
3506   if (seq->flag & SEQ_SCENE_NO_GPENCIL) {
3507     use_gpencil = false;
3508   }
3509
3510   /* prevent eternal loop */
3511   scene->r.scemode &= ~R_DOSEQ;
3512
3513 #ifdef DURIAN_CAMERA_SWITCH
3514   /* stooping to new low's in hackyness :( */
3515   scene->r.mode |= R_NO_CAMERA_SWITCH;
3516 #endif
3517
3518   is_frame_update = (orig_data.cfra != scene->r.cfra) || (orig_data.subframe != scene->r.subframe);
3519
3520   if ((sequencer_view3d_cb && do_seq_gl && camera) && is_thread_main) {
3521     char err_out[256] = "unknown";
3522     const int width = (scene->r.xsch * scene->r.size) / 100;
3523     const int height = (scene->r.ysch * scene->r.size) / 100;
3524     const bool use_background = (scene->r.alphamode == R_ADDSKY);
3525     const char *viewname = BKE_scene_multiview_render_view_name_get(&scene->r, context->view_id);
3526
3527     unsigned int draw_flags = SEQ_OFSDRAW_NONE;
3528     draw_flags |= (use_gpencil) ? SEQ_OFSDRAW_USE_GPENCIL : 0;
3529     draw_flags |= (use_background) ? SEQ_OFSDRAW_USE_BACKGROUND : 0;
3530     draw_flags |= (context->gpu_full_samples) ? SEQ_OFSDRAW_USE_FULL_SAMPLE : 0;
3531     draw_flags |= (context->scene->r.seq_flag & R_SEQ_SOLID_TEX) ? SEQ_OFSDRAW_USE_SOLID_TEX : 0;
3532     draw_flags |= (context->scene->r.seq_flag & R_SEQ_CAMERA_DOF) ? SEQ_OFSDRAW_USE_CAMERA_DOF : 0;
3533
3534     /* for old scene this can be uninitialized,
3535      * should probably be added to do_versions at some point if the functionality stays */
3536     if (context->scene->r.seq_prev_type == 0) {
3537       context->scene->r.seq_prev_type = 3 /* == OB_SOLID */;
3538     }
3539
3540     /* opengl offscreen render */
3541     depsgraph = BKE_scene_get_depsgraph(scene, view_layer, true);
3542     BKE_scene_graph_update_for_newframe(depsgraph, context->bmain);
3543     ibuf = sequencer_view3d_cb(
3544         /* set for OpenGL render (NULL when scrubbing) */
3545         depsgraph,
3546         scene,
3547         context->scene->r.seq_prev_type,
3548         camera,
3549         width,
3550         height,
3551         IB_rect,
3552         draw_flags,
3553         scene->r.alphamode,
3554         context->gpu_samples,
3555         viewname,
3556         context->gpu_offscreen,
3557         err_out);
3558     if (ibuf == NULL) {
3559       fprintf(stderr, "seq_render_scene_strip failed to get opengl buffer: %s\n", err_out);
3560     }
3561   }
3562   else {
3563     Render *re = RE_GetSceneRender(scene);
3564     const int totviews = BKE_scene_multiview_num_views_get(&scene->r);
3565     int i;
3566     ImBuf **ibufs_arr;
3567
3568     ibufs_arr = MEM_callocN(sizeof(ImBuf *) * totviews, "Sequence Image Views Imbufs");
3569
3570     /* XXX: this if can be removed when sequence preview rendering uses the job system
3571      *
3572      * disable rendered preview for sequencer while rendering -- it's very much possible
3573      * that preview render will went into conflict with final render
3574      *
3575      * When rendering from command line renderer is called from main thread, in this
3576      * case it's always safe to render scene here
3577      */
3578     if (!is_thread_main || is_rendering == false || is_background || context->for_render) {
3579       if (re == NULL) {
3580         re = RE_NewSceneRender(scene);
3581       }
3582
3583       RE_BlenderFrame(re, context->bmain, scene, view_layer, camera, frame, false);
3584
3585       /* restore previous state after it was toggled on & off by RE_BlenderFrame */
3586       G.is_rendering = is_rendering;
3587     }
3588
3589     for (i = 0; i < totviews; i++) {
3590       SeqRenderData localcontext = *context;
3591       RenderResult rres;
3592
3593       localcontext.view_id = i;
3594
3595       RE_AcquireResultImage(re, &rres, i);
3596
3597       if (rres.rectf) {
3598         ibufs_arr[i] = IMB_allocImBuf(rres.rectx, rres.recty, 32, IB_rectfloat);
3599         memcpy(ibufs_arr[i]->rect_float, rres.rectf, 4 * sizeof(float) * rres.rectx * rres.recty);
3600
3601         if (rres.rectz) {
3602           addzbuffloatImBuf(ibufs_arr[i]);
3603           memcpy(ibufs_arr[i]->zbuf_float, rres.rectz, sizeof(float) * rres.rectx * rres.recty);
3604         }
3605
3606         /* float buffers in the sequencer are not linear */
3607         BKE_sequencer_imbuf_to_sequencer_space(context->scene, ibufs_arr[i], false);
3608       }
3609       else if (rres.rect32) {
3610         ibufs_arr[i] = IMB_allocImBuf(rres.rectx, rres.recty, 32, IB_rect);
3611         memcpy(ibufs_arr[i]->rect, rres.rect32, 4 * rres.rectx * rres.recty);
3612       }
3613
3614       if (i != context->view_id) {
3615         BKE_sequencer_cache_put(&localcontext, seq, cfra, SEQ_CACHE_STORE_RAW, ibufs_arr[i], 0);
3616       }
3617
3618       RE_ReleaseResultImage(re);
3619     }
3620
3621     /* return the original requested ImBuf */
3622     ibuf = ibufs_arr[context->view_id];
3623
3624     /* "remove" the others (decrease their refcount) */
3625     for (i = 0; i < totviews; i++) {
3626       if (ibufs_arr[i] != ibuf) {
3627         IMB_freeImBuf(ibufs_arr[i]);
3628       }
3629     }
3630     MEM_freeN(ibufs_arr);
3631   }
3632
3633 finally:
3634   /* restore */
3635   scene->r.scemode = orig_data.scemode;
3636   scene->r.cfra = orig_data.cfra;
3637   scene->r.subframe = orig_data.subframe;
3638
3639   if (is_frame_update && (depsgraph != NULL)) {
3640     BKE_scene_graph_update_for_newframe(depsgraph, context->bmain);
3641   }
3642
3643 #ifdef DURIAN_CAMERA_SWITCH
3644   /* stooping to new low's in hackyness :( */
3645   scene->r.mode &= ~(orig_data.mode & R_NO_CAMERA_SWITCH);
3646 #endif
3647
3648   return ibuf;
3649 }
3650
3651 /**
3652  * Used for meta-strips & scenes with #SEQ_SCENE_STRIPS flag set.
3653  */
3654 static ImBuf *do_render_strip_seqbase(const SeqRenderData *context,
3655                                       SeqRenderState *state,
3656                                       Sequence *seq,
3657                                       float nr,
3658                                       bool use_preprocess)
3659 {
3660   ImBuf *meta_ibuf = NULL, *ibuf = NULL;
3661   ListBase *seqbase = NULL;
3662   int offset;
3663
3664   seqbase = BKE_sequence_seqbase_get(seq, &offset);
3665
3666   if (seqbase && !BLI_listbase_is_empty(seqbase)) {
3667     meta_ibuf = seq_render_strip_stack(context,
3668                                        state,
3669                                        seqbase,
3670                                        /* scene strips don't have their start taken into account */
3671                                        nr + offset,
3672                                        0);
3673   }