oak-team/oak-editor
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

refactor(plugin): de-Qt oakplugin and wrap it in a pure C ABI

Browse Source 
- de-Qt src/plugin/src (olivehost/oliveplugininstance/oliveclip/
  paraminstance/image/pluginprogressreporter); QMessageBox/
  QApplication replaced by facade callbacks
- new C ABI in include/plugin/{error,host,instance}.h with
  refcounted OakPluginInstance value handle
- paraminstance bridges via oaknode C ABI (OakNodeNode value handle,
  oaknode_node_identity registry); undo via oakundo C ABI
- oliveclip textures are OakRenderTexture value handles; oakrender
  gains texture/copier/ticket C API additions
- oaknode gains get_input_at_time/set_input_at_time_undoable/
  node_identity/sequence_from_node/sequence_set_default_parameters/
  find_input_footage
- move avframeptr.h to src/common/src (shared by codec and render)
- node transition pluginSupport stubs bridge the real oakplugin
  headers; all oaknode-building standalone trees add src/plugin and
  link oakplugin into their test binaries
- plugin tests self-sufficient (ipc shim, OfxHost force_load,
  PRE_TEST discovery, OCIO env); timeline standalone gains
  render/c_api
- restore ffmpegdecoder.cpp in src/codec/src/ffmpeg/CMakeLists.txt
  (dropped in 3d004c081, caused jump-to-0 in decoder/encoder tests)

