style cleanup: comment blocks
[blender.git] / source / blender / blenkernel / intern / seqeffects.c
index 8015e53e4c96647e068da2d92ab273eaa3048f93..33519483843b9890e08859486f23880e6e5593e9 100644 (file)
 
 #include "BKE_fcurve.h"
 #include "BKE_main.h"
-#include "BKE_plugin_types.h"
 #include "BKE_sequencer.h"
 #include "BKE_texture.h"
-#include "BKE_utildefines.h"
 
 #include "IMB_imbuf_types.h"
 #include "IMB_imbuf.h"
+#include "IMB_colormanagement.h"
 
 #include "RNA_access.h"
 
-/* **** XXX **** */
-static void error(const char *UNUSED(error), ...) {}
+static void slice_get_byte_buffers(const SeqRenderData *context, const ImBuf *ibuf1, const ImBuf *ibuf2,
+                                   const ImBuf *ibuf3, const ImBuf *out, int start_line, unsigned char **rect1,
+                                   unsigned char **rect2, unsigned char **rect3, unsigned char **rect_out)
+{
+       int offset = 4 * start_line * context->rectx;
+
+       *rect1 = (unsigned char*) ibuf1->rect + offset;
+       *rect_out = (unsigned char*) out->rect + offset;
+
+       if (ibuf2)
+               *rect2 = (unsigned char*) ibuf2->rect + offset;
+
+       if (ibuf3)
+               *rect3 = (unsigned char*) ibuf3->rect + offset;
+}
+
+static void slice_get_float_buffers(const SeqRenderData *context, const ImBuf *ibuf1, const ImBuf *ibuf2,
+                                    const ImBuf *ibuf3, const ImBuf *out, int start_line,
+                                    float **rect1, float **rect2, float **rect3, float **rect_out)
+{
+       int offset = 4 * start_line * context->rectx;
+
+       *rect1 = ibuf1->rect_float + offset;
+       *rect_out = out->rect_float + offset;
+
+       if (ibuf2)
+               *rect2 = ibuf2->rect_float + offset;
 
-#define INT    96
-#define FLO    128
+       if (ibuf3)
+               *rect3 = ibuf3->rect_float + offset;
+}
 
-/* **** XXX **** */
+/*********************** Glow effect *************************/
 
-/* Glow effect */
 enum {
-       GlowR=0,
-       GlowG=1,
-       GlowB=2,
-       GlowA=3
+       GlowR = 0,
+       GlowG = 1,
+       GlowB = 2,
+       GlowA = 3
 };
 
-static struct ImBuf * prepare_effect_imbufs(
-       SeqRenderData context,
-       struct ImBuf *ibuf1, struct ImBuf *ibuf2,
-       struct ImBuf *ibuf3)
+static ImBuf *prepare_effect_imbufs(SeqRenderData context, ImBuf *ibuf1, ImBuf *ibuf2, ImBuf *ibuf3)
 {
-       struct ImBuf * out;
+       ImBuf *out;
        int x = context.rectx;
        int y = context.recty;
 
        if (!ibuf1 && !ibuf2 && !ibuf3) {
                /* hmmm, global float option ? */
-               out = IMB_allocImBuf((short)x, (short)y, 32, IB_rect);
+               out = IMB_allocImBuf(x, y, 32, IB_rect);
        }
        else if ((ibuf1 && ibuf1->rect_float) ||
-                  (ibuf2 && ibuf2->rect_float) || 
-                  (ibuf3 && ibuf3->rect_float)) {
+                (ibuf2 && ibuf2->rect_float) ||
+                (ibuf3 && ibuf3->rect_float))
+       {
                /* if any inputs are rectfloat, output is float too */
 
-               out = IMB_allocImBuf((short)x, (short)y, 32, IB_rectfloat);
+               out = IMB_allocImBuf(x, y, 32, IB_rectfloat);
        }
        else {
-               out = IMB_allocImBuf((short)x, (short)y, 32, IB_rect);
+               out = IMB_allocImBuf(x, y, 32, IB_rect);
        }
        
        if (ibuf1 && !ibuf1->rect_float && out->rect_float) {
-               IMB_float_from_rect_simple(ibuf1);
+               BKE_sequencer_imbuf_to_sequencer_space(context.scene, ibuf1, TRUE);
        }
        if (ibuf2 && !ibuf2->rect_float && out->rect_float) {
-               IMB_float_from_rect_simple(ibuf2);
+               BKE_sequencer_imbuf_to_sequencer_space(context.scene, ibuf2, TRUE);
        }
        if (ibuf3 && !ibuf3->rect_float && out->rect_float) {
-               IMB_float_from_rect_simple(ibuf3);
+               BKE_sequencer_imbuf_to_sequencer_space(context.scene, ibuf3, TRUE);
        }
        
        if (ibuf1 && !ibuf1->rect && !out->rect_float) {
@@ -116,414 +138,129 @@ static struct ImBuf * prepare_effect_imbufs(
        if (ibuf3 && !ibuf3->rect && !out->rect_float) {
                IMB_rect_from_float(ibuf3);
        }
-                       
-       return out;
-}
-
-/* **********************************************************************
- * PLUGINS
- * ********************************************************************** */
-
-static void open_plugin_seq(PluginSeq *pis, const char *seqname)
-{
-       int (*version)(void);
-       void* (*alloc_private)(void);
-       char *cp;
-
-       /* to be sure: (is tested for) */
-       pis->doit= NULL;
-       pis->pname= NULL;
-       pis->varstr= NULL;
-       pis->cfra= NULL;
-       pis->version= 0;
-       pis->instance_private_data = NULL;
-
-       /* clear the error list */
-       BLI_dynlib_get_error_as_string(NULL);
-
-       /* if (pis->handle) BLI_dynlib_close(pis->handle); */
-       /* pis->handle= 0; */
-
-       /* open the needed object */
-       pis->handle= BLI_dynlib_open(pis->name);
-       if (test_dlerr(pis->name, pis->name)) return;
-
-       if (pis->handle != NULL) {
-               /* find the address of the version function */
-               version= (int (*)(void))BLI_dynlib_find_symbol(pis->handle, "plugin_seq_getversion");
-               if (test_dlerr(pis->name, "plugin_seq_getversion")) return;
-
-               if (version != NULL) {
-                       pis->version= version();
-                       if (pis->version >= 2 && pis->version <= 6) {
-                               int (*info_func)(PluginInfo *);
-                               PluginInfo *info= (PluginInfo*) MEM_mallocN(sizeof(PluginInfo), "plugin_info");
-
-                               info_func= (int (*)(PluginInfo *))BLI_dynlib_find_symbol(pis->handle, "plugin_getinfo");
-
-                               if (info_func == NULL) error("No info func");
-                               else {
-                                       info_func(info);
-
-                                       pis->pname= info->name;
-                                       pis->vars= info->nvars;
-                                       pis->cfra= info->cfra;
-
-                                       pis->varstr= info->varstr;
-
-                                       pis->doit= (void(*)(void))info->seq_doit;
-                                       if (info->init)
-                                               info->init();
-                               }
-                               MEM_freeN(info);
-
-                               cp= BLI_dynlib_find_symbol(pis->handle, "seqname");
-                               if (cp) BLI_strncpy(cp, seqname, SEQ_NAME_MAXSTR);
-                       }
-                       else {
-                               printf ("Plugin returned unrecognized version number\n");
-                               return;
-                       }
-               }
-               alloc_private = (void* (*)(void))BLI_dynlib_find_symbol(
-                       pis->handle, "plugin_seq_alloc_private_data");
-               if (alloc_private) {
-                       pis->instance_private_data = alloc_private();
-               }
-               
-               pis->current_private_data = (void**) 
-                       BLI_dynlib_find_symbol(
-                               pis->handle, "plugin_private_data");
-       }
-}
-
-static PluginSeq *add_plugin_seq(const char *str, const char *seqname)
-{
-       PluginSeq *pis;
-       VarStruct *varstr;
-       int a;
-
-       pis= MEM_callocN(sizeof(PluginSeq), "PluginSeq");
-
-       BLI_strncpy(pis->name, str, FILE_MAX);
-       open_plugin_seq(pis, seqname);
-
-       if (pis->doit==NULL) {
-               if (pis->handle==NULL) error("no plugin: %s", str);
-               else error("in plugin: %s", str);
-               MEM_freeN(pis);
-               return NULL;
-       }
-
-       /* default values */
-       varstr= pis->varstr;
-       for (a=0; a<pis->vars; a++, varstr++) {
-               if ( (varstr->type & FLO)==FLO)
-                       pis->data[a]= varstr->def;
-               else if ( (varstr->type & INT)==INT)
-                       *((int *)(pis->data+a))= (int) varstr->def;
-       }
-
-       return pis;
-}
-
-static void free_plugin_seq(PluginSeq *pis)
-{
-       if (pis==NULL) return;
-
-       /* no BLI_dynlib_close: same plugin can be opened multiple times with 1 handle */
-
-       if (pis->instance_private_data) {
-               void (*free_private)(void *);
-
-               free_private = (void (*)(void *))BLI_dynlib_find_symbol(
-                       pis->handle, "plugin_seq_free_private_data");
-               if (free_private) {
-                       free_private(pis->instance_private_data);
-               }
-       }
-
-       MEM_freeN(pis);
-}
-
-static void init_plugin(Sequence * seq, const char * fname)
-{
-       seq->plugin= (PluginSeq *)add_plugin_seq(fname, seq->name+2);
-}
-
-/* 
- * FIXME: should query plugin! Could be generator, that needs zero inputs...
- */
-static int num_inputs_plugin(void)
-{
-       return 1;
-}
-
-static void load_plugin(Sequence * seq)
-{
-       if (seq) {
-               open_plugin_seq(seq->plugin, seq->name+2);
-       }
-}
-
-static void copy_plugin(Sequence * dst, Sequence * src)
-{
-       if (src->plugin) {
-               dst->plugin= MEM_dupallocN(src->plugin);
-               open_plugin_seq(dst->plugin, dst->name+2);
-       }
-}
-
-static ImBuf * IMB_cast_away_list(ImBuf * i)
-{
-       if (!i) {
-               return NULL;
-       }
-       return (ImBuf*) (((void**) i) + 2);
-}
-
-static struct ImBuf * do_plugin_effect(
-       SeqRenderData context, Sequence *seq, float cfra,
-       float facf0, float facf1,
-       struct ImBuf *ibuf1, struct ImBuf *ibuf2, 
-       struct ImBuf *ibuf3)
-{
-       char *cp;
-       int float_rendering;
-       int use_temp_bufs = 0; /* Are needed since blur.c (and maybe some other
-                               * old plugins) do very bad stuff
-                               * with imbuf-internals */
-
-       struct ImBuf * out = prepare_effect_imbufs(context,ibuf1, ibuf2, ibuf3);
-       int x = context.rectx;
-       int y = context.recty;
-
-       if (seq->plugin && seq->plugin->doit) {
-               
-               if (seq->plugin->cfra) 
-                       *(seq->plugin->cfra)= cfra;
-               
-               cp = BLI_dynlib_find_symbol(
-                       seq->plugin->handle, "seqname");
-
-               /* XXX: it's crappy to limit copying buffer by it's lemgth,
-                *      but assuming plugin stuff is using correct buffer size
-                *      it should be fine */
-               if (cp) strncpy(cp, seq->name+2, sizeof(seq->name)-2);
 
-               if (seq->plugin->current_private_data) {
-                       *seq->plugin->current_private_data 
-                               = seq->plugin->instance_private_data;
-               }
-
-               float_rendering = (out->rect_float != NULL);
-
-               if (seq->plugin->version<=3 && float_rendering) {
-                       use_temp_bufs = 1;
-
-                       if (ibuf1) {
-                               ibuf1 = IMB_dupImBuf(ibuf1);
-                               IMB_rect_from_float(ibuf1);
-                               imb_freerectfloatImBuf(ibuf1);
-                               ibuf1->flags &= ~IB_rectfloat;
-                       }
-                       if (ibuf2) {
-                               ibuf2 = IMB_dupImBuf(ibuf2);
-                               IMB_rect_from_float(ibuf2);
-                               imb_freerectfloatImBuf(ibuf2);
-                               ibuf2->flags &= ~IB_rectfloat;
-                       } 
-                       if (ibuf3) {
-                               ibuf3 = IMB_dupImBuf(ibuf3);
-                               IMB_rect_from_float(ibuf3);
-                               imb_freerectfloatImBuf(ibuf3);
-                               ibuf3->flags &= ~IB_rectfloat;
-                       } 
-                       if (!out->rect) imb_addrectImBuf(out);
-                       imb_freerectfloatImBuf(out);
-                       out->flags &= ~IB_rectfloat;
-               }
-
-               if (seq->plugin->version<=2) {
-                       if (ibuf1) IMB_convert_rgba_to_abgr(ibuf1);
-                       if (ibuf2) IMB_convert_rgba_to_abgr(ibuf2);
-                       if (ibuf3) IMB_convert_rgba_to_abgr(ibuf3);
-               }
-
-               if (seq->plugin->version<=4) {
-                       ((SeqDoit)seq->plugin->doit)(
-                               seq->plugin->data, facf0, facf1, x, y,
-                               IMB_cast_away_list(ibuf1), 
-                               IMB_cast_away_list(ibuf2), 
-                               IMB_cast_away_list(out), 
-                               IMB_cast_away_list(ibuf3));
-               }
-               else {
-                       ((SeqDoit)seq->plugin->doit)(
-                               seq->plugin->data, facf0, facf1, x, y,
-                               ibuf1, ibuf2, out, ibuf3);
-               }
-
-               if (seq->plugin->version<=2) {
-                       if (!use_temp_bufs) {
-                               if (ibuf1) IMB_convert_rgba_to_abgr(ibuf1);
-                               if (ibuf2) IMB_convert_rgba_to_abgr(ibuf2);
-                               if (ibuf3) IMB_convert_rgba_to_abgr(ibuf3);
-                       }
-                       IMB_convert_rgba_to_abgr(out);
-               }
-               if (seq->plugin->version<=3 && float_rendering) {
-                       IMB_float_from_rect_simple(out);
-               }
-
-               if (use_temp_bufs) {
-                       if (ibuf1) IMB_freeImBuf(ibuf1);
-                       if (ibuf2) IMB_freeImBuf(ibuf2);
-                       if (ibuf3) IMB_freeImBuf(ibuf3);
-               }
-       }
        return out;
 }
 
-static int do_plugin_early_out(struct Sequence *UNUSED(seq),
-                                  float UNUSED(facf0), float UNUSED(facf1))
-{
-       return 0;
-}
-
-static void free_plugin(struct Sequence * seq)
-{
-       free_plugin_seq(seq->plugin);
-       seq->plugin = NULL;
-}
-
-/* **********************************************************************
- * ALPHA OVER
- * ********************************************************************** */
+/*********************** Alpha Over *************************/
 
-static void init_alpha_over_or_under(Sequence * seq)
+static void init_alpha_over_or_under(Sequence *seq)
 {
-       Sequence * seq1 = seq->seq1;
-       Sequence * seq2 = seq->seq2;
+       Sequence *seq1 = seq->seq1;
+       Sequence *seq2 = seq->seq2;
 
-       seq->seq2= seq1;
-       seq->seq1= seq2;
+       seq->seq2 = seq1;
+       seq->seq1 = seq2;
 }
 
-static void do_alphaover_effect_byte(float facf0, float facf1, int x, int y, 
-                                        char * rect1, char *rect2, char *out)
+static void do_alphaover_effect_byte(float facf0, float facf1, int x, int y,  char *rect1, char *rect2, char *out)
 {
        int fac2, mfac, fac, fac4;
        int xo, tempc;
        char *rt1, *rt2, *rt;
 
-       xo= x;
-       rt1= (char *)rect1;
-       rt2= (char *)rect2;
-       rt= (char *)out;
+       xo = x;
+       rt1 = (char *) rect1;
+       rt2 = (char *) rect2;
+       rt = (char *) out;
 
-       fac2= (int)(256.0f*facf0);
-       fac4= (int)(256.0f*facf1);
+       fac2 = (int) (256.0f * facf0);
+       fac4 = (int) (256.0f * facf1);
 
        while (y--) {
-
-               x= xo;
+               x = xo;
                while (x--) {
 
                        /* rt = rt1 over rt2  (alpha from rt1) */
 
-                       fac= fac2;
-                       mfac= 256 - ( (fac2*rt1[3])>>8 );
+                       fac = fac2;
+                       mfac = 256 - ( (fac2 * rt1[3]) >> 8);
 
-                       if (fac==0) *( (unsigned int *)rt) = *( (unsigned int *)rt2);
-                       else if (mfac==0) *( (unsigned int *)rt) = *( (unsigned int *)rt1);
+                       if (fac == 0) *( (unsigned int *) rt) = *( (unsigned int *) rt2);
+                       else if (mfac == 0) *( (unsigned int *) rt) = *( (unsigned int *) rt1);
                        else {
-                               tempc= ( fac*rt1[0] + mfac*rt2[0])>>8;
-                               if (tempc>255) rt[0]= 255; else rt[0]= tempc;
-                               tempc= ( fac*rt1[1] + mfac*rt2[1])>>8;
-                               if (tempc>255) rt[1]= 255; else rt[1]= tempc;
-                               tempc= ( fac*rt1[2] + mfac*rt2[2])>>8;
-                               if (tempc>255) rt[2]= 255; else rt[2]= tempc;
-                               tempc= ( fac*rt1[3] + mfac*rt2[3])>>8;
-                               if (tempc>255) rt[3]= 255; else rt[3]= tempc;
-                       }
-                       rt1+= 4; rt2+= 4; rt+= 4;
+                               tempc = (fac * rt1[0] + mfac * rt2[0]) >> 8;
+                               if (tempc > 255) rt[0] = 255; else rt[0] = tempc;
+                               tempc = (fac * rt1[1] + mfac * rt2[1]) >> 8;
+                               if (tempc > 255) rt[1] = 255; else rt[1] = tempc;
+                               tempc = (fac * rt1[2] + mfac * rt2[2]) >> 8;
+                               if (tempc > 255) rt[2] = 255; else rt[2] = tempc;
+                               tempc = (fac * rt1[3] + mfac * rt2[3]) >> 8;
+                               if (tempc > 255) rt[3] = 255; else rt[3] = tempc;
+                       }
+                       rt1 += 4; rt2 += 4; rt += 4;
                }
 
-               if (y==0) break;
+               if (y == 0) break;
                y--;
 
-               x= xo;
+               x = xo;
                while (x--) {
+                       fac = fac4;
+                       mfac = 256 - ( (fac4 * rt1[3]) >> 8);
 
-                       fac= fac4;
-                       mfac= 256 - ( (fac4*rt1[3])>>8 );
-
-                       if (fac==0) *( (unsigned int *)rt) = *( (unsigned int *)rt2);
-                       else if (mfac==0) *( (unsigned int *)rt) = *( (unsigned int *)rt1);
+                       if (fac == 0) *( (unsigned int *) rt) = *( (unsigned int *) rt2);
+                       else if (mfac == 0) *( (unsigned int *) rt) = *( (unsigned int *) rt1);
                        else {
-                               tempc= ( fac*rt1[0] + mfac*rt2[0])>>8;
-                               if (tempc>255) rt[0]= 255; else rt[0]= tempc;
-                               tempc= ( fac*rt1[1] + mfac*rt2[1])>>8;
-                               if (tempc>255) rt[1]= 255; else rt[1]= tempc;
-                               tempc= ( fac*rt1[2] + mfac*rt2[2])>>8;
-                               if (tempc>255) rt[2]= 255; else rt[2]= tempc;
-                               tempc= ( fac*rt1[3] + mfac*rt2[3])>>8;
-                               if (tempc>255) rt[3]= 255; else rt[3]= tempc;
-                       }
-                       rt1+= 4; rt2+= 4; rt+= 4;
+                               tempc = (fac * rt1[0] + mfac * rt2[0]) >> 8;
+                               if (tempc > 255) rt[0] = 255; else rt[0] = tempc;
+                               tempc = (fac * rt1[1] + mfac * rt2[1]) >> 8;
+                               if (tempc > 255) rt[1] = 255; else rt[1] = tempc;
+                               tempc = (fac * rt1[2] + mfac * rt2[2]) >> 8;
+                               if (tempc > 255) rt[2] = 255; else rt[2] = tempc;
+                               tempc = (fac * rt1[3] + mfac * rt2[3]) >> 8;
+                               if (tempc > 255) rt[3] = 255; else rt[3] = tempc;
+                       }
+                       rt1 += 4; rt2 += 4; rt += 4;
                }
        }
 }
 
