acc: Stub GetUserCount.

CMakeLists.txt

@@ -1,5 +1,5 @@
-cmake_minimum_required(VERSION 3.7)
-
+# CMake 3.6 required for FindBoost to define IMPORTED libs properly on unknown Boost versions
+cmake_minimum_required(VERSION 3.6)
 list(APPEND CMAKE_MODULE_PATH "${CMAKE_CURRENT_SOURCE_DIR}/CMakeModules")
 list(APPEND CMAKE_MODULE_PATH "${CMAKE_CURRENT_SOURCE_DIR}/externals/cmake-modules")
 include(DownloadExternals)
@@ -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()
 
@@ -189,8 +187,8 @@ find_package(Threads REQUIRED)
 if (ENABLE_SDL2)
     if (YUZU_USE_BUNDLED_SDL2)
         # Detect toolchain and platform
-        if ((MSVC_VERSION GREATER_EQUAL 1910 AND MSVC_VERSION LESS 1920) AND ARCHITECTURE_x86_64)
-            set(SDL2_VER "SDL2-2.0.8")
+        if (MSVC14 AND ARCHITECTURE_x86_64)
+            set(SDL2_VER "SDL2-2.0.5")
         else()
             message(FATAL_ERROR "No bundled SDL2 binaries for your toolchain. Disable YUZU_USE_BUNDLED_SDL2 and provide your own.")
         endif()
@@ -222,7 +220,7 @@ if (YUZU_USE_BUNDLED_UNICORN)
     if (MSVC)
         message(STATUS "unicorn not found, falling back to bundled")
         # Detect toolchain and platform
-        if ((MSVC_VERSION GREATER_EQUAL 1910 AND MSVC_VERSION LESS 1920) AND ARCHITECTURE_x86_64)
+        if (MSVC14 AND ARCHITECTURE_x86_64)
             set(UNICORN_VER "unicorn-yuzu")
         else()
             message(FATAL_ERROR "No bundled Unicorn binaries for your toolchain. Disable YUZU_USE_BUNDLED_UNICORN and provide your own.")
@@ -281,7 +279,7 @@ endif()
 
 if (ENABLE_QT)
     if (YUZU_USE_BUNDLED_QT)
-        if ((MSVC_VERSION GREATER_EQUAL 1910 AND MSVC_VERSION LESS 1920) AND ARCHITECTURE_x86_64)
+        if (MSVC14 AND ARCHITECTURE_x86_64)
             set(QT_VER qt-5.10.0-msvc2015_64)
         else()
             message(FATAL_ERROR "No bundled Qt binaries for your toolchain. Disable YUZU_USE_BUNDLED_QT and provide your own.")
@@ -305,7 +303,7 @@ endif()
 # ======================================
 
 IF (APPLE)
-    find_library(COCOA_LIBRARY Cocoa)           # Umbrella framework for everything GUI-related
+    FIND_LIBRARY(COCOA_LIBRARY Cocoa)           # Umbrella framework for everything GUI-related
     set(PLATFORM_LIBRARIES ${COCOA_LIBRARY} ${IOKIT_LIBRARY} ${COREVIDEO_LIBRARY})
 
     if (CMAKE_CXX_COMPILER_ID STREQUAL Clang)

CMakeModules/CopyYuzuQt5Deps.cmake

@@ -4,10 +4,8 @@ function(copy_yuzu_Qt5_deps target_dir)
     set(Qt5_DLL_DIR "${Qt5_DIR}/../../../bin")
     set(Qt5_PLATFORMS_DIR "${Qt5_DIR}/../../../plugins/platforms/")
     set(Qt5_STYLES_DIR "${Qt5_DIR}/../../../plugins/styles/")
-    set(Qt5_IMAGEFORMATS_DIR "${Qt5_DIR}/../../../plugins/imageformats/")
     set(PLATFORMS ${DLL_DEST}platforms/)
     set(STYLES ${DLL_DEST}styles/)
-    set(IMAGEFORMATS ${DLL_DEST}imageformats/)
     windows_copy_files(${target_dir} ${Qt5_DLL_DIR} ${DLL_DEST}
         icudt*.dll
         icuin*.dll
@@ -19,5 +17,4 @@ function(copy_yuzu_Qt5_deps target_dir)
     )
     windows_copy_files(yuzu ${Qt5_PLATFORMS_DIR} ${PLATFORMS} qwindows$<$<CONFIG:Debug>:d>.*)
     windows_copy_files(yuzu ${Qt5_STYLES_DIR} ${STYLES} qwindowsvistastyle$<$<CONFIG:Debug>:d>.*)
-    windows_copy_files(yuzu ${Qt5_IMAGEFORMATS_DIR} ${IMAGEFORMATS} qjpeg$<$<CONFIG:Debug>:d>.*)
 endfunction(copy_yuzu_Qt5_deps)

appveyor.yml

@@ -117,7 +117,6 @@ after_build:
           mkdir $RELEASE_DIST
           mkdir $RELEASE_DIST/platforms
           mkdir $RELEASE_DIST/styles
-          mkdir $RELEASE_DIST/imageformats
 
           # copy the compiled binaries and other release files to the release folder
           Get-ChildItem "$CMAKE_BINARY_DIR" -Filter "yuzu*.exe" | Copy-Item -destination $RELEASE_DIST
@@ -141,9 +140,6 @@ after_build:
           # copy the qt windows vista style dll to platforms
           Copy-Item -path "C:/msys64/mingw64/share/qt5/plugins/styles/qwindowsvistastyle.dll" -force -destination "$RELEASE_DIST/styles"
 
-          # copy the qt jpeg imageformat dll to platforms
-          Copy-Item -path "C:/msys64/mingw64/share/qt5/plugins/imageformats/qjpeg.dll" -force -destination "$RELEASE_DIST/imageformats"
-
           7z a -tzip $MINGW_BUILD_ZIP $RELEASE_DIST\*
           7z a $MINGW_SEVENZIP $RELEASE_DIST
         }

externals/CMakeLists.txt

@@ -32,7 +32,7 @@ add_subdirectory(inih)
 
 # lz4
 set(LZ4_BUNDLED_MODE ON)
-add_subdirectory(lz4/contrib/cmake_unofficial EXCLUDE_FROM_ALL)
+add_subdirectory(lz4/contrib/cmake_unofficial)
 target_include_directories(lz4_static INTERFACE ./lz4/lib)
 
 # mbedtls

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"
@@ -27,18 +26,6 @@ AudioRenderer::AudioRenderer(AudioRendererParameter params,
     QueueMixedBuffer(2);
 }
 
