render: create less textures

app/render/renderer.cpp

@@ -20,36 +20,54 @@
 
 #include "renderer.h"
 
+#include <QDateTime>
+#include <QTimer>
 #include <QVector2D>
 
-#include "common/ocioutils.h"
-
 namespace olive {
 
 Renderer::Renderer(QObject *parent) :
   QObject(parent)
 {
-
-}
-
-TexturePtr Renderer::CreateTexture(const VideoParams &params, Texture::Type type, const void *data, int linesize)
-{
-  QVariant v;
-
-  if (type == Texture::k3D) {
-    v = CreateNativeTexture3D(params.effective_width(), params.effective_height(),
-                              params.effective_depth(), params.format(), params.channel_count(), data, linesize);
-  } else {
-    v = CreateNativeTexture2D(params.effective_width(), params.effective_height(), params.format(),
-                              params.channel_count(), data, linesize);
-  }
-
-  return CreateTextureFromNativeHandle(v, params, type);
+  QTimer *texture_garbage_collector = new QTimer(this);
+  texture_garbage_collector->setInterval(MAX_TEXTURE_LIFE);
+  connect(texture_garbage_collector, &QTimer::timeout, this, &Renderer::ClearOldTextures);
+  texture_garbage_collector->start();
 }
 
 TexturePtr Renderer::CreateTexture(const VideoParams &params, const void *data, int linesize)
 {
-  return CreateTexture(params, Texture::k2D, data, linesize);
+  QVariant v;
+
+  /*for (auto it=texture_cache_.begin(); it!=texture_cache_.end(); it++) {
+    if (it->width == params.effective_width()
+        && it->height == params.effective_height()
+        && it->depth == params.effective_depth()
+        && it->format == params.format()
+        && it->channel_count == params.channel_count()) {
+      this->Flush();
+      v = it->handle;
+      texture_cache_.erase(it);
+      break;
+    }
+  }*/
+
+  v = CreateNativeTexture(params.effective_width(), params.effective_height(), params.effective_depth(),
+                          params.format(), params.channel_count(), data, linesize);
+
+  return CreateTextureFromNativeHandle(v, params);
+}
+
+void Renderer::DestroyTexture(Texture *texture)
+{
+  /*texture_cache_.push_back({texture->params().effective_width(),
+                            texture->params().effective_height(),
+                            texture->params().effective_depth(),
+                            texture->params().format(),
+                            texture->params().channel_count(),
+                            texture->id(),
+                            QDateTime::currentMSecsSinceEpoch()});*/
+  DestroyNativeTexture(texture->id());
 }
 
 TexturePtr Renderer::InterlaceTexture(TexturePtr top, TexturePtr bottom, const VideoParams &params)
@@ -83,6 +101,11 @@ QVariant Renderer::GetDefaultShader()
 
 void Renderer::Destroy()
 {
+  for (auto it=texture_cache_.begin(); it!=texture_cache_.end(); it++) {
+    DestroyNativeTexture(it->handle);
+  }
+  texture_cache_.clear();
+
   if (!default_shader_.isNull()) {
     DestroyNativeShader(default_shader_);
     default_shader_.clear();
@@ -98,13 +121,13 @@ void Renderer::Destroy()
   DestroyInternal();
 }
 
-TexturePtr Renderer::CreateTextureFromNativeHandle(const QVariant &v, const VideoParams &params, Texture::Type type)
+TexturePtr Renderer::CreateTextureFromNativeHandle(const QVariant &v, const VideoParams &params)
 {
   if (v.isNull()) {
     return nullptr;
   }
 
-  return std::make_shared<Texture>(this, v, params, type);
+  return std::make_shared<Texture>(this, v, params);
 }
 
 bool Renderer::GetColorContext(const ColorTransformJob &color_job, Renderer::ColorContext *ctx)
@@ -175,8 +198,7 @@ bool Renderer::GetColorContext(const ColorTransformJob &color_job, Renderer::Col
       }
 
       // Allocate 3D LUT
-      color_ctx.lut3d_textures[i].texture = CreateTexture(VideoParams(edge_len, edge_len, edge_len, VideoParams::kFormatFloat32, VideoParams::kRGBChannelCount),
-                                                          Texture::k3D, values);
+      color_ctx.lut3d_textures[i].texture = CreateTexture(VideoParams(edge_len, edge_len, edge_len, VideoParams::kFormatFloat32, VideoParams::kRGBChannelCount), values);
       color_ctx.lut3d_textures[i].name = sampler_name;
       color_ctx.lut3d_textures[i].interpolation = (interpolation == OCIO::INTERP_NEAREST) ? Texture::kNearest : Texture::kLinear;
     }
@@ -206,9 +228,7 @@ bool Renderer::GetColorContext(const ColorTransformJob &color_job, Renderer::Col
       }
 
       // Allocate 1D LUT
-      color_ctx.lut1d_textures[i].texture = CreateTexture(VideoParams(width, height, VideoParams::kFormatFloat32, (channel == OCIO::GpuShaderDesc::TEXTURE_RED_CHANNEL) ? 1 : VideoParams::kRGBChannelCount),
-                                                          Texture::k2D,
-                                                          values);
+      color_ctx.lut1d_textures[i].texture = CreateTexture(VideoParams(width, height, VideoParams::kFormatFloat32, (channel == OCIO::GpuShaderDesc::TEXTURE_RED_CHANNEL) ? 1 : VideoParams::kRGBChannelCount), values);
       color_ctx.lut1d_textures[i].name = sampler_name;
       color_ctx.lut1d_textures[i].interpolation = (interpolation == OCIO::INTERP_NEAREST) ? Texture::kNearest : Texture::kLinear;
     }
@@ -219,6 +239,18 @@ bool Renderer::GetColorContext(const ColorTransformJob &color_job, Renderer::Col
   }
 }
 
+void Renderer::ClearOldTextures()
+{
+  for (auto it=texture_cache_.begin(); it!=texture_cache_.end(); ) {
+    if (it->accessed < QDateTime::currentMSecsSinceEpoch() - MAX_TEXTURE_LIFE) {
+      DestroyNativeTexture(it->handle);
+      it = texture_cache_.erase(it);
+    } else {
+      it++;
+    }
+  }
+}
+
 void Renderer::BlitColorManaged(const ColorTransformJob &color_job, Texture *destination, const VideoParams &params)
 {
   ColorContext color_ctx;