-static void do_alphaover_effect_float(float facf0, float facf1, int x, int y, 
-                                         float * rect1, float *rect2, float *out)
+static void do_alphaover_effect_float(float facf0, float facf1, int x, int y,  float *rect1, float *rect2, float *out)
 {
        float fac2, mfac, fac, fac4;
        int xo;
        float *rt1, *rt2, *rt;
 
-       xo= x;
-       rt1= rect1;
-       rt2= rect2;
-       rt= out;
+       xo = x;
+       rt1 = rect1;
+       rt2 = rect2;
+       rt = out;
 
-       fac2= facf0;
-       fac4= facf1;
+       fac2 = facf0;
+       fac4 = facf1;
 
        while (y--) {
-
-               x= xo;
+               x = xo;
                while (x--) {
-
                        /* rt = rt1 over rt2  (alpha from rt1) */
 
-                       fac= fac2;
-                       mfac= 1.0f - (fac2 * rt1[3]);
+                       fac = fac2;
+                       mfac = 1.0f - (fac2 * rt1[3]);
 
                        if (fac <= 0.0f) {
                                memcpy(rt, rt2, 4 * sizeof(float));
                        }
-                       else if (mfac <=0) {
+                       else if (mfac <= 0) {
                                memcpy(rt, rt1, 4 * sizeof(float));
                        }
                        else {
-                               rt[0] = fac*rt1[0] + mfac*rt2[0];
-                               rt[1] = fac*rt1[1] + mfac*rt2[1];
-                               rt[2] = fac*rt1[2] + mfac*rt2[2];
-                               rt[3] = fac*rt1[3] + mfac*rt2[3];
+                               rt[0] = fac * rt1[0] + mfac * rt2[0];
+                               rt[1] = fac * rt1[1] + mfac * rt2[1];
+                               rt[2] = fac * rt1[2] + mfac * rt2[2];
+                               rt[3] = fac * rt1[3] + mfac * rt2[3];
                        }
-                       rt1+= 4; rt2+= 4; rt+= 4;
+                       rt1 += 4; rt2 += 4; rt += 4;
                }
 
-               if (y==0) break;
+               if (y == 0)
+                       break;
                y--;
 
-               x= xo;
+               x = xo;
                while (x--) {
-
-                       fac= fac4;
-                       mfac= 1.0f - (fac4*rt1[3]);
+                       fac = fac4;
+                       mfac = 1.0f - (fac4 * rt1[3]);
 
                        if (fac <= 0.0f) {
                                memcpy(rt, rt2, 4 * sizeof(float));
@@ -532,140 +269,125 @@ static void do_alphaover_effect_float(float facf0, float facf1, int x, int y,
                                memcpy(rt, rt1, 4 * sizeof(float));
                        }
                        else {
-                               rt[0] = fac*rt1[0] + mfac*rt2[0];
-                               rt[1] = fac*rt1[1] + mfac*rt2[1];
-                               rt[2] = fac*rt1[2] + mfac*rt2[2];
-                               rt[3] = fac*rt1[3] + mfac*rt2[3];
+                               rt[0] = fac * rt1[0] + mfac * rt2[0];
+                               rt[1] = fac * rt1[1] + mfac * rt2[1];
+                               rt[2] = fac * rt1[2] + mfac * rt2[2];
+                               rt[3] = fac * rt1[3] + mfac * rt2[3];
                        }
-                       rt1+= 4; rt2+= 4; rt+= 4;
+                       rt1 += 4; rt2 += 4; rt += 4;
                }
        }
 }
 
-static struct ImBuf * do_alphaover_effect(
-       SeqRenderData context, Sequence *UNUSED(seq), float UNUSED(cfra),
-       float facf0, float facf1, 
-       struct ImBuf *ibuf1, struct ImBuf *ibuf2, 
-       struct ImBuf *ibuf3)
+static void do_alphaover_effect(SeqRenderData context, Sequence *UNUSED(seq), float UNUSED(cfra), float facf0,
+                                float facf1, ImBuf *ibuf1, ImBuf *ibuf2, ImBuf *UNUSED(ibuf3),
+                                int start_line, int total_lines, ImBuf *out)
 {
-       struct ImBuf * out = prepare_effect_imbufs(context,ibuf1, ibuf2, ibuf3);
-
        if (out->rect_float) {
-               do_alphaover_effect_float(
-                       facf0, facf1, context.rectx, context.recty,
-                       ibuf1->rect_float, ibuf2->rect_float,
-                       out->rect_float);
+               float *rect1 = NULL, *rect2 = NULL, *rect_out = NULL;
+
+               slice_get_float_buffers(&context, ibuf1, ibuf2, NULL, out, start_line, &rect1, &rect2, NULL, &rect_out);
+
+               do_alphaover_effect_float(facf0, facf1, context.rectx, total_lines, rect1, rect2, rect_out);
        }
        else {
-               do_alphaover_effect_byte(
-                       facf0, facf1, context.rectx, context.recty,
-                       (char*) ibuf1->rect, (char*) ibuf2->rect,
-                       (char*) out->rect);
+               unsigned char *rect1 = NULL, *rect2 = NULL, *rect_out = NULL;
+
+               slice_get_byte_buffers(&context, ibuf1, ibuf2, NULL, out, start_line, &rect1, &rect2, NULL, &rect_out);
+
+               do_alphaover_effect_byte(facf0, facf1, context.rectx, total_lines, (char *) rect1, (char *) rect2, (char *) rect_out);
        }
-       return out;
 }
 
+/*********************** Alpha Under *************************/
 
-/* **********************************************************************
- * ALPHA UNDER
- * ********************************************************************** */
-
-static void do_alphaunder_effect_byte(
-       float facf0, float facf1, int x, int y, char *rect1, 
-       char *rect2, char *out)
+static void do_alphaunder_effect_byte(float facf0, float facf1, int x, int y, char *rect1, char *rect2, char *out)
 {
        int fac2, mfac, fac, fac4;
        int xo;
        char *rt1, *rt2, *rt;
 
-       xo= x;
-       rt1= rect1;
-       rt2= rect2;
-       rt= out;
+       xo = x;
+       rt1 = rect1;
+       rt2 = rect2;
+       rt = out;
 
-       fac2= (int)(256.0f*facf0);
-       fac4= (int)(256.0f*facf1);
+       fac2 = (int)(256.0f * facf0);
+       fac4 = (int)(256.0f * facf1);
 
        while (y--) {
-
-               x= xo;
+               x = xo;
                while (x--) {
-
                        /* rt = rt1 under rt2  (alpha from rt2) */
 
-                       /* this complex optimalisation is because the
+                       /* this complex optimization is because the
                         * 'skybuf' can be crossed in
                         */
-                       if (rt2[3]==0 && fac2==256) *( (unsigned int *)rt) = *( (unsigned int *)rt1);
-                       else if (rt2[3]==255) *( (unsigned int *)rt) = *( (unsigned int *)rt2);
+                       if (rt2[3] == 0 && fac2 == 256) *( (unsigned int *) rt) = *( (unsigned int *) rt1);
+                       else if (rt2[3] == 255) *( (unsigned int *) rt) = *( (unsigned int *) rt2);
                        else {
-                               mfac= rt2[3];
-                               fac= (fac2*(256-mfac))>>8;
+                               mfac = rt2[3];
+                               fac = (fac2 * (256 - mfac)) >> 8;
 
-                               if (fac==0) *( (unsigned int *)rt) = *( (unsigned int *)rt2);
+                               if (fac == 0) *( (unsigned int *) rt) = *( (unsigned int *) rt2);
                                else {
-                                       rt[0]= ( fac*rt1[0] + mfac*rt2[0])>>8;
-                                       rt[1]= ( fac*rt1[1] + mfac*rt2[1])>>8;
-                                       rt[2]= ( fac*rt1[2] + mfac*rt2[2])>>8;
-                                       rt[3]= ( fac*rt1[3] + mfac*rt2[3])>>8;
+                                       rt[0] = (fac * rt1[0] + mfac * rt2[0]) >> 8;
+                                       rt[1] = (fac * rt1[1] + mfac * rt2[1]) >> 8;
+                                       rt[2] = (fac * rt1[2] + mfac * rt2[2]) >> 8;
+                                       rt[3] = (fac * rt1[3] + mfac * rt2[3]) >> 8;
                                }
                        }
-                       rt1+= 4; rt2+= 4; rt+= 4;
+                       rt1 += 4; rt2 += 4; rt += 4;
                }
 
-               if (y==0) break;
+               if (y == 0)
+                       break;
                y--;
 
-               x= xo;
+               x = xo;
                while (x--) {
-
-                       if (rt2[3]==0 && fac4==256) *( (unsigned int *)rt) = *( (unsigned int *)rt1);
-                       else if (rt2[3]==255) *( (unsigned int *)rt) = *( (unsigned int *)rt2);
+                       if (rt2[3] == 0 && fac4 == 256) *( (unsigned int *) rt) = *( (unsigned int *) rt1);
+                       else if (rt2[3] == 255) *( (unsigned int *) rt) = *( (unsigned int *) rt2);
                        else {
-                               mfac= rt2[3];
-                               fac= (fac4*(256-mfac))>>8;
+                               mfac = rt2[3];
+                               fac = (fac4 * (256 - mfac)) >> 8;
 
-                               if (fac==0) *( (unsigned int *)rt) = *( (unsigned int *)rt2);
+                               if (fac == 0) *( (unsigned int *)rt) = *( (unsigned int *)rt2);
                                else {
-                                       rt[0]= ( fac*rt1[0] + mfac*rt2[0])>>8;
-                                       rt[1]= ( fac*rt1[1] + mfac*rt2[1])>>8;
-                                       rt[2]= ( fac*rt1[2] + mfac*rt2[2])>>8;
-                                       rt[3]= ( fac*rt1[3] + mfac*rt2[3])>>8;
+                                       rt[0] = (fac * rt1[0] + mfac * rt2[0]) >> 8;
+                                       rt[1] = (fac * rt1[1] + mfac * rt2[1]) >> 8;
+                                       rt[2] = (fac * rt1[2] + mfac * rt2[2]) >> 8;
+                                       rt[3] = (fac * rt1[3] + mfac * rt2[3]) >> 8;
                                }
                        }
-                       rt1+= 4; rt2+= 4; rt+= 4;
+                       rt1 += 4; rt2 += 4; rt += 4;
                }
        }
 }
 
-
-static void do_alphaunder_effect_float(float facf0, float facf1, int x, int y, 
-                                          float *rect1, float *rect2, 
-                                          float *out)
+static void do_alphaunder_effect_float(float facf0, float facf1, int x, int y,  float *rect1, float *rect2, float *out)
 {
        float fac2, mfac, fac, fac4;
        int xo;
        float *rt1, *rt2, *rt;
 
-       xo= x;
-       rt1= rect1;
-       rt2= rect2;
-       rt= out;
+       xo = x;
+       rt1 = rect1;
+       rt2 = rect2;
+       rt = out;
 
-       fac2= facf0;
-       fac4= facf1;
+       fac2 = facf0;
+       fac4 = facf1;
 
        while (y--) {
-
-               x= xo;
+               x = xo;
                while (x--) {
-
                        /* rt = rt1 under rt2  (alpha from rt2) */
 
-                       /* this complex optimalisation is because the
+                       /* this complex optimization is because the
                         * 'skybuf' can be crossed in
                         */
-                       if ( rt2[3]<=0 && fac2 >= 1.0f) {
+                       if (rt2[3] <= 0 && fac2 >= 1.0f) {
                                memcpy(rt, rt1, 4 * sizeof(float));
                        }
                        else if (rt2[3] >= 1.0f) {
@@ -679,201 +401,177 @@ static void do_alphaunder_effect_float(float facf0, float facf1, int x, int y,
                                        memcpy(rt, rt2, 4 * sizeof(float));
                                }
                                else {
-                                       rt[0]= fac*rt1[0] + mfac*rt2[0];
-                                       rt[1]= fac*rt1[1] + mfac*rt2[1];
-                                       rt[2]= fac*rt1[2] + mfac*rt2[2];
-                                       rt[3]= fac*rt1[3] + mfac*rt2[3];
+                                       rt[0] = fac * rt1[0] + mfac * rt2[0];
+                                       rt[1] = fac * rt1[1] + mfac * rt2[1];
+                                       rt[2] = fac * rt1[2] + mfac * rt2[2];
+                                       rt[3] = fac * rt1[3] + mfac * rt2[3];
                                }
                        }
-                       rt1+= 4; rt2+= 4; rt+= 4;
+                       rt1 += 4; rt2 += 4; rt += 4;
                }
 
-               if (y==0) break;
+               if (y == 0)
+                       break;
                y--;
 
-               x= xo;
+               x = xo;
                while (x--) {
-
-                       if (rt2[3]<=0 && fac4 >= 1.0f) {
+                       if (rt2[3] <= 0 && fac4 >= 1.0f) {
                                memcpy(rt, rt1, 4 * sizeof(float));
                        }
-                       else if (rt2[3]>=1.0f) {
+                       else if (rt2[3] >= 1.0f) {
                                memcpy(rt, rt2, 4 * sizeof(float));
                        }
                        else {
-                               mfac= rt2[3];
-                               fac= fac4*(1.0f-mfac);
+                               mfac = rt2[3];
+                               fac = fac4 * (1.0f - mfac);
 
                                if (fac == 0) {
                                        memcpy(rt, rt2, 4 * sizeof(float));
                                }
                                else {
-                                       rt[0]= fac * rt1[0] + mfac * rt2[0];
-                                       rt[1]= fac * rt1[1] + mfac * rt2[1];
-                                       rt[2]= fac * rt1[2] + mfac * rt2[2];
-                                       rt[3]= fac * rt1[3] + mfac * rt2[3];
+                                       rt[0] = fac * rt1[0] + mfac * rt2[0];
+                                       rt[1] = fac * rt1[1] + mfac * rt2[1];
+                                       rt[2] = fac * rt1[2] + mfac * rt2[2];
+                                       rt[3] = fac * rt1[3] + mfac * rt2[3];
                                }
                        }
-                       rt1+= 4; rt2+= 4; rt+= 4;
+                       rt1 += 4; rt2 += 4; rt += 4;
                }
        }
 }
 
-static struct ImBuf* do_alphaunder_effect(
-       SeqRenderData context, Sequence *UNUSED(seq), float UNUSED(cfra),
-       float facf0, float facf1, 
-       struct ImBuf *ibuf1, struct ImBuf *ibuf2, 
-       struct ImBuf *ibuf3)
+static void do_alphaunder_effect(SeqRenderData context, Sequence *UNUSED(seq), float UNUSED(cfra),
+                                 float facf0, float facf1, ImBuf *ibuf1, ImBuf *ibuf2, ImBuf *UNUSED(ibuf3),
+                                 int start_line, int total_lines, ImBuf *out)
 {
-       struct ImBuf * out = prepare_effect_imbufs(
-               context, ibuf1, ibuf2, ibuf3);
-
        if (out->rect_float) {
-               do_alphaunder_effect_float(
-                       facf0, facf1, context.rectx, context.recty,
-                       ibuf1->rect_float, ibuf2->rect_float,
-                       out->rect_float);
+               float *rect1 = NULL, *rect2 = NULL, *rect_out = NULL;
+
+               slice_get_float_buffers(&context, ibuf1, ibuf2, NULL, out, start_line, &rect1, &rect2, NULL, &rect_out);
+
+               do_alphaunder_effect_float(facf0, facf1, context.rectx, total_lines, rect1, rect2, rect_out);
        }
        else {
-               do_alphaunder_effect_byte(
-                       facf0, facf1, context.rectx, context.recty,
-                       (char*) ibuf1->rect, (char*) ibuf2->rect,
-                       (char*) out->rect);
+               unsigned char *rect1 = NULL, *rect2 = NULL, *rect_out = NULL;
+
+               slice_get_byte_buffers(&context, ibuf1, ibuf2, NULL, out, start_line, &rect1, &rect2, NULL, &rect_out);
+
+               do_alphaunder_effect_byte(facf0, facf1, context.rectx, total_lines, (char *) rect1, (char *) rect2, (char *) rect_out);
        }
-       return out;
 }
 
+/*********************** Cross *************************/
 
-/* **********************************************************************
- * CROSS
- * ********************************************************************** */
-
-static void do_cross_effect_byte(float facf0, float facf1, int x, int y, 
-                         char *rect1, char *rect2, 
-                         char *out)
+static void do_cross_effect_byte(float facf0, float facf1, int x, int y, char *rect1, char *rect2, char *out)
 {
        int fac1, fac2, fac3, fac4;
        int xo;
        char *rt1, *rt2, *rt;
 
-       xo= x;
-       rt1= rect1;
-       rt2= rect2;
-       rt= out;
+       xo = x;
+       rt1 = rect1;
+       rt2 = rect2;
+       rt = out;
 
-       fac2= (int)(256.0f*facf0);
-       fac1= 256-fac2;
-       fac4= (int)(256.0f*facf1);
-       fac3= 256-fac4;
+       fac2 = (int) (256.0f * facf0);
+       fac1 = 256 - fac2;
+       fac4 = (int) (256.0f * facf1);
+       fac3 = 256 - fac4;
 
        while (y--) {
-
-               x= xo;
+               x = xo;
                while (x--) {
+                       rt[0] = (fac1 * rt1[0] + fac2 * rt2[0]) >> 8;
+                       rt[1] = (fac1 * rt1[1] + fac2 * rt2[1]) >> 8;
+                       rt[2] = (fac1 * rt1[2] + fac2 * rt2[2]) >> 8;
+                       rt[3] = (fac1 * rt1[3] + fac2 * rt2[3]) >> 8;
 
-                       rt[0]= (fac1*rt1[0] + fac2*rt2[0])>>8;
-                       rt[1]= (fac1*rt1[1] + fac2*rt2[1])>>8;
-                       rt[2]= (fac1*rt1[2] + fac2*rt2[2])>>8;
-                       rt[3]= (fac1*rt1[3] + fac2*rt2[3])>>8;
-
-                       rt1+= 4; rt2+= 4; rt+= 4;
+                       rt1 += 4; rt2 += 4; rt += 4;
                }
 
-               if (y==0) break;
+               if (y == 0)
+                       break;
                y--;
 
-               x= xo;
+               x = xo;
                while (x--) {
+                       rt[0] = (fac3 * rt1[0] + fac4 * rt2[0]) >> 8;
+                       rt[1] = (fac3 * rt1[1] + fac4 * rt2[1]) >> 8;
+                       rt[2] = (fac3 * rt1[2] + fac4 * rt2[2]) >> 8;
+                       rt[3] = (fac3 * rt1[3] + fac4 * rt2[3]) >> 8;
 
-                       rt[0]= (fac3*rt1[0] + fac4*rt2[0])>>8;
-                       rt[1]= (fac3*rt1[1] + fac4*rt2[1])>>8;
-                       rt[2]= (fac3*rt1[2] + fac4*rt2[2])>>8;
-                       rt[3]= (fac3*rt1[3] + fac4*rt2[3])>>8;
-
-                       rt1+= 4; rt2+= 4; rt+= 4;
+                       rt1 += 4; rt2 += 4; rt += 4;
                }
 
        }
 }
 
-static void do_cross_effect_float(float facf0, float facf1, int x, int y, 
-                          float *rect1, float *rect2, float *out)
+static void do_cross_effect_float(float facf0, float facf1, int x, int y, float *rect1, float *rect2, float *out)
 {
        float fac1, fac2, fac3, fac4;
        int xo;
        float *rt1, *rt2, *rt;
 
-       xo= x;
-       rt1= rect1;
-       rt2= rect2;
-       rt= out;
+       xo = x;
+       rt1 = rect1;
+       rt2 = rect2;
+       rt = out;
 
-       fac2= facf0;
-       fac1= 1.0f - fac2;
-       fac4= facf1;
-       fac3= 1.0f - fac4;
+       fac2 = facf0;
+       fac1 = 1.0f - fac2;
+       fac4 = facf1;
+       fac3 = 1.0f - fac4;
 
        while (y--) {
-
-               x= xo;
+               x = xo;
                while (x--) {
+                       rt[0] = fac1 * rt1[0] + fac2 * rt2[0];
+                       rt[1] = fac1 * rt1[1] + fac2 * rt2[1];
+                       rt[2] = fac1 * rt1[2] + fac2 * rt2[2];
+                       rt[3] = fac1 * rt1[3] + fac2 * rt2[3];
 
-                       rt[0]= fac1*rt1[0] + fac2*rt2[0];
-                       rt[1]= fac1*rt1[1] + fac2*rt2[1];
-                       rt[2]= fac1*rt1[2] + fac2*rt2[2];
-                       rt[3]= fac1*rt1[3] + fac2*rt2[3];
-
-                       rt1+= 4; rt2+= 4; rt+= 4;
+                       rt1 += 4; rt2 += 4; rt += 4;
                }
 
-               if (y==0) break;
+               if (y == 0)
+                       break;
                y--;
 
-               x= xo;
+               x = xo;
                while (x--) {
+                       rt[0] = fac3 * rt1[0] + fac4 * rt2[0];
+                       rt[1] = fac3 * rt1[1] + fac4 * rt2[1];
+                       rt[2] = fac3 * rt1[2] + fac4 * rt2[2];
+                       rt[3] = fac3 * rt1[3] + fac4 * rt2[3];
 
-                       rt[0]= fac3*rt1[0] + fac4*rt2[0];
-                       rt[1]= fac3*rt1[1] + fac4*rt2[1];
-                       rt[2]= fac3*rt1[2] + fac4*rt2[2];
-                       rt[3]= fac3*rt1[3] + fac4*rt2[3];
-
-                       rt1+= 4; rt2+= 4; rt+= 4;
+                       rt1 += 4; rt2 += 4; rt += 4;
                }
 
        }
 }
 
-/* careful: also used by speed effect! */
-
-static struct ImBuf* do_cross_effect(
-       SeqRenderData context, Sequence *UNUSED(seq), float UNUSED(cfra),
-       float facf0, float facf1, 
-       struct ImBuf *ibuf1, struct ImBuf *ibuf2, 
-       struct ImBuf *ibuf3)
+static void do_cross_effect(SeqRenderData context, Sequence *UNUSED(seq), float UNUSED(cfra),
+                            float facf0, float facf1, ImBuf *ibuf1, ImBuf *ibuf2, ImBuf *UNUSED(ibuf3),
+                            int start_line, int total_lines, ImBuf *out)
 {
-       struct ImBuf * out = prepare_effect_imbufs(
-               context, ibuf1, ibuf2, ibuf3);
-
        if (out->rect_float) {
-               do_cross_effect_float(
-                       facf0, facf1, context.rectx, context.recty,
-                       ibuf1->rect_float, ibuf2->rect_float,
-                       out->rect_float);
+               float *rect1 = NULL, *rect2 = NULL, *rect_out = NULL;
+
+               slice_get_float_buffers(&context, ibuf1, ibuf2, NULL, out, start_line, &rect1, &rect2, NULL, &rect_out);
+
+               do_cross_effect_float(facf0, facf1, context.rectx, total_lines, rect1, rect2, rect_out);
        }
        else {
-               do_cross_effect_byte(
-                       facf0, facf1, context.rectx, context.recty,
-                       (char*) ibuf1->rect, (char*) ibuf2->rect,
-                       (char*) out->rect);
+               unsigned char *rect1 = NULL, *rect2 = NULL, *rect_out = NULL;
+
+               slice_get_byte_buffers(&context, ibuf1, ibuf2, NULL, out, start_line, &rect1, &rect2, NULL, &rect_out);
+
+               do_cross_effect_byte(facf0, facf1, context.rectx, total_lines, (char *) rect1, (char *) rect2, (char *) rect_out);
        }
-       return out;
 }
 
-
-/* **********************************************************************
- * GAMMA CROSS
- * ********************************************************************** */
+/*********************** Gamma Cross *************************/
 
 /* copied code from initrender.c */
 static unsigned short gamtab[65536];
@@ -897,39 +595,36 @@ static void makeGammaTables(float gamma)
        /* we need two tables: one forward, one backward */
        int i;
 
-       valid_gamma        = gamma;
-       valid_inv_gamma    = 1.0f / gamma;
+       valid_gamma       = gamma;
+       valid_inv_gamma   = 1.0f / gamma;
        color_step        = 1.0f / RE_GAMMA_TABLE_SIZE;
        inv_color_step    = (float) RE_GAMMA_TABLE_SIZE; 
 
-       /* We could squeeze out the two range tables to gain some memory.        */     
+       /* We could squeeze out the two range tables to gain some memory */     
        for (i = 0; i < RE_GAMMA_TABLE_SIZE; i++) {
-               color_domain_table[i]   = i * color_step;
-               gamma_range_table[i]     = pow(color_domain_table[i],
-                                                                               valid_gamma);
-               inv_gamma_range_table[i] = pow(color_domain_table[i],
-                                                                               valid_inv_gamma);
-       }
-
-       /* The end of the table should match 1.0 carefully. In order to avoid    */
-       /* rounding errors, we just set this explicitly. The last segment may    */
-       /* have a different length than the other segments, but our              */
-       /* interpolation is insensitive to that.                                 */
-       color_domain_table[RE_GAMMA_TABLE_SIZE]   = 1.0;
+               color_domain_table[i]    = i * color_step;
+               gamma_range_table[i]     = pow(color_domain_table[i], valid_gamma);
+               inv_gamma_range_table[i] = pow(color_domain_table[i], valid_inv_gamma);
+       }
+
+       /* The end of the table should match 1.0 carefully. In order to avoid
+        * rounding errors, we just set this explicitly. The last segment may
+        * have a different length than the other segments, but our
+        * interpolation is insensitive to that
+        */
+       color_domain_table[RE_GAMMA_TABLE_SIZE]    = 1.0;
        gamma_range_table[RE_GAMMA_TABLE_SIZE]     = 1.0;
        inv_gamma_range_table[RE_GAMMA_TABLE_SIZE] = 1.0;
 
-       /* To speed up calculations, we make these calc factor tables. They are  */
-       /* multiplication factors used in scaling the interpolation.             */
-       for (i = 0; i < RE_GAMMA_TABLE_SIZE; i++ ) {
-               gamfactor_table[i] = inv_color_step
-                       * (gamma_range_table[i + 1] - gamma_range_table[i]);
-               inv_gamfactor_table[i] = inv_color_step
-                       * (inv_gamma_range_table[i + 1] - inv_gamma_range_table[i]);
+       /* To speed up calculations, we make these calc factor tables. They are
+        * multiplication factors used in scaling the interpolation
+        */
+       for (i = 0; i < RE_GAMMA_TABLE_SIZE; i++) {
+               gamfactor_table[i] = inv_color_step * (gamma_range_table[i + 1] - gamma_range_table[i]);
+               inv_gamfactor_table[i] = inv_color_step * (inv_gamma_range_table[i + 1] - inv_gamma_range_table[i]);
        }
 
-} /* end of void makeGammaTables(float gamma) */
-
+}
 
 static float gammaCorrect(float c)
 {
@@ -937,17 +632,17 @@ static float gammaCorrect(float c)
        float res = 0.0;
        
        i = floor(c * inv_color_step);
-       /* Clip to range [0,1]: outside, just do the complete calculation.       */
-       /* We may have some performance problems here. Stretching up the LUT     */
-       /* may help solve that, by exchanging LUT size for the interpolation.    */
-       /* Negative colors are explicitly handled.                              */
+       /* Clip to range [0, 1]: outside, just do the complete calculation.
+        * We may have some performance problems here. Stretching up the LUT
+        * may help solve that, by exchanging LUT size for the interpolation.
+        * Negative colors are explicitly handled.
+        */
        if (i < 0) res = -pow(abs(c), valid_gamma);
-       else if (i >= RE_GAMMA_TABLE_SIZE ) res = pow(c, valid_gamma);
-       else res = gamma_range_table[i] + 
-                          ( (c - color_domain_table[i]) * gamfactor_table[i]); 
+       else if (i >= RE_GAMMA_TABLE_SIZE) res = pow(c, valid_gamma);
+       else res = gamma_range_table[i] + ( (c - color_domain_table[i]) * gamfactor_table[i]);
        
        return res;
-} /* end of float gammaCorrect(float col) */
+}
 
 /* ------------------------------------------------------------------------- */
 
@@ -956,42 +651,39 @@ static float invGammaCorrect(float col)
        int i;
        float res = 0.0;
 
-       i = floor(col*inv_color_step);
-       /* Negative colors are explicitly handled.                              */
+       i = floor(col * inv_color_step);
+       /* Negative colors are explicitly handled */
        if (i < 0) res = -pow(abs(col), valid_inv_gamma);
        else if (i >= RE_GAMMA_TABLE_SIZE) res = pow(col, valid_inv_gamma);
-       else res = inv_gamma_range_table[i] + 
-                          ( (col - color_domain_table[i]) * inv_gamfactor_table[i]);
+       else res = inv_gamma_range_table[i] +  ( (col - color_domain_table[i]) * inv_gamfactor_table[i]);
  
        return res;
-} /* end of float invGammaCorrect(float col) */
-
+}
 
 static void gamtabs(float gamma)
 {
-       float val, igamma= 1.0f/gamma;
+       float val, igamma = 1.0f / gamma;
        int a;
        
        /* gamtab: in short, out short */
-       for (a=0; a<65536; a++) {
-               val= a;
-               val/= 65535.0f;
+       for (a = 0; a < 65536; a++) {
+               val = a;
+               val /= 65535.0f;
                
-               if (gamma==2.0f) val= sqrt(val);
-               else if (gamma!=1.0f) val= pow(val, igamma);
+               if (gamma == 2.0f) val = sqrt(val);
+               else if (gamma != 1.0f) val = pow(val, igamma);
                
-               gamtab[a]= (65535.99f*val);
+               gamtab[a] = (65535.99f * val);
        }
        /* inverse gamtab1 : in byte, out short */
-       for (a=1; a<=256; a++) {
-               if (gamma==2.0f) igamtab1[a-1]= a*a-1;
-               else if (gamma==1.0f) igamtab1[a-1]= 256*a-1;
+       for (a = 1; a <= 256; a++) {
+               if (gamma == 2.0f) igamtab1[a - 1] = a * a - 1;
+               else if (gamma == 1.0f) igamtab1[a - 1] = 256 * a - 1;
                else {
-                       val= a/256.0f;
-                       igamtab1[a - 1]= (65535.0 * pow(val, gamma)) - 1;
+                       val = a / 256.0f;
+                       igamtab1[a - 1] = (65535.0 * pow(val, gamma)) - 1;
                }
        }
-
 }
 
 static void build_gammatabs(void)
@@ -1003,229 +695,210 @@ static void build_gammatabs(void)
        }
 }
 
