fixed size calculation error for decode interleaved

unique_ptr doesn't seem to like c structs, so using a void * and casting it to an OpusDecoder

.gitmodules

@@ -7,9 +7,6 @@
 [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
@@ -25,9 +22,6 @@
 [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
+	path = externals/opus
+	url = https://github.com/ogniK5377/opus.git

CMakeLists.txt

@@ -17,8 +17,6 @@ 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

dist/qt_themes/qdarkstyle/LICENSE.md

@@ -1,183 +0,0 @@
-# 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,10 +35,6 @@ 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)
@@ -58,9 +54,3 @@ 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()

src/audio_core/CMakeLists.txt

@@ -1,27 +1,11 @@
 add_library(audio_core STATIC
     audio_out.cpp
     audio_out.h
-    audio_renderer.cpp
-    audio_renderer.h
     buffer.h
-    cubeb_sink.cpp
-    cubeb_sink.h
-    codec.cpp
-    codec.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

@@ -3,16 +3,13 @@
 // 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) {
+static Stream::Format ChannelsToStreamFormat(int num_channels) {
     switch (num_channels) {
     case 1:
         return Stream::Format::Mono16;
@@ -27,19 +24,14 @@ static Stream::Format ChannelsToStreamFormat(u32 num_channels) {
     return {};
 }
 
-StreamPtr AudioOut::OpenStream(u32 sample_rate, u32 num_channels, std::string&& name,
+StreamPtr AudioOut::OpenStream(int sample_rate, int 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, name), std::move(name));
+    streams.push_back(std::make_shared<Stream>(sample_rate, ChannelsToStreamFormat(num_channels),
+                                               std::move(release_callback)));
+    return streams.back();
 }
 
-std::vector<Buffer::Tag> AudioOut::GetTagsAndReleaseBuffers(StreamPtr stream, size_t max_count) {
+std::vector<u64> AudioOut::GetTagsAndReleaseBuffers(StreamPtr stream, size_t max_count) {
     return stream->GetTagsAndReleaseBuffers(max_count);
 }
 
@@ -51,7 +43,7 @@ void AudioOut::StopStream(StreamPtr stream) {
     stream->Stop();
 }
 
-bool AudioOut::QueueBuffer(StreamPtr stream, Buffer::Tag tag, std::vector<s16>&& data) {
+bool AudioOut::QueueBuffer(StreamPtr stream, Buffer::Tag tag, std::vector<u8>&& data) {
     return stream->QueueBuffer(std::make_shared<Buffer>(tag, std::move(data)));
 }
 

src/audio_core/audio_out.h

@@ -5,27 +5,27 @@
 #pragma once
 
 #include <memory>
-#include <string>
 #include <vector>
 
 #include "audio_core/buffer.h"
-#include "audio_core/sink.h"
 #include "audio_core/stream.h"
 #include "common/common_types.h"
 
 namespace AudioCore {
 
+using StreamPtr = std::shared_ptr<Stream>;
+
 /**
  * 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, std::string&& name,
+    StreamPtr OpenStream(int sample_rate, int 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);
+    std::vector<u64> GetTagsAndReleaseBuffers(StreamPtr stream, size_t max_count);
 
     /// Starts an audio stream for playback
     void StartStream(StreamPtr stream);
@@ -34,10 +34,11 @@ public:
     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<s16>&& data);
+    bool QueueBuffer(StreamPtr stream, Buffer::Tag tag, std::vector<u8>&& data);
 
 private:
-    SinkPtr sink;
+    /// Active audio streams on the interface
+    std::vector<StreamPtr> streams;
 };
 
 } // namespace AudioCore

src/audio_core/audio_renderer.cpp

@@ -1,234 +0,0 @@
-// Copyright 2018 yuzu Emulator Project
-// Licensed under GPLv2 or any later version
-// Refer to the license.txt file included.
-
-#include "audio_core/audio_renderer.h"
-#include "common/assert.h"
-#include "common/logging/log.h"
-#include "core/memory.h"
-
-namespace AudioCore {
-
-constexpr u32 STREAM_SAMPLE_RATE{48000};
-constexpr u32 STREAM_NUM_CHANNELS{2};
-
-AudioRenderer::AudioRenderer(AudioRendererParameter params,
-                             Kernel::SharedPtr<Kernel::Event> buffer_event)
-    : worker_params{params}, buffer_event{buffer_event}, voices(params.voice_count) {
-
-    audio_core = std::make_unique<AudioCore::AudioOut>();
-    stream = audio_core->OpenStream(STREAM_SAMPLE_RATE, STREAM_NUM_CHANNELS, "AudioRenderer",
-                                    [=]() { buffer_event->Signal(); });
-    audio_core->StartStream(stream);
-
-    QueueMixedBuffer(0);
-    QueueMixedBuffer(1);
-    QueueMixedBuffer(2);
-}
-
-std::vector<u8> AudioRenderer::UpdateAudioRenderer(const std::vector<u8>& input_params) {
-    // Copy UpdateDataHeader struct
-    UpdateDataHeader config{};
-    std::memcpy(&config, input_params.data(), sizeof(UpdateDataHeader));
-    u32 memory_pool_count = worker_params.effect_count + (worker_params.voice_count * 4);
-
-    // Copy MemoryPoolInfo structs
-    std::vector<MemoryPoolInfo> mem_pool_info(memory_pool_count);
-    std::memcpy(mem_pool_info.data(),
-                input_params.data() + sizeof(UpdateDataHeader) + config.behavior_size,
-                memory_pool_count * sizeof(MemoryPoolInfo));
-
-    // Copy VoiceInfo structs
-    size_t offset{sizeof(UpdateDataHeader) + config.behavior_size + config.memory_pools_size +
-                  config.voice_resource_size};
-    for (auto& voice : voices) {
-        std::memcpy(&voice.Info(), input_params.data() + offset, sizeof(VoiceInfo));
-        offset += sizeof(VoiceInfo);
-    }
-
-    // Update voices
-    for (auto& voice : voices) {
-        voice.UpdateState();
-        if (!voice.GetInfo().is_in_use) {
-            continue;
-        }
-        if (voice.GetInfo().is_new) {
-            voice.SetWaveIndex(voice.GetInfo().wave_buffer_head);
-        }
-    }
-
-    // Update memory pool state
-    std::vector<MemoryPoolEntry> memory_pool(memory_pool_count);
-    for (size_t index = 0; index < memory_pool.size(); ++index) {
-        if (mem_pool_info[index].pool_state == MemoryPoolStates::RequestAttach) {
-            memory_pool[index].state = MemoryPoolStates::Attached;
-        } else if (mem_pool_info[index].pool_state == MemoryPoolStates::RequestDetach) {
-            memory_pool[index].state = MemoryPoolStates::Detached;
-        }
-    }
-
-    // Release previous buffers and queue next ones for playback
-    ReleaseAndQueueBuffers();
-
-    // Copy output header
-    UpdateDataHeader response_data{worker_params};
-    std::vector<u8> output_params(response_data.total_size);
-    std::memcpy(output_params.data(), &response_data, sizeof(UpdateDataHeader));
-
-    // Copy output memory pool entries
-    std::memcpy(output_params.data() + sizeof(UpdateDataHeader), memory_pool.data(),
-                response_data.memory_pools_size);
-
-    // Copy output voice status
-    size_t voice_out_status_offset{sizeof(UpdateDataHeader) + response_data.memory_pools_size};
-    for (const auto& voice : voices) {
-        std::memcpy(output_params.data() + voice_out_status_offset, &voice.GetOutStatus(),
-                    sizeof(VoiceOutStatus));
-        voice_out_status_offset += sizeof(VoiceOutStatus);
-    }
-
-    return output_params;
-}
-
-void AudioRenderer::VoiceState::SetWaveIndex(size_t index) {
-    wave_index = index & 3;
-    is_refresh_pending = true;
-}
-
-std::vector<s16> AudioRenderer::VoiceState::DequeueSamples(size_t sample_count) {
-    if (!IsPlaying()) {
-        return {};
-    }
-
-    if (is_refresh_pending) {
-        RefreshBuffer();
-    }
-
-    const size_t max_size{samples.size() - offset};
-    const size_t dequeue_offset{offset};
-    size_t size{sample_count * STREAM_NUM_CHANNELS};
-    if (size > max_size) {
-        size = max_size;
-    }
-
-    out_status.played_sample_count += size / STREAM_NUM_CHANNELS;
-    offset += size;
-
-    const auto& wave_buffer{info.wave_buffer[wave_index]};
-    if (offset == samples.size()) {
-        offset = 0;
-
-        if (!wave_buffer.is_looping) {
-            SetWaveIndex(wave_index + 1);
-        }
-
-        out_status.wave_buffer_consumed++;
-
-        if (wave_buffer.end_of_stream) {
-            info.play_state = PlayState::Paused;
-        }
-    }
-
-    return {samples.begin() + dequeue_offset, samples.begin() + dequeue_offset + size};
-}
-
-void AudioRenderer::VoiceState::UpdateState() {
-    if (is_in_use && !info.is_in_use) {
-        // No longer in use, reset state
-        is_refresh_pending = true;
-        wave_index = 0;
-        offset = 0;
-        out_status = {};
-    }
-    is_in_use = info.is_in_use;
-}
-
-void AudioRenderer::VoiceState::RefreshBuffer() {
-    std::vector<s16> new_samples(info.wave_buffer[wave_index].buffer_sz / sizeof(s16));
-    Memory::ReadBlock(info.wave_buffer[wave_index].buffer_addr, new_samples.data(),
-                      info.wave_buffer[wave_index].buffer_sz);
-
-    switch (static_cast<Codec::PcmFormat>(info.sample_format)) {
-    case Codec::PcmFormat::Int16: {
-        // PCM16 is played as-is
-        break;
-    }
-    case Codec::PcmFormat::Adpcm: {
-        // Decode ADPCM to PCM16
-        Codec::ADPCM_Coeff coeffs;
-        Memory::ReadBlock(info.additional_params_addr, coeffs.data(), sizeof(Codec::ADPCM_Coeff));
-        new_samples = Codec::DecodeADPCM(reinterpret_cast<u8*>(new_samples.data()),
-                                         new_samples.size() * sizeof(s16), coeffs, adpcm_state);
-        break;
-    }
-    default:
-        LOG_CRITICAL(Audio, "Unimplemented sample_format={}", info.sample_format);
-        UNREACHABLE();
-        break;
-    }
-
-    switch (info.channel_count) {
-    case 1:
-        // 1 channel is upsampled to 2 channel
-        samples.resize(new_samples.size() * 2);
-        for (size_t index = 0; index < new_samples.size(); ++index) {
-            samples[index * 2] = new_samples[index];
-            samples[index * 2 + 1] = new_samples[index];
-        }
-        break;
-    case 2: {
-        // 2 channel is played as is
-        samples = std::move(new_samples);
-        break;
-    }
-    default:
-        LOG_CRITICAL(Audio, "Unimplemented channel_count={}", info.channel_count);
-        UNREACHABLE();
-        break;
-    }
-
-    is_refresh_pending = false;
-}
-
-static constexpr s16 ClampToS16(s32 value) {
-    return static_cast<s16>(std::clamp(value, -32768, 32767));
-}
-
-void AudioRenderer::QueueMixedBuffer(Buffer::Tag tag) {
-    constexpr size_t BUFFER_SIZE{512};
-    std::vector<s16> buffer(BUFFER_SIZE * stream->GetNumChannels());
-
-    for (auto& voice : voices) {
-        if (!voice.IsPlaying()) {
-            continue;
-        }
-
-        size_t offset{};
-        s64 samples_remaining{BUFFER_SIZE};
-        while (samples_remaining > 0) {
-            const std::vector<s16> samples{voice.DequeueSamples(samples_remaining)};
-
-            if (samples.empty()) {
-                break;
-            }
-
-            samples_remaining -= samples.size();
-
-            for (const auto& sample : samples) {
-                const s32 buffer_sample{buffer[offset]};
-                buffer[offset++] =
-                    ClampToS16(buffer_sample + static_cast<s32>(sample * voice.GetInfo().volume));
-            }
-        }
-    }
-    audio_core->QueueBuffer(stream, tag, std::move(buffer));
-}
-
-void AudioRenderer::ReleaseAndQueueBuffers() {
-    const auto released_buffers{audio_core->GetTagsAndReleaseBuffers(stream, 2)};
-    for (const auto& tag : released_buffers) {
-        QueueMixedBuffer(tag);
-    }
-}
-
-} // namespace AudioCore

src/audio_core/audio_renderer.h

@@ -1,206 +0,0 @@
-// Copyright 2018 yuzu Emulator Project
-// Licensed under GPLv2 or any later version
-// Refer to the license.txt file included.
-
-#pragma once
-
-#include <array>
-#include <memory>
-#include <vector>
-
-#include "audio_core/audio_out.h"
-#include "audio_core/codec.h"
-#include "audio_core/stream.h"
-#include "common/common_types.h"
-#include "common/swap.h"
-#include "core/hle/kernel/event.h"
-
-namespace AudioCore {
-
-enum class PlayState : u8 {
-    Started = 0,
-    Stopped = 1,
-    Paused = 2,
-};
-
-struct AudioRendererParameter {
-    u32_le sample_rate;
-    u32_le sample_count;
-    u32_le unknown_8;
-    u32_le unknown_c;
-    u32_le voice_count;
-    u32_le sink_count;
-    u32_le effect_count;
-    u32_le unknown_1c;
-    u8 unknown_20;
-    INSERT_PADDING_BYTES(3);
-    u32_le splitter_count;
-    u32_le unknown_2c;
-    INSERT_PADDING_WORDS(1);
-    u32_le revision;
-};
-static_assert(sizeof(AudioRendererParameter) == 52, "AudioRendererParameter is an invalid size");
-
-enum class MemoryPoolStates : u32 { // Should be LE
-    Invalid = 0x0,
-    Unknown = 0x1,
-    RequestDetach = 0x2,
-    Detached = 0x3,
-    RequestAttach = 0x4,
-    Attached = 0x5,
-    Released = 0x6,
-};
-
-struct MemoryPoolEntry {
-    MemoryPoolStates state;
-    u32_le unknown_4;
-    u32_le unknown_8;
-    u32_le unknown_c;
-};
-static_assert(sizeof(MemoryPoolEntry) == 0x10, "MemoryPoolEntry has wrong size");
-
-struct MemoryPoolInfo {
-    u64_le pool_address;
-    u64_le pool_size;
-    MemoryPoolStates pool_state;
-    INSERT_PADDING_WORDS(3); // Unknown
-};
-static_assert(sizeof(MemoryPoolInfo) == 0x20, "MemoryPoolInfo has wrong size");
-struct BiquadFilter {
-    u8 enable;
-    INSERT_PADDING_BYTES(1);
-    std::array<s16_le, 3> numerator;
-    std::array<s16_le, 2> denominator;
-};
-static_assert(sizeof(BiquadFilter) == 0xc, "BiquadFilter has wrong size");
-
-struct WaveBuffer {
-    u64_le buffer_addr;
-    u64_le buffer_sz;
-    s32_le start_sample_offset;
-    s32_le end_sample_offset;
-    u8 is_looping;
-    u8 end_of_stream;
-    u8 sent_to_server;
-    INSERT_PADDING_BYTES(5);
-    u64 context_addr;
-    u64 context_sz;
-    INSERT_PADDING_BYTES(8);
-};
-static_assert(sizeof(WaveBuffer) == 0x38, "WaveBuffer has wrong size");
-
-struct VoiceInfo {
-    u32_le id;
-    u32_le node_id;
-    u8 is_new;
-    u8 is_in_use;
-    PlayState play_state;
-    u8 sample_format;
-    u32_le sample_rate;
-    u32_le priority;
-    u32_le sorting_order;
-    u32_le channel_count;
-    float_le pitch;
-    float_le volume;
-    std::array<BiquadFilter, 2> biquad_filter;
-    u32_le wave_buffer_count;
-    u32_le wave_buffer_head;
-    INSERT_PADDING_WORDS(1);
-    u64_le additional_params_addr;
-    u64_le additional_params_sz;
-    u32_le mix_id;
-    u32_le splitter_info_id;
-    std::array<WaveBuffer, 4> wave_buffer;
-    std::array<u32_le, 6> voice_channel_resource_ids;
-    INSERT_PADDING_BYTES(24);
-};
-static_assert(sizeof(VoiceInfo) == 0x170, "VoiceInfo is wrong size");
-
-struct VoiceOutStatus {
-    u64_le played_sample_count;
-    u32_le wave_buffer_consumed;
-    u32_le voice_drops_count;
-};
-static_assert(sizeof(VoiceOutStatus) == 0x10, "VoiceOutStatus has wrong size");
-
-struct UpdateDataHeader {
-    UpdateDataHeader() {}
-
-    explicit UpdateDataHeader(const AudioRendererParameter& config) {
-        revision = Common::MakeMagic('R', 'E', 'V', '4'); // 5.1.0 Revision
-        behavior_size = 0xb0;
-        memory_pools_size = (config.effect_count + (config.voice_count * 4)) * 0x10;
-        voices_size = config.voice_count * 0x10;
-        voice_resource_size = 0x0;
-        effects_size = config.effect_count * 0x10;
-        mixes_size = 0x0;
-        sinks_size = config.sink_count * 0x20;
-        performance_manager_size = 0x10;
-        total_size = sizeof(UpdateDataHeader) + behavior_size + memory_pools_size + voices_size +
-                     effects_size + sinks_size + performance_manager_size;
-    }
-
-    u32_le revision;
-    u32_le behavior_size;
-    u32_le memory_pools_size;
-    u32_le voices_size;
-    u32_le voice_resource_size;
-    u32_le effects_size;
-    u32_le mixes_size;
-    u32_le sinks_size;
-    u32_le performance_manager_size;
-    INSERT_PADDING_WORDS(6);
-    u32_le total_size;
-};
-static_assert(sizeof(UpdateDataHeader) == 0x40, "UpdateDataHeader has wrong size");
-
-class AudioRenderer {
-public:
-    AudioRenderer(AudioRendererParameter params, Kernel::SharedPtr<Kernel::Event> buffer_event);
-    std::vector<u8> UpdateAudioRenderer(const std::vector<u8>& input_params);
-    void QueueMixedBuffer(Buffer::Tag tag);
-    void ReleaseAndQueueBuffers();
-
-private:
-    class VoiceState {
-    public:
-        bool IsPlaying() const {
-            return is_in_use && info.play_state == PlayState::Started;
-        }
-
-        const VoiceOutStatus& GetOutStatus() const {
-            return out_status;
-        }
-
-        const VoiceInfo& GetInfo() const {
-            return info;
-        }
-
-        VoiceInfo& Info() {
-            return info;
-        }
-
-        void SetWaveIndex(size_t index);
-        std::vector<s16> DequeueSamples(size_t sample_count);
-        void UpdateState();
-        void RefreshBuffer();
-
-    private:
-        bool is_in_use{};
-        bool is_refresh_pending{};
-        size_t wave_index{};
-        size_t offset{};
-        Codec::ADPCMState adpcm_state{};
-        std::vector<s16> samples;
-        VoiceOutStatus out_status{};
-        VoiceInfo info{};
-    };
-
-    AudioRendererParameter worker_params;
-    Kernel::SharedPtr<Kernel::Event> buffer_event;
-    std::vector<VoiceState> voices;
-    std::unique_ptr<AudioCore::AudioOut> audio_core;
-    AudioCore::StreamPtr stream;
-};
-
-} // namespace AudioCore

src/audio_core/buffer.h

@@ -4,7 +4,6 @@
 
 #pragma once
 
-#include <memory>
 #include <vector>
 
 #include "common/common_types.h"
@@ -18,16 +17,11 @@ class Buffer {
 public:
     using Tag = u64;
 
-    Buffer(Tag tag, std::vector<s16>&& samples) : tag{tag}, samples{std::move(samples)} {}
+    Buffer(Tag tag, std::vector<u8>&& data) : tag{tag}, data{std::move(data)} {}
 
     /// Returns the raw audio data for the buffer
-    std::vector<s16>& Samples() {
-        return samples;
-    }
-
-    /// Returns the raw audio data for the buffer
-    const std::vector<s16>& GetSamples() const {
-        return samples;
+    const std::vector<u8>& GetData() const {
+        return data;
     }
 
     /// Returns the buffer tag, this is provided by the game to the audout service
@@ -37,9 +31,7 @@ public:
 
 private:
     Tag tag;
-    std::vector<s16> samples;
+    std::vector<u8> data;
 };
 
-using BufferPtr = std::shared_ptr<Buffer>;
-
 } // namespace AudioCore

src/audio_core/codec.cpp

@@ -1,77 +0,0 @@
-// Copyright 2018 yuzu Emulator Project
-// Licensed under GPLv2 or any later version
-// Refer to the license.txt file included.
-
-#include <algorithm>
-
-#include "audio_core/codec.h"
-
-namespace AudioCore::Codec {
-
-std::vector<s16> DecodeADPCM(const u8* const data, size_t size, const ADPCM_Coeff& coeff,
-                             ADPCMState& state) {
-    // GC-ADPCM with scale factor and variable coefficients.
-    // Frames are 8 bytes long containing 14 samples each.
-    // Samples are 4 bits (one nibble) long.
-
-    constexpr size_t FRAME_LEN = 8;
-    constexpr size_t SAMPLES_PER_FRAME = 14;
-    constexpr std::array<int, 16> SIGNED_NIBBLES = {
-        {0, 1, 2, 3, 4, 5, 6, 7, -8, -7, -6, -5, -4, -3, -2, -1}};
-
-    const size_t sample_count = (size / FRAME_LEN) * SAMPLES_PER_FRAME;
-    const size_t ret_size =
-        sample_count % 2 == 0 ? sample_count : sample_count + 1; // Ensure multiple of two.
-    std::vector<s16> ret(ret_size);
-
-    int yn1 = state.yn1, yn2 = state.yn2;
-
-    const size_t NUM_FRAMES =
-        (sample_count + (SAMPLES_PER_FRAME - 1)) / SAMPLES_PER_FRAME; // Round up.
-    for (size_t framei = 0; framei < NUM_FRAMES; framei++) {
-        const int frame_header = data[framei * FRAME_LEN];
-        const int scale = 1 << (frame_header & 0xF);
-        const int idx = (frame_header >> 4) & 0x7;
-
-        // Coefficients are fixed point with 11 bits fractional part.
-        const int coef1 = coeff[idx * 2 + 0];
-        const int coef2 = coeff[idx * 2 + 1];
-
-        // Decodes an audio sample. One nibble produces one sample.
-        const auto decode_sample = [&](const int nibble) -> s16 {
-            const int xn = nibble * scale;
-            // We first transform everything into 11 bit fixed point, perform the second order
-            // digital filter, then transform back.
-            // 0x400 == 0.5 in 11 bit fixed point.
-            // Filter: y[n] = x[n] + 0.5 + c1 * y[n-1] + c2 * y[n-2]
-            int val = ((xn << 11) + 0x400 + coef1 * yn1 + coef2 * yn2) >> 11;
-            // Clamp to output range.
-            val = std::clamp<s32>(val, -32768, 32767);
-            // Advance output feedback.
-            yn2 = yn1;
-            yn1 = val;
-            return static_cast<s16>(val);
-        };
-
-        size_t outputi = framei * SAMPLES_PER_FRAME;
-        size_t datai = framei * FRAME_LEN + 1;
-        for (size_t i = 0; i < SAMPLES_PER_FRAME && outputi < sample_count; i += 2) {
-            const s16 sample1 = decode_sample(SIGNED_NIBBLES[data[datai] >> 4]);
-            ret[outputi] = sample1;
-            outputi++;
-
-            const s16 sample2 = decode_sample(SIGNED_NIBBLES[data[datai] & 0xF]);
-            ret[outputi] = sample2;
-            outputi++;
-
-            datai++;
-        }
-    }
-
-    state.yn1 = yn1;
-    state.yn2 = yn2;
-
-    return ret;
-}
-
-} // namespace AudioCore::Codec

src/audio_core/codec.h

@@ -1,44 +0,0 @@
-// Copyright 2018 yuzu Emulator Project
-// Licensed under GPLv2 or any later version
-// Refer to the license.txt file included.
-
-#pragma once
-
-#include <array>
-#include <vector>
-
-#include "common/common_types.h"
-
-namespace AudioCore::Codec {
-
-enum class PcmFormat : u32 {
-    Invalid = 0,
-    Int8 = 1,
-    Int16 = 2,
-    Int24 = 3,
-    Int32 = 4,
-    PcmFloat = 5,
-    Adpcm = 6,
-};
-
-/// See: Codec::DecodeADPCM
-struct ADPCMState {
-    // Two historical samples from previous processed buffer,
-    // required for ADPCM decoding
-    s16 yn1; ///< y[n-1]
-    s16 yn2; ///< y[n-2]
-};
-
-using ADPCM_Coeff = std::array<s16, 16>;
-
-/**
- * @param data Pointer to buffer that contains ADPCM data to decode
- * @param size Size of buffer in bytes
- * @param coeff ADPCM coefficients
- * @param state ADPCM state, this is updated with new state
- * @return Decoded stereo signed PCM16 data, sample_count in length
- */
-std::vector<s16> DecodeADPCM(const u8* const data, size_t size, const ADPCM_Coeff& coeff,
-                             ADPCMState& state);
-
-}; // namespace AudioCore::Codec

src/audio_core/cubeb_sink.cpp

@@ -1,200 +0,0 @@
-// 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, u32 sample_rate, u32 num_channels_, cubeb_devid output_device,
-                   const std::string& name)
-        : ctx{ctx}, num_channels{num_channels_} {
-
-        if (num_channels == 6) {
-            // 6-channel audio does not seem to work with cubeb + SDL, so we downsample this to 2
-            // channel for now
-            is_6_channel = true;
-            num_channels = 2;
-        }
-
-        cubeb_stream_params params{};
-        params.rate = sample_rate;
-        params.channels = num_channels;
-        params.format = CUBEB_SAMPLE_S16NE;
-        params.layout = num_channels == 1 ? CUBEB_LAYOUT_MONO : CUBEB_LAYOUT_STEREO;
-
-        u32 minimum_latency{};
-        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, name.c_str(), 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 std::vector<s16>& samples) override {
-        if (!ctx) {
-            return;
-        }
-
-        queue.reserve(queue.size() + samples.size() * GetNumChannels());
-
-        if (is_6_channel) {
-            // Downsample 6 channels to 2
-            const size_t sample_count_copy_size = samples.size() * 2;
-            queue.reserve(sample_count_copy_size);
-            for (size_t i = 0; i < samples.size(); i += num_channels) {
-                queue.push_back(samples[i]);
-                queue.push_back(samples[i + 1]);
-            }
-        } else {
-            // Copy as-is
-            std::copy(samples.begin(), samples.end(), std::back_inserter(queue));
-        }
-    }
-
-    u32 GetNumChannels() const {
-        return num_channels;
-    }
-
-private:
-    std::vector<std::string> device_list;
-
-    cubeb* ctx{};
-    cubeb_stream* stream_backend{};
-    u32 num_channels{};
-    bool is_6_channel{};
-
-    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,
-                                         const std::string& name) {
-    sink_streams.push_back(
-        std::make_unique<SinkStreamImpl>(ctx, sample_rate, num_channels, output_device, name));
-    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

@@ -1,32 +0,0 @@
-// 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,
-                                  const std::string& name) 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

@@ -1,27 +0,0 @@
-// 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*/,
-                                  const std::string& /*name*/) override {
-        return null_sink_stream;
-    }
-
-private:
-    struct NullSinkStreamImpl final : SinkStream {
-        void EnqueueSamples(u32 /*num_channels*/, const std::vector<s16>& /*samples*/) override {}
-    } null_sink_stream;
-};
-
-} // namespace AudioCore

src/audio_core/sink.h

@@ -1,31 +0,0 @@
-// Copyright 2018 yuzu Emulator Project
-// Licensed under GPLv2 or any later version
-// Refer to the license.txt file included.
-
-#pragma once
-
-#include <memory>
-#include <string>
-
-#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,
-                                          const std::string& name) = 0;
-};
-
-using SinkPtr = std::unique_ptr<Sink>;
-
-} // namespace AudioCore

