perf: reduce redundant work and memory allocations across capture pipeline

Toni500github · Toni500github · commit b9651a4339a0 · 2026-03-19T19:18:42.000+01:00
- config: eliminate double hash lookup in Config::GetValue by reusing
  the iterator from find() instead of calling at() twice per override

- capture: remove file-scope cap_portal global; merge its fields
  into portal_state_t so portal capture state is stack-local and the
  function becomes re-entrant

- tool: cache resolved font path in inputs_results_t to avoid
  recursive filesystem scan on every rendered frame per text annotation;
  invalidate on StartWindow() and when the user edits the font field

- tool: eliminate per-frame heap allocation in draw_pencil by
  casting point_t* directly to ImVec2* (layout-compatible structs);
  guarded by static_assert

- main: fix fake move of trivially-copyable uint8_t in IPC image handler;
  replace move_iterator range-construction with erase + move of the
  existing vector, avoiding an unnecessary ~8MB copy for 1080p captures

- util/clipboard: deduplicate svpng encoding logic into a shared
  encode_to_png() helper, removing duplicated macro boilerplate from
  clipboard.cpp
diff --git a/CMakeLists.txt b/CMakeLists.txt
@@ -100,6 +100,9 @@ execute_process(
 )
 
 target_compile_definitions(${PROJECT_NAME} PRIVATE $<$<CONFIG:Debug>:DEBUG=1>)
