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

Squashed commit of the following:

Browse Source 
commit dec7ca6b96c58decf2c5e5194b665fa2342951b2
Author: itsmattkc <34096995+itsmattkc@users.noreply.github.com>
Date:   Wed Feb 8 12:32:12 2023 -0800

    moved previewautocacher to rendermanager

commit d289d74d82c3911f3fdaa707abe9994c7363594d
Merge: a8a049a28 70d34c674
Author: itsmattkc <34096995+itsmattkc@users.noreply.github.com>
Date:   Wed Feb 8 12:15:31 2023 -0800

    Merge branch 'master' into move-cacher-to-renderman

commit a8a049a2857c438cbab0f1ab21e3299fdfbf1fa1
Author: itsmattkc <34096995+itsmattkc@users.noreply.github.com>
Date:   Wed Feb 8 11:18:25 2023 -0800

    initial work
This commit is contained in:
itsmattkc
2023-02-08 12:40:19 -08:00
parent 70d34c674b
commit 5da72e4d35
11 changed files with 118 additions and 102 deletions
Download Patch File Download Diff File Expand all files Collapse all files
app/render/previewautocacher.cpp
+48 -47
View File
@@ -28,12 +28,13 @@
#include "node/inputdragger.h"
#include "node/project/project.h"
#include "render/diskmanager.h"
#include "render/rendermanager.h"
namespace olive {
PreviewAutoCacher::PreviewAutoCacher(QObject *parent) :
QObject(parent),
viewer_node_(nullptr),
project_(nullptr),
use_custom_range_(false),
pause_renders_(false),
pause_thumbnails_(false),
@@ -61,15 +62,15 @@ PreviewAutoCacher::PreviewAutoCacher(QObject *parent) :
PreviewAutoCacher::~PreviewAutoCacher()
{
// Ensure everything is cleaned up appropriately
SetViewerNode(nullptr);
SetProject(nullptr);
}
RenderTicketPtr PreviewAutoCacher::GetSingleFrame(const rational &t, bool dry)
RenderTicketPtr PreviewAutoCacher::GetSingleFrame(ViewerOutput *viewer, const rational &t, bool dry)
{
return GetSingleFrame(viewer_node_->GetConnectedTextureOutput(), t, dry);
return GetSingleFrame(viewer->GetConnectedTextureOutput(), viewer, t, dry);
}
RenderTicketPtr PreviewAutoCacher::GetSingleFrame(Node *n, const rational &t, bool dry)
RenderTicketPtr PreviewAutoCacher::GetSingleFrame(Node *n, ViewerOutput *viewer, const rational &t, bool dry)
{
// If we have a single frame render queued (but not yet sent to the RenderManager), cancel it now
CancelQueuedSingleFrameRender();
@@ -80,6 +81,7 @@ RenderTicketPtr PreviewAutoCacher::GetSingleFrame(Node *n, const rational &t, bo
sfr->setProperty("time", QVariant::fromValue(t));
sfr->setProperty("dry", dry);
sfr->setProperty("node", Node::PtrToValue(n));
sfr->setProperty("viewer", Node::PtrToValue(viewer));
// Queue it and try to render
single_frame_render_ = sfr;
@@ -88,9 +90,10 @@ RenderTicketPtr PreviewAutoCacher::GetSingleFrame(Node *n, const rational &t, bo
return sfr;
}
RenderTicketPtr PreviewAutoCacher::GetRangeOfAudio(TimeRange range)
RenderTicketPtr PreviewAutoCacher::GetRangeOfAudio(ViewerOutput *viewer, TimeRange range)
{
return RenderAudio(copied_viewer_node_->GetConnectedSampleOutput(), range, nullptr);
Node *copy = copier_->GetCopy(viewer->GetConnectedSampleOutput());
return RenderAudio(copy, viewer, range, nullptr);
}
void PreviewAutoCacher::ClearSingleFrameRenders()
@@ -105,22 +108,22 @@ void PreviewAutoCacher::ClearSingleFrameRenders()
}
}
void PreviewAutoCacher::VideoInvalidatedFromCache(const TimeRange &range)
void PreviewAutoCacher::VideoInvalidatedFromCache(ViewerOutput *context, const TimeRange &range)
{
PlaybackCache *cache = static_cast<PlaybackCache*>(sender());
cache->ClearRequestRange(range);
VideoInvalidatedFromNode(cache, range);
VideoInvalidatedFromNode(context, cache, range);
}
void PreviewAutoCacher::AudioInvalidatedFromCache(const TimeRange &range)
void PreviewAutoCacher::AudioInvalidatedFromCache(ViewerOutput *context, const TimeRange &range)
{
PlaybackCache *cache = static_cast<PlaybackCache*>(sender());
cache->ClearRequestRange(range);
AudioInvalidatedFromNode(cache, range);
AudioInvalidatedFromNode(context, cache, range);
}
void PreviewAutoCacher::CancelForCache()
@@ -341,39 +344,39 @@ void PreviewAutoCacher::StartCachingRange(const TimeRange &range, TimeRangeList
tracker->insert(range, copier_->GetGraphChangeTime());
}
void PreviewAutoCacher::StartCachingVideoRange(PlaybackCache *cache, const TimeRange &range)
void PreviewAutoCacher::StartCachingVideoRange(ViewerOutput *context, PlaybackCache *cache, const TimeRange &range)
{
Node *node = cache->parent();
rational using_tb;
if (ThumbnailCache *thumbs = dynamic_cast<ThumbnailCache*>(cache)) {
using_tb = thumbs->GetTimebase();
} else {
using_tb = viewer_node_->GetVideoParams().frame_rate_as_time_base();
using_tb = context->GetVideoParams().frame_rate_as_time_base();
}
cache->ClearRequestRange(range);
TimeRangeListFrameIterator iterator({range}, using_tb);
pending_video_jobs_.push_back({node, cache, range, iterator});
pending_video_jobs_.push_back({node, context, cache, range, iterator});
video_cache_data_[cache].job_tracker.insert(TimeRange(iterator.Snap(range.in()), range.out()), copier_->GetGraphChangeTime());
TryRender();
}
void PreviewAutoCacher::StartCachingAudioRange(PlaybackCache *cache, const TimeRange &range)
void PreviewAutoCacher::StartCachingAudioRange(ViewerOutput *context, PlaybackCache *cache, const TimeRange &range)
{
Node *node = cache->parent();
cache->ClearRequestRange(range);
pending_audio_jobs_.push_back({node, cache, range});
pending_audio_jobs_.push_back({node, context, cache, range});
audio_cache_data_[cache].job_tracker.insert(range, copier_->GetGraphChangeTime());
TryRender();
}
void PreviewAutoCacher::VideoInvalidatedFromNode(PlaybackCache *cache, const TimeRange &range)
void PreviewAutoCacher::VideoInvalidatedFromNode(ViewerOutput *context, PlaybackCache *cache, const TimeRange &range)
{
// Ignore render requests if no video is present
if (!viewer_node_ || !viewer_node_->GetVideoParams().is_valid()) {
if (!context || !context->GetVideoParams().is_valid()) {
return;
}
@@ -385,14 +388,14 @@ void PreviewAutoCacher::VideoInvalidatedFromNode(PlaybackCache *cache, const Tim
// If auto-cache is enabled and a slider is not being dragged, queue up to hash these frames
if (!NodeInputDragger::IsInputBeingDragged()) {
StartCachingVideoRange(cache, range);
StartCachingVideoRange(context, cache, range);
}
}
void PreviewAutoCacher::AudioInvalidatedFromNode(PlaybackCache *cache, const TimeRange &range)
void PreviewAutoCacher::AudioInvalidatedFromNode(ViewerOutput *context, PlaybackCache *cache, const TimeRange &range)
{
// Ignore render requests if no video is present
if (!viewer_node_ || !viewer_node_->GetAudioParams().is_valid()) {
if (!context || !context->GetAudioParams().is_valid()) {
return;
}
@@ -403,7 +406,7 @@ void PreviewAutoCacher::AudioInvalidatedFromNode(PlaybackCache *cache, const Tim
cache->ClearRequestRange(range);
// If we're auto-caching audio or require realtime waveforms, we'll have to render this
StartCachingAudioRange(cache, range);
StartCachingAudioRange(context, cache, range);
}
void PreviewAutoCacher::SetPlayhead(const rational &playhead)
@@ -492,6 +495,7 @@ void PreviewAutoCacher::TryRender()
if (copy) {
RenderTicketWatcher *watcher = RenderFrame(copy,
Node::ValueToPtr<ViewerOutput>(t->property("viewer")),
t->property("time").value<rational>(),
nullptr,
t->property("dry").toBool());
@@ -515,7 +519,7 @@ void PreviewAutoCacher::TryRender()
// Queue next frames
rational t;
while (running_video_tasks_.size() < max_tasks && d.iterator.GetNext(&t)) {
RenderFrame(copy, t, d.cache, false);
RenderFrame(copy, d.context, t, d.cache, false);
emit SignalCacheProxyTaskProgress(double(d.iterator.frame_index()) / double(d.iterator.size()));
@@ -556,7 +560,7 @@ void PreviewAutoCacher::TryRender()
}
}
RenderAudio(copy, use_range, d.cache);
RenderAudio(copy, d.context, use_range, d.cache);
} else {
qCritical() << "Failed to find node copy for audio job";
}
@@ -568,7 +572,7 @@ void PreviewAutoCacher::TryRender()
}
}
RenderTicketWatcher* PreviewAutoCacher::RenderFrame(Node *node, const rational& time, PlaybackCache *cache, bool dry)
RenderTicketWatcher* PreviewAutoCacher::RenderFrame(Node *node, ViewerOutput *context, const rational& time, PlaybackCache *cache, bool dry)
{
RenderTicketWatcher* watcher = new RenderTicketWatcher();
watcher->setProperty("job", QVariant::fromValue(copier_->GetLastUpdateTime()));
@@ -579,8 +583,8 @@ RenderTicketWatcher* PreviewAutoCacher::RenderFrame(Node *node, const rational&
running_video_tasks_.append(watcher);
RenderManager::RenderVideoParams rvp(node,
copied_viewer_node_->GetVideoParams(),
copied_viewer_node_->GetAudioParams(),
context->GetVideoParams(),
context->GetAudioParams(),
time,
copied_color_manager_,
RenderMode::kOffline);
@@ -591,7 +595,7 @@ RenderTicketWatcher* PreviewAutoCacher::RenderFrame(Node *node, const rational&
rvp.force_color_output = display_color_processor_;
rvp.force_format = PixelFormat::U8;
} else {
frame_cache->SetTimebase(viewer_node_->GetVideoParams().frame_rate_as_time_base());
frame_cache->SetTimebase(context->GetVideoParams().frame_rate_as_time_base());
}
rvp.AddCache(frame_cache);
@@ -610,7 +614,7 @@ RenderTicketWatcher* PreviewAutoCacher::RenderFrame(Node *node, const rational&
return watcher;
}
RenderTicketPtr PreviewAutoCacher::RenderAudio(Node *node, const TimeRange &r, PlaybackCache *cache)
RenderTicketPtr PreviewAutoCacher::RenderAudio(Node *node, ViewerOutput *context, const TimeRange &r, PlaybackCache *cache)
{
RenderTicketWatcher* watcher = new RenderTicketWatcher();
watcher->setProperty("job", QVariant::fromValue(copier_->GetLastUpdateTime()));
@@ -622,7 +626,7 @@ RenderTicketPtr PreviewAutoCacher::RenderAudio(Node *node, const TimeRange &r, P
RenderManager::RenderAudioParams rap(node,
r,
copied_viewer_node_->GetAudioParams(),
context->GetAudioParams(),
RenderMode::kOffline);
rap.generate_waveforms = dynamic_cast<AudioWaveformCache*>(cache);
@@ -638,12 +642,13 @@ void PreviewAutoCacher::ConformFinished()
// Got an audio conform, requeue all the audio currently needing a conform
last_conform_task_.Acquire();
for (auto it=audio_cache_data_.begin(); it!=audio_cache_data_.end(); it++) {
qDebug() << "CONFORM RESPONSE TEMPORARILY DISABLED";
/*for (auto it=audio_cache_data_.begin(); it!=audio_cache_data_.end(); it++) {
foreach (const TimeRange &range, it.value().needs_conform) {
it.key()->Request(range);
}
it.value().needs_conform.clear();
}
}*/
}
void PreviewAutoCacher::CacheProxyTaskCancelled()
@@ -653,22 +658,22 @@ void PreviewAutoCacher::CacheProxyTaskCancelled()
TryRender();
}
void PreviewAutoCacher::ForceCacheRange(const TimeRange &range)
void PreviewAutoCacher::ForceCacheRange(ViewerOutput *context, const TimeRange &range)
{
use_custom_range_ = true;
custom_autocache_range_ = range;
// Re-hash these frames and start rendering
StartCachingVideoRange(viewer_node_->video_frame_cache(), range);
StartCachingVideoRange(context, context->video_frame_cache(), range);
}
void PreviewAutoCacher::SetViewerNode(ViewerOutput *viewer_node)
void PreviewAutoCacher::SetProject(Project *project)
{
if (viewer_node_ == viewer_node) {
if (project_ == project) {
return;
}
if (viewer_node_) {
if (project_) {
// We must wait for any jobs to finish because they'll be using our copied graph and we're
// about to destroy it
@@ -702,7 +707,6 @@ void PreviewAutoCacher::SetViewerNode(ViewerOutput *viewer_node)
// Delete all of our copied nodes
copier_->SetProject(nullptr);
copied_viewer_node_ = nullptr;
// Ensure all cache data is cleared
video_cache_data_.clear();
@@ -712,23 +716,20 @@ void PreviewAutoCacher::SetViewerNode(ViewerOutput *viewer_node)
multicam_ = nullptr;
}
viewer_node_ = viewer_node;
project_ = project;
if (viewer_node_) {
if (project_) {
// Copy graph (this should always be a Project)
Project* graph = static_cast<Project*>(viewer_node_->parent());
SetRendersPaused(true);
copier_->SetProject(graph);
copier_->SetProject(project_);
for (int i=0; i<graph->nodes().size(); i++) {
graph->nodes().at(i)->ConnectedToPreviewEvent();
for (int i=0; i<project_->nodes().size(); i++) {
project_->nodes().at(i)->ConnectedToPreviewEvent();
}
// Find copied viewer node
copied_viewer_node_ = copier_->GetCopy(viewer_node_);
copied_color_manager_ = copier_->GetCopy(graph->color_manager());
copied_color_manager_ = copier_->GetCopy(project_->color_manager());
SetRendersPaused(false);
}