53 files changed, 1862 insertions, 303 deletions

diff --git a/src/common/fs/fs_paths.h b/src/common/fs/fs_paths.h
index 61bac9eba..441c8af97 100644
--- a/src/common/fs/fs_paths.h
+++ b/src/common/fs/fs_paths.h
@@ -18,10 +18,12 @@
 #define LOAD_DIR "load"
 #define LOG_DIR "log"
 #define NAND_DIR "nand"
+#define PLAY_TIME_DIR "play_time"
 #define SCREENSHOTS_DIR "screenshots"
 #define SDMC_DIR "sdmc"
 #define SHADER_DIR "shader"
 #define TAS_DIR "tas"
+#define ICONS_DIR "icons"
 
 // yuzu-specific files
 
diff --git a/src/common/fs/path_util.cpp b/src/common/fs/path_util.cpp
index dce219fcf..0abd81a45 100644
--- a/src/common/fs/path_util.cpp
+++ b/src/common/fs/path_util.cpp
@@ -124,10 +124,12 @@ public:
         GenerateYuzuPath(YuzuPath::LoadDir, yuzu_path / LOAD_DIR);
         GenerateYuzuPath(YuzuPath::LogDir, yuzu_path / LOG_DIR);
         GenerateYuzuPath(YuzuPath::NANDDir, yuzu_path / NAND_DIR);
+        GenerateYuzuPath(YuzuPath::PlayTimeDir, yuzu_path / PLAY_TIME_DIR);
         GenerateYuzuPath(YuzuPath::ScreenshotsDir, yuzu_path / SCREENSHOTS_DIR);
         GenerateYuzuPath(YuzuPath::SDMCDir, yuzu_path / SDMC_DIR);
         GenerateYuzuPath(YuzuPath::ShaderDir, yuzu_path / SHADER_DIR);
         GenerateYuzuPath(YuzuPath::TASDir, yuzu_path / TAS_DIR);
+        GenerateYuzuPath(YuzuPath::IconsDir, yuzu_path / ICONS_DIR);
     }
 
 private:
