51162c8f99f65eddae9d2a34c6b8eaebce7601d3
[blender.git] / source / blender / editors / space_sequencer / sequencer_draw.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
20 /** \file
21  * \ingroup spseq
22  */
23
24 #include <string.h>
25 #include <math.h>
26
27 #include "BLI_blenlib.h"
28 #include "BLI_math.h"
29 #include "BLI_utildefines.h"
30 #include "BLI_threads.h"
31
32 #include "IMB_imbuf_types.h"
33
34 #include "DNA_scene_types.h"
35 #include "DNA_mask_types.h"
36 #include "DNA_object_types.h"
37 #include "DNA_screen_types.h"
38 #include "DNA_space_types.h"
39 #include "DNA_userdef_types.h"
40 #include "DNA_sound_types.h"
41
42 #include "BKE_context.h"
43 #include "BKE_global.h"
44 #include "BKE_sequencer.h"
45 #include "BKE_sound.h"
46 #include "BKE_scene.h"
47
48 #include "IMB_colormanagement.h"
49 #include "IMB_imbuf.h"
50
51 #include "GPU_immediate.h"
52 #include "GPU_immediate_util.h"
53 #include "GPU_matrix.h"
54 #include "GPU_state.h"
55 #include "GPU_framebuffer.h"
56
57 #include "ED_anim_api.h"
58 #include "ED_gpencil.h"
59 #include "ED_markers.h"
60 #include "ED_mask.h"
61 #include "ED_sequencer.h"
62 #include "ED_screen.h"
63 #include "ED_time_scrub_ui.h"
64 #include "ED_space_api.h"
65
66 #include "BIF_glutil.h"
67
68 #include "UI_interface.h"
69 #include "UI_resources.h"
70 #include "UI_view2d.h"
71
72 #include "WM_api.h"
73
74 #include "MEM_guardedalloc.h"
75
76 /* own include */
77 #include "sequencer_intern.h"
78
79 #define SEQ_LEFTHANDLE 1
80 #define SEQ_RIGHTHANDLE 2
81
82 #define SEQ_HANDLE_SIZE_MIN 7.0f
83 #define SEQ_HANDLE_SIZE_MAX 40.0f
84
85 #define SEQ_SCROLLER_TEXT_OFFSET 8
86
87 /* Note, Don't use SEQ_BEGIN/SEQ_END while drawing!
88  * it messes up transform, - Campbell */
89 #undef SEQ_BEGIN
90 #undef SEQP_BEGIN
91 #undef SEQ_END
92
93 static Sequence *special_seq_update = NULL;
94
95 void color3ubv_from_seq(Scene *curscene, Sequence *seq, unsigned char col[3])
96 {
97   unsigned char blendcol[3];
98   SolidColorVars *colvars = (SolidColorVars *)seq->effectdata;
99
100   switch (seq->type) {
101     case SEQ_TYPE_IMAGE:
102       UI_GetThemeColor3ubv(TH_SEQ_IMAGE, col);
103       break;
104
105     case SEQ_TYPE_META:
106       UI_GetThemeColor3ubv(TH_SEQ_META, col);
107       break;
108
109     case SEQ_TYPE_MOVIE:
110       UI_GetThemeColor3ubv(TH_SEQ_MOVIE, col);
111       break;
112
113     case SEQ_TYPE_MOVIECLIP:
114       UI_GetThemeColor3ubv(TH_SEQ_MOVIECLIP, col);
115       break;
116
117     case SEQ_TYPE_MASK:
118       UI_GetThemeColor3ubv(TH_SEQ_MASK, col); /* TODO */
119       break;
120
121     case SEQ_TYPE_SCENE:
122       UI_GetThemeColor3ubv(TH_SEQ_SCENE, col);
123
124       if (seq->scene == curscene) {
125         UI_GetColorPtrShade3ubv(col, col, 20);
126       }
127       break;
128
129     /* transitions */
130     case SEQ_TYPE_CROSS:
131     case SEQ_TYPE_GAMCROSS:
132     case SEQ_TYPE_WIPE:
133       UI_GetThemeColor3ubv(TH_SEQ_TRANSITION, col);
134
135       /* slightly offset hue to distinguish different effects */
136       if (seq->type == SEQ_TYPE_CROSS) {
137         rgb_byte_set_hue_float_offset(col, 0.04);
138       }
139       if (seq->type == SEQ_TYPE_GAMCROSS) {
140         rgb_byte_set_hue_float_offset(col, 0.08);
141       }
142       if (seq->type == SEQ_TYPE_WIPE) {
143         rgb_byte_set_hue_float_offset(col, 0.12);
144       }
145       break;
146
147     /* effects */
148     case SEQ_TYPE_TRANSFORM:
149     case SEQ_TYPE_SPEED:
150     case SEQ_TYPE_ADD:
151     case SEQ_TYPE_SUB:
152     case SEQ_TYPE_MUL:
153     case SEQ_TYPE_ALPHAOVER:
154     case SEQ_TYPE_ALPHAUNDER:
155     case SEQ_TYPE_OVERDROP:
156     case SEQ_TYPE_GLOW:
157     case SEQ_TYPE_MULTICAM:
158     case SEQ_TYPE_ADJUSTMENT:
159     case SEQ_TYPE_GAUSSIAN_BLUR:
160     case SEQ_TYPE_COLORMIX:
161       UI_GetThemeColor3ubv(TH_SEQ_EFFECT, col);
162
163       /* slightly offset hue to distinguish different effects */
164       if (seq->type == SEQ_TYPE_ADD) {
165         rgb_byte_set_hue_float_offset(col, 0.04);
166       }
167       else if (seq->type == SEQ_TYPE_SUB) {
168         rgb_byte_set_hue_float_offset(col, 0.08);
169       }
170       else if (seq->type == SEQ_TYPE_MUL) {
171         rgb_byte_set_hue_float_offset(col, 0.12);
172       }
173       else if (seq->type == SEQ_TYPE_ALPHAOVER) {
174         rgb_byte_set_hue_float_offset(col, 0.16);
175       }
176       else if (seq->type == SEQ_TYPE_ALPHAUNDER) {
177         rgb_byte_set_hue_float_offset(col, 0.20);
178       }
179       else if (seq->type == SEQ_TYPE_OVERDROP) {
180         rgb_byte_set_hue_float_offset(col, 0.24);
181       }
182       else if (seq->type == SEQ_TYPE_GLOW) {
183         rgb_byte_set_hue_float_offset(col, 0.28);
184       }
185       else if (seq->type == SEQ_TYPE_TRANSFORM) {
186         rgb_byte_set_hue_float_offset(col, 0.36);
187       }
188       else if (seq->type == SEQ_TYPE_MULTICAM) {
189         rgb_byte_set_hue_float_offset(col, 0.32);
190       }
191       else if (seq->type == SEQ_TYPE_ADJUSTMENT) {
192         rgb_byte_set_hue_float_offset(col, 0.40);
193       }
194       else if (seq->type == SEQ_TYPE_GAUSSIAN_BLUR) {
195         rgb_byte_set_hue_float_offset(col, 0.42);
196       }
197       else if (seq->type == SEQ_TYPE_COLORMIX) {
198         rgb_byte_set_hue_float_offset(col, 0.46);
199       }
200       break;
201
202     case SEQ_TYPE_COLOR:
203       rgb_float_to_uchar(col, colvars->col);
204       break;
205
206     case SEQ_TYPE_SOUND_RAM:
207       UI_GetThemeColor3ubv(TH_SEQ_AUDIO, col);
208       blendcol[0] = blendcol[1] = blendcol[2] = 128;
209       if (seq->flag & SEQ_MUTE) {
210         UI_GetColorPtrBlendShade3ubv(col, blendcol, col, 0.5, 20);
211       }
212       break;
213
214     case SEQ_TYPE_TEXT:
215       UI_GetThemeColor3ubv(TH_SEQ_TEXT, col);
216       break;
217
218     default:
219       col[0] = 10;
220       col[1] = 255;
221       col[2] = 40;
222       break;
223   }
224 }
225
226 static void drawseqwave(View2D *v2d,
227                         const bContext *C,
228                         SpaceSeq *sseq,
229                         Scene *scene,
230                         Sequence *seq,
231                         float x1,
232                         float y1,
233                         float x2,
234                         float y2,
235                         float stepsize)
236 {
237   /*
238    * x1 is the starting x value to draw the wave,
239    * x2 the end x value, same for y1 and y2
240    * stepsize is width of a pixel.
241    */
242
243   /* offset x1 and x2 values, to match view min/max, if strip is out of bounds */
244   int x1_offset = max_ff(v2d->cur.xmin, x1);
245   int x2_offset = min_ff(v2d->cur.xmax + 1.0f, x2);
246
247   if (seq->sound && ((sseq->flag & SEQ_ALL_WAVEFORMS) || (seq->flag & SEQ_AUDIO_DRAW_WAVEFORM))) {
248     int i, j, p;
249     int length = floor((x2_offset - x1_offset) / stepsize) + 1;
250     float ymid = (y1 + y2) / 2.0f;
251     float yscale = (y2 - y1) / 2.0f;
252     float samplestep;
253     float startsample, endsample;
254     float value1, value2;
255     bSound *sound = seq->sound;
256
257     SoundWaveform *waveform;
258
259     if (length < 2) {
260       return;
261     }
262
263     if (!sound->spinlock) {
264       sound->spinlock = MEM_mallocN(sizeof(SpinLock), "sound_spinlock");
265       BLI_spin_init(sound->spinlock);
266     }
267
268     BLI_spin_lock(sound->spinlock);
269     if (!sound->waveform) {
270       if (!(sound->tags & SOUND_TAGS_WAVEFORM_LOADING)) {
271         /* prevent sounds from reloading */
272         sound->tags |= SOUND_TAGS_WAVEFORM_LOADING;
273         BLI_spin_unlock(sound->spinlock);
274         sequencer_preview_add_sound(C, seq);
275       }
276       else {
277         BLI_spin_unlock(sound->spinlock);
278       }
279       return; /* nothing to draw */
280     }
281     BLI_spin_unlock(sound->spinlock);
282
283     waveform = sound->waveform;
284
285     if (waveform->length == 0) {
286       /* BKE_sound_read_waveform() set an empty SoundWaveform data in case it cannot generate a
287        * valid one. See T45726. */
288       return;
289     }
290
291     startsample = floor((seq->startofs + seq->anim_startofs) / FPS *
292                         SOUND_WAVE_SAMPLES_PER_SECOND);
293     endsample = ceil((seq->startofs + seq->anim_startofs + seq->enddisp - seq->startdisp) / FPS *
294                      SOUND_WAVE_SAMPLES_PER_SECOND);
295     samplestep = (endsample - startsample) * stepsize / (x2 - x1);
296
297     length = min_ii(
298         floor((waveform->length - startsample) / samplestep - (x1_offset - x1) / stepsize),
299         length);
300
301     if (length < 2) {
302       return;
303     }
304
305     GPU_blend(true);
306     GPUVertFormat *format = immVertexFormat();
307     uint pos = GPU_vertformat_attr_add(format, "pos", GPU_COMP_F32, 2, GPU_FETCH_FLOAT);
308     uint col = GPU_vertformat_attr_add(format, "color", GPU_COMP_F32, 4, GPU_FETCH_FLOAT);
309     immBindBuiltinProgram(GPU_SHADER_2D_FLAT_COLOR);
310     immBegin(GPU_PRIM_TRI_STRIP, length * 2);
311
312     for (i = 0; i < length; i++) {
313       float sampleoffset = startsample + ((x1_offset - x1) / stepsize + i) * samplestep;
314       p = sampleoffset;
315
316       value1 = waveform->data[p * 3];
317       value2 = waveform->data[p * 3 + 1];
318
319       if (samplestep > 1.0f) {
320         for (j = p + 1; (j < waveform->length) && (j < p + samplestep); j++) {
321           if (value1 > waveform->data[j * 3]) {
322             value1 = waveform->data[j * 3];
323           }
324
325           if (value2 < waveform->data[j * 3 + 1]) {
326             value2 = waveform->data[j * 3 + 1];
327           }
328         }
329       }
330       else if (p + 1 < waveform->length) {
331         /* use simple linear interpolation */
332         float f = sampleoffset - p;
333         value1 = (1.0f - f) * value1 + f * waveform->data[p * 3 + 3];
334         value2 = (1.0f - f) * value2 + f * waveform->data[p * 3 + 4];
335       }
336
337       value1 *= seq->volume;
338       value2 *= seq->volume;
339
340       if (value2 > 1 || value1 < -1) {
341         immAttr4f(col, 1.0f, 0.0f, 0.0f, 0.5f);
342
343         CLAMP_MAX(value2, 1.0f);
344         CLAMP_MIN(value1, -1.0f);
345       }
346       else {
347         immAttr4f(col, 1.0f, 1.0f, 1.0f, 0.5f);
348       }
349
350       immVertex2f(pos, x1_offset + i * stepsize, ymid + value1 * yscale);
351       immVertex2f(pos, x1_offset + i * stepsize, ymid + value2 * yscale);
352     }
353
354     immEnd();
355     immUnbindProgram();
356     GPU_blend(false);
357   }
358 }
359 static void drawmeta_contents(Scene *scene, Sequence *seqm, float x1, float y1, float x2, float y2)
360 {
361   /* note: this used to use SEQ_BEGIN/SEQ_END, but it messes up the
362    * seq->depth value, (needed by transform when doing overlap checks)
363    * so for now, just use the meta's immediate children, could be fixed but
364    * its only drawing - campbell */
365   Sequence *seq;
366   unsigned char col[4];
367
368   int chan_min = MAXSEQ;
369   int chan_max = 0;
370   int chan_range = 0;
371   float draw_range = y2 - y1;
372   float draw_height;
373   ListBase *seqbase;
374   int offset;
375
376   seqbase = BKE_sequence_seqbase_get(seqm, &offset);
377   if (!seqbase || BLI_listbase_is_empty(seqbase)) {
378     return;
379   }
380
381   if (seqm->type == SEQ_TYPE_SCENE) {
382     offset = seqm->start - offset;
383   }
384   else {
385     offset = 0;
386   }
387
388   GPU_blend(true);
389   GPU_blend_set_func_separate(
390       GPU_SRC_ALPHA, GPU_ONE_MINUS_SRC_ALPHA, GPU_ONE, GPU_ONE_MINUS_SRC_ALPHA);
391
392   for (seq = seqbase->first; seq; seq = seq->next) {
393     chan_min = min_ii(chan_min, seq->machine);
394     chan_max = max_ii(chan_max, seq->machine);
395   }
396
397   chan_range = (chan_max - chan_min) + 1;
398   draw_height = draw_range / chan_range;
399
400   col[3] = 196; /* alpha, used for all meta children */
401
402   uint pos = GPU_vertformat_attr_add(immVertexFormat(), "pos", GPU_COMP_F32, 2, GPU_FETCH_FLOAT);
403
404   immBindBuiltinProgram(GPU_SHADER_2D_UNIFORM_COLOR);
405
406   for (seq = seqbase->first; seq; seq = seq->next) {
407     const int startdisp = seq->startdisp + offset;
408     const int enddisp = seq->enddisp + offset;
409
410     if ((startdisp > x2 || enddisp < x1) == 0) {
411       float y_chan = (seq->machine - chan_min) / (float)(chan_range)*draw_range;
412       float x1_chan = startdisp;
413       float x2_chan = enddisp;
414       float y1_chan, y2_chan;
415
416       color3ubv_from_seq(scene, seq, col);
417
418       if ((seqm->flag & SEQ_MUTE) || (seq->flag & SEQ_MUTE)) {
419         col[3] = 64;
420       }
421       else {
422         col[3] = 196;
423       }
424
425       immUniformColor4ubv(col);
426
427       /* clamp within parent sequence strip bounds */
428       if (x1_chan < x1) {
429         x1_chan = x1;
430       }
431       if (x2_chan > x2) {
432         x2_chan = x2;
433       }
434
435       y1_chan = y1 + y_chan + (draw_height * SEQ_STRIP_OFSBOTTOM);
436       y2_chan = y1 + y_chan + (draw_height * SEQ_STRIP_OFSTOP);
437
438       immRectf(pos, x1_chan, y1_chan, x2_chan, y2_chan);
439     }
440   }
441
442   immUnbindProgram();
443
444   GPU_blend(false);
445 }
446
447 /* clamp handles to defined size in pixel space */
448 static float draw_seq_handle_size_get_clamped(Sequence *seq, const float pixelx)
449 {
450   const float minhandle = pixelx * SEQ_HANDLE_SIZE_MIN;
451   const float maxhandle = pixelx * SEQ_HANDLE_SIZE_MAX;
452   float size = CLAMPIS(seq->handsize, minhandle, maxhandle);
453
454   /* ensure we're not greater than half width */
455   return min_ff(size, ((float)(seq->enddisp - seq->startdisp) / 2.0f) / pixelx);
456 }
457
458 /* draw a handle, for each end of a sequence strip */
459 static void draw_seq_handle(View2D *v2d,
460                             Sequence *seq,
461                             const float handsize_clamped,
462                             const short direction,
463                             unsigned int pos)
464 {
465   float v1[2], v2[2], v3[2], rx1 = 0, rx2 = 0;  // for triangles and rect
466   float x1, x2, y1, y2;
467   unsigned int whichsel = 0;
468
469   x1 = seq->startdisp;
470   x2 = seq->enddisp;
471
472   y1 = seq->machine + SEQ_STRIP_OFSBOTTOM;
473   y2 = seq->machine + SEQ_STRIP_OFSTOP;
474
475   /* set up co-ordinates/dimensions for either left or right handle */
476   if (direction == SEQ_LEFTHANDLE) {
477     rx1 = x1;
478     rx2 = x1 + handsize_clamped * 0.75f;
479
480     v1[0] = x1 + handsize_clamped / 4;
481     v1[1] = y1 + (((y1 + y2) / 2.0f - y1) / 2);
482     v2[0] = x1 + handsize_clamped / 4;
483     v2[1] = y2 - (((y1 + y2) / 2.0f - y1) / 2);
484     v3[0] = v2[0] + handsize_clamped / 4;
485     v3[1] = (y1 + y2) / 2.0f;
486
487     whichsel = SEQ_LEFTSEL;
488   }
489   else if (direction == SEQ_RIGHTHANDLE) {
490     rx1 = x2 - handsize_clamped * 0.75f;
491     rx2 = x2;
492
493     v1[0] = x2 - handsize_clamped / 4;
494     v1[1] = y1 + (((y1 + y2) / 2.0f - y1) / 2);
495     v2[0] = x2 - handsize_clamped / 4;
496     v2[1] = y2 - (((y1 + y2) / 2.0f - y1) / 2);
497     v3[0] = v2[0] - handsize_clamped / 4;
498     v3[1] = (y1 + y2) / 2.0f;
499
500     whichsel = SEQ_RIGHTSEL;
501   }
502
503   /* draw! */
504   if (!(seq->type & SEQ_TYPE_EFFECT) || BKE_sequence_effect_get_num_inputs(seq->type) == 0) {
505     GPU_blend(true);
506
507     GPU_blend_set_func_separate(
508         GPU_SRC_ALPHA, GPU_ONE_MINUS_SRC_ALPHA, GPU_ONE, GPU_ONE_MINUS_SRC_ALPHA);
509
510     if (seq->flag & whichsel) {
511       immUniformColor4ub(0, 0, 0, 80);
512     }
513     else if (seq->flag & SELECT) {
514       immUniformColor4ub(255, 255, 255, 30);
515     }
516     else {
517       immUniformColor4ub(0, 0, 0, 22);
518     }
519
520     immRectf(pos, rx1, y1, rx2, y2);
521
522     if (seq->flag & whichsel) {
523       immUniformColor4ub(255, 255, 255, 200);
524     }
525     else {
526       immUniformColor4ub(0, 0, 0, 50);
527     }
528
529     immBegin(GPU_PRIM_TRIS, 3);
530     immVertex2fv(pos, v1);
531     immVertex2fv(pos, v2);
532     immVertex2fv(pos, v3);
533     immEnd();
534
535     GPU_blend(false);
536   }
537
538   if ((G.moving & G_TRANSFORM_SEQ) || (seq->flag & whichsel)) {
539     const char col[4] = {255, 255, 255, 255};
540     char numstr[32];
541     size_t numstr_len;
542
543     if (direction == SEQ_LEFTHANDLE) {
544       numstr_len = BLI_snprintf_rlen(numstr, sizeof(numstr), "%d", seq->startdisp);
545       x1 = rx1;
546       y1 -= 0.45f;
547     }
548     else {
549       numstr_len = BLI_snprintf_rlen(numstr, sizeof(numstr), "%d", seq->enddisp - 1);
550       x1 = x2 - handsize_clamped * 0.75f;
551       y1 = y2 + 0.05f;
552     }
553     UI_view2d_text_cache_add(v2d, x1, y1, numstr, numstr_len, col);
554   }
555 }
556
557 /* draw info text on a sequence strip */
558 static void draw_seq_text(View2D *v2d,
559                           SpaceSeq *sseq,
560                           Sequence *seq,
561                           float x1,
562                           float x2,
563                           float y1,
564                           float y2,
565                           const unsigned char background_col[3])
566 {
567   rctf rect;
568   char str[32 + FILE_MAX];
569   size_t str_len;
570   const char *name = seq->name + 2;
571   char col[4];
572
573   /* note, all strings should include 'name' */
574   if (name[0] == '\0') {
575     name = BKE_sequence_give_name(seq);
576   }
577
578   if (seq->type == SEQ_TYPE_META || seq->type == SEQ_TYPE_ADJUSTMENT) {
579     str_len = BLI_snprintf(str, sizeof(str), "%s | %d", name, seq->len);
580   }
581   else if (seq->type == SEQ_TYPE_SCENE) {
582     if (seq->scene) {
583       if (seq->scene_camera) {
584         str_len = BLI_snprintf(str,
585                                sizeof(str),
586                                "%s: %s (%s) | %d",
587                                name,
588                                seq->scene->id.name + 2,
589                                ((ID *)seq->scene_camera)->name + 2,
590                                seq->len);
591       }
592       else {
593         str_len = BLI_snprintf(
594             str, sizeof(str), "%s: %s | %d", name, seq->scene->id.name + 2, seq->len);
595       }
596     }
597     else {
598       str_len = BLI_snprintf(str, sizeof(str), "%s | %d", name, seq->len);
599     }
600   }
601   else if (seq->type == SEQ_TYPE_MOVIECLIP) {
602     if (seq->clip && !STREQ(name, seq->clip->id.name + 2)) {
603       str_len = BLI_snprintf(
604           str, sizeof(str), "%s: %s | %d", name, seq->clip->id.name + 2, seq->len);
605     }
606     else {
607       str_len = BLI_snprintf(str, sizeof(str), "%s | %d", name, seq->len);
608     }
609   }
610   else if (seq->type == SEQ_TYPE_MASK) {
611     if (seq->mask && !STREQ(name, seq->mask->id.name + 2)) {
612       str_len = BLI_snprintf(
613           str, sizeof(str), "%s: %s | %d", name, seq->mask->id.name + 2, seq->len);
614     }
615     else {
616       str_len = BLI_snprintf(str, sizeof(str), "%s | %d", name, seq->len);
617     }
618   }
619   else if (seq->type == SEQ_TYPE_MULTICAM) {
620     str_len = BLI_snprintf(str, sizeof(str), "Cam %s: %d", name, seq->multicam_source);
621   }
622   else if (seq->type == SEQ_TYPE_IMAGE) {
623     str_len = BLI_snprintf(str,
624                            sizeof(str),
625                            "%s: %s%s | %d",
626                            name,
627                            seq->strip->dir,
628                            seq->strip->stripdata->name,
629                            seq->len);
630   }
631   else if (seq->type == SEQ_TYPE_TEXT) {
632     TextVars *textdata = seq->effectdata;
633     str_len = BLI_snprintf(str, sizeof(str), "%s | %d", textdata->text, seq->startdisp);
634   }
635   else if (seq->type & SEQ_TYPE_EFFECT) {
636     str_len = BLI_snprintf(str, sizeof(str), "%s | %d", name, seq->len);
637   }
638   else if (seq->type == SEQ_TYPE_SOUND_RAM) {
639     /* If a waveform is drawn, we don't want to overlay it with text,
640      * as it would make both hard to read. */
641     if ((sseq->flag & SEQ_ALL_WAVEFORMS) || (seq->flag & SEQ_AUDIO_DRAW_WAVEFORM)) {
642       str[0] = 0;
643       str_len = 0;
644     }
645     else if (seq->sound) {
646       str_len = BLI_snprintf(str, sizeof(str), "%s: %s | %d", name, seq->sound->name, seq->len);
647     }
648     else {
649       str_len = BLI_snprintf(str, sizeof(str), "%s | %d", name, seq->len);
650     }
651   }
652   else if (seq->type == SEQ_TYPE_MOVIE) {
653     str_len = BLI_snprintf(str,
654                            sizeof(str),
655                            "%s: %s%s | %d",
656                            name,
657                            seq->strip->dir,
658                            seq->strip->stripdata->name,
659                            seq->len);
660   }
661   else {
662     /* should never get here!, but might with files from future */
663     BLI_assert(0);
664
665     str_len = BLI_snprintf(str, sizeof(str), "%s | %d", name, seq->len);
666   }
667
668   if (seq->flag & SELECT) {
669     col[0] = col[1] = col[2] = 255;
670   }
671   else if ((((int)background_col[0] + (int)background_col[1] + (int)background_col[2]) / 3) < 50) {
672     col[0] = col[1] = col[2] = 80; /* use lighter text color for dark background */
673   }
674   else {
675     col[0] = col[1] = col[2] = 0;
676   }
677   col[3] = 255;
678
679   rect.xmin = x1;
680   rect.ymin = y1;
681   rect.xmax = x2;
682   rect.ymax = y2;
683
684   UI_view2d_text_cache_add_rectf(v2d, &rect, str, str_len, col);
685 }
686
687 static void draw_sequence_extensions(Scene *scene, ARegion *ar, Sequence *seq, unsigned int pos)
688 {
689   float x1, x2, y1, y2, pixely;
690   unsigned char col[4], blendcol[3];
691   View2D *v2d = &ar->v2d;
692
693   x1 = seq->startdisp;
694   x2 = seq->enddisp;
695
696   y1 = seq->machine + SEQ_STRIP_OFSBOTTOM;
697   y2 = seq->machine + SEQ_STRIP_OFSTOP;
698
699   pixely = BLI_rctf_size_y(&v2d->cur) / BLI_rcti_size_y(&v2d->mask);
700
701   if (pixely <= 0) {
702     return; /* can happen when the view is split/resized */
703   }
704
705   blendcol[0] = blendcol[1] = blendcol[2] = 120;
706
707   if (seq->startofs || seq->endofs) {
708     GPU_blend(true);
709     GPU_blend_set_func_separate(
710         GPU_SRC_ALPHA, GPU_ONE_MINUS_SRC_ALPHA, GPU_ONE, GPU_ONE_MINUS_SRC_ALPHA);
711
712     color3ubv_from_seq(scene, seq, col);
713
714     if (seq->flag & SELECT) {
715       UI_GetColorPtrShade3ubv(col, col, -50);
716     }
717
718     if (seq->flag & SEQ_MUTE) {
719       col[3] = 64;
720     }
721     else {
722       if (seq->flag & SELECT) {
723         col[3] = 170;
724       }
725       else {
726         col[3] = 80;
727       }
728     }
729   }
730
731   if (seq->startofs) {
732     immUniformColor4ubv(col);
733     immRectf(pos, (float)(seq->start), y1 - SEQ_STRIP_OFSBOTTOM, x1, y1);
734
735     immUniformColor3ubvAlpha(col, col[3] + 50);
736
737     /* outline */
738     imm_draw_box_wire_2d(pos, (float)(seq->start), y1 - SEQ_STRIP_OFSBOTTOM, x1, y1);
739   }
740   if (seq->endofs) {
741     immUniformColor4ubv(col);
742     immRectf(pos, x2, y2, (float)(seq->start + seq->len), y2 + SEQ_STRIP_OFSBOTTOM);
743
744     immUniformColor3ubvAlpha(col, col[3] + 50);
745
746     /* outline */
747     imm_draw_box_wire_2d(pos, x2, y2, (float)(seq->start + seq->len), y2 + SEQ_STRIP_OFSBOTTOM);
748   }
749
750   if (seq->startofs || seq->endofs) {
751     GPU_blend(false);
752   }
753
754   if (seq->startstill || seq->endstill) {
755     GPU_blend(true);
756     GPU_blend_set_func_separate(
757         GPU_SRC_ALPHA, GPU_ONE_MINUS_SRC_ALPHA, GPU_ONE, GPU_ONE_MINUS_SRC_ALPHA);
758
759     color3ubv_from_seq(scene, seq, col);
760     UI_GetColorPtrBlendShade3ubv(col, blendcol, col, 0.5f, 60);
761
762     if (seq->flag & SEQ_MUTE) {
763       col[3] = 96;
764     }
765     else {
766       if (seq->flag & SELECT) {
767         col[3] = 255;
768       }
769       else {
770         col[3] = 170;
771       }
772     }
773
774     immUniformColor4ubv(col);
775   }
776
777   if (seq->startstill) {
778     immRectf(pos, x1, y1, (float)(seq->start), y2);
779   }
780   if (seq->endstill) {
781     immRectf(pos, (float)(seq->start + seq->len), y1, x2, y2);
782   }
783
784   if (seq->startstill || seq->endstill) {
785     GPU_blend(false);
786   }
787 }
788
789 /*
790  * Draw a sequence strip, bounds check already made
791  * ARegion is currently only used to get the windows width in pixels
792  * so wave file sample drawing precision is zoom adjusted
793  */
794 static void draw_seq_strip(const bContext *C,
795                            SpaceSeq *sseq,
796                            Scene *scene,
797                            ARegion *ar,
798                            Sequence *seq,
799                            int outline_tint,
800                            float pixelx)
801 {
802   View2D *v2d = &ar->v2d;
803   float x1, x2, y1, y2;
804   unsigned char col[4], background_col[4], is_single_image;
805   const float handsize_clamped = draw_seq_handle_size_get_clamped(seq, pixelx);
806
807   /* we need to know if this is a single image/color or not for drawing */
808   is_single_image = (char)BKE_sequence_single_check(seq);
809
810   /* body */
811   x1 = (seq->startstill) ? seq->start : seq->startdisp;
812   y1 = seq->machine + SEQ_STRIP_OFSBOTTOM;
813   x2 = (seq->endstill) ? (seq->start + seq->len) : seq->enddisp;
814   y2 = seq->machine + SEQ_STRIP_OFSTOP;
815
816   uint pos = GPU_vertformat_attr_add(immVertexFormat(), "pos", GPU_COMP_F32, 2, GPU_FETCH_FLOAT);
817
818   immBindBuiltinProgram(GPU_SHADER_2D_UNIFORM_COLOR);
819
820   /* get the correct color per strip type*/
821   // color3ubv_from_seq(scene, seq, col);
822   color3ubv_from_seq(scene, seq, background_col);
823
824   if (seq->flag & SEQ_MUTE) {
825     background_col[3] = 128;
826
827     GPU_blend(true);
828     GPU_blend_set_func_separate(
829         GPU_SRC_ALPHA, GPU_ONE_MINUS_SRC_ALPHA, GPU_ONE, GPU_ONE_MINUS_SRC_ALPHA);
830   }
831   else {
832     background_col[3] = 255;
833   }
834
835   if (seq->flag & SELECT) {
836     UI_GetColorPtrShade3ubv(background_col, background_col, -50);
837   }
838
839   immUniformColor4ubv(background_col);
840
841   /* draw the main strip body */
842   if (is_single_image) { /* single image */
843     immRectf(pos,
844              BKE_sequence_tx_get_final_left(seq, false),
845              y1,
846              BKE_sequence_tx_get_final_right(seq, false),
847              y2);
848   }
849   else { /* normal operation */
850     immRectf(pos, x1, y1, x2, y2);
851   }
852
853   if (seq->flag & SEQ_MUTE) {
854     GPU_blend(false);
855   }
856
857   if (!is_single_image) {
858     if ((sseq->draw_flag & SEQ_DRAW_OFFSET_EXT) || (seq == special_seq_update)) {
859       draw_sequence_extensions(scene, ar, seq, pos);
860     }
861   }
862
863   draw_seq_handle(v2d, seq, handsize_clamped, SEQ_LEFTHANDLE, pos);
864   draw_seq_handle(v2d, seq, handsize_clamped, SEQ_RIGHTHANDLE, pos);
865
866   x1 = seq->startdisp;
867   x2 = seq->enddisp;
868
869   immUnbindProgram();
870
871   /* draw sound wave */
872   if (seq->type == SEQ_TYPE_SOUND_RAM) {
873     if (!(sseq->flag & SEQ_NO_WAVEFORMS)) {
874       drawseqwave(
875           v2d, C, sseq, scene, seq, x1, y1, x2, y2, BLI_rctf_size_x(&ar->v2d.cur) / ar->winx);
876     }
877   }
878
879   /* draw lock */
880   if (seq->flag & SEQ_LOCK) {
881     GPU_blend(true);
882
883     pos = GPU_vertformat_attr_add(immVertexFormat(), "pos", GPU_COMP_F32, 2, GPU_FETCH_FLOAT);
884     immBindBuiltinProgram(GPU_SHADER_2D_DIAG_STRIPES);
885
886     immUniform4f("color1", 1.0f, 1.0f, 1.0f, 0.125f);
887     immUniform4f("color2", 0.0f, 0.0f, 0.0f, 0.125f);
888     immUniform1i("size1", 8);
889     immUniform1i("size2", 8);
890
891     immRectf(pos, x1, y1, x2, y2);
892
893     immUnbindProgram();
894
895     GPU_blend(false);
896   }
897
898   if (!BKE_sequence_is_valid_check(seq)) {
899     GPU_blend(true);
900
901     pos = GPU_vertformat_attr_add(immVertexFormat(), "pos", GPU_COMP_F32, 2, GPU_FETCH_FLOAT);
902     immBindBuiltinProgram(GPU_SHADER_2D_DIAG_STRIPES);
903
904     immUniform4f("color1", 1.0f, 0.0f, 0.0f, 1.0f);
905     immUniform4f("color2", 0.0f, 0.0f, 0.0f, 0.0f);
906     immUniform1i("size1", 8);
907     immUniform1i("size2", 8);
908
909     immRectf(pos, x1, y1, x2, y2);
910
911     immUnbindProgram();
912
913     GPU_blend(false);
914   }
915
916   color3ubv_from_seq(scene, seq, col);
917
918   /* draw the strip outline */
919   color3ubv_from_seq(scene, seq, col);
920   if ((G.moving & G_TRANSFORM_SEQ) && (seq->flag & SELECT)) {
921     if (seq->flag & SEQ_OVERLAP) {
922       col[0] = 255;
923       col[1] = col[2] = 40;
924     }
925     else {
926       UI_GetColorPtrShade3ubv(col, col, 120 + outline_tint);
927     }
928   }
929   else {
930     UI_GetColorPtrShade3ubv(col, col, outline_tint);
931   }
932
933   if ((seq->type == SEQ_TYPE_META) ||
934       ((seq->type == SEQ_TYPE_SCENE) && (seq->flag & SEQ_SCENE_STRIPS))) {
935     drawmeta_contents(scene, seq, x1, y1, x2, y2);
936   }
937
938   pos = GPU_vertformat_attr_add(immVertexFormat(), "pos", GPU_COMP_F32, 2, GPU_FETCH_FLOAT);
939
940   /* TODO: add back stippled line for muted strips? */
941   immBindBuiltinProgram(GPU_SHADER_2D_UNIFORM_COLOR);
942
943   if (seq->flag & SEQ_MUTE) {
944     col[3] = 96;
945
946     GPU_blend(true);
947     GPU_blend_set_func_separate(
948         GPU_SRC_ALPHA, GPU_ONE_MINUS_SRC_ALPHA, GPU_ONE, GPU_ONE_MINUS_SRC_ALPHA);
949
950     immUniformColor4ubv(col);
951   }
952   else {
953     immUniformColor3ubv(col);
954   }
955
956   imm_draw_box_wire_2d(pos, x1, y1, x2, y2); /* outline */
957
958   immUnbindProgram();
959
960   /* calculate if seq is long enough to print a name */
961   x1 = seq->startdisp + handsize_clamped;
962   x2 = seq->enddisp - handsize_clamped;
963
964   float scroller_vert_xoffs = (V2D_SCROLL_WIDTH_HANDLES + SEQ_SCROLLER_TEXT_OFFSET) * pixelx;
965
966   /* info text on the strip */
967   if (x1 < v2d->cur.xmin + scroller_vert_xoffs) {
968     x1 = v2d->cur.xmin + scroller_vert_xoffs;
969   }
970   else if (x1 > v2d->cur.xmax) {
971     x1 = v2d->cur.xmax;
972   }
973   if (x2 < v2d->cur.xmin) {
974     x2 = v2d->cur.xmin;
975   }
976   else if (x2 > v2d->cur.xmax) {
977     x2 = v2d->cur.xmax;
978   }
979
980   /* nice text here would require changing the view matrix for texture text */
981   if ((x2 - x1) / pixelx > 32) {
982     draw_seq_text(v2d, sseq, seq, x1, x2, y1, y2, background_col);
983   }
984 }
985
986 void sequencer_special_update_set(Sequence *seq)
987 {
988   special_seq_update = seq;
989 }
990
991 Sequence *ED_sequencer_special_preview_get(void)
992 {
993   return special_seq_update;
994 }
995
996 void ED_sequencer_special_preview_set(bContext *C, const int mval[2])
997 {
998   Scene *scene = CTX_data_scene(C);
999   ARegion *ar = CTX_wm_region(C);
1000   int hand;
1001   Sequence *seq;
1002   seq = find_nearest_seq(scene, &ar->v2d, &hand, mval);
1003   sequencer_special_update_set(seq);
1004 }
1005
1006 void ED_sequencer_special_preview_clear(void)
1007 {
1008   sequencer_special_update_set(NULL);
1009 }
1010
1011 ImBuf *sequencer_ibuf_get(struct Main *bmain,
1012                           struct Depsgraph *depsgraph,
1013                           Scene *scene,
1014                           SpaceSeq *sseq,
1015                           int cfra,
1016                           int frame_ofs,
1017                           const char *viewname)
1018 {
1019   SeqRenderData context = {0};
1020   ImBuf *ibuf;
1021   int rectx, recty;
1022   float render_size;
1023   float proxy_size = 100.0;
1024   short is_break = G.is_break;
1025
1026   render_size = sseq->render_size;
1027   if (render_size == 0) {
1028     render_size = scene->r.size;
1029   }
1030   else {
1031     proxy_size = render_size;
1032   }
1033
1034   if (render_size < 0) {
1035     return NULL;
1036   }
1037
1038   rectx = (render_size * (float)scene->r.xsch) / 100.0f + 0.5f;
1039   recty = (render_size * (float)scene->r.ysch) / 100.0f + 0.5f;
1040
1041   BKE_sequencer_new_render_data(
1042       bmain, depsgraph, scene, rectx, recty, proxy_size, false, &context);
1043   context.view_id = BKE_scene_multiview_view_id_get(&scene->r, viewname);
1044
1045   /* sequencer could start rendering, in this case we need to be sure it wouldn't be canceled
1046    * by Esc pressed somewhere in the past
1047    */
1048   G.is_break = false;
1049
1050   /* Rendering can change OGL context. Save & Restore framebuffer. */
1051   GPUFrameBuffer *fb = GPU_framebuffer_active_get();
1052   GPU_framebuffer_restore();
1053
1054   if (special_seq_update) {
1055     ibuf = BKE_sequencer_give_ibuf_direct(&context, cfra + frame_ofs, special_seq_update);
1056   }
1057   else if (!U.prefetchframes) {  // XXX || (G.f & G_PLAYANIM) == 0) {
1058     ibuf = BKE_sequencer_give_ibuf(&context, cfra + frame_ofs, sseq->chanshown);
1059   }
1060   else {
1061     ibuf = BKE_sequencer_give_ibuf_threaded(&context, cfra + frame_ofs, sseq->chanshown);
1062   }
1063
1064   if (fb) {
1065     GPU_framebuffer_bind(fb);
1066   }
1067
1068   /* restore state so real rendering would be canceled (if needed) */
1069   G.is_break = is_break;
1070
1071   return ibuf;
1072 }
1073
1074 static void sequencer_check_scopes(SequencerScopes *scopes, ImBuf *ibuf)
1075 {
1076   if (scopes->reference_ibuf != ibuf) {
1077     if (scopes->zebra_ibuf) {
1078       IMB_freeImBuf(scopes->zebra_ibuf);
1079       scopes->zebra_ibuf = NULL;
1080     }
1081
1082     if (scopes->waveform_ibuf) {
1083       IMB_freeImBuf(scopes->waveform_ibuf);
1084       scopes->waveform_ibuf = NULL;
1085     }
1086
1087     if (scopes->sep_waveform_ibuf) {
1088       IMB_freeImBuf(scopes->sep_waveform_ibuf);
1089       scopes->sep_waveform_ibuf = NULL;
1090     }
1091
1092     if (scopes->vector_ibuf) {
1093       IMB_freeImBuf(scopes->vector_ibuf);
1094       scopes->vector_ibuf = NULL;
1095     }
1096
1097     if (scopes->histogram_ibuf) {
1098       IMB_freeImBuf(scopes->histogram_ibuf);
1099       scopes->histogram_ibuf = NULL;
1100     }
1101   }
1102 }
1103
1104 static ImBuf *sequencer_make_scope(Scene *scene, ImBuf *ibuf, ImBuf *(*make_scope_cb)(ImBuf *ibuf))
1105 {
1106   ImBuf *display_ibuf = IMB_dupImBuf(ibuf);
1107   ImBuf *scope;
1108
1109   IMB_colormanagement_imbuf_make_display_space(
1110       display_ibuf, &scene->view_settings, &scene->display_settings);
1111
1112   scope = make_scope_cb(display_ibuf);
1113
1114   IMB_freeImBuf(display_ibuf);
1115
1116   return scope;
1117 }
1118
1119 static void sequencer_display_size(Scene *scene, float r_viewrect[2])
1120 {
1121   r_viewrect[0] = (float)scene->r.xsch;
1122   r_viewrect[1] = (float)scene->r.ysch;
1123
1124   r_viewrect[0] *= scene->r.xasp / scene->r.yasp;
1125 }
1126
1127 static void sequencer_draw_gpencil(const bContext *C)
1128 {
1129   /* draw grease-pencil (image aligned) */
1130   ED_annotation_draw_2dimage(C);
1131
1132   /* ortho at pixel level */
1133   UI_view2d_view_restore(C);
1134
1135   /* draw grease-pencil (screen aligned) */
1136   ED_annotation_draw_view2d(C, 0);
1137 }
1138
1139 /* draws content borders plus safety borders if needed */
1140 static void sequencer_draw_borders(const SpaceSeq *sseq, const View2D *v2d, const Scene *scene)
1141 {
1142   float x1 = v2d->tot.xmin;
1143   float y1 = v2d->tot.ymin;
1144   float x2 = v2d->tot.xmax;
1145   float y2 = v2d->tot.ymax;
1146
1147   GPU_line_width(1.0f);
1148
1149   /* border */
1150   const uint shdr_pos = GPU_vertformat_attr_add(
1151       immVertexFormat(), "pos", GPU_COMP_F32, 2, GPU_FETCH_FLOAT);
1152
1153   immBindBuiltinProgram(GPU_SHADER_2D_LINE_DASHED_UNIFORM_COLOR);
1154
1155   float viewport_size[4];
1156   GPU_viewport_size_get_f(viewport_size);
1157   immUniform2f("viewport_size", viewport_size[2] / UI_DPI_FAC, viewport_size[3] / UI_DPI_FAC);
1158
1159   immUniformThemeColor(TH_BACK);
1160   immUniform1i("colors_len", 0); /* Simple dashes. */
1161   immUniform1f("dash_width", 6.0f);
1162   immUniform1f("dash_factor", 0.5f);
1163
1164   imm_draw_box_wire_2d(shdr_pos, x1 - 0.5f, y1 - 0.5f, x2 + 0.5f, y2 + 0.5f);
1165
1166   /* safety border */
1167   if (sseq->flag & SEQ_SHOW_SAFE_MARGINS) {
1168     immUniformThemeColorBlend(TH_VIEW_OVERLAY, TH_BACK, 0.25f);
1169
1170     UI_draw_safe_areas(
1171         shdr_pos, x1, x2, y1, y2, scene->safe_areas.title, scene->safe_areas.action);
1172
1173     if (sseq->flag & SEQ_SHOW_SAFE_CENTER) {
1174       UI_draw_safe_areas(shdr_pos,
1175                          x1,
1176                          x2,
1177                          y1,
1178                          y2,
1179                          scene->safe_areas.title_center,
1180                          scene->safe_areas.action_center);
1181     }
1182   }
1183
1184   immUnbindProgram();
1185 }
1186
1187 #if 0
1188 void sequencer_draw_maskedit(const bContext *C, Scene *scene, ARegion *ar, SpaceSeq *sseq)
1189 {
1190   /* NOTE: sequencer mask editing isnt finished, the draw code is working but editing not,
1191    * for now just disable drawing since the strip frame will likely be offset */
1192
1193   // if (sc->mode == SC_MODE_MASKEDIT)
1194   if (0 && sseq->mainb == SEQ_DRAW_IMG_IMBUF) {
1195     Mask *mask = BKE_sequencer_mask_get(scene);
1196
1197     if (mask) {
1198       int width, height;
1199       float aspx = 1.0f, aspy = 1.0f;
1200       // ED_mask_get_size(C, &width, &height);
1201
1202       //Scene *scene = CTX_data_scene(C);
1203       width = (scene->r.size * scene->r.xsch) / 100;
1204       height = (scene->r.size * scene->r.ysch) / 100;
1205
1206       ED_mask_draw_region(mask,
1207                           ar,
1208                           0,
1209                           0,
1210                           0, /* TODO */
1211                           width,
1212                           height,
1213                           aspx,
1214                           aspy,
1215                           false,
1216                           true,
1217                           NULL,
1218                           C);
1219     }
1220   }
1221 }
1222 #endif
1223
1224 static void *sequencer_OCIO_transform_ibuf(
1225     const bContext *C, ImBuf *ibuf, bool *glsl_used, int *format, int *type)
1226 {
1227   void *display_buffer;
1228   void *cache_handle = NULL;
1229   bool force_fallback = false;
1230   *glsl_used = false;
1231   force_fallback |= (ED_draw_imbuf_method(ibuf) != IMAGE_DRAW_METHOD_GLSL);
1232   force_fallback |= (ibuf->dither != 0.0f);
1233
1234   if (force_fallback) {
1235     /* Fallback to CPU based color space conversion */
1236     *glsl_used = false;
1237     *format = GL_RGBA;
1238     *type = GL_UNSIGNED_BYTE;
1239     display_buffer = NULL;
1240   }
1241   else if (ibuf->rect_float) {
1242     display_buffer = ibuf->rect_float;
1243
1244     if (ibuf->channels == 4) {
1245       *format = GL_RGBA;
1246     }
1247     else if (ibuf->channels == 3) {
1248       *format = GL_RGB;
1249     }
1250     else {
1251       BLI_assert(!"Incompatible number of channels for float buffer in sequencer");
1252       *format = GL_RGBA;
1253       display_buffer = NULL;
1254     }
1255
1256     *type = GL_FLOAT;
1257
1258     if (ibuf->float_colorspace) {
1259       *glsl_used = IMB_colormanagement_setup_glsl_draw_from_space_ctx(
1260           C, ibuf->float_colorspace, ibuf->dither, true);
1261     }
1262     else {
1263       *glsl_used = IMB_colormanagement_setup_glsl_draw_ctx(C, ibuf->dither, true);
1264     }
1265   }
1266   else if (ibuf->rect) {
1267     display_buffer = ibuf->rect;
1268     *format = GL_RGBA;
1269     *type = GL_UNSIGNED_BYTE;
1270
1271     *glsl_used = IMB_colormanagement_setup_glsl_draw_from_space_ctx(
1272         C, ibuf->rect_colorspace, ibuf->dither, false);
1273   }
1274   else {
1275     *format = GL_RGBA;
1276     *type = GL_UNSIGNED_BYTE;
1277     display_buffer = NULL;
1278   }
1279
1280   /* there's a data to be displayed, but GLSL is not initialized
1281    * properly, in this case we fallback to CPU-based display transform
1282    */
1283   if ((ibuf->rect || ibuf->rect_float) && !*glsl_used) {
1284     display_buffer = IMB_display_buffer_acquire_ctx(C, ibuf, &cache_handle);
1285     *format = GL_RGBA;
1286     *type = GL_UNSIGNED_BYTE;
1287   }
1288   if (cache_handle) {
1289     IMB_display_buffer_release(cache_handle);
1290   }
1291
1292   return display_buffer;
1293 }
1294
1295 static void sequencer_stop_running_jobs(const bContext *C, Scene *scene)
1296 {
1297   if (G.is_rendering == false && (scene->r.seq_prev_type) == OB_RENDER) {
1298     /* stop all running jobs, except screen one. currently previews frustrate Render
1299      * needed to make so sequencer's rendering doesn't conflict with compositor
1300      */
1301     WM_jobs_kill_type(CTX_wm_manager(C), NULL, WM_JOB_TYPE_COMPOSITE);
1302
1303     /* in case of final rendering used for preview, kill all previews,
1304      * otherwise threading conflict will happen in rendering module
1305      */
1306     WM_jobs_kill_type(CTX_wm_manager(C), NULL, WM_JOB_TYPE_RENDER_PREVIEW);
1307   }
1308 }
1309
1310 static void sequencer_preview_clear(void)
1311 {
1312   float col[3];
1313
1314   UI_GetThemeColor3fv(TH_SEQ_PREVIEW, col);
1315   GPU_clear_color(col[0], col[1], col[2], 0.0);
1316   GPU_clear(GPU_COLOR_BIT);
1317 }
1318
1319 static void sequencer_preview_get_rect(rctf *preview,
1320                                        Scene *scene,
1321                                        ARegion *ar,
1322                                        SpaceSeq *sseq,
1323                                        bool draw_overlay,
1324                                        bool draw_backdrop)
1325 {
1326   struct View2D *v2d = &ar->v2d;
1327   float viewrect[2];
1328
1329   sequencer_display_size(scene, viewrect);
1330   BLI_rctf_init(preview, -1.0f, 1.0f, -1.0f, 1.0f);
1331
1332   if (draw_overlay && sseq->overlay_type == SEQ_DRAW_OVERLAY_RECT) {
1333     preview->xmax = v2d->tot.xmin +
1334                     (fabsf(BLI_rctf_size_x(&v2d->tot)) * scene->ed->over_border.xmax);
1335     preview->xmin = v2d->tot.xmin +
1336                     (fabsf(BLI_rctf_size_x(&v2d->tot)) * scene->ed->over_border.xmin);
1337     preview->ymax = v2d->tot.ymin +
1338                     (fabsf(BLI_rctf_size_y(&v2d->tot)) * scene->ed->over_border.ymax);
1339     preview->ymin = v2d->tot.ymin +
1340                     (fabsf(BLI_rctf_size_y(&v2d->tot)) * scene->ed->over_border.ymin);
1341   }
1342   else if (draw_backdrop) {
1343     float aspect = BLI_rcti_size_x(&ar->winrct) / (float)BLI_rcti_size_y(&ar->winrct);
1344     float image_aspect = viewrect[0] / viewrect[1];
1345
1346     if (aspect >= image_aspect) {
1347       preview->xmax = image_aspect / aspect;
1348       preview->xmin = -preview->xmax;
1349     }
1350     else {
1351       preview->ymax = aspect / image_aspect;
1352       preview->ymin = -preview->ymax;
1353     }
1354   }
1355   else {
1356     *preview = v2d->tot;
1357   }
1358 }
1359
1360 static void sequencer_draw_display_buffer(const bContext *C,
1361                                           Scene *scene,
1362                                           ARegion *ar,
1363                                           SpaceSeq *sseq,
1364                                           ImBuf *ibuf,
1365                                           ImBuf *scope,
1366                                           bool draw_overlay,
1367                                           bool draw_backdrop)
1368 {
1369   void *display_buffer;
1370
1371   if (sseq->mainb == SEQ_DRAW_IMG_IMBUF && sseq->flag & SEQ_USE_ALPHA) {
1372     GPU_blend(true);
1373     GPU_blend_set_func_separate(
1374         GPU_SRC_ALPHA, GPU_ONE_MINUS_SRC_ALPHA, GPU_ONE, GPU_ONE_MINUS_SRC_ALPHA);
1375   }
1376
1377   /* Format needs to be created prior to any immBindProgram call.
1378    * Do it here because OCIO binds it's own shader.
1379    */
1380   int format, type;
1381   bool glsl_used = false;
1382   GLuint texid;
1383   GPUVertFormat *imm_format = immVertexFormat();
1384   uint pos = GPU_vertformat_attr_add(imm_format, "pos", GPU_COMP_F32, 2, GPU_FETCH_FLOAT);
1385   uint texCoord = GPU_vertformat_attr_add(
1386       imm_format, "texCoord", GPU_COMP_F32, 2, GPU_FETCH_FLOAT);
1387
1388   if (scope) {
1389     ibuf = scope;
1390
1391     if (ibuf->rect_float && ibuf->rect == NULL) {
1392       IMB_rect_from_float(ibuf);
1393     }
1394
1395     display_buffer = (unsigned char *)ibuf->rect;
1396     format = GL_RGBA;
1397     type = GL_UNSIGNED_BYTE;
1398   }
1399   else {
1400     display_buffer = sequencer_OCIO_transform_ibuf(C, ibuf, &glsl_used, &format, &type);
1401   }
1402
1403   if (draw_backdrop) {
1404     GPU_matrix_push();
1405     GPU_matrix_identity_set();
1406     GPU_matrix_push_projection();
1407     GPU_matrix_identity_projection_set();
1408   }
1409
1410   glGenTextures(1, (GLuint *)&texid);
1411   glActiveTexture(GL_TEXTURE0);
1412   glBindTexture(GL_TEXTURE_2D, texid);
1413   glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
1414   glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
1415
1416   if (type == GL_FLOAT) {
1417     glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA16F, ibuf->x, ibuf->y, 0, format, type, display_buffer);
1418   }
1419   else {
1420     glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA8, ibuf->x, ibuf->y, 0, format, type, display_buffer);
1421   }
1422
1423   if (!glsl_used) {
1424     immBindBuiltinProgram(GPU_SHADER_2D_IMAGE_COLOR);
1425     immUniformColor3f(1.0f, 1.0f, 1.0f);
1426     immUniform1i("image", 0);
1427   }
1428
1429   immBegin(GPU_PRIM_TRI_FAN, 4);
1430
1431   rctf preview;
1432   rctf canvas;
1433   sequencer_preview_get_rect(&preview, scene, ar, sseq, draw_overlay, draw_backdrop);
1434
1435   if (draw_overlay && sseq->overlay_type == SEQ_DRAW_OVERLAY_RECT) {
1436     canvas = scene->ed->over_border;
1437   }
1438   else {
1439     BLI_rctf_init(&canvas, 0.0f, 1.0f, 0.0f, 1.0f);
1440   }
1441
1442   immAttr2f(texCoord, canvas.xmin, canvas.ymin);
1443   immVertex2f(pos, preview.xmin, preview.ymin);
1444
1445   immAttr2f(texCoord, canvas.xmin, canvas.ymax);
1446   immVertex2f(pos, preview.xmin, preview.ymax);
1447
1448   immAttr2f(texCoord, canvas.xmax, canvas.ymax);
1449   immVertex2f(pos, preview.xmax, preview.ymax);
1450
1451   immAttr2f(texCoord, canvas.xmax, canvas.ymin);
1452   immVertex2f(pos, preview.xmax, preview.ymin);
1453
1454   immEnd();
1455   glBindTexture(GL_TEXTURE_2D, 0);
1456   glDeleteTextures(1, &texid);
1457
1458   if (!glsl_used) {
1459     immUnbindProgram();
1460   }
1461   else {
1462     IMB_colormanagement_finish_glsl_draw();
1463   }
1464
1465   if (sseq->mainb == SEQ_DRAW_IMG_IMBUF && sseq->flag & SEQ_USE_ALPHA) {
1466     GPU_blend(false);
1467   }
1468
1469   if (draw_backdrop) {
1470     GPU_matrix_pop();
1471     GPU_matrix_pop_projection();
1472   }
1473 }
1474
1475 static ImBuf *sequencer_get_scope(Scene *scene, SpaceSeq *sseq, ImBuf *ibuf, bool draw_backdrop)
1476 {
1477   struct ImBuf *scope = NULL;
1478   SequencerScopes *scopes = &sseq->scopes;
1479
1480   if (!draw_backdrop && (sseq->mainb != SEQ_DRAW_IMG_IMBUF || sseq->zebra != 0)) {
1481     sequencer_check_scopes(scopes, ibuf);
1482
1483     switch (sseq->mainb) {
1484       case SEQ_DRAW_IMG_IMBUF:
1485         if (!scopes->zebra_ibuf) {
1486           ImBuf *display_ibuf = IMB_dupImBuf(ibuf);
1487
1488           if (display_ibuf->rect_float) {
1489             IMB_colormanagement_imbuf_make_display_space(
1490                 display_ibuf, &scene->view_settings, &scene->display_settings);
1491           }
1492           scopes->zebra_ibuf = make_zebra_view_from_ibuf(display_ibuf, sseq->zebra);
1493           IMB_freeImBuf(display_ibuf);
1494         }
1495         scope = scopes->zebra_ibuf;
1496         break;
1497       case SEQ_DRAW_IMG_WAVEFORM:
1498         if ((sseq->flag & SEQ_DRAW_COLOR_SEPARATED) != 0) {
1499           if (!scopes->sep_waveform_ibuf) {
1500             scopes->sep_waveform_ibuf = sequencer_make_scope(
1501                 scene, ibuf, make_sep_waveform_view_from_ibuf);
1502           }
1503           scope = scopes->sep_waveform_ibuf;
1504         }
1505         else {
1506           if (!scopes->waveform_ibuf) {
1507             scopes->waveform_ibuf = sequencer_make_scope(
1508                 scene, ibuf, make_waveform_view_from_ibuf);
1509           }
1510           scope = scopes->waveform_ibuf;
1511         }
1512         break;
1513       case SEQ_DRAW_IMG_VECTORSCOPE:
1514         if (!scopes->vector_ibuf) {
1515           scopes->vector_ibuf = sequencer_make_scope(scene, ibuf, make_vectorscope_view_from_ibuf);
1516         }
1517         scope = scopes->vector_ibuf;
1518         break;
1519       case SEQ_DRAW_IMG_HISTOGRAM:
1520         if (!scopes->histogram_ibuf) {
1521           scopes->histogram_ibuf = sequencer_make_scope(
1522               scene, ibuf, make_histogram_view_from_ibuf);
1523         }
1524         scope = scopes->histogram_ibuf;
1525         break;
1526     }
1527
1528     /* future files may have new scopes we don't catch above */
1529     if (scope) {
1530       scopes->reference_ibuf = ibuf;
1531     }
1532   }
1533   return scope;
1534 }
1535
1536 void sequencer_draw_preview(const bContext *C,
1537                             Scene *scene,
1538                             ARegion *ar,
1539                             SpaceSeq *sseq,
1540                             int cfra,
1541                             int frame_ofs,
1542                             bool draw_overlay,
1543                             bool draw_backdrop)
1544 {
1545   struct Main *bmain = CTX_data_main(C);
1546   struct Depsgraph *depsgraph = CTX_data_depsgraph(C);
1547   struct View2D *v2d = &ar->v2d;
1548   struct ImBuf *ibuf = NULL;
1549   struct ImBuf *scope = NULL;
1550   float viewrect[2];
1551   const bool show_imbuf = ED_space_sequencer_check_show_imbuf(sseq);
1552   const bool draw_gpencil = ((sseq->flag & SEQ_SHOW_GPENCIL) && sseq->gpd);
1553   const char *names[2] = {STEREO_LEFT_NAME, STEREO_RIGHT_NAME};
1554
1555   sequencer_stop_running_jobs(C, scene);
1556   if (G.is_rendering) {
1557     return;
1558   }
1559
1560   if (sseq->render_size == SEQ_PROXY_RENDER_SIZE_NONE) {
1561     sequencer_preview_clear();
1562     return;
1563   }
1564
1565   /* Setup view */
1566   sequencer_display_size(scene, viewrect);
1567   UI_view2d_totRect_set(v2d, viewrect[0] + 0.5f, viewrect[1] + 0.5f);
1568   UI_view2d_curRect_validate(v2d);
1569   UI_view2d_view_ortho(v2d);
1570
1571   /* Draw background */
1572   if (!draw_backdrop && (!draw_overlay || sseq->overlay_type == SEQ_DRAW_OVERLAY_REFERENCE)) {
1573     sequencer_preview_clear();
1574
1575     if (sseq->flag & SEQ_USE_ALPHA) {
1576       imm_draw_box_checker_2d(v2d->tot.xmin, v2d->tot.ymin, v2d->tot.xmax, v2d->tot.ymax);
1577     }
1578   }
1579   /* Get image */
1580   ibuf = sequencer_ibuf_get(
1581       bmain, depsgraph, scene, sseq, cfra, frame_ofs, names[sseq->multiview_eye]);
1582
1583   if (ibuf) {
1584     scope = sequencer_get_scope(scene, sseq, ibuf, draw_backdrop);
1585
1586     /* Draw image */
1587     sequencer_draw_display_buffer(C, scene, ar, sseq, ibuf, scope, draw_overlay, draw_backdrop);
1588
1589     /* Draw over image */
1590     if (sseq->flag & SEQ_SHOW_METADATA) {
1591       ED_region_image_metadata_draw(0.0, 0.0, ibuf, &v2d->tot, 1.0, 1.0);
1592     }
1593   }
1594
1595   if (show_imbuf) {
1596     sequencer_draw_borders(sseq, v2d, scene);
1597   }
1598
1599   if (draw_gpencil && show_imbuf) {
1600     sequencer_draw_gpencil(C);
1601   }
1602
1603   /* TODO */
1604   /* sequencer_draw_maskedit(C, scene, ar, sseq); */
1605
1606   /* Scope is freed in sequencer_check_scopes when ibuf changes and
1607    * scope image is to be replaced. */
1608   if (ibuf) {
1609     IMB_freeImBuf(ibuf);
1610   }
1611
1612   UI_view2d_view_restore(C);
1613 }
1614
1615 #if 0
1616 void drawprefetchseqspace(Scene *scene, ARegion *UNUSED(ar), SpaceSeq *sseq)
1617 {
1618   int rectx, recty;
1619   int render_size = sseq->render_size;
1620   int proxy_size = 100.0;
1621   if (render_size == 0) {
1622     render_size = scene->r.size;
1623   }
1624   else {
1625     proxy_size = render_size;
1626   }
1627   if (render_size < 0) {
1628     return;
1629   }
1630
1631   rectx = (render_size * scene->r.xsch) / 100;
1632   recty = (render_size * scene->r.ysch) / 100;
1633
1634   if (sseq->mainb != SEQ_DRAW_SEQUENCE) {
1635     give_ibuf_prefetch_request(rectx, recty, (scene->r.cfra), sseq->chanshown, proxy_size);
1636   }
1637 }
1638 #endif
1639
1640 /* draw backdrop of the sequencer strips view */
1641 static void draw_seq_backdrop(View2D *v2d)
1642 {
1643   int i;
1644
1645   uint pos = GPU_vertformat_attr_add(immVertexFormat(), "pos", GPU_COMP_F32, 2, GPU_FETCH_FLOAT);
1646   immBindBuiltinProgram(GPU_SHADER_2D_UNIFORM_COLOR);
1647
1648   /* darker gray overlay over the view backdrop */
1649   immUniformThemeColorShade(TH_BACK, -20);
1650   immRectf(pos, v2d->cur.xmin, -1.0, v2d->cur.xmax, 1.0);
1651
1652   /* Alternating horizontal stripes */
1653   i = max_ii(1, ((int)v2d->cur.ymin) - 1);
1654
1655   while (i < v2d->cur.ymax) {
1656     if (i & 1) {
1657       immUniformThemeColorShade(TH_BACK, -15);
1658     }
1659     else {
1660       immUniformThemeColorShade(TH_BACK, -25);
1661     }
1662
1663     immRectf(pos, v2d->cur.xmin, i, v2d->cur.xmax, i + 1);
1664
1665     i++;
1666   }
1667
1668   /* Darker lines separating the horizontal bands */
1669   i = max_ii(1, ((int)v2d->cur.ymin) - 1);
1670   int line_len = (int)v2d->cur.ymax - i + 1;
1671   immUniformThemeColor(TH_GRID);
1672   immBegin(GPU_PRIM_LINES, line_len * 2);
1673   while (line_len--) {
1674     immVertex2f(pos, v2d->cur.xmax, i);
1675     immVertex2f(pos, v2d->cur.xmin, i);
1676   }
1677   immEnd();
1678
1679   immUnbindProgram();
1680 }
1681
1682 /* draw the contents of the sequencer strips view */
1683 static void draw_seq_strips(const bContext *C, Editing *ed, ARegion *ar)
1684 {
1685   Scene *scene = CTX_data_scene(C);
1686   View2D *v2d = &ar->v2d;
1687   SpaceSeq *sseq = CTX_wm_space_seq(C);
1688   Sequence *last_seq = BKE_sequencer_active_get(scene);
1689   int sel = 0, j;
1690   float pixelx = BLI_rctf_size_x(&v2d->cur) / BLI_rcti_size_x(&v2d->mask);
1691
1692   /* loop through twice, first unselected, then selected */
1693   for (j = 0; j < 2; j++) {
1694     Sequence *seq;
1695     /* highlighting around strip edges indicating selection */
1696     int outline_tint = (j) ? -60 : -150;
1697
1698     /* loop through strips, checking for those that are visible */
1699     for (seq = ed->seqbasep->first; seq; seq = seq->next) {
1700       /* boundbox and selection tests for NOT drawing the strip... */
1701       if ((seq->flag & SELECT) != sel) {
1702         continue;
1703       }
1704       else if (seq == last_seq) {
1705         continue;
1706       }
1707       else if (min_ii(seq->startdisp, seq->start) > v2d->cur.xmax) {
1708         continue;
1709       }
1710       else if (max_ii(seq->enddisp, seq->start + seq->len) < v2d->cur.xmin) {
1711         continue;
1712       }
1713       else if (seq->machine + 1.0f < v2d->cur.ymin) {
1714         continue;
1715       }
1716       else if (seq->machine > v2d->cur.ymax) {
1717         continue;
1718       }
1719
1720       /* strip passed all tests unscathed... so draw it now */
1721       draw_seq_strip(C, sseq, scene, ar, seq, outline_tint, pixelx);
1722     }
1723
1724     /* draw selected next time round */
1725     sel = SELECT;
1726   }
1727
1728   /* draw the last selected last (i.e. 'active' in other parts of Blender),
1729    * removes some overlapping error */
1730   if (last_seq) {
1731     draw_seq_strip(C, sseq, scene, ar, last_seq, 120, pixelx);
1732   }
1733
1734   /* draw highlight when previewing a single strip */
1735   if (special_seq_update) {
1736     const Sequence *seq = special_seq_update;
1737     GPU_blend(true);
1738
1739     uint pos = GPU_vertformat_attr_add(immVertexFormat(), "pos", GPU_COMP_F32, 2, GPU_FETCH_FLOAT);
1740     immBindBuiltinProgram(GPU_SHADER_2D_UNIFORM_COLOR);
1741
1742     immUniformColor4ub(255, 255, 255, 48);
1743     immRectf(pos,
1744              seq->startdisp,
1745              seq->machine + SEQ_STRIP_OFSBOTTOM,
1746              seq->enddisp,
1747              seq->machine + SEQ_STRIP_OFSTOP);
1748
1749     immUnbindProgram();
1750
1751     GPU_blend(false);
1752   }
1753 }
1754
1755 static void seq_draw_sfra_efra(Scene *scene, View2D *v2d)
1756 {
1757   const Editing *ed = BKE_sequencer_editing_get(scene, false);
1758   const int frame_sta = PSFRA;
1759   const int frame_end = PEFRA + 1;
1760
1761   GPU_blend(true);
1762
1763   uint pos = GPU_vertformat_attr_add(immVertexFormat(), "pos", GPU_COMP_F32, 2, GPU_FETCH_FLOAT);
1764   immBindBuiltinProgram(GPU_SHADER_2D_UNIFORM_COLOR);
1765
1766   /* draw darkened area outside of active timeline
1767    * frame range used is preview range or scene range */
1768   immUniformThemeColorShadeAlpha(TH_BACK, -25, -100);
1769
1770   if (frame_sta < frame_end) {
1771     immRectf(pos, v2d->cur.xmin, v2d->cur.ymin, (float)frame_sta, v2d->cur.ymax);
1772     immRectf(pos, (float)frame_end, v2d->cur.ymin, v2d->cur.xmax, v2d->cur.ymax);
1773   }
1774   else {
1775     immRectf(pos, v2d->cur.xmin, v2d->cur.ymin, v2d->cur.xmax, v2d->cur.ymax);
1776   }
1777
1778   immUniformThemeColorShade(TH_BACK, -60);
1779
1780   /* thin lines where the actual frames are */
1781   immBegin(GPU_PRIM_LINES, 4);
1782
1783   immVertex2f(pos, frame_sta, v2d->cur.ymin);
1784   immVertex2f(pos, frame_sta, v2d->cur.ymax);
1785
1786   immVertex2f(pos, frame_end, v2d->cur.ymin);
1787   immVertex2f(pos, frame_end, v2d->cur.ymax);
1788
1789   immEnd();
1790
1791   if (ed && !BLI_listbase_is_empty(&ed->metastack)) {
1792     MetaStack *ms = ed->metastack.last;
1793
1794     immUniformColor4ub(255, 255, 255, 8);
1795     immRectf(pos, ms->disp_range[0], v2d->cur.ymin, ms->disp_range[1], v2d->cur.ymax);
1796
1797     immUniformThemeColorShade(TH_BACK, -40);
1798
1799     immBegin(GPU_PRIM_LINES, 4);
1800
1801     immVertex2f(pos, ms->disp_range[0], v2d->cur.ymin);
1802     immVertex2f(pos, ms->disp_range[0], v2d->cur.ymax);
1803
1804     immVertex2f(pos, ms->disp_range[1], v2d->cur.ymin);
1805     immVertex2f(pos, ms->disp_range[1], v2d->cur.ymax);
1806
1807     immEnd();
1808   }
1809
1810   immUnbindProgram();
1811
1812   GPU_blend(false);
1813 }
1814
1815 typedef struct CacheDrawData {
1816   const bContext *C;
1817   uint pos;
1818   float stripe_offs;
1819   float stripe_ht;
1820 } CacheDrawData;
1821
1822 /* Called as a callback */
1823 static bool draw_cache_view_cb(
1824     void *userdata, struct Sequence *seq, int cfra, int cache_type, float UNUSED(cost))
1825 {
1826   CacheDrawData *drawdata = userdata;
1827   const bContext *C = drawdata->C;
1828   Scene *scene = CTX_data_scene(C);
1829   ARegion *ar = CTX_wm_region(C);
1830   struct View2D *v2d = &ar->v2d;
1831   Editing *ed = scene->ed;
1832   uint pos = drawdata->pos;
1833
1834   if ((ed->cache_flag & SEQ_CACHE_VIEW_FINAL_OUT) == 0) {
1835     return true;
1836   }
1837
1838   float stripe_bot, stripe_top, stripe_offs, stripe_ht;
1839   float color[4];
1840   color[3] = 0.4f;
1841
1842   switch (cache_type) {
1843     case SEQ_CACHE_STORE_FINAL_OUT:
1844       if (scene->ed->cache_flag & SEQ_CACHE_VIEW_FINAL_OUT) {
1845         color[0] = 1.0f;
1846         color[1] = 0.4f;
1847         color[2] = 0.2f;
1848         stripe_ht = UI_view2d_region_to_view_y(v2d, 4.0f * UI_DPI_FAC * U.pixelsize) -
1849                     v2d->cur.ymin;
1850         stripe_bot = UI_view2d_region_to_view_y(v2d, V2D_SCROLL_HEIGHT_HANDLES);
1851         stripe_top = stripe_bot + stripe_ht;
1852         break;
1853       }
1854       else {
1855         return false;
1856       }
1857
1858     case SEQ_CACHE_STORE_RAW:
1859       if (scene->ed->cache_flag & SEQ_CACHE_VIEW_RAW) {
1860         color[0] = 1.0f;
1861         color[1] = 0.1f;
1862         color[2] = 0.02f;
1863         stripe_offs = drawdata->stripe_offs;
1864         stripe_ht = drawdata->stripe_ht;
1865         stripe_bot = seq->machine + SEQ_STRIP_OFSBOTTOM + stripe_offs;
1866         stripe_top = stripe_bot + stripe_ht;
1867         break;
1868       }
1869       else {
1870         return false;
1871       }
1872
1873     case SEQ_CACHE_STORE_PREPROCESSED:
1874       if (scene->ed->cache_flag & SEQ_CACHE_VIEW_PREPROCESSED) {
1875         color[0] = 0.1f;
1876         color[1] = 0.1f;
1877         color[2] = 0.75f;
1878         stripe_offs = drawdata->stripe_offs;
1879         stripe_ht = drawdata->stripe_ht;
1880         stripe_bot = seq->machine + SEQ_STRIP_OFSBOTTOM + (stripe_offs + stripe_ht) + stripe_offs;
1881         stripe_top = stripe_bot + stripe_ht;
1882         break;
1883       }
1884       else {
1885         return false;
1886       }
1887
1888     case SEQ_CACHE_STORE_COMPOSITE:
1889       if (scene->ed->cache_flag & SEQ_CACHE_VIEW_COMPOSITE) {
1890         color[0] = 1.0f;
1891         color[1] = 0.6f;
1892         color[2] = 0.0f;
1893         stripe_offs = drawdata->stripe_offs;
1894         stripe_ht = drawdata->stripe_ht;
1895         stripe_top = seq->machine + SEQ_STRIP_OFSTOP - stripe_offs;
1896         stripe_bot = stripe_top - stripe_ht;
1897         break;
1898       }
1899       else {
1900         return false;
1901       }
1902   }
1903
1904   immUniformColor4f(color[0], color[1], color[2], color[3]);
1905   immRectf(pos, cfra, stripe_bot, cfra + 1, stripe_top);
1906
1907   return false;
1908 }
1909
1910 static void draw_cache_view(const bContext *C)
1911 {
1912   Scene *scene = CTX_data_scene(C);
1913   ARegion *ar = CTX_wm_region(C);
1914   struct View2D *v2d = &ar->v2d;
1915
1916   if ((scene->ed->cache_flag & SEQ_CACHE_VIEW_ENABLE) == 0) {
1917     return;
1918   }
1919
1920   GPU_blend(true);
1921   uint pos = GPU_vertformat_attr_add(immVertexFormat(), "pos", GPU_COMP_F32, 2, GPU_FETCH_FLOAT);
1922   immBindBuiltinProgram(GPU_SHADER_2D_UNIFORM_COLOR);
1923
1924   float stripe_bot, stripe_top;
1925   float stripe_offs = UI_view2d_region_to_view_y(v2d, 1.0f) - v2d->cur.ymin;
1926   float stripe_ht = UI_view2d_region_to_view_y(v2d, 4.0f * UI_DPI_FAC * U.pixelsize) -
1927                     v2d->cur.ymin;
1928
1929   CLAMP_MAX(stripe_ht, 0.2f);
1930   CLAMP_MIN(stripe_offs, stripe_ht / 2);
1931
1932   if (scene->ed->cache_flag & SEQ_CACHE_VIEW_FINAL_OUT) {
1933     stripe_bot = UI_view2d_region_to_view_y(v2d, V2D_SCROLL_HEIGHT_HANDLES);
1934     stripe_top = stripe_bot + stripe_ht;
1935     float bg_color[4] = {1.0f, 0.4f, 0.2f, 0.1f};
1936
1937     immUniformColor4f(bg_color[0], bg_color[1], bg_color[2], bg_color[3]);
1938     immRectf(pos, scene->r.sfra, stripe_bot, scene->r.efra, stripe_top);
1939   }
1940
1941   for (Sequence *seq = scene->ed->seqbasep->first; seq != NULL; seq = seq->next) {
1942     if (seq->type == SEQ_TYPE_SOUND_RAM) {
1943       continue;
1944     }
1945
1946     if (seq->startdisp > v2d->cur.xmax || seq->enddisp < v2d->cur.xmin) {
1947       continue;
1948     }
1949
1950     stripe_bot = seq->machine + SEQ_STRIP_OFSBOTTOM + stripe_offs;
1951     stripe_top = stripe_bot + stripe_ht;
1952
1953     if (scene->ed->cache_flag & SEQ_CACHE_VIEW_RAW) {
1954       float bg_color[4] = {1.0f, 0.1f, 0.02f, 0.1f};
1955       immUniformColor4f(bg_color[0], bg_color[1], bg_color[2], bg_color[3]);
1956       immRectf(pos, seq->startdisp, stripe_bot, seq->enddisp, stripe_top);
1957     }
1958
1959     stripe_bot += stripe_ht + stripe_offs;
1960     stripe_top = stripe_bot + stripe_ht;
1961
1962     if (scene->ed->cache_flag & SEQ_CACHE_VIEW_PREPROCESSED) {
1963       float bg_color[4] = {0.1f, 0.1f, 0.75f, 0.1f};
1964       immUniformColor4f(bg_color[0], bg_color[1], bg_color[2], bg_color[3]);
1965       immRectf(pos, seq->startdisp, stripe_bot, seq->enddisp, stripe_top);
1966     }
1967
1968     stripe_top = seq->machine + SEQ_STRIP_OFSTOP - stripe_offs;
1969     stripe_bot = stripe_top - stripe_ht;
1970
1971     if (scene->ed->cache_flag & SEQ_CACHE_VIEW_COMPOSITE) {
1972       float bg_color[4] = {1.0f, 0.6f, 0.0f, 0.1f};
1973       immUniformColor4f(bg_color[0], bg_color[1], bg_color[2], bg_color[3]);
1974       immRectf(pos, seq->startdisp, stripe_bot, seq->enddisp, stripe_top);
1975     }
1976   }
1977
1978   CacheDrawData userdata;
1979   userdata.C = C;
1980   userdata.pos = pos;
1981   userdata.stripe_offs = stripe_offs;
1982   userdata.stripe_ht = stripe_ht;
1983
1984   BKE_sequencer_cache_iterate(scene, &userdata, draw_cache_view_cb);
1985
1986   immUnbindProgram();
1987   GPU_blend(false);
1988 }
1989
1990 /* Draw Timeline/Strip Editor Mode for Sequencer */
1991 void draw_timeline_seq(const bContext *C, ARegion *ar)
1992 {
1993   Scene *scene = CTX_data_scene(C);
1994   Editing *ed = BKE_sequencer_editing_get(scene, false);
1995   SpaceSeq *sseq = CTX_wm_space_seq(C);
1996   View2D *v2d = &ar->v2d;
1997   View2DScrollers *scrollers;
1998   short cfra_flag = 0;
1999   float col[3];
2000
2001   /* clear and setup matrix */
2002   UI_GetThemeColor3fv(TH_BACK, col);
2003   if (ed && ed->metastack.first) {
2004     GPU_clear_color(col[0], col[1], col[2] - 0.1f, 0.0f);
2005   }
2006   else {
2007     GPU_clear_color(col[0], col[1], col[2], 0.0f);
2008   }
2009   GPU_clear(GPU_COLOR_BIT);
2010
2011   UI_view2d_view_ortho(v2d);
2012
2013   /* calculate extents of sequencer strips/data
2014    * NOTE: needed for the scrollers later
2015    */
2016   boundbox_seq(scene, &v2d->tot);
2017
2018   /* draw backdrop */
2019   draw_seq_backdrop(v2d);
2020
2021   /* regular grid-pattern over the rest of the view (i.e. 1-second grid lines) */
2022   UI_view2d_constant_grid_draw(v2d, FPS);
2023
2024   /* Only draw backdrop in pure sequence view. */
2025   if (sseq->view == SEQ_VIEW_SEQUENCE && sseq->draw_flag & SEQ_DRAW_BACKDROP) {
2026     sequencer_draw_preview(C, scene, ar, sseq, scene->r.cfra, 0, false, true);
2027     UI_view2d_view_ortho(v2d);
2028   }
2029
2030   ED_region_draw_cb_draw(C, ar, REGION_DRAW_PRE_VIEW);
2031
2032   seq_draw_sfra_efra(scene, v2d);
2033
2034   /* sequence strips (if there is data available to be drawn) */
2035   if (ed) {
2036     /* draw the data */
2037     draw_seq_strips(C, ed, ar);
2038     draw_cache_view(C);
2039
2040     /* text draw cached (for sequence names), in pixelspace now */
2041     UI_view2d_text_cache_draw(ar);
2042   }
2043
2044   /* current frame */
2045   UI_view2d_view_ortho(v2d);
2046   if ((sseq->flag & SEQ_DRAWFRAMES) == 0) {
2047     cfra_flag |= DRAWCFRA_UNIT_SECONDS;
2048   }
2049   ANIM_draw_cfra(C, v2d, cfra_flag);
2050
2051   /* markers */
2052   UI_view2d_view_orthoSpecial(ar, v2d, 1);
2053   int marker_draw_flag = DRAW_MARKERS_MARGIN;
2054   if (sseq->flag & SEQ_SHOW_MARKER_LINES) {
2055     marker_draw_flag |= DRAW_MARKERS_LINES;
2056   }
2057   ED_markers_draw(C, marker_draw_flag);
2058
2059   /* preview range */
2060   UI_view2d_view_ortho(v2d);
2061   ANIM_draw_previewrange(C, v2d, 1);
2062
2063   /* overlap playhead */
2064   if (scene->ed && scene->ed->over_flag & SEQ_EDIT_OVERLAY_SHOW) {
2065     int cfra_over = (scene->ed->over_flag & SEQ_EDIT_OVERLAY_ABS) ?
2066                         scene->ed->over_cfra :
2067                         scene->r.cfra + scene->ed->over_ofs;
2068
2069     uint pos = GPU_vertformat_attr_add(immVertexFormat(), "pos", GPU_COMP_F32, 2, GPU_FETCH_FLOAT);
2070     immBindBuiltinProgram(GPU_SHADER_2D_UNIFORM_COLOR);
2071
2072     immUniformColor3f(0.2f, 0.2f, 0.2f);
2073
2074     immBegin(GPU_PRIM_LINES, 2);
2075     immVertex2f(pos, cfra_over, v2d->cur.ymin);
2076     immVertex2f(pos, cfra_over, v2d->cur.ymax);
2077     immEnd();
2078
2079     immUnbindProgram();
2080   }
2081
2082   /* callback */
2083   ED_region_draw_cb_draw(C, ar, REGION_DRAW_POST_VIEW);
2084
2085   /* reset view matrix */
2086   UI_view2d_view_restore(C);
2087
2088   /* scrubbing region */
2089   ED_scrubbing_draw(ar, scene, !(sseq->flag & SEQ_DRAWFRAMES), true);
2090
2091   /* scrollers */
2092   scrollers = UI_view2d_scrollers_calc(v2d, NULL);
2093   UI_view2d_scrollers_draw(v2d, scrollers);
2094   UI_view2d_scrollers_free(scrollers);
2095
2096   /* channel numbers */
2097   {
2098     rcti rect;
2099     BLI_rcti_init(&rect,
2100                   0,
2101                   15 * UI_DPI_FAC,
2102                   15 * UI_DPI_FAC,
2103                   UI_DPI_FAC * ar->sizey - UI_SCRUBBING_MARGIN_Y);
2104     UI_view2d_draw_scale_y__block(ar, v2d, &rect, TH_SCROLL_TEXT);
2105   }
2106 }