427 lines
13 KiB
C++
427 lines
13 KiB
C++
#include "openglworker.h"
|
|
|
|
#include <QThread>
|
|
|
|
#include "functions.h"
|
|
#include "node/block/block.h"
|
|
#include "node/node.h"
|
|
|
|
OpenGLWorker::OpenGLWorker(QOpenGLContext *share_ctx, OpenGLShaderCache *shader_cache, DecoderCache *decoder_cache, QObject *parent) :
|
|
QObject(parent),
|
|
share_ctx_(share_ctx),
|
|
ctx_(nullptr),
|
|
functions_(nullptr),
|
|
shader_cache_(shader_cache),
|
|
decoder_cache_(decoder_cache),
|
|
working_(0)
|
|
{
|
|
surface_.create();
|
|
}
|
|
|
|
OpenGLWorker::~OpenGLWorker()
|
|
{
|
|
surface_.destroy();
|
|
}
|
|
|
|
bool OpenGLWorker::IsStarted()
|
|
{
|
|
return ctx_ != nullptr;
|
|
}
|
|
|
|
void OpenGLWorker::SetParameters(const VideoRenderingParams &video_params)
|
|
{
|
|
video_params_ = video_params;
|
|
}
|
|
|
|
void OpenGLWorker::Init()
|
|
{
|
|
// Create context object
|
|
ctx_ = new QOpenGLContext();
|
|
|
|
// Set share context
|
|
ctx_->setShareContext(share_ctx_);
|
|
|
|
// Create OpenGL context (automatically destroys any existing if there is one)
|
|
if (!ctx_->create()) {
|
|
qWarning() << "Failed to create OpenGL context in thread" << thread();
|
|
Close();
|
|
return;
|
|
}
|
|
|
|
ctx_->moveToThread(this->thread());
|
|
|
|
//qDebug() << "Processor initialized in thread" << thread() << "- context is in" << ctx_->thread();
|
|
|
|
// The rest of the initialization needs to occur in the other thread, so we signal for it to start
|
|
QMetaObject::invokeMethod(this, "FinishInit", Qt::QueuedConnection);
|
|
}
|
|
|
|
bool OpenGLWorker::IsAvailable()
|
|
{
|
|
return (working_ == 0);
|
|
}
|
|
|
|
void OpenGLWorker::Close()
|
|
{
|
|
buffer_.Destroy();
|
|
|
|
functions_ = nullptr;
|
|
delete ctx_;
|
|
}
|
|
|
|
void OpenGLWorker::Render(NodeDependency path)
|
|
{
|
|
NodeOutput* output = path.node();
|
|
Node* node = output->parent();
|
|
|
|
QList<Node*> all_nodes_in_graph;
|
|
all_nodes_in_graph.append(node);
|
|
all_nodes_in_graph.append(node->GetDependencies());
|
|
|
|
// Lock all Nodes to prevent UI changes during this render
|
|
foreach (Node* dep, all_nodes_in_graph) {
|
|
dep->LockUserInput();
|
|
}
|
|
|
|
// Start traversing graph
|
|
RenderAsSibling(path);
|
|
|
|
// Start OpenGL flushing now while we do clean up work on the CPU
|
|
functions_->glFlush();
|
|
|
|
// Unlock all Nodes so changes can be made again
|
|
foreach (Node* dep, all_nodes_in_graph) {
|
|
dep->UnlockUserInput();
|
|
}
|
|
|
|
// Now we need the texture done so we call glFinish()
|
|
functions_->glFinish();
|
|
|
|
emit CompletedFrame(path);
|
|
}
|
|
|
|
void OpenGLWorker::UpdateViewportFromParams()
|
|
{
|
|
if (functions_ != nullptr && video_params_.is_valid()) {
|
|
functions_->glViewport(0, 0, video_params_.effective_width(), video_params_.effective_height());
|
|
}
|
|
}
|
|
|
|
Node *OpenGLWorker::ValidateBlock(Node *n, const rational& time)
|
|
{
|
|
if (n->IsBlock()) {
|
|
Block* block = static_cast<Block*>(n);
|
|
|
|
while (block->in() > time && block != nullptr) {
|
|
// This Block is too late, find an earlier one
|
|
block = block->previous();
|
|
}
|
|
|
|
while (block->out() <= time && block != nullptr) {
|
|
// This block is too early, find a later one
|
|
block = block->next();
|
|
}
|
|
|
|
// By this point, we should have the correct Block or nullptr if there's no Block here
|
|
return block;
|
|
}
|
|
|
|
return n;
|
|
}
|
|
|
|
QList<NodeInput*> OpenGLWorker::ProcessNodeInputsForTime(Node *n, const TimeRange &time)
|
|
{
|
|
QList<NodeInput*> connected_inputs;
|
|
|
|
// Now we need to gather information about this Node's inputs
|
|
foreach (NodeParam* param, n->parameters()) {
|
|
// Check if this parameter is an input and if the Node is dependent on it
|
|
if (param->type() == NodeParam::kInput) {
|
|
NodeInput* input = static_cast<NodeInput*>(param);
|
|
|
|
if (input->dependent()) {
|
|
// If we're here, this input is necessary and we need to acquire the value for this Node
|
|
if (input->IsConnected()) {
|
|
// If it's connected to something, we need to retrieve that output at some point
|
|
connected_inputs.append(input);
|
|
} else {
|
|
// If it isn't connected, it'll have the value we need inside it. We just need to store it for the node.
|
|
input->set_stored_value(input->get_value_at_time(n->InputTimeAdjustment(input, time).in()));
|
|
}
|
|
|
|
// Special types like FOOTAGE require extra work from us (to decrease node complexity dealing with decoders)
|
|
if (input->data_type() == NodeParam::kFootage) {
|
|
input->set_stored_value(0);
|
|
|
|
// Access a map of Node inputs and decoder instances and retrieve a frame!
|
|
StreamPtr stream = input->get_value_at_time(0).value<StreamPtr>();
|
|
DecoderPtr decoder = decoder_cache_->GetDecoder(stream.get());
|
|
|
|
if (decoder == nullptr && stream != nullptr) {
|
|
// Init decoder
|
|
decoder = Decoder::CreateFromID(stream->footage()->decoder());
|
|
decoder->set_stream(stream);
|
|
decoder_cache_->AddDecoder(stream.get(), decoder);
|
|
}
|
|
|
|
// By this point we should definitely have a decoder, and if we don't something's gone terribly wrong
|
|
if (decoder != nullptr) {
|
|
FramePtr frame = decoder->Retrieve(time.in());
|
|
|
|
if (frame != nullptr) {
|
|
OpenGLTexturePtr footage_tex = std::make_shared<OpenGLTexture>();
|
|
footage_tex->Create(ctx_, frame, OpenGLTexture::kDoubleBuffer);
|
|
|
|
// FIXME: Alpha association and color management
|
|
|
|
input->set_stored_value(QVariant::fromValue(footage_tex));
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
return connected_inputs;
|
|
}
|
|
|
|
OpenGLTexturePtr OpenGLWorker::RunNodeAsShader(Node* node, OpenGLShaderPtr shader)
|
|
{
|
|
shader->bind();
|
|
|
|
unsigned int input_texture_count = 0;
|
|
|
|
foreach (NodeParam* param, node->parameters()) {
|
|
if (param->type() == NodeParam::kInput) {
|
|
// See if the shader has takes this parameter as an input
|
|
int variable_location = shader->uniformLocation(param->id());
|
|
|
|
if (variable_location > -1) {
|
|
// This variable is used in the shader, let's set it to our value
|
|
|
|
NodeInput* input = static_cast<NodeInput*>(param);
|
|
switch (input->data_type()) {
|
|
case NodeInput::kInt:
|
|
shader->setUniformValue(variable_location, input->value().toInt());
|
|
break;
|
|
case NodeInput::kFloat:
|
|
shader->setUniformValue(variable_location, input->value().toFloat());
|
|
break;
|
|
case NodeInput::kVec2:
|
|
shader->setUniformValue(variable_location, input->value().value<QVector2D>());
|
|
break;
|
|
case NodeInput::kVec3:
|
|
shader->setUniformValue(variable_location, input->value().value<QVector3D>());
|
|
break;
|
|
case NodeInput::kVec4:
|
|
shader->setUniformValue(variable_location, input->value().value<QVector4D>());
|
|
break;
|
|
case NodeInput::kMatrix:
|
|
shader->setUniformValue(variable_location, input->value().value<QMatrix4x4>());
|
|
break;
|
|
case NodeInput::kColor:
|
|
shader->setUniformValue(variable_location, input->value().value<QColor>());
|
|
break;
|
|
case NodeInput::kBoolean:
|
|
shader->setUniformValue(variable_location, input->value().toBool());
|
|
break;
|
|
case NodeInput::kTexture:
|
|
case NodeInput::kFootage:
|
|
{
|
|
OpenGLTexturePtr texture = input->value().value<OpenGLTexturePtr>();
|
|
functions_->glActiveTexture(GL_TEXTURE0 + input_texture_count);
|
|
functions_->glBindTexture(GL_TEXTURE_2D, texture->texture());
|
|
|
|
// Set value to bound texture
|
|
shader->setUniformValue(variable_location, input_texture_count);
|
|
|
|
input_texture_count++;
|
|
break;
|
|
}
|
|
case NodeInput::kAny:
|
|
case NodeInput::kSamples:
|
|
case NodeInput::kTrack:
|
|
case NodeInput::kString:
|
|
case NodeInput::kRational:
|
|
case NodeInput::kBlock:
|
|
case NodeInput::kFont:
|
|
case NodeInput::kFile:
|
|
case NodeInput::kNone:
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
// Create the output texture
|
|
OpenGLTexturePtr output = std::make_shared<OpenGLTexture>();
|
|
output->Create(ctx_, video_params_.width(), video_params_.height(), video_params_.format());
|
|
|
|
buffer_.Attach(output);
|
|
|
|
buffer_.Bind();
|
|
|
|
olive::gl::Blit(shader);
|
|
|
|
buffer_.Release();
|
|
|
|
buffer_.Detach();
|
|
|
|
// Release any textures we bound before
|
|
while (input_texture_count > 0) {
|
|
input_texture_count--;
|
|
|
|
// Release texture here
|
|
functions_->glActiveTexture(GL_TEXTURE0 + input_texture_count);
|
|
functions_->glBindTexture(GL_TEXTURE_2D, 0);
|
|
}
|
|
|
|
shader->release();
|
|
|
|
return output;
|
|
}
|
|
|
|
void OpenGLWorker::FinishInit()
|
|
{
|
|
// Make context current on that surface
|
|
if (!ctx_->makeCurrent(&surface_)) {
|
|
qWarning() << "Failed to makeCurrent() on offscreen surface in thread" << thread();
|
|
return;
|
|
}
|
|
|
|
// Store OpenGL functions instance
|
|
functions_ = ctx_->functions();
|
|
|
|
// Set up OpenGL parameters as necessary
|
|
functions_->glEnable(GL_BLEND);
|
|
UpdateViewportFromParams();
|
|
|
|
buffer_.Create(ctx_);
|
|
|
|
//qDebug() << "Context in" << ctx_->thread() << "successfully finished";
|
|
}
|
|
|
|
void OpenGLWorker::RenderAsSibling(NodeDependency dep)
|
|
{
|
|
NodeOutput* output = dep.node();
|
|
Node* original_node = output->parent();
|
|
Node* node;
|
|
rational time = dep.in();
|
|
QList<NodeInput*> connected_inputs;
|
|
OpenGLShaderPtr shader;
|
|
|
|
// Set working state
|
|
working_++;
|
|
|
|
original_node->LockProcessing();
|
|
|
|
// Firstly we check if this node is a "Block", if it is that means it's part of a linked list of mutually exclusive
|
|
// nodes based on time and we might need to locate which Block to attach to
|
|
if ((node = ValidateBlock(original_node, time)) == nullptr) {
|
|
// ValidateBlock() may have returned nullptr if there was no Block found at this time so no texture to return
|
|
output->cache_value(dep.range(), 0);
|
|
|
|
original_node->UnlockProcessing();
|
|
goto end_render;
|
|
}
|
|
|
|
if (original_node != node) {
|
|
// Ensure output is the output matching the node as it may have changed
|
|
output = static_cast<NodeOutput*>(node->GetParameterWithID(output->id()));
|
|
|
|
// Switch locks
|
|
original_node->UnlockProcessing();
|
|
node->LockProcessing();
|
|
}
|
|
|
|
// Check if the output already has a value for this time
|
|
if (output->has_cached_value(dep.range())) {
|
|
// If so, we don't need to do anything, we can just send this value and exit here
|
|
dep.node()->cache_value(dep.range(), output->get_cached_value(dep.range()));
|
|
|
|
node->UnlockProcessing();
|
|
goto end_render;
|
|
}
|
|
|
|
// We need to run the Node's code to get the correct value for this time
|
|
|
|
connected_inputs = ProcessNodeInputsForTime(node, dep.range());
|
|
|
|
// For each connected input, we need to acquire the value from another node
|
|
while (!connected_inputs.isEmpty()) {
|
|
|
|
// Remove any inputs from the list that we have valid cached values for already
|
|
for (int i=0;i<connected_inputs.size();i++) {
|
|
NodeInput* input = connected_inputs.at(i);
|
|
NodeOutput* connected_output = input->get_connected_output();
|
|
TimeRange input_time = node->InputTimeAdjustment(input, dep.range());
|
|
|
|
if (connected_output->has_cached_value(input_time)) {
|
|
// This output already has this value, no need to process it again
|
|
input->set_stored_value(connected_output->get_cached_value(input_time));
|
|
connected_inputs.removeAt(i);
|
|
i--;
|
|
}
|
|
}
|
|
|
|
// For every connected input except the first, we'll request another Node to do it
|
|
int input_for_this_thread = -1;
|
|
|
|
for (int i=0;i<connected_inputs.size();i++) {
|
|
NodeInput* input = connected_inputs.at(i);
|
|
|
|
// If this node is locked, we assume it's already being processed. Otherwise we need to request a sibling
|
|
if (!input->get_connected_node()->IsProcessingLocked()) {
|
|
if (input_for_this_thread == -1) {
|
|
// Store this later since we can process it on this thread as we wait for other threads
|
|
input_for_this_thread = i;
|
|
} else {
|
|
TimeRange input_time = node->InputTimeAdjustment(input, dep.range());
|
|
|
|
emit RequestSibling(NodeDependency(input->get_connected_output(),
|
|
input_time));
|
|
}
|
|
}
|
|
}
|
|
|
|
if (input_for_this_thread > -1) {
|
|
// In the mean time, this thread can go off to do the first parameter
|
|
NodeInput* input = connected_inputs.at(input_for_this_thread);
|
|
TimeRange input_range = node->InputTimeAdjustment(input, dep.range());
|
|
RenderAsSibling(NodeDependency(input->get_connected_output(),
|
|
input_range));
|
|
input->set_stored_value(input->get_connected_output()->get_cached_value(input_range));
|
|
connected_inputs.removeAt(input_for_this_thread);
|
|
} else {
|
|
// Nothing for this thread to do. We'll wait 0.5 sec and check again for other nodes
|
|
// FIXME: It would be nicer if this thread could do other nodes during this time
|
|
QThread::msleep(500);
|
|
}
|
|
}
|
|
|
|
// By this point, the node should have all the inputs it needs to render correctly
|
|
|
|
// Check if we have a shader for this output
|
|
shader = shader_cache_->GetShader(output);
|
|
|
|
if (shader != nullptr) {
|
|
// Run code
|
|
OpenGLTexturePtr texture = RunNodeAsShader(node, shader);
|
|
|
|
output->cache_value(dep.range(), QVariant::fromValue(texture));
|
|
} else {
|
|
// Generate the value as expected
|
|
QVariant value = node->Value(output);
|
|
|
|
// Place the value into the output
|
|
output->cache_value(dep.range(), value);
|
|
}
|
|
|
|
// We're done!
|
|
node->UnlockProcessing();
|
|
|
|
end_render:
|
|
// End this working state
|
|
working_--;
|
|
}
|