griefith/test
1
0
Fork 0
Code Issues Pull Requests Actions 1 Packages Projects Releases Wiki Activity

Cleanup: Remove unnecessary struct keywords in sequences headers

Browse Source 
Also remove const for non-pointer arguments which is meaningless in
the declaration, move a scene enum to the "enums.hh" header, and add
missing forward declaration of structs.
This commit is contained in:
Hans Goudey
2023-11-03 09:05:31 +01:00
parent d59c6d3e5c
commit 0ff4060cd3
20 changed files with 417 additions and 480 deletions
Download Patch File Download Diff File Expand all files Collapse all files

7
source/blender/makesdna/DNA_scene_enums.h
View File

@@ -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;

7
source/blender/makesdna/DNA_scene_types.h
View File

@@ -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;
/** \} */
/* -------------------------------------------------------------------- */

83
source/blender/sequencer/SEQ_add.hh
View File

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

26
source/blender/sequencer/SEQ_animation.hh
View File

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

25
source/blender/sequencer/SEQ_channels.hh
View File

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

16
source/blender/sequencer/SEQ_clipboard.hh
View File

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

46
source/blender/sequencer/SEQ_edit.hh
View File

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

52
source/blender/sequencer/SEQ_effects.hh
View File

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

42
source/blender/sequencer/SEQ_modifier.hh
View File

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

6
source/blender/sequencer/SEQ_prefetch.hh
View File

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

38
source/blender/sequencer/SEQ_proxy.hh
View File

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

48
source/blender/sequencer/SEQ_relations.hh
View File

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

84
source/blender/sequencer/SEQ_render.hh
View File

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

111
source/blender/sequencer/SEQ_retiming.hh
View File

@@ -11,70 +11,65 @@
#include "BLI_map.hh"
#include "BLI_span.hh"
struct Editing;
struct Scene;
struct Sequence;
struct SeqRetimingKey;
blender::MutableSpan<SeqRetimingKey> SEQ_retiming_keys_get(const Sequence *seq);
blender::Map<SeqRetimingKey *, Sequence *> 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<SeqRetimingKey *, Sequence *> 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<SeqRetimingKey *> &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<SeqRetimingKey *> &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);

8
source/blender/sequencer/SEQ_select.hh
View File

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

84
source/blender/sequencer/SEQ_sequencer.hh
View File

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

57
source/blender/sequencer/SEQ_sound.hh
View File

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

48
source/blender/sequencer/SEQ_time.hh
View File

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

79
source/blender/sequencer/SEQ_transform.hh
View File

@@ -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]);

30
source/blender/sequencer/SEQ_utils.hh
View File

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