nodes: optimize node graph changes by only updating from inputs that changed

A huge optimization that ensures only the parts of a node graph that have
changed get pushed to the renderer. For thread-safety, the node graph is
copied elsewhere so that users can make changes asynchronously and the graph
can update when its threads are ready. Up until now, if an input value changed,
every node's values would be re-copied, or worse, if a connection was changed,
the entire graph would be recopied. This has been negligible in testing since
we've been largely testing with small graphs, but for massive projects, it's
important that this be as optimized as possible.

app/node/output/track/track.cpp

@@ -38,8 +38,8 @@ TrackOutput::TrackOutput() :
   block_input_ = new NodeInputArray("block_in", NodeParam::kAny);
   block_input_->set_is_keyframable(false);
   AddInput(block_input_);
-  connect(block_input_, &NodeInputArray::EdgeAdded, this, &TrackOutput::BlockConnected);
-  connect(block_input_, &NodeInputArray::EdgeRemoved, this, &TrackOutput::BlockDisconnected);
+  connect(block_input_, &NodeInputArray::SubParamEdgeAdded, this, &TrackOutput::BlockConnected);
+  connect(block_input_, &NodeInputArray::SubParamEdgeRemoved, this, &TrackOutput::BlockDisconnected);
   connect(block_input_, &NodeInputArray::SizeChanged, this, &TrackOutput::BlockListSizeChanged);
 
   muted_input_ = new NodeInput("muted_in", NodeParam::kBoolean);
@@ -236,10 +236,10 @@ const QVector<Block *> &TrackOutput::Blocks() const
   return block_cache_;
 }
 
-void TrackOutput::InvalidateCache(const rational &start_range, const rational &end_range, NodeInput *from)
+void TrackOutput::InvalidateCache(const TimeRange &range, NodeInput *from, NodeInput *source)
 {
   if (block_invalidate_cache_stack_ == 0) {
-    Node::InvalidateCache(qMax(start_range, rational(0)), qMin(end_range, track_length()), from);
+    Node::InvalidateCache(TimeRange(qMax(range.in(), rational(0)), qMin(range.out(), track_length())), from, source);
   }
 }
 
@@ -276,7 +276,7 @@ void TrackOutput::InsertBlockAtIndex(Block *block, int index)
 
   UnblockInvalidateCache();
 
-  InvalidateCache(block->in(), track_length());
+  InvalidateCache(TimeRange(block->in(), track_length()), block_input_, block_input_);
 }
 
 void TrackOutput::AppendBlock(Block *block)
@@ -291,7 +291,7 @@ void TrackOutput::AppendBlock(Block *block)
   UnblockInvalidateCache();
 
   // Invalidate area that block was added to
-  InvalidateCache(block->in(), track_length());
+  InvalidateCache(TimeRange(block->in(), track_length()), block_input_, block_input_);
 }
 
 void TrackOutput::BlockInvalidateCache()
@@ -316,7 +316,7 @@ void TrackOutput::RippleRemoveBlock(Block *block)
 
   UnblockInvalidateCache();
 
-  InvalidateCache(remove_in, track_length());
+  InvalidateCache(TimeRange(remove_in, track_length()), block_input_, block_input_);
 }
 
 void TrackOutput::ReplaceBlock(Block *old, Block *replace)
@@ -334,9 +334,9 @@ void TrackOutput::ReplaceBlock(Block *old, Block *replace)
   UnblockInvalidateCache();
 
   if (old->length() == replace->length()) {
-    InvalidateCache(replace->in(), replace->out());
+    InvalidateCache(TimeRange(replace->in(), replace->out()), block_input_, block_input_);
   } else {
-    InvalidateCache(replace->in(), RATIONAL_MAX);
+    InvalidateCache(TimeRange(replace->in(), RATIONAL_MAX), block_input_, block_input_);
   }
 }
 
@@ -407,6 +407,11 @@ bool TrackOutput::IsLocked() const
   return locked_;
 }
 
+NodeInputArray *TrackOutput::block_input() const
+{
+  return block_input_;
+}
+
 void TrackOutput::SetTrackName(const QString &name)
 {
   track_name_ = name;
@@ -415,7 +420,7 @@ void TrackOutput::SetTrackName(const QString &name)
 void TrackOutput::SetMuted(bool e)
 {
   muted_input_->set_standard_value(e);
-  InvalidateCache(0, track_length());
+  InvalidateCache(TimeRange(0, track_length()), block_input_, block_input_);
 }
 
 void TrackOutput::SetLocked(bool e)
@@ -462,8 +467,9 @@ void TrackOutput::UpdateInOutFrom(int index)
     track_length_ = new_track_length;
     emit TrackLengthChanged();
 
-    InvalidateCache(qMin(old_track_length, new_track_length),
-                    qMax(old_track_length, new_track_length));
+    InvalidateCache(TimeRange(qMin(old_track_length, new_track_length), qMax(old_track_length, new_track_length)),
+                    block_input_,
+                    block_input_);
   }
 }
 

app/node/output/track/track.h

@@ -84,7 +84,7 @@ public:
 
   const QVector<Block*>& Blocks() const;
 
