show title splash while the game is loading

src/core/file_format/splash.cpp

@@ -0,0 +1,42 @@
+// SPDX-FileCopyrightText: Copyright 2024 shadPS4 Emulator Project
+// SPDX-License-Identifier: GPL-2.0-or-later
+
+#include <fstream>
+
+#include "common/assert.h"
+#include "common/io_file.h"
+#include "splash.h"
+
+#define STB_IMAGE_IMPLEMENTATION
+#define STBI_ONLY_PNG
+#define STBI_NO_STDIO
+#include "third-party/stb_image.h"
+
+bool Splash::Open(const std::string& filepath) {
+    ASSERT_MSG(filepath.ends_with(".png"), "Unexpected file format passed");
+
+    Common::FS::IOFile file(filepath, Common::FS::FileAccessMode::Read);
+    if (!file.IsOpen()) {
+        return false;
+    }
+
+    std::vector<u8> png_file{};
+    const auto png_size = file.GetSize();
+    png_file.resize(png_size);
+    file.Seek(0);
+    file.Read(png_file);
+
+    auto* img_mem = stbi_load_from_memory(png_file.data(), png_file.size(),
+                                          reinterpret_cast<int*>(&img_info.width),
+                                          reinterpret_cast<int*>(&img_info.height),
+                                          reinterpret_cast<int*>(&img_info.num_channels), 4);
+    if (!img_mem) {
+        return false;
+    }
+
+    const auto img_size = img_info.GetSizeBytes();
+    img_data.resize(img_size);
+    std::memcpy(img_data.data(), img_mem, img_size);
+    stbi_image_free(img_mem);
+    return true;
+}

src/core/file_format/splash.h

@@ -0,0 +1,41 @@
+// SPDX-FileCopyrightText: Copyright 2024 shadPS4 Emulator Project
+// SPDX-License-Identifier: GPL-2.0-or-later
+
+#pragma once
+
+#include <string>
+#include <vector>
+#include "common/types.h"
+
+class Splash {
+public:
+    struct ImageInfo {
+        u32 width;
+        u32 height;
+        u32 num_channels;
+
+        u32 GetSizeBytes() const {
+            return width * height * 4; // we always forcing rgba8 for simplicity
+        }
+    };
+
+    Splash() = default;
+    ~Splash() = default;
+
+    bool Open(const std::string& filepath);
+    [[nodiscard]] bool IsLoaded() const {
+        return img_data.size();
+    }
+
+    const auto& GetImageData() const {
+        return img_data;
+    }
+
+    ImageInfo GetImageInfo() const {
+        return img_info;
+    }
+
+private:
+    ImageInfo img_info{};
+    std::vector<u8> img_data{};
+};

src/core/libraries/system/systemservice.cpp

@@ -1,6 +1,7 @@
 // SPDX-FileCopyrightText: Copyright 2024 shadPS4 Emulator Project
 // SPDX-License-Identifier: GPL-2.0-or-later
 
+#include "common/config.h"
 #include "common/logging/log.h"
 #include "core/libraries/error_codes.h"
 #include "core/libraries/libs.h"
@@ -8,6 +9,12 @@
 
 namespace Libraries::SystemService {
 
+bool g_splash_status{true};
+
+bool IsSplashVisible() {
+    return Config::showSplash() && g_splash_status;
+}
+
 int PS4_SYSV_ABI sceAppMessagingClearEventFlag() {
     LOG_ERROR(Lib_SystemService, "(STUBBED) called");
     return ORBIS_OK;
@@ -1787,7 +1794,8 @@ int PS4_SYSV_ABI sceSystemServiceGetVersionNumberOfCameraCalibrationData() {
 }
 
 s32 PS4_SYSV_ABI sceSystemServiceHideSplashScreen() {
-    LOG_WARNING(Lib_SystemService, "called");
+    LOG_INFO(Lib_SystemService, "called");
+    g_splash_status = false;
     return ORBIS_OK;
 }
 

src/core/libraries/system/systemservice.h

@@ -102,6 +102,8 @@ struct OrbisSystemServiceDisplaySafeAreaInfo {
     uint8_t reserved[128];
 };
 
+bool IsSplashVisible();
+
 int PS4_SYSV_ABI sceAppMessagingClearEventFlag();
 int PS4_SYSV_ABI sceAppMessagingReceiveMsg();
 int PS4_SYSV_ABI sceAppMessagingSendMsg();

src/core/libraries/videoout/driver.cpp

@@ -167,6 +167,7 @@ void VideoOutDriver::Flip(std::chrono::microseconds timeout) {
         std::unique_lock lock{mutex};
         submit_cond.wait_for(lock, timeout, [&] { return !requests.empty(); });
         if (requests.empty()) {
+            renderer->ShowSplash();
             return;
         }
 
@@ -175,8 +176,11 @@ void VideoOutDriver::Flip(std::chrono::microseconds timeout) {
         requests.pop();
     }
 
-    // Present the frame.
-    renderer->Present(req.frame);
+    if (!renderer->ShowSplash(
+            req.frame)) { // Whatever the game is rendering show splash if it is active
+        // Present the frame.
+        renderer->Present(req.frame);
+    }
 
     std::scoped_lock lock{mutex};