license

externals/bc_decoder/bc_decoder.h

@@ -1,43 +1,23 @@
 // SPDX-License-Identifier: MPL-2.0
-// Copyright © 2022 Skyline Team and Contributors (https://github.com/skyline-emu/)
+// Copyright 2022 Skyline Team and Contributors (https://github.com/skyline-emu/)
 
 #pragma once
 
 #include <cstdint>
 
 namespace bcn {
-    /**
-     * @brief Decodes a BC1 encoded image to R8G8B8A8
-     */
-    void DecodeBc1(const uint8_t *src, uint8_t *dst, size_t x, size_t y, size_t width, size_t height);
-
-    /**
-     * @brief Decodes a BC2 encoded image to R8G8B8A8
-     */
-    void DecodeBc2(const uint8_t *src, uint8_t *dst, size_t x, size_t y, size_t width, size_t height);
-
-    /**
-     * @brief Decodes a BC3 encoded image to R8G8B8A8
-     */
-    void DecodeBc3(const uint8_t *src, uint8_t *dst, size_t x, size_t y, size_t width, size_t height);
-
-    /**
-     * @brief Decodes a BC4 encoded image to R8
-     */
+    /// @brief Decodes a BC1 encoded image to R8G8B8A8
+    void DecodeBc1(const uint8_t *src, uint8_t *dst, size_t x, size_t y, size_t width, size_t height, bool isSigned);
+    /// @brief Decodes a BC2 encoded image to R8G8B8A8
+    void DecodeBc2(const uint8_t *src, uint8_t *dst, size_t x, size_t y, size_t width, size_t height, bool isSigned);
+    //// @brief Decodes a BC3 encoded image to R8G8B8A8
+    void DecodeBc3(const uint8_t *src, uint8_t *dst, size_t x, size_t y, size_t width, size_t height, bool isSigned);
+    /// @brief Decodes a BC4 encoded image to R8
     void DecodeBc4(const uint8_t *src, uint8_t *dst, size_t x, size_t y, size_t width, size_t height, bool isSigned);
-
-    /**
-     * @brief Decodes a BC5 encoded image to R8G8
-     */
+    //// @brief Decodes a BC5 encoded image to R8G8
     void DecodeBc5(const uint8_t *src, uint8_t *dst, size_t x, size_t y, size_t width, size_t height, bool isSigned);
-
-    /**
-     * @brief Decodes a BC6 encoded image to R16G16B16A16
-     */
+    //// @brief Decodes a BC6 encoded image to R16G16B16A16
     void DecodeBc6(const uint8_t *src, uint8_t *dst, size_t x, size_t y, size_t width, size_t height, bool isSigned);
-
-    /**
-     * @brief Decodes a BC7 encoded image to R8G8B8A8
-     */
-    void DecodeBc7(const uint8_t *src, uint8_t *dst, size_t x, size_t y, size_t width, size_t height);
+    /// @brief Decodes a BC7 encoded image to R8G8B8A8
+    void DecodeBc7(const uint8_t *src, uint8_t *dst, size_t x, size_t y, size_t width, size_t height, bool isSigned);
 }

src/core/core.cpp

@@ -4,7 +4,6 @@
 #include <array>
 #include <atomic>
 #include <memory>
-#include <unordered_map>
 #include <utility>
 
 #include "game_settings.h"
@@ -249,30 +248,12 @@ struct System::Impl {
         }
     }
 
