Code cleanup: BKE_ prefix for public sequencer functions

8 files changed, 258 insertions, 257 deletions

diff --git a/source/blender/blenkernel/BKE_sequencer.h b/source/blender/blenkernel/BKE_sequencer.h
index 0792339e85f..0aee2b07f4a 100644
--- a/source/blender/blenkernel/BKE_sequencer.h
+++ b/source/blender/blenkernel/BKE_sequencer.h
@@ -61,25 +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 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 {
@@ -92,8 +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);
+SeqRenderData BKE_sequencer_new_render_data(struct Main *bmain, struct Scene *scene, int rectx, int recty,
+                                            int preview_render_size);
 
 /* Wipe effect */
 enum {
@@ -148,17 +152,16 @@ struct SeqEffectHandle {
 /* ********************* 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
@@ -170,35 +173,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_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);
-int evaluate_seq_frame(struct Scene *scene, int cfra);
-struct StripElem *give_stripelem(struct Sequence *seq, int cfra);
+void BKE_sequencer_free_clipboard(void);
 
-/* intern */
-void update_changed_seq_and_deps(struct Scene *scene, struct Sequence *changed_seq, int len_change, int ibuf_change);
+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);
 
-int input_have_to_preprocess(SeqRenderData context, struct Sequence *seq, float 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 *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);
+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
@@ -213,18 +216,18 @@ 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_stripelem_cache_destruct(void);
+void BKE_sequencer_stripelem_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);
 
 /* **********************************************************************
  * seqeffects.c
@@ -234,13 +237,12 @@ void seq_stripelem_cache_put(SeqRenderData context, struct Sequence *seq, float
  */
 
 /* 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
@@ -248,40 +250,41 @@ int get_sequence_effect_num_inputs(int seq_type);
  */
    
 /* for transform but also could use elsewhere */
-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_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 {
@@ -313,11 +316,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);
+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]);
diff --git a/source/blender/blenkernel/intern/blender.c b/source/blender/blenkernel/intern/blender.c
index 9e222307aa9..54ddb33e1ae 100644
--- a/source/blender/blenkernel/intern/blender.c
+++ b/source/blender/blenkernel/intern/blender.c
@@ -116,7 +116,7 @@ void free_blender(void)
 
 	BLI_callback_global_finalize();
 
-	seq_stripelem_cache_destruct();
+	BKE_sequencer_stripelem_cache_destruct();
 	IMB_moviecache_destruct();
 	
 	free_nodesystem();	
diff --git a/source/blender/blenkernel/intern/image.c b/source/blender/blenkernel/intern/image.c
index 21b335aa1e9..936ef973128 100644
--- a/source/blender/blenkernel/intern/image.c
+++ b/source/blender/blenkernel/intern/image.c
@@ -1442,7 +1442,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));
diff --git a/source/blender/blenkernel/intern/scene.c b/source/blender/blenkernel/intern/scene.c
index edc82b56d23..889792ad3f8 100644
--- a/source/blender/blenkernel/intern/scene.c
+++ b/source/blender/blenkernel/intern/scene.c
@@ -237,7 +237,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);
 		}
 	}
 
@@ -639,7 +639,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);
diff --git a/source/blender/blenkernel/intern/seqcache.c b/source/blender/blenkernel/intern/seqcache.c
index 6eb4c6734e4..99eb44d1a71 100644
--- a/source/blender/blenkernel/intern/seqcache.c
+++ b/source/blender/blenkernel/intern/seqcache.c
@@ -155,13 +155,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_stripelem_cache_destruct(void)
 {
 	if (moviecache)
 		IMB_moviecache_free(moviecache);
 }
 
-void seq_stripelem_cache_cleanup(void)
+void BKE_sequencer_stripelem_cache_cleanup(void)
 {
 	if (moviecache) {
 		IMB_moviecache_free(moviecache);
@@ -169,7 +169,7 @@ void seq_stripelem_cache_cleanup(void)
 	}
 }
 
