blender
/
blender
136
405
Fork 586
Code Issues 6.2k Pull Requests 756 Projects 19 Wiki Activity

Cleanup: move public doc-strings into headers for 'sequencer' 

Ref T92709
This commit is contained in:
Campbell Barton 2021-12-08 21:02:29 +11:00
parent e89d42ddff
commit 32b1a13fa1
Notes: blender-bot 2023-02-14 06:49:54 +01:00 
Referenced by issue #93854, Relocate doc-strings into public headers
Referenced by issue #92709, Code Style: documentation at declaration or definition
32 changed files with 506 additions and 448 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

81
source/blender/sequencer/SEQ_add.h
View File

@ -67,11 +67,30 @@ typedef struct SeqLoadData {
bool allow_invalid_file; /* Used by RNA API to create placeholder strips. */
} SeqLoadData;
/**
* Initialize common SeqLoadData members
*
* \param load_data: SeqLoadData to be initialized
* \param name: strip name (can be NULL)
* \param path: path to file that is used as strip input (can be NULL)
* \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,
const int start_frame,
const int channel);
/**
* Add image strip.
* \note Use #SEQ_add_image_set_directory() and #SEQ_add_image_load_file() to load image sequences
*
* \param main: Main reference
* \param scene: Scene where strips will be added
* \param seqbase: ListBase where strips will be added
* \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,
@ -84,26 +103,88 @@ struct Sequence *SEQ_add_sound_strip(struct Main *bmain,
struct Sequence *SEQ_add_meta_strip(struct Scene *scene,
struct ListBase *seqbase,
struct SeqLoadData *load_data);
/**
* Add movie strip.
*
* \param main: Main reference
* \param scene: Scene where strips will be added
* \param seqbase: ListBase where strips will be added
* \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,
double *r_start_offset);
/**
* Add scene strip.
*
* \param scene: Scene where strips will be added
* \param seqbase: ListBase where strips will be added
* \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);
/**
* Add movieclip strip.
*
* \param scene: Scene where strips will be added
* \param seqbase: ListBase where strips will be added
* \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);
/**
* Add mask strip.
*
* \param scene: Scene where strips will be added
* \param seqbase: ListBase where strips will be added
* \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);
/**
* Add effect strip.
*
* \param scene: Scene where strips will be added
* \param seqbase: ListBase where strips will be added
* \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);
/**
* 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, char *path);
/**
* Set directory used by image strip.
*
* \param seq: image strip to be changed
* \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 Sequence *seq, size_t strip_frame, char *filename);
/**
* Set image strip alpha mode
*
* \param seq: image strip to be changed
*/
void SEQ_add_image_init_alpha_mode(struct Sequence *seq);
/**
* \note caller should run `SEQ_time_update_sequence(scene, seq)` after..
*/
void SEQ_add_reload_new_file(struct Main *bmain,
struct Scene *scene,
struct Sequence *seq,

7
source/blender/sequencer/SEQ_clipboard.h
View File

@ -38,6 +38,13 @@ 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);
/**
* 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.
*
* \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);
#ifdef __cplusplus

42
source/blender/sequencer/SEQ_edit.h
View File

@ -33,18 +33,40 @@ struct Scene;
struct Sequence;
int SEQ_edit_sequence_swap(struct Sequence *seq_a, struct Sequence *seq_b, const char **error_str);
/**
* Move sequence to seqbase.
*
* \param scene: Scene containing the editing
* \param dst_seqbase: seqbase where `seq` is located
* \param seq: Sequence to move
* \param dst_seqbase: Target seqbase
*/
bool SEQ_edit_move_strip_to_seqbase(struct Scene *scene,
ListBase *seqbase,
struct Sequence *src_seq,
ListBase *dst_seqbase);
/**
* Move sequence to meta sequence.
*
* \param scene: Scene containing the editing
* \param src_seq: Sequence to move
* \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,
const char **error_str);
bool SEQ_meta_separate(struct Scene *scene, struct 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);
/**
* 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);
@ -53,6 +75,17 @@ typedef enum eSeqSplitMethod {
SEQ_SPLIT_HARD,
} eSeqSplitMethod;
/**
* Split Sequence at timeline_frame in two.
*
* \param bmain: Main in which Sequence is located
* \param scene: Scene in which Sequence is located
* \param seqbase: ListBase in which Sequence is located
* \param seq: Sequence to be split
* \param timeline_frame: frame at which seq is split.
* \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,
@ -60,6 +93,15 @@ struct Sequence *SEQ_edit_strip_split(struct Main *bmain,
const int timeline_frame,
const eSeqSplitMethod method,
const char **r_error);
/**
* Find gap after initial_frame and move strips on right side to close the gap
*
* \param scene: Scene in which strips are located
* \param seqbase: ListBase in which strips are located
* \param initial_frame: frame on timeline from where gaps are searched for
* \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,
const int initial_frame,

139
source/blender/sequencer/SEQ_iterator.h
View File

@ -63,42 +63,179 @@ typedef struct SeqIterator {
bool iterator_initialized;
} SeqIterator;
/**
* Utility function for SEQ_ITERATOR_FOREACH macro.
* Ensure, that iterator is initialized. During initialization return pointer to collection element
* and step gset iterator. When this function is called after iterator has been initialized, it
* will do nothing and return true.
*
* \param collection: collection to iterate
* \param iterator: iterator to be initialized
* \param r_seq: pointer to Sequence pointer
*
* \return false when iterator can not be initialized, true otherwise
*/
bool SEQ_iterator_ensure(SeqCollection *collection,
SeqIterator *iterator,
struct Sequence **r_seq);
/**
* Utility function for SEQ_ITERATOR_FOREACH macro.
* Yield collection element
*
* \param iterator: iterator to be initialized
*
* \return collection element or NULL when iteration has ended
*/
struct Sequence *SEQ_iterator_yield(SeqIterator *iterator);
/* Callback format for the for_each function below. */
/**
* Callback format for the for_each function below.
*/
typedef bool (*SeqForEachFunc)(struct Sequence *seq, void *user_data);
/**
* Utility function to recursively iterate through all sequence strips in a `seqbase` list.
* Uses callback to do operations on each sequence element.
* The callback can stop the iteration if needed.
*
* \param seqbase: #ListBase of sequences to be iterated over.
* \param callback: query function callback, returns false if iteration should stop.
* \param user_data: pointer to user data that can be used in the callback function.
*/
void SEQ_for_each_callback(struct ListBase *seqbase, SeqForEachFunc callback, void *user_data);
/**
* Create new empty strip collection.
*
* \return empty strip collection.
*/
SeqCollection *SEQ_collection_create(const char *name);
/**
* Duplicate collection
*
* \param collection: collection to be duplicated
* \return duplicate of collection
*/
SeqCollection *SEQ_collection_duplicate(SeqCollection *collection);
/**
* Return number of items in collection.
*/
uint SEQ_collection_len(const SeqCollection *collection);
/**
* Check if seq is in collection.
*/
bool SEQ_collection_has_strip(const struct Sequence *seq, const SeqCollection *collection);
/**
* Add strip to collection.
*
* \param seq: strip to be added
* \param collection: collection to which strip will be added
* \return false if strip is already in set, otherwise true
*/
bool SEQ_collection_append_strip(struct Sequence *seq, SeqCollection *data);
/**
* Remove strip from collection.
*
* \param seq: strip to be removed
* \param collection: collection from which strip will be removed
* \return true if strip exists in set and it was removed from set, otherwise false
*/
bool SEQ_collection_remove_strip(struct Sequence *seq, SeqCollection *data);
/**
* Free strip collection.
*
* \param collection: collection to be freed
*/
void SEQ_collection_free(SeqCollection *collection);
/**
* Move strips from collection_src to collection_dst. Source collection will be freed.
*
* \param collection_dst: destination collection
* \param collection_src: source collection
*/
void SEQ_collection_merge(SeqCollection *collection_dst, SeqCollection *collection_src);
/**
* Remove strips from collection that are also in `exclude_elements`. Source collection will be
* freed.
*
* \param collection: collection from which strips are removed
* \param exclude_elements: collection of strips to be removed
*/
void SEQ_collection_exclude(SeqCollection *collection, SeqCollection *exclude_elements);
/**
* Expand collection by running SEQ_query() for each strip, which will be used as reference.
* Results of these queries will be merged into provided collection.
*
* \param seqbase: ListBase in which strips are queried
* \param collection: SeqCollection to be expanded
* \param seq_query_func: query function callback
*/
void SEQ_collection_expand(struct ListBase *seqbase,
SeqCollection *collection,
void query_func(struct Sequence *seq_reference,
struct ListBase *seqbase,
SeqCollection *collection));
/**
* Query strips from seqbase. seq_reference is used by query function as filter condition.
*
* \param seq_reference: reference strip for query function
* \param seqbase: ListBase in which strips are queried
* \param seq_query_func: query function callback
* \return strip collection
*/
SeqCollection *SEQ_query_by_reference(struct Sequence *seq_reference,
struct ListBase *seqbase,
void seq_query_func(struct Sequence *seq_reference,
struct ListBase *seqbase,
SeqCollection *collection));
/**
* Query all selected strips in seqbase.
*
* \param seqbase: ListBase in which strips are queried
* \return strip collection
*/
SeqCollection *SEQ_query_selected_strips(struct ListBase *seqbase);
/**
* Query all unselected strips in seqbase.
*
* \param seqbase: ListBase in which strips are queried
* \return strip collection
*/
SeqCollection *SEQ_query_unselected_strips(struct ListBase *seqbase);
/**
* Query all strips in seqbase. This does not include strips nested in meta strips.
*
* \param seqbase: ListBase in which strips are queried
* \return strip collection
*/
SeqCollection *SEQ_query_all_strips(ListBase *seqbase);
/**
* Query all strips in seqbase and nested meta strips.
*
* \param seqbase: ListBase in which strips are queried
* \return strip collection
*/
SeqCollection *SEQ_query_all_strips_recursive(ListBase *seqbase);
/**
* Query strips that are rendered at \a timeline_frame when \a displayed channel is viewed
*
* \param seqbase: ListBase in which strips are queried
* \param timeline_frame: viewed frame
* \param displayed_channel: viewed channel. when set to 0, no channel filter is applied
* \return strip collection
*/
SeqCollection *SEQ_query_rendered_strips(ListBase *seqbase,
const int timeline_frame,
const int displayed_channel);
/**
* Query all effect strips that are directly or indirectly connected to seq_reference.
* This includes all effects of seq_reference, strips used by another inputs and their effects, so
* that whole chain is fully independent of other strips.
*
* \param seq_reference: reference strip
* \param seqbase: ListBase in which strips are queried
* \param collection: collection to be filled
*/
void SEQ_query_strip_effect_chain(struct Sequence *seq_reference,
struct ListBase *seqbase,
SeqCollection *collection);

