fixup! CoreTiming: Keep Cores synced by having each core it's own downcount and let the main core run an intermediate run if it's slice_length was cropped

CMakeLists.txt

@@ -66,12 +66,10 @@ if (NOT ENABLE_GENERIC)
         detect_architecture("_M_AMD64" x86_64)
         detect_architecture("_M_IX86" x86)
         detect_architecture("_M_ARM" ARM)
-        detect_architecture("_M_ARM64" ARM64)
     else()
         detect_architecture("__x86_64__" x86_64)
         detect_architecture("__i386__" x86)
         detect_architecture("__arm__" ARM)
-        detect_architecture("__aarch64__" ARM64)
     endif()
 endif()
 

appveyor.yml

@@ -53,7 +53,7 @@ build_script:
           # https://www.appveyor.com/docs/build-phase
           msbuild msvc_build/yuzu.sln /maxcpucount /logger:"C:\Program Files\AppVeyor\BuildAgent\Appveyor.MSBuildLogger.dll"
         } else {
-          C:\msys64\usr\bin\bash.exe -lc 'mingw32-make -j4 -C mingw_build/ 2>&1'
+          C:\msys64\usr\bin\bash.exe -lc 'mingw32-make -C mingw_build/ 2>&1'
         }
 
 after_build:

src/audio_core/CMakeLists.txt

@@ -1,8 +1,4 @@
 add_library(audio_core STATIC
-    algorithm/filter.cpp
-    algorithm/filter.h
-    algorithm/interpolate.cpp
-    algorithm/interpolate.h
     audio_out.cpp
     audio_out.h
     audio_renderer.cpp
@@ -11,12 +7,12 @@ add_library(audio_core STATIC
     codec.cpp
     codec.h
     null_sink.h
+    stream.cpp
+    stream.h
     sink.h
     sink_details.cpp
     sink_details.h
     sink_stream.h
-    stream.cpp
-    stream.h
 
     $<$<BOOL:${ENABLE_CUBEB}>:cubeb_sink.cpp cubeb_sink.h>
 )

src/audio_core/algorithm/filter.cpp

@@ -1,79 +0,0 @@
-// Copyright 2018 yuzu Emulator Project
-// Licensed under GPLv2 or any later version
-// Refer to the license.txt file included.
-
-#define _USE_MATH_DEFINES
-
-#include <algorithm>
-#include <array>
-#include <cmath>
-#include <vector>
-#include "audio_core/algorithm/filter.h"
-#include "common/common_types.h"
-
-namespace AudioCore {
-
-Filter Filter::LowPass(double cutoff, double Q) {
-    const double w0 = 2.0 * M_PI * cutoff;
-    const double sin_w0 = std::sin(w0);
-    const double cos_w0 = std::cos(w0);
-    const double alpha = sin_w0 / (2 * Q);
-
-    const double a0 = 1 + alpha;
-    const double a1 = -2.0 * cos_w0;
-    const double a2 = 1 - alpha;
-    const double b0 = 0.5 * (1 - cos_w0);
-    const double b1 = 1.0 * (1 - cos_w0);
-    const double b2 = 0.5 * (1 - cos_w0);
-
-    return {a0, a1, a2, b0, b1, b2};
-}
-
-Filter::Filter() : Filter(1.0, 0.0, 0.0, 1.0, 0.0, 0.0) {}
-
-Filter::Filter(double a0, double a1, double a2, double b0, double b1, double b2)
-    : a1(a1 / a0), a2(a2 / a0), b0(b0 / a0), b1(b1 / a0), b2(b2 / a0) {}
-
-void Filter::Process(std::vector<s16>& signal) {
-    const size_t num_frames = signal.size() / 2;
-    for (size_t i = 0; i < num_frames; i++) {
-        std::rotate(in.begin(), in.end() - 1, in.end());
-        std::rotate(out.begin(), out.end() - 1, out.end());
-
-        for (size_t ch = 0; ch < channel_count; ch++) {
-            in[0][ch] = signal[i * channel_count + ch];
-
-            out[0][ch] = b0 * in[0][ch] + b1 * in[1][ch] + b2 * in[2][ch] - a1 * out[1][ch] -
-                         a2 * out[2][ch];
-
-            signal[i * 2 + ch] = std::clamp(out[0][ch], -32768.0, 32767.0);
-        }
-    }
-}
-
-/// Calculates the appropriate Q for each biquad in a cascading filter.
-/// @param total_count The total number of biquads to be cascaded.
-/// @param index 0-index of the biquad to calculate the Q value for.
-static double CascadingBiquadQ(size_t total_count, size_t index) {
-    const double pole = M_PI * (2 * index + 1) / (4.0 * total_count);
-    return 1.0 / (2.0 * std::cos(pole));
-}
-
-CascadingFilter CascadingFilter::LowPass(double cutoff, size_t cascade_size) {
-    std::vector<Filter> cascade(cascade_size);
-    for (size_t i = 0; i < cascade_size; i++) {
-        cascade[i] = Filter::LowPass(cutoff, CascadingBiquadQ(cascade_size, i));
-    }
-    return CascadingFilter{std::move(cascade)};
-}
-
-CascadingFilter::CascadingFilter() = default;
-CascadingFilter::CascadingFilter(std::vector<Filter> filters) : filters(std::move(filters)) {}
-
-void CascadingFilter::Process(std::vector<s16>& signal) {
-    for (auto& filter : filters) {
-        filter.Process(signal);
-    }
-}
-
-} // namespace AudioCore

src/audio_core/algorithm/filter.h

@@ -1,62 +0,0 @@
-// Copyright 2018 yuzu Emulator Project
-// Licensed under GPLv2 or any later version
-// Refer to the license.txt file included.
-
-#pragma once
-
-#include <array>
-#include <vector>
-#include "common/common_types.h"
-
-namespace AudioCore {
-
-/// Digital biquad filter:
-///
-///          b0 + b1 z^-1 + b2 z^-2
-///  H(z) = ------------------------
-///          a0 + a1 z^-1 + b2 z^-2
-class Filter {
-public:
-    /// Creates a low-pass filter.
-    /// @param cutoff Determines the cutoff frequency. A value from 0.0 to 1.0.
-    /// @param Q Determines the quality factor of this filter.
-    static Filter LowPass(double cutoff, double Q = 0.7071);
-
-    /// Passthrough filter.
-    Filter();
-
-    Filter(double a0, double a1, double a2, double b0, double b1, double b2);
-
-    void Process(std::vector<s16>& signal);
-
-private:
-    static constexpr size_t channel_count = 2;
-
-    /// Coefficients are in normalized form (a0 = 1.0).
-    double a1, a2, b0, b1, b2;
-    /// Input History
-    std::array<std::array<double, channel_count>, 3> in;
-    /// Output History
-    std::array<std::array<double, channel_count>, 3> out;
-};
-
-/// Cascade filters to build up higher-order filters from lower-order ones.
-class CascadingFilter {
-public:
-    /// Creates a cascading low-pass filter.
-    /// @param cutoff Determines the cutoff frequency. A value from 0.0 to 1.0.
-    /// @param cascade_size Number of biquads in cascade.
-    static CascadingFilter LowPass(double cutoff, size_t cascade_size);
-
-    /// Passthrough.
-    CascadingFilter();
-
-    explicit CascadingFilter(std::vector<Filter> filters);
-
-    void Process(std::vector<s16>& signal);
-
-private:
-    std::vector<Filter> filters;
-};
-
-} // namespace AudioCore

src/audio_core/algorithm/interpolate.cpp

@@ -1,71 +0,0 @@
-// Copyright 2018 yuzu Emulator Project
-// Licensed under GPLv2 or any later version
-// Refer to the license.txt file included.
-
-#define _USE_MATH_DEFINES
-
-#include <algorithm>
-#include <cmath>
-#include <vector>
-#include "audio_core/algorithm/interpolate.h"
-#include "common/common_types.h"
-#include "common/logging/log.h"
-
-namespace AudioCore {
-
-/// The Lanczos kernel
-static double Lanczos(size_t a, double x) {
-    if (x == 0.0)
-        return 1.0;
-    const double px = M_PI * x;
-    return a * std::sin(px) * std::sin(px / a) / (px * px);
-}
-
-std::vector<s16> Interpolate(InterpolationState& state, std::vector<s16> input, double ratio) {
-    if (input.size() < 2)
-        return {};
-
-    if (ratio <= 0) {
-        LOG_CRITICAL(Audio, "Nonsensical interpolation ratio {}", ratio);
-        ratio = 1.0;
-    }
-
-    if (ratio != state.current_ratio) {
-        const double cutoff_frequency = std::min(0.5 / ratio, 0.5 * ratio);
-        state.nyquist = CascadingFilter::LowPass(std::clamp(cutoff_frequency, 0.0, 0.4), 3);
-        state.current_ratio = ratio;
-    }
-    state.nyquist.Process(input);
-
-    constexpr size_t taps = InterpolationState::lanczos_taps;
-    const size_t num_frames = input.size() / 2;
-
-    std::vector<s16> output;
-    output.reserve(static_cast<size_t>(input.size() / ratio + 4));
-
-    double& pos = state.position;
-    auto& h = state.history;
-    for (size_t i = 0; i < num_frames; ++i) {
-        std::rotate(h.begin(), h.end() - 1, h.end());
-        h[0][0] = input[i * 2 + 0];
-        h[0][1] = input[i * 2 + 1];
-
-        while (pos <= 1.0) {
-            double l = 0.0;
-            double r = 0.0;
-            for (size_t j = 0; j < h.size(); j++) {
-                l += Lanczos(taps, pos + j - taps + 1) * h[j][0];
-                r += Lanczos(taps, pos + j - taps + 1) * h[j][1];
-            }
-            output.emplace_back(static_cast<s16>(std::clamp(l, -32768.0, 32767.0)));
-            output.emplace_back(static_cast<s16>(std::clamp(r, -32768.0, 32767.0)));
-
-            pos += ratio;
-        }
-        pos -= 1.0;
-    }
-
-    return output;
-}
-
-} // namespace AudioCore

src/audio_core/algorithm/interpolate.h

@@ -1,43 +0,0 @@
-// Copyright 2018 yuzu Emulator Project
-// Licensed under GPLv2 or any later version
-// Refer to the license.txt file included.
-
-#pragma once
-
-#include <array>
-#include <vector>
-#include "audio_core/algorithm/filter.h"
-#include "common/common_types.h"
-
-namespace AudioCore {
-
-struct InterpolationState {
-    static constexpr size_t lanczos_taps = 4;
-    static constexpr size_t history_size = lanczos_taps * 2 - 1;
-
-    double current_ratio = 0.0;
-    CascadingFilter nyquist;
-    std::array<std::array<s16, 2>, history_size> history = {};
-    double position = 0;
-};
-
-/// Interpolates input signal to produce output signal.
-/// @param input The signal to interpolate.
-/// @param ratio Interpolation ratio.
-///              ratio > 1.0 results in fewer output samples.
-///              ratio < 1.0 results in more output samples.
-/// @returns Output signal.
-std::vector<s16> Interpolate(InterpolationState& state, std::vector<s16> input, double ratio);
-
-/// Interpolates input signal to produce output signal.
-/// @param input The signal to interpolate.
-/// @param input_rate The sample rate of input.
-/// @param output_rate The desired sample rate of the output.
-/// @returns Output signal.
-inline std::vector<s16> Interpolate(InterpolationState& state, std::vector<s16> input,
-                                    u32 input_rate, u32 output_rate) {
-    const double ratio = static_cast<double>(input_rate) / static_cast<double>(output_rate);
-    return Interpolate(state, std::move(input), ratio);
-}
-
-} // namespace AudioCore

src/audio_core/audio_renderer.cpp

@@ -2,7 +2,6 @@
 // Licensed under GPLv2 or any later version
 // Refer to the license.txt file included.
 
-#include "audio_core/algorithm/interpolate.h"
 #include "audio_core/audio_renderer.h"
 #include "common/assert.h"
 #include "common/logging/log.h"
@@ -200,8 +199,6 @@ void AudioRenderer::VoiceState::RefreshBuffer() {
         break;
     }
 
-    samples = Interpolate(interp_state, std::move(samples), Info().sample_rate, STREAM_SAMPLE_RATE);
-
     is_refresh_pending = false;
 }
 
@@ -227,7 +224,7 @@ void AudioRenderer::QueueMixedBuffer(Buffer::Tag tag) {
                 break;
             }
 
