From 32b1a13fa1e427bc5b2cce2bf179fd274679e08f Mon Sep 17 00:00:00 2001 From: Campbell Barton Date: Wed, 8 Dec 2021 21:02:29 +1100 Subject: Cleanup: move public doc-strings into headers for 'sequencer' Ref T92709 --- source/blender/sequencer/SEQ_add.h | 81 +++++++++++++ source/blender/sequencer/SEQ_clipboard.h | 7 ++ source/blender/sequencer/SEQ_edit.h | 42 +++++++ source/blender/sequencer/SEQ_iterator.h | 139 +++++++++++++++++++++- source/blender/sequencer/SEQ_prefetch.h | 4 + source/blender/sequencer/SEQ_relations.h | 19 ++- source/blender/sequencer/SEQ_render.h | 18 +++ source/blender/sequencer/SEQ_sequencer.h | 64 +++++++++- source/blender/sequencer/SEQ_time.h | 28 +++++ source/blender/sequencer/SEQ_transform.h | 47 ++++++++ source/blender/sequencer/SEQ_utils.h | 21 ++++ source/blender/sequencer/intern/clipboard.c | 7 -- source/blender/sequencer/intern/effects.c | 3 - source/blender/sequencer/intern/effects.h | 7 ++ source/blender/sequencer/intern/image_cache.c | 3 - source/blender/sequencer/intern/image_cache.h | 4 + source/blender/sequencer/intern/iterator.c | 135 --------------------- source/blender/sequencer/intern/multiview.c | 1 - source/blender/sequencer/intern/multiview.h | 3 + source/blender/sequencer/intern/prefetch.c | 6 - source/blender/sequencer/intern/prefetch.h | 9 ++ source/blender/sequencer/intern/render.c | 11 +- source/blender/sequencer/intern/sequence_lookup.c | 21 ---- source/blender/sequencer/intern/sequencer.c | 41 +------ source/blender/sequencer/intern/sequencer.h | 4 + source/blender/sequencer/intern/strip_add.c | 80 ------------- source/blender/sequencer/intern/strip_edit.c | 38 ------ source/blender/sequencer/intern/strip_relations.c | 3 - source/blender/sequencer/intern/strip_time.c | 36 ------ source/blender/sequencer/intern/strip_time.h | 9 ++ source/blender/sequencer/intern/strip_transform.c | 40 ------- source/blender/sequencer/intern/utils.c | 23 +--- 32 files changed, 506 insertions(+), 448 deletions(-) (limited to 'source/blender') diff --git a/source/blender/sequencer/SEQ_add.h b/source/blender/sequencer/SEQ_add.h index d2a731d9953..9a9f229e2d7 100644 --- a/source/blender/sequencer/SEQ_add.h +++ b/source/blender/sequencer/SEQ_add.h @@ -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, diff --git a/source/blender/sequencer/SEQ_clipboard.h b/source/blender/sequencer/SEQ_clipboard.h index ea7f01e6ae3..72388c5db64 100644 --- a/source/blender/sequencer/SEQ_clipboard.h +++ b/source/blender/sequencer/SEQ_clipboard.h @@ -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 diff --git a/source/blender/sequencer/SEQ_edit.h b/source/blender/sequencer/SEQ_edit.h index f3a64c9cd62..c237ffea9c6 100644 --- a/source/blender/sequencer/SEQ_edit.h +++ b/source/blender/sequencer/SEQ_edit.h @@ -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, diff --git a/source/blender/sequencer/SEQ_iterator.h b/source/blender/sequencer/SEQ_iterator.h index d2a47a13db3..a3f378bcfd4 100644 --- a/source/blender/sequencer/SEQ_iterator.h +++ b/source/blender/sequencer/SEQ_iterator.h @@ -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); diff --git a/source/blender/sequencer/SEQ_prefetch.h b/source/blender/sequencer/SEQ_prefetch.h index 93fc8883e99..980f7611094 100644 --- a/source/blender/sequencer/SEQ_prefetch.h +++ b/source/blender/sequencer/SEQ_prefetch.h @@ -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); diff --git a/source/blender/sequencer/SEQ_relations.h b/source/blender/sequencer/SEQ_relations.h index 3b9d430a3c9..3c3fe2fdd83 100644 --- a/source/blender/sequencer/SEQ_relations.h +++ b/source/blender/sequencer/SEQ_relations.h @@ -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); diff --git a/source/blender/sequencer/SEQ_render.h b/source/blender/sequencer/SEQ_render.h index e99dc6d344f..7f10160bf6a 100644 --- a/source/blender/sequencer/SEQ_render.h +++ b/source/blender/sequencer/SEQ_render.h @@ -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, diff --git a/source/blender/sequencer/SEQ_sequencer.h b/source/blender/sequencer/SEQ_sequencer.h index 1b8982da0d2..a3ee716c3f6 100644 --- a/source/blender/sequencer/SEQ_sequencer.h +++ b/source/blender/sequencer/SEQ_sequencer.h @@ -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 diff --git a/source/blender/sequencer/SEQ_time.h b/source/blender/sequencer/SEQ_time.h index a0abaf8813a..e563e94da24 100644 --- a/source/blender/sequencer/SEQ_time.h +++ b/source/blender/sequencer/SEQ_time.h @@ -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); diff --git a/source/blender/sequencer/SEQ_transform.h b/source/blender/sequencer/SEQ_transform.h index 18437680731..fe0c223bcb1 100644 --- a/source/blender/sequencer/SEQ_transform.h +++ b/source/blender/sequencer/SEQ_transform.h @@ -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]); diff --git a/source/blender/sequencer/SEQ_utils.h b/source/blender/sequencer/SEQ_utils.h index d30a1b2d7ae..58d7a92f370 100644 --- a/source/blender/sequencer/SEQ_utils.h +++ b/source/blender/sequencer/SEQ_utils.h @@ -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 } diff --git a/source/blender/sequencer/intern/clipboard.c b/source/blender/sequencer/intern/clipboard.c index 05406c50303..73e0f616da4 100644 --- a/source/blender/sequencer/intern/clipboard.c +++ b/source/blender/sequencer/intern/clipboard.c @@ -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); diff --git a/source/blender/sequencer/intern/effects.c b/source/blender/sequencer/intern/effects.c index 6a6889c3679..05ce35deeec 100644 --- a/source/blender/sequencer/intern/effects.c +++ b/source/blender/sequencer/intern/effects.c @@ -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, diff --git a/source/blender/sequencer/intern/effects.h b/source/blender/sequencer/intern/effects.h index 25ba4d8956e..c63f8f7a404 100644 --- a/source/blender/sequencer/intern/effects.h +++ b/source/blender/sequencer/intern/effects.h @@ -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, diff --git a/source/blender/sequencer/intern/image_cache.c b/source/blender/sequencer/intern/image_cache.c index c742fca0562..51e4613f088 100644 --- a/source/blender/sequencer/intern/image_cache.c +++ b/source/blender/sequencer/intern/image_cache.c @@ -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); diff --git a/source/blender/sequencer/intern/image_cache.h b/source/blender/sequencer/intern/image_cache.h index e7827c15305..65732b5d83d 100644 --- a/source/blender/sequencer/intern/image_cache.h +++ b/source/blender/sequencer/intern/image_cache.h @@ -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); diff --git a/source/blender/sequencer/intern/iterator.c b/source/blender/sequencer/intern/iterator.c index a12a5cbdc61..6cd53f08b3a 100644 --- a/source/blender/sequencer/intern/iterator.c +++ b/source/blender/sequencer/intern/iterator.c @@ -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) diff --git a/source/blender/sequencer/intern/multiview.c b/source/blender/sequencer/intern/multiview.c index e120234ed8b..68d2a33fd5c 100644 --- a/source/blender/sequencer/intern/multiview.c +++ b/source/blender/sequencer/intern/multiview.c @@ -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) { diff --git a/source/blender/sequencer/intern/multiview.h b/source/blender/sequencer/intern/multiview.h index bbc66c6f84c..3d528c22fff 100644 --- a/source/blender/sequencer/intern/multiview.h +++ b/source/blender/sequencer/intern/multiview.h @@ -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 diff --git a/source/blender/sequencer/intern/prefetch.c b/source/blender/sequencer/intern/prefetch.c index 3e0b4738db1..0c45eb09492 100644 --- a/source/blender/sequencer/intern/prefetch.c +++ b/source/blender/sequencer/intern/prefetch.c @@ -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; diff --git a/source/blender/sequencer/intern/prefetch.h b/source/blender/sequencer/intern/prefetch.h index 8cfc6bf90bd..8cc5f6d35d1 100644 --- a/source/blender/sequencer/intern/prefetch.h +++ b/source/blender/sequencer/intern/prefetch.h @@ -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 diff --git a/source/blender/sequencer/intern/render.c b/source/blender/sequencer/intern/render.c index 27274626929..8fa0989d840 100644 --- a/source/blender/sequencer/intern/render.c +++ b/source/blender/sequencer/intern/render.c @@ -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, diff --git a/source/blender/sequencer/intern/sequence_lookup.c b/source/blender/sequencer/intern/sequence_lookup.c index 25b42957d99..8d451d59e92 100644 --- a/source/blender/sequencer/intern/sequence_lookup.c +++ b/source/blender/sequencer/intern/sequence_lookup.c @@ -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) { diff --git a/source/blender/sequencer/intern/sequencer.c b/source/blender/sequencer/intern/sequencer.c index 3478c2d4f97..eddaa51f2de 100644 --- a/source/blender/sequencer/intern/sequencer.c +++ b/source/blender/sequencer/intern/sequencer.c @@ -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); diff --git a/source/blender/sequencer/intern/sequencer.h b/source/blender/sequencer/intern/sequencer.h index e43535d14ee..f8ad17e9032 100644 --- a/source/blender/sequencer/intern/sequencer.h +++ b/source/blender/sequencer/intern/sequencer.h @@ -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, diff --git a/source/blender/sequencer/intern/strip_add.c b/source/blender/sequencer/intern/strip_add.c index 382fdd4953f..b7f6178955a 100644 --- a/source/blender/sequencer/intern/strip_add.c +++ b/source/blender/sequencer/intern/strip_add.c @@ -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]; diff --git a/source/blender/sequencer/intern/strip_edit.c b/source/blender/sequencer/intern/strip_edit.c index 00b3da86306..912ba9d41db 100644 --- a/source/blender/sequencer/intern/strip_edit.c +++ b/source/blender/sequencer/intern/strip_edit.c @@ -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, diff --git a/source/blender/sequencer/intern/strip_relations.c b/source/blender/sequencer/intern/strip_relations.c index e6d9cd330b3..7baae5afabd 100644 --- a/source/blender/sequencer/intern/strip_relations.c +++ b/source/blender/sequencer/intern/strip_relations.c @@ -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; diff --git a/source/blender/sequencer/intern/strip_time.c b/source/blender/sequencer/intern/strip_time.c index a8e07f37a0b..3228277ce72 100644 --- a/source/blender/sequencer/intern/strip_time.c +++ b/source/blender/sequencer/intern/strip_time.c @@ -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); diff --git a/source/blender/sequencer/intern/strip_time.h b/source/blender/sequencer/intern/strip_time.h index ca9a935bc96..aa807b6da25 100644 --- a/source/blender/sequencer/intern/strip_time.h +++ b/source/blender/sequencer/intern/strip_time.h @@ -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, diff --git a/source/blender/sequencer/intern/strip_transform.c b/source/blender/sequencer/intern/strip_transform.c index c2aab84244f..ce5917b999f 100644 --- a/source/blender/sequencer/intern/strip_transform.c +++ b/source/blender/sequencer/intern/strip_transform.c @@ -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]) diff --git a/source/blender/sequencer/intern/utils.c b/source/blender/sequencer/intern/utils.c index 71686065882..cd779b0b0c7 100644 --- a/source/blender/sequencer/intern/utils.c +++ b/source/blender/sequencer/intern/utils.c @@ -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]; -- cgit v1.2.3