feat: compile the scenes (no alpha atm)

Author: anpawo

.gitignore

@@ -15,6 +15,8 @@ video/
 *.mkv
 *.jpg
 *.png
+*.mov
+*.webm
 
 # Python
 __pycache__/

Makefile

@@ -72,28 +72,37 @@ LFLAGS			=	-O1 -Wl,-rpath-link,/usr/lib64
 SRC				=	$(SRC_MAIN)				\
 					$(SRC_VM)				\
 					$(SRC_INPUT)			\
-					$(SRC_TRANSFORM)	\
+					$(SRC_TRANSFORM)		\
+					$(SRC_COMPILER)			\
 
 
 SRC_MAIN		=	src/Main.cpp
 
-SRC_VM			=	src/vm/LiveWindow.cpp	\
-					src/vm/WindowEvent.cpp	\
+SRC_VM			=	src/vm/VideoCode.cpp	\
 					src/vm/Register.cpp		\
+					src/vm/AppWindow.cpp	\
+					src/vm/AppEvent.cpp		\
+
+
+SRC_COMPILER	=	src/compiler/generateVideo.cpp	\
 
 
 SRC_INPUT		=	src/input/ABCInput.cpp	\
 					src/input/Image.cpp		\
 					src/input/Video.cpp		\
 
+
 SRC_TRANSFORM	=	$(SRC_TSF_POS)		\
 					$(SRC_TSF_COLOR)	\
 					$(SRC_TSF_OTHER)	\
 
+
 SRC_TSF_POS		=	src/transformation/position/translate.cpp		\
 
+
 SRC_TSF_COLOR	=	src/transformation/color/fade.cpp				\
 
+
 SRC_TSF_OTHER	=	src/transformation/other/overlay.cpp			\
 
 

include/compiler/Compiler.hpp

@@ -0,0 +1,23 @@
+/*
+** EPITECH PROJECT, 2025
+** video-code
+** File description:
+** Compiler
+*/
+
+#pragma once
+
+#include <vector>
+
+#include "opencv2/core/mat.hpp"
+
+namespace Compiler::Writer
+{
+    int generateVideo(
+        int width,
+        int height,
+        int fps,
+        std::string filename,
+        const std::vector<cv::Mat> &frames
+    );
+};

include/vm/WindowEvent.hpp include/vm/AppEvent.hppinclude/vm/WindowEvent.hpp renamed to include/vm/AppEvent.hpp

@@ -7,17 +7,18 @@
 
 #pragma once
 
-#include <map>
+#include <qevent.h>
+#include <qlabel.h>
+#include <qwidget.h>
 
-#include "qevent.h"
-#include "qwidget.h"
+#include <map>
 
