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/caps/caps.cpp

@@ -5,6 +5,7 @@
 // SPDX-License-Identifier: GPL-2.0-or-later
 
 #include "core/hle/service/caps/caps.h"
+#include "core/hle/service/caps/caps_a.h"
 #include "core/hle/service/caps/caps_c.h"
 #include "core/hle/service/caps/caps_manager.h"
 #include "core/hle/service/caps/caps_sc.h"
@@ -13,223 +14,24 @@
 #include "core/hle/service/caps/caps_u.h"
 #include "core/hle/service/server_manager.h"
 #include "core/hle/service/service.h"
-#include "common/logging.h"
 #include "frontend_common/firmware_manager.h"
-#include "core/hle/service/caps/caps_result.h"
-#include "core/hle/service/cmif_serialization.h"
-#include "core/hle/service/ipc_helpers.h"
 
 namespace Service::Capture {
 
 class IDecoderControlService final : public ServiceFramework<IDecoderControlService> {
 public:
-    explicit IDecoderControlService(Core::System& system_) : ServiceFramework{system_, "grc:d"} {}
-
-    static constexpr auto functions = CreateStaticMap(
-            FunctionInfo{3001, nullptr, "DecodeJpeg"},
-            FunctionInfo{4001, nullptr, "ShrinkJpeg"},
-            FunctionInfo{4002, nullptr, "ShrinkJpegEx"}
-        );
-    std::optional<FunctionInfoBase> FindRequest(u32 key) override {
-        return HandlerTableGenerateWithFind(key, functions);
+    explicit IDecoderControlService(Core::System& system_) : ServiceFramework{system_, "grc:d"} {
+        // clang-format off
+        static const FunctionInfo functions[] = {
+            {3001, nullptr, "DecodeJpeg"},
+            {4001, nullptr, "ShrinkJpeg"},
+            {4002, nullptr, "ShrinkJpegEx"},
+        };
+        // clang-format on
+        RegisterHandlers(functions);
     }
 };
 
-class IAlbumAccessorService final : public ServiceFramework<IAlbumAccessorService> {
-public:
-    explicit IAlbumAccessorService(Core::System& system_, std::shared_ptr<AlbumManager> album_manager) : ServiceFramework{system_, "caps:a"}, manager{album_manager} {}
-    ~IAlbumAccessorService() override = default;
-
-    Result GetAlbumFileList(
-        Out<u64> out_count, AlbumStorage storage,
-        OutArray<AlbumEntry, BufferAttr_HipcMapAlias> out_entries) {
-        LOG_INFO(Service_Capture, "called, storage={}", storage);
-
-        const Result result = manager->GetAlbumFileList(out_entries, *out_count, storage, 0);
-        R_RETURN(TranslateResult(result));
-    }
-
-    Result DeleteAlbumFile(AlbumFileId file_id) {
-        LOG_INFO(Service_Capture, "called, application_id={:#0x}, storage={}, type={}",
-                file_id.application_id, file_id.storage, file_id.type);
-
-        const Result result = manager->DeleteAlbumFile(file_id);
-        R_RETURN(TranslateResult(result));
-    }
-
-    Result IsAlbumMounted(Out<bool> out_is_mounted, AlbumStorage storage) {
-        LOG_INFO(Service_Capture, "called, storage={}", storage);
-
-        const Result result = manager->IsAlbumMounted(storage);
-        *out_is_mounted = result.IsSuccess();
-        R_RETURN(TranslateResult(result));
-    }
-
-    Result Unknown18(
-        Out<u32> out_buffer_size,
-        OutArray<u8, BufferAttr_HipcMapAlias | BufferAttr_HipcMapTransferAllowsNonSecure> out_buffer) {
-        LOG_WARNING(Service_Capture, "(STUBBED) called");
-        *out_buffer_size = 0;
-        R_SUCCEED();
-    }
-
-    Result GetAlbumFileListEx0(
-        Out<u64> out_entries_size, AlbumStorage storage, u8 flags,
-        OutArray<AlbumEntry, BufferAttr_HipcMapAlias> out_entries) {
-        LOG_INFO(Service_Capture, "called, storage={}, flags={}", storage, flags);
-
-        const Result result = manager->GetAlbumFileList(out_entries, *out_entries_size, storage, flags);
-        R_RETURN(TranslateResult(result));
-    }
-
-    Result GetAutoSavingStorage(Out<bool> out_is_autosaving) {
-        LOG_WARNING(Service_Capture, "(STUBBED) called");
-
-        const Result result = manager->GetAutoSavingStorage(*out_is_autosaving);
-        R_RETURN(TranslateResult(result));
-    }
-
-    Result LoadAlbumScreenShotImageEx1(
-        const AlbumFileId& file_id, const ScreenShotDecodeOption& decoder_options,
-        OutLargeData<LoadAlbumScreenShotImageOutput, BufferAttr_HipcMapAlias> out_image_output,
-        OutArray<u8, BufferAttr_HipcMapAlias | BufferAttr_HipcMapTransferAllowsNonSecure> out_image,
-        OutArray<u8, BufferAttr_HipcMapAlias> out_buffer) {
-        LOG_INFO(Service_Capture, "called, application_id={:#0x}, storage={}, type={}, flags={}",
-                file_id.application_id, file_id.storage, file_id.type, decoder_options.flags);
-
-        const Result result =
-            manager->LoadAlbumScreenShotImage(*out_image_output, out_image, file_id, decoder_options);
-        R_RETURN(TranslateResult(result));
-    }
-
-    Result LoadAlbumScreenShotThumbnailImageEx1(
-        const AlbumFileId& file_id, const ScreenShotDecodeOption& decoder_options,
-        OutLargeData<LoadAlbumScreenShotImageOutput, BufferAttr_HipcMapAlias> out_image_output,
-        OutArray<u8, BufferAttr_HipcMapAlias | BufferAttr_HipcMapTransferAllowsNonSecure> out_image,
-        OutArray<u8, BufferAttr_HipcMapAlias> out_buffer) {
-        LOG_INFO(Service_Capture, "called, application_id={:#0x}, storage={}, type={}, flags={}",
-                file_id.application_id, file_id.storage, file_id.type, decoder_options.flags);
-
-        const Result result = manager->LoadAlbumScreenShotThumbnail(*out_image_output, out_image,
-                                                                    file_id, decoder_options);
-        R_RETURN(TranslateResult(result));
-    }
-
-    Result TranslateResult(Result in_result) {
-        if (in_result.IsSuccess()) {
-            return in_result;
-        }
-
-        if ((in_result.raw & 0x3801ff) == ResultUnknown1024.raw) {
-            if (in_result.GetDescription() - 0x514 < 100) {
-                return ResultInvalidFileData;
-            }
-            if (in_result.GetDescription() - 0x5dc < 100) {
-                return ResultInvalidFileData;
-            }
-
-            if (in_result.GetDescription() - 0x578 < 100) {
-                if (in_result == ResultFileCountLimit) {
-                    return ResultUnknown22;
-                }
-                return ResultUnknown25;
-            }
-
-            if (in_result.raw < ResultUnknown1801.raw) {
-                if (in_result == ResultUnknown1202) {
-                    return ResultUnknown810;
-                }
-                if (in_result == ResultUnknown1203) {
-                    return ResultUnknown810;
-                }
-                if (in_result == ResultUnknown1701) {
-                    return ResultUnknown5;
-                }
-            } else if (in_result.raw < ResultUnknown1803.raw) {
-                if (in_result == ResultUnknown1801) {
-                    return ResultUnknown5;
-                }
-                if (in_result == ResultUnknown1802) {
-                    return ResultUnknown6;
-                }
-            } else {
-                if (in_result == ResultUnknown1803) {
-                    return ResultUnknown7;
-                }
-                if (in_result == ResultUnknown1804) {
-                    return ResultOutOfRange;
-                }
-            }
-            return ResultUnknown1024;
-        }
-
-        if (in_result.GetModule() == ErrorModule::FS) {
-            if ((in_result.GetDescription() >> 0xc < 0x7d) ||
-                (in_result.GetDescription() - 1000 < 2000) ||
-                (((in_result.GetDescription() - 3000) >> 3) < 0x271)) {
-                // TODO: Translate FS error
-                return in_result;
-            }
-        }
-
-        return in_result;
-    }
-
-    Result GetAlbumAccessResultForDebug(Out<Result> out_result) {
-        LOG_WARNING(Service_Capture, "(STUBBED) called");
-        *out_result = ResultSuccess;
-        R_SUCCEED();
-    }
-
-    std::optional<FunctionInfoBase> FindRequest(u32 key) override {
-        return HandlerTableGenerateWithFind(key, functions);
-    }
-    static constexpr auto functions = CreateStaticMap(
-        FunctionInfo{0, nullptr, "GetAlbumFileCount"},
-        FunctionInfo{1, C<&IAlbumAccessorService::GetAlbumFileList>, "GetAlbumFileList"},
-        FunctionInfo{2, nullptr, "LoadAlbumFile"},
-        FunctionInfo{3, C<&IAlbumAccessorService::DeleteAlbumFile>, "DeleteAlbumFile"},
-        FunctionInfo{4, nullptr, "StorageCopyAlbumFile"},
-        FunctionInfo{5, C<&IAlbumAccessorService::IsAlbumMounted>, "IsAlbumMounted"},
-        FunctionInfo{6, nullptr, "GetAlbumUsage"},
-        FunctionInfo{7, nullptr, "GetAlbumFileSize"},
-        FunctionInfo{8, nullptr, "LoadAlbumFileThumbnail"},
-        FunctionInfo{9, nullptr, "LoadAlbumScreenShotImage"},
-        FunctionInfo{10, nullptr, "LoadAlbumScreenShotThumbnailImage"},
-        FunctionInfo{11, nullptr, "GetAlbumEntryFromApplicationAlbumEntry"},
-        FunctionInfo{12, nullptr, "LoadAlbumScreenShotImageEx"},
-        FunctionInfo{13, nullptr, "LoadAlbumScreenShotThumbnailImageEx"},
-        FunctionInfo{14, nullptr, "LoadAlbumScreenShotImageEx0"},
-        FunctionInfo{15, nullptr, "GetAlbumUsage3"},
-        FunctionInfo{16, nullptr, "GetAlbumMountResult"},
-        FunctionInfo{17, nullptr, "GetAlbumUsage16"},
-        FunctionInfo{18, C<&IAlbumAccessorService::Unknown18>, "Unknown18"},
-        FunctionInfo{19, nullptr, "Unknown19"},
-        FunctionInfo{100, nullptr, "GetAlbumFileCountEx0"},
-        FunctionInfo{101, C<&IAlbumAccessorService::GetAlbumFileListEx0>, "GetAlbumFileListEx0"},
-        FunctionInfo{202, nullptr, "SaveEditedScreenShot"},
-        FunctionInfo{301, nullptr, "GetLastThumbnail"},
-        FunctionInfo{302, nullptr, "GetLastOverlayMovieThumbnail"},
-        FunctionInfo{401,  C<&IAlbumAccessorService::GetAutoSavingStorage>, "GetAutoSavingStorage"},
-        FunctionInfo{501, nullptr, "GetRequiredStorageSpaceSizeToCopyAll"},
-        FunctionInfo{1001, nullptr, "LoadAlbumScreenShotThumbnailImageEx0"},
-        FunctionInfo{1002, C<&IAlbumAccessorService::LoadAlbumScreenShotImageEx1>, "LoadAlbumScreenShotImageEx1"},
-        FunctionInfo{1003, C<&IAlbumAccessorService::LoadAlbumScreenShotThumbnailImageEx1>, "LoadAlbumScreenShotThumbnailImageEx1"},
-        FunctionInfo{8001, nullptr, "ForceAlbumUnmounted"},
-        FunctionInfo{8002, nullptr, "ResetAlbumMountStatus"},
-        FunctionInfo{8011, nullptr, "RefreshAlbumCache"},
-        FunctionInfo{8012, nullptr, "GetAlbumCache"},
-        FunctionInfo{8013, nullptr, "GetAlbumCacheEx"},
-        FunctionInfo{8021, nullptr, "GetAlbumEntryFromApplicationAlbumEntryAruid"},
-        FunctionInfo{10011, nullptr, "SetInternalErrorConversionEnabled"},
-        FunctionInfo{50000, nullptr, "LoadMakerNoteInfoForDebug"},
-        FunctionInfo{50011, C<&IAlbumAccessorService::GetAlbumAccessResultForDebug>, "GetAlbumAccessResultForDebug"},
-        FunctionInfo{60002, nullptr, "OpenAccessorSession"}
-    );
-
-    std::shared_ptr<AlbumManager> manager = nullptr;
-};
-
 void LoopProcess(Core::System& system) {
     auto server_manager = std::make_unique<ServerManager>(system);
     auto album_manager = std::make_shared<AlbumManager>(system);

src/core/hle/service/caps/caps.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/caps/caps_a.cpp

@@ -0,0 +1,211 @@
+// SPDX-FileCopyrightText: Copyright 2026 Eden Emulator Project
+// SPDX-License-Identifier: GPL-3.0-or-later
+
+// SPDX-FileCopyrightText: Copyright 2020 yuzu Emulator Project
+// SPDX-License-Identifier: GPL-2.0-or-later
+
+#include "common/logging.h"
+#include "core/hle/service/caps/caps_a.h"
+#include "core/hle/service/caps/caps_manager.h"
+#include "core/hle/service/caps/caps_result.h"
+#include "core/hle/service/cmif_serialization.h"
+#include "core/hle/service/ipc_helpers.h"
+
+namespace Service::Capture {
+
+IAlbumAccessorService::IAlbumAccessorService(Core::System& system_,
+                                             std::shared_ptr<AlbumManager> album_manager)
+    : ServiceFramework{system_, "caps:a"}, manager{album_manager} {
+    // clang-format off
+    static const FunctionInfo functions[] = {
+        {0, nullptr, "GetAlbumFileCount"},
+        {1, C<&IAlbumAccessorService::GetAlbumFileList>, "GetAlbumFileList"},
+        {2, nullptr, "LoadAlbumFile"},
+        {3, C<&IAlbumAccessorService::DeleteAlbumFile>, "DeleteAlbumFile"},
+        {4, nullptr, "StorageCopyAlbumFile"},
+        {5, C<&IAlbumAccessorService::IsAlbumMounted>, "IsAlbumMounted"},
+        {6, nullptr, "GetAlbumUsage"},
+        {7, nullptr, "GetAlbumFileSize"},
+        {8, nullptr, "LoadAlbumFileThumbnail"},
+        {9, nullptr, "LoadAlbumScreenShotImage"},
+        {10, nullptr, "LoadAlbumScreenShotThumbnailImage"},
+        {11, nullptr, "GetAlbumEntryFromApplicationAlbumEntry"},
+        {12, nullptr, "LoadAlbumScreenShotImageEx"},
+        {13, nullptr, "LoadAlbumScreenShotThumbnailImageEx"},
+        {14, nullptr, "LoadAlbumScreenShotImageEx0"},
+        {15, nullptr, "GetAlbumUsage3"},
+        {16, nullptr, "GetAlbumMountResult"},
+        {17, nullptr, "GetAlbumUsage16"},
+        {18, C<&IAlbumAccessorService::Unknown18>, "Unknown18"},
+        {19, nullptr, "Unknown19"},
+        {100, nullptr, "GetAlbumFileCountEx0"},
+        {101, C<&IAlbumAccessorService::GetAlbumFileListEx0>, "GetAlbumFileListEx0"},
+        {202, nullptr, "SaveEditedScreenShot"},
+        {301, nullptr, "GetLastThumbnail"},
+        {302, nullptr, "GetLastOverlayMovieThumbnail"},
+        {401,  C<&IAlbumAccessorService::GetAutoSavingStorage>, "GetAutoSavingStorage"},
+        {501, nullptr, "GetRequiredStorageSpaceSizeToCopyAll"},
+        {1001, nullptr, "LoadAlbumScreenShotThumbnailImageEx0"},
+        {1002, C<&IAlbumAccessorService::LoadAlbumScreenShotImageEx1>, "LoadAlbumScreenShotImageEx1"},
+        {1003, C<&IAlbumAccessorService::LoadAlbumScreenShotThumbnailImageEx1>, "LoadAlbumScreenShotThumbnailImageEx1"},
+        {8001, nullptr, "ForceAlbumUnmounted"},
+        {8002, nullptr, "ResetAlbumMountStatus"},
+        {8011, nullptr, "RefreshAlbumCache"},
+        {8012, nullptr, "GetAlbumCache"},
+        {8013, nullptr, "GetAlbumCacheEx"},
+        {8021, nullptr, "GetAlbumEntryFromApplicationAlbumEntryAruid"},
+        {10011, nullptr, "SetInternalErrorConversionEnabled"},
+        {50000, nullptr, "LoadMakerNoteInfoForDebug"},
+        {50011, C<&IAlbumAccessorService::GetAlbumAccessResultForDebug>, "GetAlbumAccessResultForDebug"},
+        {60002, nullptr, "OpenAccessorSession"},
+    };
+    // clang-format on
+
+    RegisterHandlers(functions);
+}
+
+IAlbumAccessorService::~IAlbumAccessorService() = default;
+
+Result IAlbumAccessorService::GetAlbumFileList(
+    Out<u64> out_count, AlbumStorage storage,
+    OutArray<AlbumEntry, BufferAttr_HipcMapAlias> out_entries) {
+    LOG_INFO(Service_Capture, "called, storage={}", storage);
+
+    const Result result = manager->GetAlbumFileList(out_entries, *out_count, storage, 0);
+    R_RETURN(TranslateResult(result));
+}
+
+Result IAlbumAccessorService::DeleteAlbumFile(AlbumFileId file_id) {
+    LOG_INFO(Service_Capture, "called, application_id={:#0x}, storage={}, type={}",
+             file_id.application_id, file_id.storage, file_id.type);
+
+    const Result result = manager->DeleteAlbumFile(file_id);
+    R_RETURN(TranslateResult(result));
+}
+
+Result IAlbumAccessorService::IsAlbumMounted(Out<bool> out_is_mounted, AlbumStorage storage) {
+    LOG_INFO(Service_Capture, "called, storage={}", storage);
+
+    const Result result = manager->IsAlbumMounted(storage);
+    *out_is_mounted = result.IsSuccess();
+    R_RETURN(TranslateResult(result));
+}
+
+Result IAlbumAccessorService::Unknown18(
+    Out<u32> out_buffer_size,
+    OutArray<u8, BufferAttr_HipcMapAlias | BufferAttr_HipcMapTransferAllowsNonSecure> out_buffer) {
+    LOG_WARNING(Service_Capture, "(STUBBED) called");
+    *out_buffer_size = 0;
+    R_SUCCEED();
+}
+
+Result IAlbumAccessorService::GetAlbumFileListEx0(
+    Out<u64> out_entries_size, AlbumStorage storage, u8 flags,
+    OutArray<AlbumEntry, BufferAttr_HipcMapAlias> out_entries) {
+    LOG_INFO(Service_Capture, "called, storage={}, flags={}", storage, flags);
+
+    const Result result = manager->GetAlbumFileList(out_entries, *out_entries_size, storage, flags);
+    R_RETURN(TranslateResult(result));
+}
+
+Result IAlbumAccessorService::GetAutoSavingStorage(Out<bool> out_is_autosaving) {
+    LOG_WARNING(Service_Capture, "(STUBBED) called");
+
+    const Result result = manager->GetAutoSavingStorage(*out_is_autosaving);
+    R_RETURN(TranslateResult(result));
+}
+
+Result IAlbumAccessorService::LoadAlbumScreenShotImageEx1(
+    const AlbumFileId& file_id, const ScreenShotDecodeOption& decoder_options,
+    OutLargeData<LoadAlbumScreenShotImageOutput, BufferAttr_HipcMapAlias> out_image_output,
+    OutArray<u8, BufferAttr_HipcMapAlias | BufferAttr_HipcMapTransferAllowsNonSecure> out_image,
+    OutArray<u8, BufferAttr_HipcMapAlias> out_buffer) {
+    LOG_INFO(Service_Capture, "called, application_id={:#0x}, storage={}, type={}, flags={}",
+             file_id.application_id, file_id.storage, file_id.type, decoder_options.flags);
+
+    const Result result =
+        manager->LoadAlbumScreenShotImage(*out_image_output, out_image, file_id, decoder_options);
+    R_RETURN(TranslateResult(result));
+}
+
+Result IAlbumAccessorService::LoadAlbumScreenShotThumbnailImageEx1(
+    const AlbumFileId& file_id, const ScreenShotDecodeOption& decoder_options,
+    OutLargeData<LoadAlbumScreenShotImageOutput, BufferAttr_HipcMapAlias> out_image_output,
+    OutArray<u8, BufferAttr_HipcMapAlias | BufferAttr_HipcMapTransferAllowsNonSecure> out_image,
+    OutArray<u8, BufferAttr_HipcMapAlias> out_buffer) {
+    LOG_INFO(Service_Capture, "called, application_id={:#0x}, storage={}, type={}, flags={}",
+             file_id.application_id, file_id.storage, file_id.type, decoder_options.flags);
+
+    const Result result = manager->LoadAlbumScreenShotThumbnail(*out_image_output, out_image,
+                                                                file_id, decoder_options);
+    R_RETURN(TranslateResult(result));
+}
+
+Result IAlbumAccessorService::TranslateResult(Result in_result) {
+    if (in_result.IsSuccess()) {
+        return in_result;
+    }
+
+    if ((in_result.raw & 0x3801ff) == ResultUnknown1024.raw) {
+        if (in_result.GetDescription() - 0x514 < 100) {
+            return ResultInvalidFileData;
+        }
+        if (in_result.GetDescription() - 0x5dc < 100) {
+            return ResultInvalidFileData;
+        }
+
+        if (in_result.GetDescription() - 0x578 < 100) {
+            if (in_result == ResultFileCountLimit) {
+                return ResultUnknown22;
+            }
+            return ResultUnknown25;
+        }
+
+        if (in_result.raw < ResultUnknown1801.raw) {
+            if (in_result == ResultUnknown1202) {
+                return ResultUnknown810;
+            }
+            if (in_result == ResultUnknown1203) {
+                return ResultUnknown810;
+            }
+            if (in_result == ResultUnknown1701) {
+                return ResultUnknown5;
+            }
+        } else if (in_result.raw < ResultUnknown1803.raw) {
+            if (in_result == ResultUnknown1801) {
+                return ResultUnknown5;
+            }
+            if (in_result == ResultUnknown1802) {
+                return ResultUnknown6;
+            }
+        } else {
+            if (in_result == ResultUnknown1803) {
+                return ResultUnknown7;
+            }
+            if (in_result == ResultUnknown1804) {
+                return ResultOutOfRange;
+            }
+        }
+        return ResultUnknown1024;
+    }
+
+    if (in_result.GetModule() == ErrorModule::FS) {
+        if ((in_result.GetDescription() >> 0xc < 0x7d) ||
+            (in_result.GetDescription() - 1000 < 2000) ||
+            (((in_result.GetDescription() - 3000) >> 3) < 0x271)) {
+            // TODO: Translate FS error
+            return in_result;
+        }
+    }
+
+    return in_result;
+}
+
+
+Result IAlbumAccessorService::GetAlbumAccessResultForDebug(Out<Result> out_result) {
+    LOG_WARNING(Service_Capture, "(STUBBED) called");
+    *out_result = ResultSuccess;
+    R_SUCCEED();
+}
+
+} // namespace Service::Capture

src/core/hle/service/caps/caps_a.h

@@ -0,0 +1,63 @@
+// SPDX-FileCopyrightText: Copyright 2026 Eden Emulator Project
+// SPDX-License-Identifier: GPL-3.0-or-later
+
+// SPDX-FileCopyrightText: Copyright 2020 yuzu Emulator Project
+// SPDX-License-Identifier: GPL-2.0-or-later
+
+#pragma once
+
+#include "core/hle/service/caps/caps_types.h"
+#include "core/hle/service/cmif_types.h"
+#include "core/hle/service/service.h"
+
+namespace Core {
+class System;
+}
+
+namespace Service::Capture {
+class AlbumManager;
+
+class IAlbumAccessorService final : public ServiceFramework<IAlbumAccessorService> {
+public:
+    explicit IAlbumAccessorService(Core::System& system_,
+                                   std::shared_ptr<AlbumManager> album_manager);
+    ~IAlbumAccessorService() override;
+
+private:
+    Result GetAlbumFileList(Out<u64> out_count, AlbumStorage storage,
+                            OutArray<AlbumEntry, BufferAttr_HipcMapAlias> out_entries);
+
+    Result DeleteAlbumFile(AlbumFileId file_id);
+
+    Result IsAlbumMounted(Out<bool> out_is_mounted, AlbumStorage storage);
+
+    Result Unknown18(
+        Out<u32> out_buffer_size,
+        OutArray<u8, BufferAttr_HipcMapAlias | BufferAttr_HipcMapTransferAllowsNonSecure>
+            out_buffer);
+
+    Result GetAlbumFileListEx0(Out<u64> out_entries_size, AlbumStorage storage, u8 flags,
+                               OutArray<AlbumEntry, BufferAttr_HipcMapAlias> out_entries);
+
+    Result GetAutoSavingStorage(Out<bool> out_is_autosaving);
+
+    Result LoadAlbumScreenShotImageEx1(
+        const AlbumFileId& file_id, const ScreenShotDecodeOption& decoder_options,
+        OutLargeData<LoadAlbumScreenShotImageOutput, BufferAttr_HipcMapAlias> out_image_output,
+        OutArray<u8, BufferAttr_HipcMapAlias | BufferAttr_HipcMapTransferAllowsNonSecure> out_image,
+        OutArray<u8, BufferAttr_HipcMapAlias> out_buffer);
+
+    Result LoadAlbumScreenShotThumbnailImageEx1(
+        const AlbumFileId& file_id, const ScreenShotDecodeOption& decoder_options,
+        OutLargeData<LoadAlbumScreenShotImageOutput, BufferAttr_HipcMapAlias> out_image_output,
+        OutArray<u8, BufferAttr_HipcMapAlias | BufferAttr_HipcMapTransferAllowsNonSecure> out_image,
+        OutArray<u8, BufferAttr_HipcMapAlias> out_buffer);
+
+    Result TranslateResult(Result in_result);
+
+    Result GetAlbumAccessResultForDebug(Out<Result> out_result);
+
+    std::shared_ptr<AlbumManager> manager = nullptr;
+};
+
+} // namespace Service::Capture

src/core/hle/service/caps/caps_c.cpp

@@ -14,34 +14,34 @@
 
 namespace Service::Capture {
 
-std::optional<ServiceFrameworkBase::FunctionInfoBase> IAlbumControlService::FindRequest(u32 key) {
-    static constexpr auto functions = CreateStaticMap(
-        FunctionInfo{1, nullptr, "CaptureRawImage"},
-        FunctionInfo{2, nullptr, "CaptureRawImageWithTimeout"},
-        FunctionInfo{33, C<&IAlbumControlService::SetShimLibraryVersion>, "SetShimLibraryVersion"},
-        FunctionInfo{1001, nullptr, "RequestTakingScreenShot"},
-        FunctionInfo{1002, nullptr, "RequestTakingScreenShotWithTimeout"},
-        FunctionInfo{1011, nullptr, "NotifyTakingScreenShotRefused"},
-        FunctionInfo{2001, nullptr, "NotifyAlbumStorageIsAvailable"},
-        FunctionInfo{2002, nullptr, "NotifyAlbumStorageIsUnavailable"},
-        FunctionInfo{2011, nullptr, "RegisterAppletResourceUserId"},
-        FunctionInfo{2012, nullptr, "UnregisterAppletResourceUserId"},
-        FunctionInfo{2013, nullptr, "GetApplicationIdFromAruid"},
-        FunctionInfo{2014, nullptr, "CheckApplicationIdRegistered"},
-        FunctionInfo{2101, nullptr, "GenerateCurrentAlbumFileId"},
-        FunctionInfo{2102, nullptr, "GenerateApplicationAlbumEntry"},
-        FunctionInfo{2201, nullptr, "SaveAlbumScreenShotFile"},
-        FunctionInfo{2202, nullptr, "SaveAlbumScreenShotFileEx"},
-        FunctionInfo{2301, nullptr, "SetOverlayScreenShotThumbnailData"},
-        FunctionInfo{2302, nullptr, "SetOverlayMovieThumbnailData"},
-        FunctionInfo{60001, nullptr, "OpenControlSession"}
-    );
-    return HandlerTableGenerateWithFind(key, functions);
-}
-
 IAlbumControlService::IAlbumControlService(Core::System& system_,
                                            std::shared_ptr<AlbumManager> album_manager)
     : ServiceFramework{system_, "caps:c"}, manager{album_manager} {
+    // clang-format off
+    static const FunctionInfo functions[] = {
+        {1, nullptr, "CaptureRawImage"},
+        {2, nullptr, "CaptureRawImageWithTimeout"},
+        {33, C<&IAlbumControlService::SetShimLibraryVersion>, "SetShimLibraryVersion"},
+        {1001, nullptr, "RequestTakingScreenShot"},
+        {1002, nullptr, "RequestTakingScreenShotWithTimeout"},
+        {1011, nullptr, "NotifyTakingScreenShotRefused"},
+        {2001, nullptr, "NotifyAlbumStorageIsAvailable"},
+        {2002, nullptr, "NotifyAlbumStorageIsUnavailable"},
+        {2011, nullptr, "RegisterAppletResourceUserId"},
+        {2012, nullptr, "UnregisterAppletResourceUserId"},
+        {2013, nullptr, "GetApplicationIdFromAruid"},
+        {2014, nullptr, "CheckApplicationIdRegistered"},
+        {2101, nullptr, "GenerateCurrentAlbumFileId"},
+        {2102, nullptr, "GenerateApplicationAlbumEntry"},
+        {2201, nullptr, "SaveAlbumScreenShotFile"},
+        {2202, nullptr, "SaveAlbumScreenShotFileEx"},
+        {2301, nullptr, "SetOverlayScreenShotThumbnailData"},
+        {2302, nullptr, "SetOverlayMovieThumbnailData"},
+        {60001, nullptr, "OpenControlSession"},
+    };
+    // clang-format on
+
+    RegisterHandlers(functions);
 }
 
 IAlbumControlService::~IAlbumControlService() = default;

src/core/hle/service/caps/caps_c.h

@@ -19,11 +19,14 @@ enum class ShimLibraryVersion : u64;
 
 class IAlbumControlService final : public ServiceFramework<IAlbumControlService> {
 public:
-    explicit IAlbumControlService(Core::System& system_, std::shared_ptr<AlbumManager> album_manager);
+    explicit IAlbumControlService(Core::System& system_,
+                                  std::shared_ptr<AlbumManager> album_manager);
     ~IAlbumControlService() override;
+
 private:
-    Result SetShimLibraryVersion(ShimLibraryVersion library_version, ClientAppletResourceUserId aruid);
-    std::optional<FunctionInfoBase> FindRequest(u32 key) override;
+    Result SetShimLibraryVersion(ShimLibraryVersion library_version,
+                                 ClientAppletResourceUserId aruid);
+
     std::shared_ptr<AlbumManager> manager = nullptr;
 };
 

src/core/hle/service/caps/caps_result.h

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

src/core/hle/service/caps/caps_sc.cpp

@@ -10,6 +10,32 @@ namespace Service::Capture {
 
 IScreenShotControlService::IScreenShotControlService(Core::System& system_)
     : ServiceFramework{system_, "caps:sc"} {
+    // clang-format off
+    static const FunctionInfo functions[] = {
+        {1, nullptr, "CaptureRawImage"},
+        {2, nullptr, "CaptureRawImageWithTimeout"},
+        {3, nullptr, "AttachSharedBuffer"},
+        {5, nullptr, "CaptureRawImageToAttachedSharedBuffer"},
+        {210, nullptr, "Unknown210"},
+        {1001, nullptr, "RequestTakingScreenShot"},
+        {1002, nullptr, "RequestTakingScreenShotWithTimeout"},
+        {1003, nullptr, "RequestTakingScreenShotEx"},
+        {1004, nullptr, "RequestTakingScreenShotEx1"},
+        {1009, nullptr, "CancelTakingScreenShot"},
+        {1010, nullptr, "SetTakingScreenShotCancelState"},
+        {1011, nullptr, "NotifyTakingScreenShotRefused"},
+        {1012, nullptr, "NotifyTakingScreenShotFailed"},
+        {1101, nullptr, "SetupOverlayMovieThumbnail"},
+        {1106, nullptr, "Unknown1106"},
+        {1107, nullptr, "Unknown1107"},
+        {1201, nullptr, "OpenRawScreenShotReadStream"},
+        {1202, nullptr, "CloseRawScreenShotReadStream"},
+        {1203, nullptr, "ReadRawScreenShotReadStream"},
+        {1204, nullptr, "Unknown1204"},
+    };
+    // clang-format on
+
+    RegisterHandlers(functions);
 }
 
 IScreenShotControlService::~IScreenShotControlService() = default;

src/core/hle/service/caps/caps_sc.h

@@ -18,32 +18,6 @@ class IScreenShotControlService final : public ServiceFramework<IScreenShotContr
 public:
     explicit IScreenShotControlService(Core::System& system_);
     ~IScreenShotControlService() override;
-
-    std::optional<FunctionInfoBase> FindRequest(u32 key) override {
-        return HandlerTableGenerateWithFind(key, functions);
-    }
-    static constexpr auto functions = CreateStaticMap(
-        FunctionInfo{1, nullptr, "CaptureRawImage"},
-        FunctionInfo{2, nullptr, "CaptureRawImageWithTimeout"},
-        FunctionInfo{3, nullptr, "AttachSharedBuffer"},
-        FunctionInfo{5, nullptr, "CaptureRawImageToAttachedSharedBuffer"},
-        FunctionInfo{210, nullptr, "Unknown210"},
-        FunctionInfo{1001, nullptr, "RequestTakingScreenShot"},
-        FunctionInfo{1002, nullptr, "RequestTakingScreenShotWithTimeout"},
-        FunctionInfo{1003, nullptr, "RequestTakingScreenShotEx"},
-        FunctionInfo{1004, nullptr, "RequestTakingScreenShotEx1"},
-        FunctionInfo{1009, nullptr, "CancelTakingScreenShot"},
-        FunctionInfo{1010, nullptr, "SetTakingScreenShotCancelState"},
-        FunctionInfo{1011, nullptr, "NotifyTakingScreenShotRefused"},
-        FunctionInfo{1012, nullptr, "NotifyTakingScreenShotFailed"},
-        FunctionInfo{1101, nullptr, "SetupOverlayMovieThumbnail"},
-        FunctionInfo{1106, nullptr, "Unknown1106"},
-        FunctionInfo{1107, nullptr, "Unknown1107"},
-        FunctionInfo{1201, nullptr, "OpenRawScreenShotReadStream"},
-        FunctionInfo{1202, nullptr, "CloseRawScreenShotReadStream"},
-        FunctionInfo{1203, nullptr, "ReadRawScreenShotReadStream"},
-        FunctionInfo{1204, nullptr, "Unknown1204"}
-    );
 };
 
 } // namespace Service::Capture

src/core/hle/service/caps/caps_ss.cpp

@@ -12,22 +12,22 @@
 
 namespace Service::Capture {
 
-std::optional<ServiceFrameworkBase::FunctionInfoBase> IScreenShotService::FindRequest(u32 key) {
-    static constexpr auto functions = CreateStaticMap(
-        FunctionInfo{201, nullptr, "SaveScreenShot"},
-        FunctionInfo{202, nullptr, "SaveEditedScreenShot"},
-        FunctionInfo{203, C<&IScreenShotService::SaveScreenShotEx0>, "SaveScreenShotEx0"},
-        FunctionInfo{204, nullptr, "SaveEditedScreenShotEx0"},
-        FunctionInfo{206, C<&IScreenShotService::SaveEditedScreenShotEx1>, "SaveEditedScreenShotEx1"},
-        FunctionInfo{208, nullptr, "SaveScreenShotOfMovieEx1"},
-        FunctionInfo{1000, nullptr, "Unknown1000"}
-    );
-    return HandlerTableGenerateWithFind(key, functions);
-}
-
 IScreenShotService::IScreenShotService(Core::System& system_,
                                        std::shared_ptr<AlbumManager> album_manager)
     : ServiceFramework{system_, "caps:ss"}, manager{album_manager} {
+    // clang-format off
+    static const FunctionInfo functions[] = {
+        {201, nullptr, "SaveScreenShot"},
+        {202, nullptr, "SaveEditedScreenShot"},
+        {203, C<&IScreenShotService::SaveScreenShotEx0>, "SaveScreenShotEx0"},
+        {204, nullptr, "SaveEditedScreenShotEx0"},
+        {206, C<&IScreenShotService::SaveEditedScreenShotEx1>, "SaveEditedScreenShotEx1"},
+        {208, nullptr, "SaveScreenShotOfMovieEx1"},
+        {1000, nullptr, "Unknown1000"},
+    };
+    // clang-format on
+
+    RegisterHandlers(functions);
 }
 
 IScreenShotService::~IScreenShotService() = default;

src/core/hle/service/caps/caps_ss.h

@@ -37,7 +37,6 @@ private:
         const InBuffer<BufferAttr_HipcMapTransferAllowsNonSecure | BufferAttr_HipcMapAlias>
             thumbnail_image_data_buffer);
 
-    std::optional<FunctionInfoBase> FindRequest(u32 key) override;
     std::shared_ptr<AlbumManager> manager;
 };
 

src/core/hle/service/caps/caps_su.cpp

@@ -15,20 +15,20 @@
 
 namespace Service::Capture {
 
-std::optional<ServiceFrameworkBase::FunctionInfoBase> IScreenShotApplicationService::FindRequest(u32 key) {
-    static constexpr auto functions = CreateStaticMap(
-        FunctionInfo{32, C<&IScreenShotApplicationService::SetShimLibraryVersion>, "SetShimLibraryVersion"},
-        FunctionInfo{201, nullptr, "SaveScreenShot"},
-        FunctionInfo{203, C<&IScreenShotApplicationService::SaveScreenShotEx0>, "SaveScreenShotEx0"},
-        FunctionInfo{205, C<&IScreenShotApplicationService::SaveScreenShotEx1>, "SaveScreenShotEx1"},
-        FunctionInfo{210, nullptr, "SaveScreenShotEx2"}
-    );
-    return HandlerTableGenerateWithFind(key, functions);
-}
-
 IScreenShotApplicationService::IScreenShotApplicationService(
     Core::System& system_, std::shared_ptr<AlbumManager> album_manager)
     : ServiceFramework{system_, "caps:su"}, manager{album_manager} {
+    // clang-format off
+    static const FunctionInfo functions[] = {
+        {32, C<&IScreenShotApplicationService::SetShimLibraryVersion>, "SetShimLibraryVersion"},
+        {201, nullptr, "SaveScreenShot"},
+        {203, C<&IScreenShotApplicationService::SaveScreenShotEx0>, "SaveScreenShotEx0"},
+        {205, C<&IScreenShotApplicationService::SaveScreenShotEx1>, "SaveScreenShotEx1"},
+        {210, nullptr, "SaveScreenShotEx2"},
+    };
+    // clang-format on
+
+    RegisterHandlers(functions);
 }
 
 IScreenShotApplicationService::~IScreenShotApplicationService() = default;

src/core/hle/service/caps/caps_su.h

@@ -45,8 +45,8 @@ private:
         const InBuffer<BufferAttr_HipcMapTransferAllowsNonSecure | BufferAttr_HipcMapAlias>
             image_data_buffer);
 
-    std::optional<FunctionInfoBase> FindRequest(u32 key) override;
     std::array<u8, screenshot_width * screenshot_height * bytes_per_pixel> image_data;
+
     std::shared_ptr<AlbumManager> manager;
 };
 

src/core/hle/service/caps/caps_u.cpp

@@ -13,29 +13,29 @@
 
 namespace Service::Capture {
 
-std::optional<ServiceFrameworkBase::FunctionInfoBase> IAlbumApplicationService::FindRequest(u32 key) {
-    static constexpr auto functions = CreateStaticMap(
-        FunctionInfo{32, C<&IAlbumApplicationService::SetShimLibraryVersion>, "SetShimLibraryVersion"},
-        FunctionInfo{102, C<&IAlbumApplicationService::GetAlbumFileList0AafeAruidDeprecated>, "GetAlbumFileList0AafeAruidDeprecated"},
-        FunctionInfo{103, nullptr, "DeleteAlbumFileByAruid"},
-        FunctionInfo{104, nullptr, "GetAlbumFileSizeByAruid"},
-        FunctionInfo{105, nullptr, "DeleteAlbumFileByAruidForDebug"},
-        FunctionInfo{110, nullptr, "LoadAlbumScreenShotImageByAruid"},
-        FunctionInfo{120, nullptr, "LoadAlbumScreenShotThumbnailImageByAruid"},
-        FunctionInfo{130, nullptr, "PrecheckToCreateContentsByAruid"},
-        FunctionInfo{140, nullptr, "GetAlbumFileList1AafeAruidDeprecated"},
-        FunctionInfo{141, nullptr, "GetAlbumFileList2AafeUidAruidDeprecated"},
-        FunctionInfo{142, C<&IAlbumApplicationService::GetAlbumFileList3AaeAruid>, "GetAlbumFileList3AaeAruid"},
-        FunctionInfo{143, nullptr, "GetAlbumFileList4AaeUidAruid"},
-        FunctionInfo{144, nullptr, "GetAllAlbumFileList3AaeAruid"},
-        FunctionInfo{60002, nullptr, "OpenAccessorSessionForApplication"}
-    );
-    return HandlerTableGenerateWithFind(key, functions);
-}
-
 IAlbumApplicationService::IAlbumApplicationService(Core::System& system_,
                                                    std::shared_ptr<AlbumManager> album_manager)
     : ServiceFramework{system_, "caps:u"}, manager{album_manager} {
+    // clang-format off
+    static const FunctionInfo functions[] = {
+        {32, C<&IAlbumApplicationService::SetShimLibraryVersion>, "SetShimLibraryVersion"},
+        {102, C<&IAlbumApplicationService::GetAlbumFileList0AafeAruidDeprecated>, "GetAlbumFileList0AafeAruidDeprecated"},
+        {103, nullptr, "DeleteAlbumFileByAruid"},
+        {104, nullptr, "GetAlbumFileSizeByAruid"},
+        {105, nullptr, "DeleteAlbumFileByAruidForDebug"},
+        {110, nullptr, "LoadAlbumScreenShotImageByAruid"},
+        {120, nullptr, "LoadAlbumScreenShotThumbnailImageByAruid"},
+        {130, nullptr, "PrecheckToCreateContentsByAruid"},
+        {140, nullptr, "GetAlbumFileList1AafeAruidDeprecated"},
+        {141, nullptr, "GetAlbumFileList2AafeUidAruidDeprecated"},
+        {142, C<&IAlbumApplicationService::GetAlbumFileList3AaeAruid>, "GetAlbumFileList3AaeAruid"},
+        {143, nullptr, "GetAlbumFileList4AaeUidAruid"},
+        {144, nullptr, "GetAllAlbumFileList3AaeAruid"},
+        {60002, nullptr, "OpenAccessorSessionForApplication"},
+    };
+    // clang-format on
+
+    RegisterHandlers(functions);
 }
 
 IAlbumApplicationService::~IAlbumApplicationService() = default;

src/core/hle/service/caps/caps_u.h

@@ -36,7 +36,6 @@ private:
         AlbumFileDateTime end_date_time, ClientAppletResourceUserId aruid,
         OutArray<ApplicationAlbumEntry, BufferAttr_HipcMapAlias> out_entries);
 
-    std::optional<FunctionInfoBase> FindRequest(u32 key) override;
     std::shared_ptr<AlbumManager> manager = nullptr;
 };