[dynarmic] backport WAITPKG based spinlocks

Signed-off-by: lizzie <lizzie@eden-emu.dev>

CMakeLists.txt

@@ -224,7 +224,7 @@ set(YUZU_TZDB_PATH "" CACHE STRING "Path to a pre-downloaded timezone database")
 
 cmake_dependent_option(YUZU_USE_FASTER_LD "Check if a faster linker is available" ON "LINUX" OFF)
 
-cmake_dependent_option(YUZU_APPLE_USE_BUNDLED_MONTENVK "Download bundled MoltenVK lib" ON "APPLE" OFF)
+cmake_dependent_option(YUZU_USE_BUNDLED_MOLTENVK "Download bundled MoltenVK lib" ON "APPLE" OFF)
 
 option(YUZU_DISABLE_LLVM "Disable LLVM (useful for CI)" OFF)
 

docs/Options.md

@@ -31,7 +31,7 @@ Notes:
   * Currently, build fails without this
 - `YUZU_USE_FASTER_LD` (ON) Check if a faster linker is available
   * Only available on UNIX
-- `YUZU_APPLE_USE_BUNDLED_MONTENVK` (ON, macOS only) Download bundled MoltenVK lib)
+- `YUZU_USE_BUNDLED_MOLTENVK` (ON, macOS only) Download bundled MoltenVK lib)
 - `YUZU_TZDB_PATH` (string) Path to a pre-downloaded timezone database (useful for nixOS)
 - `ENABLE_OPENSSL` (ON for Linux and *BSD) Enable OpenSSL backend for the ssl service
   * Always enabled if the web service is enabled

src/audio_core/renderer/behavior/info_updater.cpp