diff --git a/src/common/fs/path_util.h b/src/common/fs/path_util.h
index ba28964d0..63801c924 100644
--- a/src/common/fs/path_util.h
+++ b/src/common/fs/path_util.h
@@ -20,10 +20,12 @@ enum class YuzuPath {
     LoadDir,        // Where cheat/mod files are stored.
     LogDir,         // Where log files are stored.
     NANDDir,        // Where the emulated NAND is stored.
+    PlayTimeDir,    // Where play time data is stored.
     ScreenshotsDir, // Where yuzu screenshots are stored.
     SDMCDir,        // Where the emulated SDMC is stored.
     ShaderDir,      // Where shaders are stored.
     TASDir,         // Where TAS scripts are stored.
+    IconsDir,       // Where Icons for Windows shortcuts are stored.
 };
 
 /**
diff --git a/src/core/CMakeLists.txt b/src/core/CMakeLists.txt
index e02ededfc..e4f499135 100644
--- a/src/core/CMakeLists.txt
+++ b/src/core/CMakeLists.txt
@@ -466,14 +466,18 @@ add_library(core STATIC
     hle/service/caps/caps_a.h
     hle/service/caps/caps_c.cpp
     hle/service/caps/caps_c.h
-    hle/service/caps/caps_u.cpp
-    hle/service/caps/caps_u.h
+    hle/service/caps/caps_manager.cpp
+    hle/service/caps/caps_manager.h
+    hle/service/caps/caps_result.h
     hle/service/caps/caps_sc.cpp
     hle/service/caps/caps_sc.h
     hle/service/caps/caps_ss.cpp
     hle/service/caps/caps_ss.h
     hle/service/caps/caps_su.cpp
     hle/service/caps/caps_su.h
+    hle/service/caps/caps_types.h
+    hle/service/caps/caps_u.cpp
+    hle/service/caps/caps_u.h
     hle/service/erpt/erpt.cpp
     hle/service/erpt/erpt.h
     hle/service/es/es.cpp
diff --git a/src/core/hle/kernel/k_page_table.cpp b/src/core/hle/kernel/k_page_table.cpp
index 5b51edf30..1fbfbf31f 100644
--- a/src/core/hle/kernel/k_page_table.cpp
+++ b/src/core/hle/kernel/k_page_table.cpp
@@ -2949,6 +2949,23 @@ Result KPageTable::UnlockForIpcUserBuffer(KProcessAddress address, size_t size)
                                 KMemoryAttribute::Locked, nullptr));
 }
 
+Result KPageTable::LockForTransferMemory(KPageGroup* out, KProcessAddress address, size_t size,
+                                         KMemoryPermission perm) {
+    R_RETURN(this->LockMemoryAndOpen(out, nullptr, address, size, KMemoryState::FlagCanTransfer,
+                                     KMemoryState::FlagCanTransfer, KMemoryPermission::All,
+                                     KMemoryPermission::UserReadWrite, KMemoryAttribute::All,
+                                     KMemoryAttribute::None, perm, KMemoryAttribute::Locked));
+}
+
+Result KPageTable::UnlockForTransferMemory(KProcessAddress address, size_t size,
+                                           const KPageGroup& pg) {
+    R_RETURN(this->UnlockMemory(address, size, KMemoryState::FlagCanTransfer,
+                                KMemoryState::FlagCanTransfer, KMemoryPermission::None,
+                                KMemoryPermission::None, KMemoryAttribute::All,
+                                KMemoryAttribute::Locked, KMemoryPermission::UserReadWrite,
+                                KMemoryAttribute::Locked, std::addressof(pg)));
+}
+
 Result KPageTable::LockForCodeMemory(KPageGroup* out, KProcessAddress addr, size_t size) {
     R_RETURN(this->LockMemoryAndOpen(
         out, nullptr, addr, size, KMemoryState::FlagCanCodeMemory, KMemoryState::FlagCanCodeMemory,
diff --git a/src/core/hle/kernel/k_page_table.h b/src/core/hle/kernel/k_page_table.h
index b9e8c6042..7da675f27 100644
--- a/src/core/hle/kernel/k_page_table.h
+++ b/src/core/hle/kernel/k_page_table.h
@@ -104,6 +104,9 @@ public:
     Result CleanupForIpcServer(KProcessAddress address, size_t size, KMemoryState dst_state);
     Result CleanupForIpcClient(KProcessAddress address, size_t size, KMemoryState dst_state);
 
+    Result LockForTransferMemory(KPageGroup* out, KProcessAddress address, size_t size,
+                                 KMemoryPermission perm);
+    Result UnlockForTransferMemory(KProcessAddress address, size_t size, const KPageGroup& pg);
     Result LockForCodeMemory(KPageGroup* out, KProcessAddress addr, size_t size);
     Result UnlockForCodeMemory(KProcessAddress addr, size_t size, const KPageGroup& pg);
     Result MakeAndOpenPageGroup(KPageGroup* out, KProcessAddress address, size_t num_pages,
diff --git a/src/core/hle/kernel/k_transfer_memory.cpp b/src/core/hle/kernel/k_transfer_memory.cpp
index 13d34125c..0e2e11743 100644
--- a/src/core/hle/kernel/k_transfer_memory.cpp
+++ b/src/core/hle/kernel/k_transfer_memory.cpp
@@ -1,6 +1,7 @@
 // SPDX-FileCopyrightText: Copyright 2021 yuzu Emulator Project
 // SPDX-License-Identifier: GPL-2.0-or-later
 
+#include "common/scope_exit.h"
 #include "core/hle/kernel/k_process.h"
 #include "core/hle/kernel/k_resource_limit.h"
 #include "core/hle/kernel/k_transfer_memory.h"
@@ -9,28 +10,50 @@
 namespace Kernel {
 
 KTransferMemory::KTransferMemory(KernelCore& kernel)
-    : KAutoObjectWithSlabHeapAndContainer{kernel} {}
+    : KAutoObjectWithSlabHeapAndContainer{kernel}, m_lock{kernel} {}
 
 KTransferMemory::~KTransferMemory() = default;
 
-Result KTransferMemory::Initialize(KProcessAddress address, std::size_t size,
-                                   Svc::MemoryPermission owner_perm) {
+Result KTransferMemory::Initialize(KProcessAddress addr, std::size_t size,
+                                   Svc::MemoryPermission own_perm) {
     // Set members.
     m_owner = GetCurrentProcessPointer(m_kernel);
 
-    // TODO(bunnei): Lock for transfer memory
+    // Get the owner page table.
+    auto& page_table = m_owner->GetPageTable();
+
+    // Construct the page group, guarding to make sure our state is valid on exit.
+    m_page_group.emplace(m_kernel, page_table.GetBlockInfoManager());
+    auto pg_guard = SCOPE_GUARD({ m_page_group.reset(); });
+
+    // Lock the memory.
+    R_TRY(page_table.LockForTransferMemory(std::addressof(*m_page_group), addr, size,
+                                           ConvertToKMemoryPermission(own_perm)));
 
     // Set remaining tracking members.
     m_owner->Open();
-    m_owner_perm = owner_perm;
-    m_address = address;
-    m_size = size;
+    m_owner_perm = own_perm;
+    m_address = addr;
     m_is_initialized = true;
+    m_is_mapped = false;
 
+    // We succeeded.
+    pg_guard.Cancel();
     R_SUCCEED();
 }
 
-void KTransferMemory::Finalize() {}
+void KTransferMemory::Finalize() {
+    // Unlock.
+    if (!m_is_mapped) {
+        const size_t size = m_page_group->GetNumPages() * PageSize;
+        ASSERT(R_SUCCEEDED(
+            m_owner->GetPageTable().UnlockForTransferMemory(m_address, size, *m_page_group)));
+    }
+
+    // Close the page group.
+    m_page_group->Close();
+    m_page_group->Finalize();
+}
 
 void KTransferMemory::PostDestroy(uintptr_t arg) {
     KProcess* owner = reinterpret_cast<KProcess*>(arg);
@@ -38,4 +61,54 @@ void KTransferMemory::PostDestroy(uintptr_t arg) {
     owner->Close();
 }
 
+Result KTransferMemory::Map(KProcessAddress address, size_t size, Svc::MemoryPermission map_perm) {
+    // Validate the size.
+    R_UNLESS(m_page_group->GetNumPages() == Common::DivideUp(size, PageSize), ResultInvalidSize);
+
+    // Validate the permission.
+    R_UNLESS(m_owner_perm == map_perm, ResultInvalidState);
+
+    // Lock ourselves.
+    KScopedLightLock lk(m_lock);
+
+    // Ensure we're not already mapped.
+    R_UNLESS(!m_is_mapped, ResultInvalidState);
+
+    // Map the memory.
+    const KMemoryState state = (m_owner_perm == Svc::MemoryPermission::None)
+                                   ? KMemoryState::Transfered
+                                   : KMemoryState::SharedTransfered;
+    R_TRY(GetCurrentProcess(m_kernel).GetPageTable().MapPageGroup(
+        address, *m_page_group, state, KMemoryPermission::UserReadWrite));
+
+    // Mark ourselves as mapped.
+    m_is_mapped = true;
+
+    R_SUCCEED();
+}
+
+Result KTransferMemory::Unmap(KProcessAddress address, size_t size) {
+    // Validate the size.
+    R_UNLESS(m_page_group->GetNumPages() == Common::DivideUp(size, PageSize), ResultInvalidSize);
+
+    // Lock ourselves.
+    KScopedLightLock lk(m_lock);
+
+    // Unmap the memory.
+    const KMemoryState state = (m_owner_perm == Svc::MemoryPermission::None)
+                                   ? KMemoryState::Transfered
+                                   : KMemoryState::SharedTransfered;
+    R_TRY(GetCurrentProcess(m_kernel).GetPageTable().UnmapPageGroup(address, *m_page_group, state));
+
+    // Mark ourselves as unmapped.
+    ASSERT(m_is_mapped);
+    m_is_mapped = false;
+
+    R_SUCCEED();
+}
+
+size_t KTransferMemory::GetSize() const {
+    return m_is_initialized ? m_page_group->GetNumPages() * PageSize : 0;
+}
+
 } // namespace Kernel
diff --git a/src/core/hle/kernel/k_transfer_memory.h b/src/core/hle/kernel/k_transfer_memory.h
index 54f97ccb4..8a0b08761 100644
--- a/src/core/hle/kernel/k_transfer_memory.h
+++ b/src/core/hle/kernel/k_transfer_memory.h
@@ -3,6 +3,9 @@
 
 #pragma once
 
+#include <optional>
+
+#include "core/hle/kernel/k_page_group.h"
 #include "core/hle/kernel/slab_helpers.h"
 #include "core/hle/kernel/svc_types.h"
 #include "core/hle/result.h"
@@ -48,16 +51,19 @@ public:
         return m_address;
     }
 
-    size_t GetSize() const {
-        return m_is_initialized ? m_size : 0;
-    }
+    size_t GetSize() const;
+
+    Result Map(KProcessAddress address, size_t size, Svc::MemoryPermission map_perm);
+    Result Unmap(KProcessAddress address, size_t size);
 
 private:
+    std::optional<KPageGroup> m_page_group{};
     KProcess* m_owner{};
     KProcessAddress m_address{};
+    KLightLock m_lock;
     Svc::MemoryPermission m_owner_perm{};
-    size_t m_size{};
     bool m_is_initialized{};
+    bool m_is_mapped{};
 };
 
 } // namespace Kernel
diff --git a/src/core/hle/kernel/svc/svc_transfer_memory.cpp b/src/core/hle/kernel/svc/svc_transfer_memory.cpp
index 7d94e7f09..1f97121b3 100644
--- a/src/core/hle/kernel/svc/svc_transfer_memory.cpp
+++ b/src/core/hle/kernel/svc/svc_transfer_memory.cpp
@@ -71,15 +71,59 @@ Result CreateTransferMemory(Core::System& system, Handle* out, u64 address, u64
 }
 
 Result MapTransferMemory(Core::System& system, Handle trmem_handle, uint64_t address, uint64_t size,
-                         MemoryPermission owner_perm) {
-    UNIMPLEMENTED();
-    R_THROW(ResultNotImplemented);
+                         MemoryPermission map_perm) {
+    // Validate the address/size.
+    R_UNLESS(Common::IsAligned(address, PageSize), ResultInvalidAddress);
+    R_UNLESS(Common::IsAligned(size, PageSize), ResultInvalidSize);
+    R_UNLESS(size > 0, ResultInvalidSize);
+    R_UNLESS((address < address + size), ResultInvalidCurrentMemory);
+
+    // Validate the permission.
+    R_UNLESS(IsValidTransferMemoryPermission(map_perm), ResultInvalidState);
+
+    // Get the transfer memory.
+    KScopedAutoObject trmem = GetCurrentProcess(system.Kernel())
+                                  .GetHandleTable()
+                                  .GetObject<KTransferMemory>(trmem_handle);
+    R_UNLESS(trmem.IsNotNull(), ResultInvalidHandle);
+
+    // Verify that the mapping is in range.
+    R_UNLESS(GetCurrentProcess(system.Kernel())
+                 .GetPageTable()
+                 .CanContain(address, size, KMemoryState::Transfered),
+             ResultInvalidMemoryRegion);
+
+    // Map the transfer memory.
+    R_TRY(trmem->Map(address, size, map_perm));
+
+    // We succeeded.
+    R_SUCCEED();
 }
 
 Result UnmapTransferMemory(Core::System& system, Handle trmem_handle, uint64_t address,
                            uint64_t size) {
-    UNIMPLEMENTED();
-    R_THROW(ResultNotImplemented);
+    // Validate the address/size.
+    R_UNLESS(Common::IsAligned(address, PageSize), ResultInvalidAddress);
+    R_UNLESS(Common::IsAligned(size, PageSize), ResultInvalidSize);
+    R_UNLESS(size > 0, ResultInvalidSize);
+    R_UNLESS((address < address + size), ResultInvalidCurrentMemory);
+
+    // Get the transfer memory.
+    KScopedAutoObject trmem = GetCurrentProcess(system.Kernel())
+                                  .GetHandleTable()
+                                  .GetObject<KTransferMemory>(trmem_handle);
+    R_UNLESS(trmem.IsNotNull(), ResultInvalidHandle);
+
+    // Verify that the mapping is in range.
+    R_UNLESS(GetCurrentProcess(system.Kernel())
+                 .GetPageTable()
+                 .CanContain(address, size, KMemoryState::Transfered),
+             ResultInvalidMemoryRegion);
+
+    // Unmap the transfer memory.
+    R_TRY(trmem->Unmap(address, size));
+
+    R_SUCCEED();
 }
 
 Result MapTransferMemory64(Core::System& system, Handle trmem_handle, uint64_t address,
diff --git a/src/core/hle/service/am/am.cpp b/src/core/hle/service/am/am.cpp
index 819dea6a7..ac376b55a 100644
--- a/src/core/hle/service/am/am.cpp
+++ b/src/core/hle/service/am/am.cpp
@@ -31,7 +31,7 @@
 #include "core/hle/service/apm/apm_controller.h"
 #include "core/hle/service/apm/apm_interface.h"
 #include "core/hle/service/bcat/backend/backend.h"
-#include "core/hle/service/caps/caps.h"
+#include "core/hle/service/caps/caps_types.h"
 #include "core/hle/service/filesystem/filesystem.h"
 #include "core/hle/service/ipc_helpers.h"
 #include "core/hle/service/ns/ns.h"
@@ -764,6 +764,66 @@ void AppletMessageQueue::OperationModeChanged() {
     on_operation_mode_changed->Signal();
 }
 
+ILockAccessor::ILockAccessor(Core::System& system_)
+    : ServiceFramework{system_, "ILockAccessor"}, service_context{system_, "ILockAccessor"} {
+    // clang-format off
+        static const FunctionInfo functions[] = {
+            {1, &ILockAccessor::TryLock, "TryLock"},
+            {2, &ILockAccessor::Unlock, "Unlock"},
+            {3, &ILockAccessor::GetEvent, "GetEvent"},
+            {4,&ILockAccessor::IsLocked, "IsLocked"},
+        };
+    // clang-format on
+
+    RegisterHandlers(functions);
+
+    lock_event = service_context.CreateEvent("ILockAccessor::LockEvent");
+}
+
+ILockAccessor::~ILockAccessor() = default;
+
+void ILockAccessor::TryLock(HLERequestContext& ctx) {
+    IPC::RequestParser rp{ctx};
+    const auto return_handle = rp.Pop<bool>();
+
+    LOG_WARNING(Service_AM, "(STUBBED) called, return_handle={}", return_handle);
+
+    // TODO: When return_handle is true this function should return the lock handle
+
+    is_locked = true;
+
+    IPC::ResponseBuilder rb{ctx, 3};
+    rb.Push(ResultSuccess);
+    rb.Push<u8>(is_locked);
+}
+
+void ILockAccessor::Unlock(HLERequestContext& ctx) {
+    LOG_INFO(Service_AM, "called");
+
+    is_locked = false;
+
+    IPC::ResponseBuilder rb{ctx, 2};
+    rb.Push(ResultSuccess);
+}
+
+void ILockAccessor::GetEvent(HLERequestContext& ctx) {
+    LOG_INFO(Service_AM, "called");
+
+    lock_event->Signal();
+
+    IPC::ResponseBuilder rb{ctx, 2, 1};
+    rb.Push(ResultSuccess);
+    rb.PushCopyObjects(lock_event->GetReadableEvent());
+}
+
+void ILockAccessor::IsLocked(HLERequestContext& ctx) {
+    LOG_INFO(Service_AM, "called");
+
+    IPC::ResponseBuilder rb{ctx, 2};
+    rb.Push(ResultSuccess);
+    rb.Push<u8>(is_locked);
+}
+
 ICommonStateGetter::ICommonStateGetter(Core::System& system_,
                                        std::shared_ptr<AppletMessageQueue> msg_queue_)
     : ServiceFramework{system_, "ICommonStateGetter"}, msg_queue{std::move(msg_queue_)},
@@ -787,7 +847,7 @@ ICommonStateGetter::ICommonStateGetter(Core::System& system_,
         {14, nullptr, "GetWakeupCount"},
         {20, nullptr, "PushToGeneralChannel"},
         {30, nullptr, "GetHomeButtonReaderLockAccessor"},
-        {31, nullptr, "GetReaderLockAccessorEx"},
+        {31, &ICommonStateGetter::GetReaderLockAccessorEx, "GetReaderLockAccessorEx"},
         {32, nullptr, "GetWriterLockAccessorEx"},
         {40, nullptr, "GetCradleFwVersion"},
         {50, &ICommonStateGetter::IsVrModeEnabled, "IsVrModeEnabled"},
@@ -805,7 +865,7 @@ ICommonStateGetter::ICommonStateGetter(Core::System& system_,
         {65, nullptr, "GetApplicationIdByContentActionName"},
         {66, &ICommonStateGetter::SetCpuBoostMode, "SetCpuBoostMode"},
         {67, nullptr, "CancelCpuBoostMode"},
-        {68, nullptr, "GetBuiltInDisplayType"},
+        {68, &ICommonStateGetter::GetBuiltInDisplayType, "GetBuiltInDisplayType"},
         {80, &ICommonStateGetter::PerformSystemButtonPressingIfInFocus, "PerformSystemButtonPressingIfInFocus"},
         {90, nullptr, "SetPerformanceConfigurationChangedNotification"},
         {91, nullptr, "GetCurrentPerformanceConfiguration"},
@@ -886,6 +946,18 @@ void ICommonStateGetter::RequestToAcquireSleepLock(HLERequestContext& ctx) {
     rb.Push(ResultSuccess);
 }
 
+void ICommonStateGetter::GetReaderLockAccessorEx(HLERequestContext& ctx) {
+    IPC::RequestParser rp{ctx};
+    const auto unknown = rp.Pop<u32>();
+
+    LOG_INFO(Service_AM, "called, unknown={}", unknown);
+
+    IPC::ResponseBuilder rb{ctx, 2, 0, 1};
+
+    rb.Push(ResultSuccess);
+    rb.PushIpcInterface<ILockAccessor>(system);
+}
+
 void ICommonStateGetter::GetAcquiredSleepLockEvent(HLERequestContext& ctx) {
     LOG_WARNING(Service_AM, "called");
 
@@ -970,6 +1042,14 @@ void ICommonStateGetter::SetCpuBoostMode(HLERequestContext& ctx) {
     apm_sys->SetCpuBoostMode(ctx);
 }
 
+void ICommonStateGetter::GetBuiltInDisplayType(HLERequestContext& ctx) {
+    LOG_WARNING(Service_AM, "(STUBBED) called");
+
+    IPC::ResponseBuilder rb{ctx, 3};
+    rb.Push(ResultSuccess);
+    rb.Push(0);
+}
+
 void ICommonStateGetter::PerformSystemButtonPressingIfInFocus(HLERequestContext& ctx) {
     IPC::RequestParser rp{ctx};
     const auto system_button{rp.PopEnum<SystemButtonType>()};
@@ -1493,6 +1573,9 @@ ILibraryAppletSelfAccessor::ILibraryAppletSelfAccessor(Core::System& system_)
     case Applets::AppletId::MiiEdit:
         PushInShowMiiEditData();
         break;
+    case Applets::AppletId::PhotoViewer:
+        PushInShowAlbum();
+        break;
     default:
         break;
     }
@@ -1569,6 +1652,23 @@ void ILibraryAppletSelfAccessor::GetCallerAppletIdentityInfo(HLERequestContext&
     rb.PushRaw(applet_info);
 }
 
+void ILibraryAppletSelfAccessor::PushInShowAlbum() {
+    const Applets::CommonArguments arguments{
+        .arguments_version = Applets::CommonArgumentVersion::Version3,
+        .size = Applets::CommonArgumentSize::Version3,
+        .library_version = 1,
+        .theme_color = Applets::ThemeColor::BasicBlack,
+        .play_startup_sound = true,
+        .system_tick = system.CoreTiming().GetClockTicks(),
+    };
+
+    std::vector<u8> argument_data(sizeof(arguments));
+    std::vector<u8> settings_data{2};
+    std::memcpy(argument_data.data(), &arguments, sizeof(arguments));
+    queue_data.emplace_back(std::move(argument_data));
+    queue_data.emplace_back(std::move(settings_data));
+}
+
 void ILibraryAppletSelfAccessor::PushInShowCabinetData() {
     const Applets::CommonArguments arguments{
         .arguments_version = Applets::CommonArgumentVersion::Version3,
diff --git a/src/core/hle/service/am/am.h b/src/core/hle/service/am/am.h
index 349482dcc..4a045cfd4 100644
--- a/src/core/hle/service/am/am.h
+++ b/src/core/hle/service/am/am.h
@@ -195,6 +195,23 @@ private:
     ScreenshotPermission screenshot_permission = ScreenshotPermission::Inherit;
 };
 
+class ILockAccessor final : public ServiceFramework<ILockAccessor> {
+public:
+    explicit ILockAccessor(Core::System& system_);
+    ~ILockAccessor() override;
+
+private:
+    void TryLock(HLERequestContext& ctx);
+    void Unlock(HLERequestContext& ctx);
+    void GetEvent(HLERequestContext& ctx);
+    void IsLocked(HLERequestContext& ctx);
+
+    bool is_locked{};
+
+    Kernel::KEvent* lock_event;
+    KernelHelpers::ServiceContext service_context;
+};
+
 class ICommonStateGetter final : public ServiceFramework<ICommonStateGetter> {
 public:
     explicit ICommonStateGetter(Core::System& system_,
@@ -237,6 +254,7 @@ private:
     void GetCurrentFocusState(HLERequestContext& ctx);
     void RequestToAcquireSleepLock(HLERequestContext& ctx);
     void GetAcquiredSleepLockEvent(HLERequestContext& ctx);
+    void GetReaderLockAccessorEx(HLERequestContext& ctx);
     void GetDefaultDisplayResolutionChangeEvent(HLERequestContext& ctx);
     void GetOperationMode(HLERequestContext& ctx);
     void GetPerformanceMode(HLERequestContext& ctx);
@@ -248,6 +266,7 @@ private:
     void EndVrModeEx(HLERequestContext& ctx);
     void GetDefaultDisplayResolution(HLERequestContext& ctx);
     void SetCpuBoostMode(HLERequestContext& ctx);
+    void GetBuiltInDisplayType(HLERequestContext& ctx);
     void PerformSystemButtonPressingIfInFocus(HLERequestContext& ctx);
     void GetSettingsPlatformRegion(HLERequestContext& ctx);
     void SetRequestExitToLibraryAppletAtExecuteNextProgramEnabled(HLERequestContext& ctx);
@@ -327,6 +346,7 @@ private:
     void ExitProcessAndReturn(HLERequestContext& ctx);
     void GetCallerAppletIdentityInfo(HLERequestContext& ctx);
 
+    void PushInShowAlbum();
     void PushInShowCabinetData();
     void PushInShowMiiEditData();
 
diff --git a/src/core/hle/service/am/applet_ae.cpp b/src/core/hle/service/am/applet_ae.cpp
index eb12312cc..e30e6478a 100644
--- a/src/core/hle/service/am/applet_ae.cpp
+++ b/src/core/hle/service/am/applet_ae.cpp
@@ -28,8 +28,8 @@ public:
             {11, &ILibraryAppletProxy::GetLibraryAppletCreator, "GetLibraryAppletCreator"},
             {20, &ILibraryAppletProxy::OpenLibraryAppletSelfAccessor, "OpenLibraryAppletSelfAccessor"},
             {21, &ILibraryAppletProxy::GetAppletCommonFunctions, "GetAppletCommonFunctions"},
-            {22, nullptr, "GetHomeMenuFunctions"},
-            {23, nullptr, "GetGlobalStateController"},
+            {22, &ILibraryAppletProxy::GetHomeMenuFunctions, "GetHomeMenuFunctions"},
+            {23, &ILibraryAppletProxy::GetGlobalStateController, "GetGlobalStateController"},
             {1000, &ILibraryAppletProxy::GetDebugFunctions, "GetDebugFunctions"},
         };
         // clang-format on
@@ -110,6 +110,22 @@ private:
         rb.PushIpcInterface<IAppletCommonFunctions>(system);
     }
 
+    void GetHomeMenuFunctions(HLERequestContext& ctx) {
+        LOG_DEBUG(Service_AM, "called");
+
+        IPC::ResponseBuilder rb{ctx, 2, 0, 1};
+        rb.Push(ResultSuccess);
+        rb.PushIpcInterface<IHomeMenuFunctions>(system);
+    }
+
+    void GetGlobalStateController(HLERequestContext& ctx) {
+        LOG_DEBUG(Service_AM, "called");
+
+        IPC::ResponseBuilder rb{ctx, 2, 0, 1};
+        rb.Push(ResultSuccess);
+        rb.PushIpcInterface<IGlobalStateController>(system);
+    }
+
     void GetDebugFunctions(HLERequestContext& ctx) {
         LOG_DEBUG(Service_AM, "called");
 
diff --git a/src/core/hle/service/am/applets/applet_error.cpp b/src/core/hle/service/am/applets/applet_error.cpp
index b46ea840c..5d17c353f 100644
--- a/src/core/hle/service/am/applets/applet_error.cpp
+++ b/src/core/hle/service/am/applets/applet_error.cpp
@@ -138,6 +138,10 @@ void Error::Initialize() {
         CopyArgumentData(data, args->application_error);
         error_code = Result(args->application_error.error_code);
         break;
+    case ErrorAppletMode::ShowErrorPctl:
+        CopyArgumentData(data, args->error_record);
+        error_code = Decode64BitError(args->error_record.error_code_64);
+        break;
     case ErrorAppletMode::ShowErrorRecord:
         CopyArgumentData(data, args->error_record);
         error_code = Decode64BitError(args->error_record.error_code_64);
@@ -191,6 +195,7 @@ void Error::Execute() {
         frontend.ShowCustomErrorText(error_code, main_text_string, detail_text_string, callback);
         break;
     }
+    case ErrorAppletMode::ShowErrorPctl:
     case ErrorAppletMode::ShowErrorRecord:
         reporter.SaveErrorReport(title_id, error_code,
                                  fmt::format("{:016X}", args->error_record.posix_time));
diff --git a/src/core/hle/service/caps/caps.cpp b/src/core/hle/service/caps/caps.cpp
index 610fe9940..286f9fd10 100644
--- a/src/core/hle/service/caps/caps.cpp
+++ b/src/core/hle/service/caps/caps.cpp
@@ -4,6 +4,7 @@
 #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"
 #include "core/hle/service/caps/caps_ss.h"
 #include "core/hle/service/caps/caps_su.h"
@@ -15,13 +16,21 @@ namespace Service::Capture {
 
 void LoopProcess(Core::System& system) {
     auto server_manager = std::make_unique<ServerManager>(system);
+    auto album_manager = std::make_shared<AlbumManager>();
+
+    server_manager->RegisterNamedService(
+        "caps:a", std::make_shared<IAlbumAccessorService>(system, album_manager));
+    server_manager->RegisterNamedService(
+        "caps:c", std::make_shared<IAlbumControlService>(system, album_manager));
+    server_manager->RegisterNamedService(
+        "caps:u", std::make_shared<IAlbumApplicationService>(system, album_manager));
+
+    server_manager->RegisterNamedService("caps:ss", std::make_shared<IScreenShotService>(system));
+    server_manager->RegisterNamedService("caps:sc",
+                                         std::make_shared<IScreenShotControlService>(system));
+    server_manager->RegisterNamedService("caps:su",
+                                         std::make_shared<IScreenShotApplicationService>(system));
 
-    server_manager->RegisterNamedService("caps:a", std::make_shared<CAPS_A>(system));
-    server_manager->RegisterNamedService("caps:c", std::make_shared<CAPS_C>(system));
-    server_manager->RegisterNamedService("caps:u", std::make_shared<CAPS_U>(system));
-    server_manager->RegisterNamedService("caps:sc", std::make_shared<CAPS_SC>(system));
-    server_manager->RegisterNamedService("caps:ss", std::make_shared<CAPS_SS>(system));
-    server_manager->RegisterNamedService("caps:su", std::make_shared<CAPS_SU>(system));
     ServerManager::RunServer(std::move(server_manager));
 }
 
diff --git a/src/core/hle/service/caps/caps.h b/src/core/hle/service/caps/caps.h
index 15f0ecfaa..58e9725b8 100644
--- a/src/core/hle/service/caps/caps.h
+++ b/src/core/hle/service/caps/caps.h
@@ -3,93 +3,12 @@
 
 #pragma once
 
-#include "common/common_funcs.h"
-#include "common/common_types.h"
-
 namespace Core {
 class System;
 }
 
-namespace Service::SM {
-class ServiceManager;
-}
-
 namespace Service::Capture {
 
-enum class AlbumImageOrientation {
-    Orientation0 = 0,
-    Orientation1 = 1,
-    Orientation2 = 2,
-    Orientation3 = 3,
-};
-
-enum class AlbumReportOption : s32 {
-    Disable = 0,
-    Enable = 1,
-};
-
-enum class ContentType : u8 {
-    Screenshot = 0,
-    Movie = 1,
-    ExtraMovie = 3,
-};
-
-enum class AlbumStorage : u8 {
-    NAND = 0,
-    SD = 1,
-};
-
-struct AlbumFileDateTime {
-    s16 year{};
-    s8 month{};
-    s8 day{};
-    s8 hour{};
-    s8 minute{};
-    s8 second{};
-    s8 uid{};
-};
-static_assert(sizeof(AlbumFileDateTime) == 0x8, "AlbumFileDateTime has incorrect size.");
-
-struct AlbumEntry {
-    u64 size{};
-    u64 application_id{};
-    AlbumFileDateTime datetime{};
-    AlbumStorage storage{};
-    ContentType content{};
-    INSERT_PADDING_BYTES(6);
-};
-static_assert(sizeof(AlbumEntry) == 0x20, "AlbumEntry has incorrect size.");
-
-struct AlbumFileEntry {
-    u64 size{}; // Size of the entry
-    u64 hash{}; // AES256 with hardcoded key over AlbumEntry
-    AlbumFileDateTime datetime{};
-    AlbumStorage storage{};
-    ContentType content{};
-    INSERT_PADDING_BYTES(5);
-    u8 unknown{1}; // Set to 1 on official SW
-};
-static_assert(sizeof(AlbumFileEntry) == 0x20, "AlbumFileEntry has incorrect size.");
-
-struct ApplicationAlbumEntry {
-    u64 size{}; // Size of the entry
-    u64 hash{}; // AES256 with hardcoded key over AlbumEntry
-    AlbumFileDateTime datetime{};
-    AlbumStorage storage{};
-    ContentType content{};
-    INSERT_PADDING_BYTES(5);
-    u8 unknown{1}; // Set to 1 on official SW
-};
-static_assert(sizeof(ApplicationAlbumEntry) == 0x20, "ApplicationAlbumEntry has incorrect size.");
-
-struct ApplicationAlbumFileEntry {
-    ApplicationAlbumEntry entry{};
-    AlbumFileDateTime datetime{};
-    u64 unknown{};
-};
-static_assert(sizeof(ApplicationAlbumFileEntry) == 0x30,
-              "ApplicationAlbumFileEntry has incorrect size.");
-
 void LoopProcess(Core::System& system);
 
 } // namespace Service::Capture
diff --git a/src/core/hle/service/caps/caps_a.cpp b/src/core/hle/service/caps/caps_a.cpp
index 44267b284..e22f72bf6 100644
--- a/src/core/hle/service/caps/caps_a.cpp
+++ b/src/core/hle/service/caps/caps_a.cpp
@@ -1,40 +1,26 @@
 // SPDX-FileCopyrightText: Copyright 2020 yuzu Emulator Project
 // SPDX-License-Identifier: GPL-2.0-or-later
 
+#include "common/logging/log.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/caps/caps_types.h"
+#include "core/hle/service/ipc_helpers.h"
 
 namespace Service::Capture {
 
-class IAlbumAccessorSession final : public ServiceFramework<IAlbumAccessorSession> {
-public:
-    explicit IAlbumAccessorSession(Core::System& system_)
-        : ServiceFramework{system_, "IAlbumAccessorSession"} {
-        // clang-format off
-        static const FunctionInfo functions[] = {
-            {2001, nullptr, "OpenAlbumMovieReadStream"},
-            {2002, nullptr, "CloseAlbumMovieReadStream"},
-            {2003, nullptr, "GetAlbumMovieReadStreamMovieDataSize"},
-            {2004, nullptr, "ReadMovieDataFromAlbumMovieReadStream"},
-            {2005, nullptr, "GetAlbumMovieReadStreamBrokenReason"},
-            {2006, nullptr, "GetAlbumMovieReadStreamImageDataSize"},
-            {2007, nullptr, "ReadImageDataFromAlbumMovieReadStream"},
-            {2008, nullptr, "ReadFileAttributeFromAlbumMovieReadStream"},
-        };
-        // clang-format on
-
-        RegisterHandlers(functions);
-    }
-};
-
-CAPS_A::CAPS_A(Core::System& system_) : ServiceFramework{system_, "caps:a"} {
+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, nullptr, "GetAlbumFileList"},
         {2, nullptr, "LoadAlbumFile"},
-        {3, nullptr, "DeleteAlbumFile"},
+        {3, &IAlbumAccessorService::DeleteAlbumFile, "DeleteAlbumFile"},
         {4, nullptr, "StorageCopyAlbumFile"},
-        {5, nullptr, "IsAlbumMounted"},
+        {5, &IAlbumAccessorService::IsAlbumMounted, "IsAlbumMounted"},
         {6, nullptr, "GetAlbumUsage"},
         {7, nullptr, "GetAlbumFileSize"},
         {8, nullptr, "LoadAlbumFileThumbnail"},
@@ -47,18 +33,18 @@ CAPS_A::CAPS_A(Core::System& system_) : ServiceFramework{system_, "caps:a"} {
         {15, nullptr, "GetAlbumUsage3"},
         {16, nullptr, "GetAlbumMountResult"},
         {17, nullptr, "GetAlbumUsage16"},
-        {18, nullptr, "Unknown18"},
+        {18, &IAlbumAccessorService::Unknown18, "Unknown18"},
         {19, nullptr, "Unknown19"},
         {100, nullptr, "GetAlbumFileCountEx0"},
-        {101, nullptr, "GetAlbumFileListEx0"},
+        {101, &IAlbumAccessorService::GetAlbumFileListEx0, "GetAlbumFileListEx0"},
         {202, nullptr, "SaveEditedScreenShot"},
         {301, nullptr, "GetLastThumbnail"},
         {302, nullptr, "GetLastOverlayMovieThumbnail"},
-        {401, nullptr, "GetAutoSavingStorage"},
+        {401,  &IAlbumAccessorService::GetAutoSavingStorage, "GetAutoSavingStorage"},
         {501, nullptr, "GetRequiredStorageSpaceSizeToCopyAll"},
         {1001, nullptr, "LoadAlbumScreenShotThumbnailImageEx0"},
-        {1002, nullptr, "LoadAlbumScreenShotImageEx1"},
-        {1003, nullptr, "LoadAlbumScreenShotThumbnailImageEx1"},
+        {1002, &IAlbumAccessorService::LoadAlbumScreenShotImageEx1, "LoadAlbumScreenShotImageEx1"},
+        {1003, &IAlbumAccessorService::LoadAlbumScreenShotThumbnailImageEx1, "LoadAlbumScreenShotThumbnailImageEx1"},
         {8001, nullptr, "ForceAlbumUnmounted"},
         {8002, nullptr, "ResetAlbumMountStatus"},
         {8011, nullptr, "RefreshAlbumCache"},
@@ -74,6 +60,199 @@ CAPS_A::CAPS_A(Core::System& system_) : ServiceFramework{system_, "caps:a"} {
     RegisterHandlers(functions);
 }
 
-CAPS_A::~CAPS_A() = default;
+IAlbumAccessorService::~IAlbumAccessorService() = default;
+
+void IAlbumAccessorService::DeleteAlbumFile(HLERequestContext& ctx) {
+    IPC::RequestParser rp{ctx};
+    const auto file_id{rp.PopRaw<AlbumFileId>()};
+
+    LOG_INFO(Service_Capture, "called, application_id=0x{:0x}, storage={}, type={}",
+             file_id.application_id, file_id.storage, file_id.type);
+
+    Result result = manager->DeleteAlbumFile(file_id);
+    result = TranslateResult(result);
+
+    IPC::ResponseBuilder rb{ctx, 2};
+    rb.Push(result);
+}
+
+void IAlbumAccessorService::IsAlbumMounted(HLERequestContext& ctx) {
+    IPC::RequestParser rp{ctx};
+    const auto storage{rp.PopEnum<AlbumStorage>()};
+
+    LOG_INFO(Service_Capture, "called, storage={}", storage);
+
+    Result result = manager->IsAlbumMounted(storage);
+    const bool is_mounted = result.IsSuccess();
+    result = TranslateResult(result);
+
+    IPC::ResponseBuilder rb{ctx, 3};
+    rb.Push(result);
+    rb.Push<u8>(is_mounted);
+}
+
+void IAlbumAccessorService::Unknown18(HLERequestContext& ctx) {
+    struct UnknownBuffer {
+        INSERT_PADDING_BYTES(0x10);
+    };
+    static_assert(sizeof(UnknownBuffer) == 0x10, "UnknownBuffer is an invalid size");
+
+    LOG_WARNING(Service_Capture, "(STUBBED) called");
+
+    std::vector<UnknownBuffer> buffer{};
+
+    if (!buffer.empty()) {
+        ctx.WriteBuffer(buffer);
+    }
+
+    IPC::ResponseBuilder rb{ctx, 3};
+    rb.Push(ResultSuccess);
+    rb.Push(static_cast<u32>(buffer.size()));
+}
+
+void IAlbumAccessorService::GetAlbumFileListEx0(HLERequestContext& ctx) {
+    IPC::RequestParser rp{ctx};
+    const auto storage{rp.PopEnum<AlbumStorage>()};
+    const auto flags{rp.Pop<u8>()};
+    const auto album_entry_size{ctx.GetWriteBufferNumElements<AlbumEntry>()};
+
+    LOG_INFO(Service_Capture, "called, storage={}, flags={}", storage, flags);
+
+    std::vector<AlbumEntry> entries;
+    Result result = manager->GetAlbumFileList(entries, storage, flags);
+    result = TranslateResult(result);
+
+    entries.resize(std::min(album_entry_size, entries.size()));
+
+    if (!entries.empty()) {
+        ctx.WriteBuffer(entries);
+    }
+
+    IPC::ResponseBuilder rb{ctx, 3};
+    rb.Push(result);
+    rb.Push(entries.size());
+}
+
+void IAlbumAccessorService::GetAutoSavingStorage(HLERequestContext& ctx) {
+    LOG_WARNING(Service_Capture, "(STUBBED) called");
+
+    bool is_autosaving{};
+    Result result = manager->GetAutoSavingStorage(is_autosaving);
+    result = TranslateResult(result);
+
+    IPC::ResponseBuilder rb{ctx, 3};
+    rb.Push(result);
+    rb.Push<u8>(is_autosaving);
+}
+
+void IAlbumAccessorService::LoadAlbumScreenShotImageEx1(HLERequestContext& ctx) {
+    IPC::RequestParser rp{ctx};
+    const auto file_id{rp.PopRaw<AlbumFileId>()};
+    const auto decoder_options{rp.PopRaw<ScreenShotDecodeOption>()};
+    const auto image_buffer_size{ctx.GetWriteBufferSize(1)};
+
+    LOG_INFO(Service_Capture, "called, application_id=0x{:0x}, storage={}, type={}, flags={}",
+             file_id.application_id, file_id.storage, file_id.type, decoder_options.flags);
+
+    std::vector<u8> image;
+    LoadAlbumScreenShotImageOutput image_output;
+    Result result =
+        manager->LoadAlbumScreenShotImage(image_output, image, file_id, decoder_options);
+    result = TranslateResult(result);
+
+    if (image.size() > image_buffer_size) {
+        result = ResultWorkMemoryError;
+    }
+
+    if (result.IsSuccess()) {
+        ctx.WriteBuffer(image_output, 0);
+        ctx.WriteBuffer(image, 1);
+    }
+
+    IPC::ResponseBuilder rb{ctx, 2};
+    rb.Push(result);
+}
+
+void IAlbumAccessorService::LoadAlbumScreenShotThumbnailImageEx1(HLERequestContext& ctx) {
+    IPC::RequestParser rp{ctx};
+    const auto file_id{rp.PopRaw<AlbumFileId>()};
+    const auto decoder_options{rp.PopRaw<ScreenShotDecodeOption>()};
+
+    LOG_INFO(Service_Capture, "called, application_id=0x{:0x}, storage={}, type={}, flags={}",
+             file_id.application_id, file_id.storage, file_id.type, decoder_options.flags);
+
+    std::vector<u8> image(ctx.GetWriteBufferSize(1));
+    LoadAlbumScreenShotImageOutput image_output;
+    Result result =
+        manager->LoadAlbumScreenShotThumbnail(image_output, image, file_id, decoder_options);
+    result = TranslateResult(result);
+
+    if (result.IsSuccess()) {
+        ctx.WriteBuffer(image_output, 0);
+        ctx.WriteBuffer(image, 1);
+    }
+
+    IPC::ResponseBuilder rb{ctx, 2};
+    rb.Push(result);
+}
+
+Result IAlbumAccessorService::TranslateResult(Result in_result) {
+    if (in_result.IsSuccess()) {
+        return in_result;
+    }
+
+    if ((in_result.raw & 0x3801ff) == ResultUnknown1024.raw) {
+        if (in_result.description - 0x514 < 100) {
+            return ResultInvalidFileData;
+        }
+        if (in_result.description - 0x5dc < 100) {
+            return ResultInvalidFileData;
+        }
+
+        if (in_result.description - 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.module == ErrorModule::FS) {
+        if ((in_result.description >> 0xc < 0x7d) || (in_result.description - 1000 < 2000) ||
+            (((in_result.description - 3000) >> 3) < 0x271)) {
+            // TODO: Translate FS error
+            return in_result;
+        }
+    }
+
+    return in_result;
+}
 
 } // namespace Service::Capture
diff --git a/src/core/hle/service/caps/caps_a.h b/src/core/hle/service/caps/caps_a.h
index 98a21a5ad..c90cff71e 100644
--- a/src/core/hle/service/caps/caps_a.h
+++ b/src/core/hle/service/caps/caps_a.h
@@ -10,11 +10,26 @@ class System;
 }
 
 namespace Service::Capture {
+class AlbumManager;
 
-class CAPS_A final : public ServiceFramework<CAPS_A> {
+class IAlbumAccessorService final : public ServiceFramework<IAlbumAccessorService> {
 public:
-    explicit CAPS_A(Core::System& system_);
-    ~CAPS_A() override;
+    explicit IAlbumAccessorService(Core::System& system_,
+                                   std::shared_ptr<AlbumManager> album_manager);
+    ~IAlbumAccessorService() override;
+
+private:
+    void DeleteAlbumFile(HLERequestContext& ctx);
+    void IsAlbumMounted(HLERequestContext& ctx);
+    void Unknown18(HLERequestContext& ctx);
+    void GetAlbumFileListEx0(HLERequestContext& ctx);
+    void GetAutoSavingStorage(HLERequestContext& ctx);
+    void LoadAlbumScreenShotImageEx1(HLERequestContext& ctx);
+    void LoadAlbumScreenShotThumbnailImageEx1(HLERequestContext& ctx);
+
+    Result TranslateResult(Result in_result);
+
+    std::shared_ptr<AlbumManager> manager = nullptr;
 };
 
 } // namespace Service::Capture
diff --git a/src/core/hle/service/caps/caps_c.cpp b/src/core/hle/service/caps/caps_c.cpp
index fc77e35cd..1e7fe6474 100644
--- a/src/core/hle/service/caps/caps_c.cpp
+++ b/src/core/hle/service/caps/caps_c.cpp
@@ -3,53 +3,21 @@
 
 #include "common/logging/log.h"
 #include "core/hle/service/caps/caps_c.h"
+#include "core/hle/service/caps/caps_manager.h"
+#include "core/hle/service/caps/caps_result.h"
+#include "core/hle/service/caps/caps_types.h"
 #include "core/hle/service/ipc_helpers.h"
 
 namespace Service::Capture {
 
-class IAlbumControlSession final : public ServiceFramework<IAlbumControlSession> {
-public:
-    explicit IAlbumControlSession(Core::System& system_)
-        : ServiceFramework{system_, "IAlbumControlSession"} {
-        // clang-format off
-        static const FunctionInfo functions[] = {
-            {2001, nullptr, "OpenAlbumMovieReadStream"},
-            {2002, nullptr, "CloseAlbumMovieReadStream"},
-            {2003, nullptr, "GetAlbumMovieReadStreamMovieDataSize"},
-            {2004, nullptr, "ReadMovieDataFromAlbumMovieReadStream"},
-            {2005, nullptr, "GetAlbumMovieReadStreamBrokenReason"},
-            {2006, nullptr, "GetAlbumMovieReadStreamImageDataSize"},
-            {2007, nullptr, "ReadImageDataFromAlbumMovieReadStream"},
-            {2008, nullptr, "ReadFileAttributeFromAlbumMovieReadStream"},
-            {2401, nullptr, "OpenAlbumMovieWriteStream"},
-            {2402, nullptr, "FinishAlbumMovieWriteStream"},
-            {2403, nullptr, "CommitAlbumMovieWriteStream"},
-            {2404, nullptr, "DiscardAlbumMovieWriteStream"},
-            {2405, nullptr, "DiscardAlbumMovieWriteStreamNoDelete"},
-            {2406, nullptr, "CommitAlbumMovieWriteStreamEx"},
-            {2411, nullptr, "StartAlbumMovieWriteStreamDataSection"},
-            {2412, nullptr, "EndAlbumMovieWriteStreamDataSection"},
-            {2413, nullptr, "StartAlbumMovieWriteStreamMetaSection"},
-            {2414, nullptr, "EndAlbumMovieWriteStreamMetaSection"},
-            {2421, nullptr, "ReadDataFromAlbumMovieWriteStream"},
-            {2422, nullptr, "WriteDataToAlbumMovieWriteStream"},
-            {2424, nullptr, "WriteMetaToAlbumMovieWriteStream"},
-            {2431, nullptr, "GetAlbumMovieWriteStreamBrokenReason"},
-            {2433, nullptr, "GetAlbumMovieWriteStreamDataSize"},
-            {2434, nullptr, "SetAlbumMovieWriteStreamDataSize"},
-        };
-        // clang-format on
-
-        RegisterHandlers(functions);
-    }
-};
-
-CAPS_C::CAPS_C(Core::System& system_) : ServiceFramework{system_, "caps:c"} {
+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, &CAPS_C::SetShimLibraryVersion, "SetShimLibraryVersion"},
+        {33, &IAlbumControlService::SetShimLibraryVersion, "SetShimLibraryVersion"},
         {1001, nullptr, "RequestTakingScreenShot"},
         {1002, nullptr, "RequestTakingScreenShotWithTimeout"},
         {1011, nullptr, "NotifyTakingScreenShotRefused"},
@@ -72,9 +40,9 @@ CAPS_C::CAPS_C(Core::System& system_) : ServiceFramework{system_, "caps:c"} {
     RegisterHandlers(functions);
 }
 
-CAPS_C::~CAPS_C() = default;
+IAlbumControlService::~IAlbumControlService() = default;
 
-void CAPS_C::SetShimLibraryVersion(HLERequestContext& ctx) {
+void IAlbumControlService::SetShimLibraryVersion(HLERequestContext& ctx) {
     IPC::RequestParser rp{ctx};
     const auto library_version{rp.Pop<u64>()};
     const auto applet_resource_user_id{rp.Pop<u64>()};
diff --git a/src/core/hle/service/caps/caps_c.h b/src/core/hle/service/caps/caps_c.h
index 537b3a2e3..92ba242db 100644
--- a/src/core/hle/service/caps/caps_c.h
+++ b/src/core/hle/service/caps/caps_c.h
@@ -10,14 +10,18 @@ class System;
 }
 
 namespace Service::Capture {
+class AlbumManager;
 
-class CAPS_C final : public ServiceFramework<CAPS_C> {
+class IAlbumControlService final : public ServiceFramework<IAlbumControlService> {
 public:
-    explicit CAPS_C(Core::System& system_);
-    ~CAPS_C() override;
+    explicit IAlbumControlService(Core::System& system_,
+                                  std::shared_ptr<AlbumManager> album_manager);
+    ~IAlbumControlService() override;
 
 private:
     void SetShimLibraryVersion(HLERequestContext& ctx);
+
+    std::shared_ptr<AlbumManager> manager = nullptr;
 };
 
 } // namespace Service::Capture
diff --git a/src/core/hle/service/caps/caps_manager.cpp b/src/core/hle/service/caps/caps_manager.cpp
new file mode 100644
index 000000000..2df6a930a
--- /dev/null
+++ b/src/core/hle/service/caps/caps_manager.cpp
@@ -0,0 +1,342 @@
+// SPDX-FileCopyrightText: Copyright 2023 yuzu Emulator Project
+// SPDX-License-Identifier: GPL-2.0-or-later
+
+#include <sstream>
+#include <stb_image.h>
+#include <stb_image_resize.h>
+
+#include "common/fs/file.h"
+#include "common/fs/path_util.h"
+#include "common/logging/log.h"
+#include "core/hle/service/caps/caps_manager.h"
+#include "core/hle/service/caps/caps_result.h"
+
+namespace Service::Capture {
+
+AlbumManager::AlbumManager() {}
+
+AlbumManager::~AlbumManager() = default;
+
+Result AlbumManager::DeleteAlbumFile(const AlbumFileId& file_id) {
+    if (file_id.storage > AlbumStorage::Sd) {
+        return ResultInvalidStorage;
+    }
+
+    if (!is_mounted) {
+        return ResultIsNotMounted;
+    }
+
+    std::filesystem::path path;
+    const auto result = GetFile(path, file_id);
+
+    if (result.IsError()) {
+        return result;
+    }
+
+    if (!Common::FS::RemoveFile(path)) {
+        return ResultFileNotFound;
+    }
+
+    return ResultSuccess;
+}
+
+Result AlbumManager::IsAlbumMounted(AlbumStorage storage) {
+    if (storage > AlbumStorage::Sd) {
+        return ResultInvalidStorage;
+    }
+
+    is_mounted = true;
+
+    if (storage == AlbumStorage::Sd) {
+        FindScreenshots();
+    }
+
+    return is_mounted ? ResultSuccess : ResultIsNotMounted;
+}
+
+Result AlbumManager::GetAlbumFileList(std::vector<AlbumEntry>& out_entries, AlbumStorage storage,
+                                      u8 flags) const {
+    if (storage > AlbumStorage::Sd) {
+        return ResultInvalidStorage;
+    }
+
+    if (!is_mounted) {
+        return ResultIsNotMounted;
+    }
+
+    for (auto& [file_id, path] : album_files) {
+        if (file_id.storage != storage) {
+            continue;
+        }
+        if (out_entries.size() >= SdAlbumFileLimit) {
+            break;
+        }
+
+        const auto entry_size = Common::FS::GetSize(path);
+        out_entries.push_back({
+            .entry_size = entry_size,
+            .file_id = file_id,
+        });
+    }
+
+    return ResultSuccess;
+}
+
+Result AlbumManager::GetAlbumFileList(std::vector<ApplicationAlbumFileEntry>& out_entries,
+                                      ContentType contex_type, AlbumFileDateTime start_date,
+                                      AlbumFileDateTime end_date, u64 aruid) const {
+    if (!is_mounted) {
+        return ResultIsNotMounted;
+    }
+
+    for (auto& [file_id, path] : album_files) {
+        if (file_id.type != contex_type) {
+            continue;
+        }
+
+        if (file_id.date > start_date) {
+            continue;
+        }
+
+        if (file_id.date < end_date) {
+            continue;
+        }
+
+        if (out_entries.size() >= SdAlbumFileLimit) {
+            break;
+        }
+
+        const auto entry_size = Common::FS::GetSize(path);
+        ApplicationAlbumFileEntry entry{.entry =
+                                            {
+                                                .size = entry_size,
+                                                .hash{},
+                                                .datetime = file_id.date,
+                                                .storage = file_id.storage,
+                                                .content = contex_type,
+                                                .unknown = 1,
+                                            },
+                                        .datetime = file_id.date,
+                                        .unknown = {}};
+        out_entries.push_back(entry);
+    }
+
+    return ResultSuccess;
+}
+
+Result AlbumManager::GetAutoSavingStorage(bool& out_is_autosaving) const {
+    out_is_autosaving = false;
+    return ResultSuccess;
+}
+
+Result AlbumManager::LoadAlbumScreenShotImage(LoadAlbumScreenShotImageOutput& out_image_output,
+                                              std::vector<u8>& out_image,
+                                              const AlbumFileId& file_id,
+                                              const ScreenShotDecodeOption& decoder_options) const {
+    if (file_id.storage > AlbumStorage::Sd) {
+        return ResultInvalidStorage;
+    }
+
+    if (!is_mounted) {
+        return ResultIsNotMounted;
+    }
+
+    out_image_output = {
+        .width = 1280,
+        .height = 720,
+        .attribute =
+            {
+                .unknown_0{},
+                .orientation = AlbumImageOrientation::None,
+                .unknown_1{},
+                .unknown_2{},
+            },
+    };
+
+    std::filesystem::path path;
+    const auto result = GetFile(path, file_id);
+
+    if (result.IsError()) {
+        return result;
+    }
+
+    out_image.resize(out_image_output.height * out_image_output.width * STBI_rgb_alpha);
+
+    return LoadImage(out_image, path, static_cast<int>(out_image_output.width),
+                     +static_cast<int>(out_image_output.height), decoder_options.flags);
+}
+
+Result AlbumManager::LoadAlbumScreenShotThumbnail(
+    LoadAlbumScreenShotImageOutput& out_image_output, std::vector<u8>& out_image,
+    const AlbumFileId& file_id, const ScreenShotDecodeOption& decoder_options) const {
+    if (file_id.storage > AlbumStorage::Sd) {
+        return ResultInvalidStorage;
+    }
+
+    if (!is_mounted) {
+        return ResultIsNotMounted;
+    }
+
+    out_image_output = {
+        .width = 320,
+        .height = 180,
+        .attribute =
+            {
+                .unknown_0{},
+                .orientation = AlbumImageOrientation::None,
+                .unknown_1{},
+                .unknown_2{},
+            },
+    };
+
+    std::filesystem::path path;
+    const auto result = GetFile(path, file_id);
+
+    if (result.IsError()) {
+        return result;
+    }
+
+    out_image.resize(out_image_output.height * out_image_output.width * STBI_rgb_alpha);
+
+    return LoadImage(out_image, path, static_cast<int>(out_image_output.width),
+                     +static_cast<int>(out_image_output.height), decoder_options.flags);
+}
+
+Result AlbumManager::GetFile(std::filesystem::path& out_path, const AlbumFileId& file_id) const {
+    const auto file = album_files.find(file_id);
+
+    if (file == album_files.end()) {
+        return ResultFileNotFound;
+    }
+
+    out_path = file->second;
+    return ResultSuccess;
+}
+
+void AlbumManager::FindScreenshots() {
+    is_mounted = false;
+    album_files.clear();
+
+    // TODO: Swap this with a blocking operation.
+    const auto screenshots_dir = Common::FS::GetYuzuPath(Common::FS::YuzuPath::ScreenshotsDir);
+    Common::FS::IterateDirEntries(
+        screenshots_dir,
+        [this](const std::filesystem::path& full_path) {
+            AlbumEntry entry;
+            if (GetAlbumEntry(entry, full_path).IsError()) {
+                return true;
+            }
+            while (album_files.contains(entry.file_id)) {
+                if (++entry.file_id.date.unique_id == 0) {
+                    break;
+                }
+            }
+            album_files[entry.file_id] = full_path;
+            return true;
+        },
+        Common::FS::DirEntryFilter::File);
+
+    is_mounted = true;
+}
+
+Result AlbumManager::GetAlbumEntry(AlbumEntry& out_entry, const std::filesystem::path& path) const {
+    std::istringstream line_stream(path.filename().string());
+    std::string date;
+    std::string application;
+    std::string time;
+
+    // Parse filename to obtain entry properties
+    std::getline(line_stream, application, '_');
+    std::getline(line_stream, date, '_');
+    std::getline(line_stream, time, '_');
+
+    std::istringstream date_stream(date);
+    std::istringstream time_stream(time);
+    std::string year;
+    std::string month;
+    std::string day;
+    std::string hour;
+    std::string minute;
+    std::string second;
+
+    std::getline(date_stream, year, '-');
+    std::getline(date_stream, month, '-');
+    std::getline(date_stream, day, '-');
+
+    std::getline(time_stream, hour, '-');
+    std::getline(time_stream, minute, '-');
+    std::getline(time_stream, second, '-');
+
+    try {
+        out_entry = {
+            .entry_size = 1,
+            .file_id{
+                .application_id = static_cast<u64>(std::stoll(application, 0, 16)),
+                .date =
+                    {
+                        .year = static_cast<u16>(std::stoi(year)),
+                        .month = static_cast<u8>(std::stoi(month)),
+                        .day = static_cast<u8>(std::stoi(day)),
+                        .hour = static_cast<u8>(std::stoi(hour)),
+                        .minute = static_cast<u8>(std::stoi(minute)),
+                        .second = static_cast<u8>(std::stoi(second)),
+                        .unique_id = 0,
+                    },
+                .storage = AlbumStorage::Sd,
+                .type = ContentType::Screenshot,
+                .unknown = 1,
+            },
+        };
+    } catch (const std::invalid_argument&) {
+        return ResultUnknown;
+    } catch (const std::out_of_range&) {
+        return ResultUnknown;
+    } catch (const std::exception&) {
+        return ResultUnknown;
+    }
+
+    return ResultSuccess;
+}
+
+Result AlbumManager::LoadImage(std::span<u8> out_image, const std::filesystem::path& path,
+                               int width, int height, ScreenShotDecoderFlag flag) const {
+    if (out_image.size() != static_cast<std::size_t>(width * height * STBI_rgb_alpha)) {
+        return ResultUnknown;
+    }
+
+    const Common::FS::IOFile db_file{path, Common::FS::FileAccessMode::Read,
+                                     Common::FS::FileType::BinaryFile};
+
+    std::vector<u8> raw_file(db_file.GetSize());
+    if (db_file.Read(raw_file) != raw_file.size()) {
+        return ResultUnknown;
+    }
+
+    int filter_flag = STBIR_FILTER_DEFAULT;
+    int original_width, original_height, color_channels;
+    const auto dbi_image =
+        stbi_load_from_memory(raw_file.data(), static_cast<int>(raw_file.size()), &original_width,
+                              &original_height, &color_channels, STBI_rgb_alpha);
+
+    if (dbi_image == nullptr) {
+        return ResultUnknown;
+    }
+
+    switch (flag) {
+    case ScreenShotDecoderFlag::EnableFancyUpsampling:
+        filter_flag = STBIR_FILTER_TRIANGLE;
+        break;
+    case ScreenShotDecoderFlag::EnableBlockSmoothing:
+        filter_flag = STBIR_FILTER_BOX;
+        break;
+    default:
+        filter_flag = STBIR_FILTER_DEFAULT;
+        break;
+    }
+
+    stbir_resize_uint8_srgb(dbi_image, original_width, original_height, 0, out_image.data(), width,
+                            height, 0, STBI_rgb_alpha, 3, filter_flag);
+
+    return ResultSuccess;
+}
+} // namespace Service::Capture
diff --git a/src/core/hle/service/caps/caps_manager.h b/src/core/hle/service/caps/caps_manager.h
new file mode 100644
index 000000000..8337c655c
--- /dev/null
+++ b/src/core/hle/service/caps/caps_manager.h
@@ -0,0 +1,72 @@
+// SPDX-FileCopyrightText: Copyright 2023 yuzu Emulator Project
+// SPDX-License-Identifier: GPL-2.0-or-later
+
+#pragma once
+
+#include <unordered_map>
+
+#include "common/fs/fs.h"
+#include "core/hle/result.h"
+#include "core/hle/service/caps/caps_types.h"
+
+namespace Core {
+class System;
+}
+
+namespace std {
+// Hash used to create lists from AlbumFileId data
+template <>
+struct hash<Service::Capture::AlbumFileId> {
+    size_t operator()(const Service::Capture::AlbumFileId& pad_id) const noexcept {
+        u64 hash_value = (static_cast<u64>(pad_id.date.year) << 8);
+        hash_value ^= (static_cast<u64>(pad_id.date.month) << 7);
+        hash_value ^= (static_cast<u64>(pad_id.date.day) << 6);
+        hash_value ^= (static_cast<u64>(pad_id.date.hour) << 5);
+        hash_value ^= (static_cast<u64>(pad_id.date.minute) << 4);
+        hash_value ^= (static_cast<u64>(pad_id.date.second) << 3);
+        hash_value ^= (static_cast<u64>(pad_id.date.unique_id) << 2);
+        hash_value ^= (static_cast<u64>(pad_id.storage) << 1);
+        hash_value ^= static_cast<u64>(pad_id.type);
+        return static_cast<size_t>(hash_value);
+    }
+};
+
+} // namespace std
+
+namespace Service::Capture {
+
+class AlbumManager {
+public:
+    explicit AlbumManager();
+    ~AlbumManager();
+
+    Result DeleteAlbumFile(const AlbumFileId& file_id);
+    Result IsAlbumMounted(AlbumStorage storage);
+    Result GetAlbumFileList(std::vector<AlbumEntry>& out_entries, AlbumStorage storage,
+                            u8 flags) const;
+    Result GetAlbumFileList(std::vector<ApplicationAlbumFileEntry>& out_entries,
+                            ContentType contex_type, AlbumFileDateTime start_date,
+                            AlbumFileDateTime end_date, u64 aruid) const;
+    Result GetAutoSavingStorage(bool& out_is_autosaving) const;
+    Result LoadAlbumScreenShotImage(LoadAlbumScreenShotImageOutput& out_image_output,
+                                    std::vector<u8>& out_image, const AlbumFileId& file_id,
+                                    const ScreenShotDecodeOption& decoder_options) const;
+    Result LoadAlbumScreenShotThumbnail(LoadAlbumScreenShotImageOutput& out_image_output,
+                                        std::vector<u8>& out_image, const AlbumFileId& file_id,
+                                        const ScreenShotDecodeOption& decoder_options) const;
+
+private:
+    static constexpr std::size_t NandAlbumFileLimit = 1000;
+    static constexpr std::size_t SdAlbumFileLimit = 10000;
+
+    void FindScreenshots();
+    Result GetFile(std::filesystem::path& out_path, const AlbumFileId& file_id) const;
+    Result GetAlbumEntry(AlbumEntry& out_entry, const std::filesystem::path& path) const;
+    Result LoadImage(std::span<u8> out_image, const std::filesystem::path& path, int width,
+                     int height, ScreenShotDecoderFlag flag) const;
+
+    bool is_mounted{};
+    std::unordered_map<AlbumFileId, std::filesystem::path> album_files;
+};
+
+} // namespace Service::Capture
diff --git a/src/core/hle/service/caps/caps_result.h b/src/core/hle/service/caps/caps_result.h
new file mode 100644
index 000000000..c65e5fb9a
--- /dev/null
+++ b/src/core/hle/service/caps/caps_result.h
@@ -0,0 +1,35 @@
+// SPDX-FileCopyrightText: Copyright 2023 yuzu Emulator Project
+// SPDX-License-Identifier: GPL-2.0-or-later
+
+#pragma once
+
+#include "core/hle/result.h"
+
+namespace Service::Capture {
+
+constexpr Result ResultWorkMemoryError(ErrorModule::Capture, 3);
+constexpr Result ResultUnknown5(ErrorModule::Capture, 5);
+constexpr Result ResultUnknown6(ErrorModule::Capture, 6);
+constexpr Result ResultUnknown7(ErrorModule::Capture, 7);
+constexpr Result ResultOutOfRange(ErrorModule::Capture, 8);
+constexpr Result ResulInvalidTimestamp(ErrorModule::Capture, 12);
+constexpr Result ResultInvalidStorage(ErrorModule::Capture, 13);
+constexpr Result ResultInvalidFileContents(ErrorModule::Capture, 14);
+constexpr Result ResultIsNotMounted(ErrorModule::Capture, 21);
+constexpr Result ResultUnknown22(ErrorModule::Capture, 22);
+constexpr Result ResultFileNotFound(ErrorModule::Capture, 23);
+constexpr Result ResultInvalidFileData(ErrorModule::Capture, 24);
+constexpr Result ResultUnknown25(ErrorModule::Capture, 25);
+constexpr Result ResultReadBufferShortage(ErrorModule::Capture, 30);
+constexpr Result ResultUnknown810(ErrorModule::Capture, 810);
+constexpr Result ResultUnknown1024(ErrorModule::Capture, 1024);
+constexpr Result ResultUnknown1202(ErrorModule::Capture, 1202);
+constexpr Result ResultUnknown1203(ErrorModule::Capture, 1203);
+constexpr Result ResultFileCountLimit(ErrorModule::Capture, 1401);
+constexpr Result ResultUnknown1701(ErrorModule::Capture, 1701);
+constexpr Result ResultUnknown1801(ErrorModule::Capture, 1801);
+constexpr Result ResultUnknown1802(ErrorModule::Capture, 1802);
+constexpr Result ResultUnknown1803(ErrorModule::Capture, 1803);
+constexpr Result ResultUnknown1804(ErrorModule::Capture, 1804);
+
+} // namespace Service::Capture
diff --git a/src/core/hle/service/caps/caps_sc.cpp b/src/core/hle/service/caps/caps_sc.cpp
index 395b13da7..6117cb7c6 100644
--- a/src/core/hle/service/caps/caps_sc.cpp
+++ b/src/core/hle/service/caps/caps_sc.cpp
@@ -5,7 +5,8 @@
 
 namespace Service::Capture {
 
-CAPS_SC::CAPS_SC(Core::System& system_) : ServiceFramework{system_, "caps:sc"} {
+IScreenShotControlService::IScreenShotControlService(Core::System& system_)
+    : ServiceFramework{system_, "caps:sc"} {
     // clang-format off
     static const FunctionInfo functions[] = {
         {1, nullptr, "CaptureRawImage"},
@@ -34,6 +35,6 @@ CAPS_SC::CAPS_SC(Core::System& system_) : ServiceFramework{system_, "caps:sc"} {
     RegisterHandlers(functions);
 }
 
-CAPS_SC::~CAPS_SC() = default;
+IScreenShotControlService::~IScreenShotControlService() = default;
 
 } // namespace Service::Capture
diff --git a/src/core/hle/service/caps/caps_sc.h b/src/core/hle/service/caps/caps_sc.h
index e5600f6d7..d555f4979 100644
--- a/src/core/hle/service/caps/caps_sc.h
+++ b/src/core/hle/service/caps/caps_sc.h
@@ -11,10 +11,10 @@ class System;
 
 namespace Service::Capture {
 
-class CAPS_SC final : public ServiceFramework<CAPS_SC> {
+class IScreenShotControlService final : public ServiceFramework<IScreenShotControlService> {
 public:
-    explicit CAPS_SC(Core::System& system_);
-    ~CAPS_SC() override;
+    explicit IScreenShotControlService(Core::System& system_);
+    ~IScreenShotControlService() override;
 };
 
 } // namespace Service::Capture
diff --git a/src/core/hle/service/caps/caps_ss.cpp b/src/core/hle/service/caps/caps_ss.cpp
index 62b9edd41..d0d1b5425 100644
--- a/src/core/hle/service/caps/caps_ss.cpp
+++ b/src/core/hle/service/caps/caps_ss.cpp
@@ -5,7 +5,8 @@
 
 namespace Service::Capture {
 
-CAPS_SS::CAPS_SS(Core::System& system_) : ServiceFramework{system_, "caps:ss"} {
+IScreenShotService::IScreenShotService(Core::System& system_)
+    : ServiceFramework{system_, "caps:ss"} {
     // clang-format off
     static const FunctionInfo functions[] = {
         {201, nullptr, "SaveScreenShot"},
@@ -21,6 +22,6 @@ CAPS_SS::CAPS_SS(Core::System& system_) : ServiceFramework{system_, "caps:ss"} {
     RegisterHandlers(functions);
 }
 
-CAPS_SS::~CAPS_SS() = default;
+IScreenShotService::~IScreenShotService() = default;
 
 } // namespace Service::Capture
diff --git a/src/core/hle/service/caps/caps_ss.h b/src/core/hle/service/caps/caps_ss.h
index 718ade485..381e44fd4 100644
--- a/src/core/hle/service/caps/caps_ss.h
+++ b/src/core/hle/service/caps/caps_ss.h
@@ -11,10 +11,10 @@ class System;
 
 namespace Service::Capture {
 
-class CAPS_SS final : public ServiceFramework<CAPS_SS> {
+class IScreenShotService final : public ServiceFramework<IScreenShotService> {
 public:
-    explicit CAPS_SS(Core::System& system_);
-    ~CAPS_SS() override;
+    explicit IScreenShotService(Core::System& system_);
+    ~IScreenShotService() override;
 };
 
 } // namespace Service::Capture
diff --git a/src/core/hle/service/caps/caps_su.cpp b/src/core/hle/service/caps/caps_su.cpp
index 3b11cc95c..cad173dc7 100644
--- a/src/core/hle/service/caps/caps_su.cpp
+++ b/src/core/hle/service/caps/caps_su.cpp
@@ -7,10 +7,11 @@
 
 namespace Service::Capture {
 
-CAPS_SU::CAPS_SU(Core::System& system_) : ServiceFramework{system_, "caps:su"} {
+IScreenShotApplicationService::IScreenShotApplicationService(Core::System& system_)
+    : ServiceFramework{system_, "caps:su"} {
     // clang-format off
     static const FunctionInfo functions[] = {
-        {32, &CAPS_SU::SetShimLibraryVersion, "SetShimLibraryVersion"},
+        {32, &IScreenShotApplicationService::SetShimLibraryVersion, "SetShimLibraryVersion"},
         {201, nullptr, "SaveScreenShot"},
         {203, nullptr, "SaveScreenShotEx0"},
         {205, nullptr, "SaveScreenShotEx1"},
@@ -21,9 +22,9 @@ CAPS_SU::CAPS_SU(Core::System& system_) : ServiceFramework{system_, "caps:su"} {
     RegisterHandlers(functions);
 }
 
-CAPS_SU::~CAPS_SU() = default;
+IScreenShotApplicationService::~IScreenShotApplicationService() = default;
 
-void CAPS_SU::SetShimLibraryVersion(HLERequestContext& ctx) {
+void IScreenShotApplicationService::SetShimLibraryVersion(HLERequestContext& ctx) {
     IPC::RequestParser rp{ctx};
     const auto library_version{rp.Pop<u64>()};
     const auto applet_resource_user_id{rp.Pop<u64>()};
diff --git a/src/core/hle/service/caps/caps_su.h b/src/core/hle/service/caps/caps_su.h
index c6398858d..647e3059d 100644
--- a/src/core/hle/service/caps/caps_su.h
+++ b/src/core/hle/service/caps/caps_su.h
@@ -11,10 +11,10 @@ class System;
 
 namespace Service::Capture {
 
-class CAPS_SU final : public ServiceFramework<CAPS_SU> {
+class IScreenShotApplicationService final : public ServiceFramework<IScreenShotApplicationService> {
 public:
-    explicit CAPS_SU(Core::System& system_);
-    ~CAPS_SU() override;
+    explicit IScreenShotApplicationService(Core::System& system_);
+    ~IScreenShotApplicationService() override;
 
 private:
     void SetShimLibraryVersion(HLERequestContext& ctx);
diff --git a/src/core/hle/service/caps/caps_types.h b/src/core/hle/service/caps/caps_types.h
new file mode 100644
index 000000000..bf6061273
--- /dev/null
+++ b/src/core/hle/service/caps/caps_types.h
@@ -0,0 +1,184 @@
+// SPDX-FileCopyrightText: Copyright 2018 yuzu Emulator Project
+// SPDX-License-Identifier: GPL-2.0-or-later
+
+#pragma once
+
+#include "common/common_funcs.h"
+#include "common/common_types.h"
+
+namespace Service::Capture {
+
+// This is nn::album::ImageOrientation
+enum class AlbumImageOrientation {
+    None,
+    Rotate90,
+    Rotate180,
+    Rotate270,
+};
+
+// This is nn::album::AlbumReportOption
+enum class AlbumReportOption : s32 {
+    Disable,
+    Enable,
+};
+
+enum class ContentType : u8 {
+    Screenshot = 0,
+    Movie = 1,
+    ExtraMovie = 3,
+};
+
+enum class AlbumStorage : u8 {
+    Nand,
+    Sd,
+};
+
+enum class ScreenShotDecoderFlag : u64 {
+    None = 0,
+    EnableFancyUpsampling = 1 << 0,
+    EnableBlockSmoothing = 1 << 1,
+};
+
+// This is nn::capsrv::AlbumFileDateTime
+struct AlbumFileDateTime {
+    u16 year{};
+    u8 month{};
+    u8 day{};
+    u8 hour{};
+    u8 minute{};
+    u8 second{};
+    u8 unique_id{};
+
+    friend constexpr bool operator==(const AlbumFileDateTime&, const AlbumFileDateTime&) = default;
+    friend constexpr bool operator>(const AlbumFileDateTime& a, const AlbumFileDateTime& b) {
+        if (a.year > b.year) {
+            return true;
+        }
+        if (a.month > b.month) {
+            return true;
+        }
+        if (a.day > b.day) {
+            return true;
+        }
+        if (a.hour > b.hour) {
+            return true;
+        }
+        if (a.minute > b.minute) {
+            return true;
+        }
+        return a.second > b.second;
+    };
+    friend constexpr bool operator<(const AlbumFileDateTime& a, const AlbumFileDateTime& b) {
+        if (a.year < b.year) {
+            return true;
+        }
+        if (a.month < b.month) {
+            return true;
+        }
+        if (a.day < b.day) {
+            return true;
+        }
+        if (a.hour < b.hour) {
+            return true;
+        }
+        if (a.minute < b.minute) {
+            return true;
+        }
+        return a.second < b.second;
+    };
+};
+static_assert(sizeof(AlbumFileDateTime) == 0x8, "AlbumFileDateTime has incorrect size.");
+
+// This is nn::album::AlbumEntry
+struct AlbumFileEntry {
+    u64 size{}; // Size of the entry
+    u64 hash{}; // AES256 with hardcoded key over AlbumEntry
+    AlbumFileDateTime datetime{};
+    AlbumStorage storage{};
+    ContentType content{};
+    INSERT_PADDING_BYTES(5);
+    u8 unknown{}; // Set to 1 on official SW
+};
+static_assert(sizeof(AlbumFileEntry) == 0x20, "AlbumFileEntry has incorrect size.");
+
+struct AlbumFileId {
+    u64 application_id{};
+    AlbumFileDateTime date{};
+    AlbumStorage storage{};
+    ContentType type{};
+    INSERT_PADDING_BYTES(0x5);
+    u8 unknown{};
+
+    friend constexpr bool operator==(const AlbumFileId&, const AlbumFileId&) = default;
+};
+static_assert(sizeof(AlbumFileId) == 0x18, "AlbumFileId is an invalid size");
+
+// This is nn::capsrv::AlbumEntry
+struct AlbumEntry {
+    u64 entry_size{};
+    AlbumFileId file_id{};
+};
+static_assert(sizeof(AlbumEntry) == 0x20, "AlbumEntry has incorrect size.");
+
+// This is nn::capsrv::ApplicationAlbumEntry
+struct ApplicationAlbumEntry {
+    u64 size{}; // Size of the entry
+    u64 hash{}; // AES256 with hardcoded key over AlbumEntry
+    AlbumFileDateTime datetime{};
+    AlbumStorage storage{};
+    ContentType content{};
+    INSERT_PADDING_BYTES(5);
+    u8 unknown{1}; // Set to 1 on official SW
+};
+static_assert(sizeof(ApplicationAlbumEntry) == 0x20, "ApplicationAlbumEntry has incorrect size.");
+
+// This is nn::capsrv::ApplicationAlbumFileEntry
+struct ApplicationAlbumFileEntry {
+    ApplicationAlbumEntry entry{};
+    AlbumFileDateTime datetime{};
+    u64 unknown{};
+};
+static_assert(sizeof(ApplicationAlbumFileEntry) == 0x30,
+              "ApplicationAlbumFileEntry has incorrect size.");
+
+struct ApplicationData {
+    std::array<u8, 0x400> data{};
+    u32 data_size{};
+};
+static_assert(sizeof(ApplicationData) == 0x404, "ApplicationData is an invalid size");
+
+struct ScreenShotAttribute {
+    u32 unknown_0{};
+    AlbumImageOrientation orientation{};
+    u32 unknown_1{};
+    u32 unknown_2{};
+    INSERT_PADDING_BYTES(0x30);
+};
+static_assert(sizeof(ScreenShotAttribute) == 0x40, "ScreenShotAttribute is an invalid size");
+
+struct ScreenShotDecodeOption {
+    ScreenShotDecoderFlag flags{};
+    INSERT_PADDING_BYTES(0x18);
+};
+static_assert(sizeof(ScreenShotDecodeOption) == 0x20, "ScreenShotDecodeOption is an invalid size");
+
+struct LoadAlbumScreenShotImageOutput {
+    s64 width{};
+    s64 height{};
+    ScreenShotAttribute attribute{};
+    INSERT_PADDING_BYTES(0x400);
+};
+static_assert(sizeof(LoadAlbumScreenShotImageOutput) == 0x450,
+              "LoadAlbumScreenShotImageOutput is an invalid size");
+
+struct LoadAlbumScreenShotImageOutputForApplication {
+    s64 width{};
+    s64 height{};
+    ScreenShotAttribute attribute{};
+    ApplicationData data{};
+    INSERT_PADDING_BYTES(0xAC);
+};
+static_assert(sizeof(LoadAlbumScreenShotImageOutputForApplication) == 0x500,
+              "LoadAlbumScreenShotImageOutput is an invalid size");
+
+} // namespace Service::Capture
diff --git a/src/core/hle/service/caps/caps_u.cpp b/src/core/hle/service/caps/caps_u.cpp
index bffe0f8d0..260f25490 100644
--- a/src/core/hle/service/caps/caps_u.cpp
+++ b/src/core/hle/service/caps/caps_u.cpp
@@ -2,45 +2,29 @@
 // SPDX-License-Identifier: GPL-2.0-or-later
 
 #include "common/logging/log.h"
-#include "core/hle/service/caps/caps.h"
+#include "core/hle/service/caps/caps_manager.h"
+#include "core/hle/service/caps/caps_types.h"
 #include "core/hle/service/caps/caps_u.h"
 #include "core/hle/service/ipc_helpers.h"
 
 namespace Service::Capture {
 
-class IAlbumAccessorApplicationSession final
-    : public ServiceFramework<IAlbumAccessorApplicationSession> {
-public:
-    explicit IAlbumAccessorApplicationSession(Core::System& system_)
-        : ServiceFramework{system_, "IAlbumAccessorApplicationSession"} {
-        // clang-format off
-        static const FunctionInfo functions[] = {
-            {2001, nullptr, "OpenAlbumMovieReadStream"},
-            {2002, nullptr, "CloseAlbumMovieReadStream"},
-            {2003, nullptr, "GetAlbumMovieReadStreamMovieDataSize"},
-            {2004, nullptr, "ReadMovieDataFromAlbumMovieReadStream"},
-            {2005, nullptr, "GetAlbumMovieReadStreamBrokenReason"},
-        };
-        // clang-format on
-
-        RegisterHandlers(functions);
-    }
-};
-
-CAPS_U::CAPS_U(Core::System& system_) : ServiceFramework{system_, "caps:u"} {
+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, &CAPS_U::SetShimLibraryVersion, "SetShimLibraryVersion"},
-        {102, &CAPS_U::GetAlbumContentsFileListForApplication, "GetAlbumContentsFileListForApplication"},
-        {103, nullptr, "DeleteAlbumContentsFileForApplication"},
-        {104, nullptr, "GetAlbumContentsFileSizeForApplication"},
+        {32, &IAlbumApplicationService::SetShimLibraryVersion, "SetShimLibraryVersion"},
+        {102, &IAlbumApplicationService::GetAlbumFileList0AafeAruidDeprecated, "GetAlbumFileList0AafeAruidDeprecated"},
+        {103, nullptr, "DeleteAlbumFileByAruid"},
+        {104, nullptr, "GetAlbumFileSizeByAruid"},
         {105, nullptr, "DeleteAlbumFileByAruidForDebug"},
-        {110, nullptr, "LoadAlbumContentsFileScreenShotImageForApplication"},
-        {120, nullptr, "LoadAlbumContentsFileThumbnailImageForApplication"},
-        {130, nullptr, "PrecheckToCreateContentsForApplication"},
+        {110, nullptr, "LoadAlbumScreenShotImageByAruid"},
+        {120, nullptr, "LoadAlbumScreenShotThumbnailImageByAruid"},
+        {130, nullptr, "PrecheckToCreateContentsByAruid"},
         {140, nullptr, "GetAlbumFileList1AafeAruidDeprecated"},
         {141, nullptr, "GetAlbumFileList2AafeUidAruidDeprecated"},
-        {142, &CAPS_U::GetAlbumFileList3AaeAruid, "GetAlbumFileList3AaeAruid"},
+        {142, &IAlbumApplicationService::GetAlbumFileList3AaeAruid, "GetAlbumFileList3AaeAruid"},
         {143, nullptr, "GetAlbumFileList4AaeUidAruid"},
         {144, nullptr, "GetAllAlbumFileList3AaeAruid"},
         {60002, nullptr, "OpenAccessorSessionForApplication"},
@@ -50,9 +34,9 @@ CAPS_U::CAPS_U(Core::System& system_) : ServiceFramework{system_, "caps:u"} {
     RegisterHandlers(functions);
 }
 
-CAPS_U::~CAPS_U() = default;
+IAlbumApplicationService::~IAlbumApplicationService() = default;
 
-void CAPS_U::SetShimLibraryVersion(HLERequestContext& ctx) {
+void IAlbumApplicationService::SetShimLibraryVersion(HLERequestContext& ctx) {
     IPC::RequestParser rp{ctx};
     const auto library_version{rp.Pop<u64>()};
     const auto applet_resource_user_id{rp.Pop<u64>()};
@@ -64,10 +48,7 @@ void CAPS_U::SetShimLibraryVersion(HLERequestContext& ctx) {
     rb.Push(ResultSuccess);
 }
 
-void CAPS_U::GetAlbumContentsFileListForApplication(HLERequestContext& ctx) {
-    // Takes a type-0x6 output buffer containing an array of ApplicationAlbumFileEntry, a PID, an
-    // u8 ContentType, two s64s, and an u64 AppletResourceUserId. Returns an output u64 for total
-    // output entries (which is copied to a s32 by official SW).
+void IAlbumApplicationService::GetAlbumFileList0AafeAruidDeprecated(HLERequestContext& ctx) {
     IPC::RequestParser rp{ctx};
     const auto pid{rp.Pop<s32>()};
     const auto content_type{rp.PopEnum<ContentType>()};
@@ -75,26 +56,49 @@ void CAPS_U::GetAlbumContentsFileListForApplication(HLERequestContext& ctx) {
     const auto end_posix_time{rp.Pop<s64>()};
     const auto applet_resource_user_id{rp.Pop<u64>()};
 
-    // TODO: Update this when we implement the album.
-    // Currently we do not have a method of accessing album entries, set this to 0 for now.
-    constexpr u32 total_entries_1{};
-    constexpr u32 total_entries_2{};
+    LOG_WARNING(Service_Capture,
+                "(STUBBED) called. pid={}, content_type={}, start_posix_time={}, "
+                "end_posix_time={}, applet_resource_user_id={}",
+                pid, content_type, start_posix_time, end_posix_time, applet_resource_user_id);
+
+    // TODO: Translate posix to DateTime
+
+    std::vector<ApplicationAlbumFileEntry> entries;
+    const Result result =
+        manager->GetAlbumFileList(entries, content_type, {}, {}, applet_resource_user_id);
 
-    LOG_WARNING(
-        Service_Capture,
-        "(STUBBED) called. pid={}, content_type={}, start_posix_time={}, "
-        "end_posix_time={}, applet_resource_user_id={}, total_entries_1={}, total_entries_2={}",
-        pid, content_type, start_posix_time, end_posix_time, applet_resource_user_id,
-        total_entries_1, total_entries_2);
+    if (!entries.empty()) {
+        ctx.WriteBuffer(entries);
+    }
 
     IPC::ResponseBuilder rb{ctx, 4};
-    rb.Push(ResultSuccess);
-    rb.Push(total_entries_1);
-    rb.Push(total_entries_2);
+    rb.Push(result);
+    rb.Push<u64>(entries.size());
 }
 
-void CAPS_U::GetAlbumFileList3AaeAruid(HLERequestContext& ctx) {
-    GetAlbumContentsFileListForApplication(ctx);
+void IAlbumApplicationService::GetAlbumFileList3AaeAruid(HLERequestContext& ctx) {
+    IPC::RequestParser rp{ctx};
+    const auto pid{rp.Pop<s32>()};
+    const auto content_type{rp.PopEnum<ContentType>()};
+    const auto start_date_time{rp.PopRaw<AlbumFileDateTime>()};
+    const auto end_date_time{rp.PopRaw<AlbumFileDateTime>()};
+    const auto applet_resource_user_id{rp.Pop<u64>()};
+
+    LOG_WARNING(Service_Capture,
+                "(STUBBED) called. pid={}, content_type={}, applet_resource_user_id={}", pid,
+                content_type, applet_resource_user_id);
+
+    std::vector<ApplicationAlbumFileEntry> entries;
+    const Result result = manager->GetAlbumFileList(entries, content_type, start_date_time,
+                                                    end_date_time, applet_resource_user_id);
+
+    if (!entries.empty()) {
+        ctx.WriteBuffer(entries);
+    }
+
+    IPC::ResponseBuilder rb{ctx, 4};
+    rb.Push(result);
+    rb.Push<u64>(entries.size());
 }
 
 } // namespace Service::Capture
diff --git a/src/core/hle/service/caps/caps_u.h b/src/core/hle/service/caps/caps_u.h
index e8dd037d7..9458c128e 100644
--- a/src/core/hle/service/caps/caps_u.h
+++ b/src/core/hle/service/caps/caps_u.h
@@ -10,16 +10,20 @@ class System;
 }
 
 namespace Service::Capture {
+class AlbumManager;
 
-class CAPS_U final : public ServiceFramework<CAPS_U> {
+class IAlbumApplicationService final : public ServiceFramework<IAlbumApplicationService> {
 public:
-    explicit CAPS_U(Core::System& system_);
-    ~CAPS_U() override;
+    explicit IAlbumApplicationService(Core::System& system_,
+                                      std::shared_ptr<AlbumManager> album_manager);
+    ~IAlbumApplicationService() override;
 
 private:
     void SetShimLibraryVersion(HLERequestContext& ctx);
-    void GetAlbumContentsFileListForApplication(HLERequestContext& ctx);
+    void GetAlbumFileList0AafeAruidDeprecated(HLERequestContext& ctx);
     void GetAlbumFileList3AaeAruid(HLERequestContext& ctx);
+
+    std::shared_ptr<AlbumManager> manager = nullptr;
 };
 
 } // namespace Service::Capture
diff --git a/src/core/hle/service/nifm/nifm.cpp b/src/core/hle/service/nifm/nifm.cpp
index 21b06d10b..22dc55a6d 100644
--- a/src/core/hle/service/nifm/nifm.cpp
+++ b/src/core/hle/service/nifm/nifm.cpp
@@ -545,6 +545,16 @@ void IGeneralService::IsAnyInternetRequestAccepted(HLERequestContext& ctx) {
     }
 }
 
+void IGeneralService::IsAnyForegroundRequestAccepted(HLERequestContext& ctx) {
+    const bool is_accepted{};
+
+    LOG_WARNING(Service_NIFM, "(STUBBED) called, is_accepted={}", is_accepted);
+
+    IPC::ResponseBuilder rb{ctx, 3};
+    rb.Push(ResultSuccess);
+    rb.Push<u8>(is_accepted);
+}
+
 IGeneralService::IGeneralService(Core::System& system_)
     : ServiceFramework{system_, "IGeneralService"}, network{system_.GetRoomNetwork()} {
     // clang-format off
@@ -569,7 +579,7 @@ IGeneralService::IGeneralService(Core::System& system_)
         {19, nullptr, "SetEthernetCommunicationEnabled"},
         {20, &IGeneralService::IsEthernetCommunicationEnabled, "IsEthernetCommunicationEnabled"},
         {21, &IGeneralService::IsAnyInternetRequestAccepted, "IsAnyInternetRequestAccepted"},
-        {22, nullptr, "IsAnyForegroundRequestAccepted"},
+        {22, &IGeneralService::IsAnyForegroundRequestAccepted, "IsAnyForegroundRequestAccepted"},
         {23, nullptr, "PutToSleep"},
         {24, nullptr, "WakeUp"},
         {25, nullptr, "GetSsidListVersion"},
diff --git a/src/core/hle/service/nifm/nifm.h b/src/core/hle/service/nifm/nifm.h
index ae99c4695..b74b66438 100644
--- a/src/core/hle/service/nifm/nifm.h
+++ b/src/core/hle/service/nifm/nifm.h
@@ -35,6 +35,7 @@ private:
     void GetInternetConnectionStatus(HLERequestContext& ctx);
     void IsEthernetCommunicationEnabled(HLERequestContext& ctx);
     void IsAnyInternetRequestAccepted(HLERequestContext& ctx);
+    void IsAnyForegroundRequestAccepted(HLERequestContext& ctx);
 
     Network::RoomNetwork& network;
 };
diff --git a/src/core/hle/service/ns/ns.cpp b/src/core/hle/service/ns/ns.cpp
index 6e0baf0be..f9e0e272d 100644
--- a/src/core/hle/service/ns/ns.cpp
+++ b/src/core/hle/service/ns/ns.cpp
@@ -7,6 +7,7 @@
 #include "core/file_sys/control_metadata.h"
 #include "core/file_sys/patch_manager.h"
 #include "core/file_sys/vfs.h"
+#include "core/hle/service/filesystem/filesystem.h"
 #include "core/hle/service/glue/glue_manager.h"
 #include "core/hle/service/ipc_helpers.h"
 #include "core/hle/service/ns/errors.h"
@@ -502,8 +503,8 @@ IContentManagementInterface::IContentManagementInterface(Core::System& system_)
     static const FunctionInfo functions[] = {
         {11, nullptr, "CalculateApplicationOccupiedSize"},
         {43, nullptr, "CheckSdCardMountStatus"},
-        {47, nullptr, "GetTotalSpaceSize"},
-        {48, nullptr, "GetFreeSpaceSize"},
+        {47, &IContentManagementInterface::GetTotalSpaceSize, "GetTotalSpaceSize"},
+        {48, &IContentManagementInterface::GetFreeSpaceSize, "GetFreeSpaceSize"},
         {600, nullptr, "CountApplicationContentMeta"},
         {601, nullptr, "ListApplicationContentMetaStatus"},
         {605, nullptr, "ListApplicationContentMetaStatusWithRightsCheck"},
@@ -516,6 +517,28 @@ IContentManagementInterface::IContentManagementInterface(Core::System& system_)
 
 IContentManagementInterface::~IContentManagementInterface() = default;
 
+void IContentManagementInterface::GetTotalSpaceSize(HLERequestContext& ctx) {
+    IPC::RequestParser rp{ctx};
+    const auto storage{rp.PopEnum<FileSys::StorageId>()};
+
+    LOG_INFO(Service_Capture, "called, storage={}", storage);
+
+    IPC::ResponseBuilder rb{ctx, 4};
+    rb.Push(ResultSuccess);
+    rb.Push<u64>(system.GetFileSystemController().GetTotalSpaceSize(storage));
+}
+
+void IContentManagementInterface::GetFreeSpaceSize(HLERequestContext& ctx) {
+    IPC::RequestParser rp{ctx};
+    const auto storage{rp.PopEnum<FileSys::StorageId>()};
+
+    LOG_INFO(Service_Capture, "called, storage={}", storage);
+
+    IPC::ResponseBuilder rb{ctx, 4};
+    rb.Push(ResultSuccess);
+    rb.Push<u64>(system.GetFileSystemController().GetFreeSpaceSize(storage));
+}
+
 IDocumentInterface::IDocumentInterface(Core::System& system_)
     : ServiceFramework{system_, "IDocumentInterface"} {
     // clang-format off
diff --git a/src/core/hle/service/ns/ns.h b/src/core/hle/service/ns/ns.h
index 175dad780..34d2a45dc 100644
--- a/src/core/hle/service/ns/ns.h
+++ b/src/core/hle/service/ns/ns.h
@@ -48,6 +48,10 @@ class IContentManagementInterface final : public ServiceFramework<IContentManage
 public:
     explicit IContentManagementInterface(Core::System& system_);
     ~IContentManagementInterface() override;
+
+private:
+    void GetTotalSpaceSize(HLERequestContext& ctx);
+    void GetFreeSpaceSize(HLERequestContext& ctx);
 };
 
 class IDocumentInterface final : public ServiceFramework<IDocumentInterface> {
diff --git a/src/core/hle/service/pctl/pctl_module.cpp b/src/core/hle/service/pctl/pctl_module.cpp
index 5db1703d1..938330dd0 100644
--- a/src/core/hle/service/pctl/pctl_module.cpp
+++ b/src/core/hle/service/pctl/pctl_module.cpp
@@ -33,7 +33,7 @@ public:
             {1001, &IParentalControlService::CheckFreeCommunicationPermission, "CheckFreeCommunicationPermission"},
             {1002, nullptr, "ConfirmLaunchApplicationPermission"},
             {1003, nullptr, "ConfirmResumeApplicationPermission"},
-            {1004, nullptr, "ConfirmSnsPostPermission"},
+            {1004, &IParentalControlService::ConfirmSnsPostPermission, "ConfirmSnsPostPermission"},
             {1005, nullptr, "ConfirmSystemSettingsPermission"},
             {1006, &IParentalControlService::IsRestrictionTemporaryUnlocked, "IsRestrictionTemporaryUnlocked"},
             {1007, nullptr, "RevertRestrictionTemporaryUnlocked"},
@@ -236,6 +236,13 @@ private:
         states.free_communication = true;
     }
 
+    void ConfirmSnsPostPermission(HLERequestContext& ctx) {
+        LOG_WARNING(Service_PCTL, "(STUBBED) called");
+
+        IPC::ResponseBuilder rb{ctx, 2};
+        rb.Push(Error::ResultNoFreeCommunication);
+    }
+
     void IsRestrictionTemporaryUnlocked(HLERequestContext& ctx) {
         const bool is_temporary_unlocked = false;
 
diff --git a/src/video_core/texture_cache/format_lookup_table.cpp b/src/video_core/texture_cache/format_lookup_table.cpp
index 3162c8f5e..8c774f512 100644
--- a/src/video_core/texture_cache/format_lookup_table.cpp
+++ b/src/video_core/texture_cache/format_lookup_table.cpp
@@ -138,6 +138,8 @@ PixelFormat PixelFormatFromTextureInfo(TextureFormat format, ComponentType red,
         return PixelFormat::E5B9G9R9_FLOAT;
     case Hash(TextureFormat::Z32, FLOAT):
         return PixelFormat::D32_FLOAT;
+    case Hash(TextureFormat::Z32, FLOAT, UINT, UINT, UINT, LINEAR):
+        return PixelFormat::D32_FLOAT;
     case Hash(TextureFormat::Z16, UNORM):
         return PixelFormat::D16_UNORM;
     case Hash(TextureFormat::Z16, UNORM, UINT, UINT, UINT, LINEAR):
diff --git a/src/yuzu/CMakeLists.txt b/src/yuzu/CMakeLists.txt
index 8f86a1553..9ebece907 100644
--- a/src/yuzu/CMakeLists.txt
+++ b/src/yuzu/CMakeLists.txt
@@ -195,6 +195,8 @@ add_executable(yuzu
     multiplayer/state.cpp
     multiplayer/state.h
     multiplayer/validation.h
+    play_time_manager.cpp
+    play_time_manager.h
     precompiled_headers.h
     qt_common.cpp
     qt_common.h
diff --git a/src/yuzu/configuration/configure_ui.cpp b/src/yuzu/configuration/configure_ui.cpp
index a9fde9f4f..82f3b6e78 100644
--- a/src/yuzu/configuration/configure_ui.cpp
+++ b/src/yuzu/configuration/configure_ui.cpp
@@ -123,6 +123,8 @@ ConfigureUi::ConfigureUi(Core::System& system_, QWidget* parent)
     connect(ui->show_compat, &QCheckBox::stateChanged, this, &ConfigureUi::RequestGameListUpdate);
     connect(ui->show_size, &QCheckBox::stateChanged, this, &ConfigureUi::RequestGameListUpdate);
     connect(ui->show_types, &QCheckBox::stateChanged, this, &ConfigureUi::RequestGameListUpdate);
+    connect(ui->show_play_time, &QCheckBox::stateChanged, this,
+            &ConfigureUi::RequestGameListUpdate);
     connect(ui->game_icon_size_combobox, QOverload<int>::of(&QComboBox::currentIndexChanged), this,
             &ConfigureUi::RequestGameListUpdate);
     connect(ui->folder_icon_size_combobox, QOverload<int>::of(&QComboBox::currentIndexChanged),
@@ -167,6 +169,7 @@ void ConfigureUi::ApplyConfiguration() {
     UISettings::values.show_compat = ui->show_compat->isChecked();
     UISettings::values.show_size = ui->show_size->isChecked();
     UISettings::values.show_types = ui->show_types->isChecked();
+    UISettings::values.show_play_time = ui->show_play_time->isChecked();
     UISettings::values.game_icon_size = ui->game_icon_size_combobox->currentData().toUInt();
     UISettings::values.folder_icon_size = ui->folder_icon_size_combobox->currentData().toUInt();
     UISettings::values.row_1_text_id = ui->row_1_text_combobox->currentData().toUInt();
@@ -179,6 +182,7 @@ void ConfigureUi::ApplyConfiguration() {
     const u32 height = ScreenshotDimensionToInt(ui->screenshot_height->currentText());
     UISettings::values.screenshot_height.SetValue(height);
 
+    RequestGameListUpdate();
     system.ApplySettings();
 }
 
@@ -194,6 +198,7 @@ void ConfigureUi::SetConfiguration() {
     ui->show_compat->setChecked(UISettings::values.show_compat.GetValue());
     ui->show_size->setChecked(UISettings::values.show_size.GetValue());
     ui->show_types->setChecked(UISettings::values.show_types.GetValue());
+    ui->show_play_time->setChecked(UISettings::values.show_play_time.GetValue());
     ui->game_icon_size_combobox->setCurrentIndex(
         ui->game_icon_size_combobox->findData(UISettings::values.game_icon_size.GetValue()));
     ui->folder_icon_size_combobox->setCurrentIndex(
diff --git a/src/yuzu/configuration/configure_ui.ui b/src/yuzu/configuration/configure_ui.ui
index cb66ef104..b8e648381 100644
--- a/src/yuzu/configuration/configure_ui.ui
+++ b/src/yuzu/configuration/configure_ui.ui
@@ -105,6 +105,13 @@
          </widget>
         </item>
         <item>
+         <widget class="QCheckBox" name="show_play_time">
+          <property name="text">
+           <string>Show Play Time Column</string>
+          </property>
+         </widget>
+        </item>
+        <item>
          <layout class="QHBoxLayout" name="game_icon_size_qhbox_layout_2">
           <item>
            <widget class="QLabel" name="game_icon_size_label">
diff --git a/src/yuzu/game_list.cpp b/src/yuzu/game_list.cpp
index f254c1e1c..74f48031a 100644
--- a/src/yuzu/game_list.cpp
+++ b/src/yuzu/game_list.cpp
@@ -312,8 +312,10 @@ void GameList::OnFilterCloseClicked() {
 }
 
 GameList::GameList(FileSys::VirtualFilesystem vfs_, FileSys::ManualContentProvider* provider_,
-                   Core::System& system_, GMainWindow* parent)
-    : QWidget{parent}, vfs{std::move(vfs_)}, provider{provider_}, system{system_} {
+                   PlayTime::PlayTimeManager& play_time_manager_, Core::System& system_,
+                   GMainWindow* parent)
+    : QWidget{parent}, vfs{std::move(vfs_)}, provider{provider_},
+      play_time_manager{play_time_manager_}, system{system_} {
     watcher = new QFileSystemWatcher(this);
     connect(watcher, &QFileSystemWatcher::directoryChanged, this, &GameList::RefreshGameDirectory);
 
@@ -340,6 +342,7 @@ GameList::GameList(FileSys::VirtualFilesystem vfs_, FileSys::ManualContentProvid
 
     tree_view->setColumnHidden(COLUMN_ADD_ONS, !UISettings::values.show_add_ons);
     tree_view->setColumnHidden(COLUMN_COMPATIBILITY, !UISettings::values.show_compat);
+    tree_view->setColumnHidden(COLUMN_PLAY_TIME, !UISettings::values.show_play_time);
     item_model->setSortRole(GameListItemPath::SortRole);
 
     connect(main_window, &GMainWindow::UpdateThemedIcons, this, &GameList::OnUpdateThemedIcons);
@@ -548,6 +551,7 @@ void GameList::AddGamePopup(QMenu& context_menu, u64 program_id, const std::stri
     QAction* remove_update = remove_menu->addAction(tr("Remove Installed Update"));
     QAction* remove_dlc = remove_menu->addAction(tr("Remove All Installed DLC"));
     QAction* remove_custom_config = remove_menu->addAction(tr("Remove Custom Configuration"));
+    QAction* remove_play_time_data = remove_menu->addAction(tr("Remove Play Time Data"));
     QAction* remove_cache_storage = remove_menu->addAction(tr("Remove Cache Storage"));
     QAction* remove_gl_shader_cache = remove_menu->addAction(tr("Remove OpenGL Pipeline Cache"));
     QAction* remove_vk_shader_cache = remove_menu->addAction(tr("Remove Vulkan Pipeline Cache"));
@@ -560,9 +564,9 @@ void GameList::AddGamePopup(QMenu& context_menu, u64 program_id, const std::stri
     QAction* verify_integrity = context_menu.addAction(tr("Verify Integrity"));
     QAction* copy_tid = context_menu.addAction(tr("Copy Title ID to Clipboard"));
     QAction* navigate_to_gamedb_entry = context_menu.addAction(tr("Navigate to GameDB entry"));
-#ifndef WIN32
     QMenu* shortcut_menu = context_menu.addMenu(tr("Create Shortcut"));
     QAction* create_desktop_shortcut = shortcut_menu->addAction(tr("Add to Desktop"));
+#ifndef WIN32
     QAction* create_applications_menu_shortcut =
         shortcut_menu->addAction(tr("Add to Applications Menu"));
 #endif
@@ -622,6 +626,8 @@ void GameList::AddGamePopup(QMenu& context_menu, u64 program_id, const std::stri
     connect(remove_custom_config, &QAction::triggered, [this, program_id, path]() {
         emit RemoveFileRequested(program_id, GameListRemoveTarget::CustomConfiguration, path);
     });
+    connect(remove_play_time_data, &QAction::triggered,
+            [this, program_id]() { emit RemovePlayTimeRequested(program_id); });
     connect(remove_cache_storage, &QAction::triggered, [this, program_id, path] {
         emit RemoveFileRequested(program_id, GameListRemoveTarget::CacheStorage, path);
     });
@@ -638,10 +644,10 @@ void GameList::AddGamePopup(QMenu& context_menu, u64 program_id, const std::stri
     connect(navigate_to_gamedb_entry, &QAction::triggered, [this, program_id]() {
         emit NavigateToGamedbEntryRequested(program_id, compatibility_list);
     });
-#ifndef WIN32
     connect(create_desktop_shortcut, &QAction::triggered, [this, program_id, path]() {
         emit CreateShortcut(program_id, path, GameListShortcutTarget::Desktop);
     });
+#ifndef WIN32
     connect(create_applications_menu_shortcut, &QAction::triggered, [this, program_id, path]() {
         emit CreateShortcut(program_id, path, GameListShortcutTarget::Applications);
     });
@@ -790,6 +796,7 @@ void GameList::RetranslateUI() {
     item_model->setHeaderData(COLUMN_ADD_ONS, Qt::Horizontal, tr("Add-ons"));
     item_model->setHeaderData(COLUMN_FILE_TYPE, Qt::Horizontal, tr("File type"));
     item_model->setHeaderData(COLUMN_SIZE, Qt::Horizontal, tr("Size"));
+    item_model->setHeaderData(COLUMN_PLAY_TIME, Qt::Horizontal, tr("Play time"));
 }
 
 void GameListSearchField::changeEvent(QEvent* event) {
@@ -817,6 +824,7 @@ void GameList::PopulateAsync(QVector<UISettings::GameDir>& game_dirs) {
     tree_view->setColumnHidden(COLUMN_COMPATIBILITY, !UISettings::values.show_compat);
     tree_view->setColumnHidden(COLUMN_FILE_TYPE, !UISettings::values.show_types);
     tree_view->setColumnHidden(COLUMN_SIZE, !UISettings::values.show_size);
+    tree_view->setColumnHidden(COLUMN_PLAY_TIME, !UISettings::values.show_play_time);
 
     // Delete any rows that might already exist if we're repopulating
     item_model->removeRows(0, item_model->rowCount());
@@ -825,7 +833,7 @@ void GameList::PopulateAsync(QVector<UISettings::GameDir>& game_dirs) {
     emit ShouldCancelWorker();
 
     GameListWorker* worker =
-        new GameListWorker(vfs, provider, game_dirs, compatibility_list, system);
+        new GameListWorker(vfs, provider, game_dirs, compatibility_list, play_time_manager, system);
 
     connect(worker, &GameListWorker::EntryReady, this, &GameList::AddEntry, Qt::QueuedConnection);
     connect(worker, &GameListWorker::DirEntryReady, this, &GameList::AddDirEntry,
diff --git a/src/yuzu/game_list.h b/src/yuzu/game_list.h
index 1fcbbf0ba..712570cea 100644
--- a/src/yuzu/game_list.h
+++ b/src/yuzu/game_list.h
@@ -18,6 +18,7 @@
 #include "core/core.h"
 #include "uisettings.h"
 #include "yuzu/compatibility_list.h"
+#include "yuzu/play_time_manager.h"
 
 namespace Core {
 class System;
@@ -75,11 +76,13 @@ public:
         COLUMN_ADD_ONS,
         COLUMN_FILE_TYPE,
         COLUMN_SIZE,
+        COLUMN_PLAY_TIME,
         COLUMN_COUNT, // Number of columns
     };
 
     explicit GameList(std::shared_ptr<FileSys::VfsFilesystem> vfs_,
-                      FileSys::ManualContentProvider* provider_, Core::System& system_,
+                      FileSys::ManualContentProvider* provider_,
+                      PlayTime::PlayTimeManager& play_time_manager_, Core::System& system_,
                       GMainWindow* parent = nullptr);
     ~GameList() override;
 
@@ -113,6 +116,7 @@ signals:
     void RemoveInstalledEntryRequested(u64 program_id, InstalledEntryType type);
     void RemoveFileRequested(u64 program_id, GameListRemoveTarget target,
                              const std::string& game_path);
+    void RemovePlayTimeRequested(u64 program_id);
     void DumpRomFSRequested(u64 program_id, const std::string& game_path, DumpRomFSTarget target);
     void VerifyIntegrityRequested(const std::string& game_path);
     void CopyTIDRequested(u64 program_id);
@@ -168,6 +172,7 @@ private:
 
     friend class GameListSearchField;
 
+    const PlayTime::PlayTimeManager& play_time_manager;
     Core::System& system;
 };
 
diff --git a/src/yuzu/game_list_p.h b/src/yuzu/game_list_p.h
index 1800f090f..86a0c41d9 100644
--- a/src/yuzu/game_list_p.h
+++ b/src/yuzu/game_list_p.h
@@ -18,6 +18,7 @@
 #include "common/common_types.h"
 #include "common/logging/log.h"
 #include "common/string_util.h"
+#include "yuzu/play_time_manager.h"
 #include "yuzu/uisettings.h"
 #include "yuzu/util/util.h"
 
@@ -221,6 +222,31 @@ public:
     }
 };
 
+/**
+ * GameListItem for Play Time values.
+ * This object stores the play time of a game in seconds, and its readable
+ * representation in minutes/hours
+ */
+class GameListItemPlayTime : public GameListItem {
+public:
+    static constexpr int PlayTimeRole = SortRole;
+
+    GameListItemPlayTime() = default;
+    explicit GameListItemPlayTime(const qulonglong time_seconds) {
+        setData(time_seconds, PlayTimeRole);
+    }
+
+    void setData(const QVariant& value, int role) override {
+        qulonglong time_seconds = value.toULongLong();
+        GameListItem::setData(PlayTime::ReadablePlayTime(time_seconds), Qt::DisplayRole);
+        GameListItem::setData(value, PlayTimeRole);
+    }
+
+    bool operator<(const QStandardItem& other) const override {
+        return data(PlayTimeRole).toULongLong() < other.data(PlayTimeRole).toULongLong();
+    }
+};
+
 class GameListDir : public GameListItem {
 public:
     static constexpr int GameDirRole = Qt::UserRole + 2;
diff --git a/src/yuzu/game_list_worker.cpp b/src/yuzu/game_list_worker.cpp
index e7fb8a282..588f1dd6e 100644
--- a/src/yuzu/game_list_worker.cpp
+++ b/src/yuzu/game_list_worker.cpp
@@ -194,6 +194,7 @@ QList<QStandardItem*> MakeGameListEntry(const std::string& path, const std::stri
                                         const std::size_t size, const std::vector<u8>& icon,
                                         Loader::AppLoader& loader, u64 program_id,
                                         const CompatibilityList& compatibility_list,
+                                        const PlayTime::PlayTimeManager& play_time_manager,
                                         const FileSys::PatchManager& patch) {
     const auto it = FindMatchingCompatibilityEntry(compatibility_list, program_id);
 
@@ -212,6 +213,7 @@ QList<QStandardItem*> MakeGameListEntry(const std::string& path, const std::stri
         new GameListItemCompat(compatibility),
         new GameListItem(file_type_string),
         new GameListItemSize(size),
+        new GameListItemPlayTime(play_time_manager.GetPlayTime(program_id)),
     };
 
     const auto patch_versions = GetGameListCachedObject(
@@ -227,9 +229,12 @@ QList<QStandardItem*> MakeGameListEntry(const std::string& path, const std::stri
 GameListWorker::GameListWorker(FileSys::VirtualFilesystem vfs_,
                                FileSys::ManualContentProvider* provider_,
                                QVector<UISettings::GameDir>& game_dirs_,
-                               const CompatibilityList& compatibility_list_, Core::System& system_)
+                               const CompatibilityList& compatibility_list_,
+                               const PlayTime::PlayTimeManager& play_time_manager_,
+                               Core::System& system_)
     : vfs{std::move(vfs_)}, provider{provider_}, game_dirs{game_dirs_},
-      compatibility_list{compatibility_list_}, system{system_} {}
+      compatibility_list{compatibility_list_},
+      play_time_manager{play_time_manager_}, system{system_} {}
 
 GameListWorker::~GameListWorker() = default;
 
@@ -280,7 +285,7 @@ void GameListWorker::AddTitlesToGameList(GameListDir* parent_dir) {
         }
 
         emit EntryReady(MakeGameListEntry(file->GetFullPath(), name, file->GetSize(), icon, *loader,
-                                          program_id, compatibility_list, patch),
+                                          program_id, compatibility_list, play_time_manager, patch),
                         parent_dir);
     }
 }
