s^2

fix linking issues
remove latency func
2026-09-05 03:54:32 +00:00 · 2026-09-02 21:22:23 +00:00 · 2026-09-02 11:37:51 +00:00 · 2026-09-02 10:58:33 +00:00 · 2026-09-02 10:55:54 +00:00
44 changed files with 291 additions and 1332 deletions
@@ -52,7 +52,6 @@ if (YUZU_STATIC_ROOM)
    # disable e v e r y t h i n g
    set(ENABLE_QT OFF)
    set(YUZU_CMD OFF)
-    set(ENABLE_CUBEB OFF)
    set(ENABLE_UPDATE_CHECKER OFF)
    set(USE_DISCORD_PRESENCE OFF)
    set(BUILD_TESTING OFF)
@@ -214,8 +213,6 @@ if(MSVC)
 endif()

 # TODO(crueter): Cleanup, each dep that has a bundled option should allow to choose between bundled, external, system
-option(ENABLE_CUBEB "Enables the cubeb audio backend" ON)
-
 set(EXT_DEFAULT OFF)
 if (MSVC OR ANDROID)
    set(EXT_DEFAULT ON)
@@ -574,10 +571,6 @@ if (NOT YUZU_STATIC_ROOM)
        find_package(DiscordRPC)
    endif()

-    if (ENABLE_CUBEB)
-        find_package(cubeb)
-    endif()
-
    if (YUZU_TESTS OR DYNARMIC_TESTS)
        find_package(Catch2)
    endif()
@@ -54,18 +54,6 @@
        "repo": "arun11299/cpp-jwt",
        "version": "7f24eb4c32"
    },
