33 files changed, 418 insertions, 155 deletions
diff --git a/src/common/microprofile.h b/src/common/microprofile.h
index 91d14d5e1..56ef0a2dc 100644
--- a/src/common/microprofile.h
+++ b/src/common/microprofile.h
@@ -22,12 +22,3 @@ typedef void* HANDLE;
 #include <microprofile.h>
 #define MP_RGB(r, g, b) ((r) << 16 | (g) << 8 | (b) << 0)
-// On OS X, some Mach header included by MicroProfile defines these as macros, conflicting with
-// identifiers we use.
-#ifdef PAGE_SIZE
-#undef PAGE_SIZE
-#endif
-#ifdef PAGE_MASK
-#undef PAGE_MASK
-#endif
diff --git a/src/core/CMakeLists.txt b/src/core/CMakeLists.txt
index 3230d7199..8db9a3c65 100644
--- a/src/core/CMakeLists.txt
+++ b/src/core/CMakeLists.txt
@@ -786,7 +786,7 @@ endif()
 create_target_directory_groups(core)
 target_link_libraries(core PUBLIC common PRIVATE audio_core network video_core)
-target_link_libraries(core PUBLIC Boost::boost PRIVATE fmt::fmt nlohmann_json::nlohmann_json mbedtls Opus::Opus)
+target_link_libraries(core PUBLIC Boost::boost PRIVATE fmt::fmt nlohmann_json::nlohmann_json mbedtls Opus::opus)
 if (MINGW)
    target_link_libraries(core PRIVATE ${MSWSOCK_LIBRARY})
 endif()
