update

Author: Frank1o3

includes/capture.hpp

@@ -163,9 +163,10 @@ inline bool is_window_visible(HWND hwnd)
     return hwnd && IsWindowVisible(hwnd);
 }
 
-// ── Windows screen capture via GDI PrintWindow + BitBlt ───────────────────────
-// PrintWindow captures the window's own backbuffer — works even when the
-// window is partially occluded, unlike BitBlt from the desktop DC.
+// ── Windows screen capture via GDI BitBlt ─────────────────────────────────────
+// bgra_buf_ is pre-allocated in init() and reused every grab() call so we never
+// heap-allocate inside the hot loop (the old code did `cv::Mat bgra(h,w,CV_8UC4)`
+// on every single frame which triggered a malloc+free pair at capture rate).
 
 class PlatformCapture
 {
@@ -193,6 +194,12 @@ class PlatformCapture
             return false;
         }
         SelectObject(hdc_mem_, hbmp_);
+
+        // Pre-allocate the intermediate BGRA buffer once for this region size.
+        // grab() reuses it every frame via GetDIBits writing directly into
+        // bgra_buf_.data — no heap allocation in the hot path.
+        bgra_buf_.create(h_, w_, CV_8UC4);
+
         ready_ = true;
         return true;
     }
@@ -202,24 +209,24 @@ class PlatformCapture
         if (!ready_)
             return false;
 
-        // Capture the window into our memory DC
         HDC hwnd_dc = GetDC(hwnd_);
         BitBlt(hdc_mem_, 0, 0, w_, h_, hwnd_dc, x_, y_, SRCCOPY);
         ReleaseDC(hwnd_, hwnd_dc);
 
-        // Pull pixels from HBITMAP into a cv::Mat
         BITMAPINFOHEADER bi{};
         bi.biSize = sizeof(bi);
         bi.biWidth = w_;
-        bi.biHeight = -h_; // negative = top-down
+        bi.biHeight = -h_; // negative = top-down row order
         bi.biPlanes = 1;
         bi.biBitCount = 32;
         bi.biCompression = BI_RGB;
 
-        cv::Mat bgra(h_, w_, CV_8UC4);
-        GetDIBits(hdc_mem_, hbmp_, 0, h_, bgra.data,
+        // Write directly into the pre-allocated buffer — zero heap activity
+        GetDIBits(hdc_mem_, hbmp_, 0, h_, bgra_buf_.data,
                   reinterpret_cast<BITMAPINFO *>(&bi), DIB_RGB_COLORS);
-        cv::cvtColor(bgra, out, cv::COLOR_BGRA2BGR);
+
+        // Convert in-place into caller's Mat (reuses its buffer if same size)
+        cv::cvtColor(bgra_buf_, out, cv::COLOR_BGRA2BGR);
         return true;
     }
 
@@ -242,11 +249,14 @@ class PlatformCapture
             DeleteObject(hbmp_);
             hbmp_ = nullptr;
         }
+        bgra_buf_.release();
         ready_ = false;
     }
+
     HWND hwnd_{nullptr};
     HDC hdc_mem_{nullptr};
     HBITMAP hbmp_{nullptr};
+    cv::Mat bgra_buf_; // pre-allocated BGRA scratch — never reallocated
     int x_{0}, y_{0}, w_{0}, h_{0};
     bool ready_{false};
 };
@@ -380,7 +390,8 @@ class XWin
             if (rd)
                 XFree(rd);
         }
-        int cw = attr.width - fl - fr, ch = attr.height - ft - fb;
+        int cw = attr.width - fl - fr;
+        int ch = attr.height - ft - fb;
         if (cw <= 0 || ch <= 0)
             return std::nullopt;
         return Rect{attr.x + fl, attr.y + ft, cw, ch};
@@ -389,7 +400,8 @@ class XWin
     bool is_visible(Window w) const
     {
         XWindowAttributes attr;
-        return XGetWindowAttributes(dpy_, w, &attr) && attr.map_state == IsViewable;
+        return XGetWindowAttributes(dpy_, w, &attr) &&
+               attr.map_state == IsViewable;
     }
 
     Display *dpy() const { return dpy_; }
@@ -452,6 +464,7 @@ class PlatformCapture
         if (!XShmGetImage(dpy_, root_, img_, x_, y_, AllPlanes))
             return false;
         cv::Mat raw(h_, w_, CV_8UC4, img_->data);
+        // copyTo reuses out's buffer when dimensions match — no heap alloc
         cv::cvtColor(raw, out, cv::COLOR_BGRA2BGR);
         return true;
     }
