Sequence editor code cleanup

* The logic in some parts of the sequencer code was rather cryptic, so I cleaned it up a bit.
* There should be no functional changes what so ever from these changes.

2 files changed, 255 insertions, 381 deletions

diff --git a/source/blender/blenkernel/BKE_sequencer.h b/source/blender/blenkernel/BKE_sequencer.h
index 8cf541ae03a..6e20b912811 100644
--- a/source/blender/blenkernel/BKE_sequencer.h
+++ b/source/blender/blenkernel/BKE_sequencer.h
@@ -46,6 +46,11 @@ struct StripElem;
 #define BUILD_SEQAR_COUNT_CURRENT  1
 #define BUILD_SEQAR_COUNT_CHILDREN 2
 
+#define EARLY_NO_INPUT		-1
+#define EARLY_DO_EFFECT		0
+#define EARLY_USE_INPUT_1	1
+#define EARLY_USE_INPUT_2	2
+
 /* sequence iterator */
 
 typedef struct SeqIterator {
diff --git a/source/blender/blenkernel/intern/sequencer.c b/source/blender/blenkernel/intern/sequencer.c
index fcf574e1f1f..c379ca43f82 100644
--- a/source/blender/blenkernel/intern/sequencer.c
+++ b/source/blender/blenkernel/intern/sequencer.c
@@ -372,7 +372,7 @@ void build_seqar(ListBase *seqbase, Sequence  ***seqar, int *totseq)
 	do_seq_count(seqbase, totseq);
 
 	if(*totseq==0) {
-		*seqar= 0;
+		*seqar= NULL;
 		return;
 	}
 	*seqar= MEM_mallocN(sizeof(void *)* *totseq, "seqar");
@@ -411,8 +411,7 @@ static void do_build_seqar_cb(ListBase *seqbase, Sequence ***seqar, int depth,
 		seq->depth= depth;
 
 		if(seq->seqbase.first && (test & BUILD_SEQAR_COUNT_CHILDREN)) {
-			do_build_seqar_cb(&seq->seqbase, seqar, depth+1, 
-					  test_func);
+			do_build_seqar_cb(&seq->seqbase, seqar, depth+1, test_func);
 		}
 		if (test & BUILD_SEQAR_COUNT_CURRENT) {
 			**seqar= seq;
@@ -431,7 +430,7 @@ void build_seqar_cb(ListBase *seqbase, Sequence  ***seqar, int *totseq,
 	do_seq_count_cb(seqbase, totseq, test_func);
 
 	if(*totseq==0) {
-		*seqar= 0;
+		*seqar= NULL;
 		return;
 	}
 	*seqar= MEM_mallocN(sizeof(void *)* *totseq, "seqar");
@@ -471,7 +470,7 @@ static void seq_update_sound_bounds_recursive(Scene *scene, Sequence *metaseq)
 		if(seq->type == SEQ_META) {
 			seq_update_sound_bounds_recursive(scene, seq);
 		}
-		else if((seq->type == SEQ_SOUND) || (seq->type == SEQ_SCENE)) {
+		else if(ELEM(seq->type, SEQ_SOUND, SEQ_SCENE)) {
 			if(seq->scene_sound) {
 				int startofs = seq->startofs;
 				int endofs = seq->endofs;
@@ -502,8 +501,8 @@ void calc_sequence(Scene *scene, Sequence *seq)
 
 	if(seq->type & SEQ_EFFECT) {
 		/* pointers */
-		if(seq->seq2==0) seq->seq2= seq->seq1;
-		if(seq->seq3==0) seq->seq3= seq->seq1;
+		if(seq->seq2==NULL) seq->seq2= seq->seq1;
+		if(seq->seq3==NULL) seq->seq3= seq->seq1;
 
 		/* effecten go from seq1 -> seq2: test */
 
@@ -558,9 +557,7 @@ void reload_sequence_new_file(Scene *scene, Sequence * seq, int lock_range)
 	int prev_startdisp, prev_enddisp;
 	/* note: dont rename the strip, will break animation curves */
 
-	if (!(seq->type == SEQ_MOVIE || seq->type == SEQ_IMAGE ||
-		  seq->type == SEQ_SOUND ||
-		  seq->type == SEQ_SCENE || seq->type == SEQ_META)) {
+	if (ELEM5(seq->type, SEQ_MOVIE, SEQ_IMAGE, SEQ_SOUND, SEQ_SCENE, SEQ_META)==0) {
 		return;
 	}
 
@@ -574,13 +571,14 @@ void reload_sequence_new_file(Scene *scene, Sequence * seq, int lock_range)
 
 	new_tstripdata(seq);
 
-	if (seq->type != SEQ_SCENE && seq->type != SEQ_META &&
-		seq->type != SEQ_IMAGE) {
+	if (ELEM3(seq->type, SEQ_SCENE, SEQ_META, SEQ_IMAGE)==0) {
 		BLI_join_dirfile(str, seq->strip->dir, seq->strip->stripdata->name);
 		BLI_path_abs(str, G.main->name);
 	}
 
-	if (seq->type == SEQ_IMAGE) {
+	switch(seq->type) {
+	case SEQ_IMAGE:
+	{
 		/* Hack? */
 		size_t olen = MEM_allocN_len(seq->strip->stripdata)/sizeof(struct StripElem);
 
@@ -591,7 +589,9 @@ void reload_sequence_new_file(Scene *scene, Sequence * seq, int lock_range)
 			seq->len = 0;
 		}
 		seq->strip->len = seq->len;
-	} else if (seq->type == SEQ_MOVIE) {
+		break;
+	}
+	case SEQ_MOVIE:
 		if(seq->anim) IMB_free_anim(seq->anim);
 		seq->anim = openanim(str, IB_rect | ((seq->flag & SEQ_FILTERY) ? IB_animdeinterlace : 0));
 
@@ -609,7 +609,7 @@ void reload_sequence_new_file(Scene *scene, Sequence * seq, int lock_range)
 			seq->len = 0;
 		}
 		seq->strip->len = seq->len;
-	} else if (seq->type == SEQ_SOUND) {
+	case SEQ_SOUND:
 		seq->len = ceil(AUD_getInfo(seq->sound->playback_handle).length * FPS);
 		seq->len -= seq->anim_startofs;
 		seq->len -= seq->anim_endofs;
@@ -617,7 +617,9 @@ void reload_sequence_new_file(Scene *scene, Sequence * seq, int lock_range)
 			seq->len = 0;
 		}
 		seq->strip->len = seq->len;
-	} else if (seq->type == SEQ_SCENE) {
+		break;
+	case SEQ_SCENE:
+	{
 		/* 'seq->scenenr' should be replaced with something more reliable */
 		Scene * sce = G.main->scene.first;
 		int nr = 1;
@@ -643,6 +645,8 @@ void reload_sequence_new_file(Scene *scene, Sequence * seq, int lock_range)
 			seq->len = 0;
 		}
 		seq->strip->len = seq->len;
+		break;
+	}
 	}
 
 	free_proxy_seq(seq);
@@ -804,7 +808,7 @@ static char *give_seqname_by_type(int type)
 	case SEQ_MULTICAM:   return "Multicam";
 	case SEQ_SPEED:      return "Speed";
 	default:
-		return 0;
+		return NULL;
 	}
 }
 
@@ -896,19 +900,24 @@ static void multibuf(ImBuf *ibuf, float fmul)
 static float give_stripelem_index(Sequence *seq, float cfra)
 {
 	float nr;
+	int sta = seq->start;
+	int end = seq->start+seq->len-1;
 
 	if(seq->len == 0) return -1;
+
 	if(seq->flag&SEQ_REVERSE_FRAMES) {	
 		/*reverse frame in this sequence */
-		if(cfra <= seq->start) nr= seq->len-1;
-		else if(cfra >= seq->start+seq->len-1) nr= 0;
-		else nr= (seq->start + seq->len - 1) - cfra;
+		if(cfra <= sta) nr= seq->len-1;
+		else if(cfra >= end) nr= 0;
+		else nr= end - cfra;
 	} else {
-		if(cfra <= seq->start) nr= 0;
-		else if(cfra >= seq->start+seq->len-1) nr= seq->len-1;
-		else nr= cfra-seq->start;
+		if(cfra <= sta) nr= 0;
+		else if(cfra >= end) nr= seq->len-1;
+		else nr= cfra - sta;
 	}
+	
 	if (seq->strobe < 1.0) seq->strobe = 1.0;
+	
 	if (seq->strobe > 1.0) {
 		nr -= fmod((double)nr, (double)seq->strobe);
 	}
@@ -920,14 +929,10 @@ StripElem *give_stripelem(Sequence *seq, int cfra)
 {
 	StripElem *se= seq->strip->stripdata;
 
-	if(seq->type == SEQ_MOVIE) {
-		/* use the first */
-	}
-	else {
+	if(seq->type != SEQ_MOVIE) { /* movie use the first */
 		int nr = (int) give_stripelem_index(seq, cfra);
 
-		if (nr == -1) return 0;
-		if (se == 0) return 0;
+		if (nr == -1 || se == 0) return 0;
 	
 		se += nr + seq->anim_startofs;
 	}
@@ -964,9 +969,7 @@ int evaluate_seq_frame(Scene *scene, int cfra)
 
 static int video_seq_is_rendered(Sequence * seq)
 {
-	return (seq
-		&& !(seq->flag & SEQ_MUTE)
-		&& seq->type != SEQ_SOUND);
+	return (seq && !(seq->flag & SEQ_MUTE) && seq->type != SEQ_SOUND);
 }
 
 static int get_shown_sequences(	ListBase * seqbasep, int cfra, int chanshown, Sequence ** seq_arr_out)
@@ -1028,13 +1031,11 @@ static int seq_proxy_get_fname(Scene *UNUSED(scene), Sequence * seq, int cfra, c
 		return FALSE;
 	}
 
-	if ((seq->flag & SEQ_USE_PROXY_CUSTOM_DIR)
-	    || (seq->flag & SEQ_USE_PROXY_CUSTOM_FILE)) {
+	if (seq->flag & (SEQ_USE_PROXY_CUSTOM_DIR|SEQ_USE_PROXY_CUSTOM_FILE)) {
 		strcpy(dir, seq->strip->proxy->dir);
 	} else {
-		if (seq->type == SEQ_IMAGE || seq->type == SEQ_MOVIE) {
-			snprintf(dir, FILE_MAXDIR, "%s/BL_proxy", 
-				 seq->strip->dir);
+		if (ELEM(seq->type, SEQ_IMAGE, SEQ_MOVIE)) {
+			snprintf(dir, FILE_MAXDIR, "%s/BL_proxy", seq->strip->dir);
 		} else {
 			return FALSE;
 		}
@@ -1049,30 +1050,25 @@ static int seq_proxy_get_fname(Scene *UNUSED(scene), Sequence * seq, int cfra, c
 
 	/* generate a separate proxy directory for each preview size */
 
-	if (seq->type == SEQ_IMAGE) {
-		StripElem * se = give_stripelem(seq, cfra);
-		snprintf(name, PROXY_MAXFILE, "%s/images/%d/%s_proxy",
-			 dir, render_size, se->name);
+	switch(seq->type) {
+	case SEQ_IMAGE:
+		snprintf(name, PROXY_MAXFILE, "%s/images/%d/%s_proxy", dir,
+					render_size, give_stripelem(seq, cfra)->name);
 		frameno = 1;
-	} else if (seq->type == SEQ_MOVIE) {
-		frameno = (int) give_stripelem_index(seq, cfra) 
-			+ seq->anim_startofs;
-
+		break;
+	case SEQ_MOVIE:
+		frameno = (int) give_stripelem_index(seq, cfra) + seq->anim_startofs;
 		snprintf(name, PROXY_MAXFILE, "%s/%s/%d/####", dir,
-			 seq->strip->stripdata->name,
-			 render_size);
-	} else {
-		frameno = (int) give_stripelem_index(seq, cfra) 
-			+ seq->anim_startofs;
-
-		snprintf(name, PROXY_MAXFILE, "%s/proxy_misc/%d/####", dir,
-			 render_size);
+					seq->strip->stripdata->name, render_size);
+		break;
+	default:
+		frameno = (int) give_stripelem_index(seq, cfra) + seq->anim_startofs;
+		snprintf(name, PROXY_MAXFILE, "%s/proxy_misc/%d/####", dir, render_size);
 	}
 
 	BLI_path_abs(name, G.main->name);
 	BLI_path_frame(name, frameno, 0);
 
-
 	strcat(name, ".jpg");
 
 	return TRUE;
@@ -1092,24 +1088,22 @@ static struct ImBuf * seq_proxy_fetch(Scene *scene, Sequence * seq, int cfra, in
 	}
 
 	if (seq->flag & SEQ_USE_PROXY_CUSTOM_FILE) {
-		int frameno = (int) give_stripelem_index(seq, cfra) 
-			+ seq->anim_startofs;
-		if (!seq->strip->proxy->anim) {
-			if (!seq_proxy_get_fname(
-				    scene, seq, cfra, name, render_size)) {
+		int frameno = (int) give_stripelem_index(seq, cfra) + seq->anim_startofs;
+		if (seq->strip->proxy->anim == NULL) {
+			if (seq_proxy_get_fname(scene, seq, cfra, name, render_size)==0) {
 				return 0;
 			}
  
 			seq->strip->proxy->anim = openanim(name, IB_rect);
 		}
-		if (!seq->strip->proxy->anim) {
+		if (seq->strip->proxy->anim==NULL) {
 			return 0;
 		}
  
 		return IMB_anim_absolute(seq->strip->proxy->anim, frameno);
 	}
  
-	if (!seq_proxy_get_fname(scene, seq, cfra, name, render_size)) {
+	if (seq_proxy_get_fname(scene, seq, cfra, name, render_size)==0) {
 		return 0;
 	}
 
@@ -1378,8 +1372,7 @@ static void color_balance_byte_float(Sequence * seq, ImBuf* ibuf, float mul)
 	cb = calc_cb(seq->strip->color_balance);
 
 	for (c = 0; c < 3; c++) {
-		make_cb_table_float(cb.lift[c], cb.gain[c], cb.gamma[c],
-				    cb_tab[c], mul);
+		make_cb_table_float(cb.lift[c], cb.gain[c], cb.gamma[c], cb_tab[c], mul);
 	}
 
 	for (i = 0; i < 256; i++) {
@@ -1446,13 +1439,8 @@ int input_have_to_preprocess(
 {
 	float mul;
 
-	if ((seq->flag & SEQ_FILTERY) || 
-	    (seq->flag & SEQ_USE_CROP) ||
-	    (seq->flag & SEQ_USE_TRANSFORM) ||
-	    (seq->flag & SEQ_FLIPX) ||
-	    (seq->flag & SEQ_FLIPY) ||
-	    (seq->flag & SEQ_USE_COLOR_BALANCE) ||
-	    (seq->flag & SEQ_MAKE_PREMUL)) {
+	if (seq->flag & (SEQ_FILTERY|SEQ_USE_CROP|SEQ_USE_TRANSFORM|SEQ_FLIPX|
+						SEQ_FLIPY|SEQ_USE_COLOR_BALANCE|SEQ_MAKE_PREMUL)) {
 		return TRUE;
 	}
 
@@ -1474,8 +1462,7 @@ int input_have_to_preprocess(
 }
 
 static ImBuf * input_preprocess(
-	Scene *scene, Sequence *seq, float UNUSED(cfra), int seqrectx, int seqrecty,
-	ImBuf * ibuf)
+	Scene *scene, Sequence *seq, float UNUSED(cfra), int seqrectx, int seqrecty, ImBuf * ibuf)
 {
 	float mul;
 
@@ -1486,7 +1473,7 @@ static ImBuf * input_preprocess(
 		IMB_filtery(ibuf);
 	}
 
-	if(seq->flag & SEQ_USE_CROP || seq->flag & SEQ_USE_TRANSFORM) {
+	if(seq->flag & (SEQ_USE_CROP|SEQ_USE_TRANSFORM)) {
 		StripCrop c;
 		StripTransform t;
 		int sx,sy,dx,dy;
@@ -1511,23 +1498,13 @@ static ImBuf * input_preprocess(
 			dy = scene->r.ysch;
 		}
 
-		if (c.top + c.bottom >= ibuf->y ||
-			c.left + c.right >= ibuf->x ||
-			t.xofs >= dx || t.yofs >= dy) {
+		if (c.top + c.bottom >= ibuf->y || c.left + c.right >= ibuf->x ||
+				t.xofs >= dx || t.yofs >= dy) {
 			make_black_ibuf(ibuf);
 		} else {
-			ImBuf * i;
+			ImBuf * i = IMB_allocImBuf(dx, dy,32, ibuf->rect_float ? IB_rectfloat : IB_rect);
 
-			if (ibuf->rect_float) {
-				i = IMB_allocImBuf(dx, dy,32, IB_rectfloat);
-			} else {
-				i = IMB_allocImBuf(dx, dy,32, IB_rect);
-			}
-
-			IMB_rectcpy(i, ibuf, 
-				    t.xofs, t.yofs, 
-				    c.left, c.bottom, 
-				    sx, sy);
+			IMB_rectcpy(i, ibuf, t.xofs, t.yofs, c.left, c.bottom, sx, sy);
 			
 			IMB_freeImBuf(ibuf);
 
@@ -1602,11 +1579,9 @@ static ImBuf * input_preprocess(
 
 	if(ibuf->x != seqrectx || ibuf->y != seqrecty ) {
 		if(scene->r.mode & R_OSA) {
-			IMB_scaleImBuf(ibuf, 
-				       (short)seqrectx, (short)seqrecty);
+			IMB_scaleImBuf(ibuf, (short)seqrectx, (short)seqrecty);
 		} else {
-			IMB_scalefastImBuf(ibuf, 
-					   (short)seqrectx, (short)seqrecty);
+			IMB_scalefastImBuf(ibuf, (short)seqrectx, (short)seqrecty);
 		}
 	}
 	return ibuf;
@@ -1656,34 +1631,32 @@ static void copy_to_ibuf_still(Sequence * seq, float nr,
    strip rendering functions
    ********************************************************************** */
 
-static ImBuf* seq_render_strip_stack(
-	Main *bmain, Scene *scene,
-	ListBase *seqbasep, float cfra, int chanshown, int render_size,
-	int seqrectx, int seqrecty);
+static ImBuf* seq_render_strip_stack( Main *bmain, Scene *scene, ListBase *seqbasep,
+		float cfra, int chanshown, int render_size, int seqrectx, int seqrecty);
 
 static ImBuf * seq_render_strip(Main *bmain, Scene *scene, Sequence * seq, float cfra,
-				int render_size, 
-				int seqrectx, int seqrecty);
+		int render_size, int seqrectx, int seqrecty);
 
 
-static ImBuf* seq_render_effect_strip_impl(
-	Main *bmain, Scene *scene, float cfra, Sequence *seq, int render_size,
-	int seqrectx, int seqrecty)
+static ImBuf* seq_render_effect_strip_impl(Main *bmain, Scene *scene, float cfra,
+		Sequence *seq, int render_size, int seqrectx, int seqrecty)
 {
 	float fac, facf;
 	int early_out;
 	int i;
-	int must_preprocess = FALSE;
-
 	struct SeqEffectHandle sh = get_sequence_effect(seq);
 	FCurve *fcu= NULL;
 	ImBuf * ibuf[3];
-	ImBuf * out = 0;
+	Sequence *input[3];
+	ImBuf * out = NULL;
+
+	ibuf[0] = ibuf[1] = ibuf[2] = NULL;
 
-	ibuf[0] = ibuf[1] = ibuf[2] = 0;
+	input[0] = seq->seq1; input[1] = seq->seq2; input[2] = seq->seq3;
 
 	if (!sh.execute) { /* effect not supported in this version... */
-		goto finish;
+		out = IMB_allocImBuf((short)seqrectx, (short)seqrecty, 32, IB_rect);
+		return out;
 	}
 
 	/* Override render size here, effects need to get the actual
@@ -1695,12 +1668,14 @@ static ImBuf* seq_render_effect_strip_impl(
 	 */
 	render_size = 100*seqrectx/scene->r.xsch;
 
-	if ((seq->flag & SEQ_USE_EFFECT_DEFAULT_FADE) != 0) {
+	if (seq->flag & SEQ_USE_EFFECT_DEFAULT_FADE) {
 		sh.get_default_fac(seq, cfra, &fac, &facf);
-		if( scene->r.mode & R_FIELDS ); else facf= fac;
-	} else {
-		fcu = id_data_find_fcurve(&scene->id, seq, &RNA_Sequence, 
-					  "effect_fader", 0);
+		
+		if ((scene->r.mode & R_FIELDS)==0)
+			facf= fac;
+	}
+	else {
+		fcu = id_data_find_fcurve(&scene->id, seq, &RNA_Sequence, "effect_fader", 0);
 		if (fcu) {
 			fac = facf = evaluate_fcurve(fcu, cfra);
 			if( scene->r.mode & R_FIELDS ) {
@@ -1713,88 +1688,58 @@ static ImBuf* seq_render_effect_strip_impl(
 
 	early_out = sh.early_out(seq, fac, facf);
 
-	if (early_out == -1) { /* no input needed */
+	switch (early_out) {
+	case EARLY_NO_INPUT:
 		out = sh.execute(bmain, scene, seq, cfra, fac, facf, 
-				 seqrectx, seqrecty, render_size,
-				 0, 0, 0);
-		goto finish;
-	}
-
-
-	must_preprocess = input_have_to_preprocess(
-		scene, seq, cfra, seqrectx, seqrecty);
+				 seqrectx, seqrecty, render_size, NULL, NULL, NULL);
+	case EARLY_DO_EFFECT:
+		for(i=0; i<3; i++) {
+			if(input[i])
+				ibuf[i] = seq_render_strip(bmain, scene, input[i], cfra,
+							render_size, seqrectx, seqrecty);
+		}
 
-	switch (early_out) {
-	case 0:
+		if (ibuf[0] && ibuf[1]) {
+			out = sh.execute(bmain, scene, seq, cfra, fac, facf, seqrectx, seqrecty, 
+					 render_size, ibuf[0], ibuf[1], ibuf[2]);
+		}
 		break;
-	case 1:
-		if (seq->seq1) {
-			ibuf[0] = seq_render_strip(bmain, scene, seq->seq1, cfra,
-						   render_size, 
-						   seqrectx, seqrecty);
+	case EARLY_USE_INPUT_1:
+		if (input[0]) {
+			ibuf[0] = seq_render_strip(bmain, scene, input[0], cfra,
+						   render_size, seqrectx, seqrecty);
 		}
 		if (ibuf[0]) {
-			if (must_preprocess) {
+			if (input_have_to_preprocess(scene, seq, cfra, seqrectx, seqrecty)) {
 				out = IMB_dupImBuf(ibuf[0]);
 			} else {
 				out = ibuf[0];
 				IMB_refImBuf(out);
 			}
 		}
-		goto finish;
-	case 2:
-		if (seq->seq2) {
-			ibuf[1] = seq_render_strip(bmain, scene, seq->seq2, cfra,
-						   render_size, 
-						   seqrectx, seqrecty);
+		break;
+	case EARLY_USE_INPUT_2:
+		if (input[1]) {
+			ibuf[1] = seq_render_strip(bmain, scene, input[1], cfra,
+						   render_size, seqrectx, seqrecty);
 		}
 		if (ibuf[1]) {
-			if (must_preprocess) {
+			if (input_have_to_preprocess(scene, seq, cfra, seqrectx, seqrecty)) {
 				out = IMB_dupImBuf(ibuf[1]);
 			} else {
 				out = ibuf[1];
 				IMB_refImBuf(out);
 			}
 		}
-		goto finish;
-	default:
-		goto finish;
-	}
-
-	if (seq->seq1) {
-		ibuf[0] = seq_render_strip(bmain, scene, seq->seq1, cfra,
-					   render_size, 
-					   seqrectx, seqrecty);
-	} 
-
-	if (seq->seq2) {
-		ibuf[1] = seq_render_strip(bmain, scene, seq->seq2, cfra,
-					   render_size, 
-					   seqrectx, seqrecty);
-	}
-
-	if (seq->seq3) {
-		ibuf[2] = seq_render_strip(bmain, scene, seq->seq3, cfra,
-					   render_size, 
-					   seqrectx, seqrecty);
-	}
-
-	if (!ibuf[0] || !ibuf[1]) {
-		goto finish;
+		break;
 	}
 
-	out = sh.execute(bmain, scene, seq, cfra, fac, facf, seqrectx, seqrecty, 
-			 render_size,
-			 ibuf[0], ibuf[1], ibuf[2]);
-
-finish:
 	for (i = 0; i < 3; i++) {
 		IMB_freeImBuf(ibuf[i]);
 	}
 
-	if (!out) {
-		out = IMB_allocImBuf(
-			(short)seqrectx, (short)seqrecty, 32, IB_rect);
+	if (out == NULL) {
+		out = IMB_allocImBuf((short)seqrectx, (short)seqrecty, 32, IB_rect);
 	}
 
 	return out;
@@ -1938,185 +1883,143 @@ static ImBuf * seq_render_scene_strip_impl(
 }
 
 static ImBuf * seq_render_strip(Main *bmain, Scene *scene, Sequence * seq, float cfra,
-				int render_size, 
-				int seqrectx, int seqrecty)
+				int render_size, int seqrectx, int seqrecty)
 {
+	ImBuf * ibuf = NULL;
 	char name[FILE_MAXDIR+FILE_MAXFILE];
-	int use_preprocess = input_have_to_preprocess(
-		scene, seq, cfra, seqrectx, seqrecty);
-	ImBuf * ibuf = seq_stripelem_cache_get(
-		seq, seqrectx, seqrecty, cfra, SEQ_STRIPELEM_IBUF);
+	int use_preprocess = input_have_to_preprocess(scene, seq, cfra, seqrectx, seqrecty);
 	float nr = give_stripelem_index(seq, cfra);
+	/* all effects are handled similarly with the exception of speed effect */
+	int type = (seq->type & SEQ_EFFECT && seq->type != SEQ_SPEED) ? SEQ_EFFECT : seq->type;
 
+	ibuf = seq_stripelem_cache_get(seq, seqrectx, seqrecty, cfra, SEQ_STRIPELEM_IBUF);
+
+	if (ibuf == NULL)
+		ibuf = copy_from_ibuf_still(seq,nr,seqrectx,seqrecty);
+	
 	/* currently, we cache preprocessed images */
-	if (ibuf) {
+	if (ibuf)
 		use_preprocess = FALSE;
-	}
 
-	if(seq->type == SEQ_META) {
-		ImBuf * meta_ibuf = 0;
+	if (ibuf == NULL)
+		ibuf = seq_proxy_fetch(scene, seq, cfra, render_size);
 
-		if (ibuf == 0) {
-			ibuf = seq_proxy_fetch(scene, seq, cfra, render_size);
-		}
+	if(ibuf == NULL) switch(type) {
+		case SEQ_META:
+		{
+			ImBuf * meta_ibuf = NULL;
 
-		if(!ibuf && seq->seqbase.first) {
-			meta_ibuf = seq_render_strip_stack(
-				bmain, scene,
-				&seq->seqbase, seq->start + nr, 0,
-				render_size, seqrectx, seqrecty);
-		}
+			if(seq->seqbase.first)
+				meta_ibuf = seq_render_strip_stack(bmain, scene, &seq->seqbase,
+							seq->start + nr, 0, render_size, seqrectx, seqrecty);
 
-		if(!ibuf && meta_ibuf) {
-			ibuf = meta_ibuf;
-			if(ibuf && use_preprocess) {
-				struct ImBuf * i = IMB_dupImBuf(ibuf);
+			if(meta_ibuf) {
+				ibuf = meta_ibuf;
+				if(ibuf && use_preprocess) {
+					struct ImBuf * i = IMB_dupImBuf(ibuf);
 
-				IMB_freeImBuf(ibuf);
+					IMB_freeImBuf(ibuf);
 
-				ibuf = i;
+					ibuf = i;
+				}
 			}
+			break;
 		}
-	} else if(seq->type == SEQ_SPEED) {
-		ImBuf * child_ibuf = 0;
-
-		if (ibuf == 0) {
-			ibuf = seq_proxy_fetch(scene, seq, cfra, render_size);
-		}
+		case SEQ_SPEED:
+		{
+			ImBuf * child_ibuf = NULL;
 
-		if (ibuf == 0) {
 			float f_cfra;
-			SpeedControlVars * s 
-				= (SpeedControlVars *)seq->effectdata;
+			SpeedControlVars * s = (SpeedControlVars *)seq->effectdata;
 
 			sequence_effect_speed_rebuild_map(scene, seq, 0);
 
 			/* weeek! */
 			f_cfra = seq->start + s->frameMap[(int) nr];
 
-			child_ibuf = seq_render_strip(bmain, scene, seq->seq1, f_cfra,
-						      render_size, 
-						      seqrectx, seqrecty);
-		}
+			child_ibuf = seq_render_strip(bmain, scene, seq->seq1, f_cfra, render_size,
+										seqrectx, seqrecty);
 
-		if (!ibuf && child_ibuf) {
-			ibuf = child_ibuf;
-			if(ibuf && use_preprocess) {
-				struct ImBuf * i = IMB_dupImBuf(ibuf);
+			if (child_ibuf) {
+				ibuf = child_ibuf;
+				if(ibuf && use_preprocess) {
+					struct ImBuf * i = IMB_dupImBuf(ibuf);
 
-				IMB_freeImBuf(ibuf);
+					IMB_freeImBuf(ibuf);
 
-				ibuf = i;
+					ibuf = i;
+				}
 			}
+			break;
 		}
-	} else if(seq->type & SEQ_EFFECT) {
-		/* should the effect be recalculated? */
-		
-		if (ibuf == 0) {
-			ibuf = seq_proxy_fetch(scene, seq, cfra, render_size);
-		}
-
-		if(ibuf == 0) {		
-			ibuf = seq_render_effect_strip_impl(
-				bmain, scene, cfra, seq, render_size, 
-				seqrectx, seqrecty);
-		}
-	} else if(seq->type == SEQ_IMAGE) {
-		StripElem * s_elem = give_stripelem(seq, cfra);
-
-		if(ibuf == 0 && s_elem) {
-			BLI_join_dirfile(name, seq->strip->dir, s_elem->name);
-			BLI_path_abs(name, G.main->name);
-
-			ibuf = seq_proxy_fetch(scene, seq, cfra, render_size);
+		case SEQ_EFFECT:
+		{	
+			ibuf = seq_render_effect_strip_impl(bmain, scene, cfra, seq, render_size,
+										seqrectx, seqrecty);
+			break;
 		}
+		case SEQ_IMAGE:
+		{
+			StripElem * s_elem = give_stripelem(seq, cfra);
 
-		if (ibuf == 0) {
-			ibuf = copy_from_ibuf_still(seq,nr,seqrectx,seqrecty);
-		}
+			if (s_elem) {
+				BLI_join_dirfile(name, seq->strip->dir, s_elem->name);
+				BLI_path_abs(name, G.main->name);
+			}
 
-		if (ibuf == 0 && s_elem && 
-		    (ibuf = IMB_loadiffname(name, IB_rect))) {
-			/* we don't need both (speed reasons)! */
-			if (ibuf->rect_float && ibuf->rect)
-				imb_freerectImBuf(ibuf);
+			if (s_elem && (ibuf = IMB_loadiffname(name, IB_rect))) {
+				/* we don't need both (speed reasons)! */
+				if (ibuf->rect_float && ibuf->rect)
+					imb_freerectImBuf(ibuf);
 
-			/* all sequencer color is done in SRGB space, linear gives odd crossfades */
-			if(ibuf->profile == IB_PROFILE_LINEAR_RGB)
-				IMB_convert_profile(ibuf, IB_PROFILE_NONE);
+				/* all sequencer color is done in SRGB space, linear gives odd crossfades */
+				if(ibuf->profile == IB_PROFILE_LINEAR_RGB)
+					IMB_convert_profile(ibuf, IB_PROFILE_NONE);
 
-			copy_to_ibuf_still(seq, nr, ibuf);
-		}
-	} else if(seq->type == SEQ_MOVIE) {
-		if(ibuf == 0) {
-			ibuf = seq_proxy_fetch(scene, seq, cfra, render_size);
-			
-		}
-		
-		if (ibuf == 0) {
-			ibuf = copy_from_ibuf_still(seq, nr,seqrectx,seqrecty);
+				copy_to_ibuf_still(seq, nr, ibuf);
+			}
+			break;
 		}
-
-		if (ibuf == 0) {
+		case SEQ_MOVIE:
+		{
 			if(seq->anim==0) {
-				BLI_join_dirfile(name, 
-						 seq->strip->dir, 
-						 seq->strip->stripdata->name);
+				BLI_join_dirfile(name, seq->strip->dir, seq->strip->stripdata->name);
 				BLI_path_abs(name, G.main->name);
 					
-				seq->anim = openanim(
-					name, IB_rect | 
-					((seq->flag & SEQ_FILTERY) 
-					 ? IB_animdeinterlace : 0));
+				seq->anim = openanim(name, IB_rect |
+									((seq->flag & SEQ_FILTERY) ? IB_animdeinterlace : 0));
 			}
+
 			if(seq->anim) {
-				IMB_anim_set_preseek(seq->anim, 
-						     seq->anim_preseek);
-				ibuf = IMB_anim_absolute(seq->anim, 
-							 nr 
-							 + seq->anim_startofs);
+				IMB_anim_set_preseek(seq->anim, seq->anim_preseek);
+				ibuf = IMB_anim_absolute(seq->anim, nr + seq->anim_startofs);
 				/* we don't need both (speed reasons)! */
-				if (ibuf && ibuf->rect_float 
-				    && ibuf->rect) {
+				if (ibuf && ibuf->rect_float && ibuf->rect)
 					imb_freerectImBuf(ibuf);
-				}
 
 			}
 			copy_to_ibuf_still(seq, nr, ibuf);
+			break;
 		}
-			
-	} else if(seq->type == SEQ_SCENE) {	// scene can be NULL after deletions
-		if (ibuf == 0) {
-			ibuf = seq_proxy_fetch(scene, seq, cfra, render_size);
-		}
-		if (ibuf == 0) {
-			ibuf = copy_from_ibuf_still(seq, nr,seqrectx,seqrecty);
-		}
-		
-		if (ibuf == 0) {
-			ibuf = seq_render_scene_strip_impl(bmain, scene, seq, nr,
-							   seqrectx, seqrecty);
+		case SEQ_SCENE:
+		{	// scene can be NULL after deletions
+			ibuf = seq_render_scene_strip_impl(bmain, scene, seq, nr, seqrectx, seqrecty);
 
 			copy_to_ibuf_still(seq, nr, ibuf);
+			break;
 		}
 	}
 
-	if (!ibuf) {
-	        ibuf = IMB_allocImBuf(
-			(short)seqrectx, (short)seqrecty, 32, IB_rect);
-	}
+	if (ibuf == NULL)
+		ibuf = IMB_allocImBuf((short)seqrectx, (short)seqrecty, 32, IB_rect);
 
-	if (ibuf->x != seqrectx || ibuf->y != seqrecty) {
+	if (ibuf->x != seqrectx || ibuf->y != seqrecty)
 		use_preprocess = TRUE;
-	}
 
-	if (use_preprocess) {
-		ibuf = input_preprocess(scene, seq, cfra, seqrectx,
-					seqrecty, ibuf);
-	}
+	if (use_preprocess)
+		ibuf = input_preprocess(scene, seq, cfra, seqrectx, seqrecty, ibuf);
 
-	seq_stripelem_cache_put(
-		seq, seqrectx, seqrecty, cfra, SEQ_STRIPELEM_IBUF, ibuf);
+	seq_stripelem_cache_put(seq, seqrectx, seqrecty, cfra, SEQ_STRIPELEM_IBUF, ibuf);
 
 	return ibuf;
 }
@@ -2132,9 +2035,7 @@ static int seq_must_swap_input_in_blend_mode(Sequence * seq)
 	/* bad hack, to fix crazy input ordering of 
 	   those two effects */
 
-	if (seq->blend_mode == SEQ_ALPHAOVER ||
-		seq->blend_mode == SEQ_ALPHAUNDER ||
-		seq->blend_mode == SEQ_OVERDROP) {
+	if (ELEM3(seq->blend_mode, SEQ_ALPHAOVER, SEQ_ALPHAUNDER, SEQ_OVERDROP)) {
 		swap_input = TRUE;
 	}
 	
@@ -2147,15 +2048,15 @@ static int seq_get_early_out_for_blend_mode(Sequence * seq)
 	float facf = seq->blend_opacity / 100.0;
 	int early_out = sh.early_out(seq, facf, facf);
 	
-	if (early_out < 1) {
+	if (ELEM(early_out, EARLY_DO_EFFECT, EARLY_NO_INPUT)) {
 		return early_out;
 	}
 
 	if (seq_must_swap_input_in_blend_mode(seq)) {
-		if (early_out == 2) {
-			return 1;
-		} else if (early_out == 1) {
-			return 2;
+		if (early_out == EARLY_USE_INPUT_2) {
+			return EARLY_USE_INPUT_1;
+		} else if (early_out == EARLY_USE_INPUT_1) {
+			return EARLY_USE_INPUT_2;
 		}
 	}
 	return early_out;
@@ -2168,13 +2069,12 @@ static ImBuf* seq_render_strip_stack(
 	Sequence* seq_arr[MAXSEQ+1];
 	int count;
 	int i;
-	ImBuf* out = 0;
+	ImBuf* out = NULL;
 
-	count = get_shown_sequences(seqbasep, cfra, chanshown, 
-				    (Sequence **)&seq_arr);
+	count = get_shown_sequences(seqbasep, cfra, chanshown, (Sequence **)&seq_arr);
 
-	if (!count) {
-		return 0;
+	if (count == 0) {
+		return NULL;
 	}
 
 #if 0 /* commentind since this breaks keyframing, since it resets the value on draw */
@@ -2185,22 +2085,15 @@ static ImBuf* seq_render_strip_stack(
 	}
 #endif
 
-	out = seq_stripelem_cache_get(
-		seq_arr[count - 1], 
-		seqrectx, seqrecty, cfra, SEQ_STRIPELEM_IBUF_COMP);
+	out = seq_stripelem_cache_get(seq_arr[count - 1], seqrectx, seqrecty, cfra, SEQ_STRIPELEM_IBUF_COMP);
 
 	if (out) {
 		return out;
 	}
 	
 	if(count == 1) {
-		out = seq_render_strip(bmain, scene, seq_arr[0],
-					cfra, render_size,
-					seqrectx, seqrecty);
-		seq_stripelem_cache_put(
-			seq_arr[0], 
-			seqrectx, seqrecty, cfra, 
-			SEQ_STRIPELEM_IBUF_COMP, out);
+		out = seq_render_strip(bmain, scene, seq_arr[0], cfra, render_size, seqrectx, seqrecty);
+		seq_stripelem_cache_put(seq_arr[0], seqrectx, seqrecty, cfra, SEQ_STRIPELEM_IBUF_COMP, out);
 
 		return out;
 	}
@@ -2208,43 +2101,33 @@ static ImBuf* seq_render_strip_stack(
 
 	for (i = count - 1; i >= 0; i--) {
 		int early_out;
-		Sequence * seq = seq_arr[i];
+		Sequence *seq = seq_arr[i];
 
-		out = seq_stripelem_cache_get(
-			seq, 
-			seqrectx, seqrecty, cfra, SEQ_STRIPELEM_IBUF_COMP);
+		out = seq_stripelem_cache_get(seq, seqrectx, seqrecty, cfra, SEQ_STRIPELEM_IBUF_COMP);
 
 		if (out) {
 			break;
 		}
 		if (seq->blend_mode == SEQ_BLEND_REPLACE) {
-			out = seq_render_strip(bmain, scene, seq, cfra,
-					       render_size,
-					       seqrectx, seqrecty);
+			out = seq_render_strip(bmain, scene, seq, cfra, render_size, seqrectx, seqrecty);
 			break;
 		}
 
 		early_out = seq_get_early_out_for_blend_mode(seq);
 
 		switch (early_out) {
-		case -1:
-		case 2:
-			out = seq_render_strip(bmain, scene, seq, cfra,
-					       render_size,
-					       seqrectx, seqrecty);
+		case EARLY_NO_INPUT:
+		case EARLY_USE_INPUT_2:
+			out = seq_render_strip(bmain, scene, seq, cfra, render_size, seqrectx, seqrecty);
 			break;
-		case 1:
+		case EARLY_USE_INPUT_1:
 			if (i == 0) {
-				out = IMB_allocImBuf(
-					(short)seqrectx, (short)seqrecty, 
-					32, IB_rect);
+				out = IMB_allocImBuf((short)seqrectx, (short)seqrecty, 32, IB_rect);
 			}
 			break;
-		case 0:
+		case EARLY_DO_EFFECT:
 			if (i == 0) {
-				out = seq_render_strip(bmain, scene, seq, cfra,
-						       render_size,
-						       seqrectx, seqrecty);
+				out = seq_render_strip(bmain, scene, seq, cfra, render_size, seqrectx, seqrecty);
 			}
 
 			break;
@@ -2254,9 +2137,7 @@ static ImBuf* seq_render_strip_stack(
 		}
 	}
 
-	seq_stripelem_cache_put(
-		seq_arr[i], seqrectx, seqrecty, cfra, 
-		SEQ_STRIPELEM_IBUF_COMP, out);
+	seq_stripelem_cache_put(seq_arr[i], seqrectx, seqrecty, cfra, SEQ_STRIPELEM_IBUF_COMP, out);
 
 
 	i++;
@@ -2264,37 +2145,32 @@ static ImBuf* seq_render_strip_stack(
 	for (; i < count; i++) {
 		Sequence * seq = seq_arr[i];
 
-		if (seq_get_early_out_for_blend_mode(seq) == 0) {
+		if (seq_get_early_out_for_blend_mode(seq) == EARLY_DO_EFFECT) {
 			struct SeqEffectHandle sh = get_sequence_blend(seq);
 			ImBuf * ibuf1 = out;
-			ImBuf * ibuf2 = seq_render_strip(bmain, scene, seq, cfra,
-							 render_size,
-							 seqrectx, seqrecty);
+			ImBuf * ibuf2 = seq_render_strip(bmain, scene, seq, cfra, render_size,
+												seqrectx, seqrecty);
 
 			float facf = seq->blend_opacity / 100.0;
-			int swap_input 
-				= seq_must_swap_input_in_blend_mode(seq);
+			int swap_input = seq_must_swap_input_in_blend_mode(seq);
 
 			int x= seqrectx;
 			int y= seqrecty;
 
 			if (swap_input) {
-				out = sh.execute(bmain, scene, seq, cfra, 
-						 facf, facf, x, y, render_size,
-						 ibuf2, ibuf1, 0);
+				out = sh.execute(bmain, scene, seq, cfra, facf, facf, x, y,
+									render_size, ibuf2, ibuf1, 0);
 			} else {
-				out = sh.execute(bmain, scene, seq, cfra, 
-						 facf, facf, x, y, render_size,
-						 ibuf1, ibuf2, 0);
+				out = sh.execute(bmain, scene, seq, cfra, facf, facf, x, y,
+									render_size, ibuf1, ibuf2, 0);
 			}
 		
 			IMB_freeImBuf(ibuf1);
 			IMB_freeImBuf(ibuf2);
 		}
 
-		seq_stripelem_cache_put(
-			seq_arr[i], seqrectx, seqrecty, cfra, 
-			SEQ_STRIPELEM_IBUF_COMP, out);
+		seq_stripelem_cache_put(seq_arr[i], seqrectx, seqrecty, cfra,
+									SEQ_STRIPELEM_IBUF_COMP, out);
 	}
 
 	return out;
@@ -2321,8 +2197,8 @@ ImBuf *give_ibuf_seq(Main *bmain, Scene *scene, int rectx, int recty, int cfra,
 		seqbasep= ed->seqbasep;
 	}
 
-	return seq_render_strip_stack(
-		bmain, scene, seqbasep, cfra, chanshown, render_size, rectx, recty);
+	return seq_render_strip_stack(bmain, scene, seqbasep, cfra, chanshown,
+									render_size, rectx, recty);
 }
 
 ImBuf *give_ibuf_seqbase(Main *bmain, Scene *scene, int rectx, int recty, int cfra, int chanshown, int render_size, ListBase *seqbasep)
@@ -2543,8 +2419,7 @@ static void seq_stop_threads()
 }
 #endif
 
-void give_ibuf_prefetch_request(int rectx, int recty, int cfra, int chanshown,
-				int render_size)
+void give_ibuf_prefetch_request(int rectx, int recty, int cfra, int chanshown, int render_size)
 {
 	PrefetchQueueElem *e;
 	if (seq_thread_shutdown) {
@@ -2730,8 +2605,7 @@ void free_imbuf_seq(Scene *scene, ListBase * seqbase, int check_mem_usage,
 			}
 		}
 		if(seq->type==SEQ_META) {
-			free_imbuf_seq(scene, &seq->seqbase, FALSE,
-				       keep_file_handles);
+			free_imbuf_seq(scene, &seq->seqbase, FALSE, keep_file_handles);
 		}
 		if(seq->type==SEQ_SCENE) {
 			/* FIXME: recurs downwards, 
@@ -2855,11 +2729,7 @@ void seq_tx_set_final_right(Sequence *seq, int val)
    since they work a bit differently to normal image seq's (during transform) */
 int seq_single_check(Sequence *seq)
 {
-	if ( seq->len==1 && (seq->type == SEQ_IMAGE || seq->type == SEQ_COLOR
-			     || seq->type == SEQ_MULTICAM))
-		return 1;
-	else
-		return 0;
+	return (seq->len==1 && ELEM3(seq->type, SEQ_IMAGE, SEQ_COLOR, SEQ_MULTICAM));
 }
 
 /* check if the selected seq's reference unselected seq's */
@@ -2881,17 +2751,20 @@ int seqbase_isolated_sel_check(ListBase *seqbase)
 
 	/* test relationships */
 	for(seq= seqbase->first; seq; seq= seq->next) {
+		if((seq->type & SEQ_EFFECT)==0)
+			continue;
+
 		if(seq->flag & SELECT) {
-			if(seq->type & SEQ_EFFECT) {
-				if(seq->seq1 && (seq->seq1->flag & SELECT)==0) return FALSE;
-				if(seq->seq2 && (seq->seq2->flag & SELECT)==0) return FALSE;
-				if(seq->seq3 && (seq->seq3->flag & SELECT)==0) return FALSE;
-			}
+			if( (seq->seq1 && (seq->seq1->flag & SELECT)==0) ||
+				(seq->seq2 && (seq->seq2->flag & SELECT)==0) ||
+				(seq->seq3 && (seq->seq3->flag & SELECT)==0) )
+				return FALSE;
 		}
-		else if(seq->type & SEQ_EFFECT) {
-			if(seq->seq1 && (seq->seq1->flag & SELECT)) return FALSE;
-			if(seq->seq2 && (seq->seq2->flag & SELECT)) return FALSE;
-			if(seq->seq3 && (seq->seq3->flag & SELECT)) return FALSE;
+		else {
+			if( (seq->seq1 && (seq->seq1->flag & SELECT)) ||
+				(seq->seq2 && (seq->seq2->flag & SELECT)) ||
+				(seq->seq3 && (seq->seq3->flag & SELECT)) )
+				return FALSE;
 		}
 	}
 
@@ -2968,12 +2841,8 @@ int seq_tx_test(Sequence * seq)
 
 static int seq_overlap(Sequence *seq1, Sequence *seq2)
 {
-	if(seq1 != seq2)
-		if(seq1->machine==seq2->machine)
-			if(((seq1->enddisp <= seq2->startdisp) || (seq1->startdisp >= seq2->enddisp))==0)
-				return 1;
-
-	return 0;
+	return (seq1 != seq2 && seq1->machine == seq2->machine &&
+			((seq1->enddisp <= seq2->startdisp) || (seq1->startdisp >= seq2->enddisp))==0);
 }
 
 int seq_test_overlap(ListBase * seqbasep, Sequence *test)
@@ -3140,7 +3009,7 @@ static void seq_update_muting_recursive(Scene *scene, ListBase *seqbasep, Sequen
 
 			seq_update_muting_recursive(scene, &seq->seqbase, metaseq, seqmute);
 		}
-		else if((seq->type == SEQ_SOUND) || (seq->type == SEQ_SCENE)) {
+		else if(ELEM(seq->type, SEQ_SOUND, SEQ_SCENE)) {
 			if(seq->scene_sound) {
 				sound_mute_scene_sound(scene, seq->scene_sound, seqmute);
 			}