+target_compile_definitions(${PROJECT_NAME} PRIVATE
+    FMT_HEADER_ONLY=0
+)
 target_compile_options(
     ${PROJECT_NAME}
     PRIVATE
diff --git a/include/config.hpp b/include/config.hpp
@@ -132,19 +132,19 @@ class Config
     {
         const auto& overridePos = m_overrides.find(value.data());
 
-        // user wants a bool (overridable), we found an override matching the name, and the override is a bool.
-        if constexpr (std::is_same<T, bool>())
-            if (overridePos != m_overrides.end() && m_overrides.at(value.data()).value_type == ValueType::kBool)
-                return m_overrides.at(value.data()).bool_value;
-
-        // user wants a str (overridable), we found an override matching the name, and the override is a str.
-        if constexpr (std::is_same<T, std::string>())
-            if (overridePos != m_overrides.end() && m_overrides.at(value.data()).value_type == ValueType::kString)
-                return m_overrides.at(value.data()).string_value;
-
-        if constexpr (std::is_same<T, int>())
-            if (overridePos != m_overrides.end() && m_overrides.at(value.data()).value_type == ValueType::kInt)
-                return m_overrides.at(value.data()).int_value;
+        if (overridePos != m_overrides.end())
+        {
+            const auto& ov = overridePos->second;
+            if constexpr (std::is_same<T, bool>())
+                if (ov.value_type == ValueType::kBool)
+                    return ov.bool_value;
+            if constexpr (std::is_same<T, std::string>())
+                if (ov.value_type == ValueType::kString)
+                    return ov.string_value;
+            if constexpr (std::is_same<T, int>())
+                if (ov.value_type == ValueType::kInt)
+                    return ov.int_value;
+        }
 
         const std::optional<T>& ret = this->m_tbl.at_path(value).value<T>();
         if constexpr (toml::is_string<T>)
diff --git a/include/screenshot_tool.hpp b/include/screenshot_tool.hpp
@@ -109,7 +109,7 @@ struct annotation_t
 class ScreenshotTool
 {
 public:
-    ScreenshotTool() : m_io(dummy), m_inputs{ g_config->File.ocr_path, g_config->File.ocr_model, {}, "", {}, "" } {}
+    ScreenshotTool() : m_io(dummy), m_inputs{ g_config->File.ocr_path, g_config->File.ocr_model, {}, "", {}, "", "" } {}
 
     Result<>          Start();
     Result<>          StartWindow();
@@ -175,6 +175,7 @@ class ScreenshotTool
         zbar_result_t zbar_scan_result;
 
         std::string ann_font;
+        std::string resolved_ann_font_path;
     };
 
     ImGuiIO&         m_io;
diff --git a/include/util.hpp b/include/util.hpp
@@ -160,6 +160,7 @@ static inline const std::string version_infos = fmt::format(
 #ifdef __linux__
 std::vector<uint8_t> ximage_to_rgba(XImage* image, int width, int height);
 #endif
+std::vector<uint8_t> encode_to_png(const capture_result_t& cap);
 
 std::string replace_str(std::string& str, const std::string_view from, const std::string_view to);
 std::string select_image();
diff --git a/src/clipboard.cpp b/src/clipboard.cpp
@@ -7,14 +7,6 @@
 #include "clip/clip.h"
 #include "socket.hpp"
 
-#define SVPNG_LINKAGE inline
-#define SVPNG_OUTPUT  std::vector<uint8_t>* output
-#define SVPNG_PUT(u)  output->push_back(static_cast<uint8_t>(u))
-#pragma GCC diagnostic push
-#pragma GCC diagnostic ignored "-Wfree-nonheap-object"
-#include "svpng.h"
-#pragma GCC diagnostic pop
-
 // used to track the wl-copy process
 static int wlcopy_pid = -1;
 
@@ -113,10 +105,7 @@ Result<> Clipboard::CopyImage(const capture_result_t& cap)
 
     if (m_session == SessionType::Wayland)
     {
-        std::vector<uint8_t> png;
-        png.reserve(static_cast<size_t>(cap.w) * cap.h * 4);
-
-        svpng(&png, cap.w, cap.h, cap.view().data(), 1);
+        const std::vector<uint8_t>& png = encode_to_png(cap);
 
         const Result<int>& res = start_wlcopy("image/png");
         if (!res.ok())
diff --git a/src/main.cpp b/src/main.cpp
@@ -488,9 +488,8 @@ int main(int argc, char* argv[])
                     continue;
 
                 // Strip the 8-byte header
-                std::vector<uint8_t> pixel_data(std::make_move_iterator(payload.begin() + 8),
-                                                std::make_move_iterator(payload.end()));
-                capture_result_t     cap{ std::move(pixel_data), w, h };
+                payload.erase(payload.begin(), payload.begin() + 8);
+                capture_result_t cap{ std::move(payload), w, h };
                 {
                     std::lock_guard lk(mtx);
                     pending_image = std::move(cap);
diff --git a/src/screen_capture.cpp b/src/screen_capture.cpp
@@ -284,25 +284,22 @@ Result<capture_result_t> capture_full_screen_wayland()
     return Ok(std::move(result));
 }
 
-struct portal_capture_t
-{
-    std::string      png_path;
-    std::string      error_msg;
-    capture_result_t cap;
-} cap_portal;
-
 struct portal_state_t
 {
     GMainLoop* loop;
     guint      subscription_id;
     guint      timeout_id;  // tracked so we can cancel it before the stack frame is gone
+
+    std::string      png_path;
+    std::string      error_msg;
+    capture_result_t cap;
 };
 
 static gboolean on_timeout(gpointer user_data)
 {
-    portal_state_t* st   = reinterpret_cast<portal_state_t*>(user_data);
-    cap_portal.error_msg = "Timed out waiting for portal response (is xdg-desktop-portal running?)";
-    st->timeout_id       = 0;  // GLib will remove the source; mark it gone so cleanup skips it
+    portal_state_t* st = reinterpret_cast<portal_state_t*>(user_data);
+    st->error_msg      = "Timed out waiting for portal response (is xdg-desktop-portal running?)";
+    st->timeout_id     = 0;  // GLib will remove the source; mark it gone so cleanup skips it
     g_main_loop_quit(st->loop);
     return G_SOURCE_REMOVE;
 }
@@ -343,9 +340,9 @@ static void on_response(GDBusConnection* conn,
     g_variant_get(parameters, "(u@a{sv})", &response, &results);
 
     if (response != 0)
-        cap_portal.error_msg = fmt::format("Cancelled or failed (response={})", (unsigned)response);
+        st->error_msg = fmt::format("Cancelled or failed (response={})", (unsigned)response);
     else if (!(g_variant_lookup(results, "uri", "&s", &uri) && uri))
-        cap_portal.error_msg = "Success, but portal returned no uri";
+        st->error_msg = "Success, but portal returned no uri";
 
     if (results)
         g_variant_unref(results);
@@ -359,31 +356,30 @@ static void on_response(GDBusConnection* conn,
     const Result<std::string>& res = uri_to_path(uri);
     if (res.ok())
     {
-        cap_portal.png_path  = res.get();
-        cap_portal.error_msg = "";
+        st->png_path  = res.get();
+        st->error_msg = "";
     }
     else
     {
-        cap_portal.png_path  = "";
-        cap_portal.error_msg = res.error_v();
+        st->png_path  = "";
+        st->error_msg = res.error_v();
     }
 
     g_main_loop_quit(st->loop);
 }
 
 Result<capture_result_t> capture_full_screen_portal()
 {
-    cap_portal = {};
+    portal_state_t st{};
     warn("Fallback to portal capture");
 
     GError*          error = nullptr;
     GDBusConnection* bus   = g_bus_get_sync(G_BUS_TYPE_SESSION, nullptr, &error);
     if (!bus)
     {
-        cap_portal.error_msg =
-            "Failed to connect to session bus: " + std::string(error->message ? error->message : "Unknown");
+        st.error_msg = "Failed to connect to session bus: " + std::string(error->message ? error->message : "Unknown");
         g_error_free(error);
-        return Err(cap_portal.error_msg);
+        return Err(st.error_msg);
     }
 
     // Call Screenshot portal synchronously so we can fail loudly if the service isn't there.
@@ -402,10 +398,10 @@ Result<capture_result_t> capture_full_screen_portal()
 
     if (!reply)
     {
-        cap_portal.error_msg = "Portal call failed: " + std::string(error->message ? error->message : "Unknown");
+        st.error_msg = "Portal call failed: " + std::string(error->message ? error->message : "Unknown");
         g_error_free(error);
         g_object_unref(bus);
-        return Err(cap_portal.error_msg);
+        return Err(st.error_msg);
     }
 
     const char* request_path = nullptr;
@@ -418,7 +414,6 @@ Result<capture_result_t> capture_full_screen_portal()
         return Err("Portal returned an empty request handle");
     }
 
-    portal_state_t st;
     st.loop            = g_main_loop_new(nullptr, FALSE);
     st.subscription_id = 0;
     st.timeout_id      = 0;
@@ -457,73 +452,66 @@ Result<capture_result_t> capture_full_screen_portal()
     g_main_loop_unref(st.loop);
     g_object_unref(bus);
 
-    if (cap_portal.png_path.empty())
+    if (st.png_path.empty())
     {
-        if (cap_portal.error_msg.empty())
+        if (st.error_msg.empty())
             return Err("Failed to retrieve uri path to screenshot PNG");
-        return Err(cap_portal.error_msg);
+        return Err(st.error_msg);
     }
 
     int      w = 0, h = 0, comp = 0;
-    uint8_t* rgba = stbi_load(cap_portal.png_path.c_str(), &w, &h, &comp, STBI_rgb_alpha);
+    uint8_t* rgba = stbi_load(st.png_path.c_str(), &w, &h, &comp, STBI_rgb_alpha);
 
     if (!rgba)
     {
         const char* reason = stbi_failure_reason();
-        unlink(cap_portal.png_path.c_str());
+        unlink(st.png_path.c_str());
         return Err("Failed to read PNG data: " + std::string(reason ? reason : "Unknown"));
     }
 
-    cap_portal.cap.w = w;
-    cap_portal.cap.h = h;
-    cap_portal.cap.data.assign(rgba, rgba + (static_cast<size_t>(w) * h * 4));
+    st.cap.w = w;
+    st.cap.h = h;
+    st.cap.data.assign(rgba, rgba + (static_cast<size_t>(w) * h * 4));
     stbi_image_free(rgba);
 
     // The portal backend (on KDE mostly) writes a permanent file to ~/Pictures named "Screenshot_*.png".
     // Delete it now that we have the pixels in memory.
-    unlink(cap_portal.png_path.c_str());
+    unlink(st.png_path.c_str());
 
     // The portal always captures the full virtual desktop on multi-monitor
     // setups. Crop down to the monitor that contains the cursor.
     // XRandR works on native X11 and on KDE/GNOME Wayland via XWayland.
     {
         int mx = 0, my = 0, mw = 0, mh = 0;
-        if (get_cursor_monitor_xrandr(nullptr, mx, my, mw, mh) && (cap_portal.cap.w > mw || cap_portal.cap.h > mh))
+        if (get_cursor_monitor_xrandr(nullptr, mx, my, mw, mh) && (st.cap.w > mw || st.cap.h > mh))
         {
-            debug("Portal: cropping {}x{} capture to monitor {}x{}+{}+{}",
-                  cap_portal.cap.w,
-                  cap_portal.cap.h,
-                  mw,
-                  mh,
-                  mx,
-                  my);
+            debug("Portal: cropping {}x{} capture to monitor {}x{}+{}+{}", st.cap.w, st.cap.h, mw, mh, mx, my);
 
             const int x0    = std::max(0, mx);
             const int y0    = std::max(0, my);
-            const int x1    = std::min(cap_portal.cap.w, mx + mw);
-            const int y1    = std::min(cap_portal.cap.h, my + mh);
+            const int x1    = std::min(st.cap.w, mx + mw);
+            const int y1    = std::min(st.cap.h, my + mh);
             const int new_w = x1 - x0;
             const int new_h = y1 - y0;
 
             if (new_w > 0 && new_h > 0)
             {
-                const int            src_stride = cap_portal.cap.w;
+                const int            src_stride = st.cap.w;
                 std::vector<uint8_t> cropped(static_cast<size_t>(new_w) * new_h * 4);
                 for (int row = 0; row < new_h; ++row)
                 {
-                    const uint8_t* src =
-                        cap_portal.cap.data.data() + (static_cast<size_t>(y0 + row) * src_stride + x0) * 4;
-                    uint8_t* dst = cropped.data() + static_cast<size_t>(row) * new_w * 4;
+                    const uint8_t* src = st.cap.data.data() + (static_cast<size_t>(y0 + row) * src_stride + x0) * 4;
+                    uint8_t*       dst = cropped.data() + static_cast<size_t>(row) * new_w * 4;
                     std::memcpy(dst, src, static_cast<size_t>(new_w) * 4);
                 }
-                cap_portal.cap.data = std::move(cropped);
-                cap_portal.cap.w    = new_w;
-                cap_portal.cap.h    = new_h;
+                st.cap.data = std::move(cropped);
+                st.cap.w    = new_w;
+                st.cap.h    = new_h;
             }
         }
     }
 
-    return Ok(std::move(cap_portal.cap));
+    return Ok(std::move(st.cap));
 }
 
 #else
diff --git a/src/screenshot_tool.cpp b/src/screenshot_tool.cpp
@@ -230,8 +230,9 @@ Result<> ScreenshotTool::StartWindow()
     m_io    = ImGui::GetIO();
     m_state = ToolState::Selecting;
 
-    m_inputs.ann_font = g_config->File.fonts.size() > 0 ? g_config->File.fonts[0] : "";
-    m_show_text_tools = g_config->File.show_text_tools;
+    m_inputs.ann_font               = g_config->File.fonts.size() > 0 ? g_config->File.fonts[0] : "";
+    m_show_text_tools               = g_config->File.show_text_tools;
+    m_inputs.resolved_ann_font_path = get_font_path(m_inputs.ann_font).string();
 
     fit_to_screen(m_screenshot);
     RefreshOcrModels();
@@ -526,8 +527,7 @@ void ScreenshotTool::HandleAnnotationInput()
             if (ImGui::IsWindowAppearing())
                 ImGui::SetKeyboardFocusHere();
 
-            ImFont* ann_font =
-                CacheAndGetFont(get_font_path(m_inputs.ann_font).string(), m_current_annotation.thickness);
+            ImFont* ann_font = CacheAndGetFont(m_inputs.resolved_ann_font_path, m_current_annotation.thickness);
             ImGui::PushFont(ann_font);
 
             ImGui::PushStyleColor(ImGuiCol_Text, m_current_annotation.color);
@@ -1308,7 +1308,12 @@ void ScreenshotTool::DrawAnnotationToolbar()
                 ImGui::TextUnformatted("Font Size");
                 static const char* font_filters[] = { "*.ttf", "*.otf", "*.woff", "*.woff2" };
                 draw_input_text_file(
-                    "Font name/path", "##font_path_ann_settings", font_filters, 4, [] {}, m_inputs.ann_font);
+                    "Font name/path",
+                    "##font_path_ann_settings",
+                    font_filters,
+                    4,
+                    [&] { m_inputs.resolved_ann_font_path = get_font_path(m_inputs.ann_font).string(); },
+                    m_inputs.ann_font);
             }
             else
             {
@@ -1376,6 +1381,9 @@ void ScreenshotTool::DrawAnnotationToolbar()
 
 void ScreenshotTool::DrawAnnotations()
 {
+    static_assert(sizeof(point_t) == sizeof(ImVec2) && alignof(point_t) == alignof(ImVec2),
+                  "point_t and ImVec2 layout mismatch");
+
     ImDrawList* draw_list = ImGui::GetBackgroundDrawList();
     const float dpi       = m_io.DisplayFramebufferScale.x;
 
@@ -1385,7 +1393,7 @@ void ScreenshotTool::DrawAnnotations()
 
     auto draw_text = [&](const annotation_t& ann, const ImVec2& p1) {
         const float font_size = ann.thickness > 8.0f ? ann.thickness : ImGui::GetFontSize();
-        ImFont*     font      = CacheAndGetFont(get_font_path(m_inputs.ann_font).string(), font_size);
+        ImFont*     font      = CacheAndGetFont(m_inputs.resolved_ann_font_path, font_size);
         draw_list->AddText(font, font_size, p1, ann.color, ann.text.c_str());
     };
 
@@ -1409,11 +1417,11 @@ void ScreenshotTool::DrawAnnotations()
     auto draw_pencil = [&](const annotation_t& ann, const float t) {
         if (ann.points.size() > 1)
         {
-            std::vector<ImVec2> pts;
-            pts.reserve(ann.points.size());
-            for (const auto& p : ann.points)
-                pts.emplace_back(p.x, p.y);
-            draw_list->AddPolyline(pts.data(), static_cast<int>(pts.size()), ann.color, ImDrawFlags_None, t);
+            draw_list->AddPolyline(reinterpret_cast<const ImVec2*>(ann.points.data()),
+                                   static_cast<int>(ann.points.size()),
+                                   ann.color,
+                                   ImDrawFlags_None,
+                                   t);
         }
     };
 
@@ -1706,7 +1714,7 @@ capture_result_t ScreenshotTool::GetFinalImage(bool is_text_tools)
                     break;
 
                 const float font_size = ann.thickness > 8.0f ? ann.thickness : ImGui::GetFontSize();
-                ImFont*     font      = CacheAndGetFont(get_font_path(m_inputs.ann_font).string(), font_size);
+                ImFont*     font      = CacheAndGetFont(m_inputs.resolved_ann_font_path, font_size);
                 if (!font || !font->OwnerAtlas)
                     break;
 
diff --git a/src/util.cpp b/src/util.cpp

Original file line number	Diff line number	Diff line change
`@@ -100,6 +100,9 @@ execute_process(`
`100`	`100`	`)`
`101`	`101`
`102`	`102`	`target_compile_definitions(${PROJECT_NAME} PRIVATE $<$<CONFIG:Debug>:DEBUG=1>)`
	`103`	`+target_compile_definitions(${PROJECT_NAME} PRIVATE`
	`104`	`+ FMT_HEADER_ONLY=0`
	`105`	`+)`
`103`	`106`	`target_compile_options(`
`104`	`107`	`${PROJECT_NAME}`
`105`	`108`	`PRIVATE`