@@ -165,12 +165,6 @@ Result InfoUpdater::UpdateEffectsVersion1(EffectContext& effect_context, const b
         reinterpret_cast<EffectInfoBase::OutStatusVersion1*>(output), effect_count};
 
     for (u32 i = 0; i < effect_count; i++) {
-#ifdef _WIN32
-        // There's a bug in Windows where using this effect causes extreme noise. So let's skip it.
-        if (in_params[i].type == EffectInfoBase::Type::Reverb) {
-            continue;
-        }
-#endif
         auto effect_info{&effect_context.GetInfo(i)};
         if (effect_info->GetType() != in_params[i].type) {
             effect_info->ForceUnmapBuffers(pool_mapper);
@@ -218,12 +212,6 @@ Result InfoUpdater::UpdateEffectsVersion2(EffectContext& effect_context, const b
         reinterpret_cast<EffectInfoBase::OutStatusVersion2*>(output), effect_count};
 
     for (u32 i = 0; i < effect_count; i++) {
-#ifdef _WIN32
-        // There's a bug in Windows where using this effect causes extreme noise. So let's skip it.
-        if (in_params[i].type == EffectInfoBase::Type::Reverb) {
-            continue;
-        }
-#endif
         auto effect_info{&effect_context.GetInfo(i)};
         if (effect_info->GetType() != in_params[i].type) {
             effect_info->ForceUnmapBuffers(pool_mapper);

src/audio_core/renderer/command/effect/reverb.cpp

@@ -191,8 +191,6 @@ static void InitializeReverbEffect(const ReverbInfo::ParameterVersion2& params,
     const auto center_delay_time{(5 * delay).to_uint_floor()};
     state.center_delay_line.Initialize(center_delay_time, 1.0f);
 
-    UpdateReverbEffectParameter(params, state);
-
     for (u32 i = 0; i < ReverbInfo::MaxDelayLines; i++) {
         std::ranges::fill(state.fdn_delay_lines[i].buffer, 0);
         std::ranges::fill(state.decay_delay_lines[i].buffer, 0);

src/common/logging/backend.cpp

@@ -39,9 +39,17 @@ namespace Common::Log {
 
 namespace {
 
-/**
- * Interface for logging backends.
- */
+/// @brief Trims up to and including the last of ../, ..\, src/, src\ in a string
+/// do not be fooled this isn't generating new strings on .rodata :)
+constexpr const char* TrimSourcePath(std::string_view source) {
+    const auto rfind = [source](const std::string_view match) {
+        return source.rfind(match) == source.npos ? 0 : (source.rfind(match) + match.size());
+    };
+    auto idx = (std::max)({rfind("src/"), rfind("src\\"), rfind("../"), rfind("..\\")});
+    return source.data() + idx;
+}
+
+/// @brief Interface for logging backends.
 class Backend {
 public:
     virtual ~Backend() = default;
@@ -53,9 +61,7 @@ public:
     virtual void Flush() = 0;
 };
 
-/**
- * Backend that writes to stderr and with color
- */
+/// @brief Backend that writes to stderr and with color
 class ColorConsoleBackend final : public Backend {
 public:
     explicit ColorConsoleBackend() = default;
@@ -84,9 +90,7 @@ private:
     std::atomic_bool enabled{false};
 };
 
-/**
- * Backend that writes to a file passed into the constructor
- */
+/// @brief Backend that writes to a file passed into the constructor
 class FileBackend final : public Backend {
 public:
     explicit FileBackend(const std::filesystem::path& filename) {
@@ -248,13 +252,14 @@ public:
         color_console_backend.SetEnabled(enabled);
     }
 
+    bool CanPushEntry(Class log_class, Level log_level) const noexcept {
+        return filter.CheckMessage(log_class, log_level);
+    }
+
     void PushEntry(Class log_class, Level log_level, const char* filename, unsigned int line_num,
-                   const char* function, std::string&& message) {
-        if (!filter.CheckMessage(log_class, log_level)) {
-            return;
-        }
+                   const char* function, std::string&& message) noexcept {
         message_queue.EmplaceWait(
-            CreateEntry(log_class, log_level, filename, line_num, function, std::move(message)));
+            CreateEntry(log_class, log_level, TrimSourcePath(filename), line_num, function, std::move(message)));
     }
 
 private:
@@ -368,8 +373,9 @@ void FmtLogMessageImpl(Class log_class, Level log_level, const char* filename,
                        unsigned int line_num, const char* function, fmt::string_view format,
                        const fmt::format_args& args) {
     if (!initialization_in_progress_suppress_logging) {
-        Impl::Instance().PushEntry(log_class, log_level, filename, line_num, function,
-                                   fmt::vformat(format, args));
+        auto& instance = Impl::Instance();
+        if (instance.CanPushEntry(log_class, log_level))
+            instance.PushEntry(log_class, log_level, filename, line_num, function, fmt::vformat(format, args));
     }
 }
 } // namespace Common::Log

src/common/logging/filter.cpp

@@ -1,3 +1,6 @@
+// SPDX-FileCopyrightText: Copyright 2025 Eden Emulator Project
+// SPDX-License-Identifier: GPL-3.0-or-later
+
 // SPDX-FileCopyrightText: 2014 Citra Emulator Project
 // SPDX-License-Identifier: GPL-2.0-or-later
 
@@ -9,22 +12,20 @@ namespace Common::Log {
 namespace {
 template <typename It>
 Level GetLevelByName(const It begin, const It end) {
-    for (u8 i = 0; i < static_cast<u8>(Level::Count); ++i) {
-        const char* level_name = GetLevelName(static_cast<Level>(i));
-        if (Common::ComparePartialString(begin, end, level_name)) {
-            return static_cast<Level>(i);
-        }
+    for (u32 i = 0; i < u32(Level::Count); ++i) {
+        const char* level_name = GetLevelName(Level(i));
+        if (Common::ComparePartialString(begin, end, level_name))
+            return Level(i);
     }
     return Level::Count;
 }
 
 template <typename It>
 Class GetClassByName(const It begin, const It end) {
-    for (u8 i = 0; i < static_cast<u8>(Class::Count); ++i) {
-        const char* level_name = GetLogClassName(static_cast<Class>(i));
-        if (Common::ComparePartialString(begin, end, level_name)) {
-            return static_cast<Class>(i);
-        }
+    for (u32 i = 0; i < u32(Class::Count); ++i) {
+        const char* level_name = GetLogClassName(Class(i));
+        if (Common::ComparePartialString(begin, end, level_name))
+            return Class(i);
     }
     return Class::Count;
 }
@@ -229,13 +230,12 @@ void Filter::ParseFilterString(std::string_view filter_view) {
 }
 
 bool Filter::CheckMessage(Class log_class, Level level) const {
-    return static_cast<u8>(level) >=
-           static_cast<u8>(class_levels[static_cast<std::size_t>(log_class)]);
+    return u8(level) >= u8(class_levels[std::size_t(log_class)]);
 }
 
 bool Filter::IsDebug() const {
     return std::any_of(class_levels.begin(), class_levels.end(), [](const Level& l) {
-        return static_cast<u8>(l) <= static_cast<u8>(Level::Debug);
+        return u8(l) <= u8(Level::Debug);
     });
 }
 

src/common/logging/log.h

@@ -16,15 +16,6 @@
 
 namespace Common::Log {
 
-// trims up to and including the last of ../, ..\, src/, src\ in a string
-constexpr const char* TrimSourcePath(std::string_view source) {
-    const auto rfind = [source](const std::string_view match) {
-        return source.rfind(match) == source.npos ? 0 : (source.rfind(match) + match.size());
-    };
-    auto idx = (std::max)({rfind("src/"), rfind("src\\"), rfind("../"), rfind("..\\")});
-    return source.data() + idx;
-}
-
 /// Logs a message to the global logger, using fmt
 void FmtLogMessageImpl(Class log_class, Level log_level, const char* filename,
                        unsigned int line_num, const char* function, fmt::string_view format,
@@ -42,7 +33,7 @@ void FmtLogMessage(Class log_class, Level log_level, const char* filename, unsig
 #ifdef _DEBUG
 #define LOG_TRACE(log_class, ...)                                                                  \
     Common::Log::FmtLogMessage(Common::Log::Class::log_class, Common::Log::Level::Trace,           \
-                               Common::Log::TrimSourcePath(__FILE__), __LINE__, __func__,          \
+                               __FILE__, __LINE__, __func__,          \
                                __VA_ARGS__)
 #else
 #define LOG_TRACE(log_class, fmt, ...) (void(0))
@@ -50,21 +41,21 @@ void FmtLogMessage(Class log_class, Level log_level, const char* filename, unsig
 
 #define LOG_DEBUG(log_class, ...)                                                                  \
     Common::Log::FmtLogMessage(Common::Log::Class::log_class, Common::Log::Level::Debug,           \
-                               Common::Log::TrimSourcePath(__FILE__), __LINE__, __func__,          \
+                               __FILE__, __LINE__, __func__,          \
                                __VA_ARGS__)
 #define LOG_INFO(log_class, ...)                                                                   \
     Common::Log::FmtLogMessage(Common::Log::Class::log_class, Common::Log::Level::Info,            \
-                               Common::Log::TrimSourcePath(__FILE__), __LINE__, __func__,          \
+                               __FILE__, __LINE__, __func__,          \
                                __VA_ARGS__)
 #define LOG_WARNING(log_class, ...)                                                                \
     Common::Log::FmtLogMessage(Common::Log::Class::log_class, Common::Log::Level::Warning,         \
-                               Common::Log::TrimSourcePath(__FILE__), __LINE__, __func__,          \
+                               __FILE__, __LINE__, __func__,          \
                                __VA_ARGS__)
 #define LOG_ERROR(log_class, ...)                                                                  \
     Common::Log::FmtLogMessage(Common::Log::Class::log_class, Common::Log::Level::Error,           \
-                               Common::Log::TrimSourcePath(__FILE__), __LINE__, __func__,          \
+                               __FILE__, __LINE__, __func__,          \
                                __VA_ARGS__)
 #define LOG_CRITICAL(log_class, ...)                                                               \
     Common::Log::FmtLogMessage(Common::Log::Class::log_class, Common::Log::Level::Critical,        \
-                               Common::Log::TrimSourcePath(__FILE__), __LINE__, __func__,          \
+                               __FILE__, __LINE__, __func__,          \
                                __VA_ARGS__)

src/common/scm_rev.cpp.in

@@ -18,7 +18,7 @@
 #define TITLE_BAR_FORMAT_RUNNING "@TITLE_BAR_FORMAT_RUNNING@"
 #define IS_DEV_BUILD @IS_DEV_BUILD@
 #define COMPILER_ID "@CXX_COMPILER@"
-#define BUILD_AUTO_UPDATE_WEBISTE "@BUILD_AUTO_UPDATE_WEBISTE@"
+#define BUILD_AUTO_UPDATE_WEBSITE "@BUILD_AUTO_UPDATE_WEBSITE@"
 #define BUILD_AUTO_UPDATE_API "@BUILD_AUTO_UPDATE_API@"
 #define BUILD_AUTO_UPDATE_REPO "@BUILD_AUTO_UPDATE_REPO@"
 
@@ -37,7 +37,7 @@ constexpr const char g_title_bar_format_running[] = TITLE_BAR_FORMAT_RUNNING;
 constexpr const char g_compiler_id[] = COMPILER_ID;
 constexpr const bool g_is_dev_build = IS_DEV_BUILD;
 
-constexpr const char g_build_auto_update_website[] = BUILD_AUTO_UPDATE_WEBISTE;
+constexpr const char g_build_auto_update_website[] = BUILD_AUTO_UPDATE_WEBSITE;
 constexpr const char g_build_auto_update_api[] = BUILD_AUTO_UPDATE_API;
 constexpr const char g_build_auto_update_repo[] = BUILD_AUTO_UPDATE_REPO;
 

src/core/file_sys/content_archive.cpp

@@ -38,9 +38,6 @@ NCA::NCA(VirtualFile file_, const NCA* base_nca)
 
     reader = std::make_shared<NcaReader>();
     if (Result rc = reader->Initialize(file, GetCryptoConfiguration(), GetNcaCompressionConfiguration()); R_FAILED(rc)) {
-        if (rc != ResultInvalidNcaSignature) {
-            LOG_ERROR(Loader, "File reader errored out during header read: {:#x}", rc.GetInnerValue());
-        }
         status = Loader::ResultStatus::ErrorBadNCAHeader;
         return;
     }
@@ -85,7 +82,6 @@ NCA::NCA(VirtualFile file_, const NCA* base_nca)
     for (s32 i = 0; i < fs_count; i++) {
         NcaFsHeaderReader header_reader;
         if (Result rc = fs.OpenStorage(&filesystems[i], &header_reader, i); R_FAILED(rc)) {
-            LOG_DEBUG(Loader, "File reader errored out during read of section {}: {:#x}", i, rc.GetInnerValue());
             status = Loader::ResultStatus::ErrorBadNCAHeader;
             return;
         }

src/core/file_sys/fssystem/fs_types.h

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

src/core/file_sys/fssystem/fssystem_nca_file_system_driver.cpp

@@ -1049,13 +1049,11 @@ Result NcaFileSystemDriver::CreatePatchMetaStorage(
     ASSERT(out_aes_ctr_ex_meta != nullptr);
     ASSERT(out_indirect_meta != nullptr);
     ASSERT(base_storage != nullptr);
-    //ASSERT(patch_info.HasAesCtrExTable());
-    //ASSERT(patch_info.HasIndirectTable());
     ASSERT(Common::IsAligned<s64>(patch_info.aes_ctr_ex_size, NcaHeader::XtsBlockSize));
 
     // Validate patch info extents.
-    R_UNLESS(patch_info.indirect_size > 0, ResultInvalidNcaPatchInfoIndirectSize);
-    R_UNLESS(patch_info.aes_ctr_ex_size >= 0, ResultInvalidNcaPatchInfoAesCtrExSize);
+    R_UNLESS(patch_info.aes_ctr_ex_size >= 0 && patch_info.HasAesCtrExTable(), ResultInvalidNcaPatchInfoAesCtrExSize);
+    R_UNLESS(patch_info.indirect_size > 0 && patch_info.HasIndirectTable(), ResultInvalidNcaPatchInfoIndirectSize);
     R_UNLESS(patch_info.indirect_size + patch_info.indirect_offset <= patch_info.aes_ctr_ex_offset,
              ResultInvalidNcaPatchInfoAesCtrExOffset);
     R_UNLESS(patch_info.aes_ctr_ex_offset + patch_info.aes_ctr_ex_size <=
@@ -1333,10 +1331,30 @@ Result NcaFileSystemDriver::CreateIntegrityVerificationStorageImpl(
         R_UNLESS(last_layer_info_offset + layer_info.size <= layer_info_offset,
                  ResultRomNcaInvalidIntegrityLayerInfoOffset);
     }
-    storage_info[level_hash_info.max_layers - 1]
-        = std::make_shared<OffsetVfsFile>(std::move(base_storage),
-                                          layer_info.size,
-                                          last_layer_info_offset);
+
+    switch (level_hash_info.max_layers - 1) {
+        case FileSys::HierarchicalIntegrityVerificationStorage::HierarchicalStorageInformation::MasterStorage:
+            storage_info.SetMasterHashStorage(std::make_shared<OffsetVfsFile>(std::move(base_storage), layer_info.size, last_layer_info_offset));
+            break;
+        case FileSys::HierarchicalIntegrityVerificationStorage::HierarchicalStorageInformation::Layer1Storage:
+            storage_info.SetLayer1HashStorage(std::make_shared<OffsetVfsFile>(std::move(base_storage), layer_info.size, last_layer_info_offset));
+            break;
+        case FileSys::HierarchicalIntegrityVerificationStorage::HierarchicalStorageInformation::Layer2Storage:
+            storage_info.SetLayer2HashStorage(std::make_shared<OffsetVfsFile>(std::move(base_storage), layer_info.size, last_layer_info_offset));
+            break;
+        case FileSys::HierarchicalIntegrityVerificationStorage::HierarchicalStorageInformation::Layer3Storage:
+            storage_info.SetLayer3HashStorage(std::make_shared<OffsetVfsFile>(std::move(base_storage), layer_info.size, last_layer_info_offset));
+            break;
+        case FileSys::HierarchicalIntegrityVerificationStorage::HierarchicalStorageInformation::Layer4Storage:
+            storage_info.SetLayer4HashStorage(std::make_shared<OffsetVfsFile>(std::move(base_storage), layer_info.size, last_layer_info_offset));
+            break;
+        case FileSys::HierarchicalIntegrityVerificationStorage::HierarchicalStorageInformation::Layer5Storage:
+            storage_info.SetLayer5HashStorage(std::make_shared<OffsetVfsFile>(std::move(base_storage), layer_info.size, last_layer_info_offset));
+            break;
+        case FileSys::HierarchicalIntegrityVerificationStorage::HierarchicalStorageInformation::DataStorage:
+            storage_info.SetDataStorage(std::make_shared<OffsetVfsFile>(std::move(base_storage), layer_info.size, last_layer_info_offset));
+            break;
+    }
 
     // Make the integrity romfs storage.
     auto integrity_storage = std::make_shared<IntegrityRomFsStorage>();

src/core/hle/service/nvdrv/devices/nvhost_nvdec_common.cpp

@@ -135,8 +135,8 @@ NvResult nvhost_nvdec_common::GetSyncpoint(IoctlGetSyncpoint& params) {
 }
 
 NvResult nvhost_nvdec_common::GetWaitbase(IoctlGetWaitbase& params) {
-    LOG_CRITICAL(Service_NVDRV, "called WAITBASE");
-    params.value = 0; // Seems to be hard coded at 0
+    LOG_DEBUG(Service_NVDRV, "called WAITBASE");
+    params.value = 0;
     return NvResult::Success;
 }
 

src/core/hle/service/ssl/ssl_backend_openssl.cpp

@@ -1,3 +1,6 @@
+// SPDX-FileCopyrightText: Copyright 2025 Eden Emulator Project
+// SPDX-License-Identifier: GPL-3.0-or-later
+
 // SPDX-FileCopyrightText: Copyright 2023 yuzu Emulator Project
 // SPDX-License-Identifier: GPL-2.0-or-later
 
@@ -286,7 +289,7 @@ Result CheckOpenSSLErrors() {
             msg.append(data);
         }
         Common::Log::FmtLogMessage(Common::Log::Class::Service_SSL, Common::Log::Level::Error,
-                                   Common::Log::TrimSourcePath(file), line, func, "OpenSSL: {}",
+                                   file, line, func, "OpenSSL: {}",
                                    msg);
     }
     return ResultInternalError;

src/dynarmic/src/dynarmic/interface/optimization_flags.h

@@ -1,3 +1,6 @@
+// SPDX-FileCopyrightText: Copyright 2025 Eden Emulator Project
+// SPDX-License-Identifier: GPL-3.0-or-later
+
 /* This file is part of the dynarmic project.
  * Copyright (c) 2020 MerryMage
  * SPDX-License-Identifier: 0BSD
@@ -34,6 +37,8 @@ enum class OptimizationFlag : std::uint32_t {
     MiscIROpt = 0x00000020,
     /// Optimize for code speed rather than for code size (this serves well for tight loops)
     CodeSpeed = 0x00000040,
+    /// Disable verification passes
+    DisableVerification = 0x00000080,
 
     /// This is an UNSAFE optimization that reduces accuracy of fused multiply-add operations.
     /// This unfuses fused instructions to improve performance on host CPUs without FMA support.

src/dynarmic/src/dynarmic/ir/opt_passes.cpp

@@ -1491,9 +1491,9 @@ void Optimize(IR::Block& block, const A32::UserConfig& conf, const Optimization:
         Optimization::DeadCodeElimination(block);
     }
     Optimization::IdentityRemovalPass(block);
-    //if (!conf.HasOptimization(OptimizationFlag::DisableVerification)) {
+    if (!conf.HasOptimization(OptimizationFlag::DisableVerification)) {
         Optimization::VerificationPass(block);
-    //}
+    }
 }
 
 void Optimize(IR::Block& block, const A64::UserConfig& conf, const Optimization::PolyfillOptions& polyfill_options) {
@@ -1511,9 +1511,9 @@ void Optimize(IR::Block& block, const A64::UserConfig& conf, const Optimization:
     if (conf.HasOptimization(OptimizationFlag::MiscIROpt)) [[likely]] {
         Optimization::A64MergeInterpretBlocksPass(block, conf.callbacks);
     }
-    //if (!conf.HasOptimization(OptimizationFlag::DisableVerification)) {
+    if (!conf.HasOptimization(OptimizationFlag::DisableVerification)) {
         Optimization::VerificationPass(block);
-    //}
+    }
 }
 
 }  // namespace Dynarmic::Optimization

src/video_core/host1x/codecs/decoder.cpp

@@ -38,6 +38,10 @@ void Decoder::Decode() {
     // Receive output frames from decoder.
     auto frame = decode_api.ReceiveFrame();
 
+    if (!frame) {
+        return;
+    }
+
     if (IsInterlaced()) {
         auto [luma_top, luma_bottom, chroma_top, chroma_bottom] = GetInterlacedOffsets();
         auto frame_copy = frame;

src/video_core/host1x/ffmpeg/ffmpeg.cpp

@@ -233,7 +233,7 @@ bool DecoderContext::OpenContext(const Decoder& decoder) {
 }
 
 bool DecoderContext::SendPacket(const Packet& packet) {
-	if (const int ret = avcodec_send_packet(m_codec_context, packet.GetPacket()); ret < 0 && ret != AVERROR_EOF) {
+	if (const int ret = avcodec_send_packet(m_codec_context, packet.GetPacket()); ret < 0 && ret != AVERROR_EOF && ret != AVERROR(EAGAIN)) {
 		LOG_ERROR(HW_GPU, "avcodec_send_packet error: {}", AVError(ret));
 		return false;
 	}
@@ -242,31 +242,31 @@ bool DecoderContext::SendPacket(const Packet& packet) {
 }
 
 std::shared_ptr<Frame> DecoderContext::ReceiveFrame() {
-	auto ReceiveImpl = [&](AVFrame* frame) -> bool {
-		if (const int ret = avcodec_receive_frame(m_codec_context, frame); ret < 0 && ret != AVERROR_EOF) {
+	auto ReceiveImpl = [&](AVFrame* frame) -> int {
+        const int ret = avcodec_receive_frame(m_codec_context, frame);
+		if (ret < 0 && ret != AVERROR_EOF && ret != AVERROR(EAGAIN)) {
 			LOG_ERROR(HW_GPU, "avcodec_receive_frame error: {}", AVError(ret));
-			return false;
 		}
-		return true;
+		return ret;
 	};
 
 	std::shared_ptr<Frame> intermediate_frame = std::make_shared<Frame>();
-	if (!ReceiveImpl(intermediate_frame->GetFrame())) {
+	if (ReceiveImpl(intermediate_frame->GetFrame()) < 0) {
 		return {};
 	}
 
-	m_temp_frame = std::make_shared<Frame>();
+	m_final_frame = std::make_shared<Frame>();
 	if (m_codec_context->hw_device_ctx) {
-		m_temp_frame->SetFormat(PreferredGpuFormat);
-		if (int ret = av_hwframe_transfer_data(m_temp_frame->GetFrame(), intermediate_frame->GetFrame(), 0); ret < 0) {
+		m_final_frame->SetFormat(PreferredGpuFormat);
+		if (const int ret = av_hwframe_transfer_data(m_final_frame->GetFrame(), intermediate_frame->GetFrame(), 0); ret < 0) {
 			LOG_ERROR(HW_GPU, "av_hwframe_transfer_data error: {}", AVError(ret));
 			return {};
 		}
 	} else {
-		m_temp_frame = std::move(intermediate_frame);
+		m_final_frame = std::move(intermediate_frame);
 	}
 
-	return std::move(m_temp_frame);
+	return std::move(m_final_frame);
 }
 
 void DecodeApi::Reset() {

src/video_core/host1x/ffmpeg/ffmpeg.h

@@ -194,7 +194,7 @@ public:
 private:
     const Decoder& m_decoder;
     AVCodecContext* m_codec_context{};
-    std::shared_ptr<Frame> m_temp_frame{};
+    std::shared_ptr<Frame> m_final_frame{};
     bool m_decode_order{};
 };
 

src/video_core/host1x/vic.cpp

@@ -146,6 +146,11 @@ void Vic::Execute() {
             }
 
             auto frame = frame_queue.GetFrame(nvdec_id, luma_offset);
+
+            if (!frame) {
+                continue;
+            }
+
             if (!frame.get()) {
                 LOG_ERROR(HW_GPU, "Vic {} failed to get frame with offset {:#X}", id, luma_offset);
                 continue;

src/video_core/renderer_opengl/gl_shader_cache.cpp

@@ -54,7 +54,7 @@ using VideoCommon::LoadPipelines;
 using VideoCommon::SerializePipeline;
 using Context = ShaderContext::Context;
 
-constexpr u32 CACHE_VERSION = 10;
+constexpr u32 CACHE_VERSION = 13;
 
 template <typename Container>
 auto MakeSpan(Container& container) {

src/video_core/renderer_vulkan/present/layer.cpp

@@ -280,6 +280,7 @@ void Layer::UpdateRawImage(const Tegra::FramebufferConfig& framebuffer, size_t i
         Tegra::Texture::UnswizzleTexture(
             mapped_span.subspan(image_offset, linear_size), std::span(host_ptr, tiled_size),
             bytes_per_pixel, framebuffer.width, framebuffer.height, 1, block_height_log2, 0);
+        buffer.Flush();  // Ensure host writes are visible before the GPU copy.
     }
 
     const VkBufferImageCopy copy{

src/video_core/renderer_vulkan/vk_pipeline_cache.cpp

@@ -55,7 +55,7 @@ using VideoCommon::FileEnvironment;
 using VideoCommon::GenericEnvironment;
 using VideoCommon::GraphicsEnvironment;
 
-constexpr u32 CACHE_VERSION = 12;
+constexpr u32 CACHE_VERSION = 13;
 constexpr std::array<char, 8> VULKAN_CACHE_MAGIC_NUMBER{'y', 'u', 'z', 'u', 'v', 'k', 'c', 'h'};
 
 template <typename Container>

src/yuzu/CMakeLists.txt

@@ -366,7 +366,7 @@ if (APPLE)
     set_target_properties(yuzu PROPERTIES MACOSX_BUNDLE TRUE)
     set_target_properties(yuzu PROPERTIES MACOSX_BUNDLE_INFO_PLIST ${CMAKE_CURRENT_SOURCE_DIR}/Info.plist)
 
-    if (YUZU_APPLE_USE_BUNDLED_MONTENVK)
+    if (YUZU_USE_BUNDLED_MOLTENVK)
         set(MOLTENVK_PLATFORM "macOS")
         set(MOLTENVK_VERSION "v1.3.0")
         download_moltenvk(${MOLTENVK_PLATFORM} ${MOLTENVK_VERSION})

src/yuzu/main.cpp

@@ -4204,8 +4204,8 @@ void GMainWindow::OnEmulatorUpdateAvailable() {
 }
 #endif
 
-void GMainWindow::UpdateWindowTitle(std::string_view title_name, std::string_view title_version,
-                                    std::string_view gpu_vendor) {
+void GMainWindow::UpdateWindowTitle(std::string_view title_name, std::string_view title_version, std::string_view gpu_vendor) {
+    static const std::string build_id = std::string{Common::g_build_id};
     static const std::string yuzu_title = fmt::format("{} | {} | {}",
         std::string{Common::g_build_name},
         std::string{Common::g_build_version},

src/yuzu/update_checker.cpp

@@ -58,7 +58,7 @@ std::optional<std::string> UpdateChecker::GetResponse(std::string url, std::stri
 
 std::optional<std::string> UpdateChecker::GetLatestRelease(bool include_prereleases)
 {
-    constexpr auto update_check_url = std::string{Common::g_build_auto_update_api};
+    const auto update_check_url = std::string{Common::g_build_auto_update_api};
     std::string update_check_path = fmt::format("/repos/{}", std::string{Common::g_build_auto_update_repo});
     try {
         if (include_prereleases) { // This can return either a prerelease or a stable release,