4
source/blender/sequencer/SEQ_prefetch.h
View File

@ -31,6 +31,10 @@ struct Main;
struct Scene;
void SEQ_prefetch_stop_all(void);
/**
* 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);

19
source/blender/sequencer/SEQ_relations.h
View File

@ -34,8 +34,14 @@ struct ReportList;
struct Scene;
struct Sequence;
/**
* 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);
/**
* 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 *seqbasep, bool for_render);
void SEQ_relations_invalidate_cache_raw(struct Scene *scene, struct Sequence *seq);
@ -49,10 +55,14 @@ void SEQ_relations_invalidate_cache_in_range(struct Scene *scene,
struct Sequence *range_mask,
int invalidate_types);
void SEQ_relations_free_all_anim_ibufs(struct Scene *scene, int timeline_frame);
/* A debug and development function which checks whether sequences have unique UUIDs.
* Errors will be reported to the console. */
/**
* 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);
/* Generate new UUID for the given sequence. */
/**
* Generate new UUID for the given sequence.
*/
void SEQ_relations_session_uuid_generate(struct Sequence *sequence);
void SEQ_cache_cleanup(struct Scene *scene);
@ -61,6 +71,9 @@ void SEQ_cache_iterate(
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));
/**
* Return immediate parent meta of sequence.
*/
struct Sequence *SEQ_find_metastrip_by_sequence(ListBase *seqbase /* = ed->seqbase */,
struct Sequence *meta /* = NULL */,
struct Sequence *seq);

18
source/blender/sequencer/SEQ_render.h
View File

