multicam: refactor to heavily optimize multicam monitor retrieval

app/widget/multicam/multicamdisplay.cpp

@@ -26,7 +26,9 @@ namespace olive {
 
 MulticamDisplay::MulticamDisplay(QWidget *parent) :
   super(parent),
-  node_(nullptr)
+  node_(nullptr),
+  rows_(0),
+  cols_(0)
 {
 }
 
@@ -55,6 +57,113 @@ void MulticamDisplay::OnPaint()
   }
 }
 
+void MulticamDisplay::OnDestroy()
+{
+  shader_ = QVariant();
+}
+
+TexturePtr MulticamDisplay::LoadCustomTextureFromFrame(const QVariant &v)
+{
+  if (v.canConvert<QVector<TexturePtr> >()) {
+    QVector<TexturePtr> tex = v.value<QVector<TexturePtr> >();
+
+    TexturePtr main = renderer()->CreateTexture(this->GetViewportParams());
+
+    int rows, cols;
+    MultiCamNode::GetRowsAndColumns(tex.size(), &rows, &cols);
+
+    if (shader_.isNull() || rows_ != rows || cols_ != cols) {
+      if (!shader_.isNull()) {
+        renderer()->DestroyNativeShader(shader_);
+      }
+
+      shader_ = renderer()->CreateNativeShader(ShaderCode(GenerateShaderCode(rows, cols)));
+
+      rows_ = rows;
+      cols_ = cols;
+    }
+
+    ShaderJob job;
+
+    for (int i=0; i<tex.size(); i++) {
+      int c, r;
+      MultiCamNode::IndexToRowCols(i, rows, cols, &r, &c);
+      job.Insert(QStringLiteral("tex_%1_%2").arg(QString::number(r), QString::number(c)), NodeValue(NodeValue::kTexture, tex.at(i)));
+    }
+
+    renderer()->BlitToTexture(shader_, job, main.get());
+
+    return main;
+  } else {
+    return super::LoadCustomTextureFromFrame(v);
+  }
+}
+
+QString dblToGlsl(double d)
+{
+  return QString::number(d, 'f');
+}
+
+QString MulticamDisplay::GenerateShaderCode(int rows, int cols)
+{
+  int multiplier = std::max(cols, rows);
+
+  QStringList shader;
+
+  shader.append(QStringLiteral("in vec2 ove_texcoord;"));
+  shader.append(QStringLiteral("out vec4 frag_color;"));
+
+  for (int x=0;x<cols;x++) {
+    for (int y=0;y<rows;y++) {
+      shader.append(QStringLiteral("uniform sampler2D tex_%1_%2;").arg(QString::number(y), QString::number(x)));
+      shader.append(QStringLiteral("uniform bool tex_%1_%2_enabled;").arg(QString::number(y), QString::number(x)));
+    }
+  }
+
+  shader.append(QStringLiteral("void main() {"));
+
+  for (int x=0;x<cols;x++) {
+    if (x > 0) {
+      shader.append(QStringLiteral("  else"));
+    }
+    if (x == cols-1) {
+      shader.append(QStringLiteral("  {"));
+    } else {
+      shader.append(QStringLiteral("  if (ove_texcoord.x < %1) {").arg(dblToGlsl(double(x+1)/double(multiplier))));
+    }
+
+    for (int y=0;y<rows;y++) {
+      if (y > 0) {
+        shader.append(QStringLiteral("    else"));
+      }
+      if (y == rows-1) {
+        shader.append(QStringLiteral("    {"));
+      } else {
+        shader.append(QStringLiteral("    if (ove_texcoord.y < %1) {").arg(dblToGlsl(double(y+1)/double(multiplier))));
+      }
+      QString input = QStringLiteral("tex_%1_%2").arg(QString::number(y), QString::number(x));
+      shader.append(QStringLiteral("      vec2 coord = vec2((ove_texcoord.x+%1)*%2, (ove_texcoord.y+%3)*%4);").arg(
+                      dblToGlsl( - double(x)/double(multiplier)),
+                      dblToGlsl(multiplier),
+                      dblToGlsl( - double(y)/double(multiplier)),
+                      dblToGlsl(multiplier)
+                      ));
+      shader.append(QStringLiteral("      if (%1_enabled && coord.x >= 0.0 && coord.x < 1.0 && coord.y >= 0.0 && coord.y < 1.0) {").arg(input));
+      shader.append(QStringLiteral("        frag_color = texture(%1, coord);").arg(input));
+      shader.append(QStringLiteral("      } else {"));
+      shader.append(QStringLiteral("        discard;"));
+      shader.append(QStringLiteral("      }"));
+      shader.append(QStringLiteral("    }"));
+    }
+
+    shader.append(QStringLiteral("  }"));
+  }
+
+  shader.append(QStringLiteral("}"));
+
+  return shader.join('\n');
+}
+
 void MulticamDisplay::SetMulticamNode(MultiCamNode *n)
 {
   node_ = n;

app/widget/multicam/multicamdisplay.h

@@ -37,9 +37,19 @@ public:
 protected:
   virtual void OnPaint() override;
 
+  virtual void OnDestroy() override;
+
+  virtual TexturePtr LoadCustomTextureFromFrame(const QVariant &v) override;
+
 private:
+  static QString GenerateShaderCode(int rows, int cols);
+
   MultiCamNode *node_;
 
+  QVariant shader_;
+  int rows_;
+  int cols_;
+
 };
 
 }