src/audio_core/sink_details.cpp

@@ -1,44 +0,0 @@
-// 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

@@ -1,35 +0,0 @@
-// 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

@@ -1,32 +0,0 @@
-// 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 {
-
-/**
- * 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.
-     */
-    virtual void EnqueueSamples(u32 num_channels, const std::vector<s16>& samples) = 0;
-};
-
-using SinkStreamPtr = std::unique_ptr<SinkStream>;
-
-} // namespace AudioCore

src/audio_core/stream.cpp

@@ -2,43 +2,37 @@
 // 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"
+
+#include "audio_core/stream.h"
 
 namespace AudioCore {
 
 constexpr size_t MaxAudioBufferCount{32};
 
-u32 Stream::GetNumChannels() const {
+/// Returns the sample size for the specified audio stream format
+static size_t SampleSizeFromFormat(Stream::Format format) {
     switch (format) {
-    case Format::Mono16:
-        return 1;
-    case Format::Stereo16:
+    case Stream::Format::Mono16:
         return 2;
-    case Format::Multi51Channel16:
-        return 6;
-    }
+    case Stream::Format::Stereo16:
+        return 4;
+    case Stream::Format::Multi51Channel16:
+        return 12;
+    };
+
     LOG_CRITICAL(Audio, "Unimplemented format={}", static_cast<u32>(format));
     UNREACHABLE();
     return {};
 }
 
-Stream::Stream(u32 sample_rate, Format format, ReleaseCallback&& release_callback,
-               SinkStream& sink_stream, std::string&& name_)
-    : sample_rate{sample_rate}, format{format}, release_callback{std::move(release_callback)},
-      sink_stream{sink_stream}, name{std::move(name_)} {
-
+Stream::Stream(int sample_rate, Format format, ReleaseCallback&& release_callback)
+    : sample_rate{sample_rate}, format{format}, release_callback{std::move(release_callback)} {
     release_event = CoreTiming::RegisterEvent(
-        name, [this](u64 userdata, int cycles_late) { ReleaseActiveBuffer(); });
+        "Stream::Release", [this](u64 userdata, int cycles_late) { ReleaseActiveBuffer(); });
 }
 
 void Stream::Play() {
@@ -51,24 +45,10 @@ void Stream::Stop() {
 }
 
 s64 Stream::GetBufferReleaseCycles(const Buffer& buffer) const {
-    const size_t num_samples{buffer.GetSamples().size() / GetNumChannels()};
+    const size_t num_samples{buffer.GetData().size() / SampleSizeFromFormat(format)};
     return CoreTiming::usToCycles((static_cast<u64>(num_samples) * 1000000) / sample_rate);
 }
 
-static void VolumeAdjustSamples(std::vector<s16>& samples) {
-    const float volume{std::clamp(Settings::values.volume, 0.0f, 1.0f)};
-
-    if (volume == 1.0f) {
-        return;
-    }
-
-    // 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);
-    }
-}
-
 void Stream::PlayNextBuffer() {
     if (!IsPlaying()) {
         // Ensure we are in playing state before playing the next buffer
@@ -88,14 +68,10 @@ void Stream::PlayNextBuffer() {
     active_buffer = queued_buffers.front();
     queued_buffers.pop();
 
-    VolumeAdjustSamples(active_buffer->Samples());
-    sink_stream.EnqueueSamples(GetNumChannels(), active_buffer->GetSamples());
-
     CoreTiming::ScheduleEventThreadsafe(GetBufferReleaseCycles(*active_buffer), release_event, {});
 }
 
 void Stream::ReleaseActiveBuffer() {
-    ASSERT(active_buffer);
     released_buffers.push(std::move(active_buffer));
     release_callback();
     PlayNextBuffer();

src/audio_core/stream.h

@@ -6,18 +6,18 @@
 
 #include <functional>
 #include <memory>
-#include <string>
 #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 {
 
+using BufferPtr = std::shared_ptr<Buffer>;
+
 /**
  * Represents an audio stream, which is a sequence of queued buffers, to be outputed by AudioOut
  */
@@ -33,8 +33,7 @@ public:
     /// 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, std::string&& name_);
+    Stream(int sample_rate, Format format, ReleaseCallback&& release_callback);
 
     /// Plays the audio stream
     void Play();
@@ -61,14 +60,6 @@ public:
         return queued_buffers.size();
     }
 
-    /// Gets the sample rate
-    u32 GetSampleRate() const {
-        return sample_rate;
-    }
-
-    /// Gets the number of channels
-    u32 GetNumChannels() const;
-
 private:
     /// Current state of the stream
     enum class State {
@@ -85,7 +76,7 @@ private:
     /// 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
+    int 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
@@ -93,10 +84,6 @@ private:
     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
-    std::string name;                       ///< Name of the stream, must be unique
 };
 
-using StreamPtr = std::shared_ptr<Stream>;
-
 } // namespace AudioCore

src/common/common_funcs.h

@@ -6,7 +6,7 @@
 
 #include <string>
 
-#if !defined(ARCHITECTURE_x86_64)
+#if !defined(ARCHITECTURE_x86_64) && !defined(ARCHITECTURE_ARM)
 #include <cstdlib> // for exit
 #endif
 #include "common/common_types.h"
@@ -32,6 +32,8 @@
 
 #ifdef ARCHITECTURE_x86_64
 #define Crash() __asm__ __volatile__("int $3")
+#elif defined(ARCHITECTURE_ARM)
+#define Crash() __asm__ __volatile__("trap")
 #else
 #define Crash() exit(1)
 #endif

src/common/common_paths.h

@@ -32,7 +32,6 @@
 #define SDMC_DIR "sdmc"
 #define NAND_DIR "nand"
 #define SYSDATA_DIR "sysdata"
-#define KEYS_DIR "keys"
 #define LOG_DIR "log"
 
 // Filenames

src/common/file_util.cpp

@@ -706,7 +706,6 @@ const std::string& GetUserPath(UserPath path, const std::string& new_path) {
         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);
     }
@@ -737,19 +736,6 @@ const std::string& GetUserPath(UserPath path, const std::string& new_path) {
     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) {
     return FileUtil::IOFile(filename, text_file ? "w" : "wb").WriteBytes(str.data(), str.size());
 }

src/common/file_util.h

@@ -23,7 +23,6 @@ namespace FileUtil {
 enum class UserPath {
     CacheDir,
     ConfigDir,
-    KeysDir,
     LogDir,
     NANDDir,
     RootDir,
@@ -126,8 +125,6 @@ bool SetCurrentDir(const std::string& directory);
 // directory. To be used in "multi-user" mode (that is, installed).
 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();
 

src/common/logging/backend.cpp

@@ -168,40 +168,28 @@ void FileBackend::Write(const Entry& entry) {
     SUB(Service, AM)                                                                               \
     SUB(Service, AOC)                                                                              \
     SUB(Service, APM)                                                                              \
-    SUB(Service, ARP)                                                                              \
     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)                                                                                   \
@@ -218,7 +206,6 @@ void FileBackend::Write(const Entry& entry) {
     CLS(Input)                                                                                     \
     CLS(Network)                                                                                   \
     CLS(Loader)                                                                                    \
-    CLS(Crypto)                                                                                    \
     CLS(WebService)
 
 // GetClassName is a macro defined by Windows.h, grrr...

src/common/logging/log.h

@@ -54,41 +54,29 @@ enum class Class : ClassType {
     Service_AM,        ///< The AM (Applet manager) service
     Service_AOC,       ///< The AOC (AddOn Content) service
     Service_APM,       ///< The APM (Performance) service
-    Service_ARP,       ///< The ARP 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
@@ -103,7 +91,6 @@ 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

src/common/logging/text_formatter.h

@@ -5,7 +5,6 @@
 #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() = default;
+    Rectangle() {}
 
     Rectangle(T left, T top, T right, T bottom)
         : left(left), top(top), right(right), bottom(bottom) {}

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,15 +24,13 @@ namespace Common {
 
 /// Make a string lowercase
 std::string ToLower(std::string str) {
-    std::transform(str.begin(), str.end(), str.begin(),
-                   [](unsigned char c) { return std::tolower(c); });
+    boost::transform(str, str.begin(), ::tolower);
     return str;
 }
 
 /// Make a string uppercase
 std::string ToUpper(std::string str) {
-    std::transform(str.begin(), str.end(), str.begin(),
-                   [](unsigned char c) { return std::toupper(c); });
+    boost::transform(str, str.begin(), ::toupper);
     return str;
 }
 

src/common/swap.h

@@ -69,7 +69,7 @@ inline u32 swap32(u32 _data) {
 inline u64 swap64(u64 _data) {
     return _byteswap_uint64(_data);
 }
-#elif defined(ARCHITECTURE_ARM) && (__ARM_ARCH >= 6)
+#elif ARCHITECTURE_ARM
 inline u16 swap16(u16 _data) {
     u32 data = _data;
     __asm__("rev16 %0, %1\n" : "=l"(data) : "l"(data));

src/common/threadsafe_queue.h

@@ -33,11 +33,9 @@ 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
@@ -110,41 +108,15 @@ private:
 // single reader, multiple writer queue
 
 template <typename T, bool NeedSize = true>
-class MPSCQueue {
+class MPSCQueue : public SPSCQueue<T, NeedSize> {
 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);
-        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();
+        SPSCQueue<T, NeedSize>::Push(t);
     }
 
 private:
-    SPSCQueue<T, NeedSize> spsc_queue;
     std::mutex write_lock;
 };
 } // namespace Common

src/common/timer.cpp

@@ -3,16 +3,31 @@
 // 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 {
 
-std::chrono::milliseconds Timer::GetTimeMs() {
-    return std::chrono::duration_cast<std::chrono::milliseconds>(
-        std::chrono::system_clock::now().time_since_epoch());
+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
 }
 
 // --------------------------------------------
@@ -48,7 +63,7 @@ void Timer::Update() {
 // -------------------------------------
 
 // Get the number of milliseconds since the last Update()
-std::chrono::milliseconds Timer::GetTimeDifference() {
+u64 Timer::GetTimeDifference() {
     return GetTimeMs() - m_LastTime;
 }
 
@@ -59,11 +74,11 @@ void Timer::AddTimeDifference() {
 }
 
 // Get the time elapsed since the Start()
-std::chrono::milliseconds Timer::GetTimeElapsed() {
+u64 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.count() == 0)
-        return std::chrono::milliseconds(1);
+    if (m_StartTime == 0)
+        return 1;
 
     // Return the final timer time if the timer is stopped
     if (!m_Running)
@@ -75,34 +90,49 @@ std::chrono::milliseconds 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.count() == 0)
+    if (m_StartTime == 0)
         return "00:00:00:000";
 
     // The number of milliseconds since the start.
     // Use a different value if the timer is stopped.
-    std::chrono::milliseconds Milliseconds;
+    u64 Milliseconds;
     if (m_Running)
         Milliseconds = GetTimeMs() - m_StartTime;
     else
         Milliseconds = m_LastTime - m_StartTime;
     // Seconds
-    std::chrono::seconds Seconds = std::chrono::duration_cast<std::chrono::seconds>(Milliseconds);
+    u32 Seconds = (u32)(Milliseconds / 1000);
     // Minutes
-    std::chrono::minutes Minutes = std::chrono::duration_cast<std::chrono::minutes>(Milliseconds);
+    u32 Minutes = Seconds / 60;
     // Hours
-    std::chrono::hours Hours = std::chrono::duration_cast<std::chrono::hours>(Milliseconds);
+    u32 Hours = Minutes / 60;
 
-    std::string TmpStr = fmt::format("{:02}:{:02}:{:02}:{:03}", Hours.count(), Minutes.count() % 60,
-                                     Seconds.count() % 60, Milliseconds.count() % 1000);
+    std::string TmpStr = fmt::format("{:02}:{:02}:{:02}:{:03}", Hours, Minutes % 60, Seconds % 60,
+                                     Milliseconds % 1000);
     return TmpStr;
 }
 
-// Get the number of seconds since January 1 1970
-std::chrono::seconds Timer::GetTimeSinceJan1970() {
-    return std::chrono::duration_cast<std::chrono::seconds>(GetTimeMs());
+// Get current time
+void Timer::IncreaseResolution() {
+#ifdef _WIN32
+    timeBeginPeriod(1);
+#endif
 }
 
-std::chrono::seconds Timer::GetLocalTimeSinceJan1970() {
+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);
+}
+
+u64 Timer::GetLocalTimeSinceJan1970() {
     time_t sysTime, tzDiff, tzDST;
     struct tm* gmTime;
 
@@ -119,7 +149,7 @@ std::chrono::seconds Timer::GetLocalTimeSinceJan1970() {
     gmTime = gmtime(&sysTime);
     tzDiff = sysTime - mktime(gmTime);
 
-    return std::chrono::seconds(sysTime + tzDiff + tzDST);
+    return (u64)(sysTime + tzDiff + tzDST);
 }
 
 // Return the current time formatted as Minutes:Seconds:Milliseconds
@@ -134,16 +164,30 @@ std::string Timer::GetTimeFormatted() {
 
     strftime(tmp, 6, "%M:%S", gmTime);
 
-    u64 milliseconds = static_cast<u64>(GetTimeMs().count()) % 1000;
-    return fmt::format("{}:{:03}", tmp, milliseconds);
+// 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
 }
 
 // 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 = static_cast<u64>(Common::Timer::GetTimeSinceJan1970().count());
-    double ms = static_cast<u64>(GetTimeMs().count()) % 1000;
+    u64 TmpSeconds = Common::Timer::GetTimeSinceJan1970();
 
     // Remove a few years. We only really want enough seconds to make
     // sure that we are detecting actual actions, perhaps 60 seconds is
@@ -152,7 +196,12 @@ double Timer::GetDoubleTime() {
     TmpSeconds = TmpSeconds - (38 * 365 * 24 * 60 * 60);
 
     // Make a smaller integer that fits in the double
-    u32 Seconds = static_cast<u32>(TmpSeconds);
+    u32 Seconds = (u32)TmpSeconds;
+#ifdef _WIN32
+    double ms = tp.millitm / 1000.0 / 1000.0;
+#else
+    double ms = t.tv_usec / 1000000.0;
+#endif
     double TmpTime = Seconds + ms;
 
     return TmpTime;

src/common/timer.h

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

src/core/CMakeLists.txt

@@ -12,16 +12,6 @@ add_library(core STATIC
     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
@@ -73,10 +63,12 @@ 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.cpp
-    hle/kernel/object.h
+    hle/kernel/object_address_table.cpp
+    hle/kernel/object_address_table.h
     hle/kernel/process.cpp
     hle/kernel/process.h
     hle/kernel/resource_limit.cpp
@@ -122,41 +114,23 @@ 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/arp/arp.cpp
-    hle/service/arp/arp.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_a.cpp
-    hle/service/audio/audren_a.h
     hle/service/audio/audren_u.cpp
+    hle/service/audio/audren_u.cpp
+    hle/service/audio/audren_u.h
     hle/service/audio/audren_u.h
     hle/service/audio/codecctl.cpp
     hle/service/audio/codecctl.h
@@ -166,14 +140,8 @@ add_library(core STATIC
     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
@@ -188,14 +156,8 @@ 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/interface.cpp
@@ -216,14 +178,8 @@ add_library(core STATIC
     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/ncm/ncm.cpp
-    hle/service/ncm/ncm.h
     hle/service/nfc/nfc.cpp
     hle/service/nfc/nfc.h
     hle/service/nfp/nfp.cpp
@@ -263,20 +219,14 @@ 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
@@ -323,8 +273,10 @@ add_library(core STATIC
     hle/service/vi/vi_s.h
     hle/service/vi/vi_u.cpp
     hle/service/vi/vi_u.h
-    hle/service/wlan/wlan.cpp
-    hle/service/wlan/wlan.h
+    hw/hw.cpp
+    hw/hw.h
+    hw/lcd.cpp
+    hw/lcd.h
     loader/deconstructed_rom_directory.cpp
     loader/deconstructed_rom_directory.h
     loader/elf.cpp
@@ -339,8 +291,6 @@ 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
@@ -360,7 +310,7 @@ add_library(core STATIC
 create_target_directory_groups(core)
 
 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)
+target_link_libraries(core PUBLIC Boost::boost PRIVATE fmt lz4_static opus unicorn)
 
 if (ARCHITECTURE_x86_64)
     target_sources(core PRIVATE

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/process.h"
+#include "core/hle/kernel/memory.h"
 #include "core/hle/kernel/svc.h"
 #include "core/memory.h"
 
@@ -139,12 +139,14 @@ void ARM_Dynarmic::Step() {
 }
 
 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;
+    : cb(std::make_unique<ARM_Dynarmic_Callbacks>(*this)),
+      jit(MakeJit()), exclusive_monitor{std::dynamic_pointer_cast<DynarmicExclusiveMonitor>(
+                          exclusive_monitor)},
+      core_index{core_index} {
+    ARM_Interface::ThreadContext ctx;
     inner_unicorn.SaveContext(ctx);
-    PageTableChanged();
     LoadContext(ctx);
+    PageTableChanged();
 }
 
 ARM_Dynarmic::~ARM_Dynarmic() = default;
@@ -203,7 +205,7 @@ u64 ARM_Dynarmic::GetTlsAddress() const {
     return cb->tpidrro_el0;
 }
 
-void ARM_Dynarmic::SetTlsAddress(VAddr address) {
+void ARM_Dynarmic::SetTlsAddress(u64 address) {
     cb->tpidrro_el0 = address;
 }
 
@@ -215,7 +217,7 @@ void ARM_Dynarmic::SetTPIDR_EL0(u64 value) {
     cb->tpidr_el0 = value;
 }
 
-void ARM_Dynarmic::SaveContext(ThreadContext& ctx) {
+void ARM_Dynarmic::SaveContext(ARM_Interface::ThreadContext& ctx) {
     ctx.cpu_registers = jit->GetRegisters();
     ctx.sp = jit->GetSP();
     ctx.pc = jit->GetPC();
@@ -224,7 +226,7 @@ void ARM_Dynarmic::SaveContext(ThreadContext& ctx) {
     ctx.fpscr = jit->GetFpcr();
 }
 
-void ARM_Dynarmic::LoadContext(const ThreadContext& ctx) {
+void ARM_Dynarmic::LoadContext(const ARM_Interface::ThreadContext& ctx) {
     jit->SetRegisters(ctx.cpu_registers);
     jit->SetSP(ctx.sp);
     jit->SetPC(ctx.pc);

src/core/core.cpp

@@ -15,10 +15,11 @@
 #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/renderer_base.h"
 #include "video_core/video_core.h"
 
 namespace Core {
@@ -85,7 +86,7 @@ System::ResultStatus System::SingleStep() {
     return RunLoop(false);
 }
 
-System::ResultStatus System::Load(EmuWindow& emu_window, const std::string& 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) {
@@ -100,10 +101,8 @@ System::ResultStatus System::Load(EmuWindow& emu_window, const std::string& file
                      static_cast<int>(system_mode.second));
 
         switch (system_mode.second) {
-        case Loader::ResultStatus::ErrorMissingKeys:
-            return ResultStatus::ErrorLoader_ErrorMissingKeys;
-        case Loader::ResultStatus::ErrorDecrypting:
-            return ResultStatus::ErrorLoader_ErrorDecrypting;
+        case Loader::ResultStatus::ErrorEncrypted:
+            return ResultStatus::ErrorLoader_ErrorEncrypted;
         case Loader::ResultStatus::ErrorInvalidFormat:
             return ResultStatus::ErrorLoader_ErrorInvalidFormat;
         case Loader::ResultStatus::ErrorUnsupportedArch:
@@ -113,7 +112,7 @@ System::ResultStatus System::Load(EmuWindow& emu_window, const std::string& file
         }
     }
 
-    ResultStatus init_result{Init(emu_window)};
+    ResultStatus init_result{Init(emu_window, system_mode.first.get())};
     if (init_result != ResultStatus::Success) {
         LOG_CRITICAL(Core, "Failed to initialize system (Error {})!",
                      static_cast<int>(init_result));
@@ -127,10 +126,8 @@ System::ResultStatus System::Load(EmuWindow& emu_window, const std::string& file
         System::Shutdown();
 
         switch (load_result) {
-        case Loader::ResultStatus::ErrorMissingKeys:
-            return ResultStatus::ErrorLoader_ErrorMissingKeys;
-        case Loader::ResultStatus::ErrorDecrypting:
-            return ResultStatus::ErrorLoader_ErrorDecrypting;
+        case Loader::ResultStatus::ErrorEncrypted:
+            return ResultStatus::ErrorLoader_ErrorEncrypted;
         case Loader::ResultStatus::ErrorInvalidFormat:
             return ResultStatus::ErrorLoader_ErrorInvalidFormat;
         case Loader::ResultStatus::ErrorUnsupportedArch:
@@ -166,7 +163,7 @@ Cpu& System::CpuCore(size_t core_index) {
     return *cpu_cores[core_index];
 }
 
-System::ResultStatus System::Init(EmuWindow& emu_window) {
+System::ResultStatus System::Init(EmuWindow* emu_window, u32 system_mode) {
     LOG_DEBUG(HW_Memory, "initialized OK");
 
     CoreTiming::Init();
@@ -179,20 +176,20 @@ System::ResultStatus System::Init(EmuWindow& emu_window) {
         cpu_cores[index] = std::make_shared<Cpu>(cpu_exclusive_monitor, cpu_barrier, index);
     }
 
+    gpu_core = std::make_unique<Tegra::GPU>();
+    audio_core = std::make_unique<AudioCore::AudioOut>();
     telemetry_session = std::make_unique<Core::TelemetrySession>();
     service_manager = std::make_shared<Service::SM::ServiceManager>();
 
-    Kernel::Init();
+    HW::Init();
+    Kernel::Init(system_mode);
     Service::Init(service_manager);
     GDBStub::Init();
 
-    renderer = VideoCore::CreateRenderer(emu_window);
-    if (!renderer->Init()) {
+    if (!VideoCore::Init(emu_window)) {
         return ResultStatus::ErrorVideoCore;
     }
 
-    gpu_core = std::make_unique<Tegra::GPU>(renderer->Rasterizer());
-
     // Create threads for CPU cores 1-3, and build thread_to_cpu map
     // CPU core 0 is run on the main thread
     thread_to_cpu[std::this_thread::get_id()] = cpu_cores[0];
@@ -224,13 +221,15 @@ void System::Shutdown() {
                          perf_results.frametime * 1000.0);
 
     // Shutdown emulation session
-    renderer.reset();
+    VideoCore::Shutdown();
     GDBStub::Shutdown();
     Service::Shutdown();
     Kernel::Shutdown();
+    HW::Shutdown();
     service_manager.reset();
     telemetry_session.reset();
     gpu_core.reset();
+    audio_core.reset();
 
     // Close all CPU/threading state
     cpu_barrier->NotifyEnd();

src/core/core.h

@@ -8,10 +8,11 @@
 #include <memory>
 #include <string>
 #include <thread>
+#include "audio_core/audio_out.h"
 #include "common/common_types.h"
 #include "core/arm/exclusive_monitor.h"
 #include "core/core_cpu.h"
-#include "core/hle/kernel/object.h"
+#include "core/hle/kernel/kernel.h"
 #include "core/hle/kernel/scheduler.h"
 #include "core/loader/loader.h"
 #include "core/memory.h"
@@ -27,10 +28,6 @@ namespace Service::SM {
 class ServiceManager;
 }
 
-namespace VideoCore {
-class RendererBase;
-}
-
 namespace Core {
 
 class System {
@@ -47,14 +44,12 @@ 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_ErrorMissingKeys, ///< Error because the key/keys needed to run could not be
-                                      ///< found.
-        ErrorLoader_ErrorDecrypting,  ///< 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_ErrorEncrypted, ///< 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
@@ -87,12 +82,11 @@ public:
 
     /**
      * Load an executable application.
-     * @param emu_window Reference to the host-system window used for video output and keyboard
-     *                   input.
+     * @param emu_window Pointer 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
@@ -133,24 +127,14 @@ public:
     /// Gets a CPU interface to the CPU core with the specified index
     Cpu& CpuCore(size_t core_index);
 
-    /// Gets a mutable reference to the GPU interface
+    /// Gets the GPU interface
     Tegra::GPU& GPU() {
         return *gpu_core;
     }
 
-    /// Gets an immutable reference to the GPU interface.
-    const Tegra::GPU& GPU() const {
-        return *gpu_core;
-    }
-
-    /// Gets a mutable reference to the renderer.
-    VideoCore::RendererBase& Renderer() {
-        return *renderer;
-    }
-
-    /// Gets an immutable reference to the renderer.
-    const VideoCore::RendererBase& Renderer() const {
-        return *renderer;
+    /// Gets the AudioCore interface
+    AudioCore::AudioOut& AudioCore() {
+        return *audio_core;
     }
 
     /// Gets the scheduler for the CPU core that is currently running
@@ -208,16 +192,16 @@ private:
 
     /**
      * Initialize the emulated system.
-     * @param emu_window Reference to the host-system window used for video output and keyboard
-     *                   input.
+     * @param emu_window Pointer to the host-system window used for video output and keyboard input.
+     * @param system_mode The system mode.
      * @return ResultStatus code, indicating if the operation succeeded.
      */
-    ResultStatus Init(EmuWindow& emu_window);
+    ResultStatus Init(EmuWindow* emu_window, u32 system_mode);
 
     /// AppLoader used to load the current executing application
     std::unique_ptr<Loader::AppLoader> app_loader;
-    std::unique_ptr<VideoCore::RendererBase> renderer;
     std::unique_ptr<Tegra::GPU> gpu_core;
+    std::unique_ptr<AudioCore::AudioOut> audio_core;
     std::shared_ptr<Tegra::DebugContext> debug_context;
     Kernel::SharedPtr<Kernel::Process> current_process;
     std::shared_ptr<ExclusiveMonitor> cpu_exclusive_monitor;

src/core/core_cpu.cpp

@@ -12,6 +12,7 @@
 #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"

src/core/core_timing.cpp

@@ -141,7 +141,7 @@ void ScheduleEvent(s64 cycles_into_future, const EventType* event_type, u64 user
         ForceExceptionCheck(cycles_into_future);
 
     event_queue.emplace_back(Event{timeout, event_fifo_id++, userdata, event_type});
-    std::push_heap(event_queue.begin(), event_queue.end(), std::greater<>());
+    std::push_heap(event_queue.begin(), event_queue.end(), std::greater<Event>());
 }
 
 void ScheduleEventThreadsafe(s64 cycles_into_future, const EventType* event_type, u64 userdata) {
@@ -156,7 +156,7 @@ void UnscheduleEvent(const EventType* event_type, u64 userdata) {
     // Removing random items breaks the invariant so we have to re-establish it.
     if (itr != event_queue.end()) {
         event_queue.erase(itr, event_queue.end());
-        std::make_heap(event_queue.begin(), event_queue.end(), std::greater<>());
+        std::make_heap(event_queue.begin(), event_queue.end(), std::greater<Event>());
     }
 }
 
@@ -167,7 +167,7 @@ void RemoveEvent(const EventType* event_type) {
     // Removing random items breaks the invariant so we have to re-establish it.
     if (itr != event_queue.end()) {
         event_queue.erase(itr, event_queue.end());
-        std::make_heap(event_queue.begin(), event_queue.end(), std::greater<>());
+        std::make_heap(event_queue.begin(), event_queue.end(), std::greater<Event>());
     }
 }
 
@@ -190,7 +190,7 @@ void MoveEvents() {
     for (Event ev; ts_queue.Pop(ev);) {
         ev.fifo_order = event_fifo_id++;
         event_queue.emplace_back(std::move(ev));
-        std::push_heap(event_queue.begin(), event_queue.end(), std::greater<>());
+        std::push_heap(event_queue.begin(), event_queue.end(), std::greater<Event>());
     }
 }
 
@@ -205,7 +205,7 @@ void Advance() {
 
     while (!event_queue.empty() && event_queue.front().time <= global_timer) {
         Event evt = std::move(event_queue.front());
-        std::pop_heap(event_queue.begin(), event_queue.end(), std::greater<>());
+        std::pop_heap(event_queue.begin(), event_queue.end(), std::greater<Event>());
         event_queue.pop_back();
         evt.type->callback(evt.userdata, static_cast<int>(global_timer - evt.time));
     }

src/core/core_timing.h

@@ -23,10 +23,6 @@
 
 namespace CoreTiming {
 
-struct EventType;
-
-using TimedCallback = std::function<void(u64 userdata, int cycles_late)>;
-
 /**
  * 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.
@@ -34,6 +30,8 @@ using TimedCallback = std::function<void(u64 userdata, int cycles_late)>;
 void Init();
 void Shutdown();
 
+typedef std::function<void(u64 userdata, int cycles_late)> TimedCallback;
+
 /**
  * This should only be called from the emu thread, if you are calling it any other thread, you are
  * doing something evil
@@ -42,6 +40,8 @@ u64 GetTicks();
 u64 GetIdleTicks();
 void AddTicks(u64 ticks);
 
+struct EventType;
+
 /**
  * Returns the event_type identifier. if name is not unique, it will assert.
  */

src/core/crypto/aes_util.cpp

@@ -1,115 +0,0 @@
-// Copyright 2018 yuzu emulator team
-// Licensed under GPLv2 or any later version
-// Refer to the license.txt file included.
-
-#include <mbedtls/cipher.h>
-#include "common/assert.h"
-#include "common/logging/log.h"
-#include "core/crypto/aes_util.h"
-#include "core/crypto/key_manager.h"
-
-namespace Core::Crypto {
-namespace {
-std::vector<u8> 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;
-}
-} // Anonymous namespace
-
-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) const {
-    auto* const context = op == Op::Encrypt ? &ctx->encryption_context : &ctx->decryption_context;
-
-    mbedtls_cipher_reset(context);
-
-    size_t written = 0;
-    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 class AESCipher<Key128>;
-template class AESCipher<Key256>;
-} // namespace Core::Crypto

src/core/crypto/aes_util.h

@@ -1,64 +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 <type_traits>
-#include <vector>
-#include "common/common_types.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) const {
-        static_assert(std::is_trivially_copyable_v<Source> && std::is_trivially_copyable_v<Dest>,
-                      "Transcode source and destination types must be trivially copyable.");
-        Transcode(reinterpret_cast<const u8*>(src), size, reinterpret_cast<u8*>(dest), op);
-    }
-
-    void Transcode(const u8* src, size_t size, u8* dest, Op op) const;
-
-    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) {
-        static_assert(std::is_trivially_copyable_v<Source> && std::is_trivially_copyable_v<Dest>,
-                      "XTSTranscode source and destination types must be trivially copyable.");
-        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;
-};
-} // namespace Core::Crypto

src/core/crypto/ctr_encryption_layer.cpp

@@ -1,56 +0,0 @@
-// Copyright 2018 yuzu emulator team
-// Licensed under GPLv2 or any later version
-// Refer to the license.txt file included.
-
-#include <cstring>
-#include "common/assert.h"
-#include "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

@@ -1,33 +0,0 @@
-// Copyright 2018 yuzu emulator team
-// Licensed under GPLv2 or any later version
-// Refer to the license.txt file included.
-
-#pragma once
-
-#include <vector>
-#include "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

@@ -1,42 +0,0 @@
-// 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

@@ -1,33 +0,0 @@
-// 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"
-#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

@@ -1,208 +0,0 @@
-// Copyright 2018 yuzu emulator team
-// Licensed under GPLv2 or any later version
-// Refer to the license.txt file included.
-
-#include <algorithm>
-#include <array>
-#include <fstream>
-#include <locale>
-#include <sstream>
-#include <string_view>
-#include "common/common_paths.h"
-#include "common/file_util.h"
-#include "core/crypto/key_manager.h"
-#include "core/settings.h"
-
-namespace Core::Crypto {
-
-static u8 ToHexNibble(char c1) {
-    if (c1 >= 65 && c1 <= 70)
-        return c1 - 55;
-    if (c1 >= 97 && c1 <= 102)
-        return c1 - 87;
-    if (c1 >= 48 && c1 <= 57)
-        return c1 - 48;
-    throw std::logic_error("Invalid hex digit");
-}
-
-template <size_t Size>
-static std::array<u8, Size> HexStringToArray(std::string_view str) {
-    std::array<u8, Size> out{};
-    for (size_t i = 0; i < 2 * Size; i += 2) {
-        auto d1 = str[i];
-        auto d2 = str[i + 1];
-        out[i / 2] = (ToHexNibble(d1) << 4) | ToHexNibble(d2);
-    }
-    return out;
-}
-
-std::array<u8, 16> operator""_array16(const char* str, size_t len) {
-    if (len != 32)
-        throw std::logic_error("Not of correct size.");
-    return HexStringToArray<16>(str);
-}
-
-std::array<u8, 32> operator""_array32(const char* str, size_t len) {
-    if (len != 64)
-        throw std::logic_error("Not of correct size.");
-    return HexStringToArray<32>(str);
-}
-
-KeyManager::KeyManager() {
-    // Initialize keys
-    const std::string hactool_keys_dir = FileUtil::GetHactoolConfigurationPath();
-    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(const std::string& filename, bool is_title_keys) {
-    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(const std::string& dir1, const std::string& dir2,
-                                    const std::string& filename, bool title) {
-    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

@@ -1,120 +0,0 @@
-// Copyright 2018 yuzu emulator team
-// Licensed under GPLv2 or any later version
-// Refer to the license.txt file included.
-
-#pragma once
-
-#include <array>
-#include <string>
-#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(const std::string& filename, bool is_title_keys);
-    void AttemptLoadKeyFile(const std::string& dir1, const std::string& dir2,
-                            const std::string& 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

@@ -1,5 +0,0 @@
-// 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

@@ -1,20 +0,0 @@
-// 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

@@ -1,149 +0,0 @@
-// 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

@@ -1,96 +0,0 @@
-// Copyright 2018 yuzu emulator team
-// Licensed under GPLv2 or any later version
-// Refer to the license.txt file included.
-
-#pragma once
-
-#include <array>
-#include <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

@@ -4,14 +4,12 @@
 
 #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"
+#include "romfs.h"
 
 namespace FileSys {
 
@@ -31,19 +29,11 @@ enum class NCASectionFilesystemType : u8 {
 struct NCASectionHeaderBlock {
     INSERT_PADDING_BYTES(3);
     NCASectionFilesystemType filesystem_type;
-    NCASectionCryptoType crypto_type;
+    u8 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;
@@ -53,170 +43,67 @@ struct PFS0Superblock {
     u64_le hash_table_size;
     u64_le pfs0_header_offset;
     u64_le pfs0_size;
-    INSERT_PADDING_BYTES(0x1B0);
+    INSERT_PADDING_BYTES(432);
 };
 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;
-    }
-}
+static_assert(sizeof(RomFSSuperblock) == 0xE8, "RomFSSuperblock has incorrect size.");
 
 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;
+        LOG_CRITICAL(Loader, "File reader errored out during header read.");
 
     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;
-        }
+        status = Loader::ResultStatus::ErrorInvalidFormat;
+        return;
     }
 
-    const std::ptrdiff_t number_sections =
+    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];
+        // Seek to beginning of this section.
+        NCASectionHeaderBlock block{};
+        if (sizeof(NCASectionHeaderBlock) !=
+            file->ReadObject(&block, SECTION_HEADER_OFFSET + i * SECTION_HEADER_SIZE))
+            LOG_CRITICAL(Loader, "File reader errored out during header read.");
+
+        if (block.filesystem_type == NCASectionFilesystemType::ROMFS) {
+            RomFSSuperblock sb{};
+            if (sizeof(RomFSSuperblock) !=
+                file->ReadObject(&sb, SECTION_HEADER_OFFSET + i * SECTION_HEADER_SIZE))
+                LOG_CRITICAL(Loader, "File reader errored out during header read.");
 
-        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) {
+                sb.ivfc.levels[IVFC_MAX_LEVEL - 1].offset;
+            const size_t romfs_size = sb.ivfc.levels[IVFC_MAX_LEVEL - 1].size;
+            files.emplace_back(std::make_shared<OffsetVfsFile>(file, romfs_size, romfs_offset));
+            romfs = files.back();
+        } else if (block.filesystem_type == NCASectionFilesystemType::PFS0) {
+            PFS0Superblock sb{};
+            // Seek back to beginning of this section.
+            if (sizeof(PFS0Superblock) !=
+                file->ReadObject(&sb, SECTION_HEADER_OFFSET + i * SECTION_HEADER_SIZE))
+                LOG_CRITICAL(Loader, "File reader errored out during header read.");
+
             u64 offset = (static_cast<u64>(header.section_tables[i].media_offset) *
                           MEDIA_OFFSET_MULTIPLIER) +
-                         section.pfs0.pfs0_header_offset;
+                         sb.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));
+            auto npfs = std::make_shared<PartitionFilesystem>(
+                std::make_shared<OffsetVfsFile>(file, size, offset));
 
-                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;
+            if (npfs->GetStatus() == Loader::ResultStatus::Success) {
+                dirs.emplace_back(npfs);
+                if (IsDirectoryExeFS(dirs.back()))
+                    exefs = dirs.back();
             }
         }
     }
@@ -266,10 +153,6 @@ VirtualDir NCA::GetExeFS() const {
     return exefs;
 }
 
-VirtualFile NCA::GetBaseFile() const {
-    return file;
-}
-
 bool NCA::ReplaceFileWithSubdirectory(VirtualFile file, VirtualDir dir) {
     return false;
 }

src/core/file_sys/content_archive.h

@@ -8,18 +8,14 @@
 #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,
@@ -28,13 +24,6 @@ enum class NCAContentType : u8 {
     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;
@@ -59,7 +48,7 @@ struct NCAHeader {
     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;
+    std::array<std::array<u8, 0x10>, 0x4> key_area;
     INSERT_PADDING_BYTES(0xC0);
 };
 static_assert(sizeof(NCAHeader) == 0x400, "NCAHeader has incorrect size.");
@@ -69,7 +58,10 @@ inline bool IsDirectoryExeFS(const std::shared_ptr<VfsDirectory>& pfs) {
     return pfs->GetFile("main") != nullptr && pfs->GetFile("main.npdm") != nullptr;
 }
 
-bool IsValidNCA(const NCAHeader& header);
+inline bool IsValidNCA(const NCAHeader& header) {
+    return header.magic == Common::MakeMagic('N', 'C', 'A', '2') ||
+           header.magic == Common::MakeMagic('N', 'C', 'A', '3');
+}
 
 // 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.
@@ -89,15 +81,10 @@ public:
     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;
 
@@ -108,10 +95,6 @@ private:
     NCAHeader header{};
 
     Loader::ResultStatus status{};
-
-    bool encrypted;
-
-    Core::Crypto::KeyManager keys;
 };
 
 } // namespace FileSys

src/core/file_sys/partition_filesystem.cpp

@@ -97,8 +97,9 @@ 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++) {
-        LOG_DEBUG(Service_FS, " > File {}:              {} (0x{:X} bytes)", i,
-                  pfs_files[i]->GetName(), pfs_files[i]->GetSize());
+        LOG_DEBUG(Service_FS, " > File {}:              {} (0x{:X} bytes, at 0x{:X})", i,
+                  pfs_files[i]->GetName(), pfs_files[i]->GetSize(),
+                  dynamic_cast<OffsetVfsFile*>(pfs_files[i].get())->GetOffset());
     }
 }
 

src/core/file_sys/vfs.cpp

@@ -285,26 +285,6 @@ bool ReadOnlyVfsDirectory::Rename(std::string_view name) {
     return false;
 }
 
-bool DeepEquals(const VirtualFile& file1, const VirtualFile& file2, size_t block_size) {
-    if (file1->GetSize() != file2->GetSize())
-        return false;
-
-    std::vector<u8> f1_v(block_size);
-    std::vector<u8> f2_v(block_size);
-    for (size_t i = 0; i < file1->GetSize(); i += block_size) {
-        auto f1_vs = file1->Read(f1_v.data(), block_size, i);
-        auto f2_vs = file2->Read(f2_v.data(), block_size, i);
-
-        if (f1_vs != f2_vs)
-            return false;
-        auto iters = std::mismatch(f1_v.begin(), f1_v.end(), f2_v.begin(), f2_v.end());
-        if (iters.first != f1_v.end() && iters.second != f2_v.end())
-            return false;
-    }
-
-    return true;
-}
-
 bool VfsRawCopy(VirtualFile src, VirtualFile dest) {
     if (src == nullptr || dest == nullptr)
         return false;

src/core/file_sys/vfs.h

@@ -245,9 +245,6 @@ struct ReadOnlyVfsDirectory : public VfsDirectory {
     bool Rename(std::string_view name) override;
 };
 
-// Compare the two files, byte-for-byte, in increments specificed by block_size
-bool DeepEquals(const VirtualFile& file1, const VirtualFile& file2, size_t block_size = 0x200);
-
 // A method that copies the raw data between two different implementations of VirtualFile. If you
 // are using the same implementation, it is probably better to use the Copy method in the parent
 // directory of src/dest.

src/core/file_sys/vfs_vector.cpp

@@ -3,7 +3,6 @@
 // Refer to the license.txt file included.
 
 #include <algorithm>
-#include <utility>
 #include "core/file_sys/vfs_vector.h"
 
 namespace FileSys {
@@ -32,18 +31,16 @@ bool VectorVfsDirectory::IsReadable() const {
 std::string VectorVfsDirectory::GetName() const {
     return name;
 }
-
 std::shared_ptr<VfsDirectory> VectorVfsDirectory::GetParentDirectory() const {
     return parent;
 }
 
 template <typename T>
 static bool FindAndRemoveVectorElement(std::vector<T>& vec, std::string_view name) {
-    const auto iter =
-        std::find_if(vec.begin(), vec.end(), [name](const T& e) { return e->GetName() == name; });
+    auto iter = std::find_if(vec.begin(), vec.end(), [name](T e) { return e->GetName() == name; });
     if (iter == vec.end())
         return false;
-
+    auto old_size = vec.size();
     vec.erase(iter);
     return true;
 }
@@ -80,7 +77,7 @@ void VectorVfsDirectory::AddDirectory(VirtualDir dir) {
 bool VectorVfsDirectory::ReplaceFileWithSubdirectory(VirtualFile file, VirtualDir dir) {
     if (!DeleteFile(file->GetName()))
         return false;
-    dirs.emplace_back(std::move(dir));
+    dirs.emplace_back(dir);
     return true;
 }
 } // namespace FileSys

src/core/gdbstub/gdbstub.cpp

@@ -37,46 +37,45 @@
 #include "core/core.h"
 #include "core/core_cpu.h"
 #include "core/gdbstub/gdbstub.h"
+#include "core/hle/kernel/kernel.h"
 #include "core/hle/kernel/scheduler.h"
 #include "core/loader/loader.h"
 #include "core/memory.h"
 
-namespace GDBStub {
-namespace {
-constexpr int GDB_BUFFER_SIZE = 10000;
+const int GDB_BUFFER_SIZE = 10000;
 
-constexpr char GDB_STUB_START = '$';
-constexpr char GDB_STUB_END = '#';
-constexpr char GDB_STUB_ACK = '+';
-constexpr char GDB_STUB_NACK = '-';
+const char GDB_STUB_START = '$';
+const char GDB_STUB_END = '#';
+const char GDB_STUB_ACK = '+';
+const char GDB_STUB_NACK = '-';
 
 #ifndef SIGTRAP
-constexpr u32 SIGTRAP = 5;
+const u32 SIGTRAP = 5;
 #endif
 
 #ifndef SIGTERM
-constexpr u32 SIGTERM = 15;
+const u32 SIGTERM = 15;
 #endif
 
 #ifndef MSG_WAITALL
-constexpr u32 MSG_WAITALL = 8;
+const u32 MSG_WAITALL = 8;
 #endif
 
-constexpr u32 LR_REGISTER = 30;
-constexpr u32 SP_REGISTER = 31;
-constexpr u32 PC_REGISTER = 32;
-constexpr u32 CPSR_REGISTER = 33;
-constexpr u32 UC_ARM64_REG_Q0 = 34;
-constexpr u32 FPSCR_REGISTER = 66;
+const u32 LR_REGISTER = 30;
+const u32 SP_REGISTER = 31;
+const u32 PC_REGISTER = 32;
+const u32 CPSR_REGISTER = 33;
+const u32 UC_ARM64_REG_Q0 = 34;
+const u32 FPSCR_REGISTER = 66;
 
 // TODO/WiP - Used while working on support for FPU
-constexpr u32 TODO_DUMMY_REG_997 = 997;
-constexpr u32 TODO_DUMMY_REG_998 = 998;
+const u32 TODO_DUMMY_REG_997 = 997;
+const u32 TODO_DUMMY_REG_998 = 998;
 
 // For sample XML files see the GDB source /gdb/features
 // GDB also wants the l character at the start
 // This XML defines what the registers are for this specific ARM device
-constexpr char target_xml[] =
+static const char* target_xml =
     R"(l<?xml version="1.0"?>
 <!DOCTYPE target SYSTEM "gdb-target.dtd">
 <target version="1.0">
@@ -142,28 +141,30 @@ constexpr char target_xml[] =
 </target>
 )";
 
-int gdbserver_socket = -1;
+namespace GDBStub {
 
-u8 command_buffer[GDB_BUFFER_SIZE];
-u32 command_length;
+static int gdbserver_socket = -1;
 
-u32 latest_signal = 0;
-bool memory_break = false;
+static u8 command_buffer[GDB_BUFFER_SIZE];
+static u32 command_length;
 
-Kernel::Thread* current_thread = nullptr;
-u32 current_core = 0;
+static u32 latest_signal = 0;
+static bool memory_break = false;
+
+static Kernel::Thread* current_thread = nullptr;
+static u32 current_core = 0;
 
 // Binding to a port within the reserved ports range (0-1023) requires root permissions,
 // so default to a port outside of that range.
-u16 gdbstub_port = 24689;
+static u16 gdbstub_port = 24689;
 
-bool halt_loop = true;
-bool step_loop = false;
-bool send_trap = false;
+static bool halt_loop = true;
+static bool step_loop = false;
+static bool send_trap = false;
 
 // If set to false, the server will never be started and no
 // gdbstub-related functions will be executed.
-std::atomic<bool> server_enabled(false);
+static std::atomic<bool> server_enabled(false);
 
 #ifdef _WIN32
 WSADATA InitData;
@@ -171,25 +172,23 @@ WSADATA InitData;
 
 struct Breakpoint {
     bool active;
-    VAddr addr;
+    PAddr addr;
     u64 len;
 };
 
-using BreakpointMap = std::map<VAddr, Breakpoint>;
-BreakpointMap breakpoints_execute;
-BreakpointMap breakpoints_read;
-BreakpointMap breakpoints_write;
+static std::map<u64, Breakpoint> breakpoints_execute;
+static std::map<u64, Breakpoint> breakpoints_read;
+static std::map<u64, Breakpoint> breakpoints_write;
 
 struct Module {
     std::string name;
-    VAddr beg;
-    VAddr end;
+    PAddr beg;
+    PAddr end;
 };
 
-std::vector<Module> modules;
-} // Anonymous namespace
+static std::vector<Module> modules;
 
-void RegisterModule(std::string name, VAddr beg, VAddr end, bool add_elf_ext) {
+void RegisterModule(std::string name, PAddr beg, PAddr end, bool add_elf_ext) {
     Module module;
     if (add_elf_ext) {
         Common::SplitPath(name, nullptr, &module.name, nullptr);
@@ -420,11 +419,11 @@ static u8 CalculateChecksum(const u8* buffer, size_t length) {
 }
 
 /**
- * Get the map of breakpoints for a given breakpoint type.
+ * Get the list of breakpoints for a given breakpoint type.
  *
- * @param type Type of breakpoint map.
+ * @param type Type of breakpoint list.
  */
-static BreakpointMap& GetBreakpointMap(BreakpointType type) {
+static std::map<u64, Breakpoint>& GetBreakpointList(BreakpointType type) {
     switch (type) {
     case BreakpointType::Execute:
         return breakpoints_execute;
@@ -443,22 +442,20 @@ static BreakpointMap& GetBreakpointMap(BreakpointType type) {
  * @param type Type of breakpoint.
  * @param addr Address of breakpoint.
  */
-static void RemoveBreakpoint(BreakpointType type, VAddr addr) {
-    BreakpointMap& p = GetBreakpointMap(type);
+static void RemoveBreakpoint(BreakpointType type, PAddr addr) {
+    std::map<u64, Breakpoint>& p = GetBreakpointList(type);
 
-    const auto bp = p.find(addr);
-    if (bp == p.end()) {
-        return;
+    auto bp = p.find(static_cast<u64>(addr));
+    if (bp != p.end()) {
+        LOG_DEBUG(Debug_GDBStub, "gdb: removed a breakpoint: {:016X} bytes at {:016X} of type {}",
+                  bp->second.len, bp->second.addr, static_cast<int>(type));
+        p.erase(static_cast<u64>(addr));
     }
-
-    LOG_DEBUG(Debug_GDBStub, "gdb: removed a breakpoint: {:016X} bytes at {:016X} of type {}",
-              bp->second.len, bp->second.addr, static_cast<int>(type));
-    p.erase(addr);
 }
 
-BreakpointAddress GetNextBreakpointFromAddress(VAddr addr, BreakpointType type) {
-    const BreakpointMap& p = GetBreakpointMap(type);
-    const auto next_breakpoint = p.lower_bound(addr);
+BreakpointAddress GetNextBreakpointFromAddress(PAddr addr, BreakpointType type) {
+    std::map<u64, Breakpoint>& p = GetBreakpointList(type);
+    auto next_breakpoint = p.lower_bound(static_cast<u64>(addr));
     BreakpointAddress breakpoint;
 
     if (next_breakpoint != p.end()) {
@@ -472,38 +469,36 @@ BreakpointAddress GetNextBreakpointFromAddress(VAddr addr, BreakpointType type)
     return breakpoint;
 }
 
-bool CheckBreakpoint(VAddr addr, BreakpointType type) {
+bool CheckBreakpoint(PAddr addr, BreakpointType type) {
     if (!IsConnected()) {
         return false;
     }
 
-    const BreakpointMap& p = GetBreakpointMap(type);
-    const auto bp = p.find(addr);
+    std::map<u64, Breakpoint>& p = GetBreakpointList(type);
 
-    if (bp == p.end()) {
-        return false;
-    }
+    auto bp = p.find(static_cast<u64>(addr));
+    if (bp != p.end()) {
+        u64 len = bp->second.len;
 
-    u64 len = bp->second.len;
+        // IDA Pro defaults to 4-byte breakpoints for all non-hardware breakpoints
+        // no matter if it's a 4-byte or 2-byte instruction. When you execute a
+        // Thumb instruction with a 4-byte breakpoint set, it will set a breakpoint on
+        // two instructions instead of the single instruction you placed the breakpoint
+        // on. So, as a way to make sure that execution breakpoints are only breaking
+        // on the instruction that was specified, set the length of an execution
+        // breakpoint to 1. This should be fine since the CPU should never begin executing
+        // an instruction anywhere except the beginning of the instruction.
+        if (type == BreakpointType::Execute) {
+            len = 1;
+        }
 
-    // IDA Pro defaults to 4-byte breakpoints for all non-hardware breakpoints
-    // no matter if it's a 4-byte or 2-byte instruction. When you execute a
-    // Thumb instruction with a 4-byte breakpoint set, it will set a breakpoint on
-    // two instructions instead of the single instruction you placed the breakpoint
-    // on. So, as a way to make sure that execution breakpoints are only breaking
-    // on the instruction that was specified, set the length of an execution
-    // breakpoint to 1. This should be fine since the CPU should never begin executing
-    // an instruction anywhere except the beginning of the instruction.
-    if (type == BreakpointType::Execute) {
-        len = 1;
-    }
-
-    if (bp->second.active && (addr >= bp->second.addr && addr < bp->second.addr + len)) {
-        LOG_DEBUG(Debug_GDBStub,
-                  "Found breakpoint type {} @ {:016X}, range: {:016X}"
-                  " - {:016X} ({:X} bytes)",
-                  static_cast<int>(type), addr, bp->second.addr, bp->second.addr + len, len);
-        return true;
+        if (bp->second.active && (addr >= bp->second.addr && addr < bp->second.addr + len)) {
+            LOG_DEBUG(Debug_GDBStub,
+                      "Found breakpoint type {} @ {:016X}, range: {:016X}"
+                      " - {:016X} ({:X} bytes)",
+                      static_cast<int>(type), addr, bp->second.addr, bp->second.addr + len, len);
+            return true;
+        }
     }
 
     return false;
@@ -981,8 +976,8 @@ static void Continue() {
  * @param addr Address of breakpoint.
  * @param len Length of breakpoint.
  */
-static bool CommitBreakpoint(BreakpointType type, VAddr addr, u64 len) {
-    BreakpointMap& p = GetBreakpointMap(type);
+static bool CommitBreakpoint(BreakpointType type, PAddr addr, u64 len) {
+    std::map<u64, Breakpoint>& p = GetBreakpointList(type);
 
     Breakpoint breakpoint;
     breakpoint.active = true;
@@ -1021,7 +1016,7 @@ static void AddBreakpoint() {
 
     auto start_offset = command_buffer + 3;
     auto addr_pos = std::find(start_offset, command_buffer + command_length, ',');
-    VAddr addr = HexToLong(start_offset, static_cast<u64>(addr_pos - start_offset));
+    PAddr addr = HexToLong(start_offset, static_cast<u64>(addr_pos - start_offset));
 
     start_offset = addr_pos + 1;
     u64 len =
@@ -1070,7 +1065,7 @@ static void RemoveBreakpoint() {
 
     auto start_offset = command_buffer + 3;
     auto addr_pos = std::find(start_offset, command_buffer + command_length, ',');
-    VAddr addr = HexToLong(start_offset, static_cast<u64>(addr_pos - start_offset));
+    PAddr addr = HexToLong(start_offset, static_cast<u64>(addr_pos - start_offset));
 
     if (type == BreakpointType::Access) {
         // Access is made up of Read and Write types, so add both breakpoints

src/core/gdbstub/gdbstub.h

@@ -22,7 +22,7 @@ enum class BreakpointType {
 };
 
 struct BreakpointAddress {
-    VAddr address;
+    PAddr address;
     BreakpointType type;
 };
 
@@ -53,7 +53,7 @@ bool IsServerEnabled();
 bool IsConnected();
 
 /// Register module.
-void RegisterModule(std::string name, VAddr beg, VAddr end, bool add_elf_ext = true);
+void RegisterModule(std::string name, PAddr beg, PAddr end, bool add_elf_ext = true);
 
 /**
  * Signal to the gdbstub server that it should halt CPU execution.
@@ -74,7 +74,7 @@ void HandlePacket();
  * @param addr Address to search from.
  * @param type Type of breakpoint.
  */
-BreakpointAddress GetNextBreakpointFromAddress(VAddr addr, GDBStub::BreakpointType type);
+BreakpointAddress GetNextBreakpointFromAddress(PAddr addr, GDBStub::BreakpointType type);
 
 /**
  * Check if a breakpoint of the specified type exists at the given address.
@@ -82,7 +82,7 @@ BreakpointAddress GetNextBreakpointFromAddress(VAddr addr, GDBStub::BreakpointTy
  * @param addr Address of breakpoint.
  * @param type Type of breakpoint.
  */
-bool CheckBreakpoint(VAddr addr, GDBStub::BreakpointType type);
+bool CheckBreakpoint(PAddr addr, GDBStub::BreakpointType type);
 
 /// If set to true, the CPU will halt at the beginning of the next CPU loop.
 bool GetCpuHaltFlag();

src/core/hle/ipc_helpers.h

@@ -5,18 +5,15 @@
 #pragma once
 
 #include <array>
-#include <cstring>
-#include <memory>
 #include <tuple>
 #include <type_traits>
 #include <utility>
-#include "common/assert.h"
-#include "common/common_types.h"
 #include "core/hle/ipc.h"
 #include "core/hle/kernel/client_port.h"
 #include "core/hle/kernel/client_session.h"
+#include "core/hle/kernel/handle_table.h"
 #include "core/hle/kernel/hle_ipc.h"
-#include "core/hle/kernel/object.h"
+#include "core/hle/kernel/kernel.h"
 #include "core/hle/kernel/server_port.h"
 
 namespace IPC {

src/core/hle/kernel/address_arbiter.cpp

@@ -2,17 +2,15 @@
 // Licensed under GPLv2 or any later version
 // Refer to the license.txt file included.
 
-#include <algorithm>
-#include <vector>
-
 #include "common/assert.h"
+#include "common/common_funcs.h"
 #include "common/common_types.h"
 #include "core/core.h"
 #include "core/hle/kernel/errors.h"
-#include "core/hle/kernel/object.h"
+#include "core/hle/kernel/kernel.h"
 #include "core/hle/kernel/process.h"
 #include "core/hle/kernel/thread.h"
-#include "core/hle/result.h"
+#include "core/hle/lock.h"
 #include "core/memory.h"
 
 namespace Kernel {
@@ -32,8 +30,9 @@ static ResultCode WaitForAddress(VAddr address, s64 timeout) {
 }
 
 // Gets the threads waiting on an address.
-static std::vector<SharedPtr<Thread>> GetThreadsWaitingOnAddress(VAddr address) {
-    const auto RetrieveWaitingThreads =
+static void GetThreadsWaitingOnAddress(std::vector<SharedPtr<Thread>>& waiting_threads,
+                                       VAddr address) {
+    auto RetrieveWaitingThreads =
         [](size_t core_index, std::vector<SharedPtr<Thread>>& waiting_threads, VAddr arb_addr) {
             const auto& scheduler = Core::System::GetInstance().Scheduler(core_index);
             auto& thread_list = scheduler->GetThreadList();
@@ -44,20 +43,16 @@ static std::vector<SharedPtr<Thread>> GetThreadsWaitingOnAddress(VAddr address)
             }
         };
 
-    // Retrieve all threads that are waiting for this address.
-    std::vector<SharedPtr<Thread>> threads;
-    RetrieveWaitingThreads(0, threads, address);
-    RetrieveWaitingThreads(1, threads, address);
-    RetrieveWaitingThreads(2, threads, address);
-    RetrieveWaitingThreads(3, threads, address);
-
+    // Retrieve a list of all threads that are waiting for this address.
+    RetrieveWaitingThreads(0, waiting_threads, address);
+    RetrieveWaitingThreads(1, waiting_threads, address);
+    RetrieveWaitingThreads(2, waiting_threads, address);
+    RetrieveWaitingThreads(3, waiting_threads, address);
     // Sort them by priority, such that the highest priority ones come first.
-    std::sort(threads.begin(), threads.end(),
+    std::sort(waiting_threads.begin(), waiting_threads.end(),
               [](const SharedPtr<Thread>& lhs, const SharedPtr<Thread>& rhs) {
                   return lhs->current_priority < rhs->current_priority;
               });
-
-    return threads;
 }
 
 // Wake up num_to_wake (or all) threads in a vector.
@@ -79,7 +74,9 @@ static void WakeThreads(std::vector<SharedPtr<Thread>>& waiting_threads, s32 num
 
 // Signals an address being waited on.
 ResultCode SignalToAddress(VAddr address, s32 num_to_wake) {
-    std::vector<SharedPtr<Thread>> waiting_threads = GetThreadsWaitingOnAddress(address);
+    // Get threads waiting on the address.
+    std::vector<SharedPtr<Thread>> waiting_threads;
+    GetThreadsWaitingOnAddress(waiting_threads, address);
 
     WakeThreads(waiting_threads, num_to_wake);
     return RESULT_SUCCESS;
@@ -111,11 +108,12 @@ ResultCode ModifyByWaitingCountAndSignalToAddressIfEqual(VAddr address, s32 valu
     }
 
     // Get threads waiting on the address.
-    std::vector<SharedPtr<Thread>> waiting_threads = GetThreadsWaitingOnAddress(address);
+    std::vector<SharedPtr<Thread>> waiting_threads;
+    GetThreadsWaitingOnAddress(waiting_threads, address);
 
     // Determine the modified value depending on the waiting count.
     s32 updated_value;
-    if (waiting_threads.empty()) {
+    if (waiting_threads.size() == 0) {
         updated_value = value - 1;
     } else if (num_to_wake <= 0 || waiting_threads.size() <= static_cast<u32>(num_to_wake)) {
         updated_value = value + 1;

src/core/hle/kernel/address_arbiter.h

@@ -4,9 +4,7 @@
 
 #pragma once
 
-#include "common/common_types.h"
-
-union ResultCode;
+#include "core/hle/result.h"
 
 namespace Kernel {
 

src/core/hle/kernel/client_port.cpp

@@ -2,13 +2,12 @@
 // Licensed under GPLv2 or any later version
 // Refer to the license.txt file included.
 
-#include <tuple>
-
+#include "common/assert.h"
 #include "core/hle/kernel/client_port.h"
 #include "core/hle/kernel/client_session.h"
 #include "core/hle/kernel/errors.h"
 #include "core/hle/kernel/hle_ipc.h"
-#include "core/hle/kernel/object.h"
+#include "core/hle/kernel/kernel.h"
 #include "core/hle/kernel/server_port.h"
 #include "core/hle/kernel/server_session.h"
 

src/core/hle/kernel/client_port.h

@@ -6,7 +6,7 @@
 
 #include <string>
 #include "common/common_types.h"
-#include "core/hle/kernel/object.h"
+#include "core/hle/kernel/kernel.h"
 #include "core/hle/result.h"
 
 namespace Kernel {

src/core/hle/kernel/client_session.cpp

@@ -2,6 +2,8 @@
 // Licensed under GPLv2 or any later version
 // Refer to the license.txt file included.
 
+#include "common/assert.h"
+
 #include "core/hle/kernel/client_session.h"
 #include "core/hle/kernel/errors.h"
 #include "core/hle/kernel/hle_ipc.h"

src/core/hle/kernel/client_session.h

@@ -7,7 +7,7 @@
 #include <memory>
 #include <string>
 #include "common/common_types.h"
-#include "core/hle/kernel/object.h"
+#include "core/hle/kernel/kernel.h"
 #include "core/hle/result.h"
 
 namespace Kernel {

src/core/hle/kernel/event.cpp

@@ -3,9 +3,11 @@
 // Refer to the license.txt file included.
 
 #include <algorithm>
+#include <map>
+#include <vector>
 #include "common/assert.h"
 #include "core/hle/kernel/event.h"
-#include "core/hle/kernel/object.h"
+#include "core/hle/kernel/kernel.h"
 #include "core/hle/kernel/thread.h"
 
 namespace Kernel {

src/core/hle/kernel/event.h

@@ -5,7 +5,7 @@
 #pragma once
 
 #include "common/common_types.h"
-#include "core/hle/kernel/object.h"
+#include "core/hle/kernel/kernel.h"
 #include "core/hle/kernel/wait_object.h"
 
 namespace Kernel {
@@ -31,9 +31,10 @@ public:
         return HANDLE_TYPE;
     }
 
-    ResetType GetResetType() const {
-        return reset_type;
-    }
+    ResetType reset_type; ///< Current ResetType
+
+    bool signaled;    ///< Whether the event has already been signaled
+    std::string name; ///< Name of event (optional)
 
     bool ShouldWait(Thread* thread) const override;
     void Acquire(Thread* thread) override;
@@ -46,11 +47,6 @@ public:
 private:
     Event();
     ~Event() override;
-
-    ResetType reset_type; ///< Current ResetType
-
-    bool signaled;    ///< Whether the event has already been signaled
-    std::string name; ///< Name of event (optional)
 };
 
 } // namespace Kernel

src/core/hle/kernel/handle_table.cpp

@@ -8,6 +8,7 @@
 #include "core/core.h"
 #include "core/hle/kernel/errors.h"
 #include "core/hle/kernel/handle_table.h"
+#include "core/hle/kernel/kernel.h"
 #include "core/hle/kernel/process.h"
 #include "core/hle/kernel/thread.h"
 

src/core/hle/kernel/handle_table.h

@@ -7,7 +7,7 @@
 #include <array>
 #include <cstddef>
 #include "common/common_types.h"
-#include "core/hle/kernel/object.h"
+#include "core/hle/kernel/kernel.h"
 #include "core/hle/result.h"
 
 namespace Kernel {

src/core/hle/kernel/hle_ipc.cpp

@@ -2,22 +2,17 @@
 // Licensed under GPLv2 or any later version
 // Refer to the license.txt file included.
 
-#include <algorithm>
-#include <array>
-#include <sstream>
 #include <utility>
 
 #include <boost/range/algorithm_ext/erase.hpp>
-
 #include "common/assert.h"
 #include "common/common_funcs.h"
 #include "common/common_types.h"
-#include "common/logging/log.h"
 #include "core/hle/ipc_helpers.h"
 #include "core/hle/kernel/event.h"
 #include "core/hle/kernel/handle_table.h"
 #include "core/hle/kernel/hle_ipc.h"
-#include "core/hle/kernel/object.h"
+#include "core/hle/kernel/kernel.h"
 #include "core/hle/kernel/process.h"
 #include "core/hle/kernel/server_session.h"
 #include "core/memory.h"

src/core/hle/kernel/hle_ipc.h

@@ -5,6 +5,7 @@
 #pragma once
 
 #include <array>
+#include <iterator>
 #include <memory>
 #include <string>
 #include <type_traits>
@@ -13,7 +14,7 @@
 #include "common/common_types.h"
 #include "common/swap.h"
 #include "core/hle/ipc.h"
-#include "core/hle/kernel/object.h"
+#include "core/hle/kernel/kernel.h"
 #include "core/hle/kernel/server_session.h"
 #include "core/hle/kernel/thread.h"
 

src/core/hle/kernel/kernel.cpp

@@ -4,6 +4,8 @@
 
 #include "core/hle/kernel/handle_table.h"
 #include "core/hle/kernel/kernel.h"
+#include "core/hle/kernel/memory.h"
+#include "core/hle/kernel/object_address_table.h"
 #include "core/hle/kernel/process.h"
 #include "core/hle/kernel/resource_limit.h"
 #include "core/hle/kernel/thread.h"
@@ -14,7 +16,9 @@ namespace Kernel {
 unsigned int Object::next_object_id;
 
 /// Initialize the kernel
-void Init() {
+void Init(u32 system_mode) {
+    Kernel::MemoryInit(system_mode);
+
     Kernel::ResourceLimitsInit();
     Kernel::ThreadingInit();
     Kernel::TimersInit();
@@ -29,11 +33,13 @@ void Init() {
 void Shutdown() {
     // Free all kernel objects
     g_handle_table.Clear();
+    g_object_address_table.Clear();
 
     Kernel::ThreadingShutdown();
 
     Kernel::TimersShutdown();
     Kernel::ResourceLimitsShutdown();
+    Kernel::MemoryShutdown();
 }
 
 } // namespace Kernel

src/core/hle/kernel/kernel.h

@@ -4,12 +4,122 @@
 
 #pragma once
 
+#include <cstddef>
+#include <string>
+#include <utility>
+#include <boost/smart_ptr/intrusive_ptr.hpp>
+#include "common/assert.h"
 #include "common/common_types.h"
 
 namespace Kernel {
 
+using Handle = u32;
+
+enum class HandleType : u32 {
+    Unknown,
+    Event,
+    SharedMemory,
+    Thread,
+    Process,
+    AddressArbiter,
+    Timer,
+    ResourceLimit,
+    CodeSet,
+    ClientPort,
+    ServerPort,
+    ClientSession,
+    ServerSession,
+};
+
+enum class ResetType {
+    OneShot,
+    Sticky,
+    Pulse,
+};
+
+class Object : NonCopyable {
+public:
+    virtual ~Object() {}
+
+    /// Returns a unique identifier for the object. For debugging purposes only.
+    unsigned int GetObjectId() const {
+        return object_id;
+    }
+
+    virtual std::string GetTypeName() const {
+        return "[BAD KERNEL OBJECT TYPE]";
+    }
+    virtual std::string GetName() const {
+        return "[UNKNOWN KERNEL OBJECT]";
+    }
+    virtual Kernel::HandleType GetHandleType() const = 0;
+
+    /**
+     * Check if a thread can wait on the object
+     * @return True if a thread can wait on the object, otherwise false
+     */
+    bool IsWaitable() const {
+        switch (GetHandleType()) {
+        case HandleType::Event:
+        case HandleType::Thread:
+        case HandleType::Timer:
+        case HandleType::ServerPort:
+        case HandleType::ServerSession:
+            return true;
+
+        case HandleType::Unknown:
+        case HandleType::SharedMemory:
+        case HandleType::Process:
+        case HandleType::AddressArbiter:
+        case HandleType::ResourceLimit:
+        case HandleType::CodeSet:
+        case HandleType::ClientPort:
+        case HandleType::ClientSession:
+            return false;
+        }
+
+        UNREACHABLE();
+    }
+
+public:
+    static unsigned int next_object_id;
+
+private:
+    friend void intrusive_ptr_add_ref(Object*);
+    friend void intrusive_ptr_release(Object*);
+
+    unsigned int ref_count = 0;
+    unsigned int object_id = next_object_id++;
+};
+
+// Special functions used by boost::instrusive_ptr to do automatic ref-counting
+inline void intrusive_ptr_add_ref(Object* object) {
+    ++object->ref_count;
+}
+
+inline void intrusive_ptr_release(Object* object) {
+    if (--object->ref_count == 0) {
+        delete object;
+    }
+}
+
+template <typename T>
+using SharedPtr = boost::intrusive_ptr<T>;
+
+/**
+ * Attempts to downcast the given Object pointer to a pointer to T.
+ * @return Derived pointer to the object, or `nullptr` if `object` isn't of type T.
+ */
+template <typename T>
+inline SharedPtr<T> DynamicObjectCast(SharedPtr<Object> object) {
+    if (object != nullptr && object->GetHandleType() == T::HANDLE_TYPE) {
+        return boost::static_pointer_cast<T>(std::move(object));
+    }
+    return nullptr;
+}
+
 /// Initialize the kernel with the specified system mode.
-void Init();
+void Init(u32 system_mode);
 
 /// Shutdown the kernel
 void Shutdown();

src/core/hle/kernel/memory.cpp

@@ -0,0 +1,92 @@
+// Copyright 2014 Citra Emulator Project
+// Licensed under GPLv2 or any later version
+// Refer to the license.txt file included.
+
+#include <algorithm>
+#include <cinttypes>
+#include <map>
+#include <memory>
+#include <utility>
+#include <vector>
+#include "common/assert.h"
+#include "common/common_types.h"
+#include "common/logging/log.h"
+#include "core/hle/kernel/memory.h"
+#include "core/hle/kernel/vm_manager.h"
+#include "core/hle/result.h"
+#include "core/memory.h"
+#include "core/memory_setup.h"
+
+////////////////////////////////////////////////////////////////////////////////////////////////////
+
+namespace Kernel {
+
+MemoryRegionInfo memory_regions[3];
+
+/// Size of the APPLICATION, SYSTEM and BASE memory regions (respectively) for each system
+/// memory configuration type.
+static const u32 memory_region_sizes[8][3] = {
+    // Old 3DS layouts
+    {0x04000000, 0x02C00000, 0x01400000}, // 0
+    {/* This appears to be unused. */},   // 1
+    {0x06000000, 0x00C00000, 0x01400000}, // 2
+    {0x05000000, 0x01C00000, 0x01400000}, // 3
+    {0x04800000, 0x02400000, 0x01400000}, // 4
+    {0x02000000, 0x04C00000, 0x01400000}, // 5
+
+    // New 3DS layouts
+    {0x07C00000, 0x06400000, 0x02000000}, // 6
+    {0x0B200000, 0x02E00000, 0x02000000}, // 7
+};
+
+void MemoryInit(u32 mem_type) {
+    // TODO(yuriks): On the n3DS, all o3DS configurations (<=5) are forced to 6 instead.
+    ASSERT_MSG(mem_type <= 5, "New 3DS memory configuration aren't supported yet!");
+    ASSERT(mem_type != 1);
+
+    // The kernel allocation regions (APPLICATION, SYSTEM and BASE) are laid out in sequence, with
+    // the sizes specified in the memory_region_sizes table.
+    VAddr base = 0;
+    for (int i = 0; i < 3; ++i) {
+        memory_regions[i].base = base;
+        memory_regions[i].size = memory_region_sizes[mem_type][i];
+        memory_regions[i].used = 0;
+        memory_regions[i].linear_heap_memory = std::make_shared<std::vector<u8>>();
+        // Reserve enough space for this region of FCRAM.
+        // We do not want this block of memory to be relocated when allocating from it.
+        memory_regions[i].linear_heap_memory->reserve(memory_regions[i].size);
+
+        base += memory_regions[i].size;
+    }
+
+    // We must've allocated the entire FCRAM by the end
+    ASSERT(base == Memory::FCRAM_SIZE);
+}
+
+void MemoryShutdown() {
+    for (auto& region : memory_regions) {
+        region.base = 0;
+        region.size = 0;
+        region.used = 0;
+        region.linear_heap_memory = nullptr;
+    }
+}
+
+MemoryRegionInfo* GetMemoryRegion(MemoryRegion region) {
+    switch (region) {
+    case MemoryRegion::APPLICATION:
+        return &memory_regions[0];
+    case MemoryRegion::SYSTEM:
+        return &memory_regions[1];
+    case MemoryRegion::BASE:
+        return &memory_regions[2];
+    default:
+        UNREACHABLE();
+    }
+}
+
+void HandleSpecialMapping(VMManager& address_space, const AddressMapping& mapping) {}
+
+void MapSharedPages(VMManager& address_space) {}
+
+} // namespace Kernel

src/core/hle/kernel/memory.h

@@ -0,0 +1,31 @@
+// Copyright 2014 Citra 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"
+#include "core/hle/kernel/process.h"
+
+namespace Kernel {
+
+class VMManager;
+
+struct MemoryRegionInfo {
+    u64 base; // Not an address, but offset from start of FCRAM
+    u64 size;
+    u64 used;
+
+    std::shared_ptr<std::vector<u8>> linear_heap_memory;
+};
+
+void MemoryInit(u32 mem_type);
+void MemoryShutdown();
+MemoryRegionInfo* GetMemoryRegion(MemoryRegion region);
+
+void HandleSpecialMapping(VMManager& address_space, const AddressMapping& mapping);
+void MapSharedPages(VMManager& address_space);
+
+extern MemoryRegionInfo memory_regions[3];
+} // namespace Kernel

src/core/hle/kernel/mutex.cpp

@@ -3,19 +3,16 @@
 // Refer to the license.txt file included.
 
 #include <map>
-#include <utility>
 #include <vector>
-
 #include <boost/range/algorithm_ext/erase.hpp>
-
 #include "common/assert.h"
 #include "core/core.h"
 #include "core/hle/kernel/errors.h"
 #include "core/hle/kernel/handle_table.h"
+#include "core/hle/kernel/kernel.h"
 #include "core/hle/kernel/mutex.h"
-#include "core/hle/kernel/object.h"
+#include "core/hle/kernel/object_address_table.h"
 #include "core/hle/kernel/thread.h"
-#include "core/hle/result.h"
 
 namespace Kernel {
 

src/core/hle/kernel/mutex.h

@@ -4,10 +4,12 @@
 
 #pragma once
 
+#include <string>
 #include "common/common_types.h"
-#include "core/hle/kernel/object.h"
-
-union ResultCode;
+#include "common/swap.h"
+#include "core/hle/kernel/kernel.h"
+#include "core/hle/kernel/wait_object.h"
+#include "core/hle/result.h"
 
 namespace Kernel {
 

src/core/hle/kernel/object.cpp

@@ -1,35 +0,0 @@
-// Copyright 2018 Citra Emulator Project
-// Licensed under GPLv2 or any later version
-// Refer to the license.txt file included.
-
-#include "common/assert.h"
-#include "core/hle/kernel/object.h"
-
-namespace Kernel {
-
-Object::~Object() = default;
-
-bool Object::IsWaitable() const {
-    switch (GetHandleType()) {
-    case HandleType::Event:
-    case HandleType::Thread:
-    case HandleType::Timer:
-    case HandleType::ServerPort:
-    case HandleType::ServerSession:
-        return true;
-
-    case HandleType::Unknown:
-    case HandleType::SharedMemory:
-    case HandleType::Process:
-    case HandleType::AddressArbiter:
-    case HandleType::ResourceLimit:
-    case HandleType::CodeSet:
-    case HandleType::ClientPort:
-    case HandleType::ClientSession:
-        return false;
-    }
-
-    UNREACHABLE();
-}
-
-} // namespace Kernel

src/core/hle/kernel/object.h

@@ -1,100 +0,0 @@
-// Copyright 2018 Citra Emulator Project
-// Licensed under GPLv2 or any later version
-// Refer to the license.txt file included.
-
-#pragma once
-
-#include <string>
-#include <utility>
-
-#include <boost/smart_ptr/intrusive_ptr.hpp>
-
-#include "common/common_types.h"
-
-namespace Kernel {
-
-using Handle = u32;
-
-enum class HandleType : u32 {
-    Unknown,
-    Event,
-    SharedMemory,
-    Thread,
-    Process,
-    AddressArbiter,
-    Timer,
-    ResourceLimit,
-    CodeSet,
-    ClientPort,
-    ServerPort,
-    ClientSession,
-    ServerSession,
-};
-
-enum class ResetType {
-    OneShot,
-    Sticky,
-    Pulse,
-};
-
-class Object : NonCopyable {
-public:
-    virtual ~Object();
-
-    /// Returns a unique identifier for the object. For debugging purposes only.
-    unsigned int GetObjectId() const {
-        return object_id;
-    }
-
-    virtual std::string GetTypeName() const {
-        return "[BAD KERNEL OBJECT TYPE]";
-    }
-    virtual std::string GetName() const {
-        return "[UNKNOWN KERNEL OBJECT]";
-    }
-    virtual HandleType GetHandleType() const = 0;
-
-    /**
-     * Check if a thread can wait on the object
-     * @return True if a thread can wait on the object, otherwise false
-     */
-    bool IsWaitable() const;
-
-public:
-    static unsigned int next_object_id;
-
-private:
-    friend void intrusive_ptr_add_ref(Object*);
-    friend void intrusive_ptr_release(Object*);
-
-    unsigned int ref_count = 0;
-    unsigned int object_id = next_object_id++;
-};
-
-// Special functions used by boost::instrusive_ptr to do automatic ref-counting
-inline void intrusive_ptr_add_ref(Object* object) {
-    ++object->ref_count;
-}
-
-inline void intrusive_ptr_release(Object* object) {
-    if (--object->ref_count == 0) {
-        delete object;
-    }
-}
-
-template <typename T>
-using SharedPtr = boost::intrusive_ptr<T>;
-
-/**
- * Attempts to downcast the given Object pointer to a pointer to T.
- * @return Derived pointer to the object, or `nullptr` if `object` isn't of type T.
- */
-template <typename T>
-inline SharedPtr<T> DynamicObjectCast(SharedPtr<Object> object) {
-    if (object != nullptr && object->GetHandleType() == T::HANDLE_TYPE) {
-        return boost::static_pointer_cast<T>(std::move(object));
-    }
-    return nullptr;
-}
-
-} // namespace Kernel

src/core/hle/kernel/object_address_table.cpp

@@ -0,0 +1,36 @@
+// Copyright 2018 yuzu emulator team
+// Licensed under GPLv2 or any later version
+// Refer to the license.txt file included.
+
+#include <utility>
+
+#include "common/assert.h"
+#include "core/hle/kernel/object_address_table.h"
+
+namespace Kernel {
+
+ObjectAddressTable g_object_address_table;
+
+void ObjectAddressTable::Insert(VAddr addr, SharedPtr<Object> obj) {
+    ASSERT_MSG(objects.find(addr) == objects.end(), "Object already exists with addr=0x{:X}", addr);
+    objects[addr] = std::move(obj);
+}
+
+void ObjectAddressTable::Close(VAddr addr) {
+    ASSERT_MSG(objects.find(addr) != objects.end(), "Object does not exist with addr=0x{:X}", addr);
+    objects.erase(addr);
+}
+
+SharedPtr<Object> ObjectAddressTable::GetGeneric(VAddr addr) const {
+    auto iter = objects.find(addr);
+    if (iter != objects.end()) {
+        return iter->second;
+    }
+    return {};
+}
+
+void ObjectAddressTable::Clear() {
+    objects.clear();
+}
+
+} // namespace Kernel

src/core/hle/kernel/object_address_table.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 <map>
+#include "common/common_types.h"
+#include "core/hle/kernel/kernel.h"
+
+namespace Kernel {
+
+/**
+ * This class is used to keep a table of Kernel objects and their respective addresses in emulated
+ * memory. For certain Switch SVCs, Kernel objects are referenced by an address to an object the
+ * guest application manages, so we use this table to look these kernel objects up. This is similiar
+ * to the HandleTable class.
+ */
+class ObjectAddressTable final : NonCopyable {
+public:
+    ObjectAddressTable() = default;
+
+    /**
+     * Inserts an object and address pair into the table.
+     */
+    void Insert(VAddr addr, SharedPtr<Object> obj);
+
+    /**
+     * Closes an object by its address, removing it from the table and decreasing the object's
+     * ref-count.
+     * @return `RESULT_SUCCESS` or one of the following errors:
+     *           - `ERR_INVALID_HANDLE`: an invalid handle was passed in.
+     */
+    void Close(VAddr addr);
+
+    /**
+     * Looks up an object by its address.
+     * @return Pointer to the looked-up object, or `nullptr` if the handle is not valid.
+     */
+    SharedPtr<Object> GetGeneric(VAddr addr) const;
+
+    /**
+     * Looks up an object by its address while verifying its type.
+     * @return Pointer to the looked-up object, or `nullptr` if the handle is not valid or its
+     *         type differs from the requested one.
+     */
+    template <class T>
+    SharedPtr<T> Get(VAddr addr) const {
+        return DynamicObjectCast<T>(GetGeneric(addr));
+    }
+
+    /// Closes all addresses held in this table.
+    void Clear();
+
+private:
+    /// Stores the Object referenced by the address
+    std::map<VAddr, SharedPtr<Object>> objects;
+};
+
+extern ObjectAddressTable g_object_address_table;
+
+} // namespace Kernel

src/core/hle/kernel/process.cpp

@@ -8,6 +8,7 @@
 #include "common/common_funcs.h"
 #include "common/logging/log.h"
 #include "core/hle/kernel/errors.h"
+#include "core/hle/kernel/memory.h"
 #include "core/hle/kernel/process.h"
 #include "core/hle/kernel/resource_limit.h"
 #include "core/hle/kernel/thread.h"
@@ -124,6 +125,14 @@ void Process::Run(VAddr entry_point, s32 main_thread_priority, u32 stack_size) {
                         std::make_shared<std::vector<u8>>(stack_size, 0), 0, stack_size,
                         MemoryState::Mapped)
         .Unwrap();
+    misc_memory_used += stack_size;
+    memory_region->used += stack_size;
+
+    // Map special address mappings
+    MapSharedPages(vm_manager);
+    for (const auto& mapping : address_mappings) {
+        HandleSpecialMapping(vm_manager, mapping);
+    }
 
     vm_manager.LogLayout();
     status = ProcessStatus::Running;
@@ -132,19 +141,37 @@ void Process::Run(VAddr entry_point, s32 main_thread_priority, u32 stack_size) {
 }
 
 void Process::LoadModule(SharedPtr<CodeSet> module_, VAddr base_addr) {
-    const auto MapSegment = [&](CodeSet::Segment& segment, VMAPermission permissions,
-                                MemoryState memory_state) {
+    memory_region = GetMemoryRegion(flags.memory_region);
+
+    auto MapSegment = [&](CodeSet::Segment& segment, VMAPermission permissions,
+                          MemoryState memory_state) {
         auto vma = vm_manager
                        .MapMemoryBlock(segment.addr + base_addr, module_->memory, segment.offset,
                                        segment.size, memory_state)
                        .Unwrap();
         vm_manager.Reprotect(vma, permissions);
+        misc_memory_used += segment.size;
+        memory_region->used += segment.size;
     };
 
     // Map CodeSet segments
-    MapSegment(module_->CodeSegment(), VMAPermission::ReadExecute, MemoryState::CodeStatic);
-    MapSegment(module_->RODataSegment(), VMAPermission::Read, MemoryState::CodeMutable);
-    MapSegment(module_->DataSegment(), VMAPermission::ReadWrite, MemoryState::CodeMutable);
+    MapSegment(module_->code, VMAPermission::ReadExecute, MemoryState::CodeStatic);
+    MapSegment(module_->rodata, VMAPermission::Read, MemoryState::CodeMutable);
+    MapSegment(module_->data, VMAPermission::ReadWrite, MemoryState::CodeMutable);
+}
+
+VAddr Process::GetLinearHeapAreaAddress() const {
+    // Starting from system version 8.0.0 a new linear heap layout is supported to allow usage of
+    // the extra RAM in the n3DS.
+    return kernel_version < 0x22C ? Memory::LINEAR_HEAP_VADDR : Memory::NEW_LINEAR_HEAP_VADDR;
+}
+
+VAddr Process::GetLinearHeapBase() const {
+    return GetLinearHeapAreaAddress() + memory_region->base;
+}
+
+VAddr Process::GetLinearHeapLimit() const {
+    return GetLinearHeapBase() + memory_region->size;
 }
 
 ResultVal<VAddr> Process::HeapAllocate(VAddr target, u64 size, VMAPermission perms) {
@@ -179,6 +206,7 @@ ResultVal<VAddr> Process::HeapAllocate(VAddr target, u64 size, VMAPermission per
     vm_manager.Reprotect(vma, perms);
 
     heap_used = size;
+    memory_region->used += size;
 
     return MakeResult<VAddr>(heap_end - size);
 }
@@ -198,6 +226,52 @@ ResultCode Process::HeapFree(VAddr target, u32 size) {
         return result;
 
     heap_used -= size;
+    memory_region->used -= size;
+
+    return RESULT_SUCCESS;
+}
+
+ResultVal<VAddr> Process::LinearAllocate(VAddr target, u32 size, VMAPermission perms) {
+    UNIMPLEMENTED();
+    return {};
+}
+
+ResultCode Process::LinearFree(VAddr target, u32 size) {
+    auto& linheap_memory = memory_region->linear_heap_memory;
+
+    if (target < GetLinearHeapBase() || target + size > GetLinearHeapLimit() ||
+        target + size < target) {
+
+        return ERR_INVALID_ADDRESS;
+    }
+
+    if (size == 0) {
+        return RESULT_SUCCESS;
+    }
+
+    VAddr heap_end = GetLinearHeapBase() + (u32)linheap_memory->size();
+    if (target + size > heap_end) {
+        return ERR_INVALID_ADDRESS_STATE;
+    }
+
+    ResultCode result = vm_manager.UnmapRange(target, size);
+    if (result.IsError())
+        return result;
+
+    linear_heap_used -= size;
+    memory_region->used -= size;
+
+    if (target + size == heap_end) {
+        // End of linear heap has been freed, so check what's the last allocated block in it and
+        // reduce the size.
+        auto vma = vm_manager.FindVMA(target);
+        ASSERT(vma != vm_manager.vma_map.end());
+        ASSERT(vma->second.type == VMAType::Free);
+        VAddr new_end = vma->second.base;
+        if (new_end >= GetLinearHeapBase()) {
+            linheap_memory->resize(new_end - GetLinearHeapBase());
+        }
+    }
 
     return RESULT_SUCCESS;
 }

src/core/hle/kernel/process.h

@@ -4,7 +4,6 @@
 
 #pragma once
 
-#include <array>
 #include <bitset>
 #include <cstddef>
 #include <memory>
@@ -13,7 +12,7 @@
 #include <boost/container/static_vector.hpp>
 #include "common/bit_field.h"
 #include "common/common_types.h"
-#include "core/hle/kernel/object.h"
+#include "core/hle/kernel/kernel.h"
 #include "core/hle/kernel/thread.h"
 #include "core/hle/kernel/vm_manager.h"
 
@@ -54,14 +53,9 @@ union ProcessFlags {
 enum class ProcessStatus { Created, Running, Exited };
 
 class ResourceLimit;
+struct MemoryRegionInfo;
 
 struct CodeSet final : public Object {
-    struct Segment {
-        size_t offset = 0;
-        VAddr addr = 0;
-        u32 size = 0;
-    };
-
     static SharedPtr<CodeSet> Create(std::string name);
 
     std::string GetTypeName() const override {
@@ -76,37 +70,23 @@ struct CodeSet final : public Object {
         return HANDLE_TYPE;
     }
 
-    Segment& CodeSegment() {
-        return segments[0];
-    }
-
-    const Segment& CodeSegment() const {
-        return segments[0];
-    }
-
-    Segment& RODataSegment() {
-        return segments[1];
-    }
-
-    const Segment& RODataSegment() const {
-        return segments[1];
-    }
-
-    Segment& DataSegment() {
-        return segments[2];
-    }
-
-    const Segment& DataSegment() const {
-        return segments[2];
-    }
+    /// Name of the process
+    std::string name;
 
     std::shared_ptr<std::vector<u8>> memory;
 
-    std::array<Segment, 3> segments;
-    VAddr entrypoint;
+    struct Segment {
+        size_t offset = 0;
+        VAddr addr = 0;
+        u32 size = 0;
+    };
 
-    /// Name of the process
-    std::string name;
+    Segment segments[3];
+    Segment& code = segments[0];
+    Segment& rodata = segments[1];
+    Segment& data = segments[2];
+
+    VAddr entrypoint;
 
 private:
     CodeSet();
@@ -183,11 +163,12 @@ public:
     // This makes deallocation and reallocation of holes fast and keeps process memory contiguous
     // in the emulator address space, allowing Memory::GetPointer to be reasonably safe.
     std::shared_ptr<std::vector<u8>> heap_memory;
-
     // The left/right bounds of the address space covered by heap_memory.
-    VAddr heap_start = 0;
-    VAddr heap_end = 0;
-    u64 heap_used = 0;
+    VAddr heap_start = 0, heap_end = 0;
+
+    u64 heap_used = 0, linear_heap_used = 0, misc_memory_used = 0;
+
+    MemoryRegionInfo* memory_region = nullptr;
 
     /// The Thread Local Storage area is allocated as processes create threads,
     /// each TLS area is 0x200 bytes, so one page (0x1000) is split up in 8 parts, and each part
@@ -198,9 +179,16 @@ public:
 
     std::string name;
 
+    VAddr GetLinearHeapAreaAddress() const;
+    VAddr GetLinearHeapBase() const;
+    VAddr GetLinearHeapLimit() const;
+
     ResultVal<VAddr> HeapAllocate(VAddr target, u64 size, VMAPermission perms);
     ResultCode HeapFree(VAddr target, u32 size);
 
+    ResultVal<VAddr> LinearAllocate(VAddr target, u32 size, VMAPermission perms);
+    ResultCode LinearFree(VAddr target, u32 size);
+
     ResultCode MirrorMemory(VAddr dst_addr, VAddr src_addr, u64 size);
 
     ResultCode UnmapMemory(VAddr dst_addr, VAddr src_addr, u64 size);

src/core/hle/kernel/resource_limit.h

@@ -5,7 +5,7 @@
 #pragma once
 
 #include "common/common_types.h"
-#include "core/hle/kernel/object.h"
+#include "core/hle/kernel/kernel.h"
 
 namespace Kernel {
 

src/core/hle/kernel/scheduler.cpp

@@ -2,12 +2,8 @@
 // Licensed under GPLv2 or any later version
 // Refer to the license.txt file included.
 
-#include <algorithm>
 #include <utility>
 
-#include "common/assert.h"
-#include "common/logging/log.h"
-#include "core/arm/arm_interface.h"
 #include "core/core.h"
 #include "core/core_timing.h"
 #include "core/hle/kernel/process.h"

src/core/hle/kernel/scheduler.h

@@ -8,11 +8,9 @@
 #include <vector>
 #include "common/common_types.h"
 #include "common/thread_queue_list.h"
-#include "core/hle/kernel/object.h"
+#include "core/arm/arm_interface.h"
 #include "core/hle/kernel/thread.h"
 
-class ARM_Interface;
-
 namespace Kernel {
 
 class Scheduler final {

src/core/hle/kernel/server_port.cpp

@@ -6,7 +6,7 @@
 #include "common/assert.h"
 #include "core/hle/kernel/client_port.h"
 #include "core/hle/kernel/errors.h"
-#include "core/hle/kernel/object.h"
+#include "core/hle/kernel/kernel.h"
 #include "core/hle/kernel/server_port.h"
 #include "core/hle/kernel/server_session.h"
 #include "core/hle/kernel/thread.h"

src/core/hle/kernel/server_port.h

@@ -7,9 +7,8 @@
 #include <memory>
 #include <string>
 #include <tuple>
-#include <vector>
 #include "common/common_types.h"
-#include "core/hle/kernel/object.h"
+#include "core/hle/kernel/kernel.h"
 #include "core/hle/kernel/wait_object.h"
 
 namespace Kernel {

src/core/hle/kernel/server_session.cpp

@@ -5,8 +5,6 @@
 #include <tuple>
 #include <utility>
 
-#include "common/assert.h"
-#include "common/logging/log.h"
 #include "core/core.h"
 #include "core/hle/ipc_helpers.h"
 #include "core/hle/kernel/client_port.h"

src/core/hle/kernel/server_session.h

@@ -6,12 +6,12 @@
 
 #include <memory>
 #include <string>
-#include <vector>
-
+#include "common/assert.h"
 #include "common/common_types.h"
-#include "core/hle/kernel/object.h"
+#include "core/hle/kernel/kernel.h"
 #include "core/hle/kernel/wait_object.h"
 #include "core/hle/result.h"
+#include "core/memory.h"
 
 namespace Kernel {
 

src/core/hle/kernel/session.h

@@ -4,7 +4,7 @@
 
 #pragma once
 
-#include "core/hle/kernel/object.h"
+#include "core/hle/kernel/kernel.h"
 
 namespace Kernel {
 

src/core/hle/kernel/shared_memory.cpp

@@ -3,11 +3,10 @@
 // Refer to the license.txt file included.
 
 #include <utility>
-
-#include "common/assert.h"
 #include "common/logging/log.h"
 #include "core/core.h"
 #include "core/hle/kernel/errors.h"
+#include "core/hle/kernel/memory.h"
 #include "core/hle/kernel/shared_memory.h"
 #include "core/memory.h"
 
@@ -29,17 +28,35 @@ SharedPtr<SharedMemory> SharedMemory::Create(SharedPtr<Process> owner_process, u
     shared_memory->other_permissions = other_permissions;
 
     if (address == 0) {
-        shared_memory->backing_block = std::make_shared<std::vector<u8>>(size);
-        shared_memory->backing_block_offset = 0;
+        // We need to allocate a block from the Linear Heap ourselves.
+        // We'll manually allocate some memory from the linear heap in the specified region.
+        MemoryRegionInfo* memory_region = GetMemoryRegion(region);
+        auto& linheap_memory = memory_region->linear_heap_memory;
+
+        ASSERT_MSG(linheap_memory->size() + size <= memory_region->size,
+                   "Not enough space in region to allocate shared memory!");
+
+        shared_memory->backing_block = linheap_memory;
+        shared_memory->backing_block_offset = linheap_memory->size();
+        // Allocate some memory from the end of the linear heap for this region.
+        linheap_memory->insert(linheap_memory->end(), size, 0);
+        memory_region->used += size;
+
+        shared_memory->linear_heap_phys_address =
+            Memory::FCRAM_PADDR + memory_region->base +
+            static_cast<PAddr>(shared_memory->backing_block_offset);
+
+        // Increase the amount of used linear heap memory for the owner process.
+        if (shared_memory->owner_process != nullptr) {
+            shared_memory->owner_process->linear_heap_used += size;
+        }
 
         // Refresh the address mappings for the current process.
         if (Core::CurrentProcess() != nullptr) {
-            Core::CurrentProcess()->vm_manager.RefreshMemoryBlockMappings(
-                shared_memory->backing_block.get());
+            Core::CurrentProcess()->vm_manager.RefreshMemoryBlockMappings(linheap_memory.get());
         }
     } else {
         auto& vm_manager = shared_memory->owner_process->vm_manager;
-
         // The memory is already available and mapped in the owner process.
         auto vma = vm_manager.FindVMA(address);
         ASSERT_MSG(vma != vm_manager.vma_map.end(), "Invalid memory address");
@@ -55,7 +72,6 @@ SharedPtr<SharedMemory> SharedMemory::Create(SharedPtr<Process> owner_process, u
     }
 
     shared_memory->base_address = address;
-
     return shared_memory;
 }
 
@@ -106,6 +122,11 @@ ResultCode SharedMemory::Map(Process* target_process, VAddr address, MemoryPermi
 
     VAddr target_address = address;
 
+    if (base_address == 0 && target_address == 0) {
+        // Calculate the address at which to map the memory block.
+        target_address = Memory::PhysicalToVirtualAddress(linear_heap_phys_address).value();
+    }
+
     // Map the memory block into the target process
     auto result = target_process->vm_manager.MapMemoryBlock(
         target_address, backing_block, backing_block_offset, size, MemoryState::Shared);

src/core/hle/kernel/shared_memory.h

@@ -4,12 +4,9 @@
 
 #pragma once
 
-#include <memory>
 #include <string>
-#include <vector>
-
 #include "common/common_types.h"
-#include "core/hle/kernel/object.h"
+#include "core/hle/kernel/kernel.h"
 #include "core/hle/kernel/process.h"
 #include "core/hle/result.h"
 
@@ -111,6 +108,9 @@ public:
     SharedPtr<Process> owner_process;
     /// Address of shared memory block in the owner process if specified.
     VAddr base_address;
+    /// Physical address of the shared memory block in the linear heap if no address was specified
+    /// during creation.
+    PAddr linear_heap_phys_address;
     /// Backing memory for this shared memory block.
     std::shared_ptr<std::vector<u8>> backing_block;
     /// Offset into the backing block for this shared memory.