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,214 @@
+/***
+
+  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 "renderticket.h"
+
+namespace olive
+{
+
+RenderTicket::RenderTicket()
+	: is_running_(false)
+	, has_result_(false)
+	, finish_count_(0)
+{
+}
+
+void RenderTicket::wait_for_finished(QMutex *mutex)
+{
+	if (is_running_) {
+		wait_.wait(mutex);
+	}
+}
+
+void RenderTicket::start()
+{
+	QMutexLocker locker(&lock_);
+
+	is_running_ = true;
+	has_result_ = false;
+	result_.clear();
+}
+
+void RenderTicket::finish()
+{
+	finish_internal(false, QVariant());
+}
+
+void RenderTicket::finish(QVariant result)
+{
+	finish_internal(true, result);
+}
+
+QVariant RenderTicket::get()
+{
+	wait_for_finished();
+
+	// We don't have to mutex around this because there is no way to write to `result_` after
+	// the ticket has finished and the above function blocks the calling thread until it is finished
+	return result_;
+}
+
+void RenderTicket::wait_for_finished()
+{
+	QMutexLocker locker(&lock_);
+
+	wait_for_finished(&lock_);
+}
+
+bool RenderTicket::is_running(bool lock)
+{
+	if (lock) {
+		lock_.lock();
+	}
+
+	bool running = is_running_;
+
+	if (lock) {
+		lock_.unlock();
+	}
+
+	return running;
+}
+
+int RenderTicket::get_finish_count(bool lock)
+{
+	if (lock) {
+		lock_.lock();
+	}
+
+	int count = finish_count_;
+
+	if (lock) {
+		lock_.unlock();
+	}
+
+	return count;
+}
+
+bool RenderTicket::has_result()
+{
+	QMutexLocker locker(&lock_);
+
+	return has_result_;
+}
+
+void RenderTicket::finish_internal(bool has_result, QVariant result)
+{
+	QMutexLocker locker(&lock_);
+
+	if (!is_running_) {
+		qWarning() << "Tried to finish ticket that wasn't running";
+	} else {
+		is_running_ = false;
+		has_result_ = has_result;
+		result_ = result;
+		finish_count_++;
+
+		wait_.wakeAll();
+
+		locker.unlock();
+
+		emit finished();
+	}
+}
+
+RenderTicketWatcher::RenderTicketWatcher(QObject *parent)
+	: QObject(parent)
+	, ticket_(nullptr)
+{
+}
+
+void RenderTicketWatcher::set_ticket(RenderTicketPtr ticket)
+{
+	if (ticket_) {
+		qCritical() << "Tried to set a ticket on a RenderTicketWatcher twice";
+		return;
+	}
+
+	if (!ticket) {
+		qCritical() << "Tried to set a null ticket on a RenderTicketWatcher";
+		return;
+	}
+
+	ticket_ = ticket;
+
+	// Lock ticket so we can query if it's already finished by the time this code runs
+	QMutexLocker locker(ticket->lock());
+
+	connect(ticket_.get(), &RenderTicket::finished, this,
+			&RenderTicketWatcher::ticket_finished);
+
+	if (!ticket_->is_running(false) && ticket_->get_finish_count(false) > 0) {
+		// Ticket has already finished before, so we emit a signal asynchronously
+		// to avoid deleting this watcher before the caller has a chance to use
+		// the returned pointer.
+		QMetaObject::invokeMethod(this, &RenderTicketWatcher::ticket_finished,
+								  Qt::QueuedConnection);
+	}
+}
+
+bool RenderTicketWatcher::is_running()
+{
+	if (ticket_) {
+		return ticket_->is_running();
+	} else {
+		return false;
+	}
+}
+
+void RenderTicketWatcher::wait_for_finished()
+{
+	if (ticket_) {
+		ticket_->wait_for_finished();
+	}
+}
+
+QVariant RenderTicketWatcher::get()
+{
+	if (ticket_) {
+		return ticket_->get();
+	} else {
+		return QVariant();
+	}
+}
+
+bool RenderTicketWatcher::has_result()
+{
+	if (ticket_) {
+		return ticket_->has_result();
+	} else {
+		return false;
+	}
+}
+
+void RenderTicketWatcher::cancel()
+{
+	if (ticket_) {
+		ticket_->cancel();
+	}
+}
+
+void RenderTicketWatcher::ticket_finished()
+{
+	emit finished(this);
+}
+
+}