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

Ref T92709

32 files changed, 506 insertions, 448 deletions

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