Merging r49681 through r49707 from trunk into soc-2011-tomato
authorSergey Sharybin <sergey.vfx@gmail.com>
Wed, 8 Aug 2012 16:48:05 +0000 (16:48 +0000)
committerSergey Sharybin <sergey.vfx@gmail.com>
Wed, 8 Aug 2012 16:48:05 +0000 (16:48 +0000)
49 files changed:
build_files/cmake/macros.cmake
release/scripts/startup/bl_operators/__init__.py
release/scripts/startup/bl_operators/node.py [new file with mode: 0644]
source/blender/blenkernel/BKE_sequencer.h
source/blender/blenkernel/intern/blender.c
source/blender/blenkernel/intern/image.c
source/blender/blenkernel/intern/scene.c
source/blender/blenkernel/intern/seqcache.c
source/blender/blenkernel/intern/seqeffects.c
source/blender/blenkernel/intern/sequencer.c
source/blender/blenkernel/intern/sound.c
source/blender/blenloader/intern/readfile.c
source/blender/blenloader/intern/versioning_250.c
source/blender/compositor/nodes/COM_DefocusNode.cpp
source/blender/compositor/operations/COM_ConvertDepthToRadiusOperation.cpp
source/blender/compositor/operations/COM_FastGaussianBlurOperation.cpp
source/blender/compositor/operations/COM_FastGaussianBlurOperation.h
source/blender/editors/animation/anim_channels_edit.c
source/blender/editors/animation/anim_deps.c
source/blender/editors/animation/anim_filter.c
source/blender/editors/interface/interface_anim.c
source/blender/editors/render/render_internal.c
source/blender/editors/render/render_opengl.c
source/blender/editors/space_action/action_select.c
source/blender/editors/space_file/filelist.c
source/blender/editors/space_file/space_file.c
source/blender/editors/space_graph/graph_select.c
source/blender/editors/space_nla/nla_channels.c
source/blender/editors/space_nla/nla_select.c
source/blender/editors/space_node/drawnode.c
source/blender/editors/space_node/node_header.c
source/blender/editors/space_sequencer/sequencer_add.c
source/blender/editors/space_sequencer/sequencer_draw.c
source/blender/editors/space_sequencer/sequencer_edit.c
source/blender/editors/space_sequencer/sequencer_select.c
source/blender/editors/transform/transform_conversions.c
source/blender/imbuf/IMB_moviecache.h
source/blender/imbuf/intern/filter.c
source/blender/imbuf/intern/moviecache.c
source/blender/imbuf/intern/scaling.c
source/blender/makesrna/intern/rna_scene.c
source/blender/makesrna/intern/rna_screen.c
source/blender/makesrna/intern/rna_sequencer.c
source/blender/makesrna/intern/rna_sequencer_api.c
source/blender/makesrna/intern/rna_space.c
source/blender/nodes/composite/nodes/node_composite_defocus.c
source/blender/render/intern/source/pipeline.c
source/blender/windowmanager/intern/wm_init_exit.c
source/blenderplayer/bad_level_call_stubs/stubs.c

