Merge 309384da88 into 2b06301dbf

XCI and Encrypted NCA Support

.gitignore

@@ -11,6 +11,7 @@ src/common/scm_rev.cpp
 .idea/
 .vs/
 .vscode/
+CMakeLists.txt.user*
 
 # *nix related
 # Common convention for backup or temporary files

.gitmodules

@@ -7,6 +7,9 @@
 [submodule "catch"]
     path = externals/catch
     url = https://github.com/philsquared/Catch.git
+[submodule "cubeb"]
+    path = externals/cubeb
+    url = https://github.com/kinetiknz/cubeb.git
 [submodule "dynarmic"]
     path = externals/dynarmic
     url = https://github.com/MerryMage/dynarmic.git
@@ -22,3 +25,9 @@
 [submodule "unicorn"]
     path = externals/unicorn
     url = https://github.com/yuzu-emu/unicorn
+[submodule "mbedtls"]
+    path = externals/mbedtls
+    url = https://github.com/DarkLordZach/mbedtls
+[submodule "opus"]
+    path = externals/opus
+    url = https://github.com/ogniK5377/opus.git

CMakeLists.txt

@@ -17,6 +17,8 @@ CMAKE_DEPENDENT_OPTION(YUZU_USE_BUNDLED_QT "Download bundled Qt binaries" ON "EN
 
 option(YUZU_USE_BUNDLED_UNICORN "Build/Download bundled Unicorn" ON)
 
+option(ENABLE_CUBEB "Enables the cubeb audio backend" ON)
+
 if(NOT EXISTS ${CMAKE_SOURCE_DIR}/.git/hooks/pre-commit)
     message(STATUS "Copying pre-commit hook")
     file(COPY hooks/pre-commit

CMakeModules/CopyYuzuQt5Deps.cmake

@@ -3,7 +3,9 @@ function(copy_yuzu_Qt5_deps target_dir)
     set(DLL_DEST "${CMAKE_BINARY_DIR}/bin/$<CONFIG>/")
     set(Qt5_DLL_DIR "${Qt5_DIR}/../../../bin")
     set(Qt5_PLATFORMS_DIR "${Qt5_DIR}/../../../plugins/platforms/")
+    set(Qt5_STYLES_DIR "${Qt5_DIR}/../../../plugins/styles/")
     set(PLATFORMS ${DLL_DEST}platforms/)
+    set(STYLES ${DLL_DEST}styles/)
     windows_copy_files(${target_dir} ${Qt5_DLL_DIR} ${DLL_DEST}
         icudt*.dll
         icuin*.dll
@@ -14,4 +16,5 @@ function(copy_yuzu_Qt5_deps target_dir)
         Qt5Widgets$<$<CONFIG:Debug>:d>.*
     )
     windows_copy_files(yuzu ${Qt5_PLATFORMS_DIR} ${PLATFORMS} qwindows$<$<CONFIG:Debug>:d>.*)
+    windows_copy_files(yuzu ${Qt5_STYLES_DIR} ${STYLES} qwindowsvistastyle$<$<CONFIG:Debug>:d>.*)
 endfunction(copy_yuzu_Qt5_deps)

CONTRIBUTING.md

@@ -1,6 +1,6 @@
 # Reporting Issues
 
-**The issue tracker is not a support forum.** Unless you can provide precise *technical information* regarding an issue, you *should not post in it*. If you need support, first read the [FAQ](https://github.com/yuzu-emu/yuzu/wiki/FAQ) and then either visit our Discord server, [our forum](https://community.citra-emu.org) or ask in a general emulation forum such as [/r/emulation](https://www.reddit.com/r/emulation/). If you post support questions, generic messages to the developers or vague reports without technical details, they will be closed and locked.
+**The issue tracker is not a support forum.** Unless you can provide precise *technical information* regarding an issue, you *should not post in it*. If you need support, first read the [FAQ](https://github.com/yuzu-emu/yuzu/wiki/FAQ) and then either visit our [Discord server](https://discordapp.com/invite/u77vRWY), [our forum](https://community.citra-emu.org) or ask in a general emulation forum such as [/r/emulation](https://www.reddit.com/r/emulation/). If you post support questions, generic messages to the developers or vague reports without technical details, they will be closed and locked.
 
 If you believe you have a valid issue report, please post text or a screenshot from the log (the console window that opens alongside yuzu) and build version (hex string visible in the titlebar and zip filename), as well as your hardware and software information if applicable.
 

appveyor.yml

@@ -116,6 +116,7 @@ after_build:
 
           mkdir $RELEASE_DIST
           mkdir $RELEASE_DIST/platforms
+          mkdir $RELEASE_DIST/styles
 
           # 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
@@ -136,6 +137,9 @@ after_build:
           # copy the qt windows plugin dll to platforms
           Copy-Item -path "C:/msys64/mingw64/share/qt5/plugins/platforms/qwindows.dll" -force -destination "$RELEASE_DIST/platforms"
 
+          # 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"
+
           7z a -tzip $MINGW_BUILD_ZIP $RELEASE_DIST\*
           7z a $MINGW_SEVENZIP $RELEASE_DIST
         }

dist/qt_themes/qdarkstyle/LICENSE.md

@@ -0,0 +1,183 @@
+# License
+
+## The MIT License (MIT) - Code
+
+Copyright (c) 2013-2018 Colin Duquesnoy
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.
+
+## Creative Commons Attribution International 4.0 - Images
+
+QDarkStyle (c) 2013-2018 Colin Duquesnoy
+
+Creative Commons Corporation (“Creative Commons”) is not a law firm and does not provide legal services or legal advice. Distribution of Creative Commons public licenses does not create a lawyer-client or other relationship. Creative Commons makes its licenses and related information available on an “as-is” basis. Creative Commons gives no warranties regarding its licenses, any material licensed under their terms and conditions, or any related information. Creative Commons disclaims all liability for damages resulting from their use to the fullest extent possible.
+
+### Using Creative Commons Public Licenses
+
+Creative Commons public licenses provide a standard set of terms and conditions that creators and other rights holders may use to share original works of authorship and other material subject to copyright and certain other rights specified in the public license below. The following considerations are for informational purposes only, are not exhaustive, and do not form part of our licenses.
+
+* __Considerations for licensors:__ Our public licenses are intended for use by those authorized to give the public permission to use material in ways otherwise restricted by copyright and certain other rights. Our licenses are irrevocable. Licensors should read and understand the terms and conditions of the license they choose before applying it. Licensors should also secure all rights necessary before applying our licenses so that the public can reuse the material as expected. Licensors should clearly mark any material not subject to the license. This includes other CC-licensed material, or material used under an exception or limitation to copyright. [More considerations for licensors](http://wiki.creativecommons.org/Considerations_for_licensors_and_licensees#Considerations_for_licensors).
+
+* __Considerations for the public:__ By using one of our public licenses, a licensor grants the public permission to use the licensed material under specified terms and conditions. If the licensor’s permission is not necessary for any reason–for example, because of any applicable exception or limitation to copyright–then that use is not regulated by the license. Our licenses grant only permissions under copyright and certain other rights that a licensor has authority to grant. Use of the licensed material may still be restricted for other reasons, including because others have copyright or other rights in the material. A licensor may make special requests, such as asking that all changes be marked or described. Although not required by our licenses, you are encouraged to respect those requests where reasonable. [More considerations for the public](http://wiki.creativecommons.org/Considerations_for_licensors_and_licensees#Considerations_for_licensees).
+
+## Creative Commons Attribution 4.0 International Public License
+
+By exercising the Licensed Rights (defined below), You accept and agree to be bound by the terms and conditions of this Creative Commons Attribution 4.0 International Public License ("Public License"). To the extent this Public License may be interpreted as a contract, You are granted the Licensed Rights in consideration of Your acceptance of these terms and conditions, and the Licensor grants You such rights in consideration of benefits the Licensor receives from making the Licensed Material available under these terms and conditions.
+
+### Section 1 – Definitions
+
+a. __Adapted Material__ means material subject to Copyright and Similar Rights that is derived from or based upon the Licensed Material and in which the Licensed Material is translated, altered, arranged, transformed, or otherwise modified in a manner requiring permission under the Copyright and Similar Rights held by the Licensor. For purposes of this Public License, where the Licensed Material is a musical work, performance, or sound recording, Adapted Material is always produced where the Licensed Material is synched in timed relation with a moving image.
+
+b. __Adapter's License__ means the license You apply to Your Copyright and Similar Rights in Your contributions to Adapted Material in accordance with the terms and conditions of this Public License.
+
+c. __Copyright and Similar Rights__ means copyright and/or similar rights closely related to copyright including, without limitation, performance, broadcast, sound recording, and Sui Generis Database Rights, without regard to how the rights are labeled or categorized. For purposes of this Public License, the rights specified in Section 2(b)(1)-(2) are not Copyright and Similar Rights.
+
+d. __Effective Technological Measures__ means those measures that, in the absence of proper authority, may not be circumvented under laws fulfilling obligations under Article 11 of the WIPO Copyright Treaty adopted on December 20, 1996, and/or similar international agreements.
+
+e. __Exceptions and Limitations__ means fair use, fair dealing, and/or any other exception or limitation to Copyright and Similar Rights that applies to Your use of the Licensed Material.
+
+f. __Licensed Material__ means the artistic or literary work, database, or other material to which the Licensor applied this Public License.
+
+g. __Licensed Rights__ means the rights granted to You subject to the terms and conditions of this Public License, which are limited to all Copyright and Similar Rights that apply to Your use of the Licensed Material and that the Licensor has authority to license.
+
+h. __Licensor__ means the individual(s) or entity(ies) granting rights under this Public License.
+
+i. __Share__ means to provide material to the public by any means or process that requires permission under the Licensed Rights, such as reproduction, public display, public performance, distribution, dissemination, communication, or importation, and to make material available to the public including in ways that members of the public may access the material from a place and at a time individually chosen by them.
+
+j. __Sui Generis Database Rights__ means rights other than copyright resulting from Directive 96/9/EC of the European Parliament and of the Council of 11 March 1996 on the legal protection of databases, as amended and/or succeeded, as well as other essentially equivalent rights anywhere in the world.
+
+k. __You__ means the individual or entity exercising the Licensed Rights under this Public License. Your has a corresponding meaning.
+
+### Section 2 – Scope
+
+a. ___License grant.___
+
+   1. Subject to the terms and conditions of this Public License, the Licensor hereby grants You a worldwide, royalty-free, non-sublicensable, non-exclusive, irrevocable license to exercise the Licensed Rights in the Licensed Material to:
+
+       A. reproduce and Share the Licensed Material, in whole or in part; and
+
+       B. produce, reproduce, and Share Adapted Material.
+
+   2. __Exceptions and Limitations.__ For the avoidance of doubt, where Exceptions and Limitations apply to Your use, this Public License does not apply, and You do not need to comply with its terms and conditions.
+
+   3. __Term.__ The term of this Public License is specified in Section 6(a).
+
+   4. __Media and formats; technical modifications allowed.__ The Licensor authorizes You to exercise the Licensed Rights in all media and formats whether now known or hereafter created, and to make technical modifications necessary to do so. The Licensor waives and/or agrees not to assert any right or authority to forbid You from making technical modifications necessary to exercise the Licensed Rights, including technical modifications necessary to circumvent Effective Technological Measures. For purposes of this Public License, simply making modifications authorized by this Section 2(a)(4) never produces Adapted Material.
+
+   5. __Downstream recipients.__
+
+       A. __Offer from the Licensor – Licensed Material.__ Every recipient of the Licensed Material automatically receives an offer from the Licensor to exercise the Licensed Rights under the terms and conditions of this Public License.
+
+       B. __No downstream restrictions.__ You may not offer or impose any additional or different terms or conditions on, or apply any Effective Technological Measures to, the Licensed Material if doing so restricts exercise of the Licensed Rights by any recipient of the Licensed Material.
+
+   6. __No endorsement.__ Nothing in this Public License constitutes or may be construed as permission to assert or imply that You are, or that Your use of the Licensed Material is, connected with, or sponsored, endorsed, or granted official status by, the Licensor or others designated to receive attribution as provided in Section 3(a)(1)(A)(i).
+
+b. ___Other rights.___
+
+   1. Moral rights, such as the right of integrity, are not licensed under this Public License, nor are publicity, privacy, and/or other similar personality rights; however, to the extent possible, the Licensor waives and/or agrees not to assert any such rights held by the Licensor to the limited extent necessary to allow You to exercise the Licensed Rights, but not otherwise.
+
+   2. Patent and trademark rights are not licensed under this Public License.
+
+   3. To the extent possible, the Licensor waives any right to collect royalties from You for the exercise of the Licensed Rights, whether directly or through a collecting society under any voluntary or waivable statutory or compulsory licensing scheme. In all other cases the Licensor expressly reserves any right to collect such royalties.
+
+### Section 3 – License Conditions
+
+Your exercise of the Licensed Rights is expressly made subject to the following conditions.
+
+a. ___Attribution.___
+
+   1. If You Share the Licensed Material (including in modified form), You must:
+
+       A. retain the following if it is supplied by the Licensor with the Licensed Material:
+
+         i. identification of the creator(s) of the Licensed Material and any others designated to receive attribution, in any reasonable manner requested by the Licensor (including by pseudonym if designated);
+
+         ii. a copyright notice;
+
+         iii. a notice that refers to this Public License;
+
+         iv. a notice that refers to the disclaimer of warranties;
+
+         v. a URI or hyperlink to the Licensed Material to the extent reasonably practicable;
+
+       B. indicate if You modified the Licensed Material and retain an indication of any previous modifications; and
+
+       C. indicate the Licensed Material is licensed under this Public License, and include the text of, or the URI or hyperlink to, this Public License.
+
+   2. You may satisfy the conditions in Section 3(a)(1) in any reasonable manner based on the medium, means, and context in which You Share the Licensed Material. For example, it may be reasonable to satisfy the conditions by providing a URI or hyperlink to a resource that includes the required information.
+
+   3. If requested by the Licensor, You must remove any of the information required by Section 3(a)(1)(A) to the extent reasonably practicable.
+
+   4. If You Share Adapted Material You produce, the Adapter's License You apply must not prevent recipients of the Adapted Material from complying with this Public License.
+
+### Section 4 – Sui Generis Database Rights
+
+Where the Licensed Rights include Sui Generis Database Rights that apply to Your use of the Licensed Material:
+
+a. for the avoidance of doubt, Section 2(a)(1) grants You the right to extract, reuse, reproduce, and Share all or a substantial portion of the contents of the database;
+
+b. if You include all or a substantial portion of the database contents in a database in which You have Sui Generis Database Rights, then the database in which You have Sui Generis Database Rights (but not its individual contents) is Adapted Material; and
+
+c. You must comply with the conditions in Section 3(a) if You Share all or a substantial portion of the contents of the database.
+
+For the avoidance of doubt, this Section 4 supplements and does not replace Your obligations under this Public License where the Licensed Rights include other Copyright and Similar Rights.
+
+### Section 5 – Disclaimer of Warranties and Limitation of Liability
+
+a. __Unless otherwise separately undertaken by the Licensor, to the extent possible, the Licensor offers the Licensed Material as-is and as-available, and makes no representations or warranties of any kind concerning the Licensed Material, whether express, implied, statutory, or other. This includes, without limitation, warranties of title, merchantability, fitness for a particular purpose, non-infringement, absence of latent or other defects, accuracy, or the presence or absence of errors, whether or not known or discoverable. Where disclaimers of warranties are not allowed in full or in part, this disclaimer may not apply to You.__
+
+b. __To the extent possible, in no event will the Licensor be liable to You on any legal theory (including, without limitation, negligence) or otherwise for any direct, special, indirect, incidental, consequential, punitive, exemplary, or other losses, costs, expenses, or damages arising out of this Public License or use of the Licensed Material, even if the Licensor has been advised of the possibility of such losses, costs, expenses, or damages. Where a limitation of liability is not allowed in full or in part, this limitation may not apply to You.__
+
+c. The disclaimer of warranties and limitation of liability provided above shall be interpreted in a manner that, to the extent possible, most closely approximates an absolute disclaimer and waiver of all liability.
+
+### Section 6 – Term and Termination
+
+a. This Public License applies for the term of the Copyright and Similar Rights licensed here. However, if You fail to comply with this Public License, then Your rights under this Public License terminate automatically.
+
+b. Where Your right to use the Licensed Material has terminated under Section 6(a), it reinstates:
+
+   1. automatically as of the date the violation is cured, provided it is cured within 30 days of Your discovery of the violation; or
+
+   2. upon express reinstatement by the Licensor.
+
+   For the avoidance of doubt, this Section 6(b) does not affect any right the Licensor may have to seek remedies for Your violations of this Public License.
+
+c. For the avoidance of doubt, the Licensor may also offer the Licensed Material under separate terms or conditions or stop distributing the Licensed Material at any time; however, doing so will not terminate this Public License.
+
+d. Sections 1, 5, 6, 7, and 8 survive termination of this Public License.
+
+### Section 7 – Other Terms and Conditions
+
+a. The Licensor shall not be bound by any additional or different terms or conditions communicated by You unless expressly agreed.
+
+b. Any arrangements, understandings, or agreements regarding the Licensed Material not stated herein are separate from and independent of the terms and conditions of this Public License.
+
+### Section 8 – Interpretation
+
+a. For the avoidance of doubt, this Public License does not, and shall not be interpreted to, reduce, limit, restrict, or impose conditions on any use of the Licensed Material that could lawfully be made without permission under this Public License.
+
+b. To the extent possible, if any provision of this Public License is deemed unenforceable, it shall be automatically reformed to the minimum extent necessary to make it enforceable. If the provision cannot be reformed, it shall be severed from this Public License without affecting the enforceability of the remaining terms and conditions.
+
+c. No term or condition of this Public License will be waived and no failure to comply consented to unless expressly agreed to by the Licensor.
+
+d. Nothing in this Public License constitutes or may be interpreted as a limitation upon, or waiver of, any privileges and immunities that apply to the Licensor or You, including from the legal processes of any jurisdiction or authority.
+
+> Creative Commons is not a party to its public licenses. Notwithstanding, Creative Commons may elect to apply one of its public licenses to material it publishes and in those instances will be considered the “Licensor.” Except for the limited purpose of indicating that material is shared under a Creative Commons public license or as otherwise permitted by the Creative Commons policies published at [creativecommons.org/policies](http://creativecommons.org/policies), Creative Commons does not authorize the use of the trademark “Creative Commons” or any other trademark or logo of Creative Commons without its prior written consent including, without limitation, in connection with any unauthorized modifications to any of its public licenses or any other arrangements, understandings, or agreements concerning use of licensed material. For the avoidance of doubt, this paragraph does not form part of the public licenses.
+>
+> Creative Commons may be contacted at creativecommons.org

externals/CMakeLists.txt

@@ -35,6 +35,10 @@ set(LZ4_BUNDLED_MODE ON)
 add_subdirectory(lz4/contrib/cmake_unofficial)
 target_include_directories(lz4_static INTERFACE ./lz4/lib)
 
+# mbedtls
+add_subdirectory(mbedtls)
+target_include_directories(mbedtls PUBLIC ./mbedtls/include)
+
 # MicroProfile
 add_library(microprofile INTERFACE)
 target_include_directories(microprofile INTERFACE ./microprofile)
@@ -50,3 +54,13 @@ if (ARCHITECTURE_x86_64)
     target_include_directories(xbyak INTERFACE ./xbyak/xbyak)
     target_compile_definitions(xbyak INTERFACE XBYAK_NO_OP_NAMES)
 endif()
+
+# Opus
+add_subdirectory(opus)
+target_include_directories(opus INTERFACE ./opus/include)
+
+# Cubeb
+if(ENABLE_CUBEB)
+    set(BUILD_TESTS OFF CACHE BOOL "")
+    add_subdirectory(cubeb)
+endif()

externals/cmake-modules/WindowsCopyFiles.cmake

@@ -1,4 +1,4 @@
-# Copyright 2016 Citra Emulator Project
+# Copyright 2018 Yuzu Emulator Project
 # Licensed under GPLv2 or any later version
 # Refer to the license.txt file included.
 
@@ -22,7 +22,7 @@ function(windows_copy_files TARGET SOURCE_DIR DEST_DIR)
     # cmake adds an extra check for command success which doesn't work too well with robocopy
     # so trick it into thinking the command was successful with the || cmd /c "exit /b 0"
     add_custom_command(TARGET ${TARGET} POST_BUILD
-        COMMAND if not exist ${DEST_DIR} mkdir ${DEST_DIR} 2> nul
+        COMMAND ${CMAKE_COMMAND} -E make_directory ${DEST_DIR}
         COMMAND robocopy ${SOURCE_DIR} ${DEST_DIR} ${ARGN} /NJH /NJS /NDL /NFL /NC /NS /NP || cmd /c "exit /b 0"
     )
-endfunction()
+endfunction()

externals/glad/include/KHR/khrplatform.h

@@ -2,7 +2,7 @@
 #define __khrplatform_h_
 
 /*
-** Copyright (c) 2008-2009 The Khronos Group Inc.
+** Copyright (c) 2008-2018 The Khronos Group Inc.
 **
 ** Permission is hereby granted, free of charge, to any person obtaining a
 ** copy of this software and/or associated documentation files (the
@@ -26,18 +26,16 @@
 
 /* Khronos platform-specific types and definitions.
  *
- * $Revision: 32517 $ on $Date: 2016-03-11 02:41:19 -0800 (Fri, 11 Mar 2016) $
+ * The master copy of khrplatform.h is maintained in the Khronos EGL
+ * Registry repository at https://github.com/KhronosGroup/EGL-Registry
+ * The last semantic modification to khrplatform.h was at commit ID:
+ *      67a3e0864c2d75ea5287b9f3d2eb74a745936692
  *
  * Adopters may modify this file to suit their platform. Adopters are
  * encouraged to submit platform specific modifications to the Khronos
  * group so that they can be included in future versions of this file.
- * Please submit changes by sending them to the public Khronos Bugzilla
- * (http://khronos.org/bugzilla) by filing a bug against product
- * "Khronos (general)" component "Registry".
- *
- * A predefined template which fills in some of the bug fields can be
- * reached using http://tinyurl.com/khrplatform-h-bugreport, but you
- * must create a Bugzilla login first.
+ * Please submit changes by filing pull requests or issues on
+ * the EGL Registry repository linked above.
  *
  *
  * See the Implementer's Guidelines for information about where this file

src/CMakeLists.txt

@@ -3,6 +3,7 @@ include_directories(.)
 
 add_subdirectory(common)
 add_subdirectory(core)
+add_subdirectory(audio_core)
 add_subdirectory(video_core)
 add_subdirectory(input_common)
 add_subdirectory(tests)

src/audio_core/CMakeLists.txt

@@ -0,0 +1,23 @@
+add_library(audio_core STATIC
+    audio_out.cpp
+    audio_out.h
+    buffer.h
+    cubeb_sink.cpp
+    cubeb_sink.h
+    null_sink.h
+    stream.cpp
+    stream.h
+    sink.h
+    sink_details.cpp
+    sink_details.h
+    sink_stream.h
+)
+
+create_target_directory_groups(audio_core)
+
+target_link_libraries(audio_core PUBLIC common core)
+
+if(ENABLE_CUBEB)
+    target_link_libraries(audio_core PRIVATE cubeb)
+    target_compile_definitions(audio_core PRIVATE -DHAVE_CUBEB=1)
+endif()

src/audio_core/audio_out.cpp

@@ -0,0 +1,58 @@
+// Copyright 2018 yuzu Emulator Project
+// Licensed under GPLv2 or any later version
+// Refer to the license.txt file included.
+
+#include "audio_core/audio_out.h"
+#include "audio_core/sink.h"
+#include "audio_core/sink_details.h"
+#include "common/assert.h"
+#include "common/logging/log.h"
+#include "core/settings.h"
+
+namespace AudioCore {
+
+/// Returns the stream format from the specified number of channels
+static Stream::Format ChannelsToStreamFormat(u32 num_channels) {
+    switch (num_channels) {
+    case 1:
+        return Stream::Format::Mono16;
+    case 2:
+        return Stream::Format::Stereo16;
+    case 6:
+        return Stream::Format::Multi51Channel16;
+    }
+
+    LOG_CRITICAL(Audio, "Unimplemented num_channels={}", num_channels);
+    UNREACHABLE();
+    return {};
+}
+
+StreamPtr AudioOut::OpenStream(u32 sample_rate, u32 num_channels,
+                               Stream::ReleaseCallback&& release_callback) {
+    if (!sink) {
+        const SinkDetails& sink_details = GetSinkDetails(Settings::values.sink_id);
+        sink = sink_details.factory(Settings::values.audio_device_id);
+    }
+
+    return std::make_shared<Stream>(sample_rate, ChannelsToStreamFormat(num_channels),
+                                    std::move(release_callback),
+                                    sink->AcquireSinkStream(sample_rate, num_channels));
+}
+
+std::vector<Buffer::Tag> AudioOut::GetTagsAndReleaseBuffers(StreamPtr stream, size_t max_count) {
+    return stream->GetTagsAndReleaseBuffers(max_count);
+}
+
+void AudioOut::StartStream(StreamPtr stream) {
+    stream->Play();
+}
+
+void AudioOut::StopStream(StreamPtr stream) {
+    stream->Stop();
+}
+
+bool AudioOut::QueueBuffer(StreamPtr stream, Buffer::Tag tag, std::vector<u8>&& data) {
+    return stream->QueueBuffer(std::make_shared<Buffer>(tag, std::move(data)));
+}
+
+} // namespace AudioCore

src/audio_core/audio_out.h

@@ -0,0 +1,42 @@
+// Copyright 2018 yuzu Emulator Project
+// Licensed under GPLv2 or any later version
+// Refer to the license.txt file included.
+
+#pragma once
+
+#include <memory>
+#include <vector>
+
+#include "audio_core/buffer.h"
+#include "audio_core/sink.h"
+#include "audio_core/stream.h"
+#include "common/common_types.h"
+
+namespace AudioCore {
+
+/**
+ * Represents an audio playback interface, used to open and play audio streams
+ */
+class AudioOut {
+public:
+    /// Opens a new audio stream
+    StreamPtr OpenStream(u32 sample_rate, u32 num_channels,
+                         Stream::ReleaseCallback&& release_callback);
+
+    /// Returns a vector of recently released buffers specified by tag for the specified stream
+    std::vector<Buffer::Tag> GetTagsAndReleaseBuffers(StreamPtr stream, size_t max_count);
+
+    /// Starts an audio stream for playback
+    void StartStream(StreamPtr stream);
+
+    /// Stops an audio stream that is currently playing
+    void StopStream(StreamPtr stream);
+
+    /// Queues a buffer into the specified audio stream, returns true on success
+    bool QueueBuffer(StreamPtr stream, Buffer::Tag tag, std::vector<u8>&& data);
+
+private:
+    SinkPtr sink;
+};
+
+} // namespace AudioCore

src/audio_core/buffer.h

@@ -0,0 +1,40 @@
+// Copyright 2018 yuzu Emulator Project
+// Licensed under GPLv2 or any later version
+// Refer to the license.txt file included.
+
+#pragma once
+
+#include <memory>
+#include <vector>
+
+#include "common/common_types.h"
+
+namespace AudioCore {
+
+/**
+ * Represents a buffer of audio samples to be played in an audio stream
+ */
+class Buffer {
+public:
+    using Tag = u64;
+
+    Buffer(Tag tag, std::vector<u8>&& data) : tag{tag}, data{std::move(data)} {}
+
+    /// Returns the raw audio data for the buffer
+    const std::vector<u8>& GetData() const {
+        return data;
+    }
+
+    /// Returns the buffer tag, this is provided by the game to the audout service
+    Tag GetTag() const {
+        return tag;
+    }
+
+private:
+    Tag tag;
+    std::vector<u8> data;
+};
+
+using BufferPtr = std::shared_ptr<Buffer>;
+
+} // namespace AudioCore

src/audio_core/cubeb_sink.cpp

@@ -0,0 +1,190 @@
+// Copyright 2018 yuzu Emulator Project
+// Licensed under GPLv2 or any later version
+// Refer to the license.txt file included.
+
+#include <algorithm>
+#include <cstring>
+
+#include "audio_core/cubeb_sink.h"
+#include "audio_core/stream.h"
+#include "common/logging/log.h"
+
+namespace AudioCore {
+
+class SinkStreamImpl final : public SinkStream {
+public:
+    SinkStreamImpl(cubeb* ctx, cubeb_devid output_device) : ctx{ctx} {
+        cubeb_stream_params params;
+        params.rate = 48000;
+        params.channels = GetNumChannels();
+        params.format = CUBEB_SAMPLE_S16NE;
+        params.layout = CUBEB_LAYOUT_STEREO;
+
+        u32 minimum_latency = 0;
+        if (cubeb_get_min_latency(ctx, &params, &minimum_latency) != CUBEB_OK) {
+            LOG_CRITICAL(Audio_Sink, "Error getting minimum latency");
+        }
+
+        if (cubeb_stream_init(ctx, &stream_backend, "yuzu Audio Output", nullptr, nullptr,
+                              output_device, &params, std::max(512u, minimum_latency),
+                              &SinkStreamImpl::DataCallback, &SinkStreamImpl::StateCallback,
+                              this) != CUBEB_OK) {
+            LOG_CRITICAL(Audio_Sink, "Error initializing cubeb stream");
+            return;
+        }
+
+        if (cubeb_stream_start(stream_backend) != CUBEB_OK) {
+            LOG_CRITICAL(Audio_Sink, "Error starting cubeb stream");
+            return;
+        }
+    }
+
+    ~SinkStreamImpl() {
+        if (!ctx) {
+            return;
+        }
+
+        if (cubeb_stream_stop(stream_backend) != CUBEB_OK) {
+            LOG_CRITICAL(Audio_Sink, "Error stopping cubeb stream");
+        }
+
+        cubeb_stream_destroy(stream_backend);
+    }
+
+    void EnqueueSamples(u32 num_channels, const s16* samples, size_t sample_count) override {
+        if (!ctx) {
+            return;
+        }
+
+        queue.reserve(queue.size() + sample_count * GetNumChannels());
+
+        if (num_channels == 2) {
+            // Copy as-is
+            std::copy(samples, samples + sample_count * GetNumChannels(),
+                      std::back_inserter(queue));
+        } else if (num_channels == 6) {
+            // Downsample 6 channels to 2
+            const size_t sample_count_copy_size = sample_count * num_channels * 2;
+            queue.reserve(sample_count_copy_size);
+            for (size_t i = 0; i < sample_count * num_channels; i += num_channels) {
+                queue.push_back(samples[i]);
+                queue.push_back(samples[i + 1]);
+            }
+        } else {
+            ASSERT_MSG(false, "Unimplemented");
+        }
+    }
+
+    u32 GetNumChannels() const {
+        // Only support 2-channel stereo output for now
+        return 2;
+    }
+
+private:
+    std::vector<std::string> device_list;
+
+    cubeb* ctx{};
+    cubeb_stream* stream_backend{};
+
+    std::vector<s16> queue;
+
+    static long DataCallback(cubeb_stream* stream, void* user_data, const void* input_buffer,
+                             void* output_buffer, long num_frames);
+    static void StateCallback(cubeb_stream* stream, void* user_data, cubeb_state state);
+};
+
+CubebSink::CubebSink(std::string target_device_name) {
+    if (cubeb_init(&ctx, "yuzu", nullptr) != CUBEB_OK) {
+        LOG_CRITICAL(Audio_Sink, "cubeb_init failed");
+        return;
+    }
+
+    if (target_device_name != auto_device_name && !target_device_name.empty()) {
+        cubeb_device_collection collection;
+        if (cubeb_enumerate_devices(ctx, CUBEB_DEVICE_TYPE_OUTPUT, &collection) != CUBEB_OK) {
+            LOG_WARNING(Audio_Sink, "Audio output device enumeration not supported");
+        } else {
+            const auto collection_end{collection.device + collection.count};
+            const auto device{std::find_if(collection.device, collection_end,
+                                           [&](const cubeb_device_info& device) {
+                                               return target_device_name == device.friendly_name;
+                                           })};
+            if (device != collection_end) {
+                output_device = device->devid;
+            }
+            cubeb_device_collection_destroy(ctx, &collection);
+        }
+    }
+}
+
+CubebSink::~CubebSink() {
+    if (!ctx) {
+        return;
+    }
+
+    for (auto& sink_stream : sink_streams) {
+        sink_stream.reset();
+    }
+
+    cubeb_destroy(ctx);
+}
+
+SinkStream& CubebSink::AcquireSinkStream(u32 sample_rate, u32 num_channels) {
+    sink_streams.push_back(std::make_unique<SinkStreamImpl>(ctx, output_device));
+    return *sink_streams.back();
+}
+
+long SinkStreamImpl::DataCallback(cubeb_stream* stream, void* user_data, const void* input_buffer,
+                                  void* output_buffer, long num_frames) {
+    SinkStreamImpl* impl = static_cast<SinkStreamImpl*>(user_data);
+    u8* buffer = reinterpret_cast<u8*>(output_buffer);
+
+    if (!impl) {
+        return {};
+    }
+
+    const size_t frames_to_write{
+        std::min(impl->queue.size() / impl->GetNumChannels(), static_cast<size_t>(num_frames))};
+
+    memcpy(buffer, impl->queue.data(), frames_to_write * sizeof(s16) * impl->GetNumChannels());
+    impl->queue.erase(impl->queue.begin(),
+                      impl->queue.begin() + frames_to_write * impl->GetNumChannels());
+
+    if (frames_to_write < num_frames) {
+        // Fill the rest of the frames with silence
+        memset(buffer + frames_to_write * sizeof(s16) * impl->GetNumChannels(), 0,
+               (num_frames - frames_to_write) * sizeof(s16) * impl->GetNumChannels());
+    }
+
+    return num_frames;
+}
+
+void SinkStreamImpl::StateCallback(cubeb_stream* stream, void* user_data, cubeb_state state) {}
+
+std::vector<std::string> ListCubebSinkDevices() {
+    std::vector<std::string> device_list;
+    cubeb* ctx;
+
+    if (cubeb_init(&ctx, "Citra Device Enumerator", nullptr) != CUBEB_OK) {
+        LOG_CRITICAL(Audio_Sink, "cubeb_init failed");
+        return {};
+    }
+
+    cubeb_device_collection collection;
+    if (cubeb_enumerate_devices(ctx, CUBEB_DEVICE_TYPE_OUTPUT, &collection) != CUBEB_OK) {
+        LOG_WARNING(Audio_Sink, "Audio output device enumeration not supported");
+    } else {
+        for (size_t i = 0; i < collection.count; i++) {
+            const cubeb_device_info& device = collection.device[i];
+            if (device.friendly_name) {
+                device_list.emplace_back(device.friendly_name);
+            }
+        }
+        cubeb_device_collection_destroy(ctx, &collection);
+    }
+
+    cubeb_destroy(ctx);
+    return device_list;
+}
+
+} // namespace AudioCore

src/audio_core/cubeb_sink.h

@@ -0,0 +1,31 @@
+// Copyright 2018 yuzu Emulator Project
+// Licensed under GPLv2 or any later version
+// Refer to the license.txt file included.
+
+#pragma once
+
+#include <string>
+#include <vector>
+
+#include <cubeb/cubeb.h>
+
+#include "audio_core/sink.h"
+
+namespace AudioCore {
+
+class CubebSink final : public Sink {
+public:
+    explicit CubebSink(std::string device_id);
+    ~CubebSink() override;
+
+    SinkStream& AcquireSinkStream(u32 sample_rate, u32 num_channels) override;
+
+private:
+    cubeb* ctx{};
+    cubeb_devid output_device{};
+    std::vector<SinkStreamPtr> sink_streams;
+};
+
+std::vector<std::string> ListCubebSinkDevices();
+
+} // namespace AudioCore

src/audio_core/null_sink.h

@@ -0,0 +1,27 @@
+// Copyright 2018 yuzu Emulator Project
+// Licensed under GPLv2 or any later version
+// Refer to the license.txt file included.
+
+#pragma once
+
+#include "audio_core/sink.h"
+
+namespace AudioCore {
+
+class NullSink final : public Sink {
+public:
+    explicit NullSink(std::string){};
+    ~NullSink() override = default;
+
+    SinkStream& AcquireSinkStream(u32 /*sample_rate*/, u32 /*num_channels*/) override {
+        return null_sink_stream;
+    }
+
+private:
+    struct NullSinkStreamImpl final : SinkStream {
+        void EnqueueSamples(u32 /*num_channels*/, const s16* /*samples*/,
+                            size_t /*sample_count*/) override {}
+    } null_sink_stream;
+};
+
+} // namespace AudioCore

src/audio_core/sink.h

@@ -0,0 +1,29 @@
+// Copyright 2018 yuzu Emulator Project
+// Licensed under GPLv2 or any later version
+// Refer to the license.txt file included.
+
+#pragma once
+
+#include <memory>
+
+#include "audio_core/sink_stream.h"
+#include "common/common_types.h"
+
+namespace AudioCore {
+
+constexpr char auto_device_name[] = "auto";
+
+/**
+ * This class is an interface for an audio sink. An audio sink accepts samples in stereo signed
+ * PCM16 format to be output. Sinks *do not* handle resampling and expect the correct sample rate.
+ * They are dumb outputs.
+ */
+class Sink {
+public:
+    virtual ~Sink() = default;
+    virtual SinkStream& AcquireSinkStream(u32 sample_rate, u32 num_channels) = 0;
+};
+
+using SinkPtr = std::unique_ptr<Sink>;
+
+} // namespace AudioCore

src/audio_core/sink_details.cpp

@@ -0,0 +1,44 @@
+// Copyright 2018 yuzu Emulator Project
+// Licensed under GPLv2 or any later version
+// Refer to the license.txt file included.
+
+#include <algorithm>
+#include <memory>
+#include <string>
+#include <vector>
+#include "audio_core/null_sink.h"
+#include "audio_core/sink_details.h"
+#ifdef HAVE_CUBEB
+#include "audio_core/cubeb_sink.h"
+#endif
+#include "common/logging/log.h"
+
+namespace AudioCore {
+
+// g_sink_details is ordered in terms of desirability, with the best choice at the top.
+const std::vector<SinkDetails> g_sink_details = {
+#ifdef HAVE_CUBEB
+    SinkDetails{"cubeb", &std::make_unique<CubebSink, std::string>, &ListCubebSinkDevices},
+#endif
+    SinkDetails{"null", &std::make_unique<NullSink, std::string>,
+                [] { return std::vector<std::string>{"null"}; }},
+};
+
+const SinkDetails& GetSinkDetails(std::string sink_id) {
+    auto iter =
+        std::find_if(g_sink_details.begin(), g_sink_details.end(),
+                     [sink_id](const auto& sink_detail) { return sink_detail.id == sink_id; });
+
+    if (sink_id == "auto" || iter == g_sink_details.end()) {
+        if (sink_id != "auto") {
+            LOG_ERROR(Audio, "AudioCore::SelectSink given invalid sink_id {}", sink_id);
+        }
+        // Auto-select.
+        // g_sink_details is ordered in terms of desirability, with the best choice at the front.
+        iter = g_sink_details.begin();
+    }
+
+    return *iter;
+}
+
+} // namespace AudioCore

src/audio_core/sink_details.h

@@ -0,0 +1,35 @@
+// Copyright 2018 yuzu Emulator Project
+// Licensed under GPLv2 or any later version
+// Refer to the license.txt file included.
+
+#pragma once
+
+#include <functional>
+#include <memory>
+#include <utility>
+#include <vector>
+
+namespace AudioCore {
+
+class Sink;
+
+struct SinkDetails {
+    using FactoryFn = std::function<std::unique_ptr<Sink>(std::string)>;
+    using ListDevicesFn = std::function<std::vector<std::string>()>;
+
+    SinkDetails(const char* id_, FactoryFn factory_, ListDevicesFn list_devices_)
+        : id(id_), factory(std::move(factory_)), list_devices(std::move(list_devices_)) {}
+
+    /// Name for this sink.
+    const char* id;
+    /// A method to call to construct an instance of this type of sink.
+    FactoryFn factory;
+    /// A method to call to list available devices.
+    ListDevicesFn list_devices;
+};
+
+extern const std::vector<SinkDetails> g_sink_details;
+
+const SinkDetails& GetSinkDetails(std::string sink_id);
+
+} // namespace AudioCore

src/audio_core/sink_stream.h

@@ -0,0 +1,32 @@
+// Copyright 2018 yuzu Emulator Project
+// Licensed under GPLv2 or any later version
+// Refer to the license.txt file included.
+
+#pragma once
+
+#include <memory>
+
+#include "common/common_types.h"
+
+namespace AudioCore {
+
+/**
+ * Accepts samples in stereo signed PCM16 format to be output. Sinks *do not* handle resampling and
+ * expect the correct sample rate. They are dumb outputs.
+ */
+class SinkStream {
+public:
+    virtual ~SinkStream() = default;
+
+    /**
+     * Feed stereo samples to sink.
+     * @param num_channels Number of channels used.
+     * @param samples Samples in interleaved stereo PCM16 format.
+     * @param sample_count Number of samples.
+     */
+    virtual void EnqueueSamples(u32 num_channels, const s16* samples, size_t sample_count) = 0;
+};
+
+using SinkStreamPtr = std::unique_ptr<SinkStream>;
+
+} // namespace AudioCore

src/audio_core/stream.cpp

@@ -0,0 +1,135 @@
+// Copyright 2018 yuzu Emulator Project
+// Licensed under GPLv2 or any later version
+// Refer to the license.txt file included.
+
+#include <algorithm>
+#include <cmath>
+
+#include "audio_core/sink.h"
+#include "audio_core/sink_details.h"
+#include "audio_core/stream.h"
+#include "common/assert.h"
+#include "common/logging/log.h"
+#include "core/core_timing.h"
+#include "core/core_timing_util.h"
+#include "core/settings.h"
+
+namespace AudioCore {
+
+constexpr size_t MaxAudioBufferCount{32};
+
+u32 Stream::GetNumChannels() const {
+    switch (format) {
+    case Format::Mono16:
+        return 1;
+    case Format::Stereo16:
+        return 2;
+    case Format::Multi51Channel16:
+        return 6;
+    }
+    LOG_CRITICAL(Audio, "Unimplemented format={}", static_cast<u32>(format));
+    UNREACHABLE();
+    return {};
+}
+
+u32 Stream::GetSampleSize() const {
+    return GetNumChannels() * 2;
+}
+
+Stream::Stream(u32 sample_rate, Format format, ReleaseCallback&& release_callback,
+               SinkStream& sink_stream)
+    : sample_rate{sample_rate}, format{format}, release_callback{std::move(release_callback)},
+      sink_stream{sink_stream} {
+
+    release_event = CoreTiming::RegisterEvent(
+        "Stream::Release", [this](u64 userdata, int cycles_late) { ReleaseActiveBuffer(); });
+}
+
+void Stream::Play() {
+    state = State::Playing;
+    PlayNextBuffer();
+}
+
+void Stream::Stop() {
+    ASSERT_MSG(false, "Unimplemented");
+}
+
+s64 Stream::GetBufferReleaseCycles(const Buffer& buffer) const {
+    const size_t num_samples{buffer.GetData().size() / GetSampleSize()};
+    return CoreTiming::usToCycles((static_cast<u64>(num_samples) * 1000000) / sample_rate);
+}
+
+static std::vector<s16> GetVolumeAdjustedSamples(const std::vector<u8>& data) {
+    std::vector<s16> samples(data.size() / sizeof(s16));
+    std::memcpy(samples.data(), data.data(), data.size());
+    const float volume{std::clamp(Settings::values.volume, 0.0f, 1.0f)};
+
+    if (volume == 1.0f) {
+        return samples;
+    }
+
+    // Implementation of a volume slider with a dynamic range of 60 dB
+    const float volume_scale_factor{std::exp(6.90775f * volume) * 0.001f};
+    for (auto& sample : samples) {
+        sample = static_cast<s16>(sample * volume_scale_factor);
+    }
+
+    return samples;
+}
+
+void Stream::PlayNextBuffer() {
+    if (!IsPlaying()) {
+        // Ensure we are in playing state before playing the next buffer
+        return;
+    }
+
+    if (active_buffer) {
+        // Do not queue a new buffer if we are already playing a buffer
+        return;
+    }
+
+    if (queued_buffers.empty()) {
+        // No queued buffers - we are effectively paused
+        return;
+    }
+
+    active_buffer = queued_buffers.front();
+    queued_buffers.pop();
+
+    const size_t sample_count{active_buffer->GetData().size() / GetSampleSize()};
+    sink_stream.EnqueueSamples(
+        GetNumChannels(), GetVolumeAdjustedSamples(active_buffer->GetData()).data(), sample_count);
+
+    CoreTiming::ScheduleEventThreadsafe(GetBufferReleaseCycles(*active_buffer), release_event, {});
+}
+
+void Stream::ReleaseActiveBuffer() {
+    released_buffers.push(std::move(active_buffer));
+    release_callback();
+    PlayNextBuffer();
+}
+
+bool Stream::QueueBuffer(BufferPtr&& buffer) {
+    if (queued_buffers.size() < MaxAudioBufferCount) {
+        queued_buffers.push(std::move(buffer));
+        PlayNextBuffer();
+        return true;
+    }
+    return false;
+}
+
+bool Stream::ContainsBuffer(Buffer::Tag tag) const {
+    ASSERT_MSG(false, "Unimplemented");
+    return {};
+}
+
+std::vector<Buffer::Tag> Stream::GetTagsAndReleaseBuffers(size_t max_count) {
+    std::vector<Buffer::Tag> tags;
+    for (size_t count = 0; count < max_count && !released_buffers.empty(); ++count) {
+        tags.push_back(released_buffers.front()->GetTag());
+        released_buffers.pop();
+    }
+    return tags;
+}
+
+} // namespace AudioCore

src/audio_core/stream.h

@@ -0,0 +1,103 @@
+// Copyright 2018 yuzu Emulator Project
+// Licensed under GPLv2 or any later version
+// Refer to the license.txt file included.
+
+#pragma once
+
+#include <functional>
+#include <memory>
+#include <vector>
+#include <queue>
+
+#include "audio_core/buffer.h"
+#include "audio_core/sink_stream.h"
+#include "common/assert.h"
+#include "common/common_types.h"
+#include "core/core_timing.h"
+
+namespace AudioCore {
+
+/**
+ * Represents an audio stream, which is a sequence of queued buffers, to be outputed by AudioOut
+ */
+class Stream {
+public:
+    /// Audio format of the stream
+    enum class Format {
+        Mono16,
+        Stereo16,
+        Multi51Channel16,
+    };
+
+    /// Callback function type, used to change guest state on a buffer being released
+    using ReleaseCallback = std::function<void()>;
+
+    Stream(u32 sample_rate, Format format, ReleaseCallback&& release_callback,
+           SinkStream& sink_stream);
+
+    /// Plays the audio stream
+    void Play();
+
+    /// Stops the audio stream
+    void Stop();
+
+    /// Queues a buffer into the audio stream, returns true on success
+    bool QueueBuffer(BufferPtr&& buffer);
+
+    /// Returns true if the audio stream contains a buffer with the specified tag
+    bool ContainsBuffer(Buffer::Tag tag) const;
+
+    /// Returns a vector of recently released buffers specified by tag
+    std::vector<Buffer::Tag> GetTagsAndReleaseBuffers(size_t max_count);
+
+    /// Returns true if the stream is currently playing
+    bool IsPlaying() const {
+        return state == State::Playing;
+    }
+
+    /// Returns the number of queued buffers
+    size_t GetQueueSize() const {
+        return queued_buffers.size();
+    }
+
+    /// Gets the sample rate
+    u32 GetSampleRate() const {
+        return sample_rate;
+    }
+
+    /// Gets the number of channels
+    u32 GetNumChannels() const;
+
+    /// Gets the sample size in bytes
+    u32 GetSampleSize() const;
+
+private:
+    /// Current state of the stream
+    enum class State {
+        Stopped,
+        Playing,
+    };
+
+    /// Plays the next queued buffer in the audio stream, starting playback if necessary
+    void PlayNextBuffer();
+
+    /// Releases the actively playing buffer, signalling that it has been completed
+    void ReleaseActiveBuffer();
+
+    /// Gets the number of core cycles when the specified buffer will be released
+    s64 GetBufferReleaseCycles(const Buffer& buffer) const;
+
+    u32 sample_rate;                        ///< Sample rate of the stream
+    Format format;                          ///< Format of the stream
+    ReleaseCallback release_callback;       ///< Buffer release callback for the stream
+    State state{State::Stopped};            ///< Playback state of the stream
+    CoreTiming::EventType* release_event{}; ///< Core timing release event for the stream
+    BufferPtr active_buffer;                ///< Actively playing buffer in the stream
+    std::queue<BufferPtr> queued_buffers;   ///< Buffers queued to be played in the stream
+    std::queue<BufferPtr> released_buffers; ///< Buffers recently released from the stream
+    SinkStream& sink_stream;                ///< Output sink for the stream
+};
+
+using StreamPtr = std::shared_ptr<Stream>;
+
+} // namespace AudioCore

src/common/CMakeLists.txt

@@ -63,7 +63,6 @@ add_library(common STATIC
     string_util.cpp
     string_util.h
     swap.h
-    synchronized_wrapper.h
     telemetry.cpp
     telemetry.h
     thread.cpp

src/common/assert.h

@@ -30,15 +30,14 @@ __declspec(noinline, noreturn)
 #define ASSERT(_a_)                                                                                \
     do                                                                                             \
         if (!(_a_)) {                                                                              \
-            assert_noinline_call([] { NGLOG_CRITICAL(Debug, "Assertion Failed!"); });              \
+            assert_noinline_call([] { LOG_CRITICAL(Debug, "Assertion Failed!"); });                \
         }                                                                                          \
     while (0)
 
 #define ASSERT_MSG(_a_, ...)                                                                       \
     do                                                                                             \
         if (!(_a_)) {                                                                              \
-            assert_noinline_call(                                                                  \
-                [&] { NGLOG_CRITICAL(Debug, "Assertion Failed!\n" __VA_ARGS__); });                \
+            assert_noinline_call([&] { LOG_CRITICAL(Debug, "Assertion Failed!\n" __VA_ARGS__); }); \
         }                                                                                          \
     while (0)
 
@@ -53,5 +52,5 @@ __declspec(noinline, noreturn)
 #define DEBUG_ASSERT_MSG(_a_, _desc_, ...)
 #endif
 
-#define UNIMPLEMENTED() DEBUG_ASSERT_MSG(false, "Unimplemented code!")
+#define UNIMPLEMENTED() LOG_CRITICAL(Debug, "Unimplemented code!")
 #define UNIMPLEMENTED_MSG(...) ASSERT_MSG(false, __VA_ARGS__)

src/common/common_funcs.h

@@ -4,7 +4,9 @@
 
 #pragma once
 
-#if !defined(ARCHITECTURE_x86_64) && !defined(_M_ARM)
+#include <string>
+
+#if !defined(ARCHITECTURE_x86_64)
 #include <cstdlib> // for exit
 #endif
 #include "common/common_types.h"
@@ -30,46 +32,10 @@
 
 #ifdef ARCHITECTURE_x86_64
 #define Crash() __asm__ __volatile__("int $3")
-#elif defined(_M_ARM)
-#define Crash() __asm__ __volatile__("trap")
 #else
 #define Crash() exit(1)
 #endif
 
-// GCC 4.8 defines all the rotate functions now
-// Small issue with GCC's lrotl/lrotr intrinsics is they are still 32bit while we require 64bit
-#ifdef _rotl
-#define rotl _rotl
-#else
-inline u32 rotl(u32 x, int shift) {
-    shift &= 31;
-    if (!shift)
-        return x;
-    return (x << shift) | (x >> (32 - shift));
-}
-#endif
-
-#ifdef _rotr
-#define rotr _rotr
-#else
-inline u32 rotr(u32 x, int shift) {
-    shift &= 31;
-    if (!shift)
-        return x;
-    return (x >> shift) | (x << (32 - shift));
-}
-#endif
-
-inline u64 _rotl64(u64 x, unsigned int shift) {
-    unsigned int n = shift % 64;
-    return (x << n) | (x >> (64 - n));
-}
-
-inline u64 _rotr64(u64 x, unsigned int shift) {
-    unsigned int n = shift % 64;
-    return (x >> n) | (x << (64 - n));
-}
-
 #else // _MSC_VER
 
 // Locale Cross-Compatibility
@@ -80,17 +46,13 @@ __declspec(dllimport) void __stdcall DebugBreak(void);
 }
 #define Crash() DebugBreak()
 
-// cstdlib provides these on MSVC
-#define rotr _rotr
-#define rotl _rotl
-
 #endif // _MSC_VER ndef
 
 // Generic function to get last error message.
 // Call directly after the command or use the error num.
 // This function might change the error code.
 // Defined in Misc.cpp.
-const char* GetLastErrorMsg();
+std::string GetLastErrorMsg();
 
 namespace Common {
 

src/common/common_paths.h

@@ -26,18 +26,22 @@
 #define USA_DIR "USA"
 #define JAP_DIR "JAP"
 
-// Subdirs in the User dir returned by GetUserPath(D_USER_IDX)
+// Subdirs in the User dir returned by GetUserPath(UserPath::UserDir)
 #define CONFIG_DIR "config"
 #define CACHE_DIR "cache"
 #define SDMC_DIR "sdmc"
 #define NAND_DIR "nand"
 #define SYSDATA_DIR "sysdata"
+#define KEYS_DIR "keys"
+#define LOG_DIR "log"
 
 // Filenames
-// Files in the directory returned by GetUserPath(D_CONFIG_IDX)
+// Files in the directory returned by GetUserPath(UserPath::ConfigDir)
 #define EMU_CONFIG "emu.ini"
 #define DEBUGGER_CONFIG "debugger.ini"
 #define LOGGER_CONFIG "logger.ini"
+// Files in the directory returned by GetUserPath(UserPath::LogDir)
+#define LOG_FILE "yuzu_log.txt"
 
 // Sys files
 #define SHARED_FONT "shared_font.bin"

src/common/file_util.cpp

@@ -2,6 +2,10 @@
 // Licensed under GPLv2 or any later version
 // Refer to the license.txt file included.
 
+#include <array>
+#include <memory>
+#include <sstream>
+#include <unordered_map>
 #include "common/assert.h"
 #include "common/common_funcs.h"
 #include "common/common_paths.h"
@@ -118,7 +122,7 @@ bool IsDirectory(const std::string& filename) {
 #endif
 
     if (result < 0) {
-        NGLOG_DEBUG(Common_Filesystem, "stat failed on {}: {}", filename, GetLastErrorMsg());
+        LOG_DEBUG(Common_Filesystem, "stat failed on {}: {}", filename, GetLastErrorMsg());
         return false;
     }
 
@@ -128,29 +132,29 @@ bool IsDirectory(const std::string& filename) {
 // Deletes a given filename, return true on success
 // Doesn't supports deleting a directory
 bool Delete(const std::string& filename) {
-    NGLOG_TRACE(Common_Filesystem, "file {}", filename);
+    LOG_TRACE(Common_Filesystem, "file {}", filename);
 
     // Return true because we care about the file no
     // being there, not the actual delete.
     if (!Exists(filename)) {
-        NGLOG_DEBUG(Common_Filesystem, "{} does not exist", filename);
+        LOG_DEBUG(Common_Filesystem, "{} does not exist", filename);
         return true;
     }
 
     // We can't delete a directory
     if (IsDirectory(filename)) {
-        NGLOG_ERROR(Common_Filesystem, "Failed: {} is a directory", filename);
+        LOG_ERROR(Common_Filesystem, "Failed: {} is a directory", filename);
         return false;
     }
 
 #ifdef _WIN32
     if (!DeleteFileW(Common::UTF8ToUTF16W(filename).c_str())) {
-        NGLOG_ERROR(Common_Filesystem, "DeleteFile failed on {}: {}", filename, GetLastErrorMsg());
+        LOG_ERROR(Common_Filesystem, "DeleteFile failed on {}: {}", filename, GetLastErrorMsg());
         return false;
     }
 #else
     if (unlink(filename.c_str()) == -1) {
-        NGLOG_ERROR(Common_Filesystem, "unlink failed on {}: {}", filename, GetLastErrorMsg());
+        LOG_ERROR(Common_Filesystem, "unlink failed on {}: {}", filename, GetLastErrorMsg());
         return false;
     }
 #endif
@@ -160,16 +164,16 @@ bool Delete(const std::string& filename) {
 
 // Returns true if successful, or path already exists.
 bool CreateDir(const std::string& path) {
-    NGLOG_TRACE(Common_Filesystem, "directory {}", path);
+    LOG_TRACE(Common_Filesystem, "directory {}", path);
 #ifdef _WIN32
     if (::CreateDirectoryW(Common::UTF8ToUTF16W(path).c_str(), nullptr))
         return true;
     DWORD error = GetLastError();
     if (error == ERROR_ALREADY_EXISTS) {
-        NGLOG_DEBUG(Common_Filesystem, "CreateDirectory failed on {}: already exists", path);
+        LOG_DEBUG(Common_Filesystem, "CreateDirectory failed on {}: already exists", path);
         return true;
     }
-    NGLOG_ERROR(Common_Filesystem, "CreateDirectory failed on {}: {}", path, error);
+    LOG_ERROR(Common_Filesystem, "CreateDirectory failed on {}: {}", path, error);
     return false;
 #else
     if (mkdir(path.c_str(), 0755) == 0)
@@ -178,11 +182,11 @@ bool CreateDir(const std::string& path) {
     int err = errno;
 
     if (err == EEXIST) {
-        NGLOG_DEBUG(Common_Filesystem, "mkdir failed on {}: already exists", path);
+        LOG_DEBUG(Common_Filesystem, "mkdir failed on {}: already exists", path);
         return true;
     }
 
-    NGLOG_ERROR(Common_Filesystem, "mkdir failed on {}: {}", path, strerror(err));
+    LOG_ERROR(Common_Filesystem, "mkdir failed on {}: {}", path, strerror(err));
     return false;
 #endif
 }
@@ -190,10 +194,10 @@ bool CreateDir(const std::string& path) {
 // Creates the full path of fullPath returns true on success
 bool CreateFullPath(const std::string& fullPath) {
     int panicCounter = 100;
-    NGLOG_TRACE(Common_Filesystem, "path {}", fullPath);
+    LOG_TRACE(Common_Filesystem, "path {}", fullPath);
 
     if (FileUtil::Exists(fullPath)) {
-        NGLOG_DEBUG(Common_Filesystem, "path exists {}", fullPath);
+        LOG_DEBUG(Common_Filesystem, "path exists {}", fullPath);
         return true;
     }
 
@@ -209,14 +213,14 @@ bool CreateFullPath(const std::string& fullPath) {
         // Include the '/' so the first call is CreateDir("/") rather than CreateDir("")
         std::string const subPath(fullPath.substr(0, position + 1));
         if (!FileUtil::IsDirectory(subPath) && !FileUtil::CreateDir(subPath)) {
-            NGLOG_ERROR(Common, "CreateFullPath: directory creation failed");
+            LOG_ERROR(Common, "CreateFullPath: directory creation failed");
             return false;
         }
 
         // A safety check
         panicCounter--;
         if (panicCounter <= 0) {
-            NGLOG_ERROR(Common, "CreateFullPath: directory structure is too deep");
+            LOG_ERROR(Common, "CreateFullPath: directory structure is too deep");
             return false;
         }
         position++;
@@ -225,11 +229,11 @@ bool CreateFullPath(const std::string& fullPath) {
 
 // Deletes a directory filename, returns true on success
 bool DeleteDir(const std::string& filename) {
-    NGLOG_TRACE(Common_Filesystem, "directory {}", filename);
+    LOG_TRACE(Common_Filesystem, "directory {}", filename);
 
     // check if a directory
     if (!FileUtil::IsDirectory(filename)) {
-        NGLOG_ERROR(Common_Filesystem, "Not a directory {}", filename);
+        LOG_ERROR(Common_Filesystem, "Not a directory {}", filename);
         return false;
     }
 
@@ -240,14 +244,14 @@ bool DeleteDir(const std::string& filename) {
     if (rmdir(filename.c_str()) == 0)
         return true;
 #endif
-    NGLOG_ERROR(Common_Filesystem, "failed {}: {}", filename, GetLastErrorMsg());
+    LOG_ERROR(Common_Filesystem, "failed {}: {}", filename, GetLastErrorMsg());
 
     return false;
 }
 
 // renames file srcFilename to destFilename, returns true on success
 bool Rename(const std::string& srcFilename, const std::string& destFilename) {
-    NGLOG_TRACE(Common_Filesystem, "{} --> {}", srcFilename, destFilename);
+    LOG_TRACE(Common_Filesystem, "{} --> {}", srcFilename, destFilename);
 #ifdef _WIN32
     if (_wrename(Common::UTF8ToUTF16W(srcFilename).c_str(),
                  Common::UTF8ToUTF16W(destFilename).c_str()) == 0)
@@ -256,88 +260,76 @@ bool Rename(const std::string& srcFilename, const std::string& destFilename) {
     if (rename(srcFilename.c_str(), destFilename.c_str()) == 0)
         return true;
 #endif
-    NGLOG_ERROR(Common_Filesystem, "failed {} --> {}: {}", srcFilename, destFilename,
-                GetLastErrorMsg());
+    LOG_ERROR(Common_Filesystem, "failed {} --> {}: {}", srcFilename, destFilename,
+              GetLastErrorMsg());
     return false;
 }
 
 // copies file srcFilename to destFilename, returns true on success
 bool Copy(const std::string& srcFilename, const std::string& destFilename) {
-    NGLOG_TRACE(Common_Filesystem, "{} --> {}", srcFilename, destFilename);
+    LOG_TRACE(Common_Filesystem, "{} --> {}", srcFilename, destFilename);
 #ifdef _WIN32
     if (CopyFileW(Common::UTF8ToUTF16W(srcFilename).c_str(),
                   Common::UTF8ToUTF16W(destFilename).c_str(), FALSE))
         return true;
 
-    NGLOG_ERROR(Common_Filesystem, "failed {} --> {}: {}", srcFilename, destFilename,
-                GetLastErrorMsg());
+    LOG_ERROR(Common_Filesystem, "failed {} --> {}: {}", srcFilename, destFilename,
+              GetLastErrorMsg());
     return false;
 #else
-
-// buffer size
-#define BSIZE 1024
-
-    char buffer[BSIZE];
+    using CFilePointer = std::unique_ptr<FILE, decltype(&std::fclose)>;
 
     // Open input file
-    FILE* input = fopen(srcFilename.c_str(), "rb");
+    CFilePointer input{fopen(srcFilename.c_str(), "rb"), std::fclose};
     if (!input) {
-        NGLOG_ERROR(Common_Filesystem, "opening input failed {} --> {}: {}", srcFilename,
-                    destFilename, GetLastErrorMsg());
+        LOG_ERROR(Common_Filesystem, "opening input failed {} --> {}: {}", srcFilename,
+                  destFilename, GetLastErrorMsg());
         return false;
     }
 
     // open output file
-    FILE* output = fopen(destFilename.c_str(), "wb");
+    CFilePointer output{fopen(destFilename.c_str(), "wb"), std::fclose};
     if (!output) {
-        fclose(input);
-        NGLOG_ERROR(Common_Filesystem, "opening output failed {} --> {}: {}", srcFilename,
-                    destFilename, GetLastErrorMsg());
+        LOG_ERROR(Common_Filesystem, "opening output failed {} --> {}: {}", srcFilename,
+                  destFilename, GetLastErrorMsg());
         return false;
     }
 
     // copy loop
-    while (!feof(input)) {
+    std::array<char, 1024> buffer;
+    while (!feof(input.get())) {
         // read input
-        size_t rnum = fread(buffer, sizeof(char), BSIZE, input);
-        if (rnum != BSIZE) {
-            if (ferror(input) != 0) {
-                NGLOG_ERROR(Common_Filesystem, "failed reading from source, {} --> {}: {}",
-                            srcFilename, destFilename, GetLastErrorMsg());
-                goto bail;
+        size_t rnum = fread(buffer.data(), sizeof(char), buffer.size(), input.get());
+        if (rnum != buffer.size()) {
+            if (ferror(input.get()) != 0) {
+                LOG_ERROR(Common_Filesystem, "failed reading from source, {} --> {}: {}",
+                          srcFilename, destFilename, GetLastErrorMsg());
+                return false;
             }
         }
 
         // write output
-        size_t wnum = fwrite(buffer, sizeof(char), rnum, output);
+        size_t wnum = fwrite(buffer.data(), sizeof(char), rnum, output.get());
         if (wnum != rnum) {
-            NGLOG_ERROR(Common_Filesystem, "failed writing to output, {} --> {}: {}", srcFilename,
-                        destFilename, GetLastErrorMsg());
-            goto bail;
+            LOG_ERROR(Common_Filesystem, "failed writing to output, {} --> {}: {}", srcFilename,
+                      destFilename, GetLastErrorMsg());
+            return false;
         }
     }
-    // close files
-    fclose(input);
-    fclose(output);
+
     return true;
-bail:
-    if (input)
-        fclose(input);
-    if (output)
-        fclose(output);
-    return false;
 #endif
 }
 
 // Returns the size of filename (64bit)
 u64 GetSize(const std::string& filename) {
     if (!Exists(filename)) {
-        NGLOG_ERROR(Common_Filesystem, "failed {}: No such file", filename);
+        LOG_ERROR(Common_Filesystem, "failed {}: No such file", filename);
         return 0;
     }
 
     if (IsDirectory(filename)) {
-        NGLOG_ERROR(Common_Filesystem, "failed {}: is a directory", filename);
+        LOG_ERROR(Common_Filesystem, "failed {}: is a directory", filename);
         return 0;
     }
 
@@ -348,11 +340,11 @@ u64 GetSize(const std::string& filename) {
     if (stat(filename.c_str(), &buf) == 0)
 #endif
     {
-        NGLOG_TRACE(Common_Filesystem, "{}: {}", filename, buf.st_size);
+        LOG_TRACE(Common_Filesystem, "{}: {}", filename, buf.st_size);
         return buf.st_size;
     }
 
-    NGLOG_ERROR(Common_Filesystem, "Stat failed {}: {}", filename, GetLastErrorMsg());
+    LOG_ERROR(Common_Filesystem, "Stat failed {}: {}", filename, GetLastErrorMsg());
     return 0;
 }
 
@@ -360,7 +352,7 @@ u64 GetSize(const std::string& filename) {
 u64 GetSize(const int fd) {
     struct stat buf;
     if (fstat(fd, &buf) != 0) {
-        NGLOG_ERROR(Common_Filesystem, "GetSize: stat failed {}: {}", fd, GetLastErrorMsg());
+        LOG_ERROR(Common_Filesystem, "GetSize: stat failed {}: {}", fd, GetLastErrorMsg());
         return 0;
     }
     return buf.st_size;
@@ -371,14 +363,12 @@ u64 GetSize(FILE* f) {
     // can't use off_t here because it can be 32-bit
     u64 pos = ftello(f);
     if (fseeko(f, 0, SEEK_END) != 0) {
-        NGLOG_ERROR(Common_Filesystem, "GetSize: seek failed {}: {}", fmt::ptr(f),
-                    GetLastErrorMsg());
+        LOG_ERROR(Common_Filesystem, "GetSize: seek failed {}: {}", fmt::ptr(f), GetLastErrorMsg());
         return 0;
     }
     u64 size = ftello(f);
     if ((size != pos) && (fseeko(f, pos, SEEK_SET) != 0)) {
-        NGLOG_ERROR(Common_Filesystem, "GetSize: seek failed {}: {}", fmt::ptr(f),
-                    GetLastErrorMsg());
+        LOG_ERROR(Common_Filesystem, "GetSize: seek failed {}: {}", fmt::ptr(f), GetLastErrorMsg());
         return 0;
     }
     return size;
@@ -386,22 +376,22 @@ u64 GetSize(FILE* f) {
 
 // creates an empty file filename, returns true on success
 bool CreateEmptyFile(const std::string& filename) {
-    NGLOG_TRACE(Common_Filesystem, "{}", filename);
+    LOG_TRACE(Common_Filesystem, "{}", filename);
 
-    if (!FileUtil::IOFile(filename, "wb")) {
-        NGLOG_ERROR(Common_Filesystem, "failed {}: {}", filename, GetLastErrorMsg());
+    if (!FileUtil::IOFile(filename, "wb").IsOpen()) {
+        LOG_ERROR(Common_Filesystem, "failed {}: {}", filename, GetLastErrorMsg());
         return false;
     }
 
     return true;
 }
 
-bool ForeachDirectoryEntry(unsigned* num_entries_out, const std::string& directory,
+bool ForeachDirectoryEntry(u64* num_entries_out, const std::string& directory,
                            DirectoryEntryCallable callback) {
-    NGLOG_TRACE(Common_Filesystem, "directory {}", directory);
+    LOG_TRACE(Common_Filesystem, "directory {}", directory);
 
     // How many files + directories we found
-    unsigned found_entries = 0;
+    u64 found_entries = 0;
 
     // Save the status of callback function
     bool callback_error = false;
@@ -431,7 +421,7 @@ bool ForeachDirectoryEntry(unsigned* num_entries_out, const std::string& directo
         if (virtual_name == "." || virtual_name == "..")
             continue;
 
-        unsigned ret_entries = 0;
+        u64 ret_entries = 0;
         if (!callback(&ret_entries, directory, virtual_name)) {
             callback_error = true;
             break;
@@ -455,9 +445,9 @@ bool ForeachDirectoryEntry(unsigned* num_entries_out, const std::string& directo
     return true;
 }
 
-unsigned ScanDirectoryTree(const std::string& directory, FSTEntry& parent_entry,
-                           unsigned int recursion) {
-    const auto callback = [recursion, &parent_entry](unsigned* num_entries_out,
+u64 ScanDirectoryTree(const std::string& directory, FSTEntry& parent_entry,
+                      unsigned int recursion) {
+    const auto callback = [recursion, &parent_entry](u64* num_entries_out,
                                                      const std::string& directory,
                                                      const std::string& virtual_name) -> bool {
         FSTEntry entry;
@@ -469,7 +459,7 @@ unsigned ScanDirectoryTree(const std::string& directory, FSTEntry& parent_entry,
             // is a directory, lets go inside if we didn't recurse to often
             if (recursion > 0) {
                 entry.size = ScanDirectoryTree(entry.physicalName, entry, recursion - 1);
-                *num_entries_out += (int)entry.size;
+                *num_entries_out += entry.size;
             } else {
                 entry.size = 0;
             }
@@ -480,16 +470,16 @@ unsigned ScanDirectoryTree(const std::string& directory, FSTEntry& parent_entry,
         (*num_entries_out)++;
 
         // Push into the tree
-        parent_entry.children.push_back(entry);
+        parent_entry.children.push_back(std::move(entry));
         return true;
     };
 
-    unsigned num_entries;
+    u64 num_entries;
     return ForeachDirectoryEntry(&num_entries, directory, callback) ? num_entries : 0;
 }
 
 bool DeleteDirRecursively(const std::string& directory, unsigned int recursion) {
-    const auto callback = [recursion](unsigned* num_entries_out, const std::string& directory,
+    const auto callback = [recursion](u64* num_entries_out, const std::string& directory,
                                       const std::string& virtual_name) -> bool {
         std::string new_path = directory + DIR_SEP_CHR + virtual_name;
 
@@ -556,7 +546,7 @@ std::string GetCurrentDir() {
     char* dir;
     if (!(dir = getcwd(nullptr, 0))) {
 #endif
-        NGLOG_ERROR(Common_Filesystem, "GetCurrentDirectory failed: {}", GetLastErrorMsg());
+        LOG_ERROR(Common_Filesystem, "GetCurrentDirectory failed: {}", GetLastErrorMsg());
         return nullptr;
     }
 #ifdef _WIN32
@@ -593,7 +583,7 @@ std::string GetBundleDirectory() {
 #endif
 
 #ifdef _WIN32
-std::string& GetExeDirectory() {
+const std::string& GetExeDirectory() {
     static std::string exe_path;
     if (exe_path.empty()) {
         wchar_t wchar_exe_path[2048];
@@ -676,71 +666,88 @@ std::string GetSysDirectory() {
 #endif
     sysDir += DIR_SEP;
 
-    NGLOG_DEBUG(Common_Filesystem, "Setting to {}:", sysDir);
+    LOG_DEBUG(Common_Filesystem, "Setting to {}:", sysDir);
     return sysDir;
 }
 
-// Returns a string with a Citra data dir or file in the user's home
+// Returns a string with a yuzu data dir or file in the user's home
 // directory. To be used in "multi-user" mode (that is, installed).
-const std::string& GetUserPath(const unsigned int DirIDX, const std::string& newPath) {
-    static std::string paths[NUM_PATH_INDICES];
+const std::string& GetUserPath(UserPath path, const std::string& new_path) {
+    static std::unordered_map<UserPath, std::string> paths;
+    auto& user_path = paths[UserPath::UserDir];
 
     // Set up all paths and files on the first run
-    if (paths[D_USER_IDX].empty()) {
+    if (user_path.empty()) {
 #ifdef _WIN32
-        paths[D_USER_IDX] = GetExeDirectory() + DIR_SEP USERDATA_DIR DIR_SEP;
-        if (!FileUtil::IsDirectory(paths[D_USER_IDX])) {
-            paths[D_USER_IDX] = AppDataRoamingDirectory() + DIR_SEP EMU_DATA_DIR DIR_SEP;
+        user_path = GetExeDirectory() + DIR_SEP USERDATA_DIR DIR_SEP;
+        if (!FileUtil::IsDirectory(user_path)) {
+            user_path = AppDataRoamingDirectory() + DIR_SEP EMU_DATA_DIR DIR_SEP;
         } else {
-            NGLOG_INFO(Common_Filesystem, "Using the local user directory");
+            LOG_INFO(Common_Filesystem, "Using the local user directory");
         }
 
-        paths[D_CONFIG_IDX] = paths[D_USER_IDX] + CONFIG_DIR DIR_SEP;
-        paths[D_CACHE_IDX] = paths[D_USER_IDX] + CACHE_DIR DIR_SEP;
+        paths.emplace(UserPath::ConfigDir, user_path + CONFIG_DIR DIR_SEP);
+        paths.emplace(UserPath::CacheDir, user_path + CACHE_DIR DIR_SEP);
 #else
         if (FileUtil::Exists(ROOT_DIR DIR_SEP USERDATA_DIR)) {
-            paths[D_USER_IDX] = ROOT_DIR DIR_SEP USERDATA_DIR DIR_SEP;
-            paths[D_CONFIG_IDX] = paths[D_USER_IDX] + CONFIG_DIR DIR_SEP;
-            paths[D_CACHE_IDX] = paths[D_USER_IDX] + CACHE_DIR DIR_SEP;
+            user_path = ROOT_DIR DIR_SEP USERDATA_DIR DIR_SEP;
+            paths.emplace(UserPath::ConfigDir, user_path + CONFIG_DIR DIR_SEP);
+            paths.emplace(UserPath::CacheDir, user_path + CACHE_DIR DIR_SEP);
         } else {
             std::string data_dir = GetUserDirectory("XDG_DATA_HOME");
             std::string config_dir = GetUserDirectory("XDG_CONFIG_HOME");
             std::string cache_dir = GetUserDirectory("XDG_CACHE_HOME");
 
-            paths[D_USER_IDX] = data_dir + DIR_SEP EMU_DATA_DIR DIR_SEP;
-            paths[D_CONFIG_IDX] = config_dir + DIR_SEP EMU_DATA_DIR DIR_SEP;
-            paths[D_CACHE_IDX] = cache_dir + DIR_SEP EMU_DATA_DIR DIR_SEP;
+            user_path = data_dir + DIR_SEP EMU_DATA_DIR DIR_SEP;
+            paths.emplace(UserPath::ConfigDir, config_dir + DIR_SEP EMU_DATA_DIR DIR_SEP);
+            paths.emplace(UserPath::CacheDir, cache_dir + DIR_SEP EMU_DATA_DIR DIR_SEP);
         }
 #endif
-        paths[D_SDMC_IDX] = paths[D_USER_IDX] + SDMC_DIR DIR_SEP;
-        paths[D_NAND_IDX] = paths[D_USER_IDX] + NAND_DIR DIR_SEP;
-        paths[D_SYSDATA_IDX] = paths[D_USER_IDX] + SYSDATA_DIR DIR_SEP;
+        paths.emplace(UserPath::SDMCDir, user_path + SDMC_DIR DIR_SEP);
+        paths.emplace(UserPath::NANDDir, user_path + NAND_DIR DIR_SEP);
+        paths.emplace(UserPath::SysDataDir, user_path + SYSDATA_DIR DIR_SEP);
+        paths.emplace(UserPath::KeysDir, user_path + KEYS_DIR DIR_SEP);
+        // TODO: Put the logs in a better location for each OS
+        paths.emplace(UserPath::LogDir, user_path + LOG_DIR DIR_SEP);
     }
 
-    if (!newPath.empty()) {
-        if (!FileUtil::IsDirectory(newPath)) {
-            NGLOG_ERROR(Common_Filesystem, "Invalid path specified {}", newPath);
-            return paths[DirIDX];
+    if (!new_path.empty()) {
+        if (!FileUtil::IsDirectory(new_path)) {
+            LOG_ERROR(Common_Filesystem, "Invalid path specified {}", new_path);
+            return paths[path];
         } else {
-            paths[DirIDX] = newPath;
+            paths[path] = new_path;
         }
 
-        switch (DirIDX) {
-        case D_ROOT_IDX:
-            paths[D_USER_IDX] = paths[D_ROOT_IDX] + DIR_SEP;
+        switch (path) {
+        case UserPath::RootDir:
+            user_path = paths[UserPath::RootDir] + DIR_SEP;
             break;
 
-        case D_USER_IDX:
-            paths[D_USER_IDX] = paths[D_ROOT_IDX] + DIR_SEP;
-            paths[D_CONFIG_IDX] = paths[D_USER_IDX] + CONFIG_DIR DIR_SEP;
-            paths[D_CACHE_IDX] = paths[D_USER_IDX] + CACHE_DIR DIR_SEP;
-            paths[D_SDMC_IDX] = paths[D_USER_IDX] + SDMC_DIR DIR_SEP;
-            paths[D_NAND_IDX] = paths[D_USER_IDX] + NAND_DIR DIR_SEP;
+        case UserPath::UserDir:
+            user_path = paths[UserPath::RootDir] + DIR_SEP;
+            paths[UserPath::ConfigDir] = user_path + CONFIG_DIR DIR_SEP;
+            paths[UserPath::CacheDir] = user_path + CACHE_DIR DIR_SEP;
+            paths[UserPath::SDMCDir] = user_path + SDMC_DIR DIR_SEP;
+            paths[UserPath::NANDDir] = user_path + NAND_DIR DIR_SEP;
             break;
         }
     }
 
-    return paths[DirIDX];
+    return paths[path];
+}
+
+std::string GetHactoolConfigurationPath() {
+#ifdef _WIN32
+    PWSTR pw_local_path = nullptr;
+    if (SHGetKnownFolderPath(FOLDERID_Profile, 0, nullptr, &pw_local_path) != S_OK)
+        return "";
+    std::string local_path = Common::UTF16ToUTF8(pw_local_path);
+    CoTaskMemFree(pw_local_path);
+    return local_path + "\\.switch";
+#else
+    return GetHomeDirectory() + "/.switch";
+#endif
 }
 
 size_t WriteStringToFile(bool text_file, const std::string& str, const char* filename) {
@@ -750,7 +757,7 @@ size_t WriteStringToFile(bool text_file, const std::string& str, const char* fil
 size_t ReadFileToString(bool text_file, const char* filename, std::string& str) {
     IOFile file(filename, text_file ? "r" : "rb");
 
-    if (!file)
+    if (!file.IsOpen())
         return false;
 
     str.resize(static_cast<u32>(file.GetSize()));
@@ -799,10 +806,97 @@ void SplitFilename83(const std::string& filename, std::array<char, 9>& short_nam
     }
 }
 
+std::vector<std::string> SplitPathComponents(std::string_view filename) {
+    std::string copy(filename);
+    std::replace(copy.begin(), copy.end(), '\\', '/');
+    std::vector<std::string> out;
+
+    std::stringstream stream(copy);
+    std::string item;
+    while (std::getline(stream, item, '/')) {
+        out.push_back(std::move(item));
+    }
+
+    return out;
+}
+
+std::string_view GetParentPath(std::string_view path) {
+    const auto name_bck_index = path.rfind('\\');
+    const auto name_fwd_index = path.rfind('/');
+    size_t name_index;
+
+    if (name_bck_index == std::string_view::npos || name_fwd_index == std::string_view::npos) {
+        name_index = std::min(name_bck_index, name_fwd_index);
+    } else {
+        name_index = std::max(name_bck_index, name_fwd_index);
+    }
+
+    return path.substr(0, name_index);
+}
+
+std::string_view GetPathWithoutTop(std::string_view path) {
+    if (path.empty()) {
+        return path;
+    }
+
+    while (path[0] == '\\' || path[0] == '/') {
+        path.remove_prefix(1);
+        if (path.empty()) {
+            return path;
+        }
+    }
+
+    const auto name_bck_index = path.find('\\');
+    const auto name_fwd_index = path.find('/');
+    return path.substr(std::min(name_bck_index, name_fwd_index) + 1);
+}
+
+std::string_view GetFilename(std::string_view path) {
+    const auto name_index = path.find_last_of("\\/");
+
+    if (name_index == std::string_view::npos) {
+        return {};
+    }
+
+    return path.substr(name_index + 1);
+}
+
+std::string_view GetExtensionFromFilename(std::string_view name) {
+    const size_t index = name.rfind('.');
+
+    if (index == std::string_view::npos) {
+        return {};
+    }
+
+    return name.substr(index + 1);
+}
+
+std::string_view RemoveTrailingSlash(std::string_view path) {
+    if (path.empty()) {
+        return path;
+    }
+
+    if (path.back() == '\\' || path.back() == '/') {
+        path.remove_suffix(1);
+        return path;
+    }
+
+    return path;
+}
+
+std::string SanitizePath(std::string_view path_) {
+    std::string path(path_);
+    std::replace(path.begin(), path.end(), '\\', '/');
+    path.erase(std::unique(path.begin(), path.end(),
+                           [](char c1, char c2) { return c1 == '/' && c2 == '/'; }),
+               path.end());
+    return std::string(RemoveTrailingSlash(path));
+}
+
 IOFile::IOFile() {}
 
-IOFile::IOFile(const std::string& filename, const char openmode[]) {
-    Open(filename, openmode);
+IOFile::IOFile(const std::string& filename, const char openmode[], int flags) {
+    Open(filename, openmode, flags);
 }
 
 IOFile::~IOFile() {
@@ -820,28 +914,31 @@ IOFile& IOFile::operator=(IOFile&& other) noexcept {
 
 void IOFile::Swap(IOFile& other) noexcept {
     std::swap(m_file, other.m_file);
-    std::swap(m_good, other.m_good);
 }
 
-bool IOFile::Open(const std::string& filename, const char openmode[]) {
+bool IOFile::Open(const std::string& filename, const char openmode[], int flags) {
     Close();
 #ifdef _WIN32
-    _wfopen_s(&m_file, Common::UTF8ToUTF16W(filename).c_str(),
-              Common::UTF8ToUTF16W(openmode).c_str());
+    if (flags != 0) {
+        m_file = _wfsopen(Common::UTF8ToUTF16W(filename).c_str(),
+                          Common::UTF8ToUTF16W(openmode).c_str(), flags);
+    } else {
+        _wfopen_s(&m_file, Common::UTF8ToUTF16W(filename).c_str(),
+                  Common::UTF8ToUTF16W(openmode).c_str());
+    }
 #else
     m_file = fopen(filename.c_str(), openmode);
 #endif
 
-    m_good = IsOpen();
-    return m_good;
+    return IsOpen();
 }
 
 bool IOFile::Close() {
     if (!IsOpen() || 0 != std::fclose(m_file))
-        m_good = false;
+        return false;
 
     m_file = nullptr;
-    return m_good;
+    return true;
 }
 
 u64 IOFile::GetSize() const {
@@ -851,11 +948,8 @@ u64 IOFile::GetSize() const {
     return 0;
 }
 
-bool IOFile::Seek(s64 off, int origin) {
-    if (!IsOpen() || 0 != fseeko(m_file, off, origin))
-        m_good = false;
-
-    return m_good;
+bool IOFile::Seek(s64 off, int origin) const {
+    return IsOpen() && 0 == fseeko(m_file, off, origin);
 }
 
 u64 IOFile::Tell() const {
@@ -866,26 +960,20 @@ u64 IOFile::Tell() const {
 }
 
 bool IOFile::Flush() {
-    if (!IsOpen() || 0 != std::fflush(m_file))
-        m_good = false;
-
-    return m_good;
+    return IsOpen() && 0 == std::fflush(m_file);
 }
 
 bool IOFile::Resize(u64 size) {
-    if (!IsOpen() || 0 !=
+    return IsOpen() && 0 ==
 #ifdef _WIN32
-                         // ector: _chsize sucks, not 64-bit safe
-                         // F|RES: changed to _chsize_s. i think it is 64-bit safe
-                         _chsize_s(_fileno(m_file), size)
+                           // ector: _chsize sucks, not 64-bit safe
+                           // F|RES: changed to _chsize_s. i think it is 64-bit safe
+                           _chsize_s(_fileno(m_file), size)
 #else
-                         // TODO: handle 64bit and growing
-                         ftruncate(fileno(m_file), size)
+                           // TODO: handle 64bit and growing
+                           ftruncate(fileno(m_file), size)
 #endif
-    )
-        m_good = false;
-
-    return m_good;
+        ;
 }
 
 } // namespace FileUtil

src/common/file_util.h

@@ -9,6 +9,7 @@
 #include <fstream>
 #include <functional>
 #include <string>
+#include <string_view>
 #include <type_traits>
 #include <vector>
 #include "common/common_types.h"
@@ -16,21 +17,21 @@
 #include "common/string_util.h"
 #endif
 
-// User directory indices for GetUserPath
-enum {
-    D_USER_IDX,
-    D_ROOT_IDX,
-    D_CONFIG_IDX,
-    D_CACHE_IDX,
-    D_SDMC_IDX,
-    D_NAND_IDX,
-    D_SYSDATA_IDX,
-    D_LOGS_IDX,
-    NUM_PATH_INDICES
-};
-
 namespace FileUtil {
 
+// User paths for GetUserPath
+enum class UserPath {
+    CacheDir,
+    ConfigDir,
+    KeysDir,
+    LogDir,
+    NANDDir,
+    RootDir,
+    SDMCDir,
+    SysDataDir,
+    UserDir,
+};
+
 // FileSystem tree node/
 struct FSTEntry {
     bool isDirectory;
@@ -85,7 +86,7 @@ bool CreateEmptyFile(const std::string& filename);
  * @return whether handling the entry succeeded
  */
 using DirectoryEntryCallable = std::function<bool(
-    unsigned* num_entries_out, const std::string& directory, const std::string& virtual_name)>;
+    u64* num_entries_out, const std::string& directory, const std::string& virtual_name)>;
 
 /**
  * Scans a directory, calling the callback for each file/directory contained within.
@@ -96,7 +97,7 @@ using DirectoryEntryCallable = std::function<bool(
  * @param callback The callback which will be called for each entry
  * @return whether scanning the directory succeeded
  */
-bool ForeachDirectoryEntry(unsigned* num_entries_out, const std::string& directory,
+bool ForeachDirectoryEntry(u64* num_entries_out, const std::string& directory,
                            DirectoryEntryCallable callback);
 
 /**
@@ -106,8 +107,8 @@ bool ForeachDirectoryEntry(unsigned* num_entries_out, const std::string& directo
  * @param recursion Number of children directories to read before giving up.
  * @return the total number of files/directories found
  */
-unsigned ScanDirectoryTree(const std::string& directory, FSTEntry& parent_entry,
-                           unsigned int recursion = 0);
+u64 ScanDirectoryTree(const std::string& directory, FSTEntry& parent_entry,
+                      unsigned int recursion = 0);
 
 // deletes the given directory and anything under it. Returns true on success.
 bool DeleteDirRecursively(const std::string& directory, unsigned int recursion = 256);
@@ -123,7 +124,9 @@ bool SetCurrentDir(const std::string& directory);
 
 // Returns a pointer to a string with a yuzu data dir in the user's home
 // directory. To be used in "multi-user" mode (that is, installed).
-const std::string& GetUserPath(const unsigned int DirIDX, const std::string& newPath = "");
+const std::string& GetUserPath(UserPath path, const std::string& new_path = "");
+
+std::string GetHactoolConfigurationPath();
 
 // Returns the path to where the sys file are
 std::string GetSysDirectory();
@@ -133,7 +136,7 @@ std::string GetBundleDirectory();
 #endif
 
 #ifdef _WIN32
-std::string& GetExeDirectory();
+const std::string& GetExeDirectory();
 std::string AppDataRoamingDirectory();
 #endif
 
@@ -150,13 +153,47 @@ size_t ReadFileToString(bool text_file, const char* filename, std::string& str);
 void SplitFilename83(const std::string& filename, std::array<char, 9>& short_name,
                      std::array<char, 4>& extension);
 
+// Splits the path on '/' or '\' and put the components into a vector
+// i.e. "C:\Users\Yuzu\Documents\save.bin" becomes {"C:", "Users", "Yuzu", "Documents", "save.bin" }
+std::vector<std::string> SplitPathComponents(std::string_view filename);
+
+// Gets all of the text up to the last '/' or '\' in the path.
+std::string_view GetParentPath(std::string_view path);
+
+// Gets all of the text after the first '/' or '\' in the path.
+std::string_view GetPathWithoutTop(std::string_view path);
+
+// Gets the filename of the path
+std::string_view GetFilename(std::string_view path);
+
+// Gets the extension of the filename
+std::string_view GetExtensionFromFilename(std::string_view name);
+
+// Removes the final '/' or '\' if one exists
+std::string_view RemoveTrailingSlash(std::string_view path);
+
+// Creates a new vector containing indices [first, last) from the original.
+template <typename T>
+std::vector<T> SliceVector(const std::vector<T>& vector, size_t first, size_t last) {
+    if (first >= last)
+        return {};
+    last = std::min<size_t>(last, vector.size());
+    return std::vector<T>(vector.begin() + first, vector.begin() + first + last);
+}
+
+// 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
 // and make forgetting an fclose() harder
 class IOFile : public NonCopyable {
 public:
     IOFile();
-    IOFile(const std::string& filename, const char openmode[]);
+    // flags is used for windows specific file open mode flags, which
+    // allows yuzu to open the logs in shared write mode, so that the file
+    // isn't considered "locked" while yuzu is open and people can open the log file and view it
+    IOFile(const std::string& filename, const char openmode[], int flags = 0);
 
     ~IOFile();
 
@@ -165,45 +202,31 @@ public:
 
     void Swap(IOFile& other) noexcept;
 
-    bool Open(const std::string& filename, const char openmode[]);
+    bool Open(const std::string& filename, const char openmode[], int flags = 0);
     bool Close();
 
     template <typename T>
-    size_t ReadArray(T* data, size_t length) {
+    size_t ReadArray(T* data, size_t length) const {
         static_assert(std::is_trivially_copyable<T>(),
                       "Given array does not consist of trivially copyable objects");
 
-        if (!IsOpen()) {
-            m_good = false;
+        if (!IsOpen())
             return -1;
-        }
 
-        size_t items_read = std::fread(data, sizeof(T), length, m_file);
-        if (items_read != length)
-            m_good = false;
-
-        return items_read;
+        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<T>(),
                       "Given array does not consist of trivially copyable objects");
-
-        if (!IsOpen()) {
-            m_good = false;
+        if (!IsOpen())
             return -1;
-        }
-
-        size_t items_written = std::fwrite(data, sizeof(T), length, m_file);
-        if (items_written != length)
-            m_good = false;
-
-        return items_written;
+        return std::fwrite(data, sizeof(T), length, m_file);
     }
 
     template <typename T>
-    size_t ReadBytes(T* data, size_t length) {
+    size_t ReadBytes(T* data, size_t length) const {
         static_assert(std::is_trivially_copyable<T>(), "T must be trivially copyable");
         return ReadArray(reinterpret_cast<char*>(data), length);
     }
@@ -220,19 +243,15 @@ public:
         return WriteArray(&object, 1);
     }
 
+    size_t WriteString(const std::string& str) {
+        return WriteArray(str.c_str(), str.length());
+    }
+
     bool IsOpen() const {
         return nullptr != m_file;
     }
 
-    // m_good is set to false when a read, write or other function fails
-    bool IsGood() const {
-        return m_good;
-    }
-    explicit operator bool() const {
-        return IsGood();
-    }
-
-    bool Seek(s64 off, int origin);
+    bool Seek(s64 off, int origin) const;
     u64 Tell() const;
     u64 GetSize() const;
     bool Resize(u64 size);
@@ -240,13 +259,11 @@ public:
 
     // clear error state
     void Clear() {
-        m_good = true;
         std::clearerr(m_file);
     }
 
 private:
     std::FILE* m_file = nullptr;
-    bool m_good = true;
 };
 
 } // namespace FileUtil

src/common/logging/backend.cpp

@@ -2,16 +2,149 @@
 // Licensed under GPLv2 or any later version
 // Refer to the license.txt file included.
 
-#include <utility>
+#include <algorithm>
+#include <atomic>
+#include <chrono>
+#include <climits>
+#include <condition_variable>
+#include <memory>
+#include <mutex>
+#include <thread>
+#include <vector>
+#ifdef _WIN32
+#include <share.h> // For _SH_DENYWR
+#else
+#define _SH_DENYWR 0
+#endif
 #include "common/assert.h"
 #include "common/logging/backend.h"
-#include "common/logging/filter.h"
 #include "common/logging/log.h"
 #include "common/logging/text_formatter.h"
 #include "common/string_util.h"
+#include "common/threadsafe_queue.h"
 
 namespace Log {
 
+/**
+ * Static state as a singleton.
+ */
+class Impl {
+public:
+    static Impl& Instance() {
+        static Impl backend;
+        return backend;
+    }
+
+    Impl(Impl const&) = delete;
+    const Impl& operator=(Impl const&) = delete;
+
+    void PushEntry(Entry e) {
+        std::lock_guard<std::mutex> lock(message_mutex);
+        message_queue.Push(std::move(e));
+        message_cv.notify_one();
+    }
+
+    void AddBackend(std::unique_ptr<Backend> backend) {
+        std::lock_guard<std::mutex> lock(writing_mutex);
+        backends.push_back(std::move(backend));
+    }
+
+    void RemoveBackend(std::string_view backend_name) {
+        std::lock_guard<std::mutex> lock(writing_mutex);
+        const auto it =
+            std::remove_if(backends.begin(), backends.end(),
+                           [&backend_name](const auto& i) { return backend_name == i->GetName(); });
+        backends.erase(it, backends.end());
+    }
+
+    const Filter& GetGlobalFilter() const {
+        return filter;
+    }
+
+    void SetGlobalFilter(const Filter& f) {
+        filter = f;
+    }
+
+    Backend* GetBackend(std::string_view backend_name) {
+        const auto it =
+            std::find_if(backends.begin(), backends.end(),
+                         [&backend_name](const auto& i) { return backend_name == i->GetName(); });
+        if (it == backends.end())
+            return nullptr;
+        return it->get();
+    }
+
+private:
+    Impl() {
+        backend_thread = std::thread([&] {
+            Entry entry;
+            auto write_logs = [&](Entry& e) {
+                std::lock_guard<std::mutex> lock(writing_mutex);
+                for (const auto& backend : backends) {
+                    backend->Write(e);
+                }
+            };
+            while (true) {
+                {
+                    std::unique_lock<std::mutex> lock(message_mutex);
+                    message_cv.wait(lock, [&] { return !running || message_queue.Pop(entry); });
+                }
+                if (!running) {
+                    break;
+                }
+                write_logs(entry);
+            }
+            // Drain the logging queue. Only writes out up to MAX_LOGS_TO_WRITE to prevent a case
+            // where a system is repeatedly spamming logs even on close.
+            const int MAX_LOGS_TO_WRITE = filter.IsDebug() ? INT_MAX : 100;
+            int logs_written = 0;
+            while (logs_written++ < MAX_LOGS_TO_WRITE && message_queue.Pop(entry)) {
+                write_logs(entry);
+            }
+        });
+    }
+
+    ~Impl() {
+        running = false;
+        message_cv.notify_one();
+        backend_thread.join();
+    }
+
+    std::atomic_bool running{true};
+    std::mutex message_mutex, writing_mutex;
+    std::condition_variable message_cv;
+    std::thread backend_thread;
+    std::vector<std::unique_ptr<Backend>> backends;
+    Common::MPSCQueue<Log::Entry> message_queue;
+    Filter filter;
+};
+
+void ConsoleBackend::Write(const Entry& entry) {
+    PrintMessage(entry);
+}
+
+void ColorConsoleBackend::Write(const Entry& entry) {
+    PrintColoredMessage(entry);
+}
+
+// _SH_DENYWR allows read only access to the file for other programs.
+// It is #defined to 0 on other platforms
+FileBackend::FileBackend(const std::string& filename)
+    : file(filename, "w", _SH_DENYWR), bytes_written(0) {}
+
+void FileBackend::Write(const Entry& entry) {
+    // prevent logs from going over the maximum size (in case its spamming and the user doesn't
+    // know)
+    constexpr size_t MAX_BYTES_WRITTEN = 50 * 1024L * 1024L;
+    if (!file.IsOpen() || bytes_written > MAX_BYTES_WRITTEN) {
+        return;
+    }
+    bytes_written += file.WriteString(FormatLogMessage(entry) + '\n');
+    if (entry.log_level >= Level::Error) {
+        file.Flush();
+    }
+}
+
 /// Macro listing all log classes. Code should define CLS and SUB as desired before invoking this.
 #define ALL_LOG_CLASSES()                                                                          \
     CLS(Log)                                                                                       \
@@ -36,24 +169,38 @@ namespace Log {
     SUB(Service, AOC)                                                                              \
     SUB(Service, APM)                                                                              \
     SUB(Service, BCAT)                                                                             \
+    SUB(Service, BPC)                                                                              \
+    SUB(Service, BTM)                                                                              \
+    SUB(Service, Capture)                                                                          \
     SUB(Service, Fatal)                                                                            \
+    SUB(Service, FGM)                                                                              \
     SUB(Service, Friend)                                                                           \
     SUB(Service, FS)                                                                               \
     SUB(Service, HID)                                                                              \
+    SUB(Service, LBL)                                                                              \
+    SUB(Service, LDN)                                                                              \
     SUB(Service, LM)                                                                               \
+    SUB(Service, Migration)                                                                        \
+    SUB(Service, Mii)                                                                              \
     SUB(Service, MM)                                                                               \
+    SUB(Service, NCM)                                                                              \
+    SUB(Service, NFC)                                                                              \
     SUB(Service, NFP)                                                                              \
     SUB(Service, NIFM)                                                                             \
     SUB(Service, NS)                                                                               \
     SUB(Service, NVDRV)                                                                            \
+    SUB(Service, PCIE)                                                                             \
     SUB(Service, PCTL)                                                                             \
+    SUB(Service, PCV)                                                                              \
     SUB(Service, PREPO)                                                                            \
+    SUB(Service, PSC)                                                                              \
     SUB(Service, SET)                                                                              \
     SUB(Service, SM)                                                                               \
     SUB(Service, SPL)                                                                              \
     SUB(Service, SSL)                                                                              \
     SUB(Service, Time)                                                                             \
     SUB(Service, VI)                                                                               \
+    SUB(Service, WLAN)                                                                             \
     CLS(HW)                                                                                        \
     SUB(HW, Memory)                                                                                \
     SUB(HW, LCD)                                                                                   \
@@ -70,6 +217,7 @@ namespace Log {
     CLS(Input)                                                                                     \
     CLS(Network)                                                                                   \
     CLS(Loader)                                                                                    \
+    CLS(Crypto)                                                                                    \
     CLS(WebService)
 
 // GetClassName is a macro defined by Windows.h, grrr...
@@ -125,20 +273,32 @@ Entry CreateEntry(Class log_class, Level log_level, const char* filename, unsign
     return entry;
 }
 
-static Filter* filter = nullptr;
+void SetGlobalFilter(const Filter& filter) {
+    Impl::Instance().SetGlobalFilter(filter);
+}
 
-void SetFilter(Filter* new_filter) {
-    filter = new_filter;
+void AddBackend(std::unique_ptr<Backend> backend) {
+    Impl::Instance().AddBackend(std::move(backend));
+}
+
+void RemoveBackend(std::string_view backend_name) {
+    Impl::Instance().RemoveBackend(backend_name);
+}
+
+Backend* GetBackend(std::string_view backend_name) {
+    return Impl::Instance().GetBackend(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) {
-    if (filter && !filter->CheckMessage(log_class, log_level))
+    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));
 
-    PrintColoredMessage(entry);
+    Impl::Instance().PushEntry(std::move(entry));
 }
 } // namespace Log

src/common/logging/backend.h

@@ -1,13 +1,14 @@
 // Copyright 2014 Citra Emulator Project
 // Licensed under GPLv2 or any later version
 // Refer to the license.txt file included.
-
 #pragma once
 
 #include <chrono>
-#include <cstdarg>
+#include <memory>
 #include <string>
-#include <utility>
+#include <string_view>
+#include "common/file_util.h"
+#include "common/logging/filter.h"
 #include "common/logging/log.h"
 
 namespace Log {
@@ -34,6 +35,80 @@ struct Entry {
     Entry& operator=(const Entry& o) = default;
 };
 
+/**
+ * Interface for logging backends. As loggers can be created and removed at runtime, this can be
+ * used by a frontend for adding a custom logging backend as needed
+ */
+class Backend {
+public:
+    virtual ~Backend() = default;
+    virtual void SetFilter(const Filter& new_filter) {
+        filter = new_filter;
+    }
+    virtual const char* GetName() const = 0;
+    virtual void Write(const Entry& entry) = 0;
+
+private:
+    Filter filter;
+};
+
+/**
+ * Backend that writes to stderr without any color commands
+ */
+class ConsoleBackend : public Backend {
+public:
+    static const char* Name() {
+        return "console";
+    }
+    const char* GetName() const override {
+        return Name();
+    }
+    void Write(const Entry& entry) override;
+};
+
+/**
+ * Backend that writes to stderr and with color
+ */
+class ColorConsoleBackend : public Backend {
+public:
+    static const char* Name() {
+        return "color_console";
+    }
+
+    const char* GetName() const override {
+        return Name();
+    }
+    void Write(const Entry& entry) override;
+};
+
+/**
+ * Backend that writes to a file passed into the constructor
+ */
+class FileBackend : public Backend {
+public:
+    explicit FileBackend(const std::string& filename);
+
+    static const char* Name() {
+        return "file";
+    }
+
+    const char* GetName() const override {
+        return Name();
+    }
+
+    void Write(const Entry& entry) override;
+
+private:
+    FileUtil::IOFile file;
+    size_t bytes_written;
+};
+
+void AddBackend(std::unique_ptr<Backend> backend);
+
+void RemoveBackend(std::string_view backend_name);
+
+Backend* GetBackend(std::string_view backend_name);
+
 /**
  * Returns the name of the passed log class as a C-string. Subclasses are separated by periods
  * instead of underscores as in the enumeration.
@@ -49,5 +124,10 @@ const char* GetLevelName(Level log_level);
 Entry CreateEntry(Class log_class, Level log_level, const char* filename, unsigned int line_nr,
                   const char* function, std::string message);
 
-void SetFilter(Filter* filter);
-} // namespace Log
+/**
+ * The global filter will prevent any messages from even being processed if they are filtered. Each
+ * backend can have a filter, but if the level is lower than the global filter, the backend will
+ * never get the message
+ */
+void SetGlobalFilter(const Filter& filter);
+} // namespace Log

src/common/logging/filter.cpp

@@ -8,6 +8,59 @@
 #include "common/string_util.h"
 
 namespace Log {
+namespace {
+template <typename It>
+Level GetLevelByName(const It begin, const It end) {
+    for (u8 i = 0; i < static_cast<u8>(Level::Count); ++i) {
+        const char* level_name = GetLevelName(static_cast<Level>(i));
+        if (Common::ComparePartialString(begin, end, level_name)) {
+            return static_cast<Level>(i);
+        }
+    }
+    return Level::Count;
+}
+
+template <typename It>
+Class GetClassByName(const It begin, const It end) {
+    for (ClassType i = 0; i < static_cast<ClassType>(Class::Count); ++i) {
+        const char* level_name = GetLogClassName(static_cast<Class>(i));
+        if (Common::ComparePartialString(begin, end, level_name)) {
+            return static_cast<Class>(i);
+        }
+    }
+    return Class::Count;
+}
+
+template <typename Iterator>
+bool ParseFilterRule(Filter& instance, Iterator begin, Iterator end) {
+    auto level_separator = std::find(begin, end, ':');
+    if (level_separator == end) {
+        LOG_ERROR(Log, "Invalid log filter. Must specify a log level after `:`: {}",
+                  std::string(begin, end));
+        return false;
+    }
+
+    const Level level = GetLevelByName(level_separator + 1, end);
+    if (level == Level::Count) {
+        LOG_ERROR(Log, "Unknown log level in filter: {}", std::string(begin, end));
+        return false;
+    }
+
+    if (Common::ComparePartialString(begin, level_separator, "*")) {
+        instance.ResetAll(level);
+        return true;
+    }
+
+    const Class log_class = GetClassByName(begin, level_separator);
+    if (log_class == Class::Count) {
+        LOG_ERROR(Log, "Unknown log class in filter: {}", std::string(begin, end));
+        return false;
+    }
+
+    instance.SetClassLevel(log_class, level);
+    return true;
+}
+} // Anonymous namespace
 
 Filter::Filter(Level default_level) {
     ResetAll(default_level);
@@ -21,17 +74,17 @@ void Filter::SetClassLevel(Class log_class, Level level) {
     class_levels[static_cast<size_t>(log_class)] = level;
 }
 
-void Filter::ParseFilterString(const std::string& filter_str) {
-    auto clause_begin = filter_str.cbegin();
-    while (clause_begin != filter_str.cend()) {
-        auto clause_end = std::find(clause_begin, filter_str.cend(), ' ');
+void Filter::ParseFilterString(std::string_view filter_view) {
+    auto clause_begin = filter_view.cbegin();
+    while (clause_begin != filter_view.cend()) {
+        auto clause_end = std::find(clause_begin, filter_view.cend(), ' ');
 
         // If clause isn't empty
         if (clause_end != clause_begin) {
-            ParseFilterRule(clause_begin, clause_end);
+            ParseFilterRule(*this, clause_begin, clause_end);
         }
 
-        if (clause_end != filter_str.cend()) {
+        if (clause_end != filter_view.cend()) {
             // Skip over the whitespace
             ++clause_end;
         }
@@ -39,59 +92,14 @@ void Filter::ParseFilterString(const std::string& filter_str) {
     }
 }
 
-template <typename It>
-static Level GetLevelByName(const It begin, const It end) {
-    for (u8 i = 0; i < static_cast<u8>(Level::Count); ++i) {
-        const char* level_name = GetLevelName(static_cast<Level>(i));
-        if (Common::ComparePartialString(begin, end, level_name)) {
-            return static_cast<Level>(i);
-        }
-    }
-    return Level::Count;
-}
-
-template <typename It>
-static Class GetClassByName(const It begin, const It end) {
-    for (ClassType i = 0; i < static_cast<ClassType>(Class::Count); ++i) {
-        const char* level_name = GetLogClassName(static_cast<Class>(i));
-        if (Common::ComparePartialString(begin, end, level_name)) {
-            return static_cast<Class>(i);
-        }
-    }
-    return Class::Count;
-}
-
-bool Filter::ParseFilterRule(const std::string::const_iterator begin,
-                             const std::string::const_iterator end) {
-    auto level_separator = std::find(begin, end, ':');
-    if (level_separator == end) {
-        NGLOG_ERROR(Log, "Invalid log filter. Must specify a log level after `:`: %s",
-                    std::string(begin, end).c_str());
-        return false;
-    }
-
-    const Level level = GetLevelByName(level_separator + 1, end);
-    if (level == Level::Count) {
-        NGLOG_ERROR(Log, "Unknown log level in filter: %s", std::string(begin, end).c_str());
-        return false;
-    }
-
-    if (Common::ComparePartialString(begin, level_separator, "*")) {
-        ResetAll(level);
-        return true;
-    }
-
-    const Class log_class = GetClassByName(begin, level_separator);
-    if (log_class == Class::Count) {
-        NGLOG_ERROR(Log, "Unknown log class in filter: %s", std::string(begin, end).c_str());
-        return false;
-    }
-
-    SetClassLevel(log_class, level);
-    return true;
-}
-
 bool Filter::CheckMessage(Class log_class, Level level) const {
     return static_cast<u8>(level) >= static_cast<u8>(class_levels[static_cast<size_t>(log_class)]);
 }
+
+bool Filter::IsDebug() const {
+    return std::any_of(class_levels.begin(), class_levels.end(), [](const Level& l) {
+        return static_cast<u8>(l) <= static_cast<u8>(Level::Debug);
+    });
+}
+
 } // namespace Log

src/common/logging/filter.h

@@ -6,7 +6,7 @@
 
 #include <array>
 #include <cstddef>
-#include <string>
+#include <string_view>
 #include "common/logging/log.h"
 
 namespace Log {
@@ -40,13 +40,14 @@ public:
      *  - `Service:Info` -- Sets the level of Service to Info.
      *  - `Service.FS:Trace` -- Sets the level of the Service.FS class to Trace.
      */
-    void ParseFilterString(const std::string& filter_str);
-    bool ParseFilterRule(const std::string::const_iterator start,
-                         const std::string::const_iterator end);
+    void ParseFilterString(std::string_view filter_view);
 
     /// Matches class/level combination against the filter, returning true if it passed.
     bool CheckMessage(Class log_class, Level level) const;
 
+    /// Returns true if any logging classes are set to debug
+    bool IsDebug() const;
+
 private:
     std::array<Level, (size_t)Class::Count> class_levels;
 };

src/common/logging/log.h

@@ -56,24 +56,38 @@ enum class Class : ClassType {
     Service_APM,       ///< The APM (Performance) service
     Service_Audio,     ///< The Audio (Audio control) service
     Service_BCAT,      ///< The BCAT service
+    Service_BPC,       ///< The BPC service
+    Service_BTM,       ///< The BTM service
+    Service_Capture,   ///< The capture service
     Service_Fatal,     ///< The Fatal service
+    Service_FGM,       ///< The FGM service
     Service_Friend,    ///< The friend service
     Service_FS,        ///< The FS (Filesystem) 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_LM,        ///< The LM (Logger) service
+    Service_Migration, ///< The migration service
+    Service_Mii,       ///< The Mii service
     Service_MM,        ///< The MM (Multimedia) service
+    Service_NCM,       ///< The NCM service
+    Service_NFC,       ///< The NFC (Near-field communication) service
     Service_NFP,       ///< The NFP service
     Service_NIFM,      ///< The NIFM (Network interface) 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_PREPO,     ///< The PREPO (Play report) service
+    Service_PSC,       ///< The PSC service
     Service_SET,       ///< The SET (Settings) service
     Service_SM,        ///< The SM (Service manager) service
     Service_SPL,       ///< The SPL service
     Service_SSL,       ///< The SSL service
     Service_Time,      ///< The time service
     Service_VI,        ///< The VI (Video interface) service
+    Service_WLAN,      ///< The WLAN (Wireless local area network) service
     HW,                ///< Low-level hardware emulation
     HW_Memory,         ///< Memory-map and address translation
     HW_LCD,            ///< LCD register emulation
@@ -88,6 +102,7 @@ enum class Class : ClassType {
     Audio_DSP,         ///< The HLE implementation of the DSP
     Audio_Sink,        ///< Emulator audio output backend
     Loader,            ///< ROM loader
+    Crypto,            ///< Cryptographic engine/functions
     Input,             ///< Input emulation
     Network,           ///< Network emulation
     WebService,        ///< Interface to yuzu Web Services
@@ -103,31 +118,31 @@ template <typename... Args>
 void FmtLogMessage(Class log_class, Level log_level, const char* filename, unsigned int line_num,
                    const char* function, const char* format, const Args&... args) {
     FmtLogMessageImpl(log_class, log_level, filename, line_num, function, format,
-                      fmt::make_args(args...));
+                      fmt::make_format_args(args...));
 }
 
 } // namespace Log
 
 #ifdef _DEBUG
-#define NGLOG_TRACE(log_class, ...)                                                                \
+#define LOG_TRACE(log_class, ...)                                                                  \
     ::Log::FmtLogMessage(::Log::Class::log_class, ::Log::Level::Trace, __FILE__, __LINE__,         \
                          __func__, __VA_ARGS__)
 #else
-#define NGLOG_TRACE(log_class, fmt, ...) (void(0))
+#define LOG_TRACE(log_class, fmt, ...) (void(0))
 #endif
 
-#define NGLOG_DEBUG(log_class, ...)                                                                \
+#define LOG_DEBUG(log_class, ...)                                                                  \
     ::Log::FmtLogMessage(::Log::Class::log_class, ::Log::Level::Debug, __FILE__, __LINE__,         \
                          __func__, __VA_ARGS__)
-#define NGLOG_INFO(log_class, ...)                                                                 \
+#define LOG_INFO(log_class, ...)                                                                   \
     ::Log::FmtLogMessage(::Log::Class::log_class, ::Log::Level::Info, __FILE__, __LINE__,          \
                          __func__, __VA_ARGS__)
-#define NGLOG_WARNING(log_class, ...)                                                              \
+#define LOG_WARNING(log_class, ...)                                                                \
     ::Log::FmtLogMessage(::Log::Class::log_class, ::Log::Level::Warning, __FILE__, __LINE__,       \
                          __func__, __VA_ARGS__)
-#define NGLOG_ERROR(log_class, ...)                                                                \
+#define LOG_ERROR(log_class, ...)                                                                  \
     ::Log::FmtLogMessage(::Log::Class::log_class, ::Log::Level::Error, __FILE__, __LINE__,         \
                          __func__, __VA_ARGS__)
-#define NGLOG_CRITICAL(log_class, ...)                                                             \
+#define LOG_CRITICAL(log_class, ...)                                                               \
     ::Log::FmtLogMessage(::Log::Class::log_class, ::Log::Level::Critical, __FILE__, __LINE__,      \
                          __func__, __VA_ARGS__)

src/common/logging/text_formatter.h

@@ -5,6 +5,7 @@
 #pragma once
 
 #include <cstddef>
+#include <string>
 
 namespace Log {
 

src/common/math_util.h

@@ -19,12 +19,12 @@ inline bool IntervalsIntersect(unsigned start0, unsigned length0, unsigned start
 
 template <class T>
 struct Rectangle {
-    T left;
-    T top;
-    T right;
-    T bottom;
+    T left{};
+    T top{};
+    T right{};
+    T bottom{};
 
-    Rectangle() {}
+    Rectangle() = default;
 
     Rectangle(T left, T top, T right, T bottom)
         : left(left), top(top), right(right), bottom(bottom) {}

src/common/memory_util.cpp

@@ -16,7 +16,7 @@
 #include <sys/mman.h>
 #endif
 
-#if !defined(_WIN32) && defined(ARCHITECTURE_X64) && !defined(MAP_32BIT)
+#if !defined(_WIN32) && defined(ARCHITECTURE_x86_64) && !defined(MAP_32BIT)
 #include <unistd.h>
 #define PAGE_MASK (getpagesize() - 1)
 #define round_page(x) ((((unsigned long)(x)) + PAGE_MASK) & ~(PAGE_MASK))
@@ -30,7 +30,7 @@ void* AllocateExecutableMemory(size_t size, bool low) {
     void* ptr = VirtualAlloc(nullptr, size, MEM_COMMIT, PAGE_EXECUTE_READWRITE);
 #else
     static char* map_hint = nullptr;
-#if defined(ARCHITECTURE_X64) && !defined(MAP_32BIT)
+#if defined(ARCHITECTURE_x86_64) && !defined(MAP_32BIT)
     // This OS has no flag to enforce allocation below the 4 GB boundary,
     // but if we hint that we want a low address it is very likely we will
     // get one.
@@ -42,7 +42,7 @@ void* AllocateExecutableMemory(size_t size, bool low) {
 #endif
     void* ptr = mmap(map_hint, size, PROT_READ | PROT_WRITE | PROT_EXEC,
                      MAP_ANON | MAP_PRIVATE
-#if defined(ARCHITECTURE_X64) && defined(MAP_32BIT)
+#if defined(ARCHITECTURE_x86_64) && defined(MAP_32BIT)
                          | (low ? MAP_32BIT : 0)
 #endif
                          ,
@@ -55,9 +55,9 @@ void* AllocateExecutableMemory(size_t size, bool low) {
     if (ptr == MAP_FAILED) {
         ptr = nullptr;
 #endif
-        NGLOG_ERROR(Common_Memory, "Failed to allocate executable memory");
+        LOG_ERROR(Common_Memory, "Failed to allocate executable memory");
     }
-#if !defined(_WIN32) && defined(ARCHITECTURE_X64) && !defined(MAP_32BIT)
+#if !defined(_WIN32) && defined(ARCHITECTURE_x86_64) && !defined(MAP_32BIT)
     else {
         if (low) {
             map_hint += size;
@@ -68,7 +68,7 @@ void* AllocateExecutableMemory(size_t size, bool low) {
 
 #if EMU_ARCH_BITS == 64
     if ((u64)ptr >= 0x80000000 && low == true)
-        NGLOG_ERROR(Common_Memory, "Executable memory ended up above 2GB!");
+        LOG_ERROR(Common_Memory, "Executable memory ended up above 2GB!");
 #endif
 
     return ptr;
@@ -85,7 +85,7 @@ void* AllocateMemoryPages(size_t size) {
 #endif
 
     if (ptr == nullptr)
-        NGLOG_ERROR(Common_Memory, "Failed to allocate raw memory");
+        LOG_ERROR(Common_Memory, "Failed to allocate raw memory");
 
     return ptr;
 }
@@ -99,12 +99,12 @@ void* AllocateAlignedMemory(size_t size, size_t alignment) {
     ptr = memalign(alignment, size);
 #else
     if (posix_memalign(&ptr, alignment, size) != 0)
-        NGLOG_ERROR(Common_Memory, "Failed to allocate aligned memory");
+        LOG_ERROR(Common_Memory, "Failed to allocate aligned memory");
 #endif
 #endif
 
     if (ptr == nullptr)
-        NGLOG_ERROR(Common_Memory, "Failed to allocate aligned memory");
+        LOG_ERROR(Common_Memory, "Failed to allocate aligned memory");
 
     return ptr;
 }
@@ -113,7 +113,7 @@ void FreeMemoryPages(void* ptr, size_t size) {
     if (ptr) {
 #ifdef _WIN32
         if (!VirtualFree(ptr, 0, MEM_RELEASE))
-            NGLOG_ERROR(Common_Memory, "FreeMemoryPages failed!\n{}", GetLastErrorMsg());
+            LOG_ERROR(Common_Memory, "FreeMemoryPages failed!\n{}", GetLastErrorMsg());
 #else
         munmap(ptr, size);
 #endif
@@ -134,7 +134,7 @@ void WriteProtectMemory(void* ptr, size_t size, bool allowExecute) {
 #ifdef _WIN32
     DWORD oldValue;
     if (!VirtualProtect(ptr, size, allowExecute ? PAGE_EXECUTE_READ : PAGE_READONLY, &oldValue))
-        NGLOG_ERROR(Common_Memory, "WriteProtectMemory failed!\n{}", GetLastErrorMsg());
+        LOG_ERROR(Common_Memory, "WriteProtectMemory failed!\n{}", GetLastErrorMsg());
 #else
     mprotect(ptr, size, allowExecute ? (PROT_READ | PROT_EXEC) : PROT_READ);
 #endif
@@ -145,7 +145,7 @@ void UnWriteProtectMemory(void* ptr, size_t size, bool allowExecute) {
     DWORD oldValue;
     if (!VirtualProtect(ptr, size, allowExecute ? PAGE_EXECUTE_READWRITE : PAGE_READWRITE,
                         &oldValue))
-        NGLOG_ERROR(Common_Memory, "UnWriteProtectMemory failed!\n{}", GetLastErrorMsg());
+        LOG_ERROR(Common_Memory, "UnWriteProtectMemory failed!\n{}", GetLastErrorMsg());
 #else
     mprotect(ptr, size,
              allowExecute ? (PROT_READ | PROT_WRITE | PROT_EXEC) : PROT_WRITE | PROT_READ);

src/common/misc.cpp

@@ -4,34 +4,28 @@
 
 #include <cstddef>
 #ifdef _WIN32
-#include <windows.h>
+#include <Windows.h>
 #else
 #include <cerrno>
 #include <cstring>
 #endif
 
-// Neither Android nor OS X support TLS
-#if defined(__APPLE__) || (ANDROID && __clang__)
-#define __thread
-#endif
+#include "common/common_funcs.h"
 
 // Generic function to get last error message.
 // Call directly after the command or use the error num.
 // This function might change the error code.
-const char* GetLastErrorMsg() {
+std::string GetLastErrorMsg() {
     static const size_t buff_size = 255;
+    char err_str[buff_size];
 
 #ifdef _WIN32
-    static __declspec(thread) char err_str[buff_size] = {};
-
     FormatMessageA(FORMAT_MESSAGE_FROM_SYSTEM, nullptr, GetLastError(),
                    MAKELANGID(LANG_NEUTRAL, SUBLANG_DEFAULT), err_str, buff_size, nullptr);
 #else
-    static __thread char err_str[buff_size] = {};
-
     // Thread safe (XSI-compliant)
     strerror_r(errno, err_str, buff_size);
 #endif
 
-    return err_str;
+    return std::string(err_str, buff_size);
 }

src/common/param_package.cpp

@@ -3,7 +3,9 @@
 // Refer to the license.txt file included.
 
 #include <array>
+#include <utility>
 #include <vector>
+
 #include "common/logging/log.h"
 #include "common/param_package.h"
 #include "common/string_util.h"
@@ -12,10 +14,11 @@ namespace Common {
 
 constexpr char KEY_VALUE_SEPARATOR = ':';
 constexpr char PARAM_SEPARATOR = ',';
+
 constexpr char ESCAPE_CHARACTER = '$';
-const std::string KEY_VALUE_SEPARATOR_ESCAPE{ESCAPE_CHARACTER, '0'};
-const std::string PARAM_SEPARATOR_ESCAPE{ESCAPE_CHARACTER, '1'};
-const std::string ESCAPE_CHARACTER_ESCAPE{ESCAPE_CHARACTER, '2'};
+constexpr char KEY_VALUE_SEPARATOR_ESCAPE[] = "$0";
+constexpr char PARAM_SEPARATOR_ESCAPE[] = "$1";
+constexpr char ESCAPE_CHARACTER_ESCAPE[] = "$2";
 
 ParamPackage::ParamPackage(const std::string& serialized) {
     std::vector<std::string> pairs;
@@ -25,7 +28,7 @@ ParamPackage::ParamPackage(const std::string& serialized) {
         std::vector<std::string> key_value;
         Common::SplitString(pair, KEY_VALUE_SEPARATOR, key_value);
         if (key_value.size() != 2) {
-            NGLOG_ERROR(Common, "invalid key pair {}", pair);
+            LOG_ERROR(Common, "invalid key pair {}", pair);
             continue;
         }
 
@@ -35,7 +38,7 @@ ParamPackage::ParamPackage(const std::string& serialized) {
             part = Common::ReplaceAll(part, ESCAPE_CHARACTER_ESCAPE, {ESCAPE_CHARACTER});
         }
 
-        Set(key_value[0], key_value[1]);
+        Set(key_value[0], std::move(key_value[1]));
     }
 }
 
@@ -64,7 +67,7 @@ std::string ParamPackage::Serialize() const {
 std::string ParamPackage::Get(const std::string& key, const std::string& default_value) const {
     auto pair = data.find(key);
     if (pair == data.end()) {
-        NGLOG_DEBUG(Common, "key '{}' not found", key);
+        LOG_DEBUG(Common, "key '{}' not found", key);
         return default_value;
     }
 
@@ -74,14 +77,14 @@ std::string ParamPackage::Get(const std::string& key, const std::string& default
 int ParamPackage::Get(const std::string& key, int default_value) const {
     auto pair = data.find(key);
     if (pair == data.end()) {
-        NGLOG_DEBUG(Common, "key '{}' not found", key);
+        LOG_DEBUG(Common, "key '{}' not found", key);
         return default_value;
     }
 
     try {
         return std::stoi(pair->second);
     } catch (const std::logic_error&) {
-        NGLOG_ERROR(Common, "failed to convert {} to int", pair->second);
+        LOG_ERROR(Common, "failed to convert {} to int", pair->second);
         return default_value;
     }
 }
@@ -89,28 +92,28 @@ int ParamPackage::Get(const std::string& key, int default_value) const {
 float ParamPackage::Get(const std::string& key, float default_value) const {
     auto pair = data.find(key);
     if (pair == data.end()) {
-        NGLOG_DEBUG(Common, "key {} not found", key);
+        LOG_DEBUG(Common, "key {} not found", key);
         return default_value;
     }
 
     try {
         return std::stof(pair->second);
     } catch (const std::logic_error&) {
-        NGLOG_ERROR(Common, "failed to convert {} to float", pair->second);
+        LOG_ERROR(Common, "failed to convert {} to float", pair->second);
         return default_value;
     }
 }
 
-void ParamPackage::Set(const std::string& key, const std::string& value) {
-    data[key] = value;
+void ParamPackage::Set(const std::string& key, std::string value) {
+    data.insert_or_assign(key, std::move(value));
 }
 
 void ParamPackage::Set(const std::string& key, int value) {
-    data[key] = std::to_string(value);
+    data.insert_or_assign(key, std::to_string(value));
 }
 
 void ParamPackage::Set(const std::string& key, float value) {
-    data[key] = std::to_string(value);
+    data.insert_or_assign(key, std::to_string(value));
 }
 
 bool ParamPackage::Has(const std::string& key) const {

src/common/param_package.h

@@ -28,7 +28,7 @@ public:
     std::string Get(const std::string& key, const std::string& default_value) const;
     int Get(const std::string& key, int default_value) const;
     float Get(const std::string& key, float default_value) const;
-    void Set(const std::string& key, const std::string& value);
+    void Set(const std::string& key, std::string value);
     void Set(const std::string& key, int value);
     void Set(const std::string& key, float value);
     bool Has(const std::string& key) const;

src/common/string_util.cpp

@@ -2,12 +2,12 @@
 // Licensed under GPLv2 or any later version
 // Refer to the license.txt file included.
 
+#include <algorithm>
 #include <cctype>
 #include <cerrno>
 #include <cstdio>
 #include <cstdlib>
 #include <cstring>
-#include <boost/range/algorithm/transform.hpp>
 #include "common/common_paths.h"
 #include "common/logging/log.h"
 #include "common/string_util.h"
@@ -24,28 +24,18 @@ namespace Common {
 
 /// Make a string lowercase
 std::string ToLower(std::string str) {
-    boost::transform(str, str.begin(), ::tolower);
+    std::transform(str.begin(), str.end(), str.begin(),
+                   [](unsigned char c) { return std::tolower(c); });
     return str;
 }
 
 /// Make a string uppercase
 std::string ToUpper(std::string str) {
-    boost::transform(str, str.begin(), ::toupper);
+    std::transform(str.begin(), str.end(), str.begin(),
+                   [](unsigned char c) { return std::toupper(c); });
     return str;
 }
 
-// faster than sscanf
-bool AsciiToHex(const char* _szValue, u32& result) {
-    char* endptr = nullptr;
-    const u32 value = strtoul(_szValue, &endptr, 16);
-
-    if (!endptr || *endptr)
-        return false;
-
-    result = value;
-    return true;
-}
-
 // For Debugging. Read out an u8 array.
 std::string ArrayToString(const u8* data, size_t size, int line_len, bool spaces) {
     std::ostringstream oss;
@@ -134,7 +124,7 @@ bool SplitPath(const std::string& full_path, std::string* _pPath, std::string* _
     size_t dir_end = full_path.find_last_of("/"
 // windows needs the : included for something like just "C:" to be considered a directory
 #ifdef _WIN32
-                                            ":"
+                                            "\\:"
 #endif
     );
     if (std::string::npos == dir_end)
@@ -174,21 +164,21 @@ void SplitString(const std::string& str, const char delim, std::vector<std::stri
     std::istringstream iss(str);
     output.resize(1);
 
-    while (std::getline(iss, *output.rbegin(), delim))
-        output.push_back("");
+    while (std::getline(iss, *output.rbegin(), delim)) {
+        output.emplace_back();
+    }
 
     output.pop_back();
 }
 
-std::string TabsToSpaces(int tab_size, const std::string& in) {
-    const std::string spaces(tab_size, ' ');
-    std::string out(in);
-
+std::string TabsToSpaces(int tab_size, std::string in) {
     size_t i = 0;
-    while (out.npos != (i = out.find('\t')))
-        out.replace(i, 1, spaces);
 
-    return out;
+    while ((i = in.find('\t')) != std::string::npos) {
+        in.replace(i, 1, tab_size, ' ');
+    }
+
+    return in;
 }
 
 std::string ReplaceAll(std::string result, const std::string& src, const std::string& dest) {
@@ -232,31 +222,37 @@ std::u16string UTF8ToUTF16(const std::string& input) {
 }
 
 static std::wstring CPToUTF16(u32 code_page, const std::string& input) {
-    auto const size =
+    const auto size =
         MultiByteToWideChar(code_page, 0, input.data(), static_cast<int>(input.size()), nullptr, 0);
 
-    std::wstring output;
-    output.resize(size);
+    if (size == 0) {
+        return L"";
+    }
 
-    if (size == 0 ||
-        size != MultiByteToWideChar(code_page, 0, input.data(), static_cast<int>(input.size()),
-                                    &output[0], static_cast<int>(output.size())))
+    std::wstring output(size, L'\0');
+
+    if (size != MultiByteToWideChar(code_page, 0, input.data(), static_cast<int>(input.size()),
+                                    &output[0], static_cast<int>(output.size()))) {
         output.clear();
+    }
 
     return output;
 }
 
 std::string UTF16ToUTF8(const std::wstring& input) {
-    auto const size = WideCharToMultiByte(CP_UTF8, 0, input.data(), static_cast<int>(input.size()),
+    const auto size = WideCharToMultiByte(CP_UTF8, 0, input.data(), static_cast<int>(input.size()),
                                           nullptr, 0, nullptr, nullptr);
+    if (size == 0) {
+        return "";
+    }
 
-    std::string output;
-    output.resize(size);
+    std::string output(size, '\0');
 
-    if (size == 0 ||
-        size != WideCharToMultiByte(CP_UTF8, 0, input.data(), static_cast<int>(input.size()),
-                                    &output[0], static_cast<int>(output.size()), nullptr, nullptr))
+    if (size != WideCharToMultiByte(CP_UTF8, 0, input.data(), static_cast<int>(input.size()),
+                                    &output[0], static_cast<int>(output.size()), nullptr,
+                                    nullptr)) {
         output.clear();
+    }
 
     return output;
 }
@@ -277,11 +273,9 @@ std::string CP1252ToUTF8(const std::string& input) {
 
 template <typename T>
 static std::string CodeToUTF8(const char* fromcode, const std::basic_string<T>& input) {
-    std::string result;
-
     iconv_t const conv_desc = iconv_open("UTF-8", fromcode);
     if ((iconv_t)(-1) == conv_desc) {
-        NGLOG_ERROR(Common, "Iconv initialization failure [{}]: {}", fromcode, strerror(errno));
+        LOG_ERROR(Common, "Iconv initialization failure [{}]: {}", fromcode, strerror(errno));
         iconv_close(conv_desc);
         return {};
     }
@@ -290,8 +284,7 @@ static std::string CodeToUTF8(const char* fromcode, const std::basic_string<T>&
     // Multiply by 4, which is the max number of bytes to encode a codepoint
     const size_t out_buffer_size = 4 * in_bytes;
 
-    std::string out_buffer;
-    out_buffer.resize(out_buffer_size);
+    std::string out_buffer(out_buffer_size, '\0');
 
     auto src_buffer = &input[0];
     size_t src_bytes = in_bytes;
@@ -310,12 +303,13 @@ static std::string CodeToUTF8(const char* fromcode, const std::basic_string<T>&
                     ++src_buffer;
                 }
             } else {
-                NGLOG_ERROR(Common, "iconv failure [{}]: {}", fromcode, strerror(errno));
+                LOG_ERROR(Common, "iconv failure [{}]: {}", fromcode, strerror(errno));
                 break;
             }
         }
     }
 
+    std::string result;
     out_buffer.resize(out_buffer_size - dst_bytes);
     out_buffer.swap(result);
 
@@ -325,11 +319,9 @@ static std::string CodeToUTF8(const char* fromcode, const std::basic_string<T>&
 }
 
 std::u16string UTF8ToUTF16(const std::string& input) {
-    std::u16string result;
-
     iconv_t const conv_desc = iconv_open("UTF-16LE", "UTF-8");
     if ((iconv_t)(-1) == conv_desc) {
-        NGLOG_ERROR(Common, "Iconv initialization failure [UTF-8]: {}", strerror(errno));
+        LOG_ERROR(Common, "Iconv initialization failure [UTF-8]: {}", strerror(errno));
         iconv_close(conv_desc);
         return {};
     }
@@ -338,8 +330,7 @@ std::u16string UTF8ToUTF16(const std::string& input) {
     // Multiply by 4, which is the max number of bytes to encode a codepoint
     const size_t out_buffer_size = 4 * sizeof(char16_t) * in_bytes;
 
-    std::u16string out_buffer;
-    out_buffer.resize(out_buffer_size);
+    std::u16string out_buffer(out_buffer_size, char16_t{});
 
     char* src_buffer = const_cast<char*>(&input[0]);
     size_t src_bytes = in_bytes;
@@ -358,12 +349,13 @@ std::u16string UTF8ToUTF16(const std::string& input) {
                     ++src_buffer;
                 }
             } else {
-                NGLOG_ERROR(Common, "iconv failure [UTF-8]: {}", strerror(errno));
+                LOG_ERROR(Common, "iconv failure [UTF-8]: {}", strerror(errno));
                 break;
             }
         }
     }
 
+    std::u16string result;
     out_buffer.resize(out_buffer_size - dst_bytes);
     out_buffer.swap(result);
 

src/common/string_util.h

@@ -57,10 +57,7 @@ static bool TryParse(const std::string& str, N* const output) {
         return false;
 }
 
-// TODO: kill this
-bool AsciiToHex(const char* _szValue, u32& result);
-
-std::string TabsToSpaces(int tab_size, const std::string& in);
+std::string TabsToSpaces(int tab_size, std::string in);
 
 void SplitString(const std::string& str, char delim, std::vector<std::string>& output);
 

src/common/swap.h

@@ -69,7 +69,7 @@ inline u32 swap32(u32 _data) {
 inline u64 swap64(u64 _data) {
     return _byteswap_uint64(_data);
 }
-#elif _M_ARM
+#elif defined(ARCHITECTURE_ARM) && (__ARM_ARCH >= 6)
 inline u16 swap16(u16 _data) {
     u32 data = _data;
     __asm__("rev16 %0, %1\n" : "=l"(data) : "l"(data));
@@ -167,7 +167,7 @@ inline double swapd(double f) {
 
 template <typename T, typename F>
 struct swap_struct_t {
-    typedef swap_struct_t<T, F> swapped_t;
+    using swapped_t = swap_struct_t;
 
 protected:
     T value = T();
@@ -177,7 +177,7 @@ protected:
     }
 
 public:
-    T const swap() const {
+    T swap() const {
         return swap(value);
     }
     swap_struct_t() = default;
@@ -185,39 +185,39 @@ public:
 
     template <typename S>
     swapped_t& operator=(const S& source) {
-        value = swap((T)source);
+        value = swap(static_cast<T>(source));
         return *this;
     }
 
     operator s8() const {
-        return (s8)swap();
+        return static_cast<s8>(swap());
     }
     operator u8() const {
-        return (u8)swap();
+        return static_cast<u8>(swap());
     }
     operator s16() const {
-        return (s16)swap();
+        return static_cast<s16>(swap());
     }
     operator u16() const {
-        return (u16)swap();
+        return static_cast<u16>(swap());
     }
     operator s32() const {
-        return (s32)swap();
+        return static_cast<s32>(swap());
     }
     operator u32() const {
-        return (u32)swap();
+        return static_cast<u32>(swap());
     }
     operator s64() const {
-        return (s64)swap();
+        return static_cast<s64>(swap());
     }
     operator u64() const {
-        return (u64)swap();
+        return static_cast<u64>(swap());
     }
     operator float() const {
-        return (float)swap();
+        return static_cast<float>(swap());
     }
     operator double() const {
-        return (double)swap();
+        return static_cast<double>(swap());
     }
 
     // +v
@@ -253,7 +253,7 @@ public:
     }
     template <typename S>
     swapped_t operator+(const S& i) const {
-        return swap() + (T)i;
+        return swap() + static_cast<T>(i);
     }
     // v - 5
     swapped_t operator-(const swapped_t& i) const {
@@ -261,7 +261,7 @@ public:
     }
     template <typename S>
     swapped_t operator-(const S& i) const {
-        return swap() - (T)i;
+        return swap() - static_cast<T>(i);
     }
 
     // v += 5
@@ -271,7 +271,7 @@ public:
     }
     template <typename S>
     swapped_t& operator+=(const S& i) {
-        value = swap(swap() + (T)i);
+        value = swap(swap() + static_cast<T>(i));
         return *this;
     }
     // v -= 5
@@ -281,7 +281,7 @@ public:
     }
     template <typename S>
     swapped_t& operator-=(const S& i) {
-        value = swap(swap() - (T)i);
+        value = swap(swap() - static_cast<T>(i));
         return *this;
     }
 
@@ -541,7 +541,7 @@ S operator&(const S& i, const swap_struct_t<T, F> v) {
 
 template <typename S, typename T, typename F>
 S operator&(const swap_struct_t<T, F> v, const S& i) {
-    return (S)(v.swap() & i);
+    return static_cast<S>(v.swap() & i);
 }
 
 // Comparaison
@@ -606,51 +606,51 @@ struct swap_double_t {
 };
 
 #if COMMON_LITTLE_ENDIAN
-typedef u32 u32_le;
-typedef u16 u16_le;
-typedef u64 u64_le;
+using u16_le = u16;
+using u32_le = u32;
+using u64_le = u64;
 
-typedef s32 s32_le;
-typedef s16 s16_le;
-typedef s64 s64_le;
+using s16_le = s16;
+using s32_le = s32;
+using s64_le = s64;
 
-typedef float float_le;
-typedef double double_le;
+using float_le = float;
+using double_le = double;
 
-typedef swap_struct_t<u64, swap_64_t<u64>> u64_be;
-typedef swap_struct_t<s64, swap_64_t<s64>> s64_be;
+using u64_be = swap_struct_t<u64, swap_64_t<u64>>;
+using s64_be = swap_struct_t<s64, swap_64_t<s64>>;
 
-typedef swap_struct_t<u32, swap_32_t<u32>> u32_be;
-typedef swap_struct_t<s32, swap_32_t<s32>> s32_be;
+using u32_be = swap_struct_t<u32, swap_32_t<u32>>;
+using s32_be = swap_struct_t<s32, swap_32_t<s32>>;
 
-typedef swap_struct_t<u16, swap_16_t<u16>> u16_be;
-typedef swap_struct_t<s16, swap_16_t<s16>> s16_be;
+using u16_be = swap_struct_t<u16, swap_16_t<u16>>;
+using s16_be = swap_struct_t<s16, swap_16_t<s16>>;
 
-typedef swap_struct_t<float, swap_float_t<float>> float_be;
-typedef swap_struct_t<double, swap_double_t<double>> double_be;
+using float_be = swap_struct_t<float, swap_float_t<float>>;
+using double_be = swap_struct_t<double, swap_double_t<double>>;
 #else
 
-typedef swap_struct_t<u64, swap_64_t<u64>> u64_le;
-typedef swap_struct_t<s64, swap_64_t<s64>> s64_le;
+using u64_le = swap_struct_t<u64, swap_64_t<u64>>;
+using s64_le = swap_struct_t<s64, swap_64_t<s64>>;
 
-typedef swap_struct_t<u32, swap_32_t<u32>> u32_le;
-typedef swap_struct_t<s32, swap_32_t<s32>> s32_le;
+using u32_le = swap_struct_t<u32, swap_32_t<u32>>;
+using s32_le = swap_struct_t<s32, swap_32_t<s32>>;
 
-typedef swap_struct_t<u16, swap_16_t<u16>> u16_le;
-typedef swap_struct_t<s16, swap_16_t<s16>> s16_le;
+using u16_le = swap_struct_t<u16, swap_16_t<u16>>;
+using s16_le = swap_struct_t<s16, swap_16_t<s16>>;
 
-typedef swap_struct_t<float, swap_float_t<float>> float_le;
-typedef swap_struct_t<double, swap_double_t<double>> double_le;
+using float_le = swap_struct_t<float, swap_float_t<float>>;
+using double_le = swap_struct_t<double, swap_double_t<double>>;
 
-typedef u32 u32_be;
-typedef u16 u16_be;
-typedef u64 u64_be;
+using u16_be = u16;
+using u32_be = u32;
+using u64_be = u64;
 
-typedef s32 s32_be;
-typedef s16 s16_be;
-typedef s64 s64_be;
+using s16_be = s16;
+using s32_be = s32;
+using s64_be = s64;
 
-typedef float float_be;
-typedef double double_be;
+using float_be = float;
+using double_be = double;
 
 #endif

src/common/synchronized_wrapper.h

@@ -1,85 +0,0 @@
-// Copyright 2015 Citra Emulator Project
-// Licensed under GPLv2 or any later version
-// Refer to the license.txt file included.
-
-#pragma once
-
-#include <algorithm>
-#include <mutex>
-
-namespace Common {
-
-template <typename T>
-class SynchronizedWrapper;
-
-/**
- * Synchronized reference, that keeps a SynchronizedWrapper's mutex locked during its lifetime. This
- * greatly reduces the chance that someone will access the wrapped resource without locking the
- * mutex.
- */
-template <typename T>
-class SynchronizedRef {
-public:
-    SynchronizedRef(SynchronizedWrapper<T>& wrapper) : wrapper(&wrapper) {
-        wrapper.mutex.lock();
-    }
-
-    SynchronizedRef(SynchronizedRef&) = delete;
-    SynchronizedRef(SynchronizedRef&& o) : wrapper(o.wrapper) {
-        o.wrapper = nullptr;
-    }
-
-    ~SynchronizedRef() {
-        if (wrapper)
-            wrapper->mutex.unlock();
-    }
-
-    SynchronizedRef& operator=(SynchronizedRef&) = delete;
-    SynchronizedRef& operator=(SynchronizedRef&& o) {
-        std::swap(wrapper, o.wrapper);
-        return *this;
-    }
-
-    T& operator*() {
-        return wrapper->data;
-    }
-    const T& operator*() const {
-        return wrapper->data;
-    }
-
-    T* operator->() {
-        return &wrapper->data;
-    }
-    const T* operator->() const {
-        return &wrapper->data;
-    }
-
-private:
-    SynchronizedWrapper<T>* wrapper;
-};
-
-/**
- * Wraps an object, only allowing access to it via a locking reference wrapper. Good to ensure no
- * one forgets to lock a mutex before acessing an object. To access the wrapped object construct a
- * SyncronizedRef on this wrapper. Inspired by Rust's Mutex type
- * (http://doc.rust-lang.org/std/sync/struct.Mutex.html).
- */
-template <typename T>
-class SynchronizedWrapper {
-public:
-    template <typename... Args>
-    SynchronizedWrapper(Args&&... args) : data(std::forward<Args>(args)...) {}
-
-    SynchronizedRef<T> Lock() {
-        return {*this};
-    }
-
-private:
-    template <typename U>
-    friend class SynchronizedRef;
-
-    std::mutex mutex;
-    T data;
-};
-
-} // namespace Common

src/common/telemetry.h

@@ -52,27 +52,14 @@ public:
 template <typename T>
 class Field : public FieldInterface {
 public:
-    Field(FieldType type, std::string name, const T& value)
-        : name(std::move(name)), type(type), value(value) {}
-
-    Field(FieldType type, std::string name, T&& value)
+    Field(FieldType type, std::string name, T value)
         : name(std::move(name)), type(type), value(std::move(value)) {}
 
-    Field(const Field& other) : Field(other.type, other.name, other.value) {}
+    Field(const Field&) = default;
+    Field& operator=(const Field&) = default;
 
-    Field& operator=(const Field& other) {
-        type = other.type;
-        name = other.name;
-        value = other.value;
-        return *this;
-    }
-
-    Field& operator=(Field&& other) {
-        type = other.type;
-        name = std::move(other.name);
-        value = std::move(other.value);
-        return *this;
-    }
+    Field(Field&&) = default;
+    Field& operator=(Field&& other) = default;
 
     void Accept(VisitorInterface& visitor) const override;
 
@@ -94,11 +81,11 @@ public:
         return value;
     }
 
-    inline bool operator==(const Field<T>& other) {
+    bool operator==(const Field& other) const {
         return (type == other.type) && (name == other.name) && (value == other.value);
     }
 
-    inline bool operator!=(const Field<T>& other) {
+    bool operator!=(const Field& other) const {
         return !(*this == other);
     }
 

src/common/threadsafe_queue.h

@@ -33,9 +33,11 @@ public:
     bool Empty() const {
         return !read_ptr->next.load();
     }
+
     T& Front() const {
         return read_ptr->current;
     }
+
     template <typename Arg>
     void Push(Arg&& t) {
         // create the element, add it to the queue
@@ -108,15 +110,41 @@ private:
 // single reader, multiple writer queue
 
 template <typename T, bool NeedSize = true>
-class MPSCQueue : public SPSCQueue<T, NeedSize> {
+class MPSCQueue {
 public:
+    u32 Size() const {
+        return spsc_queue.Size();
+    }
+
+    bool Empty() const {
+        return spsc_queue.Empty();
+    }
+
+    T& Front() const {
+        return spsc_queue.Front();
+    }
+
     template <typename Arg>
     void Push(Arg&& t) {
         std::lock_guard<std::mutex> lock(write_lock);
-        SPSCQueue<T, NeedSize>::Push(t);
+        spsc_queue.Push(t);
+    }
+
+    void Pop() {
+        return spsc_queue.Pop();
+    }
+
+    bool Pop(T& t) {
+        return spsc_queue.Pop(t);
+    }
+
+    // not thread-safe
+    void Clear() {
+        spsc_queue.Clear();
     }
 
 private:
+    SPSCQueue<T, NeedSize> spsc_queue;
     std::mutex write_lock;
 };
 } // namespace Common

src/common/timer.cpp

@@ -3,31 +3,16 @@
 // Refer to the license.txt file included.
 
 #include <ctime>
-
 #include <fmt/format.h>
-
-#ifdef _WIN32
-#include <windows.h>
-// windows.h needs to be included before other windows headers
-#include <mmsystem.h>
-#include <sys/timeb.h>
-#else
-#include <sys/time.h>
-#endif
 #include "common/common_types.h"
 #include "common/string_util.h"
 #include "common/timer.h"
 
 namespace Common {
 
-u32 Timer::GetTimeMs() {
-#ifdef _WIN32
-    return timeGetTime();
-#else
-    struct timeval t;
-    (void)gettimeofday(&t, nullptr);
-    return ((u32)(t.tv_sec * 1000 + t.tv_usec / 1000));
-#endif
+std::chrono::milliseconds Timer::GetTimeMs() {
+    return std::chrono::duration_cast<std::chrono::milliseconds>(
+        std::chrono::system_clock::now().time_since_epoch());
 }
 
 // --------------------------------------------
@@ -63,7 +48,7 @@ void Timer::Update() {
 // -------------------------------------
 
 // Get the number of milliseconds since the last Update()
-u64 Timer::GetTimeDifference() {
+std::chrono::milliseconds Timer::GetTimeDifference() {
     return GetTimeMs() - m_LastTime;
 }
 
@@ -74,11 +59,11 @@ void Timer::AddTimeDifference() {
 }
 
 // Get the time elapsed since the Start()
-u64 Timer::GetTimeElapsed() {
+std::chrono::milliseconds Timer::GetTimeElapsed() {
     // If we have not started yet, return 1 (because then I don't
     // have to change the FPS calculation in CoreRerecording.cpp .
-    if (m_StartTime == 0)
-        return 1;
+    if (m_StartTime.count() == 0)
+        return std::chrono::milliseconds(1);
 
     // Return the final timer time if the timer is stopped
     if (!m_Running)
@@ -90,49 +75,34 @@ u64 Timer::GetTimeElapsed() {
 // Get the formatted time elapsed since the Start()
 std::string Timer::GetTimeElapsedFormatted() const {
     // If we have not started yet, return zero
-    if (m_StartTime == 0)
+    if (m_StartTime.count() == 0)
         return "00:00:00:000";
 
     // The number of milliseconds since the start.
     // Use a different value if the timer is stopped.
-    u64 Milliseconds;
+    std::chrono::milliseconds Milliseconds;
     if (m_Running)
         Milliseconds = GetTimeMs() - m_StartTime;
     else
         Milliseconds = m_LastTime - m_StartTime;
     // Seconds
-    u32 Seconds = (u32)(Milliseconds / 1000);
+    std::chrono::seconds Seconds = std::chrono::duration_cast<std::chrono::seconds>(Milliseconds);
     // Minutes
-    u32 Minutes = Seconds / 60;
+    std::chrono::minutes Minutes = std::chrono::duration_cast<std::chrono::minutes>(Milliseconds);
     // Hours
-    u32 Hours = Minutes / 60;
+    std::chrono::hours Hours = std::chrono::duration_cast<std::chrono::hours>(Milliseconds);
 
-    std::string TmpStr = fmt::format("{:02}:{:02}:{:02}:{:03}", Hours, Minutes % 60, Seconds % 60,
-                                     Milliseconds % 1000);
+    std::string TmpStr = fmt::format("{:02}:{:02}:{:02}:{:03}", Hours.count(), Minutes.count() % 60,
+                                     Seconds.count() % 60, Milliseconds.count() % 1000);
     return TmpStr;
 }
 
-// Get current time
-void Timer::IncreaseResolution() {
-#ifdef _WIN32
-    timeBeginPeriod(1);
-#endif
-}
-
-void Timer::RestoreResolution() {
-#ifdef _WIN32
-    timeEndPeriod(1);
-#endif
-}
-
 // Get the number of seconds since January 1 1970
-u64 Timer::GetTimeSinceJan1970() {
-    time_t ltime;
-    time(&ltime);
-    return ((u64)ltime);
+std::chrono::seconds Timer::GetTimeSinceJan1970() {
+    return std::chrono::duration_cast<std::chrono::seconds>(GetTimeMs());
 }
 
-u64 Timer::GetLocalTimeSinceJan1970() {
+std::chrono::seconds Timer::GetLocalTimeSinceJan1970() {
     time_t sysTime, tzDiff, tzDST;
     struct tm* gmTime;
 
@@ -149,7 +119,7 @@ u64 Timer::GetLocalTimeSinceJan1970() {
     gmTime = gmtime(&sysTime);
     tzDiff = sysTime - mktime(gmTime);
 
-    return (u64)(sysTime + tzDiff + tzDST);
+    return std::chrono::seconds(sysTime + tzDiff + tzDST);
 }
 
 // Return the current time formatted as Minutes:Seconds:Milliseconds
@@ -164,30 +134,16 @@ std::string Timer::GetTimeFormatted() {
 
     strftime(tmp, 6, "%M:%S", gmTime);
 
-// Now tack on the milliseconds
-#ifdef _WIN32
-    struct timeb tp;
-    (void)::ftime(&tp);
-    return fmt::format("{}:{:03}", tmp, tp.millitm);
-#else
-    struct timeval t;
-    (void)gettimeofday(&t, nullptr);
-    return fmt::format("{}:{:03}", tmp, static_cast<int>(t.tv_usec / 1000));
-#endif
+    u64 milliseconds = static_cast<u64>(GetTimeMs().count()) % 1000;
+    return fmt::format("{}:{:03}", tmp, milliseconds);
 }
 
 // Returns a timestamp with decimals for precise time comparisons
 // ----------------
 double Timer::GetDoubleTime() {
-#ifdef _WIN32
-    struct timeb tp;
-    (void)::ftime(&tp);
-#else
-    struct timeval t;
-    (void)gettimeofday(&t, nullptr);
-#endif
     // Get continuous timestamp
-    u64 TmpSeconds = Common::Timer::GetTimeSinceJan1970();
+    u64 TmpSeconds = static_cast<u64>(Common::Timer::GetTimeSinceJan1970().count());
+    double ms = static_cast<u64>(GetTimeMs().count()) % 1000;
 
     // Remove a few years. We only really want enough seconds to make
     // sure that we are detecting actual actions, perhaps 60 seconds is
@@ -196,12 +152,7 @@ double Timer::GetDoubleTime() {
     TmpSeconds = TmpSeconds - (38 * 365 * 24 * 60 * 60);
 
     // Make a smaller integer that fits in the double
-    u32 Seconds = (u32)TmpSeconds;
-#ifdef _WIN32
-    double ms = tp.millitm / 1000.0 / 1000.0;
-#else
-    double ms = t.tv_usec / 1000000.0;
-#endif
+    u32 Seconds = static_cast<u32>(TmpSeconds);
     double TmpTime = Seconds + ms;
 
     return TmpTime;

src/common/timer.h

@@ -4,6 +4,7 @@
 
 #pragma once
 
+#include <chrono>
 #include <string>
 #include "common/common_types.h"
 
@@ -18,24 +19,22 @@ public:
 
     // The time difference is always returned in milliseconds, regardless of alternative internal
     // representation
-    u64 GetTimeDifference();
+    std::chrono::milliseconds GetTimeDifference();
     void AddTimeDifference();
 
-    static void IncreaseResolution();
-    static void RestoreResolution();
-    static u64 GetTimeSinceJan1970();
-    static u64 GetLocalTimeSinceJan1970();
+    static std::chrono::seconds GetTimeSinceJan1970();
+    static std::chrono::seconds GetLocalTimeSinceJan1970();
     static double GetDoubleTime();
 
     static std::string GetTimeFormatted();
     std::string GetTimeElapsedFormatted() const;
-    u64 GetTimeElapsed();
+    std::chrono::milliseconds GetTimeElapsed();
 
-    static u32 GetTimeMs();
+    static std::chrono::milliseconds GetTimeMs();
 
 private:
-    u64 m_LastTime;
-    u64 m_StartTime;
+    std::chrono::milliseconds m_LastTime;
+    std::chrono::milliseconds m_StartTime;
     bool m_Running;
 };
 

src/core/CMakeLists.txt

@@ -1,5 +1,7 @@
 add_library(core STATIC
     arm/arm_interface.h
+    arm/exclusive_monitor.cpp
+    arm/exclusive_monitor.h
     arm/unicorn/arm_unicorn.cpp
     arm/unicorn/arm_unicorn.h
     core.cpp
@@ -8,27 +10,45 @@ add_library(core STATIC
     core_cpu.h
     core_timing.cpp
     core_timing.h
+    core_timing_util.cpp
+    core_timing_util.h
+    crypto/aes_util.cpp
+    crypto/aes_util.h
+    crypto/encryption_layer.cpp
+    crypto/encryption_layer.h
+    crypto/key_manager.cpp
+    crypto/key_manager.h
+    crypto/ctr_encryption_layer.cpp
+    crypto/ctr_encryption_layer.h
+    file_sys/card_image.cpp
+    file_sys/card_image.h
+    file_sys/content_archive.cpp
+    file_sys/content_archive.h
+    file_sys/control_metadata.cpp
+    file_sys/control_metadata.h
     file_sys/directory.h
-    file_sys/disk_filesystem.cpp
-    file_sys/disk_filesystem.h
     file_sys/errors.h
-    file_sys/filesystem.cpp
-    file_sys/filesystem.h
+    file_sys/mode.h
     file_sys/partition_filesystem.cpp
     file_sys/partition_filesystem.h
-    file_sys/path_parser.cpp
-    file_sys/path_parser.h
     file_sys/program_metadata.cpp
     file_sys/program_metadata.h
+    file_sys/romfs.cpp
+    file_sys/romfs.h
     file_sys/romfs_factory.cpp
     file_sys/romfs_factory.h
-    file_sys/romfs_filesystem.cpp
-    file_sys/romfs_filesystem.h
     file_sys/savedata_factory.cpp
     file_sys/savedata_factory.h
     file_sys/sdmc_factory.cpp
     file_sys/sdmc_factory.h
-    file_sys/storage.h
+    file_sys/vfs.cpp
+    file_sys/vfs.h
+    file_sys/vfs_offset.cpp
+    file_sys/vfs_offset.h
+    file_sys/vfs_real.cpp
+    file_sys/vfs_real.h
+    file_sys/vfs_vector.cpp
+    file_sys/vfs_vector.h
     frontend/emu_window.cpp
     frontend/emu_window.h
     frontend/framebuffer_layout.cpp
@@ -36,8 +56,6 @@ add_library(core STATIC
     frontend/input.h
     gdbstub/gdbstub.cpp
     gdbstub/gdbstub.h
-    hle/config_mem.cpp
-    hle/config_mem.h
     hle/ipc.h
     hle/ipc_helpers.h
     hle/kernel/address_arbiter.cpp
@@ -55,12 +73,10 @@ add_library(core STATIC
     hle/kernel/hle_ipc.h
     hle/kernel/kernel.cpp
     hle/kernel/kernel.h
-    hle/kernel/memory.cpp
-    hle/kernel/memory.h
     hle/kernel/mutex.cpp
     hle/kernel/mutex.h
-    hle/kernel/object_address_table.cpp
-    hle/kernel/object_address_table.h
+    hle/kernel/object.cpp
+    hle/kernel/object.h
     hle/kernel/process.cpp
     hle/kernel/process.h
     hle/kernel/resource_limit.cpp
@@ -106,32 +122,62 @@ add_library(core STATIC
     hle/service/am/applet_ae.h
     hle/service/am/applet_oe.cpp
     hle/service/am/applet_oe.h
+    hle/service/am/idle.cpp
+    hle/service/am/idle.h
+    hle/service/am/omm.cpp
+    hle/service/am/omm.h
+    hle/service/am/spsm.cpp
+    hle/service/am/spsm.h
     hle/service/aoc/aoc_u.cpp
     hle/service/aoc/aoc_u.h
     hle/service/apm/apm.cpp
     hle/service/apm/apm.h
     hle/service/apm/interface.cpp
     hle/service/apm/interface.h
-    hle/service/audio/audio.cpp
-    hle/service/audio/audio.h
+    hle/service/audio/audctl.cpp
+    hle/service/audio/audctl.h
+    hle/service/audio/auddbg.cpp
+    hle/service/audio/auddbg.h
+    hle/service/audio/audin_a.cpp
+    hle/service/audio/audin_a.h
     hle/service/audio/audin_u.cpp
     hle/service/audio/audin_u.h
+    hle/service/audio/audio.cpp
+    hle/service/audio/audio.h
+    hle/service/audio/audout_a.cpp
+    hle/service/audio/audout_a.h
     hle/service/audio/audout_u.cpp
     hle/service/audio/audout_u.h
+    hle/service/audio/audrec_a.cpp
+    hle/service/audio/audrec_a.h
     hle/service/audio/audrec_u.cpp
     hle/service/audio/audrec_u.h
-    hle/service/audio/audren_u.cpp
-    hle/service/audio/audren_u.h
+    hle/service/audio/audren_a.cpp
+    hle/service/audio/audren_a.h
     hle/service/audio/audren_u.cpp
     hle/service/audio/audren_u.h
     hle/service/audio/codecctl.cpp
     hle/service/audio/codecctl.h
     hle/service/audio/hwopus.cpp
     hle/service/audio/hwopus.h
-    hle/service/bcat/module.cpp
-    hle/service/bcat/module.h
     hle/service/bcat/bcat.cpp
     hle/service/bcat/bcat.h
+    hle/service/bcat/module.cpp
+    hle/service/bcat/module.h
+    hle/service/bpc/bpc.cpp
+    hle/service/bpc/bpc.h
+    hle/service/btdrv/btdrv.cpp
+    hle/service/btdrv/btdrv.h
+    hle/service/btm/btm.cpp
+    hle/service/btm/btm.h
+    hle/service/caps/caps.cpp
+    hle/service/caps/caps.h
+    hle/service/erpt/erpt.cpp
+    hle/service/erpt/erpt.h
+    hle/service/es/es.cpp
+    hle/service/es/es.h
+    hle/service/eupld/eupld.cpp
+    hle/service/eupld/eupld.h
     hle/service/fatal/fatal.cpp
     hle/service/fatal/fatal.h
     hle/service/fatal/fatal_p.cpp
@@ -140,32 +186,52 @@ add_library(core STATIC
     hle/service/fatal/fatal_u.h
     hle/service/filesystem/filesystem.cpp
     hle/service/filesystem/filesystem.h
+    hle/service/filesystem/fsp_ldr.cpp
+    hle/service/filesystem/fsp_ldr.h
+    hle/service/filesystem/fsp_pr.cpp
+    hle/service/filesystem/fsp_pr.h
     hle/service/filesystem/fsp_srv.cpp
     hle/service/filesystem/fsp_srv.h
+    hle/service/fgm/fgm.cpp
+    hle/service/fgm/fgm.h
     hle/service/friend/friend.cpp
     hle/service/friend/friend.h
-    hle/service/friend/friend_a.cpp
-    hle/service/friend/friend_a.h
-    hle/service/friend/friend_u.cpp
-    hle/service/friend/friend_u.h
+    hle/service/friend/interface.cpp
+    hle/service/friend/interface.h
+    hle/service/grc/grc.cpp
+    hle/service/grc/grc.h
     hle/service/hid/hid.cpp
     hle/service/hid/hid.h
+    hle/service/hid/irs.cpp
+    hle/service/hid/irs.h
+    hle/service/hid/xcd.cpp
+    hle/service/hid/xcd.h
+    hle/service/lbl/lbl.cpp
+    hle/service/lbl/lbl.h
+    hle/service/ldn/ldn.cpp
+    hle/service/ldn/ldn.h
+    hle/service/ldr/ldr.cpp
+    hle/service/ldr/ldr.h
     hle/service/lm/lm.cpp
     hle/service/lm/lm.h
+    hle/service/mig/mig.cpp
+    hle/service/mig/mig.h
+    hle/service/mii/mii.cpp
+    hle/service/mii/mii.h
     hle/service/mm/mm_u.cpp
     hle/service/mm/mm_u.h
-    hle/service/nifm/nifm.cpp
-    hle/service/nifm/nifm.h
-    hle/service/nifm/nifm_a.cpp
-    hle/service/nifm/nifm_a.h
-    hle/service/nifm/nifm_s.cpp
-    hle/service/nifm/nifm_s.h
-    hle/service/nifm/nifm_u.cpp
-    hle/service/nifm/nifm_u.h
+    hle/service/ncm/ncm.cpp
+    hle/service/ncm/ncm.h
+    hle/service/nfc/nfc.cpp
+    hle/service/nfc/nfc.h
     hle/service/nfp/nfp.cpp
     hle/service/nfp/nfp.h
     hle/service/nfp/nfp_user.cpp
     hle/service/nfp/nfp_user.h
+    hle/service/nifm/nifm.cpp
+    hle/service/nifm/nifm.h
+    hle/service/nim/nim.cpp
+    hle/service/nim/nim.h
     hle/service/ns/ns.cpp
     hle/service/ns/ns.h
     hle/service/ns/pl_u.cpp
@@ -195,12 +261,20 @@ add_library(core STATIC
     hle/service/nvflinger/buffer_queue.h
     hle/service/nvflinger/nvflinger.cpp
     hle/service/nvflinger/nvflinger.h
+    hle/service/pcie/pcie.cpp
+    hle/service/pcie/pcie.h
     hle/service/pctl/module.cpp
     hle/service/pctl/module.h
     hle/service/pctl/pctl.cpp
     hle/service/pctl/pctl.h
+    hle/service/pcv/pcv.cpp
+    hle/service/pcv/pcv.h
+    hle/service/pm/pm.cpp
+    hle/service/pm/pm.h
     hle/service/prepo/prepo.cpp
     hle/service/prepo/prepo.h
+    hle/service/psc/psc.cpp
+    hle/service/psc/psc.h
     hle/service/service.cpp
     hle/service/service.h
     hle/service/set/set.cpp
@@ -219,6 +293,8 @@ add_library(core STATIC
     hle/service/sm/sm.h
     hle/service/sockets/bsd.cpp
     hle/service/sockets/bsd.h
+    hle/service/sockets/ethc.cpp
+    hle/service/sockets/ethc.h
     hle/service/sockets/nsd.cpp
     hle/service/sockets/nsd.h
     hle/service/sockets/sfdnsres.cpp
@@ -233,12 +309,10 @@ add_library(core STATIC
     hle/service/spl/spl.h
     hle/service/ssl/ssl.cpp
     hle/service/ssl/ssl.h
+    hle/service/time/interface.cpp
+    hle/service/time/interface.h
     hle/service/time/time.cpp
     hle/service/time/time.h
-    hle/service/time/time_s.cpp
-    hle/service/time/time_s.h
-    hle/service/time/time_u.cpp
-    hle/service/time/time_u.h
     hle/service/vi/vi.cpp
     hle/service/vi/vi.h
     hle/service/vi/vi_m.cpp
@@ -247,12 +321,8 @@ add_library(core STATIC
     hle/service/vi/vi_s.h
     hle/service/vi/vi_u.cpp
     hle/service/vi/vi_u.h
-    hle/shared_page.cpp
-    hle/shared_page.h
-    hw/hw.cpp
-    hw/hw.h
-    hw/lcd.cpp
-    hw/lcd.h
+    hle/service/wlan/wlan.cpp
+    hle/service/wlan/wlan.h
     loader/deconstructed_rom_directory.cpp
     loader/deconstructed_rom_directory.h
     loader/elf.cpp
@@ -267,6 +337,8 @@ add_library(core STATIC
     loader/nro.h
     loader/nso.cpp
     loader/nso.h
+    loader/xci.cpp
+    loader/xci.h
     memory.cpp
     memory.h
     memory_hook.cpp
@@ -285,8 +357,8 @@ add_library(core STATIC
 
 create_target_directory_groups(core)
 
-target_link_libraries(core PUBLIC common PRIVATE video_core)
-target_link_libraries(core PUBLIC Boost::boost PRIVATE fmt lz4_static unicorn)
+target_link_libraries(core PUBLIC common PRIVATE audio_core video_core)
+target_link_libraries(core PUBLIC Boost::boost PRIVATE fmt lz4_static mbedtls opus unicorn)
 
 if (ARCHITECTURE_x86_64)
     target_sources(core PRIVATE

src/core/arm/arm_interface.h

@@ -20,9 +20,6 @@ public:
         u64 cpsr;
         std::array<u128, 32> fpu_registers;
         u64 fpscr;
-
-        // TODO(bunnei): Fix once we have proper support for tpidrro_el0, etc. in the JIT
-        VAddr tls_address;
     };
 
     /// Runs the CPU until an event happens
@@ -104,6 +101,10 @@ public:
 
     virtual void SetTlsAddress(VAddr address) = 0;
 
+    virtual u64 GetTPIDR_EL0() const = 0;
+
+    virtual void SetTPIDR_EL0(u64 value) = 0;
+
     /**
      * Saves the current CPU context
      * @param ctx Thread context to save
@@ -116,6 +117,8 @@ public:
      */
     virtual void LoadContext(const ThreadContext& ctx) = 0;
 
+    virtual void ClearExclusiveState() = 0;
+
     /// Prepare core for thread reschedule (if needed to correctly handle state)
     virtual void PrepareReschedule() = 0;
 };

src/core/arm/dynarmic/arm_dynarmic.cpp

@@ -10,7 +10,7 @@
 #include "core/arm/dynarmic/arm_dynarmic.h"
 #include "core/core.h"
 #include "core/core_timing.h"
-#include "core/hle/kernel/memory.h"
+#include "core/hle/kernel/process.h"
 #include "core/hle/kernel/svc.h"
 #include "core/memory.h"
 
@@ -55,8 +55,8 @@ public:
     }
 
     void InterpreterFallback(u64 pc, size_t num_instructions) override {
-        NGLOG_INFO(Core_ARM, "Unicorn fallback @ 0x{:X} for {} instructions (instr = {:08X})", pc,
-                   num_instructions, MemoryReadCode(pc));
+        LOG_INFO(Core_ARM, "Unicorn fallback @ 0x{:X} for {} instructions (instr = {:08X})", pc,
+                 num_instructions, MemoryReadCode(pc));
 
         ARM_Interface::ThreadContext ctx;
         parent.SaveContext(ctx);
@@ -102,18 +102,28 @@ public:
     u64 tpidr_el0 = 0;
 };
 
-std::unique_ptr<Dynarmic::A64::Jit> MakeJit(const std::unique_ptr<ARM_Dynarmic_Callbacks>& cb) {
-    const auto page_table = Core::CurrentProcess()->vm_manager.page_table.pointers.data();
+std::unique_ptr<Dynarmic::A64::Jit> ARM_Dynarmic::MakeJit() const {
+    auto** const page_table = Core::CurrentProcess()->vm_manager.page_table.pointers.data();
 
     Dynarmic::A64::UserConfig config;
+
+    // Callbacks
     config.callbacks = cb.get();
+
+    // Memory
+    config.page_table = reinterpret_cast<void**>(page_table);
+    config.page_table_address_space_bits = Memory::ADDRESS_SPACE_BITS;
+    config.silently_mirror_page_table = false;
+
+    // Multi-process state
+    config.processor_id = core_index;
+    config.global_monitor = &exclusive_monitor->monitor;
+
+    // System registers
     config.tpidrro_el0 = &cb->tpidrro_el0;
     config.tpidr_el0 = &cb->tpidr_el0;
     config.dczid_el0 = 4;
     config.ctr_el0 = 0x8444c004;
-    config.page_table = reinterpret_cast<void**>(page_table);
-    config.page_table_address_space_bits = Memory::ADDRESS_SPACE_BITS;
-    config.silently_mirror_page_table = false;
 
     return std::make_unique<Dynarmic::A64::Jit>(config);
 }
@@ -128,12 +138,13 @@ void ARM_Dynarmic::Step() {
     cb->InterpreterFallback(jit->GetPC(), 1);
 }
 
-ARM_Dynarmic::ARM_Dynarmic()
-    : cb(std::make_unique<ARM_Dynarmic_Callbacks>(*this)), jit(MakeJit(cb)) {
-    ARM_Interface::ThreadContext ctx;
+ARM_Dynarmic::ARM_Dynarmic(std::shared_ptr<ExclusiveMonitor> exclusive_monitor, size_t core_index)
+    : cb(std::make_unique<ARM_Dynarmic_Callbacks>(*this)), core_index{core_index},
+      exclusive_monitor{std::dynamic_pointer_cast<DynarmicExclusiveMonitor>(exclusive_monitor)} {
+    ThreadContext ctx;
     inner_unicorn.SaveContext(ctx);
-    LoadContext(ctx);
     PageTableChanged();
+    LoadContext(ctx);
 }
 
 ARM_Dynarmic::~ARM_Dynarmic() = default;
@@ -192,28 +203,34 @@ u64 ARM_Dynarmic::GetTlsAddress() const {
     return cb->tpidrro_el0;
 }
 
-void ARM_Dynarmic::SetTlsAddress(u64 address) {
+void ARM_Dynarmic::SetTlsAddress(VAddr address) {
     cb->tpidrro_el0 = address;
 }
 
-void ARM_Dynarmic::SaveContext(ARM_Interface::ThreadContext& ctx) {
+u64 ARM_Dynarmic::GetTPIDR_EL0() const {
+    return cb->tpidr_el0;
+}
+
+void ARM_Dynarmic::SetTPIDR_EL0(u64 value) {
+    cb->tpidr_el0 = value;
+}
+
+void ARM_Dynarmic::SaveContext(ThreadContext& ctx) {
     ctx.cpu_registers = jit->GetRegisters();
     ctx.sp = jit->GetSP();
     ctx.pc = jit->GetPC();
     ctx.cpsr = jit->GetPstate();
     ctx.fpu_registers = jit->GetVectors();
     ctx.fpscr = jit->GetFpcr();
-    ctx.tls_address = cb->tpidrro_el0;
 }
 
-void ARM_Dynarmic::LoadContext(const ARM_Interface::ThreadContext& ctx) {
+void ARM_Dynarmic::LoadContext(const ThreadContext& ctx) {
     jit->SetRegisters(ctx.cpu_registers);
     jit->SetSP(ctx.sp);
     jit->SetPC(ctx.pc);
     jit->SetPstate(static_cast<u32>(ctx.cpsr));
     jit->SetVectors(ctx.fpu_registers);
     jit->SetFpcr(static_cast<u32>(ctx.fpscr));
-    cb->tpidrro_el0 = ctx.tls_address;
 }
 
 void ARM_Dynarmic::PrepareReschedule() {
@@ -226,7 +243,50 @@ void ARM_Dynarmic::ClearInstructionCache() {
     jit->ClearCache();
 }
 
+void ARM_Dynarmic::ClearExclusiveState() {
+    jit->ClearExclusiveState();
+}
+
 void ARM_Dynarmic::PageTableChanged() {
-    jit = MakeJit(cb);
+    jit = MakeJit();
     current_page_table = Memory::GetCurrentPageTable();
 }
+
+DynarmicExclusiveMonitor::DynarmicExclusiveMonitor(size_t core_count) : monitor(core_count) {}
+DynarmicExclusiveMonitor::~DynarmicExclusiveMonitor() = default;
+
+void DynarmicExclusiveMonitor::SetExclusive(size_t core_index, VAddr addr) {
+    // Size doesn't actually matter.
+    monitor.Mark(core_index, addr, 16);
+}
+
+void DynarmicExclusiveMonitor::ClearExclusive() {
+    monitor.Clear();
+}
+
+bool DynarmicExclusiveMonitor::ExclusiveWrite8(size_t core_index, VAddr vaddr, u8 value) {
+    return monitor.DoExclusiveOperation(core_index, vaddr, 1,
+                                        [&] { Memory::Write8(vaddr, value); });
+}
+
+bool DynarmicExclusiveMonitor::ExclusiveWrite16(size_t core_index, VAddr vaddr, u16 value) {
+    return monitor.DoExclusiveOperation(core_index, vaddr, 2,
+                                        [&] { Memory::Write16(vaddr, value); });
+}
+
+bool DynarmicExclusiveMonitor::ExclusiveWrite32(size_t core_index, VAddr vaddr, u32 value) {
+    return monitor.DoExclusiveOperation(core_index, vaddr, 4,
+                                        [&] { Memory::Write32(vaddr, value); });
+}
+
+bool DynarmicExclusiveMonitor::ExclusiveWrite64(size_t core_index, VAddr vaddr, u64 value) {
+    return monitor.DoExclusiveOperation(core_index, vaddr, 8,
+                                        [&] { Memory::Write64(vaddr, value); });
+}
+
+bool DynarmicExclusiveMonitor::ExclusiveWrite128(size_t core_index, VAddr vaddr, u128 value) {
+    return monitor.DoExclusiveOperation(core_index, vaddr, 16, [&] {
+        Memory::Write64(vaddr, value[0]);
+        Memory::Write64(vaddr, value[1]);
+    });
+}

src/core/arm/dynarmic/arm_dynarmic.h

@@ -6,15 +6,18 @@
 
 #include <memory>
 #include <dynarmic/A64/a64.h>
+#include <dynarmic/A64/exclusive_monitor.h>
 #include "common/common_types.h"
 #include "core/arm/arm_interface.h"
+#include "core/arm/exclusive_monitor.h"
 #include "core/arm/unicorn/arm_unicorn.h"
 
 class ARM_Dynarmic_Callbacks;
+class DynarmicExclusiveMonitor;
 
 class ARM_Dynarmic final : public ARM_Interface {
 public:
-    ARM_Dynarmic();
+    ARM_Dynarmic(std::shared_ptr<ExclusiveMonitor> exclusive_monitor, size_t core_index);
     ~ARM_Dynarmic();
 
     void MapBackingMemory(VAddr address, size_t size, u8* memory,
@@ -34,20 +37,47 @@ public:
     void SetCPSR(u32 cpsr) override;
     VAddr GetTlsAddress() const override;
     void SetTlsAddress(VAddr address) override;
+    void SetTPIDR_EL0(u64 value) override;
+    u64 GetTPIDR_EL0() const override;
 
     void SaveContext(ThreadContext& ctx) override;
     void LoadContext(const ThreadContext& ctx) override;
 
     void PrepareReschedule() override;
+    void ClearExclusiveState() override;
 
     void ClearInstructionCache() override;
     void PageTableChanged() override;
 
 private:
+    std::unique_ptr<Dynarmic::A64::Jit> MakeJit() const;
+
     friend class ARM_Dynarmic_Callbacks;
     std::unique_ptr<ARM_Dynarmic_Callbacks> cb;
     std::unique_ptr<Dynarmic::A64::Jit> jit;
     ARM_Unicorn inner_unicorn;
 
+    size_t core_index;
+    std::shared_ptr<DynarmicExclusiveMonitor> exclusive_monitor;
+
     Memory::PageTable* current_page_table = nullptr;
 };
+
+class DynarmicExclusiveMonitor final : public ExclusiveMonitor {
+public:
+    explicit DynarmicExclusiveMonitor(size_t core_count);
+    ~DynarmicExclusiveMonitor();
+
+    void SetExclusive(size_t core_index, VAddr addr) override;
+    void ClearExclusive() override;
+
+    bool ExclusiveWrite8(size_t core_index, VAddr vaddr, u8 value) override;
+    bool ExclusiveWrite16(size_t core_index, VAddr vaddr, u16 value) override;
+    bool ExclusiveWrite32(size_t core_index, VAddr vaddr, u32 value) override;
+    bool ExclusiveWrite64(size_t core_index, VAddr vaddr, u64 value) override;
+    bool ExclusiveWrite128(size_t core_index, VAddr vaddr, u128 value) override;
+
+private:
+    friend class ARM_Dynarmic;
+    Dynarmic::A64::ExclusiveMonitor monitor;
+};

src/core/arm/exclusive_monitor.cpp

@@ -0,0 +1,7 @@
+// Copyright 2018 yuzu emulator team
+// Licensed under GPLv2 or any later version
+// Refer to the license.txt file included.
+
+#include "core/arm/exclusive_monitor.h"
+
+ExclusiveMonitor::~ExclusiveMonitor() = default;

src/core/arm/exclusive_monitor.h

@@ -0,0 +1,21 @@
+// Copyright 2018 yuzu emulator team
+// Licensed under GPLv2 or any later version
+// Refer to the license.txt file included.
+
+#pragma once
+
+#include "common/common_types.h"
+
+class ExclusiveMonitor {
+public:
+    virtual ~ExclusiveMonitor();
+
+    virtual void SetExclusive(size_t core_index, VAddr addr) = 0;
+    virtual void ClearExclusive() = 0;
+
+    virtual bool ExclusiveWrite8(size_t core_index, VAddr vaddr, u8 value) = 0;
+    virtual bool ExclusiveWrite16(size_t core_index, VAddr vaddr, u16 value) = 0;
+    virtual bool ExclusiveWrite32(size_t core_index, VAddr vaddr, u32 value) = 0;
+    virtual bool ExclusiveWrite64(size_t core_index, VAddr vaddr, u64 value) = 0;
+    virtual bool ExclusiveWrite128(size_t core_index, VAddr vaddr, u128 value) = 0;
+};

src/core/arm/unicorn/arm_unicorn.cpp

@@ -169,6 +169,16 @@ void ARM_Unicorn::SetTlsAddress(VAddr base) {
     CHECKED(uc_reg_write(uc, UC_ARM64_REG_TPIDRRO_EL0, &base));
 }
 
+u64 ARM_Unicorn::GetTPIDR_EL0() const {
+    u64 value{};
+    CHECKED(uc_reg_read(uc, UC_ARM64_REG_TPIDR_EL0, &value));
+    return value;
+}
+
+void ARM_Unicorn::SetTPIDR_EL0(u64 value) {
+    CHECKED(uc_reg_write(uc, UC_ARM64_REG_TPIDR_EL0, &value));
+}
+
 void ARM_Unicorn::Run() {
     if (GDBStub::IsServerEnabled()) {
         ExecuteInstructions(std::max(4000000, 0));
@@ -193,11 +203,11 @@ void ARM_Unicorn::ExecuteInstructions(int num_instructions) {
         }
         Kernel::Thread* thread = Kernel::GetCurrentThread();
         SaveContext(thread->context);
-        if (last_bkpt_hit) {
+        if (last_bkpt_hit || (num_instructions == 1)) {
             last_bkpt_hit = false;
             GDBStub::Break();
+            GDBStub::SendTrap(thread, 5);
         }
-        GDBStub::SendTrap(thread, 5);
     }
 }
 
@@ -220,8 +230,6 @@ void ARM_Unicorn::SaveContext(ARM_Interface::ThreadContext& ctx) {
 
     CHECKED(uc_reg_read_batch(uc, uregs, tregs, 31));
 
-    ctx.tls_address = GetTlsAddress();
-
     for (int i = 0; i < 32; ++i) {
         uregs[i] = UC_ARM64_REG_Q0 + i;
         tregs[i] = &ctx.fpu_registers[i];
@@ -249,8 +257,6 @@ void ARM_Unicorn::LoadContext(const ARM_Interface::ThreadContext& ctx) {
 
     CHECKED(uc_reg_write_batch(uc, uregs, tregs, 31));
 
-    SetTlsAddress(ctx.tls_address);
-
     for (auto i = 0; i < 32; ++i) {
         uregs[i] = UC_ARM64_REG_Q0 + i;
         tregs[i] = (void*)&ctx.fpu_registers[i];
@@ -263,6 +269,8 @@ void ARM_Unicorn::PrepareReschedule() {
     CHECKED(uc_emu_stop(uc));
 }
 
+void ARM_Unicorn::ClearExclusiveState() {}
+
 void ARM_Unicorn::ClearInstructionCache() {}
 
 void ARM_Unicorn::RecordBreak(GDBStub::BreakpointAddress bkpt) {

src/core/arm/unicorn/arm_unicorn.h

@@ -28,9 +28,12 @@ public:
     void SetCPSR(u32 cpsr) override;
     VAddr GetTlsAddress() const override;
     void SetTlsAddress(VAddr address) override;
+    void SetTPIDR_EL0(u64 value) override;
+    u64 GetTPIDR_EL0() const override;
     void SaveContext(ThreadContext& ctx) override;
     void LoadContext(const ThreadContext& ctx) override;
     void PrepareReschedule() override;
+    void ClearExclusiveState() override;
     void ExecuteInstructions(int num_instructions);
     void Run() override;
     void Step() override;

src/core/core.cpp

@@ -15,21 +15,22 @@
 #include "core/hle/service/service.h"
 #include "core/hle/service/sm/controller.h"
 #include "core/hle/service/sm/sm.h"
-#include "core/hw/hw.h"
 #include "core/loader/loader.h"
-#include "core/memory_setup.h"
 #include "core/settings.h"
+#include "file_sys/vfs_real.h"
 #include "video_core/video_core.h"
 
 namespace Core {
 
 /*static*/ System System::s_instance;
 
+System::System() = default;
+
 System::~System() = default;
 
 /// Runs a CPU core while the system is powered on
 static void RunCpuCore(std::shared_ptr<Cpu> cpu_state) {
-    while (Core::System().GetInstance().IsPoweredOn()) {
+    while (Core::System::GetInstance().IsPoweredOn()) {
         cpu_state->RunLoop(true);
     }
 }
@@ -83,23 +84,25 @@ System::ResultStatus System::SingleStep() {
     return RunLoop(false);
 }
 
-System::ResultStatus System::Load(EmuWindow* emu_window, const std::string& filepath) {
-    app_loader = Loader::GetLoader(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) {
-        NGLOG_CRITICAL(Core, "Failed to obtain loader for {}!", filepath);
+        LOG_CRITICAL(Core, "Failed to obtain loader for {}!", filepath);
         return ResultStatus::ErrorGetLoader;
     }
     std::pair<boost::optional<u32>, Loader::ResultStatus> system_mode =
         app_loader->LoadKernelSystemMode();
 
     if (system_mode.second != Loader::ResultStatus::Success) {
-        NGLOG_CRITICAL(Core, "Failed to determine system mode (Error {})!",
-                       static_cast<int>(system_mode.second));
+        LOG_CRITICAL(Core, "Failed to determine system mode (Error {})!",
+                     static_cast<int>(system_mode.second));
 
         switch (system_mode.second) {
-        case Loader::ResultStatus::ErrorEncrypted:
-            return ResultStatus::ErrorLoader_ErrorEncrypted;
+        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:
@@ -109,22 +112,24 @@ System::ResultStatus System::Load(EmuWindow* emu_window, const std::string& file
         }
     }
 
-    ResultStatus init_result{Init(emu_window, system_mode.first.get())};
+    ResultStatus init_result{Init(emu_window)};
     if (init_result != ResultStatus::Success) {
-        NGLOG_CRITICAL(Core, "Failed to initialize system (Error {})!",
-                       static_cast<int>(init_result));
+        LOG_CRITICAL(Core, "Failed to initialize system (Error {})!",
+                     static_cast<int>(init_result));
         System::Shutdown();
         return init_result;
     }
 
     const Loader::ResultStatus load_result{app_loader->Load(current_process)};
     if (Loader::ResultStatus::Success != load_result) {
-        NGLOG_CRITICAL(Core, "Failed to load ROM (Error {})!", static_cast<int>(load_result));
+        LOG_CRITICAL(Core, "Failed to load ROM (Error {})!", static_cast<int>(load_result));
         System::Shutdown();
 
         switch (load_result) {
-        case Loader::ResultStatus::ErrorEncrypted:
-            return ResultStatus::ErrorLoader_ErrorEncrypted;
+        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:
@@ -160,24 +165,24 @@ Cpu& System::CpuCore(size_t core_index) {
     return *cpu_cores[core_index];
 }
 
-System::ResultStatus System::Init(EmuWindow* emu_window, u32 system_mode) {
-    NGLOG_DEBUG(HW_Memory, "initialized OK");
+System::ResultStatus System::Init(EmuWindow& emu_window) {
+    LOG_DEBUG(HW_Memory, "initialized OK");
 
     CoreTiming::Init();
 
     current_process = Kernel::Process::Create("main");
 
     cpu_barrier = std::make_shared<CpuBarrier>();
+    cpu_exclusive_monitor = Cpu::MakeExclusiveMonitor(cpu_cores.size());
     for (size_t index = 0; index < cpu_cores.size(); ++index) {
-        cpu_cores[index] = std::make_shared<Cpu>(cpu_barrier, index);
+        cpu_cores[index] = std::make_shared<Cpu>(cpu_exclusive_monitor, cpu_barrier, index);
     }
 
     gpu_core = std::make_unique<Tegra::GPU>();
     telemetry_session = std::make_unique<Core::TelemetrySession>();
     service_manager = std::make_shared<Service::SM::ServiceManager>();
 
-    HW::Init();
-    Kernel::Init(system_mode);
+    Kernel::Init();
     Service::Init(service_manager);
     GDBStub::Init();
 
@@ -196,7 +201,7 @@ System::ResultStatus System::Init(EmuWindow* emu_window, u32 system_mode) {
         }
     }
 
-    NGLOG_DEBUG(Core, "Initialized OK");
+    LOG_DEBUG(Core, "Initialized OK");
 
     // Reset counters and set time origin to current frame
     GetAndResetPerfStats();
@@ -220,7 +225,6 @@ void System::Shutdown() {
     GDBStub::Shutdown();
     Service::Shutdown();
     Kernel::Shutdown();
-    HW::Shutdown();
     service_manager.reset();
     telemetry_session.reset();
     gpu_core.reset();
@@ -245,7 +249,7 @@ void System::Shutdown() {
     // Close app loader
     app_loader.reset();
 
-    NGLOG_DEBUG(Core, "Shutdown OK");
+    LOG_DEBUG(Core, "Shutdown OK");
 }
 
 Service::SM::ServiceManager& System::ServiceManager() {

src/core/core.h

@@ -9,8 +9,9 @@
 #include <string>
 #include <thread>
 #include "common/common_types.h"
+#include "core/arm/exclusive_monitor.h"
 #include "core/core_cpu.h"
-#include "core/hle/kernel/kernel.h"
+#include "core/hle/kernel/object.h"
 #include "core/hle/kernel/scheduler.h"
 #include "core/loader/loader.h"
 #include "core/memory.h"
@@ -42,12 +43,14 @@ 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
-        ErrorLoader,                ///< Error loading the specified application
-        ErrorLoader_ErrorEncrypted, ///< Error loading the specified application due to encryption
+        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
@@ -80,11 +83,12 @@ public:
 
     /**
      * Load an executable application.
-     * @param emu_window Pointer to the host-system window used for video output and keyboard input.
+     * @param emu_window Reference to the host-system window used for video output and keyboard
+     *                   input.
      * @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(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
@@ -114,6 +118,11 @@ public:
         return CurrentCpuCore().ArmInterface();
     }
 
+    /// Gets the index of the currently running CPU core
+    size_t CurrentCoreIndex() {
+        return CurrentCpuCore().CoreIndex();
+    }
+
     /// Gets an ARM interface to the CPU core with the specified index
     ARM_Interface& ArmInterface(size_t core_index);
 
@@ -130,6 +139,11 @@ public:
         return *CurrentCpuCore().Scheduler();
     }
 
+    /// Gets the exclusive monitor
+    ExclusiveMonitor& Monitor() {
+        return *cpu_exclusive_monitor;
+    }
+
     /// Gets the scheduler for the CPU core with the specified index
     const std::shared_ptr<Kernel::Scheduler>& Scheduler(size_t core_index);
 
@@ -168,22 +182,25 @@ public:
     }
 
 private:
+    System();
+
     /// Returns the currently running CPU core
     Cpu& CurrentCpuCore();
 
     /**
      * Initialize the emulated system.
-     * @param emu_window Pointer to the host-system window used for video output and keyboard input.
-     * @param system_mode The system mode.
+     * @param emu_window Reference to the host-system window used for video output and keyboard
+     *                   input.
      * @return ResultStatus code, indicating if the operation succeeded.
      */
-    ResultStatus Init(EmuWindow* emu_window, u32 system_mode);
+    ResultStatus Init(EmuWindow& emu_window);
 
     /// AppLoader used to load the current executing application
     std::unique_ptr<Loader::AppLoader> app_loader;
     std::unique_ptr<Tegra::GPU> gpu_core;
     std::shared_ptr<Tegra::DebugContext> debug_context;
     Kernel::SharedPtr<Kernel::Process> current_process;
+    std::shared_ptr<ExclusiveMonitor> cpu_exclusive_monitor;
     std::shared_ptr<CpuBarrier> cpu_barrier;
     std::array<std::shared_ptr<Cpu>, NUM_CPU_CORES> cpu_cores;
     std::array<std::unique_ptr<std::thread>, NUM_CPU_CORES - 1> cpu_core_threads;

src/core/core_cpu.cpp

@@ -12,7 +12,6 @@
 #include "core/arm/unicorn/arm_unicorn.h"
 #include "core/core_cpu.h"
 #include "core/core_timing.h"
-#include "core/hle/kernel/kernel.h"
 #include "core/hle/kernel/scheduler.h"
 #include "core/hle/kernel/thread.h"
 #include "core/settings.h"
@@ -48,15 +47,16 @@ bool CpuBarrier::Rendezvous() {
     return false;
 }
 
-Cpu::Cpu(std::shared_ptr<CpuBarrier> cpu_barrier, size_t core_index)
+Cpu::Cpu(std::shared_ptr<ExclusiveMonitor> exclusive_monitor,
+         std::shared_ptr<CpuBarrier> cpu_barrier, size_t core_index)
     : cpu_barrier{std::move(cpu_barrier)}, core_index{core_index} {
 
     if (Settings::values.use_cpu_jit) {
 #ifdef ARCHITECTURE_x86_64
-        arm_interface = std::make_shared<ARM_Dynarmic>();
+        arm_interface = std::make_shared<ARM_Dynarmic>(exclusive_monitor, core_index);
 #else
-        cpu_core = std::make_shared<ARM_Unicorn>();
-        NGLOG_WARNING(Core, "CPU JIT requested, but Dynarmic not available");
+        arm_interface = std::make_shared<ARM_Unicorn>();
+        LOG_WARNING(Core, "CPU JIT requested, but Dynarmic not available");
 #endif
     } else {
         arm_interface = std::make_shared<ARM_Unicorn>();
@@ -65,6 +65,18 @@ Cpu::Cpu(std::shared_ptr<CpuBarrier> cpu_barrier, size_t core_index)
     scheduler = std::make_shared<Kernel::Scheduler>(arm_interface.get());
 }
 
+std::shared_ptr<ExclusiveMonitor> Cpu::MakeExclusiveMonitor(size_t num_cores) {
+    if (Settings::values.use_cpu_jit) {
+#ifdef ARCHITECTURE_x86_64
+        return std::make_shared<DynarmicExclusiveMonitor>(num_cores);
+#else
+        return nullptr; // TODO(merry): Passthrough exclusive monitor
+#endif
+    } else {
+        return nullptr; // TODO(merry): Passthrough exclusive monitor
+    }
+}
+
 void Cpu::RunLoop(bool tight_loop) {
     // Wait for all other CPU cores to complete the previous slice, such that they run in lock-step
     if (!cpu_barrier->Rendezvous()) {
@@ -75,7 +87,7 @@ void Cpu::RunLoop(bool tight_loop) {
     // If we don't have a currently active thread then don't execute instructions,
     // instead advance to the next event and try to yield to the next thread
     if (Kernel::GetCurrentThread() == nullptr) {
-        NGLOG_TRACE(Core, "Core-{} idling", core_index);
+        LOG_TRACE(Core, "Core-{} idling", core_index);
 
         if (IsMainCore()) {
             CoreTiming::Idle();

src/core/core_cpu.h

@@ -10,6 +10,7 @@
 #include <mutex>
 #include <string>
 #include "common/common_types.h"
+#include "core/arm/exclusive_monitor.h"
 
 class ARM_Interface;
 
@@ -40,7 +41,8 @@ private:
 
 class Cpu {
 public:
-    Cpu(std::shared_ptr<CpuBarrier> cpu_barrier, size_t core_index);
+    Cpu(std::shared_ptr<ExclusiveMonitor> exclusive_monitor,
+        std::shared_ptr<CpuBarrier> cpu_barrier, size_t core_index);
 
     void RunLoop(bool tight_loop = true);
 
@@ -64,6 +66,12 @@ public:
         return core_index == 0;
     }
 
+    size_t CoreIndex() const {
+        return core_index;
+    }
+
+    static std::shared_ptr<ExclusiveMonitor> MakeExclusiveMonitor(size_t num_cores);
+
 private:
     void Reschedule();
 

src/core/core_timing.cpp

@@ -5,17 +5,15 @@
 #include "core/core_timing.h"
 
 #include <algorithm>
-#include <cinttypes>
-#include <limits>
 #include <mutex>
 #include <string>
 #include <tuple>
 #include <unordered_map>
 #include <vector>
 #include "common/assert.h"
-#include "common/logging/log.h"
 #include "common/thread.h"
 #include "common/threadsafe_queue.h"
+#include "core/core_timing_util.h"
 
 namespace CoreTiming {
 
@@ -59,7 +57,6 @@ static u64 event_fifo_id;
 static Common::MPSCQueue<Event, false> ts_queue;
 
 constexpr int MAX_SLICE_LENGTH = 20000;
-constexpr u64 MAX_VALUE_TO_MULTIPLY = std::numeric_limits<s64>::max() / BASE_CLOCK_RATE;
 
 static s64 idled_cycles;
 
@@ -72,54 +69,6 @@ static EventType* ev_lost = nullptr;
 
 static void EmptyTimedCallback(u64 userdata, s64 cyclesLate) {}
 
-s64 usToCycles(s64 us) {
-    if (us / 1000000 > MAX_VALUE_TO_MULTIPLY) {
-        NGLOG_ERROR(Core_Timing, "Integer overflow, use max value");
-        return std::numeric_limits<s64>::max();
-    }
-    if (us > MAX_VALUE_TO_MULTIPLY) {
-        NGLOG_DEBUG(Core_Timing, "Time very big, do rounding");
-        return BASE_CLOCK_RATE * (us / 1000000);
-    }
-    return (BASE_CLOCK_RATE * us) / 1000000;
-}
-
-s64 usToCycles(u64 us) {
-    if (us / 1000000 > MAX_VALUE_TO_MULTIPLY) {
-        NGLOG_ERROR(Core_Timing, "Integer overflow, use max value");
-        return std::numeric_limits<s64>::max();
-    }
-    if (us > MAX_VALUE_TO_MULTIPLY) {
-        NGLOG_DEBUG(Core_Timing, "Time very big, do rounding");
-        return BASE_CLOCK_RATE * static_cast<s64>(us / 1000000);
-    }
-    return (BASE_CLOCK_RATE * static_cast<s64>(us)) / 1000000;
-}
-
-s64 nsToCycles(s64 ns) {
-    if (ns / 1000000000 > MAX_VALUE_TO_MULTIPLY) {
-        NGLOG_ERROR(Core_Timing, "Integer overflow, use max value");
-        return std::numeric_limits<s64>::max();
-    }
-    if (ns > MAX_VALUE_TO_MULTIPLY) {
-        NGLOG_DEBUG(Core_Timing, "Time very big, do rounding");
-        return BASE_CLOCK_RATE * (ns / 1000000000);
-    }
-    return (BASE_CLOCK_RATE * ns) / 1000000000;
-}
-
-s64 nsToCycles(u64 ns) {
-    if (ns / 1000000000 > MAX_VALUE_TO_MULTIPLY) {
-        NGLOG_ERROR(Core_Timing, "Integer overflow, use max value");
-        return std::numeric_limits<s64>::max();
-    }
-    if (ns > MAX_VALUE_TO_MULTIPLY) {
-        NGLOG_DEBUG(Core_Timing, "Time very big, do rounding");
-        return BASE_CLOCK_RATE * (static_cast<s64>(ns) / 1000000000);
-    }
-    return (BASE_CLOCK_RATE * static_cast<s64>(ns)) / 1000000000;
-}
-
 EventType* RegisterEvent(const std::string& name, TimedCallback callback) {
     // check for existing type with same name.
     // we want event type names to remain unique so that we can use them for serialization.

src/core/core_timing.h

@@ -23,59 +23,6 @@
 
 namespace CoreTiming {
 
-// The below clock rate is based on Switch's clockspeed being widely known as 1.020GHz
-// The exact value used is of course unverified.
-constexpr u64 BASE_CLOCK_RATE = 1019215872; // Switch clock speed is 1020MHz un/docked
-
-inline s64 msToCycles(int ms) {
-    // since ms is int there is no way to overflow
-    return BASE_CLOCK_RATE * static_cast<s64>(ms) / 1000;
-}
-
-inline s64 msToCycles(float ms) {
-    return static_cast<s64>(BASE_CLOCK_RATE * (0.001f) * ms);
-}
-
-inline s64 msToCycles(double ms) {
-    return static_cast<s64>(BASE_CLOCK_RATE * (0.001) * ms);
-}
-
-inline s64 usToCycles(float us) {
-    return static_cast<s64>(BASE_CLOCK_RATE * (0.000001f) * us);
-}
-
-inline s64 usToCycles(int us) {
-    return (BASE_CLOCK_RATE * static_cast<s64>(us) / 1000000);
-}
-
-s64 usToCycles(s64 us);
-
-s64 usToCycles(u64 us);
-
-inline s64 nsToCycles(float ns) {
-    return static_cast<s64>(BASE_CLOCK_RATE * (0.000000001f) * ns);
-}
-
-inline s64 nsToCycles(int ns) {
-    return BASE_CLOCK_RATE * static_cast<s64>(ns) / 1000000000;
-}
-
-s64 nsToCycles(s64 ns);
-
-s64 nsToCycles(u64 ns);
-
-inline u64 cyclesToNs(s64 cycles) {
-    return cycles * 1000000000 / BASE_CLOCK_RATE;
-}
-
-inline s64 cyclesToUs(s64 cycles) {
-    return cycles * 1000000 / BASE_CLOCK_RATE;
-}
-
-inline u64 cyclesToMs(s64 cycles) {
-    return cycles * 1000 / BASE_CLOCK_RATE;
-}
-
 /**
  * CoreTiming begins at the boundary of timing slice -1. An initial call to Advance() is
  * required to end slice -1 and start slice 0 before the first cycle of code is executed.

src/core/core_timing_util.cpp

@@ -0,0 +1,63 @@
+// Copyright 2008 Dolphin Emulator Project / 2017 Citra Emulator Project
+// Licensed under GPLv2+
+// Refer to the license.txt file included.
+
+#include "core/core_timing_util.h"
+
+#include <cinttypes>
+#include <limits>
+#include "common/logging/log.h"
+
+namespace CoreTiming {
+
+constexpr u64 MAX_VALUE_TO_MULTIPLY = std::numeric_limits<s64>::max() / BASE_CLOCK_RATE;
+
+s64 usToCycles(s64 us) {
+    if (us / 1000000 > MAX_VALUE_TO_MULTIPLY) {
+        LOG_ERROR(Core_Timing, "Integer overflow, use max value");
+        return std::numeric_limits<s64>::max();
+    }
+    if (us > MAX_VALUE_TO_MULTIPLY) {
+        LOG_DEBUG(Core_Timing, "Time very big, do rounding");
+        return BASE_CLOCK_RATE * (us / 1000000);
+    }
+    return (BASE_CLOCK_RATE * us) / 1000000;
+}
+
+s64 usToCycles(u64 us) {
+    if (us / 1000000 > MAX_VALUE_TO_MULTIPLY) {
+        LOG_ERROR(Core_Timing, "Integer overflow, use max value");
+        return std::numeric_limits<s64>::max();
+    }
+    if (us > MAX_VALUE_TO_MULTIPLY) {
+        LOG_DEBUG(Core_Timing, "Time very big, do rounding");
+        return BASE_CLOCK_RATE * static_cast<s64>(us / 1000000);
+    }
+    return (BASE_CLOCK_RATE * static_cast<s64>(us)) / 1000000;
+}
+
+s64 nsToCycles(s64 ns) {
+    if (ns / 1000000000 > MAX_VALUE_TO_MULTIPLY) {
+        LOG_ERROR(Core_Timing, "Integer overflow, use max value");
+        return std::numeric_limits<s64>::max();
+    }
+    if (ns > MAX_VALUE_TO_MULTIPLY) {
+        LOG_DEBUG(Core_Timing, "Time very big, do rounding");
+        return BASE_CLOCK_RATE * (ns / 1000000000);
+    }
+    return (BASE_CLOCK_RATE * ns) / 1000000000;
+}
+
+s64 nsToCycles(u64 ns) {
+    if (ns / 1000000000 > MAX_VALUE_TO_MULTIPLY) {
+        LOG_ERROR(Core_Timing, "Integer overflow, use max value");
+        return std::numeric_limits<s64>::max();
+    }
+    if (ns > MAX_VALUE_TO_MULTIPLY) {
+        LOG_DEBUG(Core_Timing, "Time very big, do rounding");
+        return BASE_CLOCK_RATE * (static_cast<s64>(ns) / 1000000000);
+    }
+    return (BASE_CLOCK_RATE * static_cast<s64>(ns)) / 1000000000;
+}
+
+} // namespace CoreTiming

src/core/core_timing_util.h

@@ -0,0 +1,64 @@
+// Copyright 2008 Dolphin Emulator Project / 2017 Citra Emulator Project
+// Licensed under GPLv2+
+// Refer to the license.txt file included.
+
+#pragma once
+
+#include "common/common_types.h"
+
+namespace CoreTiming {
+
+// The below clock rate is based on Switch's clockspeed being widely known as 1.020GHz
+// The exact value used is of course unverified.
+constexpr u64 BASE_CLOCK_RATE = 1019215872; // Switch clock speed is 1020MHz un/docked
+
+inline s64 msToCycles(int ms) {
+    // since ms is int there is no way to overflow
+    return BASE_CLOCK_RATE * static_cast<s64>(ms) / 1000;
+}
+
+inline s64 msToCycles(float ms) {
+    return static_cast<s64>(BASE_CLOCK_RATE * (0.001f) * ms);
+}
+
+inline s64 msToCycles(double ms) {
+    return static_cast<s64>(BASE_CLOCK_RATE * (0.001) * ms);
+}
+
+inline s64 usToCycles(float us) {
+    return static_cast<s64>(BASE_CLOCK_RATE * (0.000001f) * us);
+}
+
+inline s64 usToCycles(int us) {
+    return (BASE_CLOCK_RATE * static_cast<s64>(us) / 1000000);
+}
+
+s64 usToCycles(s64 us);
+
+s64 usToCycles(u64 us);
+
+inline s64 nsToCycles(float ns) {
+    return static_cast<s64>(BASE_CLOCK_RATE * (0.000000001f) * ns);
+}
+
+inline s64 nsToCycles(int ns) {
+    return BASE_CLOCK_RATE * static_cast<s64>(ns) / 1000000000;
+}
+
+s64 nsToCycles(s64 ns);
+
+s64 nsToCycles(u64 ns);
+
+inline u64 cyclesToNs(s64 cycles) {
+    return cycles * 1000000000 / BASE_CLOCK_RATE;
+}
+
+inline s64 cyclesToUs(s64 cycles) {
+    return cycles * 1000000 / BASE_CLOCK_RATE;
+}
+
+inline u64 cyclesToMs(s64 cycles) {
+    return cycles * 1000 / BASE_CLOCK_RATE;
+}
+
+} // namespace CoreTiming

src/core/crypto/aes_util.cpp

@@ -0,0 +1,112 @@
+// Copyright 2018 yuzu emulator team
+// Licensed under GPLv2 or any later version
+// Refer to the license.txt file included.
+
+#include <mbedtls/cipher.h>
+#include "core/crypto/aes_util.h"
+#include "core/crypto/key_manager.h"
+
+namespace Core::Crypto {
+
+static_assert(static_cast<size_t>(Mode::CTR) == static_cast<size_t>(MBEDTLS_CIPHER_AES_128_CTR),
+              "CTR has incorrect value.");
+static_assert(static_cast<size_t>(Mode::ECB) == static_cast<size_t>(MBEDTLS_CIPHER_AES_128_ECB),
+              "ECB has incorrect value.");
+static_assert(static_cast<size_t>(Mode::XTS) == static_cast<size_t>(MBEDTLS_CIPHER_AES_128_XTS),
+              "XTS has incorrect value.");
+
+// Structure to hide mbedtls types from header file
+struct CipherContext {
+    mbedtls_cipher_context_t encryption_context;
+    mbedtls_cipher_context_t decryption_context;
+};
+
+template <typename Key, size_t KeySize>
+Crypto::AESCipher<Key, KeySize>::AESCipher(Key key, Mode mode)
+    : ctx(std::make_unique<CipherContext>()) {
+    mbedtls_cipher_init(&ctx->encryption_context);
+    mbedtls_cipher_init(&ctx->decryption_context);
+
+    ASSERT_MSG((mbedtls_cipher_setup(
+                    &ctx->encryption_context,
+                    mbedtls_cipher_info_from_type(static_cast<mbedtls_cipher_type_t>(mode))) ||
+                mbedtls_cipher_setup(
+                    &ctx->decryption_context,
+                    mbedtls_cipher_info_from_type(static_cast<mbedtls_cipher_type_t>(mode)))) == 0,
+               "Failed to initialize mbedtls ciphers.");
+
+    ASSERT(
+        !mbedtls_cipher_setkey(&ctx->encryption_context, key.data(), KeySize * 8, MBEDTLS_ENCRYPT));
+    ASSERT(
+        !mbedtls_cipher_setkey(&ctx->decryption_context, key.data(), KeySize * 8, MBEDTLS_DECRYPT));
+    //"Failed to set key on mbedtls ciphers.");
+}
+
+template <typename Key, size_t KeySize>
+AESCipher<Key, KeySize>::~AESCipher() {
+    mbedtls_cipher_free(&ctx->encryption_context);
+    mbedtls_cipher_free(&ctx->decryption_context);
+}
+
+template <typename Key, size_t KeySize>
+void AESCipher<Key, KeySize>::SetIV(std::vector<u8> iv) {
+    ASSERT_MSG((mbedtls_cipher_set_iv(&ctx->encryption_context, iv.data(), iv.size()) ||
+                mbedtls_cipher_set_iv(&ctx->decryption_context, iv.data(), iv.size())) == 0,
+               "Failed to set IV on mbedtls ciphers.");
+}
+
+template <typename Key, size_t KeySize>
+void AESCipher<Key, KeySize>::Transcode(const u8* src, size_t size, u8* dest, Op op) {
+    size_t written = 0;
+
+    const auto context = op == Op::Encrypt ? &ctx->encryption_context : &ctx->decryption_context;
+
+    mbedtls_cipher_reset(context);
+
+    if (mbedtls_cipher_get_cipher_mode(context) == MBEDTLS_MODE_XTS) {
+        mbedtls_cipher_update(context, src, size, dest, &written);
+        if (written != size)
+            LOG_WARNING(Crypto, "Not all data was decrypted requested={:016X}, actual={:016X}.",
+                        size, written);
+    } else {
+        const auto block_size = mbedtls_cipher_get_block_size(context);
+
+        for (size_t offset = 0; offset < size; offset += block_size) {
+            auto length = std::min<size_t>(block_size, size - offset);
+            mbedtls_cipher_update(context, src + offset, length, dest + offset, &written);
+            if (written != length)
+                LOG_WARNING(Crypto, "Not all data was decrypted requested={:016X}, actual={:016X}.",
+                            length, written);
+        }
+    }
+
+    mbedtls_cipher_finish(context, nullptr, nullptr);
+}
+
+template <typename Key, size_t KeySize>
+void AESCipher<Key, KeySize>::XTSTranscode(const u8* src, size_t size, u8* dest, size_t sector_id,
+                                           size_t sector_size, Op op) {
+    if (size % sector_size > 0) {
+        LOG_CRITICAL(Crypto, "Data size must be a multiple of sector size.");
+        return;
+    }
+
+    for (size_t i = 0; i < size; i += sector_size) {
+        SetIV(CalculateNintendoTweak(sector_id++));
+        Transcode<u8, u8>(src + i, sector_size, dest + i, op);
+    }
+}
+
+template <typename Key, size_t KeySize>
+std::vector<u8> AESCipher<Key, KeySize>::CalculateNintendoTweak(size_t sector_id) {
+    std::vector<u8> out(0x10);
+    for (size_t i = 0xF; i <= 0xF; --i) {
+        out[i] = sector_id & 0xFF;
+        sector_id >>= 8;
+    }
+    return out;
+}
+
+template class AESCipher<Key128>;
+template class AESCipher<Key256>;
+} // namespace Core::Crypto

src/core/crypto/aes_util.h

@@ -0,0 +1,62 @@
+// Copyright 2018 yuzu emulator team
+// Licensed under GPLv2 or any later version
+// Refer to the license.txt file included.
+
+#pragma once
+
+#include <memory>
+#include <type_traits>
+#include <vector>
+#include "common/assert.h"
+#include "core/file_sys/vfs.h"
+
+namespace Core::Crypto {
+
+struct CipherContext;
+
+enum class Mode {
+    CTR = 11,
+    ECB = 2,
+    XTS = 70,
+};
+
+enum class Op {
+    Encrypt,
+    Decrypt,
+};
+
+template <typename Key, size_t KeySize = sizeof(Key)>
+class AESCipher {
+    static_assert(std::is_same_v<Key, std::array<u8, KeySize>>, "Key must be std::array of u8.");
+    static_assert(KeySize == 0x10 || KeySize == 0x20, "KeySize must be 128 or 256.");
+
+public:
+    AESCipher(Key key, Mode mode);
+
+    ~AESCipher();
+
+    void SetIV(std::vector<u8> iv);
+
+    template <typename Source, typename Dest>
+    void Transcode(const Source* src, size_t size, Dest* dest, Op op) {
+        Transcode(reinterpret_cast<const u8*>(src), size, reinterpret_cast<u8*>(dest), op);
+    }
+
+    void Transcode(const u8* src, size_t size, u8* dest, Op op);
+
+    template <typename Source, typename Dest>
+    void XTSTranscode(const Source* src, size_t size, Dest* dest, size_t sector_id,
+                      size_t sector_size, Op op) {
+        XTSTranscode(reinterpret_cast<const u8*>(src), size, reinterpret_cast<u8*>(dest), sector_id,
+                     sector_size, op);
+    }
+
+    void XTSTranscode(const u8* src, size_t size, u8* dest, size_t sector_id, size_t sector_size,
+                      Op op);
+
+private:
+    std::unique_ptr<CipherContext> ctx;
+
+    static std::vector<u8> CalculateNintendoTweak(size_t sector_id);
+};
+} // namespace Core::Crypto

src/core/crypto/ctr_encryption_layer.cpp

@@ -0,0 +1,56 @@
+// Copyright 2018 yuzu emulator team
+// Licensed under GPLv2 or any later version
+// Refer to the license.txt file included.
+
+#include <cstring>
+#include "common/assert.h"
+#include "core/crypto/ctr_encryption_layer.h"
+
+namespace Core::Crypto {
+
+CTREncryptionLayer::CTREncryptionLayer(FileSys::VirtualFile base_, Key128 key_, size_t base_offset)
+    : EncryptionLayer(std::move(base_)), base_offset(base_offset), cipher(key_, Mode::CTR),
+      iv(16, 0) {}
+
+size_t CTREncryptionLayer::Read(u8* data, size_t length, size_t offset) const {
+    if (length == 0)
+        return 0;
+
+    const auto sector_offset = offset & 0xF;
+    if (sector_offset == 0) {
+        UpdateIV(base_offset + offset);
+        std::vector<u8> raw = base->ReadBytes(length, offset);
+        if (raw.size() != length)
+            return Read(data, raw.size(), offset);
+        cipher.Transcode(raw.data(), length, data, Op::Decrypt);
+        return length;
+    }
+
+    // offset does not fall on block boundary (0x10)
+    std::vector<u8> block = base->ReadBytes(0x10, offset - sector_offset);
+    UpdateIV(base_offset + offset - sector_offset);
+    cipher.Transcode(block.data(), block.size(), block.data(), Op::Decrypt);
+    size_t read = 0x10 - sector_offset;
+
+    if (length + sector_offset < 0x10) {
+        std::memcpy(data, block.data() + sector_offset, std::min<u64>(length, read));
+        return read;
+    }
+    std::memcpy(data, block.data() + sector_offset, read);
+    return read + Read(data + read, length - read, offset + read);
+}
+
+void CTREncryptionLayer::SetIV(const std::vector<u8>& iv_) {
+    const auto length = std::min(iv_.size(), iv.size());
+    iv.assign(iv_.cbegin(), iv_.cbegin() + length);
+}
+
+void CTREncryptionLayer::UpdateIV(size_t offset) const {
+    offset >>= 4;
+    for (size_t i = 0; i < 8; ++i) {
+        iv[16 - i - 1] = offset & 0xFF;
+        offset >>= 8;
+    }
+    cipher.SetIV(iv);
+}
+} // namespace Core::Crypto

src/core/crypto/ctr_encryption_layer.h

@@ -0,0 +1,33 @@
+// Copyright 2018 yuzu emulator team
+// Licensed under GPLv2 or any later version
+// Refer to the license.txt file included.
+
+#pragma once
+
+#include <vector>
+#include "core/crypto/aes_util.h"
+#include "core/crypto/encryption_layer.h"
+#include "core/crypto/key_manager.h"
+
+namespace Core::Crypto {
+
+// Sits on top of a VirtualFile and provides CTR-mode AES decription.
+class CTREncryptionLayer : public EncryptionLayer {
+public:
+    CTREncryptionLayer(FileSys::VirtualFile base, Key128 key, size_t base_offset);
+
+    size_t Read(u8* data, size_t length, size_t offset) const override;
+
+    void SetIV(const std::vector<u8>& iv);
+
+private:
+    size_t base_offset;
+
+    // Must be mutable as operations modify cipher contexts.
+    mutable AESCipher<Key128> cipher;
+    mutable std::vector<u8> iv;
+
+    void UpdateIV(size_t offset) const;
+};
+
+} // namespace Core::Crypto

src/core/crypto/encryption_layer.cpp

@@ -0,0 +1,42 @@
+// Copyright 2018 yuzu emulator team
+// Licensed under GPLv2 or any later version
+// Refer to the license.txt file included.
+
+#include "core/crypto/encryption_layer.h"
+
+namespace Core::Crypto {
+
+EncryptionLayer::EncryptionLayer(FileSys::VirtualFile base_) : base(std::move(base_)) {}
+
+std::string EncryptionLayer::GetName() const {
+    return base->GetName();
+}
+
+size_t EncryptionLayer::GetSize() const {
+    return base->GetSize();
+}
+
+bool EncryptionLayer::Resize(size_t new_size) {
+    return false;
+}
+
+std::shared_ptr<FileSys::VfsDirectory> EncryptionLayer::GetContainingDirectory() const {
+    return base->GetContainingDirectory();
+}
+
+bool EncryptionLayer::IsWritable() const {
+    return false;
+}
+
+bool EncryptionLayer::IsReadable() const {
+    return true;
+}
+
+size_t EncryptionLayer::Write(const u8* data, size_t length, size_t offset) {
+    return 0;
+}
+
+bool EncryptionLayer::Rename(std::string_view name) {
+    return base->Rename(name);
+}
+} // namespace Core::Crypto

src/core/crypto/encryption_layer.h

@@ -0,0 +1,32 @@
+// Copyright 2018 yuzu emulator team
+// Licensed under GPLv2 or any later version
+// Refer to the license.txt file included.
+
+#pragma once
+
+#include "core/file_sys/vfs.h"
+
+namespace Core::Crypto {
+
+// Basically non-functional class that implements all of the methods that are irrelevant to an
+// EncryptionLayer. Reduces duplicate code.
+class EncryptionLayer : public FileSys::VfsFile {
+public:
+    explicit EncryptionLayer(FileSys::VirtualFile base);
+
+    size_t Read(u8* data, size_t length, size_t offset) const override = 0;
+
+    std::string GetName() const override;
+    size_t GetSize() const override;
+    bool Resize(size_t new_size) override;
+    std::shared_ptr<FileSys::VfsDirectory> GetContainingDirectory() const override;
+    bool IsWritable() const override;
+    bool IsReadable() const override;
+    size_t Write(const u8* data, size_t length, size_t offset) override;
+    bool Rename(std::string_view name) override;
+
+protected:
+    FileSys::VirtualFile base;
+};
+
+} // namespace Core::Crypto

src/core/crypto/key_manager.cpp

@@ -0,0 +1,215 @@
+// Copyright 2018 yuzu emulator team
+// Licensed under GPLv2 or any later version
+// Refer to the license.txt file included.
+
+#include <array>
+#include <fstream>
+#include <locale>
+#include <sstream>
+#include <string_view>
+#include <mbedtls/sha256.h>
+#include "common/assert.h"
+#include "common/common_paths.h"
+#include "common/file_util.h"
+#include "common/logging/log.h"
+#include "core/crypto/key_manager.h"
+#include "core/settings.h"
+#include "key_manager.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();
+    const std::string yuzu_keys_dir = FileUtil::GetUserPath(FileUtil::UserPath::KeysDir);
+    if (Settings::values.use_dev_keys) {
+        dev_mode = true;
+        AttemptLoadKeyFile(yuzu_keys_dir, hactool_keys_dir, "dev.keys", false);
+    } else {
+        dev_mode = false;
+        AttemptLoadKeyFile(yuzu_keys_dir, hactool_keys_dir, "prod.keys", false);
+    }
+
+    AttemptLoadKeyFile(yuzu_keys_dir, hactool_keys_dir, "title.keys", true);
+}
+
+void KeyManager::LoadFromFile(std::string_view filename_, bool is_title_keys) {
+    const auto filename = std::string(filename_);
+    std::ifstream file(filename);
+    if (!file.is_open())
+        return;
+
+    std::string line;
+    while (std::getline(file, line)) {
+        std::vector<std::string> out;
+        std::stringstream stream(line);
+        std::string item;
+        while (std::getline(stream, item, '='))
+            out.push_back(std::move(item));
+
+        if (out.size() != 2)
+            continue;
+
+        out[0].erase(std::remove(out[0].begin(), out[0].end(), ' '), out[0].end());
+        out[1].erase(std::remove(out[1].begin(), out[1].end(), ' '), out[1].end());
+
+        if (is_title_keys) {
+            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 = 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 = 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 = HexStringToArray<32>(out[1]);
+                SetKey(index.type, key, index.field1, index.field2);
+            }
+        }
+    }
+}
+
+void KeyManager::AttemptLoadKeyFile(std::string_view dir1_, std::string_view dir2_,
+                                    std::string_view filename_, bool title) {
+    const std::string dir1(dir1_);
+    const std::string dir2(dir2_);
+    const std::string filename(filename_);
+    if (FileUtil::Exists(dir1 + DIR_SEP + filename))
+        LoadFromFile(dir1 + DIR_SEP + filename, title);
+    else if (FileUtil::Exists(dir2 + DIR_SEP + filename))
+        LoadFromFile(dir2 + DIR_SEP + filename, title);
+}
+
+bool KeyManager::HasKey(S128KeyType id, u64 field1, u64 field2) const {
+    return s128_keys.find({id, field1, field2}) != s128_keys.end();
+}
+
+bool KeyManager::HasKey(S256KeyType id, u64 field1, u64 field2) const {
+    return s256_keys.find({id, field1, field2}) != s256_keys.end();
+}
+
+Key128 KeyManager::GetKey(S128KeyType id, u64 field1, u64 field2) const {
+    if (!HasKey(id, field1, field2))
+        return {};
+    return s128_keys.at({id, field1, field2});
+}
+
+Key256 KeyManager::GetKey(S256KeyType id, u64 field1, u64 field2) const {
+    if (!HasKey(id, field1, field2))
+        return {};
+    return s256_keys.at({id, field1, field2});
+}
+
+void KeyManager::SetKey(S128KeyType id, Key128 key, u64 field1, u64 field2) {
+    s128_keys[{id, field1, field2}] = key;
+}
+
+void KeyManager::SetKey(S256KeyType id, Key256 key, u64 field1, u64 field2) {
+    s256_keys[{id, field1, field2}] = key;
+}
+
+bool KeyManager::KeyFileExists(bool title) {
+    const std::string hactool_keys_dir = FileUtil::GetHactoolConfigurationPath();
+    const std::string yuzu_keys_dir = FileUtil::GetUserPath(FileUtil::UserPath::KeysDir);
+    if (title) {
+        return FileUtil::Exists(hactool_keys_dir + DIR_SEP + "title.keys") ||
+               FileUtil::Exists(yuzu_keys_dir + DIR_SEP + "title.keys");
+    }
+
+    if (Settings::values.use_dev_keys) {
+        return FileUtil::Exists(hactool_keys_dir + DIR_SEP + "dev.keys") ||
+               FileUtil::Exists(yuzu_keys_dir + DIR_SEP + "dev.keys");
+    }
+
+    return FileUtil::Exists(hactool_keys_dir + DIR_SEP + "prod.keys") ||
+           FileUtil::Exists(yuzu_keys_dir + DIR_SEP + "prod.keys");
+}
+
+const std::unordered_map<std::string, KeyIndex<S128KeyType>> KeyManager::s128_file_id = {
+    {"master_key_00", {S128KeyType::Master, 0, 0}},
+    {"master_key_01", {S128KeyType::Master, 1, 0}},
+    {"master_key_02", {S128KeyType::Master, 2, 0}},
+    {"master_key_03", {S128KeyType::Master, 3, 0}},
+    {"master_key_04", {S128KeyType::Master, 4, 0}},
+    {"package1_key_00", {S128KeyType::Package1, 0, 0}},
+    {"package1_key_01", {S128KeyType::Package1, 1, 0}},
+    {"package1_key_02", {S128KeyType::Package1, 2, 0}},
+    {"package1_key_03", {S128KeyType::Package1, 3, 0}},
+    {"package1_key_04", {S128KeyType::Package1, 4, 0}},
+    {"package2_key_00", {S128KeyType::Package2, 0, 0}},
+    {"package2_key_01", {S128KeyType::Package2, 1, 0}},
+    {"package2_key_02", {S128KeyType::Package2, 2, 0}},
+    {"package2_key_03", {S128KeyType::Package2, 3, 0}},
+    {"package2_key_04", {S128KeyType::Package2, 4, 0}},
+    {"titlekek_00", {S128KeyType::Titlekek, 0, 0}},
+    {"titlekek_01", {S128KeyType::Titlekek, 1, 0}},
+    {"titlekek_02", {S128KeyType::Titlekek, 2, 0}},
+    {"titlekek_03", {S128KeyType::Titlekek, 3, 0}},
+    {"titlekek_04", {S128KeyType::Titlekek, 4, 0}},
+    {"eticket_rsa_kek", {S128KeyType::ETicketRSAKek, 0, 0}},
+    {"key_area_key_application_00",
+     {S128KeyType::KeyArea, 0, static_cast<u64>(KeyAreaKeyType::Application)}},
+    {"key_area_key_application_01",
+     {S128KeyType::KeyArea, 1, static_cast<u64>(KeyAreaKeyType::Application)}},
+    {"key_area_key_application_02",
+     {S128KeyType::KeyArea, 2, static_cast<u64>(KeyAreaKeyType::Application)}},
+    {"key_area_key_application_03",
+     {S128KeyType::KeyArea, 3, static_cast<u64>(KeyAreaKeyType::Application)}},
+    {"key_area_key_application_04",
+     {S128KeyType::KeyArea, 4, static_cast<u64>(KeyAreaKeyType::Application)}},
+    {"key_area_key_ocean_00", {S128KeyType::KeyArea, 0, static_cast<u64>(KeyAreaKeyType::Ocean)}},
+    {"key_area_key_ocean_01", {S128KeyType::KeyArea, 1, static_cast<u64>(KeyAreaKeyType::Ocean)}},
+    {"key_area_key_ocean_02", {S128KeyType::KeyArea, 2, static_cast<u64>(KeyAreaKeyType::Ocean)}},
+    {"key_area_key_ocean_03", {S128KeyType::KeyArea, 3, static_cast<u64>(KeyAreaKeyType::Ocean)}},
+    {"key_area_key_ocean_04", {S128KeyType::KeyArea, 4, static_cast<u64>(KeyAreaKeyType::Ocean)}},
+    {"key_area_key_system_00", {S128KeyType::KeyArea, 0, static_cast<u64>(KeyAreaKeyType::System)}},
+    {"key_area_key_system_01", {S128KeyType::KeyArea, 1, static_cast<u64>(KeyAreaKeyType::System)}},
+    {"key_area_key_system_02", {S128KeyType::KeyArea, 2, static_cast<u64>(KeyAreaKeyType::System)}},
+    {"key_area_key_system_03", {S128KeyType::KeyArea, 3, static_cast<u64>(KeyAreaKeyType::System)}},
+    {"key_area_key_system_04", {S128KeyType::KeyArea, 4, static_cast<u64>(KeyAreaKeyType::System)}},
+};
+
+const std::unordered_map<std::string, KeyIndex<S256KeyType>> KeyManager::s256_file_id = {
+    {"header_key", {S256KeyType::Header, 0, 0}},
+    {"sd_card_save_key", {S256KeyType::SDSave, 0, 0}},
+    {"sd_card_nca_key", {S256KeyType::SDNCA, 0, 0}},
+};
+} // namespace Core::Crypto

src/core/crypto/key_manager.h

@@ -0,0 +1,119 @@
+// Copyright 2018 yuzu emulator team
+// Licensed under GPLv2 or any later version
+// Refer to the license.txt file included.
+
+#pragma once
+
+#include <array>
+#include <type_traits>
+#include <unordered_map>
+#include <vector>
+#include <fmt/format.h>
+#include "common/common_types.h"
+
+namespace Core::Crypto {
+
+using Key128 = std::array<u8, 0x10>;
+using Key256 = std::array<u8, 0x20>;
+using SHA256Hash = std::array<u8, 0x20>;
+
+static_assert(sizeof(Key128) == 16, "Key128 must be 128 bytes big.");
+static_assert(sizeof(Key256) == 32, "Key128 must be 128 bytes big.");
+
+enum class S256KeyType : u64 {
+    Header, //
+    SDSave, //
+    SDNCA,  //
+};
+
+enum class S128KeyType : u64 {
+    Master,        // f1=crypto revision
+    Package1,      // f1=crypto revision
+    Package2,      // f1=crypto revision
+    Titlekek,      // f1=crypto revision
+    ETicketRSAKek, //
+    KeyArea,       // f1=crypto revision f2=type {app, ocean, system}
+    SDSeed,        //
+    Titlekey,      // f1=rights id LSB f2=rights id MSB
+};
+
+enum class KeyAreaKeyType : u8 {
+    Application,
+    Ocean,
+    System,
+};
+
+template <typename KeyType>
+struct KeyIndex {
+    KeyType type;
+    u64 field1;
+    u64 field2;
+
+    std::string DebugInfo() const {
+        u8 key_size = 16;
+        if constexpr (std::is_same_v<KeyType, S256KeyType>)
+            key_size = 32;
+        return fmt::format("key_size={:02X}, key={:02X}, field1={:016X}, field2={:016X}", key_size,
+                           static_cast<u8>(type), field1, field2);
+    }
+};
+
+// The following two (== and hash) are so KeyIndex can be a key in unordered_map
+
+template <typename KeyType>
+bool operator==(const KeyIndex<KeyType>& lhs, const KeyIndex<KeyType>& rhs) {
+    return std::tie(lhs.type, lhs.field1, lhs.field2) == std::tie(rhs.type, rhs.field1, rhs.field2);
+}
+
+template <typename KeyType>
+bool operator!=(const KeyIndex<KeyType>& lhs, const KeyIndex<KeyType>& rhs) {
+    return !operator==(lhs, rhs);
+}
+
+} // namespace Core::Crypto
+
+namespace std {
+template <typename KeyType>
+struct hash<Core::Crypto::KeyIndex<KeyType>> {
+    size_t operator()(const Core::Crypto::KeyIndex<KeyType>& k) const {
+        using std::hash;
+
+        return ((hash<u64>()(static_cast<u64>(k.type)) ^ (hash<u64>()(k.field1) << 1)) >> 1) ^
+               (hash<u64>()(k.field2) << 1);
+    }
+};
+} // namespace std
+
+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();
+
+    bool HasKey(S128KeyType id, u64 field1 = 0, u64 field2 = 0) const;
+    bool HasKey(S256KeyType id, u64 field1 = 0, u64 field2 = 0) const;
+
+    Key128 GetKey(S128KeyType id, u64 field1 = 0, u64 field2 = 0) const;
+    Key256 GetKey(S256KeyType id, u64 field1 = 0, u64 field2 = 0) const;
+
+    void SetKey(S128KeyType id, Key128 key, u64 field1 = 0, u64 field2 = 0);
+    void SetKey(S256KeyType id, Key256 key, u64 field1 = 0, u64 field2 = 0);
+
+    static bool KeyFileExists(bool title);
+
+private:
+    std::unordered_map<KeyIndex<S128KeyType>, Key128> s128_keys;
+    std::unordered_map<KeyIndex<S256KeyType>, Key256> s256_keys;
+
+    bool dev_mode;
+    void LoadFromFile(std::string_view filename, bool is_title_keys);
+    void AttemptLoadKeyFile(std::string_view dir1, std::string_view dir2, std::string_view filename,
+                            bool title);
+
+    static const std::unordered_map<std::string, KeyIndex<S128KeyType>> s128_file_id;
+    static const std::unordered_map<std::string, KeyIndex<S256KeyType>> s256_file_id;
+};
+} // namespace Core::Crypto

src/core/crypto/sha_util.cpp

@@ -0,0 +1,5 @@
+// Copyright 2018 yuzu emulator team
+// Licensed under GPLv2 or any later version
+// Refer to the license.txt file included.
+
+namespace Crypto {} // namespace Crypto

src/core/crypto/sha_util.h

@@ -0,0 +1,20 @@
+// Copyright 2018 yuzu emulator team
+// Licensed under GPLv2 or any later version
+// Refer to the license.txt file included.
+
+#pragma once
+
+#include "common/assert.h"
+#include "core/file_sys/vfs.h"
+#include "key_manager.h"
+#include "mbedtls/cipher.h"
+
+namespace Crypto {
+typedef std::array<u8, 0x20> SHA256Hash;
+
+inline SHA256Hash operator"" _HASH(const char* data, size_t len) {
+    if (len != 0x40)
+        return {};
+}
+
+} // namespace Crypto

src/core/file_sys/card_image.cpp

@@ -0,0 +1,149 @@
+// Copyright 2018 yuzu emulator team
+// Licensed under GPLv2 or any later version
+// Refer to the license.txt file included.
+
+#include <array>
+#include <string>
+#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"
+
+namespace FileSys {
+
+XCI::XCI(VirtualFile file_) : file(std::move(file_)), partitions(0x4) {
+    if (file->ReadObject(&header) != sizeof(GamecardHeader)) {
+        status = Loader::ResultStatus::ErrorInvalidFormat;
+        return;
+    }
+
+    if (header.magic != Common::MakeMagic('H', 'E', 'A', 'D')) {
+        status = Loader::ResultStatus::ErrorInvalidFormat;
+        return;
+    }
+
+    PartitionFilesystem main_hfs(
+        std::make_shared<OffsetVfsFile>(file, header.hfs_size, header.hfs_offset));
+
+    if (main_hfs.GetStatus() != Loader::ResultStatus::Success) {
+        status = main_hfs.GetStatus();
+        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)]);
+        if (raw != nullptr)
+            partitions[static_cast<size_t>(partition)] = std::make_shared<PartitionFilesystem>(raw);
+    }
+
+    auto result = AddNCAFromPartition(XCIPartition::Secure);
+    if (result != Loader::ResultStatus::Success) {
+        status = result;
+        return;
+    }
+
+    result = AddNCAFromPartition(XCIPartition::Update);
+    if (result != Loader::ResultStatus::Success) {
+        status = result;
+        return;
+    }
+
+    result = AddNCAFromPartition(XCIPartition::Normal);
+    if (result != Loader::ResultStatus::Success) {
+        status = result;
+        return;
+    }
+
+    if (GetFormatVersion() >= 0x2) {
+        result = AddNCAFromPartition(XCIPartition::Logo);
+        if (result != Loader::ResultStatus::Success) {
+            status = result;
+            return;
+        }
+    }
+
+    status = Loader::ResultStatus::Success;
+}
+
+Loader::ResultStatus XCI::GetStatus() const {
+    return status;
+}
+
+VirtualDir XCI::GetPartition(XCIPartition partition) const {
+    return partitions[static_cast<size_t>(partition)];
+}
+
+VirtualDir XCI::GetSecurePartition() const {
+    return GetPartition(XCIPartition::Secure);
+}
+
+VirtualDir XCI::GetNormalPartition() const {
+    return GetPartition(XCIPartition::Normal);
+}
+
+VirtualDir XCI::GetUpdatePartition() const {
+    return GetPartition(XCIPartition::Update);
+}
+
+VirtualDir XCI::GetLogoPartition() const {
+    return GetPartition(XCIPartition::Logo);
+}
+
+std::shared_ptr<NCA> XCI::GetNCAByType(NCAContentType type) const {
+    const auto iter =
+        std::find_if(ncas.begin(), ncas.end(),
+                     [type](const std::shared_ptr<NCA>& nca) { return nca->GetType() == type; });
+    return iter == ncas.end() ? nullptr : *iter;
+}
+
+VirtualFile XCI::GetNCAFileByType(NCAContentType type) const {
+    auto nca = GetNCAByType(type);
+    if (nca != nullptr)
+        return nca->GetBaseFile();
+    return nullptr;
+}
+
+std::vector<std::shared_ptr<VfsFile>> XCI::GetFiles() 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();
+}
+
+std::shared_ptr<VfsDirectory> XCI::GetParentDirectory() const {
+    return file->GetContainingDirectory();
+}
+
+bool XCI::ReplaceFileWithSubdirectory(VirtualFile file, VirtualDir dir) {
+    return false;
+}
+
+Loader::ResultStatus XCI::AddNCAFromPartition(XCIPartition part) {
+    if (partitions[static_cast<size_t>(part)] == nullptr) {
+        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)
+            ncas.push_back(std::move(nca));
+    }
+
+    return Loader::ResultStatus::Success;
+}
+
+u8 XCI::GetFormatVersion() const {
+    return GetLogoPartition() == nullptr ? 0x1 : 0x2;
+}
+} // namespace FileSys

src/core/file_sys/card_image.h

@@ -0,0 +1,96 @@
+// Copyright 2018 yuzu emulator team
+// 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"
+#include "common/swap.h"
+#include "core/file_sys/content_archive.h"
+#include "core/file_sys/vfs.h"
+#include "core/loader/loader.h"
+
+namespace FileSys {
+
+enum class GamecardSize : u8 {
+    S_1GB = 0xFA,
+    S_2GB = 0xF8,
+    S_4GB = 0xF0,
+    S_8GB = 0xE0,
+    S_16GB = 0xE1,
+    S_32GB = 0xE2,
+};
+
+struct GamecardInfo {
+    std::array<u8, 0x70> data;
+};
+static_assert(sizeof(GamecardInfo) == 0x70, "GamecardInfo has incorrect size.");
+
+struct GamecardHeader {
+    std::array<u8, 0x100> signature;
+    u32_le magic;
+    u32_le secure_area_start;
+    u32_le backup_area_start;
+    u8 kek_index;
+    GamecardSize size;
+    u8 header_version;
+    u8 flags;
+    u64_le package_id;
+    u64_le valid_data_end;
+    u128 info_iv;
+    u64_le hfs_offset;
+    u64_le hfs_size;
+    std::array<u8, 0x20> hfs_header_hash;
+    std::array<u8, 0x20> initial_data_hash;
+    u32_le secure_mode_flag;
+    u32_le title_key_flag;
+    u32_le key_flag;
+    u32_le normal_area_end;
+    GamecardInfo info;
+};
+static_assert(sizeof(GamecardHeader) == 0x200, "GamecardHeader has incorrect size.");
+
+enum class XCIPartition : u8 { Update, Normal, Secure, Logo };
+
+class XCI : public ReadOnlyVfsDirectory {
+public:
+    explicit XCI(VirtualFile file);
+
+    Loader::ResultStatus GetStatus() const;
+
+    u8 GetFormatVersion() const;
+
+    VirtualDir GetPartition(XCIPartition partition) const;
+    VirtualDir GetSecurePartition() const;
+    VirtualDir GetNormalPartition() const;
+    VirtualDir GetUpdatePartition() const;
+    VirtualDir GetLogoPartition() const;
+
+    std::shared_ptr<NCA> GetNCAByType(NCAContentType type) const;
+    VirtualFile GetNCAFileByType(NCAContentType type) const;
+
+    std::vector<std::shared_ptr<VfsFile>> GetFiles() const override;
+
+    std::vector<std::shared_ptr<VfsDirectory>> GetSubdirectories() const override;
+
+    std::string GetName() const override;
+
+    std::shared_ptr<VfsDirectory> GetParentDirectory() const override;
+
+protected:
+    bool ReplaceFileWithSubdirectory(VirtualFile file, VirtualDir dir) override;
+
+private:
+    Loader::ResultStatus AddNCAFromPartition(XCIPartition part);
+
+    VirtualFile file;
+    GamecardHeader header{};
+
+    Loader::ResultStatus status;
+
+    std::vector<VirtualDir> partitions;
+    std::vector<std::shared_ptr<NCA>> ncas;
+};
+} // namespace FileSys

src/core/file_sys/content_archive.cpp

@@ -0,0 +1,276 @@
+// Copyright 2018 yuzu emulator team
+// Licensed under GPLv2 or any later version
+// Refer to the license.txt file included.
+
+#include <algorithm>
+#include <utility>
+#include <boost/optional.hpp>
+#include "common/logging/log.h"
+#include "core/crypto/aes_util.h"
+#include "core/crypto/ctr_encryption_layer.h"
+#include "core/file_sys/content_archive.h"
+#include "core/file_sys/romfs.h"
+#include "core/file_sys/vfs_offset.h"
+#include "core/loader/loader.h"
+
+namespace FileSys {
+
+// Media offsets in headers are stored divided by 512. Mult. by this to get real offset.
+constexpr u64 MEDIA_OFFSET_MULTIPLIER = 0x200;
+
+constexpr u64 SECTION_HEADER_SIZE = 0x200;
+constexpr u64 SECTION_HEADER_OFFSET = 0x400;
+
+constexpr u32 IVFC_MAX_LEVEL = 6;
+
+enum class NCASectionFilesystemType : u8 {
+    PFS0 = 0x2,
+    ROMFS = 0x3,
+};
+
+struct NCASectionHeaderBlock {
+    INSERT_PADDING_BYTES(3);
+    NCASectionFilesystemType filesystem_type;
+    NCASectionCryptoType crypto_type;
+    INSERT_PADDING_BYTES(3);
+};
+static_assert(sizeof(NCASectionHeaderBlock) == 0x8, "NCASectionHeaderBlock has incorrect size.");
+
+struct NCASectionRaw {
+    NCASectionHeaderBlock header;
+    std::array<u8, 0x138> block_data;
+    std::array<u8, 0x8> section_ctr;
+    INSERT_PADDING_BYTES(0xB8);
+};
+static_assert(sizeof(NCASectionRaw) == 0x200, "NCASectionRaw has incorrect size.");
+
+struct PFS0Superblock {
+    NCASectionHeaderBlock header_block;
+    std::array<u8, 0x20> hash;
+    u32_le size;
+    INSERT_PADDING_BYTES(4);
+    u64_le hash_table_offset;
+    u64_le hash_table_size;
+    u64_le pfs0_header_offset;
+    u64_le pfs0_size;
+    INSERT_PADDING_BYTES(0x1B0);
+};
+static_assert(sizeof(PFS0Superblock) == 0x200, "PFS0Superblock has incorrect size.");
+
+struct RomFSSuperblock {
+    NCASectionHeaderBlock header_block;
+    IVFCHeader ivfc;
+    INSERT_PADDING_BYTES(0x118);
+};
+static_assert(sizeof(RomFSSuperblock) == 0x200, "RomFSSuperblock has incorrect size.");
+
+union NCASectionHeader {
+    NCASectionRaw raw;
+    PFS0Superblock pfs0;
+    RomFSSuperblock romfs;
+};
+static_assert(sizeof(NCASectionHeader) == 0x200, "NCASectionHeader has incorrect size.");
+
+bool IsValidNCA(const NCAHeader& header) {
+    // TODO(DarkLordZach): Add NCA2/NCA0 support.
+    return header.magic == Common::MakeMagic('N', 'C', 'A', '3');
+}
+
+boost::optional<Core::Crypto::Key128> NCA::GetKeyAreaKey(NCASectionCryptoType type) const {
+    u8 master_key_id = header.crypto_type;
+    if (header.crypto_type_2 > master_key_id)
+        master_key_id = header.crypto_type_2;
+    if (master_key_id > 0)
+        --master_key_id;
+
+    if (!keys.HasKey(Core::Crypto::S128KeyType::KeyArea, master_key_id, header.key_index))
+        return boost::none;
+
+    std::vector<u8> key_area(header.key_area.begin(), header.key_area.end());
+    Core::Crypto::AESCipher<Core::Crypto::Key128> cipher(
+        keys.GetKey(Core::Crypto::S128KeyType::KeyArea, master_key_id, header.key_index),
+        Core::Crypto::Mode::ECB);
+    cipher.Transcode(key_area.data(), key_area.size(), key_area.data(), Core::Crypto::Op::Decrypt);
+
+    Core::Crypto::Key128 out;
+    if (type == NCASectionCryptoType::XTS)
+        std::copy(key_area.begin(), key_area.begin() + 0x10, out.begin());
+    else if (type == NCASectionCryptoType::CTR)
+        std::copy(key_area.begin() + 0x20, key_area.begin() + 0x30, out.begin());
+    else
+        LOG_CRITICAL(Crypto, "Called GetKeyAreaKey on invalid NCASectionCryptoType type={:02X}",
+                     static_cast<u8>(type));
+    u128 out_128{};
+    memcpy(out_128.data(), out.data(), 16);
+    LOG_DEBUG(Crypto, "called with crypto_rev={:02X}, kak_index={:02X}, key={:016X}{:016X}",
+              master_key_id, header.key_index, out_128[1], out_128[0]);
+
+    return out;
+}
+
+VirtualFile NCA::Decrypt(NCASectionHeader header, VirtualFile in, u64 starting_offset) const {
+    if (!encrypted)
+        return in;
+
+    switch (header.raw.header.crypto_type) {
+    case NCASectionCryptoType::NONE:
+        LOG_DEBUG(Crypto, "called with mode=NONE");
+        return in;
+    case NCASectionCryptoType::CTR:
+        LOG_DEBUG(Crypto, "called with mode=CTR, starting_offset={:016X}", starting_offset);
+        {
+            const auto key = GetKeyAreaKey(NCASectionCryptoType::CTR);
+            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);
+            for (u8 i = 0; i < 8; ++i)
+                iv[i] = header.raw.section_ctr[0x8 - i - 1];
+            out->SetIV(iv);
+            return std::static_pointer_cast<VfsFile>(out);
+        }
+    case NCASectionCryptoType::XTS:
+        // TODO(DarkLordZach): Implement XTSEncryptionLayer and title key encryption.
+    default:
+        LOG_ERROR(Crypto, "called with unhandled crypto type={:02X}",
+                  static_cast<u8>(header.raw.header.crypto_type));
+        return nullptr;
+    }
+}
+
+NCA::NCA(VirtualFile file_) : file(std::move(file_)) {
+    if (sizeof(NCAHeader) != file->ReadObject(&header))
+        LOG_ERROR(Loader, "File reader errored out during header read.");
+
+    encrypted = false;
+
+    if (!IsValidNCA(header)) {
+        NCAHeader dec_header{};
+        Core::Crypto::AESCipher<Core::Crypto::Key256> cipher(
+            keys.GetKey(Core::Crypto::S256KeyType::Header), Core::Crypto::Mode::XTS);
+        cipher.XTSTranscode(&header, sizeof(NCAHeader), &dec_header, 0, 0x200,
+                            Core::Crypto::Op::Decrypt);
+        if (IsValidNCA(dec_header)) {
+            header = dec_header;
+            encrypted = true;
+        } else {
+            if (!keys.HasKey(Core::Crypto::S256KeyType::Header))
+                status = Loader::ResultStatus::ErrorMissingKeys;
+            else
+                status = Loader::ResultStatus::ErrorDecrypting;
+            return;
+        }
+    }
+
+    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; });
+
+    std::vector<NCASectionHeader> sections(number_sections);
+    const auto length_sections = SECTION_HEADER_SIZE * number_sections;
+
+    if (encrypted) {
+        auto raw = file->ReadBytes(length_sections, SECTION_HEADER_OFFSET);
+        Core::Crypto::AESCipher<Core::Crypto::Key256> cipher(
+            keys.GetKey(Core::Crypto::S256KeyType::Header), Core::Crypto::Mode::XTS);
+        cipher.XTSTranscode(raw.data(), length_sections, sections.data(), 2, SECTION_HEADER_SIZE,
+                            Core::Crypto::Op::Decrypt);
+    } else {
+        file->ReadBytes(sections.data(), length_sections, SECTION_HEADER_OFFSET);
+    }
+
+    for (std::ptrdiff_t i = 0; i < number_sections; ++i) {
+        auto section = sections[i];
+
+        if (section.raw.header.filesystem_type == NCASectionFilesystemType::ROMFS) {
+            const size_t romfs_offset =
+                header.section_tables[i].media_offset * MEDIA_OFFSET_MULTIPLIER +
+                section.romfs.ivfc.levels[IVFC_MAX_LEVEL - 1].offset;
+            const size_t romfs_size = section.romfs.ivfc.levels[IVFC_MAX_LEVEL - 1].size;
+            auto dec =
+                Decrypt(section, std::make_shared<OffsetVfsFile>(file, romfs_size, romfs_offset),
+                        romfs_offset);
+            if (dec != nullptr) {
+                files.push_back(std::move(dec));
+                romfs = files.back();
+            } else {
+                status = Loader::ResultStatus::ErrorMissingKeys;
+                return;
+            }
+        } else if (section.raw.header.filesystem_type == NCASectionFilesystemType::PFS0) {
+            u64 offset = (static_cast<u64>(header.section_tables[i].media_offset) *
+                          MEDIA_OFFSET_MULTIPLIER) +
+                         section.pfs0.pfs0_header_offset;
+            u64 size = MEDIA_OFFSET_MULTIPLIER * (header.section_tables[i].media_end_offset -
+                                                  header.section_tables[i].media_offset);
+            auto dec =
+                Decrypt(section, std::make_shared<OffsetVfsFile>(file, size, offset), offset);
+            if (dec != nullptr) {
+                auto npfs = std::make_shared<PartitionFilesystem>(std::move(dec));
+
+                if (npfs->GetStatus() == Loader::ResultStatus::Success) {
+                    dirs.push_back(std::move(npfs));
+                    if (IsDirectoryExeFS(dirs.back()))
+                        exefs = dirs.back();
+                }
+            } else {
+                status = Loader::ResultStatus::ErrorMissingKeys;
+                return;
+            }
+        }
+    }
+
+    status = Loader::ResultStatus::Success;
+}
+
+Loader::ResultStatus NCA::GetStatus() const {
+    return status;
+}
+
+std::vector<std::shared_ptr<VfsFile>> NCA::GetFiles() const {
+    if (status != Loader::ResultStatus::Success)
+        return {};
+    return files;
+}
+
+std::vector<std::shared_ptr<VfsDirectory>> NCA::GetSubdirectories() const {
+    if (status != Loader::ResultStatus::Success)
+        return {};
+    return dirs;
+}
+
+std::string NCA::GetName() const {
+    return file->GetName();
+}
+
+std::shared_ptr<VfsDirectory> NCA::GetParentDirectory() const {
+    return file->GetContainingDirectory();
+}
+
+NCAContentType NCA::GetType() const {
+    return header.content_type;
+}
+
+u64 NCA::GetTitleId() const {
+    if (status != Loader::ResultStatus::Success)
+        return {};
+    return header.title_id;
+}
+
+VirtualFile NCA::GetRomFS() const {
+    return romfs;
+}
+
+VirtualDir NCA::GetExeFS() const {
+    return exefs;
+}
+
+VirtualFile NCA::GetBaseFile() const {
+    return file;
+}
+
+bool NCA::ReplaceFileWithSubdirectory(VirtualFile file, VirtualDir dir) {
+    return false;
+}
+} // namespace FileSys

src/core/file_sys/content_archive.h

@@ -0,0 +1,117 @@
+// Copyright 2018 yuzu emulator team
+// Licensed under GPLv2 or any later version
+// Refer to the license.txt file included.
+
+#pragma once
+
+#include <array>
+#include <memory>
+#include <string>
+#include <vector>
+#include <boost/optional.hpp>
+#include "common/common_funcs.h"
+#include "common/common_types.h"
+#include "common/swap.h"
+#include "core/crypto/key_manager.h"
+#include "core/file_sys/partition_filesystem.h"
+#include "core/loader/loader.h"
+
+namespace FileSys {
+
+union NCASectionHeader;
+
+enum class NCAContentType : u8 {
+    Program = 0,
+    Meta = 1,
+    Control = 2,
+    Manual = 3,
+    Data = 4,
+};
+
+enum class NCASectionCryptoType : u8 {
+    NONE = 1,
+    XTS = 2,
+    CTR = 3,
+    BKTR = 4,
+};
+
+struct NCASectionTableEntry {
+    u32_le media_offset;
+    u32_le media_end_offset;
+    INSERT_PADDING_BYTES(0x8);
+};
+static_assert(sizeof(NCASectionTableEntry) == 0x10, "NCASectionTableEntry has incorrect size.");
+
+struct NCAHeader {
+    std::array<u8, 0x100> rsa_signature_1;
+    std::array<u8, 0x100> rsa_signature_2;
+    u32_le magic;
+    u8 is_system;
+    NCAContentType content_type;
+    u8 crypto_type;
+    u8 key_index;
+    u64_le size;
+    u64_le title_id;
+    INSERT_PADDING_BYTES(0x4);
+    u32_le sdk_version;
+    u8 crypto_type_2;
+    INSERT_PADDING_BYTES(15);
+    std::array<u8, 0x10> rights_id;
+    std::array<NCASectionTableEntry, 0x4> section_tables;
+    std::array<std::array<u8, 0x20>, 0x4> hash_tables;
+    std::array<u8, 0x40> key_area;
+    INSERT_PADDING_BYTES(0xC0);
+};
+static_assert(sizeof(NCAHeader) == 0x400, "NCAHeader has incorrect size.");
+
+inline bool IsDirectoryExeFS(const std::shared_ptr<VfsDirectory>& pfs) {
+    // According to switchbrew, an exefs must only contain these two files:
+    return pfs->GetFile("main") != nullptr && pfs->GetFile("main.npdm") != nullptr;
+}
+
+bool IsValidNCA(const NCAHeader& header);
+
+// An implementation of VfsDirectory that represents a Nintendo Content Archive (NCA) conatiner.
+// After construction, use GetStatus to determine if the file is valid and ready to be used.
+class NCA : public ReadOnlyVfsDirectory {
+public:
+    explicit NCA(VirtualFile file);
+    Loader::ResultStatus GetStatus() const;
+
+    std::vector<std::shared_ptr<VfsFile>> GetFiles() const override;
+    std::vector<std::shared_ptr<VfsDirectory>> GetSubdirectories() const override;
+    std::string GetName() const override;
+    std::shared_ptr<VfsDirectory> GetParentDirectory() const override;
+
+    NCAContentType GetType() const;
+    u64 GetTitleId() const;
+
+    VirtualFile GetRomFS() const;
+    VirtualDir GetExeFS() const;
+
+    VirtualFile GetBaseFile() const;
+
+protected:
+    bool ReplaceFileWithSubdirectory(VirtualFile file, VirtualDir dir) override;
+
+private:
+    boost::optional<Core::Crypto::Key128> GetKeyAreaKey(NCASectionCryptoType type) const;
+    VirtualFile Decrypt(NCASectionHeader header, VirtualFile in, u64 starting_offset) const;
+
+    std::vector<VirtualDir> dirs;
+    std::vector<VirtualFile> files;
+
+    VirtualFile romfs = nullptr;
+    VirtualDir exefs = nullptr;
+    VirtualFile file;
+
+    NCAHeader header{};
+
+    Loader::ResultStatus status{};
+
+    bool encrypted;
+
+    Core::Crypto::KeyManager keys;
+};
+
+} // namespace FileSys

src/core/file_sys/control_metadata.cpp

@@ -0,0 +1,42 @@
+// Copyright 2018 yuzu emulator team
+// Licensed under GPLv2 or any later version
+// Refer to the license.txt file included.
+
+#include "common/string_util.h"
+#include "common/swap.h"
+#include "core/file_sys/control_metadata.h"
+
+namespace FileSys {
+
+std::string LanguageEntry::GetApplicationName() const {
+    return Common::StringFromFixedZeroTerminatedBuffer(application_name.data(), 0x200);
+}
+
+std::string LanguageEntry::GetDeveloperName() const {
+    return Common::StringFromFixedZeroTerminatedBuffer(developer_name.data(), 0x100);
+}
+
+NACP::NACP(VirtualFile file_) : file(std::move(file_)), raw(std::make_unique<RawNACP>()) {
+    file->ReadObject(raw.get());
+}
+
+const LanguageEntry& NACP::GetLanguageEntry(Language language) const {
+    return raw->language_entries.at(static_cast<u8>(language));
+}
+
+std::string NACP::GetApplicationName(Language language) const {
+    return GetLanguageEntry(language).GetApplicationName();
+}
+
+std::string NACP::GetDeveloperName(Language language) const {
+    return GetLanguageEntry(language).GetDeveloperName();
+}
+
+u64 NACP::GetTitleId() const {
+    return raw->title_id;
+}
+
+std::string NACP::GetVersionString() const {
+    return Common::StringFromFixedZeroTerminatedBuffer(raw->version_string.data(), 0x10);
+}
+} // namespace FileSys

src/core/file_sys/control_metadata.h

@@ -0,0 +1,81 @@
+// Copyright 2018 yuzu emulator team
+// Licensed under GPLv2 or any later version
+// Refer to the license.txt file included.
+
+#pragma once
+
+#include <array>
+#include <memory>
+#include <string>
+#include "common/common_funcs.h"
+#include "core/file_sys/vfs.h"
+
+namespace FileSys {
+
+// A localized entry containing strings within the NACP.
+// One for each language of type Language.
+struct LanguageEntry {
+    std::array<char, 0x200> application_name;
+    std::array<char, 0x100> developer_name;
+
+    std::string GetApplicationName() const;
+    std::string GetDeveloperName() const;
+};
+static_assert(sizeof(LanguageEntry) == 0x300, "LanguageEntry has incorrect size.");
+
+// The raw file format of a NACP file.
+struct RawNACP {
+    std::array<LanguageEntry, 16> language_entries;
+    INSERT_PADDING_BYTES(0x38);
+    u64_le title_id;
+    INSERT_PADDING_BYTES(0x20);
+    std::array<char, 0x10> version_string;
+    u64_le dlc_base_title_id;
+    u64_le title_id_2;
+    INSERT_PADDING_BYTES(0x28);
+    u64_le product_code;
+    u64_le title_id_3;
+    std::array<u64_le, 0x7> title_id_array;
+    INSERT_PADDING_BYTES(0x8);
+    u64_le title_id_update;
+    std::array<u8, 0x40> bcat_passphrase;
+    INSERT_PADDING_BYTES(0xEC0);
+};
+static_assert(sizeof(RawNACP) == 0x4000, "RawNACP has incorrect size.");
+
+// A language on the NX. These are for names and icons.
+enum class Language : u8 {
+    AmericanEnglish = 0,
+    BritishEnglish = 1,
+    Japanese = 2,
+    French = 3,
+    German = 4,
+    LatinAmericanSpanish = 5,
+    Spanish = 6,
+    Italian = 7,
+    Dutch = 8,
+    CanadianFrench = 9,
+    Portugese = 10,
+    Russian = 11,
+    Korean = 12,
+    Taiwanese = 13,
+    Chinese = 14,
+};
+
+// 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 {
+public:
+    explicit NACP(VirtualFile file);
+    const LanguageEntry& GetLanguageEntry(Language language = Language::AmericanEnglish) const;
+    std::string GetApplicationName(Language language = Language::AmericanEnglish) const;
+    std::string GetDeveloperName(Language language = Language::AmericanEnglish) const;
+    u64 GetTitleId() const;
+    std::string GetVersionString() const;
+
+private:
+    VirtualFile file;
+    std::unique_ptr<RawNACP> raw;
+};
+
+} // namespace FileSys

src/core/file_sys/directory.h

@@ -8,13 +8,17 @@
 #include <cstddef>
 #include "common/common_funcs.h"
 #include "common/common_types.h"
-#include "core/file_sys/filesystem.h"
 
 ////////////////////////////////////////////////////////////////////////////////////////////////////
 // FileSys namespace
 
 namespace FileSys {
 
+enum EntryType : u8 {
+    Directory = 0,
+    File = 1,
+};
+
 // Structure of a directory entry, from
 // http://switchbrew.org/index.php?title=Filesystem_services#DirectoryEntry
 const size_t FILENAME_LENGTH = 0x300;

src/core/file_sys/disk_filesystem.cpp

@@ -1,237 +0,0 @@
-// Copyright 2018 yuzu emulator team
-// Licensed under GPLv2 or any later version
-// Refer to the license.txt file included.
-
-#include <cstring>
-#include <memory>
-#include "common/common_types.h"
-#include "common/logging/log.h"
-#include "core/file_sys/disk_filesystem.h"
-#include "core/file_sys/errors.h"
-
-namespace FileSys {
-
-static std::string ModeFlagsToString(Mode mode) {
-    std::string mode_str;
-    u32 mode_flags = static_cast<u32>(mode);
-
-    // Calculate the correct open mode for the file.
-    if ((mode_flags & static_cast<u32>(Mode::Read)) &&
-        (mode_flags & static_cast<u32>(Mode::Write))) {
-        if (mode_flags & static_cast<u32>(Mode::Append))
-            mode_str = "a+";
-        else
-            mode_str = "r+";
-    } else {
-        if (mode_flags & static_cast<u32>(Mode::Read))
-            mode_str = "r";
-        else if (mode_flags & static_cast<u32>(Mode::Append))
-            mode_str = "a";
-        else if (mode_flags & static_cast<u32>(Mode::Write))
-            mode_str = "w";
-    }
-
-    mode_str += "b";
-
-    return mode_str;
-}
-
-std::string Disk_FileSystem::GetName() const {
-    return "Disk";
-}
-
-ResultVal<std::unique_ptr<StorageBackend>> Disk_FileSystem::OpenFile(const std::string& path,
-                                                                     Mode mode) const {
-
-    // Calculate the correct open mode for the file.
-    std::string mode_str = ModeFlagsToString(mode);
-
-    std::string full_path = base_directory + path;
-    auto file = std::make_shared<FileUtil::IOFile>(full_path, mode_str.c_str());
-
-    if (!file->IsOpen()) {
-        return ERROR_PATH_NOT_FOUND;
-    }
-
-    return MakeResult<std::unique_ptr<StorageBackend>>(
-        std::make_unique<Disk_Storage>(std::move(file)));
-}
-
-ResultCode Disk_FileSystem::DeleteFile(const std::string& path) const {
-    if (!FileUtil::Exists(path)) {
-        return ERROR_PATH_NOT_FOUND;
-    }
-
-    FileUtil::Delete(path);
-
-    return RESULT_SUCCESS;
-}
-
-ResultCode Disk_FileSystem::RenameFile(const std::string& src_path,
-                                       const std::string& dest_path) const {
-    const std::string full_src_path = base_directory + src_path;
-    const std::string full_dest_path = base_directory + dest_path;
-
-    if (!FileUtil::Exists(full_src_path)) {
-        return ERROR_PATH_NOT_FOUND;
-    }
-    // TODO(wwylele): Use correct error code
-    return FileUtil::Rename(full_src_path, full_dest_path) ? RESULT_SUCCESS : ResultCode(-1);
-}
-
-ResultCode Disk_FileSystem::DeleteDirectory(const Path& path) const {
-    NGLOG_WARNING(Service_FS, "(STUBBED) called");
-    // TODO(wwylele): Use correct error code
-    return ResultCode(-1);
-}
-
-ResultCode Disk_FileSystem::DeleteDirectoryRecursively(const Path& path) const {
-    NGLOG_WARNING(Service_FS, "(STUBBED) called");
-    // TODO(wwylele): Use correct error code
-    return ResultCode(-1);
-}
-
-ResultCode Disk_FileSystem::CreateFile(const std::string& path, u64 size) const {
-    NGLOG_WARNING(Service_FS, "(STUBBED) called");
-
-    std::string full_path = base_directory + path;
-    if (size == 0) {
-        FileUtil::CreateEmptyFile(full_path);
-        return RESULT_SUCCESS;
-    }
-
-    FileUtil::IOFile file(full_path, "wb");
-    // Creates a sparse file (or a normal file on filesystems without the concept of sparse files)
-    // We do this by seeking to the right size, then writing a single null byte.
-    if (file.Seek(size - 1, SEEK_SET) && file.WriteBytes("", 1) == 1) {
-        return RESULT_SUCCESS;
-    }
-
-    NGLOG_ERROR(Service_FS, "Too large file");
-    // TODO(Subv): Find out the correct error code
-    return ResultCode(-1);
-}
-
-ResultCode Disk_FileSystem::CreateDirectory(const std::string& path) const {
-    // TODO(Subv): Perform path validation to prevent escaping the emulator sandbox.
-    std::string full_path = base_directory + path;
-
-    if (FileUtil::CreateDir(full_path)) {
-        return RESULT_SUCCESS;
-    }
-
-    NGLOG_CRITICAL(Service_FS, "(unreachable) Unknown error creating {}", full_path);
-    // TODO(wwylele): Use correct error code
-    return ResultCode(-1);
-}
-
-ResultCode Disk_FileSystem::RenameDirectory(const Path& src_path, const Path& dest_path) const {
-    NGLOG_WARNING(Service_FS, "(STUBBED) called");
-    // TODO(wwylele): Use correct error code
-    return ResultCode(-1);
-}
-
-ResultVal<std::unique_ptr<DirectoryBackend>> Disk_FileSystem::OpenDirectory(
-    const std::string& path) const {
-
-    std::string full_path = base_directory + path;
-
-    if (!FileUtil::IsDirectory(full_path)) {
-        // TODO(Subv): Find the correct error code for this.
-        return ResultCode(-1);
-    }
-
-    auto directory = std::make_unique<Disk_Directory>(full_path);
-    return MakeResult<std::unique_ptr<DirectoryBackend>>(std::move(directory));
-}
-
-u64 Disk_FileSystem::GetFreeSpaceSize() const {
-    NGLOG_WARNING(Service_FS, "(STUBBED) called");
-    return 0;
-}
-
-ResultVal<FileSys::EntryType> Disk_FileSystem::GetEntryType(const std::string& path) const {
-    std::string full_path = base_directory + path;
-    if (!FileUtil::Exists(full_path)) {
-        return ERROR_PATH_NOT_FOUND;
-    }
-
-    if (FileUtil::IsDirectory(full_path))
-        return MakeResult(EntryType::Directory);
-
-    return MakeResult(EntryType::File);
-}
-
-ResultVal<size_t> Disk_Storage::Read(const u64 offset, const size_t length, u8* buffer) const {
-    NGLOG_TRACE(Service_FS, "called offset={}, length={}", offset, length);
-    file->Seek(offset, SEEK_SET);
-    return MakeResult<size_t>(file->ReadBytes(buffer, length));
-}
-
-ResultVal<size_t> Disk_Storage::Write(const u64 offset, const size_t length, const bool flush,
-                                      const u8* buffer) const {
-    NGLOG_WARNING(Service_FS, "(STUBBED) called");
-    file->Seek(offset, SEEK_SET);
-    size_t written = file->WriteBytes(buffer, length);
-    if (flush) {
-        file->Flush();
-    }
-    return MakeResult<size_t>(written);
-}
-
-u64 Disk_Storage::GetSize() const {
-    return file->GetSize();
-}
-
-bool Disk_Storage::SetSize(const u64 size) const {
-    file->Resize(size);
-    file->Flush();
-    return true;
-}
-
-Disk_Directory::Disk_Directory(const std::string& path) {
-    unsigned size = FileUtil::ScanDirectoryTree(path, directory);
-    directory.size = size;
-    directory.isDirectory = true;
-    children_iterator = directory.children.begin();
-}
-
-u64 Disk_Directory::Read(const u64 count, Entry* entries) {
-    u64 entries_read = 0;
-
-    while (entries_read < count && children_iterator != directory.children.cend()) {
-        const FileUtil::FSTEntry& file = *children_iterator;
-        const std::string& filename = file.virtualName;
-        Entry& entry = entries[entries_read];
-
-        NGLOG_TRACE(Service_FS, "File {}: size={} dir={}", filename, file.size, file.isDirectory);
-
-        // TODO(Link Mauve): use a proper conversion to UTF-16.
-        for (size_t j = 0; j < FILENAME_LENGTH; ++j) {
-            entry.filename[j] = filename[j];
-            if (!filename[j])
-                break;
-        }
-
-        if (file.isDirectory) {
-            entry.file_size = 0;
-            entry.type = EntryType::Directory;
-        } else {
-            entry.file_size = file.size;
-            entry.type = EntryType::File;
-        }
-
-        ++entries_read;
-        ++children_iterator;
-    }
-    return entries_read;
-}
-
-u64 Disk_Directory::GetEntryCount() const {
-    // We convert the children iterator into a const_iterator to allow template argument deduction
-    // in std::distance.
-    std::vector<FileUtil::FSTEntry>::const_iterator current = children_iterator;
-    return std::distance(current, directory.children.end());
-}
-
-} // namespace FileSys

src/core/file_sys/disk_filesystem.h

@@ -1,84 +0,0 @@
-// Copyright 2018 yuzu emulator team
-// Licensed under GPLv2 or any later version
-// Refer to the license.txt file included.
-
-#pragma once
-
-#include <cstddef>
-#include <memory>
-#include <string>
-#include "common/common_types.h"
-#include "common/file_util.h"
-#include "core/file_sys/directory.h"
-#include "core/file_sys/filesystem.h"
-#include "core/file_sys/storage.h"
-#include "core/hle/result.h"
-
-namespace FileSys {
-
-class Disk_FileSystem : public FileSystemBackend {
-public:
-    explicit Disk_FileSystem(std::string base_directory)
-        : base_directory(std::move(base_directory)) {}
-
-    std::string GetName() const override;
-
-    ResultVal<std::unique_ptr<StorageBackend>> OpenFile(const std::string& path,
-                                                        Mode mode) const override;
-    ResultCode DeleteFile(const std::string& path) const override;
-    ResultCode RenameFile(const std::string& src_path, const std::string& dest_path) const override;
-    ResultCode DeleteDirectory(const Path& path) const override;
-    ResultCode DeleteDirectoryRecursively(const Path& path) const override;
-    ResultCode CreateFile(const std::string& path, u64 size) const override;
-    ResultCode CreateDirectory(const std::string& path) const override;
-    ResultCode RenameDirectory(const Path& src_path, const Path& dest_path) const override;
-    ResultVal<std::unique_ptr<DirectoryBackend>> OpenDirectory(
-        const std::string& path) const override;
-    u64 GetFreeSpaceSize() const override;
-    ResultVal<EntryType> GetEntryType(const std::string& path) const override;
-
-protected:
-    std::string base_directory;
-};
-
-class Disk_Storage : public StorageBackend {
-public:
-    explicit Disk_Storage(std::shared_ptr<FileUtil::IOFile> file) : file(std::move(file)) {}
-
-    ResultVal<size_t> Read(u64 offset, size_t length, u8* buffer) const override;
-    ResultVal<size_t> Write(u64 offset, size_t length, bool flush, const u8* buffer) const override;
-    u64 GetSize() const override;
-    bool SetSize(u64 size) const override;
-    bool Close() const override {
-        return false;
-    }
-    void Flush() const override {}
-
-private:
-    std::shared_ptr<FileUtil::IOFile> file;
-};
-
-class Disk_Directory : public DirectoryBackend {
-public:
-    explicit Disk_Directory(const std::string& path);
-
-    ~Disk_Directory() override {
-        Close();
-    }
-
-    u64 Read(const u64 count, Entry* entries) override;
-    u64 GetEntryCount() const override;
-
-    bool Close() const override {
-        return true;
-    }
-
-protected:
-    FileUtil::FSTEntry directory;
-
-    // We need to remember the last entry we returned, so a subsequent call to Read will continue
-    // from the next one. This iterator will always point to the next unread entry.
-    std::vector<FileUtil::FSTEntry>::iterator children_iterator;
-};
-
-} // namespace FileSys

src/core/file_sys/errors.h

@@ -11,19 +11,22 @@ namespace FileSys {
 namespace ErrCodes {
 enum {
     NotFound = 1,
+    TitleNotFound = 1002,
+    SdCardNotFound = 2001,
+    RomFSNotFound = 2520,
 };
 }
 
 constexpr ResultCode ERROR_PATH_NOT_FOUND(ErrorModule::FS, ErrCodes::NotFound);
 
 // TODO(bunnei): Replace these with correct errors for Switch OS
-constexpr ResultCode ERROR_INVALID_PATH(ResultCode(-1));
-constexpr ResultCode ERROR_UNSUPPORTED_OPEN_FLAGS(ResultCode(-1));
-constexpr ResultCode ERROR_INVALID_OPEN_FLAGS(ResultCode(-1));
-constexpr ResultCode ERROR_FILE_NOT_FOUND(ResultCode(-1));
-constexpr ResultCode ERROR_UNEXPECTED_FILE_OR_DIRECTORY(ResultCode(-1));
-constexpr ResultCode ERROR_DIRECTORY_ALREADY_EXISTS(ResultCode(-1));
-constexpr ResultCode ERROR_FILE_ALREADY_EXISTS(ResultCode(-1));
-constexpr ResultCode ERROR_DIRECTORY_NOT_EMPTY(ResultCode(-1));
+constexpr ResultCode ERROR_INVALID_PATH(-1);
+constexpr ResultCode ERROR_UNSUPPORTED_OPEN_FLAGS(-1);
+constexpr ResultCode ERROR_INVALID_OPEN_FLAGS(-1);
+constexpr ResultCode ERROR_FILE_NOT_FOUND(-1);
+constexpr ResultCode ERROR_UNEXPECTED_FILE_OR_DIRECTORY(-1);
+constexpr ResultCode ERROR_DIRECTORY_ALREADY_EXISTS(-1);
+constexpr ResultCode ERROR_FILE_ALREADY_EXISTS(-1);
+constexpr ResultCode ERROR_DIRECTORY_NOT_EMPTY(-1);
 
 } // namespace FileSys

src/core/file_sys/filesystem.cpp

@@ -1,122 +0,0 @@
-// Copyright 2018 yuzu emulator team
-// Licensed under GPLv2 or any later version
-// Refer to the license.txt file included.
-
-#include <cstddef>
-#include <iomanip>
-#include <sstream>
-#include "common/logging/log.h"
-#include "common/string_util.h"
-#include "core/file_sys/filesystem.h"
-#include "core/memory.h"
-
-namespace FileSys {
-
-Path::Path(LowPathType type, u32 size, u32 pointer) : type(type) {
-    switch (type) {
-    case Binary: {
-        binary.resize(size);
-        Memory::ReadBlock(pointer, binary.data(), binary.size());
-        break;
-    }
-
-    case Char: {
-        string.resize(size - 1); // Data is always null-terminated.
-        Memory::ReadBlock(pointer, &string[0], string.size());
-        break;
-    }
-
-    case Wchar: {
-        u16str.resize(size / 2 - 1); // Data is always null-terminated.
-        Memory::ReadBlock(pointer, &u16str[0], u16str.size() * sizeof(char16_t));
-        break;
-    }
-
-    default:
-        break;
-    }
-}
-
-std::string Path::DebugStr() const {
-    switch (GetType()) {
-    case Invalid:
-    default:
-        return "[Invalid]";
-    case Empty:
-        return "[Empty]";
-    case Binary: {
-        std::stringstream res;
-        res << "[Binary: ";
-        for (unsigned byte : binary)
-            res << std::hex << std::setw(2) << std::setfill('0') << byte;
-        res << ']';
-        return res.str();
-    }
-    case Char:
-        return "[Char: " + AsString() + ']';
-    case Wchar:
-        return "[Wchar: " + AsString() + ']';
-    }
-}
-
-std::string Path::AsString() const {
-    switch (GetType()) {
-    case Char:
-        return string;
-    case Wchar:
-        return Common::UTF16ToUTF8(u16str);
-    case Empty:
-        return {};
-    case Invalid:
-    case Binary:
-    default:
-        // TODO(yuriks): Add assert
-        NGLOG_ERROR(Service_FS, "LowPathType cannot be converted to string!");
-        return {};
-    }
-}
-
-std::u16string Path::AsU16Str() const {
-    switch (GetType()) {
-    case Char:
-        return Common::UTF8ToUTF16(string);
-    case Wchar:
-        return u16str;
-    case Empty:
-        return {};
-    case Invalid:
-    case Binary:
-        // TODO(yuriks): Add assert
-        NGLOG_ERROR(Service_FS, "LowPathType cannot be converted to u16string!");
-        return {};
-    }
-
-    UNREACHABLE();
-}
-
-std::vector<u8> Path::AsBinary() const {
-    switch (GetType()) {
-    case Binary:
-        return binary;
-    case Char:
-        return std::vector<u8>(string.begin(), string.end());
-    case Wchar: {
-        // use two u8 for each character of u16str
-        std::vector<u8> to_return(u16str.size() * 2);
-        for (size_t i = 0; i < u16str.size(); ++i) {
-            u16 tmp_char = u16str.at(i);
-            to_return[i * 2] = (tmp_char & 0xFF00) >> 8;
-            to_return[i * 2 + 1] = (tmp_char & 0x00FF);
-        }
-        return to_return;
-    }
-    case Empty:
-        return {};
-    case Invalid:
-    default:
-        // TODO(yuriks): Add assert
-        NGLOG_ERROR(Service_FS, "LowPathType cannot be converted to binary!");
-        return {};
-    }
-}
-} // namespace FileSys

src/core/file_sys/filesystem.h

@@ -1,201 +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>
-#include <utility>
-#include <vector>
-#include "common/bit_field.h"
-#include "common/common_types.h"
-#include "common/swap.h"
-#include "core/hle/result.h"
-
-namespace FileSys {
-
-class StorageBackend;
-class DirectoryBackend;
-
-// Path string type
-enum LowPathType : u32 {
-    Invalid = 0,
-    Empty = 1,
-    Binary = 2,
-    Char = 3,
-    Wchar = 4,
-};
-
-enum EntryType : u8 {
-    Directory = 0,
-    File = 1,
-};
-
-enum class Mode : u32 {
-    Read = 1,
-    Write = 2,
-    Append = 4,
-};
-
-class Path {
-public:
-    Path() : type(Invalid) {}
-    Path(const char* path) : type(Char), string(path) {}
-    Path(std::vector<u8> binary_data) : type(Binary), binary(std::move(binary_data)) {}
-    Path(LowPathType type, u32 size, u32 pointer);
-
-    LowPathType GetType() const {
-        return type;
-    }
-
-    /**
-     * Gets the string representation of the path for debugging
-     * @return String representation of the path for debugging
-     */
-    std::string DebugStr() const;
-
-    std::string AsString() const;
-    std::u16string AsU16Str() const;
-    std::vector<u8> AsBinary() const;
-
-private:
-    LowPathType type;
-    std::vector<u8> binary;
-    std::string string;
-    std::u16string u16str;
-};
-
-/// Parameters of the archive, as specified in the Create or Format call.
-struct ArchiveFormatInfo {
-    u32_le total_size;         ///< The pre-defined size of the archive.
-    u32_le number_directories; ///< The pre-defined number of directories in the archive.
-    u32_le number_files;       ///< The pre-defined number of files in the archive.
-    u8 duplicate_data;         ///< Whether the archive should duplicate the data.
-};
-static_assert(std::is_pod<ArchiveFormatInfo>::value, "ArchiveFormatInfo is not POD");
-
-class FileSystemBackend : NonCopyable {
-public:
-    virtual ~FileSystemBackend() {}
-
-    /**
-     * Get a descriptive name for the archive (e.g. "RomFS", "SaveData", etc.)
-     */
-    virtual std::string GetName() const = 0;
-
-    /**
-     * Create a file specified by its path
-     * @param path Path relative to the Archive
-     * @param size The size of the new file, filled with zeroes
-     * @return Result of the operation
-     */
-    virtual ResultCode CreateFile(const std::string& path, u64 size) const = 0;
-
-    /**
-     * Delete a file specified by its path
-     * @param path Path relative to the archive
-     * @return Result of the operation
-     */
-    virtual ResultCode DeleteFile(const std::string& path) const = 0;
-
-    /**
-     * Create a directory specified by its path
-     * @param path Path relative to the archive
-     * @return Result of the operation
-     */
-    virtual ResultCode CreateDirectory(const std::string& path) const = 0;
-
-    /**
-     * Delete a directory specified by its path
-     * @param path Path relative to the archive
-     * @return Result of the operation
-     */
-    virtual ResultCode DeleteDirectory(const Path& path) const = 0;
-
-    /**
-     * Delete a directory specified by its path and anything under it
-     * @param path Path relative to the archive
-     * @return Result of the operation
-     */
-    virtual ResultCode DeleteDirectoryRecursively(const Path& path) const = 0;
-
-    /**
-     * Rename a File specified by its path
-     * @param src_path Source path relative to the archive
-     * @param dest_path Destination path relative to the archive
-     * @return Result of the operation
-     */
-    virtual ResultCode RenameFile(const std::string& src_path,
-                                  const std::string& dest_path) const = 0;
-
-    /**
-     * Rename a Directory specified by its path
-     * @param src_path Source path relative to the archive
-     * @param dest_path Destination path relative to the archive
-     * @return Result of the operation
-     */
-    virtual ResultCode RenameDirectory(const Path& src_path, const Path& dest_path) const = 0;
-
-    /**
-     * Open a file specified by its path, using the specified mode
-     * @param path Path relative to the archive
-     * @param mode Mode to open the file with
-     * @return Opened file, or error code
-     */
-    virtual ResultVal<std::unique_ptr<StorageBackend>> OpenFile(const std::string& path,
-                                                                Mode mode) const = 0;
-
-    /**
-     * Open a directory specified by its path
-     * @param path Path relative to the archive
-     * @return Opened directory, or error code
-     */
-    virtual ResultVal<std::unique_ptr<DirectoryBackend>> OpenDirectory(
-        const std::string& path) const = 0;
-
-    /**
-     * Get the free space
-     * @return The number of free bytes in the archive
-     */
-    virtual u64 GetFreeSpaceSize() const = 0;
-
-    /**
-     * Get the type of the specified path
-     * @return The type of the specified path or error code
-     */
-    virtual ResultVal<EntryType> GetEntryType(const std::string& path) const = 0;
-};
-
-class FileSystemFactory : NonCopyable {
-public:
-    virtual ~FileSystemFactory() {}
-
-    /**
-     * Get a descriptive name for the archive (e.g. "RomFS", "SaveData", etc.)
-     */
-    virtual std::string GetName() const = 0;
-
-    /**
-     * Tries to open the archive of this type with the specified path
-     * @param path Path to the archive
-     * @return An ArchiveBackend corresponding operating specified archive path.
-     */
-    virtual ResultVal<std::unique_ptr<FileSystemBackend>> Open(const Path& path) = 0;
-
-    /**
-     * Deletes the archive contents and then re-creates the base folder
-     * @param path Path to the archive
-     * @return ResultCode of the operation, 0 on success
-     */
-    virtual ResultCode Format(const Path& path) = 0;
-
-    /**
-     * Retrieves the format info about the archive with the specified path
-     * @param path Path to the archive
-     * @return Format information about the archive or error code
-     */
-    virtual ResultVal<ArchiveFormatInfo> GetFormatInfo(const Path& path) const = 0;
-};
-
-} // namespace FileSys

src/core/file_sys/mode.h

@@ -0,0 +1,23 @@
+// Copyright 2018 yuzu emulator team
+// Licensed under GPLv2 or any later version
+// Refer to the license.txt file included.
+
+#pragma once
+
+#include "common/common_types.h"
+
+namespace FileSys {
+
+enum class Mode : u32 {
+    Read = 1,
+    Write = 2,
+    ReadWrite = 3,
+    Append = 4,
+    WriteAppend = 6,
+};
+
+inline u32 operator&(Mode lhs, Mode rhs) {
+    return static_cast<u32>(lhs) & static_cast<u32>(rhs);
+}
+
+} // namespace FileSys

src/core/file_sys/partition_filesystem.cpp

@@ -2,135 +2,117 @@
 // Licensed under GPLv2 or any later version
 // Refer to the license.txt file included.
 
+#include <algorithm>
+#include <cstddef>
+#include <cstring>
+#include <iterator>
 #include <utility>
+
 #include "common/file_util.h"
 #include "common/logging/log.h"
 #include "core/file_sys/partition_filesystem.h"
+#include "core/file_sys/vfs_offset.h"
 #include "core/loader/loader.h"
 
 namespace FileSys {
 
-Loader::ResultStatus PartitionFilesystem::Load(const std::string& file_path, size_t offset) {
-    FileUtil::IOFile file(file_path, "rb");
-    if (!file.IsOpen())
-        return Loader::ResultStatus::Error;
+bool PartitionFilesystem::Header::HasValidMagicValue() const {
+    return magic == Common::MakeMagic('H', 'F', 'S', '0') ||
+           magic == Common::MakeMagic('P', 'F', 'S', '0');
+}
 
+PartitionFilesystem::PartitionFilesystem(std::shared_ptr<VfsFile> file) {
     // At least be as large as the header
-    if (file.GetSize() < sizeof(Header))
-        return Loader::ResultStatus::Error;
-
-    file.Seek(offset, SEEK_SET);
-    // 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.
-    Header pfs_header;
-    if (!file.ReadBytes(&pfs_header, sizeof(Header)))
-        return Loader::ResultStatus::Error;
-
-    if (pfs_header.magic != Common::MakeMagic('H', 'F', 'S', '0') &&
-        pfs_header.magic != Common::MakeMagic('P', 'F', 'S', '0')) {
-        return Loader::ResultStatus::ErrorInvalidFormat;
+    if (file->GetSize() < sizeof(Header)) {
+        status = Loader::ResultStatus::Error;
+        return;
     }
 
-    bool is_hfs = pfs_header.magic == Common::MakeMagic('H', 'F', 'S', '0');
+    // 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::Error;
+        return;
+    }
+
+    if (!pfs_header.HasValidMagicValue()) {
+        status = Loader::ResultStatus::ErrorInvalidFormat;
+        return;
+    }
+
+    is_hfs = pfs_header.magic == Common::MakeMagic('H', 'F', 'S', '0');
 
     size_t entry_size = is_hfs ? sizeof(HFSEntry) : sizeof(PFSEntry);
     size_t metadata_size =
         sizeof(Header) + (pfs_header.num_entries * entry_size) + pfs_header.strtab_size;
 
     // Actually read in now...
-    file.Seek(offset, SEEK_SET);
-    std::vector<u8> file_data(metadata_size);
+    std::vector<u8> file_data = file->ReadBytes(metadata_size);
+    const size_t total_size = file_data.size();
 
-    if (!file.ReadBytes(file_data.data(), metadata_size))
-        return Loader::ResultStatus::Error;
-
-    Loader::ResultStatus result = Load(file_data);
-    if (result != Loader::ResultStatus::Success)
-        NGLOG_ERROR(Service_FS, "Failed to load PFS from file {}!", file_path);
-
-    return result;
-}
-
-Loader::ResultStatus PartitionFilesystem::Load(const std::vector<u8>& file_data, size_t offset) {
-    size_t total_size = file_data.size() - offset;
-    if (total_size < sizeof(Header))
-        return Loader::ResultStatus::Error;
-
-    memcpy(&pfs_header, &file_data[offset], sizeof(Header));
-    if (pfs_header.magic != Common::MakeMagic('H', 'F', 'S', '0') &&
-        pfs_header.magic != Common::MakeMagic('P', 'F', 'S', '0')) {
-        return Loader::ResultStatus::ErrorInvalidFormat;
+    if (total_size != metadata_size) {
+        status = Loader::ResultStatus::Error;
+        return;
     }
 
-    is_hfs = pfs_header.magic == Common::MakeMagic('H', 'F', 'S', '0');
-
-    size_t entries_offset = offset + sizeof(Header);
-    size_t entry_size = is_hfs ? sizeof(HFSEntry) : sizeof(PFSEntry);
+    size_t entries_offset = sizeof(Header);
     size_t strtab_offset = entries_offset + (pfs_header.num_entries * entry_size);
-    for (u16 i = 0; i < pfs_header.num_entries; i++) {
-        FileEntry entry;
-
-        memcpy(&entry.fs_entry, &file_data[entries_offset + (i * entry_size)], sizeof(FSEntry));
-        entry.name = std::string(reinterpret_cast<const char*>(
-            &file_data[strtab_offset + entry.fs_entry.strtab_offset]));
-        pfs_entries.push_back(std::move(entry));
-    }
-
     content_offset = strtab_offset + pfs_header.strtab_size;
+    for (u16 i = 0; i < pfs_header.num_entries; i++) {
+        FSEntry entry;
 
-    return Loader::ResultStatus::Success;
-}
+        memcpy(&entry, &file_data[entries_offset + (i * entry_size)], sizeof(FSEntry));
+        std::string name(
+            reinterpret_cast<const char*>(&file_data[strtab_offset + entry.strtab_offset]));
 
-u32 PartitionFilesystem::GetNumEntries() const {
-    return pfs_header.num_entries;
-}
-
-u64 PartitionFilesystem::GetEntryOffset(u32 index) const {
-    if (index > GetNumEntries())
-        return 0;
-
-    return content_offset + pfs_entries[index].fs_entry.offset;
-}
-
-u64 PartitionFilesystem::GetEntrySize(u32 index) const {
-    if (index > GetNumEntries())
-        return 0;
-
-    return pfs_entries[index].fs_entry.size;
-}
-
-std::string PartitionFilesystem::GetEntryName(u32 index) const {
-    if (index > GetNumEntries())
-        return "";
-
-    return pfs_entries[index].name;
-}
-
-u64 PartitionFilesystem::GetFileOffset(const std::string& name) const {
-    for (u32 i = 0; i < pfs_header.num_entries; i++) {
-        if (pfs_entries[i].name == name)
-            return content_offset + pfs_entries[i].fs_entry.offset;
+        pfs_files.emplace_back(std::make_shared<OffsetVfsFile>(
+            file, entry.size, content_offset + entry.offset, std::move(name)));
     }
 
-    return 0;
+    status = Loader::ResultStatus::Success;
 }
 
-u64 PartitionFilesystem::GetFileSize(const std::string& name) const {
-    for (u32 i = 0; i < pfs_header.num_entries; i++) {
-        if (pfs_entries[i].name == name)
-            return pfs_entries[i].fs_entry.size;
-    }
-
-    return 0;
+Loader::ResultStatus PartitionFilesystem::GetStatus() const {
+    return status;
 }
 
-void PartitionFilesystem::Print() const {
-    NGLOG_DEBUG(Service_FS, "Magic:                  {}", pfs_header.magic);
-    NGLOG_DEBUG(Service_FS, "Files:                  {}", pfs_header.num_entries);
+std::vector<std::shared_ptr<VfsFile>> PartitionFilesystem::GetFiles() const {
+    return pfs_files;
+}
+
+std::vector<std::shared_ptr<VfsDirectory>> PartitionFilesystem::GetSubdirectories() const {
+    return pfs_dirs;
+}
+
+std::string PartitionFilesystem::GetName() const {
+    return is_hfs ? "HFS0" : "PFS0";
+}
+
+std::shared_ptr<VfsDirectory> PartitionFilesystem::GetParentDirectory() const {
+    // TODO(DarkLordZach): Add support for nested containers.
+    return nullptr;
+}
+
+void PartitionFilesystem::PrintDebugInfo() const {
+    LOG_DEBUG(Service_FS, "Magic:                  {:.4}", pfs_header.magic);
+    LOG_DEBUG(Service_FS, "Files:                  {}", pfs_header.num_entries);
     for (u32 i = 0; i < pfs_header.num_entries; i++) {
-        NGLOG_DEBUG(Service_FS, " > File {}:              {} (0x{:X} bytes, at 0x{:X})", i,
-                    pfs_entries[i].name.c_str(), pfs_entries[i].fs_entry.size,
-                    GetFileOffset(pfs_entries[i].name));
+        LOG_DEBUG(Service_FS, " > File {}:              {} (0x{:X} bytes)", i,
+                  pfs_files[i]->GetName(), pfs_files[i]->GetSize());
     }
 }
+
+bool PartitionFilesystem::ReplaceFileWithSubdirectory(VirtualFile file, VirtualDir dir) {
+    const auto iter = std::find(pfs_files.begin(), pfs_files.end(), file);
+    if (iter == pfs_files.end())
+        return false;
+
+    const std::ptrdiff_t offset = std::distance(pfs_files.begin(), iter);
+    pfs_files[offset] = std::move(pfs_files.back());
+    pfs_files.pop_back();
+
+    pfs_dirs.emplace_back(std::move(dir));
+
+    return true;
+}
 } // namespace FileSys

src/core/file_sys/partition_filesystem.h

@@ -10,6 +10,7 @@
 #include "common/common_funcs.h"
 #include "common/common_types.h"
 #include "common/swap.h"
+#include "core/file_sys/vfs.h"
 
 namespace Loader {
 enum class ResultStatus;
@@ -21,19 +22,19 @@ namespace FileSys {
  * Helper which implements an interface to parse PFS/HFS filesystems.
  * Data can either be loaded from a file path or data with an offset into it.
  */
-class PartitionFilesystem {
+class PartitionFilesystem : public ReadOnlyVfsDirectory {
 public:
-    Loader::ResultStatus Load(const std::string& file_path, size_t offset = 0);
-    Loader::ResultStatus Load(const std::vector<u8>& file_data, size_t offset = 0);
+    explicit PartitionFilesystem(std::shared_ptr<VfsFile> file);
+    Loader::ResultStatus GetStatus() const;
 
-    u32 GetNumEntries() const;
-    u64 GetEntryOffset(u32 index) const;
-    u64 GetEntrySize(u32 index) const;
-    std::string GetEntryName(u32 index) const;
-    u64 GetFileOffset(const std::string& name) const;
-    u64 GetFileSize(const std::string& name) const;
+    std::vector<std::shared_ptr<VfsFile>> GetFiles() const override;
+    std::vector<std::shared_ptr<VfsDirectory>> GetSubdirectories() const override;
+    std::string GetName() const override;
+    std::shared_ptr<VfsDirectory> GetParentDirectory() const override;
+    void PrintDebugInfo() const;
 
-    void Print() const;
+protected:
+    bool ReplaceFileWithSubdirectory(VirtualFile file, VirtualDir dir) override;
 
 private:
     struct Header {
@@ -41,6 +42,8 @@ private:
         u32_le num_entries;
         u32_le strtab_size;
         INSERT_PADDING_BYTES(0x4);
+
+        bool HasValidMagicValue() const;
     };
 
     static_assert(sizeof(Header) == 0x10, "PFS/HFS header structure size is wrong");
@@ -72,16 +75,14 @@ private:
 
 #pragma pack(pop)
 
-    struct FileEntry {
-        FSEntry fs_entry;
-        std::string name;
-    };
+    Loader::ResultStatus status{};
 
-    Header pfs_header;
-    bool is_hfs;
-    size_t content_offset;
+    Header pfs_header{};
+    bool is_hfs = false;
+    size_t content_offset = 0;
 
-    std::vector<FileEntry> pfs_entries;
+    std::vector<VirtualFile> pfs_files;
+    std::vector<VirtualDir> pfs_dirs;
 };
 
 } // namespace FileSys