-class WindowEvent : public QWidget
+class AppEvent : public QWidget
 {
 public:
 
-    WindowEvent(const std::map<int, std::function<void()>> &events, std::string &sourceFile, int width, int height, std::function<void()> &&mainLoop);
-    ~WindowEvent() = default;
+    AppEvent(const std::map<int, std::function<void()>> &events, const std::string &sourceFile, int width, int height, std::function<void()> &&mainLoop);
+    ~AppEvent() = default;
 
     void mainLoop();
 

include/vm/AppWindow.hpp

@@ -0,0 +1,44 @@
+/*
+** EPITECH PROJECT, 2025
+** video-code
+** File description:
+** AppWindow
+*/
+
+#pragma once
+
+#include "qapplication.h"
+#include "qboxlayout.h"
+#include "qlabel.h"
+#include "qtimer.h"
+#include "vm/AppEvent.hpp"
+
+class AppWindow
+{
+public:
+
+    AppWindow(int argc, char **argv, const std::map<int, std::function<void()>> &events, const std::string &sourceFile, int width, int height, int frameRate, std::function<void(QLabel &imageLabel)> &&mainLoop);
+
+    ///< Start the app
+    int run();
+
+private:
+
+    ///< QT app
+    QApplication _app;
+
+    ///< QT window
+    AppEvent _window;
+
+    ///< Label containing the image
+    QLabel _imageLabel;
+
+    ///< Layout linking the label and the window
+    QVBoxLayout _imageLayout;
+
+    ///< Encapsulation of the Main loop which updates the current frame
+    QTimer _timer;
+
+    ///< Main loop
+    std::function<void(QLabel &imageLabel)> _mainLoop;
+};

include/vm/LiveWindow.hpp include/vm/VideoCode.hppinclude/vm/LiveWindow.hpp renamed to include/vm/VideoCode.hpp

@@ -13,36 +13,32 @@
 #include <cstddef>
 #include <functional>
 #include <map>
+#include <memory>
 #include <nlohmann/json.hpp>
 #include <opencv2/core/mat.hpp>
 #include <string>
 #include <vector>
 
-#include "qboxlayout.h"
 #include "qlabel.h"
 #include "qnamespace.h"
-#include "qtimer.h"
+#include "vm/AppWindow.hpp"
 #include "vm/Register.hpp"
-#include "vm/WindowEvent.hpp"
 
 #define bindCmd(x) ([this]() { this->x(); })
-#define bindInst(x) ([this](const json::array_t &args) { return this->x(args); })
-#define bindTsf(x) ([this](std::shared_ptr<_IInput> input, const json::array_t &args) { return this->x(input, args); })
 
 using json = nlohmann::json;
 
-class LiveWindow
+class VideoCode
 {
 public:
 
-    LiveWindow(int &argc, char **argv, int width, int height, std::string &&_sourceFile = "video.py");
-    ~LiveWindow();
+    VideoCode(int argc, char **argv, int width, int height, std::string sourceFile, bool generate, std::string outputFile);
 
     ///< Start the program
     int run();
 
     ///< Called every loop iteration to update the current frame being displayed
-    void updateFrame();
+    void updateFrame(QLabel &imageLabel);
 
     ///< Set the index of the timeline to a label
     void goToLabel(const std::string &label);
@@ -75,30 +71,15 @@ class LiveWindow
     const int _frameRate{24};
 
     ///< Window size
-    const int _width{1920};
-    const int _height{1080};
+    const int _width;
+    const int _height;
 
     ///< source file
     const std::string _sourceFile;
 
     ///< Black frame for empty timelines
     const cv::Mat _defaultBlackFrame;
 
-    ///< QT app
-    QApplication _app;
-
-    ///< QT window
-    WindowEvent _window;
-
-    ///< Label containing the image
-    QLabel _imageLabel;
-
-    ///< Layout linking the label and the window
-    QVBoxLayout _imageLayout;
-
-    ///< Main loop updating the current frame
-    QTimer _timer;
-
     ///< Current index of the frame of the timeline being displayed
     std::size_t _index{0};
 
@@ -139,4 +120,10 @@ class LiveWindow
 
     ///< Stack containing the transformations to apply to the Inputs
     json::array_t _actionStack{};
+
+    ///< Window to modify the video in real time
+    std::unique_ptr<AppWindow> _app{nullptr};
+
+    ///< Output File for the generation
+    std::string _outputFile;
 };

src/Main.cpp

@@ -5,13 +5,20 @@
 ** Main
 */
 
+#include <argparse/argparse.hpp>
 #include <opencv2/opencv.hpp>
 
-#include "vm/LiveWindow.hpp"
+#include "vm/VideoCode.hpp"
 
 int main(int argc, char *argv[])
 {
-    LiveWindow win(argc, argv, 1920, 1080);
+    argparse::ArgumentParser parser("Video-Code", "", argparse::default_arguments::help);
 
-    return win.run();
+    parser.add_argument("--sourceFile").default_value("video.py").help("file containing the steps to create the video.");
+    parser.add_argument("--generate").nargs(0, 1).default_value("output.mov").help("generate the video.");
+    parser.parse_args(argc, argv);
+
+    VideoCode vc(argc, argv, 1920, 1080, parser.get("--sourceFile"), parser.is_used("--generate"), parser.get<std::string>("--generate"));
+
+    return vc.run();
 }

src/compiler/generateVideo.cpp

@@ -0,0 +1,75 @@
+/*
+** EPITECH PROJECT, 2025
+** video-code
+** File description:
+** generateVideo
+*/
+
+#include <cstdio>
+#include <format>
+
+#include "compiler/Compiler.hpp"
+#include "opencv2/imgcodecs.hpp"
+#include "opencv2/imgproc.hpp"
+#include "utils/Debug.hpp"
+#include "utils/Exception.hpp"
+
+int Compiler::Writer::generateVideo(
+    int width,
+    int height,
+    int fps,
+    std::string filename,
+    const std::vector<cv::Mat> &frames
+)
+{
+    FILE *ffmpegPipe = popen(
+        std::format(
+            "ffmpeg"
+            " -y"                    // override existing file
+            " -f rawvideo"           // rawvideo codec
+            " -pixel_format rgba"    // red green blue alpha
+            " -video_size {}x{}"     // width and height
+            " -framerate {}"         // fps
+            " -an"                   // tells ffmpeg to expect no audio
+            " -i -"                  // the inputs comes from stdin (pipe)
+            " -c:v prores_ks"        // Use VP9 codec (supports alpha)
+            " -pix_fmt yuva444p10le" // Ensure alpha channel is preserved
+            " -loglevel warning"     // display only warnings
+            " {}",                   // output filename
+            width,
+            height,
+            fps,
+            filename
+        )
+            .c_str(),
+        "w"
+    );
+
+    if (!ffmpegPipe)
+    {
+        throw Error("Could not start the ffmpeg pipe.");
+    }
+
+    int i = 0;
+    for (const auto &frame : frames)
+    {
+        i++;
+        cv::Mat rgba_frame = frame;
+        cv::cvtColor(frame, rgba_frame, cv::COLOR_BGRA2RGBA);
+
+        if (i > 10)
+        {
+            break;
+        }
+
+        fwrite(rgba_frame.data, 1, rgba_frame.total() * rgba_frame.elemSize(), ffmpegPipe);
+        fflush(ffmpegPipe);
+    }
+
+    pclose(ffmpegPipe);
+
+    VC_LOG_DEBUG("video generated as:")
+    VC_LOG_DEBUG(filename.c_str())
+
+    return 0;
+}

src/input/Image.cpp

@@ -31,3 +31,6 @@ Image::Image(const std::string& inputName)
 
     _frames = {image};
 }
+
+///< After lots of tests, I feel like opencv crashs with the handling of RGBA.
+///< So I'll keep them BGRA until the last second which is the display.

src/vm/WindowEvent.cpp src/vm/AppEvent.cppsrc/vm/WindowEvent.cpp renamed to src/vm/AppEvent.cpp

@@ -5,9 +5,9 @@
 ** WindowEvent
 */
 
-#include "vm/WindowEvent.hpp"
+#include "vm/AppEvent.hpp"
 
-WindowEvent::WindowEvent(const std::map<int, std::function<void()>> &events, std::string &sourceFile, int width, int height, std::function<void()> &&mainLoop)
+AppEvent::AppEvent(const std::map<int, std::function<void()>> &events, const std::string &sourceFile, int width, int height, std::function<void()> &&mainLoop)
     : _mainLoop(mainLoop)
     , _events(events)
 {
@@ -19,7 +19,7 @@ WindowEvent::WindowEvent(const std::map<int, std::function<void()>> &events, std
     show();
 }
 
-void WindowEvent::mainLoop()
+void AppEvent::mainLoop()
 {
     _mainLoop();
 }