renderer: use a dedicated decoder per thread

app/render/backend/audio/audiobackend.cpp

@@ -46,7 +46,7 @@ bool AudioBackend::InitInternal()
   // Initiate one thread per CPU core
   for (int i=0;i<threads().size();i++) {
     // Create one processor object for each thread
-    AudioWorker* processor = new AudioWorker(decoder_cache(), &copy_map_);
+    AudioWorker* processor = new AudioWorker(&copy_map_);
     processor->SetParameters(params());
     processors_.append(processor);
   }

app/render/backend/audio/audioworker.cpp

@@ -22,8 +22,8 @@
 
 OLIVE_NAMESPACE_ENTER
 
-AudioWorker::AudioWorker(DecoderCache* decoder_cache, QHash<Node *, Node *> *copy_map, QObject *parent) :
-  AudioRenderWorker(decoder_cache, copy_map, parent)
+AudioWorker::AudioWorker(QHash<Node *, Node *> *copy_map, QObject *parent) :
+  AudioRenderWorker(copy_map, parent)
 {
 }
 

app/render/backend/audio/audioworker.h

@@ -28,7 +28,7 @@ OLIVE_NAMESPACE_ENTER
 class AudioWorker : public AudioRenderWorker
 {
 public:
-  AudioWorker(DecoderCache* decoder_cache, QHash<Node*, Node*>* copy_map, QObject* parent = nullptr);
+  AudioWorker(QHash<Node*, Node*>* copy_map, QObject* parent = nullptr);
 
 protected:
   virtual void FrameToValue(DecoderPtr decoder, StreamPtr stream, const TimeRange &range, NodeValueTable* table) override;

app/render/backend/audiorenderworker.cpp

@@ -30,8 +30,8 @@
 
 OLIVE_NAMESPACE_ENTER
 
-AudioRenderWorker::AudioRenderWorker(DecoderCache* decoder_cache, QHash<Node *, Node *> *copy_map, QObject *parent) :
-  RenderWorker(decoder_cache, parent),
+AudioRenderWorker::AudioRenderWorker(QHash<Node *, Node *> *copy_map, QObject *parent) :
+  RenderWorker(parent),
   copy_map_(copy_map)
 {
 }

app/render/backend/audiorenderworker.h

@@ -29,7 +29,7 @@ class AudioRenderWorker : public RenderWorker
 {
   Q_OBJECT
 public:
-  AudioRenderWorker(DecoderCache* decoder_cache, QHash<Node*, Node*>* copy_map, QObject* parent = nullptr);
+  AudioRenderWorker(QHash<Node*, Node*>* copy_map, QObject* parent = nullptr);
 
   void SetParameters(const AudioRenderingParams& audio_params);
 

app/render/backend/opengl/openglbackend.cpp

@@ -63,7 +63,7 @@ bool OpenGLBackend::InitInternal()
   // Initiate one thread per CPU core
   for (int i=0;i<threads().size();i++) {
     // Create one processor object for each thread
-    OpenGLWorker* processor = new OpenGLWorker(frame_cache(), decoder_cache());
+    OpenGLWorker* processor = new OpenGLWorker(frame_cache());
     processor->SetParameters(params());
     processors_.append(processor);
 

app/render/backend/opengl/openglworker.cpp

@@ -31,8 +31,8 @@
 
 OLIVE_NAMESPACE_ENTER
 
-OpenGLWorker::OpenGLWorker(VideoRenderFrameCache *frame_cache, DecoderCache* decoder_cache, QObject *parent) :
-  VideoRenderWorker(frame_cache, decoder_cache, parent)
+OpenGLWorker::OpenGLWorker(VideoRenderFrameCache *frame_cache, QObject *parent) :
+  VideoRenderWorker(frame_cache, parent)
 {
 }
 

app/render/backend/opengl/openglworker.h

@@ -34,7 +34,7 @@ OLIVE_NAMESPACE_ENTER
 class OpenGLWorker : public VideoRenderWorker {
   Q_OBJECT
 public:
-  OpenGLWorker(VideoRenderFrameCache* frame_cache, DecoderCache *decoder_cache,
+  OpenGLWorker(VideoRenderFrameCache* frame_cache,
                QObject* parent = nullptr);
 
 signals:

app/render/backend/renderbackend.cpp

@@ -105,8 +105,6 @@ void RenderBackend::Close()
 
   threads_.clear();
   processors_.clear();
-
-  decoder_cache_.Clear();
 }
 
 const QString &RenderBackend::GetError() const
@@ -404,11 +402,6 @@ void RenderBackend::SetWorkerBusyState(RenderWorker *worker, bool busy)
   processor_busy_state_.replace(processors_.indexOf(worker), busy);
 }
 
-DecoderCache *RenderBackend::decoder_cache()
-{
-  return &decoder_cache_;
-}
-
 bool RenderBackend::AllProcessorsAreAvailable() const
 {
   foreach (bool busy, processor_busy_state_) {

app/render/backend/renderbackend.h

@@ -118,14 +118,10 @@ protected:
   bool WorkerIsBusy(RenderWorker* worker) const;
   void SetWorkerBusyState(RenderWorker* worker, bool busy);
 
-  DecoderCache* decoder_cache();
-
   TimeRangeList cache_queue_;
 
   QVector<RenderWorker*> processors_;
 
-  DecoderCache decoder_cache_;
-
   bool compiled_;
 
   QHash<TimeRange, qint64> render_job_info_;

app/render/backend/renderworker.cpp

@@ -26,10 +26,9 @@
 
 OLIVE_NAMESPACE_ENTER
 
-RenderWorker::RenderWorker(DecoderCache *decoder_cache, QObject *parent) :
+RenderWorker::RenderWorker(QObject *parent) :
   QObject(parent),
-  started_(false),
-  decoder_cache_(decoder_cache)
+  started_(false)
 {
 }
 
@@ -50,6 +49,8 @@ void RenderWorker::Close()
 {
   CloseInternal();
 
+  decoder_cache_.Clear();
+
   started_ = false;
 }
 
@@ -82,11 +83,9 @@ StreamPtr RenderWorker::ResolveStreamFromInput(NodeInput *input)
 
 DecoderPtr RenderWorker::ResolveDecoderFromInput(StreamPtr stream)
 {
-  QMutexLocker locker(decoder_cache_->lock());
-
   // Access a map of Node inputs and decoder instances and retrieve a frame!
 
-  DecoderPtr decoder = decoder_cache_->Get(stream.get());
+  DecoderPtr decoder = decoder_cache_.Get(stream.get());
 
   if (!decoder && stream) {
     // Create a new Decoder here
@@ -94,7 +93,7 @@ DecoderPtr RenderWorker::ResolveDecoderFromInput(StreamPtr stream)
     decoder->set_stream(stream);
 
     if (decoder->Open()) {
-      decoder_cache_->Add(stream.get(), decoder);
+      decoder_cache_.Add(stream.get(), decoder);
     } else {
       decoder = nullptr;
       qWarning() << "Failed to open decoder for" << stream->footage()->filename() << "::" << stream->index();

app/render/backend/renderworker.h

@@ -35,7 +35,7 @@ class RenderWorker : public QObject, public NodeTraverser
 {
   Q_OBJECT
 public:
-  RenderWorker(DecoderCache* decoder_cache, QObject* parent = nullptr);
+  RenderWorker(QObject* parent = nullptr);
 
   bool Init();
 
@@ -77,7 +77,7 @@ protected:
 private:
   bool started_;
 
-  DecoderCache* decoder_cache_;
+  DecoderCache decoder_cache_;
 
   NodeDependency path_;
 

app/render/backend/videorenderworker.cpp

@@ -34,8 +34,8 @@
 
 OLIVE_NAMESPACE_ENTER
 
-VideoRenderWorker::VideoRenderWorker(VideoRenderFrameCache *frame_cache, DecoderCache* decoder_cache, QObject *parent) :
-  RenderWorker(decoder_cache, parent),
+VideoRenderWorker::VideoRenderWorker(VideoRenderFrameCache *frame_cache, QObject *parent) :
+  RenderWorker(parent),
   frame_cache_(frame_cache),
   operating_mode_(kHashRenderCache)
 {

app/render/backend/videorenderworker.h

@@ -63,7 +63,7 @@ public:
     kHashRenderCache = 0x7
   };
 
-  VideoRenderWorker(VideoRenderFrameCache* frame_cache, DecoderCache *decoder_cache, QObject* parent = nullptr);
+  VideoRenderWorker(VideoRenderFrameCache* frame_cache, QObject* parent = nullptr);
 
   void SetParameters(const VideoRenderingParams& video_params);