From 1bf893e9c886361bddda23bad7233385a262c098 Mon Sep 17 00:00:00 2001 From: Sergey Sharybin Date: Wed, 8 Aug 2012 11:15:40 +0000 Subject: Code cleanup: BKE_ prefix for public sequencer functions --- source/blender/blenkernel/intern/sequencer.c | 304 +++++++++++++-------------- 1 file changed, 151 insertions(+), 153 deletions(-) (limited to 'source/blender/blenkernel/intern/sequencer.c') diff --git a/source/blender/blenkernel/intern/sequencer.c b/source/blender/blenkernel/intern/sequencer.c index 50ce7552c98..137c0180fb4 100644 --- a/source/blender/blenkernel/intern/sequencer.c +++ b/source/blender/blenkernel/intern/sequencer.c @@ -103,17 +103,17 @@ static void printf_strip(Sequence *seq) } #endif -int seqbase_recursive_apply(ListBase *seqbase, int (*apply_func)(Sequence *seq, void *), void *arg) +int BKE_sequencer_base_recursive_apply(ListBase *seqbase, int (*apply_func)(Sequence *seq, void *), void *arg) { Sequence *iseq; for (iseq = seqbase->first; iseq; iseq = iseq->next) { - if (seq_recursive_apply(iseq, apply_func, arg) == -1) + if (BKE_sequencer_recursive_apply(iseq, apply_func, arg) == -1) return -1; /* bail out */ } return 1; } -int seq_recursive_apply(Sequence *seq, int (*apply_func)(Sequence *, void *), void *arg) +int BKE_sequencer_recursive_apply(Sequence *seq, int (*apply_func)(Sequence *, void *), void *arg) { int ret = apply_func(seq, arg); @@ -121,7 +121,7 @@ int seq_recursive_apply(Sequence *seq, int (*apply_func)(Sequence *, void *), vo return -1; /* bail out */ if (ret && seq->seqbase.first) - ret = seqbase_recursive_apply(&seq->seqbase, apply_func, arg); + ret = BKE_sequencer_base_recursive_apply(&seq->seqbase, apply_func, arg); return ret; } @@ -172,7 +172,7 @@ static void seq_free_strip(Strip *strip) MEM_freeN(strip); } -void seq_free_sequence(Scene *scene, Sequence *seq) +void BKE_sequence_free(Scene *scene, Sequence *seq) { if (seq->strip) seq_free_strip(seq->strip); @@ -181,7 +181,7 @@ void seq_free_sequence(Scene *scene, Sequence *seq) IMB_free_anim(seq->anim); if (seq->type & SEQ_TYPE_EFFECT) { - struct SeqEffectHandle sh = get_sequence_effect(seq); + struct SeqEffectHandle sh = BKE_sequence_get_effect(seq); sh.free(seq); } @@ -214,7 +214,7 @@ static void seq_free_sequence_recurse(Scene *scene, Sequence *seq) seq_free_sequence_recurse(scene, iseq); } - seq_free_sequence(scene, seq); + BKE_sequence_free(scene, seq); } @@ -235,10 +235,10 @@ static void seq_free_clipboard_recursive(Sequence *seq_parent) seq_free_clipboard_recursive(seq); } - seq_free_sequence(NULL, seq_parent); + BKE_sequence_free(NULL, seq_parent); } -void seq_free_clipboard(void) +void BKE_sequencer_free_clipboard(void) { Sequence *seq, *nseq; @@ -272,7 +272,7 @@ void BKE_sequencer_editing_free(Scene *scene) SEQ_BEGIN (ed, seq) { - seq_free_sequence(scene, seq); + BKE_sequence_free(scene, seq); } SEQ_END @@ -288,7 +288,7 @@ void BKE_sequencer_editing_free(Scene *scene) /*********************** sequencer pipeline functions *************************/ -SeqRenderData seq_new_render_data(Main *bmain, Scene *scene, int rectx, int recty, int preview_render_size) +SeqRenderData BKE_sequencer_new_render_data(Main *bmain, Scene *scene, int rectx, int recty, int preview_render_size) { SeqRenderData rval; @@ -363,7 +363,7 @@ static void seq_array(Editing *ed, Sequence ***seqarray, int *tot, int use_point seq_build_array(&ed->seqbase, &array, 0); } -void seq_begin(Editing *ed, SeqIterator *iter, int use_pointer) +void BKE_seqence_iterator_begin(Editing *ed, SeqIterator *iter, int use_pointer) { memset(iter, 0, sizeof(*iter)); seq_array(ed, &iter->array, &iter->tot, use_pointer); @@ -375,7 +375,7 @@ void seq_begin(Editing *ed, SeqIterator *iter, int use_pointer) } } -void seq_next(SeqIterator *iter) +void BKE_seqence_iterator_next(SeqIterator *iter) { if (++iter->cur < iter->tot) iter->seq = iter->array[iter->cur]; @@ -383,7 +383,7 @@ void seq_next(SeqIterator *iter) iter->valid = 0; } -void seq_end(SeqIterator *iter) +void BKE_seqence_iterator_end(SeqIterator *iter) { if (iter->array) MEM_freeN(iter->array); @@ -434,7 +434,7 @@ static void seq_update_sound_bounds_recursive(Scene *scene, Sequence *metaseq) seq_update_sound_bounds_recursive_rec(scene, metaseq, metaseq_start(metaseq), metaseq_end(metaseq)); } -void calc_sequence_disp(Scene *scene, Sequence *seq) +void BKE_sequence_calc_disp(Scene *scene, Sequence *seq) { if (seq->startofs && seq->startstill) seq->startstill = 0; @@ -453,13 +453,13 @@ void calc_sequence_disp(Scene *scene, Sequence *seq) } if (ELEM(seq->type, SEQ_TYPE_SOUND_RAM, SEQ_TYPE_SCENE)) { - seq_update_sound_bounds(scene, seq); + BKE_sequencer_update_sound_bounds(scene, seq); } else if (seq->type == SEQ_TYPE_META) seq_update_sound_bounds_recursive(scene, seq); } -void calc_sequence(Scene *scene, Sequence *seq) +void BKE_sequence_calc(Scene *scene, Sequence *seq) { Sequence *seqm; int min, max; @@ -467,7 +467,7 @@ void calc_sequence(Scene *scene, Sequence *seq) /* check all metas recursively */ seqm = seq->seqbase.first; while (seqm) { - if (seqm->seqbase.first) calc_sequence(scene, seqm); + if (seqm->seqbase.first) BKE_sequence_calc(scene, seqm); seqm = seqm->next; } @@ -509,7 +509,7 @@ void calc_sequence(Scene *scene, Sequence *seq) seq->len = seq->enddisp - seq->startdisp; } else { - calc_sequence_disp(scene, seq); + BKE_sequence_calc_disp(scene, seq); } } else { @@ -530,12 +530,12 @@ void calc_sequence(Scene *scene, Sequence *seq) } seq_update_sound_bounds_recursive(scene, seq); } - calc_sequence_disp(scene, seq); + BKE_sequence_calc_disp(scene, seq); } } /* note: caller should run calc_sequence(scene, seq) after */ -void reload_sequence_new_file(Scene *scene, Sequence *seq, int lock_range) +void BKE_sequence_reload_new_file(Scene *scene, Sequence *seq, int lock_range) { char str[FILE_MAX]; int prev_startdisp = 0, prev_enddisp = 0; @@ -550,7 +550,7 @@ void reload_sequence_new_file(Scene *scene, Sequence *seq, int lock_range) if (lock_range) { /* keep so we don't have to move the actual start and end points (only the data) */ - calc_sequence_disp(scene, seq); + BKE_sequence_calc_disp(scene, seq); prev_startdisp = seq->startdisp; prev_enddisp = seq->enddisp; } @@ -638,12 +638,12 @@ void reload_sequence_new_file(Scene *scene, Sequence *seq, int lock_range) free_proxy_seq(seq); if (lock_range) { - seq_tx_set_final_left(seq, prev_startdisp); - seq_tx_set_final_right(seq, prev_enddisp); - seq_single_fix(seq); + BKE_sequence_tx_set_final_left(seq, prev_startdisp); + BKE_sequence_tx_set_final_right(seq, prev_enddisp); + BKE_sequence_single_fix(seq); } - calc_sequence(scene, seq); + BKE_sequence_calc(scene, seq); } void BKE_sequencer_sort(Scene *scene) @@ -700,14 +700,14 @@ static int clear_scene_in_allseqs_cb(Sequence *seq, void *arg_pt) return 1; } -void clear_scene_in_allseqs(Main *bmain, Scene *scene) +void BKE_sequencer_clear_scene_in_allseqs(Main *bmain, Scene *scene) { Scene *scene_iter; /* when a scene is deleted: test all seqs */ for (scene_iter = bmain->scene.first; scene_iter; scene_iter = scene_iter->id.next) { if (scene_iter != scene && scene_iter->ed) { - seqbase_recursive_apply(&scene_iter->ed->seqbase, clear_scene_in_allseqs_cb, scene); + BKE_sequencer_base_recursive_apply(&scene_iter->ed->seqbase, clear_scene_in_allseqs_cb, scene); } } } @@ -739,7 +739,7 @@ static int seqbase_unique_name_recursive_cb(Sequence *seq, void *arg_pt) return 1; } -void seqbase_unique_name_recursive(ListBase *seqbasep, Sequence *seq) +void BKE_seqence_base_unique_name_recursive(ListBase *seqbasep, Sequence *seq) { SeqUniqueInfo sui; char *dot; @@ -762,7 +762,7 @@ void seqbase_unique_name_recursive(ListBase *seqbasep, Sequence *seq) while (sui.match) { sui.match = 0; seqbase_unique_name(seqbasep, &sui); - seqbase_recursive_apply(seqbasep, seqbase_unique_name_recursive_cb, &sui); + BKE_sequencer_base_recursive_apply(seqbasep, seqbase_unique_name_recursive_cb, &sui); } BLI_strncpy(seq->name + 2, sui.name_dest, sizeof(seq->name) - 2); @@ -798,7 +798,7 @@ static const char *give_seqname_by_type(int type) } } -const char *give_seqname(Sequence *seq) +const char *BKE_sequence_give_name(Sequence *seq) { const char *name = give_seqname_by_type(seq->type); @@ -914,7 +914,7 @@ static float give_stripelem_index(Sequence *seq, float cfra) return nr; } -StripElem *give_stripelem(Sequence *seq, int cfra) +StripElem *BKE_sequencer_give_stripelem(Sequence *seq, int cfra) { StripElem *se = seq->strip->stripdata; @@ -952,7 +952,7 @@ static int evaluate_seq_frame_gen(Sequence **seq_arr, ListBase *seqbase, int cfr return totseq; } -int evaluate_seq_frame(Scene *scene, int cfra) +int BKE_sequencer_evaluate_frame(Scene *scene, int cfra) { Editing *ed = BKE_sequencer_editing_get(scene, FALSE); Sequence *seq_arr[MAXSEQ + 1]; @@ -1130,7 +1130,7 @@ static int seq_proxy_get_fname(Sequence *seq, int cfra, int render_size, char *n if (seq->type == SEQ_TYPE_IMAGE) { BLI_snprintf(name, PROXY_MAXFILE, "%s/images/%d/%s_proxy", dir, render_size, - give_stripelem(seq, cfra)->name); + BKE_sequencer_give_stripelem(seq, cfra)->name); frameno = 1; } else { @@ -1244,7 +1244,7 @@ static void seq_proxy_build_frame(SeqRenderData context, Sequence *seq, int cfra IMB_freeImBuf(ibuf); } -SeqIndexBuildContext *seq_proxy_rebuild_context(Main *bmain, Scene *scene, Sequence *seq) +SeqIndexBuildContext *BKE_sequencer_proxy_rebuild_context(Main *bmain, Scene *scene, Sequence *seq) { SeqIndexBuildContext *context; Sequence *nseq; @@ -1259,7 +1259,7 @@ SeqIndexBuildContext *seq_proxy_rebuild_context(Main *bmain, Scene *scene, Seque context = MEM_callocN(sizeof(SeqIndexBuildContext), "seq proxy rebuild context"); - nseq = seq_dupli_recursive(scene, scene, seq, 0); + nseq = BKE_sequence_dupli_recursive(scene, scene, seq, 0); context->tc_flags = nseq->strip->proxy->build_tc_flags; context->size_flags = nseq->strip->proxy->build_size_flags; @@ -1282,7 +1282,7 @@ SeqIndexBuildContext *seq_proxy_rebuild_context(Main *bmain, Scene *scene, Seque return context; } -void seq_proxy_rebuild(SeqIndexBuildContext *context, short *stop, short *do_update, float *progress) +void BKE_sequencer_proxy_rebuild(SeqIndexBuildContext *context, short *stop, short *do_update, float *progress) { SeqRenderData render_context; Sequence *seq = context->seq; @@ -1308,7 +1308,7 @@ void seq_proxy_rebuild(SeqIndexBuildContext *context, short *stop, short *do_upd /* fail safe code */ - render_context = seq_new_render_data(context->bmain, context->scene, + render_context = BKE_sequencer_new_render_data(context->bmain, context->scene, (scene->r.size * (float) scene->r.xsch) / 100.0f + 0.5f, (scene->r.size * (float) scene->r.ysch) / 100.0f + 0.5f, 100); @@ -1334,7 +1334,7 @@ void seq_proxy_rebuild(SeqIndexBuildContext *context, short *stop, short *do_upd } } -void seq_proxy_rebuild_finish(SeqIndexBuildContext *context, short stop) +void BKE_sequencer_proxy_rebuild_finish(SeqIndexBuildContext *context, short stop) { if (context->index_context) { IMB_close_anim_proxies(context->seq->anim); @@ -1609,7 +1609,7 @@ static void color_balance(Sequence *seq, ImBuf *ibuf, float mul) * - Premultiply */ -int input_have_to_preprocess(SeqRenderData UNUSED(context), Sequence *seq, float UNUSED(cfra)) +int BKE_sequencer_input_have_to_preprocess(SeqRenderData UNUSED(context), Sequence *seq, float UNUSED(cfra)) { float mul; @@ -1773,10 +1773,10 @@ static ImBuf *copy_from_ibuf_still(SeqRenderData context, Sequence *seq, ImBuf *ibuf = NULL; if (nr == 0) { - ibuf = seq_stripelem_cache_get(context, seq, seq->start, SEQ_STRIPELEM_IBUF_STARTSTILL); + ibuf = BKE_sequencer_cache_get(context, seq, seq->start, SEQ_STRIPELEM_IBUF_STARTSTILL); } else if (nr == seq->len - 1) { - ibuf = seq_stripelem_cache_get(context, seq, seq->start, SEQ_STRIPELEM_IBUF_ENDSTILL); + ibuf = BKE_sequencer_cache_get(context, seq, seq->start, SEQ_STRIPELEM_IBUF_ENDSTILL); } if (ibuf) { @@ -1797,11 +1797,11 @@ static void copy_to_ibuf_still(SeqRenderData context, Sequence *seq, float nr, ibuf = IMB_dupImBuf(ibuf); if (nr == 0) { - seq_stripelem_cache_put(context, seq, seq->start, SEQ_STRIPELEM_IBUF_STARTSTILL, ibuf); + BKE_sequencer_cache_put(context, seq, seq->start, SEQ_STRIPELEM_IBUF_STARTSTILL, ibuf); } if (nr == seq->len - 1) { - seq_stripelem_cache_put(context, seq, seq->start, SEQ_STRIPELEM_IBUF_ENDSTILL, ibuf); + BKE_sequencer_cache_put(context, seq, seq->start, SEQ_STRIPELEM_IBUF_ENDSTILL, ibuf); } IMB_freeImBuf(ibuf); @@ -1815,7 +1815,7 @@ static ImBuf *seq_render_effect_strip_impl(SeqRenderData context, Sequence *seq, float fac, facf; int early_out; int i; - struct SeqEffectHandle sh = get_sequence_effect(seq); + struct SeqEffectHandle sh = BKE_sequence_get_effect(seq); FCurve *fcu = NULL; ImBuf *ibuf[3]; Sequence *input[3]; @@ -1874,7 +1874,7 @@ static ImBuf *seq_render_effect_strip_impl(SeqRenderData context, Sequence *seq, ibuf[0] = seq_render_strip(context, input[0], cfra); } if (ibuf[0]) { - if (input_have_to_preprocess(context, seq, cfra)) { + if (BKE_sequencer_input_have_to_preprocess(context, seq, cfra)) { out = IMB_dupImBuf(ibuf[0]); } else { @@ -1888,7 +1888,7 @@ static ImBuf *seq_render_effect_strip_impl(SeqRenderData context, Sequence *seq, ibuf[1] = seq_render_strip(context, input[1], cfra); } if (ibuf[1]) { - if (input_have_to_preprocess(context, seq, cfra)) { + if (BKE_sequencer_input_have_to_preprocess(context, seq, cfra)) { out = IMB_dupImBuf(ibuf[1]); } else { @@ -2193,14 +2193,14 @@ static ImBuf *seq_render_strip(SeqRenderData context, Sequence *seq, float cfra) { ImBuf *ibuf = NULL; char name[FILE_MAX]; - int use_preprocess = input_have_to_preprocess(context, seq, cfra); + int use_preprocess = BKE_sequencer_input_have_to_preprocess(context, seq, cfra); int is_proxy_image = FALSE; float nr = give_stripelem_index(seq, cfra); /* all effects are handled similarly with the exception of speed effect */ int type = (seq->type & SEQ_TYPE_EFFECT && seq->type != SEQ_TYPE_SPEED) ? SEQ_TYPE_EFFECT : seq->type; int is_preprocessed = !ELEM3(type, SEQ_TYPE_IMAGE, SEQ_TYPE_MOVIE, SEQ_TYPE_SCENE); - ibuf = seq_stripelem_cache_get(context, seq, cfra, SEQ_STRIPELEM_IBUF); + ibuf = BKE_sequencer_cache_get(context, seq, cfra, SEQ_STRIPELEM_IBUF); /* currently, we cache preprocessed images in SEQ_STRIPELEM_IBUF, * but not(!) on SEQ_STRIPELEM_IBUF_ENDSTILL and ..._STARTSTILL */ @@ -2246,7 +2246,7 @@ static ImBuf *seq_render_strip(SeqRenderData context, Sequence *seq, float cfra) float f_cfra; SpeedControlVars *s = (SpeedControlVars *)seq->effectdata; - sequence_effect_speed_rebuild_map(context.scene, seq, 0); + BKE_sequence_effect_speed_rebuild_map(context.scene, seq, 0); /* weeek! */ f_cfra = seq->start + s->frameMap[(int)nr]; @@ -2272,9 +2272,7 @@ static ImBuf *seq_render_strip(SeqRenderData context, Sequence *seq, float cfra) } case SEQ_TYPE_IMAGE: { - StripElem *s_elem = give_stripelem(seq, cfra); - - printf("Render image strip\n"); + StripElem *s_elem = BKE_sequencer_give_stripelem(seq, cfra); if (s_elem) { BLI_join_dirfile(name, sizeof(name), seq->strip->dir, s_elem->name); @@ -2364,7 +2362,7 @@ static ImBuf *seq_render_strip(SeqRenderData context, Sequence *seq, float cfra) if (use_preprocess) ibuf = input_preprocess(context, seq, cfra, ibuf, is_proxy_image, is_preprocessed); - seq_stripelem_cache_put(context, seq, cfra, SEQ_STRIPELEM_IBUF, ibuf); + BKE_sequencer_cache_put(context, seq, cfra, SEQ_STRIPELEM_IBUF, ibuf); return ibuf; } @@ -2387,7 +2385,7 @@ static int seq_must_swap_input_in_blend_mode(Sequence *seq) static int seq_get_early_out_for_blend_mode(Sequence *seq) { - struct SeqEffectHandle sh = get_sequence_blend(seq); + struct SeqEffectHandle sh = BKE_sequence_get_blend(seq); float facf = seq->blend_opacity / 100.0f; int early_out = sh.early_out(seq, facf, facf); @@ -2427,7 +2425,7 @@ static ImBuf *seq_render_strip_stack(SeqRenderData context, ListBase *seqbasep, } #endif - out = seq_stripelem_cache_get(context, seq_arr[count - 1], cfra, SEQ_STRIPELEM_IBUF_COMP); + out = BKE_sequencer_cache_get(context, seq_arr[count - 1], cfra, SEQ_STRIPELEM_IBUF_COMP); if (out) { return out; @@ -2435,7 +2433,7 @@ static ImBuf *seq_render_strip_stack(SeqRenderData context, ListBase *seqbasep, if (count == 1) { out = seq_render_strip(context, seq_arr[0], cfra); - seq_stripelem_cache_put(context, seq_arr[0], cfra, SEQ_STRIPELEM_IBUF_COMP, out); + BKE_sequencer_cache_put(context, seq_arr[0], cfra, SEQ_STRIPELEM_IBUF_COMP, out); return out; } @@ -2445,7 +2443,7 @@ static ImBuf *seq_render_strip_stack(SeqRenderData context, ListBase *seqbasep, int early_out; Sequence *seq = seq_arr[i]; - out = seq_stripelem_cache_get(context, seq, cfra, SEQ_STRIPELEM_IBUF_COMP); + out = BKE_sequencer_cache_get(context, seq, cfra, SEQ_STRIPELEM_IBUF_COMP); if (out) { break; @@ -2479,7 +2477,7 @@ static ImBuf *seq_render_strip_stack(SeqRenderData context, ListBase *seqbasep, } } - seq_stripelem_cache_put(context, seq_arr[i], cfra, SEQ_STRIPELEM_IBUF_COMP, out); + BKE_sequencer_cache_put(context, seq_arr[i], cfra, SEQ_STRIPELEM_IBUF_COMP, out); i++; @@ -2487,7 +2485,7 @@ static ImBuf *seq_render_strip_stack(SeqRenderData context, ListBase *seqbasep, Sequence *seq = seq_arr[i]; if (seq_get_early_out_for_blend_mode(seq) == EARLY_DO_EFFECT) { - struct SeqEffectHandle sh = get_sequence_blend(seq); + struct SeqEffectHandle sh = BKE_sequence_get_blend(seq); ImBuf *ibuf1 = out; ImBuf *ibuf2 = seq_render_strip(context, seq, cfra); @@ -2509,7 +2507,7 @@ static ImBuf *seq_render_strip_stack(SeqRenderData context, ListBase *seqbasep, IMB_freeImBuf(ibuf2); } - seq_stripelem_cache_put(context, seq_arr[i], cfra, SEQ_STRIPELEM_IBUF_COMP, out); + BKE_sequencer_cache_put(context, seq_arr[i], cfra, SEQ_STRIPELEM_IBUF_COMP, out); } return out; @@ -2520,7 +2518,7 @@ static ImBuf *seq_render_strip_stack(SeqRenderData context, ListBase *seqbasep, * you have to free after usage! */ -ImBuf *give_ibuf_seq(SeqRenderData context, float cfra, int chanshown) +ImBuf *BKE_sequencer_give_ibuf(SeqRenderData context, float cfra, int chanshown) { Editing *ed = BKE_sequencer_editing_get(context.scene, FALSE); int count; @@ -2540,13 +2538,13 @@ ImBuf *give_ibuf_seq(SeqRenderData context, float cfra, int chanshown) return seq_render_strip_stack(context, seqbasep, cfra, chanshown); } -ImBuf *give_ibuf_seqbase(SeqRenderData context, float cfra, int chanshown, ListBase *seqbasep) +ImBuf *BKE_sequencer_give_ibuf_seqbase(SeqRenderData context, float cfra, int chanshown, ListBase *seqbasep) { return seq_render_strip_stack(context, seqbasep, cfra, chanshown); } -ImBuf *give_ibuf_seq_direct(SeqRenderData context, float cfra, Sequence *seq) +ImBuf *BKE_sequencer_give_ibuf_direct(SeqRenderData context, float cfra, Sequence *seq) { return seq_render_strip(context, seq, cfra); } @@ -2595,7 +2593,7 @@ typedef struct PrefetchQueueElem { ImBuf *ibuf; } PrefetchQueueElem; -void give_ibuf_prefetch_request(SeqRenderData context, float cfra, int chanshown) +void BKE_sequencer_give_ibuf_prefetch_request(SeqRenderData context, float cfra, int chanshown) { PrefetchQueueElem *e; if (seq_thread_shutdown) { @@ -2619,13 +2617,13 @@ void give_ibuf_prefetch_request(SeqRenderData context, float cfra, int chanshown pthread_mutex_unlock(&wakeup_lock); } -ImBuf *give_ibuf_seq_threaded(SeqRenderData context, float cfra, int chanshown) +ImBuf *BKE_sequencer_give_ibuf_threaded(SeqRenderData context, float cfra, int chanshown) { PrefetchQueueElem *e = NULL; int found_something = FALSE; if (seq_thread_shutdown) { - return give_ibuf_seq(context, cfra, chanshown); + return BKE_sequencer_give_ibuf(context, cfra, chanshown); } while (!e) { @@ -2713,7 +2711,7 @@ static void free_anim_seq(Sequence *seq) } } -void free_imbuf_seq(Scene *scene, ListBase *seqbase, int check_mem_usage, int keep_file_handles) +void BKE_sequencer_free_imbuf(Scene *scene, ListBase *seqbase, int check_mem_usage, int keep_file_handles) { Sequence *seq; @@ -2741,18 +2739,18 @@ void free_imbuf_seq(Scene *scene, ListBase *seqbase, int check_mem_usage, int ke } } - seq_stripelem_cache_cleanup(); + BKE_sequencer_stripelem_cache_cleanup(); for (seq = seqbase->first; seq; seq = seq->next) { if (seq->strip) { if (seq->type == SEQ_TYPE_MOVIE && !keep_file_handles) free_anim_seq(seq); if (seq->type == SEQ_TYPE_SPEED) { - sequence_effect_speed_rebuild_map(scene, seq, 1); + BKE_sequence_effect_speed_rebuild_map(scene, seq, 1); } } if (seq->type == SEQ_TYPE_META) { - free_imbuf_seq(scene, &seq->seqbase, FALSE, keep_file_handles); + BKE_sequencer_free_imbuf(scene, &seq->seqbase, FALSE, keep_file_handles); } if (seq->type == SEQ_TYPE_SCENE) { /* FIXME: recurs downwards, @@ -2794,18 +2792,18 @@ static int update_changed_seq_recurs(Scene *scene, Sequence *seq, Sequence *chan if (seq->type == SEQ_TYPE_MOVIE) free_anim_seq(seq); if (seq->type == SEQ_TYPE_SPEED) { - sequence_effect_speed_rebuild_map(scene, seq, 1); + BKE_sequence_effect_speed_rebuild_map(scene, seq, 1); } } if (len_change) - calc_sequence(scene, seq); + BKE_sequence_calc(scene, seq); } return free_imbuf; } -void update_changed_seq_and_deps(Scene *scene, Sequence *changed_seq, int len_change, int ibuf_change) +void BKE_sequencer_update_changed_seq_and_deps(Scene *scene, Sequence *changed_seq, int len_change, int ibuf_change) { Editing *ed = BKE_sequencer_editing_get(scene, FALSE); Sequence *seq; @@ -2831,29 +2829,29 @@ static int seq_tx_get_end(Sequence *seq) return seq->start + seq->len; } -int seq_tx_get_final_left(Sequence *seq, int metaclip) +int BKE_sequence_tx_get_final_left(Sequence *seq, int metaclip) { if (metaclip && seq->tmp) { /* return the range clipped by the parents range */ - return maxi(seq_tx_get_final_left(seq, 0), seq_tx_get_final_left((Sequence *)seq->tmp, TRUE)); + return maxi(BKE_sequence_tx_get_final_left(seq, 0), BKE_sequence_tx_get_final_left((Sequence *)seq->tmp, TRUE)); } else { return (seq->start - seq->startstill) + seq->startofs; } } -int seq_tx_get_final_right(Sequence *seq, int metaclip) +int BKE_sequence_tx_get_final_right(Sequence *seq, int metaclip) { if (metaclip && seq->tmp) { /* return the range clipped by the parents range */ - return mini(seq_tx_get_final_right(seq, 0), seq_tx_get_final_right((Sequence *)seq->tmp, TRUE)); + return mini(BKE_sequence_tx_get_final_right(seq, 0), BKE_sequence_tx_get_final_right((Sequence *)seq->tmp, TRUE)); } else { return ((seq->start + seq->len) + seq->endstill) - seq->endofs; } } -void seq_tx_set_final_left(Sequence *seq, int val) +void BKE_sequence_tx_set_final_left(Sequence *seq, int val) { if (val < (seq)->start) { seq->startstill = abs(val - (seq)->start); @@ -2865,7 +2863,7 @@ void seq_tx_set_final_left(Sequence *seq, int val) } } -void seq_tx_set_final_right(Sequence *seq, int val) +void BKE_sequence_tx_set_final_right(Sequence *seq, int val) { if (val > (seq)->start + (seq)->len) { seq->endstill = abs(val - (seq->start + (seq)->len)); @@ -2879,16 +2877,16 @@ void seq_tx_set_final_right(Sequence *seq, int val) /* used so we can do a quick check for single image seq * since they work a bit differently to normal image seq's (during transform) */ -int seq_single_check(Sequence *seq) +int BKE_sequence_single_check(Sequence *seq) { return ((seq->len == 1) && (seq->type == SEQ_TYPE_IMAGE || ((seq->type & SEQ_TYPE_EFFECT) && - get_sequence_effect_num_inputs(seq->type) == 0))); + BKE_sequence_effect_get_num_inputs(seq->type) == 0))); } /* check if the selected seq's reference unselected seq's */ -int seqbase_isolated_sel_check(ListBase *seqbase) +int BKE_sequence_base_isolated_sel_check(ListBase *seqbase) { Sequence *seq; /* is there more than 1 select */ @@ -2932,16 +2930,16 @@ int seqbase_isolated_sel_check(ListBase *seqbase) /* use to impose limits when dragging/extending - so impossible situations don't happen * Cant use the SEQ_LEFTSEL and SEQ_LEFTSEL directly because the strip may be in a metastrip */ -void seq_tx_handle_xlimits(Sequence *seq, int leftflag, int rightflag) +void BKE_sequence_tx_handle_xlimits(Sequence *seq, int leftflag, int rightflag) { if (leftflag) { - if (seq_tx_get_final_left(seq, 0) >= seq_tx_get_final_right(seq, 0)) { - seq_tx_set_final_left(seq, seq_tx_get_final_right(seq, 0) - 1); + if (BKE_sequence_tx_get_final_left(seq, 0) >= BKE_sequence_tx_get_final_right(seq, 0)) { + BKE_sequence_tx_set_final_left(seq, BKE_sequence_tx_get_final_right(seq, 0) - 1); } - if (seq_single_check(seq) == 0) { - if (seq_tx_get_final_left(seq, 0) >= seq_tx_get_end(seq)) { - seq_tx_set_final_left(seq, seq_tx_get_end(seq) - 1); + if (BKE_sequence_single_check(seq) == 0) { + if (BKE_sequence_tx_get_final_left(seq, 0) >= seq_tx_get_end(seq)) { + BKE_sequence_tx_set_final_left(seq, seq_tx_get_end(seq) - 1); } /* dosnt work now - TODO */ @@ -2957,13 +2955,13 @@ void seq_tx_handle_xlimits(Sequence *seq, int leftflag, int rightflag) } if (rightflag) { - if (seq_tx_get_final_right(seq, 0) <= seq_tx_get_final_left(seq, 0)) { - seq_tx_set_final_right(seq, seq_tx_get_final_left(seq, 0) + 1); + if (BKE_sequence_tx_get_final_right(seq, 0) <= BKE_sequence_tx_get_final_left(seq, 0)) { + BKE_sequence_tx_set_final_right(seq, BKE_sequence_tx_get_final_left(seq, 0) + 1); } - if (seq_single_check(seq) == 0) { - if (seq_tx_get_final_right(seq, 0) <= seq_tx_get_start(seq)) { - seq_tx_set_final_right(seq, seq_tx_get_start(seq) + 1); + if (BKE_sequence_single_check(seq) == 0) { + if (BKE_sequence_tx_get_final_right(seq, 0) <= seq_tx_get_start(seq)) { + BKE_sequence_tx_set_final_right(seq, seq_tx_get_start(seq) + 1); } } } @@ -2975,27 +2973,27 @@ void seq_tx_handle_xlimits(Sequence *seq, int leftflag, int rightflag) } } -void seq_single_fix(Sequence *seq) +void BKE_sequence_single_fix(Sequence *seq) { int left, start, offset; - if (!seq_single_check(seq)) + if (!BKE_sequence_single_check(seq)) return; /* make sure the image is always at the start since there is only one, * adjusting its start should be ok */ - left = seq_tx_get_final_left(seq, 0); + left = BKE_sequence_tx_get_final_left(seq, 0); start = seq->start; if (start != left) { offset = left - start; - seq_tx_set_final_left(seq, seq_tx_get_final_left(seq, 0) - offset); - seq_tx_set_final_right(seq, seq_tx_get_final_right(seq, 0) - offset); + BKE_sequence_tx_set_final_left(seq, BKE_sequence_tx_get_final_left(seq, 0) - offset); + BKE_sequence_tx_set_final_right(seq, BKE_sequence_tx_get_final_right(seq, 0) - offset); seq->start += offset; } } -int seq_tx_test(Sequence *seq) +int BKE_sequence_tx_test(Sequence *seq) { - return (seq->type < SEQ_TYPE_EFFECT) || (get_sequence_effect_num_inputs(seq->type) == 0); + return (seq->type < SEQ_TYPE_EFFECT) || (BKE_sequence_effect_get_num_inputs(seq->type) == 0); } static int seq_overlap(Sequence *seq1, Sequence *seq2) @@ -3004,7 +3002,7 @@ static int seq_overlap(Sequence *seq1, Sequence *seq2) ((seq1->enddisp <= seq2->startdisp) || (seq1->startdisp >= seq2->enddisp)) == 0); } -int seq_test_overlap(ListBase *seqbasep, Sequence *test) +int BKE_sequence_test_overlap(ListBase *seqbasep, Sequence *test) { Sequence *seq; @@ -3019,27 +3017,27 @@ int seq_test_overlap(ListBase *seqbasep, Sequence *test) } -void seq_translate(Scene *evil_scene, Sequence *seq, int delta) +void BKE_sequence_translate(Scene *evil_scene, Sequence *seq, int delta) { - seq_offset_animdata(evil_scene, seq, delta); + BKE_sequencer_offset_animdata(evil_scene, seq, delta); seq->start += delta; if (seq->type == SEQ_TYPE_META) { Sequence *seq_child; for (seq_child = seq->seqbase.first; seq_child; seq_child = seq_child->next) { - seq_translate(evil_scene, seq_child, delta); + BKE_sequence_translate(evil_scene, seq_child, delta); } } - calc_sequence_disp(evil_scene, seq); + BKE_sequence_calc_disp(evil_scene, seq); } -void seq_sound_init(Scene *scene, Sequence *seq) +void BKE_sequence_sound_init(Scene *scene, Sequence *seq) { if (seq->type == SEQ_TYPE_META) { Sequence *seq_child; for (seq_child = seq->seqbase.first; seq_child; seq_child = seq_child->next) { - seq_sound_init(scene, seq_child); + BKE_sequence_sound_init(scene, seq_child); } } else { @@ -3052,7 +3050,7 @@ void seq_sound_init(Scene *scene, Sequence *seq) } } -Sequence *seq_foreground_frame_get(Scene *scene, int frame) +Sequence *BKE_sequencer_foreground_frame_get(Scene *scene, int frame) { Editing *ed = BKE_sequencer_editing_get(scene, FALSE); Sequence *seq, *best_seq = NULL; @@ -3075,17 +3073,17 @@ Sequence *seq_foreground_frame_get(Scene *scene, int frame) } /* return 0 if there werent enough space */ -int shuffle_seq(ListBase *seqbasep, Sequence *test, Scene *evil_scene) +int BKE_sequence_base_shuffle(ListBase *seqbasep, Sequence *test, Scene *evil_scene) { int orig_machine = test->machine; test->machine++; - calc_sequence(evil_scene, test); - while (seq_test_overlap(seqbasep, test) ) { + BKE_sequence_calc(evil_scene, test); + while (BKE_sequence_test_overlap(seqbasep, test) ) { if (test->machine >= MAXSEQ) { break; } test->machine++; - calc_sequence(evil_scene, test); // XXX - I don't think this is needed since were only moving vertically, Campbell. + BKE_sequence_calc(evil_scene, test); // XXX - I don't think this is needed since were only moving vertically, Campbell. } @@ -3103,9 +3101,9 @@ int shuffle_seq(ListBase *seqbasep, Sequence *test, Scene *evil_scene) test->machine = orig_machine; new_frame = new_frame + (test->start - test->startdisp); /* adjust by the startdisp */ - seq_translate(evil_scene, test, new_frame - test->start); + BKE_sequence_translate(evil_scene, test, new_frame - test->start); - calc_sequence(evil_scene, test); + BKE_sequence_calc(evil_scene, test); return 0; } else { @@ -3154,13 +3152,13 @@ static int shuffle_seq_time_offset(Scene *scene, ListBase *seqbasep, char dir) for (seq = seqbasep->first; seq; seq = seq->next) { if (seq->tmp) - calc_sequence_disp(scene, seq); /* corrects dummy startdisp/enddisp values */ + BKE_sequence_calc_disp(scene, seq); /* corrects dummy startdisp/enddisp values */ } return tot_ofs; } -int shuffle_seq_time(ListBase *seqbasep, Scene *evil_scene) +int BKE_sequence_base_shuffle_time(ListBase *seqbasep, Scene *evil_scene) { /* note: seq->tmp is used to tag strips to move */ @@ -3173,7 +3171,7 @@ int shuffle_seq_time(ListBase *seqbasep, Scene *evil_scene) if (offset) { for (seq = seqbasep->first; seq; seq = seq->next) { if (seq->tmp) { - seq_translate(evil_scene, seq, offset); + BKE_sequence_translate(evil_scene, seq, offset); seq->flag &= ~SEQ_OVERLAP; } } @@ -3182,7 +3180,7 @@ int shuffle_seq_time(ListBase *seqbasep, Scene *evil_scene) return offset ? 0 : 1; } -void seq_update_sound_bounds_all(Scene *scene) +void BKE_sequencer_update_sound_bounds_all(Scene *scene) { Editing *ed = scene->ed; @@ -3194,13 +3192,13 @@ void seq_update_sound_bounds_all(Scene *scene) seq_update_sound_bounds_recursive(scene, seq); } else if (ELEM(seq->type, SEQ_TYPE_SOUND_RAM, SEQ_TYPE_SCENE)) { - seq_update_sound_bounds(scene, seq); + BKE_sequencer_update_sound_bounds(scene, seq); } } } } -void seq_update_sound_bounds(Scene *scene, Sequence *seq) +void BKE_sequencer_update_sound_bounds(Scene *scene, Sequence *seq) { sound_move_scene_sound_defaults(scene, seq); /* mute is set in seq_update_muting_recursive */ @@ -3232,7 +3230,7 @@ static void seq_update_muting_recursive(ListBase *seqbasep, Sequence *metaseq, i } } -void seq_update_muting(Editing *ed) +void BKE_sequencer_update_muting(Editing *ed) { if (ed) { /* mute all sounds up to current metastack list */ @@ -3261,7 +3259,7 @@ static void seq_update_sound_recursive(Scene *scene, ListBase *seqbasep, bSound } } -void seq_update_sound(Scene *scene, bSound *sound) +void BKE_sequencer_update_sound(Scene *scene, bSound *sound) { if (scene->ed) { seq_update_sound_recursive(scene, &scene->ed->seqbase, sound); @@ -3269,7 +3267,7 @@ void seq_update_sound(Scene *scene, bSound *sound) } /* in cases where we done know the sequence's listbase */ -ListBase *seq_seqbase(ListBase *seqbase, Sequence *seq) +ListBase *BKE_sequence_seqbase(ListBase *seqbase, Sequence *seq) { Sequence *iseq; ListBase *lb = NULL; @@ -3278,7 +3276,7 @@ ListBase *seq_seqbase(ListBase *seqbase, Sequence *seq) if (seq == iseq) { return seqbase; } - else if (iseq->seqbase.first && (lb = seq_seqbase(&iseq->seqbase, seq))) { + else if (iseq->seqbase.first && (lb = BKE_sequence_seqbase(&iseq->seqbase, seq))) { return lb; } } @@ -3286,7 +3284,7 @@ ListBase *seq_seqbase(ListBase *seqbase, Sequence *seq) return NULL; } -Sequence *seq_metastrip(ListBase *seqbase, Sequence *meta, Sequence *seq) +Sequence *BKE_sequence_metastrip(ListBase *seqbase, Sequence *meta, Sequence *seq) { Sequence *iseq; @@ -3297,7 +3295,7 @@ Sequence *seq_metastrip(ListBase *seqbase, Sequence *meta, Sequence *seq) return meta; } else if (iseq->seqbase.first && - (rval = seq_metastrip(&iseq->seqbase, iseq, seq))) + (rval = BKE_sequence_metastrip(&iseq->seqbase, iseq, seq))) { return rval; } @@ -3306,7 +3304,7 @@ Sequence *seq_metastrip(ListBase *seqbase, Sequence *meta, Sequence *seq) return NULL; } -int seq_swap(Sequence *seq_a, Sequence *seq_b, const char **error_str) +int BKE_sequence_swap(Sequence *seq_a, Sequence *seq_b, const char **error_str) { char name[sizeof(seq_a->name)]; @@ -3329,7 +3327,7 @@ int seq_swap(Sequence *seq_a, Sequence *seq_b, const char **error_str) } if ((seq_a->type & SEQ_TYPE_EFFECT) && (seq_b->type & SEQ_TYPE_EFFECT)) { - if (get_sequence_effect_num_inputs(seq_a->type) != get_sequence_effect_num_inputs(seq_b->type)) { + if (BKE_sequence_effect_get_num_inputs(seq_a->type) != BKE_sequence_effect_get_num_inputs(seq_b->type)) { *error_str = "Strips must have the same number of inputs"; return 0; } @@ -3363,7 +3361,7 @@ int seq_swap(Sequence *seq_a, Sequence *seq_b, const char **error_str) } /* XXX - hackish function needed for transforming strips! TODO - have some better solution */ -void seq_offset_animdata(Scene *scene, Sequence *seq, int ofs) +void BKE_sequencer_offset_animdata(Scene *scene, Sequence *seq, int ofs) { char str[SEQ_NAME_MAXSTR + 3]; FCurve *fcu; @@ -3386,7 +3384,7 @@ void seq_offset_animdata(Scene *scene, Sequence *seq, int ofs) } } -void seq_dupe_animdata(Scene *scene, const char *name_src, const char *name_dst) +void BKE_sequencer_dupe_animdata(Scene *scene, const char *name_src, const char *name_dst) { char str_from[SEQ_NAME_MAXSTR + 3]; FCurve *fcu; @@ -3443,7 +3441,7 @@ static void seq_free_animdata(Scene *scene, Sequence *seq) } } -Sequence *get_seq_by_name(ListBase *seqbase, const char *name, int recursive) +Sequence *BKE_sequwnce_get_by_name(ListBase *seqbase, const char *name, int recursive) { Sequence *iseq = NULL; Sequence *rseq = NULL; @@ -3451,7 +3449,7 @@ Sequence *get_seq_by_name(ListBase *seqbase, const char *name, int recursive) for (iseq = seqbase->first; iseq; iseq = iseq->next) { if (strcmp(name, iseq->name + 2) == 0) return iseq; - else if (recursive && (iseq->seqbase.first) && (rseq = get_seq_by_name(&iseq->seqbase, name, 1))) { + else if (recursive && (iseq->seqbase.first) && (rseq = BKE_sequwnce_get_by_name(&iseq->seqbase, name, 1))) { return rseq; } } @@ -3527,7 +3525,7 @@ static void seq_load_apply(Scene *scene, Sequence *seq, SeqLoadInfo *seq_load) { if (seq) { BLI_strncpy(seq->name + 2, seq_load->name, sizeof(seq->name) - 2); - seqbase_unique_name_recursive(&scene->ed->seqbase, seq); + BKE_seqence_base_unique_name_recursive(&scene->ed->seqbase, seq); if (seq_load->flag & SEQ_LOAD_FRAME_ADVANCE) { seq_load->start_frame += (seq->enddisp - seq->startdisp); @@ -3550,7 +3548,7 @@ static void seq_load_apply(Scene *scene, Sequence *seq, SeqLoadInfo *seq_load) } } -Sequence *alloc_sequence(ListBase *lb, int cfra, int machine) +Sequence *BKE_sequence_alloc(ListBase *lb, int cfra, int machine) { Sequence *seq; @@ -3574,13 +3572,13 @@ Sequence *alloc_sequence(ListBase *lb, int cfra, int machine) } /* NOTE: this function doesn't fill in image names */ -Sequence *sequencer_add_image_strip(bContext *C, ListBase *seqbasep, SeqLoadInfo *seq_load) +Sequence *BKE_sequencer_add_image_strip(bContext *C, ListBase *seqbasep, SeqLoadInfo *seq_load) { Scene *scene = CTX_data_scene(C); /* only for active seq */ Sequence *seq; Strip *strip; - seq = alloc_sequence(seqbasep, seq_load->start_frame, seq_load->channel); + seq = BKE_sequence_alloc(seqbasep, seq_load->start_frame, seq_load->channel); seq->type = SEQ_TYPE_IMAGE; seq->blend_mode = SEQ_TYPE_CROSS; /* so alpha adjustment fade to the strip below */ @@ -3598,7 +3596,7 @@ Sequence *sequencer_add_image_strip(bContext *C, ListBase *seqbasep, SeqLoadInfo } #ifdef WITH_AUDASPACE -Sequence *sequencer_add_sound_strip(bContext *C, ListBase *seqbasep, SeqLoadInfo *seq_load) +Sequence *BKE_sequencer_add_sound_strip(bContext *C, ListBase *seqbasep, SeqLoadInfo *seq_load) { Main *bmain = CTX_data_main(C); Scene *scene = CTX_data_scene(C); /* only for sound */ @@ -3633,12 +3631,12 @@ Sequence *sequencer_add_sound_strip(bContext *C, ListBase *seqbasep, SeqLoadInfo return NULL; } - seq = alloc_sequence(seqbasep, seq_load->start_frame, seq_load->channel); + seq = BKE_sequence_alloc(seqbasep, seq_load->start_frame, seq_load->channel); seq->type = SEQ_TYPE_SOUND_RAM; seq->sound = sound; BLI_strncpy(seq->name + 2, "Sound", SEQ_NAME_MAXSTR - 2); - seqbase_unique_name_recursive(&scene->ed->seqbase, seq); + BKE_seqence_base_unique_name_recursive(&scene->ed->seqbase, seq); /* basic defaults */ seq->strip = strip = MEM_callocN(sizeof(Strip), "strip"); @@ -3652,7 +3650,7 @@ Sequence *sequencer_add_sound_strip(bContext *C, ListBase *seqbasep, SeqLoadInfo seq->scene_sound = sound_add_scene_sound(scene, seq, seq_load->start_frame, seq_load->start_frame + seq->len, 0); - calc_sequence_disp(scene, seq); + BKE_sequence_calc_disp(scene, seq); /* last active name */ BLI_strncpy(ed->act_sounddir, strip->dir, FILE_MAXDIR); @@ -3671,7 +3669,7 @@ Sequence *sequencer_add_sound_strip(bContext *C, ListBase *seqbasep, SeqLoadInfo } #endif // WITH_AUDASPACE -Sequence *sequencer_add_movie_strip(bContext *C, ListBase *seqbasep, SeqLoadInfo *seq_load) +Sequence *BKE_sequencer_add_movie_strip(bContext *C, ListBase *seqbasep, SeqLoadInfo *seq_load) { Scene *scene = CTX_data_scene(C); /* only for sound */ char path[sizeof(seq_load->path)]; @@ -3690,14 +3688,14 @@ Sequence *sequencer_add_movie_strip(bContext *C, ListBase *seqbasep, SeqLoadInfo if (an == NULL) return NULL; - seq = alloc_sequence(seqbasep, seq_load->start_frame, seq_load->channel); + seq = BKE_sequence_alloc(seqbasep, seq_load->start_frame, seq_load->channel); seq->type = SEQ_TYPE_MOVIE; seq->blend_mode = SEQ_TYPE_CROSS; /* so alpha adjustment fade to the strip below */ seq->anim = an; seq->anim_preseek = IMB_anim_get_preseek(an); BLI_strncpy(seq->name + 2, "Movie", SEQ_NAME_MAXSTR - 2); - seqbase_unique_name_recursive(&scene->ed->seqbase, seq); + BKE_seqence_base_unique_name_recursive(&scene->ed->seqbase, seq); /* basic defaults */ seq->strip = strip = MEM_callocN(sizeof(Strip), "strip"); @@ -3709,14 +3707,14 @@ Sequence *sequencer_add_movie_strip(bContext *C, ListBase *seqbasep, SeqLoadInfo BLI_split_dirfile(seq_load->path, strip->dir, se->name, sizeof(strip->dir), sizeof(se->name)); - calc_sequence_disp(scene, seq); + BKE_sequence_calc_disp(scene, seq); if (seq_load->flag & SEQ_LOAD_MOVIE_SOUND) { int start_frame_back = seq_load->start_frame; seq_load->channel++; - sequencer_add_sound_strip(C, seqbasep, seq_load); + BKE_sequencer_add_sound_strip(C, seqbasep, seq_load); seq_load->start_frame = start_frame_back; seq_load->channel--; @@ -3794,7 +3792,7 @@ static Sequence *seq_dupli(Scene *scene, Scene *scene_to, Sequence *seq, int dup if (seq->type & SEQ_TYPE_EFFECT) { struct SeqEffectHandle sh; - sh = get_sequence_effect(seq); + sh = BKE_sequence_get_effect(seq); if (sh.copy) sh.copy(seq, seqn); } @@ -3807,21 +3805,21 @@ static Sequence *seq_dupli(Scene *scene, Scene *scene_to, Sequence *seq, int dup } if (dupe_flag & SEQ_DUPE_UNIQUE_NAME) - seqbase_unique_name_recursive(&scene->ed->seqbase, seqn); + BKE_seqence_base_unique_name_recursive(&scene->ed->seqbase, seqn); if (dupe_flag & SEQ_DUPE_ANIM) - seq_dupe_animdata(scene, seq->name + 2, seqn->name + 2); + BKE_sequencer_dupe_animdata(scene, seq->name + 2, seqn->name + 2); return seqn; } -Sequence *seq_dupli_recursive(Scene *scene, Scene *scene_to, Sequence *seq, int dupe_flag) +Sequence *BKE_sequence_dupli_recursive(Scene *scene, Scene *scene_to, Sequence *seq, int dupe_flag) { Sequence *seqn = seq_dupli(scene, scene_to, seq, dupe_flag); if (seq->type == SEQ_TYPE_META) { Sequence *s; for (s = seq->seqbase.first; s; s = s->next) { - Sequence *n = seq_dupli_recursive(scene, scene_to, s, dupe_flag); + Sequence *n = BKE_sequence_dupli_recursive(scene, scene_to, s, dupe_flag); if (n) { BLI_addtail(&seqn->seqbase, n); } @@ -3830,7 +3828,7 @@ Sequence *seq_dupli_recursive(Scene *scene, Scene *scene_to, Sequence *seq, int return seqn; } -void seqbase_dupli_recursive(Scene *scene, Scene *scene_to, ListBase *nseqbase, ListBase *seqbase, int dupe_flag) +void BKE_sequence_base_dupli_recursive(Scene *scene, Scene *scene_to, ListBase *nseqbase, ListBase *seqbase, int dupe_flag) { Sequence *seq; Sequence *seqn = NULL; @@ -3848,7 +3846,7 @@ void seqbase_dupli_recursive(Scene *scene, Scene *scene_to, ListBase *nseqbase, BLI_addtail(nseqbase, seqn); if (seq->type == SEQ_TYPE_META) - seqbase_dupli_recursive(scene, scene_to, &seqn->seqbase, &seq->seqbase, dupe_flag); + BKE_sequence_base_dupli_recursive(scene, scene_to, &seqn->seqbase, &seq->seqbase, dupe_flag); if (dupe_flag & SEQ_DUPE_CONTEXT) { if (seq == last_seq) { -- cgit v1.2.3