13 files changed, 177 insertions, 111 deletions

diff --git a/src/common/settings.h b/src/common/settings.h
index 16749ab68..f1b1add56 100644
--- a/src/common/settings.h
+++ b/src/common/settings.h
@@ -134,12 +134,12 @@ struct Values {
     Linkage linkage{};
 
     // Audio
-    Setting<AudioEngine> sink_id{linkage, AudioEngine::Auto, "output_engine", Category::Audio,
-                                 Specialization::RuntimeList};
-    Setting<std::string> audio_output_device_id{linkage, "auto", "output_device", Category::Audio,
-                                                Specialization::RuntimeList};
-    Setting<std::string> audio_input_device_id{linkage, "auto", "input_device", Category::Audio,
-                                               Specialization::RuntimeList};
+    SwitchableSetting<AudioEngine> sink_id{linkage, AudioEngine::Auto, "output_engine",
+                                           Category::Audio, Specialization::RuntimeList};
+    SwitchableSetting<std::string> audio_output_device_id{
+        linkage, "auto", "output_device", Category::Audio, Specialization::RuntimeList};
+    SwitchableSetting<std::string> audio_input_device_id{
+        linkage, "auto", "input_device", Category::Audio, Specialization::RuntimeList};
     SwitchableSetting<AudioMode, true> sound_index{
         linkage,       AudioMode::Stereo,     AudioMode::Mono,         AudioMode::Surround,
         "sound_index", Category::SystemAudio, Specialization::Default, true,
diff --git a/src/core/hle/service/aoc/aoc_u.cpp b/src/core/hle/service/aoc/aoc_u.cpp
index 7075ab800..486719cc0 100644
--- a/src/core/hle/service/aoc/aoc_u.cpp
+++ b/src/core/hle/service/aoc/aoc_u.cpp
@@ -202,7 +202,7 @@ void AOC_U::ListAddOnContent(HLERequestContext& ctx) {
     LOG_DEBUG(Service_AOC, "called with offset={}, count={}, process_id={}", offset, count,
               process_id);
 
-    const auto current = system.GetApplicationProcessProgramID();
+    const auto current = FileSys::GetBaseTitleID(system.GetApplicationProcessProgramID());
 
     std::vector<u32> out;
     const auto& disabled = Settings::values.disabled_addons[current];
diff --git a/src/core/hle/service/glue/time/time_zone.cpp b/src/core/hle/service/glue/time/time_zone.cpp
index 5dc1187cb..98d928697 100644
--- a/src/core/hle/service/glue/time/time_zone.cpp
+++ b/src/core/hle/service/glue/time/time_zone.cpp
@@ -197,32 +197,27 @@ Result TimeZoneService::ToCalendarTimeWithMyRule(
 
 Result TimeZoneService::ToPosixTime(Out<u32> out_count,
                                     OutArray<s64, BufferAttr_HipcPointer> out_times,
-                                    Out<u32> out_times_count,
-                                    Service::PSC::Time::CalendarTime& calendar_time, InRule rule) {
+                                    const Service::PSC::Time::CalendarTime& calendar_time,
+                                    InRule rule) {
     SCOPE_EXIT({
         LOG_DEBUG(Service_Time,
-                  "called. calendar_time={} out_count={} out_times[0]={} out_times[1]={} "
-                  "out_times_count={}",
-                  calendar_time, *out_count, out_times[0], out_times[1], *out_times_count);
+                  "called. calendar_time={} out_count={} out_times[0]={} out_times[1]={}",
+                  calendar_time, *out_count, out_times[0], out_times[1]);
     });
 
-    R_RETURN(
-        m_wrapped_service->ToPosixTime(out_count, out_times, out_times_count, calendar_time, rule));
+    R_RETURN(m_wrapped_service->ToPosixTime(out_count, out_times, calendar_time, rule));
 }
 
-Result TimeZoneService::ToPosixTimeWithMyRule(Out<u32> out_count,
-                                              OutArray<s64, BufferAttr_HipcPointer> out_times,
-                                              Out<u32> out_times_count,
-                                              Service::PSC::Time::CalendarTime& calendar_time) {
+Result TimeZoneService::ToPosixTimeWithMyRule(
+    Out<u32> out_count, OutArray<s64, BufferAttr_HipcPointer> out_times,
+    const Service::PSC::Time::CalendarTime& calendar_time) {
     SCOPE_EXIT({
         LOG_DEBUG(Service_Time,
-                  "called. calendar_time={} out_count={} out_times[0]={} out_times[1]={} "
-                  "out_times_count={}",
-                  calendar_time, *out_count, out_times[0], out_times[1], *out_times_count);
+                  "called. calendar_time={} out_count={} out_times[0]={} out_times[1]={}",
+                  calendar_time, *out_count, out_times[0], out_times[1]);
     });
 
-    R_RETURN(m_wrapped_service->ToPosixTimeWithMyRule(out_count, out_times, out_times_count,
-                                                      calendar_time));
+    R_RETURN(m_wrapped_service->ToPosixTimeWithMyRule(out_count, out_times, calendar_time));
 }
 
 } // namespace Service::Glue::Time
diff --git a/src/core/hle/service/glue/time/time_zone.h b/src/core/hle/service/glue/time/time_zone.h
index bf12adbdc..9c1530966 100644
--- a/src/core/hle/service/glue/time/time_zone.h
+++ b/src/core/hle/service/glue/time/time_zone.h
@@ -68,12 +68,10 @@ public:
         Out<Service::PSC::Time::CalendarTime> out_calendar_time,
         Out<Service::PSC::Time::CalendarAdditionalInfo> out_additional_info, s64 time);
     Result ToPosixTime(Out<u32> out_count, OutArray<s64, BufferAttr_HipcPointer> out_times,
-                       Out<u32> out_times_count, Service::PSC::Time::CalendarTime& calendar_time,
-                       InRule rule);
+                       const Service::PSC::Time::CalendarTime& calendar_time, InRule rule);
     Result ToPosixTimeWithMyRule(Out<u32> out_count,
                                  OutArray<s64, BufferAttr_HipcPointer> out_times,
-                                 Out<u32> out_times_count,
-                                 Service::PSC::Time::CalendarTime& calendar_time);
+                                 const Service::PSC::Time::CalendarTime& calendar_time);
 
 private:
     Core::System& m_system;
