2026-09-14 00:57:14

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

.patch/ffmpeg/0001-steamdeck.patch

@@ -0,0 +1,34 @@
+diff --git a/libavutil/hwcontext_vulkan.c b/libavutil/hwcontext_vulkan.c
+index 2859ee1..766961f 100644
+--- a/libavutil/hwcontext_vulkan.c
++++ b/libavutil/hwcontext_vulkan.c
+@@ -1688,10 +1688,12 @@ static int setup_queue_families(AVHWDeviceContext *ctx, VkDeviceCreateInfo *cd)
+ 
+     hwctx->nb_qf = 0;
+     hwctx->queue_flags = 0;
++/* SD gamemode vkroots crash
+ #ifdef VK_KHR_internally_synchronized_queues
+     if (p->vkctx.extensions & FF_VK_EXT_INTERNAL_QUEUE_SYNC)
+         hwctx->queue_flags |= VK_DEVICE_QUEUE_CREATE_INTERNALLY_SYNCHRONIZED_BIT_KHR;
+ #endif
++*/
+ 
+     /* Pick each queue family to use. */
+ #define PICK_QF(type, vid_op)                                            \
+diff --git a/libavutil/vulkan.c b/libavutil/vulkan.c
+index b2e575c..5b3c9cf 100644
+--- a/libavutil/vulkan.c
++++ b/libavutil/vulkan.c
+@@ -574,10 +574,12 @@ int ff_vk_exec_pool_init(FFVulkanContext *s, AVVulkanDeviceQueueFamily *qf,
+         e->qf = qf->idx;
+         VkDeviceQueueInfo2 qinfo = {
+             .sType            = VK_STRUCTURE_TYPE_DEVICE_QUEUE_INFO_2,
++/* SD gamemode vkroots crash
+ #ifdef VK_KHR_internally_synchronized_queues
+             .flags            = internal_queue_sync ?
+                                 VK_DEVICE_QUEUE_CREATE_INTERNALLY_SYNCHRONIZED_BIT_KHR : 0,
+ #endif
++*/
+             .queueFamilyIndex = qf->idx,
+             .queueIndex       = e->qi,
+         };

cpmfile.json

@@ -70,16 +70,16 @@
         "version": "v1.3.18"
     },
     "ffmpeg": {
-        "hash": "ed177621176b3961bdcaa339187d3a7688c1c8b060b79c4bb0257cbc67ad7021ae5d5adca5303b45625abbbe3d9aafdd87ce777b8690ac295290d744c875489a",
+        "hash": "68f46abf0d5dc47ab95083d59e273131a8df7948b82e62db00f00fa416e1d0bd24b799671b5a60752209bb2ac0f75295055ed0085c89a98113323cde23b69710",
         "repo": "FFmpeg/FFmpeg",
-        "version": "c7b5f1537d"
+        "version": "6efe500d2e"
     },
     "ffmpeg-ci": {
         "ci": true,
         "name": "ffmpeg",
         "package": "FFmpeg",
         "repo": "crueter-ci/FFmpeg",
-        "version": "9.0.2-1790726865-946fcce07b"
+        "version": "9.0.1-1788120736-bf1b838f2a"
     },
     "fmt": {
         "hash": "f0da82c545b01692e9fd30fdfb613dbb8dd9716983dcd0ff19ac2a8d36f74beb5540ef38072fdecc1e34191b3682a8542ecbf3a61ef287dbba0a2679d4e023f2",

src/android/app/src/main/java/org/yuzu/yuzu_emu/model/DriverViewModel.kt

@@ -23,7 +23,6 @@ import org.yuzu.yuzu_emu.model.Driver.Companion.toDriver
 import org.yuzu.yuzu_emu.utils.GpuDriverHelper
 import org.yuzu.yuzu_emu.NativeLibrary
 import org.yuzu.yuzu_emu.utils.GpuDriverMetadata
-import org.yuzu.yuzu_emu.utils.DirectoryInitialization
 import org.yuzu.yuzu_emu.utils.NativeConfig
 import java.io.File
 
@@ -147,11 +146,11 @@ class DriverViewModel : ViewModel() {
     private fun wipeGameShaders(game: Game) {
         viewModelScope.launch {
             withContext(Dispatchers.IO) {
-                val userDirectory = DirectoryInitialization.userDirectory
+                val externalFilesDir = YuzuApplication.appContext.getExternalFilesDir(null)
                     ?: return@withContext
                 val shaderDir = File(
-                    userDirectory +
-                    "/cache/shader/" + game.settingsName.lowercase()
+                    externalFilesDir.absolutePath +
+                    "/shader/" + game.settingsName.lowercase()
                 )
                 if (shaderDir.exists()) {
                     shaderDir.deleteRecursively()

src/core/hle/service/ro/ro.cpp

@@ -426,30 +426,28 @@ public:
                                    std::addressof(ro_size), std::addressof(rw_size),
                                    nro_info->base_address, nro_size, bss_size));
 #ifdef HAS_NCE
-        if (Settings::GetDebugKnobAt(1)) {
-            if (Settings::IsNceEnabled()) {
-                auto* process = context->GetProcess();
-                auto& memory = process->GetMemory();
+        if (Settings::IsNceEnabled()) {
+            auto* process = context->GetProcess();
+            auto& memory = process->GetMemory();
 
-                std::vector<u8> image(total_size);
-                memory.ReadBlock(nro_info->base_address, image.data(), rx_size);
+            std::vector<u8> image(total_size);
+            memory.ReadBlock(nro_info->base_address, image.data(), rx_size);
 
-                Kernel::CodeSet::Segment code{.size = static_cast<u32>(rx_size)};
-                Core::NCE::Patcher patch;
-                patch.PatchText(image, code);
-                patch.RelocateAndCopy(nro_info->base_address, code, image, nullptr);
+            Kernel::CodeSet::Segment code{.size = static_cast<u32>(rx_size)};
+            Core::NCE::Patcher patch;
+            patch.PatchText(image, code);
+            patch.RelocateAndCopy(nro_info->base_address, code, image, nullptr);
 
-                const u64 patch_address = nro_info->base_address + total_size;
-                const size_t patch_size = patch.GetSectionSize();
-                constexpr auto permission = Kernel::Svc::MemoryPermission::ReadExecute;
+            const u64 patch_address = nro_info->base_address + total_size;
+            const size_t patch_size = patch.GetSectionSize();
+            constexpr auto permission = Kernel::Svc::MemoryPermission::ReadExecute;
 
-                auto* patch_memory = Kernel::KSharedMemory::Create(kernel);
-                R_TRY(patch_memory->Initialize(kernel, kernel.System().DeviceMemory(), process, permission, permission, patch_size));
-                std::memcpy(patch_memory->GetPointer(), image.data() + total_size, patch_size);
-                R_TRY(process->AddSharedMemory(kernel, patch_memory, patch_address, patch_size));
-                R_TRY(patch_memory->Map(*process, patch_address, patch_size, permission));
-                memory.WriteBlock(nro_info->base_address, image.data(), rx_size);
-            }
+            auto* patch_memory = Kernel::KSharedMemory::Create(kernel);
+            R_TRY(patch_memory->Initialize(kernel, kernel.System().DeviceMemory(), process, permission, permission, patch_size));
+            std::memcpy(patch_memory->GetPointer(), image.data() + total_size, patch_size);
+            R_TRY(process->AddSharedMemory(kernel, patch_memory, patch_address, patch_size));
+            R_TRY(patch_memory->Map(*process, patch_address, patch_size, permission));
+            memory.WriteBlock(nro_info->base_address, image.data(), rx_size);
         }
 #endif
         // Set NRO perms.

src/core/memory.cpp

@@ -757,7 +757,7 @@ struct Memory::Impl {
         };
         auto& gpu = system.GPU();
         gpu_device_memory->ApplyOpOnPointer(
-            p, scratch_buffers[core], [&](DAddr address) { gpu.InvalidateRegion(address, size, true); });
+            p, scratch_buffers[core], [&](DAddr address) { gpu.InvalidateRegion(address, size); });
     }
 
     Core::System& system;

src/video_core/gpu.cpp

@@ -226,19 +226,7 @@ struct GPU::Impl {
     }
 
     /// Notify rasterizer that any caches of the specified region should be invalidated
-    void InvalidateRegion(DAddr addr, u64 size, bool preserve_gpu_writes) {
-        if (Settings::GetDebugKnobAt(0)) {
-            VideoCore::RasterizerInterface* rasterizer = renderer->ReadRasterizer();
-            if (preserve_gpu_writes && rasterizer->MustFlushRegion(addr, size, VideoCommon::CacheType::BufferCache)) {
-                const u64 fence = RequestSyncOperation([rasterizer, addr, size] {
-                    rasterizer->FlushRegion(addr, size, VideoCommon::CacheType::BufferCache);
-                    rasterizer->OnCacheInvalidation(addr, size);
-                });
-                gpu_thread.TickGPU(is_async);
-                WaitForSyncOperation(fence);
-                return;
-            }
-        }
+    void InvalidateRegion(DAddr addr, u64 size) {
         gpu_thread.InvalidateRegion(addr, size);
     }
 
@@ -530,8 +518,8 @@ void GPU::FlushRegion(DAddr addr, u64 size) {
     impl->FlushRegion(addr, size);
 }
 
-void GPU::InvalidateRegion(DAddr addr, u64 size, bool preserve_gpu_writes) {
-    impl->InvalidateRegion(addr, size, preserve_gpu_writes);
+void GPU::InvalidateRegion(DAddr addr, u64 size) {
+    impl->InvalidateRegion(addr, size);
 }
 
 bool GPU::OnCPUWrite(DAddr addr, u64 size) {

src/video_core/gpu.h

@@ -248,7 +248,7 @@ public:
     void FlushRegion(DAddr addr, u64 size);
 
     /// Notify rasterizer that any caches of the specified region should be invalidated
-    void InvalidateRegion(DAddr addr, u64 size, bool preserve_gpu_writes = false);
+    void InvalidateRegion(DAddr addr, u64 size);
 
     /// Notify rasterizer that CPU is trying to write this area. It returns true if the area is
     /// sensible, false otherwise, addr and size must be a valid combination