Cleanup: Rename BKE_sequencer functions

API functions get SEQ_ prefix.
Intern functions get seq_ prefix

Functions also have appropriate category included in name.

1 files changed, 197 insertions, 198 deletions

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);
     }
   }