-struct ImBuf *seq_stripelem_cache_get(
+struct ImBuf *BKE_sequencer_cache_get(
         SeqRenderData context, struct Sequence *seq,
         float cfra, seq_stripelem_ibuf_t type)
 {
@@ -188,7 +188,7 @@ struct ImBuf *seq_stripelem_cache_get(
 	return NULL;
 }
 
-void seq_stripelem_cache_put(
+void BKE_sequencer_cache_put(
         SeqRenderData context, struct Sequence *seq,
         float cfra, seq_stripelem_ibuf_t type, struct ImBuf *i)
 {
diff --git a/source/blender/blenkernel/intern/seqeffects.c b/source/blender/blenkernel/intern/seqeffects.c
index 99cb60327d6..2a0409662ce 100644
--- a/source/blender/blenkernel/intern/seqeffects.c
+++ b/source/blender/blenkernel/intern/seqeffects.c
@@ -2393,17 +2393,17 @@ static ImBuf *do_multicam(SeqRenderData context, Sequence *seq, float cfra, floa
 	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);
 	}
@@ -2435,10 +2435,10 @@ static ImBuf *do_adjustment_impl(SeqRenderData context, Sequence *seq, float cfr
 
 	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
@@ -2449,7 +2449,7 @@ static ImBuf *do_adjustment_impl(SeqRenderData context, Sequence *seq, float cfr
 	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);
@@ -2474,7 +2474,7 @@ static ImBuf *do_adjustment(SeqRenderData context, Sequence *seq, float cfra, fl
 
 	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);
 	}
@@ -2545,7 +2545,7 @@ static void store_icu_yrange_speed(Sequence *seq, short UNUSED(adrcode), float *
 	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;
@@ -2563,7 +2563,7 @@ static void store_icu_yrange_speed(Sequence *seq, short UNUSED(adrcode), float *
 	}	
 }
 
-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;
@@ -2572,7 +2572,7 @@ void sequence_effect_speed_rebuild_map(Scene *scene, Sequence *seq, int force)
 	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) &&
@@ -2863,7 +2863,7 @@ 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};
 
@@ -2878,7 +2878,7 @@ 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};
 
@@ -2893,7 +2893,7 @@ 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);
 
diff --git a/source/blender/blenkernel/intern/sequencer.c b/source/blender/blenkernel/intern/sequencer.c
index 50ce7552c98..137c0180fb4 100644
--- a/source/blender/blenkernel/intern/sequencer.c
+++ b/source/blender/blenkernel/intern/sequencer.c
@@ -103,17 +103,17 @@ static void printf_strip(Sequence *seq)
 }
 #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,7 +121,7 @@ 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;
 }
@@ -172,7 +172,7 @@ static 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);
@@ -181,7 +181,7 @@ void seq_free_sequence(Scene *scene, Sequence *seq)
 		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);
 	}
@@ -214,7 +214,7 @@ static 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);
 }
 
 
@@ -235,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;
 
@@ -272,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
 
@@ -288,7 +288,7 @@ void BKE_sequencer_editing_free(Scene *scene)
 
 /*********************** sequencer pipeline functions *************************/
 
-SeqRenderData seq_new_render_data(Main *bmain, 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;
 
@@ -363,7 +363,7 @@ static void seq_array(Editing *ed, Sequence ***seqarray, int *tot, int use_point
 		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);
@@ -375,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];
@@ -383,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);
@@ -434,7 +434,7 @@ 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;
@@ -453,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;
@@ -467,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;
 	}
 
@@ -509,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 {
@@ -530,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;
@@ -550,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;
 	}
@@ -638,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)
@@ -700,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);
 		}
 	}
 }
@@ -739,7 +739,7 @@ static int seqbase_unique_name_recursive_cb(Sequence *seq, void *arg_pt)
 	return 1;
 }
 
-void seqbase_unique_name_recursive(ListBase *seqbasep, Sequence *seq)
+void BKE_seqence_base_unique_name_recursive(ListBase *seqbasep, Sequence *seq)
 {
 	SeqUniqueInfo sui;
 	char *dot;
@@ -762,7 +762,7 @@ void seqbase_unique_name_recursive(ListBase *seqbasep, 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);
@@ -798,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);
 