-static void init_gammacross(Sequence * UNUSED(seq))
+static void init_gammacross(Sequence *UNUSED(seq))
 {
 }
 
-static void load_gammacross(Sequence * UNUSED(seq))
+static void load_gammacross(Sequence *UNUSED(seq))
 {
 }
 
-static void free_gammacross(Sequence * UNUSED(seq))
+static void free_gammacross(Sequence *UNUSED(seq))
 {
 }
 
-static void do_gammacross_effect_byte(float facf0, float UNUSED(facf1), 
-                                         int x, int y, 
-                                         unsigned char *rect1, 
-                                         unsigned char *rect2, 
-                                         unsigned char *out)
+static void do_gammacross_effect_byte(float facf0, float UNUSED(facf1),  int x, int y, unsigned char *rect1,
+                                      unsigned char *rect2, unsigned char *out)
 {
        int fac1, fac2, col;
        int xo;
        unsigned char *rt1, *rt2, *rt;
        
-       xo= x;
-       rt1= (unsigned char *)rect1;
-       rt2= (unsigned char *)rect2;
-       rt= (unsigned char *)out;
+       xo = x;
+       rt1 = (unsigned char *) rect1;
+       rt2 = (unsigned char *) rect2;
+       rt = (unsigned char *) out;
 
-       fac2= (int)(256.0f*facf0);
-       fac1= 256-fac2;
+       fac2 = (int)(256.0f * facf0);
+       fac1 = 256 - fac2;
 
        while (y--) {
-
-               x= xo;
+               x = xo;
                while (x--) {
+                       col = (fac1 * igamtab1[rt1[0]] + fac2 * igamtab1[rt2[0]]) >> 8;
+                       if (col > 65535) rt[0] = 255; else rt[0] = ( (char *)(gamtab + col))[MOST_SIG_BYTE];
+                       col = (fac1 * igamtab1[rt1[1]] + fac2 * igamtab1[rt2[1]]) >> 8;
+                       if (col > 65535) rt[1] = 255; else rt[1] = ( (char *)(gamtab + col))[MOST_SIG_BYTE];
+                       col = (fac1 * igamtab1[rt1[2]] + fac2 * igamtab1[rt2[2]]) >> 8;
+                       if (col > 65535) rt[2] = 255; else rt[2] = ( (char *)(gamtab + col))[MOST_SIG_BYTE];
+                       col = (fac1 * igamtab1[rt1[3]] + fac2 * igamtab1[rt2[3]]) >> 8;
+                       if (col > 65535) rt[3] = 255; else rt[3] = ( (char *)(gamtab + col))[MOST_SIG_BYTE];
 
-                       col= (fac1*igamtab1[rt1[0]] + fac2*igamtab1[rt2[0]])>>8;
-                       if (col>65535) rt[0]= 255; else rt[0]= ( (char *)(gamtab+col))[MOST_SIG_BYTE];
-                       col=(fac1*igamtab1[rt1[1]] + fac2*igamtab1[rt2[1]])>>8;
-                       if (col>65535) rt[1]= 255; else rt[1]= ( (char *)(gamtab+col))[MOST_SIG_BYTE];
-                       col= (fac1*igamtab1[rt1[2]] + fac2*igamtab1[rt2[2]])>>8;
-                       if (col>65535) rt[2]= 255; else rt[2]= ( (char *)(gamtab+col))[MOST_SIG_BYTE];
-                       col= (fac1*igamtab1[rt1[3]] + fac2*igamtab1[rt2[3]])>>8;
-                       if (col>65535) rt[3]= 255; else rt[3]= ( (char *)(gamtab+col))[MOST_SIG_BYTE];
-
-                       rt1+= 4; rt2+= 4; rt+= 4;
+                       rt1 += 4; rt2 += 4; rt += 4;
                }
 
-               if (y==0) break;
+               if (y == 0)
+                       break;
                y--;
 
-               x= xo;
+               x = xo;
                while (x--) {
+                       col = (fac1 * igamtab1[rt1[0]] + fac2 * igamtab1[rt2[0]]) >> 8;
+                       if (col > 65535) rt[0] = 255; else rt[0] = ( (char *)(gamtab + col))[MOST_SIG_BYTE];
+                       col = (fac1 * igamtab1[rt1[1]] + fac2 * igamtab1[rt2[1]]) >> 8;
+                       if (col > 65535) rt[1] = 255; else rt[1] = ( (char *)(gamtab + col))[MOST_SIG_BYTE];
+                       col = (fac1 * igamtab1[rt1[2]] + fac2 * igamtab1[rt2[2]]) >> 8;
+                       if (col > 65535) rt[2] = 255; else rt[2] = ( (char *)(gamtab + col))[MOST_SIG_BYTE];
+                       col = (fac1 * igamtab1[rt1[3]] + fac2 * igamtab1[rt2[3]]) >> 8;
+                       if (col > 65535) rt[3] = 255; else rt[3] = ( (char *)(gamtab + col))[MOST_SIG_BYTE];
 
-                       col= (fac1*igamtab1[rt1[0]] + fac2*igamtab1[rt2[0]])>>8;
-                       if (col>65535) rt[0]= 255; else rt[0]= ( (char *)(gamtab+col))[MOST_SIG_BYTE];
-                       col= (fac1*igamtab1[rt1[1]] + fac2*igamtab1[rt2[1]])>>8;
-                       if (col>65535) rt[1]= 255; else rt[1]= ( (char *)(gamtab+col))[MOST_SIG_BYTE];
-                       col= (fac1*igamtab1[rt1[2]] + fac2*igamtab1[rt2[2]])>>8;
-                       if (col>65535) rt[2]= 255; else rt[2]= ( (char *)(gamtab+col))[MOST_SIG_BYTE];
-                       col= (fac1*igamtab1[rt1[3]] + fac2*igamtab1[rt2[3]])>>8;
-                       if (col>65535) rt[3]= 255; else rt[3]= ( (char *)(gamtab+col))[MOST_SIG_BYTE];
-
-                       rt1+= 4; rt2+= 4; rt+= 4;
+                       rt1 += 4; rt2 += 4; rt += 4;
                }
        }
-
 }
 
-static void do_gammacross_effect_float(float facf0, float UNUSED(facf1), 
-                                          int x, int y, 
-                                          float *rect1, float *rect2, 
-                                          float *out)
+static void do_gammacross_effect_float(float facf0, float UNUSED(facf1), int x, int y, float *rect1,
+                                       float *rect2, float *out)
 {
        float fac1, fac2;
        int xo;
        float *rt1, *rt2, *rt;
 
-       xo= x;
-       rt1= rect1;
-       rt2= rect2;
-       rt= out;
+       xo = x;
+       rt1 = rect1;
+       rt2 = rect2;
+       rt = out;
 
-       fac2= facf0;
-       fac1= 1.0f - fac2;
+       fac2 = facf0;
+       fac1 = 1.0f - fac2;
 
        while (y--) {
-
-               x= xo * 4;
+               x = xo * 4;
                while (x--) {
-
-                       *rt= gammaCorrect(
-                               fac1 * invGammaCorrect(*rt1) 
-                               + fac2 * invGammaCorrect(*rt2));
+                       *rt = gammaCorrect(fac1 * invGammaCorrect(*rt1) + fac2 * invGammaCorrect(*rt2));
                        rt1++; rt2++; rt++;
                }
 
-               if (y==0) break;
+               if (y == 0)
+                       break;
                y--;
 
-               x= xo * 4;
+               x = xo * 4;
                while (x--) {
-
-                       *rt= gammaCorrect(
-                               fac1*invGammaCorrect(*rt1) 
-                               + fac2*invGammaCorrect(*rt2));
+                       *rt = gammaCorrect(fac1 * invGammaCorrect(*rt1) + fac2 * invGammaCorrect(*rt2));
 
                        rt1++; rt2++; rt++;
                }
        }
 }
 
-static struct ImBuf * do_gammacross_effect(
-       SeqRenderData context,
-       Sequence *UNUSED(seq), float UNUSED(cfra),
-       float facf0, float facf1, 
-       struct ImBuf *ibuf1, struct ImBuf *ibuf2, 
-       struct ImBuf *ibuf3)
+static struct ImBuf *gammacross_init_execution(SeqRenderData context, ImBuf *ibuf1, ImBuf *ibuf2, ImBuf *ibuf3)
 {
-       struct ImBuf * out = prepare_effect_imbufs(context,ibuf1, ibuf2, ibuf3);
-
+       ImBuf *out = prepare_effect_imbufs(context, ibuf1, ibuf2, ibuf3);
        build_gammatabs();
 
+       return out;
+}
+
+static void do_gammacross_effect(SeqRenderData context, Sequence *UNUSED(seq), float UNUSED(cfra),
+                                 float facf0, float facf1, ImBuf *ibuf1, ImBuf *ibuf2, ImBuf *UNUSED(ibuf3),
+                                 int start_line, int total_lines, ImBuf *out)
+{
        if (out->rect_float) {
-               do_gammacross_effect_float(
-                       facf0, facf1, context.rectx, context.recty,
-                       ibuf1->rect_float, ibuf2->rect_float,
-                       out->rect_float);
+               float *rect1 = NULL, *rect2 = NULL, *rect_out = NULL;
+
+               slice_get_float_buffers(&context, ibuf1, ibuf2, NULL, out, start_line, &rect1, &rect2, NULL, &rect_out);
+
+               do_gammacross_effect_float(facf0, facf1, context.rectx, total_lines, rect1, rect2, rect_out);
        }
        else {
-               do_gammacross_effect_byte(
-                       facf0, facf1, context.rectx, context.recty,
-                       (unsigned char*) ibuf1->rect, (unsigned char*) ibuf2->rect,
-                       (unsigned char*) out->rect);
+               unsigned char *rect1 = NULL, *rect2 = NULL, *rect_out = NULL;
+
+               slice_get_byte_buffers(&context, ibuf1, ibuf2, NULL, out, start_line, &rect1, &rect2, NULL, &rect_out);
+
+               do_gammacross_effect_byte(facf0, facf1, context.rectx, total_lines, rect1, rect2, rect_out);
        }
-       return out;
 }
 
+/*********************** Add *************************/
 
-/* **********************************************************************
- * ADD
- * ********************************************************************** */
-
-static void do_add_effect_byte(float facf0, float facf1, int x, int y, 
-                                  unsigned char *rect1, unsigned char *rect2, 
-                                  unsigned char *out)
+static void do_add_effect_byte(float facf0, float facf1, int x, int y, unsigned char *rect1, unsigned char *rect2,
+                               unsigned char *out)
 {
        int col, xo, fac1, fac3;
        char *rt1, *rt2, *rt;
 
-       xo= x;
-       rt1= (char *)rect1;
-       rt2= (char *)rect2;
-       rt= (char *)out;
+       xo = x;
+       rt1 = (char *)rect1;
+       rt2 = (char *)rect2;
+       rt = (char *)out;
 
-       fac1= (int)(256.0f*facf0);
-       fac3= (int)(256.0f*facf1);
+       fac1 = (int)(256.0f * facf0);
+       fac3 = (int)(256.0f * facf1);
 
        while (y--) {
+               x = xo;
 
-               x= xo;
                while (x--) {
+                       col = rt1[0] + ((fac1 * rt2[0]) >> 8);
+                       if (col > 255) rt[0] = 255; else rt[0] = col;
+                       col = rt1[1] + ((fac1 * rt2[1]) >> 8);
+                       if (col > 255) rt[1] = 255; else rt[1] = col;
+                       col = rt1[2] + ((fac1 * rt2[2]) >> 8);
+                       if (col > 255) rt[2] = 255; else rt[2] = col;
+                       col = rt1[3] + ((fac1 * rt2[3]) >> 8);
+                       if (col > 255) rt[3] = 255; else rt[3] = col;
 
-                       col= rt1[0]+ ((fac1*rt2[0])>>8);
-                       if (col>255) rt[0]= 255; else rt[0]= col;
-                       col= rt1[1]+ ((fac1*rt2[1])>>8);
-                       if (col>255) rt[1]= 255; else rt[1]= col;
-                       col= rt1[2]+ ((fac1*rt2[2])>>8);
-                       if (col>255) rt[2]= 255; else rt[2]= col;
-                       col= rt1[3]+ ((fac1*rt2[3])>>8);
-                       if (col>255) rt[3]= 255; else rt[3]= col;
-
-                       rt1+= 4; rt2+= 4; rt+= 4;
+                       rt1 += 4; rt2 += 4; rt += 4;
                }
 
-               if (y==0) break;
+               if (y == 0)
+                       break;
                y--;
 
-               x= xo;
+               x = xo;
                while (x--) {
+                       col = rt1[0] + ((fac3 * rt2[0]) >> 8);
+                       if (col > 255) rt[0] = 255; else rt[0] = col;
+                       col = rt1[1] + ((fac3 * rt2[1]) >> 8);
+                       if (col > 255) rt[1] = 255; else rt[1] = col;
+                       col = rt1[2] + ((fac3 * rt2[2]) >> 8);
+                       if (col > 255) rt[2] = 255; else rt[2] = col;
+                       col = rt1[3] + ((fac3 * rt2[3]) >> 8);
+                       if (col > 255) rt[3] = 255; else rt[3] = col;
 
-                       col= rt1[0]+ ((fac3*rt2[0])>>8);
-                       if (col>255) rt[0]= 255; else rt[0]= col;
-                       col= rt1[1]+ ((fac3*rt2[1])>>8);
-                       if (col>255) rt[1]= 255; else rt[1]= col;
-                       col= rt1[2]+ ((fac3*rt2[2])>>8);
-                       if (col>255) rt[2]= 255; else rt[2]= col;
-                       col= rt1[3]+ ((fac3*rt2[3])>>8);
-                       if (col>255) rt[3]= 255; else rt[3]= col;
-
-                       rt1+= 4; rt2+= 4; rt+= 4;
+                       rt1 += 4; rt2 += 4; rt += 4;
                }
        }
 }
 
