fixed signal/slot connections which had been renamed and weren't resolving

app/core.cpp

@@ -319,6 +319,7 @@ void Core::DeclareTypesForQt()
   qRegisterMetaType<NodeDependency>();
   qRegisterMetaType<rational>();
   qRegisterMetaType<OpenGLTexturePtr>();
+  qRegisterMetaType<NodeValueTable>();
 }
 
 void Core::StartGUI(bool full_screen)

app/node/output/viewer/viewer.cpp

@@ -116,7 +116,13 @@ void ViewerOutput::set_audio_params(const AudioParams &audio)
 rational ViewerOutput::Length()
 {
   // FIXME: This is pretty messy, there's probably a better way...
-  return length_input_->get_connected_node()->Value(NodeValueDatabase()).Get(NodeParam::kRational).value<rational>();
+  Node* connected_node = length_input_->get_connected_node();
+
+  if (connected_node) {
+    return connected_node->Value(NodeValueDatabase()).Get(NodeParam::kNumber).value<rational>();
+  }
+
+  return 0;
 }
 
 void ViewerOutput::DependentEdgeChanged(NodeInput *from)
@@ -127,7 +133,5 @@ void ViewerOutput::DependentEdgeChanged(NodeInput *from)
     emit AudioGraphChanged();
   }
 
-  // NOTE: This node technically has no outputs so default behavior is unnecessary, but if this node gets outputs some
-  //       day this should be uncommented
-  //Node::DependentEdgeChanged(from);
+  Node::DependentEdgeChanged(from);
 }

app/node/value.h

@@ -64,4 +64,6 @@ private:
 
 };
 
+Q_DECLARE_METATYPE(NodeValueTable)
+
 #endif // VALUE_H

app/render/backend/audio/audiobackend.cpp

@@ -62,14 +62,14 @@ void AudioBackend::DecompileInternal()
 
 void AudioBackend::ConnectWorkerToThis(RenderWorker *worker)
 {
-  connect(worker, SIGNAL(CompletedCache(NodeDependency, QVariant)), this, SLOT(ThreadCompletedCache(NodeDependency, QVariant)));
+  connect(worker, SIGNAL(CompletedCache(NodeDependency, NodeValueTable)), this, SLOT(ThreadCompletedCache(NodeDependency, NodeValueTable)));
 }
 
-void AudioBackend::ThreadCompletedCache(NodeDependency dep, QVariant data)
+void AudioBackend::ThreadCompletedCache(NodeDependency dep, NodeValueTable data)
 {
   caching_ = false;
 
-  QByteArray cached_samples = data.toByteArray();
+  QByteArray cached_samples = data.Get(NodeParam::kSamples).toByteArray();
 
   int offset = params().time_to_bytes(dep.in());
   int length = params().time_to_bytes(dep.range().length());

app/render/backend/audio/audiobackend.h

@@ -30,7 +30,7 @@ protected:
   virtual void ConnectWorkerToThis(RenderWorker* worker) override;
 
 private slots:
-  void ThreadCompletedCache(NodeDependency dep, QVariant data);
+  void ThreadCompletedCache(NodeDependency dep, NodeValueTable data);
 
 private:
   QFile pull_device_;

app/render/backend/audio/audioworker.cpp

@@ -5,7 +5,7 @@ AudioWorker::AudioWorker(DecoderCache *decoder_cache, QObject *parent) :
 {
 }
 
-QVariant AudioWorker::FrameToValue(FramePtr frame)
+void AudioWorker::FrameToValue(FramePtr frame, NodeValueTable *table)
 {
-  return frame->ToByteArray();
+  table->Push(NodeParam::kSamples, frame->ToByteArray());
 }

app/render/backend/audio/audioworker.h

@@ -9,7 +9,7 @@ public:
   AudioWorker(DecoderCache* decoder_cache, QObject* parent = nullptr);
 
 protected:
-  virtual QVariant FrameToValue(FramePtr frame) override;
+  virtual void FrameToValue(FramePtr frame, NodeValueTable* table) override;
 
 private:
 

app/render/backend/opengl/openglbackend.cpp

@@ -140,13 +140,14 @@ bool OpenGLBackend::TimeIsCached(const TimeRange &time)
   return cache_queue_.contains(time);
 }
 
