Cleanup: Rename BKE_sequencer functions

API functions get SEQ_ prefix.
Intern functions get seq_ prefix

Functions also have appropriate category included in name.

21 files changed, 363 insertions, 365 deletions

diff --git a/source/blender/editors/animation/anim_deps.c b/source/blender/editors/animation/anim_deps.c
index 32ce78e405e..fbd55592729 100644
--- a/source/blender/editors/animation/anim_deps.c
+++ b/source/blender/editors/animation/anim_deps.c
@@ -212,7 +212,7 @@ static void animchan_sync_fcurve_scene(bAnimListElem *ale)
     return;
   }
 
-  Editing *ed = BKE_sequencer_editing_get(scene, false);
+  Editing *ed = SEQ_editing_get(scene, false);
 
   /* get strip name, and check if this strip is selected */
   char *seq_name = BLI_str_quoted_substrN(fcu->rna_path, "sequences_all[");
@@ -220,7 +220,7 @@ static void animchan_sync_fcurve_scene(bAnimListElem *ale)
     return;
   }
 
-  Sequence *seq = BKE_sequence_get_by_name(ed->seqbasep, seq_name, false);
+  Sequence *seq = SEQ_get_sequence_by_name(ed->seqbasep, seq_name, false);
   MEM_freeN(seq_name);
 
   if (seq == NULL) {
diff --git a/source/blender/editors/animation/anim_filter.c b/source/blender/editors/animation/anim_filter.c
index f4a487140ff..83665d7a053 100644
--- a/source/blender/editors/animation/anim_filter.c
+++ b/source/blender/editors/animation/anim_filter.c
@@ -225,7 +225,7 @@ static bool actedit_get_context(bAnimContext *ac, SpaceAction *saction)
     {
       /* TODO, other methods to get the mask */
 #if 0
-      Sequence *seq = BKE_sequencer_active_get(ac->scene);
+      Sequence *seq = SEQ_select_active_get(ac->scene);
       MovieClip *clip = ac->scene->clip;
       struct Mask *mask = seq ? seq->mask : NULL;
 #endif
@@ -1103,14 +1103,14 @@ static bool skip_fcurve_selected_data(bDopeSheet *ads, FCurve *fcu, ID *owner_id
 
     /* only consider if F-Curve involves sequence_editor.sequences */
     if ((fcu->rna_path) && strstr(fcu->rna_path, "sequences_all")) {
-      Editing *ed = BKE_sequencer_editing_get(scene, false);
+      Editing *ed = SEQ_editing_get(scene, false);
       Sequence *seq = NULL;
 
       if (ed) {
         /* get strip name, and check if this strip is selected */
         char *seq_name = BLI_str_quoted_substrN(fcu->rna_path, "sequences_all[");
         if (seq_name) {
-          seq = BKE_sequence_get_by_name(ed->seqbasep, seq_name, false);
+          seq = SEQ_get_sequence_by_name(ed->seqbasep, seq_name, false);
           MEM_freeN(seq_name);
         }
       }
diff --git a/source/blender/editors/animation/anim_ops.c b/source/blender/editors/animation/anim_ops.c
index 0db3e984b60..07601414fb0 100644
--- a/source/blender/editors/animation/anim_ops.c
+++ b/source/blender/editors/animation/anim_ops.c
@@ -93,7 +93,7 @@ static void change_frame_apply(bContext *C, wmOperator *op)
 
   if (do_snap) {
     if (CTX_wm_space_seq(C)) {
-      frame = BKE_sequencer_find_next_prev_edit(scene, frame, SEQ_SIDE_BOTH, true, false, false);
+      frame = SEQ_time_find_next_prev_edit(scene, frame, SEQ_SIDE_BOTH, true, false, false);
     }
     else {
       frame = BKE_scene_frame_snap_by_seconds(scene, 1.0, frame);
diff --git a/source/blender/editors/render/render_internal.c b/source/blender/editors/render/render_internal.c
index 69c1e887392..46680f649cd 100644
--- a/source/blender/editors/render/render_internal.c
+++ b/source/blender/editors/render/render_internal.c
@@ -363,7 +363,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_RenderFrame,
    * since sequence rendering can call that recursively... (peter) */
-  BKE_sequencer_cache_cleanup(scene);
+  SEQ_cache_cleanup(scene);
 
   RE_SetReports(re, op->reports);
 
@@ -935,7 +935,7 @@ static int screen_render_invoke(bContext *C, wmOperator *op, const wmEvent *even
 
   /* Reports are done inside check function, and it will return false if there are other strips to
    * render. */
-  if ((scene->r.scemode & R_DOSEQ) && BKE_sequencer_check_scene_recursion(scene, op->reports)) {
+  if ((scene->r.scemode & R_DOSEQ) && SEQ_relations_check_scene_recursion(scene, op->reports)) {
     return OPERATOR_CANCELLED;
   }
 
@@ -957,7 +957,7 @@ static int screen_render_invoke(bContext *C, wmOperator *op, const wmEvent *even
    * otherwise, invalidated cache entries can make their way into
    * the output rendering. We can't put that into RE_RenderFrame,
    * since sequence rendering can call that recursively... (peter) */
-  BKE_sequencer_cache_cleanup(scene);
+  SEQ_cache_cleanup(scene);
 
   /* store spare
    * get view3d layer, local layer, make this nice api call to render
diff --git a/source/blender/editors/screen/screen_context.c b/source/blender/editors/screen/screen_context.c
index fb7606d1fe5..1dfe606be78 100644
--- a/source/blender/editors/screen/screen_context.c
+++ b/source/blender/editors/screen/screen_context.c
@@ -604,7 +604,7 @@ static eContextResult screen_ctx_sequences(const bContext *C, bContextDataResult
 {
   wmWindow *win = CTX_wm_window(C);
   Scene *scene = WM_window_get_active_scene(win);
-  Editing *ed = BKE_sequencer_editing_get(scene, false);
+  Editing *ed = SEQ_editing_get(scene, false);
   if (ed) {
     LISTBASE_FOREACH (Sequence *, seq, ed->seqbasep) {
       CTX_data_list_add(result, &scene->id, &RNA_Sequence, seq);
@@ -618,7 +618,7 @@ static eContextResult screen_ctx_selected_sequences(const bContext *C, bContextD
 {
   wmWindow *win = CTX_wm_window(C);
   Scene *scene = WM_window_get_active_scene(win);
-  Editing *ed = BKE_sequencer_editing_get(scene, false);
+  Editing *ed = SEQ_editing_get(scene, false);
   if (ed) {
     LISTBASE_FOREACH (Sequence *, seq, ed->seqbasep) {
       if (seq->flag & SELECT) {
@@ -635,7 +635,7 @@ static eContextResult screen_ctx_selected_editable_sequences(const bContext *C,
 {
   wmWindow *win = CTX_wm_window(C);
   Scene *scene = WM_window_get_active_scene(win);
-  Editing *ed = BKE_sequencer_editing_get(scene, false);
+  Editing *ed = SEQ_editing_get(scene, false);
   if (ed) {
     LISTBASE_FOREACH (Sequence *, seq, ed->seqbasep) {
       if (seq->flag & SELECT && !(seq->flag & SEQ_LOCK)) {
diff --git a/source/blender/editors/sound/sound_ops.c b/source/blender/editors/sound/sound_ops.c
index 8dac90c2346..5bc13ec1b75 100644
--- a/source/blender/editors/sound/sound_ops.c
+++ b/source/blender/editors/sound/sound_ops.c
@@ -259,7 +259,7 @@ static void sound_update_animation_flags(Scene *scene)
   scene->id.tag |= LIB_TAG_DOIT;
 
   SEQ_ALL_BEGIN (scene->ed, seq) {
-    BKE_sequencer_recursive_apply(seq, sound_update_animation_flags_fn, scene);
+    SEQ_iterator_recursive_apply(seq, sound_update_animation_flags_fn, scene);
   }
   SEQ_ALL_END;
 
diff --git a/source/blender/editors/space_outliner/outliner_select.c b/source/blender/editors/space_outliner/outliner_select.c
index 658e6adbe33..a1df922b335 100644
--- a/source/blender/editors/space_outliner/outliner_select.c
+++ b/source/blender/editors/space_outliner/outliner_select.c
@@ -870,13 +870,13 @@ static eOLDrawState tree_element_active_sequence(bContext *C,
                                                  const eOLSetState set)
 {
   Sequence *seq = (Sequence *)te->directdata;
-  Editing *ed = BKE_sequencer_editing_get(scene, false);
+  Editing *ed = SEQ_editing_get(scene, false);
 
   if (set != OL_SETSEL_NONE) {
     /* only check on setting */
     if (BLI_findindex(ed->seqbasep, seq) != -1) {
       if (set == OL_SETSEL_EXTEND) {
-        BKE_sequencer_active_set(scene, NULL);
+        SEQ_select_active_set(scene, NULL);
       }
       ED_sequencer_deselect_all(scene);
 
@@ -885,7 +885,7 @@ static eOLDrawState tree_element_active_sequence(bContext *C,
       }
       else {
         seq->flag |= SELECT;
-        BKE_sequencer_active_set(scene, seq);
+        SEQ_select_active_set(scene, seq);
       }
     }
 
@@ -905,7 +905,7 @@ static eOLDrawState tree_element_active_sequence_dup(Scene *scene,
                                                      const eOLSetState set)
 {
   Sequence *seq, *p;
-  Editing *ed = BKE_sequencer_editing_get(scene, false);
+  Editing *ed = SEQ_editing_get(scene, false);
 
   seq = (Sequence *)te->directdata;
   if (set == OL_SETSEL_NONE) {
diff --git a/source/blender/editors/space_outliner/outliner_sync.c b/source/blender/editors/space_outliner/outliner_sync.c
index 0f5c74a9168..b3e8761f60b 100644
--- a/source/blender/editors/space_outliner/outliner_sync.c
+++ b/source/blender/editors/space_outliner/outliner_sync.c
@@ -305,7 +305,7 @@ static void outliner_select_sync_to_sequence(Scene *scene, TreeStoreElem *tselem
   Sequence *seq = (Sequence *)tselem->id;
 
   if (tselem->flag & TSE_ACTIVE) {
-    BKE_sequencer_active_set(scene, seq);
+    SEQ_select_active_set(scene, seq);
   }
 
   if (tselem->flag & TSE_SELECTED) {
@@ -542,7 +542,7 @@ static void get_sync_select_active_data(const bContext *C, SyncSelectActiveData
   active_data->object = OBACT(view_layer);
   active_data->edit_bone = CTX_data_active_bone(C);
   active_data->pose_channel = CTX_data_active_pose_bone(C);
-  active_data->sequence = BKE_sequencer_active_get(scene);
+  active_data->sequence = SEQ_select_active_get(scene);
 }
 
 /* If outliner is dirty sync selection from view layer and sequwncer */
diff --git a/source/blender/editors/space_outliner/outliner_tools.c b/source/blender/editors/space_outliner/outliner_tools.c
index 492fc5c23bc..d4784a509bf 100644
--- a/source/blender/editors/space_outliner/outliner_tools.c
+++ b/source/blender/editors/space_outliner/outliner_tools.c
@@ -1206,7 +1206,7 @@ static void sequence_fn(int event, TreeElement *te, TreeStoreElem *tselem, void
   Sequence *seq = (Sequence *)te->directdata;
   if (event == OL_DOP_SELECT) {
     Scene *scene = (Scene *)scene_ptr;
-    Editing *ed = BKE_sequencer_editing_get(scene, false);
+    Editing *ed = SEQ_editing_get(scene, false);
     if (BLI_findindex(ed->seqbasep, seq) != -1) {
       ED_sequencer_select_sequence_single(scene, seq, true);
     }
diff --git a/source/blender/editors/space_outliner/tree/tree_display_sequencer.cc b/source/blender/editors/space_outliner/tree/tree_display_sequencer.cc
index 48f0322ccb9..40f329d72c3 100644
--- a/source/blender/editors/space_outliner/tree/tree_display_sequencer.cc
+++ b/source/blender/editors/space_outliner/tree/tree_display_sequencer.cc
@@ -43,7 +43,7 @@ ListBase TreeDisplaySequencer::buildTree(const TreeSourceData &source_data)
 {
   ListBase tree = {nullptr};
 
-  Editing *ed = BKE_sequencer_editing_get(source_data.scene, false);
+  Editing *ed = SEQ_editing_get(source_data.scene, false);
   if (ed == nullptr) {
     return tree;
   }
diff --git a/source/blender/editors/space_sequencer/sequencer_add.c b/source/blender/editors/space_sequencer/sequencer_add.c
index 71433a6978a..e40e9f5429d 100644
--- a/source/blender/editors/space_sequencer/sequencer_add.c
+++ b/source/blender/editors/space_sequencer/sequencer_add.c
@@ -149,7 +149,7 @@ static void sequencer_generic_invoke_path__internal(bContext *C,
 {
   if (RNA_struct_find_property(op->ptr, identifier)) {
     Scene *scene = CTX_data_scene(C);
-    Sequence *last_seq = BKE_sequencer_active_get(scene);
+    Sequence *last_seq = SEQ_select_active_get(scene);
     if (last_seq && last_seq->strip && SEQ_HAS_PATH(last_seq)) {
       Main *bmain = CTX_data_main(C);
       char path[FILE_MAX];
@@ -165,7 +165,7 @@ static int sequencer_generic_invoke_xy_guess_channel(bContext *C, int type)
   Sequence *tgt = NULL;
   Sequence *seq;
   Scene *scene = CTX_data_scene(C);
-  Editing *ed = BKE_sequencer_editing_get(scene, true);
+  Editing *ed = SEQ_editing_get(scene, true);
   int timeline_frame = (int)CFRA;
   int proximity = INT_MAX;
 
@@ -306,11 +306,11 @@ static void seq_load_operator_info(SeqLoadInfo *seq_load, bContext *C, wmOperato
 static void sequencer_add_apply_overlap(bContext *C, wmOperator *op, Sequence *seq)
 {
   Scene *scene = CTX_data_scene(C);
-  Editing *ed = BKE_sequencer_editing_get(scene, false);
+  Editing *ed = SEQ_editing_get(scene, false);
 
   if (RNA_boolean_get(op->ptr, "overlap") == false) {
-    if (BKE_sequence_test_overlap(ed->seqbasep, seq)) {
-      BKE_sequence_base_shuffle(ed->seqbasep, seq, scene);
+    if (SEQ_transform_test_overlap(ed->seqbasep, seq)) {
+      SEQ_transform_seqbase_shuffle(ed->seqbasep, seq, scene);
     }
   }
 }
@@ -321,7 +321,7 @@ static void sequencer_add_apply_replace_sel(bContext *C, wmOperator *op, Sequenc
 
   if (RNA_boolean_get(op->ptr, "replace_sel")) {
     ED_sequencer_deselect_all(scene);
-    BKE_sequencer_active_set(scene, seq);
+    SEQ_select_active_set(scene, seq);
     seq->flag |= SELECT;
   }
 }
@@ -334,7 +334,7 @@ static bool seq_effect_add_properties_poll(const bContext *UNUSED(C),
   int type = RNA_enum_get(op->ptr, "type");
 
   /* Hide start/end frames for effect strips that are locked to their parents' location. */
-  if (BKE_sequence_effect_get_num_inputs(type) != 0) {
+  if (SEQ_effect_get_num_inputs(type) != 0) {
     if (STR_ELEM(prop_id, "frame_start", "frame_end")) {
       return false;
     }
@@ -350,7 +350,7 @@ static int sequencer_add_scene_strip_exec(bContext *C, wmOperator *op)
 {
   Main *bmain = CTX_data_main(C);
   Scene *scene = CTX_data_scene(C);
-  Editing *ed = BKE_sequencer_editing_get(scene, true);
+  Editing *ed = SEQ_editing_get(scene, true);
   Scene *sce_seq;
   Sequence *seq;
 
@@ -364,20 +364,20 @@ static int sequencer_add_scene_strip_exec(bContext *C, wmOperator *op)
     return OPERATOR_CANCELLED;
   }
 
-  seq = BKE_sequence_alloc(ed->seqbasep, start_frame, channel, SEQ_TYPE_SCENE);
+  seq = SEQ_sequence_alloc(ed->seqbasep, start_frame, channel, SEQ_TYPE_SCENE);
   seq->blend_mode = SEQ_TYPE_CROSS;
   seq->scene = sce_seq;
   seq->len = sce_seq->r.efra - sce_seq->r.sfra + 1;
 
   BLI_strncpy(seq->name + 2, sce_seq->id.name + 2, sizeof(seq->name) - 2);
-  BKE_sequence_base_unique_name_recursive(&ed->seqbase, seq);
+  SEQ_sequence_base_unique_name_recursive(&ed->seqbase, seq);
 
-  BKE_sequence_calc_disp(scene, seq);
-  BKE_sequencer_sort(scene);
+  SEQ_time_update_sequence_bounds(scene, seq);
+  SEQ_sort(scene);
 
   sequencer_add_apply_replace_sel(C, op, seq);
   sequencer_add_apply_overlap(C, op, seq);
-  BKE_sequence_invalidate_cache_composite(scene, seq);
+  SEQ_relations_invalidate_cache_composite(scene, seq);
 
   DEG_id_tag_update(&scene->id, ID_RECALC_SEQUENCER_STRIPS);
   DEG_relations_tag_update(bmain);
@@ -424,7 +424,7 @@ static int sequencer_add_movieclip_strip_exec(bContext *C, wmOperator *op)
 {
   Main *bmain = CTX_data_main(C);
   Scene *scene = CTX_data_scene(C);
-  Editing *ed = BKE_sequencer_editing_get(scene, true);
+  Editing *ed = SEQ_editing_get(scene, true);
   MovieClip *clip;
   Sequence *seq;
 
@@ -438,7 +438,7 @@ static int sequencer_add_movieclip_strip_exec(bContext *C, wmOperator *op)
     return OPERATOR_CANCELLED;
   }
 
-  seq = BKE_sequence_alloc(ed->seqbasep, start_frame, channel, SEQ_TYPE_MOVIECLIP);
+  seq = SEQ_sequence_alloc(ed->seqbasep, start_frame, channel, SEQ_TYPE_MOVIECLIP);
   seq->blend_mode = SEQ_TYPE_CROSS;
   seq->clip = clip;
   seq->len = BKE_movieclip_get_duration(clip);
@@ -446,14 +446,14 @@ static int sequencer_add_movieclip_strip_exec(bContext *C, wmOperator *op)
   id_us_ensure_real(&seq->clip->id);
 
   BLI_strncpy(seq->name + 2, clip->id.name + 2, sizeof(seq->name) - 2);
-  BKE_sequence_base_unique_name_recursive(&ed->seqbase, seq);
+  SEQ_sequence_base_unique_name_recursive(&ed->seqbase, seq);
 
-  BKE_sequence_calc_disp(scene, seq);
-  BKE_sequencer_sort(scene);
+  SEQ_time_update_sequence_bounds(scene, seq);
+  SEQ_sort(scene);
 
   sequencer_add_apply_replace_sel(C, op, seq);
   sequencer_add_apply_overlap(C, op, seq);
-  BKE_sequence_invalidate_cache_composite(scene, seq);
+  SEQ_relations_invalidate_cache_composite(scene, seq);
 
   DEG_id_tag_update(&scene->id, ID_RECALC_SEQUENCER_STRIPS);
   WM_event_add_notifier(C, NC_SCENE | ND_SEQUENCER, scene);
@@ -500,7 +500,7 @@ static int sequencer_add_mask_strip_exec(bContext *C, wmOperator *op)
 {
   Main *bmain = CTX_data_main(C);
   Scene *scene = CTX_data_scene(C);
-  Editing *ed = BKE_sequencer_editing_get(scene, true);
+  Editing *ed = SEQ_editing_get(scene, true);
   Mask *mask;
   Sequence *seq;
 
@@ -514,7 +514,7 @@ static int sequencer_add_mask_strip_exec(bContext *C, wmOperator *op)
     return OPERATOR_CANCELLED;
   }
 
-  seq = BKE_sequence_alloc(ed->seqbasep, start_frame, channel, SEQ_TYPE_MASK);
+  seq = SEQ_sequence_alloc(ed->seqbasep, start_frame, channel, SEQ_TYPE_MASK);
   seq->blend_mode = SEQ_TYPE_CROSS;
   seq->mask = mask;
   seq->len = BKE_mask_get_duration(mask);
@@ -522,14 +522,14 @@ static int sequencer_add_mask_strip_exec(bContext *C, wmOperator *op)
   id_us_ensure_real(&seq->mask->id);
 
   BLI_strncpy(seq->name + 2, mask->id.name + 2, sizeof(seq->name) - 2);
-  BKE_sequence_base_unique_name_recursive(&ed->seqbase, seq);
+  SEQ_sequence_base_unique_name_recursive(&ed->seqbase, seq);
 
-  BKE_sequence_calc_disp(scene, seq);
-  BKE_sequencer_sort(scene);
+  SEQ_time_update_sequence_bounds(scene, seq);
+  SEQ_sort(scene);
 
   sequencer_add_apply_replace_sel(C, op, seq);
   sequencer_add_apply_overlap(C, op, seq);
-  BKE_sequence_invalidate_cache_composite(scene, seq);
+  SEQ_relations_invalidate_cache_composite(scene, seq);
 
   DEG_id_tag_update(&scene->id, ID_RECALC_SEQUENCER_STRIPS);
   WM_event_add_notifier(C, NC_SCENE | ND_SEQUENCER, scene);
@@ -574,7 +574,7 @@ void SEQUENCER_OT_mask_strip_add(struct wmOperatorType *ot)
 static int sequencer_add_generic_strip_exec(bContext *C, wmOperator *op, SeqLoadFn seq_load_fn)
 {
   Scene *scene = CTX_data_scene(C);
-  Editing *ed = BKE_sequencer_editing_get(scene, true);
+  Editing *ed = SEQ_editing_get(scene, true);
   SeqLoadInfo seq_load;
   int tot_files;
 
@@ -632,7 +632,7 @@ static int sequencer_add_generic_strip_exec(bContext *C, wmOperator *op, SeqLoad
     return OPERATOR_CANCELLED;
   }
 
-  BKE_sequencer_sort(scene);
+  SEQ_sort(scene);
 
   DEG_id_tag_update(&scene->id, ID_RECALC_SEQUENCER_STRIPS);
   WM_event_add_notifier(C, NC_SCENE | ND_SEQUENCER, scene);
@@ -664,7 +664,7 @@ static bool sequencer_add_draw_check_fn(PointerRNA *UNUSED(ptr),
 
 static int sequencer_add_movie_strip_exec(bContext *C, wmOperator *op)
 {
-  return sequencer_add_generic_strip_exec(C, op, BKE_sequencer_add_movie_strip);
+  return sequencer_add_generic_strip_exec(C, op, SEQ_add_movie_strip);
 }
 
 static int sequencer_add_movie_strip_invoke(bContext *C,
@@ -673,7 +673,7 @@ static int sequencer_add_movie_strip_invoke(bContext *C,
 {
   PropertyRNA *prop;
   Scene *scene = CTX_data_scene(C);
-  Editing *ed = BKE_sequencer_editing_get(scene, false);
+  Editing *ed = SEQ_editing_get(scene, false);
 
   /* Only enable "use_framerate" if there aren't any existing strips, unless overridden by user. */
   if (ed && ed->seqbasep && ed->seqbasep->first) {
@@ -757,7 +757,7 @@ void SEQUENCER_OT_movie_strip_add(struct wmOperatorType *ot)
 
 static int sequencer_add_sound_strip_exec(bContext *C, wmOperator *op)
 {
-  return sequencer_add_generic_strip_exec(C, op, BKE_sequencer_add_sound_strip);
+  return sequencer_add_generic_strip_exec(C, op, SEQ_add_sound_strip);
 }
 
 static int sequencer_add_sound_strip_invoke(bContext *C,
@@ -871,7 +871,7 @@ static int sequencer_add_image_strip_exec(bContext *C, wmOperator *op)
 {
   int minframe, numdigits;
   Scene *scene = CTX_data_scene(C);
-  Editing *ed = BKE_sequencer_editing_get(scene, true);
+  Editing *ed = SEQ_editing_get(scene, true);
   SeqLoadInfo seq_load;
   Sequence *seq;
   Strip *strip;
@@ -899,7 +899,7 @@ static int sequencer_add_image_strip_exec(bContext *C, wmOperator *op)
   }
 
   /* Main adding function. */
-  seq = BKE_sequencer_add_image_strip(C, ed->seqbasep, &seq_load);
+  seq = SEQ_add_image_strip(C, ed->seqbasep, &seq_load);
   strip = seq->strip;
   se = strip->stripdata;
   seq->blend_mode = SEQ_TYPE_ALPHAOVER;
@@ -924,8 +924,8 @@ static int sequencer_add_image_strip_exec(bContext *C, wmOperator *op)
   }
 
   SEQ_render_init_colorspace(seq);
-  BKE_sequence_calc_disp(scene, seq);
-  BKE_sequencer_sort(scene);
+  SEQ_time_update_sequence_bounds(scene, seq);
+  SEQ_sort(scene);
 
   /* Last active name. */
   BLI_strncpy(ed->act_imagedir, strip->dir, sizeof(ed->act_imagedir));
@@ -935,7 +935,7 @@ static int sequencer_add_image_strip_exec(bContext *C, wmOperator *op)
     MEM_freeN(op->customdata);
   }
 
-  BKE_sequence_invalidate_cache_composite(scene, seq);
+  SEQ_relations_invalidate_cache_composite(scene, seq);
   DEG_id_tag_update(&scene->id, ID_RECALC_SEQUENCER_STRIPS);
   WM_event_add_notifier(C, NC_SCENE | ND_SEQUENCER, scene);
 
@@ -1009,7 +1009,7 @@ void SEQUENCER_OT_image_strip_add(struct wmOperatorType *ot)
 static int sequencer_add_effect_strip_exec(bContext *C, wmOperator *op)
 {
   Scene *scene = CTX_data_scene(C);
-  Editing *ed = BKE_sequencer_editing_get(scene, true);
+  Editing *ed = SEQ_editing_get(scene, true);
   Sequence *seq;
   struct SeqEffectHandle sh;
   Sequence *seq1, *seq2, *seq3;
@@ -1032,11 +1032,11 @@ static int sequencer_add_effect_strip_exec(bContext *C, wmOperator *op)
     RNA_int_set(op->ptr, "frame_end", end_frame);
   }
 
-  seq = BKE_sequence_alloc(ed->seqbasep, start_frame, channel, type);
-  BLI_strncpy(seq->name + 2, BKE_sequence_give_name(seq), sizeof(seq->name) - 2);
-  BKE_sequence_base_unique_name_recursive(&ed->seqbase, seq);
+  seq = SEQ_sequence_alloc(ed->seqbasep, start_frame, channel, type);
+  BLI_strncpy(seq->name + 2, SEQ_sequence_give_name(seq), sizeof(seq->name) - 2);
+  SEQ_sequence_base_unique_name_recursive(&ed->seqbase, seq);
 
-  sh = BKE_sequence_get_effect(seq);
+  sh = SEQ_effect_handle_get(seq);
   sh.init(seq);
   seq->seq1 = seq1;
   seq->seq2 = seq2;
@@ -1044,11 +1044,11 @@ static int sequencer_add_effect_strip_exec(bContext *C, wmOperator *op)
 
   if (!seq1) {
     seq->len = 1; /* Effect is generator, set non zero length. */
-    BKE_sequence_tx_set_final_right(seq, end_frame);
+    SEQ_transform_set_right_handle_frame(seq, end_frame);
   }
 
   seq->flag |= SEQ_USE_EFFECT_DEFAULT_FADE;
-  BKE_sequence_calc(scene, seq);
+  SEQ_time_update_sequence(scene, seq);
 
   if (seq->type == SEQ_TYPE_COLOR) {
     SolidColorVars *colvars = (SolidColorVars *)seq->effectdata;
@@ -1077,10 +1077,10 @@ static int sequencer_add_effect_strip_exec(bContext *C, wmOperator *op)
   sequencer_add_apply_replace_sel(C, op, seq);
   sequencer_add_apply_overlap(C, op, seq);
 
-  BKE_sequencer_update_changed_seq_and_deps(scene, seq, 1, 1); /* Runs BKE_sequence_calc. */
-  BKE_sequencer_sort(scene);
+  SEQ_relations_update_changed_seq_and_deps(scene, seq, 1, 1); /* Runs SEQ_time_update_sequence. */
+  SEQ_sort(scene);
 
-  BKE_sequence_invalidate_cache_composite(scene, seq);
+  SEQ_relations_invalidate_cache_composite(scene, seq);
   DEG_id_tag_update(&scene->id, ID_RECALC_SEQUENCER_STRIPS);
   WM_event_add_notifier(C, NC_SCENE | ND_SEQUENCER, scene);
 
@@ -1100,7 +1100,7 @@ static int sequencer_add_effect_strip_invoke(bContext *C,
 
     /* When invoking an effect strip which uses inputs, skip initializing the channel from the
      * mouse. */
-    if (BKE_sequence_effect_get_num_inputs(type) != 0) {
+    if (SEQ_effect_get_num_inputs(type) != 0) {
       prop_flag |= SEQPROP_NOCHAN;
     }
   }
diff --git a/source/blender/editors/space_sequencer/sequencer_draw.c b/source/blender/editors/space_sequencer/sequencer_draw.c
index d7d601a3c76..2f146690416 100644
--- a/source/blender/editors/space_sequencer/sequencer_draw.c
+++ b/source/blender/editors/space_sequencer/sequencer_draw.c
@@ -371,7 +371,7 @@ static void drawmeta_contents(Scene *scene, Sequence *seqm, float x1, float y1,
   ListBase *seqbase;
   int offset;
 
-  seqbase = BKE_sequence_seqbase_get(seqm, &offset);
+  seqbase = SEQ_get_seqbase_from_sequence(seqm, &offset);
   if (!seqbase || BLI_listbase_is_empty(seqbase)) {
     return;
   }
@@ -488,7 +488,7 @@ static void draw_seq_handle(View2D *v2d,
     whichsel = SEQ_RIGHTSEL;
   }
 
-  if (!(seq->type & SEQ_TYPE_EFFECT) || BKE_sequence_effect_get_num_inputs(seq->type) == 0) {
+  if (!(seq->type & SEQ_TYPE_EFFECT) || SEQ_effect_get_num_inputs(seq->type) == 0) {
     GPU_blend(GPU_BLEND_ALPHA);
 
     GPU_blend(GPU_BLEND_ALPHA);
@@ -607,7 +607,7 @@ static const char *draw_seq_text_get_name(Sequence *seq)
 {
   const char *name = seq->name + 2;
   if (name[0] == '\0') {
-    name = BKE_sequence_give_name(seq);
+    name = SEQ_sequence_give_name(seq);
   }
   return name;
 }
@@ -840,9 +840,9 @@ static void draw_seq_background(Scene *scene,
   /* Draw the main strip body. */
   if (is_single_image) {
     immRectf(pos,
-             BKE_sequence_tx_get_final_left(seq, false),
+             SEQ_transform_get_left_handle_frame(seq, false),
              y1,
-             BKE_sequence_tx_get_final_right(seq, false),
+             SEQ_transform_get_right_handle_frame(seq, false),
              y2);
   }
   else {
@@ -1067,7 +1067,7 @@ static void draw_seq_strip(const bContext *C,
   float pixely = BLI_rctf_size_y(&v2d->cur) / BLI_rcti_size_y(&v2d->mask);
 
   /* Check if we are doing "solo preview". */
-  bool is_single_image = (char)BKE_sequence_single_check(seq);
+  bool is_single_image = (char)SEQ_transform_single_image_check(seq);
 
   /* Draw strip body. */
   x1 = (seq->startstill) ? seq->start : seq->startdisp;
@@ -1143,7 +1143,7 @@ static void draw_seq_strip(const bContext *C,
   }
 
   /* Draw Red line on the top of invalid strip (Missing media). */
-  if (!BKE_sequence_is_valid_check(seq)) {
+  if (!SEQ_sequence_has_source(seq)) {
     draw_seq_invalid(x1, x2, y2, text_margin_y);
   }
 
@@ -1441,7 +1441,7 @@ void sequencer_draw_maskedit(const bContext *C, Scene *scene, ARegion *region, S
 
   // if (sc->mode == SC_MODE_MASKEDIT)
   if (0 && sseq->mainb == SEQ_DRAW_IMG_IMBUF) {
-    Mask *mask = BKE_sequencer_mask_get(scene);
+    Mask *mask = SEQ_active_mask_get(scene);
 
     if (mask) {
       int width, height;
@@ -1473,7 +1473,7 @@ void sequencer_draw_maskedit(const bContext *C, Scene *scene, ARegion *region, S
 /* Force redraw, when prefetching and using cache view. */
 static void seq_prefetch_wm_notify(const bContext *C, Scene *scene)
 {
-  if (BKE_sequencer_prefetch_need_redraw(CTX_data_main(C), scene)) {
+  if (SEQ_prefetch_need_redraw(CTX_data_main(C), scene)) {
     WM_event_add_notifier(C, NC_SCENE | ND_SEQUENCER, NULL);
   }
 }
@@ -1913,7 +1913,7 @@ static void draw_seq_strips(const bContext *C, Editing *ed, ARegion *region)
   Scene *scene = CTX_data_scene(C);
   View2D *v2d = &region->v2d;
   SpaceSeq *sseq = CTX_wm_space_seq(C);
-  Sequence *last_seq = BKE_sequencer_active_get(scene);
+  Sequence *last_seq = SEQ_select_active_get(scene);
   int sel = 0, j;
   float pixelx = BLI_rctf_size_x(&v2d->cur) / BLI_rcti_size_x(&v2d->mask);
 
@@ -1956,7 +1956,7 @@ static void draw_seq_strips(const bContext *C, Editing *ed, ARegion *region)
     draw_seq_strip(C, sseq, scene, region, last_seq, pixelx, true);
 
     /* When active strip is an effect, highlight its inputs. */
-    if (BKE_sequence_effect_get_num_inputs(last_seq->type) > 0) {
+    if (SEQ_effect_get_num_inputs(last_seq->type) > 0) {
       draw_effect_inputs_highlight(last_seq);
     }
     /* When active is a Multi-cam strip, highlight its source channel. */
@@ -2000,7 +2000,7 @@ static void draw_seq_strips(const bContext *C, Editing *ed, ARegion *region)
 
 static void seq_draw_sfra_efra(Scene *scene, View2D *v2d)
 {
-  const Editing *ed = BKE_sequencer_editing_get(scene, false);
+  const Editing *ed = SEQ_editing_get(scene, false);
   const int frame_sta = scene->r.sfra;
   const int frame_end = scene->r.efra + 1;
 
@@ -2265,7 +2265,7 @@ static void draw_cache_view(const bContext *C)
   userdata.composite_vbo = GPU_vertbuf_create_with_format(&format);
   userdata.final_out_vbo = GPU_vertbuf_create_with_format(&format);
 
-  BKE_sequencer_cache_iterate(scene, &userdata, draw_cache_view_init_fn, draw_cache_view_iter_fn);
+  SEQ_cache_iterate(scene, &userdata, draw_cache_view_init_fn, draw_cache_view_iter_fn);
 
   draw_cache_view_batch(userdata.raw_vbo, userdata.raw_vert_count, 1.0f, 0.1f, 0.02f, 0.4f);
   draw_cache_view_batch(
@@ -2282,7 +2282,7 @@ static void draw_cache_view(const bContext *C)
 void draw_timeline_seq(const bContext *C, ARegion *region)
 {
   Scene *scene = CTX_data_scene(C);
-  Editing *ed = BKE_sequencer_editing_get(scene, false);
+  Editing *ed = SEQ_editing_get(scene, false);
   SpaceSeq *sseq = CTX_wm_space_seq(C);
   View2D *v2d = &region->v2d;
   short cfra_flag = 0;
diff --git a/source/blender/editors/space_sequencer/sequencer_edit.c b/source/blender/editors/space_sequencer/sequencer_edit.c
index ddc9ba2e0f6..f78b602ceda 100644
--- a/source/blender/editors/space_sequencer/sequencer_edit.c
+++ b/source/blender/editors/space_sequencer/sequencer_edit.c
@@ -96,7 +96,7 @@ bool ED_space_sequencer_maskedit_mask_poll(bContext *C)
 bool ED_space_sequencer_check_show_maskedit(SpaceSeq *sseq, Scene *scene)
 {
   if (sseq && sseq->mainb == SEQ_DRAW_IMG_IMBUF) {
-    return (BKE_sequencer_mask_get(scene) != NULL);
+    return (SEQ_active_mask_get(scene) != NULL);
   }
 
   return false;
@@ -136,14 +136,14 @@ bool ED_space_sequencer_check_show_strip(SpaceSeq *sseq)
 /* Operator functions. */
 bool sequencer_edit_poll(bContext *C)
 {
-  return (BKE_sequencer_editing_get(CTX_data_scene(C), false) != NULL);
+  return (SEQ_editing_get(CTX_data_scene(C), false) != NULL);
 }
 
 #if 0 /* UNUSED */
 bool sequencer_strip_poll(bContext *C)
 {
   Editing *ed;
-  return (((ed = BKE_sequencer_editing_get(CTX_data_scene(C), false)) != NULL) &&
+  return (((ed = SEQ_editing_get(CTX_data_scene(C), false)) != NULL) &&
           (ed->act_seq != NULL));
 }
 #endif
@@ -152,14 +152,14 @@ bool sequencer_strip_has_path_poll(bContext *C)
 {
   Editing *ed;
   Sequence *seq;
-  return (((ed = BKE_sequencer_editing_get(CTX_data_scene(C), false)) != NULL) &&
+  return (((ed = SEQ_editing_get(CTX_data_scene(C), false)) != NULL) &&
           ((seq = ed->act_seq) != NULL) && (SEQ_HAS_PATH(seq)));
 }
 
 bool sequencer_view_preview_poll(bContext *C)
 {
   SpaceSeq *sseq = CTX_wm_space_seq(C);
-  Editing *ed = BKE_sequencer_editing_get(CTX_data_scene(C), false);
+  Editing *ed = SEQ_editing_get(CTX_data_scene(C), false);
   if (ed && sseq && (sseq->mainb == SEQ_DRAW_IMG_IMBUF)) {
     return 1;
   }
@@ -187,7 +187,7 @@ static int sequencer_gap_remove_exec(bContext *C, wmOperator *op)
 {
   Scene *scene = CTX_data_scene(C);
   const bool do_all = RNA_boolean_get(op->ptr, "all");
-  const Editing *ed = BKE_sequencer_editing_get(scene, false);
+  const Editing *ed = SEQ_editing_get(scene, false);
 
   SEQ_edit_remove_gaps(scene, ed->seqbasep, CFRA, do_all);
 
@@ -227,8 +227,8 @@ static int sequencer_gap_insert_exec(bContext *C, wmOperator *op)
 {
   Scene *scene = CTX_data_scene(C);
   const int frames = RNA_int_get(op->ptr, "frames");
-  const Editing *ed = BKE_sequencer_editing_get(scene, false);
-  SEQ_offset_after_frame(scene, ed->seqbasep, frames, CFRA);
+  const Editing *ed = SEQ_editing_get(scene, false);
+  SEQ_transform_offset_after_frame(scene, ed->seqbasep, frames, CFRA);
 
   WM_event_add_notifier(C, NC_SCENE | ND_SEQUENCER, scene);
 
@@ -273,7 +273,7 @@ static int sequencer_snap_exec(bContext *C, wmOperator *op)
 {
   Scene *scene = CTX_data_scene(C);
 
-  Editing *ed = BKE_sequencer_editing_get(scene, false);
+  Editing *ed = SEQ_editing_get(scene, false);
   Sequence *seq;
   int snap_frame;
 
@@ -282,22 +282,22 @@ static int sequencer_snap_exec(bContext *C, wmOperator *op)
   /* Check metas. */
   for (seq = ed->seqbasep->first; seq; seq = seq->next) {
     if (seq->flag & SELECT && !(seq->depth == 0 && seq->flag & SEQ_LOCK) &&
-        BKE_sequence_tx_test(seq)) {
+        SEQ_transform_sequence_can_be_translated(seq)) {
       if ((seq->flag & (SEQ_LEFTSEL + SEQ_RIGHTSEL)) == 0) {
-        BKE_sequence_translate(
+        SEQ_transform_translate_sequence(
             scene, seq, (snap_frame - seq->startofs + seq->startstill) - seq->start);
       }
       else {
         if (seq->flag & SEQ_LEFTSEL) {
-          BKE_sequence_tx_set_final_left(seq, snap_frame);
+          SEQ_transform_set_left_handle_frame(seq, snap_frame);
         }
         else { /* SEQ_RIGHTSEL */
-          BKE_sequence_tx_set_final_right(seq, snap_frame);
+          SEQ_transform_set_right_handle_frame(seq, snap_frame);
         }
-        BKE_sequence_tx_handle_xlimits(seq, seq->flag & SEQ_LEFTSEL, seq->flag & SEQ_RIGHTSEL);
-        BKE_sequence_single_fix(seq);
+        SEQ_transform_handle_xlimits(seq, seq->flag & SEQ_LEFTSEL, seq->flag & SEQ_RIGHTSEL);
+        SEQ_transform_fix_single_image_seq_offsets(seq);
       }
-      BKE_sequence_calc(scene, seq);
+      SEQ_time_update_sequence(scene, seq);
     }
   }
 
@@ -306,8 +306,8 @@ static int sequencer_snap_exec(bContext *C, wmOperator *op)
   for (seq = ed->seqbasep->first; seq; seq = seq->next) {
     if (seq->flag & SELECT && !(seq->depth == 0 && seq->flag & SEQ_LOCK)) {
       seq->flag &= ~SEQ_OVERLAP;
-      if (BKE_sequence_test_overlap(ed->seqbasep, seq)) {
-        BKE_sequence_base_shuffle(ed->seqbasep, seq, scene);
+      if (SEQ_transform_test_overlap(ed->seqbasep, seq)) {
+        SEQ_transform_seqbase_shuffle(ed->seqbasep, seq, scene);
       }
     }
   }
@@ -316,21 +316,21 @@ static int sequencer_snap_exec(bContext *C, wmOperator *op)
   for (seq = ed->seqbasep->first; seq; seq = seq->next) {
     if (seq->type & SEQ_TYPE_EFFECT) {
       if (seq->seq1 && (seq->seq1->flag & SELECT)) {
-        BKE_sequencer_offset_animdata(scene, seq, (snap_frame - seq->startdisp));
-        BKE_sequence_calc(scene, seq);
+        SEQ_offset_animdata(scene, seq, (snap_frame - seq->startdisp));
+        SEQ_time_update_sequence(scene, seq);
       }
       else if (seq->seq2 && (seq->seq2->flag & SELECT)) {
-        BKE_sequencer_offset_animdata(scene, seq, (snap_frame - seq->startdisp));
-        BKE_sequence_calc(scene, seq);
+        SEQ_offset_animdata(scene, seq, (snap_frame - seq->startdisp));
+        SEQ_time_update_sequence(scene, seq);
       }
       else if (seq->seq3 && (seq->seq3->flag & SELECT)) {
-        BKE_sequencer_offset_animdata(scene, seq, (snap_frame - seq->startdisp));
-        BKE_sequence_calc(scene, seq);
+        SEQ_offset_animdata(scene, seq, (snap_frame - seq->startdisp));
+        SEQ_time_update_sequence(scene, seq);
       }
     }
   }
 
-  BKE_sequencer_sort(scene);
+  SEQ_sort(scene);
 
   DEG_id_tag_update(&scene->id, ID_RECALC_SEQUENCER_STRIPS);
   WM_event_add_notifier(C, NC_SCENE | ND_SEQUENCER, scene);
@@ -470,7 +470,7 @@ static int sequencer_slip_invoke(bContext *C, wmOperator *op, const wmEvent *eve
 {
   SlipData *data;
   Scene *scene = CTX_data_scene(C);
-  Editing *ed = BKE_sequencer_editing_get(scene, false);
+  Editing *ed = SEQ_editing_get(scene, false);
   float mouseloc[2];
   int num_seq;
   View2D *v2d = UI_view2d_fromcontext(C);
@@ -518,7 +518,7 @@ static int sequencer_slip_invoke(bContext *C, wmOperator *op, const wmEvent *eve
 static bool sequencer_slip_recursively(Scene *scene, SlipData *data, int offset)
 {
   /* Only data types supported for now. */
-  Editing *ed = BKE_sequencer_editing_get(scene, false);
+  Editing *ed = SEQ_editing_get(scene, false);
   bool changed = false;
 
   /* Iterate in reverse so meta-strips are iterated after their children. */
@@ -568,11 +568,11 @@ static bool sequencer_slip_recursively(Scene *scene, SlipData *data, int offset)
      * we can skip calculating for effects.
      * This way we can avoid an extra loop just for effects. */
     if (!(seq->type & SEQ_TYPE_EFFECT)) {
-      BKE_sequence_calc(scene, seq);
+      SEQ_time_update_sequence(scene, seq);
     }
   }
   if (changed) {
-    BKE_sequencer_free_imbuf(scene, &ed->seqbase, false);
+    SEQ_relations_free_imbuf(scene, &ed->seqbase, false);
   }
   return changed;
 }
@@ -602,7 +602,7 @@ static void sequencer_slip_apply_limits(SlipData *data, int *offset)
 static int sequencer_slip_exec(bContext *C, wmOperator *op)
 {
   Scene *scene = CTX_data_scene(C);
-  Editing *ed = BKE_sequencer_editing_get(scene, false);
+  Editing *ed = SEQ_editing_get(scene, false);
   int offset = RNA_int_get(op->ptr, "offset");
   bool success = false;
 
@@ -737,7 +737,7 @@ static int sequencer_slip_modal(bContext *C, wmOperator *op, const wmEvent *even
 
     case EVT_ESCKEY:
     case RIGHTMOUSE: {
-      Editing *ed = BKE_sequencer_editing_get(scene, false);
+      Editing *ed = SEQ_editing_get(scene, false);
 
       for (int i = 0; i < data->num_seq; i++) {
         transseq_restore(data->ts + i, data->seq_array[i]);
@@ -745,8 +745,8 @@ static int sequencer_slip_modal(bContext *C, wmOperator *op, const wmEvent *even
 
       for (int i = 0; i < data->num_seq; i++) {
         Sequence *seq = data->seq_array[i];
-        BKE_sequence_reload_new_file(bmain, scene, seq, false);
-        BKE_sequence_calc(scene, seq);
+        SEQ_add_reload_new_file(bmain, scene, seq, false);
+        SEQ_time_update_sequence(scene, seq);
       }
 
       MEM_freeN(data->seq_array);
@@ -757,7 +757,7 @@ static int sequencer_slip_modal(bContext *C, wmOperator *op, const wmEvent *even
 
       WM_event_add_notifier(C, NC_SCENE | ND_SEQUENCER, scene);
 
-      BKE_sequencer_free_imbuf(scene, &ed->seqbase, false);
+      SEQ_relations_free_imbuf(scene, &ed->seqbase, false);
 
       if (area) {
         ED_area_status_text(area, NULL);
@@ -839,7 +839,7 @@ void SEQUENCER_OT_slip(struct wmOperatorType *ot)
 static int sequencer_mute_exec(bContext *C, wmOperator *op)
 {
   Scene *scene = CTX_data_scene(C);
-  Editing *ed = BKE_sequencer_editing_get(scene, false);
+  Editing *ed = SEQ_editing_get(scene, false);
   Sequence *seq;
   bool selected;
 
@@ -850,13 +850,13 @@ static int sequencer_mute_exec(bContext *C, wmOperator *op)
       if (selected) {
         if (seq->flag & SELECT) {
           seq->flag |= SEQ_MUTE;
-          BKE_sequence_invalidate_dependent(scene, seq);
+          SEQ_relations_invalidate_dependent(scene, seq);
         }
       }
       else {
         if ((seq->flag & SELECT) == 0) {
           seq->flag |= SEQ_MUTE;
-          BKE_sequence_invalidate_dependent(scene, seq);
+          SEQ_relations_invalidate_dependent(scene, seq);
         }
       }
     }
@@ -895,7 +895,7 @@ void SEQUENCER_OT_mute(struct wmOperatorType *ot)
 static int sequencer_unmute_exec(bContext *C, wmOperator *op)
 {
   Scene *scene = CTX_data_scene(C);
-  Editing *ed = BKE_sequencer_editing_get(scene, false);
+  Editing *ed = SEQ_editing_get(scene, false);
   Sequence *seq;
   bool selected;
 
@@ -906,13 +906,13 @@ static int sequencer_unmute_exec(bContext *C, wmOperator *op)
       if (selected) {
         if (seq->flag & SELECT) {
           seq->flag &= ~SEQ_MUTE;
-          BKE_sequence_invalidate_dependent(scene, seq);
+          SEQ_relations_invalidate_dependent(scene, seq);
         }
       }
       else {
         if ((seq->flag & SELECT) == 0) {
           seq->flag &= ~SEQ_MUTE;
-          BKE_sequence_invalidate_dependent(scene, seq);
+          SEQ_relations_invalidate_dependent(scene, seq);
         }
       }
     }
@@ -951,7 +951,7 @@ void SEQUENCER_OT_unmute(struct wmOperatorType *ot)
 static int sequencer_lock_exec(bContext *C, wmOperator *UNUSED(op))
 {
   Scene *scene = CTX_data_scene(C);
-  Editing *ed = BKE_sequencer_editing_get(scene, false);
+  Editing *ed = SEQ_editing_get(scene, false);
   Sequence *seq;
 
   for (seq = ed->seqbasep->first; seq; seq = seq->next) {
@@ -989,7 +989,7 @@ void SEQUENCER_OT_lock(struct wmOperatorType *ot)
 static int sequencer_unlock_exec(bContext *C, wmOperator *UNUSED(op))
 {
   Scene *scene = CTX_data_scene(C);
-  Editing *ed = BKE_sequencer_editing_get(scene, false);
+  Editing *ed = SEQ_editing_get(scene, false);
   Sequence *seq;
 
   for (seq = ed->seqbasep->first; seq; seq = seq->next) {
@@ -1028,18 +1028,18 @@ static int sequencer_reload_exec(bContext *C, wmOperator *op)
 {
   Main *bmain = CTX_data_main(C);
   Scene *scene = CTX_data_scene(C);
-  Editing *ed = BKE_sequencer_editing_get(scene, false);
+  Editing *ed = SEQ_editing_get(scene, false);
   Sequence *seq;
   const bool adjust_length = RNA_boolean_get(op->ptr, "adjust_length");
 
   for (seq = ed->seqbasep->first; seq; seq = seq->next) {
     if (seq->flag & SELECT) {
-      BKE_sequencer_update_changed_seq_and_deps(scene, seq, 0, 1);
-      BKE_sequence_reload_new_file(bmain, scene, seq, !adjust_length);
+      SEQ_relations_update_changed_seq_and_deps(scene, seq, 0, 1);
+      SEQ_add_reload_new_file(bmain, scene, seq, !adjust_length);
 
       if (adjust_length) {
-        if (BKE_sequence_test_overlap(ed->seqbasep, seq)) {
-          BKE_sequence_base_shuffle(ed->seqbasep, seq, scene);
+        if (SEQ_transform_test_overlap(ed->seqbasep, seq)) {
+          SEQ_transform_seqbase_shuffle(ed->seqbasep, seq, scene);
         }
       }
     }
@@ -1091,9 +1091,9 @@ static bool sequencer_refresh_all_poll(bContext *C)
 static int sequencer_refresh_all_exec(bContext *C, wmOperator *UNUSED(op))
 {
   Scene *scene = CTX_data_scene(C);
-  Editing *ed = BKE_sequencer_editing_get(scene, false);
+  Editing *ed = SEQ_editing_get(scene, false);
 
-  BKE_sequencer_free_imbuf(scene, &ed->seqbase, false);
+  SEQ_relations_free_imbuf(scene, &ed->seqbase, false);
 
   WM_event_add_notifier(C, NC_SCENE | ND_SEQUENCER, scene);
 
@@ -1126,18 +1126,18 @@ int seq_effect_find_selected(Scene *scene,
                              Sequence **r_selseq3,
                              const char **r_error_str)
 {
-  Editing *ed = BKE_sequencer_editing_get(scene, false);
+  Editing *ed = SEQ_editing_get(scene, false);
   Sequence *seq1 = NULL, *seq2 = NULL, *seq3 = NULL, *seq;
 
   *r_error_str = NULL;
 
   if (!activeseq) {
-    seq2 = BKE_sequencer_active_get(scene);
+    seq2 = SEQ_select_active_get(scene);
   }
 
   for (seq = ed->seqbasep->first; seq; seq = seq->next) {
     if (seq->flag & SELECT) {
-      if (seq->type == SEQ_TYPE_SOUND_RAM && BKE_sequence_effect_get_num_inputs(type) != 0) {
+      if (seq->type == SEQ_TYPE_SOUND_RAM && SEQ_effect_get_num_inputs(type) != 0) {
         *r_error_str = N_("Cannot apply effects to audio sequence strips");
         return 0;
       }
@@ -1167,7 +1167,7 @@ int seq_effect_find_selected(Scene *scene,
     seq3 = tmp;
   }
 
-  switch (BKE_sequence_effect_get_num_inputs(type)) {
+  switch (SEQ_effect_get_num_inputs(type)) {
     case 0:
       *r_selseq1 = *r_selseq2 = *r_selseq3 = NULL;
       return 1; /* Success. */
@@ -1204,10 +1204,10 @@ int seq_effect_find_selected(Scene *scene,
   *r_selseq3 = seq3;
 
   /* TODO(Richard): This function needs some refactoring, this is just quick hack for T73828. */
-  if (BKE_sequence_effect_get_num_inputs(type) < 3) {
+  if (SEQ_effect_get_num_inputs(type) < 3) {
     *r_selseq3 = NULL;
   }
-  if (BKE_sequence_effect_get_num_inputs(type) < 2) {
+  if (SEQ_effect_get_num_inputs(type) < 2) {
     *r_selseq2 = NULL;
   }
 
@@ -1217,24 +1217,24 @@ int seq_effect_find_selected(Scene *scene,
 static int sequencer_reassign_inputs_exec(bContext *C, wmOperator *op)
 {
   Scene *scene = CTX_data_scene(C);
-  Sequence *seq1, *seq2, *seq3, *last_seq = BKE_sequencer_active_get(scene);
+  Sequence *seq1, *seq2, *seq3, *last_seq = SEQ_select_active_get(scene);
   const char *error_msg;
 
-  if (BKE_sequence_effect_get_num_inputs(last_seq->type) == 0) {
+  if (SEQ_effect_get_num_inputs(last_seq->type) == 0) {
     BKE_report(op->reports, RPT_ERROR, "Cannot reassign inputs: strip has no inputs");
     return OPERATOR_CANCELLED;
   }
 
   if (!seq_effect_find_selected(
           scene, last_seq, last_seq->type, &seq1, &seq2, &seq3, &error_msg) ||
-      BKE_sequence_effect_get_num_inputs(last_seq->type) == 0) {
+      SEQ_effect_get_num_inputs(last_seq->type) == 0) {
     BKE_report(op->reports, RPT_ERROR, error_msg);
     return OPERATOR_CANCELLED;
   }
   /* Check if reassigning would create recursivity. */
-  if (BKE_sequencer_render_loop_check(seq1, last_seq) ||
-      BKE_sequencer_render_loop_check(seq2, last_seq) ||
-      BKE_sequencer_render_loop_check(seq3, last_seq)) {
+  if (SEQ_relations_render_loop_check(seq1, last_seq) ||
+      SEQ_relations_render_loop_check(seq2, last_seq) ||
+      SEQ_relations_render_loop_check(seq3, last_seq)) {
     BKE_report(op->reports, RPT_ERROR, "Cannot reassign inputs: recursion detected");
     return OPERATOR_CANCELLED;
   }
@@ -1243,7 +1243,7 @@ static int sequencer_reassign_inputs_exec(bContext *C, wmOperator *op)
   last_seq->seq2 = seq2;
   last_seq->seq3 = seq3;
 
-  BKE_sequencer_update_changed_seq_and_deps(scene, last_seq, 1, 1);
+  SEQ_relations_update_changed_seq_and_deps(scene, last_seq, 1, 1);
 
   WM_event_add_notifier(C, NC_SCENE | ND_SEQUENCER, scene);
 
@@ -1253,10 +1253,10 @@ static int sequencer_reassign_inputs_exec(bContext *C, wmOperator *op)
 static bool sequencer_effect_poll(bContext *C)
 {
   Scene *scene = CTX_data_scene(C);
-  Editing *ed = BKE_sequencer_editing_get(scene, false);
+  Editing *ed = SEQ_editing_get(scene, false);
 
   if (ed) {
-    Sequence *last_seq = BKE_sequencer_active_get(scene);
+    Sequence *last_seq = SEQ_select_active_get(scene);
     if (last_seq && (last_seq->type & SEQ_TYPE_EFFECT)) {
       return 1;
     }
@@ -1289,7 +1289,7 @@ void SEQUENCER_OT_reassign_inputs(struct wmOperatorType *ot)
 static int sequencer_swap_inputs_exec(bContext *C, wmOperator *op)
 {
   Scene *scene = CTX_data_scene(C);
-  Sequence *seq, *last_seq = BKE_sequencer_active_get(scene);
+  Sequence *seq, *last_seq = SEQ_select_active_get(scene);
 
   if (last_seq->seq1 == NULL || last_seq->seq2 == NULL) {
     BKE_report(op->reports, RPT_ERROR, "No valid inputs to swap");
@@ -1300,7 +1300,7 @@ static int sequencer_swap_inputs_exec(bContext *C, wmOperator *op)
   last_seq->seq1 = last_seq->seq2;
   last_seq->seq2 = seq;
 
-  BKE_sequencer_update_changed_seq_and_deps(scene, last_seq, 1, 1);
+  SEQ_relations_update_changed_seq_and_deps(scene, last_seq, 1, 1);
 
   WM_event_add_notifier(C, NC_SCENE | ND_SEQUENCER, scene);
 
@@ -1360,7 +1360,7 @@ static int sequencer_split_exec(bContext *C, wmOperator *op)
 {
   Main *bmain = CTX_data_main(C);
   Scene *scene = CTX_data_scene(C);
-  Editing *ed = BKE_sequencer_editing_get(scene, false);
+  Editing *ed = SEQ_editing_get(scene, false);
   bool changed = false;
   bool seq_selected = false;
 
@@ -1371,7 +1371,7 @@ static int sequencer_split_exec(bContext *C, wmOperator *op)
   const int split_side = RNA_enum_get(op->ptr, "side");
   const bool ignore_selection = RNA_boolean_get(op->ptr, "ignore_selection");
 
-  BKE_sequencer_prefetch_stop(scene);
+  SEQ_prefetch_stop(scene);
 
   LISTBASE_FOREACH_BACKWARD (Sequence *, seq, ed->seqbasep) {
     if (use_cursor_position && seq->machine != split_channel) {
@@ -1423,7 +1423,7 @@ static int sequencer_split_exec(bContext *C, wmOperator *op)
       }
     }
 
-    BKE_sequencer_sort(scene);
+    SEQ_sort(scene);
   }
   if (changed) {
     WM_event_add_notifier(C, NC_SCENE | ND_SEQUENCER, scene);
@@ -1566,15 +1566,15 @@ static int apply_unique_name_fn(Sequence *seq, void *arg_pt)
   char name[sizeof(seq->name) - 2];
 
   BLI_strncpy_utf8(name, seq->name + 2, sizeof(name));
-  BKE_sequence_base_unique_name_recursive(&scene->ed->seqbase, seq);
-  BKE_sequencer_dupe_animdata(scene, name, seq->name + 2);
+  SEQ_sequence_base_unique_name_recursive(&scene->ed->seqbase, seq);
+  SEQ_dupe_animdata(scene, name, seq->name + 2);
   return 1;
 }
 
 static int sequencer_add_duplicate_exec(bContext *C, wmOperator *UNUSED(op))
 {
   Scene *scene = CTX_data_scene(C);
-  Editing *ed = BKE_sequencer_editing_get(scene, false);
+  Editing *ed = SEQ_editing_get(scene, false);
 
   ListBase nseqbase = {NULL, NULL};
 
@@ -1582,16 +1582,16 @@ static int sequencer_add_duplicate_exec(bContext *C, wmOperator *UNUSED(op))
     return OPERATOR_CANCELLED;
   }
 
-  BKE_sequence_base_dupli_recursive(scene, scene, &nseqbase, ed->seqbasep, SEQ_DUPE_CONTEXT, 0);
+  SEQ_sequence_base_dupli_recursive(scene, scene, &nseqbase, ed->seqbasep, SEQ_DUPE_CONTEXT, 0);
 
   if (nseqbase.first) {
     Sequence *seq = nseqbase.first;
     /* Rely on the nseqbase list being added at the end.
-     * Their UUIDs has been re-generated by the BKE_sequence_base_dupli_recursive(), */
+     * Their UUIDs has been re-generated by the SEQ_sequence_base_dupli_recursive(), */
     BLI_movelisttolist(ed->seqbasep, &nseqbase);
 
     for (; seq; seq = seq->next) {
-      BKE_sequencer_recursive_apply(seq, apply_unique_name_fn, scene);
+      SEQ_iterator_recursive_apply(seq, apply_unique_name_fn, scene);
     }
 
     WM_event_add_notifier(C, NC_SCENE | ND_SEQUENCER, scene);
@@ -1626,18 +1626,18 @@ static int sequencer_delete_exec(bContext *C, wmOperator *UNUSED(op))
 {
   Main *bmain = CTX_data_main(C);
   Scene *scene = CTX_data_scene(C);
-  Editing *ed = BKE_sequencer_editing_get(scene, false);
+  Editing *ed = SEQ_editing_get(scene, false);
   Sequence *seq;
 
-  BKE_sequencer_prefetch_stop(scene);
+  SEQ_prefetch_stop(scene);
 
   SEQ_CURRENT_BEGIN (scene->ed, seq) {
     if (seq->flag & SELECT) {
-      BKE_sequencer_flag_for_removal(scene, ed->seqbasep, seq);
+      SEQ_edit_flag_for_removal(scene, ed->seqbasep, seq);
     }
   }
   SEQ_CURRENT_END;
-  BKE_sequencer_remove_flagged_sequences(scene, ed->seqbasep);
+  SEQ_edit_remove_flagged_sequences(scene, ed->seqbasep);
 
   DEG_id_tag_update(&scene->id, ID_RECALC_SEQUENCER_STRIPS);
   DEG_relations_tag_update(bmain);
@@ -1687,7 +1687,7 @@ void SEQUENCER_OT_delete(wmOperatorType *ot)
 static int sequencer_offset_clear_exec(bContext *C, wmOperator *UNUSED(op))
 {
   Scene *scene = CTX_data_scene(C);
-  Editing *ed = BKE_sequencer_editing_get(scene, false);
+  Editing *ed = SEQ_editing_get(scene, false);
   Sequence *seq;
 
   /* For effects, try to find a replacement input. */
@@ -1700,14 +1700,14 @@ static int sequencer_offset_clear_exec(bContext *C, wmOperator *UNUSED(op))
   /* Update lengths, etc. */
   seq = ed->seqbasep->first;
   while (seq) {
-    BKE_sequence_calc(scene, seq);
+    SEQ_time_update_sequence(scene, seq);
     seq = seq->next;
   }
 
   for (seq = ed->seqbasep->first; seq; seq = seq->next) {
     if ((seq->type & SEQ_TYPE_EFFECT) == 0 && (seq->flag & SELECT)) {
-      if (BKE_sequence_test_overlap(ed->seqbasep, seq)) {
-        BKE_sequence_base_shuffle(ed->seqbasep, seq, scene);
+      if (SEQ_transform_test_overlap(ed->seqbasep, seq)) {
+        SEQ_transform_seqbase_shuffle(ed->seqbasep, seq, scene);
       }
     }
   }
@@ -1742,7 +1742,7 @@ void SEQUENCER_OT_offset_clear(wmOperatorType *ot)
 static int sequencer_separate_images_exec(bContext *C, wmOperator *op)
 {
   Scene *scene = CTX_data_scene(C);
-  Editing *ed = BKE_sequencer_editing_get(scene, false);
+  Editing *ed = SEQ_editing_get(scene, false);
 
   Sequence *seq, *seq_new;
   Strip *strip_new;
@@ -1752,7 +1752,7 @@ static int sequencer_separate_images_exec(bContext *C, wmOperator *op)
 
   seq = ed->seqbasep->first; /* Poll checks this is valid. */
 
-  BKE_sequencer_prefetch_stop(scene);
+  SEQ_prefetch_stop(scene);
 
   while (seq) {
     if ((seq->flag & SELECT) && (seq->type == SEQ_TYPE_IMAGE) && (seq->len > 1)) {
@@ -1764,14 +1764,14 @@ static int sequencer_separate_images_exec(bContext *C, wmOperator *op)
       /* if (seq->ipo) id_us_min(&seq->ipo->id); */
       /* XXX, remove fcurve and assign to split image strips */
 
-      start_ofs = timeline_frame = BKE_sequence_tx_get_final_left(seq, false);
-      frame_end = BKE_sequence_tx_get_final_right(seq, false);
+      start_ofs = timeline_frame = SEQ_transform_get_left_handle_frame(seq, false);
+      frame_end = SEQ_transform_get_right_handle_frame(seq, false);
 
       while (timeline_frame < frame_end) {
         /* New seq. */
         se = SEQ_render_give_stripelem(seq, timeline_frame);
 
-        seq_new = BKE_sequence_dupli_recursive(
+        seq_new = SEQ_sequence_dupli_recursive(
             scene, scene, ed->seqbasep, seq, SEQ_DUPE_UNIQUE_NAME);
 
         seq_new->start = start_ofs;
@@ -1790,12 +1790,12 @@ static int sequencer_separate_images_exec(bContext *C, wmOperator *op)
         BLI_strncpy(se_new->name, se->name, sizeof(se_new->name));
         strip_new->stripdata = se_new;
 
-        BKE_sequence_calc(scene, seq_new);
+        SEQ_time_update_sequence(scene, seq_new);
 
         if (step > 1) {
           seq_new->flag &= ~SEQ_OVERLAP;
-          if (BKE_sequence_test_overlap(ed->seqbasep, seq_new)) {
-            BKE_sequence_base_shuffle(ed->seqbasep, seq_new, scene);
+          if (SEQ_transform_test_overlap(ed->seqbasep, seq_new)) {
+            SEQ_transform_seqbase_shuffle(ed->seqbasep, seq_new, scene);
           }
         }
 
@@ -1806,7 +1806,7 @@ static int sequencer_separate_images_exec(bContext *C, wmOperator *op)
       }
 
       seq_next = seq->next;
-      BKE_sequence_free(scene, seq, true);
+      SEQ_sequence_free(scene, seq, true);
       seq = seq_next;
     }
     else {
@@ -1814,7 +1814,7 @@ static int sequencer_separate_images_exec(bContext *C, wmOperator *op)
     }
   }
 
-  BKE_sequencer_sort(scene);
+  SEQ_sort(scene);
 
   WM_event_add_notifier(C, NC_SCENE | ND_SEQUENCER, scene);
 
@@ -1873,8 +1873,8 @@ void recurs_sel_seq(Sequence *seqm)
 static int sequencer_meta_toggle_exec(bContext *C, wmOperator *UNUSED(op))
 {
   Scene *scene = CTX_data_scene(C);
-  Editing *ed = BKE_sequencer_editing_get(scene, false);
-  Sequence *last_seq = BKE_sequencer_active_get(scene);
+  Editing *ed = SEQ_editing_get(scene, false);
+  Sequence *last_seq = SEQ_select_active_get(scene);
   MetaStack *ms;
 
   if (last_seq && last_seq->type == SEQ_TYPE_META && last_seq->flag & SELECT) {
@@ -1887,7 +1887,7 @@ static int sequencer_meta_toggle_exec(bContext *C, wmOperator *UNUSED(op))
 
     ed->seqbasep = &last_seq->seqbase;
 
-    BKE_sequencer_active_set(scene, NULL);
+    SEQ_select_active_set(scene, NULL);
   }
   else {
     /* Exit metastrip if possible. */
@@ -1910,23 +1910,23 @@ static int sequencer_meta_toggle_exec(bContext *C, wmOperator *UNUSED(op))
 
     /* Recalc all: the meta can have effects connected to it. */
     for (seq = ed->seqbasep->first; seq; seq = seq->next) {
-      BKE_sequence_calc(scene, seq);
+      SEQ_time_update_sequence(scene, seq);
     }
 
     /* 2.73+, keeping endpoints is important!
      * Moving them around means you can't usefully use metas in a complex edit. */
 #if 1
-    BKE_sequence_tx_set_final_left(ms->parseq, ms->disp_range[0]);
-    BKE_sequence_tx_set_final_right(ms->parseq, ms->disp_range[1]);
-    BKE_sequence_single_fix(ms->parseq);
-    BKE_sequence_calc(scene, ms->parseq);
+    SEQ_transform_set_left_handle_frame(ms->parseq, ms->disp_range[0]);
+    SEQ_transform_set_right_handle_frame(ms->parseq, ms->disp_range[1]);
+    SEQ_transform_fix_single_image_seq_offsets(ms->parseq);
+    SEQ_time_update_sequence(scene, ms->parseq);
 #else
-    if (BKE_sequence_test_overlap(ed->seqbasep, ms->parseq)) {
-      BKE_sequence_base_shuffle(ed->seqbasep, ms->parseq, scene);
+    if (SEQ_transform_test_overlap(ed->seqbasep, ms->parseq)) {
+      SEQ_transform_seqbase_shuffle(ed->seqbasep, ms->parseq, scene);
     }
 #endif
 
-    BKE_sequencer_active_set(scene, ms->parseq);
+    SEQ_select_active_set(scene, ms->parseq);
 
     ms->parseq->flag |= SELECT;
     recurs_sel_seq(ms->parseq);
@@ -1964,21 +1964,21 @@ void SEQUENCER_OT_meta_toggle(wmOperatorType *ot)
 static int sequencer_meta_make_exec(bContext *C, wmOperator *op)
 {
   Scene *scene = CTX_data_scene(C);
-  Editing *ed = BKE_sequencer_editing_get(scene, false);
+  Editing *ed = SEQ_editing_get(scene, false);
 
-  Sequence *seq, *seqm, *next, *last_seq = BKE_sequencer_active_get(scene);
+  Sequence *seq, *seqm, *next, *last_seq = SEQ_select_active_get(scene);
   int channel_max = 1;
 
-  if (BKE_sequence_base_isolated_sel_check(ed->seqbasep) == false) {
+  if (SEQ_transform_seqbase_isolated_sel_check(ed->seqbasep) == false) {
     BKE_report(op->reports, RPT_ERROR, "Please select all related strips");
     return OPERATOR_CANCELLED;
   }
 
-  BKE_sequencer_prefetch_stop(scene);
+  SEQ_prefetch_stop(scene);
 
   /* Remove all selected from main list, and put in meta. */
 
-  seqm = BKE_sequence_alloc(ed->seqbasep, 1, 1, SEQ_TYPE_META); /* Channel number set later. */
+  seqm = SEQ_sequence_alloc(ed->seqbasep, 1, 1, SEQ_TYPE_META); /* Channel number set later. */
   strcpy(seqm->name + 2, "MetaStrip");
   seqm->flag = SELECT;
 
@@ -1986,7 +1986,7 @@ static int sequencer_meta_make_exec(bContext *C, wmOperator *op)
   while (seq) {
     next = seq->next;
     if (seq != seqm && (seq->flag & SELECT)) {
-      BKE_sequence_invalidate_cache_composite(scene, seq);
+      SEQ_relations_invalidate_cache_composite(scene, seq);
       channel_max = max_ii(seq->machine, channel_max);
       /* Sequence is moved within the same edit, no need to re-generate the UUID. */
       BLI_remlink(ed->seqbasep, seq);
@@ -1995,18 +1995,18 @@ static int sequencer_meta_make_exec(bContext *C, wmOperator *op)
     seq = next;
   }
   seqm->machine = last_seq ? last_seq->machine : channel_max;
-  BKE_sequence_calc(scene, seqm);
+  SEQ_time_update_sequence(scene, seqm);
 
-  BKE_sequencer_active_set(scene, seqm);
+  SEQ_select_active_set(scene, seqm);
 
-  if (BKE_sequence_test_overlap(ed->seqbasep, seqm)) {
-    BKE_sequence_base_shuffle(ed->seqbasep, seqm, scene);
+  if (SEQ_transform_test_overlap(ed->seqbasep, seqm)) {
+    SEQ_transform_seqbase_shuffle(ed->seqbasep, seqm, scene);
   }
 
   DEG_id_tag_update(&scene->id, ID_RECALC_SEQUENCER_STRIPS);
 
-  BKE_sequence_base_unique_name_recursive(&scene->ed->seqbase, seqm);
-  BKE_sequence_invalidate_cache_composite(scene, seqm);
+  SEQ_sequence_base_unique_name_recursive(&scene->ed->seqbase, seqm);
+  SEQ_relations_invalidate_cache_composite(scene, seqm);
   WM_event_add_notifier(C, NC_SCENE | ND_SEQUENCER, scene);
 
   return OPERATOR_FINISHED;
@@ -2053,7 +2053,7 @@ static int seq_depends_on_meta(Sequence *seq, Sequence *seqm)
 static void recurs_del_seq_flag(Scene *scene, ListBase *lb, short flag, short deleteall)
 {
   Sequence *seq, *seqn;
-  Sequence *last_seq = BKE_sequencer_active_get(scene);
+  Sequence *last_seq = SEQ_select_active_get(scene);
 
   seq = lb->first;
   while (seq) {
@@ -2061,12 +2061,12 @@ static void recurs_del_seq_flag(Scene *scene, ListBase *lb, short flag, short de
     if ((seq->flag & flag) || deleteall) {
       BLI_remlink(lb, seq);
       if (seq == last_seq) {
-        BKE_sequencer_active_set(scene, NULL);
+        SEQ_select_active_set(scene, NULL);
       }
       if (seq->type == SEQ_TYPE_META) {
         recurs_del_seq_flag(scene, &seq->seqbase, flag, 1);
       }
-      BKE_sequence_free(scene, seq, true);
+      SEQ_sequence_free(scene, seq, true);
     }
     seq = seqn;
   }
@@ -2075,18 +2075,18 @@ static void recurs_del_seq_flag(Scene *scene, ListBase *lb, short flag, short de
 static int sequencer_meta_separate_exec(bContext *C, wmOperator *UNUSED(op))
 {
   Scene *scene = CTX_data_scene(C);
-  Editing *ed = BKE_sequencer_editing_get(scene, false);
+  Editing *ed = SEQ_editing_get(scene, false);
 
-  Sequence *seq, *last_seq = BKE_sequencer_active_get(scene); /* last_seq checks (ed == NULL) */
+  Sequence *seq, *last_seq = SEQ_select_active_get(scene); /* last_seq checks (ed == NULL) */
 
   if (last_seq == NULL || last_seq->type != SEQ_TYPE_META) {
     return OPERATOR_CANCELLED;
   }
 
-  BKE_sequencer_prefetch_stop(scene);
+  SEQ_prefetch_stop(scene);
 
   for (seq = last_seq->seqbase.first; seq != NULL; seq = seq->next) {
-    BKE_sequence_invalidate_cache_composite(scene, seq);
+    SEQ_relations_invalidate_cache_composite(scene, seq);
   }
 
   /* This moves strips from meta to parent, sating within same edit and no new strips are
@@ -2097,7 +2097,7 @@ static int sequencer_meta_separate_exec(bContext *C, wmOperator *UNUSED(op))
   BLI_listbase_clear(&last_seq->seqbase);
 
   BLI_remlink(ed->seqbasep, last_seq);
-  BKE_sequence_free(scene, last_seq, true);
+  SEQ_sequence_free(scene, last_seq, true);
 
   /* Empty meta strip, delete all effects depending on it. */
   for (seq = ed->seqbasep->first; seq; seq = seq->next) {
@@ -2113,13 +2113,13 @@ static int sequencer_meta_separate_exec(bContext *C, wmOperator *UNUSED(op))
   for (seq = ed->seqbasep->first; seq; seq = seq->next) {
     if (seq->flag & SELECT) {
       seq->flag &= ~SEQ_OVERLAP;
-      if (BKE_sequence_test_overlap(ed->seqbasep, seq)) {
-        BKE_sequence_base_shuffle(ed->seqbasep, seq, scene);
+      if (SEQ_transform_test_overlap(ed->seqbasep, seq)) {
+        SEQ_transform_seqbase_shuffle(ed->seqbasep, seq, scene);
       }
     }
   }
 
-  BKE_sequencer_sort(scene);
+  SEQ_sort(scene);
   DEG_id_tag_update(&scene->id, ID_RECALC_SEQUENCER_STRIPS);
 
   WM_event_add_notifier(C, NC_SCENE | ND_SEQUENCER, scene);
@@ -2155,7 +2155,7 @@ static bool strip_jump_internal(Scene *scene,
 {
   bool changed = false;
   int timeline_frame = CFRA;
-  int next_frame = BKE_sequencer_find_next_prev_edit(
+  int next_frame = SEQ_time_find_next_prev_edit(
       scene, timeline_frame, side, do_skip_mute, do_center, false);
 
   if (next_frame != timeline_frame) {
@@ -2230,19 +2230,19 @@ static void swap_sequence(Scene *scene, Sequence *seqa, Sequence *seqb)
   int seq_b_start;
 
   seq_b_start = (seqb->start - seqb->startdisp) + seqa->startdisp;
-  BKE_sequence_translate(scene, seqb, seq_b_start - seqb->start);
-  BKE_sequence_calc(scene, seqb);
+  SEQ_transform_translate_sequence(scene, seqb, seq_b_start - seqb->start);
+  SEQ_time_update_sequence(scene, seqb);
 
   seq_a_start = (seqa->start - seqa->startdisp) + seqb->enddisp + gap;
-  BKE_sequence_translate(scene, seqa, seq_a_start - seqa->start);
-  BKE_sequence_calc(scene, seqa);
+  SEQ_transform_translate_sequence(scene, seqa, seq_a_start - seqa->start);
+  SEQ_time_update_sequence(scene, seqa);
 }
 
 static Sequence *find_next_prev_sequence(Scene *scene, Sequence *test, int lr, int sel)
 {
   /* sel: 0==unselected, 1==selected, -1==don't care. */
   Sequence *seq, *best_seq = NULL;
-  Editing *ed = BKE_sequencer_editing_get(scene, false);
+  Editing *ed = SEQ_editing_get(scene, false);
 
   int dist, best_dist;
   best_dist = MAXFRAME * 2;
@@ -2292,8 +2292,8 @@ static bool seq_is_parent(Sequence *par, Sequence *seq)
 static int sequencer_swap_exec(bContext *C, wmOperator *op)
 {
   Scene *scene = CTX_data_scene(C);
-  Editing *ed = BKE_sequencer_editing_get(scene, false);
-  Sequence *active_seq = BKE_sequencer_active_get(scene);
+  Editing *ed = SEQ_editing_get(scene, false);
+  Sequence *active_seq = SEQ_select_active_get(scene);
   Sequence *seq, *iseq;
   int side = RNA_enum_get(op->ptr, "side");
 
@@ -2306,11 +2306,11 @@ static int sequencer_swap_exec(bContext *C, wmOperator *op)
   if (seq) {
 
     /* Disallow effect strips. */
-    if (BKE_sequence_effect_get_num_inputs(seq->type) >= 1 &&
+    if (SEQ_effect_get_num_inputs(seq->type) >= 1 &&
         (seq->effectdata || seq->seq1 || seq->seq2 || seq->seq3)) {
       return OPERATOR_CANCELLED;
     }
-    if ((BKE_sequence_effect_get_num_inputs(active_seq->type) >= 1) &&
+    if ((SEQ_effect_get_num_inputs(active_seq->type) >= 1) &&
         (active_seq->effectdata || active_seq->seq1 || active_seq->seq2 || active_seq->seq3)) {
       return OPERATOR_CANCELLED;
     }
@@ -2328,7 +2328,7 @@ static int sequencer_swap_exec(bContext *C, wmOperator *op)
     for (iseq = scene->ed->seqbasep->first; iseq; iseq = iseq->next) {
       if ((iseq->type & SEQ_TYPE_EFFECT) &&
           (seq_is_parent(iseq, active_seq) || seq_is_parent(iseq, seq))) {
-        BKE_sequence_calc(scene, iseq);
+        SEQ_time_update_sequence(scene, iseq);
       }
     }
 
@@ -2337,13 +2337,13 @@ static int sequencer_swap_exec(bContext *C, wmOperator *op)
       if ((iseq->type & SEQ_TYPE_EFFECT) &&
           (seq_is_parent(iseq, active_seq) || seq_is_parent(iseq, seq))) {
         /* This may now overlap. */
-        if (BKE_sequence_test_overlap(ed->seqbasep, iseq)) {
-          BKE_sequence_base_shuffle(ed->seqbasep, iseq, scene);
+        if (SEQ_transform_test_overlap(ed->seqbasep, iseq)) {
+          SEQ_transform_seqbase_shuffle(ed->seqbasep, iseq, scene);
         }
       }
     }
 
-    BKE_sequencer_sort(scene);
+    SEQ_sort(scene);
 
     WM_event_add_notifier(C, NC_SCENE | ND_SEQUENCER, scene);
 
@@ -2382,7 +2382,7 @@ static int sequencer_rendersize_exec(bContext *C, wmOperator *UNUSED(op))
 {
   int retval = OPERATOR_CANCELLED;
   Scene *scene = CTX_data_scene(C);
-  Sequence *active_seq = BKE_sequencer_active_get(scene);
+  Sequence *active_seq = SEQ_select_active_get(scene);
   StripElem *se = NULL;
 
   if (active_seq == NULL) {
@@ -2458,11 +2458,11 @@ static int sequencer_copy_exec(bContext *C, wmOperator *op)
 {
   Main *bmain = CTX_data_main(C);
   Scene *scene = CTX_data_scene(C);
-  Editing *ed = BKE_sequencer_editing_get(scene, false);
+  Editing *ed = SEQ_editing_get(scene, false);
 
-  BKE_sequencer_free_clipboard();
+  SEQ_clipboard_free();
 
-  if (BKE_sequence_base_isolated_sel_check(ed->seqbasep) == false) {
+  if (SEQ_transform_seqbase_isolated_sel_check(ed->seqbasep) == false) {
     BKE_report(op->reports, RPT_ERROR, "Please select all related strips");
     return OPERATOR_CANCELLED;
   }
@@ -2470,7 +2470,7 @@ static int sequencer_copy_exec(bContext *C, wmOperator *op)
   /* NOTE: The UUID is re-generated on paste, so we can keep UUID in the clipboard since
    * nobody can reach them anyway.
    * This reduces chance or running out of UUIDs if a cat falls asleep on Ctrl-C. */
-  BKE_sequence_base_dupli_recursive(scene,
+  SEQ_sequence_base_dupli_recursive(scene,
                                     scene,
                                     &seqbase_clipboard,
                                     ed->seqbasep,
@@ -2486,7 +2486,7 @@ static int sequencer_copy_exec(bContext *C, wmOperator *op)
 
   /* Replace datablock pointers with copies, to keep things working in case
    * data-blocks get deleted or another .blend file is opened. */
-  BKE_sequencer_base_clipboard_pointers_store(bmain, &seqbase_clipboard);
+  SEQ_clipboard_pointers_store(bmain, &seqbase_clipboard);
 
   return OPERATOR_FINISHED;
 }
@@ -2515,7 +2515,7 @@ void SEQUENCER_OT_copy(wmOperatorType *ot)
 void ED_sequencer_deselect_all(Scene *scene)
 {
   Sequence *seq;
-  Editing *ed = BKE_sequencer_editing_get(scene, false);
+  Editing *ed = SEQ_editing_get(scene, false);
 
   if (ed == NULL) {
     return;
@@ -2531,7 +2531,7 @@ static int sequencer_paste_exec(bContext *C, wmOperator *op)
 {
   Main *bmain = CTX_data_main(C);
   Scene *scene = CTX_data_scene(C);
-  Editing *ed = BKE_sequencer_editing_get(scene, true); /* Create if needed. */
+  Editing *ed = SEQ_editing_get(scene, true); /* Create if needed. */
   ListBase nseqbase = {NULL, NULL};
   int ofs;
   Sequence *iseq, *iseq_first;
@@ -2559,25 +2559,25 @@ static int sequencer_paste_exec(bContext *C, wmOperator *op)
   /* Copy strips, temporarily restoring pointers to actual data-blocks. This
    * must happen on the clipboard itself, so that copying does user counting
    * on the actual data-blocks. */
-  BKE_sequencer_base_clipboard_pointers_restore(&seqbase_clipboard, bmain);
-  BKE_sequence_base_dupli_recursive(scene, scene, &nseqbase, &seqbase_clipboard, 0, 0);
-  BKE_sequencer_base_clipboard_pointers_store(bmain, &seqbase_clipboard);
+  SEQ_clipboard_pointers_restore(&seqbase_clipboard, bmain);
+  SEQ_sequence_base_dupli_recursive(scene, scene, &nseqbase, &seqbase_clipboard, 0, 0);
+  SEQ_clipboard_pointers_store(bmain, &seqbase_clipboard);
 
   iseq_first = nseqbase.first;
 
-  /* NOTE: BKE_sequence_base_dupli_recursive() takes care of generating new UUIDs for sequences
+  /* NOTE: SEQ_sequence_base_dupli_recursive() takes care of generating new UUIDs for sequences
    * in the new list. */
   BLI_movelisttolist(ed->seqbasep, &nseqbase);
 
   for (iseq = iseq_first; iseq; iseq = iseq->next) {
     /* Make sure, that pasted strips have unique names. */
-    BKE_sequencer_recursive_apply(iseq, apply_unique_name_fn, scene);
+    SEQ_iterator_recursive_apply(iseq, apply_unique_name_fn, scene);
     /* Translate after name has been changed, otherwise this will affect animdata of original
      * strip. */
-    BKE_sequence_translate(scene, iseq, ofs);
+    SEQ_transform_translate_sequence(scene, iseq, ofs);
     /* Ensure, that pasted strips don't overlap. */
-    if (BKE_sequence_test_overlap(ed->seqbasep, iseq)) {
-      BKE_sequence_base_shuffle(ed->seqbasep, iseq, scene);
+    if (SEQ_transform_test_overlap(ed->seqbasep, iseq)) {
+      SEQ_transform_seqbase_shuffle(ed->seqbasep, iseq, scene);
     }
   }
 
@@ -2622,12 +2622,12 @@ static int sequencer_swap_data_exec(bContext *C, wmOperator *op)
   Sequence *seq_other;
   const char *error_msg;
 
-  if (BKE_sequencer_active_get_pair(scene, &seq_act, &seq_other) == 0) {
+  if (SEQ_select_active_get_pair(scene, &seq_act, &seq_other) == 0) {
     BKE_report(op->reports, RPT_ERROR, "Please select two strips");
     return OPERATOR_CANCELLED;
   }
 
-  if (BKE_sequence_swap(seq_act, seq_other, &error_msg) == 0) {
+  if (SEQ_edit_sequence_swap(seq_act, seq_other, &error_msg) == 0) {
     BKE_report(op->reports, RPT_ERROR, error_msg);
     return OPERATOR_CANCELLED;
   }
@@ -2643,8 +2643,8 @@ static int sequencer_swap_data_exec(bContext *C, wmOperator *op)
   seq_act->scene_sound = NULL;
   seq_other->scene_sound = NULL;
 
-  BKE_sequence_calc(scene, seq_act);
-  BKE_sequence_calc(scene, seq_other);
+  SEQ_time_update_sequence(scene, seq_act);
+  SEQ_time_update_sequence(scene, seq_other);
 
   if (seq_act->sound) {
     BKE_sound_add_scene_sound_defaults(scene, seq_act);
@@ -2653,8 +2653,8 @@ static int sequencer_swap_data_exec(bContext *C, wmOperator *op)
     BKE_sound_add_scene_sound_defaults(scene, seq_other);
   }
 
-  BKE_sequence_invalidate_cache_raw(scene, seq_act);
-  BKE_sequence_invalidate_cache_raw(scene, seq_other);
+  SEQ_relations_invalidate_cache_raw(scene, seq_act);
+  SEQ_relations_invalidate_cache_raw(scene, seq_other);
 
   WM_event_add_notifier(C, NC_SCENE | ND_SEQUENCER, scene);
 
@@ -2692,8 +2692,8 @@ static const EnumPropertyItem prop_change_effect_input_types[] = {
 static int sequencer_change_effect_input_exec(bContext *C, wmOperator *op)
 {
   Scene *scene = CTX_data_scene(C);
-  Editing *ed = BKE_sequencer_editing_get(scene, false);
-  Sequence *seq = BKE_sequencer_active_get(scene);
+  Editing *ed = SEQ_editing_get(scene, false);
+  Sequence *seq = SEQ_select_active_get(scene);
 
   Sequence **seq_1, **seq_2;
 
@@ -2719,10 +2719,10 @@ static int sequencer_change_effect_input_exec(bContext *C, wmOperator *op)
 
   SWAP(Sequence *, *seq_1, *seq_2);
 
-  BKE_sequencer_update_changed_seq_and_deps(scene, seq, 0, 1);
+  SEQ_relations_update_changed_seq_and_deps(scene, seq, 0, 1);
 
   /* Invalidate cache. */
-  BKE_sequencer_free_imbuf(scene, &ed->seqbase, false);
+  SEQ_relations_free_imbuf(scene, &ed->seqbase, false);
   WM_event_add_notifier(C, NC_SCENE | ND_SEQUENCER, scene);
 
   return OPERATOR_FINISHED;
@@ -2776,8 +2776,8 @@ EnumPropertyItem sequencer_prop_effect_types[] = {
 static int sequencer_change_effect_type_exec(bContext *C, wmOperator *op)
 {
   Scene *scene = CTX_data_scene(C);
-  Editing *ed = BKE_sequencer_editing_get(scene, false);
-  Sequence *seq = BKE_sequencer_active_get(scene);
+  Editing *ed = SEQ_editing_get(scene, false);
+  Sequence *seq = SEQ_select_active_get(scene);
   const int new_type = RNA_enum_get(op->ptr, "type");
 
   /* Free previous effect and init new effect. */
@@ -2789,23 +2789,22 @@ static int sequencer_change_effect_type_exec(bContext *C, wmOperator *op)
 
   /* Can someone explain the logic behind only allowing to increase this,
    * copied from 2.4x - campbell */
-  if (BKE_sequence_effect_get_num_inputs(seq->type) <
-      BKE_sequence_effect_get_num_inputs(new_type)) {
+  if (SEQ_effect_get_num_inputs(seq->type) < SEQ_effect_get_num_inputs(new_type)) {
     BKE_report(op->reports, RPT_ERROR, "New effect needs more input strips");
     return OPERATOR_CANCELLED;
   }
 
-  sh = BKE_sequence_get_effect(seq);
+  sh = SEQ_effect_handle_get(seq);
   sh.free(seq, true);
 
   seq->type = new_type;
 
-  sh = BKE_sequence_get_effect(seq);
+  sh = SEQ_effect_handle_get(seq);
   sh.init(seq);
 
-  BKE_sequencer_update_changed_seq_and_deps(scene, seq, 0, 1);
+  SEQ_relations_update_changed_seq_and_deps(scene, seq, 0, 1);
   /* Invalidate cache. */
-  BKE_sequencer_free_imbuf(scene, &ed->seqbase, false);
+  SEQ_relations_free_imbuf(scene, &ed->seqbase, false);
 
   WM_event_add_notifier(C, NC_SCENE | ND_SEQUENCER, scene);
 
@@ -2843,8 +2842,8 @@ static int sequencer_change_path_exec(bContext *C, wmOperator *op)
 {
   Main *bmain = CTX_data_main(C);
   Scene *scene = CTX_data_scene(C);
-  Editing *ed = BKE_sequencer_editing_get(scene, false);
-  Sequence *seq = BKE_sequencer_active_get(scene);
+  Editing *ed = SEQ_editing_get(scene, false);
+  Sequence *seq = SEQ_select_active_get(scene);
   const bool is_relative_path = RNA_boolean_get(op->ptr, "relative_path");
   const bool use_placeholders = RNA_boolean_get(op->ptr, "use_placeholders");
   int minext_frameme, numdigits;
@@ -2897,12 +2896,12 @@ static int sequencer_change_path_exec(bContext *C, wmOperator *op)
 
     /* Correct start/end frames so we don't move.
      * Important not to set seq->len = len; allow the function to handle it. */
-    BKE_sequence_reload_new_file(bmain, scene, seq, true);
+    SEQ_add_reload_new_file(bmain, scene, seq, true);
 
-    BKE_sequence_calc(scene, seq);
+    SEQ_time_update_sequence(scene, seq);
 
     /* Invalidate cache. */
-    BKE_sequencer_free_imbuf(scene, &ed->seqbase, false);
+    SEQ_relations_free_imbuf(scene, &ed->seqbase, false);
   }
   else if (ELEM(seq->type, SEQ_TYPE_SOUND_RAM, SEQ_TYPE_SOUND_HD)) {
     bSound *sound = seq->sound;
@@ -2936,7 +2935,7 @@ static int sequencer_change_path_exec(bContext *C, wmOperator *op)
 static int sequencer_change_path_invoke(bContext *C, wmOperator *op, const wmEvent *UNUSED(event))
 {
   Scene *scene = CTX_data_scene(C);
-  Sequence *seq = BKE_sequencer_active_get(scene);
+  Sequence *seq = SEQ_select_active_get(scene);
   char filepath[FILE_MAX];
 
   BLI_join_dirfile(filepath, sizeof(filepath), seq->strip->dir, seq->strip->stripdata->name);
@@ -3020,7 +3019,7 @@ static int sequencer_export_subtitles_exec(bContext *C, wmOperator *op)
 {
   Scene *scene = CTX_data_scene(C);
   Sequence *seq, *seq_next;
-  Editing *ed = BKE_sequencer_editing_get(scene, false);
+  Editing *ed = SEQ_editing_get(scene, false);
   ListBase text_seq = {0};
   int iter = 0;
   FILE *file;
@@ -3059,7 +3058,7 @@ static int sequencer_export_subtitles_exec(bContext *C, wmOperator *op)
     return OPERATOR_CANCELLED;
   }
 
-  BLI_listbase_sort(&text_seq, BKE_sequencer_cmp_time_startdisp);
+  BLI_listbase_sort(&text_seq, SEQ_time_cmp_time_startdisp);
 
   /* Open and write file. */
   file = BLI_fopen(filepath, "w");
@@ -3098,7 +3097,7 @@ static bool sequencer_strip_is_text_poll(bContext *C)
 {
   Editing *ed;
   Sequence *seq;
-  return (((ed = BKE_sequencer_editing_get(CTX_data_scene(C), false)) != NULL) &&
+  return (((ed = SEQ_editing_get(CTX_data_scene(C), false)) != NULL) &&
           ((seq = ed->act_seq) != NULL) && (seq->type == SEQ_TYPE_TEXT));
 }
 
@@ -3135,7 +3134,7 @@ void SEQUENCER_OT_export_subtitles(struct wmOperatorType *ot)
 static int sequencer_set_range_to_strips_exec(bContext *C, wmOperator *op)
 {
   Scene *scene = CTX_data_scene(C);
-  Editing *ed = BKE_sequencer_editing_get(scene, false);
+  Editing *ed = SEQ_editing_get(scene, false);
   Sequence *seq;
 
   int sfra = MAXFRAME;
@@ -3206,7 +3205,7 @@ void SEQUENCER_OT_set_range_to_strips(struct wmOperatorType *ot)
 static void set_filter_seq(Scene *scene)
 {
   Sequence *seq;
-  Editing *ed = BKE_sequencer_editing_get(scene, false);
+  Editing *ed = SEQ_editing_get(scene, false);
 
   if (ed == NULL) {
     return;
@@ -3220,8 +3219,8 @@ static void set_filter_seq(Scene *scene)
     if (seq->flag & SELECT) {
       if (seq->type == SEQ_TYPE_MOVIE) {
         seq->flag |= SEQ_FILTERY;
-        BKE_sequence_reload_new_file(bmain, scene, seq, false);
-        BKE_sequence_calc(scene, seq);
+        SEQ_add_reload_new_file(bmain, scene, seq, false);
+        SEQ_time_update_sequence(scene, seq);
       }
     }
   }
@@ -3230,8 +3229,8 @@ static void set_filter_seq(Scene *scene)
 
 static void UNUSED_FUNCTION(seq_remap_paths)(Scene *scene)
 {
-  Sequence *seq, *last_seq = BKE_sequencer_active_get(scene);
-  Editing *ed = BKE_sequencer_editing_get(scene, false);
+  Sequence *seq, *last_seq = SEQ_select_active_get(scene);
+  Editing *ed = SEQ_editing_get(scene, false);
   char from[FILE_MAX], to[FILE_MAX], stripped[FILE_MAX];
 
   if (last_seq == NULL) {
@@ -3270,7 +3269,7 @@ static void UNUSED_FUNCTION(seq_remap_paths)(Scene *scene)
 
 static Sequence *sequence_find_parent(Scene *scene, Sequence *child)
 {
-  Editing *ed = BKE_sequencer_editing_get(scene, false);
+  Editing *ed = SEQ_editing_get(scene, false);
   Sequence *parent = NULL;
   Sequence *seq;
 
@@ -3322,7 +3321,7 @@ Sequence *find_neighboring_sequence(Scene *scene, Sequence *test, int lr, int se
 {
   /* sel: 0==unselected, 1==selected, -1==don't care. */
   Sequence *seq;
-  Editing *ed = BKE_sequencer_editing_get(scene, false);
+  Editing *ed = SEQ_editing_get(scene, false);
 
   if (ed == NULL) {
     return NULL;
@@ -3356,7 +3355,7 @@ Sequence *find_neighboring_sequence(Scene *scene, Sequence *test, int lr, int se
 Sequence *find_nearest_seq(Scene *scene, View2D *v2d, int *hand, const int mval[2])
 {
   Sequence *seq;
-  Editing *ed = BKE_sequencer_editing_get(scene, false);
+  Editing *ed = SEQ_editing_get(scene, false);
   float x, y;
   float pixelx;
   float handsize;
@@ -3378,7 +3377,7 @@ Sequence *find_nearest_seq(Scene *scene, View2D *v2d, int *hand, const int mval[
       /* Check for both normal strips, and strips that have been flipped horizontally. */
       if (((seq->startdisp < seq->enddisp) && (seq->startdisp <= x && seq->enddisp >= x)) ||
           ((seq->startdisp > seq->enddisp) && (seq->startdisp >= x && seq->enddisp <= x))) {
-        if (BKE_sequence_tx_test(seq)) {
+        if (SEQ_transform_sequence_can_be_translated(seq)) {
 
           /* Clamp handles to defined size in pixel space. */
           handsize = 2.0f * sequence_handle_size_get_clamped(seq, pixelx);
@@ -3437,7 +3436,7 @@ static const EnumPropertyItem transform_reset_properties[] = {
 static int sequencer_strip_transform_clear_exec(bContext *C, wmOperator *op)
 {
   Scene *scene = CTX_data_scene(C);
-  const Editing *ed = BKE_sequencer_editing_get(scene, false);
+  const Editing *ed = SEQ_editing_get(scene, false);
   Sequence *seq;
   const int property = RNA_enum_get(op->ptr, "property");
 
@@ -3464,7 +3463,7 @@ static int sequencer_strip_transform_clear_exec(bContext *C, wmOperator *op)
           transform->rotation = 0.0f;
           break;
       }
-      BKE_sequence_invalidate_cache_preprocessed(scene, seq);
+      SEQ_relations_invalidate_cache_preprocessed(scene, seq);
     }
   }
 
@@ -3510,7 +3509,7 @@ static const EnumPropertyItem scale_fit_methods[] = {
 static int sequencer_strip_transform_fit_exec(bContext *C, wmOperator *op)
 {
   Scene *scene = CTX_data_scene(C);
-  const Editing *ed = BKE_sequencer_editing_get(scene, false);
+  const Editing *ed = SEQ_editing_get(scene, false);
   Sequence *seq;
   const eSeqImageFitMethod fit_method = RNA_enum_get(op->ptr, "fit_method");
 
@@ -3529,7 +3528,7 @@ static int sequencer_strip_transform_fit_exec(bContext *C, wmOperator *op)
                            scene->r.xsch,
                            scene->r.ysch,
                            fit_method);
-      BKE_sequence_invalidate_cache_preprocessed(scene, seq);
+      SEQ_relations_invalidate_cache_preprocessed(scene, seq);
     }
   }
 
diff --git a/source/blender/editors/space_sequencer/sequencer_modifier.c b/source/blender/editors/space_sequencer/sequencer_modifier.c
index fb09afc6ca5..e8f4fac1920 100644
--- a/source/blender/editors/space_sequencer/sequencer_modifier.c
+++ b/source/blender/editors/space_sequencer/sequencer_modifier.c
@@ -44,13 +44,13 @@
 static bool strip_modifier_active_poll(bContext *C)
 {
   Scene *scene = CTX_data_scene(C);
-  Editing *ed = BKE_sequencer_editing_get(scene, false);
+  Editing *ed = SEQ_editing_get(scene, false);
 
   if (ed) {
-    Sequence *seq = BKE_sequencer_active_get(scene);
+    Sequence *seq = SEQ_select_active_get(scene);
 
     if (seq) {
-      return BKE_sequence_supports_modifiers(seq);
+      return SEQ_sequence_supports_modifiers(seq);
     }
   }
 
@@ -60,12 +60,12 @@ static bool strip_modifier_active_poll(bContext *C)
 static int strip_modifier_add_exec(bContext *C, wmOperator *op)
 {
   Scene *scene = CTX_data_scene(C);
-  Sequence *seq = BKE_sequencer_active_get(scene);
+  Sequence *seq = SEQ_select_active_get(scene);
   int type = RNA_enum_get(op->ptr, "type");
 
-  BKE_sequence_modifier_new(seq, NULL, type);
+  SEQ_modifier_new(seq, NULL, type);
 
-  BKE_sequence_invalidate_cache_preprocessed(scene, seq);
+  SEQ_relations_invalidate_cache_preprocessed(scene, seq);
   WM_event_add_notifier(C, NC_SCENE | ND_SEQUENCER, scene);
 
   return OPERATOR_FINISHED;
@@ -102,21 +102,21 @@ void SEQUENCER_OT_strip_modifier_add(wmOperatorType *ot)
 static int strip_modifier_remove_exec(bContext *C, wmOperator *op)
 {
   Scene *scene = CTX_data_scene(C);
-  Sequence *seq = BKE_sequencer_active_get(scene);
+  Sequence *seq = SEQ_select_active_get(scene);
   char name[MAX_NAME];
   SequenceModifierData *smd;
 
   RNA_string_get(op->ptr, "name", name);
 
-  smd = BKE_sequence_modifier_find_by_name(seq, name);
+  smd = SEQ_modifier_find_by_name(seq, name);
   if (!smd) {
     return OPERATOR_CANCELLED;
   }
 
   BLI_remlink(&seq->modifiers, smd);
-  BKE_sequence_modifier_free(smd);
+  SEQ_modifier_free(smd);
 
-  BKE_sequence_invalidate_cache_preprocessed(scene, seq);
+  SEQ_relations_invalidate_cache_preprocessed(scene, seq);
   WM_event_add_notifier(C, NC_SCENE | ND_SEQUENCER, scene);
 
   return OPERATOR_FINISHED;
@@ -153,7 +153,7 @@ enum {
 static int strip_modifier_move_exec(bContext *C, wmOperator *op)
 {
   Scene *scene = CTX_data_scene(C);
-  Sequence *seq = BKE_sequencer_active_get(scene);
+  Sequence *seq = SEQ_select_active_get(scene);
   char name[MAX_NAME];
   int direction;
   SequenceModifierData *smd;
@@ -161,7 +161,7 @@ static int strip_modifier_move_exec(bContext *C, wmOperator *op)
   RNA_string_get(op->ptr, "name", name);
   direction = RNA_enum_get(op->ptr, "direction");
 
-  smd = BKE_sequence_modifier_find_by_name(seq, name);
+  smd = SEQ_modifier_find_by_name(seq, name);
   if (!smd) {
     return OPERATOR_CANCELLED;
   }
@@ -179,7 +179,7 @@ static int strip_modifier_move_exec(bContext *C, wmOperator *op)
     }
   }
 
-  BKE_sequence_invalidate_cache_preprocessed(scene, seq);
+  SEQ_relations_invalidate_cache_preprocessed(scene, seq);
   WM_event_add_notifier(C, NC_SCENE | ND_SEQUENCER, scene);
 
   return OPERATOR_FINISHED;
@@ -225,7 +225,7 @@ static int strip_modifier_copy_exec(bContext *C, wmOperator *op)
 {
   Scene *scene = CTX_data_scene(C);
   Editing *ed = scene->ed;
-  Sequence *seq = BKE_sequencer_active_get(scene);
+  Sequence *seq = SEQ_select_active_get(scene);
   Sequence *seq_iter;
   const int type = RNA_enum_get(op->ptr, "type");
 
@@ -245,19 +245,19 @@ static int strip_modifier_copy_exec(bContext *C, wmOperator *op)
           while (smd) {
             smd_tmp = smd->next;
             BLI_remlink(&seq_iter->modifiers, smd);
-            BKE_sequence_modifier_free(smd);
+            SEQ_modifier_free(smd);
             smd = smd_tmp;
           }
           BLI_listbase_clear(&seq_iter->modifiers);
         }
       }
 
-      BKE_sequence_modifier_list_copy(seq_iter, seq);
+      SEQ_modifier_list_copy(seq_iter, seq);
     }
   }
   SEQ_CURRENT_END;
 
-  BKE_sequence_invalidate_cache_preprocessed(scene, seq);
+  SEQ_relations_invalidate_cache_preprocessed(scene, seq);
   WM_event_add_notifier(C, NC_SCENE | ND_SEQUENCER, scene);
 
   return OPERATOR_FINISHED;
diff --git a/source/blender/editors/space_sequencer/sequencer_proxy.c b/source/blender/editors/space_sequencer/sequencer_proxy.c
index 2d23520814a..032885c2719 100644
--- a/source/blender/editors/space_sequencer/sequencer_proxy.c
+++ b/source/blender/editors/space_sequencer/sequencer_proxy.c
@@ -90,14 +90,14 @@ static void proxy_startjob(void *pjv, short *stop, short *do_update, float *prog
 static void proxy_endjob(void *pjv)
 {
   ProxyJob *pj = pjv;
-  Editing *ed = BKE_sequencer_editing_get(pj->scene, false);
+  Editing *ed = SEQ_editing_get(pj->scene, false);
   LinkData *link;
 
   for (link = pj->queue.first; link; link = link->next) {
     SEQ_proxy_rebuild_finish(link->data, pj->stop);
   }
 
-  BKE_sequencer_free_imbuf(pj->scene, &ed->seqbase, false);
+  SEQ_relations_free_imbuf(pj->scene, &ed->seqbase, false);
 
   WM_main_add_notifier(NC_SCENE | ND_SEQUENCER, pj->scene);
 }
@@ -108,7 +108,7 @@ static void seq_proxy_build_job(const bContext *C, ReportList *reports)
   ProxyJob *pj;
   struct Depsgraph *depsgraph = CTX_data_depsgraph_pointer(C);
   Scene *scene = CTX_data_scene(C);
-  Editing *ed = BKE_sequencer_editing_get(scene, false);
+  Editing *ed = SEQ_editing_get(scene, false);
   ScrArea *area = CTX_wm_area(C);
   Sequence *seq;
   GSet *file_list;
@@ -201,7 +201,7 @@ static int sequencer_rebuild_proxy_exec(bContext *C, wmOperator *UNUSED(op))
   Main *bmain = CTX_data_main(C);
   struct Depsgraph *depsgraph = CTX_data_ensure_evaluated_depsgraph(C);
   Scene *scene = CTX_data_scene(C);
-  Editing *ed = BKE_sequencer_editing_get(scene, false);
+  Editing *ed = SEQ_editing_get(scene, false);
   Sequence *seq;
   GSet *file_list;
 
@@ -225,7 +225,7 @@ static int sequencer_rebuild_proxy_exec(bContext *C, wmOperator *UNUSED(op))
         SEQ_proxy_rebuild(context, &stop, &do_update, &progress);
         SEQ_proxy_rebuild_finish(context, 0);
       }
-      BKE_sequencer_free_imbuf(scene, &ed->seqbase, false);
+      SEQ_relations_free_imbuf(scene, &ed->seqbase, false);
     }
   }
   SEQ_CURRENT_END;
@@ -266,7 +266,7 @@ static int sequencer_enable_proxies_invoke(bContext *C,
 static int sequencer_enable_proxies_exec(bContext *C, wmOperator *op)
 {
   Scene *scene = CTX_data_scene(C);
-  Editing *ed = BKE_sequencer_editing_get(scene, false);
+  Editing *ed = SEQ_editing_get(scene, false);
   Sequence *seq;
   bool proxy_25 = RNA_boolean_get(op->ptr, "proxy_25");
   bool proxy_50 = RNA_boolean_get(op->ptr, "proxy_50");
diff --git a/source/blender/editors/space_sequencer/sequencer_select.c b/source/blender/editors/space_sequencer/sequencer_select.c
index a6b2d7feae3..6534a63f03e 100644
--- a/source/blender/editors/space_sequencer/sequencer_select.c
+++ b/source/blender/editors/space_sequencer/sequencer_select.c
@@ -198,13 +198,13 @@ void select_surround_from_last(Scene *scene)
 
 void ED_sequencer_select_sequence_single(Scene *scene, Sequence *seq, bool deselect_all)
 {
-  Editing *ed = BKE_sequencer_editing_get(scene, false);
+  Editing *ed = SEQ_editing_get(scene, false);
 
   if (deselect_all) {
     ED_sequencer_deselect_all(scene);
   }
 
-  BKE_sequencer_active_set(scene, seq);
+  SEQ_select_active_set(scene, seq);
 
   if (ELEM(seq->type, SEQ_TYPE_IMAGE, SEQ_TYPE_MOVIE)) {
     if (seq->strip) {
@@ -223,7 +223,7 @@ void ED_sequencer_select_sequence_single(Scene *scene, Sequence *seq, bool desel
 #if 0
 static void select_neighbor_from_last(Scene *scene, int lr)
 {
-  Sequence *seq = BKE_sequencer_active_get(scene);
+  Sequence *seq = SEQ_select_active_get(scene);
   Sequence *neighbor;
   bool changed = false;
   if (seq) {
@@ -264,7 +264,7 @@ static int sequencer_de_select_all_exec(bContext *C, wmOperator *op)
   int action = RNA_enum_get(op->ptr, "action");
 
   Scene *scene = CTX_data_scene(C);
-  Editing *ed = BKE_sequencer_editing_get(scene, false);
+  Editing *ed = SEQ_editing_get(scene, false);
   Sequence *seq;
 
   if (action == SEL_TOGGLE) {
@@ -331,7 +331,7 @@ void SEQUENCER_OT_select_all(struct wmOperatorType *ot)
 static int sequencer_select_inverse_exec(bContext *C, wmOperator *UNUSED(op))
 {
   Scene *scene = CTX_data_scene(C);
-  Editing *ed = BKE_sequencer_editing_get(scene, false);
+  Editing *ed = SEQ_editing_get(scene, false);
   Sequence *seq;
 
   for (seq = ed->seqbasep->first; seq; seq = seq->next) {
@@ -376,7 +376,7 @@ static int sequencer_select_exec(bContext *C, wmOperator *op)
 {
   View2D *v2d = UI_view2d_fromcontext(C);
   Scene *scene = CTX_data_scene(C);
-  Editing *ed = BKE_sequencer_editing_get(scene, false);
+  Editing *ed = SEQ_editing_get(scene, false);
   const bool extend = RNA_boolean_get(op->ptr, "extend");
   const bool deselect_all = RNA_boolean_get(op->ptr, "deselect_all");
   const bool linked_handle = RNA_boolean_get(op->ptr, "linked_handle");
@@ -464,7 +464,7 @@ static int sequencer_select_exec(bContext *C, wmOperator *op)
         ret_value = OPERATOR_FINISHED;
       }
 
-      BKE_sequencer_active_set(scene, seq);
+      SEQ_select_active_set(scene, seq);
 
       if (ELEM(seq->type, SEQ_TYPE_IMAGE, SEQ_TYPE_MOVIE)) {
         if (seq->strip) {
@@ -667,7 +667,7 @@ void SEQUENCER_OT_select(wmOperatorType *ot)
 /* Run recursively to select linked. */
 static bool select_more_less_seq__internal(Scene *scene, bool sel, const bool linked)
 {
-  Editing *ed = BKE_sequencer_editing_get(scene, false);
+  Editing *ed = SEQ_editing_get(scene, false);
   Sequence *seq, *neighbor;
   bool changed = false;
   int isel;
@@ -903,7 +903,7 @@ void SEQUENCER_OT_select_linked(wmOperatorType *ot)
 static int sequencer_select_handles_exec(bContext *C, wmOperator *op)
 {
   Scene *scene = CTX_data_scene(C);
-  Editing *ed = BKE_sequencer_editing_get(scene, false);
+  Editing *ed = SEQ_editing_get(scene, false);
   Sequence *seq;
   int sel_side = RNA_enum_get(op->ptr, "side");
 
@@ -964,7 +964,7 @@ void SEQUENCER_OT_select_handles(wmOperatorType *ot)
 static int sequencer_select_side_of_frame_exec(bContext *C, wmOperator *op)
 {
   Scene *scene = CTX_data_scene(C);
-  Editing *ed = BKE_sequencer_editing_get(scene, false);
+  Editing *ed = SEQ_editing_get(scene, false);
   const bool extend = RNA_boolean_get(op->ptr, "extend");
   const int side = RNA_enum_get(op->ptr, "side");
   Sequence *seq;
@@ -1038,7 +1038,7 @@ void SEQUENCER_OT_select_side_of_frame(wmOperatorType *ot)
 static int sequencer_select_side_exec(bContext *C, wmOperator *op)
 {
   Scene *scene = CTX_data_scene(C);
-  Editing *ed = BKE_sequencer_editing_get(scene, false);
+  Editing *ed = SEQ_editing_get(scene, false);
 
   const int sel_side = RNA_enum_get(op->ptr, "side");
   const int frame_init = sel_side == SEQ_SIDE_LEFT ? INT_MIN : INT_MAX;
@@ -1109,7 +1109,7 @@ static int sequencer_box_select_exec(bContext *C, wmOperator *op)
 {
   Scene *scene = CTX_data_scene(C);
   View2D *v2d = UI_view2d_fromcontext(C);
-  Editing *ed = BKE_sequencer_editing_get(scene, false);
+  Editing *ed = SEQ_editing_get(scene, false);
 
   if (ed == NULL) {
     return OPERATOR_CANCELLED;
@@ -1454,8 +1454,7 @@ static bool select_grouped_effect_link(Editing *ed, Sequence *actseq, const int
 
   actseq->tmp = POINTER_FROM_INT(true);
 
-  for (BKE_sequence_iterator_begin(ed, &iter, true); iter.valid;
-       BKE_sequence_iterator_next(&iter)) {
+  for (SEQ_iterator_begin(ed, &iter, true); iter.valid; SEQ_iterator_next(&iter)) {
     seq = iter.seq;
 
     /* Ignore all seqs already selected. */
@@ -1486,8 +1485,8 @@ static bool select_grouped_effect_link(Editing *ed, Sequence *actseq, const int
       changed = true;
 
       /* Unfortunately, we must restart checks from the beginning. */
-      BKE_sequence_iterator_end(&iter);
-      BKE_sequence_iterator_begin(ed, &iter, true);
+      SEQ_iterator_end(&iter);
+      SEQ_iterator_begin(ed, &iter, true);
     }
 
     /* Video strips below active one, or any strip for audio (order doesn't matter here). */
@@ -1496,7 +1495,7 @@ static bool select_grouped_effect_link(Editing *ed, Sequence *actseq, const int
       changed = true;
     }
   }
-  BKE_sequence_iterator_end(&iter);
+  SEQ_iterator_end(&iter);
 
   return changed;
 }
@@ -1508,8 +1507,8 @@ static bool select_grouped_effect_link(Editing *ed, Sequence *actseq, const int
 static int sequencer_select_grouped_exec(bContext *C, wmOperator *op)
 {
   Scene *scene = CTX_data_scene(C);
-  Editing *ed = BKE_sequencer_editing_get(scene, false);
-  Sequence *seq, *actseq = BKE_sequencer_active_get(scene);
+  Editing *ed = SEQ_editing_get(scene, false);
+  Sequence *seq, *actseq = SEQ_select_active_get(scene);
 
   if (actseq == NULL) {
     BKE_report(op->reports, RPT_ERROR, "No active sequence!");
diff --git a/source/blender/editors/space_sequencer/sequencer_view.c b/source/blender/editors/space_sequencer/sequencer_view.c
index e12c43b7804..250a0afc717 100644
--- a/source/blender/editors/space_sequencer/sequencer_view.c
+++ b/source/blender/editors/space_sequencer/sequencer_view.c
@@ -88,7 +88,7 @@ static int sequencer_view_all_exec(bContext *C, wmOperator *op)
 
   const int smooth_viewtx = WM_operator_smooth_viewtx_get(op);
   Scene *scene = CTX_data_scene(C);
-  const Editing *ed = BKE_sequencer_editing_get(scene, false);
+  const Editing *ed = SEQ_editing_get(scene, false);
 
   SEQ_timeline_boundbox(scene, SEQ_active_seqbase_get(ed), &box);
   UI_view2d_smooth_view(C, region, &box, smooth_viewtx);
@@ -272,8 +272,8 @@ static int sequencer_view_selected_exec(bContext *C, wmOperator *op)
   Scene *scene = CTX_data_scene(C);
   View2D *v2d = UI_view2d_fromcontext(C);
   ARegion *region = CTX_wm_region(C);
-  Editing *ed = BKE_sequencer_editing_get(scene, false);
-  Sequence *last_seq = BKE_sequencer_active_get(scene);
+  Editing *ed = SEQ_editing_get(scene, false);
+  Sequence *last_seq = SEQ_select_active_get(scene);
   Sequence *seq;
   rctf cur_new = v2d->cur;
 
diff --git a/source/blender/editors/space_sequencer/space_sequencer.c b/source/blender/editors/space_sequencer/space_sequencer.c
index 2bf4741e4f5..19146db3719 100644
--- a/source/blender/editors/space_sequencer/space_sequencer.c
+++ b/source/blender/editors/space_sequencer/space_sequencer.c
@@ -471,7 +471,7 @@ static int /*eContextResult*/ sequencer_context(const bContext *C,
     return CTX_RESULT_OK;
   }
   if (CTX_data_equals(member, "edit_mask")) {
-    Mask *mask = BKE_sequencer_mask_get(scene);
+    Mask *mask = SEQ_active_mask_get(scene);
     if (mask) {
       CTX_data_id_pointer_set(result, &mask->id);
     }
diff --git a/source/blender/editors/transform/transform_convert_sequencer.c b/source/blender/editors/transform/transform_convert_sequencer.c
index 3f86ef3e81b..83e384010bd 100644
--- a/source/blender/editors/transform/transform_convert_sequencer.c
+++ b/source/blender/editors/transform/transform_convert_sequencer.c
@@ -84,8 +84,8 @@ static void SeqTransInfo(TransInfo *t, Sequence *seq, int *r_recursive, int *r_c
 
     Scene *scene = t->scene;
     int cfra = CFRA;
-    int left = BKE_sequence_tx_get_final_left(seq, true);
-    int right = BKE_sequence_tx_get_final_right(seq, true);
+    int left = SEQ_transform_get_left_handle_frame(seq, true);
+    int right = SEQ_transform_get_right_handle_frame(seq, true);
 
     if (seq->depth == 0 && ((seq->flag & SELECT) == 0 || (seq->flag & SEQ_LOCK))) {
       *r_recursive = false;
@@ -186,7 +186,7 @@ static void SeqTransInfo(TransInfo *t, Sequence *seq, int *r_recursive, int *r_c
         /* Meta's can only directly be moved between channels since they
          * don't have their start and length set directly (children affect that)
          * since this Meta is nested we don't need any of its data in fact.
-         * BKE_sequence_calc() will update its settings when run on the top-level meta. */
+         * SEQ_time_update_sequence() will update its settings when run on the top-level meta. */
         *r_flag = 0;
         *r_count = 0;
         *r_recursive = true;
@@ -235,16 +235,16 @@ static TransData *SeqToTransData(
       /* Use seq_tx_get_final_left() and an offset here
        * so transform has the left hand location of the strip.
        * tdsq->start_offset is used when flushing the tx data back */
-      start_left = BKE_sequence_tx_get_final_left(seq, false);
+      start_left = SEQ_transform_get_left_handle_frame(seq, false);
       td2d->loc[0] = start_left;
       tdsq->start_offset = start_left - seq->start; /* use to apply the original location */
       break;
     case SEQ_LEFTSEL:
-      start_left = BKE_sequence_tx_get_final_left(seq, false);
+      start_left = SEQ_transform_get_left_handle_frame(seq, false);
       td2d->loc[0] = start_left;
       break;
     case SEQ_RIGHTSEL:
-      td2d->loc[0] = BKE_sequence_tx_get_final_right(seq, false);
+      td2d->loc[0] = SEQ_transform_get_right_handle_frame(seq, false);
       break;
   }
 
@@ -366,7 +366,7 @@ static void SeqTransDataBounds(TransInfo *t, ListBase *seqbase, TransSeq *ts)
 
 static void freeSeqData(TransInfo *t, TransDataContainer *tc, TransCustomData *custom_data)
 {
-  Editing *ed = BKE_sequencer_editing_get(t->scene, false);
+  Editing *ed = SEQ_editing_get(t->scene, false);
 
   if (ed != NULL) {
 
@@ -388,7 +388,7 @@ static void freeSeqData(TransInfo *t, TransDataContainer *tc, TransCustomData *c
       for (a = 0; a < t->total; a++, td++) {
         if ((seq != seq_prev) && (seq->depth == 0) && (seq->flag & SEQ_OVERLAP)) {
           seq = ((TransDataSeq *)td->extra)->seq;
-          BKE_sequence_base_shuffle(seqbasep, seq, t->scene);
+          SEQ_transform_seqbase_shuffle(seqbasep, seq, t->scene);
         }
 
         seq_prev = seq;
@@ -429,7 +429,7 @@ static void freeSeqData(TransInfo *t, TransDataContainer *tc, TransCustomData *c
               }
               else {
                 /* Tag seq with a non zero value, used by
-                 * BKE_sequence_base_shuffle_time to identify the ones to shuffle */
+                 * SEQ_transform_seqbase_shuffle_time to identify the ones to shuffle */
                 if (seq->depth == 0) {
                   seq->tmp = (void *)1;
                 }
@@ -455,7 +455,7 @@ static void freeSeqData(TransInfo *t, TransDataContainer *tc, TransCustomData *c
               }
             }
 
-            BKE_sequence_base_shuffle_time(seqbasep, t->scene, markers, use_sync_markers);
+            SEQ_transform_seqbase_shuffle_time(seqbasep, t->scene, markers, use_sync_markers);
 
             for (seq = seqbasep->first; seq; seq = seq->next) {
               if (seq->machine >= MAXSEQ * 2) {
@@ -467,10 +467,10 @@ static void freeSeqData(TransInfo *t, TransDataContainer *tc, TransCustomData *c
               }
             }
 
-            BKE_sequence_base_shuffle_time(seqbasep, t->scene, markers, use_sync_markers);
+            SEQ_transform_seqbase_shuffle_time(seqbasep, t->scene, markers, use_sync_markers);
           }
           else {
-            BKE_sequence_base_shuffle_time(seqbasep, t->scene, markers, use_sync_markers);
+            SEQ_transform_seqbase_shuffle_time(seqbasep, t->scene, markers, use_sync_markers);
           }
 
           if (has_effect_any) {
@@ -480,7 +480,7 @@ static void freeSeqData(TransInfo *t, TransDataContainer *tc, TransCustomData *c
               seq = ((TransDataSeq *)td->extra)->seq;
               if ((seq != seq_prev)) {
                 if ((seq->type & SEQ_TYPE_EFFECT) && seq->seq1) {
-                  BKE_sequence_calc(t->scene, seq);
+                  SEQ_time_update_sequence(t->scene, seq);
                 }
               }
             }
@@ -493,8 +493,8 @@ static void freeSeqData(TransInfo *t, TransDataContainer *tc, TransCustomData *c
               seq = ((TransDataSeq *)td->extra)->seq;
               if ((seq != seq_prev) && (seq->depth == 0)) {
                 if ((seq->type & SEQ_TYPE_EFFECT) && seq->seq1) {
-                  if (BKE_sequence_test_overlap(seqbasep, seq)) {
-                    BKE_sequence_base_shuffle(seqbasep, seq, t->scene);
+                  if (SEQ_transform_test_overlap(seqbasep, seq)) {
+                    SEQ_transform_seqbase_shuffle(seqbasep, seq, t->scene);
                   }
                 }
               }
@@ -509,18 +509,18 @@ static void freeSeqData(TransInfo *t, TransDataContainer *tc, TransCustomData *c
         /* We might want to build a list of effects that need to be updated during transform */
         if (seq->type & SEQ_TYPE_EFFECT) {
           if (seq->seq1 && seq->seq1->flag & SELECT) {
-            BKE_sequence_calc(t->scene, seq);
+            SEQ_time_update_sequence(t->scene, seq);
           }
           else if (seq->seq2 && seq->seq2->flag & SELECT) {
-            BKE_sequence_calc(t->scene, seq);
+            SEQ_time_update_sequence(t->scene, seq);
           }
           else if (seq->seq3 && seq->seq3->flag & SELECT) {
-            BKE_sequence_calc(t->scene, seq);
+            SEQ_time_update_sequence(t->scene, seq);
           }
         }
       }
 
-      BKE_sequencer_sort(t->scene);
+      SEQ_sort(t->scene);
     }
     else {
       /* Canceled, need to update the strips display */
@@ -528,10 +528,10 @@ static void freeSeqData(TransInfo *t, TransDataContainer *tc, TransCustomData *c
         seq = ((TransDataSeq *)td->extra)->seq;
         if ((seq != seq_prev) && (seq->depth == 0)) {
           if (seq->flag & SEQ_OVERLAP) {
-            BKE_sequence_base_shuffle(seqbasep, seq, t->scene);
+            SEQ_transform_seqbase_shuffle(seqbasep, seq, t->scene);
           }
 
-          BKE_sequence_calc_disp(t->scene, seq);
+          SEQ_time_update_sequence_bounds(t->scene, seq);
         }
         seq_prev = seq;
       }
@@ -553,7 +553,7 @@ void createTransSeqData(TransInfo *t)
 #define XXX_DURIAN_ANIM_TX_HACK
 
   Scene *scene = t->scene;
-  Editing *ed = BKE_sequencer_editing_get(t->scene, false);
+  Editing *ed = SEQ_editing_get(t->scene, false);
   TransData *td = NULL;
   TransData2D *td2d = NULL;
   TransDataSeq *tdsq = NULL;
@@ -640,21 +640,21 @@ BLI_INLINE void trans_update_seq(Scene *sce, Sequence *seq, int old_start, int s
     /* Calculate this strip and all nested strips.
      * Children are ALWAYS transformed first so we don't need to do this in another loop.
      */
-    BKE_sequence_calc(sce, seq);
+    SEQ_time_update_sequence(sce, seq);
   }
   else {
-    BKE_sequence_calc_disp(sce, seq);
+    SEQ_time_update_sequence_bounds(sce, seq);
   }
 
   if (sel_flag == SELECT) {
-    BKE_sequencer_offset_animdata(sce, seq, seq->start - old_start);
+    SEQ_offset_animdata(sce, seq, seq->start - old_start);
   }
 }
 
 static void flushTransSeq(TransInfo *t)
 {
   /* Editing null check already done */
-  ListBase *seqbasep = BKE_sequencer_editing_get(t->scene, false)->seqbasep;
+  ListBase *seqbasep = SEQ_editing_get(t->scene, false)->seqbasep;
 
   int a, new_frame;
   TransData *td = NULL;
@@ -681,7 +681,7 @@ static void flushTransSeq(TransInfo *t)
     switch (tdsq->sel_flag) {
       case SELECT:
 #ifdef SEQ_TX_NESTED_METAS
-        if ((seq->depth != 0 || BKE_sequence_tx_test(seq))) {
+        if ((seq->depth != 0 || SEQ_transform_sequence_can_be_translated(seq))) {
           /* for meta's, their children move */
           seq->start = new_frame - tdsq->start_offset;
         }
@@ -697,18 +697,18 @@ static void flushTransSeq(TransInfo *t)
         }
         break;
       case SEQ_LEFTSEL: /* no vertical transform  */
-        BKE_sequence_tx_set_final_left(seq, new_frame);
-        BKE_sequence_tx_handle_xlimits(seq, tdsq->flag & SEQ_LEFTSEL, tdsq->flag & SEQ_RIGHTSEL);
+        SEQ_transform_set_left_handle_frame(seq, new_frame);
+        SEQ_transform_handle_xlimits(seq, tdsq->flag & SEQ_LEFTSEL, tdsq->flag & SEQ_RIGHTSEL);
 
         /* todo - move this into aftertrans update? - old seq tx needed it anyway */
-        BKE_sequence_single_fix(seq);
+        SEQ_transform_fix_single_image_seq_offsets(seq);
         break;
       case SEQ_RIGHTSEL: /* no vertical transform  */
-        BKE_sequence_tx_set_final_right(seq, new_frame);
-        BKE_sequence_tx_handle_xlimits(seq, tdsq->flag & SEQ_LEFTSEL, tdsq->flag & SEQ_RIGHTSEL);
+        SEQ_transform_set_right_handle_frame(seq, new_frame);
+        SEQ_transform_handle_xlimits(seq, tdsq->flag & SEQ_LEFTSEL, tdsq->flag & SEQ_RIGHTSEL);
 
         /* todo - move this into aftertrans update? - old seq tx needed it anyway */
-        BKE_sequence_single_fix(seq);
+        SEQ_transform_fix_single_image_seq_offsets(seq);
         break;
     }
 
@@ -743,12 +743,12 @@ static void flushTransSeq(TransInfo *t)
     /* calc all meta's then effects T27953. */
     for (seq = seqbasep->first; seq; seq = seq->next) {
       if (seq->type == SEQ_TYPE_META && seq->flag & SELECT) {
-        BKE_sequence_calc(t->scene, seq);
+        SEQ_time_update_sequence(t->scene, seq);
       }
     }
     for (seq = seqbasep->first; seq; seq = seq->next) {
       if (seq->seq1 || seq->seq2 || seq->seq3) {
-        BKE_sequence_calc(t->scene, seq);
+        SEQ_time_update_sequence(t->scene, seq);
       }
     }
 
@@ -759,7 +759,7 @@ static void flushTransSeq(TransInfo *t)
       seq = tdsq->seq;
       if ((seq != seq_prev) && (seq->depth != 0)) {
         if (seq->seq1 || seq->seq2 || seq->seq3) {
-          BKE_sequence_calc(t->scene, seq);
+          SEQ_time_update_sequence(t->scene, seq);
         }
       }
     }
@@ -777,7 +777,7 @@ static void flushTransSeq(TransInfo *t)
       if (seq->depth == 0) {
         /* test overlap, displays red outline */
         seq->flag &= ~SEQ_OVERLAP;
-        if (BKE_sequence_test_overlap(seqbasep, seq)) {
+        if (SEQ_transform_test_overlap(seqbasep, seq)) {
           seq->flag |= SEQ_OVERLAP;
         }
       }
@@ -800,7 +800,7 @@ void recalcData_sequencer(TransInfo *t)
     Sequence *seq = tdsq->seq;
 
     if (seq != seq_prev) {
-      BKE_sequence_invalidate_cache_composite(t->scene, seq);
+      SEQ_relations_invalidate_cache_composite(t->scene, seq);
     }
 
     seq_prev = seq;
diff --git a/source/blender/editors/transform/transform_snap.c b/source/blender/editors/transform/transform_snap.c
index f1c4c243780..8d20f1686f2 100644
--- a/source/blender/editors/transform/transform_snap.c
+++ b/source/blender/editors/transform/transform_snap.c
@@ -1409,7 +1409,7 @@ void snapSequenceBounds(TransInfo *t, const int mval[2])
   const int frame_curr = round_fl_to_int(xmouse);
 
   /* Now find the closest sequence. */
-  const int frame_near = BKE_sequencer_find_next_prev_edit(
+  const int frame_near = SEQ_time_find_next_prev_edit(
       t->scene, frame_curr, SEQ_SIDE_BOTH, true, false, true);
 
   const int frame_snap = transform_convert_sequencer_get_snap_bound(t);
diff --git a/source/blender/editors/util/ed_util_imbuf.c b/source/blender/editors/util/ed_util_imbuf.c
index b832d9a1d86..ca97a7b21c3 100644
--- a/source/blender/editors/util/ed_util_imbuf.c
+++ b/source/blender/editors/util/ed_util_imbuf.c
@@ -564,7 +564,7 @@ bool ED_imbuf_sample_poll(bContext *C)
       return false;
     }
 
-    return sseq && BKE_sequencer_editing_get(CTX_data_scene(C), false) != NULL;
+    return sseq && SEQ_editing_get(CTX_data_scene(C), false) != NULL;
   }
 
   return false;