feat: implement plugin system

Author: Hip-po

CMakeLists.txt

@@ -107,28 +107,11 @@ set(SOURCES
     # --- Core ---
     src/core/Core.cpp
 
-    # --- Inputs ---
+    # --- Input Runtime ---
     src/input/AInput.cpp
-    # Media
-    src/input/media/Image.cpp
-    src/input/media/WebImage.cpp
-    src/input/media/Video.cpp
-    # Text
-    src/input/text/Text.cpp
-    # Shape
-    src/input/shape/Circle.cpp
-    src/input/shape/Rectangle.cpp
-    src/input/shape/Line.cpp
-
-    # --- Fragment Shader ---
-    src/shader/Grayscale.cpp
-    src/shader/Opacity.cpp
-    src/shader/Blur.cpp
-    src/shader/Gamma.cpp
-    src/shader/Grain.cpp
-    src/shader/Brightness.cpp
-    src/shader/Contrast.cpp
-    src/shader/Sharpen.cpp
+
+    # --- Plugin Runtime ---
+    src/plugin/PluginRegistry.cpp
 )
 
 add_executable(${PROJECT_NAME} ${SOURCES})
@@ -145,6 +128,7 @@ target_link_libraries(${PROJECT_NAME}
     argparse::argparse
     nlohmann_json::nlohmann_json
     ${OpenCV_LIBS}
+    ${CMAKE_DL_LIBS}
     ${FFMPEG_LIBRARIES}
     Qt6::Widgets
     Qt6::Core

docs/user/user.md

@@ -45,15 +45,20 @@ go to [qt6](https://www.qt.io/download) and download the latest version of qt6.
     cp build/video-code video-code
     ```
 
+5. **Build plugins (decoupled from main build):**
+  ```sh
+  ./scripts/build_plugins.sh plugins/build
+  ```
+
 ### Launch
 
 To launch the project, run:
 ```sh
-./video-code --file path/to/your/script.py
+./video-code --file path/to/your/script.py --plugin-dir plugins/build
 ```
 If you want to generate a video directly, use:
 ```sh
-./video-code --file path/to/your/script.py --generate
+./video-code --file path/to/your/script.py --generate output.mp4 --plugin-dir plugins/build
 
 ```
 

include/core/Core.hpp

@@ -13,6 +13,7 @@
 #include <opencv2/opencv.hpp>
 
 #include "input/IInput.hpp"
+#include "plugin/PluginRegistry.hpp"
 
 namespace VC
 {
@@ -64,6 +65,7 @@ namespace VC
         ///< Source & Output file
         const std::string _sourceFile;
         const std::string _outputFile;
+        const std::string _pluginDir;
 
         ///< Background frame, black with alpha 0
         const cv::Mat _bgFrame;
@@ -80,5 +82,8 @@ namespace VC
 
         ///< Stack containing the steps of the video
         json::array_t _stack{};
+
+        ///< Runtime plugin registry
+        PluginRegistry _pluginRegistry{};
     };
 };

include/input/AInput.hpp

@@ -10,6 +10,7 @@
 #include <memory>
 #include <nlohmann/json.hpp>
 #include <opencv2/core/mat.hpp>
+#include <string>
 #include <vector>
 
 #include "input/IInput.hpp"
@@ -29,6 +30,8 @@ class AInput : public IInput
 
     void add(nlohmann::basic_json<>& modification) final;
 
+    void setShaderFactory(void* context, ShaderFactoryCallback callback) final;
+
     // -
 
     Metadata getMetadata(size_t index);
@@ -41,6 +44,9 @@ class AInput : public IInput
 
 protected:
 
+    void* _shaderFactoryContext{nullptr};
+    ShaderFactoryCallback _shaderFactory{nullptr};
+
     ///< Arguments needed to generate the Input's matrix
     const json::object_t _baseArgs;
 

include/input/IInput.hpp

@@ -7,15 +7,22 @@
 
 #pragma once
 
+#include <functional>
+#include <memory>
 #include <nlohmann/json.hpp>
 #include <opencv2/core/mat.hpp>
+#include <string>
+
+#include "shader/IFragmentShader.hpp"
 
 using json = nlohmann::json;
 
 class IInput
 {
 public:
 
+    using ShaderFactoryCallback = std::unique_ptr<IFragmentShader> (*)(void* context, const std::string& name, const json::object_t& args);
+
     IInput() = default;
     virtual ~IInput() = default;
 
@@ -32,4 +39,12 @@ class IInput
     virtual void overlay(cv::Mat& bg, size_t t) = 0;
 
     // -
+
+    virtual void setShaderFactory(void* context, ShaderFactoryCallback callback) = 0;
+
+    // -
+
+    virtual size_t maxFrameHint() const { return 0; }
+
+    // -
 };

include/plugin/PluginAPI.hpp

@@ -0,0 +1,34 @@
+/*
+** EPITECH PROJECT, 2026
+** video-code
+** File description:
+** Plugin API
+*/
+
+#pragma once
+
+#include <memory>
+#include <nlohmann/json.hpp>
+
+#include "input/IInput.hpp"
+#include "shader/IFragmentShader.hpp"
+
+namespace VC
+{
+    using InputFactoryFunction = std::unique_ptr<IInput> (*)(nlohmann::json::object_t&& args);
+    using FragmentShaderFactoryFunction = std::unique_ptr<IFragmentShader> (*)(const nlohmann::json::object_t& args);
+
+    using RegisterInputFunction = void (*)(void* context, const char* name, InputFactoryFunction factory);
+    using RegisterFragmentShaderFunction = void (*)(void* context, const char* name, FragmentShaderFactoryFunction factory);
+
+    struct PluginRegistrar
+    {
+        void* context;
+        RegisterInputFunction registerInput;
+        RegisterFragmentShaderFunction registerFragmentShader;
+    };
+}
+
+extern "C" {
+using VCRegisterPluginFunction = void (*)(VC::PluginRegistrar* registrar);
+}

include/plugin/PluginRegistry.hpp

@@ -0,0 +1,42 @@
+/*
+** EPITECH PROJECT, 2026
+** video-code
+** File description:
+** Plugin registry
+*/
+
+#pragma once
+
+#include <filesystem>
+#include <map>
+#include <memory>
+#include <nlohmann/json.hpp>
+#include <string>
+#include <vector>
+
+#include "plugin/PluginAPI.hpp"
+
+namespace VC
+{
+    class PluginRegistry
+    {
+    public:
+
+        void registerInput(const std::string& name, InputFactoryFunction factory);
+        void registerFragmentShader(const std::string& name, FragmentShaderFactoryFunction factory);
+
+        std::unique_ptr<IInput> createInput(const std::string& name, nlohmann::json::object_t&& args) const;
+        std::unique_ptr<IFragmentShader> createFragmentShader(const std::string& name, const nlohmann::json::object_t& args) const;
+
+        void loadPluginDirectories(const std::vector<std::string>& directories);
+
+    private:
+
+        void loadMetadataFile(const std::filesystem::path& metadataPath);
+        void loadCppPlugin(const std::filesystem::path& metadataPath, const std::filesystem::path& libraryPath);
+
+        std::map<std::string, InputFactoryFunction> _inputFactories{};
+        std::map<std::string, FragmentShaderFactoryFunction> _shaderFactories{};
+        std::vector<void*> _libraryHandles{};
+    };
+}

plugins/sources/blur/cpp/CMakeLists.txt

@@ -0,0 +1,13 @@
+cmake_minimum_required(VERSION 3.21)
+project(vc-plugin-blur LANGUAGES CXX)
+set(CMAKE_CXX_STANDARD 20)
+set(CMAKE_CXX_STANDARD_REQUIRED ON)
+if(NOT VIDEO_CODE_ROOT)
+  message(FATAL_ERROR "VIDEO_CODE_ROOT must be provided")
+endif()
+find_package(OpenCV REQUIRED)
+find_package(nlohmann_json CONFIG REQUIRED)
+add_library(blur_plugin SHARED blur_plugin.cpp)
+target_include_directories(blur_plugin PRIVATE ${VIDEO_CODE_ROOT}/include)
+target_link_libraries(blur_plugin PRIVATE ${OpenCV_LIBS} nlohmann_json::nlohmann_json)
+set_target_properties(blur_plugin PROPERTIES OUTPUT_NAME "blur_plugin")

plugins/sources/blur/cpp/blur_plugin.cpp

@@ -0,0 +1,47 @@
+#include <cmath>
+#include <opencv2/opencv.hpp>
+
+#include "plugin/PluginAPI.hpp"
+
+class Blur final : public IFragmentShader
+{
+public:
+    explicit Blur(const nlohmann::json::object_t& args)
+        : _start(args.at("start").get<size_t>())
+        , _args(args)
+    {
+    }
+
+    size_t start() const override
+    {
+        return _start;
+    }
+
+    void render(cv::Mat& mat, size_t) const override
+    {
+        size_t strength = _args.at("strength");
+
+        if (strength < 1) {
+            strength = 1;
+        }
+        if (strength % 2 == 0) {
+            strength++;
+        }
+
+        cv::GaussianBlur(mat, mat, cv::Size(strength, strength), 0);
+    }
+
+private:
+    size_t _start;
+    nlohmann::json::object_t _args;
+};
+
+static std::unique_ptr<IFragmentShader> createShader(const nlohmann::json::object_t& args)
+{
+    return std::make_unique<Blur>(args);
+}
+
+extern "C" void vc_register_plugin(VC::PluginRegistrar* registrar)
+{
+    registrar->registerFragmentShader(registrar->context, "Blur", createShader);
+}

plugins/sources/blur/python/blur_plugin.py

@@ -0,0 +1,11 @@
+from videocode.shader.ishader import FragmentShader
+from videocode.ty import *
+
+
+class blur(FragmentShader):
+    def __init__(self, strength: unumber = 1.0):
+        self.strength = strength
+
+
+def register(target):
+    target["blur"] = blur