-void OpenGLBackend::ThreadCompletedFrame(NodeDependency path, QByteArray hash, QVariant value)
+void OpenGLBackend::ThreadCompletedFrame(NodeDependency path, QByteArray hash, NodeValueTable table)
 {
   caching_ = false;
 
+  QVariant value = table.Get(NodeParam::kTexture);
   OpenGLTexturePtr texture = value.value<OpenGLTexturePtr>();
 
-  if (texture == nullptr) {
+  if (!texture) {
     // No frame received, we set hash to an empty
     frame_cache()->RemoveHash(path.in(), hash);
   } else {

app/render/backend/opengl/openglbackend.h

@@ -40,7 +40,7 @@ private:
   OpenGLShaderCache shader_cache_;
 
 private slots:
-  void ThreadCompletedFrame(NodeDependency path, QByteArray hash, QVariant value);
+  void ThreadCompletedFrame(NodeDependency path, QByteArray hash, NodeValueTable table);
   void ThreadCompletedDownload(NodeDependency dep, QByteArray hash);
   void ThreadSkippedFrame();
   void ThreadHashAlreadyExists(NodeDependency dep, QByteArray hash);

app/render/backend/opengl/openglworker.cpp

@@ -47,7 +47,7 @@ bool OpenGLWorker::InitInternal()
   return true;
 }
 
-QVariant OpenGLWorker::FrameToValue(FramePtr frame)
+void OpenGLWorker::FrameToValue(FramePtr frame, NodeValueTable *table)
 {
   OpenGLTexturePtr footage_tex = std::make_shared<OpenGLTexture>();
   footage_tex->Create(ctx_, frame);
@@ -60,7 +60,7 @@ QVariant OpenGLWorker::FrameToValue(FramePtr frame)
 
   // FIXME: Alpha association and color management
 
-  return QVariant::fromValue(footage_tex);
+  table->Push(NodeParam::kTexture, QVariant::fromValue(footage_tex));
 }
 
 void OpenGLWorker::CloseInternal()

app/render/backend/opengl/openglworker.h

@@ -45,7 +45,7 @@ protected:
 
   virtual void CloseInternal() override;
 
-  virtual QVariant FrameToValue(FramePtr frame) override;
+  virtual void FrameToValue(FramePtr frame, NodeValueTable* table) override;
 
   virtual void RunNodeAccelerated(Node *node, const NodeValueDatabase *input_params, NodeValueTable* output_params) override;
 

app/render/backend/renderworker.cpp

@@ -144,6 +144,19 @@ NodeValueTable RenderWorker::ProcessNodeNormally(const NodeDependency& dep)
         table.Push(input->data_type(), input_value);
       }
 
+      // Exception for Footage types where we actually retrieve some Footage data from a decoder
+      if (input->data_type() == NodeParam::kFootage) {
+        DecoderPtr decoder = ResolveDecoderFromInput(input);
+
+        if (decoder) {
+          FramePtr frame = RetrieveFromDecoder(decoder, input_time);
+
+          if (frame) {
+            FrameToValue(frame, &table);
+          }
+        }
+      }
+
       database.Insert(input, table);
     }
   }

app/render/backend/renderworker.h

@@ -50,7 +50,7 @@ protected:
 
   virtual FramePtr RetrieveFromDecoder(DecoderPtr decoder, const TimeRange& range) = 0;
 
-  virtual QVariant FrameToValue(FramePtr frame) = 0;
+  virtual void FrameToValue(FramePtr frame, NodeValueTable* table) = 0;
 
   NodeValueTable ProcessNodeNormally(const NodeDependency &dep);
 

app/render/backend/videorenderbackend.cpp

@@ -174,7 +174,7 @@ void VideoRenderBackend::CacheIDChangedEvent(const QString &id)
 
 void VideoRenderBackend::ConnectWorkerToThis(RenderWorker *processor)
 {
-  connect(processor, SIGNAL(CompletedFrame(NodeDependency, QByteArray, QVariant)), this, SLOT(ThreadCompletedFrame(NodeDependency, QByteArray, QVariant)));
+  connect(processor, SIGNAL(CompletedFrame(NodeDependency, QByteArray, NodeValueTable)), this, SLOT(ThreadCompletedFrame(NodeDependency, QByteArray, NodeValueTable)));
   connect(processor, SIGNAL(HashAlreadyBeingCached()), this, SLOT(ThreadSkippedFrame()));
   connect(processor, SIGNAL(CompletedDownload(NodeDependency, QByteArray)), this, SLOT(ThreadCompletedDownload(NodeDependency, QByteArray)));
   connect(processor, SIGNAL(HashAlreadyExists(NodeDependency, QByteArray)), this, SLOT(ThreadHashAlreadyExists(NodeDependency, QByteArray)));