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)
2026-07-20 03:23:28 +08:00
parent 026ff94b5e
commit 28c4426236
604 changed files with 243 additions and 172 deletions
@@ -0,0 +1,378 @@
+/***
+
+  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 "loadotio.h"
+
+#ifdef USE_OTIO
+
+#include <opentimelineio/clip.h>
+#include <opentimelineio/externalReference.h>
+#include <opentimelineio/gap.h>
+#include <opentimelineio/serializableCollection.h>
+#include <opentimelineio/timeline.h>
+#include <opentimelineio/transition.h>
+#include <QApplication>
+#include <QFileInfo>
+#include <QThread>
+
+#include "coreengine.h"
+#include "node/audio/volume/volume.h"
+#include "node/block/clip/clip.h"
+#include "node/block/gap/gap.h"
+#include "node/block/transition/crossdissolve/crossdissolvetransition.h"
+#include "node/distort/transform/transformdistortnode.h"
+#include "node/generator/matrix/matrix.h"
+#include "node/math/math/math.h"
+#include "node/nodeundo.h"
+#include "node/project/folder/folder.h"
+#include "node/project/footage/footage.h"
+#include "node/project/sequence/sequence.h"
+#include "timeline/timelineundogeneral.h"
+#include "window/mainwindow/mainwindowundo.h"
+
+namespace olive
+{
+
+LoadOTIOTask::LoadOTIOTask(const QString &s)
+	: ProjectLoadBaseTask(s)
+{
+}
+
+bool LoadOTIOTask::Run()
+{
+	OTIO::ErrorStatus es;
+
+	auto root = OTIO::SerializableObjectWithMetadata::from_json_file(
+		GetFilename().toStdString(), &es);
+
+	if (es.outcome != OTIO::ErrorStatus::Outcome::OK) {
+		SetError(
+			tr("Failed to load OpenTimelineIO from file \"%1\" \n\nOpenTimelineIO Error:\n\n%2")
+				.arg(GetFilename(),
+					 QString::fromStdString(es.full_description)));
+		return false;
+	}
+
+	project_ = new Project();
+	project_->Initialize();
+	project_->set_modified(true);
+
+	std::vector<OTIO::Timeline *> timelines;
+
+	if (root->schema_name() == "SerializableCollection") {
+		// This is a number of timelines
+		std::vector<OTIO::SerializableObject::Retainer<OTIO::SerializableObject>>
+			&root_children =
+				static_cast<OTIO::SerializableCollection *>(root)->children();
+
+		timelines.resize(root_children.size());
+		for (size_t j = 0; j < root_children.size(); j++) {
+			timelines[j] =
+				static_cast<OTIO::Timeline *>(root_children[j].value);
+		}
+	} else if (root->schema_name() == "Timeline") {
+		// This is a single timeline
+		timelines.push_back(static_cast<OTIO::Timeline *>(root));
+	} else {
+		// Unknown root, we don't know what to do with this
+		SetError(tr("Unknown OpenTimelineIO root element"));
+		delete project_;
+		project_ = nullptr;
+		return false;
+	}
+
+	// Keep track of imported footage
+	QMap<QString, Footage *> imported_footage;
+	QMap<OTIO::Timeline *, Sequence *> timeline_sequnce_map;
+
+	// Variables used for loading bar
+	float number_of_clips = 0;
+	float clips_done = 0;
+
+	// Generate a list of sequences with the same names as the timelines.
+	// Assumes each timeline has a unique name.
+	int unnamed_sequence_count = 0;
+	foreach (auto timeline, timelines) {
+		Sequence *sequence = new Sequence();
+		if (!timeline->name().empty()) {
+			sequence->SetLabel(QString::fromStdString(timeline->name()));
+		} else {
+			// If the otio timeline does not provide a name, create a default one here
+			unnamed_sequence_count++;
+			QString label = tr("Sequence %1").arg(unnamed_sequence_count);
+			sequence->SetLabel(QString::fromStdString(label.toStdString()));
+		}
+		// Set default params incase they aren't edited.
+		sequence->set_default_parameters();
+		timeline_sequnce_map.insert(timeline, sequence);
+
+		// Get number of clips for loading bar
+		foreach (auto track, timeline->tracks()->children()) {
+			auto otio_track = static_cast<OTIO::Track *>(track.value);
+			number_of_clips += otio_track->children().size();
+		}
+	}
+
+	// Dialog has to be called from the main thread so we pass the list of sequences here.
+	bool accepted = false;
+	QMetaObject::invokeMethod(
+		EngineCore::instance(), "show_otio_import_dialog", Qt::BlockingQueuedConnection,
+		Q_RETURN_ARG(bool, accepted),
+		Q_ARG(QList<Sequence *>, timeline_sequnce_map.values()));
+
+	if (!accepted) {
+		// Cancel to indicate to caller that this task did not complete and to simply dispose of it
+		Cancel();
+		qDeleteAll(timeline_sequnce_map); // Clear sequences
+		return true;
+	}
+
+	foreach (auto timeline, timeline_sequnce_map.keys()) {
+		Sequence *sequence = timeline_sequnce_map.value(timeline);
+		sequence->setParent(project_);
+		FolderAddChild(project_->root(), sequence).redo_now();
+
+		// Create a folder for this sequence's footage
+		Folder *sequence_footage = new Folder();
+		sequence_footage->SetLabel(QString::fromStdString(timeline->name()));
+		sequence_footage->setParent(project_);
+		FolderAddChild(project_->root(), sequence_footage).redo_now();
+
+		// Iterate through tracks
+		for (auto c : timeline->tracks()->children()) {
+			auto otio_track = static_cast<OTIO::Track *>(c.value);
+
+			// Create a new track
+			Track *track = nullptr;
+
+			// Determine what kind of track it is
+			if (otio_track->kind() == "Video" ||
+				otio_track->kind() == "Audio") {
+				Track::Type type;
+
+				if (otio_track->kind() == "Video") {
+					type = Track::kVideo;
+				} else {
+					type = Track::kAudio;
+				}
+
+				// Create track
+				TimelineAddTrackCommand t(sequence->track_list(type));
+				t.redo_now();
+				track = t.track();
+			} else {
+				qWarning() << "Found unknown track type:"
+						   << otio_track->kind().c_str();
+				continue;
+			}
+
+			// Get clips from track
+			auto clip_map = otio_track->children();
+			if (es.outcome != OTIO::ErrorStatus::Outcome::OK) {
+				SetError(tr("Failed to load clip"));
+				return false;
+			}
+
+			Block *previous_block = nullptr;
+			bool prev_block_transition = false;
+
+			for (auto otio_block_retainer : clip_map) {
+				auto otio_block = otio_block_retainer.value;
+
+				Block *block = nullptr;
+
+				if (otio_block->schema_name() == "Clip") {
+					block = new ClipBlock();
+
+				} else if (otio_block->schema_name() == "Gap") {
+					block = new GapBlock();
+
+				} else if (otio_block->schema_name() == "Transition") {
+					// Todo: Look into OTIO supported transitions and add them to Olive
+					block = new CrossDissolveTransition();
+
+				} else {
+					// We don't know what this is yet, just create a gap for now so that *something* is there
+					qWarning() << "Found unknown block type:"
+							   << otio_block->schema_name().c_str();
+					block = new GapBlock();
+				}
+
+				block->setParent(project_);
+				block->SetLabel(QString::fromStdString(otio_block->name()));
+
+				track->AppendBlock(block);
+
+				Rational start_time;
+				Rational duration;
+
+				if (otio_block->schema_name() == "Clip" ||
+					otio_block->schema_name() == "Gap") {
+					start_time = Rational::fromDouble(
+						static_cast<OTIO::Item *>(otio_block)
+							->source_range()
+							->start_time()
+							.to_seconds());
+					duration = Rational::fromDouble(
+						static_cast<OTIO::Item *>(otio_block)
+							->source_range()
+							->duration()
+							.to_seconds());
+
+					if (otio_block->schema_name() == "Clip") {
+						static_cast<ClipBlock *>(block)->set_media_in(
+							start_time);
+					}
+					block->set_length_and_media_out(duration);
+				}
+
+				// If the previous block was a transition, connect the current block to it
+				if (prev_block_transition) {
+					TransitionBlock *previous_transition_block =
+						static_cast<TransitionBlock *>(previous_block);
+					Node::ConnectEdge(
+						block, NodeInput(previous_transition_block,
+										 TransitionBlock::kInBlockInput));
+					prev_block_transition = false;
+				}
+
+				if (otio_block->schema_name() == "Transition") {
+					TransitionBlock *transition_block =
+						static_cast<TransitionBlock *>(block);
+					OTIO::Transition *otio_block_transition =
+						static_cast<OTIO::Transition *>(otio_block);
+
+					// Set how far the transition eats into the previous clip
+					transition_block->set_offsets_and_length(
+						Rational::fromRationalTime(
+							otio_block_transition->in_offset()),
+						Rational::fromRationalTime(
+							otio_block_transition->out_offset()));
+
+					if (previous_block) {
+						Node::ConnectEdge(
+							previous_block,
+							NodeInput(transition_block,
+									  TransitionBlock::kOutBlockInput));
+					}
+					prev_block_transition = true;
+
+					// Add nodes to the graph and set up contexts
+					block->setParent(sequence->parent());
+
+					// Position transition in its own context
+					block->SetNodePositionInContext(block, QPointF(0, 0));
+				}
+
+				if (otio_block->schema_name() == "Gap") {
+					// Add nodes to the graph and set up contexts
+					block->setParent(sequence->parent());
+
+					// Position transition in its own context
+					block->SetNodePositionInContext(block, QPointF(0, 0));
+				}
+
+				// Update this after it's used but before any continue statements
+				previous_block = block;
+
+				if (otio_block->schema_name() == "Clip") {
+					auto otio_clip = static_cast<OTIO::Clip *>(otio_block);
+					if (!otio_clip->media_reference()) {
+						continue;
+					}
+					if (otio_clip->media_reference()->schema_name() ==
+						"ExternalReference") {
+						// Link footage
+						QString footage_url = QString::fromStdString(
+							static_cast<OTIO::ExternalReference *>(
+								otio_clip->media_reference())
+								->target_url());
+
+						Footage *probed_item;
+
+						if (imported_footage.contains(footage_url)) {
+							probed_item = imported_footage.value(footage_url);
+						} else {
+							probed_item = new Footage(footage_url);
+							imported_footage.insert(footage_url, probed_item);
+							probed_item->setParent(project_);
+
+							QFileInfo info(probed_item->filename());
+							probed_item->SetLabel(info.fileName());
+
+							FolderAddChild add(sequence_footage, probed_item);
+							add.redo_now();
+						}
+
+						// Add nodes to the graph and set up contexts
+						block->setParent(sequence->parent());
+
+						// Position clip in its own context
+						block->SetNodePositionInContext(block, QPointF(0, 0));
+
+						// Position footage in its context
+						block->SetNodePositionInContext(probed_item,
+														QPointF(-2, 0));
+
+						if (track->type() == Track::kVideo) {
+							TransformDistortNode *transform =
+								new TransformDistortNode();
+							transform->setParent(sequence->parent());
+
+							Node::ConnectEdge(
+								probed_item,
+								NodeInput(transform,
+										  TransformDistortNode::kTextureInput));
+							Node::ConnectEdge(transform,
+											  NodeInput(block,
+														ClipBlock::kBufferIn));
+							block->SetNodePositionInContext(transform,
+															QPointF(-1, 0));
+						} else {
+							VolumeNode *volume_node = new VolumeNode();
+							volume_node->setParent(sequence->parent());
+
+							Node::ConnectEdge(
+								probed_item,
+								NodeInput(volume_node,
+										  VolumeNode::kSamplesInput));
+							Node::ConnectEdge(volume_node,
+											  NodeInput(block,
+														ClipBlock::kBufferIn));
+							block->SetNodePositionInContext(volume_node,
+															QPointF(-1, 0));
+						}
+					}
+				}
+				clips_done++;
+				emit ProgressChanged(clips_done / number_of_clips);
+			}
+		}
+	}
+
+	project_->moveToThread(qApp->thread());
+
+	return true;
+}
+
+}
+
+#endif // USE_OTIO