diff --git a/source/blender/makesdna/DNA_scene_enums.h b/source/blender/makesdna/DNA_scene_enums.h index 66eca932f54..8ea21e656e4 100644 --- a/source/blender/makesdna/DNA_scene_enums.h +++ b/source/blender/makesdna/DNA_scene_enums.h @@ -16,3 +16,10 @@ typedef enum eVGroupSelect { WT_VGROUP_BONE_DEFORM = 3, WT_VGROUP_BONE_DEFORM_OFF = 4, } eVGroupSelect; + +typedef enum eSeqImageFitMethod { + SEQ_SCALE_TO_FIT, + SEQ_SCALE_TO_FILL, + SEQ_STRETCH_TO_FILL, + SEQ_USE_ORIGINAL_SIZE, +} eSeqImageFitMethod; diff --git a/source/blender/makesdna/DNA_scene_types.h b/source/blender/makesdna/DNA_scene_types.h index c59eddd79c4..3728d658346 100644 --- a/source/blender/makesdna/DNA_scene_types.h +++ b/source/blender/makesdna/DNA_scene_types.h @@ -1511,13 +1511,6 @@ typedef enum eSeqOverlapMode { SEQ_OVERLAP_SHUFFLE, } eSeqOverlapMode; -typedef enum eSeqImageFitMethod { - SEQ_SCALE_TO_FIT, - SEQ_SCALE_TO_FILL, - SEQ_STRETCH_TO_FILL, - SEQ_USE_ORIGINAL_SIZE, -} eSeqImageFitMethod; - /** \} */ /* -------------------------------------------------------------------- */ diff --git a/source/blender/sequencer/SEQ_add.hh b/source/blender/sequencer/SEQ_add.hh index 8ff2ac60eb6..a84c53c527e 100644 --- a/source/blender/sequencer/SEQ_add.hh +++ b/source/blender/sequencer/SEQ_add.hh @@ -7,23 +7,27 @@ /** \file * \ingroup sequencer */ + #include "BLI_utildefines.h" +#include "DNA_scene_enums.h" + struct ListBase; +struct Main; struct Scene; struct Sequence; /** #SeqLoadData.flags */ -typedef enum eSeqLoadFlags { +enum eSeqLoadFlags { SEQ_LOAD_SOUND_CACHE = (1 << 1), SEQ_LOAD_SOUND_MONO = (1 << 2), SEQ_LOAD_MOVIE_SYNC_FPS = (1 << 3), SEQ_LOAD_SET_VIEW_TRANSFORM = (1 << 4), -} eSeqLoadFlags; +}; ENUM_OPERATORS(eSeqLoadFlags, SEQ_LOAD_SET_VIEW_TRANSFORM) /* Api for adding new sequence strips. */ -typedef struct SeqLoadData { +struct SeqLoadData { int start_frame; int channel; char name[64]; /* Strip name. */ @@ -51,7 +55,7 @@ typedef struct SeqLoadData { bool allow_invalid_file; /* Used by RNA API to create placeholder strips. */ double r_video_stream_start; /* For AV synchronization. Set by `SEQ_add_movie_strip`. */ bool adjust_playback_rate; -} SeqLoadData; +}; /** * Initialize common SeqLoadData members @@ -62,11 +66,8 @@ typedef struct SeqLoadData { * \param start_frame: timeline frame where strip will be created * \param channel: timeline channel where strip will be created */ -void SEQ_add_load_data_init(struct SeqLoadData *load_data, - const char *name, - const char *path, - int start_frame, - int channel); +void SEQ_add_load_data_init( + SeqLoadData *load_data, const char *name, const char *path, int start_frame, int channel); /** * Add image strip. * \note Use #SEQ_add_image_set_directory() and #SEQ_add_image_load_file() to load image sequences @@ -77,10 +78,10 @@ void SEQ_add_load_data_init(struct SeqLoadData *load_data, * \param load_data: SeqLoadData with information necessary to create strip * \return created strip */ -struct Sequence *SEQ_add_image_strip(struct Main *bmain, - struct Scene *scene, - struct ListBase *seqbase, - struct SeqLoadData *load_data); +Sequence *SEQ_add_image_strip(Main *bmain, + Scene *scene, + ListBase *seqbase, + SeqLoadData *load_data); /** * Add sound strip. * \note Use SEQ_add_image_set_directory() and SEQ_add_image_load_file() to load image sequences @@ -91,10 +92,10 @@ struct Sequence *SEQ_add_image_strip(struct Main *bmain, * \param load_data: SeqLoadData with information necessary to create strip * \return created strip */ -struct Sequence *SEQ_add_sound_strip(struct Main *bmain, - struct Scene *scene, - struct ListBase *seqbase, - struct SeqLoadData *load_data); +Sequence *SEQ_add_sound_strip(Main *bmain, + Scene *scene, + ListBase *seqbase, + SeqLoadData *load_data); /** * Add meta strip. * @@ -103,9 +104,7 @@ struct Sequence *SEQ_add_sound_strip(struct Main *bmain, * \param load_data: SeqLoadData with information necessary to create strip * \return created strip */ -struct Sequence *SEQ_add_meta_strip(struct Scene *scene, - struct ListBase *seqbase, - struct SeqLoadData *load_data); +Sequence *SEQ_add_meta_strip(Scene *scene, ListBase *seqbase, SeqLoadData *load_data); /** * Add movie strip. * @@ -115,10 +114,10 @@ struct Sequence *SEQ_add_meta_strip(struct Scene *scene, * \param load_data: SeqLoadData with information necessary to create strip * \return created strip */ -struct Sequence *SEQ_add_movie_strip(struct Main *bmain, - struct Scene *scene, - struct ListBase *seqbase, - struct SeqLoadData *load_data); +Sequence *SEQ_add_movie_strip(Main *bmain, + Scene *scene, + ListBase *seqbase, + SeqLoadData *load_data); /** * Add scene strip. * @@ -127,9 +126,7 @@ struct Sequence *SEQ_add_movie_strip(struct Main *bmain, * \param load_data: SeqLoadData with information necessary to create strip * \return created strip */ -struct Sequence *SEQ_add_scene_strip(struct Scene *scene, - struct ListBase *seqbase, - struct SeqLoadData *load_data); +Sequence *SEQ_add_scene_strip(Scene *scene, ListBase *seqbase, SeqLoadData *load_data); /** * Add movieclip strip. * @@ -138,9 +135,7 @@ struct Sequence *SEQ_add_scene_strip(struct Scene *scene, * \param load_data: SeqLoadData with information necessary to create strip * \return created strip */ -struct Sequence *SEQ_add_movieclip_strip(struct Scene *scene, - struct ListBase *seqbase, - struct SeqLoadData *load_data); +Sequence *SEQ_add_movieclip_strip(Scene *scene, ListBase *seqbase, SeqLoadData *load_data); /** * Add mask strip. * @@ -149,9 +144,7 @@ struct Sequence *SEQ_add_movieclip_strip(struct Scene *scene, * \param load_data: SeqLoadData with information necessary to create strip * \return created strip */ -struct Sequence *SEQ_add_mask_strip(struct Scene *scene, - struct ListBase *seqbase, - struct SeqLoadData *load_data); +Sequence *SEQ_add_mask_strip(Scene *scene, ListBase *seqbase, SeqLoadData *load_data); /** * Add effect strip. * @@ -160,16 +153,14 @@ struct Sequence *SEQ_add_mask_strip(struct Scene *scene, * \param load_data: SeqLoadData with information necessary to create strip * \return created strip */ -struct Sequence *SEQ_add_effect_strip(struct Scene *scene, - struct ListBase *seqbase, - struct SeqLoadData *load_data); +Sequence *SEQ_add_effect_strip(Scene *scene, ListBase *seqbase, SeqLoadData *load_data); /** * Set directory used by image strip. * * \param seq: image strip to be changed * \param path: directory path */ -void SEQ_add_image_set_directory(struct Sequence *seq, const char *dirpath); +void SEQ_add_image_set_directory(Sequence *seq, const char *dirpath); /** * Set directory used by image strip. * @@ -177,8 +168,8 @@ void SEQ_add_image_set_directory(struct Sequence *seq, const char *dirpath); * \param strip_frame: frame index of strip to be changed * \param filename: image filename (only filename, not complete path) */ -void SEQ_add_image_load_file(struct Scene *scene, - struct Sequence *seq, +void SEQ_add_image_load_file(Scene *scene, + Sequence *seq, size_t strip_frame, const char *filename); /** @@ -186,13 +177,7 @@ void SEQ_add_image_load_file(struct Scene *scene, * * \param seq: image strip to be changed */ -void SEQ_add_image_init_alpha_mode(struct Sequence *seq); -void SEQ_add_reload_new_file(struct Main *bmain, - struct Scene *scene, - struct Sequence *seq, - bool lock_range); -void SEQ_add_movie_reload_if_needed(struct Main *bmain, - struct Scene *scene, - struct Sequence *seq, - bool *r_was_reloaded, - bool *r_can_produce_frames); +void SEQ_add_image_init_alpha_mode(Sequence *seq); +void SEQ_add_reload_new_file(Main *bmain, Scene *scene, Sequence *seq, bool lock_range); +void SEQ_add_movie_reload_if_needed( + Main *bmain, Scene *scene, Sequence *seq, bool *r_was_reloaded, bool *r_can_produce_frames); diff --git a/source/blender/sequencer/SEQ_animation.hh b/source/blender/sequencer/SEQ_animation.hh index dc04b1df5b5..ad17fbdae04 100644 --- a/source/blender/sequencer/SEQ_animation.hh +++ b/source/blender/sequencer/SEQ_animation.hh @@ -8,32 +8,34 @@ * \ingroup sequencer */ +#include "DNA_listBase.h" + struct GSet; struct ListBase; struct Scene; struct Sequence; struct SeqAnimationBackup; -bool SEQ_animation_curves_exist(struct Scene *scene); -bool SEQ_animation_drivers_exist(struct Scene *scene); -void SEQ_free_animdata(struct Scene *scene, struct Sequence *seq); -void SEQ_offset_animdata(struct Scene *scene, struct Sequence *seq, int ofs); -struct GSet *SEQ_fcurves_by_strip_get(const struct Sequence *seq, struct ListBase *fcurve_base); -typedef struct SeqAnimationBackup { +bool SEQ_animation_curves_exist(Scene *scene); +bool SEQ_animation_drivers_exist(Scene *scene); +void SEQ_free_animdata(Scene *scene, Sequence *seq); +void SEQ_offset_animdata(Scene *scene, Sequence *seq, int ofs); +GSet *SEQ_fcurves_by_strip_get(const Sequence *seq, ListBase *fcurve_base); +struct SeqAnimationBackup { ListBase curves; ListBase drivers; -} SeqAnimationBackup; +}; /** * Move all F-Curves and drivers from `scene` to `backup`. */ -void SEQ_animation_backup_original(struct Scene *scene, struct SeqAnimationBackup *backup); +void SEQ_animation_backup_original(Scene *scene, SeqAnimationBackup *backup); /** * Move all F-Curves and drivers from `backup` to `scene`. */ -void SEQ_animation_restore_original(struct Scene *scene, struct SeqAnimationBackup *backup); +void SEQ_animation_restore_original(Scene *scene, SeqAnimationBackup *backup); /** * Duplicate F-Curves and drivers used by `seq` from `backup` to `scene`. */ -void SEQ_animation_duplicate_backup_to_scene(struct Scene *scene, - struct Sequence *seq, - struct SeqAnimationBackup *backup); +void SEQ_animation_duplicate_backup_to_scene(Scene *scene, + Sequence *seq, + SeqAnimationBackup *backup); diff --git a/source/blender/sequencer/SEQ_channels.hh b/source/blender/sequencer/SEQ_channels.hh index bc3423ad9d9..191673cea65 100644 --- a/source/blender/sequencer/SEQ_channels.hh +++ b/source/blender/sequencer/SEQ_channels.hh @@ -13,18 +13,15 @@ struct ListBase; struct SeqTimelineChannel; struct Sequence; -struct ListBase *SEQ_channels_displayed_get(struct Editing *ed); -void SEQ_channels_displayed_set(struct Editing *ed, struct ListBase *channels); -void SEQ_channels_ensure(struct ListBase *channels); -void SEQ_channels_duplicate(struct ListBase *channels_dst, struct ListBase *channels_src); -void SEQ_channels_free(struct ListBase *channels); +ListBase *SEQ_channels_displayed_get(Editing *ed); +void SEQ_channels_displayed_set(Editing *ed, ListBase *channels); +void SEQ_channels_ensure(ListBase *channels); +void SEQ_channels_duplicate(ListBase *channels_dst, ListBase *channels_src); +void SEQ_channels_free(ListBase *channels); -struct SeqTimelineChannel *SEQ_channel_get_by_index(const struct ListBase *channels, - int channel_index); -char *SEQ_channel_name_get(struct ListBase *channels, int channel_index); -bool SEQ_channel_is_locked(const struct SeqTimelineChannel *channel); -bool SEQ_channel_is_muted(const struct SeqTimelineChannel *channel); -int SEQ_channel_index_get(const struct SeqTimelineChannel *channel); -ListBase *SEQ_get_channels_by_seq(struct ListBase *seqbase, - struct ListBase *channels, - const struct Sequence *seq); +SeqTimelineChannel *SEQ_channel_get_by_index(const ListBase *channels, int channel_index); +char *SEQ_channel_name_get(ListBase *channels, int channel_index); +bool SEQ_channel_is_locked(const SeqTimelineChannel *channel); +bool SEQ_channel_is_muted(const SeqTimelineChannel *channel); +int SEQ_channel_index_get(const SeqTimelineChannel *channel); +ListBase *SEQ_get_channels_by_seq(ListBase *seqbase, ListBase *channels, const Sequence *seq); diff --git a/source/blender/sequencer/SEQ_clipboard.hh b/source/blender/sequencer/SEQ_clipboard.hh index 013cede2f3f..c0cffd625d8 100644 --- a/source/blender/sequencer/SEQ_clipboard.hh +++ b/source/blender/sequencer/SEQ_clipboard.hh @@ -13,14 +13,14 @@ struct Main; struct Scene; struct Sequence; -extern struct ListBase seqbase_clipboard; -extern struct ListBase fcurves_clipboard; -extern struct ListBase drivers_clipboard; +extern ListBase seqbase_clipboard; +extern ListBase fcurves_clipboard; +extern ListBase drivers_clipboard; extern int seqbase_clipboard_frame; -void SEQ_clipboard_pointers_store(struct Main *bmain, struct ListBase *seqbase); -void SEQ_clipboard_pointers_restore(struct ListBase *seqbase, struct Main *bmain); -void SEQ_clipboard_free(void); -void SEQ_clipboard_active_seq_name_store(struct Scene *scene); +void SEQ_clipboard_pointers_store(Main *bmain, ListBase *seqbase); +void SEQ_clipboard_pointers_restore(ListBase *seqbase, Main *bmain); +void SEQ_clipboard_free(); +void SEQ_clipboard_active_seq_name_store(Scene *scene); /** * Check if strip was active when it was copied. User should restrict this check to pasted strips * before ensuring original name, because strip name comparison is used to check. @@ -28,4 +28,4 @@ void SEQ_clipboard_active_seq_name_store(struct Scene *scene); * \param pasted_seq: Strip that is pasted(duplicated) from clipboard * \return true if strip was active, false otherwise */ -bool SEQ_clipboard_pasted_seq_was_active(struct Sequence *pasted_seq); +bool SEQ_clipboard_pasted_seq_was_active(Sequence *pasted_seq); diff --git a/source/blender/sequencer/SEQ_edit.hh b/source/blender/sequencer/SEQ_edit.hh index 67820901156..5902665280a 100644 --- a/source/blender/sequencer/SEQ_edit.hh +++ b/source/blender/sequencer/SEQ_edit.hh @@ -13,9 +13,9 @@ struct Main; struct Scene; struct Sequence; -bool SEQ_edit_sequence_swap(struct Scene *scene, - struct Sequence *seq_a, - struct Sequence *seq_b, +bool SEQ_edit_sequence_swap(Scene *scene, + Sequence *seq_a, + Sequence *seq_b, const char **error_str); /** * Move sequence to seqbase. @@ -25,9 +25,9 @@ bool SEQ_edit_sequence_swap(struct Scene *scene, * \param seq: Sequence to move * \param dst_seqbase: Target seqbase */ -bool SEQ_edit_move_strip_to_seqbase(struct Scene *scene, +bool SEQ_edit_move_strip_to_seqbase(Scene *scene, ListBase *seqbase, - struct Sequence *seq, + Sequence *seq, ListBase *dst_seqbase); /** * Move sequence to meta sequence. @@ -37,22 +37,20 @@ bool SEQ_edit_move_strip_to_seqbase(struct Scene *scene, * \param dst_seqm: Target Meta sequence * \param error_str: Error message */ -bool SEQ_edit_move_strip_to_meta(struct Scene *scene, - struct Sequence *src_seq, - struct Sequence *dst_seqm, +bool SEQ_edit_move_strip_to_meta(Scene *scene, + Sequence *src_seq, + Sequence *dst_seqm, const char **error_str); -bool SEQ_meta_separate(struct Scene *scene, struct Sequence *src_meta, const char **error_str); +bool SEQ_meta_separate(Scene *scene, Sequence *src_meta, const char **error_str); /** * Flag seq and its users (effects) for removal. */ -void SEQ_edit_flag_for_removal(struct Scene *scene, - struct ListBase *seqbase, - struct Sequence *seq); +void SEQ_edit_flag_for_removal(Scene *scene, ListBase *seqbase, Sequence *seq); /** * Remove all flagged sequences, return true if sequence is removed. */ -void SEQ_edit_remove_flagged_sequences(struct Scene *scene, struct ListBase *seqbase); -void SEQ_edit_update_muting(struct Editing *ed); +void SEQ_edit_remove_flagged_sequences(Scene *scene, ListBase *seqbase); +void SEQ_edit_update_muting(Editing *ed); typedef enum eSeqSplitMethod { SEQ_SPLIT_SOFT, @@ -70,13 +68,13 @@ typedef enum eSeqSplitMethod { * \param method: affects type of offset to be applied to resize Sequence * \return The newly created sequence strip. This is always Sequence on right side. */ -struct Sequence *SEQ_edit_strip_split(struct Main *bmain, - struct Scene *scene, - struct ListBase *seqbase, - struct Sequence *seq, - int timeline_frame, - eSeqSplitMethod method, - const char **r_error); +Sequence *SEQ_edit_strip_split(Main *bmain, + Scene *scene, + ListBase *seqbase, + Sequence *seq, + int timeline_frame, + eSeqSplitMethod method, + const char **r_error); /** * Find gap after initial_frame and move strips on right side to close the gap * @@ -86,8 +84,8 @@ struct Sequence *SEQ_edit_strip_split(struct Main *bmain, * \param remove_all_gaps: remove all gaps instead of one gap * \return true if gap is removed, otherwise false */ -bool SEQ_edit_remove_gaps(struct Scene *scene, - struct ListBase *seqbase, +bool SEQ_edit_remove_gaps(Scene *scene, + ListBase *seqbase, int initial_frame, bool remove_all_gaps); -void SEQ_edit_sequence_name_set(struct Scene *scene, struct Sequence *seq, const char *new_name); +void SEQ_edit_sequence_name_set(Scene *scene, Sequence *seq, const char *new_name); diff --git a/source/blender/sequencer/SEQ_effects.hh b/source/blender/sequencer/SEQ_effects.hh index 22a0a4136c6..99785974905 100644 --- a/source/blender/sequencer/SEQ_effects.hh +++ b/source/blender/sequencer/SEQ_effects.hh @@ -29,7 +29,7 @@ struct SeqEffectHandle { /* constructors & destructor */ /* init is _only_ called on first creation */ - void (*init)(struct Sequence *seq); + void (*init)(Sequence *seq); /* number of input strips needed * (called directly after construction) */ @@ -37,57 +37,51 @@ struct SeqEffectHandle { /* load is called first time after readblenfile in * get_sequence_effect automatically */ - void (*load)(struct Sequence *seqconst); + void (*load)(Sequence *seqconst); /* duplicate */ - void (*copy)(struct Sequence *dst, struct Sequence *src, int flag); + void (*copy)(Sequence *dst, Sequence *src, int flag); /* destruct */ - void (*free)(struct Sequence *seq, bool do_id_user); + void (*free)(Sequence *seq, bool do_id_user); /* returns: -1: no input needed, * 0: no early out, * 1: out = ibuf1, * 2: out = ibuf2 */ - int (*early_out)(struct Sequence *seq, float fac); + int (*early_out)(Sequence *seq, float fac); /* sets the default `fac` value */ - void (*get_default_fac)(const struct Scene *scene, - struct Sequence *seq, - float timeline_frame, - float *fac); + void (*get_default_fac)(const Scene *scene, Sequence *seq, float timeline_frame, float *fac); /* execute the effect * sequence effects are only required to either support * float-rects or byte-rects * (mixed cases are handled one layer up...) */ - struct ImBuf *(*execute)(const struct SeqRenderData *context, - struct Sequence *seq, - float timeline_frame, - float fac, - struct ImBuf *ibuf1, - struct ImBuf *ibuf2, - struct ImBuf *ibuf3); + ImBuf *(*execute)(const SeqRenderData *context, + Sequence *seq, + float timeline_frame, + float fac, + ImBuf *ibuf1, + ImBuf *ibuf2, + ImBuf *ibuf3); - struct ImBuf *(*init_execution)(const struct SeqRenderData *context, - struct ImBuf *ibuf1, - struct ImBuf *ibuf2, - struct ImBuf *ibuf3); + ImBuf *(*init_execution)(const SeqRenderData *context, ImBuf *ibuf1, ImBuf *ibuf2, ImBuf *ibuf3); - void (*execute_slice)(const struct SeqRenderData *context, - struct Sequence *seq, + void (*execute_slice)(const SeqRenderData *context, + Sequence *seq, float timeline_frame, float fac, - struct ImBuf *ibuf1, - struct ImBuf *ibuf2, - struct ImBuf *ibuf3, + ImBuf *ibuf1, + ImBuf *ibuf2, + ImBuf *ibuf3, int start_line, int total_lines, - struct ImBuf *out); + ImBuf *out); }; -struct SeqEffectHandle SEQ_effect_handle_get(struct Sequence *seq); +SeqEffectHandle SEQ_effect_handle_get(Sequence *seq); int SEQ_effect_get_num_inputs(int seq_type); -void SEQ_effect_text_font_unload(struct TextVars *data, bool do_id_user); -void SEQ_effect_text_font_load(struct TextVars *data, bool do_id_user); +void SEQ_effect_text_font_unload(TextVars *data, bool do_id_user); +void SEQ_effect_text_font_load(TextVars *data, bool do_id_user); diff --git a/source/blender/sequencer/SEQ_modifier.hh b/source/blender/sequencer/SEQ_modifier.hh index 66a1e906e1a..6d350ea23d0 100644 --- a/source/blender/sequencer/SEQ_modifier.hh +++ b/source/blender/sequencer/SEQ_modifier.hh @@ -18,7 +18,7 @@ struct SeqRenderData; struct Sequence; struct SequenceModifierData; -typedef struct SequenceModifierTypeInfo { +struct SequenceModifierTypeInfo { /* default name for the modifier */ char name[64]; /* MAX_NAME */ @@ -29,34 +29,34 @@ typedef struct SequenceModifierTypeInfo { int struct_size; /* data initialization */ - void (*init_data)(struct SequenceModifierData *smd); + void (*init_data)(SequenceModifierData *smd); /* free data used by modifier, * only modifier-specific data should be freed, modifier descriptor would * be freed outside of this callback */ - void (*free_data)(struct SequenceModifierData *smd); + void (*free_data)(SequenceModifierData *smd); /* copy data from one modifier to another */ - void (*copy_data)(struct SequenceModifierData *smd, struct SequenceModifierData *target); + void (*copy_data)(SequenceModifierData *smd, SequenceModifierData *target); /* apply modifier on a given image buffer */ - void (*apply)(struct SequenceModifierData *smd, struct ImBuf *ibuf, struct ImBuf *mask); -} SequenceModifierTypeInfo; + void (*apply)(SequenceModifierData *smd, ImBuf *ibuf, ImBuf *mask); +}; -const struct SequenceModifierTypeInfo *SEQ_modifier_type_info_get(int type); -struct SequenceModifierData *SEQ_modifier_new(struct Sequence *seq, const char *name, int type); -bool SEQ_modifier_remove(struct Sequence *seq, struct SequenceModifierData *smd); -void SEQ_modifier_clear(struct Sequence *seq); -void SEQ_modifier_free(struct SequenceModifierData *smd); -void SEQ_modifier_unique_name(struct Sequence *seq, struct SequenceModifierData *smd); -struct SequenceModifierData *SEQ_modifier_find_by_name(struct Sequence *seq, const char *name); -struct ImBuf *SEQ_modifier_apply_stack(const struct SeqRenderData *context, - struct Sequence *seq, - struct ImBuf *ibuf, - int timeline_frame); -void SEQ_modifier_list_copy(struct Sequence *seqn, struct Sequence *seq); -int SEQ_sequence_supports_modifiers(struct Sequence *seq); +const SequenceModifierTypeInfo *SEQ_modifier_type_info_get(int type); +SequenceModifierData *SEQ_modifier_new(Sequence *seq, const char *name, int type); +bool SEQ_modifier_remove(Sequence *seq, SequenceModifierData *smd); +void SEQ_modifier_clear(Sequence *seq); +void SEQ_modifier_free(SequenceModifierData *smd); +void SEQ_modifier_unique_name(Sequence *seq, SequenceModifierData *smd); +SequenceModifierData *SEQ_modifier_find_by_name(Sequence *seq, const char *name); +ImBuf *SEQ_modifier_apply_stack(const SeqRenderData *context, + Sequence *seq, + ImBuf *ibuf, + int timeline_frame); +void SEQ_modifier_list_copy(Sequence *seqn, Sequence *seq); +int SEQ_sequence_supports_modifiers(Sequence *seq); -void SEQ_modifier_blend_write(struct BlendWriter *writer, struct ListBase *modbase); -void SEQ_modifier_blend_read_data(struct BlendDataReader *reader, struct ListBase *lb); +void SEQ_modifier_blend_write(BlendWriter *writer, ListBase *modbase); +void SEQ_modifier_blend_read_data(BlendDataReader *reader, ListBase *lb); diff --git a/source/blender/sequencer/SEQ_prefetch.hh b/source/blender/sequencer/SEQ_prefetch.hh index 57b9dc11dfd..2bb5f7dbd7d 100644 --- a/source/blender/sequencer/SEQ_prefetch.hh +++ b/source/blender/sequencer/SEQ_prefetch.hh @@ -11,10 +11,10 @@ struct Main; struct Scene; -void SEQ_prefetch_stop_all(void); +void SEQ_prefetch_stop_all(); /** * Use also to update scene and context changes * This function should almost always be called by cache invalidation, not directly. */ -void SEQ_prefetch_stop(struct Scene *scene); -bool SEQ_prefetch_need_redraw(struct Main *bmain, struct Scene *scene); +void SEQ_prefetch_stop(Scene *scene); +bool SEQ_prefetch_need_redraw(Main *bmain, Scene *scene); diff --git a/source/blender/sequencer/SEQ_proxy.hh b/source/blender/sequencer/SEQ_proxy.hh index 53cfa550e10..83262dd26ff 100644 --- a/source/blender/sequencer/SEQ_proxy.hh +++ b/source/blender/sequencer/SEQ_proxy.hh @@ -13,33 +13,35 @@ struct GSet; struct ListBase; struct ListBase; struct Main; +struct ProxyJob; struct Scene; struct SeqIndexBuildContext; struct SeqRenderData; struct Sequence; +struct wmJob; struct wmJobWorkerStatus; -bool SEQ_proxy_rebuild_context(struct Main *bmain, - struct Depsgraph *depsgraph, - struct Scene *scene, - struct Sequence *seq, - struct GSet *file_list, - struct ListBase *queue, +bool SEQ_proxy_rebuild_context(Main *bmain, + Depsgraph *depsgraph, + Scene *scene, + Sequence *seq, + GSet *file_list, + ListBase *queue, bool build_only_on_bad_performance); -void SEQ_proxy_rebuild(struct SeqIndexBuildContext *context, wmJobWorkerStatus *worker_status); -void SEQ_proxy_rebuild_finish(struct SeqIndexBuildContext *context, bool stop); -void SEQ_proxy_set(struct Sequence *seq, bool value); -bool SEQ_can_use_proxy(const struct SeqRenderData *context, struct Sequence *seq, int psize); +void SEQ_proxy_rebuild(SeqIndexBuildContext *context, wmJobWorkerStatus *worker_status); +void SEQ_proxy_rebuild_finish(SeqIndexBuildContext *context, bool stop); +void SEQ_proxy_set(Sequence *seq, bool value); +bool SEQ_can_use_proxy(const SeqRenderData *context, Sequence *seq, int psize); int SEQ_rendersize_to_proxysize(int render_size); double SEQ_rendersize_to_scale_factor(int size); -typedef struct ProxyBuildJob { - struct Main *main; - struct Depsgraph *depsgraph; - struct Scene *scene; - struct ListBase queue; +struct ProxyJob { + Main *main; + Depsgraph *depsgraph; + Scene *scene; + ListBase queue; int stop; -} ProxyJob; +}; -struct wmJob *ED_seq_proxy_wm_job_get(const struct bContext *C); -ProxyJob *ED_seq_proxy_job_get(const struct bContext *C, struct wmJob *wm_job); +wmJob *ED_seq_proxy_wm_job_get(const bContext *C); +ProxyJob *ED_seq_proxy_job_get(const bContext *C, wmJob *wm_job); diff --git a/source/blender/sequencer/SEQ_relations.hh b/source/blender/sequencer/SEQ_relations.hh index b9389f31c45..11234d50085 100644 --- a/source/blender/sequencer/SEQ_relations.hh +++ b/source/blender/sequencer/SEQ_relations.hh @@ -18,51 +18,51 @@ struct Sequence; /** * Check if one sequence is input to the other. */ -bool SEQ_relation_is_effect_of_strip(const struct Sequence *effect, const struct Sequence *input); +bool SEQ_relation_is_effect_of_strip(const Sequence *effect, const Sequence *input); /** * Function to free imbuf and anim data on changes. */ -void SEQ_relations_sequence_free_anim(struct Sequence *seq); -bool SEQ_relations_check_scene_recursion(struct Scene *scene, struct ReportList *reports); +void SEQ_relations_sequence_free_anim(Sequence *seq); +bool SEQ_relations_check_scene_recursion(Scene *scene, ReportList *reports); /** * Check if "seq_main" (indirectly) uses strip "seq". */ -bool SEQ_relations_render_loop_check(struct Sequence *seq_main, struct Sequence *seq); -void SEQ_relations_free_imbuf(struct Scene *scene, struct ListBase *seqbase, bool for_render); -void SEQ_relations_invalidate_cache_raw(struct Scene *scene, struct Sequence *seq); -void SEQ_relations_invalidate_cache_preprocessed(struct Scene *scene, struct Sequence *seq); -void SEQ_relations_invalidate_cache_composite(struct Scene *scene, struct Sequence *seq); -void SEQ_relations_invalidate_dependent(struct Scene *scene, struct Sequence *seq); -void SEQ_relations_invalidate_scene_strips(struct Main *bmain, struct Scene *scene_target); -void SEQ_relations_invalidate_movieclip_strips(struct Main *bmain, struct MovieClip *clip_target); -void SEQ_relations_invalidate_cache_in_range(struct Scene *scene, - struct Sequence *seq, - struct Sequence *range_mask, +bool SEQ_relations_render_loop_check(Sequence *seq_main, Sequence *seq); +void SEQ_relations_free_imbuf(Scene *scene, ListBase *seqbase, bool for_render); +void SEQ_relations_invalidate_cache_raw(Scene *scene, Sequence *seq); +void SEQ_relations_invalidate_cache_preprocessed(Scene *scene, Sequence *seq); +void SEQ_relations_invalidate_cache_composite(Scene *scene, Sequence *seq); +void SEQ_relations_invalidate_dependent(Scene *scene, Sequence *seq); +void SEQ_relations_invalidate_scene_strips(Main *bmain, Scene *scene_target); +void SEQ_relations_invalidate_movieclip_strips(Main *bmain, MovieClip *clip_target); +void SEQ_relations_invalidate_cache_in_range(Scene *scene, + Sequence *seq, + Sequence *range_mask, int invalidate_types); /** * Release FFmpeg handles of strips that are not currently displayed to minimize memory usage. */ -void SEQ_relations_free_all_anim_ibufs(struct Scene *scene, int timeline_frame); +void SEQ_relations_free_all_anim_ibufs(Scene *scene, int timeline_frame); /** * A debug and development function which checks whether sequences have unique UUIDs. * Errors will be reported to the console. */ -void SEQ_relations_check_uuids_unique_and_report(const struct Scene *scene); +void SEQ_relations_check_uuids_unique_and_report(const Scene *scene); /** * Generate new UUID for the given sequence. */ -void SEQ_relations_session_uuid_generate(struct Sequence *sequence); +void SEQ_relations_session_uuid_generate(Sequence *sequence); -void SEQ_cache_cleanup(struct Scene *scene); +void SEQ_cache_cleanup(Scene *scene); void SEQ_cache_iterate( - struct Scene *scene, + Scene *scene, void *userdata, bool callback_init(void *userdata, size_t item_count), - bool callback_iter(void *userdata, struct Sequence *seq, int timeline_frame, int cache_type)); + bool callback_iter(void *userdata, Sequence *seq, int timeline_frame, int cache_type)); /** * Return immediate parent meta of sequence. */ -struct Sequence *SEQ_find_metastrip_by_sequence(ListBase *seqbase /* = ed->seqbase */, - struct Sequence *meta /* = NULL */, - struct Sequence *seq); -bool SEQ_exists_in_seqbase(const struct Sequence *seq, const struct ListBase *seqbase); +Sequence *SEQ_find_metastrip_by_sequence(ListBase *seqbase /* = ed->seqbase */, + Sequence *meta /* = NULL */, + Sequence *seq); +bool SEQ_exists_in_seqbase(const Sequence *seq, const ListBase *seqbase); diff --git a/source/blender/sequencer/SEQ_render.hh b/source/blender/sequencer/SEQ_render.hh index 3945404a126..abe49b1a2c4 100644 --- a/source/blender/sequencer/SEQ_render.hh +++ b/source/blender/sequencer/SEQ_render.hh @@ -10,21 +10,25 @@ #define SEQ_RENDER_THUMB_SIZE 256 +struct Depsgraph; +struct GPUOffScreen; +struct ImBuf; struct ListBase; struct Main; struct Scene; struct Sequence; +struct StripElem; struct rctf; -typedef enum eSeqTaskId { +enum eSeqTaskId { SEQ_TASK_MAIN_RENDER, SEQ_TASK_PREFETCH_RENDER, -} eSeqTaskId; +}; -typedef struct SeqRenderData { - struct Main *bmain; - struct Depsgraph *depsgraph; - struct Scene *scene; +struct SeqRenderData { + Main *bmain; + Depsgraph *depsgraph; + Scene *scene; int rectx; int recty; int preview_render_size; @@ -40,86 +44,78 @@ typedef struct SeqRenderData { eSeqTaskId task_id; /* special case for OpenGL render */ - struct GPUOffScreen *gpu_offscreen; + GPUOffScreen *gpu_offscreen; // int gpu_samples; // bool gpu_full_samples; -} SeqRenderData; +}; /** * \return The image buffer or NULL. * * \note The returned #ImBuf has its reference increased, free after usage! */ -struct ImBuf *SEQ_render_give_ibuf(const SeqRenderData *context, +ImBuf *SEQ_render_give_ibuf(const SeqRenderData *context, float timeline_frame, int chanshown); +ImBuf *SEQ_render_give_ibuf_direct(const SeqRenderData *context, float timeline_frame, - int chanshown); -struct ImBuf *SEQ_render_give_ibuf_direct(const SeqRenderData *context, - float timeline_frame, - struct Sequence *seq); + Sequence *seq); /** * Render the series of thumbnails and store in cache. */ -void SEQ_render_thumbnails(const struct SeqRenderData *context, - struct Sequence *seq, - struct Sequence *seq_orig, +void SEQ_render_thumbnails(const SeqRenderData *context, + Sequence *seq, + Sequence *seq_orig, float frame_step, - const struct rctf *view_area, + const rctf *view_area, const bool *stop); /** * Get cached thumbnails. */ -struct ImBuf *SEQ_get_thumbnail(const struct SeqRenderData *context, - struct Sequence *seq, - float timeline_frame, - rcti *crop, - bool clipped); +ImBuf *SEQ_get_thumbnail( + const SeqRenderData *context, Sequence *seq, float timeline_frame, rcti *crop, bool clipped); /** * Get frame for first thumbnail. */ -float SEQ_render_thumbnail_first_frame_get(const struct Scene *scene, - struct Sequence *seq, +float SEQ_render_thumbnail_first_frame_get(const Scene *scene, + Sequence *seq, float frame_step, - const struct rctf *view_area); + const rctf *view_area); /** * Get frame for first thumbnail. */ -float SEQ_render_thumbnail_next_frame_get(const struct Scene *scene, - struct Sequence *seq, +float SEQ_render_thumbnail_next_frame_get(const Scene *scene, + Sequence *seq, float last_frame, float frame_step); /** * Get frame step for equally spaced thumbnails. These thumbnails should always be present in * memory, so they can be used when zooming. */ -int SEQ_render_thumbnails_guaranteed_set_frame_step_get(const struct Scene *scene, - const struct Sequence *seq); +int SEQ_render_thumbnails_guaranteed_set_frame_step_get(const Scene *scene, const Sequence *seq); /** * Render set of evenly spaced thumbnails that are drawn when zooming.. */ -void SEQ_render_thumbnails_base_set(const struct SeqRenderData *context, - struct Sequence *seq, - struct Sequence *seq_orig, - const struct rctf *view_area, +void SEQ_render_thumbnails_base_set(const SeqRenderData *context, + Sequence *seq, + Sequence *seq_orig, + const rctf *view_area, const bool *stop); -void SEQ_render_init_colorspace(struct Sequence *seq); -void SEQ_render_new_render_data(struct Main *bmain, - struct Depsgraph *depsgraph, - struct Scene *scene, +void SEQ_render_init_colorspace(Sequence *seq); +void SEQ_render_new_render_data(Main *bmain, + Depsgraph *depsgraph, + Scene *scene, int rectx, int recty, int preview_render_size, int for_render, SeqRenderData *r_context); -int SEQ_render_evaluate_frame(struct ListBase *seqbase, int timeline_frame); -struct StripElem *SEQ_render_give_stripelem(const struct Scene *scene, - struct Sequence *seq, - int timeline_frame); +int SEQ_render_evaluate_frame(ListBase *seqbase, int timeline_frame); +StripElem *SEQ_render_give_stripelem(const Scene *scene, Sequence *seq, int timeline_frame); -void SEQ_render_imbuf_from_sequencer_space(struct Scene *scene, struct ImBuf *ibuf); -void SEQ_render_pixel_from_sequencer_space_v4(struct Scene *scene, float pixel[4]); +void SEQ_render_imbuf_from_sequencer_space(Scene *scene, ImBuf *ibuf); +void SEQ_render_pixel_from_sequencer_space_v4(Scene *scene, float pixel[4]); /** * Check if `seq` is muted for rendering. * This function also checks `SeqTimelineChannel` flag. */ -bool SEQ_render_is_muted(const struct ListBase *channels, const struct Sequence *seq); +bool SEQ_render_is_muted(const ListBase *channels, const Sequence *seq); diff --git a/source/blender/sequencer/SEQ_retiming.hh b/source/blender/sequencer/SEQ_retiming.hh index b08dc1de2a5..89d98a22c6f 100644 --- a/source/blender/sequencer/SEQ_retiming.hh +++ b/source/blender/sequencer/SEQ_retiming.hh @@ -11,70 +11,65 @@ #include "BLI_map.hh" #include "BLI_span.hh" +struct Editing; +struct Scene; struct Sequence; struct SeqRetimingKey; blender::MutableSpan SEQ_retiming_keys_get(const Sequence *seq); -blender::Map SEQ_retiming_selection_get(const struct Editing *ed); -int SEQ_retiming_keys_count(const struct Sequence *seq); -bool SEQ_retiming_is_active(const struct Sequence *seq); -void SEQ_retiming_data_ensure(struct Sequence *seq); -void SEQ_retiming_data_clear(struct Sequence *seq); -bool SEQ_retiming_is_allowed(const struct Sequence *seq); +blender::Map SEQ_retiming_selection_get(const Editing *ed); +int SEQ_retiming_keys_count(const Sequence *seq); +bool SEQ_retiming_is_active(const Sequence *seq); +void SEQ_retiming_data_ensure(Sequence *seq); +void SEQ_retiming_data_clear(Sequence *seq); +bool SEQ_retiming_is_allowed(const Sequence *seq); /** * Add new retiming key. * This function always reallocates memory, so when function is used all stored pointers will * become invalid. */ -SeqRetimingKey *SEQ_retiming_add_key(const struct Scene *scene, - struct Sequence *seq, - const int timeline_frame); -SeqRetimingKey *SEQ_retiming_add_transition(const struct Scene *scene, - struct Sequence *seq, - struct SeqRetimingKey *key, - const int offset); -SeqRetimingKey *SEQ_retiming_add_freeze_frame(const struct Scene *scene, - struct Sequence *seq, - struct SeqRetimingKey *key, - const int offset); -bool SEQ_retiming_is_last_key(const struct Sequence *seq, const struct SeqRetimingKey *key); -struct SeqRetimingKey *SEQ_retiming_last_key_get(const struct Sequence *seq); -void SEQ_retiming_remove_key(const struct Scene *scene, - struct Sequence *seq, - struct SeqRetimingKey *key); -void SEQ_retiming_offset_transition_key(const struct Scene *scene, - const struct Sequence *seq, - struct SeqRetimingKey *key, - const int offset); -float SEQ_retiming_key_speed_get(const struct Sequence *seq, const struct SeqRetimingKey *key); -void SEQ_retiming_key_speed_set(const struct Scene *scene, - struct Sequence *seq, - struct SeqRetimingKey *key, - const float speed); -int SEQ_retiming_key_index_get(const struct Sequence *seq, const struct SeqRetimingKey *key); -SeqRetimingKey *SEQ_retiming_key_get_by_timeline_frame(const struct Scene *scene, - const struct Sequence *seq, - const int timeline_frame); -void SEQ_retiming_sound_animation_data_set(const struct Scene *scene, const struct Sequence *seq); -float SEQ_retiming_key_timeline_frame_get(const struct Scene *scene, - const struct Sequence *seq, - const struct SeqRetimingKey *key); -void SEQ_retiming_key_timeline_frame_set(const struct Scene *scene, - struct Sequence *seq, - struct SeqRetimingKey *key, - const int timeline_frame); -SeqRetimingKey *SEQ_retiming_find_segment_start_key(const struct Sequence *seq, - const int frame_index); -bool SEQ_retiming_key_is_transition_type(const struct SeqRetimingKey *key); -bool SEQ_retiming_key_is_transition_start(const struct SeqRetimingKey *key); -SeqRetimingKey *SEQ_retiming_transition_start_get(struct SeqRetimingKey *key); -bool SEQ_retiming_key_is_freeze_frame(const struct SeqRetimingKey *key); -bool SEQ_retiming_selection_clear(const struct Editing *ed); -void SEQ_retiming_selection_append(struct SeqRetimingKey *key); -void SEQ_retiming_selection_remove(struct SeqRetimingKey *key); -void SEQ_retiming_remove_multiple_keys(struct Sequence *seq, - blender::Vector &keys); -bool SEQ_retiming_selection_contains(const struct Editing *ed, const struct SeqRetimingKey *key); -bool SEQ_retiming_selection_has_whole_transition(const struct Editing *ed, - struct SeqRetimingKey *key); -bool SEQ_retiming_data_is_editable(const struct Sequence *seq); +SeqRetimingKey *SEQ_retiming_add_key(const Scene *scene, Sequence *seq, int timeline_frame); +SeqRetimingKey *SEQ_retiming_add_transition(const Scene *scene, + Sequence *seq, + SeqRetimingKey *key, + int offset); +SeqRetimingKey *SEQ_retiming_add_freeze_frame(const Scene *scene, + Sequence *seq, + SeqRetimingKey *key, + int offset); +bool SEQ_retiming_is_last_key(const Sequence *seq, const SeqRetimingKey *key); +SeqRetimingKey *SEQ_retiming_last_key_get(const Sequence *seq); +void SEQ_retiming_remove_key(const Scene *scene, Sequence *seq, SeqRetimingKey *key); +void SEQ_retiming_offset_transition_key(const Scene *scene, + const Sequence *seq, + SeqRetimingKey *key, + int offset); +float SEQ_retiming_key_speed_get(const Sequence *seq, const SeqRetimingKey *key); +void SEQ_retiming_key_speed_set(const Scene *scene, + Sequence *seq, + SeqRetimingKey *key, + float speed); +int SEQ_retiming_key_index_get(const Sequence *seq, const SeqRetimingKey *key); +SeqRetimingKey *SEQ_retiming_key_get_by_timeline_frame(const Scene *scene, + const Sequence *seq, + int timeline_frame); +void SEQ_retiming_sound_animation_data_set(const Scene *scene, const Sequence *seq); +float SEQ_retiming_key_timeline_frame_get(const Scene *scene, + const Sequence *seq, + const SeqRetimingKey *key); +void SEQ_retiming_key_timeline_frame_set(const Scene *scene, + Sequence *seq, + SeqRetimingKey *key, + int timeline_frame); +SeqRetimingKey *SEQ_retiming_find_segment_start_key(const Sequence *seq, int frame_index); +bool SEQ_retiming_key_is_transition_type(const SeqRetimingKey *key); +bool SEQ_retiming_key_is_transition_start(const SeqRetimingKey *key); +SeqRetimingKey *SEQ_retiming_transition_start_get(SeqRetimingKey *key); +bool SEQ_retiming_key_is_freeze_frame(const SeqRetimingKey *key); +bool SEQ_retiming_selection_clear(const Editing *ed); +void SEQ_retiming_selection_append(SeqRetimingKey *key); +void SEQ_retiming_selection_remove(SeqRetimingKey *key); +void SEQ_retiming_remove_multiple_keys(Sequence *seq, blender::Vector &keys); +bool SEQ_retiming_selection_contains(const Editing *ed, const SeqRetimingKey *key); +bool SEQ_retiming_selection_has_whole_transition(const Editing *ed, SeqRetimingKey *key); +bool SEQ_retiming_data_is_editable(const Sequence *seq); diff --git a/source/blender/sequencer/SEQ_select.hh b/source/blender/sequencer/SEQ_select.hh index 4a95f76600a..e83d64010ae 100644 --- a/source/blender/sequencer/SEQ_select.hh +++ b/source/blender/sequencer/SEQ_select.hh @@ -11,8 +11,6 @@ struct Scene; struct Sequence; -struct Sequence *SEQ_select_active_get(struct Scene *scene); -bool SEQ_select_active_get_pair(struct Scene *scene, - struct Sequence **r_seq_act, - struct Sequence **r_seq_other); -void SEQ_select_active_set(struct Scene *scene, struct Sequence *seq); +Sequence *SEQ_select_active_get(Scene *scene); +bool SEQ_select_active_get_pair(Scene *scene, Sequence **r_seq_act, Sequence **r_seq_other); +void SEQ_select_active_set(Scene *scene, Sequence *seq); diff --git a/source/blender/sequencer/SEQ_sequencer.hh b/source/blender/sequencer/SEQ_sequencer.hh index 999e3e3c6d1..6774528b6a6 100644 --- a/source/blender/sequencer/SEQ_sequencer.hh +++ b/source/blender/sequencer/SEQ_sequencer.hh @@ -15,6 +15,8 @@ struct BlendLibReader; struct BlendWriter; struct Depsgraph; struct Editing; +struct Main; +struct MetaStack; struct Scene; struct Sequence; struct SequencerToolSettings; @@ -34,75 +36,75 @@ enum { #define SEQ_DUPE_ALL (1 << 3) /* otherwise only selected are copied */ #define SEQ_DUPE_IS_RECURSIVE_CALL (1 << 4) -struct SequencerToolSettings *SEQ_tool_settings_init(void); -struct SequencerToolSettings *SEQ_tool_settings_ensure(struct Scene *scene); -void SEQ_tool_settings_free(struct SequencerToolSettings *tool_settings); -eSeqImageFitMethod SEQ_tool_settings_fit_method_get(struct Scene *scene); -void SEQ_tool_settings_fit_method_set(struct Scene *scene, eSeqImageFitMethod fit_method); -short SEQ_tool_settings_snap_flag_get(struct Scene *scene); -short SEQ_tool_settings_snap_mode_get(struct Scene *scene); -int SEQ_tool_settings_snap_distance_get(struct Scene *scene); -eSeqOverlapMode SEQ_tool_settings_overlap_mode_get(struct Scene *scene); -int SEQ_tool_settings_pivot_point_get(struct Scene *scene); -struct SequencerToolSettings *SEQ_tool_settings_copy(struct SequencerToolSettings *tool_settings); -struct Editing *SEQ_editing_get(const struct Scene *scene); -struct Editing *SEQ_editing_ensure(struct Scene *scene); -void SEQ_editing_free(struct Scene *scene, bool do_id_user); +SequencerToolSettings *SEQ_tool_settings_init(); +SequencerToolSettings *SEQ_tool_settings_ensure(Scene *scene); +void SEQ_tool_settings_free(SequencerToolSettings *tool_settings); +eSeqImageFitMethod SEQ_tool_settings_fit_method_get(Scene *scene); +void SEQ_tool_settings_fit_method_set(Scene *scene, eSeqImageFitMethod fit_method); +short SEQ_tool_settings_snap_flag_get(Scene *scene); +short SEQ_tool_settings_snap_mode_get(Scene *scene); +int SEQ_tool_settings_snap_distance_get(Scene *scene); +eSeqOverlapMode SEQ_tool_settings_overlap_mode_get(Scene *scene); +int SEQ_tool_settings_pivot_point_get(Scene *scene); +SequencerToolSettings *SEQ_tool_settings_copy(SequencerToolSettings *tool_settings); +Editing *SEQ_editing_get(const Scene *scene); +Editing *SEQ_editing_ensure(Scene *scene); +void SEQ_editing_free(Scene *scene, bool do_id_user); /** * Get seqbase that is being viewed currently. This can be main seqbase or meta strip seqbase * * \param ed: sequence editor data * \return pointer to active seqbase. returns NULL if ed is NULL */ -struct ListBase *SEQ_active_seqbase_get(const struct Editing *ed); +ListBase *SEQ_active_seqbase_get(const Editing *ed); /** * Set seqbase that is being viewed currently. This can be main seqbase or meta strip seqbase * * \param ed: sequence editor data * \param seqbase: ListBase with strips */ -void SEQ_seqbase_active_set(struct Editing *ed, struct ListBase *seqbase); -struct Sequence *SEQ_sequence_alloc(ListBase *lb, int timeline_frame, int machine, int type); -void SEQ_sequence_free(struct Scene *scene, struct Sequence *seq); +void SEQ_seqbase_active_set(Editing *ed, ListBase *seqbase); +Sequence *SEQ_sequence_alloc(ListBase *lb, int timeline_frame, int machine, int type); +void SEQ_sequence_free(Scene *scene, Sequence *seq); /** * Get #MetaStack that corresponds to current level that is being viewed * * \return pointer to meta stack */ -struct MetaStack *SEQ_meta_stack_active_get(const struct Editing *ed); +MetaStack *SEQ_meta_stack_active_get(const Editing *ed); /** * Open Meta strip content for editing. * * \param ed: sequence editor data * \param seqm: meta sequence or NULL for top level view */ -void SEQ_meta_stack_set(const struct Scene *scene, struct Sequence *dst_seq); +void SEQ_meta_stack_set(const Scene *scene, Sequence *dst_seq); /** * Close last Meta strip open for editing. * * \param ed: sequence editor data */ -struct Sequence *SEQ_meta_stack_pop(struct Editing *ed); -struct Sequence *SEQ_sequence_dupli_recursive(const struct Scene *scene_src, - struct Scene *scene_dst, - struct ListBase *new_seq_list, - struct Sequence *seq, - int dupe_flag); -void SEQ_sequence_base_dupli_recursive(const struct Scene *scene_src, - struct Scene *scene_dst, - struct ListBase *nseqbase, - const struct ListBase *seqbase, +Sequence *SEQ_meta_stack_pop(Editing *ed); +Sequence *SEQ_sequence_dupli_recursive(const Scene *scene_src, + Scene *scene_dst, + ListBase *new_seq_list, + Sequence *seq, + int dupe_flag); +void SEQ_sequence_base_dupli_recursive(const Scene *scene_src, + Scene *scene_dst, + ListBase *nseqbase, + const ListBase *seqbase, int dupe_flag, int flag); -bool SEQ_valid_strip_channel(struct Sequence *seq); +bool SEQ_valid_strip_channel(Sequence *seq); /** * Read and Write functions for `.blend` file data. */ -void SEQ_blend_write(struct BlendWriter *writer, struct ListBase *seqbase); -void SEQ_blend_read(struct BlendDataReader *reader, struct ListBase *seqbase); +void SEQ_blend_write(BlendWriter *writer, ListBase *seqbase); +void SEQ_blend_read(BlendDataReader *reader, ListBase *seqbase); -void SEQ_doversion_250_sound_proxy_update(struct Main *bmain, struct Editing *ed); +void SEQ_doversion_250_sound_proxy_update(Main *bmain, Editing *ed); /* Depsgraph update function. */ @@ -111,15 +113,13 @@ void SEQ_doversion_250_sound_proxy_update(struct Main *bmain, struct Editing *ed * This does NOT include actual rendering of the strips, but rather makes them up-to-date for * animation playback and makes them ready for the sequencer's rendering pipeline to render them. */ -void SEQ_eval_sequences(struct Depsgraph *depsgraph, - struct Scene *scene, - struct ListBase *seqbase); +void SEQ_eval_sequences(Depsgraph *depsgraph, Scene *scene, ListBase *seqbase); /* Defined in `sequence_lookup.cc`. */ -typedef enum eSequenceLookupTag { +enum eSequenceLookupTag { SEQ_LOOKUP_TAG_INVALID = (1 << 0), -} eSequenceLookupTag; +}; ENUM_OPERATORS(eSequenceLookupTag, SEQ_LOOKUP_TAG_INVALID) /** @@ -132,18 +132,18 @@ ENUM_OPERATORS(eSequenceLookupTag, SEQ_LOOKUP_TAG_INVALID) * * \return pointer to Sequence */ -struct Sequence *SEQ_sequence_lookup_seq_by_name(const struct Scene *scene, const char *key); +Sequence *SEQ_sequence_lookup_seq_by_name(const Scene *scene, const char *key); /** * Free lookup hash data. * * \param scene: scene that owns lookup hash */ -void SEQ_sequence_lookup_free(const struct Scene *scene); +void SEQ_sequence_lookup_free(const Scene *scene); /** * Find a sequence with a given name. * * \param scene: scene that owns lookup hash * \param tag: tag to set */ -void SEQ_sequence_lookup_tag(const struct Scene *scene, eSequenceLookupTag tag); +void SEQ_sequence_lookup_tag(const Scene *scene, eSequenceLookupTag tag); diff --git a/source/blender/sequencer/SEQ_sound.hh b/source/blender/sequencer/SEQ_sound.hh index c1c35c21374..a5efbb79c7c 100644 --- a/source/blender/sequencer/SEQ_sound.hh +++ b/source/blender/sequencer/SEQ_sound.hh @@ -8,11 +8,13 @@ * \ingroup sequencer */ +struct EQCurveMappingData; struct Main; struct Scene; struct Sequence; struct bSound; struct SequencerSoundEqualizer; +struct SoundModifierWorkerInfo; struct BlendWriter; struct BlendDataReader; struct ListBase; @@ -24,36 +26,33 @@ struct SoundEqualizerModifierData; #define SOUND_EQUALIZER_SIZE_CONVERSION 2048 #define SOUND_EQUALIZER_SIZE_DEFINITION 1000 -void SEQ_sound_update_bounds_all(struct Scene *scene); -void SEQ_sound_update_bounds(struct Scene *scene, struct Sequence *seq); -void SEQ_sound_update(struct Scene *scene, struct bSound *sound); -void SEQ_sound_update_length(struct Main *bmain, struct Scene *scene); -float SEQ_sound_pitch_get(const struct Scene *scene, const struct Sequence *seq); -struct EQCurveMappingData *SEQ_sound_equalizer_add(struct SoundEqualizerModifierData *semd, - float minX, - float maxX); -void SEQ_sound_blend_write(struct BlendWriter *writer, struct ListBase *soundbase); -void SEQ_sound_blend_read_data(struct BlendDataReader *reader, struct ListBase *lb); +void SEQ_sound_update_bounds_all(Scene *scene); +void SEQ_sound_update_bounds(Scene *scene, Sequence *seq); +void SEQ_sound_update(Scene *scene, bSound *sound); +void SEQ_sound_update_length(Main *bmain, Scene *scene); +float SEQ_sound_pitch_get(const Scene *scene, const Sequence *seq); +EQCurveMappingData *SEQ_sound_equalizer_add(SoundEqualizerModifierData *semd, + float minX, + float maxX); +void SEQ_sound_blend_write(BlendWriter *writer, ListBase *soundbase); +void SEQ_sound_blend_read_data(BlendDataReader *reader, ListBase *lb); -void *SEQ_sound_modifier_recreator(struct Sequence *seq, - struct SequenceModifierData *smd, - void *sound); +void *SEQ_sound_modifier_recreator(Sequence *seq, SequenceModifierData *smd, void *sound); -void SEQ_sound_equalizermodifier_init_data(struct SequenceModifierData *smd); -void SEQ_sound_equalizermodifier_free(struct SequenceModifierData *smd); -void SEQ_sound_equalizermodifier_copy_data(struct SequenceModifierData *target, - struct SequenceModifierData *smd); -void *SEQ_sound_equalizermodifier_recreator(struct Sequence *seq, - struct SequenceModifierData *smd, - void *sound); -void SEQ_sound_equalizermodifier_set_graphs(struct SoundEqualizerModifierData *semd, int number); -const struct SoundModifierWorkerInfo *SEQ_sound_modifier_worker_info_get(int type); -struct EQCurveMappingData *SEQ_sound_equalizermodifier_add_graph( - struct SoundEqualizerModifierData *semd, float min_freq, float max_freq); -void SEQ_sound_equalizermodifier_remove_graph(struct SoundEqualizerModifierData *semd, - struct EQCurveMappingData *gsed); +void SEQ_sound_equalizermodifier_init_data(SequenceModifierData *smd); +void SEQ_sound_equalizermodifier_free(SequenceModifierData *smd); +void SEQ_sound_equalizermodifier_copy_data(SequenceModifierData *target, + SequenceModifierData *smd); +void *SEQ_sound_equalizermodifier_recreator(Sequence *seq, SequenceModifierData *smd, void *sound); +void SEQ_sound_equalizermodifier_set_graphs(SoundEqualizerModifierData *semd, int number); +const SoundModifierWorkerInfo *SEQ_sound_modifier_worker_info_get(int type); +EQCurveMappingData *SEQ_sound_equalizermodifier_add_graph(SoundEqualizerModifierData *semd, + float min_freq, + float max_freq); +void SEQ_sound_equalizermodifier_remove_graph(SoundEqualizerModifierData *semd, + EQCurveMappingData *gsed); -typedef struct SoundModifierWorkerInfo { +struct SoundModifierWorkerInfo { int type; - void *(*recreator)(struct Sequence *seq, struct SequenceModifierData *smd, void *sound); -} SoundModifierWorkerInfo; + void *(*recreator)(Sequence *seq, SequenceModifierData *smd, void *sound); +}; diff --git a/source/blender/sequencer/SEQ_time.hh b/source/blender/sequencer/SEQ_time.hh index 62ab1a7e81b..87a77039120 100644 --- a/source/blender/sequencer/SEQ_time.hh +++ b/source/blender/sequencer/SEQ_time.hh @@ -19,16 +19,14 @@ struct rctf; * \param scene: the Scene instance whose timeline boundaries are extracted from * \param rect: output parameter to be filled with timeline boundaries */ -void SEQ_timeline_init_boundbox(const struct Scene *scene, struct rctf *rect); +void SEQ_timeline_init_boundbox(const Scene *scene, rctf *rect); /** * Stretch the given rectangle to include the given strips boundaries * * \param seqbase: ListBase in which strips are located * \param rect: output parameter to be filled with strips' boundaries */ -void SEQ_timeline_expand_boundbox(const struct Scene *scene, - const struct ListBase *seqbase, - struct rctf *rect); +void SEQ_timeline_expand_boundbox(const Scene *scene, const ListBase *seqbase, rctf *rect); /** * Define boundary rectangle of sequencer timeline and fill in rect data * @@ -36,14 +34,12 @@ void SEQ_timeline_expand_boundbox(const struct Scene *scene, * \param seqbase: ListBase in which strips are located * \param rect: data structure describing rectangle, that will be filled in by this function */ -void SEQ_timeline_boundbox(const struct Scene *scene, - const struct ListBase *seqbase, - struct rctf *rect); +void SEQ_timeline_boundbox(const Scene *scene, const ListBase *seqbase, rctf *rect); /** * Get FPS rate of source media. Movie, scene and movie-clip strips are supported. * Returns 0 for unsupported strip or if media can't be loaded. */ -float SEQ_time_sequence_get_fps(struct Scene *scene, struct Sequence *seq); +float SEQ_time_sequence_get_fps(Scene *scene, Sequence *seq); /** * Find start or end position of next or previous strip. * \param scene: Video editing scene @@ -52,7 +48,7 @@ float SEQ_time_sequence_get_fps(struct Scene *scene, struct Sequence *seq); * \param do_center: find closest strip center if true, otherwise finds closest handle position. * \param do_unselected: only find closest position of unselected strip. */ -int SEQ_time_find_next_prev_edit(struct Scene *scene, +int SEQ_time_find_next_prev_edit(Scene *scene, int timeline_frame, short side, bool do_skip_mute, @@ -67,66 +63,60 @@ int SEQ_time_find_next_prev_edit(struct Scene *scene, * \param timeline_frame: absolute frame position * \return true if strip intersects with timeline frame. */ -bool SEQ_time_strip_intersects_frame(const struct Scene *scene, - const struct Sequence *seq, - int timeline_frame); +bool SEQ_time_strip_intersects_frame(const Scene *scene, const Sequence *seq, int timeline_frame); /* Convert timeline frame so strip frame index. */ -float SEQ_give_frame_index(const struct Scene *scene, struct Sequence *seq, float timeline_frame); +float SEQ_give_frame_index(const Scene *scene, Sequence *seq, float timeline_frame); /** * Returns true if strip has frames without content to render. */ -bool SEQ_time_has_still_frames(const struct Scene *scene, const struct Sequence *seq); +bool SEQ_time_has_still_frames(const Scene *scene, const Sequence *seq); /** * Returns true if at beginning of strip there is no content to be rendered. */ -bool SEQ_time_has_left_still_frames(const struct Scene *scene, const struct Sequence *seq); +bool SEQ_time_has_left_still_frames(const Scene *scene, const Sequence *seq); /** * Returns true if at end of strip there is no content to be rendered. */ -bool SEQ_time_has_right_still_frames(const struct Scene *scene, const struct Sequence *seq); +bool SEQ_time_has_right_still_frames(const Scene *scene, const Sequence *seq); /** * Get timeline frame where strip boundary starts. */ -int SEQ_time_left_handle_frame_get(const struct Scene *scene, const struct Sequence *seq); +int SEQ_time_left_handle_frame_get(const Scene *scene, const Sequence *seq); /** * Get timeline frame where strip boundary ends. */ -int SEQ_time_right_handle_frame_get(const struct Scene *scene, const struct Sequence *seq); +int SEQ_time_right_handle_frame_get(const Scene *scene, const Sequence *seq); /** * Set frame where strip boundary starts. This function moves only handle, content is not moved. */ -void SEQ_time_left_handle_frame_set(const struct Scene *scene, - struct Sequence *seq, - int timeline_frame); +void SEQ_time_left_handle_frame_set(const Scene *scene, Sequence *seq, int timeline_frame); /** * Set frame where strip boundary ends. * This function moves only handle, content is not moved. */ -void SEQ_time_right_handle_frame_set(const struct Scene *scene, - struct Sequence *seq, - int timeline_frame); +void SEQ_time_right_handle_frame_set(const Scene *scene, Sequence *seq, int timeline_frame); /** * Get number of frames (in timeline) that can be rendered. * This can change depending on scene FPS or strip speed factor. */ -int SEQ_time_strip_length_get(const struct Scene *scene, const struct Sequence *seq); +int SEQ_time_strip_length_get(const Scene *scene, const Sequence *seq); /** * Get timeline frame where strip content starts. */ -float SEQ_time_start_frame_get(const struct Sequence *seq); +float SEQ_time_start_frame_get(const Sequence *seq); /** * Get timeline frame where strip content ends. */ -float SEQ_time_content_end_frame_get(const struct Scene *scene, const struct Sequence *seq); +float SEQ_time_content_end_frame_get(const Scene *scene, const Sequence *seq); /** * Set frame where strip content starts. * This function will also move strip handles. */ -void SEQ_time_start_frame_set(const struct Scene *scene, struct Sequence *seq, int timeline_frame); +void SEQ_time_start_frame_set(const Scene *scene, Sequence *seq, int timeline_frame); /** * Update meta strip content start and end, update sound playback range. * To be used after any contained strip length or position has changed. * * \note this function is currently only used internally and in versioning code. */ -void SEQ_time_update_meta_strip_range(const struct Scene *scene, struct Sequence *seq_meta); +void SEQ_time_update_meta_strip_range(const Scene *scene, Sequence *seq_meta); diff --git a/source/blender/sequencer/SEQ_transform.hh b/source/blender/sequencer/SEQ_transform.hh index 31a251fe85b..e952cbb0147 100644 --- a/source/blender/sequencer/SEQ_transform.hh +++ b/source/blender/sequencer/SEQ_transform.hh @@ -13,45 +13,39 @@ struct Scene; struct SeqCollection; struct Sequence; -bool SEQ_transform_sequence_can_be_translated(struct Sequence *seq); +bool SEQ_transform_sequence_can_be_translated(Sequence *seq); /** * 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). */ -bool SEQ_transform_single_image_check(struct Sequence *seq); -bool SEQ_transform_test_overlap(const struct Scene *scene, - struct ListBase *seqbasep, - struct Sequence *test); -bool SEQ_transform_test_overlap_seq_seq(const struct Scene *scene, - struct Sequence *seq1, - struct Sequence *seq2); -void SEQ_transform_translate_sequence(struct Scene *evil_scene, struct Sequence *seq, int delta); +bool SEQ_transform_single_image_check(Sequence *seq); +bool SEQ_transform_test_overlap(const Scene *scene, ListBase *seqbasep, Sequence *test); +bool SEQ_transform_test_overlap_seq_seq(const Scene *scene, Sequence *seq1, Sequence *seq2); +void SEQ_transform_translate_sequence(Scene *evil_scene, Sequence *seq, int delta); /** * \return 0 if there weren't enough space. */ -bool SEQ_transform_seqbase_shuffle_ex(struct ListBase *seqbasep, - struct Sequence *test, - struct Scene *evil_scene, +bool SEQ_transform_seqbase_shuffle_ex(ListBase *seqbasep, + Sequence *test, + Scene *evil_scene, int channel_delta); -bool SEQ_transform_seqbase_shuffle(struct ListBase *seqbasep, - struct Sequence *test, - struct Scene *evil_scene); -bool SEQ_transform_seqbase_shuffle_time(struct SeqCollection *strips_to_shuffle, - struct SeqCollection *time_dependent_strips, - struct ListBase *seqbasep, - struct Scene *evil_scene, - struct ListBase *markers, +bool SEQ_transform_seqbase_shuffle(ListBase *seqbasep, Sequence *test, Scene *evil_scene); +bool SEQ_transform_seqbase_shuffle_time(SeqCollection *strips_to_shuffle, + SeqCollection *time_dependent_strips, + ListBase *seqbasep, + Scene *evil_scene, + ListBase *markers, bool use_sync_markers); -void SEQ_transform_handle_overlap(struct Scene *scene, - struct ListBase *seqbasep, - struct SeqCollection *transformed_strips, - struct SeqCollection *time_dependent_strips, +void SEQ_transform_handle_overlap(Scene *scene, + ListBase *seqbasep, + SeqCollection *transformed_strips, + SeqCollection *time_dependent_strips, bool use_sync_markers); /** * Check if the selected seq's reference unselected seq's. */ -bool SEQ_transform_seqbase_isolated_sel_check(struct ListBase *seqbase); +bool SEQ_transform_seqbase_isolated_sel_check(ListBase *seqbase); /** * Move strips and markers (if not locked) that start after timeline_frame by delta frames * @@ -60,8 +54,8 @@ bool SEQ_transform_seqbase_isolated_sel_check(struct ListBase *seqbase); * \param delta: offset in frames to be applied * \param timeline_frame: frame on timeline from where strips are moved */ -void SEQ_transform_offset_after_frame(struct Scene *scene, - struct ListBase *seqbase, +void SEQ_transform_offset_after_frame(Scene *scene, + ListBase *seqbase, int delta, int timeline_frame); @@ -69,11 +63,11 @@ void SEQ_transform_offset_after_frame(struct Scene *scene, * Check if `seq` can be moved. * This function also checks `SeqTimelineChannel` flag. */ -bool SEQ_transform_is_locked(struct ListBase *channels, struct Sequence *seq); +bool SEQ_transform_is_locked(ListBase *channels, Sequence *seq); /* Image transformation. */ -void SEQ_image_transform_mirror_factor_get(const struct Sequence *seq, float r_mirror[2]); +void SEQ_image_transform_mirror_factor_get(const Sequence *seq, float r_mirror[2]); /** * Get strip transform origin offset from image center * NOTE: This function does not apply axis mirror. @@ -82,8 +76,8 @@ void SEQ_image_transform_mirror_factor_get(const struct Sequence *seq, float r_m * \param seq: Sequence to calculate image transform origin * \param r_origin: return value */ -void SEQ_image_transform_origin_offset_pixelspace_get(const struct Scene *scene, - const struct Sequence *seq, +void SEQ_image_transform_origin_offset_pixelspace_get(const Scene *scene, + const Sequence *seq, float r_origin[2]); /** * Get 4 corner points of strip image, optionally without rotation component applied. @@ -94,8 +88,8 @@ void SEQ_image_transform_origin_offset_pixelspace_get(const struct Scene *scene, * \param apply_rotation: Apply sequence rotation transform to the quad * \param r_quad: array of 4 2D vectors */ -void SEQ_image_transform_quad_get(const struct Scene *scene, - const struct Sequence *seq, +void SEQ_image_transform_quad_get(const Scene *scene, + const Sequence *seq, bool apply_rotation, float r_quad[4][2]); /** @@ -105,16 +99,12 @@ void SEQ_image_transform_quad_get(const struct Scene *scene, * \param seq: Sequence to calculate transformed image quad * \param r_quad: array of 4 2D vectors */ -void SEQ_image_transform_final_quad_get(const struct Scene *scene, - const struct Sequence *seq, +void SEQ_image_transform_final_quad_get(const Scene *scene, + const Sequence *seq, float r_quad[4][2]); -void SEQ_image_preview_unit_to_px(const struct Scene *scene, - const float co_src[2], - float co_dst[2]); -void SEQ_image_preview_unit_from_px(const struct Scene *scene, - const float co_src[2], - float co_dst[2]); +void SEQ_image_preview_unit_to_px(const Scene *scene, const float co_src[2], float co_dst[2]); +void SEQ_image_preview_unit_from_px(const Scene *scene, const float co_src[2], float co_dst[2]); /** * Get viewport axis aligned bounding box from a collection of sequences. @@ -126,8 +116,5 @@ void SEQ_image_preview_unit_from_px(const struct Scene *scene, * \param r_min: Minimum x and y values * \param r_max: Maximum x and y values */ -void SEQ_image_transform_bounding_box_from_collection(struct Scene *scene, - struct SeqCollection *strips, - bool apply_rotation, - float r_min[2], - float r_max[2]); +void SEQ_image_transform_bounding_box_from_collection( + Scene *scene, SeqCollection *strips, bool apply_rotation, float r_min[2], float r_max[2]); diff --git a/source/blender/sequencer/SEQ_utils.hh b/source/blender/sequencer/SEQ_utils.hh index 337e5b4aaa2..405c9df8e30 100644 --- a/source/blender/sequencer/SEQ_utils.hh +++ b/source/blender/sequencer/SEQ_utils.hh @@ -16,30 +16,24 @@ struct Scene; struct Sequence; struct StripElem; -void SEQ_sequence_base_unique_name_recursive(struct Scene *scene, - struct ListBase *seqbasep, - struct Sequence *seq); -const char *SEQ_sequence_give_name(struct Sequence *seq); -struct ListBase *SEQ_get_seqbase_from_sequence(struct Sequence *seq, - struct ListBase **channels, - int *r_offset); -const struct Sequence *SEQ_get_topmost_sequence(const struct Scene *scene, int frame); +void SEQ_sequence_base_unique_name_recursive(Scene *scene, ListBase *seqbasep, Sequence *seq); +const char *SEQ_sequence_give_name(Sequence *seq); +ListBase *SEQ_get_seqbase_from_sequence(Sequence *seq, ListBase **channels, int *r_offset); +const Sequence *SEQ_get_topmost_sequence(const Scene *scene, int frame); /** * In cases where we don't know the sequence's listbase. */ -struct ListBase *SEQ_get_seqbase_by_seq(const struct Scene *scene, struct Sequence *seq); +ListBase *SEQ_get_seqbase_by_seq(const Scene *scene, Sequence *seq); /** * Only use as last resort when the StripElem is available but no the Sequence. * (needed for RNA) */ -struct Sequence *SEQ_sequence_from_strip_elem(struct ListBase *seqbase, struct StripElem *se); -struct Sequence *SEQ_get_sequence_by_name(struct ListBase *seqbase, - const char *name, - bool recursive); -struct Mask *SEQ_active_mask_get(struct Scene *scene); -void SEQ_alpha_mode_from_file_extension(struct Sequence *seq); -bool SEQ_sequence_has_source(const struct Sequence *seq); -void SEQ_set_scale_to_fit(const struct Sequence *seq, +Sequence *SEQ_sequence_from_strip_elem(ListBase *seqbase, StripElem *se); +Sequence *SEQ_get_sequence_by_name(ListBase *seqbase, const char *name, bool recursive); +Mask *SEQ_active_mask_get(Scene *scene); +void SEQ_alpha_mode_from_file_extension(Sequence *seq); +bool SEQ_sequence_has_source(const Sequence *seq); +void SEQ_set_scale_to_fit(const Sequence *seq, int image_width, int image_height, int preview_width, @@ -52,4 +46,4 @@ void SEQ_set_scale_to_fit(const struct Sequence *seq, * \param seq: Sequence which name will be ensured to be unique * \param scene: Scene in which name must be unique */ -void SEQ_ensure_unique_name(struct Sequence *seq, struct Scene *scene); +void SEQ_ensure_unique_name(Sequence *seq, Scene *scene);