Revert "[hle] constexpr handler dispatch maps, introduce version gating (#4480)" (#4532)

This reverts commit 218c6705d9.

- [x] I have read and followed the [Contribution Guidelines](https://git.eden-emu.dev/eden-emu/eden/src/branch/master/CONTRIBUTING.md#code-contributions).
- [x] I have read and followed the [AI Policy](https://git.eden-emu.dev/eden-emu/eden/src/branch/master/docs/policies/AI.md).
- [x] I have read and followed the [Coding Guidelines](https://git.eden-emu.dev/eden-emu/eden/src/branch/master/docs/policies/Coding.md) to the best of my ability.

-------------------

Reviewed-on: https://git.eden-emu.dev/eden-emu/eden/pulls/4532
Reviewed-by: lizzie <lizzie@eden-emu.dev>
Reviewed-by: CamilleLaVey <camillelavey99@gmail.com>
Reviewed-by: Maufeat <sahyno1996@gmail.com>

src/core/hle/service/audio/audio.cpp

@@ -21,164 +21,164 @@ namespace Service::Audio {
 class IAudioOutManagerForApplet final : public ServiceFramework<IAudioOutManagerForApplet> {
 public:
     explicit IAudioOutManagerForApplet(Core::System& system_)
-        : ServiceFramework{system_, "audout:a"} {}
-
-    static constexpr auto functions = CreateStaticMap(
-            FunctionInfo{0, nullptr, "RequestSuspend"},
-            FunctionInfo{1, nullptr, "RequestResume"},
-            FunctionInfo{2, nullptr, "GetProcessMasterVolume"},
-            FunctionInfo{3, nullptr, "SetProcessMasterVolume"},
-            FunctionInfo{4, nullptr, "GetProcessRecordVolume"},
-            FunctionInfo{5, nullptr, "SetProcessRecordVolume"}
-        );
-    std::optional<FunctionInfoBase> FindRequest(u32 key) override {
-        return HandlerTableGenerateWithFind(key, functions);
+        : ServiceFramework{system_, "audout:a"} {
+        // clang-format off
+        static const FunctionInfo functions[] = {
+            {0, nullptr, "RequestSuspend"},
+            {1, nullptr, "RequestResume"},
+            {2, nullptr, "GetProcessMasterVolume"},
+            {3, nullptr, "SetProcessMasterVolume"},
+            {4, nullptr, "GetProcessRecordVolume"},
+            {5, nullptr, "SetProcessRecordVolume"},
+        };
+        // clang-format on
+        RegisterHandlers(functions);
     }
 };
 
 class IAudioSnoopManager final : public ServiceFramework<IAudioSnoopManager> {
 public:
     explicit IAudioSnoopManager(Core::System& system_)
-        : ServiceFramework{system_, "auddev"} {}
-
-    static constexpr auto functions = CreateStaticMap(
-            FunctionInfo{0, nullptr, "GetDspStatistics"},
-            FunctionInfo{1, nullptr, "GetAppletStateSummaries"},
-            FunctionInfo{2, nullptr, "SetDspStatisticsParameter"},
-            FunctionInfo{3, nullptr, "GetDspStatisticsParameter"},
-            FunctionInfo{6, nullptr, "GetDspUsage"}
-        );
-    std::optional<FunctionInfoBase> FindRequest(u32 key) override {
-        return HandlerTableGenerateWithFind(key, functions);
+        : ServiceFramework{system_, "auddev"} {
+        // clang-format off
+        static const FunctionInfo functions[] = {
+            {0, nullptr, "GetDspStatistics"},
+            {1, nullptr, "GetAppletStateSummaries"},
+            {2, nullptr, "SetDspStatisticsParameter"},
+            {3, nullptr, "GetDspStatisticsParameter"},
+            {6, nullptr, "GetDspUsage"},
+        };
+        // clang-format on
+        RegisterHandlers(functions);
     }
 };
 
 class IAudioInManagerForApplet final : public ServiceFramework<IAudioInManagerForApplet> {
 public:
     explicit IAudioInManagerForApplet(Core::System& system_)
-        : ServiceFramework{system_, "audin:a"} {}
-
-    static constexpr auto functions = CreateStaticMap(
-            FunctionInfo{0, nullptr, "RequestSuspend"},
-            FunctionInfo{1, nullptr, "RequestResume"},
-            FunctionInfo{2, nullptr, "GetProcessMasterVolume"},
-            FunctionInfo{3, nullptr, "SetProcessMasterVolume"}
-        );
-    std::optional<FunctionInfoBase> FindRequest(u32 key) override {
-        return HandlerTableGenerateWithFind(key, functions);
+        : ServiceFramework{system_, "audin:a"} {
+        // clang-format off
+        static const FunctionInfo functions[] = {
+            {0, nullptr, "RequestSuspend"},
+            {1, nullptr, "RequestResume"},
+            {2, nullptr, "GetProcessMasterVolume"},
+            {3, nullptr, "SetProcessMasterVolume"},
+        };
+        // clang-format on
+        RegisterHandlers(functions);
     }
 };
 
 class IAudioRendererManagerForApplet final : public ServiceFramework<IAudioRendererManagerForApplet> {
 public:
     explicit IAudioRendererManagerForApplet(Core::System& system_)
-        : ServiceFramework{system_, "audren:a"} {}
-
-    static constexpr auto functions = CreateStaticMap(
-            FunctionInfo{0, nullptr, "RequestSuspend"},
-            FunctionInfo{1, nullptr, "RequestResume"},
-            FunctionInfo{2, nullptr, "GetProcessMasterVolume"},
-            FunctionInfo{3, nullptr, "SetProcessMasterVolume"},
-            FunctionInfo{4, nullptr, "RegisterAppletResourceUserId"},
-            FunctionInfo{5, nullptr, "UnregisterAppletResourceUserId"},
-            FunctionInfo{6, nullptr, "GetProcessRecordVolume"},
-            FunctionInfo{7, nullptr, "SetProcessRecordVolume"}
-        );
-    std::optional<FunctionInfoBase> FindRequest(u32 key) override {
-        return HandlerTableGenerateWithFind(key, functions);
+        : ServiceFramework{system_, "audren:a"} {
+        // clang-format off
+        static const FunctionInfo functions[] = {
+            {0, nullptr, "RequestSuspend"},
+            {1, nullptr, "RequestResume"},
+            {2, nullptr, "GetProcessMasterVolume"},
+            {3, nullptr, "SetProcessMasterVolume"},
+            {4, nullptr, "RegisterAppletResourceUserId"},
+            {5, nullptr, "UnregisterAppletResourceUserId"},
+            {6, nullptr, "GetProcessRecordVolume"},
+            {7, nullptr, "SetProcessRecordVolume"},
+        };
+        // clang-format on
+        RegisterHandlers(functions);
     }
 };
 
 class IAudioOutManagerForDebugger final : public ServiceFramework<IAudioOutManagerForDebugger> {
 public:
     explicit IAudioOutManagerForDebugger(Core::System& system_)
-        : ServiceFramework{system_, "audout:d"} {}
-
-    static constexpr auto functions = CreateStaticMap(
-            FunctionInfo{0, nullptr, "RequestSuspend"},
-            FunctionInfo{1, nullptr, "RequestResume"}
-        );
-    std::optional<FunctionInfoBase> FindRequest(u32 key) override {
-        return HandlerTableGenerateWithFind(key, functions);
+        : ServiceFramework{system_, "audout:d"} {
+        // clang-format off
+        static const FunctionInfo functions[] = {
+            {0, nullptr, "RequestSuspend"},
+            {1, nullptr, "RequestResume"},
+        };
+        // clang-format on
+        RegisterHandlers(functions);
     }
 };
 
 class IAudioInManagerForDebugger final : public ServiceFramework<IAudioInManagerForDebugger> {
 public:
     explicit IAudioInManagerForDebugger(Core::System& system_)
-        : ServiceFramework{system_, "audin:d"} {}
-
-    static constexpr auto functions = CreateStaticMap(
-            FunctionInfo{0, nullptr, "RequestSuspend"},
-            FunctionInfo{1, nullptr, "RequestResume"}
-        );
-    std::optional<FunctionInfoBase> FindRequest(u32 key) override {
-        return HandlerTableGenerateWithFind(key, functions);
+        : ServiceFramework{system_, "audin:d"} {
+        // clang-format off
+        static const FunctionInfo functions[] = {
+            {0, nullptr, "RequestSuspend"},
+            {1, nullptr, "RequestResume"},
+        };
+        // clang-format on
+        RegisterHandlers(functions);
     }
 };
 
 class IFinalOutputRecorderManagerForDebugger final : public ServiceFramework<IFinalOutputRecorderManagerForDebugger> {
 public:
     explicit IFinalOutputRecorderManagerForDebugger(Core::System& system_)
-        : ServiceFramework{system_, "audrec:d"} {}
-
-    static constexpr auto functions = CreateStaticMap(
-            FunctionInfo{0, nullptr, "RequestSuspend"},
-            FunctionInfo{1, nullptr, "RequestResume"}
-        );
-    std::optional<FunctionInfoBase> FindRequest(u32 key) override {
-        return HandlerTableGenerateWithFind(key, functions);
+        : ServiceFramework{system_, "audrec:d"} {
+        // clang-format off
+        static const FunctionInfo functions[] = {
+            {0, nullptr, "RequestSuspend"},
+            {1, nullptr, "RequestResume"},
+        };
+        // clang-format on
+        RegisterHandlers(functions);
     }
 };
 
 class IAudioRendererManagerForDebugger final : public ServiceFramework<IAudioRendererManagerForDebugger> {
 public:
     explicit IAudioRendererManagerForDebugger(Core::System& system_)
-        : ServiceFramework{system_, "audren:d"} {}
-
-    static constexpr auto functions = CreateStaticMap(
-            FunctionInfo{0, nullptr, "RequestSuspend"},
-            FunctionInfo{1, nullptr, "RequestResume"}
-        );
-    std::optional<FunctionInfoBase> FindRequest(u32 key) override {
-        return HandlerTableGenerateWithFind(key, functions);
+        : ServiceFramework{system_, "audren:d"} {
+        // clang-format off
+        static const FunctionInfo functions[] = {
+            {0, nullptr, "RequestSuspend"},
+            {1, nullptr, "RequestResume"},
+        };
+        // clang-format on
+        RegisterHandlers(functions);
     }
 };
 
 class IAudioSystemManagerForApplet final : public ServiceFramework<IAudioSystemManagerForApplet> {
 public:
     explicit IAudioSystemManagerForApplet(Core::System& system_)
-        : ServiceFramework{system_, "aud:a"} {}
-
-    static constexpr auto functions = CreateStaticMap(
-            FunctionInfo{0, nullptr, "RegisterAppletResourceUserId"},
-            FunctionInfo{1, nullptr, "UnregisterAppletResourceUserId"},
-            FunctionInfo{2, nullptr, "RequestSuspendAudio"},
-            FunctionInfo{3, nullptr, "RequestResumeAudio"},
-            FunctionInfo{4, nullptr, "GetAudioOutputProcessMasterVolume"},
-            FunctionInfo{5, nullptr, "SetAudioOutputProcessMasterVolume"},
-            FunctionInfo{6, nullptr, "GetAudioInputProcessMasterVolume"},
-            FunctionInfo{7, nullptr, "SetAudioInputProcessMasterVolume"},
-            FunctionInfo{8, nullptr, "GetAudioOutputProcessRecordVolume"},
-            FunctionInfo{9, nullptr, "SetAudioOutputProcessRecordVolume"},
-            FunctionInfo{10, nullptr, "GetAppletStateSummaries"}
-        );
-    std::optional<FunctionInfoBase> FindRequest(u32 key) override {
-        return HandlerTableGenerateWithFind(key, functions);
+        : ServiceFramework{system_, "aud:a"} {
+        // clang-format off
+        static const FunctionInfo functions[] = {
+            {0, nullptr, "RegisterAppletResourceUserId"},
+            {1, nullptr, "UnregisterAppletResourceUserId"},
+            {2, nullptr, "RequestSuspendAudio"},
+            {3, nullptr, "RequestResumeAudio"},
+            {4, nullptr, "GetAudioOutputProcessMasterVolume"},
+            {5, nullptr, "SetAudioOutputProcessMasterVolume"},
+            {6, nullptr, "GetAudioInputProcessMasterVolume"},
+            {7, nullptr, "SetAudioInputProcessMasterVolume"},
+            {8, nullptr, "GetAudioOutputProcessRecordVolume"},
+            {9, nullptr, "SetAudioOutputProcessRecordVolume"},
+            {10, nullptr, "GetAppletStateSummaries"},
+        };
+        // clang-format on
+        RegisterHandlers(functions);
     }
 };
 
 class IAudioSystemManagerForDebugger final : public ServiceFramework<IAudioSystemManagerForDebugger> {
 public:
     explicit IAudioSystemManagerForDebugger(Core::System& system_)
-        : ServiceFramework{system_, "aud:d"} {}
-
-    static constexpr auto functions = CreateStaticMap(
-            FunctionInfo{0, nullptr, "RequestSuspendAudioForDebug"},
-            FunctionInfo{1, nullptr, "RequestResumeAudioForDebug"}
-        );
-    std::optional<FunctionInfoBase> FindRequest(u32 key) override {
-        return HandlerTableGenerateWithFind(key, functions);
+        : ServiceFramework{system_, "aud:d"} {
+        // clang-format off
+        static const FunctionInfo functions[] = {
+            {0, nullptr, "RequestSuspendAudioForDebug"},
+            {1, nullptr, "RequestResumeAudioForDebug"},
+        };
+        // clang-format on
+        RegisterHandlers(functions);
     }
 };
 

src/core/hle/service/audio/audio.h

@@ -1,3 +1,6 @@
+// SPDX-FileCopyrightText: Copyright 2026 Eden Emulator Project
+// SPDX-License-Identifier: GPL-3.0-or-later
+
 // SPDX-FileCopyrightText: Copyright 2018 yuzu Emulator Project
 // SPDX-License-Identifier: GPL-2.0-or-later
 

src/core/hle/service/audio/audio_controller.cpp

@@ -1,9 +1,6 @@
 // SPDX-FileCopyrightText: Copyright 2026 Eden Emulator Project
 // SPDX-License-Identifier: GPL-3.0-or-later
 
-// SPDX-FileCopyrightText: Copyright 2026 Eden Emulator Project
-// SPDX-License-Identifier: GPL-3.0-or-later
-
 // SPDX-FileCopyrightText: Copyright 2018 yuzu Emulator Project
 // SPDX-License-Identifier: GPL-2.0-or-later
 
@@ -20,75 +17,77 @@
 
 namespace Service::Audio {
 
-std::optional<ServiceFrameworkBase::FunctionInfoBase> IAudioController::FindRequest(u32 key) {
-    static constexpr auto functions = CreateStaticMap(
-        FunctionInfo{0, D<&IAudioController::GetTargetVolume>, "GetTargetVolume"},
-        FunctionInfo{1, D<&IAudioController::SetTargetVolume>, "SetTargetVolume"},
-        FunctionInfo{2, D<&IAudioController::GetTargetVolumeMin>, "GetTargetVolumeMin"},
-        FunctionInfo{3, D<&IAudioController::GetTargetVolumeMax>, "GetTargetVolumeMax"},
-        FunctionInfo{4, D<&IAudioController::IsTargetMute>, "IsTargetMute"},
-        FunctionInfo{5, D<&IAudioController::SetTargetMute>, "SetTargetMute"},
-        FunctionInfo{6, nullptr, "IsTargetConnected", MakeVersionGate({20,0,0})},
-        FunctionInfo{7, nullptr, "SetDefaultTarget"},
-        FunctionInfo{8, nullptr, "GetDefaultTarget"},
-        FunctionInfo{9, D<&IAudioController::GetAudioOutputMode>, "GetAudioOutputMode"},
-        FunctionInfo{10, D<&IAudioController::SetAudioOutputMode>, "SetAudioOutputMode"},
-        FunctionInfo{11, nullptr, "SetForceMutePolicy"},
-        FunctionInfo{12, D<&IAudioController::GetForceMutePolicy>, "GetForceMutePolicy"},
-        FunctionInfo{13, D<&IAudioController::GetOutputModeSetting>, "GetOutputModeSetting"},
-        FunctionInfo{14, D<&IAudioController::SetOutputModeSetting>, "SetOutputModeSetting"},
-        FunctionInfo{15, nullptr, "SetOutputTarget"},
-        FunctionInfo{16, nullptr, "SetInputTargetForceEnabled"},
-        FunctionInfo{17, D<&IAudioController::SetHeadphoneOutputLevelMode>, "SetHeadphoneOutputLevelMode"},
-        FunctionInfo{18, D<&IAudioController::GetHeadphoneOutputLevelMode>, "GetHeadphoneOutputLevelMode"},
-        FunctionInfo{19, nullptr, "AcquireAudioVolumeUpdateEventForPlayReport"},
-        FunctionInfo{20, nullptr, "AcquireAudioOutputDeviceUpdateEventForPlayReport"},
-        FunctionInfo{21, nullptr, "GetAudioOutputTargetForPlayReport"},
-        FunctionInfo{22, D<&IAudioController::NotifyHeadphoneVolumeWarningDisplayedEvent>, "NotifyHeadphoneVolumeWarningDisplayedEvent"},
-        FunctionInfo{23, nullptr, "SetSystemOutputMasterVolume"},
-        FunctionInfo{24, nullptr, "GetSystemOutputMasterVolume"},
-        FunctionInfo{25, nullptr, "GetAudioVolumeDataForPlayReport"},
-        FunctionInfo{26, nullptr, "UpdateHeadphoneSettings"},
-        FunctionInfo{27, nullptr, "SetVolumeMappingTableForDev"},
-        FunctionInfo{28, nullptr, "GetAudioOutputChannelCountForPlayReport"},
-        FunctionInfo{29, nullptr, "BindAudioOutputChannelCountUpdateEventForPlayReport"},
-        FunctionInfo{30, D<&IAudioController::SetSpeakerAutoMuteEnabled>, "SetSpeakerAutoMuteEnabled"},
-        FunctionInfo{31, D<&IAudioController::IsSpeakerAutoMuteEnabled>, "IsSpeakerAutoMuteEnabled"},
-        FunctionInfo{32, D<&IAudioController::GetActiveOutputTarget>, "GetActiveOutputTarget"},
-        FunctionInfo{33, nullptr, "GetTargetDeviceInfo"},
-        FunctionInfo{34, D<&IAudioController::AcquireTargetNotification>, "AcquireTargetNotification"},
-        FunctionInfo{35, nullptr, "SetHearingProtectionSafeguardTimerRemainingTimeForDebug"},
-        FunctionInfo{36, nullptr, "GetHearingProtectionSafeguardTimerRemainingTimeForDebug"},
-        FunctionInfo{37, nullptr, "SetHearingProtectionSafeguardEnabled"},
-        FunctionInfo{38, nullptr, "IsHearingProtectionSafeguardEnabled"},
-        FunctionInfo{39, nullptr, "IsHearingProtectionSafeguardMonitoringOutputForDebug"},
-        FunctionInfo{40, nullptr, "GetSystemInformationForDebug"},
-        FunctionInfo{41, nullptr, "SetVolumeButtonLongPressTime"},
-        FunctionInfo{42, nullptr, "SetNativeVolumeForDebug"},
-        FunctionInfo{43, nullptr, "Unknown43", MakeVersionGate({21,0,0})},
-        FunctionInfo{5000, D<&IAudioController::Unknown5000>, "Unknown5000", MakeVersionGate({19,0,0})},
-        FunctionInfo{10000, nullptr, "NotifyAudioOutputTargetForPlayReport"},
-        FunctionInfo{10001, nullptr, "NotifyAudioOutputChannelCountForPlayReport"},
-        FunctionInfo{10002, nullptr, "NotifyUnsupportedUsbOutputDeviceAttachedForPlayReport"},
-        FunctionInfo{10100, nullptr, "GetAudioVolumeDataForPlayReport"},
-        FunctionInfo{10101, nullptr, "BindAudioVolumeUpdateEventForPlayReport"},
-        FunctionInfo{10102, nullptr, "BindAudioOutputTargetUpdateEventForPlayReport"},
-        FunctionInfo{10103, nullptr, "GetAudioOutputTargetForPlayReport"},
-        FunctionInfo{10104, nullptr, "GetAudioOutputChannelCountForPlayReport"},
-        FunctionInfo{10105, nullptr, "BindAudioOutputChannelCountUpdateEventForPlayReport", MakeVersionGate({14,0,0}, {19,0,1})},
-        FunctionInfo{10106, nullptr, "GetDefaultAudioOutputTargetForPlayReport", MakeVersionGate({14,0,0}, {19,0,1})},
-        FunctionInfo{10200, nullptr, "Unknown10200", MakeVersionGate({20,0,0})},
-        FunctionInfo{50000, nullptr, "SetAnalogInputBoostGainForPrototyping", MakeVersionGate({15,0,0}, {18,1,0})},
-        FunctionInfo{50001, nullptr, "OverrideDefaultTargetForDebug", MakeVersionGate({19,0,0}, {19,0,1})},
-        FunctionInfo{50003, nullptr, "SetForceOverrideExternalDeviceNameForDebug", MakeVersionGate({19,0,0})},
-        FunctionInfo{50004, nullptr, "ClearForceOverrideExternalDeviceNameForDebug", MakeVersionGate({19,0,0})}
-    );
-    return HandlerTableGenerateWithFind(key, functions);
-}
-
 IAudioController::IAudioController(Core::System& system_)
     : ServiceFramework{system_, "audctl"}, service_context{system, "audctl"} {
-    m_set_sys = system.ServiceManager().GetService<Service::Set::ISystemSettingsServer>("set:sys", true);
+    // clang-format off
+    static const FunctionInfo functions[] = {
+        {0, D<&IAudioController::GetTargetVolume>, "GetTargetVolume"},
+        {1, D<&IAudioController::SetTargetVolume>, "SetTargetVolume"},
+        {2, D<&IAudioController::GetTargetVolumeMin>, "GetTargetVolumeMin"},
+        {3, D<&IAudioController::GetTargetVolumeMax>, "GetTargetVolumeMax"},
+        {4, D<&IAudioController::IsTargetMute>, "IsTargetMute"},
+        {5, D<&IAudioController::SetTargetMute>, "SetTargetMute"},
+        {6, nullptr, "IsTargetConnected"}, //20.0.0+
+        {7, nullptr, "SetDefaultTarget"},
+        {8, nullptr, "GetDefaultTarget"},
+        {9, D<&IAudioController::GetAudioOutputMode>, "GetAudioOutputMode"},
+        {10, D<&IAudioController::SetAudioOutputMode>, "SetAudioOutputMode"},
+        {11, nullptr, "SetForceMutePolicy"},
+        {12, D<&IAudioController::GetForceMutePolicy>, "GetForceMutePolicy"},
+        {13, D<&IAudioController::GetOutputModeSetting>, "GetOutputModeSetting"},
+        {14, D<&IAudioController::SetOutputModeSetting>, "SetOutputModeSetting"},
+        {15, nullptr, "SetOutputTarget"},
+        {16, nullptr, "SetInputTargetForceEnabled"},
+        {17, D<&IAudioController::SetHeadphoneOutputLevelMode>, "SetHeadphoneOutputLevelMode"},
+        {18, D<&IAudioController::GetHeadphoneOutputLevelMode>, "GetHeadphoneOutputLevelMode"},
+        {19, nullptr, "AcquireAudioVolumeUpdateEventForPlayReport"},
+        {20, nullptr, "AcquireAudioOutputDeviceUpdateEventForPlayReport"},
+        {21, nullptr, "GetAudioOutputTargetForPlayReport"},
+        {22, D<&IAudioController::NotifyHeadphoneVolumeWarningDisplayedEvent>, "NotifyHeadphoneVolumeWarningDisplayedEvent"},
+        {23, nullptr, "SetSystemOutputMasterVolume"},
+        {24, nullptr, "GetSystemOutputMasterVolume"},
+        {25, nullptr, "GetAudioVolumeDataForPlayReport"},
+        {26, nullptr, "UpdateHeadphoneSettings"},
+        {27, nullptr, "SetVolumeMappingTableForDev"},
+        {28, nullptr, "GetAudioOutputChannelCountForPlayReport"},
+        {29, nullptr, "BindAudioOutputChannelCountUpdateEventForPlayReport"},
+        {30, D<&IAudioController::SetSpeakerAutoMuteEnabled>, "SetSpeakerAutoMuteEnabled"},
+        {31, D<&IAudioController::IsSpeakerAutoMuteEnabled>, "IsSpeakerAutoMuteEnabled"},
+        {32, D<&IAudioController::GetActiveOutputTarget>, "GetActiveOutputTarget"},
+        {33, nullptr, "GetTargetDeviceInfo"},
+        {34, D<&IAudioController::AcquireTargetNotification>, "AcquireTargetNotification"},
+        {35, nullptr, "SetHearingProtectionSafeguardTimerRemainingTimeForDebug"},
+        {36, nullptr, "GetHearingProtectionSafeguardTimerRemainingTimeForDebug"},
+        {37, nullptr, "SetHearingProtectionSafeguardEnabled"},
+        {38, nullptr, "IsHearingProtectionSafeguardEnabled"},
+        {39, nullptr, "IsHearingProtectionSafeguardMonitoringOutputForDebug"},
+        {40, nullptr, "GetSystemInformationForDebug"},
+        {41, nullptr, "SetVolumeButtonLongPressTime"},
+        {42, nullptr, "SetNativeVolumeForDebug"},
+        {43, nullptr, "Unknown43"}, //21.0.0+
+        {5000, D<&IAudioController::Unknown5000>, "Unknown5000"}, //19.0.0+
+        {10000, nullptr, "NotifyAudioOutputTargetForPlayReport"},
+        {10001, nullptr, "NotifyAudioOutputChannelCountForPlayReport"},
+        {10002, nullptr, "NotifyUnsupportedUsbOutputDeviceAttachedForPlayReport"},
+        {10100, nullptr, "GetAudioVolumeDataForPlayReport"},
+        {10101, nullptr, "BindAudioVolumeUpdateEventForPlayReport"},
+        {10102, nullptr, "BindAudioOutputTargetUpdateEventForPlayReport"},
+        {10103, nullptr, "GetAudioOutputTargetForPlayReport"},
+        {10104, nullptr, "GetAudioOutputChannelCountForPlayReport"},
+        {10105, nullptr, "BindAudioOutputChannelCountUpdateEventForPlayReport"}, //14.0.0-19.0.1
+        {10106, nullptr, "GetDefaultAudioOutputTargetForPlayReport"}, //14.0.0-19.0.1
+        {10200, nullptr, "Unknown10200"}, //20.0.0+
+        {50000, nullptr, "SetAnalogInputBoostGainForPrototyping"}, //15.0.0-18.1.0
+        {50001, nullptr, "OverrideDefaultTargetForDebug"}, //19.0.0-19.0.1
+        {50003, nullptr, "SetForceOverrideExternalDeviceNameForDebug"}, //19.0.0+
+        {50004, nullptr, "ClearForceOverrideExternalDeviceNameForDebug"} //19.0.0+
+    };
+    // clang-format on
+
+    RegisterHandlers(functions);
+
+    m_set_sys =
+        system.ServiceManager().GetService<Service::Set::ISystemSettingsServer>("set:sys", true);
     notification_event = service_context.CreateEvent("IAudioController:NotificationEvent");
 
     // Probably shouldn't do this in constructor?

src/core/hle/service/audio/audio_controller.h

@@ -59,8 +59,8 @@ private:
     Result AcquireTargetNotification(OutCopyHandle<Kernel::KReadableEvent> out_notification_event);
     Result Unknown5000(Out<SharedPointer<IAudioController>> out_audio_controller);
 
-    std::optional<FunctionInfoBase> FindRequest(u32 key) override;
     KernelHelpers::ServiceContext service_context;
+
     Kernel::KEvent* notification_event;
     std::shared_ptr<Service::Set::ISystemSettingsServer> m_set_sys;
     std::array<s32, 6> m_target_volumes{{15, 15, 15, 15, 15, 15}};

src/core/hle/service/audio/audio_device.cpp

@@ -12,38 +12,36 @@
 namespace Service::Audio {
 using namespace AudioCore::Renderer;
 
-std::optional<ServiceFrameworkBase::FunctionInfoBase> IAudioDevice::FindRequest(u32 key) {
-    static constexpr auto functions = CreateStaticMap(
-        FunctionInfo{0, D<&IAudioDevice::ListAudioDeviceName>, "ListAudioDeviceName"},
-        FunctionInfo{1, D<&IAudioDevice::SetAudioDeviceOutputVolume>, "SetAudioDeviceOutputVolume"},
-        FunctionInfo{2, D<&IAudioDevice::GetAudioDeviceOutputVolume>, "GetAudioDeviceOutputVolume"},
-        FunctionInfo{3, D<&IAudioDevice::GetActiveAudioDeviceName>, "GetActiveAudioDeviceName"},
-        FunctionInfo{4, D<&IAudioDevice::QueryAudioDeviceSystemEvent>, "QueryAudioDeviceSystemEvent"},
-        FunctionInfo{5, D<&IAudioDevice::GetActiveChannelCount>, "GetActiveChannelCount"},
-        FunctionInfo{6, D<&IAudioDevice::ListAudioDeviceNameAuto>, "ListAudioDeviceNameAuto"},
-        FunctionInfo{7, D<&IAudioDevice::SetAudioDeviceOutputVolumeAuto>, "SetAudioDeviceOutputVolumeAuto"},
-        FunctionInfo{8, D<&IAudioDevice::GetAudioDeviceOutputVolumeAuto>, "GetAudioDeviceOutputVolumeAuto"},
-        FunctionInfo{10, D<&IAudioDevice::GetActiveAudioDeviceNameAuto>, "GetActiveAudioDeviceNameAuto"},
-        FunctionInfo{11, D<&IAudioDevice::QueryAudioDeviceInputEvent>, "QueryAudioDeviceInputEvent"},
-        FunctionInfo{12, D<&IAudioDevice::QueryAudioDeviceOutputEvent>, "QueryAudioDeviceOutputEvent"},
-        FunctionInfo{13, D<&IAudioDevice::GetActiveAudioDeviceName>, "GetActiveAudioOutputDeviceName"},
-        FunctionInfo{14, D<&IAudioDevice::ListAudioOutputDeviceName>, "ListAudioOutputDeviceName"},
-        FunctionInfo{15, nullptr, "AcquireAudioInputDeviceNotification", MakeVersionGate({17,0,0})},
-        FunctionInfo{16, nullptr, "ReleaseAudioInputDeviceNotification", MakeVersionGate({17,0,0})},
-        FunctionInfo{17, nullptr, "AcquireAudioOutputDeviceNotification", MakeVersionGate({17,0,0})},
-        FunctionInfo{18, nullptr, "ReleaseAudioOutputDeviceNotification", MakeVersionGate({17,0,0})},
-        FunctionInfo{19, D<&IAudioDevice::SetAudioDeviceOutputVolumeAutoTuneEnabled>, "SetAudioDeviceOutputVolumeAutoTuneEnabled", MakeVersionGate({18,0,0})},
-        FunctionInfo{20, D<&IAudioDevice::IsAudioDeviceOutputVolumeAutoTuneEnabled>, "IsAudioDeviceOutputVolumeAutoTuneEnabled", MakeVersionGate({18,0,0})},
-        FunctionInfo{21, nullptr, "IsActiveOutputDeviceEstimatedLowLatency", MakeVersionGate({21,0,0})}
-    );
-    return HandlerTableGenerateWithFind(key, functions);
-}
-
 IAudioDevice::IAudioDevice(Core::System& system_, u64 applet_resource_user_id, u32 revision,
                            u32 device_num)
     : ServiceFramework{system_, "IAudioDevice"}, service_context{system_, "IAudioDevice"},
       impl{std::make_unique<AudioDevice>(system_, applet_resource_user_id, revision)},
       event{service_context.CreateEvent(fmt::format("IAudioDeviceEvent-{}", device_num))} {
+    static const FunctionInfo functions[] = {
+        {0, D<&IAudioDevice::ListAudioDeviceName>, "ListAudioDeviceName"},
+        {1, D<&IAudioDevice::SetAudioDeviceOutputVolume>, "SetAudioDeviceOutputVolume"},
+        {2, D<&IAudioDevice::GetAudioDeviceOutputVolume>, "GetAudioDeviceOutputVolume"},
+        {3, D<&IAudioDevice::GetActiveAudioDeviceName>, "GetActiveAudioDeviceName"},
+        {4, D<&IAudioDevice::QueryAudioDeviceSystemEvent>, "QueryAudioDeviceSystemEvent"},
+        {5, D<&IAudioDevice::GetActiveChannelCount>, "GetActiveChannelCount"},
+        {6, D<&IAudioDevice::ListAudioDeviceNameAuto>, "ListAudioDeviceNameAuto"},
+        {7, D<&IAudioDevice::SetAudioDeviceOutputVolumeAuto>, "SetAudioDeviceOutputVolumeAuto"},
+        {8, D<&IAudioDevice::GetAudioDeviceOutputVolumeAuto>, "GetAudioDeviceOutputVolumeAuto"},
+        {10, D<&IAudioDevice::GetActiveAudioDeviceNameAuto>, "GetActiveAudioDeviceNameAuto"},
+        {11, D<&IAudioDevice::QueryAudioDeviceInputEvent>, "QueryAudioDeviceInputEvent"},
+        {12, D<&IAudioDevice::QueryAudioDeviceOutputEvent>, "QueryAudioDeviceOutputEvent"},
+        {13, D<&IAudioDevice::GetActiveAudioDeviceName>, "GetActiveAudioOutputDeviceName"},
+        {14, D<&IAudioDevice::ListAudioOutputDeviceName>, "ListAudioOutputDeviceName"},
+        {15, nullptr, "AcquireAudioInputDeviceNotification"}, //17.0.0+
+        {16, nullptr, "ReleaseAudioInputDeviceNotification"}, //17.0.0+
+        {17, nullptr, "AcquireAudioOutputDeviceNotification"}, //17.0.0+
+        {18, nullptr, "ReleaseAudioOutputDeviceNotification"}, //17.0.0+
+        {19, D<&IAudioDevice::SetAudioDeviceOutputVolumeAutoTuneEnabled>, "SetAudioDeviceOutputVolumeAutoTuneEnabled"}, //18.0.0+
+        {20, D<&IAudioDevice::IsAudioDeviceOutputVolumeAutoTuneEnabled>, "IsAudioDeviceOutputVolumeAutoTuneEnabled"}, //18.0.0+
+        {21, nullptr, "IsActiveOutputDeviceEstimatedLowLatency"} //21.0.0+
+    };
+    RegisterHandlers(functions);
+
     event->Signal(system.Kernel());
 }
 

src/core/hle/service/audio/audio_device.h

@@ -55,7 +55,6 @@ private:
     Result SetAudioDeviceOutputVolumeAutoTuneEnabled(bool enabled);
     Result IsAudioDeviceOutputVolumeAutoTuneEnabled(Out<bool> out_enabled);
 
-    std::optional<FunctionInfoBase> FindRequest(u32 key) override;
     KernelHelpers::ServiceContext service_context;
     std::unique_ptr<AudioCore::Renderer::AudioDevice> impl;
     Kernel::KEvent* event;

src/core/hle/service/audio/audio_in.cpp

@@ -11,33 +11,35 @@
 namespace Service::Audio {
 using namespace AudioCore::AudioIn;
 
-std::optional<ServiceFrameworkBase::FunctionInfoBase> IAudioIn::FindRequest(u32 key) {
-    static constexpr auto functions = CreateStaticMap(
-        FunctionInfo{0, D<&IAudioIn::GetAudioInState>, "GetAudioInState"},
-        FunctionInfo{1, D<&IAudioIn::Start>, "Start"},
-        FunctionInfo{2, D<&IAudioIn::Stop>, "Stop"},
-        FunctionInfo{3, D<&IAudioIn::AppendAudioInBuffer>, "AppendAudioInBuffer"},
-        FunctionInfo{4, D<&IAudioIn::RegisterBufferEvent>, "RegisterBufferEvent"},
-        FunctionInfo{5, D<&IAudioIn::GetReleasedAudioInBuffers>, "GetReleasedAudioInBuffers"},
-        FunctionInfo{6, D<&IAudioIn::ContainsAudioInBuffer>, "ContainsAudioInBuffer"},
-        FunctionInfo{7, D<&IAudioIn::AppendAudioInBuffer>, "AppendUacInBuffer"},
-        FunctionInfo{8, D<&IAudioIn::AppendAudioInBufferAuto>, "AppendAudioInBufferAuto"},
-        FunctionInfo{9, D<&IAudioIn::GetReleasedAudioInBuffersAuto>, "GetReleasedAudioInBuffersAuto"},
-        FunctionInfo{10, D<&IAudioIn::AppendAudioInBufferAuto>, "AppendUacInBufferAuto"},
-        FunctionInfo{11, D<&IAudioIn::GetAudioInBufferCount>, "GetAudioInBufferCount"},
-        FunctionInfo{12, D<&IAudioIn::SetDeviceGain>, "SetDeviceGain"},
-        FunctionInfo{13, D<&IAudioIn::GetDeviceGain>, "GetDeviceGain"},
-        FunctionInfo{14, D<&IAudioIn::FlushAudioInBuffers>, "FlushAudioInBuffers"}
-    );
-    return HandlerTableGenerateWithFind(key, functions);
-}
-
 IAudioIn::IAudioIn(Core::System& system_, Manager& manager, size_t session_id,
                    const std::string& device_name, const AudioInParameter& in_params,
                    Kernel::KProcess* handle, u64 applet_resource_user_id)
-    : ServiceFramework{system_, "IAudioIn"}, process{handle}, service_context{system_, "IAudioIn"}
-    , event{service_context.CreateEvent("AudioInEvent")}, impl{std::make_shared<In>(system_, manager, event, session_id)}
-{
+    : ServiceFramework{system_, "IAudioIn"}, process{handle}, service_context{system_, "IAudioIn"},
+      event{service_context.CreateEvent("AudioInEvent")}, impl{std::make_shared<In>(system_,
+                                                                                    manager, event,
+                                                                                    session_id)} {
+    // clang-format off
+    static const FunctionInfo functions[] = {
+        {0, D<&IAudioIn::GetAudioInState>, "GetAudioInState"},
+        {1, D<&IAudioIn::Start>, "Start"},
+        {2, D<&IAudioIn::Stop>, "Stop"},
+        {3, D<&IAudioIn::AppendAudioInBuffer>, "AppendAudioInBuffer"},
+        {4, D<&IAudioIn::RegisterBufferEvent>, "RegisterBufferEvent"},
+        {5, D<&IAudioIn::GetReleasedAudioInBuffers>, "GetReleasedAudioInBuffers"},
+        {6, D<&IAudioIn::ContainsAudioInBuffer>, "ContainsAudioInBuffer"},
+        {7, D<&IAudioIn::AppendAudioInBuffer>, "AppendUacInBuffer"},
+        {8, D<&IAudioIn::AppendAudioInBufferAuto>, "AppendAudioInBufferAuto"},
+        {9, D<&IAudioIn::GetReleasedAudioInBuffersAuto>, "GetReleasedAudioInBuffersAuto"},
+        {10, D<&IAudioIn::AppendAudioInBufferAuto>, "AppendUacInBufferAuto"},
+        {11, D<&IAudioIn::GetAudioInBufferCount>, "GetAudioInBufferCount"},
+        {12, D<&IAudioIn::SetDeviceGain>, "SetDeviceGain"},
+        {13, D<&IAudioIn::GetDeviceGain>, "GetDeviceGain"},
+        {14, D<&IAudioIn::FlushAudioInBuffers>, "FlushAudioInBuffers"},
+    };
+    // clang-format on
+
+    RegisterHandlers(functions);
+
     process->Open(system.Kernel());
 
     if (impl->GetSystem()

src/core/hle/service/audio/audio_in.h

@@ -46,7 +46,6 @@ public:
     Result FlushAudioInBuffers(Out<bool> out_flushed);
 
 private:
-    std::optional<FunctionInfoBase> FindRequest(u32 key) override;
     Kernel::KProcess* process;
     KernelHelpers::ServiceContext service_context;
     Kernel::KEvent* event;

src/core/hle/service/audio/audio_in_manager.cpp

@@ -12,22 +12,22 @@
 namespace Service::Audio {
 using namespace AudioCore::AudioIn;
 
-std::optional<ServiceFrameworkBase::FunctionInfoBase> IAudioInManager::FindRequest(u32 key) {
-    static constexpr auto functions = CreateStaticMap(
-        FunctionInfo{0, D<&IAudioInManager::ListAudioIns>, "ListAudioIns"},
-        FunctionInfo{1, D<&IAudioInManager::OpenAudioIn>, "OpenAudioIn"},
-        FunctionInfo{2, D<&IAudioInManager::ListAudioIns>, "ListAudioInsAuto"},
-        FunctionInfo{3, D<&IAudioInManager::OpenAudioIn>, "OpenAudioInAuto"},
-        FunctionInfo{4, D<&IAudioInManager::ListAudioInsAutoFiltered>, "ListAudioInsAutoFiltered"},
-        FunctionInfo{5, D<&IAudioInManager::OpenAudioInProtocolSpecified>, "OpenAudioInProtocolSpecified"}
-    );
-    return HandlerTableGenerateWithFind(key, functions);
-}
-
 IAudioInManager::IAudioInManager(Core::System& system_)
-    : ServiceFramework{system_, "audin:u"}
-    , impl{std::make_unique<AudioCore::AudioIn::Manager>(system_)}
-{}
+    : ServiceFramework{system_, "audin:u"}, impl{std::make_unique<AudioCore::AudioIn::Manager>(
+                                                system_)} {
+    // clang-format off
+    static const FunctionInfo functions[] = {
+        {0, D<&IAudioInManager::ListAudioIns>, "ListAudioIns"},
+        {1, D<&IAudioInManager::OpenAudioIn>, "OpenAudioIn"},
+        {2, D<&IAudioInManager::ListAudioIns>, "ListAudioInsAuto"},
+        {3, D<&IAudioInManager::OpenAudioIn>, "OpenAudioInAuto"},
+        {4, D<&IAudioInManager::ListAudioInsAutoFiltered>, "ListAudioInsAutoFiltered"},
+        {5, D<&IAudioInManager::OpenAudioInProtocolSpecified>, "OpenAudioInProtocolSpecified"},
+    };
+    // clang-format on
+
+    RegisterHandlers(functions);
+}
 
 IAudioInManager::~IAudioInManager() = default;
 

src/core/hle/service/audio/audio_in_manager.h

@@ -54,7 +54,6 @@ private:
         AudioCore::AudioIn::AudioInParameter parameter,
         InCopyHandle<Kernel::KProcess> process_handle, ClientAppletResourceUserId aruid);
 
-    std::optional<FunctionInfoBase> FindRequest(u32 key) override;
     std::unique_ptr<AudioCore::AudioIn::Manager> impl;
 };
 

src/core/hle/service/audio/audio_out.cpp

@@ -15,26 +15,6 @@
 namespace Service::Audio {
 using namespace AudioCore::AudioOut;
 
-std::optional<ServiceFrameworkBase::FunctionInfoBase> IAudioOut::FindRequest(u32 key) {
-    static constexpr auto functions = CreateStaticMap(
-        FunctionInfo{0, D<&IAudioOut::GetAudioOutState>, "GetAudioOutState"},
-        FunctionInfo{1, D<&IAudioOut::Start>, "Start"},
-        FunctionInfo{2, D<&IAudioOut::Stop>, "Stop"},
-        FunctionInfo{3, D<&IAudioOut::AppendAudioOutBuffer>, "AppendAudioOutBuffer"},
-        FunctionInfo{4, D<&IAudioOut::RegisterBufferEvent>, "RegisterBufferEvent"},
-        FunctionInfo{5, D<&IAudioOut::GetReleasedAudioOutBuffers>, "GetReleasedAudioOutBuffers"},
-        FunctionInfo{6, D<&IAudioOut::ContainsAudioOutBuffer>, "ContainsAudioOutBuffer"},
-        FunctionInfo{7, D<&IAudioOut::AppendAudioOutBufferAuto>, "AppendAudioOutBufferAuto"},
-        FunctionInfo{8, D<&IAudioOut::GetReleasedAudioOutBuffersAuto>, "GetReleasedAudioOutBuffersAuto"},
-        FunctionInfo{9, D<&IAudioOut::GetAudioOutBufferCount>, "GetAudioOutBufferCount"},
-        FunctionInfo{10, D<&IAudioOut::GetAudioOutPlayedSampleCount>, "GetAudioOutPlayedSampleCount"},
-        FunctionInfo{11, D<&IAudioOut::FlushAudioOutBuffers>, "FlushAudioOutBuffers"},
-        FunctionInfo{12, D<&IAudioOut::SetAudioOutVolume>, "SetAudioOutVolume"},
-        FunctionInfo{13, D<&IAudioOut::GetAudioOutVolume>, "GetAudioOutVolume"}
-    );
-    return HandlerTableGenerateWithFind(key, functions);
-}
-
 IAudioOut::IAudioOut(Core::System& system_, Manager& manager, size_t session_id,
                      const std::string& device_name, const AudioOutParameter& in_params,
                      Kernel::KProcess* handle, u64 applet_resource_user_id)
@@ -42,6 +22,26 @@ IAudioOut::IAudioOut(Core::System& system_, Manager& manager, size_t session_id,
       event{service_context.CreateEvent("AudioOutEvent")}, process{handle},
       impl{std::make_shared<AudioCore::AudioOut::Out>(system_, manager, event, session_id)} {
 
+    // clang-format off
+    static const FunctionInfo functions[] = {
+        {0, D<&IAudioOut::GetAudioOutState>, "GetAudioOutState"},
+        {1, D<&IAudioOut::Start>, "Start"},
+        {2, D<&IAudioOut::Stop>, "Stop"},
+        {3, D<&IAudioOut::AppendAudioOutBuffer>, "AppendAudioOutBuffer"},
+        {4, D<&IAudioOut::RegisterBufferEvent>, "RegisterBufferEvent"},
+        {5, D<&IAudioOut::GetReleasedAudioOutBuffers>, "GetReleasedAudioOutBuffers"},
+        {6, D<&IAudioOut::ContainsAudioOutBuffer>, "ContainsAudioOutBuffer"},
+        {7, D<&IAudioOut::AppendAudioOutBufferAuto>, "AppendAudioOutBufferAuto"},
+        {8, D<&IAudioOut::GetReleasedAudioOutBuffersAuto>, "GetReleasedAudioOutBuffersAuto"},
+        {9, D<&IAudioOut::GetAudioOutBufferCount>, "GetAudioOutBufferCount"},
+        {10, D<&IAudioOut::GetAudioOutPlayedSampleCount>, "GetAudioOutPlayedSampleCount"},
+        {11, D<&IAudioOut::FlushAudioOutBuffers>, "FlushAudioOutBuffers"},
+        {12, D<&IAudioOut::SetAudioOutVolume>, "SetAudioOutVolume"},
+        {13, D<&IAudioOut::GetAudioOutVolume>, "GetAudioOutVolume"},
+    };
+    // clang-format on
+    RegisterHandlers(functions);
+
     process->Open(system.Kernel());
 }
 

src/core/hle/service/audio/audio_out.h

@@ -52,8 +52,6 @@ public:
     Result GetAudioOutVolume(Out<f32> out_volume);
 
 private:
-    std::optional<FunctionInfoBase> FindRequest(u32 key) override;
-
     KernelHelpers::ServiceContext service_context;
     Kernel::KEvent* event;
     Kernel::KProcess* process;

src/core/hle/service/audio/audio_out_manager.cpp

@@ -13,20 +13,20 @@
 namespace Service::Audio {
 using namespace AudioCore::AudioOut;
 
-std::optional<ServiceFrameworkBase::FunctionInfoBase> IAudioOutManager::FindRequest(u32 key) {
-    static constexpr auto functions = CreateStaticMap(
-        FunctionInfo{0, D<&IAudioOutManager::ListAudioOuts>, "ListAudioOuts"},
-        FunctionInfo{1, D<&IAudioOutManager::OpenAudioOut>, "OpenAudioOut"},
-        FunctionInfo{2, D<&IAudioOutManager::ListAudioOutsAuto>, "ListAudioOutsAuto"},
-        FunctionInfo{3, D<&IAudioOutManager::OpenAudioOutAuto>, "OpenAudioOutAuto"}
-    );
-    return HandlerTableGenerateWithFind(key, functions);
-}
-
 IAudioOutManager::IAudioOutManager(Core::System& system_)
     : ServiceFramework{system_, "audout:u"}
     , impl(system_)
 {
+    // clang-format off
+    static const FunctionInfo functions[] = {
+        {0, D<&IAudioOutManager::ListAudioOuts>, "ListAudioOuts"},
+        {1, D<&IAudioOutManager::OpenAudioOut>, "OpenAudioOut"},
+        {2, D<&IAudioOutManager::ListAudioOutsAuto>, "ListAudioOutsAuto"},
+        {3, D<&IAudioOutManager::OpenAudioOutAuto>, "OpenAudioOutAuto"},
+    };
+    // clang-format on
+
+    RegisterHandlers(functions);
 }
 
 IAudioOutManager::~IAudioOutManager() = default;

src/core/hle/service/audio/audio_out_manager.h

@@ -43,7 +43,6 @@ private:
         AudioCore::AudioOut::AudioOutParameter parameter,
         InCopyHandle<Kernel::KProcess> process_handle, ClientAppletResourceUserId aruid);
 
-    std::optional<FunctionInfoBase> FindRequest(u32 key) override;
     std::optional<AudioCore::AudioOut::Manager> impl;
 };
 

src/core/hle/service/audio/audio_renderer.cpp

@@ -10,37 +10,38 @@
 namespace Service::Audio {
 using namespace AudioCore::Renderer;
 
-std::optional<ServiceFrameworkBase::FunctionInfoBase> IAudioRenderer::FindRequest(u32 key) {
-    static constexpr auto functions = CreateStaticMap(
-        FunctionInfo{0, D<&IAudioRenderer::GetSampleRate>, "GetSampleRate"},
-        FunctionInfo{1, D<&IAudioRenderer::GetSampleCount>, "GetSampleCount"},
-        FunctionInfo{2, D<&IAudioRenderer::GetMixBufferCount>, "GetMixBufferCount"},
-        FunctionInfo{3, D<&IAudioRenderer::GetState>, "GetState"},
-        FunctionInfo{4, D<&IAudioRenderer::RequestUpdate>, "RequestUpdate"},
-        FunctionInfo{5, D<&IAudioRenderer::Start>, "Start"},
-        FunctionInfo{6, D<&IAudioRenderer::Stop>, "Stop"},
-        FunctionInfo{7, D<&IAudioRenderer::QuerySystemEvent>, "QuerySystemEvent"},
-        FunctionInfo{8, D<&IAudioRenderer::SetRenderingTimeLimit>, "SetRenderingTimeLimit"},
-        FunctionInfo{9, D<&IAudioRenderer::GetRenderingTimeLimit>, "GetRenderingTimeLimit"},
-        FunctionInfo{10, D<&IAudioRenderer::RequestUpdateAuto>, "RequestUpdateAuto", MakeVersionGate({3,0,0})},
-        FunctionInfo{11, nullptr, "ExecuteAudioRendererRendering", MakeVersionGate({3,0,0})},
-        FunctionInfo{12, D<&IAudioRenderer::SetVoiceDropParameter>, "SetVoiceDropParameter", MakeVersionGate({15,0,0})},
-        FunctionInfo{13, D<&IAudioRenderer::GetVoiceDropParameter>, "GetVoiceDropParameter", MakeVersionGate({15,0,0})}
-    );
-    return HandlerTableGenerateWithFind(key, functions);
-}
-
 IAudioRenderer::IAudioRenderer(Core::System& system_, Manager& manager_,
                                AudioCore::AudioRendererParameterInternal& params,
                                Kernel::KTransferMemory* transfer_memory, u64 transfer_memory_size,
                                Kernel::KProcess* process_handle_, u64 applet_resource_user_id,
                                s32 session_id)
-    : ServiceFramework{system_, "IAudioRenderer"}, service_context{system_, "IAudioRenderer"}
-    , rendered_event{service_context.CreateEvent("IAudioRendererEvent")}, manager{manager_}
-    , impl{std::make_unique<Renderer>(system_, manager, rendered_event)}
-    , process_handle{process_handle_} {
+    : ServiceFramework{system_, "IAudioRenderer"}, service_context{system_, "IAudioRenderer"},
+      rendered_event{service_context.CreateEvent("IAudioRendererEvent")}, manager{manager_},
+      impl{std::make_unique<Renderer>(system_, manager, rendered_event)}, process_handle{
+                                                                              process_handle_} {
+    // clang-format off
+    static const FunctionInfo functions[] = {
+        {0, D<&IAudioRenderer::GetSampleRate>, "GetSampleRate"},
+        {1, D<&IAudioRenderer::GetSampleCount>, "GetSampleCount"},
+        {2, D<&IAudioRenderer::GetMixBufferCount>, "GetMixBufferCount"},
+        {3, D<&IAudioRenderer::GetState>, "GetState"},
+        {4, D<&IAudioRenderer::RequestUpdate>, "RequestUpdate"},
+        {5, D<&IAudioRenderer::Start>, "Start"},
+        {6, D<&IAudioRenderer::Stop>, "Stop"},
+        {7, D<&IAudioRenderer::QuerySystemEvent>, "QuerySystemEvent"},
+        {8, D<&IAudioRenderer::SetRenderingTimeLimit>, "SetRenderingTimeLimit"},
+        {9, D<&IAudioRenderer::GetRenderingTimeLimit>, "GetRenderingTimeLimit"},
+        {10, D<&IAudioRenderer::RequestUpdateAuto>, "RequestUpdateAuto"}, //3.0.0+
+        {11, nullptr, "ExecuteAudioRendererRendering"}, //3.0.0+
+        {12, D<&IAudioRenderer::SetVoiceDropParameter>, "SetVoiceDropParameter"}, //15.0.0+
+        {13, D<&IAudioRenderer::GetVoiceDropParameter>, "GetVoiceDropParameter"}, //15.0.0+
+    };
+    // clang-format on
+    RegisterHandlers(functions);
+
     process_handle->Open(system_.Kernel());
-    impl->Initialize(params, transfer_memory, transfer_memory_size, process_handle, applet_resource_user_id, session_id);
+    impl->Initialize(params, transfer_memory, transfer_memory_size, process_handle,
+                     applet_resource_user_id, session_id);
 }
 
 IAudioRenderer::~IAudioRenderer() {

src/core/hle/service/audio/audio_renderer.h

@@ -45,7 +45,6 @@ private:
     Result SetVoiceDropParameter(f32 voice_drop_parameter);
     Result GetVoiceDropParameter(Out<f32> out_voice_drop_parameter);
 
-    std::optional<FunctionInfoBase> FindRequest(u32 key) override;
     KernelHelpers::ServiceContext service_context;
     Kernel::KEvent* rendered_event;
     AudioCore::Renderer::Manager& manager;

src/core/hle/service/audio/audio_renderer_manager.cpp

@@ -18,21 +18,21 @@ namespace Service::Audio {
 
 using namespace AudioCore::Renderer;
 
-std::optional<ServiceFrameworkBase::FunctionInfoBase> IAudioRendererManager::FindRequest(u32 key) {
-    static constexpr auto functions = CreateStaticMap(
-        FunctionInfo{0, D<&IAudioRendererManager::OpenAudioRenderer>, "OpenAudioRenderer"},
-        FunctionInfo{1, D<&IAudioRendererManager::GetWorkBufferSize>, "GetWorkBufferSize"},
-        FunctionInfo{2, D<&IAudioRendererManager::GetAudioDeviceService>, "GetAudioDeviceService"},
-        FunctionInfo{3, nullptr, "OpenAudioRendererForManualExecution"},
-        FunctionInfo{4, D<&IAudioRendererManager::GetAudioDeviceServiceWithRevisionInfo>, "GetAudioDeviceServiceWithRevisionInfo"}
-    );
-    return HandlerTableGenerateWithFind(key, functions);
-}
-
 IAudioRendererManager::IAudioRendererManager(Core::System& system_)
     : ServiceFramework{system_, "audren:u"}
     , impl(system_)
 {
+    // clang-format off
+    static const FunctionInfo functions[] = {
+        {0, D<&IAudioRendererManager::OpenAudioRenderer>, "OpenAudioRenderer"},
+        {1, D<&IAudioRendererManager::GetWorkBufferSize>, "GetWorkBufferSize"},
+        {2, D<&IAudioRendererManager::GetAudioDeviceService>, "GetAudioDeviceService"},
+        {3, nullptr, "OpenAudioRendererForManualExecution"},
+        {4, D<&IAudioRendererManager::GetAudioDeviceServiceWithRevisionInfo>, "GetAudioDeviceServiceWithRevisionInfo"},
+    };
+    // clang-format on
+
+    RegisterHandlers(functions);
 }
 
 IAudioRendererManager::~IAudioRendererManager() = default;

src/core/hle/service/audio/audio_renderer_manager.h

@@ -33,7 +33,6 @@ private:
     Result GetAudioDeviceServiceWithRevisionInfo(Out<SharedPointer<IAudioDevice>> out_audio_device,
                                                  u32 revision, ClientAppletResourceUserId aruid);
 
-    std::optional<FunctionInfoBase> FindRequest(u32 key) override;
     std::optional<AudioCore::Renderer::Manager> impl;
     u32 num_audio_devices{0};
 };

src/core/hle/service/audio/final_output_recorder_manager.cpp

@@ -11,29 +11,34 @@ namespace Service::Audio {
 class IFinalOutputRecorder final : public ServiceFramework<IFinalOutputRecorder> {
 public:
     explicit IFinalOutputRecorder(Core::System& system_)
-        : ServiceFramework{system_, "IFinalOutputRecorder"} {}
+        : ServiceFramework{system_, "IFinalOutputRecorder"} {
+        // clang-format off
+        static const FunctionInfo functions[] = {
+            {0, nullptr, "GetFinalOutputRecorderState"},
+            {1, nullptr, "Start"},
+            {2, nullptr, "Stop"},
+            {3, nullptr, "AppendFinalOutputRecorderBuffer"},
+            {4, nullptr, "RegisterBufferEvent"},
+            {5, nullptr, "GetReleasedFinalOutputRecorderBuffers"},
+            {6, nullptr, "ContainsFinalOutputRecorderBuffer"},
+            {7, nullptr, "GetFinalOutputRecorderBufferEndTime"},
+            {8, nullptr, "AppendFinalOutputRecorderBufferAuto"},
+            {9, nullptr, "GetReleasedFinalOutputRecorderBufferAuto"},
+            {10, nullptr, "FlushFinalOutputRecorderBuffers"},
+            {11, nullptr, "AttachWorkBuffer"},
+        };
+        // clang-format on
 
-    static constexpr auto functions = CreateStaticMap(
-            FunctionInfo{0, nullptr, "GetFinalOutputRecorderState"},
-            FunctionInfo{1, nullptr, "Start"},
-            FunctionInfo{2, nullptr, "Stop"},
-            FunctionInfo{3, nullptr, "AppendFinalOutputRecorderBuffer"},
-            FunctionInfo{4, nullptr, "RegisterBufferEvent"},
-            FunctionInfo{5, nullptr, "GetReleasedFinalOutputRecorderBuffers"},
-            FunctionInfo{6, nullptr, "ContainsFinalOutputRecorderBuffer"},
-            FunctionInfo{7, nullptr, "GetFinalOutputRecorderBufferEndTime"},
-            FunctionInfo{8, nullptr, "AppendFinalOutputRecorderBufferAuto"},
-            FunctionInfo{9, nullptr, "GetReleasedFinalOutputRecorderBufferAuto"},
-            FunctionInfo{10, nullptr, "FlushFinalOutputRecorderBuffers"},
-            FunctionInfo{11, nullptr, "AttachWorkBuffer"}
-        );
-    std::optional<FunctionInfoBase> FindRequest(u32 key) override {
-        return HandlerTableGenerateWithFind(key, functions);
+        RegisterHandlers(functions);
     }
 };
 
 IFinalOutputRecorderManager::IFinalOutputRecorderManager(Core::System& system_)
     : ServiceFramework{system_, "audrec:u"} {
+    static const FunctionInfo functions[] = {
+        {0, nullptr, "OpenFinalOutputRecorder"},
+    };
+    RegisterHandlers(functions);
 }
 
 IFinalOutputRecorderManager::~IFinalOutputRecorderManager() = default;

src/core/hle/service/audio/final_output_recorder_manager.h

@@ -18,13 +18,6 @@ class IFinalOutputRecorderManager final : public ServiceFramework<IFinalOutputRe
 public:
     explicit IFinalOutputRecorderManager(Core::System& system_);
     ~IFinalOutputRecorderManager() override;
-
-    std::optional<FunctionInfoBase> FindRequest(u32 key) override {
-        return HandlerTableGenerateWithFind(key, functions);
-    }
-    static constexpr auto functions = CreateStaticMap(
-        FunctionInfo{0, nullptr, "OpenFinalOutputRecorder"}
-    );
 };
 
 } // namespace Service::Audio

src/core/hle/service/audio/final_output_recorder_manager_for_applet.cpp

@@ -10,6 +10,14 @@ namespace Service::Audio {
 
 IFinalOutputRecorderManagerForApplet::IFinalOutputRecorderManagerForApplet(Core::System& system_)
     : ServiceFramework{system_, "audrec:a"} {
+    // clang-format off
+    static const FunctionInfo functions[] = {
+        {0, nullptr, "RequestSuspend"},
+        {1, nullptr, "RequestResume"},
+    };
+    // clang-format on
+
+    RegisterHandlers(functions);
 }
 
 IFinalOutputRecorderManagerForApplet::~IFinalOutputRecorderManagerForApplet() = default;

src/core/hle/service/audio/final_output_recorder_manager_for_applet.h

@@ -19,14 +19,6 @@ class IFinalOutputRecorderManagerForApplet final
 public:
     explicit IFinalOutputRecorderManagerForApplet(Core::System& system_);
     ~IFinalOutputRecorderManagerForApplet() override;
-
-    std::optional<FunctionInfoBase> FindRequest(u32 key) override {
-        return HandlerTableGenerateWithFind(key, functions);
-    }
-    static constexpr auto functions = CreateStaticMap(
-        FunctionInfo{0, nullptr, "RequestSuspend"},
-        FunctionInfo{1, nullptr, "RequestResume"}
-    );
 };
 
 } // namespace Service::Audio

src/core/hle/service/audio/hardware_opus_decoder.cpp

@@ -11,25 +11,25 @@ namespace Service::Audio {
 
 using namespace AudioCore::OpusDecoder;
 
-    std::optional<ServiceFrameworkBase::FunctionInfoBase> IHardwareOpusDecoder::FindRequest(u32 key) {
-        static constexpr auto functions = CreateStaticMap(
-            FunctionInfo{0, D<&IHardwareOpusDecoder::DecodeInterleavedOld>, "DecodeInterleavedOld"},
-            FunctionInfo{1, D<&IHardwareOpusDecoder::SetContext>, "SetContext"},
-            FunctionInfo{2, D<&IHardwareOpusDecoder::DecodeInterleavedForMultiStreamOld>, "DecodeInterleavedForMultiStreamOld"},
-            FunctionInfo{3, D<&IHardwareOpusDecoder::SetContextForMultiStream>, "SetContextForMultiStream"},
-            FunctionInfo{4, D<&IHardwareOpusDecoder::DecodeInterleavedWithPerfOld>, "DecodeInterleavedWithPerfOld"},
-            FunctionInfo{5, D<&IHardwareOpusDecoder::DecodeInterleavedForMultiStreamWithPerfOld>, "DecodeInterleavedForMultiStreamWithPerfOld"},
-            FunctionInfo{6, D<&IHardwareOpusDecoder::DecodeInterleavedWithPerfAndResetOld>, "DecodeInterleavedWithPerfAndResetOld"},
-            FunctionInfo{7, D<&IHardwareOpusDecoder::DecodeInterleavedForMultiStreamWithPerfAndResetOld>, "DecodeInterleavedForMultiStreamWithPerfAndResetOld"},
-            FunctionInfo{8, D<&IHardwareOpusDecoder::DecodeInterleaved>, "DecodeInterleaved"},
-            FunctionInfo{9, D<&IHardwareOpusDecoder::DecodeInterleavedForMultiStream>, "DecodeInterleavedForMultiStream"}
-        );
-        return HandlerTableGenerateWithFind(key, functions);
-    }
-
 IHardwareOpusDecoder::IHardwareOpusDecoder(Core::System& system_, HardwareOpus& hardware_opus)
     : ServiceFramework{system_, "IHardwareOpusDecoder"},
       impl{std::make_unique<AudioCore::OpusDecoder::OpusDecoder>(system_, hardware_opus)} {
+    // clang-format off
+    static const FunctionInfo functions[] = {
+        {0, D<&IHardwareOpusDecoder::DecodeInterleavedOld>, "DecodeInterleavedOld"},
+        {1, D<&IHardwareOpusDecoder::SetContext>, "SetContext"},
+        {2, D<&IHardwareOpusDecoder::DecodeInterleavedForMultiStreamOld>, "DecodeInterleavedForMultiStreamOld"},
+        {3, D<&IHardwareOpusDecoder::SetContextForMultiStream>, "SetContextForMultiStream"},
+        {4, D<&IHardwareOpusDecoder::DecodeInterleavedWithPerfOld>, "DecodeInterleavedWithPerfOld"},
+        {5, D<&IHardwareOpusDecoder::DecodeInterleavedForMultiStreamWithPerfOld>, "DecodeInterleavedForMultiStreamWithPerfOld"},
+        {6, D<&IHardwareOpusDecoder::DecodeInterleavedWithPerfAndResetOld>, "DecodeInterleavedWithPerfAndResetOld"},
+        {7, D<&IHardwareOpusDecoder::DecodeInterleavedForMultiStreamWithPerfAndResetOld>, "DecodeInterleavedForMultiStreamWithPerfAndResetOld"},
+        {8, D<&IHardwareOpusDecoder::DecodeInterleaved>, "DecodeInterleaved"},
+        {9, D<&IHardwareOpusDecoder::DecodeInterleavedForMultiStream>, "DecodeInterleavedForMultiStream"},
+    };
+    // clang-format on
+
+    RegisterHandlers(functions);
 }
 
 IHardwareOpusDecoder::~IHardwareOpusDecoder() = default;

src/core/hle/service/audio/hardware_opus_decoder.h

@@ -58,7 +58,6 @@ private:
         Out<u32> out_data_size, Out<u32> out_sample_count, Out<u64> out_time_taken,
         InBuffer<BufferAttr_HipcMapAlias | BufferAttr_HipcMapTransferAllowsNonSecure> opus_data,
         bool reset);
-    std::optional<FunctionInfoBase> FindRequest(u32 key) override;
 
     std::unique_ptr<AudioCore::OpusDecoder::OpusDecoder> impl;
     Common::ScratchBuffer<u8> output_data;

src/core/hle/service/audio/hardware_opus_decoder_manager.cpp

@@ -12,24 +12,23 @@ namespace Service::Audio {
 
 using namespace AudioCore::OpusDecoder;
 
-std::optional<ServiceFrameworkBase::FunctionInfoBase> IHardwareOpusDecoderManager::FindRequest(u32 key) {
-    static constexpr auto functions = CreateStaticMap(
-        FunctionInfo{0, D<&IHardwareOpusDecoderManager::OpenHardwareOpusDecoder>, "OpenHardwareOpusDecoder"},
-        FunctionInfo{1, D<&IHardwareOpusDecoderManager::GetWorkBufferSize>, "GetWorkBufferSize"},
-        FunctionInfo{2, D<&IHardwareOpusDecoderManager::OpenHardwareOpusDecoderForMultiStream>, "OpenOpusDecoderForMultiStream"},
-        FunctionInfo{3, D<&IHardwareOpusDecoderManager::GetWorkBufferSizeForMultiStream>, "GetWorkBufferSizeForMultiStream"},
-        FunctionInfo{4, D<&IHardwareOpusDecoderManager::OpenHardwareOpusDecoderEx>, "OpenHardwareOpusDecoderEx"},
-        FunctionInfo{5, D<&IHardwareOpusDecoderManager::GetWorkBufferSizeEx>, "GetWorkBufferSizeEx"},
-        FunctionInfo{6, D<&IHardwareOpusDecoderManager::OpenHardwareOpusDecoderForMultiStreamEx>, "OpenHardwareOpusDecoderForMultiStreamEx"},
-        FunctionInfo{7, D<&IHardwareOpusDecoderManager::GetWorkBufferSizeForMultiStreamEx>, "GetWorkBufferSizeForMultiStreamEx"},
-        FunctionInfo{8, D<&IHardwareOpusDecoderManager::GetWorkBufferSizeExEx>, "GetWorkBufferSizeExEx"},
-        FunctionInfo{9, D<&IHardwareOpusDecoderManager::GetWorkBufferSizeForMultiStreamExEx>, "GetWorkBufferSizeForMultiStreamExEx"}
-    );
-    return HandlerTableGenerateWithFind(key, functions);
-}
-
 IHardwareOpusDecoderManager::IHardwareOpusDecoderManager(Core::System& system_)
     : ServiceFramework{system_, "hwopus"}, system{system_}, impl{system} {
+    // clang-format off
+    static const FunctionInfo functions[] = {
+        {0, D<&IHardwareOpusDecoderManager::OpenHardwareOpusDecoder>, "OpenHardwareOpusDecoder"},
+        {1, D<&IHardwareOpusDecoderManager::GetWorkBufferSize>, "GetWorkBufferSize"},
+        {2, D<&IHardwareOpusDecoderManager::OpenHardwareOpusDecoderForMultiStream>, "OpenOpusDecoderForMultiStream"},
+        {3, D<&IHardwareOpusDecoderManager::GetWorkBufferSizeForMultiStream>, "GetWorkBufferSizeForMultiStream"},
+        {4, D<&IHardwareOpusDecoderManager::OpenHardwareOpusDecoderEx>, "OpenHardwareOpusDecoderEx"},
+        {5, D<&IHardwareOpusDecoderManager::GetWorkBufferSizeEx>, "GetWorkBufferSizeEx"},
+        {6, D<&IHardwareOpusDecoderManager::OpenHardwareOpusDecoderForMultiStreamEx>, "OpenHardwareOpusDecoderForMultiStreamEx"},
+        {7, D<&IHardwareOpusDecoderManager::GetWorkBufferSizeForMultiStreamEx>, "GetWorkBufferSizeForMultiStreamEx"},
+        {8, D<&IHardwareOpusDecoderManager::GetWorkBufferSizeExEx>, "GetWorkBufferSizeExEx"},
+        {9, D<&IHardwareOpusDecoderManager::GetWorkBufferSizeForMultiStreamExEx>, "GetWorkBufferSizeForMultiStreamExEx"},
+    };
+    // clang-format on
+    RegisterHandlers(functions);
 }
 
 IHardwareOpusDecoderManager::~IHardwareOpusDecoderManager() = default;

src/core/hle/service/audio/hardware_opus_decoder_manager.h

@@ -49,7 +49,6 @@ private:
     Result GetWorkBufferSizeForMultiStreamExEx(
         Out<u32> out_size, InLargeData<OpusMultiStreamParametersEx, BufferAttr_HipcPointer> params);
 
-    std::optional<FunctionInfoBase> FindRequest(u32 key) override;
     Core::System& system;
     AudioCore::OpusDecoder::OpusDecoderManager impl;
 };