Fix [core, gpu, threads] Multithreading refactor (#4254) (#4548)

Performance loss regression fixed in Link's Awakening, Castlevania, Super Mario RPG, etc

Tested by Mr. Knobs on Android and myself on Linux

Multicore ON may be fixed for some users using Intel CPUs.
Games include: FF Tactics, Shredder's Revenge, Unity Engine Games.

- [x] I have read and followed the [Contribution Guidelines](https://git.eden-emu.dev/eden-emu/eden/src/branch/master/CONTRIBUTING.md#code-contributions).
- [x] I have read and followed the [AI Policy](https://git.eden-emu.dev/eden-emu/eden/src/branch/master/docs/policies/AI.md).
- [x] I have read and followed the [Coding Guidelines](https://git.eden-emu.dev/eden-emu/eden/src/branch/master/docs/policies/Coding.md) to the best of my ability.

-------------------

Reviewed-on: https://git.eden-emu.dev/eden-emu/eden/pulls/4548
Reviewed-by: Maufeat <sahyno1996@gmail.com>
Reviewed-by: lizzie <lizzie@eden-emu.dev>

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/android/app/src/main/jni/game_metadata.cpp

@@ -76,9 +76,7 @@ jboolean Java_org_yuzu_yuzu_1emu_utils_GameMetadata_getIsValid(JNIEnv* env, jobj
             auto const file_type = loader->GetFileType();
             if (file_type == Loader::FileType::Unknown || file_type == Loader::FileType::Error)
                 return false;
-            if ((file_type == Loader::FileType::NSP || file_type == Loader::FileType::XCI ||
-                 file_type == Loader::FileType::NSZ || file_type == Loader::FileType::XCZ) &&
-                !Loader::IsBootableGameContainer(file, file_type))
+            if ((file_type == Loader::FileType::NSP || file_type == Loader::FileType::XCI) && !Loader::IsBootableGameContainer(file, file_type))
                 return false;
             u64 program_id = 0;
             return loader->ReadProgramId(program_id) == Loader::ResultStatus::Success;

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,430 +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 <zstd.h>
-
-#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::size_t Chunk = 0x100000;
-// Upper bound on NCZ section entries (64 bytes each, so the table is at most 4 MiB). A base NCA
-// has a handful of sections, but nsz stores an update's patch (BKTR) data one entry per
-// subsection, which is thousands of them.
-constexpr u64 MaxSectionCount = 0x10000;
-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 > MaxSectionCount || 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{};
-};
-
-// Solid NCZ: one zstd stream over the whole body. Decoded incrementally into memory, up to the
-// requested offset, so sequential install reads are O(n) instead of O(n^2).
-class SolidNczFile final : public FileSys::VfsFile {
-public:
-    SolidNczFile(std::string name_, FileSys::VirtualFile source_,
-                 std::vector<Section> sections_, u64 payload_start_)
-        : name{std::move(name_)}, source{std::move(source_)}, sections{std::move(sections_)},
-          payload_start{payload_start_} {
-        const auto raw_header = source->ReadBytes(HeaderSize, 0);
-        data.assign(raw_header.begin(), raw_header.end());
-        frontier = HeaderSize;
-    }
-
-    ~SolidNczFile() override {
-        if (stream != nullptr) ZSTD_freeDStream(stream);
-    }
-
-    std::string GetName() const override { return name; }
-    std::size_t GetSize() const override {
-        u64 size = HeaderSize;
-        for (const auto& s : sections)
-            size = std::max<u64>(size, static_cast<u64>(s.offset + s.size));
-        return static_cast<std::size_t>(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* out, std::size_t len, std::size_t off) const override {
-        std::scoped_lock lock{mutex};
-        const u64 nca_size = GetSize();
-        if (off >= nca_size) return 0;
-        len = static_cast<std::size_t>(std::min<u64>(len, nca_size - off));
-        const u64 needed = off + len;
-        if (needed > frontier && !DecodeTo(needed)) return 0;
-        std::memcpy(out, data.data() + off, len);
-        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:
-    bool DecodeTo(u64 needed) const {
-        if (stream == nullptr) {
-            stream = ZSTD_createDStream();
-            if (stream == nullptr) return false;
-            ZSTD_DCtx_setParameter(stream, ZSTD_d_windowLogMax, 31);
-            read_pos = payload_start;
-        }
-
-        const u64 file_size = source->GetSize();
-        std::vector<u8> out_buf(Chunk);
-
-        std::size_t index = 0;
-        for (; index < sections.size(); ++index) {
-            const auto& s = sections[index];
-            const u64 begin = std::max<u64>(static_cast<u64>(s.offset), HeaderSize);
-            const u64 end = std::max<u64>(static_cast<u64>(s.offset) + static_cast<u64>(s.size),
-                                          begin);
-            if (end > frontier) break;
-        }
-
-        for (; index < sections.size() && frontier < needed; ++index) {
-            const auto& s = sections[index];
-            const u64 begin = std::max<u64>(static_cast<u64>(s.offset), HeaderSize);
-            const u64 end = std::max<u64>(static_cast<u64>(s.offset) + static_cast<u64>(s.size),
-                                          begin);
-            if (end <= frontier) continue;
-            u64 pos = std::max<u64>(begin, frontier);
-
-            std::optional<AESCipher<Key128>> cipher;
-            if (s.Ctr()) cipher.emplace(s.key, Mode::CTR);
-
-            while (pos < end && frontier < needed) {
-                const u64 want = std::min<u64>(end - pos, out_buf.size());
-                std::size_t produced = 0;
-                while (produced < want) {
-                    if (in.pos >= in.size) {
-                        const u64 remaining = file_size - read_pos;
-                        const std::size_t chunk = static_cast<std::size_t>(
-                            std::min<u64>(Chunk, remaining));
-                        if (chunk == 0) { LOG_ERROR(Crypto, "Solid NCZ: truncated"); return false; }
-                        const auto bytes = source->ReadBytes(chunk, read_pos);
-                        if (bytes.empty()) { LOG_ERROR(Crypto, "Solid NCZ: truncated"); return false; }
-                        read_pos += bytes.size();
-                        in_buf.assign(bytes.begin(), bytes.end());
-                        in.src = in_buf.data();
-                        in.size = in_buf.size();
-                        in.pos = 0;
-                    }
-                    ZSTD_outBuffer outb{out_buf.data() + produced, want - produced, 0};
-                    const std::size_t res = ZSTD_decompressStream(stream, &outb, &in);
-                    if (ZSTD_isError(res)) {
-                        LOG_ERROR(Crypto, "Solid NCZ: zstd error");
-                        return false;
-                    }
-                    produced += outb.pos;
-                }
-                if (cipher) {
-                    Key128 iv{};
-                    SetIv(iv, s.counter, pos);
-                    cipher->SetIV(iv);
-                    cipher->Transcode(out_buf.data(), produced, out_buf.data(), Op::Encrypt);
-                }
-                data.insert(data.end(), out_buf.begin(), out_buf.begin() + produced);
-                pos += produced;
-                frontier = pos;
-            }
-        }
-        return frontier >= needed;
-    }
-
-    const std::string name;
-    const FileSys::VirtualFile source;
-    const std::vector<Section> sections;
-    const u64 payload_start;
-    mutable std::mutex mutex;
-    mutable std::vector<u8> data;
-    mutable ZSTD_DStream* stream = nullptr;
-    mutable u64 read_pos = 0;
-    mutable u64 frontier = 0;
-    mutable std::vector<u8> in_buf;
-    mutable ZSTD_inBuffer in{nullptr, 0, 0};
-};
-
-// Shared opener: block path always; solid only when allow_solid is true.
-FileSys::VirtualFile OpenNcz(const FileSys::VirtualFile& f, std::string_view name,
-                             bool allow_solid) {
-    if (!f) return nullptr;
-    u64 ps = 0;
-    auto parsed = ParseHeader(f, ps);
-    if (!parsed) return nullptr;
-    auto& [sections, block] = *parsed;
-
-    if (block) {
-        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));
-    }
-
-    if (allow_solid) {
-        return std::make_shared<SolidNczFile>(std::string{name}, f, std::move(sections), ps);
-    }
-
-    LOG_DEBUG(Crypto, "Solid NCZ {} skipped (only NCZBLOCK is supported for play)", name);
-    return nullptr;
-}
-
-} // 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) {
-    return OpenNcz(f, name, /*allow_solid=*/false);
-}
-
-FileSys::VirtualFile DecompressNCZForInstall(const FileSys::VirtualFile& f,
-                                             std::string_view name) {
-    return OpenNcz(f, name, /*allow_solid=*/true);
-}
-
-} // namespace Core::Crypto

src/core/crypto/ncz_decompressor.h

@@ -1,35 +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);
-
-// Install to NAND: same as DecompressNCZ, but solid NCZ is decoded on demand too.
-[[nodiscard]] FileSys::VirtualFile DecompressNCZForInstall(
-    const FileSys::VirtualFile& ncz_file, std::string_view output_name);
-
-} // 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) {
@@ -831,14 +811,7 @@ std::vector<ContentProviderEntry> RegisteredCache::ListEntriesFilter(
 }
 
 static std::shared_ptr<NCA> GetNCAFromNSPForID(const NSP& nsp, const NcaID& id) {
-    const auto id_string = Common::HexToString(id, false);
-    auto file = nsp.GetFile(fmt::format("{}.nca", id_string));
-    if (file == nullptr) {
-        if (auto ncz_file = nsp.GetFile(fmt::format("{}.ncz", id_string))) {
-            file = Core::Crypto::DecompressNCZForInstall(
-                ncz_file, fmt::format("{}.nca", id_string));
-        }
-    }
+    auto file = nsp.GetFile(fmt::format("{}.nca", Common::HexToString(id, false)));
     if (file == nullptr) {
         return nullptr;
     }
@@ -1300,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,

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,17 +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_DEBUG(Service_FS, "Skipping solid or unsupported NCZ content {}.ncz", id_string);
-                            continue;
-                        }
-                    }
-                }
-
                 if (next_file == nullptr) {
                     if (rec.type != ContentRecordType::DeltaFragment) {
                         LOG_WARNING(Service_FS,

src/core/hle/service/nvnflinger/hardware_composer.cpp

@@ -57,8 +57,21 @@ u32 HardwareComposer::ComposeLocked(f32* out_speed_scale, Display& display,
     // Set default speed limit to 100%.
     *out_speed_scale = 1.0f;
 
+    // If no layers are visible, skip the logic. Acquiring and holding buffers here would
+    // consume the producer's queue without ever presenting.
+    bool any_visible = false;
+    for (auto& layer : display.stack.layers) {
+        if (layer->visible) {
+            any_visible = true;
+            break;
+        }
+    }
+    if (!any_visible) {
+        return 1;
+    }
+
+    // Wait for the previous composite, bounding the number of in-flight composites.
     nvdisp.WaitForComposite();
-    this->ReleaseFramebuffersLocked(display);
 
     // Determine the number of vsync periods to wait before composing again.
     std::optional<s32> swap_interval{};
@@ -152,6 +165,13 @@ u32 HardwareComposer::ComposeLocked(f32* out_speed_scale, Display& display,
     // Advance by 1 frame (60 FPS compositing)
     m_frame_number += 1;
 
+    // Release framebuffers once the frame has been handed to the compositor. This happens
+    // within the same vsync period as the acquire (release_frame_number is checked against
+    // the advanced counter), so the producer gets its buffers back immediately instead of
+    // losing a queue slot for a whole frame.
+    // TODO: support release fences; releasing before the composite has finished can tear.
+    this->ReleaseFramebuffersLocked(display);
+
     return 1;
 }
 

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/core/loader/nsp.cpp

@@ -56,11 +56,6 @@ AppLoader_NSP::AppLoader_NSP(FileSys::VirtualFile file_,
 AppLoader_NSP::~AppLoader_NSP() = default;
 
 FileType AppLoader_NSP::IdentifyType(const FileSys::VirtualFile& nsp_file) {
-    // .nsz is NSP-compatible; return NSZ so the game list shows the right type.
-    if (nsp_file->GetName().ends_with(".nsz")) {
-        return FileType::NSZ;
-    }
-
     const FileSys::NSP nsp(nsp_file);
 
     if (nsp.GetStatus() != ResultStatus::Success) {

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/input_common/drivers/joycon.cpp

@@ -83,21 +83,20 @@ void Joycons::ScanThread(std::stop_token stop_token) {
     constexpr u16 nintendo_vendor_id = 0x057e;
     Common::SetCurrentThreadName("JoyconScanThread");
 
-    auto last_ret = 0u;
     do {
-        auto ret = SDL_hid_device_change_count();
-        if (last_ret == 0u || last_ret != ret) {
-            last_ret = ret;
-            SDL_hid_device_info* devs = SDL_hid_enumerate(nintendo_vendor_id, 0x0);
-            for (auto* cur_dev = devs; cur_dev; cur_dev = cur_dev->next) {
-                if (IsDeviceNew(cur_dev)) {
-                    LOG_DEBUG(Input, "Device Found,type : {:04X} {:04X}", cur_dev->vendor_id, cur_dev->product_id);
-                    RegisterNewDevice(cur_dev);
-                }
-                cur_dev = cur_dev->next;
+        SDL_hid_device_info* devs = SDL_hid_enumerate(nintendo_vendor_id, 0x0);
+        SDL_hid_device_info* cur_dev = devs;
+
+        while (cur_dev) {
+            if (IsDeviceNew(cur_dev)) {
+                LOG_DEBUG(Input, "Device Found,type : {:04X} {:04X}", cur_dev->vendor_id,
+                          cur_dev->product_id);
+                RegisterNewDevice(cur_dev);
             }
-            SDL_hid_free_enumeration(devs);
+            cur_dev = cur_dev->next;
         }
+
+        SDL_hid_free_enumeration(devs);
     } while (Common::StoppableTimedWait(stop_token, std::chrono::seconds{5}));
 }
 

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/yuzu/main_window.cpp

@@ -2797,9 +2797,9 @@ void MainWindow::IncrementInstallProgress() {
 
 void MainWindow::OnMenuInstallToNAND() {
     const QString file_filter =
-        tr("Installable Switch File (*.nca *.nsp *.nsz *.xci *.xcz);;Nintendo Content Archive "
-           "(*.nca);;Nintendo Submission Package (*.nsp *.nsz);;NX Cartridge "
-           "Image (*.xci *.xcz)");
+        tr("Installable Switch File (*.nca *.nsp *.xci);;Nintendo Content Archive "
+           "(*.nca);;Nintendo Submission Package (*.nsp);;NX Cartridge "
+           "Image (*.xci)");
 
     QStringList filenames = QFileDialog::getOpenFileNames(
         this, tr("Install Files"), QString::fromStdString(UISettings::values.roms_path),
@@ -2856,10 +2856,7 @@ void MainWindow::OnMenuInstallToNAND() {
         QFuture<ContentManager::InstallResult> future;
         ContentManager::InstallResult result;
 
-        if (file.endsWith(QStringLiteral("nsp"), Qt::CaseInsensitive) ||
-            file.endsWith(QStringLiteral("nsz"), Qt::CaseInsensitive) ||
-            file.endsWith(QStringLiteral("xci"), Qt::CaseInsensitive) ||
-            file.endsWith(QStringLiteral("xcz"), Qt::CaseInsensitive)) {
+        if (file.endsWith(QStringLiteral("nsp"), Qt::CaseInsensitive)) {
             const auto progress_callback = [this](size_t size, size_t progress) {
                 emit UpdateInstallProgress();
                 if (install_progress->wasCanceled()) {