VSE: minimal cache invalidation

3 files changed, 61 insertions, 27 deletions

diff --git a/source/blender/blenkernel/BKE_sequencer.h b/source/blender/blenkernel/BKE_sequencer.h
index 170ab657388..807c4a93654 100644
--- a/source/blender/blenkernel/BKE_sequencer.h
+++ b/source/blender/blenkernel/BKE_sequencer.h
@@ -323,7 +323,10 @@ void BKE_sequencer_cache_free_temp_cache(struct Scene *scene, short id, int cfra
 void BKE_sequencer_cache_destruct(struct Scene *scene);
 void BKE_sequencer_cache_cleanup_all(struct Main *bmain);
 void BKE_sequencer_cache_cleanup(struct Scene *scene);
-void BKE_sequencer_cache_cleanup_sequence(struct Scene *scene, struct Sequence *seq);
+void BKE_sequencer_cache_cleanup_sequence(struct Scene *scene,
+                                          struct Sequence *seq,
+                                          struct Sequence *seq_changed,
+                                          int invalidate_types);
 void BKE_sequencer_cache_iterate(
     struct Scene *scene,
     void *userdata,
@@ -391,9 +394,10 @@ struct Sequence *BKE_sequence_dupli_recursive(const struct Scene *scene_src,
 int BKE_sequence_swap(struct Sequence *seq_a, struct Sequence *seq_b, const char **error_str);
 
 bool BKE_sequence_check_depend(struct Sequence *seq, struct Sequence *cur);
-void BKE_sequence_invalidate_cache(struct Scene *scene, struct Sequence *seq);
+void BKE_sequence_invalidate_cache_raw(struct Scene *scene, struct Sequence *seq);
+void BKE_sequence_invalidate_cache_preprocessed(struct Scene *scene, struct Sequence *seq);
+void BKE_sequence_invalidate_cache_composite(struct Scene *scene, struct Sequence *seq);
 void BKE_sequence_invalidate_dependent(struct Scene *scene, struct Sequence *seq);
-void BKE_sequence_invalidate_cache_for_modifier(struct Scene *scene, struct Sequence *seq);
 
 void BKE_sequencer_update_sound_bounds_all(struct Scene *scene);
 void BKE_sequencer_update_sound_bounds(struct Scene *scene, struct Sequence *seq);
diff --git a/source/blender/blenkernel/intern/seqcache.c b/source/blender/blenkernel/intern/seqcache.c
index f77b3e99e30..6f5b5f90d37 100644
--- a/source/blender/blenkernel/intern/seqcache.c
+++ b/source/blender/blenkernel/intern/seqcache.c
@@ -476,7 +476,10 @@ void BKE_sequencer_cache_cleanup(Scene *scene)
   seq_cache_unlock(scene);
 }
 
-void BKE_sequencer_cache_cleanup_sequence(Scene *scene, Sequence *seq)
+void BKE_sequencer_cache_cleanup_sequence(Scene *scene,
+                                          Sequence *seq,
+                                          Sequence *seq_changed,
+                                          int invalidate_types)
 {
   SeqCache *cache = seq_cache_get_from_scene(scene);
   if (!cache) {
@@ -485,14 +488,40 @@ void BKE_sequencer_cache_cleanup_sequence(Scene *scene, Sequence *seq)
 
   seq_cache_lock(scene);
 
+  int range_start = seq_changed->startdisp;
+  int range_end = seq_changed->enddisp;
+
+  if (seq->startdisp > range_start) {
+    range_start = seq->startdisp;
+  }
+
+  if (seq->enddisp < range_end) {
+    range_end = seq->enddisp;
+  }
+
+  int invalidate_composite = invalidate_types & SEQ_CACHE_STORE_FINAL_OUT;
+  int invalidate_source = invalidate_types & (SEQ_CACHE_STORE_RAW | SEQ_CACHE_STORE_PREPROCESSED |
+                                              SEQ_CACHE_STORE_COMPOSITE);
+
   GHashIterator gh_iter;
   BLI_ghashIterator_init(&gh_iter, cache->hash);
   while (!BLI_ghashIterator_done(&gh_iter)) {
     SeqCacheKey *key = BLI_ghashIterator_getKey(&gh_iter);
     BLI_ghashIterator_step(&gh_iter);
 
-    if (key->seq == seq) {
-      /* Relink keys, so we don't end up with orphaned keys */
+    int key_cfra = key->seq->start + key->nfra;
+
+    /* clean all final and composite in intersection of seq and seq_changed */
+    if (key->type & invalidate_composite && key_cfra >= range_start && key_cfra <= range_end) {
+      if (key->link_next || key->link_prev) {
+        seq_cache_relink_keys(key->link_next, key->link_prev);
+      }
+
+      BLI_ghash_remove(cache->hash, key, seq_cache_keyfree, seq_cache_valfree);
+    }
+
+    if (key->type & invalidate_source && key->seq == seq && key_cfra >= seq_changed->startdisp &&
+        key_cfra <= seq_changed->enddisp) {
       if (key->link_next || key->link_prev) {
         seq_cache_relink_keys(key->link_next, key->link_prev);
       }
diff --git a/source/blender/blenkernel/intern/sequencer.c b/source/blender/blenkernel/intern/sequencer.c
index 29e9776407d..d6347f5e84d 100644
--- a/source/blender/blenkernel/intern/sequencer.c
+++ b/source/blender/blenkernel/intern/sequencer.c
@@ -279,7 +279,7 @@ static void BKE_sequence_free_ex(Scene *scene,
    */
   if (do_cache) {
     if (scene) {
-      BKE_sequence_invalidate_cache(scene, seq);
+      BKE_sequence_invalidate_cache_raw(scene, seq);
     }
   }
 
@@ -4307,7 +4307,8 @@ static void sequence_do_invalidate_dependent(Scene *scene, Sequence *seq, ListBa
     }
 
     if (BKE_sequence_check_depend(seq, cur)) {
-      BKE_sequencer_cache_cleanup_sequence(scene, cur);
+      BKE_sequencer_cache_cleanup_sequence(
+          scene, cur, seq, SEQ_CACHE_STORE_COMPOSITE | SEQ_CACHE_STORE_FINAL_OUT);
     }
 
     if (cur->seqbase.first) {
@@ -4319,46 +4320,46 @@ static void sequence_do_invalidate_dependent(Scene *scene, Sequence *seq, ListBa
 static void sequence_invalidate_cache(Scene *scene,
                                       Sequence *seq,
                                       bool invalidate_self,
-                                      bool UNUSED(invalidate_preprocess))
+                                      int invalidate_types)
 {
   Editing *ed = scene->ed;
 
-  /* invalidate cache for current sequence */
   if (invalidate_self) {
-    /* Animation structure holds some buffers inside,
-     * so for proper cache invalidation we need to
-     * re-open the animation.
-     */
     BKE_sequence_free_anim(seq);
-    BKE_sequencer_cache_cleanup_sequence(scene, seq);
+    BKE_sequencer_cache_cleanup_sequence(scene, seq, seq, invalidate_types);
   }
 
-  /* if invalidation is invoked from sequence free routine, effectdata would be NULL here */
   if (seq->effectdata && seq->type == SEQ_TYPE_SPEED) {
     BKE_sequence_effect_speed_rebuild_map(scene, seq, true);
   }
 
-  /* invalidate cache for all dependent sequences */
-
-  /* NOTE: can not use SEQ_BEGIN/SEQ_END here because that macro will change sequence's depth,
-   *       which makes transformation routines work incorrect
-   */
   sequence_do_invalidate_dependent(scene, seq, &ed->seqbase);
 }
 
-void BKE_sequence_invalidate_cache(Scene *scene, Sequence *seq)
+void BKE_sequence_invalidate_cache_raw(Scene *scene, Sequence *seq)
 {
-  sequence_invalidate_cache(scene, seq, true, true);
+  sequence_invalidate_cache(scene, seq, true, SEQ_CACHE_ALL_TYPES);
 }
 
-void BKE_sequence_invalidate_dependent(Scene *scene, Sequence *seq)
+void BKE_sequence_invalidate_cache_preprocessed(Scene *scene, Sequence *seq)
 {
-  sequence_invalidate_cache(scene, seq, false, true);
+  sequence_invalidate_cache(scene,
+                            seq,
+                            true,
+                            SEQ_CACHE_STORE_PREPROCESSED | SEQ_CACHE_STORE_COMPOSITE |
+                                SEQ_CACHE_STORE_FINAL_OUT);
 }
 
-void BKE_sequence_invalidate_cache_for_modifier(Scene *scene, Sequence *seq)
+void BKE_sequence_invalidate_cache_composite(Scene *scene, Sequence *seq)
+{
+  sequence_invalidate_cache(
+      scene, seq, true, SEQ_CACHE_STORE_COMPOSITE | SEQ_CACHE_STORE_FINAL_OUT);
+}
+
+void BKE_sequence_invalidate_dependent(Scene *scene, Sequence *seq)
 {
-  sequence_invalidate_cache(scene, seq, true, false);
+  sequence_invalidate_cache(
+      scene, seq, false, SEQ_CACHE_STORE_COMPOSITE | SEQ_CACHE_STORE_FINAL_OUT);
 }
 
 void BKE_sequencer_free_imbuf(Scene *scene, ListBase *seqbase, bool for_render)