@@ -357,7 +362,8 @@ void GameListWorker::ScanFileSystem(ScanTarget target, const std::string& dir_pa
 
                         emit EntryReady(MakeGameListEntry(physical_name, name,
                                                           Common::FS::GetSize(physical_name), icon,
-                                                          *loader, id, compatibility_list, patch),
+                                                          *loader, id, compatibility_list,
+                                                          play_time_manager, patch),
                                         parent_dir);
                     }
                 } else {
@@ -370,10 +376,11 @@ void GameListWorker::ScanFileSystem(ScanTarget target, const std::string& dir_pa
                     const FileSys::PatchManager patch{program_id, system.GetFileSystemController(),
                                                       system.GetContentProvider()};
 
-                    emit EntryReady(
-                        MakeGameListEntry(physical_name, name, Common::FS::GetSize(physical_name),
-                                          icon, *loader, program_id, compatibility_list, patch),
-                        parent_dir);
+                    emit EntryReady(MakeGameListEntry(physical_name, name,
+                                                      Common::FS::GetSize(physical_name), icon,
+                                                      *loader, program_id, compatibility_list,
+                                                      play_time_manager, patch),
+                                    parent_dir);
                 }
             }
         } else if (is_dir) {
diff --git a/src/yuzu/game_list_worker.h b/src/yuzu/game_list_worker.h
index 24a4e92c3..2bb0a0cb6 100644
--- a/src/yuzu/game_list_worker.h
+++ b/src/yuzu/game_list_worker.h
@@ -13,6 +13,7 @@
 #include <QString>
 
 #include "yuzu/compatibility_list.h"
+#include "yuzu/play_time_manager.h"
 
 namespace Core {
 class System;
@@ -36,7 +37,9 @@ public:
     explicit GameListWorker(std::shared_ptr<FileSys::VfsFilesystem> vfs_,
                             FileSys::ManualContentProvider* provider_,
                             QVector<UISettings::GameDir>& game_dirs_,
-                            const CompatibilityList& compatibility_list_, Core::System& system_);
+                            const CompatibilityList& compatibility_list_,
+                            const PlayTime::PlayTimeManager& play_time_manager_,
+                            Core::System& system_);
     ~GameListWorker() override;
 
     /// Starts the processing of directory tree information.
@@ -76,6 +79,7 @@ private:
     FileSys::ManualContentProvider* provider;
     QVector<UISettings::GameDir>& game_dirs;
     const CompatibilityList& compatibility_list;
+    const PlayTime::PlayTimeManager& play_time_manager;
 
     QStringList watch_list;
     std::atomic_bool stop_processing;
diff --git a/src/yuzu/main.cpp b/src/yuzu/main.cpp
index 1753fec12..5427758c1 100644
--- a/src/yuzu/main.cpp
+++ b/src/yuzu/main.cpp
@@ -98,6 +98,7 @@ static FileSys::VirtualFile VfsDirectoryCreateFileWrapper(const FileSys::Virtual
 #include "common/scm_rev.h"
 #include "common/scope_exit.h"
 #ifdef _WIN32
+#include <shlobj.h>
 #include "common/windows/timer_resolution.h"
 #endif
 #ifdef ARCHITECTURE_x86_64
@@ -150,6 +151,7 @@ static FileSys::VirtualFile VfsDirectoryCreateFileWrapper(const FileSys::Virtual
 #include "yuzu/install_dialog.h"
 #include "yuzu/loading_screen.h"
 #include "yuzu/main.h"
+#include "yuzu/play_time_manager.h"
 #include "yuzu/startup_checks.h"
 #include "yuzu/uisettings.h"
 #include "yuzu/util/clickable_label.h"
@@ -338,6 +340,8 @@ GMainWindow::GMainWindow(std::unique_ptr<Config> config_, bool has_broken_vulkan
     SetDiscordEnabled(UISettings::values.enable_discord_presence.GetValue());
     discord_rpc->Update();
 
+    play_time_manager = std::make_unique<PlayTime::PlayTimeManager>();
+
     system->GetRoomNetwork().Init();
 
     RegisterMetaTypes();
@@ -986,7 +990,7 @@ void GMainWindow::InitializeWidgets() {
     render_window = new GRenderWindow(this, emu_thread.get(), input_subsystem, *system);
     render_window->hide();
 
-    game_list = new GameList(vfs, provider.get(), *system, this);
+    game_list = new GameList(vfs, provider.get(), *play_time_manager, *system, this);
     ui->horizontalLayout->addWidget(game_list);
 
     game_list_placeholder = new GameListPlaceholder(this);
@@ -1461,6 +1465,8 @@ void GMainWindow::ConnectWidgetEvents() {
     connect(game_list, &GameList::RemoveInstalledEntryRequested, this,
             &GMainWindow::OnGameListRemoveInstalledEntry);
     connect(game_list, &GameList::RemoveFileRequested, this, &GMainWindow::OnGameListRemoveFile);
+    connect(game_list, &GameList::RemovePlayTimeRequested, this,
+            &GMainWindow::OnGameListRemovePlayTimeData);
     connect(game_list, &GameList::DumpRomFSRequested, this, &GMainWindow::OnGameListDumpRomFS);
     connect(game_list, &GameList::VerifyIntegrityRequested, this,
             &GMainWindow::OnGameListVerifyIntegrity);
@@ -1554,6 +1560,7 @@ void GMainWindow::ConnectMenuEvents() {
     // Tools
     connect_menu(ui->action_Rederive, std::bind(&GMainWindow::OnReinitializeKeys, this,
                                                 ReinitializeKeyBehavior::Warning));
+    connect_menu(ui->action_Load_Album, &GMainWindow::OnAlbum);
     connect_menu(ui->action_Load_Cabinet_Nickname_Owner,
                  [this]() { OnCabinet(Service::NFP::CabinetMode::StartNicknameAndOwnerSettings); });
     connect_menu(ui->action_Load_Cabinet_Eraser,
@@ -1591,6 +1598,7 @@ void GMainWindow::UpdateMenuState() {
     };
 
     const std::array applet_actions{
+        ui->action_Load_Album,
         ui->action_Load_Cabinet_Nickname_Owner,
         ui->action_Load_Cabinet_Eraser,
         ui->action_Load_Cabinet_Restorer,
@@ -2535,6 +2543,17 @@ void GMainWindow::OnGameListRemoveFile(u64 program_id, GameListRemoveTarget targ
     }
 }
 
+void GMainWindow::OnGameListRemovePlayTimeData(u64 program_id) {
+    if (QMessageBox::question(this, tr("Remove Play Time Data"), tr("Reset play time?"),
+                              QMessageBox::Yes | QMessageBox::No,
+                              QMessageBox::No) != QMessageBox::Yes) {
+        return;
+    }
+
+    play_time_manager->ResetProgramPlayTime(program_id);
+    game_list->PopulateAsync(UISettings::values.game_dirs);
+}
+
 void GMainWindow::RemoveTransferableShaderCache(u64 program_id, GameListRemoveTarget target) {
     const auto target_file_name = [target] {
         switch (target) {
@@ -2826,7 +2845,6 @@ void GMainWindow::OnGameListCreateShortcut(u64 program_id, const std::string& ga
     const QStringList args = QApplication::arguments();
     std::filesystem::path yuzu_command = args[0].toStdString();
 
-#if defined(__linux__) || defined(__FreeBSD__)
     // If relative path, make it an absolute path
     if (yuzu_command.c_str()[0] == '.') {
         yuzu_command = Common::FS::GetCurrentDir() / yuzu_command;
@@ -2849,12 +2867,14 @@ void GMainWindow::OnGameListCreateShortcut(u64 program_id, const std::string& ga
         UISettings::values.shortcut_already_warned = true;
     }
 #endif // __linux__
-#endif // __linux__ || __FreeBSD__
 
     std::filesystem::path target_directory{};
     // Determine target directory for shortcut
-#if defined(__linux__) || defined(__FreeBSD__)
+#if defined(WIN32)
+    const char* home = std::getenv("USERPROFILE");
+#else
     const char* home = std::getenv("HOME");
+#endif
     const std::filesystem::path home_path = (home == nullptr ? "~" : home);
     const char* xdg_data_home = std::getenv("XDG_DATA_HOME");
 
@@ -2864,7 +2884,7 @@ void GMainWindow::OnGameListCreateShortcut(u64 program_id, const std::string& ga
             QMessageBox::critical(
                 this, tr("Create Shortcut"),
                 tr("Cannot create shortcut on desktop. Path \"%1\" does not exist.")
-                    .arg(QString::fromStdString(target_directory)),
+                    .arg(QString::fromStdString(target_directory.generic_string())),
                 QMessageBox::StandardButton::Ok);
             return;
         }
@@ -2872,15 +2892,15 @@ void GMainWindow::OnGameListCreateShortcut(u64 program_id, const std::string& ga
         target_directory = (xdg_data_home == nullptr ? home_path / ".local/share" : xdg_data_home) /
                            "applications";
         if (!Common::FS::CreateDirs(target_directory)) {
-            QMessageBox::critical(this, tr("Create Shortcut"),
-                                  tr("Cannot create shortcut in applications menu. Path \"%1\" "
-                                     "does not exist and cannot be created.")
-                                      .arg(QString::fromStdString(target_directory)),
-                                  QMessageBox::StandardButton::Ok);
+            QMessageBox::critical(
+                this, tr("Create Shortcut"),
+                tr("Cannot create shortcut in applications menu. Path \"%1\" "
+                   "does not exist and cannot be created.")
+                    .arg(QString::fromStdString(target_directory.generic_string())),
+                QMessageBox::StandardButton::Ok);
             return;
         }
     }
-#endif
 
     const std::string game_file_name = std::filesystem::path(game_path).filename().string();
     // Determine full paths for icon and shortcut
@@ -2902,9 +2922,14 @@ void GMainWindow::OnGameListCreateShortcut(u64 program_id, const std::string& ga
     const std::filesystem::path shortcut_path =
         target_directory / (program_id == 0 ? fmt::format("yuzu-{}.desktop", game_file_name)
                                             : fmt::format("yuzu-{:016X}.desktop", program_id));
+#elif defined(WIN32)
+    std::filesystem::path icons_path =
+        Common::FS::GetYuzuPathString(Common::FS::YuzuPath::IconsDir);
+    std::filesystem::path icon_path =
+        icons_path / ((program_id == 0 ? fmt::format("yuzu-{}.ico", game_file_name)
+                                       : fmt::format("yuzu-{:016X}.ico", program_id)));
 #else
-    const std::filesystem::path icon_path{};
-    const std::filesystem::path shortcut_path{};
+    std::string icon_extension;
 #endif
 
     // Get title from game file
@@ -2929,29 +2954,37 @@ void GMainWindow::OnGameListCreateShortcut(u64 program_id, const std::string& ga
         LOG_WARNING(Frontend, "Could not read icon from {:s}", game_path);
     }
 
-    QImage icon_jpeg =
+    QImage icon_data =
         QImage::fromData(icon_image_file.data(), static_cast<int>(icon_image_file.size()));
 #if defined(__linux__) || defined(__FreeBSD__)
     // Convert and write the icon as a PNG
-    if (!icon_jpeg.save(QString::fromStdString(icon_path.string()))) {
+    if (!icon_data.save(QString::fromStdString(icon_path.string()))) {
         LOG_ERROR(Frontend, "Could not write icon as PNG to file");
     } else {
         LOG_INFO(Frontend, "Wrote an icon to {}", icon_path.string());
     }
+#elif defined(WIN32)
+    if (!SaveIconToFile(icon_path.string(), icon_data)) {
+        LOG_ERROR(Frontend, "Could not write icon to file");
+        return;
+    }
 #endif // __linux__
 
-#if defined(__linux__) || defined(__FreeBSD__)
+#ifdef _WIN32
+    // Replace characters that are illegal in Windows filenames by a dash
+    const std::string illegal_chars = "<>:\"/\\|?*";
+    for (char c : illegal_chars) {
+        std::replace(title.begin(), title.end(), c, '_');
+    }
+    const std::filesystem::path shortcut_path = target_directory / (title + ".lnk").c_str();
+#endif
+
     const std::string comment =
         tr("Start %1 with the yuzu Emulator").arg(QString::fromStdString(title)).toStdString();
     const std::string arguments = fmt::format("-g \"{:s}\"", game_path);
     const std::string categories = "Game;Emulator;Qt;";
     const std::string keywords = "Switch;Nintendo;";
-#else
-    const std::string comment{};
-    const std::string arguments{};
-    const std::string categories{};
-    const std::string keywords{};
-#endif
+
     if (!CreateShortcut(shortcut_path.string(), title, comment, icon_path.string(),
                         yuzu_command.string(), arguments, categories, keywords)) {
         QMessageBox::critical(this, tr("Create Shortcut"),
@@ -3358,6 +3391,9 @@ void GMainWindow::OnStartGame() {
     UpdateMenuState();
     OnTasStateChanged();
 
+    play_time_manager->SetProgramId(system->GetApplicationProcessProgramID());
+    play_time_manager->Start();
+
     discord_rpc->Update();
 }
 
@@ -3373,6 +3409,7 @@ void GMainWindow::OnRestartGame() {
 
 void GMainWindow::OnPauseGame() {
     emu_thread->SetRunning(false);
+    play_time_manager->Stop();
     UpdateMenuState();
     AllowOSSleep();
 }
@@ -3393,6 +3430,9 @@ void GMainWindow::OnStopGame() {
         return;
     }
 
+    play_time_manager->Stop();
+    // Update game list to show new play time
+    game_list->PopulateAsync(UISettings::values.game_dirs);
     if (OnShutdownBegin()) {
         OnShutdownBeginDialog();
     } else {
@@ -3966,6 +4006,34 @@ bool GMainWindow::CreateShortcut(const std::string& shortcut_path, const std::st
     shortcut_stream.close();
 
     return true;
+#elif defined(WIN32)
+    IShellLinkW* shell_link;
+    auto hres = CoCreateInstance(CLSID_ShellLink, NULL, CLSCTX_INPROC_SERVER, IID_IShellLinkW,
+                                 (void**)&shell_link);
+    if (FAILED(hres)) {
+        return false;
+    }
+    shell_link->SetPath(
+        Common::UTF8ToUTF16W(command).data()); // Path to the object we are referring to
+    shell_link->SetArguments(Common::UTF8ToUTF16W(arguments).data());
+    shell_link->SetDescription(Common::UTF8ToUTF16W(comment).data());
+    shell_link->SetIconLocation(Common::UTF8ToUTF16W(icon_path).data(), 0);
+
+    IPersistFile* persist_file;
+    hres = shell_link->QueryInterface(IID_IPersistFile, (void**)&persist_file);
+    if (FAILED(hres)) {
+        return false;
+    }
+
+    hres = persist_file->Save(Common::UTF8ToUTF16W(shortcut_path).data(), TRUE);
+    if (FAILED(hres)) {
+        return false;
+    }
+
+    persist_file->Release();
+    shell_link->Release();
+
+    return true;
 #endif
     return false;
 }
@@ -4158,6 +4226,29 @@ void GMainWindow::OnToggleStatusBar() {
     statusBar()->setVisible(ui->action_Show_Status_Bar->isChecked());
 }
 
+void GMainWindow::OnAlbum() {
+    constexpr u64 AlbumId = 0x010000000000100Dull;
+    auto bis_system = system->GetFileSystemController().GetSystemNANDContents();
+    if (!bis_system) {
+        QMessageBox::warning(this, tr("No firmware available"),
+                             tr("Please install the firmware to use the Album applet."));
+        return;
+    }
+
+    auto album_nca = bis_system->GetEntry(AlbumId, FileSys::ContentRecordType::Program);
+    if (!album_nca) {
+        QMessageBox::warning(this, tr("Album Applet"),
+                             tr("Album applet is not available. Please reinstall firmware."));
+        return;
+    }
+
+    system->GetAppletManager().SetCurrentAppletId(Service::AM::Applets::AppletId::PhotoViewer);
+
+    const auto filename = QString::fromStdString(album_nca->GetFullPath());
+    UISettings::values.roms_path = QFileInfo(filename).path();
+    BootGame(filename);
+}
+
 void GMainWindow::OnCabinet(Service::NFP::CabinetMode mode) {
     constexpr u64 CabinetId = 0x0100000000001002ull;
     auto bis_system = system->GetFileSystemController().GetSystemNANDContents();
diff --git a/src/yuzu/main.h b/src/yuzu/main.h
index 52028234c..2346eb3bd 100644
--- a/src/yuzu/main.h
+++ b/src/yuzu/main.h
@@ -81,6 +81,10 @@ namespace DiscordRPC {
 class DiscordInterface;
 }
 
+namespace PlayTime {
+class PlayTimeManager;
+}
+
 namespace FileSys {
 class ContentProvider;
 class ManualContentProvider;
@@ -323,6 +327,7 @@ private slots:
     void OnGameListRemoveInstalledEntry(u64 program_id, InstalledEntryType type);
     void OnGameListRemoveFile(u64 program_id, GameListRemoveTarget target,
                               const std::string& game_path);
+    void OnGameListRemovePlayTimeData(u64 program_id);
     void OnGameListDumpRomFS(u64 program_id, const std::string& game_path, DumpRomFSTarget target);
     void OnGameListVerifyIntegrity(const std::string& game_path);
     void OnGameListCopyTID(u64 program_id);
@@ -369,6 +374,7 @@ private slots:
     void ResetWindowSize720();
     void ResetWindowSize900();
     void ResetWindowSize1080();
+    void OnAlbum();
     void OnCabinet(Service::NFP::CabinetMode mode);
     void OnMiiEdit();
     void OnCaptureScreenshot();
@@ -389,6 +395,7 @@ private:
     void RemoveVulkanDriverPipelineCache(u64 program_id);
     void RemoveAllTransferableShaderCaches(u64 program_id);
     void RemoveCustomConfiguration(u64 program_id, const std::string& game_path);
+    void RemovePlayTimeData(u64 program_id);
     void RemoveCacheStorage(u64 program_id);
     bool SelectRomFSDumpTarget(const FileSys::ContentProvider&, u64 program_id,
                                u64* selected_title_id, u8* selected_content_record_type);
@@ -428,6 +435,7 @@ private:
 
     std::unique_ptr<Core::System> system;
     std::unique_ptr<DiscordRPC::DiscordInterface> discord_rpc;
+    std::unique_ptr<PlayTime::PlayTimeManager> play_time_manager;
     std::shared_ptr<InputCommon::InputSubsystem> input_subsystem;
 
     MultiplayerState* multiplayer_state = nullptr;
diff --git a/src/yuzu/main.ui b/src/yuzu/main.ui
index 31c3de9ef..88684ffb5 100644
--- a/src/yuzu/main.ui
+++ b/src/yuzu/main.ui
@@ -160,6 +160,7 @@
     <addaction name="action_Verify_installed_contents"/>
     <addaction name="separator"/>
     <addaction name="menu_cabinet_applet"/>
+    <addaction name="action_Load_Album"/>
     <addaction name="action_Load_Mii_Edit"/>
     <addaction name="separator"/>
     <addaction name="action_Capture_Screenshot"/>
@@ -380,6 +381,11 @@
     <string>&amp;Capture Screenshot</string>
    </property>
   </action>
+  <action name="action_Load_Album">
+    <property name="text">
+      <string>Open &amp;Album</string>
+    </property>
+  </action>
   <action name="action_Load_Cabinet_Nickname_Owner">
    <property name="text">
     <string>&amp;Set Nickname and Owner</string>
diff --git a/src/yuzu/play_time_manager.cpp b/src/yuzu/play_time_manager.cpp
new file mode 100644
index 000000000..155c36b7d
--- /dev/null
+++ b/src/yuzu/play_time_manager.cpp
@@ -0,0 +1,179 @@
+// SPDX-FileCopyrightText: 2023 yuzu Emulator Project
+// SPDX-License-Identifier: GPL-2.0-or-later
+
+#include "common/alignment.h"
+#include "common/fs/file.h"
+#include "common/fs/fs.h"
+#include "common/fs/path_util.h"
+#include "common/logging/log.h"
+#include "common/settings.h"
+#include "common/thread.h"
+#include "core/hle/service/acc/profile_manager.h"
+#include "yuzu/play_time_manager.h"
+
+namespace PlayTime {
+
+namespace {
+
+struct PlayTimeElement {
+    ProgramId program_id;
+    PlayTime play_time;
+};
+
+std::optional<std::filesystem::path> GetCurrentUserPlayTimePath() {
+    const Service::Account::ProfileManager manager;
+    const auto uuid = manager.GetUser(static_cast<s32>(Settings::values.current_user));
+    if (!uuid.has_value()) {
+        return std::nullopt;
+    }
+    return Common::FS::GetYuzuPath(Common::FS::YuzuPath::PlayTimeDir) /
+           uuid->RawString().append(".bin");
+}
+
+[[nodiscard]] bool ReadPlayTimeFile(PlayTimeDatabase& out_play_time_db) {
+    const auto filename = GetCurrentUserPlayTimePath();
+
+    if (!filename.has_value()) {
+        LOG_ERROR(Frontend, "Failed to get current user path");
+        return false;
+    }
+
+    out_play_time_db.clear();
+
+    if (Common::FS::Exists(filename.value())) {
+        Common::FS::IOFile file{filename.value(), Common::FS::FileAccessMode::Read,
+                                Common::FS::FileType::BinaryFile};
+        if (!file.IsOpen()) {
+            LOG_ERROR(Frontend, "Failed to open play time file: {}",
+                      Common::FS::PathToUTF8String(filename.value()));
+            return false;
+        }
+
+        const size_t num_elements = file.GetSize() / sizeof(PlayTimeElement);
+        std::vector<PlayTimeElement> elements(num_elements);
+
+        if (file.ReadSpan<PlayTimeElement>(elements) != num_elements) {
+            return false;
+        }
+
+        for (const auto& [program_id, play_time] : elements) {
+            if (program_id != 0) {
+                out_play_time_db[program_id] = play_time;
+            }
+        }
+    }
+
+    return true;
+}
+
+[[nodiscard]] bool WritePlayTimeFile(const PlayTimeDatabase& play_time_db) {
+    const auto filename = GetCurrentUserPlayTimePath();
+
+    if (!filename.has_value()) {
+        LOG_ERROR(Frontend, "Failed to get current user path");
+        return false;
+    }
+
+    Common::FS::IOFile file{filename.value(), Common::FS::FileAccessMode::Write,
+                            Common::FS::FileType::BinaryFile};
+    if (!file.IsOpen()) {
+        LOG_ERROR(Frontend, "Failed to open play time file: {}",
+                  Common::FS::PathToUTF8String(filename.value()));
+        return false;
+    }
+
+    std::vector<PlayTimeElement> elements;
+    elements.reserve(play_time_db.size());
+
+    for (auto& [program_id, play_time] : play_time_db) {
+        if (program_id != 0) {
+            elements.push_back(PlayTimeElement{program_id, play_time});
+        }
+    }
+
+    return file.WriteSpan<PlayTimeElement>(elements) == elements.size();
+}
+
+} // namespace
+
+PlayTimeManager::PlayTimeManager() {
+    if (!ReadPlayTimeFile(database)) {
+        LOG_ERROR(Frontend, "Failed to read play time database! Resetting to default.");
+    }
+}
+
+PlayTimeManager::~PlayTimeManager() {
+    Save();
+}
+
+void PlayTimeManager::SetProgramId(u64 program_id) {
+    running_program_id = program_id;
+}
+
+void PlayTimeManager::Start() {
+    play_time_thread = std::jthread([&](std::stop_token stop_token) { AutoTimestamp(stop_token); });
+}
+
+void PlayTimeManager::Stop() {
+    play_time_thread = {};
+}
+
+void PlayTimeManager::AutoTimestamp(std::stop_token stop_token) {
+    Common::SetCurrentThreadName("PlayTimeReport");
+
+    using namespace std::literals::chrono_literals;
+    using std::chrono::seconds;
+    using std::chrono::steady_clock;
+
+    auto timestamp = steady_clock::now();
+
+    const auto GetDuration = [&]() -> u64 {
+        const auto last_timestamp = std::exchange(timestamp, steady_clock::now());
+        const auto duration = std::chrono::duration_cast<seconds>(timestamp - last_timestamp);
+        return static_cast<u64>(duration.count());
+    };
+
+    while (!stop_token.stop_requested()) {
+        Common::StoppableTimedWait(stop_token, 30s);
+
+        database[running_program_id] += GetDuration();
+        Save();
+    }
+}
+
+void PlayTimeManager::Save() {
+    if (!WritePlayTimeFile(database)) {
+        LOG_ERROR(Frontend, "Failed to update play time database!");
+    }
+}
+
+u64 PlayTimeManager::GetPlayTime(u64 program_id) const {
+    auto it = database.find(program_id);
+    if (it != database.end()) {
+        return it->second;
+    } else {
+        return 0;
+    }
+}
+
+void PlayTimeManager::ResetProgramPlayTime(u64 program_id) {
+    database.erase(program_id);
+    Save();
+}
+
+QString ReadablePlayTime(qulonglong time_seconds) {
+    if (time_seconds == 0) {
+        return {};
+    }
+    const auto time_minutes = std::max(static_cast<double>(time_seconds) / 60, 1.0);
+    const auto time_hours = static_cast<double>(time_seconds) / 3600;
+    const bool is_minutes = time_minutes < 60;
+    const char* unit = is_minutes ? "m" : "h";
+    const auto value = is_minutes ? time_minutes : time_hours;
+
+    return QStringLiteral("%L1 %2")
+        .arg(value, 0, 'f', !is_minutes && time_seconds % 60 != 0)
+        .arg(QString::fromUtf8(unit));
+}
+
+} // namespace PlayTime
diff --git a/src/yuzu/play_time_manager.h b/src/yuzu/play_time_manager.h
new file mode 100644
index 000000000..5f96f3447
--- /dev/null
+++ b/src/yuzu/play_time_manager.h
@@ -0,0 +1,44 @@
+// SPDX-FileCopyrightText: 2023 yuzu Emulator Project
+// SPDX-License-Identifier: GPL-2.0-or-later
+
+#pragma once
+
+#include <QString>
+
+#include <map>
+
+#include "common/common_funcs.h"
+#include "common/common_types.h"
+#include "common/polyfill_thread.h"
+
+namespace PlayTime {
+
+using ProgramId = u64;
+using PlayTime = u64;
+using PlayTimeDatabase = std::map<ProgramId, PlayTime>;
+
+class PlayTimeManager {
+public:
+    explicit PlayTimeManager();
+    ~PlayTimeManager();
+
+    YUZU_NON_COPYABLE(PlayTimeManager);
+    YUZU_NON_MOVEABLE(PlayTimeManager);
+
+    u64 GetPlayTime(u64 program_id) const;
+    void ResetProgramPlayTime(u64 program_id);
+    void SetProgramId(u64 program_id);
+    void Start();
+    void Stop();
+
+private:
+    PlayTimeDatabase database;
+    u64 running_program_id;
+    std::jthread play_time_thread;
+    void AutoTimestamp(std::stop_token stop_token);
+    void Save();
+};
+
+QString ReadablePlayTime(qulonglong time_seconds);
+
+} // namespace PlayTime
diff --git a/src/yuzu/uisettings.h b/src/yuzu/uisettings.h
index 8a2caa9dd..975008159 100644
--- a/src/yuzu/uisettings.h
+++ b/src/yuzu/uisettings.h
@@ -183,6 +183,9 @@ struct Values {
     Setting<bool> show_size{linkage, true, "show_size", Category::UiGameList};
     Setting<bool> show_types{linkage, true, "show_types", Category::UiGameList};
 
+    // Play time
+    Setting<bool> show_play_time{linkage, true, "show_play_time", Category::UiGameList};
+
     bool configuration_applied;
     bool reset_to_defaults;
     bool shortcut_already_warned{false};
diff --git a/src/yuzu/util/util.cpp b/src/yuzu/util/util.cpp
index 5c3e4589e..61cf00176 100644
--- a/src/yuzu/util/util.cpp
+++ b/src/yuzu/util/util.cpp
@@ -5,6 +5,10 @@
 #include <cmath>
 #include <QPainter>
 #include "yuzu/util/util.h"
+#ifdef _WIN32
+#include <windows.h>
+#include "common/fs/file.h"
+#endif
 
 QFont GetMonospaceFont() {
     QFont font(QStringLiteral("monospace"));
@@ -37,3 +41,76 @@ QPixmap CreateCirclePixmapFromColor(const QColor& color) {
     painter.drawEllipse({circle_pixmap.width() / 2.0, circle_pixmap.height() / 2.0}, 7.0, 7.0);
     return circle_pixmap;
 }
+
+bool SaveIconToFile(const std::string_view path, const QImage& image) {
+#if defined(WIN32)
+#pragma pack(push, 2)
+    struct IconDir {
+        WORD id_reserved;
+        WORD id_type;
+        WORD id_count;
+    };
+
+    struct IconDirEntry {
+        BYTE width;
+        BYTE height;
+        BYTE color_count;
+        BYTE reserved;
+        WORD planes;
+        WORD bit_count;
+        DWORD bytes_in_res;
+        DWORD image_offset;
+    };
+#pragma pack(pop)
+
+    QImage source_image = image.convertToFormat(QImage::Format_RGB32);
+    constexpr int bytes_per_pixel = 4;
+    const int image_size = source_image.width() * source_image.height() * bytes_per_pixel;
+
+    BITMAPINFOHEADER info_header{};
+    info_header.biSize = sizeof(BITMAPINFOHEADER), info_header.biWidth = source_image.width(),
+    info_header.biHeight = source_image.height() * 2, info_header.biPlanes = 1,
+    info_header.biBitCount = bytes_per_pixel * 8, info_header.biCompression = BI_RGB;
+
+    const IconDir icon_dir{.id_reserved = 0, .id_type = 1, .id_count = 1};
+    const IconDirEntry icon_entry{.width = static_cast<BYTE>(source_image.width()),
+                                  .height = static_cast<BYTE>(source_image.height() * 2),
+                                  .color_count = 0,
+                                  .reserved = 0,
+                                  .planes = 1,
+                                  .bit_count = bytes_per_pixel * 8,
+                                  .bytes_in_res =
+                                      static_cast<DWORD>(sizeof(BITMAPINFOHEADER) + image_size),
+                                  .image_offset = sizeof(IconDir) + sizeof(IconDirEntry)};
+
+    Common::FS::IOFile icon_file(path, Common::FS::FileAccessMode::Write,
+                                 Common::FS::FileType::BinaryFile);
+    if (!icon_file.IsOpen()) {
+        return false;
+    }
+
+    if (!icon_file.Write(icon_dir)) {
+        return false;
+    }
+    if (!icon_file.Write(icon_entry)) {
+        return false;
+    }
+    if (!icon_file.Write(info_header)) {
+        return false;
+    }
+
+    for (int y = 0; y < image.height(); y++) {
+        const auto* line = source_image.scanLine(source_image.height() - 1 - y);
+        std::vector<u8> line_data(source_image.width() * bytes_per_pixel);
+        std::memcpy(line_data.data(), line, line_data.size());
+        if (!icon_file.Write(line_data)) {
+            return false;
+        }
+    }
+    icon_file.Close();
+
+    return true;
+#else
+    return false;
+#endif
+}
diff --git a/src/yuzu/util/util.h b/src/yuzu/util/util.h
index 39dd2d895..09c14ce3f 100644
--- a/src/yuzu/util/util.h
+++ b/src/yuzu/util/util.h
@@ -7,14 +7,22 @@
 #include <QString>
 
 /// Returns a QFont object appropriate to use as a monospace font for debugging widgets, etc.
-QFont GetMonospaceFont();
+[[nodiscard]] QFont GetMonospaceFont();
 
 /// Convert a size in bytes into a readable format (KiB, MiB, etc.)
-QString ReadableByteSize(qulonglong size);
+[[nodiscard]] QString ReadableByteSize(qulonglong size);
 
 /**
  * Creates a circle pixmap from a specified color
  * @param color The color the pixmap shall have
  * @return QPixmap circle pixmap
  */
-QPixmap CreateCirclePixmapFromColor(const QColor& color);
+[[nodiscard]] QPixmap CreateCirclePixmapFromColor(const QColor& color);
+
+/**
+ * Saves a windows icon to a file
+ * @param path The icons path
+ * @param image The image to save
+ * @return bool If the operation succeeded
+ */
+[[nodiscard]] bool SaveIconToFile(const std::string_view path, const QImage& image);