renderers: add early functions for cancelling long render processes

app/render/backend/audiorenderworker.cpp

@@ -23,9 +23,9 @@ void AudioRenderWorker::CloseInternal()
   // Nothing to init yet
 }
 
-FramePtr AudioRenderWorker::RetrieveFromDecoder(DecoderPtr decoder, const TimeRange &range)
+FramePtr AudioRenderWorker::RetrieveFromDecoder(DecoderPtr decoder, const TimeRange &range, const QAtomicInt *cancelled)
 {
-  return decoder->RetrieveAudio(range.in(), range.out() - range.in(), audio_params_);
+  return decoder->RetrieveAudio(range.in(), range.out() - range.in(), audio_params_, cancelled);
 }
 
 NodeValueTable AudioRenderWorker::RenderBlock(const TrackOutput *track, const TimeRange &range)

app/render/backend/audiorenderworker.h

@@ -16,7 +16,7 @@ protected:
 
   virtual void CloseInternal() override;
 
-  virtual FramePtr RetrieveFromDecoder(DecoderPtr decoder, const TimeRange& range) override;
+  virtual FramePtr RetrieveFromDecoder(DecoderPtr decoder, const TimeRange& range, const QAtomicInt* cancelled) override;
 
   virtual NodeValueTable RenderBlock(const TrackOutput *track, const TimeRange& range) override;
 

app/render/backend/renderworker.cpp

@@ -122,6 +122,10 @@ NodeValueDatabase RenderWorker::GenerateDatabase(const Node* node, const TimeRan
 
   // We need to insert tables into the database for each input
   foreach (NodeParam* param, node->parameters()) {
+    if (IsCancelled()) {
+      return NodeValueDatabase();
+    }
+
     if (param->type() == NodeParam::kInput) {
       NodeInput* input = static_cast<NodeInput*>(param);
       TimeRange input_time = node->InputTimeAdjustment(input, range);
@@ -136,7 +140,7 @@ NodeValueDatabase RenderWorker::GenerateDatabase(const Node* node, const TimeRan
           DecoderPtr decoder = ResolveDecoderFromInput(stream);
 
           if (decoder) {
-            FramePtr frame = RetrieveFromDecoder(decoder, input_time);
+            FramePtr frame = RetrieveFromDecoder(decoder, input_time, &IsCancelled());
 
             if (frame) {
               FrameToValue(stream, frame, &table);

app/render/backend/renderworker.h

@@ -3,12 +3,13 @@
 
 #include <QObject>
 
+#include "common/cancelableobject.h"
 #include "common/constructors.h"
 #include "node/output/track/track.h"
 #include "node/node.h"
 #include "decodercache.h"
 
-class RenderWorker : public QObject
+class RenderWorker : public QObject, public CancelableObject
 {
   Q_OBJECT
 public:
@@ -40,7 +41,7 @@ protected:
   StreamPtr ResolveStreamFromInput(NodeInput* input);
   DecoderPtr ResolveDecoderFromInput(StreamPtr stream);
 
-  virtual FramePtr RetrieveFromDecoder(DecoderPtr decoder, const TimeRange& range) = 0;
+  virtual FramePtr RetrieveFromDecoder(DecoderPtr decoder, const TimeRange& range, const QAtomicInt* cancelled) = 0;
 
   virtual void FrameToValue(StreamPtr stream, FramePtr frame, NodeValueTable* table) = 0;
 

app/render/backend/videorenderworker.cpp

@@ -38,7 +38,7 @@ NodeValueTable VideoRenderWorker::RenderInternal(const NodeDependency& path, con
     hasher.addData(reinterpret_cast<const char*>(&vfmt), sizeof(PixelFormat::Format));
     hasher.addData(reinterpret_cast<const char*>(&vmode), sizeof(RenderMode::Mode));
 
-    HashNodeRecursively(&hasher, path.node(), path.in());
+    HashNodeRecursively(&hasher, path.node(), path.in(), &IsCancelled());
     hash = hasher.result();
   }
 
@@ -87,12 +87,12 @@ NodeValueTable VideoRenderWorker::RenderInternal(const NodeDependency& path, con
   return value;
 }
 
-FramePtr VideoRenderWorker::RetrieveFromDecoder(DecoderPtr decoder, const TimeRange &range)
+FramePtr VideoRenderWorker::RetrieveFromDecoder(DecoderPtr decoder, const TimeRange &range, const QAtomicInt* cancelled)
 {
-  return decoder->RetrieveVideo(range.in());
+  return decoder->RetrieveVideo(range.in(), cancelled);
 }
 
-void VideoRenderWorker::HashNodeRecursively(QCryptographicHash *hash, const Node* n, const rational& time)
+void VideoRenderWorker::HashNodeRecursively(QCryptographicHash *hash, const Node* n, const rational& time, const QAtomicInt* cancelled)
 {
   // Resolve BlockList
   if (n->IsTrack()) {
@@ -140,7 +140,7 @@ void VideoRenderWorker::HashNodeRecursively(QCryptographicHash *hash, const Node
 
       if (input->IsConnected()) {
         // Traverse down this edge
-        HashNodeRecursively(hash, input->get_connected_node(), input_time);
+        HashNodeRecursively(hash, input->get_connected_node(), input_time, cancelled);
       } else {
         // Grab the value at this time
         QVariant value = input->get_value_at_time(input_time);
@@ -168,7 +168,7 @@ void VideoRenderWorker::HashNodeRecursively(QCryptographicHash *hash, const Node
             ImageStreamPtr video_stream = std::static_pointer_cast<ImageStream>(stream);
 
             // Footage timestamp
-            hash->addData(QString::number(decoder->GetTimestampFromTime(input_time)).toUtf8());
+            hash->addData(QString::number(decoder->GetTimestampFromTime(input_time, cancelled)).toUtf8());
 
             // Current color config and space
             hash->addData(video_stream->footage()->project()->ocio_config().toUtf8());

app/render/backend/videorenderworker.h

@@ -56,6 +56,8 @@ signals:
 
   void HashAlreadyExists(NodeDependency path, qint64 job_time, QByteArray hash);
 
+  void Aborted();
+
 protected:
   virtual bool InitInternal() override;
 
@@ -69,14 +71,14 @@ protected:
 
   virtual NodeValueTable RenderInternal(const NodeDependency& path, const qint64& job_time) override;
 
-  virtual FramePtr RetrieveFromDecoder(DecoderPtr decoder, const TimeRange& range) override;
+  virtual FramePtr RetrieveFromDecoder(DecoderPtr decoder, const TimeRange& range, const QAtomicInt *cancelled) override;
 
   virtual NodeValueTable RenderBlock(const TrackOutput *track, const TimeRange& range) override;
 
   ColorProcessorCache* color_cache();
 
 private:
-  void HashNodeRecursively(QCryptographicHash* hash, const Node *n, const rational &time);
+  void HashNodeRecursively(QCryptographicHash* hash, const Node *n, const rational &time, const QAtomicInt *cancelled);
 
   void Download(QVariant texture, QString filename);