2026-09-15 07:28:16

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

src/common/CMakeLists.txt

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

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

@@ -0,0 +1,55 @@
+// 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/video_core/host1x/codecs/vp9.cpp

@@ -895,16 +895,17 @@ void VpxRangeEncoder::Write(bool bit, s32 probability) {
         const s32 offset = shift - count;
 
         if (((low_value << (offset - 1)) >> 31) != 0) {
-            auto const current_pos = s32(stream_pos);
-            --stream_pos;
-            while (stream_data[stream_pos] == 0xff) {
-                stream_data[stream_pos++] = 0;
-                stream_pos -= 2;
+            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);
             }
-            stream_data[stream_pos]++;
-            stream_pos = current_pos;
+            base_stream.WriteByte(static_cast<u8>((PeekByte() + 1)));
+            base_stream.Seek(current_pos, Common::SeekOrigin::SetOrigin);
         }
-        stream_data[stream_pos++] = u8((low_value >> (24 - offset)));
+        base_stream.WriteByte(static_cast<u8>((low_value >> (24 - offset))));
 
         low_value <<= offset;
         shift = count;
@@ -922,6 +923,13 @@ 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,6 +12,7 @@
 
 #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"
@@ -51,19 +52,16 @@ public:
     void End();
 
     [[nodiscard]] std::vector<u8>& GetBuffer() {
-        return stream_data;
+        return base_stream.GetBuffer();
     }
 
     [[nodiscard]] const std::vector<u8>& GetBuffer() const {
-        return stream_data;
+        return base_stream.GetBuffer();
     }
 
 private:
     u8 PeekByte();
-
-    std::vector<u8> stream_data{};
-    size_t stream_pos;
-
+    Common::Stream base_stream{};
     u32 low_value{};
     u32 range{0xff};
     s32 count{-24};

src/yuzu/CMakeLists.txt

@@ -444,6 +444,10 @@ if (YUZU_ROOM)
     target_link_libraries(yuzu PRIVATE yuzu-room)
 endif()
 
+if (LINKER STREQUAL "lld")
+    target_link_options(yuzu-cmd PRIVATE "LINKER:--icf=all")
+endif()
+
 if (NOT MSVC AND (APPLE OR NOT YUZU_STATIC_BUILD))
     # needed for vma
     target_compile_options(yuzu PRIVATE

src/yuzu_cmd/CMakeLists.txt

@@ -67,6 +67,10 @@ endif()
 
 create_target_directory_groups(yuzu-cmd)
 
+if (LINKER STREQUAL "lld")
+    target_link_options(yuzu-cmd PRIVATE "LINKER:--icf=all")
+endif()
+
 # needed for vma
 if (NOT MSVC)
     target_compile_options(yuzu-cmd PRIVATE