Mike-Solar
bb40b4923e
Automated with clang-tidy readability-identifier-naming (config added to .clang-tidy) plus scripted passes, per the updated rules now documented in CONTRIBUTING.md: - types (class/struct/enum/alias/template params): PascalCase - functions, variables, members: snake_case (incl. rational -> Rational) - private/protected members: trailing underscore; static member variables likewise (instance_, available_themes_) - constants and enum values: snake_case (kLinear -> k_linear, F32P -> f32p); ALL_CAPS reserved for macros - macros: OAK_ prefix (OLIVE_ADD_TEST/OLIVE_ASSERT/OLIVE_CONFIG -> OAK_ADD_TEST/OAK_ASSERT/OAK_CONFIG, GL_PREAMBLE -> OAK_GL_PREAMBLE, include guards -> OAK_*) - file names: all lowercase (Current/Plugin/OliveHost/OliveClip/ OlivePluginInstance -> current/plugin/olivehost/oliveclip/ oliveplugininstance) - getters share the member name sans underscore, setters set_foo() - Qt and third-party (OpenFX) virtual overrides and framework callbacks keep their original names (exempt in .clang-tidy) Manual follow-ups required where automation could not reach: - string-based QMetaObject/SIGNAL/SLOT references updated to renamed methods (AddTask, CreatedFile, DeleteSpecificFile, moveSelectionUp, ...) - macro bodies referencing renamed methods (OLIVE_CONFIG, NODE_DEFAULT_DESTRUCTOR, MANAGEDDISPLAYWIDGET_*) - self-shadowing locals renamed where signals/methods became same-named (size_changed, worker_count, selected_items, import param, filters) - third_party OFX member/namespace usages restored (OFX::Host::*, _created, _clipPrefsDirty, createInstance, clearPersistentMessage) - STL protocol aliases restored (const_iterator) with .clang-tidy ignore rules; qHash overloads restored Full build and test suite pass: ctest 4/4, ~1960 gtest cases green.
897 lines
26 KiB
C++
897 lines
26 KiB
C++
/***
|
|
|
|
Olive - Non-Linear Video Editor
|
|
Copyright (C) 2022 Olive Team
|
|
Modifications Copyright (C) 2025 mikesolar
|
|
|
|
This program is free software: you can redistribute it and/or modify
|
|
it under the terms of the GNU General Public License as published by
|
|
the Free Software Foundation, either version 3 of the License, or
|
|
(at your option) any later version.
|
|
|
|
This program is distributed in the hope that it will be useful,
|
|
but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
GNU General Public License for more details.
|
|
|
|
You should have received a copy of the GNU General Public License
|
|
along with this program. If not, see <http://www.gnu.org/licenses/>.
|
|
|
|
***/
|
|
|
|
#include "renderprocessor.h"
|
|
|
|
#include <QFileInfo>
|
|
#include <QOpenGLContext>
|
|
#include <QThreadStorage>
|
|
#include <QVector2D>
|
|
#include <QVector3D>
|
|
#include <QVector4D>
|
|
|
|
#include "audio/audioprocessor.h"
|
|
#include "node/block/clip/clip.h"
|
|
#include "node/block/transition/transition.h"
|
|
#include "node/project.h"
|
|
#include "rendermanager.h"
|
|
#include "render/plugin/pluginrenderer.h"
|
|
#include "pluginSupport/oliveclip.h"
|
|
#include "pluginSupport/olivehost.h"
|
|
#include "render/ipc/frameslotpool.h"
|
|
|
|
namespace olive
|
|
{
|
|
|
|
#define super NodeTraverser
|
|
|
|
RenderProcessor::RenderProcessor(RenderTicketPtr ticket, Renderer *render_ctx,
|
|
DecoderCache *decoder_cache,
|
|
ShaderCache *shader_cache)
|
|
: ticket_(ticket)
|
|
, render_ctx_(render_ctx)
|
|
, decoder_cache_(decoder_cache)
|
|
, shader_cache_(shader_cache)
|
|
{
|
|
}
|
|
|
|
TexturePtr RenderProcessor::generate_texture(const Rational &time,
|
|
const Rational &frame_length)
|
|
{
|
|
TimeRange range = TimeRange(time, time + frame_length);
|
|
|
|
NodeValueTable table;
|
|
if (Node *node = QtUtils::value_to_ptr<Node>(ticket_->property("node"))) {
|
|
table = generate_table(node, range);
|
|
}
|
|
|
|
NodeValue tex_val = table.get(NodeValue::k_texture);
|
|
|
|
resolve_jobs(tex_val);
|
|
|
|
return tex_val.to_texture();
|
|
}
|
|
|
|
FramePtr RenderProcessor::generate_frame(TexturePtr texture,
|
|
const Rational &time)
|
|
{
|
|
// Set up output frame parameters
|
|
VideoParams frame_params = get_cache_video_params();
|
|
|
|
QSize frame_size = ticket_->property("size").value<QSize>();
|
|
if (!frame_size.isNull()) {
|
|
frame_params.set_width(frame_size.width());
|
|
frame_params.set_height(frame_size.height());
|
|
}
|
|
|
|
PixelFormat frame_format =
|
|
static_cast<PixelFormat::Format>(ticket_->property("format").toInt());
|
|
if (frame_format != PixelFormat::invalid) {
|
|
frame_params.set_format(frame_format);
|
|
}
|
|
|
|
int force_channel_count = ticket_->property("channelcount").toInt();
|
|
if (force_channel_count != 0) {
|
|
frame_params.set_channel_count(force_channel_count);
|
|
} else {
|
|
frame_params.set_channel_count(texture ?
|
|
texture->channel_count() :
|
|
VideoParams::k_rgba_channel_count);
|
|
}
|
|
|
|
FramePtr frame = Frame::create();
|
|
frame->set_timestamp(time);
|
|
frame->set_video_params(frame_params);
|
|
frame->allocate();
|
|
|
|
if (!texture) {
|
|
// Blank frame out
|
|
memset(frame->data(), 0, frame->allocated_size());
|
|
} else {
|
|
// Dump texture contents to frame
|
|
ColorProcessorPtr output_color_transform =
|
|
ticket_->property("coloroutput").value<ColorProcessorPtr>();
|
|
const VideoParams &tex_params = texture->params();
|
|
|
|
if (output_color_transform) {
|
|
TexturePtr transform_tex = render_ctx_->create_texture(tex_params);
|
|
ColorTransformJob job;
|
|
|
|
job.set_color_processor(output_color_transform);
|
|
job.set_input_texture(texture);
|
|
job.set_input_alpha_association(
|
|
OAK_CONFIG("ReassocLinToNonLin").toBool() ? k_alpha_associated :
|
|
k_alpha_none);
|
|
|
|
render_ctx_->blit_color_managed(job, transform_tex.get());
|
|
|
|
texture = transform_tex;
|
|
}
|
|
|
|
if (tex_params.effective_width() != frame_params.effective_width() ||
|
|
tex_params.effective_height() != frame_params.effective_height() ||
|
|
tex_params.format() != frame_params.format()) {
|
|
TexturePtr blit_tex = render_ctx_->create_texture(frame_params);
|
|
|
|
QMatrix4x4 matrix = ticket_->property("matrix").value<QMatrix4x4>();
|
|
|
|
// No color transform, just blit
|
|
ShaderJob job;
|
|
job.insert(QStringLiteral("ove_maintex"),
|
|
NodeValue(NodeValue::k_texture,
|
|
QVariant::fromValue(texture)));
|
|
job.insert(QStringLiteral("ove_mvpmat"),
|
|
NodeValue(NodeValue::k_matrix, matrix));
|
|
|
|
render_ctx_->blit_to_texture(render_ctx_->get_default_shader(), job,
|
|
blit_tex.get());
|
|
|
|
// Replace texture that we're going to download in the next step
|
|
texture = blit_tex;
|
|
}
|
|
|
|
render_ctx_->download_from_texture(texture->id(), texture->params(),
|
|
frame->data(),
|
|
frame->linesize_pixels());
|
|
if (output_color_transform) {
|
|
VideoParams display_params = frame->video_params();
|
|
display_params.set_colorspace(
|
|
QStringLiteral("display:") +
|
|
QString::fromUtf8(output_color_transform->id()));
|
|
frame->set_video_params(display_params);
|
|
}
|
|
}
|
|
|
|
return frame;
|
|
}
|
|
|
|
void RenderProcessor::run()
|
|
{
|
|
// Depending on the render ticket type, start a job
|
|
RenderManager::TicketType type =
|
|
ticket_->property("type").value<RenderManager::TicketType>();
|
|
|
|
set_cancel_pointer(ticket_->get_cancel_atom());
|
|
|
|
VideoParams params = ticket_->property("vparam").value<VideoParams>();
|
|
params.set_format(PixelFormat::f32);
|
|
set_cache_video_params(params);
|
|
set_cache_audio_params(ticket_->property("aparam").value<AudioParams>());
|
|
|
|
if (is_cancelled()) {
|
|
ticket_->finish();
|
|
return;
|
|
}
|
|
|
|
// if is a plugin
|
|
/*Node *node=ticket_->property("node").value<Node*>();
|
|
if (node && node->getPlugin()) {
|
|
std::shared_ptr<OFX::Host::ImageEffect::ImageEffectPlugin> plugin
|
|
= node->getPlugin();
|
|
std::unique_ptr<OFX::Host::ImageEffect::Instance> instance(plugin->createInstance(kOfxImageEffectContextFilter, NULL));
|
|
|
|
|
|
}
|
|
*/
|
|
|
|
switch (type) {
|
|
case RenderManager::k_type_video: {
|
|
Rational time = ticket_->property("time").value<Rational>();
|
|
|
|
Rational frame_length = get_cache_video_params().frame_rate_as_time_base();
|
|
if (get_cache_video_params().interlacing() !=
|
|
VideoParams::k_interlace_none) {
|
|
frame_length /= 2;
|
|
}
|
|
|
|
TexturePtr texture = generate_texture(time, frame_length);
|
|
|
|
if (!render_ctx_) {
|
|
ticket_->finish();
|
|
} else {
|
|
if (get_cache_video_params().interlacing() !=
|
|
VideoParams::k_interlace_none) {
|
|
// Get next between frame and interlace it
|
|
TexturePtr top = texture;
|
|
TexturePtr bottom =
|
|
generate_texture(time + frame_length, frame_length);
|
|
|
|
if (get_cache_video_params().interlacing() ==
|
|
VideoParams::k_interlaced_bottom_first) {
|
|
std::swap(top, bottom);
|
|
}
|
|
|
|
texture = render_ctx_->interlace_texture(top, bottom,
|
|
get_cache_video_params());
|
|
}
|
|
|
|
if (heard_cancel()) {
|
|
// Finish cancelled ticket with nothing since we can't guarantee the frame we generated
|
|
// is actually "complete
|
|
ticket_->finish();
|
|
} else {
|
|
FramePtr frame;
|
|
QString cache = ticket_->property("cache").toString();
|
|
RenderManager::ReturnType return_type =
|
|
RenderManager::ReturnType(
|
|
ticket_->property("return").toInt());
|
|
|
|
if (return_type == RenderManager::k_frame || !cache.isEmpty()) {
|
|
// Convert to CPU frame
|
|
frame = generate_frame(texture, time);
|
|
|
|
// Save to cache if requested
|
|
if (!cache.isEmpty()) {
|
|
Rational timebase =
|
|
ticket_->property("cachetimebase").value<Rational>();
|
|
QUuid uuid =
|
|
ticket_->property("cacheid").value<QUuid>();
|
|
bool cache_result = FrameHashCache::save_cache_frame(
|
|
cache, uuid, time, timebase, frame);
|
|
ticket_->setProperty("cached", cache_result);
|
|
}
|
|
}
|
|
|
|
if (return_type == RenderManager::k_texture) {
|
|
// Return GPU texture
|
|
if (!texture) {
|
|
texture =
|
|
render_ctx_->create_texture(get_cache_video_params());
|
|
render_ctx_->clear_destination(texture.get());
|
|
}
|
|
|
|
render_ctx_->flush();
|
|
ticket_->finish(QVariant::fromValue(texture));
|
|
} else {
|
|
ticket_->finish(QVariant::fromValue(frame));
|
|
}
|
|
}
|
|
}
|
|
break;
|
|
}
|
|
case RenderManager::k_type_audio: {
|
|
TimeRange time = ticket_->property("time").value<TimeRange>();
|
|
|
|
NodeValueTable table;
|
|
if (Node *node = QtUtils::value_to_ptr<Node>(ticket_->property("node"))) {
|
|
table = generate_table(node, time);
|
|
}
|
|
|
|
NodeValue sample_val = table.get(NodeValue::k_samples);
|
|
|
|
resolve_jobs(sample_val);
|
|
|
|
SampleBuffer samples = sample_val.to_samples();
|
|
if (samples.is_allocated()) {
|
|
if (ticket_->property("clamp").toBool() && !is_cancelled()) {
|
|
samples.clamp();
|
|
}
|
|
|
|
if (ticket_->property("enablewaveforms").toBool() &&
|
|
!is_cancelled()) {
|
|
AudioVisualWaveform vis;
|
|
vis.set_channel_count(samples.audio_params().channel_count());
|
|
vis.overwrite_samples(samples,
|
|
samples.audio_params().sample_rate());
|
|
ticket_->setProperty("waveform", QVariant::fromValue(vis));
|
|
}
|
|
}
|
|
|
|
if (heard_cancel()) {
|
|
ticket_->finish();
|
|
} else {
|
|
ticket_->finish(QVariant::fromValue(samples));
|
|
}
|
|
break;
|
|
}
|
|
default:
|
|
// Fail
|
|
ticket_->finish();
|
|
}
|
|
}
|
|
|
|
DecoderPtr
|
|
RenderProcessor::resolve_decoder_from_input(const QString &decoder_id,
|
|
const Decoder::CodecStream &stream)
|
|
{
|
|
if (!stream.is_valid()) {
|
|
qWarning() << "Attempted to resolve the decoder of a null stream";
|
|
return nullptr;
|
|
}
|
|
|
|
if (!decoder_cache_) {
|
|
qWarning() << "Cannot resolve decoder for" << stream.filename()
|
|
<< "without a decoder cache";
|
|
return nullptr;
|
|
}
|
|
|
|
QMutexLocker locker(decoder_cache_->mutex());
|
|
|
|
DecoderPair decoder = decoder_cache_->value(stream);
|
|
|
|
qint64 file_last_modified =
|
|
QFileInfo(stream.filename()).lastModified().toMSecsSinceEpoch();
|
|
|
|
DecoderPtr dec = nullptr;
|
|
|
|
if (decoder.decoder && decoder.last_modified == file_last_modified) {
|
|
dec = decoder.decoder;
|
|
} else {
|
|
// No decoder
|
|
decoder.decoder = dec = Decoder::create_from_id(decoder_id);
|
|
decoder.last_modified = file_last_modified;
|
|
decoder_cache_->insert(stream, decoder);
|
|
locker.unlock();
|
|
|
|
if (!dec->open(stream)) {
|
|
qWarning() << "Failed to open decoder for" << stream.filename()
|
|
<< "::" << stream.stream();
|
|
return nullptr;
|
|
}
|
|
|
|
if (!render_ctx_) {
|
|
// Assume dry run and increment access time
|
|
decoder.decoder->increment_access_time(
|
|
RenderManager::k_dry_run_interval.to_double() * 1000);
|
|
}
|
|
}
|
|
|
|
return dec;
|
|
}
|
|
|
|
NodeValueDatabase RenderProcessor::generate_database(const Node *node,
|
|
const TimeRange &range)
|
|
{
|
|
NodeValueDatabase db = super::generate_database(node, range);
|
|
|
|
if (const MultiCamNode *multicam =
|
|
dynamic_cast<const MultiCamNode *>(node)) {
|
|
if (QtUtils::value_to_ptr<MultiCamNode>(ticket_->property("multicam")) ==
|
|
multicam) {
|
|
int sz = multicam->get_source_count();
|
|
QVector<TexturePtr> multicam_tex(sz);
|
|
for (int i = 0; i < sz; i++) {
|
|
NodeValueTable t =
|
|
generate_table(multicam->get_connected_render_output(
|
|
multicam->k_sources_input, i),
|
|
range, multicam);
|
|
NodeValue val = generate_row_value_element(
|
|
multicam, multicam->k_sources_input, i, &t, range);
|
|
resolve_jobs(val);
|
|
|
|
multicam_tex[i] = val.to_texture();
|
|
}
|
|
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);
|
|
p.run();
|
|
}
|
|
|
|
void RenderProcessor::process_video_footage(TexturePtr destination,
|
|
const FootageJob *stream,
|
|
const Rational &input_time)
|
|
{
|
|
if (ticket_->property("type").value<RenderManager::TicketType>() !=
|
|
RenderManager::k_type_video) {
|
|
// Video cannot contribute to audio, so we do nothing here
|
|
return;
|
|
}
|
|
|
|
// Check the still frame cache. On large frames such as high resolution still images, uploading
|
|
// and color managing them for every frame is a waste of time, so we implement a small cache here
|
|
// to optimize such a situation
|
|
VideoParams stream_data = stream->video_params();
|
|
|
|
ColorManager *color_manager =
|
|
QtUtils::value_to_ptr<ColorManager>(ticket_->property("colormanager"));
|
|
|
|
QString using_colorspace = stream_data.colorspace();
|
|
|
|
if (using_colorspace.isEmpty() && color_manager) {
|
|
using_colorspace = color_manager->get_default_input_color_space();
|
|
}
|
|
|
|
if (using_colorspace.isEmpty()) {
|
|
qWarning()
|
|
<< "RenderProcessor ProcessVideoFootage: no input colorspace available";
|
|
}
|
|
|
|
auto blit_color_managed = [&](const TexturePtr &unmanaged_texture,
|
|
const VideoParams &texture_params) {
|
|
if (!render_ctx_ || !unmanaged_texture || is_cancelled()) {
|
|
return;
|
|
}
|
|
|
|
// We convert to our rendering pixel format, since that will always be float-based which
|
|
// is necessary for correct color conversion
|
|
ColorProcessorPtr processor =
|
|
ColorProcessor::create(color_manager, using_colorspace,
|
|
color_manager->get_reference_color_space());
|
|
|
|
ColorTransformJob job;
|
|
job.set_color_processor(processor);
|
|
job.set_input_texture(unmanaged_texture);
|
|
|
|
if (texture_params.channel_count() != VideoParams::k_rgba_channel_count ||
|
|
texture_params.colorspace() ==
|
|
color_manager->get_reference_color_space()) {
|
|
job.set_input_alpha_association(k_alpha_none);
|
|
} else if (texture_params.premultiplied_alpha()) {
|
|
job.set_input_alpha_association(k_alpha_associated);
|
|
} else {
|
|
job.set_input_alpha_association(k_alpha_unassociated);
|
|
}
|
|
|
|
render_ctx_->blit_color_managed(job, destination.get());
|
|
// macOS TBDR: ensure tile writeback completes before the texture
|
|
// is read back in a potentially different shared OpenGL context.
|
|
render_ctx_->flush();
|
|
};
|
|
|
|
auto *input_pool = QtUtils::value_to_ptr<ipc::FrameSlotPool>(
|
|
ticket_->property("ipc_input_pool"));
|
|
int input_slot = -1;
|
|
const QVariantList input_slots =
|
|
ticket_->property("ipc_input_slots").toList();
|
|
if (!input_slots.isEmpty()) {
|
|
const QVariant cursor_value =
|
|
ticket_->property("ipc_input_slot_cursor");
|
|
const int cursor = cursor_value.isValid() ? cursor_value.toInt() : 0;
|
|
if (cursor >= 0 && cursor < input_slots.size()) {
|
|
input_slot = input_slots.at(cursor).toInt();
|
|
ticket_->setProperty("ipc_input_slot_cursor", cursor + 1);
|
|
}
|
|
} else {
|
|
const QVariant input_slot_value = ticket_->property("ipc_input_slot");
|
|
input_slot = input_slot_value.isValid() ? input_slot_value.toInt() : -1;
|
|
}
|
|
if (render_ctx_ && input_pool && input_slot >= 0) {
|
|
if (input_slot >= int(input_pool->slot_count())) {
|
|
qWarning()
|
|
<< "RenderProcessor received out-of-range IPC input frame slot"
|
|
<< input_slot;
|
|
return;
|
|
}
|
|
|
|
const ipc::FrameSlotMeta *meta = input_pool->meta(uint32_t(input_slot));
|
|
if (meta && meta->width > 0 && meta->height > 0 &&
|
|
meta->data_size > 0 &&
|
|
meta->data_size <= int(input_pool->slot_data_bytes())) {
|
|
VideoParams input_params = stream_data;
|
|
input_params.set_width(meta->width);
|
|
input_params.set_height(meta->height);
|
|
input_params.set_format(PixelFormat::Format(meta->format));
|
|
input_params.set_channel_count(meta->channel_count);
|
|
// The decoder may leave depth at 0 for 2D frames, but the renderer
|
|
// needs depth >= 1 to compute image size and upload the texture.
|
|
if (input_params.depth() <= 0) {
|
|
input_params.set_depth(1);
|
|
}
|
|
|
|
// Prefer the colorspace that the main process used when decoding this
|
|
// frame. The FootageJob reconstructed in the worker may have stale or
|
|
// empty colorspace if the project snapshot was saved before stream
|
|
// metadata was fully resolved.
|
|
const QString ipc_colorspace = QString::fromUtf8(meta->colorspace);
|
|
if (!ipc_colorspace.isEmpty()) {
|
|
input_params.set_colorspace(ipc_colorspace);
|
|
using_colorspace = ipc_colorspace;
|
|
}
|
|
|
|
const int bytes_per_pixel = input_params.get_bytes_per_pixel();
|
|
const int linesize_pixels = bytes_per_pixel > 0 ?
|
|
meta->linesize / bytes_per_pixel :
|
|
input_params.effective_width();
|
|
|
|
const void *slot_data = input_pool->slot_data(uint32_t(input_slot));
|
|
TexturePtr unmanaged_texture = render_ctx_->create_texture(
|
|
input_params, slot_data, linesize_pixels);
|
|
|
|
blit_color_managed(unmanaged_texture, input_params);
|
|
return;
|
|
}
|
|
qWarning() << "RenderProcessor received invalid IPC input frame slot"
|
|
<< input_slot;
|
|
return;
|
|
}
|
|
|
|
if (!decoder_cache_) {
|
|
qWarning()
|
|
<< "RenderProcessor has no decoder cache or IPC input frame for"
|
|
<< stream->filename();
|
|
return;
|
|
}
|
|
|
|
const bool use_proxy =
|
|
static_cast<RenderMode::Mode>(ticket_->property("mode").toInt()) ==
|
|
RenderMode::k_offline &&
|
|
stream->has_proxy() && QFileInfo::exists(stream->proxy_filename());
|
|
const QString decode_filename = use_proxy ? stream->proxy_filename() :
|
|
stream->filename();
|
|
const QString decoder_id = use_proxy ? stream->proxy_decoder() :
|
|
stream->decoder();
|
|
const int stream_index = use_proxy ? stream->proxy_stream_index() :
|
|
stream_data.stream_index();
|
|
|
|
Decoder::CodecStream default_codec_stream(decode_filename, stream_index,
|
|
get_current_block());
|
|
|
|
DecoderPtr decoder = nullptr;
|
|
|
|
switch (stream_data.video_type()) {
|
|
case VideoParams::k_video_type_video:
|
|
case VideoParams::k_video_type_still:
|
|
decoder = resolve_decoder_from_input(decoder_id, default_codec_stream);
|
|
break;
|
|
case VideoParams::k_video_type_image_sequence: {
|
|
if (render_ctx_) {
|
|
// Since image sequences involve multiple files, we don't engage the decoder cache
|
|
decoder = Decoder::create_from_id(decoder_id);
|
|
|
|
QString frame_filename;
|
|
|
|
int64_t frame_number =
|
|
stream_data.get_time_in_timebase_units(input_time);
|
|
frame_filename = Decoder::transform_image_sequence_file_name(
|
|
decode_filename, frame_number);
|
|
|
|
// Decoder will close automatically since it's a stream_ptr
|
|
decoder->open(Decoder::CodecStream(frame_filename, stream_index,
|
|
get_current_block()));
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
|
|
if (decoder && render_ctx_) {
|
|
Decoder::RetrieveVideoParams p;
|
|
p.divider = stream->video_params().divider();
|
|
p.maximum_format = destination->format();
|
|
|
|
if (!is_cancelled()) {
|
|
VideoParams tex_params = stream->video_params();
|
|
|
|
if (tex_params.is_valid()) {
|
|
TexturePtr unmanaged_texture;
|
|
|
|
p.renderer = render_ctx_;
|
|
p.time =
|
|
(stream_data.video_type() == VideoParams::k_video_type_video) ?
|
|
input_time :
|
|
Decoder::k_any_timecode;
|
|
p.cancelled = get_cancel_pointer();
|
|
p.force_range = stream_data.color_range();
|
|
p.src_interlacing = stream_data.interlacing();
|
|
|
|
unmanaged_texture = decoder->retrieve_video(p);
|
|
|
|
if (!is_cancelled() && unmanaged_texture) {
|
|
blit_color_managed(unmanaged_texture, stream_data);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
void RenderProcessor::process_audio_footage(SampleBuffer &destination,
|
|
const FootageJob *stream,
|
|
const TimeRange &input_time)
|
|
{
|
|
// The worker process has no decoder cache and does not decode audio. Bail
|
|
// out gracefully rather than letting ResolveDecoderFromInput crash.
|
|
if (!decoder_cache_) {
|
|
return;
|
|
}
|
|
|
|
// Mirror the video path: use the proxy (when enabled, ready, and containing
|
|
// audio) for offline renders only, never for export
|
|
const bool use_proxy =
|
|
static_cast<RenderMode::Mode>(ticket_->property("mode").toInt()) ==
|
|
RenderMode::k_offline &&
|
|
stream->has_proxy() && QFileInfo::exists(stream->proxy_filename());
|
|
const QString decode_filename = use_proxy ? stream->proxy_filename() :
|
|
stream->filename();
|
|
const QString decoder_id = use_proxy ? stream->proxy_decoder() :
|
|
stream->decoder();
|
|
const int stream_index = use_proxy ?
|
|
stream->proxy_stream_index() :
|
|
stream->audio_params().stream_index();
|
|
|
|
DecoderPtr decoder = resolve_decoder_from_input(
|
|
decoder_id,
|
|
Decoder::CodecStream(decode_filename, stream_index, nullptr));
|
|
|
|
if (decoder) {
|
|
const AudioParams &audio_params = get_cache_audio_params();
|
|
|
|
Decoder::RetrieveAudioStatus status = decoder->retrieve_audio(
|
|
destination, input_time, audio_params, stream->cache_path(),
|
|
loop_mode(),
|
|
static_cast<RenderMode::Mode>(ticket_->property("mode").toInt()));
|
|
|
|
if (status == Decoder::k_waiting_for_conform) {
|
|
ticket_->setProperty("incomplete", true);
|
|
}
|
|
}
|
|
}
|
|
|
|
void RenderProcessor::process_shader(TexturePtr destination, const Node *node,
|
|
const ShaderJob *job)
|
|
{
|
|
if (!render_ctx_) {
|
|
return;
|
|
}
|
|
|
|
QString full_shader_id =
|
|
QStringLiteral("%1:%2").arg(node->id(), job->get_shader_id());
|
|
|
|
QMutexLocker locker(shader_cache_->mutex());
|
|
|
|
QVariant shader = shader_cache_->value(full_shader_id);
|
|
|
|
if (shader.isNull()) {
|
|
// Since we have shader code, compile it now
|
|
shader = render_ctx_->create_native_shader(
|
|
node->get_shader_code(job->get_shader_id()));
|
|
|
|
if (shader.isNull()) {
|
|
// Couldn't find or build the shader required
|
|
return;
|
|
}
|
|
|
|
shader_cache_->insert(full_shader_id, shader);
|
|
}
|
|
|
|
locker.unlock();
|
|
|
|
// Run shader
|
|
render_ctx_->blit_to_texture(shader, const_cast<ShaderJob &>(*job),
|
|
destination.get());
|
|
}
|
|
|
|
void RenderProcessor::process_samples(SampleBuffer &destination,
|
|
const Node *node, const TimeRange &range,
|
|
const SampleJob &job)
|
|
{
|
|
if (!job.samples().is_allocated()) {
|
|
return;
|
|
}
|
|
|
|
NodeValueRow value_db;
|
|
|
|
const AudioParams &audio_params = get_cache_audio_params();
|
|
|
|
for (size_t i = 0; i < job.samples().sample_count(); i++) {
|
|
// Calculate the exact Rational time at this sample
|
|
double sample_to_second =
|
|
static_cast<double>(i) /
|
|
static_cast<double>(audio_params.sample_rate());
|
|
|
|
Rational this_sample_time =
|
|
Rational::from_double(range.in().to_double() + sample_to_second);
|
|
|
|
// Update all non-sample and non-footage inputs
|
|
for (auto j = job.get_values().constBegin();
|
|
j != job.get_values().constEnd(); j++) {
|
|
TimeRange r = TimeRange(this_sample_time, this_sample_time);
|
|
NodeValueTable value = process_input(node, j.key(), r);
|
|
|
|
value_db.insert(j.key(),
|
|
generate_row_value(node, j.key(), &value, r));
|
|
}
|
|
|
|
node->process_samples(value_db, job.samples(), destination, i);
|
|
}
|
|
}
|
|
|
|
void RenderProcessor::process_color_transform(TexturePtr destination,
|
|
const Node *node,
|
|
const ColorTransformJob *job)
|
|
{
|
|
if (!render_ctx_) {
|
|
return;
|
|
}
|
|
|
|
render_ctx_->blit_color_managed(*job, destination.get());
|
|
}
|
|
|
|
void RenderProcessor::process_frame_generation(TexturePtr destination,
|
|
const Node *node,
|
|
const GenerateJob *job)
|
|
{
|
|
if (!render_ctx_) {
|
|
return;
|
|
}
|
|
|
|
FramePtr frame = Frame::create();
|
|
|
|
frame->set_video_params(destination->params());
|
|
frame->allocate();
|
|
|
|
node->generate_frame(frame, *job);
|
|
|
|
destination->upload(frame->data(), frame->linesize_pixels());
|
|
}
|
|
|
|
TexturePtr RenderProcessor::process_plugin_job(TexturePtr texture,
|
|
TexturePtr destination,
|
|
const Node *node)
|
|
{
|
|
(void)node;
|
|
|
|
if (!render_ctx_ || !texture || !destination) {
|
|
return destination;
|
|
}
|
|
|
|
auto *plugin_job = dynamic_cast<plugin::PluginJob *>(texture->job());
|
|
if (!plugin_job) {
|
|
return destination;
|
|
}
|
|
|
|
plugin::PluginRenderer plugin_renderer(render_ctx_);
|
|
if (!plugin_renderer.renderer()) {
|
|
return destination;
|
|
}
|
|
|
|
NodeValueRow &values = plugin_job->get_values();
|
|
|
|
auto is_usable_texture = [](const TexturePtr &tex) {
|
|
if (!tex) {
|
|
return false;
|
|
}
|
|
if (!tex->is_dummy() && tex->renderer()) {
|
|
return true;
|
|
}
|
|
AVFramePtr frame = tex->frame();
|
|
return frame && frame->data(0);
|
|
};
|
|
|
|
TexturePtr src = nullptr;
|
|
QString effect_input_id;
|
|
if (plugin_job->node()) {
|
|
effect_input_id = plugin_job->node()->get_effect_input_id();
|
|
}
|
|
if (!effect_input_id.isEmpty()) {
|
|
if (TexturePtr effect_tex = values.value(effect_input_id).to_texture();
|
|
is_usable_texture(effect_tex)) {
|
|
src = effect_tex;
|
|
}
|
|
}
|
|
if (!src) {
|
|
const QString source_key =
|
|
QString::fromUtf8(kOfxImageEffectSimpleSourceClipName);
|
|
if (TexturePtr source_tex = values.value(source_key).to_texture();
|
|
is_usable_texture(source_tex)) {
|
|
src = source_tex;
|
|
} else if (TexturePtr effect_tex =
|
|
values.value(plugin::k_texture_input).to_texture();
|
|
is_usable_texture(effect_tex)) {
|
|
src = effect_tex;
|
|
}
|
|
}
|
|
if (!src) {
|
|
for (auto it = values.cbegin(); it != values.cend(); ++it) {
|
|
if (it.value().type() == NodeValue::k_texture) {
|
|
if (TexturePtr any_tex = it.value().to_texture();
|
|
is_usable_texture(any_tex)) {
|
|
src = any_tex;
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
plugin_renderer.render_plugin(src, *plugin_job, destination,
|
|
destination->params(), true, false);
|
|
|
|
return destination;
|
|
}
|
|
|
|
TexturePtr RenderProcessor::process_video_cache_job(const CacheJob *val)
|
|
{
|
|
FramePtr frame = FrameHashCache::load_cache_frame(val->get_filename());
|
|
if (frame) {
|
|
// Auto-detect and discard black/empty cached frames (macOS TBDR artifact)
|
|
bool all_black = true;
|
|
if (frame->data() && frame->allocated_size() > 0) {
|
|
const uint8_t *pixels =
|
|
reinterpret_cast<const uint8_t *>(frame->data());
|
|
size_t alloc_size = static_cast<size_t>(frame->allocated_size());
|
|
size_t check_bytes = std::min(alloc_size, size_t(4096));
|
|
for (size_t i = 0; i < check_bytes; ++i) {
|
|
if (pixels[i] != 0) {
|
|
all_black = false;
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
if (all_black) {
|
|
qWarning() << "[CACHE] Discarding black cached frame:"
|
|
<< val->get_filename()
|
|
<< "time=" << frame->timestamp().to_double()
|
|
<< "size=" << frame->allocated_size();
|
|
QFile::remove(val->get_filename());
|
|
return nullptr;
|
|
}
|
|
|
|
TexturePtr tex = create_texture(frame->video_params());
|
|
if (tex) {
|
|
tex->upload(frame->data(), frame->linesize_pixels());
|
|
return tex;
|
|
}
|
|
} else {
|
|
QStringList s = ticket_->property("badcache").toStringList();
|
|
s.append(val->get_filename());
|
|
ticket_->setProperty("badcache", s);
|
|
}
|
|
|
|
return nullptr;
|
|
}
|
|
|
|
TexturePtr RenderProcessor::create_texture(const VideoParams &p)
|
|
{
|
|
if (render_ctx_) {
|
|
return render_ctx_->create_texture(p);
|
|
} else {
|
|
return super::create_texture(p);
|
|
}
|
|
}
|
|
|
|
void RenderProcessor::convert_to_reference_space(TexturePtr destination,
|
|
TexturePtr source,
|
|
const QString &input_cs)
|
|
{
|
|
if (!render_ctx_) {
|
|
return;
|
|
}
|
|
|
|
ColorManager *color_manager =
|
|
QtUtils::value_to_ptr<ColorManager>(ticket_->property("colormanager"));
|
|
ColorProcessorPtr cp = ColorProcessor::create(
|
|
color_manager, input_cs, color_manager->get_reference_color_space());
|
|
|
|
ColorTransformJob ctj;
|
|
|
|
ctj.set_color_processor(cp);
|
|
ctj.set_input_texture(source);
|
|
ctj.set_input_alpha_association(k_alpha_associated);
|
|
|
|
render_ctx_->blit_color_managed(ctj, destination.get());
|
|
}
|
|
|
|
bool RenderProcessor::use_cache() const
|
|
{
|
|
return static_cast<RenderMode::Mode>(ticket_->property("mode").toInt()) ==
|
|
RenderMode::k_offline;
|
|
}
|
|
|
|
}
|