feat: add render video functionality, WIP

only available under linux with many hacks atm, so still heaviliy in WIP

Author: Totto16

src/game/game.cpp

@@ -12,9 +12,20 @@ Game::Game(
         u32 simulation_frequency,
         const ui::Layout& layout,
         bool is_top_level
+)
+    : Game{ service_provider, input,       starting_parameters, std::make_shared<LocalClock>(simulation_frequency),
+            layout,           is_top_level } { }
+
+Game::Game(
+        ServiceProvider* const service_provider,
+        const std::shared_ptr<input::GameInput>& input,
+        const tetrion::StartingParameters& starting_parameters,
+        const std::shared_ptr<ClockSource>& clock_source,
+        const ui::Layout& layout,
+        bool is_top_level
 )
     : ui::Widget{ layout, ui::WidgetType::Component, is_top_level },
-      m_clock_source{ std::make_unique<LocalClock>(simulation_frequency) },
+      m_clock_source{ clock_source },
       m_input{ input } {
 
 

src/game/game.hpp

@@ -12,7 +12,7 @@ struct Game : public ui::Widget {
 private:
     using TetrionHeaders = std::vector<recorder::TetrionHeader>;
 
-    std::unique_ptr<ClockSource> m_clock_source;
+    std::shared_ptr<ClockSource> m_clock_source;
     SimulationStep m_simulation_step_index{ 0 };
     std::unique_ptr<Tetrion> m_tetrion;
     std::shared_ptr<input::GameInput> m_input;
@@ -28,6 +28,15 @@ struct Game : public ui::Widget {
             bool is_top_level
     );
 
+    OOPETRIS_GRAPHICS_EXPORTED explicit Game(
+            ServiceProvider* service_provider,
+            const std::shared_ptr<input::GameInput>& input,
+            const tetrion::StartingParameters& starting_parameters,
+            const std::shared_ptr<ClockSource>& clock_source,
+            const ui::Layout& layout,
+            bool is_top_level
+    );
+
     OOPETRIS_GRAPHICS_EXPORTED void update() override;
 
     OOPETRIS_GRAPHICS_EXPORTED void render(const ServiceProvider& service_provider) const override;

src/graphics/meson.build

@@ -8,6 +8,26 @@ graphics_src_files += files(
     'text.hpp',
     'texture.cpp',
     'texture.hpp',
+    'video_renderer.cpp',
+    'video_renderer.hpp',
     'window.cpp',
     'window.hpp',
 )
+
+
+# TODO: make this optional
+if host_machine.system() == 'darwin'
+graphics_src_files += files(
+    'video_renderer_mac.cpp',
+)
+elif host_machine.system() == 'linux'
+   graphics_src_files += files(
+    'video_renderer_linux.cpp',
+)
+elif host_machine.system() == 'windows'
+    graphics_src_files += files(
+    'video_renderer_windows.cpp',
+)
+else
+    error('unsuported system for video rendering: ' + host_machine.system())
+endif

src/graphics/video_renderer.cpp

@@ -0,0 +1,194 @@
+
+
+#include "video_renderer.hpp"
+
+#include <fmt/format.h>
+
+VideoRenderer::VideoRenderer(
+        ServiceProvider* service_provider,
+        const std::filesystem::path& recording_path,
+        shapes::UPoint size
+)
+    : m_main_provider{ service_provider },
+      m_size{ size } {
+    auto* surface = SDL_CreateRGBSurface(0, static_cast<int>(size.x), static_cast<int>(size.y), 32, 0, 0, 0, 0);
+
+    if (surface == nullptr) {
+        throw std::runtime_error{ fmt::format("Failed creating a SDL RGB Surface: {}", SDL_GetError()) };
+    }
+
+    m_surface.reset(surface);
+    auto renderer = Renderer::get_software_renderer(m_surface);
+
+    m_renderer = std::make_unique<Renderer>(std::move(renderer));
+
+    initialize_games(recording_path);
+}
+
+void VideoRenderer::initialize_games(const std::filesystem::path& recording_path) {
+
+    auto [parameters, information] = input::get_game_parameters_for_replay(this, recording_path);
+
+    auto layout = ui::FullScreenLayout{
+        shapes::URect{ { 0, 0 }, m_size }
+    };
+
+    std::vector<ui::Layout> layouts{};
+    layouts.reserve(parameters.size());
+
+    if (parameters.empty()) {
+        throw std::runtime_error("An empty recording file isn't supported");
+    } else if (parameters.size() == 1) { // NOLINT(readability-else-after-return,llvm-else-after-return)
+        layouts.push_back(ui::RelativeLayout{ layout, 0.02, 0.01, 0.96, 0.98 });
+    } else if (parameters.size() == 2) {
+        layouts.push_back(ui::RelativeLayout{ layout, 0.02, 0.01, 0.46, 0.98 });
+        layouts.push_back(ui::RelativeLayout{ layout, 0.52, 0.01, 0.46, 0.98 });
+    } else {
+
+        //TODO(Totto): support bigger layouts than just 2
+        throw std::runtime_error("At the moment only replays from up to two players are supported");
+    }
+
+    m_clock = std::make_shared<ManualClock>();
+
+
+    for (decltype(parameters.size()) i = 0; i < parameters.size(); ++i) {
+        auto [input, starting_parameters] = std::move(parameters.at(i));
+
+        m_games.emplace_back(
+                std::make_unique<Game>(this, std::move(input), starting_parameters, m_clock, layouts.at(i), false)
+        );
+    }
+}
+
+
+VideoRenderer::~VideoRenderer() {
+    if (m_surface) {
+        SDL_FreeSurface(m_surface.get());
+    }
+}
+
+
+std::optional<std::string> VideoRenderer::render(
+        const std::string& destination_path,
+        u32 fps,
+        const std::function<void(double progress)>& progress_callback
+) {
+
+    auto backend = VideoRendererBackend{ destination_path };
+
+    if (auto result = backend.setup(fps, m_size); result.has_value()) {
+        return fmt::format("No video renderer backend available: {}", result.value());
+    }
+
+    auto all_games_finished = [this]() -> bool {
+        for (const auto& game : m_games) {
+            if (not game->is_game_finished()) {
+                return false;
+            }
+        }
+
+        return true;
+    };
+
+    //TODO: this is just a dummy thing atm, change that
+    double progress = 0.0;
+
+    while (all_games_finished()) {
+        progress_callback(progress);
+
+        for (const auto& game : m_games) {
+            game->update();
+            game->render(*this);
+        }
+
+        backend.add_frame(m_surface.get());
+        m_clock->increment_simulation_step_index();
+
+        progress += 0.1;
+
+        progress_callback(progress);
+    }
+
+    backend.finish(false);
+    return std::nullopt;
+}
+
+
+// implementation of ServiceProvider
+
+[[nodiscard]] EventDispatcher& VideoRenderer::event_dispatcher() {
+    return m_main_provider->event_dispatcher();
+}
+
+[[nodiscard]] const EventDispatcher& VideoRenderer::event_dispatcher() const {
+    return m_main_provider->event_dispatcher();
+}
+
+FontManager& VideoRenderer::font_manager() {
+    return m_main_provider->font_manager();
+}
+
+[[nodiscard]] const FontManager& VideoRenderer::font_manager() const {
+    return m_main_provider->font_manager();
+}
+
+CommandLineArguments& VideoRenderer::command_line_arguments() {
+    return m_main_provider->command_line_arguments();
+}
+
+[[nodiscard]] const CommandLineArguments& VideoRenderer::command_line_arguments() const {
+    return m_main_provider->command_line_arguments();
+}
+
+SettingsManager& VideoRenderer::settings_manager() {
+    return m_main_provider->settings_manager();
+}
+
+[[nodiscard]] const SettingsManager& VideoRenderer::settings_manager() const {
+    return m_main_provider->settings_manager();
+}
+
+MusicManager& VideoRenderer::music_manager() {
+    return m_main_provider->music_manager();
+}
+
+[[nodiscard]] const MusicManager& VideoRenderer::music_manager() const {
+    return m_main_provider->music_manager();
+}
+
+[[nodiscard]] const Renderer& VideoRenderer::renderer() const {
+    return *m_renderer;
+}
+
+[[nodiscard]] const Window& VideoRenderer::window() const {
+    return m_main_provider->window();
+}
+
+[[nodiscard]] Window& VideoRenderer::window() {
+    return m_main_provider->window();
+}
+
+[[nodiscard]] input::InputManager& VideoRenderer::input_manager() {
+    return m_main_provider->input_manager();
+}
+
+[[nodiscard]] const input::InputManager& VideoRenderer::input_manager() const {
+    return m_main_provider->input_manager();
+}
+
+[[nodiscard]] const std::unique_ptr<lobby::API>& VideoRenderer::api() const {
+    return m_main_provider->api();
+}
+
+#if defined(_HAVE_DISCORD_SDK)
+
+[[nodiscard]] std::optional<DiscordInstance>& VideoRenderer::discord_instance() {
+    return m_main_provider->discord_instance();
+}
+
+[[nodiscard]] const std::optional<DiscordInstance>& VideoRenderer::discord_instance() const {
+    return m_main_provider->discord_instance();
+}
+
+#endif

src/graphics/video_renderer.hpp

@@ -0,0 +1,102 @@
+
+
+#pragma once
+
+#include <SDL.h>
+#include <memory>
+
+#include "game/game.hpp"
+#include "graphics/rect.hpp"
+#include "helper/windows.hpp"
+#include "manager/service_provider.hpp"
+#include "renderer.hpp"
+
+struct VideoRenderer : ServiceProvider {
+private:
+    std::unique_ptr<SDL_Surface> m_surface;
+    std::unique_ptr<Renderer> m_renderer;
+    std::vector<std::unique_ptr<Game>> m_games;
+    ServiceProvider* m_main_provider;
+    shapes::UPoint m_size;
+    std::shared_ptr<ManualClock> m_clock;
+
+    void initialize_games(const std::filesystem::path& recording_path);
+
+public:
+    OOPETRIS_GRAPHICS_EXPORTED explicit VideoRenderer(
+            ServiceProvider* service_provider,
+            const std::filesystem::path& recording_path,
+            shapes::UPoint size
+    );
+
+    std::optional<std::string>
+    render(const std::string& destination_path, u32 fps, const std::function<void(double progress)>& progress_callback);
+
+    ~VideoRenderer();
+
+
+    // implementation of ServiceProvider
+
+    [[nodiscard]] EventDispatcher& event_dispatcher() override;
+
+    [[nodiscard]] const EventDispatcher& event_dispatcher() const override;
+
+    FontManager& font_manager() override;
+
+    [[nodiscard]] const FontManager& font_manager() const override;
+
+    CommandLineArguments& command_line_arguments() override;
+
+    [[nodiscard]] const CommandLineArguments& command_line_arguments() const override;
+
+    SettingsManager& settings_manager() override;
+
+    [[nodiscard]] const SettingsManager& settings_manager() const override;
+
+    MusicManager& music_manager() override;
+
+    [[nodiscard]] const MusicManager& music_manager() const override;
+
+    [[nodiscard]] const Renderer& renderer() const override;
+
+    [[nodiscard]] const Window& window() const override;
+
+    [[nodiscard]] Window& window() override;
+
+    [[nodiscard]] input::InputManager& input_manager() override;
+
+    [[nodiscard]] const input::InputManager& input_manager() const override;
+
+    [[nodiscard]] const std::unique_ptr<lobby::API>& api() const override;
+
+#if defined(_HAVE_DISCORD_SDK)
+
+    [[nodiscard]] std::optional<DiscordInstance>& discord_instance() override;
+
+    [[nodiscard]] const std::optional<DiscordInstance>& discord_instance() const override;
+
+#endif
+};
+
+
+struct Decoder;
+
+
+//TODO(Totto): also support library and not only subprocess call
+// See e.g. https://github.com/Raveler/ffmpeg-cpp
+struct VideoRendererBackend {
+private:
+    std::string m_destination_path;
+    std::unique_ptr<Decoder> m_decoder;
+
+public:
+    OOPETRIS_GRAPHICS_EXPORTED explicit VideoRendererBackend(const std::filesystem::path& destination_path);
+
+    OOPETRIS_GRAPHICS_EXPORTED ~VideoRendererBackend();
+
+    OOPETRIS_GRAPHICS_EXPORTED [[nodiscard]] std::optional<std::string> setup(u32 fps, shapes::UPoint size);
+
+    bool add_frame(SDL_Surface* surface);
+
+    bool finish(bool cancel);
+};