@ -63,12 +63,20 @@ typedef struct SeqRenderData {
// 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,
float timeline_frame,
int chanshown);
struct ImBuf *SEQ_render_give_ibuf_direct(const SeqRenderData *context,
float timeline_frame,
struct 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,
@ -76,12 +84,22 @@ void SEQ_render_thumbnails(const struct SeqRenderData *context,
float frame_step,
rctf *view_area,
const short *stop);
/**
* Get cached thumbnails.
*/
struct ImBuf *SEQ_get_thumbnail(const struct SeqRenderData *context,
struct Sequence *seq,
float timeline_frame,
rcti *crop,
bool clipped);
/**
* 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 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,

64
source/blender/sequencer/SEQ_sequencer.h
View File

@ -69,12 +69,43 @@ struct SequencerToolSettings *SEQ_tool_settings_copy(struct SequencerToolSetting
struct Editing *SEQ_editing_get(const struct Scene *scene);
struct Editing *SEQ_editing_ensure(struct Scene *scene);
void SEQ_editing_free(struct Scene *scene, const 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);
/**
* 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, const bool do_clean_animdata);
/**
* Create and initialize #MetaStack, append it to `ed->metastack` ListBase
*
* \param ed: sequence editor data
* \param seq_meta: meta strip
* \return pointer to created meta stack
*/
struct MetaStack *SEQ_meta_stack_alloc(struct Editing *ed, struct Sequence *seq_meta);
/**
* Get #MetaStack that corresponds to current level that is being viewed
*
* \param ed: sequence editor data
* \return pointer to meta stack
*/
struct MetaStack *SEQ_meta_stack_active_get(const struct Editing *ed);
/**
* Free #MetaStack and remove it from `ed->metastack` ListBase.
*
* \param ed: sequence editor data
* \param ms: meta stack
*/
void SEQ_meta_stack_free(struct Editing *ed, struct MetaStack *ms);
void SEQ_offset_animdata(struct Scene *scene, struct Sequence *seq, int ofs);
void SEQ_dupe_animdata(struct Scene *scene, const char *name_src, const char *name_dst);
@ -91,7 +122,9 @@ void SEQ_sequence_base_dupli_recursive(const struct Scene *scene_src,
const int flag);
bool SEQ_valid_strip_channel(struct Sequence *seq);
/* Read and Write functions for .blend file data */
/**
* 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);
@ -101,7 +134,13 @@ void SEQ_blend_read_lib(struct BlendLibReader *reader,
void SEQ_blend_read_expand(struct BlendExpander *expander, struct ListBase *seqbase);
/* Depsgraph update function */
/* Depsgraph update function. */
/**
* Evaluate parts of sequences which needs to be done as a part of a dependency graph evaluation.
* 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);
@ -112,8 +151,29 @@ typedef enum eSequenceLookupTag {
SEQ_LOOKUP_TAG_INVALID = (1 << 0),
} eSequenceLookupTag;
/**
* Find a sequence with a given name.
* If lookup hash doesn't exist, it will be created. If hash is tagged as invalid, it will be
* rebuilt.
*
* \param scene: scene that owns lookup hash
* \param key: Sequence name without SQ prefix (seq->name + 2)
*
* \return pointer to Sequence
*/
struct Sequence *SEQ_sequence_lookup_by_name(const struct 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);
/**
* 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);
#ifdef __cplusplus

28
source/blender/sequencer/SEQ_time.h
View File

@ -32,8 +32,27 @@ struct Scene;
struct Sequence;
struct rctf;
/**
* Initialize given rectangle with the Scene's timeline boundaries.
*
* \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);
/**
* 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 ListBase *seqbase, struct rctf *rect);
/**
* Define boundary rectangle of sequencer timeline and fill in rect data
*
* \param scene: Scene in which strips are located
* \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);
@ -46,6 +65,15 @@ int SEQ_time_find_next_prev_edit(struct Scene *scene,
const bool do_unselected);
void SEQ_time_update_sequence(struct Scene *scene, struct ListBase *seqbase, struct Sequence *seq);
void SEQ_time_update_recursive(struct Scene *scene, struct Sequence *changed_seq);
/**
* Test if strip intersects with timeline frame.
* \note This checks if strip would be rendered at this frame. For rendering it is assumed, that
* timeline frame has width of 1 frame and therefore ends at timeline_frame + 1
*
* \param seq: Sequence to be checked
* \param timeline_frame: absolute frame position
* \return true if strip intersects with timeline frame.
*/
bool SEQ_time_strip_intersects_frame(const struct Sequence *seq, const int timeline_frame);
void SEQ_time_update_meta_strip_range(struct Scene *scene, struct Sequence *seq_meta);

47
source/blender/sequencer/SEQ_transform.h
View File

@ -36,13 +36,24 @@ int SEQ_transform_get_left_handle_frame(struct Sequence *seq);
int SEQ_transform_get_right_handle_frame(struct Sequence *seq);
void SEQ_transform_set_left_handle_frame(struct Sequence *seq, int val);
void SEQ_transform_set_right_handle_frame(struct Sequence *seq, int val);
/**
* Use to impose limits when dragging/extending - so impossible situations don't happen.
* Can't use the #SEQ_LEFTSEL and #SEQ_LEFTSEL directly because the strip may be in a meta-strip.
*/
void SEQ_transform_handle_xlimits(struct Sequence *seq, int leftflag, int rightflag);
bool SEQ_transform_sequence_can_be_translated(struct 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);
void SEQ_transform_fix_single_image_seq_offsets(struct Sequence *seq);
bool SEQ_transform_test_overlap(struct ListBase *seqbasep, struct Sequence *test);
bool SEQ_transform_test_overlap_seq_seq(struct Sequence *seq1, struct Sequence *seq2);
void SEQ_transform_translate_sequence(struct Scene *scene, struct 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,
@ -55,21 +66,57 @@ bool SEQ_transform_seqbase_shuffle_time(struct SeqCollection *strips_to_shuffle,
struct Scene *evil_scene,
struct ListBase *markers,
const bool use_sync_markers);
/**
* Check if the selected seq's reference unselected seq's.
*/
bool SEQ_transform_seqbase_isolated_sel_check(struct ListBase *seqbase);
/**
* Move strips and markers (if not locked) that start after timeline_frame by delta frames
*
* \param scene: Scene in which strips are located
* \param seqbase: ListBase in which strips are located
* \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,
const int delta,
const int timeline_frame);
/* Image transformation. */
void SEQ_image_transform_mirror_factor_get(const struct Sequence *seq, float r_mirror[2]);
/**
* Get strip transform origin offset from image center
* NOTE: This function does not apply axis mirror.
*
* \param scene: Scene in which strips are located
* \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,
float r_origin[2]);
/**
* Get 4 corner points of strip image, optionally without rotation component applied.
* Corner vectors are in viewport space.
*
* \param scene: Scene in which strips are located
* \param seq: Sequence to calculate transformed image quad
* \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,
bool apply_rotation,
float r_quad[4][2]);
/**
* Get 4 corner points of strip image. Corner vectors are in viewport space.
*
* \param scene: Scene in which strips are located
* \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,
float r_quad[4][2]);

21
source/blender/sequencer/SEQ_utils.h
View File

@ -36,6 +36,13 @@ struct Sequence;
struct StripElem;
struct SeqRenderData;
/**
* Sort strips in provided seqbase. Effect strips are trailing the list and they are sorted by
* channel position as well.
* This is important for SEQ_time_update_sequence to work properly
*
* \param seqbase: ListBase with strips
*/
void SEQ_sort(struct ListBase *seqbase);
void SEQ_sequence_base_unique_name_recursive(struct Scene *scene,
struct ListBase *seqbasep,
@ -43,7 +50,14 @@ void SEQ_sequence_base_unique_name_recursive(struct Scene *scene,
const char *SEQ_sequence_give_name(struct Sequence *seq);
struct ListBase *SEQ_get_seqbase_from_sequence(struct Sequence *seq, int *r_offset);
const struct Sequence *SEQ_get_topmost_sequence(const struct Scene *scene, int frame);
/**
* In cases where we don't know the sequence's listbase.
*/
struct ListBase *SEQ_get_seqbase_by_seq(struct ListBase *seqbase, struct 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,
@ -57,6 +71,13 @@ void SEQ_set_scale_to_fit(const struct Sequence *seq,
const int preview_width,
const int preview_height,
const eSeqImageFitMethod fit_method);
/**
* Ensure, that provided Sequence has unique name. If animation data exists for this Sequence, it
* will be duplicated and mapped onto new name
*
* \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);
#ifdef __cplusplus
}

7
source/blender/sequencer/intern/clipboard.c
View File

@ -194,13 +194,6 @@ 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.
*
* \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(Sequence *pasted_seq)
{
return STREQ(pasted_seq->name, seq_clipboard_active_seq_name);

3
source/blender/sequencer/intern/effects.c
View File

@ -3135,8 +3135,6 @@ static FCurve *seq_effect_speed_speed_factor_curve_get(Scene *scene, Sequence *s
return id_data_find_fcurve(&scene->id, seq, &RNA_Sequence, "speed_factor", 0, NULL);
}
/* Build frame map when speed in mode #SEQ_SPEED_MULTIPLY is animated.
* This is, because `target_frame` value is integrated over time. */
void seq_effect_speed_rebuild_map(Scene *scene, Sequence *seq)
{
if ((seq->seq1 == NULL) || (seq->len < 1)) {
@ -3175,7 +3173,6 @@ static void seq_effect_speed_frame_map_ensure(Scene *scene, Sequence *seq)
seq_effect_speed_rebuild_map(scene, seq);
}
/* Override timeline_frame when rendering speed effect input. */
float seq_speed_effect_target_frame_get(Scene *scene,
Sequence *seq_speed,
float timeline_frame,

7
source/blender/sequencer/intern/effects.h
View File

@ -39,7 +39,14 @@ struct Sequence;
*/
struct SeqEffectHandle seq_effect_get_sequence_blend(struct Sequence *seq);
/**
* Build frame map when speed in mode #SEQ_SPEED_MULTIPLY is animated.
* This is, because `target_frame` value is integrated over time.
*/
void seq_effect_speed_rebuild_map(struct Scene *scene, struct Sequence *seq);
/**
* Override timeline_frame when rendering speed effect input.
*/
float seq_speed_effect_target_frame_get(struct Scene *scene,
struct Sequence *seq,
float timeline_frame,

3
source/blender/sequencer/intern/image_cache.c
View File

@ -453,9 +453,6 @@ static SeqCacheKey *seq_cache_get_item_for_removal(Scene *scene)
return finalkey;
}
/* Find only "base" keys.
* Sources(other types) for a frame must be freed all at once.
*/
bool seq_cache_recycle_item(Scene *scene)
{
SeqCache *cache = seq_cache_get_from_scene(scene);

4
source/blender/sequencer/intern/image_cache.h
View File

@ -70,6 +70,10 @@ bool seq_cache_put_if_possible(const struct SeqRenderData *context,
float timeline_frame,
int type,
struct ImBuf *nval);
/**
* Find only "base" keys.
* Sources(other types) for a frame must be freed all at once.
*/
bool seq_cache_recycle_item(struct Scene *scene);
void seq_cache_free_temp_cache(struct Scene *scene, short id, int timeline_frame);
void seq_cache_destruct(struct Scene *scene);

135
source/blender/sequencer/intern/iterator.c
View File

@ -44,18 +44,6 @@
/** \Iterator API
* \{ */
/**
* Utility function for SEQ_ITERATOR_FOREACH macro.
* Ensure, that iterator is initialized. During initialization return pointer to collection element
* and step gset iterator. When this function is called after iterator has been initialized, it
* will do nothing and return true.
*
* \param collection: collection to iterate
* \param iterator: iterator to be initialized
* \param r_seq: pointer to Sequence pointer
*
* \return false when iterator can not be initialized, true otherwise
*/
bool SEQ_iterator_ensure(SeqCollection *collection, SeqIterator *iterator, Sequence **r_seq)
{
if (iterator->iterator_initialized) {
@ -76,14 +64,6 @@ bool SEQ_iterator_ensure(SeqCollection *collection, SeqIterator *iterator, Seque
return true;
}
/**
* Utility function for SEQ_ITERATOR_FOREACH macro.
* Yield collection element
*
* \param iterator: iterator to be initialized
*
* \return collection element or NULL when iteration has ended
*/
Sequence *SEQ_iterator_yield(SeqIterator *iterator)
{
Sequence *seq = BLI_gsetIterator_done(&iterator->gsi) ? NULL :
@ -108,36 +88,17 @@ static bool seq_for_each_recursive(ListBase *seqbase, SeqForEachFunc callback, v
return true;
}
/**
* Utility function to recursively iterate through all sequence strips in a `seqbase` list.
* Uses callback to do operations on each sequence element.
* The callback can stop the iteration if needed.
*
* \param seqbase: #ListBase of sequences to be iterated over.
* \param callback: query function callback, returns false if iteration should stop.
* \param user_data: pointer to user data that can be used in the callback function.
*/
void SEQ_for_each_callback(ListBase *seqbase, SeqForEachFunc callback, void *user_data)
{
seq_for_each_recursive(seqbase, callback, user_data);
}
/**
* Free strip collection.
*
* \param collection: collection to be freed
*/
void SEQ_collection_free(SeqCollection *collection)
{
BLI_gset_free(collection->set, NULL);
MEM_freeN(collection);
}
/**
* Create new empty strip collection.
*
* \return empty strip collection.
*/
SeqCollection *SEQ_collection_create(const char *name)
{
SeqCollection *collection = MEM_callocN(sizeof(SeqCollection), name);
@ -146,30 +107,16 @@ SeqCollection *SEQ_collection_create(const char *name)
return collection;
}
/**
* Return number of items in collection.
*/
uint SEQ_collection_len(const SeqCollection *collection)
{
return BLI_gset_len(collection->set);
}
/**
* Check if seq is in collection.
*/
bool SEQ_collection_has_strip(const Sequence *seq, const SeqCollection *collection)
{
return BLI_gset_haskey(collection->set, seq);
}
/**
* Query strips from seqbase. seq_reference is used by query function as filter condition.
*
* \param seq_reference: reference strip for query function
* \param seqbase: ListBase in which strips are queried
* \param seq_query_func: query function callback
* \return strip collection
*/
SeqCollection *SEQ_query_by_reference(Sequence *seq_reference,
ListBase *seqbase,
void seq_query_func(Sequence *seq_reference,
@ -180,13 +127,6 @@ SeqCollection *SEQ_query_by_reference(Sequence *seq_reference,
seq_query_func(seq_reference, seqbase, collection);
return collection;
}
/**
* Add strip to collection.
*
* \param seq: strip to be added
* \param collection: collection to which strip will be added
* \return false if strip is already in set, otherwise true
*/
bool SEQ_collection_append_strip(Sequence *seq, SeqCollection *collection)
{
void **key;
@ -198,24 +138,11 @@ bool SEQ_collection_append_strip(Sequence *seq, SeqCollection *collection)
return true;
}
/**
* Remove strip from collection.
*
* \param seq: strip to be removed
* \param collection: collection from which strip will be removed
* \return true if strip exists in set and it was removed from set, otherwise false
*/
bool SEQ_collection_remove_strip(Sequence *seq, SeqCollection *collection)
{
return BLI_gset_remove(collection->set, seq, NULL);
}
/**
* Move strips from collection_src to collection_dst. Source collection will be freed.
*
* \param collection_dst: destination collection
* \param collection_src: source collection
*/
void SEQ_collection_merge(SeqCollection *collection_dst, SeqCollection *collection_src)
{
Sequence *seq;
@ -225,13 +152,6 @@ void SEQ_collection_merge(SeqCollection *collection_dst, SeqCollection *collecti
SEQ_collection_free(collection_src);
}
/**
* Remove strips from collection that are also in `exclude_elements`. Source collection will be
* freed.
*
* \param collection: collection from which strips are removed
* \param exclude_elements: collection of strips to be removed
*/
void SEQ_collection_exclude(SeqCollection *collection, SeqCollection *exclude_elements)
{
Sequence *seq;
@ -241,14 +161,6 @@ void SEQ_collection_exclude(SeqCollection *collection, SeqCollection *exclude_el
SEQ_collection_free(exclude_elements);
}
/**
* Expand collection by running SEQ_query() for each strip, which will be used as reference.
* Results of these queries will be merged into provided collection.
*
* \param seqbase: ListBase in which strips are queried
* \param collection: SeqCollection to be expanded
* \param seq_query_func: query function callback
*/
void SEQ_collection_expand(ListBase *seqbase,
SeqCollection *collection,
void seq_query_func(Sequence *seq_reference,
@ -267,12 +179,6 @@ void SEQ_collection_expand(ListBase *seqbase,
SEQ_collection_merge(collection, query_matches);
}
/**
* Duplicate collection
*
* \param collection: collection to be duplicated
* \return duplicate of collection
*/
SeqCollection *SEQ_collection_duplicate(SeqCollection *collection)
{
SeqCollection *duplicate = SEQ_collection_create(__func__);
@ -295,12 +201,6 @@ static void query_all_strips_recursive(ListBase *seqbase, SeqCollection *collect
}
}
/**
* Query all strips in seqbase and nested meta strips.
*
* \param seqbase: ListBase in which strips are queried
* \return strip collection
*/
SeqCollection *SEQ_query_all_strips_recursive(ListBase *seqbase)
{
SeqCollection *collection = SEQ_collection_create(__func__);
@ -313,12 +213,6 @@ SeqCollection *SEQ_query_all_strips_recursive(ListBase *seqbase)
return collection;
}
/**
* Query all strips in seqbase. This does not include strips nested in meta strips.
*
* \param seqbase: ListBase in which strips are queried
* \return strip collection
*/
SeqCollection *SEQ_query_all_strips(ListBase *seqbase)
{
SeqCollection *collection = SEQ_collection_create(__func__);
@ -328,12 +222,6 @@ SeqCollection *SEQ_query_all_strips(ListBase *seqbase)
return collection;
}
/**
* Query all selected strips in seqbase.
*
* \param seqbase: ListBase in which strips are queried
* \return strip collection
*/
SeqCollection *SEQ_query_selected_strips(ListBase *seqbase)
{
SeqCollection *collection = SEQ_collection_create(__func__);
@ -434,14 +322,6 @@ static void collection_filter_rendered_strips(SeqCollection *collection)
}
}
/**
* Query strips that are rendered at \a timeline_frame when \a displayed channel is viewed
*
* \param seqbase: ListBase in which strips are queried
* \param timeline_frame: viewed frame
* \param displayed_channel: viewed channel. when set to 0, no channel filter is applied
* \return strip collection
*/
SeqCollection *SEQ_query_rendered_strips(ListBase *seqbase,
const int timeline_frame,
const int displayed_channel)
@ -454,12 +334,6 @@ SeqCollection *SEQ_query_rendered_strips(ListBase *seqbase,
return collection;
}
/**
* Query all unselected strips in seqbase.
*
* \param seqbase: ListBase in which strips are queried
* \return strip collection
*/
SeqCollection *SEQ_query_unselected_strips(ListBase *seqbase)
{
SeqCollection *collection = SEQ_collection_create(__func__);
@ -472,15 +346,6 @@ SeqCollection *SEQ_query_unselected_strips(ListBase *seqbase)
return collection;
}
/**
* Query all effect strips that are directly or indirectly connected to seq_reference.
* This includes all effects of seq_reference, strips used by another inputs and their effects, so
* that whole chain is fully independent of other strips.
*
* \param seq_reference: reference strip
* \param seqbase: ListBase in which strips are queried
* \param collection: collection to be filled
*/
void SEQ_query_strip_effect_chain(Sequence *seq_reference,
ListBase *seqbase,
SeqCollection *collection)

1
source/blender/sequencer/intern/multiview.c
View File

@ -40,7 +40,6 @@ void seq_anim_add_suffix(Scene *scene, struct anim *anim, const int view_id)
IMB_suffix_anim(anim, suffix);
}
/* the number of files will vary according to the stereo format */
int seq_num_files(Scene *scene, char views_format, const bool is_multiview)
{
if (!is_multiview) {

3
source/blender/sequencer/intern/multiview.h
View File

@ -43,6 +43,9 @@ void seq_multiview_name(struct Scene *scene,
const char *ext,
char *r_path,
size_t r_size);
/**
* The number of files will vary according to the stereo format.
*/
int seq_num_files(struct Scene *scene, char views_format, const bool is_multiview);
#ifdef __cplusplus

6
source/blender/sequencer/intern/prefetch.c
View File

@ -162,14 +162,12 @@ static Sequence *sequencer_prefetch_get_original_sequence(Sequence *seq, ListBas
return NULL;
}
/* for cache context swapping */
Sequence *seq_prefetch_get_original_sequence(Sequence *seq, Scene *scene)
{
Editing *ed = scene->ed;
return sequencer_prefetch_get_original_sequence(seq, &ed->seqbase);
}
/* for cache context swapping */
SeqRenderData *seq_prefetch_get_original_context(const SeqRenderData *context)
{
PrefetchJob *pfjob = seq_prefetch_job_get(context->scene);
@ -268,9 +266,6 @@ void SEQ_prefetch_stop_all(void)
}
}
/* Use also to update scene and context changes
* This function should almost always be called by cache invalidation, not directly.
*/
void SEQ_prefetch_stop(Scene *scene)
{
PrefetchJob *pfjob;
@ -561,7 +556,6 @@ static PrefetchJob *seq_prefetch_start_ex(const SeqRenderData *context, float cf
return pfjob;
}
/* Start or resume prefetching. */
void seq_prefetch_start(const SeqRenderData *context, float timeline_frame)
{
Scene *scene = context->scene;

9
source/blender/sequencer/intern/prefetch.h
View File

@ -35,11 +35,20 @@ struct Sequence;
}
#endif
/**
* Start or resume prefetching.
*/
void seq_prefetch_start(const struct SeqRenderData *context, float timeline_frame);
void seq_prefetch_free(struct Scene *scene);
bool seq_prefetch_job_is_running(struct Scene *scene);
void seq_prefetch_get_time_range(struct Scene *scene, int *start, int *end);
/**
* For cache context swapping.
*/
struct SeqRenderData *seq_prefetch_get_original_context(const struct SeqRenderData *context);
/**
* For cache context swapping.
*/
struct Sequence *seq_prefetch_get_original_sequence(struct Sequence *seq, struct Scene *scene);
#ifdef __cplusplus

11
source/blender/sequencer/intern/render.c
View File

@ -97,6 +97,7 @@ SequencerDrawView sequencer_view3d_fn = NULL; /* NULL in background mode */
/* -------------------------------------------------------------------- */
/** \name Color-space utility functions
* \{ */
void seq_imbuf_assign_spaces(Scene *scene, ImBuf *ibuf)
{
#if 0
@ -1914,11 +1915,6 @@ static ImBuf *seq_render_strip_stack(const SeqRenderData *context,
return out;
}
/**
* \return The image buffer or NULL.
*
* \note The returned #ImBuf has its reference increased, free after usage!
*/
ImBuf *SEQ_render_give_ibuf(const SeqRenderData *context, float timeline_frame, int chanshown)
{
Scene *scene = context->scene;
@ -2029,7 +2025,6 @@ static ImBuf *seq_get_uncached_thumbnail(const SeqRenderData *context,
return scaled_ibuf;
}
/* Get cached thumbnails. */
ImBuf *SEQ_get_thumbnail(
const SeqRenderData *context, Sequence *seq, float timeline_frame, rcti *crop, bool clipped)
{
@ -2054,7 +2049,6 @@ ImBuf *SEQ_get_thumbnail(
return ibuf_cropped;
}
/* Render the series of thumbnails and store in cache. */
void SEQ_render_thumbnails(const SeqRenderData *context,
Sequence *seq,
Sequence *seq_orig,
@ -2099,8 +2093,6 @@ void SEQ_render_thumbnails(const SeqRenderData *context,
}
}
/* 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 Sequence *seq)
{
const int content_len = (seq->enddisp - seq->startdisp - seq->startstill - seq->endstill);
@ -2113,7 +2105,6 @@ int SEQ_render_thumbnails_guaranteed_set_frame_step_get(const Sequence *seq)
return content_len / thumbnails_base_set_count;
}
/* Render set of evenly spaced thumbnails that are drawn when zooming. */
void SEQ_render_thumbnails_base_set(const SeqRenderData *context,
Sequence *seq,
Sequence *seq_orig,

21
source/blender/sequencer/intern/sequence_lookup.c
View File

@ -105,11 +105,6 @@ static void seq_sequence_lookup_update_if_needed(const struct Scene *scene,
seq_sequence_lookup_rebuild(scene, lookup);
}
/**
* Free lookup hash data.
*
* \param scene: scene that owns lookup hash
*/
void SEQ_sequence_lookup_free(const Scene *scene)
{
BLI_assert(scene->ed);
@ -119,16 +114,6 @@ void SEQ_sequence_lookup_free(const Scene *scene)
BLI_mutex_unlock(&lookup_lock);
}
/**
* Find a sequence with a given name.
* If lookup hash doesn't exist, it will be created. If hash is tagged as invalid, it will be
* rebuilt.
*
* \param scene: scene that owns lookup hash
* \param key: Sequence name without SQ prefix (seq->name + 2)
*
* \return pointer to Sequence
*/
Sequence *SEQ_sequence_lookup_by_name(const Scene *scene, const char *key)
{
BLI_assert(scene->ed);
@ -140,12 +125,6 @@ Sequence *SEQ_sequence_lookup_by_name(const Scene *scene, const char *key)
return seq;
}
/**
* 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 Scene *scene, eSequenceLookupTag tag)
{
if (!scene->ed) {

41
source/blender/sequencer/intern/sequencer.c
View File

@ -227,8 +227,6 @@ void SEQ_sequence_free(Scene *scene, Sequence *seq, const bool do_clean_animdata
seq_sequence_free_ex(scene, seq, true, true, do_clean_animdata);
}
/* cache must be freed before calling this function
* since it leaves the seqbase in an invalid state */
void seq_free_sequence_recurse(Scene *scene,
Sequence *seq,
const bool do_id_user,
@ -388,12 +386,6 @@ int SEQ_tool_settings_pivot_point_get(Scene *scene)
return tool_settings->pivot_point;
}
/**
* 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
*/
ListBase *SEQ_active_seqbase_get(const Editing *ed)
{
if (ed == NULL) {
@ -403,24 +395,11 @@ ListBase *SEQ_active_seqbase_get(const Editing *ed)
return ed->seqbasep;
}
/**
* 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(Editing *ed, ListBase *seqbase)
{
ed->seqbasep = seqbase;
}
/**
* Create and initialize #MetaStack, append it to `ed->metastack` ListBase
*
* \param ed: sequence editor data
* \param seq_meta: meta strip
* \return pointer to created meta stack
*/
MetaStack *SEQ_meta_stack_alloc(Editing *ed, Sequence *seq_meta)
{
MetaStack *ms = MEM_mallocN(sizeof(MetaStack), "metastack");
@ -431,24 +410,12 @@ MetaStack *SEQ_meta_stack_alloc(Editing *ed, Sequence *seq_meta)
return ms;
}
/**
* Free #MetaStack and remove it from `ed->metastack` ListBase.
*
* \param ed: sequence editor data
* \param ms: meta stack
*/
void SEQ_meta_stack_free(Editing *ed, MetaStack *ms)
{
BLI_remlink(&ed->metastack, ms);
MEM_freeN(ms);
}
/**
* Get #MetaStack that corresponds to current level that is being viewed
*
* \param ed: sequence editor data
* \return pointer to meta stack
*/
MetaStack *SEQ_meta_stack_active_get(const Editing *ed)
{
return ed->metastack.last;
@ -662,9 +629,11 @@ static size_t sequencer_rna_path_prefix(char str[SEQ_RNAPATH_MAXSTR], const char
str, SEQ_RNAPATH_MAXSTR, "sequence_editor.sequences_all[\"%s\"]", name_esc);
}
/* XXX: hackish function needed for transforming strips! TODO: have some better solution. */
void SEQ_offset_animdata(Scene *scene, Sequence *seq, int ofs)
{
/* XXX: hackish function needed for transforming strips!
* TODO: have some better solution. */
char str[SEQ_RNAPATH_MAXSTR];
size_t str_len;
FCurve *fcu;
@ -1069,10 +1038,6 @@ static bool seq_update_seq_cb(Sequence *seq, void *user_data)
return true;
}
/* Evaluate parts of sequences which needs to be done as a part of a dependency graph evaluation.
* 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(Depsgraph *depsgraph, Scene *scene, ListBase *seqbase)
{
DEG_debug_print_eval(depsgraph, __func__, scene->id.name, scene);

4
source/blender/sequencer/intern/sequencer.h
View File

@ -30,6 +30,10 @@ extern "C" {
struct Scene;
struct Sequence;
/**
* Cache must be freed before calling this function
* since it leaves the seqbase in an invalid state.
*/
void seq_free_sequence_recurse(struct Scene *scene,
struct Sequence *seq,
const bool do_id_user,

80
source/blender/sequencer/intern/strip_add.c
View File

@ -70,16 +70,6 @@
#include "proxy.h"
#include "utils.h"
/**
* Initialize common SeqLoadData members
*
* \param load_data: SeqLoadData to be initialized
* \param name: strip name (can be NULL)
* \param path: path to file that is used as strip input (can be NULL)
* \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(SeqLoadData *load_data,
const char *name,
const char *path,
@ -147,14 +137,6 @@ static void seq_add_set_view_transform(Scene *scene, Sequence *seq, SeqLoadData
}
}
/**
* Add scene strip.
*
* \param scene: Scene where strips will be added
* \param seqbase: ListBase where strips will be added
* \param load_data: SeqLoadData with information necessary to create strip
* \return created strip
*/
Sequence *SEQ_add_scene_strip(Scene *scene, ListBase *seqbase, struct SeqLoadData *load_data)
{
Sequence *seq = SEQ_sequence_alloc(
@ -168,14 +150,6 @@ Sequence *SEQ_add_scene_strip(Scene *scene, ListBase *seqbase, struct SeqLoadDat
return seq;
}
/**
* Add movieclip strip.
*
* \param scene: Scene where strips will be added
* \param seqbase: ListBase where strips will be added
* \param load_data: SeqLoadData with information necessary to create strip
* \return created strip
*/
Sequence *SEQ_add_movieclip_strip(Scene *scene, ListBase *seqbase, struct SeqLoadData *load_data)
{
Sequence *seq = SEQ_sequence_alloc(
@ -189,14 +163,6 @@ Sequence *SEQ_add_movieclip_strip(Scene *scene, ListBase *seqbase, struct SeqLoa
return seq;
}
/**
* Add mask strip.
*
* \param scene: Scene where strips will be added
* \param seqbase: ListBase where strips will be added
* \param load_data: SeqLoadData with information necessary to create strip
* \return created strip
*/
Sequence *SEQ_add_mask_strip(Scene *scene, ListBase *seqbase, struct SeqLoadData *load_data)
{
Sequence *seq = SEQ_sequence_alloc(
@ -210,14 +176,6 @@ Sequence *SEQ_add_mask_strip(Scene *scene, ListBase *seqbase, struct SeqLoadData
return seq;
}
/**
* Add effect strip.
*
* \param scene: Scene where strips will be added
* \param seqbase: ListBase where strips will be added
* \param load_data: SeqLoadData with information necessary to create strip
* \return created strip
*/
Sequence *SEQ_add_effect_strip(Scene *scene, ListBase *seqbase, struct SeqLoadData *load_data)
{
Sequence *seq = SEQ_sequence_alloc(
@ -248,35 +206,17 @@ Sequence *SEQ_add_effect_strip(Scene *scene, ListBase *seqbase, struct SeqLoadDa
return seq;
}
/**
* Set directory used by image strip.
*
* \param seq: image strip to be changed
* \param path: directory path
*/
void SEQ_add_image_set_directory(Sequence *seq, char *path)
{
BLI_strncpy(seq->strip->dir, path, sizeof(seq->strip->dir));
}
/**
* Set directory used by image strip.
*
* \param seq: image strip to be changed
* \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(Sequence *seq, size_t strip_frame, char *filename)
{
StripElem *se = SEQ_render_give_stripelem(seq, seq->start + strip_frame);
BLI_strncpy(se->name, filename, sizeof(se->name));
}
/**
* Set image strip alpha mode
*
* \param seq: image strip to be changed
*/
void SEQ_add_image_init_alpha_mode(Sequence *seq)
{
if (seq->strip && seq->strip->stripdata) {
@ -306,16 +246,6 @@ void SEQ_add_image_init_alpha_mode(Sequence *seq)
}
}
/**
* Add image strip.
* NOTE: Use SEQ_add_image_set_directory() and SEQ_add_image_load_file() to load image sequences
*
* \param main: Main reference
* \param scene: Scene where strips will be added
* \param seqbase: ListBase where strips will be added
* \param load_data: SeqLoadData with information necessary to create strip
* \return created strip
*/
Sequence *SEQ_add_image_strip(Main *bmain, Scene *scene, ListBase *seqbase, SeqLoadData *load_data)
{
Sequence *seq = SEQ_sequence_alloc(
@ -470,15 +400,6 @@ Sequence *SEQ_add_meta_strip(Scene *scene, ListBase *seqbase, SeqLoadData *load_
return seqm;
}
/**
* Add movie strip.
*
* \param main: Main reference
* \param scene: Scene where strips will be added
* \param seqbase: ListBase where strips will be added
* \param load_data: SeqLoadData with information necessary to create strip
* \return created strip
*/
Sequence *SEQ_add_movie_strip(
Main *bmain, Scene *scene, ListBase *seqbase, SeqLoadData *load_data, double *r_start_offset)
{
@ -617,7 +538,6 @@ Sequence *SEQ_add_movie_strip(
return seq;
}
/* NOTE: caller should run SEQ_time_update_sequence(scene, seq) after. */
void SEQ_add_reload_new_file(Main *bmain, Scene *scene, Sequence *seq, const bool lock_range)
{
char path[FILE_MAX];

38
source/blender/sequencer/intern/strip_edit.c
View File

@ -175,7 +175,6 @@ static void sequencer_flag_users_for_removal(Scene *scene, ListBase *seqbase, Se
}
}
/* Flag seq and its users (effects) for removal. */
void SEQ_edit_flag_for_removal(Scene *scene, ListBase *seqbase, Sequence *seq)
{
if (seq == NULL || (seq->flag & SEQ_FLAG_DELETE) != 0) {
@ -193,7 +192,6 @@ void SEQ_edit_flag_for_removal(Scene *scene, ListBase *seqbase, Sequence *seq)
sequencer_flag_users_for_removal(scene, seqbase, seq);
}
/* Remove all flagged sequences, return true if sequence is removed. */
void SEQ_edit_remove_flagged_sequences(Scene *scene, ListBase *seqbase)
{
LISTBASE_FOREACH_MUTABLE (Sequence *, seq, seqbase) {
@ -221,14 +219,6 @@ static bool seq_exists_in_seqbase(Sequence *seq, ListBase *seqbase)
return false;
}
/**
* Move sequence to seqbase.
*
* \param scene: Scene containing the editing
* \param dst_seqbase: seqbase where `seq` is located
* \param seq: Sequence to move
* \param dst_seqbase: Target seqbase
*/
bool SEQ_edit_move_strip_to_seqbase(Scene *scene,
ListBase *seqbase,
Sequence *seq,
@ -247,14 +237,6 @@ bool SEQ_edit_move_strip_to_seqbase(Scene *scene,
return true;
}
/**
* Move sequence to meta sequence.
*
* \param scene: Scene containing the editing
* \param src_seq: Sequence to move
* \param dst_seqm: Target Meta sequence
* \param error_str: Error message
*/
bool SEQ_edit_move_strip_to_meta(Scene *scene,
Sequence *src_seq,
Sequence *dst_seqm,
@ -468,17 +450,6 @@ static bool seq_edit_split_operation_permitted_check(SeqCollection *strips,
return true;
}
/**
* Split Sequence at timeline_frame in two.
*
* \param bmain: Main in which Sequence is located
* \param scene: Scene in which Sequence is located
* \param seqbase: ListBase in which Sequence is located
* \param seq: Sequence to be split
* \param timeline_frame: frame at which seq is split.
* \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.
*/
Sequence *SEQ_edit_strip_split(Main *bmain,
Scene *scene,
ListBase *seqbase,
@ -558,15 +529,6 @@ Sequence *SEQ_edit_strip_split(Main *bmain,
return return_seq;
}
/**
* Find gap after initial_frame and move strips on right side to close the gap
*
* \param scene: Scene in which strips are located
* \param seqbase: ListBase in which strips are located
* \param initial_frame: frame on timeline from where gaps are searched for
* \param remove_all_gaps: remove all gaps instead of one gap
* \return true if gap is removed, otherwise false
*/
bool SEQ_edit_remove_gaps(Scene *scene,
ListBase *seqbase,
const int initial_frame,

3
source/blender/sequencer/intern/strip_relations.c
View File

@ -352,7 +352,6 @@ bool SEQ_relations_check_scene_recursion(Scene *scene, ReportList *reports)
return false;
}
/* Check if "seq_main" (indirectly) uses strip "seq". */
bool SEQ_relations_render_loop_check(Sequence *seq_main, Sequence *seq)
{
if (seq_main == NULL || seq == NULL) {
@ -379,7 +378,6 @@ bool SEQ_relations_render_loop_check(Sequence *seq_main, Sequence *seq)
return false;
}
/* Function to free imbuf and anim data on changes */
void SEQ_relations_sequence_free_anim(Sequence *seq)
{
while (seq->anims.last) {
@ -432,7 +430,6 @@ void SEQ_relations_check_uuids_unique_and_report(const Scene *scene)
BLI_gset_free(used_uuids, NULL);
}
/* Return immediate parent meta of sequence */
struct Sequence *SEQ_find_metastrip_by_sequence(ListBase *seqbase, Sequence *meta, Sequence *seq)
{
Sequence *iseq;

36
source/blender/sequencer/intern/strip_time.c
View File

@ -434,12 +434,6 @@ float SEQ_time_sequence_get_fps(Scene *scene, Sequence *seq)
return 0.0f;
}
/**
* Initialize given rectangle with the Scene's timeline boundaries.
*
* \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 Scene *scene, rctf *rect)
{
rect->xmin = scene->r.sfra;
@ -448,12 +442,6 @@ void SEQ_timeline_init_boundbox(const Scene *scene, rctf *rect)
rect->ymax = 8.0f;
}
/**
* 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 ListBase *seqbase, rctf *rect)
{
if (seqbase == NULL) {
@ -473,13 +461,6 @@ void SEQ_timeline_expand_boundbox(const ListBase *seqbase, rctf *rect)
}
}
/**
* Define boundary rectangle of sequencer timeline and fill in rect data
*
* \param scene: Scene in which strips are located
* \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 Scene *scene, const ListBase *seqbase, rctf *rect)
{
SEQ_timeline_init_boundbox(scene, rect);
@ -497,14 +478,6 @@ static bool strip_exists_at_frame(SeqCollection *all_strips, const int timeline_
return false;
}
/**
* Find first gap between strips after initial_frame and describe it by filling data of r_gap_info
*
* \param scene: Scene in which strips are located
* \param seqbase: ListBase in which strips are located
* \param initial_frame: frame on timeline from where gaps are searched for
* \param r_gap_info: data structure describing gap, that will be filled in by this function
*/
void seq_time_gap_info_get(const Scene *scene,
ListBase *seqbase,
const int initial_frame,
@ -550,15 +523,6 @@ void seq_time_gap_info_get(const Scene *scene,
}
}
/**
* Test if strip intersects with timeline frame.
* NOTE: This checks if strip would be rendered at this frame. For rendering it is assumed, that
* timeline frame has width of 1 frame and therefore ends at timeline_frame + 1
*
* \param seq: Sequence to be checked
* \param timeline_frame: absolute frame position
* \return true if strip intersects with timeline frame.
*/
bool SEQ_time_strip_intersects_frame(const Sequence *seq, const int timeline_frame)
{
return (seq->startdisp <= timeline_frame) && (seq->enddisp > timeline_frame);

9
source/blender/sequencer/intern/strip_time.h
View File

@ -40,6 +40,15 @@ typedef struct GapInfo {
int gap_length; /* Length of the gap. */
bool gap_exists; /* False if there are no gaps. */
} GapInfo;
/**
* Find first gap between strips after initial_frame and describe it by filling data of r_gap_info
*
* \param scene: Scene in which strips are located.
* \param seqbase: ListBase in which strips are located.
* \param initial_frame: frame on timeline from where gaps are searched for.
* \param r_gap_info: data structure describing gap, that will be filled in by this function.
*/
void seq_time_gap_info_get(const struct Scene *scene,
struct ListBase *seqbase,
const int initial_frame,

40
source/blender/sequencer/intern/strip_transform.c
View File

@ -86,8 +86,6 @@ void SEQ_transform_set_right_handle_frame(Sequence *seq, int val)
}
}
/* used so we can do a quick check for single image seq
* since they work a bit differently to normal image seq's (during transform) */
bool SEQ_transform_single_image_check(Sequence *seq)
{
return ((seq->len == 1) &&
@ -95,7 +93,6 @@ bool SEQ_transform_single_image_check(Sequence *seq)
((seq->type & SEQ_TYPE_EFFECT) && SEQ_effect_get_num_inputs(seq->type) == 0)));
}
/* check if the selected seq's reference unselected seq's */
bool SEQ_transform_seqbase_isolated_sel_check(ListBase *seqbase)
{
Sequence *seq;
@ -137,10 +134,6 @@ bool SEQ_transform_seqbase_isolated_sel_check(ListBase *seqbase)
return true;
}
/**
* Use to impose limits when dragging/extending - so impossible situations don't happen.
* Can't use the #SEQ_LEFTSEL and #SEQ_LEFTSEL directly because the strip may be in a meta-strip.
*/
void SEQ_transform_handle_xlimits(Sequence *seq, int leftflag, int rightflag)
{
if (leftflag) {
@ -257,7 +250,6 @@ void SEQ_transform_translate_sequence(Scene *evil_scene, Sequence *seq, int delt
SEQ_time_update_sequence(evil_scene, seqbase, seq);
}
/* return 0 if there weren't enough space */
bool SEQ_transform_seqbase_shuffle_ex(ListBase *seqbasep,
Sequence *test,
Scene *evil_scene,
@ -393,14 +385,6 @@ bool SEQ_transform_seqbase_shuffle_time(SeqCollection *strips_to_shuffle,
return offset ? false : true;
}
/**
* Move strips and markers (if not locked) that start after timeline_frame by delta frames
*
* \param scene: Scene in which strips are located
* \param seqbase: ListBase in which strips are located
* \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(Scene *scene,
ListBase *seqbase,
const int delta,
@ -436,14 +420,6 @@ 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.
*
* \param scene: Scene in which strips are located
* \param seq: Sequence to calculate image transform origin
* \param r_origin: return value
*/
void SEQ_image_transform_origin_offset_pixelspace_get(const Scene *scene,
const Sequence *seq,
float r_origin[2])
@ -523,15 +499,6 @@ static void seq_image_transform_quad_get_ex(const Scene *scene,
}
}
/**
* Get 4 corner points of strip image, optionally without rotation component applied.
* Corner vectors are in viewport space.
*
* \param scene: Scene in which strips are located
* \param seq: Sequence to calculate transformed image quad
* \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 Scene *scene,
const Sequence *seq,
bool apply_rotation,
@ -540,13 +507,6 @@ void SEQ_image_transform_quad_get(const Scene *scene,
seq_image_transform_quad_get_ex(scene, seq, apply_rotation, r_quad);
}
/**
* Get 4 corner points of strip image. Corner vectors are in viewport space.
*
* \param scene: Scene in which strips are located
* \param seq: Sequence to calculate transformed image quad
* \param r_quad: array of 4 2D vectors
*/
void SEQ_image_transform_final_quad_get(const Scene *scene,
const Sequence *seq,
float r_quad[4][2])

23
source/blender/sequencer/intern/utils.c
View File

@ -55,13 +55,6 @@
#include "proxy.h"
#include "utils.h"
/**
* Sort strips in provided seqbase. Effect strips are trailing the list and they are sorted by
* channel position as well.
* This is important for SEQ_time_update_sequence to work properly
*
* \param seqbase: ListBase with strips
*/
void SEQ_sort(ListBase *seqbase)
{
if (seqbase == NULL) {
@ -432,7 +425,6 @@ const Sequence *SEQ_get_topmost_sequence(const Scene *scene, int frame)
return best_seq;
}
/* in cases where we don't know the sequence's listbase */
ListBase *SEQ_get_seqbase_by_seq(ListBase *seqbase, Sequence *seq)
{
Sequence *iseq;
@ -465,10 +457,6 @@ Sequence *SEQ_get_meta_by_seqbase(ListBase *seqbase_main, ListBase *meta_seqbase
return seq;
}
/**
* Only use as last resort when the StripElem is available but no the Sequence.
* (needed for RNA)
*/
Sequence *SEQ_sequence_from_strip_elem(ListBase *seqbase, StripElem *se)
{
Sequence *iseq;
@ -525,10 +513,10 @@ void SEQ_alpha_mode_from_file_extension(Sequence *seq)
}
}
/* called on draw, needs to be fast,
* we could cache and use a flag if we want to make checks for file paths resolving for eg. */
bool SEQ_sequence_has_source(const Sequence *seq)
{
/* Called on draw, needs to be fast,
* we could cache and use a flag if we want to make checks for file paths resolving for eg. */
switch (seq->type) {
case SEQ_TYPE_MASK:
return (seq->mask != NULL);
@ -589,13 +577,6 @@ void SEQ_set_scale_to_fit(const Sequence *seq,
}
}
/**
* Ensure, that provided Sequence has unique name. If animation data exists for this Sequence, it
* will be duplicated and mapped onto new name
*
* \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(Sequence *seq, Scene *scene)
{
char name[SEQ_NAME_MAXSTR];