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,189 @@
+/***
+
+  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 "frame.h"
+
+#include <OpenImageIO/imagebuf.h>
+#include <QDebug>
+#include <QtGlobal>
+#include <QtMath>
+
+#include "common/oiioutils.h"
+#include "render/framemanager.h"
+
+namespace olive
+{
+
+Frame::Frame()
+	: data_(nullptr)
+	, data_size_(0)
+	, timestamp_(0)
+{
+}
+
+Frame::~Frame()
+{
+	destroy();
+}
+
+FramePtr Frame::create()
+{
+	return std::make_shared<Frame>();
+}
+
+const VideoParams &Frame::video_params() const
+{
+	return params_;
+}
+
+void Frame::set_video_params(const VideoParams &params)
+{
+	params_ = params;
+
+	linesize_ = generate_linesize_bytes(width(), params_.format(),
+										params_.channel_count());
+	linesize_pixels_ = linesize_ / params_.get_bytes_per_pixel();
+}
+
+FramePtr Frame::interlace(FramePtr top, FramePtr bottom)
+{
+	if (top->video_params() != bottom->video_params()) {
+		qCritical()
+			<< "Tried to interlace two frames that had incompatible parameters";
+		return nullptr;
+	}
+
+	FramePtr interlaced = Frame::create();
+	interlaced->set_video_params(top->video_params());
+	interlaced->allocate();
+
+	int linesize = interlaced->linesize_bytes();
+
+	for (int i = 0; i < interlaced->height(); i++) {
+		FramePtr which = (i % 2 == 0) ? top : bottom;
+
+		memcpy(interlaced->data() + i * linesize,
+			   which->const_data() + i * linesize, linesize);
+	}
+
+	return interlaced;
+}
+
+int Frame::generate_linesize_bytes(int width, PixelFormat format,
+								   int channel_count)
+{
+	// Align to 32 bytes (not sure if this is necessary?)
+	return VideoParams::get_bytes_per_pixel(format, channel_count) *
+		   ((width + 31) & ~31);
+}
+
+Color Frame::get_pixel(int x, int y) const
+{
+	if (!contains_pixel(x, y)) {
+		return Color();
+	}
+
+	int byte_offset =
+		y * linesize_bytes() + x * video_params().get_bytes_per_pixel();
+
+	return Color(reinterpret_cast<const char *>(data_ + byte_offset),
+				 video_params().format(), video_params().channel_count());
+}
+
+bool Frame::contains_pixel(int x, int y) const
+{
+	return (is_allocated() && x >= 0 && x < width() && y >= 0 && y < height());
+}
+
+void Frame::set_pixel(int x, int y, const Color &c)
+{
+	if (!contains_pixel(x, y)) {
+		return;
+	}
+
+	int byte_offset =
+		y * linesize_bytes() + x * video_params().get_bytes_per_pixel();
+
+	c.to_data(reinterpret_cast<char *>(data_ + byte_offset),
+			 video_params().format(), video_params().channel_count());
+}
+
+bool Frame::allocate()
+{
+	// Assume this frame is intended to be a video frame
+	if (!params_.is_valid()) {
+		qWarning() << "Tried to allocate a frame with invalid parameters";
+		return false;
+	}
+
+	if (is_allocated()) {
+		// Already allocated
+		return true;
+	}
+
+	data_size_ = linesize_ * height();
+	data_ = FrameManager::allocate(data_size_);
+
+	return true;
+}
+
+void Frame::destroy()
+{
+	if (is_allocated()) {
+		FrameManager::deallocate(data_size_, data_);
+
+		data_size_ = 0;
+		data_ = nullptr;
+	}
+}
+
+FramePtr Frame::convert(PixelFormat format) const
+{
+	// Create new params with destination format
+	VideoParams params = params_;
+	params.set_format(format);
+
+	// Create new frame
+	FramePtr converted = Frame::create();
+	converted->set_video_params(params);
+	converted->set_timestamp(timestamp_);
+	converted->allocate();
+
+	// Do the conversion through OIIO for convenience
+	OIIO::ImageBuf src(
+		OIIO::ImageSpec(width(), height(), channel_count(),
+						OIIOUtils::get_oiio_base_type_from_format(this->format())));
+
+	OIIOUtils::frame_to_buffer(this, &src);
+
+	OIIO::ImageBuf dst(OIIO::ImageSpec(
+		converted->width(), converted->height(), channel_count(),
+		OIIOUtils::get_oiio_base_type_from_format(format)));
+
+	if (dst.copy_pixels(src)) {
+		OIIOUtils::buffer_to_frame(&dst, converted.get());
+		return converted;
+	} else {
+		return nullptr;
+	}
+}
+
+}