-static void do_add_effect_float(float facf0, float facf1, int x, int y, 
-                               float *rect1, float *rect2, 
-                               float *out)
+static void do_add_effect_float(float facf0, float facf1, int x, int y, float *rect1, float *rect2, float *out)
 {
        int xo;
        float fac1, fac3;
        float *rt1, *rt2, *rt;
 
-       xo= x;
-       rt1= rect1;
-       rt2= rect2;
-       rt= out;
+       xo = x;
+       rt1 = rect1;
+       rt2 = rect2;
+       rt = out;
 
-       fac1= facf0;
-       fac3= facf1;
+       fac1 = facf0;
+       fac3 = facf1;
 
        while (y--) {
-
-               x= xo * 4;
+               x = xo * 4;
                while (x--) {
                        *rt = *rt1 + fac1 * (*rt2);
 
                        rt1++; rt2++; rt++;
                }
 
-               if (y==0) break;
+               if (y == 0)
+                       break;
                y--;
 
-               x= xo * 4;
+               x = xo * 4;
                while (x--) {
                        *rt = *rt1 + fac3 * (*rt2);
 
@@ -1234,115 +907,102 @@ static void do_add_effect_float(float facf0, float facf1, int x, int y,
        }
 }
 
-static struct ImBuf * do_add_effect(SeqRenderData context, 
-                                   Sequence *UNUSED(seq), float UNUSED(cfra),
-                                   float facf0, float facf1,
-                                   struct ImBuf *ibuf1, struct ImBuf *ibuf2, 
-                                   struct ImBuf *ibuf3)
+static void do_add_effect(SeqRenderData context, Sequence *UNUSED(seq), float UNUSED(cfra), float facf0, float facf1,
+                          ImBuf *ibuf1, ImBuf *ibuf2, ImBuf *UNUSED(ibuf3), int start_line, int total_lines, ImBuf *out)
 {
-       struct ImBuf * out = prepare_effect_imbufs(context,ibuf1, ibuf2, ibuf3);
-
        if (out->rect_float) {
-               do_add_effect_float(
-                       facf0, facf1, context.rectx, context.recty,
-                       ibuf1->rect_float, ibuf2->rect_float,
-                       out->rect_float);
+               float *rect1 = NULL, *rect2 = NULL, *rect_out = NULL;
+
+               slice_get_float_buffers(&context, ibuf1, ibuf2, NULL, out, start_line, &rect1, &rect2, NULL, &rect_out);
+
+               do_add_effect_float(facf0, facf1, context.rectx, total_lines, rect1, rect2, rect_out);
        }
        else {
-               do_add_effect_byte(
-                       facf0, facf1, context.rectx, context.recty,
-                       (unsigned char*) ibuf1->rect, (unsigned char*) ibuf2->rect,
-                       (unsigned char*) out->rect);
+               unsigned char *rect1 = NULL, *rect2 = NULL, *rect_out = NULL;
+
+               slice_get_byte_buffers(&context, ibuf1, ibuf2, NULL, out, start_line, &rect1, &rect2, NULL, &rect_out);
+
+               do_add_effect_byte(facf0, facf1, context.rectx, total_lines, rect1, rect2, rect_out);
        }
-       return out;
 }
 
+/*********************** Sub *************************/
 
-/* **********************************************************************
- * SUB
- * ********************************************************************** */
-
-static void do_sub_effect_byte(float facf0, float facf1, 
-                                  int x, int y, 
-                                  char *rect1, char *rect2, char *out)
+static void do_sub_effect_byte(float facf0, float facf1, int x, int y, char *rect1, char *rect2, char *out)
 {
        int col, xo, fac1, fac3;
        char *rt1, *rt2, *rt;
 
-       xo= x;
-       rt1= (char *)rect1;
-       rt2= (char *)rect2;
-       rt= (char *)out;
+       xo = x;
+       rt1 = (char *) rect1;
+       rt2 = (char *) rect2;
+       rt = (char *) out;
 
-       fac1= (int)(256.0f*facf0);
-       fac3= (int)(256.0f*facf1);
+       fac1 = (int) (256.0f * facf0);
+       fac3 = (int) (256.0f * facf1);
 
        while (y--) {
-
-               x= xo;
+               x = xo;
                while (x--) {
+                       col = rt1[0] - ((fac1 * rt2[0]) >> 8);
+                       if (col < 0) rt[0] = 0; else rt[0] = col;
+                       col = rt1[1] - ((fac1 * rt2[1]) >> 8);
+                       if (col < 0) rt[1] = 0; else rt[1] = col;
+                       col = rt1[2] - ((fac1 * rt2[2]) >> 8);
+                       if (col < 0) rt[2] = 0; else rt[2] = col;
+                       col = rt1[3] - ((fac1 * rt2[3]) >> 8);
+                       if (col < 0) rt[3] = 0; else rt[3] = col;
 
-                       col= rt1[0]- ((fac1*rt2[0])>>8);
-                       if (col<0) rt[0]= 0; else rt[0]= col;
-                       col= rt1[1]- ((fac1*rt2[1])>>8);
-                       if (col<0) rt[1]= 0; else rt[1]= col;
-                       col= rt1[2]- ((fac1*rt2[2])>>8);
-                       if (col<0) rt[2]= 0; else rt[2]= col;
-                       col= rt1[3]- ((fac1*rt2[3])>>8);
-                       if (col<0) rt[3]= 0; else rt[3]= col;
-
-                       rt1+= 4; rt2+= 4; rt+= 4;
+                       rt1 += 4; rt2 += 4; rt += 4;
                }
 
-               if (y==0) break;
+               if (y == 0)
+                       break;
                y--;
 
-               x= xo;
+               x = xo;
                while (x--) {
+                       col = rt1[0] - ((fac3 * rt2[0]) >> 8);
+                       if (col < 0) rt[0] = 0; else rt[0] = col;
+                       col = rt1[1] - ((fac3 * rt2[1]) >> 8);
+                       if (col < 0) rt[1] = 0; else rt[1] = col;
+                       col = rt1[2] - ((fac3 * rt2[2]) >> 8);
+                       if (col < 0) rt[2] = 0; else rt[2] = col;
+                       col = rt1[3] - ((fac3 * rt2[3]) >> 8);
+                       if (col < 0) rt[3] = 0; else rt[3] = col;
 
-                       col= rt1[0]- ((fac3*rt2[0])>>8);
-                       if (col<0) rt[0]= 0; else rt[0]= col;
-                       col= rt1[1]- ((fac3*rt2[1])>>8);
-                       if (col<0) rt[1]= 0; else rt[1]= col;
-                       col= rt1[2]- ((fac3*rt2[2])>>8);
-                       if (col<0) rt[2]= 0; else rt[2]= col;
-                       col= rt1[3]- ((fac3*rt2[3])>>8);
-                       if (col<0) rt[3]= 0; else rt[3]= col;
-
-                       rt1+= 4; rt2+= 4; rt+= 4;
+                       rt1 += 4; rt2 += 4; rt += 4;
                }
        }
 }
 
-static void do_sub_effect_float(float facf0, float facf1, int x, int y, 
-                               float *rect1, float *rect2, 
-                               float *out)
+static void do_sub_effect_float(float facf0, float facf1, int x, int y, float *rect1, float *rect2, float *out)
 {
        int xo;
        float fac1, fac3;
        float *rt1, *rt2, *rt;
 
-       xo= x;
-       rt1= rect1;
-       rt2= rect2;
-       rt= out;
+       xo = x;
+       rt1 = rect1;
+       rt2 = rect2;
+       rt = out;
 
-       fac1= facf0;
-       fac3= facf1;
+       fac1 = facf0;
+       fac3 = facf1;
 
        while (y--) {
-
-               x= xo * 4;
+               x = xo * 4;
                while (x--) {
                        *rt = *rt1 - fac1 * (*rt2);
 
                        rt1++; rt2++; rt++;
                }
 
-               if (y==0) break;
+               if (y == 0)
+                       break;
                y--;
 
-               x= xo * 4;
+               x = xo * 4;
                while (x--) {
                        *rt = *rt1 - fac3 * (*rt2);
 
@@ -1351,247 +1011,223 @@ static void do_sub_effect_float(float facf0, float facf1, int x, int y,
        }
 }
 
-static struct ImBuf * do_sub_effect(
-       SeqRenderData context, Sequence *UNUSED(seq), float UNUSED(cfra),
-       float facf0, float facf1, 
-       struct ImBuf *ibuf1, struct ImBuf *ibuf2, 
-       struct ImBuf *ibuf3)
+static void do_sub_effect(SeqRenderData context, Sequence *UNUSED(seq), float UNUSED(cfra), float facf0, float facf1,
+                          ImBuf *ibuf1, ImBuf *ibuf2, ImBuf *UNUSED(ibuf3), int start_line, int total_lines, ImBuf *out)
 {
-       struct ImBuf * out = prepare_effect_imbufs(context,ibuf1, ibuf2, ibuf3);
-
        if (out->rect_float) {
-               do_sub_effect_float(
-                       facf0, facf1, context.rectx, context.recty,
-                       ibuf1->rect_float, ibuf2->rect_float,
-                       out->rect_float);
+               float *rect1 = NULL, *rect2 = NULL, *rect_out = NULL;
+
+               slice_get_float_buffers(&context, ibuf1, ibuf2, NULL, out, start_line, &rect1, &rect2, NULL, &rect_out);
+
+               do_sub_effect_float(facf0, facf1, context.rectx, total_lines, rect1, rect2, rect_out);
        }
        else {
-               do_sub_effect_byte(
-                       facf0, facf1, context.rectx, context.recty,
-                       (char*) ibuf1->rect, (char*) ibuf2->rect,
-                       (char*) out->rect);
+               unsigned char *rect1 = NULL, *rect2 = NULL, *rect_out = NULL;
+
+               slice_get_byte_buffers(&context, ibuf1, ibuf2, NULL, out, start_line, &rect1, &rect2, NULL, &rect_out);
+
+               do_sub_effect_byte(facf0, facf1, context.rectx, total_lines, (char *) rect1, (char *) rect2, (char *) rect_out);
        }
-       return out;
 }
 
-/* **********************************************************************
- * DROP
- * ********************************************************************** */
+/*********************** Drop *************************/
 
 /* Must be > 0 or add precopy, etc to the function */
-#define XOFF   8
-#define YOFF   8
+#define XOFF    8
+#define YOFF    8
 
-static void do_drop_effect_byte(float facf0, float facf1, int x, int y, 
-                               char *rect2i, char *rect1i, 
-                               char *outi)
+static void do_drop_effect_byte(float facf0, float facf1, int x, int y, char *rect2i, char *rect1i, char *outi)
 {
        int height, width, temp, fac, fac1, fac2;
        char *rt1, *rt2, *out;
-       int field= 1;
-
-       width= x;
-       height= y;
-
-       fac1= (int)(70.0f*facf0);
-       fac2= (int)(70.0f*facf1);
-
-       rt2= (char*) (rect2i + YOFF*width);
-       rt1= (char*) rect1i;
-       out= (char*) outi;
-       for (y=0; y<height-YOFF; y++) {
-               if (field) fac= fac1;
-               else fac= fac2;
-               field= !field;
-
-               memcpy(out, rt1, sizeof(int)*XOFF);
-               rt1+= XOFF*4;
-               out+= XOFF*4;
-
-               for (x=XOFF; x<width; x++) {
-                       temp= ((fac*rt2[3])>>8);
-
-                       *(out++)= MAX2(0, *rt1 - temp); rt1++;
-                       *(out++)= MAX2(0, *rt1 - temp); rt1++;
-                       *(out++)= MAX2(0, *rt1 - temp); rt1++;
-                       *(out++)= MAX2(0, *rt1 - temp); rt1++;
-                       rt2+=4;
+       int field = 1;
+
+       width = x;
+       height = y;
+
+       fac1 = (int) (70.0f * facf0);
+       fac2 = (int) (70.0f * facf1);
+
+       rt2 = (char *) (rect2i + YOFF * width);
+       rt1 = (char *) rect1i;
+       out = (char *) outi;
+       for (y = 0; y < height - YOFF; y++) {
+               if (field) fac = fac1;
+               else fac = fac2;
+               field = !field;
+
+               memcpy(out, rt1, sizeof(int) * XOFF);
+               rt1 += XOFF * 4;
+               out += XOFF * 4;
+
+               for (x = XOFF; x < width; x++) {
+                       temp = ((fac * rt2[3]) >> 8);
+
+                       *(out++) = MAX2(0, *rt1 - temp); rt1++;
+                       *(out++) = MAX2(0, *rt1 - temp); rt1++;
+                       *(out++) = MAX2(0, *rt1 - temp); rt1++;
+                       *(out++) = MAX2(0, *rt1 - temp); rt1++;
+                       rt2 += 4;
                }
-               rt2+=XOFF*4;
+               rt2 += XOFF * 4;
        }
-       memcpy(out, rt1, sizeof(int)*YOFF*width);
+       memcpy(out, rt1, sizeof(int) * YOFF * width);
 }
 
-static void do_drop_effect_float(float facf0, float facf1, int x, int y, 
-                                float *rect2i, float *rect1i, 
-                                float *outi)
+static void do_drop_effect_float(float facf0, float facf1, int x, int y, float *rect2i, float *rect1i, float *outi)
 {
        int height, width;
        float temp, fac, fac1, fac2;
        float *rt1, *rt2, *out;
-       int field= 1;
-
-       width= x;
-       height= y;
-
-       fac1= 70.0f*facf0;
-       fac2= 70.0f*facf1;
-
-       rt2=  (rect2i + YOFF*width);
-       rt1=  rect1i;
-       out=  outi;
-       for (y=0; y<height-YOFF; y++) {
-               if (field) fac= fac1;
-               else fac= fac2;
-               field= !field;
-
-               memcpy(out, rt1, 4 * sizeof(float)*XOFF);
-               rt1+= XOFF*4;
-               out+= XOFF*4;
-
-               for (x=XOFF; x<width; x++) {
-                       temp= fac * rt2[3];
-
-                       *(out++)= MAX2(0.0f, *rt1 - temp); rt1++;
-                       *(out++)= MAX2(0.0f, *rt1 - temp); rt1++;
-                       *(out++)= MAX2(0.0f, *rt1 - temp); rt1++;
-                       *(out++)= MAX2(0.0f, *rt1 - temp); rt1++;
-                       rt2+=4;
+       int field = 1;
+
+       width = x;
+       height = y;
+
+       fac1 = 70.0f * facf0;
+       fac2 = 70.0f * facf1;
+
+       rt2 =  (rect2i + YOFF * width);
+       rt1 =  rect1i;
+       out =  outi;
+       for (y = 0; y < height - YOFF; y++) {
+               if (field) fac = fac1;
+               else fac = fac2;
+               field = !field;
+
+               memcpy(out, rt1, 4 * sizeof(float) * XOFF);
+               rt1 += XOFF * 4;
+               out += XOFF * 4;
+
+               for (x = XOFF; x < width; x++) {
+                       temp = fac * rt2[3];
+
+                       *(out++) = MAX2(0.0f, *rt1 - temp); rt1++;
+                       *(out++) = MAX2(0.0f, *rt1 - temp); rt1++;
+                       *(out++) = MAX2(0.0f, *rt1 - temp); rt1++;
+                       *(out++) = MAX2(0.0f, *rt1 - temp); rt1++;
+                       rt2 += 4;
                }
-               rt2+=XOFF*4;
+               rt2 += XOFF * 4;
        }
-       memcpy(out, rt1, 4 * sizeof(float)*YOFF*width);
+       memcpy(out, rt1, 4 * sizeof(float) * YOFF * width);
 }
 
-/* **********************************************************************
- * MUL
- * ********************************************************************** */
+/*********************** Mul *************************/
 
-static void do_mul_effect_byte(float facf0, float facf1, int x, int y, 
-                                  unsigned char *rect1, unsigned char *rect2, 
-                                  unsigned char *out)
+static void do_mul_effect_byte(float facf0, float facf1, int x, int y, unsigned char *rect1, unsigned char *rect2,
+                               unsigned char *out)
 {
        int xo, fac1, fac3;
        char *rt1, *rt2, *rt;
 
-       xo= x;
-       rt1= (char *)rect1;
-       rt2= (char *)rect2;
-       rt= (char *)out;
+       xo = x;
+       rt1 = (char *)rect1;
+       rt2 = (char *)rect2;
+       rt = (char *)out;
 
-       fac1= (int)(256.0f*facf0);
-       fac3= (int)(256.0f*facf1);
+       fac1 = (int)(256.0f * facf0);
+       fac3 = (int)(256.0f * facf1);
 
        /* formula:
-        *              fac*(a*b) + (1-fac)*a  => fac*a*(b-1)+axaux= c*px + py*s ;//+centx
-        *              yaux= -s*px + c*py;//+centy
+        *              fac * (a * b) + (1-fac)*a  => fac * a * (b - 1) + axaux = c * px + py * s; //+centx
+        *              yaux = -s * px + c * py; //+centy
         */
 
        while (y--) {
 
-               x= xo;
+               x = xo;
                while (x--) {
 
-                       rt[0]= rt1[0] + ((fac1*rt1[0]*(rt2[0]-256))>>16);
-                       rt[1]= rt1[1] + ((fac1*rt1[1]*(rt2[1]-256))>>16);
-                       rt[2]= rt1[2] + ((fac1*rt1[2]*(rt2[2]-256))>>16);
-                       rt[3]= rt1[3] + ((fac1*rt1[3]*(rt2[3]-256))>>16);
+                       rt[0] = rt1[0] + ((fac1 * rt1[0] * (rt2[0] - 256)) >> 16);
+                       rt[1] = rt1[1] + ((fac1 * rt1[1] * (rt2[1] - 256)) >> 16);
+                       rt[2] = rt1[2] + ((fac1 * rt1[2] * (rt2[2] - 256)) >> 16);
+                       rt[3] = rt1[3] + ((fac1 * rt1[3] * (rt2[3] - 256)) >> 16);
 
-                       rt1+= 4; rt2+= 4; rt+= 4;
+                       rt1 += 4; rt2 += 4; rt += 4;
                }
 
-               if (y==0) break;
+               if (y == 0) break;
                y--;
 
-               x= xo;
+               x = xo;
                while (x--) {
 
-                       rt[0]= rt1[0] + ((fac3*rt1[0]*(rt2[0]-256))>>16);
-                       rt[1]= rt1[1] + ((fac3*rt1[1]*(rt2[1]-256))>>16);
-                       rt[2]= rt1[2] + ((fac3*rt1[2]*(rt2[2]-256))>>16);
-                       rt[3]= rt1[3] + ((fac3*rt1[3]*(rt2[3]-256))>>16);
+                       rt[0] = rt1[0] + ((fac3 * rt1[0] * (rt2[0] - 256)) >> 16);
+                       rt[1] = rt1[1] + ((fac3 * rt1[1] * (rt2[1] - 256)) >> 16);
+                       rt[2] = rt1[2] + ((fac3 * rt1[2] * (rt2[2] - 256)) >> 16);
+                       rt[3] = rt1[3] + ((fac3 * rt1[3] * (rt2[3] - 256)) >> 16);
 
-                       rt1+= 4; rt2+= 4; rt+= 4;
+                       rt1 += 4; rt2 += 4; rt += 4;
                }
        }
 }
 
-static void do_mul_effect_float(float facf0, float facf1, int x, int y, 
-                                       float *rect1, float *rect2, 
-                                       float *out)
+static void do_mul_effect_float(float facf0, float facf1, int x, int y, float *rect1, float *rect2, float *out)
 {
        int xo;
        float fac1, fac3;
        float *rt1, *rt2, *rt;
 
-       xo= x;
-       rt1= rect1;
-       rt2= rect2;
-       rt= out;
+       xo = x;
+       rt1 = rect1;
+       rt2 = rect2;
+       rt = out;
 
-       fac1= facf0;
-       fac3= facf1;
+       fac1 = facf0;
+       fac3 = facf1;
 
        /* formula:
         *              fac*(a*b) + (1-fac)*a  => fac*a*(b-1)+a
         */
 
        while (y--) {
-
-               x= xo;
+               x = xo;
                while (x--) {
+                       rt[0] = rt1[0] + fac1 * rt1[0] * (rt2[0] - 1.0f);
+                       rt[1] = rt1[1] + fac1 * rt1[1] * (rt2[1] - 1.0f);
+                       rt[2] = rt1[2] + fac1 * rt1[2] * (rt2[2] - 1.0f);
+                       rt[3] = rt1[3] + fac1 * rt1[3] * (rt2[3] - 1.0f);
 
-                       rt[0]= rt1[0] + fac1*rt1[0]*(rt2[0]-1.0f);
-                       rt[1]= rt1[1] + fac1*rt1[1]*(rt2[1]-1.0f);
-                       rt[2]= rt1[2] + fac1*rt1[2]*(rt2[2]-1.0f);
-                       rt[3]= rt1[3] + fac1*rt1[3]*(rt2[3]-1.0f);
-
-                       rt1+= 4; rt2+= 4; rt+= 4;
+                       rt1 += 4; rt2 += 4; rt += 4;
                }
 
-               if (y==0) break;
+               if (y == 0)
+                       break;
                y--;
 
-               x= xo;
+               x = xo;
                while (x--) {
+                       rt[0] = rt1[0] + fac3 * rt1[0] * (rt2[0] - 1.0f);
+                       rt[1] = rt1[1] + fac3 * rt1[1] * (rt2[1] - 1.0f);
+                       rt[2] = rt1[2] + fac3 * rt1[2] * (rt2[2] - 1.0f);
+                       rt[3] = rt1[3] + fac3 * rt1[3] * (rt2[3] - 1.0f);
 
-                       rt[0]= rt1[0] + fac3*rt1[0]*(rt2[0]-1.0f);
-                       rt[1]= rt1[1] + fac3*rt1[1]*(rt2[1]-1.0f);
-                       rt[2]= rt1[2] + fac3*rt1[2]*(rt2[2]-1.0f);
-                       rt[3]= rt1[3] + fac3*rt1[3]*(rt2[3]-1.0f);
-
-                       rt1+= 4; rt2+= 4; rt+= 4;
+                       rt1 += 4; rt2 += 4; rt += 4;
                }
        }
 }
 
-static struct ImBuf * do_mul_effect(
-       SeqRenderData context, Sequence *UNUSED(seq), float UNUSED(cfra),
-       float facf0, float facf1, 
-       struct ImBuf *ibuf1, struct ImBuf *ibuf2, 
-       struct ImBuf *ibuf3)
+static void do_mul_effect(SeqRenderData context, Sequence *UNUSED(seq), float UNUSED(cfra), float facf0, float facf1,
+                          ImBuf *ibuf1, ImBuf *ibuf2, ImBuf *UNUSED(ibuf3), int start_line, int total_lines, ImBuf *out)
 {
-       struct ImBuf * out = prepare_effect_imbufs(context,ibuf1, ibuf2, ibuf3);
-
        if (out->rect_float) {
-               do_mul_effect_float(
-                       facf0, facf1, context.rectx, context.recty,
-                       ibuf1->rect_float, ibuf2->rect_float,
-                       out->rect_float);
+               float *rect1 = NULL, *rect2 = NULL, *rect_out = NULL;
+
+               slice_get_float_buffers(&context, ibuf1, ibuf2, NULL, out, start_line, &rect1, &rect2, NULL, &rect_out);
+
+               do_mul_effect_float(facf0, facf1, context.rectx, total_lines, rect1, rect2, rect_out);
        }
        else {
-               do_mul_effect_byte(
-                       facf0, facf1, context.rectx, context.recty,
-                       (unsigned char*) ibuf1->rect, (unsigned char*) ibuf2->rect,
-                       (unsigned char*) out->rect);
-       }
+               unsigned char *rect1 = NULL, *rect2 = NULL, *rect_out = NULL;
 
-       return out;
+               slice_get_byte_buffers(&context, ibuf1, ibuf2, NULL, out, start_line, &rect1, &rect2, NULL, &rect_out);
+
+               do_mul_effect_byte(facf0, facf1, context.rectx, total_lines, rect1, rect2, rect_out);
+       }
 }
 
-/* **********************************************************************
- * WIPE
- * ********************************************************************** */
+/*********************** Wipe *************************/
 
 typedef struct WipeZone {
        float angle;
@@ -1607,12 +1243,12 @@ static void precalc_wipe_zone(WipeZone *wipezone, WipeVars *wipe, int xo, int yo
        wipezone->angle = tanf(DEG2RADF(fabsf(wipe->angle)));
        wipezone->xo = xo;
        wipezone->yo = yo;
-       wipezone->width = (int)(wipe->edgeWidth*((xo+yo)/2.0f));
-       wipezone->pythangle = 1.0f/sqrtf(wipezone->angle*wipezone->angle + 1.0f);
+       wipezone->width = (int)(wipe->edgeWidth * ((xo + yo) / 2.0f));
+       wipezone->pythangle = 1.0f / sqrtf(wipezone->angle * wipezone->angle + 1.0f);
 }
 
-// This function calculates the blur band for the wipe effects
-static float in_band(float width,float dist,int side,int dir)
+/* This function calculates the blur band for the wipe effects */
+static float in_band(float width, float dist, int side, int dir)
 {
        float alpha;
 
@@ -1623,28 +1259,27 @@ static float in_band(float width,float dist,int side,int dir)
                return (float)side;
 
        if (side == 1)
-               alpha = (dist+0.5f*width) / (width);
+               alpha = (dist + 0.5f * width) / (width);
        else
-               alpha = (0.5f*width-dist) / (width);
+               alpha = (0.5f * width - dist) / (width);
 
        if (dir == 0)
-               alpha = 1-alpha;
+               alpha = 1 - alpha;
 
        return alpha;
 }
 
-static float check_zone(WipeZone *wipezone, int x, int y,
-       Sequence *seq, float facf0) 
+static float check_zone(WipeZone *wipezone, int x, int y, Sequence *seq, float facf0)
 {
-       float posx, posy,hyp,hyp2,angle,hwidth,b1,b2,b3,pointdist;
+       float posx, posy, hyp, hyp2, angle, hwidth, b1, b2, b3, pointdist;
        /* some future stuff */
-       // float hyp3,hyp4,b4,b5
-       float temp1,temp2,temp3,temp4; //some placeholder variables
+       /* float hyp3, hyp4, b4, b5 */
+       float temp1, temp2, temp3, temp4; /* some placeholder variables */
        int xo = wipezone->xo;
        int yo = wipezone->yo;
-       float halfx = xo*0.5f;
-       float halfy = yo*0.5f;
-       float widthf,output=0;
+       float halfx = xo * 0.5f;
+       float halfy = yo * 0.5f;
+       float widthf, output = 0;
        WipeVars *wipe = (WipeVars *)seq->effectdata;
        int width;
 
@@ -1670,9 +1305,9 @@ static float check_zone(WipeZone *wipezone, int x, int y,
                                hyp = fabs(y - posy);
                        }
                        else {
-                               b1 = posy - (-angle)*posx;
-                               b2 = y - (-angle)*x;
-                               hyp = fabsf(angle*x+y+(-posy-angle*posx))*wipezone->pythangle;
+                               b1 = posy - (-angle) * posx;
+                               b2 = y - (-angle) * x;
+                               hyp = fabsf(angle * x + y + (-posy - angle * posx)) * wipezone->pythangle;
                        }
 
                        if (angle < 0) {
@@ -1683,186 +1318,186 @@ static float check_zone(WipeZone *wipezone, int x, int y,
 
                        if (wipe->forward) {
                                if (b1 < b2)
-                                       output = in_band(width,hyp,1,1);
+                                       output = in_band(width, hyp, 1, 1);
                                else
-                                       output = in_band(width,hyp,0,1);
+                                       output = in_band(width, hyp, 0, 1);
                        }
                        else {
                                if (b1 < b2)
-                                       output = in_band(width,hyp,0,1);
+                                       output = in_band(width, hyp, 0, 1);
                                else
-                                       output = in_band(width,hyp,1,1);
+                                       output = in_band(width, hyp, 1, 1);
                        }
-               break;
+                       break;
 
                case DO_DOUBLE_WIPE:
                        if (!wipe->forward)
-                               facf0 = 1.0f-facf0;   // Go the other direction
+                               facf0 = 1.0f - facf0;  /* Go the other direction */
 
-                       width = wipezone->width;  // calculate the blur width
-                       hwidth = width*0.5f;
+                       width = wipezone->width;  /* calculate the blur width */
+                       hwidth = width * 0.5f;
                        if (angle == 0) {
-                               b1 = posy*0.5f;
-                               b3 = yo-posy*0.5f;
+                               b1 = posy * 0.5f;
+                               b3 = yo - posy * 0.5f;
                                b2 = y;
 
-                               hyp = abs(y - posy*0.5f);
-                               hyp2 = abs(y - (yo-posy*0.5f));
+                               hyp = abs(y - posy * 0.5f);
+                               hyp2 = abs(y - (yo - posy * 0.5f));
                        }
                        else {
-                               b1 = posy*0.5f - (-angle)*posx*0.5f;
-                               b3 = (yo-posy*0.5f) - (-angle)*(xo-posx*0.5f);
-                               b2 = y - (-angle)*x;
+                               b1 = posy * 0.5f - (-angle) * posx * 0.5f;
+                               b3 = (yo - posy * 0.5f) - (-angle) * (xo - posx * 0.5f);
+                               b2 = y - (-angle) * x;
 
-                               hyp = fabsf(angle*x+y+(-posy*0.5f-angle*posx*0.5f))*wipezone->pythangle;
-                               hyp2 = fabsf(angle*x+y+(-(yo-posy*0.5f)-angle*(xo-posx*0.5f)))*wipezone->pythangle;
+                               hyp = fabsf(angle * x + y + (-posy * 0.5f - angle * posx * 0.5f)) * wipezone->pythangle;
+                               hyp2 = fabsf(angle * x + y + (-(yo - posy * 0.5f) - angle * (xo - posx * 0.5f))) * wipezone->pythangle;
                        }
 
-                       hwidth = minf(hwidth, fabsf(b3-b1)/2.0f);
+                       hwidth = minf(hwidth, fabsf(b3 - b1) / 2.0f);
 
-                       if (b2 < b1 && b2 < b3 ) {
-                               output = in_band(hwidth,hyp,0,1);
+                       if (b2 < b1 && b2 < b3) {
+                               output = in_band(hwidth, hyp, 0, 1);
                        }
-                       else if (b2 > b1 && b2 > b3 ) {
-                               output = in_band(hwidth,hyp2,0,1);
+                       else if (b2 > b1 && b2 > b3) {
+                               output = in_band(hwidth, hyp2, 0, 1);
                        }
                        else {
-                               if (  hyp < hwidth && hyp2 > hwidth )
-                                       output = in_band(hwidth,hyp,1,1);
-                               else if ( hyp > hwidth && hyp2 < hwidth )
-                                         output = in_band(hwidth,hyp2,1,1);
+                               if (hyp < hwidth && hyp2 > hwidth)
+                                       output = in_band(hwidth, hyp, 1, 1);
+                               else if (hyp > hwidth && hyp2 < hwidth)
+                                       output = in_band(hwidth, hyp2, 1, 1);
                                else
-                                         output = in_band(hwidth,hyp2,1,1) * in_band(hwidth,hyp,1,1);
+                                       output = in_band(hwidth, hyp2, 1, 1) * in_band(hwidth, hyp, 1, 1);
                        }
-                       if (!wipe->forward)output = 1-output;
-               break;
+                       if (!wipe->forward) output = 1 - output;
+                       break;
                case DO_CLOCK_WIPE:
                        /*
                         *  temp1: angle of effect center in rads
-                        *  temp2: angle of line through (halfx,halfy) and (x,y) in rads
+                        *  temp2: angle of line through (halfx, halfy) and (x, y) in rads
                         *  temp3: angle of low side of blur
                         *  temp4: angle of high side of blur
                         */
                        output = 1.0f - facf0;
-                       widthf = wipe->edgeWidth*2.0f*(float)M_PI;
+                       widthf = wipe->edgeWidth * 2.0f * (float)M_PI;
                        temp1 = 2.0f * (float)M_PI * facf0;
 
                        if (wipe->forward) {
-                               temp1 = 2.0f*(float)M_PI - temp1;
+                               temp1 = 2.0f * (float)M_PI - temp1;
                        }
 
                        x = x - halfx;
                        y = y - halfy;
 
-                       temp2 = asin(abs(y)/sqrt(x*x + y*y));
+                       temp2 = asin(abs(y) / sqrt(x * x + y * y));
                        if (x <= 0 && y >= 0) temp2 = (float)M_PI - temp2;
-                       else if (x<=0 && y <= 0) temp2 += (float)M_PI;
-                       else if (x >= 0 && y <= 0) temp2 = 2.0f*(float)M_PI - temp2;
+                       else if (x <= 0 && y <= 0) temp2 += (float)M_PI;
+                       else if (x >= 0 && y <= 0) temp2 = 2.0f * (float)M_PI - temp2;
 
                        if (wipe->forward) {
-                               temp3 = temp1-(widthf*0.5f)*facf0;
-                               temp4 = temp1+(widthf*0.5f)*(1-facf0);
+                               temp3 = temp1 - (widthf * 0.5f) * facf0;
+                               temp4 = temp1 + (widthf * 0.5f) * (1 - facf0);
                        }
                        else {
-                               temp3 = temp1-(widthf*0.5f)*(1-facf0);
-                               temp4 = temp1+(widthf*0.5f)*facf0;
+                               temp3 = temp1 - (widthf * 0.5f) * (1 - facf0);
+                               temp4 = temp1 + (widthf * 0.5f) * facf0;
                        }
                        if (temp3 < 0) temp3 = 0;
-                       if (temp4 > 2.0f*(float)M_PI) temp4 = 2.0f*(float)M_PI;
+                       if (temp4 > 2.0f * (float)M_PI) temp4 = 2.0f * (float)M_PI;
 
 
                        if (temp2 < temp3) output = 0;
                        else if (temp2 > temp4) output = 1;
-                       else output = (temp2-temp3)/(temp4-temp3);
+                       else output = (temp2 - temp3) / (temp4 - temp3);
                        if (x == 0 && y == 0) output = 1;
                        if (output != output) output = 1;
                        if (wipe->forward) output = 1 - output;
-               break;
-       /* BOX WIPE IS NOT WORKING YET */
-       /* case DO_CROSS_WIPE: */
-       /* BOX WIPE IS NOT WORKING YET */
+                       break;
+                       /* BOX WIPE IS NOT WORKING YET */
+                       /* case DO_CROSS_WIPE: */
+                       /* BOX WIPE IS NOT WORKING YET */
 #if 0
                case DO_BOX_WIPE: 
-                       if (invert)facf0 = 1-facf0;
+                       if (invert) facf0 = 1 - facf0;
 
-                       width = (int)(wipe->edgeWidth*((xo+yo)/2.0));
-                       hwidth = (float)width/2.0;
-                       if (angle == 0)angle = 0.000001;
-                       b1 = posy/2 - (-angle)*posx/2;
-                       b3 = (yo-posy/2) - (-angle)*(xo-posx/2);
-                       b2 = y - (-angle)*x;
+                       width = (int)(wipe->edgeWidth * ((xo + yo) / 2.0));
+                       hwidth = (float)width / 2.0;
+                       if (angle == 0) angle = 0.000001;
+                       b1 = posy / 2 - (-angle) * posx / 2;
+                       b3 = (yo - posy / 2) - (-angle) * (xo - posx / 2);
+                       b2 = y - (-angle) * x;
 
-                       hyp = abs(angle*x+y+(-posy/2-angle*posx/2))*wipezone->pythangle;
-                       hyp2 = abs(angle*x+y+(-(yo-posy/2)-angle*(xo-posx/2)))*wipezone->pythangle;
+                       hyp = abs(angle * x + y + (-posy / 2 - angle * posx / 2)) * wipezone->pythangle;
+                       hyp2 = abs(angle * x + y + (-(yo - posy / 2) - angle * (xo - posx / 2))) * wipezone->pythangle;
 
-                       temp1 = xo*(1-facf0/2)-xo*facf0/2;
-                       temp2 = yo*(1-facf0/2)-yo*facf0/2;
-                       pointdist = sqrt(temp1*temp1 + temp2*temp2);
+                       temp1 = xo * (1 - facf0 / 2) - xo * facf0 / 2;
+                       temp2 = yo * (1 - facf0 / 2) - yo * facf0 / 2;
+                       pointdist = sqrt(temp1 * temp1 + temp2 * temp2);
 
-                       if (b2 < b1 && b2 < b3 ) {
+                       if (b2 < b1 && b2 < b3) {
                                if (hwidth < pointdist)
-                                       output = in_band(wipezone,hwidth,hyp,facf0,0,1);
-               }
-               else if (b2 > b1 && b2 > b3 ) {
+                                       output = in_band(wipezone, hwidth, hyp, facf0, 0, 1);
+                       }
+                       else if (b2 > b1 && b2 > b3) {
                                if (hwidth < pointdist)
-                                       output = in_band(wipezone,hwidth,hyp2,facf0,0,1);       
-               }
-               else {
-                               if ( hyp < hwidth && hyp2 > hwidth )
-                                       output = in_band(wipezone,hwidth,hyp,facf0,1,1);
-                               else if ( hyp > hwidth && hyp2 < hwidth )
-                                        output = in_band(wipezone,hwidth,hyp2,facf0,1,1);
+                                       output = in_band(wipezone, hwidth, hyp2, facf0, 0, 1);
+                       }
+                       else {
+                               if (hyp < hwidth && hyp2 > hwidth)
+                                       output = in_band(wipezone, hwidth, hyp, facf0, 1, 1);
+                               else if (hyp > hwidth && hyp2 < hwidth)
+                                       output = in_band(wipezone, hwidth, hyp2, facf0, 1, 1);
                                else
-                                        output = in_band(wipezone,hwidth,hyp2,facf0,1,1) * in_band(wipezone,hwidth,hyp,facf0,1,1);
+                                       output = in_band(wipezone, hwidth, hyp2, facf0, 1, 1) * in_band(wipezone, hwidth, hyp, facf0, 1, 1);
                        }
 
-                       if (invert)facf0 = 1-facf0;
-                       angle = -1/angle;
-                       b1 = posy/2 - (-angle)*posx/2;
-                       b3 = (yo-posy/2) - (-angle)*(xo-posx/2);
-                       b2 = y - (-angle)*x;
+                       if (invert) facf0 = 1 - facf0;
+                       angle = -1 / angle;
+                       b1 = posy / 2 - (-angle) * posx / 2;
+                       b3 = (yo - posy / 2) - (-angle) * (xo - posx / 2);
+                       b2 = y - (-angle) * x;
 
-                       hyp = abs(angle*x+y+(-posy/2-angle*posx/2))*wipezone->pythangle;
-                       hyp2 = abs(angle*x+y+(-(yo-posy/2)-angle*(xo-posx/2)))*wipezone->pythangle;
+                       hyp = abs(angle * x + y + (-posy / 2 - angle * posx / 2)) * wipezone->pythangle;
+                       hyp2 = abs(angle * x + y + (-(yo - posy / 2) - angle * (xo - posx / 2))) * wipezone->pythangle;
 
-                       if (b2 < b1 && b2 < b3 ) {
+                       if (b2 < b1 && b2 < b3) {
                                if (hwidth < pointdist)
-                                       output *= in_band(wipezone,hwidth,hyp,facf0,0,1);
-               }
-               else if (b2 > b1 && b2 > b3 ) {
+                                       output *= in_band(wipezone, hwidth, hyp, facf0, 0, 1);
+                       }
+                       else if (b2 > b1 && b2 > b3) {
                                if (hwidth < pointdist)
-                                       output *= in_band(wipezone,hwidth,hyp2,facf0,0,1);      
-               }
-               else {
-                               if ( hyp < hwidth && hyp2 > hwidth )
-                                       output *= in_band(wipezone,hwidth,hyp,facf0,1,1);
-                               else if ( hyp > hwidth && hyp2 < hwidth )
-                                       output *= in_band(wipezone,hwidth,hyp2,facf0,1,1);
+                                       output *= in_band(wipezone, hwidth, hyp2, facf0, 0, 1);
+                       }
+                       else {
+                               if (hyp < hwidth && hyp2 > hwidth)
+                                       output *= in_band(wipezone, hwidth, hyp, facf0, 1, 1);
+                               else if (hyp > hwidth && hyp2 < hwidth)
+                                       output *= in_band(wipezone, hwidth, hyp2, facf0, 1, 1);
                                else
-                                       output *= in_band(wipezone,hwidth,hyp2,facf0,1,1) * in_band(wipezone,hwidth,hyp,facf0,1,1);
+                                       output *= in_band(wipezone, hwidth, hyp2, facf0, 1, 1) * in_band(wipezone, hwidth, hyp, facf0, 1, 1);
                        }
 
-               break;
+                       break;
 #endif
                case DO_IRIS_WIPE:
                        if (xo > yo) yo = xo;
                        else xo = yo;
 
-                       if (!wipe->forward) facf0 = 1-facf0;
+                       if (!wipe->forward) facf0 = 1 - facf0;
 
                        width = wipezone->width;
-                       hwidth = width*0.5f;
+                       hwidth = width * 0.5f;
 
-                       temp1 = (halfx-(halfx)*facf0);
-                       pointdist = sqrt(temp1*temp1 + temp1*temp1);
+                       temp1 = (halfx - (halfx) * facf0);
+                       pointdist = sqrt(temp1 * temp1 + temp1 * temp1);
 
-                       temp2 = sqrt((halfx-x)*(halfx-x) + (halfy-y)*(halfy-y));
-                       if (temp2 > pointdist) output = in_band(hwidth,fabs(temp2-pointdist),0,1);
-                       else output = in_band(hwidth,fabs(temp2-pointdist),1,1);
+                       temp2 = sqrt((halfx - x) * (halfx - x) + (halfy - y) * (halfy - y));
+                       if (temp2 > pointdist) output = in_band(hwidth, fabs(temp2 - pointdist), 0, 1);
+                       else output = in_band(hwidth, fabs(temp2 - pointdist), 1, 1);
 
-                       if (!wipe->forward) output = 1-output;
+                       if (!wipe->forward) output = 1 - output;
                        
-               break;
+                       break;
        }
        if (output < 0) output = 0;
        else if (output > 1) output = 1;
@@ -1871,8 +1506,10 @@ static float check_zone(WipeZone *wipezone, int x, int y,
 
 static void init_wipe_effect(Sequence *seq)
 {
-       if (seq->effectdata)MEM_freeN(seq->effectdata);
-       seq->effectdata = MEM_callocN(sizeof(struct WipeVars), "wipevars");
+       if (seq->effectdata)
+               MEM_freeN(seq->effectdata);
+
+       seq->effectdata = MEM_callocN(sizeof(WipeVars), "wipevars");
 }
 
 static int num_inputs_wipe(void)
@@ -1882,7 +1519,9 @@ static int num_inputs_wipe(void)
 
 static void free_wipe_effect(Sequence *seq)
 {
-       if (seq->effectdata)MEM_freeN(seq->effectdata);
+       if (seq->effectdata)
+               MEM_freeN(seq->effectdata);
+
        seq->effectdata = NULL;
 }
 
@@ -1891,10 +1530,8 @@ static void copy_wipe_effect(Sequence *dst, Sequence *src)
        dst->effectdata = MEM_dupallocN(src->effectdata);
 }
 
-static void do_wipe_effect_byte(Sequence *seq, float facf0, float UNUSED(facf1), 
-                               int x, int y, 
-                               unsigned char *rect1, 
-                               unsigned char *rect2, unsigned char *out)
+static void do_wipe_effect_byte(Sequence *seq, float facf0, float UNUSED(facf1),  int x, int y, unsigned char *rect1,
+                                unsigned char *rect2, unsigned char *out)
 {
        WipeZone wipezone;
        WipeVars *wipe = (WipeVars *)seq->effectdata;
@@ -1909,15 +1546,15 @@ static void do_wipe_effect_byte(Sequence *seq, float facf0, float UNUSED(facf1),
 
        xo = x;
        yo = y;
-       for (y=0;y<yo;y++) {
-               for (x=0;x<xo;x++) {
-                       float check = check_zone(&wipezone,x,y,seq,facf0);
+       for (y = 0; y < yo; y++) {
+               for (x = 0; x < xo; x++) {
+                       float check = check_zone(&wipezone, x, y, seq, facf0);
                        if (check) {
                                if (rt1) {
-                                       rt[0] = (int)(rt1[0]*check)+ (int)(rt2[0]*(1-check));
-                                       rt[1] = (int)(rt1[1]*check)+ (int)(rt2[1]*(1-check));
-                                       rt[2] = (int)(rt1[2]*check)+ (int)(rt2[2]*(1-check));
-                                       rt[3] = (int)(rt1[3]*check)+ (int)(rt2[3]*(1-check));
+                                       rt[0] = (int)(rt1[0] * check) + (int)(rt2[0] * (1 - check));
+                                       rt[1] = (int)(rt1[1] * check) + (int)(rt2[1] * (1 - check));
+                                       rt[2] = (int)(rt1[2] * check) + (int)(rt2[2] * (1 - check));
+                                       rt[3] = (int)(rt1[3] * check) + (int)(rt2[3] * (1 - check));
                                }
                                else {
                                        rt[0] = 0;
@@ -1941,21 +1578,19 @@ static void do_wipe_effect_byte(Sequence *seq, float facf0, float UNUSED(facf1),
                                }
                        }
 
-                       rt+=4;
-                       if (rt1 !=NULL) {
-                               rt1+=4;
+                       rt += 4;
+                       if (rt1 != NULL) {
+                               rt1 += 4;
                        }
-                       if (rt2 !=NULL) {
-                               rt2+=4;
+                       if (rt2 != NULL) {
+                               rt2 += 4;
                        }
                }
        }
 }
 
-static void do_wipe_effect_float(Sequence *seq, float facf0, float UNUSED(facf1), 
-                                int x, int y, 
-                                float *rect1, 
-                                float *rect2, float *out)
+static void do_wipe_effect_float(Sequence *seq, float facf0, float UNUSED(facf1), int x, int y, float *rect1,
+                                 float *rect2, float *out)
 {
        WipeZone wipezone;
        WipeVars *wipe = (WipeVars *)seq->effectdata;
@@ -1970,15 +1605,15 @@ static void do_wipe_effect_float(Sequence *seq, float facf0, float UNUSED(facf1)
 
        xo = x;
        yo = y;
-       for (y=0;y<yo;y++) {
-               for (x=0;x<xo;x++) {
-                       float check = check_zone(&wipezone,x,y,seq,facf0);
+       for (y = 0; y < yo; y++) {
+               for (x = 0; x < xo; x++) {
+                       float check = check_zone(&wipezone, x, y, seq, facf0);
                        if (check) {
                                if (rt1) {
-                                       rt[0] = rt1[0]*check+ rt2[0]*(1-check);
-                                       rt[1] = rt1[1]*check+ rt2[1]*(1-check);
-                                       rt[2] = rt1[2]*check+ rt2[2]*(1-check);
-                                       rt[3] = rt1[3]*check+ rt2[3]*(1-check);
+                                       rt[0] = rt1[0] * check + rt2[0] * (1 - check);
+                                       rt[1] = rt1[1] * check + rt2[1] * (1 - check);
+                                       rt[2] = rt1[2] * check + rt2[2] * (1 - check);
+                                       rt[3] = rt1[3] * check + rt2[3] * (1 - check);
                                }
                                else {
                                        rt[0] = 0;
@@ -2002,63 +1637,58 @@ static void do_wipe_effect_float(Sequence *seq, float facf0, float UNUSED(facf1)
                                }
                        }
 
-                       rt+=4;
-                       if (rt1 !=NULL) {
-                               rt1+=4;
+                       rt += 4;
+                       if (rt1 != NULL) {
+                               rt1 += 4;
                        }
-                       if (rt2 !=NULL) {
-                               rt2+=4;
+                       if (rt2 != NULL) {
+                               rt2 += 4;
                        }
                }
        }
 }
 
-static struct ImBuf * do_wipe_effect(
-       SeqRenderData context, Sequence *seq, float UNUSED(cfra),
-       float facf0, float facf1, 
-       struct ImBuf *ibuf1, struct ImBuf *ibuf2, 
-       struct ImBuf *ibuf3)
+static ImBuf *do_wipe_effect(SeqRenderData context, Sequence *seq, float UNUSED(cfra), float facf0, float facf1,
+                             ImBuf *ibuf1, ImBuf *ibuf2, ImBuf *ibuf3)
 {
-       struct ImBuf * out = prepare_effect_imbufs(context,ibuf1, ibuf2, ibuf3);
+       ImBuf *out = prepare_effect_imbufs(context, ibuf1, ibuf2, ibuf3);
 
        if (out->rect_float) {
-               do_wipe_effect_float(seq,
-                                    facf0, facf1, context.rectx, context.recty,
-                                    ibuf1->rect_float, ibuf2->rect_float,
-                                    out->rect_float);
+               do_wipe_effect_float(seq, facf0, facf1, context.rectx, context.recty, ibuf1->rect_float,
+                                    ibuf2->rect_float, out->rect_float);
        }
        else {
-               do_wipe_effect_byte(seq,
-                                   facf0, facf1, context.rectx, context.recty,
-                                   (unsigned char*) ibuf1->rect, (unsigned char*) ibuf2->rect,
-                                   (unsigned char*) out->rect);
+               do_wipe_effect_byte(seq, facf0, facf1, context.rectx, context.recty, (unsigned char *) ibuf1->rect,
+                                   (unsigned char *) ibuf2->rect, (unsigned char *) out->rect);
        }
 
        return out;
 }
-/* **********************************************************************
- * TRANSFORM
- * ********************************************************************** */
+
+/*********************** Transform *************************/
+
 static void init_transform_effect(Sequence *seq)
 {
        TransformVars *transform;
 
-       if (seq->effectdata)MEM_freeN(seq->effectdata);
-       seq->effectdata = MEM_callocN(sizeof(struct TransformVars), "transformvars");
+       if (seq->effectdata)
+               MEM_freeN(seq->effectdata);
+
+       seq->effectdata = MEM_callocN(sizeof(TransformVars), "transformvars");
 
-       transform = (TransformVars *)seq->effectdata;
+       transform = (TransformVars *) seq->effectdata;
 
        transform->ScalexIni = 1.0f;
        transform->ScaleyIni = 1.0f;
 
-       transform->xIni=0.0f;
-       transform->yIni=0.0f;
+       transform->xIni = 0.0f;
+       transform->yIni = 0.0f;
 
-       transform->rotIni=0.0f;
+       transform->rotIni = 0.0f;
        
-       transform->interpolation=1;
-       transform->percent=1;
-       transform->uniform_scale=0;
+       transform->interpolation = 1;
+       transform->percent = 1;
+       transform->uniform_scale = 0;
 }
 
 static int num_inputs_transform(void)
@@ -2068,7 +1698,7 @@ static int num_inputs_transform(void)
 
 static void free_transform_effect(Sequence *seq)
 {
-       if (seq->effectdata)MEM_freeN(seq->effectdata);
+       if (seq->effectdata) MEM_freeN(seq->effectdata);
        seq->effectdata = NULL;
 }
 
@@ -2077,63 +1707,60 @@ static void copy_transform_effect(Sequence *dst, Sequence *src)
        dst->effectdata = MEM_dupallocN(src->effectdata);
 }
 
-static void transform_image(int x, int y, struct ImBuf *ibuf1, struct ImBuf *out, 
-                           float scale_x, float scale_y, float translate_x, float translate_y, 
-                           float rotate, int interpolation)
+static void transform_image(int x, int y, ImBuf *ibuf1, ImBuf *out,  float scale_x, float scale_y,
+                            float translate_x, float translate_y, float rotate, int interpolation)
 {
        int xo, yo, xi, yi;
        float xt, yt, xr, yr;
-       float s,c;
+       float s, c;
 
        xo = x;
        yo = y;
        
-       // Rotate
-       s= sin(rotate);
-       c= cos(rotate);
+       /* Rotate */
+       s = sin(rotate);
+       c = cos(rotate);
 
        for (yi = 0; yi < yo; yi++) {
                for (xi = 0; xi < xo; xi++) {
+                       /* translate point */
+                       xt = xi - translate_x;
+                       yt = yi - translate_y;
 
-                       //translate point
-                       xt = xi-translate_x;
-                       yt = yi-translate_y;
-
-                       //rotate point with center ref
-                       xr =  c*xt + s*yt;
-                       yr = -s*xt + c*yt;
+                       /* rotate point with center ref */
+                       xr =  c * xt + s * yt;
+                       yr = -s * xt + c * yt;
 
-                       //scale point with center ref
+                       /* scale point with center ref */
                        xt = xr / scale_x;
                        yt = yr / scale_y;
 
-                       //undo reference center point 
+                       /* undo reference center point  */
                        xt += (xo / 2.0f);
                        yt += (yo / 2.0f);
 
-                       //interpolate
-                       switch(interpolation) {
-                       case 0:
-                               neareast_interpolation(ibuf1,out, xt,yt,xi,yi);
-                               break;
-                       case 1:
-                               bilinear_interpolation(ibuf1,out, xt,yt,xi,yi);
-                               break;
-                       case 2:
-                               bicubic_interpolation(ibuf1,out, xt,yt,xi,yi);
-                               break;
+                       /* interpolate */
+                       switch (interpolation) {
+                               case 0:
+                                       neareast_interpolation(ibuf1, out, xt, yt, xi, yi);
+                                       break;
+                               case 1:
+                                       bilinear_interpolation(ibuf1, out, xt, yt, xi, yi);
+                                       break;
+                               case 2:
+                                       bicubic_interpolation(ibuf1, out, xt, yt, xi, yi);
+                                       break;
                        }
                }
        }
 }
 
-static void do_transform(Scene *scene, Sequence *seq, float UNUSED(facf0), int x, int y, 
-                         struct ImBuf *ibuf1,struct ImBuf *out)
+static void do_transform(Scene *scene, Sequence *seq, float UNUSED(facf0), int x, int y,  ImBuf *ibuf1, ImBuf *out)
 {
-       TransformVars *transform = (TransformVars *)seq->effectdata;
+       TransformVars *transform = (TransformVars *) seq->effectdata;
        float scale_x, scale_y, translate_x, translate_y, rotate_radians;
        
-       // Scale
+       /* Scale */
        if (transform->uniform_scale) {
                scale_x = scale_y = transform->ScalexIni;
        }
@@ -2142,47 +1769,38 @@ static void do_transform(Scene *scene, Sequence *seq, float UNUSED(facf0), int x
                scale_y = transform->ScaleyIni;
        }
 
-       // Translate
+       /* Translate */
        if (!transform->percent) {
-               float rd_s = (scene->r.size/100.0f);
+               float rd_s = (scene->r.size / 100.0f);
 
-               translate_x = transform->xIni*rd_s+(x/2.0f);
-               translate_y = transform->yIni*rd_s+(y/2.0f);
+               translate_x = transform->xIni * rd_s + (x / 2.0f);
+               translate_y = transform->yIni * rd_s + (y / 2.0f);
        }
        else {
-               translate_x = x*(transform->xIni/100.0f)+(x/2.0f);
-               translate_y = y*(transform->yIni/100.0f)+(y/2.0f);
+               translate_x = x * (transform->xIni / 100.0f) + (x / 2.0f);
+               translate_y = y * (transform->yIni / 100.0f) + (y / 2.0f);
        }
-       
-       // Rotate
+
+       /* Rotate */
        rotate_radians = DEG2RADF(transform->rotIni);
 
-       transform_image(x,y, ibuf1, out, scale_x, scale_y, translate_x, translate_y, rotate_radians, transform->interpolation);
+       transform_image(x, y, ibuf1, out, scale_x, scale_y, translate_x, translate_y, rotate_radians, transform->interpolation);
 }
 
 
-static struct ImBuf * do_transform_effect(
-       SeqRenderData context, Sequence *seq,float UNUSED(cfra),
-       float facf0, float UNUSED(facf1), 
-       struct ImBuf *ibuf1, struct ImBuf *ibuf2, 
-       struct ImBuf *ibuf3)
+static ImBuf *do_transform_effect(SeqRenderData context, Sequence *seq, float UNUSED(cfra), float facf0,
+                                  float UNUSED(facf1), ImBuf *ibuf1, ImBuf *ibuf2, ImBuf *ibuf3)
 {
-       struct ImBuf * out = prepare_effect_imbufs(context,ibuf1, ibuf2, ibuf3);
+       ImBuf *out = prepare_effect_imbufs(context, ibuf1, ibuf2, ibuf3);
 
-       do_transform(context.scene, seq, facf0, 
-                    context.rectx, context.recty, ibuf1, out);
+       do_transform(context.scene, seq, facf0, context.rectx, context.recty, ibuf1, out);
 
        return out;
 }
 
+/*********************** Glow *************************/
 
-/* **********************************************************************
- * GLOW
- * ********************************************************************** */
-
-static void RVBlurBitmap2_byte ( unsigned char* map, int width,int height,
-                                float blur,
-                                int quality)
+static void RVBlurBitmap2_byte(unsigned char *map, int width, int height, float blur, int quality)
 /*     MUUUCCH better than the previous blur. */
 /*     We do the blurring in two passes which is a whole lot faster. */
 /*     I changed the math arount to implement an actual Gaussian */
@@ -2192,166 +1810,157 @@ static void RVBlurBitmap2_byte ( unsigned char* map, int width,int height,
 /*     a small bitmap.  Avoid avoid avoid. */
 /*=============================== */
 {
-       unsigned char*  temp=NULL,*swap;
-       float   *filter=NULL;
-       int     x,y,i,fx,fy;
-       int     index, ix, halfWidth;
-       float   fval, k, curColor[3], curColor2[3], weight=0;
+       unsigned char *temp = NULL, *swap;
+       float   *filter = NULL;
+       int x, y, i, fx, fy;
+       int index, ix, halfWidth;
+       float fval, k, curColor[3], curColor2[3], weight = 0;
 
-       /*      If we're not really blurring, bail out */
-       if (blur<=0)
+       /* If we're not really blurring, bail out */
+       if (blur <= 0)
                return;
 
-       /*      Allocate memory for the tempmap and the blur filter matrix */
-       temp= MEM_mallocN( (width*height*4), "blurbitmaptemp");
+       /*Allocate memory for the tempmap and the blur filter matrix */
+       temp = MEM_mallocN((width * height * 4), "blurbitmaptemp");
        if (!temp)
                return;
 
-       /*      Allocate memory for the filter elements */
-       halfWidth = ((quality+1)*blur);
-       filter = (float *)MEM_mallocN(sizeof(float)*halfWidth*2, "blurbitmapfilter");
+       /*Allocate memory for the filter elements */
+       halfWidth = ((quality + 1) * blur);
+       filter = (float *)MEM_mallocN(sizeof(float) * halfWidth * 2, "blurbitmapfilter");
        if (!filter) {
-               MEM_freeN (temp);
+               MEM_freeN(temp);
                return;
        }
 
-       /*      Apparently we're calculating a bell curve */
-       /*      based on the standard deviation (or radius) */
-       /*      This code is based on an example */
-       /*      posted to comp.graphics.algorithms by */
-       /*      Blancmange (bmange@airdmhor.gen.nz) */
+       /* Apparently we're calculating a bell curve based on the standard deviation (or radius)
+        * This code is based on an example posted to comp.graphics.algorithms by
+        * Blancmange (bmange@airdmhor.gen.nz)
+        */
 
-       k = -1.0f/(2.0f*(float)M_PI*blur*blur);
-       for (ix = 0;ix< halfWidth;ix++) {
-               weight = (float)exp(k*(ix*ix));
+       k = -1.0f / (2.0f * (float)M_PI * blur * blur);
+       for (ix = 0; ix < halfWidth; ix++) {
+               weight = (float)exp(k * (ix * ix));
                filter[halfWidth - ix] = weight;
                filter[halfWidth + ix] = weight;
        }
        filter[0] = weight;
 
-       /*      Normalize the array */
-       fval=0;
-       for (ix = 0;ix< halfWidth*2;ix++)
-               fval+=filter[ix];
+       /* Normalize the array */
+       fval = 0;
+       for (ix = 0; ix < halfWidth * 2; ix++)
+               fval += filter[ix];
 
-       for (ix = 0;ix< halfWidth*2;ix++)
-               filter[ix]/=fval;
+       for (ix = 0; ix < halfWidth * 2; ix++)
+               filter[ix] /= fval;
 
-       /*      Blur the rows */
-       for (y=0;y<height;y++) {
-               /*      Do the left & right strips */
-               for (x=0;x<halfWidth;x++) {
-                       index=(x+y*width)*4;
-                       fx=0;
+       /* Blur the rows */
+       for (y = 0; y < height; y++) {
+               /* Do the left & right strips */
+               for (x = 0; x < halfWidth; x++) {
+                       index = (x + y * width) * 4;
+                       fx = 0;
                        zero_v3(curColor);
                        zero_v3(curColor2);
 
-                       for (i=x-halfWidth;i<x+halfWidth;i++) {
-                               if ((i>=0)&&(i<width)) {
-                                       curColor[0]+=map[(i+y*width)*4+GlowR]*filter[fx];
-                                       curColor[1]+=map[(i+y*width)*4+GlowG]*filter[fx];
-                                       curColor[2]+=map[(i+y*width)*4+GlowB]*filter[fx];
-
-                                       curColor2[0]+=map[(width-1-i+y*width)*4+GlowR] *
-                                               filter[fx];
-                                       curColor2[1]+=map[(width-1-i+y*width)*4+GlowG] *
-                                               filter[fx];
-                                       curColor2[2]+=map[(width-1-i+y*width)*4+GlowB] *
-                                               filter[fx];
+                       for (i = x - halfWidth; i < x + halfWidth; i++) {
+                               if ((i >= 0) && (i < width)) {
+                                       curColor[0] += map[(i + y * width) * 4 + GlowR] * filter[fx];
+                                       curColor[1] += map[(i + y * width) * 4 + GlowG] * filter[fx];
+                                       curColor[2] += map[(i + y * width) * 4 + GlowB] * filter[fx];
+
+                                       curColor2[0] += map[(width - 1 - i + y * width) * 4 + GlowR] * filter[fx];
+                                       curColor2[1] += map[(width - 1 - i + y * width) * 4 + GlowG] * filter[fx];
+                                       curColor2[2] += map[(width - 1 - i + y * width) * 4 + GlowB] * filter[fx];
                                }
                                fx++;
                        }
-                       temp[index+GlowR]=curColor[0];
-                       temp[index+GlowG]=curColor[1];
-                       temp[index+GlowB]=curColor[2];
+                       temp[index + GlowR] = curColor[0];
+                       temp[index + GlowG] = curColor[1];
+                       temp[index + GlowB] = curColor[2];
 
-                       temp[((width-1-x+y*width)*4)+GlowR]=curColor2[0];
-                       temp[((width-1-x+y*width)*4)+GlowG]=curColor2[1];
-                       temp[((width-1-x+y*width)*4)+GlowB]=curColor2[2];
+                       temp[((width - 1 - x + y * width) * 4) + GlowR] = curColor2[0];
+                       temp[((width - 1 - x + y * width) * 4) + GlowG] = curColor2[1];
+                       temp[((width - 1 - x + y * width) * 4) + GlowB] = curColor2[2];
 
                }
-               /*      Do the main body */
-               for (x=halfWidth;x<width-halfWidth;x++) {
-                       index=(x+y*width)*4;
-                       fx=0;
+
+               /* Do the main body */
+               for (x = halfWidth; x < width - halfWidth; x++) {
+                       index = (x + y * width) * 4;
+                       fx = 0;
                        zero_v3(curColor);
-                       for (i=x-halfWidth;i<x+halfWidth;i++) {
-                               curColor[0]+=map[(i+y*width)*4+GlowR]*filter[fx];
-                               curColor[1]+=map[(i+y*width)*4+GlowG]*filter[fx];
-                               curColor[2]+=map[(i+y*width)*4+GlowB]*filter[fx];
+                       for (i = x - halfWidth; i < x + halfWidth; i++) {
+                               curColor[0] += map[(i + y * width) * 4 + GlowR] * filter[fx];
+                               curColor[1] += map[(i + y * width) * 4 + GlowG] * filter[fx];
+                               curColor[2] += map[(i + y * width) * 4 + GlowB] * filter[fx];
                                fx++;
                        }
-                       temp[index+GlowR]=curColor[0];
-                       temp[index+GlowG]=curColor[1];
-                       temp[index+GlowB]=curColor[2];
+                       temp[index + GlowR] = curColor[0];
+                       temp[index + GlowG] = curColor[1];
+                       temp[index + GlowB] = curColor[2];
                }
        }
 
-       /*      Swap buffers */
-       swap=temp;temp=map;map=swap;
+       /* Swap buffers */
+       swap = temp; temp = map; map = swap;
 
-
-       /*      Blur the columns */
-       for (x=0;x<width;x++) {
-               /*      Do the top & bottom strips */
-               for (y=0;y<halfWidth;y++) {
-                       index=(x+y*width)*4;
-                       fy=0;
+       /* Blur the columns */
+       for (x = 0; x < width; x++) {
+               /* Do the top & bottom strips */
+               for (y = 0; y < halfWidth; y++) {
+                       index = (x + y * width) * 4;
+                       fy = 0;
                        zero_v3(curColor);
                        zero_v3(curColor2);
-                       for (i=y-halfWidth;i<y+halfWidth;i++) {
-                               if ((i>=0)&&(i<height)) {
-                                       /*      Bottom */
-                                       curColor[0]+=map[(x+i*width)*4+GlowR]*filter[fy];
-                                       curColor[1]+=map[(x+i*width)*4+GlowG]*filter[fy];
-                                       curColor[2]+=map[(x+i*width)*4+GlowB]*filter[fy];
-
-                                       /*      Top */
-                                       curColor2[0]+=map[(x+(height-1-i)*width) *
-                                               4+GlowR]*filter[fy];
-                                       curColor2[1]+=map[(x+(height-1-i)*width) *
-                                               4+GlowG]*filter[fy];
-                                       curColor2[2]+=map[(x+(height-1-i)*width) *
-                                               4+GlowB]*filter[fy];
+                       for (i = y - halfWidth; i < y + halfWidth; i++) {
+                               if ((i >= 0) && (i < height)) {
+                                       /* Bottom */
+                                       curColor[0] += map[(x + i * width) * 4 + GlowR] * filter[fy];
+                                       curColor[1] += map[(x + i * width) * 4 + GlowG] * filter[fy];
+                                       curColor[2] += map[(x + i * width) * 4 + GlowB] * filter[fy];
+
+                                       /* Top */
+                                       curColor2[0] += map[(x + (height - 1 - i) * width) * 4 + GlowR] * filter[fy];
+                                       curColor2[1] += map[(x + (height - 1 - i) * width) * 4 + GlowG] * filter[fy];
+                                       curColor2[2] += map[(x + (height - 1 - i) * width) * 4 + GlowB] * filter[fy];
                                }
                                fy++;
                        }
-                       temp[index+GlowR]=curColor[0];
-                       temp[index+GlowG]=curColor[1];
-                       temp[index+GlowB]=curColor[2];
-                       temp[((x+(height-1-y)*width)*4)+GlowR]=curColor2[0];
-                       temp[((x+(height-1-y)*width)*4)+GlowG]=curColor2[1];
-                       temp[((x+(height-1-y)*width)*4)+GlowB]=curColor2[2];
+                       temp[index + GlowR] = curColor[0];
+                       temp[index + GlowG] = curColor[1];
+                       temp[index + GlowB] = curColor[2];
+                       temp[((x + (height - 1 - y) * width) * 4) + GlowR] = curColor2[0];
+                       temp[((x + (height - 1 - y) * width) * 4) + GlowG] = curColor2[1];
+                       temp[((x + (height - 1 - y) * width) * 4) + GlowB] = curColor2[2];
                }
-               /*      Do the main body */
-               for (y=halfWidth;y<height-halfWidth;y++) {
-                       index=(x+y*width)*4;
-                       fy=0;
+
+               /* Do the main body */
+               for (y = halfWidth; y < height - halfWidth; y++) {
+                       index = (x + y * width) * 4;
+                       fy = 0;
                        zero_v3(curColor);
-                       for (i=y-halfWidth;i<y+halfWidth;i++) {
-                               curColor[0]+=map[(x+i*width)*4+GlowR]*filter[fy];
-                               curColor[1]+=map[(x+i*width)*4+GlowG]*filter[fy];
-                               curColor[2]+=map[(x+i*width)*4+GlowB]*filter[fy];
+                       for (i = y - halfWidth; i < y + halfWidth; i++) {
+                               curColor[0] += map[(x + i * width) * 4 + GlowR] * filter[fy];
+                               curColor[1] += map[(x + i * width) * 4 + GlowG] * filter[fy];
+                               curColor[2] += map[(x + i * width) * 4 + GlowB] * filter[fy];
                                fy++;
                        }
-                       temp[index+GlowR]=curColor[0];
-                       temp[index+GlowG]=curColor[1];
-                       temp[index+GlowB]=curColor[2];
+                       temp[index + GlowR] = curColor[0];
+                       temp[index + GlowG] = curColor[1];
+                       temp[index + GlowB] = curColor[2];
                }
        }
 
+       /* Swap buffers */
+       swap = temp; temp = map; /* map = swap; */ /* UNUSED */
 
-       /*      Swap buffers */
-       swap=temp;temp=map; /* map=swap; */ /* UNUSED */
-
-       /*      Tidy up  */
-       MEM_freeN (filter);
-       MEM_freeN (temp);
+       /* Tidy up */
+       MEM_freeN(filter);
+       MEM_freeN(temp);
 }
 
-static void RVBlurBitmap2_float ( float* map, int width,int height,
-                                 float blur,
-                                 int quality)
+static void RVBlurBitmap2_float(float *map, int width, int height, float blur, int quality)
 /*     MUUUCCH better than the previous blur. */
 /*     We do the blurring in two passes which is a whole lot faster. */
 /*     I changed the math arount to implement an actual Gaussian */
@@ -2361,162 +1970,155 @@ static void RVBlurBitmap2_float ( float* map, int width,int height,
 /*     a small bitmap.  Avoid avoid avoid. */
 /*=============================== */
 {
-       float*  temp=NULL,*swap;
-       float   *filter=NULL;
-       int     x,y,i,fx,fy;
-       int     index, ix, halfWidth;
-       float   fval, k, curColor[3], curColor2[3], weight=0;
+       float *temp = NULL, *swap;
+       float *filter = NULL;
+       int x, y, i, fx, fy;
+       int index, ix, halfWidth;
+       float fval, k, curColor[3], curColor2[3], weight = 0;
 
-       /*      If we're not really blurring, bail out */
-       if (blur<=0)
+       /* If we're not really blurring, bail out */
+       if (blur <= 0)
                return;
 
-       /*      Allocate memory for the tempmap and the blur filter matrix */
-       temp= MEM_mallocN( (width*height*4*sizeof(float)), "blurbitmaptemp");
+       /* Allocate memory for the tempmap and the blur filter matrix */
+       temp = MEM_mallocN((width * height * 4 * sizeof(float)), "blurbitmaptemp");
        if (!temp)
                return;
 
-       /*      Allocate memory for the filter elements */
-       halfWidth = ((quality+1)*blur);
-       filter = (float *)MEM_mallocN(sizeof(float)*halfWidth*2, "blurbitmapfilter");
+       /* Allocate memory for the filter elements */
+       halfWidth = ((quality + 1) * blur);
+       filter = (float *)MEM_mallocN(sizeof(float) * halfWidth * 2, "blurbitmapfilter");
        if (!filter) {
-               MEM_freeN (temp);
+               MEM_freeN(temp);
                return;
        }
 
-       /*      Apparently we're calculating a bell curve */
-       /*      based on the standard deviation (or radius) */
-       /*      This code is based on an example */
-       /*      posted to comp.graphics.algorithms by */
-       /*      Blancmange (bmange@airdmhor.gen.nz) */
+       /* Apparently we're calculating a bell curve based on the standard deviation (or radius)
+        * This code is based on an example posted to comp.graphics.algorithms by
+        * Blancmange (bmange@airdmhor.gen.nz)
+        */
 
-       k = -1.0f/(2.0f*(float)M_PI*blur*blur);
+       k = -1.0f / (2.0f * (float)M_PI * blur * blur);
 
-       for (ix = 0;ix< halfWidth;ix++) {
-               weight = (float)exp(k*(ix*ix));
+       for (ix = 0; ix < halfWidth; ix++) {
+               weight = (float)exp(k * (ix * ix));
                filter[halfWidth - ix] = weight;
                filter[halfWidth + ix] = weight;
        }
        filter[0] = weight;
 
-       /*      Normalize the array */
-       fval=0;
-       for (ix = 0;ix< halfWidth*2;ix++)
-               fval+=filter[ix];
-
-       for (ix = 0;ix< halfWidth*2;ix++)
-               filter[ix]/=fval;
-
-       /*      Blur the rows */
-       for (y=0;y<height;y++) {
-               /*      Do the left & right strips */
-               for (x=0;x<halfWidth;x++) {
-                       index=(x+y*width)*4;
-                       fx=0;
-                       curColor[0]=curColor[1]=curColor[2]=0.0f;
-                       curColor2[0]=curColor2[1]=curColor2[2]=0.0f;
-
-                       for (i=x-halfWidth;i<x+halfWidth;i++) {
-                               if ((i>=0)&&(i<width)) {
-                                       curColor[0]+=map[(i+y*width)*4+GlowR]*filter[fx];
-                                       curColor[1]+=map[(i+y*width)*4+GlowG]*filter[fx];
-                                       curColor[2]+=map[(i+y*width)*4+GlowB]*filter[fx];
-
-                                       curColor2[0]+=map[(width-1-i+y*width)*4+GlowR] *
-                                               filter[fx];
-                                       curColor2[1]+=map[(width-1-i+y*width)*4+GlowG] *
-                                               filter[fx];
-                                       curColor2[2]+=map[(width-1-i+y*width)*4+GlowB] *
-                                               filter[fx];
+       /* Normalize the array */
+       fval = 0;
+       for (ix = 0; ix < halfWidth * 2; ix++)
+               fval += filter[ix];
+
+       for (ix = 0; ix < halfWidth * 2; ix++)
+               filter[ix] /= fval;
+
+       /* Blur the rows */
+       for (y = 0; y < height; y++) {
+               /* Do the left & right strips */
+               for (x = 0; x < halfWidth; x++) {
+                       index = (x + y * width) * 4;
+                       fx = 0;
+                       curColor[0] = curColor[1] = curColor[2] = 0.0f;
+                       curColor2[0] = curColor2[1] = curColor2[2] = 0.0f;
+
+                       for (i = x - halfWidth; i < x + halfWidth; i++) {
+                               if ((i >= 0) && (i < width)) {
+                                       curColor[0] += map[(i + y * width) * 4 + GlowR] * filter[fx];
+                                       curColor[1] += map[(i + y * width) * 4 + GlowG] * filter[fx];
+                                       curColor[2] += map[(i + y * width) * 4 + GlowB] * filter[fx];
+
+                                       curColor2[0] += map[(width - 1 - i + y * width) * 4 + GlowR] * filter[fx];
+                                       curColor2[1] += map[(width - 1 - i + y * width) * 4 + GlowG] * filter[fx];
+                                       curColor2[2] += map[(width - 1 - i + y * width) * 4 + GlowB] * filter[fx];
                                }
                                fx++;
                        }
-                       temp[index+GlowR]=curColor[0];
-                       temp[index+GlowG]=curColor[1];
-                       temp[index+GlowB]=curColor[2];
+                       temp[index + GlowR] = curColor[0];
+                       temp[index + GlowG] = curColor[1];
+                       temp[index + GlowB] = curColor[2];
 
-                       temp[((width-1-x+y*width)*4)+GlowR]=curColor2[0];
-                       temp[((width-1-x+y*width)*4)+GlowG]=curColor2[1];
-                       temp[((width-1-x+y*width)*4)+GlowB]=curColor2[2];
+                       temp[((width - 1 - x + y * width) * 4) + GlowR] = curColor2[0];
+                       temp[((width - 1 - x + y * width) * 4) + GlowG] = curColor2[1];
+                       temp[((width - 1 - x + y * width) * 4) + GlowB] = curColor2[2];
 
                }
-               /*      Do the main body */
-               for (x=halfWidth;x<width-halfWidth;x++) {
-                       index=(x+y*width)*4;
-                       fx=0;
+
+               /* Do the main body */
+               for (x = halfWidth; x < width - halfWidth; x++) {
+                       index = (x + y * width) * 4;
+                       fx = 0;
                        zero_v3(curColor);
-                       for (i=x-halfWidth;i<x+halfWidth;i++) {
-                               curColor[0]+=map[(i+y*width)*4+GlowR]*filter[fx];
-                               curColor[1]+=map[(i+y*width)*4+GlowG]*filter[fx];
-                               curColor[2]+=map[(i+y*width)*4+GlowB]*filter[fx];
+                       for (i = x - halfWidth; i < x + halfWidth; i++) {
+                               curColor[0] += map[(i + y * width) * 4 + GlowR] * filter[fx];
+                               curColor[1] += map[(i + y * width) * 4 + GlowG] * filter[fx];
+                               curColor[2] += map[(i + y * width) * 4 + GlowB] * filter[fx];
                                fx++;
                        }
-                       temp[index+GlowR]=curColor[0];
-                       temp[index+GlowG]=curColor[1];
-                       temp[index+GlowB]=curColor[2];
+                       temp[index + GlowR] = curColor[0];
+                       temp[index + GlowG] = curColor[1];
+                       temp[index + GlowB] = curColor[2];
                }
        }
 
-       /*      Swap buffers */
-       swap=temp;temp=map;map=swap;
-
+       /* Swap buffers */
+       swap = temp; temp = map; map = swap;
 
-       /*      Blur the columns */
-       for (x=0;x<width;x++) {
-               /*      Do the top & bottom strips */
-               for (y=0;y<halfWidth;y++) {
-                       index=(x+y*width)*4;
-                       fy=0;
+       /* Blur the columns */
+       for (x = 0; x < width; x++) {
+               /* Do the top & bottom strips */
+               for (y = 0; y < halfWidth; y++) {
+                       index = (x + y * width) * 4;
+                       fy = 0;
                        zero_v3(curColor);
                        zero_v3(curColor2);
-                       for (i=y-halfWidth;i<y+halfWidth;i++) {
-                               if ((i>=0)&&(i<height)) {
-                                       /*      Bottom */
-                                       curColor[0]+=map[(x+i*width)*4+GlowR]*filter[fy];
-                                       curColor[1]+=map[(x+i*width)*4+GlowG]*filter[fy];
-                                       curColor[2]+=map[(x+i*width)*4+GlowB]*filter[fy];
-
-                                       /*      Top */
-                                       curColor2[0]+=map[(x+(height-1-i)*width) *
-                                               4+GlowR]*filter[fy];
-                                       curColor2[1]+=map[(x+(height-1-i)*width) *
-                                               4+GlowG]*filter[fy];
-                                       curColor2[2]+=map[(x+(height-1-i)*width) *
-                                               4+GlowB]*filter[fy];
+                       for (i = y - halfWidth; i < y + halfWidth; i++) {
+                               if ((i >= 0) && (i < height)) {
+                                       /* Bottom */
+                                       curColor[0] += map[(x + i * width) * 4 + GlowR] * filter[fy];
+                                       curColor[1] += map[(x + i * width) * 4 + GlowG] * filter[fy];
+                                       curColor[2] += map[(x + i * width) * 4 + GlowB] * filter[fy];
+
+                                       /* Top */
+                                       curColor2[0] += map[(x + (height - 1 - i) * width) * 4 + GlowR] * filter[fy];
+                                       curColor2[1] += map[(x + (height - 1 - i) * width) * 4 + GlowG] * filter[fy];
+                                       curColor2[2] += map[(x + (height - 1 - i) * width) * 4 + GlowB] * filter[fy];
                                }
                                fy++;
                        }
-                       temp[index+GlowR]=curColor[0];
-                       temp[index+GlowG]=curColor[1];
-                       temp[index+GlowB]=curColor[2];
-                       temp[((x+(height-1-y)*width)*4)+GlowR]=curColor2[0];
-                       temp[((x+(height-1-y)*width)*4)+GlowG]=curColor2[1];
-                       temp[((x+(height-1-y)*width)*4)+GlowB]=curColor2[2];
+                       temp[index + GlowR] = curColor[0];
+                       temp[index + GlowG] = curColor[1];
+                       temp[index + GlowB] = curColor[2];
+                       temp[((x + (height - 1 - y) * width) * 4) + GlowR] = curColor2[0];
+                       temp[((x + (height - 1 - y) * width) * 4) + GlowG] = curColor2[1];
+                       temp[((x + (height - 1 - y) * width) * 4) + GlowB] = curColor2[2];
                }
-               /*      Do the main body */
-               for (y=halfWidth;y<height-halfWidth;y++) {
-                       index=(x+y*width)*4;
-                       fy=0;
+       
+               /* Do the main body */
+               for (y = halfWidth; y < height - halfWidth; y++) {
+                       index = (x + y * width) * 4;
+                       fy = 0;
                        zero_v3(curColor);
-                       for (i=y-halfWidth;i<y+halfWidth;i++) {
-                               curColor[0]+=map[(x+i*width)*4+GlowR]*filter[fy];
-                               curColor[1]+=map[(x+i*width)*4+GlowG]*filter[fy];
-                               curColor[2]+=map[(x+i*width)*4+GlowB]*filter[fy];
+                       for (i = y - halfWidth; i < y + halfWidth; i++) {
+                               curColor[0] += map[(x + i * width) * 4 + GlowR] * filter[fy];
+                               curColor[1] += map[(x + i * width) * 4 + GlowG] * filter[fy];
+                               curColor[2] += map[(x + i * width) * 4 + GlowB] * filter[fy];
                                fy++;
                        }
-                       temp[index+GlowR]=curColor[0];
-                       temp[index+GlowG]=curColor[1];
-                       temp[index+GlowB]=curColor[2];
+                       temp[index + GlowR] = curColor[0];
+                       temp[index + GlowG] = curColor[1];
+                       temp[index + GlowB] = curColor[2];
                }
        }
 
+       /* Swap buffers */
+       swap = temp; temp = map; /* map = swap; */ /* UNUSED */
 
-       /*      Swap buffers */
-       swap=temp;temp=map; /* map=swap; */ /* UNUSED */
-
-       /*      Tidy up  */
-       MEM_freeN (filter);
-       MEM_freeN (temp);
+       /* Tidy up       */
+       MEM_freeN(filter);
+       MEM_freeN(temp);
 }
 
 
@@ -2524,94 +2126,89 @@ static void RVBlurBitmap2_float ( float* map, int width,int height,
 /*     C must have been previously allocated but it may be A or B. */
 /*     We clamp values to 255 to prevent weirdness */
 /*=============================== */
-static void RVAddBitmaps_byte (unsigned char* a, unsigned char* b, unsigned char* c, int width, int height)
+static void RVAddBitmaps_byte(unsigned char *a, unsigned char *b, unsigned char *c, int width, int height)
 {
-       int     x,y,index;
+       int x, y, index;
 
-       for (y=0;y<height;y++) {
-               for (x=0;x<width;x++) {
-                       index=(x+y*width)*4;
-                       c[index+GlowR]=MIN2(255,a[index+GlowR]+b[index+GlowR]);
-                       c[index+GlowG]=MIN2(255,a[index+GlowG]+b[index+GlowG]);
-                       c[index+GlowB]=MIN2(255,a[index+GlowB]+b[index+GlowB]);
-                       c[index+GlowA]=MIN2(255,a[index+GlowA]+b[index+GlowA]);
+       for (y = 0; y < height; y++) {
+               for (x = 0; x < width; x++) {
+                       index = (x + y * width) * 4;
+                       c[index + GlowR] = MIN2(255, a[index + GlowR] + b[index + GlowR]);
+                       c[index + GlowG] = MIN2(255, a[index + GlowG] + b[index + GlowG]);
+                       c[index + GlowB] = MIN2(255, a[index + GlowB] + b[index + GlowB]);
+                       c[index + GlowA] = MIN2(255, a[index + GlowA] + b[index + GlowA]);
                }
        }
 }
 
-static void RVAddBitmaps_float (float* a, float* b, float* c, 
-                               int width, int height)
+static void RVAddBitmaps_float(float *a, float *b, float *c, int width, int height)
 {
-       int     x,y,index;
+       int x, y, index;
 
-       for (y=0;y<height;y++) {
-               for (x=0;x<width;x++) {
-                       index=(x+y*width)*4;
-                       c[index+GlowR]= MIN2(1.0f, a[index+GlowR]+b[index+GlowR]);
-                       c[index+GlowG]= MIN2(1.0f, a[index+GlowG]+b[index+GlowG]);
-                       c[index+GlowB]= MIN2(1.0f, a[index+GlowB]+b[index+GlowB]);
-                       c[index+GlowA]= MIN2(1.0f, a[index+GlowA]+b[index+GlowA]);
+       for (y = 0; y < height; y++) {
+               for (x = 0; x < width; x++) {
+                       index = (x + y * width) * 4;
+                       c[index + GlowR] = MIN2(1.0f, a[index + GlowR] + b[index + GlowR]);
+                       c[index + GlowG] = MIN2(1.0f, a[index + GlowG] + b[index + GlowG]);
+                       c[index + GlowB] = MIN2(1.0f, a[index + GlowB] + b[index + GlowB]);
+                       c[index + GlowA] = MIN2(1.0f, a[index + GlowA] + b[index + GlowA]);
                }
        }
 }
 
-/*     For each pixel whose total luminance exceeds the threshold, */
-/*     Multiply it's value by BOOST and add it to the output map */
-static void RVIsolateHighlights_byte (unsigned char* in, unsigned char* out, 
-                                         int width, int height, int threshold, 
-                                         float boost, float clamp)
+/* For each pixel whose total luminance exceeds the threshold,
+ * Multiply it's value by BOOST and add it to the output map
+ */
+static void RVIsolateHighlights_byte(unsigned char *in, unsigned char *out, int width, int height, int threshold,
+                                     float boost, float clamp)
 {
-       int x,y,index;
-       int     intensity;
+       int x, y, index;
+       int intensity;
 
+       for (y = 0; y < height; y++) {
+               for (x = 0; x < width; x++) {
+                       index = (x + y * width) * 4;
 
-       for (y=0;y< height;y++) {
-               for (x=0;x< width;x++) {
-                       index= (x+y*width)*4;
-
-                       /*      Isolate the intensity */
-                       intensity=(in[index+GlowR]+in[index+GlowG]+in[index+GlowB]-threshold);
-                       if (intensity>0) {
-                               out[index+GlowR]=MIN2(255*clamp, (in[index+GlowR]*boost*intensity)/255);
-                               out[index+GlowG]=MIN2(255*clamp, (in[index+GlowG]*boost*intensity)/255);
-                               out[index+GlowB]=MIN2(255*clamp, (in[index+GlowB]*boost*intensity)/255);
-                               out[index+GlowA]=MIN2(255*clamp, (in[index+GlowA]*boost*intensity)/255);
+                       /* Isolate the intensity */
+                       intensity = (in[index + GlowR] + in[index + GlowG] + in[index + GlowB] - threshold);
+                       if (intensity > 0) {
+                               out[index + GlowR] = MIN2(255 * clamp, (in[index + GlowR] * boost * intensity) / 255);
+                               out[index + GlowG] = MIN2(255 * clamp, (in[index + GlowG] * boost * intensity) / 255);
+                               out[index + GlowB] = MIN2(255 * clamp, (in[index + GlowB] * boost * intensity) / 255);
+                               out[index + GlowA] = MIN2(255 * clamp, (in[index + GlowA] * boost * intensity) / 255);
                        }
                        else {
-                               out[index+GlowR]=0;
-                               out[index+GlowG]=0;
-                               out[index+GlowB]=0;
-                               out[index+GlowA]=0;
+                               out[index + GlowR] = 0;
+                               out[index + GlowG] = 0;
+                               out[index + GlowB] = 0;
+                               out[index + GlowA] = 0;
                        }
                }
        }
 }
 
-static void RVIsolateHighlights_float (float* in, float* out, 
-                                         int width, int height, float threshold, 
-                                         float boost, float clamp)
+static void RVIsolateHighlights_float(float *in, float *out, int width, int height, float threshold, float boost, float clamp)
 {
-       int x,y,index;
-       float   intensity;
-
+       int x, y, index;
+       float intensity;
 
-       for (y=0;y< height;y++) {
-               for (x=0;x< width;x++) {
-                       index= (x+y*width)*4;
+       for (y = 0; y < height; y++) {
+               for (x = 0; x < width; x++) {
+                       index = (x + y * width) * 4;
 
-                       /*      Isolate the intensity */
-                       intensity=(in[index+GlowR]+in[index+GlowG]+in[index+GlowB]-threshold);
-                       if (intensity>0) {
-                               out[index+GlowR]=MIN2(clamp, (in[index+GlowR]*boost*intensity));
-                               out[index+GlowG]=MIN2(clamp, (in[index+GlowG]*boost*intensity));
-                               out[index+GlowB]=MIN2(clamp, (in[index+GlowB]*boost*intensity));
-                               out[index+GlowA]=MIN2(clamp, (in[index+GlowA]*boost*intensity));
+                       /* Isolate the intensity */
+                       intensity = (in[index + GlowR] + in[index + GlowG] + in[index + GlowB] - threshold);
+                       if (intensity > 0) {
+                               out[index + GlowR] = MIN2(clamp, (in[index + GlowR] * boost * intensity));
+                               out[index + GlowG] = MIN2(clamp, (in[index + GlowG] * boost * intensity));
+                               out[index + GlowB] = MIN2(clamp, (in[index + GlowB] * boost * intensity));
+                               out[index + GlowA] = MIN2(clamp, (in[index + GlowA] * boost * intensity));
                        }
                        else {
-                               out[index+GlowR]=0;
-                               out[index+GlowG]=0;
-                               out[index+GlowB]=0;
-                               out[index+GlowA]=0;
+                               out[index + GlowR] = 0;
+                               out[index + GlowG] = 0;
+                               out[index + GlowB] = 0;
+                               out[index + GlowA] = 0;
                        }
                }
        }
@@ -2621,8 +2218,10 @@ static void init_glow_effect(Sequence *seq)
 {
        GlowVars *glow;
 
-       if (seq->effectdata)MEM_freeN(seq->effectdata);
-       seq->effectdata = MEM_callocN(sizeof(struct GlowVars), "glowvars");
+       if (seq->effectdata)
+               MEM_freeN(seq->effectdata);
+
+       seq->effectdata = MEM_callocN(sizeof(GlowVars), "glowvars");
 
        glow = (GlowVars *)seq->effectdata;
        glow->fMini = 0.25;
@@ -2640,7 +2239,9 @@ static int num_inputs_glow(void)
 
 static void free_glow_effect(Sequence *seq)
 {
-       if (seq->effectdata)MEM_freeN(seq->effectdata);
+       if (seq->effectdata)
+               MEM_freeN(seq->effectdata);
+
        seq->effectdata = NULL;
 }
 
@@ -2649,73 +2250,61 @@ static void copy_glow_effect(Sequence *dst, Sequence *src)
        dst->effectdata = MEM_dupallocN(src->effectdata);
 }
 
-//void do_glow_effect(Cast *cast, float facf0, float facf1, int xo, int yo, ImBuf *ibuf1, ImBuf *ibuf2, ImBuf *outbuf, ImBuf *use)
-static void do_glow_effect_byte(Sequence *seq, int render_size, float facf0, float UNUSED(facf1), 
-                               int x, int y, char *rect1, 
-                               char *UNUSED(rect2), char *out)
+static void do_glow_effect_byte(Sequence *seq, int render_size, float facf0, float UNUSED(facf1),  int x, int y,
+                                char *rect1, char *UNUSED(rect2), char *out)
 {
-       unsigned char *outbuf=(unsigned char *)out;
-       unsigned char *inbuf=(unsigned char *)rect1;
+       unsigned char *outbuf = (unsigned char *)out;
+       unsigned char *inbuf = (unsigned char *)rect1;
        GlowVars *glow = (GlowVars *)seq->effectdata;
        
-       RVIsolateHighlights_byte(inbuf, outbuf , x, y, glow->fMini*765, glow->fBoost * facf0, glow->fClamp);
-       RVBlurBitmap2_byte (outbuf, x, y, glow->dDist * (render_size / 100.0f),glow->dQuality);
+       RVIsolateHighlights_byte(inbuf, outbuf, x, y, glow->fMini * 765, glow->fBoost * facf0, glow->fClamp);
+       RVBlurBitmap2_byte(outbuf, x, y, glow->dDist * (render_size / 100.0f), glow->dQuality);
        if (!glow->bNoComp)
-               RVAddBitmaps_byte (inbuf , outbuf, outbuf, x, y);
+               RVAddBitmaps_byte(inbuf, outbuf, outbuf, x, y);
 }
 
-static void do_glow_effect_float(Sequence *seq, int render_size, float facf0, float UNUSED(facf1), 
-                                int x, int y, 
-                                float *rect1, float *UNUSED(rect2), float *out)
+static void do_glow_effect_float(Sequence *seq, int render_size, float facf0, float UNUSED(facf1),  int x, int y,
+                                 float *rect1, float *UNUSED(rect2), float *out)
 {
        float *outbuf = out;
        float *inbuf = rect1;
        GlowVars *glow = (GlowVars *)seq->effectdata;
 
-       RVIsolateHighlights_float(inbuf, outbuf , x, y, glow->fMini*3.0f, glow->fBoost * facf0, glow->fClamp);
-       RVBlurBitmap2_float (outbuf, x, y, glow->dDist * (render_size / 100.0f),glow->dQuality);
+       RVIsolateHighlights_float(inbuf, outbuf, x, y, glow->fMini * 3.0f, glow->fBoost * facf0, glow->fClamp);
+       RVBlurBitmap2_float(outbuf, x, y, glow->dDist * (render_size / 100.0f), glow->dQuality);
        if (!glow->bNoComp)
-               RVAddBitmaps_float (inbuf , outbuf, outbuf, x, y);
+               RVAddBitmaps_float(inbuf, outbuf, outbuf, x, y);
 }
 
-static struct ImBuf * do_glow_effect(
-       SeqRenderData context, Sequence *seq, float UNUSED(cfra),
-       float facf0, float facf1, 
-       struct ImBuf *ibuf1, struct ImBuf *ibuf2, 
-       struct ImBuf *ibuf3)
+static ImBuf *do_glow_effect(SeqRenderData context, Sequence *seq, float UNUSED(cfra), float facf0, float facf1,
+                             ImBuf *ibuf1, ImBuf *ibuf2, ImBuf *ibuf3)
 {
-       struct ImBuf * out = prepare_effect_imbufs(context,ibuf1, ibuf2, ibuf3);
+       ImBuf *out = prepare_effect_imbufs(context, ibuf1, ibuf2, ibuf3);
 
-       int render_size = 100*context.rectx/context.scene->r.xsch;
+       int render_size = 100 * context.rectx / context.scene->r.xsch;
 
        if (out->rect_float) {
-               do_glow_effect_float(seq, render_size,
-                                    facf0, facf1, 
-                                    context.rectx, context.recty,
-                                    ibuf1->rect_float, ibuf2->rect_float,
-                                    out->rect_float);
+               do_glow_effect_float(seq, render_size, facf0, facf1, context.rectx, context.recty,
+                                    ibuf1->rect_float, ibuf2->rect_float, out->rect_float);
        }
        else {
-               do_glow_effect_byte(seq, render_size,
-                                   facf0, facf1, 
-                                   context.rectx, context.recty,
-                                   (char*) ibuf1->rect, (char*) ibuf2->rect,
-                                   (char*) out->rect);
+               do_glow_effect_byte(seq, render_size, facf0, facf1, context.rectx, context.recty,
+                                   (char *) ibuf1->rect, (char *) ibuf2->rect, (char *) out->rect);
        }
 
        return out;
 }
 
-/* **********************************************************************
- * SOLID COLOR
- * ********************************************************************** */
+/*********************** Solid color *************************/
 
 static void init_solid_color(Sequence *seq)
 {
        SolidColorVars *cv;
        
-       if (seq->effectdata)MEM_freeN(seq->effectdata);
-       seq->effectdata = MEM_callocN(sizeof(struct SolidColorVars), "solidcolor");
+       if (seq->effectdata)
+               MEM_freeN(seq->effectdata);
+
+       seq->effectdata = MEM_callocN(sizeof(SolidColorVars), "solidcolor");
        
        cv = (SolidColorVars *)seq->effectdata;
        cv->col[0] = cv->col[1] = cv->col[2] = 0.5;
@@ -2728,7 +2317,9 @@ static int num_inputs_color(void)
 
 static void free_solid_color(Sequence *seq)
 {
-       if (seq->effectdata)MEM_freeN(seq->effectdata);
+       if (seq->effectdata)
+               MEM_freeN(seq->effectdata);
+
        seq->effectdata = NULL;
 }
 
@@ -2737,19 +2328,15 @@ static void copy_solid_color(Sequence *dst, Sequence *src)
        dst->effectdata = MEM_dupallocN(src->effectdata);
 }
 
-static int early_out_color(struct Sequence *UNUSED(seq),
-                          float UNUSED(facf0), float UNUSED(facf1))
+static int early_out_color(Sequence *UNUSED(seq), float UNUSED(facf0), float UNUSED(facf1))
 {
-       return -1;
+       return EARLY_NO_INPUT;
 }
 
-static struct ImBuf * do_solid_color(
-       SeqRenderData context, Sequence *seq, float UNUSED(cfra),
-       float facf0, float facf1, 
-       struct ImBuf *ibuf1, struct ImBuf *ibuf2, 
-       struct ImBuf *ibuf3)
+static ImBuf *do_solid_color(SeqRenderData context, Sequence *seq, float UNUSED(cfra), float facf0, float facf1,
+                             ImBuf *ibuf1, ImBuf *ibuf2, ImBuf *ibuf3)
 {
-       struct ImBuf * out = prepare_effect_imbufs(context,ibuf1, ibuf2, ibuf3);
+       ImBuf *out = prepare_effect_imbufs(context, ibuf1, ibuf2, ibuf3);
 
        SolidColorVars *cv = (SolidColorVars *)seq->effectdata;
 
@@ -2772,20 +2359,20 @@ static struct ImBuf * do_solid_color(
 
                rect = (unsigned char *)out->rect;
                
-               for (y=0; y<out->y; y++) {      
-                       for (x=0; x<out->x; x++, rect+=4) {
-                               rect[0]= col0[0];
-                               rect[1]= col0[1];
-                               rect[2]= col0[2];
-                               rect[3]= 255;
+               for (y = 0; y < out->y; y++) {
+                       for (x = 0; x < out->x; x++, rect += 4) {
+                               rect[0] = col0[0];
+                               rect[1] = col0[1];
+                               rect[2] = col0[2];
+                               rect[3] = 255;
                        }
                        y++;
-                       if (y<out->y) {
-                               for (x=0; x<out->x; x++, rect+=4) {
-                                       rect[0]= col1[0];
-                                       rect[1]= col1[1];
-                                       rect[2]= col1[2];
-                                       rect[3]= 255;
+                       if (y < out->y) {
+                               for (x = 0; x < out->x; x++, rect += 4) {
+                                       rect[0] = col1[0];
+                                       rect[1] = col1[1];
+                                       rect[2] = col1[2];
+                                       rect[3] = 255;
                                }       
                        }
                }
@@ -2805,20 +2392,20 @@ static struct ImBuf * do_solid_color(
 
                rect_float = out->rect_float;
                
-               for (y=0; y<out->y; y++) {      
-                       for (x=0; x<out->x; x++, rect_float+=4) {
-                               rect_float[0]= col0[0];
-                               rect_float[1]= col0[1];
-                               rect_float[2]= col0[2];
-                               rect_float[3]= 1.0;
+               for (y = 0; y < out->y; y++) {
+                       for (x = 0; x < out->x; x++, rect_float += 4) {
+                               rect_float[0] = col0[0];
+                               rect_float[1] = col0[1];
+                               rect_float[2] = col0[2];
+                               rect_float[3] = 1.0;
                        }
                        y++;
-                       if (y<out->y) {
-                               for (x=0; x<out->x; x++, rect_float+=4) {
-                                       rect_float[0]= col1[0];
-                                       rect_float[1]= col1[1];
-                                       rect_float[2]= col1[2];
-                                       rect_float[3]= 1.0;
+                       if (y < out->y) {
+                               for (x = 0; x < out->x; x++, rect_float += 4) {
+                                       rect_float[0] = col1[0];
+                                       rect_float[1] = col1[1];
+                                       rect_float[2] = col1[2];
+                                       rect_float[3] = 1.0;
                                }
                        }
                }
@@ -2826,9 +2413,7 @@ static struct ImBuf * do_solid_color(
        return out;
 }
 
-/* **********************************************************************
- * MULTICAM
- * ********************************************************************** */
+/*********************** Mulitcam *************************/
 
 /* no effect inputs for multicam, we use give_ibuf_seq */
 static int num_inputs_multicam(void)
@@ -2836,21 +2421,18 @@ static int num_inputs_multicam(void)
        return 0;
 }
 
-static int early_out_multicam(struct Sequence *UNUSED(seq), float UNUSED(facf0), float UNUSED(facf1))
+static int early_out_multicam(Sequence *UNUSED(seq), float UNUSED(facf0), float UNUSED(facf1))
 {
-       return -1;
+       return EARLY_NO_INPUT;
 }
 
-static struct ImBuf * do_multicam(
-       SeqRenderData context, Sequence *seq, float cfra,
-       float UNUSED(facf0), float UNUSED(facf1),
-       struct ImBuf *UNUSED(ibuf1), struct ImBuf *UNUSED(ibuf2), 
-       struct ImBuf *UNUSED(ibuf3))
+static ImBuf *do_multicam(SeqRenderData context, Sequence *seq, float cfra, float UNUSED(facf0), float UNUSED(facf1),
+                          ImBuf *UNUSED(ibuf1), ImBuf *UNUSED(ibuf2), ImBuf *UNUSED(ibuf3))
 {
-       struct ImBuf * i;
-       struct ImBuf * out;
-       Editing * ed;
-       ListBase * seqbasep;
+       ImBuf *i;
+       ImBuf *out;
+       Editing *ed;
+       ListBase *seqbasep;
 
        if (seq->multicam_source == 0 || seq->multicam_source >= seq->machine) {
                return NULL;
@@ -2860,17 +2442,17 @@ static struct ImBuf * do_multicam(
        if (!ed) {
                return NULL;
        }
-       seqbasep = seq_seqbase(&ed->seqbase, seq);
+       seqbasep = BKE_sequence_seqbase(&ed->seqbase, seq);
        if (!seqbasep) {
                return NULL;
        }
 
-       i = give_ibuf_seqbase(context, cfra, seq->multicam_source, seqbasep);
+       i = BKE_sequencer_give_ibuf_seqbase(context, cfra, seq->multicam_source, seqbasep);
        if (!i) {
                return NULL;
        }
 
-       if (input_have_to_preprocess(context, seq, cfra)) {
+       if (BKE_sequencer_input_have_to_preprocess(context, seq, cfra)) {
                out = IMB_dupImBuf(i);
                IMB_freeImBuf(i);
        }
@@ -2881,9 +2463,7 @@ static struct ImBuf * do_multicam(
        return out;
 }
 
-/* **********************************************************************
- * ADJUSTMENT
- * ********************************************************************** */
+/*********************** Adjustment *************************/
 
 /* no effect inputs for adjustment, we use give_ibuf_seq */
 static int num_inputs_adjustment(void)
@@ -2891,36 +2471,34 @@ static int num_inputs_adjustment(void)
        return 0;
 }
 
-static int early_out_adjustment(struct Sequence *UNUSED(seq), float UNUSED(facf0), float UNUSED(facf1))
+static int early_out_adjustment(Sequence *UNUSED(seq), float UNUSED(facf0), float UNUSED(facf1))
 {
-       return -1;
+       return EARLY_NO_INPUT;
 }
 
-static struct ImBuf * do_adjustment_impl(SeqRenderData context, Sequence * seq,
-                                        float cfra)
+static ImBuf *do_adjustment_impl(SeqRenderData context, Sequence *seq, float cfra)
 {
-       Editing * ed;
-       ListBase * seqbasep;
-       struct ImBuf * i= NULL;
+       Editing *ed;
+       ListBase *seqbasep;
+       ImBuf *i = NULL;
 
        ed = context.scene->ed;
 
-       seqbasep = seq_seqbase(&ed->seqbase, seq);
+       seqbasep = BKE_sequence_seqbase(&ed->seqbase, seq);
 
-       if (seq->machine > 0) {
-               i = give_ibuf_seqbase(context, cfra,
-                                     seq->machine - 1, seqbasep);
+       if (seq->machine > 1) {
+               i = BKE_sequencer_give_ibuf_seqbase(context, cfra, seq->machine - 1, seqbasep);
        }
 
        /* found nothing? so let's work the way up the metastrip stack, so
-        *  that it is possible to group a bunch of adjustment strips into
-        *  a metastrip and have that work on everything below the metastrip
+        * that it is possible to group a bunch of adjustment strips into
+        * a metastrip and have that work on everything below the metastrip
         */
 
        if (!i) {
-               Sequence * meta;
+               Sequence *meta;
 
-               meta = seq_metastrip(&ed->seqbase, NULL, seq);
+               meta = BKE_sequence_metastrip(&ed->seqbase, NULL, seq);
 
                if (meta) {
                        i = do_adjustment_impl(context, meta, cfra);
@@ -2930,15 +2508,12 @@ static struct ImBuf * do_adjustment_impl(SeqRenderData context, Sequence * seq,
        return i;
 }
 
-static struct ImBuf * do_adjustment(
-       SeqRenderData context, Sequence *seq, float cfra,
-       float UNUSED(facf0), float UNUSED(facf1),
-       struct ImBuf *UNUSED(ibuf1), struct ImBuf *UNUSED(ibuf2), 
-       struct ImBuf *UNUSED(ibuf3))
+static ImBuf *do_adjustment(SeqRenderData context, Sequence *seq, float cfra, float UNUSED(facf0), float UNUSED(facf1),
+                            ImBuf *UNUSED(ibuf1), ImBuf *UNUSED(ibuf2), ImBuf *UNUSED(ibuf3))
 {
-       struct ImBuf * i = NULL;
-       struct ImBuf * out;
-       Editing * ed;
+       ImBuf *i = NULL;
+       ImBuf *out;
+       Editing *ed;
 
        ed = context.scene->ed;
 
@@ -2948,7 +2523,7 @@ static struct ImBuf * do_adjustment(
 
        i = do_adjustment_impl(context, seq, cfra);
 
-       if (input_have_to_preprocess(context, seq, cfra)) {
+       if (BKE_sequencer_input_have_to_preprocess(context, seq, cfra)) {
                out = IMB_dupImBuf(i);
                IMB_freeImBuf(i);
        }
@@ -2959,16 +2534,16 @@ static struct ImBuf * do_adjustment(
        return out;
 }
 
-/* **********************************************************************
- * SPEED
- * ********************************************************************** */
+/*********************** Speed *************************/
+
 static void init_speed_effect(Sequence *seq)
 {
-       SpeedControlVars * v;
+       SpeedControlVars *v;
 
-       if (seq->effectdata) MEM_freeN(seq->effectdata);
-       seq->effectdata = MEM_callocN(sizeof(struct SpeedControlVars), 
-                                         "speedcontrolvars");
+       if (seq->effectdata)
+               MEM_freeN(seq->effectdata);
+
+       seq->effectdata = MEM_callocN(sizeof(SpeedControlVars), "speedcontrolvars");
 
        v = (SpeedControlVars *)seq->effectdata;
        v->globalSpeed = 1.0;
@@ -2977,9 +2552,9 @@ static void init_speed_effect(Sequence *seq)
        v->length = 0;
 }
 
-static void load_speed_effect(Sequence * seq)
+static void load_speed_effect(Sequence *seq)
 {
-       SpeedControlVars * v = (SpeedControlVars *)seq->effectdata;
+       SpeedControlVars *v = (SpeedControlVars *)seq->effectdata;
 
        v->frameMap = NULL;
        v->length = 0;
@@ -2992,34 +2567,34 @@ static int num_inputs_speed(void)
 
 static void free_speed_effect(Sequence *seq)
 {
-       SpeedControlVars * v = (SpeedControlVars *)seq->effectdata;
-       if (v->frameMap) MEM_freeN(v->frameMap);
-       if (seq->effectdata) MEM_freeN(seq->effectdata);
+       SpeedControlVars *v = (SpeedControlVars *)seq->effectdata;
+       if (v->frameMap)
+               MEM_freeN(v->frameMap);
+       if (seq->effectdata)
+               MEM_freeN(seq->effectdata);
        seq->effectdata = NULL;
 }
 
 static void copy_speed_effect(Sequence *dst, Sequence *src)
 {
-       SpeedControlVars * v;
+       SpeedControlVars *v;
        dst->effectdata = MEM_dupallocN(src->effectdata);
        v = (SpeedControlVars *)dst->effectdata;
        v->frameMap = NULL;
        v->length = 0;
 }
 
-static int early_out_speed(struct Sequence *UNUSED(seq),
-                         float UNUSED(facf0), float UNUSED(facf1))
+static int early_out_speed(Sequence *UNUSED(seq), float UNUSED(facf0), float UNUSED(facf1))
 {
-       return 1;
+       return EARLY_USE_INPUT_1;
 }
 
-static void store_icu_yrange_speed(struct Sequence * seq,
-                                  short UNUSED(adrcode), float * ymin, float * ymax)
+static void store_icu_yrange_speed(Sequence *seq, short UNUSED(adrcode), float *ymin, float *ymax)
 {
-       SpeedControlVars * v = (SpeedControlVars *)seq->effectdata;
+       SpeedControlVars *v = (SpeedControlVars *)seq->effectdata;
 
        /* if not already done, load / initialize data */
-       get_sequence_effect(seq);
+       BKE_sequence_get_effect(seq);
 
        if ((v->flags & SEQ_SPEED_INTEGRATE) != 0) {
                *ymin = -100.0;
@@ -3036,32 +2611,32 @@ static void store_icu_yrange_speed(struct Sequence * seq,
                }
        }       
 }
-void sequence_effect_speed_rebuild_map(Scene *scene, Sequence * seq, int force)
+
+void BKE_sequence_effect_speed_rebuild_map(Scene *scene, Sequence *seq, int force)
 {
        int cfra;
        float fallback_fac = 1.0f;
-       SpeedControlVars * v = (SpeedControlVars *)seq->effectdata;
-       FCurve *fcu= NULL;
+       SpeedControlVars *v = (SpeedControlVars *) seq->effectdata;
+       FCurve *fcu = NULL;
        int flags = v->flags;
 
        /* if not already done, load / initialize data */
-       get_sequence_effect(seq);
+       BKE_sequence_get_effect(seq);
 
-       if (    (force == FALSE) &&
-                       (seq->len == v->length) &&
-                       (v->frameMap != NULL)
-       {
+       if ((force == FALSE) &&
+           (seq->len == v->length) &&
+           (v->frameMap != NULL))
+       {
                return;
        }
-       if (    (seq->seq1 == NULL) ||
-               (seq->len < 1)
-       ) { /* make coverity happy and check for (CID 598) input strip ... */
+       if ((seq->seq1 == NULL) || (seq->len < 1)) {
+               /* make coverity happy and check for (CID 598) input strip ... */
                return;
        }
 
        /* XXX - new in 2.5x. should we use the animation system this way?
         * The fcurve is needed because many frames need evaluating at once - campbell */
-       fcu= id_data_find_fcurve(&scene->id, seq, &RNA_Sequence, "speed_factor", 0, NULL);
+       fcu = id_data_find_fcurve(&scene->id, seq, &RNA_Sequence, "speed_factor", 0, NULL);
 
 
        if (!v->frameMap || v->length != seq->len) {
@@ -3069,8 +2644,7 @@ void sequence_effect_speed_rebuild_map(Scene *scene, Sequence * seq, int force)
 
                v->length = seq->len;
 
-               v->frameMap = MEM_callocN(sizeof(float) * v->length, 
-                                         "speedcontrol frameMap");
+               v->frameMap = MEM_callocN(sizeof(float) * v->length, "speedcontrol frameMap");
        }
 
        fallback_fac = 1.0;
@@ -3079,8 +2653,7 @@ void sequence_effect_speed_rebuild_map(Scene *scene, Sequence * seq, int force)
                if ((seq->seq1->enddisp != seq->seq1->start) &&
                    (seq->seq1->len != 0))
                {
-                       fallback_fac = (float) seq->seq1->len / 
-                               (float) (seq->seq1->enddisp - seq->seq1->start);
+                       fallback_fac = (float) seq->seq1->len / (float) (seq->seq1->enddisp - seq->seq1->start);
                        flags = SEQ_SPEED_INTEGRATE;
                        fcu = NULL;
                }
@@ -3148,27 +2721,61 @@ void sequence_effect_speed_rebuild_map(Scene *scene, Sequence * seq, int force)
        }
 }
 
-/* **********************************************************************
- * sequence effect factory
- * ********************************************************************** */
+static ImBuf *do_speed_effect(SeqRenderData context, Sequence *UNUSED(seq), float UNUSED(cfra),
+                              float facf0, float facf1, ImBuf *ibuf1, ImBuf *ibuf2, ImBuf *ibuf3)
+{
+       ImBuf *out = prepare_effect_imbufs(context, ibuf1, ibuf2, ibuf3);
+
+       if (out->rect_float) {
+               do_cross_effect_float(facf0, facf1, context.rectx, context.recty,
+                                     ibuf1->rect_float, ibuf2->rect_float, out->rect_float);
+       }
+       else {
+               do_cross_effect_byte(facf0, facf1, context.rectx, context.recty,
+                                    (char *) ibuf1->rect, (char *) ibuf2->rect, (char *) out->rect);
+       }
+       return out;
+}
 
+/*********************** overdrop *************************/
 
-static void init_noop(struct Sequence *UNUSED(seq))
+static void do_overdrop_effect(SeqRenderData context, Sequence *UNUSED(seq), float UNUSED(cfra), float facf0, float facf1,
+                               ImBuf *ibuf1, ImBuf *ibuf2, ImBuf *UNUSED(ibuf3), int start_line, int total_lines, ImBuf *out)
 {
+       int x = context.rectx;
+       int y = total_lines;
+
+       if (out->rect_float) {
+               float *rect1 = NULL, *rect2 = NULL, *rect_out = NULL;
+
+               slice_get_float_buffers(&context, ibuf1, ibuf2, NULL, out, start_line, &rect1, &rect2, NULL, &rect_out);
 
+               do_drop_effect_float(facf0, facf1, x, y, rect1, rect2, rect_out);
+               do_alphaover_effect_float(facf0, facf1, x, y, rect1, rect2, rect_out);
+       }
+       else {
+               unsigned char *rect1 = NULL, *rect2 = NULL, *rect_out = NULL;
+
+               slice_get_byte_buffers(&context, ibuf1, ibuf2, NULL, out, start_line, &rect1, &rect2, NULL, &rect_out);
+
+               do_drop_effect_byte(facf0, facf1, x, y, (char *) rect1, (char *) rect2, (char *) rect_out);
+               do_alphaover_effect_byte(facf0, facf1, x, y, (char *) rect1, (char *) rect2, (char *) rect_out);
+       }
 }
 
-static void load_noop(struct Sequence *UNUSED(seq))
+/*********************** sequence effect factory *************************/
+
+static void init_noop(Sequence *UNUSED(seq))
 {
 
 }
 
-static void init_plugin_noop(struct Sequence *UNUSED(seq), const char *UNUSED(fname))
+static void load_noop(Sequence *UNUSED(seq))
 {
 
 }
 
-static void free_noop(struct Sequence *UNUSED(seq))
+static void free_noop(Sequence *UNUSED(seq))
 {
 
 }
@@ -3178,47 +2785,41 @@ static int num_inputs_default(void)
        return 2;
 }
 
-static int early_out_noop(struct Sequence *UNUSED(seq),
-                         float UNUSED(facf0), float UNUSED(facf1))
+static int early_out_noop(Sequence *UNUSED(seq), float UNUSED(facf0), float UNUSED(facf1))
 {
-       return 0;
+       return EARLY_DO_EFFECT;
 }
 
-static int early_out_fade(struct Sequence *UNUSED(seq),
-                         float facf0, float facf1)
+static int early_out_fade(Sequence *UNUSED(seq), float facf0, float facf1)
 {
        if (facf0 == 0.0f && facf1 == 0.0f) {
-               return 1;
+               return EARLY_USE_INPUT_1;
        }
        else if (facf0 == 1.0f && facf1 == 1.0f) {
-               return 2;
+               return EARLY_USE_INPUT_2;
        }
-       return 0;
+       return EARLY_DO_EFFECT;
 }
 
-static int early_out_mul_input2(struct Sequence *UNUSED(seq),
-                               float facf0, float facf1)
+static int early_out_mul_input2(Sequence *UNUSED(seq), float facf0, float facf1)
 {
        if (facf0 == 0.0f && facf1 == 0.0f) {
-               return 1;
+               return EARLY_USE_INPUT_1;
        }
-       return 0;
+       return EARLY_DO_EFFECT;
 }
 
-static void store_icu_yrange_noop(struct Sequence * UNUSED(seq),
-                                 short UNUSED(adrcode), float *UNUSED(ymin), float *UNUSED(ymax))
+static void store_icu_yrange_noop(Sequence *UNUSED(seq), short UNUSED(adrcode), float *UNUSED(ymin), float *UNUSED(ymax))
 {
        /* defaults are fine */
 }
 
-static void get_default_fac_noop(struct Sequence *UNUSED(seq), float UNUSED(cfra),
-                                float * facf0, float * facf1)
+static void get_default_fac_noop(Sequence *UNUSED(seq), float UNUSED(cfra), float *facf0, float *facf1)
 {
        *facf0 = *facf1 = 1.0;
 }
 
-static void get_default_fac_fade(struct Sequence *seq, float cfra,
-                                float * facf0, float * facf1)
+static void get_default_fac_fade(Sequence *seq, float cfra, float *facf0, float *facf1)
 {
        *facf0 = (float)(cfra - seq->startdisp);
        *facf1 = (float)(*facf0 + 0.5f);
@@ -3226,39 +2827,9 @@ static void get_default_fac_fade(struct Sequence *seq, float cfra,
        *facf1 /= seq->len;
 }
 
-static struct ImBuf * do_overdrop_effect(SeqRenderData context, 
-                                        Sequence *UNUSED(seq), 
-                                        float UNUSED(cfra),
-                                        float facf0, float facf1, 
-                                        struct ImBuf * ibuf1, 
-                                        struct ImBuf * ibuf2, 
-                                        struct ImBuf * ibuf3)
+static struct ImBuf *init_execution(SeqRenderData context, ImBuf *ibuf1, ImBuf *ibuf2, ImBuf *ibuf3)
 {
-       struct ImBuf * out = prepare_effect_imbufs(context,ibuf1, ibuf2, ibuf3);
-       int x = context.rectx;
-       int y = context.recty;
-
-       if (out->rect_float) {
-               do_drop_effect_float(
-                       facf0, facf1, x, y,
-                       ibuf1->rect_float, ibuf2->rect_float,
-                       out->rect_float);
-               do_alphaover_effect_float(
-                       facf0, facf1, x, y,
-                       ibuf1->rect_float, ibuf2->rect_float,
-                       out->rect_float);
-       }
-       else {
-               do_drop_effect_byte(
-                       facf0, facf1, x, y,
-                       (char*) ibuf1->rect, 
-                       (char*) ibuf2->rect,
-                       (char*) out->rect);
-               do_alphaover_effect_byte(
-                       facf0, facf1, x, y,
-                       (char*) ibuf1->rect, (char*) ibuf2->rect,
-                       (char*) out->rect);
-       }
+       ImBuf *out = prepare_effect_imbufs(context, ibuf1, ibuf2, ibuf3);
 
        return out;
 }
@@ -3268,8 +2839,9 @@ static struct SeqEffectHandle get_sequence_effect_impl(int seq_type)
        struct SeqEffectHandle rval;
        int sequence_type = seq_type;
 
+       rval.multithreaded = FALSE;
+       rval.supports_mask = FALSE;
        rval.init = init_noop;
-       rval.init_plugin = init_plugin_noop;
        rval.num_inputs = num_inputs_default;
        rval.load = load_noop;
        rval.free = free_noop;
@@ -3277,117 +2849,118 @@ static struct SeqEffectHandle get_sequence_effect_impl(int seq_type)
        rval.get_default_fac = get_default_fac_noop;
        rval.store_icu_yrange = store_icu_yrange_noop;
        rval.execute = NULL;
+       rval.init_execution = init_execution;
+       rval.execute_slice = NULL;
        rval.copy = NULL;
 
        switch (sequence_type) {
-       case SEQ_CROSS:
-               rval.execute = do_cross_effect;
-               rval.early_out = early_out_fade;
-               rval.get_default_fac = get_default_fac_fade;
-               break;
-       case SEQ_GAMCROSS:
-               rval.init = init_gammacross;
-               rval.load = load_gammacross;
-               rval.free = free_gammacross;
-               rval.early_out = early_out_fade;
-               rval.get_default_fac = get_default_fac_fade;
-               rval.execute = do_gammacross_effect;
-               break;
-       case SEQ_ADD:
-               rval.execute = do_add_effect;
-               rval.early_out = early_out_mul_input2;
-               break;
-       case SEQ_SUB:
-               rval.execute = do_sub_effect;
-               rval.early_out = early_out_mul_input2;
-               break;
-       case SEQ_MUL:
-               rval.execute = do_mul_effect;
-               rval.early_out = early_out_mul_input2;
-               break;
-       case SEQ_ALPHAOVER:
-               rval.init = init_alpha_over_or_under;
-               rval.execute = do_alphaover_effect;
-               break;
-       case SEQ_OVERDROP:
-               rval.execute = do_overdrop_effect;
-               break;
-       case SEQ_ALPHAUNDER:
-               rval.init = init_alpha_over_or_under;
-               rval.execute = do_alphaunder_effect;
-               break;
-       case SEQ_WIPE:
-               rval.init = init_wipe_effect;
-               rval.num_inputs = num_inputs_wipe;
-               rval.free = free_wipe_effect;
-               rval.copy = copy_wipe_effect;
-               rval.early_out = early_out_fade;
-               rval.get_default_fac = get_default_fac_fade;
-               rval.execute = do_wipe_effect;
-               break;
-       case SEQ_GLOW:
-               rval.init = init_glow_effect;
-               rval.num_inputs = num_inputs_glow;
-               rval.free = free_glow_effect;
-               rval.copy = copy_glow_effect;
-               rval.execute = do_glow_effect;
-               break;
-       case SEQ_TRANSFORM:
-               rval.init = init_transform_effect;
-               rval.num_inputs = num_inputs_transform;
-               rval.free = free_transform_effect;
-               rval.copy = copy_transform_effect;
-               rval.execute = do_transform_effect;
-               break;
-       case SEQ_SPEED:
-               rval.init = init_speed_effect;
-               rval.num_inputs = num_inputs_speed;
-               rval.load = load_speed_effect;
-               rval.free = free_speed_effect;
-               rval.copy = copy_speed_effect;
-               rval.execute = do_cross_effect;
-               rval.early_out = early_out_speed;
-               rval.store_icu_yrange = store_icu_yrange_speed;
-               break;
-       case SEQ_COLOR:
-               rval.init = init_solid_color;
-               rval.num_inputs = num_inputs_color;
-               rval.early_out = early_out_color;
-               rval.free = free_solid_color;
-               rval.copy = copy_solid_color;
-               rval.execute = do_solid_color;
-               break;
-       case SEQ_PLUGIN:
-               rval.init_plugin = init_plugin;
-               rval.num_inputs = num_inputs_plugin;
-               rval.load = load_plugin;
-               rval.free = free_plugin;
-               rval.copy = copy_plugin;
-               rval.execute = do_plugin_effect;
-               rval.early_out = do_plugin_early_out;
-               rval.get_default_fac = get_default_fac_fade;
-               break;
-       case SEQ_MULTICAM:
-               rval.num_inputs = num_inputs_multicam;
-               rval.early_out = early_out_multicam;
-               rval.execute = do_multicam;
-               break;
-       case SEQ_ADJUSTMENT:
-               rval.num_inputs = num_inputs_adjustment;
-               rval.early_out = early_out_adjustment;
-               rval.execute = do_adjustment;
-               break;
+               case SEQ_TYPE_CROSS:
+                       rval.multithreaded = TRUE;
+                       rval.execute_slice = do_cross_effect;
+                       rval.early_out = early_out_fade;
+                       rval.get_default_fac = get_default_fac_fade;
+                       break;
+               case SEQ_TYPE_GAMCROSS:
+                       rval.multithreaded = TRUE;
+                       rval.init = init_gammacross;
+                       rval.load = load_gammacross;
+                       rval.free = free_gammacross;
+                       rval.early_out = early_out_fade;
+                       rval.get_default_fac = get_default_fac_fade;
+                       rval.init_execution = gammacross_init_execution;
+                       rval.execute_slice = do_gammacross_effect;
+                       break;
+               case SEQ_TYPE_ADD:
+                       rval.multithreaded = TRUE;
+                       rval.execute_slice = do_add_effect;
+                       rval.early_out = early_out_mul_input2;
+                       break;
+               case SEQ_TYPE_SUB:
+                       rval.multithreaded = TRUE;
+                       rval.execute_slice = do_sub_effect;
+                       rval.early_out = early_out_mul_input2;
+                       break;
+               case SEQ_TYPE_MUL:
+                       rval.multithreaded = TRUE;
+                       rval.execute_slice = do_mul_effect;
+                       rval.early_out = early_out_mul_input2;
+                       break;
+               case SEQ_TYPE_ALPHAOVER:
+                       rval.multithreaded = TRUE;
+                       rval.init = init_alpha_over_or_under;
+                       rval.execute_slice = do_alphaover_effect;
+                       break;
+               case SEQ_TYPE_OVERDROP:
+                       rval.multithreaded = TRUE;
+                       rval.execute_slice = do_overdrop_effect;
+                       break;
+               case SEQ_TYPE_ALPHAUNDER:
+                       rval.multithreaded = TRUE;
+                       rval.init = init_alpha_over_or_under;
+                       rval.execute_slice = do_alphaunder_effect;
+                       break;
+               case SEQ_TYPE_WIPE:
+                       rval.init = init_wipe_effect;
+                       rval.num_inputs = num_inputs_wipe;
+                       rval.free = free_wipe_effect;
+                       rval.copy = copy_wipe_effect;
+                       rval.early_out = early_out_fade;
+                       rval.get_default_fac = get_default_fac_fade;
+                       rval.execute = do_wipe_effect;
+                       break;
+               case SEQ_TYPE_GLOW:
+                       rval.init = init_glow_effect;
+                       rval.num_inputs = num_inputs_glow;
+                       rval.free = free_glow_effect;
+                       rval.copy = copy_glow_effect;
+                       rval.execute = do_glow_effect;
+                       break;
+               case SEQ_TYPE_TRANSFORM:
+                       rval.init = init_transform_effect;
+                       rval.num_inputs = num_inputs_transform;
+                       rval.free = free_transform_effect;
+                       rval.copy = copy_transform_effect;
+                       rval.execute = do_transform_effect;
+                       break;
+               case SEQ_TYPE_SPEED:
+                       rval.init = init_speed_effect;
+                       rval.num_inputs = num_inputs_speed;
+                       rval.load = load_speed_effect;
+                       rval.free = free_speed_effect;
+                       rval.copy = copy_speed_effect;
+                       rval.execute = do_speed_effect;
+                       rval.early_out = early_out_speed;
+                       rval.store_icu_yrange = store_icu_yrange_speed;
+                       break;
+               case SEQ_TYPE_COLOR:
+                       rval.init = init_solid_color;
+                       rval.num_inputs = num_inputs_color;
+                       rval.early_out = early_out_color;
+                       rval.free = free_solid_color;
+                       rval.copy = copy_solid_color;
+                       rval.execute = do_solid_color;
+                       break;
+               case SEQ_TYPE_MULTICAM:
+                       rval.num_inputs = num_inputs_multicam;
+                       rval.early_out = early_out_multicam;
+                       rval.execute = do_multicam;
+                       break;
+               case SEQ_TYPE_ADJUSTMENT:
+                       rval.supports_mask = TRUE;
+                       rval.num_inputs = num_inputs_adjustment;
+                       rval.early_out = early_out_adjustment;
+                       rval.execute = do_adjustment;
+                       break;
        }
 
        return rval;
 }
 
-
-struct SeqEffectHandle get_sequence_effect(Sequence * seq)
+struct SeqEffectHandle BKE_sequence_get_effect(Sequence *seq)
 {
-       struct SeqEffectHandle rval= {NULL};
+       struct SeqEffectHandle rval = {FALSE, FALSE, NULL};
 
-       if (seq->type & SEQ_EFFECT) {
+       if (seq->type & SEQ_TYPE_EFFECT) {
                rval = get_sequence_effect_impl(seq->type);
                if ((seq->flag & SEQ_EFFECT_NOT_LOADED) != 0) {
                        rval.load(seq);
@@ -3398,9 +2971,9 @@ struct SeqEffectHandle get_sequence_effect(Sequence * seq)
        return rval;
 }
 
-struct SeqEffectHandle get_sequence_blend(Sequence * seq)
+struct SeqEffectHandle BKE_sequence_get_blend(Sequence *seq)
 {
-       struct SeqEffectHandle rval= {NULL};
+       struct SeqEffectHandle rval = {FALSE, FALSE, NULL};
 
        if (seq->blend_mode != 0) {
                rval = get_sequence_effect_impl(seq->blend_mode);
@@ -3413,13 +2986,20 @@ struct SeqEffectHandle get_sequence_blend(Sequence * seq)
        return rval;
 }
 
-int get_sequence_effect_num_inputs(int seq_type)
+int BKE_sequence_effect_get_num_inputs(int seq_type)
 {
        struct SeqEffectHandle rval = get_sequence_effect_impl(seq_type);
 
        int cnt = rval.num_inputs();
-       if (rval.execute) {
+       if (rval.execute || (rval.execute_slice && rval.init_execution)) {
                return cnt;
        }
        return 0;
 }
+
+int BKE_sequence_effect_get_supports_mask(int seq_type)
+{
+       struct SeqEffectHandle rval = get_sequence_effect_impl(seq_type);
+
+       return rval.supports_mask;
+}