Merge 63e39d07e7 into c8e5c74092

According to @wwylele comment, there's no need to cast to u32

CMakeModules/CopyYuzuQt5Deps.cmake

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

appveyor.yml

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

externals/CMakeLists.txt

@@ -32,11 +32,11 @@ add_subdirectory(inih)
 
 # lz4
 set(LZ4_BUNDLED_MODE ON)
-add_subdirectory(lz4/contrib/cmake_unofficial EXCLUDE_FROM_ALL)
+add_subdirectory(lz4/contrib/cmake_unofficial)
 target_include_directories(lz4_static INTERFACE ./lz4/lib)
 
 # mbedtls
-add_subdirectory(mbedtls EXCLUDE_FROM_ALL)
+add_subdirectory(mbedtls)
 target_include_directories(mbedtls PUBLIC ./mbedtls/include)
 
 # MicroProfile
@@ -62,5 +62,5 @@ target_include_directories(opus INTERFACE ./opus/include)
 # Cubeb
 if(ENABLE_CUBEB)
     set(BUILD_TESTS OFF CACHE BOOL "")
-    add_subdirectory(cubeb EXCLUDE_FROM_ALL)
+    add_subdirectory(cubeb)
 endif()

src/audio_core/CMakeLists.txt

@@ -1,11 +1,9 @@
 add_library(audio_core STATIC
     audio_out.cpp
     audio_out.h
-    audio_renderer.cpp
-    audio_renderer.h
     buffer.h
-    codec.cpp
-    codec.h
+    cubeb_sink.cpp
+    cubeb_sink.h
     null_sink.h
     stream.cpp
     stream.h
@@ -13,8 +11,6 @@ add_library(audio_core STATIC
     sink_details.cpp
     sink_details.h
     sink_stream.h
-
-    $<$<BOOL:${ENABLE_CUBEB}>:cubeb_sink.cpp cubeb_sink.h>
 )
 
 create_target_directory_groups(audio_core)

src/audio_core/audio_out.cpp

@@ -27,16 +27,16 @@ static Stream::Format ChannelsToStreamFormat(u32 num_channels) {
     return {};
 }
 
-StreamPtr AudioOut::OpenStream(u32 sample_rate, u32 num_channels, std::string&& name,
+StreamPtr AudioOut::OpenStream(u32 sample_rate, u32 num_channels,
                                Stream::ReleaseCallback&& release_callback) {
     if (!sink) {
         const SinkDetails& sink_details = GetSinkDetails(Settings::values.sink_id);
         sink = sink_details.factory(Settings::values.audio_device_id);
     }
 
-    return std::make_shared<Stream>(
-        sample_rate, ChannelsToStreamFormat(num_channels), std::move(release_callback),
-        sink->AcquireSinkStream(sample_rate, num_channels, name), std::move(name));
+    return std::make_shared<Stream>(sample_rate, ChannelsToStreamFormat(num_channels),
+                                    std::move(release_callback),
+                                    sink->AcquireSinkStream(sample_rate, num_channels));
 }
 
 std::vector<Buffer::Tag> AudioOut::GetTagsAndReleaseBuffers(StreamPtr stream, size_t max_count) {
@@ -51,7 +51,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,7 +5,6 @@
 #pragma once
 
 #include <memory>
-#include <string>
 #include <vector>
 
 #include "audio_core/buffer.h"
@@ -21,7 +20,7 @@ namespace AudioCore {
 class AudioOut {
 public:
     /// Opens a new audio stream
-    StreamPtr OpenStream(u32 sample_rate, u32 num_channels, std::string&& name,
+    StreamPtr OpenStream(u32 sample_rate, u32 num_channels,
                          Stream::ReleaseCallback&& release_callback);
 
     /// Returns a vector of recently released buffers specified by tag for the specified stream
@@ -34,7 +33,7 @@ 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;

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

@@ -18,16 +18,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,7 +32,7 @@ public:
 
 private:
     Tag tag;
-    std::vector<s16> samples;
+    std::vector<u8> data;
 };
 
 using BufferPtr = std::shared_ptr<Buffer>;

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

@@ -13,30 +13,20 @@ 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;
+    SinkStreamImpl(cubeb* ctx, cubeb_devid output_device) : ctx{ctx} {
+        cubeb_stream_params params;
+        params.rate = 48000;
+        params.channels = GetNumChannels();
         params.format = CUBEB_SAMPLE_S16NE;
-        params.layout = num_channels == 1 ? CUBEB_LAYOUT_MONO : CUBEB_LAYOUT_STEREO;
+        params.layout = CUBEB_LAYOUT_STEREO;
 
-        u32 minimum_latency{};
+        u32 minimum_latency = 0;
         if (cubeb_get_min_latency(ctx, &params, &minimum_latency) != CUBEB_OK) {
             LOG_CRITICAL(Audio_Sink, "Error getting minimum latency");
         }
 
-        if (cubeb_stream_init(ctx, &stream_backend, name.c_str(), nullptr, nullptr, output_device,
-                              &params, std::max(512u, minimum_latency),
+        if (cubeb_stream_init(ctx, &stream_backend, "yuzu Audio Output", nullptr, nullptr,
+                              output_device, &params, std::max(512u, minimum_latency),
                               &SinkStreamImpl::DataCallback, &SinkStreamImpl::StateCallback,
                               this) != CUBEB_OK) {
             LOG_CRITICAL(Audio_Sink, "Error initializing cubeb stream");
@@ -61,29 +51,33 @@ public:
         cubeb_stream_destroy(stream_backend);
     }
 
-    void EnqueueSamples(u32 num_channels, const std::vector<s16>& samples) override {
+    void EnqueueSamples(u32 num_channels, const s16* samples, size_t sample_count) override {
         if (!ctx) {
             return;
         }
 
-        queue.reserve(queue.size() + samples.size() * GetNumChannels());
+        queue.reserve(queue.size() + sample_count * GetNumChannels());
 
-        if (is_6_channel) {
+        if (num_channels == 2) {
+            // Copy as-is
+            std::copy(samples, samples + sample_count * GetNumChannels(),
+                      std::back_inserter(queue));
+        } else if (num_channels == 6) {
             // Downsample 6 channels to 2
-            const size_t sample_count_copy_size = samples.size() * 2;
+            const size_t sample_count_copy_size = sample_count * num_channels * 2;
             queue.reserve(sample_count_copy_size);
-            for (size_t i = 0; i < samples.size(); i += num_channels) {
+            for (size_t i = 0; i < sample_count * num_channels; i += num_channels) {
                 queue.push_back(samples[i]);
                 queue.push_back(samples[i + 1]);
             }
         } else {
-            // Copy as-is
-            std::copy(samples.begin(), samples.end(), std::back_inserter(queue));
+            ASSERT_MSG(false, "Unimplemented");
         }
     }
 
     u32 GetNumChannels() const {
-        return num_channels;
+        // Only support 2-channel stereo output for now
+        return 2;
     }
 
 private:
@@ -91,8 +85,6 @@ private:
 
     cubeb* ctx{};
     cubeb_stream* stream_backend{};
-    u32 num_channels{};
-    bool is_6_channel{};
 
     std::vector<s16> queue;
 
@@ -137,10 +129,8 @@ CubebSink::~CubebSink() {
     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));
+SinkStream& CubebSink::AcquireSinkStream(u32 sample_rate, u32 num_channels) {
+    sink_streams.push_back(std::make_unique<SinkStreamImpl>(ctx, output_device));
     return *sink_streams.back();
 }
 

src/audio_core/cubeb_sink.h

@@ -18,8 +18,7 @@ public:
     explicit CubebSink(std::string device_id);
     ~CubebSink() override;
 
-    SinkStream& AcquireSinkStream(u32 sample_rate, u32 num_channels,
-                                  const std::string& name) override;
+    SinkStream& AcquireSinkStream(u32 sample_rate, u32 num_channels) override;
 
 private:
     cubeb* ctx{};

src/audio_core/null_sink.h

@@ -13,14 +13,14 @@ public:
     explicit NullSink(std::string){};
     ~NullSink() override = default;
 
-    SinkStream& AcquireSinkStream(u32 /*sample_rate*/, u32 /*num_channels*/,
-                                  const std::string& /*name*/) override {
+    SinkStream& AcquireSinkStream(u32 /*sample_rate*/, u32 /*num_channels*/) override {
         return null_sink_stream;
     }
 
 private:
     struct NullSinkStreamImpl final : SinkStream {
-        void EnqueueSamples(u32 /*num_channels*/, const std::vector<s16>& /*samples*/) override {}
+        void EnqueueSamples(u32 /*num_channels*/, const s16* /*samples*/,
+                            size_t /*sample_count*/) override {}
     } null_sink_stream;
 };
 

src/audio_core/sink.h

@@ -5,7 +5,6 @@
 #pragma once
 
 #include <memory>
-#include <string>
 
 #include "audio_core/sink_stream.h"
 #include "common/common_types.h"
@@ -22,8 +21,7 @@ constexpr char auto_device_name[] = "auto";
 class Sink {
 public:
     virtual ~Sink() = default;
-    virtual SinkStream& AcquireSinkStream(u32 sample_rate, u32 num_channels,
-                                          const std::string& name) = 0;
+    virtual SinkStream& AcquireSinkStream(u32 sample_rate, u32 num_channels) = 0;
 };
 
 using SinkPtr = std::unique_ptr<Sink>;

src/audio_core/sink_stream.h

@@ -5,7 +5,6 @@
 #pragma once
 
 #include <memory>
-#include <vector>
 
 #include "common/common_types.h"
 
@@ -23,8 +22,9 @@ public:
      * Feed stereo samples to sink.
      * @param num_channels Number of channels used.
      * @param samples Samples in interleaved stereo PCM16 format.
+     * @param sample_count Number of samples.
      */
-    virtual void EnqueueSamples(u32 num_channels, const std::vector<s16>& samples) = 0;
+    virtual void EnqueueSamples(u32 num_channels, const s16* samples, size_t sample_count) = 0;
 };
 
 using SinkStreamPtr = std::unique_ptr<SinkStream>;

src/audio_core/stream.cpp

@@ -32,13 +32,17 @@ u32 Stream::GetNumChannels() const {
     return {};
 }
 
+u32 Stream::GetSampleSize() const {
+    return GetNumChannels() * 2;
+}
+
 Stream::Stream(u32 sample_rate, Format format, ReleaseCallback&& release_callback,
-               SinkStream& sink_stream, std::string&& name_)
+               SinkStream& sink_stream)
     : sample_rate{sample_rate}, format{format}, release_callback{std::move(release_callback)},
-      sink_stream{sink_stream}, name{std::move(name_)} {
+      sink_stream{sink_stream} {
 
     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,15 +55,17 @@ 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() / GetSampleSize()};
     return CoreTiming::usToCycles((static_cast<u64>(num_samples) * 1000000) / sample_rate);
 }
 
-static void VolumeAdjustSamples(std::vector<s16>& samples) {
+static std::vector<s16> GetVolumeAdjustedSamples(const std::vector<u8>& data) {
+    std::vector<s16> samples(data.size() / sizeof(s16));
+    std::memcpy(samples.data(), data.data(), data.size());
     const float volume{std::clamp(Settings::values.volume, 0.0f, 1.0f)};
 
     if (volume == 1.0f) {
-        return;
+        return samples;
     }
 
     // Implementation of a volume slider with a dynamic range of 60 dB
@@ -67,6 +73,8 @@ static void VolumeAdjustSamples(std::vector<s16>& samples) {
     for (auto& sample : samples) {
         sample = static_cast<s16>(sample * volume_scale_factor);
     }
+
+    return samples;
 }
 
 void Stream::PlayNextBuffer() {
@@ -88,14 +96,14 @@ void Stream::PlayNextBuffer() {
     active_buffer = queued_buffers.front();
     queued_buffers.pop();
 
-    VolumeAdjustSamples(active_buffer->Samples());
-    sink_stream.EnqueueSamples(GetNumChannels(), active_buffer->GetSamples());
+    const size_t sample_count{active_buffer->GetData().size() / GetSampleSize()};
+    sink_stream.EnqueueSamples(
+        GetNumChannels(), GetVolumeAdjustedSamples(active_buffer->GetData()).data(), sample_count);
 
     CoreTiming::ScheduleEventThreadsafe(GetBufferReleaseCycles(*active_buffer), release_event, {});
 }
 
 void Stream::ReleaseActiveBuffer() {
-    ASSERT(active_buffer);
     released_buffers.push(std::move(active_buffer));
     release_callback();
     PlayNextBuffer();

src/audio_core/stream.h

@@ -6,7 +6,6 @@
 
 #include <functional>
 #include <memory>
-#include <string>
 #include <vector>
 #include <queue>
 
@@ -34,7 +33,7 @@ public:
     using ReleaseCallback = std::function<void()>;
 
     Stream(u32 sample_rate, Format format, ReleaseCallback&& release_callback,
-           SinkStream& sink_stream, std::string&& name_);
+           SinkStream& sink_stream);
 
     /// Plays the audio stream
     void Play();
@@ -69,6 +68,9 @@ public:
     /// Gets the number of channels
     u32 GetNumChannels() const;
 
+    /// Gets the sample size in bytes
+    u32 GetSampleSize() const;
+
 private:
     /// Current state of the stream
     enum class State {
@@ -94,7 +96,6 @@ private:
     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>;

src/common/alignment.h

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

src/common/bit_set.h

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

src/common/file_util.h

@@ -8,7 +8,6 @@
 #include <cstdio>
 #include <fstream>
 #include <functional>
-#include <limits>
 #include <string>
 #include <string_view>
 #include <type_traits>
@@ -208,42 +207,39 @@ public:
 
     template <typename T>
     size_t ReadArray(T* data, size_t length) const {
-        static_assert(std::is_trivially_copyable_v<T>,
+        static_assert(std::is_trivially_copyable<T>(),
                       "Given array does not consist of trivially copyable objects");
 
-        if (!IsOpen()) {
-            return std::numeric_limits<size_t>::max();
-        }
+        if (!IsOpen())
+            return -1;
 
         return std::fread(data, sizeof(T), length, m_file);
     }
 
     template <typename T>
     size_t WriteArray(const T* data, size_t length) {
-        static_assert(std::is_trivially_copyable_v<T>,
+        static_assert(std::is_trivially_copyable<T>(),
                       "Given array does not consist of trivially copyable objects");
-        if (!IsOpen()) {
-            return std::numeric_limits<size_t>::max();
-        }
-
+        if (!IsOpen())
+            return -1;
         return std::fwrite(data, sizeof(T), length, m_file);
     }
 
     template <typename T>
     size_t ReadBytes(T* data, size_t length) const {
-        static_assert(std::is_trivially_copyable_v<T>, "T must be trivially copyable");
+        static_assert(std::is_trivially_copyable<T>(), "T must be trivially copyable");
         return ReadArray(reinterpret_cast<char*>(data), length);
     }
 
     template <typename T>
     size_t WriteBytes(const T* data, size_t length) {
-        static_assert(std::is_trivially_copyable_v<T>, "T must be trivially copyable");
+        static_assert(std::is_trivially_copyable<T>(), "T must be trivially copyable");
         return WriteArray(reinterpret_cast<const char*>(data), length);
     }
 
     template <typename T>
     size_t WriteObject(const T& object) {
-        static_assert(!std::is_pointer_v<T>, "WriteObject arguments must not be a pointer");
+        static_assert(!std::is_pointer<T>::value, "Given object is a pointer");
         return WriteArray(&object, 1);
     }
 

src/common/hash.h

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

src/common/logging/backend.cpp

@@ -200,7 +200,6 @@ void FileBackend::Write(const Entry& entry) {
     SUB(Service, SPL)                                                                              \
     SUB(Service, SSL)                                                                              \
     SUB(Service, Time)                                                                             \
-    SUB(Service, USB)                                                                              \
     SUB(Service, VI)                                                                               \
     SUB(Service, WLAN)                                                                             \
     CLS(HW)                                                                                        \

src/common/logging/log.h

@@ -87,7 +87,6 @@ enum class Class : ClassType {
     Service_SPL,       ///< The SPL service
     Service_SSL,       ///< The SSL service
     Service_Time,      ///< The time service
-    Service_USB,       ///< The USB (Universal Serial Bus) service
     Service_VI,        ///< The VI (Video interface) service
     Service_WLAN,      ///< The WLAN (Wireless local area network) service
     HW,                ///< Low-level hardware emulation

src/common/vector_math.h

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

src/common/x64/xbyak_util.h

@@ -34,7 +34,7 @@ inline bool IsWithin2G(const Xbyak::CodeGenerator& code, uintptr_t target) {
 
 template <typename T>
 inline void CallFarFunction(Xbyak::CodeGenerator& code, const T f) {
-    static_assert(std::is_pointer_v<T>, "Argument must be a (function) pointer.");
+    static_assert(std::is_pointer<T>(), "Argument must be a (function) pointer.");
     size_t addr = reinterpret_cast<size_t>(f);
     if (IsWithin2G(code, addr)) {
         code.call(f);

src/core/CMakeLists.txt

@@ -104,6 +104,8 @@ add_library(core STATIC
     hle/lock.cpp
     hle/lock.h
     hle/result.h
+    hle/romfs.cpp
+    hle/romfs.h
     hle/service/acc/acc.cpp
     hle/service/acc/acc.h
     hle/service/acc/acc_aa.cpp
@@ -313,8 +315,6 @@ add_library(core STATIC
     hle/service/time/interface.h
     hle/service/time/time.cpp
     hle/service/time/time.h
-    hle/service/usb/usb.cpp
-    hle/service/usb/usb.h
     hle/service/vi/vi.cpp
     hle/service/vi/vi.h
     hle/service/vi/vi_m.cpp

src/core/arm/unicorn/arm_unicorn.cpp

@@ -203,7 +203,7 @@ void ARM_Unicorn::ExecuteInstructions(int num_instructions) {
         }
         Kernel::Thread* thread = Kernel::GetCurrentThread();
         SaveContext(thread->context);
-        if (last_bkpt_hit || GDBStub::GetCpuStepFlag()) {
+        if (last_bkpt_hit || (num_instructions == 1)) {
             last_bkpt_hit = false;
             GDBStub::Break();
             GDBStub::SendTrap(thread, 5);

src/core/core.cpp

@@ -62,6 +62,7 @@ System::ResultStatus System::RunLoop(bool tight_loop) {
         // execute. Otherwise, get out of the loop function.
         if (GDBStub::GetCpuHaltFlag()) {
             if (GDBStub::GetCpuStepFlag()) {
+                GDBStub::SetCpuStepFlag(false);
                 tight_loop = false;
             } else {
                 return ResultStatus::Success;
@@ -77,10 +78,6 @@ System::ResultStatus System::RunLoop(bool tight_loop) {
         }
     }
 
-    if (GDBStub::IsServerEnabled()) {
-        GDBStub::SetCpuStepFlag(false);
-    }
-
     return status;
 }
 

src/core/core.h

@@ -82,17 +82,6 @@ public:
      */
     ResultStatus SingleStep();
 
-    /**
-     * Invalidate the CPU instruction caches
-     * This function should only be used by GDB Stub to support breakpoints, memory updates and
-     * step/continue commands.
-     */
-    void InvalidateCpuInstructionCaches() {
-        for (auto& cpu : cpu_cores) {
-            cpu->ArmInterface().ClearInstructionCache();
-        }
-    }
-
     /// Shutdown the emulated system.
     void Shutdown();
 

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));
     }
@@ -226,8 +226,8 @@ void Idle() {
     downcount = 0;
 }
 
-std::chrono::microseconds GetGlobalTimeUs() {
-    return std::chrono::microseconds{GetTicks() * 1000000 / BASE_CLOCK_RATE};
+u64 GetGlobalTimeUs() {
+    return GetTicks() * 1000000 / BASE_CLOCK_RATE;
 }
 
 int GetDowncount() {

src/core/core_timing.h

@@ -17,17 +17,12 @@
  *   ScheduleEvent(periodInCycles - cyclesLate, callback, "whatever")
  */
 
-#include <chrono>
 #include <functional>
 #include <string>
 #include "common/common_types.h"
 
 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.
@@ -35,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
@@ -43,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.
  */
@@ -87,7 +86,7 @@ void ClearPendingEvents();
 
 void ForceExceptionCheck(s64 cycles);
 
-std::chrono::microseconds GetGlobalTimeUs();
+u64 GetGlobalTimeUs();
 
 int GetDowncount();
 

src/core/file_sys/card_image.cpp

@@ -5,7 +5,6 @@
 #include <array>
 #include <string>
 #include <core/loader/loader.h>
-#include "common/logging/log.h"
 #include "core/file_sys/card_image.h"
 #include "core/file_sys/partition_filesystem.h"
 #include "core/file_sys/vfs_offset.h"

src/core/file_sys/content_archive.cpp

@@ -76,17 +76,12 @@ bool IsValidNCA(const NCAHeader& header) {
     return header.magic == Common::MakeMagic('N', 'C', 'A', '3');
 }
 
-u8 NCA::GetCryptoRevision() const {
+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;
-    return master_key_id;
-}
-
-boost::optional<Core::Crypto::Key128> NCA::GetKeyAreaKey(NCASectionCryptoType type) const {
-    const auto master_key_id = GetCryptoRevision();
 
     if (!keys.HasKey(Core::Crypto::S128KeyType::KeyArea, master_key_id, header.key_index))
         return boost::none;
@@ -113,67 +108,38 @@ boost::optional<Core::Crypto::Key128> NCA::GetKeyAreaKey(NCASectionCryptoType ty
     return out;
 }
 
-boost::optional<Core::Crypto::Key128> NCA::GetTitlekey() const {
-    const auto master_key_id = GetCryptoRevision();
-
-    u128 rights_id{};
-    memcpy(rights_id.data(), header.rights_id.data(), 16);
-    if (rights_id == u128{})
-        return boost::none;
-
-    auto titlekey = keys.GetKey(Core::Crypto::S128KeyType::Titlekey, rights_id[1], rights_id[0]);
-    if (titlekey == Core::Crypto::Key128{})
-        return boost::none;
-    Core::Crypto::AESCipher<Core::Crypto::Key128> cipher(
-        keys.GetKey(Core::Crypto::S128KeyType::Titlekek, master_key_id), Core::Crypto::Mode::ECB);
-    cipher.Transcode(titlekey.data(), titlekey.size(), titlekey.data(), Core::Crypto::Op::Decrypt);
-
-    return titlekey;
-}
-
-VirtualFile NCA::Decrypt(NCASectionHeader s_header, VirtualFile in, u64 starting_offset) const {
+VirtualFile NCA::Decrypt(NCASectionHeader header, VirtualFile in, u64 starting_offset) const {
     if (!encrypted)
         return in;
 
-    switch (s_header.raw.header.crypto_type) {
+    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);
         {
-            boost::optional<Core::Crypto::Key128> key = boost::none;
-            if (std::find_if_not(header.rights_id.begin(), header.rights_id.end(),
-                                 [](char c) { return c == 0; }) == header.rights_id.end()) {
-                key = GetKeyAreaKey(NCASectionCryptoType::CTR);
-            } else {
-                key = GetTitlekey();
-            }
-
+            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] = s_header.raw.section_ctr[0x8 - i - 1];
+                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.
+        // TODO(DarkLordZach): Implement XTSEncryptionLayer and title key encryption.
     default:
         LOG_ERROR(Crypto, "called with unhandled crypto type={:02X}",
-                  static_cast<u8>(s_header.raw.header.crypto_type));
+                  static_cast<u8>(header.raw.header.crypto_type));
         return nullptr;
     }
 }
 
 NCA::NCA(VirtualFile file_) : file(std::move(file_)) {
-    if (file == nullptr) {
-        status = Loader::ResultStatus::ErrorInvalidFormat;
-        return;
-    }
     if (sizeof(NCAHeader) != file->ReadObject(&header))
         LOG_ERROR(Loader, "File reader errored out during header read.");
 

src/core/file_sys/content_archive.h

@@ -12,7 +12,6 @@
 #include "common/common_funcs.h"
 #include "common/common_types.h"
 #include "common/swap.h"
-#include "control_metadata.h"
 #include "core/crypto/key_manager.h"
 #include "core/file_sys/partition_filesystem.h"
 #include "core/loader/loader.h"
@@ -96,9 +95,7 @@ protected:
     bool ReplaceFileWithSubdirectory(VirtualFile file, VirtualDir dir) override;
 
 private:
-    u8 GetCryptoRevision() const;
     boost::optional<Core::Crypto::Key128> GetKeyAreaKey(NCASectionCryptoType type) const;
-    boost::optional<Core::Crypto::Key128> GetTitlekey() const;
     VirtualFile Decrypt(NCASectionHeader header, VirtualFile in, u64 starting_offset) const;
 
     std::vector<VirtualDir> dirs;

src/core/file_sys/control_metadata.h

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

src/core/gdbstub/gdbstub.cpp

@@ -41,42 +41,40 @@
 #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 +140,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,26 +171,23 @@ WSADATA InitData;
 
 struct Breakpoint {
     bool active;
-    VAddr addr;
+    PAddr addr;
     u64 len;
-    std::array<u8, 4> inst;
 };
 
-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);
@@ -421,11 +418,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;
@@ -444,24 +441,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));
-    Memory::WriteBlock(bp->second.addr, bp->second.inst.data(), bp->second.inst.size());
-    Core::System::GetInstance().InvalidateCpuInstructionCaches();
-    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()) {
@@ -475,38 +468,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;
@@ -752,7 +743,7 @@ static bool IsDataAvailable() {
     fd_set fd_socket;
 
     FD_ZERO(&fd_socket);
-    FD_SET(static_cast<u32>(gdbserver_socket), &fd_socket);
+    FD_SET(gdbserver_socket, &fd_socket);
 
     struct timeval t;
     t.tv_sec = 0;
@@ -940,7 +931,6 @@ static void WriteMemory() {
 
     GdbHexToMem(data.data(), len_pos + 1, len);
     Memory::WriteBlock(addr, data.data(), len);
-    Core::System::GetInstance().InvalidateCpuInstructionCaches();
     SendReply("OK");
 }
 
@@ -960,7 +950,6 @@ static void Step() {
     step_loop = true;
     halt_loop = true;
     send_trap = true;
-    Core::System::GetInstance().InvalidateCpuInstructionCaches();
 }
 
 /// Tell the CPU if we hit a memory breakpoint.
@@ -977,7 +966,6 @@ static void Continue() {
     memory_break = false;
     step_loop = false;
     halt_loop = false;
-    Core::System::GetInstance().InvalidateCpuInstructionCaches();
 }
 
 /**
@@ -987,17 +975,13 @@ 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;
     breakpoint.addr = addr;
     breakpoint.len = len;
-    Memory::ReadBlock(addr, breakpoint.inst.data(), breakpoint.inst.size());
-    static constexpr std::array<u8, 4> btrap{{0xd4, 0x20, 0x7d, 0x0}};
-    Memory::WriteBlock(addr, btrap.data(), btrap.size());
-    Core::System::GetInstance().InvalidateCpuInstructionCaches();
     p.insert({addr, breakpoint});
 
     LOG_DEBUG(Debug_GDBStub, "gdb: added {} breakpoint: {:016X} bytes at {:016X}",
@@ -1031,7 +1015,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 =
@@ -1080,7 +1064,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/kernel/address_arbiter.cpp

@@ -32,8 +32,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 +45,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 +76,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 +110,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/client_port.cpp

@@ -14,8 +14,8 @@
 
 namespace Kernel {
 
-ClientPort::ClientPort() = default;
-ClientPort::~ClientPort() = default;
+ClientPort::ClientPort() {}
+ClientPort::~ClientPort() {}
 
 ResultVal<SharedPtr<ClientSession>> ClientPort::Connect() {
     // Note: Threads do not wait for the server endpoint to call
@@ -40,12 +40,4 @@ ResultVal<SharedPtr<ClientSession>> ClientPort::Connect() {
     return MakeResult(std::get<SharedPtr<ClientSession>>(sessions));
 }
 
-void ClientPort::ConnectionClosed() {
-    if (active_sessions == 0) {
-        return;
-    }
-
-    --active_sessions;
-}
-
 } // namespace Kernel

src/core/hle/kernel/client_port.h

@@ -37,20 +37,14 @@ public:
      */
     ResultVal<SharedPtr<ClientSession>> Connect();
 
-    /**
-     * Signifies that a previously active connection has been closed,
-     * decreasing the total number of active connections to this port.
-     */
-    void ConnectionClosed();
+    SharedPtr<ServerPort> server_port; ///< ServerPort associated with this client port.
+    u32 max_sessions;    ///< Maximum number of simultaneous sessions the port can have
+    u32 active_sessions; ///< Number of currently open sessions to this port
+    std::string name;    ///< Name of client port (optional)
 
 private:
     ClientPort();
     ~ClientPort() override;
-
-    SharedPtr<ServerPort> server_port; ///< ServerPort associated with this client port.
-    u32 max_sessions = 0;    ///< Maximum number of simultaneous sessions the port can have
-    u32 active_sessions = 0; ///< Number of currently open sessions to this port
-    std::string name;        ///< Name of client port (optional)
 };
 
 } // namespace Kernel

src/core/hle/kernel/event.h

@@ -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/server_session.cpp

@@ -27,7 +27,7 @@ ServerSession::~ServerSession() {
 
     // Decrease the port's connection count.
     if (parent->port)
-        parent->port->ConnectionClosed();
+        parent->port->active_sessions--;
 
     // TODO(Subv): Wake up all the ClientSession's waiting threads and set
     // the SendSyncRequest result to 0xC920181A.

src/core/hle/romfs.cpp

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

src/core/hle/romfs.h

@@ -0,0 +1,22 @@
+// Copyright 2017 Citra Emulator Project
+// Licensed under GPLv2 or any later version
+// Refer to the license.txt file included.
+
+#pragma once
+
+#include <string>
+#include <vector>
+#include "common/common_types.h"
+
+namespace RomFS {
+
+/**
+ * Gets the pointer to a file in a RomFS image.
+ * @param romfs The pointer to the RomFS image
+ * @param path A vector containing the directory names and file name of the path to the file
+ * @return the pointer to the file
+ * @todo reimplement this with a full RomFS manager
+ */
+const u8* GetFilePointer(const u8* romfs, const std::vector<std::u16string>& path);
+
+} // namespace RomFS

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

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

src/core/hle/service/acc/acc.h

@@ -14,7 +14,6 @@ public:
     public:
         explicit Interface(std::shared_ptr<Module> module, const char* name);
 
-        void GetUserCount(Kernel::HLERequestContext& ctx);
         void GetUserExistence(Kernel::HLERequestContext& ctx);
         void ListAllUsers(Kernel::HLERequestContext& ctx);
         void ListOpenUsers(Kernel::HLERequestContext& ctx);

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

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

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

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

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

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

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

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

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

@@ -83,7 +83,6 @@ private:
     void LockExit(Kernel::HLERequestContext& ctx);
     void UnlockExit(Kernel::HLERequestContext& ctx);
     void GetLibraryAppletLaunchableEvent(Kernel::HLERequestContext& ctx);
-    void SetScreenShotImageOrientation(Kernel::HLERequestContext& ctx);
     void CreateManagedDisplayLayer(Kernel::HLERequestContext& ctx);
     void SetScreenShotPermission(Kernel::HLERequestContext& ctx);
     void SetHandlesRequestToDisplay(Kernel::HLERequestContext& ctx);

src/core/hle/service/apm/apm.cpp

@@ -13,7 +13,6 @@ void InstallInterfaces(SM::ServiceManager& service_manager) {
     auto module_ = std::make_shared<Module>();
     std::make_shared<APM>(module_, "apm")->InstallAsService(service_manager);
     std::make_shared<APM>(module_, "apm:p")->InstallAsService(service_manager);
-    std::make_shared<APM_Sys>()->InstallAsService(service_manager);
 }
 
 } // namespace Service::APM

src/core/hle/service/apm/interface.cpp

@@ -74,31 +74,6 @@ void APM::OpenSession(Kernel::HLERequestContext& ctx) {
     IPC::ResponseBuilder rb{ctx, 2, 0, 1};
     rb.Push(RESULT_SUCCESS);
     rb.PushIpcInterface<ISession>();
-
-    LOG_DEBUG(Service_APM, "called");
-}
-
-APM_Sys::APM_Sys() : ServiceFramework{"apm:sys"} {
-    // clang-format off
-    static const FunctionInfo functions[] = {
-        {0, nullptr, "RequestPerformanceMode"},
-        {1, &APM_Sys::GetPerformanceEvent, "GetPerformanceEvent"},
-        {2, nullptr, "GetThrottlingState"},
-        {3, nullptr, "GetLastThrottlingState"},
-        {4, nullptr, "ClearLastThrottlingState"},
-        {5, nullptr, "LoadAndApplySettings"},
-    };
-    // clang-format on
-
-    RegisterHandlers(functions);
-}
-
-void APM_Sys::GetPerformanceEvent(Kernel::HLERequestContext& ctx) {
-    IPC::ResponseBuilder rb{ctx, 2, 0, 1};
-    rb.Push(RESULT_SUCCESS);
-    rb.PushIpcInterface<ISession>();
-
-    LOG_DEBUG(Service_APM, "called");
 }
 
 } // namespace Service::APM

src/core/hle/service/apm/interface.h

@@ -19,12 +19,4 @@ private:
     std::shared_ptr<Module> apm;
 };
 
-class APM_Sys final : public ServiceFramework<APM_Sys> {
-public:
-    explicit APM_Sys();
-
-private:
-    void GetPerformanceEvent(Kernel::HLERequestContext& ctx);
-};
-
 } // namespace Service::APM

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

@@ -2,6 +2,8 @@
 // Licensed under GPLv2 or any later version
 // Refer to the license.txt file included.
 
+#pragma once
+
 #include "core/hle/service/audio/audout_a.h"
 
 namespace Service::Audio {

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

@@ -4,8 +4,6 @@
 
 #include <array>
 #include <vector>
-
-#include "audio_core/codec.h"
 #include "common/logging/log.h"
 #include "core/core.h"
 #include "core/hle/ipc_helpers.h"
@@ -50,7 +48,7 @@ public:
         buffer_event = Kernel::Event::Create(Kernel::ResetType::Sticky, "IAudioOutBufferReleased");
 
         stream = audio_core.OpenStream(audio_params.sample_rate, audio_params.channel_count,
-                                       "IAudioOut", [=]() { buffer_event->Signal(); });
+                                       [=]() { buffer_event->Signal(); });
     }
 
 private:
@@ -113,10 +111,10 @@ private:
         std::memcpy(&audio_buffer, input_buffer.data(), sizeof(AudioBuffer));
         const u64 tag{rp.Pop<u64>()};
 
-        std::vector<s16> samples(audio_buffer.buffer_size / sizeof(s16));
-        Memory::ReadBlock(audio_buffer.buffer, samples.data(), audio_buffer.buffer_size);
+        std::vector<u8> data(audio_buffer.buffer_size);
+        Memory::ReadBlock(audio_buffer.buffer, data.data(), data.size());
 
-        if (!audio_core.QueueBuffer(stream, tag, std::move(samples))) {
+        if (!audio_core.QueueBuffer(stream, tag, std::move(data))) {
             IPC::ResponseBuilder rb{ctx, 2};
             rb.Push(ResultCode(ErrorModule::Audio, ErrCodes::BufferCountExceeded));
         }
@@ -202,7 +200,7 @@ void AudOutU::OpenAudioOutImpl(Kernel::HLERequestContext& ctx) {
     rb.Push(RESULT_SUCCESS);
     rb.Push<u32>(DefaultSampleRate);
     rb.Push<u32>(params.channel_count);
-    rb.Push<u32>(static_cast<u32>(AudioCore::Codec::PcmFormat::Int16));
+    rb.Push<u32>(static_cast<u32>(PcmFormat::Int16));
     rb.Push<u32>(static_cast<u32>(AudioState::Stopped));
     rb.PushIpcInterface<Audio::IAudioOut>(audio_out_interface);
 }

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

@@ -38,6 +38,16 @@ private:
 
     void ListAudioOutsImpl(Kernel::HLERequestContext& ctx);
     void OpenAudioOutImpl(Kernel::HLERequestContext& ctx);
+
+    enum class PcmFormat : u32 {
+        Invalid = 0,
+        Int8 = 1,
+        Int16 = 2,
+        Int24 = 3,
+        Int32 = 4,
+        PcmFloat = 5,
+        Adpcm = 6,
+    };
 };
 
 } // namespace Service::Audio

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

@@ -15,10 +15,13 @@
 
 namespace Service::Audio {
 
+/// TODO(bunnei): Find a proper value for the audio_ticks
+constexpr u64 audio_ticks{static_cast<u64>(CoreTiming::BASE_CLOCK_RATE / 200)};
+
 class IAudioRenderer final : public ServiceFramework<IAudioRenderer> {
 public:
-    explicit IAudioRenderer(AudioCore::AudioRendererParameter audren_params)
-        : ServiceFramework("IAudioRenderer") {
+    explicit IAudioRenderer(AudioRendererParameter audren_params)
+        : ServiceFramework("IAudioRenderer"), worker_params(audren_params) {
         static const FunctionInfo functions[] = {
             {0, nullptr, "GetAudioRendererSampleRate"},
             {1, nullptr, "GetAudioRendererSampleCount"},
@@ -36,8 +39,21 @@ public:
         RegisterHandlers(functions);
 
         system_event =
-            Kernel::Event::Create(Kernel::ResetType::Sticky, "IAudioRenderer:SystemEvent");
-        renderer = std::make_unique<AudioCore::AudioRenderer>(audren_params, system_event);
+            Kernel::Event::Create(Kernel::ResetType::OneShot, "IAudioRenderer:SystemEvent");
+
+        // Register event callback to update the Audio Buffer
+        audio_event = CoreTiming::RegisterEvent(
+            "IAudioRenderer::UpdateAudioCallback", [this](u64 userdata, int cycles_late) {
+                UpdateAudioCallback();
+                CoreTiming::ScheduleEvent(audio_ticks - cycles_late, audio_event);
+            });
+
+        // Start the audio event
+        CoreTiming::ScheduleEvent(audio_ticks, audio_event);
+        voice_status_list.resize(worker_params.voice_count);
+    }
+    ~IAudioRenderer() {
+        CoreTiming::UnscheduleEvent(audio_event, 0);
     }
 
 private:
@@ -46,9 +62,60 @@ private:
     }
 
     void RequestUpdateAudioRenderer(Kernel::HLERequestContext& ctx) {
-        ctx.WriteBuffer(renderer->UpdateAudioRenderer(ctx.ReadBuffer()));
+        UpdateDataHeader config{};
+        auto buf = ctx.ReadBuffer();
+        std::memcpy(&config, buf.data(), sizeof(UpdateDataHeader));
+        u32 memory_pool_count = worker_params.effect_count + (worker_params.voice_count * 4);
+
+        std::vector<MemoryPoolInfo> mem_pool_info(memory_pool_count);
+        std::memcpy(mem_pool_info.data(),
+                    buf.data() + sizeof(UpdateDataHeader) + config.behavior_size,
+                    memory_pool_count * sizeof(MemoryPoolInfo));
+
+        std::vector<VoiceInfo> voice_info(worker_params.voice_count);
+        std::memcpy(voice_info.data(),
+                    buf.data() + sizeof(UpdateDataHeader) + config.behavior_size +
+                        config.memory_pools_size + config.voice_resource_size,
+                    worker_params.voice_count * sizeof(VoiceInfo));
+
+        UpdateDataHeader response_data{worker_params};
+
+        ASSERT(ctx.GetWriteBufferSize() == response_data.total_size);
+
+        std::vector<u8> output(response_data.total_size);
+        std::memcpy(output.data(), &response_data, sizeof(UpdateDataHeader));
+        std::vector<MemoryPoolEntry> memory_pool(memory_pool_count);
+        for (unsigned i = 0; i < memory_pool.size(); i++) {
+            if (mem_pool_info[i].pool_state == MemoryPoolStates::RequestAttach)
+                memory_pool[i].state = MemoryPoolStates::Attached;
+            else if (mem_pool_info[i].pool_state == MemoryPoolStates::RequestDetach)
+                memory_pool[i].state = MemoryPoolStates::Detached;
+        }
+        std::memcpy(output.data() + sizeof(UpdateDataHeader), memory_pool.data(),
+                    response_data.memory_pools_size);
+
+        for (unsigned i = 0; i < voice_info.size(); i++) {
+            if (voice_info[i].is_new) {
+                voice_status_list[i].played_sample_count = 0;
+                voice_status_list[i].wave_buffer_consumed = 0;
+            } else if (voice_info[i].play_state == (u8)PlayStates::Started) {
+                for (u32 buff_idx = 0; buff_idx < voice_info[i].wave_buffer_count; buff_idx++) {
+                    voice_status_list[i].played_sample_count +=
+                        (voice_info[i].wave_buffer[buff_idx].end_sample_offset -
+                         voice_info[i].wave_buffer[buff_idx].start_sample_offset) /
+                        2;
+                    voice_status_list[i].wave_buffer_consumed++;
+                }
+            }
+        }
+        std::memcpy(output.data() + sizeof(UpdateDataHeader) + response_data.memory_pools_size,
+                    voice_status_list.data(), response_data.voices_size);
+
+        ctx.WriteBuffer(output);
+
         IPC::ResponseBuilder rb{ctx, 2};
         rb.Push(RESULT_SUCCESS);
+
         LOG_WARNING(Service_Audio, "(STUBBED) called");
     }
 
@@ -69,6 +136,8 @@ private:
     }
 
     void QuerySystemEvent(Kernel::HLERequestContext& ctx) {
+        // system_event->Signal();
+
         IPC::ResponseBuilder rb{ctx, 2, 1};
         rb.Push(RESULT_SUCCESS);
         rb.PushCopyObjects(system_event);
@@ -76,8 +145,131 @@ private:
         LOG_WARNING(Service_Audio, "(STUBBED) called");
     }
 
+    enum class MemoryPoolStates : u32 { // Should be LE
+        Invalid = 0x0,
+        Unknown = 0x1,
+        RequestDetach = 0x2,
+        Detached = 0x3,
+        RequestAttach = 0x4,
+        Attached = 0x5,
+        Released = 0x6,
+    };
+
+    enum class PlayStates : u8 {
+        Started = 0,
+        Stopped = 1,
+    };
+
+    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 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");
+
+    struct BiquadFilter {
+        u8 enable;
+        INSERT_PADDING_BYTES(1);
+        s16_le numerator[3];
+        s16_le denominator[2];
+    };
+    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 loop;
+        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;
+        u8 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;
+        BiquadFilter biquad_filter[2];
+        u32_le wave_buffer_count;
+        u16_le wave_buffer_head;
+        INSERT_PADDING_BYTES(6);
+        u64_le additional_params_addr;
+        u64_le additional_params_sz;
+        u32_le mix_id;
+        u32_le splitter_info_id;
+        WaveBuffer wave_buffer[4];
+        u32_le voice_channel_resource_ids[6];
+        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;
+        INSERT_PADDING_WORDS(1);
+    };
+    static_assert(sizeof(VoiceOutStatus) == 0x10, "VoiceOutStatus has wrong size");
+
+    /// This is used to trigger the audio event callback.
+    CoreTiming::EventType* audio_event;
+
     Kernel::SharedPtr<Kernel::Event> system_event;
-    std::unique_ptr<AudioCore::AudioRenderer> renderer;
+    AudioRendererParameter worker_params;
+    std::vector<VoiceOutStatus> voice_status_list;
 };
 
 class IAudioDevice final : public ServiceFramework<IAudioDevice> {
@@ -176,7 +368,7 @@ AudRenU::AudRenU() : ServiceFramework("audren:u") {
 
 void AudRenU::OpenAudioRenderer(Kernel::HLERequestContext& ctx) {
     IPC::RequestParser rp{ctx};
-    auto params = rp.PopRaw<AudioCore::AudioRendererParameter>();
+    auto params = rp.PopRaw<AudioRendererParameter>();
     IPC::ResponseBuilder rb{ctx, 2, 0, 1};
 
     rb.Push(RESULT_SUCCESS);
@@ -187,7 +379,7 @@ void AudRenU::OpenAudioRenderer(Kernel::HLERequestContext& ctx) {
 
 void AudRenU::GetAudioRendererWorkBufferSize(Kernel::HLERequestContext& ctx) {
     IPC::RequestParser rp{ctx};
-    auto params = rp.PopRaw<AudioCore::AudioRendererParameter>();
+    auto params = rp.PopRaw<AudioRendererParameter>();
 
     u64 buffer_sz = Common::AlignUp(4 * params.unknown_8, 0x40);
     buffer_sz += params.unknown_c * 1024;

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

@@ -4,7 +4,6 @@
 
 #pragma once
 
-#include "audio_core/audio_renderer.h"
 #include "core/hle/service/service.h"
 
 namespace Kernel {
@@ -13,6 +12,24 @@ class HLERequestContext;
 
 namespace Service::Audio {
 
+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");
+
 class AudRenU final : public ServiceFramework<AudRenU> {
 public:
     explicit AudRenU();

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

@@ -337,7 +337,6 @@ public:
              "AcquireNpadStyleSetUpdateEventHandle"},
             {107, nullptr, "DisconnectNpad"},
             {108, &Hid::GetPlayerLedPattern, "GetPlayerLedPattern"},
-            {109, nullptr, "ActivateNpadWithRevision"},
             {120, &Hid::SetNpadJoyHoldType, "SetNpadJoyHoldType"},
             {121, &Hid::GetNpadJoyHoldType, "GetNpadJoyHoldType"},
             {122, &Hid::SetNpadJoyAssignmentModeSingleByDefault,
@@ -457,7 +456,7 @@ private:
     }
 
     void IsSixAxisSensorAtRest(Kernel::HLERequestContext& ctx) {
-        IPC::ResponseBuilder rb{ctx, 3};
+        IPC::ResponseBuilder rb{ctx, 2};
         rb.Push(RESULT_SUCCESS);
         // TODO (Hexagon12): Properly implement reading gyroscope values from controllers.
         rb.Push(true);

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

@@ -7,8 +7,8 @@
 #include "core/core.h"
 #include "core/hle/service/nvdrv/devices/nvdisp_disp0.h"
 #include "core/hle/service/nvdrv/devices/nvmap.h"
-#include "video_core/gpu.h"
 #include "video_core/renderer_base.h"
+#include "video_core/video_core.h"
 
 namespace Service::Nvidia::Devices {
 

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

@@ -2,15 +2,14 @@
 // Licensed under GPLv2 or any later version
 // Refer to the license.txt file included.
 
-#include <cstring>
+#include <cinttypes>
 #include "common/assert.h"
 #include "common/logging/log.h"
 #include "core/core.h"
 #include "core/hle/service/nvdrv/devices/nvhost_as_gpu.h"
 #include "core/hle/service/nvdrv/devices/nvmap.h"
-#include "video_core/memory_manager.h"
-#include "video_core/rasterizer_interface.h"
 #include "video_core/renderer_base.h"
+#include "video_core/video_core.h"
 
 namespace Service::Nvidia::Devices {
 

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

@@ -2,9 +2,6 @@
 // Licensed under GPLv2 or any later version
 // Refer to the license.txt file included.
 
-#include <cstdlib>
-#include <cstring>
-
 #include "common/assert.h"
 #include "common/logging/log.h"
 #include "core/hle/service/nvdrv/devices/nvhost_ctrl.h"

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

@@ -5,6 +5,8 @@
 #pragma once
 
 #include <array>
+#include <cstdlib>
+#include <cstring>
 #include <vector>
 #include "common/common_types.h"
 #include "core/hle/service/nvdrv/devices/nvdevice.h"

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

@@ -2,7 +2,7 @@
 // Licensed under GPLv2 or any later version
 // Refer to the license.txt file included.
 
-#include <cstring>
+#include <cinttypes>
 #include "common/assert.h"
 #include "common/logging/log.h"
 #include "core/hle/service/nvdrv/devices/nvhost_ctrl_gpu.h"

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

@@ -2,14 +2,12 @@
 // Licensed under GPLv2 or any later version
 // Refer to the license.txt file included.
 
-#include <cstring>
+#include <cinttypes>
+#include <map>
 #include "common/assert.h"
 #include "common/logging/log.h"
 #include "core/core.h"
 #include "core/hle/service/nvdrv/devices/nvhost_gpu.h"
-#include "core/memory.h"
-#include "video_core/gpu.h"
-#include "video_core/memory_manager.h"
 
 namespace Service::Nvidia::Devices {
 
@@ -147,7 +145,7 @@ u32 nvhost_gpu::SubmitGPFIFO(const std::vector<u8>& input, std::vector<u8>& outp
     }
     params.fence_out.id = 0;
     params.fence_out.value = 0;
-    std::memcpy(output.data(), &params, sizeof(IoctlSubmitGpfifo));
+    std::memcpy(output.data(), &params, output.size());
     return 0;
 }
 

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

@@ -6,7 +6,6 @@
 
 #include <memory>
 #include <vector>
-#include "common/bit_field.h"
 #include "common/common_types.h"
 #include "common/swap.h"
 #include "core/hle/service/nvdrv/devices/nvdevice.h"

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

@@ -2,8 +2,6 @@
 // Licensed under GPLv2 or any later version
 // Refer to the license.txt file included.
 
-#include <cstring>
-
 #include "common/assert.h"
 #include "common/logging/log.h"
 #include "core/hle/service/nvdrv/devices/nvhost_nvdec.h"

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

@@ -4,9 +4,11 @@
 
 #pragma once
 
+#include <array>
+#include <cstdlib>
+#include <cstring>
 #include <vector>
 #include "common/common_types.h"
-#include "common/swap.h"
 #include "core/hle/service/nvdrv/devices/nvdevice.h"
 
 namespace Service::Nvidia::Devices {

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

@@ -3,7 +3,7 @@
 // Refer to the license.txt file included.
 
 #include <algorithm>
-#include <cstring>
+#include <cinttypes>
 
 #include "common/assert.h"
 #include "common/logging/log.h"

src/core/hle/service/nvdrv/interface.h

@@ -5,6 +5,7 @@
 #pragma once
 
 #include <memory>
+#include <string>
 #include "core/hle/kernel/event.h"
 #include "core/hle/service/nvdrv/nvdrv.h"
 #include "core/hle/service/service.h"

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

@@ -16,18 +16,19 @@
 #include "core/hle/service/nvdrv/interface.h"
 #include "core/hle/service/nvdrv/nvdrv.h"
 #include "core/hle/service/nvdrv/nvmemp.h"
-#include "core/hle/service/nvflinger/nvflinger.h"
 
 namespace Service::Nvidia {
 
-void InstallInterfaces(SM::ServiceManager& service_manager, NVFlinger::NVFlinger& nvflinger) {
+std::weak_ptr<Module> nvdrv;
+
+void InstallInterfaces(SM::ServiceManager& service_manager) {
     auto module_ = std::make_shared<Module>();
     std::make_shared<NVDRV>(module_, "nvdrv")->InstallAsService(service_manager);
     std::make_shared<NVDRV>(module_, "nvdrv:a")->InstallAsService(service_manager);
     std::make_shared<NVDRV>(module_, "nvdrv:s")->InstallAsService(service_manager);
     std::make_shared<NVDRV>(module_, "nvdrv:t")->InstallAsService(service_manager);
     std::make_shared<NVMEMP>()->InstallAsService(service_manager);
-    nvflinger.SetNVDrvInstance(module_);
+    nvdrv = module_;
 }
 
 Module::Module() {
@@ -53,7 +54,7 @@ u32 Module::Open(const std::string& device_name) {
     return fd;
 }
 
-u32 Module::Ioctl(u32 fd, u32 command, const std::vector<u8>& input, std::vector<u8>& output) {
+u32 Module::Ioctl(u32 fd, u32_le command, const std::vector<u8>& input, std::vector<u8>& output) {
     auto itr = open_files.find(fd);
     ASSERT_MSG(itr != open_files.end(), "Tried to talk to an invalid device");
 

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

@@ -10,10 +10,6 @@
 #include "common/common_types.h"
 #include "core/hle/service/service.h"
 
-namespace Service::NVFlinger {
-class NVFlinger;
-}
-
 namespace Service::Nvidia {
 
 namespace Devices {
@@ -60,6 +56,8 @@ private:
 };
 
 /// Registers all NVDRV services with the specified service manager.
-void InstallInterfaces(SM::ServiceManager& service_manager, NVFlinger::NVFlinger& nvflinger);
+void InstallInterfaces(SM::ServiceManager& service_manager);
+
+extern std::weak_ptr<Module> nvdrv;
 
 } // namespace Service::Nvidia

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

@@ -4,6 +4,8 @@
 
 #include "common/assert.h"
 #include "common/logging/log.h"
+#include "core/hle/ipc_helpers.h"
+#include "core/hle/service/nvdrv/nvdrv.h"
 #include "core/hle/service/nvdrv/nvmemp.h"
 
 namespace Service::Nvidia {

src/core/hle/service/nvflinger/nvflinger.cpp

@@ -3,11 +3,8 @@
 // Refer to the license.txt file included.
 
 #include <algorithm>
-#include <boost/optional.hpp>
 
 #include "common/alignment.h"
-#include "common/assert.h"
-#include "common/logging/log.h"
 #include "common/microprofile.h"
 #include "common/scope_exit.h"
 #include "core/core.h"
@@ -34,7 +31,7 @@ NVFlinger::NVFlinger() {
 
     // Schedule the screen composition events
     composition_event =
-        CoreTiming::RegisterEvent("ScreenComposition", [this](u64 userdata, int cycles_late) {
+        CoreTiming::RegisterEvent("ScreenCompositioin", [this](u64 userdata, int cycles_late) {
             Compose();
             CoreTiming::ScheduleEvent(frame_ticks - cycles_late, composition_event);
         });
@@ -46,11 +43,7 @@ NVFlinger::~NVFlinger() {
     CoreTiming::UnscheduleEvent(composition_event, 0);
 }
 
-void NVFlinger::SetNVDrvInstance(std::shared_ptr<Nvidia::Module> instance) {
-    nvdrv = std::move(instance);
-}
-
-u64 NVFlinger::OpenDisplay(std::string_view name) {
+u64 NVFlinger::OpenDisplay(const std::string& name) {
     LOG_WARNING(Service, "Opening display {}", name);
 
     // TODO(Subv): Currently we only support the Default display.
@@ -145,6 +138,9 @@ void NVFlinger::Compose() {
         auto& igbp_buffer = buffer->igbp_buffer;
 
         // Now send the buffer to the GPU for drawing.
+        auto nvdrv = Nvidia::nvdrv.lock();
+        ASSERT(nvdrv);
+
         // TODO(Subv): Support more than just disp0. The display device selection is probably based
         // on which display we're drawing (Default, Internal, External, etc)
         auto nvdisp = nvdrv->GetDevice<Nvidia::Devices::nvdisp_disp0>("/dev/nvdisp_disp0");

src/core/hle/service/nvflinger/nvflinger.h

@@ -5,21 +5,13 @@
 #pragma once
 
 #include <memory>
-#include <string>
-#include <string_view>
-#include <vector>
-
-#include "common/common_types.h"
+#include <boost/optional.hpp>
 #include "core/hle/kernel/event.h"
 
 namespace CoreTiming {
 struct EventType;
 }
 
-namespace Service::Nvidia {
-class Module;
-}
-
 namespace Service::NVFlinger {
 
 class BufferQueue;
@@ -48,11 +40,8 @@ public:
     NVFlinger();
     ~NVFlinger();
 
-    /// Sets the NVDrv module instance to use to send buffers to the GPU.
-    void SetNVDrvInstance(std::shared_ptr<Nvidia::Module> instance);
-
     /// Opens the specified display and returns the id.
-    u64 OpenDisplay(std::string_view name);
+    u64 OpenDisplay(const std::string& name);
 
     /// Creates a layer on the specified display and returns the layer id.
     u64 CreateLayer(u64 display_id);
@@ -77,8 +66,6 @@ private:
     /// Returns the layer identified by the specified id in the desired display.
     Layer& GetLayer(u64 display_id, u64 layer_id);
 
-    std::shared_ptr<Nvidia::Module> nvdrv;
-
     std::vector<Display> displays;
     std::vector<std::shared_ptr<BufferQueue>> buffer_queues;
 

src/core/hle/service/service.cpp

@@ -63,7 +63,6 @@
 #include "core/hle/service/spl/module.h"
 #include "core/hle/service/ssl/ssl.h"
 #include "core/hle/service/time/time.h"
-#include "core/hle/service/usb/usb.h"
 #include "core/hle/service/vi/vi.h"
 #include "core/hle/service/wlan/wlan.h"
 
@@ -238,7 +237,7 @@ void Init(std::shared_ptr<SM::ServiceManager>& sm) {
     NIFM::InstallInterfaces(*sm);
     NIM::InstallInterfaces(*sm);
     NS::InstallInterfaces(*sm);
-    Nvidia::InstallInterfaces(*sm, *nv_flinger);
+    Nvidia::InstallInterfaces(*sm);
     PCIe::InstallInterfaces(*sm);
     PCTL::InstallInterfaces(*sm);
     PCV::InstallInterfaces(*sm);
@@ -250,7 +249,6 @@ void Init(std::shared_ptr<SM::ServiceManager>& sm) {
     SPL::InstallInterfaces(*sm);
     SSL::InstallInterfaces(*sm);
     Time::InstallInterfaces(*sm);
-    USB::InstallInterfaces(*sm);
     VI::InstallInterfaces(*sm, nv_flinger);
     WLAN::InstallInterfaces(*sm);
 

src/core/hle/service/time/time.cpp

@@ -80,8 +80,8 @@ public:
             {5, nullptr, "GetTimeZoneRuleVersion"},
             {100, &ITimeZoneService::ToCalendarTime, "ToCalendarTime"},
             {101, &ITimeZoneService::ToCalendarTimeWithMyRule, "ToCalendarTimeWithMyRule"},
-            {201, nullptr, "ToPosixTime"},
-            {202, nullptr, "ToPosixTimeWithMyRule"},
+            {200, nullptr, "ToPosixTime"},
+            {201, nullptr, "ToPosixTimeWithMyRule"},
         };
         RegisterHandlers(functions);
     }

src/core/hle/service/usb/usb.cpp

@@ -1,238 +0,0 @@
-// Copyright 2018 yuzu emulator team
-// Licensed under GPLv2 or any later version
-// Refer to the license.txt file included.
-
-#include <memory>
-
-#include "common/logging/log.h"
-#include "core/hle/ipc_helpers.h"
-#include "core/hle/kernel/hle_ipc.h"
-#include "core/hle/service/service.h"
-#include "core/hle/service/sm/sm.h"
-#include "core/hle/service/usb/usb.h"
-
-namespace Service::USB {
-
-class IDsInterface final : public ServiceFramework<IDsInterface> {
-public:
-    explicit IDsInterface() : ServiceFramework{"IDsInterface"} {
-        // clang-format off
-        static const FunctionInfo functions[] = {
-            {0, nullptr, "GetDsEndpoint"},
-            {1, nullptr, "GetSetupEvent"},
-            {2, nullptr, "Unknown"},
-            {3, nullptr, "EnableInterface"},
-            {4, nullptr, "DisableInterface"},
-            {5, nullptr, "CtrlInPostBufferAsync"},
-            {6, nullptr, "CtrlOutPostBufferAsync"},
-            {7, nullptr, "GetCtrlInCompletionEvent"},
-            {8, nullptr, "GetCtrlInReportData"},
-            {9, nullptr, "GetCtrlOutCompletionEvent"},
-            {10, nullptr, "GetCtrlOutReportData"},
-            {11, nullptr, "StallCtrl"},
-            {12, nullptr, "AppendConfigurationData"},
-        };
-        // clang-format on
-
-        RegisterHandlers(functions);
-    }
-};
-
-class USB_DS final : public ServiceFramework<USB_DS> {
-public:
-    explicit USB_DS() : ServiceFramework{"usb:ds"} {
-        // clang-format off
-        static const FunctionInfo functions[] = {
-            {0, nullptr, "BindDevice"},
-            {1, nullptr, "BindClientProcess"},
-            {2, nullptr, "GetDsInterface"},
-            {3, nullptr, "GetStateChangeEvent"},
-            {4, nullptr, "GetState"},
-            {5, nullptr, "ClearDeviceData"},
-            {6, nullptr, "AddUsbStringDescriptor"},
-            {7, nullptr, "DeleteUsbStringDescriptor"},
-            {8, nullptr, "SetUsbDeviceDescriptor"},
-            {9, nullptr, "SetBinaryObjectStore"},
-            {10, nullptr, "Enable"},
-            {11, nullptr, "Disable"},
-        };
-        // clang-format on
-
-        RegisterHandlers(functions);
-    }
-};
-
-class IClientEpSession final : public ServiceFramework<IClientEpSession> {
-public:
-    explicit IClientEpSession() : ServiceFramework{"IClientEpSession"} {
-        // clang-format off
-        static const FunctionInfo functions[] = {
-            {0, nullptr, "Unknown1"},
-            {1, nullptr, "Unknown2"},
-            {2, nullptr, "Unknown3"},
-            {3, nullptr, "Unknown4"},
-            {4, nullptr, "PostBufferAsync"},
-            {5, nullptr, "Unknown5"},
-            {6, nullptr, "Unknown6"},
-            {7, nullptr, "Unknown7"},
-            {8, nullptr, "Unknown8"},
-        };
-        // clang-format on
-
-        RegisterHandlers(functions);
-    }
-};
-
-class IClientIfSession final : public ServiceFramework<IClientIfSession> {
-public:
-    explicit IClientIfSession() : ServiceFramework{"IClientIfSession"} {
-        // clang-format off
-        static const FunctionInfo functions[] = {
-            {0, nullptr, "Unknown1"},
-            {1, nullptr, "Unknown2"},
-            {2, nullptr, "Unknown3"},
-            {3, nullptr, "Unknown4"},
-            {4, nullptr, "Unknown5"},
-            {5, nullptr, "CtrlXferAsync"},
-            {6, nullptr, "Unknown6"},
-            {7, nullptr, "GetCtrlXferReport"},
-            {8, nullptr, "Unknown7"},
-            {9, nullptr, "GetClientEpSession"},
-        };
-        // clang-format on
-
-        RegisterHandlers(functions);
-    }
-};
-
-class USB_HS final : public ServiceFramework<USB_HS> {
-public:
-    explicit USB_HS() : ServiceFramework{"usb:hs"} {
-        // clang-format off
-        static const FunctionInfo functions[] = {
-            {0, nullptr, "BindClientProcess"},
-            {1, nullptr, "Unknown1"},
-            {2, nullptr, "Unknown2"},
-            {3, nullptr, "Unknown3"},
-            {4, nullptr, "Unknown4"},
-            {5, nullptr, "Unknown5"},
-            {6, nullptr, "GetInterfaceStateChangeEvent"},
-            {7, nullptr, "GetClientIfSession"},
-        };
-        // clang-format on
-
-        RegisterHandlers(functions);
-    }
-};
-
-class IPdSession final : public ServiceFramework<IPdSession> {
-public:
-    explicit IPdSession() : ServiceFramework{"IPdSession"} {
-        // clang-format off
-        static const FunctionInfo functions[] = {
-            {0, nullptr, "BindNoticeEvent"},
-            {1, nullptr, "Unknown1"},
-            {2, nullptr, "GetStatus"},
-            {3, nullptr, "GetNotice"},
-            {4, nullptr, "Unknown2"},
-            {5, nullptr, "Unknown3"},
-            {6, nullptr, "ReplyPowerRequest"},
-        };
-        // clang-format on
-
-        RegisterHandlers(functions);
-    }
-};
-
-class USB_PD final : public ServiceFramework<USB_PD> {
-public:
-    explicit USB_PD() : ServiceFramework{"usb:pd"} {
-        // clang-format off
-        static const FunctionInfo functions[] = {
-            {0, &USB_PD::GetPdSession, "GetPdSession"},
-        };
-        // clang-format on
-
-        RegisterHandlers(functions);
-    }
-
-private:
-    void GetPdSession(Kernel::HLERequestContext& ctx) {
-        IPC::ResponseBuilder rb{ctx, 2, 0, 1};
-        rb.Push(RESULT_SUCCESS);
-        rb.PushIpcInterface<IPdSession>();
-
-        LOG_DEBUG(Service_USB, "called");
-    }
-};
-
-class IPdCradleSession final : public ServiceFramework<IPdCradleSession> {
-public:
-    explicit IPdCradleSession() : ServiceFramework{"IPdCradleSession"} {
-        // clang-format off
-        static const FunctionInfo functions[] = {
-            {0, nullptr, "VdmUserWrite"},
-            {1, nullptr, "VdmUserRead"},
-            {2, nullptr, "Vdm20Init"},
-            {3, nullptr, "GetFwType"},
-            {4, nullptr, "GetFwRevision"},
-            {5, nullptr, "GetManufacturerId"},
-            {6, nullptr, "GetDeviceId"},
-            {7, nullptr, "Unknown1"},
-            {8, nullptr, "Unknown2"},
-        };
-        // clang-format on
-
-        RegisterHandlers(functions);
-    }
-};
-
-class USB_PD_C final : public ServiceFramework<USB_PD_C> {
-public:
-    explicit USB_PD_C() : ServiceFramework{"usb:pd:c"} {
-        // clang-format off
-        static const FunctionInfo functions[] = {
-            {0, &USB_PD_C::GetPdCradleSession, "GetPdCradleSession"},
-        };
-        // clang-format on
-
-        RegisterHandlers(functions);
-    }
-
-private:
-    void GetPdCradleSession(Kernel::HLERequestContext& ctx) {
-        IPC::ResponseBuilder rb{ctx, 2, 0, 1};
-        rb.Push(RESULT_SUCCESS);
-        rb.PushIpcInterface<IPdCradleSession>();
-
-        LOG_DEBUG(Service_USB, "called");
-    }
-};
-
-class USB_PM final : public ServiceFramework<USB_PM> {
-public:
-    explicit USB_PM() : ServiceFramework{"usb:pm"} {
-        // clang-format off
-        static const FunctionInfo functions[] = {
-            {0, nullptr, "Unknown1"},
-            {1, nullptr, "Unknown2"},
-            {2, nullptr, "Unknown3"},
-            {3, nullptr, "Unknown4"},
-            {4, nullptr, "Unknown5"},
-            {5, nullptr, "Unknown6"},
-        };
-        // clang-format on
-
-        RegisterHandlers(functions);
-    }
-};
-
-void InstallInterfaces(SM::ServiceManager& sm) {
-    std::make_shared<USB_DS>()->InstallAsService(sm);
-    std::make_shared<USB_HS>()->InstallAsService(sm);
-    std::make_shared<USB_PD>()->InstallAsService(sm);
-    std::make_shared<USB_PD_C>()->InstallAsService(sm);
-    std::make_shared<USB_PM>()->InstallAsService(sm);
-}
-
-} // namespace Service::USB

src/core/hle/service/usb/usb.h

@@ -1,15 +0,0 @@
-// Copyright 2018 yuzu emulator team
-// Licensed under GPLv2 or any later version
-// Refer to the license.txt file included.
-
-#pragma once
-
-namespace Service::SM {
-class ServiceManager;
-}
-
-namespace Service::USB {
-
-void InstallInterfaces(SM::ServiceManager& sm);
-
-} // namespace Service::USB

src/core/loader/deconstructed_rom_directory.cpp

@@ -7,7 +7,6 @@
 #include "common/file_util.h"
 #include "common/logging/log.h"
 #include "core/file_sys/content_archive.h"
-#include "core/file_sys/control_metadata.h"
 #include "core/gdbstub/gdbstub.h"
 #include "core/hle/kernel/process.h"
 #include "core/hle/kernel/resource_limit.h"
@@ -18,54 +17,8 @@
 
 namespace Loader {
 
-AppLoader_DeconstructedRomDirectory::AppLoader_DeconstructedRomDirectory(FileSys::VirtualFile file_)
-    : AppLoader(std::move(file_)) {
-    const auto dir = file->GetContainingDirectory();
-
-    // Icon
-    FileSys::VirtualFile icon_file = nullptr;
-    for (const auto& language : FileSys::LANGUAGE_NAMES) {
-        icon_file = dir->GetFile("icon_" + std::string(language) + ".dat");
-        if (icon_file != nullptr) {
-            icon_data = icon_file->ReadAllBytes();
-            break;
-        }
-    }
-
-    if (icon_data.empty()) {
-        // Any png, jpeg, or bmp file
-        const auto& files = dir->GetFiles();
-        const auto icon_iter =
-            std::find_if(files.begin(), files.end(), [](const FileSys::VirtualFile& file) {
-                return file->GetExtension() == "png" || file->GetExtension() == "jpg" ||
-                       file->GetExtension() == "bmp" || file->GetExtension() == "jpeg";
-            });
-        if (icon_iter != files.end())
-            icon_data = (*icon_iter)->ReadAllBytes();
-    }
-
-    // Metadata
-    FileSys::VirtualFile nacp_file = dir->GetFile("control.nacp");
-    if (nacp_file == nullptr) {
-        const auto& files = dir->GetFiles();
-        const auto nacp_iter =
-            std::find_if(files.begin(), files.end(), [](const FileSys::VirtualFile& file) {
-                return file->GetExtension() == "nacp";
-            });
-        if (nacp_iter != files.end())
-            nacp_file = *nacp_iter;
-    }
-
-    if (nacp_file != nullptr) {
-        FileSys::NACP nacp(nacp_file);
-        title_id = nacp.GetTitleId();
-        name = nacp.GetApplicationName();
-    }
-}
-
-AppLoader_DeconstructedRomDirectory::AppLoader_DeconstructedRomDirectory(
-    FileSys::VirtualDir directory)
-    : AppLoader(directory->GetFile("main")), dir(std::move(directory)) {}
+AppLoader_DeconstructedRomDirectory::AppLoader_DeconstructedRomDirectory(FileSys::VirtualFile file)
+    : AppLoader(std::move(file)) {}
 
 FileType AppLoader_DeconstructedRomDirectory::IdentifyType(const FileSys::VirtualFile& file) {
     if (FileSys::IsDirectoryExeFS(file->GetContainingDirectory())) {
@@ -81,12 +34,7 @@ ResultStatus AppLoader_DeconstructedRomDirectory::Load(
         return ResultStatus::ErrorAlreadyLoaded;
     }
 
-    if (dir == nullptr) {
-        if (file == nullptr)
-            return ResultStatus::ErrorInvalidFormat;
-        dir = file->GetContainingDirectory();
-    }
-
+    const FileSys::VirtualDir dir = file->GetContainingDirectory();
     const FileSys::VirtualFile npdm = dir->GetFile("main.npdm");
     if (npdm == nullptr)
         return ResultStatus::ErrorInvalidFormat;
@@ -148,25 +96,4 @@ ResultStatus AppLoader_DeconstructedRomDirectory::ReadRomFS(FileSys::VirtualFile
     return ResultStatus::Success;
 }
 
-ResultStatus AppLoader_DeconstructedRomDirectory::ReadIcon(std::vector<u8>& buffer) {
-    if (icon_data.empty())
-        return ResultStatus::ErrorNotUsed;
-    buffer = icon_data;
-    return ResultStatus::Success;
-}
-
-ResultStatus AppLoader_DeconstructedRomDirectory::ReadProgramId(u64& out_program_id) {
-    if (name.empty())
-        return ResultStatus::ErrorNotUsed;
-    out_program_id = title_id;
-    return ResultStatus::Success;
-}
-
-ResultStatus AppLoader_DeconstructedRomDirectory::ReadTitle(std::string& title) {
-    if (name.empty())
-        return ResultStatus::ErrorNotUsed;
-    title = name;
-    return ResultStatus::Success;
-}
-
 } // namespace Loader

src/core/loader/deconstructed_rom_directory.h

@@ -22,9 +22,6 @@ class AppLoader_DeconstructedRomDirectory final : public AppLoader {
 public:
     explicit AppLoader_DeconstructedRomDirectory(FileSys::VirtualFile main_file);
 
-    // Overload to accept exefs directory. Must contain 'main' and 'main.npdm'
-    explicit AppLoader_DeconstructedRomDirectory(FileSys::VirtualDir directory);
-
     /**
      * Returns the type of the file
      * @param file std::shared_ptr<VfsFile> open file
@@ -39,18 +36,10 @@ public:
     ResultStatus Load(Kernel::SharedPtr<Kernel::Process>& process) override;
 
     ResultStatus ReadRomFS(FileSys::VirtualFile& dir) override;
-    ResultStatus ReadIcon(std::vector<u8>& buffer) override;
-    ResultStatus ReadProgramId(u64& out_program_id) override;
-    ResultStatus ReadTitle(std::string& title) override;
 
 private:
     FileSys::ProgramMetadata metadata;
     FileSys::VirtualFile romfs;
-    FileSys::VirtualDir dir;
-
-    std::vector<u8> icon_data;
-    std::string name;
-    u64 title_id{};
 };
 
 } // namespace Loader

src/core/loader/loader.cpp

@@ -68,7 +68,7 @@ FileType GuessFromFilename(const std::string& name) {
     return FileType::Unknown;
 }
 
-std::string GetFileTypeString(FileType type) {
+const char* GetFileTypeString(FileType type) {
     switch (type) {
     case FileType::ELF:
         return "ELF";

src/core/loader/loader.h

@@ -61,7 +61,7 @@ FileType GuessFromFilename(const std::string& name);
 /**
  * Convert a FileType into a string which can be displayed to the user.
  */
-std::string GetFileTypeString(FileType type);
+const char* GetFileTypeString(FileType type);
 
 /// Return type for functions in Loader namespace
 enum class ResultStatus {

src/core/loader/nca.cpp

@@ -22,8 +22,7 @@
 
 namespace Loader {
 
-AppLoader_NCA::AppLoader_NCA(FileSys::VirtualFile file_)
-    : AppLoader(std::move(file_)), nca(std::make_unique<FileSys::NCA>(file)) {}
+AppLoader_NCA::AppLoader_NCA(FileSys::VirtualFile file) : AppLoader(std::move(file)) {}
 
 FileType AppLoader_NCA::IdentifyType(const FileSys::VirtualFile& file) {
     FileSys::NCA nca(file);
@@ -40,7 +39,8 @@ ResultStatus AppLoader_NCA::Load(Kernel::SharedPtr<Kernel::Process>& process) {
         return ResultStatus::ErrorAlreadyLoaded;
     }
 
-    const auto result = nca->GetStatus();
+    nca = std::make_unique<FileSys::NCA>(file);
+    ResultStatus result = nca->GetStatus();
     if (result != ResultStatus::Success) {
         return result;
     }
@@ -48,16 +48,44 @@ ResultStatus AppLoader_NCA::Load(Kernel::SharedPtr<Kernel::Process>& process) {
     if (nca->GetType() != FileSys::NCAContentType::Program)
         return ResultStatus::ErrorInvalidFormat;
 
-    const auto exefs = nca->GetExeFS();
+    auto exefs = nca->GetExeFS();
 
     if (exefs == nullptr)
         return ResultStatus::ErrorInvalidFormat;
 
-    directory_loader = std::make_unique<AppLoader_DeconstructedRomDirectory>(exefs);
+    result = metadata.Load(exefs->GetFile("main.npdm"));
+    if (result != ResultStatus::Success) {
+        return result;
+    }
+    metadata.Print();
 
-    const auto load_result = directory_loader->Load(process);
-    if (load_result != ResultStatus::Success)
-        return load_result;
+    const FileSys::ProgramAddressSpaceType arch_bits{metadata.GetAddressSpaceType()};
+    if (arch_bits == FileSys::ProgramAddressSpaceType::Is32Bit) {
+        return ResultStatus::ErrorUnsupportedArch;
+    }
+
+    VAddr next_load_addr{Memory::PROCESS_IMAGE_VADDR};
+    for (const auto& module : {"rtld", "main", "subsdk0", "subsdk1", "subsdk2", "subsdk3",
+                               "subsdk4", "subsdk5", "subsdk6", "subsdk7", "sdk"}) {
+        const VAddr load_addr = next_load_addr;
+
+        next_load_addr = AppLoader_NSO::LoadModule(exefs->GetFile(module), load_addr);
+        if (next_load_addr) {
+            LOG_DEBUG(Loader, "loaded module {} @ 0x{:X}", module, load_addr);
+            // Register module with GDBStub
+            GDBStub::RegisterModule(module, load_addr, next_load_addr - 1, false);
+        } else {
+            next_load_addr = load_addr;
+        }
+    }
+
+    process->program_id = metadata.GetTitleID();
+    process->svc_access_mask.set();
+    process->address_mappings = default_address_mappings;
+    process->resource_limit =
+        Kernel::ResourceLimit::GetForCategory(Kernel::ResourceLimitCategory::APPLICATION);
+    process->Run(Memory::PROCESS_IMAGE_VADDR, metadata.GetMainThreadPriority(),
+                 metadata.GetMainThreadStackSize());
 
     if (nca->GetRomFS() != nullptr && nca->GetRomFS()->GetSize() > 0)
         Service::FileSystem::RegisterRomFS(std::make_unique<FileSys::RomFSFactory>(*this));
@@ -77,8 +105,8 @@ ResultStatus AppLoader_NCA::ReadRomFS(FileSys::VirtualFile& dir) {
 }
 
 ResultStatus AppLoader_NCA::ReadProgramId(u64& out_program_id) {
-    if (nca == nullptr || nca->GetStatus() != ResultStatus::Success)
-        return ResultStatus::ErrorInvalidFormat;
+    if (nca == nullptr)
+        return ResultStatus::ErrorNotLoaded;
     out_program_id = nca->GetTitleId();
     return ResultStatus::Success;
 }

src/core/loader/nca.h

@@ -10,7 +10,6 @@
 #include "core/file_sys/program_metadata.h"
 #include "core/hle/kernel/object.h"
 #include "core/loader/loader.h"
-#include "deconstructed_rom_directory.h"
 
 namespace Loader {
 
@@ -33,6 +32,7 @@ public:
     ResultStatus Load(Kernel::SharedPtr<Kernel::Process>& process) override;
 
     ResultStatus ReadRomFS(FileSys::VirtualFile& dir) override;
+
     ResultStatus ReadProgramId(u64& out_program_id) override;
 
     ~AppLoader_NCA();
@@ -40,9 +40,7 @@ public:
 private:
     FileSys::ProgramMetadata metadata;
 
-    FileSys::NCAHeader header;
     std::unique_ptr<FileSys::NCA> nca;
-    std::unique_ptr<AppLoader_DeconstructedRomDirectory> directory_loader;
 };
 
 } // namespace Loader

src/core/loader/xci.cpp

@@ -26,25 +26,7 @@ namespace Loader {
 AppLoader_XCI::AppLoader_XCI(FileSys::VirtualFile file)
     : AppLoader(file), xci(std::make_unique<FileSys::XCI>(file)),
       nca_loader(std::make_unique<AppLoader_NCA>(
-          xci->GetNCAFileByType(FileSys::NCAContentType::Program))) {
-    if (xci->GetStatus() != ResultStatus::Success)
-        return;
-    const auto control_nca = xci->GetNCAByType(FileSys::NCAContentType::Control);
-    if (control_nca == nullptr || control_nca->GetStatus() != ResultStatus::Success)
-        return;
-    const auto romfs = FileSys::ExtractRomFS(control_nca->GetRomFS());
-    if (romfs == nullptr)
-        return;
-    for (const auto& language : FileSys::LANGUAGE_NAMES) {
-        icon_file = romfs->GetFile("icon_" + std::string(language) + ".dat");
-        if (icon_file != nullptr)
-            break;
-    }
-    const auto nacp_raw = romfs->GetFile("control.nacp");
-    if (nacp_raw == nullptr)
-        return;
-    nacp_file = std::make_shared<FileSys::NACP>(nacp_raw);
-}
+          xci->GetNCAFileByType(FileSys::NCAContentType::Program))) {}
 
 AppLoader_XCI::~AppLoader_XCI() = default;
 
@@ -89,17 +71,4 @@ ResultStatus AppLoader_XCI::ReadProgramId(u64& out_program_id) {
     return nca_loader->ReadProgramId(out_program_id);
 }
 
-ResultStatus AppLoader_XCI::ReadIcon(std::vector<u8>& buffer) {
-    if (icon_file == nullptr)
-        return ResultStatus::ErrorInvalidFormat;
-    buffer = icon_file->ReadAllBytes();
-    return ResultStatus::Success;
-}
-
-ResultStatus AppLoader_XCI::ReadTitle(std::string& title) {
-    if (nacp_file == nullptr)
-        return ResultStatus::ErrorInvalidFormat;
-    title = nacp_file->GetApplicationName();
-    return ResultStatus::Success;
-}
 } // namespace Loader

src/core/loader/xci.h

@@ -33,17 +33,12 @@ public:
 
     ResultStatus ReadRomFS(FileSys::VirtualFile& dir) override;
     ResultStatus ReadProgramId(u64& out_program_id) override;
-    ResultStatus ReadIcon(std::vector<u8>& buffer) override;
-    ResultStatus ReadTitle(std::string& title) override;
 
 private:
     FileSys::ProgramMetadata metadata;
 
     std::unique_ptr<FileSys::XCI> xci;
     std::unique_ptr<AppLoader_NCA> nca_loader;
-
-    FileSys::VirtualFile icon_file;
-    std::shared_ptr<FileSys::NACP> nacp_file;
 };
 
 } // namespace Loader

src/core/memory.h

@@ -140,10 +140,10 @@ void SetCurrentPageTable(PageTable* page_table);
 PageTable* GetCurrentPageTable();
 
 /// Determines if the given VAddr is valid for the specified process.
-bool IsValidVirtualAddress(const Kernel::Process& process, VAddr vaddr);
-bool IsValidVirtualAddress(VAddr vaddr);
+bool IsValidVirtualAddress(const Kernel::Process& process, const VAddr vaddr);
+bool IsValidVirtualAddress(const VAddr addr);
 /// Determines if the given VAddr is a kernel address
-bool IsKernelVirtualAddress(VAddr vaddr);
+bool IsKernelVirtualAddress(const VAddr addr);
 
 u8 Read8(VAddr addr);
 u16 Read16(VAddr addr);
@@ -155,17 +155,18 @@ void Write16(VAddr addr, u16 data);
 void Write32(VAddr addr, u32 data);
 void Write64(VAddr addr, u64 data);
 
-void ReadBlock(const Kernel::Process& process, VAddr src_addr, void* dest_buffer, size_t size);
-void ReadBlock(VAddr src_addr, void* dest_buffer, size_t size);
-void WriteBlock(const Kernel::Process& process, VAddr dest_addr, const void* src_buffer,
+void ReadBlock(const Kernel::Process& process, const VAddr src_addr, void* dest_buffer,
+               size_t size);
+void ReadBlock(const VAddr src_addr, void* dest_buffer, size_t size);
+void WriteBlock(const Kernel::Process& process, const VAddr dest_addr, const void* src_buffer,
                 size_t size);
-void WriteBlock(VAddr dest_addr, const void* src_buffer, size_t size);
-void ZeroBlock(const Kernel::Process& process, VAddr dest_addr, size_t size);
+void WriteBlock(const VAddr dest_addr, const void* src_buffer, size_t size);
+void ZeroBlock(const VAddr dest_addr, const size_t size);
 void CopyBlock(VAddr dest_addr, VAddr src_addr, size_t size);
 
-u8* GetPointer(VAddr vaddr);
+u8* GetPointer(VAddr virtual_address);
 
-std::string ReadCString(VAddr vaddr, std::size_t max_length);
+std::string ReadCString(VAddr virtual_address, std::size_t max_length);
 
 enum class FlushMode {
     /// Write back modified surfaces to RAM
@@ -179,7 +180,7 @@ enum class FlushMode {
 /**
  * Mark each page touching the region as cached.
  */
-void RasterizerMarkRegionCached(Tegra::GPUVAddr gpu_addr, u64 size, bool cached);
+void RasterizerMarkRegionCached(Tegra::GPUVAddr start, u64 size, bool cached);
 
 /**
  * Flushes and invalidates any externally cached rasterizer resources touching the given virtual

src/core/perf_stats.cpp

@@ -40,21 +40,22 @@ void PerfStats::EndGameFrame() {
     game_frames += 1;
 }
 
-PerfStats::Results PerfStats::GetAndResetStats(microseconds current_system_time_us) {
+PerfStats::Results PerfStats::GetAndResetStats(u64 current_system_time_us) {
     std::lock_guard<std::mutex> lock(object_mutex);
 
-    const auto now = Clock::now();
+    auto now = Clock::now();
     // Walltime elapsed since stats were reset
-    const auto interval = duration_cast<DoubleSecs>(now - reset_point).count();
+    auto interval = duration_cast<DoubleSecs>(now - reset_point).count();
 
-    const auto system_us_per_second = (current_system_time_us - reset_point_system_us) / interval;
+    auto system_us_per_second =
+        static_cast<double>(current_system_time_us - reset_point_system_us) / interval;
 
     Results results{};
     results.system_fps = static_cast<double>(system_frames) / interval;
     results.game_fps = static_cast<double>(game_frames) / interval;
     results.frametime = duration_cast<DoubleSecs>(accumulated_frametime).count() /
                         static_cast<double>(system_frames);
-    results.emulation_speed = system_us_per_second.count() / 1'000'000.0;
+    results.emulation_speed = system_us_per_second / 1'000'000.0;
 
     // Reset counters
     reset_point = now;
@@ -73,10 +74,10 @@ double PerfStats::GetLastFrameTimeScale() {
     return duration_cast<DoubleSecs>(previous_frame_length).count() / FRAME_LENGTH;
 }
 
-void FrameLimiter::DoFrameLimiting(microseconds current_system_time_us) {
+void FrameLimiter::DoFrameLimiting(u64 current_system_time_us) {
     // Max lag caused by slow frames. Can be adjusted to compensate for too many slow frames. Higher
     // values increase the time needed to recover and limit framerate again after spikes.
-    constexpr microseconds MAX_LAG_TIME_US = 25us;
+    constexpr microseconds MAX_LAG_TIME_US = 25ms;
 
     if (!Settings::values.toggle_framelimit) {
         return;
@@ -84,7 +85,7 @@ void FrameLimiter::DoFrameLimiting(microseconds current_system_time_us) {
 
     auto now = Clock::now();
 
-    frame_limiting_delta_err += current_system_time_us - previous_system_time_us;
+    frame_limiting_delta_err += microseconds(current_system_time_us - previous_system_time_us);
     frame_limiting_delta_err -= duration_cast<microseconds>(now - previous_walltime);
     frame_limiting_delta_err =
         std::clamp(frame_limiting_delta_err, -MAX_LAG_TIME_US, MAX_LAG_TIME_US);

src/core/perf_stats.h

@@ -33,7 +33,7 @@ public:
     void EndSystemFrame();
     void EndGameFrame();
 
-    Results GetAndResetStats(std::chrono::microseconds current_system_time_us);
+    Results GetAndResetStats(u64 current_system_time_us);
 
     /**
      * Gets the ratio between walltime and the emulated time of the previous system frame. This is
@@ -47,7 +47,7 @@ private:
     /// Point when the cumulative counters were reset
     Clock::time_point reset_point = Clock::now();
     /// System time when the cumulative counters were reset
-    std::chrono::microseconds reset_point_system_us{0};
+    u64 reset_point_system_us = 0;
 
     /// Cumulative duration (excluding v-sync/frame-limiting) of frames since last reset
     Clock::duration accumulated_frametime = Clock::duration::zero();
@@ -68,11 +68,11 @@ class FrameLimiter {
 public:
     using Clock = std::chrono::high_resolution_clock;
 
-    void DoFrameLimiting(std::chrono::microseconds current_system_time_us);
+    void DoFrameLimiting(u64 current_system_time_us);
 
 private:
     /// Emulated system time (in microseconds) at the last limiter invocation
-    std::chrono::microseconds previous_system_time_us{0};
+    u64 previous_system_time_us = 0;
     /// Walltime at the last limiter invocation
     Clock::time_point previous_walltime = Clock::now();
 

src/tests/common/param_package.cpp

@@ -2,7 +2,7 @@
 // Licensed under GPLv2 or any later version
 // Refer to the license.txt file included.
 
-#include <catch2/catch.hpp>
+#include <catch.hpp>
 #include <math.h>
 #include "common/param_package.h"
 

src/tests/core/core_timing.cpp

@@ -2,7 +2,7 @@
 // Licensed under GPLv2+
 // Refer to the license.txt file included.
 
-#include <catch2/catch.hpp>
+#include <catch.hpp>
 
 #include <array>
 #include <bitset>

src/tests/glad.cpp

@@ -2,7 +2,7 @@
 // Licensed under GPLv2 or any later version
 // Refer to the license.txt file included.
 
-#include <catch2/catch.hpp>
+#include <catch.hpp>
 #include <glad/glad.h>
 
 // This is not an actual test, but a work-around for issue #2183.

src/tests/tests.cpp

@@ -3,7 +3,7 @@
 // Refer to the license.txt file included.
 
 #define CATCH_CONFIG_MAIN
-#include <catch2/catch.hpp>
+#include <catch.hpp>
 
 // Catch provides the main function since we've given it the
 // CATCH_CONFIG_MAIN preprocessor directive.