video_core: Move OpenGL specific utils to its renderer

renderer_opengl: Correct bpp value for ASTC_2D_8X5

src/audio_core/cubeb_sink.cpp

@@ -121,7 +121,8 @@ CubebSink::CubebSink(std::string target_device_name) {
             const auto collection_end{collection.device + collection.count};
             const auto device{
                 std::find_if(collection.device, collection_end, [&](const cubeb_device_info& info) {
-                    return target_device_name == info.friendly_name;
+                    return info.friendly_name != nullptr &&
+                           target_device_name == info.friendly_name;
                 })};
             if (device != collection_end) {
                 output_device = device->devid;

src/core/crypto/key_manager.cpp

@@ -395,7 +395,7 @@ static bool ValidCryptoRevisionString(std::string_view base, size_t begin, size_
     if (base.size() < begin + length)
         return false;
     return std::all_of(base.begin() + begin, base.begin() + begin + length,
-                       [](u8 c) { return std::isdigit(c); });
+                       [](u8 c) { return std::isxdigit(c); });
 }
 
 void KeyManager::LoadFromFile(const std::string& filename, bool is_title_keys) {

src/core/file_sys/patch_manager.cpp

@@ -61,13 +61,12 @@ VirtualDir PatchManager::PatchExeFS(VirtualDir exefs) const {
     // Game Updates
     const auto update_tid = GetUpdateTitleID(title_id);
     const auto update = installed->GetEntry(update_tid, ContentRecordType::Program);
-    if (update != nullptr) {
-        if (update->GetStatus() == Loader::ResultStatus::ErrorMissingBKTRBaseRomFS &&
-            update->GetExeFS() != nullptr) {
-            LOG_INFO(Loader, "    ExeFS: Update ({}) applied successfully",
-                     FormatTitleVersion(installed->GetEntryVersion(update_tid).get_value_or(0)));
-            exefs = update->GetExeFS();
-        }
+
+    if (update != nullptr && update->GetExeFS() != nullptr &&
+        update->GetStatus() == Loader::ResultStatus::ErrorMissingBKTRBaseRomFS) {
+        LOG_INFO(Loader, "    ExeFS: Update ({}) applied successfully",
+                 FormatTitleVersion(installed->GetEntryVersion(update_tid).get_value_or(0)));
+        exefs = update->GetExeFS();
     }
 
     return exefs;

src/core/hle/kernel/process.h

@@ -202,6 +202,16 @@ public:
         return is_64bit_process;
     }
 
+    /// Gets the total running time of the process instance in ticks.
+    u64 GetCPUTimeTicks() const {
+        return total_process_running_time_ticks;
+    }
+
+    /// Updates the total running time, adding the given ticks to it.
+    void UpdateCPUTimeTicks(u64 ticks) {
+        total_process_running_time_ticks += ticks;
+    }
+
     /**
      * Loads process-specifics configuration info with metadata provided
      * by an executable.
@@ -305,6 +315,9 @@ private:
     /// specified by metadata provided to the process during loading.
     bool is_64bit_process = true;
 
+    /// Total running time for the process in ticks.
+    u64 total_process_running_time_ticks = 0;
+
     /// Per-process handle table for storing created object handles in.
     HandleTable handle_table;
 

src/core/hle/kernel/scheduler.cpp

@@ -9,6 +9,7 @@
 #include "common/logging/log.h"
 #include "core/arm/arm_interface.h"
 #include "core/core.h"
+#include "core/core_timing.h"
 #include "core/hle/kernel/kernel.h"
 #include "core/hle/kernel/process.h"
 #include "core/hle/kernel/scheduler.h"
@@ -34,6 +35,10 @@ Thread* Scheduler::GetCurrentThread() const {
     return current_thread.get();
 }
 
+u64 Scheduler::GetLastContextSwitchTicks() const {
+    return last_context_switch_time;
+}
+
 Thread* Scheduler::PopNextReadyThread() {
     Thread* next = nullptr;
     Thread* thread = GetCurrentThread();
@@ -54,7 +59,10 @@ Thread* Scheduler::PopNextReadyThread() {
 }
 
 void Scheduler::SwitchContext(Thread* new_thread) {
-    Thread* previous_thread = GetCurrentThread();
+    Thread* const previous_thread = GetCurrentThread();
+    Process* const previous_process = Core::CurrentProcess();
+
+    UpdateLastContextSwitchTime(previous_thread, previous_process);
 
     // Save context for previous thread
     if (previous_thread) {
@@ -78,8 +86,6 @@ void Scheduler::SwitchContext(Thread* new_thread) {
         // Cancel any outstanding wakeup events for this thread
         new_thread->CancelWakeupTimer();
 
-        auto* const previous_process = Core::CurrentProcess();
-
         current_thread = new_thread;
 
         ready_queue.remove(new_thread->GetPriority(), new_thread);
@@ -102,6 +108,22 @@ void Scheduler::SwitchContext(Thread* new_thread) {
     }
 }
 
+void Scheduler::UpdateLastContextSwitchTime(Thread* thread, Process* process) {
+    const u64 prev_switch_ticks = last_context_switch_time;
+    const u64 most_recent_switch_ticks = CoreTiming::GetTicks();
+    const u64 update_ticks = most_recent_switch_ticks - prev_switch_ticks;
+
+    if (thread != nullptr) {
+        thread->UpdateCPUTimeTicks(update_ticks);
+    }
+
+    if (process != nullptr) {
+        process->UpdateCPUTimeTicks(update_ticks);
+    }
+
+    last_context_switch_time = most_recent_switch_ticks;
+}
+
 void Scheduler::Reschedule() {
     std::lock_guard<std::mutex> lock(scheduler_mutex);
 

src/core/hle/kernel/scheduler.h

@@ -17,6 +17,8 @@ class ARM_Interface;
 
 namespace Kernel {
 
+class Process;
+
 class Scheduler final {
 public:
     explicit Scheduler(Core::ARM_Interface& cpu_core);
@@ -31,6 +33,9 @@ public:
     /// Gets the current running thread
     Thread* GetCurrentThread() const;
 
+    /// Gets the timestamp for the last context switch in ticks.
+    u64 GetLastContextSwitchTicks() const;
+
     /// Adds a new thread to the scheduler
     void AddThread(SharedPtr<Thread> thread, u32 priority);
 
@@ -64,6 +69,19 @@ private:
      */
     void SwitchContext(Thread* new_thread);
 
+    /**
+     * Called on every context switch to update the internal timestamp
+     * This also updates the running time ticks for the given thread and
+     * process using the following difference:
+     *
+     * ticks += most_recent_ticks - last_context_switch_ticks
+     *
+     * The internal tick timestamp for the scheduler is simply the
+     * most recent tick count retrieved. No special arithmetic is
+     * applied to it.
+     */
+    void UpdateLastContextSwitchTime(Thread* thread, Process* process);
+
     /// Lists all thread ids that aren't deleted/etc.
     std::vector<SharedPtr<Thread>> thread_list;
 
@@ -73,6 +91,7 @@ private:
     SharedPtr<Thread> current_thread = nullptr;
 
     Core::ARM_Interface& cpu_core;
+    u64 last_context_switch_time = 0;
 
     static std::mutex scheduler_mutex;
 };

src/core/hle/kernel/svc.cpp

@@ -467,6 +467,37 @@ static ResultCode GetInfo(u64* result, u64 info_id, u64 handle, u64 info_sub_id)
     LOG_TRACE(Kernel_SVC, "called info_id=0x{:X}, info_sub_id=0x{:X}, handle=0x{:08X}", info_id,
               info_sub_id, handle);
 
+    enum class GetInfoType : u64 {
+        // 1.0.0+
+        AllowedCpuIdBitmask = 0,
+        AllowedThreadPrioBitmask = 1,
+        MapRegionBaseAddr = 2,
+        MapRegionSize = 3,
+        HeapRegionBaseAddr = 4,
+        HeapRegionSize = 5,
+        TotalMemoryUsage = 6,
+        TotalHeapUsage = 7,
+        IsCurrentProcessBeingDebugged = 8,
+        ResourceHandleLimit = 9,
+        IdleTickCount = 10,
+        RandomEntropy = 11,
+        PerformanceCounter = 0xF0000002,
+        // 2.0.0+
+        ASLRRegionBaseAddr = 12,
+        ASLRRegionSize = 13,
+        NewMapRegionBaseAddr = 14,
+        NewMapRegionSize = 15,
+        // 3.0.0+
+        IsVirtualAddressMemoryEnabled = 16,
+        PersonalMmHeapUsage = 17,
+        TitleId = 18,
+        // 4.0.0+
+        PrivilegedProcessId = 19,
+        // 5.0.0+
+        UserExceptionContextAddr = 20,
+        ThreadTickCount = 0xF0000002,
+    };
+
     const auto* current_process = Core::CurrentProcess();
     const auto& vm_manager = current_process->VMManager();
 
@@ -529,6 +560,36 @@ static ResultCode GetInfo(u64* result, u64 info_id, u64 handle, u64 info_sub_id)
                     "(STUBBED) Attempted to query user exception context address, returned 0");
         *result = 0;
         break;
+    case GetInfoType::ThreadTickCount: {
+        constexpr u64 num_cpus = 4;
+        if (info_sub_id != 0xFFFFFFFFFFFFFFFF && info_sub_id >= num_cpus) {
+            return ERR_INVALID_COMBINATION_KERNEL;
+        }
+
+        const auto thread =
+            current_process->GetHandleTable().Get<Thread>(static_cast<Handle>(handle));
+        if (!thread) {
+            return ERR_INVALID_HANDLE;
+        }
+
+        auto& system = Core::System::GetInstance();
+        const auto& scheduler = system.CurrentScheduler();
+        const auto* const current_thread = scheduler.GetCurrentThread();
+        const bool same_thread = current_thread == thread;
+
+        const u64 prev_ctx_ticks = scheduler.GetLastContextSwitchTicks();
+        u64 out_ticks = 0;
+        if (same_thread && info_sub_id == 0xFFFFFFFFFFFFFFFF) {
+            const u64 thread_ticks = current_thread->GetTotalCPUTimeTicks();
+
+            out_ticks = thread_ticks + (CoreTiming::GetTicks() - prev_ctx_ticks);
+        } else if (same_thread && info_sub_id == system.CurrentCoreIndex()) {
+            out_ticks = CoreTiming::GetTicks() - prev_ctx_ticks;
+        }
+
+        *result = out_ticks;
+        break;
+    }
     default:
         UNIMPLEMENTED();
     }