-  virtual void InvalidateCache(const rational& start_range, const rational& end_range, NodeInput* from = nullptr) override;
+  virtual void InvalidateCache(const TimeRange& range, NodeInput* from, NodeInput *source) override;
 
   /**
    * @brief Adds Block `block` at the very beginning of the Sequence before all other clips
@@ -150,6 +150,8 @@ public:
 
   bool IsLocked() const;
 
+  NodeInputArray* block_input() const;
+
 public slots:
   void SetTrackName(const QString& name);
 

app/node/output/track/tracklist.cpp

@@ -31,8 +31,8 @@ TrackList::TrackList(ViewerOutput *parent, const Timeline::TrackType &type, Node
   track_input_(track_input),
   type_(type)
 {
-  connect(track_input, &NodeInputArray::EdgeAdded, this, &TrackList::TrackConnected);
-  connect(track_input, &NodeInputArray::EdgeRemoved, this, &TrackList::TrackDisconnected);
+  connect(track_input, &NodeInputArray::SubParamEdgeAdded, this, &TrackList::TrackConnected);
+  connect(track_input, &NodeInputArray::SubParamEdgeRemoved, this, &TrackList::TrackDisconnected);
   connect(track_input, &NodeInputArray::SizeChanged, this, &TrackList::TrackListSizeChanged);
 }
 
@@ -120,8 +120,8 @@ TrackOutput* TrackList::AddTrack()
             Node* blend = NodeFactory::CreateFromID(QStringLiteral("org.olivevideoeditor.Olive.alphaoverblend"));
             GetParentGraph()->AddNode(blend);
 
-            NodeParam::ConnectEdge(track->output(), static_cast<NodeInput*>(blend->GetParameterWithID("blend_in")));
-            NodeParam::ConnectEdge(last_track->output(), static_cast<NodeInput*>(blend->GetParameterWithID("base_in")));
+            NodeParam::ConnectEdge(track->output(), static_cast<NodeInput*>(blend->GetInputWithID("blend_in")));
+            NodeParam::ConnectEdge(last_track->output(), static_cast<NodeInput*>(blend->GetInputWithID("base_in")));
             NodeParam::ConnectEdge(blend->output(), edge->input());
             break;
           }

app/node/output/viewer/viewer.cpp

@@ -92,26 +92,24 @@ NodeInput *ViewerOutput::samples_input() const
   return samples_input_;
 }
 
-void ViewerOutput::InvalidateCache(const rational &start_range, const rational &end_range, NodeInput *from)
+void ViewerOutput::InvalidateCache(const TimeRange &range, NodeInput *from, NodeInput *source)
 {
-  Node::InvalidateCache(start_range, end_range, from);
-
   if (from == texture_input()) {
-    emit VideoChangedBetween(TimeRange(start_range, end_range));
+    emit VideoChangedBetween(range, source);
   } else if (from == samples_input()) {
-    emit AudioChangedBetween(TimeRange(start_range, end_range));
+    emit AudioChangedBetween(range, source);
   }
 
-  SendInvalidateCache(start_range, end_range);
+  Node::InvalidateCache(range, from, source);
 }
 
-void ViewerOutput::InvalidateVisible(NodeInput* from)
+void ViewerOutput::InvalidateVisible(NodeInput* from, NodeInput *source)
 {
   if (from == texture_input()) {
-    emit VisibleInvalidated();
+    emit VisibleInvalidated(source);
   }
 
-  Node::InvalidateVisible(from);
+  Node::InvalidateVisible(from, source);
 }
 
 const VideoParams &ViewerOutput::video_params() const
@@ -164,17 +162,6 @@ const QUuid &ViewerOutput::uuid() const
   return uuid_;
 }
 
-void ViewerOutput::DependentEdgeChanged(NodeInput *from)
-{
-  if (from == texture_input_) {
-    emit VideoGraphChanged();
-  } else if (from == samples_input_) {
-    emit AudioGraphChanged();
-  }
-
-  Node::DependentEdgeChanged(from);
-}
-
 void ViewerOutput::UpdateTrackCache()
 {
   track_cache_.clear();

app/node/output/viewer/viewer.h

@@ -55,8 +55,8 @@ public:
   NodeInput* texture_input() const;
   NodeInput* samples_input() const;
 
-  virtual void InvalidateCache(const rational &start_range, const rational &end_range, NodeInput *from = nullptr) override;
-  virtual void InvalidateVisible(NodeInput *from) override;
+  virtual void InvalidateCache(const TimeRange &range, NodeInput *from, NodeInput* source) override;
+  virtual void InvalidateVisible(NodeInput *from, NodeInput* source) override;
 
   const VideoParams& video_params() const;
   const AudioParams& audio_params() const;
@@ -79,21 +79,14 @@ public:
   const QString& media_name() const;
   void set_media_name(const QString& name);
 
-protected:
-  virtual void DependentEdgeChanged(NodeInput* from) override;
-
 signals:
   void TimebaseChanged(const rational&);
 
-  void VideoChangedBetween(const TimeRange& range);
+  void VideoChangedBetween(const TimeRange& range, NodeInput* source);
 
-  void AudioChangedBetween(const TimeRange& range);
+  void AudioChangedBetween(const TimeRange& range, NodeInput* source);
 
-  void VisibleInvalidated();
-
-  void VideoGraphChanged();
-
-  void AudioGraphChanged();
+  void VisibleInvalidated(NodeInput* source);
 
   void LengthChanged(const rational& length);