diff --git a/src/core/hle/service/psc/time/common.h b/src/core/hle/service/psc/time/common.h
index 596828b8b..3e13144a0 100644
--- a/src/core/hle/service/psc/time/common.h
+++ b/src/core/hle/service/psc/time/common.h
@@ -189,7 +189,7 @@ struct fmt::formatter<Service::PSC::Time::SteadyClockTimePoint> : fmt::formatter
     template <typename FormatContext>
     auto format(const Service::PSC::Time::SteadyClockTimePoint& time_point,
                 FormatContext& ctx) const {
-        return fmt::format_to(ctx.out(), "time_point={}", time_point.time_point);
+        return fmt::format_to(ctx.out(), "[time_point={}]", time_point.time_point);
     }
 };
 
@@ -197,7 +197,7 @@ template <>
 struct fmt::formatter<Service::PSC::Time::SystemClockContext> : fmt::formatter<fmt::string_view> {
     template <typename FormatContext>
     auto format(const Service::PSC::Time::SystemClockContext& context, FormatContext& ctx) const {
-        return fmt::format_to(ctx.out(), "offset={} steady_time_point={}", context.offset,
+        return fmt::format_to(ctx.out(), "[offset={} steady_time_point={}]", context.offset,
                               context.steady_time_point.time_point);
     }
 };
@@ -206,8 +206,9 @@ template <>
 struct fmt::formatter<Service::PSC::Time::CalendarTime> : fmt::formatter<fmt::string_view> {
     template <typename FormatContext>
     auto format(const Service::PSC::Time::CalendarTime& calendar, FormatContext& ctx) const {
-        return fmt::format_to(ctx.out(), "{}/{}/{} {}:{}:{}", calendar.day, calendar.month,
-                              calendar.year, calendar.hour, calendar.minute, calendar.second);
+        return fmt::format_to(ctx.out(), "[{:02}/{:02}/{:04} {:02}:{:02}:{:02}]", calendar.day,
+                              calendar.month, calendar.year, calendar.hour, calendar.minute,
+                              calendar.second);
     }
 };
 
@@ -217,7 +218,7 @@ struct fmt::formatter<Service::PSC::Time::CalendarAdditionalInfo>
     template <typename FormatContext>
     auto format(const Service::PSC::Time::CalendarAdditionalInfo& additional,
                 FormatContext& ctx) const {
-        return fmt::format_to(ctx.out(), "weekday={} yearday={} name={} is_dst={} ut_offset={}",
+        return fmt::format_to(ctx.out(), "[weekday={} yearday={} name={} is_dst={} ut_offset={}]",
                               additional.day_of_week, additional.day_of_year,
                               additional.name.data(), additional.is_dst, additional.ut_offset);
     }
@@ -227,8 +228,7 @@ template <>
 struct fmt::formatter<Service::PSC::Time::LocationName> : fmt::formatter<fmt::string_view> {
     template <typename FormatContext>
     auto format(const Service::PSC::Time::LocationName& name, FormatContext& ctx) const {
-        std::string_view n{name.data(), name.size()};
-        return formatter<string_view>::format(n, ctx);
+        return formatter<string_view>::format(name.data(), ctx);
     }
 };
 
@@ -236,8 +236,7 @@ template <>
 struct fmt::formatter<Service::PSC::Time::RuleVersion> : fmt::formatter<fmt::string_view> {
     template <typename FormatContext>
     auto format(const Service::PSC::Time::RuleVersion& version, FormatContext& ctx) const {
-        std::string_view v{version.data(), version.size()};
-        return formatter<string_view>::format(v, ctx);
+        return formatter<string_view>::format(version.data(), ctx);
     }
 };
 
@@ -247,10 +246,11 @@ struct fmt::formatter<Service::PSC::Time::ClockSnapshot> : fmt::formatter<fmt::s
     auto format(const Service::PSC::Time::ClockSnapshot& snapshot, FormatContext& ctx) const {
         return fmt::format_to(
             ctx.out(),
-            "user_context={} network_context={} user_time={} network_time={} user_calendar_time={} "
+            "[user_context={} network_context={} user_time={} network_time={} "
+            "user_calendar_time={} "
             "network_calendar_time={} user_calendar_additional_time={} "
             "network_calendar_additional_time={} steady_clock_time_point={} location={} "
-            "is_automatic_correction_enabled={} type={}",
+            "is_automatic_correction_enabled={} type={}]",
             snapshot.user_context, snapshot.network_context, snapshot.user_time,
             snapshot.network_time, snapshot.user_calendar_time, snapshot.network_calendar_time,
             snapshot.user_calendar_additional_time, snapshot.network_calendar_additional_time,
@@ -266,7 +266,7 @@ struct fmt::formatter<Service::PSC::Time::ContinuousAdjustmentTimePoint>
     auto format(const Service::PSC::Time::ContinuousAdjustmentTimePoint& time_point,
                 FormatContext& ctx) const {
         return fmt::format_to(ctx.out(),
-                              "rtc_offset={} diff_scale={} shift_amount={} lower={} upper={}",
+                              "[rtc_offset={} diff_scale={} shift_amount={} lower={} upper={}]",
                               time_point.rtc_offset, time_point.diff_scale, time_point.shift_amount,
                               time_point.lower, time_point.upper);
     }
diff --git a/src/core/hle/service/psc/time/service_manager.cpp b/src/core/hle/service/psc/time/service_manager.cpp
index ec906b723..4e1643fcb 100644
--- a/src/core/hle/service/psc/time/service_manager.cpp
+++ b/src/core/hle/service/psc/time/service_manager.cpp
@@ -120,11 +120,8 @@ Result ServiceManager::SetupStandardNetworkSystemClockCore(SystemClockContext& c
               context, context.steady_time_point.clock_source_id.RawString(), accuracy);
 
     // TODO this is a hack! The network clock should be updated independently, from the ntc service
-    // and maybe elsewhere. We do not do that, so fix the clock to the local clock on first boot
-    // to avoid it being stuck at 0.
-    if (context == Service::PSC::Time::SystemClockContext{}) {
-        m_local_system_clock.GetContext(context);
-    }
+    // and maybe elsewhere. We do not do that, so fix the clock to the local clock.
+    m_local_system_clock.GetContext(context);
 
     m_network_system_clock.SetContextWriter(m_network_system_context_writer);
     m_network_system_clock.Initialize(context, accuracy);
@@ -138,13 +135,6 @@ Result ServiceManager::SetupStandardUserSystemClockCore(bool automatic_correctio
     LOG_DEBUG(Service_Time, "called. automatic_correction={} time_point={} clock_source_id={}",
               automatic_correction, time_point, time_point.clock_source_id.RawString());
 
-    // TODO this is a hack! The user clock should be updated independently, from the ntc service
-    // and maybe elsewhere. We do not do that, so fix the clock to the local clock on first boot
-    // to avoid it being stuck at 0.
-    if (time_point == Service::PSC::Time::SteadyClockTimePoint{}) {
-        m_local_system_clock.GetCurrentTimePoint(time_point);
-    }
-
     m_user_system_clock.SetAutomaticCorrection(automatic_correction);
     m_user_system_clock.SetTimePointAndSignal(time_point);
     m_user_system_clock.SetInitialized();
diff --git a/src/core/hle/service/psc/time/time_zone.cpp b/src/core/hle/service/psc/time/time_zone.cpp
index 82ddba42f..cc855c763 100644
--- a/src/core/hle/service/psc/time/time_zone.cpp
+++ b/src/core/hle/service/psc/time/time_zone.cpp
@@ -140,11 +140,11 @@ Result TimeZone::ParseBinaryInto(Tz::Rule& out_rule, std::span<const u8> binary)
     R_RETURN(ParseBinaryImpl(out_rule, binary));
 }
 
-Result TimeZone::ToPosixTime(u32& out_count, std::span<s64> out_times, u32 out_times_count,
-                             CalendarTime& calendar, const Tz::Rule& rule) {
+Result TimeZone::ToPosixTime(u32& out_count, std::span<s64> out_times, size_t out_times_max_count,
+                             const CalendarTime& calendar, const Tz::Rule& rule) {
     std::scoped_lock l{m_mutex};
 
-    auto res = ToPosixTimeImpl(out_count, out_times, out_times_count, calendar, rule, -1);
+    auto res = ToPosixTimeImpl(out_count, out_times, out_times_max_count, calendar, rule, -1);
 
     if (res != ResultSuccess) {
         if (res == ResultTimeZoneNotFound) {
@@ -158,10 +158,10 @@ Result TimeZone::ToPosixTime(u32& out_count, std::span<s64> out_times, u32 out_t
 }
 
 Result TimeZone::ToPosixTimeWithMyRule(u32& out_count, std::span<s64> out_times,
-                                       u32 out_times_count, CalendarTime& calendar) {
+                                       size_t out_times_max_count, const CalendarTime& calendar) {
     std::scoped_lock l{m_mutex};
 
-    auto res = ToPosixTimeImpl(out_count, out_times, out_times_count, calendar, m_my_rule, -1);
+    auto res = ToPosixTimeImpl(out_count, out_times, out_times_max_count, calendar, m_my_rule, -1);
 
     if (res != ResultSuccess) {
         if (res == ResultTimeZoneNotFound) {
@@ -212,20 +212,23 @@ Result TimeZone::ToCalendarTimeImpl(CalendarTime& out_calendar_time,
     R_SUCCEED();
 }
 
-Result TimeZone::ToPosixTimeImpl(u32& out_count, std::span<s64> out_times, u32 out_times_count,
-                                 CalendarTime& calendar, const Tz::Rule& rule, s32 is_dst) {
+Result TimeZone::ToPosixTimeImpl(u32& out_count, std::span<s64> out_times,
+                                 size_t out_times_max_count, const CalendarTime& calendar,
+                                 const Tz::Rule& rule, s32 is_dst) {
     R_TRY(ValidateRule(rule));
 
-    calendar.month -= 1;
-    calendar.year -= 1900;
+    CalendarTime local_calendar{calendar};
+
+    local_calendar.month -= 1;
+    local_calendar.year -= 1900;
 
     Tz::CalendarTimeInternal internal{
-        .tm_sec = calendar.second,
-        .tm_min = calendar.minute,
-        .tm_hour = calendar.hour,
-        .tm_mday = calendar.day,
-        .tm_mon = calendar.month,
-        .tm_year = calendar.year,
+        .tm_sec = local_calendar.second,
+        .tm_min = local_calendar.minute,
+        .tm_hour = local_calendar.hour,
+        .tm_mday = local_calendar.day,
+        .tm_mon = local_calendar.month,
+        .tm_year = local_calendar.year,
         .tm_wday = 0,
         .tm_yday = 0,
         .tm_isdst = is_dst,
@@ -243,9 +246,9 @@ Result TimeZone::ToPosixTimeImpl(u32& out_count, std::span<s64> out_times, u32 o
         R_RETURN(ResultTimeZoneNotFound);
     }
 
-    if (internal.tm_sec != calendar.second || internal.tm_min != calendar.minute ||
-        internal.tm_hour != calendar.hour || internal.tm_mday != calendar.day ||
-        internal.tm_mon != calendar.month || internal.tm_year != calendar.year) {
+    if (internal.tm_sec != local_calendar.second || internal.tm_min != local_calendar.minute ||
+        internal.tm_hour != local_calendar.hour || internal.tm_mday != local_calendar.day ||
+        internal.tm_mon != local_calendar.month || internal.tm_year != local_calendar.year) {
         R_RETURN(ResultTimeZoneNotFound);
     }
 
@@ -254,7 +257,7 @@ Result TimeZone::ToPosixTimeImpl(u32& out_count, std::span<s64> out_times, u32 o
     }
 
     out_times[0] = time;
-    if (out_times_count < 2) {
+    if (out_times_max_count < 2) {
         out_count = 1;
         R_SUCCEED();
     }
diff --git a/src/core/hle/service/psc/time/time_zone.h b/src/core/hle/service/psc/time/time_zone.h
index 6bd8f2fda..6248e45f9 100644
--- a/src/core/hle/service/psc/time/time_zone.h
+++ b/src/core/hle/service/psc/time/time_zone.h
@@ -38,18 +38,18 @@ public:
                                     CalendarAdditionalInfo& calendar_additional, s64 time);
     Result ParseBinary(LocationName& name, std::span<const u8> binary);
     Result ParseBinaryInto(Tz::Rule& out_rule, std::span<const u8> binary);
-    Result ToPosixTime(u32& out_count, std::span<s64> out_times, u32 out_times_count,
-                       CalendarTime& calendar, const Tz::Rule& rule);
-    Result ToPosixTimeWithMyRule(u32& out_count, std::span<s64> out_times, u32 out_times_count,
-                                 CalendarTime& calendar);
+    Result ToPosixTime(u32& out_count, std::span<s64> out_times, size_t out_times_max_count,
+                       const CalendarTime& calendar, const Tz::Rule& rule);
+    Result ToPosixTimeWithMyRule(u32& out_count, std::span<s64> out_times,
+                                 size_t out_times_max_count, const CalendarTime& calendar);
 
 private:
     Result ParseBinaryImpl(Tz::Rule& out_rule, std::span<const u8> binary);
     Result ToCalendarTimeImpl(CalendarTime& out_calendar_time,
                               CalendarAdditionalInfo& out_additional_info, s64 time,
                               const Tz::Rule& rule);
-    Result ToPosixTimeImpl(u32& out_count, std::span<s64> out_times, u32 out_times_count,
-                           CalendarTime& calendar, const Tz::Rule& rule, s32 is_dst);
+    Result ToPosixTimeImpl(u32& out_count, std::span<s64> out_times, size_t out_times_max_count,
+                           const CalendarTime& calendar, const Tz::Rule& rule, s32 is_dst);
 
     bool m_initialized{};
     std::recursive_mutex m_mutex;
diff --git a/src/core/hle/service/psc/time/time_zone_service.cpp b/src/core/hle/service/psc/time/time_zone_service.cpp
index 9376a0324..eb81f5b03 100644
--- a/src/core/hle/service/psc/time/time_zone_service.cpp
+++ b/src/core/hle/service/psc/time/time_zone_service.cpp
@@ -138,32 +138,28 @@ Result TimeZoneService::ToCalendarTimeWithMyRule(Out<CalendarTime> out_calendar_
 
 Result TimeZoneService::ToPosixTime(Out<u32> out_count,
                                     OutArray<s64, BufferAttr_HipcPointer> out_times,
-                                    Out<u32> out_times_count, CalendarTime& calendar_time,
-                                    InRule rule) {
+                                    const CalendarTime& calendar_time, InRule rule) {
     SCOPE_EXIT({
         LOG_DEBUG(Service_Time,
-                  "called. calendar_time={} out_count={} out_times[0]={} out_times[1]={} "
-                  "out_times_count={}",
-                  calendar_time, *out_count, out_times[0], out_times[1], *out_times_count);
+                  "called. calendar_time={} out_count={} out_times[0]={} out_times[1]={} ",
+                  calendar_time, *out_count, out_times[0], out_times[1]);
     });
 
     R_RETURN(
-        m_time_zone.ToPosixTime(*out_count, out_times, *out_times_count, calendar_time, *rule));
+        m_time_zone.ToPosixTime(*out_count, out_times, out_times.size(), calendar_time, *rule));
 }
 
 Result TimeZoneService::ToPosixTimeWithMyRule(Out<u32> out_count,
                                               OutArray<s64, BufferAttr_HipcPointer> out_times,
-                                              Out<u32> out_times_count,
-                                              CalendarTime& calendar_time) {
+                                              const CalendarTime& calendar_time) {
     SCOPE_EXIT({
         LOG_DEBUG(Service_Time,
-                  "called. calendar_time={} out_count={} out_times[0]={} out_times[1]={} "
-                  "out_times_count={}",
-                  calendar_time, *out_count, out_times[0], out_times[1], *out_times_count);
+                  "called. calendar_time={} out_count={} out_times[0]={} out_times[1]={} ",
+                  calendar_time, *out_count, out_times[0], out_times[1]);
     });
 
     R_RETURN(
-        m_time_zone.ToPosixTimeWithMyRule(*out_count, out_times, *out_times_count, calendar_time));
+        m_time_zone.ToPosixTimeWithMyRule(*out_count, out_times, out_times.size(), calendar_time));
 }
 
 } // namespace Service::PSC::Time
diff --git a/src/core/hle/service/psc/time/time_zone_service.h b/src/core/hle/service/psc/time/time_zone_service.h
index 084e3f907..6eb9ddc4b 100644
--- a/src/core/hle/service/psc/time/time_zone_service.h
+++ b/src/core/hle/service/psc/time/time_zone_service.h
@@ -50,10 +50,10 @@ public:
     Result ToCalendarTimeWithMyRule(Out<CalendarTime> out_calendar_time,
                                     Out<CalendarAdditionalInfo> out_additional_info, s64 time);
     Result ToPosixTime(Out<u32> out_count, OutArray<s64, BufferAttr_HipcPointer> out_times,
-                       Out<u32> out_times_count, CalendarTime& calendar_time, InRule rule);
+                       const CalendarTime& calendar_time, InRule rule);
     Result ToPosixTimeWithMyRule(Out<u32> out_count,
                                  OutArray<s64, BufferAttr_HipcPointer> out_times,
-                                 Out<u32> out_times_count, CalendarTime& calendar_time);
+                                 const CalendarTime& calendar_time);
 
 private:
     Core::System& m_system;
diff --git a/src/core/hle/service/set/system_settings_server.cpp b/src/core/hle/service/set/system_settings_server.cpp
index 100cb2db4..d3d0fb112 100644
--- a/src/core/hle/service/set/system_settings_server.cpp
+++ b/src/core/hle/service/set/system_settings_server.cpp
@@ -25,7 +25,7 @@
 namespace Service::Set {
 
 namespace {
-constexpr u32 SETTINGS_VERSION{2u};
+constexpr u32 SETTINGS_VERSION{3u};
 constexpr auto SETTINGS_MAGIC = Common::MakeMagic('y', 'u', 'z', 'u', '_', 's', 'e', 't');
 struct SettingsHeader {
     u64 magic;
diff --git a/src/yuzu/configuration/configure_audio.cpp b/src/yuzu/configuration/configure_audio.cpp
index 9b6ef47a7..c235b0fca 100644
--- a/src/yuzu/configuration/configure_audio.cpp
+++ b/src/yuzu/configuration/configure_audio.cpp
@@ -5,6 +5,7 @@
 #include <memory>
 #include <vector>
 #include <QComboBox>
+#include <QPushButton>
 
 #include "audio_core/sink/sink.h"
 #include "audio_core/sink/sink_details.h"
@@ -67,19 +68,99 @@ void ConfigureAudio::Setup(const ConfigurationShared::Builder& builder) {
 
         hold.emplace(std::pair{setting->Id(), widget});
 
+        auto global_sink_match = [this] {
+            return static_cast<Settings::AudioEngine>(sink_combo_box->currentIndex()) ==
+                   Settings::values.sink_id.GetValue(true);
+        };
         if (setting->Id() == Settings::values.sink_id.Id()) {
             // TODO (lat9nq): Let the system manage sink_id
             sink_combo_box = widget->combobox;
             InitializeAudioSinkComboBox();
 
-            connect(sink_combo_box, qOverload<int>(&QComboBox::currentIndexChanged), this,
-                    &ConfigureAudio::UpdateAudioDevices);
+            if (Settings::IsConfiguringGlobal()) {
+                connect(sink_combo_box, qOverload<int>(&QComboBox::currentIndexChanged), this,
+                        &ConfigureAudio::UpdateAudioDevices);
+            } else {
+                restore_sink_button = ConfigurationShared::Widget::CreateRestoreGlobalButton(
+                    Settings::values.sink_id.UsingGlobal(), widget);
+                widget->layout()->addWidget(restore_sink_button);
+                connect(restore_sink_button, &QAbstractButton::clicked, [this](bool) {
+                    Settings::values.sink_id.SetGlobal(true);
+                    const int sink_index = static_cast<int>(Settings::values.sink_id.GetValue());
+                    sink_combo_box->setCurrentIndex(sink_index);
+                    ConfigureAudio::UpdateAudioDevices(sink_index);
+                    Settings::values.audio_output_device_id.SetGlobal(true);
+                    Settings::values.audio_input_device_id.SetGlobal(true);
+                    restore_sink_button->setVisible(false);
+                });
+                connect(sink_combo_box, qOverload<int>(&QComboBox::currentIndexChanged),
+                        [this, global_sink_match](const int slot) {
+                            Settings::values.sink_id.SetGlobal(false);
+                            Settings::values.audio_output_device_id.SetGlobal(false);
+                            Settings::values.audio_input_device_id.SetGlobal(false);
+
+                            restore_sink_button->setVisible(true);
+                            restore_sink_button->setEnabled(true);
+                            output_device_combo_box->setCurrentIndex(0);
+                            restore_output_device_button->setVisible(true);
+                            restore_output_device_button->setEnabled(global_sink_match());
+                            input_device_combo_box->setCurrentIndex(0);
+                            restore_input_device_button->setVisible(true);
+                            restore_input_device_button->setEnabled(global_sink_match());
+                            ConfigureAudio::UpdateAudioDevices(slot);
+                        });
+            }
         } else if (setting->Id() == Settings::values.audio_output_device_id.Id()) {
             // Keep track of output (and input) device comboboxes to populate them with system
             // devices, which are determined at run time
             output_device_combo_box = widget->combobox;
+
+            if (!Settings::IsConfiguringGlobal()) {
+                restore_output_device_button =
+                    ConfigurationShared::Widget::CreateRestoreGlobalButton(
+                        Settings::values.audio_output_device_id.UsingGlobal(), widget);
+                restore_output_device_button->setEnabled(global_sink_match());
+                restore_output_device_button->setVisible(
+                    !Settings::values.audio_output_device_id.UsingGlobal());
+                widget->layout()->addWidget(restore_output_device_button);
+                connect(restore_output_device_button, &QAbstractButton::clicked, [this](bool) {
+                    Settings::values.audio_output_device_id.SetGlobal(true);
+                    SetOutputDevicesFromDeviceID();
+                    restore_output_device_button->setVisible(false);
+                });
+                connect(output_device_combo_box, qOverload<int>(&QComboBox::currentIndexChanged),
+                        [this, global_sink_match](int) {
+                            if (updating_devices) {
+                                return;
+                            }
+                            Settings::values.audio_output_device_id.SetGlobal(false);
+                            restore_output_device_button->setVisible(true);
+                            restore_output_device_button->setEnabled(global_sink_match());
+                        });
+            }
         } else if (setting->Id() == Settings::values.audio_input_device_id.Id()) {
             input_device_combo_box = widget->combobox;
+
+            if (!Settings::IsConfiguringGlobal()) {
+                restore_input_device_button =
+                    ConfigurationShared::Widget::CreateRestoreGlobalButton(
+                        Settings::values.audio_input_device_id.UsingGlobal(), widget);
+                widget->layout()->addWidget(restore_input_device_button);
+                connect(restore_input_device_button, &QAbstractButton::clicked, [this](bool) {
+                    Settings::values.audio_input_device_id.SetGlobal(true);
+                    SetInputDevicesFromDeviceID();
+                    restore_input_device_button->setVisible(false);
+                });
+                connect(input_device_combo_box, qOverload<int>(&QComboBox::currentIndexChanged),
+                        [this, global_sink_match](int) {
+                            if (updating_devices) {
+                                return;
+                            }
+                            Settings::values.audio_input_device_id.SetGlobal(false);
+                            restore_input_device_button->setVisible(true);
+                            restore_input_device_button->setEnabled(global_sink_match());
+                        });
+            }
         }
     }
 
@@ -89,16 +170,13 @@ void ConfigureAudio::Setup(const ConfigurationShared::Builder& builder) {
 }
 
 void ConfigureAudio::SetConfiguration() {
-    if (!Settings::IsConfiguringGlobal()) {
-        return;
-    }
-
     SetOutputSinkFromSinkID();
 
     // The device list cannot be pre-populated (nor listed) until the output sink is known.
     UpdateAudioDevices(sink_combo_box->currentIndex());
 
-    SetAudioDevicesFromDeviceID();
+    SetOutputDevicesFromDeviceID();
+    SetInputDevicesFromDeviceID();
 }
 
 void ConfigureAudio::SetOutputSinkFromSinkID() {
@@ -116,8 +194,8 @@ void ConfigureAudio::SetOutputSinkFromSinkID() {
     sink_combo_box->setCurrentIndex(new_sink_index);
 }
 
-void ConfigureAudio::SetAudioDevicesFromDeviceID() {
-    int new_device_index = -1;
+void ConfigureAudio::SetOutputDevicesFromDeviceID() {
+    int new_device_index = 0;
 
     const QString output_device_id =
         QString::fromStdString(Settings::values.audio_output_device_id.GetValue());
@@ -129,8 +207,10 @@ void ConfigureAudio::SetAudioDevicesFromDeviceID() {
     }
 
     output_device_combo_box->setCurrentIndex(new_device_index);
+}
 
-    new_device_index = -1;
+void ConfigureAudio::SetInputDevicesFromDeviceID() {
+    int new_device_index = 0;
     const QString input_device_id =
         QString::fromStdString(Settings::values.audio_input_device_id.GetValue());
     for (int index = 0; index < input_device_combo_box->count(); index++) {
@@ -149,15 +229,12 @@ void ConfigureAudio::ApplyConfiguration() {
         apply_func(is_powered_on);
     }
 
-    if (Settings::IsConfiguringGlobal()) {
-        Settings::values.sink_id.LoadString(
-            sink_combo_box->itemText(sink_combo_box->currentIndex()).toStdString());
-        Settings::values.audio_output_device_id.SetValue(
-            output_device_combo_box->itemText(output_device_combo_box->currentIndex())
-                .toStdString());
-        Settings::values.audio_input_device_id.SetValue(
-            input_device_combo_box->itemText(input_device_combo_box->currentIndex()).toStdString());
-    }
+    Settings::values.sink_id.LoadString(
+        sink_combo_box->itemText(sink_combo_box->currentIndex()).toStdString());
+    Settings::values.audio_output_device_id.SetValue(
+        output_device_combo_box->itemText(output_device_combo_box->currentIndex()).toStdString());
+    Settings::values.audio_input_device_id.SetValue(
+        input_device_combo_box->itemText(input_device_combo_box->currentIndex()).toStdString());
 }
 
 void ConfigureAudio::changeEvent(QEvent* event) {
@@ -169,6 +246,7 @@ void ConfigureAudio::changeEvent(QEvent* event) {
 }
 
 void ConfigureAudio::UpdateAudioDevices(int sink_index) {
+    updating_devices = true;
     output_device_combo_box->clear();
     output_device_combo_box->addItem(QString::fromUtf8(AudioCore::Sink::auto_device_name));
 
@@ -183,6 +261,7 @@ void ConfigureAudio::UpdateAudioDevices(int sink_index) {
     for (const auto& device : AudioCore::Sink::GetDeviceListForSink(sink_id, true)) {
         input_device_combo_box->addItem(QString::fromStdString(device));
     }
+    updating_devices = false;
 }
 
 void ConfigureAudio::InitializeAudioSinkComboBox() {
diff --git a/src/yuzu/configuration/configure_audio.h b/src/yuzu/configuration/configure_audio.h
index 82d7f6524..32a2fa5f0 100644
--- a/src/yuzu/configuration/configure_audio.h
+++ b/src/yuzu/configuration/configure_audio.h
@@ -45,7 +45,8 @@ private:
     void UpdateAudioDevices(int sink_index);
 
     void SetOutputSinkFromSinkID();
-    void SetAudioDevicesFromDeviceID();
+    void SetOutputDevicesFromDeviceID();
+    void SetInputDevicesFromDeviceID();
 
     void Setup(const ConfigurationShared::Builder& builder);
 
@@ -55,7 +56,11 @@ private:
 
     std::vector<std::function<void(bool)>> apply_funcs{};
 
+    bool updating_devices = false;
     QComboBox* sink_combo_box;
+    QPushButton* restore_sink_button;
     QComboBox* output_device_combo_box;
+    QPushButton* restore_output_device_button;
     QComboBox* input_device_combo_box;
+    QPushButton* restore_input_device_button;
 };