Reapply "[core/memory] remove indirection handling for unaligned access (#3584)" (#3725)

This reverts commit 59b0e66722.

cpmfile.json

@@ -179,6 +179,12 @@
         "repo": "eden-emulator/oaknut",
         "version": "v2.0.3"
     },
+    "oboe": {
+        "bundled": true,
+        "hash": "ce4011afe7345370d4ead3b891cd69a5ef224b129535783586c0ca75051d303ed446e6c7f10bde8da31fff58d6e307f1732a3ffd03b249f9ef1fd48fd4132715",
+        "repo": "google/oboe",
+        "version": "1.10.0"
+    },
     "openssl": {
         "hash": "29002ce50cb95a4f4f1d0e9d3f684401fbd4eac34203dc2eef3b6334af5d44aa46bf788b63a6f5c139c383eafb7269ae87a58a9a3ad5912903b9773e545ccc0a",
         "min_version": "3.0.0",

externals/CMakeLists.txt

@@ -388,6 +388,13 @@ if (YUZU_CRASH_DUMPS AND NOT TARGET libbreakpad_client)
     endif()
 endif()
 
+# oboe
+if (ANDROID)
+    AddJsonPackage(oboe)
+
+    add_library(oboe::oboe ALIAS oboe)
+endif()
+
 if (APPLE)
     # moltenvk
     if (NOT YUZU_USE_BUNDLED_MOLTENVK)

src/android/app/src/main/res/values-fa/strings.xml

@@ -799,6 +799,10 @@
     <string name="theme_mode_light">روشن</string>
     <string name="theme_mode_dark">تاریک</string>
 
+    <!-- Audio output engines -->
+    <string name="oboe">oboe</string>
+    <string name="cubeb">cubeb</string>
+
     <!-- Anisotropic filtering options -->
     <string name="multiplier_x2">x2</string>
     <string name="multiplier_x4">x4</string>

src/android/app/src/main/res/values/arrays.xml

@@ -465,14 +465,14 @@
 
     <string-array name="outputEngineEntries">
         <item>@string/auto</item>
+        <item>@string/oboe</item>
         <item>@string/cubeb</item>
-        <item>@string/sdl3</item>
         <item>@string/string_null</item>
     </string-array>
     <integer-array name="outputEngineValues">
         <item>0</item>
+        <item>4</item>
         <item>1</item>
-        <item>2</item>
         <item>3</item>
     </integer-array>
 

src/android/app/src/main/res/values/strings.xml

@@ -1240,7 +1240,7 @@
     <string name="theme_mode_dark">Dark</string>
 
     <!-- Audio output engines -->
-    <string name="sdl3" translatable="false">sdl3</string>
+    <string name="oboe" translatable="false">oboe</string>
     <string name="cubeb" translatable="false">cubeb</string>
 
     <!-- Anisotropic filtering options -->

src/audio_core/CMakeLists.txt

@@ -238,10 +238,20 @@ if (ENABLE_CUBEB)
     target_compile_definitions(audio_core PRIVATE HAVE_CUBEB=1)
 endif()
 
-target_sources(audio_core PRIVATE
-    sink/sdl3_sink.cpp
-    sink/sdl3_sink.h)
-target_link_libraries(audio_core PRIVATE SDL3::SDL3)
-target_compile_definitions(audio_core PRIVATE HAVE_SDL3)
+if(ANDROID)
+    target_sources(audio_core PRIVATE
+        sink/oboe_sink.cpp
+        sink/oboe_sink.h)
+
+    target_link_libraries(audio_core PRIVATE oboe)
+    target_compile_definitions(audio_core PUBLIC HAVE_OBOE)
+else()
+    target_sources(audio_core PRIVATE
+        sink/sdl3_sink.cpp
+        sink/sdl3_sink.h)
+
+    target_link_libraries(audio_core PRIVATE SDL3::SDL3)
+    target_compile_definitions(audio_core PRIVATE HAVE_SDL3)
+endif()
 
 create_target_directory_groups(audio_core)

src/audio_core/sink/oboe_sink.cpp

@@ -0,0 +1,230 @@
+// SPDX-FileCopyrightText: Copyright 2026 Eden Emulator Project
+// SPDX-License-Identifier: GPL-3.0-or-later
+
+// SPDX-FileCopyrightText: Copyright 2023 yuzu Emulator Project
+// SPDX-License-Identifier: GPL-2.0-or-later
+
+#include <span>
+#include <vector>
+
+#include <oboe/Oboe.h>
+
+#include "audio_core/common/common.h"
+#include "audio_core/sink/oboe_sink.h"
+#include "audio_core/sink/sink_stream.h"
+#include "common/logging.h"
+#include "common/scope_exit.h"
+#include "core/core.h"
+
+namespace AudioCore::Sink {
+
+class OboeSinkStream final : public SinkStream,
+                             public oboe::AudioStreamDataCallback,
+                             public oboe::AudioStreamErrorCallback {
+public:
+    explicit OboeSinkStream(Core::System& system_, StreamType type_, const std::string& name_,
+                            u32 system_channels_)
+        : SinkStream(system_, type_) {
+        name = name_;
+        system_channels = system_channels_;
+
+        this->OpenStream();
+    }
+
+    ~OboeSinkStream() override {
+        LOG_INFO(Audio_Sink, "Destroyed Oboe stream");
+    }
+
+    void Finalize() override {
+        this->Stop();
+        m_stream.reset();
+    }
+
+    void Start(bool resume = false) override {
+        if (!m_stream || !paused) {
+            return;
+        }
+
+        paused = false;
+
+        if (m_stream->start() != oboe::Result::OK) {
+            LOG_CRITICAL(Audio_Sink, "Error starting Oboe stream");
+        }
+    }
+
+    void Stop() override {
+        if (!m_stream || paused) {
+            return;
+        }
+
+        this->SignalPause();
+
+        if (m_stream->stop() != oboe::Result::OK) {
+            LOG_CRITICAL(Audio_Sink, "Error stopping Oboe stream");
+        }
+    }
+
+public:
+    static s32 QueryChannelCount(oboe::Direction direction) {
+        std::shared_ptr<oboe::AudioStream> temp_stream;
+        oboe::AudioStreamBuilder builder;
+
+        const auto result = ConfigureBuilder(builder, direction)->openStream(temp_stream);
+        if (result == oboe::Result::OK) {
+            return temp_stream->getChannelCount() >= 6 ? 6 : 2;
+        }
+
+        LOG_ERROR(Audio_Sink, "Failed to open {} stream. Using default channel count 2",
+                  direction == oboe::Direction::Output ? "output" : "input");
+        return 2;
+    }
+
+protected:
+    oboe::DataCallbackResult onAudioReady(oboe::AudioStream*, void* audio_data,
+                                          s32 num_buffer_frames) override {
+        const size_t num_channels = this->GetDeviceChannels();
+        const size_t frame_size = num_channels;
+        const size_t num_frames = static_cast<size_t>(num_buffer_frames);
+
+        if (type == StreamType::In) {
+            std::span<const s16> input_buffer{reinterpret_cast<const s16*>(audio_data),
+                                              num_frames * frame_size};
+            this->ProcessAudioIn(input_buffer, num_frames);
+        } else {
+            std::span<s16> output_buffer{reinterpret_cast<s16*>(audio_data),
+                                         num_frames * frame_size};
+            this->ProcessAudioOutAndRender(output_buffer, num_frames);
+        }
+
+        return oboe::DataCallbackResult::Continue;
+    }
+
+    void onErrorAfterClose(oboe::AudioStream*, oboe::Result) override {
+        LOG_INFO(Audio_Sink, "Audio stream closed, reinitializing");
+
+        if (this->OpenStream()) {
+            m_stream->start();
+        }
+    }
+
+private:
+    static oboe::AudioStreamBuilder* ConfigureBuilder(oboe::AudioStreamBuilder& builder,
+                                                      oboe::Direction direction) {
+        // TODO: investigate callback delay issues when using AAudio
+        return builder.setPerformanceMode(oboe::PerformanceMode::LowLatency)
+            ->setAudioApi(oboe::AudioApi::OpenSLES)
+            ->setDirection(direction)
+            ->setSampleRate(TargetSampleRate)
+            ->setSampleRateConversionQuality(oboe::SampleRateConversionQuality::High)
+            ->setFormat(oboe::AudioFormat::I16)
+            ->setFormatConversionAllowed(true)
+            ->setUsage(oboe::Usage::Game)
+            ->setBufferCapacityInFrames(TargetSampleCount * 2);
+    }
+
+    bool OpenStream() {
+        const auto direction = [&]() {
+            switch (type) {
+            case StreamType::In:
+                return oboe::Direction::Input;
+            case StreamType::Out:
+            case StreamType::Render:
+                return oboe::Direction::Output;
+            default:
+                ASSERT(false);
+                return oboe::Direction::Output;
+            }
+        }();
+
+        const auto expected_channels = QueryChannelCount(direction);
+        const auto expected_mask = [&]() {
+            switch (expected_channels) {
+            case 1:
+                return oboe::ChannelMask::Mono;
+            case 2:
+                return oboe::ChannelMask::Stereo;
+            case 6:
+                return oboe::ChannelMask::CM5Point1;
+            default:
+                ASSERT(false);
+                return oboe::ChannelMask::Unspecified;
+            }
+        }();
+
+        oboe::AudioStreamBuilder builder;
+        const auto result = ConfigureBuilder(builder, direction)
+                                ->setChannelCount(expected_channels)
+                                ->setChannelMask(expected_mask)
+                                ->setChannelConversionAllowed(true)
+                                ->setDataCallback(this)
+                                ->setErrorCallback(this)
+                                ->openStream(m_stream);
+        ASSERT(result == oboe::Result::OK);
+        return result == oboe::Result::OK && this->SetStreamProperties();
+    }
+
+    bool SetStreamProperties() {
+        ASSERT(m_stream);
+
+        m_stream->setBufferSizeInFrames(TargetSampleCount * 2);
+        device_channels = m_stream->getChannelCount();
+
+        const auto sample_rate = m_stream->getSampleRate();
+        const auto buffer_capacity = m_stream->getBufferCapacityInFrames();
+        const auto stream_backend =
+            m_stream->getAudioApi() == oboe::AudioApi::AAudio ? "AAudio" : "OpenSLES";
+
+        LOG_INFO(Audio_Sink, "Opened Oboe {} stream with {} channels sample rate {} capacity {}",
+                 stream_backend, device_channels, sample_rate, buffer_capacity);
+
+        return true;
+    }
+
+    std::shared_ptr<oboe::AudioStream> m_stream{};
+};
+
+OboeSink::OboeSink() {
+    // TODO: This is not generally knowable
+    // The channel count is distinct based on direction and can change
+    device_channels = OboeSinkStream::QueryChannelCount(oboe::Direction::Output);
+}
+
+OboeSink::~OboeSink() = default;
+
+SinkStream* OboeSink::AcquireSinkStream(Core::System& system, u32 system_channels,
+                                        const std::string& name, StreamType type) {
+    SinkStreamPtr& stream = sink_streams.emplace_back(
+        std::make_unique<OboeSinkStream>(system, type, name, system_channels));
+
+    return stream.get();
+}
+
+void OboeSink::CloseStream(SinkStream* to_remove) {
+    sink_streams.remove_if([&](auto& stream) { return stream.get() == to_remove; });
+}
+
+void OboeSink::CloseStreams() {
+    sink_streams.clear();
+}
+
+f32 OboeSink::GetDeviceVolume() const {
+    if (sink_streams.empty()) {
+        return 1.0f;
+    }
+
+    return sink_streams.front()->GetDeviceVolume();
+}
+
+void OboeSink::SetDeviceVolume(f32 volume) {
+    for (auto& stream : sink_streams) {
+        stream->SetDeviceVolume(volume);
+    }
+}
+
+void OboeSink::SetSystemVolume(f32 volume) {
+    for (auto& stream : sink_streams) {
+        stream->SetSystemVolume(volume);
+    }
+}
+
+} // namespace AudioCore::Sink

src/audio_core/sink/oboe_sink.h

@@ -0,0 +1,75 @@
+// SPDX-FileCopyrightText: Copyright 2023 yuzu Emulator Project
+// SPDX-License-Identifier: GPL-2.0-or-later
+
+#pragma once
+
+#include <list>
+#include <string>
+
+#include "audio_core/sink/sink.h"
+
+namespace Core {
+class System;
+}
+
+namespace AudioCore::Sink {
+class SinkStream;
+
+class OboeSink final : public Sink {
+public:
+    explicit OboeSink();
+    ~OboeSink() override;
+
+    /**
+     * Create a new sink stream.
+     *
+     * @param system          - Core system.
+     * @param system_channels - Number of channels the audio system expects.
+     *                          May differ from the device's channel count.
+     * @param name            - Name of this stream.
+     * @param type            - Type of this stream, render/in/out.
+     *
+     * @return A pointer to the created SinkStream
+     */
+    SinkStream* AcquireSinkStream(Core::System& system, u32 system_channels,
+                                  const std::string& name, StreamType type) override;
+
+    /**
+     * Close a given stream.
+     *
+     * @param stream - The stream to close.
+     */
+    void CloseStream(SinkStream* stream) override;
+
+    /**
+     * Close all streams.
+     */
+    void CloseStreams() override;
+
+    /**
+     * Get the device volume. Set from calls to the IAudioDevice service.
+     *
+     * @return Volume of the device.
+     */
+    f32 GetDeviceVolume() const override;
+
+    /**
+     * Set the device volume. Set from calls to the IAudioDevice service.
+     *
+     * @param volume - New volume of the device.
+     */
+    void SetDeviceVolume(f32 volume) override;
+
+    /**
+     * Set the system volume. Comes from the audio system using this stream.
+     *
+     * @param volume - New volume of the system.
+     */
+    void SetSystemVolume(f32 volume) override;
+
+private:
+    /// List of streams managed by this sink
+    std::list<SinkStreamPtr> sink_streams{};
+};
+
+} // namespace AudioCore::Sink

src/audio_core/sink/sink_details.cpp

@@ -10,6 +10,9 @@
 #include <vector>
 
 #include "audio_core/sink/sink_details.h"
+#ifdef HAVE_OBOE
+#include "audio_core/sink/oboe_sink.h"
+#endif
 #ifdef HAVE_CUBEB
 #include "audio_core/sink/cubeb_sink.h"
 #endif
@@ -48,6 +51,16 @@ struct SinkDetails {
 
 // sink_details is ordered in terms of desirability, with the best choice at the top.
 constexpr SinkDetails sink_details[] = {
+#ifdef HAVE_OBOE
+    SinkDetails{
+        Settings::AudioEngine::Oboe,
+        [](std::string_view device_id) -> std::unique_ptr<Sink> {
+            return std::make_unique<OboeSink>();
+        },
+        [](bool capture) { return std::vector<std::string>{"Default"}; },
+        []() { return 0u; },
+    },
+#endif
 #ifdef HAVE_CUBEB
     SinkDetails{
         Settings::AudioEngine::Cubeb,

src/common/settings_enums.h

@@ -92,14 +92,14 @@ struct EnumMetadata {
 // AudioEngine must be specified discretely due to having existing but slightly different
 // canonicalizations
 // TODO (lat9nq): Remove explicit definition of AudioEngine/sink_id
-enum class AudioEngine : u32 { Auto, Cubeb, Sdl3, Null, };
+enum class AudioEngine : u32 { Auto, Cubeb, Sdl3, Null, Oboe, };
 template<>
 inline std::vector<std::pair<std::string_view, AudioEngine>> EnumMetadata<AudioEngine>::Canonicalizations() {
     return {
         {"auto", AudioEngine::Auto},
         {"cubeb", AudioEngine::Cubeb},
         {"sdl3", AudioEngine::Sdl3},
-        {"null", AudioEngine::Null},
+        {"null", AudioEngine::Null}, {"oboe", AudioEngine::Oboe},
     };
 }
 /// @brief This is just a sufficiently large number that is more than the number of other enums declared here
@@ -113,7 +113,7 @@ inline AudioEngine EnumMetadata<AudioEngine>::GetFirst() {
 }
 template<>
 inline AudioEngine EnumMetadata<AudioEngine>::GetLast() {
-    return AudioEngine::Null;
+    return AudioEngine::Oboe;
 }
 
 ENUM(AudioMode, Mono, Stereo, Surround);

src/core/memory.cpp

@@ -6,6 +6,7 @@
 // SPDX-License-Identifier: GPL-2.0-or-later
 
 #include <algorithm>
+#include <bit>
 #include <cstring>
 #include <mutex>
 #include <span>
@@ -122,83 +123,14 @@ struct Memory::Impl {
         }
     }
 
-    [[nodiscard]] u8* GetPointerFromRasterizerCachedMemory(u64 vaddr) const {
-        Common::PhysicalAddress const paddr = current_page_table->entries[vaddr >> YUZU_PAGEBITS].addr;
-        if (paddr)
-            return system.DeviceMemory().GetPointer<u8>(paddr + vaddr);
-        return {};
+    [[nodiscard]] inline u8* GetPointerFromRasterizerCachedMemory(u64 vaddr) const {
+        auto const paddr = current_page_table->entries[vaddr >> YUZU_PAGEBITS].addr;
+        return paddr ? system.DeviceMemory().GetPointer<u8>(paddr + vaddr) : nullptr;
     }
 
-    [[nodiscard]] u8* GetPointerFromDebugMemory(u64 vaddr) const {
-        const Common::PhysicalAddress paddr = current_page_table->entries[vaddr >> YUZU_PAGEBITS].addr;
-        if (paddr != 0)
-            return system.DeviceMemory().GetPointer<u8>(paddr + vaddr);
-        return {};
-    }
-
-    u8 Read8(const Common::ProcessAddress addr) {
-        return Read<u8>(addr);
-    }
-
-    u16 Read16(const Common::ProcessAddress addr) {
-        if ((addr & 1) == 0) {
-            return Read<u16_le>(addr);
-        } else {
-            const u32 a{Read<u8>(addr)};
-            const u32 b{Read<u8>(addr + sizeof(u8))};
-            return static_cast<u16>((b << 8) | a);
-        }
-    }
-
-    u32 Read32(const Common::ProcessAddress addr) {
-        if ((addr & 3) == 0) {
-            return Read<u32_le>(addr);
-        } else {
-            const u32 a{Read16(addr)};
-            const u32 b{Read16(addr + sizeof(u16))};
-            return (b << 16) | a;
-        }
-    }
-
-    u64 Read64(const Common::ProcessAddress addr) {
-        if ((addr & 7) == 0) {
-            return Read<u64_le>(addr);
-        } else {
-            const u32 a{Read32(addr)};
-            const u32 b{Read32(addr + sizeof(u32))};
-            return (static_cast<u64>(b) << 32) | a;
-        }
-    }
-
-    void Write8(const Common::ProcessAddress addr, const u8 data) {
-        Write<u8>(addr, data);
-    }
-
-    void Write16(const Common::ProcessAddress addr, const u16 data) {
-        if ((addr & 1) == 0) {
-            Write<u16_le>(addr, data);
-        } else {
-            Write<u8>(addr, static_cast<u8>(data));
-            Write<u8>(addr + sizeof(u8), static_cast<u8>(data >> 8));
-        }
-    }
-
-    void Write32(const Common::ProcessAddress addr, const u32 data) {
-        if ((addr & 3) == 0) {
-            Write<u32_le>(addr, data);
-        } else {
-            Write16(addr, static_cast<u16>(data));
-            Write16(addr + sizeof(u16), static_cast<u16>(data >> 16));
-        }
-    }
-
-    void Write64(const Common::ProcessAddress addr, const u64 data) {
-        if ((addr & 7) == 0) {
-            Write<u64_le>(addr, data);
-        } else {
-            Write32(addr, static_cast<u32>(data));
-            Write32(addr + sizeof(u32), static_cast<u32>(data >> 32));
-        }
+    [[nodiscard]] inline u8* GetPointerFromDebugMemory(u64 vaddr) const {
+        auto const paddr = current_page_table->entries[vaddr >> YUZU_PAGEBITS].addr;
+        return paddr ? system.DeviceMemory().GetPointer<u8>(paddr + vaddr) : nullptr;
     }
 
     bool WriteExclusive8(const Common::ProcessAddress addr, const u8 data, const u8 expected) {
@@ -564,7 +496,7 @@ struct Memory::Impl {
     }
 
     template<typename F, typename G>
-    [[nodiscard]] u8* GetPointerImpl(u64 vaddr, F&& on_unmapped, G&& on_rasterizer) const {
+    [[nodiscard]] inline u8* GetPointerImpl(u64 vaddr, F&& on_unmapped, G&& on_rasterizer) const {
         // AARCH64 masks the upper 16 bit of all memory accesses
         vaddr &= 0xffffffffffffULL;
         if (AddressSpaceContains(*current_page_table, vaddr, 1)) [[likely]] {
@@ -619,18 +551,42 @@ struct Memory::Impl {
     /// @returns The instance of T read from the specified virtual address.
     template <typename T>
     inline T Read(Common::ProcessAddress vaddr) noexcept requires(std::is_trivially_copyable_v<T>) {
-        const u64 addr = GetInteger(vaddr);
-        if (auto const ptr = GetPointerImpl(addr, [addr]() {
-            LOG_ERROR(HW_Memory, "Unmapped Read{} @ {:#016x}", sizeof(T) * 8, addr);
-        }, [&]() {
-            HandleRasterizerDownload(addr, sizeof(T));
-        }); ptr) [[likely]] {
-            // It may be tempting to rewrite this particular section to use "reinterpret_cast";
-            // afterall, it's trivially copyable so surely it can be copied ov- Alignment.
-            // Remember, alignment. memcpy() will deal with all the alignment extremely fast.
-            T result{};
-            std::memcpy(&result, ptr, sizeof(T));
-            return result;
+        auto const addr_c1 = GetInteger(vaddr);
+        if (!(sizeof(T) > 1 && (addr_c1 & 4095) + sizeof(T) > 4096)) {
+            if (auto const ptr_c1 = GetPointerImpl(addr_c1, [addr_c1] {
+                LOG_ERROR(HW_Memory, "Unmapped Read{} @ {:#016X}", sizeof(T) * 8, addr_c1);
+            }, [&] {
+                HandleRasterizerDownload(addr_c1, sizeof(T));
+            }); ptr_c1) {
+                // It may be tempting to rewrite this particular section to use "reinterpret_cast";
+                // afterall, it's trivially copyable so surely it can be copied ov- Alignment.
+                // Remember, alignment. memcpy() will deal with all the alignment extremely fast.
+                T result{};
+                std::memcpy(&result, ptr_c1, sizeof(T));
+                return result;
+            }
+        } else {
+            auto const addr_c2 = (addr_c1 & (~0xfff)) + 0x1000;
+            // page crossing: say if sizeof(T) = 2, vaddr = 4095
+            // 4095 + 2 mod 4096 = 1 => 2 - 1 = 1, thus c1=1, c2=1
+            auto const count_c2 = (addr_c1 + sizeof(T)) & 4095;
+            auto const count_c1 = sizeof(T) - count_c2;
+            if (auto const ptr_c1 = GetPointerImpl(addr_c1, [addr_c1] {
+                LOG_ERROR(HW_Memory, "Unmapped Read{} @ {:#016X}", sizeof(T) * 8, addr_c1);
+            }, [&] {
+                HandleRasterizerDownload(addr_c1, count_c1);
+            }); ptr_c1) {
+                if (auto const ptr_c2 = GetPointerImpl(addr_c2, [addr_c2] {
+                    LOG_ERROR(HW_Memory, "Unmapped Read{} @ {:#016X}", sizeof(T) * 8, addr_c2);
+                }, [&] {
+                    HandleRasterizerDownload(addr_c2, count_c2);
+                }); ptr_c2) {
+                    std::array<char, sizeof(T)> result{};
+                    std::memcpy(result.data() + 0, ptr_c1, count_c1);
+                    std::memcpy(result.data() + count_c1, ptr_c2, count_c2);
+                    return std::bit_cast<T>(result);
+                }
+            }
         }
         return T{};
     }
@@ -640,11 +596,37 @@ struct Memory::Impl {
     /// @tparam T The data type to write to memory.
     template <typename T>
     inline void Write(Common::ProcessAddress vaddr, const T data) noexcept requires(std::is_trivially_copyable_v<T>) {
-        const u64 addr = GetInteger(vaddr);
-        if (auto const ptr = GetPointerImpl(addr, [addr, data]() {
-            LOG_ERROR(HW_Memory, "Unmapped Write{} @ {:#016x} = {:#016x}", sizeof(T) * 8, addr, u64(data));
-        }, [&]() { HandleRasterizerWrite(addr, sizeof(T)); }); ptr) [[likely]]
-            std::memcpy(ptr, &data, sizeof(T));
+        auto const addr_c1 = GetInteger(vaddr);
+        if (!(sizeof(T) > 1 && (addr_c1 & 4095) + sizeof(T) > 4096)) {
+            if (auto const ptr_c1 = GetPointerImpl(addr_c1, [addr_c1] {
+                LOG_ERROR(HW_Memory, "Unmapped Read{} @ {:#016X}", sizeof(T) * 8, addr_c1);
+            }, [&] {
+                HandleRasterizerWrite(addr_c1, sizeof(T));
+            }); ptr_c1) {
+                std::memcpy(ptr_c1, &data, sizeof(T));
+            }
+        } else {
+            auto const addr_c2 = (addr_c1 & (~0xfff)) + 0x1000;
+            // page crossing: say if sizeof(T) = 2, vaddr = 4095
+            // 4095 + 2 mod 4096 = 1 => 2 - 1 = 1, thus c1=1, c2=1
+            auto const count_c2 = (addr_c1 + sizeof(T)) & 4095;
+            auto const count_c1 = sizeof(T) - count_c2;
+            if (auto const ptr_c1 = GetPointerImpl(addr_c1, [addr_c1] {
+                LOG_ERROR(HW_Memory, "Unmapped Write{} @ {:#016X}", sizeof(T) * 8, addr_c1);
+            }, [&] {
+                HandleRasterizerWrite(addr_c1, count_c1);
+            }); ptr_c1) {
+                if (auto const ptr_c2 = GetPointerImpl(addr_c2, [addr_c2] {
+                    LOG_ERROR(HW_Memory, "Unmapped Write{} @ {:#016X}", sizeof(T) * 8, addr_c2);
+                }, [&] {
+                    HandleRasterizerWrite(addr_c2, count_c2);
+                }); ptr_c2) {
+                    std::array<char, sizeof(T)> tmp = std::bit_cast<std::array<char, sizeof(T)>>(data);
+                    std::memcpy(ptr_c1, tmp.data() + 0, count_c1);
+                    std::memcpy(ptr_c2, tmp.data() + count_c1, count_c2);
+                }
+            }
+        }
     }
 
     template <typename T>
@@ -842,35 +824,35 @@ const u8* Memory::GetPointer(Common::ProcessAddress vaddr) const {
 }
 
 u8 Memory::Read8(const Common::ProcessAddress addr) {
-    return impl->Read8(addr);
+    return impl->Read<u8>(addr);
 }
 
 u16 Memory::Read16(const Common::ProcessAddress addr) {
-    return impl->Read16(addr);
+    return impl->Read<u16_le>(addr);
 }
 
 u32 Memory::Read32(const Common::ProcessAddress addr) {
-    return impl->Read32(addr);
+    return impl->Read<u32_le>(addr);
 }
 
 u64 Memory::Read64(const Common::ProcessAddress addr) {
-    return impl->Read64(addr);
+    return impl->Read<u64_le>(addr);
 }
 
 void Memory::Write8(Common::ProcessAddress addr, u8 data) {
-    impl->Write8(addr, data);
+    impl->Write<u8>(addr, data);
 }
 
 void Memory::Write16(Common::ProcessAddress addr, u16 data) {
-    impl->Write16(addr, data);
+    impl->Write<u16_le>(addr, data);
 }
 
 void Memory::Write32(Common::ProcessAddress addr, u32 data) {
-    impl->Write32(addr, data);
+    impl->Write<u32_le>(addr, data);
 }
 
 void Memory::Write64(Common::ProcessAddress addr, u64 data) {
-    impl->Write64(addr, data);
+    impl->Write<u64_le>(addr, data);
 }
 
 bool Memory::WriteExclusive8(Common::ProcessAddress addr, u8 data, u8 expected) {