code cleanup: favor braces when blocks have mixed brace use.
[blender.git] / source / blender / editors / space_sequencer / sequencer_draw.c
index 0fcc935..7ebe04f 100644 (file)
@@ -62,6 +62,7 @@
 #include "ED_gpencil.h"
 #include "ED_markers.h"
 #include "ED_mask.h"
+#include "ED_sequencer.h"
 #include "ED_types.h"
 #include "ED_space_api.h"
 
@@ -285,8 +286,8 @@ static void drawmeta_contents(Scene *scene, Sequence *seqm, float x1, float y1,
                drawmeta_stipple(1);
 
        for (seq = seqm->seqbase.first; seq; seq = seq->next) {
-               chan_min = MIN2(chan_min, seq->machine);
-               chan_max = MAX2(chan_max, seq->machine);
+               chan_min = min_ii(chan_min, seq->machine);
+               chan_max = max_ii(chan_max, seq->machine);
        }
 
        chan_range = (chan_max - chan_min) + 1;
@@ -355,7 +356,7 @@ static void draw_seq_handle(View2D *v2d, Sequence *seq, const float handsize_cla
        y2 = seq->machine + SEQ_STRIP_OFSTOP;
 
        /* set up co-ordinates/dimensions for either left or right handle */
-       if (direction == SEQ_LEFTHANDLE) {      
+       if (direction == SEQ_LEFTHANDLE) {
                rx1 = x1;
                rx2 = x1 + handsize_clamped * 0.75f;
                
@@ -415,7 +416,7 @@ static void draw_seq_handle(View2D *v2d, Sequence *seq, const float handsize_cla
                        y1 = y2 + 0.05f;
                }
                UI_view2d_text_cache_add(v2d, x1, y1, numstr, col);
-       }       
+       }
 }
 
 static void draw_seq_extensions(Scene *scene, ARegion *ar, Sequence *seq)
@@ -432,7 +433,7 @@ static void draw_seq_extensions(Scene *scene, ARegion *ar, Sequence *seq)
        y1 = seq->machine + SEQ_STRIP_OFSBOTTOM;
        y2 = seq->machine + SEQ_STRIP_OFSTOP;
 
-       pixely = (v2d->cur.ymax - v2d->cur.ymin) / (v2d->mask.ymax - v2d->mask.ymin);
+       pixely = BLI_rctf_size_y(&v2d->cur) / BLI_rcti_size_y(&v2d->mask);
        
        if (pixely <= 0) return;  /* can happen when the view is split/resized */
        
@@ -704,7 +705,9 @@ static void draw_seq_strip(Scene *scene, ARegion *ar, Sequence *seq, int outline
        
        /* draw the main strip body */
        if (is_single_image) {  /* single image */
-               draw_shadedstrip(seq, background_col, BKE_sequence_tx_get_final_left(seq, 0), y1, BKE_sequence_tx_get_final_right(seq, 0), y2);
+               draw_shadedstrip(seq, background_col,
+                                BKE_sequence_tx_get_final_left(seq, 0), y1,
+                                BKE_sequence_tx_get_final_right(seq, 0), y2);
        }
        else {  /* normal operation */
                draw_shadedstrip(seq, background_col, x1, y1, x2, y2);
@@ -723,7 +726,7 @@ static void draw_seq_strip(Scene *scene, ARegion *ar, Sequence *seq, int outline
        
        /* draw sound wave */
        if (seq->type == SEQ_TYPE_SOUND_RAM) {
-               drawseqwave(scene, seq, x1, y1, x2, y2, (ar->v2d.cur.xmax - ar->v2d.cur.xmin) / ar->winx);
+               drawseqwave(scene, seq, x1, y1, x2, y2, BLI_rctf_size_x(&ar->v2d.cur) / ar->winx);
        }
 
        /* draw lock */
@@ -745,6 +748,17 @@ static void draw_seq_strip(Scene *scene, ARegion *ar, Sequence *seq, int outline
                glDisable(GL_BLEND);
        }
 
+       if (!BKE_sequence_is_valid_check(seq)) {
+               glEnable(GL_POLYGON_STIPPLE);
+
+               /* panic! */
+               glColor4ub(255, 0, 0, 255);
+               glPolygonStipple(stipple_diag_stripes_pos);
+               glRectf(x1, y1, x2, y2);
+
+               glDisable(GL_POLYGON_STIPPLE);
+       }
+
        get_seq_color3ubv(scene, seq, col);
        if (G.moving && (seq->flag & SELECT)) {
                if (seq->flag & SEQ_OVERLAP) {
@@ -797,27 +811,134 @@ static void UNUSED_FUNCTION(set_special_seq_update) (int val)
 
        /* if mouse over a sequence && LEFTMOUSE */
        if (val) {
-// XXX         special_seq_update= find_nearest_seq(&x);
+// XXX         special_seq_update = find_nearest_seq(&x);
+       }
+       else {
+               special_seq_update = NULL;
        }
-       else special_seq_update = NULL;
 }
 
-void draw_image_seq(const bContext *C, Scene *scene, ARegion *ar, SpaceSeq *sseq, int cfra, int frame_ofs)
+ImBuf *sequencer_ibuf_get(struct Main *bmain, Scene *scene, SpaceSeq *sseq, int cfra, int frame_ofs)
+{
+       SeqRenderData context;
+       ImBuf *ibuf;
+       int rectx, recty;
+       float render_size = 0.0;
+       float proxy_size = 100.0;
+       short is_break = G.is_break;
+
+       render_size = sseq->render_size;
+       if (render_size == 0) {
+               render_size = scene->r.size;
+       }
+       else {
+               proxy_size = render_size;
+       }
+
+       if (render_size < 0) {
+               return NULL;
+       }
+
+       rectx = (render_size * (float)scene->r.xsch) / 100.0f + 0.5f;
+       recty = (render_size * (float)scene->r.ysch) / 100.0f + 0.5f;
+
+       context = BKE_sequencer_new_render_data(bmain, scene, rectx, recty, proxy_size);
+
+       /* sequencer could start rendering, in this case we need to be sure it wouldn't be canceled
+        * by Esc pressed somewhere in the past
+        */
+       G.is_break = FALSE;
+
+       if (special_seq_update)
+               ibuf = BKE_sequencer_give_ibuf_direct(context, cfra + frame_ofs, special_seq_update);
+       else if (!U.prefetchframes) // XXX || (G.f & G_PLAYANIM) == 0) {
+               ibuf = BKE_sequencer_give_ibuf(context, cfra + frame_ofs, sseq->chanshown);
+       else
+               ibuf = BKE_sequencer_give_ibuf_threaded(context, cfra + frame_ofs, sseq->chanshown);
+
+       /* restore state so real rendering would be canceled (if needed) */
+       G.is_break = is_break;
+
+       return ibuf;
+}
+
+static void sequencer_check_scopes(SequencerScopes *scopes, ImBuf *ibuf)
+{
+       if (scopes->reference_ibuf != ibuf) {
+               if (scopes->zebra_ibuf) {
+                       IMB_freeImBuf(scopes->zebra_ibuf);
+                       scopes->zebra_ibuf = NULL;
+               }
+
+               if (scopes->waveform_ibuf) {
+                       IMB_freeImBuf(scopes->waveform_ibuf);
+                       scopes->waveform_ibuf = NULL;
+               }
+
+               if (scopes->sep_waveform_ibuf) {
+                       IMB_freeImBuf(scopes->sep_waveform_ibuf);
+                       scopes->sep_waveform_ibuf = NULL;
+               }
+
+               if (scopes->vector_ibuf) {
+                       IMB_freeImBuf(scopes->vector_ibuf);
+                       scopes->vector_ibuf = NULL;
+               }
+
+               if (scopes->histogram_ibuf) {
+                       IMB_freeImBuf(scopes->histogram_ibuf);
+                       scopes->histogram_ibuf = NULL;
+               }
+       }
+}
+
+static ImBuf *sequencer_make_scope(Scene *scene, ImBuf *ibuf, ImBuf *(*make_scope_cb) (ImBuf *ibuf))
+{
+       ImBuf *display_ibuf = IMB_dupImBuf(ibuf);
+       ImBuf *scope;
+
+       if (display_ibuf->rect_float) {
+               IMB_colormanagement_imbuf_make_display_space(display_ibuf, &scene->view_settings,
+                                                            &scene->display_settings);
+       }
+
+       scope = make_scope_cb(display_ibuf);
+
+       IMB_freeImBuf(display_ibuf);
+
+       return scope;
+}
+
+void draw_image_seq(const bContext *C, Scene *scene, ARegion *ar, SpaceSeq *sseq, int cfra, int frame_ofs, int draw_overlay)
 {
        struct Main *bmain = CTX_data_main(C);
        struct ImBuf *ibuf = NULL;
        struct ImBuf *scope = NULL;
        struct View2D *v2d = &ar->v2d;
-       int rectx, recty;
+       /* int rectx, recty; */ /* UNUSED */
        float viewrectx, viewrecty;
        float render_size = 0.0;
        float proxy_size = 100.0;
        float col[3];
        GLuint texid;
        GLuint last_texid;
-       SeqRenderData context;
        unsigned char *display_buffer;
        void *cache_handle = NULL;
+       const int is_imbuf = ED_space_sequencer_check_show_imbuf(sseq);
+
+       if (G.is_rendering == FALSE && (scene->r.seq_flag & R_SEQ_GL_PREV) == 0) {
+               /* stop all running jobs, except screen one. currently previews frustrate Render
+                * needed to make so sequencer's rendering doesn't conflict with compositor
+                */
+               WM_jobs_kill_type(CTX_wm_manager(C), WM_JOB_TYPE_COMPOSITE);
+
+               if ((scene->r.seq_flag & R_SEQ_GL_PREV) == 0) {
+                       /* in case of final rendering used for preview, kill all previews,
+                        * otherwise threading conflict will happen in rendering module
+                        */
+                       WM_jobs_kill_type(CTX_wm_manager(C), WM_JOB_TYPE_RENDER_PREVIEW);
+               }
+       }
 
        render_size = sseq->render_size;
        if (render_size == 0) {
@@ -833,8 +954,8 @@ void draw_image_seq(const bContext *C, Scene *scene, ARegion *ar, SpaceSeq *sseq
        viewrectx = (render_size * (float)scene->r.xsch) / 100.0f;
        viewrecty = (render_size * (float)scene->r.ysch) / 100.0f;
 
-       rectx = viewrectx + 0.5f;
-       recty = viewrecty + 0.5f;
+       /* rectx = viewrectx + 0.5f; */ /* UNUSED */
+       /* recty = viewrecty + 0.5f; */ /* UNUSED */
 
        if (sseq->mainb == SEQ_DRAW_IMG_IMBUF) {
                viewrectx *= scene->r.xasp / scene->r.yasp;
@@ -842,7 +963,7 @@ void draw_image_seq(const bContext *C, Scene *scene, ARegion *ar, SpaceSeq *sseq
                viewrecty /= proxy_size / 100.0f;
        }
 
-       if (frame_ofs == 0) {
+       if (!draw_overlay || sseq->overlay_type == SEQ_DRAW_OVERLAY_REFERENCE) {
                UI_GetThemeColor3fv(TH_SEQ_PREVIEW, col);
                glClearColor(col[0], col[1], col[2], 0.0);
                glClear(GL_COLOR_BUFFER_BIT);
@@ -855,44 +976,61 @@ void draw_image_seq(const bContext *C, Scene *scene, ARegion *ar, SpaceSeq *sseq
        UI_view2d_curRect_validate(v2d);
 
        /* only initialize the preview if a render is in progress */
-       if (G.rendering)
+       if (G.is_rendering)
                return;
 
-       context = BKE_sequencer_new_render_data(bmain, scene, rectx, recty, proxy_size);
-
-       if (special_seq_update)
-               ibuf = BKE_sequencer_give_ibuf_direct(context, cfra + frame_ofs, special_seq_update);
-       else if (!U.prefetchframes) // XXX || (G.f & G_PLAYANIM) == 0) {
-               ibuf = BKE_sequencer_give_ibuf(context, cfra + frame_ofs, sseq->chanshown);
-       else
-               ibuf = BKE_sequencer_give_ibuf_threaded(context, cfra + frame_ofs, sseq->chanshown);
+       ibuf = sequencer_ibuf_get(bmain, scene, sseq, cfra, frame_ofs);
        
        if (ibuf == NULL)
                return;
 
        if (ibuf->rect == NULL && ibuf->rect_float == NULL)
                return;
-       
-       switch (sseq->mainb) {
-               case SEQ_DRAW_IMG_IMBUF:
-                       if (sseq->zebra != 0) {
-                               scope = make_zebra_view_from_ibuf(ibuf, sseq->zebra);
-                       }
-                       break;
-               case SEQ_DRAW_IMG_WAVEFORM:
-                       if ((sseq->flag & SEQ_DRAW_COLOR_SEPARATED) != 0) {
-                               scope = make_sep_waveform_view_from_ibuf(ibuf);
-                       }
-                       else {
-                               scope = make_waveform_view_from_ibuf(ibuf);
-                       }
-                       break;
-               case SEQ_DRAW_IMG_VECTORSCOPE:
-                       scope = make_vectorscope_view_from_ibuf(ibuf);
-                       break;
-               case SEQ_DRAW_IMG_HISTOGRAM:
-                       scope = make_histogram_view_from_ibuf(ibuf);
-                       break;
+
+       if (sseq->mainb != SEQ_DRAW_IMG_IMBUF || sseq->zebra != 0) {
+               SequencerScopes *scopes = &sseq->scopes;
+
+               sequencer_check_scopes(scopes, ibuf);
+
+               switch (sseq->mainb) {
+                       case SEQ_DRAW_IMG_IMBUF:
+                               if (!scopes->zebra_ibuf) {
+                                       ImBuf *display_ibuf = IMB_dupImBuf(ibuf);
+
+                                       if (display_ibuf->rect_float) {
+                                               IMB_colormanagement_imbuf_make_display_space(display_ibuf, &scene->view_settings,
+                                                                                            &scene->display_settings);
+                                       }
+                                       scopes->zebra_ibuf = make_zebra_view_from_ibuf(display_ibuf, sseq->zebra);
+                                       IMB_freeImBuf(display_ibuf);
+                               }
+                               scope = scopes->zebra_ibuf;
+                               break;
+                       case SEQ_DRAW_IMG_WAVEFORM:
+                               if ((sseq->flag & SEQ_DRAW_COLOR_SEPARATED) != 0) {
+                                       if (!scopes->sep_waveform_ibuf)
+                                               scopes->sep_waveform_ibuf = sequencer_make_scope(scene, ibuf, make_sep_waveform_view_from_ibuf);
+                                       scope = scopes->sep_waveform_ibuf;
+                               }
+                               else {
+                                       if (!scopes->waveform_ibuf)
+                                               scopes->waveform_ibuf = sequencer_make_scope(scene, ibuf, make_waveform_view_from_ibuf);
+                                       scope = scopes->waveform_ibuf;
+                               }
+                               break;
+                       case SEQ_DRAW_IMG_VECTORSCOPE:
+                               if (!scopes->vector_ibuf)
+                                       scopes->vector_ibuf = sequencer_make_scope(scene, ibuf, make_vectorscope_view_from_ibuf);
+                               scope = scopes->vector_ibuf;
+                               break;
+                       case SEQ_DRAW_IMG_HISTOGRAM:
+                               if (!scopes->histogram_ibuf)
+                                       scopes->histogram_ibuf = sequencer_make_scope(scene, ibuf, make_histogram_view_from_ibuf);
+                               scope = scopes->histogram_ibuf;
+                               break;
+               }
+
+               scopes->reference_ibuf = ibuf;
        }
 
        if (scope) {
@@ -906,13 +1044,7 @@ void draw_image_seq(const bContext *C, Scene *scene, ARegion *ar, SpaceSeq *sseq
                display_buffer = (unsigned char *)ibuf->rect;
        }
        else {
-               const ColorManagedViewSettings *view_settings;
-               wmWindow *win = CTX_wm_window(C);
-
-               ibuf->colormanagement_flags |= IMB_COLORMANAGEMENT_SRGB_SOURCE;
-
-               view_settings = IMB_view_settings_get_effective(win, &sseq->view_settings);
-               display_buffer = IMB_display_buffer_acquire(ibuf, view_settings, &win->display_settings, &cache_handle);
+               display_buffer = IMB_display_buffer_acquire_ctx(C, ibuf, &cache_handle);
        }
 
        /* setting up the view - actual drawing starts here */
@@ -928,19 +1060,33 @@ void draw_image_seq(const bContext *C, Scene *scene, ARegion *ar, SpaceSeq *sseq
        glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
 
        glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA8, ibuf->x, ibuf->y, 0, GL_RGBA, GL_UNSIGNED_BYTE, display_buffer);
-       glBegin(GL_QUADS);
 
-       if (frame_ofs) {
-               rctf tot_clip;
-               tot_clip.xmin = v2d->tot.xmin + (ABS(v2d->tot.xmax - v2d->tot.xmin) * scene->ed->over_border.xmin);
-               tot_clip.ymin = v2d->tot.ymin + (ABS(v2d->tot.ymax - v2d->tot.ymin) * scene->ed->over_border.ymin);
-               tot_clip.xmax = v2d->tot.xmin + (ABS(v2d->tot.xmax - v2d->tot.xmin) * scene->ed->over_border.xmax);
-               tot_clip.ymax = v2d->tot.ymin + (ABS(v2d->tot.ymax - v2d->tot.ymin) * scene->ed->over_border.ymax);
+       if (sseq->flag & SEQ_USE_ALPHA) {
+               glEnable(GL_BLEND);
+               glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
+       }
+
+       glBegin(GL_QUADS);
 
-               glTexCoord2f(scene->ed->over_border.xmin, scene->ed->over_border.ymin); glVertex2f(tot_clip.xmin, tot_clip.ymin);
-               glTexCoord2f(scene->ed->over_border.xmin, scene->ed->over_border.ymax); glVertex2f(tot_clip.xmin, tot_clip.ymax);
-               glTexCoord2f(scene->ed->over_border.xmax, scene->ed->over_border.ymax); glVertex2f(tot_clip.xmax, tot_clip.ymax);
-               glTexCoord2f(scene->ed->over_border.xmax, scene->ed->over_border.ymin); glVertex2f(tot_clip.xmax, tot_clip.ymin);
+       if (draw_overlay) {
+               if (sseq->overlay_type == SEQ_DRAW_OVERLAY_RECT) {
+                       rctf tot_clip;
+                       tot_clip.xmin = v2d->tot.xmin + (fabsf(BLI_rctf_size_x(&v2d->tot)) * scene->ed->over_border.xmin);
+                       tot_clip.ymin = v2d->tot.ymin + (fabsf(BLI_rctf_size_y(&v2d->tot)) * scene->ed->over_border.ymin);
+                       tot_clip.xmax = v2d->tot.xmin + (fabsf(BLI_rctf_size_x(&v2d->tot)) * scene->ed->over_border.xmax);
+                       tot_clip.ymax = v2d->tot.ymin + (fabsf(BLI_rctf_size_y(&v2d->tot)) * scene->ed->over_border.ymax);
+
+                       glTexCoord2f(scene->ed->over_border.xmin, scene->ed->over_border.ymin); glVertex2f(tot_clip.xmin, tot_clip.ymin);
+                       glTexCoord2f(scene->ed->over_border.xmin, scene->ed->over_border.ymax); glVertex2f(tot_clip.xmin, tot_clip.ymax);
+                       glTexCoord2f(scene->ed->over_border.xmax, scene->ed->over_border.ymax); glVertex2f(tot_clip.xmax, tot_clip.ymax);
+                       glTexCoord2f(scene->ed->over_border.xmax, scene->ed->over_border.ymin); glVertex2f(tot_clip.xmax, tot_clip.ymin);
+               }
+               else if (sseq->overlay_type == SEQ_DRAW_OVERLAY_REFERENCE) {
+                       glTexCoord2f(0.0f, 0.0f); glVertex2f(v2d->tot.xmin, v2d->tot.ymin);
+                       glTexCoord2f(0.0f, 1.0f); glVertex2f(v2d->tot.xmin, v2d->tot.ymax);
+                       glTexCoord2f(1.0f, 1.0f); glVertex2f(v2d->tot.xmax, v2d->tot.ymax);
+                       glTexCoord2f(1.0f, 0.0f); glVertex2f(v2d->tot.xmax, v2d->tot.ymin);
+               }
        }
        else {
                glTexCoord2f(0.0f, 0.0f); glVertex2f(v2d->tot.xmin, v2d->tot.ymin);
@@ -951,6 +1097,8 @@ void draw_image_seq(const bContext *C, Scene *scene, ARegion *ar, SpaceSeq *sseq
        glEnd();
        glBindTexture(GL_TEXTURE_2D, last_texid);
        glDisable(GL_TEXTURE_2D);
+       if (sseq->flag & SEQ_USE_ALPHA)
+               glDisable(GL_BLEND);
        glDeleteTextures(1, &texid);
 
        if (sseq->mainb == SEQ_DRAW_IMG_IMBUF) {
@@ -996,17 +1144,25 @@ void draw_image_seq(const bContext *C, Scene *scene, ARegion *ar, SpaceSeq *sseq
                setlinestyle(0);
        }
        
-       /* draw grease-pencil (image aligned) */
-       draw_gpencil_2dimage(C);
+       if (sseq->flag & SEQ_SHOW_GPENCIL) {
+               if (is_imbuf) {
+                       /* draw grease-pencil (image aligned) */
+                       draw_gpencil_2dimage(C);
+               }
+       }
 
-       IMB_freeImBuf(ibuf);
+       if (!scope)
+               IMB_freeImBuf(ibuf);
        
        /* ortho at pixel level */
        UI_view2d_view_restore(C);
        
-       /* draw grease-pencil (screen aligned) */
-       draw_gpencil_view2d(C, 0);
-
+       if (sseq->flag & SEQ_SHOW_GPENCIL) {
+               if (is_imbuf) {
+                       /* draw grease-pencil (screen aligned) */
+                       draw_gpencil_view2d(C, 0);
+               }
+       }
 
 
        /* NOTE: sequencer mask editing isnt finished, the draw code is working but editing not,
@@ -1018,6 +1174,7 @@ void draw_image_seq(const bContext *C, Scene *scene, ARegion *ar, SpaceSeq *sseq
 
                if (mask) {
                        int width, height;
+                       float aspx = 1.0f, aspy = 1.0f;
                        // ED_mask_get_size(C, &width, &height);
 
                        //Scene *scene = CTX_data_scene(C);
@@ -1027,6 +1184,7 @@ void draw_image_seq(const bContext *C, Scene *scene, ARegion *ar, SpaceSeq *sseq
                        ED_mask_draw_region(mask, ar,
                                            0, 0,  /* TODO */
                                            width, height,
+                                           aspx, aspy,
                                            FALSE, TRUE,
                                            NULL, C);
                }
@@ -1073,7 +1231,7 @@ static void draw_seq_backdrop(View2D *v2d)
        glRectf(v2d->cur.xmin,  -1.0,  v2d->cur.xmax,  1.0);
 
        /* Alternating horizontal stripes */
-       i = maxi(1, ((int)v2d->cur.ymin) - 1);
+       i = max_ii(1, ((int)v2d->cur.ymin) - 1);
 
        glBegin(GL_QUADS);
        while (i < v2d->cur.ymax) {
@@ -1092,7 +1250,7 @@ static void draw_seq_backdrop(View2D *v2d)
        glEnd();
        
        /* Darker lines separating the horizontal bands */
-       i = maxi(1, ((int)v2d->cur.ymin) - 1);
+       i = max_ii(1, ((int)v2d->cur.ymin) - 1);
        UI_ThemeColor(TH_GRID);
        
        glBegin(GL_LINES);
@@ -1112,7 +1270,7 @@ static void draw_seq_strips(const bContext *C, Editing *ed, ARegion *ar)
        View2D *v2d = &ar->v2d;
        Sequence *last_seq = BKE_sequencer_active_get(scene);
        int sel = 0, j;
-       float pixelx = (v2d->cur.xmax - v2d->cur.xmin) / (v2d->mask.xmax - v2d->mask.xmin);
+       float pixelx = BLI_rctf_size_x(&v2d->cur) / BLI_rcti_size_x(&v2d->mask);
        
        /* loop through twice, first unselected, then selected */
        for (j = 0; j < 2; j++) {
@@ -1124,8 +1282,8 @@ static void draw_seq_strips(const bContext *C, Editing *ed, ARegion *ar)
                        /* boundbox and selection tests for NOT drawing the strip... */
                        if ((seq->flag & SELECT) != sel) continue;
                        else if (seq == last_seq) continue;
-                       else if (MIN2(seq->startdisp, seq->start) > v2d->cur.xmax) continue;
-                       else if (MAX2(seq->enddisp, seq->start + seq->len) < v2d->cur.xmin) continue;
+                       else if (min_ii(seq->startdisp, seq->start) > v2d->cur.xmax) continue;
+                       else if (max_ii(seq->enddisp, seq->start + seq->len) < v2d->cur.xmin) continue;
                        else if (seq->machine + 1.0f < v2d->cur.ymin) continue;
                        else if (seq->machine > v2d->cur.ymax) continue;