2026-09-15 07:59:31

Signed-off-by: lizzie <lizzie@eden-emu.dev>

src/common/CMakeLists.txt

@@ -115,8 +115,6 @@ add_library(
     stb.h
     steady_clock.cpp
     steady_clock.h
-    stream.cpp
-    stream.h
     string_util.cpp
     string_util.h
     swap.h

src/common/stream.cpp

@@ -1,46 +0,0 @@
-// SPDX-FileCopyrightText: Copyright 2020 yuzu Emulator Project
-// SPDX-License-Identifier: GPL-2.0-or-later
-
-#include <stdexcept>
-#include "common/common_types.h"
-#include "common/stream.h"
-
-namespace Common {
-
-Stream::Stream() = default;
-Stream::~Stream() = default;
-
-void Stream::Seek(s32 offset, SeekOrigin origin) {
-    if (origin == SeekOrigin::SetOrigin) {
-        if (offset < 0) {
-            position = 0;
-        } else if (position >= buffer.size()) {
-            position = buffer.size();
-        } else {
-            position = offset;
-        }
-    } else if (origin == SeekOrigin::FromCurrentPos) {
-        Seek(static_cast<s32>(position) + offset, SeekOrigin::SetOrigin);
-    } else if (origin == SeekOrigin::FromEnd) {
-        Seek(static_cast<s32>(buffer.size()) - offset, SeekOrigin::SetOrigin);
-    }
-}
-
-u8 Stream::ReadByte() {
-    if (position < buffer.size()) {
-        return buffer[position++];
-    } else {
-        throw std::out_of_range("Attempting to read a byte not within the buffer range");
-    }
-}
-
-void Stream::WriteByte(u8 byte) {
-    if (position == buffer.size()) {
-        buffer.push_back(byte);
-        position++;
-    } else {
-        buffer.insert(buffer.begin() + position, byte);
-    }
-}
-
-} // namespace Common

src/common/stream.h

@@ -1,55 +0,0 @@
-// SPDX-FileCopyrightText: Copyright 2020 yuzu Emulator Project
-// SPDX-License-Identifier: GPL-2.0-or-later
-
-#pragma once
-
-#include <vector>
-#include "common/common_types.h"
-
-namespace Common {
-
-enum class SeekOrigin {
-    SetOrigin,
-    FromCurrentPos,
-    FromEnd,
-};
-
-class Stream {
-public:
-    /// Stream creates a bitstream and provides common functionality on the stream.
-    explicit Stream();
-    ~Stream();
-
-    Stream(const Stream&) = delete;
-    Stream& operator=(const Stream&) = delete;
-
-    Stream(Stream&&) = default;
-    Stream& operator=(Stream&&) = default;
-
-    /// Reposition bitstream "cursor" to the specified offset from origin
-    void Seek(s32 offset, SeekOrigin origin);
-
-    /// Reads next byte in the stream buffer and increments position
-    u8 ReadByte();
-
-    /// Writes byte at current position
-    void WriteByte(u8 byte);
-
-    [[nodiscard]] std::size_t GetPosition() const {
-        return position;
-    }
-
-    [[nodiscard]] std::vector<u8>& GetBuffer() {
-        return buffer;
-    }
-
-    [[nodiscard]] const std::vector<u8>& GetBuffer() const {
-        return buffer;
-    }
-
-private:
-    std::vector<u8> buffer;
-    std::size_t position{0};
-};
-
-} // namespace Common

src/core/frontend/applets/controller.cpp

@@ -12,7 +12,6 @@
 #include "hid_core/frontend/emulated_controller.h"
 #include "hid_core/hid_core.h"
 #include "hid_core/hid_types.h"
-#include <array>
 
 namespace Core::Frontend {
 
@@ -30,39 +29,23 @@ void DefaultControllerApplet::ReconfigureControllers(ReconfigureCallback callbac
 
     const std::size_t min_supported_players =
         parameters.enable_single_mode ? 1 : parameters.min_players;
-    using Core::HID::NpadStyleIndex;
-    const std::size_t max_supported_players = parameters.enable_single_mode ? 1 : parameters.max_players;
-    std::size_t num_selected_players = 0;
-    std::array<bool, HID::HIDCore::available_controllers> keep_connected{};
 
-    // reserve existing AND valid players before filling slots. include Handheld, but not other
-    for (std::size_t index = 0; index < hid_core.available_controllers - 1; ++index) {
-        const auto* controller = hid_core.GetEmulatedControllerByIndex(index);
-        if (!parameters.keep_controllers_connected || !controller->IsConnected() || num_selected_players >= max_supported_players) continue;
-
-        const auto style = controller->GetNpadStyleIndex();
-        keep_connected[index] =
-            (style == NpadStyleIndex::Fullkey && parameters.allow_pro_controller) ||
-            (style == NpadStyleIndex::JoyconDual && parameters.allow_dual_joycons) ||
-            (style == NpadStyleIndex::JoyconLeft && parameters.allow_left_joycon) ||
-            (style == NpadStyleIndex::JoyconRight && parameters.allow_right_joycon) ||
-            (style == NpadStyleIndex::Handheld && parameters.enable_single_mode && parameters.allow_handheld && !Settings::IsDockedMode()) ||
-            (style == NpadStyleIndex::GameCube && parameters.allow_gamecube_controller);
-        num_selected_players += keep_connected[index];
-    }
+    // Disconnect Handheld first.
     auto* handheld = hid_core.GetEmulatedController(Core::HID::NpadIdType::Handheld);
-    if (!keep_connected[hid_core.available_controllers - 2]) handheld->Disconnect();
+    handheld->Disconnect();
 
     // Deduce the best configuration based on the input parameters.
     for (std::size_t index = 0; index < hid_core.available_controllers - 2; ++index) {
         auto* controller = hid_core.GetEmulatedControllerByIndex(index);
 
-        if (keep_connected[index]) continue;
+        // First, disconnect all controllers regardless of the value of keep_controllers_connected.
+        // This makes it easy to connect the desired controllers.
         controller->Disconnect();
 
-        // only add players still needed to reach the minimum
-        if (num_selected_players >= min_supported_players) continue;
-        ++num_selected_players;
+        // Only connect the minimum number of required players.
+        if (index >= min_supported_players) {
+            continue;
+        }
 
         // Connect controllers based on the following priority list from highest to lowest priority:
         // Pro Controller -> Dual Joycons -> Left Joycon/Right Joycon -> Handheld

src/video_core/host1x/codecs/vp9.cpp

@@ -895,17 +895,16 @@ void VpxRangeEncoder::Write(bool bit, s32 probability) {
         const s32 offset = shift - count;
 
         if (((low_value << (offset - 1)) >> 31) != 0) {
-            const s32 current_pos = static_cast<s32>(base_stream.GetPosition());
-            base_stream.Seek(-1, Common::SeekOrigin::FromCurrentPos);
-            while (PeekByte() == 0xff) {
-                base_stream.WriteByte(0);
-
-                base_stream.Seek(-2, Common::SeekOrigin::FromCurrentPos);
+            auto const current_pos = s32(stream_pos);
+            --stream_pos;
+            while (stream_data[stream_pos] == 0xff) {
+                stream_data[stream_pos++] = 0;
+                stream_pos -= 2;
             }
-            base_stream.WriteByte(static_cast<u8>((PeekByte() + 1)));
-            base_stream.Seek(current_pos, Common::SeekOrigin::SetOrigin);
+            stream_data[stream_pos]++;
+            stream_pos = current_pos;
         }
-        base_stream.WriteByte(static_cast<u8>((low_value >> (24 - offset))));
+        stream_data[stream_pos++] = u8((low_value >> (24 - offset)));
 
         low_value <<= offset;
         shift = count;
@@ -923,13 +922,6 @@ void VpxRangeEncoder::End() {
     }
 }
 
-u8 VpxRangeEncoder::PeekByte() {
-    const u8 value = base_stream.ReadByte();
-    base_stream.Seek(-1, Common::SeekOrigin::FromCurrentPos);
-
-    return value;
-}
-
 VpxBitStreamWriter::VpxBitStreamWriter() = default;
 
 VpxBitStreamWriter::~VpxBitStreamWriter() = default;

src/video_core/host1x/codecs/vp9.h

@@ -12,7 +12,6 @@
 
 #include "common/common_types.h"
 #include "common/scratch_buffer.h"
-#include "common/stream.h"
 #include "video_core/host1x/codecs/decoder.h"
 #include "video_core/host1x/codec_types.h"
 #include "video_core/host1x/nvdec_common.h"
@@ -52,16 +51,19 @@ public:
     void End();
 
     [[nodiscard]] std::vector<u8>& GetBuffer() {
-        return base_stream.GetBuffer();
+        return stream_data;
     }
 
     [[nodiscard]] const std::vector<u8>& GetBuffer() const {
-        return base_stream.GetBuffer();
+        return stream_data;
     }
 
 private:
     u8 PeekByte();
-    Common::Stream base_stream{};
+
+    std::vector<u8> stream_data{};
+    size_t stream_pos;
+
     u32 low_value{};
     u32 range{0xff};
     s32 count{-24};

src/video_core/renderer_vulkan/vk_texture_cache.cpp

@@ -2850,6 +2850,8 @@ Sampler::VariantKey Sampler::MakeKey(const ImageView& image_view, bool is_depth)
     VariantKey key{};
     key.reduce_anisotropy = has_added_anisotropy && !image_view.SupportsAnisotropy();
     key.force_nearest = has_linear_filtering && IsPixelFormatInteger(image_view.format);
+    key.drop_depth_comparison =
+        is_depth && has_depth_comparison && !image_view.SupportsDepthComparison();
     key.drop_reduction = has_minmax_reduction && !image_view.SupportsMinmaxFilter();
     key.drop_custom_border = has_custom_border_colors && image_view.RequiresBorderColorFormat();
     key.srgb_border = has_srgb_border_color && IsPixelFormatSRGB(image_view.format);
@@ -2927,6 +2929,9 @@ VkSampler Sampler::Emplace(VariantKey key) {
         create_info.anisotropyEnable = static_cast<VkBool32>(default_anisotropy > 1.0f);
         create_info.maxAnisotropy = default_anisotropy;
     }
+    if (key.drop_depth_comparison) {
+        create_info.compareEnable = VK_FALSE;
+    }
     if (!custom_border) {
         create_info.borderColor = ConvertBorderColor(color);
     }

src/video_core/renderer_vulkan/vk_texture_cache.h

@@ -536,6 +536,7 @@ private:
     struct VariantKey {
         bool reduce_anisotropy;
         bool force_nearest;
+        bool drop_depth_comparison;
         bool drop_reduction;
         bool drop_custom_border;
         bool srgb_border;