-            samples_remaining -= samples.size() / stream->GetNumChannels();
+            samples_remaining -= samples.size();
 
             for (const auto& sample : samples) {
                 const s32 buffer_sample{buffer[offset]};

src/audio_core/audio_renderer.h

@@ -8,7 +8,6 @@
 #include <memory>
 #include <vector>
 
-#include "audio_core/algorithm/interpolate.h"
 #include "audio_core/audio_out.h"
 #include "audio_core/codec.h"
 #include "audio_core/stream.h"
@@ -195,7 +194,6 @@ private:
         size_t wave_index{};
         size_t offset{};
         Codec::ADPCMState adpcm_state{};
-        InterpolationState interp_state{};
         std::vector<s16> samples;
         VoiceOutStatus out_status{};
         VoiceInfo info{};

src/common/CMakeLists.txt

@@ -29,6 +29,8 @@ add_library(common STATIC
     assert.h
     bit_field.h
     bit_set.h
+    break_points.cpp
+    break_points.h
     cityhash.cpp
     cityhash.h
     color.h
@@ -38,8 +40,6 @@ add_library(common STATIC
     file_util.cpp
     file_util.h
     hash.h
-    hex_util.cpp
-    hex_util.h
     logging/backend.cpp
     logging/backend.h
     logging/filter.cpp

src/common/break_points.cpp

@@ -0,0 +1,90 @@
+// Copyright 2013 Dolphin Emulator Project / 2014 Citra Emulator Project
+// Licensed under GPLv2 or any later version
+// Refer to the license.txt file included.
+
+#include <algorithm>
+#include <sstream>
+#include "common/break_points.h"
+
+bool BreakPoints::IsAddressBreakPoint(u32 iAddress) const {
+    auto cond = [&iAddress](const TBreakPoint& bp) { return bp.iAddress == iAddress; };
+    auto it = std::find_if(m_BreakPoints.begin(), m_BreakPoints.end(), cond);
+    return it != m_BreakPoints.end();
+}
+
+bool BreakPoints::IsTempBreakPoint(u32 iAddress) const {
+    auto cond = [&iAddress](const TBreakPoint& bp) {
+        return bp.iAddress == iAddress && bp.bTemporary;
+    };
+    auto it = std::find_if(m_BreakPoints.begin(), m_BreakPoints.end(), cond);
+    return it != m_BreakPoints.end();
+}
+
+BreakPoints::TBreakPointsStr BreakPoints::GetStrings() const {
+    TBreakPointsStr bps;
+    for (auto breakpoint : m_BreakPoints) {
+        if (!breakpoint.bTemporary) {
+            std::stringstream bp;
+            bp << std::hex << breakpoint.iAddress << " " << (breakpoint.bOn ? "n" : "");
+            bps.push_back(bp.str());
+        }
+    }
+
+    return bps;
+}
+
+void BreakPoints::AddFromStrings(const TBreakPointsStr& bps) {
+    for (auto bps_item : bps) {
+        TBreakPoint bp;
+        std::stringstream bpstr;
+        bpstr << std::hex << bps_item;
+        bpstr >> bp.iAddress;
+        bp.bOn = bps_item.find("n") != bps_item.npos;
+        bp.bTemporary = false;
+        Add(bp);
+    }
+}
+
+void BreakPoints::Add(const TBreakPoint& bp) {
+    if (!IsAddressBreakPoint(bp.iAddress)) {
+        m_BreakPoints.push_back(bp);
+        // if (jit)
+        //    jit->GetBlockCache()->InvalidateICache(bp.iAddress, 4);
+    }
+}
+
+void BreakPoints::Add(u32 em_address, bool temp) {
+    if (!IsAddressBreakPoint(em_address)) // only add new addresses
+    {
+        TBreakPoint pt; // breakpoint settings
+        pt.bOn = true;
+        pt.bTemporary = temp;
+        pt.iAddress = em_address;
+
+        m_BreakPoints.push_back(pt);
+
+        // if (jit)
+        //    jit->GetBlockCache()->InvalidateICache(em_address, 4);
+    }
+}
+
+void BreakPoints::Remove(u32 em_address) {
+    auto cond = [&em_address](const TBreakPoint& bp) { return bp.iAddress == em_address; };
+    auto it = std::find_if(m_BreakPoints.begin(), m_BreakPoints.end(), cond);
+    if (it != m_BreakPoints.end())
+        m_BreakPoints.erase(it);
+}
+
+void BreakPoints::Clear() {
+    // if (jit)
+    //{
+    //    std::for_each(m_BreakPoints.begin(), m_BreakPoints.end(),
+    //        [](const TBreakPoint& bp)
+    //        {
+    //            jit->GetBlockCache()->InvalidateICache(bp.iAddress, 4);
+    //        }
+    //    );
+    //}
+
+    m_BreakPoints.clear();
+}

src/common/break_points.h

@@ -0,0 +1,49 @@
+// Copyright 2013 Dolphin Emulator Project / 2014 Citra Emulator Project
+// Licensed under GPLv2 or any later version
+// Refer to the license.txt file included.
+
+#pragma once
+
+#include <string>
+#include <vector>
+#include "common/common_types.h"
+
+class DebugInterface;
+
+struct TBreakPoint {
+    u32 iAddress;
+    bool bOn;
+    bool bTemporary;
+};
+
+// Code breakpoints.
+class BreakPoints {
+public:
+    typedef std::vector<TBreakPoint> TBreakPoints;
+    typedef std::vector<std::string> TBreakPointsStr;
+
+    const TBreakPoints& GetBreakPoints() {
+        return m_BreakPoints;
+    }
+
+    TBreakPointsStr GetStrings() const;
+    void AddFromStrings(const TBreakPointsStr& bps);
+
+    // is address breakpoint
+    bool IsAddressBreakPoint(u32 iAddress) const;
+    bool IsTempBreakPoint(u32 iAddress) const;
+
+    // Add BreakPoint
+    void Add(u32 em_address, bool temp = false);
+    void Add(const TBreakPoint& bp);
+
+    // Remove Breakpoint
+    void Remove(u32 iAddress);
+    void Clear();
+
+    void DeleteByAddress(u32 Address);
+
+private:
+    TBreakPoints m_BreakPoints;
+    u32 m_iBreakOnCount;
+};

src/common/file_util.cpp

@@ -750,12 +750,6 @@ std::string GetHactoolConfigurationPath() {
 #endif
 }
 
-std::string GetNANDRegistrationDir(bool system) {
-    if (system)
-        return GetUserPath(UserPath::NANDDir) + "system/Contents/registered/";
-    return GetUserPath(UserPath::NANDDir) + "user/Contents/registered/";
-}
-
 size_t WriteStringToFile(bool text_file, const std::string& str, const char* filename) {
     return FileUtil::IOFile(filename, text_file ? "w" : "wb").WriteBytes(str.data(), str.size());
 }

src/common/file_util.h

@@ -129,8 +129,6 @@ const std::string& GetUserPath(UserPath path, const std::string& new_path = "");
 
 std::string GetHactoolConfigurationPath();
 
-std::string GetNANDRegistrationDir(bool system = false);
-
 // Returns the path to where the sys file are
 std::string GetSysDirectory();
 

src/common/hex_util.cpp

@@ -1,31 +0,0 @@
-// Copyright 2013 Dolphin Emulator Project / 2014 Citra Emulator Project
-// Licensed under GPLv2 or any later version
-// Refer to the license.txt file included.
-
-#include "common/hex_util.h"
-
-namespace Common {
-
-u8 ToHexNibble(char c1) {
-    if (c1 >= 65 && c1 <= 70)
-        return c1 - 55;
-    if (c1 >= 97 && c1 <= 102)
-        return c1 - 87;
-    if (c1 >= 48 && c1 <= 57)
-        return c1 - 48;
-    throw std::logic_error("Invalid hex digit");
-}
-
-std::array<u8, 16> operator""_array16(const char* str, size_t len) {
-    if (len != 32)
-        throw std::logic_error("Not of correct size.");
-    return HexStringToArray<16>(str);
-}
-
-std::array<u8, 32> operator""_array32(const char* str, size_t len) {
-    if (len != 64)
-        throw std::logic_error("Not of correct size.");
-    return HexStringToArray<32>(str);
-}
-
-} // namespace Common

src/common/hex_util.h

@@ -1,41 +0,0 @@
-// Copyright 2013 Dolphin Emulator Project / 2014 Citra Emulator Project
-// Licensed under GPLv2 or any later version
-// Refer to the license.txt file included.
-
-#pragma once
-
-#include <array>
-#include <cstddef>
-#include <string>
-#include <fmt/format.h>
-#include "common/common_types.h"
-
-namespace Common {
-
-u8 ToHexNibble(char c1);
-
-template <size_t Size, bool le = false>
-std::array<u8, Size> HexStringToArray(std::string_view str) {
-    std::array<u8, Size> out{};
-    if constexpr (le) {
-        for (size_t i = 2 * Size - 2; i <= 2 * Size; i -= 2)
-            out[i / 2] = (ToHexNibble(str[i]) << 4) | ToHexNibble(str[i + 1]);
-    } else {
-        for (size_t i = 0; i < 2 * Size; i += 2)
-            out[i / 2] = (ToHexNibble(str[i]) << 4) | ToHexNibble(str[i + 1]);
-    }
-    return out;
-}
-
-template <size_t Size>
-std::string HexArrayToString(std::array<u8, Size> array, bool upper = true) {
-    std::string out;
-    for (u8 c : array)
-        out += fmt::format(upper ? "{:02X}" : "{:02x}", c);
-    return out;
-}
-
-std::array<u8, 0x10> operator"" _array16(const char* str, size_t len);
-std::array<u8, 0x20> operator"" _array32(const char* str, size_t len);
-
-} // namespace Common

src/common/logging/backend.cpp

@@ -302,14 +302,13 @@ Backend* GetBackend(std::string_view backend_name) {
 void FmtLogMessageImpl(Class log_class, Level log_level, const char* filename,
                        unsigned int line_num, const char* function, const char* format,
                        const fmt::format_args& args) {
-    auto& instance = Impl::Instance();
-    const auto& filter = instance.GetGlobalFilter();
+    auto filter = Impl::Instance().GetGlobalFilter();
     if (!filter.CheckMessage(log_class, log_level))
         return;
 
     Entry entry =
         CreateEntry(log_class, log_level, filename, line_num, function, fmt::vformat(format, args));
 
-    instance.PushEntry(std::move(entry));
+    Impl::Instance().PushEntry(std::move(entry));
 }
 } // namespace Log

src/common/misc.cpp

@@ -4,7 +4,7 @@
 
 #include <cstddef>
 #ifdef _WIN32
-#include <windows.h>
+#include <Windows.h>
 #else
 #include <cerrno>
 #include <cstring>

src/common/x64/xbyak_abi.h

@@ -9,9 +9,10 @@
 #include "common/assert.h"
 #include "common/bit_set.h"
 
-namespace Common::X64 {
+namespace Common {
+namespace X64 {
 
-inline int RegToIndex(const Xbyak::Reg& reg) {
+int RegToIndex(const Xbyak::Reg& reg) {
     using Kind = Xbyak::Reg::Kind;
     ASSERT_MSG((reg.getKind() & (Kind::REG | Kind::XMM)) != 0,
                "RegSet only support GPRs and XMM registers.");
@@ -151,8 +152,8 @@ constexpr size_t ABI_SHADOW_SPACE = 0;
 
 #endif
 
-inline void ABI_CalculateFrameSize(BitSet32 regs, size_t rsp_alignment, size_t needed_frame_size,
-                                   s32* out_subtraction, s32* out_xmm_offset) {
+void ABI_CalculateFrameSize(BitSet32 regs, size_t rsp_alignment, size_t needed_frame_size,
+                            s32* out_subtraction, s32* out_xmm_offset) {
     int count = (regs & ABI_ALL_GPRS).Count();
     rsp_alignment -= count * 8;
     size_t subtraction = 0;
@@ -173,8 +174,8 @@ inline void ABI_CalculateFrameSize(BitSet32 regs, size_t rsp_alignment, size_t n
     *out_xmm_offset = (s32)(subtraction - xmm_base_subtraction);
 }
 
-inline size_t ABI_PushRegistersAndAdjustStack(Xbyak::CodeGenerator& code, BitSet32 regs,
-                                              size_t rsp_alignment, size_t needed_frame_size = 0) {
+size_t ABI_PushRegistersAndAdjustStack(Xbyak::CodeGenerator& code, BitSet32 regs,
+                                       size_t rsp_alignment, size_t needed_frame_size = 0) {
     s32 subtraction, xmm_offset;
     ABI_CalculateFrameSize(regs, rsp_alignment, needed_frame_size, &subtraction, &xmm_offset);
 
@@ -194,8 +195,8 @@ inline size_t ABI_PushRegistersAndAdjustStack(Xbyak::CodeGenerator& code, BitSet
     return ABI_SHADOW_SPACE;
 }
 
-inline void ABI_PopRegistersAndAdjustStack(Xbyak::CodeGenerator& code, BitSet32 regs,
-                                           size_t rsp_alignment, size_t needed_frame_size = 0) {
+void ABI_PopRegistersAndAdjustStack(Xbyak::CodeGenerator& code, BitSet32 regs, size_t rsp_alignment,
+                                    size_t needed_frame_size = 0) {
     s32 subtraction, xmm_offset;
     ABI_CalculateFrameSize(regs, rsp_alignment, needed_frame_size, &subtraction, &xmm_offset);
 
@@ -216,4 +217,5 @@ inline void ABI_PopRegistersAndAdjustStack(Xbyak::CodeGenerator& code, BitSet32
     }
 }
 
-} // namespace Common::X64
+} // namespace X64
+} // namespace Common

src/common/x64/xbyak_util.h

@@ -8,7 +8,8 @@
 #include <xbyak.h>
 #include "common/x64/xbyak_abi.h"
 
-namespace Common::X64 {
+namespace Common {
+namespace X64 {
 
 // Constants for use with cmpps/cmpss
 enum {
@@ -44,4 +45,5 @@ inline void CallFarFunction(Xbyak::CodeGenerator& code, const T f) {
     }
 }
 
-} // namespace Common::X64
+} // namespace X64
+} // namespace Common

src/core/CMakeLists.txt

@@ -20,8 +20,6 @@ add_library(core STATIC
     crypto/key_manager.h
     crypto/ctr_encryption_layer.cpp
     crypto/ctr_encryption_layer.h
-    file_sys/bis_factory.cpp
-    file_sys/bis_factory.h
     file_sys/card_image.cpp
     file_sys/card_image.h
     file_sys/content_archive.cpp
@@ -31,14 +29,10 @@ add_library(core STATIC
     file_sys/directory.h
     file_sys/errors.h
     file_sys/mode.h
-    file_sys/nca_metadata.cpp
-    file_sys/nca_metadata.h
     file_sys/partition_filesystem.cpp
     file_sys/partition_filesystem.h
     file_sys/program_metadata.cpp
     file_sys/program_metadata.h
-    file_sys/registered_cache.cpp
-    file_sys/registered_cache.h
     file_sys/romfs.cpp
     file_sys/romfs.h
     file_sys/romfs_factory.cpp
@@ -49,8 +43,6 @@ add_library(core STATIC
     file_sys/sdmc_factory.h
     file_sys/vfs.cpp
     file_sys/vfs.h
-    file_sys/vfs_concat.cpp
-    file_sys/vfs_concat.h
     file_sys/vfs_offset.cpp
     file_sys/vfs_offset.h
     file_sys/vfs_real.cpp
@@ -257,10 +249,6 @@ add_library(core STATIC
     hle/service/nvdrv/devices/nvhost_gpu.h
     hle/service/nvdrv/devices/nvhost_nvdec.cpp
     hle/service/nvdrv/devices/nvhost_nvdec.h
-    hle/service/nvdrv/devices/nvhost_nvjpg.cpp
-    hle/service/nvdrv/devices/nvhost_nvjpg.h
-    hle/service/nvdrv/devices/nvhost_vic.cpp
-    hle/service/nvdrv/devices/nvhost_vic.h
     hle/service/nvdrv/devices/nvmap.cpp
     hle/service/nvdrv/devices/nvmap.h
     hle/service/nvdrv/interface.cpp

src/core/arm/dynarmic/arm_dynarmic.cpp

@@ -134,9 +134,6 @@ std::unique_ptr<Dynarmic::A64::Jit> ARM_Dynarmic::MakeJit() const {
     config.dczid_el0 = 4;
     config.ctr_el0 = 0x8444c004;
 
-    // Unpredictable instructions
-    config.define_unpredictable_behaviour = true;
-
     return std::make_unique<Dynarmic::A64::Jit>(config);
 }
 
@@ -246,7 +243,9 @@ void ARM_Dynarmic::LoadContext(const ThreadContext& ctx) {
 }
 
 void ARM_Dynarmic::PrepareReschedule() {
-    jit->HaltExecution();
+    if (jit->IsExecuting()) {
+        jit->HaltExecution();
+    }
 }
 
 void ARM_Dynarmic::ClearInstructionCache() {

src/core/core.cpp

@@ -5,7 +5,6 @@
 #include <memory>
 #include <utility>
 #include "common/logging/log.h"
-#include "common/string_util.h"
 #include "core/core.h"
 #include "core/core_timing.h"
 #include "core/gdbstub/gdbstub.h"
@@ -18,7 +17,6 @@
 #include "core/hle/service/sm/sm.h"
 #include "core/loader/loader.h"
 #include "core/settings.h"
-#include "file_sys/vfs_concat.h"
 #include "file_sys/vfs_real.h"
 #include "video_core/renderer_base.h"
 #include "video_core/video_core.h"
@@ -90,39 +88,8 @@ System::ResultStatus System::SingleStep() {
     return RunLoop(false);
 }
 
-static FileSys::VirtualFile GetGameFileFromPath(const FileSys::VirtualFilesystem& vfs,
-                                                const std::string& path) {
-    // To account for split 00+01+etc files.
-    std::string dir_name;
-    std::string filename;
-    Common::SplitPath(path, &dir_name, &filename, nullptr);
-    if (filename == "00") {
-        const auto dir = vfs->OpenDirectory(dir_name, FileSys::Mode::Read);
-        std::vector<FileSys::VirtualFile> concat;
-        for (u8 i = 0; i < 0x10; ++i) {
-            auto next = dir->GetFile(fmt::format("{:02X}", i));
-            if (next != nullptr)
-                concat.push_back(std::move(next));
-            else {
-                next = dir->GetFile(fmt::format("{:02x}", i));
-                if (next != nullptr)
-                    concat.push_back(std::move(next));
-                else
-                    break;
-            }
-        }
-
-        if (concat.empty())
-            return nullptr;
-
-        return FileSys::ConcatenateFiles(concat, dir->GetName());
-    }
-
-    return vfs->OpenFile(path, FileSys::Mode::Read);
-}
-
 System::ResultStatus System::Load(Frontend::EmuWindow& emu_window, const std::string& filepath) {
-    app_loader = Loader::GetLoader(GetGameFileFromPath(virtual_filesystem, filepath));
+    app_loader = Loader::GetLoader(virtual_filesystem->OpenFile(filepath, FileSys::Mode::Read));
 
     if (!app_loader) {
         LOG_CRITICAL(Core, "Failed to obtain loader for {}!", filepath);

src/core/core.h

@@ -40,12 +40,6 @@ namespace Core {
 
 class System {
 public:
-    System(const System&) = delete;
-    System& operator=(const System&) = delete;
-
-    System(System&&) = delete;
-    System& operator=(System&&) = delete;
-
     ~System();
 
     /**

src/core/core_cpu.cpp

@@ -25,7 +25,7 @@ void CpuBarrier::NotifyEnd() {
     condition.notify_all();
 }
 
-bool CpuBarrier::Rendezvous() {
+bool CpuBarrier::Rendezvous(bool main_core) {
     if (!Settings::values.use_multi_core) {
         // Meaningless when running in single-core mode
         return true;
@@ -36,11 +36,21 @@ bool CpuBarrier::Rendezvous() {
 
         --cores_waiting;
         if (!cores_waiting) {
+            if (CoreTiming::MainSliceWasCropped() && main_core) {
+                // This is the main thread but we were cropped, so just continue;
+                ++cores_waiting;
+                return true;
+            }
             cores_waiting = NUM_CPU_CORES;
             condition.notify_all();
             return true;
         }
 
+        if (CoreTiming::MainSliceWasCropped() && main_core) {
+            // This is the main thread but we were cropped, so just continue;
+            ++cores_waiting;
+            return true;
+        }
         condition.wait(lock);
         return true;
     }
@@ -80,7 +90,7 @@ std::shared_ptr<ExclusiveMonitor> Cpu::MakeExclusiveMonitor(size_t num_cores) {
 
 void Cpu::RunLoop(bool tight_loop) {
     // Wait for all other CPU cores to complete the previous slice, such that they run in lock-step
-    if (!cpu_barrier->Rendezvous()) {
+    if (!cpu_barrier->Rendezvous(IsMainCore())) {
         // If rendezvous failed, session has been killed
         return;
     }
@@ -89,18 +99,11 @@ void Cpu::RunLoop(bool tight_loop) {
     // instead advance to the next event and try to yield to the next thread
     if (Kernel::GetCurrentThread() == nullptr) {
         LOG_TRACE(Core, "Core-{} idling", core_index);
-
-        if (IsMainCore()) {
-            // TODO(Subv): Only let CoreTiming idle if all 4 cores are idling.
-            CoreTiming::Idle();
-            CoreTiming::Advance();
-        }
-
+        CoreTiming::Idle();
+        CoreTiming::Advance();
         PrepareReschedule();
     } else {
-        if (IsMainCore()) {
-            CoreTiming::Advance();
-        }
+        CoreTiming::Advance();
 
         if (tight_loop) {
             arm_interface->Run();

src/core/core_cpu.h

@@ -30,7 +30,7 @@ public:
 
     void NotifyEnd();
 
-    bool Rendezvous();
+    bool Rendezvous(bool main_core);
 
 private:
     unsigned cores_waiting{NUM_CPU_CORES};

src/core/core_timing.cpp

@@ -13,13 +13,16 @@
 #include "common/assert.h"
 #include "common/thread.h"
 #include "common/threadsafe_queue.h"
+#include "core/core.h"
+#include "core/core_cpu.h"
 #include "core/core_timing_util.h"
 
 namespace CoreTiming {
 
 static s64 global_timer;
 static int slice_length;
-static int downcount;
+static int next_slice_length;
+static std::array<int, Core::NUM_CPU_CORES> downcount;
 
 struct EventType {
     TimedCallback callback;
@@ -56,12 +59,9 @@ static u64 event_fifo_id;
 // to the event_queue by the emu thread
 static Common::MPSCQueue<Event, false> ts_queue;
 
-// the queue for unscheduling the events from other threads threadsafe
-static Common::MPSCQueue<std::pair<const EventType*, u64>, false> unschedule_queue;
-
 constexpr int MAX_SLICE_LENGTH = 20000;
 
-static s64 idled_cycles;
+static std::mutex mutex;
 
 // Are we in a function that has been called from Advance()
 // If events are sheduled from a function that gets called from Advance(),
@@ -92,10 +92,11 @@ void UnregisterAllEvents() {
 }
 
 void Init() {
-    downcount = MAX_SLICE_LENGTH;
+    std::unique_lock<std::mutex> lock(mutex);
+    downcount.fill(MAX_SLICE_LENGTH);
     slice_length = MAX_SLICE_LENGTH;
+    next_slice_length = MAX_SLICE_LENGTH;
     global_timer = 0;
-    idled_cycles = 0;
 
     // The time between CoreTiming being intialized and the first call to Advance() is considered
     // the slice boundary between slice -1 and slice 0. Dispatcher loops must call Advance() before
@@ -116,19 +117,17 @@ void Shutdown() {
 // This should only be called from the CPU thread. If you are calling
 // it from any other thread, you are doing something evil
 u64 GetTicks() {
+    std::unique_lock<std::mutex> lock(mutex);
     u64 ticks = static_cast<u64>(global_timer);
     if (!is_global_timer_sane) {
-        ticks += slice_length - downcount;
+        ticks += slice_length - downcount[0];
     }
     return ticks;
 }
 
 void AddTicks(u64 ticks) {
-    downcount -= static_cast<int>(ticks);
-}
-
-u64 GetIdleTicks() {
-    return static_cast<u64>(idled_cycles);
+    std::unique_lock<std::mutex> lock(mutex);
+    downcount[Core::System::GetInstance().CurrentCoreIndex()] -= static_cast<int>(ticks);
 }
 
 void ClearPendingEvents() {
@@ -146,6 +145,7 @@ void ScheduleEvent(s64 cycles_into_future, const EventType* event_type, u64 user
 }
 
 void ScheduleEventThreadsafe(s64 cycles_into_future, const EventType* event_type, u64 userdata) {
+    std::unique_lock<std::mutex> lock(mutex);
     ts_queue.Push(Event{global_timer + cycles_into_future, 0, userdata, event_type});
 }
 
@@ -161,10 +161,6 @@ void UnscheduleEvent(const EventType* event_type, u64 userdata) {
     }
 }
 
-void UnscheduleEventThreadsafe(const EventType* event_type, u64 userdata) {
-    unschedule_queue.Push(std::make_pair(event_type, userdata));
-}
-
 void RemoveEvent(const EventType* event_type) {
     auto itr = std::remove_if(event_queue.begin(), event_queue.end(),
                               [&](const Event& e) { return e.type == event_type; });
@@ -183,11 +179,14 @@ void RemoveNormalAndThreadsafeEvent(const EventType* event_type) {
 
 void ForceExceptionCheck(s64 cycles) {
     cycles = std::max<s64>(0, cycles);
-    if (downcount > cycles) {
+    std::unique_lock<std::mutex> lock(mutex);
+    if (downcount[0] > cycles) {
         // downcount is always (much) smaller than MAX_INT so we can safely cast cycles to an int
         // here. Account for cycles already executed by adjusting the g.slice_length
-        slice_length -= downcount - static_cast<int>(cycles);
-        downcount = static_cast<int>(cycles);
+        slice_length -= downcount[0] - static_cast<int>(cycles);
+        downcount[0] = static_cast<int>(cycles);
+        if (next_slice_length <= 0)
+            next_slice_length = MAX_SLICE_LENGTH;
     }
 }
 
@@ -200,14 +199,19 @@ void MoveEvents() {
 }
 
 void Advance() {
-    MoveEvents();
-    for (std::pair<const EventType*, u64> ev; unschedule_queue.Pop(ev);) {
-        UnscheduleEvent(ev.first, ev.second);
+    std::unique_lock<std::mutex> lock(mutex);
+    const size_t current_core = Core::System::GetInstance().CurrentCoreIndex();
+    if (current_core != 0) {
+        downcount[current_core] = MAX_SLICE_LENGTH;
+        return;
     }
 
-    int cycles_executed = slice_length - downcount;
+    MoveEvents();
+
+    int cycles_executed = slice_length - downcount[0];
     global_timer += cycles_executed;
-    slice_length = MAX_SLICE_LENGTH;
+    slice_length = next_slice_length;
+    next_slice_length = MAX_SLICE_LENGTH;
 
     is_global_timer_sane = true;
 
@@ -226,12 +230,18 @@ void Advance() {
             std::min<s64>(event_queue.front().time - global_timer, MAX_SLICE_LENGTH));
     }
 
-    downcount = slice_length;
+    downcount[0] = slice_length;
+    next_slice_length = MAX_SLICE_LENGTH - slice_length;
 }
 
 void Idle() {
-    idled_cycles += downcount;
-    downcount = 0;
+    std::unique_lock<std::mutex> lock(mutex);
+    downcount[Core::System::GetInstance().CurrentCoreIndex()] = 0;
+}
+
+bool MainSliceWasCropped() {
+    std::unique_lock<std::mutex> lock(mutex);
+    return next_slice_length != MAX_SLICE_LENGTH;
 }
 
 std::chrono::microseconds GetGlobalTimeUs() {
@@ -239,7 +249,8 @@ std::chrono::microseconds GetGlobalTimeUs() {
 }
 
 int GetDowncount() {
-    return downcount;
+    std::unique_lock<std::mutex> lock(mutex);
+    return downcount[Core::System::GetInstance().CurrentCoreIndex()];
 }
 
 } // namespace CoreTiming

src/core/core_timing.h

@@ -40,7 +40,6 @@ void Shutdown();
  * doing something evil
  */
 u64 GetTicks();
-u64 GetIdleTicks();
 void AddTicks(u64 ticks);
 
 /**
@@ -65,7 +64,6 @@ void ScheduleEvent(s64 cycles_into_future, const EventType* event_type, u64 user
 void ScheduleEventThreadsafe(s64 cycles_into_future, const EventType* event_type, u64 userdata);
 
 void UnscheduleEvent(const EventType* event_type, u64 userdata);
-void UnscheduleEventThreadsafe(const EventType* event_type, u64 userdata);
 
 /// We only permit one event of each type in the queue at a time.
 void RemoveEvent(const EventType* event_type);
@@ -83,6 +81,9 @@ void MoveEvents();
 /// Pretend that the main CPU has executed enough cycles to reach the next event.
 void Idle();
 
+/// Checks if the Main Core executed less then MAX_SLICE_LENGTH
+bool MainSliceWasCropped();
+
 /// Clear all pending events. This should ONLY be done on exit.
 void ClearPendingEvents();
 

src/core/crypto/key_manager.cpp

@@ -10,13 +10,44 @@
 #include <string_view>
 #include "common/common_paths.h"
 #include "common/file_util.h"
-#include "common/hex_util.h"
-#include "common/logging/log.h"
 #include "core/crypto/key_manager.h"
 #include "core/settings.h"
 
 namespace Core::Crypto {
 
+static u8 ToHexNibble(char c1) {
+    if (c1 >= 65 && c1 <= 70)
+        return c1 - 55;
+    if (c1 >= 97 && c1 <= 102)
+        return c1 - 87;
+    if (c1 >= 48 && c1 <= 57)
+        return c1 - 48;
+    throw std::logic_error("Invalid hex digit");
+}
+
+template <size_t Size>
+static std::array<u8, Size> HexStringToArray(std::string_view str) {
+    std::array<u8, Size> out{};
+    for (size_t i = 0; i < 2 * Size; i += 2) {
+        auto d1 = str[i];
+        auto d2 = str[i + 1];
+        out[i / 2] = (ToHexNibble(d1) << 4) | ToHexNibble(d2);
+    }
+    return out;
+}
+
+std::array<u8, 16> operator""_array16(const char* str, size_t len) {
+    if (len != 32)
+        throw std::logic_error("Not of correct size.");
+    return HexStringToArray<16>(str);
+}
+
+std::array<u8, 32> operator""_array32(const char* str, size_t len) {
+    if (len != 64)
+        throw std::logic_error("Not of correct size.");
+    return HexStringToArray<32>(str);
+}
+
 KeyManager::KeyManager() {
     // Initialize keys
     const std::string hactool_keys_dir = FileUtil::GetHactoolConfigurationPath();
@@ -52,20 +83,20 @@ void KeyManager::LoadFromFile(const std::string& filename, bool is_title_keys) {
         out[1].erase(std::remove(out[1].begin(), out[1].end(), ' '), out[1].end());
 
         if (is_title_keys) {
-            auto rights_id_raw = Common::HexStringToArray<16>(out[0]);
+            auto rights_id_raw = HexStringToArray<16>(out[0]);
             u128 rights_id{};
             std::memcpy(rights_id.data(), rights_id_raw.data(), rights_id_raw.size());
-            Key128 key = Common::HexStringToArray<16>(out[1]);
+            Key128 key = HexStringToArray<16>(out[1]);
             SetKey(S128KeyType::Titlekey, key, rights_id[1], rights_id[0]);
         } else {
             std::transform(out[0].begin(), out[0].end(), out[0].begin(), ::tolower);
             if (s128_file_id.find(out[0]) != s128_file_id.end()) {
                 const auto index = s128_file_id.at(out[0]);
-                Key128 key = Common::HexStringToArray<16>(out[1]);
+                Key128 key = HexStringToArray<16>(out[1]);
                 SetKey(index.type, key, index.field1, index.field2);
             } else if (s256_file_id.find(out[0]) != s256_file_id.end()) {
                 const auto index = s256_file_id.at(out[0]);
-                Key256 key = Common::HexStringToArray<32>(out[1]);
+                Key256 key = HexStringToArray<32>(out[1]);
                 SetKey(index.type, key, index.field1, index.field2);
             }
         }

src/core/crypto/key_manager.h

@@ -87,6 +87,9 @@ struct hash<Core::Crypto::KeyIndex<KeyType>> {
 
 namespace Core::Crypto {
 
+std::array<u8, 0x10> operator"" _array16(const char* str, size_t len);
+std::array<u8, 0x20> operator"" _array32(const char* str, size_t len);
+
 class KeyManager {
 public:
     KeyManager();

src/core/file_sys/bis_factory.cpp

@@ -1,31 +0,0 @@
-// Copyright 2018 yuzu emulator team
-// Licensed under GPLv2 or any later version
-// Refer to the license.txt file included.
-
-#include "core/file_sys/bis_factory.h"
-
-namespace FileSys {
-
-static VirtualDir GetOrCreateDirectory(const VirtualDir& dir, std::string_view path) {
-    const auto res = dir->GetDirectoryRelative(path);
-    if (res == nullptr)
-        return dir->CreateDirectoryRelative(path);
-    return res;
-}
-
-BISFactory::BISFactory(VirtualDir nand_root_)
-    : nand_root(std::move(nand_root_)),
-      sysnand_cache(std::make_shared<RegisteredCache>(
-          GetOrCreateDirectory(nand_root, "/system/Contents/registered"))),
-      usrnand_cache(std::make_shared<RegisteredCache>(
-          GetOrCreateDirectory(nand_root, "/user/Contents/registered"))) {}
-
-std::shared_ptr<RegisteredCache> BISFactory::GetSystemNANDContents() const {
-    return sysnand_cache;
-}
-
-std::shared_ptr<RegisteredCache> BISFactory::GetUserNANDContents() const {
-    return usrnand_cache;
-}
-
-} // namespace FileSys

src/core/file_sys/bis_factory.h

@@ -1,30 +0,0 @@
-// Copyright 2018 yuzu emulator team
-// Licensed under GPLv2 or any later version
-// Refer to the license.txt file included.
-
-#pragma once
-
-#include <memory>
-#include "core/loader/loader.h"
-#include "registered_cache.h"
-
-namespace FileSys {
-
-/// File system interface to the Built-In Storage
-/// This is currently missing accessors to BIS partitions, but seemed like a good place for the NAND
-/// registered caches.
-class BISFactory {
-public:
-    explicit BISFactory(VirtualDir nand_root);
-
-    std::shared_ptr<RegisteredCache> GetSystemNANDContents() const;
-    std::shared_ptr<RegisteredCache> GetUserNANDContents() const;
-
-private:
-    VirtualDir nand_root;
-
-    std::shared_ptr<RegisteredCache> sysnand_cache;
-    std::shared_ptr<RegisteredCache> usrnand_cache;
-};
-
-} // namespace FileSys

src/core/file_sys/card_image.cpp

@@ -4,14 +4,11 @@
 
 #include <array>
 #include <string>
-
-#include <fmt/ostream.h>
-
+#include <core/loader/loader.h>
 #include "common/logging/log.h"
 #include "core/file_sys/card_image.h"
 #include "core/file_sys/partition_filesystem.h"
 #include "core/file_sys/vfs_offset.h"
-#include "core/loader/loader.h"
 
 namespace FileSys {
 
@@ -96,10 +93,6 @@ VirtualDir XCI::GetLogoPartition() const {
     return GetPartition(XCIPartition::Logo);
 }
 
-const std::vector<std::shared_ptr<NCA>>& XCI::GetNCAs() const {
-    return ncas;
-}
-
 std::shared_ptr<NCA> XCI::GetNCAByType(NCAContentType type) const {
     const auto iter =
         std::find_if(ncas.begin(), ncas.end(),
@@ -149,7 +142,7 @@ Loader::ResultStatus XCI::AddNCAFromPartition(XCIPartition part) {
             const u16 error_id = static_cast<u16>(nca->GetStatus());
             LOG_CRITICAL(Loader, "Could not load NCA {}/{}, failed with error code {:04X} ({})",
                          partition_names[static_cast<size_t>(part)], nca->GetName(), error_id,
-                         nca->GetStatus());
+                         Loader::GetMessageForResultStatus(nca->GetStatus()));
         }
     }
 

src/core/file_sys/card_image.h

@@ -68,7 +68,6 @@ public:
     VirtualDir GetUpdatePartition() const;
     VirtualDir GetLogoPartition() const;
 
-    const std::vector<std::shared_ptr<NCA>>& GetNCAs() const;
     std::shared_ptr<NCA> GetNCAByType(NCAContentType type) const;
     VirtualFile GetNCAFileByType(NCAContentType type) const;
 

src/core/file_sys/content_archive.h

@@ -27,7 +27,6 @@ enum class NCAContentType : u8 {
     Control = 2,
     Manual = 3,
     Data = 4,
-    Data_Unknown5 = 5, ///< Seems to be used on some system archives
 };
 
 enum class NCASectionCryptoType : u8 {

src/core/file_sys/control_metadata.cpp

@@ -16,7 +16,7 @@ std::string LanguageEntry::GetDeveloperName() const {
     return Common::StringFromFixedZeroTerminatedBuffer(developer_name.data(), 0x100);
 }
 
-NACP::NACP(VirtualFile file) : raw(std::make_unique<RawNACP>()) {
+NACP::NACP(VirtualFile file_) : file(std::move(file_)), raw(std::make_unique<RawNACP>()) {
     file->ReadObject(raw.get());
 }
 

src/core/file_sys/control_metadata.h

@@ -81,6 +81,7 @@ public:
     std::string GetVersionString() const;
 
 private:
+    VirtualFile file;
     std::unique_ptr<RawNACP> raw;
 };
 

src/core/file_sys/nca_metadata.cpp

@@ -1,131 +0,0 @@
-// Copyright 2018 yuzu emulator team
-// Licensed under GPLv2 or any later version
-// Refer to the license.txt file included.
-
-#include <cstring>
-#include "common/common_funcs.h"
-#include "common/logging/log.h"
-#include "common/swap.h"
-#include "content_archive.h"
-#include "core/file_sys/nca_metadata.h"
-
-namespace FileSys {
-
-bool operator>=(TitleType lhs, TitleType rhs) {
-    return static_cast<size_t>(lhs) >= static_cast<size_t>(rhs);
-}
-
-bool operator<=(TitleType lhs, TitleType rhs) {
-    return static_cast<size_t>(lhs) <= static_cast<size_t>(rhs);
-}
-
-CNMT::CNMT(VirtualFile file) {
-    if (file->ReadObject(&header) != sizeof(CNMTHeader))
-        return;
-
-    // If type is {Application, Update, AOC} has opt-header.
-    if (header.type >= TitleType::Application && header.type <= TitleType::AOC) {
-        if (file->ReadObject(&opt_header, sizeof(CNMTHeader)) != sizeof(OptionalHeader)) {
-            LOG_WARNING(Loader, "Failed to read optional header.");
-        }
-    }
-
-    for (u16 i = 0; i < header.number_content_entries; ++i) {
-        auto& next = content_records.emplace_back(ContentRecord{});
-        if (file->ReadObject(&next, sizeof(CNMTHeader) + i * sizeof(ContentRecord) +
-                                        header.table_offset) != sizeof(ContentRecord)) {
-            content_records.erase(content_records.end() - 1);
-        }
-    }
-
-    for (u16 i = 0; i < header.number_meta_entries; ++i) {
-        auto& next = meta_records.emplace_back(MetaRecord{});
-        if (file->ReadObject(&next, sizeof(CNMTHeader) + i * sizeof(MetaRecord) +
-                                        header.table_offset) != sizeof(MetaRecord)) {
-            meta_records.erase(meta_records.end() - 1);
-        }
-    }
-}
-
-CNMT::CNMT(CNMTHeader header, OptionalHeader opt_header, std::vector<ContentRecord> content_records,
-           std::vector<MetaRecord> meta_records)
-    : header(std::move(header)), opt_header(std::move(opt_header)),
-      content_records(std::move(content_records)), meta_records(std::move(meta_records)) {}
-
-u64 CNMT::GetTitleID() const {
-    return header.title_id;
-}
-
-u32 CNMT::GetTitleVersion() const {
-    return header.title_version;
-}
-
-TitleType CNMT::GetType() const {
-    return header.type;
-}
-
-const std::vector<ContentRecord>& CNMT::GetContentRecords() const {
-    return content_records;
-}
-
-const std::vector<MetaRecord>& CNMT::GetMetaRecords() const {
-    return meta_records;
-}
-
-bool CNMT::UnionRecords(const CNMT& other) {
-    bool change = false;
-    for (const auto& rec : other.content_records) {
-        const auto iter = std::find_if(content_records.begin(), content_records.end(),
-                                       [&rec](const ContentRecord& r) {
-                                           return r.nca_id == rec.nca_id && r.type == rec.type;
-                                       });
-        if (iter == content_records.end()) {
-            content_records.emplace_back(rec);
-            ++header.number_content_entries;
-            change = true;
-        }
-    }
-    for (const auto& rec : other.meta_records) {
-        const auto iter =
-            std::find_if(meta_records.begin(), meta_records.end(), [&rec](const MetaRecord& r) {
-                return r.title_id == rec.title_id && r.title_version == rec.title_version &&
-                       r.type == rec.type;
-            });
-        if (iter == meta_records.end()) {
-            meta_records.emplace_back(rec);
-            ++header.number_meta_entries;
-            change = true;
-        }
-    }
-    return change;
-}
-
-std::vector<u8> CNMT::Serialize() const {
-    const bool has_opt_header =
-        header.type >= TitleType::Application && header.type <= TitleType::AOC;
-    const auto dead_zone = header.table_offset + sizeof(CNMTHeader);
-    std::vector<u8> out(
-        std::max(sizeof(CNMTHeader) + (has_opt_header ? sizeof(OptionalHeader) : 0), dead_zone) +
-        content_records.size() * sizeof(ContentRecord) + meta_records.size() * sizeof(MetaRecord));
-    memcpy(out.data(), &header, sizeof(CNMTHeader));
-
-    // Optional Header
-    if (has_opt_header) {
-        memcpy(out.data() + sizeof(CNMTHeader), &opt_header, sizeof(OptionalHeader));
-    }
-
-    auto offset = header.table_offset;
-
-    for (const auto& rec : content_records) {
-        memcpy(out.data() + offset + sizeof(CNMTHeader), &rec, sizeof(ContentRecord));
-        offset += sizeof(ContentRecord);
-    }
-
-    for (const auto& rec : meta_records) {
-        memcpy(out.data() + offset + sizeof(CNMTHeader), &rec, sizeof(MetaRecord));
-        offset += sizeof(MetaRecord);
-    }
-
-    return out;
-}
-} // namespace FileSys

src/core/file_sys/nca_metadata.h

@@ -1,111 +0,0 @@
-// Copyright 2018 yuzu emulator team
-// Licensed under GPLv2 or any later version
-// Refer to the license.txt file included.
-
-#pragma once
-
-#include <cstring>
-#include <memory>
-#include <vector>
-#include "common/common_types.h"
-#include "common/swap.h"
-#include "core/file_sys/vfs.h"
-
-namespace FileSys {
-class CNMT;
-
-struct CNMTHeader;
-struct OptionalHeader;
-
-enum class TitleType : u8 {
-    SystemProgram = 0x01,
-    SystemDataArchive = 0x02,
-    SystemUpdate = 0x03,
-    FirmwarePackageA = 0x04,
-    FirmwarePackageB = 0x05,
-    Application = 0x80,
-    Update = 0x81,
-    AOC = 0x82,
-    DeltaTitle = 0x83,
-};
-
-bool operator>=(TitleType lhs, TitleType rhs);
-bool operator<=(TitleType lhs, TitleType rhs);
-
-enum class ContentRecordType : u8 {
-    Meta = 0,
-    Program = 1,
-    Data = 2,
-    Control = 3,
-    Manual = 4,
-    Legal = 5,
-    Patch = 6,
-};
-
-struct ContentRecord {
-    std::array<u8, 0x20> hash;
-    std::array<u8, 0x10> nca_id;
-    std::array<u8, 0x6> size;
-    ContentRecordType type;
-    INSERT_PADDING_BYTES(1);
-};
-static_assert(sizeof(ContentRecord) == 0x38, "ContentRecord has incorrect size.");
-
-constexpr ContentRecord EMPTY_META_CONTENT_RECORD{{}, {}, {}, ContentRecordType::Meta, {}};
-
-struct MetaRecord {
-    u64_le title_id;
-    u32_le title_version;
-    TitleType type;
-    u8 install_byte;
-    INSERT_PADDING_BYTES(2);
-};
-static_assert(sizeof(MetaRecord) == 0x10, "MetaRecord has incorrect size.");
-
-struct OptionalHeader {
-    u64_le title_id;
-    u64_le minimum_version;
-};
-static_assert(sizeof(OptionalHeader) == 0x10, "OptionalHeader has incorrect size.");
-
-struct CNMTHeader {
-    u64_le title_id;
-    u32_le title_version;
-    TitleType type;
-    INSERT_PADDING_BYTES(1);
-    u16_le table_offset;
-    u16_le number_content_entries;
-    u16_le number_meta_entries;
-    INSERT_PADDING_BYTES(12);
-};
-static_assert(sizeof(CNMTHeader) == 0x20, "CNMTHeader has incorrect size.");
-
-// A class representing the format used by NCA metadata files, typically named {}.cnmt.nca or
-// meta0.ncd. These describe which NCA's belong with which titles in the registered cache.
-class CNMT {
-public:
-    explicit CNMT(VirtualFile file);
-    CNMT(CNMTHeader header, OptionalHeader opt_header, std::vector<ContentRecord> content_records,
-         std::vector<MetaRecord> meta_records);
-
-    u64 GetTitleID() const;
-    u32 GetTitleVersion() const;
-    TitleType GetType() const;
-
-    const std::vector<ContentRecord>& GetContentRecords() const;
-    const std::vector<MetaRecord>& GetMetaRecords() const;
-
-    bool UnionRecords(const CNMT& other);
-    std::vector<u8> Serialize() const;
-
-private:
-    CNMTHeader header;
-    OptionalHeader opt_header;
-    std::vector<ContentRecord> content_records;
-    std::vector<MetaRecord> meta_records;
-
-    // TODO(DarkLordZach): According to switchbrew, for Patch-type there is additional data
-    // after the table. This is not documented, unfortunately.
-};
-
-} // namespace FileSys

src/core/file_sys/registered_cache.cpp

@@ -1,479 +0,0 @@
-// Copyright 2018 yuzu emulator team
-// Licensed under GPLv2 or any later version
-// Refer to the license.txt file included.
-
-#include <regex>
-#include <mbedtls/sha256.h>
-#include "common/assert.h"
-#include "common/hex_util.h"
-#include "common/logging/log.h"
-#include "core/crypto/encryption_layer.h"
-#include "core/file_sys/card_image.h"
-#include "core/file_sys/nca_metadata.h"
-#include "core/file_sys/registered_cache.h"
-#include "core/file_sys/vfs_concat.h"
-
-namespace FileSys {
-std::string RegisteredCacheEntry::DebugInfo() const {
-    return fmt::format("title_id={:016X}, content_type={:02X}", title_id, static_cast<u8>(type));
-}
-
-bool operator<(const RegisteredCacheEntry& lhs, const RegisteredCacheEntry& rhs) {
-    return (lhs.title_id < rhs.title_id) || (lhs.title_id == rhs.title_id && lhs.type < rhs.type);
-}
-
-static bool FollowsTwoDigitDirFormat(std::string_view name) {
-    static const std::regex two_digit_regex("000000[0-9A-F]{2}", std::regex_constants::ECMAScript |
-                                                                     std::regex_constants::icase);
-    return std::regex_match(name.begin(), name.end(), two_digit_regex);
-}
-
-static bool FollowsNcaIdFormat(std::string_view name) {
-    static const std::regex nca_id_regex("[0-9A-F]{32}\\.nca", std::regex_constants::ECMAScript |
-                                                                   std::regex_constants::icase);
-    return name.size() == 36 && std::regex_match(name.begin(), name.end(), nca_id_regex);
-}
-
-static std::string GetRelativePathFromNcaID(const std::array<u8, 16>& nca_id, bool second_hex_upper,
-                                            bool within_two_digit) {
-    if (!within_two_digit)
-        return fmt::format("/{}.nca", Common::HexArrayToString(nca_id, second_hex_upper));
-
-    Core::Crypto::SHA256Hash hash{};
-    mbedtls_sha256(nca_id.data(), nca_id.size(), hash.data(), 0);
-    return fmt::format("/000000{:02X}/{}.nca", hash[0],
-                       Common::HexArrayToString(nca_id, second_hex_upper));
-}
-
-static std::string GetCNMTName(TitleType type, u64 title_id) {
-    constexpr std::array<const char*, 9> TITLE_TYPE_NAMES{
-        "SystemProgram",
-        "SystemData",
-        "SystemUpdate",
-        "BootImagePackage",
-        "BootImagePackageSafe",
-        "Application",
-        "Patch",
-        "AddOnContent",
-        "" ///< Currently unknown 'DeltaTitle'
-    };
-
-    auto index = static_cast<size_t>(type);
-    // If the index is after the jump in TitleType, subtract it out.
-    if (index >= static_cast<size_t>(TitleType::Application)) {
-        index -= static_cast<size_t>(TitleType::Application) -
-                 static_cast<size_t>(TitleType::FirmwarePackageB);
-    }
-    return fmt::format("{}_{:016x}.cnmt", TITLE_TYPE_NAMES[index], title_id);
-}
-
-static ContentRecordType GetCRTypeFromNCAType(NCAContentType type) {
-    switch (type) {
-    case NCAContentType::Program:
-        // TODO(DarkLordZach): Differentiate between Program and Patch
-        return ContentRecordType::Program;
-    case NCAContentType::Meta:
-        return ContentRecordType::Meta;
-    case NCAContentType::Control:
-        return ContentRecordType::Control;
-    case NCAContentType::Data:
-    case NCAContentType::Data_Unknown5:
-        return ContentRecordType::Data;
-    case NCAContentType::Manual:
-        // TODO(DarkLordZach): Peek at NCA contents to differentiate Manual and Legal.
-        return ContentRecordType::Manual;
-    default:
-        UNREACHABLE_MSG("Invalid NCAContentType={:02X}", static_cast<u8>(type));
-    }
-}
-
-VirtualFile RegisteredCache::OpenFileOrDirectoryConcat(const VirtualDir& dir,
-                                                       std::string_view path) const {
-    if (dir->GetFileRelative(path) != nullptr)
-        return dir->GetFileRelative(path);
-    if (dir->GetDirectoryRelative(path) != nullptr) {
-        const auto nca_dir = dir->GetDirectoryRelative(path);
-        VirtualFile file = nullptr;
-
-        const auto files = nca_dir->GetFiles();
-        if (files.size() == 1 && files[0]->GetName() == "00") {
-            file = files[0];
-        } else {
-            std::vector<VirtualFile> concat;
-            // Since the files are a two-digit hex number, max is FF.
-            for (size_t i = 0; i < 0x100; ++i) {
-                auto next = nca_dir->GetFile(fmt::format("{:02X}", i));
-                if (next != nullptr) {
-                    concat.push_back(std::move(next));
-                } else {
-                    next = nca_dir->GetFile(fmt::format("{:02x}", i));
-                    if (next != nullptr)
-                        concat.push_back(std::move(next));
-                    else
-                        break;
-                }
-            }
-
-            if (concat.empty())
-                return nullptr;
-
-            file = FileSys::ConcatenateFiles(concat);
-        }
-
-        return file;
-    }
-    return nullptr;
-}
-
-VirtualFile RegisteredCache::GetFileAtID(NcaID id) const {
-    VirtualFile file;
-    // Try all four modes of file storage:
-    // (bit 1 = uppercase/lower, bit 0 = within a two-digit dir)
-    // 00: /000000**/{:032X}.nca
-    // 01: /{:032X}.nca
-    // 10: /000000**/{:032x}.nca
-    // 11: /{:032x}.nca
-    for (u8 i = 0; i < 4; ++i) {
-        const auto path = GetRelativePathFromNcaID(id, (i & 0b10) == 0, (i & 0b01) == 0);
-        file = OpenFileOrDirectoryConcat(dir, path);
-        if (file != nullptr)
-            return file;
-    }
-    return file;
-}
-
-static boost::optional<NcaID> CheckMapForContentRecord(
-    const boost::container::flat_map<u64, CNMT>& map, u64 title_id, ContentRecordType type) {
-    if (map.find(title_id) == map.end())
-        return boost::none;
-
-    const auto& cnmt = map.at(title_id);
-
-    const auto iter = std::find_if(cnmt.GetContentRecords().begin(), cnmt.GetContentRecords().end(),
-                                   [type](const ContentRecord& rec) { return rec.type == type; });
-    if (iter == cnmt.GetContentRecords().end())
-        return boost::none;
-
-    return boost::make_optional(iter->nca_id);
-}
-
-boost::optional<NcaID> RegisteredCache::GetNcaIDFromMetadata(u64 title_id,
-                                                             ContentRecordType type) const {
-    if (type == ContentRecordType::Meta && meta_id.find(title_id) != meta_id.end())
-        return meta_id.at(title_id);
-
-    const auto res1 = CheckMapForContentRecord(yuzu_meta, title_id, type);
-    if (res1 != boost::none)
-        return res1;
-    return CheckMapForContentRecord(meta, title_id, type);
-}
-
-std::vector<NcaID> RegisteredCache::AccumulateFiles() const {
-    std::vector<NcaID> ids;
-    for (const auto& d2_dir : dir->GetSubdirectories()) {
-        if (FollowsNcaIdFormat(d2_dir->GetName())) {
-            ids.push_back(Common::HexStringToArray<0x10, true>(d2_dir->GetName().substr(0, 0x20)));
-            continue;
-        }
-
-        if (!FollowsTwoDigitDirFormat(d2_dir->GetName()))
-            continue;
-
-        for (const auto& nca_dir : d2_dir->GetSubdirectories()) {
-            if (!FollowsNcaIdFormat(nca_dir->GetName()))
-                continue;
-
-            ids.push_back(Common::HexStringToArray<0x10, true>(nca_dir->GetName().substr(0, 0x20)));
-        }
-
-        for (const auto& nca_file : d2_dir->GetFiles()) {
-            if (!FollowsNcaIdFormat(nca_file->GetName()))
-                continue;
-
-            ids.push_back(
-                Common::HexStringToArray<0x10, true>(nca_file->GetName().substr(0, 0x20)));
-        }
-    }
-
-    for (const auto& d2_file : dir->GetFiles()) {
-        if (FollowsNcaIdFormat(d2_file->GetName()))
-            ids.push_back(Common::HexStringToArray<0x10, true>(d2_file->GetName().substr(0, 0x20)));
-    }
-    return ids;
-}
-
-void RegisteredCache::ProcessFiles(const std::vector<NcaID>& ids) {
-    for (const auto& id : ids) {
-        const auto file = GetFileAtID(id);
-
-        if (file == nullptr)
-            continue;
-        const auto nca = std::make_shared<NCA>(parser(file, id));
-        if (nca->GetStatus() != Loader::ResultStatus::Success ||
-            nca->GetType() != NCAContentType::Meta) {
-            continue;
-        }
-
-        const auto section0 = nca->GetSubdirectories()[0];
-
-        for (const auto& file : section0->GetFiles()) {
-            if (file->GetExtension() != "cnmt")
-                continue;
-
-            meta.insert_or_assign(nca->GetTitleId(), CNMT(file));
-            meta_id.insert_or_assign(nca->GetTitleId(), id);
-            break;
-        }
-    }
-}
-
-void RegisteredCache::AccumulateYuzuMeta() {
-    const auto dir = this->dir->GetSubdirectory("yuzu_meta");
-    if (dir == nullptr)
-        return;
-
-    for (const auto& file : dir->GetFiles()) {
-        if (file->GetExtension() != "cnmt")
-            continue;
-
-        CNMT cnmt(file);
-        yuzu_meta.insert_or_assign(cnmt.GetTitleID(), std::move(cnmt));
-    }
-}
-
-void RegisteredCache::Refresh() {
-    if (dir == nullptr)
-        return;
-    const auto ids = AccumulateFiles();
-    ProcessFiles(ids);
-    AccumulateYuzuMeta();
-}
-
-RegisteredCache::RegisteredCache(VirtualDir dir_, RegisteredCacheParsingFunction parsing_function)
-    : dir(std::move(dir_)), parser(std::move(parsing_function)) {
-    Refresh();
-}
-
-bool RegisteredCache::HasEntry(u64 title_id, ContentRecordType type) const {
-    return GetEntryRaw(title_id, type) != nullptr;
-}
-
-bool RegisteredCache::HasEntry(RegisteredCacheEntry entry) const {
-    return GetEntryRaw(entry) != nullptr;
-}
-
-VirtualFile RegisteredCache::GetEntryRaw(u64 title_id, ContentRecordType type) const {
-    const auto id = GetNcaIDFromMetadata(title_id, type);
-    if (id == boost::none)
-        return nullptr;
-
-    return parser(GetFileAtID(id.get()), id.get());
-}
-
-VirtualFile RegisteredCache::GetEntryRaw(RegisteredCacheEntry entry) const {
-    return GetEntryRaw(entry.title_id, entry.type);
-}
-
-std::shared_ptr<NCA> RegisteredCache::GetEntry(u64 title_id, ContentRecordType type) const {
-    const auto raw = GetEntryRaw(title_id, type);
-    if (raw == nullptr)
-        return nullptr;
-    return std::make_shared<NCA>(raw);
-}
-
-std::shared_ptr<NCA> RegisteredCache::GetEntry(RegisteredCacheEntry entry) const {
-    return GetEntry(entry.title_id, entry.type);
-}
-
-template <typename T>
-void RegisteredCache::IterateAllMetadata(
-    std::vector<T>& out, std::function<T(const CNMT&, const ContentRecord&)> proc,
-    std::function<bool(const CNMT&, const ContentRecord&)> filter) const {
-    for (const auto& kv : meta) {
-        const auto& cnmt = kv.second;
-        if (filter(cnmt, EMPTY_META_CONTENT_RECORD))
-            out.push_back(proc(cnmt, EMPTY_META_CONTENT_RECORD));
-        for (const auto& rec : cnmt.GetContentRecords()) {
-            if (GetFileAtID(rec.nca_id) != nullptr && filter(cnmt, rec)) {
-                out.push_back(proc(cnmt, rec));
-            }
-        }
-    }
-    for (const auto& kv : yuzu_meta) {
-        const auto& cnmt = kv.second;
-        for (const auto& rec : cnmt.GetContentRecords()) {
-            if (GetFileAtID(rec.nca_id) != nullptr && filter(cnmt, rec)) {
-                out.push_back(proc(cnmt, rec));
-            }
-        }
-    }
-}
-
-std::vector<RegisteredCacheEntry> RegisteredCache::ListEntries() const {
-    std::vector<RegisteredCacheEntry> out;
-    IterateAllMetadata<RegisteredCacheEntry>(
-        out,
-        [](const CNMT& c, const ContentRecord& r) {
-            return RegisteredCacheEntry{c.GetTitleID(), r.type};
-        },
-        [](const CNMT& c, const ContentRecord& r) { return true; });
-    return out;
-}
-
-std::vector<RegisteredCacheEntry> RegisteredCache::ListEntriesFilter(
-    boost::optional<TitleType> title_type, boost::optional<ContentRecordType> record_type,
-    boost::optional<u64> title_id) const {
-    std::vector<RegisteredCacheEntry> out;
-    IterateAllMetadata<RegisteredCacheEntry>(
-        out,
-        [](const CNMT& c, const ContentRecord& r) {
-            return RegisteredCacheEntry{c.GetTitleID(), r.type};
-        },
-        [&title_type, &record_type, &title_id](const CNMT& c, const ContentRecord& r) {
-            if (title_type != boost::none && title_type.get() != c.GetType())
-                return false;
-            if (record_type != boost::none && record_type.get() != r.type)
-                return false;
-            if (title_id != boost::none && title_id.get() != c.GetTitleID())
-                return false;
-            return true;
-        });
-    return out;
-}
-
-static std::shared_ptr<NCA> GetNCAFromXCIForID(std::shared_ptr<XCI> xci, const NcaID& id) {
-    const auto filename = fmt::format("{}.nca", Common::HexArrayToString(id, false));
-    const auto iter =
-        std::find_if(xci->GetNCAs().begin(), xci->GetNCAs().end(),
-                     [&filename](std::shared_ptr<NCA> nca) { return nca->GetName() == filename; });
-    return iter == xci->GetNCAs().end() ? nullptr : *iter;
-}
-
-InstallResult RegisteredCache::InstallEntry(std::shared_ptr<XCI> xci, bool overwrite_if_exists,
-                                            const VfsCopyFunction& copy) {
-    const auto& ncas = xci->GetNCAs();
-    const auto& meta_iter = std::find_if(ncas.begin(), ncas.end(), [](std::shared_ptr<NCA> nca) {
-        return nca->GetType() == NCAContentType::Meta;
-    });
-
-    if (meta_iter == ncas.end()) {
-        LOG_ERROR(Loader, "The XCI you are attempting to install does not have a metadata NCA and "
-                          "is therefore malformed. Double check your encryption keys.");
-        return InstallResult::ErrorMetaFailed;
-    }
-
-    // Install Metadata File
-    const auto meta_id_raw = (*meta_iter)->GetName().substr(0, 32);
-    const auto meta_id = Common::HexStringToArray<16>(meta_id_raw);
-
-    const auto res = RawInstallNCA(*meta_iter, copy, overwrite_if_exists, meta_id);
-    if (res != InstallResult::Success)
-        return res;
-
-    // Install all the other NCAs
-    const auto section0 = (*meta_iter)->GetSubdirectories()[0];
-    const auto cnmt_file = section0->GetFiles()[0];
-    const CNMT cnmt(cnmt_file);
-    for (const auto& record : cnmt.GetContentRecords()) {
-        const auto nca = GetNCAFromXCIForID(xci, record.nca_id);
-        if (nca == nullptr)
-            return InstallResult::ErrorCopyFailed;
-        const auto res2 = RawInstallNCA(nca, copy, overwrite_if_exists, record.nca_id);
-        if (res2 != InstallResult::Success)
-            return res2;
-    }
-
-    Refresh();
-    return InstallResult::Success;
-}
-
-InstallResult RegisteredCache::InstallEntry(std::shared_ptr<NCA> nca, TitleType type,
-                                            bool overwrite_if_exists, const VfsCopyFunction& copy) {
-    CNMTHeader header{
-        nca->GetTitleId(), ///< Title ID
-        0,                 ///< Ignore/Default title version
-        type,              ///< Type
-        {},                ///< Padding
-        0x10,              ///< Default table offset
-        1,                 ///< 1 Content Entry
-        0,                 ///< No Meta Entries
-        {},                ///< Padding
-    };
-    OptionalHeader opt_header{0, 0};
-    ContentRecord c_rec{{}, {}, {}, GetCRTypeFromNCAType(nca->GetType()), {}};
-    const auto& data = nca->GetBaseFile()->ReadBytes(0x100000);
-    mbedtls_sha256(data.data(), data.size(), c_rec.hash.data(), 0);
-    memcpy(&c_rec.nca_id, &c_rec.hash, 16);
-    const CNMT new_cnmt(header, opt_header, {c_rec}, {});
-    if (!RawInstallYuzuMeta(new_cnmt))
-        return InstallResult::ErrorMetaFailed;
-    return RawInstallNCA(nca, copy, overwrite_if_exists, c_rec.nca_id);
-}
-
-InstallResult RegisteredCache::RawInstallNCA(std::shared_ptr<NCA> nca, const VfsCopyFunction& copy,
-                                             bool overwrite_if_exists,
-                                             boost::optional<NcaID> override_id) {
-    const auto in = nca->GetBaseFile();
-    Core::Crypto::SHA256Hash hash{};
-
-    // Calculate NcaID
-    // NOTE: Because computing the SHA256 of an entire NCA is quite expensive (especially if the
-    // game is massive), we're going to cheat and only hash the first MB of the NCA.
-    // Also, for XCIs the NcaID matters, so if the override id isn't none, use that.
-    NcaID id{};
-    if (override_id == boost::none) {
-        const auto& data = in->ReadBytes(0x100000);
-        mbedtls_sha256(data.data(), data.size(), hash.data(), 0);
-        memcpy(id.data(), hash.data(), 16);
-    } else {
-        id = override_id.get();
-    }
-
-    std::string path = GetRelativePathFromNcaID(id, false, true);
-
-    if (GetFileAtID(id) != nullptr && !overwrite_if_exists) {
-        LOG_WARNING(Loader, "Attempting to overwrite existing NCA. Skipping...");
-        return InstallResult::ErrorAlreadyExists;
-    }
-
-    if (GetFileAtID(id) != nullptr) {
-        LOG_WARNING(Loader, "Overwriting existing NCA...");
-        VirtualDir c_dir;
-        { c_dir = dir->GetFileRelative(path)->GetContainingDirectory(); }
-        c_dir->DeleteFile(FileUtil::GetFilename(path));
-    }
-
-    auto out = dir->CreateFileRelative(path);
-    if (out == nullptr)
-        return InstallResult::ErrorCopyFailed;
-    return copy(in, out) ? InstallResult::Success : InstallResult::ErrorCopyFailed;
-}
-
-bool RegisteredCache::RawInstallYuzuMeta(const CNMT& cnmt) {
-    // Reasoning behind this method can be found in the comment for InstallEntry, NCA overload.
-    const auto dir = this->dir->CreateDirectoryRelative("yuzu_meta");
-    const auto filename = GetCNMTName(cnmt.GetType(), cnmt.GetTitleID());
-    if (dir->GetFile(filename) == nullptr) {
-        auto out = dir->CreateFile(filename);
-        const auto buffer = cnmt.Serialize();
-        out->Resize(buffer.size());
-        out->WriteBytes(buffer);
-    } else {
-        auto out = dir->GetFile(filename);
-        CNMT old_cnmt(out);
-        // Returns true on change
-        if (old_cnmt.UnionRecords(cnmt)) {
-            out->Resize(0);
-            const auto buffer = old_cnmt.Serialize();
-            out->Resize(buffer.size());
-            out->WriteBytes(buffer);
-        }
-    }
-    Refresh();
-    return std::find_if(yuzu_meta.begin(), yuzu_meta.end(),
-                        [&cnmt](const std::pair<u64, CNMT>& kv) {
-                            return kv.second.GetType() == cnmt.GetType() &&
-                                   kv.second.GetTitleID() == cnmt.GetTitleID();
-                        }) != yuzu_meta.end();
-}
-} // namespace FileSys

src/core/file_sys/registered_cache.h

@@ -1,124 +0,0 @@
-// Copyright 2018 yuzu emulator team
-// Licensed under GPLv2 or any later version
-// Refer to the license.txt file included.
-
-#pragma once
-
-#include <array>
-#include <functional>
-#include <map>
-#include <memory>
-#include <string>
-#include <vector>
-#include <boost/container/flat_map.hpp>
-#include "common/common_funcs.h"
-#include "common/common_types.h"
-#include "content_archive.h"
-#include "core/file_sys/nca_metadata.h"
-#include "core/file_sys/vfs.h"
-
-namespace FileSys {
-class XCI;
-class CNMT;
-
-using NcaID = std::array<u8, 0x10>;
-using RegisteredCacheParsingFunction = std::function<VirtualFile(const VirtualFile&, const NcaID&)>;
-using VfsCopyFunction = std::function<bool(VirtualFile, VirtualFile)>;
-
-enum class InstallResult {
-    Success,
-    ErrorAlreadyExists,
-    ErrorCopyFailed,
-    ErrorMetaFailed,
-};
-
-struct RegisteredCacheEntry {
-    u64 title_id;
-    ContentRecordType type;
-
-    std::string DebugInfo() const;
-};
-
-// boost flat_map requires operator< for O(log(n)) lookups.
-bool operator<(const RegisteredCacheEntry& lhs, const RegisteredCacheEntry& rhs);
-
-/*
- * A class that catalogues NCAs in the registered directory structure.
- * Nintendo's registered format follows this structure:
- *
- * Root
- *   | 000000XX <- XX is the ____ two digits of the NcaID
- *       | <hash>.nca <- hash is the NcaID (first half of SHA256 over entire file) (folder)
- *         | 00
- *         | 01 <- Actual content split along 4GB boundaries. (optional)
- *
- * (This impl also supports substituting the nca dir for an nca file, as that's more convenient when
- * 4GB splitting can be ignored.)
- */
-class RegisteredCache {
-public:
-    // Parsing function defines the conversion from raw file to NCA. If there are other steps
-    // besides creating the NCA from the file (e.g. NAX0 on SD Card), that should go in a custom
-    // parsing function.
-    explicit RegisteredCache(VirtualDir dir,
-                             RegisteredCacheParsingFunction parsing_function =
-                                 [](const VirtualFile& file, const NcaID& id) { return file; });
-
-    void Refresh();
-
-    bool HasEntry(u64 title_id, ContentRecordType type) const;
-    bool HasEntry(RegisteredCacheEntry entry) const;
-
-    VirtualFile GetEntryRaw(u64 title_id, ContentRecordType type) const;
-    VirtualFile GetEntryRaw(RegisteredCacheEntry entry) const;
-
-    std::shared_ptr<NCA> GetEntry(u64 title_id, ContentRecordType type) const;
-    std::shared_ptr<NCA> GetEntry(RegisteredCacheEntry entry) const;
-
-    std::vector<RegisteredCacheEntry> ListEntries() const;
-    // If a parameter is not boost::none, it will be filtered for from all entries.
-    std::vector<RegisteredCacheEntry> ListEntriesFilter(
-        boost::optional<TitleType> title_type = boost::none,
-        boost::optional<ContentRecordType> record_type = boost::none,
-        boost::optional<u64> title_id = boost::none) const;
-
-    // Raw copies all the ncas from the xci to the csache. Does some quick checks to make sure there
-    // is a meta NCA and all of them are accessible.
-    InstallResult InstallEntry(std::shared_ptr<XCI> xci, bool overwrite_if_exists = false,
-                               const VfsCopyFunction& copy = &VfsRawCopy);
-
-    // Due to the fact that we must use Meta-type NCAs to determine the existance of files, this
-    // poses quite a challenge. Instead of creating a new meta NCA for this file, yuzu will create a
-    // dir inside the NAND called 'yuzu_meta' and store the raw CNMT there.
-    // TODO(DarkLordZach): Author real meta-type NCAs and install those.
-    InstallResult InstallEntry(std::shared_ptr<NCA> nca, TitleType type,
-                               bool overwrite_if_exists = false,
-                               const VfsCopyFunction& copy = &VfsRawCopy);
-
-private:
-    template <typename T>
-    void IterateAllMetadata(std::vector<T>& out,
-                            std::function<T(const CNMT&, const ContentRecord&)> proc,
-                            std::function<bool(const CNMT&, const ContentRecord&)> filter) const;
-    std::vector<NcaID> AccumulateFiles() const;
-    void ProcessFiles(const std::vector<NcaID>& ids);
-    void AccumulateYuzuMeta();
-    boost::optional<NcaID> GetNcaIDFromMetadata(u64 title_id, ContentRecordType type) const;
-    VirtualFile GetFileAtID(NcaID id) const;
-    VirtualFile OpenFileOrDirectoryConcat(const VirtualDir& dir, std::string_view path) const;
-    InstallResult RawInstallNCA(std::shared_ptr<NCA> nca, const VfsCopyFunction& copy,
-                                bool overwrite_if_exists,
-                                boost::optional<NcaID> override_id = boost::none);
-    bool RawInstallYuzuMeta(const CNMT& cnmt);
-
-    VirtualDir dir;
-    RegisteredCacheParsingFunction parser;
-    // maps tid -> NcaID of meta
-    boost::container::flat_map<u64, NcaID> meta_id;
-    // maps tid -> meta
-    boost::container::flat_map<u64, CNMT> meta;
-    // maps tid -> meta for CNMT in yuzu_meta
-    boost::container::flat_map<u64, CNMT> yuzu_meta;
-};
-
-} // namespace FileSys

src/core/file_sys/romfs.cpp

@@ -65,7 +65,7 @@ void ProcessFile(VirtualFile file, size_t file_offset, size_t data_offset, u32 t
         auto entry = GetEntry<FileEntry>(file, file_offset + this_file_offset);
 
         parent->AddFile(std::make_shared<OffsetVfsFile>(
-            file, entry.first.size, entry.first.offset + data_offset, entry.second));
+            file, entry.first.size, entry.first.offset + data_offset, entry.second, parent));
 
         if (entry.first.sibling == ROMFS_ENTRY_EMPTY)
             break;
@@ -79,7 +79,7 @@ void ProcessDirectory(VirtualFile file, size_t dir_offset, size_t file_offset, s
     while (true) {
         auto entry = GetEntry<DirectoryEntry>(file, dir_offset + this_dir_offset);
         auto current = std::make_shared<VectorVfsDirectory>(
-            std::vector<VirtualFile>{}, std::vector<VirtualDir>{}, entry.second);
+            std::vector<VirtualFile>{}, std::vector<VirtualDir>{}, parent, entry.second);
 
         if (entry.first.child_file != ROMFS_ENTRY_EMPTY) {
             ProcessFile(file, file_offset, data_offset, entry.first.child_file, current);
@@ -108,9 +108,9 @@ VirtualDir ExtractRomFS(VirtualFile file) {
     const u64 file_offset = header.file_meta.offset;
     const u64 dir_offset = header.directory_meta.offset + 4;
 
-    auto root =
+    const auto root =
         std::make_shared<VectorVfsDirectory>(std::vector<VirtualFile>{}, std::vector<VirtualDir>{},
-                                             file->GetName(), file->GetContainingDirectory());
+                                             file->GetContainingDirectory(), file->GetName());
 
     ProcessDirectory(file, dir_offset, file_offset, header.data_offset, 0, root);
 

src/core/file_sys/romfs_factory.cpp

@@ -6,9 +6,7 @@
 #include <memory>
 #include "common/common_types.h"
 #include "common/logging/log.h"
-#include "core/core.h"
 #include "core/file_sys/romfs_factory.h"
-#include "core/hle/kernel/process.h"
 
 namespace FileSys {
 
@@ -19,41 +17,9 @@ RomFSFactory::RomFSFactory(Loader::AppLoader& app_loader) {
     }
 }
 
-ResultVal<VirtualFile> RomFSFactory::OpenCurrentProcess() {
+ResultVal<VirtualFile> RomFSFactory::Open(u64 title_id) {
+    // TODO(DarkLordZach): Use title id.
     return MakeResult<VirtualFile>(file);
 }
 
-ResultVal<VirtualFile> RomFSFactory::Open(u64 title_id, StorageId storage, ContentRecordType type) {
-    switch (storage) {
-    case StorageId::NandSystem: {
-        const auto res = Service::FileSystem::GetSystemNANDContents()->GetEntry(title_id, type);
-        if (res == nullptr) {
-            // TODO(DarkLordZach): Find the right error code to use here
-            return ResultCode(-1);
-        }
-        const auto romfs = res->GetRomFS();
-        if (romfs == nullptr) {
-            // TODO(DarkLordZach): Find the right error code to use here
-            return ResultCode(-1);
-        }
-        return MakeResult<VirtualFile>(romfs);
-    }
-    case StorageId::NandUser: {
-        const auto res = Service::FileSystem::GetUserNANDContents()->GetEntry(title_id, type);
-        if (res == nullptr) {
-            // TODO(DarkLordZach): Find the right error code to use here
-            return ResultCode(-1);
-        }
-        const auto romfs = res->GetRomFS();
-        if (romfs == nullptr) {
-            // TODO(DarkLordZach): Find the right error code to use here
-            return ResultCode(-1);
-        }
-        return MakeResult<VirtualFile>(romfs);
-    }
-    default:
-        UNIMPLEMENTED_MSG("Unimplemented storage_id={:02X}", static_cast<u8>(storage));
-    }
-}
-
 } // namespace FileSys

src/core/file_sys/romfs_factory.h

@@ -11,22 +11,12 @@
 
 namespace FileSys {
 
-enum class StorageId : u8 {
-    None = 0,
-    Host = 1,
-    GameCard = 2,
-    NandSystem = 3,
-    NandUser = 4,
-    SdCard = 5,
-};
-
 /// File system interface to the RomFS archive
 class RomFSFactory {
 public:
     explicit RomFSFactory(Loader::AppLoader& app_loader);
 
-    ResultVal<VirtualFile> OpenCurrentProcess();
-    ResultVal<VirtualFile> Open(u64 title_id, StorageId storage, ContentRecordType type);
+    ResultVal<VirtualFile> Open(u64 title_id);
 
 private:
     VirtualFile file;

src/core/file_sys/vfs_concat.cpp

@@ -1,94 +0,0 @@
-// Copyright 2018 yuzu emulator team
-// Licensed under GPLv2 or any later version
-// Refer to the license.txt file included.
-
-#include <algorithm>
-#include <utility>
-
-#include "core/file_sys/vfs_concat.h"
-
-namespace FileSys {
-
-VirtualFile ConcatenateFiles(std::vector<VirtualFile> files, std::string name) {
-    if (files.empty())
-        return nullptr;
-    if (files.size() == 1)
-        return files[0];
-
-    return std::shared_ptr<VfsFile>(new ConcatenatedVfsFile(std::move(files), std::move(name)));
-}
-
-ConcatenatedVfsFile::ConcatenatedVfsFile(std::vector<VirtualFile> files_, std::string name)
-    : name(std::move(name)) {
-    size_t next_offset = 0;
-    for (const auto& file : files_) {
-        files[next_offset] = file;
-        next_offset += file->GetSize();
-    }
-}
-
-std::string ConcatenatedVfsFile::GetName() const {
-    if (files.empty())
-        return "";
-    if (!name.empty())
-        return name;
-    return files.begin()->second->GetName();
-}
-
-size_t ConcatenatedVfsFile::GetSize() const {
-    if (files.empty())
-        return 0;
-    return files.rbegin()->first + files.rbegin()->second->GetSize();
-}
-
-bool ConcatenatedVfsFile::Resize(size_t new_size) {
-    return false;
-}
-
-std::shared_ptr<VfsDirectory> ConcatenatedVfsFile::GetContainingDirectory() const {
-    if (files.empty())
-        return nullptr;
-    return files.begin()->second->GetContainingDirectory();
-}
-
-bool ConcatenatedVfsFile::IsWritable() const {
-    return false;
-}
-
-bool ConcatenatedVfsFile::IsReadable() const {
-    return true;
-}
-
-size_t ConcatenatedVfsFile::Read(u8* data, size_t length, size_t offset) const {
-    auto entry = files.end();
-    for (auto iter = files.begin(); iter != files.end(); ++iter) {
-        if (iter->first > offset) {
-            entry = --iter;
-            break;
-        }
-    }
-
-    // Check if the entry should be the last one. The loop above will make it end().
-    if (entry == files.end() && offset < files.rbegin()->first + files.rbegin()->second->GetSize())
-        --entry;
-
-    if (entry == files.end())
-        return 0;
-
-    const auto remaining = entry->second->GetSize() + offset - entry->first;
-    if (length > remaining) {
-        return entry->second->Read(data, remaining, offset - entry->first) +
-               Read(data + remaining, length - remaining, offset + remaining);
-    }
-
-    return entry->second->Read(data, length, offset - entry->first);
-}
-
-size_t ConcatenatedVfsFile::Write(const u8* data, size_t length, size_t offset) {
-    return 0;
-}
-
-bool ConcatenatedVfsFile::Rename(std::string_view name) {
-    return false;
-}
-} // namespace FileSys

src/core/file_sys/vfs_concat.h

@@ -1,41 +0,0 @@
-// Copyright 2018 yuzu emulator team
-// Licensed under GPLv2 or any later version
-// Refer to the license.txt file included.
-
-#pragma once
-
-#include <memory>
-#include <string_view>
-#include <boost/container/flat_map.hpp>
-#include "core/file_sys/vfs.h"
-
-namespace FileSys {
-
-// Wrapper function to allow for more efficient handling of files.size() == 0, 1 cases.
-VirtualFile ConcatenateFiles(std::vector<VirtualFile> files, std::string name = "");
-
-// Class that wraps multiple vfs files and concatenates them, making reads seamless. Currently
-// read-only.
-class ConcatenatedVfsFile : public VfsFile {
-    friend VirtualFile ConcatenateFiles(std::vector<VirtualFile> files, std::string name);
-
-    ConcatenatedVfsFile(std::vector<VirtualFile> files, std::string name);
-
-public:
-    std::string GetName() const override;
-    size_t GetSize() const override;
-    bool Resize(size_t new_size) override;
-    std::shared_ptr<VfsDirectory> GetContainingDirectory() const override;
-    bool IsWritable() const override;
-    bool IsReadable() const override;
-    size_t Read(u8* data, size_t length, size_t offset) const override;
-    size_t Write(const u8* data, size_t length, size_t offset) override;
-    bool Rename(std::string_view name) override;
-
-private:
-    // Maps starting offset to file -- more efficient.
-    boost::container::flat_map<u64, VirtualFile> files;
-    std::string name;
-};
-
-} // namespace FileSys

src/core/file_sys/vfs_real.cpp

@@ -83,12 +83,8 @@ VirtualFile RealVfsFilesystem::OpenFile(std::string_view path_, Mode perms) {
 
 VirtualFile RealVfsFilesystem::CreateFile(std::string_view path_, Mode perms) {
     const auto path = FileUtil::SanitizePath(path_, FileUtil::DirectorySeparator::PlatformDefault);
-    const auto path_fwd = FileUtil::SanitizePath(path, FileUtil::DirectorySeparator::ForwardSlash);
-    if (!FileUtil::Exists(path)) {
-        FileUtil::CreateFullPath(path_fwd);
-        if (!FileUtil::CreateEmptyFile(path))
-            return nullptr;
-    }
+    if (!FileUtil::Exists(path) && !FileUtil::CreateEmptyFile(path))
+        return nullptr;
     return OpenFile(path, perms);
 }
 
@@ -144,12 +140,8 @@ VirtualDir RealVfsFilesystem::OpenDirectory(std::string_view path_, Mode perms)
 
 VirtualDir RealVfsFilesystem::CreateDirectory(std::string_view path_, Mode perms) {
     const auto path = FileUtil::SanitizePath(path_, FileUtil::DirectorySeparator::PlatformDefault);
-    const auto path_fwd = FileUtil::SanitizePath(path, FileUtil::DirectorySeparator::ForwardSlash);
-    if (!FileUtil::Exists(path)) {
-        FileUtil::CreateFullPath(path_fwd);
-        if (!FileUtil::CreateDir(path))
-            return nullptr;
-    }
+    if (!FileUtil::Exists(path) && !FileUtil::CreateDir(path))
+        return nullptr;
     // Cannot use make_shared as RealVfsDirectory constructor is private
     return std::shared_ptr<RealVfsDirectory>(new RealVfsDirectory(*this, path, perms));
 }
@@ -314,14 +306,14 @@ RealVfsDirectory::RealVfsDirectory(RealVfsFilesystem& base_, const std::string&
 
 std::shared_ptr<VfsFile> RealVfsDirectory::GetFileRelative(std::string_view path) const {
     const auto full_path = FileUtil::SanitizePath(this->path + DIR_SEP + std::string(path));
-    if (!FileUtil::Exists(full_path) || FileUtil::IsDirectory(full_path))
+    if (!FileUtil::Exists(full_path))
         return nullptr;
     return base.OpenFile(full_path, perms);
 }
 
 std::shared_ptr<VfsDirectory> RealVfsDirectory::GetDirectoryRelative(std::string_view path) const {
     const auto full_path = FileUtil::SanitizePath(this->path + DIR_SEP + std::string(path));
-    if (!FileUtil::Exists(full_path) || !FileUtil::IsDirectory(full_path))
+    if (!FileUtil::Exists(full_path))
         return nullptr;
     return base.OpenDirectory(full_path, perms);
 }

src/core/file_sys/vfs_real.h

@@ -5,6 +5,7 @@
 #pragma once
 
 #include <string_view>
+
 #include <boost/container/flat_map.hpp>
 #include "common/file_util.h"
 #include "core/file_sys/mode.h"

src/core/file_sys/vfs_vector.cpp

@@ -8,8 +8,8 @@
 
 namespace FileSys {
 VectorVfsDirectory::VectorVfsDirectory(std::vector<VirtualFile> files_,
-                                       std::vector<VirtualDir> dirs_, std::string name_,
-                                       VirtualDir parent_)
+                                       std::vector<VirtualDir> dirs_, VirtualDir parent_,
+                                       std::string name_)
     : files(std::move(files_)), dirs(std::move(dirs_)), parent(std::move(parent_)),
       name(std::move(name_)) {}
 

src/core/file_sys/vfs_vector.h

@@ -13,8 +13,8 @@ namespace FileSys {
 class VectorVfsDirectory : public VfsDirectory {
 public:
     explicit VectorVfsDirectory(std::vector<VirtualFile> files = {},
-                                std::vector<VirtualDir> dirs = {}, std::string name = "",
-                                VirtualDir parent = nullptr);
+                                std::vector<VirtualDir> dirs = {}, VirtualDir parent = nullptr,
+                                std::string name = "");
 
     std::vector<std::shared_ptr<VfsFile>> GetFiles() const override;
     std::vector<std::shared_ptr<VfsDirectory>> GetSubdirectories() const override;

src/core/frontend/emu_window.h

@@ -34,9 +34,9 @@ class EmuWindow {
 public:
     /// Data structure to store emuwindow configuration
     struct WindowConfig {
-        bool fullscreen = false;
-        int res_width = 0;
-        int res_height = 0;
+        bool fullscreen;
+        int res_width;
+        int res_height;
         std::pair<unsigned, unsigned> min_client_area_size;
     };
 

src/core/hle/kernel/server_session.cpp

@@ -152,7 +152,7 @@ ResultCode ServerSession::HandleSyncRequest(SharedPtr<Thread> thread) {
     // Handle scenario when ConvertToDomain command was issued, as we must do the conversion at the
     // end of the command such that only commands following this one are handled as domains
     if (convert_to_domain) {
-        ASSERT_MSG(IsSession(), "ServerSession is already a domain instance.");
+        ASSERT_MSG(domain_request_handlers.empty(), "already a domain");
         domain_request_handlers = {hle_handler};
         convert_to_domain = false;
     }

src/core/hle/kernel/server_session.h

@@ -97,12 +97,7 @@ public:
 
     /// Returns true if the session has been converted to a domain, otherwise False
     bool IsDomain() const {
-        return !IsSession();
-    }
-
-    /// Returns true if this session has not been converted to a domain, otherwise false.
-    bool IsSession() const {
-        return domain_request_handlers.empty();
+        return !domain_request_handlers.empty();
     }
 
     /// Converts the session to a domain at the end of the current command

src/core/hle/kernel/svc.cpp

@@ -250,11 +250,8 @@ static ResultCode ArbitrateUnlock(VAddr mutex_addr) {
 }
 
 /// Break program execution
-static void Break(u64 reason, u64 info1, u64 info2) {
-    LOG_CRITICAL(
-        Debug_Emulated,
-        "Emulated program broke execution! reason=0x{:016X}, info1=0x{:016X}, info2=0x{:016X}",
-        reason, info1, info2);
+static void Break(u64 unk_0, u64 unk_1, u64 unk_2) {
+    LOG_CRITICAL(Debug_Emulated, "Emulated program broke execution!");
     ASSERT(false);
 }
 

src/core/hle/kernel/thread.cpp

@@ -167,7 +167,7 @@ void Thread::WakeAfterDelay(s64 nanoseconds) {
 }
 
 void Thread::CancelWakeupTimer() {
-    CoreTiming::UnscheduleEventThreadsafe(ThreadWakeupEventType, callback_handle);
+    CoreTiming::UnscheduleEvent(ThreadWakeupEventType, callback_handle);
 }
 
 static boost::optional<s32> GetNextProcessorId(u64 mask) {

src/core/hle/service/am/am.cpp

@@ -145,8 +145,8 @@ ISelfController::ISelfController(std::shared_ptr<NVFlinger::NVFlinger> nvflinger
         {51, nullptr, "ApproveToDisplay"},
         {60, nullptr, "OverrideAutoSleepTimeAndDimmingTime"},
         {61, nullptr, "SetMediaPlaybackState"},
-        {62, &ISelfController::SetIdleTimeDetectionExtension, "SetIdleTimeDetectionExtension"},
-        {63, &ISelfController::GetIdleTimeDetectionExtension, "GetIdleTimeDetectionExtension"},
+        {62, nullptr, "SetIdleTimeDetectionExtension"},
+        {63, nullptr, "GetIdleTimeDetectionExtension"},
         {64, nullptr, "SetInputDetectionSourceSet"},
         {65, nullptr, "ReportUserIsActive"},
         {66, nullptr, "GetCurrentIlluminance"},
@@ -281,23 +281,6 @@ void ISelfController::SetHandlesRequestToDisplay(Kernel::HLERequestContext& ctx)
     LOG_WARNING(Service_AM, "(STUBBED) called");
 }
 
-void ISelfController::SetIdleTimeDetectionExtension(Kernel::HLERequestContext& ctx) {
-    IPC::RequestParser rp{ctx};
-    idle_time_detection_extension = rp.Pop<u32>();
-    IPC::ResponseBuilder rb{ctx, 2};
-    rb.Push(RESULT_SUCCESS);
-
-    LOG_WARNING(Service_AM, "(STUBBED) called");
-}
-
-void ISelfController::GetIdleTimeDetectionExtension(Kernel::HLERequestContext& ctx) {
-    IPC::ResponseBuilder rb{ctx, 3};
-    rb.Push(RESULT_SUCCESS);
-    rb.Push<u32>(idle_time_detection_extension);
-
-    LOG_WARNING(Service_AM, "(STUBBED) called");
-}
-
 ICommonStateGetter::ICommonStateGetter() : ServiceFramework("ICommonStateGetter") {
     static const FunctionInfo functions[] = {
         {0, &ICommonStateGetter::GetEventHandle, "GetEventHandle"},
@@ -323,8 +306,7 @@ ICommonStateGetter::ICommonStateGetter() : ServiceFramework("ICommonStateGetter"
         {52, nullptr, "SwitchLcdBacklight"},
         {55, nullptr, "IsInControllerFirmwareUpdateSection"},
         {60, nullptr, "GetDefaultDisplayResolution"},
-        {61, &ICommonStateGetter::GetDefaultDisplayResolutionChangeEvent,
-         "GetDefaultDisplayResolutionChangeEvent"},
+        {61, nullptr, "GetDefaultDisplayResolutionChangeEvent"},
         {62, nullptr, "GetHdcpAuthenticationState"},
         {63, nullptr, "GetHdcpAuthenticationStateChangeEvent"},
     };
@@ -359,16 +341,6 @@ void ICommonStateGetter::GetCurrentFocusState(Kernel::HLERequestContext& ctx) {
     LOG_WARNING(Service_AM, "(STUBBED) called");
 }
 
-void ICommonStateGetter::GetDefaultDisplayResolutionChangeEvent(Kernel::HLERequestContext& ctx) {
-    event->Signal();
-
-    IPC::ResponseBuilder rb{ctx, 2, 1};
-    rb.Push(RESULT_SUCCESS);
-    rb.PushCopyObjects(event);
-
-    LOG_WARNING(Service_AM, "(STUBBED) called");
-}
-
 void ICommonStateGetter::GetOperationMode(Kernel::HLERequestContext& ctx) {
     const bool use_docked_mode{Settings::values.use_docked_mode};
     IPC::ResponseBuilder rb{ctx, 3};

src/core/hle/service/am/am.h

@@ -87,12 +87,9 @@ private:
     void CreateManagedDisplayLayer(Kernel::HLERequestContext& ctx);
     void SetScreenShotPermission(Kernel::HLERequestContext& ctx);
     void SetHandlesRequestToDisplay(Kernel::HLERequestContext& ctx);
-    void SetIdleTimeDetectionExtension(Kernel::HLERequestContext& ctx);
-    void GetIdleTimeDetectionExtension(Kernel::HLERequestContext& ctx);
 
     std::shared_ptr<NVFlinger::NVFlinger> nvflinger;
     Kernel::SharedPtr<Kernel::Event> launchable_event;
-    u32 idle_time_detection_extension = 0;
 };
 
 class ICommonStateGetter final : public ServiceFramework<ICommonStateGetter> {
@@ -113,7 +110,6 @@ private:
     void GetEventHandle(Kernel::HLERequestContext& ctx);
     void ReceiveMessage(Kernel::HLERequestContext& ctx);
     void GetCurrentFocusState(Kernel::HLERequestContext& ctx);
-    void GetDefaultDisplayResolutionChangeEvent(Kernel::HLERequestContext& ctx);
     void GetOperationMode(Kernel::HLERequestContext& ctx);
     void GetPerformanceMode(Kernel::HLERequestContext& ctx);
 

src/core/hle/service/audio/audout_u.cpp

@@ -28,7 +28,7 @@ constexpr int DefaultSampleRate{48000};
 class IAudioOut final : public ServiceFramework<IAudioOut> {
 public:
     IAudioOut(AudoutParams audio_params, AudioCore::AudioOut& audio_core)
-        : ServiceFramework("IAudioOut"), audio_core(audio_core), audio_params(audio_params) {
+        : ServiceFramework("IAudioOut"), audio_params(audio_params), audio_core(audio_core) {
 
         static const FunctionInfo functions[] = {
             {0, &IAudioOut::GetAudioOutState, "GetAudioOutState"},

src/core/hle/service/filesystem/filesystem.cpp

@@ -226,7 +226,6 @@ ResultVal<FileSys::EntryType> VfsDirectoryServiceWrapper::GetEntryType(
 static std::unique_ptr<FileSys::RomFSFactory> romfs_factory;
 static std::unique_ptr<FileSys::SaveDataFactory> save_data_factory;
 static std::unique_ptr<FileSys::SDMCFactory> sdmc_factory;
-static std::unique_ptr<FileSys::BISFactory> bis_factory;
 
 ResultCode RegisterRomFS(std::unique_ptr<FileSys::RomFSFactory>&& factory) {
     ASSERT_MSG(romfs_factory == nullptr, "Tried to register a second RomFS");
@@ -249,35 +248,15 @@ ResultCode RegisterSDMC(std::unique_ptr<FileSys::SDMCFactory>&& factory) {
     return RESULT_SUCCESS;
 }
 
-ResultCode RegisterBIS(std::unique_ptr<FileSys::BISFactory>&& factory) {
-    ASSERT_MSG(bis_factory == nullptr, "Tried to register a second BIS");
-    bis_factory = std::move(factory);
-    LOG_DEBUG(Service_FS, "Registred BIS");
-    return RESULT_SUCCESS;
-}
-
-ResultVal<FileSys::VirtualFile> OpenRomFSCurrentProcess() {
-    LOG_TRACE(Service_FS, "Opening RomFS for current process");
+ResultVal<FileSys::VirtualFile> OpenRomFS(u64 title_id) {
+    LOG_TRACE(Service_FS, "Opening RomFS for title_id={:016X}", title_id);
 
     if (romfs_factory == nullptr) {
         // TODO(bunnei): Find a better error code for this
         return ResultCode(-1);
     }
 
-    return romfs_factory->OpenCurrentProcess();
-}
-
-ResultVal<FileSys::VirtualFile> OpenRomFS(u64 title_id, FileSys::StorageId storage_id,
-                                          FileSys::ContentRecordType type) {
-    LOG_TRACE(Service_FS, "Opening RomFS for title_id={:016X}, storage_id={:02X}, type={:02X}",
-              title_id, static_cast<u8>(storage_id), static_cast<u8>(type));
-
-    if (romfs_factory == nullptr) {
-        // TODO(bunnei): Find a better error code for this
-        return ResultCode(-1);
-    }
-
-    return romfs_factory->Open(title_id, storage_id, type);
+    return romfs_factory->Open(title_id);
 }
 
 ResultVal<FileSys::VirtualDir> OpenSaveData(FileSys::SaveDataSpaceId space,
@@ -302,14 +281,6 @@ ResultVal<FileSys::VirtualDir> OpenSDMC() {
     return sdmc_factory->Open();
 }
 
-std::shared_ptr<FileSys::RegisteredCache> GetSystemNANDContents() {
-    return bis_factory->GetSystemNANDContents();
-}
-
-std::shared_ptr<FileSys::RegisteredCache> GetUserNANDContents() {
-    return bis_factory->GetUserNANDContents();
-}
-
 void RegisterFileSystems(const FileSys::VirtualFilesystem& vfs) {
     romfs_factory = nullptr;
     save_data_factory = nullptr;
@@ -320,9 +291,6 @@ void RegisterFileSystems(const FileSys::VirtualFilesystem& vfs) {
     auto sd_directory = vfs->OpenDirectory(FileUtil::GetUserPath(FileUtil::UserPath::SDMCDir),
                                            FileSys::Mode::ReadWrite);
 
-    if (bis_factory == nullptr)
-        bis_factory = std::make_unique<FileSys::BISFactory>(nand_directory);
-
     auto savedata = std::make_unique<FileSys::SaveDataFactory>(std::move(nand_directory));
     save_data_factory = std::move(savedata);
 

src/core/hle/service/filesystem/filesystem.h

@@ -6,7 +6,6 @@
 
 #include <memory>
 #include "common/common_types.h"
-#include "core/file_sys/bis_factory.h"
 #include "core/file_sys/directory.h"
 #include "core/file_sys/mode.h"
 #include "core/file_sys/romfs_factory.h"
@@ -25,17 +24,16 @@ namespace FileSystem {
 ResultCode RegisterRomFS(std::unique_ptr<FileSys::RomFSFactory>&& factory);
 ResultCode RegisterSaveData(std::unique_ptr<FileSys::SaveDataFactory>&& factory);
 ResultCode RegisterSDMC(std::unique_ptr<FileSys::SDMCFactory>&& factory);
-ResultCode RegisterBIS(std::unique_ptr<FileSys::BISFactory>&& factory);
 
-ResultVal<FileSys::VirtualFile> OpenRomFSCurrentProcess();
-ResultVal<FileSys::VirtualFile> OpenRomFS(u64 title_id, FileSys::StorageId storage_id,
-                                          FileSys::ContentRecordType type);
+// TODO(DarkLordZach): BIS Filesystem
+// ResultCode RegisterBIS(std::unique_ptr<FileSys::BISFactory>&& factory);
+ResultVal<FileSys::VirtualFile> OpenRomFS(u64 title_id);
 ResultVal<FileSys::VirtualDir> OpenSaveData(FileSys::SaveDataSpaceId space,
                                             FileSys::SaveDataDescriptor save_struct);
 ResultVal<FileSys::VirtualDir> OpenSDMC();
 
-std::shared_ptr<FileSys::RegisteredCache> GetSystemNANDContents();
-std::shared_ptr<FileSys::RegisteredCache> GetUserNANDContents();
+// TODO(DarkLordZach): BIS Filesystem
+// ResultVal<std::unique_ptr<FileSys::FileSystemBackend>> OpenBIS();
 
 /// Registers all Filesystem services with the specified service manager.
 void InstallInterfaces(SM::ServiceManager& service_manager, const FileSys::VirtualFilesystem& vfs);

src/core/hle/service/filesystem/fsp_srv.cpp

@@ -23,6 +23,15 @@
 
 namespace Service::FileSystem {
 
+enum class StorageId : u8 {
+    None = 0,
+    Host = 1,
+    GameCard = 2,
+    NandSystem = 3,
+    NandUser = 4,
+    SdCard = 5,
+};
+
 class IStorage final : public ServiceFramework<IStorage> {
 public:
     explicit IStorage(FileSys::VirtualFile backend_)
@@ -458,7 +467,7 @@ FSP_SRV::FSP_SRV() : ServiceFramework("fsp-srv") {
         {110, nullptr, "OpenContentStorageFileSystem"},
         {200, &FSP_SRV::OpenDataStorageByCurrentProcess, "OpenDataStorageByCurrentProcess"},
         {201, nullptr, "OpenDataStorageByProgramId"},
-        {202, &FSP_SRV::OpenDataStorageByDataId, "OpenDataStorageByDataId"},
+        {202, nullptr, "OpenDataStorageByDataId"},
         {203, &FSP_SRV::OpenRomStorage, "OpenRomStorage"},
         {400, nullptr, "OpenDeviceOperator"},
         {500, nullptr, "OpenSdCardDetectionEventNotifier"},
@@ -571,7 +580,7 @@ void FSP_SRV::GetGlobalAccessLogMode(Kernel::HLERequestContext& ctx) {
 void FSP_SRV::OpenDataStorageByCurrentProcess(Kernel::HLERequestContext& ctx) {
     LOG_DEBUG(Service_FS, "called");
 
-    auto romfs = OpenRomFSCurrentProcess();
+    auto romfs = OpenRomFS(Core::System::GetInstance().CurrentProcess()->program_id);
     if (romfs.Failed()) {
         // TODO (bunnei): Find the right error code to use here
         LOG_CRITICAL(Service_FS, "no file system interface available!");
@@ -587,37 +596,10 @@ void FSP_SRV::OpenDataStorageByCurrentProcess(Kernel::HLERequestContext& ctx) {
     rb.PushIpcInterface<IStorage>(std::move(storage));
 }
 
-void FSP_SRV::OpenDataStorageByDataId(Kernel::HLERequestContext& ctx) {
-    IPC::RequestParser rp{ctx};
-    const auto storage_id = rp.PopRaw<FileSys::StorageId>();
-    const auto unknown = rp.PopRaw<u32>();
-    const auto title_id = rp.PopRaw<u64>();
-
-    LOG_DEBUG(Service_FS, "called with storage_id={:02X}, unknown={:08X}, title_id={:016X}",
-              static_cast<u8>(storage_id), unknown, title_id);
-
-    auto data = OpenRomFS(title_id, storage_id, FileSys::ContentRecordType::Data);
-    if (data.Failed()) {
-        // TODO(DarkLordZach): Find the right error code to use here
-        LOG_ERROR(Service_FS,
-                  "could not open data storage with title_id={:016X}, storage_id={:02X}", title_id,
-                  static_cast<u8>(storage_id));
-        IPC::ResponseBuilder rb{ctx, 2};
-        rb.Push(ResultCode(-1));
-        return;
-    }
-
-    IStorage storage(std::move(data.Unwrap()));
-
-    IPC::ResponseBuilder rb{ctx, 2, 0, 1};
-    rb.Push(RESULT_SUCCESS);
-    rb.PushIpcInterface<IStorage>(std::move(storage));
-}
-
 void FSP_SRV::OpenRomStorage(Kernel::HLERequestContext& ctx) {
     IPC::RequestParser rp{ctx};
 
-    auto storage_id = rp.PopRaw<FileSys::StorageId>();
+    auto storage_id = rp.PopRaw<StorageId>();
     auto title_id = rp.PopRaw<u64>();
 
     LOG_DEBUG(Service_FS, "called with storage_id={:02X}, title_id={:016X}",

src/core/hle/service/filesystem/fsp_srv.h

@@ -25,7 +25,6 @@ private:
     void MountSaveData(Kernel::HLERequestContext& ctx);
     void GetGlobalAccessLogMode(Kernel::HLERequestContext& ctx);
     void OpenDataStorageByCurrentProcess(Kernel::HLERequestContext& ctx);
-    void OpenDataStorageByDataId(Kernel::HLERequestContext& ctx);
     void OpenRomStorage(Kernel::HLERequestContext& ctx);
 
     FileSys::VirtualFile romfs;

src/core/hle/service/lm/lm.cpp

@@ -92,11 +92,7 @@ private:
 
         // Parse out log metadata
         u32 line{};
-        std::string module;
-        std::string message;
-        std::string filename;
-        std::string function;
-        std::string thread;
+        std::string message, filename, function;
         while (addr < end_addr) {
             const Field field{static_cast<Field>(Memory::Read8(addr++))};
             const size_t length{Memory::Read8(addr++)};
@@ -106,8 +102,6 @@ private:
             }
 
             switch (field) {
-            case Field::Skip:
-                break;
             case Field::Message:
                 message = Memory::ReadCString(addr, length);
                 break;
@@ -120,12 +114,6 @@ private:
             case Field::Function:
                 function = Memory::ReadCString(addr, length);
                 break;
-            case Field::Module:
-                module = Memory::ReadCString(addr, length);
-                break;
-            case Field::Thread:
-                thread = Memory::ReadCString(addr, length);
-                break;
             }
 
             addr += length;
@@ -140,18 +128,12 @@ private:
         if (!filename.empty()) {
             log_stream << filename << ':';
         }
-        if (!module.empty()) {
-            log_stream << module << ':';
-        }
         if (!function.empty()) {
             log_stream << function << ':';
         }
         if (line) {
             log_stream << std::to_string(line) << ':';
         }
-        if (!thread.empty()) {
-            log_stream << thread << ':';
-        }
         if (log_stream.str().length() > 0 && log_stream.str().back() == ':') {
             log_stream << ' ';
         }
@@ -160,7 +142,7 @@ private:
         if (header.IsTailLog()) {
             switch (header.severity) {
             case MessageHeader::Severity::Trace:
-                LOG_DEBUG(Debug_Emulated, "{}", log_stream.str());
+                LOG_TRACE(Debug_Emulated, "{}", log_stream.str());
                 break;
             case MessageHeader::Severity::Info:
                 LOG_INFO(Debug_Emulated, "{}", log_stream.str());

src/core/hle/service/mm/mm_u.cpp

@@ -9,63 +9,42 @@
 
 namespace Service::MM {
 
-class MM_U final : public ServiceFramework<MM_U> {
-public:
-    explicit MM_U() : ServiceFramework{"mm:u"} {
-        // clang-format off
-        static const FunctionInfo functions[] = {
-            {0, &MM_U::Initialize, "InitializeOld"},
-            {1, &MM_U::Finalize, "FinalizeOld"},
-            {2, &MM_U::SetAndWait, "SetAndWaitOld"},
-            {3, &MM_U::Get, "GetOld"},
-            {4, &MM_U::Initialize, "Initialize"},
-            {5, &MM_U::Finalize, "Finalize"},
-            {6, &MM_U::SetAndWait, "SetAndWait"},
-            {7, &MM_U::Get, "Get"},
-        };
-        // clang-format on
-
-        RegisterHandlers(functions);
-    }
-
-private:
-    void Initialize(Kernel::HLERequestContext& ctx) {
-        LOG_WARNING(Service_MM, "(STUBBED) called");
-        IPC::ResponseBuilder rb{ctx, 2};
-        rb.Push(RESULT_SUCCESS);
-    }
-
-    void Finalize(Kernel::HLERequestContext& ctx) {
-        LOG_WARNING(Service_MM, "(STUBBED) called");
-        IPC::ResponseBuilder rb{ctx, 2};
-        rb.Push(RESULT_SUCCESS);
-    }
-
-    void SetAndWait(Kernel::HLERequestContext& ctx) {
-        IPC::RequestParser rp{ctx};
-        min = rp.Pop<u32>();
-        max = rp.Pop<u32>();
-        current = min;
-
-        LOG_WARNING(Service_MM, "(STUBBED) called, min=0x{:X}, max=0x{:X}", min, max);
-        IPC::ResponseBuilder rb{ctx, 2};
-        rb.Push(RESULT_SUCCESS);
-    }
-
-    void Get(Kernel::HLERequestContext& ctx) {
-        LOG_WARNING(Service_MM, "(STUBBED) called");
-        IPC::ResponseBuilder rb{ctx, 3};
-        rb.Push(RESULT_SUCCESS);
-        rb.Push(current);
-    }
-
-    u32 min{0};
-    u32 max{0};
-    u32 current{0};
-};
-
 void InstallInterfaces(SM::ServiceManager& service_manager) {
     std::make_shared<MM_U>()->InstallAsService(service_manager);
 }
 
+void MM_U::Initialize(Kernel::HLERequestContext& ctx) {
+    LOG_WARNING(Service_MM, "(STUBBED) called");
+    IPC::ResponseBuilder rb{ctx, 2};
+    rb.Push(RESULT_SUCCESS);
+}
+
+void MM_U::SetAndWait(Kernel::HLERequestContext& ctx) {
+    IPC::RequestParser rp{ctx};
+    min = rp.Pop<u32>();
+    max = rp.Pop<u32>();
+    current = min;
+
+    LOG_WARNING(Service_MM, "(STUBBED) called, min=0x{:X}, max=0x{:X}", min, max);
+    IPC::ResponseBuilder rb{ctx, 2};
+    rb.Push(RESULT_SUCCESS);
+}
+
+void MM_U::Get(Kernel::HLERequestContext& ctx) {
+    LOG_WARNING(Service_MM, "(STUBBED) called");
+    IPC::ResponseBuilder rb{ctx, 3};
+    rb.Push(RESULT_SUCCESS);
+    rb.Push(current);
+}
+
+MM_U::MM_U() : ServiceFramework("mm:u") {
+    static const FunctionInfo functions[] = {
+        {0, nullptr, "InitializeOld"},        {1, nullptr, "FinalizeOld"},
+        {2, nullptr, "SetAndWaitOld"},        {3, nullptr, "GetOld"},
+        {4, &MM_U::Initialize, "Initialize"}, {5, nullptr, "Finalize"},
+        {6, &MM_U::SetAndWait, "SetAndWait"}, {7, &MM_U::Get, "Get"},
+    };
+    RegisterHandlers(functions);
+}
+
 } // namespace Service::MM

src/core/hle/service/mm/mm_u.h

@@ -8,6 +8,21 @@
 
 namespace Service::MM {
 
+class MM_U final : public ServiceFramework<MM_U> {
+public:
+    MM_U();
+    ~MM_U() = default;
+
+private:
+    void Initialize(Kernel::HLERequestContext& ctx);
+    void SetAndWait(Kernel::HLERequestContext& ctx);
+    void Get(Kernel::HLERequestContext& ctx);
+
+    u32 min{0};
+    u32 max{0};
+    u32 current{0};
+};
+
 /// Registers all MM services with the specified service manager.
 void InstallInterfaces(SM::ServiceManager& service_manager);
 

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

@@ -1,34 +0,0 @@
-// Copyright 2018 yuzu emulator team
-// Licensed under GPLv2 or any later version
-// Refer to the license.txt file included.
-
-#include <cstring>
-
-#include "common/assert.h"
-#include "common/logging/log.h"
-#include "core/hle/service/nvdrv/devices/nvhost_nvjpg.h"
-
-namespace Service::Nvidia::Devices {
-
-u32 nvhost_nvjpg::ioctl(Ioctl command, const std::vector<u8>& input, std::vector<u8>& output) {
-    LOG_DEBUG(Service_NVDRV, "called, command=0x{:08X}, input_size=0x{:X}, output_size=0x{:X}",
-              command.raw, input.size(), output.size());
-
-    switch (static_cast<IoctlCommand>(command.raw)) {
-    case IoctlCommand::IocSetNVMAPfdCommand:
-        return SetNVMAPfd(input, output);
-    }
-
-    UNIMPLEMENTED_MSG("Unimplemented ioctl");
-    return 0;
-}
-
-u32 nvhost_nvjpg::SetNVMAPfd(const std::vector<u8>& input, std::vector<u8>& output) {
-    IoctlSetNvmapFD params{};
-    std::memcpy(&params, input.data(), input.size());
-    LOG_DEBUG(Service_NVDRV, "called, fd={}", params.nvmap_fd);
-    nvmap_fd = params.nvmap_fd;
-    return 0;
-}
-
-} // namespace Service::Nvidia::Devices

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

@@ -1,36 +0,0 @@
-// Copyright 2018 yuzu emulator team
-// Licensed under GPLv2 or any later version
-// Refer to the license.txt file included.
-
-#pragma once
-
-#include <vector>
-#include "common/common_types.h"
-#include "common/swap.h"
-#include "core/hle/service/nvdrv/devices/nvdevice.h"
-
-namespace Service::Nvidia::Devices {
-
-class nvhost_nvjpg final : public nvdevice {
-public:
-    nvhost_nvjpg() = default;
-    ~nvhost_nvjpg() override = default;
-
-    u32 ioctl(Ioctl command, const std::vector<u8>& input, std::vector<u8>& output) override;
-
-private:
-    enum class IoctlCommand : u32_le {
-        IocSetNVMAPfdCommand = 0x40044801,
-    };
-
-    struct IoctlSetNvmapFD {
-        u32_le nvmap_fd;
-    };
-    static_assert(sizeof(IoctlSetNvmapFD) == 4, "IoctlSetNvmapFD is incorrect size");
-
-    u32_le nvmap_fd{};
-
-    u32 SetNVMAPfd(const std::vector<u8>& input, std::vector<u8>& output);
-};
-
-} // namespace Service::Nvidia::Devices

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

@@ -1,34 +0,0 @@
-// Copyright 2018 yuzu emulator team
-// Licensed under GPLv2 or any later version
-// Refer to the license.txt file included.
-
-#include <cstring>
-
-#include "common/assert.h"
-#include "common/logging/log.h"
-#include "core/hle/service/nvdrv/devices/nvhost_vic.h"
-
-namespace Service::Nvidia::Devices {
-
-u32 nvhost_vic::ioctl(Ioctl command, const std::vector<u8>& input, std::vector<u8>& output) {
-    LOG_DEBUG(Service_NVDRV, "called, command=0x{:08X}, input_size=0x{:X}, output_size=0x{:X}",
-              command.raw, input.size(), output.size());
-
-    switch (static_cast<IoctlCommand>(command.raw)) {
-    case IoctlCommand::IocSetNVMAPfdCommand:
-        return SetNVMAPfd(input, output);
-    }
-
-    UNIMPLEMENTED_MSG("Unimplemented ioctl");
-    return 0;
-}
-
-u32 nvhost_vic::SetNVMAPfd(const std::vector<u8>& input, std::vector<u8>& output) {
-    IoctlSetNvmapFD params{};
-    std::memcpy(&params, input.data(), input.size());
-    LOG_DEBUG(Service_NVDRV, "called, fd={}", params.nvmap_fd);
-    nvmap_fd = params.nvmap_fd;
-    return 0;
-}
-
-} // namespace Service::Nvidia::Devices

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

@@ -1,36 +0,0 @@
-// Copyright 2018 yuzu emulator team
-// Licensed under GPLv2 or any later version
-// Refer to the license.txt file included.
-
-#pragma once
-
-#include <vector>
-#include "common/common_types.h"
-#include "common/swap.h"
-#include "core/hle/service/nvdrv/devices/nvdevice.h"
-
-namespace Service::Nvidia::Devices {
-
-class nvhost_vic final : public nvdevice {
-public:
-    nvhost_vic() = default;
-    ~nvhost_vic() override = default;
-
-    u32 ioctl(Ioctl command, const std::vector<u8>& input, std::vector<u8>& output) override;
-
-private:
-    enum class IoctlCommand : u32_le {
-        IocSetNVMAPfdCommand = 0x40044801,
-    };
-
-    struct IoctlSetNvmapFD {
-        u32_le nvmap_fd;
-    };
-    static_assert(sizeof(IoctlSetNvmapFD) == 4, "IoctlSetNvmapFD is incorrect size");
-
-    u32_le nvmap_fd{};
-
-    u32 SetNVMAPfd(const std::vector<u8>& input, std::vector<u8>& output);
-};
-
-} // namespace Service::Nvidia::Devices

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

@@ -12,8 +12,6 @@
 #include "core/hle/service/nvdrv/devices/nvhost_ctrl_gpu.h"
 #include "core/hle/service/nvdrv/devices/nvhost_gpu.h"
 #include "core/hle/service/nvdrv/devices/nvhost_nvdec.h"
-#include "core/hle/service/nvdrv/devices/nvhost_nvjpg.h"
-#include "core/hle/service/nvdrv/devices/nvhost_vic.h"
 #include "core/hle/service/nvdrv/devices/nvmap.h"
 #include "core/hle/service/nvdrv/interface.h"
 #include "core/hle/service/nvdrv/nvdrv.h"
@@ -41,8 +39,6 @@ Module::Module() {
     devices["/dev/nvdisp_disp0"] = std::make_shared<Devices::nvdisp_disp0>(nvmap_dev);
     devices["/dev/nvhost-ctrl"] = std::make_shared<Devices::nvhost_ctrl>();
     devices["/dev/nvhost-nvdec"] = std::make_shared<Devices::nvhost_nvdec>();
-    devices["/dev/nvhost-nvjpg"] = std::make_shared<Devices::nvhost_nvjpg>();
-    devices["/dev/nvhost-vic"] = std::make_shared<Devices::nvhost_vic>();
 }
 
 u32 Module::Open(const std::string& device_name) {

src/core/hle/service/sm/controller.cpp

@@ -10,7 +10,7 @@
 namespace Service::SM {
 
 void Controller::ConvertSessionToDomain(Kernel::HLERequestContext& ctx) {
-    ASSERT_MSG(ctx.Session()->IsSession(), "Session is already a domain");
+    ASSERT_MSG(!ctx.Session()->IsDomain(), "session is alread a domain");
     ctx.Session()->ConvertToDomain();
 
     IPC::ResponseBuilder rb{ctx, 3};
@@ -41,7 +41,7 @@ void Controller::DuplicateSessionEx(Kernel::HLERequestContext& ctx) {
 void Controller::QueryPointerBufferSize(Kernel::HLERequestContext& ctx) {
     IPC::ResponseBuilder rb{ctx, 3};
     rb.Push(RESULT_SUCCESS);
-    rb.Push<u16>(0x500);
+    rb.Push<u32>(0x500);
 
     LOG_WARNING(Service, "(STUBBED) called");
 }

src/core/loader/deconstructed_rom_directory.cpp

@@ -118,6 +118,7 @@ ResultStatus AppLoader_DeconstructedRomDirectory::Load(
 
     process->program_id = metadata.GetTitleID();
     process->svc_access_mask.set();
+    process->address_mappings = default_address_mappings;
     process->resource_limit =
         Kernel::ResourceLimit::GetForCategory(Kernel::ResourceLimitCategory::APPLICATION);
     process->Run(Memory::PROCESS_IMAGE_VADDR, metadata.GetMainThreadPriority(),

src/core/loader/elf.cpp

@@ -398,6 +398,7 @@ ResultStatus AppLoader_ELF::Load(Kernel::SharedPtr<Kernel::Process>& process) {
 
     process->LoadModule(codeset, codeset->entrypoint);
     process->svc_access_mask.set();
+    process->address_mappings = default_address_mappings;
 
     // Attach the default resource limit (APPLICATION) to the process
     process->resource_limit =

src/core/loader/loader.cpp

@@ -3,7 +3,6 @@
 // Refer to the license.txt file included.
 
 #include <memory>
-#include <ostream>
 #include <string>
 #include "common/logging/log.h"
 #include "common/string_util.h"
@@ -18,6 +17,12 @@
 
 namespace Loader {
 
+const std::initializer_list<Kernel::AddressMapping> default_address_mappings = {
+    {0x1FF50000, 0x8000, true},    // part of DSP RAM
+    {0x1FF70000, 0x8000, true},    // part of DSP RAM
+    {0x1F000000, 0x600000, false}, // entire VRAM
+};
+
 FileType IdentifyFile(FileSys::VirtualFile file) {
     FileType type;
 
@@ -41,8 +46,6 @@ FileType IdentifyFile(FileSys::VirtualFile file) {
 FileType GuessFromFilename(const std::string& name) {
     if (name == "main")
         return FileType::DeconstructedRomDirectory;
-    if (name == "00")
-        return FileType::NCA;
 
     const std::string extension =
         Common::ToLower(std::string(FileUtil::GetExtensionFromFilename(name)));
@@ -122,9 +125,14 @@ constexpr std::array<const char*, 36> RESULT_MESSAGES{
     "There is no control data available.",
 };
 
-std::ostream& operator<<(std::ostream& os, ResultStatus status) {
-    os << RESULT_MESSAGES.at(static_cast<size_t>(status));
-    return os;
+std::string GetMessageForResultStatus(ResultStatus status) {
+    return GetMessageForResultStatus(static_cast<u16>(status));
+}
+
+std::string GetMessageForResultStatus(u16 status) {
+    if (status >= 36)
+        return "";
+    return RESULT_MESSAGES[status];
 }
 
 /**

src/core/loader/loader.h

@@ -5,7 +5,7 @@
 #pragma once
 
 #include <algorithm>
-#include <iosfwd>
+#include <initializer_list>
 #include <memory>
 #include <string>
 #include <utility>
@@ -95,7 +95,8 @@ enum class ResultStatus : u16 {
     ErrorNoControl,
 };
 
-std::ostream& operator<<(std::ostream& os, ResultStatus status);
+std::string GetMessageForResultStatus(ResultStatus status);
+std::string GetMessageForResultStatus(u16 status);
 
 /// Interface for loading an application
 class AppLoader : NonCopyable {
@@ -206,6 +207,12 @@ protected:
     bool is_loaded = false;
 };
 
+/**
+ * Common address mappings found in most games, used for binary formats that don't have this
+ * information.
+ */
+extern const std::initializer_list<Kernel::AddressMapping> default_address_mappings;
+
 /**
  * Identifies a bootable file and return a suitable loader
  * @param file The bootable file

src/core/loader/nca.cpp

@@ -3,22 +3,28 @@
 // Refer to the license.txt file included.
 
 #include <utility>
+#include <vector>
 
 #include "common/file_util.h"
 #include "common/logging/log.h"
+#include "common/string_util.h"
+#include "common/swap.h"
+#include "core/core.h"
 #include "core/file_sys/content_archive.h"
+#include "core/file_sys/program_metadata.h"
+#include "core/gdbstub/gdbstub.h"
 #include "core/hle/kernel/process.h"
+#include "core/hle/kernel/resource_limit.h"
 #include "core/hle/service/filesystem/filesystem.h"
-#include "core/loader/deconstructed_rom_directory.h"
 #include "core/loader/nca.h"
+#include "core/loader/nso.h"
+#include "core/memory.h"
 
 namespace Loader {
 
 AppLoader_NCA::AppLoader_NCA(FileSys::VirtualFile file_)
     : AppLoader(std::move(file_)), nca(std::make_unique<FileSys::NCA>(file)) {}
 
-AppLoader_NCA::~AppLoader_NCA() = default;
-
 FileType AppLoader_NCA::IdentifyType(const FileSys::VirtualFile& file) {
     FileSys::NCA nca(file);
 
@@ -77,4 +83,6 @@ ResultStatus AppLoader_NCA::ReadProgramId(u64& out_program_id) {
     return ResultStatus::Success;
 }
 
+AppLoader_NCA::~AppLoader_NCA() = default;
+
 } // namespace Loader

src/core/loader/nca.h

@@ -4,24 +4,20 @@
 
 #pragma once
 
+#include <string>
 #include "common/common_types.h"
-#include "core/file_sys/vfs.h"
+#include "core/file_sys/content_archive.h"
+#include "core/file_sys/program_metadata.h"
 #include "core/hle/kernel/object.h"
 #include "core/loader/loader.h"
-
-namespace FileSys {
-class NCA;
-}
+#include "deconstructed_rom_directory.h"
 
 namespace Loader {
 
-class AppLoader_DeconstructedRomDirectory;
-
 /// Loads an NCA file
 class AppLoader_NCA final : public AppLoader {
 public:
     explicit AppLoader_NCA(FileSys::VirtualFile file);
-    ~AppLoader_NCA() override;
 
     /**
      * Returns the type of the file
@@ -39,7 +35,12 @@ public:
     ResultStatus ReadRomFS(FileSys::VirtualFile& dir) override;
     ResultStatus ReadProgramId(u64& out_program_id) override;
 
+    ~AppLoader_NCA();
+
 private:
+    FileSys::ProgramMetadata metadata;
+
+    FileSys::NCAHeader header;
     std::unique_ptr<FileSys::NCA> nca;
     std::unique_ptr<AppLoader_DeconstructedRomDirectory> directory_loader;
 };

src/core/loader/nro.cpp

@@ -186,6 +186,7 @@ ResultStatus AppLoader_NRO::Load(Kernel::SharedPtr<Kernel::Process>& process) {
     }
 
     process->svc_access_mask.set();
+    process->address_mappings = default_address_mappings;
     process->resource_limit =
         Kernel::ResourceLimit::GetForCategory(Kernel::ResourceLimitCategory::APPLICATION);
     process->Run(base_addr, THREADPRIO_DEFAULT, Memory::DEFAULT_STACK_SIZE);

src/core/loader/nso.cpp

@@ -152,6 +152,7 @@ ResultStatus AppLoader_NSO::Load(Kernel::SharedPtr<Kernel::Process>& process) {
     LOG_DEBUG(Loader, "loaded module {} @ 0x{:X}", file->GetName(), Memory::PROCESS_IMAGE_VADDR);
 
     process->svc_access_mask.set();
+    process->address_mappings = default_address_mappings;
     process->resource_limit =
         Kernel::ResourceLimit::GetForCategory(Kernel::ResourceLimitCategory::APPLICATION);
     process->Run(Memory::PROCESS_IMAGE_VADDR, THREADPRIO_DEFAULT, Memory::DEFAULT_STACK_SIZE);

src/core/loader/xci.cpp

@@ -4,14 +4,22 @@
 
 #include <vector>
 
-#include "common/common_types.h"
-#include "core/file_sys/card_image.h"
+#include "common/file_util.h"
+#include "common/logging/log.h"
+#include "common/string_util.h"
+#include "common/swap.h"
+#include "core/core.h"
 #include "core/file_sys/content_archive.h"
 #include "core/file_sys/control_metadata.h"
+#include "core/file_sys/program_metadata.h"
 #include "core/file_sys/romfs.h"
+#include "core/gdbstub/gdbstub.h"
 #include "core/hle/kernel/process.h"
-#include "core/loader/nca.h"
+#include "core/hle/kernel/resource_limit.h"
+#include "core/hle/service/filesystem/filesystem.h"
+#include "core/loader/nso.h"
 #include "core/loader/xci.h"
+#include "core/memory.h"
 
 namespace Loader {
 

src/core/loader/xci.h

@@ -6,18 +6,12 @@
 
 #include <memory>
 #include "common/common_types.h"
-#include "core/file_sys/vfs.h"
+#include "core/file_sys/card_image.h"
 #include "core/loader/loader.h"
-
-namespace FileSys {
-class NACP;
-class XCI;
-} // namespace FileSys
+#include "core/loader/nca.h"
 
 namespace Loader {
 
-class AppLoader_NCA;
-
 /// Loads an XCI file
 class AppLoader_XCI final : public AppLoader {
 public:
@@ -43,6 +37,8 @@ public:
     ResultStatus ReadTitle(std::string& title) override;
 
 private:
+    FileSys::ProgramMetadata metadata;
+
     std::unique_ptr<FileSys::XCI> xci;
     std::unique_ptr<AppLoader_NCA> nca_loader;
 

src/video_core/engines/maxwell_3d.cpp

@@ -222,18 +222,6 @@ void Maxwell3D::DrawArrays() {
         debug_context->OnEvent(Tegra::DebugContext::Event::FinishedPrimitiveBatch, nullptr);
     }
 
-    // Both instance configuration registers can not be set at the same time.
-    ASSERT_MSG(!regs.draw.instance_next || !regs.draw.instance_cont,
-               "Illegal combination of instancing parameters");
-
-    if (regs.draw.instance_next) {
-        // Increment the current instance *before* drawing.
-        state.current_instance += 1;
-    } else if (!regs.draw.instance_cont) {
-        // Reset the current instance to 0.
-        state.current_instance = 0;
-    }
-
     const bool is_indexed{regs.index_array.count && !regs.vertex_buffer.count};
     rasterizer.AccelerateDrawBatch(is_indexed);
 

src/video_core/engines/maxwell_3d.h

@@ -638,8 +638,6 @@ public:
                     union {
                         u32 vertex_begin_gl;
                         BitField<0, 16, PrimitiveTopology> topology;
-                        BitField<26, 1, u32> instance_next;
-                        BitField<27, 1, u32> instance_cont;
                     };
                 } draw;
 
@@ -832,7 +830,6 @@ public:
         };
 
         std::array<ShaderStageInfo, Regs::MaxShaderStage> shader_stages;
-        u32 current_instance = 0; ///< Current instance to be used to simulate instanced rendering.
     };
 
     State state{};

src/video_core/engines/shader_bytecode.h

@@ -141,7 +141,6 @@ enum class PredCondition : u64 {
     NotEqual = 5,
     GreaterEqual = 6,
     LessThanWithNan = 9,
-    GreaterThanWithNan = 12,
     NotEqualWithNan = 13,
     // TODO(Subv): Other condition types
 };

src/video_core/gpu.cpp

@@ -47,10 +47,8 @@ u32 RenderTargetBytesPerPixel(RenderTargetFormat format) {
     case RenderTargetFormat::RGBA32_UINT:
         return 16;
     case RenderTargetFormat::RGBA16_UINT:
-    case RenderTargetFormat::RGBA16_UNORM:
     case RenderTargetFormat::RGBA16_FLOAT:
     case RenderTargetFormat::RG32_FLOAT:
-    case RenderTargetFormat::RG32_UINT:
         return 8;
     case RenderTargetFormat::RGBA8_UNORM:
     case RenderTargetFormat::RGBA8_SNORM:
@@ -64,7 +62,6 @@ u32 RenderTargetBytesPerPixel(RenderTargetFormat format) {
     case RenderTargetFormat::RG16_FLOAT:
     case RenderTargetFormat::R32_FLOAT:
     case RenderTargetFormat::R11G11B10_FLOAT:
-    case RenderTargetFormat::R32_UINT:
         return 4;
     case RenderTargetFormat::R16_UNORM:
     case RenderTargetFormat::R16_SNORM:

src/video_core/gpu.h

@@ -20,11 +20,9 @@ enum class RenderTargetFormat : u32 {
     NONE = 0x0,
     RGBA32_FLOAT = 0xC0,
     RGBA32_UINT = 0xC2,
-    RGBA16_UNORM = 0xC6,
     RGBA16_UINT = 0xC9,
     RGBA16_FLOAT = 0xCA,
     RG32_FLOAT = 0xCB,
-    RG32_UINT = 0xCD,
     BGRA8_UNORM = 0xCF,
     RGB10_A2_UNORM = 0xD1,
     RGBA8_UNORM = 0xD5,
@@ -36,7 +34,6 @@ enum class RenderTargetFormat : u32 {
     RG16_UINT = 0xDD,
     RG16_FLOAT = 0xDE,
     R11G11B10_FLOAT = 0xE0,
-    R32_UINT = 0xE4,
     R32_FLOAT = 0xE5,
     B5G6R5_UNORM = 0xE8,
     RG8_UNORM = 0xEA,

src/video_core/renderer_opengl/gl_rasterizer.cpp

@@ -124,7 +124,7 @@ std::pair<u8*, GLintptr> RasterizerOpenGL::SetupVertexArrays(u8* array_ptr,
         glBindVertexBuffer(index, stream_buffer.GetHandle(), vertex_buffer_offset,
                            vertex_array.stride);
 
-        ASSERT_MSG(vertex_array.divisor == 0, "Instanced vertex arrays are not supported");
+        ASSERT_MSG(vertex_array.divisor == 0, "Vertex buffer divisor unimplemented");
     }
 
     // Use the vertex array as-is, assumes that the data is formatted correctly for OpenGL.
@@ -648,11 +648,11 @@ std::tuple<u8*, GLintptr, u32> RasterizerOpenGL::SetupConstBuffers(
 
         if (used_buffer.IsIndirect()) {
             // Buffer is accessed indirectly, so upload the entire thing
-            size = buffer.size;
+            size = buffer.size * sizeof(float);
 
             if (size > MaxConstbufferSize) {
-                LOG_CRITICAL(HW_GPU, "indirect constbuffer size {} exceeds maximum {}", size,
-                             MaxConstbufferSize);
+                LOG_ERROR(HW_GPU, "indirect constbuffer size {} exceeds maximum {}", size,
+                          MaxConstbufferSize);
                 size = MaxConstbufferSize;
             }
         } else {

src/video_core/renderer_opengl/gl_rasterizer_cache.cpp

@@ -94,14 +94,13 @@ struct FormatTuple {
 static constexpr std::array<FormatTuple, SurfaceParams::MaxPixelFormat> tex_format_tuples = {{
     {GL_RGBA8, GL_RGBA, GL_UNSIGNED_INT_8_8_8_8_REV, ComponentType::UNorm, false}, // ABGR8U
     {GL_RGBA8, GL_RGBA, GL_BYTE, ComponentType::SNorm, false},                     // ABGR8S
-    {GL_RGB, GL_RGB, GL_UNSIGNED_SHORT_5_6_5_REV, ComponentType::UNorm, false},    // B5G6R5U
+    {GL_RGB, GL_RGB, GL_UNSIGNED_SHORT_5_6_5_REV, ComponentType::UNorm, false},    // B5G6R5
     {GL_RGB10_A2, GL_RGBA, GL_UNSIGNED_INT_2_10_10_10_REV, ComponentType::UNorm,
-     false}, // A2B10G10R10U
-    {GL_RGB5_A1, GL_RGBA, GL_UNSIGNED_SHORT_1_5_5_5_REV, ComponentType::UNorm, false}, // A1B5G5R5U
-    {GL_R8, GL_RED, GL_UNSIGNED_BYTE, ComponentType::UNorm, false},                    // R8U
+     false}, // A2B10G10R10
+    {GL_RGB5_A1, GL_RGBA, GL_UNSIGNED_SHORT_1_5_5_5_REV, ComponentType::UNorm, false}, // A1B5G5R5
+    {GL_R8, GL_RED, GL_UNSIGNED_BYTE, ComponentType::UNorm, false},                    // R8
     {GL_R8UI, GL_RED_INTEGER, GL_UNSIGNED_BYTE, ComponentType::UInt, false},           // R8UI
     {GL_RGBA16F, GL_RGBA, GL_HALF_FLOAT, ComponentType::Float, false},                 // RGBA16F
-    {GL_RGBA16, GL_RGBA, GL_UNSIGNED_SHORT, ComponentType::UNorm, false},              // RGBA16U
     {GL_RGBA16UI, GL_RGBA, GL_UNSIGNED_SHORT, ComponentType::UInt, false},             // RGBA16UI
     {GL_R11F_G11F_B10F, GL_RGB, GL_UNSIGNED_INT_10F_11F_11F_REV, ComponentType::Float,
      false},                                                                     // R11FG11FB10F
@@ -116,17 +115,16 @@ static constexpr std::array<FormatTuple, SurfaceParams::MaxPixelFormat> tex_form
     {GL_COMPRESSED_RG_RGTC2, GL_RG, GL_UNSIGNED_INT_8_8_8_8, ComponentType::UNorm,
      true},                                                                     // DXN2UNORM
     {GL_COMPRESSED_SIGNED_RG_RGTC2, GL_RG, GL_INT, ComponentType::SNorm, true}, // DXN2SNORM
-    {GL_COMPRESSED_RGBA_BPTC_UNORM_ARB, GL_RGBA, GL_UNSIGNED_INT_8_8_8_8, ComponentType::UNorm,
+    {GL_COMPRESSED_RGBA_BPTC_UNORM_ARB, GL_RGB, GL_UNSIGNED_INT_8_8_8_8, ComponentType::UNorm,
      true},                                                                    // BC7U
     {GL_RGBA8, GL_RGBA, GL_UNSIGNED_BYTE, ComponentType::UNorm, false},        // ASTC_2D_4X4
-    {GL_RG8, GL_RG, GL_UNSIGNED_BYTE, ComponentType::UNorm, false},            // G8R8U
-    {GL_RG8, GL_RG, GL_BYTE, ComponentType::SNorm, false},                     // G8R8S
+    {GL_RG8, GL_RG, GL_UNSIGNED_BYTE, ComponentType::UNorm, false},            // G8R8
     {GL_RGBA8, GL_BGRA, GL_UNSIGNED_BYTE, ComponentType::UNorm, false},        // BGRA8
     {GL_RGBA32F, GL_RGBA, GL_FLOAT, ComponentType::Float, false},              // RGBA32F
     {GL_RG32F, GL_RG, GL_FLOAT, ComponentType::Float, false},                  // RG32F
     {GL_R32F, GL_RED, GL_FLOAT, ComponentType::Float, false},                  // R32F
     {GL_R16F, GL_RED, GL_HALF_FLOAT, ComponentType::Float, false},             // R16F
-    {GL_R16, GL_RED, GL_UNSIGNED_SHORT, ComponentType::UNorm, false},          // R16U
+    {GL_R16, GL_RED, GL_UNSIGNED_SHORT, ComponentType::UNorm, false},          // R16UNORM
     {GL_R16_SNORM, GL_RED, GL_SHORT, ComponentType::SNorm, false},             // R16S
     {GL_R16UI, GL_RED_INTEGER, GL_UNSIGNED_SHORT, ComponentType::UInt, false}, // R16UI
     {GL_R16I, GL_RED_INTEGER, GL_SHORT, ComponentType::SInt, false},           // R16I
@@ -139,19 +137,15 @@ static constexpr std::array<FormatTuple, SurfaceParams::MaxPixelFormat> tex_form
     {GL_SRGB8_ALPHA8, GL_RGBA, GL_UNSIGNED_INT_8_8_8_8_REV, ComponentType::UNorm, false}, // SRGBA8
     {GL_RG8, GL_RG, GL_UNSIGNED_BYTE, ComponentType::UNorm, false},                       // RG8U
     {GL_RG8, GL_RG, GL_BYTE, ComponentType::SNorm, false},                                // RG8S
-    {GL_RG32UI, GL_RG_INTEGER, GL_UNSIGNED_INT, ComponentType::UInt, false},              // RG32UI
-    {GL_R32UI, GL_RED_INTEGER, GL_UNSIGNED_INT, ComponentType::UInt, false},              // R32UI
-
-    // Depth formats
-    {GL_DEPTH_COMPONENT32F, GL_DEPTH_COMPONENT, GL_FLOAT, ComponentType::Float, false}, // Z32F
-    {GL_DEPTH_COMPONENT16, GL_DEPTH_COMPONENT, GL_UNSIGNED_SHORT, ComponentType::UNorm,
-     false}, // Z16
 
     // DepthStencil formats
     {GL_DEPTH24_STENCIL8, GL_DEPTH_STENCIL, GL_UNSIGNED_INT_24_8, ComponentType::UNorm,
      false}, // Z24S8
     {GL_DEPTH24_STENCIL8, GL_DEPTH_STENCIL, GL_UNSIGNED_INT_24_8, ComponentType::UNorm,
-     false}, // S8Z24
+     false},                                                                            // S8Z24
+    {GL_DEPTH_COMPONENT32F, GL_DEPTH_COMPONENT, GL_FLOAT, ComponentType::Float, false}, // Z32F
+    {GL_DEPTH_COMPONENT16, GL_DEPTH_COMPONENT, GL_UNSIGNED_SHORT, ComponentType::UNorm,
+     false}, // Z16
     {GL_DEPTH32F_STENCIL8, GL_DEPTH_STENCIL, GL_FLOAT_32_UNSIGNED_INT_24_8_REV,
      ComponentType::Float, false}, // Z32FS8
 }};
@@ -245,13 +239,12 @@ static constexpr std::array<void (*)(u32, u32, u32, std::vector<u8>&, Tegra::GPU
         // clang-format off
         MortonCopy<true, PixelFormat::ABGR8U>,
         MortonCopy<true, PixelFormat::ABGR8S>,
-        MortonCopy<true, PixelFormat::B5G6R5U>,
-        MortonCopy<true, PixelFormat::A2B10G10R10U>,
-        MortonCopy<true, PixelFormat::A1B5G5R5U>,
-        MortonCopy<true, PixelFormat::R8U>,
+        MortonCopy<true, PixelFormat::B5G6R5>,
+        MortonCopy<true, PixelFormat::A2B10G10R10>,
+        MortonCopy<true, PixelFormat::A1B5G5R5>,
+        MortonCopy<true, PixelFormat::R8>,
         MortonCopy<true, PixelFormat::R8UI>,
         MortonCopy<true, PixelFormat::RGBA16F>,
-        MortonCopy<true, PixelFormat::RGBA16U>,
         MortonCopy<true, PixelFormat::RGBA16UI>,
         MortonCopy<true, PixelFormat::R11FG11FB10F>,
         MortonCopy<true, PixelFormat::RGBA32UI>,
@@ -263,14 +256,13 @@ static constexpr std::array<void (*)(u32, u32, u32, std::vector<u8>&, Tegra::GPU
         MortonCopy<true, PixelFormat::DXN2SNORM>,
         MortonCopy<true, PixelFormat::BC7U>,
         MortonCopy<true, PixelFormat::ASTC_2D_4X4>,
-        MortonCopy<true, PixelFormat::G8R8U>,
-        MortonCopy<true, PixelFormat::G8R8S>,
+        MortonCopy<true, PixelFormat::G8R8>,
         MortonCopy<true, PixelFormat::BGRA8>,
         MortonCopy<true, PixelFormat::RGBA32F>,
         MortonCopy<true, PixelFormat::RG32F>,
         MortonCopy<true, PixelFormat::R32F>,
         MortonCopy<true, PixelFormat::R16F>,
-        MortonCopy<true, PixelFormat::R16U>,
+        MortonCopy<true, PixelFormat::R16UNORM>,
         MortonCopy<true, PixelFormat::R16S>,
         MortonCopy<true, PixelFormat::R16UI>,
         MortonCopy<true, PixelFormat::R16I>,
@@ -283,12 +275,10 @@ static constexpr std::array<void (*)(u32, u32, u32, std::vector<u8>&, Tegra::GPU
         MortonCopy<true, PixelFormat::SRGBA8>,
         MortonCopy<true, PixelFormat::RG8U>,
         MortonCopy<true, PixelFormat::RG8S>,
-        MortonCopy<true, PixelFormat::RG32UI>,
-        MortonCopy<true, PixelFormat::R32UI>,
-        MortonCopy<true, PixelFormat::Z32F>,
-        MortonCopy<true, PixelFormat::Z16>,
         MortonCopy<true, PixelFormat::Z24S8>,
         MortonCopy<true, PixelFormat::S8Z24>,
+        MortonCopy<true, PixelFormat::Z32F>,
+        MortonCopy<true, PixelFormat::Z16>,
         MortonCopy<true, PixelFormat::Z32FS8>,
         // clang-format on
 };
@@ -299,13 +289,12 @@ static constexpr std::array<void (*)(u32, u32, u32, std::vector<u8>&, Tegra::GPU
         // clang-format off
         MortonCopy<false, PixelFormat::ABGR8U>,
         MortonCopy<false, PixelFormat::ABGR8S>,
-        MortonCopy<false, PixelFormat::B5G6R5U>,
-        MortonCopy<false, PixelFormat::A2B10G10R10U>,
-        MortonCopy<false, PixelFormat::A1B5G5R5U>,
-        MortonCopy<false, PixelFormat::R8U>,
+        MortonCopy<false, PixelFormat::B5G6R5>,
+        MortonCopy<false, PixelFormat::A2B10G10R10>,
+        MortonCopy<false, PixelFormat::A1B5G5R5>,
+        MortonCopy<false, PixelFormat::R8>,
         MortonCopy<false, PixelFormat::R8UI>,
         MortonCopy<false, PixelFormat::RGBA16F>,
-        MortonCopy<false, PixelFormat::RGBA16U>,
         MortonCopy<false, PixelFormat::RGBA16UI>,
         MortonCopy<false, PixelFormat::R11FG11FB10F>,
         MortonCopy<false, PixelFormat::RGBA32UI>,
@@ -319,14 +308,13 @@ static constexpr std::array<void (*)(u32, u32, u32, std::vector<u8>&, Tegra::GPU
         nullptr,
         nullptr,
         nullptr,
-        MortonCopy<false, PixelFormat::G8R8U>,
-        MortonCopy<false, PixelFormat::G8R8S>,
+        MortonCopy<false, PixelFormat::G8R8>,
         MortonCopy<false, PixelFormat::BGRA8>,
         MortonCopy<false, PixelFormat::RGBA32F>,
         MortonCopy<false, PixelFormat::RG32F>,
         MortonCopy<false, PixelFormat::R32F>,
         MortonCopy<false, PixelFormat::R16F>,
-        MortonCopy<false, PixelFormat::R16U>,
+        MortonCopy<false, PixelFormat::R16UNORM>,
         MortonCopy<false, PixelFormat::R16S>,
         MortonCopy<false, PixelFormat::R16UI>,
         MortonCopy<false, PixelFormat::R16I>,
@@ -339,12 +327,10 @@ static constexpr std::array<void (*)(u32, u32, u32, std::vector<u8>&, Tegra::GPU
         MortonCopy<false, PixelFormat::SRGBA8>,
         MortonCopy<false, PixelFormat::RG8U>,
         MortonCopy<false, PixelFormat::RG8S>,
-        MortonCopy<false, PixelFormat::RG32UI>,
-        MortonCopy<false, PixelFormat::R32UI>,
-        MortonCopy<false, PixelFormat::Z32F>,
-        MortonCopy<false, PixelFormat::Z16>,
         MortonCopy<false, PixelFormat::Z24S8>,
         MortonCopy<false, PixelFormat::S8Z24>,
+        MortonCopy<false, PixelFormat::Z32F>,
+        MortonCopy<false, PixelFormat::Z16>,
         MortonCopy<false, PixelFormat::Z32FS8>,
         // clang-format on
 };
@@ -466,7 +452,7 @@ static void ConvertS8Z24ToZ24S8(std::vector<u8>& data, u32 width, u32 height) {
 }
 
 static void ConvertG8R8ToR8G8(std::vector<u8>& data, u32 width, u32 height) {
-    const auto bpp{CachedSurface::GetGLBytesPerPixel(PixelFormat::G8R8U)};
+    const auto bpp{CachedSurface::GetGLBytesPerPixel(PixelFormat::G8R8)};
     for (size_t y = 0; y < height; ++y) {
         for (size_t x = 0; x < width; ++x) {
             const size_t offset{bpp * (y * width + x)};
@@ -498,8 +484,7 @@ static void ConvertFormatAsNeeded_LoadGLBuffer(std::vector<u8>& data, PixelForma
         ConvertS8Z24ToZ24S8(data, width, height);
         break;
 
-    case PixelFormat::G8R8U:
-    case PixelFormat::G8R8S:
+    case PixelFormat::G8R8:
         // Convert the G8R8 color format to R8G8, as OpenGL does not support G8R8.
         ConvertG8R8ToR8G8(data, width, height);
         break;
@@ -790,6 +775,8 @@ Surface RasterizerCacheOpenGL::RecreateSurface(const Surface& surface,
     // Verify surface is compatible for blitting
     const auto& params{surface->GetSurfaceParams()};
     ASSERT(params.type == new_params.type);
+    ASSERT(params.pixel_format == new_params.pixel_format);
+    ASSERT(params.component_type == new_params.component_type);
 
     // Create a new surface with the new parameters, and blit the previous surface to it
     Surface new_surface{std::make_shared<CachedSurface>(new_params)};

src/video_core/renderer_opengl/gl_rasterizer_cache.h

@@ -25,59 +25,51 @@ struct SurfaceParams {
     enum class PixelFormat {
         ABGR8U = 0,
         ABGR8S = 1,
-        B5G6R5U = 2,
-        A2B10G10R10U = 3,
-        A1B5G5R5U = 4,
-        R8U = 5,
+        B5G6R5 = 2,
+        A2B10G10R10 = 3,
+        A1B5G5R5 = 4,
+        R8 = 5,
         R8UI = 6,
         RGBA16F = 7,
-        RGBA16U = 8,
-        RGBA16UI = 9,
-        R11FG11FB10F = 10,
-        RGBA32UI = 11,
-        DXT1 = 12,
-        DXT23 = 13,
-        DXT45 = 14,
-        DXN1 = 15, // This is also known as BC4
-        DXN2UNORM = 16,
-        DXN2SNORM = 17,
-        BC7U = 18,
-        ASTC_2D_4X4 = 19,
-        G8R8U = 20,
-        G8R8S = 21,
-        BGRA8 = 22,
-        RGBA32F = 23,
-        RG32F = 24,
-        R32F = 25,
-        R16F = 26,
-        R16U = 27,
-        R16S = 28,
-        R16UI = 29,
-        R16I = 30,
-        RG16 = 31,
-        RG16F = 32,
-        RG16UI = 33,
-        RG16I = 34,
-        RG16S = 35,
-        RGB32F = 36,
-        SRGBA8 = 37,
-        RG8U = 38,
-        RG8S = 39,
-        RG32UI = 40,
-        R32UI = 41,
+        RGBA16UI = 8,
+        R11FG11FB10F = 9,
+        RGBA32UI = 10,
+        DXT1 = 11,
+        DXT23 = 12,
+        DXT45 = 13,
+        DXN1 = 14, // This is also known as BC4
+        DXN2UNORM = 15,
+        DXN2SNORM = 16,
+        BC7U = 17,
+        ASTC_2D_4X4 = 18,
+        G8R8 = 19,
+        BGRA8 = 20,
+        RGBA32F = 21,
+        RG32F = 22,
+        R32F = 23,
+        R16F = 24,
+        R16UNORM = 25,
+        R16S = 26,
+        R16UI = 27,
+        R16I = 28,
+        RG16 = 29,
+        RG16F = 30,
+        RG16UI = 31,
+        RG16I = 32,
+        RG16S = 33,
+        RGB32F = 34,
+        SRGBA8 = 35,
+        RG8U = 36,
+        RG8S = 37,
 
         MaxColorFormat,
 
-        // Depth formats
-        Z32F = 42,
-        Z16 = 43,
-
-        MaxDepthFormat,
-
         // DepthStencil formats
-        Z24S8 = 44,
-        S8Z24 = 45,
-        Z32FS8 = 46,
+        Z24S8 = 38,
+        S8Z24 = 39,
+        Z32F = 40,
+        Z16 = 41,
+        Z32FS8 = 42,
 
         MaxDepthStencilFormat,
 
@@ -117,13 +109,12 @@ struct SurfaceParams {
         constexpr std::array<u32, MaxPixelFormat> compression_factor_table = {{
             1, // ABGR8U
             1, // ABGR8S
-            1, // B5G6R5U
-            1, // A2B10G10R10U
-            1, // A1B5G5R5U
-            1, // R8U
+            1, // B5G6R5
+            1, // A2B10G10R10
+            1, // A1B5G5R5
+            1, // R8
             1, // R8UI
             1, // RGBA16F
-            1, // RGBA16U
             1, // RGBA16UI
             1, // R11FG11FB10F
             1, // RGBA32UI
@@ -135,14 +126,13 @@ struct SurfaceParams {
             4, // DXN2SNORM
             4, // BC7U
             4, // ASTC_2D_4X4
-            1, // G8R8U
-            1, // G8R8S
+            1, // G8R8
             1, // BGRA8
             1, // RGBA32F
             1, // RG32F
             1, // R32F
             1, // R16F
-            1, // R16U
+            1, // R16UNORM
             1, // R16S
             1, // R16UI
             1, // R16I
@@ -155,12 +145,10 @@ struct SurfaceParams {
             1, // SRGBA8
             1, // RG8U
             1, // RG8S
-            1, // RG32UI
-            1, // R32UI
-            1, // Z32F
-            1, // Z16
             1, // Z24S8
             1, // S8Z24
+            1, // Z32F
+            1, // Z16
             1, // Z32FS8
         }};
 
@@ -175,13 +163,12 @@ struct SurfaceParams {
         constexpr std::array<u32, MaxPixelFormat> bpp_table = {{
             32,  // ABGR8U
             32,  // ABGR8S
-            16,  // B5G6R5U
-            32,  // A2B10G10R10U
-            16,  // A1B5G5R5U
-            8,   // R8U
+            16,  // B5G6R5
+            32,  // A2B10G10R10
+            16,  // A1B5G5R5
+            8,   // R8
             8,   // R8UI
             64,  // RGBA16F
-            64,  // RGBA16U
             64,  // RGBA16UI
             32,  // R11FG11FB10F
             128, // RGBA32UI
@@ -193,14 +180,13 @@ struct SurfaceParams {
             128, // DXN2SNORM
             128, // BC7U
             32,  // ASTC_2D_4X4
-            16,  // G8R8U
-            16,  // G8R8S
+            16,  // G8R8
             32,  // BGRA8
             128, // RGBA32F
             64,  // RG32F
             32,  // R32F
             16,  // R16F
-            16,  // R16U
+            16,  // R16UNORM
             16,  // R16S
             16,  // R16UI
             16,  // R16I
@@ -213,12 +199,10 @@ struct SurfaceParams {
             32,  // SRGBA8
             16,  // RG8U
             16,  // RG8S
-            64,  // RG32UI
-            32,  // R32UI
-            32,  // Z32F
-            16,  // Z16
             32,  // Z24S8
             32,  // S8Z24
+            32,  // Z32F
+            16,  // Z16
             64,  // Z32FS8
         }};
 
@@ -260,11 +244,9 @@ struct SurfaceParams {
         case Tegra::RenderTargetFormat::BGRA8_UNORM:
             return PixelFormat::BGRA8;
         case Tegra::RenderTargetFormat::RGB10_A2_UNORM:
-            return PixelFormat::A2B10G10R10U;
+            return PixelFormat::A2B10G10R10;
         case Tegra::RenderTargetFormat::RGBA16_FLOAT:
             return PixelFormat::RGBA16F;
-        case Tegra::RenderTargetFormat::RGBA16_UNORM:
-            return PixelFormat::RGBA16U;
         case Tegra::RenderTargetFormat::RGBA16_UINT:
             return PixelFormat::RGBA16UI;
         case Tegra::RenderTargetFormat::RGBA32_FLOAT:
@@ -274,11 +256,11 @@ struct SurfaceParams {
         case Tegra::RenderTargetFormat::R11G11B10_FLOAT:
             return PixelFormat::R11FG11FB10F;
         case Tegra::RenderTargetFormat::B5G6R5_UNORM:
-            return PixelFormat::B5G6R5U;
+            return PixelFormat::B5G6R5;
         case Tegra::RenderTargetFormat::RGBA32_UINT:
             return PixelFormat::RGBA32UI;
         case Tegra::RenderTargetFormat::R8_UNORM:
-            return PixelFormat::R8U;
+            return PixelFormat::R8;
         case Tegra::RenderTargetFormat::R8_UINT:
             return PixelFormat::R8UI;
         case Tegra::RenderTargetFormat::RG16_FLOAT:
@@ -298,7 +280,7 @@ struct SurfaceParams {
         case Tegra::RenderTargetFormat::R16_FLOAT:
             return PixelFormat::R16F;
         case Tegra::RenderTargetFormat::R16_UNORM:
-            return PixelFormat::R16U;
+            return PixelFormat::R16UNORM;
         case Tegra::RenderTargetFormat::R16_SNORM:
             return PixelFormat::R16S;
         case Tegra::RenderTargetFormat::R16_UINT:
@@ -307,10 +289,6 @@ struct SurfaceParams {
             return PixelFormat::R16I;
         case Tegra::RenderTargetFormat::R32_FLOAT:
             return PixelFormat::R32F;
-        case Tegra::RenderTargetFormat::R32_UINT:
-            return PixelFormat::R32UI;
-        case Tegra::RenderTargetFormat::RG32_UINT:
-            return PixelFormat::RG32UI;
         default:
             LOG_CRITICAL(HW_GPU, "Unimplemented format={}", static_cast<u32>(format));
             UNREACHABLE();
@@ -332,33 +310,15 @@ struct SurfaceParams {
                          static_cast<u32>(component_type));
             UNREACHABLE();
         case Tegra::Texture::TextureFormat::B5G6R5:
-            switch (component_type) {
-            case Tegra::Texture::ComponentType::UNORM:
-                return PixelFormat::B5G6R5U;
-            }
-            LOG_CRITICAL(HW_GPU, "Unimplemented component_type={}",
-                         static_cast<u32>(component_type));
-            UNREACHABLE();
+            return PixelFormat::B5G6R5;
         case Tegra::Texture::TextureFormat::A2B10G10R10:
-            switch (component_type) {
-            case Tegra::Texture::ComponentType::UNORM:
-                return PixelFormat::A2B10G10R10U;
-            }
-            LOG_CRITICAL(HW_GPU, "Unimplemented component_type={}",
-                         static_cast<u32>(component_type));
-            UNREACHABLE();
+            return PixelFormat::A2B10G10R10;
         case Tegra::Texture::TextureFormat::A1B5G5R5:
-            switch (component_type) {
-            case Tegra::Texture::ComponentType::UNORM:
-                return PixelFormat::A1B5G5R5U;
-            }
-            LOG_CRITICAL(HW_GPU, "Unimplemented component_type={}",
-                         static_cast<u32>(component_type));
-            UNREACHABLE();
+            return PixelFormat::A1B5G5R5;
         case Tegra::Texture::TextureFormat::R8:
             switch (component_type) {
             case Tegra::Texture::ComponentType::UNORM:
-                return PixelFormat::R8U;
+                return PixelFormat::R8;
             case Tegra::Texture::ComponentType::UINT:
                 return PixelFormat::R8UI;
             }
@@ -366,33 +326,11 @@ struct SurfaceParams {
                          static_cast<u32>(component_type));
             UNREACHABLE();
         case Tegra::Texture::TextureFormat::G8R8:
-            switch (component_type) {
-            case Tegra::Texture::ComponentType::UNORM:
-                return PixelFormat::G8R8U;
-            case Tegra::Texture::ComponentType::SNORM:
-                return PixelFormat::G8R8S;
-            }
-            LOG_CRITICAL(HW_GPU, "Unimplemented component_type={}",
-                         static_cast<u32>(component_type));
-            UNREACHABLE();
+            return PixelFormat::G8R8;
         case Tegra::Texture::TextureFormat::R16_G16_B16_A16:
-            switch (component_type) {
-            case Tegra::Texture::ComponentType::UNORM:
-                return PixelFormat::RGBA16U;
-            case Tegra::Texture::ComponentType::FLOAT:
-                return PixelFormat::RGBA16F;
-            }
-            LOG_CRITICAL(HW_GPU, "Unimplemented component_type={}",
-                         static_cast<u32>(component_type));
-            UNREACHABLE();
+            return PixelFormat::RGBA16F;
         case Tegra::Texture::TextureFormat::BF10GF11RF11:
-            switch (component_type) {
-            case Tegra::Texture::ComponentType::FLOAT:
-                return PixelFormat::R11FG11FB10F;
-            }
-            LOG_CRITICAL(HW_GPU, "Unimplemented component_type={}",
-                         static_cast<u32>(component_type));
-            UNREACHABLE();
+            return PixelFormat::R11FG11FB10F;
         case Tegra::Texture::TextureFormat::R32_G32_B32_A32:
             switch (component_type) {
             case Tegra::Texture::ComponentType::FLOAT:
@@ -404,29 +342,15 @@ struct SurfaceParams {
                          static_cast<u32>(component_type));
             UNREACHABLE();
         case Tegra::Texture::TextureFormat::R32_G32:
-            switch (component_type) {
-            case Tegra::Texture::ComponentType::FLOAT:
-                return PixelFormat::RG32F;
-            case Tegra::Texture::ComponentType::UINT:
-                return PixelFormat::RG32UI;
-            }
-            LOG_CRITICAL(HW_GPU, "Unimplemented component_type={}",
-                         static_cast<u32>(component_type));
-            UNREACHABLE();
+            return PixelFormat::RG32F;
         case Tegra::Texture::TextureFormat::R32_G32_B32:
-            switch (component_type) {
-            case Tegra::Texture::ComponentType::FLOAT:
-                return PixelFormat::RGB32F;
-            }
-            LOG_CRITICAL(HW_GPU, "Unimplemented component_type={}",
-                         static_cast<u32>(component_type));
-            UNREACHABLE();
+            return PixelFormat::RGB32F;
         case Tegra::Texture::TextureFormat::R16:
             switch (component_type) {
             case Tegra::Texture::ComponentType::FLOAT:
                 return PixelFormat::R16F;
             case Tegra::Texture::ComponentType::UNORM:
-                return PixelFormat::R16U;
+                return PixelFormat::R16UNORM;
             case Tegra::Texture::ComponentType::SNORM:
                 return PixelFormat::R16S;
             case Tegra::Texture::ComponentType::UINT:
@@ -438,19 +362,9 @@ struct SurfaceParams {
                          static_cast<u32>(component_type));
             UNREACHABLE();
         case Tegra::Texture::TextureFormat::R32:
-            switch (component_type) {
-            case Tegra::Texture::ComponentType::FLOAT:
-                return PixelFormat::R32F;
-            case Tegra::Texture::ComponentType::UINT:
-                return PixelFormat::R32UI;
-            }
-            LOG_CRITICAL(HW_GPU, "Unimplemented component_type={}",
-                         static_cast<u32>(component_type));
-            UNREACHABLE();
+            return PixelFormat::R32F;
         case Tegra::Texture::TextureFormat::ZF32:
             return PixelFormat::Z32F;
-        case Tegra::Texture::TextureFormat::Z16:
-            return PixelFormat::Z16;
         case Tegra::Texture::TextureFormat::Z24S8:
             return PixelFormat::Z24S8;
         case Tegra::Texture::TextureFormat::DXT1:
@@ -529,7 +443,6 @@ struct SurfaceParams {
         case Tegra::RenderTargetFormat::R16_UNORM:
         case Tegra::RenderTargetFormat::B5G6R5_UNORM:
         case Tegra::RenderTargetFormat::RG8_UNORM:
-        case Tegra::RenderTargetFormat::RGBA16_UNORM:
             return ComponentType::UNorm;
         case Tegra::RenderTargetFormat::RGBA8_SNORM:
         case Tegra::RenderTargetFormat::RG16_SNORM:
@@ -549,8 +462,6 @@ struct SurfaceParams {
         case Tegra::RenderTargetFormat::RG16_UINT:
         case Tegra::RenderTargetFormat::R8_UINT:
         case Tegra::RenderTargetFormat::R16_UINT:
-        case Tegra::RenderTargetFormat::RG32_UINT:
-        case Tegra::RenderTargetFormat::R32_UINT:
             return ComponentType::UInt;
         case Tegra::RenderTargetFormat::RG16_SINT:
         case Tegra::RenderTargetFormat::R16_SINT:
@@ -591,10 +502,6 @@ struct SurfaceParams {
             return SurfaceType::ColorTexture;
         }
 
-        if (static_cast<size_t>(pixel_format) < static_cast<size_t>(PixelFormat::MaxDepthFormat)) {
-            return SurfaceType::Depth;
-        }
-
         if (static_cast<size_t>(pixel_format) <
             static_cast<size_t>(PixelFormat::MaxDepthStencilFormat)) {
             return SurfaceType::DepthStencil;

src/video_core/renderer_opengl/gl_shader_decompiler.cpp

@@ -367,32 +367,31 @@ public:
     }
 
     /// Generates code representing a uniform (C buffer) register, interpreted as the input type.
-    std::string GetUniform(u64 index, u64 offset, GLSLRegister::Type type,
-                           Register::Size size = Register::Size::Word) {
+    std::string GetUniform(u64 index, u64 offset, GLSLRegister::Type type) {
         declr_const_buffers[index].MarkAsUsed(index, offset, stage);
         std::string value = 'c' + std::to_string(index) + '[' + std::to_string(offset / 4) + "][" +
                             std::to_string(offset % 4) + ']';
 
         if (type == GLSLRegister::Type::Float) {
-            // Do nothing, default
+            return value;
         } else if (type == GLSLRegister::Type::Integer) {
-            value = "floatBitsToInt(" + value + ')';
+            return "floatBitsToInt(" + value + ')';
         } else if (type == GLSLRegister::Type::UnsignedInteger) {
-            value = "floatBitsToUint(" + value + ')';
+            return "floatBitsToUint(" + value + ')';
         } else {
             UNREACHABLE();
         }
-
-        return ConvertIntegerSize(value, size);
     }
 
-    std::string GetUniformIndirect(u64 cbuf_index, s64 offset, const std::string& index_str,
+    std::string GetUniformIndirect(u64 index, s64 offset, const Register& index_reg,
                                    GLSLRegister::Type type) {
-        declr_const_buffers[cbuf_index].MarkAsUsedIndirect(cbuf_index, stage);
+        declr_const_buffers[index].MarkAsUsedIndirect(index, stage);
 
-        std::string final_offset = fmt::format("({} + {})", index_str, offset / 4);
-        std::string value = 'c' + std::to_string(cbuf_index) + '[' + final_offset + " / 4][" +
-                            final_offset + " % 4]";
+        std::string final_offset = "((floatBitsToInt(" + GetRegister(index_reg, 0) + ") + " +
+                                   std::to_string(offset) + ") / 4)";
+
+        std::string value =
+            'c' + std::to_string(index) + '[' + final_offset + " / 4][" + final_offset + " % 4]";
 
         if (type == GLSLRegister::Type::Float) {
             return value;
@@ -541,7 +540,7 @@ private:
             // vertex shader, and what's the value of the fourth element when inside a Tess Eval
             // shader.
             ASSERT(stage == Maxwell3D::Regs::ShaderStage::Vertex);
-            return "vec4(0, 0, uintBitsToFloat(instance_id.x), uintBitsToFloat(gl_VertexID))";
+            return "vec4(0, 0, uintBitsToFloat(gl_InstanceID), uintBitsToFloat(gl_VertexID))";
         default:
             const u32 index{static_cast<u32>(attribute) -
                             static_cast<u32>(Attribute::Index::Attribute_0)};
@@ -703,11 +702,10 @@ private:
                                        const std::string& op_a, const std::string& op_b) const {
         using Tegra::Shader::PredCondition;
         static const std::unordered_map<PredCondition, const char*> PredicateComparisonStrings = {
-            {PredCondition::LessThan, "<"},           {PredCondition::Equal, "=="},
-            {PredCondition::LessEqual, "<="},         {PredCondition::GreaterThan, ">"},
-            {PredCondition::NotEqual, "!="},          {PredCondition::GreaterEqual, ">="},
-            {PredCondition::LessThanWithNan, "<"},    {PredCondition::NotEqualWithNan, "!="},
-            {PredCondition::GreaterThanWithNan, ">"},
+            {PredCondition::LessThan, "<"},        {PredCondition::Equal, "=="},
+            {PredCondition::LessEqual, "<="},      {PredCondition::GreaterThan, ">"},
+            {PredCondition::NotEqual, "!="},       {PredCondition::GreaterEqual, ">="},
+            {PredCondition::LessThanWithNan, "<"}, {PredCondition::NotEqualWithNan, "!="},
         };
 
         const auto& comparison{PredicateComparisonStrings.find(condition)};
@@ -716,8 +714,7 @@ private:
 
         std::string predicate{'(' + op_a + ") " + comparison->second + " (" + op_b + ')'};
         if (condition == PredCondition::LessThanWithNan ||
-            condition == PredCondition::NotEqualWithNan ||
-            condition == PredCondition::GreaterThanWithNan) {
+            condition == PredCondition::NotEqualWithNan) {
             predicate += " || isnan(" + op_a + ") || isnan(" + op_b + ')';
         }
 
@@ -1252,41 +1249,20 @@ private:
                     op_a = "abs(" + op_a + ')';
                 }
 
-                if (instr.conversion.negate_a) {
-                    op_a = "-(" + op_a + ')';
-                }
-
                 regs.SetRegisterToInteger(instr.gpr0, instr.conversion.is_output_signed, 0, op_a, 1,
                                           1, instr.alu.saturate_d, 0, instr.conversion.dest_size);
                 break;
             }
-            case OpCode::Id::I2F_R:
-            case OpCode::Id::I2F_C: {
+            case OpCode::Id::I2F_R: {
                 ASSERT_MSG(instr.conversion.dest_size == Register::Size::Word, "Unimplemented");
                 ASSERT_MSG(!instr.conversion.selector, "Unimplemented");
-
-                std::string op_a{};
-
-                if (instr.is_b_gpr) {
-                    op_a =
-                        regs.GetRegisterAsInteger(instr.gpr20, 0, instr.conversion.is_input_signed,
-                                                  instr.conversion.src_size);
-                } else {
-                    op_a = regs.GetUniform(instr.cbuf34.index, instr.cbuf34.offset,
-                                           instr.conversion.is_input_signed
-                                               ? GLSLRegister::Type::Integer
-                                               : GLSLRegister::Type::UnsignedInteger,
-                                           instr.conversion.src_size);
-                }
+                std::string op_a = regs.GetRegisterAsInteger(
+                    instr.gpr20, 0, instr.conversion.is_input_signed, instr.conversion.src_size);
 
                 if (instr.conversion.abs_a) {
                     op_a = "abs(" + op_a + ')';
                 }
 
-                if (instr.conversion.negate_a) {
-                    op_a = "-(" + op_a + ')';
-                }
-
                 regs.SetRegisterToFloat(instr.gpr0, 0, op_a, 1, 1);
                 break;
             }
@@ -1295,14 +1271,6 @@ private:
                 ASSERT_MSG(instr.conversion.src_size == Register::Size::Word, "Unimplemented");
                 std::string op_a = regs.GetRegisterAsFloat(instr.gpr20);
 
-                if (instr.conversion.abs_a) {
-                    op_a = "abs(" + op_a + ')';
-                }
-
-                if (instr.conversion.negate_a) {
-                    op_a = "-(" + op_a + ')';
-                }
-
                 switch (instr.conversion.f2f.rounding) {
                 case Tegra::Shader::F2fRoundingOp::None:
                     break;
@@ -1325,27 +1293,19 @@ private:
                     break;
                 }
 
-                regs.SetRegisterToFloat(instr.gpr0, 0, op_a, 1, 1, instr.alu.saturate_d);
-                break;
-            }
-            case OpCode::Id::F2I_R:
-            case OpCode::Id::F2I_C: {
-                ASSERT_MSG(instr.conversion.src_size == Register::Size::Word, "Unimplemented");
-                std::string op_a{};
-
-                if (instr.is_b_gpr) {
-                    op_a = regs.GetRegisterAsFloat(instr.gpr20);
-                } else {
-                    op_a = regs.GetUniform(instr.cbuf34.index, instr.cbuf34.offset,
-                                           GLSLRegister::Type::Float);
-                }
-
                 if (instr.conversion.abs_a) {
                     op_a = "abs(" + op_a + ')';
                 }
 
-                if (instr.conversion.negate_a) {
-                    op_a = "-(" + op_a + ')';
+                regs.SetRegisterToFloat(instr.gpr0, 0, op_a, 1, 1, instr.alu.saturate_d);
+                break;
+            }
+            case OpCode::Id::F2I_R: {
+                ASSERT_MSG(instr.conversion.src_size == Register::Size::Word, "Unimplemented");
+                std::string op_a = regs.GetRegisterAsFloat(instr.gpr20);
+
+                if (instr.conversion.abs_a) {
+                    op_a = "abs(" + op_a + ')';
                 }
 
                 switch (instr.conversion.f2i.rounding) {
@@ -1395,16 +1355,11 @@ private:
             case OpCode::Id::LD_C: {
                 ASSERT_MSG(instr.ld_c.unknown == 0, "Unimplemented");
 
-                // Add an extra scope and declare the index register inside to prevent
-                // overwriting it in case it is used as an output of the LD instruction.
-                shader.AddLine("{");
-                ++shader.scope;
-
-                shader.AddLine("uint index = (" + regs.GetRegisterAsInteger(instr.gpr8, 0, false) +
-                               " / 4) & (MAX_CONSTBUFFER_ELEMENTS - 1);");
-
                 std::string op_a =
-                    regs.GetUniformIndirect(instr.cbuf36.index, instr.cbuf36.offset + 0, "index",
+                    regs.GetUniformIndirect(instr.cbuf36.index, instr.cbuf36.offset + 0, instr.gpr8,
+                                            GLSLRegister::Type::Float);
+                std::string op_b =
+                    regs.GetUniformIndirect(instr.cbuf36.index, instr.cbuf36.offset + 4, instr.gpr8,
                                             GLSLRegister::Type::Float);
 
                 switch (instr.ld_c.type.Value()) {
@@ -1412,22 +1367,16 @@ private:
                     regs.SetRegisterToFloat(instr.gpr0, 0, op_a, 1, 1);
                     break;
 
-                case Tegra::Shader::UniformType::Double: {
-                    std::string op_b =
-                        regs.GetUniformIndirect(instr.cbuf36.index, instr.cbuf36.offset + 4,
-                                                "index", GLSLRegister::Type::Float);
+                case Tegra::Shader::UniformType::Double:
                     regs.SetRegisterToFloat(instr.gpr0, 0, op_a, 1, 1);
                     regs.SetRegisterToFloat(instr.gpr0.Value() + 1, 0, op_b, 1, 1);
                     break;
-                }
+
                 default:
                     LOG_CRITICAL(HW_GPU, "Unhandled type: {}",
                                  static_cast<unsigned>(instr.ld_c.type.Value()));
                     UNREACHABLE();
                 }
-
-                --shader.scope;
-                shader.AddLine("}");
                 break;
             }
             case OpCode::Id::ST_A: {

src/video_core/renderer_opengl/gl_shader_gen.cpp

@@ -38,7 +38,6 @@ out vec4 position;
 
 layout (std140) uniform vs_config {
     vec4 viewport_flip;
-    uvec4 instance_id;
 };
 
 void main() {
@@ -91,7 +90,6 @@ out vec4 color;
 
 layout (std140) uniform fs_config {
     vec4 viewport_flip;
-    uvec4 instance_id;
 };
 
 void main() {

src/video_core/renderer_opengl/gl_shader_manager.cpp

@@ -37,16 +37,11 @@ void SetShaderUniformBlockBindings(GLuint shader) {
 } // namespace Impl
 
 void MaxwellUniformData::SetFromRegs(const Maxwell3D::State::ShaderStageInfo& shader_stage) {
-    const auto& gpu = Core::System::GetInstance().GPU().Maxwell3D();
-    const auto& regs = gpu.regs;
-    const auto& state = gpu.state;
+    const auto& regs = Core::System::GetInstance().GPU().Maxwell3D().regs;
 
     // TODO(bunnei): Support more than one viewport
     viewport_flip[0] = regs.viewport_transform[0].scale_x < 0.0 ? -1.0f : 1.0f;
     viewport_flip[1] = regs.viewport_transform[0].scale_y < 0.0 ? -1.0f : 1.0f;
-
-    // We only assign the instance to the first component of the vector, the rest is just padding.
-    instance_id[0] = state.current_instance;
 }
 
 } // namespace GLShader

src/video_core/renderer_opengl/gl_shader_manager.h

@@ -24,15 +24,14 @@ void SetShaderUniformBlockBindings(GLuint shader);
 } // namespace Impl
 
 /// Uniform structure for the Uniform Buffer Object, all vectors must be 16-byte aligned
-// NOTE: Always keep a vec4 at the end. The GL spec is not clear whether the alignment at
+// NOTE: Always keep a vec4 at the end. The GL spec is not clear wether the alignment at
 //       the end of a uniform block is included in UNIFORM_BLOCK_DATA_SIZE or not.
 //       Not following that rule will cause problems on some AMD drivers.
 struct MaxwellUniformData {
     void SetFromRegs(const Maxwell3D::State::ShaderStageInfo& shader_stage);
     alignas(16) GLvec4 viewport_flip;
-    alignas(16) GLuvec4 instance_id;
 };
-static_assert(sizeof(MaxwellUniformData) == 32, "MaxwellUniformData structure size is incorrect");
+static_assert(sizeof(MaxwellUniformData) == 16, "MaxwellUniformData structure size is incorrect");
 static_assert(sizeof(MaxwellUniformData) < 16384,
               "MaxwellUniformData structure must be less than 16kb as per the OpenGL spec");
 

src/video_core/renderer_opengl/maxwell_to_gl.h

@@ -24,25 +24,15 @@ using Maxwell = Tegra::Engines::Maxwell3D::Regs;
 
 inline GLenum VertexType(Maxwell::VertexAttribute attrib) {
     switch (attrib.type) {
-    case Maxwell::VertexAttribute::Type::UnsignedInt:
     case Maxwell::VertexAttribute::Type::UnsignedNorm: {
 
         switch (attrib.size) {
-        case Maxwell::VertexAttribute::Size::Size_8:
         case Maxwell::VertexAttribute::Size::Size_8_8:
-        case Maxwell::VertexAttribute::Size::Size_8_8_8:
         case Maxwell::VertexAttribute::Size::Size_8_8_8_8:
             return GL_UNSIGNED_BYTE;
-        case Maxwell::VertexAttribute::Size::Size_16:
         case Maxwell::VertexAttribute::Size::Size_16_16:
-        case Maxwell::VertexAttribute::Size::Size_16_16_16:
         case Maxwell::VertexAttribute::Size::Size_16_16_16_16:
             return GL_UNSIGNED_SHORT;
-        case Maxwell::VertexAttribute::Size::Size_32:
-        case Maxwell::VertexAttribute::Size::Size_32_32:
-        case Maxwell::VertexAttribute::Size::Size_32_32_32:
-        case Maxwell::VertexAttribute::Size::Size_32_32_32_32:
-            return GL_UNSIGNED_INT;
         case Maxwell::VertexAttribute::Size::Size_10_10_10_2:
             return GL_UNSIGNED_INT_2_10_10_10_REV;
         }
@@ -52,25 +42,16 @@ inline GLenum VertexType(Maxwell::VertexAttribute attrib) {
         return {};
     }
 
-    case Maxwell::VertexAttribute::Type::SignedInt:
     case Maxwell::VertexAttribute::Type::SignedNorm: {
 
         switch (attrib.size) {
-        case Maxwell::VertexAttribute::Size::Size_8:
+        case Maxwell::VertexAttribute::Size::Size_32_32_32:
+            return GL_INT;
         case Maxwell::VertexAttribute::Size::Size_8_8:
-        case Maxwell::VertexAttribute::Size::Size_8_8_8:
         case Maxwell::VertexAttribute::Size::Size_8_8_8_8:
             return GL_BYTE;
-        case Maxwell::VertexAttribute::Size::Size_16:
         case Maxwell::VertexAttribute::Size::Size_16_16:
-        case Maxwell::VertexAttribute::Size::Size_16_16_16:
-        case Maxwell::VertexAttribute::Size::Size_16_16_16_16:
             return GL_SHORT;
-        case Maxwell::VertexAttribute::Size::Size_32:
-        case Maxwell::VertexAttribute::Size::Size_32_32:
-        case Maxwell::VertexAttribute::Size::Size_32_32_32:
-        case Maxwell::VertexAttribute::Size::Size_32_32_32_32:
-            return GL_INT;
         case Maxwell::VertexAttribute::Size::Size_10_10_10_2:
             return GL_INT_2_10_10_10_REV;
         }
@@ -80,6 +61,9 @@ inline GLenum VertexType(Maxwell::VertexAttribute attrib) {
         return {};
     }
 
+    case Maxwell::VertexAttribute::Type::UnsignedInt:
+        return GL_UNSIGNED_INT;
+
     case Maxwell::VertexAttribute::Type::Float:
         return GL_FLOAT;
     }

src/video_core/renderer_opengl/renderer_opengl.cpp

@@ -425,7 +425,7 @@ static void APIENTRY DebugHandler(GLenum source, GLenum type, GLuint id, GLenum
 
     switch (severity) {
     case GL_DEBUG_SEVERITY_HIGH:
-        LOG_CRITICAL(Render_OpenGL, format, str_source, str_type, id, message);
+        LOG_ERROR(Render_OpenGL, format, str_source, str_type, id, message);
         break;
     case GL_DEBUG_SEVERITY_MEDIUM:
         LOG_WARNING(Render_OpenGL, format, str_source, str_type, id, message);

src/yuzu/game_list.cpp

@@ -2,7 +2,6 @@
 // Licensed under GPLv2 or any later version
 // Refer to the license.txt file included.
 
-#include <regex>
 #include <QApplication>
 #include <QDir>
 #include <QFileInfo>
@@ -403,72 +402,12 @@ void GameList::RefreshGameDirectory() {
     }
 }
 
-static void GetMetadataFromControlNCA(const std::shared_ptr<FileSys::NCA>& nca,
-                                      std::vector<u8>& icon, std::string& name) {
-    const auto control_dir = FileSys::ExtractRomFS(nca->GetRomFS());
-    if (control_dir == nullptr)
-        return;
+void GameListWorker::AddFstEntriesToGameList(const std::string& dir_path, unsigned int recursion) {
+    boost::container::flat_map<u64, std::shared_ptr<FileSys::NCA>> nca_control_map;
 
-    const auto nacp_file = control_dir->GetFile("control.nacp");
-    if (nacp_file == nullptr)
-        return;
-    FileSys::NACP nacp(nacp_file);
-    name = nacp.GetApplicationName();
-
-    FileSys::VirtualFile icon_file = nullptr;
-    for (const auto& language : FileSys::LANGUAGE_NAMES) {
-        icon_file = control_dir->GetFile("icon_" + std::string(language) + ".dat");
-        if (icon_file != nullptr) {
-            icon = icon_file->ReadAllBytes();
-            break;
-        }
-    }
-}
-
-void GameListWorker::AddInstalledTitlesToGameList() {
-    const auto usernand = Service::FileSystem::GetUserNANDContents();
-    const auto installed_games = usernand->ListEntriesFilter(FileSys::TitleType::Application,
-                                                             FileSys::ContentRecordType::Program);
-
-    for (const auto& game : installed_games) {
-        const auto& file = usernand->GetEntryRaw(game);
-        std::unique_ptr<Loader::AppLoader> loader = Loader::GetLoader(file);
-        if (!loader)
-            continue;
-
-        std::vector<u8> icon;
-        std::string name;
-        u64 program_id;
-        loader->ReadProgramId(program_id);
-
-        const auto& control =
-            usernand->GetEntry(game.title_id, FileSys::ContentRecordType::Control);
-        if (control != nullptr)
-            GetMetadataFromControlNCA(control, icon, name);
-        emit EntryReady({
-            new GameListItemPath(
-                FormatGameName(file->GetFullPath()), icon, QString::fromStdString(name),
-                QString::fromStdString(Loader::GetFileTypeString(loader->GetFileType())),
-                program_id),
-            new GameListItem(
-                QString::fromStdString(Loader::GetFileTypeString(loader->GetFileType()))),
-            new GameListItemSize(file->GetSize()),
-        });
-    }
-
-    const auto control_data = usernand->ListEntriesFilter(FileSys::TitleType::Application,
-                                                          FileSys::ContentRecordType::Control);
-
-    for (const auto& entry : control_data) {
-        const auto nca = usernand->GetEntry(entry);
-        if (nca != nullptr)
-            nca_control_map.insert_or_assign(entry.title_id, nca);
-    }
-}
-
-void GameListWorker::FillControlMap(const std::string& dir_path) {
-    const auto nca_control_callback = [this](u64* num_entries_out, const std::string& directory,
-                                             const std::string& virtual_name) -> bool {
+    const auto nca_control_callback =
+        [this, &nca_control_map](u64* num_entries_out, const std::string& directory,
+                                 const std::string& virtual_name) -> bool {
         std::string physical_name = directory + DIR_SEP + virtual_name;
 
         if (stop_processing)
@@ -486,11 +425,10 @@ void GameListWorker::FillControlMap(const std::string& dir_path) {
     };
 
     FileUtil::ForeachDirectoryEntry(nullptr, dir_path, nca_control_callback);
-}
 
-void GameListWorker::AddFstEntriesToGameList(const std::string& dir_path, unsigned int recursion) {
-    const auto callback = [this, recursion](u64* num_entries_out, const std::string& directory,
-                                            const std::string& virtual_name) -> bool {
+    const auto callback = [this, recursion,
+                           &nca_control_map](u64* num_entries_out, const std::string& directory,
+                                             const std::string& virtual_name) -> bool {
         std::string physical_name = directory + DIR_SEP + virtual_name;
 
         if (stop_processing)
@@ -520,7 +458,20 @@ void GameListWorker::AddFstEntriesToGameList(const std::string& dir_path, unsign
                 // Use from metadata pool.
                 if (nca_control_map.find(program_id) != nca_control_map.end()) {
                     const auto nca = nca_control_map[program_id];
-                    GetMetadataFromControlNCA(nca, icon, name);
+                    const auto control_dir = FileSys::ExtractRomFS(nca->GetRomFS());
+
+                    const auto nacp_file = control_dir->GetFile("control.nacp");
+                    FileSys::NACP nacp(nacp_file);
+                    name = nacp.GetApplicationName();
+
+                    FileSys::VirtualFile icon_file = nullptr;
+                    for (const auto& language : FileSys::LANGUAGE_NAMES) {
+                        icon_file = control_dir->GetFile("icon_" + std::string(language) + ".dat");
+                        if (icon_file != nullptr) {
+                            icon = icon_file->ReadAllBytes();
+                            break;
+                        }
+                    }
                 }
             }
 
@@ -547,10 +498,7 @@ void GameListWorker::AddFstEntriesToGameList(const std::string& dir_path, unsign
 void GameListWorker::run() {
     stop_processing = false;
     watch_list.append(dir_path);
-    FillControlMap(dir_path.toStdString());
-    AddInstalledTitlesToGameList();
     AddFstEntriesToGameList(dir_path.toStdString(), deep_scan ? 256 : 0);
-    nca_control_map.clear();
     emit Finished(watch_list);
 }
 

src/yuzu/game_list_p.h

@@ -163,13 +163,10 @@ signals:
 
 private:
     FileSys::VirtualFilesystem vfs;
-    std::map<u64, std::shared_ptr<FileSys::NCA>> nca_control_map;
     QStringList watch_list;
     QString dir_path;
     bool deep_scan;
     std::atomic_bool stop_processing;
 
-    void AddInstalledTitlesToGameList();
-    void FillControlMap(const std::string& dir_path);
     void AddFstEntriesToGameList(const std::string& dir_path, unsigned int recursion = 0);
 };

src/yuzu/main.cpp

@@ -6,10 +6,7 @@
 #include <clocale>
 #include <memory>
 #include <thread>
-
-#include <fmt/ostream.h>
 #include <glad/glad.h>
-
 #define QT_NO_OPENGL
 #include <QDesktopWidget>
 #include <QFileDialog>
@@ -27,7 +24,6 @@
 #include "common/string_util.h"
 #include "core/core.h"
 #include "core/crypto/key_manager.h"
-#include "core/file_sys/card_image.h"
 #include "core/file_sys/vfs_real.h"
 #include "core/gdbstub/gdbstub.h"
 #include "core/loader/loader.h"
@@ -118,9 +114,6 @@ GMainWindow::GMainWindow()
                        .arg(Common::g_build_name, Common::g_scm_branch, Common::g_scm_desc));
     show();
 
-    // Necessary to load titles from nand in gamelist.
-    Service::FileSystem::RegisterBIS(std::make_unique<FileSys::BISFactory>(vfs->OpenDirectory(
-        FileUtil::GetUserPath(FileUtil::UserPath::NANDDir), FileSys::Mode::ReadWrite)));
     game_list->PopulateAsync(UISettings::values.gamedir, UISettings::values.gamedir_deepscan);
 
     // Show one-time "callout" messages to the user
@@ -316,8 +309,6 @@ void GMainWindow::ConnectMenuEvents() {
     // File
     connect(ui.action_Load_File, &QAction::triggered, this, &GMainWindow::OnMenuLoadFile);
     connect(ui.action_Load_Folder, &QAction::triggered, this, &GMainWindow::OnMenuLoadFolder);
-    connect(ui.action_Install_File_NAND, &QAction::triggered, this,
-            &GMainWindow::OnMenuInstallToNAND);
     connect(ui.action_Select_Game_List_Root, &QAction::triggered, this,
             &GMainWindow::OnMenuSelectGameListRoot);
     connect(ui.action_Exit, &QAction::triggered, this, &QMainWindow::close);
@@ -463,7 +454,7 @@ bool GMainWindow::LoadROM(const QString& filename) {
                         "While attempting to load the ROM requested, an error occured. Please "
                         "refer to the yuzu wiki for more information or the yuzu discord for "
                         "additional help.\n\nError Code: {:04X}-{:04X}\nError Description: {}",
-                        loader_id, error_id, static_cast<Loader::ResultStatus>(error_id))));
+                        loader_id, error_id, Loader::GetMessageForResultStatus(error_id))));
             } else {
                 QMessageBox::critical(
                     this, tr("Error while loading ROM!"),
@@ -621,148 +612,6 @@ void GMainWindow::OnMenuLoadFolder() {
     }
 }
 
-void GMainWindow::OnMenuInstallToNAND() {
-    const QString file_filter =
-        tr("Installable Switch File (*.nca *.xci);;Nintendo Content Archive (*.nca);;NX Cartridge "
-           "Image (*.xci)");
-    QString filename = QFileDialog::getOpenFileName(this, tr("Install File"),
-                                                    UISettings::values.roms_path, file_filter);
-
-    if (filename.isEmpty()) {
-        return;
-    }
-
-    const auto qt_raw_copy = [this](FileSys::VirtualFile src, FileSys::VirtualFile dest) {
-        if (src == nullptr || dest == nullptr)
-            return false;
-        if (!dest->Resize(src->GetSize()))
-            return false;
-
-        std::array<u8, 0x1000> buffer{};
-        const int progress_maximum = static_cast<int>(src->GetSize() / buffer.size());
-
-        QProgressDialog progress(
-            tr("Installing file \"%1\"...").arg(QString::fromStdString(src->GetName())),
-            tr("Cancel"), 0, progress_maximum, this);
-        progress.setWindowModality(Qt::WindowModal);
-
-        for (size_t i = 0; i < src->GetSize(); i += buffer.size()) {
-            if (progress.wasCanceled()) {
-                dest->Resize(0);
-                return false;
-            }
-
-            const int progress_value = static_cast<int>(i / buffer.size());
-            progress.setValue(progress_value);
-
-            const auto read = src->Read(buffer.data(), buffer.size(), i);
-            dest->Write(buffer.data(), read, i);
-        }
-
-        return true;
-    };
-
-    const auto success = [this]() {
-        QMessageBox::information(this, tr("Successfully Installed"),
-                                 tr("The file was successfully installed."));
-        game_list->PopulateAsync(UISettings::values.gamedir, UISettings::values.gamedir_deepscan);
-    };
-
-    const auto failed = [this]() {
-        QMessageBox::warning(
-            this, tr("Failed to Install"),
-            tr("There was an error while attempting to install the provided file. It "
-               "could have an incorrect format or be missing metadata. Please "
-               "double-check your file and try again."));
-    };
-
-    const auto overwrite = [this]() {
-        return QMessageBox::question(this, tr("Failed to Install"),
-                                     tr("The file you are attempting to install already exists "
-                                        "in the cache. Would you like to overwrite it?")) ==
-               QMessageBox::Yes;
-    };
-
-    if (filename.endsWith("xci", Qt::CaseInsensitive)) {
-        const auto xci = std::make_shared<FileSys::XCI>(
-            vfs->OpenFile(filename.toStdString(), FileSys::Mode::Read));
-        if (xci->GetStatus() != Loader::ResultStatus::Success) {
-            failed();
-            return;
-        }
-        const auto res =
-            Service::FileSystem::GetUserNANDContents()->InstallEntry(xci, false, qt_raw_copy);
-        if (res == FileSys::InstallResult::Success) {
-            success();
-        } else {
-            if (res == FileSys::InstallResult::ErrorAlreadyExists) {
-                if (overwrite()) {
-                    const auto res2 = Service::FileSystem::GetUserNANDContents()->InstallEntry(
-                        xci, true, qt_raw_copy);
-                    if (res2 == FileSys::InstallResult::Success) {
-                        success();
-                    } else {
-                        failed();
-                    }
-                }
-            } else {
-                failed();
-            }
-        }
-    } else {
-        const auto nca = std::make_shared<FileSys::NCA>(
-            vfs->OpenFile(filename.toStdString(), FileSys::Mode::Read));
-        if (nca->GetStatus() != Loader::ResultStatus::Success) {
-            failed();
-            return;
-        }
-
-        const QStringList tt_options{tr("System Application"),
-                                     tr("System Archive"),
-                                     tr("System Application Update"),
-                                     tr("Firmware Package (Type A)"),
-                                     tr("Firmware Package (Type B)"),
-                                     tr("Game"),
-                                     tr("Game Update"),
-                                     tr("Game DLC"),
-                                     tr("Delta Title")};
-        bool ok;
-        const auto item = QInputDialog::getItem(
-            this, tr("Select NCA Install Type..."),
-            tr("Please select the type of title you would like to install this NCA as:\n(In "
-               "most instances, the default 'Game' is fine.)"),
-            tt_options, 5, false, &ok);
-
-        auto index = tt_options.indexOf(item);
-        if (!ok || index == -1) {
-            QMessageBox::warning(this, tr("Failed to Install"),
-                                 tr("The title type you selected for the NCA is invalid."));
-            return;
-        }
-
-        if (index >= 5)
-            index += 0x7B;
-
-        const auto res = Service::FileSystem::GetUserNANDContents()->InstallEntry(
-            nca, static_cast<FileSys::TitleType>(index), false, qt_raw_copy);
-        if (res == FileSys::InstallResult::Success) {
-            success();
-        } else if (res == FileSys::InstallResult::ErrorAlreadyExists) {
-            if (overwrite()) {
-                const auto res2 = Service::FileSystem::GetUserNANDContents()->InstallEntry(
-                    nca, static_cast<FileSys::TitleType>(index), true, qt_raw_copy);
-                if (res2 == FileSys::InstallResult::Success) {
-                    success();
-                } else {
-                    failed();
-                }
-            }
-        } else {
-            failed();
-        }
-    }
-}
-
 void GMainWindow::OnMenuSelectGameListRoot() {
     QString dir_path = QFileDialog::getExistingDirectory(this, tr("Select Directory"));
     if (!dir_path.isEmpty()) {

src/yuzu/main.h

@@ -125,7 +125,6 @@ private slots:
     void OnGameListOpenSaveFolder(u64 program_id);
     void OnMenuLoadFile();
     void OnMenuLoadFolder();
-    void OnMenuInstallToNAND();
     /// Called whenever a user selects the "File->Select Game List Root" menu item
     void OnMenuSelectGameListRoot();
     void OnMenuRecentFile();