-    void NotifyNVDECChannelOpen(u64 process_id) {
-        std::scoped_lock lock{nvdec_active_mutex};
-        ++nvdec_active_channels[process_id];
-    }
-
-    void NotifyNVDECChannelClose(u64 process_id) {
-        std::scoped_lock lock{nvdec_active_mutex};
-        const auto it = nvdec_active_channels.find(process_id);
-        if (it == nvdec_active_channels.end()) {
-            return;
-        }
-        if (--it->second == 0) {
-            nvdec_active_channels.erase(it);
-        }
+    void SetNVDECActive(bool is_nvdec_active) {
+        nvdec_active = is_nvdec_active;
     }
 
     bool GetNVDECActive() {
-        std::scoped_lock lock{nvdec_active_mutex};
-        return !nvdec_active_channels.empty();
-    }
-
-    bool IsNVDECActiveForProcess(u64 process_id) {
-        std::scoped_lock lock{nvdec_active_mutex};
-        return nvdec_active_channels.contains(process_id);
+        return nvdec_active;
     }
 
     void InitializeDebugger(System& system, u16 port) {
@@ -524,8 +505,6 @@ struct System::Impl {
 
     mutable std::mutex suspend_guard;
     std::mutex general_channel_mutex;
-    std::mutex nvdec_active_mutex;
-    std::unordered_map<u64, u32> nvdec_active_channels;
     std::atomic_bool is_paused{};
     std::atomic_bool is_shutting_down{};
     std::atomic_bool is_powered_on{};
@@ -533,6 +512,7 @@ struct System::Impl {
     bool extended_memory_layout : 1 = false;
     bool exit_locked : 1 = false;
     bool exit_requested : 1 = false;
+    bool nvdec_active : 1 = false;
 
     void EnsureGeneralChannelInitialized(System& system) {
         if (!general_channel_event) {
@@ -596,22 +576,14 @@ void System::UnstallApplication() {
     impl->UnstallApplication();
 }
 
-void System::NotifyNVDECChannelOpen(u64 process_id) {
-    impl->NotifyNVDECChannelOpen(process_id);
-}
-
-void System::NotifyNVDECChannelClose(u64 process_id) {
-    impl->NotifyNVDECChannelClose(process_id);
+void System::SetNVDECActive(bool is_nvdec_active) {
+    impl->SetNVDECActive(is_nvdec_active);
 }
 
 bool System::GetNVDECActive() {
     return impl->GetNVDECActive();
 }
 
-bool System::IsNVDECActiveForProcess(u64 process_id) {
-    return impl->IsNVDECActiveForProcess(process_id);
-}
-
 void System::InitializeDebugger() {
     impl->InitializeDebugger(*this, Settings::values.gdbstub_port.GetValue());
 }

src/core/core.h

@@ -191,10 +191,8 @@ public:
     std::unique_lock<std::mutex> StallApplication();
     void UnstallApplication();
 
-    void NotifyNVDECChannelOpen(u64 process_id);
-    void NotifyNVDECChannelClose(u64 process_id);
+    void SetNVDECActive(bool is_nvdec_active);
     [[nodiscard]] bool GetNVDECActive();
-    [[nodiscard]] bool IsNVDECActiveForProcess(u64 process_id);
 
     /**
      * Initialize the debugger.

src/core/hle/kernel/k_server_session.cpp

@@ -1216,7 +1216,7 @@ Result KServerSession::ReceiveRequest(KernelCore& kernel, uintptr_t server_messa
 }
 
 Result KServerSession::SendReply(KernelCore& kernel, uintptr_t server_message, uintptr_t server_buffer_size,
-                                 KPhysicalAddress server_message_paddr, bool is_hle, bool session_closed) {
+                                 KPhysicalAddress server_message_paddr, bool is_hle) {
     // Lock the session.
     KScopedLightLock lk{m_lock};
 
@@ -1248,7 +1248,7 @@ Result KServerSession::SendReply(KernelCore& kernel, uintptr_t server_message, u
     KEvent* event = request->GetEvent();
 
     // Check whether we're closed.
-    const bool closed = (client_thread == nullptr || m_parent->IsClientClosed() || session_closed);
+    const bool closed = (client_thread == nullptr || m_parent->IsClientClosed());
 
     Result result = ResultSuccess;
     if (!closed) {

src/core/hle/kernel/k_server_session.h

@@ -54,14 +54,14 @@ public:
 
     Result OnRequest(KernelCore& kernel, KSessionRequest* request);
     Result SendReply(KernelCore& kernel, uintptr_t server_message, uintptr_t server_buffer_size,
-                     KPhysicalAddress server_message_paddr, bool is_hle = false, bool session_closed = false);
+                     KPhysicalAddress server_message_paddr, bool is_hle = false);
     Result ReceiveRequest(KernelCore& kernel, uintptr_t server_message, uintptr_t server_buffer_size,
                           KPhysicalAddress server_message_paddr,
                           std::shared_ptr<Service::HLERequestContext>* out_context = nullptr,
                           std::weak_ptr<Service::SessionRequestManager> manager = {});
 
-    Result SendReplyHLE(KernelCore& kernel, bool session_closed = false) {
-        R_RETURN(this->SendReply(kernel, 0, 0, 0, true, session_closed));
+    Result SendReplyHLE(KernelCore& kernel) {
+        R_RETURN(this->SendReply(kernel, 0, 0, 0, true));
     }
 
     Result ReceiveRequestHLE(KernelCore& kernel, std::shared_ptr<Service::HLERequestContext>* out_context,

src/core/hle/service/nvdrv/devices/nvhost_nvdec.cpp

@@ -8,7 +8,6 @@
 #include "common/assert.h"
 #include "common/logging.h"
 #include "core/core.h"
-#include "core/hle/kernel/k_process.h"
 #include "core/hle/service/nvdrv/core/container.h"
 #include "core/hle/service/nvdrv/devices/ioctl_serialization.h"
 #include "core/hle/service/nvdrv/devices/nvhost_nvdec.h"
@@ -72,23 +71,17 @@ NvResult nvhost_nvdec::Ioctl3(DeviceFD fd, Ioctl command, std::span<const u8> in
 
 void nvhost_nvdec::OnOpen(NvCore::SessionId session_id, DeviceFD fd) {
     LOG_INFO(Service_NVDRV, "NVDEC video stream started");
+    system.SetNVDECActive(true);
     sessions[fd] = session_id;
-    if (const auto* session = core.GetSession(session_id);
-        session != nullptr && session->process != nullptr) {
-        system.NotifyNVDECChannelOpen(session->process->GetId());
-    }
     host1x.StartDevice(fd, Tegra::Host1x::ChannelType::NvDec, channel_syncpoint);
 }
 
 void nvhost_nvdec::OnClose(DeviceFD fd) {
     LOG_INFO(Service_NVDRV, "NVDEC video stream ended");
     host1x.StopDevice(fd, Tegra::Host1x::ChannelType::NvDec);
+    system.SetNVDECActive(false);
     auto it = sessions.find(fd);
     if (it != sessions.end()) {
-        if (const auto* session = core.GetSession(it->second);
-            session != nullptr && session->process != nullptr) {
-            system.NotifyNVDECChannelClose(session->process->GetId());
-        }
         sessions.erase(it);
     }
 }

src/core/hle/service/server_manager.cpp

@@ -393,7 +393,7 @@ Result ServerManager::CompleteSyncRequest(Session* session) {
     }
 
     // Send the reply.
-    res = server_session->SendReplyHLE(m_system.Kernel(), service_res == IPC::ResultSessionClosed);
+    res = server_session->SendReplyHLE(m_system.Kernel());
 
     // If the session has been closed, we're done.
     if (res == Kernel::ResultSessionClosed || service_res == IPC::ResultSessionClosed) {

src/core/hle/service/service.cpp

@@ -4,16 +4,12 @@
 // SPDX-FileCopyrightText: Copyright 2018 yuzu Emulator Project
 // SPDX-License-Identifier: GPL-2.0-or-later
 
-#include <chrono>
 #include <fmt/ranges.h>
-#include <string_view>
-#include <thread>
 #include "common/assert.h"
 #include "common/logging.h"
 #include "common/settings.h"
 #include "core/core.h"
 #include "core/hle/ipc.h"
-#include "core/hle/kernel/k_process.h"
 #include "core/hle/kernel/kernel.h"
 #include "core/hle/service/ipc_helpers.h"
 #include "core/hle/service/service.h"
@@ -37,7 +33,6 @@ ServiceFrameworkBase::ServiceFrameworkBase(Core::System& system_, const char* se
     : SessionRequestHandler(system_.Kernel(), service_name_)
     , system{system_}
     , service_name{service_name_}
-    , is_i_storage{std::string_view{service_name_} == "IStorage"}
     , handler_invoker{handler_invoker_}
     , max_sessions{max_sessions_}
 {}
@@ -82,22 +77,13 @@ void ServiceFrameworkBase::ReportUnimplementedFunction(HLERequestContext& ctx,
 }
 
 void ServiceFrameworkBase::InvokeRequest(HLERequestContext& ctx) {
-    const auto command = ctx.GetCommand();
-    auto it = handlers.find(command);
-    const bool is_cmd_read = command == 0;
+    auto it = handlers.find(ctx.GetCommand());
     FunctionInfoBase const* info = it == handlers.end() ? nullptr : &it->second;
     if (info == nullptr || info->handler_callback == nullptr)
         return ReportUnimplementedFunction(ctx, info);
 
     LOG_TRACE(Service, "{}", MakeFunctionString(info->name, GetServiceName(), ctx.CommandBuffer()));
     handler_invoker(this, info->handler_callback, ctx);
-
-    if (is_i_storage && is_cmd_read) {
-        const auto* const process = ctx.GetThread().GetOwnerProcess();
-        if (process != nullptr && system.IsNVDECActiveForProcess(process->GetId())) {
-            std::this_thread::sleep_for(std::chrono::microseconds{600});
-        }
-    }
 }
 
 void ServiceFrameworkBase::InvokeRequestTipc(HLERequestContext& ctx) {

src/core/hle/service/service.h

@@ -107,8 +107,6 @@ protected:
     Core::System& system;
     /// Identifier string used to connect to the service.
     const char* service_name;
-    /// Whether this is the IStorage service.
-    const bool is_i_storage;
     /// Function used to safely up-cast pointers to the derived class before invoking a handler.
     InvokerFn* handler_invoker;
     /// Maximum number of concurrent sessions that this service can handle.

src/video_core/texture_cache/decode_bc.cpp

@@ -1,4 +1,4 @@
-// SPDX-FileCopyrightText: Copyright 2025 Eden Emulator Project
+// SPDX-FileCopyrightText: Copyright 2026 Eden Emulator Project
 // SPDX-License-Identifier: GPL-3.0-or-later
 
 // SPDX-FileCopyrightText: Copyright 2020 yuzu Emulator Project
@@ -9,6 +9,7 @@
 #include <span>
 #include <bc_decoder.h>
 
+#include "common/assert.h"
 #include "common/common_types.h"
 #include "video_core/texture_cache/decode_bc.h"
 
@@ -22,11 +23,8 @@ using VideoCore::Surface::PixelFormat;
 constexpr bool IsSigned(PixelFormat pixel_format) {
     switch (pixel_format) {
     case PixelFormat::BC4_SNORM:
-    case PixelFormat::BC4_UNORM:
     case PixelFormat::BC5_SNORM:
-    case PixelFormat::BC5_UNORM:
     case PixelFormat::BC6H_SFLOAT:
-    case PixelFormat::BC6H_UFLOAT:
         return true;
     default:
         return false;
@@ -62,9 +60,28 @@ u32 ConvertedBytesPerBlock(VideoCore::Surface::PixelFormat pixel_format) {
     }
 }
 
-template <auto decompress, PixelFormat pixel_format>
-void DecompressBlocks(std::span<const u8> input, std::span<u8> output, BufferImageCopy& copy,
-                      bool is_signed = false) {
+void DecompressBCn(std::span<const u8> input, std::span<u8> output, BufferImageCopy& copy, VideoCore::Surface::PixelFormat pixel_format) {
+    auto const f = [pixel_format]{
+        switch (pixel_format) {
+        case PixelFormat::BC1_RGBA_UNORM:
+        case PixelFormat::BC1_RGBA_SRGB: return &bcn::DecodeBc1;
+        case PixelFormat::BC2_UNORM:
+        case PixelFormat::BC2_SRGB: return &bcn::DecodeBc2;
+        case PixelFormat::BC3_UNORM:
+        case PixelFormat::BC3_SRGB: return &bcn::DecodeBc3;
+        case PixelFormat::BC4_SNORM:
+        case PixelFormat::BC4_UNORM: return &bcn::DecodeBc4;
+        case PixelFormat::BC5_SNORM:
+        case PixelFormat::BC5_UNORM: return &bcn::DecodeBc5;
+        case PixelFormat::BC6H_SFLOAT:
+        case PixelFormat::BC6H_UFLOAT: return &bcn::DecodeBc6;
+        case PixelFormat::BC7_SRGB:
+        case PixelFormat::BC7_UNORM: return &bcn::DecodeBc7;
+        default:
+            UNREACHABLE_MSG("Unimplemented BCn decompression {}", pixel_format);
+            return &bcn::DecodeBc1;
+        }
+    }();
     const u32 out_bpp = ConvertedBytesPerBlock(pixel_format);
     const u32 block_size = BlockSize(pixel_format);
     const u32 width = copy.image_extent.width;
@@ -82,11 +99,7 @@ void DecompressBlocks(std::span<const u8> input, std::span<u8> output, BufferIma
             for (u32 x = 0; x < width; x += block_width) {
                 const u8* src = input.data() + src_offset;
                 u8* const dst = output.data() + dst_offset;
-                if constexpr (IsSigned(pixel_format)) {
-                    decompress(src, dst, x, y, width, height, is_signed);
-                } else {
-                    decompress(src, dst, x, y, width, height);
-                }
+                f(src, dst, x, y, width, height, IsSigned(pixel_format));
                 src_offset += block_size;
                 dst_offset += block_width * out_bpp;
             }
@@ -96,43 +109,4 @@ void DecompressBlocks(std::span<const u8> input, std::span<u8> output, BufferIma
     }
 }
 
-void DecompressBCn(std::span<const u8> input, std::span<u8> output, BufferImageCopy& copy,
-                   VideoCore::Surface::PixelFormat pixel_format) {
-    switch (pixel_format) {
-    case PixelFormat::BC1_RGBA_UNORM:
-    case PixelFormat::BC1_RGBA_SRGB:
-        DecompressBlocks<bcn::DecodeBc1, PixelFormat::BC1_RGBA_UNORM>(input, output, copy);
-        break;
-    case PixelFormat::BC2_UNORM:
-    case PixelFormat::BC2_SRGB:
-        DecompressBlocks<bcn::DecodeBc2, PixelFormat::BC2_UNORM>(input, output, copy);
-        break;
-    case PixelFormat::BC3_UNORM:
-    case PixelFormat::BC3_SRGB:
-        DecompressBlocks<bcn::DecodeBc3, PixelFormat::BC3_UNORM>(input, output, copy);
-        break;
-    case PixelFormat::BC4_SNORM:
-    case PixelFormat::BC4_UNORM:
-        DecompressBlocks<bcn::DecodeBc4, PixelFormat::BC4_UNORM>(
-            input, output, copy, pixel_format == PixelFormat::BC4_SNORM);
-        break;
-    case PixelFormat::BC5_SNORM:
-    case PixelFormat::BC5_UNORM:
-        DecompressBlocks<bcn::DecodeBc5, PixelFormat::BC5_UNORM>(
-            input, output, copy, pixel_format == PixelFormat::BC5_SNORM);
-        break;
-    case PixelFormat::BC6H_SFLOAT:
-    case PixelFormat::BC6H_UFLOAT:
-        DecompressBlocks<bcn::DecodeBc6, PixelFormat::BC6H_UFLOAT>(
-            input, output, copy, pixel_format == PixelFormat::BC6H_SFLOAT);
-        break;
-    case PixelFormat::BC7_SRGB:
-    case PixelFormat::BC7_UNORM:
-        DecompressBlocks<bcn::DecodeBc7, PixelFormat::BC7_UNORM>(input, output, copy);
-        break;
-    default:
-        LOG_WARNING(HW_GPU, "Unimplemented BCn decompression {}", pixel_format);
-    }
-}
-
 } // namespace VideoCommon

src/video_core/texture_cache/util.cpp

@@ -1,4 +1,4 @@
-// SPDX-FileCopyrightText: Copyright 2025 Eden Emulator Project
+// SPDX-FileCopyrightText: Copyright 2026 Eden Emulator Project
 // SPDX-License-Identifier: GPL-3.0-or-later
 
 // SPDX-FileCopyrightText: Copyright 2020 yuzu Emulator Project
@@ -922,8 +922,7 @@ boost::container::small_vector<BufferImageCopy, 16> UnswizzleImage(Tegra::Memory
     return copies;
 }
 
-void ConvertImage(std::span<const u8> input, const ImageInfo& info, std::span<u8> output,
-                  std::span<BufferImageCopy> copies) {
+void ConvertImage(std::span<const u8> input, const ImageInfo& info, std::span<u8> output, std::span<BufferImageCopy> copies) {
     u32 output_offset = 0;
     Common::ScratchBuffer<u8> decode_scratch;
 
@@ -955,10 +954,10 @@ void ConvertImage(std::span<const u8> input, const ImageInfo& info, std::span<u8
         } else if (astc) {
             // BC1 uses 0.5 bytes per texel
             // BC3 uses 1 byte per texel
-            const auto compress = recompression_setting == Settings::AstcRecompression::Bc1
-                                      ? Tegra::Texture::BCN::CompressBC1
-                                      : Tegra::Texture::BCN::CompressBC3;
-            const auto bpp_div = recompression_setting == Settings::AstcRecompression::Bc1 ? 2 : 1;
+            auto const compress = recompression_setting == Settings::AstcRecompression::Bc1
+                ? Tegra::Texture::BCN::CompressBC1
+                : Tegra::Texture::BCN::CompressBC3;
+            const auto bpp_div = compress == Tegra::Texture::BCN::CompressBC1 ? 2 : 1;
 
             const u32 plane_dim = copy.image_extent.width * copy.image_extent.height;
             const u32 level_size = plane_dim * copy.image_extent.depth *
@@ -975,18 +974,12 @@ void ConvertImage(std::span<const u8> input, const ImageInfo& info, std::span<u8
                      copy.image_subresource.num_layers * copy.image_extent.depth,
                      output.subspan(output_offset));
 
-            const u32 aligned_plane_dim = Common::AlignUp(copy.image_extent.width, 4) *
-                                          Common::AlignUp(copy.image_extent.height, 4);
-
-            copy.buffer_size =
-                (aligned_plane_dim * copy.image_extent.depth * copy.image_subresource.num_layers) /
-                bpp_div;
-            output_offset += static_cast<u32>(copy.buffer_size);
+            const u32 aligned_plane_dim = Common::AlignUp(copy.image_extent.width, 4) * Common::AlignUp(copy.image_extent.height, 4);
+            copy.buffer_size = (aligned_plane_dim * copy.image_extent.depth * copy.image_subresource.num_layers) / bpp_div;
+            output_offset += u32(copy.buffer_size);
         } else {
             DecompressBCn(input_offset, output.subspan(output_offset), copy, info.format);
-            output_offset += copy.image_extent.width * copy.image_extent.height *
-                             copy.image_subresource.num_layers *
-                             ConvertedBytesPerBlock(info.format);
+            output_offset += copy.image_extent.width * copy.image_extent.height * copy.image_subresource.num_layers * ConvertedBytesPerBlock(info.format);
         }
 
         copy.buffer_row_length = mip_size.width;