oak-team/oak-editor
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

multicam: refactor to heavily optimize multicam monitor retrieval

Browse Source
This commit is contained in:
itsmattkc
2022-09-29 17:50:09 -07:00
parent 63163ba23e
commit 6e183fe4be
25 changed files with 300 additions and 162 deletions
Download Patch File Download Diff File Expand all files Collapse all files
app/node/input/multicam/multicamnode.cpp
+4 -93
View File
@@ -17,8 +17,6 @@ MultiCamNode::MultiCamNode()
AddInput(kSourcesInput, NodeValue::kNone, InputFlags(kInputFlagNotKeyframable | kInputFlagArray));
SetInputProperty(kSourcesInput, QStringLiteral("arraystart"), 1);
monitor_ = false;
}
QString MultiCamNode::Name() const
@@ -43,7 +41,7 @@ QString MultiCamNode::Description() const
Node::ActiveElements MultiCamNode::GetActiveElementsAtTime(const QString &input, const TimeRange &r) const
{
if (input == kSourcesInput && !monitor_) {
if (input == kSourcesInput) {
Node::ActiveElements a;
a.add(GetCurrentSource());
return a;
@@ -52,98 +50,11 @@ Node::ActiveElements MultiCamNode::GetActiveElementsAtTime(const QString &input,
}
}
QString dblToGlsl(double d)
{
return QString::number(d, 'f');
}
ShaderCode MultiCamNode::GetShaderCode(const ShaderRequest &id) const
{
QStringList pieces = id.id.split(',');
int rows = pieces.at(0).toInt();
int cols = pieces.at(1).toInt();
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 ShaderCode(shader.join('\n'));
}
void MultiCamNode::Value(const NodeValueRow &value, const NodeGlobals &globals, NodeValueTable *table) const
{
if (!monitor_) {
NodeValueArray arr = value[kSourcesInput].toArray();
if (!arr.empty()) {
table->Push(arr.begin()->second);
}
} else {
NodeValueArray arr = value[kSourcesInput].toArray();
int rows, cols;
GetRowsAndColumns(arr.size(), &rows, &cols);
ShaderJob job;
job.SetShaderID(QStringLiteral("%1,%2").arg(QString::number(rows), QString::number(cols)));
for (int i=0; i<int(arr.size()); i++) {
int c, r;
IndexToRowCols(i, rows, cols, &r, &c);
job.Insert(QStringLiteral("tex_%1_%2").arg(QString::number(r), QString::number(c)), arr[i]);
}
table->Push(NodeValue::kTexture, Texture::Job(globals.vparams(), job), this);
NodeValueArray arr = value[kSourcesInput].toArray();
if (!arr.empty()) {
table->Push(arr.begin()->second);
}
}
app/node/input/multicam/multicamnode.h
-7
View File
@@ -20,8 +20,6 @@ public:
virtual ActiveElements GetActiveElementsAtTime(const QString &input, const TimeRange &r) const override;
virtual ShaderCode GetShaderCode(const ShaderRequest &id) const override;
virtual void Value(const NodeValueRow& value, const NodeGlobals &globals, NodeValueTable *table) const override;
virtual void Retranslate() override;
@@ -29,8 +27,6 @@ public:
static const QString kCurrentInput;
static const QString kSourcesInput;
void SetMonitorMode(bool e) { monitor_ = e; }
int GetCurrentSource() const
{
return GetStandardValue(kCurrentInput).toInt();
@@ -54,9 +50,6 @@ public:
return col + row * total_cols;
}
private:
bool monitor_;
};
}
app/node/traverser.h
+1 -1
View File
@@ -42,7 +42,7 @@ public:
NodeValueTable GenerateTable(const Node *n, const TimeRange &range, const Node *next_node = nullptr);
NodeValueDatabase GenerateDatabase(const Node *node, const TimeRange &range);
virtual NodeValueDatabase GenerateDatabase(const Node *node, const TimeRange &range);
NodeValueRow GenerateRow(NodeValueDatabase *database, const Node *node, const TimeRange &range);
NodeValueRow GenerateRow(const Node *node, const TimeRange &range);
app/panel/multicam/multicampanel.cpp
+2 -3
View File
@@ -2,13 +2,12 @@
namespace olive {
#define super ViewerPanelBase
#define super TimeBasedPanel
MulticamPanel::MulticamPanel(QWidget *parent) :
super(QStringLiteral("MultiCamPanel"), parent)
{
widget_ = new MulticamWidget();
SetViewerWidget(widget_);
SetTimeBasedWidget(new MulticamWidget());
Retranslate();
}
app/panel/multicam/multicampanel.h
+5 -6
View File
@@ -6,28 +6,27 @@
namespace olive {
class MulticamPanel : public ViewerPanelBase
class MulticamPanel : public TimeBasedPanel
{
Q_OBJECT
public:
MulticamPanel(QWidget* parent = nullptr);
MulticamWidget *GetMulticamWidget() const { return static_cast<MulticamWidget *>(GetTimeBasedWidget()); }
void SetMulticamNode(MultiCamNode *n)
{
widget_->SetMulticamNode(n);
GetMulticamWidget()->SetMulticamNode(n);
}
void SetClip(ClipBlock* clip)
{
widget_->SetClip(clip);
GetMulticamWidget()->SetClip(clip);
}
protected:
virtual void Retranslate() override;
private:
MulticamWidget *widget_;
};
}
app/panel/viewer/viewerbase.cpp
+13 -11
View File
@@ -24,35 +24,37 @@
namespace olive {
#define super TimeBasedPanel
ViewerPanelBase::ViewerPanelBase(const QString& object_name, QWidget *parent) :
TimeBasedPanel(object_name, parent)
super(object_name, parent)
{
connect(PanelManager::instance(), &PanelManager::FocusedPanelChanged, this, &ViewerPanelBase::FocusedPanelChanged);
}
void ViewerPanelBase::PlayPause()
{
static_cast<ViewerWidget*>(GetTimeBasedWidget())->TogglePlayPause();
GetViewerWidget()->TogglePlayPause();
}
void ViewerPanelBase::PlayInToOut()
{
static_cast<ViewerWidget*>(GetTimeBasedWidget())->Play(true);
GetViewerWidget()->Play(true);
}
void ViewerPanelBase::ShuttleLeft()
{
static_cast<ViewerWidget*>(GetTimeBasedWidget())->ShuttleLeft();
GetViewerWidget()->ShuttleLeft();
}
void ViewerPanelBase::ShuttleStop()
{
static_cast<ViewerWidget*>(GetTimeBasedWidget())->ShuttleStop();
GetViewerWidget()->ShuttleStop();
}
void ViewerPanelBase::ShuttleRight()
{
static_cast<ViewerWidget*>(GetTimeBasedWidget())->ShuttleRight();
GetViewerWidget()->ShuttleRight();
}
void ViewerPanelBase::ConnectTimeBasedPanel(TimeBasedPanel *panel)
@@ -75,22 +77,22 @@ void ViewerPanelBase::DisconnectTimeBasedPanel(TimeBasedPanel *panel)
void ViewerPanelBase::SetFullScreen(QScreen *screen)
{
static_cast<ViewerWidget*>(GetTimeBasedWidget())->SetFullScreen(screen);
GetViewerWidget()->SetFullScreen(screen);
}
void ViewerPanelBase::SetGizmos(Node *node)
{
static_cast<ViewerWidget*>(GetTimeBasedWidget())->SetGizmos(node);
GetViewerWidget()->SetGizmos(node);
}
void ViewerPanelBase::CacheEntireSequence()
{
static_cast<ViewerWidget*>(GetTimeBasedWidget())->CacheEntireSequence();
GetViewerWidget()->CacheEntireSequence();
}
void ViewerPanelBase::CacheSequenceInOut()
{
static_cast<ViewerWidget*>(GetTimeBasedWidget())->CacheSequenceInOut();
GetViewerWidget()->CacheSequenceInOut();
}
void ViewerPanelBase::SetViewerWidget(ViewerWidget *vw)
@@ -104,7 +106,7 @@ void ViewerPanelBase::SetViewerWidget(ViewerWidget *vw)
void ViewerPanelBase::FocusedPanelChanged(PanelWidget *panel)
{
auto vw = static_cast<ViewerWidget*>(GetTimeBasedWidget());
auto vw = GetViewerWidget();
if (vw->IsPlaying() && panel != this) {
vw->Pause();
}
app/panel/viewer/viewerbase.h
+18 -3
View File
@@ -33,6 +33,11 @@ class ViewerPanelBase : public TimeBasedPanel
public:
ViewerPanelBase(const QString& object_name, QWidget* parent = nullptr);
ViewerWidget *GetViewerWidget() const
{
return static_cast<ViewerWidget*>(GetTimeBasedWidget());
}
virtual void PlayPause() override;
virtual void PlayInToOut() override;
@@ -54,12 +59,22 @@ public:
ColorManager *GetColorManager()
{
return static_cast<ViewerWidget*>(GetTimeBasedWidget())->color_manager();
return GetViewerWidget()->color_manager();
}
void UpdateTextureFromNode()
{
static_cast<ViewerWidget*>(GetTimeBasedWidget())->UpdateTextureFromNode();
GetViewerWidget()->UpdateTextureFromNode();
}
void AddPlaybackDevice(ViewerDisplayWidget *vw)
{
GetViewerWidget()->AddPlaybackDevice(vw);
}
void SetMulticamNode(MultiCamNode *n)
{
GetViewerWidget()->SetMulticamNode(n);
}
public slots:
@@ -71,7 +86,7 @@ public slots:
void RequestStartEditingText()
{
static_cast<ViewerWidget*>(GetTimeBasedWidget())->RequestStartEditingText();
GetViewerWidget()->RequestStartEditingText();
}
signals:
app/render/previewautocacher.cpp
+8 -8
View File
@@ -43,7 +43,7 @@ PreviewAutoCacher::PreviewAutoCacher(QObject *parent) :
pause_renders_(false),
single_frame_render_(nullptr),
display_color_processor_(nullptr),
multicam_mode_(false),
multicam_(nullptr),
ignore_cache_requests_(false)
{
// Set defaults
@@ -216,6 +216,7 @@ void PreviewAutoCacher::VideoRendered()
QVector<RenderTicketPtr> tickets = video_immediate_passthroughs_.take(watcher);
foreach (RenderTicketPtr t, tickets) {
if (watcher->HasResult()) {
t->setProperty("multicam_output", watcher->GetTicket()->property("multicam_output"));
t->Finish(watcher->Get());
} else {
t->Finish();
@@ -288,13 +289,6 @@ void PreviewAutoCacher::AddNode(Node *node)
// Copy node
Node* copy = node->copy();
// Fairly hacky way of getting multicam nodes to produce a monitor rather than a single source
if (multicam_mode_) {
if (MultiCamNode *m = dynamic_cast<MultiCamNode*>(copy)) {
m->SetMonitorMode(true);
}
}
// Add to project
copy->setParent(&copied_project_);
@@ -742,6 +736,9 @@ RenderTicketWatcher* PreviewAutoCacher::RenderFrame(Node *node, const rational&
// Allow using cached images for this render job
rvp.use_cache = true;
// Multicam
rvp.multicam = static_cast<MultiCamNode*>(copy_map_.value(multicam_));
watcher->SetTicket(RenderManager::instance()->RenderFrame(rvp));
return watcher;
@@ -848,6 +845,9 @@ void PreviewAutoCacher::SetViewerNode(ViewerOutput *viewer_node)
video_cache_data_.clear();
audio_cache_data_.clear();
// Clear multicam reference
multicam_ = nullptr;
// Disconnect signals for future node additions/deletions
NodeGraph* graph = viewer_node_->parent();
app/render/previewautocacher.h
+4 -2
View File
@@ -90,7 +90,8 @@ public:
void SetRendersPaused(bool e);
void SetMulticamMode(bool e) { multicam_mode_ = e; }
void SetMulticamNode(MultiCamNode *n) { multicam_ = n; }
void SetIgnoreCacheRequests(bool e) { ignore_cache_requests_ = e; }
public slots:
@@ -221,7 +222,8 @@ private:
ColorProcessorPtr display_color_processor_;
bool multicam_mode_;
MultiCamNode *multicam_;
bool ignore_cache_requests_;
private slots:
app/render/rendermanager.cpp
+1
View File
@@ -111,6 +111,7 @@ RenderTicketPtr RenderManager::RenderFrame(const RenderVideoParams &params)
ticket->setProperty("cache", params.cache_dir);
ticket->setProperty("cachetimebase", QVariant::fromValue(params.cache_timebase));
ticket->setProperty("cacheid", QVariant::fromValue(params.cache_id));
ticket->setProperty("multicam", Node::PtrToValue(params.multicam));
if (params.return_type == ReturnType::kNull) {
dry_run_thread_->AddTicket(ticket);
app/render/rendermanager.h
+2
View File
@@ -117,6 +117,7 @@ public:
force_size = QSize(0, 0);
force_channel_count = 0;
mode = m;
multicam = nullptr;
}
void AddCache(FrameHashCache *cache)
@@ -134,6 +135,7 @@ public:
bool use_cache;
ReturnType return_type;
RenderMode::Mode mode;
MultiCamNode *multicam;
QString cache_dir;
rational cache_timebase;
app/render/renderprocessor.cpp
+24
View File
@@ -294,6 +294,30 @@ DecoderPtr RenderProcessor::ResolveDecoderFromInput(const QString& decoder_id, c
return dec;
}
NodeValueDatabase RenderProcessor::GenerateDatabase(const Node *node, const TimeRange &range)
{
NodeValueDatabase db = super::GenerateDatabase(node, range);
if (const MultiCamNode *multicam = dynamic_cast<const MultiCamNode*>(node)) {
if (Node::ValueToPtr<MultiCamNode>(ticket_->property("multicam")) == multicam) {
int sz = multicam->InputArraySize(multicam->kSourcesInput);
NodeValueTableArray arr;
QVector<TexturePtr> multicam_tex(sz);
for (int i=0; i<sz; i++) {
ProcessInputElement(arr, multicam, multicam->kSourcesInput, i, range);
NodeValue val = GenerateRowValueElement(multicam, multicam->kSourcesInput, i, &arr.at(i), range);
ResolveJobs(val);
multicam_tex[i] = val.toTexture();
}
ticket_->setProperty("multicam_output", QVariant::fromValue(multicam_tex));
}
}
return db;
}
void RenderProcessor::Process(RenderTicketPtr ticket, Renderer *render_ctx, DecoderCache *decoder_cache, ShaderCache *shader_cache)
{
RenderProcessor p(ticket, render_ctx, decoder_cache, shader_cache);
app/render/renderprocessor.h
+2
View File
@@ -32,6 +32,8 @@ namespace olive {
class RenderProcessor : public NodeTraverser
{
public:
virtual NodeValueDatabase GenerateDatabase(const Node *node, const TimeRange &range) override;
static void Process(RenderTicketPtr ticket, Renderer* render_ctx, DecoderCache* decoder_cache, ShaderCache* shader_cache);
struct RenderedWaveform {
app/widget/multicam/multicamdisplay.cpp
+110 -1
View File
@@ -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
+10
View File
@@ -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
+36 -15
View File
@@ -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
+9 -2
View File
@@ -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_;
app/widget/viewer/viewer.cpp
+21 -6
View File
@@ -44,6 +44,7 @@
#include "viewerpreventsleep.h"
#include "widget/audiomonitor/audiomonitor.h"
#include "widget/menu/menu.h"
#include "widget/multicam/multicamdisplay.h"
#include "widget/nodeparamview/nodeparamviewundo.h"
#include "widget/timelinewidget/tool/add.h"
#include "widget/timeruler/timeruler.h"
@@ -82,7 +83,6 @@ ViewerWidget::ViewerWidget(ViewerDisplayWidget *display, QWidget *parent) :
// Create main OpenGL-based view and sizer
sizer_ = new ViewerSizer();
sizer_->setSizePolicy(QSizePolicy::Expanding, QSizePolicy::Expanding);
layout->addWidget(sizer_);
display_widget_ = display;
@@ -260,7 +260,7 @@ void ViewerWidget::DisconnectNodeEvent(ViewerOutput *n)
CloseAudioProcessor();
audio_scrub_watchers_.clear();
SetDisplayImage(QVariant());
SetDisplayImage(nullptr);
ruler()->SetPlaybackCache(nullptr);
@@ -998,10 +998,18 @@ bool ViewerWidget::ViewerMightBeAStill()
return GetConnectedNode() && GetConnectedNode()->GetConnectedTextureOutput() && GetConnectedNode()->GetVideoLength().isNull();
}
void ViewerWidget::SetDisplayImage(QVariant frame)
void ViewerWidget::SetDisplayImage(RenderTicketPtr ticket)
{
foreach (ViewerDisplayWidget *dw, playback_devices_) {
dw->SetImage(frame);
QVariant push;
if (ticket) {
if (dynamic_cast<MulticamDisplay*>(dw)) {
push = ticket->property("multicam_output");
} else {
push = ticket->Get();
}
}
dw->SetImage(push);
}
}
@@ -1160,7 +1168,7 @@ void ViewerWidget::RendererGeneratedFrame()
}
}
SetDisplayImage(ticket->Get());
SetDisplayImage(ticket->GetTicket());
}
}
@@ -1182,7 +1190,14 @@ void ViewerWidget::RendererGeneratedFrameForQueue()
rational ts = watcher->property("time").value<rational>();
foreach (ViewerDisplayWidget *dw, playback_devices_) {
dw->queue()->AppendTimewise({ts, frame}, playback_speed_);
QVariant push;
if (dynamic_cast<MulticamDisplay*>(dw)) {
push = watcher->GetTicket()->property("multicam_output");
} else {
push = frame;
}
dw->queue()->AppendTimewise({ts, push}, playback_speed_);
}
if (prequeuing_video_) {
app/widget/viewer/viewer.h
+11 -1
View File
@@ -104,6 +104,16 @@ public:
PreviewAutoCacher *GetCacher() const { return auto_cacher_; }
void AddPlaybackDevice(ViewerDisplayWidget *vw)
{
playback_devices_.push_back(vw);
}
void SetMulticamNode(MultiCamNode *n)
{
auto_cacher()->SetMulticamNode(n);
}
public slots:
void Play(bool in_to_out_only);
@@ -219,7 +229,7 @@ private:
bool ViewerMightBeAStill();
void SetDisplayImage(QVariant frame);
void SetDisplayImage(RenderTicketPtr ticket);
RenderTicketWatcher *RequestNextFrameForQueue(bool increment = true);
app/widget/viewer/viewerdisplay.cpp
+2
View File
@@ -398,6 +398,8 @@ void ViewerDisplayWidget::OnPaint()
} else if (TexturePtr texture = load_frame_.value<TexturePtr>()) {
// This is a GPU texture, switch to it directly
texture_ = texture;
} else {
texture_ = LoadCustomTextureFromFrame(load_frame_);
}
emit TextureChanged(texture_);
app/widget/viewer/viewerdisplay.h
+5
View File
@@ -245,6 +245,11 @@ protected:
return TimeRange(node_time, node_time + gizmo_params_.frame_rate_as_time_base());
}
virtual TexturePtr LoadCustomTextureFromFrame(const QVariant &v)
{
return nullptr;
}
protected slots:
/**
* @brief Paint function to display the texture (received in SetTexture()) on screen.
app/widget/viewer/viewerqueue.h
+4 -2
View File
@@ -27,12 +27,14 @@
namespace olive {
struct ViewerPlaybackFrame {
struct ViewerPlaybackFrame
{
rational timestamp;
QVariant frame;
};
class ViewerQueue : public std::list<ViewerPlaybackFrame> {
class ViewerQueue : public std::list<ViewerPlaybackFrame>
{
public:
ViewerQueue() = default;
app/widget/viewer/viewersizer.cpp
+2
View File
@@ -39,6 +39,8 @@ ViewerSizer::ViewerSizer(QWidget *parent) :
vert_scrollbar_ = new QScrollBar(Qt::Vertical, this);
vert_scrollbar_->setVisible(false);
connect(vert_scrollbar_, &QScrollBar::valueChanged, this, &ViewerSizer::ScrollBarMoved);
setSizePolicy(QSizePolicy::Expanding, QSizePolicy::Expanding);
}
void ViewerSizer::SetWidget(QWidget *widget)
app/widget/viewer/viewersizer.h
+1 -1
View File
@@ -51,6 +51,7 @@ public:
*/
void SetWidget(QWidget* widget);
public slots:
/**
* @brief Set resolution to use
*
@@ -70,7 +71,6 @@ public:
*/
void SetZoom(int percent);
public slots:
void HandDragMove(int x, int y);
signals:
app/window/mainwindow/mainwindow.cpp
+5
View File
@@ -125,6 +125,8 @@ MainWindow::MainWindow(QWidget *parent) :
sequence_viewer_panel_->ConnectTimeBasedPanel(curve_panel_);
sequence_viewer_panel_->ConnectTimeBasedPanel(multicam_panel_);
sequence_viewer_panel_->AddPlaybackDevice(multicam_panel_->GetMulticamWidget()->GetDisplayWidget());
scope_panel_->SetViewerPanel(sequence_viewer_panel_);
UpdateTitle();
@@ -510,10 +512,12 @@ void MainWindow::TimelinePanelSelectionChanged(const QVector<Block *> &blocks)
}
if (multicam) {
sequence_viewer_panel_->SetMulticamNode(multicam);
multicam_panel_->SetMulticamNode(multicam);
multicam_panel_->SetClip(clip);
multicam_panel_->ConnectViewerNode(panel->GetConnectedViewer());
} else {
sequence_viewer_panel_->SetMulticamNode(nullptr);
multicam_panel_->ConnectViewerNode(nullptr);
multicam_panel_->SetMulticamNode(nullptr);
multicam_panel_->SetClip(nullptr);
@@ -678,6 +682,7 @@ void MainWindow::RemoveProjectPanel(ProjectPanel *panel)
void MainWindow::TimelineFocused(ViewerOutput* viewer)
{
sequence_viewer_panel_->ConnectViewerNode(viewer);
multicam_panel_->ConnectViewerNode(viewer);
param_panel_->ConnectViewerNode(viewer);
curve_panel_->ConnectViewerNode(viewer);
}