@@ -914,7 +914,7 @@ 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;
 
@@ -952,7 +952,7 @@ 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];
@@ -1130,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 {
@@ -1244,7 +1244,7 @@ static void seq_proxy_build_frame(SeqRenderData context, Sequence *seq, int cfra
 	IMB_freeImBuf(ibuf);
 }
 
-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;
@@ -1259,7 +1259,7 @@ SeqIndexBuildContext *seq_proxy_rebuild_context(Main *bmain, Scene *scene, Seque
 
 	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;
@@ -1282,7 +1282,7 @@ SeqIndexBuildContext *seq_proxy_rebuild_context(Main *bmain, Scene *scene, Seque
 	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;
@@ -1308,7 +1308,7 @@ void seq_proxy_rebuild(SeqIndexBuildContext *context, short *stop, short *do_upd
 
 	/* fail safe code */
 
-	render_context = seq_new_render_data(context->bmain, context->scene,
+	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);
 
@@ -1334,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);
@@ -1609,7 +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;
 
@@ -1773,10 +1773,10 @@ static ImBuf *copy_from_ibuf_still(SeqRenderData context, Sequence *seq,
 	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) {
@@ -1797,11 +1797,11 @@ 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);
@@ -1815,7 +1815,7 @@ static ImBuf *seq_render_effect_strip_impl(SeqRenderData context, Sequence *seq,
 	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];
@@ -1874,7 +1874,7 @@ static ImBuf *seq_render_effect_strip_impl(SeqRenderData context, Sequence *seq,
 				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 {
@@ -1888,7 +1888,7 @@ static ImBuf *seq_render_effect_strip_impl(SeqRenderData context, Sequence *seq,
 				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 {
@@ -2193,14 +2193,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 */
@@ -2246,7 +2246,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];
@@ -2272,9 +2272,7 @@ static ImBuf *seq_render_strip(SeqRenderData context, Sequence *seq, float cfra)
 			}
 			case SEQ_TYPE_IMAGE:
 			{
-				StripElem *s_elem = give_stripelem(seq, cfra);
-
-				printf("Render image strip\n");
+				StripElem *s_elem = BKE_sequencer_give_stripelem(seq, cfra);
 
 				if (s_elem) {
 					BLI_join_dirfile(name, sizeof(name), seq->strip->dir, s_elem->name);
@@ -2364,7 +2362,7 @@ static ImBuf *seq_render_strip(SeqRenderData context, Sequence *seq, float cfra)
 	if (use_preprocess)
 		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;
 }
@@ -2387,7 +2385,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);
 	
@@ -2427,7 +2425,7 @@ static ImBuf *seq_render_strip_stack(SeqRenderData context, ListBase *seqbasep,
 	}
 #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;
@@ -2435,7 +2433,7 @@ static ImBuf *seq_render_strip_stack(SeqRenderData context, ListBase *seqbasep,
 	
 	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;
 	}
@@ -2445,7 +2443,7 @@ static ImBuf *seq_render_strip_stack(SeqRenderData context, ListBase *seqbasep,
 		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;
@@ -2479,7 +2477,7 @@ static ImBuf *seq_render_strip_stack(SeqRenderData context, ListBase *seqbasep,
 		}
 	}
 
-	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++;
 
@@ -2487,7 +2485,7 @@ static ImBuf *seq_render_strip_stack(SeqRenderData context, ListBase *seqbasep,
 		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);
 
@@ -2509,7 +2507,7 @@ static ImBuf *seq_render_strip_stack(SeqRenderData context, ListBase *seqbasep,
 			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;
@@ -2520,7 +2518,7 @@ static ImBuf *seq_render_strip_stack(SeqRenderData context, ListBase *seqbasep,
  * 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;
@@ -2540,13 +2538,13 @@ 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);
 }
@@ -2595,7 +2593,7 @@ typedef struct PrefetchQueueElem {
 	ImBuf *ibuf;
 } PrefetchQueueElem;
 
-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) {
@@ -2619,13 +2617,13 @@ void give_ibuf_prefetch_request(SeqRenderData context, float cfra, int chanshown
 	pthread_mutex_unlock(&wakeup_lock);
 }
 
-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) {
@@ -2713,7 +2711,7 @@ 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_sequencer_free_imbuf(Scene *scene, ListBase *seqbase, int check_mem_usage, int keep_file_handles)
 {
 	Sequence *seq;
 
@@ -2741,18 +2739,18 @@ void free_imbuf_seq(Scene *scene, ListBase *seqbase, int check_mem_usage, int ke
 		}
 	}
 
-	seq_stripelem_cache_cleanup();
+	BKE_sequencer_stripelem_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, 
@@ -2794,18 +2792,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;
@@ -2831,29 +2829,29 @@ 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);
@@ -2865,7 +2863,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));
@@ -2879,16 +2877,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 */
@@ -2932,16 +2930,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 */
@@ -2957,13 +2955,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);
 			}
 		}
 	}
