Match gsr monitor name with wayland monitor name. Thanks info@leocodes

README.md

@@ -14,7 +14,7 @@ A program called `gsr-ui-cli` is also installed when installing this software. T
 # Installation
 If you are using an Arch Linux based distro then you can find gpu screen recorder ui on aur under the name gpu-screen-recorder-ui (`yay -S gpu-screen-recorder-ui`).\
 If you are running another distro then you can run `sudo ./install.sh`, but you need to manually install the dependencies, as described below.\
-You can also install gpu screen recorder from [flathub](https://flathub.org/apps/details/com.dec05eba.gpu_screen_recorder). This flatpak includes both this UI and gpu-screen-recorder so no need to install that first.
+You can also install gpu screen recorder from [flathub](https://flathub.org/apps/details/com.dec05eba.gpu_screen_recorder) which includes this UI.
 
 # Dependencies
 GPU Screen Recorder UI uses meson build system so you need to install `meson` to build GPU Screen Recorder UI.
@@ -28,6 +28,7 @@ These are the dependencies needed to build GPU Screen Recorder UI:
 * libpulse (libpulse-simple)
 * libdrm
 * wayland (wayland-client, wayland-egl, wayland-scanner)
+* setcap (libcap)
 
 ## Runtime dependencies
 There are also additional dependencies needed at runtime:
@@ -61,7 +62,9 @@ I'm looking for somebody that can create sound effects for the notifications.
 
 # Known issues
 * When the UI is open the wallpaper is shown instead of the game on Hyprland. This is an issue with Hyprland. It cant be fixed until the UI is redesigned to not be a fullscreen overlay.
-* Opening the UI when a game is fullscreened can mess up the game window a bit on Hyprland. I believe this is an issue with Hyprland.
+* Opening the UI when a game is fullscreen can mess up the game window a bit on Hyprland. This is an issue with Hyprland.
+* The background of the UI is black when opening the UI while a Wayland application is focused on COSMIC. This is an issue with COSMIC.
+* Unable to close the region selection with escape key while a Wayland application is focused on COSMIC. This is an issue with COSMIC.
 
 # FAQ
 ## I get an error when trying to start the gpu-screen-recorder-ui.service systemd service

TODO

@@ -37,8 +37,6 @@ Fix first frame being black when running without a compositor.
 
 Add support for systray.
 
-Add option to take screenshot.
-
 Move event callbacks to a global list instead of std::function object in each widget. This reduces the size of widgets,
     since most widgets wont have the event callback set.
     This event callback would pass the widget as an argument.
@@ -147,8 +145,6 @@ Add systray for recording status.
 
 Add a desktop icon when gsr-ui has a window mode option (which should be the default launch option).
 
-Use /dev/input/eventN (or /dev/hidrawN) instead of /dev/input/jsN for joystick input.
-
 Verify if cursor tracker monitor name is always correct. It uses the wayland monitor name for recording, but gpu screen recorder uses a custom name created from the drm connector name.
 
 Notification with the focused monitor (with CursorTrackerWayland) assumes that the x11 monitor name is the same as the drm monitor name. Same for find_monitor_by_name.
@@ -184,4 +180,14 @@ When gpu screen recorder ui can run as a regular window (and supports tray icon
 
 Add a bug report page that automatically includes system info (make this clear to the user).
     Do this by sending the report to a custom server that stores that data.
-    The server should limit reports per IP to prevent spam.
+    The server should limit reports per IP to prevent spam.
+
+Make it possible to change controller hotkeys. Also read from /dev/input/eventN instead of /dev/input/jsN. This is readable for controllers.
+
+Add option to copy screenshot to clipboard. Does it work properly on Wayland compositors? Maybe need to wait until the application becomes Wayland native instead of XWayland.
+
+Show message that replay/streaming has to be restarted if recording settings are changed while replay/streaming is ongoing.
+
+Support vector graphics. Maybe support svg, rendering it to a texture for better performance.
+
+Support freetype for text rendering. Maybe load freetype as runtime (with dlopen) and use that when available and fallback to stb_freetype if not available.

include/Config.hpp

@@ -55,7 +55,7 @@ namespace gsr {
         std::string video_quality = "very_high";
         std::string video_codec = "auto";
         std::string audio_codec = "opus";
-        std::string framerate_mode = "vfr";
+        std::string framerate_mode = "auto";
         bool advanced_view = false;
         bool overclock = false;
         bool record_cursor = true;
@@ -79,6 +79,10 @@ namespace gsr {
         std::string stream_key;
     };
 
+    struct RumbleStreamConfig {
+        std::string stream_key;
+    };
+
     struct CustomStreamConfig {
         std::string url;
         std::string container = "flv";
@@ -91,6 +95,7 @@ namespace gsr {
         std::string streaming_service = "twitch";
         YoutubeStreamConfig youtube;
         TwitchStreamConfig twitch;
+        RumbleStreamConfig rumble;
         CustomStreamConfig custom;
         ConfigHotkey start_stop_hotkey;
     };
@@ -100,6 +105,7 @@ namespace gsr {
         bool save_video_in_game_folder = false;
         bool show_recording_started_notifications = true;
         bool show_video_saved_notifications = true;
+        bool show_video_paused_notifications = true;
         std::string save_directory;
         std::string container = "mp4";
         ConfigHotkey start_stop_hotkey;

include/Theme.hpp

@@ -28,6 +28,7 @@ namespace gsr {
         mgl::Texture combobox_arrow_texture;
         mgl::Texture settings_texture;
         mgl::Texture settings_small_texture;
+        mgl::Texture settings_extra_small_texture;
         mgl::Texture folder_texture;
         mgl::Texture up_arrow_texture;
         mgl::Texture replay_button_texture;

include/gui/SettingsPage.hpp

@@ -186,11 +186,13 @@ namespace gsr {
         CheckBox *save_recording_in_game_folder_ptr = nullptr;
         CheckBox *show_recording_started_notification_checkbox_ptr = nullptr;
         CheckBox *show_video_saved_notification_checkbox_ptr = nullptr;
+        CheckBox *show_video_paused_notification_checkbox_ptr = nullptr;
         CheckBox *show_streaming_started_notification_checkbox_ptr = nullptr;
         CheckBox *show_streaming_stopped_notification_checkbox_ptr = nullptr;
         Button *save_directory_button_ptr = nullptr;
         Entry *twitch_stream_key_entry_ptr = nullptr;
         Entry *youtube_stream_key_entry_ptr = nullptr;
+        Entry *rumble_stream_key_entry_ptr = nullptr;
         Entry *stream_url_entry_ptr = nullptr;
         Entry *replay_time_entry_ptr = nullptr;
         RadioButton *replay_storage_button_ptr = nullptr;

meson.build

@@ -1,4 +1,4 @@
-project('gsr-ui', ['c', 'cpp'], version : '1.6.3', default_options : ['warning_level=2', 'cpp_std=c++17'], subproject_dir : 'depends')
+project('gsr-ui', ['c', 'cpp'], version : '1.6.5', default_options : ['warning_level=2', 'cpp_std=c++17'], subproject_dir : 'depends')
 
 if get_option('buildtype') == 'debug'
     add_project_arguments('-g3', language : ['c', 'cpp'])

project.conf

@@ -1,7 +1,7 @@
 [package]
 name = "gsr-ui"
 type = "executable"
-version = "1.6.3"
+version = "1.6.5"
 platforms = ["posix"]
 
 [lang.cpp]

src/Config.cpp

@@ -201,6 +201,7 @@ namespace gsr {
             {"streaming.service", &config.streaming_config.streaming_service},
             {"streaming.youtube.key", &config.streaming_config.youtube.stream_key},
             {"streaming.twitch.key", &config.streaming_config.twitch.stream_key},
+            {"streaming.rumble.key", &config.streaming_config.rumble.stream_key},
             {"streaming.custom.url", &config.streaming_config.custom.url},
             {"streaming.custom.container", &config.streaming_config.custom.container},
             {"streaming.start_stop_hotkey", &config.streaming_config.start_stop_hotkey},
@@ -229,6 +230,7 @@ namespace gsr {
             {"record.save_video_in_game_folder", &config.record_config.save_video_in_game_folder},
             {"record.show_recording_started_notifications", &config.record_config.show_recording_started_notifications},
             {"record.show_video_saved_notifications", &config.record_config.show_video_saved_notifications},
+            {"record.show_video_paused_notifications", &config.record_config.show_video_paused_notifications},
             {"record.save_directory", &config.record_config.save_directory},
             {"record.container", &config.record_config.container},
             {"record.start_stop_hotkey", &config.record_config.start_stop_hotkey},

src/CursorTracker/CursorTrackerWayland.cpp

@@ -9,14 +9,8 @@
 
 namespace gsr {
     static const int MAX_CONNECTORS = 32;
-    static const int CONNECTOR_TYPE_COUNTS = 32;
     static const uint32_t plane_property_all = 0xF;
 
-    typedef struct {
-        int type;
-        int count;
-    } drm_connector_type_count;
-
     typedef enum {
         PLANE_PROPERTY_CRTC_X      = 1 << 0,
         PLANE_PROPERTY_CRTC_Y      = 1 << 1,
@@ -105,22 +99,6 @@ namespace gsr {
         return get_drm_property_by_name(drm_fd, &properties, name, result);
     }
 
-    static drm_connector_type_count* drm_connector_types_get_index(drm_connector_type_count *type_counts, int *num_type_counts, int connector_type) {
-        for(int i = 0; i < *num_type_counts; ++i) {
-            if(type_counts[i].type == connector_type)
-                return &type_counts[i];
-        }
-
-        if(*num_type_counts == CONNECTOR_TYPE_COUNTS)
-            return NULL;
-
-        const int index = *num_type_counts;
-        type_counts[index].type = connector_type;
-        type_counts[index].count = 0;
-        ++*num_type_counts;
-        return &type_counts[index];
-    }
-
     // Note: this monitor name logic is kept in sync with gpu screen recorder
     static std::string get_monitor_name_from_crtc_id(int drm_fd, uint32_t crtc_id) {
         std::string result;
@@ -128,27 +106,23 @@ namespace gsr {
         if(!resources)
             return result;
 
-        drm_connector_type_count type_counts[CONNECTOR_TYPE_COUNTS];
-        int num_type_counts = 0;
-
         for(int i = 0; i < resources->count_connectors; ++i) {
             uint64_t connector_crtc_id = 0;
             drmModeConnectorPtr connector = drmModeGetConnectorCurrent(drm_fd, resources->connectors[i]);
             if(!connector)
                 continue;
 
-            drm_connector_type_count *connector_type = drm_connector_types_get_index(type_counts, &num_type_counts, connector->connector_type);
             const char *connection_name = drmModeGetConnectorTypeName(connector->connector_type);
-            if(connector_type)
-                ++connector_type->count;
+            if(!connection_name)
+                goto next;
 
             if(connector->connection != DRM_MODE_CONNECTED)
                 goto next;
 
-            if(connector_type && connector_get_property_by_name(drm_fd, connector, "CRTC_ID", &connector_crtc_id) && connector_crtc_id == crtc_id) {
+            if(connector_get_property_by_name(drm_fd, connector, "CRTC_ID", &connector_crtc_id) && connector_crtc_id == crtc_id) {
                 result = connection_name;
                 result += "-";
-                result += std::to_string(connector_type->count);
+                result += std::to_string(connector->connector_type_id);
                 drmModeFreeConnector(connector);
                 break;
             }

src/GlobalHotkeys/GlobalHotkeysJoystick.cpp

@@ -14,6 +14,68 @@ namespace gsr {
     static constexpr int axis_up_down = 7;
     static constexpr int axis_left_right = 6;
 
+    struct DeviceId {
+        uint16_t vendor;
+        uint16_t product;
+    };
+
+    static bool read_file_hex_number(const char *path, unsigned int *value) {
+        *value = 0;
+        FILE *f = fopen(path, "rb");
+        if(!f)
+            return false;
+
+        fscanf(f, "%x", value);
+        fclose(f);
+        return true;
+    }
+
+    static DeviceId joystick_get_device_id(const char *path) {
+        DeviceId device_id;
+        device_id.vendor = 0;
+        device_id.product = 0;
+
+        const char *js_path_id = nullptr;
+        const int len = strlen(path);
+        for(int i = len - 1; i >= 0; --i) {
+            if(path[i] == '/') {
+                js_path_id = path + i + 1;
+                break;
+            }
+        }
+
+        if(!js_path_id)
+            return device_id;
+
+        unsigned int vendor = 0;
+        unsigned int product = 0;
+        char path_buf[1024];
+
+        snprintf(path_buf, sizeof(path_buf), "/sys/class/input/%s/device/id/vendor", js_path_id);
+        if(!read_file_hex_number(path_buf, &vendor))
+            return device_id;
+
+        snprintf(path_buf, sizeof(path_buf), "/sys/class/input/%s/device/id/product", js_path_id);
+        if(!read_file_hex_number(path_buf, &product))
+            return device_id;
+
+        device_id.vendor = vendor;
+        device_id.product = product;
+        return device_id;
+    }
+
+    static bool is_ps4_controller(DeviceId device_id) {
+        return device_id.vendor == 0x054C && (device_id.product == 0x09CC || device_id.product == 0x0BA0 || device_id.product == 0x05C4);
+    }
+
+    static bool is_ps5_controller(DeviceId device_id) {
+        return device_id.vendor == 0x054C && (device_id.product == 0x0DF2 || device_id.product == 0x0CE6);
+    }
+
+    static bool is_stadia_controller(DeviceId device_id) {
+        return device_id.vendor == 0x18D1 && (device_id.product == 0x9400);
+    }
+
     // Returns -1 on error
     static int get_js_dev_input_id_from_filepath(const char *dev_input_filepath) {
         if(strncmp(dev_input_filepath, "/dev/input/js", 13) != 0)
@@ -276,6 +338,8 @@ namespace gsr {
             dev_input_id
         };
 
+        //const DeviceId device_id = joystick_get_device_id(dev_input_filepath);
+
         ++num_poll_fd;
         fprintf(stderr, "Info: added joystick: %s\n", dev_input_filepath);
         return true;

src/Overlay.cpp

@@ -37,6 +37,7 @@
 #include <X11/Xcursor/Xcursor.h>
 #include <mglpp/system/Rect.hpp>
 #include <mglpp/window/Event.hpp>
+#include <mglpp/system/Utf8.hpp>
 
 extern "C" {
 #include <mgl/mgl.h>
@@ -903,6 +904,7 @@ namespace gsr {
         // Wayland doesn't allow XGrabPointer/XGrabKeyboard when a wayland application is focused.
         // If the focused window is a wayland application then don't use override redirect and instead create
         // a fullscreen window for the ui.
+        // TODO: (x11_cursor_window && is_window_fullscreen_on_monitor(display, x11_cursor_window, *focused_monitor))
         const bool prevent_game_minimizing = gsr_info.system_info.display_server != DisplayServer::WAYLAND || x11_cursor_window || is_wlroots;
 
         if(prevent_game_minimizing) {
@@ -1090,7 +1092,7 @@ namespace gsr {
             button->set_item_icon("save", &get_theme().save_texture);
             button->set_item_icon("save_1_min", &get_theme().save_texture);
             button->set_item_icon("save_10_min", &get_theme().save_texture);
-            button->set_item_icon("settings", &get_theme().settings_small_texture);
+            button->set_item_icon("settings", &get_theme().settings_extra_small_texture);
             button->on_click = [this](const std::string &id) {
                 if(id == "settings") {
                     auto replay_settings_page = std::make_unique<SettingsPage>(SettingsPage::Type::REPLAY, &gsr_info, config, &page_stack);
@@ -1124,7 +1126,7 @@ namespace gsr {
             button->add_item("Settings", "settings");
             button->set_item_icon("start", &get_theme().play_texture);
             button->set_item_icon("pause", &get_theme().pause_texture);
-            button->set_item_icon("settings", &get_theme().settings_small_texture);
+            button->set_item_icon("settings", &get_theme().settings_extra_small_texture);
             button->on_click = [this](const std::string &id) {
                 if(id == "settings") {
                     auto record_settings_page = std::make_unique<SettingsPage>(SettingsPage::Type::RECORD, &gsr_info, config, &page_stack);
@@ -1149,7 +1151,7 @@ namespace gsr {
             button->add_item("Start", "start", config.streaming_config.start_stop_hotkey.to_string(false, false));
             button->add_item("Settings", "settings");
             button->set_item_icon("start", &get_theme().play_texture);
-            button->set_item_icon("settings", &get_theme().settings_small_texture);
+            button->set_item_icon("settings", &get_theme().settings_extra_small_texture);
             button->on_click = [this](const std::string &id) {
                 if(id == "settings") {
                     auto stream_settings_page = std::make_unique<SettingsPage>(SettingsPage::Type::STREAM, &gsr_info, config, &page_stack);
@@ -1382,10 +1384,12 @@ namespace gsr {
 
         if(paused) {
             update_ui_recording_unpaused();
-            show_notification("Recording has been unpaused", notification_timeout_seconds, mgl::Color(255, 255, 255), get_color_theme().tint_color, NotificationType::RECORD);
+            if(config.record_config.show_video_paused_notifications)
+                show_notification("Recording has been unpaused", notification_timeout_seconds, mgl::Color(255, 255, 255), get_color_theme().tint_color, NotificationType::RECORD);
         } else {
             update_ui_recording_paused();
-            show_notification("Recording has been paused", notification_timeout_seconds, mgl::Color(255, 255, 255), get_color_theme().tint_color, NotificationType::RECORD);
+            if(config.record_config.show_video_paused_notifications)
+                show_notification("Recording has been paused", notification_timeout_seconds, mgl::Color(255, 255, 255), get_color_theme().tint_color, NotificationType::RECORD);
         }
 
         kill(gpu_screen_recorder_process, SIGUSR2);
@@ -1462,6 +1466,49 @@ namespace gsr {
         return strcmp(capture_target, "focused") != 0 && strcmp(capture_target, "region") != 0 && strcmp(capture_target, "portal") != 0 && contains_non_hex_number(capture_target);
     }
 
+    static std::string get_valid_monitor_x11(const std::string &target_monitor_name, const std::vector<Monitor> &monitors) {
+        std::string target_monitor_name_clean = target_monitor_name;
+        if(starts_with(target_monitor_name_clean, "HDMI-A"))
+            target_monitor_name_clean.replace(0, 6, "HDMI");
+
+        for(const Monitor &monitor : monitors) {
+            std::string monitor_name_clean = monitor.name;
+            if(starts_with(monitor_name_clean, "HDMI-A"))
+                monitor_name_clean.replace(0, 6, "HDMI");
+
+            if(target_monitor_name_clean == monitor_name_clean)
+                return monitor.name;
+        }
+
+        return "";
+    }
+
+    static std::string get_focused_monitor_by_cursor(CursorTracker *cursor_tracker, const GsrInfo &gsr_info, const std::vector<Monitor> &x11_monitors) {
+        std::optional<CursorInfo> cursor_info;
+        if(cursor_tracker) {
+            cursor_tracker->update();
+            cursor_info = cursor_tracker->get_latest_cursor_info();
+        }
+
+        std::string focused_monitor_name;
+        if(cursor_info) {
+            focused_monitor_name = std::move(cursor_info->monitor_name);
+        } else {
+            mgl_context *context = mgl_get_context();
+            Display *display = (Display*)context->connection;
+
+            Window x11_cursor_window = None;
+            mgl::vec2i cursor_position = get_cursor_position(display, &x11_cursor_window);
+
+            const mgl::vec2i monitor_position_query_value = (x11_cursor_window || gsr_info.system_info.display_server != DisplayServer::WAYLAND) ? cursor_position : create_window_get_center_position(display);
+            const Monitor *focused_monitor = find_monitor_at_position(x11_monitors, monitor_position_query_value);
+            if(focused_monitor)
+                focused_monitor_name = focused_monitor->name;
+        }
+
+        return focused_monitor_name;
+    }
+
     void Overlay::show_notification(const char *str, double timeout_seconds, mgl::Color icon_color, mgl::Color bg_color, NotificationType notification_type, const char *capture_target) {
         char timeout_seconds_str[32];
         snprintf(timeout_seconds_str, sizeof(timeout_seconds_str), "%f", timeout_seconds);
@@ -1480,20 +1527,24 @@ namespace gsr {
             notification_args[arg_index++] = notification_type_str;
         }
 
-        if(capture_target && is_capture_target_monitor(capture_target)) {
-            notification_args[arg_index++] = "--monitor";
-            notification_args[arg_index++] = capture_target;
-        } else {
-            std::optional<CursorInfo> cursor_info;
-            if(cursor_tracker) {
-                cursor_tracker->update();
-                cursor_info = cursor_tracker->get_latest_cursor_info();
-            }
+        mgl_context *context = mgl_get_context();
+        Display *display = (Display*)context->connection;
 
-            if(cursor_info) {
-                notification_args[arg_index++] = "--monitor";
-                notification_args[arg_index++] = cursor_info->monitor_name.c_str();
-            }
+        std::string monitor_name;
+        const auto monitors = get_monitors(display);
+
+        if(capture_target && is_capture_target_monitor(capture_target))
+            monitor_name = capture_target;
+        else
+            monitor_name = get_focused_monitor_by_cursor(cursor_tracker.get(), gsr_info, monitors);
+
+        monitor_name = get_valid_monitor_x11(monitor_name, monitors);
+        if(!monitor_name.empty()) {
+            notification_args[arg_index++] = "--monitor";
+            notification_args[arg_index++] = monitor_name.c_str();
+        } else if(!monitors.empty()) {
+            notification_args[arg_index++] = "--monitor";
+            notification_args[arg_index++] = monitors.front().name.c_str();
         }
 
         notification_args[arg_index++] = nullptr;
@@ -1592,8 +1643,21 @@ namespace gsr {
     }
 
     static void truncate_string(std::string &str, int max_length) {
-        if((int)str.size() > max_length)
-            str.replace(str.begin() + max_length, str.end(), "...");
+        int index = 0;
+        size_t byte_index = 0;
+
+        while(index < max_length && byte_index < str.size()) {
+            uint32_t codepoint = 0;
+            size_t codepoint_length = 0;
+            mgl::utf8_decode((const unsigned char*)str.c_str() + byte_index, str.size() - byte_index, &codepoint, &codepoint_length);
+            if(codepoint_length == 0)
+                codepoint_length = 1;
+
+            index += 1;
+            byte_index += codepoint_length;
+        }
+
+        str.erase(byte_index);
     }
 
     void Overlay::save_video_in_current_game_directory(const char *video_filepath, NotificationType notification_type) {
@@ -1684,7 +1748,7 @@ namespace gsr {
         replay_save_show_notification = false;
         if(config.replay_config.save_video_in_game_folder) {
             save_video_in_current_game_directory(replay_saved_filepath, NotificationType::REPLAY);
-        } else {
+        } else if(config.replay_config.show_replay_saved_notifications) {
             char duration[32];
             if(replay_save_duration_min > 0)
                 snprintf(duration, sizeof(duration), " %d minute ", replay_save_duration_min);
@@ -1814,7 +1878,7 @@ namespace gsr {
         if(exit_code == 0) {
             if(config.screenshot_config.save_screenshot_in_game_folder) {
                 save_video_in_current_game_directory(screenshot_filepath.c_str(), NotificationType::SCREENSHOT);
-            } else {
+            } else if(config.screenshot_config.show_screenshot_saved_notifications) {
                 char msg[512];
                 if(is_capture_target_monitor(screenshot_capture_target.c_str()))
                     snprintf(msg, sizeof(msg), "Saved a screenshot of this monitor");
@@ -1916,7 +1980,7 @@ namespace gsr {
         if(exit_code == 0) {
             if(config.record_config.save_video_in_game_folder) {
                 save_video_in_current_game_directory(video_filepath.c_str(), NotificationType::RECORD);
-            } else {
+            } else if(config.record_config.show_video_saved_notifications) {
                 char msg[512];
                 if(is_capture_target_monitor(recording_capture_target.c_str()))
                     snprintf(msg, sizeof(msg), "Saved a recording of this monitor");
@@ -2132,6 +2196,23 @@ namespace gsr {
         }
     }
 
+    static std::string get_valid_capture_target(const std::string &capture_target, const SupportedCaptureOptions &capture_options) {
+        std::string capture_target_clean = capture_target;
+        if(starts_with(capture_target_clean, "HDMI-A"))
+            capture_target_clean.replace(0, 6, "HDMI");
+
+        for(const GsrMonitor &monitor : capture_options.monitors) {
+            std::string monitor_name_clean = monitor.name;
+            if(starts_with(monitor_name_clean, "HDMI-A"))
+                monitor_name_clean.replace(0, 6, "HDMI");
+
+            if(capture_target_clean == monitor_name_clean)
+                return monitor.name;
+        }
+
+        return "";
+    }
+
     std::string Overlay::get_capture_target(const std::string &capture_target, const SupportedCaptureOptions &capture_options) {
         if(capture_target == "focused_monitor") {
             std::optional<CursorInfo> cursor_info;
@@ -2146,17 +2227,10 @@ namespace gsr {
             } else {
                 mgl_context *context = mgl_get_context();
                 Display *display = (Display*)context->connection;
-
-                Window x11_cursor_window = None;
-                mgl::vec2i cursor_position = get_cursor_position(display, &x11_cursor_window);
-
-                const mgl::vec2i monitor_position_query_value = (x11_cursor_window || gsr_info.system_info.display_server != DisplayServer::WAYLAND) ? cursor_position : create_window_get_center_position(display);
-                auto monitors = get_monitors(display);
-                const Monitor *focused_monitor = find_monitor_at_position(monitors, monitor_position_query_value);
-                if(focused_monitor)
-                    focused_monitor_name = focused_monitor->name;
+                focused_monitor_name = get_focused_monitor_by_cursor(cursor_tracker.get(), gsr_info, get_monitors(display));
             }
 
+            focused_monitor_name = get_valid_capture_target(focused_monitor_name, capture_options);
             if(!focused_monitor_name.empty())
                 return focused_monitor_name;
             else if(!capture_options.monitors.empty())
@@ -2520,6 +2594,9 @@ namespace gsr {
         } else if(config.streaming_config.streaming_service == "youtube") {
             url += "rtmp://a.rtmp.youtube.com/live2/";
             url += config.streaming_config.youtube.stream_key;
+        } else if(config.streaming_config.streaming_service == "rumble") {
+            url += "rtmp://rtmp.rumble.com/live/";
+            url += config.streaming_config.rumble.stream_key;
         } else if(config.streaming_config.streaming_service == "custom") {
             url = config.streaming_config.custom.url;
             if(url.size() >= 7 && strncmp(url.c_str(), "rtmp://", 7) == 0)

src/Theme.cpp

@@ -63,31 +63,34 @@ namespace gsr {
         if(!theme->title_font_file.load((resources_path + "fonts/NotoSans-Bold.ttf").c_str(), mgl::MemoryMappedFile::LoadOptions{true, false}))
             goto error;
 
-        if(!theme->combobox_arrow_texture.load_from_file((resources_path + "images/combobox_arrow.png").c_str()))
+        if(!theme->combobox_arrow_texture.load_from_file((resources_path + "images/combobox_arrow.png").c_str(), mgl::Texture::LoadOptions{false, false, MGL_TEXTURE_SCALE_LINEAR_MIPMAP}))
             goto error;
 
         if(!theme->settings_texture.load_from_file((resources_path + "images/settings.png").c_str()))
             goto error;
 
-        if(!theme->settings_small_texture.load_from_file((resources_path + "images/settings_small.png").c_str()))
+        if(!theme->settings_small_texture.load_from_file((resources_path + "images/settings_small.png").c_str(), mgl::Texture::LoadOptions{false, false, MGL_TEXTURE_SCALE_LINEAR_MIPMAP}))
             goto error;
 
-        if(!theme->folder_texture.load_from_file((resources_path + "images/folder.png").c_str()))
+        if(!theme->settings_extra_small_texture.load_from_file((resources_path + "images/settings_extra_small.png").c_str(), mgl::Texture::LoadOptions{false, false, MGL_TEXTURE_SCALE_LINEAR_MIPMAP}))
+            goto error;
+
+        if(!theme->folder_texture.load_from_file((resources_path + "images/folder.png").c_str(), mgl::Texture::LoadOptions{false, false, MGL_TEXTURE_SCALE_LINEAR_MIPMAP}))
             goto error;
 
         if(!theme->up_arrow_texture.load_from_file((resources_path + "images/up_arrow.png").c_str(), mgl::Texture::LoadOptions{false, false, MGL_TEXTURE_SCALE_LINEAR_MIPMAP}))
             goto error;
 
-        if(!theme->replay_button_texture.load_from_file((resources_path + "images/replay.png").c_str()))
+        if(!theme->replay_button_texture.load_from_file((resources_path + "images/replay.png").c_str(), mgl::Texture::LoadOptions{false, false, MGL_TEXTURE_SCALE_LINEAR_MIPMAP}))
             goto error;
 
-        if(!theme->record_button_texture.load_from_file((resources_path + "images/record.png").c_str()))
+        if(!theme->record_button_texture.load_from_file((resources_path + "images/record.png").c_str(), mgl::Texture::LoadOptions{false, false, MGL_TEXTURE_SCALE_LINEAR_MIPMAP}))
             goto error;
 
-        if(!theme->stream_button_texture.load_from_file((resources_path + "images/stream.png").c_str()))
+        if(!theme->stream_button_texture.load_from_file((resources_path + "images/stream.png").c_str(), mgl::Texture::LoadOptions{false, false, MGL_TEXTURE_SCALE_LINEAR_MIPMAP}))
             goto error;
 
-        if(!theme->close_texture.load_from_file((resources_path + "images/cross.png").c_str()))
+        if(!theme->close_texture.load_from_file((resources_path + "images/cross.png").c_str(), mgl::Texture::LoadOptions{false, false, MGL_TEXTURE_SCALE_LINEAR_MIPMAP}))
             goto error;
 
         if(!theme->logo_texture.load_from_file((resources_path + "images/gpu_screen_recorder_logo.png").c_str()))
@@ -99,19 +102,19 @@ namespace gsr {
         if(!theme->checkbox_background_texture.load_from_file((resources_path + "images/checkbox_background.png").c_str(), mgl::Texture::LoadOptions{false, false, MGL_TEXTURE_SCALE_LINEAR_MIPMAP}))
             goto error;
 
-        if(!theme->play_texture.load_from_file((resources_path + "images/play.png").c_str()))
+        if(!theme->play_texture.load_from_file((resources_path + "images/play.png").c_str(), mgl::Texture::LoadOptions{false, false, MGL_TEXTURE_SCALE_LINEAR_MIPMAP}))
             goto error;
 
-        if(!theme->stop_texture.load_from_file((resources_path + "images/stop.png").c_str()))
+        if(!theme->stop_texture.load_from_file((resources_path + "images/stop.png").c_str(), mgl::Texture::LoadOptions{false, false, MGL_TEXTURE_SCALE_LINEAR_MIPMAP}))
             goto error;
 
-        if(!theme->pause_texture.load_from_file((resources_path + "images/pause.png").c_str()))
+        if(!theme->pause_texture.load_from_file((resources_path + "images/pause.png").c_str(), mgl::Texture::LoadOptions{false, false, MGL_TEXTURE_SCALE_LINEAR_MIPMAP}))
             goto error;
 
-        if(!theme->save_texture.load_from_file((resources_path + "images/save.png").c_str()))
+        if(!theme->save_texture.load_from_file((resources_path + "images/save.png").c_str(), mgl::Texture::LoadOptions{false, false, MGL_TEXTURE_SCALE_LINEAR_MIPMAP}))
             goto error;
 
-        if(!theme->screenshot_texture.load_from_file((resources_path + "images/screenshot.png").c_str()))
+        if(!theme->screenshot_texture.load_from_file((resources_path + "images/screenshot.png").c_str(), mgl::Texture::LoadOptions{false, false, MGL_TEXTURE_SCALE_LINEAR_MIPMAP}))
             goto error;
 
         if(!theme->trash_texture.load_from_file((resources_path + "images/trash.png").c_str(), mgl::Texture::LoadOptions{false, false, MGL_TEXTURE_SCALE_LINEAR_MIPMAP}))

src/gui/SettingsPage.cpp

@@ -940,6 +940,11 @@ namespace gsr {
         show_video_saved_notification_checkbox_ptr = show_video_saved_notification_checkbox.get();
         checkboxes_list->add_widget(std::move(show_video_saved_notification_checkbox));
 
+        auto show_video_paused_notification_checkbox = std::make_unique<CheckBox>(&get_theme().body_font, "Show video paused/unpaused notification");
+        show_video_paused_notification_checkbox->set_checked(true);
+        show_video_paused_notification_checkbox_ptr = show_video_paused_notification_checkbox.get();
+        checkboxes_list->add_widget(std::move(show_video_paused_notification_checkbox));
+
         auto notifications_subsection = std::make_unique<Subsection>("Notifications", std::move(checkboxes_list), mgl::vec2f(settings_scrollable_page_ptr->get_inner_size().x, 0.0f));        
         Subsection *notifications_subsection_ptr = notifications_subsection.get();
         settings_list_ptr->add_widget(std::move(notifications_subsection));
@@ -959,6 +964,7 @@ namespace gsr {
         auto streaming_service_box = std::make_unique<ComboBox>(&get_theme().body_font);
         streaming_service_box->add_item("Twitch", "twitch");
         streaming_service_box->add_item("YouTube", "youtube");
+        streaming_service_box->add_item("Rumble", "rumble");
         streaming_service_box->add_item("Custom", "custom");
         streaming_service_box_ptr = streaming_service_box.get();
         return streaming_service_box;
@@ -983,6 +989,10 @@ namespace gsr {
         youtube_stream_key_entry_ptr = youtube_stream_key_entry.get();
         stream_key_list->add_widget(std::move(youtube_stream_key_entry));
 
+        auto rumble_stream_key_entry = std::make_unique<Entry>(&get_theme().body_font, "", get_theme().body_font.get_character_size() * 20);
+        rumble_stream_key_entry_ptr = rumble_stream_key_entry.get();
+        stream_key_list->add_widget(std::move(rumble_stream_key_entry));
+
         stream_key_list_ptr = stream_key_list.get();
         return stream_key_list;
     }
@@ -1044,12 +1054,14 @@ namespace gsr {
         streaming_service_box_ptr->on_selection_changed = [this](const std::string&, const std::string &id) {
             const bool twitch_option = id == "twitch";
             const bool youtube_option = id == "youtube";
+            const bool rumble_option = id == "rumble";
             const bool custom_option = id == "custom";
             stream_key_list_ptr->set_visible(!custom_option);
             stream_url_list_ptr->set_visible(custom_option);
             container_list_ptr->set_visible(custom_option);
             twitch_stream_key_entry_ptr->set_visible(twitch_option);
             youtube_stream_key_entry_ptr->set_visible(youtube_option);
+            rumble_stream_key_entry_ptr->set_visible(rumble_option);
             return true;
         };
         streaming_service_box_ptr->on_selection_changed("Twitch", "twitch");
@@ -1239,6 +1251,7 @@ namespace gsr {
         save_recording_in_game_folder_ptr->set_checked(config.record_config.save_video_in_game_folder);
         show_recording_started_notification_checkbox_ptr->set_checked(config.record_config.show_recording_started_notifications);
         show_video_saved_notification_checkbox_ptr->set_checked(config.record_config.show_video_saved_notifications);
+        show_video_paused_notification_checkbox_ptr->set_checked(config.record_config.show_video_paused_notifications);
         save_directory_button_ptr->set_text(config.record_config.save_directory);
         container_box_ptr->set_selected_item(config.record_config.container);
     }
@@ -1250,6 +1263,7 @@ namespace gsr {
         streaming_service_box_ptr->set_selected_item(config.streaming_config.streaming_service);
         youtube_stream_key_entry_ptr->set_text(config.streaming_config.youtube.stream_key);
         twitch_stream_key_entry_ptr->set_text(config.streaming_config.twitch.stream_key);
+        rumble_stream_key_entry_ptr->set_text(config.streaming_config.rumble.stream_key);
         stream_url_entry_ptr->set_text(config.streaming_config.custom.url);
         container_box_ptr->set_selected_item(config.streaming_config.custom.container);
     }
@@ -1379,6 +1393,7 @@ namespace gsr {
         config.record_config.save_video_in_game_folder = save_recording_in_game_folder_ptr->is_checked();
         config.record_config.show_recording_started_notifications = show_recording_started_notification_checkbox_ptr->is_checked();
         config.record_config.show_video_saved_notifications = show_video_saved_notification_checkbox_ptr->is_checked();
+        config.record_config.show_video_paused_notifications = show_video_paused_notification_checkbox_ptr->is_checked();
         config.record_config.save_directory = save_directory_button_ptr->get_text();
         config.record_config.container = container_box_ptr->get_selected_id();
     }
@@ -1390,6 +1405,7 @@ namespace gsr {
         config.streaming_config.streaming_service = streaming_service_box_ptr->get_selected_id();
         config.streaming_config.youtube.stream_key = youtube_stream_key_entry_ptr->get_text();
         config.streaming_config.twitch.stream_key = twitch_stream_key_entry_ptr->get_text();
+        config.streaming_config.rumble.stream_key = rumble_stream_key_entry_ptr->get_text();
         config.streaming_config.custom.url = stream_url_entry_ptr->get_text();
         config.streaming_config.custom.container = container_box_ptr->get_selected_id();
     }

tools/gsr-global-hotkeys/main.c

@@ -44,42 +44,42 @@ int main(int argc, char **argv) {
         } else if(strcmp(grab_type_arg, "--virtual") == 0) {
             grab_type = KEYBOARD_GRAB_TYPE_VIRTUAL;
         } else {
-            fprintf(stderr, "Error: expected --all or --virtual, got %s\n", grab_type_arg);
+            fprintf(stderr, "gsr-global-hotkeys error: expected --all or --virtual, got %s\n", grab_type_arg);
             usage();
             return 1;
         }
     } else if(argc != 1) {
-        fprintf(stderr, "Error: expected 0 or 1 arguments, got %d argument(s)\n", argc);
+        fprintf(stderr, "gsr-global-hotkeys error: expected 0 or 1 arguments, got %d argument(s)\n", argc);
         usage();
         return 1;
     }
 
     if(is_gsr_global_hotkeys_already_running()) {
-        fprintf(stderr, "Error: gsr-global-hotkeys is already running\n");
+        fprintf(stderr, "gsr-global-hotkeys error: gsr-global-hotkeys is already running\n");
         return 1;
     }
 
     const uid_t user_id = getuid();
     if(geteuid() != 0) {
         if(setuid(0) == -1) {
-            fprintf(stderr, "Error: failed to change user to root\n");
+            fprintf(stderr, "gsr-global-hotkeys error: failed to change user to root, global hotkeys will not work. Make sure to set the correct capability on gsr-global-hotkeys\n");
             return 1;
         }
     }
 
     keyboard_event keyboard_ev;
     if(!keyboard_event_init(&keyboard_ev, true, grab_type)) {
-        fprintf(stderr, "Error: failed to setup hotplugging and no keyboard input devices were found\n");
+        fprintf(stderr, "gsr-global-hotkeys error: failed to setup hotplugging and no keyboard input devices were found\n");
         setuid(user_id);
         return 1;
     }
 
-    fprintf(stderr, "Info: global hotkeys setup, waiting for hotkeys to be pressed\n");
+    fprintf(stderr, "gsr-global-hotkeys info: global hotkeys setup, waiting for hotkeys to be pressed\n");
 
     for(;;) {
         keyboard_event_poll_events(&keyboard_ev, -1);
         if(keyboard_event_stdin_has_failed(&keyboard_ev)) {
-            fprintf(stderr, "Info: stdin closed (parent process likely closed this process), exiting...\n");
+            fprintf(stderr, "gsr-global-hotkeys info: stdin closed (parent process likely closed this process), exiting...\n");
             break;
         }
     }