-u32 AudioRenderer::GetSampleRate() const {
-    return worker_params.sample_rate;
-}
-
-u32 AudioRenderer::GetSampleCount() const {
-    return worker_params.sample_count;
-}
-
-u32 AudioRenderer::GetMixBufferCount() const {
-    return worker_params.mix_buffer_count;
-}
-
 std::vector<u8> AudioRenderer::UpdateAudioRenderer(const std::vector<u8>& input_params) {
     // Copy UpdateDataHeader struct
     UpdateDataHeader config{};
@@ -200,8 +187,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 +212,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"
@@ -27,7 +26,7 @@ enum class PlayState : u8 {
 struct AudioRendererParameter {
     u32_le sample_rate;
     u32_le sample_count;
-    u32_le mix_buffer_count;
+    u32_le unknown_8;
     u32_le unknown_c;
     u32_le voice_count;
     u32_le sink_count;
@@ -161,9 +160,6 @@ public:
     std::vector<u8> UpdateAudioRenderer(const std::vector<u8>& input_params);
     void QueueMixedBuffer(Buffer::Tag tag);
     void ReleaseAndQueueBuffers();
-    u32 GetSampleRate() const;
-    u32 GetSampleCount() const;
-    u32 GetMixBufferCount() const;
 
 private:
     class VoiceState {
@@ -195,7 +191,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/audio_core/cubeb_sink.cpp

@@ -4,7 +4,6 @@
 
 #include <algorithm>
 #include <cstring>
-#include <mutex>
 
 #include "audio_core/cubeb_sink.h"
 #include "audio_core/stream.h"
@@ -67,8 +66,6 @@ public:
             return;
         }
 
-        std::lock_guard lock{queue_mutex};
-
         queue.reserve(queue.size() + samples.size() * GetNumChannels());
 
         if (is_6_channel) {
@@ -97,7 +94,6 @@ private:
     u32 num_channels{};
     bool is_6_channel{};
 
-    std::mutex queue_mutex;
     std::vector<s16> queue;
 
     static long DataCallback(cubeb_stream* stream, void* user_data, const void* input_buffer,
@@ -157,8 +153,6 @@ long SinkStreamImpl::DataCallback(cubeb_stream* stream, void* user_data, const v
         return {};
     }
 
-    std::lock_guard lock{impl->queue_mutex};
-
     const size_t frames_to_write{
         std::min(impl->queue.size() / impl->GetNumChannels(), static_cast<size_t>(num_frames))};
 

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/alignment.h

@@ -9,13 +9,13 @@ namespace Common {
 
 template <typename T>
 constexpr T AlignUp(T value, size_t size) {
-    static_assert(std::is_unsigned_v<T>, "T must be an unsigned value.");
+    static_assert(std::is_unsigned<T>::value, "T must be an unsigned value.");
     return static_cast<T>(value + (size - value % size) % size);
 }
 
 template <typename T>
 constexpr T AlignDown(T value, size_t size) {
-    static_assert(std::is_unsigned_v<T>, "T must be an unsigned value.");
+    static_assert(std::is_unsigned<T>::value, "T must be an unsigned value.");
     return static_cast<T>(value - value % size);
 }
 

src/common/bit_set.h

@@ -96,7 +96,7 @@ static inline int LeastSignificantSetBit(u64 val) {
 
 template <typename IntTy>
 class BitSet {
-    static_assert(!std::is_signed_v<IntTy>, "BitSet should not be used with signed types");
+    static_assert(!std::is_signed<IntTy>::value, "BitSet should not be used with signed types");
 
 public:
     // A reference to a particular bit, returned from operator[].

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/color.h

@@ -4,8 +4,6 @@
 
 #pragma once
 
-#include <cstring>
-
 #include "common/common_types.h"
 #include "common/swap.h"
 #include "common/vector_math.h"
@@ -57,7 +55,7 @@ constexpr u8 Convert8To6(u8 value) {
  * @param bytes Pointer to encoded source color
  * @return Result color decoded as Math::Vec4<u8>
  */
-inline Math::Vec4<u8> DecodeRGBA8(const u8* bytes) {
+inline const Math::Vec4<u8> DecodeRGBA8(const u8* bytes) {
     return {bytes[3], bytes[2], bytes[1], bytes[0]};
 }
 
@@ -66,7 +64,7 @@ inline Math::Vec4<u8> DecodeRGBA8(const u8* bytes) {
  * @param bytes Pointer to encoded source color
  * @return Result color decoded as Math::Vec4<u8>
  */
-inline Math::Vec4<u8> DecodeRGB8(const u8* bytes) {
+inline const Math::Vec4<u8> DecodeRGB8(const u8* bytes) {
     return {bytes[2], bytes[1], bytes[0], 255};
 }
 
@@ -75,7 +73,7 @@ inline Math::Vec4<u8> DecodeRGB8(const u8* bytes) {
  * @param bytes Pointer to encoded source color
  * @return Result color decoded as Math::Vec4<u8>
  */
-inline Math::Vec4<u8> DecodeRG8(const u8* bytes) {
+inline const Math::Vec4<u8> DecodeRG8(const u8* bytes) {
     return {bytes[1], bytes[0], 0, 255};
 }
 
@@ -84,9 +82,8 @@ inline Math::Vec4<u8> DecodeRG8(const u8* bytes) {
  * @param bytes Pointer to encoded source color
  * @return Result color decoded as Math::Vec4<u8>
  */
-inline Math::Vec4<u8> DecodeRGB565(const u8* bytes) {
-    u16_le pixel;
-    std::memcpy(&pixel, bytes, sizeof(pixel));
+inline const Math::Vec4<u8> DecodeRGB565(const u8* bytes) {
+    const u16_le pixel = *reinterpret_cast<const u16_le*>(bytes);
     return {Convert5To8((pixel >> 11) & 0x1F), Convert6To8((pixel >> 5) & 0x3F),
             Convert5To8(pixel & 0x1F), 255};
 }
@@ -96,9 +93,8 @@ inline Math::Vec4<u8> DecodeRGB565(const u8* bytes) {
  * @param bytes Pointer to encoded source color
  * @return Result color decoded as Math::Vec4<u8>
  */
-inline Math::Vec4<u8> DecodeRGB5A1(const u8* bytes) {
-    u16_le pixel;
-    std::memcpy(&pixel, bytes, sizeof(pixel));
+inline const Math::Vec4<u8> DecodeRGB5A1(const u8* bytes) {
+    const u16_le pixel = *reinterpret_cast<const u16_le*>(bytes);
     return {Convert5To8((pixel >> 11) & 0x1F), Convert5To8((pixel >> 6) & 0x1F),
             Convert5To8((pixel >> 1) & 0x1F), Convert1To8(pixel & 0x1)};
 }
@@ -108,9 +104,8 @@ inline Math::Vec4<u8> DecodeRGB5A1(const u8* bytes) {
  * @param bytes Pointer to encoded source color
  * @return Result color decoded as Math::Vec4<u8>
  */
-inline Math::Vec4<u8> DecodeRGBA4(const u8* bytes) {
-    u16_le pixel;
-    std::memcpy(&pixel, bytes, sizeof(pixel));
+inline const Math::Vec4<u8> DecodeRGBA4(const u8* bytes) {
+    const u16_le pixel = *reinterpret_cast<const u16_le*>(bytes);
     return {Convert4To8((pixel >> 12) & 0xF), Convert4To8((pixel >> 8) & 0xF),
             Convert4To8((pixel >> 4) & 0xF), Convert4To8(pixel & 0xF)};
 }
@@ -121,9 +116,7 @@ inline Math::Vec4<u8> DecodeRGBA4(const u8* bytes) {
  * @return Depth value as an u32
  */
 inline u32 DecodeD16(const u8* bytes) {
-    u16_le data;
-    std::memcpy(&data, bytes, sizeof(data));
-    return data;
+    return *reinterpret_cast<const u16_le*>(bytes);
 }
 
 /**
@@ -140,7 +133,7 @@ inline u32 DecodeD24(const u8* bytes) {
  * @param bytes Pointer to encoded source values
  * @return Resulting values stored as a Math::Vec2
  */
-inline Math::Vec2<u32> DecodeD24S8(const u8* bytes) {
+inline const Math::Vec2<u32> DecodeD24S8(const u8* bytes) {
     return {static_cast<u32>((bytes[2] << 16) | (bytes[1] << 8) | bytes[0]), bytes[3]};
 }
 
@@ -182,10 +175,8 @@ inline void EncodeRG8(const Math::Vec4<u8>& color, u8* bytes) {
  * @param bytes Destination pointer to store encoded color
  */
 inline void EncodeRGB565(const Math::Vec4<u8>& color, u8* bytes) {
-    const u16_le data =
+    *reinterpret_cast<u16_le*>(bytes) =
         (Convert8To5(color.r()) << 11) | (Convert8To6(color.g()) << 5) | Convert8To5(color.b());
-
-    std::memcpy(bytes, &data, sizeof(data));
 }
 
 /**
@@ -194,10 +185,9 @@ inline void EncodeRGB565(const Math::Vec4<u8>& color, u8* bytes) {
  * @param bytes Destination pointer to store encoded color
  */
 inline void EncodeRGB5A1(const Math::Vec4<u8>& color, u8* bytes) {
-    const u16_le data = (Convert8To5(color.r()) << 11) | (Convert8To5(color.g()) << 6) |
-                        (Convert8To5(color.b()) << 1) | Convert8To1(color.a());
-
-    std::memcpy(bytes, &data, sizeof(data));
+    *reinterpret_cast<u16_le*>(bytes) = (Convert8To5(color.r()) << 11) |
+                                        (Convert8To5(color.g()) << 6) |
+                                        (Convert8To5(color.b()) << 1) | Convert8To1(color.a());
 }
 
 /**
@@ -206,10 +196,9 @@ inline void EncodeRGB5A1(const Math::Vec4<u8>& color, u8* bytes) {
  * @param bytes Destination pointer to store encoded color
  */
 inline void EncodeRGBA4(const Math::Vec4<u8>& color, u8* bytes) {
-    const u16 data = (Convert8To4(color.r()) << 12) | (Convert8To4(color.g()) << 8) |
-                     (Convert8To4(color.b()) << 4) | Convert8To4(color.a());
-
-    std::memcpy(bytes, &data, sizeof(data));
+    *reinterpret_cast<u16_le*>(bytes) = (Convert8To4(color.r()) << 12) |
+                                        (Convert8To4(color.g()) << 8) |
+                                        (Convert8To4(color.b()) << 4) | Convert8To4(color.a());
 }
 
 /**
@@ -218,8 +207,7 @@ inline void EncodeRGBA4(const Math::Vec4<u8>& color, u8* bytes) {
  * @param bytes Pointer where to store the encoded value
  */
 inline void EncodeD16(u32 value, u8* bytes) {
-    const u16_le data = static_cast<u16>(value);
-    std::memcpy(bytes, &data, sizeof(data));
+    *reinterpret_cast<u16_le*>(bytes) = value & 0xFFFF;
 }
 
 /**

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());
 }
@@ -890,21 +884,11 @@ std::string_view RemoveTrailingSlash(std::string_view path) {
     return path;
 }
 
-std::string SanitizePath(std::string_view path_, DirectorySeparator directory_separator) {
+std::string SanitizePath(std::string_view path_) {
     std::string path(path_);
-    char type1 = directory_separator == DirectorySeparator::BackwardSlash ? '/' : '\\';
-    char type2 = directory_separator == DirectorySeparator::BackwardSlash ? '\\' : '/';
-
-    if (directory_separator == DirectorySeparator::PlatformDefault) {
-#ifdef _WIN32
-        type1 = '/';
-        type2 = '\\';
-#endif
-    }
-
-    std::replace(path.begin(), path.end(), type1, type2);
+    std::replace(path.begin(), path.end(), '\\', '/');
     path.erase(std::unique(path.begin(), path.end(),
-                           [type2](char c1, char c2) { return c1 == type2 && c2 == type2; }),
+                           [](char c1, char c2) { return c1 == '/' && c2 == '/'; }),
                path.end());
     return std::string(RemoveTrailingSlash(path));
 }

src/common/file_util.h

@@ -8,7 +8,6 @@
 #include <cstdio>
 #include <fstream>
 #include <functional>
-#include <limits>
 #include <string>
 #include <string_view>
 #include <type_traits>
@@ -129,8 +128,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();
 
@@ -184,12 +181,8 @@ std::vector<T> SliceVector(const std::vector<T>& vector, size_t first, size_t la
     return std::vector<T>(vector.begin() + first, vector.begin() + first + last);
 }
 
-enum class DirectorySeparator { ForwardSlash, BackwardSlash, PlatformDefault };
-
-// Removes trailing slash, makes all '\\' into '/', and removes duplicate '/'. Makes '/' into '\\'
-// depending if directory_separator is BackwardSlash or PlatformDefault and running on windows
-std::string SanitizePath(std::string_view path,
-                         DirectorySeparator directory_separator = DirectorySeparator::ForwardSlash);
+// Removes trailing slash, makes all '\\' into '/', and removes duplicate '/'.
+std::string SanitizePath(std::string_view path);
 
 // simple wrapper for cstdlib file functions to
 // hopefully will make error checking easier
@@ -214,42 +207,39 @@ public:
 
     template <typename T>
     size_t ReadArray(T* data, size_t length) const {
-        static_assert(std::is_trivially_copyable_v<T>,
+        static_assert(std::is_trivially_copyable<T>(),
                       "Given array does not consist of trivially copyable objects");
 
-        if (!IsOpen()) {
-            return std::numeric_limits<size_t>::max();
-        }
+        if (!IsOpen())
+            return -1;
 
         return std::fread(data, sizeof(T), length, m_file);
     }
 
     template <typename T>
     size_t WriteArray(const T* data, size_t length) {
-        static_assert(std::is_trivially_copyable_v<T>,
+        static_assert(std::is_trivially_copyable<T>(),
                       "Given array does not consist of trivially copyable objects");
-        if (!IsOpen()) {
-            return std::numeric_limits<size_t>::max();
-        }
-
+        if (!IsOpen())
+            return -1;
         return std::fwrite(data, sizeof(T), length, m_file);
     }
 
     template <typename T>
     size_t ReadBytes(T* data, size_t length) const {
-        static_assert(std::is_trivially_copyable_v<T>, "T must be trivially copyable");
+        static_assert(std::is_trivially_copyable<T>(), "T must be trivially copyable");
         return ReadArray(reinterpret_cast<char*>(data), length);
     }
 
     template <typename T>
     size_t WriteBytes(const T* data, size_t length) {
-        static_assert(std::is_trivially_copyable_v<T>, "T must be trivially copyable");
+        static_assert(std::is_trivially_copyable<T>(), "T must be trivially copyable");
         return WriteArray(reinterpret_cast<const char*>(data), length);
     }
 
     template <typename T>
     size_t WriteObject(const T& object) {
-        static_assert(!std::is_pointer_v<T>, "WriteObject arguments must not be a pointer");
+        static_assert(!std::is_pointer<T>::value, "Given object is a pointer");
         return WriteArray(&object, 1);
     }
 

src/common/hash.h

@@ -28,7 +28,7 @@ static inline u64 ComputeHash64(const void* data, size_t len) {
  */
 template <typename T>
 static inline u64 ComputeStructHash64(const T& data) {
-    static_assert(std::is_trivially_copyable_v<T>,
+    static_assert(std::is_trivially_copyable<T>(),
                   "Type passed to ComputeStructHash64 must be trivially copyable");
     return ComputeHash64(&data, sizeof(data));
 }
@@ -38,7 +38,7 @@ template <typename T>
 struct HashableStruct {
     // In addition to being trivially copyable, T must also have a trivial default constructor,
     // because any member initialization would be overridden by memset
-    static_assert(std::is_trivial_v<T>, "Type passed to HashableStruct must be trivial");
+    static_assert(std::is_trivial<T>(), "Type passed to HashableStruct must be trivial");
     /*
      * We use a union because "implicitly-defined copy/move constructor for a union X copies the
      * object representation of X." and "implicitly-defined copy assignment operator for a union X

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

@@ -171,21 +171,15 @@ void FileBackend::Write(const Entry& entry) {
     SUB(Service, ARP)                                                                              \
     SUB(Service, BCAT)                                                                             \
     SUB(Service, BPC)                                                                              \
-    SUB(Service, BTDRV)                                                                            \
     SUB(Service, BTM)                                                                              \
     SUB(Service, Capture)                                                                          \
-    SUB(Service, ERPT)                                                                             \
-    SUB(Service, ETicket)                                                                          \
-    SUB(Service, EUPLD)                                                                            \
     SUB(Service, Fatal)                                                                            \
     SUB(Service, FGM)                                                                              \
     SUB(Service, Friend)                                                                           \
     SUB(Service, FS)                                                                               \
-    SUB(Service, GRC)                                                                              \
     SUB(Service, HID)                                                                              \
     SUB(Service, LBL)                                                                              \
     SUB(Service, LDN)                                                                              \
-    SUB(Service, LDR)                                                                              \
     SUB(Service, LM)                                                                               \
     SUB(Service, Migration)                                                                        \
     SUB(Service, Mii)                                                                              \
@@ -194,13 +188,11 @@ void FileBackend::Write(const Entry& entry) {
     SUB(Service, NFC)                                                                              \
     SUB(Service, NFP)                                                                              \
     SUB(Service, NIFM)                                                                             \
-    SUB(Service, NIM)                                                                              \
     SUB(Service, NS)                                                                               \
     SUB(Service, NVDRV)                                                                            \
     SUB(Service, PCIE)                                                                             \
     SUB(Service, PCTL)                                                                             \
     SUB(Service, PCV)                                                                              \
-    SUB(Service, PM)                                                                               \
     SUB(Service, PREPO)                                                                            \
     SUB(Service, PSC)                                                                              \
     SUB(Service, SET)                                                                              \
@@ -302,14 +294,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/logging/log.h

@@ -58,21 +58,15 @@ enum class Class : ClassType {
     Service_Audio,     ///< The Audio (Audio control) service
     Service_BCAT,      ///< The BCAT service
     Service_BPC,       ///< The BPC service
-    Service_BTDRV,     ///< The Bluetooth driver service
     Service_BTM,       ///< The BTM service
     Service_Capture,   ///< The capture service
-    Service_ERPT,      ///< The error reporting service
-    Service_ETicket,   ///< The ETicket service
-    Service_EUPLD,     ///< The error upload service
     Service_Fatal,     ///< The Fatal service
     Service_FGM,       ///< The FGM service
     Service_Friend,    ///< The friend service
     Service_FS,        ///< The FS (Filesystem) service
-    Service_GRC,       ///< The game recording service
     Service_HID,       ///< The HID (Human interface device) service
     Service_LBL,       ///< The LBL (LCD backlight) service
     Service_LDN,       ///< The LDN (Local domain network) service
-    Service_LDR,       ///< The loader service
     Service_LM,        ///< The LM (Logger) service
     Service_Migration, ///< The migration service
     Service_Mii,       ///< The Mii service
@@ -81,13 +75,11 @@ enum class Class : ClassType {
     Service_NFC,       ///< The NFC (Near-field communication) service
     Service_NFP,       ///< The NFP service
     Service_NIFM,      ///< The NIFM (Network interface) service
-    Service_NIM,       ///< The NIM service
     Service_NS,        ///< The NS services
     Service_NVDRV,     ///< The NVDRV (Nvidia driver) service
     Service_PCIE,      ///< The PCIe service
     Service_PCTL,      ///< The PCTL (Parental control) service
     Service_PCV,       ///< The PCV service
-    Service_PM,        ///< The PM service
     Service_PREPO,     ///< The PREPO (Play report) service
     Service_PSC,       ///< The PSC service
     Service_SET,       ///< The SET (Settings) service

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/thread_queue_list.h

@@ -16,7 +16,7 @@ struct ThreadQueueList {
     //               (dynamically resizable) circular buffers to remove their overhead when
     //               inserting and popping.
 
-    using Priority = unsigned int;
+    typedef unsigned int Priority;
 
     // Number of priority levels. (Valid levels are [0..NUM_QUEUES).)
     static const Priority NUM_QUEUES = N;
@@ -26,9 +26,9 @@ struct ThreadQueueList {
     }
 
     // Only for debugging, returns priority level.
-    Priority contains(const T& uid) const {
+    Priority contains(const T& uid) {
         for (Priority i = 0; i < NUM_QUEUES; ++i) {
-            const Queue& cur = queues[i];
+            Queue& cur = queues[i];
             if (std::find(cur.data.cbegin(), cur.data.cend(), uid) != cur.data.cend()) {
                 return i;
             }
@@ -37,8 +37,8 @@ struct ThreadQueueList {
         return -1;
     }
 
-    T get_first() const {
-        const Queue* cur = first;
+    T get_first() {
+        Queue* cur = first;
         while (cur != nullptr) {
             if (!cur->data.empty()) {
                 return cur->data.front();

src/common/vector_math.h

@@ -42,136 +42,140 @@ class Vec3;
 template <typename T>
 class Vec4;
 
+template <typename T>
+static inline Vec2<T> MakeVec(const T& x, const T& y);
+template <typename T>
+static inline Vec3<T> MakeVec(const T& x, const T& y, const T& z);
+template <typename T>
+static inline Vec4<T> MakeVec(const T& x, const T& y, const T& z, const T& w);
+
 template <typename T>
 class Vec2 {
 public:
     T x{};
     T y{};
 
-    constexpr Vec2() = default;
-    constexpr Vec2(const T& x_, const T& y_) : x(x_), y(y_) {}
+    Vec2() = default;
+    Vec2(const T& _x, const T& _y) : x(_x), y(_y) {}
 
     template <typename T2>
-    constexpr Vec2<T2> Cast() const {
-        return Vec2<T2>(static_cast<T2>(x), static_cast<T2>(y));
+    Vec2<T2> Cast() const {
+        return Vec2<T2>((T2)x, (T2)y);
     }
 
-    static constexpr Vec2 AssignToAll(const T& f) {
-        return Vec2{f, f};
+    static Vec2 AssignToAll(const T& f) {
+        return Vec2<T>(f, f);
     }
 
-    constexpr Vec2<decltype(T{} + T{})> operator+(const Vec2& other) const {
-        return {x + other.x, y + other.y};
+    Vec2<decltype(T{} + T{})> operator+(const Vec2& other) const {
+        return MakeVec(x + other.x, y + other.y);
     }
-    constexpr Vec2& operator+=(const Vec2& other) {
+    void operator+=(const Vec2& other) {
         x += other.x;
         y += other.y;
-        return *this;
     }
-    constexpr Vec2<decltype(T{} - T{})> operator-(const Vec2& other) const {
-        return {x - other.x, y - other.y};
+    Vec2<decltype(T{} - T{})> operator-(const Vec2& other) const {
+        return MakeVec(x - other.x, y - other.y);
     }
-    constexpr Vec2& operator-=(const Vec2& other) {
+    void operator-=(const Vec2& other) {
         x -= other.x;
         y -= other.y;
-        return *this;
     }
 
     template <typename U = T>
-    constexpr Vec2<std::enable_if_t<std::is_signed_v<U>, U>> operator-() const {
-        return {-x, -y};
+    Vec2<std::enable_if_t<std::is_signed<U>::value, U>> operator-() const {
+        return MakeVec(-x, -y);
     }
-    constexpr Vec2<decltype(T{} * T{})> operator*(const Vec2& other) const {
-        return {x * other.x, y * other.y};
+    Vec2<decltype(T{} * T{})> operator*(const Vec2& other) const {
+        return MakeVec(x * other.x, y * other.y);
     }
-
     template <typename V>
-    constexpr Vec2<decltype(T{} * V{})> operator*(const V& f) const {
-        return {x * f, y * f};
+    Vec2<decltype(T{} * V{})> operator*(const V& f) const {
+        return MakeVec(x * f, y * f);
     }
-
     template <typename V>
-    constexpr Vec2& operator*=(const V& f) {
+    void operator*=(const V& f) {
         *this = *this * f;
-        return *this;
     }
-
     template <typename V>
-    constexpr Vec2<decltype(T{} / V{})> operator/(const V& f) const {
-        return {x / f, y / f};
+    Vec2<decltype(T{} / V{})> operator/(const V& f) const {
+        return MakeVec(x / f, y / f);
     }
-
     template <typename V>
-    constexpr Vec2& operator/=(const V& f) {
+    void operator/=(const V& f) {
         *this = *this / f;
-        return *this;
     }
 
-    constexpr T Length2() const {
+    T Length2() const {
         return x * x + y * y;
     }
 
     // Only implemented for T=float
     float Length() const;
+    void SetLength(const float l);
+    Vec2 WithLength(const float l) const;
+    float Distance2To(Vec2& other);
+    Vec2 Normalized() const;
     float Normalize(); // returns the previous length, which is often useful
 
-    constexpr T& operator[](std::size_t i) {
+    T& operator[](int i) // allow vector[1] = 3   (vector.y=3)
+    {
         return *((&x) + i);
     }
-    constexpr const T& operator[](std::size_t i) const {
+    T operator[](const int i) const {
         return *((&x) + i);
     }
 
-    constexpr void SetZero() {
+    void SetZero() {
         x = 0;
         y = 0;
     }
 
     // Common aliases: UV (texel coordinates), ST (texture coordinates)
-    constexpr T& u() {
+    T& u() {
         return x;
     }
-    constexpr T& v() {
+    T& v() {
         return y;
     }
-    constexpr T& s() {
+    T& s() {
         return x;
     }
-    constexpr T& t() {
+    T& t() {
         return y;
     }
 
-    constexpr const T& u() const {
+    const T& u() const {
         return x;
     }
-    constexpr const T& v() const {
+    const T& v() const {
         return y;
     }
-    constexpr const T& s() const {
+    const T& s() const {
         return x;
     }
-    constexpr const T& t() const {
+    const T& t() const {
         return y;
     }
 
     // swizzlers - create a subvector of specific components
-    constexpr Vec2 yx() const {
+    const Vec2 yx() const {
         return Vec2(y, x);
     }
-    constexpr Vec2 vu() const {
+    const Vec2 vu() const {
         return Vec2(y, x);
     }
-    constexpr Vec2 ts() const {
+    const Vec2 ts() const {
         return Vec2(y, x);
     }
 };
 
 template <typename T, typename V>
-constexpr Vec2<T> operator*(const V& f, const Vec2<T>& vec) {
+Vec2<T> operator*(const V& f, const Vec2<T>& vec) {
     return Vec2<T>(f * vec.x, f * vec.y);
 }
 
-using Vec2f = Vec2<float>;
+typedef Vec2<float> Vec2f;
 
 template <>
 inline float Vec2<float>::Length() const {
@@ -192,151 +196,147 @@ public:
     T y{};
     T z{};
 
-    constexpr Vec3() = default;
-    constexpr Vec3(const T& x_, const T& y_, const T& z_) : x(x_), y(y_), z(z_) {}
+    Vec3() = default;
+    Vec3(const T& _x, const T& _y, const T& _z) : x(_x), y(_y), z(_z) {}
 
     template <typename T2>
-    constexpr Vec3<T2> Cast() const {
-        return Vec3<T2>(static_cast<T2>(x), static_cast<T2>(y), static_cast<T2>(z));
+    Vec3<T2> Cast() const {
+        return MakeVec<T2>((T2)x, (T2)y, (T2)z);
     }
 
-    static constexpr Vec3 AssignToAll(const T& f) {
-        return Vec3(f, f, f);
+    // Only implemented for T=int and T=float
+    static Vec3 FromRGB(unsigned int rgb);
+    unsigned int ToRGB() const; // alpha bits set to zero
+
+    static Vec3 AssignToAll(const T& f) {
+        return MakeVec(f, f, f);
     }
 
-    constexpr Vec3<decltype(T{} + T{})> operator+(const Vec3& other) const {
-        return {x + other.x, y + other.y, z + other.z};
+    Vec3<decltype(T{} + T{})> operator+(const Vec3& other) const {
+        return MakeVec(x + other.x, y + other.y, z + other.z);
     }
-
-    constexpr Vec3& operator+=(const Vec3& other) {
+    void operator+=(const Vec3& other) {
         x += other.x;
         y += other.y;
         z += other.z;
-        return *this;
     }
-
-    constexpr Vec3<decltype(T{} - T{})> operator-(const Vec3& other) const {
-        return {x - other.x, y - other.y, z - other.z};
+    Vec3<decltype(T{} - T{})> operator-(const Vec3& other) const {
+        return MakeVec(x - other.x, y - other.y, z - other.z);
     }
-
-    constexpr Vec3& operator-=(const Vec3& other) {
+    void operator-=(const Vec3& other) {
         x -= other.x;
         y -= other.y;
         z -= other.z;
-        return *this;
     }
 
     template <typename U = T>
-    constexpr Vec3<std::enable_if_t<std::is_signed_v<U>, U>> operator-() const {
-        return {-x, -y, -z};
+    Vec3<std::enable_if_t<std::is_signed<U>::value, U>> operator-() const {
+        return MakeVec(-x, -y, -z);
     }
-
-    constexpr Vec3<decltype(T{} * T{})> operator*(const Vec3& other) const {
-        return {x * other.x, y * other.y, z * other.z};
+    Vec3<decltype(T{} * T{})> operator*(const Vec3& other) const {
+        return MakeVec(x * other.x, y * other.y, z * other.z);
     }
-
     template <typename V>
-    constexpr Vec3<decltype(T{} * V{})> operator*(const V& f) const {
-        return {x * f, y * f, z * f};
+    Vec3<decltype(T{} * V{})> operator*(const V& f) const {
+        return MakeVec(x * f, y * f, z * f);
     }
-
     template <typename V>
-    constexpr Vec3& operator*=(const V& f) {
+    void operator*=(const V& f) {
         *this = *this * f;
-        return *this;
     }
     template <typename V>
-    constexpr Vec3<decltype(T{} / V{})> operator/(const V& f) const {
-        return {x / f, y / f, z / f};
+    Vec3<decltype(T{} / V{})> operator/(const V& f) const {
+        return MakeVec(x / f, y / f, z / f);
     }
-
     template <typename V>
-    constexpr Vec3& operator/=(const V& f) {
+    void operator/=(const V& f) {
         *this = *this / f;
-        return *this;
     }
 
-    constexpr T Length2() const {
+    T Length2() const {
         return x * x + y * y + z * z;
     }
 
     // Only implemented for T=float
     float Length() const;
+    void SetLength(const float l);
+    Vec3 WithLength(const float l) const;
+    float Distance2To(Vec3& other);
     Vec3 Normalized() const;
     float Normalize(); // returns the previous length, which is often useful
 
-    constexpr T& operator[](std::size_t i) {
+    T& operator[](int i) // allow vector[2] = 3   (vector.z=3)
+    {
+        return *((&x) + i);
+    }
+    T operator[](const int i) const {
         return *((&x) + i);
     }
 
-    constexpr const T& operator[](std::size_t i) const {
-        return *((&x) + i);
-    }
-
-    constexpr void SetZero() {
+    void SetZero() {
         x = 0;
         y = 0;
         z = 0;
     }
 
     // Common aliases: UVW (texel coordinates), RGB (colors), STQ (texture coordinates)
-    constexpr T& u() {
+    T& u() {
         return x;
     }
-    constexpr T& v() {
+    T& v() {
         return y;
     }
-    constexpr T& w() {
+    T& w() {
         return z;
     }
 
-    constexpr T& r() {
+    T& r() {
         return x;
     }
-    constexpr T& g() {
+    T& g() {
         return y;
     }
-    constexpr T& b() {
+    T& b() {
         return z;
     }
 
-    constexpr T& s() {
+    T& s() {
         return x;
     }
-    constexpr T& t() {
+    T& t() {
         return y;
     }
-    constexpr T& q() {
+    T& q() {
         return z;
     }
 
-    constexpr const T& u() const {
+    const T& u() const {
         return x;
     }
-    constexpr const T& v() const {
+    const T& v() const {
         return y;
     }
-    constexpr const T& w() const {
+    const T& w() const {
         return z;
     }
 
-    constexpr const T& r() const {
+    const T& r() const {
         return x;
     }
-    constexpr const T& g() const {
+    const T& g() const {
         return y;
     }
-    constexpr const T& b() const {
+    const T& b() const {
         return z;
     }
 
-    constexpr const T& s() const {
+    const T& s() const {
         return x;
     }
-    constexpr const T& t() const {
+    const T& t() const {
         return y;
     }
-    constexpr const T& q() const {
+    const T& q() const {
         return z;
     }
 
@@ -345,7 +345,7 @@ public:
 // _DEFINE_SWIZZLER2 defines a single such function, DEFINE_SWIZZLER2 defines all of them for all
 // component names (x<->r) and permutations (xy<->yx)
 #define _DEFINE_SWIZZLER2(a, b, name)                                                              \
-    constexpr Vec2<T> name() const {                                                               \
+    const Vec2<T> name() const {                                                                   \
         return Vec2<T>(a, b);                                                                      \
     }
 #define DEFINE_SWIZZLER2(a, b, a2, b2, a3, b3, a4, b4)                                             \
@@ -366,7 +366,7 @@ public:
 };
 
 template <typename T, typename V>
-constexpr Vec3<T> operator*(const V& f, const Vec3<T>& vec) {
+Vec3<T> operator*(const V& f, const Vec3<T>& vec) {
     return Vec3<T>(f * vec.x, f * vec.y, f * vec.z);
 }
 
@@ -387,7 +387,7 @@ inline float Vec3<float>::Normalize() {
     return length;
 }
 
-using Vec3f = Vec3<float>;
+typedef Vec3<float> Vec3f;
 
 template <typename T>
 class Vec4 {
@@ -397,88 +397,86 @@ public:
     T z{};
     T w{};
 
-    constexpr Vec4() = default;
-    constexpr Vec4(const T& x_, const T& y_, const T& z_, const T& w_)
-        : x(x_), y(y_), z(z_), w(w_) {}
+    Vec4() = default;
+    Vec4(const T& _x, const T& _y, const T& _z, const T& _w) : x(_x), y(_y), z(_z), w(_w) {}
 
     template <typename T2>
-    constexpr Vec4<T2> Cast() const {
-        return Vec4<T2>(static_cast<T2>(x), static_cast<T2>(y), static_cast<T2>(z),
-                        static_cast<T2>(w));
+    Vec4<T2> Cast() const {
+        return Vec4<T2>((T2)x, (T2)y, (T2)z, (T2)w);
     }
 
-    static constexpr Vec4 AssignToAll(const T& f) {
-        return Vec4(f, f, f, f);
+    // Only implemented for T=int and T=float
+    static Vec4 FromRGBA(unsigned int rgba);
+    unsigned int ToRGBA() const;
+
+    static Vec4 AssignToAll(const T& f) {
+        return Vec4<T>(f, f, f, f);
     }
 
-    constexpr Vec4<decltype(T{} + T{})> operator+(const Vec4& other) const {
-        return {x + other.x, y + other.y, z + other.z, w + other.w};
+    Vec4<decltype(T{} + T{})> operator+(const Vec4& other) const {
+        return MakeVec(x + other.x, y + other.y, z + other.z, w + other.w);
     }
-
-    constexpr Vec4& operator+=(const Vec4& other) {
+    void operator+=(const Vec4& other) {
         x += other.x;
         y += other.y;
         z += other.z;
         w += other.w;
-        return *this;
     }
-
-    constexpr Vec4<decltype(T{} - T{})> operator-(const Vec4& other) const {
-        return {x - other.x, y - other.y, z - other.z, w - other.w};
+    Vec4<decltype(T{} - T{})> operator-(const Vec4& other) const {
+        return MakeVec(x - other.x, y - other.y, z - other.z, w - other.w);
     }
-
-    constexpr Vec4& operator-=(const Vec4& other) {
+    void operator-=(const Vec4& other) {
         x -= other.x;
         y -= other.y;
         z -= other.z;
         w -= other.w;
-        return *this;
     }
 
     template <typename U = T>
-    constexpr Vec4<std::enable_if_t<std::is_signed_v<U>, U>> operator-() const {
-        return {-x, -y, -z, -w};
+    Vec4<std::enable_if_t<std::is_signed<U>::value, U>> operator-() const {
+        return MakeVec(-x, -y, -z, -w);
     }
-
-    constexpr Vec4<decltype(T{} * T{})> operator*(const Vec4& other) const {
-        return {x * other.x, y * other.y, z * other.z, w * other.w};
+    Vec4<decltype(T{} * T{})> operator*(const Vec4& other) const {
+        return MakeVec(x * other.x, y * other.y, z * other.z, w * other.w);
     }
-
     template <typename V>
-    constexpr Vec4<decltype(T{} * V{})> operator*(const V& f) const {
-        return {x * f, y * f, z * f, w * f};
+    Vec4<decltype(T{} * V{})> operator*(const V& f) const {
+        return MakeVec(x * f, y * f, z * f, w * f);
     }
-
     template <typename V>
-    constexpr Vec4& operator*=(const V& f) {
+    void operator*=(const V& f) {
         *this = *this * f;
-        return *this;
     }
-
     template <typename V>
-    constexpr Vec4<decltype(T{} / V{})> operator/(const V& f) const {
-        return {x / f, y / f, z / f, w / f};
+    Vec4<decltype(T{} / V{})> operator/(const V& f) const {
+        return MakeVec(x / f, y / f, z / f, w / f);
     }
-
     template <typename V>
-    constexpr Vec4& operator/=(const V& f) {
+    void operator/=(const V& f) {
         *this = *this / f;
-        return *this;
     }
 
-    constexpr T Length2() const {
+    T Length2() const {
         return x * x + y * y + z * z + w * w;
     }
 
-    constexpr T& operator[](std::size_t i) {
+    // Only implemented for T=float
+    float Length() const;
+    void SetLength(const float l);
+    Vec4 WithLength(const float l) const;
+    float Distance2To(Vec4& other);
+    Vec4 Normalized() const;
+    float Normalize(); // returns the previous length, which is often useful
+
+    T& operator[](int i) // allow vector[2] = 3   (vector.z=3)
+    {
+        return *((&x) + i);
+    }
+    T operator[](const int i) const {
         return *((&x) + i);
     }
 
-    constexpr const T& operator[](std::size_t i) const {
-        return *((&x) + i);
-    }
-
-    constexpr void SetZero() {
+    void SetZero() {
         x = 0;
         y = 0;
         z = 0;
@@ -486,29 +484,29 @@ public:
     }
 
     // Common alias: RGBA (colors)
-    constexpr T& r() {
+    T& r() {
         return x;
     }
-    constexpr T& g() {
+    T& g() {
         return y;
     }
-    constexpr T& b() {
+    T& b() {
         return z;
     }
-    constexpr T& a() {
+    T& a() {
         return w;
     }
 
-    constexpr const T& r() const {
+    const T& r() const {
         return x;
     }
-    constexpr const T& g() const {
+    const T& g() const {
         return y;
     }
-    constexpr const T& b() const {
+    const T& b() const {
         return z;
     }
-    constexpr const T& a() const {
+    const T& a() const {
         return w;
     }
 
@@ -520,7 +518,7 @@ public:
 // DEFINE_SWIZZLER2_COMP2 defines two component functions for all component names (x<->r) and
 // permutations (xy<->yx)
 #define _DEFINE_SWIZZLER2(a, b, name)                                                              \
-    constexpr Vec2<T> name() const {                                                               \
+    const Vec2<T> name() const {                                                                   \
         return Vec2<T>(a, b);                                                                      \
     }
 #define DEFINE_SWIZZLER2_COMP1(a, a2)                                                              \
@@ -547,7 +545,7 @@ public:
 #undef _DEFINE_SWIZZLER2
 
 #define _DEFINE_SWIZZLER3(a, b, c, name)                                                           \
-    constexpr Vec3<T> name() const {                                                               \
+    const Vec3<T> name() const {                                                                   \
         return Vec3<T>(a, b, c);                                                                   \
     }
 #define DEFINE_SWIZZLER3_COMP1(a, a2)                                                              \
@@ -581,51 +579,51 @@ public:
 };
 
 template <typename T, typename V>
-constexpr Vec4<decltype(V{} * T{})> operator*(const V& f, const Vec4<T>& vec) {
-    return {f * vec.x, f * vec.y, f * vec.z, f * vec.w};
+Vec4<decltype(V{} * T{})> operator*(const V& f, const Vec4<T>& vec) {
+    return MakeVec(f * vec.x, f * vec.y, f * vec.z, f * vec.w);
 }
 
-using Vec4f = Vec4<float>;
+typedef Vec4<float> Vec4f;
 
 template <typename T>
-constexpr decltype(T{} * T{} + T{} * T{}) Dot(const Vec2<T>& a, const Vec2<T>& b) {
+static inline decltype(T{} * T{} + T{} * T{}) Dot(const Vec2<T>& a, const Vec2<T>& b) {
     return a.x * b.x + a.y * b.y;
 }
 
 template <typename T>
-constexpr decltype(T{} * T{} + T{} * T{}) Dot(const Vec3<T>& a, const Vec3<T>& b) {
+static inline decltype(T{} * T{} + T{} * T{}) Dot(const Vec3<T>& a, const Vec3<T>& b) {
     return a.x * b.x + a.y * b.y + a.z * b.z;
 }
 
 template <typename T>
-constexpr decltype(T{} * T{} + T{} * T{}) Dot(const Vec4<T>& a, const Vec4<T>& b) {
+static inline decltype(T{} * T{} + T{} * T{}) Dot(const Vec4<T>& a, const Vec4<T>& b) {
     return a.x * b.x + a.y * b.y + a.z * b.z + a.w * b.w;
 }
 
 template <typename T>
-constexpr Vec3<decltype(T{} * T{} - T{} * T{})> Cross(const Vec3<T>& a, const Vec3<T>& b) {
-    return {a.y * b.z - a.z * b.y, a.z * b.x - a.x * b.z, a.x * b.y - a.y * b.x};
+static inline Vec3<decltype(T{} * T{} - T{} * T{})> Cross(const Vec3<T>& a, const Vec3<T>& b) {
+    return MakeVec(a.y * b.z - a.z * b.y, a.z * b.x - a.x * b.z, a.x * b.y - a.y * b.x);
 }
 
 // linear interpolation via float: 0.0=begin, 1.0=end
 template <typename X>
-constexpr decltype(X{} * float{} + X{} * float{}) Lerp(const X& begin, const X& end,
-                                                       const float t) {
+static inline decltype(X{} * float{} + X{} * float{}) Lerp(const X& begin, const X& end,
+                                                           const float t) {
     return begin * (1.f - t) + end * t;
 }
 
 // linear interpolation via int: 0=begin, base=end
 template <typename X, int base>
-constexpr decltype((X{} * int{} + X{} * int{}) / base) LerpInt(const X& begin, const X& end,
-                                                               const int t) {
+static inline decltype((X{} * int{} + X{} * int{}) / base) LerpInt(const X& begin, const X& end,
+                                                                   const int t) {
     return (begin * (base - t) + end * t) / base;
 }
 
 // bilinear interpolation. s is for interpolating x00-x01 and x10-x11, and t is for the second
 // interpolation.
 template <typename X>
-constexpr auto BilinearInterp(const X& x00, const X& x01, const X& x10, const X& x11, const float s,
-                              const float t) {
+inline auto BilinearInterp(const X& x00, const X& x01, const X& x10, const X& x11, const float s,
+                           const float t) {
     auto y0 = Lerp(x00, x01, s);
     auto y1 = Lerp(x10, x11, s);
     return Lerp(y0, y1, t);
@@ -633,42 +631,42 @@ constexpr auto BilinearInterp(const X& x00, const X& x01, const X& x10, const X&
 
 // Utility vector factories
 template <typename T>
-constexpr Vec2<T> MakeVec(const T& x, const T& y) {
+static inline Vec2<T> MakeVec(const T& x, const T& y) {
     return Vec2<T>{x, y};
 }
 
 template <typename T>
-constexpr Vec3<T> MakeVec(const T& x, const T& y, const T& z) {
+static inline Vec3<T> MakeVec(const T& x, const T& y, const T& z) {
     return Vec3<T>{x, y, z};
 }
 
 template <typename T>
-constexpr Vec4<T> MakeVec(const T& x, const T& y, const Vec2<T>& zw) {
+static inline Vec4<T> MakeVec(const T& x, const T& y, const Vec2<T>& zw) {
     return MakeVec(x, y, zw[0], zw[1]);
 }
 
 template <typename T>
-constexpr Vec3<T> MakeVec(const Vec2<T>& xy, const T& z) {
+static inline Vec3<T> MakeVec(const Vec2<T>& xy, const T& z) {
     return MakeVec(xy[0], xy[1], z);
 }
 
 template <typename T>
-constexpr Vec3<T> MakeVec(const T& x, const Vec2<T>& yz) {
+static inline Vec3<T> MakeVec(const T& x, const Vec2<T>& yz) {
     return MakeVec(x, yz[0], yz[1]);
 }
 
 template <typename T>
-constexpr Vec4<T> MakeVec(const T& x, const T& y, const T& z, const T& w) {
+static inline Vec4<T> MakeVec(const T& x, const T& y, const T& z, const T& w) {
     return Vec4<T>{x, y, z, w};
 }
 
 template <typename T>
-constexpr Vec4<T> MakeVec(const Vec2<T>& xy, const T& z, const T& w) {
+static inline Vec4<T> MakeVec(const Vec2<T>& xy, const T& z, const T& w) {
     return MakeVec(xy[0], xy[1], z, w);
 }
 
 template <typename T>
-constexpr Vec4<T> MakeVec(const T& x, const Vec2<T>& yz, const T& w) {
+static inline Vec4<T> MakeVec(const T& x, const Vec2<T>& yz, const T& w) {
     return MakeVec(x, yz[0], yz[1], w);
 }
 
@@ -676,17 +674,17 @@ constexpr Vec4<T> MakeVec(const T& x, const Vec2<T>& yz, const T& w) {
 //       Even if someone wanted to use an odd object like Vec2<Vec2<T>>, the compiler would error
 //       out soon enough due to misuse of the returned structure.
 template <typename T>
-constexpr Vec4<T> MakeVec(const Vec2<T>& xy, const Vec2<T>& zw) {
+static inline Vec4<T> MakeVec(const Vec2<T>& xy, const Vec2<T>& zw) {
     return MakeVec(xy[0], xy[1], zw[0], zw[1]);
 }
 
 template <typename T>
-constexpr Vec4<T> MakeVec(const Vec3<T>& xyz, const T& w) {
+static inline Vec4<T> MakeVec(const Vec3<T>& xyz, const T& w) {
     return MakeVec(xyz[0], xyz[1], xyz[2], w);
 }
 
 template <typename T>
-constexpr Vec4<T> MakeVec(const T& x, const Vec3<T>& yzw) {
+static inline Vec4<T> MakeVec(const T& x, const Vec3<T>& yzw) {
     return MakeVec(x, yzw[0], yzw[1], yzw[2]);
 }
 

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 {
@@ -33,7 +34,7 @@ inline bool IsWithin2G(const Xbyak::CodeGenerator& code, uintptr_t target) {
 
 template <typename T>
 inline void CallFarFunction(Xbyak::CodeGenerator& code, const T f) {
-    static_assert(std::is_pointer_v<T>, "Argument must be a (function) pointer.");
+    static_assert(std::is_pointer<T>(), "Argument must be a (function) pointer.");
     size_t addr = reinterpret_cast<size_t>(f);
     if (IsWithin2G(code, addr)) {
         code.call(f);
@@ -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
@@ -112,6 +104,8 @@ add_library(core STATIC
     hle/lock.cpp
     hle/lock.h
     hle/result.h
+    hle/romfs.cpp
+    hle/romfs.h
     hle/service/acc/acc.cpp
     hle/service/acc/acc.h
     hle/service/acc/acc_aa.cpp
@@ -257,10 +251,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

@@ -86,16 +86,7 @@ public:
     }
 
     void AddTicks(u64 ticks) override {
-        // Divide the number of ticks by the amount of CPU cores. TODO(Subv): This yields only a
-        // rough approximation of the amount of executed ticks in the system, it may be thrown off
-        // if not all cores are doing a similar amount of work. Instead of doing this, we should
-        // device a way so that timing is consistent across all cores without increasing the ticks 4
-        // times.
-        u64 amortized_ticks = (ticks - num_interpreted_instructions) / Core::NUM_CPU_CORES;
-        // Always execute at least one tick.
-        amortized_ticks = std::max<u64>(amortized_ticks, 1);
-
-        CoreTiming::AddTicks(amortized_ticks);
+        CoreTiming::AddTicks(ticks - num_interpreted_instructions);
         num_interpreted_instructions = 0;
     }
     u64 GetTicksRemaining() override {
@@ -134,9 +125,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 +234,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));
+System::ResultStatus System::Load(EmuWindow& emu_window, const std::string& filepath) {
+    app_loader = Loader::GetLoader(std::make_shared<FileSys::RealVfsFile>(filepath));
 
     if (!app_loader) {
         LOG_CRITICAL(Core, "Failed to obtain loader for {}!", filepath);
@@ -135,8 +102,18 @@ System::ResultStatus System::Load(Frontend::EmuWindow& emu_window, const std::st
         LOG_CRITICAL(Core, "Failed to determine system mode (Error {})!",
                      static_cast<int>(system_mode.second));
 
-        if (system_mode.second != Loader::ResultStatus::Success)
+        switch (system_mode.second) {
+        case Loader::ResultStatus::ErrorMissingKeys:
+            return ResultStatus::ErrorLoader_ErrorMissingKeys;
+        case Loader::ResultStatus::ErrorDecrypting:
+            return ResultStatus::ErrorLoader_ErrorDecrypting;
+        case Loader::ResultStatus::ErrorInvalidFormat:
+            return ResultStatus::ErrorLoader_ErrorInvalidFormat;
+        case Loader::ResultStatus::ErrorUnsupportedArch:
+            return ResultStatus::ErrorUnsupportedArch;
+        default:
             return ResultStatus::ErrorSystemMode;
+        }
     }
 
     ResultStatus init_result{Init(emu_window)};
@@ -152,9 +129,17 @@ System::ResultStatus System::Load(Frontend::EmuWindow& emu_window, const std::st
         LOG_CRITICAL(Core, "Failed to load ROM (Error {})!", static_cast<int>(load_result));
         System::Shutdown();
 
-        if (load_result != Loader::ResultStatus::Success) {
-            return static_cast<ResultStatus>(static_cast<u32>(ResultStatus::ErrorLoader) +
-                                             static_cast<u32>(load_result));
+        switch (load_result) {
+        case Loader::ResultStatus::ErrorMissingKeys:
+            return ResultStatus::ErrorLoader_ErrorMissingKeys;
+        case Loader::ResultStatus::ErrorDecrypting:
+            return ResultStatus::ErrorLoader_ErrorDecrypting;
+        case Loader::ResultStatus::ErrorInvalidFormat:
+            return ResultStatus::ErrorLoader_ErrorInvalidFormat;
+        case Loader::ResultStatus::ErrorUnsupportedArch:
+            return ResultStatus::ErrorUnsupportedArch;
+        default:
+            return ResultStatus::ErrorLoader;
         }
     }
     status = ResultStatus::Success;
@@ -184,15 +169,11 @@ Cpu& System::CpuCore(size_t core_index) {
     return *cpu_cores[core_index];
 }
 
-System::ResultStatus System::Init(Frontend::EmuWindow& emu_window) {
+System::ResultStatus System::Init(EmuWindow& emu_window) {
     LOG_DEBUG(HW_Memory, "initialized OK");
 
     CoreTiming::Init();
 
-    // Create a default fs if one doesn't already exist.
-    if (virtual_filesystem == nullptr)
-        virtual_filesystem = std::make_shared<FileSys::RealVfsFilesystem>();
-
     current_process = Kernel::Process::Create("main");
 
     cpu_barrier = std::make_shared<CpuBarrier>();
@@ -205,7 +186,7 @@ System::ResultStatus System::Init(Frontend::EmuWindow& emu_window) {
     service_manager = std::make_shared<Service::SM::ServiceManager>();
 
     Kernel::Init();
-    Service::Init(service_manager, virtual_filesystem);
+    Service::Init(service_manager);
     GDBStub::Init();
 
     renderer = VideoCore::CreateRenderer(emu_window);

src/core/core.h

@@ -17,16 +17,11 @@
 #include "core/memory.h"
 #include "core/perf_stats.h"
 #include "core/telemetry_session.h"
-#include "file_sys/vfs_real.h"
-#include "hle/service/filesystem/filesystem.h"
 #include "video_core/debug_utils/debug_utils.h"
 #include "video_core/gpu.h"
 
-class ARM_Interface;
-
-namespace Core::Frontend {
 class EmuWindow;
-}
+class ARM_Interface;
 
 namespace Service::SM {
 class ServiceManager;
@@ -40,12 +35,6 @@ namespace Core {
 
 class System {
 public:
-    System(const System&) = delete;
-    System& operator=(const System&) = delete;
-
-    System(System&&) = delete;
-    System& operator=(System&&) = delete;
-
     ~System();
 
     /**
@@ -58,15 +47,21 @@ public:
 
     /// Enumeration representing the return values of the System Initialize and Load process.
     enum class ResultStatus : u32 {
-        Success,             ///< Succeeded
-        ErrorNotInitialized, ///< Error trying to use core prior to initialization
-        ErrorGetLoader,      ///< Error finding the correct application loader
-        ErrorSystemMode,     ///< Error determining the system mode
-        ErrorSystemFiles,    ///< Error in finding system files
-        ErrorSharedFont,     ///< Error in finding shared font
-        ErrorVideoCore,      ///< Error in the video core
-        ErrorUnknown,        ///< Any other error
-        ErrorLoader,         ///< The base for loader errors (too many to repeat)
+        Success,                      ///< Succeeded
+        ErrorNotInitialized,          ///< Error trying to use core prior to initialization
+        ErrorGetLoader,               ///< Error finding the correct application loader
+        ErrorSystemMode,              ///< Error determining the system mode
+        ErrorLoader,                  ///< Error loading the specified application
+        ErrorLoader_ErrorMissingKeys, ///< Error because the key/keys needed to run could not be
+                                      ///< found.
+        ErrorLoader_ErrorDecrypting,  ///< Error loading the specified application due to encryption
+        ErrorLoader_ErrorInvalidFormat, ///< Error loading the specified application due to an
+                                        /// invalid format
+        ErrorSystemFiles,               ///< Error in finding system files
+        ErrorSharedFont,                ///< Error in finding shared font
+        ErrorVideoCore,                 ///< Error in the video core
+        ErrorUnsupportedArch,           ///< Unsupported Architecture (32-Bit ROMs)
+        ErrorUnknown                    ///< Any other error
     };
 
     /**
@@ -108,7 +103,7 @@ public:
      * @param filepath String path to the executable application to load on the host file system.
      * @returns ResultStatus code, indicating if the operation succeeded.
      */
-    ResultStatus Load(Frontend::EmuWindow& emu_window, const std::string& filepath);
+    ResultStatus Load(EmuWindow& emu_window, const std::string& filepath);
 
     /**
      * Indicates if the emulated system is powered on (all subsystems initialized and able to run an
@@ -216,14 +211,6 @@ public:
         return debug_context;
     }
 
-    void SetFilesystem(FileSys::VirtualFilesystem vfs) {
-        virtual_filesystem = std::move(vfs);
-    }
-
-    FileSys::VirtualFilesystem GetFilesystem() const {
-        return virtual_filesystem;
-    }
-
 private:
     System();
 
@@ -236,10 +223,8 @@ private:
      *                   input.
      * @return ResultStatus code, indicating if the operation succeeded.
      */
-    ResultStatus Init(Frontend::EmuWindow& emu_window);
+    ResultStatus Init(EmuWindow& emu_window);
 
-    /// RealVfsFilesystem instance
-    FileSys::VirtualFilesystem virtual_filesystem;
     /// AppLoader used to load the current executing application
     std::unique_ptr<Loader::AppLoader> app_loader;
     std::unique_ptr<VideoCore::RendererBase> renderer;

src/core/core_cpu.cpp

@@ -14,7 +14,6 @@
 #include "core/core_timing.h"
 #include "core/hle/kernel/scheduler.h"
 #include "core/hle/kernel/thread.h"
-#include "core/hle/lock.h"
 #include "core/settings.h"
 
 namespace Core {
@@ -91,7 +90,6 @@ void Cpu::RunLoop(bool tight_loop) {
         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();
         }
@@ -127,8 +125,6 @@ void Cpu::Reschedule() {
     }
 
     reschedule_pending = false;
-    // Lock the global kernel mutex when we manipulate the HLE state
-    std::lock_guard<std::recursive_mutex> lock(HLE::g_hle_lock);
     scheduler->Reschedule();
 }
 

src/core/core_cpu.h

@@ -79,7 +79,7 @@ private:
     std::shared_ptr<CpuBarrier> cpu_barrier;
     std::shared_ptr<Kernel::Scheduler> scheduler;
 
-    std::atomic<bool> reschedule_pending = false;
+    bool reschedule_pending{};
     size_t core_index;
 };
 

src/core/core_timing.cpp

@@ -56,9 +56,6 @@ 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;
@@ -138,9 +135,11 @@ void ClearPendingEvents() {
 void ScheduleEvent(s64 cycles_into_future, const EventType* event_type, u64 userdata) {
     ASSERT(event_type != nullptr);
     s64 timeout = GetTicks() + cycles_into_future;
+
     // If this event needs to be scheduled before the next advance(), force one early
     if (!is_global_timer_sane)
         ForceExceptionCheck(cycles_into_future);
+
     event_queue.emplace_back(Event{timeout, event_fifo_id++, userdata, event_type});
     std::push_heap(event_queue.begin(), event_queue.end(), std::greater<>());
 }
@@ -161,10 +160,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; });
@@ -201,9 +196,6 @@ void MoveEvents() {
 
 void Advance() {
     MoveEvents();
-    for (std::pair<const EventType*, u64> ev; unschedule_queue.Pop(ev);) {
-        UnscheduleEvent(ev.first, ev.second);
-    }
 
     int cycles_executed = slice_length - downcount;
     global_timer += cycles_executed;

src/core/core_timing.h

@@ -65,7 +65,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);

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,27 +4,21 @@
 
 #include <array>
 #include <string>
-
-#include <fmt/ostream.h>
-
-#include "common/logging/log.h"
+#include <core/loader/loader.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 {
 
-constexpr std::array<const char*, 0x4> partition_names = {"update", "normal", "secure", "logo"};
-
 XCI::XCI(VirtualFile file_) : file(std::move(file_)), partitions(0x4) {
     if (file->ReadObject(&header) != sizeof(GamecardHeader)) {
-        status = Loader::ResultStatus::ErrorBadXCIHeader;
+        status = Loader::ResultStatus::ErrorInvalidFormat;
         return;
     }
 
     if (header.magic != Common::MakeMagic('H', 'E', 'A', 'D')) {
-        status = Loader::ResultStatus::ErrorBadXCIHeader;
+        status = Loader::ResultStatus::ErrorInvalidFormat;
         return;
     }
 
@@ -36,6 +30,9 @@ XCI::XCI(VirtualFile file_) : file(std::move(file_)), partitions(0x4) {
         return;
     }
 
+    static constexpr std::array<const char*, 0x4> partition_names = {"update", "normal", "secure",
+                                                                     "logo"};
+
     for (XCIPartition partition :
          {XCIPartition::Update, XCIPartition::Normal, XCIPartition::Secure, XCIPartition::Logo}) {
         auto raw = main_hfs.GetFile(partition_names[static_cast<size_t>(partition)]);
@@ -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(),
@@ -114,19 +107,19 @@ VirtualFile XCI::GetNCAFileByType(NCAContentType type) const {
     return nullptr;
 }
 
-std::vector<VirtualFile> XCI::GetFiles() const {
+std::vector<std::shared_ptr<VfsFile>> XCI::GetFiles() const {
     return {};
 }
 
-std::vector<VirtualDir> XCI::GetSubdirectories() const {
-    return {};
+std::vector<std::shared_ptr<VfsDirectory>> XCI::GetSubdirectories() const {
+    return std::vector<std::shared_ptr<VfsDirectory>>();
 }
 
 std::string XCI::GetName() const {
     return file->GetName();
 }
 
-VirtualDir XCI::GetParentDirectory() const {
+std::shared_ptr<VfsDirectory> XCI::GetParentDirectory() const {
     return file->GetContainingDirectory();
 }
 
@@ -136,21 +129,15 @@ bool XCI::ReplaceFileWithSubdirectory(VirtualFile file, VirtualDir dir) {
 
 Loader::ResultStatus XCI::AddNCAFromPartition(XCIPartition part) {
     if (partitions[static_cast<size_t>(part)] == nullptr) {
-        return Loader::ResultStatus::ErrorXCIMissingPartition;
+        return Loader::ResultStatus::ErrorInvalidFormat;
     }
 
     for (const VirtualFile& file : partitions[static_cast<size_t>(part)]->GetFiles()) {
         if (file->GetExtension() != "nca")
             continue;
         auto nca = std::make_shared<NCA>(file);
-        if (nca->GetStatus() == Loader::ResultStatus::Success) {
+        if (nca->GetStatus() == Loader::ResultStatus::Success)
             ncas.push_back(std::move(nca));
-        } else {
-            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());
-        }
     }
 
     return Loader::ResultStatus::Success;

src/core/file_sys/card_image.h

@@ -68,17 +68,16 @@ 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;
 
-    std::vector<VirtualFile> GetFiles() const override;
+    std::vector<std::shared_ptr<VfsFile>> GetFiles() const override;
 
-    std::vector<VirtualDir> GetSubdirectories() const override;
+    std::vector<std::shared_ptr<VfsDirectory>> GetSubdirectories() const override;
 
     std::string GetName() const override;
 
-    VirtualDir GetParentDirectory() const override;
+    std::shared_ptr<VfsDirectory> GetParentDirectory() const override;
 
 protected:
     bool ReplaceFileWithSubdirectory(VirtualFile file, VirtualDir dir) override;

src/core/file_sys/content_archive.cpp

@@ -113,27 +113,17 @@ boost::optional<Core::Crypto::Key128> NCA::GetKeyAreaKey(NCASectionCryptoType ty
     return out;
 }
 
-boost::optional<Core::Crypto::Key128> NCA::GetTitlekey() {
+boost::optional<Core::Crypto::Key128> NCA::GetTitlekey() const {
     const auto master_key_id = GetCryptoRevision();
 
     u128 rights_id{};
     memcpy(rights_id.data(), header.rights_id.data(), 16);
-    if (rights_id == u128{}) {
-        status = Loader::ResultStatus::ErrorInvalidRightsID;
+    if (rights_id == u128{})
         return boost::none;
-    }
 
     auto titlekey = keys.GetKey(Core::Crypto::S128KeyType::Titlekey, rights_id[1], rights_id[0]);
-    if (titlekey == Core::Crypto::Key128{}) {
-        status = Loader::ResultStatus::ErrorMissingTitlekey;
+    if (titlekey == Core::Crypto::Key128{})
         return boost::none;
-    }
-
-    if (!keys.HasKey(Core::Crypto::S128KeyType::Titlekek, master_key_id)) {
-        status = Loader::ResultStatus::ErrorMissingTitlekek;
-        return boost::none;
-    }
-
     Core::Crypto::AESCipher<Core::Crypto::Key128> cipher(
         keys.GetKey(Core::Crypto::S128KeyType::Titlekek, master_key_id), Core::Crypto::Mode::ECB);
     cipher.Transcode(titlekey.data(), titlekey.size(), titlekey.data(), Core::Crypto::Op::Decrypt);
@@ -141,7 +131,7 @@ boost::optional<Core::Crypto::Key128> NCA::GetTitlekey() {
     return titlekey;
 }
 
-VirtualFile NCA::Decrypt(NCASectionHeader s_header, VirtualFile in, u64 starting_offset) {
+VirtualFile NCA::Decrypt(NCASectionHeader s_header, VirtualFile in, u64 starting_offset) const {
     if (!encrypted)
         return in;
 
@@ -153,22 +143,15 @@ VirtualFile NCA::Decrypt(NCASectionHeader s_header, VirtualFile in, u64 starting
         LOG_DEBUG(Crypto, "called with mode=CTR, starting_offset={:016X}", starting_offset);
         {
             boost::optional<Core::Crypto::Key128> key = boost::none;
-            if (has_rights_id) {
-                status = Loader::ResultStatus::Success;
-                key = GetTitlekey();
-                if (key == boost::none) {
-                    if (status == Loader::ResultStatus::Success)
-                        status = Loader::ResultStatus::ErrorMissingTitlekey;
-                    return nullptr;
-                }
-            } else {
+            if (std::find_if_not(header.rights_id.begin(), header.rights_id.end(),
+                                 [](char c) { return c == 0; }) == header.rights_id.end()) {
                 key = GetKeyAreaKey(NCASectionCryptoType::CTR);
-                if (key == boost::none) {
-                    status = Loader::ResultStatus::ErrorMissingKeyAreaKey;
-                    return nullptr;
-                }
+            } else {
+                key = GetTitlekey();
             }
 
+            if (key == boost::none)
+                return nullptr;
             auto out = std::make_shared<Core::Crypto::CTREncryptionLayer>(
                 std::move(in), key.value(), starting_offset);
             std::vector<u8> iv(16);
@@ -187,31 +170,12 @@ VirtualFile NCA::Decrypt(NCASectionHeader s_header, VirtualFile in, u64 starting
 }
 
 NCA::NCA(VirtualFile file_) : file(std::move(file_)) {
-    status = Loader::ResultStatus::Success;
-
-    if (file == nullptr) {
-        status = Loader::ResultStatus::ErrorNullFile;
-        return;
-    }
-
-    if (sizeof(NCAHeader) != file->ReadObject(&header)) {
+    if (sizeof(NCAHeader) != file->ReadObject(&header))
         LOG_ERROR(Loader, "File reader errored out during header read.");
-        status = Loader::ResultStatus::ErrorBadNCAHeader;
-        return;
-    }
 
     encrypted = false;
 
     if (!IsValidNCA(header)) {
-        if (header.magic == Common::MakeMagic('N', 'C', 'A', '2')) {
-            status = Loader::ResultStatus::ErrorNCA2;
-            return;
-        }
-        if (header.magic == Common::MakeMagic('N', 'C', 'A', '0')) {
-            status = Loader::ResultStatus::ErrorNCA0;
-            return;
-        }
-
         NCAHeader dec_header{};
         Core::Crypto::AESCipher<Core::Crypto::Key256> cipher(
             keys.GetKey(Core::Crypto::S256KeyType::Header), Core::Crypto::Mode::XTS);
@@ -221,26 +185,14 @@ NCA::NCA(VirtualFile file_) : file(std::move(file_)) {
             header = dec_header;
             encrypted = true;
         } else {
-            if (dec_header.magic == Common::MakeMagic('N', 'C', 'A', '2')) {
-                status = Loader::ResultStatus::ErrorNCA2;
-                return;
-            }
-            if (dec_header.magic == Common::MakeMagic('N', 'C', 'A', '0')) {
-                status = Loader::ResultStatus::ErrorNCA0;
-                return;
-            }
-
             if (!keys.HasKey(Core::Crypto::S256KeyType::Header))
-                status = Loader::ResultStatus::ErrorMissingHeaderKey;
+                status = Loader::ResultStatus::ErrorMissingKeys;
             else
-                status = Loader::ResultStatus::ErrorIncorrectHeaderKey;
+                status = Loader::ResultStatus::ErrorDecrypting;
             return;
         }
     }
 
-    has_rights_id = std::find_if_not(header.rights_id.begin(), header.rights_id.end(),
-                                     [](char c) { return c == '\0'; }) != header.rights_id.end();
-
     const std::ptrdiff_t number_sections =
         std::count_if(std::begin(header.section_tables), std::end(header.section_tables),
                       [](NCASectionTableEntry entry) { return entry.media_offset > 0; });
@@ -273,12 +225,7 @@ NCA::NCA(VirtualFile file_) : file(std::move(file_)) {
                 files.push_back(std::move(dec));
                 romfs = files.back();
             } else {
-                if (status != Loader::ResultStatus::Success)
-                    return;
-                if (has_rights_id)
-                    status = Loader::ResultStatus::ErrorIncorrectTitlekeyOrTitlekek;
-                else
-                    status = Loader::ResultStatus::ErrorIncorrectKeyAreaKey;
+                status = Loader::ResultStatus::ErrorMissingKeys;
                 return;
             }
         } else if (section.raw.header.filesystem_type == NCASectionFilesystemType::PFS0) {
@@ -298,12 +245,7 @@ NCA::NCA(VirtualFile file_) : file(std::move(file_)) {
                         exefs = dirs.back();
                 }
             } else {
-                if (status != Loader::ResultStatus::Success)
-                    return;
-                if (has_rights_id)
-                    status = Loader::ResultStatus::ErrorIncorrectTitlekeyOrTitlekek;
-                else
-                    status = Loader::ResultStatus::ErrorIncorrectKeyAreaKey;
+                status = Loader::ResultStatus::ErrorMissingKeys;
                 return;
             }
         }

src/core/file_sys/content_archive.h

@@ -12,7 +12,6 @@
 #include "common/common_funcs.h"
 #include "common/common_types.h"
 #include "common/swap.h"
-#include "control_metadata.h"
 #include "core/crypto/key_manager.h"
 #include "core/file_sys/partition_filesystem.h"
 #include "core/loader/loader.h"
@@ -98,8 +97,8 @@ protected:
 private:
     u8 GetCryptoRevision() const;
     boost::optional<Core::Crypto::Key128> GetKeyAreaKey(NCASectionCryptoType type) const;
-    boost::optional<Core::Crypto::Key128> GetTitlekey();
-    VirtualFile Decrypt(NCASectionHeader header, VirtualFile in, u64 starting_offset);
+    boost::optional<Core::Crypto::Key128> GetTitlekey() const;
+    VirtualFile Decrypt(NCASectionHeader header, VirtualFile in, u64 starting_offset) const;
 
     std::vector<VirtualDir> dirs;
     std::vector<VirtualFile> files;
@@ -109,7 +108,6 @@ private:
     VirtualFile file;
 
     NCAHeader header{};
-    bool has_rights_id{};
 
     Loader::ResultStatus status{};
 

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

@@ -62,13 +62,6 @@ enum class Language : u8 {
     Chinese = 14,
 };
 
-static constexpr std::array<const char*, 15> LANGUAGE_NAMES = {
-    "AmericanEnglish", "BritishEnglish", "Japanese",
-    "French",          "German",         "LatinAmericanSpanish",
-    "Spanish",         "Italian",        "Dutch",
-    "CanadianFrench",  "Portugese",      "Russian",
-    "Korean",          "Taiwanese",      "Chinese"};
-
 // A class representing the format used by NX metadata files, typically named Control.nacp.
 // These store application name, dev name, title id, and other miscellaneous data.
 class NACP {
@@ -81,6 +74,7 @@ public:
     std::string GetVersionString() const;
 
 private:
+    VirtualFile file;
     std::unique_ptr<RawNACP> raw;
 };
 

src/core/file_sys/directory.h

@@ -4,9 +4,8 @@
 
 #pragma once
 
+#include <array>
 #include <cstddef>
-#include <iterator>
-#include <string_view>
 #include "common/common_funcs.h"
 #include "common/common_types.h"
 
@@ -22,14 +21,9 @@ enum EntryType : u8 {
 
 // Structure of a directory entry, from
 // http://switchbrew.org/index.php?title=Filesystem_services#DirectoryEntry
+const size_t FILENAME_LENGTH = 0x300;
 struct Entry {
-    Entry(std::string_view view, EntryType entry_type, u64 entry_size)
-        : type{entry_type}, file_size{entry_size} {
-        const size_t copy_size = view.copy(filename, std::size(filename) - 1);
-        filename[copy_size] = '\0';
-    }
-
-    char filename[0x300];
+    char filename[FILENAME_LENGTH];
     INSERT_PADDING_BYTES(4);
     EntryType type;
     INSERT_PADDING_BYTES(3);

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/partition_filesystem.cpp

@@ -24,19 +24,19 @@ bool PartitionFilesystem::Header::HasValidMagicValue() const {
 PartitionFilesystem::PartitionFilesystem(std::shared_ptr<VfsFile> file) {
     // At least be as large as the header
     if (file->GetSize() < sizeof(Header)) {
-        status = Loader::ResultStatus::ErrorBadPFSHeader;
+        status = Loader::ResultStatus::Error;
         return;
     }
 
     // For cartridges, HFSs can get very large, so we need to calculate the size up to
     // the actual content itself instead of just blindly reading in the entire file.
     if (sizeof(Header) != file->ReadObject(&pfs_header)) {
-        status = Loader::ResultStatus::ErrorBadPFSHeader;
+        status = Loader::ResultStatus::Error;
         return;
     }
 
     if (!pfs_header.HasValidMagicValue()) {
-        status = Loader::ResultStatus::ErrorBadPFSHeader;
+        status = Loader::ResultStatus::ErrorInvalidFormat;
         return;
     }
 
@@ -51,7 +51,7 @@ PartitionFilesystem::PartitionFilesystem(std::shared_ptr<VfsFile> file) {
     const size_t total_size = file_data.size();
 
     if (total_size != metadata_size) {
-        status = Loader::ResultStatus::ErrorIncorrectPFSFileSize;
+        status = Loader::ResultStatus::Error;
         return;
     }
 

src/core/file_sys/partition_filesystem.h

@@ -13,7 +13,7 @@
 #include "core/file_sys/vfs.h"
 
 namespace Loader {
-enum class ResultStatus : u16;
+enum class ResultStatus;
 }
 
 namespace FileSys {

src/core/file_sys/program_metadata.cpp

@@ -12,26 +12,26 @@ namespace FileSys {
 Loader::ResultStatus ProgramMetadata::Load(VirtualFile file) {
     size_t total_size = static_cast<size_t>(file->GetSize());
     if (total_size < sizeof(Header))
-        return Loader::ResultStatus::ErrorBadNPDMHeader;
+        return Loader::ResultStatus::Error;
 
     // TODO(DarkLordZach): Use ReadObject when Header/AcidHeader becomes trivially copyable.
     std::vector<u8> npdm_header_data = file->ReadBytes(sizeof(Header));
     if (sizeof(Header) != npdm_header_data.size())
-        return Loader::ResultStatus::ErrorBadNPDMHeader;
+        return Loader::ResultStatus::Error;
     std::memcpy(&npdm_header, npdm_header_data.data(), sizeof(Header));
 
     std::vector<u8> acid_header_data = file->ReadBytes(sizeof(AcidHeader), npdm_header.acid_offset);
     if (sizeof(AcidHeader) != acid_header_data.size())
-        return Loader::ResultStatus::ErrorBadACIDHeader;
+        return Loader::ResultStatus::Error;
     std::memcpy(&acid_header, acid_header_data.data(), sizeof(AcidHeader));
 
     if (sizeof(AciHeader) != file->ReadObject(&aci_header, npdm_header.aci_offset))
-        return Loader::ResultStatus::ErrorBadACIHeader;
+        return Loader::ResultStatus::Error;
 
     if (sizeof(FileAccessControl) != file->ReadObject(&acid_file_access, acid_header.fac_offset))
-        return Loader::ResultStatus::ErrorBadFileAccessControl;
+        return Loader::ResultStatus::Error;
     if (sizeof(FileAccessHeader) != file->ReadObject(&aci_file_access, aci_header.fah_offset))
-        return Loader::ResultStatus::ErrorBadFileAccessHeader;
+        return Loader::ResultStatus::Error;
 
     return Loader::ResultStatus::Success;
 }

src/core/file_sys/program_metadata.h

@@ -13,7 +13,7 @@
 #include "partition_filesystem.h"
 
 namespace Loader {
-enum class ResultStatus : u16;
+enum class ResultStatus;
 }
 
 namespace FileSys {

src/core/file_sys/registered_cache.cpp

@@ -1,478 +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:
-        return ContentRecordType::Data;
-    case NCAContentType::Manual:
-        // TODO(DarkLordZach): Peek at NCA contents to differentiate Manual and Legal.
-        return ContentRecordType::Manual;
-    default:
-        UNREACHABLE();
-    }
-}
-
-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/savedata_factory.h

@@ -7,7 +7,6 @@
 #include <memory>
 #include <string>
 #include "common/common_types.h"
-#include "common/swap.h"
 #include "core/hle/result.h"
 
 namespace FileSys {

src/core/file_sys/vfs.cpp

@@ -4,160 +4,12 @@
 
 #include <algorithm>
 #include <numeric>
-#include <string>
-#include "common/common_paths.h"
 #include "common/file_util.h"
 #include "common/logging/backend.h"
 #include "core/file_sys/vfs.h"
 
 namespace FileSys {
 
-VfsFilesystem::VfsFilesystem(VirtualDir root_) : root(std::move(root_)) {}
-
-VfsFilesystem::~VfsFilesystem() = default;
-
-std::string VfsFilesystem::GetName() const {
-    return root->GetName();
-}
-
-bool VfsFilesystem::IsReadable() const {
-    return root->IsReadable();
-}
-
-bool VfsFilesystem::IsWritable() const {
-    return root->IsWritable();
-}
-
-VfsEntryType VfsFilesystem::GetEntryType(std::string_view path_) const {
-    const auto path = FileUtil::SanitizePath(path_);
-    if (root->GetFileRelative(path) != nullptr)
-        return VfsEntryType::File;
-    if (root->GetDirectoryRelative(path) != nullptr)
-        return VfsEntryType::Directory;
-
-    return VfsEntryType::None;
-}
-
-VirtualFile VfsFilesystem::OpenFile(std::string_view path_, Mode perms) {
-    const auto path = FileUtil::SanitizePath(path_);
-    return root->GetFileRelative(path);
-}
-
-VirtualFile VfsFilesystem::CreateFile(std::string_view path_, Mode perms) {
-    const auto path = FileUtil::SanitizePath(path_);
-    return root->CreateFileRelative(path);
-}
-
-VirtualFile VfsFilesystem::CopyFile(std::string_view old_path_, std::string_view new_path_) {
-    const auto old_path = FileUtil::SanitizePath(old_path_);
-    const auto new_path = FileUtil::SanitizePath(new_path_);
-
-    // VfsDirectory impls are only required to implement copy across the current directory.
-    if (FileUtil::GetParentPath(old_path) == FileUtil::GetParentPath(new_path)) {
-        if (!root->Copy(FileUtil::GetFilename(old_path), FileUtil::GetFilename(new_path)))
-            return nullptr;
-        return OpenFile(new_path, Mode::ReadWrite);
-    }
-
-    // Do it using RawCopy. Non-default impls are encouraged to optimize this.
-    const auto old_file = OpenFile(old_path, Mode::Read);
-    if (old_file == nullptr)
-        return nullptr;
-    auto new_file = OpenFile(new_path, Mode::Read);
-    if (new_file != nullptr)
-        return nullptr;
-    new_file = CreateFile(new_path, Mode::Write);
-    if (new_file == nullptr)
-        return nullptr;
-    if (!VfsRawCopy(old_file, new_file))
-        return nullptr;
-    return new_file;
-}
-
-VirtualFile VfsFilesystem::MoveFile(std::string_view old_path, std::string_view new_path) {
-    const auto sanitized_old_path = FileUtil::SanitizePath(old_path);
-    const auto sanitized_new_path = FileUtil::SanitizePath(new_path);
-
-    // Again, non-default impls are highly encouraged to provide a more optimized version of this.
-    auto out = CopyFile(sanitized_old_path, sanitized_new_path);
-    if (out == nullptr)
-        return nullptr;
-    if (DeleteFile(sanitized_old_path))
-        return out;
-    return nullptr;
-}
-
-bool VfsFilesystem::DeleteFile(std::string_view path_) {
-    const auto path = FileUtil::SanitizePath(path_);
-    auto parent = OpenDirectory(FileUtil::GetParentPath(path), Mode::Write);
-    if (parent == nullptr)
-        return false;
-    return parent->DeleteFile(FileUtil::GetFilename(path));
-}
-
-VirtualDir VfsFilesystem::OpenDirectory(std::string_view path_, Mode perms) {
-    const auto path = FileUtil::SanitizePath(path_);
-    return root->GetDirectoryRelative(path);
-}
-
-VirtualDir VfsFilesystem::CreateDirectory(std::string_view path_, Mode perms) {
-    const auto path = FileUtil::SanitizePath(path_);
-    return root->CreateDirectoryRelative(path);
-}
-
-VirtualDir VfsFilesystem::CopyDirectory(std::string_view old_path_, std::string_view new_path_) {
-    const auto old_path = FileUtil::SanitizePath(old_path_);
-    const auto new_path = FileUtil::SanitizePath(new_path_);
-
-    // Non-default impls are highly encouraged to provide a more optimized version of this.
-    auto old_dir = OpenDirectory(old_path, Mode::Read);
-    if (old_dir == nullptr)
-        return nullptr;
-    auto new_dir = OpenDirectory(new_path, Mode::Read);
-    if (new_dir != nullptr)
-        return nullptr;
-    new_dir = CreateDirectory(new_path, Mode::Write);
-    if (new_dir == nullptr)
-        return nullptr;
-
-    for (const auto& file : old_dir->GetFiles()) {
-        const auto x =
-            CopyFile(old_path + DIR_SEP + file->GetName(), new_path + DIR_SEP + file->GetName());
-        if (x == nullptr)
-            return nullptr;
-    }
-
-    for (const auto& dir : old_dir->GetSubdirectories()) {
-        const auto x =
-            CopyDirectory(old_path + DIR_SEP + dir->GetName(), new_path + DIR_SEP + dir->GetName());
-        if (x == nullptr)
-            return nullptr;
-    }
-
-    return new_dir;
-}
-
-VirtualDir VfsFilesystem::MoveDirectory(std::string_view old_path, std::string_view new_path) {
-    const auto sanitized_old_path = FileUtil::SanitizePath(old_path);
-    const auto sanitized_new_path = FileUtil::SanitizePath(new_path);
-
-    // Non-default impls are highly encouraged to provide a more optimized version of this.
-    auto out = CopyDirectory(sanitized_old_path, sanitized_new_path);
-    if (out == nullptr)
-        return nullptr;
-    if (DeleteDirectory(sanitized_old_path))
-        return out;
-    return nullptr;
-}
-
-bool VfsFilesystem::DeleteDirectory(std::string_view path_) {
-    const auto path = FileUtil::SanitizePath(path_);
-    auto parent = OpenDirectory(FileUtil::GetParentPath(path), Mode::Write);
-    if (parent == nullptr)
-        return false;
-    return parent->DeleteSubdirectoryRecursive(FileUtil::GetFilename(path));
-}
-
 VfsFile::~VfsFile() = default;
 
 std::string VfsFile::GetExtension() const {

src/core/file_sys/vfs.h

@@ -11,79 +11,17 @@
 #include <vector>
 #include "boost/optional.hpp"
 #include "common/common_types.h"
-#include "core/file_sys/mode.h"
 
 namespace FileSys {
+struct VfsFile;
+struct VfsDirectory;
 
-class VfsDirectory;
-class VfsFile;
-class VfsFilesystem;
-
-// Convenience typedefs to use Vfs* interfaces
-using VirtualFilesystem = std::shared_ptr<VfsFilesystem>;
-using VirtualDir = std::shared_ptr<VfsDirectory>;
-using VirtualFile = std::shared_ptr<VfsFile>;
-
-// An enumeration representing what can be at the end of a path in a VfsFilesystem
-enum class VfsEntryType {
-    None,
-    File,
-    Directory,
-};
-
-// A class representing an abstract filesystem. A default implementation given the root VirtualDir
-// is provided for convenience, but if the Vfs implementation has any additional state or
-// functionality, they will need to override.
-class VfsFilesystem : NonCopyable {
-public:
-    explicit VfsFilesystem(VirtualDir root);
-    virtual ~VfsFilesystem();
-
-    // Gets the friendly name for the filesystem.
-    virtual std::string GetName() const;
-
-    // Return whether or not the user has read permissions on this filesystem.
-    virtual bool IsReadable() const;
-    // Return whether or not the user has write permission on this filesystem.
-    virtual bool IsWritable() const;
-
-    // Determine if the entry at path is non-existant, a file, or a directory.
-    virtual VfsEntryType GetEntryType(std::string_view path) const;
-
-    // Opens the file with path relative to root. If it doesn't exist, returns nullptr.
-    virtual VirtualFile OpenFile(std::string_view path, Mode perms);
-    // Creates a new, empty file at path
-    virtual VirtualFile CreateFile(std::string_view path, Mode perms);
-    // Copies the file from old_path to new_path, returning the new file on success and nullptr on
-    // failure.
-    virtual VirtualFile CopyFile(std::string_view old_path, std::string_view new_path);
-    // Moves the file from old_path to new_path, returning the moved file on success and nullptr on
-    // failure.
-    virtual VirtualFile MoveFile(std::string_view old_path, std::string_view new_path);
-    // Deletes the file with path relative to root, returing true on success.
-    virtual bool DeleteFile(std::string_view path);
-
-    // Opens the directory with path relative to root. If it doesn't exist, returns nullptr.
-    virtual VirtualDir OpenDirectory(std::string_view path, Mode perms);
-    // Creates a new, empty directory at path
-    virtual VirtualDir CreateDirectory(std::string_view path, Mode perms);
-    // Copies the directory from old_path to new_path, returning the new directory on success and
-    // nullptr on failure.
-    virtual VirtualDir CopyDirectory(std::string_view old_path, std::string_view new_path);
-    // Moves the directory from old_path to new_path, returning the moved directory on success and
-    // nullptr on failure.
-    virtual VirtualDir MoveDirectory(std::string_view old_path, std::string_view new_path);
-    // Deletes the directory with path relative to root, returing true on success.
-    virtual bool DeleteDirectory(std::string_view path);
-
-protected:
-    // Root directory in default implementation.
-    VirtualDir root;
-};
+// Convenience typedefs to use VfsDirectory and VfsFile
+using VirtualDir = std::shared_ptr<FileSys::VfsDirectory>;
+using VirtualFile = std::shared_ptr<FileSys::VfsFile>;
 
 // A class representing a file in an abstract filesystem.
-class VfsFile : NonCopyable {
-public:
+struct VfsFile : NonCopyable {
     virtual ~VfsFile();
 
     // Retrieves the file name.
@@ -181,8 +119,7 @@ public:
 };
 
 // A class representing a directory in an abstract filesystem.
-class VfsDirectory : NonCopyable {
-public:
+struct VfsDirectory : NonCopyable {
     virtual ~VfsDirectory();
 
     // Retrives the file located at path as if the current directory was root. Returns nullptr if
@@ -298,8 +235,7 @@ protected:
 
 // A convenience partial-implementation of VfsDirectory that stubs out methods that should only work
 // if writable. This is to avoid redundant empty methods everywhere.
-class ReadOnlyVfsDirectory : public VfsDirectory {
-public:
+struct ReadOnlyVfsDirectory : public VfsDirectory {
     bool IsWritable() const override;
     bool IsReadable() const override;
     std::shared_ptr<VfsDirectory> CreateSubdirectory(std::string_view name) override;

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_offset.h

@@ -15,8 +15,7 @@ namespace FileSys {
 // Similar to seeking to an offset.
 // If the file is writable, operations that would write past the end of the offset file will expand
 // the size of this wrapper.
-class OffsetVfsFile : public VfsFile {
-public:
+struct OffsetVfsFile : public VfsFile {
     OffsetVfsFile(std::shared_ptr<VfsFile> file, size_t size, size_t offset = 0,
                   std::string new_name = "", VirtualDir new_parent = nullptr);
 

src/core/file_sys/vfs_real.cpp

@@ -6,7 +6,7 @@
 #include <cstddef>
 #include <iterator>
 #include <utility>
-#include "common/assert.h"
+
 #include "common/common_paths.h"
 #include "common/logging/log.h"
 #include "core/file_sys/vfs_real.h"
@@ -29,8 +29,6 @@ static std::string ModeFlagsToString(Mode mode) {
             mode_str = "a";
         else if (mode & Mode::Write)
             mode_str = "w";
-        else
-            UNREACHABLE_MSG("Invalid file open mode: {:02X}", static_cast<u8>(mode));
     }
 
     mode_str += "b";
@@ -38,182 +36,8 @@ static std::string ModeFlagsToString(Mode mode) {
     return mode_str;
 }
 
-RealVfsFilesystem::RealVfsFilesystem() : VfsFilesystem(nullptr) {}
-
-std::string RealVfsFilesystem::GetName() const {
-    return "Real";
-}
-
-bool RealVfsFilesystem::IsReadable() const {
-    return true;
-}
-
-bool RealVfsFilesystem::IsWritable() const {
-    return true;
-}
-
-VfsEntryType RealVfsFilesystem::GetEntryType(std::string_view path_) const {
-    const auto path = FileUtil::SanitizePath(path_, FileUtil::DirectorySeparator::PlatformDefault);
-    if (!FileUtil::Exists(path))
-        return VfsEntryType::None;
-    if (FileUtil::IsDirectory(path))
-        return VfsEntryType::Directory;
-
-    return VfsEntryType::File;
-}
-
-VirtualFile RealVfsFilesystem::OpenFile(std::string_view path_, Mode perms) {
-    const auto path = FileUtil::SanitizePath(path_, FileUtil::DirectorySeparator::PlatformDefault);
-    if (cache.find(path) != cache.end()) {
-        auto weak = cache[path];
-        if (!weak.expired()) {
-            return std::shared_ptr<RealVfsFile>(new RealVfsFile(*this, weak.lock(), path, perms));
-        }
-    }
-
-    if (!FileUtil::Exists(path) && (perms & Mode::WriteAppend) != 0)
-        FileUtil::CreateEmptyFile(path);
-
-    auto backing = std::make_shared<FileUtil::IOFile>(path, ModeFlagsToString(perms).c_str());
-    cache[path] = backing;
-
-    // Cannot use make_shared as RealVfsFile constructor is private
-    return std::shared_ptr<RealVfsFile>(new RealVfsFile(*this, backing, path, 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;
-    }
-    return OpenFile(path, perms);
-}
-
-VirtualFile RealVfsFilesystem::CopyFile(std::string_view old_path_, std::string_view new_path_) {
-    const auto old_path =
-        FileUtil::SanitizePath(old_path_, FileUtil::DirectorySeparator::PlatformDefault);
-    const auto new_path =
-        FileUtil::SanitizePath(new_path_, FileUtil::DirectorySeparator::PlatformDefault);
-
-    if (!FileUtil::Exists(old_path) || FileUtil::Exists(new_path) ||
-        FileUtil::IsDirectory(old_path) || !FileUtil::Copy(old_path, new_path))
-        return nullptr;
-    return OpenFile(new_path, Mode::ReadWrite);
-}
-
-VirtualFile RealVfsFilesystem::MoveFile(std::string_view old_path_, std::string_view new_path_) {
-    const auto old_path =
-        FileUtil::SanitizePath(old_path_, FileUtil::DirectorySeparator::PlatformDefault);
-    const auto new_path =
-        FileUtil::SanitizePath(new_path_, FileUtil::DirectorySeparator::PlatformDefault);
-
-    if (!FileUtil::Exists(old_path) || FileUtil::Exists(new_path) ||
-        FileUtil::IsDirectory(old_path) || !FileUtil::Rename(old_path, new_path))
-        return nullptr;
-
-    if (cache.find(old_path) != cache.end()) {
-        auto cached = cache[old_path];
-        if (!cached.expired()) {
-            auto file = cached.lock();
-            file->Open(new_path, "r+b");
-            cache.erase(old_path);
-            cache[new_path] = file;
-        }
-    }
-    return OpenFile(new_path, Mode::ReadWrite);
-}
-
-bool RealVfsFilesystem::DeleteFile(std::string_view path_) {
-    const auto path = FileUtil::SanitizePath(path_, FileUtil::DirectorySeparator::PlatformDefault);
-    if (cache.find(path) != cache.end()) {
-        if (!cache[path].expired())
-            cache[path].lock()->Close();
-        cache.erase(path);
-    }
-    return FileUtil::Delete(path);
-}
-
-VirtualDir RealVfsFilesystem::OpenDirectory(std::string_view path_, Mode perms) {
-    const auto path = FileUtil::SanitizePath(path_, FileUtil::DirectorySeparator::PlatformDefault);
-    // Cannot use make_shared as RealVfsDirectory constructor is private
-    return std::shared_ptr<RealVfsDirectory>(new RealVfsDirectory(*this, path, 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;
-    }
-    // Cannot use make_shared as RealVfsDirectory constructor is private
-    return std::shared_ptr<RealVfsDirectory>(new RealVfsDirectory(*this, path, perms));
-}
-
-VirtualDir RealVfsFilesystem::CopyDirectory(std::string_view old_path_,
-                                            std::string_view new_path_) {
-    const auto old_path =
-        FileUtil::SanitizePath(old_path_, FileUtil::DirectorySeparator::PlatformDefault);
-    const auto new_path =
-        FileUtil::SanitizePath(new_path_, FileUtil::DirectorySeparator::PlatformDefault);
-    if (!FileUtil::Exists(old_path) || FileUtil::Exists(new_path) ||
-        !FileUtil::IsDirectory(old_path))
-        return nullptr;
-    FileUtil::CopyDir(old_path, new_path);
-    return OpenDirectory(new_path, Mode::ReadWrite);
-}
-
-VirtualDir RealVfsFilesystem::MoveDirectory(std::string_view old_path_,
-                                            std::string_view new_path_) {
-    const auto old_path =
-        FileUtil::SanitizePath(old_path_, FileUtil::DirectorySeparator::PlatformDefault);
-    const auto new_path =
-        FileUtil::SanitizePath(new_path_, FileUtil::DirectorySeparator::PlatformDefault);
-    if (!FileUtil::Exists(old_path) || FileUtil::Exists(new_path) ||
-        FileUtil::IsDirectory(old_path) || !FileUtil::Rename(old_path, new_path))
-        return nullptr;
-
-    for (auto& kv : cache) {
-        // Path in cache starts with old_path
-        if (kv.first.rfind(old_path, 0) == 0) {
-            const auto file_old_path =
-                FileUtil::SanitizePath(kv.first, FileUtil::DirectorySeparator::PlatformDefault);
-            const auto file_new_path =
-                FileUtil::SanitizePath(new_path + DIR_SEP + kv.first.substr(old_path.size()),
-                                       FileUtil::DirectorySeparator::PlatformDefault);
-            auto cached = cache[file_old_path];
-            if (!cached.expired()) {
-                auto file = cached.lock();
-                file->Open(file_new_path, "r+b");
-                cache.erase(file_old_path);
-                cache[file_new_path] = file;
-            }
-        }
-    }
-
-    return OpenDirectory(new_path, Mode::ReadWrite);
-}
-
-bool RealVfsFilesystem::DeleteDirectory(std::string_view path_) {
-    const auto path = FileUtil::SanitizePath(path_, FileUtil::DirectorySeparator::PlatformDefault);
-    for (auto& kv : cache) {
-        // Path in cache starts with old_path
-        if (kv.first.rfind(path, 0) == 0) {
-            if (!cache[kv.first].expired())
-                cache[kv.first].lock()->Close();
-            cache.erase(kv.first);
-        }
-    }
-    return FileUtil::DeleteDirRecursively(path);
-}
-
-RealVfsFile::RealVfsFile(RealVfsFilesystem& base_, std::shared_ptr<FileUtil::IOFile> backing_,
-                         const std::string& path_, Mode perms_)
-    : base(base_), backing(std::move(backing_)), path(path_),
+RealVfsFile::RealVfsFile(const std::string& path_, Mode perms_)
+    : backing(path_, ModeFlagsToString(perms_).c_str()), path(path_),
       parent_path(FileUtil::GetParentPath(path_)),
       path_components(FileUtil::SplitPathComponents(path_)),
       parent_components(FileUtil::SliceVector(path_components, 0, path_components.size() - 1)),
@@ -224,15 +48,15 @@ std::string RealVfsFile::GetName() const {
 }
 
 size_t RealVfsFile::GetSize() const {
-    return backing->GetSize();
+    return backing.GetSize();
 }
 
 bool RealVfsFile::Resize(size_t new_size) {
-    return backing->Resize(new_size);
+    return backing.Resize(new_size);
 }
 
 std::shared_ptr<VfsDirectory> RealVfsFile::GetContainingDirectory() const {
-    return base.OpenDirectory(parent_path, perms);
+    return std::make_shared<RealVfsDirectory>(parent_path, perms);
 }
 
 bool RealVfsFile::IsWritable() const {
@@ -244,118 +68,62 @@ bool RealVfsFile::IsReadable() const {
 }
 
 size_t RealVfsFile::Read(u8* data, size_t length, size_t offset) const {
-    if (!backing->Seek(offset, SEEK_SET))
+    if (!backing.Seek(offset, SEEK_SET))
         return 0;
-    return backing->ReadBytes(data, length);
+    return backing.ReadBytes(data, length);
 }
 
 size_t RealVfsFile::Write(const u8* data, size_t length, size_t offset) {
-    if (!backing->Seek(offset, SEEK_SET))
+    if (!backing.Seek(offset, SEEK_SET))
         return 0;
-    return backing->WriteBytes(data, length);
+    return backing.WriteBytes(data, length);
 }
 
 bool RealVfsFile::Rename(std::string_view name) {
-    return base.MoveFile(path, parent_path + DIR_SEP + std::string(name)) != nullptr;
+    std::string name_str(name.begin(), name.end());
+    const auto out = FileUtil::Rename(GetName(), name_str);
+
+    path = (parent_path + DIR_SEP).append(name);
+    path_components = parent_components;
+    path_components.push_back(std::move(name_str));
+    backing = FileUtil::IOFile(path, ModeFlagsToString(perms).c_str());
+
+    return out;
 }
 
 bool RealVfsFile::Close() {
-    return backing->Close();
+    return backing.Close();
 }
 
-// TODO(DarkLordZach): MSVC would not let me combine the following two functions using 'if
-// constexpr' because there is a compile error in the branch not used.
-
-template <>
-std::vector<VirtualFile> RealVfsDirectory::IterateEntries<RealVfsFile, VfsFile>() const {
-    if (perms == Mode::Append)
-        return {};
-
-    std::vector<VirtualFile> out;
-    FileUtil::ForeachDirectoryEntry(
-        nullptr, path,
-        [&out, this](u64* entries_out, const std::string& directory, const std::string& filename) {
-            const std::string full_path = directory + DIR_SEP + filename;
-            if (!FileUtil::IsDirectory(full_path))
-                out.emplace_back(base.OpenFile(full_path, perms));
-            return true;
-        });
-
-    return out;
-}
-
-template <>
-std::vector<VirtualDir> RealVfsDirectory::IterateEntries<RealVfsDirectory, VfsDirectory>() const {
-    if (perms == Mode::Append)
-        return {};
-
-    std::vector<VirtualDir> out;
-    FileUtil::ForeachDirectoryEntry(
-        nullptr, path,
-        [&out, this](u64* entries_out, const std::string& directory, const std::string& filename) {
-            const std::string full_path = directory + DIR_SEP + filename;
-            if (FileUtil::IsDirectory(full_path))
-                out.emplace_back(base.OpenDirectory(full_path, perms));
-            return true;
-        });
-
-    return out;
-}
-
-RealVfsDirectory::RealVfsDirectory(RealVfsFilesystem& base_, const std::string& path_, Mode perms_)
-    : base(base_), path(FileUtil::RemoveTrailingSlash(path_)),
-      parent_path(FileUtil::GetParentPath(path)),
+RealVfsDirectory::RealVfsDirectory(const std::string& path_, Mode perms_)
+    : path(FileUtil::RemoveTrailingSlash(path_)), parent_path(FileUtil::GetParentPath(path)),
       path_components(FileUtil::SplitPathComponents(path)),
       parent_components(FileUtil::SliceVector(path_components, 0, path_components.size() - 1)),
       perms(perms_) {
     if (!FileUtil::Exists(path) && perms & Mode::WriteAppend)
         FileUtil::CreateDir(path);
-}
 
-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))
-        return nullptr;
-    return base.OpenFile(full_path, perms);
-}
+    if (perms == Mode::Append)
+        return;
 
-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))
-        return nullptr;
-    return base.OpenDirectory(full_path, perms);
-}
-
-std::shared_ptr<VfsFile> RealVfsDirectory::GetFile(std::string_view name) const {
-    return GetFileRelative(name);
-}
-
-std::shared_ptr<VfsDirectory> RealVfsDirectory::GetSubdirectory(std::string_view name) const {
-    return GetDirectoryRelative(name);
-}
-
-std::shared_ptr<VfsFile> RealVfsDirectory::CreateFileRelative(std::string_view path) {
-    const auto full_path = FileUtil::SanitizePath(this->path + DIR_SEP + std::string(path));
-    return base.CreateFile(full_path, perms);
-}
-
-std::shared_ptr<VfsDirectory> RealVfsDirectory::CreateDirectoryRelative(std::string_view path) {
-    const auto full_path = FileUtil::SanitizePath(this->path + DIR_SEP + std::string(path));
-    auto parent = std::string(FileUtil::GetParentPath(full_path));
-    return base.CreateDirectory(full_path, perms);
-}
-
-bool RealVfsDirectory::DeleteSubdirectoryRecursive(std::string_view name) {
-    auto full_path = FileUtil::SanitizePath(this->path + DIR_SEP + std::string(name));
-    return base.DeleteDirectory(full_path);
+    FileUtil::ForeachDirectoryEntry(
+        nullptr, path,
+        [this](u64* entries_out, const std::string& directory, const std::string& filename) {
+            std::string full_path = directory + DIR_SEP + filename;
+            if (FileUtil::IsDirectory(full_path))
+                subdirectories.emplace_back(std::make_shared<RealVfsDirectory>(full_path, perms));
+            else
+                files.emplace_back(std::make_shared<RealVfsFile>(full_path, perms));
+            return true;
+        });
 }
 
 std::vector<std::shared_ptr<VfsFile>> RealVfsDirectory::GetFiles() const {
-    return IterateEntries<RealVfsFile, VfsFile>();
+    return files;
 }
 
 std::vector<std::shared_ptr<VfsDirectory>> RealVfsDirectory::GetSubdirectories() const {
-    return IterateEntries<RealVfsDirectory, VfsDirectory>();
+    return subdirectories;
 }
 
 bool RealVfsDirectory::IsWritable() const {
@@ -374,32 +142,57 @@ std::shared_ptr<VfsDirectory> RealVfsDirectory::GetParentDirectory() const {
     if (path_components.size() <= 1)
         return nullptr;
 
-    return base.OpenDirectory(parent_path, perms);
+    return std::make_shared<RealVfsDirectory>(parent_path, perms);
 }
 
 std::shared_ptr<VfsDirectory> RealVfsDirectory::CreateSubdirectory(std::string_view name) {
     const std::string subdir_path = (path + DIR_SEP).append(name);
-    return base.CreateDirectory(subdir_path, perms);
+
+    if (!FileUtil::CreateDir(subdir_path)) {
+        return nullptr;
+    }
+
+    subdirectories.emplace_back(std::make_shared<RealVfsDirectory>(subdir_path, perms));
+    return subdirectories.back();
 }
 
 std::shared_ptr<VfsFile> RealVfsDirectory::CreateFile(std::string_view name) {
     const std::string file_path = (path + DIR_SEP).append(name);
-    return base.CreateFile(file_path, perms);
+
+    if (!FileUtil::CreateEmptyFile(file_path)) {
+        return nullptr;
+    }
+
+    files.emplace_back(std::make_shared<RealVfsFile>(file_path, perms));
+    return files.back();
 }
 
 bool RealVfsDirectory::DeleteSubdirectory(std::string_view name) {
     const std::string subdir_path = (path + DIR_SEP).append(name);
-    return base.DeleteDirectory(subdir_path);
+
+    return FileUtil::DeleteDirRecursively(subdir_path);
 }
 
 bool RealVfsDirectory::DeleteFile(std::string_view name) {
+    const auto file = GetFile(name);
+
+    if (file == nullptr) {
+        return false;
+    }
+
+    files.erase(std::find(files.begin(), files.end(), file));
+
+    auto real_file = std::static_pointer_cast<RealVfsFile>(file);
+    real_file->Close();
+
     const std::string file_path = (path + DIR_SEP).append(name);
-    return base.DeleteFile(file_path);
+    return FileUtil::Delete(file_path);
 }
 
 bool RealVfsDirectory::Rename(std::string_view name) {
     const std::string new_name = (parent_path + DIR_SEP).append(name);
-    return base.MoveFile(path, new_name) != nullptr;
+
+    return FileUtil::Rename(path, new_name);
 }
 
 std::string RealVfsDirectory::GetFullPath() const {
@@ -409,6 +202,16 @@ std::string RealVfsDirectory::GetFullPath() const {
 }
 
 bool RealVfsDirectory::ReplaceFileWithSubdirectory(VirtualFile file, VirtualDir dir) {
-    return false;
+    const auto iter = std::find(files.begin(), files.end(), file);
+    if (iter == files.end())
+        return false;
+
+    const std::ptrdiff_t offset = std::distance(files.begin(), iter);
+    files[offset] = files.back();
+    files.pop_back();
+
+    subdirectories.emplace_back(std::move(dir));
+
+    return true;
 }
 } // namespace FileSys

src/core/file_sys/vfs_real.h

@@ -5,45 +5,19 @@
 #pragma once
 
 #include <string_view>
-#include <boost/container/flat_map.hpp>
+
 #include "common/file_util.h"
 #include "core/file_sys/mode.h"
 #include "core/file_sys/vfs.h"
 
 namespace FileSys {
 
-class RealVfsFilesystem : public VfsFilesystem {
-public:
-    RealVfsFilesystem();
-
-    std::string GetName() const override;
-    bool IsReadable() const override;
-    bool IsWritable() const override;
-    VfsEntryType GetEntryType(std::string_view path) const override;
-    VirtualFile OpenFile(std::string_view path, Mode perms = Mode::Read) override;
-    VirtualFile CreateFile(std::string_view path, Mode perms = Mode::ReadWrite) override;
-    VirtualFile CopyFile(std::string_view old_path, std::string_view new_path) override;
-    VirtualFile MoveFile(std::string_view old_path, std::string_view new_path) override;
-    bool DeleteFile(std::string_view path) override;
-    VirtualDir OpenDirectory(std::string_view path, Mode perms = Mode::Read) override;
-    VirtualDir CreateDirectory(std::string_view path, Mode perms = Mode::ReadWrite) override;
-    VirtualDir CopyDirectory(std::string_view old_path, std::string_view new_path) override;
-    VirtualDir MoveDirectory(std::string_view old_path, std::string_view new_path) override;
-    bool DeleteDirectory(std::string_view path) override;
-
-private:
-    boost::container::flat_map<std::string, std::weak_ptr<FileUtil::IOFile>> cache;
-};
-
 // An implmentation of VfsFile that represents a file on the user's computer.
-class RealVfsFile : public VfsFile {
-    friend class RealVfsDirectory;
-    friend class RealVfsFilesystem;
+struct RealVfsFile : public VfsFile {
+    friend struct RealVfsDirectory;
 
-    RealVfsFile(RealVfsFilesystem& base, std::shared_ptr<FileUtil::IOFile> backing,
-                const std::string& path, Mode perms = Mode::Read);
+    RealVfsFile(const std::string& name, Mode perms = Mode::Read);
 
-public:
     std::string GetName() const override;
     size_t GetSize() const override;
     bool Resize(size_t new_size) override;
@@ -57,8 +31,7 @@ public:
 private:
     bool Close();
 
-    RealVfsFilesystem& base;
-    std::shared_ptr<FileUtil::IOFile> backing;
+    FileUtil::IOFile backing;
     std::string path;
     std::string parent_path;
     std::vector<std::string> path_components;
@@ -67,19 +40,9 @@ private:
 };
 
 // An implementation of VfsDirectory that represents a directory on the user's computer.
-class RealVfsDirectory : public VfsDirectory {
-    friend class RealVfsFilesystem;
+struct RealVfsDirectory : public VfsDirectory {
+    RealVfsDirectory(const std::string& path, Mode perms = Mode::Read);
 
-    RealVfsDirectory(RealVfsFilesystem& base, const std::string& path, Mode perms = Mode::Read);
-
-public:
-    std::shared_ptr<VfsFile> GetFileRelative(std::string_view path) const override;
-    std::shared_ptr<VfsDirectory> GetDirectoryRelative(std::string_view path) const override;
-    std::shared_ptr<VfsFile> GetFile(std::string_view name) const override;
-    std::shared_ptr<VfsDirectory> GetSubdirectory(std::string_view name) const override;
-    std::shared_ptr<VfsFile> CreateFileRelative(std::string_view path) override;
-    std::shared_ptr<VfsDirectory> CreateDirectoryRelative(std::string_view path) override;
-    bool DeleteSubdirectoryRecursive(std::string_view name) override;
     std::vector<std::shared_ptr<VfsFile>> GetFiles() const override;
     std::vector<std::shared_ptr<VfsDirectory>> GetSubdirectories() const override;
     bool IsWritable() const override;
@@ -97,15 +60,13 @@ protected:
     bool ReplaceFileWithSubdirectory(VirtualFile file, VirtualDir dir) override;
 
 private:
-    template <typename T, typename R>
-    std::vector<std::shared_ptr<R>> IterateEntries() const;
-
-    RealVfsFilesystem& base;
     std::string path;
     std::string parent_path;
     std::vector<std::string> path_components;
     std::vector<std::string> parent_components;
     Mode perms;
+    std::vector<std::shared_ptr<VfsFile>> files;
+    std::vector<std::shared_ptr<VfsDirectory>> subdirectories;
 };
 
 } // namespace FileSys

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

@@ -10,11 +10,10 @@ namespace FileSys {
 
 // An implementation of VfsDirectory that maintains two vectors for subdirectories and files.
 // Vector data is supplied upon construction.
-class VectorVfsDirectory : public VfsDirectory {
-public:
+struct VectorVfsDirectory : public VfsDirectory {
     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.cpp

@@ -8,8 +8,6 @@
 #include "core/frontend/input.h"
 #include "core/settings.h"
 
-namespace Core::Frontend {
-
 class EmuWindow::TouchState : public Input::Factory<Input::TouchDevice>,
                               public std::enable_shared_from_this<TouchState> {
 public:
@@ -110,5 +108,3 @@ void EmuWindow::TouchMoved(unsigned framebuffer_x, unsigned framebuffer_y) {
 void EmuWindow::UpdateCurrentFramebufferLayout(unsigned width, unsigned height) {
     NotifyFramebufferLayoutChanged(Layout::DefaultFrameLayout(width, height));
 }
-
-} // namespace Core::Frontend

src/core/frontend/emu_window.h

@@ -10,8 +10,6 @@
 #include "common/common_types.h"
 #include "core/frontend/framebuffer_layout.h"
 
-namespace Core::Frontend {
-
 /**
  * Abstraction class used to provide an interface between emulation code and the frontend
  * (e.g. SDL, QGLWidget, GLFW, etc...).
@@ -34,9 +32,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;
     };
 
@@ -168,5 +166,3 @@ private:
      */
     std::tuple<unsigned, unsigned> ClipToTouchScreen(unsigned new_x, unsigned new_y);
 };
-
-} // namespace Core::Frontend

src/core/hle/kernel/hle_ipc.cpp

@@ -201,7 +201,7 @@ ResultCode HLERequestContext::PopulateFromIncomingCommandBuffer(u32_le* src_cmdb
     return RESULT_SUCCESS;
 }
 
-ResultCode HLERequestContext::WriteToOutgoingCommandBuffer(const Thread& thread) {
+ResultCode HLERequestContext::WriteToOutgoingCommandBuffer(Thread& thread) {
     std::array<u32, IPC::COMMAND_BUFFER_LENGTH> dst_cmdbuf;
     Memory::ReadBlock(*thread.owner_process, thread.GetTLSAddress(), dst_cmdbuf.data(),
                       dst_cmdbuf.size() * sizeof(u32));

src/core/hle/kernel/hle_ipc.h

@@ -132,7 +132,7 @@ public:
     ResultCode PopulateFromIncomingCommandBuffer(u32_le* src_cmdbuf, Process& src_process,
                                                  HandleTable& src_table);
     /// Writes data from this context back to the requesting process/thread.
-    ResultCode WriteToOutgoingCommandBuffer(const Thread& thread);
+    ResultCode WriteToOutgoingCommandBuffer(Thread& thread);
 
     u32_le GetCommand() const {
         return command;

src/core/hle/kernel/kernel.cpp

@@ -11,7 +11,7 @@
 
 namespace Kernel {
 
-std::atomic<u32> Object::next_object_id{0};
+unsigned int Object::next_object_id;
 
 /// Initialize the kernel
 void Init() {

src/core/hle/kernel/object.h

@@ -4,7 +4,6 @@
 
 #pragma once
 
-#include <atomic>
 #include <string>
 #include <utility>
 
@@ -43,8 +42,8 @@ public:
     virtual ~Object();
 
     /// Returns a unique identifier for the object. For debugging purposes only.
-    u32 GetObjectId() const {
-        return object_id.load(std::memory_order_relaxed);
+    unsigned int GetObjectId() const {
+        return object_id;
     }
 
     virtual std::string GetTypeName() const {
@@ -62,23 +61,23 @@ public:
     bool IsWaitable() const;
 
 public:
-    static std::atomic<u32> next_object_id;
+    static unsigned int next_object_id;
 
 private:
     friend void intrusive_ptr_add_ref(Object*);
     friend void intrusive_ptr_release(Object*);
 
-    std::atomic<u32> ref_count{0};
-    std::atomic<u32> object_id{next_object_id++};
+    unsigned int ref_count = 0;
+    unsigned int object_id = next_object_id++;
 };
 
 // Special functions used by boost::instrusive_ptr to do automatic ref-counting
 inline void intrusive_ptr_add_ref(Object* object) {
-    object->ref_count.fetch_add(1, std::memory_order_relaxed);
+    ++object->ref_count;
 }
 
 inline void intrusive_ptr_release(Object* object) {
-    if (object->ref_count.fetch_sub(1, std::memory_order_acq_rel) == 1) {
+    if (--object->ref_count == 0) {
         delete object;
     }
 }

src/core/hle/kernel/scheduler.cpp

@@ -25,7 +25,7 @@ Scheduler::~Scheduler() {
     }
 }
 
-bool Scheduler::HaveReadyThreads() const {
+bool Scheduler::HaveReadyThreads() {
     std::lock_guard<std::mutex> lock(scheduler_mutex);
     return ready_queue.get_first() != nullptr;
 }

src/core/hle/kernel/scheduler.h

@@ -21,7 +21,7 @@ public:
     ~Scheduler();
 
     /// Returns whether there are any threads that are ready to run.
-    bool HaveReadyThreads() const;
+    bool HaveReadyThreads();
 
     /// Reschedules to the next available thread (call after current thread is suspended)
     void Reschedule();

src/core/hle/kernel/server_session.cpp

@@ -71,14 +71,6 @@ ResultCode ServerSession::HandleDomainSyncRequest(Kernel::HLERequestContext& con
         const u32 object_id{context.GetDomainMessageHeader()->object_id};
         switch (domain_message_header->command) {
         case IPC::DomainMessageHeader::CommandType::SendMessage:
-            if (object_id > domain_request_handlers.size()) {
-                LOG_CRITICAL(IPC,
-                             "object_id {} is too big! This probably means a recent service call "
-                             "to {} needed to return a new interface!",
-                             object_id, name);
-                UNREACHABLE();
-                return RESULT_SUCCESS; // Ignore error if asserts are off
-            }
             return domain_request_handlers[object_id - 1]->HandleSyncRequest(context);
 
         case IPC::DomainMessageHeader::CommandType::CloseVirtualHandle: {
@@ -152,7 +144,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);
 }
 
@@ -535,6 +532,7 @@ static ResultCode CreateThread(Handle* out_handle, VAddr entry_point, u64 arg, V
     CASCADE_RESULT(thread->guest_handle, g_handle_table.Create(thread));
     *out_handle = thread->guest_handle;
 
+    Core::System::GetInstance().PrepareReschedule();
     Core::System::GetInstance().CpuCore(thread->processor_id).PrepareReschedule();
 
     LOG_TRACE(Kernel_SVC,
@@ -708,7 +706,8 @@ static ResultCode SignalProcessWideKey(VAddr condition_variable_addr, s32 target
             Handle owner_handle = static_cast<Handle>(mutex_val & Mutex::MutexOwnerMask);
             auto owner = g_handle_table.Get<Thread>(owner_handle);
             ASSERT(owner);
-            ASSERT(thread->status == ThreadStatus::WaitMutex);
+            ASSERT(thread->status != ThreadStatus::Running);
+            thread->status = ThreadStatus::WaitMutex;
             thread->wakeup_callback = nullptr;
 
             owner->AddMutexWaiter(thread);

src/core/hle/kernel/thread.cpp

@@ -23,7 +23,6 @@
 #include "core/hle/kernel/object.h"
 #include "core/hle/kernel/process.h"
 #include "core/hle/kernel/thread.h"
-#include "core/hle/lock.h"
 #include "core/hle/result.h"
 #include "core/memory.h"
 
@@ -105,10 +104,6 @@ void ExitCurrentThread() {
  */
 static void ThreadWakeupCallback(u64 thread_handle, int cycles_late) {
     const auto proper_handle = static_cast<Handle>(thread_handle);
-
-    // Lock the global kernel mutex when we enter the kernel HLE.
-    std::lock_guard<std::recursive_mutex> lock(HLE::g_hle_lock);
-
     SharedPtr<Thread> thread = wakeup_callback_handle_table.Get<Thread>(proper_handle);
     if (thread == nullptr) {
         LOG_CRITICAL(Kernel, "Callback fired for invalid thread {:08X}", proper_handle);
@@ -160,14 +155,12 @@ void Thread::WakeAfterDelay(s64 nanoseconds) {
     if (nanoseconds == -1)
         return;
 
-    // This function might be called from any thread so we have to be cautious and use the
-    // thread-safe version of ScheduleEvent.
-    CoreTiming::ScheduleEventThreadsafe(CoreTiming::nsToCycles(nanoseconds), ThreadWakeupEventType,
-                                        callback_handle);
+    CoreTiming::ScheduleEvent(CoreTiming::nsToCycles(nanoseconds), ThreadWakeupEventType,
+                              callback_handle);
 }
 
 void Thread::CancelWakeupTimer() {
-    CoreTiming::UnscheduleEventThreadsafe(ThreadWakeupEventType, callback_handle);
+    CoreTiming::UnscheduleEvent(ThreadWakeupEventType, callback_handle);
 }
 
 static boost::optional<s32> GetNextProcessorId(u64 mask) {
@@ -426,33 +419,12 @@ VAddr Thread::GetCommandBufferAddress() const {
 }
 
 void Thread::AddMutexWaiter(SharedPtr<Thread> thread) {
-    if (thread->lock_owner == this) {
-        // If the thread is already waiting for this thread to release the mutex, ensure that the
-        // waiters list is consistent and return without doing anything.
-        auto itr = std::find(wait_mutex_threads.begin(), wait_mutex_threads.end(), thread);
-        ASSERT(itr != wait_mutex_threads.end());
-        return;
-    }
-
-    // A thread can't wait on two different mutexes at the same time.
-    ASSERT(thread->lock_owner == nullptr);
-
-    // Ensure that the thread is not already in the list of mutex waiters
-    auto itr = std::find(wait_mutex_threads.begin(), wait_mutex_threads.end(), thread);
-    ASSERT(itr == wait_mutex_threads.end());
-
     thread->lock_owner = this;
     wait_mutex_threads.emplace_back(std::move(thread));
     UpdatePriority();
 }
 
 void Thread::RemoveMutexWaiter(SharedPtr<Thread> thread) {
-    ASSERT(thread->lock_owner == this);
-
-    // Ensure that the thread is in the list of mutex waiters
-    auto itr = std::find(wait_mutex_threads.begin(), wait_mutex_threads.end(), thread);
-    ASSERT(itr != wait_mutex_threads.end());
-
     boost::remove_erase(wait_mutex_threads, thread);
     thread->lock_owner = nullptr;
     UpdatePriority();

src/core/hle/romfs.cpp

@@ -0,0 +1,102 @@
+// Copyright 2017 Citra Emulator Project
+// Licensed under GPLv2 or any later version
+// Refer to the license.txt file included.
+
+#include <cstring>
+#include "common/swap.h"
+#include "core/hle/romfs.h"
+
+namespace RomFS {
+
+struct Header {
+    u32_le header_length;
+    u32_le dir_hash_table_offset;
+    u32_le dir_hash_table_length;
+    u32_le dir_table_offset;
+    u32_le dir_table_length;
+    u32_le file_hash_table_offset;
+    u32_le file_hash_table_length;
+    u32_le file_table_offset;
+    u32_le file_table_length;
+    u32_le data_offset;
+};
+
+static_assert(sizeof(Header) == 0x28, "Header has incorrect size");
+
+struct DirectoryMetadata {
+    u32_le parent_dir_offset;
+    u32_le next_dir_offset;
+    u32_le first_child_dir_offset;
+    u32_le first_file_offset;
+    u32_le same_hash_next_dir_offset;
+    u32_le name_length; // in bytes
+    // followed by directory name
+};
+
+static_assert(sizeof(DirectoryMetadata) == 0x18, "DirectoryMetadata has incorrect size");
+
+struct FileMetadata {
+    u32_le parent_dir_offset;
+    u32_le next_file_offset;
+    u64_le data_offset;
+    u64_le data_length;
+    u32_le same_hash_next_file_offset;
+    u32_le name_length; // in bytes
+    // followed by file name
+};
+
+static_assert(sizeof(FileMetadata) == 0x20, "FileMetadata has incorrect size");
+
+static bool MatchName(const u8* buffer, u32 name_length, const std::u16string& name) {
+    std::vector<char16_t> name_buffer(name_length / sizeof(char16_t));
+    std::memcpy(name_buffer.data(), buffer, name_length);
+    return name == std::u16string(name_buffer.begin(), name_buffer.end());
+}
+
+const u8* GetFilePointer(const u8* romfs, const std::vector<std::u16string>& path) {
+    constexpr u32 INVALID_FIELD = 0xFFFFFFFF;
+
+    // Split path into directory names and file name
+    std::vector<std::u16string> dir_names = path;
+    dir_names.pop_back();
+    const std::u16string& file_name = path.back();
+
+    Header header;
+    std::memcpy(&header, romfs, sizeof(header));
+
+    // Find directories of each level
+    DirectoryMetadata dir;
+    const u8* current_dir = romfs + header.dir_table_offset;
+    std::memcpy(&dir, current_dir, sizeof(dir));
+    for (const std::u16string& dir_name : dir_names) {
+        u32 child_dir_offset;
+        child_dir_offset = dir.first_child_dir_offset;
+        while (true) {
+            if (child_dir_offset == INVALID_FIELD) {
+                return nullptr;
+            }
+            const u8* current_child_dir = romfs + header.dir_table_offset + child_dir_offset;
+            std::memcpy(&dir, current_child_dir, sizeof(dir));
+            if (MatchName(current_child_dir + sizeof(dir), dir.name_length, dir_name)) {
+                current_dir = current_child_dir;
+                break;
+            }
+            child_dir_offset = dir.next_dir_offset;
+        }
+    }
+
+    // Find the file
+    FileMetadata file;
+    u32 file_offset = dir.first_file_offset;
+    while (file_offset != INVALID_FIELD) {
+        const u8* current_file = romfs + header.file_table_offset + file_offset;
+        std::memcpy(&file, current_file, sizeof(file));
+        if (MatchName(current_file + sizeof(file), file.name_length, file_name)) {
+            return romfs + header.data_offset + file.data_offset;
+        }
+        file_offset = file.next_file_offset;
+    }
+    return nullptr;
+}
+
+} // namespace RomFS

src/core/hle/romfs.h

@@ -0,0 +1,22 @@
+// Copyright 2017 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"
+
+namespace RomFS {
+
+/**
+ * Gets the pointer to a file in a RomFS image.
+ * @param romfs The pointer to the RomFS image
+ * @param path A vector containing the directory names and file name of the path to the file
+ * @return the pointer to the file
+ * @todo reimplement this with a full RomFS manager
+ */
+const u8* GetFilePointer(const u8* romfs, const std::vector<std::u16string>& path);
+
+} // namespace RomFS

src/core/hle/service/acc/acc.cpp

@@ -42,7 +42,7 @@ public:
             {0, &IProfile::Get, "Get"},
             {1, &IProfile::GetBase, "GetBase"},
             {10, nullptr, "GetImageSize"},
-            {11, &IProfile::LoadImage, "LoadImage"},
+            {11, nullptr, "LoadImage"},
         };
         RegisterHandlers(functions);
     }
@@ -83,27 +83,6 @@ private:
         rb.PushRaw(profile_base);
     }
 
-    void LoadImage(Kernel::HLERequestContext& ctx) {
-        LOG_WARNING(Service_ACC, "(STUBBED) called");
-        // smallest jpeg https://github.com/mathiasbynens/small/blob/master/jpeg.jpg
-        // TODO(mailwl): load actual profile image from disk, width 256px, max size 0x20000
-        const u32 jpeg_size = 107;
-        static const std::array<u8, jpeg_size> jpeg{
-            0xff, 0xd8, 0xff, 0xdb, 0x00, 0x43, 0x00, 0x03, 0x02, 0x02, 0x02, 0x02, 0x02, 0x03,
-            0x02, 0x02, 0x02, 0x03, 0x03, 0x03, 0x03, 0x04, 0x06, 0x04, 0x04, 0x04, 0x04, 0x04,
-            0x08, 0x06, 0x06, 0x05, 0x06, 0x09, 0x08, 0x0a, 0x0a, 0x09, 0x08, 0x09, 0x09, 0x0a,
-            0x0c, 0x0f, 0x0c, 0x0a, 0x0b, 0x0e, 0x0b, 0x09, 0x09, 0x0d, 0x11, 0x0d, 0x0e, 0x0f,
-            0x10, 0x10, 0x11, 0x10, 0x0a, 0x0c, 0x12, 0x13, 0x12, 0x10, 0x13, 0x0f, 0x10, 0x10,
-            0x10, 0xff, 0xc9, 0x00, 0x0b, 0x08, 0x00, 0x01, 0x00, 0x01, 0x01, 0x01, 0x11, 0x00,
-            0xff, 0xcc, 0x00, 0x06, 0x00, 0x10, 0x10, 0x05, 0xff, 0xda, 0x00, 0x08, 0x01, 0x01,
-            0x00, 0x00, 0x3f, 0x00, 0xd2, 0xcf, 0x20, 0xff, 0xd9,
-        };
-        ctx.WriteBuffer(jpeg.data(), jpeg_size);
-        IPC::ResponseBuilder rb{ctx, 3};
-        rb.Push(RESULT_SUCCESS);
-        rb.Push<u32>(jpeg_size);
-    }
-
     u128 user_id; ///< The user id this profile refers to.
 };
 

src/core/hle/service/acc/acc_su.cpp

@@ -8,7 +8,7 @@ namespace Service::Account {
 
 ACC_SU::ACC_SU(std::shared_ptr<Module> module) : Module::Interface(std::move(module), "acc:su") {
     static const FunctionInfo functions[] = {
-        {0, &ACC_SU::GetUserCount, "GetUserCount"},
+        {0, nullptr, "GetUserCount"},
         {1, &ACC_SU::GetUserExistence, "GetUserExistence"},
         {2, &ACC_SU::ListAllUsers, "ListAllUsers"},
         {3, &ACC_SU::ListOpenUsers, "ListOpenUsers"},

src/core/hle/service/acc/acc_u1.cpp

@@ -8,7 +8,7 @@ namespace Service::Account {
 
 ACC_U1::ACC_U1(std::shared_ptr<Module> module) : Module::Interface(std::move(module), "acc:u1") {
     static const FunctionInfo functions[] = {
-        {0, &ACC_U1::GetUserCount, "GetUserCount"},
+        {0, nullptr, "GetUserCount"},
         {1, &ACC_U1::GetUserExistence, "GetUserExistence"},
         {2, &ACC_U1::ListAllUsers, "ListAllUsers"},
         {3, &ACC_U1::ListOpenUsers, "ListOpenUsers"},

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

@@ -136,7 +136,7 @@ ISelfController::ISelfController(std::shared_ptr<NVFlinger::NVFlinger> nvflinger
         {16, &ISelfController::SetOutOfFocusSuspendingEnabled, "SetOutOfFocusSuspendingEnabled"},
         {17, nullptr, "SetControllerFirmwareUpdateSection"},
         {18, nullptr, "SetRequiresCaptureButtonShortPressedMessage"},
-        {19, &ISelfController::SetScreenShotImageOrientation, "SetScreenShotImageOrientation"},
+        {19, nullptr, "SetScreenShotImageOrientation"},
         {20, nullptr, "SetDesirableKeyboardLayout"},
         {40, &ISelfController::CreateManagedDisplayLayer, "CreateManagedDisplayLayer"},
         {41, nullptr, "IsSystemBufferSharingEnabled"},
@@ -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"},
@@ -254,13 +254,6 @@ void ISelfController::GetLibraryAppletLaunchableEvent(Kernel::HLERequestContext&
     LOG_WARNING(Service_AM, "(STUBBED) called");
 }
 
-void ISelfController::SetScreenShotImageOrientation(Kernel::HLERequestContext& ctx) {
-    IPC::ResponseBuilder rb{ctx, 2};
-    rb.Push(RESULT_SUCCESS);
-
-    LOG_WARNING(Service_AM, "(STUBBED) called");
-}
-
 void ISelfController::CreateManagedDisplayLayer(Kernel::HLERequestContext& ctx) {
     // TODO(Subv): Find out how AM determines the display to use, for now just create the layer
     // in the Default display.
@@ -281,23 +274,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 +299,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 +334,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

@@ -83,16 +83,12 @@ private:
     void LockExit(Kernel::HLERequestContext& ctx);
     void UnlockExit(Kernel::HLERequestContext& ctx);
     void GetLibraryAppletLaunchableEvent(Kernel::HLERequestContext& ctx);
-    void SetScreenShotImageOrientation(Kernel::HLERequestContext& ctx);
     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 +109,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/audio/audren_u.cpp

@@ -20,9 +20,9 @@ public:
     explicit IAudioRenderer(AudioCore::AudioRendererParameter audren_params)
         : ServiceFramework("IAudioRenderer") {
         static const FunctionInfo functions[] = {
-            {0, &IAudioRenderer::GetAudioRendererSampleRate, "GetAudioRendererSampleRate"},
-            {1, &IAudioRenderer::GetAudioRendererSampleCount, "GetAudioRendererSampleCount"},
-            {2, &IAudioRenderer::GetAudioRendererMixBufferCount, "GetAudioRendererMixBufferCount"},
+            {0, nullptr, "GetAudioRendererSampleRate"},
+            {1, nullptr, "GetAudioRendererSampleCount"},
+            {2, nullptr, "GetAudioRendererMixBufferCount"},
             {3, nullptr, "GetAudioRendererState"},
             {4, &IAudioRenderer::RequestUpdateAudioRenderer, "RequestUpdateAudioRenderer"},
             {5, &IAudioRenderer::StartAudioRenderer, "StartAudioRenderer"},
@@ -45,27 +45,6 @@ private:
         system_event->Signal();
     }
 
-    void GetAudioRendererSampleRate(Kernel::HLERequestContext& ctx) {
-        IPC::ResponseBuilder rb{ctx, 3};
-        rb.Push(RESULT_SUCCESS);
-        rb.Push<u32>(renderer->GetSampleRate());
-        LOG_DEBUG(Service_Audio, "called");
-    }
-
-    void GetAudioRendererSampleCount(Kernel::HLERequestContext& ctx) {
-        IPC::ResponseBuilder rb{ctx, 3};
-        rb.Push(RESULT_SUCCESS);
-        rb.Push<u32>(renderer->GetSampleCount());
-        LOG_DEBUG(Service_Audio, "called");
-    }
-
-    void GetAudioRendererMixBufferCount(Kernel::HLERequestContext& ctx) {
-        IPC::ResponseBuilder rb{ctx, 3};
-        rb.Push(RESULT_SUCCESS);
-        rb.Push<u32>(renderer->GetMixBufferCount());
-        LOG_DEBUG(Service_Audio, "called");
-    }
-
     void RequestUpdateAudioRenderer(Kernel::HLERequestContext& ctx) {
         ctx.WriteBuffer(renderer->UpdateAudioRenderer(ctx.ReadBuffer()));
         IPC::ResponseBuilder rb{ctx, 2};
@@ -190,8 +169,7 @@ AudRenU::AudRenU() : ServiceFramework("audren:u") {
         {1, &AudRenU::GetAudioRendererWorkBufferSize, "GetAudioRendererWorkBufferSize"},
         {2, &AudRenU::GetAudioDevice, "GetAudioDevice"},
         {3, nullptr, "OpenAudioRendererAuto"},
-        {4, &AudRenU::GetAudioDeviceServiceWithRevisionInfo,
-         "GetAudioDeviceServiceWithRevisionInfo"},
+        {4, nullptr, "GetAudioDeviceServiceWithRevisionInfo"},
     };
     RegisterHandlers(functions);
 }
@@ -211,7 +189,7 @@ void AudRenU::GetAudioRendererWorkBufferSize(Kernel::HLERequestContext& ctx) {
     IPC::RequestParser rp{ctx};
     auto params = rp.PopRaw<AudioCore::AudioRendererParameter>();
 
-    u64 buffer_sz = Common::AlignUp(4 * params.mix_buffer_count, 0x40);
+    u64 buffer_sz = Common::AlignUp(4 * params.unknown_8, 0x40);
     buffer_sz += params.unknown_c * 1024;
     buffer_sz += 0x940 * (params.unknown_c + 1);
     buffer_sz += 0x3F0 * params.voice_count;
@@ -219,7 +197,7 @@ void AudRenU::GetAudioRendererWorkBufferSize(Kernel::HLERequestContext& ctx) {
     buffer_sz += Common::AlignUp(8 * params.voice_count, 0x10);
     buffer_sz +=
         Common::AlignUp((0x3C0 * (params.sink_count + params.unknown_c) + 4 * params.sample_count) *
-                            (params.mix_buffer_count + 6),
+                            (params.unknown_8 + 6),
                         0x40);
 
     if (IsFeatureSupported(AudioFeatures::Splitter, params.revision)) {
@@ -275,16 +253,6 @@ void AudRenU::GetAudioDevice(Kernel::HLERequestContext& ctx) {
     LOG_DEBUG(Service_Audio, "called");
 }
 
-void AudRenU::GetAudioDeviceServiceWithRevisionInfo(Kernel::HLERequestContext& ctx) {
-    IPC::ResponseBuilder rb{ctx, 2, 0, 1};
-
-    rb.Push(RESULT_SUCCESS);
-    rb.PushIpcInterface<Audio::IAudioDevice>();
-
-    LOG_WARNING(Service_Audio, "(STUBBED) called"); // TODO(ogniK): Figure out what is different
-                                                    // based on the current revision
-}
-
 bool AudRenU::IsFeatureSupported(AudioFeatures feature, u32_le revision) const {
     u32_be version_num = (revision - Common::MakeMagic('R', 'E', 'V', '0')); // Byte swap
     switch (feature) {

src/core/hle/service/audio/audren_u.h

@@ -22,7 +22,6 @@ private:
     void OpenAudioRenderer(Kernel::HLERequestContext& ctx);
     void GetAudioRendererWorkBufferSize(Kernel::HLERequestContext& ctx);
     void GetAudioDevice(Kernel::HLERequestContext& ctx);
-    void GetAudioDeviceServiceWithRevisionInfo(Kernel::HLERequestContext& ctx);
 
     enum class AudioFeatures : u32 {
         Splitter,

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

@@ -59,7 +59,7 @@ ResultCode VfsDirectoryServiceWrapper::CreateFile(const std::string& path_, u64
 ResultCode VfsDirectoryServiceWrapper::DeleteFile(const std::string& path_) const {
     std::string path(FileUtil::SanitizePath(path_));
     auto dir = GetDirectoryRelativeWrapped(backing, FileUtil::GetParentPath(path));
-    if (path.empty()) {
+    if (path == "/" || path == "\\") {
         // TODO(DarkLordZach): Why do games call this and what should it do? Works as is but...
         return RESULT_SUCCESS;
     }
@@ -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,13 +248,6 @@ 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> OpenRomFS(u64 title_id) {
     LOG_TRACE(Service_FS, "Opening RomFS for title_id={:016X}", title_id);
 
@@ -289,26 +281,15 @@ 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) {
+void RegisterFileSystems() {
     romfs_factory = nullptr;
     save_data_factory = nullptr;
     sdmc_factory = nullptr;
 
-    auto nand_directory = vfs->OpenDirectory(FileUtil::GetUserPath(FileUtil::UserPath::NANDDir),
-                                             FileSys::Mode::ReadWrite);
-    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 nand_directory = std::make_shared<FileSys::RealVfsDirectory>(
+        FileUtil::GetUserPath(FileUtil::UserPath::NANDDir), FileSys::Mode::ReadWrite);
+    auto sd_directory = std::make_shared<FileSys::RealVfsDirectory>(
+        FileUtil::GetUserPath(FileUtil::UserPath::SDMCDir), FileSys::Mode::ReadWrite);
 
     auto savedata = std::make_unique<FileSys::SaveDataFactory>(std::move(nand_directory));
     save_data_factory = std::move(savedata);
@@ -317,8 +298,8 @@ void RegisterFileSystems(const FileSys::VirtualFilesystem& vfs) {
     sdmc_factory = std::move(sdcard);
 }
 
-void InstallInterfaces(SM::ServiceManager& service_manager, const FileSys::VirtualFilesystem& vfs) {
-    RegisterFileSystems(vfs);
+void InstallInterfaces(SM::ServiceManager& service_manager) {
+    RegisterFileSystems();
     std::make_shared<FSP_LDR>()->InstallAsService(service_manager);
     std::make_shared<FSP_PR>()->InstallAsService(service_manager);
     std::make_shared<FSP_SRV>()->InstallAsService(service_manager);

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,18 +24,19 @@ 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);
 
+// 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);
+void InstallInterfaces(SM::ServiceManager& service_manager);
 
 // A class that wraps a VfsDirectory with methods that return ResultVal and ResultCode instead of
 // pointers and booleans. This makes using a VfsDirectory with switch services much easier and

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

@@ -193,10 +193,13 @@ private:
 template <typename T>
 static void BuildEntryIndex(std::vector<FileSys::Entry>& entries, const std::vector<T>& new_data,
                             FileSys::EntryType type) {
-    entries.reserve(entries.size() + new_data.size());
-
     for (const auto& new_entry : new_data) {
-        entries.emplace_back(new_entry->GetName(), type, new_entry->GetSize());
+        FileSys::Entry entry;
+        entry.filename[0] = '\0';
+        std::strncat(entry.filename, new_entry->GetName().c_str(), FileSys::FILENAME_LENGTH - 1);
+        entry.type = type;
+        entry.file_size = new_entry->GetSize();
+        entries.emplace_back(std::move(entry));
     }
 }
 

src/core/hle/service/friend/friend.cpp

@@ -9,110 +9,10 @@
 
 namespace Service::Friend {
 
-class IFriendService final : public ServiceFramework<IFriendService> {
-public:
-    IFriendService() : ServiceFramework("IFriendService") {
-        static const FunctionInfo functions[] = {
-            {0, nullptr, "GetCompletionEvent"},
-            {1, nullptr, "Cancel"},
-            {10100, nullptr, "GetFriendListIds"},
-            {10101, nullptr, "GetFriendList"},
-            {10102, nullptr, "UpdateFriendInfo"},
-            {10110, nullptr, "GetFriendProfileImage"},
-            {10200, nullptr, "SendFriendRequestForApplication"},
-            {10211, nullptr, "AddFacedFriendRequestForApplication"},
-            {10400, nullptr, "GetBlockedUserListIds"},
-            {10500, nullptr, "GetProfileList"},
-            {10600, nullptr, "DeclareOpenOnlinePlaySession"},
-            {10601, &IFriendService::DeclareCloseOnlinePlaySession,
-             "DeclareCloseOnlinePlaySession"},
-            {10610, &IFriendService::UpdateUserPresence, "UpdateUserPresence"},
-            {10700, nullptr, "GetPlayHistoryRegistrationKey"},
-            {10701, nullptr, "GetPlayHistoryRegistrationKeyWithNetworkServiceAccountId"},
-            {10702, nullptr, "AddPlayHistory"},
-            {11000, nullptr, "GetProfileImageUrl"},
-            {20100, nullptr, "GetFriendCount"},
-            {20101, nullptr, "GetNewlyFriendCount"},
-            {20102, nullptr, "GetFriendDetailedInfo"},
-            {20103, nullptr, "SyncFriendList"},
-            {20104, nullptr, "RequestSyncFriendList"},
-            {20110, nullptr, "LoadFriendSetting"},
-            {20200, nullptr, "GetReceivedFriendRequestCount"},
-            {20201, nullptr, "GetFriendRequestList"},
-            {20300, nullptr, "GetFriendCandidateList"},
-            {20301, nullptr, "GetNintendoNetworkIdInfo"},
-            {20302, nullptr, "GetSnsAccountLinkage"},
-            {20303, nullptr, "GetSnsAccountProfile"},
-            {20304, nullptr, "GetSnsAccountFriendList"},
-            {20400, nullptr, "GetBlockedUserList"},
-            {20401, nullptr, "SyncBlockedUserList"},
-            {20500, nullptr, "GetProfileExtraList"},
-            {20501, nullptr, "GetRelationship"},
-            {20600, nullptr, "GetUserPresenceView"},
-            {20700, nullptr, "GetPlayHistoryList"},
-            {20701, nullptr, "GetPlayHistoryStatistics"},
-            {20800, nullptr, "LoadUserSetting"},
-            {20801, nullptr, "SyncUserSetting"},
-            {20900, nullptr, "RequestListSummaryOverlayNotification"},
-            {21000, nullptr, "GetExternalApplicationCatalog"},
-            {30100, nullptr, "DropFriendNewlyFlags"},
-            {30101, nullptr, "DeleteFriend"},
-            {30110, nullptr, "DropFriendNewlyFlag"},
-            {30120, nullptr, "ChangeFriendFavoriteFlag"},
-            {30121, nullptr, "ChangeFriendOnlineNotificationFlag"},
-            {30200, nullptr, "SendFriendRequest"},
-            {30201, nullptr, "SendFriendRequestWithApplicationInfo"},
-            {30202, nullptr, "CancelFriendRequest"},
-            {30203, nullptr, "AcceptFriendRequest"},
-            {30204, nullptr, "RejectFriendRequest"},
-            {30205, nullptr, "ReadFriendRequest"},
-            {30210, nullptr, "GetFacedFriendRequestRegistrationKey"},
-            {30211, nullptr, "AddFacedFriendRequest"},
-            {30212, nullptr, "CancelFacedFriendRequest"},
-            {30213, nullptr, "GetFacedFriendRequestProfileImage"},
-            {30214, nullptr, "GetFacedFriendRequestProfileImageFromPath"},
-            {30215, nullptr, "SendFriendRequestWithExternalApplicationCatalogId"},
-            {30216, nullptr, "ResendFacedFriendRequest"},
-            {30217, nullptr, "SendFriendRequestWithNintendoNetworkIdInfo"},
-            {30300, nullptr, "GetSnsAccountLinkPageUrl"},
-            {30301, nullptr, "UnlinkSnsAccount"},
-            {30400, nullptr, "BlockUser"},
-            {30401, nullptr, "BlockUserWithApplicationInfo"},
-            {30402, nullptr, "UnblockUser"},
-            {30500, nullptr, "GetProfileExtraFromFriendCode"},
-            {30700, nullptr, "DeletePlayHistory"},
-            {30810, nullptr, "ChangePresencePermission"},
-            {30811, nullptr, "ChangeFriendRequestReception"},
-            {30812, nullptr, "ChangePlayLogPermission"},
-            {30820, nullptr, "IssueFriendCode"},
-            {30830, nullptr, "ClearPlayLog"},
-            {49900, nullptr, "DeleteNetworkServiceAccountCache"},
-        };
-
-        RegisterHandlers(functions);
-    }
-
-private:
-    void DeclareCloseOnlinePlaySession(Kernel::HLERequestContext& ctx) {
-        // Stub used by Splatoon 2
-        LOG_WARNING(Service_ACC, "(STUBBED) called");
-        IPC::ResponseBuilder rb{ctx, 2};
-        rb.Push(RESULT_SUCCESS);
-    }
-
-    void UpdateUserPresence(Kernel::HLERequestContext& ctx) {
-        // Stub used by Retro City Rampage
-        LOG_WARNING(Service_ACC, "(STUBBED) called");
-        IPC::ResponseBuilder rb{ctx, 2};
-        rb.Push(RESULT_SUCCESS);
-    }
-};
-
 void Module::Interface::CreateFriendService(Kernel::HLERequestContext& ctx) {
-    IPC::ResponseBuilder rb{ctx, 2, 0, 1};
+    IPC::ResponseBuilder rb{ctx, 2};
     rb.Push(RESULT_SUCCESS);
-    rb.PushIpcInterface<IFriendService>();
-    LOG_DEBUG(Service_ACC, "called");
+    LOG_WARNING(Service_Friend, "(STUBBED) called");
 }
 
 Module::Interface::Interface(std::shared_ptr<Module> module, const char* name)

src/core/hle/service/hid/hid.cpp

@@ -291,7 +291,6 @@ private:
 class Hid final : public ServiceFramework<Hid> {
 public:
     Hid() : ServiceFramework("hid") {
-        // clang-format off
         static const FunctionInfo functions[] = {
             {0, &Hid::CreateAppletResource, "CreateAppletResource"},
             {1, &Hid::ActivateDebugPad, "ActivateDebugPad"},
@@ -334,13 +333,15 @@ public:
             {102, &Hid::SetSupportedNpadIdType, "SetSupportedNpadIdType"},
             {103, &Hid::ActivateNpad, "ActivateNpad"},
             {104, nullptr, "DeactivateNpad"},
-            {106, &Hid::AcquireNpadStyleSetUpdateEventHandle, "AcquireNpadStyleSetUpdateEventHandle"},
-            {107, &Hid::DisconnectNpad, "DisconnectNpad"},
+            {106, &Hid::AcquireNpadStyleSetUpdateEventHandle,
+             "AcquireNpadStyleSetUpdateEventHandle"},
+            {107, nullptr, "DisconnectNpad"},
             {108, &Hid::GetPlayerLedPattern, "GetPlayerLedPattern"},
             {109, nullptr, "ActivateNpadWithRevision"},
             {120, &Hid::SetNpadJoyHoldType, "SetNpadJoyHoldType"},
             {121, &Hid::GetNpadJoyHoldType, "GetNpadJoyHoldType"},
-            {122, &Hid::SetNpadJoyAssignmentModeSingleByDefault, "SetNpadJoyAssignmentModeSingleByDefault"},
+            {122, &Hid::SetNpadJoyAssignmentModeSingleByDefault,
+             "SetNpadJoyAssignmentModeSingleByDefault"},
             {123, nullptr, "SetNpadJoyAssignmentModeSingleByDefault"},
             {124, &Hid::SetNpadJoyAssignmentModeDual, "SetNpadJoyAssignmentModeDual"},
             {125, &Hid::MergeSingleJoyAsDualJoy, "MergeSingleJoyAsDualJoy"},
@@ -397,8 +398,6 @@ public:
             {1000, nullptr, "SetNpadCommunicationMode"},
             {1001, nullptr, "GetNpadCommunicationMode"},
         };
-        // clang-format on
-
         RegisterHandlers(functions);
 
         event = Kernel::Event::Create(Kernel::ResetType::OneShot, "hid:EventHandle");
@@ -458,7 +457,7 @@ private:
     }
 
     void IsSixAxisSensorAtRest(Kernel::HLERequestContext& ctx) {
-        IPC::ResponseBuilder rb{ctx, 3};
+        IPC::ResponseBuilder rb{ctx, 2};
         rb.Push(RESULT_SUCCESS);
         // TODO (Hexagon12): Properly implement reading gyroscope values from controllers.
         rb.Push(true);
@@ -497,12 +496,6 @@ private:
         LOG_WARNING(Service_HID, "(STUBBED) called");
     }
 
-    void DisconnectNpad(Kernel::HLERequestContext& ctx) {
-        IPC::ResponseBuilder rb{ctx, 2};
-        rb.Push(RESULT_SUCCESS);
-        LOG_WARNING(Service_HID, "(STUBBED) called");
-    }
-
     void GetPlayerLedPattern(Kernel::HLERequestContext& ctx) {
         IPC::ResponseBuilder rb{ctx, 2};
         rb.Push(RESULT_SUCCESS);

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