-    "cubeb": {
-        "find_args": "CONFIG",
-        "hash": "8a4bcb2f83ba590f52c66626e895304a73eb61928dbc57777e1822e55378e3568366f17f9da4b80036cc2ef4ea9723c32abf6e7d9bbe00fb03654f0991596ab0",
-        "options": [
-            "USE_SANITIZERS OFF",
-            "BUILD_TESTS OFF",
-            "BUILD_TOOLS OFF",
-            "BUNDLE_SPEEX ON"
-        ],
-        "repo": "mozilla/cubeb",
-        "version": "fa02160712"
-    },
    "discord-rpc": {
        "find_args": "MODULE",
        "hash": "8213c43dcb0f7d479f5861091d111ed12fbdec1e62e6d729d65a4bc181d82f48a35d5fd3cd5c291f2393ac7c9681eabc6b76609755f55376284c8a8d67e148f3",
@@ -100,8 +100,6 @@ For reasons unberknownst to any human being, `glslangValidator` will crash upon

 For this reason this patch is NOT applied to default on all platforms (for obvious reasons) - instead this is a HaikuOS specific patch, apply with `git apply <absolute path to patch>` after cloning SPIRV-Tools then `make -C build` and add the resulting binary (in `build/StandAlone/glslang`) into PATH.

-`cubeb_devel` will also not work, either disable cubeb or uninstall it.
-
 Still will not run flawlessly until `mesa-24` is available. Modify CMakeCache.txt with the `.so` of libGL and libGLESv2 by doing the incredibly difficult task of copy pasting them (`cp /boot/system/lib/libGL.so .`)

 If you have `quazip1_qt6_devel`, uninstall it. It may call `Core5Compat` on CMake which is wrongly packaged.
@@ -73,7 +73,6 @@ Certain other dependencies will be fetched by CPM regardless. System packages *c

 * [SimpleIni](https://github.com/brofield/simpleini)
 * [DiscordRPC](https://github.com/eden-emulator/discord-rpc)
-* [cubeb](https://github.com/mozilla/cubeb)
 * [libusb](https://github.com/libusb/libusb)
 * [VulkanMemoryAllocator](https://github.com/GPUOpen-LibrariesAndSDKs/VulkanMemoryAllocator)
 * [sirit](https://github.com/eden-emulator/sirit)
@@ -122,7 +121,7 @@ sudo emerge -a \
    dev-util/spirv-tools dev-util/spirv-headers dev-util/vulkan-headers \
    dev-util/vulkan-utility-libraries dev-util/glslang \
    media-gfx/renderdoc media-libs/libva media-libs/opus media-video/ffmpeg \
-    media-libs/VulkanMemoryAllocator media-libs/libsdl3 media-libs/cubeb \
+    media-libs/VulkanMemoryAllocator media-libs/libsdl3 \
    net-libs/enet \
    sys-libs/zlib \
    dev-cpp/nlohmann_json dev-cpp/simpleini dev-cpp/cpp-httplib dev-cpp/cpp-jwt \
@@ -356,7 +355,7 @@ pacman -Syuu --needed --noconfirm $packages
 <summary>HaikuOS</summary>

 ```sh
-pkgman install git cmake patch libfmt_devel nlohmann_json lz4_devel opus_devel boost1.90_devel vulkan_devel qt6_base_devel qt6_declarative_devel libsdl3_devel ffmpeg7_devel libx11_devel enet_devel catch2_devel quazip1_qt5_devel qt6_5compat_devel glslang qt6_devel qt6_charts_devel cubeb_devel simpleini quazip_qt6_devel
+pkgman install git cmake patch libfmt_devel nlohmann_json lz4_devel opus_devel boost1.90_devel vulkan_devel qt6_base_devel qt6_declarative_devel libsdl3_devel ffmpeg7_devel libx11_devel enet_devel catch2_devel quazip1_qt5_devel qt6_5compat_devel glslang qt6_devel qt6_charts_devel simpleini quazip_qt6_devel
 ```

 [Caveats](./Caveats.md#haikuos).
@@ -4,7 +4,7 @@ Modern game consoles require heavy power to be emulated appropriately. This is w

 For example, take a disk write, instead of emulating a proper SD card we instead use the C++ standard library for I/O. Additionally we use the abstractions provided by the `fs` service to "lie" to programs about certain SD card properties. Notably this includes making up sizes for the fake SD card, giving "realistic" values or expected outputs for a given card, and so on. And instead of writing to an actual SD card, the emulator simply writes to a file.

-This also means grand part of the emulator consists of just re-implementing firmware but using HLE primitives; for example audio doesn't go to an emulated audio device, but rather gets processed on the fly by a dedicated service and then passed to SDL3/cubeb/etc.
+This also means grand part of the emulator consists of just re-implementing firmware but using HLE primitives; for example audio doesn't go to an emulated audio device, but rather gets processed on the fly by a dedicated service and then passed to SDL3 or null backend.

 As such, many of the systems implemented are not 100% accurate to the original software, but they're "good enough" to pass as being so. While we do strive to maintain high compatibility (especially with homebrew), there are realistic limitations to these approaches.

@@ -35,8 +35,6 @@ These options control dependencies.

 - `ENABLE_WEB_SERVICE` (ON) Enable multiplayer service
 - `ENABLE_WIFI_SCAN` (OFF) Enable WiFi scanning (requires iw on Linux) - experimental
- `ENABLE_CUBEB` (ON) Enables the cubeb audio backend
-  - This option is subject for removal.
 - `YUZU_TESTS` (ON) Compile tests - requires Catch2
 - `ENABLE_LTO` (OFF) Enable link-time optimization
  - Not recommended on Windows
@@ -106,36 +106,6 @@ endif()
 # SimpleIni
 AddJsonPackage(simpleini)

-# Most linux distros don't package cubeb, so enable regardless of cpm settings
-if(ENABLE_CUBEB)
-    AddJsonPackage(cubeb)
-
-    if (cubeb_ADDED)
-        if (NOT MSVC)
-            if (TARGET speex)
-                target_compile_options(speex PRIVATE $<$<COMPILE_LANGUAGE:C,CXX>:-Wno-sign-compare>)
-            endif()
-            set_target_properties(cubeb PROPERTIES COMPILE_OPTIONS "")
-            target_compile_options(cubeb INTERFACE
-                $<$<COMPILE_LANGUAGE:C,CXX>:-Wno-implicit-const-int-float-conversion>
-                $<$<COMPILE_LANGUAGE:C,CXX>:-Wno-shadow>
-                $<$<COMPILE_LANGUAGE:C,CXX>:-Wno-missing-declarations>
-                $<$<COMPILE_LANGUAGE:C,CXX>:-Wno-return-type>
-                $<$<COMPILE_LANGUAGE:C,CXX>:-Wno-uninitialized>
-            )
-        else()
-            target_compile_options(cubeb PRIVATE
-                /wd4456
-                /wd4458
-            )
-        endif()
-    endif()
-
-    if (NOT TARGET cubeb::cubeb)
-        add_library(cubeb::cubeb ALIAS cubeb)
-    endif()
-endif()
-
 if (NOT YUZU_USE_BUNDLED_SDL3)
    if (NOT WIN32)
        # Yuzu itself needs: Atomic Audio Events Joystick Haptic Sensor Threads Timers
@@ -11,7 +11,6 @@
 #include <limits>
 #include <span>
 #include <array>
-#include <algorithm>
 #include <time.h>

 namespace Tz {
@@ -15,7 +15,7 @@ pkgs.mkShellNoCC {
    enet libopus vulkan-headers vulkan-utility-libraries
    spirv-tools spirv-headers vulkan-loader unzip
    glslang python3 httplib cpp-jwt ffmpeg-headless
-    libusb1 cubeb
+    libusb1
    # eden
    qt6.qtbase qt6.qtmultimedia qt6.qtwayland qt6.qttools
    qt6.qtwebengine qt6.qt5compat
@@ -58,13 +58,6 @@ class LicensesFragment : Fragment() {
                R.string.license_fidelityfx_fsr_copyright,
                R.string.license_fidelityfx_fsr_text
            ),
-            License(
-                R.string.license_cubeb,
-                R.string.license_cubeb_description,
-                R.string.license_cubeb_link,
-                R.string.license_cubeb_copyright,
-                R.string.license_cubeb_text
-            ),
            License(
                R.string.license_dynarmic,
                R.string.license_dynarmic_description,
@@ -799,9 +799,6 @@
    <string name="theme_mode_light">روشن</string>
    <string name="theme_mode_dark">تاریک</string>

-    <!-- Audio output engines -->
-    <string name="cubeb">cubeb</string>
-
    <!-- Anisotropic filtering options -->
    <string name="multiplier_x2">x2</string>
    <string name="multiplier_x4">x4</string>
@@ -466,13 +466,11 @@
    <string-array name="outputEngineEntries">
        <item>@string/auto</item>
        <item>@string/sdl3</item>
-        <item>@string/cubeb</item>
        <item>@string/string_null</item>
    </string-array>
    <integer-array name="outputEngineValues">
        <item>0</item>
        <item>2</item>
-        <item>1</item>
        <item>3</item>
    </integer-array>

@@ -1241,7 +1241,6 @@

    <!-- Audio output engines -->
    <string name="sdl3" translatable="false">SDL3</string>
-    <string name="cubeb" translatable="false">cubeb</string>

    <!-- Anisotropic filtering options -->
    <string name="multiplier_x2" translatable="false">x2</string>
@@ -1381,23 +1380,6 @@ AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
 LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
 OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
 THE SOFTWARE.
-    </string>
-    <string name="license_cubeb" translatable="false">cubeb</string>
-    <string name="license_cubeb_description" translatable="false">Cross platform audio library</string>
-    <string name="license_cubeb_link" translatable="false">https://github.com/mozilla/cubeb</string>
-    <string name="license_cubeb_copyright" translatable="false">Copyright © 2011 Mozilla Foundation</string>
-    <string name="license_cubeb_text" translatable="false">
-Permission to use, copy, modify, and distribute this software for any
-purpose with or without fee is hereby granted, provided that the above
-copyright notice and this permission notice appear in all copies.\n\n
-
-THE SOFTWARE IS PROVIDED \"AS IS\" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
-WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
-MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
-ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
-WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
-ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
-OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
    </string>
    <string name="license_dynarmic" translatable="false">Dynarmic</string>
    <string name="license_dynarmic_description" translatable="false">An ARM dynamic recompiler</string>
@@ -229,15 +229,6 @@ endif()
 target_include_directories(audio_core PRIVATE ${OPUS_INCLUDE_DIRS})
 target_link_libraries(audio_core PUBLIC common core Opus::opus)

-if (ENABLE_CUBEB)
-    target_sources(audio_core PRIVATE
-        sink/cubeb_sink.cpp
-        sink/cubeb_sink.h)
-
-    target_link_libraries(audio_core PRIVATE cubeb::cubeb)
-    target_compile_definitions(audio_core PRIVATE HAVE_CUBEB=1)
-endif()
-
 target_sources(audio_core PRIVATE
    sink/sdl3_sink.cpp
    sink/sdl3_sink.h)
@@ -245,4 +236,8 @@ target_sources(audio_core PRIVATE
 target_link_libraries(audio_core PRIVATE SDL3::SDL3)
 target_compile_definitions(audio_core PRIVATE HAVE_SDL3)

+if (ANDROID)
+    target_link_libraries(audio_core PRIVATE OpenSLES)
+endif()
+
 create_target_directory_groups(audio_core)
@@ -1,450 +0,0 @@
-// SPDX-FileCopyrightText: Copyright 2026 Eden Emulator Project
-// SPDX-License-Identifier: GPL-3.0-or-later
-
-// SPDX-FileCopyrightText: Copyright 2018 yuzu Emulator Project
-// SPDX-License-Identifier: GPL-2.0-or-later
-
-#include <span>
-#include <vector>
-
-#include "audio_core/common/common.h"
-#include "audio_core/sink/cubeb_sink.h"
-#include "audio_core/sink/sink_stream.h"
-#include "common/logging.h"
-#include "common/scope_exit.h"
-#include "core/core.h"
-
-#ifdef _WIN32
-#include <objbase.h>
-#undef CreateEvent
-#endif
-
-namespace AudioCore::Sink {
-/**
- * Cubeb sink stream, responsible for sinking samples to hardware.
- */
-class CubebSinkStream final : public SinkStream {
-public:
-    /**
-     * Create a new sink stream.
-     *
-     * @param ctx_             - Cubeb context to create this stream with.
-     * @param device_channels_ - Number of channels supported by the hardware.
-     * @param system_channels_ - Number of channels the audio systems expect.
-     * @param output_device    - Cubeb output device id.
-     * @param input_device     - Cubeb input device id.
-     * @param name_            - Name of this stream.
-     * @param type_            - Type of this stream.
-     * @param system_          - Core system.
-     * @param event            - Event used only for audio renderer, signalled on buffer consume.
-     */
-    CubebSinkStream(cubeb* ctx_, u32 device_channels_, u32 system_channels_,
-                    cubeb_devid output_device, cubeb_devid input_device, const std::string& name_,
-                    StreamType type_, Core::System& system_)
-        : SinkStream(system_, type_), ctx{ctx_} {
-#ifdef _WIN32
-        CoInitializeEx(nullptr, COINIT_MULTITHREADED);
-#endif
-        name = name_;
-        device_channels = device_channels_;
-        system_channels = system_channels_;
-
-        cubeb_stream_params params{};
-        params.rate = TargetSampleRate;
-        params.channels = device_channels;
-        params.format = CUBEB_SAMPLE_S16LE;
-        params.prefs = CUBEB_STREAM_PREF_NONE;
-        switch (params.channels) {
-        case 1:
-            params.layout = CUBEB_LAYOUT_MONO;
-            break;
-        case 2:
-            params.layout = CUBEB_LAYOUT_STEREO;
-            break;
-        case 6:
-            params.layout = CUBEB_LAYOUT_3F2_LFE;
-            break;
-        }
-
-        u32 minimum_latency{0};
-        const auto latency_error = cubeb_get_min_latency(ctx, &params, &minimum_latency);
-        if (latency_error != CUBEB_OK) {
-            LOG_CRITICAL(Audio_Sink, "Error getting minimum latency, error: {}", latency_error);
-            minimum_latency = TargetSampleCount * 2;
-        }
-
-        minimum_latency = (std::max)(minimum_latency, TargetSampleCount * 2);
-
-        LOG_INFO(Service_Audio,
-                 "Opening cubeb stream {} type {} with: rate {} channels {} (system channels {}) "
-                 "latency {}",
-                 name, type, params.rate, params.channels, system_channels, minimum_latency);
-
-        auto init_error{0};
-        if (type == StreamType::In) {
-            init_error = cubeb_stream_init(ctx, &stream_backend, name.c_str(), input_device,
-                                           &params, output_device, nullptr, minimum_latency,
-                                           &CubebSinkStream::DataCallback,
-                                           &CubebSinkStream::StateCallback, this);
-        } else {
-            init_error = cubeb_stream_init(ctx, &stream_backend, name.c_str(), input_device,
-                                           nullptr, output_device, &params, minimum_latency,
-                                           &CubebSinkStream::DataCallback,
-                                           &CubebSinkStream::StateCallback, this);
-        }
-
-        if (init_error != CUBEB_OK) {
-            LOG_CRITICAL(Audio_Sink, "Error initializing cubeb stream, error: {}", init_error);
-            return;
-        }
-    }
-
-    /**
-     * Destroy the sink stream.
-     */
-    ~CubebSinkStream() override {
-        LOG_DEBUG(Service_Audio, "Destructing cubeb stream {}", name);
-
-        if (!ctx) {
-            return;
-        }
-
-        Finalize();
-
-#ifdef _WIN32
-        CoUninitialize();
-#endif
-    }
-
-    /**
-     * Finalize the sink stream.
-     */
-    void Finalize() override {
-        Stop();
-        cubeb_stream_destroy(stream_backend);
-    }
-
-    /**
-     * Start the sink stream.
-     *
-     * @param resume - Set to true if this is resuming the stream a previously-active stream.
-     *                 Default false.
-     */
-    void Start(bool resume = false) override {
-        if (!ctx || !paused) {
-            return;
-        }
-
-        paused = false;
-        if (cubeb_stream_start(stream_backend) != CUBEB_OK) {
-            LOG_CRITICAL(Audio_Sink, "Error starting cubeb stream");
-        }
-    }
-
-    /**
-     * Stop the sink stream.
-     */
-    void Stop() override {
-        if (!ctx || paused) {
-            return;
-        }
-
-        SignalPause();
-        if (cubeb_stream_stop(stream_backend) != CUBEB_OK) {
-            LOG_CRITICAL(Audio_Sink, "Error stopping cubeb stream");
-        }
-    }
-
-private:
-    /**
-     * Main callback from Cubeb. Either expects samples from us (audio render/audio out), or will
-     * provide samples to be copied (audio in).
-     *
-     * @param stream      - Cubeb-specific data about the stream.
-     * @param user_data   - Custom data pointer passed along, points to a CubebSinkStream.
-     * @param in_buff     - Input buffer to be used if the stream is an input type.
-     * @param out_buff    - Output buffer to be used if the stream is an output type.
-     * @param num_frames_ - Number of frames of audio in the buffers. Note: Not number of samples.
-     */
-    static long DataCallback([[maybe_unused]] cubeb_stream* stream, void* user_data,
-                             [[maybe_unused]] const void* in_buff, void* out_buff,
-                             long num_frames_) {
-        auto* impl = static_cast<CubebSinkStream*>(user_data);
-        if (!impl) {
-            return -1;
-        }
-
-        const std::size_t num_channels = impl->GetDeviceChannels();
-        const std::size_t frame_size = num_channels;
-        const std::size_t num_frames{static_cast<size_t>(num_frames_)};
-
-        if (impl->type == StreamType::In) {
-            std::span<const s16> input_buffer{reinterpret_cast<const s16*>(in_buff),
-                                              num_frames * frame_size};
-            impl->ProcessAudioIn(input_buffer, num_frames);
-        } else {
-            std::span<s16> output_buffer{reinterpret_cast<s16*>(out_buff), num_frames * frame_size};
-            impl->ProcessAudioOutAndRender(output_buffer, num_frames);
-        }
-
-        return num_frames_;
-    }
-
-    /**
-     * Cubeb callback for if a device state changes. Unused currently.
-     *
-     * @param stream      - Cubeb-specific data about the stream.
-     * @param user_data   - Custom data pointer passed along, points to a CubebSinkStream.
-     * @param state       - New state of the device.
-     */
-    static void StateCallback(cubeb_stream*, void*, cubeb_state) {}
-
-    /// Main Cubeb context
-    cubeb* ctx{};
-    /// Cubeb stream backend
-    cubeb_stream* stream_backend{};
-};
-
-CubebSink::CubebSink(std::string_view target_device_name) {
-    // Cubeb requires COM to be initialized on the thread calling cubeb_init on Windows
-#ifdef _WIN32
-    com_init_result = CoInitializeEx(nullptr, COINIT_MULTITHREADED);
-#endif
-
-    if (cubeb_init(&ctx, "Eden", nullptr) != CUBEB_OK) {
-        LOG_CRITICAL(Audio_Sink, "cubeb_init failed");
-        return;
-    }
-
-    if (target_device_name != auto_device_name && !target_device_name.empty()) {
-        cubeb_device_collection collection;
-        if (cubeb_enumerate_devices(ctx, CUBEB_DEVICE_TYPE_OUTPUT, &collection) != CUBEB_OK) {
-            LOG_WARNING(Audio_Sink, "Audio output device enumeration not supported");
-        } else {
-            const auto collection_end{collection.device + collection.count};
-            const auto device{
-                std::find_if(collection.device, collection_end, [&](const cubeb_device_info& info) {
-                    return info.friendly_name != nullptr &&
-                           target_device_name == std::string(info.friendly_name);
-                })};
-            if (device != collection_end) {
-                output_device = device->devid;
-            }
-            cubeb_device_collection_destroy(ctx, &collection);
-        }
-    }
-
-    cubeb_get_max_channel_count(ctx, &device_channels);
-    device_channels = device_channels >= 6U ? 6U : 2U;
-}
-
-CubebSink::~CubebSink() {
-    if (!ctx) {
-        return;
-    }
-
-    for (auto& sink_stream : sink_streams) {
-        sink_stream.reset();
-    }
-
-    cubeb_destroy(ctx);
-
-#ifdef _WIN32
-    if (SUCCEEDED(com_init_result)) {
-        CoUninitialize();
-    }
-#endif
-}
-
-SinkStream* CubebSink::AcquireSinkStream(Core::System& system, u32 system_channels_,
-                                         const std::string& name, StreamType type) {
-    system_channels = system_channels_;
-    SinkStreamPtr& stream = sink_streams.emplace_back(std::make_unique<CubebSinkStream>(
-        ctx, device_channels, system_channels, output_device, input_device, name, type, system));
-
-    return stream.get();
-}
-
-void CubebSink::CloseStream(SinkStream* stream) {
-    for (size_t i = 0; i < sink_streams.size(); i++) {
-        if (sink_streams[i].get() == stream) {
-            sink_streams[i].reset();
-            sink_streams.erase(sink_streams.begin() + i);
-            break;
-        }
-    }
-}
-
-void CubebSink::CloseStreams() {
-    sink_streams.clear();
-}
-
-f32 CubebSink::GetDeviceVolume() const {
-    if (sink_streams.empty()) {
-        return 1.0f;
-    }
-
-    return sink_streams[0]->GetDeviceVolume();
-}
-
-void CubebSink::SetDeviceVolume(f32 volume) {
-    for (auto& stream : sink_streams) {
-        stream->SetDeviceVolume(volume);
-    }
-}
-
-void CubebSink::SetSystemVolume(f32 volume) {
-    for (auto& stream : sink_streams) {
-        stream->SetSystemVolume(volume);
-    }
-}
-
-std::vector<std::string> ListCubebSinkDevices(bool capture) {
-    std::vector<std::string> device_list;
-    cubeb* ctx;
-
-#ifdef _WIN32
-    auto com_init_result = CoInitializeEx(nullptr, COINIT_MULTITHREADED);
-#endif
-
-    if (cubeb_init(&ctx, "Eden Device Enumerator", nullptr) != CUBEB_OK) {
-        LOG_CRITICAL(Audio_Sink, "cubeb_init failed");
-        return {};
-    }
-
-#ifdef _WIN32
-    if (SUCCEEDED(com_init_result)) {
-        CoUninitialize();
-    }
-#endif
-
-    auto type{capture ? CUBEB_DEVICE_TYPE_INPUT : CUBEB_DEVICE_TYPE_OUTPUT};
-    cubeb_device_collection collection;
-    if (cubeb_enumerate_devices(ctx, type, &collection) != CUBEB_OK) {
-        LOG_WARNING(Audio_Sink, "Audio output device enumeration not supported");
-    } else {
-        for (std::size_t i = 0; i < collection.count; i++) {
-            const cubeb_device_info& device = collection.device[i];
-            if (device.friendly_name && device.friendly_name[0] != '\0' &&
-                device.state == CUBEB_DEVICE_STATE_ENABLED) {
-                device_list.emplace_back(device.friendly_name);
-            }
-        }
-        cubeb_device_collection_destroy(ctx, &collection);
-    }
-
-    cubeb_destroy(ctx);
-    return device_list;
-}
-
-/* REVERSION TO 3833 - function GetCubebLatency REINTRODUCED FROM 3833 - DIABLO 3 FIX */
-u32 GetCubebLatency() {
-    cubeb* ctx;
-
-#ifdef _WIN32
-    auto com_init_result = CoInitializeEx(nullptr, COINIT_MULTITHREADED);
-#endif
-
-    // Init cubeb
-    if (cubeb_init(&ctx, "yuzu Latency Getter", nullptr) != CUBEB_OK) {
-        LOG_CRITICAL(Audio_Sink, "cubeb_init failed");
-        // Return a large latency so we choose SDL instead.
-        return 10000u;
-    }
-
-#ifdef _WIN32
-    if (SUCCEEDED(com_init_result)) {
-        CoUninitialize();
-    }
-#endif
-
-    // Get min latency
-    cubeb_stream_params params{};
-    params.rate = TargetSampleRate;
-    params.channels = 2;
-    params.format = CUBEB_SAMPLE_S16LE;
-    params.prefs = CUBEB_STREAM_PREF_NONE;
-    params.layout = CUBEB_LAYOUT_STEREO;
-
-    u32 latency{0};
-    const auto latency_error = cubeb_get_min_latency(ctx, &params, &latency);
-    if (latency_error != CUBEB_OK) {
-        LOG_CRITICAL(Audio_Sink, "Error getting minimum latency, error: {}", latency_error);
-        latency = TargetSampleCount * 2;
-    }
-    latency = (std::max)(latency, TargetSampleCount * 2);
-    cubeb_destroy(ctx);
-    return latency;
-}
-
-// REVERTED back to 3833 - Below namespace section and function IsCubebSuitable() removed, reverting to GetCubebLatency() above. - DIABLO 3 FIX
-/*
-namespace {
-static long TmpDataCallback(cubeb_stream*, void*, const void*, void*, long) {
-    return TargetSampleCount;
-}
-static void TmpStateCallback(cubeb_stream*, void*, cubeb_state) {}
-} // namespace
-
-bool IsCubebSuitable() {
-#if !defined(HAVE_CUBEB)
-    return false;
-#else
-    cubeb* ctx{nullptr};
-
-#ifdef _WIN32
-    auto com_init_result = CoInitializeEx(nullptr, COINIT_MULTITHREADED);
-#endif
-
-    // Init cubeb
-    if (cubeb_init(&ctx, "Eden Latency Getter", nullptr) != CUBEB_OK) {
-        LOG_ERROR(Audio_Sink, "Cubeb failed to init, it is not suitable.");
-        return false;
-    }
-
-    SCOPE_EXIT {
-        cubeb_destroy(ctx);
-    };
-
-#ifdef _WIN32
-    if (SUCCEEDED(com_init_result)) {
-        CoUninitialize();
-    }
-#endif
-
-    // Get min latency
-    cubeb_stream_params params{};
-    params.rate = TargetSampleRate;
-    params.channels = 2;
-    params.format = CUBEB_SAMPLE_S16LE;
-    params.prefs = CUBEB_STREAM_PREF_NONE;
-    params.layout = CUBEB_LAYOUT_STEREO;
-
-    u32 latency{0};
-    const auto latency_error = cubeb_get_min_latency(ctx, &params, &latency);
-    if (latency_error != CUBEB_OK) {
-        LOG_ERROR(Audio_Sink, "Cubeb could not get min latency, it is not suitable.");
-        return false;
-    }
-    latency = (std::max)(latency, TargetSampleCount * 2);
-
-    // Test opening a device with standard parameters
-    cubeb_devid output_device{0};
-    cubeb_devid input_device{0};
-    std::string name{"Eden test"};
-    cubeb_stream* stream{nullptr};
-
-    if (cubeb_stream_init(ctx, &stream, name.c_str(), input_device, nullptr, output_device, &params,
-                          latency, &TmpDataCallback, &TmpStateCallback, nullptr) != CUBEB_OK) {
-        LOG_CRITICAL(Audio_Sink, "Cubeb could not open a device, it is not suitable.");
-        return false;
-    }
-
-    cubeb_stream_stop(stream);
-    cubeb_stream_destroy(stream);
-    return true;
-#endif
-}
-*/
-
-} // namespace AudioCore::Sink
@@ -1,118 +0,0 @@
-// SPDX-FileCopyrightText: Copyright 2025 Eden Emulator Project
-// SPDX-License-Identifier: GPL-3.0-or-later
-
-// SPDX-FileCopyrightText: Copyright 2018 yuzu Emulator Project
-// SPDX-License-Identifier: GPL-2.0-or-later
-
-#pragma once
-
-#include <string>
-#include <vector>
-
-#include <cubeb/cubeb.h>
-
-#include "audio_core/sink/sink.h"
-
-namespace Core {
-class System;
-}
-
-namespace AudioCore::Sink {
-class SinkStream;
-
-/**
- * Cubeb backend sink, holds multiple output streams and is responsible for sinking samples to
- * hardware. Used by Audio Render, Audio In and Audio Out.
- */
-class CubebSink final : public Sink {
-public:
-    explicit CubebSink(std::string_view device_id);
-    ~CubebSink() 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:
-    /// Backend Cubeb context
-    cubeb* ctx{};
-    /// Cubeb id of the actual hardware output device
-    cubeb_devid output_device{};
-    /// Cubeb id of the actual hardware input device
-    cubeb_devid input_device{};
-    /// Vector of streams managed by this sink
-    std::vector<SinkStreamPtr> sink_streams{};
-
-#ifdef _WIN32
-    /// Cubeb required COM to be initialized multi-threaded on Windows
-    u32 com_init_result = 0;
-#endif
-};
-
-/**
- * Get a list of connected devices from Cubeb.
- *
- * @param capture - Return input (capture) devices if true, otherwise output devices.
- */
-std::vector<std::string> ListCubebSinkDevices(bool capture);
-
-// REVERSION - function GetCubebLatency() reintroduced from EA-3833 - DIABLO 3 FIX
-/**
- * Get the reported latency for this sink.
- *
- * @return Minimum latency for this sink.
- */
-u32 GetCubebLatency();
-
-/**
- * Check if this backend is suitable for use.
- * Checks if enabled, its latency, whether it opens successfully, etc.
- *
- * @return True is this backend is suitable, false otherwise.
- */
-// bool IsCubebSuitable(); // REVERTED BACK TO GetCubebLatency() FROM 3833
-
-} // namespace AudioCore::Sink
@@ -25,9 +25,10 @@ namespace {
        // See https://github.com/PCSX2/pcsx2/pull/12312
        // "SDL and cubeb backends previously resulted in different names for the output which
        // caused them be identified as different applications by the OS."
-        //
-        // Keep in sync with cubeb_sink.cpp name.
        SDL_SetHint("SDL_AUDIO_DEVICE_APP_NAME", "yuzu Latency Getter");
+        SDL_SetHint("SDL_HINT_AUDIO_DEVICE_STREAM_ROLE", "Game");
+        // We do our own processing, so just have SDL copy our audio
+        SDL_SetHint("SDL_HINT_AUDIO_DEVICE_RAW_STREAM", "1");
        if (!SDL_InitSubSystem(SDL_INIT_AUDIO)) {
            LOG_CRITICAL(Audio_Sink, "SDL_InitSubSystem audio failed: {}", SDL_GetError());
            return false;
@@ -82,23 +83,18 @@ public:

        SDL_AudioSpec spec{};
        spec.freq = TargetSampleRate;
-        spec.channels = static_cast<u8>(device_channels);
-        spec.format = SDL_AUDIO_S16;
+        spec.channels = u8(device_channels);
+        spec.format = SDL_AUDIO_S16LE;

-        std::string device_name{output_device};
-        bool capture{false};
-        if (type == StreamType::In) {
-            device_name = input_device;
-            capture = true;
-        }
+        auto const is_capture = (type == StreamType::In);
+        std::string device_name = is_capture ? input_device : output_device;
+        const SDL_AudioDeviceID audio_device = device_name.empty()
+            ? (is_capture
+                ? SDL_AUDIO_DEVICE_DEFAULT_RECORDING
+                : SDL_AUDIO_DEVICE_DEFAULT_PLAYBACK)
+            : FindAudioDeviceByName(device_name, is_capture);

-        const SDL_AudioDeviceID audio_device =
-            device_name.empty() ? (capture ? SDL_AUDIO_DEVICE_DEFAULT_RECORDING
-                                           : SDL_AUDIO_DEVICE_DEFAULT_PLAYBACK)
-                                : FindAudioDeviceByName(device_name, capture);
-
-        stream = SDL_OpenAudioDeviceStream(audio_device, &spec, &SDLSinkStream::DataCallback,
-                                           this);
+        stream = SDL_OpenAudioDeviceStream(audio_device, &spec, &SDLSinkStream::DataCallback, this);

        if (stream == nullptr) {
            LOG_CRITICAL(Audio_Sink, "Error opening SDL audio device: {}", SDL_GetError());
@@ -107,13 +103,12 @@ public:

        SDL_AudioSpec stream_in{};
        SDL_AudioSpec stream_out{};
-        static_cast<void>(SDL_GetAudioStreamFormat(stream, &stream_in, &stream_out));
-
+        void(SDL_GetAudioStreamFormat(stream, &stream_in, &stream_out));
        LOG_INFO(Service_Audio,
                 "Opening SDL stream {} with: rate {} channels {} (system channels {}) "
                 " format {}",
                 static_cast<const void*>(stream), stream_out.freq, stream_out.channels,
-                 system_channels, static_cast<int>(stream_out.format));
+                 system_channels, int(stream_out.format));
    }

    /**
@@ -128,14 +123,12 @@ public:
     * Finalize the sink stream.
     */
    void Finalize() override {
-        if (stream == nullptr) {
-            return;
+        if (stream != nullptr) {
+            Stop();
+            SDL_ClearAudioStream(stream);
+            SDL_DestroyAudioStream(stream);
+            stream = nullptr;
        }
-
-        Stop();
-        SDL_ClearAudioStream(stream);
-        SDL_DestroyAudioStream(stream);
-        stream = nullptr;
    }

    /**
@@ -148,9 +141,8 @@ public:
        if (stream == nullptr || !paused) {
            return;
        }
-
        paused = false;
-        static_cast<void>(SDL_ResumeAudioStreamDevice(stream));
+        void(SDL_ResumeAudioStreamDevice(stream));
    }

    /**
@@ -161,7 +153,7 @@ public:
            return;
        }
        SignalPause();
-        static_cast<void>(SDL_PauseAudioStreamDevice(stream));
+        void(SDL_PauseAudioStreamDevice(stream));
    }

 private:
@@ -173,51 +165,34 @@ private:
     * @param stream   - Buffer of samples to be filled or read.
     * @param len      - Length of the stream in bytes.
     */
-    static void DataCallback(void* userdata, SDL_AudioStream* stream, int additional_amount,
-                             int total_amount) {
-        auto* impl = static_cast<SDLSinkStream*>(userdata);
-
-        if (!impl) {
-            return;
-        }
-
-        const std::size_t num_channels = impl->GetDeviceChannels();
-        const std::size_t frame_size = num_channels;
-
-        if (impl->type == StreamType::In) {
-            const int bytes_available = SDL_GetAudioStreamAvailable(stream);
-            if (bytes_available <= 0) {
-                return;
+    static void DataCallback(void* userdata, SDL_AudioStream* stream, int additional_amount, int total_amount) {
+        if (auto* impl = static_cast<SDLSinkStream*>(userdata); impl) {
+            auto const num_channels = impl->GetDeviceChannels();
+            auto const frame_size = num_channels;
+            if (impl->type == StreamType::In) {
+                auto const bytes_available = SDL_GetAudioStreamAvailable(stream);
+                if (bytes_available > 0) {
+                    std::vector<s16> input(bytes_available / int(sizeof(s16)));
+                    auto const bytes_read = SDL_GetAudioStreamData(stream, input.data(), bytes_available);
+                    if (bytes_read > 0) {
+                        auto const num_frames = std::size_t(bytes_read) / sizeof(s16) / frame_size;
+                        std::span<const s16> input_buffer{input.data(), std::size_t(bytes_read) / sizeof(s16)};
+                        impl->ProcessAudioIn(input_buffer, num_frames);
+                    }
+                }
+            } else if (additional_amount > 0 || total_amount > 0) {
+                auto const bytes_requested = additional_amount > 0 ? additional_amount : total_amount;
+                std::vector<s16> output(bytes_requested / int(sizeof(s16)));
+                auto const num_frames = std::size_t(bytes_requested) / sizeof(s16) / frame_size;
+                std::span<s16> output_buffer{output.data(), output.size()};
+                impl->ProcessAudioOutAndRender(output_buffer, num_frames);
+                void(SDL_PutAudioStreamData(stream, output.data(), bytes_requested));
            }
-
-            std::vector<s16> input(bytes_available / static_cast<int>(sizeof(s16)));
-            const int bytes_read = SDL_GetAudioStreamData(stream, input.data(), bytes_available);
-            if (bytes_read <= 0) {
-                return;
-            }
-
-            const std::size_t num_frames =
-                static_cast<std::size_t>(bytes_read) / sizeof(s16) / frame_size;
-            std::span<const s16> input_buffer{input.data(),
-                                              static_cast<std::size_t>(bytes_read) / sizeof(s16)};
-            impl->ProcessAudioIn(input_buffer, num_frames);
-        } else {
-            if (additional_amount <= 0 && total_amount <= 0) {
-                return;
-            }
-
-            const int bytes_requested = additional_amount > 0 ? additional_amount : total_amount;
-            std::vector<s16> output(bytes_requested / static_cast<int>(sizeof(s16)));
-            const std::size_t num_frames =
-                static_cast<std::size_t>(bytes_requested) / sizeof(s16) / frame_size;
-            std::span<s16> output_buffer{output.data(), output.size()};
-            impl->ProcessAudioOutAndRender(output_buffer, num_frames);
-            static_cast<void>(SDL_PutAudioStreamData(stream, output.data(), bytes_requested));
        }
    }

    /// SDL stream attached to an opened input/output device
-    SDL_AudioStream* stream{};
+    SDL_AudioStream* stream = nullptr;
 };

 SDLSink::SDLSink(std::string_view target_device_name) {
@@ -233,11 +208,9 @@ SDLSink::SDLSink(std::string_view target_device_name) {

 SDLSink::~SDLSink() = default;

-SinkStream* SDLSink::AcquireSinkStream(Core::System& system, u32 system_channels_,
-                                       const std::string&, StreamType type) {
+SinkStream* SDLSink::AcquireSinkStream(Core::System& system, u32 system_channels_, const std::string&, StreamType type) {
    system_channels = system_channels_;
-    SinkStreamPtr& stream = sink_streams.emplace_back(std::make_unique<SDLSinkStream>(
-        device_channels, system_channels, output_device, input_device, type, system));
+    SinkStreamPtr& stream = sink_streams.emplace_back(std::make_unique<SDLSinkStream>(device_channels, system_channels, output_device, input_device, type, system));
    return stream.get();
 }

@@ -256,11 +229,7 @@ void SDLSink::CloseStreams() {
 }

 f32 SDLSink::GetDeviceVolume() const {
-    if (sink_streams.empty()) {
-        return 1.0f;
-    }
-
-    return sink_streams[0]->GetDeviceVolume();
+    return sink_streams.empty() ? 1.0f : sink_streams[0]->GetDeviceVolume();
 }

 void SDLSink::SetDeviceVolume(f32 volume) {
@@ -275,68 +244,21 @@ void SDLSink::SetSystemVolume(f32 volume) {
    }
 }

-std::vector<std::string> ListSDLSinkDevices(bool capture) {
-    if (!InitializeAudio())
-        return {}; //no devices
-
-    std::vector<std::string> device_list;
-    int device_count = 0;
-    SDL_AudioDeviceID* devices =
-        capture ? SDL_GetAudioRecordingDevices(&device_count)
-                : SDL_GetAudioPlaybackDevices(&device_count);
-    if (devices == nullptr) {
-        return device_list;
-    }
-
-    for (int i = 0; i < device_count; ++i) {
-        if (const char* name = SDL_GetAudioDeviceName(devices[i])) {
-            device_list.emplace_back(name);
+std::vector<std::string> ListSDLSinkDevices(bool is_capture) {
+    std::vector<std::string> device_list{};
+    if (InitializeAudio()) {
+        int device_count = 0;
+        SDL_AudioDeviceID* devices = is_capture ? SDL_GetAudioRecordingDevices(&device_count) : SDL_GetAudioPlaybackDevices(&device_count);
+        if (devices != nullptr) {
+            for (int i = 0; i < device_count; ++i) {
+                if (const char* name = SDL_GetAudioDeviceName(devices[i]); name) {
+                    device_list.emplace_back(name);
+                }
+            }
+            SDL_free(devices);
        }
    }
-    SDL_free(devices);
-
    return device_list;
 }

-/* REVERSION to 3833 - function GetSDLLatency() REINTRODUCED FROM 3833 - DIABLO 3 FIX */
-u32 GetSDLLatency() {
-    return TargetSampleCount * 2;
-}
-
-// REVERTED back to 3833 - Below function IsSDLSuitable() removed, reverting to GetSDLLatency() above. - DIABLO 3 FIX
-/*
-bool IsSDLSuitable() {
-#if !defined(HAVE_SDL3)
-    return false;
-#else
-    // Check SDL can init
-    if (!InitializeAudio()!
-        return false;
-
-    // We can set any latency frequency we want with SDL, so no need to check that.
-
-    // Check we can open a device with standard parameters
-    SDL_AudioSpec spec;
-    spec.freq = TargetSampleRate;
-    spec.channels = 2u;
-    spec.format = AUDIO_S16SYS;
-    spec.samples = TargetSampleCount * 2;
-    spec.callback = nullptr;
-    spec.userdata = nullptr;
-
-    SDL_AudioSpec obtained;
-    auto device = SDL_OpenAudioDevice(nullptr, false, &spec, &obtained, false);
-
-    if (device == 0) {
-        LOG_ERROR(Audio_Sink, "SDL failed to open a device, it is not suitable. Error: {}",
-                  SDL_GetError());
-        return false;
-    }
-
-    SDL_CloseAudioDevice(device);
-    return true;
-#endif
-}
-*/
-
 } // namespace AudioCore::Sink
@@ -90,20 +90,4 @@ private:
 */
 std::vector<std::string> ListSDLSinkDevices(bool capture);

-// REVERSION - function GetSDLLatency() reintroduced from EA-3833 - DIABLO 3 FIX
-/**
- * Get the reported latency for this sink.
- *
- * @return Minimum latency for this sink.
- */
-u32 GetSDLLatency();
-
-/** REVERTED back to 3833 - Below function IsSDLSuitable() removed, reverting to GetSDLLatency() above. - DIABLO 3 FIX
- * Check if this backend is suitable for use.
- * Checks if enabled, its latency, whether it opens successfully, etc.
- *
- * @return True is this backend is suitable, false otherwise.
- */
-//bool IsSDLSuitable(); // REVERTED for GetSDLLatency() from EA-3833
-
 } // namespace AudioCore::Sink
@@ -10,9 +10,6 @@
 #include <vector>

 #include "audio_core/sink/sink_details.h"
-#ifdef HAVE_CUBEB
-#include "audio_core/sink/cubeb_sink.h"
-#endif
 #ifdef HAVE_SDL3
 #include "audio_core/sink/sdl3_sink.h"
 #endif
@@ -34,24 +31,10 @@ struct SinkDetails {
    FactoryFn factory;
    /// A method to call to list available devices.
    ListDevicesFn list_devices;
-    /// Method to get the latency of this backend - REINTRODUCED FROM 3833 - DIABLO 3 FIX
-    LatencyFn latency;
-    /// Check whether this backend is suitable to be used.
-    /// SuitableFn is_suitable; // REVERTED FOR LatencyFn latency ABOVE - DIABLO 3 FIX
 };

 // sink_details is ordered in terms of desirability, with the best choice at the top.
-constexpr SinkDetails sink_details[] = {
-#ifdef HAVE_CUBEB
-    SinkDetails{
-        Settings::AudioEngine::Cubeb,
-        [](std::string_view device_id) -> std::unique_ptr<Sink> {
-            return std::make_unique<CubebSink>(device_id);
-        },
-        &ListCubebSinkDevices,
-        &GetCubebLatency,
-    },
-#endif
+static constexpr SinkDetails sink_details[] = {
 #ifdef HAVE_SDL3
    SinkDetails{
        Settings::AudioEngine::Sdl3,
@@ -59,7 +42,6 @@ constexpr SinkDetails sink_details[] = {
            return std::make_unique<SDLSink>(device_id);
        },
        &ListSDLSinkDevices,
-        &GetSDLLatency,
    },
 #endif
    SinkDetails{
@@ -68,69 +50,32 @@ constexpr SinkDetails sink_details[] = {
            return std::make_unique<NullSink>(device_id);
        },
        [](bool capture) { return std::vector<std::string>{"null"}; },
-        []() { return 0u; },
    },
 };

 const SinkDetails& GetOutputSinkDetails(Settings::AudioEngine sink_id) {
    const auto find_backend{[](Settings::AudioEngine id) {
-        return std::find_if(std::begin(sink_details), std::end(sink_details),
-                            [&id](const auto& sink_detail) { return sink_detail.id == id; });
+        return std::ranges::find_if(std::begin(sink_details), std::end(sink_details), [&id](const auto& e) {
+            return e.id == id;
+        });
    }};

    auto iter = find_backend(sink_id);
-
-    if (sink_id == Settings::AudioEngine::Auto) {
-        // REVERTED TO 3833 BELOW - DIABLO 3 FIX
-        /*
-        // Auto-select a backend. Use the sink details ordering, preferring cubeb first, checking
-        // that the backend is available and suitable to use.
-        for (auto& details : sink_details) {
-            if (details.is_suitable()) {
-                iter = &details;
-                break;
-            }
-        }
-        */ // END REVERTED CODE - DIABLO 3 FIX
-
-        // BEGIN REINTRODUCED FROM 3833 - REPLACED CODE BLOCK ABOVE - DIABLO 3 FIX
-        // Auto-select a backend. Prefer CubeB, but it may report a large minimum latency which
-        // causes audio issues, in that case go with SDL.
-#if defined(HAVE_CUBEB) && defined(HAVE_SDL3)
-        iter = find_backend(Settings::AudioEngine::Cubeb);
-        if (iter->latency() > TargetSampleCount * 3) {
+    if (sink_id == Settings::AudioEngine::Cubeb || sink_id == Settings::AudioEngine::Auto) {
        iter = find_backend(Settings::AudioEngine::Sdl3);
-        }
-#else
-        iter = std::begin(sink_details);
-#endif
-        // END REINTRODUCED SECTION FROM 3833 - DIABLO 3 FIX
-        LOG_INFO(Service_Audio, "Auto-selecting the {} backend",
-                 Settings::CanonicalizeEnum(iter->id));
-    /* BEGIN REMOVED - REVERTING BACK TO 3833, this didn't exist at all. - DIABLO 3 FIX
-    } else {
-        if (iter != std::end(sink_details) && !iter->is_suitable()) {
-            LOG_ERROR(Service_Audio, "Selected backend {} is not suitable, falling back to null",
-                      Settings::CanonicalizeEnum(iter->id));
-            iter = find_backend(Settings::AudioEngine::Null);
-        } */ // END REMOVED REVERT - DIABLO 3 FIX
+        LOG_INFO(Service_Audio, "Auto-selecting the {} backend", Settings::CanonicalizeEnum(iter->id));
    }
-
    if (iter == std::end(sink_details)) {
        LOG_ERROR(Audio, "Invalid sink_id {}", Settings::CanonicalizeEnum(sink_id));
        iter = find_backend(Settings::AudioEngine::Null);
    }
-
    return *iter;
 }
 } // Anonymous namespace

 std::vector<Settings::AudioEngine> GetSinkIDs() {
    std::vector<Settings::AudioEngine> sink_ids(std::size(sink_details));
-
-    std::transform(std::begin(sink_details), std::end(sink_details), std::begin(sink_ids),
-                   [](const auto& sink) { return sink.id; });
-
+    std::transform(std::begin(sink_details), std::end(sink_details), std::begin(sink_ids), [](const auto& sink) { return sink.id; });
    return sink_ids;
 }

@@ -5,7 +5,6 @@
 // SPDX-License-Identifier: GPL-2.0-or-later

 #include <string>
-#include <cstdlib>
 #include <string_view>
 #ifdef _WIN32
 #include <llvm/Demangle/Demangle.h>
@@ -358,7 +358,7 @@ private:

        ConnectionState(boost::asio::ip::tcp::socket&& client_socket_, async_pipe signal_pipe_, Kernel::KernelCore& kernel)
            : client_socket{std::move(client_socket_)}
-            , signal_pipe{std::move(signal_pipe_)}
+            , signal_pipe{signal_pipe_}
            , active_thread{kernel, nullptr}
        {}

@@ -1021,9 +1021,6 @@ Result KProcess::Run(KernelCore& kernel, s32 priority, size_t stack_size) {

    // Suspend for debug, if we should.
    if (kernel.System().DebuggerEnabled()) {
-        LOG_INFO(Debug_GDBStub,
-                 "GDB stub enabled; suspending guest process until a debugger continues execution on port {}",
-                 Settings::values.gdbstub_port.GetValue());
        main_thread->RequestSuspend(kernel, SuspendType::Debug);
    }

@@ -31,3 +31,6 @@ endif()
 if (SOLARIS)
    target_link_libraries(network PRIVATE socket nsl)
 endif()
+if (MINGW)
+    target_link_libraries(network PRIVATE winmm)
+endif()
@@ -1,6 +1,3 @@
-// SPDX-FileCopyrightText: Copyright 2026 Eden Emulator Project
-// SPDX-License-Identifier: GPL-3.0-or-later
-
 // SPDX-FileCopyrightText: Copyright 2021 yuzu Emulator Project
 // SPDX-License-Identifier: GPL-2.0-or-later

@@ -32,7 +29,7 @@ struct FuncTraits<ReturnType_ (*)(Args...)> {
 };

 template <auto func, typename... Args>
-[[maybe_unused]] void SetDefinition(EmitContext& ctx, IR::Inst* inst, Args... args) {
+void SetDefinition(EmitContext& ctx, IR::Inst* inst, Args... args) {
    inst->SetDefinition<Id>(func(ctx, std::forward<Args>(args)...));
 }

@@ -492,9 +492,6 @@ void SetupCapabilities(const Profile& profile, const Info& info, EmitContext& ct
        if (ctx.uses_nonuniform_storage_texel_buffer) {
            ctx.AddCapability(spv::Capability::StorageTexelBufferArrayNonUniformIndexing);
        }
-        if (ctx.uses_nonuniform_storage_buffer) {
-            ctx.AddCapability(spv::Capability::StorageBufferArrayNonUniformIndexing);
-        }
    }
 }

@@ -4,6 +4,8 @@
 // SPDX-FileCopyrightText: Copyright 2021 yuzu Emulator Project
 // SPDX-License-Identifier: GPL-2.0-or-later

+#include <bit>
+
 #include "shader_recompiler/backend/spirv/emit_spirv.h"
 #include "shader_recompiler/backend/spirv/emit_spirv_instructions.h"
 #include "shader_recompiler/backend/spirv/spirv_emit_context.h"
@@ -21,13 +23,29 @@ Id SharedPointer(EmitContext& ctx, Id offset, u32 index_offset = 0) {
               : ctx.OpAccessChain(ctx.shared_u32, ctx.shared_memory_u32, index);
 }

+Id StorageIndex(EmitContext& ctx, const IR::Value& offset, size_t element_size) {
+    if (offset.IsImmediate()) {
+        const u32 imm_offset{static_cast<u32>(offset.U32() / element_size)};
+        return ctx.Const(imm_offset);
+    }
+    const u32 shift{static_cast<u32>(std::countr_zero(element_size))};
+    const Id index{ctx.Def(offset)};
+    if (shift == 0) {
+        return index;
+    }
+    const Id shift_id{ctx.Const(shift)};
+    return ctx.OpShiftRightLogical(ctx.U32[1], index, shift_id);
+}
+
 Id StoragePointer(EmitContext& ctx, const StorageTypeDefinition& type_def,
                  Id StorageDefinitions::*member_ptr, const IR::Value& binding,
                  const IR::Value& offset, size_t element_size) {
    if (!binding.IsImmediate()) {
        throw NotImplementedException("Dynamic storage buffer indexing");
    }
-    return ctx.StoragePointer(binding.U32(), ctx.Def(offset), type_def, static_cast<u32>(element_size), member_ptr);
+    const Id ssbo{ctx.ssbos[binding.U32()].*member_ptr};
+    const Id index{StorageIndex(ctx, offset, element_size)};
+    return ctx.OpAccessChain(type_def.element, ssbo, ctx.u32_zero_value, index);
 }

 std::pair<Id, Id> AtomicArgs(EmitContext& ctx) {
@@ -198,14 +216,16 @@ Id EmitStorageAtomicUMax32(EmitContext& ctx, const IR::Value& binding, const IR:

 Id EmitStorageAtomicInc32(EmitContext& ctx, const IR::Value& binding, const IR::Value& offset,
                          Id value) {
-    const Id pointer{StoragePointer(ctx, ctx.storage_types.U32, &StorageDefinitions::U32, binding, offset, sizeof(u32))};
-    return ctx.OpFunctionCall(ctx.U32[1], ctx.increment_cas_ssbo, pointer, value);
+    const Id ssbo{ctx.ssbos[binding.U32()].U32};
+    const Id base_index{StorageIndex(ctx, offset, sizeof(u32))};
+    return ctx.OpFunctionCall(ctx.U32[1], ctx.increment_cas_ssbo, base_index, value, ssbo);
 }

 Id EmitStorageAtomicDec32(EmitContext& ctx, const IR::Value& binding, const IR::Value& offset,
                          Id value) {
-    const Id pointer{StoragePointer(ctx, ctx.storage_types.U32, &StorageDefinitions::U32, binding, offset, sizeof(u32))};
-    return ctx.OpFunctionCall(ctx.U32[1], ctx.decrement_cas_ssbo, pointer, value);
+    const Id ssbo{ctx.ssbos[binding.U32()].U32};
+    const Id base_index{StorageIndex(ctx, offset, sizeof(u32))};
+    return ctx.OpFunctionCall(ctx.U32[1], ctx.decrement_cas_ssbo, base_index, value, ssbo);
 }

 Id EmitStorageAtomicAnd32(EmitContext& ctx, const IR::Value& binding, const IR::Value& offset,
@@ -344,49 +364,56 @@ Id EmitStorageAtomicExchange32x2(EmitContext& ctx, const IR::Value& binding,

 Id EmitStorageAtomicAddF32(EmitContext& ctx, const IR::Value& binding, const IR::Value& offset,
                           Id value) {
-    const Id pointer{StoragePointer(ctx, ctx.storage_types.U32, &StorageDefinitions::U32, binding, offset, sizeof(u32))};
-    return ctx.OpFunctionCall(ctx.F32[1], ctx.f32_add_cas, pointer, value);
+    const Id ssbo{ctx.ssbos[binding.U32()].U32};
+    const Id base_index{StorageIndex(ctx, offset, sizeof(u32))};
+    return ctx.OpFunctionCall(ctx.F32[1], ctx.f32_add_cas, base_index, value, ssbo);
 }

 Id EmitStorageAtomicAddF16x2(EmitContext& ctx, const IR::Value& binding, const IR::Value& offset,
                             Id value) {
-    const Id pointer{StoragePointer(ctx, ctx.storage_types.U32, &StorageDefinitions::U32, binding, offset, sizeof(u32))};
-    const Id result{ctx.OpFunctionCall(ctx.F16[2], ctx.f16x2_add_cas, pointer, value)};
+    const Id ssbo{ctx.ssbos[binding.U32()].U32};
+    const Id base_index{StorageIndex(ctx, offset, sizeof(u32))};
+    const Id result{ctx.OpFunctionCall(ctx.F16[2], ctx.f16x2_add_cas, base_index, value, ssbo)};
    return ctx.OpBitcast(ctx.U32[1], result);
 }

 Id EmitStorageAtomicAddF32x2(EmitContext& ctx, const IR::Value& binding, const IR::Value& offset,
                             Id value) {
-    const Id pointer{StoragePointer(ctx, ctx.storage_types.U32, &StorageDefinitions::U32, binding, offset, sizeof(u32))};
-    const Id result{ctx.OpFunctionCall(ctx.F32[2], ctx.f32x2_add_cas, pointer, value)};
+    const Id ssbo{ctx.ssbos[binding.U32()].U32};
+    const Id base_index{StorageIndex(ctx, offset, sizeof(u32))};
+    const Id result{ctx.OpFunctionCall(ctx.F32[2], ctx.f32x2_add_cas, base_index, value, ssbo)};
    return ctx.OpPackHalf2x16(ctx.U32[1], result);
 }

 Id EmitStorageAtomicMinF16x2(EmitContext& ctx, const IR::Value& binding, const IR::Value& offset,
                             Id value) {
-    const Id pointer{StoragePointer(ctx, ctx.storage_types.U32, &StorageDefinitions::U32, binding, offset, sizeof(u32))};
-    const Id result{ctx.OpFunctionCall(ctx.F16[2], ctx.f16x2_min_cas, pointer, value)};
+    const Id ssbo{ctx.ssbos[binding.U32()].U32};
+    const Id base_index{StorageIndex(ctx, offset, sizeof(u32))};
+    const Id result{ctx.OpFunctionCall(ctx.F16[2], ctx.f16x2_min_cas, base_index, value, ssbo)};
    return ctx.OpBitcast(ctx.U32[1], result);
 }

 Id EmitStorageAtomicMinF32x2(EmitContext& ctx, const IR::Value& binding, const IR::Value& offset,
                             Id value) {
-    const Id pointer{StoragePointer(ctx, ctx.storage_types.U32, &StorageDefinitions::U32, binding, offset, sizeof(u32))};
-    const Id result{ctx.OpFunctionCall(ctx.F32[2], ctx.f32x2_min_cas, pointer, value)};
+    const Id ssbo{ctx.ssbos[binding.U32()].U32};
+    const Id base_index{StorageIndex(ctx, offset, sizeof(u32))};
+    const Id result{ctx.OpFunctionCall(ctx.F32[2], ctx.f32x2_min_cas, base_index, value, ssbo)};
    return ctx.OpPackHalf2x16(ctx.U32[1], result);
 }

 Id EmitStorageAtomicMaxF16x2(EmitContext& ctx, const IR::Value& binding, const IR::Value& offset,
                             Id value) {
-    const Id pointer{StoragePointer(ctx, ctx.storage_types.U32, &StorageDefinitions::U32, binding, offset, sizeof(u32))};
-    const Id result{ctx.OpFunctionCall(ctx.F16[2], ctx.f16x2_max_cas, pointer, value)};
+    const Id ssbo{ctx.ssbos[binding.U32()].U32};
+    const Id base_index{StorageIndex(ctx, offset, sizeof(u32))};
+    const Id result{ctx.OpFunctionCall(ctx.F16[2], ctx.f16x2_max_cas, base_index, value, ssbo)};
    return ctx.OpBitcast(ctx.U32[1], result);
 }

 Id EmitStorageAtomicMaxF32x2(EmitContext& ctx, const IR::Value& binding, const IR::Value& offset,
                             Id value) {
-    const Id pointer{StoragePointer(ctx, ctx.storage_types.U32, &StorageDefinitions::U32, binding, offset, sizeof(u32))};
-    const Id result{ctx.OpFunctionCall(ctx.F32[2], ctx.f32x2_max_cas, pointer, value)};
+    const Id ssbo{ctx.ssbos[binding.U32()].U32};
+    const Id base_index{StorageIndex(ctx, offset, sizeof(u32))};
+    const Id result{ctx.OpFunctionCall(ctx.F32[2], ctx.f32x2_max_cas, base_index, value, ssbo)};
    return ctx.OpPackHalf2x16(ctx.U32[1], result);
 }

@@ -4,33 +4,46 @@
 // SPDX-FileCopyrightText: Copyright 2021 yuzu Emulator Project
 // SPDX-License-Identifier: GPL-2.0-or-later

+#include <bit>
+
 #include "shader_recompiler/backend/spirv/emit_spirv.h"
 #include "shader_recompiler/backend/spirv/emit_spirv_instructions.h"
 #include "shader_recompiler/backend/spirv/spirv_emit_context.h"

 namespace Shader::Backend::SPIRV {
 namespace {
-Id StorageByteOffset(EmitContext& ctx, const IR::Value& offset, size_t element_size, u32 index_offset) {
-    Id byte_offset{ctx.Def(offset)};
-    if (index_offset != 0) {
-        byte_offset = ctx.OpIAdd(ctx.U32[1], byte_offset, ctx.Const(static_cast<u32>(index_offset * element_size)));
+Id StorageIndex(EmitContext& ctx, const IR::Value& offset, size_t element_size,
+                u32 index_offset = 0) {
+    if (offset.IsImmediate()) {
+        const u32 imm_offset{static_cast<u32>(offset.U32() / element_size) + index_offset};
+        return ctx.Const(imm_offset);
    }
-    return byte_offset;
+    const u32 shift{static_cast<u32>(std::countr_zero(element_size))};
+    Id index{ctx.Def(offset)};
+    if (shift != 0) {
+        const Id shift_id{ctx.Const(shift)};
+        index = ctx.OpShiftRightLogical(ctx.U32[1], index, shift_id);
+    }
+    if (index_offset != 0) {
+        index = ctx.OpIAdd(ctx.U32[1], index, ctx.Const(index_offset));
+    }
+    return index;
 }

 Id StoragePointer(EmitContext& ctx, const IR::Value& binding, const IR::Value& offset,
                  const StorageTypeDefinition& type_def, size_t element_size,
-                  Id StorageDefinitions::* member_ptr, u32 index_offset = 0) {
+                  Id StorageDefinitions::*member_ptr, u32 index_offset = 0) {
    if (!binding.IsImmediate()) {
        throw NotImplementedException("Dynamic storage buffer indexing");
    }
-    const Id byte_offset{StorageByteOffset(ctx, offset, element_size, index_offset)};
-    return ctx.StoragePointer(binding.U32(), byte_offset, type_def, static_cast<u32>(element_size), member_ptr);
+    const Id ssbo{ctx.ssbos[binding.U32()].*member_ptr};
+    const Id index{StorageIndex(ctx, offset, element_size, index_offset)};
+    return ctx.OpAccessChain(type_def.element, ssbo, ctx.u32_zero_value, index);
 }

 Id LoadStorage(EmitContext& ctx, const IR::Value& binding, const IR::Value& offset, Id result_type,
               const StorageTypeDefinition& type_def, size_t element_size,
-               Id StorageDefinitions::* member_ptr, u32 index_offset = 0) {
+               Id StorageDefinitions::*member_ptr, u32 index_offset = 0) {
    const Id pointer{
        StoragePointer(ctx, binding, offset, type_def, element_size, member_ptr, index_offset)};
    return ctx.OpLoad(result_type, pointer);
@@ -44,7 +57,7 @@ Id LoadStorage32(EmitContext& ctx, const IR::Value& binding, const IR::Value& of

 void WriteStorage(EmitContext& ctx, const IR::Value& binding, const IR::Value& offset, Id value,
                  const StorageTypeDefinition& type_def, size_t element_size,
-                  Id StorageDefinitions::* member_ptr, u32 index_offset = 0) {
+                  Id StorageDefinitions::*member_ptr, u32 index_offset = 0) {
    const Id pointer{
        StoragePointer(ctx, binding, offset, type_def, element_size, member_ptr, index_offset)};
    ctx.OpStore(pointer, value);
@@ -299,7 +299,7 @@ void DefineConstBuffers(EmitContext& ctx, const Info& info, Id UniformDefinition
 }

 void DefineSsbos(EmitContext& ctx, StorageTypeDefinition& type_def,
-                 Id StorageDefinitions::* member_type, const Info& info, u32 binding, Id type,
+                 Id StorageDefinitions::*member_type, const Info& info, u32 binding, Id type,
                 u32 stride) {
    const Id array_type{ctx.TypeRuntimeArray(type)};
    ctx.Decorate(array_type, spv::Decoration::ArrayStride, stride);
@@ -309,27 +309,23 @@ void DefineSsbos(EmitContext& ctx, StorageTypeDefinition& type_def,
    ctx.MemberDecorate(struct_type, 0, spv::Decoration::Offset, 0U);

    const Id struct_pointer{ctx.TypePointer(spv::StorageClass::StorageBuffer, struct_type)};
+    type_def.array = struct_pointer;
    type_def.element = ctx.TypePointer(spv::StorageClass::StorageBuffer, type);

    u32 index{};
    for (const StorageBufferDescriptor& desc : info.storage_buffers_descriptors) {
-        const Id variable_type{[&] {
-            if (desc.count == 1) {
-                return struct_pointer;
-            }
-            const Id descriptor_array{ctx.TypeArray(struct_type, ctx.Const(desc.count))};
-            return ctx.TypePointer(spv::StorageClass::StorageBuffer, descriptor_array);
-        }()};
-        const Id id{ctx.AddGlobalVariable(variable_type, spv::StorageClass::StorageBuffer)};
+        const Id id{ctx.AddGlobalVariable(struct_pointer, spv::StorageClass::StorageBuffer)};
        ctx.Decorate(id, spv::Decoration::Binding, binding);
        ctx.Decorate(id, spv::Decoration::DescriptorSet, 0U);
        ctx.Name(id, fmt::format("ssbo{}", index));
        if (ctx.profile.supported_spirv >= 0x00010400) {
            ctx.interfaces.push_back(id);
        }
-        ctx.ssbos[index].*member_type = id;
-        ++index;
-        ++binding;
+        for (size_t i = 0; i < desc.count; ++i) {
+            ctx.ssbos[index + i].*member_type = id;
+        }
+        index += desc.count;
+        binding += desc.count;
    }
 }

@@ -372,7 +368,8 @@ Id CasFunction(EmitContext& ctx, Operation operation, Id value_type) {
    return func;
 }

-Id CasLoop(EmitContext& ctx, Operation operation, Id element_pointer, Id value_type, Id memory_type, spv::Scope scope) {
+Id CasLoop(EmitContext& ctx, Operation operation, Id array_pointer, Id element_pointer,
+           Id value_type, Id memory_type, spv::Scope scope) {
    const bool is_shared{scope == spv::Scope::Workgroup};
    const bool is_struct{!is_shared || ctx.uses_explicit_workgroup_layout};
    const Id cas_func{CasFunction(ctx, operation, value_type)};
@@ -382,12 +379,14 @@ Id CasLoop(EmitContext& ctx, Operation operation, Id element_pointer, Id value_t
    const Id loop_header{ctx.OpLabel()};
    const Id continue_block{ctx.OpLabel()};
    const Id merge_block{ctx.OpLabel()};
-    const Id func_type{is_shared ? ctx.TypeFunction(value_type, ctx.U32[1], value_type)
-                                 : ctx.TypeFunction(value_type, element_pointer, value_type)};
+    const Id func_type{is_shared
+                           ? ctx.TypeFunction(value_type, ctx.U32[1], value_type)
+                           : ctx.TypeFunction(value_type, ctx.U32[1], value_type, array_pointer)};

    const Id func{ctx.OpFunction(value_type, spv::FunctionControlMask::MaskNone, func_type)};
-    const Id address{ctx.OpFunctionParameter(is_shared ? ctx.U32[1] : element_pointer)};
+    const Id index{ctx.OpFunctionParameter(ctx.U32[1])};
    const Id op_b{ctx.OpFunctionParameter(value_type)};
+    const Id base{is_shared ? ctx.shared_memory_u32 : ctx.OpFunctionParameter(array_pointer)};
    ctx.AddLabel();
    ctx.OpBranch(loop_header);
    ctx.AddLabel(loop_header);
@@ -396,13 +395,8 @@ Id CasLoop(EmitContext& ctx, Operation operation, Id element_pointer, Id value_t
    ctx.OpBranch(continue_block);

    ctx.AddLabel(continue_block);
-    const Id word_pointer{[&] {
-        if (!is_shared) {
-            return address;
-        }
-        return is_struct ? ctx.OpAccessChain(element_pointer, ctx.shared_memory_u32, zero, address)
-                         : ctx.OpAccessChain(element_pointer, ctx.shared_memory_u32, address);
-    }()};
+    const Id word_pointer{is_struct ? ctx.OpAccessChain(element_pointer, base, zero, index)
+                                    : ctx.OpAccessChain(element_pointer, base, index)};
    if (value_type.value == ctx.F32[2].value) {
        const Id u32_value{ctx.OpLoad(ctx.U32[1], word_pointer)};
        const Id value{ctx.OpUnpackHalf2x16(ctx.F32[2], u32_value)};
@@ -486,7 +480,6 @@ EmitContext::EmitContext(const Profile& profile_, const RuntimeInfo& runtime_inf
    DefineSharedMemoryFunctions(program);
    DefineConstantBuffers(program.info, uniform_binding);
    DefineConstantBufferIndirectFunctions(program.info);
-    DefineStorageBufferMappings(program.info, storage_binding);
    DefineStorageBuffers(program.info, storage_binding);
    DefineTextureBuffers(program.info, texture_binding);
    DefineImageBuffers(program.info, image_binding);
@@ -539,36 +532,6 @@ Id EmitContext::BitOffset16(const IR::Value& offset) {
    return OpBitwiseAnd(U32[1], OpShiftLeftLogical(U32[1], Def(offset), Const(3u)), Const(16u));
 }

-Id EmitContext::StoragePointer(u32 binding, Id byte_offset, const StorageTypeDefinition& type_def,
-                               u32 element_size, Id StorageDefinitions::* member_ptr) {
-    const Id ssbo{ssbos[binding].*member_ptr};
-    const u32 segment_count{storage_buffer_mapping_counts[binding]};
-    if (segment_count <= 1) {
-        const Id index{
-            element_size == 1
-                ? byte_offset
-                : OpShiftRightLogical(U32[1], byte_offset, Const(static_cast<u32>(std::countr_zero(element_size))))};
-        return OpAccessChain(type_def.element, ssbo, u32_zero_value, index);
-    }
-
-    const Id mapped{OpFunctionCall(U32[2], storage_buffer_map_func,
-                                   Const(storage_buffer_mapping_bases[binding]),
-                                   Const(segment_count), byte_offset)};
-    const Id segment{OpCompositeExtract(U32[1], mapped, 0U)};
-    const Id local_offset{OpCompositeExtract(U32[1], mapped, 1U)};
-    const Id index{
-        element_size == 1
-            ? local_offset
-            : OpShiftRightLogical(U32[1], local_offset, Const(static_cast<u32>(std::countr_zero(element_size))))};
-    Decorate(segment, spv::Decoration::NonUniform);
-    non_uniform_ids.insert(segment.value);
-    const Id pointer{OpAccessChain(type_def.element, ssbo, segment, u32_zero_value, index)};
-    Decorate(pointer, spv::Decoration::NonUniform);
-    non_uniform_ids.insert(pointer.value);
-    uses_nonuniform_storage_buffer = true;
-    return pointer;
-}
-
 void EmitContext::DefineCommonTypes(const Info& info) {
    void_id = TypeVoid();

@@ -733,10 +696,12 @@ void EmitContext::DefineSharedMemory(const IR::Program& program) {

 void EmitContext::DefineSharedMemoryFunctions(const IR::Program& program) {
    if (program.info.uses_shared_increment) {
-        increment_cas_shared = CasLoop(*this, Operation::Increment, shared_u32, U32[1], U32[1], spv::Scope::Workgroup);
+        increment_cas_shared = CasLoop(*this, Operation::Increment, shared_memory_u32_type,
+                                       shared_u32, U32[1], U32[1], spv::Scope::Workgroup);
    }
    if (program.info.uses_shared_decrement) {
-        decrement_cas_shared = CasLoop(*this, Operation::Decrement, shared_u32, U32[1], U32[1], spv::Scope::Workgroup);
+        decrement_cas_shared = CasLoop(*this, Operation::Decrement, shared_memory_u32_type,
+                                       shared_u32, U32[1], U32[1], spv::Scope::Workgroup);
    }
 }

@@ -980,7 +945,8 @@ void EmitContext::DefineGlobalMemoryFunctions(const Info& info) {
    }
    using DefPtr = Id StorageDefinitions::*;
    const Id zero{u32_zero_value};
-    const auto define_body{[&](DefPtr ssbo_member, Id addr, const StorageTypeDefinition& type_def, u32 shift, auto&& callback) {
+    const auto define_body{[&](DefPtr ssbo_member, Id addr, Id element_pointer, u32 shift,
+                               auto&& callback) {
        AddLabel();
        const size_t num_buffers{info.storage_buffers_descriptors.size()};
        for (size_t index = 0; index < num_buffers; ++index) {
@@ -1007,28 +973,30 @@ void EmitContext::DefineGlobalMemoryFunctions(const Info& info) {
            OpSelectionMerge(else_label, spv::SelectionControlMask::MaskNone);
            OpBranchConditional(cond, then_label, else_label);
            AddLabel(then_label);
+            const Id ssbo_id{ssbos[index].*ssbo_member};
            const Id ssbo_offset{OpUConvert(U32[1], OpISub(U64, addr, ssbo_addr))};
-            const Id ssbo_pointer{StoragePointer(static_cast<u32>(index), ssbo_offset, type_def, 1U << shift, ssbo_member)};
+            const Id ssbo_index{OpShiftRightLogical(U32[1], ssbo_offset, Const(shift))};
+            const Id ssbo_pointer{OpAccessChain(element_pointer, ssbo_id, zero, ssbo_index)};
            callback(ssbo_pointer);
            AddLabel(else_label);
        }
    }};
-    const auto define_load{
-        [&](DefPtr ssbo_member, const StorageTypeDefinition& type_def, Id type, u32 shift) {
-            const Id function_type{TypeFunction(type, U64)};
-            const Id func_id{OpFunction(type, spv::FunctionControlMask::MaskNone, function_type)};
-            const Id addr{OpFunctionParameter(U64)};
-            define_body(ssbo_member, addr, type_def, shift, [&](Id ssbo_pointer) { OpReturnValue(OpLoad(type, ssbo_pointer)); });
-            OpReturnValue(ConstantNull(type));
-            OpFunctionEnd();
-            return func_id;
-        }};
-    const auto define_write{[&](DefPtr ssbo_member, const StorageTypeDefinition& type_def, Id type, u32 shift) {
+    const auto define_load{[&](DefPtr ssbo_member, Id element_pointer, Id type, u32 shift) {
+        const Id function_type{TypeFunction(type, U64)};
+        const Id func_id{OpFunction(type, spv::FunctionControlMask::MaskNone, function_type)};
+        const Id addr{OpFunctionParameter(U64)};
+        define_body(ssbo_member, addr, element_pointer, shift,
+                    [&](Id ssbo_pointer) { OpReturnValue(OpLoad(type, ssbo_pointer)); });
+        OpReturnValue(ConstantNull(type));
+        OpFunctionEnd();
+        return func_id;
+    }};
+    const auto define_write{[&](DefPtr ssbo_member, Id element_pointer, Id type, u32 shift) {
        const Id function_type{TypeFunction(void_id, U64, type)};
        const Id func_id{OpFunction(void_id, spv::FunctionControlMask::MaskNone, function_type)};
        const Id addr{OpFunctionParameter(U64)};
        const Id data{OpFunctionParameter(type)};
-        define_body(ssbo_member, addr, type_def, shift, [&](Id ssbo_pointer) {
+        define_body(ssbo_member, addr, element_pointer, shift, [&](Id ssbo_pointer) {
            OpStore(ssbo_pointer, data);
            OpReturn();
        });
@@ -1038,9 +1006,10 @@ void EmitContext::DefineGlobalMemoryFunctions(const Info& info) {
    }};
    const auto define{
        [&](DefPtr ssbo_member, const StorageTypeDefinition& type_def, Id type, size_t size) {
+            const Id element_type{type_def.element};
            const u32 shift{static_cast<u32>(std::countr_zero(size))};
-            const Id load_func{define_load(ssbo_member, type_def, type, shift)};
-            const Id write_func{define_write(ssbo_member, type_def, type, shift)};
+            const Id load_func{define_load(ssbo_member, element_type, type, shift)};
+            const Id write_func{define_write(ssbo_member, element_type, type, shift)};
            return std::make_pair(load_func, write_func);
        }};
    std::tie(load_global_func_u32, write_global_func_u32) =
@@ -1259,79 +1228,6 @@ void EmitContext::DefineConstantBufferIndirectFunctions(const Info& info) {
    }
 }

-void EmitContext::DefineStorageBufferMappings(const Info& info, u32& binding) {
-    if (!UsesStorageBufferMappings(info)) {
-        return;
-    }
-    ASSERT(profile.support_storage_buffer_array_nonuniform_indexing);
-    AddExtension("SPV_KHR_storage_buffer_storage_class");
-
-    const u32 num_entries{NumDescriptors(info.storage_buffers_descriptors)};
-    const Id array_type{TypeArray(U32[1], Const(num_entries))};
-    Decorate(array_type, spv::Decoration::ArrayStride, sizeof(u32));
-    const Id struct_type{TypeStruct(array_type)};
-    Decorate(struct_type, spv::Decoration::Block);
-    MemberName(struct_type, 0, "segment_sizes");
-    MemberDecorate(struct_type, 0, spv::Decoration::Offset, 0U);
-    const Id pointer_type{TypePointer(spv::StorageClass::StorageBuffer, struct_type)};
-    storage_buffer_mapping_u32 = TypePointer(spv::StorageClass::StorageBuffer, U32[1]);
-    storage_buffer_mapping = AddGlobalVariable(pointer_type, spv::StorageClass::StorageBuffer);
-    Decorate(storage_buffer_mapping, spv::Decoration::Binding, binding++);
-    Decorate(storage_buffer_mapping, spv::Decoration::DescriptorSet, 0U);
-    Name(storage_buffer_mapping, "storage_buffer_mapping");
-    //Starting with version 1.4... (https://registry.khronos.org/SPIR-V/specs/unified1/SPIRV.html)
-    if (profile.supported_spirv >= 0x00010400) {
-        interfaces.push_back(storage_buffer_mapping);
-    }
-
-    u32 mapping_base{};
-    for (u32 index = 0; index < info.storage_buffers_descriptors.size(); ++index) {
-        const StorageBufferDescriptor& desc = info.storage_buffers_descriptors[index];
-        storage_buffer_mapping_bases[index] = mapping_base;
-        storage_buffer_mapping_counts[index] = desc.count;
-        mapping_base += desc.count;
-    }
-
-    const Id function_type{TypeFunction(U32[2], U32[1], U32[1], U32[1])};
-    storage_buffer_map_func = OpFunction(U32[2], spv::FunctionControlMask::MaskNone, function_type);
-    const Id base{OpFunctionParameter(U32[1])};
-    const Id count{OpFunctionParameter(U32[1])};
-    const Id byte_offset{OpFunctionParameter(U32[1])};
-    const Id index_pointer_type{TypePointer(spv::StorageClass::Function, U32[1])};
-    const Id loop_header{OpLabel()};
-    const Id continue_block{OpLabel()};
-    const Id merge_block{OpLabel()};
-    AddLabel();
-    const Id segment_var{AddLocalVariable(index_pointer_type, spv::StorageClass::Function)};
-    const Id offset_var{AddLocalVariable(index_pointer_type, spv::StorageClass::Function)};
-    OpStore(segment_var, u32_zero_value);
-    OpStore(offset_var, byte_offset);
-    OpBranch(loop_header);
-
-    AddLabel(loop_header);
-    const Id segment{OpLoad(U32[1], segment_var)};
-    const Id local_offset{OpLoad(U32[1], offset_var)};
-    const Id mapping_index{OpIAdd(U32[1], base, segment)};
-    const Id size_pointer{OpAccessChain(storage_buffer_mapping_u32, storage_buffer_mapping, u32_zero_value, mapping_index)};
-    const Id segment_size{OpLoad(U32[1], size_pointer)};
-    const Id fits{OpULessThan(U1, local_offset, segment_size)};
-    const Id last_segment{OpISub(U32[1], count, Const(1U))};
-    const Id is_last{OpIEqual(U1, segment, last_segment)};
-    const Id found{OpLogicalOr(U1, fits, is_last)};
-    OpLoopMerge(merge_block, continue_block, spv::LoopControlMask::MaskNone);
-    OpBranchConditional(found, merge_block, continue_block);
-
-    AddLabel(continue_block);
-    OpStore(offset_var, OpISub(U32[1], local_offset, segment_size));
-    OpStore(segment_var, OpIAdd(U32[1], segment, Const(1U)));
-    OpBranch(loop_header);
-
-    AddLabel(merge_block);
-    OpReturnValue(OpCompositeConstruct(U32[2], segment, local_offset));
-    OpFunctionEnd();
-    Name(storage_buffer_map_func, "map_storage_buffer");
-}
-
 void EmitContext::DefineStorageBuffers(const Info& info, u32& binding) {
    if (info.storage_buffers_descriptors.empty()) {
        return;
@@ -1375,7 +1271,9 @@ void EmitContext::DefineStorageBuffers(const Info& info, u32& binding) {
        DefineSsbos(*this, storage_types.U32x4, &StorageDefinitions::U32x4, info, binding, U32[4],
                    sizeof(u32[4]));
    }
-    binding += static_cast<u32>(info.storage_buffers_descriptors.size());
+    for (const StorageBufferDescriptor& desc : info.storage_buffers_descriptors) {
+        binding += desc.count;
+    }
    const bool needs_function{
        info.uses_global_increment || info.uses_global_decrement || info.uses_atomic_f32_add ||
        info.uses_atomic_f16x2_add || info.uses_atomic_f16x2_min || info.uses_atomic_f16x2_max ||
@@ -1384,31 +1282,40 @@ void EmitContext::DefineStorageBuffers(const Info& info, u32& binding) {
        AddCapability(spv::Capability::VariablePointersStorageBuffer);
    }
    if (info.uses_global_increment) {
-        increment_cas_ssbo = CasLoop(*this, Operation::Increment, storage_types.U32.element, U32[1], U32[1], spv::Scope::Device);
+        increment_cas_ssbo = CasLoop(*this, Operation::Increment, storage_types.U32.array,
+                                     storage_types.U32.element, U32[1], U32[1], spv::Scope::Device);
    }
    if (info.uses_global_decrement) {
-        decrement_cas_ssbo = CasLoop(*this, Operation::Decrement, storage_types.U32.element, U32[1], U32[1], spv::Scope::Device);
+        decrement_cas_ssbo = CasLoop(*this, Operation::Decrement, storage_types.U32.array,
+                                     storage_types.U32.element, U32[1], U32[1], spv::Scope::Device);
    }
    if (info.uses_atomic_f32_add) {
-        f32_add_cas = CasLoop(*this, Operation::FPAdd, storage_types.U32.element, F32[1], U32[1], spv::Scope::Device);
+        f32_add_cas = CasLoop(*this, Operation::FPAdd, storage_types.U32.array,
+                              storage_types.U32.element, F32[1], U32[1], spv::Scope::Device);
    }
    if (info.uses_atomic_f16x2_add) {
-        f16x2_add_cas = CasLoop(*this, Operation::FPAdd, storage_types.U32.element, F16[2], F16[2], spv::Scope::Device);
+        f16x2_add_cas = CasLoop(*this, Operation::FPAdd, storage_types.U32.array,
+                                storage_types.U32.element, F16[2], F16[2], spv::Scope::Device);
    }
    if (info.uses_atomic_f16x2_min) {
-        f16x2_min_cas = CasLoop(*this, Operation::FPMin, storage_types.U32.element, F16[2], F16[2], spv::Scope::Device);
+        f16x2_min_cas = CasLoop(*this, Operation::FPMin, storage_types.U32.array,
+                                storage_types.U32.element, F16[2], F16[2], spv::Scope::Device);
    }
    if (info.uses_atomic_f16x2_max) {
-        f16x2_max_cas = CasLoop(*this, Operation::FPMax, storage_types.U32.element, F16[2], F16[2], spv::Scope::Device);
+        f16x2_max_cas = CasLoop(*this, Operation::FPMax, storage_types.U32.array,
+                                storage_types.U32.element, F16[2], F16[2], spv::Scope::Device);
    }
    if (info.uses_atomic_f32x2_add) {
-        f32x2_add_cas = CasLoop(*this, Operation::FPAdd, storage_types.U32.element, F32[2], F32[2], spv::Scope::Device);
+        f32x2_add_cas = CasLoop(*this, Operation::FPAdd, storage_types.U32.array,
+                                storage_types.U32.element, F32[2], F32[2], spv::Scope::Device);
    }
    if (info.uses_atomic_f32x2_min) {
-        f32x2_min_cas = CasLoop(*this, Operation::FPMin, storage_types.U32.element, F32[2], F32[2], spv::Scope::Device);
+        f32x2_min_cas = CasLoop(*this, Operation::FPMin, storage_types.U32.array,
+                                storage_types.U32.element, F32[2], F32[2], spv::Scope::Device);
    }
    if (info.uses_atomic_f32x2_max) {
-        f32x2_max_cas = CasLoop(*this, Operation::FPMax, storage_types.U32.element, F32[2], F32[2], spv::Scope::Device);
+        f32x2_max_cas = CasLoop(*this, Operation::FPMax, storage_types.U32.array,
+                                storage_types.U32.element, F32[2], F32[2], spv::Scope::Device);
    }
 }

@@ -114,6 +114,7 @@ struct UniformDefinitions {
 };

 struct StorageTypeDefinition {
+    Id array{};
    Id element{};
 };

@@ -172,8 +173,6 @@ public:
    [[nodiscard]] Id BitOffset8(const IR::Value& offset);
    [[nodiscard]] Id BitOffset16(const IR::Value& offset);

-    [[nodiscard]] Id StoragePointer(u32 binding, Id byte_offset, const StorageTypeDefinition& type_def, u32 element_size, Id StorageDefinitions::*member_ptr);
-
    Id Const(u32 value) {
        return Constant(U32[1], value);
    }
@@ -258,11 +257,6 @@ public:

    std::array<UniformDefinitions, Info::MAX_CBUFS> cbufs{};
    std::array<StorageDefinitions, Info::MAX_SSBOS> ssbos{};
-    std::array<u32, Info::MAX_SSBOS> storage_buffer_mapping_bases{};
-    std::array<u32, Info::MAX_SSBOS> storage_buffer_mapping_counts{};
-    Id storage_buffer_mapping{};
-    Id storage_buffer_mapping_u32{};
-    Id storage_buffer_map_func{};
    std::vector<TextureBufferDefinition> texture_buffers;
    std::vector<ImageBufferDefinition> image_buffers;
    std::vector<TextureDefinition> textures;
@@ -382,7 +376,6 @@ public:
    bool uses_nonuniform_storage_image{};
    bool uses_nonuniform_uniform_texel_buffer{};
    bool uses_nonuniform_storage_texel_buffer{};
-    bool uses_nonuniform_storage_buffer{};

 private:
    void DefineCommonTypes(const Info& info);
@@ -393,7 +386,6 @@ private:
    void DefineSharedMemoryFunctions(const IR::Program& program);
    void DefineConstantBuffers(const Info& info, u32& binding);
    void DefineConstantBufferIndirectFunctions(const Info& info);
-    void DefineStorageBufferMappings(const Info& info, u32& binding);
    void DefineStorageBuffers(const Info& info, u32& binding);
    void DefineTextureBuffers(const Info& info, u32& binding);
    void DefineImageBuffers(const Info& info, u32& binding);
@@ -132,14 +132,6 @@ void AddNVNStorageBuffers(IR::Program& program) {
    }
 }

-void ConfigureStorageBufferMappings(IR::Program& program, const HostTranslateInfo& host_info) {
-    // https://docs.vulkan.org/guide/latest/descriptor_arrays.html
-    // will be needed: descriptor array elements represent physical spans of one guest virtual buffer.
-    for (StorageBufferDescriptor& desc : program.info.storage_buffers_descriptors) {
-        desc.count = host_info.storage_buffer_segment_count;
-    }
-}
-
 using IR::IsLegacyAttribute; //rescoped to attribute.h to make it visible in load_store_attribute.cpp IPA

 std::map<IR::Attribute, IR::Attribute> GenerateLegacyToGenericMappings(
@@ -307,7 +299,6 @@ IR::Program TranslateProgram(ObjectPool<IR::Inst>& inst_pool, ObjectPool<IR::Blo
    Optimization::PositionPass(env, program);

    Optimization::GlobalMemoryToStorageBufferPass(program, normalized_host_info);
-    ConfigureStorageBufferMappings(program, normalized_host_info);
    Optimization::TexturePass(env, program, normalized_host_info);

    if (Settings::values.resolution_info.active || Settings::values.rescale_hack.GetValue()) {
@@ -323,7 +314,6 @@ IR::Program TranslateProgram(ObjectPool<IR::Inst>& inst_pool, ObjectPool<IR::Blo

    CollectInterpolationInfo(env, program);
    AddNVNStorageBuffers(program);
-    ConfigureStorageBufferMappings(program, normalized_host_info);
    return program;
 }

@@ -6,7 +6,6 @@

 #pragma once

-#include <algorithm>
 #include "common/common_types.h"

 namespace Shader {
@@ -20,7 +19,6 @@ struct HostTranslateInfo {

    u64 min_ssbo_alignment{};            ///< Minimum alignment supported by the device for SSBOs
    u32 max_per_stage_descriptor_sampled_images{}; ///< maximum sampled descriptors per stage
-    u32 max_per_stage_descriptor_storage_buffers{}; ///< maximum storage descriptors per stage
    u32 max_per_stage_resources{};                 ///< maximum resources per stage
    u32 max_descriptor_set_samplers{};
    u32 max_descriptor_set_uniform_buffers{};
@@ -40,14 +38,12 @@ struct HostTranslateInfo {
                                                ///< passthrough shaders
    bool support_conditional_barrier{}; ///< True when the device supports barriers in conditional
                                        ///< control flow
-    u32 storage_buffer_segment_count{1}; ///< Physical ranges available to each guest SSBO

    void ApplyDescriptorLimitPolicy() noexcept {
        if (min_ssbo_alignment == 0) {
            min_ssbo_alignment = 1;
        }
        ApplyDescriptorLimitFallback(max_per_stage_descriptor_sampled_images);
-        ApplyDescriptorLimitFallback(max_per_stage_descriptor_storage_buffers);
        ApplyDescriptorLimitFallback(max_per_stage_resources);
        ApplyDescriptorLimitFallback(max_descriptor_set_samplers);
        ApplyDescriptorLimitFallback(max_descriptor_set_uniform_buffers);
@@ -57,7 +53,6 @@ struct HostTranslateInfo {
        ApplyDescriptorLimitFallback(max_descriptor_set_sampled_images);
        ApplyDescriptorLimitFallback(max_descriptor_set_storage_images);
        ApplyDescriptorLimitFallback(max_descriptor_set_input_attachements);
-        storage_buffer_segment_count = (std::max)(storage_buffer_segment_count, 1U);
    }

 private:
@@ -64,7 +64,6 @@ struct Profile {
    bool support_storage_image_array_nonuniform_indexing{};
    bool support_uniform_texel_buffer_array_nonuniform_indexing{};
    bool support_storage_texel_buffer_array_nonuniform_indexing{};
-    bool support_storage_buffer_array_nonuniform_indexing{};

    bool warp_size_potentially_larger_than_guest{};

@@ -6,7 +6,6 @@

 #pragma once

-#include <algorithm>
 #include <array>
 #include <bitset>
 #include <map>
@@ -341,10 +340,6 @@ struct Info {
    ImageDescriptors image_descriptors;
 };

-[[nodiscard]] inline bool UsesStorageBufferMappings(const Info& info) noexcept {
-    return std::ranges::any_of(info.storage_buffers_descriptors, [](const auto& desc) { return desc.count > 1; });
-}
-
 template <typename Descriptors>
 u32 NumDescriptors(const Descriptors& descriptors) {
    u32 num{};
@@ -7,8 +7,6 @@
 #pragma once

 #include <algorithm>
-#include <cstring>
-#include <limits>
 #include <memory>
 #include <numeric>

@@ -425,7 +423,7 @@ void BufferCache<P>::UnbindGraphicsStorageBuffers(size_t stage) {

 template <class P>
 bool BufferCache<P>::BindGraphicsStorageBuffer(size_t stage, size_t ssbo_index, u32 cbuf_index,
-                                               u32 cbuf_offset, bool is_written, u32 descriptor_count) {
+                                               u32 cbuf_offset, bool is_written) {
    const bool already_enabled =
        ((channel_state->enabled_storage_buffers[stage] >> ssbo_index) & 1U) != 0;
    if constexpr (requires { runtime.ShouldLimitDynamicStorageBuffers(); }) {
@@ -450,8 +448,8 @@ bool BufferCache<P>::BindGraphicsStorageBuffer(size_t stage, size_t ssbo_index,
    const auto& cbufs = maxwell3d->state.shader_stages[stage];
    const GPUVAddr ssbo_addr = cbufs.const_buffers[cbuf_index].address + cbuf_offset;
    channel_state->storage_buffers[stage][ssbo_index] =
-        StorageBufferBinding(ssbo_addr, cbuf_index, is_written, descriptor_count);
-    return channel_state->storage_buffers[stage][ssbo_index].gpu_addr != 0;
+        StorageBufferBinding(ssbo_addr, cbuf_index, is_written);
+    return (channel_state->storage_buffers[stage][ssbo_index].buffer_id != NULL_BUFFER_ID);
 }

 template <class P>
@@ -489,7 +487,7 @@ void BufferCache<P>::UnbindComputeStorageBuffers() {

 template <class P>
 void BufferCache<P>::BindComputeStorageBuffer(size_t ssbo_index, u32 cbuf_index, u32 cbuf_offset,
-                                              bool is_written, u32 descriptor_count) {
+                                              bool is_written) {
    if (ssbo_index >= channel_state->compute_storage_buffers.size()) [[unlikely]] {
        LOG_ERROR(HW_GPU, "Storage buffer index {} exceeds maximum storage buffer count",
                  ssbo_index);
@@ -526,7 +524,7 @@ void BufferCache<P>::BindComputeStorageBuffer(size_t ssbo_index, u32 cbuf_index,
    const auto& cbufs = launch_desc.const_buffer_config;
    const GPUVAddr ssbo_addr = cbufs[cbuf_index].Address() + cbuf_offset;
    channel_state->compute_storage_buffers[ssbo_index] =
-        StorageBufferBinding(ssbo_addr, cbuf_index, is_written, descriptor_count);
+        StorageBufferBinding(ssbo_addr, cbuf_index, is_written);
 }

 template <class P>
@@ -1002,52 +1000,27 @@ void BufferCache<P>::BindHostGraphicsUniformBuffer(size_t stage, u32 index, u32

 template <class P>
 void BufferCache<P>::BindHostGraphicsStorageBuffers(size_t stage) {
-    boost::container::small_vector<u32, NUM_STORAGE_BUFFERS> segment_sizes;
-    bool uses_mapping{};
-    ForEachEnabledBit(channel_state->enabled_storage_buffers[stage], [&](u32 index) {
-        const StorageBufferBindingInfo& binding = channel_state->storage_buffers[stage][index];
-        uses_mapping |= binding.descriptor_count > 1;
-        for (u32 segment = 0; segment < binding.descriptor_count; ++segment) {
-            segment_sizes.push_back(segment < binding.segments.size() ? binding.segments[segment].size : 0);
-        }
-    });
-    if (uses_mapping) {
-        const u32 mapping_size = static_cast<u32>(segment_sizes.size() * sizeof(u32));
-        if constexpr (!IS_OPENGL) {
-            const std::span<u8> mapped = runtime.BindMappedStorageBuffer(mapping_size);
-            std::memcpy(mapped.data(), segment_sizes.data(), mapping_size);
-        }
-    }
-
    u32 binding_index = 0;
    ForEachEnabledBit(channel_state->enabled_storage_buffers[stage], [&](u32 index) {
-        const StorageBufferBindingInfo& storage = channel_state->storage_buffers[stage][index];
+        const Binding& binding = channel_state->storage_buffers[stage][index];
+        Buffer& buffer = slot_buffers[binding.buffer_id];
+        TouchBuffer(buffer, binding.buffer_id);
+        const u32 size = binding.size;
+        SynchronizeBuffer(buffer, binding.device_addr, size);
+
+        const u32 offset = buffer.Offset(binding.device_addr);
+        buffer.MarkUsage(offset, size);
        const bool is_written = ((channel_state->written_storage_buffers[stage] >> index) & 1) != 0;
-        for (u32 segment = 0; segment < storage.descriptor_count; ++segment) {
-            Buffer* buffer = &slot_buffers[NULL_BUFFER_ID];
-            u32 offset{};
-            u32 size{IS_OPENGL ? 0U : static_cast<u32>(sizeof(u32))};
-            const bool is_actual_segment = segment < storage.segments.size();
-            // shall be safe enough if the segment is not actual, use the last available segment or nullptr if none exist.
-            const Binding* binding = is_actual_segment ? &storage.segments[segment] : storage.segments.empty() ? nullptr : &storage.segments.back();
-            if (binding) {
-                buffer = &slot_buffers[binding->buffer_id];
-                size = binding->size;
-                offset = buffer->Offset(binding->device_addr);
-                if (is_actual_segment) {
-                    TouchBuffer(*buffer, binding->buffer_id);
-                    SynchronizeBuffer(*buffer, binding->device_addr, size);
-                    buffer->MarkUsage(offset, size);
-                    if (is_written) {
-                        MarkWrittenBuffer(binding->buffer_id, binding->device_addr, size);
-                    }
-                }
-            }
-            if constexpr (NEEDS_BIND_STORAGE_INDEX) {
-                runtime.BindStorageBuffer(stage, binding_index++, *buffer, offset, size, is_written);
-            } else {
-                runtime.BindStorageBuffer(*buffer, offset, size, is_written);
-            }
+
+        if (is_written) {
+            MarkWrittenBuffer(binding.buffer_id, binding.device_addr, size);
+        }
+
+        if constexpr (NEEDS_BIND_STORAGE_INDEX) {
+            runtime.BindStorageBuffer(stage, binding_index, buffer, offset, size, is_written);
+            ++binding_index;
+        } else {
+            runtime.BindStorageBuffer(buffer, offset, size, is_written);
        }
    });
 }
@@ -1163,53 +1136,28 @@ void BufferCache<P>::BindHostComputeUniformBuffers() {

 template <class P>
 void BufferCache<P>::BindHostComputeStorageBuffers() {
-    boost::container::small_vector<u32, NUM_STORAGE_BUFFERS> segment_sizes;
-    bool uses_mapping{};
-    ForEachEnabledBit(channel_state->enabled_compute_storage_buffers, [&](u32 index) {
-        const StorageBufferBindingInfo& binding = channel_state->compute_storage_buffers[index];
-        uses_mapping |= binding.descriptor_count > 1;
-        for (u32 segment = 0; segment < binding.descriptor_count; ++segment) {
-            segment_sizes.push_back(segment < binding.segments.size() ? binding.segments[segment].size : 0);
-        }
-    });
-    if (uses_mapping) {
-        const u32 mapping_size = static_cast<u32>(segment_sizes.size() * sizeof(u32));
-        if constexpr (!IS_OPENGL) {
-            const std::span<u8> mapped = runtime.BindMappedStorageBuffer(mapping_size);
-            std::memcpy(mapped.data(), segment_sizes.data(), mapping_size);
-        }
-    }
-
    u32 binding_index = 0;
    ForEachEnabledBit(channel_state->enabled_compute_storage_buffers, [&](u32 index) {
-        const StorageBufferBindingInfo& storage = channel_state->compute_storage_buffers[index];
+        const Binding& binding = channel_state->compute_storage_buffers[index];
+        Buffer& buffer = slot_buffers[binding.buffer_id];
+        TouchBuffer(buffer, binding.buffer_id);
+        const u32 size = binding.size;
+        SynchronizeBuffer(buffer, binding.device_addr, size);
+
+        const u32 offset = buffer.Offset(binding.device_addr);
+        buffer.MarkUsage(offset, size);
        const bool is_written =
            ((channel_state->written_compute_storage_buffers >> index) & 1) != 0;
-        for (u32 segment = 0; segment < storage.descriptor_count; ++segment) {
-            Buffer* buffer = &slot_buffers[NULL_BUFFER_ID];
-            u32 offset{};
-            u32 size{IS_OPENGL ? 0U : static_cast<u32>(sizeof(u32))};
-            const bool is_actual_segment = segment < storage.segments.size();
-            //same fallback logic
-            const Binding* binding = is_actual_segment ? &storage.segments[segment] : storage.segments.empty() ? nullptr : &storage.segments.back();
-            if (binding) {
-                buffer = &slot_buffers[binding->buffer_id];
-                size = binding->size;
-                offset = buffer->Offset(binding->device_addr);
-                if (is_actual_segment) {
-                    TouchBuffer(*buffer, binding->buffer_id);
-                    SynchronizeBuffer(*buffer, binding->device_addr, size);
-                    buffer->MarkUsage(offset, size);
-                    if (is_written) {
-                        MarkWrittenBuffer(binding->buffer_id, binding->device_addr, size);
-                    }
-                }
-            }
-            if constexpr (NEEDS_BIND_STORAGE_INDEX) {
-                runtime.BindComputeStorageBuffer(binding_index++, *buffer, offset, size, is_written);
-            } else {
-                runtime.BindStorageBuffer(*buffer, offset, size, is_written);
-            }
+
+        if (is_written) {
+            MarkWrittenBuffer(binding.buffer_id, binding.device_addr, size);
+        }
+
+        if constexpr (NEEDS_BIND_STORAGE_INDEX) {
+            runtime.BindComputeStorageBuffer(binding_index, buffer, offset, size, is_written);
+            ++binding_index;
+        } else {
+            runtime.BindStorageBuffer(buffer, offset, size, is_written);
        }
    });
 }
@@ -1402,7 +1350,10 @@ void BufferCache<P>::UpdateUniformBuffers(size_t stage) {
 template <class P>
 void BufferCache<P>::UpdateStorageBuffers(size_t stage) {
    ForEachEnabledBit(channel_state->enabled_storage_buffers[stage], [&](u32 index) {
-        UpdateStorageBuffer(channel_state->storage_buffers[stage][index]);
+        // Resolve buffer
+        Binding& binding = channel_state->storage_buffers[stage][index];
+        const BufferId buffer_id = FindBuffer(binding.device_addr, binding.size);
+        binding.buffer_id = buffer_id;
    });
 }

@@ -1463,54 +1414,12 @@ void BufferCache<P>::UpdateComputeUniformBuffers() {
 template <class P>
 void BufferCache<P>::UpdateComputeStorageBuffers() {
    ForEachEnabledBit(channel_state->enabled_compute_storage_buffers, [&](u32 index) {
-        UpdateStorageBuffer(channel_state->compute_storage_buffers[index]);
+        // Resolve buffer
+        Binding& binding = channel_state->compute_storage_buffers[index];
+        binding.buffer_id = FindBuffer(binding.device_addr, binding.size);
    });
 }

-template <class P>
-void BufferCache<P>::UpdateStorageBuffer(StorageBufferBindingInfo& binding) {
-    binding.segments.clear();
-    if (binding.gpu_addr == 0 || binding.size == 0) { return;}
-    if (binding.descriptor_count == 1) {
-        // for safety gotta preserve the legacy path on possible hosts without storage-buffer descriptor indexing.
-        const std::optional<DAddr> device_addr = gpu_memory->GpuToCpuAddress(binding.gpu_addr);
-        if (device_addr) {
-            binding.segments.push_back(Binding{
-                .device_addr = *device_addr,
-                .size = binding.size,
-                .buffer_id = FindBuffer(*device_addr, binding.size),
-            });
-        }
-        return;
-    }
-
-    const auto ranges = gpu_memory->GetSubmappedRange(binding.gpu_addr, binding.size);
-    const size_t mapped_size =
-        std::accumulate(ranges.begin(), ranges.end(), size_t{}, [](size_t total, const auto& range) { return total + range.second; });
-    if (mapped_size != binding.size) {
-        LOG_ERROR(HW_GPU, "Storage buffer range {:#x}+{:#x} is not fully mapped", binding.gpu_addr, binding.size);
-        return;
-    }
-    if (ranges.size() > binding.descriptor_count) {
-        LOG_ERROR(HW_GPU, "Storage buffer range {:#x}+{:#x} has {} physical segments, exceeding host capacity {}",
-                  binding.gpu_addr, binding.size, ranges.size(), binding.descriptor_count);
-        return;
-    }
-    for (const auto& [gpu_addr, size] : ranges) {
-        const std::optional<DAddr> device_addr = gpu_memory->GpuToCpuAddress(gpu_addr);
-        if (!device_addr || size > (std::numeric_limits<u32>::max)()) {
-            binding.segments.clear();
-            return;
-        }
-        const u32 segment_size = static_cast<u32>(size);
-        binding.segments.push_back(Binding{
-            .device_addr = *device_addr,
-            .size = segment_size,
-            .buffer_id = FindBuffer(*device_addr, segment_size),
-        });
-    }
-}
-
 template <class P>
 void BufferCache<P>::UpdateComputeTextureBuffers() {
    ForEachEnabledBit(channel_state->enabled_compute_texture_buffers, [&](u32 index) {
@@ -1932,11 +1841,6 @@ void BufferCache<P>::DeleteBuffer(BufferId buffer_id, bool do_not_mark) {
    const auto replace = [scalar_replace](std::span<Binding> bindings) {
        std::ranges::for_each(bindings, scalar_replace);
    };
-    const auto storage_replace = [scalar_replace](std::span<StorageBufferBindingInfo> bindings) {
-        for (StorageBufferBindingInfo& binding : bindings) {
-            std::ranges::for_each(binding.segments, scalar_replace);
-        }
-    };

    if (channel_state->index_buffer.buffer_id == buffer_id) {
        channel_state->index_buffer.buffer_id = BufferId{};
@@ -1952,10 +1856,10 @@ void BufferCache<P>::DeleteBuffer(BufferId buffer_id, bool do_not_mark) {
        }
    }
    std::ranges::for_each(channel_state->uniform_buffers, replace);
-    std::ranges::for_each(channel_state->storage_buffers, storage_replace);
+    std::ranges::for_each(channel_state->storage_buffers, replace);
    replace(channel_state->transform_feedback_buffers);
    replace(channel_state->compute_uniform_buffers);
-    storage_replace(channel_state->compute_storage_buffers);
+    replace(channel_state->compute_storage_buffers);

    // Mark the whole buffer as CPU written to stop tracking CPU writes
    if (!do_not_mark) {
@@ -1992,14 +1896,12 @@ void BufferCache<P>::DeleteBuffer(BufferId buffer_id, bool do_not_mark) {
 }

 template <class P>
-StorageBufferBindingInfo BufferCache<P>::StorageBufferBinding(GPUVAddr ssbo_addr, u32 cbuf_index,
-                                                              bool is_written, u32 descriptor_count) const {
-    // time to get rid of these null bindings
-    ASSERT(descriptor_count > 0); // shant happen
+Binding BufferCache<P>::StorageBufferBinding(GPUVAddr ssbo_addr, u32 cbuf_index,
+                                             bool is_written) const {
    const GPUVAddr gpu_addr = gpu_memory->Read<u64>(ssbo_addr);

    if (gpu_addr == 0) {
-        return {.descriptor_count = descriptor_count};
+        return NULL_BINDING;
    }

    const auto size = [&]() {
@@ -2021,17 +1923,21 @@ StorageBufferBindingInfo BufferCache<P>::StorageBufferBinding(GPUVAddr ssbo_addr
    const GPUVAddr aligned_gpu_addr = Common::AlignDown(gpu_addr, alignment);
    const u32 aligned_size = static_cast<u32>(gpu_addr - aligned_gpu_addr) + size;

-    if (!gpu_memory->GpuToCpuAddress(aligned_gpu_addr) || size == 0) {
+    const std::optional<DAddr> aligned_device_addr = gpu_memory->GpuToCpuAddress(aligned_gpu_addr);
+    if (!aligned_device_addr || size == 0) {
        LOG_DEBUG(HW_GPU, "Failed to find storage buffer for cbuf index {}", cbuf_index);
-        return {.descriptor_count = descriptor_count};
+        return NULL_BINDING;
    }
+    const std::optional<DAddr> device_addr = gpu_memory->GpuToCpuAddress(gpu_addr);
+    ASSERT_MSG(device_addr, "Unaligned storage buffer address not found for cbuf index {}",
+               cbuf_index);
    // The end address used for size calculation does not need to be aligned
-    const GPUVAddr gpu_end = Common::AlignUp(gpu_addr + size, Core::DEVICE_PAGESIZE);
+    const DAddr cpu_end = Common::AlignUp(*device_addr + size, Core::DEVICE_PAGESIZE);

-    const StorageBufferBindingInfo binding{
-        .gpu_addr = aligned_gpu_addr,
-        .size = is_written ? aligned_size : static_cast<u32>(gpu_end - aligned_gpu_addr),
-        .descriptor_count = descriptor_count,
+    const Binding binding{
+        .device_addr = *aligned_device_addr,
+        .size = is_written ? aligned_size : static_cast<u32>(cpu_end - *aligned_device_addr),
+        .buffer_id = BufferId{},
    };
    return binding;
 }
@@ -89,15 +89,6 @@ struct TextureBufferBinding : Binding {
    PixelFormat format;
 };

-struct StorageBufferBindingInfo {
-    // another good one: guest SSBO is a virtual interval and may span discontiguous device-memory ranges.
-    // exact case of missing character frames (high sample lane)
-    GPUVAddr gpu_addr{};
-    u32 size{};
-    u32 descriptor_count{1};
-    boost::container::small_vector<Binding, 1> segments;
-};
-
 static constexpr Binding NULL_BINDING{
    .device_addr = 0,
    .size = 0,
@@ -124,15 +115,14 @@ public:
    Binding index_buffer;
    std::array<Binding, NUM_VERTEX_BUFFERS> vertex_buffers;
    std::array<std::array<Binding, NUM_GRAPHICS_UNIFORM_BUFFERS>, NUM_STAGES> uniform_buffers;
-    std::array<std::array<StorageBufferBindingInfo, NUM_STORAGE_BUFFERS>, NUM_STAGES>
-        storage_buffers;
+    std::array<std::array<Binding, NUM_STORAGE_BUFFERS>, NUM_STAGES> storage_buffers;
    std::array<std::array<TextureBufferBinding, NUM_TEXTURE_BUFFERS>, NUM_STAGES> texture_buffers;
    std::array<Binding, NUM_TRANSFORM_FEEDBACK_BUFFERS> transform_feedback_buffers;
    Binding count_buffer_binding;
    Binding indirect_buffer_binding;

    std::array<Binding, NUM_COMPUTE_UNIFORM_BUFFERS> compute_uniform_buffers;
-    std::array<StorageBufferBindingInfo, NUM_STORAGE_BUFFERS> compute_storage_buffers;
+    std::array<Binding, NUM_STORAGE_BUFFERS> compute_storage_buffers;
    std::array<TextureBufferBinding, NUM_TEXTURE_BUFFERS> compute_texture_buffers;

    std::array<u32, NUM_STAGES> enabled_uniform_buffer_masks{};
@@ -259,7 +249,7 @@ public:
    void UnbindGraphicsStorageBuffers(size_t stage);

    bool BindGraphicsStorageBuffer(size_t stage, size_t ssbo_index, u32 cbuf_index, u32 cbuf_offset,
-                                   bool is_written, u32 descriptor_count = 1);
+                                   bool is_written);

    void UnbindGraphicsTextureBuffers(size_t stage);

@@ -269,7 +259,7 @@ public:
    void UnbindComputeStorageBuffers();

    void BindComputeStorageBuffer(size_t ssbo_index, u32 cbuf_index, u32 cbuf_offset,
-                                  bool is_written, u32 descriptor_count = 1);
+                                  bool is_written);

    void UnbindComputeTextureBuffers();

@@ -410,8 +400,6 @@ private:

    void UpdateStorageBuffers(size_t stage);

-    void UpdateStorageBuffer(StorageBufferBindingInfo& binding);
-
    void UpdateTextureBuffers(size_t stage);

    void UpdateTransformFeedbackBuffers();
@@ -461,9 +449,8 @@ private:

    void DeleteBuffer(BufferId buffer_id, bool do_not_mark = false);

-    [[nodiscard]] StorageBufferBindingInfo StorageBufferBinding(GPUVAddr ssbo_addr, u32 cbuf_index,
-                                                                bool is_written,
-                                                                u32 descriptor_count) const;
+    [[nodiscard]] Binding StorageBufferBinding(GPUVAddr ssbo_addr, u32 cbuf_index,
+                                               bool is_written) const;

    [[nodiscard]] TextureBufferBinding GetTextureBufferBinding(GPUVAddr gpu_addr, u32 size,
                                                               PixelFormat format);
@@ -6,7 +6,6 @@

 #pragma once

-#include <array>
 #include <cstddef>
 #include <optional>

@@ -137,7 +136,6 @@ inline void WriteDescriptorBuffer(const Device& device, const DescriptorBufferLa

 [[nodiscard]] inline u32 NumDescriptorEntries(const Shader::Info& info) {
    return Shader::NumDescriptors(info.constant_buffer_descriptors) +
-           static_cast<u32>(Shader::UsesStorageBufferMappings(info)) +
           Shader::NumDescriptors(info.storage_buffers_descriptors) +
           Shader::NumDescriptors(info.texture_buffer_descriptors) +
           Shader::NumDescriptors(info.image_buffer_descriptors) +
@@ -270,12 +268,6 @@ public:
        is_compute |= (stage & VK_SHADER_STAGE_COMPUTE_BIT) != 0;

        Add(VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER, stage, info.constant_buffer_descriptors);
-        // for extra implicit storage-buffer binding required by mapped-storage-buffer support
-        if (Shader::UsesStorageBufferMappings(info)) {
-            struct Descriptor { u32 count; };
-            const std::array descriptors{Descriptor{1}};
-            Add(VK_DESCRIPTOR_TYPE_STORAGE_BUFFER, stage, descriptors);
-        }
        Add(VK_DESCRIPTOR_TYPE_STORAGE_BUFFER, stage, info.storage_buffers_descriptors);
        Add(VK_DESCRIPTOR_TYPE_UNIFORM_TEXEL_BUFFER, stage, info.texture_buffer_descriptors);
        Add(VK_DESCRIPTOR_TYPE_STORAGE_TEXEL_BUFFER, stage, info.image_buffer_descriptors);
@@ -695,7 +695,7 @@ vk::Buffer BufferCacheRuntime::CreateNullBuffer() {
        .flags = 0,
        .size = 4,
        .usage = VK_BUFFER_USAGE_VERTEX_BUFFER_BIT | VK_BUFFER_USAGE_INDEX_BUFFER_BIT |
-                 VK_BUFFER_USAGE_TRANSFER_DST_BIT | VK_BUFFER_USAGE_INDIRECT_BUFFER_BIT | VK_BUFFER_USAGE_STORAGE_BUFFER_BIT,
+                 VK_BUFFER_USAGE_TRANSFER_DST_BIT | VK_BUFFER_USAGE_INDIRECT_BUFFER_BIT,
        .sharingMode = VK_SHARING_MODE_EXCLUSIVE,
        .queueFamilyIndexCount = 0,
        .pQueueFamilyIndices = nullptr,
@@ -155,13 +155,6 @@ public:
        return ref.mapped_span;
    }

-    // compute/graphics new binding
-    std::span<u8> BindMappedStorageBuffer(u32 size) {
-        const StagingBufferRef ref = staging_pool.Request(size, MemoryUsage::Upload);
-        guest_descriptor_queue.AddBuffer(ref.buffer, ref.device_address, static_cast<u32>(ref.offset), size);
-        return ref.mapped_span;
-    }
-
    void BindUniformBuffer(const Buffer& buffer, u32 offset, u32 size) {
        BindBuffer(buffer, offset, size);
    }
@@ -157,7 +157,9 @@ bool ComputePipeline::Configure(Tegra::Engines::KeplerCompute& kepler_compute,
    buffer_cache.UnbindComputeStorageBuffers();
    size_t ssbo_index{};
    for (const auto& desc : info.storage_buffers_descriptors) {
-        buffer_cache.BindComputeStorageBuffer(ssbo_index, desc.cbuf_index, desc.cbuf_offset, desc.is_written, desc.count);
+        ASSERT(desc.count == 1);
+        buffer_cache.BindComputeStorageBuffer(ssbo_index, desc.cbuf_index, desc.cbuf_offset,
+                                              desc.is_written);
        ++ssbo_index;
    }

@@ -47,7 +47,7 @@ static DescriptorBankInfo MakeBankInfo(std::span<const Shader::Info> infos) {
    DescriptorBankInfo bank;
    for (const Shader::Info& info : infos) {
        bank.uniform_buffers += Accumulate(info.constant_buffer_descriptors);
-        bank.storage_buffers += Accumulate(info.storage_buffers_descriptors) + static_cast<u32>(Shader::UsesStorageBufferMappings(info));
+        bank.storage_buffers += Accumulate(info.storage_buffers_descriptors);
        bank.texture_buffers += Accumulate(info.texture_buffer_descriptors);
        bank.image_buffers += Accumulate(info.image_buffer_descriptors);
        bank.textures += Accumulate(info.texture_descriptors);
@@ -367,8 +367,9 @@ bool GraphicsPipeline::ConfigureImpl(bool is_indexed) {
        if constexpr (Spec::has_storage_buffers) {
            size_t ssbo_index{};
            for (const auto& desc : info.storage_buffers_descriptors) {
+                ASSERT(desc.count == 1);
                buffer_cache.BindGraphicsStorageBuffer(stage, ssbo_index, desc.cbuf_index,
-                                                       desc.cbuf_offset, desc.is_written, desc.count);
+                                                       desc.cbuf_offset, desc.is_written);
                ++ssbo_index;
            }
        }
@@ -62,12 +62,7 @@ using VideoCommon::FileEnvironment;
 using VideoCommon::GenericEnvironment;
 using VideoCommon::GraphicsEnvironment;

-// SPIR-V descriptor arrays require a fixed pipeline-layout count.
-// Exploration ceiling; buffer-cache telemetry records the actual physical-range demand.
-// Keep this modest because every mapped SSBO binds the full fixed array on each update.
-constexpr u32 MAX_MAPPED_STORAGE_BUFFER_DESCRIPTORS = 32;
-
-constexpr u32 CACHE_VERSION = 19;
+constexpr u32 CACHE_VERSION = 18;
 constexpr size_t VULKAN_CACHE_FLUSH_PIPELINES = 128;
 constexpr size_t VULKAN_CACHE_FLUSH_MIN_SECONDS = 30;
 constexpr std::array<char, 8> VULKAN_CACHE_MAGIC_NUMBER{'y', 'u', 'z', 'u', 'v', 'k', 'c', 'h'};
@@ -437,8 +432,6 @@ PipelineCache::PipelineCache(Tegra::MaxwellDeviceMemoryManager& device_memory_,
            device.IsUniformTexelBufferArrayNonUniformIndexingSupported(),
        .support_storage_texel_buffer_array_nonuniform_indexing =
            device.IsStorageTexelBufferArrayNonUniformIndexingSupported(),
-        .support_storage_buffer_array_nonuniform_indexing =
-            device.IsStorageBufferArrayNonUniformIndexingSupported(),

        .warp_size_potentially_larger_than_guest = device.IsWarpSizePotentiallyBiggerThanGuest(),

@@ -467,7 +460,6 @@ PipelineCache::PipelineCache(Tegra::MaxwellDeviceMemoryManager& device_memory_,
    host_info = Shader::HostTranslateInfo{
        .min_ssbo_alignment = device.GetStorageBufferAlignment(),
        .max_per_stage_descriptor_sampled_images = device.GetMaxPerStageDescriptorSampledImages(),
-        .max_per_stage_descriptor_storage_buffers = device.GetMaxPerStageDescriptorStorageBuffers(),
        .max_per_stage_resources = device.GetMaxPerStageResources(),
        .max_descriptor_set_samplers = device.GetMaxDescriptorSetSamplers(),
        .max_descriptor_set_uniform_buffers = device.GetMaxDescriptorSetUniformBuffers(),
@@ -487,20 +479,6 @@ PipelineCache::PipelineCache(Tegra::MaxwellDeviceMemoryManager& device_memory_,
        .support_viewport_index_layer = device.IsExtShaderViewportIndexLayerSupported(),
        .support_geometry_shader_passthrough = device.IsNvGeometryShaderPassthroughSupported(),
        .support_conditional_barrier = device.SupportsConditionalBarriers(),
-        .storage_buffer_segment_count = [&] {
-            if (!device.IsStorageBufferArrayNonUniformIndexingSupported()) {
-                return 1U;
-            }
-            constexpr u32 MaxGraphicsStages = static_cast<u32>(Maxwell::MaxShaderStage);
-            const auto reserve = [](u32 limit, u32 count) {
-                return limit > count ? limit - count : 0U;
-            };
-            const u32 per_stage = reserve(device.GetMaxPerStageDescriptorStorageBuffers(), 1) / static_cast<u32>(Shader::Info::MAX_SSBOS);
-            const u32 per_set = reserve(device.GetMaxDescriptorSetStorageBuffers(), MaxGraphicsStages) / (static_cast<u32>(Shader::Info::MAX_SSBOS) * MaxGraphicsStages);
-            const u32 resources = reserve(device.GetMaxPerStageResources(), 1) / (static_cast<u32>(Shader::Info::MAX_SSBOS) * 2);
-            // ensure at least one storage buffer segment is available per stage. max is still arbitrary
-            return (std::max)(1U, (std::min)({MAX_MAPPED_STORAGE_BUFFER_DESCRIPTORS, per_stage, per_set, resources}));
-        }(),
    };
    host_info.ApplyDescriptorLimitPolicy();

@@ -708,6 +708,7 @@ Device::Device(VkInstance instance_, vk::PhysicalDevice physical_, VkSurfaceKHR
        descriptor_indexing.shaderUniformTexelBufferArrayDynamicIndexing = false;
        descriptor_indexing.shaderStorageTexelBufferArrayDynamicIndexing = false;
        descriptor_indexing.shaderUniformBufferArrayNonUniformIndexing = false;
+        descriptor_indexing.shaderStorageBufferArrayNonUniformIndexing = false;
        descriptor_indexing.shaderInputAttachmentArrayNonUniformIndexing = false;
        descriptor_indexing.descriptorBindingUniformBufferUpdateAfterBind = false;
        descriptor_indexing.descriptorBindingSampledImageUpdateAfterBind = false;
@@ -360,7 +360,6 @@ public:
 #define FN_MAX_LIMIT_LIST \
    FN_MAX_LIMIT_ELEM(ComputeSharedMemorySize) \
    FN_MAX_LIMIT_ELEM(PerStageDescriptorSampledImages) \
-    FN_MAX_LIMIT_ELEM(PerStageDescriptorStorageBuffers) \
    FN_MAX_LIMIT_ELEM(PerStageResources) \
    FN_MAX_LIMIT_ELEM(DescriptorSetSamplers) \
    FN_MAX_LIMIT_ELEM(DescriptorSetUniformBuffers) \
@@ -416,10 +415,6 @@ FN_MAX_LIMIT_LIST
        return features.descriptor_indexing.shaderStorageTexelBufferArrayNonUniformIndexing;
    }

-    bool IsStorageBufferArrayNonUniformIndexingSupported() const {
-        return features.descriptor_indexing.shaderStorageBufferArrayNonUniformIndexing;
-    }
-
    /// Returns true if the device supports float64 natively.
    bool IsFloat64Supported() const {
        return features.features.shaderFloat64;
Author	SHA1	Message	Date
lizzie	b3eb7e47fd	s^2	2026-09-02 21:22:23 +00:00
lizzie	6a7c069824	fix linking issues	2026-09-02 11:37:51 +00:00
lizzie	86df49bbc9	remove latency func	2026-09-02 10:58:33 +00:00
lizzie	4e59b71c59	[audio] Nuke cubeb and use SDL3 exclusively Signed-off-by: lizzie <lizzie@eden-emu.dev>	2026-09-02 10:55:54 +00:00