2026-09-07 23:30:42

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

src/audio_core/common/workbuffer_allocator.h

@@ -1,6 +1,3 @@
-// SPDX-FileCopyrightText: Copyright 2026 Eden Emulator Project
-// SPDX-License-Identifier: GPL-3.0-or-later
-
 // SPDX-FileCopyrightText: Copyright 2022 yuzu Emulator Project
 // SPDX-License-Identifier: GPL-2.0-or-later
 
@@ -19,9 +16,8 @@ namespace AudioCore {
  */
 class WorkbufferAllocator {
 public:
-    explicit WorkbufferAllocator(std::span<u8> buffer_)
-        : buffer{buffer_}
-    {}
+    explicit WorkbufferAllocator(std::span<u8> buffer_, u64 size_)
+        : buffer{reinterpret_cast<u64>(buffer_.data())}, size{size_} {}
 
     /**
      * Allocate the given count of T elements, aligned to alignment.
@@ -33,31 +29,36 @@ public:
     template <typename T>
     std::span<T> Allocate(u64 count, u64 alignment) {
         u64 out{0};
-        u64 byte_size = count * sizeof(T);
+        u64 byte_size{count * sizeof(T)};
+
         if (byte_size > 0) {
-            auto current{uintptr_t(buffer.data()) + offset};
+            auto current{buffer + offset};
             auto aligned_buffer{Common::AlignUp(current, alignment)};
-            if (aligned_buffer + byte_size <= uintptr_t(buffer.data()) + buffer.size()) {
+            if (aligned_buffer + byte_size <= buffer + size) {
                 out = aligned_buffer;
-                offset = byte_size - uintptr_t(buffer.data()) + aligned_buffer;
+                offset = byte_size - buffer + aligned_buffer;
             } else {
                 LOG_ERROR(
                     Service_Audio,
                     "Allocated buffer was too small to hold new alloc.\nAllocator size={:08X}, "
                     "offset={:08X}.\nAttempting to allocate {:08X} with alignment={:02X}",
-                    buffer.size(), offset, byte_size, alignment);
+                    size, offset, byte_size, alignment);
                 count = 0;
             }
         }
+
         return std::span<T>(reinterpret_cast<T*>(out), count);
     }
 
-    /// @brief Align the current offset to the given alignment.
-    /// @param alignment - The required starting alignment.
+    /**
+     * Align the current offset to the given alignment.
+     *
+     * @param alignment - The required starting alignment.
+     */
     void Align(u64 alignment) {
-        auto current{uintptr_t(buffer.data()) + offset};
+        auto current{buffer + offset};
         auto aligned_buffer{Common::AlignUp(current, alignment)};
-        offset = 0 - uintptr_t(buffer.data()) + aligned_buffer;
+        offset = 0 - buffer + aligned_buffer;
     }
 
     /**
@@ -75,7 +76,7 @@ public:
      * @return The size of the current buffer.
      */
     u64 GetSize() const {
-        return buffer.size();
+        return size;
     }
 
     /**
@@ -84,11 +85,14 @@ public:
      * @return The remaining size left in the buffer.
      */
     u64 GetRemainingSize() const {
-        return buffer.size() - offset;
+        return size - offset;
     }
 
 private:
-    const std::span<u8> buffer;
+    /// The buffer into which we are allocating.
+    u64 buffer;
+    /// Size of the buffer we're allocating to.
+    u64 size;
     /// Current offset into the buffer, an error will be thrown if it exceeds size.
     u64 offset{};
 };