Android #149

texture_cache: use pedantic type names

README.md

@@ -1,3 +1,13 @@
+| Pull Request | Commit | Title | Author | Merged? |
+|----|----|----|----|----|
+| [12235](https://github.com/yuzu-emu/yuzu//pull/12235) | [`e7dd968ac`](https://github.com/yuzu-emu/yuzu//pull/12235/files) | renderer_vulkan: adjust window origin and swizzle independently | [liamwhite](https://github.com/liamwhite/) | Yes |
+| [12263](https://github.com/yuzu-emu/yuzu//pull/12263) | [`45b616158`](https://github.com/yuzu-emu/yuzu//pull/12263/files) | file_sys: handle null romfs | [liamwhite](https://github.com/liamwhite/) | Yes |
+
+
+End of merge log. You can find the original README.md below the break.
+
+-----
+
 <!--
 SPDX-FileCopyrightText: 2018 yuzu Emulator Project
 SPDX-License-Identifier: GPL-2.0-or-later

src/android/app/src/main/jni/native.cpp

@@ -123,9 +123,6 @@ int EmulationSession::InstallFileToNand(std::string filename, std::string file_e
         ErrorFilenameExtension = 4,
     };
 
-    m_system.SetContentProvider(std::make_unique<FileSys::ContentProviderUnion>());
-    m_system.GetFileSystemController().CreateFactories(*m_vfs);
-
     [[maybe_unused]] std::shared_ptr<FileSys::NSP> nsp;
     if (file_extension == "nsp") {
         nsp = std::make_shared<FileSys::NSP>(m_vfs->OpenFile(filename, FileSys::Mode::Read));

src/common/host_memory.cpp

@@ -25,6 +25,10 @@
 #include <unistd.h>
 #include "common/scope_exit.h"
 
+#ifndef MAP_NORESERVE
+#define MAP_NORESERVE 0
+#endif
+
 #endif // ^^^ Linux ^^^
 
 #include <mutex>
@@ -404,6 +408,16 @@ static void* ChooseVirtualBase(size_t virtual_size) {
 #else
 
 static void* ChooseVirtualBase(size_t virtual_size) {
+#if defined(__FreeBSD__)
+    void* virtual_base =
+        mmap(nullptr, virtual_size, PROT_READ | PROT_WRITE,
+             MAP_PRIVATE | MAP_ANONYMOUS | MAP_NORESERVE | MAP_ALIGNED_SUPER, -1, 0);
+
+    if (virtual_base != MAP_FAILED) {
+        return virtual_base;
+    }
+#endif
+
     return mmap(nullptr, virtual_size, PROT_READ | PROT_WRITE,
                 MAP_PRIVATE | MAP_ANONYMOUS | MAP_NORESERVE, -1, 0);
 }
@@ -459,24 +473,12 @@ public:
         }
 
         // Virtual memory initialization
-#if defined(__FreeBSD__)
-        virtual_base =
-            static_cast<u8*>(mmap(nullptr, virtual_size, PROT_NONE,
-                                  MAP_PRIVATE | MAP_ANONYMOUS | MAP_ALIGNED_SUPER, -1, 0));
-        if (virtual_base == MAP_FAILED) {
-            virtual_base = static_cast<u8*>(
-                mmap(nullptr, virtual_size, PROT_NONE, MAP_PRIVATE | MAP_ANONYMOUS, -1, 0));
-            if (virtual_base == MAP_FAILED) {
-                LOG_CRITICAL(HW_Memory, "mmap failed: {}", strerror(errno));
-                throw std::bad_alloc{};
-            }
-        }
-#else
         virtual_base = virtual_map_base = static_cast<u8*>(ChooseVirtualBase(virtual_size));
         if (virtual_base == MAP_FAILED) {
             LOG_CRITICAL(HW_Memory, "mmap failed: {}", strerror(errno));
             throw std::bad_alloc{};
         }
+#if defined(__linux__)
         madvise(virtual_base, virtual_size, MADV_HUGEPAGE);
 #endif
 

src/core/file_sys/patch_manager.cpp

@@ -429,10 +429,6 @@ VirtualFile PatchManager::PatchRomFS(const NCA* base_nca, VirtualFile base_romfs
         LOG_DEBUG(Loader, "{}", log_string);
     }
 
-    if (base_romfs == nullptr) {
-        return base_romfs;
-    }
-
     auto romfs = base_romfs;
 
     // Game Updates

src/core/file_sys/romfs.cpp

@@ -3,6 +3,7 @@
 
 #include <memory>
 
+#include "common/assert.h"
 #include "common/common_types.h"
 #include "common/string_util.h"
 #include "common/swap.h"
@@ -101,24 +102,30 @@ void ProcessDirectory(const VirtualFile& file, std::size_t dir_offset, std::size
 } // Anonymous namespace
 
 VirtualDir ExtractRomFS(VirtualFile file) {
-    RomFSHeader header{};
+    auto root_container = std::make_shared<VectorVfsDirectory>();
-    if (file->ReadObject(&header) != sizeof(RomFSHeader))
+    if (!file) {
-        return nullptr;
+        return root_container;
+    }
 
-    if (header.header_size != sizeof(RomFSHeader))
+    RomFSHeader header{};
-        return nullptr;
+    if (file->ReadObject(&header) != sizeof(RomFSHeader)) {
+        return root_container;
+    }
+
+    if (header.header_size != sizeof(RomFSHeader)) {
+        return root_container;
+    }
 
     const u64 file_offset = header.file_meta.offset;
     const u64 dir_offset = header.directory_meta.offset;
 
-    auto root_container = std::make_shared<VectorVfsDirectory>();
-
     ProcessDirectory(file, dir_offset, file_offset, header.data_offset, 0, root_container);
 
     if (auto root = root_container->GetSubdirectory(""); root) {
         return std::make_shared<CachedVfsDirectory>(std::move(root));
     }
 
+    ASSERT(false);
     return nullptr;
 }
 

src/core/file_sys/romfs_factory.cpp

@@ -22,7 +22,7 @@ RomFSFactory::RomFSFactory(Loader::AppLoader& app_loader, ContentProvider& provi
     : content_provider{provider}, filesystem_controller{controller} {
     // Load the RomFS from the app
     if (app_loader.ReadRomFS(file) != Loader::ResultStatus::Success) {
-        LOG_ERROR(Service_FS, "Unable to read RomFS!");
+        LOG_WARNING(Service_FS, "Unable to read base RomFS");
     }
 
     updatable = app_loader.IsRomFSUpdatable();

src/core/loader/nca.cpp

@@ -74,10 +74,8 @@ AppLoader_NCA::LoadResult AppLoader_NCA::Load(Kernel::KProcess& process, Core::S
         return load_result;
     }
 
-    if (nca->GetRomFS() != nullptr && nca->GetRomFS()->GetSize() > 0) {
+    system.GetFileSystemController().RegisterRomFS(std::make_unique<FileSys::RomFSFactory>(
-        system.GetFileSystemController().RegisterRomFS(std::make_unique<FileSys::RomFSFactory>(
+        *this, system.GetContentProvider(), system.GetFileSystemController()));
-            *this, system.GetContentProvider(), system.GetFileSystemController()));
-    }
 
     is_loaded = true;
     return load_result;

src/video_core/renderer_vulkan/vk_blit_screen.cpp

@@ -1211,7 +1211,7 @@ void BlitScreen::CreateRawImages(const Tegra::FramebufferConfig& framebuffer) {
         aa_framebuffer = CreateFramebuffer(*aa_image_view, size, aa_renderpass);
         return;
     }
-    aa_renderpass = CreateRenderPassImpl(GetFormat(framebuffer));
+    aa_renderpass = CreateRenderPassImpl(VK_FORMAT_R16G16B16A16_SFLOAT);
     aa_framebuffer = CreateFramebuffer(*aa_image_view, size, aa_renderpass);
 
     const std::array<VkPipelineShaderStageCreateInfo, 2> fxaa_shader_stages{{

src/video_core/renderer_vulkan/vk_rasterizer.cpp

@@ -75,14 +75,20 @@ VkViewport GetViewportState(const Device& device, const Maxwell& regs, size_t in
     const float width = conv(src.scale_x * 2.0f);
     float y = conv(src.translate_y - src.scale_y);
     float height = conv(src.scale_y * 2.0f);
-    bool y_negate = regs.window_origin.mode != Maxwell::WindowOrigin::Mode::UpperLeft;
 
-    if (!device.IsNvViewportSwizzleSupported()) {
+    const bool lower_left = regs.window_origin.mode != Maxwell::WindowOrigin::Mode::UpperLeft;
-        y_negate = y_negate != (src.swizzle.y == Maxwell::ViewportSwizzle::NegativeY);
+    const bool y_negate = !device.IsNvViewportSwizzleSupported() &&
+                          src.swizzle.y == Maxwell::ViewportSwizzle::NegativeY;
+
+    if (lower_left) {
+        // Flip by surface clip height
+        y += conv(static_cast<f32>(regs.surface_clip.height));
+        height = -height;
     }
 
     if (y_negate) {
-        y += conv(static_cast<f32>(regs.surface_clip.height));
+        // Flip by viewport height
+        y += height;
         height = -height;
     }
 

src/video_core/renderer_vulkan/vk_texture_cache.cpp

@@ -1439,7 +1439,7 @@ void Image::UploadMemory(const StagingBufferRef& map, std::span<const BufferImag
     UploadMemory(map.buffer, map.offset, copies);
 }
 
-void Image::DownloadMemory(VkBuffer buffer, VkDeviceSize offset,
+void Image::DownloadMemory(VkBuffer buffer, size_t offset,
                            std::span<const VideoCommon::BufferImageCopy> copies) {
     std::array buffer_handles{
         buffer,
@@ -1450,7 +1450,7 @@ void Image::DownloadMemory(VkBuffer buffer, VkDeviceSize offset,
     DownloadMemory(buffer_handles, buffer_offsets, copies);
 }
 
-void Image::DownloadMemory(std::span<VkBuffer> buffers_span, std::span<VkDeviceSize> offsets_span,
+void Image::DownloadMemory(std::span<VkBuffer> buffers_span, std::span<size_t> offsets_span,
                            std::span<const VideoCommon::BufferImageCopy> copies) {
     const bool is_rescaled = True(flags & ImageFlagBits::Rescaled);
     if (is_rescaled) {
@@ -1530,7 +1530,7 @@ void Image::DownloadMemory(const StagingBufferRef& map, std::span<const BufferIm
         map.buffer,
     };
     std::array offsets{
-        map.offset,
+        static_cast<size_t>(map.offset),
     };
     DownloadMemory(buffers, offsets, copies);
 }

src/video_core/renderer_vulkan/vk_texture_cache.h

@@ -147,10 +147,10 @@ public:
     void UploadMemory(const StagingBufferRef& map,
                       std::span<const VideoCommon::BufferImageCopy> copies);
 
-    void DownloadMemory(VkBuffer buffer, VkDeviceSize offset,
+    void DownloadMemory(VkBuffer buffer, size_t offset,
                         std::span<const VideoCommon::BufferImageCopy> copies);
 
-    void DownloadMemory(std::span<VkBuffer> buffers, std::span<VkDeviceSize> offsets,
+    void DownloadMemory(std::span<VkBuffer> buffers, std::span<size_t> offsets,
                         std::span<const VideoCommon::BufferImageCopy> copies);
 
     void DownloadMemory(const StagingBufferRef& map,

src/video_core/texture_cache/texture_cache.h

@@ -995,7 +995,7 @@ void TextureCache<P>::DownloadImageIntoBuffer(typename TextureCache<P>::Image* i
             buffer,
             download_map.buffer,
         };
-        std::array<u64, 2> buffer_offsets{
+        std::array<size_t, 2> buffer_offsets{
             buffer_offset,
             download_map.offset,
         };

src/yuzu/main.cpp

@@ -2713,11 +2713,6 @@ void GMainWindow::OnGameListDumpRomFS(u64 program_id, const std::string& game_pa
     }
 
     const auto base_romfs = base_nca->GetRomFS();
-    if (!base_romfs) {
-        failed();
-        return;
-    }
-
     const auto dump_dir =
         target == DumpRomFSTarget::Normal
             ? Common::FS::GetYuzuPath(Common::FS::YuzuPath::DumpDir)