early-access version 1265

README.md

@@ -1,7 +1,7 @@
 yuzu emulator early access
 =============
 
-This is the source code for early-access 1264.
+This is the source code for early-access 1265.
 
 ## Legal Notice
 

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

@@ -11,8 +11,9 @@
 
 namespace Service::Nvidia::Devices {
 
-nvhost_nvdec::nvhost_nvdec(Core::System& system, std::shared_ptr<nvmap> nvmap_dev)
+nvhost_nvdec::nvhost_nvdec(Core::System& system, std::shared_ptr<nvmap> nvmap_dev,
-    : nvhost_nvdec_common(system, std::move(nvmap_dev)) {}
+                           SyncpointManager& syncpoint_manager)
+    : nvhost_nvdec_common(system, std::move(nvmap_dev), syncpoint_manager) {}
 nvhost_nvdec::~nvhost_nvdec() = default;
 
 NvResult nvhost_nvdec::Ioctl1(Ioctl command, const std::vector<u8>& input,

src/core/hle/service/nvdrv/devices/nvhost_nvdec.h

@@ -11,7 +11,8 @@ namespace Service::Nvidia::Devices {
 
 class nvhost_nvdec final : public nvhost_nvdec_common {
 public:
-    explicit nvhost_nvdec(Core::System& system, std::shared_ptr<nvmap> nvmap_dev);
+    explicit nvhost_nvdec(Core::System& system, std::shared_ptr<nvmap> nvmap_dev,
+                          SyncpointManager& syncpoint_manager);
     ~nvhost_nvdec() override;
 
     NvResult Ioctl1(Ioctl command, const std::vector<u8>& input, std::vector<u8>& output) override;

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

@@ -11,6 +11,7 @@
 #include "core/core.h"
 #include "core/hle/service/nvdrv/devices/nvhost_nvdec_common.h"
 #include "core/hle/service/nvdrv/devices/nvmap.h"
+#include "core/hle/service/nvdrv/syncpoint_manager.h"
 #include "core/memory.h"
 #include "video_core/memory_manager.h"
 #include "video_core/renderer_base.h"
@@ -36,8 +37,9 @@ std::size_t WriteVectors(std::vector<u8>& dst, const std::vector<T>& src, std::s
 }
 } // Anonymous namespace
 
-nvhost_nvdec_common::nvhost_nvdec_common(Core::System& system, std::shared_ptr<nvmap> nvmap_dev)
+nvhost_nvdec_common::nvhost_nvdec_common(Core::System& system, std::shared_ptr<nvmap> nvmap_dev,
-    : nvdevice(system), nvmap_dev(std::move(nvmap_dev)) {}
+                                         SyncpointManager& syncpoint_manager)
+    : nvdevice(system), nvmap_dev(std::move(nvmap_dev)), syncpoint_manager(syncpoint_manager) {}
 nvhost_nvdec_common::~nvhost_nvdec_common() = default;
 
 NvResult nvhost_nvdec_common::SetNVMAPfd(const std::vector<u8>& input) {
@@ -71,10 +73,15 @@ NvResult nvhost_nvdec_common::Submit(const std::vector<u8>& input, std::vector<u
     offset = SpliceVectors(input, wait_checks, params.syncpoint_count, offset);
     offset = SpliceVectors(input, fences, params.fence_count, offset);
 
-    // TODO(ameerj): For async gpu, utilize fences for syncpoint 'max' increment
-
     auto& gpu = system.GPU();
-
+    if (gpu.UseNvdec()) {
+        for (std::size_t i = 0; i < syncpt_increments.size(); i++) {
+            const SyncptIncr& syncpt_incr = syncpt_increments[i];
+            fences[i].id = syncpt_incr.id;
+            fences[i].value =
+                syncpoint_manager.IncreaseSyncpoint(syncpt_incr.id, syncpt_incr.increments);
+        }
+    }
     for (const auto& cmd_buffer : command_buffers) {
         auto object = nvmap_dev->GetObject(cmd_buffer.memory_id);
         ASSERT_OR_EXECUTE(object, return NvResult::InvalidState;);
@@ -89,7 +96,13 @@ NvResult nvhost_nvdec_common::Submit(const std::vector<u8>& input, std::vector<u
                                       cmdlist.size() * sizeof(u32));
         gpu.PushCommandBuffer(cmdlist);
     }
+    if (gpu.UseNvdec()) {
 
+        fences[0].value = syncpoint_manager.IncreaseSyncpoint(fences[0].id, 1);
+
+        Tegra::ChCommandHeaderList cmdlist{{(4 << 28) | fences[0].id}};
+        gpu.PushCommandBuffer(cmdlist);
+    }
     std::memcpy(output.data(), &params, sizeof(IoctlSubmit));
     // Some games expect command_buffers to be written back
     offset = sizeof(IoctlSubmit);
@@ -98,6 +111,7 @@ NvResult nvhost_nvdec_common::Submit(const std::vector<u8>& input, std::vector<u
     offset = WriteVectors(output, reloc_shifts, offset);
     offset = WriteVectors(output, syncpt_increments, offset);
     offset = WriteVectors(output, wait_checks, offset);
+    offset = WriteVectors(output, fences, offset);
 
     return NvResult::Success;
 }
@@ -107,9 +121,10 @@ NvResult nvhost_nvdec_common::GetSyncpoint(const std::vector<u8>& input, std::ve
     std::memcpy(&params, input.data(), sizeof(IoctlGetSyncpoint));
     LOG_DEBUG(Service_NVDRV, "called GetSyncpoint, id={}", params.param);
 
-    // We found that implementing this causes deadlocks with async gpu, along with degraded
+    if (device_syncpoints[params.param] == 0 && system.GPU().UseNvdec()) {
-    // performance. TODO: RE the nvdec async implementation
+        device_syncpoints[params.param] = syncpoint_manager.AllocateSyncpoint();
-    params.value = 0;
+    }
+    params.value = device_syncpoints[params.param];
     std::memcpy(output.data(), &params, sizeof(IoctlGetSyncpoint));
 
     return NvResult::Success;

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

@@ -10,12 +10,16 @@
 #include "common/swap.h"
 #include "core/hle/service/nvdrv/devices/nvdevice.h"
 
-namespace Service::Nvidia::Devices {
+namespace Service::Nvidia {
+class SyncpointManager;
+
+namespace Devices {
 class nvmap;
 
 class nvhost_nvdec_common : public nvdevice {
 public:
-    explicit nvhost_nvdec_common(Core::System& system, std::shared_ptr<nvmap> nvmap_dev);
+    explicit nvhost_nvdec_common(Core::System& system, std::shared_ptr<nvmap> nvmap_dev,
+                                 SyncpointManager& syncpoint_manager);
     ~nvhost_nvdec_common() override;
 
 protected:
@@ -158,8 +162,10 @@ protected:
     u32_le submit_timeout{};
     bool vic_device{};
     std::shared_ptr<nvmap> nvmap_dev;
-
+    SyncpointManager& syncpoint_manager;
+    std::array<u32, MaxSyncPoints> device_syncpoints{};
     // This is expected to be ordered, therefore we must use a map, not unordered_map
     std::map<GPUVAddr, BufferMap> buffer_mappings;
 };
-}; // namespace Service::Nvidia::Devices
+}; // namespace Devices
+} // namespace Service::Nvidia

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

@@ -10,8 +10,9 @@
 #include "video_core/renderer_base.h"
 
 namespace Service::Nvidia::Devices {
-nvhost_vic::nvhost_vic(Core::System& system, std::shared_ptr<nvmap> nvmap_dev)
+nvhost_vic::nvhost_vic(Core::System& system, std::shared_ptr<nvmap> nvmap_dev,
-    : nvhost_nvdec_common(system, std::move(nvmap_dev)) {
+                       SyncpointManager& syncpoint_manager)
+    : nvhost_nvdec_common(system, std::move(nvmap_dev), syncpoint_manager) {
     vic_device = true;
 }
 nvhost_vic::~nvhost_vic() = default;

src/core/hle/service/nvdrv/devices/nvhost_vic.h

@@ -7,11 +7,11 @@
 #include "core/hle/service/nvdrv/devices/nvhost_nvdec_common.h"
 
 namespace Service::Nvidia::Devices {
-class nvmap;
 
 class nvhost_vic final : public nvhost_nvdec_common {
 public:
-    explicit nvhost_vic(Core::System& system, std::shared_ptr<nvmap> nvmap_dev);
+    explicit nvhost_vic(Core::System& system, std::shared_ptr<nvmap> nvmap_dev,
+                        SyncpointManager& syncpoint_manager);
     ~nvhost_vic();
 
     NvResult Ioctl1(Ioctl command, const std::vector<u8>& input, std::vector<u8>& output) override;

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

@@ -55,9 +55,11 @@ Module::Module(Core::System& system) : syncpoint_manager{system.GPU()} {
     devices["/dev/nvdisp_disp0"] = std::make_shared<Devices::nvdisp_disp0>(system, nvmap_dev);
     devices["/dev/nvhost-ctrl"] =
         std::make_shared<Devices::nvhost_ctrl>(system, events_interface, syncpoint_manager);
-    devices["/dev/nvhost-nvdec"] = std::make_shared<Devices::nvhost_nvdec>(system, nvmap_dev);
+    devices["/dev/nvhost-nvdec"] =
+        std::make_shared<Devices::nvhost_nvdec>(system, nvmap_dev, syncpoint_manager);
     devices["/dev/nvhost-nvjpg"] = std::make_shared<Devices::nvhost_nvjpg>(system);
-    devices["/dev/nvhost-vic"] = std::make_shared<Devices::nvhost_vic>(system, nvmap_dev);
+    devices["/dev/nvhost-vic"] =
+        std::make_shared<Devices::nvhost_vic>(system, nvmap_dev, syncpoint_manager);
 }
 
 Module::~Module() = default;

src/video_core/CMakeLists.txt

@@ -246,7 +246,6 @@ add_library(video_core STATIC
     texture_cache/samples_helper.h
     texture_cache/slot_vector.h
     texture_cache/texture_cache.h
-    texture_cache/texture_cache.inl
     texture_cache/types.h
     texture_cache/util.cpp
     texture_cache/util.h

src/video_core/cdma_pusher.cpp

@@ -33,8 +33,7 @@ CDmaPusher::CDmaPusher(GPU& gpu_)
     : gpu{gpu_}, nvdec_processor(std::make_shared<Nvdec>(gpu)),
       vic_processor(std::make_unique<Vic>(gpu, nvdec_processor)),
       host1x_processor(std::make_unique<Host1x>(gpu)),
-      nvdec_sync(std::make_unique<SyncptIncrManager>(gpu)),
+      sync_manager(std::make_unique<SyncptIncrManager>(gpu)) {}
-      vic_sync(std::make_unique<SyncptIncrManager>(gpu)) {}
 
 CDmaPusher::~CDmaPusher() = default;
 
@@ -110,10 +109,10 @@ void CDmaPusher::ExecuteCommand(u32 state_offset, u32 data) {
             const auto syncpoint_id = static_cast<u32>(data & 0xFF);
             const auto cond = static_cast<u32>((data >> 8) & 0xFF);
             if (cond == 0) {
-                nvdec_sync->Increment(syncpoint_id);
+                sync_manager->Increment(syncpoint_id);
             } else {
-                nvdec_sync->IncrementWhenDone(static_cast<u32>(current_class), syncpoint_id);
+                sync_manager->SignalDone(
-                nvdec_sync->SignalDone(syncpoint_id);
+                    sync_manager->IncrementWhenDone(static_cast<u32>(current_class), syncpoint_id));
             }
             break;
         }
@@ -135,10 +134,10 @@ void CDmaPusher::ExecuteCommand(u32 state_offset, u32 data) {
             const auto syncpoint_id = static_cast<u32>(data & 0xFF);
             const auto cond = static_cast<u32>((data >> 8) & 0xFF);
             if (cond == 0) {
-                vic_sync->Increment(syncpoint_id);
+                sync_manager->Increment(syncpoint_id);
             } else {
-                vic_sync->IncrementWhenDone(static_cast<u32>(current_class), syncpoint_id);
+                sync_manager->SignalDone(
-                vic_sync->SignalDone(syncpoint_id);
+                    sync_manager->IncrementWhenDone(static_cast<u32>(current_class), syncpoint_id));
             }
             break;
         }

src/video_core/cdma_pusher.h

@@ -116,12 +116,10 @@ private:
     void ThiStateWrite(ThiRegisters& state, u32 state_offset, const std::vector<u32>& arguments);
 
     GPU& gpu;
-
+    std::shared_ptr<Tegra::Nvdec> nvdec_processor;
-    std::shared_ptr<Nvdec> nvdec_processor;
+    std::unique_ptr<Tegra::Vic> vic_processor;
-    std::unique_ptr<Vic> vic_processor;
+    std::unique_ptr<Tegra::Host1x> host1x_processor;
-    std::unique_ptr<Host1x> host1x_processor;
+    std::unique_ptr<SyncptIncrManager> sync_manager;
-    std::unique_ptr<SyncptIncrManager> nvdec_sync;
-    std::unique_ptr<SyncptIncrManager> vic_sync;
     ChClassId current_class{};
     ThiRegisters vic_thi_state{};
     ThiRegisters nvdec_thi_state{};

src/video_core/command_classes/host1x.cpp

@@ -10,22 +10,14 @@ Tegra::Host1x::Host1x(GPU& gpu_) : gpu(gpu_) {}
 
 Tegra::Host1x::~Host1x() = default;
 
-void Tegra::Host1x::StateWrite(u32 offset, u32 arguments) {
+void Tegra::Host1x::ProcessMethod(Method method, u32 argument) {
-    u8* const state_offset = reinterpret_cast<u8*>(&state) + offset * sizeof(u32);
-    std::memcpy(state_offset, &arguments, sizeof(u32));
-}
-
-void Tegra::Host1x::ProcessMethod(Method method, const std::vector<u32>& arguments) {
-    StateWrite(static_cast<u32>(method), arguments[0]);
     switch (method) {
-    case Method::WaitSyncpt:
-        Execute(arguments[0]);
-        break;
     case Method::LoadSyncptPayload32:
-        syncpoint_value = arguments[0];
+        syncpoint_value = argument;
         break;
+    case Method::WaitSyncpt:
     case Method::WaitSyncpt32:
-        Execute(arguments[0]);
+        Execute(argument);
         break;
     default:
         UNIMPLEMENTED_MSG("Host1x method 0x{:X}", static_cast<u32>(method));
@@ -34,6 +26,5 @@ void Tegra::Host1x::ProcessMethod(Method method, const std::vector<u32>& argumen
 }
 
 void Tegra::Host1x::Execute(u32 data) {
-    // This method waits on a valid syncpoint.
+    gpu.WaitFence(data, syncpoint_value);
-    // TODO: Implement when proper Async is in place
 }

src/video_core/command_classes/host1x.h

@@ -14,64 +14,23 @@ class Nvdec;
 
 class Host1x {
 public:
-    struct Host1xClassRegisters {
-        u32 incr_syncpt{};
-        u32 incr_syncpt_ctrl{};
-        u32 incr_syncpt_error{};
-        INSERT_PADDING_WORDS(5);
-        u32 wait_syncpt{};
-        u32 wait_syncpt_base{};
-        u32 wait_syncpt_incr{};
-        u32 load_syncpt_base{};
-        u32 incr_syncpt_base{};
-        u32 clear{};
-        u32 wait{};
-        u32 wait_with_interrupt{};
-        u32 delay_use{};
-        u32 tick_count_high{};
-        u32 tick_count_low{};
-        u32 tick_ctrl{};
-        INSERT_PADDING_WORDS(23);
-        u32 ind_ctrl{};
-        u32 ind_off2{};
-        u32 ind_off{};
-        std::array<u32, 31> ind_data{};
-        INSERT_PADDING_WORDS(1);
-        u32 load_syncpoint_payload32{};
-        u32 stall_ctrl{};
-        u32 wait_syncpt32{};
-        u32 wait_syncpt_base32{};
-        u32 load_syncpt_base32{};
-        u32 incr_syncpt_base32{};
-        u32 stall_count_high{};
-        u32 stall_count_low{};
-        u32 xref_ctrl{};
-        u32 channel_xref_high{};
-        u32 channel_xref_low{};
-    };
-    static_assert(sizeof(Host1xClassRegisters) == 0x164, "Host1xClassRegisters is an invalid size");
-
     enum class Method : u32 {
-        WaitSyncpt = offsetof(Host1xClassRegisters, wait_syncpt) / 4,
+        WaitSyncpt = 0x8,
-        LoadSyncptPayload32 = offsetof(Host1xClassRegisters, load_syncpoint_payload32) / 4,
+        LoadSyncptPayload32 = 0x4e,
-        WaitSyncpt32 = offsetof(Host1xClassRegisters, wait_syncpt32) / 4,
+        WaitSyncpt32 = 0x50,
     };
 
     explicit Host1x(GPU& gpu);
     ~Host1x();
 
     /// Writes the method into the state, Invoke Execute() if encountered
-    void ProcessMethod(Method method, const std::vector<u32>& arguments);
+    void ProcessMethod(Method method, u32 argument);
 
 private:
     /// For Host1x, execute is waiting on a syncpoint previously written into the state
     void Execute(u32 data);
 
-    /// Write argument into the provided offset
-    void StateWrite(u32 offset, u32 arguments);
-
     u32 syncpoint_value{};
-    Host1xClassRegisters state{};
     GPU& gpu;
 };
 

src/video_core/delayed_destruction_ring.h

@@ -11,6 +11,7 @@
 
 namespace VideoCommon {
 
+/// Container to push objects to be destroyed a few ticks in the future
 template <typename T, size_t TICKS_TO_DESTROY>
 class DelayedDestructionRing {
 public:

src/video_core/host_shaders/block_linear_unswizzle_2d.comp

@@ -1,4 +1,4 @@
-// Copyright 2019 yuzu Emulator Project
+// Copyright 2020 yuzu Emulator Project
 // Licensed under GPLv2 or any later version
 // Refer to the license.txt file included.
 

src/video_core/renderer_opengl/gl_rasterizer.cpp

@@ -734,7 +734,6 @@ void RasterizerOpenGL::InvalidateTextureCache(VAddr addr, u64 size) {
     if (addr == 0 || size == 0) {
         return;
     }
-    auto lock = texture_cache.AcquireLock();
     texture_cache.UnmapMemory(addr, size);
 }
 

src/video_core/renderer_opengl/gl_texture_cache.cpp

@@ -354,7 +354,7 @@ void ApplySwizzle(GLuint handle, PixelFormat format, std::array<SwizzleSource, 4
         };
     default:
         UNIMPLEMENTED_MSG("Unimplemented copy target={}", target);
-        return CopyOrigin{.x = 0, .y = 0, .z = 0};
+        return CopyOrigin{.level = 0, .x = 0, .y = 0, .z = 0};
     }
 }
 

src/video_core/renderer_opengl/util_shaders.cpp

@@ -114,7 +114,6 @@ void UtilShaders::BlockLinearUpload3D(Image& image, const ImageBufferMap& map, s
 
     const GLenum store_format = StoreFormat(BytesPerBlock(image.info.format));
     for (const SwizzleParameters& swizzle : swizzles) {
-        const Extent3D block = swizzle.block;
         const Extent3D num_tiles = swizzle.num_tiles;
         const size_t input_offset = swizzle.buffer_offset + buffer_offset;
 

src/video_core/renderer_vulkan/vk_rasterizer.cpp

@@ -657,7 +657,7 @@ void RasterizerVulkan::FlushRegion(VAddr addr, u64 size) {
     query_cache.FlushRegion(addr, size);
 }
 
-void RasterizerVulkan::InvalidateExceptTextureCache(VAddr addr, u64 size) {
+void Vulkan::RasterizerVulkan::InvalidateExceptTextureCache(VAddr addr, u64 size) {
     if (addr == 0 || size == 0) {
         return;
     }
@@ -666,11 +666,10 @@ void RasterizerVulkan::InvalidateExceptTextureCache(VAddr addr, u64 size) {
     query_cache.InvalidateRegion(addr, size);
 }
 
-void RasterizerVulkan::InvalidateTextureCache(VAddr addr, u64 size) {
+void Vulkan::RasterizerVulkan::InvalidateTextureCache(VAddr addr, u64 size) {
     if (addr == 0 || size == 0) {
         return;
     }
-    auto lock = texture_cache.AcquireLock();
     texture_cache.UnmapMemory(addr, size);
 }
 

src/video_core/renderer_vulkan/vk_rasterizer.h

@@ -51,11 +51,6 @@ struct VKScreenInfo;
 class StateTracker;
 class BufferBindings;
 
-struct Transition {
-    ImageView* view;
-    VkImageLayout* layout;
-};
-
 class RasterizerVulkan final : public VideoCore::RasterizerAccelerated {
 public:
     explicit RasterizerVulkan(Core::Frontend::EmuWindow& emu_window_, Tegra::GPU& gpu_,

src/video_core/texture_cache/formatter.cpp

@@ -6,6 +6,10 @@
 #include <string>
 
 #include "video_core/texture_cache/formatter.h"
+#include "video_core/texture_cache/image_base.h"
+#include "video_core/texture_cache/image_info.h"
+#include "video_core/texture_cache/image_view_base.h"
+#include "video_core/texture_cache/render_targets.h"
 
 namespace VideoCommon {
 

src/video_core/texture_cache/formatter.h

@@ -8,7 +8,8 @@
 
 #include <fmt/format.h>
 
-#include "video_core/texture_cache/texture_cache.h"
+#include "video_core/surface.h"
+#include "video_core/texture_cache/types.h"
 
 template <>
 struct fmt::formatter<VideoCore::Surface::PixelFormat> : fmt::formatter<fmt::string_view> {

src/video_core/texture_cache/util.cpp

@@ -40,10 +40,12 @@
 #include "common/div_ceil.h"
 #include "video_core/compatible_formats.h"
 #include "video_core/engines/maxwell_3d.h"
+#include "video_core/memory_manager.h"
 #include "video_core/surface.h"
 #include "video_core/texture_cache/decode_bc4.h"
 #include "video_core/texture_cache/format_lookup_table.h"
 #include "video_core/texture_cache/formatter.h"
+#include "video_core/texture_cache/samples_helper.h"
 #include "video_core/texture_cache/util.h"
 #include "video_core/textures/astc.h"
 #include "video_core/textures/decoders.h"

src/yuzu/main.cpp

@@ -292,12 +292,48 @@ GMainWindow::GMainWindow()
     connect(&mouse_hide_timer, &QTimer::timeout, this, &GMainWindow::HideMouseCursor);
     connect(ui.menubar, &QMenuBar::hovered, this, &GMainWindow::ShowMouseCursor);
 
+    MigrateConfigFiles();
+
+    ui.action_Fullscreen->setChecked(false);
+
     QStringList args = QApplication::arguments();
-    if (args.length() >= 2) {
+
-        BootGame(args[1]);
+    if (args.size() < 2) {
+        return;
     }
 
-    MigrateConfigFiles();
+    QString game_path;
+
+    for (int i = 1; i < args.size(); ++i) {
+        // Preserves drag/drop functionality
+        if (args.size() == 2 && !args[1].startsWith(QChar::fromLatin1('-'))) {
+            game_path = args[1];
+            break;
+        }
+
+        // Launch game in fullscreen mode
+        if (args[i] == QStringLiteral("-f")) {
+            ui.action_Fullscreen->setChecked(true);
+            continue;
+        }
+
+        // Launch game at path
+        if (args[i] == QStringLiteral("-g")) {
+            if (i >= args.size() - 1) {
+                continue;
+            }
+
+            if (args[i + 1].startsWith(QChar::fromLatin1('-'))) {
+                continue;
+            }
+
+            game_path = args[++i];
+        }
+    }
+
+    if (!game_path.isEmpty()) {
+        BootGame(game_path);
+    }
 }
 
 GMainWindow::~GMainWindow() {