proxy: cleaned up, re-use the render cache's disk save system for proxies, multithreaded compression

2020-05-04 00:29:26 +10:00
parent f7f437ab04
commit e4e797c901
14 changed files with 318 additions and 226 deletions
@@ -20,10 +20,16 @@

 #include "videorenderframecache.h"

+#include <OpenEXR/ImfFloatAttribute.h>
+#include <OpenEXR/ImfInputFile.h>
+#include <OpenEXR/ImfOutputFile.h>
+#include <OpenEXR/ImfChannelList.h>
 #include <QDir>
 #include <QFileInfo>

+#include "codec/frame.h"
 #include "common/filefunctions.h"
+#include "render/diskmanager.h"

 OLIVE_NAMESPACE_ENTER

@@ -139,25 +145,126 @@ const QMap<rational, QByteArray> &VideoRenderFrameCache::time_hash_map() const
  return time_hash_map_;
 }

+QString VideoRenderFrameCache::GetFormatExtension(const PixelFormat::Format &f)
+{
+  if (PixelFormat::FormatIsFloat(f)) {
+    return QStringLiteral(".exr");
+  } else {
+    return QStringLiteral(".jpg");
+  }
+}
+
+void VideoRenderFrameCache::SaveCacheFrame(const QByteArray& hash,
+                                           char* data,
+                                           const VideoRenderingParams& vparam) const
+{
+  QString fn = CachePathName(hash, vparam.format());
+
+  if (SaveCacheFrame(fn, data, vparam)) {
+    // Register frame with the disk manager
+    DiskManager::instance()->CreatedFile(fn, hash);
+  }
+}
+
 QString VideoRenderFrameCache::CachePathName(const QByteArray& hash, const PixelFormat::Format& pix_fmt) const
 {
-  QString ext;
-
-  if (pix_fmt == PixelFormat::PIX_FMT_RGB8
-      || pix_fmt == PixelFormat::PIX_FMT_RGBA8
-      || pix_fmt == PixelFormat::PIX_FMT_RGB16U
-      || pix_fmt == PixelFormat::PIX_FMT_RGBA16U) {
-    ext = QStringLiteral("jpg");
-  } else {
-    ext = QStringLiteral("exr");
-  }
+  QString ext = GetFormatExtension(pix_fmt);

  QDir cache_dir(QDir(FileFunctions::GetMediaCacheLocation()).filePath(QString(hash.left(1).toHex())));
  cache_dir.mkpath(".");

-  QString filename = QStringLiteral("%1.%2").arg(QString(hash.mid(1).toHex()), ext);
+  QString filename = QStringLiteral("%1%2").arg(QString(hash.mid(1).toHex()), ext);

  return cache_dir.filePath(filename);
 }

+bool VideoRenderFrameCache::SaveCacheFrame(const QString &filename, char *data, const VideoRenderingParams &vparam)
+{
+  switch (vparam.format()) {
+  case PixelFormat::PIX_FMT_RGB8:
+  case PixelFormat::PIX_FMT_RGBA8:
+  case PixelFormat::PIX_FMT_RGB16U:
+  case PixelFormat::PIX_FMT_RGBA16U:
+  {
+    // Integer types are stored in JPEG which we run through OIIO
+
+    std::string fn_std = filename.toStdString();
+
+    auto out = OIIO::ImageOutput::create(fn_std);
+
+    if (out) {
+      // Attempt to keep this write to one thread
+      out->threads(1);
+
+      out->open(fn_std, OIIO::ImageSpec(vparam.width(),
+                                        vparam.height(),
+                                        PixelFormat::ChannelCount(vparam.format()),
+                                        PixelFormat::GetOIIOTypeDesc(vparam.format())));
+
+      out->write_image(PixelFormat::GetOIIOTypeDesc(vparam.format()), data);
+
+      out->close();
+
+#if OIIO_VERSION < 10903
+      OIIO::ImageOutput::destroy(out);
+#endif
+
+      return true;
+    } else {
+      qCritical() << "Failed to write JPEG file:" << OIIO::geterror().c_str();
+      return false;
+    }
+  }
+  case PixelFormat::PIX_FMT_RGB16F:
+  case PixelFormat::PIX_FMT_RGBA16F:
+  case PixelFormat::PIX_FMT_RGB32F:
+  case PixelFormat::PIX_FMT_RGBA32F:
+  {
+    // Floating point types are stored in EXR
+    Imf::PixelType pix_type;
+
+    if (vparam.format() == PixelFormat::PIX_FMT_RGB16F
+        || vparam.format() == PixelFormat::PIX_FMT_RGBA16F) {
+      pix_type = Imf::HALF;
+    } else {
+      pix_type = Imf::FLOAT;
+    }
+
+    Imf::Header header(vparam.effective_width(),
+                       vparam.effective_height());
+    header.channels().insert("R", Imf::Channel(pix_type));
+    header.channels().insert("G", Imf::Channel(pix_type));
+    header.channels().insert("B", Imf::Channel(pix_type));
+    header.channels().insert("A", Imf::Channel(pix_type));
+
+    header.compression() = Imf::DWAA_COMPRESSION;
+    header.insert("dwaCompressionLevel", Imf::FloatAttribute(200.0f));
+
+    Imf::OutputFile out(filename.toUtf8(), header, 0);
+
+    int bpc = PixelFormat::BytesPerChannel(vparam.format());
+
+    size_t xs = kRGBAChannels * bpc;
+    size_t ys = vparam.effective_width() * kRGBAChannels * bpc;
+
+    Imf::FrameBuffer framebuffer;
+    framebuffer.insert("R", Imf::Slice(pix_type, data, xs, ys));
+    framebuffer.insert("G", Imf::Slice(pix_type, data + bpc, xs, ys));
+    framebuffer.insert("B", Imf::Slice(pix_type, data + 2*bpc, xs, ys));
+    framebuffer.insert("A", Imf::Slice(pix_type, data + 3*bpc, xs, ys));
+    out.setFrameBuffer(framebuffer);
+
+    out.writePixels(vparam.effective_height());
+
+    return true;
+  }
+  case PixelFormat::PIX_FMT_INVALID:
+  case PixelFormat::PIX_FMT_COUNT:
+    qCritical() << "Unable to cache invalid pixel format" << vparam.format();
+    break;
+  }
+
+  return false;
+}
+
 OLIVE_NAMESPACE_EXIT