Add option to save temporary replay data on disk

README.md

@@ -22,14 +22,12 @@ GPU Screen Recorder UI uses meson build system so you need to install `meson` to
 ## Build dependencies
 These are the dependencies needed to build GPU Screen Recorder UI:
 
-* x11 (libx11, libxrandr, libxrender, libxcomposite, libxfixes, libxext, libxi)
-* libxcursor
+* x11 (libx11, libxrandr, libxrender, libxcomposite, libxfixes, libxext, libxi, libxcursor)
 * libglvnd (which provides libgl, libglx and libegl)
 * linux-api-headers
 * libpulse (libpulse-simple)
 * libdrm
-* wayland-client
-* wayland-scanner
+* wayland (wayland-client, wayland-egl, wayland-scanner)
 
 ## Runtime dependencies
 There are also additional dependencies needed at runtime:
@@ -38,14 +36,17 @@ There are also additional dependencies needed at runtime:
 * [GPU Screen Recorder Notification](https://git.dec05eba.com/gpu-screen-recorder-notification/)
 
 ## Program behavior notes
-This program has to grab all keyboards and create a virtual keyboard (`gsr-ui virtual keyboard`) to make global hotkeys work on all Wayland compositors.
-This might cause issues for you if you use input remapping software. To workaround this you can go into settings and select "Only grab virtual devices"
+This program has to grab all keyboards and create a virtual keyboard (`gsr-ui virtual keyboard`) to make global hotkeys work on all Wayland compositors.\
+This might cause issues for you if you use keyboard remapping software. To workaround this you can go into settings and select "Only grab virtual devices".\
+If you use keyboard remapping software such as keyd then make sure to make it ignore "gsr-ui virtual keyboard" (dec0:5eba device id), otherwise your keyboard can get locked
+as gpu screen recorder tries to grab keys and keyd grabs gpu screen recorder, leading to a lock.\
+If you are stuck in such a lock where you cant press and keyboard keys you can press (left) ctrl+shift+alt+esc to close gpu screen recorder and remove it from system startup.
 
 # License
 This software is licensed under GPL3.0-only. Files under `fonts/` directory belong to the Noto Sans Google fonts project and they are licensed under `SIL Open Font License`.\
 `images/default.cur` it part of the [Adwaita icon theme](https://gitlab.gnome.org/GNOME/adwaita-icon-theme/-/tree/master) which is licensed under `CC BY-SA 3.0`.\
 The controller buttons under `images/` were created by [Julio Cacko](https://juliocacko.itch.io/free-input-prompts) and they are licensed under `CC0 1.0 Universal`.\
-The PlayStation logo under `images/` was created by [ArksDigital](https://arks.itch.io/ps4-buttons) and it's are licensed under `CC BY 4.0`.
+The PlayStation logo under `images/` was created by [ArksDigital](https://arks.itch.io/ps4-buttons) and it's licensed under `CC BY 4.0`.
 
 # Reporting bugs, contributing patches, questions or donation
 See [https://git.dec05eba.com/?p=about](https://git.dec05eba.com/?p=about).\

TODO

@@ -14,8 +14,6 @@ Add nvidia overclock option.
 
 Add support for window selection in capture.
 
-Add option to record the focused monitor. This works on wayland too when using kms capture since we can get cursor position without root and see which monitor (crtc) the cursor is on. Or use create_window_get_center_position.
-
 Filechooser should have the option to select list view, search bar and common folders/mounted drives on the left side for quick navigation. Also a button to create a new directory.
 
 Restart replay on system start if monitor resolution changes.
@@ -113,6 +111,8 @@ Check if "modprobe uinput" is needed on some systems (old fedora?).
 Add recording timer to see duration of recording/streaming.
 
 Make folder with window name work when using gamescope. Gamescope runs x11 itself so to get the window name inside that we have to connect to the gamescope X11 server (DISPLAY=:1 on x11 and DISPLAY=:2 on wayland, but not always).
+    Detect if the window is gamescope automatically (WM_CLASS = "gamescope") and get the x11 display automatically and connect to it to get the application its running.
+    This seems to only be an issue on wayland? the window title of the gamescope/steam bigpicture mode is the title of the game on x11, so it works automatically on x11.
 
 When clicking on current directory in file manager show a dropdown menu where you can select common directories (HOME, Videos, Downloads and mounted drives) for quick navigation. Maybe even button to search.
 
@@ -121,8 +121,6 @@ Maybe change gsr-ui startup retry time in the systemd service, from 5 seconds to
 Add support for window capture. This should not prompt for window selection directly but instead prompt for window selection when recording starts and hide the ui first.
     For screenshots window capture should exist but "follow focused" option should not exist.
 
-Improve audio design. It should have a button to add/remove audio tracks and button to add audio into each audio track separately and "record audio from all applications except the selected ones" for each audio track. Then also remove the "merge audio tracks" option.
-
 Make it possible to take a screenshot through a button in the ui instead of having to use hotkey.
 
 Handle failing to save a replay. gsr should output "failed to save replay, or something like that" to make it possible to detect that.
@@ -158,3 +156,23 @@ Notification with the focused monitor (with CursorTrackerWayland) assumes that t
 If CursorTrackerWayland fails then fallback to getting focused monitor by window creation trick. Need to take into consideration prime laptop with dGPU that controls external monitors which cant be captured (different /dev/dri/card device).
     Maybe automatically switch to recording with the device that controls the monitor.
     In that case also add all monitors available to capture in the capture list and automatically choose the gpu that controls the monitor.
+
+Support cjk font. Use fc-match to find the location of the font. This also works in flatpak, in which case the fonts are in /run/host/..., where it lists system fonts.
+
+Keyboard layout is incorrect on wayland when using kde plasma keyboard settings to setup multiple keyboards, for example when changing to french.
+    Text input is correct, but hotkey is incorrect.
+    Need to use "setxkbmap fr" as well.
+    This happens only when grabbing keyboard (gsr-global-hotkeys). Same thing is seen with xev.
+
+Getting focused monitor on wayland doesn't work when vrr is enabled. This is because it uses software cursor instead (at least on kde plasma wayland).
+    Right now it falls back to create window & getting window position trick if there is no cursor visible (or a software cursor) and one monitor has vrr enabled.
+        Remove this when linux & wayland supports vrr with hardware cursor plane.
+    Find out another way to get cursor position on wayland.
+    This was fixed in linux 6.11 and in kde plasma in this commit: https://invent.kde.org/plasma/kwin/-/merge_requests/7582/diffs.
+
+Add option to start recording/replay/stream after the notification has disappeared. Show "Starting recording on this monitor in 3 seconds".
+    See if we can use hardware overlay plane instead somehow.
+
+When using wayland for mgl try using wlr-layer-shell and set layer to overlay and keyboard interactivity to exclusive. Do something similar for notifications.
+
+When starting gsr-ui remove any temporary replay disk data that has possibly remained from a crash, by looking for all folders that starts with gsr-replay and end with .gsr, in the replay directory.

extra/gpu-screen-recorder-ui.service

@@ -2,7 +2,7 @@
 Description=GPU Screen Recorder UI Service
 
 [Service]
-ExecStart=gsr-ui
+ExecStart=gsr-ui launch-daemon
 KillSignal=SIGINT
 Restart=on-failure
 RestartSec=5s

flatpak/gpu-screen-recorder-ui.service

@@ -2,7 +2,7 @@
 Description=GPU Screen Recorder UI Service
 
 [Service]
-ExecStart=flatpak run com.dec05eba.gpu_screen_recorder gsr-ui
+ExecStart=flatpak run com.dec05eba.gpu_screen_recorder gsr-ui launch-daemon
 KillSignal=SIGINT
 Restart=on-failure
 RestartSec=5s

include/Config.hpp

@@ -6,7 +6,7 @@
 #include <vector>
 #include <optional>
 
-#define GSR_CONFIG_FILE_VERSION 1
+#define GSR_CONFIG_FILE_VERSION 2
 
 namespace gsr {
     struct SupportedCaptureOptions;
@@ -30,6 +30,14 @@ namespace gsr {
         std::string to_string(bool spaces = true, bool modifier_side = true) const;
     };
 
+    struct AudioTrack {
+        std::vector<std::string> audio_inputs; // ids
+        bool application_audio_invert = false;
+
+        bool operator==(const AudioTrack &other) const;
+        bool operator!=(const AudioTrack &other) const;
+    };
+
     struct RecordOptions {
         std::string record_area_option = "screen";
         int32_t record_area_width = 0;
@@ -38,10 +46,11 @@ namespace gsr {
         int32_t video_height = 0;
         int32_t fps = 60;
         int32_t video_bitrate = 15000;
-        bool merge_audio_tracks = true; // Currently unused for streaming because all known streaming sites only support 1 audio track
-        bool application_audio_invert = false;
+        bool merge_audio_tracks = true; // TODO: Remove in the future
+        bool application_audio_invert = false; // TODO: Remove in the future
         bool change_video_resolution = false;
-        std::vector<std::string> audio_tracks;
+        std::vector<std::string> audio_tracks; // ids, TODO: Remove in the future
+        std::vector<AudioTrack> audio_tracks_list;
         std::string color_range = "limited";
         std::string video_quality = "very_high";
         std::string video_codec = "auto";
@@ -108,8 +117,11 @@ namespace gsr {
         std::string save_directory;
         std::string container = "mp4";
         int32_t replay_time = 60;
+        std::string replay_storage = "ram";
         ConfigHotkey start_stop_hotkey;
         ConfigHotkey save_hotkey;
+        ConfigHotkey save_1_min_hotkey;
+        ConfigHotkey save_10_min_hotkey;
     };
 
     struct ScreenshotConfig {

include/GlobalHotkeys/GlobalHotkeysJoystick.hpp

@@ -1,7 +1,7 @@
 #pragma once
 
 #include "GlobalHotkeys.hpp"
-#include "Hotplug.hpp"
+#include "../Hotplug.hpp"
 #include <unordered_map>
 #include <thread>
 #include <poll.h>
@@ -21,6 +21,8 @@ namespace gsr {
         bool start();
         // Currently valid ids:
         // save_replay
+        // save_1_min_replay
+        // save_10_min_replay
         // take_screenshot
         // toggle_record
         // toggle_replay
@@ -56,6 +58,8 @@ namespace gsr {
         bool right_pressed = false;
 
         bool save_replay = false;
+        bool save_1_min_replay = false;
+        bool save_10_min_replay = false;
         bool take_screenshot = false;
         bool toggle_record = false;
         bool toggle_replay = false;

include/GlobalHotkeys/GlobalHotkeysLinux.hpp

@@ -21,6 +21,8 @@ namespace gsr {
         bool bind_key_press(Hotkey hotkey, const std::string &id, GlobalHotkeyCallback callback) override;
         void unbind_all_keys() override;
         void poll_events() override;
+    private:
+        void close_fds();
     private:
         pid_t process_id = 0;
         int read_pipes[2];

include/Overlay.hpp

@@ -6,10 +6,10 @@
 #include "Config.hpp"
 #include "window_texture.h"
 #include "WindowUtils.hpp"
-#include "GlobalHotkeysJoystick.hpp"
+#include "GlobalHotkeys/GlobalHotkeysJoystick.hpp"
 #include "AudioPlayer.hpp"
 #include "RegionSelector.hpp"
-#include "CursorTracker.hpp"
+#include "CursorTracker/CursorTracker.hpp"
 
 #include <mglpp/window/Window.hpp>
 #include <mglpp/window/Event.hpp>
@@ -59,12 +59,15 @@ namespace gsr {
         void toggle_stream();
         void toggle_replay();
         void save_replay();
+        void save_replay_1_min();
+        void save_replay_10_min();
         void take_screenshot();
         void take_screenshot_region();
         void show_notification(const char *str, double timeout_seconds, mgl::Color icon_color, mgl::Color bg_color, NotificationType notification_type, const char *capture_target = nullptr);
         bool is_open() const;
         bool should_exit(std::string &reason) const;
         void exit();
+        void go_back_to_old_ui();
 
         const Config& get_config() const;
 
@@ -86,7 +89,7 @@ namespace gsr {
         void update_notification_process_status();
         void save_video_in_current_game_directory(const char *video_filepath, NotificationType notification_type);
         void on_replay_saved(const char *replay_saved_filepath);
-        void update_gsr_replay_save();
+        void process_gsr_output();
         void update_gsr_process_status();
         void update_gsr_screenshot_process_status();
 
@@ -95,7 +98,7 @@ namespace gsr {
         void update_power_supply_status();
         void update_system_startup_status();
 
-        void on_stop_recording(int exit_code);
+        void on_stop_recording(int exit_code, const std::string &video_filepath);
 
         void update_ui_recording_paused();
         void update_ui_recording_unpaused();
@@ -109,7 +112,10 @@ namespace gsr {
         void update_ui_replay_started();
         void update_ui_replay_stopped();
 
+        void prepare_gsr_output_for_reading();
         void on_press_save_replay();
+        void on_press_save_replay_1_min_replay();
+        void on_press_save_replay_10_min_replay();
         bool on_press_start_replay(bool disable_notification, bool finished_region_selection);
         void on_press_start_record(bool finished_region_selection);
         void on_press_start_stream(bool finished_region_selection);
@@ -203,6 +209,8 @@ namespace gsr {
         bool replay_save_show_notification = false;
         ReplayStartupMode replay_startup_mode = ReplayStartupMode::TURN_ON_AT_SYSTEM_STARTUP;
         bool try_replay_startup = true;
+        bool replay_recording = false;
+        int replay_save_duration_min = 0;
 
         AudioPlayer audio_player;
         RegionSelector region_selector;
@@ -210,7 +218,6 @@ namespace gsr {
         std::function<void()> on_region_selected;
 
         std::string recording_capture_target;
-        std::string replay_capture_target;
         std::string screenshot_capture_target;
 
         std::unique_ptr<CursorTracker> cursor_tracker;

include/SafeVector.hpp

@@ -1,8 +1,15 @@
 #pragma once
 
 #include <vector>
-#include <memory>
 #include <functional>
+#include <assert.h>
+#include "gui/Widget.hpp"
+
+template <typename T>
+struct SafeVectorItem {
+    T item;
+    bool alive = false;
+};
 
 // A vector that can be modified while iterating
 template <typename T>
@@ -10,64 +17,84 @@ class SafeVector {
 public:
     using PointerType = typename std::pointer_traits<T>::element_type*;
 
+    SafeVector() = default;
+    SafeVector(const SafeVector&) = delete;
+    SafeVector& operator=(const SafeVector&) = delete;
+    ~SafeVector() {
+        clear();
+    }
+
     void push_back(T item) {
-        data.push_back(std::move(item));
+        data.push_back({std::move(item), true});
+        ++num_items_alive;
     }
 
     // Safe to call when vector is empty
     // TODO: Make this iterator safe
     void pop_back() {
-        if(!data.empty())
+        if(!data.empty()) {
+            gsr::add_widget_to_remove(std::move(data.back().item));
             data.pop_back();
+            --num_items_alive;
+        }
     }
 
     // Might not remove the data immediately if inside for_each loop.
     // In that case the item is removed at the end of the loop.
     void remove(PointerType item_to_remove) {
-        if(for_each_depth == 0)
+        if(for_each_depth == 0) {
             remove_item(item_to_remove);
-        else
-            remove_queue.push_back(item_to_remove);
+            return;
+        }
+
+        SafeVectorItem<T> *item = get_item(item_to_remove);
+        if(item && item->alive) {
+            item->alive = false;
+            --num_items_alive;
+            has_items_to_remove = true;
+        }
     }
 
     // Safe to call when vector is empty, in which case it returns nullptr
     T* back() {
-        if(data.empty())
-            return nullptr;
-        else
-            return &data.back();
+        for(auto it = data.rbegin(), end = data.rend(); it != end; ++it) {
+            if(it->alive)
+                return &it->item;
+        }
+        return nullptr;
     }
 
     // TODO: Make this iterator safe
     void clear() {
+        for(auto &item : data) {
+            gsr::add_widget_to_remove(std::move(item.item));
+        }
         data.clear();
-        remove_queue.clear();
+        num_items_alive = 0;
     }
 
     // Return true from |callback| to continue. This function returns false if |callback| returned false
-    bool for_each(std::function<bool(T &t)> callback) {
+    bool for_each(std::function<bool(T &t)> callback, bool include_dead = false) {
         bool result = true;
         ++for_each_depth;
 
         for(size_t i = 0; i < data.size(); ++i) {
-            result = callback(data[i]);
-            if(!result)
-                break;
+            if(data[i].alive || include_dead) {
+                result = callback(data[i].item);
+                if(!result)
+                    break;
+            }
         }
 
         --for_each_depth;
-        if(for_each_depth == 0) {
-            for(PointerType item_to_remove : remove_queue) {
-                remove_item(item_to_remove);
-            }
-            remove_queue.clear();
-        }
+        if(for_each_depth == 0)
+            remove_dead_items();
 
         return result;
     }
 
     // Return true from |callback| to continue. This function returns false if |callback| returned false
-    bool for_each_reverse(std::function<bool(T &t)> callback) {
+    bool for_each_reverse(std::function<bool(T &t)> callback, bool include_dead = false) {
         bool result = true;
         ++for_each_depth;
 
@@ -80,50 +107,84 @@ public:
             if(i < 0)
                 break;
 
-            result = callback(data[i]);
-            if(!result)
-                break;
+            if(data[i].alive || include_dead) {
+                result = callback(data[i].item);
+                if(!result)
+                    break;
+            }
 
             --i;
         }
 
         --for_each_depth;
-        if(for_each_depth == 0) {
-            for(PointerType item_to_remove : remove_queue) {
-                remove_item(item_to_remove);
-            }
-            remove_queue.clear();
-        }
+        if(for_each_depth == 0)
+            remove_dead_items();
 
         return result;
     }
 
     T& operator[](size_t index) {
-        return data[index];
+        assert(index < data.size());
+        return data[index].item;
     }
 
     const T& operator[](size_t index) const {
-        return data[index];
+        assert(index < data.size());
+        return data[index].item;
     }
 
     size_t size() const {
-        return data.size();
+        return (size_t)num_items_alive;
     }
 
     bool empty() const {
-        return data.empty();
+        return num_items_alive == 0;
+    }
+
+    void replace_item(PointerType item_to_replace, T new_item) {
+        SafeVectorItem<T> *item = get_item(item_to_replace);
+        if(item->alive) {
+            gsr::add_widget_to_remove(std::move(item->item));
+            item->item = std::move(new_item);
+        }
     }
 private:
     void remove_item(PointerType item_to_remove) {
         for(auto it = data.begin(), end = data.end(); it != end; ++it) {
-            if(&*(*it) == item_to_remove) {
+            if(&*(it->item) == item_to_remove) {
+                gsr::add_widget_to_remove(std::move(it->item));
                 data.erase(it);
+                --num_items_alive;
                 return;
             }
         }
     }
+
+    SafeVectorItem<T>* get_item(PointerType item_to_remove) {
+        for(auto &item : data) {
+            if(&*(item.item) == item_to_remove)
+                return &item;
+        }
+        return nullptr;
+    }
+
+    void remove_dead_items() {
+        if(!has_items_to_remove)
+            return;
+
+        for(auto it = data.begin(); it != data.end();) {
+            if(it->alive) {
+                ++it;
+            } else {
+                gsr::add_widget_to_remove(std::move(it->item));
+                it = data.erase(it);
+            }
+        }
+        has_items_to_remove = false;
+    }
 private:
-    std::vector<T> data;
-    std::vector<PointerType> remove_queue;
+    std::vector<SafeVectorItem<T>> data;
     int for_each_depth = 0;
+    int num_items_alive = 0;
+    bool has_items_to_remove = false;
 };

include/Theme.hpp

@@ -42,6 +42,7 @@ namespace gsr {
         mgl::Texture pause_texture;
         mgl::Texture save_texture;
         mgl::Texture screenshot_texture;
+        mgl::Texture trash_texture;
 
         mgl::Texture ps4_home_texture;
         mgl::Texture ps4_options_texture;
@@ -49,6 +50,8 @@ namespace gsr {
         mgl::Texture ps4_dpad_down_texture;
         mgl::Texture ps4_dpad_left_texture;
         mgl::Texture ps4_dpad_right_texture;
+        mgl::Texture ps4_cross_texture;
+        mgl::Texture ps4_triangle_texture;
 
         double double_click_timeout_seconds = 0.4;
 

include/Utils.hpp

@@ -14,6 +14,7 @@ namespace gsr {
     using StringSplitCallback = std::function<bool(std::string_view line)>;
 
     void string_split_char(std::string_view str, char delimiter, StringSplitCallback callback_func);
+    bool starts_with(std::string_view str, const char *substr);
 
     std::string get_home_dir();
     std::string get_config_dir();

include/gui/DropdownButton.hpp

@@ -21,6 +21,7 @@ namespace gsr {
         void set_item_label(const std::string &id, const std::string &new_label);
         void set_item_icon(const std::string &id, mgl::Texture *texture);
         void set_item_description(const std::string &id, const std::string &new_description);
+        void set_item_enabled(const std::string &id, bool enabled);
 
         void set_description(std::string description_text);
         void set_activated(bool activated);
@@ -36,6 +37,7 @@ namespace gsr {
             mgl::Text description_text;
             mgl::Texture *icon_texture = nullptr;
             std::string id;
+            bool enabled = true;
         };
 
         std::vector<Item> items;

include/gui/GlobalSettingsPage.hpp

@@ -22,6 +22,8 @@ namespace gsr {
         NONE,
         REPLAY_START_STOP,
         REPLAY_SAVE,
+        REPLAY_SAVE_1_MIN,
+        REPLAY_SAVE_10_MIN,
         RECORD_START_STOP,
         RECORD_PAUSE_UNPAUSE,
         STREAM_START_STOP,
@@ -56,6 +58,7 @@ namespace gsr {
         std::unique_ptr<RadioButton> create_enable_joystick_hotkeys_button();
         std::unique_ptr<List> create_show_hide_hotkey_options();
         std::unique_ptr<List> create_replay_hotkey_options();
+        std::unique_ptr<List> create_replay_partial_save_hotkey_options();
         std::unique_ptr<List> create_record_hotkey_options();
         std::unique_ptr<List> create_stream_hotkey_options();
         std::unique_ptr<List> create_screenshot_hotkey_options();
@@ -89,6 +92,8 @@ namespace gsr {
 
         Button *turn_replay_on_off_button_ptr = nullptr;
         Button *save_replay_button_ptr = nullptr;
+        Button *save_replay_1_min_button_ptr = nullptr;
+        Button *save_replay_10_min_button_ptr = nullptr;
         Button *start_stop_recording_button_ptr = nullptr;
         Button *pause_unpause_recording_button_ptr = nullptr;
         Button *start_stop_streaming_button_ptr = nullptr;

include/gui/List.hpp

@@ -21,19 +21,20 @@ namespace gsr {
         List(Orientation orientation, Alignment content_alignment = Alignment::START);
         List(const List&) = delete;
         List& operator=(const List&) = delete;
+        virtual ~List() override;
 
         bool on_event(mgl::Event &event, mgl::Window &window, mgl::vec2f offset) override;
         void draw(mgl::Window &window, mgl::vec2f offset) override;
 
-        //void remove_child_widget(Widget *widget) override;
-
         void add_widget(std::unique_ptr<Widget> widget);
         void remove_widget(Widget *widget);
+        void replace_widget(Widget *widget, std::unique_ptr<Widget> new_widget);
         void clear();
         // Return true from |callback| to continue
         void for_each_child_widget(std::function<bool(std::unique_ptr<Widget> &widget)> callback);
         // Returns nullptr if index is invalid
         Widget* get_child_widget_by_index(size_t index) const;
+        size_t get_num_children() const;
 
         void set_spacing(float spacing);
 

include/gui/Page.hpp

@@ -10,13 +10,11 @@ namespace gsr {
         Page() = default;
         Page(const Page&) = delete;
         Page& operator=(const Page&) = delete;
-        virtual ~Page() = default;
+        virtual ~Page() override;
 
         virtual void on_navigate_to_page() {}
         virtual void on_navigate_away_from_page() {}
 
-        //void remove_child_widget(Widget *widget) override;
-
         virtual void add_widget(std::unique_ptr<Widget> widget);
     protected:
         SafeVector<std::unique_ptr<Widget>> widgets;

include/gui/RadioButton.hpp

@@ -23,7 +23,8 @@ namespace gsr {
 
         void add_item(const std::string &text, const std::string &id);
         void set_selected_item(const std::string &id, bool trigger_event = true, bool trigger_event_even_if_selection_not_changed = true);
-        const std::string get_selected_id() const;
+        const std::string& get_selected_id() const;
+        const std::string& get_selected_text() const;
 
         mgl::vec2f get_size() override;
 

include/gui/ScrollablePage.hpp

@@ -12,6 +12,7 @@ namespace gsr {
         ScrollablePage(mgl::vec2f size);
         ScrollablePage(const ScrollablePage&) = delete;
         ScrollablePage& operator=(const ScrollablePage&) = delete;
+        virtual ~ScrollablePage() override;
 
         bool on_event(mgl::Event &event, mgl::Window &window, mgl::vec2f offset) override;
         void draw(mgl::Window &window, mgl::vec2f offset) override;

include/gui/SettingsPage.hpp

@@ -18,6 +18,7 @@ namespace gsr {
     class ScrollablePage;
     class Label;
     class LineSeparator;
+    class Subsection;
 
     class SettingsPage : public StaticPage {
     public:
@@ -54,19 +55,20 @@ namespace gsr {
         std::unique_ptr<Widget> create_change_video_resolution_section();
         std::unique_ptr<Widget> create_capture_target_section();
         std::unique_ptr<ComboBox> create_audio_device_selection_combobox();
-        std::unique_ptr<Button> create_remove_audio_device_button(List *audio_device_list_ptr);
-        std::unique_ptr<List> create_audio_device();
-        std::unique_ptr<Button> create_add_audio_device_button();
-        std::unique_ptr<ComboBox> create_application_audio_selection_combobox();
-        std::unique_ptr<List> create_application_audio();
-        std::unique_ptr<List> create_custom_application_audio();
-        std::unique_ptr<Button> create_add_application_audio_button();
-        std::unique_ptr<Button> create_add_custom_application_audio_button();
-        std::unique_ptr<List> create_add_audio_buttons();
-        std::unique_ptr<List> create_audio_track_track_section();
-        std::unique_ptr<CheckBox> create_split_audio_checkbox();
+        std::unique_ptr<Button> create_remove_audio_device_button(List *audio_input_list_ptr, List *audio_device_list_ptr);
+        std::unique_ptr<List> create_audio_device(List *audio_input_list_ptr);
+        std::unique_ptr<Button> create_add_audio_track_button();
+        std::unique_ptr<Button> create_add_audio_device_button(List *audio_input_list_ptr);
+        std::unique_ptr<ComboBox> create_application_audio_selection_combobox(List *application_audio_row);
+        std::unique_ptr<List> create_application_audio(List *audio_input_list_ptr);
+        std::unique_ptr<List> create_custom_application_audio(List *audio_input_list_ptr);
+        std::unique_ptr<Button> create_add_application_audio_button(List *audio_input_list_ptr);
+        std::unique_ptr<List> create_add_audio_buttons(List *audio_input_list_ptr);
+        std::unique_ptr<List> create_audio_input_section();
         std::unique_ptr<CheckBox> create_application_audio_invert_checkbox();
-        std::unique_ptr<Widget> create_audio_track_section();
+        std::unique_ptr<List> create_audio_track_title_and_remove(Subsection *audio_track_subsection, const char *title);
+        std::unique_ptr<Subsection> create_audio_track_section(Widget *parent_widget);
+        std::unique_ptr<List> create_audio_track_section_list();
         std::unique_ptr<Widget> create_audio_section();
         std::unique_ptr<List> create_video_quality_box();
         std::unique_ptr<List> create_video_bitrate_entry();
@@ -95,11 +97,12 @@ namespace gsr {
         std::unique_ptr<List> create_container_section();
         std::unique_ptr<List> create_replay_time_entry();
         std::unique_ptr<List> create_replay_time();
+        std::unique_ptr<List> create_replay_storage();
         std::unique_ptr<RadioButton> create_start_replay_automatically();
         std::unique_ptr<CheckBox> create_save_replay_in_game_folder();
         std::unique_ptr<CheckBox> create_restart_replay_on_save();
         std::unique_ptr<Label> create_estimated_replay_file_size();
-        void update_estimated_replay_file_size();
+        void update_estimated_replay_file_size(const std::string &replay_storage_type);
         void update_replay_time_text();
         std::unique_ptr<CheckBox> create_save_recording_in_game_folder();
         std::unique_ptr<Label> create_estimated_record_file_size();
@@ -125,6 +128,8 @@ namespace gsr {
         void save_replay();
         void save_record();
         void save_stream();
+
+        void view_changed(bool advanced_view, Subsection *notifications_subsection_ptr);
     private:
         Type type;
         Config &config;
@@ -152,11 +157,6 @@ namespace gsr {
         Entry *framerate_entry_ptr = nullptr;
         Entry *video_bitrate_entry_ptr = nullptr;
         List *video_bitrate_list_ptr = nullptr;
-        List *audio_track_list_ptr = nullptr;
-        Button *add_application_audio_button_ptr = nullptr;
-        Button *add_custom_application_audio_button_ptr = nullptr;
-        CheckBox *split_audio_checkbox_ptr = nullptr;
-        CheckBox *application_audio_invert_checkbox_ptr = nullptr;
         CheckBox *change_video_resolution_checkbox_ptr = nullptr;
         ComboBox *color_range_box_ptr = nullptr;
         ComboBox *video_quality_box_ptr = nullptr;
@@ -187,8 +187,11 @@ namespace gsr {
         Entry *youtube_stream_key_entry_ptr = nullptr;
         Entry *stream_url_entry_ptr = nullptr;
         Entry *replay_time_entry_ptr = nullptr;
+        RadioButton *replay_storage_button_ptr = nullptr;
         Label *replay_time_label_ptr = nullptr;
         RadioButton *turn_on_replay_automatically_mode_ptr = nullptr;
+        Subsection *audio_section_ptr = nullptr;
+        List *audio_track_section_list_ptr = nullptr;
 
         PageStack *page_stack = nullptr;
     };

include/gui/Subsection.hpp

@@ -11,15 +11,20 @@ namespace gsr {
         Subsection(const char *title, std::unique_ptr<Widget> inner_widget, mgl::vec2f size);
         Subsection(const Subsection&) = delete;
         Subsection& operator=(const Subsection&) = delete;
+        virtual ~Subsection() override;
 
         bool on_event(mgl::Event &event, mgl::Window &window, mgl::vec2f offset) override;
         void draw(mgl::Window &window, mgl::vec2f offset) override;
 
         mgl::vec2f get_size() override;
         mgl::vec2f get_inner_size() override;
+
+        Widget* get_inner_widget();
+        void set_bg_color(mgl::Color color);
     private:
         Label label;
         std::unique_ptr<Widget> inner_widget;
         mgl::vec2f size;
+        mgl::Color bg_color{25, 30, 34};
     };
 }

include/gui/Widget.hpp

@@ -1,6 +1,7 @@
 #pragma once
 
 #include <mglpp/system/vec.hpp>
+#include <memory>
 
 namespace mgl {
     class Event;
@@ -31,8 +32,6 @@ namespace gsr {
         virtual void draw(mgl::Window &window, mgl::vec2f offset) = 0;
         virtual void set_position(mgl::vec2f position);
 
-        //virtual void remove_child_widget(Widget *widget) { (void)widget; }
-
         virtual mgl::vec2f get_position() const;
         virtual mgl::vec2f get_size() = 0;
         // This can be different from get_size, for example with ScrollablePage this excludes the margins
@@ -61,4 +60,7 @@ namespace gsr {
 
         bool visible = true;
     };
+
+    void add_widget_to_remove(std::unique_ptr<Widget> widget);
+    void remove_widgets_to_be_removed();
 }

meson.build

@@ -1,4 +1,4 @@
-project('gsr-ui', ['c', 'cpp'], version : '1.3.3', default_options : ['warning_level=2', 'cpp_std=c++17'], subproject_dir : 'depends')
+project('gsr-ui', ['c', 'cpp'], version : '1.6.0', default_options : ['warning_level=2', 'cpp_std=c++17'], subproject_dir : 'depends')
 
 if get_option('buildtype') == 'debug'
     add_project_arguments('-g3', language : ['c', 'cpp'])
@@ -32,6 +32,11 @@ src = [
     'src/gui/GlobalSettingsPage.cpp',
     'src/gui/GsrPage.cpp',
     'src/gui/Subsection.cpp',
+    'src/GlobalHotkeys/GlobalHotkeysX11.cpp',
+    'src/GlobalHotkeys/GlobalHotkeysLinux.cpp',
+    'src/GlobalHotkeys/GlobalHotkeysJoystick.cpp',
+    'src/CursorTracker/CursorTrackerX11.cpp',
+    'src/CursorTracker/CursorTrackerWayland.cpp',
     'src/Utils.cpp',
     'src/WindowUtils.cpp',
     'src/RegionSelector.cpp',
@@ -39,11 +44,6 @@ src = [
     'src/GsrInfo.cpp',
     'src/Process.cpp',
     'src/Overlay.cpp',
-    'src/GlobalHotkeysX11.cpp',
-    'src/GlobalHotkeysLinux.cpp',
-    'src/GlobalHotkeysJoystick.cpp',
-    'src/CursorTrackerX11.cpp',
-    'src/CursorTrackerWayland.cpp',
     'src/AudioPlayer.cpp',
     'src/Hotplug.cpp',
     'src/Rpc.cpp',
@@ -61,7 +61,7 @@ datadir = get_option('datadir')
 gsr_ui_resources_path = join_paths(prefix, datadir, 'gsr-ui')
 
 add_project_arguments('-DGSR_UI_VERSION="' + meson.project_version() + '"', language: ['c', 'cpp'])
-add_project_arguments('-DGSR_FLATPAK_VERSION="5.3.0"', language: ['c', 'cpp'])
+add_project_arguments('-DGSR_FLATPAK_VERSION="5.5.0"', language: ['c', 'cpp'])
 
 executable(
     meson.project_name(),
@@ -75,6 +75,7 @@ executable(
         dependency('xext'),
         dependency('xi'),
         dependency('xcursor'),
+        dependency('xrandr'),
         dependency('libpulse-simple'),
         dependency('libdrm'),
         dependency('wayland-client'),

project.conf

@@ -1,7 +1,7 @@
 [package]
 name = "gsr-ui"
 type = "executable"
-version = "1.3.3"
+version = "1.6.0"
 platforms = ["posix"]
 
 [lang.cpp]
@@ -16,6 +16,7 @@ xfixes = ">=0"
 xext = ">=0"
 xi = ">=0"
 xcursor = ">=1"
+xrandr = ">=0.5"
 libpulse-simple = ">=0"
 libdrm = ">=2"
 wayland-client = ">=1"

src/Config.cpp

@@ -1,7 +1,7 @@
 #include "../include/Config.hpp"
 #include "../include/Utils.hpp"
 #include "../include/GsrInfo.hpp"
-#include "../include/GlobalHotkeys.hpp"
+#include "../include/GlobalHotkeys/GlobalHotkeys.hpp"
 #include <variant>
 #include <limits.h>
 #include <inttypes.h>
@@ -15,6 +15,8 @@
 #define FORMAT_U32 "%" PRIu32
 
 namespace gsr {
+    static const std::string_view add_audio_track_tag = "[add_audio_track]";
+
     static std::vector<mgl::Keyboard::Key> hotkey_modifiers_to_mgl_keys(uint32_t modifiers) {
         std::vector<mgl::Keyboard::Key> result;
         if(modifiers & HOTKEY_MOD_LCTRL)
@@ -82,8 +84,8 @@ namespace gsr {
 
             modifier_str = mgl::Keyboard::key_to_string(modifier_key);
             if(!modifier_side) {
-                string_remove_all(modifier_str, "Left");
-                string_remove_all(modifier_str, "Right");
+                string_remove_all(modifier_str, "Left ");
+                string_remove_all(modifier_str, "Right ");
             }
             result += modifier_str;
         }
@@ -101,6 +103,14 @@ namespace gsr {
         return result;
     }
 
+    bool AudioTrack::operator==(const AudioTrack &other) const {
+        return audio_inputs == other.audio_inputs && application_audio_invert == other.application_audio_invert;
+    }
+
+    bool AudioTrack::operator!=(const AudioTrack &other) const {
+        return !operator==(other);
+    }
+
     Config::Config(const SupportedCaptureOptions &capture_options) {
         const std::string default_videos_save_directory = get_videos_dir();
         const std::string default_pictures_save_directory = get_pictures_dir();
@@ -108,16 +118,16 @@ namespace gsr {
         set_hotkeys_to_default();
 
         streaming_config.record_options.video_quality = "custom";
-        streaming_config.record_options.audio_tracks.push_back("default_output");
+        streaming_config.record_options.audio_tracks_list.push_back({std::vector<std::string>{"default_output"}, false});
         streaming_config.record_options.video_bitrate = 15000;
 
         record_config.save_directory = default_videos_save_directory;
-        record_config.record_options.audio_tracks.push_back("default_output");
+        record_config.record_options.audio_tracks_list.push_back({std::vector<std::string>{"default_output"}, false});
         record_config.record_options.video_bitrate = 45000;
 
         replay_config.record_options.video_quality = "custom";
         replay_config.save_directory = default_videos_save_directory;
-        replay_config.record_options.audio_tracks.push_back("default_output");
+        replay_config.record_options.audio_tracks_list.push_back({std::vector<std::string>{"default_output"}, false});
         replay_config.record_options.video_bitrate = 45000;
 
         screenshot_config.save_directory = default_pictures_save_directory;
@@ -138,6 +148,8 @@ namespace gsr {
 
         replay_config.start_stop_hotkey = {mgl::Keyboard::F10, HOTKEY_MOD_LALT | HOTKEY_MOD_LSHIFT};
         replay_config.save_hotkey = {mgl::Keyboard::F10, HOTKEY_MOD_LALT};
+        replay_config.save_1_min_hotkey = {mgl::Keyboard::F11, HOTKEY_MOD_LALT};
+        replay_config.save_10_min_hotkey = {mgl::Keyboard::F12, HOTKEY_MOD_LALT};
 
         screenshot_config.take_screenshot_hotkey = {mgl::Keyboard::Printscreen, 0};
         screenshot_config.take_screenshot_region_hotkey = {mgl::Keyboard::Printscreen, HOTKEY_MOD_LCTRL};
@@ -152,7 +164,7 @@ namespace gsr {
         return KeyValue{line.substr(0, space_index), line.substr(space_index + 1)};
     }
 
-    using ConfigValue = std::variant<bool*, std::string*, int32_t*, ConfigHotkey*, std::vector<std::string>*>;
+    using ConfigValue = std::variant<bool*, std::string*, int32_t*, ConfigHotkey*, std::vector<std::string>*, std::vector<AudioTrack>*>;
 
     static std::map<std::string_view, ConfigValue> get_config_options(Config &config) {
         return {
@@ -174,6 +186,7 @@ namespace gsr {
             {"streaming.record_options.application_audio_invert", &config.streaming_config.record_options.application_audio_invert},
             {"streaming.record_options.change_video_resolution", &config.streaming_config.record_options.change_video_resolution},
             {"streaming.record_options.audio_track", &config.streaming_config.record_options.audio_tracks},
+            {"streaming.record_options.audio_track_item", &config.streaming_config.record_options.audio_tracks_list},
             {"streaming.record_options.color_range", &config.streaming_config.record_options.color_range},
             {"streaming.record_options.video_quality", &config.streaming_config.record_options.video_quality},
             {"streaming.record_options.codec", &config.streaming_config.record_options.video_codec},
@@ -203,6 +216,7 @@ namespace gsr {
             {"record.record_options.application_audio_invert", &config.record_config.record_options.application_audio_invert},
             {"record.record_options.change_video_resolution", &config.record_config.record_options.change_video_resolution},
             {"record.record_options.audio_track", &config.record_config.record_options.audio_tracks},
+            {"record.record_options.audio_track_item", &config.record_config.record_options.audio_tracks_list},
             {"record.record_options.color_range", &config.record_config.record_options.color_range},
             {"record.record_options.video_quality", &config.record_config.record_options.video_quality},
             {"record.record_options.codec", &config.record_config.record_options.video_codec},
@@ -231,6 +245,7 @@ namespace gsr {
             {"replay.record_options.application_audio_invert", &config.replay_config.record_options.application_audio_invert},
             {"replay.record_options.change_video_resolution", &config.replay_config.record_options.change_video_resolution},
             {"replay.record_options.audio_track", &config.replay_config.record_options.audio_tracks},
+            {"replay.record_options.audio_track_item", &config.replay_config.record_options.audio_tracks_list},
             {"replay.record_options.color_range", &config.replay_config.record_options.color_range},
             {"replay.record_options.video_quality", &config.replay_config.record_options.video_quality},
             {"replay.record_options.codec", &config.replay_config.record_options.video_codec},
@@ -249,8 +264,11 @@ namespace gsr {
             {"replay.save_directory", &config.replay_config.save_directory},
             {"replay.container", &config.replay_config.container},
             {"replay.time", &config.replay_config.replay_time},
+            {"replay.replay_storage", &config.replay_config.replay_storage},
             {"replay.start_stop_hotkey", &config.replay_config.start_stop_hotkey},
             {"replay.save_hotkey", &config.replay_config.save_hotkey},
+            {"replay.save_1_min_hotkey", &config.replay_config.save_1_min_hotkey},
+            {"replay.save_10_min_hotkey", &config.replay_config.save_10_min_hotkey},
 
             {"screenshot.record_area_option", &config.screenshot_config.record_area_option},
             {"screenshot.image_width", &config.screenshot_config.image_width},
@@ -291,6 +309,9 @@ namespace gsr {
             } else if(std::holds_alternative<std::vector<std::string>*>(it.second)) {
                 if(*std::get<std::vector<std::string>*>(it.second) != *std::get<std::vector<std::string>*>(it_other->second))
                     return false;
+            } else if(std::holds_alternative<std::vector<AudioTrack>*>(it.second)) {
+                if(*std::get<std::vector<AudioTrack>*>(it.second) != *std::get<std::vector<AudioTrack>*>(it_other->second))
+                    return false;
             } else {
                 assert(false);
             }
@@ -302,6 +323,17 @@ namespace gsr {
         return !operator==(other);
     }
 
+    static void populate_new_audio_track_from_old(RecordOptions &record_options) {
+        if(record_options.merge_audio_tracks) {
+            record_options.audio_tracks_list.push_back({std::move(record_options.audio_tracks), record_options.application_audio_invert});
+        } else {
+            for(const std::string &audio_input : record_options.audio_tracks) {
+                record_options.audio_tracks_list.push_back({std::vector<std::string>{audio_input}, record_options.application_audio_invert});
+            }
+        }
+        record_options.audio_tracks.clear();
+    }
+
     std::optional<Config> read_config(const SupportedCaptureOptions &capture_options) {
         std::optional<Config> config;
 
@@ -313,10 +345,15 @@ namespace gsr {
         }
 
         config = Config(capture_options);
+
         config->streaming_config.record_options.audio_tracks.clear();
         config->record_config.record_options.audio_tracks.clear();
         config->replay_config.record_options.audio_tracks.clear();
 
+        config->streaming_config.record_options.audio_tracks_list.clear();
+        config->record_config.record_options.audio_tracks_list.clear();
+        config->replay_config.record_options.audio_tracks_list.clear();
+
         auto config_options = get_config_options(config.value());
 
         string_split_char(file_content, '\n', [&](std::string_view line) {
@@ -355,6 +392,23 @@ namespace gsr {
             } else if(std::holds_alternative<std::vector<std::string>*>(it->second)) {
                 std::string array_value(key_value->value);
                 std::get<std::vector<std::string>*>(it->second)->push_back(std::move(array_value));
+            } else if(std::holds_alternative<std::vector<AudioTrack>*>(it->second)) {
+                const size_t space_index = key_value->value.find(' ');
+                if(space_index == std::string_view::npos) {
+                    fprintf(stderr, "Warning: Invalid config option value for %.*s\n", (int)key_value->key.size(), key_value->key.data());
+                    return true;
+                }
+
+                const bool application_audio_invert = key_value->value.substr(0, space_index) == "true";
+                const std::string_view audio_input = key_value->value.substr(space_index + 1);
+                std::vector<AudioTrack> &audio_tracks = *std::get<std::vector<AudioTrack>*>(it->second);
+
+                if(audio_input == add_audio_track_tag) {
+                    audio_tracks.push_back({std::vector<std::string>{}, application_audio_invert});
+                } else if(!audio_tracks.empty()) {
+                    audio_tracks.back().application_audio_invert = application_audio_invert;
+                    audio_tracks.back().audio_inputs.emplace_back(audio_input);
+                }
             } else {
                 assert(false);
             }
@@ -362,11 +416,16 @@ namespace gsr {
             return true;
         });
 
-        if(config->main_config.config_file_version != GSR_CONFIG_FILE_VERSION) {
-            fprintf(stderr, "Info: the config file is outdated, resetting it\n");
-            config = std::nullopt;
+        if(config->main_config.config_file_version == 1) {
+            populate_new_audio_track_from_old(config->streaming_config.record_options);
+            populate_new_audio_track_from_old(config->record_config.record_options);
+            populate_new_audio_track_from_old(config->replay_config.record_options);
         }
 
+        config->streaming_config.record_options.audio_tracks.clear();
+        config->record_config.record_options.audio_tracks.clear();
+        config->replay_config.record_options.audio_tracks.clear();
+
         return config;
     }
 
@@ -402,9 +461,17 @@ namespace gsr {
                 const ConfigHotkey *config_hotkey = std::get<ConfigHotkey*>(it.second);
                     fprintf(file, "%.*s " FORMAT_I64 " " FORMAT_U32 "\n", (int)it.first.size(), it.first.data(), config_hotkey->key, config_hotkey->modifiers);
             } else if(std::holds_alternative<std::vector<std::string>*>(it.second)) {
-                std::vector<std::string> *array = std::get<std::vector<std::string>*>(it.second);
-                for(const std::string &value : *array) {
-                    fprintf(file, "%.*s %s\n", (int)it.first.size(), it.first.data(), value.c_str());
+                std::vector<std::string> *audio_inputs = std::get<std::vector<std::string>*>(it.second);
+                for(const std::string &audio_input : *audio_inputs) {
+                    fprintf(file, "%.*s %s\n", (int)it.first.size(), it.first.data(), audio_input.c_str());
+                }
+            } else if(std::holds_alternative<std::vector<AudioTrack>*>(it.second)) {
+                std::vector<AudioTrack> *audio_tracks = std::get<std::vector<AudioTrack>*>(it.second);
+                for(const AudioTrack &audio_track : *audio_tracks) {
+                    fprintf(file, "%.*s %s %.*s\n", (int)it.first.size(), it.first.data(), audio_track.application_audio_invert ? "true" : "false", (int)add_audio_track_tag.size(), add_audio_track_tag.data());
+                    for(const std::string &audio_input : audio_track.audio_inputs) {
+                        fprintf(file, "%.*s %s %s\n", (int)it.first.size(), it.first.data(), audio_track.application_audio_invert ? "true" : "false", audio_input.c_str());
+                    }
                 }
             } else {
                 assert(false);

src/CursorTracker/CursorTrackerWayland.cpp

@@ -1,4 +1,4 @@
-#include "../include/CursorTrackerWayland.hpp"
+#include "../../include/CursorTracker/CursorTrackerWayland.hpp"
 #include <string.h>
 #include <unistd.h>
 #include <fcntl.h>
@@ -27,19 +27,20 @@ namespace gsr {
     typedef struct {
         uint64_t crtc_id;
         mgl::vec2i size;
+        bool vrr_enabled;
     } drm_connector;
 
     typedef struct {
         drm_connector connectors[MAX_CONNECTORS];
         int num_connectors;
+        bool has_any_crtc_with_vrr_enabled;
     } drm_connectors;
 
     /* Returns plane_property_mask */
-    static uint32_t plane_get_properties(int drm_fd, uint32_t plane_id, int *crtc_x, int *crtc_y, int *crtc_id, bool *is_cursor) {
+    static uint32_t plane_get_properties(int drm_fd, uint32_t plane_id, int *crtc_x, int *crtc_y, int *crtc_id) {
         *crtc_x = 0;
         *crtc_y = 0;
         *crtc_id = 0;
-        *is_cursor = false;
 
         uint32_t property_mask = 0;
 
@@ -80,8 +81,8 @@ namespace gsr {
         return property_mask;
     }
 
-    static bool connector_get_property_by_name(int drm_fd, drmModeConnectorPtr props, const char *name, uint64_t *result) {
-        for(int i = 0; i < props->count_props; ++i) {
+    static bool get_drm_property_by_name(int drm_fd, drmModeObjectPropertiesPtr props, const char *name, uint64_t *result) {
+        for(uint32_t i = 0; i < props->count_props; ++i) {
             drmModePropertyPtr prop = drmModeGetProperty(drm_fd, props->props[i]);
             if(!prop)
                 continue;
@@ -96,6 +97,14 @@ namespace gsr {
         return false;
     }
 
+    static bool connector_get_property_by_name(int drm_fd, drmModeConnectorPtr props, const char *name, uint64_t *result) {
+        drmModeObjectProperties properties;
+        properties.count_props = (uint32_t)props->count_props;
+        properties.props = props->props;
+        properties.prop_values = props->prop_values;
+        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)
@@ -325,7 +334,7 @@ namespace gsr {
     };
 
     /* Returns nullptr if not found */
-    static const drm_connector* get_drm_connector_by_crtc_id(const drm_connectors *connectors, uint32_t crtc_id) {
+    static drm_connector* get_drm_connector_by_crtc_id(drm_connectors *connectors, uint32_t crtc_id) {
         for(int i = 0; i < connectors->num_connectors; ++i) {
             if(connectors->connectors[i].crtc_id == crtc_id)
                 return &connectors->connectors[i];
@@ -335,6 +344,8 @@ namespace gsr {
 
     static void get_drm_connectors(int drm_fd, drm_connectors *drm_connectors) {
         drm_connectors->num_connectors = 0;
+        drm_connectors->has_any_crtc_with_vrr_enabled = false;
+
         drmModeResPtr resources = drmModeGetResources(drm_fd);
         if(!resources)
             return;
@@ -350,23 +361,59 @@ namespace gsr {
             uint64_t crtc_id = 0;
             connector_get_property_by_name(drm_fd, connector, "CRTC_ID", &crtc_id);
             if(crtc_id == 0)
-                goto next;
+                goto next_connector;
 
             crtc = drmModeGetCrtc(drm_fd, crtc_id);
             if(!crtc)
-                goto next;
+                goto next_connector;
 
             drm_connectors->connectors[drm_connectors->num_connectors].crtc_id = crtc_id;
             drm_connectors->connectors[drm_connectors->num_connectors].size = mgl::vec2i{(int)crtc->width, (int)crtc->height};
+            drm_connectors->connectors[drm_connectors->num_connectors].vrr_enabled = false;
             ++drm_connectors->num_connectors;
 
-            next:
+            next_connector:
             if(crtc)
                 drmModeFreeCrtc(crtc);
 
             if(connector)
                 drmModeFreeConnector(connector);
         }
+
+        for(int i = 0; i < resources->count_crtcs; ++i) {
+            drmModeCrtcPtr crtc = nullptr;
+            drmModeObjectPropertiesPtr properties = nullptr;
+            uint64_t vrr_enabled = 0;
+            drm_connector *connector = nullptr;
+
+            crtc = drmModeGetCrtc(drm_fd, resources->crtcs[i]);
+            if(!crtc)
+                continue;
+
+            properties = drmModeObjectGetProperties(drm_fd, crtc->crtc_id, DRM_MODE_OBJECT_CRTC);
+            if(!properties)
+                goto next_crtc;
+
+            if(!get_drm_property_by_name(drm_fd, properties, "VRR_ENABLED", &vrr_enabled))
+                goto next_crtc;
+
+            connector = get_drm_connector_by_crtc_id(drm_connectors, crtc->crtc_id);
+            if(!connector)
+                goto next_crtc;
+
+            if(vrr_enabled) {
+                connector->vrr_enabled = true;
+                drm_connectors->has_any_crtc_with_vrr_enabled = true;
+            }
+
+            next_crtc:
+            if(properties)
+                drmModeFreeObjectProperties(properties);
+
+            if(crtc)
+                drmModeFreeCrtc(crtc);
+        }
+
         drmModeFreeResources(resources);
     }
 
@@ -392,19 +439,20 @@ namespace gsr {
 
         drm_connectors connectors;
         connectors.num_connectors = 0;
+        connectors.has_any_crtc_with_vrr_enabled = false;
         get_drm_connectors(drm_fd, &connectors);
 
         drmModePlaneResPtr planes = drmModeGetPlaneResources(drm_fd);
         if(!planes)
             return;
 
+        bool found_cursor = false;
         for(uint32_t i = 0; i < planes->count_planes; ++i) {
             drmModePlanePtr plane = nullptr;
             const drm_connector *connector = nullptr;
             int crtc_x = 0;
             int crtc_y = 0;
             int crtc_id = 0;
-            bool is_cursor = false;
             uint32_t property_mask = 0;
 
             plane = drmModeGetPlane(drm_fd, planes->planes[i]);
@@ -414,7 +462,7 @@ namespace gsr {
             if(!plane->fb_id)
                 goto next;
 
-            property_mask = plane_get_properties(drm_fd, planes->planes[i], &crtc_x, &crtc_y, &crtc_id, &is_cursor);
+            property_mask = plane_get_properties(drm_fd, planes->planes[i], &crtc_x, &crtc_y, &crtc_id);
             if(property_mask != plane_property_all || crtc_id <= 0)
                 goto next;
 
@@ -426,6 +474,7 @@ namespace gsr {
                 latest_cursor_position.x = crtc_x;
                 latest_cursor_position.y = crtc_y;
                 latest_crtc_id = crtc_id;
+                found_cursor = true;
                 drmModeFreePlane(plane);
                 break;
             }
@@ -434,6 +483,11 @@ namespace gsr {
             drmModeFreePlane(plane);
         }
 
+        // On kde plasma wayland (and possibly other wayland compositors) it uses a software cursor only for the monitors with vrr enabled.
+        // In that case we cant know the cursor location and we instead want to fallback to getting focused monitor by using the hack of creating a window and getting the position.
+        if(!found_cursor && latest_crtc_id > 0 && connectors.has_any_crtc_with_vrr_enabled)
+            latest_crtc_id = -1;
+
         drmModeFreePlaneResources(planes);
     }
 

src/CursorTracker/CursorTrackerX11.cpp

@@ -1,5 +1,5 @@
-#include "../include/CursorTrackerX11.hpp"
-#include "../include/WindowUtils.hpp"
+#include "../../include/CursorTracker/CursorTrackerX11.hpp"
+#include "../../include/WindowUtils.hpp"
 
 namespace gsr {
     CursorTrackerX11::CursorTrackerX11(Display *dpy) : dpy(dpy) {

src/GlobalHotkeys/GlobalHotkeysJoystick.cpp

@@ -1,4 +1,4 @@
-#include "../include/GlobalHotkeysJoystick.hpp"
+#include "../../include/GlobalHotkeys/GlobalHotkeysJoystick.hpp"
 #include <string.h>
 #include <errno.h>
 #include <fcntl.h>
@@ -7,6 +7,8 @@
 
 namespace gsr {
     static constexpr int button_pressed = 1;
+    static constexpr int cross_button = 0;
+    static constexpr int triangle_button = 2;
     static constexpr int options_button = 9;
     static constexpr int playstation_button = 10;
     static constexpr int axis_up_down = 7;
@@ -104,6 +106,20 @@ namespace gsr {
                 it->second("save_replay");
         }
 
+        if(save_1_min_replay) {
+            save_1_min_replay = false;
+            auto it = bound_actions_by_id.find("save_1_min_replay");
+            if(it != bound_actions_by_id.end())
+                it->second("save_1_min_replay");
+        }
+
+        if(save_10_min_replay) {
+            save_10_min_replay = false;
+            auto it = bound_actions_by_id.find("save_10_min_replay");
+            if(it != bound_actions_by_id.end())
+                it->second("save_10_min_replay");
+        }
+
         if(take_screenshot) {
             take_screenshot = false;
             auto it = bound_actions_by_id.find("take_screenshot");
@@ -186,10 +202,27 @@ namespace gsr {
             return;
 
         if((event.type & JS_EVENT_BUTTON) == JS_EVENT_BUTTON) {
-            if(event.number == playstation_button)
-                playstation_button_pressed = event.value == button_pressed;
-            else if(playstation_button_pressed && event.number == options_button && event.value == button_pressed)
-                toggle_show = true;
+            switch(event.number) {
+                case playstation_button: {
+                    playstation_button_pressed = event.value == button_pressed;
+                    break;
+                }
+                case options_button: {
+                    if(playstation_button_pressed && event.value == button_pressed)
+                        toggle_show = true;
+                    break;
+                }
+                case cross_button: {
+                    if(playstation_button_pressed && event.value == button_pressed)
+                        save_1_min_replay = true;
+                    break;
+                }
+                case triangle_button: {
+                    if(playstation_button_pressed && event.value == button_pressed)
+                        save_10_min_replay = true;
+                    break;
+                }
+            }
         } else if((event.type & JS_EVENT_AXIS) == JS_EVENT_AXIS && playstation_button_pressed) {
             const int trigger_threshold = 16383;
             const bool prev_up_pressed = up_pressed;

src/GlobalHotkeys/GlobalHotkeysLinux.cpp

@@ -1,5 +1,4 @@
-#include "../include/GlobalHotkeysLinux.hpp"
-#include <signal.h>
+#include "../../include/GlobalHotkeys/GlobalHotkeysLinux.hpp"
 #include <sys/wait.h>
 #include <fcntl.h>
 #include <limits.h>
@@ -71,22 +70,42 @@ namespace gsr {
     }
 
     GlobalHotkeysLinux::~GlobalHotkeysLinux() {
-        for(int i = 0; i < 2; ++i) {
-            if(read_pipes[i] > 0)
-                close(read_pipes[i]);
-
-            if(write_pipes[i] > 0)
-                close(write_pipes[i]);
+        if(write_pipes[PIPE_WRITE] > 0) {
+            char command[32];
+            const int command_size = snprintf(command, sizeof(command), "exit\n");
+            if(write(write_pipes[PIPE_WRITE], command, command_size) != command_size) {
+                fprintf(stderr, "Error: GlobalHotkeysLinux::~GlobalHotkeysLinux: failed to write command to gsr-global-hotkeys, error: %s\n", strerror(errno));
+                close_fds();
+            }
+        } else {
+            close_fds();
         }
 
-        if(read_file)
-            fclose(read_file);
-
         if(process_id > 0) {
-            kill(process_id, SIGKILL);
             int status;
             waitpid(process_id, &status, 0);
         }
+
+        close_fds();
+    }
+
+    void GlobalHotkeysLinux::close_fds() {
+        for(int i = 0; i < 2; ++i) {
+            if(read_pipes[i] > 0) {
+                close(read_pipes[i]);
+                read_pipes[i] = -1;
+            }
+
+            if(write_pipes[i] > 0) {
+                close(write_pipes[i]);
+                write_pipes[i] = -1;
+            }
+        }
+
+        if(read_file) {
+            fclose(read_file);
+            read_file = nullptr;
+        }
     }
 
     bool GlobalHotkeysLinux::start() {

src/GlobalHotkeys/GlobalHotkeysX11.cpp

@@ -1,4 +1,4 @@
-#include "../include/GlobalHotkeysX11.hpp"
+#include "../../include/GlobalHotkeys/GlobalHotkeysX11.hpp"
 #include <X11/keysym.h>
 #include <mglpp/window/Event.hpp>
 #include <assert.h>

src/GsrInfo.cpp

@@ -175,11 +175,6 @@ namespace gsr {
         CAPTURE_OPTIONS
     };
 
-    static bool starts_with(std::string_view str, const char *substr) {
-        size_t len = strlen(substr);
-        return str.size() >= len && memcmp(str.data(), substr, len) == 0;
-    }
-
     GsrInfoExitStatus get_gpu_screen_recorder_info(GsrInfo *gsr_info) {
         *gsr_info = GsrInfo{};
 

src/Process.cpp

@@ -130,8 +130,6 @@ namespace gsr {
                 exit_status = -1;
                 break;
             }
-
-            buffer[bytes_read] = '\0';
             result.append(buffer, bytes_read);
         }
 

src/Theme.cpp

@@ -75,7 +75,7 @@ namespace gsr {
         if(!theme->folder_texture.load_from_file((resources_path + "images/folder.png").c_str()))
             goto error;
 
-        if(!theme->up_arrow_texture.load_from_file((resources_path + "images/up_arrow.png").c_str()))
+        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()))
@@ -93,10 +93,10 @@ namespace gsr {
         if(!theme->logo_texture.load_from_file((resources_path + "images/gpu_screen_recorder_logo.png").c_str()))
             goto error;
 
-        if(!theme->checkbox_circle_texture.load_from_file((resources_path + "images/checkbox_circle.png").c_str()))
+        if(!theme->checkbox_circle_texture.load_from_file((resources_path + "images/checkbox_circle.png").c_str(), mgl::Texture::LoadOptions{false, false, MGL_TEXTURE_SCALE_LINEAR_MIPMAP}))
             goto error;
 
-        if(!theme->checkbox_background_texture.load_from_file((resources_path + "images/checkbox_background.png").c_str()))
+        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()))
@@ -114,22 +114,31 @@ namespace gsr {
         if(!theme->screenshot_texture.load_from_file((resources_path + "images/screenshot.png").c_str()))
             goto error;
 
-        if(!theme->ps4_home_texture.load_from_file((resources_path + "images/ps4_home.png").c_str(), mgl::Texture::LoadOptions{false, false, true}))
+        if(!theme->trash_texture.load_from_file((resources_path + "images/trash.png").c_str(), mgl::Texture::LoadOptions{false, false, MGL_TEXTURE_SCALE_LINEAR_MIPMAP}))
             goto error;
 
-        if(!theme->ps4_options_texture.load_from_file((resources_path + "images/ps4_options.png").c_str(), mgl::Texture::LoadOptions{false, false, true}))
+        if(!theme->ps4_home_texture.load_from_file((resources_path + "images/ps4_home.png").c_str(), mgl::Texture::LoadOptions{false, false, MGL_TEXTURE_SCALE_LINEAR_MIPMAP}))
             goto error;
 
-        if(!theme->ps4_dpad_up_texture.load_from_file((resources_path + "images/ps4_dpad_up.png").c_str(), mgl::Texture::LoadOptions{false, false, true}))
+        if(!theme->ps4_options_texture.load_from_file((resources_path + "images/ps4_options.png").c_str(), mgl::Texture::LoadOptions{false, false, MGL_TEXTURE_SCALE_LINEAR_MIPMAP}))
             goto error;
 
-        if(!theme->ps4_dpad_down_texture.load_from_file((resources_path + "images/ps4_dpad_down.png").c_str(), mgl::Texture::LoadOptions{false, false, true}))
+        if(!theme->ps4_dpad_up_texture.load_from_file((resources_path + "images/ps4_dpad_up.png").c_str(), mgl::Texture::LoadOptions{false, false, MGL_TEXTURE_SCALE_LINEAR_MIPMAP}))
+            goto error;
+
+        if(!theme->ps4_dpad_down_texture.load_from_file((resources_path + "images/ps4_dpad_down.png").c_str(), mgl::Texture::LoadOptions{false, false, MGL_TEXTURE_SCALE_LINEAR_MIPMAP}))
             goto error;
         
-        if(!theme->ps4_dpad_left_texture.load_from_file((resources_path + "images/ps4_dpad_left.png").c_str(), mgl::Texture::LoadOptions{false, false, true}))
+        if(!theme->ps4_dpad_left_texture.load_from_file((resources_path + "images/ps4_dpad_left.png").c_str(), mgl::Texture::LoadOptions{false, false, MGL_TEXTURE_SCALE_LINEAR_MIPMAP}))
             goto error;
 
-        if(!theme->ps4_dpad_right_texture.load_from_file((resources_path + "images/ps4_dpad_right.png").c_str(), mgl::Texture::LoadOptions{false, false, true}))
+        if(!theme->ps4_dpad_right_texture.load_from_file((resources_path + "images/ps4_dpad_right.png").c_str(), mgl::Texture::LoadOptions{false, false, MGL_TEXTURE_SCALE_LINEAR_MIPMAP}))
+            goto error;
+
+        if(!theme->ps4_cross_texture.load_from_file((resources_path + "images/ps4_cross.png").c_str(), mgl::Texture::LoadOptions{false, false, MGL_TEXTURE_SCALE_LINEAR_MIPMAP}))
+            goto error;
+
+        if(!theme->ps4_triangle_texture.load_from_file((resources_path + "images/ps4_triangle.png").c_str(), mgl::Texture::LoadOptions{false, false, MGL_TEXTURE_SCALE_LINEAR_MIPMAP}))
             goto error;
 
         return true;

src/Utils.cpp

@@ -22,6 +22,11 @@ namespace gsr {
         }
     }
 
+    bool starts_with(std::string_view str, const char *substr) {
+        size_t len = strlen(substr);
+        return str.size() >= len && memcmp(str.data(), substr, len) == 0;
+    }
+
     std::string get_home_dir() {
         const char *home_dir = getenv("HOME");
         if(!home_dir) {

src/WindowUtils.cpp

@@ -5,6 +5,7 @@
 #include <X11/extensions/XInput2.h>
 #include <X11/extensions/Xfixes.h>
 #include <X11/extensions/shapeconst.h>
+#include <X11/extensions/Xrandr.h>
 
 #include <mglpp/system/Utf8.hpp>
 
@@ -518,14 +519,21 @@ namespace gsr {
         return XGetSelectionOwner(dpy, prop_atom) != None;
     }
 
-    static void get_monitors_callback(const mgl_monitor *monitor, void *userdata) {
-        std::vector<Monitor> *monitors = (std::vector<Monitor>*)userdata;
-        monitors->push_back({mgl::vec2i(monitor->pos.x, monitor->pos.y), mgl::vec2i(monitor->size.x, monitor->size.y), std::string(monitor->name)});
-    }
-
     std::vector<Monitor> get_monitors(Display *dpy) {
         std::vector<Monitor> monitors;
-        mgl_for_each_active_monitor_output(dpy, get_monitors_callback, &monitors);
+        int nmonitors = 0;
+        XRRMonitorInfo *monitor_info = XRRGetMonitors(dpy, DefaultRootWindow(dpy), True, &nmonitors);
+        if(monitor_info) {
+            for(int i = 0; i < nmonitors; ++i) {
+                char *monitor_name = XGetAtomName(dpy, monitor_info[i].name);
+                if(!monitor_name)
+                    continue;
+
+                monitors.push_back({mgl::vec2i(monitor_info[i].x, monitor_info[i].y), mgl::vec2i(monitor_info[i].width, monitor_info[i].height), std::string(monitor_name)});
+                XFree(monitor_name);
+            }
+            XRRFreeMonitors(monitor_info);
+        }
         return monitors;
     }
 

src/gui/Button.cpp

@@ -63,7 +63,7 @@ namespace gsr {
             window.draw(sprite);
 
             const int padding_icon_right = padding_right_icon_scale * get_button_height();
-            text.set_position((sprite.get_position() + mgl::vec2f(sprite.get_size().x + padding_icon_right, sprite.get_size().y * 0.5f - text.get_bounds().size.y * 0.5f)).floor());
+            text.set_position((sprite.get_position() + mgl::vec2f(sprite.get_size().x + padding_icon_right, sprite.get_size().y * 0.5f - text.get_bounds().size.y * 0.52f)).floor());
             window.draw(text);
         } else {
             text.set_position((draw_pos + item_size * 0.5f - text.get_bounds().size * 0.5f).floor());

src/gui/DropdownButton.cpp

@@ -110,6 +110,14 @@ namespace gsr {
             window.draw(rect);
         }
 
+        if(activated) {
+            description.set_color(get_color_theme().tint_color);
+            icon_sprite.set_color(get_color_theme().tint_color);
+        } else {
+            description.set_color(mgl::Color(150, 150, 150));
+            icon_sprite.set_color(mgl::Color(255, 255, 255));
+        }
+
         const int text_margin = size.y * 0.085;
 
         const auto title_bounds = title.get_bounds();
@@ -148,7 +156,7 @@ namespace gsr {
                     window.draw(separator);
                 }
 
-                if(mouse_inside_item == -1) {
+                if(mouse_inside_item == -1 && item.enabled) {
                     const bool inside = mgl::FloatRect(item_position, item_size).contains({ (float)mouse_pos.x, (float)mouse_pos.y });
                     if(inside) {
                         draw_rectangle_outline(window, item_position, item_size, get_color_theme().tint_color, border_size);
@@ -161,16 +169,18 @@ namespace gsr {
                     mgl::Sprite icon(item.icon_texture);
                     icon.set_height((int)(item_size.y * 0.4f));
                     icon.set_position((item_position + mgl::vec2f(padding_left, item_size.y * 0.5f - icon.get_size().y * 0.5f)).floor());
+                    icon.set_color(item.enabled ? mgl::Color(255, 255, 255, 255) : mgl::Color(255, 255, 255, 80));
                     window.draw(icon);
                     icon_offset = icon.get_size().x + icon_spacing;
                 }
 
                 item.text.set_position((item_position + mgl::vec2f(padding_left + icon_offset, item_size.y * 0.5f - text_bounds.size.y * 0.5f)).floor());
+                item.text.set_color(item.enabled ? mgl::Color(255, 255, 255, 255) : mgl::Color(255, 255, 255, 80));
                 window.draw(item.text);
 
                 const auto description_bounds = item.description_text.get_bounds();
                 item.description_text.set_position((item_position + mgl::vec2f(item_size.x - description_bounds.size.x - padding_right, item_size.y * 0.5f - description_bounds.size.y * 0.5f)).floor());
-                item.description_text.set_color(mgl::Color(255, 255, 255, 120));
+                item.description_text.set_color(item.enabled ? mgl::Color(255, 255, 255, 120) : mgl::Color(255, 255, 255, 40));
                 window.draw(item.description_text);
 
                 item_position.y += item_size.y;
@@ -179,6 +189,10 @@ namespace gsr {
     }
 
     void DropdownButton::add_item(const std::string &text, const std::string &id, const std::string &description) {
+        for(auto &item : items) {
+            if(item.id == id)
+                return;
+        }
         items.push_back({mgl::Text(text, *title_font), mgl::Text(description, *description_font), nullptr, id});
         dirty = true;
     }
@@ -210,6 +224,15 @@ namespace gsr {
         }
     }
 
+    void DropdownButton::set_item_enabled(const std::string &id, bool enabled) {
+        for(auto &item : items) {
+            if(item.id == id) {
+                item.enabled = enabled;
+                return;
+            }
+        }
+    }
+
     void DropdownButton::set_description(std::string description_text) {
         description.set_string(std::move(description_text));
     }
@@ -219,14 +242,6 @@ namespace gsr {
             return;
 
         this->activated = activated;
-
-        if(activated) {
-            description.set_color(get_color_theme().tint_color);
-            icon_sprite.set_color(get_color_theme().tint_color);
-        } else {
-            description.set_color(mgl::Color(150, 150, 150));
-            icon_sprite.set_color(mgl::Color(255, 255, 255));
-        }
     }
 
     void DropdownButton::update_if_dirty() {

src/gui/GlobalSettingsPage.cpp

@@ -1,7 +1,6 @@
 #include "../../include/gui/GlobalSettingsPage.hpp"
 
 #include "../../include/Overlay.hpp"
-#include "../../include/GlobalHotkeys.hpp"
 #include "../../include/Theme.hpp"
 #include "../../include/Process.hpp"
 #include "../../include/gui/GsrPage.hpp"
@@ -149,7 +148,7 @@ namespace gsr {
         tint_color_radio_button_ptr = tint_color_radio_button.get();
         tint_color_radio_button->add_item("Red", "amd");
         tint_color_radio_button->add_item("Green", "nvidia");
-        tint_color_radio_button->add_item("blue", "intel");
+        tint_color_radio_button->add_item("Blue", "intel");
         tint_color_radio_button->on_selection_changed = [](const std::string&, const std::string &id) {
             if(id == "amd")
                 get_color_theme().tint_color = mgl::Color(221, 0, 49);
@@ -256,6 +255,30 @@ namespace gsr {
         return list;
     }
 
+    std::unique_ptr<List> GlobalSettingsPage::create_replay_partial_save_hotkey_options() {
+        auto list = std::make_unique<List>(List::Orientation::HORIZONTAL, List::Alignment::CENTER);
+
+        list->add_widget(std::make_unique<Label>(&get_theme().body_font, "Save 1 minute replay:", get_color_theme().text_color));
+        auto save_replay_1_min_button = std::make_unique<Button>(&get_theme().body_font, "", mgl::vec2f(0.0f, 0.0f), mgl::Color(0, 0, 0, 120));
+        save_replay_1_min_button_ptr = save_replay_1_min_button.get();
+        list->add_widget(std::move(save_replay_1_min_button));
+
+        list->add_widget(std::make_unique<Label>(&get_theme().body_font, "Save 10 minute replay:", get_color_theme().text_color));
+        auto save_replay_10_min_button = std::make_unique<Button>(&get_theme().body_font, "", mgl::vec2f(0.0f, 0.0f), mgl::Color(0, 0, 0, 120));
+        save_replay_10_min_button_ptr = save_replay_10_min_button.get();
+        list->add_widget(std::move(save_replay_10_min_button));
+
+        save_replay_1_min_button_ptr->on_click = [this] {
+            configure_hotkey_start(ConfigureHotkeyType::REPLAY_SAVE_1_MIN);
+        };
+
+        save_replay_10_min_button_ptr->on_click = [this] {
+            configure_hotkey_start(ConfigureHotkeyType::REPLAY_SAVE_10_MIN);
+        };
+
+        return list;
+    }
+
     std::unique_ptr<List> GlobalSettingsPage::create_record_hotkey_options() {
         auto list = std::make_unique<List>(List::Orientation::HORIZONTAL, List::Alignment::CENTER);
 
@@ -335,6 +358,8 @@ namespace gsr {
             config.record_config.pause_unpause_hotkey = {mgl::Keyboard::Unknown, 0};
             config.replay_config.start_stop_hotkey = {mgl::Keyboard::Unknown, 0};
             config.replay_config.save_hotkey = {mgl::Keyboard::Unknown, 0};
+            config.replay_config.save_1_min_hotkey = {mgl::Keyboard::Unknown, 0};
+            config.replay_config.save_10_min_hotkey = {mgl::Keyboard::Unknown, 0};
             config.screenshot_config.take_screenshot_hotkey = {mgl::Keyboard::Unknown, 0};
             config.screenshot_config.take_screenshot_region_hotkey = {mgl::Keyboard::Unknown, 0};
             config.main_config.show_hide_hotkey = {mgl::Keyboard::Unknown, 0};
@@ -374,6 +399,7 @@ namespace gsr {
         list_ptr->add_widget(std::make_unique<LineSeparator>(LineSeparator::Orientation::HORIZONTAL, subsection->get_inner_size().x));
         list_ptr->add_widget(create_show_hide_hotkey_options());
         list_ptr->add_widget(create_replay_hotkey_options());
+        list_ptr->add_widget(create_replay_partial_save_hotkey_options());
         list_ptr->add_widget(create_record_hotkey_options());
         list_ptr->add_widget(create_stream_hotkey_options());
         list_ptr->add_widget(create_screenshot_hotkey_options());
@@ -393,6 +419,8 @@ namespace gsr {
         list_ptr->add_widget(create_joystick_hotkey_text(&get_theme().ps4_home_texture, &get_theme().ps4_options_texture, get_theme().body_font.get_character_size(), "to show/hide the UI"));
         list_ptr->add_widget(create_joystick_hotkey_text(&get_theme().ps4_home_texture, &get_theme().ps4_dpad_up_texture, get_theme().body_font.get_character_size(), "to take a screenshot"));
         list_ptr->add_widget(create_joystick_hotkey_text(&get_theme().ps4_home_texture, &get_theme().ps4_dpad_down_texture, get_theme().body_font.get_character_size(), "to save a replay"));
+        list_ptr->add_widget(create_joystick_hotkey_text(&get_theme().ps4_home_texture, &get_theme().ps4_cross_texture, get_theme().body_font.get_character_size(), "to save a 1 minute replay"));
+        list_ptr->add_widget(create_joystick_hotkey_text(&get_theme().ps4_home_texture, &get_theme().ps4_triangle_texture, get_theme().body_font.get_character_size(), "to save a 10 minute replay"));
         list_ptr->add_widget(create_joystick_hotkey_text(&get_theme().ps4_home_texture, &get_theme().ps4_dpad_left_texture, get_theme().body_font.get_character_size(), "to start/stop recording"));
         list_ptr->add_widget(create_joystick_hotkey_text(&get_theme().ps4_home_texture, &get_theme().ps4_dpad_right_texture, get_theme().body_font.get_character_size(), "to turn replay on/off"));
         return subsection;
@@ -490,6 +518,8 @@ namespace gsr {
     void GlobalSettingsPage::load_hotkeys() {
         turn_replay_on_off_button_ptr->set_text(config.replay_config.start_stop_hotkey.to_string());
         save_replay_button_ptr->set_text(config.replay_config.save_hotkey.to_string());
+        save_replay_1_min_button_ptr->set_text(config.replay_config.save_1_min_hotkey.to_string());
+        save_replay_10_min_button_ptr->set_text(config.replay_config.save_10_min_hotkey.to_string());
 
         start_stop_recording_button_ptr->set_text(config.record_config.start_stop_hotkey.to_string());
         pause_unpause_recording_button_ptr->set_text(config.record_config.pause_unpause_hotkey.to_string());
@@ -567,6 +597,10 @@ namespace gsr {
                 return turn_replay_on_off_button_ptr;
             case ConfigureHotkeyType::REPLAY_SAVE:
                 return save_replay_button_ptr;
+            case ConfigureHotkeyType::REPLAY_SAVE_1_MIN:
+                return save_replay_1_min_button_ptr;
+            case ConfigureHotkeyType::REPLAY_SAVE_10_MIN:
+                return save_replay_10_min_button_ptr;
             case ConfigureHotkeyType::RECORD_START_STOP:
                 return start_stop_recording_button_ptr;
             case ConfigureHotkeyType::RECORD_PAUSE_UNPAUSE:
@@ -591,6 +625,10 @@ namespace gsr {
                 return &config.replay_config.start_stop_hotkey;
             case ConfigureHotkeyType::REPLAY_SAVE:
                 return &config.replay_config.save_hotkey;
+            case ConfigureHotkeyType::REPLAY_SAVE_1_MIN:
+                return &config.replay_config.save_1_min_hotkey;
+            case ConfigureHotkeyType::REPLAY_SAVE_10_MIN:
+                return &config.replay_config.save_10_min_hotkey;
             case ConfigureHotkeyType::RECORD_START_STOP:
                 return &config.record_config.start_stop_hotkey;
             case ConfigureHotkeyType::RECORD_PAUSE_UNPAUSE:
@@ -643,6 +681,12 @@ namespace gsr {
             case ConfigureHotkeyType::REPLAY_SAVE:
                 hotkey_configure_action_name = "Save replay";
                 break;
+            case ConfigureHotkeyType::REPLAY_SAVE_1_MIN:
+                hotkey_configure_action_name = "Save 1 minute replay";
+                break;
+            case ConfigureHotkeyType::REPLAY_SAVE_10_MIN:
+                hotkey_configure_action_name = "Save 10 minute replay";
+                break;
             case ConfigureHotkeyType::RECORD_START_STOP:
                 hotkey_configure_action_name = "Start/stop recording";
                 break;

src/gui/GsrPage.cpp

@@ -39,8 +39,9 @@ namespace gsr {
 
         // Process widgets by visibility (backwards)
         return widgets.for_each_reverse([selected_widget, &window, &event, content_page_position](std::unique_ptr<Widget> &widget) {
-            if(widget.get() != selected_widget) {
-                if(!widget->on_event(event, window, content_page_position))
+            Widget *p = widget.get();
+            if(p != selected_widget) {
+                if(!p->on_event(event, window, content_page_position))
                     return false;
             }
             return true;

src/gui/List.cpp

@@ -24,14 +24,23 @@ namespace gsr {
         // Process widgets by visibility (backwards)
         return widgets.for_each_reverse([selected_widget, &event, &window](std::unique_ptr<Widget> &widget) {
             // Ignore offset because widgets are positioned with offset in ::draw, this solution is simpler
-            if(widget.get() != selected_widget) {
-                if(!widget->on_event(event, window, mgl::vec2f(0.0f, 0.0f)))
+            Widget *p = widget.get();
+            if(p != selected_widget) {
+                if(!p->on_event(event, window, mgl::vec2f(0.0f, 0.0f)))
                     return false;
             }
             return true;
         });
     }
 
+    List::~List() {
+        widgets.for_each([this](std::unique_ptr<Widget> &widget) {
+            if(widget->parent_widget == this)
+                widget->parent_widget = nullptr;
+            return true;
+        }, true);
+    }
+
     void List::draw(mgl::Window &window, mgl::vec2f offset) {
         if(!visible)
             return;
@@ -104,15 +113,6 @@ namespace gsr {
             selected_widget->draw(window, mgl::vec2f(0.0f, 0.0f));
     }
 
-    // void List::remove_child_widget(Widget *widget) {
-    //     for(auto it = widgets.begin(), end = widgets.end(); it != end; ++it) {
-    //         if(it->get() == widget) {
-    //             widgets.erase(it);
-    //             return;
-    //         }
-    //     }
-    // }
-
     void List::add_widget(std::unique_ptr<Widget> widget) {
         widget->parent_widget = this;
         widgets.push_back(std::move(widget));
@@ -122,6 +122,10 @@ namespace gsr {
         widgets.remove(widget);
     }
 
+    void List::replace_widget(Widget *widget, std::unique_ptr<Widget> new_widget) {
+        widgets.replace_item(widget, std::move(new_widget));
+    }
+
     void List::clear() {
         widgets.clear();
     }
@@ -137,6 +141,10 @@ namespace gsr {
             return nullptr;
     }
 
+    size_t List::get_num_children() const {
+        return widgets.size();
+    }
+
     void List::set_spacing(float spacing) {
         spacing_scale = spacing;
     }

src/gui/Page.cpp

@@ -1,14 +1,13 @@
 #include "../../include/gui/Page.hpp"
 
 namespace gsr {
-    // void Page::remove_child_widget(Widget *widget) {
-    //     for(auto it = widgets.begin(), end = widgets.end(); it != end; ++it) {
-    //         if(it->get() == widget) {
-    //             widgets.erase(it);
-    //             return;
-    //         }
-    //     }
-    // }
+    Page::~Page() {
+        widgets.for_each([this](std::unique_ptr<Widget> &widget) {
+            if(widget->parent_widget == this)
+                widget->parent_widget = nullptr;
+            return true;
+        }, true);
+    }
 
     void Page::add_widget(std::unique_ptr<Widget> widget) {
         widget->parent_widget = this;

src/gui/RadioButton.cpp

@@ -169,7 +169,7 @@ namespace gsr {
         }
     }
 
-    const std::string RadioButton::get_selected_id() const {
+    const std::string& RadioButton::get_selected_id() const {
         if(items.empty()) {
             static std::string dummy;
             return dummy;
@@ -177,4 +177,13 @@ namespace gsr {
             return items[selected_item].id;
         }
     }
+
+    const std::string& RadioButton::get_selected_text() const {
+        if(items.empty()) {
+            static std::string dummy;
+            return dummy;
+        } else {
+            return items[selected_item].text.get_string();
+        }
+    }
 }

src/gui/ScreenshotSettingsPage.cpp

@@ -257,8 +257,7 @@ namespace gsr {
     void ScreenshotSettingsPage::add_widgets() {
         content_page_ptr->add_widget(create_settings());
 
-        record_area_box_ptr->on_selection_changed = [this](const std::string &text, const std::string &id) {
-            (void)text;
+        record_area_box_ptr->on_selection_changed = [this](const std::string&, const std::string &id) {
             const bool window_selected = id == "window";
             const bool portal_selected = id == "portal";
             select_window_list_ptr->set_visible(window_selected);

src/gui/ScrollablePage.cpp

@@ -15,6 +15,14 @@ namespace gsr {
 
     ScrollablePage::ScrollablePage(mgl::vec2f size) : size(size) {}
 
+    ScrollablePage::~ScrollablePage() {
+        widgets.for_each([this](std::unique_ptr<Widget> &widget) {
+            if(widget->parent_widget == this)
+                widget->parent_widget = nullptr;
+            return true;
+        }, true);
+    }
+
     bool ScrollablePage::on_event(mgl::Event &event, mgl::Window &window, mgl::vec2f offset) {
         if(!visible)
             return true;
@@ -57,8 +65,9 @@ namespace gsr {
 
         // Process widgets by visibility (backwards)
         const bool continue_events = widgets.for_each_reverse([selected_widget, &window, &event, offset](std::unique_ptr<Widget> &widget) {
-            if(widget.get() != selected_widget) {
-                if(!widget->on_event(event, window, offset))
+            Widget *p = widget.get();
+            if(p != selected_widget) {
+                if(!p->on_event(event, window, offset))
                     return false;
             }
             return true;

src/gui/SettingsPage.cpp

@@ -11,6 +11,8 @@
 #include <string.h>
 
 namespace gsr {
+    static const char *custom_app_audio_tag = "[custom]";
+
     enum class AudioTrackType {
         DEVICE,
         APPLICATION,
@@ -202,121 +204,201 @@ namespace gsr {
         return audio_device_box;
     }
 
-    std::unique_ptr<Button> SettingsPage::create_remove_audio_device_button(List *audio_device_list_ptr) {
-        auto remove_audio_track_button = std::make_unique<Button>(&get_theme().body_font, "Remove", mgl::vec2f(0.0f, 0.0f), mgl::Color(0, 0, 0, 120));
-        remove_audio_track_button->on_click = [this, audio_device_list_ptr]() {
-            audio_track_list_ptr->remove_widget(audio_device_list_ptr);
+    static void set_application_audio_options_visible(Subsection *audio_track_subsection, bool visible, const GsrInfo &gsr_info) {
+        if(!gsr_info.system_info.supports_app_audio)
+            visible = false;
+
+        List *audio_track_items_list = dynamic_cast<List*>(audio_track_subsection->get_inner_widget());
+
+        List *buttons_list = dynamic_cast<List*>(audio_track_items_list->get_child_widget_by_index(1));
+        Button *add_application_audio_button = dynamic_cast<Button*>(buttons_list->get_child_widget_by_index(1));
+        add_application_audio_button->set_visible(visible);
+
+        CheckBox *invert_app_audio_checkbox = dynamic_cast<CheckBox*>(audio_track_items_list->get_child_widget_by_index(3));
+        invert_app_audio_checkbox->set_visible(visible);
+    }
+
+    static void set_application_audio_options_visible(List *audio_track_section_list_ptr, bool visible, const GsrInfo &gsr_info) {
+        audio_track_section_list_ptr->for_each_child_widget([visible, &gsr_info](std::unique_ptr<Widget> &widget) {
+            Subsection *audio_track_subsection = dynamic_cast<Subsection*>(widget.get());
+            set_application_audio_options_visible(audio_track_subsection, visible, gsr_info);
+            return true;
+        });
+    }
+
+    std::unique_ptr<Button> SettingsPage::create_remove_audio_device_button(List *audio_input_list_ptr, List *audio_device_list_ptr) {
+        auto remove_audio_track_button = std::make_unique<Button>(&get_theme().body_font, "", mgl::vec2f(0.0f, 0.0f), mgl::Color(0, 0, 0, 0));
+        remove_audio_track_button->set_icon(&get_theme().trash_texture);
+        remove_audio_track_button->set_icon_padding_scale(0.75f);
+        remove_audio_track_button->on_click = [audio_input_list_ptr, audio_device_list_ptr]() {
+            audio_input_list_ptr->remove_widget(audio_device_list_ptr);
         };
         return remove_audio_track_button;
     }
 
-    std::unique_ptr<List> SettingsPage::create_audio_device() {
+    std::unique_ptr<List> SettingsPage::create_audio_device(List *audio_input_list_ptr) {
         auto audio_device_list = std::make_unique<List>(List::Orientation::HORIZONTAL, List::Alignment::CENTER);
         audio_device_list->userdata = (void*)(uintptr_t)AudioTrackType::DEVICE;
         audio_device_list->add_widget(std::make_unique<Label>(&get_theme().body_font, "Device:", get_color_theme().text_color));
         audio_device_list->add_widget(create_audio_device_selection_combobox());
-        audio_device_list->add_widget(create_remove_audio_device_button(audio_device_list.get()));
+        audio_device_list->add_widget(create_remove_audio_device_button(audio_input_list_ptr, audio_device_list.get()));
         return audio_device_list;
     }
 
-    std::unique_ptr<Button> SettingsPage::create_add_audio_device_button() {
+    std::unique_ptr<Button> SettingsPage::create_add_audio_track_button() {
+        auto button = std::make_unique<Button>(&get_theme().body_font, "Add audio track", mgl::vec2f(0.0f, 0.0f), mgl::Color(0, 0, 0, 120));
+        button->on_click = [this]() {
+            audio_track_section_list_ptr->add_widget(create_audio_track_section(audio_section_ptr));
+        };
+        button->set_visible(type != Type::STREAM);
+        return button;
+    }
+
+    std::unique_ptr<Button> SettingsPage::create_add_audio_device_button(List *audio_input_list_ptr) {
         auto add_audio_track_button = std::make_unique<Button>(&get_theme().body_font, "Add audio device", mgl::vec2f(0.0f, 0.0f), mgl::Color(0, 0, 0, 120));
-        add_audio_track_button->on_click = [this]() {
+        add_audio_track_button->on_click = [this, audio_input_list_ptr]() {
             audio_devices = get_audio_devices();
-            audio_track_list_ptr->add_widget(create_audio_device());
+            audio_input_list_ptr->add_widget(create_audio_device(audio_input_list_ptr));
         };
         return add_audio_track_button;
     }
 
-    std::unique_ptr<ComboBox> SettingsPage::create_application_audio_selection_combobox() {
+    std::unique_ptr<ComboBox> SettingsPage::create_application_audio_selection_combobox(List *application_audio_row) {
         auto audio_device_box = std::make_unique<ComboBox>(&get_theme().body_font);
+        ComboBox *audio_device_box_ptr = audio_device_box.get();
         for(const auto &app_audio : application_audio) {
             audio_device_box->add_item(app_audio, app_audio);
         }
+        audio_device_box->add_item("Custom...", custom_app_audio_tag);
+
+        audio_device_box->on_selection_changed = [application_audio_row, audio_device_box_ptr](const std::string&, const std::string &id) {
+            if(id == custom_app_audio_tag) {
+                application_audio_row->userdata = (void*)(uintptr_t)AudioTrackType::APPLICATION_CUSTOM;
+                auto custom_app_audio_entry = std::make_unique<Entry>(&get_theme().body_font, "", (int)(get_theme().body_font.get_character_size() * 10.0f));
+                application_audio_row->replace_widget(audio_device_box_ptr, std::move(custom_app_audio_entry));
+            }
+        };
+
         return audio_device_box;
     }
 
-    std::unique_ptr<List> SettingsPage::create_application_audio() {
+    std::unique_ptr<List> SettingsPage::create_application_audio(List *audio_input_list_ptr) {
         auto application_audio_list = std::make_unique<List>(List::Orientation::HORIZONTAL, List::Alignment::CENTER);
         application_audio_list->userdata = (void*)(uintptr_t)AudioTrackType::APPLICATION;
         application_audio_list->add_widget(std::make_unique<Label>(&get_theme().body_font, "App:     ", get_color_theme().text_color));
-        application_audio_list->add_widget(create_application_audio_selection_combobox());
-        application_audio_list->add_widget(create_remove_audio_device_button(application_audio_list.get()));
+        application_audio_list->add_widget(create_application_audio_selection_combobox(application_audio_list.get()));
+        application_audio_list->add_widget(create_remove_audio_device_button(audio_input_list_ptr, application_audio_list.get()));
         return application_audio_list;
     }
 
-    std::unique_ptr<List> SettingsPage::create_custom_application_audio() {
+    std::unique_ptr<List> SettingsPage::create_custom_application_audio(List *audio_input_list_ptr) {
         auto application_audio_list = std::make_unique<List>(List::Orientation::HORIZONTAL, List::Alignment::CENTER);
         application_audio_list->userdata = (void*)(uintptr_t)AudioTrackType::APPLICATION_CUSTOM;
         application_audio_list->add_widget(std::make_unique<Label>(&get_theme().body_font, "App:     ", get_color_theme().text_color));
         application_audio_list->add_widget(std::make_unique<Entry>(&get_theme().body_font, "", (int)(get_theme().body_font.get_character_size() * 10.0f)));
-        application_audio_list->add_widget(create_remove_audio_device_button(application_audio_list.get()));
+        application_audio_list->add_widget(create_remove_audio_device_button(audio_input_list_ptr, application_audio_list.get()));
         return application_audio_list;
     }
 
-    std::unique_ptr<Button> SettingsPage::create_add_application_audio_button() {
+    std::unique_ptr<Button> SettingsPage::create_add_application_audio_button(List *audio_input_list_ptr) {
         auto add_audio_track_button = std::make_unique<Button>(&get_theme().body_font, "Add application audio", mgl::vec2f(0.0f, 0.0f), mgl::Color(0, 0, 0, 120));
-        add_application_audio_button_ptr = add_audio_track_button.get();
-        add_audio_track_button->on_click = [this]() {
+        add_audio_track_button->on_click = [this, audio_input_list_ptr]() {
             application_audio = get_application_audio();
-            audio_track_list_ptr->add_widget(create_application_audio());
+            if(application_audio.empty())
+                audio_input_list_ptr->add_widget(create_custom_application_audio(audio_input_list_ptr));
+            else
+                audio_input_list_ptr->add_widget(create_application_audio(audio_input_list_ptr));
         };
         return add_audio_track_button;
     }
 
-    std::unique_ptr<Button> SettingsPage::create_add_custom_application_audio_button() {
-        auto add_audio_track_button = std::make_unique<Button>(&get_theme().body_font, "Add custom application audio", mgl::vec2f(0.0f, 0.0f), mgl::Color(0, 0, 0, 120));
-        add_custom_application_audio_button_ptr = add_audio_track_button.get();
-        add_audio_track_button->on_click = [this]() {
-            audio_track_list_ptr->add_widget(create_custom_application_audio());
-        };
-        return add_audio_track_button;
-    }
-
-    std::unique_ptr<List> SettingsPage::create_add_audio_buttons() {
+    std::unique_ptr<List> SettingsPage::create_add_audio_buttons(List *audio_input_list_ptr) {
         auto list = std::make_unique<List>(List::Orientation::HORIZONTAL, List::Alignment::CENTER);
-        list->add_widget(create_add_audio_device_button());
-        list->add_widget(create_add_application_audio_button());
-        list->add_widget(create_add_custom_application_audio_button());
+        list->add_widget(create_add_audio_device_button(audio_input_list_ptr));
+        list->add_widget(create_add_application_audio_button(audio_input_list_ptr));
         return list;
     }
 
-    std::unique_ptr<List> SettingsPage::create_audio_track_track_section() {
+    std::unique_ptr<List> SettingsPage::create_audio_input_section() {
         auto list = std::make_unique<List>(List::Orientation::VERTICAL);
-        audio_track_list_ptr = list.get();
-        audio_track_list_ptr->add_widget(create_audio_device()); // Add default_output by default
+        //list->add_widget(create_audio_device(list.get())); // Add default_output by default
         return list;
     }
 
-    std::unique_ptr<CheckBox> SettingsPage::create_split_audio_checkbox() {
-        auto split_audio_checkbox = std::make_unique<CheckBox>(&get_theme().body_font, "Split each device/app audio into separate audio tracks");
-        split_audio_checkbox->set_checked(false);
-        split_audio_checkbox_ptr = split_audio_checkbox.get();
-        return split_audio_checkbox;
-    }
-
     std::unique_ptr<CheckBox> SettingsPage::create_application_audio_invert_checkbox() {
         auto application_audio_invert_checkbox = std::make_unique<CheckBox>(&get_theme().body_font, "Record audio from all applications except the selected ones");
         application_audio_invert_checkbox->set_checked(false);
-        application_audio_invert_checkbox_ptr = application_audio_invert_checkbox.get();
         return application_audio_invert_checkbox;
     }
 
-    std::unique_ptr<Widget> SettingsPage::create_audio_track_section() {
+    static void update_audio_track_titles(List *audio_track_section_list_ptr) {
+        int index = 0;
+        audio_track_section_list_ptr->for_each_child_widget([&index](std::unique_ptr<Widget> &widget) {
+            char audio_track_name[32];
+            snprintf(audio_track_name, sizeof(audio_track_name), "Audio track #%d", 1 + index);
+            ++index;
+
+            Subsection *subsection = dynamic_cast<Subsection*>(widget.get());
+            List *subesection_items = dynamic_cast<List*>(subsection->get_inner_widget());
+            Label *audio_track_title = dynamic_cast<Label*>(dynamic_cast<List*>(subesection_items->get_child_widget_by_index(0))->get_child_widget_by_index(0));
+            audio_track_title->set_text(audio_track_name);
+            return true;
+        });
+    }
+
+    std::unique_ptr<List> SettingsPage::create_audio_track_title_and_remove(Subsection *audio_track_subsection, const char *title) {
+        auto list = std::make_unique<List>(List::Orientation::HORIZONTAL, List::Alignment::CENTER);
+        list->add_widget(std::make_unique<Label>(&get_theme().title_font, title, get_color_theme().text_color));
+
+        auto remove_track_button = std::make_unique<Button>(&get_theme().body_font, "", mgl::vec2f(0.0f, 0.0f), mgl::Color(0, 0, 0, 0));
+        remove_track_button->set_icon(&get_theme().trash_texture);
+        remove_track_button->set_icon_padding_scale(0.75f);
+        remove_track_button->on_click = [this, audio_track_subsection]() {
+            audio_track_section_list_ptr->remove_widget(audio_track_subsection);
+            update_audio_track_titles(audio_track_section_list_ptr);
+        };
+        list->add_widget(std::move(remove_track_button));
+        list->set_visible(type != Type::STREAM);
+        return list;
+    }
+
+    std::unique_ptr<Subsection> SettingsPage::create_audio_track_section(Widget *parent_widget) {
+        char audio_track_name[32];
+        snprintf(audio_track_name, sizeof(audio_track_name), "Audio track #%d", 1 + (int)audio_track_section_list_ptr->get_num_children());
+
+        auto audio_input_section = create_audio_input_section();
+        List *audio_input_section_ptr = audio_input_section.get();
+
         auto list = std::make_unique<List>(List::Orientation::VERTICAL);
-        list->add_widget(create_add_audio_buttons());
-        list->add_widget(create_audio_track_track_section());
+        List *list_ptr = list.get();
+        auto subsection = std::make_unique<Subsection>("", std::move(std::move(list)), mgl::vec2f(parent_widget->get_inner_size().x, 0.0f));
+        subsection->set_bg_color(mgl::Color(35, 40, 44));
+
+        list_ptr->add_widget(create_audio_track_title_and_remove(subsection.get(), audio_track_name));
+        list_ptr->add_widget(create_add_audio_buttons(audio_input_section_ptr));
+        list_ptr->add_widget(std::move(audio_input_section));
+        list_ptr->add_widget(create_application_audio_invert_checkbox());
+
+        set_application_audio_options_visible(subsection.get(), view_radio_button_ptr->get_selected_id() == "advanced", *gsr_info);
+        return subsection;
+    }
+
+    std::unique_ptr<List> SettingsPage::create_audio_track_section_list() {
+        auto list = std::make_unique<List>(List::Orientation::VERTICAL);
+        audio_track_section_list_ptr = list.get();
         return list;
     }
 
     std::unique_ptr<Widget> SettingsPage::create_audio_section() {
         auto audio_device_section_list = std::make_unique<List>(List::Orientation::VERTICAL);
-        audio_device_section_list->add_widget(create_audio_track_section());
-        if(type != Type::STREAM)
-            audio_device_section_list->add_widget(create_split_audio_checkbox());
-        audio_device_section_list->add_widget(create_application_audio_invert_checkbox());
-        audio_device_section_list->add_widget(create_audio_codec());
-        return std::make_unique<Subsection>("Audio", std::move(audio_device_section_list), mgl::vec2f(settings_scrollable_page_ptr->get_inner_size().x, 0.0f));
+        List *audio_device_section_list_ptr = audio_device_section_list.get();
+
+        auto subsection = std::make_unique<Subsection>("Audio", std::move(audio_device_section_list), mgl::vec2f(settings_scrollable_page_ptr->get_inner_size().x, 0.0f));
+        audio_section_ptr = subsection.get();
+        audio_device_section_list_ptr->add_widget(create_add_audio_track_button());
+        audio_device_section_list_ptr->add_widget(create_audio_track_section_list());
+        audio_device_section_list_ptr->add_widget(create_audio_codec());
+        return subsection;
     }
 
     std::unique_ptr<List> SettingsPage::create_video_quality_box() {
@@ -531,8 +613,7 @@ namespace gsr {
     void SettingsPage::add_widgets() {
         content_page_ptr->add_widget(create_settings());
 
-        record_area_box_ptr->on_selection_changed = [this](const std::string &text, const std::string &id) {
-            (void)text;
+        record_area_box_ptr->on_selection_changed = [this](const std::string&, const std::string &id) {
             const bool window_selected = id == "window";
             const bool focused_selected = id == "focused";
             const bool portal_selected = id == "portal";
@@ -549,8 +630,7 @@ namespace gsr {
             video_resolution_list_ptr->set_visible(!focused_selected && checked);
         };
 
-        video_quality_box_ptr->on_selection_changed = [this](const std::string &text, const std::string &id) {
-            (void)text;
+        video_quality_box_ptr->on_selection_changed = [this](const std::string&, const std::string &id) {
             const bool custom_selected = id == "custom";
             video_bitrate_list_ptr->set_visible(custom_selected);
 
@@ -569,12 +649,6 @@ namespace gsr {
             record_area_box_ptr->set_selected_item("window");
         else
             record_area_box_ptr->on_selection_changed("", "");
-
-        if(!gsr_info->system_info.supports_app_audio) {
-            add_application_audio_button_ptr->set_visible(false);
-            add_custom_application_audio_button_ptr->set_visible(false);
-            application_audio_invert_checkbox_ptr->set_visible(false);
-        }
     }
 
     void SettingsPage::add_page_specific_widgets() {
@@ -641,7 +715,7 @@ namespace gsr {
         auto list = std::make_unique<List>(List::Orientation::HORIZONTAL, List::Alignment::CENTER);
 
         auto replay_time_entry = std::make_unique<Entry>(&get_theme().body_font, "60", get_theme().body_font.get_character_size() * 3);
-        replay_time_entry->validate_handler = create_entry_validator_integer_in_range(1, 10800);
+        replay_time_entry->validate_handler = create_entry_validator_integer_in_range(2, 86400);
         replay_time_entry_ptr = replay_time_entry.get();
         list->add_widget(std::move(replay_time_entry));
 
@@ -659,6 +733,24 @@ namespace gsr {
         return replay_time_list;
     }
 
+    std::unique_ptr<List> SettingsPage::create_replay_storage() {
+        auto list = std::make_unique<List>(List::Orientation::VERTICAL);
+        list->add_widget(std::make_unique<Label>(&get_theme().body_font, "Where should temporary replay data be stored?", get_color_theme().text_color));
+        auto replay_storage_button = std::make_unique<RadioButton>(&get_theme().body_font, RadioButton::Orientation::HORIZONTAL);
+        replay_storage_button_ptr = replay_storage_button.get();
+        replay_storage_button->add_item("RAM", "ram");
+        replay_storage_button->add_item("Disk (not recommended on SSDs)", "disk");
+
+        replay_storage_button->on_selection_changed = [this](const std::string&, const std::string &id) {
+            update_estimated_replay_file_size(id);
+            return true;
+        };
+
+        list->add_widget(std::move(replay_storage_button));
+        list->set_visible(gsr_info->system_info.gsr_version >= GsrVersion{5, 5, 0});
+        return list;
+    }
+
     std::unique_ptr<RadioButton> SettingsPage::create_start_replay_automatically() {
         char fullscreen_text[256];
         snprintf(fullscreen_text, sizeof(fullscreen_text), "Turn on replay when starting a fullscreen application%s", gsr_info->system_info.display_server == DisplayServer::X11 ? "" : " (X11 applications only)");
@@ -692,13 +784,13 @@ namespace gsr {
         return label;
     }
 
-    void SettingsPage::update_estimated_replay_file_size() {
+    void SettingsPage::update_estimated_replay_file_size(const std::string &replay_storage_type) {
         const int64_t replay_time_seconds = atoi(replay_time_entry_ptr->get_text().c_str());
         const int64_t video_bitrate_bps = atoi(video_bitrate_entry_ptr->get_text().c_str()) * 1000LL / 8LL;
         const double video_filesize_mb = ((double)replay_time_seconds * (double)video_bitrate_bps) / 1000.0 / 1000.0 * 1.024;
 
         char buffer[256];
-        snprintf(buffer, sizeof(buffer), "Estimated video max file size in RAM: %.2fMB.\nChange video bitrate or replay duration to change file size.", video_filesize_mb);
+        snprintf(buffer, sizeof(buffer), "Estimated video max file size %s: %.2fMB.\nChange video bitrate or replay duration to change file size.", replay_storage_type == "ram" ? "in RAM" : "on disk", video_filesize_mb);
         estimated_file_size_ptr->set_text(buffer);
     }
 
@@ -716,6 +808,16 @@ namespace gsr {
         replay_time_label_ptr->set_text(buffer);
     }
 
+    void SettingsPage::view_changed(bool advanced_view, Subsection *notifications_subsection_ptr) {
+        color_range_list_ptr->set_visible(advanced_view);
+        audio_codec_ptr->set_visible(advanced_view);
+        video_codec_ptr->set_visible(advanced_view);
+        framerate_mode_list_ptr->set_visible(advanced_view);
+        notifications_subsection_ptr->set_visible(advanced_view);
+        set_application_audio_options_visible(audio_track_section_list_ptr, advanced_view, *gsr_info);
+        settings_scrollable_page_ptr->reset_scroll();
+    }
+
     void SettingsPage::add_replay_widgets() {
         auto file_info_list = std::make_unique<List>(List::Orientation::VERTICAL);
         auto file_info_data_list = std::make_unique<List>(List::Orientation::HORIZONTAL);
@@ -727,12 +829,14 @@ namespace gsr {
         settings_list_ptr->add_widget(std::make_unique<Subsection>("File info", std::move(file_info_list), mgl::vec2f(settings_scrollable_page_ptr->get_inner_size().x, 0.0f)));
 
         auto general_list = std::make_unique<List>(List::Orientation::VERTICAL);
-        general_list->add_widget(create_start_replay_automatically());
+        general_list->add_widget(create_replay_storage());
         general_list->add_widget(create_save_replay_in_game_folder());
         if(gsr_info->system_info.gsr_version >= GsrVersion{5, 0, 3})
             general_list->add_widget(create_restart_replay_on_save());
         settings_list_ptr->add_widget(std::make_unique<Subsection>("General", std::move(general_list), mgl::vec2f(settings_scrollable_page_ptr->get_inner_size().x, 0.0f)));
 
+        settings_list_ptr->add_widget(std::make_unique<Subsection>("Autostart", create_start_replay_automatically(), mgl::vec2f(settings_scrollable_page_ptr->get_inner_size().x, 0.0f)));
+
         auto checkboxes_list = std::make_unique<List>(List::Orientation::VERTICAL);
 
         auto show_replay_started_notification_checkbox = std::make_unique<CheckBox>(&get_theme().body_font, "Show replay started notification");
@@ -754,27 +858,19 @@ namespace gsr {
         Subsection *notifications_subsection_ptr = notifications_subsection.get();
         settings_list_ptr->add_widget(std::move(notifications_subsection));
 
-        view_radio_button_ptr->on_selection_changed = [this, notifications_subsection_ptr](const std::string &text, const std::string &id) {
-            (void)text;
-            const bool advanced_view = id == "advanced";
-            color_range_list_ptr->set_visible(advanced_view);
-            audio_codec_ptr->set_visible(advanced_view);
-            video_codec_ptr->set_visible(advanced_view);
-            framerate_mode_list_ptr->set_visible(advanced_view);
-            notifications_subsection_ptr->set_visible(advanced_view);
-            split_audio_checkbox_ptr->set_visible(advanced_view);
-            settings_scrollable_page_ptr->reset_scroll();
+        view_radio_button_ptr->on_selection_changed = [this, notifications_subsection_ptr](const std::string&, const std::string &id) {
+            view_changed(id == "advanced", notifications_subsection_ptr);
             return true;
         };
         view_radio_button_ptr->on_selection_changed("Simple", "simple");
 
         replay_time_entry_ptr->on_changed = [this](const std::string&) {
-            update_estimated_replay_file_size();
+            update_estimated_replay_file_size(replay_storage_button_ptr->get_selected_id());
             update_replay_time_text();
         };
 
         video_bitrate_entry_ptr->on_changed = [this](const std::string&) {
-            update_estimated_replay_file_size();
+            update_estimated_replay_file_size(replay_storage_button_ptr->get_selected_id());
         };
     }
 
@@ -828,16 +924,8 @@ namespace gsr {
         Subsection *notifications_subsection_ptr = notifications_subsection.get();
         settings_list_ptr->add_widget(std::move(notifications_subsection));
 
-        view_radio_button_ptr->on_selection_changed = [this, notifications_subsection_ptr](const std::string &text, const std::string &id) {
-            (void)text;
-            const bool advanced_view = id == "advanced";
-            color_range_list_ptr->set_visible(advanced_view);
-            audio_codec_ptr->set_visible(advanced_view);
-            video_codec_ptr->set_visible(advanced_view);
-            framerate_mode_list_ptr->set_visible(advanced_view);
-            notifications_subsection_ptr->set_visible(advanced_view);
-            split_audio_checkbox_ptr->set_visible(advanced_view);
-            settings_scrollable_page_ptr->reset_scroll();
+        view_radio_button_ptr->on_selection_changed = [this, notifications_subsection_ptr](const std::string&, const std::string &id) {
+            view_changed(id == "advanced", notifications_subsection_ptr);
             return true;
         };
         view_radio_button_ptr->on_selection_changed("Simple", "simple");
@@ -933,8 +1021,7 @@ namespace gsr {
         Subsection *notifications_subsection_ptr = notifications_subsection.get();
         settings_list_ptr->add_widget(std::move(notifications_subsection));
 
-        streaming_service_box_ptr->on_selection_changed = [this](const std::string &text, const std::string &id) {
-            (void)text;
+        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 custom_option = id == "custom";
@@ -947,15 +1034,8 @@ namespace gsr {
         };
         streaming_service_box_ptr->on_selection_changed("Twitch", "twitch");
 
-        view_radio_button_ptr->on_selection_changed = [this, notifications_subsection_ptr](const std::string &text, const std::string &id) {
-            (void)text;
-            const bool advanced_view = id == "advanced";
-            color_range_list_ptr->set_visible(advanced_view);
-            audio_codec_ptr->set_visible(advanced_view);
-            video_codec_ptr->set_visible(advanced_view);
-            framerate_mode_list_ptr->set_visible(advanced_view);
-            notifications_subsection_ptr->set_visible(advanced_view);
-            settings_scrollable_page_ptr->reset_scroll();
+        view_radio_button_ptr->on_selection_changed = [this, notifications_subsection_ptr](const std::string&, const std::string &id) {
+            view_changed(id == "advanced", notifications_subsection_ptr);
             return true;
         };
         view_radio_button_ptr->on_selection_changed("Simple", "simple");
@@ -1006,50 +1086,61 @@ namespace gsr {
         return nullptr;
     }
 
-    static bool starts_with(std::string_view str, const char *substr) {
-        size_t len = strlen(substr);
-        return str.size() >= len && memcmp(str.data(), substr, len) == 0;
-    }
-
     void SettingsPage::load_audio_tracks(const RecordOptions &record_options) {
-        audio_track_list_ptr->clear();
-        for(const std::string &audio_track : record_options.audio_tracks) {
-            if(starts_with(audio_track, "app:")) {
-                if(!gsr_info->system_info.supports_app_audio)
-                    continue;
+        audio_track_section_list_ptr->clear();
+        for(const AudioTrack &audio_track : record_options.audio_tracks_list) {
+            auto audio_track_section = create_audio_track_section(audio_section_ptr);
+            List *audio_track_section_items_list_ptr = dynamic_cast<List*>(audio_track_section->get_inner_widget());
+            List *audio_input_list_ptr = dynamic_cast<List*>(audio_track_section_items_list_ptr->get_child_widget_by_index(2));
+            CheckBox *application_audio_invert_checkbox_ptr = dynamic_cast<CheckBox*>(audio_track_section_items_list_ptr->get_child_widget_by_index(3));
+            application_audio_invert_checkbox_ptr->set_checked(audio_track.application_audio_invert);
 
-                std::string audio_track_name = audio_track.substr(4);
-                const std::string *app_audio = get_application_audio_by_name_case_insensitive(application_audio, audio_track_name);
-                if(app_audio) {
-                    std::unique_ptr<List> application_audio_widget = create_application_audio();
-                    ComboBox *application_audio_box = static_cast<ComboBox*>(application_audio_widget->get_child_widget_by_index(1));
-                    application_audio_box->set_selected_item(*app_audio);
-                    audio_track_list_ptr->add_widget(std::move(application_audio_widget));
+            audio_input_list_ptr->clear();
+            for(const std::string &audio_input : audio_track.audio_inputs) {
+                if(starts_with(audio_input, "app:")) {
+                    if(!gsr_info->system_info.supports_app_audio)
+                        continue;
+
+                    std::string audio_track_name = audio_input.substr(4);
+                    const std::string *app_audio = get_application_audio_by_name_case_insensitive(application_audio, audio_track_name);
+                    if(app_audio) {
+                        std::unique_ptr<List> application_audio_widget = create_application_audio(audio_input_list_ptr);
+                        ComboBox *application_audio_box = dynamic_cast<ComboBox*>(application_audio_widget->get_child_widget_by_index(1));
+                        application_audio_box->set_selected_item(*app_audio);
+                        audio_input_list_ptr->add_widget(std::move(application_audio_widget));
+                    } else {
+                        std::unique_ptr<List> application_audio_widget = create_custom_application_audio(audio_input_list_ptr);
+                        Entry *application_audio_entry = dynamic_cast<Entry*>(application_audio_widget->get_child_widget_by_index(1));
+                        application_audio_entry->set_text(std::move(audio_track_name));
+                        audio_input_list_ptr->add_widget(std::move(application_audio_widget));
+                    }
+                } else if(starts_with(audio_input, "device:")) {
+                    std::unique_ptr<List> audio_track_widget = create_audio_device(audio_input_list_ptr);
+                    ComboBox *audio_device_box = dynamic_cast<ComboBox*>(audio_track_widget->get_child_widget_by_index(1));
+                    audio_device_box->set_selected_item(audio_input.substr(7));
+                    audio_input_list_ptr->add_widget(std::move(audio_track_widget));
                 } else {
-                    std::unique_ptr<List> application_audio_widget = create_custom_application_audio();
-                    Entry *application_audio_entry = static_cast<Entry*>(application_audio_widget->get_child_widget_by_index(1));
-                    application_audio_entry->set_text(std::move(audio_track_name));
-                    audio_track_list_ptr->add_widget(std::move(application_audio_widget));
+                    std::unique_ptr<List> audio_track_widget = create_audio_device(audio_input_list_ptr);
+                    ComboBox *audio_device_box = dynamic_cast<ComboBox*>(audio_track_widget->get_child_widget_by_index(1));
+                    audio_device_box->set_selected_item(audio_input);
+                    audio_input_list_ptr->add_widget(std::move(audio_track_widget));
                 }
-            } else if(starts_with(audio_track, "device:")) {
-                std::unique_ptr<List> audio_track_widget = create_audio_device();
-                ComboBox *audio_device_box = static_cast<ComboBox*>(audio_track_widget->get_child_widget_by_index(1));
-                audio_device_box->set_selected_item(audio_track.substr(7));
-                audio_track_list_ptr->add_widget(std::move(audio_track_widget));
-            } else {
-                std::unique_ptr<List> audio_track_widget = create_audio_device();
-                ComboBox *audio_device_box = static_cast<ComboBox*>(audio_track_widget->get_child_widget_by_index(1));
-                audio_device_box->set_selected_item(audio_track);
-                audio_track_list_ptr->add_widget(std::move(audio_track_widget));
             }
+
+            audio_track_section_list_ptr->add_widget(std::move(audio_track_section));
+
+            if(type == Type::STREAM)
+                break;
+        }
+
+        if(type == Type::STREAM && audio_track_section_list_ptr->get_num_children() == 0) {
+            auto audio_track_section = create_audio_track_section(audio_section_ptr);
+            audio_track_section_list_ptr->add_widget(std::move(audio_track_section));
         }
     }
 
     void SettingsPage::load_common(RecordOptions &record_options) {
         record_area_box_ptr->set_selected_item(record_options.record_area_option);
-        if(split_audio_checkbox_ptr)
-            split_audio_checkbox_ptr->set_checked(!record_options.merge_audio_tracks);
-        application_audio_invert_checkbox_ptr->set_checked(record_options.application_audio_invert);
         change_video_resolution_checkbox_ptr->set_checked(record_options.change_video_resolution);
         load_audio_tracks(record_options);
         color_range_box_ptr->set_selected_item(record_options.color_range);
@@ -1102,6 +1193,7 @@ namespace gsr {
 
     void SettingsPage::load_replay() {
         load_common(config.replay_config.record_options);
+        replay_storage_button_ptr->set_selected_item(config.replay_config.replay_storage);
         turn_on_replay_automatically_mode_ptr->set_selected_item(config.replay_config.turn_on_replay_automatically_mode);
         save_replay_in_game_folder_ptr->set_checked(config.replay_config.save_video_in_game_folder);
         if(restart_replay_on_save)
@@ -1114,8 +1206,8 @@ namespace gsr {
 
         if(config.replay_config.replay_time < 2)
             config.replay_config.replay_time = 2;
-        if(config.replay_config.replay_time > 10800)
-            config.replay_config.replay_time = 10800;
+        if(config.replay_config.replay_time > 86400)
+            config.replay_config.replay_time = 86400;
         replay_time_entry_ptr->set_text(std::to_string(config.replay_config.replay_time));
     }
 
@@ -1139,28 +1231,38 @@ namespace gsr {
         container_box_ptr->set_selected_item(config.streaming_config.custom.container);
     }
 
-    static void save_audio_tracks(std::vector<std::string> &audio_devices, List *audio_devices_list_ptr) {
-        audio_devices.clear();
-        audio_devices_list_ptr->for_each_child_widget([&audio_devices](std::unique_ptr<Widget> &child_widget) {
-            List *audio_track_line = static_cast<List*>(child_widget.get());
-            const AudioTrackType audio_track_type = (AudioTrackType)(uintptr_t)audio_track_line->userdata;
-            switch(audio_track_type) {
-                case AudioTrackType::DEVICE: {
-                    ComboBox *audio_device_box = static_cast<ComboBox*>(audio_track_line->get_child_widget_by_index(1));
-                    audio_devices.push_back("device:" + audio_device_box->get_selected_id());
-                    break;
+    static void save_audio_tracks(std::vector<AudioTrack> &audio_tracks, List *audio_track_section_list_ptr) {
+        audio_tracks.clear();
+        audio_track_section_list_ptr->for_each_child_widget([&audio_tracks](std::unique_ptr<Widget> &child_widget) {
+            Subsection *audio_subsection = dynamic_cast<Subsection*>(child_widget.get());
+            List *audio_track_section_items_list_ptr = dynamic_cast<List*>(audio_subsection->get_inner_widget());
+            List *audio_input_list_ptr = dynamic_cast<List*>(audio_track_section_items_list_ptr->get_child_widget_by_index(2));
+            CheckBox *application_audio_invert_checkbox_ptr = dynamic_cast<CheckBox*>(audio_track_section_items_list_ptr->get_child_widget_by_index(3));
+
+            audio_tracks.push_back({std::vector<std::string>{}, application_audio_invert_checkbox_ptr->is_checked()});
+            audio_input_list_ptr->for_each_child_widget([&audio_tracks](std::unique_ptr<Widget> &child_widget){
+                List *audio_track_line = dynamic_cast<List*>(child_widget.get());
+                const AudioTrackType audio_track_type = (AudioTrackType)(uintptr_t)audio_track_line->userdata;
+                switch(audio_track_type) {
+                    case AudioTrackType::DEVICE: {
+                        ComboBox *audio_device_box = dynamic_cast<ComboBox*>(audio_track_line->get_child_widget_by_index(1));
+                        audio_tracks.back().audio_inputs.push_back("device:" + audio_device_box->get_selected_id());
+                        break;
+                    }
+                    case AudioTrackType::APPLICATION: {
+                        ComboBox *application_audio_box = dynamic_cast<ComboBox*>(audio_track_line->get_child_widget_by_index(1));
+                        audio_tracks.back().audio_inputs.push_back("app:" + application_audio_box->get_selected_id());
+                        break;
+                    }
+                    case AudioTrackType::APPLICATION_CUSTOM: {
+                        Entry *application_audio_entry = dynamic_cast<Entry*>(audio_track_line->get_child_widget_by_index(1));
+                        audio_tracks.back().audio_inputs.push_back("app:" + application_audio_entry->get_text());
+                        break;
+                    }
                 }
-                case AudioTrackType::APPLICATION: {
-                    ComboBox *application_audio_box = static_cast<ComboBox*>(audio_track_line->get_child_widget_by_index(1));
-                    audio_devices.push_back("app:" + application_audio_box->get_selected_id());
-                    break;
-                }
-                case AudioTrackType::APPLICATION_CUSTOM: {
-                    Entry *application_audio_entry = static_cast<Entry*>(audio_track_line->get_child_widget_by_index(1));
-                    audio_devices.push_back("app:" + application_audio_entry->get_text());
-                    break;
-                }
-            }
+                return true;
+            });
+
             return true;
         });
     }
@@ -1173,11 +1275,8 @@ namespace gsr {
         record_options.video_height = atoi(video_height_entry_ptr->get_text().c_str());
         record_options.fps = atoi(framerate_entry_ptr->get_text().c_str());
         record_options.video_bitrate = atoi(video_bitrate_entry_ptr->get_text().c_str());
-        if(split_audio_checkbox_ptr)
-            record_options.merge_audio_tracks = !split_audio_checkbox_ptr->is_checked();
-        record_options.application_audio_invert = application_audio_invert_checkbox_ptr->is_checked();
         record_options.change_video_resolution = change_video_resolution_checkbox_ptr->is_checked();
-        save_audio_tracks(record_options.audio_tracks, audio_track_list_ptr);
+        save_audio_tracks(record_options.audio_tracks_list, audio_track_section_list_ptr);
         record_options.color_range = color_range_box_ptr->get_selected_id();
         record_options.video_quality = video_quality_box_ptr->get_selected_id();
         record_options.video_codec = video_codec_box_ptr->get_selected_id();
@@ -1244,6 +1343,7 @@ namespace gsr {
         config.replay_config.save_directory = save_directory_button_ptr->get_text();
         config.replay_config.container = container_box_ptr->get_selected_id();
         config.replay_config.replay_time = atoi(replay_time_entry_ptr->get_text().c_str());
+        config.replay_config.replay_storage = replay_storage_button_ptr->get_selected_id();
 
         if(config.replay_config.replay_time < 5) {
             config.replay_config.replay_time = 5;

src/gui/StaticPage.cpp

@@ -20,8 +20,9 @@ namespace gsr {
 
         // Process widgets by visibility (backwards)
         return widgets.for_each_reverse([selected_widget, &window, &event, offset](std::unique_ptr<Widget> &widget) {
-            if(widget.get() != selected_widget) {
-                if(!widget->on_event(event, window, offset))
+            Widget *p = widget.get();
+            if(p != selected_widget) {
+                if(!p->on_event(event, window, offset))
                     return false;
             }
             return true;

src/gui/Subsection.cpp

@@ -12,12 +12,17 @@ namespace gsr {
     static const float title_spacing_scale = 0.010f;
 
     Subsection::Subsection(const char *title, std::unique_ptr<Widget> inner_widget, mgl::vec2f size) :
-        label(&get_theme().title_font, title, get_color_theme().text_color),
+        label(&get_theme().title_font, title ? title : "", get_color_theme().text_color),
         inner_widget(std::move(inner_widget)),
         size(size)
     {
         this->inner_widget->parent_widget = this;
     }
+
+    Subsection::~Subsection() {
+        if(inner_widget->parent_widget == this)
+            inner_widget->parent_widget = nullptr;
+    }
     
     bool Subsection::on_event(mgl::Event &event, mgl::Window &window, mgl::vec2f) {
         if(!visible)
@@ -32,7 +37,7 @@ namespace gsr {
 
         mgl::vec2f draw_pos = position + offset;
         mgl::Rectangle background(draw_pos.floor(), get_size().floor());
-        background.set_color(mgl::Color(25, 30, 34));
+        background.set_color(bg_color);
         window.draw(background);
 
         draw_pos += mgl::vec2f(margin_left_scale, margin_top_scale) * mgl::vec2f(get_theme().window_height, get_theme().window_height);
@@ -69,4 +74,12 @@ namespace gsr {
         const mgl::vec2f margin_size = mgl::vec2f(margin_left_scale + margin_right_scale, margin_top_scale + margin_bottom_scale) * mgl::vec2f(get_theme().window_height, get_theme().window_height);
         return get_size() - margin_size;
     }
+
+    Widget* Subsection::get_inner_widget() {
+        return inner_widget.get();
+    }
+
+    void Subsection::set_bg_color(mgl::Color color) {
+        bg_color = color;
+    }
 }

src/gui/Widget.cpp

@@ -1,14 +1,15 @@
 #include "../../include/gui/Widget.hpp"
+#include <vector>
 
 namespace gsr {
+    static std::vector<std::unique_ptr<Widget>> widgets_to_remove;
+
     Widget::Widget() {
         
     }
 
     Widget::~Widget() {
         remove_widget_as_selected_in_parent();
-        // if(parent_widget)
-        //     parent_widget->remove_child_widget(this);
     }
 
     void Widget::set_position(mgl::vec2f position) {
@@ -62,4 +63,15 @@ namespace gsr {
     void Widget::set_visible(bool visible) {
         this->visible = visible;
     }
+
+    void add_widget_to_remove(std::unique_ptr<Widget> widget) {
+        widgets_to_remove.push_back(std::move(widget));
+    }
+
+    void remove_widgets_to_be_removed() {
+        for(size_t i = 0; i < widgets_to_remove.size(); ++i) {
+            widgets_to_remove[i].reset();
+        }
+        widgets_to_remove.clear();
+    }
 }

src/main.cpp

@@ -30,6 +30,10 @@ static void sigint_handler(int signal) {
     running = 0;
 }
 
+static void signal_ignore(int) {
+
+}
+
 static void disable_prime_run() {
     unsetenv("__NV_PRIME_RENDER_OFFLOAD");
     unsetenv("__NV_PRIME_RENDER_OFFLOAD_PROVIDER");
@@ -74,6 +78,16 @@ static void rpc_add_commands(gsr::Rpc *rpc, gsr::Overlay *overlay) {
         overlay->save_replay();
     });
 
+    rpc->add_handler("replay-save-1-min", [overlay](const std::string &name) {
+        fprintf(stderr, "rpc command executed: %s\n", name.c_str());
+        overlay->save_replay_1_min();
+    });
+
+    rpc->add_handler("replay-save-10-min", [overlay](const std::string &name) {
+        fprintf(stderr, "rpc command executed: %s\n", name.c_str());
+        overlay->save_replay_10_min();
+    });
+
     rpc->add_handler("take-screenshot", [overlay](const std::string &name) {
         fprintf(stderr, "rpc command executed: %s\n", name.c_str());
         overlay->take_screenshot();
@@ -145,18 +159,35 @@ static bool is_flatpak() {
     return getenv("FLATPAK_ID") != nullptr;
 }
 
+static void set_display_server_environment_variables() {
+    // Some users dont have properly setup environments (no display manager that does systemctl --user import-environment DISPLAY WAYLAND_DISPLAY)
+    const char *display = getenv("DISPLAY");
+    if(!display) {
+        display = ":0";
+        setenv("DISPLAY", display, true);
+    }
+
+    const char *wayland_display = getenv("WAYLAND_DISPLAY");
+    if(!wayland_display) {
+        wayland_display = "wayland-1";
+        setenv("WAYLAND_DISPLAY", wayland_display, true);
+    }
+}
+
 static void usage() {
     printf("usage: gsr-ui [action]\n");
     printf("OPTIONS:\n");
-    printf("  action  The launch action. Should be either \"launch-show\" or \"launch-hide\". Optional, defaults to \"launch-hide\".\n");
+    printf("  action  The launch action. Should be either \"launch-show\", \"launch-hide\" or \"launch-daemon\". Optional, defaults to \"launch-hide\".\n");
     printf("          If \"launch-show\" is used then the program starts and the UI is immediately opened and can be shown/hidden with Alt+Z.\n");
-    printf("          If \"launch-hide\" is used then the program starts but the UI is not opened until Alt+Z is pressed.\n");
+    printf("          If \"launch-hide\" is used then the program starts but the UI is not opened until Alt+Z is pressed. The UI will be opened if the program is already running in another process.\n");
+    printf("          If \"launch-daemon\" is used then the program starts but the UI is not opened until Alt+Z is pressed. The UI will not be opened if the program is already running in another process.\n");
     exit(1);
 }
 
 enum class LaunchAction {
     LAUNCH_SHOW,
-    LAUNCH_HIDE
+    LAUNCH_HIDE,
+    LAUNCH_DAEMON
 };
 
 int main(int argc, char **argv) {
@@ -177,18 +208,17 @@ int main(int argc, char **argv) {
             launch_action = LaunchAction::LAUNCH_SHOW;
         } else if(strcmp(launch_action_opt, "launch-hide") == 0) {
             launch_action = LaunchAction::LAUNCH_HIDE;
+        } else if(strcmp(launch_action_opt, "launch-daemon") == 0) {
+            launch_action = LaunchAction::LAUNCH_DAEMON;
         } else {
-            printf("error: invalid action \"%s\", expected \"launch-show\" or \"launch-hide\".\n", launch_action_opt);
+            printf("error: invalid action \"%s\", expected \"launch-show\", \"launch-hide\" or \"launch-daemon\".\n", launch_action_opt);
             usage();
         }
     } else {
         usage();
     }
 
-    if(is_flatpak())
-        install_flatpak_systemd_service();
-    else
-        remove_flatpak_systemd_service();
+    set_display_server_environment_variables();
 
     // TODO: This is a shitty method to detect if multiple instances of gsr-ui is running but this will work properly even in flatpak
     // that uses pid sandboxing. Replace this with a better method once we no longer rely on linux global hotkeys on some platform.
@@ -196,6 +226,9 @@ int main(int argc, char **argv) {
     // What do? creating a pid file doesn't work in flatpak either.
     // TODO: This doesn't work in flatpak when disabling hotkeys.
     if(is_gsr_ui_virtual_keyboard_running() || gsr::pidof("gsr-ui", getpid()) != -1) {
+        if(launch_action == LaunchAction::LAUNCH_DAEMON)
+            return 1;
+
         gsr::Rpc rpc;
         if(rpc.open("gsr-ui") && rpc.write("show_ui\n", 8)) {
             fprintf(stderr, "Error: another instance of gsr-ui is already running, opening that one instead\n");
@@ -207,6 +240,11 @@ int main(int argc, char **argv) {
         return 1;
     }
 
+    if(is_flatpak())
+        install_flatpak_systemd_service();
+    else
+        remove_flatpak_systemd_service();
+
     // Stop nvidia driver from buffering frames
     setenv("__GL_MaxFramesAllowed", "1", true);
     // If this is set to 1 then cuGraphicsGLRegisterImage will fail for egl context with error: invalid OpenGL or DirectX context,
@@ -218,6 +256,16 @@ int main(int argc, char **argv) {
     unsetenv("vblank_mode");
 
     signal(SIGINT, sigint_handler);
+    signal(SIGTERM, sigint_handler);
+    signal(SIGUSR1, signal_ignore);
+    signal(SIGUSR2, signal_ignore);
+    signal(SIGRTMIN, signal_ignore);
+    signal(SIGRTMIN+1, signal_ignore);
+    signal(SIGRTMIN+2, signal_ignore);
+    signal(SIGRTMIN+3, signal_ignore);
+    signal(SIGRTMIN+4, signal_ignore);
+    signal(SIGRTMIN+5, signal_ignore);
+    signal(SIGRTMIN+6, signal_ignore);
 
     gsr::GsrInfo gsr_info;
     // TODO: Show the error in ui
@@ -235,7 +283,7 @@ int main(int argc, char **argv) {
         disable_prime_run();
     }
 
-    if(mgl_init() != 0) {
+    if(mgl_init(MGL_WINDOW_SYSTEM_X11) != 0) {
         fprintf(stderr, "Error: failed to initialize mgl. Failed to either connect to the X11 server or setup opengl\n");
         exit(1);
     }
@@ -303,10 +351,10 @@ int main(int argc, char **argv) {
     if(exit_reason == "back-to-old-ui") {
         const char *args[] = { "gpu-screen-recorder-gtk", "use-old-ui", nullptr };
         execvp(args[0], (char* const*)args);
-    } else if(exit_reason == "restart") {
-        const char *args[] = { "gsr-ui", "launch-show", nullptr };
-        execvp(args[0], (char* const*)args);
+        return 0;
+    } else if(exit_reason == "exit") {
+        return 0;
     }
 
-    return 0;
+    return mgl_is_connected_to_display_server() ? 0 : 1;
 }

tools/gsr-global-hotkeys/README.md

@@ -18,4 +18,10 @@ To unbind all keys send `unbind_all<newline>` to the programs stdin, for example
 ```
 unbind_all
 
+```
+## Exit
+To close gsr-global-hotkeys send `exit<newline>` to the programs stdin, for example:
+```
+exit
+
 ```

tools/gsr-global-hotkeys/keyboard_event.c

@@ -404,8 +404,10 @@ static void keyboard_event_remove_event(keyboard_event *self, int index) {
     if(index < 0 || index >= self->num_event_polls)
         return;
 
-    ioctl(self->event_polls[index].fd, EVIOCGRAB, 0);
-    close(self->event_polls[index].fd);
+    if(self->event_polls[index].fd > 0) {
+        ioctl(self->event_polls[index].fd, EVIOCGRAB, 0);
+        close(self->event_polls[index].fd);
+    }
     free(self->event_extra_data[index].key_states);
     free(self->event_extra_data[index].key_presses_grabbed);
 
@@ -435,7 +437,7 @@ static int setup_virtual_keyboard_input(const char *name) {
     success &= (ioctl(fd, UI_SET_EVBIT, EV_KEY) != -1);
     success &= (ioctl(fd, UI_SET_EVBIT, EV_REP) != -1);
     success &= (ioctl(fd, UI_SET_EVBIT, EV_REL) != -1);
-    success &= (ioctl(fd, UI_SET_EVBIT, EV_LED) != -1);
+    //success &= (ioctl(fd, UI_SET_EVBIT, EV_LED) != -1);
 
     success &= (ioctl(fd, UI_SET_MSCBIT, MSC_SCAN) != -1);
     for(int i = 1; i < KEY_MAX; ++i) {
@@ -445,9 +447,9 @@ static int setup_virtual_keyboard_input(const char *name) {
     for(int i = 0; i < REL_MAX; ++i) {
         success &= (ioctl(fd, UI_SET_RELBIT, i) != -1);
     }
-    for(int i = 0; i < LED_MAX; ++i) {
-        success &= (ioctl(fd, UI_SET_LEDBIT, i) != -1);
-    }
+    // for(int i = 0; i < LED_MAX; ++i) {
+    //     success &= (ioctl(fd, UI_SET_LEDBIT, i) != -1);
+    // }
 
     // success &= (ioctl(fd, UI_SET_EVBIT, EV_ABS) != -1);
     // success &= (ioctl(fd, UI_SET_ABSBIT, ABS_X) != -1);
@@ -566,8 +568,10 @@ void keyboard_event_deinit(keyboard_event *self) {
     }
 
     for(int i = 0; i < self->num_event_polls; ++i) {
-        ioctl(self->event_polls[i].fd, EVIOCGRAB, 0);
-        close(self->event_polls[i].fd);
+        if(self->event_polls[i].fd > 0) {
+            ioctl(self->event_polls[i].fd, EVIOCGRAB, 0);
+            close(self->event_polls[i].fd);
+        }
         free(self->event_extra_data[i].key_states);
         free(self->event_extra_data[i].key_presses_grabbed);
     }
@@ -707,8 +711,11 @@ static void keyboard_event_parse_stdin_command(keyboard_event *self, const char
         }
         self->num_global_hotkeys = 0;
         fprintf(stderr, "Info: unbinded all hotkeys\n");
+    } else if(strncmp(command, "exit", 4) == 0) {
+        self->stdin_failed = true;
+        fprintf(stderr, "Info: received exit command\n");
     } else {
-        fprintf(stderr, "Warning: got invalid command: \"%s\", expected command to start with either \"bind\" or \"unbind_all\"\n", command);
+        fprintf(stderr, "Warning: got invalid command: \"%s\", expected command to start with either \"bind\", \"unbind_all\" or \"exit\"\n", command);
     }
 }
 

tools/gsr-ui-cli/main.c

@@ -56,6 +56,10 @@ static void usage(void) {
     printf("      Start/stop replay.\n");
     printf("  replay-save\n");
     printf("      Save replay.\n");
+    printf("  replay-save-1-min\n");
+    printf("      Save 1 minute replay.\n");
+    printf("  replay-save-10-min\n");
+    printf("      Save 10 minute replay.\n");
     printf("  take-screenshot\n");
     printf("      Take a screenshot.\n");
     printf("  take-screenshot-region\n");
@@ -75,6 +79,8 @@ static bool is_valid_command(const char *command) {
         "toggle-stream",
         "toggle-replay",
         "replay-save",
+        "replay-save-1-min",
+        "replay-save-10-min",
         "take-screenshot",
         "take-screenshot-region",
         NULL