minor adjustments to render threads

app/node/processor/renderer/renderer.cpp

@@ -26,7 +26,6 @@
 #include <QDateTime>
 #include <QDebug>
 #include <QDir>
-#include <QImage>
 #include <QtMath>
 
 #include "common/filefunctions.h"
@@ -76,7 +75,6 @@ void RendererProcessor::SetCacheName(const QString &s)
   GenerateCacheIDInternal();
 }
 
-#include <QFileInfo>
 QVariant RendererProcessor::Value(NodeOutput* output, const rational& time)
 {
   if (output == texture_output_) {
@@ -199,7 +197,7 @@ void RendererProcessor::Start()
 
   QOpenGLContext* ctx = QOpenGLContext::currentContext();
 
-  int background_thread_count = qMax(1, QThread::idealThreadCount() - 1);
+  int background_thread_count = QThread::idealThreadCount();
 
   threads_.resize(background_thread_count);
 
@@ -240,16 +238,16 @@ void RendererProcessor::Stop()
 
   started_ = false;
 
-  foreach (RendererProcessThreadPtr process_thread, threads_) {
-    process_thread->Cancel();
-  }
-  threads_.clear();
-
   foreach (RendererDownloadThreadPtr download_thread_, download_threads_) {
     download_thread_->Cancel();
   }
   download_threads_.clear();
 
+  foreach (RendererProcessThreadPtr process_thread, threads_) {
+    process_thread->Cancel();
+  }
+  threads_.clear();
+
   master_texture_ = nullptr;
 
   cache_frame_load_buffer_.clear();
@@ -265,9 +263,10 @@ void RendererProcessor::GenerateCacheIDInternal()
   QCryptographicHash hash(QCryptographicHash::Sha1);
   hash.addData(cache_name_.toUtf8());
   hash.addData(QString::number(cache_time_).toUtf8());
-  hash.addData(QString::number(effective_width_).toUtf8());
-  hash.addData(QString::number(effective_height_).toUtf8());
+  hash.addData(QString::number(width_).toUtf8());
+  hash.addData(QString::number(height_).toUtf8());
   hash.addData(QString::number(format_).toUtf8());
+  hash.addData(QString::number(divider_).toUtf8());
 
   QByteArray bytes = hash.result();
   cache_id_ = bytes.toHex();
@@ -286,7 +285,6 @@ void RendererProcessor::CacheNext()
 
   qDebug() << "[RendererProcessor] Caching" << cache_frame_.toDouble();
 
-  // Run this probe in another thread
   master_thread_ = threads_.at(0).get();
   master_thread_->Queue(NodeDependency(texture_input_->get_connected_output(), cache_frame_), true);
 
@@ -315,15 +313,14 @@ void RendererProcessor::ThreadCallback()
     // Threads are all done now, time to proceed
     caching_ = false;
 
-    // FIXME: Save the texture results here
     RenderTexturePtr texture = texture_input_->get_value(cache_frame_).value<RenderTexturePtr>();
 
-
     QString fn = CachePathName(cache_frame_);
-    if (texture == nullptr && QFileInfo::exists(fn)) {
-      QFile(fn).remove();
+    if (texture == nullptr) {
+      if (QFileInfo::exists(fn)) {
+        QFile(fn).remove();
+      }
     } else {
-      // Choose download thread with the smallest queue
       download_threads_[last_download_thread_%download_threads_.size()]->Queue(texture, fn);
       last_download_thread_++;
     }

app/node/processor/renderer/rendererdownloadthread.cpp

@@ -1,6 +1,7 @@
 #include "rendererdownloadthread.h"
 
 #include <QFile>
+#include <QFloat16>
 #include <OpenImageIO/imageio.h>
 
 #include "common/define.h"
@@ -13,7 +14,6 @@ RendererDownloadThread::RendererDownloadThread(QOpenGLContext *share_ctx,
                                                const olive::RenderMode &mode) :
   RendererThreadBase(share_ctx, width, height, format, mode)
 {
-
 }
 
 void RendererDownloadThread::Queue(RenderTexturePtr texture, const QString& fn)
@@ -42,68 +42,62 @@ void RendererDownloadThread::ProcessLoop()
                                                 render_instance()->width(),
                                                 render_instance()->height());
 
-  uchar* data_buffer = new uchar[buffer_size];
+  QVector<uchar> data_buffer;
+  data_buffer.resize(buffer_size);
+
+  PixelFormatInfo format_info = PixelService::GetPixelFormatInfo(render_instance()->format());
+
+  // Set up OIIO::ImageSpec for compressing cached images on disk
+  OIIO::ImageSpec spec(render_instance()->width(), render_instance()->height(), kRGBAChannels, format_info.oiio_desc);
+  spec.attribute("compression", "dwaa:200");
 
   while (!Cancelled()) {
     // Check queue for textures to download (use mutex to prevent collisions)
     texture_queue_lock_.lock();
 
-    do {
-      if (texture_queue_.isEmpty()) {
-        working_texture = nullptr;
-      } else {
-        working_texture = texture_queue_.takeFirst();
-        working_filename = download_filenames_.takeFirst();
-      }
+    while (texture_queue_.isEmpty()) {
+      // Main waiting condition
+      wait_cond_.wait(&texture_queue_lock_);
+    }
 
-      if (working_texture == nullptr) {
-        // Main waiting condition
-        wait_cond_.wait(&texture_queue_lock_);
-      }
-    } while (working_texture == nullptr);
+    working_texture = texture_queue_.takeFirst();
+    working_filename = download_filenames_.takeFirst();
 
     texture_queue_lock_.unlock();
 
     // Download the texture
-    f->glBindFramebuffer(GL_READ_FRAMEBUFFER, read_buffer_);
 
-    xf->glFramebufferTexture2D(GL_READ_FRAMEBUFFER,
+    f->glBindFramebuffer(GL_FRAMEBUFFER, read_buffer_);
+
+    xf->glFramebufferTexture2D(GL_FRAMEBUFFER,
                                GL_COLOR_ATTACHMENT0,
                                GL_TEXTURE_2D,
                                working_texture->texture(),
                                0);
 
-    PixelFormatInfo format_info = PixelService::GetPixelFormatInfo(working_texture->format());
-
     f->glReadPixels(0,
                     0,
                     working_texture->width(),
                     working_texture->height(),
                     format_info.pixel_format,
                     format_info.pixel_type,
-                    data_buffer);
+                    data_buffer.data());
 
-    xf->glFramebufferTexture2D(GL_READ_FRAMEBUFFER,
+    xf->glFramebufferTexture2D(GL_FRAMEBUFFER,
                                GL_COLOR_ATTACHMENT0,
                                GL_TEXTURE_2D,
                                0,
                                0);
 
-    f->glBindFramebuffer(GL_READ_FRAMEBUFFER, 0);
+    f->glBindFramebuffer(GL_FRAMEBUFFER, 0);
 
     std::string working_fn_std = working_filename.toStdString();
 
     std::unique_ptr<OIIO::ImageOutput> out = OIIO::ImageOutput::create(working_fn_std);
 
     if (out) {
-      OIIO::ImageSpec spec(working_texture->width(), working_texture->height(), kRGBAChannels, format_info.oiio_desc);
-
-      spec.attribute("compression", "dwaa:200");
-
       out->open(working_fn_std, spec);
-
-      out->write_image(format_info.oiio_desc, data_buffer);
-
+      out->write_image(format_info.oiio_desc, data_buffer.data());
       out->close();
     }
 
@@ -111,7 +105,5 @@ void RendererDownloadThread::ProcessLoop()
 
   }
 
-  delete [] data_buffer;
-
   f->glDeleteFramebuffers(1, &read_buffer_);
 }