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

render: fixed threading regression

Browse Source
This commit is contained in:
itsmattkc
2022-05-15 21:36:40 -07:00
parent 81956d8869
commit ea13f249b7
6 changed files with 42 additions and 47 deletions
Download Patch File Download Diff File Expand all files Collapse all files
app/render/previewautocacher.cpp
+12 -12
View File
@@ -62,7 +62,7 @@ PreviewAutoCacher::~PreviewAutoCacher()
SetViewerNode(nullptr);
}
RenderTicketPtr PreviewAutoCacher::GetSingleFrame(const rational &t, bool prioritize)
RenderTicketPtr PreviewAutoCacher::GetSingleFrame(const rational &t, RenderTicketPriority priority)
{
// If we have a single frame render queued (but not yet sent to the RenderManager), cancel it now
CancelQueuedSingleFrameRender();
@@ -78,7 +78,7 @@ RenderTicketPtr PreviewAutoCacher::GetSingleFrame(const rational &t, bool priori
auto sfr = std::make_shared<RenderTicket>();
sfr->Start();
sfr->setProperty("time", QVariant::fromValue(t));
sfr->setProperty("prioritize", prioritize);
sfr->setProperty("priority", int(priority));
sfr->setProperty("hash", hash);
// Queue it and try to render
@@ -88,9 +88,9 @@ RenderTicketPtr PreviewAutoCacher::GetSingleFrame(const rational &t, bool priori
return sfr;
}
RenderTicketPtr PreviewAutoCacher::GetRangeOfAudio(TimeRange range, bool prioritize)
RenderTicketPtr PreviewAutoCacher::GetRangeOfAudio(TimeRange range, RenderTicketPriority priority)
{
return RenderAudio(range, false, prioritize);
return RenderAudio(range, false, priority);
}
QVector<PreviewAutoCacher::HashData> PreviewAutoCacher::GenerateHashes(ViewerOutput *viewer, FrameHashCache* cache, const QVector<rational> &times)
@@ -287,7 +287,7 @@ void PreviewAutoCacher::VideoRendered()
w->SetTicket(RenderManager::instance()->SaveFrameToCache(viewer_node_->video_frame_cache(),
frame,
hash,
true));
RenderTicketPriority::kHigh));
}
}
@@ -637,7 +637,7 @@ void PreviewAutoCacher::TryRender()
} else {
watcher = RenderFrame(hash,
single_frame_render_->property("time").value<rational>(),
single_frame_render_->property("prioritize").toBool(),
RenderTicketPriority(single_frame_render_->property("priority").toInt()),
!viewer_node_->GetVideoAutoCacheEnabled());
video_immediate_passthroughs_[watcher].append(single_frame_render_);
@@ -685,7 +685,7 @@ void PreviewAutoCacher::TryRender()
// We want this hash, if we're not already rendering, start render now
if (!render_task && !video_download_tasks_.key(hash)) {
// Don't render any hash more than once
RenderFrame(hash, t, false, false);
RenderFrame(hash, t, RenderTicketPriority::kNormal, false);
}
emit SignalCacheProxyTaskProgress(double(queued_frame_iterator_.frame_index()) / double(queued_frame_iterator_.size()));
@@ -705,13 +705,13 @@ void PreviewAutoCacher::TryRender()
r.set_out(qMin(r.out(), r.in() + AudioVisualWaveform::kMinimumSampleRate.flipped()));
// Start job
RenderAudio(r, true, false);
RenderAudio(r, true, RenderTicketPriority::kNormal);
audio_iterator_.remove(r);
}
}
RenderTicketWatcher* PreviewAutoCacher::RenderFrame(const QByteArray &hash, const rational& time, bool prioritize, bool texture_only)
RenderTicketWatcher* PreviewAutoCacher::RenderFrame(const QByteArray &hash, const rational& time, RenderTicketPriority priority, bool texture_only)
{
RenderTicketWatcher* watcher = new RenderTicketWatcher();
watcher->setProperty("hash", hash);
@@ -723,19 +723,19 @@ RenderTicketWatcher* PreviewAutoCacher::RenderFrame(const QByteArray &hash, cons
time,
RenderMode::kOffline,
viewer_node_->video_frame_cache(),
prioritize,
priority,
texture_only));
return watcher;
}
RenderTicketPtr PreviewAutoCacher::RenderAudio(const TimeRange &r, bool generate_waveforms, bool prioritize)
RenderTicketPtr PreviewAutoCacher::RenderAudio(const TimeRange &r, bool generate_waveforms, RenderTicketPriority priority)
{
RenderTicketWatcher* watcher = new RenderTicketWatcher();
watcher->setProperty("job", QVariant::fromValue(last_update_time_));
connect(watcher, &RenderTicketWatcher::Finished, this, &PreviewAutoCacher::AudioRendered);
audio_tasks_.insert(watcher, r);
RenderTicketPtr ticket = RenderManager::instance()->RenderAudio(copied_viewer_node_, r, RenderMode::kOffline, generate_waveforms, prioritize);
RenderTicketPtr ticket = RenderManager::instance()->RenderAudio(copied_viewer_node_, r, RenderMode::kOffline, generate_waveforms, priority);
watcher->SetTicket(ticket);
return ticket;
}
app/render/previewautocacher.h
+5 -4
View File
@@ -32,6 +32,7 @@
#include "node/project/project.h"
#include "render/audioparams.h"
#include "render/renderjobtracker.h"
#include "threading/threadpool.h"
#include "threading/threadticketwatcher.h"
namespace olive {
@@ -49,9 +50,9 @@ public:
virtual ~PreviewAutoCacher() override;
RenderTicketPtr GetSingleFrame(const rational& t, bool prioritize);
RenderTicketPtr GetSingleFrame(const rational& t, RenderTicketPriority prioritize);
RenderTicketPtr GetRangeOfAudio(TimeRange range, bool prioritize);
RenderTicketPtr GetRangeOfAudio(TimeRange range, RenderTicketPriority prioritize);
/**
* @brief Set the viewer node to auto-cache
@@ -110,8 +111,8 @@ signals:
private:
void TryRender();
RenderTicketWatcher *RenderFrame(const QByteArray& hash, const rational &time, bool prioritize, bool texture_only);
RenderTicketPtr RenderAudio(const TimeRange &range, bool generate_waveforms, bool prioritize);
RenderTicketWatcher *RenderFrame(const QByteArray& hash, const rational &time, RenderTicketPriority priority, bool texture_only);
RenderTicketPtr RenderAudio(const TimeRange &range, bool generate_waveforms, RenderTicketPriority priority);
/**
* @brief Process all changes to internal NodeGraph copy
app/render/rendermanager.cpp
+10 -10
View File
@@ -92,7 +92,7 @@ QByteArray RenderManager::Hash(const Node *n, const Node::ValueHint &output, con
RenderTicketPtr RenderManager::RenderFrame(ViewerOutput *viewer, ColorManager* color_manager,
const rational& time, RenderMode::Mode mode,
FrameHashCache* cache, bool prioritize, bool texture_only)
FrameHashCache* cache, RenderTicketPriority priority, bool texture_only)
{
return RenderFrame(viewer,
color_manager,
@@ -105,7 +105,7 @@ RenderTicketPtr RenderManager::RenderFrame(ViewerOutput *viewer, ColorManager* c
VideoParams::kFormatInvalid,
nullptr,
cache,
prioritize,
priority,
texture_only);
}
@@ -115,7 +115,7 @@ RenderTicketPtr RenderManager::RenderFrame(ViewerOutput *viewer, ColorManager* c
const QSize& force_size,
const QMatrix4x4& force_matrix, VideoParams::Format force_format,
ColorProcessorPtr force_color_output,
FrameHashCache* cache, bool prioritize, bool texture_only)
FrameHashCache* cache, RenderTicketPriority priority, bool texture_only)
{
// Create ticket
RenderTicketPtr ticket = std::make_shared<RenderTicket>();
@@ -137,17 +137,17 @@ RenderTicketPtr RenderManager::RenderFrame(ViewerOutput *viewer, ColorManager* c
ticket->setProperty("cache", cache->GetCacheDirectory());
}
AddTicket(ticket);
AddTicket(ticket, priority);
return ticket;
}
RenderTicketPtr RenderManager::RenderAudio(ViewerOutput* viewer, const TimeRange& r, RenderMode::Mode mode, bool generate_waveforms, bool prioritize)
RenderTicketPtr RenderManager::RenderAudio(ViewerOutput* viewer, const TimeRange& r, RenderMode::Mode mode, bool generate_waveforms, RenderTicketPriority priority)
{
return RenderAudio(viewer, r, viewer->GetAudioParams(), mode, generate_waveforms, prioritize);
return RenderAudio(viewer, r, viewer->GetAudioParams(), mode, generate_waveforms, priority);
}
RenderTicketPtr RenderManager::RenderAudio(ViewerOutput* viewer, const TimeRange &r, const AudioParams &params, RenderMode::Mode mode, bool generate_waveforms, bool prioritize)
RenderTicketPtr RenderManager::RenderAudio(ViewerOutput* viewer, const TimeRange &r, const AudioParams &params, RenderMode::Mode mode, bool generate_waveforms, RenderTicketPriority priority)
{
// Create ticket
RenderTicketPtr ticket = std::make_shared<RenderTicket>();
@@ -159,12 +159,12 @@ RenderTicketPtr RenderManager::RenderAudio(ViewerOutput* viewer, const TimeRange
ticket->setProperty("enablewaveforms", generate_waveforms);
ticket->setProperty("aparam", QVariant::fromValue(params));
AddTicket(ticket);
AddTicket(ticket, priority);
return ticket;
}
RenderTicketPtr RenderManager::SaveFrameToCache(FrameHashCache *cache, FramePtr frame, const QByteArray &hash, bool prioritize)
RenderTicketPtr RenderManager::SaveFrameToCache(FrameHashCache *cache, FramePtr frame, const QByteArray &hash, RenderTicketPriority priority)
{
// Create ticket
RenderTicketPtr ticket = std::make_shared<RenderTicket>();
@@ -174,7 +174,7 @@ RenderTicketPtr RenderManager::SaveFrameToCache(FrameHashCache *cache, FramePtr
ticket->setProperty("hash", hash);
ticket->setProperty("type", kTypeVideoDownload);
AddTicket(ticket);
AddTicket(ticket, priority);
return ticket;
}
app/render/rendermanager.h
+5 -11
View File
@@ -74,36 +74,30 @@ public:
* The ticket from this function will return a FramePtr - the rendered frame in reference color
* space.
*
* Setting `prioritize` to TRUE puts this ticket at the top of the queue. Leaving it as FALSE
* appends it to the bottom.
*
* This function is thread-safe.
*/
RenderTicketPtr RenderFrame(ViewerOutput *viewer, ColorManager* color_manager,
const rational& time, RenderMode::Mode mode,
FrameHashCache* cache = nullptr, bool prioritize = false, bool texture_only = false);
FrameHashCache* cache = nullptr, RenderTicketPriority priority = RenderTicketPriority::kNormal, bool texture_only = false);
RenderTicketPtr RenderFrame(ViewerOutput* viewer, ColorManager* color_manager,
const rational& time, RenderMode::Mode mode,
const VideoParams& video_params, const AudioParams& audio_params,
const QSize& force_size,
const QMatrix4x4& force_matrix, VideoParams::Format force_format,
ColorProcessorPtr force_color_output,
FrameHashCache* cache = nullptr, bool prioritize = false, bool texture_only = false);
FrameHashCache* cache = nullptr, RenderTicketPriority priority = RenderTicketPriority::kNormal, bool texture_only = false);
/**
* @brief Asynchronously generate a chunk of audio
*
* The ticket from this function will return a SampleBufferPtr - the rendered audio.
*
* Setting `prioritize` to TRUE puts this ticket at the top of the queue. Leaving it as FALSE
* appends it to the bottom.
*
* This function is thread-safe.
*/
RenderTicketPtr RenderAudio(ViewerOutput* viewer, const TimeRange& r, const AudioParams& params, RenderMode::Mode mode, bool generate_waveforms, bool prioritize = false);
RenderTicketPtr RenderAudio(ViewerOutput *viewer, const TimeRange& r, RenderMode::Mode mode, bool generate_waveforms, bool prioritize = false);
RenderTicketPtr RenderAudio(ViewerOutput* viewer, const TimeRange& r, const AudioParams& params, RenderMode::Mode mode, bool generate_waveforms, RenderTicketPriority priority = RenderTicketPriority::kNormal);
RenderTicketPtr RenderAudio(ViewerOutput *viewer, const TimeRange& r, RenderMode::Mode mode, bool generate_waveforms, RenderTicketPriority priority = RenderTicketPriority::kNormal);
RenderTicketPtr SaveFrameToCache(FrameHashCache* cache, FramePtr frame, const QByteArray& hash, bool prioritize = false);
RenderTicketPtr SaveFrameToCache(FrameHashCache* cache, FramePtr frame, const QByteArray& hash, RenderTicketPriority priority = RenderTicketPriority::kNormal);
virtual void RunTicket(RenderTicketPtr ticket) const override;
app/widget/viewer/viewer.cpp
+8 -8
View File
@@ -546,7 +546,7 @@ void ViewerWidget::QueueNextAudioBuffer()
RenderTicketWatcher *watcher = new RenderTicketWatcher(this);
connect(watcher, &RenderTicketWatcher::Finished, this, &ViewerWidget::ReceivedAudioBufferForPlayback);
audio_playback_queue_.push_back(watcher);
watcher->SetTicket(auto_cacher_.GetRangeOfAudio(TimeRange(audio_playback_queue_time_, queue_end), true));
watcher->SetTicket(auto_cacher_.GetRangeOfAudio(TimeRange(audio_playback_queue_time_, queue_end), RenderTicketPriority::kHigh));
audio_playback_queue_time_ = queue_end;
}
@@ -694,7 +694,7 @@ void ViewerWidget::UpdateTextureFromNode()
ClearVideoAutoCacherQueue();
}
watcher->SetTicket(GetFrame(time, true));
watcher->SetTicket(GetFrame(time, RenderTicketPriority::kHigh));
} else {
// There is definitely no frame here, we can immediately flip to showing nothing
nonqueue_watchers_.clear();
@@ -769,7 +769,7 @@ void ViewerWidget::PlayInternal(int speed, bool in_to_out_only)
for (int i=0; i<prequeue_length_; i++) {
playback_queue_next_frame_ -= playback_speed_;
RequestNextFrameForQueue(true, false);
RequestNextFrameForQueue(RenderTicketPriority::kHigh, false);
}
playback_queue_next_frame_ = temp;
@@ -853,7 +853,7 @@ void ViewerWidget::PushScrubbedAudio()
RenderTicketWatcher *watcher = new RenderTicketWatcher();
connect(watcher, &RenderTicketWatcher::Finished, this, &ViewerWidget::ReceivedAudioBufferForScrubbing);
watcher->SetTicket(auto_cacher_.GetRangeOfAudio(TimeRange(GetTime(), GetTime() + interval), true));
watcher->SetTicket(auto_cacher_.GetRangeOfAudio(TimeRange(GetTime(), GetTime() + interval), RenderTicketPriority::kHigh));
}
}
}
@@ -907,7 +907,7 @@ void ViewerWidget::SetDisplayImage(QVariant frame)
}
}
void ViewerWidget::RequestNextFrameForQueue(bool prioritize, bool increment)
void ViewerWidget::RequestNextFrameForQueue(RenderTicketPriority priority, bool increment)
{
rational next_time = Timecode::timestamp_to_time(playback_queue_next_frame_,
timebase());
@@ -921,11 +921,11 @@ void ViewerWidget::RequestNextFrameForQueue(bool prioritize, bool increment)
watcher->setProperty("time", QVariant::fromValue(next_time));
connect(watcher, &RenderTicketWatcher::Finished, this, &ViewerWidget::RendererGeneratedFrameForQueue);
queue_watchers_.append(watcher);
watcher->SetTicket(GetFrame(next_time, prioritize));
watcher->SetTicket(GetFrame(next_time, priority));
}
}
RenderTicketPtr ViewerWidget::GetFrame(const rational &t, bool prioritize)
RenderTicketPtr ViewerWidget::GetFrame(const rational &t, RenderTicketPriority priority)
{
QByteArray cached_hash = GetConnectedNode()->video_frame_cache()->GetHash(t);
@@ -933,7 +933,7 @@ RenderTicketPtr ViewerWidget::GetFrame(const rational &t, bool prioritize)
if (cached_hash.isEmpty() || !QFileInfo::exists(cache_fn)) {
// Frame hasn't been cached, start render job
return auto_cacher_.GetSingleFrame(t, prioritize);
return auto_cacher_.GetSingleFrame(t, priority);
} else {
// Frame has been cached, grab the frame
RenderTicketPtr ticket = std::make_shared<RenderTicket>();
app/widget/viewer/viewer.h
+2 -2
View File
@@ -190,9 +190,9 @@ private:
void SetDisplayImage(QVariant frame);
void RequestNextFrameForQueue(bool prioritize = false, bool increment = true);
void RequestNextFrameForQueue(RenderTicketPriority priority = RenderTicketPriority::kNormal, bool increment = true);
RenderTicketPtr GetFrame(const rational& t, bool prioritize);
RenderTicketPtr GetFrame(const rational& t, RenderTicketPriority priority);
void FinishPlayPreprocess();