build: split the engine into liboakengine.so; worker drops the UI entirely

Physical split: app/{audio,cli,codec,common,config,node,pluginSupport,
render,task,timeline,undo,tool,shaders} plus coreengine, version and
ui/icons+colorcoding move to a new top-level engine/ tree, built as
liboakengine.so (shared). The render backends (oakgl/oakvulkan) move
with it and link the engine library instead of embedding a static
render-core subset (libolive-rendercore is gone).

- oak-render-worker now links liboakengine instead of the whole
  libolive-editor object set: 336MB -> 2.9MB, no Qt Widgets UI
- the editor links liboakengine for the engine and keeps only UI
  objects in libolive-editor
- install/packaging: GNUInstallDirs libdir on Linux, bundle copy on
  macOS, oakengine.dll staged for NSIS, AppImage validation entry
- fix backend lookup for the new layout: DynamicRenderer searched
  ../app but backends now live in engine/; a stale pre-split liboakgl
  in the build tree got dlopened instead, re-initialized and later
  destroyed the interposed engine statics (full-suite segfault at
  DialogSequenceParameterTab, found via gdb watchpoint)
This commit is contained in:
2026-07-20 03:23:28 +08:00
parent 026ff94b5e
commit 28c4426236
604 changed files with 243 additions and 172 deletions
+24
View File
@@ -0,0 +1,24 @@
# Olive - Non-Linear Video Editor
# Copyright (C) 2022 Olive Team
#
# 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/>.
add_subdirectory(chromakey)
add_subdirectory(colordifferencekey)
add_subdirectory(despill)
set(OLIVE_SOURCES
${OLIVE_SOURCES}
PARENT_SCOPE
)
@@ -0,0 +1,22 @@
# Olive - Non-Linear Video Editor
# Copyright (C) 2022 Olive Team
#
# 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/>.
set(OLIVE_SOURCES
${OLIVE_SOURCES}
node/keying/chromakey/chromakey.h
node/keying/chromakey/chromakey.cpp
PARENT_SCOPE
)
+179
View File
@@ -0,0 +1,179 @@
/***
Olive - Non-Linear Video Editor
Copyright (C) 2019 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 "chromakey.h"
#include "node/color/colormanager/colormanager.h"
#include "render/colorprocessor.h"
namespace olive
{
#define super OCIOBaseNode
const QString ChromaKeyNode::k_color_input = QStringLiteral("color_key");
const QString ChromaKeyNode::k_mask_only_input = QStringLiteral("mask_only_in");
const QString ChromaKeyNode::k_invert_input = QStringLiteral("invert_in");
const QString ChromaKeyNode::k_upper_tolerance_input =
QStringLiteral("upper_tolerance_in");
const QString ChromaKeyNode::k_lower_tolerance_input =
QStringLiteral("lower_tolerance_in");
const QString ChromaKeyNode::k_garbage_matte_input = QStringLiteral("garbage_in");
const QString ChromaKeyNode::k_core_matte_input = QStringLiteral("core_in");
const QString ChromaKeyNode::k_shadows_input = QStringLiteral("shadows_in");
const QString ChromaKeyNode::k_highlights_input = QStringLiteral("highlights_in");
ChromaKeyNode::ChromaKeyNode()
{
add_input(k_color_input, NodeValue::k_color,
QVariant::fromValue(Color(0.0f, 1.0f, 0.0f, 1.0f)));
add_input(k_lower_tolerance_input, NodeValue::k_float, 5.0);
set_input_property(k_lower_tolerance_input, QStringLiteral("min"), 0.0);
set_input_property(k_lower_tolerance_input, QStringLiteral("base"), 0.1);
add_input(k_upper_tolerance_input, NodeValue::k_float, 25.0);
set_input_property(k_upper_tolerance_input, QStringLiteral("base"), 0.1);
// FIXME: Temporarily disabled. This will break if "lower tolerance" is keyframed or connected to
// something and there's currently no solution to remedy that. If there is in the future,
// we can look into re-enabling this.
//SetInputProperty(kUpperToleranceInput, QStringLiteral("min"), GetStandardValue(kLowerToleranceInput).toDouble());
add_input(k_garbage_matte_input, NodeValue::k_texture,
InputFlags(k_input_flag_not_keyframable));
add_input(k_core_matte_input, NodeValue::k_texture,
InputFlags(k_input_flag_not_keyframable));
add_input(k_highlights_input, NodeValue::k_float, 100.0f);
set_input_property(k_highlights_input, QStringLiteral("min"), 0.0);
set_input_property(k_highlights_input, QStringLiteral("base"), 0.1);
add_input(k_shadows_input, NodeValue::k_float, 100.0f);
set_input_property(k_shadows_input, QStringLiteral("min"), 0.0);
set_input_property(k_shadows_input, QStringLiteral("base"), 0.1);
add_input(k_invert_input, NodeValue::k_boolean, false);
add_input(k_mask_only_input, NodeValue::k_boolean, false);
}
QString ChromaKeyNode::name() const
{
return tr("Chroma Key");
}
QString ChromaKeyNode::id() const
{
return QStringLiteral("org.olivevideoeditor.Olive.chromakey");
}
QVector<Node::CategoryID> ChromaKeyNode::category() const
{
return { k_category_keying };
}
QString ChromaKeyNode::description() const
{
return tr(
"A simple color key based on the distance from the chroma of a selected color.");
}
void ChromaKeyNode::retranslate()
{
super::retranslate();
set_input_name(k_texture_input, tr("Input"));
set_input_name(k_garbage_matte_input, tr("Garbage Matte"));
set_input_name(k_core_matte_input, tr("Core Matte"));
set_input_name(k_color_input, tr("Key Color"));
set_input_name(k_shadows_input, tr("Shadows"));
set_input_name(k_highlights_input, tr("Highlights"));
set_input_name(k_upper_tolerance_input, tr("Upper Tolerance"));
set_input_name(k_lower_tolerance_input, tr("Lower Tolerance"));
set_input_name(k_invert_input, tr("Invert Mask"));
set_input_name(k_mask_only_input, tr("Show Mask Only"));
}
void ChromaKeyNode::InputValueChangedEvent(const QString &input, int element)
{
Q_UNUSED(element);
if (input == k_lower_tolerance_input) {
// FIXME: Temporarily disabled. This will break if "lower tolerance" is keyframed or connected to
// something and there's currently no solution to remedy that. If there is in the future,
// we can look into re-enabling this.
//SetInputProperty(kUpperToleranceInput, QStringLiteral("min"), GetStandardValue(kLowerToleranceInput).toDouble());
}
generate_processor();
}
ShaderCode ChromaKeyNode::get_shader_code(const ShaderRequest &request) const
{
return ShaderCode(FileFunctions::read_file_as_string(
QStringLiteral(":/shaders/chromakey.frag"))
.arg(request.stub));
}
void ChromaKeyNode::generate_processor()
{
if (manager()) {
try {
ColorTransform transform("cie_xyz_d65_interchange");
set_processor(ColorProcessor::create(
manager(), manager()->get_reference_color_space(), transform));
} catch (const ocio::Exception &e) {
std::cerr << std::endl << e.what() << std::endl;
}
}
}
void ChromaKeyNode::value(const NodeValueRow &value, const NodeGlobals &globals,
NodeValueTable *table) const
{
if (TexturePtr tex = value[k_texture_input].to_texture()) {
if (processor()) {
ColorTransformJob job(value);
job.set_color_processor(processor());
job.set_input_texture(value[k_texture_input]);
job.set_needs_custom_shader(this);
job.set_function_name(QStringLiteral("SceneLinearToCIEXYZ_d65"));
table->push(NodeValue::k_texture, tex->to_job(job), this);
}
}
}
void ChromaKeyNode::config_changed()
{
generate_processor();
}
QString ChromaKeyNode::get_input_id_for_legacy_id(const QString &id) const
{
// Older project files used the misspelled "tolerence" input IDs
if (id == QStringLiteral("upper_tolerence_in")) {
return k_upper_tolerance_input;
}
if (id == QStringLiteral("lower_tolerence_in")) {
return k_lower_tolerance_input;
}
return super::get_input_id_for_legacy_id(id);
}
} // namespace olive
+69
View File
@@ -0,0 +1,69 @@
/***
Olive - Non-Linear Video Editor
Copyright (C) 2019 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/>.
***/
#ifndef OAK_CHROMAKEYNODE_H
#define OAK_CHROMAKEYNODE_H
#include "node/color/ociobase/ociobase.h"
namespace olive
{
class ChromaKeyNode : public OCIOBaseNode {
Q_OBJECT
public:
ChromaKeyNode();
NODE_DEFAULT_FUNCTIONS(ChromaKeyNode)
virtual QString name() const override;
virtual QString id() const override;
virtual QVector<CategoryID> category() const override;
virtual QString description() const override;
virtual void retranslate() override;
virtual void InputValueChangedEvent(const QString &input,
int element) override;
virtual ShaderCode
get_shader_code(const ShaderRequest &request) const override;
virtual void value(const NodeValueRow &value, const NodeGlobals &globals,
NodeValueTable *table) const override;
virtual void config_changed() override;
// Maps the misspelled tolerance input IDs from old project files onto the
// corrected ones
virtual QString get_input_id_for_legacy_id(const QString &id) const override;
static const QString k_color_input;
static const QString k_invert_input;
static const QString k_mask_only_input;
static const QString k_upper_tolerance_input;
static const QString k_lower_tolerance_input;
static const QString k_garbage_matte_input;
static const QString k_core_matte_input;
static const QString k_shadows_input;
static const QString k_highlights_input;
private:
void generate_processor();
};
} // namespace olive
#endif // OAK_CHROMAKEYNODE_H
@@ -0,0 +1,22 @@
# Olive - Non-Linear Video Editor
# Copyright (C) 2022 Olive Team
#
# 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/>.
set(OLIVE_SOURCES
${OLIVE_SOURCES}
node/keying/colordifferencekey/colordifferencekey.h
node/keying/colordifferencekey/colordifferencekey.cpp
PARENT_SCOPE
)
@@ -0,0 +1,119 @@
/***
Olive - Non-Linear Video Editor
Copyright (C) 2019 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 "colordifferencekey.h"
namespace olive
{
const QString ColorDifferenceKeyNode::k_texture_input = QStringLiteral("tex_in");
const QString ColorDifferenceKeyNode::k_garbage_matte_input =
QStringLiteral("garbage_in");
const QString ColorDifferenceKeyNode::k_core_matte_input =
QStringLiteral("core_in");
const QString ColorDifferenceKeyNode::k_color_input = QStringLiteral("color_in");
const QString ColorDifferenceKeyNode::k_shadows_input =
QStringLiteral("shadows_in");
const QString ColorDifferenceKeyNode::k_highlights_input =
QStringLiteral("highlights_in");
const QString ColorDifferenceKeyNode::k_mask_only_input =
QStringLiteral("mask_only_in");
#define super Node
ColorDifferenceKeyNode::ColorDifferenceKeyNode()
{
add_input(k_texture_input, NodeValue::k_texture,
InputFlags(k_input_flag_not_keyframable));
add_input(k_garbage_matte_input, NodeValue::k_texture,
InputFlags(k_input_flag_not_keyframable));
add_input(k_core_matte_input, NodeValue::k_texture,
InputFlags(k_input_flag_not_keyframable));
add_input(k_color_input, NodeValue::k_combo, 0);
add_input(k_highlights_input, NodeValue::k_float, 1.0f);
set_input_property(k_highlights_input, QStringLiteral("min"), 0.0);
set_input_property(k_highlights_input, QStringLiteral("base"), 0.01);
add_input(k_shadows_input, NodeValue::k_float, 1.0f);
set_input_property(k_shadows_input, QStringLiteral("min"), 0.0);
set_input_property(k_shadows_input, QStringLiteral("base"), 0.01);
add_input(k_mask_only_input, NodeValue::k_boolean, false);
set_flag(k_video_effect);
set_effect_input(k_texture_input);
}
QString ColorDifferenceKeyNode::name() const
{
return tr("Color Difference Key");
}
QString ColorDifferenceKeyNode::id() const
{
return QStringLiteral("org.olivevideoeditor.Olive.colordifferencekey");
}
QVector<Node::CategoryID> ColorDifferenceKeyNode::category() const
{
return { k_category_keying };
}
QString ColorDifferenceKeyNode::description() const
{
return tr(
"A simple color key based on the distance of one color from other colors.");
}
void ColorDifferenceKeyNode::retranslate()
{
super::retranslate();
set_input_name(k_texture_input, tr("Input"));
set_input_name(k_garbage_matte_input, tr("Garbage Matte"));
set_input_name(k_core_matte_input, tr("Core Matte"));
set_input_name(k_color_input, tr("Key Color"));
set_combo_box_strings(k_color_input, { tr("Green"), tr("Blue") });
set_input_name(k_shadows_input, tr("Shadows"));
set_input_name(k_highlights_input, tr("Highlights"));
set_input_name(k_mask_only_input, tr("Show Mask Only"));
}
ShaderCode
ColorDifferenceKeyNode::get_shader_code(const ShaderRequest &request) const
{
Q_UNUSED(request)
return ShaderCode(
FileFunctions::read_file_as_string(":/shaders/colordifferencekey.frag"));
}
void ColorDifferenceKeyNode::value(const NodeValueRow &value,
const NodeGlobals &globals,
NodeValueTable *table) const
{
// If there's no texture, no need to run an operation
if (TexturePtr tex = value[k_texture_input].to_texture()) {
ShaderJob job;
job.insert(value);
table->push(NodeValue::k_texture, tex->to_job(job), this);
}
}
} // namespace olive
@@ -0,0 +1,54 @@
/***
Olive - Non-Linear Video Editor
Copyright (C) 2019 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/>.
***/
#ifndef OAK_COLORDIFFERENCEKEYNODE_H
#define OAK_COLORDIFFERENCEKEYNODE_H
#include "node/node.h"
namespace olive
{
class ColorDifferenceKeyNode : public Node {
public:
ColorDifferenceKeyNode();
NODE_DEFAULT_FUNCTIONS(ColorDifferenceKeyNode)
virtual QString name() const override;
virtual QString id() const override;
virtual QVector<CategoryID> category() const override;
virtual QString description() const override;
virtual void retranslate() override;
virtual ShaderCode
get_shader_code(const ShaderRequest &request) const override;
virtual void value(const NodeValueRow &value, const NodeGlobals &globals,
NodeValueTable *table) const override;
static const QString k_texture_input;
static const QString k_garbage_matte_input;
static const QString k_core_matte_input;
static const QString k_color_input;
static const QString k_shadows_input;
static const QString k_highlights_input;
static const QString k_mask_only_input;
};
} // namespace olive
#endif // OAK_COLORDIFFERENCEKEYNODE_H
+22
View File
@@ -0,0 +1,22 @@
# Olive - Non-Linear Video Editor
# Copyright (C) 2022 Olive Team
#
# 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/>.
set(OLIVE_SOURCES
${OLIVE_SOURCES}
node/keying/despill/despill.h
node/keying/despill/despill.cpp
PARENT_SCOPE
)
+116
View File
@@ -0,0 +1,116 @@
/***
Olive - Non-Linear Video Editor
Copyright (C) 2019 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 "despill.h"
#include "node/project.h"
namespace olive
{
const QString DespillNode::k_texture_input = QStringLiteral("tex_in");
const QString DespillNode::k_color_input = QStringLiteral("color_in");
const QString DespillNode::k_method_input = QStringLiteral("method_in");
const QString DespillNode::k_preserve_luminance_input =
QStringLiteral("preserve_luminance_input");
#define super Node
DespillNode::DespillNode()
{
add_input(k_texture_input, NodeValue::k_texture,
InputFlags(k_input_flag_not_keyframable));
add_input(k_color_input, NodeValue::k_combo, 0);
add_input(k_method_input, NodeValue::k_combo, 0);
add_input(k_preserve_luminance_input, NodeValue::k_boolean, false);
set_flag(k_video_effect);
set_effect_input(k_texture_input);
}
QString DespillNode::name() const
{
return tr("Despill");
}
QString DespillNode::id() const
{
return QStringLiteral("org.olivevideoeditor.Olive.despill");
}
QVector<Node::CategoryID> DespillNode::category() const
{
return { k_category_keying };
}
QString DespillNode::description() const
{
return tr("Selection of simple despill operations");
}
void DespillNode::retranslate()
{
super::retranslate();
set_input_name(k_texture_input, tr("Input"));
set_input_name(k_color_input, tr("Key Color"));
set_combo_box_strings(k_color_input, { tr("Green"), tr("Blue") });
set_input_name(k_method_input, tr("Method"));
set_combo_box_strings(k_method_input, { tr("Average"), tr("Double Red Average"),
tr("Double Average"), tr("Limit") });
set_input_name(k_preserve_luminance_input, tr("Preserve Luminance"));
}
ShaderCode DespillNode::get_shader_code(const ShaderRequest &request) const
{
Q_UNUSED(request)
return ShaderCode(
FileFunctions::read_file_as_string(":/shaders/despill.frag"));
}
void DespillNode::value(const NodeValueRow &value, const NodeGlobals &globals,
NodeValueTable *table) const
{
ShaderJob job;
job.insert(value);
// Set luma coefficients
double luma_coeffs[3] = { 0.0f, 0.0f, 0.0f };
if (project() && project()->color_manager()) {
project()->color_manager()->get_default_luma_coefs(luma_coeffs);
} else {
luma_coeffs[0] = 0.2126;
luma_coeffs[1] = 0.7152;
luma_coeffs[2] = 0.0722;
}
job.insert(
QStringLiteral("luma_coeffs"),
NodeValue(NodeValue::k_vec3,
QVector3D(luma_coeffs[0], luma_coeffs[1], luma_coeffs[2])));
// If there's no texture, no need to run an operation
if (TexturePtr tex = job.get(k_texture_input).to_texture()) {
table->push(NodeValue::k_texture, tex->to_job(job), this);
}
}
} // namespace olive
+52
View File
@@ -0,0 +1,52 @@
/***
Olive - Non-Linear Video Editor
Copyright (C) 2019 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/>.
***/
#ifndef OAK_DESPILLNODE_H
#define OAK_DESPILLNODE_H
#include "node/node.h"
#include "node/color/colormanager/colormanager.h"
namespace olive
{
class DespillNode : public Node {
public:
DespillNode();
NODE_DEFAULT_FUNCTIONS(DespillNode)
virtual QString name() const override;
virtual QString id() const override;
virtual QVector<CategoryID> category() const override;
virtual QString description() const override;
virtual void retranslate() override;
virtual ShaderCode
get_shader_code(const ShaderRequest &request) const override;
virtual void value(const NodeValueRow &value, const NodeGlobals &globals,
NodeValueTable *table) const override;
static const QString k_texture_input;
static const QString k_color_input;
static const QString k_method_input;
static const QString k_preserve_luminance_input;
};
} // namespace olive
#endif // OAK_DESPILLNODE_H