app/widget/multicam/multicamwidget.cpp

@@ -20,27 +20,41 @@
 
 #include "multicamwidget.h"
 #include "widget/nodeparamview/nodeparamviewundo.h"
+#include "widget/timeruler/timeruler.h"
 #include "widget/timelinewidget/undo/timelineundosplit.h"
 
 namespace olive {
 
-#define super ViewerWidget
+#define super TimeBasedWidget
 
 MulticamWidget::MulticamWidget(QWidget *parent) :
-  super{new MulticamDisplay(), parent},
+  super{false, false, parent},
   node_(nullptr),
   clip_(nullptr)
 {
-  auto_cacher()->SetMulticamMode(true);
-  auto_cacher()->SetIgnoreCacheRequests(true);
+  auto layout = new QVBoxLayout(this);
 
-  connect(display_widget(), &ViewerDisplayWidget::DragStarted, this, &MulticamWidget::DisplayClicked);
+  sizer_ = new ViewerSizer(this);
+  layout->addWidget(sizer_);
+
+  display_ = new MulticamDisplay(this);
+  display_->SetShowWidgetBackground(true);
+  connect(display_, &ViewerDisplayWidget::DragStarted, this, &MulticamWidget::DisplayClicked);
+
+  connect(sizer_, &ViewerSizer::RequestScale, display_, &ViewerDisplayWidget::SetMatrixZoom);
+  connect(sizer_, &ViewerSizer::RequestTranslate, display_, &ViewerDisplayWidget::SetMatrixTranslate);
+  connect(display_, &ViewerDisplayWidget::HandDragMoved, sizer_, &ViewerSizer::HandDragMove);
+  sizer_->SetWidget(display_);
+
+  layout->addWidget(this->ruler());
+  layout->addWidget(this->scrollbar());
 }
 
 void MulticamWidget::SetMulticamNode(MultiCamNode *n)
 {
   node_ = n;
-  static_cast<MulticamDisplay*>(display_widget())->SetMulticamNode(n);
+  display_->SetMulticamNode(n);
+  display_->update();
 }
 
 void MulticamWidget::SetClip(ClipBlock *clip)
@@ -48,13 +62,20 @@ void MulticamWidget::SetClip(ClipBlock *clip)
   clip_ = clip;
 }
 
-RenderTicketPtr MulticamWidget::GetSingleFrame(const rational &t, bool dry)
+void MulticamWidget::ConnectNodeEvent(ViewerOutput *n)
 {
-  if (node_) {
-    return auto_cacher()->GetSingleFrame(node_, t, dry);
-  } else {
-    return super::GetSingleFrame(t, dry);
-  }
+  connect(n, &ViewerOutput::SizeChanged, sizer_, &ViewerSizer::SetChildSize);
+  connect(n, &ViewerOutput::PixelAspectChanged, sizer_, &ViewerSizer::SetPixelAspectRatio);
+
+  VideoParams vp = n->GetVideoParams();
+  sizer_->SetChildSize(vp.width(), vp.height());
+  sizer_->SetPixelAspectRatio(vp.pixel_aspect_ratio());
+}
+
+void MulticamWidget::DisconnectNodeEvent(ViewerOutput *n)
+{
+  disconnect(n, &ViewerOutput::SizeChanged, sizer_, &ViewerSizer::SetChildSize);
+  disconnect(n, &ViewerOutput::PixelAspectChanged, sizer_, &ViewerSizer::SetPixelAspectRatio);
 }
 
 void MulticamWidget::DisplayClicked(const QPoint &p)
@@ -63,9 +84,9 @@ void MulticamWidget::DisplayClicked(const QPoint &p)
     return;
   }
 
-  QPointF click = display_widget()->ScreenToScenePoint(p);
-  int width = display_widget()->GetVideoParams().width();
-  int height = display_widget()->GetVideoParams().height();
+  QPointF click = display_->ScreenToScenePoint(p);
+  int width = display_->GetVideoParams().width();
+  int height = display_->GetVideoParams().height();
 
   if (click.x() < 0 || click.y() < 0 || click.x() >= width || click.y() >= height) {
     return;

app/widget/multicam/multicamwidget.h

@@ -27,20 +27,27 @@
 
 namespace olive {
 
-class MulticamWidget : public ViewerWidget
+class MulticamWidget : public TimeBasedWidget
 {
   Q_OBJECT
 public:
   explicit MulticamWidget(QWidget *parent = nullptr);
 
+  MulticamDisplay *GetDisplayWidget() const { return display_; }
+
   void SetMulticamNode(MultiCamNode *n);
 
   void SetClip(ClipBlock *clip);
 
 protected:
-  virtual RenderTicketPtr GetSingleFrame(const rational &t, bool dry = false) override;
+  virtual void ConnectNodeEvent(ViewerOutput *n) override;
+  virtual void DisconnectNodeEvent(ViewerOutput *n) override;
 
 private:
+  ViewerSizer *sizer_;
+
+  MulticamDisplay *display_;
+
   MultiCamNode *node_;
 
   ClipBlock *clip_;