diff --git a/src/core/arm/dynarmic/arm_dynarmic_32.cpp b/src/core/arm/dynarmic/arm_dynarmic_32.cpp
index 3b8b43994..d1e70f19d 100644
--- a/src/core/arm/dynarmic/arm_dynarmic_32.cpp
+++ b/src/core/arm/dynarmic/arm_dynarmic_32.cpp
@@ -190,8 +190,8 @@ std::shared_ptr<Dynarmic::A32::Jit> ARM_Dynarmic_32::MakeJit(Common::PageTable*
    config.callbacks = cb.get();
    config.coprocessors[15] = cp15;
    config.define_unpredictable_behaviour = true;
-    static constexpr std::size_t PAGE_BITS = 12;
+    static constexpr std::size_t YUZU_PAGEBITS = 12;
-    static constexpr std::size_t NUM_PAGE_TABLE_ENTRIES = 1 << (32 - PAGE_BITS);
+    static constexpr std::size_t NUM_PAGE_TABLE_ENTRIES = 1 << (32 - YUZU_PAGEBITS);
    if (page_table) {
        config.page_table = reinterpret_cast<std::array<std::uint8_t*, NUM_PAGE_TABLE_ENTRIES>*>(
            page_table->pointers.data());
diff --git a/src/core/file_sys/ips_layer.cpp b/src/core/file_sys/ips_layer.cpp
index a33dbe94b..5aab428bb 100644
--- a/src/core/file_sys/ips_layer.cpp
+++ b/src/core/file_sys/ips_layer.cpp
@@ -217,9 +217,7 @@ void IPSwitchCompiler::Parse() {
            break;
        } else if (StartsWith(line, "@nsobid-")) {
            // NSO Build ID Specifier
-            auto raw_build_id = line.substr(8);
+            const auto raw_build_id = fmt::format("{:0<64}", line.substr(8));
-            if (raw_build_id.size() != 0x40)
-                raw_build_id.resize(0x40, '0');
            nso_build_id = Common::HexStringToArray<0x20>(raw_build_id);
        } else if (StartsWith(line, "#")) {
            // Mandatory Comment
diff --git a/src/core/file_sys/patch_manager.cpp b/src/core/file_sys/patch_manager.cpp
index bd525b26c..4c80e13a9 100644
--- a/src/core/file_sys/patch_manager.cpp
+++ b/src/core/file_sys/patch_manager.cpp
@@ -191,6 +191,7 @@ VirtualDir PatchManager::PatchExeFS(VirtualDir exefs) const {
 std::vector<VirtualFile> PatchManager::CollectPatches(const std::vector<VirtualDir>& patch_dirs,
                                                      const std::string& build_id) const {
    const auto& disabled = Settings::values.disabled_addons[title_id];
+    const auto nso_build_id = fmt::format("{:0<64}", build_id);
    std::vector<VirtualFile> out;
    out.reserve(patch_dirs.size());
@@ -203,21 +204,18 @@ std::vector<VirtualFile> PatchManager::CollectPatches(const std::vector<VirtualD
            for (const auto& file : exefs_dir->GetFiles()) {
                if (file->GetExtension() == "ips") {
                    auto name = file->GetName();
-                    const auto p1 = name.substr(0, name.find('.'));
-                    const auto this_build_id = p1.substr(0, p1.find_last_not_of('0') + 1);
-                    if (build_id == this_build_id)
+                    const auto this_build_id =
+                        fmt::format("{:0<64}", name.substr(0, name.find('.')));
+                    if (nso_build_id == this_build_id)
                        out.push_back(file);
                } else if (file->GetExtension() == "pchtxt") {
                    IPSwitchCompiler compiler{file};
                    if (!compiler.IsValid())
                        continue;
-                    auto this_build_id = Common::HexToString(compiler.GetBuildID());
+                    const auto this_build_id = Common::HexToString(compiler.GetBuildID());
-                    this_build_id =
+                    if (nso_build_id == this_build_id)
-                        this_build_id.substr(0, this_build_id.find_last_not_of('0') + 1);
-                    if (build_id == this_build_id)
                        out.push_back(file);
                }
            }
diff --git a/src/core/hle/service/filesystem/fsp_srv.cpp b/src/core/hle/service/filesystem/fsp_srv.cpp
index fae6e5aff..e23eae36a 100644
--- a/src/core/hle/service/filesystem/fsp_srv.cpp
+++ b/src/core/hle/service/filesystem/fsp_srv.cpp
@@ -246,7 +246,8 @@ static void BuildEntryIndex(std::vector<FileSys::Entry>& entries, const std::vec
    entries.reserve(entries.size() + new_data.size());
    for (const auto& new_entry : new_data) {
-        entries.emplace_back(new_entry->GetName(), type, new_entry->GetSize());
+        entries.emplace_back(new_entry->GetName(), type,
+                             type == FileSys::EntryType::Directory ? 0 : new_entry->GetSize());
    }
 }
diff --git a/src/core/hle/service/hid/hid.cpp b/src/core/hle/service/hid/hid.cpp
index 5ecbddf94..7909141c0 100644
--- a/src/core/hle/service/hid/hid.cpp
+++ b/src/core/hle/service/hid/hid.cpp
@@ -2146,12 +2146,18 @@ public:
            {324, nullptr, "GetUniquePadButtonSet"},
            {325, nullptr, "GetUniquePadColor"},
            {326, nullptr, "GetUniquePadAppletDetailedUiType"},
+            {327, nullptr, "GetAbstractedPadIdDataFromNpad"},
+            {328, nullptr, "AttachAbstractedPadToNpad"},
+            {329, nullptr, "DetachAbstractedPadAll"},
+            {330, nullptr, "CheckAbstractedPadConnection"},
            {500, nullptr, "SetAppletResourceUserId"},
            {501, nullptr, "RegisterAppletResourceUserId"},
            {502, nullptr, "UnregisterAppletResourceUserId"},
            {503, nullptr, "EnableAppletToGetInput"},
            {504, nullptr, "SetAruidValidForVibration"},
            {505, nullptr, "EnableAppletToGetSixAxisSensor"},
+            {506, nullptr, "EnableAppletToGetPadInput"},
+            {507, nullptr, "EnableAppletToGetTouchScreen"},
            {510, nullptr, "SetVibrationMasterVolume"},
            {511, nullptr, "GetVibrationMasterVolume"},
            {512, nullptr, "BeginPermitVibrationSession"},
diff --git a/src/core/hle/service/pcv/pcv.cpp b/src/core/hle/service/pcv/pcv.cpp
index 0989474be..f7a497a14 100644
--- a/src/core/hle/service/pcv/pcv.cpp
+++ b/src/core/hle/service/pcv/pcv.cpp
@@ -3,6 +3,7 @@
 #include <memory>
+#include "core/hle/ipc_helpers.h"
 #include "core/hle/service/pcv/pcv.h"
 #include "core/hle/service/service.h"
 #include "core/hle/service/sm/sm.h"
@@ -77,10 +78,102 @@ public:
    }
 };
+class IClkrstSession final : public ServiceFramework<IClkrstSession> {
+public:
+    explicit IClkrstSession(Core::System& system_, DeviceCode deivce_code_)
+        : ServiceFramework{system_, "IClkrstSession"}, deivce_code(deivce_code_) {
+        // clang-format off
+        static const FunctionInfo functions[] = {
+            {0, nullptr, "SetClockEnabled"},
+            {1, nullptr, "SetClockDisabled"},
+            {2, nullptr, "SetResetAsserted"},
+            {3, nullptr, "SetResetDeasserted"},
+            {4, nullptr, "SetPowerEnabled"},
+            {5, nullptr, "SetPowerDisabled"},
+            {6, nullptr, "GetState"},
+            {7, &IClkrstSession::SetClockRate, "SetClockRate"},
+            {8, &IClkrstSession::GetClockRate, "GetClockRate"},
+            {9, nullptr, "SetMinVClockRate"},
+            {10, nullptr, "GetPossibleClockRates"},
+            {11, nullptr, "GetDvfsTable"},
+        };
+        // clang-format on
+        RegisterHandlers(functions);
+    }
+private:
+    void SetClockRate(Kernel::HLERequestContext& ctx) {
+        IPC::RequestParser rp{ctx};
+        clock_rate = rp.Pop<u32>();
+        LOG_DEBUG(Service_PCV, "(STUBBED) called, clock_rate={}", clock_rate);
+        IPC::ResponseBuilder rb{ctx, 2};
+        rb.Push(ResultSuccess);
+    }
+    void GetClockRate(Kernel::HLERequestContext& ctx) {
+        LOG_DEBUG(Service_PCV, "(STUBBED) called");
+        IPC::ResponseBuilder rb{ctx, 3};
+        rb.Push(ResultSuccess);
+        rb.Push<u32>(clock_rate);
+    }
+    DeviceCode deivce_code;
+    u32 clock_rate{};
+};
+class CLKRST final : public ServiceFramework<CLKRST> {
+public:
+    explicit CLKRST(Core::System& system_, const char* name) : ServiceFramework{system_, name} {
+        // clang-format off
+        static const FunctionInfo functions[] = {
+            {0, &CLKRST::OpenSession, "OpenSession"},
+            {1, nullptr, "GetTemperatureThresholds"},
+            {2, nullptr, "SetTemperature"},
+            {3, nullptr, "GetModuleStateTable"},
+            {4, nullptr, "GetModuleStateTableEvent"},
+            {5, nullptr, "GetModuleStateTableMaxCount"},
+        };
+        // clang-format on
+        RegisterHandlers(functions);
+    }
+private:
+    void OpenSession(Kernel::HLERequestContext& ctx) {
+        IPC::RequestParser rp{ctx};
+        const auto device_code = static_cast<DeviceCode>(rp.Pop<u32>());
+        const auto unkonwn_input = rp.Pop<u32>();
+        LOG_DEBUG(Service_PCV, "called, device_code={}, input={}", device_code, unkonwn_input);
+        IPC::ResponseBuilder rb{ctx, 2, 0, 1};
+        rb.Push(ResultSuccess);
+        rb.PushIpcInterface<IClkrstSession>(system, device_code);
+    }
+};
+class CLKRST_A final : public ServiceFramework<CLKRST_A> {
+public:
+    explicit CLKRST_A(Core::System& system_) : ServiceFramework{system_, "clkrst:a"} {
+        // clang-format off
+        static const FunctionInfo functions[] = {
+            {0, nullptr, "ReleaseControl"},
+        };
+        // clang-format on
+        RegisterHandlers(functions);
+    }
+};
 void InstallInterfaces(SM::ServiceManager& sm, Core::System& system) {
    std::make_shared<PCV>(system)->InstallAsService(sm);
    std::make_shared<PCV_ARB>(system)->InstallAsService(sm);
    std::make_shared<PCV_IMM>(system)->InstallAsService(sm);
+    std::make_shared<CLKRST>(system, "clkrst")->InstallAsService(sm);
+    std::make_shared<CLKRST>(system, "clkrst:i")->InstallAsService(sm);
+    std::make_shared<CLKRST_A>(system)->InstallAsService(sm);
 }
 } // namespace Service::PCV
diff --git a/src/core/hle/service/pcv/pcv.h b/src/core/hle/service/pcv/pcv.h
index a42e6f8f6..6b26b6fa7 100644
--- a/src/core/hle/service/pcv/pcv.h
+++ b/src/core/hle/service/pcv/pcv.h
@@ -13,6 +13,97 @@ class ServiceManager;
 namespace Service::PCV {
+enum class DeviceCode : u32 {
+    Cpu = 0x40000001,
+    Gpu = 0x40000002,
+    I2s1 = 0x40000003,
+    I2s2 = 0x40000004,
+    I2s3 = 0x40000005,
+    Pwm = 0x40000006,
+    I2c1 = 0x02000001,
+    I2c2 = 0x02000002,
+    I2c3 = 0x02000003,
+    I2c4 = 0x02000004,
+    I2c5 = 0x02000005,
+    I2c6 = 0x02000006,
+    Spi1 = 0x07000000,
+    Spi2 = 0x07000001,
+    Spi3 = 0x07000002,
+    Spi4 = 0x07000003,
+    Disp1 = 0x40000011,
+    Disp2 = 0x40000012,
+    Isp = 0x40000013,
+    Vi = 0x40000014,
+    Sdmmc1 = 0x40000015,
+    Sdmmc2 = 0x40000016,
+    Sdmmc3 = 0x40000017,
+    Sdmmc4 = 0x40000018,
+    Owr = 0x40000019,
+    Csite = 0x4000001A,
+    Tsec = 0x4000001B,
+    Mselect = 0x4000001C,
+    Hda2codec2x = 0x4000001D,
+    Actmon = 0x4000001E,
+    I2cSlow = 0x4000001F,
+    Sor1 = 0x40000020,
+    Sata = 0x40000021,
+    Hda = 0x40000022,
+    XusbCoreHostSrc = 0x40000023,
+    XusbFalconSrc = 0x40000024,
+    XusbFsSrc = 0x40000025,
+    XusbCoreDevSrc = 0x40000026,
+    XusbSsSrc = 0x40000027,
+    UartA = 0x03000001,
+    UartB = 0x35000405,
+    UartC = 0x3500040F,
+    UartD = 0x37000001,
+    Host1x = 0x4000002C,
+    Entropy = 0x4000002D,
+    SocTherm = 0x4000002E,
+    Vic = 0x4000002F,
+    Nvenc = 0x40000030,
+    Nvjpg = 0x40000031,
+    Nvdec = 0x40000032,
+    Qspi = 0x40000033,
+    ViI2c = 0x40000034,
+    Tsecb = 0x40000035,
+    Ape = 0x40000036,
+    AudioDsp = 0x40000037,
+    AudioUart = 0x40000038,
+    Emc = 0x40000039,
+    Plle = 0x4000003A,
+    PlleHwSeq = 0x4000003B,
+    Dsi = 0x4000003C,
+    Maud = 0x4000003D,
+    Dpaux1 = 0x4000003E,
+    MipiCal = 0x4000003F,
+    UartFstMipiCal = 0x40000040,
+    Osc = 0x40000041,
+    SysBus = 0x40000042,
+    SorSafe = 0x40000043,
+    XusbSs = 0x40000044,
+    XusbHost = 0x40000045,
+    XusbDevice = 0x40000046,
+    Extperiph1 = 0x40000047,
+    Ahub = 0x40000048,
+    Hda2hdmicodec = 0x40000049,
+    Gpuaux = 0x4000004A,
+    UsbD = 0x4000004B,
+    Usb2 = 0x4000004C,
+    Pcie = 0x4000004D,
+    Afi = 0x4000004E,
+    PciExClk = 0x4000004F,
+    PExUsbPhy = 0x40000050,
+    XUsbPadCtl = 0x40000051,
+    Apbdma = 0x40000052,
+    Usb2TrkClk = 0x40000053,
+    XUsbIoPll = 0x40000054,
+    XUsbIoPllHwSeq = 0x40000055,
+    Cec = 0x40000056,
+    Extperiph2 = 0x40000057,
+    OscClk = 0x40000080
+};
 void InstallInterfaces(SM::ServiceManager& sm, Core::System& system);
 } // namespace Service::PCV
diff --git a/src/core/loader/kip.cpp b/src/core/loader/kip.cpp
index 9af46a0f7..d8a1bf82a 100644
--- a/src/core/loader/kip.cpp
+++ b/src/core/loader/kip.cpp
@@ -14,7 +14,7 @@ namespace Loader {
 namespace {
 constexpr u32 PageAlignSize(u32 size) {
-    return static_cast<u32>((size + Core::Memory::PAGE_MASK) & ~Core::Memory::PAGE_MASK);
+    return static_cast<u32>((size + Core::Memory::YUZU_PAGEMASK) & ~Core::Memory::YUZU_PAGEMASK);
 }
 } // Anonymous namespace
diff --git a/src/core/loader/nro.cpp b/src/core/loader/nro.cpp
index 1b0bb0876..73d04d7ee 100644
--- a/src/core/loader/nro.cpp
+++ b/src/core/loader/nro.cpp
@@ -125,7 +125,7 @@ FileType AppLoader_NRO::IdentifyType(const FileSys::VirtualFile& nro_file) {
 }
 static constexpr u32 PageAlignSize(u32 size) {
-    return static_cast<u32>((size + Core::Memory::PAGE_MASK) & ~Core::Memory::PAGE_MASK);
+    return static_cast<u32>((size + Core::Memory::YUZU_PAGEMASK) & ~Core::Memory::YUZU_PAGEMASK);
 }
 static bool LoadNroImpl(Kernel::KProcess& process, const std::vector<u8>& data) {
diff --git a/src/core/loader/nso.cpp b/src/core/loader/nso.cpp
index 8dd956fc6..4c3b3c655 100644
--- a/src/core/loader/nso.cpp
+++ b/src/core/loader/nso.cpp
@@ -45,7 +45,7 @@ std::vector<u8> DecompressSegment(const std::vector<u8>& compressed_data,
 }
 constexpr u32 PageAlignSize(u32 size) {
-    return static_cast<u32>((size + Core::Memory::PAGE_MASK) & ~Core::Memory::PAGE_MASK);
+    return static_cast<u32>((size + Core::Memory::YUZU_PAGEMASK) & ~Core::Memory::YUZU_PAGEMASK);
 }
 } // Anonymous namespace
diff --git a/src/core/memory.cpp b/src/core/memory.cpp
index 1b44280b5..34ad7cadd 100644
--- a/src/core/memory.cpp
+++ b/src/core/memory.cpp
@@ -36,10 +36,11 @@ struct Memory::Impl {
    }
    void MapMemoryRegion(Common::PageTable& page_table, VAddr base, u64 size, PAddr target) {
-        ASSERT_MSG((size & PAGE_MASK) == 0, "non-page aligned size: {:016X}", size);
+        ASSERT_MSG((size & YUZU_PAGEMASK) == 0, "non-page aligned size: {:016X}", size);
-        ASSERT_MSG((base & PAGE_MASK) == 0, "non-page aligned base: {:016X}", base);
+        ASSERT_MSG((base & YUZU_PAGEMASK) == 0, "non-page aligned base: {:016X}", base);
        ASSERT_MSG(target >= DramMemoryMap::Base, "Out of bounds target: {:016X}", target);
-        MapPages(page_table, base / PAGE_SIZE, size / PAGE_SIZE, target, Common::PageType::Memory);
+        MapPages(page_table, base / YUZU_PAGESIZE, size / YUZU_PAGESIZE, target,
+                 Common::PageType::Memory);
        if (Settings::IsFastmemEnabled()) {
            system.DeviceMemory().buffer.Map(base, target - DramMemoryMap::Base, size);
@@ -47,9 +48,10 @@ struct Memory::Impl {
    }
    void UnmapRegion(Common::PageTable& page_table, VAddr base, u64 size) {
-        ASSERT_MSG((size & PAGE_MASK) == 0, "non-page aligned size: {:016X}", size);
+        ASSERT_MSG((size & YUZU_PAGEMASK) == 0, "non-page aligned size: {:016X}", size);
-        ASSERT_MSG((base & PAGE_MASK) == 0, "non-page aligned base: {:016X}", base);
+        ASSERT_MSG((base & YUZU_PAGEMASK) == 0, "non-page aligned base: {:016X}", base);
-        MapPages(page_table, base / PAGE_SIZE, size / PAGE_SIZE, 0, Common::PageType::Unmapped);
+        MapPages(page_table, base / YUZU_PAGESIZE, size / YUZU_PAGESIZE, 0,
+                 Common::PageType::Unmapped);
        if (Settings::IsFastmemEnabled()) {
            system.DeviceMemory().buffer.Unmap(base, size);
@@ -57,7 +59,7 @@ struct Memory::Impl {
    }
    [[nodiscard]] u8* GetPointerFromRasterizerCachedMemory(VAddr vaddr) const {
-        const PAddr paddr{current_page_table->backing_addr[vaddr >> PAGE_BITS]};
+        const PAddr paddr{current_page_table->backing_addr[vaddr >> YUZU_PAGEBITS]};
        if (!paddr) {
            return {};
@@ -67,7 +69,7 @@ struct Memory::Impl {
    }
    [[nodiscard]] u8* GetPointerFromDebugMemory(VAddr vaddr) const {
-        const PAddr paddr{current_page_table->backing_addr[vaddr >> PAGE_BITS]};
+        const PAddr paddr{current_page_table->backing_addr[vaddr >> YUZU_PAGEBITS]};
        if (paddr == 0) {
            return {};
@@ -176,13 +178,14 @@ struct Memory::Impl {
                   auto on_unmapped, auto on_memory, auto on_rasterizer, auto increment) {
        const auto& page_table = process.PageTable().PageTableImpl();
        std::size_t remaining_size = size;
-        std::size_t page_index = addr >> PAGE_BITS;
+        std::size_t page_index = addr >> YUZU_PAGEBITS;
-        std::size_t page_offset = addr & PAGE_MASK;
+        std::size_t page_offset = addr & YUZU_PAGEMASK;
        while (remaining_size) {
            const std::size_t copy_amount =
-                std::min(static_cast<std::size_t>(PAGE_SIZE) - page_offset, remaining_size);
+                std::min(static_cast<std::size_t>(YUZU_PAGESIZE) - page_offset, remaining_size);
-            const auto current_vaddr = static_cast<VAddr>((page_index << PAGE_BITS) + page_offset);
+            const auto current_vaddr =
+                static_cast<VAddr>((page_index << YUZU_PAGEBITS) + page_offset);
            const auto [pointer, type] = page_table.pointers[page_index].PointerType();
            switch (type) {
@@ -192,7 +195,7 @@ struct Memory::Impl {
            }
            case Common::PageType::Memory: {
                DEBUG_ASSERT(pointer);
-                u8* mem_ptr = pointer + page_offset + (page_index << PAGE_BITS);
+                u8* mem_ptr = pointer + page_offset + (page_index << YUZU_PAGEBITS);
                on_memory(copy_amount, mem_ptr);
                break;
            }
@@ -339,10 +342,10 @@ struct Memory::Impl {
        // Iterate over a contiguous CPU address space, marking/unmarking the region.
        // The region is at a granularity of CPU pages.
-        const u64 num_pages = ((vaddr + size - 1) >> PAGE_BITS) - (vaddr >> PAGE_BITS) + 1;
+        const u64 num_pages = ((vaddr + size - 1) >> YUZU_PAGEBITS) - (vaddr >> YUZU_PAGEBITS) + 1;
-        for (u64 i = 0; i < num_pages; ++i, vaddr += PAGE_SIZE) {
+        for (u64 i = 0; i < num_pages; ++i, vaddr += YUZU_PAGESIZE) {
            const Common::PageType page_type{
-                current_page_table->pointers[vaddr >> PAGE_BITS].Type()};
+                current_page_table->pointers[vaddr >> YUZU_PAGEBITS].Type()};
            if (debug) {
                // Switch page type to debug if now debug
                switch (page_type) {
@@ -354,7 +357,7 @@ struct Memory::Impl {
                    // Page is already marked.
                    break;
                case Common::PageType::Memory:
-                    current_page_table->pointers[vaddr >> PAGE_BITS].Store(
+                    current_page_table->pointers[vaddr >> YUZU_PAGEBITS].Store(
                        nullptr, Common::PageType::DebugMemory);
                    break;
                default:
@@ -371,9 +374,9 @@ struct Memory::Impl {
                    // Don't mess with already non-debug or rasterizer memory.
                    break;
                case Common::PageType::DebugMemory: {
-                    u8* const pointer{GetPointerFromDebugMemory(vaddr & ~PAGE_MASK)};
+                    u8* const pointer{GetPointerFromDebugMemory(vaddr & ~YUZU_PAGEMASK)};
-                    current_page_table->pointers[vaddr >> PAGE_BITS].Store(
+                    current_page_table->pointers[vaddr >> YUZU_PAGEBITS].Store(
-                        pointer - (vaddr & ~PAGE_MASK), Common::PageType::Memory);
+                        pointer - (vaddr & ~YUZU_PAGEMASK), Common::PageType::Memory);
                    break;
                }
                default:
@@ -398,10 +401,10 @@ struct Memory::Impl {
        // granularity of CPU pages, hence why we iterate on a CPU page basis (note: GPU page size
        // is different). This assumes the specified GPU address region is contiguous as well.
-        const u64 num_pages = ((vaddr + size - 1) >> PAGE_BITS) - (vaddr >> PAGE_BITS) + 1;
+        const u64 num_pages = ((vaddr + size - 1) >> YUZU_PAGEBITS) - (vaddr >> YUZU_PAGEBITS) + 1;
-        for (u64 i = 0; i < num_pages; ++i, vaddr += PAGE_SIZE) {
+        for (u64 i = 0; i < num_pages; ++i, vaddr += YUZU_PAGESIZE) {
            const Common::PageType page_type{
-                current_page_table->pointers[vaddr >> PAGE_BITS].Type()};
+                current_page_table->pointers[vaddr >> YUZU_PAGEBITS].Type()};
            if (cached) {
                // Switch page type to cached if now cached
                switch (page_type) {
@@ -411,7 +414,7 @@ struct Memory::Impl {
                    break;
                case Common::PageType::DebugMemory:
                case Common::PageType::Memory:
-                    current_page_table->pointers[vaddr >> PAGE_BITS].Store(
+                    current_page_table->pointers[vaddr >> YUZU_PAGEBITS].Store(
                        nullptr, Common::PageType::RasterizerCachedMemory);
                    break;
                case Common::PageType::RasterizerCachedMemory:
@@ -434,16 +437,16 @@ struct Memory::Impl {
                    // that this area is already unmarked as cached.
                    break;
                case Common::PageType::RasterizerCachedMemory: {
-                    u8* const pointer{GetPointerFromRasterizerCachedMemory(vaddr & ~PAGE_MASK)};
+                    u8* const pointer{GetPointerFromRasterizerCachedMemory(vaddr & ~YUZU_PAGEMASK)};
                    if (pointer == nullptr) {
                        // It's possible that this function has been called while updating the
                        // pagetable after unmapping a VMA. In that case the underlying VMA will no
                        // longer exist, and we should just leave the pagetable entry blank.
-                        current_page_table->pointers[vaddr >> PAGE_BITS].Store(
+                        current_page_table->pointers[vaddr >> YUZU_PAGEBITS].Store(
                            nullptr, Common::PageType::Unmapped);
                    } else {
-                        current_page_table->pointers[vaddr >> PAGE_BITS].Store(
+                        current_page_table->pointers[vaddr >> YUZU_PAGEBITS].Store(
-                            pointer - (vaddr & ~PAGE_MASK), Common::PageType::Memory);
+                            pointer - (vaddr & ~YUZU_PAGEMASK), Common::PageType::Memory);
                    }
                    break;
                }
@@ -465,8 +468,8 @@ struct Memory::Impl {
     */
    void MapPages(Common::PageTable& page_table, VAddr base, u64 size, PAddr target,
                  Common::PageType type) {
-        LOG_DEBUG(HW_Memory, "Mapping {:016X} onto {:016X}-{:016X}", target, base * PAGE_SIZE,
+        LOG_DEBUG(HW_Memory, "Mapping {:016X} onto {:016X}-{:016X}", target, base * YUZU_PAGESIZE,
-                  (base + size) * PAGE_SIZE);
+                  (base + size) * YUZU_PAGESIZE);
        // During boot, current_page_table might not be set yet, in which case we need not flush
        if (system.IsPoweredOn()) {
@@ -474,7 +477,7 @@ struct Memory::Impl {
            for (u64 i = 0; i < size; i++) {
                const auto page = base + i;
                if (page_table.pointers[page].Type() == Common::PageType::RasterizerCachedMemory) {
-                    gpu.FlushAndInvalidateRegion(page << PAGE_BITS, PAGE_SIZE);
+                    gpu.FlushAndInvalidateRegion(page << YUZU_PAGEBITS, YUZU_PAGESIZE);
                }
            }
        }
@@ -485,7 +488,7 @@ struct Memory::Impl {
        if (!target) {
            ASSERT_MSG(type != Common::PageType::Memory,
-                       "Mapping memory page without a pointer @ {:016x}", base * PAGE_SIZE);
+                       "Mapping memory page without a pointer @ {:016x}", base * YUZU_PAGESIZE);
            while (base != end) {
                page_table.pointers[base].Store(nullptr, type);
@@ -496,14 +499,14 @@ struct Memory::Impl {
        } else {
            while (base != end) {
                page_table.pointers[base].Store(
-                    system.DeviceMemory().GetPointer(target) - (base << PAGE_BITS), type);
+                    system.DeviceMemory().GetPointer(target) - (base << YUZU_PAGEBITS), type);
-                page_table.backing_addr[base] = target - (base << PAGE_BITS);
+                page_table.backing_addr[base] = target - (base << YUZU_PAGEBITS);
                ASSERT_MSG(page_table.pointers[base].Pointer(),
                           "memory mapping base yield a nullptr within the table");
                base += 1;
-                target += PAGE_SIZE;
+                target += YUZU_PAGESIZE;
            }
        }
    }
@@ -518,7 +521,7 @@ struct Memory::Impl {
        }
        // Avoid adding any extra logic to this fast-path block
-        const uintptr_t raw_pointer = current_page_table->pointers[vaddr >> PAGE_BITS].Raw();
+        const uintptr_t raw_pointer = current_page_table->pointers[vaddr >> YUZU_PAGEBITS].Raw();
        if (u8* const pointer = Common::PageTable::PageInfo::ExtractPointer(raw_pointer)) {
            return &pointer[vaddr];
        }
@@ -657,7 +660,7 @@ void Memory::UnmapRegion(Common::PageTable& page_table, VAddr base, u64 size) {
 bool Memory::IsValidVirtualAddress(const VAddr vaddr) const {
    const Kernel::KProcess& process = *system.CurrentProcess();
    const auto& page_table = process.PageTable().PageTableImpl();
-    const size_t page = vaddr >> PAGE_BITS;
+    const size_t page = vaddr >> YUZU_PAGEBITS;
    if (page >= page_table.pointers.size()) {
        return false;
    }
@@ -668,9 +671,9 @@ bool Memory::IsValidVirtualAddress(const VAddr vaddr) const {
 bool Memory::IsValidVirtualAddressRange(VAddr base, u64 size) const {
    VAddr end = base + size;
-    VAddr page = Common::AlignDown(base, PAGE_SIZE);
+    VAddr page = Common::AlignDown(base, YUZU_PAGESIZE);
-    for (; page < end; page += PAGE_SIZE) {
+    for (; page < end; page += YUZU_PAGESIZE) {
        if (!IsValidVirtualAddress(page)) {
            return false;
        }
diff --git a/src/core/memory.h b/src/core/memory.h
index 2a21fbcfd..a11ff8766 100644
--- a/src/core/memory.h
+++ b/src/core/memory.h
@@ -27,9 +27,9 @@ namespace Core::Memory {
 * Page size used by the ARM architecture. This is the smallest granularity with which memory can
 * be mapped.
 */
-constexpr std::size_t PAGE_BITS = 12;
+constexpr std::size_t YUZU_PAGEBITS = 12;
-constexpr u64 PAGE_SIZE = 1ULL << PAGE_BITS;
+constexpr u64 YUZU_PAGESIZE = 1ULL << YUZU_PAGEBITS;
-constexpr u64 PAGE_MASK = PAGE_SIZE - 1;
+constexpr u64 YUZU_PAGEMASK = YUZU_PAGESIZE - 1;
 /// Virtual user-space memory regions
 enum : VAddr {
diff --git a/src/tests/video_core/buffer_base.cpp b/src/tests/video_core/buffer_base.cpp
index a1be8dcf1..71121e42a 100644
--- a/src/tests/video_core/buffer_base.cpp
+++ b/src/tests/video_core/buffer_base.cpp
@@ -22,8 +22,9 @@ constexpr VAddr c = 0x1328914000;
 class RasterizerInterface {
 public:
    void UpdatePagesCachedCount(VAddr addr, u64 size, int delta) {
-        const u64 page_start{addr >> Core::Memory::PAGE_BITS};
+        const u64 page_start{addr >> Core::Memory::YUZU_PAGEBITS};
-        const u64 page_end{(addr + size + Core::Memory::PAGE_SIZE - 1) >> Core::Memory::PAGE_BITS};
+        const u64 page_end{(addr + size + Core::Memory::YUZU_PAGESIZE - 1) >>
+                           Core::Memory::YUZU_PAGEBITS};
        for (u64 page = page_start; page < page_end; ++page) {
            int& value = page_table[page];
            value += delta;
@@ -37,7 +38,7 @@ public:
    }
    [[nodiscard]] int Count(VAddr addr) const noexcept {
-        const auto it = page_table.find(addr >> Core::Memory::PAGE_BITS);
+        const auto it = page_table.find(addr >> Core::Memory::YUZU_PAGEBITS);
        return it == page_table.end() ? 0 : it->second;
    }
diff --git a/src/video_core/buffer_cache/buffer_base.h b/src/video_core/buffer_cache/buffer_base.h
index 3e20608ca..0b2bc67b1 100644
--- a/src/video_core/buffer_cache/buffer_base.h
+++ b/src/video_core/buffer_cache/buffer_base.h
@@ -36,7 +36,7 @@ struct NullBufferParams {};
 template <class RasterizerInterface>
 class BufferBase {
    static constexpr u64 PAGES_PER_WORD = 64;
-    static constexpr u64 BYTES_PER_PAGE = Core::Memory::PAGE_SIZE;
+    static constexpr u64 BYTES_PER_PAGE = Core::Memory::YUZU_PAGESIZE;
    static constexpr u64 BYTES_PER_WORD = PAGES_PER_WORD * BYTES_PER_PAGE;
    /// Vector tracking modified pages tightly packed with small vector optimization
diff --git a/src/video_core/buffer_cache/buffer_cache.h b/src/video_core/buffer_cache/buffer_cache.h
index b74ad7900..f015dae56 100644
--- a/src/video_core/buffer_cache/buffer_cache.h
+++ b/src/video_core/buffer_cache/buffer_cache.h
@@ -60,8 +60,8 @@ class BufferCache {
    // Page size for caching purposes.
    // This is unrelated to the CPU page size and it can be changed as it seems optimal.
-    static constexpr u32 PAGE_BITS = 16;
+    static constexpr u32 YUZU_PAGEBITS = 16;
-    static constexpr u64 PAGE_SIZE = u64{1} << PAGE_BITS;
+    static constexpr u64 YUZU_PAGESIZE = u64{1} << YUZU_PAGEBITS;
    static constexpr bool IS_OPENGL = P::IS_OPENGL;
    static constexpr bool HAS_PERSISTENT_UNIFORM_BUFFER_BINDINGS =
@@ -216,8 +216,8 @@ private:
    template <typename Func>
    void ForEachBufferInRange(VAddr cpu_addr, u64 size, Func&& func) {
-        const u64 page_end = Common::DivCeil(cpu_addr + size, PAGE_SIZE);
+        const u64 page_end = Common::DivCeil(cpu_addr + size, YUZU_PAGESIZE);
-        for (u64 page = cpu_addr >> PAGE_BITS; page < page_end;) {
+        for (u64 page = cpu_addr >> YUZU_PAGEBITS; page < page_end;) {
            const BufferId buffer_id = page_table[page];
            if (!buffer_id) {
                ++page;
@@ -227,7 +227,7 @@ private:
            func(buffer_id, buffer);
            const VAddr end_addr = buffer.CpuAddr() + buffer.SizeBytes();
-            page = Common::DivCeil(end_addr, PAGE_SIZE);
+            page = Common::DivCeil(end_addr, YUZU_PAGESIZE);
        }
    }
@@ -262,8 +262,8 @@ private:
    }
    static bool IsRangeGranular(VAddr cpu_addr, size_t size) {
-        return (cpu_addr & ~Core::Memory::PAGE_MASK) ==
+        return (cpu_addr & ~Core::Memory::YUZU_PAGEMASK) ==
-               ((cpu_addr + size) & ~Core::Memory::PAGE_MASK);
+               ((cpu_addr + size) & ~Core::Memory::YUZU_PAGEMASK);
    }
    void RunGarbageCollector();
@@ -439,7 +439,7 @@ private:
    u64 minimum_memory = 0;
    u64 critical_memory = 0;
-    std::array<BufferId, ((1ULL << 39) >> PAGE_BITS)> page_table;
+    std::array<BufferId, ((1ULL << 39) >> YUZU_PAGEBITS)> page_table;
 };
 template <class P>
@@ -926,8 +926,8 @@ void BufferCache<P>::PopAsyncFlushes() {}
 template <class P>
 bool BufferCache<P>::IsRegionGpuModified(VAddr addr, size_t size) {
-    const u64 page_end = Common::DivCeil(addr + size, PAGE_SIZE);
+    const u64 page_end = Common::DivCeil(addr + size, YUZU_PAGESIZE);
-    for (u64 page = addr >> PAGE_BITS; page < page_end;) {
+    for (u64 page = addr >> YUZU_PAGEBITS; page < page_end;) {
        const BufferId image_id = page_table[page];
        if (!image_id) {
            ++page;
@@ -938,7 +938,7 @@ bool BufferCache<P>::IsRegionGpuModified(VAddr addr, size_t size) {
            return true;
        }
        const VAddr end_addr = buffer.CpuAddr() + buffer.SizeBytes();
-        page = Common::DivCeil(end_addr, PAGE_SIZE);
+        page = Common::DivCeil(end_addr, YUZU_PAGESIZE);
    }
    return false;
 }
@@ -946,8 +946,8 @@ bool BufferCache<P>::IsRegionGpuModified(VAddr addr, size_t size) {
 template <class P>
 bool BufferCache<P>::IsRegionRegistered(VAddr addr, size_t size) {
    const VAddr end_addr = addr + size;
-    const u64 page_end = Common::DivCeil(end_addr, PAGE_SIZE);
+    const u64 page_end = Common::DivCeil(end_addr, YUZU_PAGESIZE);
-    for (u64 page = addr >> PAGE_BITS; page < page_end;) {
+    for (u64 page = addr >> YUZU_PAGEBITS; page < page_end;) {
        const BufferId buffer_id = page_table[page];
        if (!buffer_id) {
            ++page;
@@ -959,15 +959,15 @@ bool BufferCache<P>::IsRegionRegistered(VAddr addr, size_t size) {
        if (buf_start_addr < end_addr && addr < buf_end_addr) {
            return true;
        }
-        page = Common::DivCeil(end_addr, PAGE_SIZE);
+        page = Common::DivCeil(end_addr, YUZU_PAGESIZE);
    }
    return false;
 }
 template <class P>
 bool BufferCache<P>::IsRegionCpuModified(VAddr addr, size_t size) {
-    const u64 page_end = Common::DivCeil(addr + size, PAGE_SIZE);
+    const u64 page_end = Common::DivCeil(addr + size, YUZU_PAGESIZE);
-    for (u64 page = addr >> PAGE_BITS; page < page_end;) {
+    for (u64 page = addr >> YUZU_PAGEBITS; page < page_end;) {
        const BufferId image_id = page_table[page];
        if (!image_id) {
            ++page;
@@ -978,7 +978,7 @@ bool BufferCache<P>::IsRegionCpuModified(VAddr addr, size_t size) {
            return true;
        }
        const VAddr end_addr = buffer.CpuAddr() + buffer.SizeBytes();
-        page = Common::DivCeil(end_addr, PAGE_SIZE);
+        page = Common::DivCeil(end_addr, YUZU_PAGESIZE);
    }
    return false;
 }
@@ -1472,7 +1472,7 @@ BufferId BufferCache<P>::FindBuffer(VAddr cpu_addr, u32 size) {
    if (cpu_addr == 0) {
        return NULL_BUFFER_ID;
    }
-    const u64 page = cpu_addr >> PAGE_BITS;
+    const u64 page = cpu_addr >> YUZU_PAGEBITS;
    const BufferId buffer_id = page_table[page];
    if (!buffer_id) {
        return CreateBuffer(cpu_addr, size);
@@ -1493,8 +1493,9 @@ typename BufferCache<P>::OverlapResult BufferCache<P>::ResolveOverlaps(VAddr cpu
    VAddr end = cpu_addr + wanted_size;
    int stream_score = 0;
    bool has_stream_leap = false;
-    for (; cpu_addr >> PAGE_BITS < Common::DivCeil(end, PAGE_SIZE); cpu_addr += PAGE_SIZE) {
+    for (; cpu_addr >> YUZU_PAGEBITS < Common::DivCeil(end, YUZU_PAGESIZE);
-        const BufferId overlap_id = page_table[cpu_addr >> PAGE_BITS];
+         cpu_addr += YUZU_PAGESIZE) {
+        const BufferId overlap_id = page_table[cpu_addr >> YUZU_PAGEBITS];
        if (!overlap_id) {
            continue;
        }
@@ -1520,11 +1521,11 @@ typename BufferCache<P>::OverlapResult BufferCache<P>::ResolveOverlaps(VAddr cpu
            // as a stream buffer. Increase the size to skip constantly recreating buffers.
            has_stream_leap = true;
            if (expands_right) {
-                begin -= PAGE_SIZE * 256;
+                begin -= YUZU_PAGESIZE * 256;
                cpu_addr = begin;
            }
            if (expands_left) {
-                end += PAGE_SIZE * 256;
+                end += YUZU_PAGESIZE * 256;
            }
        }
    }
@@ -1598,8 +1599,8 @@ void BufferCache<P>::ChangeRegister(BufferId buffer_id) {
    }
    const VAddr cpu_addr_begin = buffer.CpuAddr();
    const VAddr cpu_addr_end = cpu_addr_begin + size;
-    const u64 page_begin = cpu_addr_begin / PAGE_SIZE;
+    const u64 page_begin = cpu_addr_begin / YUZU_PAGESIZE;
-    const u64 page_end = Common::DivCeil(cpu_addr_end, PAGE_SIZE);
+    const u64 page_end = Common::DivCeil(cpu_addr_end, YUZU_PAGESIZE);
    for (u64 page = page_begin; page != page_end; ++page) {
        if constexpr (insert) {
            page_table[page] = buffer_id;
diff --git a/src/video_core/memory_manager.cpp b/src/video_core/memory_manager.cpp
index d373be0ba..bf9eb735d 100644
--- a/src/video_core/memory_manager.cpp
+++ b/src/video_core/memory_manager.cpp
@@ -369,8 +369,8 @@ bool MemoryManager::IsGranularRange(GPUVAddr gpu_addr, std::size_t size) const {
    if (!cpu_addr) {
        return false;
    }
-    const std::size_t page{(*cpu_addr & Core::Memory::PAGE_MASK) + size};
+    const std::size_t page{(*cpu_addr & Core::Memory::YUZU_PAGEMASK) + size};
-    return page <= Core::Memory::PAGE_SIZE;
+    return page <= Core::Memory::YUZU_PAGESIZE;
 }
 bool MemoryManager::IsContinousRange(GPUVAddr gpu_addr, std::size_t size) const {
diff --git a/src/video_core/query_cache.h b/src/video_core/query_cache.h
index fcce87acb..889b606b3 100644
--- a/src/video_core/query_cache.h
+++ b/src/video_core/query_cache.h
@@ -214,8 +214,8 @@ private:
            return cache_begin < addr_end && addr_begin < cache_end;
        };
-        const u64 page_end = addr_end >> PAGE_BITS;
+        const u64 page_end = addr_end >> YUZU_PAGEBITS;
-        for (u64 page = addr_begin >> PAGE_BITS; page <= page_end; ++page) {
+        for (u64 page = addr_begin >> YUZU_PAGEBITS; page <= page_end; ++page) {
            const auto& it = cached_queries.find(page);
            if (it == std::end(cached_queries)) {
                continue;
@@ -235,14 +235,14 @@ private:
    /// Registers the passed parameters as cached and returns a pointer to the stored cached query.
    CachedQuery* Register(VideoCore::QueryType type, VAddr cpu_addr, u8* host_ptr, bool timestamp) {
        rasterizer.UpdatePagesCachedCount(cpu_addr, CachedQuery::SizeInBytes(timestamp), 1);
-        const u64 page = static_cast<u64>(cpu_addr) >> PAGE_BITS;
+        const u64 page = static_cast<u64>(cpu_addr) >> YUZU_PAGEBITS;
        return &cached_queries[page].emplace_back(static_cast<QueryCache&>(*this), type, cpu_addr,
                                                  host_ptr);
    }
    /// Tries to a get a cached query. Returns nullptr on failure.
    CachedQuery* TryGet(VAddr addr) {
-        const u64 page = static_cast<u64>(addr) >> PAGE_BITS;
+        const u64 page = static_cast<u64>(addr) >> YUZU_PAGEBITS;
        const auto it = cached_queries.find(page);
        if (it == std::end(cached_queries)) {
            return nullptr;
@@ -260,8 +260,8 @@ private:
        uncommitted_flushes->push_back(addr);
    }
-    static constexpr std::uintptr_t PAGE_SIZE = 4096;
+    static constexpr std::uintptr_t YUZU_PAGESIZE = 4096;
-    static constexpr unsigned PAGE_BITS = 12;
+    static constexpr unsigned YUZU_PAGEBITS = 12;
    VideoCore::RasterizerInterface& rasterizer;
    Tegra::Engines::Maxwell3D& maxwell3d;
diff --git a/src/video_core/rasterizer_accelerated.cpp b/src/video_core/rasterizer_accelerated.cpp
index 87a29e144..4a197d65d 100644
--- a/src/video_core/rasterizer_accelerated.cpp
+++ b/src/video_core/rasterizer_accelerated.cpp
@@ -24,8 +24,8 @@ void RasterizerAccelerated::UpdatePagesCachedCount(VAddr addr, u64 size, int del
    u64 cache_bytes = 0;
    std::atomic_thread_fence(std::memory_order_acquire);
-    const u64 page_end = Common::DivCeil(addr + size, PAGE_SIZE);
+    const u64 page_end = Common::DivCeil(addr + size, YUZU_PAGESIZE);
-    for (u64 page = addr >> PAGE_BITS; page != page_end; ++page) {
+    for (u64 page = addr >> YUZU_PAGEBITS; page != page_end; ++page) {
        std::atomic_uint16_t& count = cached_pages.at(page >> 2).Count(page);
        if (delta > 0) {
@@ -44,26 +44,27 @@ void RasterizerAccelerated::UpdatePagesCachedCount(VAddr addr, u64 size, int del
            if (uncache_bytes == 0) {
                uncache_begin = page;
            }
-            uncache_bytes += PAGE_SIZE;
+            uncache_bytes += YUZU_PAGESIZE;
        } else if (uncache_bytes > 0) {
-            cpu_memory.RasterizerMarkRegionCached(uncache_begin << PAGE_BITS, uncache_bytes, false);
+            cpu_memory.RasterizerMarkRegionCached(uncache_begin << YUZU_PAGEBITS, uncache_bytes,
+                                                  false);
            uncache_bytes = 0;
        }
        if (count.load(std::memory_order::relaxed) == 1 && delta > 0) {
            if (cache_bytes == 0) {
                cache_begin = page;
            }
-            cache_bytes += PAGE_SIZE;
+            cache_bytes += YUZU_PAGESIZE;
        } else if (cache_bytes > 0) {
-            cpu_memory.RasterizerMarkRegionCached(cache_begin << PAGE_BITS, cache_bytes, true);
+            cpu_memory.RasterizerMarkRegionCached(cache_begin << YUZU_PAGEBITS, cache_bytes, true);
            cache_bytes = 0;
        }
    }
    if (uncache_bytes > 0) {
-        cpu_memory.RasterizerMarkRegionCached(uncache_begin << PAGE_BITS, uncache_bytes, false);
+        cpu_memory.RasterizerMarkRegionCached(uncache_begin << YUZU_PAGEBITS, uncache_bytes, false);
    }
    if (cache_bytes > 0) {
-        cpu_memory.RasterizerMarkRegionCached(cache_begin << PAGE_BITS, cache_bytes, true);
+        cpu_memory.RasterizerMarkRegionCached(cache_begin << YUZU_PAGEBITS, cache_bytes, true);
    }
 }
diff --git a/src/video_core/renderer_opengl/renderer_opengl.cpp b/src/video_core/renderer_opengl/renderer_opengl.cpp
index 01028cee0..34f3f7a67 100644
--- a/src/video_core/renderer_opengl/renderer_opengl.cpp
+++ b/src/video_core/renderer_opengl/renderer_opengl.cpp
@@ -478,13 +478,16 @@ void RendererOpenGL::DrawScreen(const Layout::FramebufferLayout& layout) {
        }
    }
-    ASSERT_MSG(framebuffer_crop_rect.top == 0, "Unimplemented");
    ASSERT_MSG(framebuffer_crop_rect.left == 0, "Unimplemented");
+    f32 left_start{};
+    if (framebuffer_crop_rect.Top() > 0) {
+        left_start = static_cast<f32>(framebuffer_crop_rect.Top()) /
+                     static_cast<f32>(framebuffer_crop_rect.Bottom());
+    }
    f32 scale_u = static_cast<f32>(framebuffer_width) / static_cast<f32>(screen_info.texture.width);
    f32 scale_v =
        static_cast<f32>(framebuffer_height) / static_cast<f32>(screen_info.texture.height);
    // Scale the output by the crop width/height. This is commonly used with 1280x720 rendering
    // (e.g. handheld mode) on a 1920x1080 framebuffer.
    if (framebuffer_crop_rect.GetWidth() > 0) {
@@ -503,10 +506,14 @@ void RendererOpenGL::DrawScreen(const Layout::FramebufferLayout& layout) {
    const auto& screen = layout.screen;
    const std::array vertices = {
-        ScreenRectVertex(screen.left, screen.top, texcoords.top * scale_u, left * scale_v),
+        ScreenRectVertex(screen.left, screen.top, texcoords.top * scale_u,
-        ScreenRectVertex(screen.right, screen.top, texcoords.bottom * scale_u, left * scale_v),
+                         left_start + left * scale_v),
-        ScreenRectVertex(screen.left, screen.bottom, texcoords.top * scale_u, right * scale_v),
+        ScreenRectVertex(screen.right, screen.top, texcoords.bottom * scale_u,
-        ScreenRectVertex(screen.right, screen.bottom, texcoords.bottom * scale_u, right * scale_v),
+                         left_start + left * scale_v),
+        ScreenRectVertex(screen.left, screen.bottom, texcoords.top * scale_u,
+                         left_start + right * scale_v),
+        ScreenRectVertex(screen.right, screen.bottom, texcoords.bottom * scale_u,
+                         left_start + right * scale_v),
    };
    glNamedBufferSubData(vertex_buffer.handle, 0, sizeof(vertices), std::data(vertices));
diff --git a/src/video_core/renderer_vulkan/maxwell_to_vk.cpp b/src/video_core/renderer_vulkan/maxwell_to_vk.cpp
index 7d1431b6d..bdb71dc53 100644
--- a/src/video_core/renderer_vulkan/maxwell_to_vk.cpp
+++ b/src/video_core/renderer_vulkan/maxwell_to_vk.cpp
@@ -172,7 +172,7 @@ struct FormatTuple {
    {VK_FORMAT_R8G8_SINT, Attachable | Storage},               // R8G8_SINT
    {VK_FORMAT_R8G8_UINT, Attachable | Storage},               // R8G8_UINT
    {VK_FORMAT_R32G32_UINT, Attachable | Storage},             // R32G32_UINT
-    {VK_FORMAT_UNDEFINED},                                     // R16G16B16X16_FLOAT
+    {VK_FORMAT_R16G16B16A16_SFLOAT, Attachable | Storage},     // R16G16B16X16_FLOAT
    {VK_FORMAT_R32_UINT, Attachable | Storage},                // R32_UINT
    {VK_FORMAT_R32_SINT, Attachable | Storage},                // R32_SINT
    {VK_FORMAT_ASTC_8x8_UNORM_BLOCK},                          // ASTC_2D_8X8_UNORM
diff --git a/src/video_core/renderer_vulkan/vk_blit_screen.cpp b/src/video_core/renderer_vulkan/vk_blit_screen.cpp
index 27e6ebf94..444c29f68 100644
--- a/src/video_core/renderer_vulkan/vk_blit_screen.cpp
+++ b/src/video_core/renderer_vulkan/vk_blit_screen.cpp
@@ -1402,12 +1402,15 @@ void BlitScreen::SetVertexData(BufferData& data, const Tegra::FramebufferConfig&
        break;
    }
-    UNIMPLEMENTED_IF(framebuffer_crop_rect.top != 0);
    UNIMPLEMENTED_IF(framebuffer_crop_rect.left != 0);
+    f32 left_start{};
+    if (framebuffer_crop_rect.Top() > 0) {
+        left_start = static_cast<f32>(framebuffer_crop_rect.Top()) /
+                     static_cast<f32>(framebuffer_crop_rect.Bottom());
+    }
    f32 scale_u = static_cast<f32>(framebuffer.width) / static_cast<f32>(screen_info.width);
    f32 scale_v = static_cast<f32>(framebuffer.height) / static_cast<f32>(screen_info.height);
    // Scale the output by the crop width/height. This is commonly used with 1280x720 rendering
    // (e.g. handheld mode) on a 1920x1080 framebuffer.
    if (!fsr) {
@@ -1426,10 +1429,13 @@ void BlitScreen::SetVertexData(BufferData& data, const Tegra::FramebufferConfig&
    const auto y = static_cast<f32>(screen.top);
    const auto w = static_cast<f32>(screen.GetWidth());
    const auto h = static_cast<f32>(screen.GetHeight());
-    data.vertices[0] = ScreenRectVertex(x, y, texcoords.top * scale_u, left * scale_v);
+    data.vertices[0] = ScreenRectVertex(x, y, texcoords.top * scale_u, left_start + left * scale_v);
-    data.vertices[1] = ScreenRectVertex(x + w, y, texcoords.bottom * scale_u, left * scale_v);
+    data.vertices[1] =
-    data.vertices[2] = ScreenRectVertex(x, y + h, texcoords.top * scale_u, right * scale_v);
+        ScreenRectVertex(x + w, y, texcoords.bottom * scale_u, left_start + left * scale_v);
-    data.vertices[3] = ScreenRectVertex(x + w, y + h, texcoords.bottom * scale_u, right * scale_v);
+    data.vertices[2] =
+        ScreenRectVertex(x, y + h, texcoords.top * scale_u, left_start + right * scale_v);
+    data.vertices[3] =
+        ScreenRectVertex(x + w, y + h, texcoords.bottom * scale_u, left_start + right * scale_v);
 }
 void BlitScreen::CreateFSR() {
diff --git a/src/video_core/shader_cache.cpp b/src/video_core/shader_cache.cpp
index 4b1101f7c..164e4ee0e 100644
--- a/src/video_core/shader_cache.cpp
+++ b/src/video_core/shader_cache.cpp
@@ -123,8 +123,8 @@ void ShaderCache::Register(std::unique_ptr<ShaderInfo> data, VAddr addr, size_t
    const VAddr addr_end = addr + size;
    Entry* const entry = NewEntry(addr, addr_end, data.get());
-    const u64 page_end = (addr_end + PAGE_SIZE - 1) >> PAGE_BITS;
+    const u64 page_end = (addr_end + YUZU_PAGESIZE - 1) >> YUZU_PAGEBITS;
-    for (u64 page = addr >> PAGE_BITS; page < page_end; ++page) {
+    for (u64 page = addr >> YUZU_PAGEBITS; page < page_end; ++page) {
        invalidation_cache[page].push_back(entry);
    }
@@ -135,8 +135,8 @@ void ShaderCache::Register(std::unique_ptr<ShaderInfo> data, VAddr addr, size_t
 void ShaderCache::InvalidatePagesInRegion(VAddr addr, size_t size) {
    const VAddr addr_end = addr + size;
-    const u64 page_end = (addr_end + PAGE_SIZE - 1) >> PAGE_BITS;
+    const u64 page_end = (addr_end + YUZU_PAGESIZE - 1) >> YUZU_PAGEBITS;
-    for (u64 page = addr >> PAGE_BITS; page < page_end; ++page) {
+    for (u64 page = addr >> YUZU_PAGEBITS; page < page_end; ++page) {
        auto it = invalidation_cache.find(page);
        if (it == invalidation_cache.end()) {
            continue;
@@ -189,8 +189,8 @@ void ShaderCache::InvalidatePageEntries(std::vector<Entry*>& entries, VAddr addr
 }
 void ShaderCache::RemoveEntryFromInvalidationCache(const Entry* entry) {
-    const u64 page_end = (entry->addr_end + PAGE_SIZE - 1) >> PAGE_BITS;
+    const u64 page_end = (entry->addr_end + YUZU_PAGESIZE - 1) >> YUZU_PAGEBITS;
-    for (u64 page = entry->addr_start >> PAGE_BITS; page < page_end; ++page) {
+    for (u64 page = entry->addr_start >> YUZU_PAGEBITS; page < page_end; ++page) {
        const auto entries_it = invalidation_cache.find(page);
        ASSERT(entries_it != invalidation_cache.end());
        std::vector<Entry*>& entries = entries_it->second;
diff --git a/src/video_core/shader_cache.h b/src/video_core/shader_cache.h
index 1109cfe83..f67cea8c4 100644
--- a/src/video_core/shader_cache.h
+++ b/src/video_core/shader_cache.h
@@ -29,8 +29,8 @@ struct ShaderInfo {
 };
 class ShaderCache {
-    static constexpr u64 PAGE_BITS = 14;
+    static constexpr u64 YUZU_PAGEBITS = 14;
-    static constexpr u64 PAGE_SIZE = u64(1) << PAGE_BITS;
+    static constexpr u64 YUZU_PAGESIZE = u64(1) << YUZU_PAGEBITS;
    static constexpr size_t NUM_PROGRAMS = 6;
diff --git a/src/video_core/texture_cache/texture_cache.h b/src/video_core/texture_cache/texture_cache.h
index cf3ca06a6..1dbe01bc0 100644
--- a/src/video_core/texture_cache/texture_cache.h
+++ b/src/video_core/texture_cache/texture_cache.h
@@ -589,7 +589,7 @@ void TextureCache<P>::BlitImage(const Tegra::Engines::Fermi2D::Surface& dst,
 template <class P>
 typename P::ImageView* TextureCache<P>::TryFindFramebufferImageView(VAddr cpu_addr) {
    // TODO: Properly implement this
-    const auto it = page_table.find(cpu_addr >> PAGE_BITS);
+    const auto it = page_table.find(cpu_addr >> YUZU_PAGEBITS);
    if (it == page_table.end()) {
        return nullptr;
    }
@@ -1485,14 +1485,14 @@ void TextureCache<P>::UnregisterImage(ImageId image_id) {
            std::unordered_map<u64, std::vector<ImageId>, IdentityHash<u64>>& selected_page_table) {
            const auto page_it = selected_page_table.find(page);
            if (page_it == selected_page_table.end()) {
-                ASSERT_MSG(false, "Unregistering unregistered page=0x{:x}", page << PAGE_BITS);
+                ASSERT_MSG(false, "Unregistering unregistered page=0x{:x}", page << YUZU_PAGEBITS);
                return;
            }
            std::vector<ImageId>& image_ids = page_it->second;
            const auto vector_it = std::ranges::find(image_ids, image_id);
            if (vector_it == image_ids.end()) {
                ASSERT_MSG(false, "Unregistering unregistered image in page=0x{:x}",
-                           page << PAGE_BITS);
+                           page << YUZU_PAGEBITS);
                return;
            }
            image_ids.erase(vector_it);
@@ -1504,14 +1504,14 @@ void TextureCache<P>::UnregisterImage(ImageId image_id) {
        ForEachCPUPage(image.cpu_addr, image.guest_size_bytes, [this, map_id](u64 page) {
            const auto page_it = page_table.find(page);
            if (page_it == page_table.end()) {
-                ASSERT_MSG(false, "Unregistering unregistered page=0x{:x}", page << PAGE_BITS);
+                ASSERT_MSG(false, "Unregistering unregistered page=0x{:x}", page << YUZU_PAGEBITS);
                return;
            }
            std::vector<ImageMapId>& image_map_ids = page_it->second;
            const auto vector_it = std::ranges::find(image_map_ids, map_id);
            if (vector_it == image_map_ids.end()) {
                ASSERT_MSG(false, "Unregistering unregistered image in page=0x{:x}",
-                           page << PAGE_BITS);
+                           page << YUZU_PAGEBITS);
                return;
            }
            image_map_ids.erase(vector_it);
@@ -1532,7 +1532,7 @@ void TextureCache<P>::UnregisterImage(ImageId image_id) {
        ForEachCPUPage(cpu_addr, size, [this, image_id](u64 page) {
            const auto page_it = page_table.find(page);
            if (page_it == page_table.end()) {
-                ASSERT_MSG(false, "Unregistering unregistered page=0x{:x}", page << PAGE_BITS);
+                ASSERT_MSG(false, "Unregistering unregistered page=0x{:x}", page << YUZU_PAGEBITS);
                return;
            }
            std::vector<ImageMapId>& image_map_ids = page_it->second;
diff --git a/src/video_core/texture_cache/texture_cache_base.h b/src/video_core/texture_cache/texture_cache_base.h
index e2f8f84c9..7e6c6cef2 100644
--- a/src/video_core/texture_cache/texture_cache_base.h
+++ b/src/video_core/texture_cache/texture_cache_base.h
@@ -47,7 +47,7 @@ struct ImageViewInOut {
 template <class P>
 class TextureCache {
    /// Address shift for caching images into a hash table
-    static constexpr u64 PAGE_BITS = 20;
+    static constexpr u64 YUZU_PAGEBITS = 20;
    /// Enables debugging features to the texture cache
    static constexpr bool ENABLE_VALIDATION = P::ENABLE_VALIDATION;
@@ -178,8 +178,8 @@ private:
    template <typename Func>
    static void ForEachCPUPage(VAddr addr, size_t size, Func&& func) {
        static constexpr bool RETURNS_BOOL = std::is_same_v<std::invoke_result<Func, u64>, bool>;
-        const u64 page_end = (addr + size - 1) >> PAGE_BITS;
+        const u64 page_end = (addr + size - 1) >> YUZU_PAGEBITS;
-        for (u64 page = addr >> PAGE_BITS; page <= page_end; ++page) {
+        for (u64 page = addr >> YUZU_PAGEBITS; page <= page_end; ++page) {
            if constexpr (RETURNS_BOOL) {
                if (func(page)) {
                    break;
@@ -193,8 +193,8 @@ private:
    template <typename Func>
    static void ForEachGPUPage(GPUVAddr addr, size_t size, Func&& func) {
        static constexpr bool RETURNS_BOOL = std::is_same_v<std::invoke_result<Func, u64>, bool>;
-        const u64 page_end = (addr + size - 1) >> PAGE_BITS;
+        const u64 page_end = (addr + size - 1) >> YUZU_PAGEBITS;
-        for (u64 page = addr >> PAGE_BITS; page <= page_end; ++page) {
+        for (u64 page = addr >> YUZU_PAGEBITS; page <= page_end; ++page) {
            if constexpr (RETURNS_BOOL) {
                if (func(page)) {
                    break;
diff --git a/src/yuzu/bootmanager.cpp b/src/yuzu/bootmanager.cpp
index c262d0a2b..d3fbdb09d 100644
--- a/src/yuzu/bootmanager.cpp
+++ b/src/yuzu/bootmanager.cpp
@@ -815,6 +815,12 @@ void GRenderWindow::InitializeCamera() {
        if (Settings::values.ir_sensor_device.GetValue() == cameraInfo.deviceName().toStdString() ||
            Settings::values.ir_sensor_device.GetValue() == "Auto") {
            camera = std::make_unique<QCamera>(cameraInfo);
+            if (!camera->isCaptureModeSupported(QCamera::CaptureMode::CaptureViewfinder) &&
+                !camera->isCaptureModeSupported(QCamera::CaptureMode::CaptureStillImage)) {
+                LOG_ERROR(Frontend,
+                          "Camera doesn't support CaptureViewfinder or CaptureStillImage");
+                continue;
+            }
            camera_found = true;
            break;
        }
@@ -825,10 +831,22 @@ void GRenderWindow::InitializeCamera() {
    }
    camera_capture = std::make_unique<QCameraImageCapture>(camera.get());
+    if (!camera_capture->isCaptureDestinationSupported(
+            QCameraImageCapture::CaptureDestination::CaptureToBuffer)) {
+        LOG_ERROR(Frontend, "Camera doesn't support saving to buffer");
+        return;
+    }
+    camera_capture->setCaptureDestination(QCameraImageCapture::CaptureDestination::CaptureToBuffer);
    connect(camera_capture.get(), &QCameraImageCapture::imageCaptured, this,
            &GRenderWindow::OnCameraCapture);
    camera->unload();
-    camera->setCaptureMode(QCamera::CaptureViewfinder);
+    if (camera->isCaptureModeSupported(QCamera::CaptureMode::CaptureViewfinder)) {
+        camera->setCaptureMode(QCamera::CaptureViewfinder);
+    } else if (camera->isCaptureModeSupported(QCamera::CaptureMode::CaptureStillImage)) {
+        camera->setCaptureMode(QCamera::CaptureStillImage);
+    }
    camera->load();
    camera->start();
diff --git a/src/yuzu/configuration/configure_camera.cpp b/src/yuzu/configuration/configure_camera.cpp
index 73cdcf3f2..2a61de2a1 100644
--- a/src/yuzu/configuration/configure_camera.cpp
+++ b/src/yuzu/configuration/configure_camera.cpp
@@ -42,6 +42,12 @@ void ConfigureCamera::PreviewCamera() {
            LOG_INFO(Frontend, "Selected Camera {} {}", cameraInfo.description().toStdString(),
                     cameraInfo.deviceName().toStdString());
            camera = std::make_unique<QCamera>(cameraInfo);
+            if (!camera->isCaptureModeSupported(QCamera::CaptureMode::CaptureViewfinder) &&
+                !camera->isCaptureModeSupported(QCamera::CaptureMode::CaptureStillImage)) {
+                LOG_ERROR(Frontend,
+                          "Camera doesn't support CaptureViewfinder or CaptureStillImage");
+                continue;
+            }
            camera_found = true;
            break;
        }
@@ -57,10 +63,22 @@ void ConfigureCamera::PreviewCamera() {
    }
    camera_capture = std::make_unique<QCameraImageCapture>(camera.get());
+    if (!camera_capture->isCaptureDestinationSupported(
+            QCameraImageCapture::CaptureDestination::CaptureToBuffer)) {
+        LOG_ERROR(Frontend, "Camera doesn't support saving to buffer");
+        return;
+    }
+    camera_capture->setCaptureDestination(QCameraImageCapture::CaptureDestination::CaptureToBuffer);
    connect(camera_capture.get(), &QCameraImageCapture::imageCaptured, this,
            &ConfigureCamera::DisplayCapturedFrame);
    camera->unload();
-    camera->setCaptureMode(QCamera::CaptureViewfinder);
+    if (camera->isCaptureModeSupported(QCamera::CaptureMode::CaptureViewfinder)) {
+        camera->setCaptureMode(QCamera::CaptureViewfinder);
+    } else if (camera->isCaptureModeSupported(QCamera::CaptureMode::CaptureStillImage)) {
+        camera->setCaptureMode(QCamera::CaptureStillImage);
+    }
    camera->load();
    camera->start();
diff --git a/src/yuzu/configuration/configure_input_player.cpp b/src/yuzu/configuration/configure_input_player.cpp
index 00bee85b2..109689c88 100644
--- a/src/yuzu/configuration/configure_input_player.cpp
+++ b/src/yuzu/configuration/configure_input_player.cpp
@@ -1475,7 +1475,7 @@ void ConfigureInputPlayer::keyPressEvent(QKeyEvent* event) {
 void ConfigureInputPlayer::CreateProfile() {
    const auto profile_name =
-        LimitableInputDialog::GetText(this, tr("New Profile"), tr("Enter a profile name:"), 1, 20,
+        LimitableInputDialog::GetText(this, tr("New Profile"), tr("Enter a profile name:"), 1, 30,
                                      LimitableInputDialog::InputLimiter::Filesystem);
    if (profile_name.isEmpty()) {
diff --git a/src/yuzu/game_list.cpp b/src/yuzu/game_list.cpp
index c4b1f65bd..b127badc2 100644
--- a/src/yuzu/game_list.cpp
+++ b/src/yuzu/game_list.cpp
@@ -126,10 +126,8 @@ GameListSearchField::GameListSearchField(GameList* parent) : QWidget{parent} {
    layout_filter = new QHBoxLayout;
    layout_filter->setContentsMargins(8, 8, 8, 8);
    label_filter = new QLabel;
-    label_filter->setText(tr("Filter:"));
    edit_filter = new QLineEdit;
    edit_filter->clear();
-    edit_filter->setPlaceholderText(tr("Enter pattern to filter"));
    edit_filter->installEventFilter(key_release_eater);
    edit_filter->setClearButtonEnabled(true);
    connect(edit_filter, &QLineEdit::textChanged, parent, &GameList::OnTextChanged);
@@ -149,6 +147,7 @@ GameListSearchField::GameListSearchField(GameList* parent) : QWidget{parent} {
    layout_filter->addWidget(label_filter_result);
    layout_filter->addWidget(button_filter_close);
    setLayout(layout_filter);
+    RetranslateUI();
 }
 /**
@@ -333,13 +332,9 @@ GameList::GameList(FileSys::VirtualFilesystem vfs_, FileSys::ManualContentProvid
    tree_view->setStyleSheet(QStringLiteral("QTreeView{ border: none; }"));
    item_model->insertColumns(0, COLUMN_COUNT);
-    item_model->setHeaderData(COLUMN_NAME, Qt::Horizontal, tr("Name"));
+    RetranslateUI();
-    item_model->setHeaderData(COLUMN_COMPATIBILITY, Qt::Horizontal, tr("Compatibility"));
-    item_model->setHeaderData(COLUMN_ADD_ONS, Qt::Horizontal, tr("Add-ons"));
    tree_view->setColumnHidden(COLUMN_ADD_ONS, !UISettings::values.show_add_ons);
-    item_model->setHeaderData(COLUMN_FILE_TYPE, Qt::Horizontal, tr("File type"));
-    item_model->setHeaderData(COLUMN_SIZE, Qt::Horizontal, tr("Size"));
    item_model->setSortRole(GameListItemPath::SortRole);
    connect(main_window, &GMainWindow::UpdateThemedIcons, this, &GameList::OnUpdateThemedIcons);
@@ -753,6 +748,35 @@ void GameList::LoadCompatibilityList() {
    }
 }
+void GameList::changeEvent(QEvent* event) {
+    if (event->type() == QEvent::LanguageChange) {
+        RetranslateUI();
+    }
+    QWidget::changeEvent(event);
+}
+void GameList::RetranslateUI() {
+    item_model->setHeaderData(COLUMN_NAME, Qt::Horizontal, tr("Name"));
+    item_model->setHeaderData(COLUMN_COMPATIBILITY, Qt::Horizontal, tr("Compatibility"));
+    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"));
+}
+void GameListSearchField::changeEvent(QEvent* event) {
+    if (event->type() == QEvent::LanguageChange) {
+        RetranslateUI();
+    }
+    QWidget::changeEvent(event);
+}
+void GameListSearchField::RetranslateUI() {
+    label_filter->setText(tr("Filter:"));
+    edit_filter->setPlaceholderText(tr("Enter pattern to filter"));
+}
 QStandardItemModel* GameList::GetModel() const {
    return item_model;
 }
diff --git a/src/yuzu/game_list.h b/src/yuzu/game_list.h
index f783283c9..cdf085019 100644
--- a/src/yuzu/game_list.h
+++ b/src/yuzu/game_list.h
@@ -140,6 +140,9 @@ private:
    void AddPermDirPopup(QMenu& context_menu, QModelIndex selected);
    void AddFavoritesPopup(QMenu& context_menu);
+    void changeEvent(QEvent*) override;
+    void RetranslateUI();
    std::shared_ptr<FileSys::VfsFilesystem> vfs;
    FileSys::ManualContentProvider* provider;
    GameListSearchField* search_field;
diff --git a/src/yuzu/game_list_p.h b/src/yuzu/game_list_p.h
index 0e19be22d..6198d1e4e 100644
--- a/src/yuzu/game_list_p.h
+++ b/src/yuzu/game_list_p.h
@@ -353,6 +353,9 @@ public:
    void setFocus();
 private:
+    void changeEvent(QEvent*) override;
+    void RetranslateUI();
    class KeyReleaseEater : public QObject {
    public:
        explicit KeyReleaseEater(GameList* gamelist_, QObject* parent = nullptr);