index 90ab0189a0946f0855ce365eae37028b86c34943..522a07ff7b23e59a3c1f43f770f333c6979ccab0 100644 (file)
@@ -731,3 +731,31 @@ macro(set_lib_path
                set(${lvar} ${LIBDIR}/${lproj})
        endif()
 endmacro()
+
+
+# not highly optimal, may replace with generated C program like makesdna
+function(data_to_c
+         file_from file_to var_name)
+
+       file(READ ${file_from} file_from_string HEX)
+       string(LENGTH ${file_from_string} _max_index)
+       math(EXPR size_on_disk ${_max_index}/2)
+
+       file(REMOVE ${file_to})
+
+       file(APPEND ${file_to} "int  ${var_name}_size = ${size_on_disk};\n")
+       file(APPEND ${file_to} "char ${var_name}[] = {")
+
+       set(_index 0)
+
+       while(NOT _index EQUAL _max_index)
+               string(SUBSTRING "${file_from_string}" ${_index} 2 _pair)
+               file(APPEND ${file_to} "0x${_pair},")
+               math(EXPR _index ${_index}+2)
+       endwhile()
+       file(APPEND ${file_to} "};\n")
+endfunction()
+
+# eg
+# data_to_c("/home/guest/test.txt" "/home/guest/test.txt.h" "this_is_data")
+
index 06b4429d25ca2143c4f7fd3a1106e179f1b711a5..ecbbe34dbb48ee77ae71790a72379679d4f4785b 100644 (file)
@@ -29,6 +29,7 @@ _modules = (
     "console",
     "image",
     "mesh",
+    "node",
     "object_align",
     "object",
     "object_randomize_transform",
diff --git a/release/scripts/startup/bl_operators/node.py b/release/scripts/startup/bl_operators/node.py
new file mode 100644 (file)
index 0000000..0927f13
--- /dev/null
@@ -0,0 +1,100 @@
+# ##### BEGIN GPL LICENSE BLOCK #####
+#
+#  This program is free software; you can redistribute it and/or
+#  modify it under the terms of the GNU General Public License
+#  as published by the Free Software Foundation; either version 2
+#  of the License, or (at your option) any later version.
+#
+#  This program is distributed in the hope that it will be useful,
+#  but WITHOUT ANY WARRANTY; without even the implied warranty of
+#  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+#  GNU General Public License for more details.
+#
+#  You should have received a copy of the GNU General Public License
+#  along with this program; if not, write to the Free Software Foundation,
+#  Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
+#
+# ##### END GPL LICENSE BLOCK #####
+
+# <pep8-80 compliant>
+
+import bpy
+from bpy.types import Operator
+from bpy.props import (EnumProperty,
+                       FloatVectorProperty,
+                       StringProperty,
+                       CollectionProperty
+                       )
+
+# XXX These node item lists should actually be generated by a callback at operator execution time (see node_type_items below),
+# using the active node tree from the context. Due to a difficult bug in bpy this is not possible (item list memory gets freed too early),
+# so for now just copy the static item lists to these global variables.
+#
+# In the custom_nodes branch, the static per-tree-type node items are replaced by a single independent type list anyway (with a poll function
+# to limit node types to the respective trees). So this workaround is only temporary.
+
+node_type_items_dict = {}
+node_type_items_dict['SHADER'] = [(item.identifier, item.name, item.description, item.value) for item in bpy.types.ShaderNode.bl_rna.properties['type'].enum_items]
+node_type_items_dict['COMPOSITING'] = [(item.identifier, item.name, item.description, item.value) for item in bpy.types.CompositorNode.bl_rna.properties['type'].enum_items]
+node_type_items_dict['TEXTURE'] = [(item.identifier, item.name, item.description, item.value) for item in bpy.types.TextureNode.bl_rna.properties['type'].enum_items]
+
+# Returns the enum item list for the edited tree in the context
+def node_type_items(self, context):
+    snode = context.space_data
+    if not snode:
+        return []
+    tree = snode.edit_tree
+    if not tree:
+        return []
+    
+    # XXX Does not work correctly, see comment above
+    #return [(item.identifier, item.name, item.description, item.value) for item in tree.nodes.bl_rna.functions['new'].parameters['type'].enum_items]
+    
+    if tree.type in node_type_items_dict:
+        return node_type_items_dict[tree.type]
+    else:
+        return []
+
+class NODE_OT_add_search(bpy.types.Operator):
+    '''Add a node to the active tree'''
+    bl_idname = "node.add_search"
+    bl_label = "Search and Add Node"
+    bl_options = {'REGISTER', 'UNDO'}
+
+    # XXX this should be called 'node_type' but the operator search property is hardcoded to 'type' by a hack in bpy_operator_wrap.c ...
+    type = EnumProperty(items=node_type_items, name="Node Type", description="Node type")
+
+    def create_node(self, context):
+        space = context.space_data
+        tree = space.edit_tree
+        
+        node = tree.nodes.new(type=self.type)
+        for n in tree.nodes:
+            if n==node:
+                node.select = True
+                tree.nodes.active = node
+            else:
+                node.select = False
+        node.location = space.cursor_location
+        return node
+    
+    @classmethod
+    def poll(cls, context):
+        space = context.space_data
+        # needs active node editor and a tree to add nodes to
+        return space.type == 'NODE_EDITOR' and space.edit_tree
+
+    def execute(self, context):
+        self.create_node(context)
+        return {'FINISHED'}
+
+    def invoke(self, context, event):
+        space = context.space_data
+        v2d = context.region.view2d
+
+        # convert mouse position to the View2D for later node placement
+        space.cursor_location = v2d.region_to_view(event.mouse_region_x, event.mouse_region_y)
+        
+        context.window_manager.invoke_search_popup(self)
+        return {'CANCELLED'}
+
index a8890d5a37e520d4a8234b6b3f8de8812c46fd61..78e65fe3ea65e43e76781b526593399be678a266 100644 (file)
@@ -61,26 +61,29 @@ typedef struct SeqIterator {
        int valid;
 } SeqIterator;
 
-void seq_begin(struct Editing *ed, SeqIterator *iter, int use_pointer);
-void seq_next(SeqIterator *iter);
-void seq_end(SeqIterator *iter);
-void seq_array(struct Editing *ed, struct Sequence ***seqarray, int *tot, int use_pointer);
+void BKE_seqence_iterator_begin(struct Editing *ed, SeqIterator *iter, int use_pointer);
+void BKE_seqence_iterator_next(SeqIterator *iter);
+void BKE_seqence_iterator_end(SeqIterator *iter);
 
 #define SEQP_BEGIN(ed, _seq)                                                  \
        {                                                                         \
                SeqIterator iter;                                                     \
-               for (seq_begin(ed, &iter, 1); iter.valid; seq_next(&iter)) {          \
+               for (BKE_seqence_iterator_begin(ed, &iter, 1);                        \
+                    iter.valid;                                                      \
+                    BKE_seqence_iterator_next(&iter)) {                              \
                        _seq = iter.seq;
                        
 #define SEQ_BEGIN(ed, _seq)                                                   \
        {                                                                         \
                SeqIterator iter;                                                     \
-               for (seq_begin(ed, &iter, 0); iter.valid; seq_next(&iter)) {          \
+               for (BKE_seqence_iterator_begin(ed, &iter, 0);                        \
+                    iter.valid;                                                      \
+                    BKE_seqence_iterator_next(&iter)) {                              \
                        _seq = iter.seq;
 
 #define SEQ_END                                                               \
                }                                                                     \
-               seq_end(&iter);                                                       \
+               BKE_seqence_iterator_end(&iter);                                      \
        }
 
 typedef struct SeqRenderData {
@@ -93,12 +96,8 @@ typedef struct SeqRenderData {
        float motion_blur_shutter;
 } SeqRenderData;
 
-SeqRenderData seq_new_render_data(
-    struct Main *bmain, struct Scene *scene,
-    int rectx, int recty, int preview_render_size);
-
-int seq_cmp_render_data(const SeqRenderData *a, const SeqRenderData *b);
-unsigned int seq_hash_render_data(const SeqRenderData *a);
+SeqRenderData BKE_sequencer_new_render_data(struct Main *bmain, struct Scene *scene, int rectx, int recty,
+                                            int preview_render_size);
 
 /* Wipe effect */
 enum {
@@ -110,8 +109,9 @@ enum {
        DO_CLOCK_WIPE
 };
 
-
 struct SeqEffectHandle {
+       int multithreaded;
+
        /* constructors & destructor */
        /* init is _only_ called on first creation */
        void (*init)(struct Sequence *seq);
@@ -147,27 +147,29 @@ struct SeqEffectHandle {
         * float-rects or byte-rects
         * (mixed cases are handled one layer up...) */
        
-       struct ImBuf * (*execute)(SeqRenderData context,
-                                 struct Sequence *seq, float cfra,
-                                 float facf0, float facf1,
-                                 struct ImBuf *ibuf1, struct ImBuf *ibuf2,
-                                 struct ImBuf *ibuf3);
+       struct ImBuf * (*execute)(SeqRenderData context, struct Sequence *seq, float cfra, float facf0, float facf1,
+                                 struct ImBuf *ibuf1, struct ImBuf *ibuf2, struct ImBuf *ibuf3);
+
+       struct ImBuf * (*init_execution)(SeqRenderData context, struct ImBuf *ibuf1, struct ImBuf *ibuf2, struct ImBuf *ibuf3);
+
+       void (*execute_slice)(SeqRenderData context, struct Sequence *seq, float cfra, float facf0, float facf1,
+                             struct ImBuf *ibuf1, struct ImBuf *ibuf2, struct ImBuf *ibuf3,
+                              int start_line, int total_lines, struct ImBuf *out);
 };
 
 /* ********************* prototypes *************** */
 
 /* **********************************************************************
- * sequence.c
+ * sequencer.c
  *
  * sequencer render functions
  * ********************************************************************** */
 
-struct ImBuf *give_ibuf_seq(SeqRenderData context, float cfra, int chanshown);
-struct ImBuf *give_ibuf_seq_threaded(SeqRenderData context, float cfra, int chanshown);
-struct ImBuf *give_ibuf_seq_direct(SeqRenderData context, float cfra, struct Sequence *seq);
-struct ImBuf *give_ibuf_seqbase(SeqRenderData context, float cfra, int chan_shown, struct ListBase *seqbasep);
-void give_ibuf_prefetch_request(SeqRenderData context, float cfra, int chan_shown);
-
+struct ImBuf *BKE_sequencer_give_ibuf(SeqRenderData context, float cfra, int chanshown);
+struct ImBuf *BKE_sequencer_give_ibuf_threaded(SeqRenderData context, float cfra, int chanshown);
+struct ImBuf *BKE_sequencer_give_ibuf_direct(SeqRenderData context, float cfra, struct Sequence *seq);
+struct ImBuf *BKE_sequencer_give_ibuf_seqbase(SeqRenderData context, float cfra, int chan_shown, struct ListBase *seqbasep);
+void BKE_sequencer_give_ibuf_prefetch_request(SeqRenderData context, float cfra, int chan_shown);
 
 /* **********************************************************************
  * sequencer scene functions
@@ -179,43 +181,35 @@ void             BKE_sequencer_editing_free(struct Scene *scene);
 void             BKE_sequencer_sort(struct Scene *scene);
 
 struct Sequence *BKE_sequencer_active_get(struct Scene *scene);
-int              BKE_sequencer_active_get_pair(struct Scene *scene,
-                                               struct Sequence **seq_act, struct Sequence **seq_other);
+int              BKE_sequencer_active_get_pair(struct Scene *scene, struct Sequence **seq_act, struct Sequence **seq_other);
 void             BKE_sequencer_active_set(struct Scene *scene, struct Sequence *seq);
-struct Mask      *BKE_sequencer_mask_get(struct Scene *scene);
+struct Mask     *BKE_sequencer_mask_get(struct Scene *scene);
 
 /* apply functions recursively */
-int seqbase_recursive_apply(struct ListBase *seqbase, int (*apply_func)(struct Sequence *seq, void *), void *arg);
-int seq_recursive_apply(struct Sequence *seq, int (*apply_func)(struct Sequence *, void *), void *arg);
+int BKE_sequencer_base_recursive_apply(struct ListBase *seqbase, int (*apply_func)(struct Sequence *seq, void *), void *arg);
+int BKE_sequencer_recursive_apply(struct Sequence *seq, int (*apply_func)(struct Sequence *, void *), void *arg);
 
 /* maintenance functions, mostly for RNA */
-// extern 
-void seq_free_sequence(struct Scene *scene, struct Sequence *seq);
-void seq_free_sequence_recurse(struct Scene *scene, struct Sequence *seq);
-void seq_free_strip(struct Strip *strip);
-
-void seq_free_clipboard(void);
-const char *give_seqname(struct Sequence *seq);
-void calc_sequence(struct Scene *scene, struct Sequence *seq);
-void calc_sequence_disp(struct Scene *scene, struct Sequence *seq);
-void reload_sequence_new_file(struct Scene *scene, struct Sequence *seq, int lock_range);
-void build_seqar_cb(struct ListBase *seqbase, struct Sequence  ***seqar, int *totseq,
-                    int (*test_func)(struct Sequence *seq));
-int evaluate_seq_frame(struct Scene *scene, int cfra);
-struct StripElem *give_stripelem(struct Sequence *seq, int cfra);
-
-// intern
-void printf_strip(struct Sequence *seq); // debugging function (unused)
-void update_changed_seq_and_deps(struct Scene *scene, struct Sequence *changed_seq, int len_change, int ibuf_change);
-
-int input_have_to_preprocess(
-    SeqRenderData context, struct Sequence *seq, float cfra);
-
-struct SeqIndexBuildContext *seq_proxy_rebuild_context(struct Main *bmain, struct Scene *scene, struct Sequence *seq);
-void seq_proxy_rebuild(struct SeqIndexBuildContext *context,
-                       short *stop, short *do_update, float *progress);
-void seq_proxy_rebuild_finish(struct SeqIndexBuildContext *context, short stop);
+/* extern  */
+
+void BKE_sequencer_free_clipboard(void);
+
+void BKE_sequence_free(struct Scene *scene, struct Sequence *seq);
+const char *BKE_sequence_give_name(struct Sequence *seq);
+void BKE_sequence_calc(struct Scene *scene, struct Sequence *seq);
+void BKE_sequence_calc_disp(struct Scene *scene, struct Sequence *seq);
+void BKE_sequence_reload_new_file(struct Scene *scene, struct Sequence *seq, int lock_range);
+int BKE_sequencer_evaluate_frame(struct Scene *scene, int cfra);
 
+struct StripElem *BKE_sequencer_give_stripelem(struct Sequence *seq, int cfra);
+
+/* intern */
+void BKE_sequencer_update_changed_seq_and_deps(struct Scene *scene, struct Sequence *changed_seq, int len_change, int ibuf_change);
+int BKE_sequencer_input_have_to_preprocess(SeqRenderData context, struct Sequence *seq, float cfra);
+
+struct SeqIndexBuildContext *BKE_sequencer_proxy_rebuild_context(struct Main *bmain, struct Scene *scene, struct Sequence *seq);
+void BKE_sequencer_proxy_rebuild(struct SeqIndexBuildContext *context, short *stop, short *do_update, float *progress);
+void BKE_sequencer_proxy_rebuild_finish(struct SeqIndexBuildContext *context, short stop);
 
 /* **********************************************************************
  * seqcache.c
@@ -230,20 +224,20 @@ typedef enum {
        SEQ_STRIPELEM_IBUF_ENDSTILL
 } seq_stripelem_ibuf_t;
 
-void seq_stripelem_cache_destruct(void);
-void seq_stripelem_cache_cleanup(void);
+void BKE_sequencer_cache_destruct(void);
+void BKE_sequencer_cache_cleanup(void);
 
 /* returned ImBuf is properly refed and has to be freed */
-struct ImBuf *seq_stripelem_cache_get(SeqRenderData context, struct Sequence *seq,
-                                      float cfra, seq_stripelem_ibuf_t type);
+struct ImBuf *BKE_sequencer_cache_get(SeqRenderData context, struct Sequence *seq, float cfra, seq_stripelem_ibuf_t type);
 
 /* passed ImBuf is properly refed, so ownership is *not* 
  * transfered to the cache.
  * you can pass the same ImBuf multiple times to the cache without problems.
  */
-   
-void seq_stripelem_cache_put(SeqRenderData context, struct Sequence *seq,
-                             float cfra, seq_stripelem_ibuf_t type, struct ImBuf *nval);
+
+void BKE_sequencer_cache_put(SeqRenderData context, struct Sequence *seq, float cfra, seq_stripelem_ibuf_t type, struct ImBuf *nval);
+
+void BKE_sequencer_cache_cleanup_sequence(struct Sequence *seq);
 
 /* **********************************************************************
  * seqeffects.c
@@ -253,13 +247,12 @@ void seq_stripelem_cache_put(SeqRenderData context, struct Sequence *seq,
  */
 
 /* intern */
-struct SeqEffectHandle get_sequence_blend(struct Sequence *seq);
-void sequence_effect_speed_rebuild_map(struct Scene *scene, struct Sequence *seq, int force);
+struct SeqEffectHandle BKE_sequence_get_blend(struct Sequence *seq);
+void BKE_sequence_effect_speed_rebuild_map(struct Scene *scene, struct Sequence *seq, int force);
 
 /* extern */
-struct SeqEffectHandle get_sequence_effect(struct Sequence *seq);
-int get_sequence_effect_num_inputs(int seq_type);
-
+struct SeqEffectHandle BKE_sequence_get_effect(struct Sequence *seq);
+int BKE_sequence_effect_get_num_inputs(int seq_type);
 
 /* **********************************************************************
  * Sequencer editing functions
@@ -267,43 +260,43 @@ int get_sequence_effect_num_inputs(int seq_type);
  */
    
 /* for transform but also could use elsewhere */
-int seq_tx_get_start(struct Sequence *seq);
-int seq_tx_get_end(struct Sequence *seq);
-int seq_tx_get_final_left(struct Sequence *seq, int metaclip);
-int seq_tx_get_final_right(struct Sequence *seq, int metaclip);
-void seq_tx_set_final_left(struct Sequence *seq, int val);
-void seq_tx_set_final_right(struct Sequence *seq, int val);
-void seq_tx_handle_xlimits(struct Sequence *seq, int leftflag, int rightflag);
-int seq_tx_test(struct Sequence *seq);
-int seq_single_check(struct Sequence *seq);
-void seq_single_fix(struct Sequence *seq);
-int seq_test_overlap(struct ListBase *seqbasep, struct Sequence *test);
-void seq_translate(struct Scene *scene, struct Sequence *seq, int delta);
-void seq_sound_init(struct Scene *scene, struct Sequence *seq);
-struct Sequence *seq_foreground_frame_get(struct Scene *scene, int frame);
-struct ListBase *seq_seqbase(struct ListBase *seqbase, struct Sequence *seq);
-struct Sequence *seq_metastrip(ListBase *seqbase /* = ed->seqbase */,
-                               struct Sequence *meta /* = NULL */, struct Sequence *seq);
-
-void seq_offset_animdata(struct Scene *scene, struct Sequence *seq, int ofs);
-void seq_dupe_animdata(struct Scene *scene, const char *name_src, const char *name_dst);
-int shuffle_seq(struct ListBase *seqbasep, struct Sequence *test, struct Scene *evil_scene);
-int shuffle_seq_time(ListBase *seqbasep, struct Scene *evil_scene);
-int seqbase_isolated_sel_check(struct ListBase *seqbase);
-void free_imbuf_seq(struct Scene *scene, struct ListBase *seqbasep, int check_mem_usage, int keep_file_handles);
-struct Sequence *seq_dupli_recursive(struct Scene *scene, struct Scene *scene_to, struct Sequence *seq, int dupe_flag);
-int seq_swap(struct Sequence *seq_a, struct Sequence *seq_b, const char **error_str);
-
-void seq_update_sound_bounds_all(struct Scene *scene);
-void seq_update_sound_bounds(struct Scene *scene, struct Sequence *seq);
-void seq_update_muting(struct Editing *ed);
-void seq_update_sound(struct Scene *scene, struct bSound *sound);
-void seqbase_unique_name_recursive(ListBase *seqbasep, struct Sequence *seq);
-void seqbase_dupli_recursive(struct Scene *scene, struct Scene *scene_to, ListBase *nseqbase, ListBase *seqbase, int dupe_flag);
-
-void clear_scene_in_allseqs(struct Main *bmain, struct Scene *sce);
-
-struct Sequence *get_seq_by_name(struct ListBase *seqbase, const char *name, int recursive);
+int BKE_sequence_tx_get_final_left(struct Sequence *seq, int metaclip);
+int BKE_sequence_tx_get_final_right(struct Sequence *seq, int metaclip);
+void BKE_sequence_tx_set_final_left(struct Sequence *seq, int val);
+void BKE_sequence_tx_set_final_right(struct Sequence *seq, int val);
+void BKE_sequence_tx_handle_xlimits(struct Sequence *seq, int leftflag, int rightflag);
+int BKE_sequence_tx_test(struct Sequence *seq);
+int BKE_sequence_single_check(struct Sequence *seq);
+void BKE_sequence_single_fix(struct Sequence *seq);
+int BKE_sequence_test_overlap(struct ListBase *seqbasep, struct Sequence *test);
+void BKE_sequence_translate(struct Scene *scene, struct Sequence *seq, int delta);
+void BKE_sequence_sound_init(struct Scene *scene, struct Sequence *seq);
+struct Sequence *BKE_sequencer_foreground_frame_get(struct Scene *scene, int frame);
+struct ListBase *BKE_sequence_seqbase(struct ListBase *seqbase, struct Sequence *seq);
+struct Sequence *BKE_sequence_metastrip(ListBase *seqbase /* = ed->seqbase */, struct Sequence *meta /* = NULL */, struct Sequence *seq);
+
+void BKE_sequencer_offset_animdata(struct Scene *scene, struct Sequence *seq, int ofs);
+void BKE_sequencer_dupe_animdata(struct Scene *scene, const char *name_src, const char *name_dst);
+int BKE_sequence_base_shuffle(struct ListBase *seqbasep, struct Sequence *test, struct Scene *evil_scene);
+int BKE_sequence_base_shuffle_time(ListBase *seqbasep, struct Scene *evil_scene);
+int BKE_sequence_base_isolated_sel_check(struct ListBase *seqbase);
+void BKE_sequencer_free_imbuf(struct Scene *scene, struct ListBase *seqbasep, int check_mem_usage, int keep_file_handles);
+struct Sequence *BKE_sequence_dupli_recursive(struct Scene *scene, struct Scene *scene_to, struct Sequence *seq, int dupe_flag);
+int BKE_sequence_swap(struct Sequence *seq_a, struct Sequence *seq_b, const char **error_str);
+
+void BKE_sequence_invalidate_cache(struct Scene *scene, struct Sequence *seq);
+
+void BKE_sequencer_update_sound_bounds_all(struct Scene *scene);
+void BKE_sequencer_update_sound_bounds(struct Scene *scene, struct Sequence *seq);
+void BKE_sequencer_update_muting(struct Editing *ed);
+void BKE_sequencer_update_sound(struct Scene *scene, struct bSound *sound);
+
+void BKE_seqence_base_unique_name_recursive(ListBase *seqbasep, struct Sequence *seq);
+void BKE_sequence_base_dupli_recursive(struct Scene *scene, struct Scene *scene_to, ListBase *nseqbase, ListBase *seqbase, int dupe_flag);
+
+void BKE_sequencer_clear_scene_in_allseqs(struct Main *bmain, struct Scene *sce);
+
+struct Sequence *BKE_sequwnce_get_by_name(struct ListBase *seqbase, const char *name, int recursive);
 
 /* api for adding new sequence strips */
 typedef struct SeqLoadInfo {
@@ -335,13 +328,11 @@ typedef struct SeqLoadInfo {
 /* use as an api function */
 typedef struct Sequence *(*SeqLoadFunc)(struct bContext *, ListBase *, struct SeqLoadInfo *);
 
-struct Sequence *alloc_sequence(ListBase *lb, int cfra, int machine);
-
-void seq_load_apply(struct Scene *scene, struct Sequence *seq, struct SeqLoadInfo *seq_load);
+struct Sequence *BKE_sequence_alloc(ListBase *lb, int cfra, int machine);
 
-struct Sequence *sequencer_add_image_strip(struct bContext *C, ListBase *seqbasep, struct SeqLoadInfo *seq_load);
-struct Sequence *sequencer_add_sound_strip(struct bContext *C, ListBase *seqbasep, struct SeqLoadInfo *seq_load);
-struct Sequence *sequencer_add_movie_strip(struct bContext *C, ListBase *seqbasep, struct SeqLoadInfo *seq_load);
+struct Sequence *BKE_sequencer_add_image_strip(struct bContext *C, ListBase *seqbasep, struct SeqLoadInfo *seq_load);
+struct Sequence *BKE_sequencer_add_sound_strip(struct bContext *C, ListBase *seqbasep, struct SeqLoadInfo *seq_load);
+struct Sequence *BKE_sequencer_add_movie_strip(struct bContext *C, ListBase *seqbasep, struct SeqLoadInfo *seq_load);
 
 /* view3d draw callback, run when not in background view */
 typedef struct ImBuf *(*SequencerDrawView)(struct Scene *, struct Object *, int, int, unsigned int, int, int, char[256]);
@@ -351,4 +342,4 @@ extern SequencerDrawView sequencer_view3d_cb;
 extern ListBase seqbase_clipboard;
 extern int seqbase_clipboard_frame;
 
-#endif // __BKE_SEQUENCER_H__
+#endif /* __BKE_SEQUENCER_H__ */
index e89b82138e32cfbfd7b84dc0a1999920d6ccfd31..0e1228cf51d1114114f3bdb7dbdb7cc455a471b5 100644 (file)
@@ -118,7 +118,7 @@ void free_blender(void)
 
        BLI_callback_global_finalize();
 
-       seq_stripelem_cache_destruct();
+       BKE_sequencer_cache_destruct();
        IMB_moviecache_destruct();
        
        free_nodesystem();      
index ebdf2f724081b96eedd35b1a60d74739b0d28a96..cdee0d98a2510359bcb313a19497fc36be130edb 100644 (file)
@@ -1462,7 +1462,7 @@ static void stampdata(Scene *scene, Object *camera, StampData *stamp_data, int d
        }
 
        if (scene->r.stamp & R_STAMP_SEQSTRIP) {
-               Sequence *seq = seq_foreground_frame_get(scene, scene->r.cfra);
+               Sequence *seq = BKE_sequencer_foreground_frame_get(scene, scene->r.cfra);
 
                if (seq) BLI_strncpy(text, seq->name + 2, sizeof(text));
                else BLI_strncpy(text, "<none>", sizeof(text));
index 22cb202e0193f2bc98c407b6535f10aab0028f90..444fbb2fc9f4ed643d3480e0ed2954bcbf666bdc 100644 (file)
@@ -247,7 +247,7 @@ Scene *BKE_scene_copy(Scene *sce, int type)
                if (sce->ed) {
                        scen->ed = MEM_callocN(sizeof(Editing), "addseq");
                        scen->ed->seqbasep = &scen->ed->seqbase;
-                       seqbase_dupli_recursive(sce, scen, &scen->ed->seqbase, &sce->ed->seqbase, SEQ_DUPE_ALL);
+                       BKE_sequence_base_dupli_recursive(sce, scen, &scen->ed->seqbase, &sce->ed->seqbase, SEQ_DUPE_ALL);
                }
        }
 
@@ -652,7 +652,7 @@ void BKE_scene_unlink(Main *bmain, Scene *sce, Scene *newsce)
                        sce1->set = NULL;
        
        /* check all sequences */
-       clear_scene_in_allseqs(bmain, sce);
+       BKE_sequencer_clear_scene_in_allseqs(bmain, sce);
 
        /* check render layer nodes in other scenes */
        clear_scene_in_nodes(bmain, sce);
index 0d91dcb7faad0dc0490f6ddf626c591ee4a98a20..a4ea5d1fb2634548e723a904d51d10f78ce9b1f0 100644 (file)
@@ -37,6 +37,7 @@
 #include "BKE_sequencer.h"
 
 #include "IMB_moviecache.h"
+#include "IMB_imbuf_types.h"
 
 typedef struct SeqCacheKey {
        struct Sequence *seq;
@@ -47,6 +48,73 @@ typedef struct SeqCacheKey {
 
 static struct MovieCache *moviecache = NULL;
 
+static int seq_cmp_render_data(const SeqRenderData *a, const SeqRenderData *b)
+{
+       if (a->preview_render_size < b->preview_render_size) {
+               return -1;
+       }
+       if (a->preview_render_size > b->preview_render_size) {
+               return 1;
+       }
+
+       if (a->rectx < b->rectx) {
+               return -1;
+       }
+       if (a->rectx > b->rectx) {
+               return 1;
+       }
+
+       if (a->recty < b->recty) {
+               return -1;
+       }
+       if (a->recty > b->recty) {
+               return 1;
+       }
+
+       if (a->bmain < b->bmain) {
+               return -1;
+       }
+       if (a->bmain > b->bmain) {
+               return 1;
+       }
+
+       if (a->scene < b->scene) {
+               return -1;
+       }
+       if (a->scene > b->scene) {
+               return 1;
+       }
+
+       if (a->motion_blur_shutter < b->motion_blur_shutter) {
+               return -1;
+       }
+       if (a->motion_blur_shutter > b->motion_blur_shutter) {
+               return 1;
+       }
+
+       if (a->motion_blur_samples < b->motion_blur_samples) {
+               return -1;
+       }
+       if (a->motion_blur_samples > b->motion_blur_samples) {
+               return 1;
+       }
+
+       return 0;
+}
+
+static unsigned int seq_hash_render_data(const SeqRenderData *a)
+{
+       unsigned int rval = a->rectx + a->recty;
+
+       rval ^= a->preview_render_size;
+       rval ^= ((intptr_t) a->bmain) << 6;
+       rval ^= ((intptr_t) a->scene) << 6;
+       rval ^= (int)(a->motion_blur_shutter * 100.0f) << 10;
+       rval ^= a->motion_blur_samples << 24;
+
+       return rval;
+}
+
 static unsigned int seqcache_hashhash(const void *key_)
 {
        const SeqCacheKey *key = (SeqCacheKey *) key_;
@@ -88,13 +156,13 @@ static int seqcache_hashcmp(const void *a_, const void *b_)
        return seq_cmp_render_data(&a->context, &b->context);
 }
 
-void seq_stripelem_cache_destruct(void)
+void BKE_sequencer_cache_destruct(void)
 {
        if (moviecache)
                IMB_moviecache_free(moviecache);
 }
 
-void seq_stripelem_cache_cleanup(void)
+void BKE_sequencer_cache_cleanup(void)
 {
        if (moviecache) {
                IMB_moviecache_free(moviecache);
@@ -102,11 +170,21 @@ void seq_stripelem_cache_cleanup(void)
        }
 }
 
-struct ImBuf *seq_stripelem_cache_get(
-        SeqRenderData context, struct Sequence *seq,
-        float cfra, seq_stripelem_ibuf_t type)
+static int seqcache_key_check_seq(void *userkey, void *userdata)
 {
+       SeqCacheKey *key = (SeqCacheKey *) userkey;
+       Sequence *seq = (Sequence *) userdata;
 
+       return key->seq == seq;
+}
+
+void BKE_sequencer_cache_cleanup_sequence(Sequence *seq)
+{
+       IMB_moviecache_cleanup(moviecache, seqcache_key_check_seq, seq);
+}
+
+struct ImBuf *BKE_sequencer_cache_get(SeqRenderData context, Sequence *seq, float cfra, seq_stripelem_ibuf_t type)
+{
        if (moviecache && seq) {
                SeqCacheKey key;
 
@@ -121,9 +199,7 @@ struct ImBuf *seq_stripelem_cache_get(
        return NULL;
 }
 
-void seq_stripelem_cache_put(
-        SeqRenderData context, struct Sequence *seq,
-        float cfra, seq_stripelem_ibuf_t type, struct ImBuf *i)
+void BKE_sequencer_cache_put(SeqRenderData context, Sequence *seq, float cfra, seq_stripelem_ibuf_t type, ImBuf *i)
 {
        SeqCacheKey key;
 
index 0532a019ecc3e6bf3193e590e8e4f70a5a2a7e20..938d11400a61cee2e4155470e8d54ebff536e396 100644 (file)
 
 #include "RNA_access.h"
 
-/* **** XXX **** */
+static void slize_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 slize_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;
+
+       if (ibuf3)
+               *rect3 = ibuf3->rect_float + offset;
+}
+
+/*********************** Glow effect *************************/
 
-/* Glow effect */
 enum {
        GlowR = 0,
        GlowG = 1,
@@ -66,12 +97,9 @@ enum {
        GlowA = 3
 };
 
-static 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;
 
@@ -114,9 +142,7 @@ static ImBuf *prepare_effect_imbufs(
        return out;
 }
 
-/* **********************************************************************
- * ALPHA OVER
- * ********************************************************************** */
+/*********************** Alpha Over *************************/
 
 static void init_alpha_over_or_under(Sequence *seq)
 {
@@ -127,23 +153,21 @@ static void init_alpha_over_or_under(Sequence *seq)
        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;
+       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;
                while (x--) {
 
@@ -152,8 +176,8 @@ static void do_alphaover_effect_byte(float facf0, float facf1, int x, int y,
                        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;
@@ -172,12 +196,11 @@ static void do_alphaover_effect_byte(float facf0, float facf1, int x, int y,
 
                x = xo;
                while (x--) {
-
                        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;
@@ -193,8 +216,7 @@ static void do_alphaover_effect_byte(float facf0, float facf1, int x, int y,
        }
 }
 
-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;
@@ -209,10 +231,8 @@ static void do_alphaover_effect_float(float facf0, float facf1, int x, int y,
        fac4 = facf1;
 
        while (y--) {
-
                x = xo;
                while (x--) {
-
                        /* rt = rt1 over rt2  (alpha from rt1) */
 
                        fac = fac2;
@@ -233,12 +253,12 @@ static void do_alphaover_effect_float(float facf0, float facf1, int x, int y,
                        rt1 += 4; rt2 += 4; rt += 4;
                }
 
-               if (y == 0) break;
+               if (y == 0)
+                       break;
                y--;
 
                x = xo;
                while (x--) {
-
                        fac = fac4;
                        mfac = 1.0f - (fac4 * rt1[3]);
 
@@ -259,37 +279,29 @@ static void do_alphaover_effect_float(float facf0, float facf1, int x, int y,
        }
 }
 
-static 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, *rect2, *rect_out;
+
+               slize_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, *rect2, *rect_out;
+
+               slize_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;
@@ -304,22 +316,20 @@ static void do_alphaunder_effect_byte(
        fac4 = (int)(256.0f * facf1);
 
        while (y--) {
-
                x = xo;
                while (x--) {
-
                        /* rt = rt1 under rt2  (alpha from rt2) */
 
                        /* 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;
 
-                               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;
@@ -330,14 +340,14 @@ static void do_alphaunder_effect_byte(
                        rt1 += 4; rt2 += 4; rt += 4;
                }
 
-               if (y == 0) break;
+               if (y == 0)
+                       break;
                y--;
 
                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;
@@ -355,10 +365,7 @@ static void do_alphaunder_effect_byte(
        }
 }
 
-
-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;
@@ -373,10 +380,8 @@ static void do_alphaunder_effect_float(float facf0, float facf1, int x, int y,
        fac4 = facf1;
 
        while (y--) {
-
                x = xo;
                while (x--) {
-
                        /* rt = rt1 under rt2  (alpha from rt2) */
 
                        /* this complex optimization is because the
@@ -405,15 +410,14 @@ static void do_alphaunder_effect_float(float facf0, float facf1, int x, int y,
                        rt1 += 4; rt2 += 4; rt += 4;
                }
 
-               if (y == 0) break;
+               if (y == 0)
+                       break;
                y--;
 
                x = xo;
                while (x--) {
-
                        if (rt2[3] <= 0 && fac4 >= 1.0f) {
                                memcpy(rt, rt1, 4 * sizeof(float));
                        }
                        else if (rt2[3] >= 1.0f) {
                                memcpy(rt, rt2, 4 * sizeof(float));
@@ -437,38 +441,29 @@ static void do_alphaunder_effect_float(float facf0, float facf1, int x, int y,
        }
 }
 
-static 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, *rect2, *rect_out;
+
+               slize_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, *rect2, *rect_out;
+
+               slize_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;
@@ -479,16 +474,14 @@ static void do_cross_effect_byte(float facf0, float facf1, int x, int y,
        rt2 = rect2;
        rt = out;
 
-       fac2 = (int)(256.0f * facf0);
+       fac2 = (int) (256.0f * facf0);
        fac1 = 256 - fac2;
-       fac4 = (int)(256.0f * facf1);
+       fac4 = (int) (256.0f * facf1);
        fac3 = 256 - fac4;
 
        while (y--) {
-
                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;
@@ -497,12 +490,12 @@ static void do_cross_effect_byte(float facf0, float facf1, int x, int y,
                        rt1 += 4; rt2 += 4; rt += 4;
                }
 
-               if (y == 0) break;
+               if (y == 0)
+                       break;
                y--;
 
                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;
@@ -514,8 +507,7 @@ static void do_cross_effect_byte(float facf0, float facf1, int x, int y,
        }
 }
 
-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;
@@ -532,10 +524,8 @@ static void do_cross_effect_float(float facf0, float facf1, int x, int y,
        fac3 = 1.0f - fac4;
 
        while (y--) {
-
                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];
@@ -544,12 +534,12 @@ static void do_cross_effect_float(float facf0, float facf1, int x, int y,
                        rt1 += 4; rt2 += 4; rt += 4;
                }
 
-               if (y == 0) break;
+               if (y == 0)
+                       break;
                y--;
 
                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];
@@ -561,36 +551,27 @@ static void do_cross_effect_float(float facf0, float facf1, int x, int y,
        }
 }
 
-/* careful: also used by speed effect! */
-
-static 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, *rect2, *rect_out;
+
+               slize_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, *rect2, *rect_out;
+
+               slize_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];
@@ -614,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.             */
+       /* 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]);
+               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)
 {
@@ -654,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 res = gamma_range_table[i] + ( (c - color_domain_table[i]) * gamfactor_table[i]);
        
        return res;
-} /* end of float gammaCorrect(float col) */
+}
 
 /* ------------------------------------------------------------------------- */
 
@@ -674,15 +652,13 @@ static float invGammaCorrect(float col)
        float res = 0.0;
 
        i = floor(col * inv_color_step);
-       /* Negative colors are explicitly handled.                              */
+       /* 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)
 {
@@ -708,7 +684,6 @@ static void gamtabs(float gamma)
                        igamtab1[a - 1] = (65535.0 * pow(val, gamma)) - 1;
                }
        }
-
 }
 
 static void build_gammatabs(void)
@@ -732,29 +707,24 @@ 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;
+       rt1 = (unsigned char *) rect1;
+       rt2 = (unsigned char *) rect2;
+       rt = (unsigned char *) out;
 
        fac2 = (int)(256.0f * facf0);
        fac1 = 256 - fac2;
 
        while (y--) {
-
                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;
@@ -767,12 +737,12 @@ static void do_gammacross_effect_byte(float facf0, float UNUSED(facf1),
                        rt1 += 4; rt2 += 4; rt += 4;
                }
 
-               if (y == 0) break;
+               if (y == 0)
+                       break;
                y--;
 
                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;
@@ -785,13 +755,10 @@ static void do_gammacross_effect_byte(float facf0, float UNUSED(facf1),
                        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;
@@ -806,62 +773,56 @@ static void do_gammacross_effect_float(float facf0, float UNUSED(facf1),
        fac1 = 1.0f - fac2;
 
        while (y--) {
-
                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;
                while (x--) {
-
-                       *rt = gammaCorrect(
-                           fac1 * invGammaCorrect(*rt1) + fac2 * invGammaCorrect(*rt2));
+                       *rt = gammaCorrect(fac1 * invGammaCorrect(*rt1) + fac2 * invGammaCorrect(*rt2));
 
                        rt1++; rt2++; rt++;
                }
        }
 }
 
-static 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, *rect2, *rect_out;
+
+               slize_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, *rect2, *rect_out;
+
+               slize_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,
+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;
@@ -876,10 +837,9 @@ static void do_add_effect_byte(float facf0, float facf1, int x, int y,
        fac3 = (int)(256.0f * facf1);
 
        while (y--) {
-
                x = xo;
-               while (x--) {
 
+               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);
@@ -892,12 +852,12 @@ static void do_add_effect_byte(float facf0, float facf1, int x, int y,
                        rt1 += 4; rt2 += 4; rt += 4;
                }
 
-               if (y == 0) break;
+               if (y == 0)
+                       break;
                y--;
 
                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);
@@ -912,9 +872,7 @@ static void do_add_effect_byte(float facf0, float facf1, int x, int y,
        }
 }
 
-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;
@@ -929,7 +887,6 @@ static void do_add_effect_float(float facf0, float facf1, int x, int y,
        fac3 = facf1;
 
        while (y--) {
-
                x = xo * 4;
                while (x--) {
                        *rt = *rt1 + fac1 * (*rt2);
@@ -937,7 +894,8 @@ static void do_add_effect_float(float facf0, float facf1, int x, int y,
                        rt1++; rt2++; rt++;
                }
 
-               if (y == 0) break;
+               if (y == 0)
+                       break;
                y--;
 
                x = xo * 4;
@@ -949,54 +907,43 @@ static void do_add_effect_float(float facf0, float facf1, int x, int y,
        }
 }
 
-static 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, *rect2, *rect_out;
+
+               slize_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, *rect2, *rect_out;
+
+               slize_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;
+       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;
                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);
@@ -1009,12 +956,12 @@ static void do_sub_effect_byte(float facf0, float facf1,
                        rt1 += 4; rt2 += 4; rt += 4;
                }
 
-               if (y == 0) break;
+               if (y == 0)
+                       break;
                y--;
 
                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);
@@ -1029,9 +976,7 @@ static void do_sub_effect_byte(float facf0, float facf1,
        }
 }
 
-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;
@@ -1046,7 +991,6 @@ static void do_sub_effect_float(float facf0, float facf1, int x, int y,
        fac3 = facf1;
 
        while (y--) {
-
                x = xo * 4;
                while (x--) {
                        *rt = *rt1 - fac1 * (*rt2);
@@ -1054,7 +998,8 @@ static void do_sub_effect_float(float facf0, float facf1, int x, int y,
                        rt1++; rt2++; rt++;
                }
 
-               if (y == 0) break;
+               if (y == 0)
+                       break;
                y--;
 
                x = xo * 4;
@@ -1066,40 +1011,32 @@ static void do_sub_effect_float(float facf0, float facf1, int x, int y,
        }
 }
 
-static 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, *rect2, *rect_out;
+
+               slize_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, *rect2, *rect_out;
+
+               slize_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
 
-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;
@@ -1108,8 +1045,8 @@ static void do_drop_effect_byte(float facf0, float facf1, int x, int y,
        width = x;
        height = y;
 
-       fac1 = (int)(70.0f * facf0);
-       fac2 = (int)(70.0f * facf1);
+       fac1 = (int) (70.0f * facf0);
+       fac2 = (int) (70.0f * facf1);
 
        rt2 = (char *) (rect2i + YOFF * width);
        rt1 = (char *) rect1i;
@@ -1137,9 +1074,7 @@ static void do_drop_effect_byte(float facf0, float facf1, int x, int y,
        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;
@@ -1178,12 +1113,9 @@ static void do_drop_effect_float(float facf0, float facf1, int x, int y,
        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,
+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;
@@ -1231,9 +1163,7 @@ static void do_mul_effect_byte(float facf0, float facf1, int x, int y,
        }
 }
 
-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;
@@ -1252,10 +1182,8 @@ static void do_mul_effect_float(float facf0, float facf1, int x, int y,
         */
 
        while (y--) {
-
                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);
@@ -1264,12 +1192,12 @@ static void do_mul_effect_float(float facf0, float facf1, int x, int y,
                        rt1 += 4; rt2 += 4; rt += 4;
                }
 
-               if (y == 0) break;
+               if (y == 0)
+                       break;
                y--;
 
                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);
@@ -1280,33 +1208,26 @@ static void do_mul_effect_float(float facf0, float facf1, int x, int y,
        }
 }
 
-static 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, *rect2, *rect_out;
+
+               slize_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, *rect2, *rect_out;
 
-       return out;
+               slize_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;
@@ -1326,7 +1247,7 @@ static void precalc_wipe_zone(WipeZone *wipezone, WipeVars *wipe, int xo, int yo
        wipezone->pythangle = 1.0f / sqrtf(wipezone->angle * wipezone->angle + 1.0f);
 }
 
-// This function calculates the blur band for the wipe effects
+/* This function calculates the blur band for the wipe effects */
 static float in_band(float width, float dist, int side, int dir)
 {
        float alpha;
@@ -1348,13 +1269,12 @@ static float in_band(float width, float dist, int side, int dir)
        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;
        /* 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;
@@ -1412,9 +1332,9 @@ static float check_zone(WipeZone *wipezone, int x, int y,
 
                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
+                       width = wipezone->width;  /* calculate the blur width */
                        hwidth = width * 0.5f;
                        if (angle == 0) {
                                b1 = posy * 0.5f;
@@ -1586,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)
@@ -1597,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;
 }
 
@@ -1606,9 +1530,7 @@ 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,
+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;
@@ -1667,9 +1589,7 @@ static void do_wipe_effect_byte(Sequence *seq, float facf0, float UNUSED(facf1),
        }
 }
 
-static void do_wipe_effect_float(Sequence *seq, float facf0, float UNUSED(facf1), 
-                                 int x, int y,
-                                 float *rect1,
+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;
@@ -1728,40 +1648,35 @@ static void do_wipe_effect_float(Sequence *seq, float facf0, float UNUSED(facf1)
        }
 }
 
-static 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;
@@ -1792,9 +1707,8 @@ 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;
@@ -1803,30 +1717,29 @@ static void transform_image(int x, int y, struct ImBuf *ibuf1, struct ImBuf *out
        xo = x;
        yo = y;
        
-       // Rotate
+       /* Rotate */
        s = sin(rotate);
        c = cos(rotate);
 
        for (yi = 0; yi < yo; yi++) {
                for (xi = 0; xi < xo; xi++) {
-
-                       //translate point
+                       /* translate point */
                        xt = xi - translate_x;
                        yt = yi - translate_y;
 
-                       //rotate point with center ref
+                       /* 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
+                       /* interpolate */
                        switch (interpolation) {
                                case 0:
                                        neareast_interpolation(ibuf1, out, xt, yt, xi, yi);
@@ -1842,10 +1755,9 @@ static void transform_image(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, 
-                         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 */
@@ -1876,28 +1788,19 @@ static void do_transform(Scene *scene, Sequence *seq, float UNUSED(facf0), int x
 }
 
 
-static 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 */
@@ -1913,16 +1816,16 @@ static void RVBlurBitmap2_byte(unsigned char *map, int width, int height,
        int index, ix, halfWidth;
        float fval, k, curColor[3], curColor2[3], weight = 0;
 
-       /*      If we're not really blurring, bail out */
+       /* If we're not really blurring, bail out */
        if (blur <= 0)
                return;
 
-       /*      Allocate memory for the tempmap and the blur filter matrix */
+       /*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 */
+       /*Allocate memory for the filter elements */
        halfWidth = ((quality + 1) * blur);
        filter = (float *)MEM_mallocN(sizeof(float) * halfWidth * 2, "blurbitmapfilter");
        if (!filter) {
@@ -1930,11 +1833,10 @@ static void RVBlurBitmap2_byte(unsigned char *map, int width, int height,
                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++) {
@@ -1944,7 +1846,7 @@ static void RVBlurBitmap2_byte(unsigned char *map, int width, int height,
        }
        filter[0] = weight;
 
-       /*      Normalize the array */
+       /* Normalize the array */
        fval = 0;
        for (ix = 0; ix < halfWidth * 2; ix++)
                fval += filter[ix];
@@ -1952,9 +1854,9 @@ static void RVBlurBitmap2_byte(unsigned char *map, int width, int height,
        for (ix = 0; ix < halfWidth * 2; ix++)
                filter[ix] /= fval;
 
-       /*      Blur the rows */
+       /* Blur the rows */
        for (y = 0; y < height; y++) {
-               /*      Do the left & right strips */
+               /* Do the left & right strips */
                for (x = 0; x < halfWidth; x++) {
                        index = (x + y * width) * 4;
                        fx = 0;
@@ -1967,12 +1869,9 @@ static void RVBlurBitmap2_byte(unsigned char *map, int width, int height,
                                        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];
+                                       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++;
                        }
@@ -1985,7 +1884,8 @@ static void RVBlurBitmap2_byte(unsigned char *map, int width, int height,
                        temp[((width - 1 - x + y * width) * 4) + GlowB] = curColor2[2];
 
                }
-               /*      Do the main body */
+
+               /* Do the main body */
                for (x = halfWidth; x < width - halfWidth; x++) {
                        index = (x + y * width) * 4;
                        fx = 0;
@@ -2002,13 +1902,12 @@ static void RVBlurBitmap2_byte(unsigned char *map, int width, int height,
                }
        }
 
-       /*      Swap buffers */
+       /* Swap buffers */
        swap = temp; temp = map; map = swap;
 
-
-       /*      Blur the columns */
+       /* Blur the columns */
        for (x = 0; x < width; x++) {
-               /*      Do the top & bottom strips */
+               /* Do the top & bottom strips */
                for (y = 0; y < halfWidth; y++) {
                        index = (x + y * width) * 4;
                        fy = 0;
@@ -2016,18 +1915,15 @@ static void RVBlurBitmap2_byte(unsigned char *map, int width, int height,
                        zero_v3(curColor2);
                        for (i = y - halfWidth; i < y + halfWidth; i++) {
                                if ((i >= 0) && (i < height)) {
-                                       /*      Bottom */
+                                       /* 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];
+                                       /* 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++;
                        }
@@ -2038,7 +1934,8 @@ static void RVBlurBitmap2_byte(unsigned char *map, int width, int height,
                        temp[((x + (height - 1 - y) * width) * 4) + GlowG] = curColor2[1];
                        temp[((x + (height - 1 - y) * width) * 4) + GlowB] = curColor2[2];
                }
-               /*      Do the main body */
+
+               /* Do the main body */
                for (y = halfWidth; y < height - halfWidth; y++) {
                        index = (x + y * width) * 4;
                        fy = 0;
@@ -2055,18 +1952,15 @@ static void RVBlurBitmap2_byte(unsigned char *map, int width, int height,
                }
        }
 
-
-       /*      Swap buffers */
+       /* Swap buffers */
        swap = temp; temp = map; /* map = swap; */ /* UNUSED */
 
-       /*      Tidy up  */
+       /* 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 */
@@ -2077,21 +1971,21 @@ static void RVBlurBitmap2_float(float *map, int width, int height,
 /*=============================== */
 {
        float *temp = NULL, *swap;
-       float   *filter = NULL;
+       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 we're not really blurring, bail out */
        if (blur <= 0)
                return;
 
-       /*      Allocate memory for the tempmap and the blur filter matrix */
+       /* 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 */
+       /* Allocate memory for the filter elements */
        halfWidth = ((quality + 1) * blur);
        filter = (float *)MEM_mallocN(sizeof(float) * halfWidth * 2, "blurbitmapfilter");
        if (!filter) {
@@ -2099,11 +1993,10 @@ static void RVBlurBitmap2_float(float *map, int width, int height,
                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);
 
@@ -2114,7 +2007,7 @@ static void RVBlurBitmap2_float(float *map, int width, int height,
        }
        filter[0] = weight;
 
-       /*      Normalize the array */
+       /* Normalize the array */
        fval = 0;
        for (ix = 0; ix < halfWidth * 2; ix++)
                fval += filter[ix];
@@ -2122,9 +2015,9 @@ static void RVBlurBitmap2_float(float *map, int width, int height,
        for (ix = 0; ix < halfWidth * 2; ix++)
                filter[ix] /= fval;
 
-       /*      Blur the rows */
+       /* Blur the rows */
        for (y = 0; y < height; y++) {
-               /*      Do the left & right strips */
+               /* Do the left & right strips */
                for (x = 0; x < halfWidth; x++) {
                        index = (x + y * width) * 4;
                        fx = 0;
@@ -2137,12 +2030,9 @@ static void RVBlurBitmap2_float(float *map, int width, int height,
                                        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];
+                                       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++;
                        }
@@ -2155,7 +2045,8 @@ static void RVBlurBitmap2_float(float *map, int width, int height,
                        temp[((width - 1 - x + y * width) * 4) + GlowB] = curColor2[2];
 
                }
-               /*      Do the main body */
+
+               /* Do the main body */
                for (x = halfWidth; x < width - halfWidth; x++) {
                        index = (x + y * width) * 4;
                        fx = 0;
@@ -2172,13 +2063,12 @@ static void RVBlurBitmap2_float(float *map, int width, int height,
                }
        }
 
-       /*      Swap buffers */
+       /* Swap buffers */
        swap = temp; temp = map; map = swap;
 
-
-       /*      Blur the columns */
+       /* Blur the columns */
        for (x = 0; x < width; x++) {
-               /*      Do the top & bottom strips */
+               /* Do the top & bottom strips */
                for (y = 0; y < halfWidth; y++) {
                        index = (x + y * width) * 4;
                        fy = 0;
@@ -2186,18 +2076,15 @@ static void RVBlurBitmap2_float(float *map, int width, int height,
                        zero_v3(curColor2);
                        for (i = y - halfWidth; i < y + halfWidth; i++) {
                                if ((i >= 0) && (i < height)) {
-                                       /*      Bottom */
+                                       /* 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];
+                                       /* 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++;
                        }
@@ -2208,7 +2095,8 @@ static void RVBlurBitmap2_float(float *map, int width, int height,
                        temp[((x + (height - 1 - y) * width) * 4) + GlowG] = curColor2[1];
                        temp[((x + (height - 1 - y) * width) * 4) + GlowB] = curColor2[2];
                }
-               /*      Do the main body */
+       
+               /* Do the main body */
                for (y = halfWidth; y < height - halfWidth; y++) {
                        index = (x + y * width) * 4;
                        fy = 0;
@@ -2225,11 +2113,10 @@ static void RVBlurBitmap2_float(float *map, int width, int height,
                }
        }
 
-
-       /*      Swap buffers */
+       /* Swap buffers */
        swap = temp; temp = map; /* map = swap; */ /* UNUSED */
 
-       /*      Tidy up  */
+       /* Tidy up       */
        MEM_freeN(filter);
        MEM_freeN(temp);
 }
@@ -2254,8 +2141,7 @@ static void RVAddBitmaps_byte(unsigned char *a, unsigned char *b, unsigned char
        }
 }
 
-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;
 
@@ -2270,21 +2156,20 @@ static void RVAddBitmaps_float(float *a, float *b, float *c,
        }
 }
 
-/*     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,
+/* 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;
 
-
        for (y = 0; y < height; y++) {
                for (x = 0; x < width; x++) {
                        index = (x + y * width) * 4;
 
-                       /*      Isolate the intensity */
+                       /* 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);
@@ -2302,19 +2187,16 @@ static void RVIsolateHighlights_byte(unsigned char *in, unsigned char *out,
        }
 }
 
-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;
 
-
        for (y = 0; y < height; y++) {
                for (x = 0; x < width; x++) {
                        index = (x + y * width) * 4;
 
-                       /*      Isolate the 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));
@@ -2336,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;
@@ -2355,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;
 }
 
@@ -2364,10 +2250,8 @@ 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;
@@ -2379,8 +2263,7 @@ static void do_glow_effect_byte(Sequence *seq, int render_size, float facf0, flo
                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,
+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;
@@ -2393,44 +2276,35 @@ static void do_glow_effect_float(Sequence *seq, int render_size, float facf0, fl
                RVAddBitmaps_float(inbuf, outbuf, outbuf, x, y);
 }
 
-static 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;
 
        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;
@@ -2443,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;
 }
 
@@ -2452,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 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;
 
@@ -2541,9 +2413,7 @@ static ImBuf *do_solid_color(
        return out;
 }
 
-/* **********************************************************************
- * MULTICAM
- * ********************************************************************** */
+/*********************** Mulitcam *************************/
 
 /* no effect inputs for multicam, we use give_ibuf_seq */
 static int num_inputs_multicam(void)
@@ -2551,19 +2421,16 @@ 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 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;
+       ImBuf *i;
+       ImBuf *out;
        Editing *ed;
        ListBase *seqbasep;
 
@@ -2575,17 +2442,17 @@ static 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);
        }
@@ -2596,9 +2463,7 @@ static ImBuf *do_multicam(
        return out;
 }
 
-/* **********************************************************************
- * ADJUSTMENT
- * ********************************************************************** */
+/*********************** Adjustment *************************/
 
 /* no effect inputs for adjustment, we use give_ibuf_seq */
 static int num_inputs_adjustment(void)
@@ -2606,35 +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 ImBuf *do_adjustment_impl(SeqRenderData context, Sequence *seq, float cfra)
 {
        Editing *ed;
        ListBase *seqbasep;
-       struct ImBuf *i = NULL;
+       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);
+               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;
 
-               meta = seq_metastrip(&ed->seqbase, NULL, seq);
+               meta = BKE_sequence_metastrip(&ed->seqbase, NULL, seq);
 
                if (meta) {
                        i = do_adjustment_impl(context, meta, cfra);
@@ -2644,14 +2508,11 @@ static ImBuf *do_adjustment_impl(SeqRenderData context, Sequence *seq, float cfr
        return i;
 }
 
-static 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;
+       ImBuf *i = NULL;
+       ImBuf *out;
        Editing *ed;
 
        ed = context.scene->ed;
@@ -2662,7 +2523,7 @@ static 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);
        }
@@ -2673,16 +2534,16 @@ static ImBuf *do_adjustment(
        return out;
 }
 
-/* **********************************************************************
- * SPEED
- * ********************************************************************** */
+/*********************** Speed *************************/
+
 static void init_speed_effect(Sequence *seq)
 {
        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;
@@ -2707,8 +2568,10 @@ 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);
+       if (v->frameMap)
+               MEM_freeN(v->frameMap);
+       if (seq->effectdata)
+               MEM_freeN(seq->effectdata);
        seq->effectdata = NULL;
 }
 
@@ -2721,19 +2584,17 @@ static void copy_speed_effect(Sequence *dst, Sequence *src)
        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;
 
        /* 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;
@@ -2750,16 +2611,17 @@ 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;
+       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) &&
@@ -2782,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;
@@ -2792,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;
                }
@@ -2861,22 +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, *rect2, *rect_out;
+
+               slize_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, *rect2, *rect_out;
 
+               slize_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 free_noop(struct Sequence *UNUSED(seq))
+static void load_noop(Sequence *UNUSED(seq))
+{
+
+}
+
+static void free_noop(Sequence *UNUSED(seq))
 {
 
 }
@@ -2886,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);
@@ -2934,39 +2827,9 @@ static void get_default_fac_fade(struct Sequence *seq, float cfra,
        *facf1 /= seq->len;
 }
 
-static 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;
 }
@@ -2976,6 +2839,7 @@ static struct SeqEffectHandle get_sequence_effect_impl(int seq_type)
        struct SeqEffectHandle rval;
        int sequence_type = seq_type;
 
+       rval.multithreaded = FALSE;
        rval.init = init_noop;
        rval.num_inputs = num_inputs_default;
        rval.load = load_noop;
@@ -2984,44 +2848,55 @@ 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_TYPE_CROSS:
-                       rval.execute = do_cross_effect;
+                       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.execute = do_gammacross_effect;
+                       rval.init_execution = gammacross_init_execution;
+                       rval.execute_slice = do_gammacross_effect;
                        break;
                case SEQ_TYPE_ADD:
-                       rval.execute = do_add_effect;
+                       rval.multithreaded = TRUE;
+                       rval.execute_slice = do_add_effect;
                        rval.early_out = early_out_mul_input2;
                        break;
                case SEQ_TYPE_SUB:
-                       rval.execute = do_sub_effect;
+                       rval.multithreaded = TRUE;
+                       rval.execute_slice = do_sub_effect;
                        rval.early_out = early_out_mul_input2;
                        break;
                case SEQ_TYPE_MUL:
-                       rval.execute = do_mul_effect;
+                       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 = do_alphaover_effect;
+                       rval.execute_slice = do_alphaover_effect;
                        break;
                case SEQ_TYPE_OVERDROP:
-                       rval.execute = do_overdrop_effect;
+                       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 = do_alphaunder_effect;
+                       rval.execute_slice = do_alphaunder_effect;
                        break;
                case SEQ_TYPE_WIPE:
                        rval.init = init_wipe_effect;
@@ -3052,7 +2927,7 @@ static struct SeqEffectHandle get_sequence_effect_impl(int seq_type)
                        rval.load = load_speed_effect;
                        rval.free = free_speed_effect;
                        rval.copy = copy_speed_effect;
-                       rval.execute = do_cross_effect;
+                       rval.execute = do_speed_effect;
                        rval.early_out = early_out_speed;
                        rval.store_icu_yrange = store_icu_yrange_speed;
                        break;
@@ -3079,10 +2954,9 @@ static struct SeqEffectHandle get_sequence_effect_impl(int seq_type)
        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, NULL};
 
        if (seq->type & SEQ_TYPE_EFFECT) {
                rval = get_sequence_effect_impl(seq->type);
@@ -3095,9 +2969,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, NULL};
 
        if (seq->blend_mode != 0) {
                rval = get_sequence_effect_impl(seq->blend_mode);
@@ -3110,12 +2984,12 @@ 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;
index 02ae9566eed597c71fc96183d99d5532f1950e34..1882318f3ea86d9dc89f32a71d4e8740ffe4b1a7 100644 (file)
 #  include "AUD_C-API.h"
 #endif
 
-static ImBuf *seq_render_strip_stack(
-        SeqRenderData context, ListBase *seqbasep, float cfra, int chanshown);
-
-static ImBuf *seq_render_strip(
-        SeqRenderData context, Sequence *seq, float cfra);
-
+static ImBuf *seq_render_strip_stack(SeqRenderData context, ListBase *seqbasep, float cfra, int chanshown);
+static ImBuf *seq_render_strip(SeqRenderData context, Sequence *seq, float cfra);
 static void seq_free_animdata(Scene *scene, Sequence *seq);
 
-
 /* **** XXX ******** */
 #define SELECT 1
 ListBase seqbase_clipboard;
 int seqbase_clipboard_frame;
 SequencerDrawView sequencer_view3d_cb = NULL; /* NULL in background mode */
 
-
-void printf_strip(Sequence *seq)
+#if 0  /* unused function */
+static void printf_strip(Sequence *seq)
 {
-       fprintf(stderr, "name: '%s', len:%d, start:%d, (startofs:%d, endofs:%d), (startstill:%d, endstill:%d), machine:%d, (startdisp:%d, enddisp:%d)\n",
-               seq->name, seq->len, seq->start, seq->startofs, seq->endofs, seq->startstill, seq->endstill, seq->machine, seq->startdisp, seq->enddisp);
-       fprintf(stderr, "\tseq_tx_set_final_left: %d %d\n\n", seq_tx_get_final_left(seq, 0), seq_tx_get_final_right(seq, 0));
+       fprintf(stderr, "name: '%s', len:%d, start:%d, (startofs:%d, endofs:%d), "
+               "(startstill:%d, endstill:%d), machine:%d, (startdisp:%d, enddisp:%d)\n",
+               seq->name, seq->len, seq->start, seq->startofs, seq->endofs, seq->startstill, seq->endstill, seq->machine,
+               seq->startdisp, seq->enddisp);
+
+       fprintf(stderr, "\tseq_tx_set_final_left: %d %d\n\n", seq_tx_get_final_left(seq, 0),
+               seq_tx_get_final_right(seq, 0));
 }
+#endif
 
-int seqbase_recursive_apply(ListBase *seqbase, int (*apply_func)(Sequence *seq, void *), void *arg)
+int BKE_sequencer_base_recursive_apply(ListBase *seqbase, int (*apply_func)(Sequence *seq, void *), void *arg)
 {
        Sequence *iseq;
        for (iseq = seqbase->first; iseq; iseq = iseq->next) {
-               if (seq_recursive_apply(iseq, apply_func, arg) == -1)
+               if (BKE_sequencer_recursive_apply(iseq, apply_func, arg) == -1)
                        return -1;  /* bail out */
        }
        return 1;
 }
 
-int seq_recursive_apply(Sequence *seq, int (*apply_func)(Sequence *, void *), void *arg)
+int BKE_sequencer_recursive_apply(Sequence *seq, int (*apply_func)(Sequence *, void *), void *arg)
 {
        int ret = apply_func(seq, arg);
 
@@ -121,14 +121,12 @@ int seq_recursive_apply(Sequence *seq, int (*apply_func)(Sequence *, void *), vo
                return -1;  /* bail out */
 
        if (ret && seq->seqbase.first)
-               ret = seqbase_recursive_apply(&seq->seqbase, apply_func, arg);
+               ret = BKE_sequencer_base_recursive_apply(&seq->seqbase, apply_func, arg);
 
        return ret;
 }
 
-/* **********************************************************************
- * alloc / free functions
- * ********************************************************************** */
+/*********************** alloc / free functions *************************/
 
 /* free */
 
@@ -140,10 +138,11 @@ static void free_proxy_seq(Sequence *seq)
        }
 }
 
-void seq_free_strip(Strip *strip)
+static void seq_free_strip(Strip *strip)
 {
        strip->us--;
-       if (strip->us > 0) return;
+       if (strip->us > 0)
+               return;
        if (strip->us < 0) {
                printf("error: negative users in strip\n");
                return;
@@ -173,14 +172,16 @@ void seq_free_strip(Strip *strip)
        MEM_freeN(strip);
 }
 
-void seq_free_sequence(Scene *scene, Sequence *seq)
+void BKE_sequence_free(Scene *scene, Sequence *seq)
 {
-       if (seq->strip) seq_free_strip(seq->strip);
+       if (seq->strip)
+               seq_free_strip(seq->strip);
 
-       if (seq->anim) IMB_free_anim(seq->anim);
+       if (seq->anim)
+               IMB_free_anim(seq->anim);
 
        if (seq->type & SEQ_TYPE_EFFECT) {
-               struct SeqEffectHandle sh = get_sequence_effect(seq);
+               struct SeqEffectHandle sh = BKE_sequence_get_effect(seq);
 
                sh.free(seq);
        }
@@ -205,7 +206,7 @@ void seq_free_sequence(Scene *scene, Sequence *seq)
        MEM_freeN(seq);
 }
 
-void seq_free_sequence_recurse(Scene *scene, Sequence *seq)
+static void seq_free_sequence_recurse(Scene *scene, Sequence *seq)
 {
        Sequence *iseq;
 
@@ -213,7 +214,7 @@ void seq_free_sequence_recurse(Scene *scene, Sequence *seq)
                seq_free_sequence_recurse(scene, iseq);
        }
 
-       seq_free_sequence(scene, seq);
+       BKE_sequence_free(scene, seq);
 }
 
 
@@ -234,10 +235,10 @@ static void seq_free_clipboard_recursive(Sequence *seq_parent)
                seq_free_clipboard_recursive(seq);
        }
 
-       seq_free_sequence(NULL, seq_parent);
+       BKE_sequence_free(NULL, seq_parent);
 }
 
-void seq_free_clipboard(void)
+void BKE_sequencer_free_clipboard(void)
 {
        Sequence *seq, *nseq;
 
@@ -271,7 +272,7 @@ void BKE_sequencer_editing_free(Scene *scene)
 
        SEQ_BEGIN (ed, seq)
        {
-               seq_free_sequence(scene, seq);
+               BKE_sequence_free(scene, seq);
        }
        SEQ_END
 
@@ -285,13 +286,9 @@ void BKE_sequencer_editing_free(Scene *scene)
        scene->ed = NULL;
 }
 
-/* **********************************************************************
- * sequencer pipeline functions
- * ********************************************************************** */
+/*********************** sequencer pipeline functions *************************/
 
-SeqRenderData seq_new_render_data(
-        struct Main *bmain, struct Scene *scene,
-        int rectx, int recty, int preview_render_size)
+SeqRenderData BKE_sequencer_new_render_data(Main *bmain, Scene *scene, int rectx, int recty, int preview_render_size)
 {
        SeqRenderData rval;
 
@@ -306,79 +303,13 @@ SeqRenderData seq_new_render_data(
        return rval;
 }
 
-int seq_cmp_render_data(const SeqRenderData *a, const SeqRenderData *b)
-{
-       if (a->preview_render_size < b->preview_render_size) {
-               return -1;
-       }
-       if (a->preview_render_size > b->preview_render_size) {
-               return 1;
-       }
-       
-       if (a->rectx < b->rectx) {
-               return -1;
-       }
-       if (a->rectx > b->rectx) {
-               return 1;
-       }
-
-       if (a->recty < b->recty) {
-               return -1;
-       }
-       if (a->recty > b->recty) {
-               return 1;
-       }
-
-       if (a->bmain < b->bmain) {
-               return -1;
-       }
-       if (a->bmain > b->bmain) {
-               return 1;
-       }
-
-       if (a->scene < b->scene) {
-               return -1;
-       }
-       if (a->scene > b->scene) {
-               return 1;
-       }
-
-       if (a->motion_blur_shutter < b->motion_blur_shutter) {
-               return -1;
-       }
-       if (a->motion_blur_shutter > b->motion_blur_shutter) {
-               return 1;
-       }
-
-       if (a->motion_blur_samples < b->motion_blur_samples) {
-               return -1;
-       }
-       if (a->motion_blur_samples > b->motion_blur_samples) {
-               return 1;
-       }
-
-       return 0;
-}
-
-unsigned int seq_hash_render_data(const SeqRenderData *a)
-{
-       unsigned int rval = a->rectx + a->recty;
-
-       rval ^= a->preview_render_size;
-       rval ^= ((intptr_t) a->bmain) << 6;
-       rval ^= ((intptr_t) a->scene) << 6;
-       rval ^= (int)(a->motion_blur_shutter * 100.0f) << 10;
-       rval ^= a->motion_blur_samples << 24;
-       
-       return rval;
-}
-
 /* ************************* iterator ************************** */
 /* *************** (replaces old WHILE_SEQ) ********************* */
 /* **************** use now SEQ_BEGIN () SEQ_END ***************** */
 
 /* sequence strip iterator:
- * - builds a full array, recursively into meta strips */
+ * - builds a full array, recursively into meta strips
+ */
 
 static void seq_count(ListBase *seqbase, int *tot)
 {
@@ -407,7 +338,7 @@ static void seq_build_array(ListBase *seqbase, Sequence ***array, int depth)
        }
 }
 
-void seq_array(Editing *ed, Sequence ***seqarray, int *tot, int use_pointer)
+static void seq_array(Editing *ed, Sequence ***seqarray, int *tot, int use_pointer)
 {
        Sequence **array;
 
@@ -432,7 +363,7 @@ void seq_array(Editing *ed, Sequence ***seqarray, int *tot, int use_pointer)
                seq_build_array(&ed->seqbase, &array, 0);
 }
 
-void seq_begin(Editing *ed, SeqIterator *iter, int use_pointer)
+void BKE_seqence_iterator_begin(Editing *ed, SeqIterator *iter, int use_pointer)
 {
        memset(iter, 0, sizeof(*iter));
        seq_array(ed, &iter->array, &iter->tot, use_pointer);
@@ -444,7 +375,7 @@ void seq_begin(Editing *ed, SeqIterator *iter, int use_pointer)
        }
 }
 
-void seq_next(SeqIterator *iter)
+void BKE_seqence_iterator_next(SeqIterator *iter)
 {
        if (++iter->cur < iter->tot)
                iter->seq = iter->array[iter->cur];
@@ -452,7 +383,7 @@ void seq_next(SeqIterator *iter)
                iter->valid = 0;
 }
 
-void seq_end(SeqIterator *iter)
+void BKE_seqence_iterator_end(SeqIterator *iter)
 {
        if (iter->array)
                MEM_freeN(iter->array);
@@ -460,73 +391,6 @@ void seq_end(SeqIterator *iter)
        iter->valid = 0;
 }
 
-/*
- * **********************************************************************
- * build_seqar
- * *********************************************************************
- * Build a complete array of _all_ sequences (including those
- * in metastrips!)
- * *********************************************************************
- */
-
-static void do_seq_count_cb(ListBase *seqbase, int *totseq,
-                            int (*test_func)(Sequence *seq))
-{
-       Sequence *seq;
-
-       seq = seqbase->first;
-       while (seq) {
-               int test = test_func(seq);
-               if (test & BUILD_SEQAR_COUNT_CURRENT) {
-                       (*totseq)++;
-               }
-               if (seq->seqbase.first && (test & BUILD_SEQAR_COUNT_CHILDREN)) {
-                       do_seq_count_cb(&seq->seqbase, totseq, test_func);
-               }
-               seq = seq->next;
-       }
-}
-
-static void do_build_seqar_cb(ListBase *seqbase, Sequence ***seqar, int depth,
-                              int (*test_func)(Sequence *seq))
-{
-       Sequence *seq;
-
-       seq = seqbase->first;
-       while (seq) {
-               int test = test_func(seq);
-               seq->depth = depth;
-
-               if (seq->seqbase.first && (test & BUILD_SEQAR_COUNT_CHILDREN)) {
-                       do_build_seqar_cb(&seq->seqbase, seqar, depth + 1, test_func);
-               }
-               if (test & BUILD_SEQAR_COUNT_CURRENT) {
-                       **seqar = seq;
-                       (*seqar)++;
-               }
-               seq = seq->next;
-       }
-}
-
-void build_seqar_cb(ListBase *seqbase, Sequence  ***seqar, int *totseq,
-                    int (*test_func)(Sequence *seq))
-{
-       Sequence **tseqar;
-
-       *totseq = 0;
-       do_seq_count_cb(seqbase, totseq, test_func);
-
-       if (*totseq == 0) {
-               *seqar = NULL;
-               return;
-       }
-       *seqar = MEM_mallocN(sizeof(void *) * *totseq, "seqar");
-       tseqar = *seqar;
-
-       do_build_seqar_cb(seqbase, seqar, 0, test_func);
-       *seqar = tseqar;
-}
-
 static int metaseq_start(Sequence *metaseq)
 {
        return metaseq->start + metaseq->startofs;
@@ -545,8 +409,7 @@ static void seq_update_sound_bounds_recursive_rec(Scene *scene, Sequence *metase
         * since sound is played outside of evaluating the imbufs, */
        for (seq = metaseq->seqbase.first; seq; seq = seq->next) {
                if (seq->type == SEQ_TYPE_META) {
-                       seq_update_sound_bounds_recursive_rec(scene, seq,
-                                                             maxi(start, metaseq_start(seq)),
+                       seq_update_sound_bounds_recursive_rec(scene, seq, maxi(start, metaseq_start(seq)),
                                                              mini(end, metaseq_end(seq)));
                }
                else if (ELEM(seq->type, SEQ_TYPE_SOUND_RAM, SEQ_TYPE_SCENE)) {
@@ -558,7 +421,9 @@ static void seq_update_sound_bounds_recursive_rec(Scene *scene, Sequence *metase
 
                                if (seq->start + seq->len - seq->endofs > end)
                                        endofs = seq->start + seq->len - end;
-                               sound_move_scene_sound(scene, seq->scene_sound, seq->start + startofs, seq->start + seq->len - endofs, startofs);
+
+                               sound_move_scene_sound(scene, seq->scene_sound, seq->start + startofs,
+                                                      seq->start + seq->len - endofs, startofs);
                        }
                }
        }
@@ -569,10 +434,12 @@ static void seq_update_sound_bounds_recursive(Scene *scene, Sequence *metaseq)
        seq_update_sound_bounds_recursive_rec(scene, metaseq, metaseq_start(metaseq), metaseq_end(metaseq));
 }
 
-void calc_sequence_disp(Scene *scene, Sequence *seq)
+void BKE_sequence_calc_disp(Scene *scene, Sequence *seq)
 {
-       if (seq->startofs && seq->startstill) seq->startstill = 0;
-       if (seq->endofs && seq->endstill) seq->endstill = 0;
+       if (seq->startofs && seq->startstill)
+               seq->startstill = 0;
+       if (seq->endofs && seq->endstill)
+               seq->endstill = 0;
        
        seq->startdisp = seq->start + seq->startofs - seq->startstill;
        seq->enddisp = seq->start + seq->len - seq->endofs + seq->endstill;
@@ -586,13 +453,13 @@ void calc_sequence_disp(Scene *scene, Sequence *seq)
        }
 
        if (ELEM(seq->type, SEQ_TYPE_SOUND_RAM, SEQ_TYPE_SCENE)) {
-               seq_update_sound_bounds(scene, seq);
+               BKE_sequencer_update_sound_bounds(scene, seq);
        }
        else if (seq->type == SEQ_TYPE_META)
                seq_update_sound_bounds_recursive(scene, seq);
 }
 
-void calc_sequence(Scene *scene, Sequence *seq)
+void BKE_sequence_calc(Scene *scene, Sequence *seq)
 {
        Sequence *seqm;
        int min, max;
@@ -600,7 +467,7 @@ void calc_sequence(Scene *scene, Sequence *seq)
        /* check all metas recursively */
        seqm = seq->seqbase.first;
        while (seqm) {
-               if (seqm->seqbase.first) calc_sequence(scene, seqm);
+               if (seqm->seqbase.first) BKE_sequence_calc(scene, seqm);
                seqm = seqm->next;
        }
 
@@ -608,8 +475,10 @@ void calc_sequence(Scene *scene, Sequence *seq)
 
        if (seq->type & SEQ_TYPE_EFFECT) {
                /* pointers */
-               if (seq->seq2 == NULL) seq->seq2 = seq->seq1;
-               if (seq->seq3 == NULL) seq->seq3 = seq->seq1;
+               if (seq->seq2 == NULL)
+                       seq->seq2 = seq->seq1;
+               if (seq->seq3 == NULL)
+                       seq->seq3 = seq->seq1;
 
                /* effecten go from seq1 -> seq2: test */
 
@@ -640,7 +509,7 @@ void calc_sequence(Scene *scene, Sequence *seq)
                        seq->len = seq->enddisp - seq->startdisp;
                }
                else {
-                       calc_sequence_disp(scene, seq);
+                       BKE_sequence_calc_disp(scene, seq);
                }
        }
        else {
@@ -661,12 +530,12 @@ void calc_sequence(Scene *scene, Sequence *seq)
                        }
                        seq_update_sound_bounds_recursive(scene, seq);
                }
-               calc_sequence_disp(scene, seq);
+               BKE_sequence_calc_disp(scene, seq);
        }
 }
 
 /* note: caller should run calc_sequence(scene, seq) after */
-void reload_sequence_new_file(Scene *scene, Sequence *seq, int lock_range)
+void BKE_sequence_reload_new_file(Scene *scene, Sequence *seq, int lock_range)
 {
        char str[FILE_MAX];
        int prev_startdisp = 0, prev_enddisp = 0;
@@ -681,7 +550,7 @@ void reload_sequence_new_file(Scene *scene, Sequence *seq, int lock_range)
 
        if (lock_range) {
                /* keep so we don't have to move the actual start and end points (only the data) */
-               calc_sequence_disp(scene, seq);
+               BKE_sequence_calc_disp(scene, seq);
                prev_startdisp = seq->startdisp;
                prev_enddisp = seq->enddisp;
        }
@@ -690,7 +559,7 @@ void reload_sequence_new_file(Scene *scene, Sequence *seq, int lock_range)
                case SEQ_TYPE_IMAGE:
                {
                        /* Hack? */
-                       size_t olen = MEM_allocN_len(seq->strip->stripdata) / sizeof(struct StripElem);
+                       size_t olen = MEM_allocN_len(seq->strip->stripdata) / sizeof(StripElem);
 
                        seq->len = olen;
                        seq->len -= seq->anim_startofs;
@@ -712,10 +581,7 @@ void reload_sequence_new_file(Scene *scene, Sequence *seq, int lock_range)
                                return;
                        }
 
-                       seq->len = IMB_anim_get_duration(seq->anim,
-                                                        seq->strip->proxy ?
-                                                        seq->strip->proxy->tc :
-                                                        IMB_TC_RECORD_RUN);
+                       seq->len = IMB_anim_get_duration(seq->anim, seq->strip->proxy ? seq->strip->proxy->tc : IMB_TC_RECORD_RUN);
        
                        seq->anim_preseek = IMB_anim_get_preseek(seq->anim);
 
@@ -772,12 +638,12 @@ void reload_sequence_new_file(Scene *scene, Sequence *seq, int lock_range)
        free_proxy_seq(seq);
 
        if (lock_range) {
-               seq_tx_set_final_left(seq, prev_startdisp);
-               seq_tx_set_final_right(seq, prev_enddisp);
-               seq_single_fix(seq);
+               BKE_sequence_tx_set_final_left(seq, prev_startdisp);
+               BKE_sequence_tx_set_final_right(seq, prev_enddisp);
+               BKE_sequence_single_fix(seq);
        }
        
-       calc_sequence(scene, seq);
+       BKE_sequence_calc(scene, seq);
 }
 
 void BKE_sequencer_sort(Scene *scene)
@@ -788,7 +654,8 @@ void BKE_sequencer_sort(Scene *scene)
        Sequence *seq, *seqt;
 
        
-       if (ed == NULL) return;
+       if (ed == NULL)
+               return;
 
        seqbase.first = seqbase.last = NULL;
        effbase.first = effbase.last = NULL;
@@ -805,7 +672,8 @@ void BKE_sequencer_sort(Scene *scene)
                                }
                                seqt = seqt->next;
                        }
-                       if (seqt == NULL) BLI_addtail(&effbase, seq);
+                       if (seqt == NULL)
+                               BLI_addtail(&effbase, seq);
                }
                else {
                        seqt = seqbase.first;
@@ -816,7 +684,8 @@ void BKE_sequencer_sort(Scene *scene)
                                }
                                seqt = seqt->next;
                        }
-                       if (seqt == NULL) BLI_addtail(&seqbase, seq);
+                       if (seqt == NULL)
+                               BLI_addtail(&seqbase, seq);
                }
        }
 
@@ -824,7 +693,6 @@ void BKE_sequencer_sort(Scene *scene)
        *(ed->seqbasep) = seqbase;
 }
 
-
 static int clear_scene_in_allseqs_cb(Sequence *seq, void *arg_pt)
 {
        if (seq->scene == (Scene *)arg_pt)
@@ -832,14 +700,14 @@ static int clear_scene_in_allseqs_cb(Sequence *seq, void *arg_pt)
        return 1;
 }
 
-void clear_scene_in_allseqs(Main *bmain, Scene *scene)
+void BKE_sequencer_clear_scene_in_allseqs(Main *bmain, Scene *scene)
 {
        Scene *scene_iter;
 
        /* when a scene is deleted: test all seqs */
        for (scene_iter = bmain->scene.first; scene_iter; scene_iter = scene_iter->id.next) {
                if (scene_iter != scene && scene_iter->ed) {
-                       seqbase_recursive_apply(&scene_iter->ed->seqbase, clear_scene_in_allseqs_cb, scene);
+                       BKE_sequencer_base_recursive_apply(&scene_iter->ed->seqbase, clear_scene_in_allseqs_cb, scene);
                }
        }
 }
@@ -852,13 +720,6 @@ typedef struct SeqUniqueInfo {
        int match;
 } SeqUniqueInfo;
 
-#if 0
-static void seqbase_unique_name(ListBase *seqbasep, Sequence *seq)
-{
-       BLI_uniquename(seqbasep, seq, "Sequence", '.', offsetof(Sequence, name), SEQ_NAME_MAXSTR);
-}
-#endif
-
 static void seqbase_unique_name(ListBase *seqbasep, SeqUniqueInfo *sui)
 {
        Sequence *seq;
@@ -878,7 +739,7 @@ static int seqbase_unique_name_recursive_cb(Sequence *seq, void *arg_pt)
        return 1;
 }
 
-void seqbase_unique_name_recursive(ListBase *seqbasep, struct Sequence *seq)
+void BKE_seqence_base_unique_name_recursive(ListBase *seqbasep, Sequence *seq)
 {
        SeqUniqueInfo sui;
        char *dot;
@@ -901,7 +762,7 @@ void seqbase_unique_name_recursive(ListBase *seqbasep, struct Sequence *seq)
        while (sui.match) {
                sui.match = 0;
                seqbase_unique_name(seqbasep, &sui);
-               seqbase_recursive_apply(seqbasep, seqbase_unique_name_recursive_cb, &sui);
+               BKE_sequencer_base_recursive_apply(seqbasep, seqbase_unique_name_recursive_cb, &sui);
        }
 
        BLI_strncpy(seq->name + 2, sui.name_dest, sizeof(seq->name) - 2);
@@ -937,7 +798,7 @@ static const char *give_seqname_by_type(int type)
        }
 }
 
-const char *give_seqname(Sequence *seq)
+const char *BKE_sequence_give_name(Sequence *seq)
 {
        const char *name = give_seqname_by_type(seq->type);
 
@@ -952,7 +813,7 @@ const char *give_seqname(Sequence *seq)
        return name;
 }
 
-/* ***************** DO THE SEQUENCE ***************** */
+/*********************** DO THE SEQUENCE *************************/
 
 static void make_black_ibuf(ImBuf *ibuf)
 {
@@ -970,7 +831,7 @@ static void make_black_ibuf(ImBuf *ibuf)
        rect_float = ibuf->rect_float;
 
        if (rect) {
-               memset(rect,       0, tot * sizeof(char) * 4);
+               memset(rect, 0, tot * sizeof(char) * 4);
        }
 
        if (rect_float) {
@@ -1053,18 +914,19 @@ static float give_stripelem_index(Sequence *seq, float cfra)
        return nr;
 }
 
-StripElem *give_stripelem(Sequence *seq, int cfra)
+StripElem *BKE_sequencer_give_stripelem(Sequence *seq, int cfra)
 {
        StripElem *se = seq->strip->stripdata;
 
-       if (seq->type == SEQ_TYPE_IMAGE) { /* only
-                                          * IMAGE strips use the whole array,
-                                          * MOVIE strips use only
-                                          * the first element, all other strips
-                                          * don't use this... */
-               int nr = (int)give_stripelem_index(seq, cfra);
+       if (seq->type == SEQ_TYPE_IMAGE) {
+               /* only IMAGE strips use the whole array, MOVIE strips use only the first element,
+                * all other strips don't use this...
+                */
 
-               if (nr == -1 || se == NULL) return NULL;
+               int nr = (int) give_stripelem_index(seq, cfra);
+
+               if (nr == -1 || se == NULL)
+                       return NULL;
        
                se += nr + seq->anim_startofs;
        }
@@ -1090,12 +952,14 @@ static int evaluate_seq_frame_gen(Sequence **seq_arr, ListBase *seqbase, int cfr
        return totseq;
 }
 
-int evaluate_seq_frame(Scene *scene, int cfra)
+int BKE_sequencer_evaluate_frame(Scene *scene, int cfra)
 {
        Editing *ed = BKE_sequencer_editing_get(scene, FALSE);
        Sequence *seq_arr[MAXSEQ + 1];
 
-       if (ed == NULL) return 0;
+       if (ed == NULL)
+               return 0;
+
        return evaluate_seq_frame_gen(seq_arr, ed->seqbasep, cfra);
 }
 
@@ -1144,10 +1008,7 @@ static int get_shown_sequences(ListBase *seqbasep, int cfra, int chanshown, Sequ
        return cnt;
 }
 
-
-/* **********************************************************************
- * proxy management
- * ********************************************************************** */
+/*********************** proxy management *************************/
 
 typedef struct SeqIndexBuildContext {
        struct IndexBuildContext *index_context;
@@ -1207,9 +1068,7 @@ static void seq_open_anim_file(Sequence *seq)
                         seq->strip->dir, seq->strip->stripdata->name);
        BLI_path_abs(name, G.main->name);
        
-       seq->anim = openanim(name, IB_rect |
-                            ((seq->flag & SEQ_FILTERY) ?
-                             IB_animdeinterlace : 0), seq->streamindex);
+       seq->anim = openanim(name, IB_rect | ((seq->flag & SEQ_FILTERY) ? IB_animdeinterlace : 0), seq->streamindex);
 
        if (seq->anim == NULL) {
                return;
@@ -1271,7 +1130,7 @@ static int seq_proxy_get_fname(Sequence *seq, int cfra, int render_size, char *n
        if (seq->type == SEQ_TYPE_IMAGE) {
                BLI_snprintf(name, PROXY_MAXFILE, "%s/images/%d/%s_proxy", dir,
                             render_size,
-                            give_stripelem(seq, cfra)->name);
+                            BKE_sequencer_give_stripelem(seq, cfra)->name);
                frameno = 1;
        }
        else {
@@ -1345,9 +1204,7 @@ static ImBuf *seq_proxy_fetch(SeqRenderData context, Sequence *seq, int cfra)
        }
 }
 
-static void seq_proxy_build_frame(SeqRenderData context,
-                                  Sequence *seq, int cfra,
-                                  int proxy_render_size)
+static void seq_proxy_build_frame(SeqRenderData context, Sequence *seq, int cfra, int proxy_render_size)
 {
        char name[PROXY_MAXFILE];
        int quality;
@@ -1387,7 +1244,7 @@ static void seq_proxy_build_frame(SeqRenderData context,
        IMB_freeImBuf(ibuf);
 }
 
-struct SeqIndexBuildContext *seq_proxy_rebuild_context(Main *bmain, Scene *scene, Sequence *seq)
+SeqIndexBuildContext *BKE_sequencer_proxy_rebuild_context(Main *bmain, Scene *scene, Sequence *seq)
 {
        SeqIndexBuildContext *context;
        Sequence *nseq;
@@ -1402,7 +1259,7 @@ struct SeqIndexBuildContext *seq_proxy_rebuild_context(Main *bmain, Scene *scene
 
        context = MEM_callocN(sizeof(SeqIndexBuildContext), "seq proxy rebuild context");
 
-       nseq = seq_dupli_recursive(scene, scene, seq, 0);
+       nseq = BKE_sequence_dupli_recursive(scene, scene, seq, 0);
 
        context->tc_flags   = nseq->strip->proxy->build_tc_flags;
        context->size_flags = nseq->strip->proxy->build_size_flags;
@@ -1425,7 +1282,7 @@ struct SeqIndexBuildContext *seq_proxy_rebuild_context(Main *bmain, Scene *scene
        return context;
 }
 
-void seq_proxy_rebuild(SeqIndexBuildContext *context, short *stop, short *do_update, float *progress)
+void BKE_sequencer_proxy_rebuild(SeqIndexBuildContext *context, short *stop, short *do_update, float *progress)
 {
        SeqRenderData render_context;
        Sequence *seq = context->seq;
@@ -1451,15 +1308,11 @@ void seq_proxy_rebuild(SeqIndexBuildContext *context, short *stop, short *do_upd
 
        /* fail safe code */
 
-       render_context = seq_new_render_data(
-               context->bmain, context->scene,
-               (scene->r.size * (float)scene->r.xsch) / 100.0f + 0.5f,
-               (scene->r.size * (float)scene->r.ysch) / 100.0f + 0.5f,
-               100);
+       render_context = BKE_sequencer_new_render_data(context->bmain, context->scene,
+                                           (scene->r.size * (float) scene->r.xsch) / 100.0f + 0.5f,
+                                           (scene->r.size * (float) scene->r.ysch) / 100.0f + 0.5f, 100);
 
-       for (cfra = seq->startdisp + seq->startstill; 
-            cfra < seq->enddisp - seq->endstill; cfra++)
-       {
+       for (cfra = seq->startdisp + seq->startstill;  cfra < seq->enddisp - seq->endstill; cfra++) {
                if (context->size_flags & IMB_PROXY_25) {
                        seq_proxy_build_frame(render_context, seq, cfra, 25);
                }
@@ -1473,8 +1326,7 @@ void seq_proxy_rebuild(SeqIndexBuildContext *context, short *stop, short *do_upd
                        seq_proxy_build_frame(render_context, seq, cfra, 100);
                }
 
-               *progress = (float)cfra / (seq->enddisp - seq->endstill -
-                                          seq->startdisp + seq->startstill);
+               *progress = (float) cfra / (seq->enddisp - seq->endstill - seq->startdisp + seq->startstill);
                *do_update = TRUE;
 
                if (*stop || G.afbreek)
@@ -1482,7 +1334,7 @@ void seq_proxy_rebuild(SeqIndexBuildContext *context, short *stop, short *do_upd
        }
 }
 
-void seq_proxy_rebuild_finish(SeqIndexBuildContext *context, short stop)
+void BKE_sequencer_proxy_rebuild_finish(SeqIndexBuildContext *context, short stop)
 {
        if (context->index_context) {
                IMB_close_anim_proxies(context->seq->anim);
@@ -1495,9 +1347,7 @@ void seq_proxy_rebuild_finish(SeqIndexBuildContext *context, short stop)
        MEM_freeN(context);
 }
 
-/* **********************************************************************
- * color balance
- * ********************************************************************** */
+/*********************** color balance *************************/
 
 static StripColorBalance calc_cb(StripColorBalance *cb_)
 {
@@ -1550,7 +1400,8 @@ MINLINE float color_balance_fl(float in, const float lift, const float gain, con
        float x = (((in - 1.0f) * lift) + 1.0f) * gain;
 
        /* prevent NaN */
-       if (x < 0.f) x = 0.f;
+       if (x < 0.f)
+               x = 0.f;
 
        return powf(x, gamma) * mul;
 }
@@ -1562,6 +1413,7 @@ static void make_cb_table_byte(float lift, float gain, float gamma,
 
        for (y = 0; y < 256; y++) {
                float v = color_balance_fl((float)y * (1.0f / 255.0f), lift, gain, gamma, mul);
+
                table[y] = FTOCHAR(v);
        }
 }
@@ -1573,6 +1425,7 @@ static void make_cb_table_float(float lift, float gain, float gamma,
 
        for (y = 0; y < 256; y++) {
                float v = color_balance_fl((float)y * (1.0f / 255.0f), lift, gain, gamma, mul);
+
                table[y] = v;
        }
 }
@@ -1587,8 +1440,7 @@ static void color_balance_byte_byte(Sequence *seq, unsigned char *rect, int widt
        StripColorBalance cb = calc_cb(seq->strip->color_balance);
 
        for (c = 0; c < 3; c++) {
-               make_cb_table_byte(cb.lift[c], cb.gain[c], cb.gamma[c],
-                                  cb_tab[c], mul);
+               make_cb_table_byte(cb.lift[c], cb.gain[c], cb.gamma[c], cb_tab[c], mul);
        }
 
        while (p < e) {
@@ -1736,8 +1588,8 @@ static void color_balance(Sequence *seq, ImBuf *ibuf, float mul)
                handle.rect_float = ibuf->rect_float;
 
                color_balance_do_thread(&handle);
-}      }
-
+       }
+}
 
 /*
  *  input preprocessing for SEQ_TYPE_IMAGE, SEQ_TYPE_MOVIE, SEQ_TYPE_MOVIECLIP and SEQ_TYPE_SCENE
@@ -1757,8 +1609,7 @@ static void color_balance(Sequence *seq, ImBuf *ibuf, float mul)
  *  - Premultiply
  */
 
-int input_have_to_preprocess(
-        SeqRenderData UNUSED(context), Sequence *seq, float UNUSED(cfra))
+int BKE_sequencer_input_have_to_preprocess(SeqRenderData UNUSED(context), Sequence *seq, float UNUSED(cfra))
 {
        float mul;
 
@@ -1785,9 +1636,8 @@ int input_have_to_preprocess(
        return FALSE;
 }
 
-static ImBuf *input_preprocess(
-        SeqRenderData context, Sequence *seq, float UNUSED(cfra), ImBuf *ibuf,
-        int is_proxy_image, int is_preprocessed)
+static ImBuf *input_preprocess(SeqRenderData context, Sequence *seq, float UNUSED(cfra), ImBuf *ibuf,
+                               int is_proxy_image, int is_preprocessed)
 {
        float mul;
 
@@ -1807,12 +1657,10 @@ static ImBuf *input_preprocess(
                double yscale = 1.0;
 
                if (is_proxy_image) {
-                       double f = seq_rendersize_to_scale_factor(
-                               context.preview_render_size);
+                       double f = seq_rendersize_to_scale_factor(context.preview_render_size);
 
                        if (f != 1.0) {
-                               IMB_scalefastImBuf(
-                                       ibuf, ibuf->x / f, ibuf->y / f);
+                               IMB_scalefastImBuf(ibuf, ibuf->x / f, ibuf->y / f);
                        }
                }
 
@@ -1823,12 +1671,8 @@ static ImBuf *input_preprocess(
                        t = *seq->strip->transform;
                }
 
-               xscale = context.scene->r.xsch ? 
-                        ((double) context.rectx /
-                         (double) context.scene->r.xsch) : 1.0;
-               yscale = context.scene->r.ysch ? 
-                        ((double) context.recty /
-                         (double) context.scene->r.ysch) : 1.0;
+               xscale = context.scene->r.xsch ? ((double) context.rectx / (double) context.scene->r.xsch) : 1.0;
+               yscale = context.scene->r.ysch ? ((double) context.recty / (double) context.scene->r.ysch) : 1.0;
 
                c.left *= xscale; c.right *= xscale;
                c.top *= yscale; c.bottom *= yscale;
@@ -1858,12 +1702,9 @@ static ImBuf *input_preprocess(
                        make_black_ibuf(ibuf);
                }
                else {
-                       ImBuf *i = IMB_allocImBuf(
-                               dx, dy, 32,
-                               ibuf->rect_float ? IB_rectfloat : IB_rect);
+                       ImBuf *i = IMB_allocImBuf(dx, dy, 32, ibuf->rect_float ? IB_rectfloat : IB_rect);
 
-                       IMB_rectcpy(i, ibuf, 
-                                   t.xofs, t.yofs, c.left, c.bottom, sx, sy);
+                       IMB_rectcpy(i, ibuf, t.xofs, t.yofs, c.left, c.bottom, sx, sy);
                        
                        IMB_freeImBuf(ibuf);
 
@@ -1925,21 +1766,16 @@ static ImBuf *input_preprocess(
        return ibuf;
 }
 
-static ImBuf *copy_from_ibuf_still(SeqRenderData context, Sequence *seq,
-                                   float nr)
+static ImBuf *copy_from_ibuf_still(SeqRenderData context, Sequence *seq, float nr)
 {
        ImBuf *rval = NULL;
        ImBuf *ibuf = NULL;
 
        if (nr == 0) {
-               ibuf = seq_stripelem_cache_get(
-                       context, seq, seq->start,
-                       SEQ_STRIPELEM_IBUF_STARTSTILL);
+               ibuf = BKE_sequencer_cache_get(context, seq, seq->start, SEQ_STRIPELEM_IBUF_STARTSTILL);
        }
        else if (nr == seq->len - 1) {
-               ibuf = seq_stripelem_cache_get(
-                       context, seq, seq->start,
-                       SEQ_STRIPELEM_IBUF_ENDSTILL);
+               ibuf = BKE_sequencer_cache_get(context, seq, seq->start, SEQ_STRIPELEM_IBUF_ENDSTILL);
        }
 
        if (ibuf) {
@@ -1950,8 +1786,7 @@ static ImBuf *copy_from_ibuf_still(SeqRenderData context, Sequence *seq,
        return rval;
 }
 
-static void copy_to_ibuf_still(SeqRenderData context, Sequence *seq, float nr,
-                               ImBuf *ibuf)
+static void copy_to_ibuf_still(SeqRenderData context, Sequence *seq, float nr, ImBuf *ibuf)
 {
        if (nr == 0 || nr == seq->len - 1) {
                /* we have to store a copy, since the passed ibuf
@@ -1960,39 +1795,102 @@ static void copy_to_ibuf_still(SeqRenderData context, Sequence *seq, float nr,
                ibuf = IMB_dupImBuf(ibuf);
 
                if (nr == 0) {
-                       seq_stripelem_cache_put(
-                               context, seq, seq->start,
-                               SEQ_STRIPELEM_IBUF_STARTSTILL, ibuf);
+                       BKE_sequencer_cache_put(context, seq, seq->start, SEQ_STRIPELEM_IBUF_STARTSTILL, ibuf);
                } 
 
                if (nr == seq->len - 1) {
-                       seq_stripelem_cache_put(
-                               context, seq, seq->start,
-                               SEQ_STRIPELEM_IBUF_ENDSTILL, ibuf);
+                       BKE_sequencer_cache_put(context, seq, seq->start, SEQ_STRIPELEM_IBUF_ENDSTILL, ibuf);
                }
 
                IMB_freeImBuf(ibuf);
        }
 }
 
-/* **********************************************************************
- * strip rendering functions
- * ********************************************************************** */
+/*********************** strip rendering functions  *************************/
 
-static ImBuf *seq_render_strip_stack(
-        SeqRenderData context, ListBase *seqbasep, float cfra, int chanshown);
+typedef struct RenderEffectInitData {
+       struct SeqEffectHandle *sh;
+       SeqRenderData context;
+       Sequence *seq;
+       float cfra, facf0, facf1;
+       ImBuf *ibuf1, *ibuf2, *ibuf3;
 
-static ImBuf *seq_render_strip(
-        SeqRenderData context, Sequence *seq, float cfra);
+       ImBuf *out;
+} RenderEffectInitData;
 
+typedef struct RenderEffectThread {
+       struct SeqEffectHandle *sh;
+       SeqRenderData context;
+       Sequence *seq;
+       float cfra, facf0, facf1;
+       ImBuf *ibuf1, *ibuf2, *ibuf3;
 
-static ImBuf *seq_render_effect_strip_impl(
-        SeqRenderData context, Sequence *seq, float cfra)
+       ImBuf *out;
+       int start_line, tot_line;
+} RenderEffectThread;
+
+static void render_effect_execute_init_handle(void *handle_v, int start_line, int tot_line, void *init_data_v)
+{
+       RenderEffectThread *handle = (RenderEffectThread *) handle_v;
+       RenderEffectInitData *init_data = (RenderEffectInitData *) init_data_v;
+
+       handle->sh = init_data->sh;
+       handle->context = init_data->context;
+       handle->seq = init_data->seq;
+       handle->cfra = init_data->cfra;
+       handle->facf0 = init_data->facf0;
+       handle->facf1 = init_data->facf1;
+       handle->ibuf1 = init_data->ibuf1;
+       handle->ibuf2 = init_data->ibuf2;
+       handle->ibuf3 = init_data->ibuf3;
+       handle->out = init_data->out;
+
+       handle->start_line = start_line;
+       handle->tot_line = tot_line;
+}
+
+static void *render_effect_execute_do_thread(void *thread_data_v)
+{
+       RenderEffectThread *thread_data = (RenderEffectThread *) thread_data_v;
+
+       thread_data->sh->execute_slice(thread_data->context, thread_data->seq, thread_data->cfra,
+                                      thread_data->facf0, thread_data->facf1, thread_data->ibuf1,
+                                      thread_data->ibuf2, thread_data->ibuf3, thread_data->start_line,
+                                      thread_data->tot_line, thread_data->out);
+
+       return NULL;
+}
+
+static ImBuf *seq_render_effect_execute_threaded(struct SeqEffectHandle *sh, SeqRenderData context, Sequence *seq,
+                                                 float cfra, float facf0, float facf1,
+                                                 ImBuf *ibuf1, ImBuf *ibuf2, ImBuf *ibuf3)
+{
+       RenderEffectInitData init_data;
+       ImBuf *out = sh->init_execution(context, ibuf1, ibuf2, ibuf3);
+
+       init_data.sh = sh;
+       init_data.context = context;
+       init_data.seq = seq;
+       init_data.cfra = cfra;
+       init_data.facf0 = facf0;
+       init_data.facf1 = facf1;
+       init_data.ibuf1 = ibuf1;
+       init_data.ibuf2 = ibuf2;
+       init_data.ibuf3 = ibuf3;
+       init_data.out = out;
+
+       IMB_processor_apply_threaded(out->y, sizeof(RenderEffectThread), &init_data,
+                                 render_effect_execute_init_handle, render_effect_execute_do_thread);
+
+       return out;
+}
+
+static ImBuf *seq_render_effect_strip_impl(SeqRenderData context, Sequence *seq, float cfra)
 {
        float fac, facf;
        int early_out;
        int i;
-       struct SeqEffectHandle sh = get_sequence_effect(seq);
+       struct SeqEffectHandle sh = BKE_sequence_get_effect(seq);
        FCurve *fcu = NULL;
        ImBuf *ibuf[3];
        Sequence *input[3];
@@ -2002,7 +1900,8 @@ static ImBuf *seq_render_effect_strip_impl(
 
        input[0] = seq->seq1; input[1] = seq->seq2; input[2] = seq->seq3;
 
-       if (!sh.execute) { /* effect not supported in this version... */
+       if (!sh.execute && !(sh.execute_slice && sh.init_execution)) {
+               /* effect not supported in this version... */
                out = IMB_allocImBuf(context.rectx, context.recty, 32, IB_rect);
                return out;
        }
@@ -2030,19 +1929,19 @@ static ImBuf *seq_render_effect_strip_impl(
 
        switch (early_out) {
                case EARLY_NO_INPUT:
-                       out = sh.execute(context, seq, cfra, fac, facf,  
-                                        NULL, NULL, NULL);
+                       out = sh.execute(context, seq, cfra, fac, facf, NULL, NULL, NULL);
                        break;
                case EARLY_DO_EFFECT:
                        for (i = 0; i < 3; i++) {
                                if (input[i])
-                                       ibuf[i] = seq_render_strip(
-                                               context, input[i], cfra);
+                                       ibuf[i] = seq_render_strip(context, input[i], cfra);
                        }
 
                        if (ibuf[0] && ibuf[1]) {
-                               out = sh.execute(context, seq, cfra, fac, facf,
-                                                ibuf[0], ibuf[1], ibuf[2]);
+                               if (sh.multithreaded)
+                                       out = seq_render_effect_execute_threaded(&sh, context, seq, cfra, fac, facf, ibuf[0], ibuf[1], ibuf[2]);
+                               else
+                                       out = sh.execute(context, seq, cfra, fac, facf, ibuf[0], ibuf[1], ibuf[2]);
                        }
                        break;
                case EARLY_USE_INPUT_1:
@@ -2050,7 +1949,7 @@ static ImBuf *seq_render_effect_strip_impl(
                                ibuf[0] = seq_render_strip(context, input[0], cfra);
                        }
                        if (ibuf[0]) {
-                               if (input_have_to_preprocess(context, seq, cfra)) {
+                               if (BKE_sequencer_input_have_to_preprocess(context, seq, cfra)) {
                                        out = IMB_dupImBuf(ibuf[0]);
                                }
                                else {
@@ -2064,7 +1963,7 @@ static ImBuf *seq_render_effect_strip_impl(
                                ibuf[1] = seq_render_strip(context, input[1], cfra);
                        }
                        if (ibuf[1]) {
-                               if (input_have_to_preprocess(context, seq, cfra)) {
+                               if (BKE_sequencer_input_have_to_preprocess(context, seq, cfra)) {
                                        out = IMB_dupImBuf(ibuf[1]);
                                }
                                else {
@@ -2086,8 +1985,7 @@ static ImBuf *seq_render_effect_strip_impl(
        return out;
 }
 
-static ImBuf *seq_render_movieclip_strip(
-        SeqRenderData context, Sequence *seq, float nr)
+static ImBuf *seq_render_movieclip_strip(SeqRenderData context, Sequence *seq, float nr)
 {
        ImBuf *ibuf = NULL;
        MovieClipUser user;
@@ -2126,21 +2024,17 @@ static ImBuf *seq_render_movieclip_strip(
        }
 
        if (seq->clip_flag & SEQ_MOVIECLIP_RENDER_STABILIZED) {
-               ibuf = BKE_movieclip_get_stable_ibuf(
-                       seq->clip, &user, tloc, &tscale, &tangle,
-                       0);
+               ibuf = BKE_movieclip_get_stable_ibuf(seq->clip, &user, tloc, &tscale, &tangle, 0);
        }
        else {
-               ibuf = BKE_movieclip_get_ibuf_flag(
-                       seq->clip, &user, 0, MOVIECLIP_CACHE_SKIP);
+               ibuf = BKE_movieclip_get_ibuf_flag(seq->clip, &user, 0, MOVIECLIP_CACHE_SKIP);
        }
 
        return ibuf;
 }
 
 
-static ImBuf *seq_render_mask_strip(
-        SeqRenderData context, Sequence *seq, float nr)
+static ImBuf *seq_render_mask_strip(SeqRenderData context, Sequence *seq, float nr)
 {
        /* TODO - add option to rasterize to alpha imbuf? */
        ImBuf *ibuf = NULL;
@@ -2162,9 +2056,7 @@ static ImBuf *seq_render_mask_strip(
 
                mr_handle = BKE_maskrasterize_handle_new();
 
-               BKE_maskrasterize_handle_init(mr_handle, mask_temp,
-                                             context.rectx, context.recty,
-                                             TRUE, TRUE, TRUE);
+               BKE_maskrasterize_handle_init(mr_handle, mask_temp, context.rectx, context.recty, TRUE, TRUE, TRUE);
 
                BKE_mask_free(mask_temp);
                MEM_freeN(mask_temp);
@@ -2217,8 +2109,7 @@ static ImBuf *seq_render_mask_strip(
        return ibuf;
 }
 
-static ImBuf *seq_render_scene_strip(
-        SeqRenderData context, Sequence *seq, float nr)
+static ImBuf *seq_render_scene_strip(SeqRenderData context, Sequence *seq, float nr)
 {
        ImBuf *ibuf = NULL;
        float frame;
@@ -2377,14 +2268,14 @@ static ImBuf *seq_render_strip(SeqRenderData context, Sequence *seq, float cfra)
 {
        ImBuf *ibuf = NULL;
        char name[FILE_MAX];
-       int use_preprocess = input_have_to_preprocess(context, seq, cfra);
+       int use_preprocess = BKE_sequencer_input_have_to_preprocess(context, seq, cfra);
        int is_proxy_image = FALSE;
        float nr = give_stripelem_index(seq, cfra);
        /* all effects are handled similarly with the exception of speed effect */
        int type = (seq->type & SEQ_TYPE_EFFECT && seq->type != SEQ_TYPE_SPEED) ? SEQ_TYPE_EFFECT : seq->type;
        int is_preprocessed = !ELEM3(type, SEQ_TYPE_IMAGE, SEQ_TYPE_MOVIE, SEQ_TYPE_SCENE);
 
-       ibuf = seq_stripelem_cache_get(context, seq, cfra, SEQ_STRIPELEM_IBUF);
+       ibuf = BKE_sequencer_cache_get(context, seq, cfra, SEQ_STRIPELEM_IBUF);
 
        /* currently, we cache preprocessed images in SEQ_STRIPELEM_IBUF,
         * but not(!) on SEQ_STRIPELEM_IBUF_ENDSTILL and ..._STARTSTILL */
@@ -2430,7 +2321,7 @@ static ImBuf *seq_render_strip(SeqRenderData context, Sequence *seq, float cfra)
                                float f_cfra;
                                SpeedControlVars *s = (SpeedControlVars *)seq->effectdata;
 
-                               sequence_effect_speed_rebuild_map(context.scene, seq, 0);
+                               BKE_sequence_effect_speed_rebuild_map(context.scene, seq, 0);
 
                                /* weeek! */
                                f_cfra = seq->start + s->frameMap[(int)nr];
@@ -2451,13 +2342,12 @@ static ImBuf *seq_render_strip(SeqRenderData context, Sequence *seq, float cfra)
                        }
                        case SEQ_TYPE_EFFECT:
                        {
-                               ibuf = seq_render_effect_strip_impl(
-                                       context, seq, seq->start + nr);
+                               ibuf = seq_render_effect_strip_impl(context, seq, seq->start + nr);
                                break;
                        }
                        case SEQ_TYPE_IMAGE:
                        {
-                               StripElem *s_elem = give_stripelem(seq, cfra);
+                               StripElem *s_elem = BKE_sequencer_give_stripelem(seq, cfra);
 
                                if (s_elem) {
                                        BLI_join_dirfile(name, sizeof(name), seq->strip->dir, s_elem->name);
@@ -2485,16 +2375,11 @@ static ImBuf *seq_render_strip(SeqRenderData context, Sequence *seq, float cfra)
                                seq_open_anim_file(seq);
 
                                if (seq->anim) {
-                                       IMB_anim_set_preseek(seq->anim,
-                                                            seq->anim_preseek);
+                                       IMB_anim_set_preseek(seq->anim, seq->anim_preseek);
 
-                                       ibuf = IMB_anim_absolute(
-                                               seq->anim, nr + seq->anim_startofs,
-                                               seq->strip->proxy ?
-                                                   seq->strip->proxy->tc :
-                                                   IMB_TC_RECORD_RUN,
-                                               seq_rendersize_to_proxysize(
-                                                   context.preview_render_size));
+                                       ibuf = IMB_anim_absolute(seq->anim, nr + seq->anim_startofs,
+                                                                seq->strip->proxy ? seq->strip->proxy->tc : IMB_TC_RECORD_RUN,
+                                                                seq_rendersize_to_proxysize(context.preview_render_size));
 
                                        /* we don't need both (speed reasons)! */
                                        if (ibuf && ibuf->rect_float && ibuf->rect)
@@ -2508,7 +2393,8 @@ static ImBuf *seq_render_strip(SeqRenderData context, Sequence *seq, float cfra)
                                break;
                        }
                        case SEQ_TYPE_SCENE:
-                       { // scene can be NULL after deletions
+                       {
+                               /* scene can be NULL after deletions */
                                ibuf = seq_render_scene_strip(context, seq, nr);
 
                                /* Scene strips update all animation, so we need to restore original state.*/
@@ -2540,7 +2426,7 @@ static ImBuf *seq_render_strip(SeqRenderData context, Sequence *seq, float cfra)
                        copy_to_ibuf_still(context, seq, nr, ibuf);
                        break;
                }
-               }
+       }
 
        if (ibuf == NULL)
                ibuf = IMB_allocImBuf(context.rectx, context.recty, 32, IB_rect);
@@ -2549,17 +2435,14 @@ static ImBuf *seq_render_strip(SeqRenderData context, Sequence *seq, float cfra)
                use_preprocess = TRUE;
 
        if (use_preprocess)
-               ibuf = input_preprocess(context, seq, cfra, ibuf, 
-                                       is_proxy_image, is_preprocessed);
+               ibuf = input_preprocess(context, seq, cfra, ibuf, is_proxy_image, is_preprocessed);
 
-       seq_stripelem_cache_put(context, seq, cfra, SEQ_STRIPELEM_IBUF, ibuf);
+       BKE_sequencer_cache_put(context, seq, cfra, SEQ_STRIPELEM_IBUF, ibuf);
 
        return ibuf;
 }
 
-/* **********************************************************************
- * strip stack rendering functions
- * ********************************************************************** */
+/*********************** strip stack rendering functions *************************/
 
 static int seq_must_swap_input_in_blend_mode(Sequence *seq)
 {
@@ -2577,7 +2460,7 @@ static int seq_must_swap_input_in_blend_mode(Sequence *seq)
 
 static int seq_get_early_out_for_blend_mode(Sequence *seq)
 {
-       struct SeqEffectHandle sh = get_sequence_blend(seq);
+       struct SeqEffectHandle sh = BKE_sequence_get_blend(seq);
        float facf = seq->blend_opacity / 100.0f;
        int early_out = sh.early_out(seq, facf, facf);
        
@@ -2596,8 +2479,7 @@ static int seq_get_early_out_for_blend_mode(Sequence *seq)
        return early_out;
 }
 
-static ImBuf *seq_render_strip_stack(
-        SeqRenderData context, ListBase *seqbasep, float cfra, int chanshown)
+static ImBuf *seq_render_strip_stack(SeqRenderData context, ListBase *seqbasep, float cfra, int chanshown)
 {
        Sequence *seq_arr[MAXSEQ + 1];
        int count;
@@ -2618,8 +2500,7 @@ static ImBuf *seq_render_strip_stack(
        }
 #endif
 
-       out = seq_stripelem_cache_get(context, seq_arr[count - 1], 
-                                     cfra, SEQ_STRIPELEM_IBUF_COMP);
+       out = BKE_sequencer_cache_get(context, seq_arr[count - 1],  cfra, SEQ_STRIPELEM_IBUF_COMP);
 
        if (out) {
                return out;
@@ -2627,8 +2508,7 @@ static ImBuf *seq_render_strip_stack(
        
        if (count == 1) {
                out = seq_render_strip(context, seq_arr[0], cfra);
-               seq_stripelem_cache_put(context, seq_arr[0], cfra, 
-                                       SEQ_STRIPELEM_IBUF_COMP, out);
+               BKE_sequencer_cache_put(context, seq_arr[0], cfra, SEQ_STRIPELEM_IBUF_COMP, out);
 
                return out;
        }
@@ -2638,8 +2518,7 @@ static ImBuf *seq_render_strip_stack(
                int early_out;
                Sequence *seq = seq_arr[i];
 
-               out = seq_stripelem_cache_get(
-                       context, seq, cfra, SEQ_STRIPELEM_IBUF_COMP);
+               out = BKE_sequencer_cache_get(context, seq, cfra, SEQ_STRIPELEM_IBUF_COMP);
 
                if (out) {
                        break;
@@ -2673,9 +2552,7 @@ static ImBuf *seq_render_strip_stack(
                }
        }
 
-       seq_stripelem_cache_put(context, seq_arr[i], cfra, 
-                               SEQ_STRIPELEM_IBUF_COMP, out);
-
+       BKE_sequencer_cache_put(context, seq_arr[i], cfra, SEQ_STRIPELEM_IBUF_COMP, out);
 
        i++;
 
@@ -2683,7 +2560,7 @@ static ImBuf *seq_render_strip_stack(
                Sequence *seq = seq_arr[i];
 
                if (seq_get_early_out_for_blend_mode(seq) == EARLY_DO_EFFECT) {
-                       struct SeqEffectHandle sh = get_sequence_blend(seq);
+                       struct SeqEffectHandle sh = BKE_sequence_get_blend(seq);
                        ImBuf *ibuf1 = out;
                        ImBuf *ibuf2 = seq_render_strip(context, seq, cfra);
 
@@ -2691,22 +2568,23 @@ static ImBuf *seq_render_strip_stack(
                        int swap_input = seq_must_swap_input_in_blend_mode(seq);
 
                        if (swap_input) {
-                               out = sh.execute(context, seq, cfra, 
-                                                facf, facf,
-                                                ibuf2, ibuf1, NULL);
+                               if (sh.multithreaded)
+                                       out = seq_render_effect_execute_threaded(&sh, context, seq, cfra, facf, facf, ibuf2, ibuf1, NULL);
+                               else
+                                       out = sh.execute(context, seq, cfra, facf, facf, ibuf2, ibuf1, NULL);
                        }
                        else {
-                               out = sh.execute(context, seq, cfra, 
-                                                facf, facf,
-                                                ibuf1, ibuf2, NULL);
+                               if (sh.multithreaded)
+                                       out = seq_render_effect_execute_threaded(&sh, context, seq, cfra, facf, facf, ibuf1, ibuf2, NULL);
+                               else
+                                       out = sh.execute(context, seq, cfra, facf, facf, ibuf1, ibuf2, NULL);
                        }
                
                        IMB_freeImBuf(ibuf1);
                        IMB_freeImBuf(ibuf2);
                }
 
-               seq_stripelem_cache_put(context, seq_arr[i], cfra,
-                                       SEQ_STRIPELEM_IBUF_COMP, out);
+               BKE_sequencer_cache_put(context, seq_arr[i], cfra, SEQ_STRIPELEM_IBUF_COMP, out);
        }
 
        return out;
@@ -2717,7 +2595,7 @@ static ImBuf *seq_render_strip_stack(
  * you have to free after usage!
  */
 
-ImBuf *give_ibuf_seq(SeqRenderData context, float cfra, int chanshown)
+ImBuf *BKE_sequencer_give_ibuf(SeqRenderData context, float cfra, int chanshown)
 {
        Editing *ed = BKE_sequencer_editing_get(context.scene, FALSE);
        int count;
@@ -2737,30 +2615,17 @@ ImBuf *give_ibuf_seq(SeqRenderData context, float cfra, int chanshown)
        return seq_render_strip_stack(context, seqbasep, cfra, chanshown);
 }
 
-ImBuf *give_ibuf_seqbase(SeqRenderData context, float cfra, int chanshown, ListBase *seqbasep)
+ImBuf *BKE_sequencer_give_ibuf_seqbase(SeqRenderData context, float cfra, int chanshown, ListBase *seqbasep)
 {
        return seq_render_strip_stack(context, seqbasep, cfra, chanshown);
 }
 
 
-ImBuf *give_ibuf_seq_direct(SeqRenderData context, float cfra, Sequence *seq)
+ImBuf *BKE_sequencer_give_ibuf_direct(SeqRenderData context, float cfra, Sequence *seq)
 {
        return seq_render_strip(context, seq, cfra);
 }
 
-#if 0
-/* check used when we need to change seq->blend_mode but not to effect or audio strips */
-static int seq_can_blend(Sequence *seq)
-{
-       if (ELEM4(seq->type, SEQ_TYPE_IMAGE, SEQ_TYPE_META, SEQ_TYPE_SCENE, SEQ_TYPE_MOVIE)) {
-               return 1;
-       }
-       else {
-               return 0;
-       }
-}
-#endif
-
 /* *********************** threading api ******************* */
 
 static ListBase running_threads;
@@ -2805,152 +2670,7 @@ typedef struct PrefetchQueueElem {
        ImBuf *ibuf;
 } PrefetchQueueElem;
 
-#if 0
-static void *seq_prefetch_thread(void *This_)
-{
-       PrefetchThread *This = This_;
-
-       while (!seq_thread_shutdown) {
-               PrefetchQueueElem *e;
-               int s_last;
-
-               pthread_mutex_lock(&queue_lock);
-               e = prefetch_wait.first;
-               if (e) {
-                       BLI_remlink(&prefetch_wait, e);
-               }
-               s_last = seq_last_given_monoton_cfra;
-
-               This->current = e;
-
-               pthread_mutex_unlock(&queue_lock);
-
-               if (!e) {
-                       pthread_mutex_lock(&prefetch_ready_lock);
-
-                       This->running = FALSE;
-
-                       pthread_cond_signal(&prefetch_ready_cond);
-                       pthread_mutex_unlock(&prefetch_ready_lock);
-
-                       pthread_mutex_lock(&wakeup_lock);
-                       if (!seq_thread_shutdown) {
-                               pthread_cond_wait(&wakeup_cond, &wakeup_lock);
-                       }
-                       pthread_mutex_unlock(&wakeup_lock);
-                       continue;
-               }
-
-               This->running = TRUE;
-               
-               if (e->cfra >= s_last) { 
-                       e->ibuf = give_ibuf_seq_impl(This->scene, 
-                                                    e->rectx, e->recty, e->cfra, e->chanshown,
-                                                    e->preview_render_size);
-               }
-
-               pthread_mutex_lock(&queue_lock);
-
-               BLI_addtail(&prefetch_done, e);
-
-               for (e = prefetch_wait.first; e; e = e->next) {
-                       if (s_last > e->monoton_cfra) {
-                               BLI_remlink(&prefetch_wait, e);
-                               MEM_freeN(e);
-                       }
-               }
-
-               for (e = prefetch_done.first; e; e = e->next) {
-                       if (s_last > e->monoton_cfra) {
-                               BLI_remlink(&prefetch_done, e);
-                               MEM_freeN(e);
-                       }
-               }
-
-               pthread_mutex_unlock(&queue_lock);
-
-               pthread_mutex_lock(&frame_done_lock);
-               pthread_cond_signal(&frame_done_cond);
-               pthread_mutex_unlock(&frame_done_lock);
-       }
-       return 0;
-}
-
-static void seq_start_threads(Scene *scene)
-{
-       int i;
-
-       running_threads.first = running_threads.last = NULL;
-       prefetch_wait.first = prefetch_wait.last = NULL;
-       prefetch_done.first = prefetch_done.last = NULL;
-
-       seq_thread_shutdown = FALSE;
-       seq_last_given_monoton_cfra = monoton_cfra = 0;
-
-       /* since global structures are modified during the processing
-        * of one frame, only one render thread is currently possible...
-        *
-        * (but we code, in the hope, that we can remove this restriction
-        * soon...)
-        */
-
-       fprintf(stderr, "SEQ-THREAD: seq_start_threads\n");
-
-       for (i = 0; i < 1; i++) {
-               PrefetchThread *t = MEM_callocN(sizeof(PrefetchThread), "prefetch_thread");
-               t->scene = scene;
-               t->running = TRUE;
-               BLI_addtail(&running_threads, t);
-
-               pthread_create(&t->pthread, NULL, seq_prefetch_thread, t);
-       }
-
-       /* init malloc mutex */
-       BLI_init_threads(0, 0, 0);
-}
-
-static void seq_stop_threads()
-{
-       PrefetchThread *tslot;
-       PrefetchQueueElem *e;
-
-       fprintf(stderr, "SEQ-THREAD: seq_stop_threads()\n");
-
-       if (seq_thread_shutdown) {
-               fprintf(stderr, "SEQ-THREAD: ... already stopped\n");
-               return;
-       }
-       
-       pthread_mutex_lock(&wakeup_lock);
-
-       seq_thread_shutdown = TRUE;
-
-       pthread_cond_broadcast(&wakeup_cond);
-       pthread_mutex_unlock(&wakeup_lock);
-
-       for (tslot = running_threads.first; tslot; tslot = tslot->next) {
-               pthread_join(tslot->pthread, NULL);
-       }
-
-
-       for (e = prefetch_wait.first; e; e = e->next) {
-               BLI_remlink(&prefetch_wait, e);
-               MEM_freeN(e);
-       }
-
-       for (e = prefetch_done.first; e; e = e->next) {
-               BLI_remlink(&prefetch_done, e);
-               MEM_freeN(e);
-       }
-
-       BLI_freelistN(&running_threads);
-
-       /* deinit malloc mutex */
-       BLI_end_threads(0);
-}
-#endif
-
-void give_ibuf_prefetch_request(SeqRenderData context, float cfra, int chanshown)
+void BKE_sequencer_give_ibuf_prefetch_request(SeqRenderData context, float cfra, int chanshown)
 {
        PrefetchQueueElem *e;
        if (seq_thread_shutdown) {
@@ -2974,44 +2694,13 @@ void give_ibuf_prefetch_request(SeqRenderData context, float cfra, int chanshown
        pthread_mutex_unlock(&wakeup_lock);
 }
 
-#if 0
-static void seq_wait_for_prefetch_ready()
-{
-       PrefetchThread *tslot;
-
-       if (seq_thread_shutdown) {
-               return;
-       }
-
-       fprintf(stderr, "SEQ-THREAD: rendering prefetch frames...\n");
-
-       pthread_mutex_lock(&prefetch_ready_lock);
-
-       for (;; ) {
-               for (tslot = running_threads.first; tslot; tslot = tslot->next) {
-                       if (tslot->running) {
-                               break;
-                       }
-               }
-               if (!tslot) {
-                       break;
-               }
-               pthread_cond_wait(&prefetch_ready_cond, &prefetch_ready_lock);
-       }
-
-       pthread_mutex_unlock(&prefetch_ready_lock);
-
-       fprintf(stderr, "SEQ-THREAD: prefetch done\n");
-}
-#endif
-
-ImBuf *give_ibuf_seq_threaded(SeqRenderData context, float cfra, int chanshown)
+ImBuf *BKE_sequencer_give_ibuf_threaded(SeqRenderData context, float cfra, int chanshown)
 {
        PrefetchQueueElem *e = NULL;
        int found_something = FALSE;
 
        if (seq_thread_shutdown) {
-               return give_ibuf_seq(context, cfra, chanshown);
+               return BKE_sequencer_give_ibuf(context, cfra, chanshown);
        }
 
        while (!e) {
@@ -3077,9 +2766,7 @@ ImBuf *give_ibuf_seq_threaded(SeqRenderData context, float cfra, int chanshown)
                        e = NULL;
 
                        if (!found_something) {
-                               fprintf(stderr, 
-                                       "SEQ-THREAD: Requested frame "
-                                       "not in queue ???\n");
+                               fprintf(stderr, "SEQ-THREAD: Requested frame not in queue ???\n");
                                break;
                        }
                        pthread_mutex_lock(&frame_done_lock);
@@ -3101,8 +2788,44 @@ static void free_anim_seq(Sequence *seq)
        }
 }
 
-void free_imbuf_seq(Scene *scene, ListBase *seqbase, int check_mem_usage,
-                    int keep_file_handles)
+void BKE_sequence_invalidate_cache(Scene *scene, Sequence *seq)
+{
+       Editing *ed = scene->ed;
+       Sequence *cur;
+       int left = seq->startdisp, right = seq->enddisp;
+
+       /* invalidate cache for current sequence */
+       BKE_sequencer_cache_cleanup_sequence(seq);
+
+       /* invalidate cache for all dependent sequences */
+       SEQ_BEGIN (ed, cur)
+       {
+               int cur_left = cur->startdisp, cur_right = cur->enddisp;
+
+               if (cur == seq)
+                       continue;
+
+               /* sequence is outside of changed one, shouldn't be invalidated */
+               if (cur_right < left || cur_left > right)
+                       continue;
+
+               /* sequence is below changed one, not dependent on it */
+               if (cur->machine < seq->machine)
+                       continue;
+
+               /* sequence is not blending with lower machines, no need to invalidate */
+               if ((cur->blend_mode == SEQ_BLEND_REPLACE) ||
+                   (cur->blend_mode == SEQ_TYPE_CROSS && cur->blend_opacity == 100.0f))
+               {
+                       continue;
+               }
+
+               BKE_sequencer_cache_cleanup_sequence(cur);
+       }
+       SEQ_END
+}
+
+void BKE_sequencer_free_imbuf(Scene *scene, ListBase *seqbase, int check_mem_usage, int keep_file_handles)
 {
        Sequence *seq;
 
@@ -3130,18 +2853,18 @@ void free_imbuf_seq(Scene *scene, ListBase *seqbase, int check_mem_usage,
                }
        }
 
-       seq_stripelem_cache_cleanup();
+       BKE_sequencer_cache_cleanup();
        
        for (seq = seqbase->first; seq; seq = seq->next) {
                if (seq->strip) {
                        if (seq->type == SEQ_TYPE_MOVIE && !keep_file_handles)
                                free_anim_seq(seq);
                        if (seq->type == SEQ_TYPE_SPEED) {
-                               sequence_effect_speed_rebuild_map(scene, seq, 1);
+                               BKE_sequence_effect_speed_rebuild_map(scene, seq, 1);
                        }
                }
                if (seq->type == SEQ_TYPE_META) {
-                       free_imbuf_seq(scene, &seq->seqbase, FALSE, keep_file_handles);
+                       BKE_sequencer_free_imbuf(scene, &seq->seqbase, FALSE, keep_file_handles);
                }
                if (seq->type == SEQ_TYPE_SCENE) {
                        /* FIXME: recurs downwards, 
@@ -3183,18 +2906,18 @@ static int update_changed_seq_recurs(Scene *scene, Sequence *seq, Sequence *chan
                        if (seq->type == SEQ_TYPE_MOVIE)
                                free_anim_seq(seq);
                        if (seq->type == SEQ_TYPE_SPEED) {
-                               sequence_effect_speed_rebuild_map(scene, seq, 1);
+                               BKE_sequence_effect_speed_rebuild_map(scene, seq, 1);
                        }
                }
                
                if (len_change)
-                       calc_sequence(scene, seq);
+                       BKE_sequence_calc(scene, seq);
        }
        
        return free_imbuf;
 }
 
-void update_changed_seq_and_deps(Scene *scene, Sequence *changed_seq, int len_change, int ibuf_change)
+void BKE_sequencer_update_changed_seq_and_deps(Scene *scene, Sequence *changed_seq, int len_change, int ibuf_change)
 {
        Editing *ed = BKE_sequencer_editing_get(scene, FALSE);
        Sequence *seq;
@@ -3211,38 +2934,38 @@ void update_changed_seq_and_deps(Scene *scene, Sequence *changed_seq, int len_ch
  * left and right are the bounds at which the sequence is rendered,
  * start and end are from the start and fixed length of the sequence.
  */
-int seq_tx_get_start(Sequence *seq)
+static int seq_tx_get_start(Sequence *seq)
 {
        return seq->start;
 }
-int seq_tx_get_end(Sequence *seq)
+static int seq_tx_get_end(Sequence *seq)
 {
        return seq->start + seq->len;
 }
 
-int seq_tx_get_final_left(Sequence *seq, int metaclip)
+int BKE_sequence_tx_get_final_left(Sequence *seq, int metaclip)
 {
        if (metaclip && seq->tmp) {
                /* return the range clipped by the parents range */
-               return maxi(seq_tx_get_final_left(seq, 0), seq_tx_get_final_left((Sequence *)seq->tmp, TRUE));
+               return maxi(BKE_sequence_tx_get_final_left(seq, 0), BKE_sequence_tx_get_final_left((Sequence *)seq->tmp, TRUE));
        }
        else {
                return (seq->start - seq->startstill) + seq->startofs;
        }
 
 }
-int seq_tx_get_final_right(Sequence *seq, int metaclip)
+int BKE_sequence_tx_get_final_right(Sequence *seq, int metaclip)
 {
        if (metaclip && seq->tmp) {
                /* return the range clipped by the parents range */
-               return mini(seq_tx_get_final_right(seq, 0), seq_tx_get_final_right((Sequence *)seq->tmp, TRUE));
+               return mini(BKE_sequence_tx_get_final_right(seq, 0), BKE_sequence_tx_get_final_right((Sequence *)seq->tmp, TRUE));
        }
        else {
                return ((seq->start + seq->len) + seq->endstill) - seq->endofs;
        }
 }
 
-void seq_tx_set_final_left(Sequence *seq, int val)
+void BKE_sequence_tx_set_final_left(Sequence *seq, int val)
 {
        if (val < (seq)->start) {
                seq->startstill = abs(val - (seq)->start);
@@ -3254,7 +2977,7 @@ void seq_tx_set_final_left(Sequence *seq, int val)
        }
 }
 
-void seq_tx_set_final_right(Sequence *seq, int val)
+void BKE_sequence_tx_set_final_right(Sequence *seq, int val)
 {
        if (val > (seq)->start + (seq)->len) {
                seq->endstill = abs(val - (seq->start + (seq)->len));
@@ -3268,16 +2991,16 @@ void seq_tx_set_final_right(Sequence *seq, int val)
 
 /* used so we can do a quick check for single image seq
  * since they work a bit differently to normal image seq's (during transform) */
-int seq_single_check(Sequence *seq)
+int BKE_sequence_single_check(Sequence *seq)
 {
        return ((seq->len == 1) &&
                (seq->type == SEQ_TYPE_IMAGE ||
                 ((seq->type & SEQ_TYPE_EFFECT) &&
-                 get_sequence_effect_num_inputs(seq->type) == 0)));
+                 BKE_sequence_effect_get_num_inputs(seq->type) == 0)));
 }
 
 /* check if the selected seq's reference unselected seq's */
-int seqbase_isolated_sel_check(ListBase *seqbase)
+int BKE_sequence_base_isolated_sel_check(ListBase *seqbase)
 {
        Sequence *seq;
        /* is there more than 1 select */
@@ -3321,16 +3044,16 @@ int seqbase_isolated_sel_check(ListBase *seqbase)
 
 /* use to impose limits when dragging/extending - so impossible situations don't happen
  * Cant use the SEQ_LEFTSEL and SEQ_LEFTSEL directly because the strip may be in a metastrip */
-void seq_tx_handle_xlimits(Sequence *seq, int leftflag, int rightflag)
+void BKE_sequence_tx_handle_xlimits(Sequence *seq, int leftflag, int rightflag)
 {
        if (leftflag) {
-               if (seq_tx_get_final_left(seq, 0) >= seq_tx_get_final_right(seq, 0)) {
-                       seq_tx_set_final_left(seq, seq_tx_get_final_right(seq, 0) - 1);
+               if (BKE_sequence_tx_get_final_left(seq, 0) >= BKE_sequence_tx_get_final_right(seq, 0)) {
+                       BKE_sequence_tx_set_final_left(seq, BKE_sequence_tx_get_final_right(seq, 0) - 1);
                }
 
-               if (seq_single_check(seq) == 0) {
-                       if (seq_tx_get_final_left(seq, 0) >= seq_tx_get_end(seq)) {
-                               seq_tx_set_final_left(seq, seq_tx_get_end(seq) - 1);
+               if (BKE_sequence_single_check(seq) == 0) {
+                       if (BKE_sequence_tx_get_final_left(seq, 0) >= seq_tx_get_end(seq)) {
+                               BKE_sequence_tx_set_final_left(seq, seq_tx_get_end(seq) - 1);
                        }
 
                        /* dosnt work now - TODO */
@@ -3346,13 +3069,13 @@ void seq_tx_handle_xlimits(Sequence *seq, int leftflag, int rightflag)
        }
 
        if (rightflag) {
-               if (seq_tx_get_final_right(seq, 0) <= seq_tx_get_final_left(seq, 0)) {
-                       seq_tx_set_final_right(seq, seq_tx_get_final_left(seq, 0) + 1);
+               if (BKE_sequence_tx_get_final_right(seq, 0) <= BKE_sequence_tx_get_final_left(seq, 0)) {
+                       BKE_sequence_tx_set_final_right(seq, BKE_sequence_tx_get_final_left(seq, 0) + 1);
                }
 
-               if (seq_single_check(seq) == 0) {
-                       if (seq_tx_get_final_right(seq, 0) <= seq_tx_get_start(seq)) {
-                               seq_tx_set_final_right(seq, seq_tx_get_start(seq) + 1);
+               if (BKE_sequence_single_check(seq) == 0) {
+                       if (BKE_sequence_tx_get_final_right(seq, 0) <= seq_tx_get_start(seq)) {
+                               BKE_sequence_tx_set_final_right(seq, seq_tx_get_start(seq) + 1);
                        }
                }
        }
@@ -3364,27 +3087,27 @@ void seq_tx_handle_xlimits(Sequence *seq, int leftflag, int rightflag)
        }
 }
 
-void seq_single_fix(Sequence *seq)
+void BKE_sequence_single_fix(Sequence *seq)
 {
        int left, start, offset;
-       if (!seq_single_check(seq))
+       if (!BKE_sequence_single_check(seq))
                return;
 
        /* make sure the image is always at the start since there is only one,
         * adjusting its start should be ok */
-       left = seq_tx_get_final_left(seq, 0);
+       left = BKE_sequence_tx_get_final_left(seq, 0);
        start = seq->start;
        if (start != left) {
                offset = left - start;
-               seq_tx_set_final_left(seq, seq_tx_get_final_left(seq, 0) - offset);
-               seq_tx_set_final_right(seq, seq_tx_get_final_right(seq, 0) - offset);
+               BKE_sequence_tx_set_final_left(seq, BKE_sequence_tx_get_final_left(seq, 0) - offset);
+               BKE_sequence_tx_set_final_right(seq, BKE_sequence_tx_get_final_right(seq, 0) - offset);
                seq->start += offset;
        }
 }
 
-int seq_tx_test(Sequence *seq)
+int BKE_sequence_tx_test(Sequence *seq)
 {
-       return (seq->type < SEQ_TYPE_EFFECT) || (get_sequence_effect_num_inputs(seq->type) == 0);
+       return (seq->type < SEQ_TYPE_EFFECT) || (BKE_sequence_effect_get_num_inputs(seq->type) == 0);
 }
 
 static int seq_overlap(Sequence *seq1, Sequence *seq2)
@@ -3393,7 +3116,7 @@ static int seq_overlap(Sequence *seq1, Sequence *seq2)
                ((seq1->enddisp <= seq2->startdisp) || (seq1->startdisp >= seq2->enddisp)) == 0);
 }
 
-int seq_test_overlap(ListBase *seqbasep, Sequence *test)
+int BKE_sequence_test_overlap(ListBase *seqbasep, Sequence *test)
 {
        Sequence *seq;
 
@@ -3408,27 +3131,27 @@ int seq_test_overlap(ListBase *seqbasep, Sequence *test)
 }
 
 
-void seq_translate(Scene *evil_scene, Sequence *seq, int delta)
+void BKE_sequence_translate(Scene *evil_scene, Sequence *seq, int delta)
 {
-       seq_offset_animdata(evil_scene, seq, delta);
+       BKE_sequencer_offset_animdata(evil_scene, seq, delta);
        seq->start += delta;
 
        if (seq->type == SEQ_TYPE_META) {
                Sequence *seq_child;
                for (seq_child = seq->seqbase.first; seq_child; seq_child = seq_child->next) {
-                       seq_translate(evil_scene, seq_child, delta);
+                       BKE_sequence_translate(evil_scene, seq_child, delta);
                }
        }
 
-       calc_sequence_disp(evil_scene, seq);
+       BKE_sequence_calc_disp(evil_scene, seq);
 }
 
-void seq_sound_init(Scene *scene, Sequence *seq)
+void BKE_sequence_sound_init(Scene *scene, Sequence *seq)
 {
        if (seq->type == SEQ_TYPE_META) {
                Sequence *seq_child;
                for (seq_child = seq->seqbase.first; seq_child; seq_child = seq_child->next) {
-                       seq_sound_init(scene, seq_child);
+                       BKE_sequence_sound_init(scene, seq_child);
                }
        }
        else {
@@ -3441,7 +3164,7 @@ void seq_sound_init(Scene *scene, Sequence *seq)
        }
 }
 
-Sequence *seq_foreground_frame_get(Scene *scene, int frame)
+Sequence *BKE_sequencer_foreground_frame_get(Scene *scene, int frame)
 {
        Editing *ed = BKE_sequencer_editing_get(scene, FALSE);
        Sequence *seq, *best_seq = NULL;
@@ -3464,17 +3187,17 @@ Sequence *seq_foreground_frame_get(Scene *scene, int frame)
 }
 
 /* return 0 if there werent enough space */
-int shuffle_seq(ListBase *seqbasep, Sequence *test, Scene *evil_scene)
+int BKE_sequence_base_shuffle(ListBase *seqbasep, Sequence *test, Scene *evil_scene)
 {
        int orig_machine = test->machine;
        test->machine++;
-       calc_sequence(evil_scene, test);
-       while (seq_test_overlap(seqbasep, test) ) {
+       BKE_sequence_calc(evil_scene, test);
+       while (BKE_sequence_test_overlap(seqbasep, test) ) {
                if (test->machine >= MAXSEQ) {
                        break;
                }
                test->machine++;
-               calc_sequence(evil_scene, test); // XXX - I don't think this is needed since were only moving vertically, Campbell.
+               BKE_sequence_calc(evil_scene, test); // XXX - I don't think this is needed since were only moving vertically, Campbell.
        }
 
        
@@ -3492,9 +3215,9 @@ int shuffle_seq(ListBase *seqbasep, Sequence *test, Scene *evil_scene)
 
                test->machine = orig_machine;
                new_frame = new_frame + (test->start - test->startdisp); /* adjust by the startdisp */
-               seq_translate(evil_scene, test, new_frame - test->start);
+               BKE_sequence_translate(evil_scene, test, new_frame - test->start);
 
-               calc_sequence(evil_scene, test);
+               BKE_sequence_calc(evil_scene, test);
                return 0;
        }
        else {
@@ -3543,13 +3266,13 @@ static int shuffle_seq_time_offset(Scene *scene, ListBase *seqbasep, char dir)
 
        for (seq = seqbasep->first; seq; seq = seq->next) {
                if (seq->tmp)
-                       calc_sequence_disp(scene, seq);  /* corrects dummy startdisp/enddisp values */
+                       BKE_sequence_calc_disp(scene, seq);  /* corrects dummy startdisp/enddisp values */
        }
 
        return tot_ofs;
 }
 
-int shuffle_seq_time(ListBase *seqbasep, Scene *evil_scene)
+int BKE_sequence_base_shuffle_time(ListBase *seqbasep, Scene *evil_scene)
 {
        /* note: seq->tmp is used to tag strips to move */
 
@@ -3562,7 +3285,7 @@ int shuffle_seq_time(ListBase *seqbasep, Scene *evil_scene)
        if (offset) {
                for (seq = seqbasep->first; seq; seq = seq->next) {
                        if (seq->tmp) {
-                               seq_translate(evil_scene, seq, offset);
+                               BKE_sequence_translate(evil_scene, seq, offset);
                                seq->flag &= ~SEQ_OVERLAP;
                        }
                }
@@ -3571,7 +3294,7 @@ int shuffle_seq_time(ListBase *seqbasep, Scene *evil_scene)
        return offset ? 0 : 1;
 }
 
-void seq_update_sound_bounds_all(Scene *scene)
+void BKE_sequencer_update_sound_bounds_all(Scene *scene)
 {
        Editing *ed = scene->ed;
 
@@ -3583,13 +3306,13 @@ void seq_update_sound_bounds_all(Scene *scene)
                                seq_update_sound_bounds_recursive(scene, seq);
                        }
                        else if (ELEM(seq->type, SEQ_TYPE_SOUND_RAM, SEQ_TYPE_SCENE)) {
-                               seq_update_sound_bounds(scene, seq);
+                               BKE_sequencer_update_sound_bounds(scene, seq);
                        }
                }
        }
 }
 
-void seq_update_sound_bounds(Scene *scene, Sequence *seq)
+void BKE_sequencer_update_sound_bounds(Scene *scene, Sequence *seq)
 {
        sound_move_scene_sound_defaults(scene, seq);
        /* mute is set in seq_update_muting_recursive */
@@ -3621,7 +3344,7 @@ static void seq_update_muting_recursive(ListBase *seqbasep, Sequence *metaseq, i
        }
 }
 
-void seq_update_muting(Editing *ed)
+void BKE_sequencer_update_muting(Editing *ed)
 {
        if (ed) {
                /* mute all sounds up to current metastack list */
@@ -3650,7 +3373,7 @@ static void seq_update_sound_recursive(Scene *scene, ListBase *seqbasep, bSound
        }
 }
 
-void seq_update_sound(struct Scene *scene, struct bSound *sound)
+void BKE_sequencer_update_sound(Scene *scene, bSound *sound)
 {
        if (scene->ed) {
                seq_update_sound_recursive(scene, &scene->ed->seqbase, sound);
@@ -3658,7 +3381,7 @@ void seq_update_sound(struct Scene *scene, struct bSound *sound)
 }
 
 /* in cases where we done know the sequence's listbase */
-ListBase *seq_seqbase(ListBase *seqbase, Sequence *seq)
+ListBase *BKE_sequence_seqbase(ListBase *seqbase, Sequence *seq)
 {
        Sequence *iseq;
        ListBase *lb = NULL;
@@ -3667,7 +3390,7 @@ ListBase *seq_seqbase(ListBase *seqbase, Sequence *seq)
                if (seq == iseq) {
                        return seqbase;
                }
-               else if (iseq->seqbase.first && (lb = seq_seqbase(&iseq->seqbase, seq))) {
+               else if (iseq->seqbase.first && (lb = BKE_sequence_seqbase(&iseq->seqbase, seq))) {
                        return lb;
                }
        }
@@ -3675,7 +3398,7 @@ ListBase *seq_seqbase(ListBase *seqbase, Sequence *seq)
        return NULL;
 }
 
-Sequence *seq_metastrip(ListBase *seqbase, Sequence *meta, Sequence *seq)
+Sequence *BKE_sequence_metastrip(ListBase *seqbase, Sequence *meta, Sequence *seq)
 {
        Sequence *iseq;
 
@@ -3686,7 +3409,7 @@ Sequence *seq_metastrip(ListBase *seqbase, Sequence *meta, Sequence *seq)
                        return meta;
                }
                else if (iseq->seqbase.first &&
-                        (rval = seq_metastrip(&iseq->seqbase, iseq, seq)))
+                        (rval = BKE_sequence_metastrip(&iseq->seqbase, iseq, seq)))
                {
                        return rval;
                }
@@ -3695,7 +3418,7 @@ Sequence *seq_metastrip(ListBase *seqbase, Sequence *meta, Sequence *seq)
        return NULL;
 }
 
-int seq_swap(Sequence *seq_a, Sequence *seq_b, const char **error_str)
+int BKE_sequence_swap(Sequence *seq_a, Sequence *seq_b, const char **error_str)
 {
        char name[sizeof(seq_a->name)];
 
@@ -3718,7 +3441,7 @@ int seq_swap(Sequence *seq_a, Sequence *seq_b, const char **error_str)
                }
 
                if ((seq_a->type & SEQ_TYPE_EFFECT) && (seq_b->type & SEQ_TYPE_EFFECT)) {
-                       if (get_sequence_effect_num_inputs(seq_a->type) != get_sequence_effect_num_inputs(seq_b->type)) {
+                       if (BKE_sequence_effect_get_num_inputs(seq_a->type) != BKE_sequence_effect_get_num_inputs(seq_b->type)) {
                                *error_str = "Strips must have the same number of inputs";
                                return 0;
                        }
@@ -3752,7 +3475,7 @@ int seq_swap(Sequence *seq_a, Sequence *seq_b, const char **error_str)
 }
 
 /* XXX - hackish function needed for transforming strips! TODO - have some better solution */
-void seq_offset_animdata(Scene *scene, Sequence *seq, int ofs)
+void BKE_sequencer_offset_animdata(Scene *scene, Sequence *seq, int ofs)
 {
        char str[SEQ_NAME_MAXSTR + 3];
        FCurve *fcu;
@@ -3775,7 +3498,7 @@ void seq_offset_animdata(Scene *scene, Sequence *seq, int ofs)
        }
 }
 
-void seq_dupe_animdata(Scene *scene, const char *name_src, const char *name_dst)
+void BKE_sequencer_dupe_animdata(Scene *scene, const char *name_src, const char *name_dst)
 {
        char str_from[SEQ_NAME_MAXSTR + 3];
        FCurve *fcu;
@@ -3832,8 +3555,7 @@ static void seq_free_animdata(Scene *scene, Sequence *seq)
        }
 }
 
-
-Sequence *get_seq_by_name(ListBase *seqbase, const char *name, int recursive)
+Sequence *BKE_sequwnce_get_by_name(ListBase *seqbase, const char *name, int recursive)
 {
        Sequence *iseq = NULL;
        Sequence *rseq = NULL;
@@ -3841,7 +3563,7 @@ Sequence *get_seq_by_name(ListBase *seqbase, const char *name, int recursive)
        for (iseq = seqbase->first; iseq; iseq = iseq->next) {
                if (strcmp(name, iseq->name + 2) == 0)
                        return iseq;
-               else if (recursive && (iseq->seqbase.first) && (rseq = get_seq_by_name(&iseq->seqbase, name, 1))) {
+               else if (recursive && (iseq->seqbase.first) && (rseq = BKE_sequwnce_get_by_name(&iseq->seqbase, name, 1))) {
                        return rseq;
                }
        }
@@ -3853,14 +3575,19 @@ Sequence *get_seq_by_name(ListBase *seqbase, const char *name, int recursive)
 Sequence *BKE_sequencer_active_get(Scene *scene)
 {
        Editing *ed = BKE_sequencer_editing_get(scene, FALSE);
-       if (ed == NULL) return NULL;
+
+       if (ed == NULL)
+               return NULL;
+
        return ed->act_seq;
 }
 
 void BKE_sequencer_active_set(Scene *scene, Sequence *seq)
 {
        Editing *ed = BKE_sequencer_editing_get(scene, FALSE);
-       if (ed == NULL) return;
+
+       if (ed == NULL)
+               return;
 
        ed->act_seq = seq;
 }
@@ -3908,11 +3635,11 @@ Mask *BKE_sequencer_mask_get(Scene *scene)
 
 /* api like funcs for adding */
 
-void seq_load_apply(Scene *scene, Sequence *seq, SeqLoadInfo *seq_load)
+static void seq_load_apply(Scene *scene, Sequence *seq, SeqLoadInfo *seq_load)
 {
        if (seq) {
                BLI_strncpy(seq->name + 2, seq_load->name, sizeof(seq->name) - 2);
-               seqbase_unique_name_recursive(&scene->ed->seqbase, seq);
+               BKE_seqence_base_unique_name_recursive(&scene->ed->seqbase, seq);
 
                if (seq_load->flag & SEQ_LOAD_FRAME_ADVANCE) {
                        seq_load->start_frame += (seq->enddisp - seq->startdisp);
@@ -3935,7 +3662,7 @@ void seq_load_apply(Scene *scene, Sequence *seq, SeqLoadInfo *seq_load)
        }
 }
 
-Sequence *alloc_sequence(ListBase *lb, int cfra, int machine)
+Sequence *BKE_sequence_alloc(ListBase *lb, int cfra, int machine)
 {
        Sequence *seq;
 
@@ -3959,13 +3686,13 @@ Sequence *alloc_sequence(ListBase *lb, int cfra, int machine)
 }
 
 /* NOTE: this function doesn't fill in image names */
-Sequence *sequencer_add_image_strip(bContext *C, ListBase *seqbasep, SeqLoadInfo *seq_load)
+Sequence *BKE_sequencer_add_image_strip(bContext *C, ListBase *seqbasep, SeqLoadInfo *seq_load)
 {
        Scene *scene = CTX_data_scene(C); /* only for active seq */
        Sequence *seq;
        Strip *strip;
 
-       seq = alloc_sequence(seqbasep, seq_load->start_frame, seq_load->channel);
+       seq = BKE_sequence_alloc(seqbasep, seq_load->start_frame, seq_load->channel);
        seq->type = SEQ_TYPE_IMAGE;
        seq->blend_mode = SEQ_TYPE_CROSS; /* so alpha adjustment fade to the strip below */
        
@@ -3983,7 +3710,7 @@ Sequence *sequencer_add_image_strip(bContext *C, ListBase *seqbasep, SeqLoadInfo
 }
 
 #ifdef WITH_AUDASPACE
-Sequence *sequencer_add_sound_strip(bContext *C, ListBase *seqbasep, SeqLoadInfo *seq_load)
+Sequence *BKE_sequencer_add_sound_strip(bContext *C, ListBase *seqbasep, SeqLoadInfo *seq_load)
 {
        Main *bmain = CTX_data_main(C);
        Scene *scene = CTX_data_scene(C); /* only for sound */
@@ -3999,8 +3726,11 @@ Sequence *sequencer_add_sound_strip(bContext *C, ListBase *seqbasep, SeqLoadInfo
        sound = sound_new_file(bmain, seq_load->path); /* handles relative paths */
 
        if (sound == NULL || sound->playback_handle == NULL) {
-               //if (op)
-               //      BKE_report(op->reports, RPT_ERROR, "Unsupported audio format");
+               /*
+                if (op)
+                       BKE_report(op->reports, RPT_ERROR, "Unsupported audio format");
+               */
+
                return NULL;
        }
 
@@ -4008,17 +3738,19 @@ Sequence *sequencer_add_sound_strip(bContext *C, ListBase *seqbasep, SeqLoadInfo
 
        if (info.specs.channels == AUD_CHANNELS_INVALID) {
                sound_delete(bmain, sound);
-               //if (op)
-               //      BKE_report(op->reports, RPT_ERROR, "Unsupported audio format");
+               /*
+               if (op)
+                       BKE_report(op->reports, RPT_ERROR, "Unsupported audio format");
+               */
                return NULL;
        }
 
-       seq = alloc_sequence(seqbasep, seq_load->start_frame, seq_load->channel);
+       seq = BKE_sequence_alloc(seqbasep, seq_load->start_frame, seq_load->channel);
 
        seq->type = SEQ_TYPE_SOUND_RAM;
        seq->sound = sound;
        BLI_strncpy(seq->name + 2, "Sound", SEQ_NAME_MAXSTR - 2);
-       seqbase_unique_name_recursive(&scene->ed->seqbase, seq);
+       BKE_seqence_base_unique_name_recursive(&scene->ed->seqbase, seq);
 
        /* basic defaults */
        seq->strip = strip = MEM_callocN(sizeof(Strip), "strip");
@@ -4032,7 +3764,7 @@ Sequence *sequencer_add_sound_strip(bContext *C, ListBase *seqbasep, SeqLoadInfo
 
        seq->scene_sound = sound_add_scene_sound(scene, seq, seq_load->start_frame, seq_load->start_frame + seq->len, 0);
 
-       calc_sequence_disp(scene, seq);
+       BKE_sequence_calc_disp(scene, seq);
 
        /* last active name */
        BLI_strncpy(ed->act_sounddir, strip->dir, FILE_MAXDIR);
@@ -4044,14 +3776,14 @@ Sequence *sequencer_add_sound_strip(bContext *C, ListBase *seqbasep, SeqLoadInfo
 #else // WITH_AUDASPACE
 Sequence *sequencer_add_sound_strip(bContext *C, ListBase *seqbasep, SeqLoadInfo *seq_load)
 {
-       (void)C;
-       (void)seqbasep;
-       (void)seq_load;
+       (void) C;
+       (void) seqbasep;
+       (void) seq_load;
        return NULL;
 }
 #endif // WITH_AUDASPACE
 
-Sequence *sequencer_add_movie_strip(bContext *C, ListBase *seqbasep, SeqLoadInfo *seq_load)
+Sequence *BKE_sequencer_add_movie_strip(bContext *C, ListBase *seqbasep, SeqLoadInfo *seq_load)
 {
        Scene *scene = CTX_data_scene(C); /* only for sound */
        char path[sizeof(seq_load->path)];
@@ -4070,14 +3802,14 @@ Sequence *sequencer_add_movie_strip(bContext *C, ListBase *seqbasep, SeqLoadInfo
        if (an == NULL)
                return NULL;
 
-       seq = alloc_sequence(seqbasep, seq_load->start_frame, seq_load->channel);
+       seq = BKE_sequence_alloc(seqbasep, seq_load->start_frame, seq_load->channel);
        seq->type = SEQ_TYPE_MOVIE;
        seq->blend_mode = SEQ_TYPE_CROSS; /* so alpha adjustment fade to the strip below */
 
        seq->anim = an;
        seq->anim_preseek = IMB_anim_get_preseek(an);
        BLI_strncpy(seq->name + 2, "Movie", SEQ_NAME_MAXSTR - 2);
-       seqbase_unique_name_recursive(&scene->ed->seqbase, seq);
+       BKE_seqence_base_unique_name_recursive(&scene->ed->seqbase, seq);
 
        /* basic defaults */
        seq->strip = strip = MEM_callocN(sizeof(Strip), "strip");
@@ -4089,14 +3821,14 @@ Sequence *sequencer_add_movie_strip(bContext *C, ListBase *seqbasep, SeqLoadInfo
 
        BLI_split_dirfile(seq_load->path, strip->dir, se->name, sizeof(strip->dir), sizeof(se->name));
 
-       calc_sequence_disp(scene, seq);
+       BKE_sequence_calc_disp(scene, seq);
 
 
        if (seq_load->flag & SEQ_LOAD_MOVIE_SOUND) {
                int start_frame_back = seq_load->start_frame;
                seq_load->channel++;
 
-               sequencer_add_sound_strip(C, seqbasep, seq_load);
+               BKE_sequencer_add_sound_strip(C, seqbasep, seq_load);
 
                seq_load->start_frame = start_frame_back;
                seq_load->channel--;
@@ -4111,8 +3843,7 @@ Sequence *sequencer_add_movie_strip(bContext *C, ListBase *seqbasep, SeqLoadInfo
        return seq;
 }
 
-
-static Sequence *seq_dupli(struct Scene *scene, struct Scene *scene_to, Sequence *seq, int dupe_flag)
+static Sequence *seq_dupli(Scene *scene, Scene *scene_to, Sequence *seq, int dupe_flag)
 {
        Scene *sce_audio = scene_to ? scene_to : scene;
        Sequence *seqn = MEM_dupallocN(seq);
@@ -4120,7 +3851,7 @@ static Sequence *seq_dupli(struct Scene *scene, struct Scene *scene_to, Sequence
        seq->tmp = seqn;
        seqn->strip = MEM_dupallocN(seq->strip);
 
-       // XXX: add F-Curve duplication stuff?
+       /* XXX: add F-Curve duplication stuff? */
 
        if (seq->strip->crop) {
                seqn->strip->crop = MEM_dupallocN(seq->strip->crop);
@@ -4175,7 +3906,7 @@ static Sequence *seq_dupli(struct Scene *scene, struct Scene *scene_to, Sequence
 
                if (seq->type & SEQ_TYPE_EFFECT) {
                        struct SeqEffectHandle sh;
-                       sh = get_sequence_effect(seq);
+                       sh = BKE_sequence_get_effect(seq);
                        if (sh.copy)
                                sh.copy(seq, seqn);
                }
@@ -4184,27 +3915,25 @@ static Sequence *seq_dupli(struct Scene *scene, struct Scene *scene_to, Sequence
 
        }
        else {
-               fprintf(stderr, "Aiiiiekkk! sequence type not "
-                       "handled in duplicate!\nExpect a crash"
-                       " now...\n");
+               fprintf(stderr, "Aiiiiekkk! sequence type not handled in duplicate!\nExpect a crash now...\n");
        }
 
        if (dupe_flag & SEQ_DUPE_UNIQUE_NAME)
-               seqbase_unique_name_recursive(&scene->ed->seqbase, seqn);
+               BKE_seqence_base_unique_name_recursive(&scene->ed->seqbase, seqn);
 
        if (dupe_flag & SEQ_DUPE_ANIM)
-               seq_dupe_animdata(scene, seq->name + 2, seqn->name + 2);
+               BKE_sequencer_dupe_animdata(scene, seq->name + 2, seqn->name + 2);
 
        return seqn;
 }
 
-Sequence *seq_dupli_recursive(struct Scene *scene, struct Scene *scene_to, Sequence *seq, int dupe_flag)
+Sequence *BKE_sequence_dupli_recursive(Scene *scene, Scene *scene_to, Sequence *seq, int dupe_flag)
 {
        Sequence *seqn = seq_dupli(scene, scene_to, seq, dupe_flag);
        if (seq->type == SEQ_TYPE_META) {
                Sequence *s;
                for (s = seq->seqbase.first; s; s = s->next) {
-                       Sequence *n = seq_dupli_recursive(scene, scene_to, s, dupe_flag);
+                       Sequence *n = BKE_sequence_dupli_recursive(scene, scene_to, s, dupe_flag);
                        if (n) {
                                BLI_addtail(&seqn->seqbase, n);
                        }
@@ -4213,7 +3942,7 @@ Sequence *seq_dupli_recursive(struct Scene *scene, struct Scene *scene_to, Seque
        return seqn;
 }
 
-void seqbase_dupli_recursive(Scene *scene, Scene *scene_to, ListBase *nseqbase, ListBase *seqbase, int dupe_flag)
+void BKE_sequence_base_dupli_recursive(Scene *scene, Scene *scene_to, ListBase *nseqbase, ListBase *seqbase, int dupe_flag)
 {
        Sequence *seq;
        Sequence *seqn = NULL;
@@ -4231,7 +3960,7 @@ void seqbase_dupli_recursive(Scene *scene, Scene *scene_to, ListBase *nseqbase,
 
                                BLI_addtail(nseqbase, seqn);
                                if (seq->type == SEQ_TYPE_META)
-                                       seqbase_dupli_recursive(scene, scene_to, &seqn->seqbase, &seq->seqbase, dupe_flag);
+                                       BKE_sequence_base_dupli_recursive(scene, scene_to, &seqn->seqbase, &seq->seqbase, dupe_flag);
 
                                if (dupe_flag & SEQ_DUPE_CONTEXT) {
                                        if (seq == last_seq) {
index 28fb75db41c46efdaecd9c5ea59082e329b1cf13..14360297ec052c8ef317959c48818160f1d30076 100644 (file)
@@ -524,7 +524,7 @@ void sound_update_sequencer(struct Main *main, bSound *sound)
        struct Scene *scene;
 
        for (scene = main->scene.first; scene; scene = scene->id.next) {
-               seq_update_sound(scene, sound);
+               BKE_sequencer_update_sound(scene, sound);
        }
 }
 
index 73494d118d4e141bebb1614343de40bd14b707d8..93a3b17369a6532ded55e10218359e4dc0478740 100644 (file)
@@ -4874,8 +4874,8 @@ static void lib_link_scene(FileData *fd, Main *main)
                        (void)marker;
 #endif
                        
-                       seq_update_muting(sce->ed);
-                       seq_update_sound_bounds_all(sce);
+                       BKE_sequencer_update_muting(sce->ed);
+                       BKE_sequencer_update_sound_bounds_all(sce);
                        
                        if (sce->nodetree) {
                                lib_link_ntree(fd, &sce->id, sce->nodetree);
@@ -5450,7 +5450,7 @@ static int lib_link_seq_clipboard_cb(Sequence *seq, void *arg_pt)
 static void lib_link_clipboard_restore(Main *newmain)
 {
        /* update IDs stored in sequencer clipboard */
-       seqbase_recursive_apply(&seqbase_clipboard, lib_link_seq_clipboard_cb, newmain);
+       BKE_sequencer_base_recursive_apply(&seqbase_clipboard, lib_link_seq_clipboard_cb, newmain);
 }
 
 /* called from kernel/blender.c */
index ca071e0cc2545e0f147b8d7c9405747393616268..d551caea425766f50df09a9286eaf9321b535706 100644 (file)
@@ -653,7 +653,7 @@ static void do_versions_seq_unique_name_all_strips(Scene * sce, ListBase *seqbas
        Sequence * seq = seqbasep->first;
 
        while (seq) {
-               seqbase_unique_name_recursive(&sce->ed->seqbase, seq);
+               BKE_seqence_base_unique_name_recursive(&sce->ed->seqbase, seq);
                if (seq->seqbase.first) {
                        do_versions_seq_unique_name_all_strips(sce, &seq->seqbase);
                }
index 7354c4fcd65689e872b0e2f19f8960f4311ebc56..c2bd899752548603e3ce90d7d58367fd9e76bf2a 100644 (file)
@@ -73,11 +73,14 @@ void DefocusNode::convertToOperations(ExecutionSystem *graph, CompositorContext
                this->getInputSocket(1)->relinkConnections(converter->getInputSocket(0), 1, graph);
                graph->addOperation(converter);
                
-               FastGaussianBlurValueOperation * blur = new FastGaussianBlurValueOperation();
+               FastGaussianBlurValueOperation *blur = new FastGaussianBlurValueOperation();
                addLink(graph, converter->getOutputSocket(0), blur->getInputSocket(0));
                graph->addOperation(blur);
                radiusOperation = blur;
                converter->setPostBlur(blur);
+
+               /* maintain close pixels so far Z values don't bleed into the foreground */
+               blur->setOverlay(FAST_GAUSS_OVERLAY_MIN);
        }
        
        BokehImageOperation *bokeh = new BokehImageOperation();
index e3f95eac3b4f1c150744e64189313f0cd1b4f338..e005232ec008ca33d54e363ae74c10204716ca47 100644 (file)
@@ -53,9 +53,11 @@ float ConvertDepthToRadiusOperation::determineFocalDistance()
                        normalize_m4(obmat);
                        invert_m4_m4(imat, obmat);
                        mult_m4_m4m4(mat, imat, camera->dof_ob->obmat);
-                       return (float)fabs(mat[3][2]);
+                       return fabsf(mat[3][2]);
+               }
+               else {
+                       return camera->YF_dofdist;
                }
-               return camera->YF_dofdist;
        }
 }
 
@@ -71,7 +73,7 @@ void ConvertDepthToRadiusOperation::initExecution()
        this->m_dof_sp = (float)minsz / (16.f / this->m_cam_lens);    // <- == aspect * MIN2(img->x, img->y) / tan(0.5f * fov);
        
        if (this->m_blurPostOperation) {
-               m_blurPostOperation->setSigma(m_aperture * 128.0f);
+               m_blurPostOperation->setSigma(min(m_aperture * 128.0f, this->m_maxRadius));
        }
 }
 
index 7ef363f5c4a6b7142c68ea59176f44f1a08ea24b..a7b5b5de6b5a614baa86b93d9fb2c54a0aaebf0f 100644 (file)
@@ -277,6 +277,28 @@ void *FastGaussianBlurValueOperation::initializeTileData(rcti *rect)
                MemoryBuffer *newBuf = (MemoryBuffer *)this->m_inputprogram->initializeTileData(rect);
                MemoryBuffer *copy = newBuf->duplicate();
                FastGaussianBlurOperation::IIR_gauss(copy, this->m_sigma, 0, 3);
+
+               if (this->m_overlay == FAST_GAUSS_OVERLAY_MIN) {
+                       float *src = newBuf->getBuffer();
+                       float *dst = copy->getBuffer();
+                       for (int i = copy->getWidth() * copy->getHeight() * COM_NUMBER_OF_CHANNELS; i != 0; i--, src++, dst++) {
+                               if (*src < *dst) {
+                                       *dst = *src;
+                               }
+                       }
+               }
+               else if (this->m_overlay == FAST_GAUSS_OVERLAY_MAX) {
+                       float *src = newBuf->getBuffer();
+                       float *dst = copy->getBuffer();
+                       for (int i = copy->getWidth() * copy->getHeight() * COM_NUMBER_OF_CHANNELS; i != 0; i--, src++, dst++) {
+                               if (*src > *dst) {
+                                       *dst = *src;
+                               }
+                       }
+               }
+
+//             newBuf->
+
                this->m_iirgaus = copy;
        }
        unlockMutex();
index 4560e1b25e38eb019b1d1e6ca3a3c66349ee3bf2..32dc428c21c3df76fa2dd948ffcaf5b7020190fd 100644 (file)
@@ -42,11 +42,23 @@ public:
        void initExecution();
 };
 
+enum {
+       FAST_GAUSS_OVERLAY_MIN  = -1,
+       FAST_GAUSS_OVERLAY_NONE =  0,
+       FAST_GAUSS_OVERLAY_MAX  =  1
+};
+
 class FastGaussianBlurValueOperation : public NodeOperation {
 private:
        float m_sigma;
        MemoryBuffer *m_iirgaus;
        SocketReader *m_inputprogram;
+
+       /**
+        * -1: re-mix with darker
+        *  0: do nothing
+        *  1 re-mix with lighter */
+       int m_overlay;
 public:
        FastGaussianBlurValueOperation();
        bool determineDependingAreaOfInterest(rcti *input, ReadBufferOperation *readOperation, rcti *output);
@@ -56,6 +68,9 @@ public:
        void deinitExecution();
        void initExecution();
        void setSigma(float sigma) { this->m_sigma = sigma; }
+
+       /* used for DOF blurring ZBuffer */
+       void setOverlay(int overlay) { this->m_overlay = overlay; }
 };
 
 #endif
index 9cd2b29afa6d53b44f44f1153f169488913c2459..c10579d2d3086e77417c7a665ddf7074203f642d 100644 (file)
@@ -287,10 +287,10 @@ void ANIM_deselect_anim_channels(bAnimContext *ac, void *data, short datatype, s
                                {
                                        Base *base = (Base *)ale->data;
                                        Object *ob = base->object;
-                               
+                                       
                                        ACHANNEL_SET_FLAG(base, sel, SELECT);
                                        ACHANNEL_SET_FLAG(ob, sel, SELECT);
-                               
+                                       
                                        if (ob->adt) {
                                                ACHANNEL_SET_FLAG(ob, sel, ADT_UI_SELECTED);
                                        }
@@ -360,11 +360,11 @@ void ANIM_deselect_anim_channels(bAnimContext *ac, void *data, short datatype, s
                                ACHANNEL_SET_FLAG(gpl, sel, GP_LAYER_SELECT);
                        }
                        break;
-
+                       
                        case ANIMTYPE_MASKLAYER:
                        {
                                MaskLayer *masklay = (MaskLayer *)ale->data;
-
+                               
                                ACHANNEL_SET_FLAG(masklay, sel, MASK_LAYERFLAG_SELECT);
                        }
                        break;
@@ -2152,7 +2152,7 @@ static int mouse_anim_channels(bAnimContext *ac, float UNUSED(x), int channel_in
                        }
                        else {
                                Base *b;
-
+                               
                                /* deselect all */
                                /* TODO: should this deselect all other types of channels too? */
                                for (b = sce->base.first; b; b = b->next) {
@@ -2242,6 +2242,8 @@ static int mouse_anim_channels(bAnimContext *ac, float UNUSED(x), int channel_in
                        /* if group is selected now, make group the 'active' one in the visible list */
                        if (agrp->flag & AGRP_SELECTED)
                                ANIM_set_active_channel(ac, ac->data, ac->datatype, filter, agrp, ANIMTYPE_GROUP);
+                       else
+                               ANIM_set_active_channel(ac, ac->data, ac->datatype, filter, NULL, ANIMTYPE_GROUP);
                                
                        notifierFlags |= (ND_ANIMCHAN | NA_SELECTED);
                }
@@ -2319,19 +2321,19 @@ static int mouse_anim_channels(bAnimContext *ac, float UNUSED(x), int channel_in
                case ANIMTYPE_MASKDATABLOCK:
                {
                        Mask *mask = (Mask *)ale->data;
-
+                       
                        /* toggle expand
                         *      - although the triangle widget already allows this, the whole channel can also be used for this purpose
                         */
                        mask->flag ^= MASK_ANIMF_EXPAND;
-
+                       
                        notifierFlags |= (ND_ANIMCHAN | NA_EDITED);
                }
                break;
                case ANIMTYPE_MASKLAYER:
                {
                        MaskLayer *masklay = (MaskLayer *)ale->data;
-
+                       
                        /* select/deselect */
                        if (selectmode == SELECT_INVERT) {
                                /* invert selection status of this layer only */
@@ -2342,7 +2344,7 @@ static int mouse_anim_channels(bAnimContext *ac, float UNUSED(x), int channel_in
                                ANIM_deselect_anim_channels(ac, ac->data, ac->datatype, 0, ACHANNEL_SETFLAG_CLEAR);
                                masklay->flag |= MASK_LAYERFLAG_SELECT;
                        }
-
+                       
                        notifierFlags |= (ND_ANIMCHAN | NA_EDITED);
                }
                break;
@@ -2407,6 +2409,8 @@ static int animchannels_mouseclick_invoke(bContext *C, wmOperator *op, wmEvent *
  
 static void ANIM_OT_channels_click(wmOperatorType *ot)
 {
+       PropertyRNA *prop;
+       
        /* identifiers */
        ot->name = "Mouse Click on Channels";
        ot->idname = "ANIM_OT_channels_click";
@@ -2419,9 +2423,13 @@ static void ANIM_OT_channels_click(wmOperatorType *ot)
        /* flags */
        ot->flag = OPTYPE_REGISTER | OPTYPE_UNDO;
        
-       /* id-props */
-       RNA_def_boolean(ot->srna, "extend", 0, "Extend Select", ""); // SHIFTKEY
-       RNA_def_boolean(ot->srna, "children_only", 0, "Select Children Only", ""); // CTRLKEY|SHIFTKEY
+       /* properties */
+       /* NOTE: don't save settings, otherwise, can end up with some weird behaviour (sticky extend) */
+       prop = RNA_def_boolean(ot->srna, "extend", 0, "Extend Select", ""); // SHIFTKEY
+       RNA_def_property_flag(prop, PROP_SKIP_SAVE);
+       
+       prop = RNA_def_boolean(ot->srna, "children_only", 0, "Select Children Only", ""); // CTRLKEY|SHIFTKEY
+       RNA_def_property_flag(prop, PROP_SKIP_SAVE);
 }
 
 /* ************************************************************************** */
index 50bdbd6673cbb95a188818f689c995bd157eb341..3cc3923871325a5e24d8cb618b32249716041252 100644 (file)
@@ -202,7 +202,7 @@ static void animchan_sync_fcurve(bAnimContext *UNUSED(ac), bAnimListElem *ale)
                        
                        /* get strip name, and check if this strip is selected */
                        seq_name = BLI_str_quoted_substrN(fcu->rna_path, "sequences_all[");
-                       seq = get_seq_by_name(ed->seqbasep, seq_name, FALSE);
+                       seq = BKE_sequwnce_get_by_name(ed->seqbasep, seq_name, FALSE);
                        if (seq_name) MEM_freeN(seq_name);
                        
                        /* can only add this F-Curve if it is selected */
index 07e773b1e9abdb53348ba072ff15f7e9ddd67277..b1497712aedbb3ad047c30963ccc253b0ab6151c 100644 (file)
@@ -917,7 +917,7 @@ static short skip_fcurve_selected_data(bDopeSheet *ads, FCurve *fcu, ID *owner_i
                        
                        /* get strip name, and check if this strip is selected */
                        seq_name = BLI_str_quoted_substrN(fcu->rna_path, "sequences_all[");
-                       seq = get_seq_by_name(ed->seqbasep, seq_name, FALSE);
+                       seq = BKE_sequwnce_get_by_name(ed->seqbasep, seq_name, FALSE);
                        if (seq_name) MEM_freeN(seq_name);
                        
                        /* can only add this F-Curve if it is selected */
index 28d18f6a3dd8c9946c2aeca465806967f3264e23..5d62ef768d246387c997db9bc09a7c93f58831a0 100644 (file)
@@ -217,7 +217,8 @@ void ui_but_anim_clear_keyframe(bContext *C)
        /* this operator calls uiContextActiveProperty */
        WM_operator_name_call(C, "ANIM_OT_keyframe_clear_button", WM_OP_INVOKE_DEFAULT, NULL);
 }
- void ui_but_anim_add_driver(bContext *C)
+
+void ui_but_anim_add_driver(bContext *C)
 {
        /* this operator calls uiContextActiveProperty */
        WM_operator_name_call(C, "ANIM_OT_driver_button_add", WM_OP_INVOKE_DEFAULT, NULL);
index d450cb58adf0f868d7227901b3504c7db3ec5fc9..87d2c79d28faefbebb70b8a501e19dc66304a863 100644 (file)
@@ -228,7 +228,7 @@ static int screen_render_exec(bContext *C, wmOperator *op)
         * otherwise, invalidated cache entries can make their way into
         * the output rendering. We can't put that into RE_BlenderFrame,
         * since sequence rendering can call that recursively... (peter) */
-       seq_stripelem_cache_cleanup();
+       BKE_sequencer_cache_cleanup();
 
        RE_SetReports(re, op->reports);
 
@@ -530,7 +530,7 @@ static int screen_render_invoke(bContext *C, wmOperator *op, wmEvent *event)
         * otherwise, invalidated cache entries can make their way into
         * the output rendering. We can't put that into RE_BlenderFrame,
         * since sequence rendering can call that recursively... (peter) */
-       seq_stripelem_cache_cleanup();
+       BKE_sequencer_cache_cleanup();
 
        /* get editmode results */
        ED_object_exit_editmode(C, 0);  /* 0 = does not exit editmode */
index 12f1e09f5bef86ce49ab7f46b882ce80dccad5b8..d705799b1d83b9d76d6d80ec058957f829c5aaf5 100644 (file)
@@ -138,9 +138,9 @@ static void screen_opengl_render_apply(OGLRender *oglrender)
                SeqRenderData context;
                int chanshown = oglrender->sseq ? oglrender->sseq->chanshown : 0;
 
-               context = seq_new_render_data(oglrender->bmain, scene, oglrender->sizex, oglrender->sizey, 100.0f);
+               context = BKE_sequencer_new_render_data(oglrender->bmain, scene, oglrender->sizex, oglrender->sizey, 100.0f);
 
-               ibuf = give_ibuf_seq(context, CFRA, chanshown);
+               ibuf = BKE_sequencer_give_ibuf(context, CFRA, chanshown);
 
                if (ibuf) {
                        BLI_assert((oglrender->sizex == ibuf->x) && (oglrender->sizey == ibuf->y));
index b42c64063622ddaab0d09793dc6a1d589d096e77..4da283733b07ed73606cab395e639edbc177b9e7 100644 (file)
@@ -184,6 +184,7 @@ void ACTION_OT_select_all_toggle(wmOperatorType *ot)
        
        /* props */
        ot->prop = RNA_def_boolean(ot->srna, "invert", 0, "Invert", "");
+       RNA_def_property_flag(ot->prop, PROP_SKIP_SAVE);
 }
 
 /* ******************** Border Select Operator **************************** */
@@ -881,6 +882,8 @@ static int actkeys_select_leftright_invoke(bContext *C, wmOperator *op, wmEvent
 
 void ACTION_OT_select_leftright(wmOperatorType *ot)
 {
+       PropertyRNA *prop;
+       
        /* identifiers */
        ot->name = "Select Left/Right";
        ot->idname = "ACTION_OT_select_leftright";
@@ -894,9 +897,12 @@ void ACTION_OT_select_leftright(wmOperatorType *ot)
        /* flags */
        ot->flag = OPTYPE_REGISTER | OPTYPE_UNDO;
        
-       /* id-props */
+       /* properties */
        ot->prop = RNA_def_enum(ot->srna, "mode", prop_actkeys_leftright_select_types, ACTKEYS_LRSEL_TEST, "Mode", "");
-       RNA_def_boolean(ot->srna, "extend", 0, "Extend Select", "");
+       RNA_def_property_flag(ot->prop, PROP_SKIP_SAVE);
+       
+       prop = RNA_def_boolean(ot->srna, "extend", 0, "Extend Select", "");
+       RNA_def_property_flag(prop, PROP_SKIP_SAVE);
 }
 
 /* ******************** Mouse-Click Select Operator *********************** */
@@ -1233,6 +1239,8 @@ static int actkeys_clickselect_invoke(bContext *C, wmOperator *op, wmEvent *even
  
 void ACTION_OT_clickselect(wmOperatorType *ot)
 {
+       PropertyRNA *prop;
+       
        /* identifiers */
        ot->name = "Mouse Select Keys";
        ot->idname = "ACTION_OT_clickselect";
@@ -1245,9 +1253,11 @@ void ACTION_OT_clickselect(wmOperatorType *ot)
        /* flags */
        ot->flag = OPTYPE_REGISTER | OPTYPE_UNDO;
        
-       /* id-props */
-       RNA_def_boolean(ot->srna, "extend", 0, "Extend Select", ""); // SHIFTKEY
-       RNA_def_boolean(ot->srna, "column", 0, "Column Select", ""); // ALTKEY
+       /* properties */
+       prop = RNA_def_boolean(ot->srna, "extend", 0, "Extend Select", ""); // SHIFTKEY
+       RNA_def_property_flag(prop, PROP_SKIP_SAVE);
+       prop = RNA_def_boolean(ot->srna, "column", 0, "Column Select", ""); // ALTKEY
+       RNA_def_property_flag(prop, PROP_SKIP_SAVE);
 }
 
 /* ************************************************************************** */
index a23cb86bb761767e10d27865e95f3a5404ef08a6..2160e2eb3a0612cdb25e8aa744392485bbffa8f2 100644 (file)
@@ -383,6 +383,9 @@ void filelist_init_icons(void)
        short x, y, k;
        ImBuf *bbuf;
        ImBuf *ibuf;
+
+       BLI_assert(G.background == FALSE);
+
 #ifdef WITH_HEADLESS
        bbuf = NULL;
 #else
@@ -408,6 +411,9 @@ void filelist_init_icons(void)
 void filelist_free_icons(void)
 {
        int i;
+
+       BLI_assert(G.background == FALSE);
+
        for (i = 0; i < SPECIAL_IMG_MAX; ++i) {
                IMB_freeImBuf(gSpecialFileImages[i]);
                gSpecialFileImages[i] = NULL;
@@ -615,7 +621,10 @@ short filelist_changed(struct FileList *filelist)
 ImBuf *filelist_getimage(struct FileList *filelist, int index)
 {
        ImBuf *ibuf = NULL;
-       int fidx = 0;   
+       int fidx = 0;
+
+       BLI_assert(G.background == FALSE);
+
        if ( (index < 0) || (index >= filelist->numfiltered) ) {
                return NULL;
        }
@@ -629,7 +638,10 @@ ImBuf *filelist_geticon(struct FileList *filelist, int index)
 {
        ImBuf *ibuf = NULL;
        struct direntry *file = NULL;
-       int fidx = 0;   
+       int fidx = 0;
+
+       BLI_assert(G.background == FALSE);
+
        if ( (index < 0) || (index >= filelist->numfiltered) ) {
                return NULL;
        }
index 95d5483b42ccb7974b799afc9f71b4739a683401..17669dfa8f9e2f41d11c11ec0f857a35cf66b629 100644 (file)
@@ -48,6 +48,7 @@
 
 #include "BKE_context.h"
 #include "BKE_screen.h"
+#include "BKE_global.h"
 
 #include "ED_space_api.h"
 #include "ED_screen.h"
@@ -624,12 +625,18 @@ void ED_file_init(void)
                fsmenu_read_bookmarks(fsmenu_get(), name);
        }
        
-       filelist_init_icons();
+       if (G.background == FALSE) {
+               filelist_init_icons();
+       }
+
        IMB_thumb_makedirs();
 }
 
 void ED_file_exit(void)
 {
        fsmenu_free(fsmenu_get());
-       filelist_free_icons();
+
+       if (G.background == FALSE) {
+               filelist_free_icons();
+       }
 }
index 52a7f9b115c4f73d7ef496f0bfda31e62c7adb41..109241ac3666d9d8035cc40bfe915f008195a822 100644 (file)
@@ -848,6 +848,8 @@ static int graphkeys_select_leftright_invoke(bContext *C, wmOperator *op, wmEven
 
 void GRAPH_OT_select_leftright(wmOperatorType *ot)
 {
+       PropertyRNA *prop;
+       
        /* identifiers */
        ot->name = "Select Left/Right";
        ot->idname = "GRAPH_OT_select_leftright";
@@ -863,7 +865,10 @@ void GRAPH_OT_select_leftright(wmOperatorType *ot)
        
        /* id-props */
        ot->prop = RNA_def_enum(ot->srna, "mode", prop_graphkeys_leftright_select_types, GRAPHKEYS_LRSEL_TEST, "Mode", "");
-       RNA_def_boolean(ot->srna, "extend", 0, "Extend Select", "");
+       RNA_def_property_flag(ot->prop, PROP_SKIP_SAVE);
+       
+       prop = RNA_def_boolean(ot->srna, "extend", 0, "Extend Select", "");
+       RNA_def_property_flag(prop, PROP_SKIP_SAVE);
 }
 
 /* ******************** Mouse-Click Select Operator *********************** */
@@ -1333,6 +1338,8 @@ static int graphkeys_clickselect_invoke(bContext *C, wmOperator *op, wmEvent *ev
  
 void GRAPH_OT_clickselect(wmOperatorType *ot)
 {
+       PropertyRNA *prop;
+       
        /* identifiers */
        ot->name = "Mouse Select Keys";
        ot->idname = "GRAPH_OT_clickselect";
@@ -1342,10 +1349,17 @@ void GRAPH_OT_clickselect(wmOperatorType *ot)
        ot->invoke = graphkeys_clickselect_invoke;
        ot->poll = graphop_visible_keyframes_poll;
        
-       /* id-props */
-       RNA_def_boolean(ot->srna, "extend", 0, "Extend Select", ""); // SHIFTKEY
-       RNA_def_boolean(ot->srna, "column", 0, "Column Select", "Select all keyframes that occur on the same frame as the one under the mouse"); // ALTKEY
-       RNA_def_boolean(ot->srna, "curves", 0, "Only Curves", "Select all the keyframes in the curve"); // CTRLKEY + ALTKEY
+       /* properties */
+       prop = RNA_def_boolean(ot->srna, "extend", 0, "Extend Select", ""); // SHIFTKEY
+       RNA_def_property_flag(prop, PROP_SKIP_SAVE);
+       
+       prop = RNA_def_boolean(ot->srna, "column", 0, "Column Select", 
+                              "Select all keyframes that occur on the same frame as the one under the mouse"); // ALTKEY
+       RNA_def_property_flag(prop, PROP_SKIP_SAVE);
+       
+       prop = RNA_def_boolean(ot->srna, "curves", 0, "Only Curves", 
+                              "Select all the keyframes in the curve"); // CTRLKEY + ALTKEY
+       RNA_def_property_flag(prop, PROP_SKIP_SAVE);
 }
 
 /* ************************************************************************** */
index af7904439284409da6c8b9f55c5219932183346d..b3a869ed57dadd947f3314589bc90c982565d959 100644 (file)
@@ -343,6 +343,8 @@ static int nlachannels_mouseclick_invoke(bContext *C, wmOperator *op, wmEvent *e
  
 void NLA_OT_channels_click(wmOperatorType *ot)
 {
+       PropertyRNA *prop;
+       
        /* identifiers */
        ot->name = "Mouse Click on NLA Channels";
        ot->idname = "NLA_OT_channels_click";
@@ -355,8 +357,9 @@ void NLA_OT_channels_click(wmOperatorType *ot)
        /* flags */
        ot->flag = OPTYPE_REGISTER | OPTYPE_UNDO;
        
-       /* id-props */
-       RNA_def_boolean(ot->srna, "extend", 0, "Extend Select", ""); // SHIFTKEY
+       /* props */
+       prop = RNA_def_boolean(ot->srna, "extend", 0, "Extend Select", ""); // SHIFTKEY
+       RNA_def_property_flag(prop, PROP_SKIP_SAVE);
 }
 
 /* *********************************************** */
index 1ba15d529e8a647fa2a8d5fc2198eecb409ff9e7..3736f83bce2e4849bbeb0bb670f8fb5c09ed9f5a 100644 (file)
@@ -198,7 +198,8 @@ void NLA_OT_select_all_toggle(wmOperatorType *ot)
        ot->flag = OPTYPE_REGISTER /*|OPTYPE_UNDO*/;
        
        /* props */
-       RNA_def_boolean(ot->srna, "invert", 0, "Invert", "");
+       ot->prop = RNA_def_boolean(ot->srna, "invert", 0, "Invert", "");
+       RNA_def_property_flag(ot->prop, PROP_SKIP_SAVE);
 }
 
 /* ******************** Border Select Operator **************************** */
@@ -483,6 +484,8 @@ static int nlaedit_select_leftright_invoke(bContext *C, wmOperator *op, wmEvent
 
 void NLA_OT_select_leftright(wmOperatorType *ot)
 {
+       PropertyRNA *prop;
+       
        /* identifiers */
        ot->name = "Select Left/Right";
        ot->idname = "NLA_OT_select_leftright";
@@ -496,9 +499,12 @@ void NLA_OT_select_leftright(wmOperatorType *ot)
        /* flags */
        ot->flag = OPTYPE_REGISTER | OPTYPE_UNDO;
        
-       /* id-props */
+       /* properties */
        ot->prop = RNA_def_enum(ot->srna, "mode", prop_nlaedit_leftright_select_types, NLAEDIT_LRSEL_TEST, "Mode", "");
-       RNA_def_boolean(ot->srna, "extend", 0, "Extend Select", "");
+       RNA_def_property_flag(ot->prop, PROP_SKIP_SAVE);
+       
+       prop = RNA_def_boolean(ot->srna, "extend", 0, "Extend Select", "");
+       RNA_def_property_flag(prop, PROP_SKIP_SAVE);
 }
 
 
@@ -645,6 +651,8 @@ static int nlaedit_clickselect_invoke(bContext *C, wmOperator *op, wmEvent *even
  
 void NLA_OT_click_select(wmOperatorType *ot)
 {
+       PropertyRNA *prop;
+       
        /* identifiers */
        ot->name = "Mouse Select";
        ot->idname = "NLA_OT_click_select";
@@ -657,8 +665,9 @@ void NLA_OT_click_select(wmOperatorType *ot)
        /* flags */
        ot->flag = OPTYPE_REGISTER | OPTYPE_UNDO;
        
-       /* id-props */
-       RNA_def_boolean(ot->srna, "extend", 0, "Extend Select", ""); // SHIFTKEY
+       /* properties */
+       prop = RNA_def_boolean(ot->srna, "extend", 0, "Extend Select", ""); // SHIFTKEY
+       RNA_def_property_flag(prop, PROP_SKIP_SAVE);
 }
 
 /* *********************************************** */
index 6c6525ed7cd2e64e4ed255dc53d0bb7af15f3e59..a1aee223c8f344c44bc045f72ea7346d111f0dc5 100644 (file)
@@ -339,8 +339,8 @@ static void node_buts_curvevec(uiLayout *layout, bContext *UNUSED(C), PointerRNA
        uiTemplateCurveMapping(layout, ptr, "mapping", 'v', 0, 0);
 }
 
-static float _sample_col[4];  /* bad bad, 2.5 will do better?... no it won't... */
 #define SAMPLE_FLT_ISNONE FLT_MAX
+static float _sample_col[4] = {SAMPLE_FLT_ISNONE};  /* bad bad, 2.5 will do better?... no it won't... */
 void ED_node_sample_set(const float col[4])
 {
        if (col) {
index 27ee600632733c34431e811d3642a05305676d12..b6bf8d77732596a721dabbbaa03eb6019a862bb7 100644 (file)
@@ -235,6 +235,9 @@ static void node_menu_add(const bContext *C, Menu *menu)
        if (!snode->nodetree)
                uiLayoutSetActive(layout, FALSE);
        
+       uiLayoutSetOperatorContext(layout, WM_OP_INVOKE_DEFAULT);
+       uiItemO(layout, "Search ...", 0, "NODE_OT_add_search");
+       
        if (ntreetype && ntreetype->foreach_nodeclass)
                ntreetype->foreach_nodeclass(scene, layout, node_menu_add_foreach_cb);
 }
index c52f4ca629a04b3c7959e5cf6edd33d3b4856cb5..7b7170d99e0864f46ea10663fac96e87cb339ff1 100644 (file)
@@ -230,7 +230,7 @@ static int sequencer_add_scene_strip_exec(bContext *C, wmOperator *op)
                return OPERATOR_CANCELLED;
        }
        
-       seq = alloc_sequence(ed->seqbasep, start_frame, channel);
+       seq = BKE_sequence_alloc(ed->seqbasep, start_frame, channel);
        seq->type = SEQ_TYPE_SCENE;
        seq->blend_mode = SEQ_TYPE_CROSS; /* so alpha adjustment fade to the strip below */
 
@@ -242,11 +242,11 @@ static int sequencer_add_scene_strip_exec(bContext *C, wmOperator *op)
        strip->us = 1;
        
        BLI_strncpy(seq->name + 2, sce_seq->id.name + 2, sizeof(seq->name) - 2);
-       seqbase_unique_name_recursive(&ed->seqbase, seq);
+       BKE_seqence_base_unique_name_recursive(&ed->seqbase, seq);
 
        seq->scene_sound = sound_scene_add_scene_sound(scene, seq, start_frame, start_frame + seq->len, 0);
 
-       calc_sequence_disp(scene, seq);
+       BKE_sequence_calc_disp(scene, seq);
        BKE_sequencer_sort(scene);
        
        if (RNA_boolean_get(op->ptr, "replace_sel")) {
@@ -256,7 +256,7 @@ static int sequencer_add_scene_strip_exec(bContext *C, wmOperator *op)
        }
 
        if (RNA_boolean_get(op->ptr, "overlap") == FALSE) {
-               if (seq_test_overlap(ed->seqbasep, seq)) shuffle_seq(ed->seqbasep, seq, scene);
+               if (BKE_sequence_test_overlap(ed->seqbasep, seq)) BKE_sequence_base_shuffle(ed->seqbasep, seq, scene);
        }
 
        WM_event_add_notifier(C, NC_SCENE | ND_SEQUENCER, scene);
@@ -329,7 +329,7 @@ static int sequencer_add_movieclip_strip_exec(bContext *C, wmOperator *op)
                return OPERATOR_CANCELLED;
        }
        
-       seq = alloc_sequence(ed->seqbasep, start_frame, channel);
+       seq = BKE_sequence_alloc(ed->seqbasep, start_frame, channel);
        seq->type = SEQ_TYPE_MOVIECLIP;
        seq->blend_mode = SEQ_TYPE_CROSS;
        seq->clip = clip;
@@ -343,9 +343,9 @@ static int sequencer_add_movieclip_strip_exec(bContext *C, wmOperator *op)
        strip->us = 1;
        
        BLI_strncpy(seq->name + 2, clip->id.name + 2, sizeof(seq->name) - 2);
-       seqbase_unique_name_recursive(&ed->seqbase, seq);
+       BKE_seqence_base_unique_name_recursive(&ed->seqbase, seq);
 
-       calc_sequence_disp(scene, seq);
+       BKE_sequence_calc_disp(scene, seq);
        BKE_sequencer_sort(scene);
        
        if (RNA_boolean_get(op->ptr, "replace_sel")) {
@@ -355,7 +355,7 @@ static int sequencer_add_movieclip_strip_exec(bContext *C, wmOperator *op)
        }
 
        if (RNA_boolean_get(op->ptr, "overlap") == FALSE) {
-               if (seq_test_overlap(ed->seqbasep, seq)) shuffle_seq(ed->seqbasep, seq, scene);
+               if (BKE_sequence_test_overlap(ed->seqbasep, seq)) BKE_sequence_base_shuffle(ed->seqbasep, seq, scene);
        }
 
        WM_event_add_notifier(C, NC_SCENE | ND_SEQUENCER, scene);
@@ -425,7 +425,7 @@ static int sequencer_add_mask_strip_exec(bContext *C, wmOperator *op)
                return OPERATOR_CANCELLED;
        }
 
-       seq = alloc_sequence(ed->seqbasep, start_frame, channel);
+       seq = BKE_sequence_alloc(ed->seqbasep, start_frame, channel);
        seq->type = SEQ_TYPE_MASK;
        seq->blend_mode = SEQ_TYPE_CROSS;
        seq->mask = mask;
@@ -439,9 +439,9 @@ static int sequencer_add_mask_strip_exec(bContext *C, wmOperator *op)
        strip->us = 1;
 
        BLI_strncpy(seq->name + 2, mask->id.name + 2, sizeof(seq->name) - 2);
-       seqbase_unique_name_recursive(&ed->seqbase, seq);
+       BKE_seqence_base_unique_name_recursive(&ed->seqbase, seq);
 
-       calc_sequence_disp(scene, seq);
+       BKE_sequence_calc_disp(scene, seq);
        BKE_sequencer_sort(scene);
 
        if (RNA_boolean_get(op->ptr, "replace_sel")) {
@@ -451,7 +451,7 @@ static int sequencer_add_mask_strip_exec(bContext *C, wmOperator *op)
        }
 
        if (RNA_boolean_get(op->ptr, "overlap") == FALSE) {
-               if (seq_test_overlap(ed->seqbasep, seq)) shuffle_seq(ed->seqbasep, seq, scene);
+               if (BKE_sequence_test_overlap(ed->seqbasep, seq)) BKE_sequence_base_shuffle(ed->seqbasep, seq, scene);
        }
 
        WM_event_add_notifier(C, NC_SCENE | ND_SEQUENCER, scene);
@@ -535,7 +535,7 @@ static int sequencer_add_generic_strip_exec(bContext *C, wmOperator *op, SeqLoad
                        seq = seq_load_func(C, ed->seqbasep, &seq_load);
                        if (seq) {
                                if (overlap == FALSE) {
-                                       if (seq_test_overlap(ed->seqbasep, seq)) shuffle_seq(ed->seqbasep, seq, scene);
+                                       if (BKE_sequence_test_overlap(ed->seqbasep, seq)) BKE_sequence_base_shuffle(ed->seqbasep, seq, scene);
                                }
                        }
                }
@@ -546,7 +546,8 @@ static int sequencer_add_generic_strip_exec(bContext *C, wmOperator *op, SeqLoad
                seq = seq_load_func(C, ed->seqbasep, &seq_load);
                if (seq) {
                        if (overlap == FALSE) {
-                               if (seq_test_overlap(ed->seqbasep, seq)) shuffle_seq(ed->seqbasep, seq, scene);
+                               if (BKE_sequence_test_overlap(ed->seqbasep, seq))
+                                       BKE_sequence_base_shuffle(ed->seqbasep, seq, scene);
                        }
                }
        }
@@ -557,7 +558,7 @@ static int sequencer_add_generic_strip_exec(bContext *C, wmOperator *op, SeqLoad
        }
 
        BKE_sequencer_sort(scene);
-       seq_update_muting(ed);
+       BKE_sequencer_update_muting(ed);
 
        WM_event_add_notifier(C, NC_SCENE | ND_SEQUENCER, scene);
 
@@ -567,7 +568,7 @@ static int sequencer_add_generic_strip_exec(bContext *C, wmOperator *op, SeqLoad
 /* add movie operator */
 static int sequencer_add_movie_strip_exec(bContext *C, wmOperator *op)
 {
-       return sequencer_add_generic_strip_exec(C, op, sequencer_add_movie_strip);
+       return sequencer_add_generic_strip_exec(C, op, BKE_sequencer_add_movie_strip);
 }
 
 
@@