src/core/hle/kernel/svc.h

@@ -24,37 +24,6 @@ struct PageInfo {
     u64 flags;
 };
 
-/// Values accepted by svcGetInfo
-enum class GetInfoType : u64 {
-    // 1.0.0+
-    AllowedCpuIdBitmask = 0,
-    AllowedThreadPrioBitmask = 1,
-    MapRegionBaseAddr = 2,
-    MapRegionSize = 3,
-    HeapRegionBaseAddr = 4,
-    HeapRegionSize = 5,
-    TotalMemoryUsage = 6,
-    TotalHeapUsage = 7,
-    IsCurrentProcessBeingDebugged = 8,
-    ResourceHandleLimit = 9,
-    IdleTickCount = 10,
-    RandomEntropy = 11,
-    PerformanceCounter = 0xF0000002,
-    // 2.0.0+
-    ASLRRegionBaseAddr = 12,
-    ASLRRegionSize = 13,
-    NewMapRegionBaseAddr = 14,
-    NewMapRegionSize = 15,
-    // 3.0.0+
-    IsVirtualAddressMemoryEnabled = 16,
-    PersonalMmHeapUsage = 17,
-    TitleId = 18,
-    // 4.0.0+
-    PrivilegedProcessId = 19,
-    // 5.0.0+
-    UserExceptionContextAddr = 20,
-};
-
 void CallSVC(u32 immediate);
 
 } // namespace Kernel

src/core/hle/kernel/thread.h

@@ -258,6 +258,14 @@ public:
         return last_running_ticks;
     }
 
+    u64 GetTotalCPUTimeTicks() const {
+        return total_cpu_time_ticks;
+    }
+
+    void UpdateCPUTimeTicks(u64 ticks) {
+        total_cpu_time_ticks += ticks;
+    }
+
     s32 GetProcessorID() const {
         return processor_id;
     }
@@ -378,7 +386,8 @@ private:
     u32 nominal_priority = 0; ///< Nominal thread priority, as set by the emulated application
     u32 current_priority = 0; ///< Current thread priority, can be temporarily changed
 
-    u64 last_running_ticks = 0; ///< CPU tick when thread was last running
+    u64 total_cpu_time_ticks = 0; ///< Total CPU running ticks.
+    u64 last_running_ticks = 0;   ///< CPU tick when thread was last running
 
     s32 processor_id = 0;
 

src/core/hle/service/filesystem/fsp_srv.cpp

@@ -273,8 +273,8 @@ public:
             {0, &IFileSystem::CreateFile, "CreateFile"},
             {1, &IFileSystem::DeleteFile, "DeleteFile"},
             {2, &IFileSystem::CreateDirectory, "CreateDirectory"},
-            {3, nullptr, "DeleteDirectory"},
-            {4, nullptr, "DeleteDirectoryRecursively"},
+            {3, &IFileSystem::DeleteDirectory, "DeleteDirectory"},
+            {4, &IFileSystem::DeleteDirectoryRecursively, "DeleteDirectoryRecursively"},
             {5, &IFileSystem::RenameFile, "RenameFile"},
             {6, nullptr, "RenameDirectory"},
             {7, &IFileSystem::GetEntryType, "GetEntryType"},
@@ -329,6 +329,30 @@ public:
         rb.Push(backend.CreateDirectory(name));
     }
 
+    void DeleteDirectory(Kernel::HLERequestContext& ctx) {
+        const IPC::RequestParser rp{ctx};
+
+        const auto file_buffer = ctx.ReadBuffer();
+        std::string name = Common::StringFromBuffer(file_buffer);
+
+        LOG_DEBUG(Service_FS, "called directory {}", name);
+
+        IPC::ResponseBuilder rb{ctx, 2};
+        rb.Push(backend.DeleteDirectory(name));
+    }
+
+    void DeleteDirectoryRecursively(Kernel::HLERequestContext& ctx) {
+        const IPC::RequestParser rp{ctx};
+
+        const auto file_buffer = ctx.ReadBuffer();
+        std::string name = Common::StringFromBuffer(file_buffer);
+
+        LOG_DEBUG(Service_FS, "called directory {}", name);
+
+        IPC::ResponseBuilder rb{ctx, 2};
+        rb.Push(backend.DeleteDirectoryRecursively(name));
+    }
+
     void RenameFile(Kernel::HLERequestContext& ctx) {
         IPC::RequestParser rp{ctx};
 

src/core/loader/nsp.cpp

@@ -36,6 +36,16 @@ AppLoader_NSP::AppLoader_NSP(FileSys::VirtualFile file)
 
     std::tie(nacp_file, icon_file) =
         FileSys::PatchManager(nsp->GetProgramTitleID()).ParseControlNCA(*control_nca);
+
+    if (nsp->IsExtractedType()) {
+        secondary_loader = std::make_unique<AppLoader_DeconstructedRomDirectory>(nsp->GetExeFS());
+    } else {
+        if (title_id == 0)
+            return;
+
+        secondary_loader = std::make_unique<AppLoader_NCA>(
+            nsp->GetNCAFile(title_id, FileSys::ContentRecordType::Program));
+    }
 }
 
 AppLoader_NSP::~AppLoader_NSP() = default;
@@ -67,26 +77,19 @@ ResultStatus AppLoader_NSP::Load(Kernel::Process& process) {
         return ResultStatus::ErrorAlreadyLoaded;
     }
 