@@ -474,6 +487,7 @@ class PlatformCapture
         img_ = nullptr;
         ready_ = false;
     }
+
     Display *dpy_{nullptr};
     Window root_{0};
     XShmSegmentInfo shm_{};
@@ -512,7 +526,6 @@ class CaptureThread
         cv::Mat kernel = cv::getStructuringElement(cv::MORPH_ELLIPSE, {3, 3});
 
 #if defined(_WIN32)
-        // Windows: screen dimensions from system metrics
         int screen_w = GetSystemMetrics(SM_CXVIRTUALSCREEN);
         int screen_h = GetSystemMetrics(SM_CYVIRTUALSCREEN);
         int screen_l = GetSystemMetrics(SM_XVIRTUALSCREEN);
@@ -523,9 +536,6 @@ class CaptureThread
         auto next_frame = clk::now();
         while (running_.load(std::memory_order_relaxed))
         {
-            // ── FPS cap — sleep until next deadline, then advance it ───────
-            // Capping next_frame to now() prevents lag accumulation after
-            // prolonged sleeps (e.g. window-not-visible 100ms pauses).
             if (cfg_.target_fps > 0)
             {
                 auto now = clk::now();
@@ -534,15 +544,14 @@ class CaptureThread
                 std::this_thread::sleep_until(next_frame);
                 next_frame += std::chrono::microseconds(1'000'000 / cfg_.target_fps);
             }
-
             if (!is_window_visible(wid_))
             {
                 std::this_thread::sleep_for(std::chrono::milliseconds(100));
                 continue;
             }
             auto rect = get_content_rect(wid_);
 #else
-        // Linux: own Display connection per thread (Xlib not thread-safe)
+        // Linux: own Display connection per thread (Xlib is not thread-safe)
         XWin xwin;
         Display *dpy = xwin.dpy();
         int screen_w = DisplayWidth(dpy, DefaultScreen(dpy));
@@ -554,9 +563,6 @@ class CaptureThread
         auto next_frame = clk::now();
         while (running_.load(std::memory_order_relaxed))
         {
-            // ── FPS cap — sleep until next deadline, then advance it ───────
-            // Capping next_frame to now() prevents lag accumulation after
-            // prolonged sleeps (e.g. window-not-visible 100ms pauses).
             if (cfg_.target_fps > 0)
             {
                 auto now = clk::now();
@@ -565,7 +571,6 @@ class CaptureThread
                 std::this_thread::sleep_until(next_frame);
                 next_frame += std::chrono::microseconds(1'000'000 / cfg_.target_fps);
             }
-
             if (!xwin.is_visible(wid_))
             {
                 std::this_thread::sleep_for(std::chrono::milliseconds(100));
@@ -600,11 +605,10 @@ class CaptureThread
             {
 #if defined(_WIN32)
                 if (!cap.init(wid_, left, top, cw, ch))
-                {
 #else
                 if (!cap.init(dpy, xwin.root(), left, top, cw, ch))
-                {
 #endif
+                {
                     std::this_thread::sleep_for(std::chrono::milliseconds(50));
                     continue;
                 }
@@ -623,17 +627,19 @@ class CaptureThread
             }
 
             // ── BGR color mask ────────────────────────────────────────────
+            // bounds() returns cached lo/hi — no sscanf or arithmetic here
             std::array<uint8_t, 3> lo, hi;
             cfg_.bounds(lo, hi);
             cv::inRange(slot.bgr,
                         cv::Scalar(lo[0], lo[1], lo[2]),
                         cv::Scalar(hi[0], hi[1], hi[2]),
                         slot.mask);
 
-            // ── Morphology — skip when mask is empty ─────────────────────
-            // cv::morphologyEx on an all-zero mask wastes CPU. The early
-            // check is cheap (single pass to count non-zeros) and avoids the
-            // kernel convolution entirely when nothing matched inRange.
+            // ── Morphology ────────────────────────────────────────────────
+            // countNonZero is O(w×h) but saves the O(w×h) morphologyEx when
+            // the mask is empty (common during cooldown / off-target frames).
+            // Worth keeping when empty frames are the majority; profile if
+            // your scene keeps targets on-screen most of the time.
             if (cv::countNonZero(slot.mask) > 0)
                 cv::morphologyEx(slot.mask, slot.mask, cv::MORPH_OPEN, kernel);
 

includes/config.hpp

@@ -7,6 +7,7 @@
 #include <filesystem>
 #include <fstream>
 #include <iostream>
+#include <stdexcept>
 #include <string>
 #include <type_traits>
 
@@ -30,9 +31,9 @@ static std::string config_path()
 struct Config
 {
     std::string window = "Sober";
-    std::string color = "#ffffb3"; // rrggbb hex
+    std::string color = "#ffffb3"; // rrggbb hex — matched in BGR space
     int fov = 250;
-    double tolerance = 15.0; // BGR per-channel tolerance [0, 255]
+    double tolerance = 15.0; // BGR per-channel ± tolerance [0, 255]
     int min_area = 15;
     int max_area = 9999;
     double lead = 0.35;
@@ -45,11 +46,14 @@ struct Config
     int target_fps = 144;          // capture loop FPS cap; 0 = unlimited
     bool triggerbot = false;       // auto-click when on target
     double trigger_dist = 10.0;    // px distance to crosshair that fires click
-    int trigger_delay = 80;        // ms between triggerbot clicks    // capture loop FPS cap; 0 = unlimited
+    int trigger_delay = 80;        // ms between triggerbot clicks
     bool debug = true;
     bool enabled = true;
 
     // ── Color helpers ─────────────────────────────────────────────────────────
+    // All matching is done in BGR space — same channel order OpenCV uses for
+    // frames captured with XShmGetImage / BitBlt.  No HSV conversion needed;
+    // a simple per-channel ± tolerance box is fast and precise enough.
 
     std::array<uint8_t, 3> color_bgr() const
     {
@@ -64,16 +68,27 @@ struct Config
         return {b, g, r};
     }
 
+    // bounds() is called once per captured frame inside the hot loop.
+    // The hex → BGR parse and tolerance arithmetic are cached so the path
+    // only copies two pre-computed arrays instead of sscanf-ing every tick.
+    // The cache is invalidated by validate() whenever tolerance or color could
+    // have changed (i.e. after every load or manual field mutation + validate).
     void bounds(std::array<uint8_t, 3> &lo,
                 std::array<uint8_t, 3> &hi) const
     {
-        auto bgr = color_bgr();
-        int tol = static_cast<int>(tolerance);
-        for (int i = 0; i < 3; ++i)
+        if (_bounds_dirty)
         {
-            lo[i] = static_cast<uint8_t>(std::max(0, (int)bgr[i] - tol));
-            hi[i] = static_cast<uint8_t>(std::min(255, (int)bgr[i] + tol));
+            auto bgr = color_bgr();
+            int tol = static_cast<int>(tolerance);
+            for (int i = 0; i < 3; ++i)
+            {
+                _cached_lo[i] = static_cast<uint8_t>(std::max(0, (int)bgr[i] - tol));
+                _cached_hi[i] = static_cast<uint8_t>(std::min(255, (int)bgr[i] + tol));
+            }
+            _bounds_dirty = false;
         }
+        lo = _cached_lo;
+        hi = _cached_hi;
     }
 
     // ── Validation ────────────────────────────────────────────────────────────
@@ -131,10 +146,15 @@ struct Config
             trigger_delay = 50;
         }
         smoothness = std::clamp(smoothness, 0.0, 1.0);
+
+        // Invalidate cached bounds — tolerance or color may have changed
+        _bounds_dirty = true;
     }
 
     // ── Persistence ───────────────────────────────────────────────────────────
 
+    // Throws std::runtime_error on first-run instead of calling std::exit()
+    // so RAII destructors fire correctly and main() controls the exit message.
     static Config load()
     {
         auto path = config_path();
@@ -143,9 +163,9 @@ struct Config
         {
             Config def;
             def.save();
-            std::cout << "[config] No config found — created default at "
-                      << path << "\n  Edit it and re-run.\n";
-            std::exit(0);
+            throw std::runtime_error(
+                "[config] No config found — created default at " + path +
+                "\n  Edit it and re-run.");
         }
         nlohmann::json j;
         f >> j;
@@ -177,7 +197,7 @@ struct Config
         get("debug", c.debug);
         get("enabled", c.enabled);
 
-        c.validate();
+        c.validate(); // also sets _bounds_dirty = true
         return c;
     }
 
@@ -211,4 +231,11 @@ struct Config
         std::ofstream out(path);
         out << j.dump(2) << '\n';
     }
+
+private:
+    // Lazily computed BGR bounds cache.  mutable so bounds() is callable on a
+    // const Config reference (e.g. in CaptureThread which holds const Config&).
+    mutable std::array<uint8_t, 3> _cached_lo{};
+    mutable std::array<uint8_t, 3> _cached_hi{};
+    mutable bool _bounds_dirty{true};
 };