Android #110

.reuse/dep5

@@ -147,7 +147,3 @@ License: GPL-3.0-or-later
 Files: src/android/gradle/wrapper/*
 Copyright: 2023 yuzu Emulator Project
 License: GPL-3.0-or-later
-
-Files: externals/stb/*
-Copyright: Sean Barrett
-License: MIT

CMakeLists.txt

@@ -294,7 +294,6 @@ find_package(lz4 REQUIRED)
 find_package(nlohmann_json 3.8 REQUIRED)
 find_package(Opus 1.3 MODULE)
 find_package(RenderDoc MODULE)
-find_package(stb MODULE)
 find_package(VulkanMemoryAllocator CONFIG)
 find_package(ZLIB 1.2 REQUIRED)
 find_package(zstd 1.5 REQUIRED)

CMakeModules/Findstb.cmake

@@ -1,31 +0,0 @@
-# SPDX-FileCopyrightText: 2023 Alexandre Bouvier <contact@amb.tf>
-#
-# SPDX-License-Identifier: GPL-3.0-or-later
-
-find_path(stb_image_INCLUDE_DIR stb_image.h PATH_SUFFIXES stb)
-find_path(stb_image_resize_INCLUDE_DIR stb_image_resize.h PATH_SUFFIXES stb)
-find_path(stb_image_write_INCLUDE_DIR stb_image_write.h PATH_SUFFIXES stb)
-
-include(FindPackageHandleStandardArgs)
-find_package_handle_standard_args(stb
-    REQUIRED_VARS
-        stb_image_INCLUDE_DIR
-        stb_image_resize_INCLUDE_DIR
-        stb_image_write_INCLUDE_DIR
-)
-
-if (stb_FOUND AND NOT TARGET stb::headers)
-    add_library(stb::headers INTERFACE IMPORTED)
-    set_property(TARGET stb::headers PROPERTY
-        INTERFACE_INCLUDE_DIRECTORIES
-            "${stb_image_INCLUDE_DIR}"
-            "${stb_image_resize_INCLUDE_DIR}"
-            "${stb_image_write_INCLUDE_DIR}"
-    )
-endif()
-
-mark_as_advanced(
-    stb_image_INCLUDE_DIR
-    stb_image_resize_INCLUDE_DIR
-    stb_image_write_INCLUDE_DIR
-)

externals/CMakeLists.txt

@@ -168,13 +168,9 @@ if (NOT TARGET LLVM::Demangle)
     add_library(LLVM::Demangle ALIAS demangle)
 endif()
 
-add_library(stb stb/stb_dxt.cpp)
+add_library(stb stb/stb_dxt.cpp stb/stb_image.cpp stb/stb_image_resize.cpp)
 target_include_directories(stb PUBLIC ./stb)
 
-if (NOT TARGET stb::headers)
-    add_library(stb::headers ALIAS stb)
-endif()
-
 add_library(bc_decoder bc_decoder/bc_decoder.cpp)
 target_include_directories(bc_decoder PUBLIC ./bc_decoder)
 

src/common/CMakeLists.txt

@@ -120,8 +120,6 @@ add_library(common STATIC
     socket_types.h
     spin_lock.cpp
     spin_lock.h
-    stb.cpp
-    stb.h
     steady_clock.cpp
     steady_clock.h
     stream.cpp
@@ -210,8 +208,6 @@ if (MSVC)
     /we4254 # 'operator': conversion from 'type1:field_bits' to 'type2:field_bits', possible loss of data
     /we4800 # Implicit conversion from 'type' to bool. Possible information loss
   )
-else()
-  set_source_files_properties(stb.cpp PROPERTIES COMPILE_OPTIONS "-Wno-implicit-fallthrough;-Wno-missing-declarations;-Wno-missing-field-initializers")
 endif()
 
 if (CMAKE_CXX_COMPILER_ID STREQUAL "Clang")
@@ -227,7 +223,7 @@ endif()
 
 create_target_directory_groups(common)
 
-target_link_libraries(common PUBLIC Boost::context Boost::headers fmt::fmt microprofile stb::headers Threads::Threads)
+target_link_libraries(common PUBLIC Boost::context Boost::headers fmt::fmt microprofile Threads::Threads)
 target_link_libraries(common PRIVATE lz4::lz4 zstd::zstd LLVM::Demangle)
 
 if (ANDROID)

src/common/stb.cpp

@@ -1,8 +0,0 @@
-// SPDX-FileCopyrightText: Copyright 2023 yuzu Emulator Project
-// SPDX-License-Identifier: GPL-2.0-or-later
-
-#define STB_IMAGE_IMPLEMENTATION
-#define STB_IMAGE_RESIZE_IMPLEMENTATION
-#define STB_IMAGE_WRITE_IMPLEMENTATION
-
-#include "common/stb.h"

src/common/stb.h

@@ -1,8 +0,0 @@
-// SPDX-FileCopyrightText: Copyright 2023 yuzu Emulator Project
-// SPDX-License-Identifier: GPL-2.0-or-later
-
-#pragma once
-
-#include <stb_image.h>
-#include <stb_image_resize.h>
-#include <stb_image_write.h>

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

@@ -25,12 +25,11 @@ void LoopProcess(Core::System& system) {
     server_manager->RegisterNamedService(
         "caps:u", std::make_shared<IAlbumApplicationService>(system, album_manager));
 
-    server_manager->RegisterNamedService(
-        "caps:ss", std::make_shared<IScreenShotService>(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, album_manager));
+    server_manager->RegisterNamedService("caps:su",
+                                         std::make_shared<IScreenShotApplicationService>(system));
 
     ServerManager::RunServer(std::move(server_manager));
 }

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

@@ -2,11 +2,12 @@
 // 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 "common/stb.h"
 #include "core/core.h"
 #include "core/hle/service/caps/caps_manager.h"
 #include "core/hle/service/caps/caps_result.h"
@@ -226,49 +227,6 @@ Result AlbumManager::LoadAlbumScreenShotThumbnail(
                      +static_cast<int>(out_image_output.height), decoder_options.flags);
 }
 
-Result AlbumManager::SaveScreenShot(ApplicationAlbumEntry& out_entry,
-                                    const ScreenShotAttribute& attribute,
-                                    std::span<const u8> image_data, u64 aruid) {
-    return SaveScreenShot(out_entry, attribute, {}, image_data, aruid);
-}
-
-Result AlbumManager::SaveScreenShot(ApplicationAlbumEntry& out_entry,
-                                    const ScreenShotAttribute& attribute,
-                                    const ApplicationData& app_data, std::span<const u8> image_data,
-                                    u64 aruid) {
-    const u64 title_id = system.GetApplicationProcessProgramID();
-    const auto& user_clock = system.GetTimeManager().GetStandardUserSystemClockCore();
-
-    s64 posix_time{};
-    Result result = user_clock.GetCurrentTime(system, posix_time);
-
-    if (result.IsError()) {
-        return result;
-    }
-
-    const auto date = ConvertToAlbumDateTime(posix_time);
-
-    return SaveImage(out_entry, image_data, title_id, date);
-}
-
-Result AlbumManager::SaveEditedScreenShot(ApplicationAlbumEntry& out_entry,
-                                          const ScreenShotAttribute& attribute,
-                                          const AlbumFileId& file_id,
-                                          std::span<const u8> image_data) {
-    const auto& user_clock = system.GetTimeManager().GetStandardUserSystemClockCore();
-
-    s64 posix_time{};
-    Result result = user_clock.GetCurrentTime(system, posix_time);
-
-    if (result.IsError()) {
-        return result;
-    }
-
-    const auto date = ConvertToAlbumDateTime(posix_time);
-
-    return SaveImage(out_entry, image_data, file_id.application_id, date);
-}
-
 Result AlbumManager::GetFile(std::filesystem::path& out_path, const AlbumFileId& file_id) const {
     const auto file = album_files.find(file_id);
 
@@ -407,47 +365,6 @@ Result AlbumManager::LoadImage(std::span<u8> out_image, const std::filesystem::p
     return ResultSuccess;
 }
 
-static void PNGToMemory(void* context, void* png, int len) {
-    std::vector<u8>* png_image = static_cast<std::vector<u8>*>(context);
-    png_image->reserve(len);
-    std::memcpy(png_image->data(), png, len);
-}
-
-Result AlbumManager::SaveImage(ApplicationAlbumEntry& out_entry, std::span<const u8> image,
-                               u64 title_id, const AlbumFileDateTime& date) const {
-    const auto screenshot_path =
-        Common::FS::GetYuzuPathString(Common::FS::YuzuPath::ScreenshotsDir);
-    const std::string formatted_date =
-        fmt::format("{:04}-{:02}-{:02}_{:02}-{:02}-{:02}-{:03}", date.year, date.month, date.day,
-                    date.hour, date.minute, date.second, 0);
-    const std::string file_path =
-        fmt::format("{}/{:016x}_{}.png", screenshot_path, title_id, formatted_date);
-
-    const Common::FS::IOFile db_file{file_path, Common::FS::FileAccessMode::Write,
-                                     Common::FS::FileType::BinaryFile};
-
-    std::vector<u8> png_image;
-    if (!stbi_write_png_to_func(PNGToMemory, &png_image, 1280, 720, STBI_rgb_alpha, image.data(),
-                                0)) {
-        return ResultFileCountLimit;
-    }
-
-    if (db_file.Write(png_image) != png_image.size()) {
-        return ResultFileCountLimit;
-    }
-
-    out_entry = {
-        .size = png_image.size(),
-        .hash = {},
-        .datetime = date,
-        .storage = AlbumStorage::Sd,
-        .content = ContentType::Screenshot,
-        .unknown = 1,
-    };
-
-    return ResultSuccess;
-}
-
 AlbumFileDateTime AlbumManager::ConvertToAlbumDateTime(u64 posix_time) const {
     Time::TimeZone::CalendarInfo calendar_date{};
     const auto& time_zone_manager =

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

@@ -58,15 +58,6 @@ public:
                                         std::vector<u8>& out_image, const AlbumFileId& file_id,
                                         const ScreenShotDecodeOption& decoder_options) const;
 
-    Result SaveScreenShot(ApplicationAlbumEntry& out_entry, const ScreenShotAttribute& attribute,
-                          std::span<const u8> image_data, u64 aruid);
-    Result SaveScreenShot(ApplicationAlbumEntry& out_entry, const ScreenShotAttribute& attribute,
-                          const ApplicationData& app_data, std::span<const u8> image_data,
-                          u64 aruid);
-    Result SaveEditedScreenShot(ApplicationAlbumEntry& out_entry,
-                                const ScreenShotAttribute& attribute, const AlbumFileId& file_id,
-                                std::span<const u8> image_data);
-
 private:
     static constexpr std::size_t NandAlbumFileLimit = 1000;
     static constexpr std::size_t SdAlbumFileLimit = 10000;
@@ -76,8 +67,6 @@ private:
     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;
-    Result SaveImage(ApplicationAlbumEntry& out_entry, std::span<const u8> image, u64 title_id,
-                     const AlbumFileDateTime& date) const;
 
     AlbumFileDateTime ConvertToAlbumDateTime(u64 posix_time) const;
 

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

@@ -1,25 +1,19 @@
 // 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_manager.h"
-#include "core/hle/service/caps/caps_types.h"
-#include "core/hle/service/ipc_helpers.h"
-
 #include "core/hle/service/caps/caps_ss.h"
 
 namespace Service::Capture {
 
-IScreenShotService::IScreenShotService(Core::System& system_,
-                                       std::shared_ptr<AlbumManager> album_manager)
-    : ServiceFramework{system_, "caps:ss"}, manager{album_manager} {
+IScreenShotService::IScreenShotService(Core::System& system_)
+    : ServiceFramework{system_, "caps:ss"} {
     // clang-format off
     static const FunctionInfo functions[] = {
         {201, nullptr, "SaveScreenShot"},
         {202, nullptr, "SaveEditedScreenShot"},
-        {203, &IScreenShotService::SaveScreenShotEx0, "SaveScreenShotEx0"},
+        {203, nullptr, "SaveScreenShotEx0"},
         {204, nullptr, "SaveEditedScreenShotEx0"},
-        {206, &IScreenShotService::SaveEditedScreenShotEx1, "SaveEditedScreenShotEx1"},
+        {206, nullptr, "Unknown206"},
         {208, nullptr, "SaveScreenShotOfMovieEx1"},
         {1000, nullptr, "Unknown1000"},
     };
@@ -30,65 +24,4 @@ IScreenShotService::IScreenShotService(Core::System& system_,
 
 IScreenShotService::~IScreenShotService() = default;
 
-void IScreenShotService::SaveScreenShotEx0(HLERequestContext& ctx) {
-    IPC::RequestParser rp{ctx};
-    struct Parameters {
-        ScreenShotAttribute attribute{};
-        u32 report_option{};
-        INSERT_PADDING_BYTES(0x4);
-        u64 applet_resource_user_id{};
-    };
-    static_assert(sizeof(Parameters) == 0x50, "Parameters has incorrect size.");
-
-    const auto parameters{rp.PopRaw<Parameters>()};
-    const auto image_data_buffer = ctx.ReadBuffer();
-
-    LOG_INFO(Service_Capture,
-             "called, report_option={}, image_data_buffer_size={}, applet_resource_user_id={}",
-             parameters.report_option, image_data_buffer.size(),
-             parameters.applet_resource_user_id);
-
-    ApplicationAlbumEntry entry{};
-    const auto result = manager->SaveScreenShot(entry, parameters.attribute, image_data_buffer,
-                                                parameters.applet_resource_user_id);
-
-    IPC::ResponseBuilder rb{ctx, 10};
-    rb.Push(result);
-    rb.PushRaw(entry);
-}
-void IScreenShotService::SaveEditedScreenShotEx1(HLERequestContext& ctx) {
-    IPC::RequestParser rp{ctx};
-    struct Parameters {
-        ScreenShotAttribute attribute;
-        u64 width;
-        u64 height;
-        u64 thumbnail_width;
-        u64 thumbnail_height;
-        AlbumFileId file_id;
-    };
-    static_assert(sizeof(Parameters) == 0x78, "Parameters has incorrect size.");
-
-    const auto parameters{rp.PopRaw<Parameters>()};
-    const auto application_data_buffer = ctx.ReadBuffer(0);
-    const auto image_data_buffer = ctx.ReadBuffer(1);
-    const auto thumbnail_image_data_buffer = ctx.ReadBuffer(2);
-
-    LOG_INFO(Service_Capture,
-             "called, width={}, height={}, thumbnail_width={}, thumbnail_height={}, "
-             "application_id={:016x},  storage={},  type={}, app_data_buffer_size={}, "
-             "image_data_buffer_size={}, thumbnail_image_buffer_size={}",
-             parameters.width, parameters.height, parameters.thumbnail_width,
-             parameters.thumbnail_height, parameters.file_id.application_id,
-             parameters.file_id.storage, parameters.file_id.type, application_data_buffer.size(),
-             image_data_buffer.size(), thumbnail_image_data_buffer.size());
-
-    ApplicationAlbumEntry entry{};
-    const auto result = manager->SaveEditedScreenShot(entry, parameters.attribute,
-                                                      parameters.file_id, image_data_buffer);
-
-    IPC::ResponseBuilder rb{ctx, 10};
-    rb.Push(result);
-    rb.PushRaw(entry);
-}
-
 } // namespace Service::Capture

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

@@ -13,14 +13,8 @@ namespace Service::Capture {
 
 class IScreenShotService final : public ServiceFramework<IScreenShotService> {
 public:
-    explicit IScreenShotService(Core::System& system_, std::shared_ptr<AlbumManager> album_manager);
+    explicit IScreenShotService(Core::System& system_);
     ~IScreenShotService() override;
-
-private:
-    void SaveScreenShotEx0(HLERequestContext& ctx);
-    void SaveEditedScreenShotEx1(HLERequestContext& ctx);
-
-    std::shared_ptr<AlbumManager> manager;
 };
 
 } // namespace Service::Capture

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

@@ -2,22 +2,19 @@
 // SPDX-License-Identifier: GPL-2.0-or-later
 
 #include "common/logging/log.h"
-#include "core/hle/service/caps/caps_manager.h"
 #include "core/hle/service/caps/caps_su.h"
-#include "core/hle/service/caps/caps_types.h"
 #include "core/hle/service/ipc_helpers.h"
 
 namespace Service::Capture {
 
-IScreenShotApplicationService::IScreenShotApplicationService(
-    Core::System& system_, std::shared_ptr<AlbumManager> album_manager)
-    : ServiceFramework{system_, "caps:su"}, manager{album_manager} {
+IScreenShotApplicationService::IScreenShotApplicationService(Core::System& system_)
+    : ServiceFramework{system_, "caps:su"} {
     // clang-format off
     static const FunctionInfo functions[] = {
         {32, &IScreenShotApplicationService::SetShimLibraryVersion, "SetShimLibraryVersion"},
         {201, nullptr, "SaveScreenShot"},
-        {203, &IScreenShotApplicationService::SaveScreenShotEx0, "SaveScreenShotEx0"},
-        {205, &IScreenShotApplicationService::SaveScreenShotEx1, "SaveScreenShotEx1"},
+        {203, nullptr, "SaveScreenShotEx0"},
+        {205, nullptr, "SaveScreenShotEx1"},
         {210, nullptr, "SaveScreenShotEx2"},
     };
     // clang-format on
@@ -39,62 +36,4 @@ void IScreenShotApplicationService::SetShimLibraryVersion(HLERequestContext& ctx
     rb.Push(ResultSuccess);
 }
 
-void IScreenShotApplicationService::SaveScreenShotEx0(HLERequestContext& ctx) {
-    IPC::RequestParser rp{ctx};
-    struct Parameters {
-        ScreenShotAttribute attribute{};
-        AlbumReportOption report_option{};
-        INSERT_PADDING_BYTES(0x4);
-        u64 applet_resource_user_id{};
-    };
-    static_assert(sizeof(Parameters) == 0x50, "Parameters has incorrect size.");
-
-    const auto parameters{rp.PopRaw<Parameters>()};
-    const auto image_data_buffer = ctx.ReadBuffer();
-
-    LOG_INFO(Service_Capture,
-             "called, report_option={}, image_data_buffer_size={}, applet_resource_user_id={}",
-             parameters.report_option, image_data_buffer.size(),
-             parameters.applet_resource_user_id);
-
-    ApplicationAlbumEntry entry{};
-    const auto result = manager->SaveScreenShot(entry, parameters.attribute, image_data_buffer,
-                                                parameters.applet_resource_user_id);
-
-    IPC::ResponseBuilder rb{ctx, 10};
-    rb.Push(result);
-    rb.PushRaw(entry);
-}
-
-void IScreenShotApplicationService::SaveScreenShotEx1(HLERequestContext& ctx) {
-    IPC::RequestParser rp{ctx};
-    struct Parameters {
-        ScreenShotAttribute attribute{};
-        AlbumReportOption report_option{};
-        INSERT_PADDING_BYTES(0x4);
-        u64 applet_resource_user_id{};
-    };
-    static_assert(sizeof(Parameters) == 0x50, "Parameters has incorrect size.");
-
-    const auto parameters{rp.PopRaw<Parameters>()};
-    const auto app_data_buffer = ctx.ReadBuffer(0);
-    const auto image_data_buffer = ctx.ReadBuffer(1);
-
-    LOG_INFO(Service_Capture,
-             "called, report_option={}, image_data_buffer_size={}, applet_resource_user_id={}",
-             parameters.report_option, image_data_buffer.size(),
-             parameters.applet_resource_user_id);
-
-    ApplicationAlbumEntry entry{};
-    ApplicationData app_data{};
-    std::memcpy(&app_data, app_data_buffer.data(), sizeof(ApplicationData));
-    const auto result =
-        manager->SaveScreenShot(entry, parameters.attribute, app_data, image_data_buffer,
-                                parameters.applet_resource_user_id);
-
-    IPC::ResponseBuilder rb{ctx, 10};
-    rb.Push(result);
-    rb.PushRaw(entry);
-}
-
 } // namespace Service::Capture

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

@@ -10,20 +10,14 @@ class System;
 }
 
 namespace Service::Capture {
-class AlbumManager;
 
 class IScreenShotApplicationService final : public ServiceFramework<IScreenShotApplicationService> {
 public:
-    explicit IScreenShotApplicationService(Core::System& system_,
-                                           std::shared_ptr<AlbumManager> album_manager);
+    explicit IScreenShotApplicationService(Core::System& system_);
     ~IScreenShotApplicationService() override;
 
 private:
     void SetShimLibraryVersion(HLERequestContext& ctx);
-    void SaveScreenShotEx0(HLERequestContext& ctx);
-    void SaveScreenShotEx1(HLERequestContext& ctx);
-
-    std::shared_ptr<AlbumManager> manager;
 };
 
 } // namespace Service::Capture

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

@@ -20,8 +20,6 @@ enum class AlbumImageOrientation {
 enum class AlbumReportOption : s32 {
     Disable,
     Enable,
-    Unknown2,
-    Unknown3,
 };
 
 enum class ContentType : u8 {

src/core/hle/service/hle_ipc.cpp

@@ -27,12 +27,10 @@ namespace {
 static thread_local std::array read_buffer_data_a{
     Common::ScratchBuffer<u8>(),
     Common::ScratchBuffer<u8>(),
-    Common::ScratchBuffer<u8>(),
 };
 static thread_local std::array read_buffer_data_x{
     Common::ScratchBuffer<u8>(),
     Common::ScratchBuffer<u8>(),
-    Common::ScratchBuffer<u8>(),
 };
 } // Anonymous namespace
 
@@ -345,7 +343,6 @@ std::span<const u8> HLERequestContext::ReadBufferA(std::size_t buffer_index) con
     static thread_local std::array read_buffer_a{
         Core::Memory::CpuGuestMemory<u8, Core::Memory::GuestMemoryFlags::SafeRead>(memory, 0, 0),
         Core::Memory::CpuGuestMemory<u8, Core::Memory::GuestMemoryFlags::SafeRead>(memory, 0, 0),
-        Core::Memory::CpuGuestMemory<u8, Core::Memory::GuestMemoryFlags::SafeRead>(memory, 0, 0),
     };
 
     ASSERT_OR_EXECUTE_MSG(
@@ -361,7 +358,6 @@ std::span<const u8> HLERequestContext::ReadBufferX(std::size_t buffer_index) con
     static thread_local std::array read_buffer_x{
         Core::Memory::CpuGuestMemory<u8, Core::Memory::GuestMemoryFlags::SafeRead>(memory, 0, 0),
         Core::Memory::CpuGuestMemory<u8, Core::Memory::GuestMemoryFlags::SafeRead>(memory, 0, 0),
-        Core::Memory::CpuGuestMemory<u8, Core::Memory::GuestMemoryFlags::SafeRead>(memory, 0, 0),
     };
 
     ASSERT_OR_EXECUTE_MSG(
@@ -377,12 +373,10 @@ std::span<const u8> HLERequestContext::ReadBuffer(std::size_t buffer_index) cons
     static thread_local std::array read_buffer_a{
         Core::Memory::CpuGuestMemory<u8, Core::Memory::GuestMemoryFlags::SafeRead>(memory, 0, 0),
         Core::Memory::CpuGuestMemory<u8, Core::Memory::GuestMemoryFlags::SafeRead>(memory, 0, 0),
-        Core::Memory::CpuGuestMemory<u8, Core::Memory::GuestMemoryFlags::SafeRead>(memory, 0, 0),
     };
     static thread_local std::array read_buffer_x{
         Core::Memory::CpuGuestMemory<u8, Core::Memory::GuestMemoryFlags::SafeRead>(memory, 0, 0),
         Core::Memory::CpuGuestMemory<u8, Core::Memory::GuestMemoryFlags::SafeRead>(memory, 0, 0),
-        Core::Memory::CpuGuestMemory<u8, Core::Memory::GuestMemoryFlags::SafeRead>(memory, 0, 0),
     };
 
     const bool is_buffer_a{BufferDescriptorA().size() > buffer_index &&

src/core/memory/cheat_engine.cpp

@@ -19,23 +19,16 @@ namespace Core::Memory {
 namespace {
 constexpr auto CHEAT_ENGINE_NS = std::chrono::nanoseconds{1000000000 / 12};
 
-std::string_view ExtractName(std::size_t& out_name_size, std::string_view data,
-                             std::size_t start_index, char match) {
+std::string_view ExtractName(std::string_view data, std::size_t start_index, char match) {
     auto end_index = start_index;
     while (data[end_index] != match) {
         ++end_index;
-        if (end_index > data.size()) {
+        if (end_index > data.size() ||
+            (end_index - start_index - 1) > sizeof(CheatDefinition::readable_name)) {
             return {};
         }
     }
 
-    out_name_size = end_index - start_index;
-
-    // Clamp name if it's too big
-    if (out_name_size > sizeof(CheatDefinition::readable_name)) {
-        end_index = start_index + sizeof(CheatDefinition::readable_name);
-    }
-
     return data.substr(start_index, end_index - start_index);
 }
 } // Anonymous namespace
@@ -120,8 +113,7 @@ std::vector<CheatEntry> TextCheatParser::Parse(std::string_view data) const {
                 return {};
             }
 
-            std::size_t name_size{};
-            const auto name = ExtractName(name_size, data, i + 1, '}');
+            const auto name = ExtractName(data, i + 1, '}');
             if (name.empty()) {
                 return {};
             }
@@ -133,13 +125,12 @@ std::vector<CheatEntry> TextCheatParser::Parse(std::string_view data) const {
                 .definition.readable_name[out[*current_entry].definition.readable_name.size() - 1] =
                 '\0';
 
-            i += name_size + 1;
+            i += name.length() + 1;
         } else if (data[i] == '[') {
             current_entry = out.size();
             out.emplace_back();
 
-            std::size_t name_size{};
-            const auto name = ExtractName(name_size, data, i + 1, ']');
+            const auto name = ExtractName(data, i + 1, ']');
             if (name.empty()) {
                 return {};
             }
@@ -151,7 +142,7 @@ std::vector<CheatEntry> TextCheatParser::Parse(std::string_view data) const {
                 .definition.readable_name[out[*current_entry].definition.readable_name.size() - 1] =
                 '\0';
 
-            i += name_size + 1;
+            i += name.length() + 1;
         } else if (::isxdigit(data[i])) {
             if (!current_entry || out[*current_entry].definition.num_opcodes >=
                                       out[*current_entry].definition.opcodes.size()) {

src/shader_recompiler/backend/glsl/emit_glsl.cpp

@@ -242,7 +242,6 @@ std::string EmitGLSL(const Profile& profile, const RuntimeInfo& runtime_info, IR
     }
     if (program.info.uses_subgroup_shuffles) {
         ctx.header += "bool shfl_in_bounds;";
-        ctx.header += "uint shfl_result;";
     }
     ctx.code.insert(0, ctx.header);
     ctx.code += '}';

src/shader_recompiler/backend/glsl/emit_glsl_warp.cpp

@@ -141,8 +141,7 @@ void EmitShuffleIndex(EmitContext& ctx, IR::Inst& inst, std::string_view value,
     const auto src_thread_id{fmt::format("({})|({})", lhs, min_thread_id)};
     ctx.Add("shfl_in_bounds=int({})<=int({});", src_thread_id, max_thread_id);
     SetInBoundsFlag(ctx, inst);
-    ctx.Add("shfl_result=readInvocationARB({},{});", value, src_thread_id);
-    ctx.AddU32("{}=shfl_in_bounds?shfl_result:{};", inst, value);
+    ctx.AddU32("{}=shfl_in_bounds?readInvocationARB({},{}):{};", inst, value, src_thread_id, value);
 }
 
 void EmitShuffleUp(EmitContext& ctx, IR::Inst& inst, std::string_view value, std::string_view index,
@@ -159,8 +158,7 @@ void EmitShuffleUp(EmitContext& ctx, IR::Inst& inst, std::string_view value, std
     const auto src_thread_id{fmt::format("({}-{})", THREAD_ID, index)};
     ctx.Add("shfl_in_bounds=int({})>=int({});", src_thread_id, max_thread_id);
     SetInBoundsFlag(ctx, inst);
-    ctx.Add("shfl_result=readInvocationARB({},{});", value, src_thread_id);
-    ctx.AddU32("{}=shfl_in_bounds?shfl_result:{};", inst, value);
+    ctx.AddU32("{}=shfl_in_bounds?readInvocationARB({},{}):{};", inst, value, src_thread_id, value);
 }
 
 void EmitShuffleDown(EmitContext& ctx, IR::Inst& inst, std::string_view value,
@@ -177,8 +175,7 @@ void EmitShuffleDown(EmitContext& ctx, IR::Inst& inst, std::string_view value,
     const auto src_thread_id{fmt::format("({}+{})", THREAD_ID, index)};
     ctx.Add("shfl_in_bounds=int({})<=int({});", src_thread_id, max_thread_id);
     SetInBoundsFlag(ctx, inst);
-    ctx.Add("shfl_result=readInvocationARB({},{});", value, src_thread_id);
-    ctx.AddU32("{}=shfl_in_bounds?shfl_result:{};", inst, value);
+    ctx.AddU32("{}=shfl_in_bounds?readInvocationARB({},{}):{};", inst, value, src_thread_id, value);
 }
 
 void EmitShuffleButterfly(EmitContext& ctx, IR::Inst& inst, std::string_view value,
@@ -196,8 +193,7 @@ void EmitShuffleButterfly(EmitContext& ctx, IR::Inst& inst, std::string_view val
     const auto src_thread_id{fmt::format("({}^{})", THREAD_ID, index)};
     ctx.Add("shfl_in_bounds=int({})<=int({});", src_thread_id, max_thread_id);
     SetInBoundsFlag(ctx, inst);
-    ctx.Add("shfl_result=readInvocationARB({},{});", value, src_thread_id);
-    ctx.AddU32("{}=shfl_in_bounds?shfl_result:{};", inst, value);
+    ctx.AddU32("{}=shfl_in_bounds?readInvocationARB({},{}):{};", inst, value, src_thread_id, value);
 }
 
 void EmitFSwizzleAdd(EmitContext& ctx, IR::Inst& inst, std::string_view op_a, std::string_view op_b,

src/video_core/vulkan_common/vulkan_wrapper.cpp

@@ -522,7 +522,7 @@ Instance Instance::Create(u32 version, Span<const char*> layers, Span<const char
         .applicationVersion = VK_MAKE_VERSION(0, 1, 0),
         .pEngineName = "yuzu Emulator",
         .engineVersion = VK_MAKE_VERSION(0, 1, 0),
-        .apiVersion = VK_API_VERSION_1_3,
+        .apiVersion = version,
     };
     const VkInstanceCreateInfo ci{
         .sType = VK_STRUCTURE_TYPE_INSTANCE_CREATE_INFO,

src/yuzu/configuration/config.cpp

@@ -114,7 +114,7 @@ const std::map<Settings::ShaderBackend, QString> Config::shader_backend_texts_ma
 // This must be in alphabetical order according to action name as it must have the same order as
 // UISetting::values.shortcuts, which is alphabetically ordered.
 // clang-format off
-const std::array<UISettings::Shortcut, 23> Config::default_hotkeys{{
+const std::array<UISettings::Shortcut, 22> Config::default_hotkeys{{
     {QStringLiteral(QT_TRANSLATE_NOOP("Hotkeys", "Audio Mute/Unmute")),        QStringLiteral(QT_TRANSLATE_NOOP("Hotkeys", "Main Window")), {QStringLiteral("Ctrl+M"),  QStringLiteral("Home+Dpad_Right"), Qt::WindowShortcut, false}},
     {QStringLiteral(QT_TRANSLATE_NOOP("Hotkeys", "Audio Volume Down")),        QStringLiteral(QT_TRANSLATE_NOOP("Hotkeys", "Main Window")), {QStringLiteral("-"),       QStringLiteral("Home+Dpad_Down"), Qt::ApplicationShortcut, true}},
     {QStringLiteral(QT_TRANSLATE_NOOP("Hotkeys", "Audio Volume Up")),          QStringLiteral(QT_TRANSLATE_NOOP("Hotkeys", "Main Window")), {QStringLiteral("="),       QStringLiteral("Home+Dpad_Up"), Qt::ApplicationShortcut, true}},
@@ -136,7 +136,6 @@ const std::array<UISettings::Shortcut, 23> Config::default_hotkeys{{
     {QStringLiteral(QT_TRANSLATE_NOOP("Hotkeys", "Toggle Filter Bar")),        QStringLiteral(QT_TRANSLATE_NOOP("Hotkeys", "Main Window")), {QStringLiteral("Ctrl+F"),  QStringLiteral(""), Qt::WindowShortcut, false}},
     {QStringLiteral(QT_TRANSLATE_NOOP("Hotkeys", "Toggle Framerate Limit")),   QStringLiteral(QT_TRANSLATE_NOOP("Hotkeys", "Main Window")), {QStringLiteral("Ctrl+U"),  QStringLiteral("Home+Y"), Qt::ApplicationShortcut, false}},
     {QStringLiteral(QT_TRANSLATE_NOOP("Hotkeys", "Toggle Mouse Panning")),     QStringLiteral(QT_TRANSLATE_NOOP("Hotkeys", "Main Window")), {QStringLiteral("Ctrl+F9"), QStringLiteral(""), Qt::ApplicationShortcut, false}},
-    {QStringLiteral(QT_TRANSLATE_NOOP("Hotkeys", "Toggle Renderdoc Capture")), QStringLiteral(QT_TRANSLATE_NOOP("Hotkeys", "Main Window")), {QStringLiteral(""),        QStringLiteral(""), Qt::ApplicationShortcut, false}},
     {QStringLiteral(QT_TRANSLATE_NOOP("Hotkeys", "Toggle Status Bar")),        QStringLiteral(QT_TRANSLATE_NOOP("Hotkeys", "Main Window")), {QStringLiteral("Ctrl+S"),  QStringLiteral(""), Qt::WindowShortcut, false}},
 }};
 // clang-format on

src/yuzu/configuration/config.h

@@ -48,7 +48,7 @@ public:
         default_mouse_buttons;
     static const std::array<int, Settings::NativeKeyboard::NumKeyboardKeys> default_keyboard_keys;
     static const std::array<int, Settings::NativeKeyboard::NumKeyboardMods> default_keyboard_mods;
-    static const std::array<UISettings::Shortcut, 23> default_hotkeys;
+    static const std::array<UISettings::Shortcut, 22> default_hotkeys;
 
     static const std::map<Settings::AntiAliasing, QString> anti_aliasing_texts_map;
     static const std::map<Settings::ScalingFilter, QString> scaling_filter_texts_map;

src/yuzu/configuration/configure_hotkeys.cpp

@@ -319,13 +319,6 @@ void ConfigureHotkeys::ApplyConfiguration(HotkeyRegistry& registry) {
 void ConfigureHotkeys::RestoreDefaults() {
     for (int r = 0; r < model->rowCount(); ++r) {
         const QStandardItem* parent = model->item(r, 0);
-        const int hotkey_size = static_cast<int>(Config::default_hotkeys.size());
-
-        if (hotkey_size != parent->rowCount()) {
-            QMessageBox::warning(this, tr("Invalid hotkey settings"),
-                                 tr("An error occurred. Please report this issue on github."));
-            return;
-        }
 
         for (int r2 = 0; r2 < parent->rowCount(); ++r2) {
             model->item(r, 0)

src/yuzu/configuration/configure_vibration.cpp

@@ -89,7 +89,7 @@ void ConfigureVibration::VibrateController(Core::HID::ControllerTriggerType type
 
     auto& player = Settings::values.players.GetValue()[player_index];
     auto controller = hid_core.GetEmulatedControllerByIndex(player_index);
-    const int vibration_strength = vibration_spinboxes[player_index]->value();
+    const int vibration_strenght = vibration_spinboxes[player_index]->value();
     const auto& buttons = controller->GetButtonsValues();
 
     bool button_is_pressed = false;
@@ -105,10 +105,10 @@ void ConfigureVibration::VibrateController(Core::HID::ControllerTriggerType type
         return;
     }
 
-    const bool old_vibration_enabled = player.vibration_enabled;
-    const int old_vibration_strength = player.vibration_strength;
+    const int old_vibration_enabled = player.vibration_enabled;
+    const bool old_vibration_strenght = player.vibration_strength;
     player.vibration_enabled = true;
-    player.vibration_strength = vibration_strength;
+    player.vibration_strength = vibration_strenght;
 
     const Core::HID::VibrationValue vibration{
         .low_amplitude = 1.0f,
@@ -121,7 +121,7 @@ void ConfigureVibration::VibrateController(Core::HID::ControllerTriggerType type
 
     // Restore previous values
     player.vibration_enabled = old_vibration_enabled;
-    player.vibration_strength = old_vibration_strength;
+    player.vibration_strength = old_vibration_strenght;
 }
 
 void ConfigureVibration::StopVibrations() {