-    if (nsp->IsExtractedType()) {
-        secondary_loader = std::make_unique<AppLoader_DeconstructedRomDirectory>(nsp->GetExeFS());
-    } else {
-        if (title_id == 0)
-            return ResultStatus::ErrorNSPMissingProgramNCA;
+    if (title_id == 0)
+        return ResultStatus::ErrorNSPMissingProgramNCA;
 
-        secondary_loader = std::make_unique<AppLoader_NCA>(
-            nsp->GetNCAFile(title_id, FileSys::ContentRecordType::Program));
+    if (nsp->GetStatus() != ResultStatus::Success)
+        return nsp->GetStatus();
 
-        if (nsp->GetStatus() != ResultStatus::Success)
-            return nsp->GetStatus();
+    if (nsp->GetProgramStatus(title_id) != ResultStatus::Success)
+        return nsp->GetProgramStatus(title_id);
 
-        if (nsp->GetProgramStatus(title_id) != ResultStatus::Success)
-            return nsp->GetProgramStatus(title_id);
-
-        if (nsp->GetNCA(title_id, FileSys::ContentRecordType::Program) == nullptr) {
-            if (!Core::Crypto::KeyManager::KeyFileExists(false))
-                return ResultStatus::ErrorMissingProductionKeyFile;
-            return ResultStatus::ErrorNSPMissingProgramNCA;
-        }
+    if (nsp->GetNCA(title_id, FileSys::ContentRecordType::Program) == nullptr) {
+        if (!Core::Crypto::KeyManager::KeyFileExists(false))
+            return ResultStatus::ErrorMissingProductionKeyFile;
+        return ResultStatus::ErrorNSPMissingProgramNCA;
     }
 
     const auto result = secondary_loader->Load(process);

src/video_core/CMakeLists.txt

@@ -51,6 +51,8 @@ add_library(video_core STATIC
     renderer_opengl/maxwell_to_gl.h
     renderer_opengl/renderer_opengl.cpp
     renderer_opengl/renderer_opengl.h
+    renderer_opengl/utils.cpp
+    renderer_opengl/utils.h
     textures/astc.cpp
     textures/astc.h
     textures/decoders.cpp

src/video_core/engines/maxwell_3d.h

@@ -723,7 +723,11 @@ public:
                 StencilOp stencil_back_op_zpass;
                 ComparisonOp stencil_back_func_func;
 
-                INSERT_PADDING_WORDS(0x17);
+                INSERT_PADDING_WORDS(0x4);
+
+                u32 framebuffer_srgb;
+
+                INSERT_PADDING_WORDS(0x12);
 
                 union {
                     BitField<2, 1, u32> coord_origin;
@@ -751,7 +755,14 @@ public:
                     };
                 } draw;
 
-                INSERT_PADDING_WORDS(0x6B);
+                INSERT_PADDING_WORDS(0xA);
+
+                struct {
+                    u32 enabled;
+                    u32 index;
+                } primitive_restart;
+
+                INSERT_PADDING_WORDS(0x5F);
 
                 struct {
                     u32 start_addr_high;
@@ -1079,9 +1090,11 @@ ASSERT_REG_POSITION(stencil_back_op_fail, 0x566);
 ASSERT_REG_POSITION(stencil_back_op_zfail, 0x567);
 ASSERT_REG_POSITION(stencil_back_op_zpass, 0x568);
 ASSERT_REG_POSITION(stencil_back_func_func, 0x569);
+ASSERT_REG_POSITION(framebuffer_srgb, 0x56E);
 ASSERT_REG_POSITION(point_coord_replace, 0x581);
 ASSERT_REG_POSITION(code_address, 0x582);
 ASSERT_REG_POSITION(draw, 0x585);
+ASSERT_REG_POSITION(primitive_restart, 0x591);
 ASSERT_REG_POSITION(index_array, 0x5F2);
 ASSERT_REG_POSITION(instanced_arrays, 0x620);
 ASSERT_REG_POSITION(cull, 0x646);

src/video_core/renderer_opengl/gl_rasterizer.cpp

@@ -418,6 +418,7 @@ void RasterizerOpenGL::ConfigureFramebuffers(bool using_color_fb, bool using_dep
     // Bind the framebuffer surfaces
     state.draw.draw_framebuffer = framebuffer.handle;
     state.Apply();
+    state.framebuffer_srgb.enabled = regs.framebuffer_srgb != 0;
 
     if (using_color_fb) {
         if (single_color_target) {
@@ -429,6 +430,9 @@ void RasterizerOpenGL::ConfigureFramebuffers(bool using_color_fb, bool using_dep
                 // Assume that a surface will be written to if it is used as a framebuffer, even if
                 // the shader doesn't actually write to it.
                 color_surface->MarkAsModified(true, res_cache);
+                // Workaround for and issue in nvidia drivers
+                // https://devtalk.nvidia.com/default/topic/776591/opengl/gl_framebuffer_srgb-functions-incorrectly/
+                state.framebuffer_srgb.enabled |= color_surface->GetSurfaceParams().srgb_conversion;
             }
 
             glFramebufferTexture2D(
@@ -446,6 +450,11 @@ void RasterizerOpenGL::ConfigureFramebuffers(bool using_color_fb, bool using_dep
                     // Assume that a surface will be written to if it is used as a framebuffer, even
                     // if the shader doesn't actually write to it.
                     color_surface->MarkAsModified(true, res_cache);
+                    // Enable sRGB only for supported formats
+                    // Workaround for and issue in nvidia drivers
+                    // https://devtalk.nvidia.com/default/topic/776591/opengl/gl_framebuffer_srgb-functions-incorrectly/
+                    state.framebuffer_srgb.enabled |=
+                        color_surface->GetSurfaceParams().srgb_conversion;
                 }
 
                 buffers[index] = GL_COLOR_ATTACHMENT0 + regs.rt_control.GetMap(index);
@@ -537,7 +546,9 @@ void RasterizerOpenGL::Clear() {
 
     ConfigureFramebuffers(use_color, use_depth || use_stencil, false,
                           regs.clear_buffers.RT.Value());
-
+    // Copy the sRGB setting to the clear state to avoid problem with
+    // specific driver implementations
+    clear_state.framebuffer_srgb.enabled = state.framebuffer_srgb.enabled;
     clear_state.Apply();
 
     if (use_color) {
@@ -570,6 +581,7 @@ void RasterizerOpenGL::DrawArrays() {
     SyncBlendState();
     SyncLogicOpState();
     SyncCullMode();
+    SyncPrimitiveRestart();
     SyncDepthRange();
     SyncScissorTest();
     // Alpha Testing is synced on shaders.
@@ -924,6 +936,13 @@ void RasterizerOpenGL::SyncCullMode() {
     }
 }
 
+void RasterizerOpenGL::SyncPrimitiveRestart() {
+    const auto& regs = Core::System::GetInstance().GPU().Maxwell3D().regs;
+
+    state.primitive_restart.enabled = regs.primitive_restart.enabled;
+    state.primitive_restart.index = regs.primitive_restart.index;
+}
+
 void RasterizerOpenGL::SyncDepthRange() {
     const auto& regs = Core::System::GetInstance().GPU().Maxwell3D().regs;
 

src/video_core/renderer_opengl/gl_rasterizer.h

@@ -144,6 +144,9 @@ private:
     /// Syncs the cull mode to match the guest state
     void SyncCullMode();
 
+    /// Syncs the primitve restart to match the guest state
+    void SyncPrimitiveRestart();
+
     /// Syncs the depth range to match the guest state
     void SyncDepthRange();
 

src/video_core/renderer_opengl/gl_rasterizer_cache.cpp

@@ -16,6 +16,7 @@
 #include "core/settings.h"
 #include "video_core/engines/maxwell_3d.h"
 #include "video_core/renderer_opengl/gl_rasterizer_cache.h"
+#include "video_core/renderer_opengl/utils.h"
 #include "video_core/textures/astc.h"
 #include "video_core/textures/decoders.h"
 #include "video_core/utils.h"
@@ -40,6 +41,10 @@ static bool IsPixelFormatASTC(PixelFormat format) {
     case PixelFormat::ASTC_2D_5X4:
     case PixelFormat::ASTC_2D_8X8:
     case PixelFormat::ASTC_2D_8X5:
+    case PixelFormat::ASTC_2D_4X4_SRGB:
+    case PixelFormat::ASTC_2D_5X4_SRGB:
+    case PixelFormat::ASTC_2D_8X8_SRGB:
+    case PixelFormat::ASTC_2D_8X5_SRGB:
         return true;
     default:
         return false;
@@ -56,6 +61,14 @@ static std::pair<u32, u32> GetASTCBlockSize(PixelFormat format) {
         return {8, 8};
     case PixelFormat::ASTC_2D_8X5:
         return {8, 5};
+    case PixelFormat::ASTC_2D_4X4_SRGB:
+        return {4, 4};
+    case PixelFormat::ASTC_2D_5X4_SRGB:
+        return {5, 4};
+    case PixelFormat::ASTC_2D_8X8_SRGB:
+        return {8, 8};
+    case PixelFormat::ASTC_2D_8X5_SRGB:
+        return {8, 5};
     default:
         LOG_CRITICAL(HW_GPU, "Unhandled format: {}", static_cast<u32>(format));
         UNREACHABLE();
@@ -108,8 +121,9 @@ std::size_t SurfaceParams::InnerMemorySize(bool layer_only) const {
     params.block_width = params.is_tiled ? config.tic.BlockWidth() : 0,
     params.block_height = params.is_tiled ? config.tic.BlockHeight() : 0,
     params.block_depth = params.is_tiled ? config.tic.BlockDepth() : 0,
-    params.pixel_format =
-        PixelFormatFromTextureFormat(config.tic.format, config.tic.r_type.Value());
+    params.srgb_conversion = config.tic.IsSrgbConversionEnabled();
+    params.pixel_format = PixelFormatFromTextureFormat(config.tic.format, config.tic.r_type.Value(),
+                                                       params.srgb_conversion);
     params.component_type = ComponentTypeFromTexture(config.tic.r_type.Value());
     params.type = GetFormatType(params.pixel_format);
     params.width = Common::AlignUp(config.tic.Width(), GetCompressionFactor(params.pixel_format));
@@ -166,6 +180,8 @@ std::size_t SurfaceParams::InnerMemorySize(bool layer_only) const {
     params.block_height = 1 << config.memory_layout.block_height;
     params.block_depth = 1 << config.memory_layout.block_depth;
     params.pixel_format = PixelFormatFromRenderTargetFormat(config.format);
+    params.srgb_conversion = config.format == Tegra::RenderTargetFormat::BGRA8_SRGB ||
+                             config.format == Tegra::RenderTargetFormat::RGBA8_SRGB;
     params.component_type = ComponentTypeFromRenderTarget(config.format);
     params.type = GetFormatType(params.pixel_format);
     params.width = config.width;
@@ -201,6 +217,7 @@ std::size_t SurfaceParams::InnerMemorySize(bool layer_only) const {
     params.pixel_format = PixelFormatFromDepthFormat(format);
     params.component_type = ComponentTypeFromDepthFormat(format);
     params.type = GetFormatType(params.pixel_format);
+    params.srgb_conversion = false;
     params.width = zeta_width;
     params.height = zeta_height;
     params.unaligned_height = zeta_height;
@@ -224,6 +241,8 @@ std::size_t SurfaceParams::InnerMemorySize(bool layer_only) const {
     params.block_height = params.is_tiled ? std::min(config.BlockHeight(), 32U) : 0,
     params.block_depth = params.is_tiled ? std::min(config.BlockDepth(), 32U) : 0,
     params.pixel_format = PixelFormatFromRenderTargetFormat(config.format);
+    params.srgb_conversion = config.format == Tegra::RenderTargetFormat::BGRA8_SRGB ||
+                             config.format == Tegra::RenderTargetFormat::RGBA8_SRGB;
     params.component_type = ComponentTypeFromRenderTarget(config.format);
     params.type = GetFormatType(params.pixel_format);
     params.width = config.width;
@@ -289,14 +308,29 @@ static constexpr std::array<FormatTuple, SurfaceParams::MaxPixelFormat> tex_form
     {GL_RG16I, GL_RG_INTEGER, GL_SHORT, ComponentType::SInt, false},           // RG16I
     {GL_RG16_SNORM, GL_RG, GL_SHORT, ComponentType::SNorm, false},             // RG16S
     {GL_RGB32F, GL_RGB, GL_FLOAT, ComponentType::Float, false},                // RGB32F
-    {GL_SRGB8_ALPHA8, GL_RGBA, GL_UNSIGNED_INT_8_8_8_8_REV, ComponentType::UNorm, false}, // SRGBA8
-    {GL_RG8, GL_RG, GL_UNSIGNED_BYTE, ComponentType::UNorm, false},                       // RG8U
-    {GL_RG8, GL_RG, GL_BYTE, ComponentType::SNorm, false},                                // RG8S
-    {GL_RG32UI, GL_RG_INTEGER, GL_UNSIGNED_INT, ComponentType::UInt, false},              // RG32UI
-    {GL_R32UI, GL_RED_INTEGER, GL_UNSIGNED_INT, ComponentType::UInt, false},              // R32UI
-    {GL_RGBA8, GL_RGBA, GL_UNSIGNED_BYTE, ComponentType::UNorm, false}, // ASTC_2D_8X8
-    {GL_RGBA8, GL_RGBA, GL_UNSIGNED_BYTE, ComponentType::UNorm, false}, // ASTC_2D_8X5
-    {GL_RGBA8, GL_RGBA, GL_UNSIGNED_BYTE, ComponentType::UNorm, false}, // ASTC_2D_5X4
+    {GL_SRGB8_ALPHA8, GL_RGBA, GL_UNSIGNED_INT_8_8_8_8_REV, ComponentType::UNorm,
+     false},                                                                   // RGBA8_SRGB
+    {GL_RG8, GL_RG, GL_UNSIGNED_BYTE, ComponentType::UNorm, false},            // RG8U
+    {GL_RG8, GL_RG, GL_BYTE, ComponentType::SNorm, false},                     // RG8S
+    {GL_RG32UI, GL_RG_INTEGER, GL_UNSIGNED_INT, ComponentType::UInt, false},   // RG32UI
+    {GL_R32UI, GL_RED_INTEGER, GL_UNSIGNED_INT, ComponentType::UInt, false},   // R32UI
+    {GL_RGBA8, GL_RGBA, GL_UNSIGNED_BYTE, ComponentType::UNorm, false},        // ASTC_2D_8X8
+    {GL_RGBA8, GL_RGBA, GL_UNSIGNED_BYTE, ComponentType::UNorm, false},        // ASTC_2D_8X5
+    {GL_RGBA8, GL_RGBA, GL_UNSIGNED_BYTE, ComponentType::UNorm, false},        // ASTC_2D_5X4
+    {GL_SRGB8_ALPHA8, GL_BGRA, GL_UNSIGNED_BYTE, ComponentType::UNorm, false}, // BGRA8
+    // Compressed sRGB formats
+    {GL_COMPRESSED_SRGB_S3TC_DXT1_EXT, GL_RGBA, GL_UNSIGNED_INT_8_8_8_8, ComponentType::UNorm,
+     true}, // DXT1_SRGB
+    {GL_COMPRESSED_SRGB_ALPHA_S3TC_DXT3_EXT, GL_RGBA, GL_UNSIGNED_INT_8_8_8_8, ComponentType::UNorm,
+     true}, // DXT23_SRGB
+    {GL_COMPRESSED_SRGB_ALPHA_S3TC_DXT5_EXT, GL_RGBA, GL_UNSIGNED_INT_8_8_8_8, ComponentType::UNorm,
+     true}, // DXT45_SRGB
+    {GL_COMPRESSED_SRGB_ALPHA_BPTC_UNORM_ARB, GL_RGBA, GL_UNSIGNED_INT_8_8_8_8,
+     ComponentType::UNorm, true},                                              // BC7U_SRGB
+    {GL_SRGB8_ALPHA8, GL_RGBA, GL_UNSIGNED_BYTE, ComponentType::UNorm, false}, // ASTC_2D_4X4_SRGB
+    {GL_SRGB8_ALPHA8, GL_RGBA, GL_UNSIGNED_BYTE, ComponentType::UNorm, false}, // ASTC_2D_8X8_SRGB
+    {GL_SRGB8_ALPHA8, GL_RGBA, GL_UNSIGNED_BYTE, ComponentType::UNorm, false}, // ASTC_2D_8X5_SRGB
+    {GL_SRGB8_ALPHA8, GL_RGBA, GL_UNSIGNED_BYTE, ComponentType::UNorm, false}, // ASTC_2D_5X4_SRGB
 
     // Depth formats
     {GL_DEPTH_COMPONENT32F, GL_DEPTH_COMPONENT, GL_FLOAT, ComponentType::Float, false}, // Z32F
@@ -361,6 +395,10 @@ static bool IsFormatBCn(PixelFormat format) {
     case PixelFormat::BC7U:
     case PixelFormat::BC6H_UF16:
     case PixelFormat::BC6H_SF16:
+    case PixelFormat::DXT1_SRGB:
+    case PixelFormat::DXT23_SRGB:
+    case PixelFormat::DXT45_SRGB:
+    case PixelFormat::BC7U_SRGB:
         return true;
     }
     return false;
@@ -432,7 +470,7 @@ static constexpr GLConversionArray morton_to_gl_fns = {
         MortonCopy<true, PixelFormat::RG16I>,
         MortonCopy<true, PixelFormat::RG16S>,
         MortonCopy<true, PixelFormat::RGB32F>,
-        MortonCopy<true, PixelFormat::SRGBA8>,
+        MortonCopy<true, PixelFormat::RGBA8_SRGB>,
         MortonCopy<true, PixelFormat::RG8U>,
         MortonCopy<true, PixelFormat::RG8S>,
         MortonCopy<true, PixelFormat::RG32UI>,
@@ -440,6 +478,15 @@ static constexpr GLConversionArray morton_to_gl_fns = {
         MortonCopy<true, PixelFormat::ASTC_2D_8X8>,
         MortonCopy<true, PixelFormat::ASTC_2D_8X5>,
         MortonCopy<true, PixelFormat::ASTC_2D_5X4>,
+        MortonCopy<true, PixelFormat::BGRA8_SRGB>,
+        MortonCopy<true, PixelFormat::DXT1_SRGB>,
+        MortonCopy<true, PixelFormat::DXT23_SRGB>,
+        MortonCopy<true, PixelFormat::DXT45_SRGB>,
+        MortonCopy<true, PixelFormat::BC7U_SRGB>,
+        MortonCopy<true, PixelFormat::ASTC_2D_4X4_SRGB>,
+        MortonCopy<true, PixelFormat::ASTC_2D_8X8_SRGB>,
+        MortonCopy<true, PixelFormat::ASTC_2D_8X5_SRGB>,
+        MortonCopy<true, PixelFormat::ASTC_2D_5X4_SRGB>,
         MortonCopy<true, PixelFormat::Z32F>,
         MortonCopy<true, PixelFormat::Z16>,
         MortonCopy<true, PixelFormat::Z24S8>,
@@ -491,7 +538,7 @@ static constexpr GLConversionArray gl_to_morton_fns = {
         MortonCopy<false, PixelFormat::RG16I>,
         MortonCopy<false, PixelFormat::RG16S>,
         MortonCopy<false, PixelFormat::RGB32F>,
-        MortonCopy<false, PixelFormat::SRGBA8>,
+        MortonCopy<false, PixelFormat::RGBA8_SRGB>,
         MortonCopy<false, PixelFormat::RG8U>,
         MortonCopy<false, PixelFormat::RG8S>,
         MortonCopy<false, PixelFormat::RG32UI>,
@@ -499,6 +546,15 @@ static constexpr GLConversionArray gl_to_morton_fns = {
         nullptr,
         nullptr,
         nullptr,
+        MortonCopy<false, PixelFormat::BGRA8_SRGB>,
+        MortonCopy<false, PixelFormat::DXT1_SRGB>,
+        MortonCopy<false, PixelFormat::DXT23_SRGB>,
+        MortonCopy<false, PixelFormat::DXT45_SRGB>,
+        MortonCopy<false, PixelFormat::BC7U_SRGB>,
+        nullptr,
+        nullptr,
+        nullptr,
+        nullptr,
         MortonCopy<false, PixelFormat::Z32F>,
         MortonCopy<false, PixelFormat::Z16>,
         MortonCopy<false, PixelFormat::Z24S8>,
@@ -546,6 +602,8 @@ static bool BlitSurface(const Surface& src_surface, const Surface& dst_surface,
     OpenGLState state;
     state.draw.read_framebuffer = read_fb_handle;
     state.draw.draw_framebuffer = draw_fb_handle;
+    // Set sRGB enabled if the destination surfaces need it
+    state.framebuffer_srgb.enabled = dst_params.srgb_conversion;
     state.Apply();
 
     u32 buffers{};
@@ -808,8 +866,8 @@ CachedSurface::CachedSurface(const SurfaceParams& params)
     glTexParameteri(SurfaceTargetToGL(params.target), GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
     glTexParameteri(SurfaceTargetToGL(params.target), GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
 
-    VideoCore::LabelGLObject(GL_TEXTURE, texture.handle, params.addr,
-                             SurfaceParams::SurfaceTargetName(params.target));
+    LabelGLObject(GL_TEXTURE, texture.handle, params.addr,
+                  SurfaceParams::SurfaceTargetName(params.target));
 
     // Clamp size to mapped GPU memory region
     // TODO(bunnei): Super Mario Odyssey maps a 0x40000 byte region and then uses it for a 0x80000
@@ -881,7 +939,11 @@ static void ConvertFormatAsNeeded_LoadGLBuffer(std::vector<u8>& data, PixelForma
     case PixelFormat::ASTC_2D_4X4:
     case PixelFormat::ASTC_2D_8X8:
     case PixelFormat::ASTC_2D_8X5:
-    case PixelFormat::ASTC_2D_5X4: {
+    case PixelFormat::ASTC_2D_5X4:
+    case PixelFormat::ASTC_2D_4X4_SRGB:
+    case PixelFormat::ASTC_2D_8X8_SRGB:
+    case PixelFormat::ASTC_2D_8X5_SRGB:
+    case PixelFormat::ASTC_2D_5X4_SRGB: {
         // Convert ASTC pixel formats to RGBA8, as most desktop GPUs do not support ASTC.
         u32 block_width{};
         u32 block_height{};
@@ -913,7 +975,9 @@ static void ConvertFormatAsNeeded_FlushGLBuffer(std::vector<u8>& data, PixelForm
     case PixelFormat::G8R8U:
     case PixelFormat::G8R8S:
     case PixelFormat::ASTC_2D_4X4:
-    case PixelFormat::ASTC_2D_8X8: {
+    case PixelFormat::ASTC_2D_8X8:
+    case PixelFormat::ASTC_2D_4X4_SRGB:
+    case PixelFormat::ASTC_2D_8X8_SRGB: {
         LOG_CRITICAL(HW_GPU, "Conversion of format {} after texture flushing is not implemented",
                      static_cast<u32>(pixel_format));
         UNREACHABLE();
@@ -960,8 +1024,8 @@ void CachedSurface::FlushGLBuffer() {
     glPixelStorei(GL_PACK_ROW_LENGTH, static_cast<GLint>(params.width));
     ASSERT(!tuple.compressed);
     glBindBuffer(GL_PIXEL_PACK_BUFFER, 0);
-    glGetTextureImage(texture.handle, 0, tuple.format, tuple.type, gl_buffer.size(),
-                      gl_buffer.data());
+    glGetTextureImage(texture.handle, 0, tuple.format, tuple.type,
+                      static_cast<GLsizei>(gl_buffer.size()), gl_buffer.data());
     glPixelStorei(GL_PACK_ROW_LENGTH, 0);
     ConvertFormatAsNeeded_FlushGLBuffer(gl_buffer, params.pixel_format, params.width,
                                         params.height);

src/video_core/renderer_opengl/gl_rasterizer_cache.h

@@ -69,7 +69,7 @@ struct SurfaceParams {
         RG16I = 37,
         RG16S = 38,
         RGB32F = 39,
-        SRGBA8 = 40,
+        RGBA8_SRGB = 40,
         RG8U = 41,
         RG8S = 42,
         RG32UI = 43,
@@ -77,19 +77,28 @@ struct SurfaceParams {
         ASTC_2D_8X8 = 45,
         ASTC_2D_8X5 = 46,
         ASTC_2D_5X4 = 47,
+        BGRA8_SRGB = 48,
+        DXT1_SRGB = 49,
+        DXT23_SRGB = 50,
+        DXT45_SRGB = 51,
+        BC7U_SRGB = 52,
+        ASTC_2D_4X4_SRGB = 53,
+        ASTC_2D_8X8_SRGB = 54,
+        ASTC_2D_8X5_SRGB = 55,
+        ASTC_2D_5X4_SRGB = 56,
 
         MaxColorFormat,
 
         // Depth formats
-        Z32F = 48,
-        Z16 = 49,
+        Z32F = 57,
+        Z16 = 58,
 
         MaxDepthFormat,
 
         // DepthStencil formats
-        Z24S8 = 50,
-        S8Z24 = 51,
-        Z32FS8 = 52,
+        Z24S8 = 59,
+        S8Z24 = 60,
+        Z32FS8 = 61,
 
         MaxDepthStencilFormat,
 
@@ -236,7 +245,7 @@ struct SurfaceParams {
             1, // RG16I
             1, // RG16S
             1, // RGB32F
-            1, // SRGBA8
+            1, // RGBA8_SRGB
             1, // RG8U
             1, // RG8S
             1, // RG32UI
@@ -244,6 +253,15 @@ struct SurfaceParams {
             4, // ASTC_2D_8X8
             4, // ASTC_2D_8X5
             4, // ASTC_2D_5X4
+            1, // BGRA8_SRGB
+            4, // DXT1_SRGB
+            4, // DXT23_SRGB
+            4, // DXT45_SRGB
+            4, // BC7U_SRGB
+            4, // ASTC_2D_4X4_SRGB
+            4, // ASTC_2D_8X8_SRGB
+            4, // ASTC_2D_8X5_SRGB
+            4, // ASTC_2D_5X4_SRGB
             1, // Z32F
             1, // Z16
             1, // Z24S8
@@ -255,6 +273,77 @@ struct SurfaceParams {
         return compression_factor_table[static_cast<std::size_t>(format)];
     }
 
+    static constexpr u32 GetDefaultBlockHeight(PixelFormat format) {
+        if (format == PixelFormat::Invalid)
+            return 0;
+        constexpr std::array<u32, MaxPixelFormat> block_height_table = {{
+            1, // ABGR8U
+            1, // ABGR8S
+            1, // ABGR8UI
+            1, // B5G6R5U
+            1, // A2B10G10R10U
+            1, // A1B5G5R5U
+            1, // R8U
+            1, // R8UI
+            1, // RGBA16F
+            1, // RGBA16U
+            1, // RGBA16UI
+            1, // R11FG11FB10F
+            1, // RGBA32UI
+            4, // DXT1
+            4, // DXT23
+            4, // DXT45
+            4, // DXN1
+            4, // DXN2UNORM
+            4, // DXN2SNORM
+            4, // BC7U
+            4, // BC6H_UF16
+            4, // BC6H_SF16
+            4, // ASTC_2D_4X4
+            1, // G8R8U
+            1, // G8R8S
+            1, // BGRA8
+            1, // RGBA32F
+            1, // RG32F
+            1, // R32F
+            1, // R16F
+            1, // R16U
+            1, // R16S
+            1, // R16UI
+            1, // R16I
+            1, // RG16
+            1, // RG16F
+            1, // RG16UI
+            1, // RG16I
+            1, // RG16S
+            1, // RGB32F
+            1, // RGBA8_SRGB
+            1, // RG8U
+            1, // RG8S
+            1, // RG32UI
+            1, // R32UI
+            8, // ASTC_2D_8X8
+            5, // ASTC_2D_8X5
+            4, // ASTC_2D_5X4
+            1, // BGRA8_SRGB
+            4, // DXT1_SRGB
+            4, // DXT23_SRGB
+            4, // DXT45_SRGB
+            4, // BC7U_SRGB
+            4, // ASTC_2D_4X4_SRGB
+            8, // ASTC_2D_8X8_SRGB
+            5, // ASTC_2D_8X5_SRGB
+            4, // ASTC_2D_5X4_SRGB
+            1, // Z32F
+            1, // Z16
+            1, // Z24S8
+            1, // S8Z24
+            1, // Z32FS8
+        }};
+        ASSERT(static_cast<std::size_t>(format) < block_height_table.size());
+        return block_height_table[static_cast<std::size_t>(format)];
+    }
+
     static constexpr u32 GetFormatBpp(PixelFormat format) {
         if (format == PixelFormat::Invalid)
             return 0;
@@ -300,14 +389,23 @@ struct SurfaceParams {
             32,  // RG16I
             32,  // RG16S
             96,  // RGB32F
-            32,  // SRGBA8
+            32,  // RGBA8_SRGB
             16,  // RG8U
             16,  // RG8S
             64,  // RG32UI
             32,  // R32UI
             16,  // ASTC_2D_8X8
-            32,  // ASTC_2D_8X5
+            16,  // ASTC_2D_8X5
             32,  // ASTC_2D_5X4
+            32,  // BGRA8_SRGB
+            64,  // DXT1_SRGB
+            128, // DXT23_SRGB
+            128, // DXT45_SRGB
+            128, // BC7U
+            32,  // ASTC_2D_4X4_SRGB
+            16,  // ASTC_2D_8X8_SRGB
+            32,  // ASTC_2D_8X5_SRGB
+            32,  // ASTC_2D_5X4_SRGB
             32,  // Z32F
             16,  // Z16
             32,  // Z24S8
@@ -346,6 +444,7 @@ struct SurfaceParams {
         // TODO (Hexagon12): Converting SRGBA to RGBA is a hack and doesn't completely correct the
         // gamma.
         case Tegra::RenderTargetFormat::RGBA8_SRGB:
+            return PixelFormat::RGBA8_SRGB;
         case Tegra::RenderTargetFormat::RGBA8_UNORM:
             return PixelFormat::ABGR8U;
         case Tegra::RenderTargetFormat::RGBA8_SNORM:
@@ -353,6 +452,7 @@ struct SurfaceParams {
         case Tegra::RenderTargetFormat::RGBA8_UINT:
             return PixelFormat::ABGR8UI;
         case Tegra::RenderTargetFormat::BGRA8_SRGB:
+            return PixelFormat::BGRA8_SRGB;
         case Tegra::RenderTargetFormat::BGRA8_UNORM:
             return PixelFormat::BGRA8;
         case Tegra::RenderTargetFormat::RGB10_A2_UNORM:
@@ -416,10 +516,14 @@ struct SurfaceParams {
     }
 
     static PixelFormat PixelFormatFromTextureFormat(Tegra::Texture::TextureFormat format,
-                                                    Tegra::Texture::ComponentType component_type) {
+                                                    Tegra::Texture::ComponentType component_type,
+                                                    bool is_srgb) {
         // TODO(Subv): Properly implement this
         switch (format) {
         case Tegra::Texture::TextureFormat::A8R8G8B8:
+            if (is_srgb) {
+                return PixelFormat::RGBA8_SRGB;
+            }
             switch (component_type) {
             case Tegra::Texture::ComponentType::UNORM:
                 return PixelFormat::ABGR8U;
@@ -554,11 +658,11 @@ struct SurfaceParams {
         case Tegra::Texture::TextureFormat::Z24S8:
             return PixelFormat::Z24S8;
         case Tegra::Texture::TextureFormat::DXT1:
-            return PixelFormat::DXT1;
+            return is_srgb ? PixelFormat::DXT1_SRGB : PixelFormat::DXT1;
         case Tegra::Texture::TextureFormat::DXT23:
-            return PixelFormat::DXT23;
+            return is_srgb ? PixelFormat::DXT23_SRGB : PixelFormat::DXT23;
         case Tegra::Texture::TextureFormat::DXT45:
-            return PixelFormat::DXT45;
+            return is_srgb ? PixelFormat::DXT45_SRGB : PixelFormat::DXT45;
         case Tegra::Texture::TextureFormat::DXN1:
             return PixelFormat::DXN1;
         case Tegra::Texture::TextureFormat::DXN2:
@@ -572,19 +676,19 @@ struct SurfaceParams {
                          static_cast<u32>(component_type));
             UNREACHABLE();
         case Tegra::Texture::TextureFormat::BC7U:
-            return PixelFormat::BC7U;
+            return is_srgb ? PixelFormat::BC7U_SRGB : PixelFormat::BC7U;
         case Tegra::Texture::TextureFormat::BC6H_UF16:
             return PixelFormat::BC6H_UF16;
         case Tegra::Texture::TextureFormat::BC6H_SF16:
             return PixelFormat::BC6H_SF16;
         case Tegra::Texture::TextureFormat::ASTC_2D_4X4:
-            return PixelFormat::ASTC_2D_4X4;
+            return is_srgb ? PixelFormat::ASTC_2D_4X4_SRGB : PixelFormat::ASTC_2D_4X4;
         case Tegra::Texture::TextureFormat::ASTC_2D_5X4:
-            return PixelFormat::ASTC_2D_5X4;
+            return is_srgb ? PixelFormat::ASTC_2D_5X4_SRGB : PixelFormat::ASTC_2D_5X4;
         case Tegra::Texture::TextureFormat::ASTC_2D_8X8:
-            return PixelFormat::ASTC_2D_8X8;
+            return is_srgb ? PixelFormat::ASTC_2D_8X8_SRGB : PixelFormat::ASTC_2D_8X8;
         case Tegra::Texture::TextureFormat::ASTC_2D_8X5:
-            return PixelFormat::ASTC_2D_8X5;
+            return is_srgb ? PixelFormat::ASTC_2D_8X5_SRGB : PixelFormat::ASTC_2D_8X5;
         case Tegra::Texture::TextureFormat::R16_G16:
             switch (component_type) {
             case Tegra::Texture::ComponentType::FLOAT:
@@ -819,7 +923,7 @@ struct SurfaceParams {
     SurfaceTarget target;
     u32 max_mip_level;
     bool is_layered;
-
+    bool srgb_conversion;
     // Parameters used for caching
     VAddr addr;
     Tegra::GPUVAddr gpu_addr;

src/video_core/renderer_opengl/gl_shader_cache.cpp

@@ -8,6 +8,7 @@
 #include "video_core/engines/maxwell_3d.h"
 #include "video_core/renderer_opengl/gl_shader_cache.h"
 #include "video_core/renderer_opengl/gl_shader_manager.h"
+#include "video_core/renderer_opengl/utils.h"
 #include "video_core/utils.h"
 
 namespace OpenGL {
@@ -89,7 +90,7 @@ CachedShader::CachedShader(VAddr addr, Maxwell::ShaderProgram program_type)
         shader.Create(program_result.first.c_str(), gl_type);
         program.Create(true, shader.handle);
         SetShaderUniformBlockBindings(program.handle);
-        VideoCore::LabelGLObject(GL_PROGRAM, program.handle, addr);
+        LabelGLObject(GL_PROGRAM, program.handle, addr);
     } else {
         // Store shader's code to lazily build it on draw
         geometry_programs.code = program_result.first;
@@ -130,7 +131,7 @@ GLuint CachedShader::LazyGeometryProgram(OGLProgram& target_program,
     shader.Create(source.c_str(), GL_GEOMETRY_SHADER);
     target_program.Create(true, shader.handle);
     SetShaderUniformBlockBindings(target_program.handle);
-    VideoCore::LabelGLObject(GL_PROGRAM, target_program.handle, addr, debug_name);
+    LabelGLObject(GL_PROGRAM, target_program.handle, addr, debug_name);
     return target_program.handle;
 };
 

src/video_core/renderer_opengl/gl_shader_decompiler.cpp

@@ -341,10 +341,10 @@ public:
      */
     void SetRegisterToFloat(const Register& reg, u64 elem, const std::string& value,
                             u64 dest_num_components, u64 value_num_components,
-                            bool is_saturated = false, u64 dest_elem = 0) {
+                            bool is_saturated = false, u64 dest_elem = 0, bool precise = false) {
 
         SetRegister(reg, elem, is_saturated ? "clamp(" + value + ", 0.0, 1.0)" : value,
-                    dest_num_components, value_num_components, dest_elem);
+                    dest_num_components, value_num_components, dest_elem, precise);
     }
 
     /**
@@ -368,7 +368,7 @@ public:
         const std::string func{is_signed ? "intBitsToFloat" : "uintBitsToFloat"};
 
         SetRegister(reg, elem, func + '(' + ConvertIntegerSize(value, size) + ')',
-                    dest_num_components, value_num_components, dest_elem);
+                    dest_num_components, value_num_components, dest_elem, false);
 
         if (sets_cc) {
             const std::string zero_condition = "( " + ConvertIntegerSize(value, size) + " == 0 )";
@@ -416,7 +416,7 @@ public:
             }
         }();
 
-        SetRegister(reg, elem, result, dest_num_components, value_num_components, dest_elem);
+        SetRegister(reg, elem, result, dest_num_components, value_num_components, dest_elem, false);
     }
 
     /**
@@ -757,7 +757,8 @@ private:
      * @param dest_elem Optional, the destination element to use for the operation.
      */
     void SetRegister(const Register& reg, u64 elem, const std::string& value,
-                     u64 dest_num_components, u64 value_num_components, u64 dest_elem) {
+                     u64 dest_num_components, u64 value_num_components, u64 dest_elem,
+                     bool precise) {
         if (reg == Register::ZeroIndex) {
             LOG_CRITICAL(HW_GPU, "Cannot set Register::ZeroIndex");
             UNREACHABLE();
@@ -774,7 +775,18 @@ private:
             src += GetSwizzle(elem);
         }
 
-        shader.AddLine(dest + " = " + src + ';');
+        if (precise && stage != Maxwell3D::Regs::ShaderStage::Fragment) {
+            shader.AddLine('{');
+            ++shader.scope;
+            // This avoids optimizations of constant propagation and keeps the code as the original
+            // Sadly using the precise keyword causes "linking" errors on fragment shaders.
+            shader.AddLine("precise float tmp = " + src + ';');
+            shader.AddLine(dest + " = tmp;");
+            --shader.scope;
+            shader.AddLine('}');
+        } else {
+            shader.AddLine(dest + " = " + src + ';');
+        }
     }
 
     /// Build the GLSL register list.
@@ -1510,8 +1522,9 @@ private:
                 ASSERT_MSG(instr.fmul.cc == 0, "FMUL cc is not implemented");
 
                 op_b = GetOperandAbsNeg(op_b, false, instr.fmul.negate_b);
+
                 regs.SetRegisterToFloat(instr.gpr0, 0, op_a + " * " + op_b, 1, 1,
-                                        instr.alu.saturate_d);
+                                        instr.alu.saturate_d, 0, true);
                 break;
             }
             case OpCode::Id::FADD_C:
@@ -1519,8 +1532,9 @@ private:
             case OpCode::Id::FADD_IMM: {
                 op_a = GetOperandAbsNeg(op_a, instr.alu.abs_a, instr.alu.negate_a);
                 op_b = GetOperandAbsNeg(op_b, instr.alu.abs_b, instr.alu.negate_b);
+
                 regs.SetRegisterToFloat(instr.gpr0, 0, op_a + " + " + op_b, 1, 1,
-                                        instr.alu.saturate_d);
+                                        instr.alu.saturate_d, 0, true);
                 break;
             }
             case OpCode::Id::MUFU: {
@@ -1528,31 +1542,31 @@ private:
                 switch (instr.sub_op) {
                 case SubOp::Cos:
                     regs.SetRegisterToFloat(instr.gpr0, 0, "cos(" + op_a + ')', 1, 1,
-                                            instr.alu.saturate_d);
+                                            instr.alu.saturate_d, 0, true);
                     break;
                 case SubOp::Sin:
                     regs.SetRegisterToFloat(instr.gpr0, 0, "sin(" + op_a + ')', 1, 1,
-                                            instr.alu.saturate_d);
+                                            instr.alu.saturate_d, 0, true);
                     break;
                 case SubOp::Ex2:
                     regs.SetRegisterToFloat(instr.gpr0, 0, "exp2(" + op_a + ')', 1, 1,
-                                            instr.alu.saturate_d);
+                                            instr.alu.saturate_d, 0, true);
                     break;
                 case SubOp::Lg2:
                     regs.SetRegisterToFloat(instr.gpr0, 0, "log2(" + op_a + ')', 1, 1,
-                                            instr.alu.saturate_d);
+                                            instr.alu.saturate_d, 0, true);
                     break;
                 case SubOp::Rcp:
                     regs.SetRegisterToFloat(instr.gpr0, 0, "1.0 / " + op_a, 1, 1,
-                                            instr.alu.saturate_d);
+                                            instr.alu.saturate_d, 0, true);
                     break;
                 case SubOp::Rsq:
                     regs.SetRegisterToFloat(instr.gpr0, 0, "inversesqrt(" + op_a + ')', 1, 1,
-                                            instr.alu.saturate_d);
+                                            instr.alu.saturate_d, 0, true);
                     break;
                 case SubOp::Sqrt:
                     regs.SetRegisterToFloat(instr.gpr0, 0, "sqrt(" + op_a + ')', 1, 1,
-                                            instr.alu.saturate_d);
+                                            instr.alu.saturate_d, 0, true);
                     break;
                 default:
                     LOG_CRITICAL(HW_GPU, "Unhandled MUFU sub op: {0:x}",
@@ -1573,7 +1587,7 @@ private:
                 regs.SetRegisterToFloat(instr.gpr0, 0,
                                         '(' + condition + ") ? min(" + parameters + ") : max(" +
                                             parameters + ')',
-                                        1, 1);
+                                        1, 1, false, 0, true);
                 break;
             }
             case OpCode::Id::RRO_C:
@@ -1602,7 +1616,7 @@ private:
                 regs.SetRegisterToFloat(instr.gpr0, 0,
                                         regs.GetRegisterAsFloat(instr.gpr8) + " * " +
                                             GetImmediate32(instr),
-                                        1, 1, instr.fmul32.saturate);
+                                        1, 1, instr.fmul32.saturate, 0, true);
                 break;
             }
             case OpCode::Id::FADD32I: {
@@ -1625,7 +1639,7 @@ private:
                     op_b = "-(" + op_b + ')';
                 }
 
-                regs.SetRegisterToFloat(instr.gpr0, 0, op_a + " + " + op_b, 1, 1);
+                regs.SetRegisterToFloat(instr.gpr0, 0, op_a + " + " + op_b, 1, 1, false, 0, true);
                 break;
             }
             }
@@ -2087,8 +2101,9 @@ private:
             }
             }
 
-            regs.SetRegisterToFloat(instr.gpr0, 0, op_a + " * " + op_b + " + " + op_c, 1, 1,
-                                    instr.alu.saturate_d);
+            regs.SetRegisterToFloat(instr.gpr0, 0, "fma(" + op_a + ", " + op_b + ", " + op_c + ')',
+                                    1, 1, instr.alu.saturate_d, 0, true);
+
             break;
         }
         case OpCode::Type::Hfma2: {

src/video_core/renderer_opengl/gl_state.cpp

@@ -11,9 +11,10 @@
 namespace OpenGL {
 
 OpenGLState OpenGLState::cur_state;
-
+bool OpenGLState::s_rgb_used;
 OpenGLState::OpenGLState() {
     // These all match default OpenGL values
+    framebuffer_srgb.enabled = false;
     cull.enabled = false;
     cull.mode = GL_BACK;
     cull.front_face = GL_CCW;
@@ -24,6 +25,9 @@ OpenGLState::OpenGLState() {
     depth.depth_range_near = 0.0f;
     depth.depth_range_far = 1.0f;
 
+    primitive_restart.enabled = false;
+    primitive_restart.index = 0;
+
     color_mask.red_enabled = GL_TRUE;
     color_mask.green_enabled = GL_TRUE;
     color_mask.blue_enabled = GL_TRUE;
@@ -86,6 +90,16 @@ OpenGLState::OpenGLState() {
 }
 
 void OpenGLState::Apply() const {
+    // sRGB
+    if (framebuffer_srgb.enabled != cur_state.framebuffer_srgb.enabled) {
+        if (framebuffer_srgb.enabled) {
+            // Track if sRGB is used
+            s_rgb_used = true;
+            glEnable(GL_FRAMEBUFFER_SRGB);
+        } else {
+            glDisable(GL_FRAMEBUFFER_SRGB);
+        }
+    }
     // Culling
     if (cull.enabled != cur_state.cull.enabled) {
         if (cull.enabled) {
@@ -127,6 +141,18 @@ void OpenGLState::Apply() const {
         glDepthRange(depth.depth_range_near, depth.depth_range_far);
     }
 
+    // Primitive restart
+    if (primitive_restart.enabled != cur_state.primitive_restart.enabled) {
+        if (primitive_restart.enabled) {
+            glEnable(GL_PRIMITIVE_RESTART);
+        } else {
+            glDisable(GL_PRIMITIVE_RESTART);
+        }
+    }
+    if (primitive_restart.index != cur_state.primitive_restart.index) {
+        glPrimitiveRestartIndex(primitive_restart.index);
+    }
+
     // Color mask
     if (color_mask.red_enabled != cur_state.color_mask.red_enabled ||
         color_mask.green_enabled != cur_state.color_mask.green_enabled ||

src/video_core/renderer_opengl/gl_state.h

@@ -35,6 +35,10 @@ constexpr TextureUnit ProcTexDiffLUT{9};
 
 class OpenGLState {
 public:
+    struct {
+        bool enabled; // GL_FRAMEBUFFER_SRGB
+    } framebuffer_srgb;
+
     struct {
         bool enabled;      // GL_CULL_FACE
         GLenum mode;       // GL_CULL_FACE_MODE
@@ -49,6 +53,11 @@ public:
         GLfloat depth_range_far;  // GL_DEPTH_RANGE
     } depth;
 
+    struct {
+        bool enabled;
+        GLuint index;
+    } primitive_restart; // GL_PRIMITIVE_RESTART
+
     struct {
         GLboolean red_enabled;
         GLboolean green_enabled;
@@ -156,7 +165,12 @@ public:
     static OpenGLState GetCurState() {
         return cur_state;
     }
-
+    static bool GetsRGBUsed() {
+        return s_rgb_used;
+    }
+    static void ClearsRGBUsed() {
+        s_rgb_used = false;
+    }
     /// Apply this state as the current OpenGL state
     void Apply() const;
 
@@ -171,6 +185,9 @@ public:
 
 private:
     static OpenGLState cur_state;
+    // Workaround for sRGB problems caused by
+    // QT not supporting srgb output
+    static bool s_rgb_used;
 };
 
 } // namespace OpenGL

src/video_core/renderer_opengl/renderer_opengl.cpp

@@ -283,7 +283,8 @@ void RendererOpenGL::CreateRasterizer() {
     if (rasterizer) {
         return;
     }
-
+    // Initialize sRGB Usage
+    OpenGLState::ClearsRGBUsed();
     rasterizer = std::make_unique<RasterizerOpenGL>(render_window, screen_info);
 }
 
@@ -356,13 +357,20 @@ void RendererOpenGL::DrawScreenTriangles(const ScreenInfo& screen_info, float x,
 
     state.texture_units[0].texture = screen_info.display_texture;
     state.texture_units[0].swizzle = {GL_RED, GL_GREEN, GL_BLUE, GL_ALPHA};
+    // Workaround brigthness problems in SMO by enabling sRGB in the final output
+    // if it has been used in the frame
+    // Needed because of this bug in QT
+    // QTBUG-50987
+    state.framebuffer_srgb.enabled = OpenGLState::GetsRGBUsed();
     state.Apply();
-
     glBufferSubData(GL_ARRAY_BUFFER, 0, sizeof(vertices), vertices.data());
     glDrawArrays(GL_TRIANGLE_STRIP, 0, 4);
-
+    // restore default state
+    state.framebuffer_srgb.enabled = false;
     state.texture_units[0].texture = 0;
     state.Apply();
+    // Clear sRGB state for the next frame
+    OpenGLState::ClearsRGBUsed();
 }
 
 /**

src/video_core/renderer_opengl/utils.cpp

@@ -0,0 +1,38 @@
+// Copyright 2014 Citra Emulator Project
+// Licensed under GPLv2 or any later version
+// Refer to the license.txt file included.
+
+#include <string>
+#include <fmt/format.h>
+#include <glad/glad.h>
+#include "common/common_types.h"
+#include "video_core/renderer_opengl/utils.h"
+
+namespace OpenGL {
+
+void LabelGLObject(GLenum identifier, GLuint handle, VAddr addr, std::string extra_info) {
+    if (!GLAD_GL_KHR_debug) {
+        return; // We don't need to throw an error as this is just for debugging
+    }
+    const std::string nice_addr = fmt::format("0x{:016x}", addr);
+    std::string object_label;
+
+    if (extra_info.empty()) {
+        switch (identifier) {
+        case GL_TEXTURE:
+            object_label = "Texture@" + nice_addr;
+            break;
+        case GL_PROGRAM:
+            object_label = "Shader@" + nice_addr;
+            break;
+        default:
+            object_label = fmt::format("Object(0x{:x})@{}", identifier, nice_addr);
+            break;
+        }
+    } else {
+        object_label = extra_info + '@' + nice_addr;
+    }
+    glObjectLabel(identifier, handle, -1, static_cast<const GLchar*>(object_label.c_str()));
+}
+
+} // namespace OpenGL

src/video_core/renderer_opengl/utils.h

@@ -0,0 +1,15 @@
+// Copyright 2014 Citra Emulator Project
+// Licensed under GPLv2 or any later version
+// Refer to the license.txt file included.
+
+#pragma once
+
+#include <string>
+#include <glad/glad.h>
+#include "common/common_types.h"
+
+namespace OpenGL {
+
+void LabelGLObject(GLenum identifier, GLuint handle, VAddr addr, std::string extra_info = "");
+
+} // namespace OpenGL

src/video_core/textures/texture.h

@@ -173,6 +173,7 @@ struct TICEntry {
     };
     union {
         BitField<0, 16, u32> width_minus_1;
+        BitField<22, 1, u32> srgb_conversion;
         BitField<23, 4, TextureType> texture_type;
     };
     union {
@@ -227,6 +228,10 @@ struct TICEntry {
         return header_version == TICHeaderVersion::BlockLinear ||
                header_version == TICHeaderVersion::BlockLinearColorKey;
     }
+
+    bool IsSrgbConversionEnabled() const {
+        return srgb_conversion != 0;
+    }
 };
 static_assert(sizeof(TICEntry) == 0x20, "TICEntry has wrong size");
 

src/video_core/utils.h

@@ -161,30 +161,4 @@ static inline void MortonCopyPixels128(u32 width, u32 height, u32 bytes_per_pixe
     }
 }
 
-static void LabelGLObject(GLenum identifier, GLuint handle, VAddr addr,
-                          std::string extra_info = "") {
-    if (!GLAD_GL_KHR_debug) {
-        return; // We don't need to throw an error as this is just for debugging
-    }
-    const std::string nice_addr = fmt::format("0x{:016x}", addr);
-    std::string object_label;
-
-    if (extra_info.empty()) {
-        switch (identifier) {
-        case GL_TEXTURE:
-            object_label = "Texture@" + nice_addr;
-            break;
-        case GL_PROGRAM:
-            object_label = "Shader@" + nice_addr;
-            break;
-        default:
-            object_label = fmt::format("Object(0x{:x})@{}", identifier, nice_addr);
-            break;
-        }
-    } else {
-        object_label = extra_info + '@' + nice_addr;
-    }
-    glObjectLabel(identifier, handle, -1, static_cast<const GLchar*>(object_label.c_str()));
-}
-
 } // namespace VideoCore