crysis fix

CMakeModules/find/Findlz4.cmake

@@ -24,7 +24,7 @@ else()
 endif()
 
 if (lz4_FOUND AND NOT TARGET lz4::lz4)
-    if (TARGET LZ4::lz4_shared AND NOT YUZU_STATIC_BUILD)
+    if (TARGET LZ4::lz4_shared)
         add_library(lz4::lz4 ALIAS LZ4::lz4_shared)
     elseif (TARGET LZ4::lz4_static)
         add_library(lz4::lz4 ALIAS LZ4::lz4_static)

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

@@ -100,7 +100,7 @@ class Game(
 
     companion object {
         val extensions: Set<String> = HashSet(
-            listOf("xci", "nsp", "nca", "nro", "nsz", "xcz")
+            listOf("xci", "nsp", "nca", "nro")
         )
     }
 }

src/android/app/src/main/java/org/yuzu/yuzu_emu/utils/GameHelper.kt

@@ -109,7 +109,7 @@ object GameHelper {
 
     // File extensions considered as external content, buuut should
     // be done better imo.
-    private val externalContentExtensions = setOf("nsp", "xci", "nsz", "xcz")
+    private val externalContentExtensions = setOf("nsp", "xci")
 
     private fun scanContentContainersRecursive(
         files: Array<MinimalDocumentFile>,

src/common/zstd_compression.cpp

@@ -1,6 +1,3 @@
-// SPDX-FileCopyrightText: Copyright 2026 Eden Emulator Project
-// SPDX-License-Identifier: GPL-3.0-or-later
-
 // SPDX-FileCopyrightText: Copyright 2019 yuzu Emulator Project
 // SPDX-License-Identifier: GPL-2.0-or-later
 
@@ -49,10 +46,4 @@ std::vector<u8> DecompressDataZSTD(std::span<const u8> compressed) {
     return decompressed;
 }
 
-std::size_t DecompressDataZSTD(std::span<const u8> compressed, std::span<u8> output) {
-    const std::size_t result =
-        ZSTD_decompress(output.data(), output.size(), compressed.data(), compressed.size());
-    return ZSTD_isError(result) ? 0 : result;
-}
-
 } // namespace Common::Compression

src/common/zstd_compression.h

@@ -1,6 +1,3 @@
-// SPDX-FileCopyrightText: Copyright 2026 Eden Emulator Project
-// SPDX-License-Identifier: GPL-3.0-or-later
-
 // SPDX-FileCopyrightText: Copyright 2019 yuzu Emulator Project
 // SPDX-License-Identifier: GPL-2.0-or-later
 
@@ -45,15 +42,4 @@ namespace Common::Compression {
  */
 [[nodiscard]] std::vector<u8> DecompressDataZSTD(std::span<const u8> compressed);
 
-/**
- * Decompresses a single Zstandard frame into a caller-provided buffer of known size.
- *
- * @param compressed the compressed source memory region.
- * @param output     the destination buffer. Its size is the maximum number of bytes to write.
- *
- * @return the number of bytes written, or 0 if the frame is invalid or doesn't fit. An empty
- *         frame also returns 0.
- */
-[[nodiscard]] std::size_t DecompressDataZSTD(std::span<const u8> compressed, std::span<u8> output);
-
 } // namespace Common::Compression

src/core/CMakeLists.txt

@@ -33,8 +33,6 @@ add_library(core STATIC
     crypto/encryption_layer.h
     crypto/key_manager.cpp
     crypto/key_manager.h
-    crypto/ncz_decompressor.cpp
-    crypto/ncz_decompressor.h
     crypto/partition_data_manager.cpp
     crypto/partition_data_manager.h
     crypto/xts_encryption_layer.cpp

src/core/crypto/ncz_decompressor.cpp

@@ -1,279 +0,0 @@
-// SPDX-FileCopyrightText: Copyright 2026 Eden Emulator Project
-// SPDX-License-Identifier: GPL-3.0-or-later
-
-#include <algorithm>
-#include <array>
-#include <cstring>
-#include <memory>
-#include <mutex>
-#include <optional>
-#include <span>
-#include <string>
-#include <vector>
-
-#include "common/common_types.h"
-#include "common/logging.h"
-#include "common/zstd_compression.h"
-#include "core/crypto/aes_util.h"
-#include "core/crypto/key_manager.h"
-#include "core/crypto/ncz_decompressor.h"
-#include "core/file_sys/vfs/vfs.h"
-
-namespace Core::Crypto {
-
-namespace {
-
-constexpr u64 HeaderSize = 0x4000;
-constexpr std::size_t SectionWire = 0x40;
-constexpr std::size_t BlockFixed = 0x18;
-constexpr std::array<u8, 8> SectionsMagic{'N', 'C', 'Z', 'S', 'E', 'C', 'T', 'N'};
-constexpr std::array<u8, 8> BlockMagic{'N', 'C', 'Z', 'B', 'L', 'O', 'C', 'K'};
-
-struct Section {
-    s64 offset, size;
-    u64 crypto_type;
-    Key128 key, counter;
-    bool Ctr() const { return crypto_type == 3 || crypto_type == 4; }
-};
-
-struct BlockHeader {
-    u32 exponent;
-    u64 decompressed_size;
-    std::vector<u32> sizes;
-};
-
-u64 Le(const u8* p, std::size_t n) {
-    u64 v = 0;
-    for (std::size_t i = n; i-- > 0;) v = (v << 8) | p[i];
-    return v;
-}
-
-// Mirrors nsz AESCTR.seek(): upper 8 bytes = stored counter, lower 8 = absolute NCA offset / 16.
-void SetIv(Key128& iv, const Key128& base, u64 off) {
-    iv = base;
-    u64 blk = off >> 4;
-    for (std::size_t i = 0; i < 8; ++i) { iv[15 - i] = static_cast<u8>(blk & 0xFF); blk >>= 8; }
-}
-
-// Parse header + section table + optional block header. Returns payload_start.
-std::optional<std::pair<std::vector<Section>, std::optional<BlockHeader>>> ParseHeader(
-    const FileSys::VirtualFile& f, u64& payload_start) {
-    const u64 fsize = f->GetSize();
-    if (fsize < HeaderSize + 16) return std::nullopt;
-
-    const auto head = f->ReadBytes(16, HeaderSize);
-    if (head.size() != 16 || !std::equal(head.begin(), head.begin() + 8, SectionsMagic.begin()))
-        return std::nullopt;
-    const u64 count = Le(head.data() + 8, 8);
-    if (count == 0 || count > 64 || count * SectionWire > fsize - HeaderSize - 16)
-        return std::nullopt;
-
-    const auto table = f->ReadBytes(count * SectionWire, HeaderSize + 16);
-    if (table.size() != count * SectionWire) return std::nullopt;
-
-    std::vector<Section> sections;
-    sections.reserve(count + 1);
-    for (u64 i = 0; i < count; ++i) {
-        const u8* e = table.data() + i * SectionWire;
-        Section s{};
-        s.offset = static_cast<s64>(Le(e, 8));
-        s.size = static_cast<s64>(Le(e + 8, 8));
-        s.crypto_type = Le(e + 16, 8);
-        std::memcpy(s.key.data(), e + 32, 16);
-        std::memcpy(s.counter.data(), e + 48, 16);
-        sections.push_back(s);
-    }
-
-    const u64 block_start = HeaderSize + 16 + count * SectionWire;
-    const auto fixed = f->ReadBytes(BlockFixed, block_start);
-    std::optional<BlockHeader> bh;
-    if (fixed.size() == BlockFixed &&
-        std::equal(fixed.begin(), fixed.begin() + 8, BlockMagic.begin())) {
-        BlockHeader b{};
-        b.exponent = fixed[11];
-        const s32 n = static_cast<s32>(Le(fixed.data() + 12, 4));
-        if (n <= 0) return std::nullopt;
-        b.decompressed_size = Le(fixed.data() + 16, 8);
-        const auto sizes = f->ReadBytes(static_cast<u64>(n) * 4, block_start + BlockFixed);
-        if (sizes.size() != static_cast<u64>(n) * 4) return std::nullopt;
-        b.sizes.resize(n);
-        for (s32 i = 0; i < n; ++i) b.sizes[i] = static_cast<u32>(Le(sizes.data() + i * 4, 4));
-        payload_start = block_start + BlockFixed + static_cast<u64>(n) * 4;
-        bh = std::move(b);
-    } else {
-        payload_start = block_start;
-    }
-
-    if (!sections.empty() && sections[0].offset > static_cast<s64>(HeaderSize)) {
-        Section fake{};
-        fake.offset = static_cast<s64>(HeaderSize);
-        fake.size = sections[0].offset - static_cast<s64>(HeaderSize);
-        sections.insert(sections.begin(), fake);
-    }
-    return std::make_pair(std::move(sections), std::move(bh));
-}
-
-// Sequential reader over independently-compressed blocks, one block cached (like nsz_rs).
-class BlockReader {
-public:
-    BlockReader(FileSys::VirtualFile f, const BlockHeader& bh, u64 payload_start)
-        : source{std::move(f)}, block_size{1ULL << bh.exponent}, sizes{bh.sizes},
-          decompressed_size{bh.decompressed_size} {
-        if (bh.exponent < 14 || bh.exponent > 32 || sizes.empty())
-            throw std::runtime_error("bad NCZBLOCK header");
-        u64 off = payload_start;
-        offsets.reserve(sizes.size());
-        for (u32 s : sizes) { offsets.push_back(off); off += s; }
-    }
-
-    // Fills `out` from `position`; returns bytes written.
-    std::size_t ReadAt(u64 position, std::span<u8> out) {
-        std::size_t done = 0;
-        while (done < out.size() && position < decompressed_size) {
-            const u64 id = position / block_size;
-            if (id >= sizes.size()) break;
-            if (cache_id != id && !Load(id)) break;
-            const u64 in = position - id * block_size;
-            const std::size_t n = static_cast<std::size_t>(
-                std::min<u64>(out.size() - done, cache.size() - in));
-            std::memcpy(out.data() + done, cache.data() + in, n);
-            done += n;
-            position += n;
-        }
-        return done;
-    }
-
-private:
-    bool Load(u64 id) {
-        u64 want = block_size;
-        if (id + 1 == sizes.size()) {
-            const u64 rem = decompressed_size % block_size;
-            if (rem > 0) want = rem; // avoid the 0-size bug from the original nsz
-        }
-        try { cache.resize(static_cast<std::size_t>(want)); }
-        catch (const std::bad_alloc&) { return false; }
-        const u32 csize = sizes[id];
-        if (csize < want) {
-            const auto comp = source->ReadBytes(csize, offsets[id]);
-            if (comp.size() != csize ||
-                Common::Compression::DecompressDataZSTD(comp, cache) != want) return false;
-        } else if (source->Read(cache.data(), cache.size(), offsets[id]) != cache.size()) {
-            return false;
-        }
-        cache_id = id;
-        return true;
-    }
-
-    FileSys::VirtualFile source;
-    u64 block_size;
-    std::vector<u64> offsets;
-    std::vector<u32> sizes;
-    u64 decompressed_size;
-    u64 cache_id = ~0ULL;
-    std::vector<u8> cache;
-};
-
-class BlockNczFile final : public FileSys::VfsFile {
-public:
-    BlockNczFile(std::string name_, std::vector<u8> hdr_, std::vector<Section> sections_,
-                 std::unique_ptr<BlockReader> body_)
-        : name{std::move(name_)}, hdr{std::move(hdr_)}, sections{std::move(sections_)},
-          body{std::move(body_)} {
-        nca_size = HeaderSize;
-        for (const auto& s : sections)
-            nca_size = std::max<u64>(nca_size, static_cast<u64>(s.offset + s.size));
-        ciphers.reserve(sections.size());
-        for (const auto& s : sections)
-            ciphers.push_back(s.Ctr() ? std::make_unique<AESCipher<Key128>>(s.key, Mode::CTR)
-                                      : nullptr);
-    }
-
-    std::string GetName() const override { return name; }
-    std::size_t GetSize() const override { return static_cast<std::size_t>(nca_size); }
-    bool Resize(std::size_t) override { return false; }
-    FileSys::VirtualDir GetContainingDirectory() const override { return nullptr; }
-    bool IsWritable() const override { return false; }
-    bool IsReadable() const override { return true; }
-
-    std::size_t Read(u8* data, std::size_t len, std::size_t off) const override {
-        if (off >= nca_size) return 0;
-        len = static_cast<std::size_t>(std::min<u64>(len, nca_size - off));
-        const u64 end = off + len;
-        u64 pos = off;
-        if (pos < HeaderSize) {
-            const u64 n = std::min<u64>(end, HeaderSize) - pos;
-            std::memcpy(data, hdr.data() + pos, static_cast<std::size_t>(n));
-            pos += n;
-        }
-        std::scoped_lock lock{mutex};
-        for (std::size_t i = 0; i < sections.size() && pos < end; ++i) {
-            const auto& s = sections[i];
-            const u64 begin = std::max<u64>(static_cast<u64>(s.offset), HeaderSize);
-            const u64 stop = std::max<u64>(static_cast<u64>(s.offset + s.size), begin);
-            if (stop <= pos) continue;
-            if (pos < begin) {
-                const u64 g = std::min(end, begin);
-                std::memset(data + (pos - off), 0, static_cast<std::size_t>(g - pos));
-                pos = g;
-                if (pos >= end) break;
-            }
-            const u64 pe = std::min(end, stop);
-            const std::span<u8> piece(data + (pos - off), static_cast<std::size_t>(pe - pos));
-            if (body->ReadAt(pos - HeaderSize, piece) != piece.size())
-                return static_cast<std::size_t>(pos - off);
-            if (ciphers[i]) {
-                Key128 iv{};
-                SetIv(iv, s.counter, pos);
-                ciphers[i]->SetIV(iv);
-                ciphers[i]->Transcode(piece.data(), piece.size(), piece.data(), Op::Encrypt);
-            }
-            pos = pe;
-        }
-        return len;
-    }
-
-    std::size_t Write(const u8*, std::size_t, std::size_t) override { return 0; }
-    bool Rename(std::string_view) override { return false; }
-
-private:
-    const std::string name;
-    const std::vector<u8> hdr;
-    const std::vector<Section> sections;
-    const std::unique_ptr<BlockReader> body;
-    std::vector<std::unique_ptr<AESCipher<Key128>>> ciphers;
-    mutable std::mutex mutex;
-    u64 nca_size{};
-};
-
-} // Anonymous namespace
-
-bool IsBlockCompressedNCZ(const FileSys::VirtualFile& f) {
-    if (!f) return false;
-    u64 ps = 0;
-    const auto p = ParseHeader(f, ps);
-    return p && p->second.has_value();
-}
-
-FileSys::VirtualFile DecompressNCZ(const FileSys::VirtualFile& f, std::string_view name) {
-    if (!f) return nullptr;
-    u64 ps = 0;
-    auto parsed = ParseHeader(f, ps);
-    if (!parsed) return nullptr;
-    auto& [sections, block] = *parsed;
-    if (!block) {
-        LOG_ERROR(Crypto, "Solid NCZ is not supported (only NCZBLOCK / nsz -B)");
-        return nullptr;
-    }
-    auto hdr = f->ReadBytes(HeaderSize, 0);
-    if (hdr.size() != HeaderSize) return nullptr;
-    std::unique_ptr<BlockReader> body;
-    try { body = std::make_unique<BlockReader>(f, *block, ps); }
-    catch (const std::exception& e) {
-        LOG_ERROR(Crypto, "Failed to open NCZBLOCK: {}", e.what());
-        return nullptr;
-    }
-    return std::make_shared<BlockNczFile>(std::string{name}, std::move(hdr),
-                                          std::move(sections), std::move(body));
-}
-
-} // namespace Core::Crypto

src/core/crypto/ncz_decompressor.h

@@ -1,31 +0,0 @@
-// SPDX-FileCopyrightText: Copyright 2026 Eden Emulator Project
-// SPDX-License-Identifier: GPL-3.0-or-later
-
-#pragma once
-
-#include <string_view>
-
-#include "core/file_sys/vfs/vfs_types.h"
-
-namespace Core::Crypto {
-
-/**
- * Opens an NCZBLOCK-compressed NCA (nsz -B / .xcz block format) as a VirtualFile backed by
- * on-demand block decoding. Nothing is written to disk; each read decodes only the blocks it
- * covers and re-encrypts CTR sections. Solid NCZ is not supported.
- *
- * @param ncz_file    The raw NCZ payload (e.g. "<id>.ncz" entry from an NSZ/XCZ PFS0).
- * @param output_name Name to give the returned VirtualFile (e.g. "<id>.nca").
- *
- * @return a VirtualFile for the NCA, or nullptr if the NCZ is malformed or not NCZBLOCK.
- */
-[[nodiscard]] FileSys::VirtualFile DecompressNCZ(const FileSys::VirtualFile& ncz_file,
-                                                 std::string_view output_name);
-
-/**
- * Returns true if the given file is an NCZ payload in block-compressed (NCZBLOCK) form,
- * i.e. one that DecompressNCZ() can open. Solid NCZ returns false.
- */
-[[nodiscard]] bool IsBlockCompressedNCZ(const FileSys::VirtualFile& ncz_file);
-
-} // namespace Core::Crypto

src/core/file_sys/registered_cache.cpp

@@ -16,7 +16,6 @@
 #include "common/random.h"
 #include "common/string_util.h"
 #include "core/crypto/key_manager.h"
-#include "core/crypto/ncz_decompressor.h"
 #include "core/file_sys/card_image.h"
 #include "core/file_sys/common_funcs.h"
 #include "core/file_sys/content_archive.h"
@@ -159,25 +158,6 @@ static std::shared_ptr<NSP> OpenContainerAsNsp(const VirtualFile& file, Loader::
     return nullptr;
 }
 
-// Checks that every .ncz entry in the container is NCZBLOCK. Solid NCZ has no random access,
-// and the whole point of this build is to reject it at scan time so such files never appear
-// in the game list. Containers without any .ncz (plain NSP/XCI) pass through.
-static bool ContainerIsFullyBlockCompressed(const std::shared_ptr<NSP>& nsp) {
-    if (!nsp) {
-        return false;
-    }
-    for (const auto& entry : nsp->GetFiles()) {
-        const auto name = entry->GetName();
-        if (name.size() < 4 || name.substr(name.size() - 4) != ".ncz") {
-            continue;
-        }
-        if (!Core::Crypto::IsBlockCompressedNCZ(entry)) {
-            return false; // solid NCZ -> reject the whole container
-        }
-    }
-    return true; // no .ncz at all, or all block-compressed
-}
-
 template <typename Callback>
 bool ForEachContainerEntry(const std::shared_ptr<NSP>& nsp, bool only_content,
                            std::optional<u64> base_program_id, Callback&& on_entry) {
@@ -1293,12 +1273,6 @@ bool ManualContentProvider::AddEntriesFromContainer(VirtualFile file, bool only_
         return false;
     }
 
-    // Reject solid NCZ (.nsz without -B): only block-compressed NCZ is supported.
-    if (!ContainerIsFullyBlockCompressed(nsp)) {
-        LOG_DEBUG(Service_FS, "Skipping solid-compressed container: {}", file->GetName());
-        return false;
-    }
-
     return ForEachContainerEntry(
         nsp, only_content, base_program_id,
         [this](TitleType title_type, ContentRecordType content_type, u64 title_id,
@@ -1460,12 +1434,6 @@ void ExternalContentProvider::ProcessNSP(const VirtualFile& file) {
         return;
     }
 
-    // Reject solid NCZ (.nsz without -B): Eden only supports block-compressed NCZ.
-    if (!ContainerIsFullyBlockCompressed(nsp)) {
-        LOG_DEBUG(Service_FS, "Skipping solid-compressed container: {}", file->GetName());
-        return;
-    }
-
     LOG_DEBUG(Service_FS, "Processing NSP file: {}", file->GetName());
     AddExternalEntriesFromContainer(nsp, entries, versions, multi_version_entries);
 }
@@ -1476,11 +1444,6 @@ void ExternalContentProvider::ProcessXCI(const VirtualFile& file) {
         return;
     }
 
-    if (!ContainerIsFullyBlockCompressed(nsp)) {
-        LOG_DEBUG(Service_FS, "Skipping solid-compressed container: {}", file->GetName());
-        return;
-    }
-
     AddExternalEntriesFromContainer(nsp, entries, versions, multi_version_entries);
 }
 

src/core/file_sys/submission_package.cpp

@@ -12,7 +12,6 @@
 #include "common/hex_util.h"
 #include "common/logging.h"
 #include "core/crypto/key_manager.h"
-#include "core/crypto/ncz_decompressor.h"
 #include "core/file_sys/common_funcs.h"
 #include "core/file_sys/content_archive.h"
 #include "core/file_sys/nca_metadata.h"
@@ -247,18 +246,6 @@ void NSP::ReadNCAs(const std::vector<VirtualFile>& files) {
                 const auto id_string = Common::HexToString(rec.nca_id, false);
                 auto next_file = pfs->GetFile(fmt::format("{}.nca", id_string));
 
-                if (next_file == nullptr) {
-                    auto ncz_file = pfs->GetFile(fmt::format("{}.ncz", id_string));
-                    if (ncz_file != nullptr) {
-                        next_file = Core::Crypto::DecompressNCZ(ncz_file, fmt::format("{}.nca", id_string));
-                        if (next_file == nullptr) {
-                            LOG_WARNING(Service_FS, "Skipping unsupported or corrupt NCZ content {}.ncz",
-                                        id_string);
-                            continue;
-                        }
-                    }
-                }
-
                 if (next_file == nullptr) {
                     if (rec.type != ContentRecordType::DeltaFragment) {
                         LOG_WARNING(Service_FS,

src/core/hle/service/sockets/bsd.cpp

@@ -40,6 +40,12 @@ bool IsConnectionBased(Type type) {
     }
 }
 
+// Size of a real BSD sockaddr_in. The guest SockAddrIn struct is padded to 0x100 so that longer
+// input addresses can be read, but an address handed back to the game is always this long.
+// Reporting 0x100 lets a game that trusts the length copy 240 bytes past its 16-byte sockaddr
+// (suspected cause of Crysis Remastered crashing ~30 s after its getsockname() call).
+constexpr size_t GuestSockAddrInSize = 16;
+
 template <typename T>
 T GetValue(std::span<const u8> buffer) {
     T t{};
@@ -655,6 +661,9 @@ std::pair<s32, Errno> BSD_USA::AcceptImpl(s32 fd, std::vector<u8>& write_buffer)
     new_descriptor.is_connection_based = descriptor.is_connection_based;
 
     const SockAddrIn guest_addr_in = Translate(result.sockaddr_in);
+    if (write_buffer.size() > GuestSockAddrInSize) {
+        write_buffer.resize(GuestSockAddrInSize);
+    }
     PutValue(write_buffer, guest_addr_in);
 
     return {new_fd, Errno::SUCCESS};
@@ -714,8 +723,8 @@ Errno BSD_USA::GetPeerNameImpl(s32 fd, std::vector<u8>& write_buffer) {
     }
     const SockAddrIn guest_addrin = Translate(addr_in);
 
-    ASSERT(write_buffer.size() >= sizeof(guest_addrin));
-    write_buffer.resize(sizeof(guest_addrin));
+    // The reported length must be that of a real sockaddr_in, not of the padded guest struct.
+    write_buffer.resize(GuestSockAddrInSize);
     PutValue(write_buffer, guest_addrin);
     return Translate(bsd_errno);
 }
@@ -736,8 +745,8 @@ Errno BSD_USA::GetSockNameImpl(s32 fd, std::vector<u8>& write_buffer) {
     }
     const SockAddrIn guest_addrin = Translate(addr_in);
 
-    ASSERT(write_buffer.size() >= sizeof(guest_addrin));
-    write_buffer.resize(sizeof(guest_addrin));
+    // The reported length must be that of a real sockaddr_in, not of the padded guest struct.
+    write_buffer.resize(GuestSockAddrInSize);
     PutValue(write_buffer, guest_addrin);
     return Translate(bsd_errno);
 }
@@ -949,8 +958,9 @@ std::pair<s32, Errno> BSD_USA::RecvFromImpl(s32 fd, u32 flags, std::vector<u8>&
         if (ret < 0) {
             addr.clear();
         } else {
-            ASSERT(addr.size() >= 16);
+            ASSERT(addr.size() >= GuestSockAddrInSize);
             const SockAddrIn result = Translate(addr_in);
+            addr.resize(GuestSockAddrInSize);
             PutValue(addr, result);
         }
     }

src/core/loader/loader.cpp

@@ -82,12 +82,12 @@ std::shared_ptr<FileSys::NSP> OpenContainerAsNsp(FileSys::VirtualFile file, File
         return nullptr;
     }
 
-    if (type == FileType::NSP || type == FileType::NSZ) {
+    if (type == FileType::NSP) {
         auto nsp = std::make_shared<FileSys::NSP>(file, program_id, program_index);
         return nsp->GetStatus() == ResultStatus::Success ? nsp : nullptr;
     }
 
-    if (type == FileType::XCI || type == FileType::XCZ) {
+    if (type == FileType::XCI) {
         FileSys::XCI xci{file, program_id, program_index};
         if (xci.GetStatus() != ResultStatus::Success) {
             return nullptr;
@@ -144,8 +144,7 @@ FileType IdentifyFile(FileSys::VirtualFile file) {
 }
 
 bool IsContainerType(FileType type) {
-    return type == FileType::NSP || type == FileType::NSZ || type == FileType::XCI ||
-           type == FileType::XCZ;
+    return type == FileType::NSP || type == FileType::XCI;
 }
 
 bool IsBootableGameContainer(FileSys::VirtualFile file, FileType type, u64 program_id,
@@ -181,12 +180,8 @@ FileType GuessFromFilename(const std::string& name) {
         return FileType::NCA;
     else if (extension == "xci")
         return FileType::XCI;
-    else if (extension == "xcz")
-        return FileType::XCZ;
     else if (extension == "nsp")
         return FileType::NSP;
-    else if (extension == "nsz")
-        return FileType::NSZ;
     else if (extension == "kip")
         return FileType::KIP;
     return FileType::Unknown;
@@ -202,14 +197,10 @@ std::string GetFileTypeString(FileType type) {
         return "NCA";
     case FileType::XCI:
         return "XCI";
-    case FileType::XCZ:
-        return "XCZ";
     case FileType::NAX:
         return "NAX";
     case FileType::NSP:
         return "NSP";
-    case FileType::NSZ:
-        return "NSZ";
     case FileType::KIP:
         return "KIP";
     case FileType::DeconstructedRomDirectory:
@@ -331,7 +322,6 @@ static std::unique_ptr<AppLoader> GetFileLoader(Core::System& system, FileSys::V
 
     // NX XCI (nX Card Image) file format.
     case FileType::XCI:
-    case FileType::XCZ:
         return std::make_unique<AppLoader_XCI>(std::move(file), system.GetFileSystemController(),
                                                system.GetContentProvider(), program_id,
                                                program_index);
@@ -342,7 +332,6 @@ static std::unique_ptr<AppLoader> GetFileLoader(Core::System& system, FileSys::V
 
     // NX NSP (Nintendo Submission Package) file format
     case FileType::NSP:
-    case FileType::NSZ:
         return std::make_unique<AppLoader_NSP>(std::move(file), system.GetFileSystemController(),
                                                system.GetContentProvider(), program_id,
                                                program_index);

src/core/loader/loader.h

@@ -42,9 +42,7 @@ enum class FileType {
     NRO,
     NCA,
     NSP,
-    NSZ,
     XCI,
-    XCZ,
     NAX,
     KIP,
     DeconstructedRomDirectory,

src/frontend_common/content_manager.h

@@ -1,4 +1,4 @@
-// SPDX-FileCopyrightText: Copyright 2026 Eden Emulator Project
+// SPDX-FileCopyrightText: Copyright 2025 Eden Emulator Project
 // SPDX-License-Identifier: GPL-3.0-or-later
 
 // SPDX-FileCopyrightText: 2024 yuzu Emulator Project
@@ -163,9 +163,7 @@ inline InstallResult InstallNSP(Core::System& system, FileSys::VfsFilesystem& vf
 
     std::shared_ptr<FileSys::NSP> nsp;
     FileSys::VirtualFile file = vfs.OpenFile(filename, FileSys::OpenMode::Read);
-    const auto lower_name = boost::to_lower_copy(file->GetName());
-
-    if (lower_name.ends_with("nsp") || lower_name.ends_with("nsz")) {
+    if (boost::to_lower_copy(file->GetName()).ends_with("nsp")) {
         nsp = std::make_shared<FileSys::NSP>(file);
         if (nsp->IsExtractedType()) {
             return InstallResult::Failure;

src/qt_common/game_list/worker.cpp

@@ -360,8 +360,7 @@ void GameListWorker::ScanFileSystem(ScanTarget target, const std::string& dir_pa
             }
 
             if (target == ScanTarget::PopulateGameList &&
-                (file_type == Loader::FileType::XCI || file_type == Loader::FileType::XCZ ||
-                 file_type == Loader::FileType::NSP || file_type == Loader::FileType::NSZ) &&
+                (file_type == Loader::FileType::XCI || file_type == Loader::FileType::NSP) &&
                 !Loader::IsBootableGameContainer(file, file_type)) {
                 return true;
             }
@@ -376,9 +375,7 @@ void GameListWorker::ScanFileSystem(ScanTarget target, const std::string& dir_pa
                                        program_id, file);
                 } else if (Settings::values.ext_content_from_game_dirs.GetValue() &&
                            (file_type == Loader::FileType::XCI ||
-                            file_type == Loader::FileType::XCZ ||
-                            file_type == Loader::FileType::NSP ||
-                            file_type == Loader::FileType::NSZ)) {
+                            file_type == Loader::FileType::NSP)) {
                     void(provider->AddEntriesFromContainer(file));
                 }
             } else {
@@ -405,8 +402,7 @@ void GameListWorker::ScanFileSystem(ScanTarget target, const std::string& dir_pa
                 };
 
                 if (res2 == Loader::ResultStatus::Success && program_ids.size() > 1 &&
-                    (file_type == Loader::FileType::XCI || file_type == Loader::FileType::XCZ ||
-                     file_type == Loader::FileType::NSP || file_type == Loader::FileType::NSZ)) {
+                    (file_type == Loader::FileType::XCI || file_type == Loader::FileType::NSP)) {
                     for (const auto id : program_ids) {
                         // dravee suggested this, only viable way to
                         // not show sub-games in qlaunch for now.

src/qt_common/qt_common.cpp

@@ -57,8 +57,7 @@ std::unique_ptr<EmuThread> emu_thread = nullptr;
 
 const QStringList supported_file_extensions = {QStringLiteral("nro"), QStringLiteral("nso"),
                                                QStringLiteral("nca"), QStringLiteral("xci"),
-                                               QStringLiteral("xcz"), QStringLiteral("nsp"),
-                                               QStringLiteral("nsz"), QStringLiteral("kip")};
+                                               QStringLiteral("nsp"), QStringLiteral("kip")};
 
 Core::Frontend::WindowSystemType GetWindowSystemType() {
     // Determine WSI type based on Qt platform.

src/video_core/renderer_vulkan/blit_image.cpp

@@ -563,10 +563,8 @@ void RecordShaderReadBarrier(Scheduler& scheduler, const ImageView& image_view)
     });
 }
 
-void BeginRenderPass(vk::CommandBuffer& cmdbuf, const Framebuffer* framebuffer) {
-    const VkRenderPass render_pass = framebuffer->RenderPass();
-    const VkFramebuffer framebuffer_handle = framebuffer->Handle();
-    const VkExtent2D render_area = framebuffer->RenderArea();
+void BeginRenderPass(vk::CommandBuffer& cmdbuf, VkRenderPass render_pass,
+                     VkFramebuffer framebuffer_handle, VkExtent2D render_area) {
     const VkRenderPassBeginInfo renderpass_bi{
         .sType = VK_STRUCTURE_TYPE_RENDER_PASS_BEGIN_INFO,
         .pNext = nullptr,
@@ -679,27 +677,67 @@ void BlitImageHelper::BlitColor(const Framebuffer* dst_framebuffer, const ImageV
 void BlitImageHelper::BlitColor(const Framebuffer* dst_framebuffer, VkImageView src_image_view,
                                 VkImage src_image, VkSampler src_sampler,
                                 const Region2D& dst_region, const Region2D& src_region,
-                                const Extent3D& src_size) {
+                                const Extent3D& src_size,
+                                const std::optional<VkRect2D>& scissor) {
     const BlitImagePipelineKey key{
         .renderpass = dst_framebuffer->RenderPass(),
         .operation = Tegra::Engines::Fermi2D::Operation::SrcCopy,
     };
     const VkPipelineLayout layout = *one_texture_pipeline_layout;
     const VkPipeline pipeline = FindOrEmplaceColorPipeline(key);
+
+    // Clip the destination rectangle to the scissor; the viewport keeps the full rectangle so
+    // the texture coordinates are unchanged.
+    std::optional<VkRect2D> clip;
+    if (scissor) {
+        const s64 x0 = (std::max)(s64{(std::min)(dst_region.start.x, dst_region.end.x)},
+                                  s64{scissor->offset.x});
+        const s64 y0 = (std::max)(s64{(std::min)(dst_region.start.y, dst_region.end.y)},
+                                  s64{scissor->offset.y});
+        const s64 x1 = (std::min)(s64{(std::max)(dst_region.start.x, dst_region.end.x)},
+                                  s64{scissor->offset.x} + scissor->extent.width);
+        const s64 y1 = (std::min)(s64{(std::max)(dst_region.start.y, dst_region.end.y)},
+                                  s64{scissor->offset.y} + scissor->extent.height);
+        if (x1 <= x0 || y1 <= y0) {
+            return; // Fully scissored out.
+        }
+        clip = VkRect2D{
+            .offset = {static_cast<s32>(x0), static_cast<s32>(y0)},
+            .extent = {static_cast<u32>(x1 - x0), static_cast<u32>(y1 - y0)},
+        };
+    }
+
+    // Read the framebuffer now: by the time the worker runs this, the texture cache may have
+    // retired it (moved into its delayed-destruction ring), leaving a null handle behind - Turnip
+    // then crashed in vkCmdBeginRenderPass (Crysis Remastered, DrawTexture).
+    const VkRenderPass render_pass = dst_framebuffer->RenderPass();
+    const VkFramebuffer framebuffer_handle = dst_framebuffer->Handle();
+    const VkExtent2D render_area = dst_framebuffer->RenderArea();
     scheduler.RequestOutsideRenderPassOperationContext();
-    scheduler.Record([this, dst_framebuffer, src_image_view, src_image, src_sampler, dst_region,
-                      src_region, src_size, pipeline, layout](vk::CommandBuffer cmdbuf) {
-        TransitionImageLayout(cmdbuf, src_image, VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL);
-        BeginRenderPass(cmdbuf, dst_framebuffer);
+    scheduler.Record([this, render_pass, framebuffer_handle, render_area, src_image_view,
+                      src_image, src_sampler, dst_region, src_region, src_size, pipeline, layout,
+                      clip](vk::CommandBuffer cmdbuf) {
+        // Images stay in GENERAL everywhere (the descriptor below says so too): only make the
+        // earlier writes visible. Moving the source to SHADER_READ_ONLY_OPTIMAL left it there
+        // for good, so every later render pass used it in the wrong layout.
+        TransitionImageLayout(cmdbuf, src_image, VK_IMAGE_LAYOUT_GENERAL);
+        BeginRenderPass(cmdbuf, render_pass, framebuffer_handle, render_area);
         const VkDescriptorSet descriptor_set = one_texture_descriptor_allocator.Commit();
         UpdateOneTextureDescriptorSet(device, descriptor_set, src_sampler, src_image_view);
         cmdbuf.BindPipeline(VK_PIPELINE_BIND_POINT_GRAPHICS, pipeline);
         cmdbuf.BindDescriptorSets(VK_PIPELINE_BIND_POINT_GRAPHICS, layout, 0, descriptor_set,
                                   nullptr);
         BindBlitState(cmdbuf, layout, dst_region, src_region, src_size);
+        if (clip) {
+            cmdbuf.SetScissor(0, *clip);
+        }
         cmdbuf.Draw(3, 1, 0, 0);
         cmdbuf.EndRenderPass();
     });
+    // The blit set its own pipeline, viewport and scissor: make the next draw set its own again,
+    // as every other helper here does. Without this the next draw kept the blit's viewport and
+    // scissor: Crysis Remastered drew its 256x256 minimap map over the whole screen.
+    scheduler.InvalidateState();
 }
 
 void BlitImageHelper::BlitImpl(const Framebuffer* dst_framebuffer,

src/video_core/renderer_vulkan/blit_image.h

@@ -7,6 +7,7 @@
 #pragma once
 
 #include <deque>
+#include <optional>
 #include <span>
 
 #include "video_core/engines/fermi_2d.h"
@@ -78,9 +79,12 @@ public:
                    Tegra::Engines::Fermi2D::Filter filter,
                    Tegra::Engines::Fermi2D::Operation operation);
 
+    /// @param scissor Optional clip rectangle in framebuffer pixels (DrawTexture honours the
+    ///                guest scissor like any other draw).
     void BlitColor(const Framebuffer* dst_framebuffer, VkImageView src_image_view,
                    VkImage src_image, VkSampler src_sampler, const Region2D& dst_region,
-                   const Region2D& src_region, const Extent3D& src_size);
+                   const Region2D& src_region, const Extent3D& src_size,
+                   const std::optional<VkRect2D>& scissor = std::nullopt);
 
     void BlitColorMSAA(const Framebuffer* dst_framebuffer, const ImageView& src_image_view,
                        const Region2D& dst_region, const Region2D& src_region);

src/video_core/renderer_vulkan/vk_rasterizer.cpp

@@ -393,8 +393,35 @@ void RasterizerVulkan::DrawTexture() {
                                     .y = ScaleSrc(draw_texture_state.src_y1)}};
     Extent3D src_size = {static_cast<u32>(ScaleSrc(texture.size.width)),
                          static_cast<u32>(ScaleSrc(texture.size.height)), texture.size.depth};
+    // DrawTexture rectangles go through the fragment pipeline, scissor included.
+    std::optional<VkRect2D> scissor;
+    if (maxwell3d->regs.scissor_test[0].enable) {
+        u32 up_scale = 1;
+        u32 down_shift = 0;
+        if (dst_rescaling) {
+            up_scale = Settings::values.resolution_info.up_scale;
+            down_shift = Settings::values.resolution_info.down_shift;
+        }
+        scissor = GetScissorState(maxwell3d->regs, 0, up_scale, down_shift);
+    }
+
+    // Drawing a texture 1:1 onto itself without blending changes nothing on hardware, but here
+    // it samples the image the render pass is writing to: undefined in Vulkan, and on tiled GPUs
+    // it reads whatever the image memory last held. Crysis Remastered does this every frame for
+    // its post-processing buffers (suspected cause of its map covering the whole screen).
+    const auto& fb_images = framebuffer->Images();
+    const bool src_is_target =
+        std::find(fb_images.begin(), fb_images.begin() + framebuffer->NumImages(),
+                  texture.ImageHandle()) != fb_images.begin() + framebuffer->NumImages();
+    if (src_is_target && src_rescaling == dst_rescaling &&
+        src_region.start.x == dst_region.start.x && src_region.start.y == dst_region.start.y &&
+        src_region.end.x == dst_region.end.x && src_region.end.y == dst_region.end.y &&
+        maxwell3d->regs.blend.enable[0] == 0) {
+        return;
+    }
+
     blit_image.BlitColor(framebuffer, texture.RenderTarget(), texture.ImageHandle(),
-                         sampler->Handle(), dst_region, src_region, src_size);
+                         sampler->Handle(), dst_region, src_region, src_size, scissor);
 }
 
 void RasterizerVulkan::Clear(u32 layer_count) {