All six standalone trees green: codec 22, audio 40, task 110,
render 49, timeline 121, plugin 100.
This commit is contained in:
Mike-Solar
2026-08-07 22:18:36 +08:00
parent 0462842f8c
commit fd2111d560
54 changed files with 6014 additions and 324 deletions
Download Patch File Download Diff File Expand all files Collapse all files
src/render/c_api/internalhandles.h
+3
View File
@@ -52,6 +52,8 @@
#include "alivecount.h"
#include "avframeptr.h"
#include "codec/frame.h"
#include "colorprocessor.h"
#include "texture.h"
@@ -70,6 +72,7 @@ struct OakRenderTextureImpl {
*/
struct OakCodecFrameImpl {
olive::FramePtr ptr;
olive::AVFramePtr avptr; /**< Set when wrapping a texture's CPU copy. */
};
/**
src/render/c_api/renderer.cpp
+87
View File
@@ -363,6 +363,9 @@ void *oakrender_codec_frame_data(OakCodecFrame frame)
if (!f || !f->ptr) {
return nullptr;
}
if (f->avptr) {
return f->avptr->data(0);
}
return f->ptr->data();
}
@@ -380,6 +383,9 @@ int oakrender_codec_frame_linesize_bytes(OakCodecFrame frame)
{
OakCodecFrameImpl *f =
oakrender_c_api::to_native<OakCodecFrameImpl>(frame);
if (f && f->avptr) {
return f->avptr->linesize(0);
}
if (!f || !f->ptr) {
return 0;
}
@@ -508,3 +514,84 @@ int oakrender_current_backend(char *buf, int n)
}
return write_string(g_requested_backend, buf, n);
}
int oakrender_display_texture_is_dummy(OakRenderTexture texture)
{
if (!texture.ctx) {
return 0;
}
return oakrender_c_api::to_native<OakRenderTextureImpl>(texture)
->ptr->is_dummy()
? 1
: 0;
}
int oakrender_display_texture_get_frame(OakRenderTexture texture,
OakCodecFrame *out)
{
if (!texture.ctx || !out) {
return OAKRENDER_E_INVALID;
}
*out = OakCodecFrame{};
olive::AVFramePtr frame =
oakrender_c_api::to_native<OakRenderTextureImpl>(texture)->ptr->frame();
if (!frame) {
return OAKRENDER_E_NOT_FOUND;
}
// The texture's CPU copy is an AVFramePtr (ffmpeg_bridge RAII); wrap
// the shared_ptr so the frame stays alive with the handle.
auto *fimpl = new OakCodecFrameImpl;
fimpl->avptr = frame;
*out = oakrender_c_api::make_handle<OakCodecFrame>(
fimpl, true, &oakrender_c_api::delete_as<OakCodecFrameImpl>);
return out->ctx ? OAKRENDER_OK : OAKRENDER_E_NOMEM;
}
OakRenderTexture oakrender_display_texture_wrap_native(
const olive::TexturePtr &texture)
{
if (!texture) {
return OakRenderTexture{};
}
auto *impl = new OakRenderTextureImpl;
impl->ptr = texture;
return oakrender_c_api::make_handle<OakRenderTexture>(
impl, true, &oakrender_c_api::delete_as<OakRenderTextureImpl>);
}
int oakrender_codec_frame_width(OakCodecFrame frame)
{
OakCodecFrameImpl *f =
oakrender_c_api::to_native<OakCodecFrameImpl>(frame);
if (!f) {
return 0;
}
if (f->avptr) {
return f->avptr->width();
}
return f->ptr ? f->ptr->width() : 0;
}
int oakrender_codec_frame_height(OakCodecFrame frame)
{
OakCodecFrameImpl *f =
oakrender_c_api::to_native<OakCodecFrameImpl>(frame);
if (!f) {
return 0;
}
if (f->avptr) {
return f->avptr->height();
}
return f->ptr ? f->ptr->height() : 0;
}
int oakrender_codec_frame_fb_format(OakCodecFrame frame)
{
OakCodecFrameImpl *f =
oakrender_c_api::to_native<OakCodecFrameImpl>(frame);
if (!f || !f->avptr) {
return -1;
}
return f->avptr->format();
}
src/render/src/texture.h
+1 -1
View File
@@ -22,7 +22,7 @@
#ifndef OAK_RENDERTEXTURE_H
#define OAK_RENDERTEXTURE_H
#include "common/avframeptr.h"
#include "avframeptr.h"
#include <atomic>
#include <memory>
src/render/standalone/CMakeLists.txt
+1
View File
@@ -154,3 +154,4 @@ if(BUILD_TESTS)
enable_testing()
add_subdirectory(${OAK_REPO_ROOT}/src/render/tests ${CMAKE_BINARY_DIR}/render_tests)
endif()
add_subdirectory(${OAK_REPO_ROOT}/src/plugin ${CMAKE_BINARY_DIR}/plugin)
src/render/tests/CMakeLists.txt
+1
View File
@@ -28,6 +28,7 @@ target_link_libraries(oakrender-gtest PRIVATE
oaktimeline
oakrender
oaknode
oakplugin
oakcommon
oakundo
olivecore
src/render/transition/common/avframeptr.h
-140
View File
@@ -1,140 +0,0 @@
// Transitional copy of engine/common/avframeptr.h（本身已无 Qt，待下沉 oakcommon）。只增不删。
/***
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/>.
***/
#ifndef OAK_AVFRAMEPTR_H
#define OAK_AVFRAMEPTR_H
#include <stdint.h>
#include <memory>
#include <ffmpeg_bridge/ffmpeg_bridge.h>
namespace olive
{
/**
* @brief C++ adapter around the ffmpeg_bridge frame handle
*
* Mirrors the AVFrame field access the codebase used to perform directly,
* but every operation goes through the pure C bridge API so the editor
* never touches FFmpeg itself. The underlying frame object always lives
* inside the bridge library.
*/
class AVFrame {
public:
AVFrame() :
handle_(fb_frame_alloc())
{
}
explicit AVFrame(FBFrame *handle) :
handle_(handle)
{
}
~AVFrame()
{
if (handle_) {
fb_frame_free(&handle_);
}
}
AVFrame(const AVFrame &) = delete;
AVFrame &operator=(const AVFrame &) = delete;
FBFrame *handle() const { return handle_; }
int width() const { return fb_frame_get_width(handle_); }
void set_width(int w) { fb_frame_set_width(handle_, w); }
int height() const { return fb_frame_get_height(handle_); }
void set_height(int h) { fb_frame_set_height(handle_, h); }
int format() const { return fb_frame_get_format(handle_); }
void set_format(int f) { fb_frame_set_format(handle_, f); }
int64_t pts() const { return fb_frame_get_pts(handle_); }
void set_pts(int64_t p) { fb_frame_set_pts(handle_, p); }
int64_t best_effort_timestamp() const
{
return fb_frame_get_best_effort_timestamp(handle_);
}
int nb_samples() const { return fb_frame_get_nb_samples(handle_); }
void set_nb_samples(int n) { fb_frame_set_nb_samples(handle_, n); }
int sample_rate() const { return fb_frame_get_sample_rate(handle_); }
void set_sample_rate(int r) { fb_frame_set_sample_rate(handle_, r); }
int color_range() const { return fb_frame_get_color_range(handle_); }
void set_color_range(int r) { fb_frame_set_color_range(handle_, r); }
int colorspace() const { return fb_frame_get_colorspace(handle_); }
void set_colorspace(int cs) { fb_frame_set_colorspace(handle_, cs); }
uint64_t channel_layout_mask() const
{
return fb_frame_get_channel_layout_mask(handle_);
}
void set_channel_layout_mask(uint64_t m)
{
fb_frame_set_channel_layout_mask(handle_, m);
}
bool is_hw() const { return fb_frame_is_hw(handle_) != 0; }
int hw_transfer_data(const AVFrame *src)
{
return fb_frame_hw_transfer_data(handle_, src->handle_);
}
int get_buffer(int align) { return fb_frame_get_buffer(handle_, align); }
int make_writable() { return fb_frame_make_writable(handle_); }
uint8_t *data(int plane) { return fb_frame_get_data(handle_, plane); }
const uint8_t *data(int plane) const
{
return fb_frame_get_data_const(handle_, plane);
}
void set_data(int plane, uint8_t *d)
{
fb_frame_set_data(handle_, plane, d);
}
int linesize(int plane) const
{
return fb_frame_get_linesize(handle_, plane);
}
void set_linesize(int plane, int l)
{
fb_frame_set_linesize(handle_, plane, l);
}
private:
FBFrame *handle_;
};
using AVFramePtr = std::shared_ptr<AVFrame>;
inline AVFramePtr create_av_frame_ptr(FBFrame *f)
{
return std::make_shared<AVFrame>(f);
}
inline AVFramePtr create_av_frame_ptr()
{
return std::make_shared<AVFrame>();
}
}
#endif // OAK_AVFRAMEPTR_H