@@ -2975,27 +2973,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)
@@ -3004,7 +3002,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;
 
@@ -3019,27 +3017,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 {
@@ -3052,7 +3050,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;
@@ -3075,17 +3073,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.
 	}
 
 	
@@ -3103,9 +3101,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 {
@@ -3154,13 +3152,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 */
 
@@ -3173,7 +3171,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;
 			}
 		}
@@ -3182,7 +3180,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;
 
@@ -3194,13 +3192,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 */
@@ -3232,7 +3230,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 */
@@ -3261,7 +3259,7 @@ static void seq_update_sound_recursive(Scene *scene, ListBase *seqbasep, bSound
 	}
 }
 
-void seq_update_sound(Scene *scene, bSound *sound)
+void BKE_sequencer_update_sound(Scene *scene, bSound *sound)
 {
 	if (scene->ed) {
 		seq_update_sound_recursive(scene, &scene->ed->seqbase, sound);
@@ -3269,7 +3267,7 @@ void seq_update_sound(Scene *scene, 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;
@@ -3278,7 +3276,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;
 		}
 	}
@@ -3286,7 +3284,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;
 
@@ -3297,7 +3295,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;
 		}
@@ -3306,7 +3304,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)];
 
@@ -3329,7 +3327,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;
 			}
@@ -3363,7 +3361,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;
@@ -3386,7 +3384,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;
@@ -3443,7 +3441,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;
@@ -3451,7 +3449,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;
 		}
 	}
@@ -3527,7 +3525,7 @@ 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);
@@ -3550,7 +3548,7 @@ static 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;
 
@@ -3574,13 +3572,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 */
 	
@@ -3598,7 +3596,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 */
@@ -3633,12 +3631,12 @@ Sequence *sequencer_add_sound_strip(bContext *C, ListBase *seqbasep, SeqLoadInfo
 		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");
@@ -3652,7 +3650,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);
@@ -3671,7 +3669,7 @@ Sequence *sequencer_add_sound_strip(bContext *C, ListBase *seqbasep, SeqLoadInfo
 }
 #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)];
@@ -3690,14 +3688,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");
@@ -3709,14 +3707,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--;
@@ -3794,7 +3792,7 @@ static Sequence *seq_dupli(Scene *scene, Scene *scene_to, Sequence *seq, int dup
 
 		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);
 		}
@@ -3807,21 +3805,21 @@ static Sequence *seq_dupli(Scene *scene, Scene *scene_to, Sequence *seq, int dup
 	}
 
 	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(Scene *scene, 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);
 			}
@@ -3830,7 +3828,7 @@ Sequence *seq_dupli_recursive(Scene *scene, Scene *scene_to, Sequence *seq, int
 	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;
@@ -3848,7 +3846,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) {
diff --git a/source/blender/blenkernel/intern/sound.c b/source/blender/blenkernel/intern/sound.c
index 28fb75db41c..14360297ec0 100644
--- a/source/blender/blenkernel/intern/sound.c
+++ b/source/blender/blenkernel/intern/sound.c
@@ -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);
 	}
 }