More modules (#99)

* added dummy sceAudio lib

* added lseek in file_system

* updated sdl3

* forgot sdl3 in cmake

* cmake is case sensitive in linux

* fixed SDL_CreateWindowWithPosition

* fixed vulkan issues with latest sdl3

* some progress in sceAudio

* improvements in audio

* more sound improvements

* first working sound output , from openorbis sound demo

* updated sdl3 , zlib-ng can now be build with msvc+clangci

* fixed cmake

* fix for audio buffering

* clang format fix

* format fix

* better error handling for sceAudioOutput

.gitmodules

@@ -1,7 +1,3 @@
-[submodule "third-party/SDL"]
-	path = third-party/SDL
-	url = https://github.com/libsdl-org/SDL
-	shallow = true
 [submodule "third-party/fmt"]
 	path = third-party/fmt
 	url = https://github.com/fmtlib/fmt.git
@@ -52,6 +48,6 @@
 [submodule "externals/zlib-ng"]
 	path = externals/zlib-ng
 	url = https://github.com/shadps4-emu/ext-zlib-ng.git
-[submodule "externals/zlib-ng-win"]
+[submodule "externals/sdl3"]
-	path = externals/zlib-ng-win
+	path = externals/sdl3
-	url = https://github.com/shadps4-emu/ext-zlib-ng-win.git
+	url = https://github.com/shadps4-emu/ext-SDL.git

CMakeLists.txt

@@ -93,6 +93,9 @@ add_subdirectory(externals)
 add_subdirectory(third-party)
 include_directories(src)
 
+set(AUDIO_CORE src/audio_core/sdl_audio.cpp 
+               src/audio_core/sdl_audio.h
+)
 set(LIBRARIES src/core/libraries/library_common.h
               src/core/libraries/error_codes.h
               src/core/libraries/libscecommondialog.cpp
@@ -105,6 +108,8 @@ set(LIBRARIES  src/core/libraries/library_common.h
               src/core/libraries/libscesystemservice.h
               src/core/libraries/libsceuserservice.cpp
               src/core/libraries/libsceuserservice.h
+              src/core/libraries/libsceaudioout.cpp
+              src/core/libraries/libsceaudioout.h
 )
 
 set(LIBC_SOURCES src/core/hle/libraries/libc/libc.cpp
@@ -243,6 +248,7 @@ qt_add_executable(shadps4
 )
 else()
 add_executable(shadps4
+    ${AUDIO_CORE}
     ${LIBC_SOURCES}
     ${PAD_SOURCES}
     ${FILESYSTEM_SOURCES}
@@ -346,15 +352,11 @@ set_target_properties(shadps4 PROPERTIES
 )
 endif()
 
-if(CMAKE_BUILD_TYPE STREQUAL "Debug")
 add_custom_command(TARGET shadps4 POST_BUILD
    COMMAND ${CMAKE_COMMAND} -E copy_if_different
-     "${PROJECT_SOURCE_DIR}/externals/zlib-ng-win/bin/zlib-ngd2.dll" $<TARGET_FILE_DIR:shadps4>)
+     $<TARGET_FILE:zlib>
-else()
+     $<TARGET_FILE_DIR:shadps4>
-add_custom_command(TARGET shadps4 POST_BUILD
+)
-   COMMAND ${CMAKE_COMMAND} -E copy_if_different
-     "${PROJECT_SOURCE_DIR}/externals/zlib-ng-win/bin/zlib-ng2.dll" $<TARGET_FILE_DIR:shadps4>)
-endif()
 
 if(NOT ENABLE_QT_GUI)
 add_custom_command(TARGET shadps4 POST_BUILD

externals/CMakeLists.txt

@@ -16,22 +16,21 @@ if (CMAKE_CXX_COMPILER_ID STREQUAL "Clang" AND MSVC)
     # CryptoPP
     add_subdirectory(cryptoppwin EXCLUDE_FROM_ALL)
     target_include_directories(cryptoppwin INTERFACE cryptoppwin/include)
-
-    # Zlib-Ng
-    add_subdirectory(zlib-ng-win EXCLUDE_FROM_ALL)
-    target_include_directories(zlib INTERFACE zlib-ng-win/include)
 else()
     # CryptoPP
     set(CRYPTOPP_BUILD_TESTING OFF)
     set(CRYPTOPP_SOURCES ${CMAKE_CURRENT_SOURCE_DIR}/cryptopp/)
     add_subdirectory(cryptopp-cmake EXCLUDE_FROM_ALL)
-
-    # Zlib-Ng
-    set(ZLIB_ENABLE_TESTS OFF)
-    set(WITH_GTEST OFF)
-    set(WITH_NEW_STRATEGIES ON)
-    set(WITH_NATIVE_INSTRUCTIONS ON)
-    add_subdirectory(zlib-ng)
 endif()
 
+# Zlib-Ng
+set(ZLIB_ENABLE_TESTS OFF)
+set(WITH_GTEST OFF)
+set(WITH_NEW_STRATEGIES ON)
+set(WITH_NATIVE_INSTRUCTIONS ON)
+add_subdirectory(zlib-ng)
 
+if(NOT ENABLE_QT_GUI)
+# SDL3
+add_subdirectory(sdl3 EXCLUDE_FROM_ALL)
+endif()

externals/sdl3

@@ -0,0 +1 @@
+Subproject commit 70b0d33106e98176bf44de5d301855d49587fa50

externals/zlib-ng

@@ -1 +1 @@
-Subproject commit 3ac71d9e2f860ac3634b43a99892255eb39179cf
+Subproject commit af8169a724bd607e4e8c7de2a705ab17206217d6

externals/zlib-ng-win

@@ -1 +0,0 @@
-Subproject commit 6ad2df3e3c2e58c009f70936a8c510b939bca1d9

src/audio_core/sdl_audio.cpp

@@ -0,0 +1,111 @@
+// SPDX-FileCopyrightText: Copyright 2024 shadPS4 Emulator Project
+// SPDX-License-Identifier: GPL-2.0-or-later
+
+#include <common/assert.h>
+#include <core/libraries/error_codes.h>
+#include "sdl_audio.h"
+
+namespace Audio {
+
+int SDLAudio::AudioInit() {
+    return SDL_InitSubSystem(SDL_INIT_AUDIO);
+}
+
+int SDLAudio::AudioOutOpen(int type, u32 samples_num, u32 freq,
+                           Libraries::AudioOut::OrbisAudioOutParam format) {
+    using Libraries::AudioOut::OrbisAudioOutParam;
+    std::scoped_lock lock{m_mutex};
+    for (int id = 0; id < portsOut.size(); id++) {
+        auto& port = portsOut[id];
+        if (!port.isOpen) {
+            port.isOpen = true;
+            port.type = type;
+            port.samples_num = samples_num;
+            port.freq = freq;
+            port.format = format;
+            SDL_AudioFormat sampleFormat;
+            switch (format) {
+            case OrbisAudioOutParam::ORBIS_AUDIO_OUT_PARAM_FORMAT_S16_MONO:
+                sampleFormat = SDL_AUDIO_S16;
+                port.channels_num = 1;
+                port.sample_size = 2;
+                break;
+            case OrbisAudioOutParam::ORBIS_AUDIO_OUT_PARAM_FORMAT_FLOAT_MONO:
+                sampleFormat = SDL_AUDIO_F32;
+                port.channels_num = 1;
+                port.sample_size = 4;
+                break;
+            case OrbisAudioOutParam::ORBIS_AUDIO_OUT_PARAM_FORMAT_S16_STEREO:
+                sampleFormat = SDL_AUDIO_S16;
+                port.channels_num = 2;
+                port.sample_size = 2;
+                break;
+            case OrbisAudioOutParam::ORBIS_AUDIO_OUT_PARAM_FORMAT_FLOAT_STEREO:
+                sampleFormat = SDL_AUDIO_F32;
+                port.channels_num = 2;
+                port.sample_size = 4;
+                break;
+            case OrbisAudioOutParam::ORBIS_AUDIO_OUT_PARAM_FORMAT_S16_8CH:
+                sampleFormat = SDL_AUDIO_S16;
+                port.channels_num = 8;
+                port.sample_size = 2;
+                break;
+            case OrbisAudioOutParam::ORBIS_AUDIO_OUT_PARAM_FORMAT_FLOAT_8CH:
+                sampleFormat = SDL_AUDIO_F32;
+                port.channels_num = 8;
+                port.sample_size = 4;
+                break;
+            case OrbisAudioOutParam::ORBIS_AUDIO_OUT_PARAM_FORMAT_S16_8CH_STD:
+                sampleFormat = SDL_AUDIO_S16;
+                port.channels_num = 8;
+                port.sample_size = 2;
+                break;
+            case OrbisAudioOutParam::ORBIS_AUDIO_OUT_PARAM_FORMAT_FLOAT_8CH_STD:
+                sampleFormat = SDL_AUDIO_F32;
+                port.channels_num = 8;
+                port.sample_size = 4;
+                break;
+            default:
+                UNREACHABLE_MSG("Unknown format");
+            }
+
+            for (int i = 0; i < port.channels_num; i++) {
+                port.volume[i] = Libraries::AudioOut::SCE_AUDIO_OUT_VOLUME_0DB;
+            }
+
+            SDL_AudioSpec fmt;
+            SDL_zero(fmt);
+            fmt.format = sampleFormat;
+            fmt.channels = port.channels_num;
+            fmt.freq = 48000;
+            port.stream =
+                SDL_OpenAudioDeviceStream(SDL_AUDIO_DEVICE_DEFAULT_OUTPUT, &fmt, NULL, NULL);
+            SDL_ResumeAudioDevice(SDL_GetAudioStreamDevice(port.stream));
+            return id + 1;
+        }
+    }
+
+    return -1; // all ports are used
+}
+
+s32 SDLAudio::AudioOutOutput(s32 handle, const void* ptr) {
+    std::scoped_lock lock{m_mutex};
+    auto& port = portsOut[handle - 1];
+    if (!port.isOpen) {
+        return ORBIS_AUDIO_OUT_ERROR_INVALID_PORT;
+    }
+    if (ptr == nullptr) {
+        return 0;
+    }
+    // TODO mixing channels
+    int result = SDL_PutAudioStreamData(port.stream, ptr,
+                                        port.samples_num * port.sample_size * port.channels_num);
+    // TODO find a correct value 8192 is estimated
+    while (SDL_GetAudioStreamAvailable(port.stream) > 8192) {
+        SDL_Delay(0);
+    }
+
+    return result;
+}
+
+} // namespace Audio

src/audio_core/sdl_audio.h

@@ -0,0 +1,41 @@
+// SPDX-FileCopyrightText: Copyright 2024 shadPS4 Emulator Project
+// SPDX-License-Identifier: GPL-2.0-or-later
+
+#pragma once
+
+#include <mutex>
+#include <SDL.h>
+#include <core/libraries/libsceaudioout.h>
+
+#include "src/common/types.h"
+
+namespace Audio {
+
+class SDLAudio {
+public:
+    SDLAudio() = default;
+    virtual ~SDLAudio() = default;
+
+    int AudioInit();
+    int AudioOutOpen(int type, u32 samples_num, u32 freq,
+                     Libraries::AudioOut::OrbisAudioOutParam format);
+    s32 AudioOutOutput(s32 handle, const void* ptr);
+
+private:
+    struct PortOut {
+        bool isOpen = false;
+        int type = 0;
+        u32 samples_num = 0;
+        u8 sample_size = 0;
+        u32 freq = 0;
+        u32 format = -1;
+        int channels_num = 0;
+        int volume[8] = {};
+        SDL_AudioStream* stream = nullptr;
+    };
+    std::mutex m_mutex;
+    std::array<PortOut, 22> portsOut; // main up to 8 ports , BGM 1 port , voice up to 4 ports ,
+                                      // personal up to 4 ports , padspk up to 5 ports , aux 1 port
+};
+
+} // namespace Audio

src/common/logging/filter.cpp

@@ -87,6 +87,7 @@ bool ParseFilterRule(Filter& instance, Iterator begin, Iterator end) {
     SUB(Lib, VideoOut)                                                                             \
     SUB(Lib, CommonDlg)                                                                            \
     SUB(Lib, MsgDlg)                                                                               \
+    SUB(Lib, AudioOut)                                                                             \
     CLS(Frontend)                                                                                  \
     CLS(Render)                                                                                    \
     SUB(Render, Vulkan)                                                                            \

src/common/logging/types.h

@@ -54,6 +54,7 @@ enum class Class : u8 {
     Lib_VideoOut,      ///< The LibSceVideoOut implementation.
     Lib_CommonDlg,     ///< The LibSceCommonDialog implementation.
     Lib_MsgDlg,        ///< The LibSceMsgDialog implementation.
+    Lib_AudioOut,      ///< The LibSceAudioOut implementation.
     Frontend,          ///< Emulator UI
     Render,            ///< Video Core
     Render_Vulkan,     ///< Vulkan backend

src/core/hle/libraries/libkernel/file_system.cpp

@@ -51,10 +51,34 @@ size_t PS4_SYSV_ABI _readv(int d, const SceKernelIovec* iov, int iovcnt) {
     return total_read;
 }
 
+s64 PS4_SYSV_ABI lseek(int d, s64 offset, int whence) {
+    auto* h = Common::Singleton<Core::FileSys::HandleTable>::Instance();
+    auto* file = h->GetFile(d);
+
+    file->m_mutex.lock();
+
+    if (whence == 1) {
+        offset = static_cast<int64_t>(file->f.Tell()) + offset;
+        whence = 0;
+    }
+
+    if (whence == 2) {
+        offset = static_cast<int64_t>(file->f.GetSize()) + offset;
+        whence = 0;
+    }
+
+    file->f.Seek(offset);
+    auto pos = static_cast<int64_t>(file->f.Tell());
+
+    file->m_mutex.unlock();
+    return pos;
+}
+
 void fileSystemSymbolsRegister(Loader::SymbolsResolver* sym) {
     LIB_FUNCTION("1G3lF1Gg1k8", "libkernel", 1, "libkernel", 1, 1, sceKernelOpen);
     LIB_FUNCTION("wuCroIGjt2g", "libScePosix", 1, "libkernel", 1, 1, posix_open);
     LIB_FUNCTION("+WRlkKjZvag", "libkernel", 1, "libkernel", 1, 1, _readv);
+    LIB_FUNCTION("Oy6IpwgtYOk", "libkernel", 1, "libkernel", 1, 1, lseek);
 
     // openOrbis (to check if it is valid out of OpenOrbis
     LIB_FUNCTION("6c3rCVE-fTU", "libkernel", 1, "libkernel", 1, 1,

src/core/hle/libraries/libkernel/file_system.h

@@ -19,6 +19,7 @@ struct SceKernelIovec {
 int PS4_SYSV_ABI sceKernelOpen(const char* path, int flags, /* SceKernelMode*/ u16 mode);
 
 int PS4_SYSV_ABI posix_open(const char* path, int flags, /* SceKernelMode*/ u16 mode);
+s64 PS4_SYSV_ABI lseek(int d, s64 offset, int whence);
 
 void fileSystemSymbolsRegister(Loader::SymbolsResolver* sym);
 

src/core/hle/libraries/libs.cpp

@@ -7,6 +7,7 @@
 #include "core/hle/libraries/libpad/pad.h"
 #include "core/hle/libraries/libs.h"
 #include "core/hle/libraries/libscegnmdriver/libscegnmdriver.h"
+#include "src/core/libraries/libsceaudioout.h"
 #include "src/core/libraries/libscecommondialog.h"
 #include "src/core/libraries/libscemsgdialog.h"
 #include "src/core/libraries/libscesystemservice.h"
@@ -26,6 +27,7 @@ void InitHLELibs(Core::Loader::SymbolsResolver* sym) {
     Libraries::SystemService::RegisterlibSceSystemService(sym);
     Libraries::CommonDialog::RegisterlibSceCommonDialog(sym);
     Libraries::MsgDialog::RegisterlibSceMsgDialog(sym);
+    Libraries::AudioOut::RegisterlibSceAudioOut(sym);
 }
 
 } // namespace OldLibraries

src/core/libraries/libsceaudioout.cpp

@@ -0,0 +1,573 @@
+// SPDX-FileCopyrightText: Copyright 2024 shadPS4 Emulator Project
+// SPDX-License-Identifier: GPL-2.0-or-later
+
+// Generated By moduleGenerator
+#include <common/singleton.h>
+#include <magic_enum.hpp>
+#include "common/logging/log.h"
+#include "error_codes.h"
+#include "libsceaudioout.h"
+#include "src/audio_core/sdl_audio.h"
+
+namespace Libraries::AudioOut {
+
+static std::unique_ptr<Audio::SDLAudio> audio;
+
+static std::string_view GetAudioOutPort(u32 port) {
+    switch (port) {
+    case ORBIS_AUDIO_OUT_PORT_TYPE_MAIN:
+        return "MAIN";
+    case ORBIS_AUDIO_OUT_PORT_TYPE_BGM:
+        return "BGM";
+    case ORBIS_AUDIO_OUT_PORT_TYPE_VOICE:
+        return "VOICE";
+    case ORBIS_AUDIO_OUT_PORT_TYPE_PERSONAL:
+        return "PERSONAL";
+    case ORBIS_AUDIO_OUT_PORT_TYPE_PADSPK:
+        return "PADSPK";
+    case ORBIS_AUDIO_OUT_PORT_TYPE_AUX:
+        return "AUX";
+    default:
+        return "INVALID";
+    }
+}
+
+static std::string_view GetAudioOutParam(u32 param) {
+    switch (param) {
+    case ORBIS_AUDIO_OUT_PARAM_FORMAT_S16_MONO:
+        return "S16_MONO";
+    case ORBIS_AUDIO_OUT_PARAM_FORMAT_S16_STEREO:
+        return "S16_STEREO";
+    case ORBIS_AUDIO_OUT_PARAM_FORMAT_S16_8CH:
+        return "S16_8CH";
+    case ORBIS_AUDIO_OUT_PARAM_FORMAT_FLOAT_MONO:
+        return "FLOAT_MONO";
+    case ORBIS_AUDIO_OUT_PARAM_FORMAT_FLOAT_STEREO:
+        return "FLOAT_STEREO";
+    case ORBIS_AUDIO_OUT_PARAM_FORMAT_FLOAT_8CH:
+        return "FLOAT_8CH";
+    case ORBIS_AUDIO_OUT_PARAM_FORMAT_S16_8CH_STD:
+        return "S16_8CH_STD";
+    case ORBIS_AUDIO_OUT_PARAM_FORMAT_FLOAT_8CH_STD:
+        return "FLOAT_8CH_STD";
+    default:
+        return "INVALID";
+    }
+}
+
+int PS4_SYSV_ABI sceAudioOutDeviceIdOpen() {
+    LOG_ERROR(Lib_AudioOut, "(STUBBED) called");
+    return ORBIS_OK;
+}
+
+int PS4_SYSV_ABI sceAudioDeviceControlGet() {
+    LOG_ERROR(Lib_AudioOut, "(STUBBED) called");
+    return ORBIS_OK;
+}
+
+int PS4_SYSV_ABI sceAudioDeviceControlSet() {
+    LOG_ERROR(Lib_AudioOut, "(STUBBED) called");
+    return ORBIS_OK;
+}
+
+int PS4_SYSV_ABI sceAudioOutA3dControl() {
+    LOG_ERROR(Lib_AudioOut, "(STUBBED) called");
+    return ORBIS_OK;
+}
+
+int PS4_SYSV_ABI sceAudioOutA3dExit() {
+    LOG_ERROR(Lib_AudioOut, "(STUBBED) called");
+    return ORBIS_OK;
+}
+
+int PS4_SYSV_ABI sceAudioOutA3dInit() {
+    LOG_ERROR(Lib_AudioOut, "(STUBBED) called");
+    return ORBIS_OK;
+}
+
+int PS4_SYSV_ABI sceAudioOutAttachToApplicationByPid() {
+    LOG_ERROR(Lib_AudioOut, "(STUBBED) called");
+    return ORBIS_OK;
+}
+
+int PS4_SYSV_ABI sceAudioOutChangeAppModuleState() {
+    LOG_ERROR(Lib_AudioOut, "(STUBBED) called");
+    return ORBIS_OK;
+}
+
+int PS4_SYSV_ABI sceAudioOutClose() {
+    LOG_ERROR(Lib_AudioOut, "(STUBBED) called");
+    return ORBIS_OK;
+}
+
+int PS4_SYSV_ABI sceAudioOutDetachFromApplicationByPid() {
+    LOG_ERROR(Lib_AudioOut, "(STUBBED) called");
+    return ORBIS_OK;
+}
+
+int PS4_SYSV_ABI sceAudioOutExConfigureOutputMode() {
+    LOG_ERROR(Lib_AudioOut, "(STUBBED) called");
+    return ORBIS_OK;
+}
+
+int PS4_SYSV_ABI sceAudioOutExGetSystemInfo() {
+    LOG_ERROR(Lib_AudioOut, "(STUBBED) called");
+    return ORBIS_OK;
+}
+
+int PS4_SYSV_ABI sceAudioOutExPtClose() {
+    LOG_ERROR(Lib_AudioOut, "(STUBBED) called");
+    return ORBIS_OK;
+}
+
+int PS4_SYSV_ABI sceAudioOutExPtGetLastOutputTime() {
+    LOG_ERROR(Lib_AudioOut, "(STUBBED) called");
+    return ORBIS_OK;
+}
+
+int PS4_SYSV_ABI sceAudioOutExPtOpen() {
+    LOG_ERROR(Lib_AudioOut, "(STUBBED) called");
+    return ORBIS_OK;
+}
+
+int PS4_SYSV_ABI sceAudioOutExSystemInfoIsSupportedAudioOutExMode() {
+    LOG_ERROR(Lib_AudioOut, "(STUBBED) called");
+    return ORBIS_OK;
+}
+
+int PS4_SYSV_ABI sceAudioOutGetFocusEnablePid() {
+    LOG_ERROR(Lib_AudioOut, "(STUBBED) called");
+    return ORBIS_OK;
+}
+
+int PS4_SYSV_ABI sceAudioOutGetHandleStatusInfo() {
+    LOG_ERROR(Lib_AudioOut, "(STUBBED) called");
+    return ORBIS_OK;
+}
+
+int PS4_SYSV_ABI sceAudioOutGetInfo() {
+    LOG_ERROR(Lib_AudioOut, "(STUBBED) called");
+    return ORBIS_OK;
+}
+
+int PS4_SYSV_ABI sceAudioOutGetInfoOpenNum() {
+    LOG_ERROR(Lib_AudioOut, "(STUBBED) called");
+    return ORBIS_OK;
+}
+
+int PS4_SYSV_ABI sceAudioOutGetLastOutputTime() {
+    LOG_ERROR(Lib_AudioOut, "(STUBBED) called");
+    return ORBIS_OK;
+}
+
+int PS4_SYSV_ABI sceAudioOutGetPortState() {
+    LOG_ERROR(Lib_AudioOut, "(STUBBED) called");
+    return ORBIS_OK;
+}
+
+int PS4_SYSV_ABI sceAudioOutGetSimulatedBusUsableStatusByBusType() {
+    LOG_ERROR(Lib_AudioOut, "(STUBBED) called");
+    return ORBIS_OK;
+}
+
+int PS4_SYSV_ABI sceAudioOutGetSimulatedHandleStatusInfo() {
+    LOG_ERROR(Lib_AudioOut, "(STUBBED) called");
+    return ORBIS_OK;
+}
+
+int PS4_SYSV_ABI sceAudioOutGetSimulatedHandleStatusInfo2() {
+    LOG_ERROR(Lib_AudioOut, "(STUBBED) called");
+    return ORBIS_OK;
+}
+
+int PS4_SYSV_ABI sceAudioOutGetSparkVss() {
+    LOG_ERROR(Lib_AudioOut, "(STUBBED) called");
+    return ORBIS_OK;
+}
+
+int PS4_SYSV_ABI sceAudioOutGetSystemState() {
+    LOG_ERROR(Lib_AudioOut, "(STUBBED) called");
+    return ORBIS_OK;
+}
+
+int PS4_SYSV_ABI sceAudioOutInit() {
+    audio = std::make_unique<Audio::SDLAudio>();
+    u32 result = audio->AudioInit() == 0 ? ORBIS_OK : ORBIS_AUDIO_OUT_ERROR_NOT_INIT;
+    LOG_INFO(Lib_AudioOut, "AudioInit returned {}", result);
+    return result;
+}
+
+int PS4_SYSV_ABI sceAudioOutInitIpmiGetSession() {
+    LOG_ERROR(Lib_AudioOut, "(STUBBED) called");
+    return ORBIS_OK;
+}
+
+int PS4_SYSV_ABI sceAudioOutMasteringGetState() {
+    LOG_ERROR(Lib_AudioOut, "(STUBBED) called");
+    return ORBIS_OK;
+}
+
+int PS4_SYSV_ABI sceAudioOutMasteringInit() {
+    LOG_ERROR(Lib_AudioOut, "(STUBBED) called");
+    return ORBIS_OK;
+}
+
+int PS4_SYSV_ABI sceAudioOutMasteringSetParam() {
+    LOG_ERROR(Lib_AudioOut, "(STUBBED) called");
+    return ORBIS_OK;
+}
+
+int PS4_SYSV_ABI sceAudioOutMasteringTerm() {
+    LOG_ERROR(Lib_AudioOut, "(STUBBED) called");
+    return ORBIS_OK;
+}
+
+int PS4_SYSV_ABI sceAudioOutMbusInit() {
+    LOG_ERROR(Lib_AudioOut, "(STUBBED) called");
+    return ORBIS_OK;
+}
+
+s32 PS4_SYSV_ABI sceAudioOutOpen(UserService::OrbisUserServiceUserId user_id,
+                                 OrbisAudioOutPort port_type, s32 index, u32 length,
+                                 u32 sample_rate, OrbisAudioOutParam param_type) {
+    LOG_INFO(Lib_AudioOut,
+             "AudioOutOpen id = {} port_type = {} index = {} lenght= {} sample_rate = {} "
+             "param_type = {}",
+             user_id, GetAudioOutPort(port_type), index, length, sample_rate,
+             GetAudioOutParam(param_type));
+    if ((port_type < 0 || port_type > 4) && (port_type != 127)) {
+        LOG_ERROR(Lib_AudioOut, "Invalid port type");
+        return ORBIS_AUDIO_OUT_ERROR_INVALID_PORT_TYPE;
+    }
+    if (sample_rate != 48000) {
+        LOG_ERROR(Lib_AudioOut, "Invalid sample rate");
+        return ORBIS_AUDIO_OUT_ERROR_INVALID_SAMPLE_FREQ;
+    }
+    if (param_type < 0 || param_type > 7) {
+        LOG_ERROR(Lib_AudioOut, "Invalid format");
+        return ORBIS_AUDIO_OUT_ERROR_INVALID_FORMAT;
+    }
+    if (length != 256 && length != 512 && length != 768 && length != 1024 && length != 1280 &&
+        length != 1536 && length != 1792 && length != 2048) {
+        LOG_ERROR(Lib_AudioOut, "Invalid length");
+        return ORBIS_AUDIO_OUT_ERROR_INVALID_SIZE;
+    }
+    if (index != 0) {
+        LOG_ERROR(Lib_AudioOut, "index is not valid !=0 {}", index);
+    }
+    int result = audio->AudioOutOpen(port_type, length, sample_rate, param_type);
+    if (result == -1) {
+        LOG_ERROR(Lib_AudioOut, "Audio ports are full");
+        return ORBIS_AUDIO_OUT_ERROR_PORT_FULL;
+    }
+    return result;
+}
+
+int PS4_SYSV_ABI sceAudioOutOpenEx() {
+    LOG_ERROR(Lib_AudioOut, "(STUBBED) called");
+    return ORBIS_OK;
+}
+
+s32 PS4_SYSV_ABI sceAudioOutOutput(s32 handle, const void* ptr) {
+    return audio->AudioOutOutput(handle, ptr);
+}
+
+int PS4_SYSV_ABI sceAudioOutOutputs() {
+    LOG_ERROR(Lib_AudioOut, "(STUBBED) called");
+    return ORBIS_OK;
+}
+
+int PS4_SYSV_ABI sceAudioOutPtClose() {
+    LOG_ERROR(Lib_AudioOut, "(STUBBED) called");
+    return ORBIS_OK;
+}
+
+int PS4_SYSV_ABI sceAudioOutPtGetLastOutputTime() {
+    LOG_ERROR(Lib_AudioOut, "(STUBBED) called");
+    return ORBIS_OK;
+}
+
+int PS4_SYSV_ABI sceAudioOutPtOpen() {
+    LOG_ERROR(Lib_AudioOut, "(STUBBED) called");
+    return ORBIS_OK;
+}
+
+int PS4_SYSV_ABI sceAudioOutSetConnections() {
+    LOG_ERROR(Lib_AudioOut, "(STUBBED) called");
+    return ORBIS_OK;
+}
+
+int PS4_SYSV_ABI sceAudioOutSetConnectionsForUser() {
+    LOG_ERROR(Lib_AudioOut, "(STUBBED) called");
+    return ORBIS_OK;
+}
+
+int PS4_SYSV_ABI sceAudioOutSetDevConnection() {
+    LOG_ERROR(Lib_AudioOut, "(STUBBED) called");
+    return ORBIS_OK;
+}
+
+int PS4_SYSV_ABI sceAudioOutSetHeadphoneOutMode() {
+    LOG_ERROR(Lib_AudioOut, "(STUBBED) called");
+    return ORBIS_OK;
+}
+
+int PS4_SYSV_ABI sceAudioOutSetJediJackVolume() {
+    LOG_ERROR(Lib_AudioOut, "(STUBBED) called");
+    return ORBIS_OK;
+}
+
+int PS4_SYSV_ABI sceAudioOutSetJediSpkVolume() {
+    LOG_ERROR(Lib_AudioOut, "(STUBBED) called");
+    return ORBIS_OK;
+}
+
+int PS4_SYSV_ABI sceAudioOutSetMainOutput() {
+    LOG_ERROR(Lib_AudioOut, "(STUBBED) called");
+    return ORBIS_OK;
+}
+
+int PS4_SYSV_ABI sceAudioOutSetMixLevelPadSpk() {
+    LOG_ERROR(Lib_AudioOut, "(STUBBED) called");
+    return ORBIS_OK;
+}
+
+int PS4_SYSV_ABI sceAudioOutSetMorpheusParam() {
+    LOG_ERROR(Lib_AudioOut, "(STUBBED) called");
+    return ORBIS_OK;
+}
+
+int PS4_SYSV_ABI sceAudioOutSetMorpheusWorkingMode() {
+    LOG_ERROR(Lib_AudioOut, "(STUBBED) called");
+    return ORBIS_OK;
+}
+
+int PS4_SYSV_ABI sceAudioOutSetPortConnections() {
+    LOG_ERROR(Lib_AudioOut, "(STUBBED) called");
+    return ORBIS_OK;
+}
+
+int PS4_SYSV_ABI sceAudioOutSetPortStatuses() {
+    LOG_ERROR(Lib_AudioOut, "(STUBBED) called");
+    return ORBIS_OK;
+}
+
+int PS4_SYSV_ABI sceAudioOutSetRecMode() {
+    LOG_ERROR(Lib_AudioOut, "(STUBBED) called");
+    return ORBIS_OK;
+}
+
+int PS4_SYSV_ABI sceAudioOutSetSparkParam() {
+    LOG_ERROR(Lib_AudioOut, "(STUBBED) called");
+    return ORBIS_OK;
+}
+
+int PS4_SYSV_ABI sceAudioOutSetUsbVolume() {
+    LOG_ERROR(Lib_AudioOut, "(STUBBED) called");
+    return ORBIS_OK;
+}
+
+int PS4_SYSV_ABI sceAudioOutSetVolume() {
+    LOG_ERROR(Lib_AudioOut, "(STUBBED) called");
+    return ORBIS_OK;
+}
+
+int PS4_SYSV_ABI sceAudioOutSetVolumeDown() {
+    LOG_ERROR(Lib_AudioOut, "(STUBBED) called");
+    return ORBIS_OK;
+}
+
+int PS4_SYSV_ABI sceAudioOutStartAuxBroadcast() {
+    LOG_ERROR(Lib_AudioOut, "(STUBBED) called");
+    return ORBIS_OK;
+}
+
+int PS4_SYSV_ABI sceAudioOutStartSharePlay() {
+    LOG_ERROR(Lib_AudioOut, "(STUBBED) called");
+    return ORBIS_OK;
+}
+
+int PS4_SYSV_ABI sceAudioOutStopAuxBroadcast() {
+    LOG_ERROR(Lib_AudioOut, "(STUBBED) called");
+    return ORBIS_OK;
+}
+
+int PS4_SYSV_ABI sceAudioOutStopSharePlay() {
+    LOG_ERROR(Lib_AudioOut, "(STUBBED) called");
+    return ORBIS_OK;
+}
+
+int PS4_SYSV_ABI sceAudioOutSuspendResume() {
+    LOG_ERROR(Lib_AudioOut, "(STUBBED) called");
+    return ORBIS_OK;
+}
+
+int PS4_SYSV_ABI sceAudioOutSysConfigureOutputMode() {
+    LOG_ERROR(Lib_AudioOut, "(STUBBED) called");
+    return ORBIS_OK;
+}
+
+int PS4_SYSV_ABI sceAudioOutSysGetHdmiMonitorInfo() {
+    LOG_ERROR(Lib_AudioOut, "(STUBBED) called");
+    return ORBIS_OK;
+}
+
+int PS4_SYSV_ABI sceAudioOutSysGetSystemInfo() {
+    LOG_ERROR(Lib_AudioOut, "(STUBBED) called");
+    return ORBIS_OK;
+}
+
+int PS4_SYSV_ABI sceAudioOutSysHdmiMonitorInfoIsSupportedAudioOutMode() {
+    LOG_ERROR(Lib_AudioOut, "(STUBBED) called");
+    return ORBIS_OK;
+}
+
+int PS4_SYSV_ABI sceAudioOutSystemControlGet() {
+    LOG_ERROR(Lib_AudioOut, "(STUBBED) called");
+    return ORBIS_OK;
+}
+
+int PS4_SYSV_ABI sceAudioOutSystemControlSet() {
+    LOG_ERROR(Lib_AudioOut, "(STUBBED) called");
+    return ORBIS_OK;
+}
+
+int PS4_SYSV_ABI sceAudioOutSparkControlSetEqCoef() {
+    LOG_ERROR(Lib_AudioOut, "(STUBBED) called");
+    return ORBIS_OK;
+}
+
+int PS4_SYSV_ABI sceAudioOutSetSystemDebugState() {
+    LOG_ERROR(Lib_AudioOut, "(STUBBED) called");
+    return ORBIS_OK;
+}
+
+void RegisterlibSceAudioOut(Core::Loader::SymbolsResolver* sym) {
+    LIB_FUNCTION("cx2dYFbzIAg", "libSceAudioOutDeviceService", 1, "libSceAudioOut", 1, 1,
+                 sceAudioOutDeviceIdOpen);
+    LIB_FUNCTION("tKumjQSzhys", "libSceAudioDeviceControl", 1, "libSceAudioOut", 1, 1,
+                 sceAudioDeviceControlGet);
+    LIB_FUNCTION("5ChfcHOf3SM", "libSceAudioDeviceControl", 1, "libSceAudioOut", 1, 1,
+                 sceAudioDeviceControlSet);
+    LIB_FUNCTION("Iz9X7ISldhs", "libSceAudioOut", 1, "libSceAudioOut", 1, 1, sceAudioOutA3dControl);
+    LIB_FUNCTION("9RVIoocOVAo", "libSceAudioOut", 1, "libSceAudioOut", 1, 1, sceAudioOutA3dExit);
+    LIB_FUNCTION("n7KgxE8rOuE", "libSceAudioOut", 1, "libSceAudioOut", 1, 1, sceAudioOutA3dInit);
+    LIB_FUNCTION("WBAO6-n0-4M", "libSceAudioOut", 1, "libSceAudioOut", 1, 1,
+                 sceAudioOutAttachToApplicationByPid);
+    LIB_FUNCTION("O3FM2WXIJaI", "libSceAudioOut", 1, "libSceAudioOut", 1, 1,
+                 sceAudioOutChangeAppModuleState);
+    LIB_FUNCTION("s1--uE9mBFw", "libSceAudioOut", 1, "libSceAudioOut", 1, 1, sceAudioOutClose);
+    LIB_FUNCTION("ol4LbeTG8mc", "libSceAudioOut", 1, "libSceAudioOut", 1, 1,
+                 sceAudioOutDetachFromApplicationByPid);
+    LIB_FUNCTION("r1V9IFEE+Ts", "libSceAudioOut", 1, "libSceAudioOut", 1, 1,
+                 sceAudioOutExConfigureOutputMode);
+    LIB_FUNCTION("wZakRQsWGos", "libSceAudioOut", 1, "libSceAudioOut", 1, 1,
+                 sceAudioOutExGetSystemInfo);
+    LIB_FUNCTION("xjjhT5uw08o", "libSceAudioOut", 1, "libSceAudioOut", 1, 1, sceAudioOutExPtClose);
+    LIB_FUNCTION("DsST7TNsyfo", "libSceAudioOut", 1, "libSceAudioOut", 1, 1,
+                 sceAudioOutExPtGetLastOutputTime);
+    LIB_FUNCTION("4UlW3CSuCa4", "libSceAudioOut", 1, "libSceAudioOut", 1, 1, sceAudioOutExPtOpen);
+    LIB_FUNCTION("Xcj8VTtnZw0", "libSceAudioOut", 1, "libSceAudioOut", 1, 1,
+                 sceAudioOutExSystemInfoIsSupportedAudioOutExMode);
+    LIB_FUNCTION("I3Fwcmkg5Po", "libSceAudioOut", 1, "libSceAudioOut", 1, 1,
+                 sceAudioOutGetFocusEnablePid);
+    LIB_FUNCTION("Y3lXfCFEWFY", "libSceAudioOut", 1, "libSceAudioOut", 1, 1,
+                 sceAudioOutGetHandleStatusInfo);
+    LIB_FUNCTION("-00OAutAw+c", "libSceAudioOut", 1, "libSceAudioOut", 1, 1, sceAudioOutGetInfo);
+    LIB_FUNCTION("RqmKxBqB8B4", "libSceAudioOut", 1, "libSceAudioOut", 1, 1,
+                 sceAudioOutGetInfoOpenNum);
+    LIB_FUNCTION("Ptlts326pds", "libSceAudioOut", 1, "libSceAudioOut", 1, 1,
+                 sceAudioOutGetLastOutputTime);
+    LIB_FUNCTION("GrQ9s4IrNaQ", "libSceAudioOut", 1, "libSceAudioOut", 1, 1,
+                 sceAudioOutGetPortState);
+    LIB_FUNCTION("c7mVozxJkPU", "libSceAudioOut", 1, "libSceAudioOut", 1, 1,
+                 sceAudioOutGetSimulatedBusUsableStatusByBusType);
+    LIB_FUNCTION("pWmS7LajYlo", "libSceAudioOut", 1, "libSceAudioOut", 1, 1,
+                 sceAudioOutGetSimulatedHandleStatusInfo);
+    LIB_FUNCTION("oPLghhAWgMM", "libSceAudioOut", 1, "libSceAudioOut", 1, 1,
+                 sceAudioOutGetSimulatedHandleStatusInfo2);
+    LIB_FUNCTION("5+r7JYHpkXg", "libSceAudioOut", 1, "libSceAudioOut", 1, 1,
+                 sceAudioOutGetSparkVss);
+    LIB_FUNCTION("R5hemoKKID8", "libSceAudioOut", 1, "libSceAudioOut", 1, 1,
+                 sceAudioOutGetSystemState);
+    LIB_FUNCTION("JfEPXVxhFqA", "libSceAudioOut", 1, "libSceAudioOut", 1, 1, sceAudioOutInit);
+    LIB_FUNCTION("n16Kdoxnvl0", "libSceAudioOut", 1, "libSceAudioOut", 1, 1,
+                 sceAudioOutInitIpmiGetSession);
+    LIB_FUNCTION("r+qKw+ueD+Q", "libSceAudioOut", 1, "libSceAudioOut", 1, 1,
+                 sceAudioOutMasteringGetState);
+    LIB_FUNCTION("xX4RLegarbg", "libSceAudioOut", 1, "libSceAudioOut", 1, 1,
+                 sceAudioOutMasteringInit);
+    LIB_FUNCTION("4055yaUg3EY", "libSceAudioOut", 1, "libSceAudioOut", 1, 1,
+                 sceAudioOutMasteringSetParam);
+    LIB_FUNCTION("RVWtUgoif5o", "libSceAudioOut", 1, "libSceAudioOut", 1, 1,
+                 sceAudioOutMasteringTerm);
+    LIB_FUNCTION("-LXhcGARw3k", "libSceAudioOut", 1, "libSceAudioOut", 1, 1, sceAudioOutMbusInit);
+    LIB_FUNCTION("ekNvsT22rsY", "libSceAudioOut", 1, "libSceAudioOut", 1, 1, sceAudioOutOpen);
+    LIB_FUNCTION("qLpSK75lXI4", "libSceAudioOut", 1, "libSceAudioOut", 1, 1, sceAudioOutOpenEx);
+    LIB_FUNCTION("QOQtbeDqsT4", "libSceAudioOut", 1, "libSceAudioOut", 1, 1, sceAudioOutOutput);
+    LIB_FUNCTION("w3PdaSTSwGE", "libSceAudioOut", 1, "libSceAudioOut", 1, 1, sceAudioOutOutputs);
+    LIB_FUNCTION("MapHTgeogbk", "libSceAudioOut", 1, "libSceAudioOut", 1, 1, sceAudioOutPtClose);
+    LIB_FUNCTION("YZaq+UKbriQ", "libSceAudioOut", 1, "libSceAudioOut", 1, 1,
+                 sceAudioOutPtGetLastOutputTime);
+    LIB_FUNCTION("xyT8IUCL3CI", "libSceAudioOut", 1, "libSceAudioOut", 1, 1, sceAudioOutPtOpen);
+    LIB_FUNCTION("o4OLQQqqA90", "libSceAudioOut", 1, "libSceAudioOut", 1, 1,
+                 sceAudioOutSetConnections);
+    LIB_FUNCTION("QHq2ylFOZ0k", "libSceAudioOut", 1, "libSceAudioOut", 1, 1,
+                 sceAudioOutSetConnectionsForUser);
+    LIB_FUNCTION("r9KGqGpwTpg", "libSceAudioOut", 1, "libSceAudioOut", 1, 1,
+                 sceAudioOutSetDevConnection);
+    LIB_FUNCTION("08MKi2E-RcE", "libSceAudioOut", 1, "libSceAudioOut", 1, 1,
+                 sceAudioOutSetHeadphoneOutMode);
+    LIB_FUNCTION("18IVGrIQDU4", "libSceAudioOut", 1, "libSceAudioOut", 1, 1,
+                 sceAudioOutSetJediJackVolume);
+    LIB_FUNCTION("h0o+D4YYr1k", "libSceAudioOut", 1, "libSceAudioOut", 1, 1,
+                 sceAudioOutSetJediSpkVolume);
+    LIB_FUNCTION("KI9cl22to7E", "libSceAudioOut", 1, "libSceAudioOut", 1, 1,
+                 sceAudioOutSetMainOutput);
+    LIB_FUNCTION("wVwPU50pS1c", "libSceAudioOut", 1, "libSceAudioOut", 1, 1,
+                 sceAudioOutSetMixLevelPadSpk);
+    LIB_FUNCTION("eeRsbeGYe20", "libSceAudioOut", 1, "libSceAudioOut", 1, 1,
+                 sceAudioOutSetMorpheusParam);
+    LIB_FUNCTION("IZrItPnflBM", "libSceAudioOut", 1, "libSceAudioOut", 1, 1,
+                 sceAudioOutSetMorpheusWorkingMode);
+    LIB_FUNCTION("Gy0ReOgXW00", "libSceAudioOut", 1, "libSceAudioOut", 1, 1,
+                 sceAudioOutSetPortConnections);
+    LIB_FUNCTION("oRBFflIrCg0", "libSceAudioOut", 1, "libSceAudioOut", 1, 1,
+                 sceAudioOutSetPortStatuses);
+    LIB_FUNCTION("ae-IVPMSWjU", "libSceAudioOut", 1, "libSceAudioOut", 1, 1, sceAudioOutSetRecMode);
+    LIB_FUNCTION("d3WL2uPE1eE", "libSceAudioOut", 1, "libSceAudioOut", 1, 1,
+                 sceAudioOutSetSparkParam);
+    LIB_FUNCTION("X7Cfsiujm8Y", "libSceAudioOut", 1, "libSceAudioOut", 1, 1,
+                 sceAudioOutSetUsbVolume);
+    LIB_FUNCTION("b+uAV89IlxE", "libSceAudioOut", 1, "libSceAudioOut", 1, 1, sceAudioOutSetVolume);
+    LIB_FUNCTION("rho9DH-0ehs", "libSceAudioOut", 1, "libSceAudioOut", 1, 1,
+                 sceAudioOutSetVolumeDown);
+    LIB_FUNCTION("I91P0HAPpjw", "libSceAudioOut", 1, "libSceAudioOut", 1, 1,
+                 sceAudioOutStartAuxBroadcast);
+    LIB_FUNCTION("uo+eoPzdQ-s", "libSceAudioOut", 1, "libSceAudioOut", 1, 1,
+                 sceAudioOutStartSharePlay);
+    LIB_FUNCTION("AImiaYFrKdc", "libSceAudioOut", 1, "libSceAudioOut", 1, 1,
+                 sceAudioOutStopAuxBroadcast);
+    LIB_FUNCTION("teCyKKZPjME", "libSceAudioOut", 1, "libSceAudioOut", 1, 1,
+                 sceAudioOutStopSharePlay);
+    LIB_FUNCTION("95bdtHdNUic", "libSceAudioOut", 1, "libSceAudioOut", 1, 1,
+                 sceAudioOutSuspendResume);
+    LIB_FUNCTION("oRJZnXxok-M", "libSceAudioOut", 1, "libSceAudioOut", 1, 1,
+                 sceAudioOutSysConfigureOutputMode);
+    LIB_FUNCTION("Tf9-yOJwF-A", "libSceAudioOut", 1, "libSceAudioOut", 1, 1,
+                 sceAudioOutSysGetHdmiMonitorInfo);
+    LIB_FUNCTION("y2-hP-KoTMI", "libSceAudioOut", 1, "libSceAudioOut", 1, 1,
+                 sceAudioOutSysGetSystemInfo);
+    LIB_FUNCTION("YV+bnMvMfYg", "libSceAudioOut", 1, "libSceAudioOut", 1, 1,
+                 sceAudioOutSysHdmiMonitorInfoIsSupportedAudioOutMode);
+    LIB_FUNCTION("JEHhANREcLs", "libSceAudioOut", 1, "libSceAudioOut", 1, 1,
+                 sceAudioOutSystemControlGet);
+    LIB_FUNCTION("9CHWVv6r3Dg", "libSceAudioOut", 1, "libSceAudioOut", 1, 1,
+                 sceAudioOutSystemControlSet);
+    LIB_FUNCTION("Mt7JB3lOyJk", "libSceAudioOutSparkControl", 1, "libSceAudioOut", 1, 1,
+                 sceAudioOutSparkControlSetEqCoef);
+    LIB_FUNCTION("7UsdDOEvjlk", "libSceDbgAudioOut", 1, "libSceAudioOut", 1, 1,
+                 sceAudioOutSetSystemDebugState);
+};
+
+} // namespace Libraries::AudioOut

src/core/libraries/libsceaudioout.h

@@ -0,0 +1,108 @@
+// SPDX-FileCopyrightText: Copyright 2024 shadPS4 Emulator Project
+// SPDX-License-Identifier: GPL-2.0-or-later
+
+#pragma once
+
+#include "library_common.h"
+#include "libsceuserservice.h"
+
+namespace Libraries::AudioOut {
+
+constexpr int SCE_AUDIO_OUT_VOLUME_0DB = 32768; // max volume value
+
+enum OrbisAudioOutPort {
+    ORBIS_AUDIO_OUT_PORT_TYPE_MAIN = 0,
+    ORBIS_AUDIO_OUT_PORT_TYPE_BGM = 1,
+    ORBIS_AUDIO_OUT_PORT_TYPE_VOICE = 2,
+    ORBIS_AUDIO_OUT_PORT_TYPE_PERSONAL = 3,
+    ORBIS_AUDIO_OUT_PORT_TYPE_PADSPK = 4,
+    ORBIS_AUDIO_OUT_PORT_TYPE_AUX = 127
+};
+
+enum OrbisAudioOutParam {
+    ORBIS_AUDIO_OUT_PARAM_FORMAT_S16_MONO = 0,
+    ORBIS_AUDIO_OUT_PARAM_FORMAT_S16_STEREO = 1,
+    ORBIS_AUDIO_OUT_PARAM_FORMAT_S16_8CH = 2,
+    ORBIS_AUDIO_OUT_PARAM_FORMAT_FLOAT_MONO = 3,
+    ORBIS_AUDIO_OUT_PARAM_FORMAT_FLOAT_STEREO = 4,
+    ORBIS_AUDIO_OUT_PARAM_FORMAT_FLOAT_8CH = 5,
+    ORBIS_AUDIO_OUT_PARAM_FORMAT_S16_8CH_STD = 6,
+    ORBIS_AUDIO_OUT_PARAM_FORMAT_FLOAT_8CH_STD = 7
+};
+
+int PS4_SYSV_ABI sceAudioOutDeviceIdOpen();
+int PS4_SYSV_ABI sceAudioDeviceControlGet();
+int PS4_SYSV_ABI sceAudioDeviceControlSet();
+int PS4_SYSV_ABI sceAudioOutA3dControl();
+int PS4_SYSV_ABI sceAudioOutA3dExit();
+int PS4_SYSV_ABI sceAudioOutA3dInit();
+int PS4_SYSV_ABI sceAudioOutAttachToApplicationByPid();
+int PS4_SYSV_ABI sceAudioOutChangeAppModuleState();
+int PS4_SYSV_ABI sceAudioOutClose();
+int PS4_SYSV_ABI sceAudioOutDetachFromApplicationByPid();
+int PS4_SYSV_ABI sceAudioOutExConfigureOutputMode();
+int PS4_SYSV_ABI sceAudioOutExGetSystemInfo();
+int PS4_SYSV_ABI sceAudioOutExPtClose();
+int PS4_SYSV_ABI sceAudioOutExPtGetLastOutputTime();
+int PS4_SYSV_ABI sceAudioOutExPtOpen();
+int PS4_SYSV_ABI sceAudioOutExSystemInfoIsSupportedAudioOutExMode();
+int PS4_SYSV_ABI sceAudioOutGetFocusEnablePid();
+int PS4_SYSV_ABI sceAudioOutGetHandleStatusInfo();
+int PS4_SYSV_ABI sceAudioOutGetInfo();
+int PS4_SYSV_ABI sceAudioOutGetInfoOpenNum();
+int PS4_SYSV_ABI sceAudioOutGetLastOutputTime();
+int PS4_SYSV_ABI sceAudioOutGetPortState();
+int PS4_SYSV_ABI sceAudioOutGetSimulatedBusUsableStatusByBusType();
+int PS4_SYSV_ABI sceAudioOutGetSimulatedHandleStatusInfo();
+int PS4_SYSV_ABI sceAudioOutGetSimulatedHandleStatusInfo2();
+int PS4_SYSV_ABI sceAudioOutGetSparkVss();
+int PS4_SYSV_ABI sceAudioOutGetSystemState();
+int PS4_SYSV_ABI sceAudioOutInit();
+int PS4_SYSV_ABI sceAudioOutInitIpmiGetSession();
+int PS4_SYSV_ABI sceAudioOutMasteringGetState();
+int PS4_SYSV_ABI sceAudioOutMasteringInit();
+int PS4_SYSV_ABI sceAudioOutMasteringSetParam();
+int PS4_SYSV_ABI sceAudioOutMasteringTerm();
+int PS4_SYSV_ABI sceAudioOutMbusInit();
+s32 PS4_SYSV_ABI sceAudioOutOpen(UserService::OrbisUserServiceUserId user_id,
+                                 OrbisAudioOutPort port_type, s32 index, u32 length,
+                                 u32 sample_rate, OrbisAudioOutParam param_type);
+int PS4_SYSV_ABI sceAudioOutOpenEx();
+s32 PS4_SYSV_ABI sceAudioOutOutput(s32 handle, const void* ptr);
+int PS4_SYSV_ABI sceAudioOutOutputs();
+int PS4_SYSV_ABI sceAudioOutPtClose();
+int PS4_SYSV_ABI sceAudioOutPtGetLastOutputTime();
+int PS4_SYSV_ABI sceAudioOutPtOpen();
+int PS4_SYSV_ABI sceAudioOutSetConnections();
+int PS4_SYSV_ABI sceAudioOutSetConnectionsForUser();
+int PS4_SYSV_ABI sceAudioOutSetDevConnection();
+int PS4_SYSV_ABI sceAudioOutSetHeadphoneOutMode();
+int PS4_SYSV_ABI sceAudioOutSetJediJackVolume();
+int PS4_SYSV_ABI sceAudioOutSetJediSpkVolume();
+int PS4_SYSV_ABI sceAudioOutSetMainOutput();
+int PS4_SYSV_ABI sceAudioOutSetMixLevelPadSpk();
+int PS4_SYSV_ABI sceAudioOutSetMorpheusParam();
+int PS4_SYSV_ABI sceAudioOutSetMorpheusWorkingMode();
+int PS4_SYSV_ABI sceAudioOutSetPortConnections();
+int PS4_SYSV_ABI sceAudioOutSetPortStatuses();
+int PS4_SYSV_ABI sceAudioOutSetRecMode();
+int PS4_SYSV_ABI sceAudioOutSetSparkParam();
+int PS4_SYSV_ABI sceAudioOutSetUsbVolume();
+int PS4_SYSV_ABI sceAudioOutSetVolume();
+int PS4_SYSV_ABI sceAudioOutSetVolumeDown();
+int PS4_SYSV_ABI sceAudioOutStartAuxBroadcast();
+int PS4_SYSV_ABI sceAudioOutStartSharePlay();
+int PS4_SYSV_ABI sceAudioOutStopAuxBroadcast();
+int PS4_SYSV_ABI sceAudioOutStopSharePlay();
+int PS4_SYSV_ABI sceAudioOutSuspendResume();
+int PS4_SYSV_ABI sceAudioOutSysConfigureOutputMode();
+int PS4_SYSV_ABI sceAudioOutSysGetHdmiMonitorInfo();
+int PS4_SYSV_ABI sceAudioOutSysGetSystemInfo();
+int PS4_SYSV_ABI sceAudioOutSysHdmiMonitorInfoIsSupportedAudioOutMode();
+int PS4_SYSV_ABI sceAudioOutSystemControlGet();
+int PS4_SYSV_ABI sceAudioOutSystemControlSet();
+int PS4_SYSV_ABI sceAudioOutSparkControlSetEqCoef();
+int PS4_SYSV_ABI sceAudioOutSetSystemDebugState();
+
+void RegisterlibSceAudioOut(Core::Loader::SymbolsResolver* sym);
+} // namespace Libraries::AudioOut

src/emulator.cpp

@@ -49,9 +49,17 @@ static void CreateSdlWindow(WindowCtx* ctx) {
         std::exit(0);
     }
     std::string title = "shadps4 v" + std::string(Common::VERSION);
-    ctx->m_window = SDL_CreateWindowWithPosition(
+    SDL_PropertiesID props = SDL_CreateProperties();
-        title.c_str(), SDL_WINDOWPOS_CENTERED, SDL_WINDOWPOS_CENTERED, width, height,
+    SDL_SetStringProperty(props, SDL_PROP_WINDOW_CREATE_TITLE_STRING, title.c_str());
+    SDL_SetNumberProperty(props, SDL_PROP_WINDOW_CREATE_X_NUMBER, SDL_WINDOWPOS_CENTERED);
+    SDL_SetNumberProperty(props, SDL_PROP_WINDOW_CREATE_Y_NUMBER, SDL_WINDOWPOS_CENTERED);
+    SDL_SetNumberProperty(props, SDL_PROP_WINDOW_CREATE_WIDTH_NUMBER, width);
+    SDL_SetNumberProperty(props, SDL_PROP_WINDOW_CREATE_HEIGHT_NUMBER, height);
+    SDL_SetNumberProperty(
+        props, "flags",
         (static_cast<uint32_t>(SDL_WINDOW_HIDDEN) | static_cast<uint32_t>(SDL_WINDOW_VULKAN)));
+    ctx->m_window = SDL_CreateWindowWithProperties(props);
+    SDL_DestroyProperties(props);
 
     ctx->is_window_hidden =
         true; // hide window until we need to show something (should draw something in buffers)

src/emulator.h

@@ -15,7 +15,8 @@ namespace Emu {
 struct VulkanExt {
     bool enable_validation_layers = false;
 
-    std::vector<const char*> required_extensions;
+    char const* const* required_extensions;
+    u32 required_extensions_count;
     std::vector<VkExtensionProperties> available_extensions;
     std::vector<const char*> required_layers;
     std::vector<VkLayerProperties> available_layers;

src/vulkan_util.cpp

@@ -32,16 +32,16 @@ void Graphics::Vulkan::vulkanCreate(Emu::WindowCtx* ctx) {
     inst_info.pNext = nullptr;
     inst_info.flags = 0;
     inst_info.pApplicationInfo = &app_info;
-    inst_info.enabledExtensionCount = ext.required_extensions.size();
+    inst_info.enabledExtensionCount = ext.required_extensions_count;
-    inst_info.ppEnabledExtensionNames = ext.required_extensions.data();
+    inst_info.ppEnabledExtensionNames = ext.required_extensions;
     inst_info.enabledLayerCount = 0;
     inst_info.ppEnabledLayerNames = nullptr;
 
     const VkResult result = vkCreateInstance(&inst_info, nullptr, &ctx->m_graphic_ctx.m_instance);
     ASSERT_MSG(result == VK_SUCCESS, "Can't create an vulkan instance");
 
-    if (SDL_Vulkan_CreateSurface(ctx->m_window, ctx->m_graphic_ctx.m_instance, &ctx->m_surface) ==
+    if (SDL_Vulkan_CreateSurface(ctx->m_window, ctx->m_graphic_ctx.m_instance, NULL,
-        SDL_FALSE) {
+                                 &ctx->m_surface) == SDL_FALSE) {
         UNREACHABLE_MSG("Can't create an vulkan surface");
     }
 
@@ -243,12 +243,8 @@ void Graphics::Vulkan::vulkanGetInstanceExtensions(Emu::VulkanExt* ext) {
     u32 required_extensions_count = 0;
     u32 available_extensions_count = 0;
     u32 available_layers_count = 0;
-    auto result = SDL_Vulkan_GetInstanceExtensions(&required_extensions_count, nullptr);
+    ext->required_extensions = SDL_Vulkan_GetInstanceExtensions(&required_extensions_count);
-
+    ext->required_extensions_count = required_extensions_count;
-    ext->required_extensions = std::vector<const char*>(required_extensions_count);
-
-    result = SDL_Vulkan_GetInstanceExtensions(&required_extensions_count,
-                                              ext->required_extensions.data());
 
     vkEnumerateInstanceExtensionProperties(nullptr, &available_extensions_count, nullptr);
 
@@ -261,9 +257,9 @@ void Graphics::Vulkan::vulkanGetInstanceExtensions(Emu::VulkanExt* ext) {
     ext->available_layers = std::vector<VkLayerProperties>(available_layers_count);
     vkEnumerateInstanceLayerProperties(&available_layers_count, ext->available_layers.data());
 
-    for (const char* ext : ext->required_extensions) {
+    // for (const char* ext : ext->required_extensions) {
-        LOG_INFO(Render_Vulkan, "Vulkan required extension = {}", ext);
+    //    LOG_INFO(Render_Vulkan, "Vulkan required extension = {}", ext);
-    }
+    //}
 
     for (const auto& ext : ext->available_extensions) {
         LOG_INFO(Render_Vulkan, "Vulkan available extension: {}, version = {}", ext.extensionName,

third-party/CMakeLists.txt

@@ -12,11 +12,6 @@ add_subdirectory(fmt EXCLUDE_FROM_ALL)
 # MagicEnum
 add_subdirectory(magic_enum EXCLUDE_FROM_ALL)
 
-if(NOT ENABLE_QT_GUI)
-# SDL3
-add_subdirectory(SDL EXCLUDE_FROM_ALL)
-endif()
-
 # Toml11
 add_subdirectory(toml11 EXCLUDE_FROM_ALL)
 

third-party/SDL

@@ -1 +0,0 @@
-Subproject commit 27556e098ecce54014ed1fc11c1e974ffdf4bc93

tools/ModuleGenerator/libraries/libsceaudioout.cpp

@@ -0,0 +1,511 @@
+// SPDX-FileCopyrightText: Copyright 2024 shadPS4 Emulator Project
+// SPDX-License-Identifier: GPL-2.0-or-later
+
+// Generated By moduleGenerator
+#include "libsceaudioout.h"
+#include "common/log.h"
+#include "error_codes.h"
+
+namespace Libraries::AudioOut{
+
+int PS4_SYSV_ABI sceAudioOutDeviceIdOpen()
+{
+	PRINT_UNIMPLEMENTED_FUNCTION_NAME();
+	return ORBIS_OK;
+}
+
+int PS4_SYSV_ABI sceAudioDeviceControlGet()
+{
+	PRINT_UNIMPLEMENTED_FUNCTION_NAME();
+	return ORBIS_OK;
+}
+
+int PS4_SYSV_ABI sceAudioDeviceControlSet()
+{
+	PRINT_UNIMPLEMENTED_FUNCTION_NAME();
+	return ORBIS_OK;
+}
+
+int PS4_SYSV_ABI sceAudioOutA3dControl()
+{
+	PRINT_UNIMPLEMENTED_FUNCTION_NAME();
+	return ORBIS_OK;
+}
+
+int PS4_SYSV_ABI sceAudioOutA3dExit()
+{
+	PRINT_UNIMPLEMENTED_FUNCTION_NAME();
+	return ORBIS_OK;
+}
+
+int PS4_SYSV_ABI sceAudioOutA3dInit()
+{
+	PRINT_UNIMPLEMENTED_FUNCTION_NAME();
+	return ORBIS_OK;
+}
+
+int PS4_SYSV_ABI sceAudioOutAttachToApplicationByPid()
+{
+	PRINT_UNIMPLEMENTED_FUNCTION_NAME();
+	return ORBIS_OK;
+}
+
+int PS4_SYSV_ABI sceAudioOutChangeAppModuleState()
+{
+	PRINT_UNIMPLEMENTED_FUNCTION_NAME();
+	return ORBIS_OK;
+}
+
+int PS4_SYSV_ABI sceAudioOutClose()
+{
+	PRINT_UNIMPLEMENTED_FUNCTION_NAME();
+	return ORBIS_OK;
+}
+
+int PS4_SYSV_ABI sceAudioOutDetachFromApplicationByPid()
+{
+	PRINT_UNIMPLEMENTED_FUNCTION_NAME();
+	return ORBIS_OK;
+}
+
+int PS4_SYSV_ABI sceAudioOutExConfigureOutputMode()
+{
+	PRINT_UNIMPLEMENTED_FUNCTION_NAME();
+	return ORBIS_OK;
+}
+
+int PS4_SYSV_ABI sceAudioOutExGetSystemInfo()
+{
+	PRINT_UNIMPLEMENTED_FUNCTION_NAME();
+	return ORBIS_OK;
+}
+
+int PS4_SYSV_ABI sceAudioOutExPtClose()
+{
+	PRINT_UNIMPLEMENTED_FUNCTION_NAME();
+	return ORBIS_OK;
+}
+
+int PS4_SYSV_ABI sceAudioOutExPtGetLastOutputTime()
+{
+	PRINT_UNIMPLEMENTED_FUNCTION_NAME();
+	return ORBIS_OK;
+}
+
+int PS4_SYSV_ABI sceAudioOutExPtOpen()
+{
+	PRINT_UNIMPLEMENTED_FUNCTION_NAME();
+	return ORBIS_OK;
+}
+
+int PS4_SYSV_ABI sceAudioOutExSystemInfoIsSupportedAudioOutExMode()
+{
+	PRINT_UNIMPLEMENTED_FUNCTION_NAME();
+	return ORBIS_OK;
+}
+
+int PS4_SYSV_ABI sceAudioOutGetFocusEnablePid()
+{
+	PRINT_UNIMPLEMENTED_FUNCTION_NAME();
+	return ORBIS_OK;
+}
+
+int PS4_SYSV_ABI sceAudioOutGetHandleStatusInfo()
+{
+	PRINT_UNIMPLEMENTED_FUNCTION_NAME();
+	return ORBIS_OK;
+}
+
+int PS4_SYSV_ABI sceAudioOutGetInfo()
+{
+	PRINT_UNIMPLEMENTED_FUNCTION_NAME();
+	return ORBIS_OK;
+}
+
+int PS4_SYSV_ABI sceAudioOutGetInfoOpenNum()
+{
+	PRINT_UNIMPLEMENTED_FUNCTION_NAME();
+	return ORBIS_OK;
+}
+
+int PS4_SYSV_ABI sceAudioOutGetLastOutputTime()
+{
+	PRINT_UNIMPLEMENTED_FUNCTION_NAME();
+	return ORBIS_OK;
+}
+
+int PS4_SYSV_ABI sceAudioOutGetPortState()
+{
+	PRINT_UNIMPLEMENTED_FUNCTION_NAME();
+	return ORBIS_OK;
+}
+
+int PS4_SYSV_ABI sceAudioOutGetSimulatedBusUsableStatusByBusType()
+{
+	PRINT_UNIMPLEMENTED_FUNCTION_NAME();
+	return ORBIS_OK;
+}
+
+int PS4_SYSV_ABI sceAudioOutGetSimulatedHandleStatusInfo()
+{
+	PRINT_UNIMPLEMENTED_FUNCTION_NAME();
+	return ORBIS_OK;
+}
+
+int PS4_SYSV_ABI sceAudioOutGetSimulatedHandleStatusInfo2()
+{
+	PRINT_UNIMPLEMENTED_FUNCTION_NAME();
+	return ORBIS_OK;
+}
+
+int PS4_SYSV_ABI sceAudioOutGetSparkVss()
+{
+	PRINT_UNIMPLEMENTED_FUNCTION_NAME();
+	return ORBIS_OK;
+}
+
+int PS4_SYSV_ABI sceAudioOutGetSystemState()
+{
+	PRINT_UNIMPLEMENTED_FUNCTION_NAME();
+	return ORBIS_OK;
+}
+
+int PS4_SYSV_ABI sceAudioOutInit()
+{
+	PRINT_UNIMPLEMENTED_FUNCTION_NAME();
+	return ORBIS_OK;
+}
+
+int PS4_SYSV_ABI sceAudioOutInitIpmiGetSession()
+{
+	PRINT_UNIMPLEMENTED_FUNCTION_NAME();
+	return ORBIS_OK;
+}
+
+int PS4_SYSV_ABI sceAudioOutMasteringGetState()
+{
+	PRINT_UNIMPLEMENTED_FUNCTION_NAME();
+	return ORBIS_OK;
+}
+
+int PS4_SYSV_ABI sceAudioOutMasteringInit()
+{
+	PRINT_UNIMPLEMENTED_FUNCTION_NAME();
+	return ORBIS_OK;
+}
+
+int PS4_SYSV_ABI sceAudioOutMasteringSetParam()
+{
+	PRINT_UNIMPLEMENTED_FUNCTION_NAME();
+	return ORBIS_OK;
+}
+
+int PS4_SYSV_ABI sceAudioOutMasteringTerm()
+{
+	PRINT_UNIMPLEMENTED_FUNCTION_NAME();
+	return ORBIS_OK;
+}
+
+int PS4_SYSV_ABI sceAudioOutMbusInit()
+{
+	PRINT_UNIMPLEMENTED_FUNCTION_NAME();
+	return ORBIS_OK;
+}
+
+int PS4_SYSV_ABI sceAudioOutOpen()
+{
+	PRINT_UNIMPLEMENTED_FUNCTION_NAME();
+	return ORBIS_OK;
+}
+
+int PS4_SYSV_ABI sceAudioOutOpenEx()
+{
+	PRINT_UNIMPLEMENTED_FUNCTION_NAME();
+	return ORBIS_OK;
+}
+
+int PS4_SYSV_ABI sceAudioOutOutput()
+{
+	PRINT_UNIMPLEMENTED_FUNCTION_NAME();
+	return ORBIS_OK;
+}
+
+int PS4_SYSV_ABI sceAudioOutOutputs()
+{
+	PRINT_UNIMPLEMENTED_FUNCTION_NAME();
+	return ORBIS_OK;
+}
+
+int PS4_SYSV_ABI sceAudioOutPtClose()
+{
+	PRINT_UNIMPLEMENTED_FUNCTION_NAME();
+	return ORBIS_OK;
+}
+
+int PS4_SYSV_ABI sceAudioOutPtGetLastOutputTime()
+{
+	PRINT_UNIMPLEMENTED_FUNCTION_NAME();
+	return ORBIS_OK;
+}
+
+int PS4_SYSV_ABI sceAudioOutPtOpen()
+{
+	PRINT_UNIMPLEMENTED_FUNCTION_NAME();
+	return ORBIS_OK;
+}
+
+int PS4_SYSV_ABI sceAudioOutSetConnections()
+{
+	PRINT_UNIMPLEMENTED_FUNCTION_NAME();
+	return ORBIS_OK;
+}
+
+int PS4_SYSV_ABI sceAudioOutSetConnectionsForUser()
+{
+	PRINT_UNIMPLEMENTED_FUNCTION_NAME();
+	return ORBIS_OK;
+}
+
+int PS4_SYSV_ABI sceAudioOutSetDevConnection()
+{
+	PRINT_UNIMPLEMENTED_FUNCTION_NAME();
+	return ORBIS_OK;
+}
+
+int PS4_SYSV_ABI sceAudioOutSetHeadphoneOutMode()
+{
+	PRINT_UNIMPLEMENTED_FUNCTION_NAME();
+	return ORBIS_OK;
+}
+
+int PS4_SYSV_ABI sceAudioOutSetJediJackVolume()
+{
+	PRINT_UNIMPLEMENTED_FUNCTION_NAME();
+	return ORBIS_OK;
+}
+
+int PS4_SYSV_ABI sceAudioOutSetJediSpkVolume()
+{
+	PRINT_UNIMPLEMENTED_FUNCTION_NAME();
+	return ORBIS_OK;
+}
+
+int PS4_SYSV_ABI sceAudioOutSetMainOutput()
+{
+	PRINT_UNIMPLEMENTED_FUNCTION_NAME();
+	return ORBIS_OK;
+}
+
+int PS4_SYSV_ABI sceAudioOutSetMixLevelPadSpk()
+{
+	PRINT_UNIMPLEMENTED_FUNCTION_NAME();
+	return ORBIS_OK;
+}
+
+int PS4_SYSV_ABI sceAudioOutSetMorpheusParam()
+{
+	PRINT_UNIMPLEMENTED_FUNCTION_NAME();
+	return ORBIS_OK;
+}
+
+int PS4_SYSV_ABI sceAudioOutSetMorpheusWorkingMode()
+{
+	PRINT_UNIMPLEMENTED_FUNCTION_NAME();
+	return ORBIS_OK;
+}
+
+int PS4_SYSV_ABI sceAudioOutSetPortConnections()
+{
+	PRINT_UNIMPLEMENTED_FUNCTION_NAME();
+	return ORBIS_OK;
+}
+
+int PS4_SYSV_ABI sceAudioOutSetPortStatuses()
+{
+	PRINT_UNIMPLEMENTED_FUNCTION_NAME();
+	return ORBIS_OK;
+}
+
+int PS4_SYSV_ABI sceAudioOutSetRecMode()
+{
+	PRINT_UNIMPLEMENTED_FUNCTION_NAME();
+	return ORBIS_OK;
+}
+
+int PS4_SYSV_ABI sceAudioOutSetSparkParam()
+{
+	PRINT_UNIMPLEMENTED_FUNCTION_NAME();
+	return ORBIS_OK;
+}
+
+int PS4_SYSV_ABI sceAudioOutSetUsbVolume()
+{
+	PRINT_UNIMPLEMENTED_FUNCTION_NAME();
+	return ORBIS_OK;
+}
+
+int PS4_SYSV_ABI sceAudioOutSetVolume()
+{
+	PRINT_UNIMPLEMENTED_FUNCTION_NAME();
+	return ORBIS_OK;
+}
+
+int PS4_SYSV_ABI sceAudioOutSetVolumeDown()
+{
+	PRINT_UNIMPLEMENTED_FUNCTION_NAME();
+	return ORBIS_OK;
+}
+
+int PS4_SYSV_ABI sceAudioOutStartAuxBroadcast()
+{
+	PRINT_UNIMPLEMENTED_FUNCTION_NAME();
+	return ORBIS_OK;
+}
+
+int PS4_SYSV_ABI sceAudioOutStartSharePlay()
+{
+	PRINT_UNIMPLEMENTED_FUNCTION_NAME();
+	return ORBIS_OK;
+}
+
+int PS4_SYSV_ABI sceAudioOutStopAuxBroadcast()
+{
+	PRINT_UNIMPLEMENTED_FUNCTION_NAME();
+	return ORBIS_OK;
+}
+
+int PS4_SYSV_ABI sceAudioOutStopSharePlay()
+{
+	PRINT_UNIMPLEMENTED_FUNCTION_NAME();
+	return ORBIS_OK;
+}
+
+int PS4_SYSV_ABI sceAudioOutSuspendResume()
+{
+	PRINT_UNIMPLEMENTED_FUNCTION_NAME();
+	return ORBIS_OK;
+}
+
+int PS4_SYSV_ABI sceAudioOutSysConfigureOutputMode()
+{
+	PRINT_UNIMPLEMENTED_FUNCTION_NAME();
+	return ORBIS_OK;
+}
+
+int PS4_SYSV_ABI sceAudioOutSysGetHdmiMonitorInfo()
+{
+	PRINT_UNIMPLEMENTED_FUNCTION_NAME();
+	return ORBIS_OK;
+}
+
+int PS4_SYSV_ABI sceAudioOutSysGetSystemInfo()
+{
+	PRINT_UNIMPLEMENTED_FUNCTION_NAME();
+	return ORBIS_OK;
+}
+
+int PS4_SYSV_ABI sceAudioOutSysHdmiMonitorInfoIsSupportedAudioOutMode()
+{
+	PRINT_UNIMPLEMENTED_FUNCTION_NAME();
+	return ORBIS_OK;
+}
+
+int PS4_SYSV_ABI sceAudioOutSystemControlGet()
+{
+	PRINT_UNIMPLEMENTED_FUNCTION_NAME();
+	return ORBIS_OK;
+}
+
+int PS4_SYSV_ABI sceAudioOutSystemControlSet()
+{
+	PRINT_UNIMPLEMENTED_FUNCTION_NAME();
+	return ORBIS_OK;
+}
+
+int PS4_SYSV_ABI sceAudioOutSparkControlSetEqCoef()
+{
+	PRINT_UNIMPLEMENTED_FUNCTION_NAME();
+	return ORBIS_OK;
+}
+
+int PS4_SYSV_ABI sceAudioOutSetSystemDebugState()
+{
+	PRINT_UNIMPLEMENTED_FUNCTION_NAME();
+	return ORBIS_OK;
+}
+
+void RegisterlibSceAudioOut(Core::Loader::SymbolsResolver * sym) {
+ LIB_FUNCTION("cx2dYFbzIAg", "libSceAudioOutDeviceService" , 1 , "libSceAudioOut", 1, 1 , sceAudioOutDeviceIdOpen );
+ LIB_FUNCTION("tKumjQSzhys", "libSceAudioDeviceControl" , 1 , "libSceAudioOut", 1, 1 , sceAudioDeviceControlGet );
+ LIB_FUNCTION("5ChfcHOf3SM", "libSceAudioDeviceControl" , 1 , "libSceAudioOut", 1, 1 , sceAudioDeviceControlSet );
+ LIB_FUNCTION("Iz9X7ISldhs", "libSceAudioOut" , 1 , "libSceAudioOut", 1, 1 , sceAudioOutA3dControl );
+ LIB_FUNCTION("9RVIoocOVAo", "libSceAudioOut" , 1 , "libSceAudioOut", 1, 1 , sceAudioOutA3dExit );
+ LIB_FUNCTION("n7KgxE8rOuE", "libSceAudioOut" , 1 , "libSceAudioOut", 1, 1 , sceAudioOutA3dInit );
+ LIB_FUNCTION("WBAO6-n0-4M", "libSceAudioOut" , 1 , "libSceAudioOut", 1, 1 , sceAudioOutAttachToApplicationByPid );
+ LIB_FUNCTION("O3FM2WXIJaI", "libSceAudioOut" , 1 , "libSceAudioOut", 1, 1 , sceAudioOutChangeAppModuleState );
+ LIB_FUNCTION("s1--uE9mBFw", "libSceAudioOut" , 1 , "libSceAudioOut", 1, 1 , sceAudioOutClose );
+ LIB_FUNCTION("ol4LbeTG8mc", "libSceAudioOut" , 1 , "libSceAudioOut", 1, 1 , sceAudioOutDetachFromApplicationByPid );
+ LIB_FUNCTION("r1V9IFEE+Ts", "libSceAudioOut" , 1 , "libSceAudioOut", 1, 1 , sceAudioOutExConfigureOutputMode );
+ LIB_FUNCTION("wZakRQsWGos", "libSceAudioOut" , 1 , "libSceAudioOut", 1, 1 , sceAudioOutExGetSystemInfo );
+ LIB_FUNCTION("xjjhT5uw08o", "libSceAudioOut" , 1 , "libSceAudioOut", 1, 1 , sceAudioOutExPtClose );
+ LIB_FUNCTION("DsST7TNsyfo", "libSceAudioOut" , 1 , "libSceAudioOut", 1, 1 , sceAudioOutExPtGetLastOutputTime );
+ LIB_FUNCTION("4UlW3CSuCa4", "libSceAudioOut" , 1 , "libSceAudioOut", 1, 1 , sceAudioOutExPtOpen );
+ LIB_FUNCTION("Xcj8VTtnZw0", "libSceAudioOut" , 1 , "libSceAudioOut", 1, 1 , sceAudioOutExSystemInfoIsSupportedAudioOutExMode );
+ LIB_FUNCTION("I3Fwcmkg5Po", "libSceAudioOut" , 1 , "libSceAudioOut", 1, 1 , sceAudioOutGetFocusEnablePid );
+ LIB_FUNCTION("Y3lXfCFEWFY", "libSceAudioOut" , 1 , "libSceAudioOut", 1, 1 , sceAudioOutGetHandleStatusInfo );
+ LIB_FUNCTION("-00OAutAw+c", "libSceAudioOut" , 1 , "libSceAudioOut", 1, 1 , sceAudioOutGetInfo );
+ LIB_FUNCTION("RqmKxBqB8B4", "libSceAudioOut" , 1 , "libSceAudioOut", 1, 1 , sceAudioOutGetInfoOpenNum );
+ LIB_FUNCTION("Ptlts326pds", "libSceAudioOut" , 1 , "libSceAudioOut", 1, 1 , sceAudioOutGetLastOutputTime );
+ LIB_FUNCTION("GrQ9s4IrNaQ", "libSceAudioOut" , 1 , "libSceAudioOut", 1, 1 , sceAudioOutGetPortState );
+ LIB_FUNCTION("c7mVozxJkPU", "libSceAudioOut" , 1 , "libSceAudioOut", 1, 1 , sceAudioOutGetSimulatedBusUsableStatusByBusType );
+ LIB_FUNCTION("pWmS7LajYlo", "libSceAudioOut" , 1 , "libSceAudioOut", 1, 1 , sceAudioOutGetSimulatedHandleStatusInfo );
+ LIB_FUNCTION("oPLghhAWgMM", "libSceAudioOut" , 1 , "libSceAudioOut", 1, 1 , sceAudioOutGetSimulatedHandleStatusInfo2 );
+ LIB_FUNCTION("5+r7JYHpkXg", "libSceAudioOut" , 1 , "libSceAudioOut", 1, 1 , sceAudioOutGetSparkVss );
+ LIB_FUNCTION("R5hemoKKID8", "libSceAudioOut" , 1 , "libSceAudioOut", 1, 1 , sceAudioOutGetSystemState );
+ LIB_FUNCTION("JfEPXVxhFqA", "libSceAudioOut" , 1 , "libSceAudioOut", 1, 1 , sceAudioOutInit );
+ LIB_FUNCTION("n16Kdoxnvl0", "libSceAudioOut" , 1 , "libSceAudioOut", 1, 1 , sceAudioOutInitIpmiGetSession );
+ LIB_FUNCTION("r+qKw+ueD+Q", "libSceAudioOut" , 1 , "libSceAudioOut", 1, 1 , sceAudioOutMasteringGetState );
+ LIB_FUNCTION("xX4RLegarbg", "libSceAudioOut" , 1 , "libSceAudioOut", 1, 1 , sceAudioOutMasteringInit );
+ LIB_FUNCTION("4055yaUg3EY", "libSceAudioOut" , 1 , "libSceAudioOut", 1, 1 , sceAudioOutMasteringSetParam );
+ LIB_FUNCTION("RVWtUgoif5o", "libSceAudioOut" , 1 , "libSceAudioOut", 1, 1 , sceAudioOutMasteringTerm );
+ LIB_FUNCTION("-LXhcGARw3k", "libSceAudioOut" , 1 , "libSceAudioOut", 1, 1 , sceAudioOutMbusInit );
+ LIB_FUNCTION("ekNvsT22rsY", "libSceAudioOut" , 1 , "libSceAudioOut", 1, 1 , sceAudioOutOpen );
+ LIB_FUNCTION("qLpSK75lXI4", "libSceAudioOut" , 1 , "libSceAudioOut", 1, 1 , sceAudioOutOpenEx );
+ LIB_FUNCTION("QOQtbeDqsT4", "libSceAudioOut" , 1 , "libSceAudioOut", 1, 1 , sceAudioOutOutput );
+ LIB_FUNCTION("w3PdaSTSwGE", "libSceAudioOut" , 1 , "libSceAudioOut", 1, 1 , sceAudioOutOutputs );
+ LIB_FUNCTION("MapHTgeogbk", "libSceAudioOut" , 1 , "libSceAudioOut", 1, 1 , sceAudioOutPtClose );
+ LIB_FUNCTION("YZaq+UKbriQ", "libSceAudioOut" , 1 , "libSceAudioOut", 1, 1 , sceAudioOutPtGetLastOutputTime );
+ LIB_FUNCTION("xyT8IUCL3CI", "libSceAudioOut" , 1 , "libSceAudioOut", 1, 1 , sceAudioOutPtOpen );
+ LIB_FUNCTION("o4OLQQqqA90", "libSceAudioOut" , 1 , "libSceAudioOut", 1, 1 , sceAudioOutSetConnections );
+ LIB_FUNCTION("QHq2ylFOZ0k", "libSceAudioOut" , 1 , "libSceAudioOut", 1, 1 , sceAudioOutSetConnectionsForUser );
+ LIB_FUNCTION("r9KGqGpwTpg", "libSceAudioOut" , 1 , "libSceAudioOut", 1, 1 , sceAudioOutSetDevConnection );
+ LIB_FUNCTION("08MKi2E-RcE", "libSceAudioOut" , 1 , "libSceAudioOut", 1, 1 , sceAudioOutSetHeadphoneOutMode );
+ LIB_FUNCTION("18IVGrIQDU4", "libSceAudioOut" , 1 , "libSceAudioOut", 1, 1 , sceAudioOutSetJediJackVolume );
+ LIB_FUNCTION("h0o+D4YYr1k", "libSceAudioOut" , 1 , "libSceAudioOut", 1, 1 , sceAudioOutSetJediSpkVolume );
+ LIB_FUNCTION("KI9cl22to7E", "libSceAudioOut" , 1 , "libSceAudioOut", 1, 1 , sceAudioOutSetMainOutput );
+ LIB_FUNCTION("wVwPU50pS1c", "libSceAudioOut" , 1 , "libSceAudioOut", 1, 1 , sceAudioOutSetMixLevelPadSpk );
+ LIB_FUNCTION("eeRsbeGYe20", "libSceAudioOut" , 1 , "libSceAudioOut", 1, 1 , sceAudioOutSetMorpheusParam );
+ LIB_FUNCTION("IZrItPnflBM", "libSceAudioOut" , 1 , "libSceAudioOut", 1, 1 , sceAudioOutSetMorpheusWorkingMode );
+ LIB_FUNCTION("Gy0ReOgXW00", "libSceAudioOut" , 1 , "libSceAudioOut", 1, 1 , sceAudioOutSetPortConnections );
+ LIB_FUNCTION("oRBFflIrCg0", "libSceAudioOut" , 1 , "libSceAudioOut", 1, 1 , sceAudioOutSetPortStatuses );
+ LIB_FUNCTION("ae-IVPMSWjU", "libSceAudioOut" , 1 , "libSceAudioOut", 1, 1 , sceAudioOutSetRecMode );
+ LIB_FUNCTION("d3WL2uPE1eE", "libSceAudioOut" , 1 , "libSceAudioOut", 1, 1 , sceAudioOutSetSparkParam );
+ LIB_FUNCTION("X7Cfsiujm8Y", "libSceAudioOut" , 1 , "libSceAudioOut", 1, 1 , sceAudioOutSetUsbVolume );
+ LIB_FUNCTION("b+uAV89IlxE", "libSceAudioOut" , 1 , "libSceAudioOut", 1, 1 , sceAudioOutSetVolume );
+ LIB_FUNCTION("rho9DH-0ehs", "libSceAudioOut" , 1 , "libSceAudioOut", 1, 1 , sceAudioOutSetVolumeDown );
+ LIB_FUNCTION("I91P0HAPpjw", "libSceAudioOut" , 1 , "libSceAudioOut", 1, 1 , sceAudioOutStartAuxBroadcast );
+ LIB_FUNCTION("uo+eoPzdQ-s", "libSceAudioOut" , 1 , "libSceAudioOut", 1, 1 , sceAudioOutStartSharePlay );
+ LIB_FUNCTION("AImiaYFrKdc", "libSceAudioOut" , 1 , "libSceAudioOut", 1, 1 , sceAudioOutStopAuxBroadcast );
+ LIB_FUNCTION("teCyKKZPjME", "libSceAudioOut" , 1 , "libSceAudioOut", 1, 1 , sceAudioOutStopSharePlay );
+ LIB_FUNCTION("95bdtHdNUic", "libSceAudioOut" , 1 , "libSceAudioOut", 1, 1 , sceAudioOutSuspendResume );
+ LIB_FUNCTION("oRJZnXxok-M", "libSceAudioOut" , 1 , "libSceAudioOut", 1, 1 , sceAudioOutSysConfigureOutputMode );
+ LIB_FUNCTION("Tf9-yOJwF-A", "libSceAudioOut" , 1 , "libSceAudioOut", 1, 1 , sceAudioOutSysGetHdmiMonitorInfo );
+ LIB_FUNCTION("y2-hP-KoTMI", "libSceAudioOut" , 1 , "libSceAudioOut", 1, 1 , sceAudioOutSysGetSystemInfo );
+ LIB_FUNCTION("YV+bnMvMfYg", "libSceAudioOut" , 1 , "libSceAudioOut", 1, 1 , sceAudioOutSysHdmiMonitorInfoIsSupportedAudioOutMode );
+ LIB_FUNCTION("JEHhANREcLs", "libSceAudioOut" , 1 , "libSceAudioOut", 1, 1 , sceAudioOutSystemControlGet );
+ LIB_FUNCTION("9CHWVv6r3Dg", "libSceAudioOut" , 1 , "libSceAudioOut", 1, 1 , sceAudioOutSystemControlSet );
+ LIB_FUNCTION("Mt7JB3lOyJk", "libSceAudioOutSparkControl" , 1 , "libSceAudioOut", 1, 1 , sceAudioOutSparkControlSetEqCoef );
+ LIB_FUNCTION("7UsdDOEvjlk", "libSceDbgAudioOut" , 1 , "libSceAudioOut", 1, 1 , sceAudioOutSetSystemDebugState );
+};
+
+}

tools/ModuleGenerator/libraries/libsceaudioout.h

@@ -0,0 +1,83 @@
+// SPDX-FileCopyrightText: Copyright 2024 shadPS4 Emulator Project
+// SPDX-License-Identifier: GPL-2.0-or-later
+
+#pragma once
+
+#include "library_common.h" 
+
+namespace Libraries::AudioOut{
+
+int PS4_SYSV_ABI sceAudioOutDeviceIdOpen();
+int PS4_SYSV_ABI sceAudioDeviceControlGet();
+int PS4_SYSV_ABI sceAudioDeviceControlSet();
+int PS4_SYSV_ABI sceAudioOutA3dControl();
+int PS4_SYSV_ABI sceAudioOutA3dExit();
+int PS4_SYSV_ABI sceAudioOutA3dInit();
+int PS4_SYSV_ABI sceAudioOutAttachToApplicationByPid();
+int PS4_SYSV_ABI sceAudioOutChangeAppModuleState();
+int PS4_SYSV_ABI sceAudioOutClose();
+int PS4_SYSV_ABI sceAudioOutDetachFromApplicationByPid();
+int PS4_SYSV_ABI sceAudioOutExConfigureOutputMode();
+int PS4_SYSV_ABI sceAudioOutExGetSystemInfo();
+int PS4_SYSV_ABI sceAudioOutExPtClose();
+int PS4_SYSV_ABI sceAudioOutExPtGetLastOutputTime();
+int PS4_SYSV_ABI sceAudioOutExPtOpen();
+int PS4_SYSV_ABI sceAudioOutExSystemInfoIsSupportedAudioOutExMode();
+int PS4_SYSV_ABI sceAudioOutGetFocusEnablePid();
+int PS4_SYSV_ABI sceAudioOutGetHandleStatusInfo();
+int PS4_SYSV_ABI sceAudioOutGetInfo();
+int PS4_SYSV_ABI sceAudioOutGetInfoOpenNum();
+int PS4_SYSV_ABI sceAudioOutGetLastOutputTime();
+int PS4_SYSV_ABI sceAudioOutGetPortState();
+int PS4_SYSV_ABI sceAudioOutGetSimulatedBusUsableStatusByBusType();
+int PS4_SYSV_ABI sceAudioOutGetSimulatedHandleStatusInfo();
+int PS4_SYSV_ABI sceAudioOutGetSimulatedHandleStatusInfo2();
+int PS4_SYSV_ABI sceAudioOutGetSparkVss();
+int PS4_SYSV_ABI sceAudioOutGetSystemState();
+int PS4_SYSV_ABI sceAudioOutInit();
+int PS4_SYSV_ABI sceAudioOutInitIpmiGetSession();
+int PS4_SYSV_ABI sceAudioOutMasteringGetState();
+int PS4_SYSV_ABI sceAudioOutMasteringInit();
+int PS4_SYSV_ABI sceAudioOutMasteringSetParam();
+int PS4_SYSV_ABI sceAudioOutMasteringTerm();
+int PS4_SYSV_ABI sceAudioOutMbusInit();
+int PS4_SYSV_ABI sceAudioOutOpen();
+int PS4_SYSV_ABI sceAudioOutOpenEx();
+int PS4_SYSV_ABI sceAudioOutOutput();
+int PS4_SYSV_ABI sceAudioOutOutputs();
+int PS4_SYSV_ABI sceAudioOutPtClose();
+int PS4_SYSV_ABI sceAudioOutPtGetLastOutputTime();
+int PS4_SYSV_ABI sceAudioOutPtOpen();
+int PS4_SYSV_ABI sceAudioOutSetConnections();
+int PS4_SYSV_ABI sceAudioOutSetConnectionsForUser();
+int PS4_SYSV_ABI sceAudioOutSetDevConnection();
+int PS4_SYSV_ABI sceAudioOutSetHeadphoneOutMode();
+int PS4_SYSV_ABI sceAudioOutSetJediJackVolume();
+int PS4_SYSV_ABI sceAudioOutSetJediSpkVolume();
+int PS4_SYSV_ABI sceAudioOutSetMainOutput();
+int PS4_SYSV_ABI sceAudioOutSetMixLevelPadSpk();
+int PS4_SYSV_ABI sceAudioOutSetMorpheusParam();
+int PS4_SYSV_ABI sceAudioOutSetMorpheusWorkingMode();
+int PS4_SYSV_ABI sceAudioOutSetPortConnections();
+int PS4_SYSV_ABI sceAudioOutSetPortStatuses();
+int PS4_SYSV_ABI sceAudioOutSetRecMode();
+int PS4_SYSV_ABI sceAudioOutSetSparkParam();
+int PS4_SYSV_ABI sceAudioOutSetUsbVolume();
+int PS4_SYSV_ABI sceAudioOutSetVolume();
+int PS4_SYSV_ABI sceAudioOutSetVolumeDown();
+int PS4_SYSV_ABI sceAudioOutStartAuxBroadcast();
+int PS4_SYSV_ABI sceAudioOutStartSharePlay();
+int PS4_SYSV_ABI sceAudioOutStopAuxBroadcast();
+int PS4_SYSV_ABI sceAudioOutStopSharePlay();
+int PS4_SYSV_ABI sceAudioOutSuspendResume();
+int PS4_SYSV_ABI sceAudioOutSysConfigureOutputMode();
+int PS4_SYSV_ABI sceAudioOutSysGetHdmiMonitorInfo();
+int PS4_SYSV_ABI sceAudioOutSysGetSystemInfo();
+int PS4_SYSV_ABI sceAudioOutSysHdmiMonitorInfoIsSupportedAudioOutMode();
+int PS4_SYSV_ABI sceAudioOutSystemControlGet();
+int PS4_SYSV_ABI sceAudioOutSystemControlSet();
+int PS4_SYSV_ABI sceAudioOutSparkControlSetEqCoef();
+int PS4_SYSV_ABI sceAudioOutSetSystemDebugState();
+
+void RegisterlibSceAudioOut(Core::Loader::SymbolsResolver * sym);
+}

tools/ModuleGenerator/libraries/libscecommondialog.cpp

@@ -0,0 +1,210 @@
+// SPDX-FileCopyrightText: Copyright 2024 shadPS4 Emulator Project
+// SPDX-License-Identifier: GPL-2.0-or-later
+
+// Generated By moduleGenerator
+#include "libscecommondialog.h"
+#include "common/log.h"
+#include "error_codes.h"
+
+namespace Libraries::CommonDialog{
+
+int PS4_SYSV_ABI _ZN3sce16CommonDialogUtil12getSelfAppIdEv()
+{
+	PRINT_UNIMPLEMENTED_FUNCTION_NAME();
+	return ORBIS_OK;
+}
+
+int PS4_SYSV_ABI _ZN3sce16CommonDialogUtil6Client11closeModuleEv()
+{
+	PRINT_UNIMPLEMENTED_FUNCTION_NAME();
+	return ORBIS_OK;
+}
+
+int PS4_SYSV_ABI _ZN3sce16CommonDialogUtil6Client11updateStateEv()
+{
+	PRINT_UNIMPLEMENTED_FUNCTION_NAME();
+	return ORBIS_OK;
+}
+
+int PS4_SYSV_ABI _ZN3sce16CommonDialogUtil6Client15launchCmnDialogEv()
+{
+	PRINT_UNIMPLEMENTED_FUNCTION_NAME();
+	return ORBIS_OK;
+}
+
+int PS4_SYSV_ABI _ZN3sce16CommonDialogUtil6ClientD0Ev()
+{
+	PRINT_UNIMPLEMENTED_FUNCTION_NAME();
+	return ORBIS_OK;
+}
+
+int PS4_SYSV_ABI _ZN3sce16CommonDialogUtil6ClientD1Ev()
+{
+	PRINT_UNIMPLEMENTED_FUNCTION_NAME();
+	return ORBIS_OK;
+}
+
+int PS4_SYSV_ABI _ZN3sce16CommonDialogUtil6ClientD2Ev()
+{
+	PRINT_UNIMPLEMENTED_FUNCTION_NAME();
+	return ORBIS_OK;
+}
+
+int PS4_SYSV_ABI _ZNK3sce16CommonDialogUtil6Client10isCloseReqEv()
+{
+	PRINT_UNIMPLEMENTED_FUNCTION_NAME();
+	return ORBIS_OK;
+}
+
+int PS4_SYSV_ABI _ZNK3sce16CommonDialogUtil6Client13getFinishDataEPvm()
+{
+	PRINT_UNIMPLEMENTED_FUNCTION_NAME();
+	return ORBIS_OK;
+}
+
+int PS4_SYSV_ABI _ZNK3sce16CommonDialogUtil6Client14getClientStateEv()
+{
+	PRINT_UNIMPLEMENTED_FUNCTION_NAME();
+	return ORBIS_OK;
+}
+
+int PS4_SYSV_ABI _ZNK3sce16CommonDialogUtil6Client19isInitializedStatusEv()
+{
+	PRINT_UNIMPLEMENTED_FUNCTION_NAME();
+	return ORBIS_OK;
+}
+
+int PS4_SYSV_ABI _ZNK3sce16CommonDialogUtil6Client8getAppIdEv()
+{
+	PRINT_UNIMPLEMENTED_FUNCTION_NAME();
+	return ORBIS_OK;
+}
+
+int PS4_SYSV_ABI _ZNK3sce16CommonDialogUtil6Client8isFinishEv()
+{
+	PRINT_UNIMPLEMENTED_FUNCTION_NAME();
+	return ORBIS_OK;
+}
+
+int PS4_SYSV_ABI _ZNK3sce16CommonDialogUtil6Client9getResultEv()
+{
+	PRINT_UNIMPLEMENTED_FUNCTION_NAME();
+	return ORBIS_OK;
+}
+
+int PS4_SYSV_ABI _ZTVN3sce16CommonDialogUtil6ClientE()
+{
+	PRINT_UNIMPLEMENTED_FUNCTION_NAME();
+	return ORBIS_OK;
+}
+
+int PS4_SYSV_ABI sceCommonDialogInitialize()
+{
+	PRINT_UNIMPLEMENTED_FUNCTION_NAME();
+	return ORBIS_OK;
+}
+
+int PS4_SYSV_ABI sceCommonDialogIsUsed()
+{
+	PRINT_UNIMPLEMENTED_FUNCTION_NAME();
+	return ORBIS_OK;
+}
+
+int PS4_SYSV_ABI Func_0FF577E4E8457883()
+{
+	PRINT_UNIMPLEMENTED_FUNCTION_NAME();
+	return ORBIS_OK;
+}
+
+int PS4_SYSV_ABI Func_41716C2CE379416C()
+{
+	PRINT_UNIMPLEMENTED_FUNCTION_NAME();
+	return ORBIS_OK;
+}
+
+int PS4_SYSV_ABI Func_483A427D8F6E0748()
+{
+	PRINT_UNIMPLEMENTED_FUNCTION_NAME();
+	return ORBIS_OK;
+}
+
+int PS4_SYSV_ABI Func_6944B83E02727BDF()
+{
+	PRINT_UNIMPLEMENTED_FUNCTION_NAME();
+	return ORBIS_OK;
+}
+
+int PS4_SYSV_ABI Func_69F2DD23A8B4950C()
+{
+	PRINT_UNIMPLEMENTED_FUNCTION_NAME();
+	return ORBIS_OK;
+}
+
+int PS4_SYSV_ABI Func_9954673DEAC170AD()
+{
+	PRINT_UNIMPLEMENTED_FUNCTION_NAME();
+	return ORBIS_OK;
+}
+
+int PS4_SYSV_ABI Func_A7D4D3AB86CB7455()
+{
+	PRINT_UNIMPLEMENTED_FUNCTION_NAME();
+	return ORBIS_OK;
+}
+
+int PS4_SYSV_ABI Func_ADE4C51256B8350C()
+{
+	PRINT_UNIMPLEMENTED_FUNCTION_NAME();
+	return ORBIS_OK;
+}
+
+int PS4_SYSV_ABI Func_B71349CF15FACAB0()
+{
+	PRINT_UNIMPLEMENTED_FUNCTION_NAME();
+	return ORBIS_OK;
+}
+
+int PS4_SYSV_ABI Func_CB18E00EFA946C64()
+{
+	PRINT_UNIMPLEMENTED_FUNCTION_NAME();
+	return ORBIS_OK;
+}
+
+int PS4_SYSV_ABI Func_F2AEE270605622B0()
+{
+	PRINT_UNIMPLEMENTED_FUNCTION_NAME();
+	return ORBIS_OK;
+}
+
+void RegisterlibSceCommonDialog(Core::Loader::SymbolsResolver * sym) {
+ LIB_FUNCTION("2RdicdHhtGA", "libSceCommonDialog" , 1 , "libSceCommonDialog", 1, 1 , _ZN3sce16CommonDialogUtil12getSelfAppIdEv );
+ LIB_FUNCTION("I+tdxsCap08", "libSceCommonDialog" , 1 , "libSceCommonDialog", 1, 1 , _ZN3sce16CommonDialogUtil6Client11closeModuleEv );
+ LIB_FUNCTION("v4+gzuTkv6k", "libSceCommonDialog" , 1 , "libSceCommonDialog", 1, 1 , _ZN3sce16CommonDialogUtil6Client11updateStateEv );
+ LIB_FUNCTION("CwCzG0nnLg8", "libSceCommonDialog" , 1 , "libSceCommonDialog", 1, 1 , _ZN3sce16CommonDialogUtil6Client15launchCmnDialogEv );
+ LIB_FUNCTION("Ib1SMmbr07k", "libSceCommonDialog" , 1 , "libSceCommonDialog", 1, 1 , _ZN3sce16CommonDialogUtil6ClientD0Ev );
+ LIB_FUNCTION("6TIMpGvsrC4", "libSceCommonDialog" , 1 , "libSceCommonDialog", 1, 1 , _ZN3sce16CommonDialogUtil6ClientD1Ev );
+ LIB_FUNCTION("+UyKxWAnqIU", "libSceCommonDialog" , 1 , "libSceCommonDialog", 1, 1 , _ZN3sce16CommonDialogUtil6ClientD2Ev );
+ LIB_FUNCTION("bUCx72-9f0g", "libSceCommonDialog" , 1 , "libSceCommonDialog", 1, 1 , _ZNK3sce16CommonDialogUtil6Client10isCloseReqEv );
+ LIB_FUNCTION("xZtXq554Lbg", "libSceCommonDialog" , 1 , "libSceCommonDialog", 1, 1 , _ZNK3sce16CommonDialogUtil6Client13getFinishDataEPvm );
+ LIB_FUNCTION("C-EZ3PkhibQ", "libSceCommonDialog" , 1 , "libSceCommonDialog", 1, 1 , _ZNK3sce16CommonDialogUtil6Client14getClientStateEv );
+ LIB_FUNCTION("70niEKUAnZ0", "libSceCommonDialog" , 1 , "libSceCommonDialog", 1, 1 , _ZNK3sce16CommonDialogUtil6Client19isInitializedStatusEv );
+ LIB_FUNCTION("mdJgdwoM0Mo", "libSceCommonDialog" , 1 , "libSceCommonDialog", 1, 1 , _ZNK3sce16CommonDialogUtil6Client8getAppIdEv );
+ LIB_FUNCTION("87GekE1nowg", "libSceCommonDialog" , 1 , "libSceCommonDialog", 1, 1 , _ZNK3sce16CommonDialogUtil6Client8isFinishEv );
+ LIB_FUNCTION("6ljeTSi+fjs", "libSceCommonDialog" , 1 , "libSceCommonDialog", 1, 1 , _ZNK3sce16CommonDialogUtil6Client9getResultEv );
+ LIB_FUNCTION("W2MzrWix2mM", "libSceCommonDialog" , 1 , "libSceCommonDialog", 1, 1 , _ZTVN3sce16CommonDialogUtil6ClientE );
+ LIB_FUNCTION("uoUpLGNkygk", "libSceCommonDialog" , 1 , "libSceCommonDialog", 1, 1 , sceCommonDialogInitialize );
+ LIB_FUNCTION("BQ3tey0JmQM", "libSceCommonDialog" , 1 , "libSceCommonDialog", 1, 1 , sceCommonDialogIsUsed );
+ LIB_FUNCTION("D-V35OhFeIM", "libSceCommonDialog" , 1 , "libSceCommonDialog", 1, 1 , Func_0FF577E4E8457883 );
+ LIB_FUNCTION("QXFsLON5QWw", "libSceCommonDialog" , 1 , "libSceCommonDialog", 1, 1 , Func_41716C2CE379416C );
+ LIB_FUNCTION("SDpCfY9uB0g", "libSceCommonDialog" , 1 , "libSceCommonDialog", 1, 1 , Func_483A427D8F6E0748 );
+ LIB_FUNCTION("aUS4PgJye98", "libSceCommonDialog" , 1 , "libSceCommonDialog", 1, 1 , Func_6944B83E02727BDF );
+ LIB_FUNCTION("afLdI6i0lQw", "libSceCommonDialog" , 1 , "libSceCommonDialog", 1, 1 , Func_69F2DD23A8B4950C );
+ LIB_FUNCTION("mVRnPerBcK0", "libSceCommonDialog" , 1 , "libSceCommonDialog", 1, 1 , Func_9954673DEAC170AD );
+ LIB_FUNCTION("p9TTq4bLdFU", "libSceCommonDialog" , 1 , "libSceCommonDialog", 1, 1 , Func_A7D4D3AB86CB7455 );
+ LIB_FUNCTION("reTFEla4NQw", "libSceCommonDialog" , 1 , "libSceCommonDialog", 1, 1 , Func_ADE4C51256B8350C );
+ LIB_FUNCTION("txNJzxX6yrA", "libSceCommonDialog" , 1 , "libSceCommonDialog", 1, 1 , Func_B71349CF15FACAB0 );
+ LIB_FUNCTION("yxjgDvqUbGQ", "libSceCommonDialog" , 1 , "libSceCommonDialog", 1, 1 , Func_CB18E00EFA946C64 );
+ LIB_FUNCTION("8q7icGBWIrA", "libSceCommonDialog" , 1 , "libSceCommonDialog", 1, 1 , Func_F2AEE270605622B0 );
+};
+
+}

tools/ModuleGenerator/libraries/libscecommondialog.h

@@ -0,0 +1,40 @@
+// SPDX-FileCopyrightText: Copyright 2024 shadPS4 Emulator Project
+// SPDX-License-Identifier: GPL-2.0-or-later
+
+#pragma once
+
+#include "library_common.h" 
+
+namespace Libraries::CommonDialog{
+
+int PS4_SYSV_ABI _ZN3sce16CommonDialogUtil12getSelfAppIdEv();
+int PS4_SYSV_ABI _ZN3sce16CommonDialogUtil6Client11closeModuleEv();
+int PS4_SYSV_ABI _ZN3sce16CommonDialogUtil6Client11updateStateEv();
+int PS4_SYSV_ABI _ZN3sce16CommonDialogUtil6Client15launchCmnDialogEv();
+int PS4_SYSV_ABI _ZN3sce16CommonDialogUtil6ClientD0Ev();
+int PS4_SYSV_ABI _ZN3sce16CommonDialogUtil6ClientD1Ev();
+int PS4_SYSV_ABI _ZN3sce16CommonDialogUtil6ClientD2Ev();
+int PS4_SYSV_ABI _ZNK3sce16CommonDialogUtil6Client10isCloseReqEv();
+int PS4_SYSV_ABI _ZNK3sce16CommonDialogUtil6Client13getFinishDataEPvm();
+int PS4_SYSV_ABI _ZNK3sce16CommonDialogUtil6Client14getClientStateEv();
+int PS4_SYSV_ABI _ZNK3sce16CommonDialogUtil6Client19isInitializedStatusEv();
+int PS4_SYSV_ABI _ZNK3sce16CommonDialogUtil6Client8getAppIdEv();
+int PS4_SYSV_ABI _ZNK3sce16CommonDialogUtil6Client8isFinishEv();
+int PS4_SYSV_ABI _ZNK3sce16CommonDialogUtil6Client9getResultEv();
+int PS4_SYSV_ABI _ZTVN3sce16CommonDialogUtil6ClientE();
+int PS4_SYSV_ABI sceCommonDialogInitialize();
+int PS4_SYSV_ABI sceCommonDialogIsUsed();
+int PS4_SYSV_ABI Func_0FF577E4E8457883();
+int PS4_SYSV_ABI Func_41716C2CE379416C();
+int PS4_SYSV_ABI Func_483A427D8F6E0748();
+int PS4_SYSV_ABI Func_6944B83E02727BDF();
+int PS4_SYSV_ABI Func_69F2DD23A8B4950C();
+int PS4_SYSV_ABI Func_9954673DEAC170AD();
+int PS4_SYSV_ABI Func_A7D4D3AB86CB7455();
+int PS4_SYSV_ABI Func_ADE4C51256B8350C();
+int PS4_SYSV_ABI Func_B71349CF15FACAB0();
+int PS4_SYSV_ABI Func_CB18E00EFA946C64();
+int PS4_SYSV_ABI Func_F2AEE270605622B0();
+
+void RegisterlibSceCommonDialog(Core::Loader::SymbolsResolver * sym);
+}

tools/ModuleGenerator/libraries/libscemsgdialog.cpp

@@ -0,0 +1,84 @@
+// SPDX-FileCopyrightText: Copyright 2024 shadPS4 Emulator Project
+// SPDX-License-Identifier: GPL-2.0-or-later
+
+// Generated By moduleGenerator
+#include "libscemsgdialog.h"
+#include "common/log.h"
+#include "error_codes.h"
+
+namespace Libraries::MsgDialog{
+
+int PS4_SYSV_ABI sceMsgDialogClose()
+{
+	PRINT_UNIMPLEMENTED_FUNCTION_NAME();
+	return ORBIS_OK;
+}
+
+int PS4_SYSV_ABI sceMsgDialogGetResult()
+{
+	PRINT_UNIMPLEMENTED_FUNCTION_NAME();
+	return ORBIS_OK;
+}
+
+int PS4_SYSV_ABI sceMsgDialogGetStatus()
+{
+	PRINT_UNIMPLEMENTED_FUNCTION_NAME();
+	return ORBIS_OK;
+}
+
+int PS4_SYSV_ABI sceMsgDialogInitialize()
+{
+	PRINT_UNIMPLEMENTED_FUNCTION_NAME();
+	return ORBIS_OK;
+}
+
+int PS4_SYSV_ABI sceMsgDialogOpen()
+{
+	PRINT_UNIMPLEMENTED_FUNCTION_NAME();
+	return ORBIS_OK;
+}
+
+int PS4_SYSV_ABI sceMsgDialogProgressBarInc()
+{
+	PRINT_UNIMPLEMENTED_FUNCTION_NAME();
+	return ORBIS_OK;
+}
+
+int PS4_SYSV_ABI sceMsgDialogProgressBarSetMsg()
+{
+	PRINT_UNIMPLEMENTED_FUNCTION_NAME();
+	return ORBIS_OK;
+}
+
+int PS4_SYSV_ABI sceMsgDialogProgressBarSetValue()
+{
+	PRINT_UNIMPLEMENTED_FUNCTION_NAME();
+	return ORBIS_OK;
+}
+
+int PS4_SYSV_ABI sceMsgDialogTerminate()
+{
+	PRINT_UNIMPLEMENTED_FUNCTION_NAME();
+	return ORBIS_OK;
+}
+
+int PS4_SYSV_ABI sceMsgDialogUpdateStatus()
+{
+	PRINT_UNIMPLEMENTED_FUNCTION_NAME();
+	return ORBIS_OK;
+}
+
+void RegisterlibSceMsgDialog(Core::Loader::SymbolsResolver * sym) {
+ LIB_FUNCTION("HTrcDKlFKuM", "libSceMsgDialog" , 1 , "libSceMsgDialog", 1, 1 , sceMsgDialogClose );
+ LIB_FUNCTION("Lr8ovHH9l6A", "libSceMsgDialog" , 1 , "libSceMsgDialog", 1, 1 , sceMsgDialogGetResult );
+ LIB_FUNCTION("CWVW78Qc3fI", "libSceMsgDialog" , 1 , "libSceMsgDialog", 1, 1 , sceMsgDialogGetStatus );
+ LIB_FUNCTION("lDqxaY1UbEo", "libSceMsgDialog" , 1 , "libSceMsgDialog", 1, 1 , sceMsgDialogInitialize );
+ LIB_FUNCTION("b06Hh0DPEaE", "libSceMsgDialog" , 1 , "libSceMsgDialog", 1, 1 , sceMsgDialogOpen );
+ LIB_FUNCTION("Gc5k1qcK4fs", "libSceMsgDialog" , 1 , "libSceMsgDialog", 1, 1 , sceMsgDialogProgressBarInc );
+ LIB_FUNCTION("6H-71OdrpXM", "libSceMsgDialog" , 1 , "libSceMsgDialog", 1, 1 , sceMsgDialogProgressBarSetMsg );
+ LIB_FUNCTION("wTpfglkmv34", "libSceMsgDialog" , 1 , "libSceMsgDialog", 1, 1 , sceMsgDialogProgressBarSetValue );
+ LIB_FUNCTION("ePw-kqZmelo", "libSceMsgDialog" , 1 , "libSceMsgDialog", 1, 1 , sceMsgDialogTerminate );
+ LIB_FUNCTION("6fIC3XKt2k0", "libSceMsgDialog" , 1 , "libSceMsgDialog", 1, 1 , sceMsgDialogUpdateStatus );
+};
+
+}

tools/ModuleGenerator/libraries/libscemsgdialog.h

@@ -0,0 +1,22 @@
+// SPDX-FileCopyrightText: Copyright 2024 shadPS4 Emulator Project
+// SPDX-License-Identifier: GPL-2.0-or-later
+
+#pragma once
+
+#include "library_common.h" 
+
+namespace Libraries::MsgDialog{
+
+int PS4_SYSV_ABI sceMsgDialogClose();
+int PS4_SYSV_ABI sceMsgDialogGetResult();
+int PS4_SYSV_ABI sceMsgDialogGetStatus();
+int PS4_SYSV_ABI sceMsgDialogInitialize();
+int PS4_SYSV_ABI sceMsgDialogOpen();
+int PS4_SYSV_ABI sceMsgDialogProgressBarInc();
+int PS4_SYSV_ABI sceMsgDialogProgressBarSetMsg();
+int PS4_SYSV_ABI sceMsgDialogProgressBarSetValue();
+int PS4_SYSV_ABI sceMsgDialogTerminate();
+int PS4_SYSV_ABI sceMsgDialogUpdateStatus();
+
+void RegisterlibSceMsgDialog(Core::Loader::SymbolsResolver * sym);
+}

tools/ModuleGenerator/main.cpp

@@ -167,6 +167,9 @@ int main(int argc, char* argv[]) {
     modules_to_generate.push_back(std::string("libkernel"));
     modules_to_generate.push_back(std::string("libSceSystemService"));
     modules_to_generate.push_back(std::string("libSceUserService"));
+    modules_to_generate.push_back(std::string("libSceCommonDialog"));
+    modules_to_generate.push_back(std::string("libSceMsgDialog"));
+    modules_to_generate.push_back(std::string("libSceAudioOut"));
     GetSymbolsFromLibDoc(modules_to_generate);
 
     return 0;