Redesign audio to support multiple audio tracks explicitly

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";

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;

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/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/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();
@@ -125,6 +127,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 +156,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;
@@ -189,6 +188,8 @@ namespace gsr {
         Entry *replay_time_entry_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();
 }